Click QPushButton => Action ouverture page d'une IHM

**AlexisM31** · 11/05/2021, 10h14

Bonjour à tous,

J'ai pour projet de créer une IHM interactive.
Débutant sur Python et PyQt je me permet de solliciter votre aide.
C'est surement quelque chose de très simple mais je n'arrive vraiment pas à comprendre ou ca peut bloquer, que faire meme.

J'ai crée 2 fenetres sur QtDesigner (D'ailleurs, je comprend pas la difference antre Qdialog et QMainWindow juste la difference avec un menu en haut de page)
Une fois crée je les ai transformé, .ui => .py

Mais avec les .py je n'arrive pas à afficher une seconde fenetre lors de l'appuie d'un QPushButton, problème que je n'avais pas avec loadUi. Je vous montre mes deux codes

Test1 :

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
# Form implementation generated from reading ui file 'test1.ui'
#
# Created by: PyQt5 UI code generator 5.9.2
#
# WARNING! All changes made in this file will be lost!
 
from PyQt5 import QtCore, QtGui, QtWidgets
from asa_control.test2 import Ui_Dialog
class Ui_test1(object):
    def setupUi(self, test1):
        test1.setObjectName("test1")
        test1.resize(800, 600)
        self.centralwidget = QtWidgets.QWidget(test1)
        self.centralwidget.setObjectName("centralwidget")
        self.pushButton = QtWidgets.QPushButton(self.centralwidget)
        self.pushButton.setGeometry(QtCore.QRect(274, 160, 141, 51))
        self.pushButton.setObjectName("pushButton")
 
 
        test1.setCentralWidget(self.centralwidget)
        self.menubar = QtWidgets.QMenuBar(test1)
        self.menubar.setGeometry(QtCore.QRect(0, 0, 800, 21))
        self.menubar.setObjectName("menubar")
        test1.setMenuBar(self.menubar)
        self.statusbar = QtWidgets.QStatusBar(test1)
        self.statusbar.setObjectName("statusbar")
        test1.setStatusBar(self.statusbar)
 
        self.retranslateUi(test1)
        QtCore.QMetaObject.connectSlotsByName(test1)
        self.testing2 = Ui_Dialog()
 
        self.pushButton.clicked.connect(self.gotest2)
    def retranslateUi(self, test1):
        _translate = QtCore.QCoreApplication.translate
        test1.setWindowTitle(_translate("test1", "MainWindow"))
        self.pushButton.setText(_translate("test1", "PushButton"))
 
    def gotest2(self):
        #.vue = self.testing2.setupUi2(Dialog)
        self.testing2
 
        #self.confasa.recupinfo()
 
if __name__ == "__main__":
    import sys
    app = QtWidgets.QApplication(sys.argv)
    test1 = QtWidgets.QMainWindow()
    ui = Ui_test1()
    ui.setupUi(test1)
    ui.gotest2()
    test1.show()
    sys.exit(app.exec_())

Test2 :

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
# -*- coding: utf-8 -*-
 
# Form implementation generated from reading ui file 'test2.ui'
#
# Created by: PyQt5 UI code generator 5.9.2
#
# WARNING! All changes made in this file will be lost!
 
from PyQt5 import QtCore, QtGui, QtWidgets
 
class Ui_Dialog(object):
    def setupUi2(self, Dialog):
        Dialog.setObjectName("Dialog")
        Dialog.resize(400, 300)
 
        self.retranslateUi(Dialog)
        QtCore.QMetaObject.connectSlotsByName(Dialog)
 
    def retranslateUi(self, Dialog):
        _translate = QtCore.QCoreApplication.translate
        Dialog.setWindowTitle(_translate("Dialog", "Dialog"))
 
 
if __name__ == "__main__":
    import sys
    app = QtWidgets.QApplication(sys.argv)
    Dialog = QtWidgets.QDialog()
    ui = Ui_Dialog()
    ui.setupUi2(Dialog)
    Dialog.show()
    sys.exit(app.exec_())

J'aimerai juste aller à la QWidget test2 en cliquant sur le bouton du QWidget Test1.
J'ai crée une fonction où je réaliser l'appel du code avec un clicked.connect

Merci d'avance pour votre aide

EDIT: Le "Dialog me bloque le plus souvent, j'ai ce message d'erreur : name 'Dialog' is not defined quand je fais

Code :

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

self.testing2.setupUi2(Dialog)

**tyrtamos** · 12/05/2021, 05h55

Bonjour,

C'est une très mauvaise idée de modifier le code issu de QtDesigner, puisque toute modification ultérieure (il y en a toujours) fera disparaître tout ce qu'on a modifié, comme c'est clairement indiqué au début de la page:

