Discussion :

[Maro_95]

Bonjour à tous,

J'ai récemment commencé une IHM en pyQt et je rencontre quelques problèmes... J'ai vu un sujet répondant à ma question mais la réponse envoyait vers un lien mort.

Alors voilà mon problème: avec QtDesigner j'ai créé une QMainWindow 'MainWindow' contenant un bouton 'Bouton' et un QWidget 'EmplacementFormulaire', et dans un autre fichier .ui j'ai créé un QWidget 'Formulaire'.

J'ai utilisé pyuic5 pour transformer ces deux fichiers en classes python (MainWindow.py et Formulaire.py) dont les fonctions de génération sont setupUi() par défaut. Mon but est simple: faire en sorte qu'en appuyant sur le bouton de la MainWindow, le formulaire apparaisse dans le widget EmplacementFormulaire.

Voici le code que j'ai jusque là:

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
 
import MainWindow
import Formulaire
from PyQt5 import QtWidgets
 
def montrer_formulaire(fenetre):
    formulaire = Formulaire.Ui_Formulaire()
    formulaire.setupUi(fenetre.EmplacementFormulaire)
    fenetre.EmplacementFormulaire.show()
 
def main():
    app = QtWidgets.QApplication(sys.argv)
 
    fenetre = Mainwindow.Ui_MainWindow()
    root = QtWidgets.QMainwindow()
    fenetre.setupUi(root)
    fenetre.Bouton.clicked.connect(lambda: montrer_formulaire(fenetre))
 
    root.show()
    sys.exit(app.exec_())
 
if _name_ == '_main__':
    main()

La fenêtre principale s'affiche correctement, on entre bien dans la fonction montrer_formulaire en appuyant sur le bouton, mais le formulaire ne s'affiche pas...

Une idée de ce qui cloche dans mon code?

Merci d'avance pour votre aide,
Mathilde

[tyrtamos]

Bonjour,

Le problème, c'est que QtDesigner produit un dessin de fenêtre, mais pas la fenêtre elle-même.

Le plus intéressant est de créer pour chaque fenêtre une classe héritant de la fenêtre modèle et de l'initialiser avec le setupUI correspondant.

Voilà un petit code de principe:

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
# -*- coding: utf-8 -*-
 
import sys
 
from PyQt5 import QtCore, QtGui, QtWidgets
 
from fenetre1_ui import Ui_MainWindow # importation du fichier fenetre1_ui.py issu de QtDesigner pour une fenêtre QMainWindow
 
from fenetre2_ui import Ui_Form # importation du fichier fenetre2_ui.py issu de QtDesigner pour une fenêtre QWidget
 
 
class Fenetre2(QtWidgets.QWidget):
 
    def __init__(self, parent=None):
        super().__init__(parent) # appel de l'ancêtre
        self.ui = Ui_Form()
        self.ui.setupUi(self)
 
        # les objets créés par QtDesigner seront accessibles dans la classe par self.ui.nomdelobjet
 
class Fenetre1(QtWidgets.QMainWindow):
 
    def __init__(self, parent=None):
        super().__init__(parent) # appel de l'ancêtre
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)
 
        # les objets créés par QtDesigner seront accessibles par self.ui.nomdelobjet
 
        # créer le lien pour connecter le bouton à la méthode "montrerformulaire"
 
    def montreformulaire(self):
        """lancé par le bouton pour afficher le formulaire
        """
        formulaire = Fenetre2(self)
        # possibilité de créer un lien (connect) pour que la fenêtre1 puisse recevoir des infos de la fenêtre2
        # possibilité de créer un lien (connect) pour que la fenêtre1 soit informée de la fermeture de la fenêtre 2
        # possibilité de dire si la fenêtre2 doit être modale ou non
        formulaire.show()
 
 
if __name__ == "__main__":
 
    # initialisation de la bibliothèque graphique
    app = QtWidgets.QApplication(sys.argv)
 
    # lancement de la fenêtre principale
    fenetre = Fenetre1()
    fenetre.show()
 
    # boucle de traitement des évènements
    sys.exit(app.exec_())

L'avantage de ce type de programmation est qu'on peut facilement ajouter tout ce que QtDesigner n'a pas ajouté. Par exemple ici l'appel de la fenêtre 2 par la fenêtre 1.

Et, puisque la fenêtre hérite d'une fenêtre modèle, on a à disposition tous ses attributs qu'on peut utiliser ou les réécrire (=surcharger) pour en changer le comportement!