Discussion :

[LinC49]

Bonjour,

J'ai un petit souci sur mon application et j'espère que vous pourrez m'éclairer, je travail avec l'IDE Eric et en language PyQt4.
Je vous explique mon problème : j'ai un Widget : "PageAccueil" et qui par clique d'un bouton ouvre le 2ème Widget : "Menu", jusqu'ici tout va bien.
Les choses se compliquent bizarrement lors de l'ouverture d'un 3ème Widget : "Création" à partir d'un clique du bouton du 2ème Widget : "Menu".
Rien ne se passe, même un print("coucou") au clique ne donne rien à croire que mon 2ème Widget:"Menu" s'affiche mais n'est pas utilisable.

voici mon code
main.py

Code :

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

1
2
3
4
5
6
7
8
9
10
from PyQt4 import QtGui
from PageAccueil import MainWindow
from Menu import Form
import sys
 
if __name__ == "__main__":
   app = QtGui.QApplication(sys.argv)
   myapp = MainWindow()
   myapp.show()
   sys.exit(app.exec_())

menu.py

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
"""
Module implementing Form.
"""
import os
from PyQt4 import *
from PyQt4.QtGui import QWidget
from PyQt4.QtCore import pyqtSignature
 
from Ui_MenuCim import Ui_Form
from Ui_CimAjouterDocument import Ui_FormAjouter
 
class Form(QWidget, Ui_Form):
    """
    Class documentation goes here.
    """
    def __init__(self, parent = None):
        """
        Constructor
        """
        QWidget.__init__(self, parent)
        self.setupUi(self)
 
    @pyqtSignature("")
    def on_BtnCreer_clicked(self):
        """
        Slot documentation goes here.
        """
 
        self.Form = QtGui.QWidget()
        ui2 = Ui_Form()
        ui2.setupUi(self.Form)
        self.Form.show() 
 
        ##print("coucou")
 
        # TODO: not implemented yet

Je vous remerice d'avance pour votre futur aide.
Cordialement

[VinsS]

Salut,

Il n'y a pas d'utilité en Python de séparer le code en de si petits fichiers.

On n'est pas trop sur de 'où se trouve quoi ?'

Dans le deuxième script, la classe hérite de QWidget et de Ui_Form et dans l'__init__() tu fais self.setupUi(self). Ce setupUi est dans Ui_Form ?

Si oui, qu'est-ce-que ce setupUi() dans la fonction on_BtnCreer_clicked() ?

Où se trouve ce BtnCreer ? dans Ui_Form ? il n'y a vraiment pas moyen de connecter ce bouton de façon conventionnelle dans le script qui l'instancie ?

Code :

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

self.BtnCreer.clicked.connect(self.do_something)

On suppose, à te lire, qu'il s'agit de fenêtres indépendantes, alors autant créer des boites de dialogue avec le Designer. Tu y gagnera beaucoup de temps. Et nous y gagnerons en compréhension.

[LinC49]

Merci VinsS pour ta réponse,

Il n'y a pas d'utilité en Python de séparer le code en de si petits fichiers.

Alors en ce qui concerne les fichiers, c'est "Eric" qui les créer automatiquement c'est-à-dire que lorque je creer une form ac Designer (ici Menu.ui) et que je compile un Ui_Menu.py se creer et quand je veux générer du code le Menu.py se creer automatiquement pré-remplit avec le _init_ et on_btn_clicked(), j'ai juste l'action du bouton à écrire.
S'il y a meilleur facon, je suis preneuse surtout pour respecter le modèle MVC

Dans le deuxième script, la classe hérite de QWidget et de Ui_Form et dans l'__init__() tu fais self.setupUi(self). Ce setupUi est dans Ui_Form ?

Par ailleur,comme je te l'ai expliquer ci dessus, dans le fichier Menu.py, la class et l'__init__ s'est généré automatiquement via Ui_Menu.py et je suppose que oui ce setupUi est dans Ui_Form qui est dans Ui_Menu.py .
Ui_Menu.py (extrait)

Code :

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

1
2
3
4
5
6
7
class Ui_Form(object):
    def setupUi(self, Form):       
        Form.setObjectName(_fromUtf8("Form"))
        Form.setWindowModality(QtCore.Qt.ApplicationModal)
......
        self.BtnCreer = QtGui.QPushButton(self.verticalLayoutWidget_2)
        self.BtnCreer.setObjectName(_fromUtf8("BtnCreer"))

Si oui, qu'est-ce-que ce setupUi() dans la fonction on_BtnCreer_clicked() ?

en revange, le setupUi() dans la fonction btn: est celui du 3ème Widget : Creation c'est a dire dans le fichier Ui_Creation.py (class Form) <-- pas très malin de laisser Form je te l'accorde

J'ai choisi des Widget car par la suite je doit afficher des données d'une base de donnée et que je croyais que des Dialog permettait juste à l'utilisateur de cliquer ok ou annuler

J'espère avoir été claire, pas simple de s'expliquer surtout quand tu vois pas l'application

Cordialement

[VinsS]

Je comprend mieux maintenant.

Il a fallut que je vérifie avec Eric pour ça, tu as utilisé l'option 'Generate dialog code'. Je n'ai jamais utilisé ça, d'où mon étonnement.


