Enjoy this app via encrypting and decrypting text • Encrypt Text with your own password • Decrypt text (password is needed) • No Ads and Premium!


When a view's attributes change and the controller will be affected, the view sends notification to the controller. The type of notification handled by the controller is NT_VIEW_STATE_CHANGE. This notification type will carry with it a block containing a structure of type
NotifyViewStateChange
, shown in The NotifyViewStateChange Structure
.
The
NotifyViewStateChange
structure contains much more information about the view than just those features affected by the controller. Additional information includes background color, increment, document bounds, Ink information, origin, etc. If you want to add functionality to the GenViewControl, you can set up additional UI gadgetry with the
GenControlClass
attribute
ATTR_GEN_CONTROL_APP_UI
and have it change and handle the appropriate attributes.
Code Display 9-8 The NotifyViewStateChange Structure
/* This structure is passed to the GenViewControl object when a feature of the * active view changes. It is passed with notification NT_VIEW_STATE_CHANGE. */
typedef struct { PointDWFixed NVSC_origin; /* absolute origin of the view */ RectDWord NVSC_docBounds; /* document bounds of the view */ PointDWord NVSC_increment; /* the view's increment value */ PointWWFixed NVSC_scaleFactor; /* view's current scale factor */ ColorQuad NVSC_color; /* view's background color */ GenViewAttrs NVSC_attrs; /* view's GVI_attrs record */ GenViewDimensionAttrs NVSC_horizAttrs; /* view's GVI_horizAttrs record */ GenViewDimensionAttrs NVSC_vertAttrs; /* view's GVI_vertAttrs record */ GenViewInkType NVSC_inkType; /* view's GVI_inkType value */ /* The following four fields are used internally by the GenViewControl. */ XYSize NVSC_contentSize; XYSize NVSC_contentScreenSize; PointDWord NVSC_originRelative; PointDWord NVSC_documentSize; } NotifyViewStateChange;


Lorem Ipsum as their default model text, and a search for 'lorem ipsum' will uncover many web sites still
It is a long established fact that a reader will be distracted by the readable
There are many variations of passages of Lorem Ipsum available,
All the Lorem Ipsum generators on the Internet tend to repeat
Making this the first true generator on the Internet. It uses a dictionary of over 200 Latin words


Instructions
Verify whether answers to questions about pictures are accurate.
In this task, you will be shown a picture and a questions and answer. Your task is to say whether the answer is correct.
Here are the answers with questions and pictures we would like you to verify:
Verify the answer for the question about the contents of the image:
Wrong
Correct
Back
/
Next
{% include "hit_templates/simpleamt.html" %}


{% extends "common/base.html" %} {% block content %}
An email has been sent to the email address you provided.


Type: Primary/Secondary/Negative/Supplemental/Served/Customer
Name: FirstName LastName
Background
- Date of Birth:
- Gender: Male/Female
- Location: Iasi, Romania
- Work place: Organization Name, Engineer
- School: Palo Alto High School (if required)
- Technology Level:(if required)
Main Points
Some points extracted from detailed description, that are specific for this persona and the reason we chose it. For example (phrases are recommended not just simple list of points):
- Experience with certain products;
- Dislikes about certain aspects;
- Disabilities relevant to our research;
- Working environment;
- Social connections;
- The user's goals.
Goals
Goals are the reasons users perform tasks, not the tasks.
- Practical Goals:
- Personal Goals:
- Business Goals:
Frustrations and Pain Points
Some of the difficulties the user has with the product.
- UI, Interaction, User Experience;
- Dislikes relevant to the research;
- Disabilities;
- Unreliability of the product;
- Difficulties in completing tasks;
- Problems with the product: slowness, hard to use, no feedback provided;
Detailed Description
"A persona is a user archetype you can use to help guide decisions about product features, navigation, interactions, and even visual design." (Kim Goodwin, Cooper.com)
Regarding the persona type: Primary/Secondary/Negative/Supplemental/Served/Customer, these categories of personas are defined in About Face 3.0 by Alan Cooper.
A few personal details regarding relationship to the application domain in which we will use the personas, work life, social life, teamwork etc.
This section should be structured as a story.

List any prior experience that is relevant to the persona
- Experience with certain applications, products;
- Frequency of use.
References
- Fluid Personas;
- An introduction to personas and how to create them;
- The Persona Lifecycle, Keeping People in Mind Throughout Product Design, John Pruitt & Tamara Adlin;
- This version of Personas Template includes microdata markup using schema.org Schemas.
Scenarios
Develop and list a few scenarios in which your product is used (when, how and with whom it is used) by this persona. In developing these scenarios consider the Main points, Goals and Frustrations & Pain Points. Describe the scenario in a few phrases and also establish a few end points. Images could be used to describe the scenarios.
Other Details
Other details regarding this persona.


Your HTML head section should look like this.
<head> <script src="http://www.openlayers.org/api/OpenLayers.js"></script> <script src="dist/Openlayers.Layer.Buildings.js"></script> </head>
Position is set to Berlin at zoom level 17
I'm using MapBox tiles here.
var map = new OpenLayers.Map('map'); map.addControl(new OpenLayers.Control.LayerSwitcher()); var osm = new OpenLayers.Layer.OSM(); map.addLayer(osm); map.setCenter( new OpenLayers.LonLat(13.37570, 52.52020) .transform( new OpenLayers.Projection('EPSG:4326'), map.getProjectionObject() ), 17 );
Attach this to the map as well.
Here we are using a database + PHP backend which has to be hosted on the same server.
Otherwise you are running into cross origin security issues. Adapt the url parameter to your needs.
Right now, the library's backend provides sample data for cities Berlin and Frankfurt, Germany.
For your city of choice, you need to convert OSM data yourself.
map.addLayer(new OpenLayers.Layer.Buildings({ url: '../server/?w={w}&n={n}&e={e}&s={s}&z={z}' }));
As a very popular alternative, you could add GeoJSON data.
Just pass a data object to the engine, it doesn't need to be real buildings.
Ensure it's coordinates are set as lon/lat[/alt] and the properties section is set as shown below.
var osmb = new OpenLayers.Layer.Buildings(); map.addLayer(osmb); var data = { "type": "FeatureCollection", "features": [{ "type": "Feature", "geometry": { "type": "Polygon", "coordinates": [[ [13.37356, 52.52064], [13.37350, 52.51971], [13.37664, 52.51973], [13.37594, 52.52062], [13.37356, 52.52064] ]] }, "properties": { "wallColor": "rgb(255,0,0)", "height": 500 } }] }; osmb.geoJSON(data);


JUST IN: Nigeria’s GDP grows by 2.28 per cent —NBS
by Oluwakemi AbimbolaNigeria’s Gross Domestic Product has grown by 2.28 per cent in the third quarter of 2019, the National Bureau of Statistics has said.
In its quarterly report, NBS said that the figure was better than 2.12% (revised from 1.94%) in the second quarter of 2019 and the third quarter of 2018, in the year-on-year analysis.
Details later.


