• Qt Signal Slots
• Qt Signal Slot Connect
• Qt Connect Class Slots To Designer Signals
• Qt Signal Slot Automatic Connection Free
• Qt Signal Slot Thread

Home > Articles > Programming > C/C++

1. Signals and Slots in Depth

Qt 5 continues to support the old string-based syntax for connecting signals and slots defined in a QObject or any class that inherits from QObject (including QWidget) connect(sender, SIGNAL(valueChanged(QString, QString)), receiver, SLOT(updateValue(QString))); New: connecting to QObject member. Support for Signals and Slots¶ One of the key features of Qt is its use of signals and slots to communicate between objects. Their use encourages the development of reusable components. A signal is emitted when something of potential interest happens. A slot is a Python callable. If a signal is connected to a slot then the slot is called when the signal is emitted.

Signals and Slots in Depth

The signals and slots mechanism is fundamental to Qt programming. It enables the application programmer to bind objects together without the objects knowing anything about each other. We have already connected some signals and slots together, declared our own signals and slots, implemented our own slots, and emitted our own signals. Let's take a moment to look at the mechanism more closely.

Slots are almost identical to ordinary C++ member functions. They can be virtual; they can be overloaded; they can be public, protected, or private; they can be directly invoked like any other C++ member functions; and their parameters can be of any types. The difference is that a slot can also be connected to a signal, in which case it is automatically called each time the signal is emitted.

The connect() statement looks like this:

where sender and receiver are pointers to QObjects and where signal and slot are function signatures without parameter names. The SIGNAL() and SLOT() macros essentially convert their argument to a string.

In the examples we have seen so far, we have always connected different signals to different slots. There are other possibilities to consider.

• One signal can be connected to many slots:

  When the signal is emitted, the slots are called one after the other, in an unspecified order.

• Many signals can be connected to the same slot:

  When either signal is emitted, the slot is called.

• A signal can be connected to another signal:

  When the first signal is emitted, the second signal is emitted as well. Apart from that, signal–signal connections are indistinguishable from signal–slot connections.

• Connections can be removed:

  This is rarely needed, because Qt automatically removes all connections involving an object when that object is deleted.

To successfully connect a signal to a slot (or to another signal), they must have the same parameter types in the same order:

Exceptionally, if a signal has more parameters than the slot it is connected to, the additional parameters are simply ignored:

If the parameter types are incompatible, or if the signal or the slot doesn't exist, Qt will issue a warning at run-time if the application is built in debug mode. Similarly, Qt will give a warning if parameter names are included in the signal or slot signatures.

So far, we have only used signals and slots with widgets. But the mechanism itself is implemented in QObject and isn't limited to GUI programming. The mechanism can be used by any QObject subclass:

Notice how the setSalary() slot is implemented. We emit the salaryChanged() signal only if newSalary != mySalary. This ensures that cyclic connections don't lead to infinite loops.

Related Resources

• Book $31.99

• Book $35.99

• Book $43.99

• 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 −

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

Qt Signal Slots

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

Qt Signal Slot Connect

When b2 is clicked, the clicked() signal is connected to b2_clicked() function

Qt Connect Class Slots To Designer Signals

Example

Qt Signal Slot Automatic Connection Free

The above code produces the following output −

Qt Signal Slot Thread

Output