Comment préserver le code personnalisé lors de la refonte des interfaces utilisateur de Qt Designer en Python ?

Comment conserver les modifications de code lors de la refonte des interfaces utilisateur avec QtDesigner

Lors de l'utilisation de Qt Designer pour créer des interfaces graphiques pour les applications Python, il est frustrant de perdre les modifications de code personnalisées lors des interfaces utilisateur ultérieures refontes. Cet article explore une solution à ce problème et introduit le concept de fractionnement de la logique en fichiers Python distincts.

Maintenir les modifications de code

Pour éviter de perdre les modifications de code lors de la refonte de l'interface utilisateur à l'aide de Qt Designer, il est recommandé de créez un fichier secondaire qui implémente la logique de l'interface graphique, tout en gardant séparé le code généré par Qt Designer.

Par exemple, si le modèle MainWindow est utilisé dans "design.ui", convertissez-le en "Ui_Design.py" et créez un nouveau fichier "logic.py" pour implémenter la logique.

# Ui_Design.py (Generated from Qt Designer)
from PyQt5 import QtCore, QtGui, QtWidgets

class Ui_MainWindow(object):
    def setupUi(self, MainWindow):
        [...]

    def retranslateUi(self, MainWindow):
        [...]

# logic.py
from PyQt5 import QtCore, QtGui, QtWidgets
from Ui_Design import Ui_MainWindow

class Logic(QMainWindow, Ui_MainWindow):
    def __init__(self, *args, **kwargs):
        QMainWindow.__init__(self, *args, **kwargs)
        self.setupUi(self)

L'utilisation de cette approche garantit que les modifications de l'interface utilisateur apportées dans Qt Designer n'écrasera pas le code personnalisé dans "logic.py".

Répartition de la logique entre les fichiers en Python

Pour organiser et gérer davantage le code, vous pouvez diviser la classe logique en plusieurs fichiers, en garantissant que chaque fichier se concentre sur un aspect spécifique de la fonctionnalité.

Pour y parvenir, la classe logique doit suivre une structure spécifique :

class Logic(PyQtClass, DesignClass):
    def __init__(self, *args, **kwargs):
        PyQtClass.__init__(self, *args, **kwargs)
        self.setupUi(self)

Où :

• PyQtClass : Dépend du modèle Qt choisi (par exemple, QMainWindow pour Window, QWidget pour Widget).
• DesignClass : Est la classe générée par Qt Designer (par exemple, Ui_MainWindow).

Fermeture de PyQt MessageBox avec CloseEvent de la fenêtre parent

À titre d'exemple d'implémentation de logique dans des fichiers séparés, envisagez de créer un événement de fermeture gestionnaire qui affiche une boîte de message de confirmation avant de fermer l'application PyQt.

class Logic(QMainWindow, Ui_MainWindow):
    def __init__(self, *args, **kwargs):
        QMainWindow.__init__(self, *args, **kwargs)
        self.setupUi(self)
    def closeEvent(self, event):
        answer = QtWidgets.QMessageBox.question(
            self,
            'Are you sure you want to quit ?',
            'Task is in progress !',
            QtWidgets.QMessageBox.Yes,
            QtWidgets.QMessageBox.No)
        if answer == QtWidgets.QMessageBox.Yes:
            event.accept()
        else:
            event.ignore()

En divisant le code en fichiers séparés et en suivant la structure des classes logiques, vous pouvez facilement maintenir et étendre vos applications Python basées sur Qt tout en préservant les le code change au milieu des refontes de l’interface utilisateur.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!