Qt is a cross-platform application framework that's used to develop UI-driven apps. Qt uses and extends C++ through a code generator called the MOC (meta-object compiler). When you build an app, the MOC reads your C++ header files looking for Qt-specific macros like Q_OBJECT, and produces the appropriate C++ meta-object code. Among other things, the meta-object code is necessary for the signals and slots mechanism.

• Qt No Such Slot In Derived Classroom
• Qt No Such Slot In Derived Classes
• Qt No Such Slot In Derived Class Example
• Qt No Such Slot In Derived Class C

In addition to the MOC, Qt provides several modules that contain foundational classes that you can use to build a Cascades app, such as QtCore, QtNetwork, QtXml, QtSql, and more. For a closer look at what parts of Qt are supported in Cascades, see Support for Qt in Cascades.

Adding QtCore.Slot decorator to base class function influences which thread executes slot in a derived class. See attached example. Executing it as-is will show that the DerivedClass's triggered function is executed in the MainThread (see logging output). QObject::connect: No such signal ButtonPanel::mostRecentPatientBtnClicked in.welcomebuttonpanel.cpp:6 So it seems QT is looking for the signal in ButtonPanel, the parent class, and not finding the signal in WelcomeButtonPanel, the derived class. The base class is ButtonPanel: Header.

QObject, the Qt base class

All objects in Cascades are derived from the QObject class. This class is the base class of all Qt objects and provides several important features. Most notably, QObject provides support for signals and slots, which is a powerful mechanism that allows objects to communicate with each other. When something happens to an object in your app (for example, a user clicks a button), the object emits a signal. You can handle that signal and respond to the event by using a function called a slot.

To illustrate some of the features and requirements of a QObject in Cascades, consider the Button control. This control represents a clickable button that you can use in your apps. The header file (button.h) for this control is located in the folder where you installed the BlackBerry 10 Native SDK, in the targetqnx6usrincludebbcascadescontrols subfolder. Let's take a closer look at some of the code in this file and what the code means.

Class declaration

All Cascades controls inherit QObject, either directly or indirectly. The Button class inherits several intermediate classes, all of which eventually inherit QObject.

Q_OBJECT macro

To identify a class as a QObject, you need to use the Q_OBJECT macro in the private: section of the class definition. This macro is processed by the Qt meta-object compiler (MOC) and enables features such as properties, signals, and slots. To learn more about the Qt meta-object system and meta-object compiler, see The Meta-Object System on the Qt website.

Property declaration

A property is a single piece of information about an object, and is declared by using the Q_PROPERTY macro. This macro allows the property to be accessible in QML. In the Q_PROPERTY, you specify the name and type of the property. You also use keywords (such as READ and WRITE) to specify the names of functions that can manipulate the value of the property. Properties are declared in the private: section of the header file, along with the Q_OBJECT macro.

As you can see above, the Button class includes the text property, which specifies the text that appears on the button. This property is a QString (the Qt representation of a text string) and has functions called text(), setText(), and resetText() to get, set, and reset the value of the property, respectively. These functions still need to be declared later; the Q_PROPERTY macro associates them only with the property. You can also specify a signal that's emitted when the value changes by using the keyword NOTIFY. To learn more about properties and the keywords you can use, see The Property System on the Qt website.

Function declaration

You can create functions for QObject classes just as you do for any other C++ classes. The Q_SLOT macro is used before the function declaration. This macro is another special element of Qt and indicates that this function is a slot. You can connect slots to signals so that when a signal is emitted, the connected slot function is called automatically. As an alternative to the Q_SLOT macro, you might see slot functions declared in a public slots: section in a header file. In Cascades, these approaches are identical.

Another useful macro that you might see is Q_INVOKABLE. You can use this macro in front of a function declaration (in the same place as Q_SLOT above) to indicate that you want to be able to call the function from QML. This approach can be useful if you have a complicated operation (for example, a custom transition for your UI control) that you want to implement in C++. You can still keep the UI-related part (calling the function at the appropriate time) in QML, but you can implement the operation in C++ any way you want. To learn more about Q_INVOKABLE, see QML and C++ integration.

Signal declaration

You can use the Q_SIGNALS: section to declare signals that a QObject emits when certain events occur. A Button emits the textChanged() signal when its text changes, and you can handle this event in your app if necessary. You might also see signals declared in a signals: section in a header file, which means the same thing in Cascades.

Object ownership

Every QObject can be related to other objects in parent/child relationships. An object can have one parent, as well as zero or more children. A parent object owns its child objects. When an object is destroyed, its children are also destroyed, so it's important to remember which objects are related to other objects in your apps.

Scene graphs

Cascades maintains the relationships between objects internally, and transfers ownership between objects automatically when you call functions that change object ownership. To make it easier to visualize the parent/child relationships in your app, you can use a hierarchical structure called a scene graph. This graph shows the controls (also called nodes) in your app and how they're related to each other. You can't view the scene graph for your app in the Momentics IDE or anywhere else; it's just a concept that makes it easier to visualize how Cascades tracks object relationships internally.

