PyQt - Guide rapide

PyQt est une boîte à outils de widgets GUI. C'est une interface Python pourQt, l'une des bibliothèques d'interfaces graphiques multiplateformes les plus puissantes et les plus populaires. PyQt a été développé par RiverBank Computing Ltd. La dernière version de PyQt peut être téléchargée depuis son site officiel - riverbankcomputing.com

L'API PyQt est un ensemble de modules contenant un grand nombre de classes et de fonctions. Tandis queQtCore le module contient des fonctionnalités non-GUI pour travailler avec des fichiers et des répertoires, etc., QtGuiLe module contient toutes les commandes graphiques. De plus, il existe des modules pour travailler avec XML(QtXml), SVG (QtSvg)et SQL (QtSql), etc.

Environnements de soutien

PyQt est compatible avec tous les systèmes d'exploitation courants, notamment Windows, Linux et Mac OS. Il s'agit d'une double licence, disponible sous GPL ainsi que sous licence commerciale.

les fenêtres

Vous pouvez télécharger et installer un programme d'installation approprié à partir du lien de téléchargement ci-dessus correspondant à la version Python (2.7 ou 3.4) et à l'architecture matérielle (32 bits ou 64 bits). Notez qu'il existe deux versions de PyQt disponibles à savoir,PyQt 4.8 et PyQt 5.5.

Alors que PyQt4 est disponible pour Python 2 ainsi que Python 3, PyQt5 peut être utilisé avec Python 3. * uniquement.

PyQt4 Windows Binaries

PyQt4-4.11.4-gpl-Py3.4-Qt4.8.7-x64.exe	Programme d'installation de Windows 64 bits
PyQt4-4.11.4-gpl-Py3.4-Qt4.8.7-x32.exe	Programme d'installation de Windows 32 bits
PyQt4-4.11.4-gpl-Py3.4-Qt5.5.0-x64.exe	Programme d'installation de Windows 64 bits
PyQt4-4.11.4-gpl-Py3.4-Qt5.5.0-x32.exe	Programme d'installation de Windows 32 bits
PyQt4-4.11.4-gpl-Py2.7-Qt4.8.7-x64.exe	Programme d'installation de Windows 64 bits
PyQt4-4.11.4-gpl-Py2.7-Qt4.8.7-x32.exe	Programme d'installation de Windows 32 bits

PyQt5 Windows Binaries

PyQt5-5.5-gpl-Py3.4-Qt5.5.0-x64.exe	Programme d'installation de Windows 64 bits
PyQt5-5.5-gpl-Py3.4-Qt5.5.0-x32.exe	Programme d'installation de Windows 32 bits

Linux

Pour Ubuntu ou toute autre distribution Linux Debian, utilisez la commande suivante pour installer PyQt -

sudo apt-get install python-qt4
or 
sudo apt-get install pyqt5-dev-tools

Vous pouvez également construire à partir du code source disponible sur la page 'téléchargement'.

PyQt-x11-gpl-4.11.4.tar.gz	Linux, source UNIX pour PyQt4
PyQt-gpl-5.5.tar.gz	Source Linux, UNIX, MacOS / X pour PyQt5

Mac OS