the and was The with were for NPRE from antiviral {background cells viral HSV- that virus DNA activity cell Vero margin extracts using {border-style px;} used #ffffff;} against herpes simplex effect have natural polyphenols MIX are concentration []. mg/mL) treatment analysis infected infection protein treated HSV compounds control pistachio proteins then cellular expression not pistachios shelled novel performed polyphenol showed (., Figure Western after binding polyphenol-rich px; reported specific their vera well {font-family (Pistacia DMSO GFP L.) activity. compared containing cytotoxic font-size found kernels obtained plaque present previously reduction resulted results significant three type NPRE. assay been concentrations could data decrease double; extracted incubated index reduced replication. such than which (data ATP Assay CA, For HSV-. However, TaqMan Therefore, [], added analysis. attachment blot border-color border-width calculated cultured described different diluted each extract further indicate infections infections. inhibition inhibitory lane mechanism mg/mL non-cytotoxic nucleoside polymerase proteins, related samples shown solid; solvent suspension this value various {font-style {font-weight (Figure (MOI) (NPRE) (mock) -well Activity Analysis Extracts PCR Staphylococcus USA). abundant according acid, activities analogues anti-HSV antibodies antimicrobial asterisks become bold courier; cytotoxicity detected due em; experiments expressed fluorescent following gene has immediately intensity interfere investigate least less maximal mean medium mg/mL). min most multiplicity new order p-values plates potential products proliferation pt;} pure real-time replication respectively. sample significance standard study tested tolerability uninfected untreated viability when °C, °C.


Welcome to “Michael Padilla’s CA”
Certificate Authority Web Site
Hello...
You can get a certificate of your very own! The Michael Padilla’s CA certificate authority (CA) is here at your service.
This certificate authority web site is administered by<EMAIL_ADDRESS>Created on 05.09.19.
Click here to download an invitation
Click here to download the CA certificates
SHA1 fingerprint of this CA certificate is:
79 D9 25 C0 D9 97 9E B6 2F 26 3D AD 18 D8 E3 F0 B2 68 E1 3F


Here you can input information about a new event your student organization is hosting and then generate a check-in code for your event.


--- layout: post permalink: petsupplies.html Tags: Array NameOfCoupon: Pet Supplies Cash Back Summary: See our Pet Supplies Coupon Code, Pet Supplies Rebate, Pet Supplies Promo Code, Pet Supplies Discount, Pet Supplies Coupon Cash Back Rebate here.  We have the best Pet Supplies Rebate anywhere. thesis_keywords: Pet Supplies, Pet Supplies Coupon Code, Pet Supplies Discount, Pet Supplies Rebate product_name: Pet Supplies hop_url: http://www.icouponblog.com/hop.php?id=2458 ---
If you have a cat or a dog and want them to be healthy, happy and well nurtured and you want to find all quality products in one place, visit www.cherrybrook.com online today. You can get premium supplies for your pets at a very affordable price. You will find everything you need from food, toys, treats to collars to dog grooming products like shampoos and conditioners and so much more. Take great care of your pets with the best products from cherrybrook.com. Use our discount coupons to get a great price.
Cherrybrook is one of the best suppliers of pet supplies and products. You can get dog or cat jewelry, ornaments, food, grooming products and so much more. Get the best products that are healthy for your pets and chemical free. You can also get DVDs and books on how to take care of your pets and how to groom them. cherrybrook.com is a very useful site. You can buy quality products for your pets. It carries everything that you will ever need. You will love the products and the prices and our discount coupons the best! Check it out today.
Visit cherrybrook.com and you will love all the wonderful products you will see for your adorable pets. Their website is user friendly and very easy to navigate. You can find everything you need for your pets. There are even items for pet lovers which you might want to gift to someone who loves pets. Don’t settle for less, when you can have the best with cherrybrook.com. Check it out today.


Become “Second to None” Computer user by applying your awareness,creativity and skills in using a Computer effectively.
Round 1: Pen-paper based Elimination Round
Participants will be given a set of questions which will check their knowledge of Moderate Level Computer Skills and Awareness.
Qualification for the next round will be based on ranking or cutoff marks.
Time Duration: 45 Minutes
Round 2: Tasks on Windows and Linux OS (Using Computer)
Participants will be given various tasks which they need to perform on Windows and Linux Operating Systems using GUI or Terminal. There will be a time limit for completion of each task and points will be given according to completeness of each task and the best way used for completion of the same.
Time Duration: 90-120 Minutes
Round 3: Clues Based Round (Using Computer)
Participants have to a complete a task after completion of which they will get a clue to be used for their next task. The clue will be available from either the previous task itself or the participants will be asked a question whose answer will be their clue. The points for each task will be based on the time taken to complete the task and its correct completion.
Time Duration: 120-150 Minutes
Rules:
1. Final result will be based on total points scored and time taken by the participants.
2. Internet access will be restricted for some tasks.
3. There will be a tie breaker round after the last round if two teams have same score.
1
7th March 2017
9:00 to 11:00 AM
CE Lab 2 and (3 or 4 having Windows)
Rs. 30
Sanket Bhimani (M:<PHONE_NUMBER>0, Email<EMAIL_ADDRESS>Juhi Madhwani (M:<PHONE_NUMBER>, Email: juhimadhwani1296@gmail.com)


Work better
-
Organize your requests in folders.
-
Very clean and fast.
-
Setup easily
-
Share your requests


| MATLAB 文件帮助: cv.ANN_MLP/LayerSizes | 查看 cv.ANN_MLP/LayerSizes 的代码 | Index |
Integer vector specifying the number of neurons in each layer including the input and output layers of the MLP.
The very first element specifies the number of elements in the input
layer (feature dimensions). The last element is the number of
elements in the output layer (regression dimensions). For example,
[N,1]
means two-layer network that takes an N-dimensional vector
as an input and output scalar. default empty (which means it must be
manually set before training).
| Constant | false |
| Dependent | true |
| Sealed | false |
| Transient | false |
| GetAccess | public |
| SetAccess | public |
| GetObservable | false |
| SetObservable | false |


Ocean [ag45], ocean, in Crystal Sea
Last updated Turn #74
Ocean [ag45], ocean, in Crystal Sea
------------------------------------------------------------------------
21: Fast Sail [ht2u], ship, 3 hulls, 1 rowing port, 9 sails, arrived from
21: Ocean [ag46], owner:
21: Stewart [k0u], Pen, with 12 sailors
22: Fast Sail [ht2u], ship, 3 hulls, 1 rowing port, 9 sails, departed for
22: Ocean [ag44].
Routes leaving Ocean:
North, to Ocean [af45], 6 days
East, to Ocean [ag46], 6 days
South, to Ocean [ah45], 6 days
West, to Ocean [ag44], 6 days


Ben Bolker has an excellent post on this complex issue over at Dynamic Ecology, which got me thinking about writing my own thoughts on the topic in reply.
Google recently announced that it will be making it’s own self-driving cars, rather than modifying those of others. Cars that won’t have steering wheels and pedals. Just a button that says “stop.” What does this tell us about the future of user-friendly complex statistical software?
Ben quotes prominent statisticians voicing fears that echo common concerns about self-driving cars:
Andrew Gelman attributes to Brad Efron the idea that “recommending that scientists use Bayes’ theorem is like giving the neighbourhood kids the key to your F-16″.
I think it is particularly interesting and instructive that the quote Gelman attributes to Efron is about a mathematical theorem rather than about software (e.g. Bayes Theorem, not WinBUGS). Even relatively simple statistical concepts like \(p\) values can cause plenty of confusion, statistical package or no. The concerns are not unique to software, so the solutions cannot come through limiting access to software.
I am very wary of the suggestion that we should address concerns of appropriate application by raising barriers to access. Those arguments have been made about knowledge of all forms, from access to publications, to raw data, to things as basic as education and democratic voting.
There are many good reasons for not creating a statistical software implementation of a new method, but I argue here that fear of misuse just is not one of them.
- The barriers created by not having a convenient software implementation are not an appropriate filter to keep out people who can miss-interpret or miss-use the software. As you know, a fundamentally different skillset is required to program a published algorithm (say, MCMC), than to correctly interpret the statistical consequences.
We must be wary of a different kind of statistical machismo, in which we use the ability to implement a method by one’s self as a proxy for interpreting it correctly.
1a) One immediate corollary of (1) is that: Like it or not, someone is going to build a method that is “easy to use”, e.g. remove the programming barriers.
1b) The second corollary is that: individuals with excellent understanding of the proper interpretation / statistics will frequently make mistakes in the computational implementation.
Both mistakes will happen. And both are much more formidable problems in the complex methodology of today than when computer was a job description.
So, what do we do? I think we should abandon the false dichotomy between “usability” and “correctness.”. Just because software that is easy to use is easy to misuse, does not imply that decreasing usability increases correctness. I think that is a dangerous fallacy.
A software implementation should aim first to remove the programming barriers rather than statistical knowledge barriers. Best practices such as modularity and documentation should make it easy for users and developers to understand and build upon it. I agree with Ben that software error messages are poor teachers. I agree that a tool cannot be foolproof, no tool ever has been.
Someone does not misuse a piece of software merely because they do not understand it. Misuse comes from mistakenly thinking you understand it. The premise that most researchers will use something they do not understand just because it is easy to use is distasteful.
Kevin Slavin gives a fantastic Ted talk on the ubiquitous role of algorithms in today’s world. His conclusion is neither one of panacea or doom, but rather that we seek to understand and characterize them, learn their strengths and weaknesses like a naturalist studies a new species.
More widespread adoption of software such as BUGS & relatives has indeed increased the amount of misuse and false conclusions. But it has also dramatically increased awareness of issues ranging from computational aspects peculiar to particular implementations to general understanding and discourse about Bayesian methods. Like Kevin, I don’t think we can escape the algorithms, but I do think we can learn to understand and live with them.