A hierarchical structure (such as a scene graph) is commonly used in many types of apps, such as complex UI apps and games, and makes it easier to manage complex arrangements of components. Using a hierarchical structure can also increase the performance of apps, which is a major reason why it was chosen as a feature for Cascades. Finally, the hierarchical nature of scene graphs fits nicely with the parent/child relationship structure of Qt objects. To learn more about this relationship structure, see Object Trees & Ownership from the Qt documentation.

For example, consider a Container with two Button controls.

Here's what the scene graph would look like for this arrangement:

Scene graphs can help you track how object ownership might affect various aspects of your app. For example, you can use a scene graph to visualize how touch events are delivered to different controls on the screen. To learn how scene graphs can help you handle touch events, see Cascades touch propagation.

Setting ownership

Object ownership can be established either when controls are created or when they're added to other controls. Both approaches result in the same parent/child relationships, so you can choose which approach you prefer to use in your apps.

For example, here's how to create a container and make it the parent for two buttons. This approach establishes object ownership when the buttons are created. The parent for each button is specified in the Button constructor, and each button becomes owned by the specified parent automatically when it's created.

Here's a second approach that establishes object ownership by adding the buttons to the container explicitly.

After object ownership is established, you can change the parent of an object by adding the object to a different parent. The object is removed from the first parent and added to the new parent, and the new parent then owns the object. Here's an example:

You can also remove an object from a container without specifying a new parent for the object. However, here's when things get tricky: even though the object was removed from the container, the container is still the object's parent and still owns the object. If the container is deleted, the object is deleted as well.

This behavior can lead to errors in your app that might be difficult to recognize. For example, consider the following example of two buttons that are added to a container. The second button is then removed from the container, and after the button is removed, the container is deleted. Finally, the removed button's setText() function is called.

Because the second button was removed from the container before the container was deleted, you might expect that when the container is deleted, the button isn't deleted and you can still access it. However, the container remains the parent of the button even after remove() is called. The second button is deleted when the container is deleted (along with the first button), so the call to setText() isn't valid because the button doesn't exist anymore.

When an object is removed from its parent, or when an object is replaced by a new object (in the case of certain setter functions, such as Page::setContent()), it's removed from the visual hierarchy (that is, it's not displayed on the screen anymore). The object's parent still owns the object, but you can change the parent or delete the object at this point. If you don't change the object's parent, it's still deleted when the parent object is deleted. It's important to note that you can't change the parent of an object if the object is still part of the visual hierarchy of its parent. You need to remove it before you try to change its parent.

