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

Qt was created with the idea of removing this boilerplate code and providing a nice and clean syntax, and the signal and slots mechanism is the answer. Signals and slots are the key of Qt and object communication within. They are in a sense comparable to callbacks, but the difference is that they are type-safe where as callbacks typically are not. In this case if you emit a signal from one thread, and catching it in another one (e.g. In main GUI thread) - Qt will put a slot's call to the message queue and will make all calls sequentially. Read this for further info - http://qt-project.org/doc/qt-4.8/threads-qobject.html#signals-and-slots-across-threads.

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.

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.

Qt Signals And Slots Tutorial

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:

Qt Signal Slot Performance

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)

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.

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

Qt Connect Signal Slot

void destroyed (QObject* = 0)

See alsodeleteLater() and QPointer.

Member Documentation

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.

Qt Signal Thread

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.

Qt Signal Slot Example

Example:

Qt Signal Slot Thread Safe Code

See alsometaObject().

Qt Signal Slot Thread Safe List