Un peu de mal avec la syntaxe signal/slot new-style

Version imprimable

Bonjour à tous

Etant en train de passer de PyQt4 à PyQt5, je cherche à comprendre la nouvelle syntaxe des signaux et slots. Mais je n'y arrive malheureusement pas et c'est pourquoi je viens ici demander un coup de main...

Bon en fait j'ai bien compris la syntaxe pour les signaux traditionnels. Exemple avec un QPushButton
old-style

Code:

1
2
3
4
5
6
btn=QPushButton(QString.fromUtf8("blablabla"))
QObject.connect(
	btn,
	SIGNAL("clicked()"),
	action,
)

new-style

Code:

1
2
btn=QPushButton(QString.fromUtf8("blablabla"))
btn.clicked.connect(action)

Donc le token "clicked" du old-style devient méthode du bouton dans le nouveau style. Jusque là ça va.

Mais là où je ne m'en sors pas, c'est quand je veux connecter mon propre signal émis. Parce que là, j'ai mon propre token. Si par exemple j'ai un emit(SIGNAL("coucou")) en old-style ; je me vois mal faire un myObject.coucou.connect(...) dans le new-style...

A titre d'exemple un petit code complet et fonctionnel (qui peut-même servir de tuto). La fenêtre principale affiche un bouton qui appelle une sous-fenêtre, et lorsque la sous-fenêtre se referme elle envoie un signal à la fenêtre principale, signal qui contient le nombre d'appels à la sous-fenêtre. C'est ce signal que je ne vois pas comment écrire en new-style...

Code:

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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
import sys
from sip import *
from PyQt4.QtCore import *
from PyQt4.QtGui import *
 
# Application principale
class QtAppli(
        QApplication):
    "Application principale"
 
    # Constructeur fenêtre
    def __init__(
            self,
            argv):
 
        # Appel constructeur de l'objet hértié
        super(QtAppli, self).__init__(argv)
 
        # Widget principale
        self.__mainWid=QtMainWindow()
        self.__mainWid.show()
    # __init__()
# class QtAppli
 
# Fenêtre principale
class QtMainWindow(
        QMainWindow):
    "Fenêtre principale"
 
    # Constructeur fenêtre
    def __init__(
            self,
            *args,
            **kwargs):
 
        # Appel constructeur de l'objet hértié
        super(QtMainWindow, self).__init__(*args, **kwargs)
        self.setCentralWidget(QWidget(self))
 
        # Le titre
        self.setWindowTitle(QString.fromUtf8("Qt %1").arg(QT_VERSION_STR))
 
        # Le bouton
        btn=QPushButton(QString.fromUtf8("Appel sous-fenêtre"))
        QObject.connect(
            btn,
            SIGNAL("clicked()"),
            self.__slotAction,
        )
        # btn.clicked.connect(self.__slotAction)		# Jusque là ça va...
 
        # Pour quitter
        quit=QPushButton(QString.fromUtf8("Quitter"))
        QObject.connect(
            quit,
            SIGNAL("clicked()"),
            self,
            SLOT("close()"),
        )
        # quit.clicked.connect(self.close)			# Là aussi...
 
        # Rangement principal
        mainLayout=QVBoxLayout(self.centralWidget())
        mainLayout.addWidget(btn, 0)
        mainLayout.addWidget(quit, 0)
 
        # Sous-fenêtre
        self.__other=QtSubWindow(self.centralWidget())
        QObject.connect(
            self.__other,
            SIGNAL("xxx"),
            self.__slotOtherClose,
        )
        # Là je ne vois pas comment écrire ça en new-style...
    # __init__()
 
    # Slot qui affiche la sous-fenêtre
    def __slotAction(
            self):
 
        print(u"%s.__slotAction" % self.__class__.__name__)
 
        # Affichage sous-fenêtre
        self.__other.show()
    # __slotAction()
 
    # A la fermeture de la sous-fenêtre
    def __slotOtherClose(
            self,
            x):
 
        print(
            u"%s.__slotOtherClose(%s)" % (
                self.__class__.__name__,
                x,
            )
        )
    # __slotOtherClose()
# class QtMainWindow
 
# Fenêtre subsidiaire
class QtSubWindow(
        QDialog):
    "Fenêtre subsidiaire"
 
    # Constructeur fenêtre
    def __init__(
            self,
            *args,
            **kwargs):
 
        # Appel constructeur de l'objet hértié
        super(QtSubWindow, self).__init__(*args, **kwargs)
        self.setModal(True)
 
        # Le compteur
        self.__cpt=0
 
        # Bouton
        btn=QPushButton(QString.fromUtf8("Fermer"))
        QObject.connect(
            btn,
            SIGNAL("clicked()"),
            self,
            SLOT("close()"),
        )
        #btn.clicked.connect(self.close)
 
        # Rangement principal
        mainLayout=QVBoxLayout(self)
        mainLayout.addWidget(btn)
    # __init__()
 
    # A la fermeture (méthode surchargée)
    def closeEvent(
            self,
            event):
 
        # Incrément compteur
        self.__cpt+=1
 
        # Emission compteur
        self.emit(SIGNAL("xxx"), self.__cpt)			# Pareil, je ne vois pas comment écrire ça en new-style...
    # closeEvent()
