Wechselstube

Das folgende Programmierbeispiel enthält die wesentlichen Elemente der Anwendungsprogrammierung mit Py Side. Es handelt sich um einen Währungsumrechner, der auf die im Internet frei verfügbare XML-RPC-Schnittstelle von [http://foxrate.org] zugreift, um die aktuellen Kurse zu beziehen. Zunächst erstellt der Entwickler das GUI: Nach dem Start von Qt Creator wählt er den Menü-Eintrag »Datei | Neu ... | Dateien und Klassen | Qt| Qt-Designer-Formular« , um eine UI-Datei anzulegen. Anschließend gilt es, das Mutterelement zu bestimmen. Im Falle eines neuen GUI-Projekts ist das »Main Window« .

Nach der Namensgebung sowie der Angabe des Speicherorts präsentiert sich die Oberfläche wie in Abbildung 1. Die Elemente lassen sich per Drag&Drop aus dem GUI-Klassenbereich in die zukünftige Benutzerschnittstelle ziehen. Die Klassen- und Objektübersicht verdeutlicht die Hierarchie der einzelnen Elemente. Eigenschaften wie geometrische Größen oder Masken für Eingabefelder legt der Anwender im Eigenschaftsfenster rechts unten fest.

Abbildung 1: Die grafische Oberfläche des Beispielprojekts in Qt Creator.

Die fertigen UI-Dateien sowie der gesamte Quelltext für diesen Artikel stehen unter [10] zum Download bereit. Die Dateien »customwidget.ui« für das Hauptfenster sowie »mainwindow.ui« für ein benutzerspezifisches Widget lassen sich über den Datei-öffnen-Dialog in Qt Creator laden. Nach dem Bearbeiten überführt der Programmierer die UI-Dateien in Python-Skripte. Dazu dient das Programm »pyside-uic« aus den Py-Side-Tools:

pyside-uic customwidget.ui > customwidget.py
pyside-uic mainwindow.ui > mainwindow.py.

Listing 3 zeigt das Einbinden der generierten Klassen. Im weiteren Sinn arbeiten diese nach dem Prinzip des Factory-Pattern. Die Methode »setupUi()« der Factory-Objekte (Zeilen 5 und 9) erwartet als Parameter die zu initialisierenden Widgets. Im Falle des Hauptfensters steht hier »self« , da die Basisklasse ein »QMainWindow« ist. Für das benutzerdefinierte Widget erstellt der Code eine Instanz der Klasse »QWidget« (Zeile 7). Eine Alternative zu dieser Vorgehensweise ist das Laden von Widgets aus so genannten Ressourcendateien, wobei der Programmierer bereits fertig initialisierte Widget-Objekte erhält.

01 from customwidget import Ui_customWidget
02 from mainwindow import Ui_MainWindow
03
04 self.ui = Ui_MainWindow()
05 self.ui.setupUi(self)
06
07 self.centralwidget = QtGui.QWidget()
08 self.customwidget = Ui_customWidget()
09 self.customwidget.setupUi(self.centralwidget)
10 self.setCentralWidget(self.centralwidget)

Signale und Slots

Qt zeichnet sich bei der Kommunikation zwischen Objekten durch eine Besonderheit aus: Sie lässt sich mit Hilfe so genannter Signale und Slots bewerkstelligen [11]. Diese Mechanismen ähneln dem traditionellen Callback-Prinzip, sind jedoch flexibler. Callbacks sind nicht Typ-sicher. Eine Methode mit exakt den gewünschten Parametern ist oft nicht vorhanden oder vorhersehbar. Der Programmierer muss bei Callbacks genau wissen, welche Methoden samt zugehörigen Methodenparamtern aufzurufen sind.

In der Implementierung des Signal-Slot-Prinzips gibt es daher eine zusätzliche Abstraktionsschicht. Der Entwickler kann exakt festlegen, welche Methode (Slot) Qt beim Auftreten eines bestimmten Signals aufruft und welche Parametertypen diese erwartet. Die gewünschte Konfiguration gibt er beim Verbinden mit der »connect()« -Methode an.

Für den zusätzlich notwendigen Code sorgen bei kompilierten Sprachen wie C++ das Qt-Buildsystem Qmake sowie der Meta-Object-Compiler. Bei Py Side passiert dies zur Laufzeit im Hintergrund. Alle Klassen, die von »QObject« erben, können Signale und Slots verarbeiten. Es ist möglich, beliebig viele Signale mit einem Slot oder beliebig viele Slots mit einem Signal zu verbinden.

Bei der neuen Syntax ergeben sich die Typen der Methodenparameter aus dem Kontext: Listing 4 zeigt die zugrunde liegende Syntax. Zeile 3 deklariert ein benutzerdefiniertes Signal. Mit Hilfe der Methode »emit()« kann der Programmierer das Signal aussenden (Zeile 6). Die Zuordnung der gewünschten Slots erfolgt im Vorfeld mit »connect()« (Zeile 16). Die dem Signal beim Aufruf übergebenen Parameter bekommen alle verbundenen Slots weitergereicht (den Wert »20« von Zeile 6 an den Methodenparameter »pValue« in Zeile 20).

01 class CSomeClass(QtCore.QObject):
02
03     sProgress = QtCore.Signal(int)
04
05     def someMethod(self):
06         sProgress.emit(20)
07         #sProgress[int].emit(20)
08
09
10 class CSomeOtherClass(QtCore.QObject):
11
12     def __init__(self):
13         self.mSome = CSomeClass()
14
15     def someOtherMethod(self):
16         self.mSome.sProgress.connect(self.onSome)
17 #        QtCore.QObject.connect(self.mSome,
18 #                QtCore.SIGNAL('sProgress(int)'), self.onSome)
19
20     def onSome(self, pValue):
21         print "Called with value: " + str(pValue)

Bei grafischen Benutzeroberflächen senden Aktionselemente und Widgets wie etwa »QPushButton« Signale aus, wenn der Benutzer sie anklickt. Ist das Signal mit einer benutzerdefinierten Methode, dem Slot, durch »connect()« verbunden, wird diese aufgerufen. Ein weiteres Beispiel sind Aktionen, die bei der Wahl von Menüpunkten ausgesendet werden. Diesen Anwendungsfall zeigt die erweiterte Hauptfenster-Klasse in Listing 5 (Zeilen 16 und 17). Aus der grafischen Oberfläche kann der Benutzer nun das Programm beenden oder die Autoreninformation abfragen.

01 ][...]
02 class Gui_Qt(QtGui.QMainWindow):
03
04 def __init__(self, parent=None):
05 super(Gui_Qt, self).__init__(parent)
06
07 self.ui = Ui_MainWindow()
08 self.ui.setupUi(self)
09
10 self.centralwidget = QtGui.QWidget()
11 self.customwidget = Ui_customWidget()
12 self.customwidget.setupUi(self.centralwidget)
13 self.setCentralWidget(self.centralwidget)
14
15 # actions
16 self.ui.actionExit.triggered.connect(self.on_actionExit_triggered)
17 self.ui.actionAbout.triggered.connect(self.on_actionAbout_triggered)
18
19 def on_actionExit_triggered(self):
20 self.close()
21
22 def on_actionAbout_triggered(self):
23 QtGui.QMessageBox.about(self, "XML-RPC Currency Calculator",
24 "<html>&copy; Rainer Poisel und Marcus Nutzinger, 2011</html>")
25 [...]

