PyQt5 - 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.

Une liste des modules fréquemment utilisés est donnée ci-dessous -

  • QtCore - Classes non-GUI de base utilisées par d'autres modules

  • QtGui - Composants d'interface utilisateur graphique

  • QtMultimedia - Cours de programmation multimédia de bas niveau

  • QtNetwork - Cours de programmation réseau

  • QtOpenGL - Classes de support OpenGL

  • QtScript - Classes pour évaluer les scripts Qt

  • QtSql - Classes d'intégration de base de données à l'aide de SQL

  • QtSvg - Classes pour afficher le contenu des fichiers SVG

  • QtWebKit - Classes de rendu et d'édition HTML

  • QtXml - Classes de gestion de XML

  • QtWidgets - Classes pour créer des interfaces utilisateur classiques de style bureau

  • QtDesigner - Classes pour étendre Qt Designer

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. La dernière version stable estPyQt5-5.13.2.

les fenêtres

Des roues pour architecture 32 bits ou 64 bits sont fournies et sont compatibles avec Python version 3.5 ou ultérieure. La méthode d'installation recommandée consiste à utiliserPIP utilité -

pip3 install PyQt5

Pour installer des outils de développement tels que Qt Designer pour prendre en charge les roues PyQt5, voici la commande -

pip3 install pyqt5-tools

Vous pouvez également créer PyQt5 sur Linux / macOS à partir du code source www.riverbankcomputing.com/static/Downloads/PyQt5

L'API PyQt5 n'est pas automatiquement compatible avec les versions antérieures. Par conséquent, le code Python impliquant des modules PyQt4 doit être mis à niveau manuellement en apportant les modifications appropriées. Dans ce chapitre, les principales différences entre PyQt4 et PyQt5 ont été répertoriées.

PyQt5 n'est pas pris en charge sur les versions de Python antérieures à la v2.6.

PyQt5 ne prend pas en charge la méthode connect () de la classe QObject pour la connexion entre le signal et le slot. Par conséquent, l'utilisation ne peut plus être mise en œuvre -

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

Seule la syntaxe suivante est définie -

widget.signal.connect(slot_function)

Les classes définies dans le module QtGui précédent ont été distribuées dans QtGui, QtPrintSupport un QtWidgets modules.

Dans la nouvelle classe QFileDialog, The getOpenFileNameAndFilter() la méthode est remplacée par getOpenFileName(), getOpenFileNamesAndFilter() par getOpenFileNames() et getSaveFileNameAndFilter() par getSaveFileName(). Les anciennes signatures de ces méthodes ont également changé.

PyQt5 n'a pas de disposition pour définir une classe qui est sous-classée à partir de plus d'une classe Qt.

pyuic5 L'utilitaire (pour générer du code Python à partir du fichier XML de Designer) ne prend pas en charge l'indicateur --pyqt3-wrapper.

pyrcc5ne prend pas en charge les indicateurs -py2 et -py3. La sortie de pyrcc5 est compatible avec toutes les versions de Python v2.6 et suivantes.

PyQt5 invoque toujours sip.setdestroyonexit() automatiquement et appelle le destructeur C ++ de toutes les instances encapsulées dont il est propriétaire.

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

  • Importez les modules QtCore, QtGui et QtWidgets à partir du package PyQt5.

  • Créez un objet d'application de la classe QApplication.

  • 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.

Voici le code pour exécuter le programme Hello World dans PyQt -

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

Le code ci-dessus produit la sortie suivante -

Il est également possible de développer une solution orientée objet du code ci-dessus.

  • Importez les modules QtCore, QtGui et QtWidgets à partir du package PyQt5.

  • Créez un objet d'application de la classe QApplication.

  • Déclarer une classe de fenêtre basée sur la classe QWidget

  • Ajoutez un objet QLabel et 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.

Voici le code complet de la solution orientée objet -

