Qt for Python/Connecting QML Signals: Difference between revisions

From Qt Wiki
Jump to navigation Jump to search
No edit summary
 
 
(12 intermediate revisions by 5 users not shown)
Line 1: Line 1:
=Connecting <span class="caps">QML</span> signals in PySide=
[[Category:Qt for Python]]
[[Category:Developing_with_Qt::Qt Quick]]


This page describes a few alternative approaches for connecting signals between <span class="caps">QML</span> and PySide. Simple illustrative examples about the signal connectivity are also provided in the [http://qt.gitorious.org/pyside/pyside-examples/trees/master/examples/declarative/signals pyside-examples repository] ''[qt.gitorious.org]''. Browse the git tree directly or [http://qt.gitorious.org/pyside/pyside-examples/archive-tarball/master download a tarball of all examples] ''[qt.gitorious.org]'' and refer to the examples/declarative/signals directory.
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].


==Connecting signals from <span class="caps">QML</span> to Python==
== Connecting signals from QML to Python ==


Connecting a signal from <span class="caps">QML</span> to Python is the most common use case. This allows for example connecting button clicks and other user interface events in <span class="caps">QML</span> to the backend logic written in 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 <span class="caps">QML</span> 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).
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 <span class="caps">QML</span>===
=== Explicitly calling a Python slot from QML ===


If the Python object is exposed to <span class="caps">QML</span> using <code>setContextProperty</code>, you can call any slot of the object explicitly from <span class="caps">QML</span>, as shown in [http://qt.gitorious.org/pyside/pyside-examples/trees/master/examples/declarative/signals/qmltopy1 qmltopy1] ''[qt.gitorious.org]''. 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:


Then, the Python object is instantiated and connected to the <span class="caps">QML</span> context:
<syntaxhighlight lang="python" line="line">
class Console(QtCore.QObject):
    @QtCore.Slot(str)
    def outputStr(self, s):
        print(s)
</syntaxhighlight>


After this, the object is accessible in <span class="caps">QML</span> and any slot can be called just like a function:
Then, the Python object is instantiated and connected to the QML context:


===Returning a value from a slot===
<syntaxhighlight lang="python" line="line">
con = Console()
view = QtDeclarative.QDeclarativeView()
context = view.rootContext()
context.setContextProperty("con", con)
</syntaxhighlight>


It is possible for slots to return values to the <span class="caps">QML</span> caller (see example [http://qt.gitorious.org/pyside/pyside-examples/trees/master/examples/declarative/signals/qmltopy2 qmltopy2] ''[qt.gitorious.org]''). In this case, the Python slot needs to define an explicit return type:
After this, the object is accessible in QML and any slot can be called just like a function:


Then the Python object is exposed to <span class="caps">QML</span>, after which it can be called just like a function:
<syntaxhighlight lang="javascript" line="line">
MouseArea {
onClicked: {
con.outputStr("Hello, world!")
}
}
</syntaxhighlight>


===Connecting signals from <span class="caps">QML</span> to Python using a top-level <span class="caps">QML</span> signal===
=== Returning a value from a slot ===


If you prefer to handle the signal connection in Python, the simplest way to do it is to declare a top-level signal in <span class="caps">QML</span> and connect that to a Python slot as shown in [http://qt.gitorious.org/pyside/pyside-examples/trees/master/examples/declarative/signals/qmltopy3 example qmltopy3] ''[qt.gitorious.org]''.
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:


First, in the top-level <span class="caps">QML</span> item, declare the signal:
<syntaxhighlight lang="python" line="line">
@QtCore.Slot(result=int)
def val(self):
    self.r = self.r + 10
    return self.r
</syntaxhighlight>


Then, in some other <span class="caps">QML</span> item, make some other signal handler emit this signal:
Then the Python object is exposed to QML, after which it can be called just like a function:


Finally, in Python, acquire the <span class="caps">QML</span> root object and connect the signal:
<syntaxhighlight lang="javascript" line="line">
onClicked: {
    helloText.rotation = rotatevalue.val()
}
</syntaxhighlight>


This approach has the benefit of hiding the Python class behaviour from <span class="caps">QML</span>. On the other hand, this approach requires the Python code to have some knowledge of the <span class="caps">QML</span> item contents.
=== Connecting signals from QML to Python using a top-level QML signal ===


===Connecting a signal from a specific <span class="caps">QML</span> item to Python.===
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].


It is also possible to acquire a specific <span class="caps">QML</span> item and connect a signal directly to it as illustrated in [http://qt.gitorious.org/pyside/pyside-examples/trees/master/examples/declarative/signals/qmltopy4 example qmltopy4] ''[qt.gitorious.org]''.
First, in the top-level QML item, declare the signal:


In principle, this approach doesn’t require any extra consideration in <span class="caps">QML</span>. Unfortunately, in practice it may be difficult to find the proper <span class="caps">QML</span> items without assigning them object names:
<syntaxhighlight lang="javascript" line="line">
Rectangle {
    id: page
 
    signal textRotationChanged(double rot)
 
    […]
</syntaxhighlight>
 
Then, in some other QML item, make some other signal handler emit this signal:
 
<syntaxhighlight lang="javascript" line="line">
onRotationChanged: textRotationChanged(rotation)
</syntaxhighlight>
 
Finally, in Python, acquire the QML root object and connect the signal:
 
<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.
 
=== 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 [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:
 
<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 <code>findChild</code> 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:


Although initially tempting, this approach ties the <span class="caps">QML</span> and Python codebases pretty tightly to each other. Also, having to define the object names in <span class="caps">QML</span> makes the approach less than optimal.
<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.


==Connecting signals from Python to <span class="caps">QML</span>==
== Connecting signals from Python to QML ==


It is also possible to connect signals from Python to <span class="caps">QML</span> when e.g. changes in the model data need to be reflected in the UI. [http://qt.gitorious.org/pyside/pyside-examples/trees/master/examples/declarative/signals/pytoqml1 Example pytoqml1] ''[qt.gitorious.org]'' 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 <span class="caps">QML</span>:
First, a function is defined in QML:


<span class="caps">QML</span> functions appear as slots in Python, so it’s a simple matter to connect a signal to them:
<syntaxhighlight lang="javascript" line="line">
function updateRotater() {
    rotater.angle = rotater.angle + 45
}
</syntaxhighlight>


This allows for fairly clean and straightforward delivery of signals from Python to <span class="caps">QML</span>.
QML functions appear as slots in Python, so it's a simple matter to connect a signal to them:


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


* [[:Category:Developing with Qt|Developing_with_Qt]]
This allows for fairly clean and straightforward delivery of signals from Python to QML.
** [[:Category:Developing with Qt::Qt Quick|Qt_Quick]]
* [[:Category:LanguageBindings|LanguageBindings]]
** [[:Category:LanguageBindings::PySide|PySide]]

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.