Task Menu Extension Example
The Task Menu Extension example shows how to create a custom widget plugin for Qt Designer, and how to to use the QDesignerTaskMenuExtension class to provide custom task menu entries associated with the plugin.
To provide a custom widget that can be used with Qt Designer, we need to supply a self-contained implementation. In this example we use a custom widget designed to show the task menu extension feature: The TicTacToe widget.
An extension is an object which modifies the behavior of Qt Designer. The QDesignerTaskMenuExtension can provide custom task menu entries when a widget with this extension is selected.
There are four available types of extensions in Qt Designer:
- QDesignerContainerExtension provides an extension that allows you to add (and delete) pages to a multi-page container plugin in Qt Designer.
- QDesignerMemberSheetExtension provides an extension that allows you to manipulate a widget's member functions which is displayed when configuring connections using Qt Designer's mode for editing signals and slots.
- QDesignerPropertySheetExtension provides an extension that allows you to manipulate a widget's properties which is displayed in Qt Designer's property editor.
- QDesignerTaskMenuExtension provides an extension that allows you to add custom menu entries to Qt Designer's task menu.
You can use all the extensions following the same pattern as in this example, only replacing the respective extension base class. For more information, see the Qt Designer C++ Classes.
The Task Menu Extension example consists of five classes:
TicTacToe
is a custom widget that lets the user play the Tic-Tac-Toe game.TicTacToePlugin
exposes theTicTacToe
class to Qt Designer.TicTacToeTaskMenuFactory
creates aTicTacToeTaskMenu
object.TicTacToeTaskMenu
provides the task menu extension, i.e the plugin's associated task menu entries.TicTacToeDialog
lets the user modify the state of a Tic-Tac-Toe plugin loaded into Qt Designer.
The project file for custom widget plugins needs some additional information to ensure that they will work within Qt Designer. For example, custom widget plugins rely on components supplied with Qt Designer, and this must be specified in the project file that we use. We will first take a look at the plugin's project file.
Then we will continue by reviewing the TicTacToePlugin
class, and take a look at the TicTacToeTaskMenuFactory
and TicTacToeTaskMenu
classes. Finally, we will review the TicTacToeDialog
class before we take a quick look at the TicTacToe
widget's class definition.
The Project File: taskmenuextension.pro
The project file must contain some additional information to ensure that the plugin will work as expected:
QT += widgets designer TEMPLATE = lib CONFIG += plugin
The TEMPLATE
variable's value makes qmake
create the custom widget as a library. Later, we will ensure that the widget will be recognized as a plugin by Qt by using the Q_PLUGIN_METADATA() macro to export the relevant widget information.
The CONFIG
variable is set to plugin
, which ensures that qmake
considers the custom widget a plugin library.
The QT
variable contains the value designer
. Since the plugin uses components supplied with Qt Designer that require linkage, this value ensures that our plugin links against Qt Designer's library (libQtDesigner.so
).
The header and source files for the widget are declared in the usual way:
HEADERS += tictactoe.h \ tictactoedialog.h \ tictactoeplugin.h \ tictactoetaskmenu.h SOURCES += tictactoe.cpp \ tictactoedialog.cpp \ tictactoeplugin.cpp \ tictactoetaskmenu.cpp OTHER_FILES += tictactoe.json
We provide an implementation of the plugin interface so that Qt Designer can use the custom widget. In this particular example we also provide implementations of the task menu extension and the extension factory as well as a dialog implementation.
It is important to ensure that the plugin is installed in a location that is searched by Qt Designer. We do this by specifying a target path for the project and adding it to the list of items to install:
target.path = $$[QT_INSTALL_PLUGINS]/designer INSTALLS += target
The task menu extension is created as a library, and will be installed alongside the other Qt Designer plugins when the project is installed (using make install
or an equivalent installation procedure).
Note that if you want the plugins to appear in a Visual Studio integration, the plugins must be built in release mode and their libraries must be copied into the plugin directory in the install path of the integration (for an example, see C:/program files/trolltech as/visual studio integration/plugins
).
For more information about plugins, see the How to Create Qt Plugins documentation.
TicTacToePlugin Class Definition
The TicTacToePlugin
class exposes the
TicTacToe class to Qt Designer. Its definition is equivalent to the Custom Widget Plugin example's plugin class which is explained in detail. The only part of the class definition that is specific to this particular custom widget is the class name:
#ifndef TICTACTOEPLUGIN_H #define TICTACTOEPLUGIN_H #include <QtUiPlugin/QDesignerCustomWidgetInterface> class QIcon; class QWidget; class TicTacToePlugin : public QObject, public QDesignerCustomWidgetInterface { Q_OBJECT Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QDesignerCustomWidgetInterface") Q_INTERFACES(QDesignerCustomWidgetInterface) public: TicTacToePlugin(QObject *parent = 0); QString name() const override; QString group() const override; QString toolTip() const override; QString whatsThis() const override; QString includeFile() const override; QIcon icon() const override; bool isContainer() const override; QWidget *createWidget(QWidget *parent) override; bool isInitialized() const override; void initialize(QDesignerFormEditorInterface *formEditor) override; QString domXml() const override; private: bool initialized; }; #endif
The plugin class provides Qt Designer with basic information about our plugin, such as its class name and its include file. Furthermore it knows how to create instances of the TicTacToe
widget. TicTacToePlugin also defines the initialize() function which is called after the plugin is loaded into Qt Designer. The function's QDesignerFormEditorInterface parameter provides the plugin with a gateway to all of Qt Designer's API's.
The TicTacToePlugin
class inherits from both QObject and QDesignerCustomWidgetInterface. It is important to remember, when using multiple inheritance, to ensure that all the interfaces (i.e. the classes that doesn't inherit Q_OBJECT) are made known to the meta object system using the Q_INTERFACES() macro.
TicTacToePlugin Class Implementation
The TicTacToePlugin class implementation is in most parts equivalent to the Custom Widget Plugin example's plugin class:
TicTacToePlugin::TicTacToePlugin(QObject *parent) : QObject(parent) , initialized(false) { } QString TicTacToePlugin::name() const { return "TicTacToe"; } QString TicTacToePlugin::group() const { return "Display Widgets [Examples]"; } QString TicTacToePlugin::toolTip() const { return ""; } QString TicTacToePlugin::whatsThis() const { return ""; } QString TicTacToePlugin::includeFile() const { return "tictactoe.h"; } QIcon TicTacToePlugin::icon() const { return QIcon(); } bool TicTacToePlugin::isContainer() const { return false; } QWidget *TicTacToePlugin::createWidget(QWidget *parent) { TicTacToe *ticTacToe = new TicTacToe(parent); ticTacToe->setState("-X-XO----"); return ticTacToe; } bool TicTacToePlugin::isInitialized() const { return initialized; }
The only function that differs significantly is the initialize() function:
void TicTacToePlugin::initialize(QDesignerFormEditorInterface *formEditor) {
The initialize()
function takes a QDesignerFormEditorInterface object as argument. The QDesignerFormEditorInterface class provides access to Qt Designer's components.
In Qt Designer you can create two kinds of plugins: custom widget plugins and tool plugins. QDesignerFormEditorInterface provides access to all the Qt Designer components that you normally need to create a tool plugin: the extension manager, the object inspector, the property editor and the widget box. Custom widget plugins have access to the same components.
if (initialized) return; QExtensionManager *manager = formEditor->extensionManager(); Q_ASSERT(manager != 0);
When creating extensions associated with custom widget plugins, we need to access Qt Designer's current extension manager which we retrieve from the QDesignerFormEditorInterface parameter.
Qt Designer's QDesignerFormEditorInterface holds information about all Qt Designer's components: The action editor, the object inspector, the property editor, the widget box, and the extension and form window managers.
The QExtensionManager class provides extension management facilities for Qt Designer. Using Qt Designer's current extension manager you can retrieve the extension for a given object. You can also register and unregister an extension for a given object. Remember that an extension is an object which modifies the behavior of Qt Designer.
When registrering an extension, it is actually the associated extension factory that is registered. In Qt Designer, extension factories are used to look up and create named extensions as they are required. So, in this example, the task menu extension itself is not created until a task menu is requested by the user.
manager->registerExtensions(new TicTacToeTaskMenuFactory(manager), Q_TYPEID(QDesignerTaskMenuExtension)); initialized = true; } QString TicTacToePlugin::domXml() const { return QLatin1String("\ <ui language=\"c++\">\ <widget class=\"TicTacToe\" name=\"ticTacToe\"/>\ <customwidgets>\ <customwidget>\ <class>TicTacToe</class>\ <propertyspecifications>\ <tooltip name=\"state\">Tic Tac Toe state</tooltip>\ <stringpropertyspecification name=\"state\" notr=\"true\" type=\"singleline\"/>\ </propertyspecifications>\ </customwidget>\ </customwidgets>\ </ui>"); }
We create a TicTacToeTaskMenuFactory
object that we register using Qt Designer's current extension manager retrieved from the QDesignerFormEditorInterface parameter. The first argument is the newly created factory and the second argument is an extension identifier which is a string. The Q_TYPEID()
macro simply converts the string into a QLatin1String.
The TicTacToeTaskMenuFactory
class is a subclass of QExtensionFactory. When the user request a task menu by clicking the right mouse button over a widget with the specified task menu extension, Qt Designer's extension manager will run through all its registered factories invoking the first one that is able to create a task menu extension for the selected widget. This factory will in turn create a TicTacToeTaskMenu
object (the extension).
We omit to reimplement the QDesignerCustomWidgetInterface::domXml() function (which include default settings for the widget in the standard XML format used by Qt Designer), since no default values are necessary.
Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QDesignerCustomWidgetInterface")
Finally, we use the Q_PLUGIN_METADATA() macro to export the TicTacToePlugin class for use with Qt's plugin handling classes: This macro ensures that Qt Designer can access and construct the custom widget. Without this macro, there is no way for Qt Designer to use the widget.
TicTacToeTaskMenuFactory Class Definition
The TicTacToeTaskMenuFactory
class inherits QExtensionFactory which provides a standard extension factory for Qt Designer.
class TicTacToeTaskMenuFactory : public QExtensionFactory { Q_OBJECT public: explicit TicTacToeTaskMenuFactory(QExtensionManager *parent = 0); protected: QObject *createExtension(QObject *object, const QString &iid, QObject *parent) const override; };
The subclass's purpose is to reimplement the QExtensionFactory::createExtension() function, making it able to create a TicTacToe
task menu extension.
TicTacToeTaskMenuFactory Class Implementation
The class constructor simply calls the QExtensionFactory base class constructor:
TicTacToeTaskMenuFactory::TicTacToeTaskMenuFactory(QExtensionManager *parent) : QExtensionFactory(parent) { }
As described above, the factory is invoked when the user request a task menu by clicking the right mouse button over a widget with the specified task menu extension in Qt Designer.
Qt Designer's behavior is the same whether the requested extension is associated with a container, a member sheet, a property sheet or a task menu: Its extension manager runs through all its registered extension factories calling createExtension()
for each until one responds by creating the requested extension.
QObject *TicTacToeTaskMenuFactory::createExtension(QObject *object, const QString &iid, QObject *parent) const { if (iid != Q_TYPEID(QDesignerTaskMenuExtension)) return 0; if (TicTacToe *tic = qobject_cast<TicTacToe*>(object)) return new TicTacToeTaskMenu(tic, parent); return 0; }
So the first thing we do in TicTacToeTaskMenuFactory::createExtension()
is to check if the requested extension is a task menu extension. If it is, and the widget requesting it is a TicTacToe
widget, we create and return a TicTacToeTaskMenu
object. Otherwise, we simply return a null pointer, allowing Qt Designer's extension manager to continue its search through the registered factories.
TicTacToeTaskMenu Class Definition
The TicTacToeTaskMenu
class inherits QDesignerTaskMenuExtension which allows you to add custom entries (in the form of QActions) to the task menu in Qt Designer.
class TicTacToeTaskMenu : public QObject, public QDesignerTaskMenuExtension { Q_OBJECT Q_INTERFACES(QDesignerTaskMenuExtension) public: explicit TicTacToeTaskMenu(TicTacToe *tic, QObject *parent); QAction *preferredEditAction() const override; QList<QAction *> taskActions() const override; private slots: void editState(); private: QAction *editStateAction; TicTacToe *ticTacToe; };
We reimplement the preferredEditAction()
and taskActions()
functions. Note that we implement a constructor that takes two arguments: the parent widget, and the TicTacToe
widget for which the task menu is requested.
In addition we declare the private editState()
slot, our custom editStateAction
and a private pointer to the TicTacToe
widget which state we want to modify.
TicTacToeTaskMenu Class Implementation
TicTacToeTaskMenu::TicTacToeTaskMenu(TicTacToe *tic, QObject *parent) : QObject(parent) , editStateAction(new QAction(tr("Edit State..."), this)) , ticTacToe(tic) { connect(editStateAction, &QAction::triggered, this, &TicTacToeTaskMenu::editState); }
In the constructor we first save the reference to the TicTacToe
widget sent as parameter, i.e the widget which state we want to modify. We will need this later when our custom action is invoked. We also create our custom editStateAction
and connect it to the editState()
slot.
void TicTacToeTaskMenu::editState() { TicTacToeDialog dialog(ticTacToe); dialog.exec(); }
The editState()
slot is called whenever the user chooses the Edit State... option in a TicTacToe
widget's task menu. The slot creates a TicTacToeDialog
presenting the current state of the widget, and allowing the user to edit its state by playing the game.
QAction *TicTacToeTaskMenu::preferredEditAction() const { return editStateAction; }
We reimplement the preferredEditAction()
function to return our custom editStateAction
as the action that should be invoked when selecting a TicTacToe
widget and pressing F2 .
QList<QAction *> TicTacToeTaskMenu::taskActions() const { QList<QAction *> list; list.append(editStateAction); return list; }
We reimplement the taskActions()
function to return a list of our custom actions making these appear on top of the default menu entries in a TicTacToe
widget's task menu.
TicTacToeDialog Class Definition
The TicTacToeDialog
class inherits QDialog. The dialog lets the user modify the state of the currently selected Tic-Tac-Toe plugin.
class TicTacToeDialog : public QDialog { Q_OBJECT public: explicit TicTacToeDialog(TicTacToe *plugin = 0, QWidget *parent = 0); QSize sizeHint() const override; private slots: void resetState(); void saveState(); private: TicTacToe *editor; TicTacToe *ticTacToe; QDialogButtonBox *buttonBox; };
We reimplement the sizeHint()
function. We also declare two private slots: resetState()
and saveState()
. In addition to the dialog's buttons and layouts we declare two TicTacToe
pointers, one to the widget the user can interact with and the other to the original custom widget plugin which state the user wants to edit.
TicTacToeDialog Class Implementation
TicTacToeDialog::TicTacToeDialog(TicTacToe *tic, QWidget *parent) : QDialog(parent) , editor(new TicTacToe) , ticTacToe(tic) , buttonBox(new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel | QDialogButtonBox::Reset)) { editor->setState(ticTacToe->state()); connect(buttonBox->button(QDialogButtonBox::Reset), &QAbstractButton::clicked, this, &TicTacToeDialog::resetState); connect(buttonBox, &QDialogButtonBox::accepted, this, &TicTacToeDialog::saveState); connect(buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject); QVBoxLayout *mainLayout = new QVBoxLayout; mainLayout->addWidget(editor); mainLayout->addWidget(buttonBox); setLayout(mainLayout); setWindowTitle(tr("Edit State")); }
In the constructor we first save the reference to the TicTacToe widget sent as parameter, i.e the widget which state the user want to modify. Then we create a new TicTacToe
widget, and set its state to be equivalent to the parameter widget's state.
Finally, we create the dialog's buttons and layout.
QSize TicTacToeDialog::sizeHint() const { return QSize(250, 250); }
We reimplement the sizeHint()
function to ensure that the dialog is given a reasonable size.
void TicTacToeDialog::resetState() { editor->clearBoard(); }
The resetState()
slot is called whenever the user press the Reset button. The only thing we do is to call the clearBoard()
function for the editor widget, i.e. the TicTacToe
widget we created in the dialog's constructor.
void TicTacToeDialog::saveState() {
The saveState()
slot is called whenever the user press the OK button, and transfers the state of the editor widget to the widget which state we want to modify. In order to make the change of state visible to Qt Designer we need to set the latter widget's state property using the QDesignerFormWindowInterface class.
QDesignerFormWindowInterface provides you with information about the associated form window as well as allowing you to alter its properties. The interface is not intended to be instantiated directly, but to provide access to Qt Designer's current form windows controlled by Qt Designer's form window manager.
If you are looking for the form window containing a specific widget, you can use the static QDesignerFormWindowInterface::findFormWindow() function:
if (QDesignerFormWindowInterface *formWindow = QDesignerFormWindowInterface::findFormWindow(ticTacToe)) { formWindow->cursor()->setProperty("state", editor->state()); }
After retrieving the form window of the widget (which state we want to modify), we use the QDesignerFormWindowInterface::cursor() function to retrieve the form window's cursor.
The QDesignerFormWindowCursorInterface class provides an interface to the form window's text cursor. Once we have cursor, we can finally set the state property using the QDesignerFormWindowCursorInterface::setProperty() function.
accept(); }
In the end we call the QEvent::accept() function which sets the accept flag of the event object. Setting the accept
parameter indicates that the event receiver wants the event. Unwanted events might be propagated to the parent widget.
TicTacToe Class Definition
The TicTacToe
class is a custom widget that lets the user play the Tic-Tac-Toe game.
class TicTacToe : public QWidget { Q_OBJECT Q_PROPERTY(QString state READ state WRITE setState) public: explicit TicTacToe(QWidget *parent = 0); QSize minimumSizeHint() const override; QSize sizeHint() const override; void setState(const QString &newState); QString state() const; void clearBoard(); protected: void mousePressEvent(QMouseEvent *event) override; void paintEvent(QPaintEvent *event) override; private: enum { Empty = '-', Cross = 'X', Nought = 'O' }; QRect cellRect(int row, int col) const; int cellWidth() const { return width() / 3; } int cellHeight() const { return height() / 3; } QString myState; int turnNumber; };
The main details to observe in the TicTacToe
class defintion is the declaration of the state
property and its state()
and setState()
functions.
We need to declare the TicTacToe
widget's state as a property to make it visible to Qt Designer; allowing Qt Designer to manage it in the same way it manages the properties the TicTacToe
widget inherits from QWidget and QObject, for example featuring the property editor.
Files:
- taskmenuextension/tictactoe.cpp
- taskmenuextension/tictactoe.h
- taskmenuextension/tictactoedialog.cpp
- taskmenuextension/tictactoedialog.h
- taskmenuextension/tictactoeplugin.cpp
- taskmenuextension/tictactoeplugin.h
- taskmenuextension/tictactoetaskmenu.cpp
- taskmenuextension/tictactoetaskmenu.h
- taskmenuextension/taskmenuextension.pro