import sys
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
class window(QWidget):
   def __init__(self, parent = None):
      super(window, self).__init__(parent)
      self.resize(200,50)
      self.setWindowTitle("PyQt5")
      self.label = QLabel(self)
      self.label.setText("Hello World")
      font = QFont()
      font.setFamily("Arial")
      font.setPointSize(16)
      self.label.setFont(font)
      self.label.move(50,20)
def main():
   app = QApplication(sys.argv)
   ex = window()
   ex.show()
   sys.exit(app.exec_())
if __name__ == '__main__':
   main()

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 -

N ° Sr. 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

QtWidgets

Classes pour créer des interfaces utilisateur classiques de style bureau.

12

QtDesigner

Classes pour étendre Qt Designer

13

QtAssistant

Assistance pour l'aide en ligne

Les outils de développement PyQt5 sont une collection d'utilitaires utiles pour le développement Qt. Voici une liste de sélection de ces utilitaires -

N ° Sr. Nom et description de l'outil
1

assistant

Outil de documentation Qt Assistant

2

pyqt5designer

Outil de mise en page de l'interface graphique Qt Designer

3

linguist

Outil de traduction Qt Linguist

4

lrelease

compiler les fichiers ts en fichiers qm

5

pylupdate5

extraire les chaînes de traduction et générer ou mettre à jour les fichiers TS

6

qmake

Outil de création de logiciel Qt

sept

pyqt5qmlscene

Visionneuse de fichiers QML

8

pyqmlviewer

Visionneuse de fichiers QML

9

pyrcc5

Compilateur de fichiers de ressources Qt

dix

pyuic5

Compilateur d'interface utilisateur Qt pour générer du code à partir de fichiers d'interface utilisateur

11

pyqmltestrunner

exécution de tests unitaires sur du code QML

12

qdbus

outil de ligne de commande pour répertorier les services D-Bus

13

QDoc

générateur de documentation pour projets logiciels.

14

Qhelpgenerator

générer et afficher les fichiers d'aide Qt.

15

qmlimportscanner

analyse et rapporte les importations QML

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.

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

N ° Sr. 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.

Démarrez l'application Qt Designer qui fait partie des outils de développement et est installée dans le dossier scripts de l'environnement virtuel.

Commencez à concevoir l'interface GUI en choisissant le menu Fichier → Nouveau.

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 pyuic5. Cet utilitaire est un wrapper pour le module uic de la boîte à outils Qt. L'utilisation de pyuic5 est la suivante -

pyuic5 -x demo.ui -o demo.py

Dans la commande ci-dessus, le commutateur -x ajoute une petite quantité de code supplémentaire au script Python généré (à partir de XML) 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 -

python demo.py

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.

Utilisation de l'éditeur de signal / slot de Qt Designer

Commencez par concevoir un formulaire simple avec un contrôle LineEdit et un PushButton.

Il est souhaitable que si le bouton est enfoncé, le contenu de la zone de texte soit effacé. Le widget QLineEdit a une méthode clear () à cet effet. Par conséquent, le boutonclicked le signal doit être connecté à clear() méthode de la zone de texte.

Pour commencer, choisissez Modifier les signaux / slots dans le menu Edition (ou appuyez sur F4). Sélectionnez ensuite le bouton avec la souris et faites glisser le curseur vers la zone de texte

Lorsque la souris est relâchée, une boîte de dialogue affichant les signaux du bouton et les méthodes de l'emplacement s'affiche. Sélectionnez le signal cliqué et la méthode clear ()

La fenêtre Signal / Slot Editor en bas à droite affichera le résultat -

Enregistrez le code ui et Build et Python à partir du fichier ui comme indiqué dans le code ci-dessous -

pyuic5 -x signalslot.ui -o signalslot.py

Le code Python généré aura la connexion entre le signal et le slot par l'instruction suivante -

self.pushButton.clicked.connect(self.lineEdit.clear)

Exécutez signauxlot.py et entrez du texte dans LineEdit. Le texte sera effacé si le bouton est enfoncé.

Connexion de signal-slot de bâtiment

Au lieu d'utiliser Designer, vous pouvez établir directement une connexion signal-slot en suivant la syntaxe -

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 techniques suivantes -

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 ().

