Discussion :

[Mimisator]

Bonjour,

J'ai besoin d'un petit coup de main dans la gestion d'une application avec plusieurs fenêtres.
J'ai créé plusieurs fenêtres de type QWidget. À partir de la première il est possible d'accéder aux autres avec des boutons.
Je peux ouvrir autant de fenêtres que je souhaite, elles ne sont pas modales. (Je retrouve là l'utilisation de Toplevel en Tkinter)

Pour cela je me suis aidée de ces deux sujets :
https://www.developpez.net/forums/d1...xieme-fenetre/
https://www.developpez.net/forums/d6...es-meme-temps/

Et voici mon code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
from PyQt5.QtWidgets import *
from PyQt5.QtCore import *
import os,sys
 
#improtation des GUI
from accueil import *
from conversion_visco import *
 
class FenetreAccueil(QWidget,Ui_Aide_aux_calculs_et_conversions):
 
    def __init__(self,parent=None):
        QWidget.__init__(self)
        self.setupUi(parent)
 
        #actions liées aux boutons
        self.button_conv_visco.clicked.connect(self.visco)
 
    def visco(self):
        """lance la fenetre associee a la conversion de viscosite"""
        self.viscowindows = FenetreConversionVisco(self)
        self.viscowindows.setWindowFlags(Qt.SubWindow)
 
        self.viscowindows.show()
 
 
class FenetreConversionVisco(QWidget):
 
    def __init__(self,parent=None):
        super(FenetreConversionVisco,self).__init__(parent)
        self.ui=Ui_conv_visco()
        self.ui.setupUi(self)
 
 
if __name__ == "__main__":
    a=QApplication(sys.argv)
    f=QWidget()
    c=FenetreAccueil(f)
    f.show()
    r=a.exec_()
 
    sys.exit(app.exec_())

J'aimerais juste que la fermeture de la fenêtre "accueil", entraine la fermeture de toutes les autres fenêtres potentiellement ouvertes.

Merci d'avance pour votre aide.

Ps: je suis preneuse de tout autre commentaire sur mon code pour m'améliorer.

[tyrtamos]

Bonjour,

J'ai fait un petit code de principe pour expliquer ce que je fais:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
#!/usr/bin/python3
# -*- coding: utf-8 -*-
 
import sys
from PyQt5 import QtCore, QtWidgets
 
#############################################################################
class Fenetre2(QtWidgets.QWidget):
 
    # crée un nouveau signal qui permettra, si nécessaire, de renvoyer des 
    # données à l'appelant
    fermeturefen2 = QtCore.pyqtSignal()
 
    #========================================================================
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setWindowTitle("Fenetre2")
        self.resize(400, 300)
 
    #========================================================================
    def closeEvent(self, event):
        """à la fermeture de cette fenêtre 2, celle-ci envoie un signal à la 
           fenêtre 1 appelante
        """
        self.fermeturefen2.emit() 
        event.accept()
 
#############################################################################
class Fenetre1(QtWidgets.QWidget):
 
    #========================================================================
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setWindowTitle("Fenetre 1")
        self.resize(300, 200)
 
        # crée un bouton
        self.bouton = QtWidgets.QPushButton("Lancer la 2ème fenêtre!", self)
        self.bouton.clicked.connect(self.appelfen2)
 
        # positionne le bouton dans la fenêtre
        posit = QtWidgets.QGridLayout()
        posit.addWidget(self.bouton, 0, 0)
        self.setLayout(posit)
 
        # initialise la variable de la fenêtre 2
        self.fenetre2 = None
 
    #========================================================================
    def appelfen2(self):
        """méthode appelée par le bouton, Lance la deuxième fenêtre
        """
        if self.fenetre2==None:
            self.fenetre2 = Fenetre2()
            # prépare la future fermeture de la fenêtre 2 
            self.fenetre2.fermeturefen2.connect(self.fen2close)
            # affiche la 2ème fenêtre
            self.fenetre2.show()
 
    #========================================================================
    def fen2close(self):
        """méthode appelée par la fermeture de la fenêtre 2
        """
        self.fenetre2 = None
 
    #========================================================================
    def closeEvent(self, event):
        """méthode appelée lors de la fermeture de la fenêtre 1
        """
        if self.fenetre2 != None:
            # la fenêtre 2 est encore ouverte: on la ferme!
            self.fenetre2.close()
            self.fenetre2 = None
            print("Fenêtre 2 fermée")
        print("Fenêtre 1 fermée")
        event.accept()    
 
#############################################################################
if __name__ == "__main__":
    app = QtWidgets.QApplication(sys.argv)
    fenetre1 = Fenetre1()
    fenetre1.show()
    sys.exit(app.exec_())

En fait, il faut:
- que la 2ème fenêtre puisse indiquer à la 1ère par un signal, qu'elle est en train de se fermer,
- et que la 1ère fenêtre puisse tester à sa fermeture que la 2ème fenêtre n'est pas fermée.

Dans les 2 cas, la méthode closeEvent est exécutée à la fermeture de la fenêtre, quelque soit la méthode utilisée pour ça (self.close(), bien sûr, mais aussi la croix de la fenêtre ou son menu système)

A noter que le signal de fermeture de la fenêtre 2 peut très bien renvoyer des données à la fenêtre 1 (il faut le signaler à la création du signal).

[Mimisator]

Merci Tyrtamos pour ta réponse.

Je viens de la tester ça marche très bien !

Seul petit bémol dans mon cas j'aurai aimé conservé la possibilité d'ouvrir plusieurs fois la même fenêtre.
Dans ton exemple cela reviendrait à ouvrir plusieurs fois la fenêtre 2, or la variable qui permet de savoir si la fenêtre est ouverte ou non bloque cette possibilité.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
# initialise la variable de la fenêtre 2
        self.fenetre2 = None

Est-il possible de contourner cela ? La seule idée qui me vient est la mise en place dun compteur à la place du None qui testerait si le nombre de fenêtres ouvertes est non nul, mais je ne sais pas si c'est la meilleure solution.
Mreci d'avance

[tyrtamos]

Ça complique un peu, mais le principe est le même. J'ai déjà fait ça dans mes programmes.

Au lieu d'une variable pour porter la fenêtre 2, on a une liste de variables pour pointer sur plusieurs fenêtres 2.

A chaque lancement d'une nouvelle fenêtre 2, il faut lui passer l'indice qu'elle a dans la liste comme argument.

Et le signal de fermeture d'un des fenêtres 2 doit transmettre aussi son indice pour que la fenêtre 1 sache qu'elle fenêtre 2 a été fermée.

Voilà le code précédent adapté:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
#!/usr/bin/python3
# -*- coding: utf-8 -*-
 
import sys
from PyQt5 import QtCore, QtWidgets
 
#############################################################################
class Fenetre2(QtWidgets.QWidget):
 
    # crée un nouveau signal de fermeture qui portera l'indice de la fenêtre 
    fermeturefen2 = QtCore.pyqtSignal(int)
 
    #========================================================================
    def __init__(self, ind, parent=None):
        super().__init__(parent)
        self.ind = ind # indice de la fenêtre
        self.setWindowTitle("Fenetre2 d'indice {}".format(self.ind))
        self.resize(400, 300)
 
    #========================================================================
    def closeEvent(self, event):
        """à la fermeture de cette fenêtre 2, celle-ci envoie un signal à la 
           fenêtre 1 appelante avec l'indice de la fenêtre
        """
        self.fermeturefen2.emit(self.ind) 
        event.accept()
 
#############################################################################
class Fenetre1(QtWidgets.QWidget):
 
    #========================================================================
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setWindowTitle("Fenetre 1")
        self.resize(300, 200)
 
        # crée un bouton
        self.bouton = QtWidgets.QPushButton("Lancer une 2ème fenêtre!", self)
        self.bouton.clicked.connect(self.appelfen2)
 
        # positionne le bouton dans la fenêtre
        posit = QtWidgets.QGridLayout()
        posit.addWidget(self.bouton, 0, 0)
        self.setLayout(posit)
 
        # initialise le liste des variables des fenetres 2
        self.fenetre2 = []
 
    #========================================================================
    def appelfen2(self):
        """méthode appelée par le bouton, Lance la deuxième fenêtre
        """
        # cherche un indice non utilisé dans la liste self.fenetre2
        ind = -1
        for i in range(0, len(self.fenetre2)):
            if self.fenetre2[i]==None:
                ind = i
                break
        if ind==-1:
            # aucune place vide, on crée un nouvel indice
            self.fenetre2.append(None)
            ind = len(self.fenetre2)-1 
 
        # crée une nouvelle fenêtre 2 d'indice ind
        self.fenetre2[ind] = Fenetre2(ind)
        # prépare la future fermeture de la fenêtre 2 d'indice ind 
        self.fenetre2[ind].fermeturefen2.connect(self.fen2close)
        # affiche cette 2ème fenêtre
        self.fenetre2[ind].show()
 
    #========================================================================
    def fen2close(self, ind):
        """méthode appelée par la fermeture de la fenêtre 2 d'indice ind
        """
        self.fenetre2[ind] = None
 
    #========================================================================
    def closeEvent(self, event):
        """méthode appelée lors de la fermeture de la fenêtre 1
        """
        for i in range(0, len(self.fenetre2)):
            if self.fenetre2[i]!=None:
                # la fenêtre 2 d'indice i est encore ouverte: on la ferme!
                self.fenetre2[i].close()
                self.fenetre2[i] = None
                print("Fenêtre 2 indice {} fermée".format(i))
        print("Fenêtre 1 fermée")
        event.accept()    
 
#############################################################################
if __name__ == "__main__":
    app = QtWidgets.QApplication(sys.argv)
    fenetre1 = Fenetre1()
    fenetre1.show()
    sys.exit(app.exec_())

Au fur et à mesure qu'on ferme l'une des fenêtres 2 ouvertes, on crée des "trous" dans la liste self.fenetre2. Alors, quand on ouvre une nouvelle fenetre 2, on cherche d'abord si l'une des positions de la liste n'est pas inutilisée (==None). Sinon, on augmente la taille de la liste. Cela permet de conserver une taille mini de cette liste.

[Mimisator]

Bonjour,

Ultime petite question.
Si on se place dans le cas d'une action sur la fenêtre 2 qui renvoie une information à la fenêtre 1. (comme dans cet exemple : https://www.developpez.net/forums/d6...es-meme-temps/)

J'ai adapté le code sous la forme suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
# -*- coding: utf-8 -*--
#!/usr/bin/env python
 
from PyQt5 import QtCore, QtWidgets
import sys
 
############################################################################# 
class Window(QtWidgets.QWidget):
 
    def __init__(self, parent = None):
 
        QtWidgets.QWidget.__init__(self, parent)
        self.setWindowTitle(self.tr("Principale"))
        self.bout=QtWidgets.QPushButton()
        self.bout.setText(self.tr("Nouvelle fenêtre"))
        self.text=QtWidgets.QTextEdit()
        self.bout.clicked.connect(self.newWindow)
        layout=QtWidgets.QVBoxLayout()
        layout.addWidget(self.bout)
        layout.addWidget(self.text)
        self.setLayout(layout)
 
        # initialise la variable de la fenêtre 2
        self.new = []
 
    def newWindow(self):
        ind=-1
        for i in range(0,len(self.new)):
            if self.new[i]==None:
                ind =i
                break
        if ind==-1:
            self.new.append(None)
            ind=len(self.new)-1
 
        self.new[ind]=NewWindow(ind)
        #action du bouton de la fenetre 2
        self.new[ind].clicbouton.connect(self.affichage)                           
        # prépare la future fermeture de la fenêtre 2 
        self.new[ind].fermeturefen2.connect(self.fen2close)
        #self.new.setWindowFlags(QtCore.Qt.Window) 
        # affiche la 2ème fenêtre
        self.new[ind].show()
 
        #========================================================================
    def fen2close(self,ind):
        """méthode appelée par la fermeture de la fenêtre 2
        """
        self.new[ind] = None
 
        #========================================================================
    def affichage(self,ind):
        """affichage dans la fenêtre 1"""
        self.text.append("Action sur fenetre2 n°{}".format(ind))
 
 
    #========================================================================
    def closeEvent(self, event):
        """méthode appelée lors de la fermeture de la fenêtre 1
        """
        for i in range(0, len(self.new)):
            if self.new[i]!=None:
                # la fenêtre 2 d'indice i est encore ouverte: on la ferme!
                self.new[i].close()
                self.new[i] = None
                print("Fenêtre 2 indice {} fermée".format(i))
        print("Fenêtre 1 fermée")
        event.accept
 
############################################################################# 
class NewWindow(QtWidgets.QWidget):
 
    fermeturefen2 = QtCore.pyqtSignal(int)
    clicbouton=QtCore.pyqtSignal(int)
 
    def __init__(self,ind, parent = None):
 
        super().__init__(parent)
        self.ind=ind
        self.setWindowTitle(self.tr("nouvelle fenetre"))
        self.bouton=QtWidgets.QPushButton()
        self.bouton.setText(self.tr("Clic"))
        self.bouton.clicked.connect(self.onClic)
        layout=QtWidgets.QVBoxLayout()
        layout.addWidget(self.bouton)
        self.setLayout(layout)
 
    def onClic(self,event):
        """capture l'action sur le bouton, pour envoyer le signal à la 
        fenêtre 1"""
        self.clicbouton.emit(self.ind)
        event.accept()
 
    def closeEvent(self, event):
        """à la fermeture de cette fenêtre 2, celle-ci envoie un signal à la 
           fenêtre 1 appelante
        """
        self.fermeturefen2.emit(self.ind) 
        event.accept()
 
############################################################################# 
if __name__=='__main__':
    app = QtWidgets.QApplication(sys.argv)
    ui = Window()
    ui.show()
    sys.exit(app.exec_())

Dans l'exemple l'action sur le bouton de la fenêtre 2 était lié à une méthode dans la class de NewWindow.
Pour que cela fonctionne dans le nouveau cas j'ai du me placer dans la classe de la première fenêtre.

Existe-t-il un moyen de conserver la structure de l'exemple ? Que les méthodes liées à des actions dans les fenêtres secondaires restent dans leur classe ?

J'espère que ma question est claire.
Certes mon code fonctionne ainsi, mais je trouverais cela plus commode de conserver les méthodes liées à des actions dans une fenêtre donnée dans sa class.

[pierjean]

Bonjour,
Y'a-t-il un avantage de faire de cette manière (avec les closeEvent), plutôt que d'utiliser les WindowFlags ?
Si on met fenetre1 parent de fenetre2, tout est fermé quand on quitte fenetre1.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#!/usr/bin/python3
# -*- coding: utf-8 -*-
 
import sys
from PyQt5 import QtCore, QtWidgets, QtGui
 
#############################################################################
class Fenetre2(QtWidgets.QWidget):
 
    def __init__(self, parent=None):
        super(Fenetre2,self).__init__(parent)
        self.setWindowTitle("Fenetre2")
        self.resize(400, 300)
 
 
#############################################################################
class Fenetre1(QtWidgets.QWidget):
 
    #========================================================================
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setWindowTitle("Fenêtre 1")
        self.resize(300, 200)
 
        # cree un bouton
        self.bouton = QtWidgets.QPushButton("Lancer la 2eme fenêtre!", self)
        self.bouton.clicked.connect(self.appelfen2)
        # positionne le bouton dans la fenetre
        posit = QtWidgets.QGridLayout()
        posit.addWidget(self.bouton, 0, 0)
        self.setLayout(posit)
 
 
    #========================================================================
    def appelfen2(self):
        """méthode appelée par le bouton, Lance la deuxième fenêtre
        """
        fen=Fenetre2(self)
        fen.setWindowFlags(QtCore.Qt.Window)
        fen.show()

[Mimisator]

Bonsoir,

Je viens de tester cette méthode mais lors de la fermeture de la fenêtre 1 cela ne ferme pas la fenêtre 2. (sauf si j'ai mal fait quelque chose, mais avec un copier coller normalement on s'en sort )

Sinon c'est sur que l'utilisation des setWindowFlag est plus simple.

[tyrtamos]

Bonsoir,

Y'a-t-il un avantage de faire de cette manière (avec les closeEvent), plutôt que d'utiliser les WindowFlags ?

L'avantage de la solution que j'ai proposée (et que j'utilise) est qu'il est facile avec le signal de fermeture de la fenêtre 2 de renvoyer des données à la fenêtre 1, situation ce que j'ai souvent rencontrée. Un peu comme une boîte de message qui renvoie une réponse de l'utilisateur à sa fermeture.