All QObject instances include a function called setParent(), and you can use this function to change the parent of an object (when it's allowed, as described above). When you use setParent() to change an object's parent, the function doesn't add that object to the parent's visual hierarchy; you still need to add it explicitly (for example, by calling Container::add()).

To prevent the error that occurred in the code sample above, you can add a call to setParent(0) after you remove an object from its parent. This way, the object isn't deleted when its former parent is deleted.

If you have a UIObject that does not have a parent, an app crash can occur if the app quits and the object hasn't been deleted first. Always make sure to set a parent for UIObject instances or delete them manually before your app quits.

Scene ownership

There's one important exception to the rules of object ownership. The top-level scene in your app, which is the AbstractPane object that you set as the root node using Application::setScene(), behaves differently. The app takes ownership of this AbstractPane only if the pane doesn't already have a parent. If the AbstractPane doesn't have a parent when setScene() is called, the app owns the pane and deletes it if a new scene is set. However, if the AbstractPane already has a parent, the app won't take ownership of the pane when setScene() is called.

This behavior lets you switch between different scenes in your apps but ensures that for the most basic use case (an app with just a single scene), the old scene is deleted when appropriate. If you want to switch between two scenes, you should set the parents of the AbstractPane objects explicitly using setParent() before you call setScene().

Many other functions of Cascades classes change the ownership of objects. You should check the API reference for the classes and functions that you're working with to make sure that they don't change object ownership in unexpected ways.

Object ownership in QML

In QML, object ownership is established automatically according to the structure of the QML code that you write. For example, here's how to create the same example as above, with two Button controls and a Container:

The container is the parent of the buttons, and the buttons are children of the container. When the container is destroyed, both buttons are destroyed as well.

Signals and slots

For handling events and inter-object communication, Qt uses a mechanism called signals and slots. By using this mechanism, objects can communicate with each other by emitting a signal. An object that wants to receive a message from another object can create a slot for that particular signal.

Unlike the callback technique for inter-object communication, signals and slots are type-safe and loosely coupled. An object that implements a slot must match the method signature for the signal that it can receive. This approach allows the compiler to check the type of the subscription. Apart from the data type in the signature, a slot implementation doesn't need to know anything about the signal implementation. The slot doesn't even need to receive the same number of arguments that a signal emits. Similarly, you can send signals to objects if you know which slots they implement. The framework discards signal arguments that are not implemented by the slot.

Events in Cascades are implemented as signals. When a user interacts with your UI, the Cascades framework emits a signal. The framework delivers the signal to each slot that's connected to the signal.

To learn more about signals and slots, see Signals and slots.

Thread support

Qt provides support for threaded apps with the QThread class. The ability to create new threads is often necessary if your app contains resource-intensive processes that might otherwise block the UI thread. Some Qt classes, like QNetworkAccessManager, are already asynchronous in nature and don't require the creation of a separate thread to operate.

QThread

A QThread represents a separate thread of control in the app; it can share data with all the other threads within the app, but runs independently in the same way that a standalone app does. To facilitate communication between threads, signals and slots are fully supported.

Previously, the standard method for creating a QThread was by subclassing it. Now, you should use QThread by creating a worker object that is derived from QObject and implementing a slot on that worker to handle the task. The worker should also specify a signal that is emitted when the task is finished, and an optional signal that is emitted when there's an error.

After you create the worker class, you can give QThread ownership of the worker, connect the appropriate signals and slots, and start the thread.

For more information, see Thread Support in Qt on the Qt website.

QtConcurrentRun

The QtConcurrent::run() function is another way that you can run processes asynchronously. The difference from QThread is that it's designed to run just a single function. For more information on QtConcurrent, see QtConcurrentRun on the Qt website.

The QObject class is the base class of all Qt objects. More...

Inherited by AbstractAudioOutput, Notifier, Effect, MediaController, MediaObject, QAbstractAnimation, QAbstractEventDispatcher, QAbstractItemDelegate, QAbstractItemModel, QAbstractMessageHandler, QAbstractNetworkCache, QAbstractState, QAbstractTextDocumentLayout, QAbstractTransition, QAbstractUriResolver, QAbstractVideoSurface, QAction, QActionGroup, QAssistantClient, QAudioInput, QAudioOutput, QButtonGroup, QClipboard, QCompleter, QCoreApplication, QDataWidgetMapper, QDBusAbstractAdaptor, QDBusAbstractInterface, QDBusPendingCallWatcher, QDBusServiceWatcher, QDeclarativeComponent, QDeclarativeContext, QDeclarativeEngine, QDeclarativeExpression, QDeclarativeExtensionPlugin, QDeclarativePropertyMap, QDesignerFormEditorInterface, QDesignerFormWindowManagerInterface, QDrag, QEventLoop, QExtensionFactory, QExtensionManager, QFileSystemWatcher, QFtp, QGesture, QGLShader, QGLShaderProgram, QGraphicsAnchor, QGraphicsEffect, QGraphicsItemAnimation, QGraphicsObject, QGraphicsScene, QGraphicsTransform, QHelpEngineCore, QHelpSearchEngine, QHttp, QHttpMultiPart, QInputContext, QIODevice, QItemSelectionModel, QLayout, QLibrary, QLocalServer, QMimeData, QMovie, QNetworkAccessManager, QNetworkConfigurationManager, QNetworkCookieJar, QNetworkSession, QObjectCleanupHandler, QPluginLoader, QPyDeclarativePropertyValueSource, QPyDesignerContainerExtension, QPyDesignerCustomWidgetCollectionPlugin, QPyDesignerCustomWidgetPlugin, QPyDesignerMemberSheetExtension, QPyDesignerPropertySheetExtension, QPyDesignerTaskMenuExtension, QPyTextObject, QScriptEngine, QScriptEngineDebugger, QSessionManager, QSettings, QSharedMemory, QShortcut, QSignalMapper, QSocketNotifier, QSound, QSqlDriver, QStyle, QSvgRenderer, QSyntaxHighlighter, QSystemTrayIcon, QTcpServer, QTextDocument, QTextObject, QThread, QThreadPool, QTimeLine, QTimer, QTranslator, QUndoGroup, QUndoStack, QValidator, QWebFrame, QWebHistoryInterface, QWebPage, QWebPluginFactory and QWidget.

Methods

• bool blockSignals (self, bool b)
• list-of-QObject children (self)
• bool connect (self, QObject, SIGNAL(), SLOT(), Qt.ConnectionType = Qt.AutoConnection)
• customEvent (self, QEvent)
• disconnectNotify (self, SIGNAL() signal)
• dumpObjectTree (self)
• emit (self, SIGNAL(), ...)
• bool eventFilter (self, QObject, QEvent)
• QObject findChild (self, type type, QString name = QString())
• QObject findChild (self, tuple types, QString name = QString())
• list-of-QObject findChildren (self, type type, QString name = QString())
• list-of-QObject findChildren (self, tuple types, QString name = QString())
• list-of-QObject findChildren (self, type type, QRegExp regExp)
• list-of-QObject findChildren (self, tuple types, QRegExp regExp)
• installEventFilter (self, QObject)
• killTimer (self, int id)
• moveToThread (self, QThread thread)
• QObject parent (self)
• pyqtConfigure (self, object)
• removeEventFilter (self, QObject)
• int senderSignalIndex (self)
• setParent (self, QObject)
• bool signalsBlocked (self)
• QThread thread (self)
• QString tr (self, str sourceText, str disambiguation = None, int n = -1)
• QString trUtf8 (self, str sourceText, str disambiguation = None, int n = -1)

Static Methods

• bool connect (QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType = Qt.AutoConnection)
• bool connect (QObject, SIGNAL(), callable, Qt.ConnectionType = Qt.AutoConnection)
• bool disconnect (QObject, SIGNAL(), QObject, SLOT())

Special Methods

• object __getattr__ (self, str name)

Qt Signals

Static Members

• QMetaObject staticMetaObject

Detailed Description

The QObject class is the base class of all Qt objects.

QObject is the heart of the Qt ObjectModel. The central feature in this model is a very powerfulmechanism for seamless object communication called signals and slots. Youcan connect a signal to a slot with connect() and destroy the connectionwith disconnect(). To avoidnever ending notification loops you can temporarily block signalswith blockSignals(). Theprotected functions connectNotify() and disconnectNotify() make itpossible to track connections.

QObjects organizethemselves in object trees. When youcreate a QObject with another object as parent, the object willautomatically add itself to the parent's children() list. The parent takesownership of the object; i.e., it will automatically delete itschildren in its destructor. You can look for an object by name andoptionally type using findChild() or findChildren().

Every object has an objectName() and its class namecan be found via the corresponding metaObject() (see QMetaObject.className()). You candetermine whether the object's class inherits another class in theQObject inheritance hierarchy by using the inherits() function.

When an object is deleted, it emits a destroyed() signal. You can catch thissignal to avoid dangling references to QObjects.

QObjects can receiveevents through event() and filterthe events of other objects. See installEventFilter() andeventFilter() for details. Aconvenience handler, childEvent(), can be reimplemented tocatch child events.

Last but not least, QObject provides the basic timer support inQt; see QTimer for high-level support fortimers.

Notice that the Q_OBJECTmacro is mandatory for any object that implements signals, slots orproperties. You also need to run the MetaObject Compiler on the source file. We strongly recommend theuse of this macro in all subclasses of QObject regardless ofwhether or not they actually use signals, slots and properties,since failure to do so may lead certain functions to exhibitstrange behavior.

All Qt widgets inherit QObject. The convenience functionisWidgetType() returnswhether an object is actually a widget. It is much faster thanqobject_cast<QWidget *>(obj) orobj->inherits('QWidget').

Some QObject functions, e.g. children(), return a QObjectList. QObjectList is a typedef forQList<QObject *>.

Thread Affinity

A QObject instance is said to have a thread affinity, orthat it lives in a certain thread. When a QObject receives aqueued signal or aposted event,the slot or event handler will run in the thread that the objectlives in.

Note: If a QObject has no thread affinity (that is, ifthread() returns zero), or if itlives in a thread that has no running event loop, then it cannotreceive queued signals or posted events.

By default, a QObject lives in the thread in which it iscreated. An object's thread affinity can be queried using thread() and changed using moveToThread().

All QObjects mustlive in the same thread as their parent. Consequently:

lisetParent() will fail if the twoQObjects involved livein different threads. li Whena QObject is moved to another thread, all its children will beautomatically moved too. limoveToThread() will fail ifthe QObject has a parent. liIf QObjects are created within QThread.run(), they cannot become childrenof the QThread object because theQThread does not live in the thread thatcalls QThread.run().

Note: A QObject's member variables do notautomatically become its children. The parent-child relationshipmust be set by either passing a pointer to the child's constructor, or by calling setParent(). Without this step, theobject's member variables will remain in the old thread whenmoveToThread() iscalled.

No copy constructor or assignment operator

QObject has neither a copy constructor nor an assignmentoperator. This is by design. Actually, they are declared, but in aprivate section with the macro Q_DISABLE_COPY(). In fact, all Qtclasses derived from QObject (direct or indirect) use this macro todeclare their copy constructor and assignment operator to beprivate. The reasoning is found in the discussion on Identity vs Value on the QtObject Model page.

The main consequence is that you should use pointers to QObject(or to your QObject subclass) where you might otherwise be temptedto use your QObject subclass as a value. For example, without acopy constructor, you can't use a subclass of QObject as the valueto be stored in one of the container classes. You must storepointers.

Auto-Connection

Qt's meta-object system provides a mechanism to automaticallyconnect signals and slots between QObject subclasses and theirchildren. As long as objects are defined with suitable objectnames, and slots follow a simple naming convention, this connectioncan be performed at run-time by the QMetaObject.connectSlotsByName()function.

uic generates code that invokes thisfunction to enable auto-connection to be performed between widgetson forms created with Qt Designer. More information aboutusing auto-connection with Qt Designer is given in theUsing a Designer UI File inYour Application section of the Qt Designer manual.

Dynamic Properties

From Qt 4.2, dynamic properties can be added to and removed fromQObject instances at run-time. Dynamic properties do not need to bedeclared at compile-time, yet they provide the same advantages asstatic properties and are manipulated using the same API - usingproperty() to read them andsetProperty() to writethem.

From Qt 4.3, dynamic properties are supported by Qt Designer,and both standard Qt widgets and user-created forms can be givendynamic properties.

Internationalization (i18n)

All QObject subclasses support Qt's translation features, makingit possible to translate an application's user interface intodifferent languages.

To make user-visible text translatable, it must be wrapped incalls to the tr() function. This isexplained in detail in the Writing Source Code forTranslation document.

Method Documentation

QObject.__init__ (self, QObjectparent = None)

The parent argument, if not None, causes self to be owned by Qt instead of PyQt.

Constructs an object with parent object parent.

The parent of an object may be viewed as the object's owner. Forinstance, a dialog box is the parent ofthe OK and Cancel buttons it contains.

The destructor of a parent object destroys all childobjects.

Setting parent to 0 constructs an object with no parent.If the object is a widget, it will become a top-level window.

See alsoparent(),findChild(), and findChildren().

bool QObject.blockSignals (self, bool b)

The return value is the previous value of signalsBlocked().

Note that the destroyed()signal will be emitted even if the signals for this object havebeen blocked.

See alsosignalsBlocked().

QObject.childEvent (self, QChildEvent)

This event handler can be reimplemented in a subclass to receivechild events. The event is passed in the eventparameter.

QEvent.ChildAdded andQEvent.ChildRemoved events aresent to objects when children are added or removed. In both casesyou can only rely on the child being a QObject, or if isWidgetType() returns true, aQWidget. (This is because, in theChildAdded case, the child isnot yet fully constructed, and in the ChildRemoved case it might have beendestructed already).

QEvent.ChildPolished eventsare sent to widgets when children are polished, or when polishedchildren are added. If you receive a child polished event, thechild's construction is usually completed. However, this is notguaranteed, and multiple polish events may be delivered during theexecution of a widget's constructor.

For every child widget, you receive one ChildAdded event, zero or more ChildPolished events, and one ChildRemoved event.

The ChildPolished event isomitted if a child is removed immediately after it is added. If achild is polished several times during construction anddestruction, you may receive several child polished events for thesame child, each time with a different virtual table.

See alsoevent().

list-of-QObject QObject.children (self)

Returns a list of child objects. The QObjectList class is definedin the <QObject> header file as the following:

The first child added is the first object in the list and the last childadded is the last object in the list,i.e. new children are appended at the end.

Note that the list order changes when QWidget children are raised or lowered. A widget that is raised becomesthe last object in the list, and a widget that is lowered becomesthe first object in the list.

See alsofindChild(), findChildren(), parent(), and setParent().

bool QObject.connect (QObject, SIGNAL(), QObject, SLOT(), Qt.ConnectionType = Qt.AutoConnection)

Creates a connection of the given type from thesignal in the sender object to the method inthe receiver object. Returns true if the connectionsucceeds; otherwise returns false.

You must use the SIGNAL() and SLOT() macroswhen specifying the signal and the method, forexample:

This example ensures that the label always displays the currentscroll bar value. Note that the signal and slots parameters mustnot contain any variable names, only the type. E.g. the followingwould not work and return false:

A signal can also be connected to another signal:

In this example, the MyWidget constructor relays asignal from a private member variable, and makes it available undera name that relates to MyWidget.

A signal can be connected to many slots and signals. Manysignals can be connected to one slot.

If a signal is connected to several slots, the slots areactivated in the same order as the order the connection was made,when the signal is emitted.

The function returns true if it successfully connects the signalto the slot. It will return false if it cannot create theconnection, for example, if QObject isunable to verify the existence of either signal ormethod, or if their signatures aren't compatible.

By default, a signal is emitted for every connection you make;two signals are emitted for duplicate connections. You can breakall of these connections with a single disconnect() call. If you pass theQt.UniqueConnectiontype, the connection will only be made if it is not aduplicate. If there is already a duplicate (exact same signal tothe exact same slot on the same objects), the connection will failand connect will return false.

The optional type parameter describes the type ofconnection to establish. In particular, it determines whether aparticular signal is delivered to a slot immediately or queued fordelivery at a later time. If the signal is queued, the parametersmust be of types that are known to Qt's meta-object system, becauseQt needs to copy the arguments to store them in an event behind thescenes. If you try to use a queued connection and get the errormessage

call qRegisterMetaType() toregister the data type before you establish the connection.

Note: This function is thread-safe.

See alsodisconnect(), sender(), qRegisterMetaType(), andQ_DECLARE_METATYPE().

bool QObject.connect (QObject, SIGNAL(), callable, Qt.ConnectionType = Qt.AutoConnection)

Creates a connection of the given type from thesignal in the sender object to the method inthe receiver object. Returns true if the connectionsucceeds; otherwise returns false.

This function works in the same way as connect(const QObject *sender, const char *signal, constQObject *receiver, const char *method,Qt.ConnectionType type)but it uses QMetaMethod to specifysignal and method.

This function was introduced in Qt 4.8.

See also connect(const QObject *sender, const char*signal, const QObject *receiver, const char *method,Qt.ConnectionType type).

bool QObject.connect (self, QObject, SIGNAL(), SLOT(), Qt.ConnectionType = Qt.AutoConnection)

This function overloads connect().

Connects signal from the sender object to thisobject's method.

Equivalent to connect(sender, signal,this, method, type).

Every connection you make emits a signal, so duplicateconnections emit two signals. You can break a connection usingdisconnect().

Note: This function is thread-safe.

See alsodisconnect().

QObject.connectNotify (self, SIGNAL() signal)

If you want to compare signal with a specific signal, useQLatin1String and theSIGNAL() macro as follows:

If the signal contains multiple parameters or parameters thatcontain spaces, call QMetaObject.normalizedSignature()on the result of the SIGNAL() macro.

Warning: This function violates the object-orientedprinciple of modularity. However, it might be useful when you needto perform expensive initialization only if something is connectedto a signal.

See alsoconnect() anddisconnectNotify().

QObject.customEvent (self, QEvent)

This event handler can be reimplemented in a subclass to receivecustom events. Custom events are user-defined events with a typevalue at least as large as the QEvent.User item of the QEvent.Type enum, and is typically aQEvent subclass. The event is passed inthe event parameter.

See alsoevent() andQEvent.

QObject.deleteLater (self)

The object will be deleted when control returns to the eventloop. If the event loop is not running when this function is called(e.g. deleteLater() is called on an object before QCoreApplication.exec()), theobject will be deleted once the event loop is started. IfdeleteLater() is called after the main event loop has stopped, theobject will not be deleted. Since Qt 4.8, if deleteLater() iscalled on an object that lives in a thread with no running eventloop, the object will be destroyed when the thread finishes.

Note that entering and leaving a new event loop (e.g., byopening a modal dialog) will not perform the deferreddeletion; for the object to be deleted, the control must return tothe event loop from which deleteLater() was called.

Note: It is safe to call this function more than once;when the first deferred deletion event is delivered, any pendingevents for the object are removed from the event queue.

See alsodestroyed()and QPointer.

bool QObject.disconnect (QObject, SIGNAL(), QObject, SLOT())

Disconnects signal in object sender frommethod in object receiver. Returns true if theconnection is successfully broken; otherwise returns false.

A signal-slot connection is removed when either of the objectsinvolved are destroyed.

disconnect() is typically used in three ways, as the followingexamples demonstrate.

1. Disconnect everything connected to an object's signals:

   equivalent to the non-static overloaded function

2. Disconnect everything connected to a specific signal:

   equivalent to the non-static overloaded function

3. Disconnect a specific receiver:

   equivalent to the non-static overloaded function

0 may be used as a wildcard, meaning 'any signal', 'anyreceiving object', or 'any slot in the receiving object',respectively.

The sender may never be 0. (You cannot disconnect signalsfrom more than one object in a single call.)

If signal is 0, it disconnects receiver andmethod from any signal. If not, only the specified signal isdisconnected.

If receiver is 0, it disconnects anything connected tosignal. If not, slots in objects other than receiverare not disconnected.

If method is 0, it disconnects anything that is connectedto receiver. If not, only slots named method will bedisconnected, and all other slots are left alone. The methodmust be 0 if receiver is left out, so you cannot disconnecta specifically-named slot on all objects.

Note: This function is thread-safe.

See alsoconnect().

bool QObject.disconnect (QObject, SIGNAL(), callable)

Disconnects signal in object sender frommethod in object receiver. Returns true if theconnection is successfully broken; otherwise returns false.

This function provides the same possibilities likedisconnect(const QObject *sender, constchar *signal, const QObject *receiver,const char *method) but uses QMetaMethod to represent the signal and themethod to be disconnected.

Additionally this function returnsfalse and no signals and slotsdisconnected if:

1. signal is not a member of sender class or one of itsparent classes.
2. method is not a member of receiver class or one of itsparent classes.
3. signal instance represents not a signal.

QMetaMethod() may be used as wildcard in the meaning 'anysignal' or 'any slot in receiving object'. In the same way 0 can beused for receiver in the meaning 'any receiving object'. Inthis case method should also be QMetaMethod(). senderparameter should be never 0.

This function was introduced in Qt 4.8.

See also disconnect(const QObject *sender, const char*signal, const QObject *receiver, const char *method).

QObject.disconnectNotify (self, SIGNAL() signal)

See connectNotify() foran example of how to compare signal with a specificsignal.

Warning: This function violates the object-orientedprinciple of modularity. However, it might be useful for optimizingaccess to expensive resources.

See alsodisconnect() and connectNotify().

QObject.dumpObjectInfo (self)

See alsodumpObjectTree().

QObject.dumpObjectTree (self)

See alsodumpObjectInfo().

list-of-QByteArray QObject.dynamicPropertyNames (self)

Returns the names of all properties that were dynamically addedto the object using setProperty().

This function was introduced in Qt 4.2.

QObject.emit (self, SIGNAL(), ...)

bool QObject.event (self, QEvent)

This virtual function receives events to an object and shouldreturn true if the event e was recognized and processed.

Qt No Such Slot In Derived Classroom

The event() function can be reimplemented to customize thebehavior of an object.

See alsoinstallEventFilter(),timerEvent(), QApplication.sendEvent(),QApplication.postEvent(),and QWidget.event().

bool QObject.eventFilter (self, QObject, QEvent)

Filters events if this object has been installed as an eventfilter for the watched object.

In your reimplementation of this function, if you want to filterthe event out, i.e. stop it being handled further, returntrue; otherwise return false.

Example:

Notice in the example above that unhandled events are passed tothe base class's eventFilter() function, since the base class mighthave reimplemented eventFilter() for its own internal purposes.

Warning: If you delete the receiver object in thisfunction, be sure to return true. Otherwise, Qt will forward theevent to the deleted object and the program might crash.

See alsoinstallEventFilter().

QObject QObject.findChild (self, type type, QString name = QString())

If there is more than one child matching the search, the mostdirect ancestor is returned. If there are several direct ancestors,it is undefined which one will be returned. In that case, findChildren() should be used.

This example returns a child QPushButton of parentWidget named'button1':

This example returns a QListWidget child ofparentWidget:

See alsofindChildren().

QObject QObject.findChild (self, tuple types, QString name = QString())

list-of-QObject QObject.findChildren (self, type type, QString name = QString())

The following example shows how to find a list of child QWidgets of the specified parentWidgetnamed widgetname:

This example returns all QPushButtons that are childrenof parentWidget:

See alsofindChild().

list-of-QObject QObject.findChildren (self, tuple types, QString name = QString())

This function overloads findChildren().

Returns the children of this object that can be cast to type Tand that have names matching the regular expression regExp,or an empty list if there are no such objects. The search isperformed recursively.

list-of-QObject QObject.findChildren (self, type type, QRegExpregExp)

list-of-QObject QObject.findChildren (self, tuple types, QRegExpregExp)

bool QObject.inherits (self, str classname)

Returns true if this object is an instance of a class thatinherits className or a QObjectsubclass that inherits className; otherwise returnsfalse.

A class is considered to inherit itself.

Example:

If you need to determine whether an object is an instance of aparticular class for the purpose of casting it, consider usingqobject_cast<Type *>(object) instead.

See alsometaObject() and qobject_cast().

QObject.installEventFilter (self, QObject)

Installs an event filter filterObj on this object. Forexample:

An event filter is an object that receives all events that aresent to this object. The filter can either stop the event orforward it to this object. The event filter filterObjreceives events via its eventFilter() function. The eventFilter() function must returntrue if the event should be filtered, (i.e. stopped); otherwise itmust return false.

If multiple event filters are installed on a single object, thefilter that was installed last is activated first.

Here's a KeyPressEater class that eats the key pressesof its monitored objects:

And here's how to install it on two widgets:

The QShortcut class, for example,uses this technique to intercept shortcut key presses.

Warning: If you delete the receiver object in youreventFilter() function, besure to return true. If you return false, Qt sends the event to thedeleted object and the program will crash.

Note that the filtering object must be in the same thread asthis object. If filterObj is in a different thread, thisfunction does nothing. If either filterObj or this objectare moved to a different thread after calling this function, theevent filter will not be called until both objects have the samethread affinity again (it is not removed).

See alsoremoveEventFilter(), eventFilter(), and event().

bool QObject.isWidgetType (self)

Calling this function is equivalent to callinginherits('QWidget'), except that it ismuch faster.

QObject.killTimer (self, int id)

The timer identifier is returned by startTimer() when a timer event isstarted.

See alsotimerEvent() and startTimer().

QMetaObject QObject.metaObject (self)

Qt No Such Slot In Derived Classes

Returns a pointer to the meta-object of this object.

A meta-object contains information about a class that inheritsQObject, e.g. class name, superclassname, properties, signals and slots. Every QObject subclass that contains the Q_OBJECT macro will have ameta-object.

The meta-object information is required by the signal/slotconnection mechanism and the property system. The inherits() function also makes use ofthe meta-object.

If you have no pointer to an actual object instance but stillwant to access the meta-object of a class, you can use staticMetaObject.

Example:

See alsostaticMetaObject.

QObject.moveToThread (self, QThreadthread)

Changes the thread affinity for this object and its children.The object cannot be moved if it has a parent. Event processingwill continue in the targetThread.

To move an object to the main thread, use QApplication.instance() toretrieve a pointer to the current application, and then useQApplication.thread() toretrieve the thread in which the application lives. Forexample:

If targetThread is zero, all event processing for thisobject and its children stops.

Note that all active timers for the object will be reset. Thetimers are first stopped in the current thread and restarted (withthe same interval) in the targetThread. As a result,constantly moving an object between threads can postpone timerevents indefinitely.

A QEvent.ThreadChange eventis sent to this object just before the thread affinity is changed.You can handle this event to perform any special processing. Notethat any new events that are posted to this object will be handledin the targetThread.

Warning: This function is not thread-safe; thecurrent thread must be same as the current thread affinity. Inother words, this function can only 'push' an object from thecurrent thread to another thread, it cannot 'pull' an object fromany arbitrary thread to the current thread.

See alsothread().

QString QObject.objectName (self)

QObject QObject.parent (self)

Returns a pointer to the parent object.

See alsosetParent()and children().

QVariant QObject.property (self, str name)

Information about all available properties is provided throughthe metaObject() and dynamicPropertyNames().

See alsosetProperty(), QVariant.isValid(), metaObject(), and dynamicPropertyNames().

QObject.pyqtConfigure (self, object)

int QObject.receivers (self, SIGNAL() signal)

QObject.removeEventFilter (self, QObject)

Removes an event filter object obj from this object. Therequest is ignored if such an event filter has not beeninstalled.

All event filters for this object are automatically removed whenthis object is destroyed.

It is always safe to remove an event filter, even during eventfilter activation (i.e. from the eventFilter() function).

See alsoinstallEventFilter(),eventFilter(), and event().

QObject QObject.sender (self)

Returns a pointer to the object that sent the signal, if calledin a slot activated by a signal; otherwise it returns 0. Thepointer is valid only during the execution of the slot that callsthis function from this object's thread context.

The pointer returned by this function becomes invalid if thesender is destroyed, or if the slot is disconnected from thesender's signal.

Warning: This function violates the object-orientedprinciple of modularity. However, getting access to the sendermight be useful when many signals are connected to a singleslot.

Warning: As mentioned above, the return value of thisfunction is not valid when the slot is called via a Qt.DirectConnection from athread different from this object's thread. Do not use thisfunction in this type of scenario.

See alsosenderSignalIndex() andQSignalMapper.

int QObject.senderSignalIndex (self)

Returns the meta-method index of the signal that called thecurrently executing slot, which is a member of the class returnedby sender(). If called outside ofa slot activated by a signal, -1 is returned.

For signals with default parameters, this function will alwaysreturn the index with all parameters, regardless of which was usedwith connect(). For example, thesignal destroyed(QObject *obj = 0) will have two differentindexes (with and without the parameter), but this function willalways return the index with a parameter. This does not apply whenoverloading signals with different parameters.

Warning: This function violates the object-orientedprinciple of modularity. However, getting access to the signalindex might be useful when many signals are connected to a singleslot.

Warning: The return value of this function is not validwhen the slot is called via a Qt.DirectConnection from athread different from this object's thread. Do not use thisfunction in this type of scenario.

This function was introduced in Qt 4.8.

See alsosender(),QMetaObject.indexOfSignal(),and QMetaObject.method().

QObject.setObjectName (self, QString name)

QObject.setParent (self, QObject)

The QObject argument, if not None, causes self to be owned by Qt instead of PyQt.

Makes the object a child of parent.

See alsoparent() andQWidget.setParent().

bool QObject.setProperty (self, str name, QVariant value)

Information about all available properties is provided throughthe metaObject() and dynamicPropertyNames().

Dynamic properties can be queried again using property() and can be removed bysetting the property value to an invalid QVariant. Changing the value of a dynamicproperty causes a QDynamicPropertyChangeEventto be sent to the object.

Note: Dynamic properties starting with '_q_' are reservedfor internal purposes.

See alsoproperty(),metaObject(), and dynamicPropertyNames().

bool QObject.signalsBlocked (self)

See alsoblockSignals().

int QObject.startTimer (self, int interval)

A timer event will occur every interval millisecondsuntil killTimer() is called.If interval is 0, then the timer event occurs once everytime there are no more window system events to process.

The virtual timerEvent()function is called with the QTimerEvent event parameter class when atimer event occurs. Reimplement this function to get timerevents.

If multiple timers are running, the QTimerEvent.timerId() can be usedto find out which timer was activated.

Example:

Note that QTimer's accuracy depends onthe underlying operating system and hardware. Most platformssupport an accuracy of 20 milliseconds; some provide more. If Qt isunable to deliver the requested number of timer events, it willsilently discard some.

The QTimer class provides a high-levelprogramming interface with single-shot timers and timer signalsinstead of events. There is also a QBasicTimer class that is more lightweightthan QTimer and less clumsy than usingtimer IDs directly.

See alsotimerEvent(), killTimer(), and QTimer.singleShot().

QThread QObject.thread (self)

Returns the thread in which the object lives.

See alsomoveToThread().

QObject.timerEvent (self, QTimerEvent)

This event handler can be reimplemented in a subclass to receivetimer events for the object.

QTimer provides a higher-levelinterface to the timer functionality, and also more generalinformation about timers. The timer event is passed in theevent parameter.

Qt No Such Slot In Derived Class Example

See alsostartTimer(), killTimer(), and event().

QString QObject.tr (self, str sourceText, str disambiguation = None, int n = -1)

See Writing Source Codefor Translation for a detailed description of Qt's translationmechanisms in general, and the Disambiguationsection for information on disambiguation.

Warning: This method is reentrant only if all translatorsare installed before calling this method. Installing orremoving translators while performing translations is notsupported. Doing so will probably result in crashes or otherundesirable behavior.

See alsotrUtf8(),QApplication.translate(),QTextCodec.setCodecForTr(),and Internationalization withQt.

QString QObject.trUtf8 (self, str sourceText, str disambiguation = None, int n = -1)

See alsotr(), QApplication.translate(),and Internationalization withQt.

object QObject.__getattr__ (self, str name)

Qt Signal Documentation

void destroyed (QObject* = 0)

See alsodeleteLater() and QPointer.

Member Documentation

Qt No Such Slot In Derived Class C

QMetaObject staticMetaObject

This member should be treated as a constant.

This variable stores the meta-object for the class.

A meta-object contains information about a class that inheritsQObject, e.g. class name, superclassname, properties, signals and slots. Every class that contains theQ_OBJECT macro will also have ameta-object.

The meta-object information is required by the signal/slotconnection mechanism and the property system. The inherits() function also makes use ofthe meta-object.

If you have a pointer to an object, you can use metaObject() to retrieve themeta-object associated with that object.

Example:

See alsometaObject().