Qt for Python/Connecting QML Signals: Difference between revisions

From Qt Wiki
Jump to navigation Jump to search
No edit summary
 
(11 intermediate revisions by 5 users not shown)
Line 1: Line 1:
[[Category:LanguageBindings::PySide]]<br />[[Category:Developing_with_Qt::Qt Quick]]<br />[toc align_right=&quot;yes&amp;quot; depth=&quot;3&amp;quot;]
[[Category:Qt for Python]]
[[Category:Developing_with_Qt::Qt Quick]]


= Connecting QML signals in PySide =
This page describes a few alternative approaches for connecting signals between QML and PySide. Simple illustrative examples about the signal connectivity are also provided in the [https://code.qt.io/cgit/pyside/pyside-setup.git/tree/examples/declarative/signals pyside-setup repository].
 
This page describes a few alternative approaches for connecting signals between QML and PySide. Simple illustrative examples about the signal connectivity are also provided in the &quot;pyside-examples repository&amp;quot;:http://qt.gitorious.org/pyside/pyside-examples/trees/master/examples/declarative/signals. Browse the git tree directly or &quot;download a tarball of all examples&amp;quot;:http://qt.gitorious.org/pyside/pyside-examples/archive-tarball/master and refer to the examples/declarative/signals directory.


== Connecting signals from QML to Python ==
== Connecting signals from QML to Python ==
Line 13: Line 12:
=== Explicitly calling a Python slot from QML ===
=== Explicitly calling a Python slot from QML ===


If the Python object is exposed to QML using &lt;code&amp;gt;setContextProperty&amp;lt;/code&amp;gt;, you can call any slot of the object explicitly from QML, as shown in &quot;qmltopy1&amp;quot;:http://qt.gitorious.org/pyside/pyside-examples/trees/master/examples/declarative/signals/qmltopy1. First, you define a class in Python, inheriting from QObject:
If the Python object is exposed to QML using <code>setContextProperty</code>, you can call any slot of the object explicitly from QML, as shown in [https://code.qt.io/cgit/pyside/pyside-setup.git/tree/examples/declarative/signals/qmltopy1 qmltopy1]. First, you define a class in Python, inheriting from QObject:


<code><br />class Console(QtCore.QObject):<br /> &amp;#64;QtCore.Slot(str)<br /> def outputStr(self, s):<br /> print s<br /></code>
<syntaxhighlight lang="python" line="line">
class Console(QtCore.QObject):
    @QtCore.Slot(str)
    def outputStr(self, s):
        print(s)
</syntaxhighlight>


Then, the Python object is instantiated and connected to the QML context:
Then, the Python object is instantiated and connected to the QML context:


<code><br />con = Console()<br />view = QtDeclarative.QDeclarativeView()<br />context = view.rootContext()<br />context.setContextProperty(&quot;con&amp;quot;, con)<br /></code>
<syntaxhighlight lang="python" line="line">
con = Console()
view = QtDeclarative.QDeclarativeView()
context = view.rootContext()
context.setContextProperty("con", con)
</syntaxhighlight>


After this, the object is accessible in QML and any slot can be called just like a function:
After this, the object is accessible in QML and any slot can be called just like a function:


<code><br />MouseArea {<br /> onClicked: {<br /> con.outputStr(&quot;Hello, world!&quot;)<br /> }<br />}<br /></code>
<syntaxhighlight lang="javascript" line="line">
MouseArea {
onClicked: {
con.outputStr("Hello, world!")
}
}
</syntaxhighlight>


=== Returning a value from a slot ===
=== Returning a value from a slot ===


It is possible for slots to return values to the QML caller (see example &quot;qmltopy2&amp;quot;:http://qt.gitorious.org/pyside/pyside-examples/trees/master/examples/declarative/signals/qmltopy2). In this case, the Python slot needs to define an explicit return type:
It is possible for slots to return values to the QML caller (see example [https://code.qt.io/cgit/pyside/pyside-setup.git/tree/examples/declarative/signals/qmltopy2 qmltopy2]). In this case, the Python slot needs to define an explicit return type:


<code><br /> &amp;#64;QtCore.Slot(result=int)<br /> def val(self):<br /> self.r = self.r + 10<br /> return self.r<br /></code>
<syntaxhighlight lang="python" line="line">
@QtCore.Slot(result=int)
def val(self):
    self.r = self.r + 10
    return self.r
</syntaxhighlight>


Then the Python object is exposed to QML, after which it can be called just like a function:
Then the Python object is exposed to QML, after which it can be called just like a function:


<code><br /> onClicked: {<br /> helloText.rotation = rotatevalue.val()<br /> }<br /></code>
<syntaxhighlight lang="javascript" line="line">
onClicked: {
    helloText.rotation = rotatevalue.val()
}
</syntaxhighlight>


=== Connecting signals from QML to Python using a top-level QML signal ===
=== Connecting signals from QML to Python using a top-level QML signal ===


If you prefer to handle the signal connection in Python, the simplest way to do it is to declare a top-level signal in QML and connect that to a Python slot as shown in &quot;example qmltopy3&amp;quot;:http://qt.gitorious.org/pyside/pyside-examples/trees/master/examples/declarative/signals/qmltopy3.
If you prefer to handle the signal connection in Python, the simplest way to do it is to declare a top-level signal in QML and connect that to a Python slot as shown in [https://code.qt.io/cgit/pyside/pyside-setup.git/tree/examples/declarative/signals/qmltopy3 example qmltopy3].


First, in the top-level QML item, declare the signal:
First, in the top-level QML item, declare the signal:


<code><br />Rectangle {<br /> id: page
<syntaxhighlight lang="javascript" line="line">
Rectangle {
    id: page


signal textRotationChanged(double rot)
    signal textRotationChanged(double rot)


[…]<br /></code>
    […]
</syntaxhighlight>


Then, in some other QML item, make some other signal handler emit this signal:
Then, in some other QML item, make some other signal handler emit this signal:


<code><br /> onRotationChanged: textRotationChanged(rotation)<br /></code>
<syntaxhighlight lang="javascript" line="line">
onRotationChanged: textRotationChanged(rotation)
</syntaxhighlight>


Finally, in Python, acquire the QML root object and connect the signal:
Finally, in Python, acquire the QML root object and connect the signal:


<code><br /> root = view.rootObject()<br /> root.textRotationChanged.connect(sayThis)<br /></code>
<syntaxhighlight lang="python" line="line">
root = view.rootObject()
root.textRotationChanged.connect(sayThis)
</syntaxhighlight>


This approach has the benefit of hiding the Python class behaviour from QML. On the other hand, this approach requires the Python code to have some knowledge of the QML item contents.
This approach has the benefit of hiding the Python class behaviour from QML. On the other hand, this approach requires the Python code to have some knowledge of the QML item contents.
Line 59: Line 91:
=== Connecting a signal from a specific QML item to Python. ===
=== Connecting a signal from a specific QML item to Python. ===


It is also possible to acquire a specific QML item and connect a signal directly to it as illustrated in &quot;example qmltopy4&amp;quot;:http://qt.gitorious.org/pyside/pyside-examples/trees/master/examples/declarative/signals/qmltopy4.
It is also possible to acquire a specific QML item and connect a signal directly to it as illustrated in [https://code.qt.io/cgit/pyside/pyside-setup.git/tree/examples/declarative/signals/qmltopy4 example qmltopy4].


In principle, this approach doesn't require any extra consideration in QML. Unfortunately, in practice it may be difficult to find the proper QML items without assigning them object names:
In principle, this approach doesn't require any extra consideration in QML. Unfortunately, in practice it may be difficult to find the proper QML items without assigning them object names:


<code><br /> MouseArea {<br /> id: buttonMouseArea<br /> objectName: &quot;buttonMouseArea&amp;quot;<br /> anchors.fill: parent<br /> }<br /></code>
<syntaxhighlight lang="javascript" line="line">
MouseArea {
    id: buttonMouseArea
    objectName: "buttonMouseArea"
    anchors.fill: parent
}
</syntaxhighlight>


Then, in Python, it is simple to find the desired item using &lt;code&amp;gt;findChild&amp;lt;/code&amp;gt; and connect a signal to it:
Then, in Python, it is simple to find the desired item using <code>findChild</code> and connect a signal to it:


<code><br /> button = root.findChild(QtCore.QObject,&quot;buttonMouseArea&amp;quot;)<br /> button.clicked.connect(lambda: sayThis(&quot;clicked button (signal directly connected)&quot;))<br /></code>
<syntaxhighlight lang="python" line="line">
button = root.findChild(QtCore.QObject,"buttonMouseArea")
button.clicked.connect(lambda: sayThis("clicked button (signal directly connected)"))
</syntaxhighlight>


Although initially tempting, this approach ties the QML and Python codebases pretty tightly to each other. Also, having to define the object names in QML makes the approach less than optimal.
Although initially tempting, this approach ties the QML and Python codebases pretty tightly to each other. Also, having to define the object names in QML makes the approach less than optimal.
Line 73: Line 114:
== Connecting signals from Python to QML ==
== Connecting signals from Python to QML ==


It is also possible to connect signals from Python to QML when e.g. changes in the model data need to be reflected in the UI. &quot;Example pytoqml1&amp;quot;:http://qt.gitorious.org/pyside/pyside-examples/trees/master/examples/declarative/signals/pytoqml1 illustrates how to do that.
It is also possible to connect signals from Python to QML when e.g. changes in the model data need to be reflected in the UI. [https://code.qt.io/cgit/pyside/pyside-setup.git/tree/examples/declarative/signals/pytoqml1 Example pytoqml1] illustrates how to do that.


First, a function is defined in QML:
First, a function is defined in QML:


<code><br /> function updateRotater() {<br /> rotater.angle = rotater.angle + 45<br /> }<br /></code>
<syntaxhighlight lang="javascript" line="line">
function updateRotater() {
    rotater.angle = rotater.angle + 45
}
</syntaxhighlight>


QML functions appear as slots in Python, so it's a simple matter to connect a signal to them:
QML functions appear as slots in Python, so it's a simple matter to connect a signal to them:


<code><br /> timer.timeout.connect(root.updateRotater)<br /></code>
<syntaxhighlight lang="python" line="line">
timer.timeout.connect(root.updateRotater)
</syntaxhighlight>


This allows for fairly clean and straightforward delivery of signals from Python to QML.
This allows for fairly clean and straightforward delivery of signals from Python to QML.

Latest revision as of 10:16, 9 February 2021


This page describes a few alternative approaches for connecting signals between QML and PySide. Simple illustrative examples about the signal connectivity are also provided in the pyside-setup repository.

Connecting signals from QML to Python

Connecting a signal from QML to Python is the most common use case. This allows for example connecting button clicks and other user interface events in QML to the backend logic written in Python.

There are multiple alternative methods for connecting QML signals to Python. The methods are not mutually exclusive; any of them can be used in a single program (and even for a single signal, if need be).

Explicitly calling a Python slot from QML

If the Python object is exposed to QML using

setContextProperty

, you can call any slot of the object explicitly from QML, as shown in qmltopy1. First, you define a class in Python, inheriting from QObject:

class Console(QtCore.QObject):
    @QtCore.Slot(str)
    def outputStr(self, s):
        print(s)

Then, the Python object is instantiated and connected to the QML context:

con = Console()
view = QtDeclarative.QDeclarativeView()
context = view.rootContext()
context.setContextProperty("con", con)

After this, the object is accessible in QML and any slot can be called just like a function:

MouseArea {
 onClicked: {
 con.outputStr("Hello, world!")
 }
}

Returning a value from a slot

It is possible for slots to return values to the QML caller (see example qmltopy2). In this case, the Python slot needs to define an explicit return type:

@QtCore.Slot(result=int)
def val(self):
    self.r = self.r + 10
    return self.r

Then the Python object is exposed to QML, after which it can be called just like a function:

onClicked: {
    helloText.rotation = rotatevalue.val()
}

Connecting signals from QML to Python using a top-level QML signal

If you prefer to handle the signal connection in Python, the simplest way to do it is to declare a top-level signal in QML and connect that to a Python slot as shown in example qmltopy3.

First, in the top-level QML item, declare the signal:

Rectangle {
    id: page

    signal textRotationChanged(double rot)

    []

Then, in some other QML item, make some other signal handler emit this signal:

onRotationChanged: textRotationChanged(rotation)

Finally, in Python, acquire the QML root object and connect the signal:

root = view.rootObject()
root.textRotationChanged.connect(sayThis)

This approach has the benefit of hiding the Python class behaviour from QML. On the other hand, this approach requires the Python code to have some knowledge of the QML item contents.

Connecting a signal from a specific QML item to Python.

It is also possible to acquire a specific QML item and connect a signal directly to it as illustrated in example qmltopy4.

In principle, this approach doesn't require any extra consideration in QML. Unfortunately, in practice it may be difficult to find the proper QML items without assigning them object names:

MouseArea {
    id: buttonMouseArea
    objectName: "buttonMouseArea"
    anchors.fill: parent
}

Then, in Python, it is simple to find the desired item using

findChild

and connect a signal to it:

button = root.findChild(QtCore.QObject,"buttonMouseArea")
button.clicked.connect(lambda: sayThis("clicked button (signal directly connected)"))

Although initially tempting, this approach ties the QML and Python codebases pretty tightly to each other. Also, having to define the object names in QML makes the approach less than optimal.

Connecting signals from Python to QML

It is also possible to connect signals from Python to QML when e.g. changes in the model data need to be reflected in the UI. Example pytoqml1 illustrates how to do that.

First, a function is defined in QML:

function updateRotater() {
    rotater.angle = rotater.angle + 45
}

QML functions appear as slots in Python, so it's a simple matter to connect a signal to them:

timer.timeout.connect(root.updateRotater)

This allows for fairly clean and straightforward delivery of signals from Python to QML.