Discussion :

[Jiyuu]

Bonjour,

Dans mon projet, j'ai une fenêtre principale.
J'aimerai faire apparaitre une nouvelle fenêtre en cliquant sur un bouton.

Je tourne en rond depuis 1h pour trouver comment faire ceci avec Qt Designer.

Si quelqu'un à une piste elle est la bienvenue.

D'avance merci

[kango]

re bonjour toi

je ne sais pas comment faire avec QtDesigner. ce que je fais, c'est la chose suivante:

je crée un ui par fenêtre ou boite de dialogue et je convertis tout ça en .py.

puis dans mon .py à moi, je gère l'instanciation de ces différentes fenêtres ou boites de dialogue.

je ne suis pas sûr qu'il existe une possibilité pour établir des slots entre 2 boites de dialogue différentes avec QtDesigner, mais je peux me tromper, je ne suis que débutant.

[VinsS]

Bonjour,

je suppose que ceci est dans la suite de ce précédent fil :

http://www.developpez.net/forums/d94...e-qt-designer/

Comme tu as pu le constater, si l'on peut créer des slots étrangers au code de la fenêtre, il seront toujours considérés comme lui appartenant. Si tu transformes ton .ui en .py tu constates que tes slots se sont vu gratifiés d'un 'self.'

Qt Designer est un outil permettant d'économiser de nombreuses heures de travail mais qui, comme toutes choses, a ses limites.

Personne n'aimerait à se taper 1000 lignes de code de ce genre :

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
 
self.label_12 = QtGui.QLabel(self.tab_img)
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(63)
sizePolicy.setVerticalStretch(158)
sizePolicy.setHeightForWidth(self.label_12.sizePolicy().hasHeightForWidth())
self.label_12.setSizePolicy(sizePolicy)
self.label_12.setMinimumSize(QtCore.QSize(60, 18))
self.label_12.setMaximumSize(QtCore.QSize(150, 18))
font = QtGui.QFont()
font.setFamily("Sans Serif")
font.setWeight(75)
font.setBold(True)
self.label_12.setFont(font)
self.hl_21.addWidget(self.label_12)
self.width_lbl = QtGui.QLabel(self.tab_img)
self.width_lbl.setAlignment(QtCore.Qt.AlignRight|QtCore.Qt.AlignTrailing|QtCore.Qt.AlignVCenter)
self.hl_21.addWidget(self.width_lbl)

Un pensum.

Personnellement, avec un quota d'une faute de frappe pour deux lignes, le temps de correction serait à lui seul supérieur au temps de création avec Qt Designer.

Pour de petites applications, i.e. boite de dialogue d'avertissement, tu n'as aucune raison de séparer le code qui lui "donne vie", ajoute-le à la suite du code généré par pyuic4.

Pour des applications plus lourdes une séparation des codes fenêtre-appli se justifie pour des questions de lisibilité et, ceci lié à cela, de maintenance.

Une mainWindow, par contre, ne sera jamais créée d'un premier jet, on sait d'avance que l'on reviendra souvent dessus, nouvelles fonctionnalités, nouvelles idées, changement de concept suite aux test, ergonomie qui ne "passe" pas auprès des essayeurs, etc, les raisons ne manquent pas.

Cela signifie qu'il conviendra, donc, de conserver le code de la fenêtre en l'état.

Deux solutions :

- Petite application(*), créer les slots comme tu l'as fait dans le Designer et ajouter ceci à la fin du code (après la fonction retranslateUi) :

Code :

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

1
2
3
4
5
6
7
8
 
def slot_11(self):
    self.main.do_1()
 
def slot_2(self):
    self.main.do_2
 
...

ceci implique que "main" ait été passé en argument à la fenêtre. Tu pourras
toujours revoir ta fenêtre et recompiler avec pyuic4, il suffira de recopier le bloc
des def slot_x à la fin.

- Application lourde, ici le risque de devoir diviser le code de la fenêtre en
modules .ui séparés, interdit la première solution,
donc, aucun slots définis lors de la création, mais tous instanciés dans
le code main, celui-ci ayant de toutes façons accès à tous les widgets de l'appli.