# class QtSubWindow
 
if __name__ == "__main__":
    # Lancement appli
    QtAppli(sys.argv).exec_()

Merci à tous ;)

Salut,

Un exemple qui montre la simplicité de la chose:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 from PyQt5.QtCore import QObject, pyqtSignal class Foo(QObject): actionFinished = pyqtSignal(int) def __init__(self): super().__init__() self.actionFinished.connect(self.on_action_finished) ... def action(self): x = 2 * 5 self.actionFinished.emit(x) def on_action_finished(self, number): etc ...
Évidemment, le signal peut aussi être connecté vers une méthode d'une autre classe.

Par contre, pour ton compteur qui est implémenté dans le dialogue lui-même, je pense qu'il sera remit à zéro à chaque foix.

Merci de ta réponse. Voilà ce que ça donne

Code:

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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
import sys
from sip import *
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
 
# Application principale
class QtAppli(
        QApplication):
    "Application principale"
 
    # Constructeur fenêtre
    def __init__(
            self,
            argv):
 
        # Appel constructeur de l'objet hértié
        super(QtAppli, self).__init__(argv)
 
        # Widget principale
        self.__mainWid=QtMainWindow()
        self.__mainWid.show()
    # __init__()
# class QtAppli
 
# Fenêtre principale
class QtMainWindow(
        QMainWindow):
    "Fenêtre principale"
 
    # Constructeur fenêtre
    def __init__(
            self,
            *args,
            **kwargs):
 
        # Appel constructeur de l'objet hértié
        super(QtMainWindow, self).__init__(*args, **kwargs)
        self.setCentralWidget(QWidget(self))
 
        # Le titre
        self.setWindowTitle("Qt {0}".format(QT_VERSION_STR))
 
        # Le bouton
        btn=QPushButton("Appel sous-fenêtre")
        btn.clicked.connect(self.__slotAction)
 
        # Pour quitter
        quit=QPushButton("Quitter")
        quit.clicked.connect(self.close)
 
        # Rangement principal
        mainLayout=QVBoxLayout(self.centralWidget())
        mainLayout.addWidget(btn, 0)
        mainLayout.addWidget(quit, 0)
 
        # Sous-fenêtre
        self.__other=QtSubWindow(self.centralWidget())
        self.__other._sigClose.connect(self.__slotOtherClose)
    # __init__()
 
    # Slot qui affiche la sous-fenêtre
    def __slotAction(
            self):
 
        print(u"%s.__slotAction" % self.__class__.__name__)
 
        # Affichage sous-fenêtre
        self.__other.show()
    # __slotAction()
 
    # A la fermeture de la sous-fenêtre
    def __slotOtherClose(
            self,
            x):
 
        print(
            u"%s.__slotOtherClose(%s)" % (
                self.__class__.__name__,
                x,
            )
        )
    # __slotOtherClose()
# class QtMainWindow
 
# Fenêtre subsidiaire
class QtSubWindow(
        QDialog):
    "Fenêtre subsidiaire"
 
    _sigClose=pyqtSignal(int)
 
    # Constructeur fenêtre
    def __init__(
            self,
            *args,
            **kwargs):
 
        # Appel constructeur de l'objet hértié
        super(QtSubWindow, self).__init__(*args, **kwargs)
        self.setModal(True)
 
        # Le compteur
        self.__cpt=0
 
        # Bouton
        btn=QPushButton("Fermer")
        btn.clicked.connect(self.close)
 
        # Rangement principal
        mainLayout=QVBoxLayout(self)
        mainLayout.addWidget(btn)
    # __init__()
 
    # A la fermeture (méthode surchargée)
    def closeEvent(
            self,
            event):
 
        # Incrément compteur
        self.__cpt+=1
 
        # Emission compteur
        self._sigClose.emit(self.__cpt)
    # closeEvent()
# class QtSubWindow
 
if __name__ == "__main__":
    # Lancement appli
    QtAppli(sys.argv).exec_()

(et le compteur n'est pas réinitialisé ;))

Mais est-on obligé de définir une variable pour le signal ??? Parce que pour moi, variable en plus égal souci en plus...

Merci encore 8-)

31/07/2017, 20h43
VinsS

Un signal est une classe, donc doit avoir un nom. Oui.
31/07/2017, 23h37
Sve@r

Super - Je ne dis pas que ça m'enchante (dans le old-style il n'est pas besoin de variable pour le signal) mais c'est super sympa de m'avoir éclairé. :merci:

A+ :ccool: