Discussion :

[BlackoOSX]

Bonjour à toutes et à tous!
J'ai besoin de mettre un graphique dans une fenêtre Qt déjà existante (qui contient des boutons, etc...) et pour cela vous l'aurez compris j'utilise le module python Qwt.
J'ai fais un test pour voir si tout fonctionnait en sachant qu'il y aurait deux fenêtres séparées (la fenêtre principale et aussi le graphique dans une autre fenêtre).
Voilà mon problème: Je n'arrive pas à trouver sur internet comment mettre mon graphique dans ma fenêtre principale et comment je pourrais changer sa taille et le positionner correctement comme une image.
Est-ce que je dois utiliser un canvas?
Une petite image pour illustrer tout cela:

Merci d'avance!

[tyrtamos]

Bonjour,

Rien n'empêche de considérer une fenêtre de type Qwt comme un widget intégrable dans une fenêtre comme QWidget qui contient d'autres composants.

Voilà un exemple:

J'ai utilisé l'un des codes tests de pythonqwt: celui qui s'appelle "ReallySimpleDemo". Conformément à la doc, on exécute les tests avec:

Code :

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

1
2
from qwt import tests
tests.run()

Après avoir importé PyQt5, j'ai créé une fenêtre QWidget avec un bouton et la classe "SimplePlot" qui hérite de QwtPlot. Dans la fenêtre QWidget, j'ai intégré ces 2 objets graphiques avec un simple QGridLayout.

Voilà le code que ça donne:

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
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
# -*- coding: utf-8 -*-
#
# Licensed under the terms of the PyQwt License
# Copyright (C) 2003-2009 Gerard Vermeulen, for the original PyQwt example
# Copyright (c) 2015 Pierre Raybaut, for the PyQt5/PySide port and further 
# developments (e.g. ported to PythonQwt API)
# (see LICENSE file for more details)
 
SHOW = True # Show test in GUI-based test launcher
 
import sys
import numpy as np
 
from qwt.qt.QtGui import QApplication, QPen
from qwt.qt.QtCore import Qt
from qwt import QwtPlot, QwtPlotMarker, QwtLegend, QwtPlotCurve, QwtText
 
from PyQt5 import (QtWidgets, QtCore)
 
class SimplePlot(QwtPlot):
    def __init__(self, *args):
        QwtPlot.__init__(self, *args)
        self.setTitle('ReallySimpleDemo.py')
        self.insertLegend(QwtLegend(), QwtPlot.RightLegend)
        self.setAxisTitle(QwtPlot.xBottom, 'x -->')
        self.setAxisTitle(QwtPlot.yLeft, 'y -->')
        self.enableAxis(self.xBottom)
 
        # insert a few curves
        cSin = QwtPlotCurve('y = sin(x)')
        cSin.setPen(QPen(Qt.red))
        cSin.attach(self)
        cCos = QwtPlotCurve('y = cos(x)')
        cCos.setPen(QPen(Qt.blue))
        cCos.attach(self)
 
        # make a Numeric array for the horizontal data
        x = np.arange(0.0, 10.0, 0.1)
 
        # initialize the data
        cSin.setData(x, np.sin(x))
        cCos.setData(x, np.cos(x))
 
        # insert a horizontal marker at y = 0
        mY = QwtPlotMarker()
        mY.setLabel(QwtText('y = 0'))
        mY.setLabelAlignment(Qt.AlignRight | Qt.AlignTop)
        mY.setLineStyle(QwtPlotMarker.HLine)
        mY.setYValue(0.0)
        mY.attach(self)
 
        # insert a vertical marker at x = 2 pi
        mX = QwtPlotMarker()
        mX.setLabel(QwtText('x = 2 pi'))
        mX.setLabelAlignment(Qt.AlignRight | Qt.AlignTop)
        mX.setLineStyle(QwtPlotMarker.VLine)
        mX.setXValue(2*np.pi)
        mX.attach(self)
 
        # replot
        self.replot()
 
class Fenetre(QtWidgets.QWidget):
 
    def __init__(self, parent=None):
        super().__init__(parent)
 
        self.resize(800, 600)
        self.setWindowTitle('Intégration Qwt dans QWidget')
 
        self.bouton = QtWidgets.QPushButton('Bouton', self)
        self.bouton.clicked.connect(self.clicbouton)
 
        self.demo = SimplePlot()
 
        posit = QtWidgets.QGridLayout()
        posit.addWidget(self.bouton, 0, 0)
        posit.addWidget(self.demo, 1, 0)
        self.setLayout(posit)
 
        self.encours = False
 
    def clicbouton(self):
        print("clic!")
 
"""
def make():
    demo = SimplePlot()
    demo.resize(800, 500)
    demo.show()
    return demo
"""
 
if __name__ == '__main__':
    app = QApplication(sys.argv)
    fen = Fenetre()
    fen.show()
    fen.demo.exportTo("demo.png", size=(1600, 900), resolution=200)
    sys.exit(app.exec_())

Et voilà ce que ça donne à l'affichage:

[BlackoOSX]

Merci de votre réponse!
J'ai tester d'un côté le code que vous m'avez fournis et de l'autre l'essai d'intégration dans le mien et cela nous donne ça (Sans toutes les lignes superflus):

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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
 
import sys
import numpy as np
from PyQt5 import QtGui, QtCore
from PyQt5.QtWidgets import QApplication, QMainWindow, QWidget, QAction, QDesktopWidget, QComboBox, QLabel, QPushButton, QMessageBox, QGridLayout
from qwt.qt.QtGui import QApplication, QPen
from qwt.qt.QtCore import Qt
from qwt import QwtPlot, QwtPlotMarker, QwtLegend, QwtPlotCurve, QwtText
 
class SimplePlot(QwtPlot):
    def __init__(self, *args):
        QwtPlot.__init__(self, *args)
        self.setTitle('ReallySimpleDemo.py')
        self.insertLegend(QwtLegend(), QwtPlot.RightLegend)
        self.setAxisTitle(QwtPlot.xBottom, 'x -->')
        self.setAxisTitle(QwtPlot.yLeft, 'y -->')
        self.enableAxis(self.xBottom)
 
        # insert a few curves
        cSin = QwtPlotCurve('y = sin(x)')
        cSin.setPen(QPen(Qt.red))
        cSin.attach(self)
        cCos = QwtPlotCurve('y = cos(x)')
        cCos.setPen(QPen(Qt.blue))
        cCos.attach(self)
 
        # make a Numeric array for the horizontal data
        x = np.arange(0.0, 10.0, 0.1)
 
        # initialize the data
        cSin.setData(x, np.sin(x))
        cCos.setData(x, np.cos(x))
 
        # insert a horizontal marker at y = 0
        mY = QwtPlotMarker()
        mY.setLabel(QwtText('y = 0'))
        mY.setLabelAlignment(Qt.AlignRight | Qt.AlignTop)
        mY.setLineStyle(QwtPlotMarker.HLine)
        mY.setYValue(0.0)
        mY.attach(self)
 
        # insert a vertical marker at x = 2 pi
        mX = QwtPlotMarker()
        mX.setLabel(QwtText('x = 2 pi'))
        mX.setLabelAlignment(Qt.AlignRight | Qt.AlignTop)
        mX.setLineStyle(QwtPlotMarker.VLine)
        mX.setXValue(2*np.pi)
        mX.attach(self)
 
        # replot
        self.replot()
 