Projet PyQtX (http://sourceforge.net/projects/pyqtx/) héberge les binaires de PyQt pour Mac. Utilisez le programme d'installation Homebrew selon la commande suivante -

brew install pyqt

La création d'une application GUI simple à l'aide de PyQt implique les étapes suivantes -

Importez le module QtGui.
Créez un objet d'application.
Un objet QWidget crée une fenêtre de niveau supérieur. Ajoutez un objet QLabel dedans.
Définissez la légende de l'étiquette comme "bonjour le monde".
Définissez la taille et la position de la fenêtre par la méthode setGeometry ().
Entrez dans la boucle principale de l'application en app.exec_() méthode.

import sys
from PyQt4 import QtGui

def window():
   app = QtGui.QApplication(sys.argv)
   w = QtGui.QWidget()
   b = QtGui.QLabel(w)
   b.setText("Hello World!")
   w.setGeometry(100,100,200,50)
   b.move(50,20)
   w.setWindowTitle(“PyQt”)
   w.show()
   sys.exit(app.exec_())
	
if __name__ == '__main__':
   window()

Le code ci-dessus produit la sortie suivante -

PyQt APIest une grande collection de classes et de méthodes. Ces classes sont définies dans plus de 20 modules. Voici quelques-uns des modules fréquemment utilisés -

Sr.No.	Modules et description
1	QtCore Classes non-GUI de base utilisées par d'autres modules
2	QtGui Composants de l'interface utilisateur graphique
3	QtMultimedia Cours de programmation multimédia de bas niveau
4	QtNetwork Cours de programmation réseau
5	QtOpenGL Classes de support OpenGL
6	QtScript Classes pour évaluer les scripts Qt
sept	QtSql Classes pour l'intégration de base de données à l'aide de SQL
8	QtSvg Classes d'affichage du contenu des fichiers SVG
9	QtWebKit Classes de rendu et d'édition HTML
dix	QtXml Classes de gestion du XML
11	QtAssistant Assistance pour l'aide en ligne
12	QtDesigner Classes pour étendre Qt Designer

L'API PyQt contient plus de 400 classes. leQObjectla classe est au sommet de la hiérarchie des classes. C'est la classe de base de tous les objets Qt. Aditionellement,QPaintDevice class est la classe de base de tous les objets qui peuvent être peints.

QApplicationclass gère les principaux paramètres et contrôle le flux d'une application GUI. Il contient une boucle d'événements principale à l'intérieur de laquelle les événements générés par les éléments de fenêtre et d'autres sources sont traités et distribués. Il gère également les paramètres à l'échelle du système et de l'application.

QWidget class, dérivée des classes QObject et QPaintDevice est la classe de base pour tous les objets d'interface utilisateur. QDialog et QFrameLes classes sont également dérivées de la classe QWidget. Ils ont leur propre système de sous-classes.

Les diagrammes suivants décrivent certaines classes importantes de leur hiérarchie.

Voici une liste de sélection de widgets fréquemment utilisés -

Vous trouverez ci-dessous les widgets couramment utilisés.

Sr.No.	Widgets et description
1	QLabel Utilisé pour afficher du texte ou une image
2	QLineEdit Permet à l'utilisateur de saisir une ligne de texte
3	QTextEdit Permet à l'utilisateur de saisir du texte sur plusieurs lignes
4	QPushButton Un bouton de commande pour appeler une action
5	QRadioButton Permet d'en choisir une parmi plusieurs options
6	QCheckBox Permet le choix de plusieurs options
sept	QSpinBox Permet d'augmenter / diminuer une valeur entière
8	QScrollBar Permet d'accéder au contenu d'un widget au-delà de l'ouverture d'affichage
9	QSlider Permet de modifier la valeur liée de manière linéaire.
dix	QComboBox Fournit une liste déroulante d'éléments à sélectionner
11	QMenuBar Barre horizontale contenant des objets QMenu
12	QStatusBar Habituellement, au bas de QMainWindow, fournit des informations d'état.
13	QToolBar Habituellement en haut de QMainWindow ou flottant. Contient des boutons d'action
14	QListView Fournit une liste sélectionnable d'éléments dans ListMode ou IconMode
15	QPixmap Représentation d'image hors écran pour affichage sur un objet QLabel ou QPushButton
16	QDialog Fenêtre modale ou non modale qui peut renvoyer des informations à la fenêtre parent

La fenêtre de niveau supérieur d'une application basée sur une interface graphique typique est créée par QMainWindowobjet widget. Certains widgets énumérés ci-dessus prennent leur place dans cette fenêtre principale, tandis que d'autres sont placés dans la zone centrale des widgets à l'aide de divers gestionnaires de disposition.

Le diagramme suivant montre le framework QMainWindow -

Le programme d'installation de PyQt est fourni avec un outil de création d'interface graphique appelé Qt Designer. En utilisant sa simple interface glisser-déposer, une interface graphique peut être rapidement construite sans avoir à écrire le code. Il ne s'agit cependant pas d'un IDE tel que Visual Studio. Par conséquent, Qt Designer n'a pas la possibilité de déboguer et de construire l'application.

La création d'une interface graphique à l'aide de Qt Designer commence par le choix d'une fenêtre de niveau supérieur pour l'application.

Vous pouvez ensuite faire glisser et déposer les widgets requis à partir de la boîte de widgets dans le volet gauche. Vous pouvez également attribuer une valeur aux propriétés du widget posé sur le formulaire.

Le formulaire conçu est enregistré sous demo.ui. Ce fichier ui contient une représentation XML des widgets et de leurs propriétés dans la conception. Cette conception est traduite en équivalent Python à l'aide de l'utilitaire de ligne de commande pyuic4. Cet utilitaire est un wrapper pour le module uic. L'utilisation de pyuic4 est la suivante -

pyuic4 –x demo.ui –o demo.py

Dans la commande ci-dessus, le commutateur -x ajoute une petite quantité de code supplémentaire au XML généré afin qu'il devienne une application autonome auto-exécutable.

if __name__ == "__main__":
   import sys
   app = QtGui.QApplication(sys.argv)
   Dialog = QtGui.QDialog()
   ui = Ui_Dialog()
   ui.setupUi(Dialog)
   Dialog.show()
   sys.exit(app.exec_())

Le script python résultant est exécuté pour afficher la boîte de dialogue suivante -

L'utilisateur peut saisir des données dans les champs de saisie, mais cliquer sur le bouton Ajouter ne générera aucune action car il n'est associé à aucune fonction. La réaction à la réponse générée par l'utilisateur est appeléeevent handling.

Contrairement à une application en mode console, qui est exécutée de manière séquentielle, une application basée sur l'interface graphique est pilotée par les événements. Les fonctions ou méthodes sont exécutées en réponse aux actions de l'utilisateur comme cliquer sur un bouton, sélectionner un élément dans une collection ou un clic de souris, etc., appeléevents.

Les widgets utilisés pour créer l'interface GUI agissent comme la source de ces événements. Chaque widget PyQt, qui est dérivé de la classe QObject, est conçu pour émettre 'signal'en réponse à un ou plusieurs événements. Le signal seul n'effectue aucune action. Au lieu de cela, il est 'connecté' à un 'slot». L'emplacement peut être n'importe quelcallable Python function.

Dans PyQt, la connexion entre un signal et un slot peut être réalisée de différentes manières. Voici les techniques les plus couramment utilisées -

QtCore.QObject.connect(widget, QtCore.SIGNAL(‘signalname’), slot_function)

Un moyen plus pratique d'appeler une fonction slot_function, lorsqu'un signal est émis par un widget est le suivant -

widget.signal.connect(slot_function)

Supposons si une fonction doit être appelée lorsqu'un bouton est cliqué. Ici, le signal cliqué doit être connecté à une fonction appelable. Il peut être réalisé dans l'une des deux techniques suivantes -

QtCore.QObject.connect(button, QtCore.SIGNAL(“clicked()”), slot_function)

button.clicked.connect(slot_function)

Exemple

Dans l'exemple suivant, deux objets QPushButton (b1 et b2) sont ajoutés dans la fenêtre QDialog. Nous voulons appeler les fonctions b1_clicked () et b2_clicked () en cliquant respectivement sur b1 et b2.

Lorsque b1 est cliqué, le signal clicked () est connecté à la fonction b1_clicked ()

b1.clicked.connect(b1_clicked())

Lorsque b2 est cliqué, le signal clicked () est connecté à la fonction b2_clicked ()

QObject.connect(b2, SIGNAL("clicked()"), b2_clicked)

Exemple

import sys
from PyQt4.QtCore import *
from PyQt4.QtGui import *

def window():
   app = QApplication(sys.argv)
   win = QDialog()
   b1 = QPushButton(win)
   b1.setText("Button1")
   b1.move(50,20)
   b1.clicked.connect(b1_clicked)

   b2 = QPushButton(win)
   b2.setText("Button2")
   b2.move(50,50)
   QObject.connect(b2,SIGNAL("clicked()"),b2_clicked)

   win.setGeometry(100,100,200,100)
   win.setWindowTitle("PyQt")
   win.show()
   sys.exit(app.exec_())

def b1_clicked():
   print "Button 1 clicked"

def b2_clicked():
   print "Button 2 clicked"

if __name__ == '__main__':
   window()

Le code ci-dessus produit la sortie suivante -

Production

Button 1 clicked
Button 2 clicked

Un widget GUI peut être placé à l'intérieur de la fenêtre du conteneur en spécifiant ses coordonnées absolues mesurées en pixels. Les coordonnées sont relatives aux dimensions de la fenêtre définies par la méthode setGeometry ().

Syntaxe setGeometry ()

QWidget.setGeometry(xpos, ypos, width, height)

Dans l'extrait de code suivant, la fenêtre de niveau supérieur de 300 x 200 pixels de dimensions est affichée à la position (10, 10) sur le moniteur.

import sys
from PyQt4 import QtGui

def window():
   app = QtGui.QApplication(sys.argv)
   w = QtGui.QWidget()
	
   b = QtGui.QPushButton(w)
   b.setText("Hello World!")
   b.move(50,20)
	
   w.setGeometry(10,10,300,200)
   w.setWindowTitle(“PyQt”)
   w.show()
   sys.exit(app.exec_())
	
if __name__ == '__main__':
   window()

UNE PushButton widget est ajouté dans la fenêtre et placé à une position de 50 pixels vers la droite et 20 pixels sous la position supérieure gauche de la fenêtre.

Ce Absolute Positioning, cependant, ne convient pas pour les raisons suivantes -

La position du widget ne change pas même si la fenêtre est redimensionnée.
L'apparence peut ne pas être uniforme sur différents périphériques d'affichage avec des résolutions différentes.
La modification de la mise en page est difficile car elle peut nécessiter une refonte de l'ensemble du formulaire.

L'API PyQt fournit des classes de mise en page pour une gestion plus élégante du positionnement des widgets à l'intérieur du conteneur. Les avantages des gestionnaires de mise en page par rapport au positionnement absolu sont:

Les widgets à l'intérieur de la fenêtre sont automatiquement redimensionnés.
Assure une apparence uniforme sur les périphériques d'affichage avec différentes résolutions.
L'ajout ou la suppression de widgets de manière dynamique est possible sans avoir à reconcevoir.

Voici la liste des classes dont nous parlerons une par une dans ce chapitre.

Sr.No.	Classes et description
1	QBoxLayout La classe QBoxLayout aligne les widgets verticalement ou horizontalement. Ses classes dérivées sont QVBoxLayout (pour organiser les widgets verticalement) et QHBoxLayout (pour organiser les widgets horizontalement).
2	QGridLayout Un objet de classe GridLayout présente une grille de cellules disposées en lignes et en colonnes. La classe contient la méthode addWidget (). Tout widget peut être ajouté en spécifiant le nombre de lignes et de colonnes de la cellule.
3	QFormLayout QFormLayout est un moyen pratique de créer un formulaire à deux colonnes, où chaque ligne se compose d'un champ d'entrée associé à une étiquette. Par convention, la colonne de gauche contient le libellé et la colonne de droite contient un champ de saisie.

Voici la liste des Widgets dont nous parlerons un par un dans ce chapitre.

Sr. Non	Widgets et description
1	QLabel Un objet QLabel agit comme un espace réservé pour afficher du texte ou une image non modifiable, ou un film de GIF animé. Il peut également être utilisé comme clé mnémotechnique pour d'autres widgets.
2	QLineEdit L'objet QLineEdit est le champ de saisie le plus couramment utilisé. Il fournit une boîte dans laquelle une ligne de texte peut être saisie. Afin de saisir du texte multiligne, l'objet QTextEdit est requis.
3	QPushButton Dans l'API PyQt, l'objet de classe QPushButton présente un bouton qui, lorsqu'il est cliqué, peut être programmé pour appeler une certaine fonction.
4	QRadioButton Un objet de classe QRadioButton présente un bouton sélectionnable avec une étiquette de texte. L'utilisateur peut sélectionner l'une des nombreuses options présentées sur le formulaire. Cette classe est dérivée de la classe QAbstractButton.
5	QCheckBox Une zone rectangulaire avant l'étiquette de texte apparaît lorsqu'un objet QCheckBox est ajouté à la fenêtre parente. Tout comme QRadioButton, il s'agit également d'un bouton sélectionnable.
6	QComboBox Un objet QComboBox présente une liste déroulante d'éléments à sélectionner. Il faut un espace d'écran minimum sur le formulaire requis pour afficher uniquement l'élément actuellement sélectionné.
sept	QSpinBox Un objet QSpinBox présente à l'utilisateur une zone de texte qui affiche un entier avec le bouton haut / bas à sa droite.
8	Widget et signal QSlider L'objet de classe QSlider présente à l'utilisateur une rainure sur laquelle une poignée peut être déplacée. C'est un widget classique pour contrôler une valeur bornée.
9	QMenuBar, QMenu et QAction Une QMenuBar horizontale juste en dessous de la barre de titre d'un objet QMainWindow est réservée à l'affichage des objets QMenu.
dix	QToolBar Un widget QToolBar est un panneau mobile composé de boutons de texte, de boutons avec des icônes ou d'autres widgets.
11	QInputDialog Il s'agit d'une boîte de dialogue préconfigurée avec un champ de texte et deux boutons, OK et Annuler. La fenêtre parente recueille l'entrée dans la zone de texte après que l'utilisateur clique sur le bouton OK ou appuie sur Entrée.
12	QFontDialog Une autre boîte de dialogue couramment utilisée, un widget de sélection de police, est l'apparence visuelle de la classe QDialog. Le résultat de cette boîte de dialogue est un objet Qfont, qui peut être utilisé par la fenêtre parente.
13	QFileDialog Ce widget est une boîte de dialogue de sélection de fichiers. Il permet à l'utilisateur de naviguer dans le système de fichiers et de sélectionner un fichier à ouvrir ou à enregistrer. Le dialogue est appelé via des fonctions statiques ou en appelant la fonction exec_ () sur l'objet de dialogue.
14	QTab Si un formulaire comporte trop de champs pour être affichés simultanément, ils peuvent être organisés en différentes pages placées sous chaque onglet d'un widget à onglets. Le QTabWidget fournit une barre d'onglets et une zone de page.
15	QStacked Le fonctionnement de QStackedWidget est similaire à celui de QTabWidget. Il contribue également à l'utilisation efficace de la zone client de Windows.
16	QSplitter Si un formulaire comporte trop de champs pour être affichés simultanément, ils peuvent être organisés en différentes pages placées sous chaque onglet d'un widget à onglets. Le QTabWidget fournit une barre d'onglets et une zone de page.
17	QDock Une fenêtre ancrable est une sous-fenêtre qui peut rester à l'état flottant ou peut être attachée à la fenêtre principale à une position spécifiée. L'objet de fenêtre principale de la classe QMainWindow a une zone réservée aux fenêtres ancrables.
18	QStatusBar L'objet QMainWindow réserve une barre horizontale en bas comme barre d'état. Il est utilisé pour afficher des informations d'état permanentes ou contextuelles.
19	QList La classe QListWidget est une interface basée sur des éléments pour ajouter ou supprimer des éléments d'une liste. Chaque élément de la liste est un objet QListWidgetItem. ListWidget peut être défini pour être multisélectionnable.
20	QScrollBar Un contrôle de barre de défilement permet à l'utilisateur d'accéder à des parties du document qui se trouvent en dehors de la zone visible. Il fournit un indicateur visuel de la position actuelle.
21	QCalendar Le widget QCalendar est un contrôle de sélection de date utile. Il fournit une vue mensuelle. L'utilisateur peut sélectionner la date à l'aide de la souris ou du clavier, la date par défaut étant la date du jour.

UNE QDialogwidget présente une fenêtre de niveau supérieur principalement utilisée pour collecter la réponse de l'utilisateur. Il peut être configuré pour êtreModal (où il bloque sa fenêtre parente) ou Modeless (la fenêtre de dialogue peut être contournée).

L'API PyQt a un certain nombre de widgets de dialogue préconfigurés tels que InputDialog, FileDialog, FontDialog, etc.

Exemple

Dans l'exemple suivant, l'attribut WindowModality de la fenêtre Dialog décide s'il est modal ou non modal. N'importe quel bouton de la boîte de dialogue peut être défini par défaut. La boîte de dialogue est ignorée par la méthode QDialog.reject () lorsque l'utilisateur appuie sur la touche Échap.

Un PushButton sur une fenêtre QWidget de niveau supérieur, lorsqu'on clique dessus, produit une fenêtre de dialogue. Une boîte de dialogue n'a pas de commandes de réduction et d'agrandissement sur sa barre de titre.

L'utilisateur ne peut pas reléguer cette boîte de dialogue en arrière-plan car sa WindowModality est définie sur ApplicationModal.

import sys
from PyQt4.QtGui import *
from PyQt4.QtCore import *

def window():
   app = QApplication(sys.argv)
   w = QWidget()
   b = QPushButton(w)
   b.setText("Hello World!")
   b.move(50,50)
   b.clicked.connect(showdialog)
   w.setWindowTitle("PyQt Dialog demo")
   w.show()
   sys.exit(app.exec_())
	
def showdialog():
   d = QDialog()
   b1 = QPushButton("ok",d)
   b1.move(50,50)
   d.setWindowTitle("Dialog")
   d.setWindowModality(Qt.ApplicationModal)
   d.exec_()
	
if __name__ == '__main__':
   window()

Le code ci-dessus produit la sortie suivante -

QMessageBoxest une boîte de dialogue modale couramment utilisée pour afficher un message d'information et demander éventuellement à l'utilisateur de répondre en cliquant sur l'un des boutons standard. Chaque bouton standard a une légende prédéfinie, un rôle et renvoie un nombre hexadécimal prédéfini.

Les méthodes et énumérations importantes associées à la classe QMessageBox sont données dans le tableau suivant -

Sr.No.	Méthodes et description
1	setIcon() Affiche l'icône prédéfinie correspondant à la gravité du message Question Information Attention Critique
2	setText() Définit le texte du message principal à afficher
3	setInformativeText() Affiche des informations supplémentaires
4	setDetailText() La boîte de dialogue affiche un bouton Détails. Ce texte apparaît en cliquant dessus
5	setTitle() Affiche le titre personnalisé de la boîte de dialogue
6	setStandardButtons() Liste des boutons standard à afficher. Chaque bouton est associé à QMessageBox.Ok 0x00000400 QMessageBox.Open 0x00002000 QMessageBox.Save 0x00000800 QMessageBox.Cancel 0x00400000 QMessageBox.Close 0x00200000 QMessageBox.Oui 0x00004000 QMessageBox.No 0x00010000 QMessageBox.Abort 0x00040000 QMessageBox.Retry 0x00080000 QMessageBox.Ignore 0x00100000
sept	setDefaultButton() Définit le bouton par défaut. Il émet le signal cliqué si vous appuyez sur Entrée
8	setEscapeButton() Définit le bouton à traiter comme cliqué si la touche d'échappement est enfoncée

Exemple

Dans l'exemple suivant, cliquez sur le signal du bouton dans la fenêtre de niveau supérieur, la fonction connectée affiche la boîte de dialogue de la boîte de message.

msg = QMessageBox()
msg.setIcon(QMessageBox.Information)
msg.setText("This is a message box")
msg.setInformativeText("This is additional information")
msg.setWindowTitle("MessageBox demo")
msg.setDetailedText("The details are as follows:")

La fonction setStandardButton () affiche les boutons souhaités.

msg.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)