Pour le reste, laissons l'expérience guider nos choix, certains préféreront importer directement le .ui plutôt que le convertir en .py.


Mais c'est vrai que tu as posé une question dans le premier post. La réponse est non.

On ne peut pas créer une sous fenêtre directement dans le designer et la lier avec un signal/slot.

Construis des objets séparés. une mainWindow et des dialogues

Pour rappel, une boite de dialogue peut s'appeler ainsi :

Code :

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

1
2
3
4
5
 
    Dialog = QtGui.QDialog()
    md = myDialog()
    md.setupDialog(Dialog)
    reply = Dialog.exec_()

Si l'on regarde comment est instanciée une mainWindow :

Code :

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

1
2
3
4
5
6
7
 
    app = QtGui.QApplication(sys.argv)
    MainWindow = QtGui.QMainWindow()
    ui = Ui_MainWindow()
    ui.setupUi(MainWindow)
    MainWindow.show()
    sys.exit(app.exec_())

On y trouve des similitudes qui permettent d'en comprendre la mécanique.

(*) ... deviendra grande , on ne se méfie jamais assez.

[Jiyuu]

Merci pour toute ces éléments de réponses que je relierai à tête reposée.

Je me pose une question sur le choix de l'import d'un .ui ou d'une conversion en .py

Selon toi que vaut-il mieux faire? Il y a-t-il une solution plus rapide en exécutuon qu'une autre? plus fiable?

[Jiyuu]

Bon j'ai créé une deuxième fenêtre.
J'ai tenté les deux manières suivantes pour l'appeler via le slot "about" associé à un bouton:

en important directement le .ui:

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 sys
from PyQt4 import QtGui, QtCore, uic
from step_config_ui import Ui_stepconfig
import about
 
class StepConfig(QtGui.QMainWindow,Ui_stepconfig):
    def __init__(self, parent=None):
        super(StepConfig,self).__init__(parent)
        self.setupUi(self)
 
    def about(self):
        QtGui.QApplication.setStyle(QtGui.QStyleFactory.create("Cleanlooks"))
        widget = uic.loadUi("about.ui")
        widget.show()
        #widget()
 
 
 
if __name__ == "__main__":      
    app = QtGui.QApplication(sys.argv)
    form = StepConfig()
    form.show()
    app.exec_()

en important le .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
import sys
from PyQt4 import QtGui, QtCore, uic
from step_config_ui import Ui_stepconfig
import about
 
class StepConfig(QtGui.QMainWindow,Ui_stepconfig):
    def __init__(self, parent=None):
        super(StepConfig,self).__init__(parent)
        self.setupUi(self)
 
    def about(self):
        About = QtGui.QFrame()
        ui = about.Ui_Frame()
        ui.setupUi(About)
        About.show()
        #About()
 
 
if __name__ == "__main__":      
    app = QtGui.QApplication(sys.argv)
    form = StepConfig()
    form.show()
    app.exec_()

Dans les deux cas, si je laisse les lignes commentées telle quelle la fenêtre apparait et disparait directement.
Si je les décommente, la fenêtre reste visible mais je crée l'erreure suivante:

Code :

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

1
2
3
4
Traceback (most recent call last):
  File "C:\Documents and Settings\Charlie\Bureau\essaiQtDesigner\step_config\run.py", line 15, in about
    widget()
TypeError: 'QFrame' object is not callable

Quelqu'un pourrait-il me guider sur la bonne manière d'appeler cette fenêtre.

D'avance merci

[kango]

bonsoir,

c'est normal qu'elle apparaisse et disparaisse aussitôt.

l'appel à show() est non bloquant: la fenêtre apparait et passe la main.
donc on arrive à la fin de la méthode.
la variable widget est liée à la méthode, elle n'est plus référencée, elle est détruite: la fenêtre disparait.

comme VinsS l'a écrit, tu peux appeler la méthode exec_ du QDialog qui est est bloquante. ou alors, il faut lier le QDialog à la portée de la classe afin d'éviter le ramasse-miettes.

pour l'import de .ui via le loadUi ou la conversion en .py j'ai aucune idée de ce qui est mieux, les deux sont pratiques je trouve. si .ui, il faut penser à les packager avec ton appli alors que le .py distutils le fait tout seul