Apre un file GUI da un altro file PyQT

Question

Ho creato molte interfacce GUI in PyQT usando QT Designer, ma ora sto provando ad aprire un'interfaccia da un'altra e non so come farlo .. Start.py è il file che corrono l'interfaccia GUI Authentification_1 e Acceuil_start.py è il file che corrono l'interfaccia GUI Acceuil_2.py, ora voglio da Start.py a pranzo Acceuil_start .py. Avete qualche idea al riguardo? Grazie. Ecco il mio codice:

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

In primo luogo, si dovrebbe dare un nome alle classi GUI in modo da avere un nome diverso, e non quella generica, così da poter distinti loro.

Perché dovresti farlo? Bene - semplicemente, perché ha senso - se ogni classe rappresenta un diverso tipo di dialogo, quindi è di tipo diverso - e dovrebbe essere chiamato diversamente. Alcuni nomi sono/potrebbero essere: QMessageBox, AboutBox, AddUserDialog e così via.

In Acceuil_start.py (è necessario rinominare la classe anche in un altro modulo).

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_()) 

nella classe padre, quando si vuole creare la finestra, vi sono vicino (ma dovrebbe funzionare in ogni caso):

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

Chi questione principale: Se il tuo widget/finestra è la creazione di un altro widget, impostando oggetto creatore di essere genitore è sempre una buona idea (a parte alcuni casi singolari), e si dovrebbe leggere this vedere perché è così:

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.

Modifica - Esempio di lavoro minimo

Per vedere cosa sto cercando di dirti, ho creato un semplice esempio. Hai due classi: MainWindow e ChildWindow. Ogni classe può funzionare senza altra classe creando oggetti separati QApplication. Tuttavia, se importi ChildWindow in MainWindow, creerai ChildWindow nello slot collegato al timer singolo che si attiverà in 5 secondi.

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

Per fare riferimento l'altra finestra di dialogo da Start.py, è necessario premettere ad essa il nome del modulo, che in questo caso è Acceuil_start. In quanto tale, va bene se ci sono nomi di funzioni duplicati in ciascun modulo.Quindi, si avrebbe:

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

Tuttavia, se si desidera che questi per eseguire dallo stesso processo, tenere presente che non si possono avere due app oggetti. Probabilmente vorrai strutturare Acceuil_start.py per agire come una finestra di dialogo, piuttosto che come una finestra principale. Se si tratta di due finestre principali distinte, potrebbe essere più semplice invocare un altro interprete Python con Acceuil_start.py come parametro.