Le signal buttonClicked () est connecté à une fonction de slot, qui identifie la légende de la source du signal.

msg.buttonClicked.connect(msgbtn)

Le code complet de l'exemple est le suivant -

import sys
from PyQt4.QtGui import *
from PyQt4.QtCore import *

def window():
   app = QApplication(sys.argv)
   w = QWidget()
   b = QPushButton(w)
   b.setText("Show message!")

   b.move(50,50)
   b.clicked.connect(showdialog)
   w.setWindowTitle("PyQt Dialog demo")
   w.show()
   sys.exit(app.exec_())
	
def showdialog():
   msg = QMessageBox()
   msg.setIcon(QMessageBox.Information)

   msg.setText("This is a message box")
   msg.setInformativeText("This is additional information")
   msg.setWindowTitle("MessageBox demo")
   msg.setDetailedText("The details are as follows:")
   msg.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)
   msg.buttonClicked.connect(msgbtn)
	
   retval = msg.exec_()
   print "value of pressed message box button:", retval
	
def msgbtn(i):
   print "Button pressed is:",i.text()
	
if __name__ == '__main__': 
   window()

Le code ci-dessus produit la sortie suivante -

Une application GUI typique peut avoir plusieurs fenêtres. Les widgets à onglets et empilés permettent d'activer une de ces fenêtres à la fois. Cependant, cette approche peut souvent ne pas être utile car la vue des autres fenêtres est masquée.