| Top |
This is the subclass of GSocketConnection that is created for UNIX domain sockets.
It contains functions to do some of the UNIX socket specific functionality like passing file descriptors.
Note that <gio/gunixconnection.h>
belongs to the UNIX-specific
GIO interfaces, thus you have to use the gio-unix-2.0.pc
pkg-config file when using it.
gint g_unix_connection_receive_fd (GUnixConnection *connection
,GCancellable *cancellable
,GError **error
);
Receives a file descriptor from the sending end of the connection.
The sending end has to call g_unix_connection_send_fd()
for this
to work.
As well as reading the fd this also reads a single byte from the stream, as this is required for fd passing to work on some implementations.
connection |
||
cancellable |
optional GCancellable object, |
[allow-none] |
error |
[allow-none] |
Since 2.22
gboolean g_unix_connection_send_fd (GUnixConnection *connection
,gint fd
,GCancellable *cancellable
,GError **error
);
Passes a file descriptor to the receiving side of the
connection. The receiving end has to call g_unix_connection_receive_fd()
to accept the file descriptor.
As well as sending the fd this also writes a single byte to the stream, as this is required for fd passing to work on some implementations.
connection |
||
fd |
a file descriptor |
|
cancellable |
optional GCancellable object, |
[allow-none] |
error |
[allow-none] |
Since 2.22
GCredentials * g_unix_connection_receive_credentials (GUnixConnection *connection
,GCancellable *cancellable
,GError **error
);
Receives credentials from the sending end of the connection. The
sending end has to call g_unix_connection_send_credentials()
(or
similar) for this to work.
As well as reading the credentials this also reads (and discards) a single byte from the stream, as this is required for credentials passing to work on some implementations.
Other ways to exchange credentials with a foreign peer includes the
GUnixCredentialsMessage type and g_socket_get_credentials()
function.
connection |
||
cancellable |
A GCancellable or |
[allow-none] |
error |
Return location for error or |
Received credentials on success (free with
g_object_unref()
), NULL
if error
is set.
[transfer full]
Since 2.26
void g_unix_connection_receive_credentials_async (GUnixConnection *connection
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
);
Asynchronously receive credentials.
For more details, see g_unix_connection_receive_credentials()
which is
the synchronous version of this call.
When the operation is finished, callback
will be called. You can then call
g_unix_connection_receive_credentials_finish()
to get the result of the operation.
connection |
||
cancellable |
optional GCancellable object, |
[allow-none] |
callback |
a GAsyncReadyCallback to call when the request is satisfied. |
[scope async] |
user_data |
the data to pass to callback function. |
[closure] |
Since 2.32
GCredentials * g_unix_connection_receive_credentials_finish (GUnixConnection *connection
,GAsyncResult *result
,GError **error
);
Finishes an asynchronous receive credentials operation started with
g_unix_connection_receive_credentials_async()
.
a GCredentials, or NULL
on error.
Free the returned object with g_object_unref()
.
[transfer full]
Since 2.32
gboolean g_unix_connection_send_credentials (GUnixConnection *connection
,GCancellable *cancellable
,GError **error
);
Passes the credentials of the current user the receiving side
of the connection. The receiving end has to call
g_unix_connection_receive_credentials()
(or similar) to accept the
credentials.
As well as sending the credentials this also writes a single NUL byte to the stream, as this is required for credentials passing to work on some implementations.
Other ways to exchange credentials with a foreign peer includes the
GUnixCredentialsMessage type and g_socket_get_credentials()
function.
connection |
||
cancellable |
A GCancellable or |
[allow-none] |
error |
Return location for error or |
Since 2.26
void g_unix_connection_send_credentials_async (GUnixConnection *connection
,GCancellable *cancellable
,GAsyncReadyCallback callback
,gpointer user_data
);
Asynchronously send credentials.
For more details, see g_unix_connection_send_credentials()
which is
the synchronous version of this call.
When the operation is finished, callback
will be called. You can then call
g_unix_connection_send_credentials_finish()
to get the result of the operation.
connection |
||
cancellable |
optional GCancellable object, |
[allow-none] |
callback |
a GAsyncReadyCallback to call when the request is satisfied. |
[scope async] |
user_data |
the data to pass to callback function. |
[closure] |
Since 2.32
gboolean g_unix_connection_send_credentials_finish (GUnixConnection *connection
,GAsyncResult *result
,GError **error
);
Finishes an asynchronous send credentials operation started with
g_unix_connection_send_credentials_async()
.
Since 2.32


