1. Description de la classe QMainWindow
- QMainWindow est une classe fondamentale de PyQt5: une bibliothèque de liaisons Python pour le populaire framework d'application multiplateforme Qt. Comme son nom l'indique, QMainWindow représente la fenêtre principale d'une application PyQt5, servant de conteneur central pour les autres éléments de l'interface utilisateur graphique (GUI) et constituant la base de développement d'applications graphiques sophistiquées et à plusieurs fenêtres.
- Au cœur de QMainWindow: on retrouve la gestion des composants principaux de l'interface utilisateur de l'application, tels que les menus, les barres d'outils, les barres d'état et les widgets pouvant être ancrés (dockables). Ces composants sont essentiels pour créer une interface utilisateur complète et conviviale, permettant aux utilisateurs d'interagir facilement avec les différentes fonctionnalités.
2. Les fonctionnalités clés de QMainWindow
Les fonctionnalités clés de QMainWindow dans PyQt5 comprennent :
- Gestion des composants de l'interface utilisateur : QMainWindow agit comme le conteneur principal pour les autres éléments de l'interface utilisateur, tels que les menus, les barres d'outils, les barres d'état et les widgets. Cela permet aux développeurs de créer une interface utilisateur complète et structurée pour leur application.
- Widget central : QMainWindow dispose d'un widget central où les principales fonctionnalités de l'application peuvent être affichées. Ce widget peut être personnalisé en ajoutant des widgets, des dispositions (layouts) ou d'autres sous-fenêtres (dialogs) pour créer une expérience utilisateur riche et interactive.
- Système d'ancrage (docking system) : L'une des fonctionnalités les plus puissantes de QMainWindow est son système d'ancrage, qui permet aux widgets comme les barres d'outils et les panneaux d'être ancrés (dockés) à différents bords de la fenêtre principale ou de flotter en tant que fenêtres indépendantes. Cette flexibilité offre aux utilisateurs la possibilité de personnaliser l'agencement de l'interface selon leurs préférences.
- Gestion des menus : QMainWindow fournit un support complet pour la création et la gestion des menus. Les développeurs peuvent créer des menus standard, des menus contextuels et des menus personnalisés pour organiser et présenter les différentes fonctionnalités de l'application de manière claire et structurée.
- Barre d'état (status bar) : QMainWindow intègre une barre d'état qui permet d'afficher des informations utiles, des messages ou des retours à l'utilisateur. Cela peut inclure des mises à jour d'état, des indicateurs de progression ou des infobulles pour fournir des informations sur l'état actuel de l'application et ses opérations en cours.
- Gestion de l'état de l'application : La classe QMainWindow facilite la gestion de l'état et des paramètres de l'application. Les développeurs peuvent sauvegarder et restaurer l'état de la fenêtre, sa géométrie et les préférences de l'utilisateur, assurant ainsi une expérience utilisateur cohérente lors des différentes sessions d'utilisation de l'application.
- Gestion des événements : QMainWindow prend en charge la gestion des événements, tels que les clics de souris, les touches du clavier, etc. Cela permet aux développeurs de définir des actions en réponse à ces événements pour rendre l'application interactive et réactive aux actions de l'utilisateur.
- Support du style et de la personnalisation : QMainWindow offre des options pour personnaliser l'apparence de l'interface utilisateur grâce à la gestion des feuilles de style et des thèmes, permettant aux développeurs de créer des interfaces esthétiquement attrayantes et cohérentes avec le reste de l'application.
- Conclusion: QMainWindow de PyQt5 est une classe polyvalente qui fournit un ensemble complet de fonctionnalités pour créer des applications graphiques sophistiquées et conviviales. Son rôle en tant que conteneur principal pour les composants de l'interface utilisateur, son système d'ancrage puissant, sa gestion des menus, sa barre d'état intégrée et sa facilité de gestion de l'état de l'application en font un outil essentiel pour les développeurs qui souhaitent construire des interfaces utilisateur interactives et flexibles.
3. Les composants de QMainWindow
Les composants de QMainWindow dans PyQt5 sont les éléments qui forment l'interface utilisateur graphique (GUI) principale d'une application. Ces composants sont hébergés et gérés par la fenêtre principale (QMainWindow) et jouent un rôle essentiel dans la création d'une interface utilisateur riche et fonctionnelle. Voici les composants clés de QMainWindow :
- Central Widget : Le widget central occupe l'espace principal de la fenêtre QMainWindow. C'est ici que le contenu principal de l'application est affiché, comme des formulaires, des graphiques, des listes, etc. Les développeurs peuvent personnaliser le widget central en y ajoutant des widgets et des dispositions (layouts) adaptés à leurs besoins.
- Menu Bar : QMainWindow prend en charge la gestion des menus, qui fournissent un moyen structuré de présenter les différentes fonctionnalités de l'application à l'utilisateur. Les menus peuvent contenir des actions, des sous-menus, des raccourcis clavier, et permettent aux utilisateurs d'accéder rapidement aux fonctionnalités de l'application.
- Toolbars (Barres d'outils) : Les barres d'outils sont des groupes de boutons et d'actions généralement disposés en haut de la fenêtre principale. Ils fournissent un accès rapide à certaines fonctionnalités fréquemment utilisées de l'application. Les développeurs peuvent personnaliser les barres d'outils en y ajoutant des icônes, des boutons et des actions selon les besoins.
- Status Bar (Barre d'état) : La barre d'état située en bas de la fenêtre QMainWindow est un espace réservé pour afficher des informations ou des messages à l'utilisateur. Elle est utilisée pour afficher des messages de statut, des informations contextuelles, des conseils ou des indicateurs de progression.
- Dock Widgets (Widgets ancrables) : QMainWindow prend en charge le système d'ancrage (docking system) qui permet à certains widgets d'être ancrés à différents côtés de la fenêtre principale ou de flotter comme des fenêtres indépendantes. Cela offre aux utilisateurs la flexibilité de personnaliser l'agencement de l'interface selon leurs préférences.
4. Syntaxe et usage de QMainWindow
4.1 Syntaxe
Afin de pouvoir utiliser et créer des applications graphiques basées sur la classe QMainWindow, il faut préalablement l'importer et y instancier:
|
1 2 3 |
from PyQt5.QtWidgets import QApplication, QMainWindow # Créer la fenêtre QMainWindow main_window = QMainWindow() |
4.2 Exemple simple d'usage de QMainWindow
Exemple (sans utiliser la POO)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
import sys from PyQt5.QtWidgets import QApplication, QMainWindow, QPushButton, QLabel, QVBoxLayout, QWidget def button_clicked(): label.setText("Le bouton a été cliqué !") if __name__ == "__main__": app = QApplication(sys.argv) # Créer la QMainWindow main_window = QMainWindow() main_window.setWindowTitle("Exemple de fenêtre QMainWindow !") # Créer le widget central central_widget = QWidget() main_window.setCentralWidget(central_widget) main_window.setGeometry(100, 100, 350, 200) # Créer les widgets label = QLabel("Appuyez sur le bouton pour changer le texte.") button = QPushButton("Cliquez ici") # Créer la mise en page verticale layout = QVBoxLayout() layout.addWidget(label) layout.addWidget(button) central_widget.setLayout(layout) # Définir la fonction de rappel pour le clic du bouton button.clicked.connect(button_clicked) # Afficher la fenêtre main_window.show() sys.exit(app.exec_()) |
4.3 Exemple de QMainWindo en adoptant l'approche objet
Exemple ( QMainWindow selon l'approche objet)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
import sys from PyQt5.QtWidgets import QApplication, QMainWindow, QPushButton, QLabel, QVBoxLayout, QWidget class MyWindow(QMainWindow): def __init__(self): super().__init__() self.setWindowTitle("Example of QMainWindow PyQt5") self.setGeometry(100, 100, 375, 175) self.init_ui() def init_ui(self): # Créer le widget central central_widget = QWidget() self.setCentralWidget(central_widget) # Créer les widgets self.label = QLabel("Click button to change text!") button = QPushButton("Click Here !") # Créer la mise en page verticale layout = QVBoxLayout() layout.addWidget(self.label) layout.addWidget(button) central_widget.setLayout(layout) # Définir la fonction de rappel pour le clic du bouton button.clicked.connect(self.button_clicked) def button_clicked(self): self.label.setText("The button has been clicked!") if __name__ == "__main__": app = QApplication(sys.argv) # Créer l'instance de la classe MyWindow window = MyWindow() # Afficher la fenêtre window.show() sys.exit(app.exec_()) |
4.4 Exemple de QMainWindow avec la barre de menu
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 |
import sys from PyQt5.QtWidgets import QApplication, QMainWindow, QAction, QLabel, QWidget class MainWindow(QMainWindow): def __init__(self): super().__init__() self.setWindowTitle("Exemple avec Menu Bar") self.init_ui() def init_ui(self): # Créer un widget central central_widget = QWidget() self.setCentralWidget(central_widget) self.setGeometry(100, 100, 400, 200) # Créer une action de menu "Nouveau" action_new = QAction("Nouveau", self) action_new.triggered.connect(self.on_new_triggered) # Créer une action de menu "Ouvrir" action_open = QAction("Ouvrir", self) action_open.triggered.connect(self.on_open_triggered) # Créer une action de menu "Enregistrer" action_save = QAction("Enregistrer", self) action_save.triggered.connect(self.on_save_triggered) # Créer une action de menu "Quitter" action_quit = QAction("Quitter", self) action_quit.triggered.connect(self.close) # Créer une barre de menu menu_bar = self.menuBar() # Ajouter le menu "Fichier" à la barre de menu file_menu = menu_bar.addMenu("Fichier") # Ajouter les actions au menu "Fichier" file_menu.addAction(action_new) file_menu.addAction(action_open) file_menu.addAction(action_save) file_menu.addSeparator() file_menu.addAction(action_quit) def on_new_triggered(self): print("Action Nouveau déclenchée.") def on_open_triggered(self): print("Action Ouvrir déclenchée.") def on_save_triggered(self): print("Action Enregistrer déclenchée.") if __name__ == "__main__": app = QApplication(sys.argv) window = MainWindow() window.show() sys.exit(app.exec_()) |
Dans cet exemple:
- Nous créons une QMainWindow: personnalisée appelée MainWindow.
- Nous ajoutons ensuite un widget central: une fenêtre QWidget() pour afficher le contenu principal de l'application.
- Nous créons quatre actions de menu : "Nouveau", "Ouvrir", "Enregistrer" et "Quitter". Chaque action est associée à une fonction de rappel qui sera exécutée lorsque l'action du menu sera déclenchée.
- Nous créons ensuite une barre de menu: en utilisant la méthode menuBar() de la QMainWindow.
- Nous ajoutons un menu "Fichier": à la barre de menu, puis nous y ajoutons les actions "Nouveau", "Ouvrir", "Enregistrer" et "Quitter".
Lorsque vous exécutez l'application, vous verrez une barre de menu en haut de la fenêtre contenant le menu "Fichier" avec les actions associées. Lorsque vous cliquez sur chaque action, la fonction de rappel correspondante sera appelée, et un message sera affiché dans la console pour indiquer que l'action a été déclenchée.
5. Méthodes et attributs associés à un objet QMainWindow
Voici une liste des méthodes et des attributs les plus couramment utilisés associés à un objet QMainWindow en PyQt5 :
5.1 Méthodes
- __init__(self, parent=None): Le constructeur de la classe QMainWindow.
- setCentralWidget(self, widget): Définit le widget central de la fenêtre principale.
- centralWidget(self): Renvoie le widget central actuellement défini.
- menuBar(self): Renvoie la barre de menu (QMenuBar) de la fenêtre principale.
- statusBar(self): Renvoie la barre d'état (QStatusBar) de la fenêtre principale.
- addToolBar(self, toolbar): Ajoute une barre d'outils (QToolBar) à la fenêtre principale.
- addDockWidget(self, area, dockwidget): Ajoute un widget ancrable (QDockWidget) à la fenêtre principale dans la zone spécifiée.
- setMenuBar(self, menubar): Définit la barre de menu de la fenêtre principale.
- setStatusBar(self, statusbar): Définit la barre d'état de la fenêtre principale.
- setWindowTitle(self, title): Définit le titre de la fenêtre principale.
- show(): Affiche la fenêtre principale à l'écran.
- close(): Ferme la fenêtre principale.
- resize(self, width, height): Redimensionne la fenêtre principale à la taille spécifiée.
5.2 Les attributs
- windowTitle: Contient le titre de la fenêtre principale.
- geometry: Contient la géométrie de la fenêtre principale (position et taille).
- centralWidget: Référence vers le widget central de la fenêtre principale.
- menuBar: Référence vers la barre de menu de la fenêtre principale (QMenuBar).
- statusBar: Référence vers la barre d'état de la fenêtre principale (QStatusBar).
- toolBars(): Renvoie une liste des barres d'outils (QToolBar) ajoutées à la fenêtre principale.
- dockWidgets(): Renvoie une liste des widgets ancrables (QDockWidget) ajoutés à la fenêtre principale.
- menuWidget(): Référence vers le widget menu de la fenêtre principale.
Younes Derfoufi
CRMEF OUJDA
Acheter sur Très Facile !
-
Effacez et formatez vos disques durs pour les systèmes d'exploitation Windows
€ 13,00 Acheter le produit -
Apprentissage de la machine: La révolution des neurones artificiels et de l'apprentissage profond
€ 23,00 Acheter le livre -
Python pour la Physique: Calcul, Graphisme, Simulation - Richard Taillet
€ 23,00 Acheter le livre