Une façon d'afficher plusieurs fenêtres simultanément consiste à les créer en tant que fenêtres indépendantes. Cela s'appelle SDI (interface de document unique). Cela nécessite plus de ressources mémoire car chaque fenêtre peut avoir son propre système de menus, sa propre barre d'outils, etc.

Les applications MDI (Multiple Document Interface) consomment moins de ressources mémoire. Les sous-fenêtres sont disposées à l'intérieur du conteneur principal les unes par rapport aux autres. Le widget conteneur est appeléQMdiArea.

Le widget QMdiArea occupe généralement le widget central de l'objet QMainWondow. Les fenêtres enfants de cette zone sont des instances de la classe QMdiSubWindow. Il est possible de définir n'importe quel QWidget comme widget interne de l'objet subWindow. Les sous-fenêtres de la zone MDI peuvent être organisées en cascade ou en mosaïque.

Le tableau suivant répertorie les méthodes importantes de la classe QMdiArea et de la classe QMdiSubWindow -

Sr.No.	Méthodes et description
1	addSubWindow() Ajoute un widget en tant que nouvelle sous-fenêtre dans la zone MDI
2	removeSubWindow() Supprime un widget qui est un widget interne d'une sous-fenêtre
3	setActiveSubWindow() Active une sous-fenêtre
4	cascadeSubWindows() Réorganise les sous-fenêtres dans MDiArea en cascade
5	tileSubWindows() Organise les sous-fenêtres dans MDiArea en mosaïque
6	closeActiveSubWindow() Ferme la sous-fenêtre active
sept	subWindowList() Renvoie la liste des sous-fenêtres dans la zone MDI
8	setWidget() Définit un QWidget comme un widget interne d'une instance QMdiSubwindow

