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

[Jiyuu]

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.

Le souci c'est que là je n'importe pas un QDialog mais un QFrame. Peut être alors ne faut il pas importer un QFrame pour faire ce que je souhaite? (à savoir une multitude d'autre fenêtre).
Venant de wxPython je me suis dit que le Frame serait ce que je cherche à appeler. A priori ce n'est pas le cas. ^^.

[kango]

bonjour,

http://pepper.troll.no/s60prerelease...ndows-mdi.html

c'est ce type d'interface que tu essaies de faire ? si oui, tu as des exemples de mdi dans les exemples Qt qu'il y a dans le paquet PyQt.

[VinsS]

Tu peux nous montrer le code de about.py ?

Il me semble que j'ai déjà importé un simple QWidget, qui peut être utilisé comme support pour tout autre widget. Ce serait peut-être une solution.

[Jiyuu]

bonjour,

http://pepper.troll.no/s60prerelease...ndows-mdi.html

c'est ce type d'interface que tu essaies de faire ? si oui, tu as des exemples de mdi dans les exemples Qt qu'il y a dans le paquet PyQt.

Oui c'est un peu ça...
(* prends le fouet et s'auto-fouette en se disant: Pourquoi n'ai je pas commencé par regarder les exemples ^^

[EDIT]:
En réalité ce que je veux c'est réellement avoir une autre fenêtre qui apparait de la même manière que si tu cliques sur que A propos de Qt dans QtDesigner par exemple.

Tu peux nous montrer le code de about.py ?

Il me semble que j'ai déjà importé un simple QWidget, qui peut être utilisé comme support pour tout autre widget. Ce serait peut-être une solution.

Pour le moment il n'y a rien de bien particulier dans about.py. J'essaye déjà de la faire apparaitre.
Je veux pouvoir comparer rapidement PyQt à wxPython et pour cela je souhaite dans un premier temps réaliser deux applic simple mais qui au final et dans le fond représente bien les applics que je souhaite faire. Donc les HMI ne sont pas très développée ^^.

Cela dit voici le code demandé:

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
# -*- coding: utf-8 -*-
 
# Form implementation generated from reading ui file 'about.ui'
#
# Created: Wed Jun 30 08:33:32 2010
#      by: PyQt4 UI code generator 4.7.3
#
# WARNING! All changes made in this file will be lost!
 
from PyQt4 import QtCore, QtGui
 
class Ui_Frame(object):
    def setupUi(self, Frame):
        Frame.setObjectName("Frame")
        Frame.resize(400, 300)
        Frame.setFrameShape(QtGui.QFrame.StyledPanel)
        Frame.setFrameShadow(QtGui.QFrame.Raised)
        self.label1 = QtGui.QLabel(Frame)
        self.label1.setGeometry(QtCore.QRect(40, 20, 151, 16))
        self.label1.setObjectName("label1")
 
        self.retranslateUi(Frame)
        QtCore.QMetaObject.connectSlotsByName(Frame)
 
    def retranslateUi(self, Frame):
        Frame.setWindowTitle(QtGui.QApplication.translate("Frame", "A propos de...", None, QtGui.QApplication.UnicodeUTF8))
        self.label1.setText(QtGui.QApplication.translate("Frame", "Logiciel fait par moi", None, QtGui.QApplication.UnicodeUTF8))

[kango]

En réalité ce que je veux c'est réellement avoir une autre fenêtre qui apparait de la même manière que si tu cliques sur que A propos de Qt dans QtDesigner par exemple.

alors c'est définitivement un QDialog qu'il te faut et il faut l'utiliser comme VinsS a dit.

[VinsS]

Ah oui, d'accord. Si c'est simplement ça que tu veux, alors utilises un QDialog.

Tu sais qu'il en existe quelques un prêt à l'emploi :

QFontDialog
QFileDialog
QColorDialog
QInputDialog
QPrintDialog

etc

[Jiyuu]

Oui j'avais vu ça. Ceci ressemble d'ailleurs beaucoup que boite dialog de wxPython. C'est ce qui me faisait ne pas les utiliser car en wxPython pour faire ce que je souhaite c'est une Frame qu'il faut reprendre...

Un petit temps d'adaptation sera nécessaire je pense ^^.