# WARNING! All changes made in this file will be lost!

Au lieu de ça, le code issu de QtDesigner doit être importé. Voir par exemple une réponse que j'ai faite récemment sur ce sujet:
https://www.developpez.net/forums/d2.../#post11721651

Les fenêtres QDialog, héritant de QWidget (comme d'ailleurs QMainWindow), ont une vocation particulière: être utilisées pour un dialogue "modal" avec l'utilisateur. Le mode "modal" signifie que pendant l'exécution d'une fenêtre QDialog, l'utilisateur n'a pas accès aux autres fenêtres du programme. Elles ont la particularité de disposer d'une pile de traitement des évènements spécifique (lancée par la méthode "exec_()") qui leur donne une certaine autonomie de fonctionnement par rapport au programme principal (dont la pile principale de traitement des évènements est lancée par "app.exec_()").

La bibliothèque Qt5 contient plusieurs classes qui héritent de QDialog comme QColorDialog, QFileDialog, QFontDialog, QInputDialog, QMessageBox, QProgressDialog (il y en a d'autres). Mais en dehors de ce type d'utilisation, les fenêtres courantes (la fenêtre principale et celles qu'elle peut lancer en plus) sont généralement des QWidget ou des QMainWindow.

Doc de QDialog: https://doc.qt.io/qt-5/qdialog.html

Doc de Qt5: https://doc.qt.io/qt-5/

**Sve@r** · 18/05/2021, 10h21

Bonjour

Envoyé par AlexisM31

(D'ailleurs, je comprend pas la difference antre Qdialog et QMainWindow

Oh là là tu vis donc dans une antre que tu n'as jamais lu la préposition "entre" dans un livre???

Envoyé par AlexisM31

juste la difference avec un menu en haut de page)

Exactement. Une QMainWindow c'est une fenêtre "principale" et à ce titre, (et en dehors du fait qu'il n'y en a qu'une seule par appli) dispose d'un menu en haut (QMainMenu) et d'une barre d'état (QStatusBar)

Envoyé par AlexisM31

Mais avec les .py je n'arrive pas à afficher une seconde fenetre lors de l'appuie d'un QPushButton, problème que je n'avais pas avec loadUi.

J'ai créé un court mais complet exemple PyQt permettant d'ouvrir une sous-fenêtre lors de l'appui sur un bouton de la fenêtre principale (mais sans utiliser designer). T'as qu'à le prendre et l'analyser...

Code python :

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
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
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
#!/usr/bin/env python3
# coding: utf-8
 
import sys
 
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):
		# Message de contrôle
		print(
			"Python version %s - QtAppli (%s)" % (
				sys.version,
				", ".join(
					"%s v%s" % (s, v) for (s, v) in (
						("qt", QT_VERSION_STR),
						("pyqt", PYQT_VERSION_STR),
					)
				),
			)
		)
		print("%s.__init__(%s)" % (self, argv))
 
		# Appel constructeur de l'objet hértié
		super().__init__(argv)
 
		# Connexion du signal de fermeture application
		self.aboutToQuit.connect(self.__slotQuit)
 
		# La translation des fenêtres prédéfinies
		self.__trans=QTranslator()
		self.installTranslator(self.__trans)
		self.__trans.load(
			"qt_%s" % QLocale.system().name(),
			QLibraryInfo.location(QLibraryInfo.TranslationsPath),
		)
 
		# Widget principale
		self.__mainWid=QtMainWindow()
	# __init__()
 
	# Destructeur fenêtre
	def __del__(self):
		# Message de contrôle
		print("%s.__del__()" % self)
 
		# Pas de destructeur hérité
		pass
	# __del__()
 
	# Lancement application
	def run(self):
		# Affichage fenêtre principale
		self.__mainWid.show()
 
		# Lancement application
		return self.exec_()
	# run()
 
	# A la fermeture de l'application
        @pyqtSlot()
	def __slotQuit(self):
		# Message de contrôle
		print("%s => %s.__slotQuit()" % (self.sender(), self))
	# __slotQuit()
# class QtAppli
 
# Fenêtre principale
class QtMainWindow(QMainWindow):
	"Fenêtre principale"
 
	# Constructeur fenêtre
	def __init__(self, *args, **kwargs):
		# Message de contrôle
		print("%s.__init__(%s, %s)" % (self, args, kwargs))
 
		# Appel constructeur de l'objet hértié
		super().__init__(*args, **kwargs)
 
		# La fenêtre est détruite à sa fermeture
		self.setAttribute(Qt.WA_DeleteOnClose)
 
		# On crée un widget associé à la fenêtre principale
		self.setCentralWidget(QWidget(self))
 
		# Titre
		self.setWindowTitle(
			QCoreApplication.translate(
				"VerifQt5",
				"Vérification Qt",
				"Note: titre de la fenêtre".encode("utf-8"),
			),
		)
 
		# Barre de status
		self.statusBar().showMessage(
			", ".join(
				(
					QCoreApplication.translate(
						"VerifQt5",
						"Qt version {0}",
						"Note: barre d'êtat".encode("utf-8"),
					).format(QT_VERSION_STR),
					QCoreApplication.translate(
						"VerifQt5",
						"PyQy version {0}",
						"Note: barre d'êtat".encode("utf-8"),
					).format(PYQT_VERSION_STR),
				),
			)
		)
 
		# Le bouton
		btn=QPushButton(
			QCoreApplication.translate(
				"VerifQt5",
				"Surtout ne pas cliquer là !!!",
				"Note: titre du bouton".encode("utf-8"),
			),
			clicked=self.__slotAction,
		)
 
		# Le bouton version
		ver=QPushButton(
			QCoreApplication.translate(
				"VerifQt5",
				"A propos de Qt",
				"Note: titre du bouton".encode("utf-8"),
			),
			clicked=self.__slotQt,
		)
 
		# Pour quitter
		quit=QPushButton(
			QCoreApplication.translate(
				"VerifQt5",
				"Quitter",
				"Note: titre du bouton".encode("utf-8"),
			),
			clicked=self.close,
		)
 
		# Rangement principal
		mainLayout=QVBoxLayout(self.centralWidget())
		mainLayout.addWidget(btn, 0)
		mainLayout.addWidget(ver, 0)
		mainLayout.addStretch(1)
		mainLayout.addWidget(quit, 0)
 
		# Le module de la sous-fenêtre
		self.__other={
			"widget" : None,
			"cpt" : 0,
		}
	# __init__()
 
	# Destructeur fenêtre
	def __del__(self):
		# Message de contrôle
		print("%s.__del__()" % self)
 
		# Pas de destructeur hérité
		pass
	# __del__()
 
	# Evènement fermeture fenêtre (méthode surchargée)
	def closeEvent(self, event):
		# Message de contrôle
		print("%s => %s.closeEvent(%s (%s))" % (self.sender(), self, event, type(event)))
 
		# Appel méthode objet hérité
		super().closeEvent(event)
 
		# Question
		event.accept() if QMessageBox.question(
			self,
			"Confirmation",
			"Confirmez-vous vouloir quitter ?",
			QMessageBox.Yes|QMessageBox.No,
		) == QMessageBox.Yes else event.ignore()
	# closeEvent()
 
	# Slot qui affiche la sous-fenêtre
        @pyqtSlot(bool)
	def __slotAction(self, state):
		# Message de contrôle
		print("%s => %s.__slotAction(%s (%s))" % (self.sender(), self, state, type(state)))
 
		# Création sous-fenêtre
		self.__other["cpt"]+=1
		self.__other["widget"]=QtSubWindow(self.__other["cpt"], self)
		self.__other["widget"].sigClose[int].connect(self.__slotSubwinClose)
 
		# Ouverture sous-fenêtre
		self.__other["widget"].open()
	# __slotAction()
 
	# Slot qui affiche la version de Qt
        @pyqtSlot(bool)
	def __slotQt(self, state):
		# Message de contrôle
		print("%s => %s.__slotQt(%s (%s))" % (self.sender(), self, state, type(state)))
 
		# Fenêtre "A propos de Qt"
		QMessageBox.aboutQt(
			self,
			QCoreApplication.translate(
				"VerifQt5",
				"à propos de {0}...",
				"Note: titre de la fenêtre".encode("utf-8"),
			).format(
				", ".join(
					(
						QCoreApplication.translate(
							"VerifQt5",
							"Qt {0}",
							"Note: titre de la fenêtre".encode("utf-8"),
						).format(QT_VERSION_STR),
						QCoreApplication.translate(
							"VerifQt5",
							"PyQt {0}",
							"Note: titre de la fenêtre".encode("utf-8"),
						).format(PYQT_VERSION_STR),
					),
				)
			)
		)
	# __slotQt()
 
	# A la fermeture de la sous-fenêtre
        @pyqtSlot(int)
	def __slotSubwinClose(self, item):
		# Message de contrôle
		print("%s => %s.__slotSubwinClose(%s (%s))" % (self.sender(), self, item, type(item)))
	# __slotSubwinClose()
# class QtMainWindow
 
# Fenêtre subsidiaire
class QtSubWindow(QDialog):
	"Fenêtre subsidiaire"
 
	# Signaux de communication
	sigClose=pyqtSignal(int)
 
	# Constructeur fenêtre
	def __init__(self, cpt, *args, **kwargs):
		# Appel constructeur de l'objet hértié
		super().__init__(*args, **kwargs)
 
		# La fenêtre est détruite à sa fermeture
		self.setAttribute(Qt.WA_DeleteOnClose)
 
		# La fenêtre est modale
		self.setModal(True)
 
		# Le compteur
		self.__cpt=cpt
 
		# Le titre
		self.setWindowTitle(
			QCoreApplication.translate(
				"VerifQt5",
				"Félicitations, Qt {0} fonctionne parfaitement !!!",
				"Note: titre de la fenêtre".encode("utf-8"),
			).format(QT_VERSION_STR)
		)
 
		# Rangement principal
		mainLayout=QVBoxLayout(self)
 
		# Texte à la con
		self.__label=QLabel()
		mainLayout.addWidget(self.__label)
 
		# Bouton
		btn=QPushButton(
			QCoreApplication.translate(
				"VerifQt5",
				"Félicitations, Qt {0} fonctionne parfaitement !!!",
				"Note: titre du bouton".encode("utf-8"),
			).format(QT_VERSION_STR)
		)
		btn.clicked[bool].connect(self.close)
		mainLayout.addWidget(btn)
 
		# Texte à la con
		mainLayout.addWidget(
			QLabel(
				"<center><font size='+1'>{0}</font></center>".format(
					"<br>".join(
						(
							QCoreApplication.translate(
								"VerifQt5",
								"Python version {0}",
								"Note: texte de la fenêtre".encode("utf-8"),
							).format(sys.version),
							QCoreApplication.translate(
								"VerifQt5",
								"Qt version {0}",
								"Note: texte de la fenêtre".encode("utf-8"),
							).format(QT_VERSION_STR),
							QCoreApplication.translate(
								"VerifQt5",
								"PyQt version {0}",
								"Note: texte de la fenêtre".encode("utf-8"),
							).format(PYQT_VERSION_STR),
						)
					)
				)
			)
		)
	# __init__()
 
	# Destructeur fenêtre
	def __del__(self):
		# Message de contrôle
		print("%s.__del__()" % self)
 
		# Pas de destructeur hérité
		pass
	# __del__()
 
	# Evènement affichage fenêtre (méthode surchargée)
	def showEvent(self, event):
		# Message de contrôle
		print("%s => %s.showEvent(%s (%s))" % (self.sender(), self, event, type(event)))
 
		# Le label est mis à jour
		self.__label.setText(
			QCoreApplication.translate(
				"VerifQt5",
				"<center><font size='+5'>C'était écrit <u><font color='red'>SURTOUT</font></u> ne pas cliquer !!!</font><br>Et l'autre gros con, qu'est-ce qu'il fait ? Il clique{0} !!!</center>",
				"Note: texte de la fenêtre".encode("utf-8"),
			).format(
				QCoreApplication.translate(
					"VerifQt5",
					" <font color='red' size='+{0}'>(et {0} fois en plus...)</font>",
					"Note: texte de la fenêtre".encode("utf-8"),
				).format(self.__cpt)\
				if self.__cpt > 1 else ""
			)
		)
 
		# Appel méthode objet hérité
		super().showEvent(event)
	# showEvent()
 
	# Evènement fermeture fenêtre (méthode surchargée)
	def closeEvent(self, event):
		# Message de contrôle
		print("%s => %s.closeEvent(%s (%s))" % (self.sender(), self, event, type(event)))
 
		# Appel méthode objet hérité
		super().closeEvent(event)
 
		# Emission compteur
		self.sigClose[int].emit(self.__cpt)
	# closeEvent()
# class QtSubWindow
 
if __name__ == "__main__":
	# Lancement appli
	sys.exit(QtAppli(sys.argv).run())

**tyrtamos** · 19/05/2021, 05h19

Bonjour Sve@r,

Envoyé par Sve@r

Une QMainWindow c'est une fenêtre "principale" et à ce titre, (et en dehors du fait qu'il n'y en a qu'une seule par appli) dispose d'un menu en haut (QMainMenu) et d'une barre d'état (QStatusBar)

Ce n'est pas la 1ère fois que je lis ça. Le fait qu'une fenêtre QMainWindow soit forcément la fenêtre principale et qu'on ne puisse pas l'appeler en tant que fenêtre secondaire n'est pas une limite de PyQt5. Je pense qu'il y a une confusion avec tkinter.

Et c'est bien pratique! Cela permet, par exemple, à un programme complexe de contenir un éditeur de texte complet (avec menu et barre d'état) appelable sur demande pour modifier un texte.

Click QPushButton => Action ouverture page d'une IHM

PyQt Python

Vue hybride

Discussions similaires

Partager

Partager