L'objet QMdiArea émet le signal subWindowActivated () tandis que le signal windowStateChanged () est émis par l'objet QMdisubWindow.

Exemple

Dans l'exemple suivant, la fenêtre de niveau supérieur comprenant QMainWindow a un menu et MdiArea.

self.mdi = QMdiArea()
self.setCentralWidget(self.mdi)
bar = self.menuBar()
file = bar.addMenu("File")

file.addAction("New")
file.addAction("cascade")
file.addAction("Tiled")

Le signal déclenché () du menu est connecté à la fonction windowaction ().

file.triggered[QAction].connect(self.windowaction)

La nouvelle action de menu ajoute une sous-fenêtre dans la zone MDI avec un titre comportant un numéro incrémentiel.

MainWindow.count = MainWindow.count+1
sub = QMdiSubWindow()
sub.setWidget(QTextEdit())
sub.setWindowTitle("subwindow"+str(MainWindow.count))
self.mdi.addSubWindow(sub)
sub.show()

Les boutons en cascade et en mosaïque du menu organisent respectivement les sous-fenêtres actuellement affichées en cascade et en mosaïque.

Le code complet est le suivant -

import sys
from PyQt4.QtCore import *
from PyQt4.QtGui import *

class MainWindow(QMainWindow):
   count = 0
	
   def __init__(self, parent = None):
      super(MainWindow, self).__init__(parent)
      self.mdi = QMdiArea()
      self.setCentralWidget(self.mdi)
      bar = self.menuBar()
		
      file = bar.addMenu("File")
      file.addAction("New")
      file.addAction("cascade")
      file.addAction("Tiled")
      file.triggered[QAction].connect(self.windowaction)
      self.setWindowTitle("MDI demo")
		
   def windowaction(self, q):
      print "triggered"
		
   if q.text() == "New":
      MainWindow.count = MainWindow.count+1
      sub = QMdiSubWindow()
      sub.setWidget(QTextEdit())
      sub.setWindowTitle("subwindow"+str(MainWindow.count))
      self.mdi.addSubWindow(sub)
      sub.show()
		
   if q.text() == "cascade":
      self.mdi.cascadeSubWindows()
		
   if q.text() == "Tiled":
      self.mdi.tileSubWindows()
		
   def main():
      app = QApplication(sys.argv)
      ex = MainWindow()
      ex.show()
      sys.exit(app.exec_())
	
   if __name__ == '__main__':
      main()

Le code ci-dessus produit la sortie suivante -

La fourniture de drag and dropest très intuitif pour l'utilisateur. Il se trouve dans de nombreuses applications de bureau où l'utilisateur peut copier ou déplacer des objets d'une fenêtre à une autre.

