La FAQ PyQt & PySide
La FAQ PyQt & PySideConsultez toutes les FAQ
Nombre d'auteurs : 4, nombre de questions : 38, dernière mise à jour : 29 août 2021
Afin de centrer la fenêtre d'une application au milieu de l'écran, nous allons utiliser la fonction QDesktopWidget().screenGeometry(), qui permettra de connaître la taille de l'écran, et la fonction geometry(), qui renvoie la taille de la fenêtre.
import
sys
from
PySide import
QtGui
class
Frame
(
QtGui.QWidget):
def
__init__
(
self, parent=
None
):
QtGui.QWidget.__init__
(
self, parent)
self.resize
(
600
,500
)
size_ecran =
QtGui.QDesktopWidget
(
).screenGeometry
(
)
"""Renvoie la taille de l'écran. Cette ligne nous permettra par la suite de connaître la hauteur et la largeur de l'écran."""
size_fenetre =
self.geometry
(
)
"""Même chose que ci-dessus mais avec la fenêtre de l'application."""
self.move
((
size_ecran.width
(
)-
size_fenetre.width
(
))/
2
, (
size_ecran.height
(
)-
size_fenetre.height
(
))/
2
)
"""La fonction move() permet de déplacer la fenêtre aux coordonnées passées en arguments.
Dans le premier cas on centre horizontalement la fenêtre, puis verticalement.
Exemple : si l'écran fait 900 pixels de large, la fenêtre, 400, le calcul pour centrer la fenêtre est bien (900-400) / 2 soit 250.
Nous aurons donc 250 pixels d'espace, une fenêtre de 400 pixels, 250 pixels d'espace soit bien 900 pixels au total."""
app =
QtGui.QApplication
(
sys.argv)
frame =
Frame
(
)
frame.show
(
)
sys.exit
(
app.exec_
(
))
Qt propose la classe QSplashScreen pour simplifier la gestion des pages de démarrage. Une page de démarrage est une image affichée lors du démarrage d'un programme, pour masquer un démarrage lent ou tout simplement par marketing.
Cette page se fermera si l'on clique dessus (dans l'exemple ci-dessous, le programme est volontairement figé
pour que l'on puisse bien voir la page d'accueil, ce qui bloque a priori cette fonction).
QSplashScreen est lancé avant la boucle d'événement de l'application, il est donc préférable d'appeler
QApplication::processEvents() de temps en temps pour traiter les événements en cours.
# -*- coding: iso-8859-1 -*-
import
sys
from
PySide import
QtGui
import
time
##Création de la fenêtre principale.
class
Frame
(
QtGui.QWidget):
def
__init__
(
self, parent=
None
):
QtGui.QWidget.__init__
(
self, parent)
self.resize
(
600
,500
)
size_ecran =
QtGui.QDesktopWidget
(
).screenGeometry
(
)
size_fenetre =
self.geometry
(
)
app =
QtGui.QApplication
(
sys.argv)
## Création d'un widget QPixmap qui permet d'accéder à l'image img.JPG. img.JPG doit être dans le répertoire courant.
pixmap =
QtGui.QPixmap
(
"img.JPG"
)
## Création de la page d'accueil.
splash =
QtGui.QSplashScreen
(
pixmap)
splash.show
(
)
app.processEvents
(
)
## Ici, je fige volontairement le code pour que nous puissions bien voir la page d'accueil.
time.sleep
(
5
)
frame =
Frame
(
)
frame.show
(
)
splash.finish
(
frame)
sys.exit
(
app.exec_
(
))
Afin de créer un combobox (liste déroulante mais avec un seul élément affichable) on fait appelle à la classe QtGui.QComboBox.
# -*- coding: iso-8859-1 -*-
import
sys
from
PySide import
QtGui
## Liste qui nous servira à remplir le combobox.
liste =
["Ligne 1"
, "Ligne 2"
, "ALigne 1"
, "BLigne 2"
, "BLigne 1"
]
class
Frame
(
QtGui.QWidget):
def
__init__
(
self, parent=
None
):
QtGui.QWidget.__init__
(
self, parent)
self.resize
(
600
,500
)
self.setFont
(
QtGui.QFont
(
"Verdana"
))
self.setWindowTitle
(
"ComboBox"
)
## Création de notre ComboBox
self.cb =
QtGui.QComboBox
(
self)
self.cb.setGeometry
(
10
,10
,300
,25
)
## Ajout des éléments de liste en tant qu'Item
self.cb.addItems
(
liste)
## Ajout manuel d'un item
self.cb.addItem
(
'Essai'
)
btn =
QtGui.QPushButton
(
"Action"
,self)
btn.move
(
10
,40
)
btn.clicked.connect
(
self.action_1)
btn_2 =
QtGui.QPushButton
(
"Insertion"
,self)
btn_2.move
(
90
,40
)
btn_2.clicked.connect
(
self.action_2)
btn_3 =
QtGui.QPushButton
(
"Effacer les choix"
,self)
btn_3.move
(
170
,40
)
btn_3.clicked.connect
(
self.action_3)
btn_4 =
QtGui.QPushButton
(
"Réinitialiser la liste"
,self)
btn_4.move
(
10
,70
)
btn_4.clicked.connect
(
self.action_4)
self.label =
QtGui.QLabel
(
""
, self)
self.label.setGeometry
(
320
,10
,100
,50
)
## Récupération du texte courant
def
action_1
(
self):
self.label.setText
(
self.cb.currentText
(
))
## Insertion d'un Item et d'un séparateur aux positions voulues
def
action_2
(
self):
self.cb.insertItem
(
1
,"Insertion"
)
self.cb.insertSeparator
(
2
)
## Suppression de tous les items
def
action_3
(
self):
self.cb.clear
(
)
## Suppression de tous les items et rechargement de ceux d'origine.
def
action_4
(
self):
self.cb.clear
(
)
self.cb.addItems
(
liste)
app =
QtGui.QApplication
(
sys.argv)
frame =
Frame
(
)
frame.show
(
)
sys.exit
(
app.exec_
(
))
Dans vos applications vous rencontrerez certainement le besoin de générer un document PDF. Qt offre de nombreux moyens permettant ceci et, tout naturellement, PyQt ou PySide aussi. Il y a cependant une solution très simple pour ceux ayant quelques notions en HTML.
Il existe deux objets Qt qui permettent de créer à volonté des documents. Il s'agit de QTextDocument, qui permet de travailler avec du texte formaté, et de QPrinter, qui permet de générer le document.
- loadResource(type, name) : récupère les données d'un fichier référencé sous le nom name et s'en sert par la suite comme modèle pour remplir le document ;
- setHtml(texte) : traite un texte passé comme du texte HTML ; elle permettra donc de traiter les balises HTML comme telles dans le futur document ;
- print_(printer) : cette fonction permet d'envoyer le texte formaté à un système d'impression qui sera défini par QPrinter.
QPrinter peut permettre de sélectionner une imprimante mais aussi de générer directement des documents. C'est cette fonction qui nous intéresse particulièrement.
# coding: Latin-1 -*-
import
sys
from
PySide import
QtGui, QtCore
Appli=
QtGui.QApplication
(
sys.argv)
## Création de l'objet printer qui permettra de générer le document.
printer=
QtGui.QPrinter
(
)
## Notification du fichier de destination.
## Si cette ligne est oubliée c'est directement vers l'imprimante par défaut que sera envoyé le document.
printer.setOutputFileName
(
"essai.pdf"
)
## Création d'un objet QTextDocument qui servira à compléter le document prochainement généré.
doc =
QtGui.QTextDocument
(
)
## Récupération du document index.html et qui nous servira de modèle par la suite.
ressource =
doc.loadResource
(
QtGui.QTextDocument.HtmlResource, QtCore.QUrl
(
"index.html"
))
## Cette ligne montre comment personnaliser notre document. Il faudra cependant s'assurer que la balise {{nom}} est bien présente dans le modèle HTML.
## A noter que cette balise peut prendre n'importe quelle valeur. Il faut juste s'assurer de ne pas remplacer des termes non souhaités.
ressource.replace
(
"{{nom}}"
, "Toto"
)
## Permettra de dire à l'objet doc que le texte passé devra être traiter comme du HTML.
doc.setHtml
(
str(
ressource))
## Génère le document voulu
doc.print_
(
printer)
- QPrinter sait générer automatiquement des fichiers PostScript et PDF ; pour les autres formats, il faut passer par la méthode setOutputFormat(format) ;
- si la méthode setOutputFileName(name) n'est pas renseignée, c'est directement vers l'imprimante par défaut de votre système que le document sera envoyé.
- il est possible que certaines balises HTML ne soient pas prises en compte, je ne les ai évidemment pas toutes testées.
Lien : Les sources