Discussion :

[clement_74]

Bonjour,
je suis en train de structurer un peu mes programmes afin de faciliter les relectures et les modifications à venir.
j'aimerais faire du main (le fichier à partir duquel le programme se lance) un fichier très simple (taille<20 lignes) énumérant simplement chacune des étapes nécessaire au bon déroulement du programme.
j'ai réussi jusqu'à maintenant à tout affecter dans différents fichiers.

il me reste un point bloquant sur lequel je ne sais pas vraiment quelle approche aborder...

cela concerne la gestion des évènements widget.cliqued.connect(méthode)
en gros actuellement cela ressemble dans mes programmes à cela:

Code :

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

1
2
3
4
5
6
7
8
class Fenetre_Principale(QMainWindow):
    def __init__(self):
        QMainWindow.__init__(self)
 
        self.bouton_charger.clicked.connect(self.fonction_charger_main)
 
    def fonction_charger_main(self):
        fonction_charger(self)

la solution ci dessus fonctionne mais je trouve plutôt "moche" de faire appel à une méthode du main qui elle même fait appel à une méthode développée ailleurs.
C'est actuellement la seule manière que j'ai trouvé pour pouvoir faire appel à un ensemble de widgets/variables déclarés précédemment.

le fait de mettre directement "fonction_charger(self)" dans le connect induit une exécution de la méthode dès l'ouverture de ma fenêtre.
si j'enlève le self... la liaison avec la méthode est ok pour une méthode ne nécessitant aucun argument... sauf que j'ai besoin de la faire passer ce QMainWindow pour pouvoir avoir accès à tout ce qu'il peut contenir.

Donc en gros, je n'arrive pas à lier le connect directement à une méthode hors main tout en métant le "self" relatif au QMainWindow en paramètre...

là je suis en train de voir si faire appel à une classe contenant mes méthodes peut me solutionner cette difficulté mais pour l'instant sans succès...

si vous avez des conseils je suis preneur :-)
merci!

[VinsS]

Salut,

Si c'est le main qui instancie l'interface, ce qui est logique d'ailleurs, alors tu passes l'instance de main à l'interface.

Ce qui donnera ceci:

Code :

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

1
2
3
4
5
 
        QMainWindow.__init__(self, main)
        self.main = main
 
        self.bouton_charger.clicked.connect(main.fonction_charger)

Ainsi ton interface pourra communiquer avec le noyau du programme.

[clement_74]

Bonjour,
je n'avais pas pensé à tourner autour du main, merci.
je viens d'essayer mais la ligne suivante ne passe pas:

Code :

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

QMainWindow.__init__(self, fenetre)

NameError: name 'fenetre' is not defined

mon main est structuré comme suivant dans mon fichier:

Code :

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

1
2
3
4
5
6
7
8
9
def main(args):
    appli = QApplication(args) # instance de l'application
    fenetre = Fenetre_Principale() # instance de ma fenetre principale
    fenetre.show() #affichage de ma fenetre principale
    r = appli.exec_() # creation de la boucle d'execution de l'application 
    return r
 
if __name__ == "__main__":
    main(sys.argv)

je vois pas trop où ça bloque...

[VinsS]

Sorry, c'est moi qui ai sauté une ligne, c'est bien sûr comme ceci:

Code :

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

1
2
3
 
    def __init__(self, main):
        QMainWindow.__init__(self)

[clement_74]

merci pour cette précision!
mais il y a un truc qui m'échappe

je pense comprendre l'intérêt d'ajouter le main qui instancie l'interface comme paramètre à la méthode __init__ de la classe QMainWindow.
En gros cela permet lors d'un appel de méthode d'aller chercher la méthode dans le "main" et non dans la classe relative à QMainWindow (ce qui est plus large du coup je pense).

Dans ce cas, lorsque je créé l'instance de ma QMainWindow, il faudrait que j'indique le paramètre à transmettre à l'__init__ de la classe QmainWindow non?
D'habitude quand je fais dialoguer deux classes, il y a le "self" qui me permet de m'y retrouver vis à vis de qui fait appel à qui.
Ici mon main est une méthode n'héritant d'aucun "objet"... du coup quel paramètre passer à l'instance de ma Fenetre_Principale pour que le main s'y retrouve dedans?

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
class Fenetre_Principale(QMainWindow):
    def __init__(self, fenetre):
        QMainWindow.__init__(self)
        self.fenetre = fenetre
        self.bouton_charger.clicked.connect(self.fenetre.fonction_charger)
 
 
def main(args):
    appli = QApplication(args)
    fenetre = Fenetre_Principale()
    fenetre.show()
    r = appli.exec_()
    return r
 
 
if __name__ == "__main__":
    main(sys.argv)

[clement_74]

Bonjour,
bon, je viens de percuter!
c'était long (dans ma tête) mais finalement la proposition ci dessus est OK
j'ai juste du réviser un peu quelques bases ;-)
Merci!