Le transfert de données par glisser-déposer basé sur MIME est basé sur la classe QDrag. QMimeDatales objets associent les données à leur type MIME correspondant. Il est stocké dans le presse-papiers, puis utilisé dans le processus de glisser-déposer.

Les fonctions de classe QMimeData suivantes permettent de détecter et d'utiliser facilement le type MIME.

Testeur	Getter	Setter	Types MIME
hasText ()	texte()	Définir le texte()	texte simple
hasHtml ()	html ()	setHtml ()	texte / html
hasUrls ()	URL ()	setUrls ()	texte / liste-uri
hasImage ()	imageData ()	setImageData ()	image / *
hasColor ()	colorData ()	setColorData ()	application / couleur x

De nombreux objets QWidget prennent en charge l'activité de glisser-déposer. Ceux qui permettent de faire glisser leurs données ont setDragEnabled () qui doit être défini sur true. D'autre part, les widgets doivent répondre aux événements de glisser-déposer afin de stocker les données qui y sont glissées.

DragEnterEvent fournit un événement qui est envoyé au widget cible lorsque l'action de glissement y pénètre.
DragMoveEvent est utilisé lorsque l'action glisser-déposer est en cours.
DragLeaveEvent est généré lorsque l'action glisser-déposer quitte le widget.
DropEvent, d'autre part, se produit lorsque le dépôt est terminé. L'action proposée par l'événement peut être acceptée ou rejetée sous condition.

Exemple

Dans le code suivant, DragEnterEvent vérifie si les données MIME de l'événement contiennent du texte. Si oui, l'action proposée par l'événement est acceptée et le texte est ajouté en tant que nouvel élément dans le ComboBox.

import sys
from PyQt4.QtGui import *
from PyQt4.QtCore import *

class combo(QComboBox):

   def __init__(self, title, parent):
      super(combo, self).__init__( parent)
	
      self.setAcceptDrops(True)
		
   def dragEnterEvent(self, e):
      print e
		
      if e.mimeData().hasText():
         e.accept()
      else:
         e.ignore()
			
   def dropEvent(self, e):
      self.addItem(e.mimeData().text())
		
class Example(QWidget):

   def __init__(self):
      super(Example, self).__init__()
		
      self.initUI()
		
   def initUI(self):
      lo = QFormLayout()
      lo.addRow(QLabel("Type some text in textbox and drag it into combo box"))
		
      edit = QLineEdit()
      edit.setDragEnabled(True)
      com = combo("Button", self)
      lo.addRow(edit,com)
      self.setLayout(lo)
      self.setWindowTitle('Simple drag & drop')
		
def main():
   app = QApplication(sys.argv)
   ex = Example()
   ex.show()
   app.exec_()
	
if __name__ == '__main__':
   main()

Le code ci-dessus produit la sortie suivante -

L'API PyQt contient un système de classes élaboré pour communiquer avec de nombreuses bases de données SQL. Son QSqlDatabase fournit un accès via un objet Connection. Voici la liste des pilotes SQL actuellement disponibles -

Sr.No.	Type de pilote et description
1	QDB2 IBM DB2
2	QIBASE Pilote Borland InterBase
3	QMYSQL Pilote MySQL
4	QOCI Pilote d'interface d'appel Oracle
5	QODBC Pilote ODBC (inclut Microsoft SQL Server)
6	QPSQL Pilote PostgreSQL
sept	QSQLITE SQLite version 3 ou supérieure
8	QSQLITE2 SQLite version 2

Exemple

Une connexion avec une base de données SQLite est établie à l'aide de la méthode statique -

db = QtSql.QSqlDatabase.addDatabase('QSQLITE')
db.setDatabaseName('sports.db')

Les autres méthodes de la classe QSqlDatabase sont les suivantes -

Sr.No.	Méthodes et description
1	setDatabaseName() Définit le nom de la base de données avec laquelle la connexion est recherchée
2	setHostName() Définit le nom de l'hôte sur lequel la base de données est installée
3	setUserName() Spécifie le nom d'utilisateur pour la connexion
4	setPassword() Définit le mot de passe de l'objet de connexion, le cas échéant
5	commit() Valide les transactions et renvoie true en cas de succès
6	rollback() Annule la transaction de base de données
sept	close() Ferme la connexion

La classe QSqlQuery a la fonctionnalité pour exécuter et manipuler des commandes SQL. Les requêtes SQL de type DDL et DML peuvent être exécutées. La méthode la plus importante de la classe est exec_ (), qui prend comme argument une chaîne contenant une instruction SQL à exécuter.

query = QtSql.QSqlQuery()
query.exec_("create table sportsmen(id int primary key, 
   " "firstname varchar(20), lastname varchar(20))")

Le script suivant crée une base de données SQLite sports.db avec une table de sportifs remplie de cinq enregistrements.

from PyQt4 import QtSql, QtGui

def createDB():
   db = QtSql.QSqlDatabase.addDatabase('QSQLITE')
   db.setDatabaseName('sports.db')
	
   if not db.open():
      QtGui.QMessageBox.critical(None, QtGui.qApp.tr("Cannot open database"),
         QtGui.qApp.tr("Unable to establish a database connection.\n"
            "This example needs SQLite support. Please read "
            "the Qt SQL driver documentation for information "
            "how to build it.\n\n" "Click Cancel to exit."),
         QtGui.QMessageBox.Cancel)
			
      return False
		
   query = QtSql.QSqlQuery()
	
   query.exec_("create table sportsmen(id int primary key, "
      "firstname varchar(20), lastname varchar(20))")
		
   query.exec_("insert into sportsmen values(101, 'Roger', 'Federer')")
   query.exec_("insert into sportsmen values(102, 'Christiano', 'Ronaldo')")
   query.exec_("insert into sportsmen values(103, 'Ussain', 'Bolt')")
   query.exec_("insert into sportsmen values(104, 'Sachin', 'Tendulkar')")
   query.exec_("insert into sportsmen values(105, 'Saina', 'Nehwal')")
   return True
	
