1. Page d'accueil

Python Bindings Tools For QtV4

Utiliser Qt Designer

Qt Designer est l’outil Qt pour dessiner et construire des interfaces graphiques utilisateur. Il vous permettra de dessiner des widgets, des boites de dialogue ou des fenêtres complètes en utilisant des formulaires on-screen et une interface simplifiée de glisser-déposer. Il a la possibilité de vous afficher une pré-visualisation de vos réalisations afin de vous assurer qu’il génère bien ce que vous escomptiez, et vous permet d’en extraire des prototypes avec vos utilisateurs ( and to allow you to prototype them with your users), avant d’avoir à écrire tout code.

Qt Designer utilise des fichiers .ui en XML pour sauvegarder vos réalisations et ne génère pas de code de lui même. Qt inclut l’utilitaire uic pour générer du code C++ qui créé l’interface utilisateur. Qt inclut aussi la class QUiLoader qui permet a une application de charger un fichier .ui et de créer l’interface correspondante dynamiquement.

PyQt n’enveloppe pas la class QUiLoader mais à la place inclut le module Python uic. Tel QUiLoader ce module peut charger des fichier .ui afin de créer une interface utilisateur dynamiquement. Comme l’utilitaire uic il peu aussi générer le code Python, qui créera l’interface utilisateur. L’utilitaire pyuic4 de PyQt est une interface en ligne de commande pour le module uic. Les deux sont décris en détail dans les sections suivantes.

Utiliser le Code Généré

Le code qui a été généré a une structure identique à celui qui est généré par Qt uic et peut être utlilisé de la même manière.

Le code est struturé dans une unique classe qui est dérivée du type object Python. Le nom de la classe est le nom de l’objet de plus haut niveau dans Designer avec le préfix Ui_. (Dans la version C++ la classe est définit dans l’espace de nom Ui.) Nous faisons référence à cette classe comme la class form.

La classe contient une méthode appelé setupUi(). Celle-ci prend un seul argument qui est le widget dans lequel l’interface utilisateur est créée. Le type de cet argument (typiquement QDialog, QWidget ou QMainWindow) est définit dans Designer. Nous faisons référence à ce type ecomme la classe Qt de base.

Dans les exemples suivants nous considérons que un fichier .ui créé contient une boite de dialogue et le nom de l’object QDialog est ImageDialog. Nous considérons aussi que le nom du fichier contenant le code généré en python est ui_imagedialog.py. Le code généré peut alors être utilisé de plusieurs manières.

Le premier exemple montre l’approche directe ou nous créons une simple application pour créer une boite de dialogue :

import sys
from PyQt4 import QtGui
from ui_imagedialog import Ui_ImageDialog

app = QtGui.QApplication(sys.argv)
window = QtGui.QDialog()
ui ! Ui_ImageDialog()
ui.setupUi(window)

window.show()
sys.exit(app.exec_())

Le deuxième exemple montre l’approche par héritage unique ou l’on sous classe QDialog et configurons l’interface utilisateur dans la méthode init() :

from PyQt4 import QtCore, QtGui
from ui_imagedialog import Ui_ImageDialog

class ImageDialog(QtGui.QDialog):
   def init(self):
       QtGui.QDialog.init(self)

       # Configurons l'interface utilisateur depuis Designer.
       self.ui = Ui_ImageDialog()
       self.ui.setupUi(self)

       # Faisons quelques modifications locales.
       self.ui.colorDepthCombo.addItem("2 colors (1 bit per pixel)")

       # Connectons les boutons.
       self.connect(self.ui.okButton, QtCore.SIGNAL("clicked()"),
                    self, QtCore.SLOT("accept()"))
       self.connect(self.ui.cancelButton, QtCore.SIGNAL("clicked()"),
                    self, QtCore.SLOT("reject()"))

Le troisième exemple montre l’approche par héritage multiple :

from PyQt4 import QtCore, QtGui
from ui_imagedialog import Ui_ImageDialog

class ImageDialog(QtGui.QDialog, Ui_ImageDialog):
   def init(self):
       QtGui.QDialog.init(self)

       # Configurons l'interface utilisateur depuis Designer.
       self.setupUi(self)

       # Faisons quelques modifications locales.
       self.colorDepthCombo.addItem("2 colors (1 bit per pixel)")

       # Connectons les boutons.
       self.connect(self.okButton, QtCore.SIGNAL("clicked()"),
                    self, QtCore.SLOT("accept()"))
       self.connect(self.cancelButton, QtCore.SIGNAL("clicked()"),
                    self, QtCore.SLOT("reject()"))

Pour une description complète voir le Manuel Qt Designer dans la documentation de Qt.

Le Module uic

Le module uic contient les fonctions suivantes :

compileUi(uifile, pyfile, execute=False, indent=4)
Cette fonction génère le code Python qui créera l’interface utilisateur depuis un fichier .ui Qt Designer.
  • uifile est un nom de fichier ou un objet de type file (ou équivalent) contenant le fichier .ui.
  • pyfile est un object de type file (ou équivalent) vers l’endroit ou doit être généré le code en python.
  • excute est optionnellement indiqué si une petite quantité de code additionnel doit être généré qui affichera l’interface utilisateur si le code est exécuté en tant qu’une application autonome.
  • indent est le nombre optionnel d’espace utilisé pour l’indentation du code généré. Si est égal à zéro alors le caratère tabulation sera utilisé à la place.
loadUiType(uifile)
Cette fonctione charge un fichier .ui Qt Designer et revoie un tuple de classe form généré et la classe de base Qt. Cela peut être utilisé pour créer n’importe quel quantité d’instance de l’interface utilisateur sans avoir à parser (ndt. lire/décoder) le fichier .ui plus d’une fois.
  • uifile est le nom de fichier ou un objet de type file (ou équivalent) contenant le fichier .ui.
loadUi(uifile, baseinstance=None)
Cette fonction charge un fichier .ui Qt Designer et renvoie une instance de l’interface utilisateur.
  • uifile est le nom de fichier ou un objet de type file (ou équivalent) contenant le fichier .ui.
  • baseinstance est une instance optionnel de classe de base Qt. Si elle est spécifiée alors l’interface utilisateur y est créée. Sinon, une nouvelle instance de classe de base est automatiquement créée.

pyuic4

L’utilitaire pyuic4 est une interface en ligne de commande vers le module uic. Les commandes ont la syntax suivante :

pyuic4 options .ui-file

La liste complète des options de ligne de commande est :

OptionDescription
-h, --help Affiche le message d’aide sur la sortie standard (stdout).
--version Affiche le numéro de version sur la sortie standard (stdout) .
-i N, --indent=N Le code Python est généré en utilisant une indentation de N espace. Si N est 0 alors les tabulations sont utilisé. Le défaut est de 4.
-o FILE, --output=FILE Le code Python généré est écrit dans le fichier File.
-p, --preview La UGI est créée dynamiquement et est affiché. Pas de code Python généré.
-x, --execute Le code Python généré inclus une petite quantité de code supplémentaire qui créé et affiche l’interface graphique utilisateur(IGU) lorsqu’il est exécuté en tant qu’application autonome.

Les commentaires sont fermé pour cet élément.