import sys
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets 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)
   b2.clicked.connect(b2_clicked)
   
   win.setGeometry(100,100,200,100)

   win.setWindowTitle("PyQt5")
   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 positionnement absolu, 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.

La boîte à outils Qt définit diverses mises en page qui peuvent être utilisées avec l'utilitaire Qt Designer.

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

N ° Sr. 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

Il s'agit d'un autre gestionnaire de mise en page avancé qui permet de modifier dynamiquement la taille des widgets enfants en faisant glisser les limites entre eux. Le contrôle Splitter fournit une poignée qui peut être déplacée pour redimensionner les contrôles.

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, WindowModalityL'attribut de la fenêtre de dialogue décide s'il est modal ou non. N'importe quel bouton de la boîte de dialogue peut être défini par défaut. La boîte de dialogue est supprimée parQDialog.reject() méthode 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 PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *

def window():
   app = QApplication(sys.argv)
   w = QWidget()
   btn = QPushButton(w)
   btn.setText("Hello World!")
   btn.move(100,50)
   btn.clicked.connect(showdialog)
   w.setWindowTitle("PyQt Dialog demo")
   w.show()
   sys.exit(app.exec_())

def showdialog():
   dlg = QDialog()
   b1 = QPushButton("ok",dlg)
   b1.move(50,50)
   dlg.setWindowTitle("Dialog") 9. PyQt5 — QDialog Class
   dlg.setWindowModality(Qt.ApplicationModal)
   dlg.exec_()

if __name__ == '__main__':
   window()

Le code ci-dessus produit la sortie suivante. Cliquez sur le bouton dans la fenêtre principale et la boîte de dialogue apparaît -

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 -

N ° Sr. Méthodes et description
1

setIcon()

Affiche l'icône prédéfinie correspondant à la gravité du message

  • Question
  • Information
  • Warning
  • Critical
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 PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *

