1. Description de la classe QMainWindow
- La classe QMainWindow dans PyQt5: est une adaptation de la classe correspondante dans le framework Qt pour le développement d'interfaces graphiques en Python. Elle offre une structure pour créer des fenêtres principales dans des applications PyQt5. Elle fournit une structure prête à l'emploi pour créer des interfaces utilisateur complètes. QMainWindow fournit une infrastructure complète pour le développement d'applications graphiques avec une interface utilisateur riche et flexible. Elle est particulièrement adaptée aux applications de bureau nécessitant une fenêtre principale avec une barre de menu, des barres d'outils et d'autres composants d'interface utilisateur standard.
- Au cœur de QMainWindow: se trouve la gestion des éléments clés de l'interface utilisateur de l'application, notamment les menus, les barres d'outils, la barres d'état et les widgets pouvant être ancrés (dockables). Ces éléments jouent un rôle crucial dans la création d'une interface utilisateur complète et conviviale, facilitant ainsi l'interaction des utilisateurs avec les diverses fonctionnalités de l'application.
2. principales fonctionnalités de la classe QMainWindow
Voici une description des principales fonctionnalités de la classe QMainWindow dans le contexte de PyQt5:
- Barre de menu (QMenuBar) : QMainWindow offre une barre de menu que vous pouvez personnaliser pour inclure des actions, des menus déroulants et d'autres éléments de menu.
- Barres d'outils (QToolBar) : Vous pouvez ajouter des barres d'outils contenant des boutons d'actions pour fournir un accès rapide aux fonctionnalités les plus fréquemment utilisées.
- Zone centrale (QWidget) : La zone centrale de la fenêtre est généralement réservée au contenu principal de l'application. Vous pouvez y placer des widgets personnalisés ou d'autres conteneurs pour organiser l'interface utilisateur.
- Barre d'état (QStatusBar) : QMainWindow inclut une barre d'état en bas de la fenêtre, généralement utilisée pour afficher des informations sur l'état de l'application ou pour fournir des conseils contextuels.
- Gestionnaire de dock (QDockWidget) : La classe QDockWidget peut être utilisée pour créer des fenêtres flottantes ou des volets ancrables à l'intérieur de la fenêtre principale. Ces volets peuvent contenir des widgets supplémentaires.
- Gestionnaire de disposition (QLayout) : QMainWindow utilise un gestionnaire de disposition pour organiser les différents composants de manière appropriée. Vous pouvez personnaliser la disposition selon les besoins de votre application.
- Gestion des actions (QAction) : QMainWindow permet la gestion des actions, qui représentent des actions pouvant être déclenchées par l'utilisateur à partir du menu, des barres d'outils ou d'autres emplacements.
- Événements (QEvent) : Vous pouvez réagir aux événements générés par l'utilisateur ou le système en surchargeant les méthodes appropriées de la classe QMainWindow.
3. Les principaux composants d'une fenêtre QMainWindow
La classe QMainWindow dans PyQt5 offre des fonctionnalités similaires à celles de Qt pour la création d'interfaces graphiques en Python. Elle facilite le développement d'applications avec une structure standard pour les éléments tels que la barre de menu, les barres d'outils, la zone centrale, la barre d'état, etc.
Barre de menu (QMenuBar) : Vous pouvez utiliser la méthode menuBar() pour accéder à la barre de menu de la fenêtre principale. Vous pouvez ensuite ajouter des actions, des menus et des actions aux menus de la barre de menu.
|
1 2 3 4 |
menu_bar = self.menuBar() file_menu = menu_bar.addMenu('File') open_action = QAction('Open', self) file_menu.addAction(open_action) |
Barres d'outils (QToolBar) : Vous pouvez créer des barres d'outils à l'aide de la méthode addToolBar(). Les barres d'outils peuvent contenir des actions pour fournir un accès rapide à certaines fonctionnalités.
|
1 2 |
tool_bar = self.addToolBar('MyToolbar') tool_bar.addAction(open_action) |
Zone centrale (QWidget) : La zone centrale de la fenêtre peut être définie en utilisant la méthode setCentralWidget(). Vous pouvez y placer des widgets personnalisés ou d'autres conteneurs.
|
1 2 |
central_widget = QWidget() self.setCentralWidget(central_widget) |
Barre d'état (QStatusBar) : Vous pouvez accéder à la barre d'état à l'aide de la méthode statusBar(). La barre d'état est généralement utilisée pour afficher des messages informatifs.
status_bar = self.statusBar()
status_bar.showMessage('Ready')
Gestionnaire de dock (QDockWidget) : Vous pouvez utiliser la classe QDockWidget pour créer des fenêtres flottantes ou des volets ancrables. Ces volets peuvent contenir des widgets supplémentaires.
|
1 2 3 |
dock_widget = QDockWidget('My Dock', self) dock_widget.setWidget(some_widget) self.addDockWidget(Qt.RightDockWidgetArea, dock_widget) |
Gestion des actions (QAction) : Vous pouvez réagir aux actions de menu, de barre d'outils ou d'autres sources en connectant des fonctions à ces actions.
|
1 |
open_action.triggered.connect(self.open_file) |
4. Usage et syntaxe de QMainWindow
4.1 Usage
Pour exploiter les fonctionnalités de la classe QMainWindow et concevoir des applications graphiques, il est nécessaire de commencer par l'importer et créer une instance de celle-ci :
|
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 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
|
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 une barre de menu
Nous allons voir un exemple de QMainWindow avec les caractéristique suivantes:
- 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".
Exemple 1
|
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 |
from PyQt5.QtWidgets import QWidget, QApplication, QMainWindow, QAction import sys class MyApp(QMainWindow): def __init__(self): super().__init__() self.initUI() def initUI(self): self.setWindowTitle("Example of PyQt5 App") self.setGeometry(100, 100, 400, 300) # Creating a menu bar menu_bar = self.menuBar() # Adding menus file_menu = menu_bar.addMenu("File") new = QAction("New", self) # Associer une action au menu 'New' new.triggered.connect(self.action_new) file_menu.addAction(new) # method that performs the action of the 'New' menu def action_new(self): print("The new menu action has ben trigged") if __name__ == '__main__': app = QApplication([]) myapp = MyApp() myapp.show() sys.exit(app.exec_()) |
Exemple2
|
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_()) |
Lors de l'exécution de l'application, une barre de menu apparaîtra en haut de la fenêtre, comprenant le menu "Fichier" avec ses actions associées. Chaque fois que vous cliquez sur une action, la fonction de rappel correspondante sera déclenchée, et un message s'affichera dans la console pour signaler que l'action a été exécutée:
5. Méthodes et attributs associées à un objet QMainWindow
Voici une synthèse des méthodes et des attributs fréquemment utilisés en relation avec un objet QMainWindow dans PyQt5 :
5.1 Méthodes
- __init__(self, parent=None): Le constructeur de la classe QMainWindow.
- setCentralWidget(self, widget): Affecte le widget central de la fenêtre principale.
- centralWidget(self): Retourne le widget central actuellement défini.
- menuBar(self): Donne accès à 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): Intègre une barre d'outils (QToolBar) à la fenêtre principale.
- addDockWidget(self, area, dockwidget): Intègre un widget ancrable (QDockWidget) à la fenêtre principale dans la zone spécifiée.
- setMenuBar(self, menubar): Configure la barre de menu de la fenêtre principale.
- setStatusBar(self, statusbar): Configure 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): Modifie les dimensions de la fenêtre principale.
5.2 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
