This section describes the older style for connecting signals and slots. Ituses the same API that a C++ application would use. This has a number ofadvantages.
- Pyqt Slot
- Pyqt5 Signal Slot Example
- Pyqt Signal Slot Between Classes Free
- Pyqt Signal Disconnect
- Pyqt Signal Connect
PyQt provides two different APIs, the first of which provides QStrings, QVariants, etc as is in Python. The new API 2 provides automatic conversion between the Qt classes and respective native Python datatypes and is much more Pythonic in nature. PyQt on Python 2.x defaults to API 1, while PyQt on Python 3 defaults to API 2.
- It is well understood and documented.
- Any future changes to the C++ API should be easily included.
It also has a number of disadvantages.
- It requires knowledge of the C++ types of signal arguments.
- It is error prone in that if you mis-type the signal name or signature thenno exception is raised, either when the signal is connected or emitted.
- It is verbose.
- It is not Pythonic.
This older style of connecting signals and slots will continue to be supportedthroughout the life of PyQt4.
PyQt4 Signals and Qt Signals¶
Qt signals are statically defined as part of a C++ class. They are referencedusing the QtCore.SIGNAL() function. This method takes a single stringargument that is the name of the signal and its C++ signature. For example:
The returned value is normally passed to the QtCore.QObject.connect()method.
PyQt4 allows new signals to be defined dynamically. The act of emitting aPyQt4 signal implicitly defines it. PyQt4 signals are also referenced usingthe QtCore.SIGNAL() function.
The PyQt_PyObject Signal Argument Type¶
It is possible to pass any Python object as a signal argument by specifyingPyQt_PyObject as the type of the argument in the signature. For example:
While this would normally be used for passing objects like lists anddictionaries as signal arguments, it can be used for any Python type. Itsadvantage when passing, for example, an integer is that the normal conversionsfrom a Python object to a C++ integer and back again are not required.
The reference count of the object being passed is maintained automatically.There is no need for the emitter of a signal to keep a reference to the objectafter the call to QtCore.QObject.emit(), even if a connection is queued.
Short-circuit Signals¶
There is also a special form of a PyQt4 signal known as a short-circuit signal.Short-circut signals implicitly declare each argument as being of typePyQt_PyObject.
Short-circuit signals do not have a list of arguments or the surroundingparentheses.
Short-circuit signals may only be connected to slots that have been implementedin Python. They cannot be connected to Qt slots or the Python callables thatwrap Qt slots.
PyQt4 Slots and Qt Slots¶
Qt slots are statically defined as part of a C++ class. They are referencedusing the QtCore.SLOT() function. This method takes a single stringargument that is the name of the slot and its C++ signature. For example:
The returned value is normally passed to the QtCore.QObject.connect()method.
PyQt4 allows any Python callable to be used as a slot, not just Qt slots. Thisis done by simply referencing the callable. Because Qt slots are implementedas class methods they are also available as Python callables. Therefore it isnot usually necessary to use QtCore.SLOT() for Qt slots. However, doing sois more efficient as it avoids a conversion to Python and back to C++.
Qt allows a signal to be connected to a slot that requires fewer arguments thanthe signal passes. The extra arguments are quietly discarded. PyQt4 slots canbe used in the same way.
Note that when a slot is a Python callable its reference count is notincreased. This means that a class instance can be deleted without having toexplicitly disconnect any signals connected to its methods. However, if a slotis a lambda function or a partial function then its reference count isautomatically incremented to prevent it from being immediately garbagecollected.
Pyqt Slot
Connecting Signals and Slots¶
Connections between signals and slots (and other signals) are made using theQtCore.QObject.connect() method. For example:
Disconnecting signals works in exactly the same way using theQtCore.QObject.disconnect() method. However, not all the variations ofthat method are supported by PyQt4. Signals must be disconnected one at atime.
Pyqt5 Signal Slot Example
Emitting Signals¶
Any instance of a class that is derived from the QtCore.QObject class canemit a signal using its emit() method. This takes a minimum of oneargument which is the signal. Any other arguments are passed to the connectedslots as the signal arguments. For example:
The QtCore.pyqtSignature() Decorator¶
The QtCore.pyqtSignature() serves the same purpose as thepyqtSlot() decorator but has a less Pythonic API.
- PyQt Tutorial
- PyQt Useful Resources
- Selected Reading
Unlike a console mode application, which is executed in a sequential manner, a GUI based application is event driven. Functions or methods are executed in response to user’s actions like clicking on a button, selecting an item from a collection or a mouse click etc., called events.
Widgets used to build the GUI interface act as the source of such events. Each PyQt widget, which is derived from QObject class, is designed to emit ‘signal’ in response to one or more events. The signal on its own does not perform any action. Instead, it is ‘connected’ to a ‘slot’. The slot can be any callable Python function.
In PyQt, connection between a signal and a slot can be achieved in different ways. Following are most commonly used techniques −
A more convenient way to call a slot_function, when a signal is emitted by a widget is as follows −
Pyqt Signal Slot Between Classes Free
Suppose if a function is to be called when a button is clicked. Here, the clicked signal is to be connected to a callable function. It can be achieved in any of the following two techniques −
or
Example
In the following example, two QPushButton objects (b1 and b2) are added in QDialog window. We want to call functions b1_clicked() and b2_clicked() on clicking b1 and b2 respectively.
When b1 is clicked, the clicked() signal is connected to b1_clicked() function
When b2 is clicked, the clicked() signal is connected to b2_clicked() function
Pyqt Signal Disconnect
Example
The above code produces the following output −