def window():
   app = QApplication(sys.argv)
   w = QWidget()
   b = QPushButton(w)
   b.setText("Show message!")
   
   b.move(100,50)
   b.clicked.connect(showdialog)
   w.setWindowTitle("PyQt MessageBox 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_()

def msgbtn(i):
   print ("Button pressed is:",i.text())

if __name__ == '__main__':
   window()

Le code ci-dessus produit la sortie suivante. La boîte de message apparaît lorsque le bouton de la fenêtre principale est cliqué -

Si vous cliquez sur le bouton Ok ou Annuler sur MessageBox, la sortie suivante est produite sur la console -

Button pressed is: OK
Button pressed is: Cancel

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. C'est ce qu'on appelle SDI(single Document Interface). 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.

MDI (Multiple Document Interface)les applications 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 deQMdiSubWindowclasse. 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 -

N ° Sr. 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 PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets 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()

Exécutez au-dessus du code et trois fenêtres dans une formation en cascade et en mosaïque -

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 QDrag classe. 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, le DragEnterEventvé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 PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets 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 and 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 -

La bibliothèque PyQt5 contient QtSqlmodule. Il s'agit d'un système de classes élaboré pour communiquer avec de nombreuses bases de données SQL. SesQSqlDatabasefournit un accès via un objet Connection. Voici la liste des pilotes SQL actuellement disponibles -

N ° Sr. 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

Pour ce chapitre, 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 -

N ° Sr. 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

QSqlQueryclass 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 première étape consiste à créer la base de données SQlite en utilisant les instructions suivantes -

db = QSqlDatabase.addDatabase('QSQLITE')
db.setDatabaseName('sportsdatabase.db')

Ensuite, obtenez l'objet Query avec QSqlQuery() et appelez sa méthode la plus importante 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.

import sys
from PyQt5.QtSql import *
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *

def createDB():
   db = QSqlDatabase.addDatabase('QSQLITE')
   db.setDatabaseName('sportsdatabase.db')

   if not db.open():
      msg = QMessageBox()
      msg.setIcon(QMessageBox.Critical)
      msg.setText("Error in Database Creation")
      retval = msg.exec_()
      return False
   query = 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__':
   app = QApplication(sys.argv)
   createDB()

Pour confirmer que la base de données SQLite est créée avec les enregistrements ci-dessus ajoutés dans la table des sportifs, utilisez un utilitaire SQLite Gui appelé SQLiteStudio.

QSqlTableModelLa classe 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 unQTableViewobjet. 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 QSqlTableModel 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 PyQt5.QtSql import *
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *

def initializeModel(model):
   model.setTable('sportsmen')
   model.setEditStrategy(QSqlTableModel.OnFieldChange)
   model.select()
   model.setHeaderData(0, Qt.Horizontal, "ID")
   model.setHeaderData(1, Qt.Horizontal, "First name")
   model.setHeaderData(2, Qt.Horizontal, "Last name")

def createView(title, model):
   view = 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 = QApplication(sys.argv)
   db = QSqlDatabase.addDatabase('QSQLITE')
   db.setDatabaseName('sportsdatabase.db')
   model = QSqlTableModel()
   delrow = -1
   initializeModel(model)

   view1 = createView("Table Model (View 1)", model)
   view1.clicked.connect(findrow)

   dlg = QDialog()
   layout = QVBoxLayout()
   layout.addWidget(view1)

   button = QPushButton("Add a row")
   button.clicked.connect(addrow)
   layout.addWidget(button)

   btn1 = 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 -

Essayez d'ajouter et de supprimer quelques enregistrements et revenez à SQLiteStudio pour confirmer les transactions.

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.

QPainterLa classe exécute 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 le begin() méthode, tandis que le end()la méthode le désactive. Entre les deux, le motif souhaité est peint par des méthodes appropriées, comme indiqué dans le tableau suivant.

N ° Sr. 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

Exemple

Dans le code suivant, diverses méthodes des méthodes de dessin de PyQt sont utilisées.

import sys
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets 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 Python")
      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("pythonlogo.png"))
      qp.fillRect(20,175,130,70,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 -

Dans ce chapitre, nous allons apprendre les constantes de style de pinceau.

Constantes de style de pinceau

Vous trouverez ci-dessous les constantes de style de pinceau -

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

Styles QColor prédéfinis

Vous trouverez ci-dessous les 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

Vous trouverez ci-dessous les 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

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 àQDrag class et utilise des types de données similaires.

La classe QApplication a une méthode statique clipboard()qui renvoie la référence à l'objet du presse-papiers. 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 -

N ° Sr. 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 -

N ° Sr. 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.

import sys
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *

class Example(QWidget):
   def __init__(self):
      super(Example, self).__init__()

      self.initUI()

   def initUI(self):
      hbox = QVBoxLayout()
      self.edit1=QTextEdit()
      hbox.addWidget(self.edit1)
      self.btn1=QPushButton("Copy")
      hbox.addWidget(self.btn1)
      self.edit2=QTextEdit()
      self.btn2=QPushButton("Paste")
      hbox.addWidget(self.edit2)
      hbox.addWidget(self.btn2)
      self.btn1.clicked.connect(self.copytext)
      self.btn2.clicked.connect(self.pastetext)
      self.setLayout(hbox)
      
      self.setGeometry(300, 300, 300, 200)
      self.setWindowTitle('Clipboard')
      self.show()
      
   def copytext(self):

      #clipboard.setText(self.edit1.copy())
      self.edit1.copy()
      print (clipboard.text())

      msg=QMessageBox()
      msg.setText(clipboard.text()+" copied on clipboard")
      msg.exec_()

   def pastetext(self):
      self.edit2.setText(clipboard.text())

app = QApplication(sys.argv)
clipboard=app.clipboard()
ex = Example()
ex.setWindowTitle("clipboard Example")
sys.exit(app.exec_())

Le code ci-dessus produit la sortie suivante -

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é 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 -

N ° Sr. 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 du setPixmap() méthode.

Le code complet est le suivant -

import sys
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *

def window():
   app = QApplication(sys.argv)
   win = QWidget()
   l1 = QLabel()
   l1.setPixmap(QPixmap("python.png"))

   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 -