Development/Tutorials/Python introduction to signals and slots: Difference between revisions
(Mark for archiving) |
|||
(23 intermediate revisions by 6 users not shown) | |||
Line 1: | Line 1: | ||
{{ | {{Archived}} | ||
{{Warning|This tutorial uses PyQt4 and Qt4.}} | |||
==Abstract== | |||
The signal and slot architecture is designed to simplify communication between objects. GUI programming is mostly event-driven and conventionally uses callbacks. The limitations of callbacks are partly resolved by the signal and slot architecture that Qt uses. The idea is that all objects can emit signals. | |||
When a button is clicked, for example, it emits a “clicked()” signal. Signals do nothing alone, but once connected to a slot, the code in the slot will be executed whenever the signal is emitted. | |||
In the Python programs, every function is a slot. It is possible to connect one signal to multiple slots, and to connect slots consecutively. For instance, one event activates its slot and related subsequent events trigger another signal and the code in its slot to be executed. | |||
==Prerequisites== | ==Prerequisites== | ||
Line 11: | Line 15: | ||
==Connecting signals and slots.== | ==Connecting signals and slots.== | ||
We use the QObject.connect() method to | We use the QObject.connect() method to connect signals and slots. | ||
< | <syntaxhighlight lang="python"> | ||
bool connect (QObject, SIGNAL(), callable, Qt.ConnectionType = Qt.AutoConnection) | bool connect (QObject, SIGNAL(), callable, Qt.ConnectionType = Qt.AutoConnection) | ||
</ | </syntaxhighlight> | ||
The first argument is the name of the object that is emitting the signal. The second argument is the signal, and the third argument is the | The first argument is the name of the object that is emitting the signal. The second argument is the signal, and the third argument is the slot. The slot has to bee a python callable object. Note that only QObjects and objects inheriting from QObject can emit signals. | ||
'''Example''' | '''Example''' | ||
< | <syntaxhighlight lang="python"> | ||
from PyQt4.QtGui import * | from PyQt4.QtGui import * | ||
from PyQt4.QtCore import * | from PyQt4.QtCore import * | ||
Line 30: | Line 34: | ||
exitButton=QPushButton("Exit") | exitButton=QPushButton("Exit") | ||
# | #Here we connect the exitButton's "clicked()" signals to the app's exit method. | ||
#This will have the effect that every time some one clicks the exitButton the app.exit method will execute and the application will close. | #This will have the effect that every time some one clicks the exitButton | ||
#the app.exit method will execute and the application will close. | |||
QObject.connect(exitButton,SIGNAL("clicked()"),app.exit) | QObject.connect(exitButton,SIGNAL("clicked()"),app.exit) | ||
Line 37: | Line 42: | ||
#Start the evnt loop | #Start the evnt loop | ||
sys.exit(app.exec_()) | sys.exit(app.exec_()) | ||
</ | </syntaxhighlight> | ||
==Emitting signals== | |||
Only QObjects and objects inheriting from QObject can emit signals. To emit a signal we use the QObject.emit() method. | |||
<syntaxhighlight lang="python"> | |||
QObject.emit (self, SIGNAL(), ...) | |||
</syntaxhighlight> | |||
emit() is an object method, the self parameter is therefor automatically inserted by the python interpreter. The next argument is the signal we would like to emit, for example it could have been SIGNAL("myfirstsignal()") if we wanted to emit a signal with that name. The next parameters is optional parameters that can be sent with the signal, will come back to that in more detail later. | |||
'''Example:'''In this example we have a class with a function "afunc" that emits the signal "doSomePrinting()". The class also have function "bfunc" that prints "Hello world". First we create a object of the class then we connect the "doSomePrinting()" to "bfunc". After that we call "afunc". This will result in the printing of "Hello World" to the standard output | |||
<syntaxhighlight lang="python"> | |||
import sys | |||
from time import time | |||
from PyQt4.QtCore import * | |||
class A (QObject): | |||
def __init__(self): | |||
QObject.__init__(self) | |||
def afunc (self): | |||
self.emit(SIGNAL("doSomePrinting()")) | |||
def bfunc(self): | |||
print "Hello World!" | |||
if __name__=="__main__": | |||
app=QCoreApplication(sys.argv) | |||
a=A() | |||
QObject.connect(a,SIGNAL("doSomePrinting()"),a.bfunc) | |||
a.afunc() | |||
sys.exit(app.exec_()) | |||
</syntaxhighlight> | |||
==Signals and slots with parameters== | ==Signals and slots with parameters== | ||
The signal and slots mechanism is type safe. In C++ this implies that both the number of arguments and the type of the arguments in a signal must match the arguments in the receiving slot. In Qt's Signal and slots architecture the receiving slot can actually have fewer parameters than the emitted signal, the extra arguments will then be ignored. Because of pythons dynamically typed nature it not possible to do any type checking in advance. It is therefor important to make sure that the emitted object is of the expected type or of a type that can be automatically converted to the expected type. For example a python string will automatically be converted to QString. If we send a object of an incompatible type we will get an runtime error. | The signal and slots mechanism is type safe. In C++ this implies that both the number of arguments and the type of the arguments in a signal must match the arguments in the receiving slot. In Qt's Signal and slots architecture the receiving slot can actually have fewer parameters than the emitted signal, the extra arguments will then be ignored. Because of pythons dynamically typed nature it not possible to do any type checking in advance. It is therefor important to make sure that the emitted object is of the expected type or of a type that can be automatically converted to the expected type. For example a python string will automatically be converted to QString. If we send a object of an incompatible type we will get an runtime error. | ||
'''Example:''' | |||
'''Example''' | This example will create a slider and display it. Every time the value of the slider is changed the new value will be printed to the standard output. The references documentation for QSlider can be found [http://www.riverbankcomputing.com/Docs/PyQt4/html/qslider.html here], the valueChanged signal is inherited from [http://www.riverbankcomputing.com/Docs/PyQt4/html/qabstractslider.html QAbstractSlider] | ||
< | <syntaxhighlight lang="python"> | ||
from PyQt4.QtGui import * | from PyQt4.QtGui import * | ||
from PyQt4.QtCore import * | from PyQt4.QtCore import * | ||
Line 53: | Line 93: | ||
if __name__=="__main__": | if __name__=="__main__": | ||
#First we create a QApplication and | #First we create a QApplication and QSlider | ||
app=QApplication(sys.argv) | app=QApplication(sys.argv) | ||
slider=QSlider(Qt.Horizontal) | slider=QSlider(Qt.Horizontal) | ||
Line 64: | Line 104: | ||
#Start the evnt loop | #Start the evnt loop | ||
sys.exit(app.exec_()) | sys.exit(app.exec_()) | ||
</ | </syntaxhighlight> | ||
==Python objects as parameters== | ==Python objects as parameters== | ||
It's possible to send a python object of any type using PyQt_PyObject in the signature. This is recommended when both signal and slot is implemented in python. By using PyQt_PyObject we avoid unnecessary conversions between python objects and C++ types and it more consistent with python dynamically typed nature. | It's possible to send a python object of any type using PyQt_PyObject in the signature. This is recommended when both signal and slot is implemented in python. By using PyQt_PyObject we avoid unnecessary conversions between python objects and C++ types and it is more consistent with python dynamically typed nature. | ||
'''Example''' | '''Example''' | ||
< | <syntaxhighlight lang="python"> | ||
import sys | import sys | ||
from time import time | from time import time | ||
Line 84: | Line 124: | ||
self.emit(SIGNAL("asignal(PyQt_PyObject)"),msg) | self.emit(SIGNAL("asignal(PyQt_PyObject)"),msg) | ||
def | def receive(self,msg): | ||
print msg | print msg | ||
Line 92: | Line 132: | ||
app=QCoreApplication(sys.argv) | app=QCoreApplication(sys.argv) | ||
a=A() | a=A() | ||
QObject.connect(a,SIGNAL("asignal(PyQt_PyObject)"),a. | QObject.connect(a,SIGNAL("asignal(PyQt_PyObject)"),a.receive) | ||
a.send() | a.send() | ||
sys.exit(app.exec_()) | sys.exit(app.exec_()) | ||
</ | </syntaxhighlight> | ||
==Short-circuit Signal== | ==Short-circuit Signal== | ||
PyQt4 | PyQt4 has a special type of signal called a short-circuit Signal. This signal implicitly declares all arguments to be of type PyQt_PyObject. Short-circuited signals do not have argument lists or parentheses. Short-circuited signals can only be connected to python slots. | ||
'''The same example as above, using short-circuited signals. ''' | '''The same example as above, using short-circuited signals. ''' | ||
< | <syntaxhighlight lang="python"> | ||
import sys | import sys | ||
from time import time | from time import time | ||
Line 117: | Line 156: | ||
self.emit(SIGNAL("asignal"),msg) | self.emit(SIGNAL("asignal"),msg) | ||
def | def receive(self,msg): | ||
print msg | print msg | ||
Line 125: | Line 164: | ||
app=QCoreApplication(sys.argv) | app=QCoreApplication(sys.argv) | ||
a=A() | a=A() | ||
QObject.connect(a,SIGNAL("asignal"),a. | QObject.connect(a,SIGNAL("asignal"),a.receive) | ||
a.send() | a.send() | ||
sys.exit(app.exec_()) | sys.exit(app.exec_()) | ||
</ | </syntaxhighlight> | ||
==Signals and slots and threading== | ==Signals and slots and threading== | ||
To send signal across threads we have to use the Qt.QueuedConnection parameter. Without this parameter the code will be executed in the same thread. | To send signal across threads we have to use the Qt.QueuedConnection parameter. Without this parameter the code will be executed in the same thread. | ||
< | <syntaxhighlight lang="python"> | ||
import sys | import sys | ||
from time import time | from time import time | ||
Line 171: | Line 208: | ||
sys.exit(app.exec_()) | sys.exit(app.exec_()) | ||
</ | </syntaxhighlight> | ||
< | <syntaxhighlight lang="text"> | ||
Output: | Output: | ||
0s starting in __main__ | 0s starting in __main__ | ||
Line 190: | Line 227: | ||
3s finished in a() | 3s finished in a() | ||
3s finished in __main__ | 3s finished in __main__ | ||
</ | </syntaxhighlight> | ||
==QueuedConnections== | |||
[[Category:Python]] | [[Category:Python]] |
Latest revision as of 13:44, 31 May 2019
Abstract
The signal and slot architecture is designed to simplify communication between objects. GUI programming is mostly event-driven and conventionally uses callbacks. The limitations of callbacks are partly resolved by the signal and slot architecture that Qt uses. The idea is that all objects can emit signals.
When a button is clicked, for example, it emits a “clicked()” signal. Signals do nothing alone, but once connected to a slot, the code in the slot will be executed whenever the signal is emitted.
In the Python programs, every function is a slot. It is possible to connect one signal to multiple slots, and to connect slots consecutively. For instance, one event activates its slot and related subsequent events trigger another signal and the code in its slot to be executed.
Prerequisites
General understanding of the python programming language. No prior knowledge of QT is required.
Connecting signals and slots.
We use the QObject.connect() method to connect signals and slots.
bool connect (QObject, SIGNAL(), callable, Qt.ConnectionType = Qt.AutoConnection)
The first argument is the name of the object that is emitting the signal. The second argument is the signal, and the third argument is the slot. The slot has to bee a python callable object. Note that only QObjects and objects inheriting from QObject can emit signals.
Example
from PyQt4.QtGui import *
from PyQt4.QtCore import *
import sys
#First we create a QApplication and QPushButton
app=QApplication(sys.argv)
exitButton=QPushButton("Exit")
#Here we connect the exitButton's "clicked()" signals to the app's exit method.
#This will have the effect that every time some one clicks the exitButton
#the app.exit method will execute and the application will close.
QObject.connect(exitButton,SIGNAL("clicked()"),app.exit)
exitButton.show()
#Start the evnt loop
sys.exit(app.exec_())
Emitting signals
Only QObjects and objects inheriting from QObject can emit signals. To emit a signal we use the QObject.emit() method.
QObject.emit (self, SIGNAL(), ...)
emit() is an object method, the self parameter is therefor automatically inserted by the python interpreter. The next argument is the signal we would like to emit, for example it could have been SIGNAL("myfirstsignal()") if we wanted to emit a signal with that name. The next parameters is optional parameters that can be sent with the signal, will come back to that in more detail later.
Example:In this example we have a class with a function "afunc" that emits the signal "doSomePrinting()". The class also have function "bfunc" that prints "Hello world". First we create a object of the class then we connect the "doSomePrinting()" to "bfunc". After that we call "afunc". This will result in the printing of "Hello World" to the standard output
import sys
from time import time
from PyQt4.QtCore import *
class A (QObject):
def __init__(self):
QObject.__init__(self)
def afunc (self):
self.emit(SIGNAL("doSomePrinting()"))
def bfunc(self):
print "Hello World!"
if __name__=="__main__":
app=QCoreApplication(sys.argv)
a=A()
QObject.connect(a,SIGNAL("doSomePrinting()"),a.bfunc)
a.afunc()
sys.exit(app.exec_())
Signals and slots with parameters
The signal and slots mechanism is type safe. In C++ this implies that both the number of arguments and the type of the arguments in a signal must match the arguments in the receiving slot. In Qt's Signal and slots architecture the receiving slot can actually have fewer parameters than the emitted signal, the extra arguments will then be ignored. Because of pythons dynamically typed nature it not possible to do any type checking in advance. It is therefor important to make sure that the emitted object is of the expected type or of a type that can be automatically converted to the expected type. For example a python string will automatically be converted to QString. If we send a object of an incompatible type we will get an runtime error.
Example: This example will create a slider and display it. Every time the value of the slider is changed the new value will be printed to the standard output. The references documentation for QSlider can be found here, the valueChanged signal is inherited from QAbstractSlider
from PyQt4.QtGui import *
from PyQt4.QtCore import *
import sys
def printNumber(number):
print number
if __name__=="__main__":
#First we create a QApplication and QSlider
app=QApplication(sys.argv)
slider=QSlider(Qt.Horizontal)
QObject.connect(slider,SIGNAL("valueChanged(int)"),printNumber)
slider.show()
#Start the evnt loop
sys.exit(app.exec_())
Python objects as parameters
It's possible to send a python object of any type using PyQt_PyObject in the signature. This is recommended when both signal and slot is implemented in python. By using PyQt_PyObject we avoid unnecessary conversions between python objects and C++ types and it is more consistent with python dynamically typed nature.
Example
import sys
from time import time
from PyQt4.QtCore import *
class A (QObject):
def __init__(self):
QObject.__init__(self)
def send (self):
msg=[1234,"1234",{1:2}]
self.emit(SIGNAL("asignal(PyQt_PyObject)"),msg)
def receive(self,msg):
print msg
def p(msg): print int(time()-start),msg
if __name__=="__main__":
app=QCoreApplication(sys.argv)
a=A()
QObject.connect(a,SIGNAL("asignal(PyQt_PyObject)"),a.receive)
a.send()
sys.exit(app.exec_())
Short-circuit Signal
PyQt4 has a special type of signal called a short-circuit Signal. This signal implicitly declares all arguments to be of type PyQt_PyObject. Short-circuited signals do not have argument lists or parentheses. Short-circuited signals can only be connected to python slots.
The same example as above, using short-circuited signals.
import sys
from time import time
from PyQt4.QtCore import *
class A (QObject):
def __init__(self):
QObject.__init__(self)
def send (self):
msg=[1234,"1234",{1:2}]
self.emit(SIGNAL("asignal"),msg)
def receive(self,msg):
print msg
def p(msg): print int(time()-start),msg
if __name__=="__main__":
app=QCoreApplication(sys.argv)
a=A()
QObject.connect(a,SIGNAL("asignal"),a.receive)
a.send()
sys.exit(app.exec_())
Signals and slots and threading
To send signal across threads we have to use the Qt.QueuedConnection parameter. Without this parameter the code will be executed in the same thread.
import sys
from time import time
from PyQt4.QtCore import *
class A (QThread):
def __init__(self):
QThread.__init__(self)
def afunc (self):
p("starting in a()")
self.emit(SIGNAL("asignal"))
p("finished in a()")
def bfunc(self):
p("starting in b()")
self.sleep(3)
p("finished in b()")
def run(self):
self.exec_()
def p(msg): print str(int(time()-start)) + "s",msg
if __name__=="__main__":
start=time()
p("starting in __main__")
app=QCoreApplication(sys.argv)
a=A()
a.start()
QObject.connect(a,SIGNAL("asignal"),a.bfunc,Qt.QueuedConnection)
a.afunc()
p("finished in __main__")
sys.exit(app.exec_())
Output:
0s starting in __main__
0s starting in a()
0s finished in a()
0s finished in __main__
0s starting in b()
3s finished in b()
without Qt.QueuedConnection the example will output:
0s starting in __main__
0s starting in a()
0s starting in b()
3s finished in b()
3s finished in a()
3s finished in __main__