if __name__ == '__main__':
   import sys
	
   app = QtGui.QApplication(sys.argv)
   createDB()

La classe QSqlTableModel dans PyQt est une interface de haut niveau qui fournit un modèle de données modifiable pour la lecture et l'écriture d'enregistrements dans une seule table. Ce modèle est utilisé pour remplir un objet QTableView. Il présente à l'utilisateur une vue déroulante et modifiable qui peut être placée sur n'importe quelle fenêtre de niveau supérieur.

Un objet QTableModel est déclaré de la manière suivante -

model = QtSql.QSqlTableModel()

Sa stratégie d'édition peut être définie sur l'une des options suivantes:

QSqlTableModel.OnFieldChange	Tous les changements seront appliqués immédiatement
QSqlTableModel.OnRowChange	Les modifications seront appliquées lorsque l'utilisateur sélectionne une ligne différente
QSqlTableModel.OnManualSubmit	Toutes les modifications seront mises en cache jusqu'à ce que submitAll () ou revertAll () soit appelé

Exemple

Dans l'exemple suivant, la table des sportifs est utilisée comme modèle et la stratégie est définie comme -

model.setTable('sportsmen') 
model.setEditStrategy(QtSql.QSqlTableModel.OnFieldChange)

   model.select()

La classe QTableView fait partie du framework Model / View dans PyQt. L'objet QTableView est créé comme suit -

view = QtGui.QTableView()
view.setModel(model)
view.setWindowTitle(title)
return view

Cet objet QTableView et deux widgets QPushButton sont ajoutés à la fenêtre QDialog de niveau supérieur. Le signal cliqué () du bouton d'ajout est connecté à addrow () qui exécute insertRow () sur la table modèle.

button.clicked.connect(addrow)
def addrow():
   print model.rowCount()
   ret = model.insertRows(model.rowCount(), 1)
   print ret

L'emplacement associé au bouton de suppression exécute une fonction lambda qui supprime une ligne, qui est sélectionnée par l'utilisateur.

btn1.clicked.connect(lambda: model.removeRow(view1.currentIndex().row()))

Le code complet est le suivant -

import sys
from PyQt4 import QtCore, QtGui, QtSql
import sportsconnection

def initializeModel(model):
   model.setTable('sportsmen')
   model.setEditStrategy(QtSql.QSqlTableModel.OnFieldChange)
   model.select()
   model.setHeaderData(0, QtCore.Qt.Horizontal, "ID")
   model.setHeaderData(1, QtCore.Qt.Horizontal, "First name")
   model.setHeaderData(2, QtCore.Qt.Horizontal, "Last name")
	
def createView(title, model):
   view = QtGui.QTableView()
   view.setModel(model)
   view.setWindowTitle(title)
   return view
	
def addrow():
   print model.rowCount()
   ret = model.insertRows(model.rowCount(), 1)
   print ret
	
def findrow(i):
   delrow = i.row()
	
if __name__ == '__main__':

   app = QtGui.QApplication(sys.argv)
   db = QtSql.QSqlDatabase.addDatabase('QSQLITE')
   db.setDatabaseName('sports.db')
   model = QtSql.QSqlTableModel()
   delrow = -1
   initializeModel(model)
	
   view1 = createView("Table Model (View 1)", model)
   view1.clicked.connect(findrow)
	
   dlg = QtGui.QDialog()
   layout = QtGui.QVBoxLayout()
   layout.addWidget(view1)
	
   button = QtGui.QPushButton("Add a row")
   button.clicked.connect(addrow)
   layout.addWidget(button)
	
   btn1 = QtGui.QPushButton("del a row")
   btn1.clicked.connect(lambda: model.removeRow(view1.currentIndex().row()))
   layout.addWidget(btn1)
	
   dlg.setLayout(layout)
   dlg.setWindowTitle("Database Demo")
   dlg.show()
   sys.exit(app.exec_())

Le code ci-dessus produit la sortie suivante -

Tous les QWidgetles classes de PyQt sont sous-classées de la classe QPaintDevice. UNEQPaintDeviceest une abstraction d'espace bidimensionnel qui peut être dessinée en utilisant un QPainter. Les dimensions du dispositif de peinture sont mesurées en pixels à partir du coin supérieur gauche.

La classe QPainter effectue une peinture de bas niveau sur les widgets et autres périphériques pouvant être peints tels que l'imprimante. Normalement, il est utilisé dans l'événement de peinture du widget. leQPaintEvent se produit chaque fois que l'apparence du widget est mise à jour.

Le peintre est activé en appelant la méthode begin (), tandis que la méthode end () la désactive. Entre les deux, le motif souhaité est peint par des méthodes appropriées, comme indiqué dans le tableau suivant.

Sr.No.	Méthodes et description
1	begin() Commence à peindre sur l'appareil cible
2	drawArc() Dessine un arc entre l'angle de départ et l'angle final
3	drawEllipse() Dessine une ellipse à l'intérieur d'un rectangle
4	drawLine() Dessine une ligne avec les coordonnées des extrémités spécifiées
5	drawPixmap() Extrait le pixmap du fichier image et l'affiche à la position spécifiée
6	drwaPolygon() Dessine un polygone à l'aide d'un tableau de coordonnées
sept	drawRect() Dessine un rectangle commençant à la coordonnée en haut à gauche avec la largeur et la hauteur données
8	drawText() Affiche le texte aux coordonnées données
9	fillRect() Remplit le rectangle avec le paramètre QColor
dix	setBrush() Définit un style de pinceau pour la peinture
11	setPen() Définit la couleur, la taille et le style du stylo à utiliser pour le dessin

Styles QColor prédéfinis