Alors, pour ton 'BtnCreer', il ne réagit pas parce qu'il n'est pas connecté.

Ce qui veux dire qu'après un self.setupUi(), il faut ensuite connecter les signaux des widgets. Comme indiqué dans mon premier message.

Si tu nous montrais les trois fichiers au complet ce sera plus simple à te montrer comment procéder. D'autant plus que tu as une sous-fenêtre qui va appeller une sous-sous-fenêtre qui elle-même devra retourner des données au programme principal.

Ca n'a rien de compliqué, il suffit de bien organiser les appels de ces fenêtres.


Quelques remarques:

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
 
import os
from PyQt4 import *     # préférer from PyQt4 import QtGui, QtCore
from PyQt4.QtGui import QWidget
from PyQt4.QtCore import pyqtSignature
 
from Ui_MenuCim import Ui_Form  # préférer tout minuscule pour les noms de modules (fichiers)
from Ui_CimAjouterDocument import Ui_FormAjouter
 
class Form(QWidget, Ui_Form):
    """
    Class documentation goes here.
    """
    def __init__(self, parent = None):
        """
        Constructor
        """
        QWidget.__init__(self, parent)
        self.setupUi(self)
        # Ici, doivent venir les connexions
 
    @pyqtSignature("")
    def on_BtnCreer_clicked(self):
        """
        Slot documentation goes here.
        """
 
        self.Form = QtGui.QWidget()
        ui2 = Ui_Form()     # à mon avis, ce doit être Ui_FormAjouter()
        ui2.setupUi(self.Form)
        # Pareil pour les connexions des widgets de cette boîte de dialogue
        self.Form.show()

J'ai choisi des Widget car par la suite je doit afficher des données d'une base de donnée et que je croyais que des Dialog permettait juste à l'utilisateur de cliquer ok ou annuler

Les boîtes de dialogue peuvent être aussi complexes que tu veux, exemple: le menu de configuration d'Eric.

[LinC49]

Bonjour VinsS,

J'ai lu attentivement ta réponse, et effectivement je pense aussi que c'est un problème de connection des widgets. Mais après plusieurs tentatives impossibles de les connecter.

Je met à ta disposition les 3 fichiers pour que tu y vois plus claire, mes tentatives sont en commentaire. c'est surment une erreur dans la facon dont j'écrit la connection..

Merci à toi de prendre du temps pour résoudre mon problème

Cordialement

[VinsS]

Salut,

Ce n'est pas totalement inutile cette option d'Eric de créer le code prenant en charge la création des fenêtres, mais, dans ton cas ça ne présente aucun intérêt. Et ça fait beaucoup d'onglets ouvert dans l'éditeur pour peu de choses.

Si l'on rassemble tout dans le main script, ça donne ceci:

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
 
#! /usr/bin/python
#-*- coding: utf-8 -*-
import os
import sys
 
from PyQt4 import QtCore, QtGui
 
from Ui_PageAccueil import Ui_MainWindow
from Ui_MenuCim import Ui_Form
 
class MainApp(object):
    def __init__(self, *args):
        # args contient les arguments de la commande
 
        # instanciation de la fenêtre principale
        self.mw = Ui_MainWindow()
        self.mw.setupUi(MainWin)
 
        # connexions des widgets
        self.mw.BtnHermione.clicked.connect(self.on_hermione_clicked)
        self.mw.BtnIrma.clicked.connect(self.on_irma_clicked)
        self.mw.BtnEdwige.clicked.connect(self.on_edwige_clicked)
        self.mw.BtnIngres.clicked.connect(self.on_ingres_clicked)
        MainWin.show()
 
    def on_hermione_clicked(self):
        print "Hermione clicked"
        self.call_menu_dialog('hermione')
 
    def on_irma_clicked(self):
        print "Irma clicked"
 
    def on_edwige_clicked(self):
        print "Edwige clicked"
 
    def on_ingres_clicked(self):
        print "Ingres clicked"
 
    def call_menu_dialog(self, name):
        # name est celui qui demande le menu
        self.dial = QtGui.QDialog()
        menu = Ui_Form()
        menu.setupUi(self.dial)
        menu.BtnCreer.clicked.connect(self.on_creer_clicked)
        menu.BtnRevue.clicked.connect(self.on_revue_clicked)
        menu.txtRecherche.textChanged.connect(self.on_recherche_edited)
        menu.BtnFermer.clicked.connect(self.dial.close)
        self.dial.show()
 
    def on_creer_clicked(self):
        print u"Bouton Créer pressé"
 
    def on_revue_clicked(self):
        print u"Bouton Revue pressé"
 
    def on_recherche_edited(self, txt):
        print u"Recherche: {0}".format(txt)
 
if __name__ == "__main__":
    app = QtGui.QApplication(sys.argv)
    MainWin = QtGui.QMainWindow()
    myapp = MainApp(sys.argv)
    sys.exit(app.exec_())

donc tu n'as plus besoin des fichiers PageAccueil.py et MenuCim.py, toutes les connexions (les signaux) sont centralisées dans le script principal.

Et j'ai rajouté un signal sur la QLineEdit de recherche pour que tu voies comment le dialogue peut communiquer des données au programme principal en temps réel.