Utilisation d'un fichier d'interface utilisateur du Designer d'Qt Widgets dans votre application Qt for Python

Conversion du formulaire en code Python

À titre d’illustration, nous utilisons l’exemple d’animation avec effet d’accélération/décélération d’ Qt Widgets.

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

[project]
name = "Easing Example"

[tool.pyside6-project]
files = ["easing.py", "form.ui"]

Le fichier d’interface utilisateur est converti en code Python qui construit le formulaire à l’aide de User Interface Compiler (uic):

uic -g python form.ui > ui_form.py

Comme le widget de niveau supérieur est nommé Form, cela entraîne la génération d’une classe Python nommée Ui_Form. Celle-ci fournit une fonction setupUi(), prenant le widget en 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, on peut accéder aux widgets via 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éponse à un événement « QEvent » de type QEvent.LanguageChange, indiquant un changement de langue de l’application.

L’approche UiTools

La classe ` QUiLoader ` fournit un objet chargeur de formulaire permettant de construire l’interface utilisateur lors 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 de formulaire à l’aide de la description de l’interface utilisateur contenue dans le fichier.

Ceci est illustré par l’exemple uiloader :

from PySide6.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.OpenModeFlag.ReadOnly):
        print(f"Cannot open {ui_file_name}: {ui_file.errorString()}")
        sys.exit(-1)
    loader = QUiLoader()
    widget = loader.load(ui_file, None)
    ui_file.close()
    if widget is None:
        print(loader.errorString())
        sys.exit(-1)
    widget.show()
    sys.exit(app.exec())

Importation de ressources

Utilisation d’un seul répertoire

Lorsque vous utilisez des icônes provenant de fichiers de ressources, par exemple resources.qrc, uic génère une importation sous la forme :

import resources_rc

Cela suppose qu’un fichier resources_rc.py, généré par l’appel de 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 dispose d’une option de ligne de commande --rc-prefix qui ajoute l’indicateur rc au début :

import rc_resources

L'option de ligne de commande --from-imports entraîne la génération des importations par rapport à « . » :

from . import resources_rc

Arbres de répertoires

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

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

Le fichier de ressources ne se trouve alors pas dans le même répertoire que le code source du formulaire et les fichiers ` .ui ` contiennent 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 une importation absolue en Python, ce qui donne :

import resources.resources_rc

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

Pour les arborescences plus profondément imbriquées, il est possible d’utiliser l’option de ligne de commande --python-paths <path list> afin de passer une liste de chemins d’importation Python. uic tentera alors de déterminer la racine du projet en faisant correspondre le chemin du fichier de configuration avec les composants du chemin.

Si l’option « --python-paths » n’est pas spécifiée, la variable d’environnement « PYTHONPATH » est vérifiée par défaut.