class MainWindow(QMainWindow):
	def __init__(self):
		self.labelProfiles = QLabel("Profiles", self)
		self.labelProfiles.setText("List of printer profiles:")
		self.labelProfiles.move(10, 35)
		self.labelProfiles.resize(200, 20)
 
 
		posit = QGridLayout()
		posit.addWidget(self.demo, 1, 0)
		self.setLayout(posit)
 
		self.encours = False
 
 
#Lancer la Fenêtre
app = QApplication(sys.argv)
GUI = MainWindow()
GUI.show()
sys.exit(app.exec_())

Et ce code me donne ça:

Avez-vous une solution?

PS: Dans le terminal j'ai cette erreur: QWidget::setLayout: Attempting to set QLayout "" on MainWindow "", which already has a layout
Mais la fenêtre se lance quand même...

Merci d'avance!

[tyrtamos]

PS: Dans le terminal j'ai cette erreur: QWidget::setLayout: Attempting to set QLayout "" on MainWindow "", which already has a layout
Mais la fenêtre se lance quand même...

Il y a 2 pb dans ton code:

création du self.demo (voir dans mon code):

Code :

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

        self.demo = SimplePlot()

L'intégration de widgets dans un QMainWindows ne marche pas de la même façon que dans un QWidget, parce que QMainWindow est un QWidget complexe qui a déjà des composants intégrés. Voilà ce qu'il faut faire dans ton cas, mais adapté à mon code précédent (tu feras la conversion en fonction de ton code):

Code :

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

1
2
3
4
5
        self.setCentralWidget(QtWidgets.QFrame())
        posit = QtWidgets.QGridLayout()
        posit.addWidget(self.bouton, 0, 0)
        posit.addWidget(self.demo, 1, 0)
        self.centralWidget().setLayout(posit)

Et tu peux effacer la ligne "self.encours = False" qui vient d'une application antérieure et qui n'a rien à faire ici.

[BlackoOSX]

Le problème c'est que j'ai appris à faire mes applications Qt avec un QMainWindow et avec un QtWigets et ce ne sont pas du tout les mêmes librairies...
J'ai essayé d'adapter mon code à ce type de fenêtre sauf que je suis bloqué pour un simple petit menu.
Le problème c'est que tous les tutos (en tout cas que j'ai trouvé utilisent tous un QMainWindow...
Est-ce totalement obligé d'utiliser un QWigets pour pouvoir utiliser Qwt correctement?
Sinon est-ce que je ne pourrais pas passer par d'autres librairies comme mathplotlib?
Merci d'avance!

[VinsS]

Salut,

On ne te dit pas de ne pas utiliser un QMainWindow mais que tu dois d'abord y mettre un centralWidget et c'est dans celui-là que tu places tous tes autres widgets.
Si tu crées ta fenêtre avec le Designer tu n'auras pas autre chose que cela.

[BlackoOSX]