Qt.NoBrush	Pas de motif de pinceau
Qt.SolidPattern	Couleur uniforme
Qt.Dense1Pattern	Motif de pinceau extrêmement dense
Qt.HorPattern	Lignes horizontales
Qt.VerPattern	Lignes verticales
Qt.CrossPattern	Traverser les lignes horizontales et verticales
Qt.BDiagPattern	Lignes diagonales vers l'arrière
Qt.FDiagPattern	Lignes diagonales avant
Qt.DiagCrossPattern	Traverser les lignes diagonales

Objets QColor prédéfinis

Qt. Blanc
Qt. noir
Qt.red
Qt.darkRed
Qt. Vert
Qt.darkGreen
Qt.bleu
Qt.cyan
Qt.magenta
Qt. Jaune
Qt.darkYellow
Qt.gray

La couleur personnalisée peut être choisie en spécifiant les valeurs RVB, CMJN ou HSV.

Exemple

L'exemple suivant implémente certaines de ces méthodes.

import sys
from PyQt4.QtGui import *
from PyQt4.QtCore import *

class Example(QWidget):

   def __init__(self):
      super(Example, self).__init__()
      self.initUI()
		
   def initUI(self):
      self.text = "hello world"
      self.setGeometry(100,100, 400,300)
      self.setWindowTitle('Draw Demo')
      self.show()
		
   def paintEvent(self, event):
      qp = QPainter()
      qp.begin(self)
      qp.setPen(QColor(Qt.red))
      qp.setFont(QFont('Arial', 20))
		
      qp.drawText(10,50, "hello Pyth
		on")
      qp.setPen(QColor(Qt.blue))
      qp.drawLine(10,100,100,100)
      qp.drawRect(10,150,150,100)
		
      qp.setPen(QColor(Qt.yellow))
      qp.drawEllipse(100,50,100,50)
      qp.drawPixmap(220,10,QPixmap("python.jpg"))
      qp.fillRect(200,175,150,100,QBrush(Qt.SolidPattern))
      qp.end()
		
def main():
   app = QApplication(sys.argv)
   ex = Example()
   sys.exit(app.exec_())
	
if __name__ == '__main__':
   main()

Le code ci-dessus produit la sortie suivante -

le QClipboardLa classe donne accès au presse-papiers à l'échelle du système qui offre un mécanisme simple pour copier et coller des données entre les applications. Son action est similaire à la classe QDrag et utilise des types de données similaires.

La classe QApplication a une méthode statique clipboard () qui renvoie une référence à un objet clipboard. Tout type de MimeData peut être copié ou collé à partir du presse-papiers.

Voici les méthodes de classe de presse-papiers qui sont couramment utilisées -

Sr.No.	Méthodes et description
1	clear() Efface le contenu du presse-papiers
2	setImage() Copie QImage dans le presse-papiers
3	setMimeData() Définit les données MIME dans le presse-papiers
4	setPixmap() Copie l'objet Pixmap dans le presse-papiers
5	setText() Copie QString dans le presse-papiers
6	text() Récupère le texte du presse-papiers

Le signal associé à l'objet presse-papiers est -

Sr.No.	Méthode et description
1	dataChanged() Chaque fois que les données du presse-papiers changent

Exemple

Dans l'exemple suivant, deux objets TextEdit et deux boutons de commande sont ajoutés à une fenêtre de niveau supérieur.

Pour commencer, l'objet presse-papiers est instancié. La méthode Copy () de l'objet textedit copie les données dans le presse-papiers du système. Lorsque vous cliquez sur le bouton Coller, il récupère les données du presse-papiers et les colle dans un autre objet textedit.

QPixmapclasse fournit une représentation hors écran d'une image. Il peut être utilisé comme objet QPaintDevice ou peut être chargé dans un autre widget, généralement une étiquette ou un bouton.

L'API Qt a une autre classe similaire QImage, optimisée pour les E / S et autres manipulations de pixels. Pixmap, d'autre part, est optimisé pour l'afficher à l'écran. Les deux formats sont interconvertibles.

Les types de fichiers image qui peuvent être lus dans un objet QPixmap sont les suivants -

BMP	Bitmap Windows
GIF	Format d'échange graphique (facultatif)
JPG	Groupe conjoint d'experts photographiques
JPEG	Groupe conjoint d'experts photographiques
PNG	Portable Network Graphics
PBM	Bitmap portable
PGM	Graymap portable
PPM	Pixmap portable
XBM	Bitmap X11
XPM	Pixmap X11

Les méthodes suivantes sont utiles pour gérer l'objet QPixmap -

Sr.No.	Méthodes et description
1	copy() Copie les données pixmap d'un objet QRect
2	fromImage() Convertit l'objet QImage en QPixmap
3	grabWidget() Crée un pixmap à partir du widget donné
4	grabWindow() Créer une pixmap de données dans une fenêtre
5	Load() Charge un fichier image en tant que pixmap
6	save() Enregistre l'objet QPixmap sous forme de fichier
sept	toImage Convertit un QPixmap en QImage

L'utilisation la plus courante de QPixmap est d'afficher une image sur une étiquette / un bouton.

Exemple

L'exemple suivant montre une image affichée sur un QLabel à l'aide de la méthode setPixmap (). Le code complet est le suivant -

import sys
from PyQt4.QtCore import *
from PyQt4.QtGui import *

def window():
   app = QApplication(sys.argv)
   win = QWidget()
   l1 = QLabel()
   l1.setPixmap(QPixmap("python.jpg"))
	
   vbox = QVBoxLayout()
   vbox.addWidget(l1)
   win.setLayout(vbox)
   win.setWindowTitle("QPixmap Demo")
   win.show()
   sys.exit(app.exec_())
	
if __name__ == '__main__':
   window()

Le code ci-dessus produit la sortie suivante -

↰ Previous page

PyQt - Guide rapide

Environnements de soutien

les fenêtres

Linux

Mac OS

Exemple

Exemple

Production

Syntaxe setGeometry ()

Exemple

Exemple

Exemple

Exemple

Exemple

Exemple

Styles QColor prédéfinis

Objets QColor prédéfinis

Exemple

Exemple

Exemple

Tutoriel PyQt

Ressources utiles PyQt