Whole New Experience to remotely operate your DSLR camera
An experience designed to improve mental health of Millennials & Gen Z
Improving usability using Heuristic Evaluation of an e-commerce app based on C2C market
A mobile app experience design to solve the problems faced by college students to buy sell & swap books
Filmmaking
Filmmaking
Filmmaking
Illustration
Illustration
Illustration
Illustration
Illustration
Illustration
Illustration
Logo - Branding Work
Logo - Branding Work


An Application That Uses the JMS API with a Session Bean
This section explains how to write, compile, package, deploy, and run an application that uses the JMS API in conjunction with a session bean. The application contains the following components:
An application client that invokes a session bean
A session bean that publishes several messages to a topic
A message-driven bean that receives and processes the messages using a durable topic subscriber and a message selector
You will find the source files for this section in the tut-install/examples/jms/clientsessionmdb/ directory. Path names in this section are relative to this directory.
Writing the Application Components for the clientsessionmdb Example
This application demonstrates how to send messages from an enterprise bean (in this case, a session bean) rather than from an application client, as in the example in Chapter 25, A Message-Driven Bean Example. Figure 48-3 illustrates the structure of this application.
The Publisher enterprise bean in this example is the enterprise-application equivalent of a wire-service news feed that categorizes news events into six news categories. The message-driven bean could represent a newsroom, where the sports desk, for example, would set up a subscription for all news events pertaining to sports.
The application client in the example injects the Publisher enterprise bean’s remote home interface and then calls the bean’s business method. The enterprise bean creates 18 text messages. For each message, it sets a String property randomly to one of six values representing the news categories and then publishes the message to a topic. The message-driven bean uses a message selector for the property to limit which of the published messages it receives.
Coding the Application Client: MyAppClient.java
The application client, clientsessionmdb-app-client/src/java/MyAppClient.java, performs no JMS API operations and so is simpler than the client in Chapter 25, A Message-Driven Bean Example. The client uses dependency injection to obtain the Publisher enterprise bean’s business interface:
@EJB(name="PublisherRemote") static private PublisherRemote publisher;
The client then calls the bean’s business method twice.
Coding the Publisher Session Bean
The Publisher bean is a stateless session bean that has one business method. The Publisher bean uses a remote interface rather than a local interface because it is accessed from the application client.
The remote interface, clientsessionmdb-ejb/src/java/sb/PublisherRemote.java, declares a single business method, publishNews.
The bean class, clientsessionmdb-ejb/src/java/sb/PublisherBean.java, implements the publishNews method and its helper method chooseType. The bean class also injects SessionContext, ConnectionFactory, and Topic resources and implements @PostConstruct and @PreDestroy callback methods. The bean class begins as follows:
@Stateless @Remote({PublisherRemote.class}) public class PublisherBean implements PublisherRemote { @Resource private SessionContext sc; @Resource(lookup = "jms/ConnectionFactory") private ConnectionFactory connectionFactory; @Resource(lookup = "jms/Topic") private Topic topic; ...
The @PostConstruct callback method of the bean class, makeConnection, creates the Connection used by the bean. The business method publishNews creates a Session and a MessageProducer and publishes the messages.
The @PreDestroy callback method, endConnection, deallocates the resources that were allocated by the @PostConstruct callback method. In this case, the method closes the Connection.
Coding the Message-Driven Bean: MessageBean.java
The message-driven bean class, clientsessionmdb-ejb/src/java/mdb/MessageBean.java, is almost identical to the one in Chapter 25, A Message-Driven Bean Example. However, the @MessageDriven annotation is different, because instead of a queue the bean is using a topic with a durable subscription, and it is also using a message selector. Therefore, the annotation sets the activation config properties messageSelector, subscriptionDurability, clientId, and subscriptionName, as follows:
@MessageDriven(mappedName = "jms/Topic", activationConfig = { @ActivationConfigProperty(propertyName = "messageSelector", propertyValue = "NewsType = 'Sports' OR NewsType = 'Opinion'") , @ActivationConfigProperty(propertyName = "subscriptionDurability", propertyValue = "Durable") , @ActivationConfigProperty(propertyName = "clientId", propertyValue = "MyID") , @ActivationConfigProperty(propertyName = "subscriptionName", propertyValue = "MySub") })
Note - For a message-driven bean, the destination is specified with the mappedName element instead of the lookup element.
The JMS resource adapter uses these properties to create a connection factory for the message-driven bean that allows the bean to use a durable subscriber.
Creating Resources for the clientsessionmdb Example
This example uses the topic named jms/Topic and the connection factory jms/ConnectionFactory, which are used in previous examples.. If you deleted the connection factory or topic, they will be recreated when you deploy the example.
To Build, Package, Deploy, and Run the clientsessionmdb Example Using NetBeans IDE
- To compile and package the project, follow these steps:
- From the File menu, choose Open Project.
- In the Open Project dialog, navigate to:
tut-install/examples/jms/
- Select the clientsessionmdb folder.
- Select the Open as Main Project check box and the Open Required Projects check box.
- Click Open Project.
- In the Projects tab, right-click the clientsessionmdb project and select Build.
This task creates the following:
An application client JAR file that contains the client class file and the session bean’s remote interface, along with a manifest file that specifies the main class and places the EJB JAR file in its classpath
An EJB JAR file that contains both the session bean and the message-driven bean
An application EAR file that contains the two JAR files
- Right-click the project and select Run.
This command creates any needed resources, deploys the project, returns a JAR file named clientsessionmdbClient.jar, and then executes it.
The output of the application client in the Output pane looks like this (preceded by application client container output):
To view the bean output, check <install_dir>/domains/domain1/logs/server.log.
The output from the enterprise beans appears in the server log (domain-dir/logs/server.log), wrapped in logging information. The Publisher session bean sends two sets of 18 messages numbered 0 through 17. Because of the message selector, the message-driven bean receives only the messages whose NewsType property is Sports or Opinion.
To Build, Package, Deploy, and Run the clientsessionmdb Example Using Ant
- Go to the following directory:
tut-install/examples/jms/clientsessionmdb/
- To compile the source files and package the application, use the following command:
ant
The ant command creates the following:
An application client JAR file that contains the client class file and the session bean’s remote interface, along with a manifest file that specifies the main class and places the EJB JAR file in its classpath
An EJB JAR file that contains both the session bean and the message-driven bean
An application EAR file that contains the two JAR files
The clientsessionmdb.ear file is created in the dist directory.
- To create any needed resources, deploy the application, and run the client, use
the following command:
ant run
Ignore the message that states that the application is deployed at a URL.
The client displays these lines (preceded by application client container output):
To view the bean output, check <install_dir>/domains/domain1/logs/server.log.
The output from the enterprise beans appears in the server log file, wrapped in logging information. The Publisher session bean sends two sets of 18 messages numbered 0 through 17. Because of the message selector, the message-driven bean receives only the messages whose NewsType property is Sports or Opinion.


Delete a post by id.
get(blogId, postId, maxComments=None)
Get a post by id.
getByPath(blogId, path=None, maxComments=None)
Retrieve a Post by Path.
Add a post.
Retrieves a list of posts, possibly filtered.
list_next(previous_request, previous_response)
Retrieves the next page of results.
Update a post. This method supports patch semantics.
Search for a post.
Update a post.
delete(blogId, postId)
Delete a post by id. Args: blogId: string, The Id of the Blog. (required) postId: string, The ID of the Post. (required)
get(blogId, postId, maxComments=None)
Get a post by id. Args: blogId: string, ID of the blog to fetch the post from. (required) postId: string, The ID of the post (required) maxComments: integer, Maximum number of comments to pull back on a post. Returns: An object of the form: { "content": "A String", # The content of the Post. May contain HTML markup. "kind": "blogger#post", # The kind of this entity. Always blogger#post "author": { # The author of this Post. "url": "A String", # The URL of the Post creator's Profile page. "image": { # The Post author's avatar. "url": "A String", # The Post author's avatar URL. }, "displayName": "A String", # The display name. "id": "A String", # The identifier of the Post creator. }, "replies": { # The container of comments on this Post. "totalItems": "A String", # The count of comments on this post. "items": [ # The List of Comments for this Post. { "content": "A String", # The actual content of the comment. May include HTML markup. "kind": "blogger#comment", # The kind of this entry. Always blogger#comment "inReplyTo": { # Data about the comment this is in reply to. "id": "A String", # The identified of the parent of this comment. }, "author": { # The author of this Comment. "url": "A String", # The URL of the Comment creator's Profile page. "image": { # The comment creator's avatar. "url": "A String", # The comment creator's avatar URL. }, "displayName": "A String", # The display name. "id": "A String", # The identifier of the Comment creator. }, "updated": "A String", # RFC 3339 date-time when this comment was last updated. "blog": { # Data about the blog containing this comment. "id": "A String", # The identifier of the blog containing this comment. }, "published": "A String", # RFC 3339 date-time when this comment was published. "post": { # Data about the post containing this comment. "id": "A String", # The identifier of the post containing this comment. }, "id": "A String", # The identifier for this resource. "selfLink": "A String", # The API REST URL to fetch this resource from. }, ], "selfLink": "A String", # The URL of the comments on this post. }, "labels": [ # The list of labels this Post was tagged with. "A String", ], "customMetaData": "A String", # The JSON meta-data for the Post. "updated": "A String", # RFC 3339 date-time when this Post was last updated. "blog": { # Data about the blog containing this Post. "id": "A String", # The identifier of the Blog that contains this Post. }, "url": "A String", # The URL where this Post is displayed. "location": { # The location for geotagged posts. "lat": 3.14, # Location's latitude. "lng": 3.14, # Location's longitude. "span": "A String", # Location's viewport span. Can be used when rendering a map preview. "name": "A String", # Location name. }, "published": "A String", # RFC 3339 date-time when this Post was published. "title": "A String", # The title of the Post. "id": "A String", # The identifier of this Post. "selfLink": "A String", # The API REST URL to fetch this resource from. }
getByPath(blogId, path=None, maxComments=None)
Retrieve a Post by Path. Args: blogId: string, ID of the blog to fetch the post from. (required) path: string, Path of the Post to retrieve. maxComments: integer, Maximum number of comments to pull back on a post. Returns: An object of the form: { "content": "A String", # The content of the Post. May contain HTML markup. "kind": "blogger#post", # The kind of this entity. Always blogger#post "author": { # The author of this Post. "url": "A String", # The URL of the Post creator's Profile page. "image": { # The Post author's avatar. "url": "A String", # The Post author's avatar URL. }, "displayName": "A String", # The display name. "id": "A String", # The identifier of the Post creator. }, "replies": { # The container of comments on this Post. "totalItems": "A String", # The count of comments on this post. "items": [ # The List of Comments for this Post. { "content": "A String", # The actual content of the comment. May include HTML markup. "kind": "blogger#comment", # The kind of this entry. Always blogger#comment "inReplyTo": { # Data about the comment this is in reply to. "id": "A String", # The identified of the parent of this comment. }, "author": { # The author of this Comment. "url": "A String", # The URL of the Comment creator's Profile page. "image": { # The comment creator's avatar. "url": "A String", # The comment creator's avatar URL. }, "displayName": "A String", # The display name. "id": "A String", # The identifier of the Comment creator. }, "updated": "A String", # RFC 3339 date-time when this comment was last updated. "blog": { # Data about the blog containing this comment. "id": "A String", # The identifier of the blog containing this comment. }, "published": "A String", # RFC 3339 date-time when this comment was published. "post": { # Data about the post containing this comment. "id": "A String", # The identifier of the post containing this comment. }, "id": "A String", # The identifier for this resource. "selfLink": "A String", # The API REST URL to fetch this resource from. }, ], "selfLink": "A String", # The URL of the comments on this post. }, "labels": [ # The list of labels this Post was tagged with. "A String", ], "customMetaData": "A String", # The JSON meta-data for the Post. "updated": "A String", # RFC 3339 date-time when this Post was last updated. "blog": { # Data about the blog containing this Post. "id": "A String", # The identifier of the Blog that contains this Post. }, "url": "A String", # The URL where this Post is displayed. "location": { # The location for geotagged posts. "lat": 3.14, # Location's latitude. "lng": 3.14, # Location's longitude. "span": "A String", # Location's viewport span. Can be used when rendering a map preview. "name": "A String", # Location name. }, "published": "A String", # RFC 3339 date-time when this Post was published. "title": "A String", # The title of the Post. "id": "A String", # The identifier of this Post. "selfLink": "A String", # The API REST URL to fetch this resource from. }
insert(blogId, body)
Add a post. Args: blogId: string, ID of the blog to fetch the post from. (required) body: object, The request body. (required) The object takes the form of: { "content": "A String", # The content of the Post. May contain HTML markup. "kind": "blogger#post", # The kind of this entity. Always blogger#post "author": { # The author of this Post. "url": "A String", # The URL of the Post creator's Profile page. "image": { # The Post author's avatar. "url": "A String", # The Post author's avatar URL. }, "displayName": "A String", # The display name. "id": "A String", # The identifier of the Post creator. }, "replies": { # The container of comments on this Post. "totalItems": "A String", # The count of comments on this post. "items": [ # The List of Comments for this Post. { "content": "A String", # The actual content of the comment. May include HTML markup. "kind": "blogger#comment", # The kind of this entry. Always blogger#comment "inReplyTo": { # Data about the comment this is in reply to. "id": "A String", # The identified of the parent of this comment. }, "author": { # The author of this Comment. "url": "A String", # The URL of the Comment creator's Profile page. "image": { # The comment creator's avatar. "url": "A String", # The comment creator's avatar URL. }, "displayName": "A String", # The display name. "id": "A String", # The identifier of the Comment creator. }, "updated": "A String", # RFC 3339 date-time when this comment was last updated. "blog": { # Data about the blog containing this comment. "id": "A String", # The identifier of the blog containing this comment. }, "published": "A String", # RFC 3339 date-time when this comment was published. "post": { # Data about the post containing this comment. "id": "A String", # The identifier of the post containing this comment. }, "id": "A String", # The identifier for this resource. "selfLink": "A String", # The API REST URL to fetch this resource from. }, ], "selfLink": "A String", # The URL of the comments on this post. }, "labels": [ # The list of labels this Post was tagged with. "A String", ], "customMetaData": "A String", # The JSON meta-data for the Post. "updated": "A String", # RFC 3339 date-time when this Post was last updated. "blog": { # Data about the blog containing this Post. "id": "A String", # The identifier of the Blog that contains this Post. }, "url": "A String", # The URL where this Post is displayed. "location": { # The location for geotagged posts. "lat": 3.14, # Location's latitude. "lng": 3.14, # Location's longitude. "span": "A String", # Location's viewport span. Can be used when rendering a map preview. "name": "A String", # Location name. }, "published": "A String", # RFC 3339 date-time when this Post was published. "title": "A String", # The title of the Post. "id": "A String", # The identifier of this Post. "selfLink": "A String", # The API REST URL to fetch this resource from. } Returns: An object of the form: { "content": "A String", # The content of the Post. May contain HTML markup. "kind": "blogger#post", # The kind of this entity. Always blogger#post "author": { # The author of this Post. "url": "A String", # The URL of the Post creator's Profile page. "image": { # The Post author's avatar. "url": "A String", # The Post author's avatar URL. }, "displayName": "A String", # The display name. "id": "A String", # The identifier of the Post creator. }, "replies": { # The container of comments on this Post. "totalItems": "A String", # The count of comments on this post. "items": [ # The List of Comments for this Post. { "content": "A String", # The actual content of the comment. May include HTML markup. "kind": "blogger#comment", # The kind of this entry. Always blogger#comment "inReplyTo": { # Data about the comment this is in reply to. "id": "A String", # The identified of the parent of this comment. }, "author": { # The author of this Comment. "url": "A String", # The URL of the Comment creator's Profile page. "image": { # The comment creator's avatar. "url": "A String", # The comment creator's avatar URL. }, "displayName": "A String", # The display name. "id": "A String", # The identifier of the Comment creator. }, "updated": "A String", # RFC 3339 date-time when this comment was last updated. "blog": { # Data about the blog containing this comment. "id": "A String", # The identifier of the blog containing this comment. }, "published": "A String", # RFC 3339 date-time when this comment was published. "post": { # Data about the post containing this comment. "id": "A String", # The identifier of the post containing this comment. }, "id": "A String", # The identifier for this resource. "selfLink": "A String", # The API REST URL to fetch this resource from. }, ], "selfLink": "A String", # The URL of the comments on this post. }, "labels": [ # The list of labels this Post was tagged with. "A String", ], "customMetaData": "A String", # The JSON meta-data for the Post. "updated": "A String", # RFC 3339 date-time when this Post was last updated. "blog": { # Data about the blog containing this Post. "id": "A String", # The identifier of the Blog that contains this Post. }, "url": "A String", # The URL where this Post is displayed. "location": { # The location for geotagged posts. "lat": 3.14, # Location's latitude. "lng": 3.14, # Location's longitude. "span": "A String", # Location's viewport span. Can be used when rendering a map preview. "name": "A String", # Location name. }, "published": "A String", # RFC 3339 date-time when this Post was published. "title": "A String", # The title of the Post. "id": "A String", # The identifier of this Post. "selfLink": "A String", # The API REST URL to fetch this resource from. }
list(blogId, startDate=None, endDate=None, pageToken=None, labels=None, maxResults=None, fetchBodies=None)
Retrieves a list of posts, possibly filtered. Args: blogId: string, ID of the blog to fetch posts from. (required) startDate: string, Earliest post date to fetch, a date-time with RFC 3339 formatting. endDate: string, Latest post date to fetch, a date-time with RFC 3339 formatting. pageToken: string, Continuation token if the request is paged. labels: string, Comma-separated list of labels to search for. maxResults: integer, Maximum number of posts to fetch. fetchBodies: boolean, Whether the body content of posts is included. Returns: An object of the form: { "nextPageToken": "A String", # Pagination token to fetch the next page, if one exists. "items": [ # The list of Posts for this Blog. { "content": "A String", # The content of the Post. May contain HTML markup. "kind": "blogger#post", # The kind of this entity. Always blogger#post "author": { # The author of this Post. "url": "A String", # The URL of the Post creator's Profile page. "image": { # The Post author's avatar. "url": "A String", # The Post author's avatar URL. }, "displayName": "A String", # The display name. "id": "A String", # The identifier of the Post creator. }, "replies": { # The container of comments on this Post. "totalItems": "A String", # The count of comments on this post. "items": [ # The List of Comments for this Post. { "content": "A String", # The actual content of the comment. May include HTML markup. "kind": "blogger#comment", # The kind of this entry. Always blogger#comment "inReplyTo": { # Data about the comment this is in reply to. "id": "A String", # The identified of the parent of this comment. }, "author": { # The author of this Comment. "url": "A String", # The URL of the Comment creator's Profile page. "image": { # The comment creator's avatar. "url": "A String", # The comment creator's avatar URL. }, "displayName": "A String", # The display name. "id": "A String", # The identifier of the Comment creator. }, "updated": "A String", # RFC 3339 date-time when this comment was last updated. "blog": { # Data about the blog containing this comment. "id": "A String", # The identifier of the blog containing this comment. }, "published": "A String", # RFC 3339 date-time when this comment was published. "post": { # Data about the post containing this comment. "id": "A String", # The identifier of the post containing this comment. }, "id": "A String", # The identifier for this resource. "selfLink": "A String", # The API REST URL to fetch this resource from. }, ], "selfLink": "A String", # The URL of the comments on this post. }, "labels": [ # The list of labels this Post was tagged with. "A String", ], "customMetaData": "A String", # The JSON meta-data for the Post. "updated": "A String", # RFC 3339 date-time when this Post was last updated. "blog": { # Data about the blog containing this Post. "id": "A String", # The identifier of the Blog that contains this Post. }, "url": "A String", # The URL where this Post is displayed. "location": { # The location for geotagged posts. "lat": 3.14, # Location's latitude. "lng": 3.14, # Location's longitude. "span": "A String", # Location's viewport span. Can be used when rendering a map preview. "name": "A String", # Location name. }, "published": "A String", # RFC 3339 date-time when this Post was published. "title": "A String", # The title of the Post. "id": "A String", # The identifier of this Post. "selfLink": "A String", # The API REST URL to fetch this resource from. }, ], "kind": "blogger#postList", # The kind of this entity. Always blogger#postList "prevPageToken": "A String", # Pagination token to fetch the previous page, if one exists. }
list_next(previous_request, previous_response)
Retrieves the next page of results. Args: previous_request: The request for the previous page. (required) previous_response: The response from the request for the previous page. (required) Returns: A request object that you can call 'execute()' on to request the next page. Returns None if there are no more items in the collection.
patch(blogId, postId, body)
Update a post. This method supports patch semantics. Args: blogId: string, The ID of the Blog. (required) postId: string, The ID of the Post. (required) body: object, The request body. (required) The object takes the form of: { "content": "A String", # The content of the Post. May contain HTML markup. "kind": "blogger#post", # The kind of this entity. Always blogger#post "author": { # The author of this Post. "url": "A String", # The URL of the Post creator's Profile page. "image": { # The Post author's avatar. "url": "A String", # The Post author's avatar URL. }, "displayName": "A String", # The display name. "id": "A String", # The identifier of the Post creator. }, "replies": { # The container of comments on this Post. "totalItems": "A String", # The count of comments on this post. "items": [ # The List of Comments for this Post. { "content": "A String", # The actual content of the comment. May include HTML markup. "kind": "blogger#comment", # The kind of this entry. Always blogger#comment "inReplyTo": { # Data about the comment this is in reply to. "id": "A String", # The identified of the parent of this comment. }, "author": { # The author of this Comment. "url": "A String", # The URL of the Comment creator's Profile page. "image": { # The comment creator's avatar. "url": "A String", # The comment creator's avatar URL. }, "displayName": "A String", # The display name. "id": "A String", # The identifier of the Comment creator. }, "updated": "A String", # RFC 3339 date-time when this comment was last updated. "blog": { # Data about the blog containing this comment. "id": "A String", # The identifier of the blog containing this comment. }, "published": "A String", # RFC 3339 date-time when this comment was published. "post": { # Data about the post containing this comment. "id": "A String", # The identifier of the post containing this comment. }, "id": "A String", # The identifier for this resource. "selfLink": "A String", # The API REST URL to fetch this resource from. }, ], "selfLink": "A String", # The URL of the comments on this post. }, "labels": [ # The list of labels this Post was tagged with. "A String", ], "customMetaData": "A String", # The JSON meta-data for the Post. "updated": "A String", # RFC 3339 date-time when this Post was last updated. "blog": { # Data about the blog containing this Post. "id": "A String", # The identifier of the Blog that contains this Post. }, "url": "A String", # The URL where this Post is displayed. "location": { # The location for geotagged posts. "lat": 3.14, # Location's latitude. "lng": 3.14, # Location's longitude. "span": "A String", # Location's viewport span. Can be used when rendering a map preview. "name": "A String", # Location name. }, "published": "A String", # RFC 3339 date-time when this Post was published. "title": "A String", # The title of the Post. "id": "A String", # The identifier of this Post. "selfLink": "A String", # The API REST URL to fetch this resource from. } Returns: An object of the form: { "content": "A String", # The content of the Post. May contain HTML markup. "kind": "blogger#post", # The kind of this entity. Always blogger#post "author": { # The author of this Post. "url": "A String", # The URL of the Post creator's Profile page. "image": { # The Post author's avatar. "url": "A String", # The Post author's avatar URL. }, "displayName": "A String", # The display name. "id": "A String", # The identifier of the Post creator. }, "replies": { # The container of comments on this Post. "totalItems": "A String", # The count of comments on this post. "items": [ # The List of Comments for this Post. { "content": "A String", # The actual content of the comment. May include HTML markup. "kind": "blogger#comment", # The kind of this entry. Always blogger#comment "inReplyTo": { # Data about the comment this is in reply to. "id": "A String", # The identified of the parent of this comment. }, "author": { # The author of this Comment. "url": "A String", # The URL of the Comment creator's Profile page. "image": { # The comment creator's avatar. "url": "A String", # The comment creator's avatar URL. }, "displayName": "A String", # The display name. "id": "A String", # The identifier of the Comment creator. }, "updated": "A String", # RFC 3339 date-time when this comment was last updated. "blog": { # Data about the blog containing this comment. "id": "A String", # The identifier of the blog containing this comment. }, "published": "A String", # RFC 3339 date-time when this comment was published. "post": { # Data about the post containing this comment. "id": "A String", # The identifier of the post containing this comment. }, "id": "A String", # The identifier for this resource. "selfLink": "A String", # The API REST URL to fetch this resource from. }, ], "selfLink": "A String", # The URL of the comments on this post. }, "labels": [ # The list of labels this Post was tagged with. "A String", ], "customMetaData": "A String", # The JSON meta-data for the Post. "updated": "A String", # RFC 3339 date-time when this Post was last updated. "blog": { # Data about the blog containing this Post. "id": "A String", # The identifier of the Blog that contains this Post. }, "url": "A String", # The URL where this Post is displayed. "location": { # The location for geotagged posts. "lat": 3.14, # Location's latitude. "lng": 3.14, # Location's longitude. "span": "A String", # Location's viewport span. Can be used when rendering a map preview. "name": "A String", # Location name. }, "published": "A String", # RFC 3339 date-time when this Post was published. "title": "A String", # The title of the Post. "id": "A String", # The identifier of this Post. "selfLink": "A String", # The API REST URL to fetch this resource from. }
search(blogId, q=None)
Search for a post. Args: blogId: string, ID of the blog to fetch the post from. (required) q: string, Query terms to search this blog for matching posts. Returns: An object of the form: { "nextPageToken": "A String", # Pagination token to fetch the next page, if one exists. "items": [ # The list of Posts for this Blog. { "content": "A String", # The content of the Post. May contain HTML markup. "kind": "blogger#post", # The kind of this entity. Always blogger#post "author": { # The author of this Post. "url": "A String", # The URL of the Post creator's Profile page. "image": { # The Post author's avatar. "url": "A String", # The Post author's avatar URL. }, "displayName": "A String", # The display name. "id": "A String", # The identifier of the Post creator. }, "replies": { # The container of comments on this Post. "totalItems": "A String", # The count of comments on this post. "items": [ # The List of Comments for this Post. { "content": "A String", # The actual content of the comment. May include HTML markup. "kind": "blogger#comment", # The kind of this entry. Always blogger#comment "inReplyTo": { # Data about the comment this is in reply to. "id": "A String", # The identified of the parent of this comment. }, "author": { # The author of this Comment. "url": "A String", # The URL of the Comment creator's Profile page. "image": { # The comment creator's avatar. "url": "A String", # The comment creator's avatar URL. }, "displayName": "A String", # The display name. "id": "A String", # The identifier of the Comment creator. }, "updated": "A String", # RFC 3339 date-time when this comment was last updated. "blog": { # Data about the blog containing this comment. "id": "A String", # The identifier of the blog containing this comment. }, "published": "A String", # RFC 3339 date-time when this comment was published. "post": { # Data about the post containing this comment. "id": "A String", # The identifier of the post containing this comment. }, "id": "A String", # The identifier for this resource. "selfLink": "A String", # The API REST URL to fetch this resource from. }, ], "selfLink": "A String", # The URL of the comments on this post. }, "labels": [ # The list of labels this Post was tagged with. "A String", ], "customMetaData": "A String", # The JSON meta-data for the Post. "updated": "A String", # RFC 3339 date-time when this Post was last updated. "blog": { # Data about the blog containing this Post. "id": "A String", # The identifier of the Blog that contains this Post. }, "url": "A String", # The URL where this Post is displayed. "location": { # The location for geotagged posts. "lat": 3.14, # Location's latitude. "lng": 3.14, # Location's longitude. "span": "A String", # Location's viewport span. Can be used when rendering a map preview. "name": "A String", # Location name. }, "published": "A String", # RFC 3339 date-time when this Post was published. "title": "A String", # The title of the Post. "id": "A String", # The identifier of this Post. "selfLink": "A String", # The API REST URL to fetch this resource from. }, ], "kind": "blogger#postList", # The kind of this entity. Always blogger#postList "prevPageToken": "A String", # Pagination token to fetch the previous page, if one exists. }
update(blogId, postId, body)
Update a post. Args: blogId: string, The ID of the Blog. (required) postId: string, The ID of the Post. (required) body: object, The request body. (required) The object takes the form of: { "content": "A String", # The content of the Post. May contain HTML markup. "kind": "blogger#post", # The kind of this entity. Always blogger#post "author": { # The author of this Post. "url": "A String", # The URL of the Post creator's Profile page. "image": { # The Post author's avatar. "url": "A String", # The Post author's avatar URL. }, "displayName": "A String", # The display name. "id": "A String", # The identifier of the Post creator. }, "replies": { # The container of comments on this Post. "totalItems": "A String", # The count of comments on this post. "items": [ # The List of Comments for this Post. { "content": "A String", # The actual content of the comment. May include HTML markup. "kind": "blogger#comment", # The kind of this entry. Always blogger#comment "inReplyTo": { # Data about the comment this is in reply to. "id": "A String", # The identified of the parent of this comment. }, "author": { # The author of this Comment. "url": "A String", # The URL of the Comment creator's Profile page. "image": { # The comment creator's avatar. "url": "A String", # The comment creator's avatar URL. }, "displayName": "A String", # The display name. "id": "A String", # The identifier of the Comment creator. }, "updated": "A String", # RFC 3339 date-time when this comment was last updated. "blog": { # Data about the blog containing this comment. "id": "A String", # The identifier of the blog containing this comment. }, "published": "A String", # RFC 3339 date-time when this comment was published. "post": { # Data about the post containing this comment. "id": "A String", # The identifier of the post containing this comment. }, "id": "A String", # The identifier for this resource. "selfLink": "A String", # The API REST URL to fetch this resource from. }, ], "selfLink": "A String", # The URL of the comments on this post. }, "labels": [ # The list of labels this Post was tagged with. "A String", ], "customMetaData": "A String", # The JSON meta-data for the Post. "updated": "A String", # RFC 3339 date-time when this Post was last updated. "blog": { # Data about the blog containing this Post. "id": "A String", # The identifier of the Blog that contains this Post. }, "url": "A String", # The URL where this Post is displayed. "location": { # The location for geotagged posts. "lat": 3.14, # Location's latitude. "lng": 3.14, # Location's longitude. "span": "A String", # Location's viewport span. Can be used when rendering a map preview. "name": "A String", # Location name. }, "published": "A String", # RFC 3339 date-time when this Post was published. "title": "A String", # The title of the Post. "id": "A String", # The identifier of this Post. "selfLink": "A String", # The API REST URL to fetch this resource from. } Returns: An object of the form: { "content": "A String", # The content of the Post. May contain HTML markup. "kind": "blogger#post", # The kind of this entity. Always blogger#post "author": { # The author of this Post. "url": "A String", # The URL of the Post creator's Profile page. "image": { # The Post author's avatar. "url": "A String", # The Post author's avatar URL. }, "displayName": "A String", # The display name. "id": "A String", # The identifier of the Post creator. }, "replies": { # The container of comments on this Post. "totalItems": "A String", # The count of comments on this post. "items": [ # The List of Comments for this Post. { "content": "A String", # The actual content of the comment. May include HTML markup. "kind": "blogger#comment", # The kind of this entry. Always blogger#comment "inReplyTo": { # Data about the comment this is in reply to. "id": "A String", # The identified of the parent of this comment. }, "author": { # The author of this Comment. "url": "A String", # The URL of the Comment creator's Profile page. "image": { # The comment creator's avatar. "url": "A String", # The comment creator's avatar URL. }, "displayName": "A String", # The display name. "id": "A String", # The identifier of the Comment creator. }, "updated": "A String", # RFC 3339 date-time when this comment was last updated. "blog": { # Data about the blog containing this comment. "id": "A String", # The identifier of the blog containing this comment. }, "published": "A String", # RFC 3339 date-time when this comment was published. "post": { # Data about the post containing this comment. "id": "A String", # The identifier of the post containing this comment. }, "id": "A String", # The identifier for this resource. "selfLink": "A String", # The API REST URL to fetch this resource from. }, ], "selfLink": "A String", # The URL of the comments on this post. }, "labels": [ # The list of labels this Post was tagged with. "A String", ], "customMetaData": "A String", # The JSON meta-data for the Post. "updated": "A String", # RFC 3339 date-time when this Post was last updated. "blog": { # Data about the blog containing this Post. "id": "A String", # The identifier of the Blog that contains this Post. }, "url": "A String", # The URL where this Post is displayed. "location": { # The location for geotagged posts. "lat": 3.14, # Location's latitude. "lng": 3.14, # Location's longitude. "span": "A String", # Location's viewport span. Can be used when rendering a map preview. "name": "A String", # Location name. }, "published": "A String", # RFC 3339 date-time when this Post was published. "title": "A String", # The title of the Post. "id": "A String", # The identifier of this Post. "selfLink": "A String", # The API REST URL to fetch this resource from. }


[gecode-users] value-consistency definition
Mikael Zayenz Lagerkvist
zayenz at gmail.com
Thu May 3 12:09:29 CEST 2007
On 5/3/07, Guido Tack <tack at ps.uni-sb.de> wrote:
> > I've searched for a definition of value-consistency, but I don't
> > really find it.
>
> Unlike bounds-consistency or domain-consistency, it's not standard
> terminology, I think.
The closest theoretical notion is probably forward checking.
However, it's good to remember that forward checking may be defined in
several ways for non-binary constraints [1]. The idea of only
subscribing to PC_INT_VAL events, but doing full domain consistent
propagation (which roughly corresponds to some of the suggestions in
the mentioned paper) is not a correct approach for Gecode, since this
would make the propagator non-monotonic. See the recent discussion
with Peter Tiedemann about non-monotonic propagators for some more
information [2].
Cheers,
Mikael
[1] "On forward checking for non-binary constraint satisfaction", C.
Bessiere, P. Meseguer, E.C. Freuder and J. Larrosa, Artificial
Intelligence, volume 141, pages 205-224
[2] http://www.gecode.org/gecode-users/2007-April/001481.html
--
Mikael Zayenz Lagerkvist, http://www.ict.kth.se/~zayenz/
More information about the gecode-users
mailing list