Utilisation d'un fichier Designer UI dans votre application Qt for Python

Conversion du formulaire en code Python

Pour la démonstration, nous utilisons l'exemple d'assouplissement de l'animation Qt Widgets.

L'application se compose d'un fichier source, easing.py, d'un fichier d'interface utilisateur form.ui, d'un fichier de ressources easing.qrc et d'un fichier de projet, easing.pyproject au format YAML :

{
    "files": ["easing.qrc", "ui_form.py", "easing.py", "easing_rc.py",
              "form.ui"]
}

Le fichier UI est converti en code Python pour construire le formulaire à l'aide de User Interface Compiler (uic) :

uic -g python form.ui > ui_form.py

Le widget de premier niveau étant nommé Form, une classe Python nommée Ui_Form est générée. Elle fournit une fonction setupUi(), prenant le widget comme paramètre, qui est appelée pour créer les éléments de l'interface utilisateur :

from ui_form import Ui_Form
...
class Window(QtWidgets.QWidget):
    def __init__(self, parent=None):
        super(Window, self).__init__(parent)

        self.m_ui = Ui_Form()
        self.m_ui.setupUi(self)

Par la suite, il est possible d'accéder aux widgets par l'intermédiaire de la classe Ui_Form:

self.m_ui.graphicsView.setScene(self.m_scene)

Outre setupUi(), Ui_Form fournit une autre méthode retranslateUi(), qui peut être appelée en réaction à un QEvent de type QEvent.LanguageChange, qui indique un changement dans la langue de l'application.

L'approche UiTools

La classe QUiLoader fournit un objet de chargement de formulaire pour construire l'interface utilisateur au moment de l'exécution. Cette interface utilisateur peut être récupérée à partir de n'importe quel objet QIODevice, par exemple un objet QFile. La fonction QUiLoader::load() construit le widget du formulaire en utilisant la description de l'interface utilisateur contenue dans le fichier.

Elle est démontrée par l'exemple uiloader :

from PySide2.QtUiTools import QUiLoader

if __name__ == '__main__':
    # Some code to obtain the form file name, ui_file_name
    app = QApplication(sys.argv)
    ui_file = QFile(ui_file_name)
    if not ui_file.open(QIODevice.ReadOnly):
        print("Cannot open {}: {}".format(ui_file_name, ui_file.errorString()))
        sys.exit(-1)
    loader = QUiLoader()
    widget = loader.load(ui_file, None)
    ui_file.close()
    if not widget:
        print(loader.errorString())
        sys.exit(-1)
    widget.show()
    sys.exit(app.exec_())

Importation de ressources

Utilisation dans un seul répertoire

Lors de l'utilisation d'icônes provenant de fichiers de ressources, par exemple resources.qrc, uic génère une importation du formulaire :

import resources_rc

Cela suppose qu'un fichier resources_rc.py généré en appelant l'outil Resource Compiler (rcc) (en passant l'option de ligne de commande -g python ) existe dans le même répertoire que la source du formulaire.

uic L'option de ligne de commande --rc-prefix fait précéder l'indicateur rc:

import rc_resources

L'option de ligne de commande --from-imports fait en sorte que les importations soient générées relativement à '.' :

from . import resources_rc

Arbres de répertoires

Certains projets ont des arborescences de répertoires plus complexes, par exemple :

project
    resources   (resources.qrc)
    ui          (.ui files)

Le fichier de ressources n'est alors pas dans le même répertoire que le formulaire source et les fichiers .ui ont généralement des chemins relatifs vers les fichiers de ressources :

<include location="../resources/resources.qrc"/>

Dans ce cas, l'option de ligne de commande --absolute-imports peut être utilisée pour générer un import absolu en Python, ce qui donne :

import resources.resources_rc

en partant du principe que .. est le répertoire racine du projet contenu dans la liste des chemins d'importation Python.

Pour les arbres plus profondément imbriqués, il est possible d'utiliser l'option de ligne de commande --python-paths <path list> pour transmettre une liste de chemins d'importation Python. uic essaiera alors de déterminer la racine du projet en faisant correspondre le chemin d'accès du fichier de formulaire aux composants du chemin d'accès.

Si --python-paths n'est pas fourni, la variable d'environnement PYTHONPATH est vérifiée par défaut.