Aus Gründen der Vollständigkeit ist in Listing 4 auch die ursprüngliche Syntax angegeben (Zeilen 7, 17 und 18). Diese findet sich hauptsächlich in Applikationen, die auf älteren Versionen der Py-Side-Bibliothek aufbauen. Hierbei musste der Entwickler die äquivalenten C++-Datentypen explizit beim Verbinden von Signalen mit deren zugehörigen Slots angeben.

Neben Signalen und Slots bietet Qt auch die Möglichkeit, so genannte Events zu verarbeiten. Diese sind für den Programmierer dann von Bedeutung, wenn er Ereignisse unterhalb des Widget-Levels auswerten muss. Ein Beispiel hierfür wäre, die aktuelle Position des Mauszeigers zu erfragen. Das Qt-Framework ruft die in den Schnittstellen der einzelnen Widgets vorgesehenen Callback-Routinen auf, sobald ein Event des entsprechenden Typs aufgetreten ist. Bei der Klasse »QWidget« ist dies die Methode »mouseMoveEvent()« .

Die Beispiel-Applikation soll den aktuellen Umrechnungskurs aus dem Internet holen. Da diese Operation unter Umständen länger dauert, erarbeitet der Entwickler eine Strategie, die die grafische Oberfläche ansprechbar hält. Glücklicherweise stellen die Entwickler von Qt und Py Side geeignete Mechanismen bereit.