Bonsoir à tous!
Merci de vous réponses à tous les deux et maintenant que tout fonctionne je me sens un peu stupide de ne pas avoir simplement copié coller le code de tytamos[FONT=Verdana, sans-serif]. [/FONT]
Donc maintenant que tout cela fonctionne (enfin que j'ai mon graphique dans ma fenêtre), j'ai ça:

Ma question maintenant est comment peut-on traiter ce Widget comme une image ou un bouton en le redimensionnant et en le plaçant dans l'espace?
J'ai essayer avec une façon qui ne créer pas d'erreurs mais qui ne créer non plus pas de résultat.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
self.demo = SimplePlot()
 
 
self.setCentralWidget(QtWidgets.QFrame())
posit = QtWidgets.QGridLayout()
posit.addWidget(self.demo, 1, 0)
self.centralWidget().setLayout(posit)
 
self.demo.resize(100, 100)
self.demo.move(100, 500)

PS: Je n'utilise pas le Designer pour créer ma fenêtre je la code à la main parce que je trouve que c'est plus propre.
Merci d'avance!

[VinsS]

Ben oui mais le Designer permet de voir ce que l'on fait (WISIWIG) et tu aurais put voir que tes labels et boutons devaient être eux aussi placés dans le QGridLayout.

En simplifié:

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
 
centralWidget = QWidget()
grid = QGridLayout(centralWidget)
# première ligne
label = QLabel(self)
grid.addWidget(label, 0, 0, 1, 1)
# deuxième ligne
bouton = QPushButton(self)
grid.addWidget(bouton, 1, 0, 1, 1)
bouton2 = QPushButton(self)
grid.addWidget(bouton, 1, 1, 1, 1)
bouton3 = QPushButton(self)
grid.addWidget(bouton, 1, 2, 1, 1)
# troisième ligne
demo = Demo(self)
grid.addWidget(demo, 2, 1, 1, 3)
window.setCentralWidget(centralWidget)

pour la demo tu mets un nombre de colonnes qui correspond aux nombre de boutons, ici j'ai mis 3.

[tyrtamos]

Bonjour,

Concernant la taille et la position du graphique self.demo:

l'avantage d'avoir placé le graphique qwt dans la fenêtre QMainWindow grâce au QGridLayout, est que ce graphique remplira tout l'espace libre qui lui est affecté dans la fenêtre, même en cas de redimensionnement à la souris (essaie!).

La contrepartie est que le redimensionnement du graphique seul ne marche pas: c'est la fenêtre qu'il faut redimensionner! Pareil pour la position de la fenêtre dans l'écran.

Il faut donc utiliser self.resize(w, h) au lieu de self.demo.resize(w, h). Pareil pour move(x, y). Tu pourrais aussi utiliser setGeometry(x, y, w, h).

[BlackoOSX]

Ok voilà ce que j'arrive à avoir:

Maintenant un autre problème me vient à l'esprit...
Mes combobox, boutons, labels, etc... ne doivent pas avoir les mêmes dimensions et je ne vois pas comment faire avec le QGridLayout....

[BlackoOSX]

Bonsoir,
J'ai pris QtDesigner pour faire la même fenêtre mais avec un QGridLayout redimensionné et placé sur ma fenêtre ce qui donne ça:



L'idée serait de faire un QGridLayout à une seule case et afficher le graphique dedans (Si c'est possible de faire comme ça je pense que c'est le plus simple possible).
Ensuite j'ai convertis le .ui en script Python3 qui utilise PyQt5 et j'ai copié-collé le code permettant d'afficher la graphique avec Qwt:

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
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
 
import sys
import numpy as np
from PyQt5 import QtCore, QtGui, QtWidgets
 
 
from qwt.qt.QtGui import QApplication, QPen
from qwt.qt.QtCore import Qt
from qwt import QwtPlot, QwtPlotMarker, QwtLegend, QwtPlotCurve, QwtText
 
 
class SimplePlot(QwtPlot):
    def __init__(self, *args):
        QwtPlot.__init__(self, *args)
        self.setTitle('ReallySimpleDemo.py')
        self.insertLegend(QwtLegend(), QwtPlot.RightLegend)
        self.setAxisTitle(QwtPlot.xBottom, 'x -->')
        self.setAxisTitle(QwtPlot.yLeft, 'y -->')
        self.enableAxis(self.xBottom)
 
        # insert a few curves
        cSin = QwtPlotCurve('y = sin(x)')
        cSin.setPen(QPen(Qt.red))
        cSin.attach(self)
        cCos = QwtPlotCurve('y = cos(x)')
        cCos.setPen(QPen(Qt.blue))
        cCos.attach(self)
 
        # make a Numeric array for the horizontal data
        x = np.arange(0.0, 10.0, 0.1)
 
        # initialize the data
        cSin.setData(x, np.sin(x))
        cCos.setData(x, np.cos(x))
 
        # insert a horizontal marker at y = 0
        mY = QwtPlotMarker()
        mY.setLabel(QwtText('y = 0'))
        mY.setLabelAlignment(Qt.AlignRight | Qt.AlignTop)
        mY.setLineStyle(QwtPlotMarker.HLine)
        mY.setYValue(0.0)
        mY.attach(self)
 
        # insert a vertical marker at x = 2 pi
        mX = QwtPlotMarker()
        mX.setLabel(QwtText('x = 2 pi'))
        mX.setLabelAlignment(Qt.AlignRight | Qt.AlignTop)
        mX.setLineStyle(QwtPlotMarker.VLine)
        mX.setXValue(2*np.pi)
        mX.attach(self)
 
        # replot
        self.replot()
 
 
 
class Ui_MainWindow(object):
    def setupUi(self, MainWindow):
        MainWindow.setObjectName("MainWindow")
        MainWindow.resize(1122, 649)
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("Icon.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        MainWindow.setWindowIcon(icon)
        MainWindow.setToolTipDuration(-10)
        MainWindow.setDocumentMode(False)
        self.centralwidget = QtWidgets.QWidget(MainWindow)
        self.centralwidget.setObjectName("centralwidget")
 
        #Tous les autres éléments graphiques
 
 
        self.gridLayoutWidget = QtWidgets.QWidget(self.centralwidget)
        self.gridLayoutWidget.setGeometry(QtCore.QRect(570, 80, 551, 541))
        self.gridLayoutWidget.setObjectName("gridLayoutWidget")
        self.gridLayout = QtWidgets.QGridLayout(self.gridLayoutWidget)
        self.gridLayout.setContentsMargins(0, 0, 0, 0)
        self.gridLayout.setObjectName("gridLayout")
        self.graphicsView = QtWidgets.QGraphicsView(self.gridLayoutWidget)
        self.graphicsView.setObjectName("graphicsView")
        self.gridLayout.addWidget(self.graphicsView, 0, 0, 1, 1)
        MainWindow.setCentralWidget(self.centralwidget)
 
        demo = SimplePlot(self)
        grid.addWidget(demo, 2, 2, 1, 1)
 
 
if __name__ == "__main__":
    app = QtWidgets.QApplication(sys.argv)
    MainWindow = QtWidgets.QMainWindow()
    ui = Ui_MainWindow()
    ui.setupUi(MainWindow)
    MainWindow.show()
    sys.exit(app.exec_())

Et j'ai cette erreur dans mon terminal:


Est-ce que vous avez une solution?
Merci d'avance!

[VinsS]

Il n'y a aucune raison de définir la géométrie du GridLayout, c'est quelque chose que l'on ne fait jamais.
Il faut laisser Qt gérer cela.

Au lieu de mettre "#Tous les autres éléments graphiques" montre nous le code complet de la fenêtre, je pense que tu n'as pas compris l'usage des layouts.

[tyrtamos]

Bonjour,

Si tu veux utiliser QtDesigner, mais que tu fais du "copier-coller" pour utiliser le code qui en est issu, ce n'est pas une bonne idée, car à chaque fois que tu modifieras le dessin avec QtDesigner, il te faudra recommencer... Je te propose plutôt de faire des importations. Voilà comment je ferais à ta place:

Je crée un répertoire spécifique pour le développement. Voilà un résumé de son contenu:
- monprogramme.py <= programme principal
- monprogramme_qwt.py <= la partie spécifique "Qwt"
- monprogramme_ui.ui <= le fichier issu directement de QtDesigner
- monprogramme_ui.bat <= le script de pyuic5 pour convertir le fichier "ui" en fichier "py" (tu adaptes à ton Linux)
- monprogramme_ui.py <= le fichier converti par le traitement par pyuic5

Pour le programme Qwt "monprogramme_qwt.py", j'ai fait un simple copier-coller du code de test sans aucune modification. A noter que lorsqu'un fichier Python est importé, la partie située sous if __name__ == "__main__": n'est jamais exécutée!

Pour le dessin fait avec QtDesigner, j'ai ajouté simplement dans la fenêtre un QGridLayout appelé "gridLayout" qui prend toute la place dédiée au futur graphique Qwt, mais sans rien dedans. Une fois le fichier monprogramme_ui.ui enregistrée, je lance le script monprogramme_ui.bat (pyuic5) et je récupère le fichier monprogramme_ui.py à jour, qu'il restera à importer.

Petite précision pour la mise en place du QGridLayout: quand tu as identifié la place destinée à recevoir le futur graphique, tu ajoutes le QGridLayout à la souris dans cette place. Il vient un petit rectangle rouge, mais ça ne suffit pas. Tu cliques alors dans la place mais en dehors du rectangle rouge, et tu cliques alors sur l’icône du menu qui ressemble à un damier: le rectangle rouge prend alors toute la place voulue => ça y est, le QGridLayout est prêt!

Le script monprogramme_ui.bat contient simplement:

Code :

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

pyuic5 monprogramme_ui.ui -o monprogramme_ui.py

Voilà maintenant le programme principal monprogramme.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
24
25
26
27
28
29
30
31
#!/usr/bin/python3
# -*- coding: utf-8 -*-
 
import sys
 
from PyQt5 import QtCore, QtGui, QtWidgets
 
from monprogramme_qwt import SimplePlot
 
from monprogramme_ui import Ui_MainWindow
 
##############################################################################
class MainWindow(QtWidgets.QMainWindow):
 
    def __init__(self, parent=None):
        super().__init__(parent)
 
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)
 
        self.demo = SimplePlot()
        self.ui.gridLayout.addWidget(self.demo)
 
        self.demo.exportTo("demo.png", size=(1600, 900), resolution=200)
 
############################################################################## 
if __name__ == "__main__":
    app = QtWidgets.QApplication(sys.argv)
    fenetre = MainWindow()
    fenetre.show()
    sys.exit(app.exec_())

Et voilà le résultat:



Tu vois qu'en s'y prenant comme ça, on évite les mélanges. Et quand tu devras modifier le dessin de la fenêtre avec QtDesigner, il te suffira de lancer de nouveau le script avec pyuic5 et ton programme principal n'aura qu'à être mis à jour des caractéristiques nouvelles du dessin.

A noter que pour un développement plus complexe, tu peux ajouter un sous-répertoire pour tous les modules utilitaires qui seront importés quand ce sera nécessaire. Ce sous-répertoire pouvant aussi contenir des sous-répertoires (etc...). Cela s'appelle en fait un "package" et il ne faudra pas oublier de mettre des "__init__.py" vides dans chaque sous-répertoire.

[BlackoOSX]

Bonsoir!
Merci beaucoup pour ces bons conseils.
Jusqu'à maintenant je n'avais jamais utilisé QtDesigner mais je codais entièrement la fenêtre.
Pour ce qui est du QGridLayout j'ai déjà réussi à mettre mon graphique dedans mais je n'ai peut-être pas utiliser les bons termes précédemment pour expliquer ma situation...
Je vais prendre l'exemple d'une fille de calcul parce que (si j'ai bien compris à le QGridLayout n'est qu'un tableau d'élément:


Voilà donc comment je vois ma fenêtre.
Mon problème c'est que avec le QGridLayout je ne peut pas (ou plutôt je n'arrive pas) à placer mes éléments correctement surtout que ma fenêtre n'a pas forcément des arrangement qui se feront dans un tableau...
Donc ma question est: Comment puis-je placer mes éléments dans un QGridLayout comme si j'étais dans une fenêtre normale [avec la même méthode que .moove(XXX, YYY)]?
Merci beaucoup de passer du temps à m'aider!

[VinsS]

Comme je l'ai dit précédemment, tous les widgets doivent être dans des layouts. Et ces layouts s'imbriquent entre eux.

Au lieu de te contenter de mettre "#Tous les autres éléments graphiques" montre nous réellement tout le code de la fenêtre.

Ce que tu veux faire est d'une très grande simplicité, il suffit de suivre les règles de construction d'une mainWindow redimensionnable.

[BlackoOSX]

Voici le code fait avec QtDesigner:

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
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
 
# -*- coding: utf-8 -*-
 
 
import sys
import numpy as np
from PyQt5 import QtCore, QtGui, QtWidgets
 
 
from qwt.PyQt5.QtGui import QApplication, QPen
from qwt.PyQt5.QtCore import Qt
from qwt import QwtPlot, QwtPlotMarker, QwtLegend, QwtPlotCurve, QwtText
 
 
class SimplePlot(QwtPlot):
    def __init__(self, *args):
        QwtPlot.__init__(self, *args)
 
 
        self.setCanvasBackground(Qt.Qt.white)
        self.alignScales()
 
 
        # Initialize data
        self.x = arange(0.0, 100.1, 0.5)
        self.y = zeros(len(self.x), Float)
        self.z = zeros(len(self.x), Float)
 
 
        self.setTitle("A Moving QwtPlot Demonstration")
        self.insertLegend(Qwt.QwtLegend(), Qwt.QwtPlot.BottomLegend);
 
 
        self.curveR = Qwt.QwtPlotCurve("Data Moving Right")
        self.curveR.attach(self)
        self.curveL = Qwt.QwtPlotCurve("Data Moving Left")
        self.curveL.attach(self)
 
 
        self.curveL.setSymbol(Qwt.QwtSymbol(Qwt.QwtSymbol.Ellipse,
                                        Qt.QBrush(),
                                        Qt.QPen(Qt.Qt.yellow),
                                        Qt.QSize(7, 7)))
 
 
        self.curveR.setPen(Qt.QPen(Qt.Qt.red))
        self.curveL.setPen(Qt.QPen(Qt.Qt.blue))
 
 
        mY = Qwt.QwtPlotMarker()
        mY.setLabelAlignment(Qt.Qt.AlignRight | Qt.Qt.AlignTop)
        mY.setLineStyle(Qwt.QwtPlotMarker.HLine)
        mY.setYValue(0.0)
        mY.attach(self)
 
 
        self.setAxisTitle(Qwt.QwtPlot.xBottom, "Time (seconds)")
        self.setAxisTitle(Qwt.QwtPlot.yLeft, "Values")
 
        self.startTimer(50)
        self.phase = 0.0
 
        # replot
        self.replot()
 
 
class Ui_MainWindow(object):
    def setupUi(self, MainWindow):
        MainWindow.setObjectName("MainWindow")
        MainWindow.resize(1122, 649)
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("Icon.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        MainWindow.setWindowIcon(icon)
        MainWindow.setToolTipDuration(-10)
        MainWindow.setDocumentMode(False)
        self.centralwidget = QtWidgets.QWidget(MainWindow)
        self.centralwidget.setObjectName("centralwidget")
        self.PrinterProfiles_label = QtWidgets.QLabel(self.centralwidget)
        self.PrinterProfiles_label.setGeometry(QtCore.QRect(20, 10, 141, 18))
        self.PrinterProfiles_label.setObjectName("PrinterProfiles_label")
        self.PrinterProfiles_comboBox = QtWidgets.QComboBox(self.centralwidget)
        self.PrinterProfiles_comboBox.setGeometry(QtCore.QRect(50, 35, 120, 30))
        self.PrinterProfiles_comboBox.setCurrentText("")
        self.PrinterProfiles_comboBox.setObjectName("PrinterProfiles_comboBox")
        self.Port_label = QtWidgets.QLabel(self.centralwidget)
        self.Port_label.setGeometry(QtCore.QRect(200, 10, 31, 18))
        self.Port_label.setObjectName("Port_label")
        self.Port_comboBox = QtWidgets.QComboBox(self.centralwidget)
        self.Port_comboBox.setGeometry(QtCore.QRect(230, 30, 230, 30))
        self.Port_comboBox.setObjectName("Port_comboBox")
        self.Baudrate_label = QtWidgets.QLabel(self.centralwidget)
        self.Baudrate_label.setGeometry(QtCore.QRect(480, 10, 61, 18))
        self.Baudrate_label.setObjectName("Baudrate_label")
        self.Baudrate_comboBox = QtWidgets.QComboBox(self.centralwidget)
        self.Baudrate_comboBox.setGeometry(QtCore.QRect(510, 30, 100, 30))
        self.Baudrate_comboBox.setObjectName("Baudrate_comboBox")
        self.Refresh_pushButton = QtWidgets.QPushButton(self.centralwidget)
        self.Refresh_pushButton.setGeometry(QtCore.QRect(630, 30, 88, 30))
        self.Refresh_pushButton.setObjectName("Refresh_pushButton")
 
        self.gridLayoutWidget = QtWidgets.QWidget(self.centralwidget)
        self.gridLayoutWidget.setGeometry(QtCore.QRect(570, 80, 551, 541))
        self.gridLayoutWidget.setObjectName("gridLayoutWidget")
        self.gridLayout = QtWidgets.QGridLayout(self.gridLayoutWidget)
        self.gridLayout.setContentsMargins(0, 0, 0, 0)
        self.gridLayout.setObjectName("gridLayout")
        self.graphicsView = QtWidgets.QGraphicsView(self.gridLayoutWidget)
        self.graphicsView.setObjectName("graphicsView")
        self.gridLayout.addWidget(self.graphicsView, 0, 0, 1, 1)
        MainWindow.setCentralWidget(self.centralwidget)
 
        demo = SimplePlot(self)
        grid.addWidget(demo, 2, 2, 1, 1)
 
 
        self.menubar = QtWidgets.QMenuBar(MainWindow)
        self.menubar.setGeometry(QtCore.QRect(0, 0, 1122, 30))
        self.menubar.setObjectName("menubar")
        self.menuFiles = QtWidgets.QMenu(self.menubar)
        self.menuFiles.setObjectName("menuFiles")
        self.menuEdit = QtWidgets.QMenu(self.menubar)
        self.menuEdit.setObjectName("menuEdit")
        self.menuPrinter_Profiles = QtWidgets.QMenu(self.menuEdit)
        self.menuPrinter_Profiles.setObjectName("menuPrinter_Profiles")
        self.menuPlastic_Profile = QtWidgets.QMenu(self.menuEdit)
        self.menuPlastic_Profile.setObjectName("menuPlastic_Profile")
        self.menuSettings = QtWidgets.QMenu(self.menubar)
        self.menuSettings.setObjectName("menuSettings")
        MainWindow.setMenuBar(self.menubar)
        self.statusbar = QtWidgets.QStatusBar(MainWindow)
        self.statusbar.setObjectName("statusbar")
        MainWindow.setStatusBar(self.statusbar)
        self.actionQuit = QtWidgets.QAction(MainWindow)
        self.actionQuit.setObjectName("actionQuit")
        self.actionQuit.triggered.connect(QtWidgets.QApplication.quit)
        self.actionNew_PrinterProfile = QtWidgets.QAction(MainWindow)
        self.actionNew_PrinterProfile.setObjectName("actionNew_PrinterProfile")
        self.actionEdit_PrinterProfile = QtWidgets.QAction(MainWindow)
        self.actionEdit_PrinterProfile.setObjectName("actionEdit_PrinterProfile")
        self.actionNew_PlasticProfile = QtWidgets.QAction(MainWindow)
        self.actionNew_PlasticProfile.setObjectName("actionNew_PlasticProfile")
        self.actionEdit_PlasticProfile = QtWidgets.QAction(MainWindow)
        self.actionEdit_PlasticProfile.setObjectName("actionEdit_PlasticProfile")
        self.actionAbout = QtWidgets.QAction(MainWindow)
        self.actionAbout.setObjectName("actionAbout")
        self.menuFiles.addAction(self.actionQuit)
        self.menuPrinter_Profiles.addAction(self.actionNew_PrinterProfile)
        self.menuPrinter_Profiles.addAction(self.actionEdit_PrinterProfile)
        self.menuPlastic_Profile.addAction(self.actionNew_PlasticProfile)
        self.menuPlastic_Profile.addAction(self.actionEdit_PlasticProfile)
        self.menuEdit.addAction(self.menuPrinter_Profiles.menuAction())
        self.menuEdit.addAction(self.menuPlastic_Profile.menuAction())
        self.menuSettings.addAction(self.actionAbout)
        self.menubar.addAction(self.menuFiles.menuAction())
        self.menubar.addAction(self.menuEdit.menuAction())
        self.menubar.addAction(self.menuSettings.menuAction())
 
 
        self.retranslateUi(MainWindow)
        QtCore.QMetaObject.connectSlotsByName(MainWindow)
 
 
    def retranslateUi(self, MainWindow):
        _translate = QtCore.QCoreApplication.translate
        MainWindow.setWindowTitle(_translate("MainWindow", "CNControl [1.0 - BETA]"))
        self.PrinterProfiles_label.setText(_translate("MainWindow", "List of printer profiles:"))
        self.PrinterProfiles_comboBox.setStatusTip(_translate("MainWindow", "Slect your printer profile to load the printer settings"))
        self.Port_label.setText(_translate("MainWindow", "Port:"))
        self.Port_comboBox.setStatusTip(_translate("MainWindow", "Select a prot to connect to the printer"))
        self.Baudrate_label.setText(_translate("MainWindow", "Baudrate:"))
        self.Baudrate_comboBox.setStatusTip(_translate("MainWindow", "Select the speed of the serial port transfer with your printer (default: 115200)"))
        self.Refresh_pushButton.setStatusTip(_translate("MainWindow", "Reload default settings"))
        self.Refresh_pushButton.setText(_translate("MainWindow", "Refresh"))
        self.menuFiles.setTitle(_translate("MainWindow", "Fi&les"))
        self.menuEdit.setTitle(_translate("MainWindow", "E&dit"))
        self.menuPrinter_Profiles.setTitle(_translate("MainWindow", "Printer Profiles"))
        self.menuPlastic_Profile.setTitle(_translate("MainWindow", "Plastic Profile"))
        self.menuSettings.setTitle(_translate("MainWindow", "Tools"))
        self.actionQuit.setText(_translate("MainWindow", "Quit"))
        self.actionQuit.setStatusTip(_translate("MainWindow", "Quit the application"))
        self.actionQuit.setShortcut(_translate("MainWindow", "Ctrl+Q"))
        self.actionNew_PrinterProfile.setText(_translate("MainWindow", "New Profile"))
        self.actionNew_PrinterProfile.setStatusTip(_translate("MainWindow", "Create a new profile for your printer"))
        self.actionEdit_PrinterProfile.setText(_translate("MainWindow", "Edit Profile"))
        self.actionEdit_PrinterProfile.setToolTip(_translate("MainWindow", "Edit Profile"))
        self.actionEdit_PrinterProfile.setStatusTip(_translate("MainWindow", "Edit an existing printer profile"))
        self.actionNew_PlasticProfile.setText(_translate("MainWindow", "New Profile"))
        self.actionNew_PlasticProfile.setStatusTip(_translate("MainWindow", "Create a new profile for your plastic"))
        self.actionEdit_PlasticProfile.setText(_translate("MainWindow", "Edit Profile"))
        self.actionEdit_PlasticProfile.setStatusTip(_translate("MainWindow", "Edit an existing plastic profile"))
        self.actionAbout.setText(_translate("MainWindow", "About CNControl"))
        self.actionAbout.setStatusTip(_translate("MainWindow", "About the application"))
 
 
if __name__ == "__main__":
    app = QtWidgets.QApplication(sys.argv)
    MainWindow = QtWidgets.QMainWindow()
    ui = Ui_MainWindow()
    ui.setupUi(MainWindow)
    MainWindow.show()
    sys.exit(app.exec_())

Et le code sans QtDesigner:

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
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
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
 
#!/usr/bin/python
# -*- coding: utf8 -*-
#Created by: HERMAN Adrien
#Version: 1.0 BETA
 
 
#Python Modules
import serial
import sys
import os
import serial
import time
import numpy as np
 
 
from PyQt5 import QtGui, QtCore, QtWidgets
from PyQt5.QtWidgets import QApplication, QMainWindow, QWidget, QAction, QLabel, QLineEdit, QInputDialog, QComboBox, QPushButton, QMessageBox, QGridLayout
 
 
from qwt.qt.QtGui import QApplication, QPen
from qwt.qt.QtCore import Qt
from qwt import QwtPlot, QwtPlotMarker, QwtLegend, QwtPlotCurve, QwtText
 
 
#CNControl Modules
from Settings import SettingsWindow as SettingsWindow
from Profile import New_PrinterProfileWindow, Edit_PrinterProfileWindow
from about import AboutWindow as AboutWindow
 
 
 
 
"""
Variables:
List_PrinterProfile --->        Global:
        -0: X Axis
        -1: Y Axis
        -2: Z Axis
        -3: Max Temp
        -4: Min Temp
        -5: Number of Extruders
        -6: Port
        -7: Baudrate
"""
 
 
 
 
class SimplePlot(QwtPlot):
	def __init__(self, *args):
		QwtPlot.__init__(self, *args)
		self.setTitle('ReallySimpleDemo.py')
		self.insertLegend(QwtLegend(), QwtPlot.RightLegend)
		self.setAxisTitle(QwtPlot.xBottom, 'x -->')
		self.setAxisTitle(QwtPlot.yLeft, 'y -->')
		self.enableAxis(self.xBottom)
 
		# insert a few curves
		cSin = QwtPlotCurve('y = sin(x)')
		cSin.setPen(QPen(Qt.red))
		cSin.attach(self)
		cCos = QwtPlotCurve('y = cos(x)')
		cCos.setPen(QPen(Qt.blue))
		cCos.attach(self)
 
		# make a Numeric array for the horizontal data
		x = np.arange(0.0, 10.0, 0.1)
 
		# initialize the data
		cSin.setData(x, np.sin(x))
		cCos.setData(x, np.cos(x))
 
		# insert a horizontal marker at y = 0
		mY = QwtPlotMarker()
		mY.setLabel(QwtText('y = 0'))
		mY.setLabelAlignment(Qt.AlignRight | Qt.AlignTop)
		mY.setLineStyle(QwtPlotMarker.HLine)
		mY.setYValue(0.0)
		mY.attach(self)
 
		# insert a vertical marker at x = 2 pi
		mX = QwtPlotMarker()
		mX.setLabel(QwtText('x = 2 pi'))
		mX.setLabelAlignment(Qt.AlignRight | Qt.AlignTop)
		mX.setLineStyle(QwtPlotMarker.VLine)
		mX.setXValue(2*np.pi)
		mX.attach(self)
 
		# replot
		self.replot()
 
 
 
 
class MainWindow(QMainWindow):
	def ChargePrinterProfile(self):
		global List_PrinterProfile
 
 
		Profiles_ComboBox = str(self.comboboxProfiles.currentText())
 
 
		if Profiles_ComboBox != "None":
			folder_path = "Profiles"
			if os.path.exists(folder_path+"/"+Profiles_ComboBox+".txt"):
				file = open(folder_path+"/"+Profiles_ComboBox+".txt", "r")
				List_PrinterProfile = []
 
 
				for i in file:
					List_PrinterProfile.append(i)
 
 
				file.close()
 
 
				i = 0
 
 
				for i in range(len(List_PrinterProfile)):
					Temp = List_PrinterProfile[i]
					List_PrinterProfile[i] = Temp[:len(Temp)-1]
 
 
					i += 1
 
 
				Ports = list(serial.tools.list_ports.comports())
				PortItem = List_PrinterProfile[8]
				self.comboboxPort.clear()
				self.comboboxPort.addItem(PortItem[:len(PortItem)-1])
 
 
				if Ports == []:
					self.comboboxPort.addItem("None")
				else:
					for ItemPort in Ports:
						if ItemPort != List_PrinterProfile[6]:
							for PortItem in Ports:
								PortItem = str(PortItem)
 
 
								i = 0
 
 
								while i < len(PortItem):
									if PortItem[i] == " ":
										break
									i += 1
 
 
								self.comboboxPort.addItem(PortItem[:i])
							self.comboboxPort.addItem("None")
 
 
				IndexComboBox_Baudrate = self.comboboxBaudrate.findText(List_PrinterProfile[9], QtCore.Qt.MatchCaseSensitive)
				self.comboboxBaudrate.setCurrentIndex(IndexComboBox_Baudrate)
		else:
			Ports = list(serial.tools.list_ports.comports())
			self.comboboxPort.clear()
 
 
			if Ports == []:
				self.comboboxPort.addItem("None")
			else:
				for PortItem in Ports:
					PortItem = str(PortItem)
 
 
					i = 0
 
 
					while i < len(PortItem):
						if PortItem[i] == " ":
							break
						i += 1
 
 
					self.comboboxPort.addItem(PortItem[:i])
				self.comboboxPort.addItem("None")
 
 
 
 
 
 
	def ConnectPrinter(self):
		global Connection_Port
 
 
		Port_ComboBox = str(self.comboboxPort.currentText())
		if Port_ComboBox == "None":
			messageboxEmptyInfos = QMessageBox.question(self, "Error", "No port selected!", QMessageBox.Ok)
		else:
			Baudrate_ComboBox = int(self.comboboxBaudrate.currentText())
 
 
			try:
				Connection_Port = serial.Serial(Port_ComboBox, Baudrate_ComboBox, timeout=0.1)
			except:
				messageboxConnectionFailed = QMessageBox.question(self, "Error", "Connection to the printer failed!\nCheck the Baudrate, the Connection Port and the USB connection with the printer.", QMessageBox.Ok)
 
 
	def openAbout(self):
		aboutWindow = QWidget()
		self.window = AboutWindow()
		self.window.SetupUi_AboutWindow()
		aboutWindow.show()
 
 
	def openSettings(self):
		settingsWindow = QWidget()
		self.window = SettingsWindow()
		self.window.SetupUi_SettingsWindow()
		settingsWindow.show()
 
 
	def openNew_profile(self):
		new_profileWindow = QWidget()
		self.window = New_PrinterProfileWindow()
		self.window.SetupUi_New_PrinterProfileWindow()
		new_profileWindow.show()
 
 
	def openEdit_profile(self):
		edit_profilewindow = QWidget()
		self.window = Edit_PrinterProfileWindow()
		self.window.SetupUi_Edit_PrinterProfileWindow()
		edit_profilewindow.show()
 
 
	def buttonRefresh(self):
		#Printer profiles
		PrinterProfile = []
		folder_path = "Profiles"
		for path, dirs, files in os.walk(folder_path):
			for filename in files:
				PrinterProfile.append(filename)
 
 
		self.comboboxProfiles.clear()
		self.comboboxProfiles.addItem("None")
 
 
		for profile in PrinterProfile:
			place_point = profile.index(".")
			self.comboboxProfiles.addItem(str(profile[0:place_point]))
 
 
		#Ports
		Ports = list(serial.tools.list_ports.comports())
		self.comboboxPort.clear()
 
 
		if Ports == []:
			self.comboboxPort.addItem("None")
		else:
			for PortItem in Ports:
				PortItem = str(PortItem)
 
 
				i = 0
 
 
				while i < len(PortItem):
					if PortItem[i] == " ":
						break
					i += 1
 
 
				self.comboboxPort.addItem(PortItem[:i])
 
 
		#Baudrate
		self.comboboxBaudrate.setCurrentIndex(0)
 
 
 
 
	def __init__(self):
		global List_PrinterProfile
 
 
		#Paramètres de la Fenêtre
		super().__init__()
 
 
		self.resize(900, 500)
		self.setWindowTitle("CNControl [1.0 BETA]")
 
 
		self.move(QApplication.desktop().screen().rect().center()- self.rect().center())
		self.setWindowIcon(QtGui.QIcon("Icon.png"))
 
 
		centralWidget = QWidget()
		grid = QGridLayout(centralWidget)
		grid.setGeometry(QtCore.QRect(100, 100, 600, 600))
 
 
 
 
		#Menu Bar
		mainMenu = self.menuBar()
		#	Menus
		fileMenu = mainMenu.addMenu("&Files")
		editMenu = mainMenu.addMenu("&Edit")
		toolsMenu = mainMenu.addMenu("&Tools")
		#	Sous-Menus
		#		Files
		#			Exit Button
		exitButton = QAction("&Exit", self)
		exitButton.setShortcut("Ctrl+Q")
		exitButton.setStatusTip("Leave the application")
		fileMenu.addAction(exitButton)
		exitButton.triggered.connect(self.close)
		#		Edit
		#			Edit Profile
		edit_profileButton = QAction("&Edit Printer Profile", self)
		edit_profileButton.setStatusTip("Edit an existing printer profile")
		editMenu.addAction(edit_profileButton)
		edit_profileButton.triggered.connect(self.openEdit_profile)
		#			New Profile
		new_profileButton = QAction("&New Printer Profile", self)
		new_profileButton.setStatusTip("Create a new 3D printer profile")
		editMenu.addAction(new_profileButton)
		new_profileButton.triggered.connect(self.openNew_profile)
		#		Tools
		#			Settings Button
		setButton = QAction("&Settings", self)
		setButton.setStatusTip("Set the application")
		toolsMenu.addAction(setButton)
		setButton.triggered.connect(self.openSettings)
		#			About Button
		aboutButton = QAction("&About CNControl", self)
		aboutButton.setStatusTip("About the application")
		toolsMenu.addAction(aboutButton)
		aboutButton.triggered.connect(self.openAbout)
 
 
		#Connection à l'imprimante
		#	Profils
		#		Label
		self.labelProfiles = QLabel("Profiles", self)
		self.labelProfiles.setText("List of printer profiles:")
		self.labelProfiles.move(10, 35)
		self.labelProfiles.resize(200, 20)
		#		ComboBox
		self.comboboxProfiles = QComboBox(self)
		self.comboboxProfiles.addItem("None")
 
 
		PrinterProfile = []
		folder_path = "Profiles"
		for path, dirs, files in os.walk(folder_path):
			for filename in files:
				PrinterProfile.append(filename)
 
 
		for profile in PrinterProfile:
			place_point = profile.index(".")
			self.comboboxProfiles.addItem(str(profile[0:place_point]))
 
 
		self.comboboxProfiles.move(30, 60)
		self.comboboxProfiles.resize(120, 30)
		self.comboboxProfiles.activated.connect(self.ChargePrinterProfile)
 
 
		#	Port
		#		Label
		self.labelPort = QLabel("Port", self)
		self.labelPort.setText("Port:")
		self.labelPort.move(170, 35)
		self.labelPort.resize(200, 20)
		#		Button
		self.buttonRefresh_PPP = QPushButton("Refresh", self)
		self.buttonRefresh_PPP.setStatusTip("Refresh the list of printer profile and the list of port")
		self.buttonRefresh_PPP.move(570, 60)
		self.buttonRefresh_PPP.clicked.connect(self.buttonRefresh)
		#		ComboBox
		self.comboboxPort = QComboBox(self)
		Ports = list(serial.tools.list_ports.comports())
 
 
		if Ports == []:
			self.comboboxPort.addItem("None")
		else:
			for PortItem in Ports:
				PortItem = str(PortItem)
 
 
				i = 0
 
 
				while i < len(PortItem):
					if PortItem[i] == " ":
						break
					i += 1
 
 
				self.comboboxPort.addItem(str(PortItem[:i]))
 
 
		self.comboboxPort.resize(230, 30)
		self.comboboxPort.move(190, 60)
 
 
		#	Baudrate
		#		Label
		self.labelBaudrate = QLabel("Baudrate", self)
		self.labelBaudrate.setText("Baudrate:")
		self.labelBaudrate.move(430, 35)
		self.labelBaudrate.resize(200, 20)
		#		ComboBox
		self.comboboxBaudrate = QComboBox(self)
		self.comboboxBaudrate.addItem("115200")
		self.comboboxBaudrate.addItem("57600")
		self.comboboxBaudrate.addItem("38400")
		self.comboboxBaudrate.addItem("28800")
		self.comboboxBaudrate.addItem("14400")
		self.comboboxBaudrate.addItem("9600")
		self.comboboxBaudrate.addItem("4800")
		self.comboboxBaudrate.addItem("2400")
		self.comboboxBaudrate.addItem("1200")
		self.comboboxBaudrate.addItem("600")
		self.comboboxBaudrate.addItem("300")
		self.comboboxBaudrate.move(450, 60)
 
 
		#	Connect to the printer
		#		Button
		self.buttonConnect = QPushButton("Connect to the printer", self)
		self.buttonConnect.move(690, 60)
		self.buttonConnect.resize(150, 30)
		self.buttonConnect.clicked.connect(self.ConnectPrinter)
		#	Variable
		List_PrinterProfile = []
 
 
		demo = SimplePlot(self)
		grid.addWidget(demo, 2, 2, 1, 1)
		MainWindow.setCentralWidget(self, centralWidget)
 
 
 
 
#Lancer la Fenêtre
app = QApplication(sys.argv)
GUI = MainWindow()
GUI.show()
sys.exit(app.exec_())

Petite question au passage: Je viens de changer Linux Mint pour Debian mais Qwt ne fonctionne pas normalement...
J'ai cru voir quelque part que ça ne fonctionnait pas sous Debian, est-ce vrai?

[VinsS]

C'est bien ce que je pensais, les widgets sont jetés en vrac dans le fenêtre. Définir leur géométrie n'est pas une solution il faut impérativement utiliser les layouts.

Regarde si ceci change convenablement les choses, j'ai pas testé.

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
 
class Ui_MainWindow(object):
    def setupUi(self, MainWindow):
        MainWindow.setObjectName("MainWindow")
        MainWindow.resize(1122, 649)
        icon = QtGui.QIcon()
        icon.addPixmap(QtGui.QPixmap("Icon.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
        MainWindow.setWindowIcon(icon)
        MainWindow.setToolTipDuration(-10)
        MainWindow.setDocumentMode(False)
        self.centralwidget = QtWidgets.QWidget(MainWindow)
        self.centralwidget.setObjectName("centralwidget")
        self.layout = QtWidgets.QHBoxLayout(self.centralwidget)
        self.grid = QtWidgets.QGridLayout()
        self.PrinterProfiles_label = QtWidgets.QLabel(self.centralwidget)
        self.PrinterProfiles_label.setObjectName("PrinterProfiles_label")
        self.grid.addWidget(self.PrinterProfiles_label, 0, 0, 1, 1)
 
        self.Port_label = QtWidgets.QLabel(self.centralwidget)
        self.Port_label.setObjectName("Port_label")
        self.grid.addWidget(self.Port_label, 0, 1, 1, 1)
 
        self.Baudrate_label = QtWidgets.QLabel(self.centralwidget)
        self.Baudrate_label.setObjectName("Baudrate_label")
        self.grid.addWidget(self.Baudrate_label, 0, 2, 1, 1)
 
        self.PrinterProfiles_comboBox = QtWidgets.QComboBox(self.centralwidget)
        self.PrinterProfiles_comboBox.setObjectName("PrinterProfiles_comboBox")
        self.grid.addWidget(self.PrinterProfiles_comboBox, 1, 0, 1, 1) 
 
        self.Port_comboBox = QtWidgets.QComboBox(self.centralwidget)
        self.Port_comboBox.setObjectName("Port_comboBox")
        self.grid.addWidget(self.Port_comboBox, 1, 1, 1, 1)
 
        self.Baudrate_comboBox = QtWidgets.QComboBox(self.centralwidget)
        self.Baudrate_comboBox.setObjectName("Baudrate_comboBox")
        self.grid.addWidget(self.Baudrate_comboBox, 1, 2, 1, 1)
 
        self.Refresh_pushButton = QtWidgets.QPushButton(self.centralwidget)
        self.Refresh_pushButton.setObjectName("Refresh_pushButton")
        self.grid.addWidget(self.Refresh_pushButton, 1, 3, 1, 1)
 
        self.layout.addLayout(self.grid)
        self.placeholder = QtWidgets.QWidget(self.centralwidget)
        self.grid1 = QtWidgets.QGridLayout(self.placeholder)
        self.gridLayout.setContentsMargins(0, 0, 0, 0)
        self.gridLayout.setObjectName("gridLayout")
        self.layout.addLayout(self.grid1)
        MainWindow.setCentralWidget(self.centralwidget)
 
        demo = SimplePlot(self)
        self.grid1.addWidget(demo, 2, 2, 1, 1)

Pour ton problème Mint versus Debian, je ne vois pas, je pensais que Mint était Debian inside, non ?

[BlackoOSX]

Avec votre code j'obtient cette erreur:

Code :

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

1
2
3
4
5
6
7
Traceback (most recent call last):
  File "test.py", line 94, in <module>
    ui.setupUi(MainWindow)
  File "test.py", line 51, in setupUi
    self.gridLayout.setContentsMargins(0, 0, 0, 0)
AttributeError: 'Ui_MainWindow' object has no attribute 'gridLayout'

J'ai donc enlevé à la ligne 51 le "self." sauf que "gridLayout" n'est définit nulle part...

Maintenant il y a autre chose que je ne comprends pas... Tous les tutoriels que j'ai vu m'ont tous appris à faire ma fenêtre avec des objets "flottants" et non dans un QGridLayout...
Pourquoi est-ce si important de faire cela?

[VinsS]

Mouais,

Code :

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

1
2
3
 
        self.gridLayout.setContentsMargins(0, 0, 0, 0)
        self.gridLayout.setObjectName("gridLayout")

devient:

Code :

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

1
2
3
 
        self.grid1.setContentsMargins(0, 0, 0, 0)
        self.grid1.setObjectName("grid1")

Ce que tu aurais put trouver par toi-même, si tu fais de la POO avec PyQt c'est que tu as les bases pour corriger des broutilles comme ça.

La raison d'utiliser des layouts (grilles de mise en page) c'est qu'ils rendent ton interface redimensionnable d'une part et ensuite tu laisses Qt gérer lui-même la présentation de l'interface.
exemple: l'utilisateur agrandit la fenêtre aux dimensions de son écran 4/3 ou 16/9 ou autre, Qt s'occupe que cela reste proportionné comme tu l'as dessiné.
Je suis d'ailleurs étonné que tu aies trouvé des tutos qui privilégient un usage sans layout.

[BlackoOSX]

Oui excusez-moi de ne pas avoir chercher cette fois-ci mais je me suis concentré sur QtDesigner parce que je n'avais pas du tout la même façon de faire (faire un fichier pour l'interface et le code).

Pour ce qui est des tutos qui n'apprennent pas à faire des layouts c'est que je me suis concentré sur les tutos débutants pour le moment (car je ne fais du Qt depuis même pas 1 mois). Et tous ces tutos ont un majeur défaut c'est justement qu'ils n'expliquent pas à faire ces layouts qui (maintenant que j'ai compris) sont vraiment la base de notre fenêtre !

J'ai trouvé quelqu'un qui explique bien tout cela sur YouTube avec QtDesigner donc je fais mon interface et je vous tiens au courant.

Merci beaucoup de votre aide ! 🙂