Ouvrir un fichier GUI à partir d'un autre fichier PyQT

Question

J'ai créé de nombreuses interfaces graphiques dans PyQT en utilisant QT Designer, mais maintenant j'essaie d'ouvrir une interface depuis un autre, et je ne sais pas comment le faire. Start.py est le fichier qui exécuter l'interface GUI Authentification_1 et Acceuil_start.py est le fichier qui exécuter l'interface graphique Acceuil_2.py, maintenant je veux de Start.py déjeuner Acceuil_start .py. Avez-vous une idée à ce sujet? Je vous remercie. Voici mon code:

Start.py :

import sys 
from PyQt4 import QtCore, QtGui 
from Authentification_1 import Ui_Fenetre_auth 
from Acceuil_2 import Ui_MainWindow #??? Acceuil_2.py is the file which I want to open 

class StartQT4(QtGui.QMainWindow): 
    def __init__(self, parent=None): 
     QtGui.QWidget.__init__(self, parent) 
     self.ui = Ui_Fenetre_auth() 
     self.ui.setupUi(self) 

    def authentifier(val): #Slot method 
     self.Acceuil = Acceuil() #??? 
     self.Acceuil.show() #??? 


if __name__ == "__main__": 
    app = QtGui.QApplication(sys.argv) 
    myapp = StartQT4() 
    myapp.show() 
    sys.exit(app.exec_()) 

Acceuil_start.py

import sys 
from PyQt4 import QtCore, QtGui 
from Authentification_1 import Ui_Fenetre_auth 
from Acceuil_2 import Ui_MainWindow 

class StartQT4(QtGui.QMainWindow): 
    def __init__(self, parent=None): 
     QtGui.QWidget.__init__(self, parent) 
     self.ui = Ui_MainWindow() 
     self.ui.setupUi(self) 


if __name__ == "__main__": 
    app = QtGui.QApplication(sys.argv) 
    myapp = StartQT4() 
    myapp.show() 
    sys.exit(app.exec_()) 

Answer 1

Tout d'abord, vous devez nommer vos classes GUI afin qu'ils aient un nom différent, et non le générique, vous pouvez donc les distinctes.

Pourquoi devriez-vous faire cela? Eh bien, simplement, parce que cela a du sens - si chaque classe représente un type de dialogue différent, donc c'est un type différent - et il devrait être nommé différemment. Certains des noms sont/peuvent être: QMessageBox, AboutBox, AddUserDialog, et ainsi de suite.

Dans Acceuil_start.py (vous devez également renommer la classe dans un autre module).

import sys 
from PyQt4 import QtCore, QtGui 
from Authentification_1 import Ui_Fenetre_auth 
from Acceuil_2 import Ui_MainWindow 

class Acceuil(QtGui.QMainWindow): 
    def __init__(self, parent=None): 
     QtGui.QWidget.__init__(self, parent) 
     self.ui = Ui_MainWindow() 
     self.ui.setupUi(self) 


if __name__ == "__main__": 
    app = QtGui.QApplication(sys.argv) 
    myapp = Acceuil() 
    myapp.show() 
    sys.exit(app.exec_()) 

dans la classe parente, lorsque vous voulez créer la fenêtre, vous êtes proche (mais il devrait fonctionner dans tous les cas):

def authentifier(val): #Slot method 
    self.Acceuil = Acceuil(self) # You should always pass the parent to the child control 
    self.Acceuil.show() #??? 

A propos de problème parent: Si votre widget/fenêtre est la création d'un autre widget, la mise en objet créateur d'être parent est toujours une bonne idée (en dehors de quelques cas singuliers), et vous devriez lire this de voir pourquoi est-ce si:

QObjects organize themselves in object trees. When you create a QObject with another object as parent, it's added to the parent's children() list, and is deleted when the parent is. It turns out that this approach fits the needs of GUI objects very well. For example, a QShortcut (keyboard shortcut) is a child of the relevant window, so when the user closes that window, the shorcut is deleted too.

Édition - Échantillon de travail minimal

Pour voir ce que j'essaie de vous dire, j'ai construit un exemple simple. Vous avez deux classes - MainWindow et ChildWindow. Chaque classe peut fonctionner sans autre classe en créant des objets distincts QApplication. Mais, si vous importez ChildWindow dans MainWindow, vous allez créer ChildWindow dans la fente connectée à la minuterie singleshot qui se déclenchera dans 5 secondes.

MainWindow.py:

import sys 
from PyQt4 import QtCore, QtGui 
from ChildWindow import ChildWindow 

class MainWindow(QtGui.QMainWindow): 
    def __init__(self, parent=None): 
     QtGui.QWidget.__init__(self, parent) 
     QtCore.QTimer.singleShot(5000, self.showChildWindow) 


    def showChildWindow(self): 
     self.child_win = ChildWindow(self) 
     self.child_win.show() 

if __name__ == "__main__": 
    app = QtGui.QApplication(sys.argv) 
    myapp = MainWindow() 
    myapp.show() 
    sys.exit(app.exec_()) 

ChildWindow.py:

import sys 
from PyQt4 import QtCore, QtGui 

class ChildWindow(QtGui.QMainWindow): 
    def __init__(self, parent=None): 
     QtGui.QWidget.__init__(self, parent) 
     self.setWindowTitle("Child Window!") 


if __name__ == "__main__": 
    app = QtGui.QApplication(sys.argv) 
    myapp = ChildWindow() 
    myapp.show() 
    sys.exit(app.exec_()) 

Answer 2

Pour référencer l'autre boîte de dialogue de Start.py, vous devez préfixer par le nom du module, qui dans ce cas est Acceuil_start. En tant que tel, il est OK s'il y a des noms de fonctions dupliqués dans chaque module.Donc, vous auriez:

def authentifier(val): #Slot method 
    dlg = Acceuil_start.StartQT4() 
    dlg.exec_() 

Cependant, si vous voulez courir à partir de ceux-ci pour le même processus, gardez à l'esprit que vous ne pouvez pas avoir deux app objets. Vous voudrez probablement structurer Acceuil_start.py pour qu'il agisse comme une boîte de dialogue plutôt qu'une fenêtre principale. S'il s'agit de deux fenêtres principales distinctes, il vous sera peut-être plus facile d'invoquer un autre interpréteur Python avec le paramètre Acceuil_start.py en tant que paramètre.