Python pas cher
Lorsqu'il s'agit de développer des applications d'interface utilisateur graphique (GUI) avec Python et PyQt, certains des éléments graphiques les plus utiles et polyvalents que vous utiliserez jamais sont les menus, les barres d'outils et les barres d'état.
Les menus et les barres d'outils peuvent donner une apparence à vos applications brillant et professionnel, offrant aux utilisateurs un ensemble d'options accessible, tandis que les barres d'état vous permettent d'afficher des informations pertinentes sur l'état de l'application.
Dans ce didacticiel, vous apprendrez:
- Quoi les menus, barres d'outils, et barres d'état sont
- Comment créer des menus, des barres d'outils et des barres d'état par programmation
- Comment remplir le menu et la barre d'outils Python en utilisant Actions PyQt
- Comment utiliser les barres d'état pour afficher informations d'état
De plus, vous en apprendrez meilleures pratiques de programmation que vous pouvez appliquer lors de la création de menus, de barres d'outils et de barres d'état avec Python et PyQt. Si vous débutez dans la programmation GUI avec PyQt, vous pouvez consulter Python et PyQt: Créer une calculatrice de bureau GUI.
Vous pouvez télécharger le code et les ressources de l'exemple d'application que vous allez créer dans ce didacticiel en cliquant sur la case ci-dessous:
Utilisation des icônes et des ressources dans PyQt
La bibliothèque Qt inclut le système de ressources Qt, qui est un moyen pratique d'ajouter des fichiers binaires tels que des icônes, des images, des fichiers de traduction et d'autres ressources à vos applications.
Pour utiliser le système de ressources, vous devez répertorier vos ressources dans un fichier de collecte de ressources, ou un .qrc
fichier. UNE .qrc
le fichier est un XML
fichier qui contient l'emplacement, ou chemin, de chaque ressource de votre système de fichiers.
Supposons que votre exemple d'application a un Ressources
répertoire contenant les icônes que vous souhaitez utiliser dans l'interface graphique de l'application. Vous avez des icônes pour des options comme Nouveau, Ouvert, etc. Vous pouvez créer un .qrc
fichier contenant le chemin de chaque icône:
<RCC version ="1.0">
<fichier alias ="fichier-nouveau.svg">resources / file-new.svg
<fichier alias ="file-open.svg">resources / file-open.svg
<fichier alias ="fichier-save.svg">resources / file-save.svg
<fichier alias ="file-exit.svg">resources / file-exit.svg
<fichier alias ="edit-copy.svg">resources / edit-copy.svg
<fichier alias ="edit-cut.svg">resources / edit-cut.svg
<fichier alias ="edit-paste.svg">resources / edit-paste.svg
<fichier alias ="help-content.svg">resources / help-content.svg
Chaque
L'entrée doit contenir le chemin d'accès à une ressource dans votre système de fichiers. Les chemins spécifiés sont relatifs au répertoire contenant le .qrc
fichier. Dans l'exemple ci-dessus, le Ressources
le répertoire doit être dans le même répertoire que le .qrc
fichier.
alias
est un attribut facultatif qui définit un nom alternatif court que vous pouvez utiliser dans votre code pour accéder à chaque ressource.
Une fois que vous avez les ressources pour votre application, vous pouvez exécuter l'outil de ligne de commande pyrcc5
ciblant votre .qrc
fichier. pyrcc5
est livré avec PyQt et doit être entièrement fonctionnel sur votre environnement Python une fois que PyQt est installé.
pyrcc5
lit un .qrc
file et produit un module Python qui contient le code binaire pour toutes vos ressources:
$ pyrcc5 -o qrc_resources.py resources.qrc
Cette commande lira resources.qrc
et générer qrc_resources.py
contenant le code binaire de chaque ressource. Vous pourrez utiliser ces ressources dans votre code Python en important qrc_resources
.
Remarque: Si quelque chose ne va pas lors de l'exécution pyrcc5
, puis assurez-vous que vous utilisez le bon environnement Python. Si vous installez PyQt dans un environnement virtuel Python, vous ne pourrez pas utiliser pyrcc5
de l'extérieur de cet environnement.
Voici un fragment du code dans qrc_resources.py
qui correspond à votre resources.qrc
:
# - * - codage: utf-8 - * -
# Code d'objet de ressource
#
# Créé par: Le compilateur de ressources pour PyQt5 (Qt v5.9.5)
#
# ATTENTION! Toutes les modifications apportées dans ce fichier seront perdues!
de PyQt5 importer QtCore
qt_resource_data = b"
x00 x00 x03 xb1
x3c
x73 x76 x67 x20 x78 x6d x6c x6e x73 x3d x22 x68 x74 x74 x70 x3a
...
Avec qrc_resources.py
en place, vous pouvez l'importer dans votre application et faire référence à chaque ressource en tapant un deux-points (:) puis soit son alias
ou son chemin. Par exemple, pour accéder file-new.svg
avec son alias, vous utiliseriez le chaîne d'accès ": fichier-nouveau.svg"
. Si vous n’aviez pas de alias
, vous y accéderiez par son chemin avec la chaîne d'accès ": resources / file-new.svg"
.
Si vous avez des alias, mais pour une raison quelconque, vous souhaitez accéder à une ressource donnée par son chemin à la place, vous devrez peut-être supprimer les deux points de la chaîne d'accès pour que cela fonctionne correctement.
Pour utiliser les icônes dans vos actions, vous devez d'abord importer votre module de ressources:
Une fois que vous avez importé le module qui contient vos ressources, vous pouvez utiliser les ressources de l'interface graphique de votre application.
Remarque: Les linters, les éditeurs et les IDE peuvent signaler la déclaration d'importation ci-dessus comme inutilisée, car votre code n'en inclura aucune utilisation explicite. Certains IDE peuvent aller encore plus loin et supprimer cette ligne automatiquement.
Dans ces situations, vous devez remplacer les suggestions de votre linter, éditeur ou IDE et conserver cette importation dans votre code. Sinon, votre application ne pourra pas afficher vos ressources.
Pour créer une icône à l'aide du système de ressources, vous devez instancier QIcon
, en passant l'alias ou le chemin au constructeur de classe:
newIcon = QIcon(": fichier-nouveau.svg")
Dans cet exemple, vous créez un QIcon
objet avec le fichier file-new.svg
, qui se trouve dans votre module de ressources. Cela fournit un moyen pratique d'utiliser les icônes et les ressources dans toute votre application GUI.
Revenez maintenant à votre exemple d'application et mettez à jour la dernière ligne de ._createMenuBar ()
:
de PyQt5.QtGui importer QIcon
importer qrc_resources
# Snip ...
classe La fenêtre(QMainWindow):
# Snip ...
def _createMenuBar(soi):
barre de menu = soi.barre de menu()
# Utilisation d'un objet QMenu
Menu Fichier = QMenu("&Fichier", soi)
barre de menu.addMenu(Menu Fichier)
# Utiliser un titre
modifierMenu = barre de menu.addMenu("&Éditer")
# Utilisation d'une icône et d'un titre
helpMenu = barre de menu.addMenu(QIcon(": help-content.svg"), "&Aidez-moi")
Pour que ce code fonctionne, vous devez d'abord importer QIcon
de PyQt5.QtGui
. Vous devez également importer qrc_resources
. Dans la dernière ligne en surbrillance, vous ajoutez une icône à helpMenu
en utilisant help-content.svg
à partir de votre module de ressources.
Si vous exécutez votre exemple d'application avec cette mise à jour, vous obtiendrez le résultat suivant:
La fenêtre principale de l'application affiche désormais une icône sur son Aidez-moi menu. Lorsque vous cliquez sur l'icône, le menu affiche le texte Aidez-moi
. L'utilisation d'icônes dans une barre de menus n'est pas une pratique courante, mais PyQt vous permet de le faire quand même.
Ajout d'options à une barre d'outils dans PyQt
Les barres d'outils sont un composant très utile lorsqu'il s'agit de créer des applications GUI avec Python et PyQt. Vous pouvez utiliser une barre d'outils pour présenter à vos utilisateurs un moyen rapide d'accéder aux options les plus couramment utilisées dans votre application. Vous pouvez également ajouter des widgets tels que des zones de sélection numérique et des zones de liste déroulante à une barre d'outils pour permettre à l'utilisateur de modifier directement certaines propriétés et variables à partir de l'interface graphique de l'application.
Dans les quelques sections suivantes, vous apprendrez à ajouter des options ou des boutons à vos barres d'outils à l'aide d'actions et également à ajouter des widgets à une barre d'outils avec .addWidget ()
.
Remplir les barres d'outils avec des actions
Pour ajouter des options ou des boutons à une barre d'outils, vous devez appeler .addAction ()
. Dans cette section, vous utiliserez la variante de .addAction ()
cette QToolBar
hérite de QWidget
. Alors tu appelleras .addAction ()
avec une action comme argument. Cela vous permettra de partager vos actions entre les menus et les barres d'outils.
Lorsque vous créez des barres d’outils, vous êtes souvent confronté au problème de décider des options à y ajouter. En règle générale, vous souhaiterez n'ajouter que les actions les plus fréquemment utilisées à vos barres d'outils.
Si vous revenez à votre exemple d'application, vous vous souviendrez que vous avez ajouté trois barres d'outils:
- Fichier
- Éditer
- Aidez-moi
dans le Fichier barre d'outils, vous pouvez ajouter des options comme les suivantes:
dans le Éditer barre d'outils, vous pouvez ajouter les options suivantes:
Normalement, lorsque vous souhaitez ajouter des boutons à une barre d'outils, vous sélectionnez d'abord les icônes que vous souhaitez utiliser sur chaque bouton. Ce n’est pas obligatoire, mais c’est une bonne pratique. Une fois que vous avez sélectionné les icônes, vous devez les ajouter à leurs actions correspondantes.
Voici comment ajouter des icônes aux actions de votre exemple d'application:
classe La fenêtre(QMainWindow):
# Snip ...
def _createActions(soi):
# Actions sur les fichiers
soi.newAction = QAction(soi)
soi.newAction.Définir le texte("&Nouveau")
soi.newAction.setIcon(QIcon(": fichier-nouveau.svg"))
soi.openAction = QAction(QIcon(": fichier-open.svg"), "&Ouvert...", soi)
soi.saveAction = QAction(QIcon(": fichier-save.svg"), "&Sauvegarder", soi)
soi.exitAction = QAction("&Sortie", soi)
# Modifier les actions
soi.copyAction = QAction(QIcon(": edit-copy.svg"), "&Copie", soi)
soi.pasteAction = QAction(QIcon(": edit-paste.svg"), "&Pâte", soi)
soi.cutAction = QAction(QIcon(": edit-cut.svg"), "Couper", soi)
# Snip ...
Pour ajouter des icônes à vos actions, vous mettez à jour les lignes en surbrillance. Dans le cas de newAction
, tu utilises .setIcon ()
. Dans le reste des actions, vous utilisez le constructeur avec un icône
, une Titre
, et un parent
objet comme arguments.
Une fois que vos actions sélectionnées ont des icônes, vous pouvez ajouter ces actions à leur barre d'outils correspondante en appelant .addAction ()
sur l'objet barre d'outils:
classe La fenêtre(QMainWindow):
# Snip ...
def _createToolBars(soi):
# Barre d'outils Fichier
fileToolBar = soi.addToolBar("Fichier")
fileToolBar.addAction(soi.newAction)
fileToolBar.addAction(soi.openAction)
fileToolBar.addAction(soi.saveAction)
# Modifier la barre d'outils
editToolBar = QToolBar("Éditer", soi)
soi.addToolBar(editToolBar)
editToolBar.addAction(soi.copyAction)
editToolBar.addAction(soi.pasteAction)
editToolBar.addAction(soi.cutAction)
Avec cette mise à jour de ._createToolBars ()
, vous ajoutez des boutons pour Nouveau, Ouvert, et sauvegarder options à la Fichier barre d'outils. Vous ajoutez également des boutons pour Copie, Pâte, et Couper options à la Éditer barre d'outils.
Remarque: L'ordre dans lequel les boutons sont affichés sur une barre d'outils de gauche à droite correspond à l'ordre dans lequel vous ajoutez les boutons dans votre code.
Si vous exécutez votre exemple d'application maintenant, la fenêtre suivante s'affichera à l'écran:
L'exemple d'application montre maintenant deux barres d'outils avec quelques boutons chacune. Vos utilisateurs peuvent cliquer sur ces boutons pour accéder rapidement aux options les plus couramment utilisées de l'application.
Remarque: Quand tu as écrit pour la première fois ._createToolBars ()
de retour dans la section Création de barres d'outils, vous avez créé un Aidez-moi barre d'outils. Cette barre d'outils était destinée à montrer comment ajouter une barre d'outils en utilisant une variante différente de .addToolBar ()
.
Dans la mise à jour ci-dessus de ._createToolBars ()
, vous vous débarrassez du Aidez-moi barre d'outils juste pour garder l'exemple court et clair.
Notez que, puisque vous partagez les mêmes actions entre vos menus et vos barres d'outils, les options de menu afficheront également les icônes sur leur côté gauche, ce qui est une grande victoire en termes de productivité et d'utilisation des ressources. C'est l'un des avantages de l'utilisation des actions PyQt pour créer des menus et des barres d'outils avec Python.
Ajouter des widgets à une barre d'outils
Dans certaines situations, vous trouverez utile d’ajouter des widgets spécifiques tels que des boîtes de sélection numérique, des listes déroulantes ou autres à une barre d’outils. Un exemple courant de ceci est les zones de liste déroulante que la plupart des traitements de texte utilisent pour permettre à l'utilisateur de changer la police d'un document ou la taille d'un texte sélectionné.
Pour ajouter des widgets à une barre d'outils, vous devez d'abord créer le widget, configurer ses propriétés, puis appeler .addWidget ()
sur l'objet de la barre d'outils en passant le widget comme argument.
Supposons que vous vouliez ajouter un QSpinBox
objecter à la Éditer barre d'outils de votre exemple d'application pour permettre à l'utilisateur de modifier la taille de quelque chose, qui pourrait être la taille de la police. Vous devez mettre à jour ._createToolBars ()
:
de PyQt5.QtWidgets importer QSpinBox
# Snip ...
classe La fenêtre(QMainWindow):
# Snip ...
def _createToolBars(soi):
# Snip ...
# Ajout d'un widget à la barre d'outils d'édition
soi.fontSizeSpinBox = QSpinBox()
soi.fontSizeSpinBox.setFocusPolicy(Qt.NoFocus)
editToolBar.addWidget(soi.fontSizeSpinBox)
Ici, vous importez d'abord la classe de boîte de sélection numérique. Ensuite, vous créez un QSpinBox
objet, définissez son focusPolicy
à Qt.NoFocus
, et enfin l'ajouter à votre Éditer barre d'outils.
Remarque: Dans le code ci-dessus, vous définissez le focusPolicy
propriété de la boîte de sélection numérique Qt.NoFocus
car si ce widget obtient le focus, les raccourcis clavier de l'application ne fonctionneront pas correctement.
Désormais, si vous exécutez l'application, vous obtiendrez le résultat suivant:
Ici le Éditer la barre d'outils affiche un QSpinBox
objet que vos utilisateurs peuvent utiliser pour définir la taille de la police ou toute autre propriété numérique de votre application.
Personnalisation des barres d'outils
Les barres d'outils PyQt sont assez flexibles et personnalisables. Vous pouvez définir un ensemble de propriétés sur un objet de barre d'outils. Certaines des propriétés les plus utiles sont présentées dans le tableau suivant:
Propriété | Fonctionnalité contrôlée | Paramètres par défaut |
---|---|---|
permis |
Les zones de la barre d'outils dans lesquelles vous pouvez placer une barre d'outils donnée | Qt.AllToolBarAreas |
flottable |
Si vous pouvez faire glisser et déposer la barre d'outils en tant que fenêtre indépendante | Vrai |
flottant |
Si la barre d'outils est une fenêtre indépendante | Vrai |
iconSize |
La taille des icônes affichées sur les boutons de la barre d'outils | Déterminé par le style de l'application |
mobile |
Si vous pouvez déplacer la barre d'outils dans la zone de la barre d'outils ou entre les zones de la barre d'outils | Vrai |
orientation |
L'orientation de la barre d'outils | Qt.horizontale |
Toutes ces propriétés ont une méthode setter associée. Par exemple, vous pouvez utiliser .setAllowedAreas ()
mettre en place permis
, .setFloatable ()
mettre en place flottable
, etc.
Supposons maintenant que vous ne souhaitiez pas que vos utilisateurs déplacent le Fichier barre d'outils autour de la fenêtre. Dans ce cas, vous pouvez définir mobile
à Faux
en utilisant .setMovable ()
:
classe La fenêtre(QMainWindow):
# Snip ...
def _createToolBars(soi):
# Barre d'outils Fichier
fileToolBar = soi.addToolBar("Fichier")
fileToolBar.ensembleMobile(Faux)
# Snip ...
La ligne en surbrillance fait la magie ici. Désormais, vos utilisateurs ne peuvent plus déplacer la barre d'outils dans la fenêtre de l'application:
le Fichier La barre d'outils n'affiche plus la double ligne pointillée, de sorte que vos utilisateurs ne pourront plus la déplacer. Notez que le Éditer la barre d'outils est toujours mobile. Vous pouvez modifier d'autres propriétés de vos barres d'outils en utilisant cette même approche et les personnaliser en fonction de vos besoins.
Building Python Status Bars in PyQt
A status bar is a horizontal panel that is usually placed at the bottom of the main window in a GUI application. Its primary purpose is to display information about the current status of the application. The status bar can also be divided into sections to show different information on each section.
According to the Qt documentation, there are three types of status indicators:
-
Temporary indicators take up almost the entire status bar for a short time to display tooltip texts, menu entries, and other time-sensitive information.
-
Normal indicators take up a part of the status bar and display information that users may want to reference periodically, such as word counts in a word processor. These may be briefly hidden by temporary indicators.
-
Permanent indicators are always displayed in the status bar, even when a temporary indicator is activated. They’re used to show important information about the current mode of the application, such as when the Caps Lock key has been pressed.
You can add a status bar to your main window–style application using one of the following options:
-
Call
.statusBar()
on yourQMainWindow
object..statusBar()
creates and returns an empty status bar for the main window. -
Create a
QStatusBar
object, then call.setStatusBar()
on your main window with the status bar object as an argument. That way,.setStatusBar()
will set your status bar object as the main window’s status bar.
Here you have two alternative implementations for adding a status bar to your sample application:
# 1. Using .statusBar()
def _createStatusBar(soi):
soi.statusbar = soi.statusBar()
# 2. Using .setStatusBar()
def _createStatusBar(soi):
soi.statusbar = QStatusBar()
soi.setStatusBar(soi.statusbar)
Both implementations produce the same result. However, most of the time you’ll use the first implementation for creating your status bars. Note that for the second implementation to work, you need to import QStatusBar
de PyQt5.QtWidgets
.
Add one of the above implementations to your application’s La fenêtre
and then call ._createStatusBar()
in the class initializer. With these additions, when you run your application again, you’ll see a window like this:
Your application now has a status bar at the bottom of its main window. The status bar is almost invisible, but if you look closely, then you’ll notice a small dotted triangle on the bottom-right corner of the window.
Showing Temporary Status Messages
The main purpose of a status bar is to present status information to the users of your application. To show temporary status messages in a status bar, you need to use QStatusBar.showMessage()
. This method takes the following two arguments:
message
holds a status indicator message as a string.timeout
holds the number of milliseconds that the message will be shown on the status bar.
Si timeout
est 0
, which is its default value, then the message remains on the status bar until you call .clearMessage()
ou .showMessage()
on the status bar.
If there’s an active message on your status bar and you call .showMessage()
with a new message, then the new message will obscure or replace the old one.
Go to your sample application and add the following line to ._createStatusBar()
:
classe La fenêtre(QMainWindow):
# Snip...
def _createStatusBar(soi):
soi.statusbar = soi.statusBar()
# Adding a temporary message
soi.statusbar.showMessage("Ready", 3000)
The final line in ._createStatusBar()
will make your application show a Ready
message on the application’s status bar for 3000
milliseconds:
When you run the application, the status bar shows the message Ready
. After 3000
milliseconds, the message disappears and the status bar gets cleared and ready to show a new status message.
Showing Permanent Messages in Status Bars
You can also show permanent messages on your application’s status bar. A permanent message keeps the user informed about some general state of the application. For example, in a text editor, you might want to show a permanent message with information about the text encoding of the currently opened file.
To add permanent messages to your status bars, you use a QLabel
object to hold the message. Then you add the label to the status bar by calling .addPermanentWidget()
. This method permanently adds the given widget to the current status bar. The widget’s parent is set to the status bar.
.addPermanentWidget()
takes the following two arguments:
widget
holds the widget object that you want to add to the status bar. Some commonly used widgets on this role areQLabel
,QToolButton
, etQProgressBar
.stretch
is used to compute a suitable size for the widget as the status bar grows and shrinks. It defaults to0
, which means that the widget is going to take the minimum amount of space.
Keep in mind that a permanent widget won’t be obscured or replaced by temporary messages. .addPermanentWidget()
locates widgets at the right side of the status bar.
Remarque: You can use .addPermanentWidget()
not only to show permanent messages on your status bars but also to present the user with a progress bar to monitor the duration of a given operation. You can also provide buttons on the status bar to allow the user to change properties like the file encoding on a text editor.
When you use these kinds of widgets on a status bar, try to stick to the most commonly used widget for the type of application that you’re developing. This way, your users will feel right at home.
Say you want to turn your sample application into a text editor, and you want to add a message to the status bar that shows information about the word count of the current file. To do that, you can create a method called .getWordCount()
and then add a permanent message using .addPermanentWidget()
et un QLabel
object:
classe La fenêtre(QMainWindow):
# Snip...
def getWordCount(soi):
# Logic for computing the word count goes here...
revenir 42
This method adds the logic for computing the word count in the currently opened document. Now, you can show this information as a permanent message:
classe La fenêtre(QMainWindow):
# Snip...
def _createStatusBar(soi):
soi.statusbar = soi.statusBar()
# Adding a temporary message
soi.statusbar.showMessage("Ready", 3000)
# Adding a permanent message
soi.wcLabel = QLabel(F"soi.getWordCount() Words")
soi.statusbar.addPermanentWidget(soi.wcLabel)
In the last two lines, you first create a QLabel
object (wcLabel
) to hold the message about the word count. To create the message, you use an f-string, in which you insert a call to .getWordCount()
to get the word count information. Then you add the label to the status bar using .addPermanentWidget()
.
In this case, you create the QLabel
object as an instance attribute because the word count needs to be updated according to the changes that the user makes to the current file.
If you run the application with this update, then you’ll see the word count message on the right side of the status bar:
The status bar shows a message that informs the user about the word count in a hypothetical current file. The ability to present the user with permanent information or other options in the status bar is quite useful and can help you to greatly improve the user experience for your applications.
Adding Help Tips to Actions
When it comes to creating GUI applications, it’s important to offer help tips to your users about specific functionalities on the application’s interface. Help tips are short messages that provide a quick guide to the user about some of the options that the application offers.
PyQt actions allow you to define the following kinds of help tips:
-
Status tips are help tips that the application shows on the status bar when the user hovers the mouse pointer over a menu option or a toolbar button. By default, a status tip contains an empty string.
-
Tooltips are help tips that the application shows as floating messages when the user hovers their mouse pointer over a toolbar button or widget. By default, a tooltip contains text that identifies the action at hand.
Remarque: PyQt also offers the What’s This help tip that you can use in widgets and actions to show a richer description of the functionality that the widget or action provides. However, this topic is beyond the scope of this tutorial.
To learn how help tips work, you can add some status tips and tooltips to your sample application. Go to ._createActions()
and add the following lines of code:
classe La fenêtre(QMainWindow):
# Snip...
def _createActions(soi):
# File actions
# Snip...
soi.saveAction.setShortcut("Ctrl+S")
# Adding help tips
newTip = "Create a new file"
soi.newAction.setStatusTip(newTip)
soi.newAction.setToolTip(newTip)
# Edit actions
soi.copyAction = QAction(QIcon(":edit-copy.svg"), "&Copy", soi)
# Snip...
The three highlighted lines set the message "Create a new file"
as the status and tooltip for the New option. If you run the application now, then you’ll see that the New option shows a short but descriptive help tip to the user:
When you click the Fichier menu and hold your mouse pointer on New, you can see the help tip message shown on the left side of the status bar. On the other hand, if you move the mouse pointer over the New toolbar button, then you can see the message on the status bar and also as a small floating box next to the mouse pointer.
In general, adding help tips to your Python menus and toolbars is considered a best practice. It will make your GUI applications easier for users to navigate and learn. As a final exercise, you can continue adding help tips to the rest of the actions of your sample application and see how it looks after you’re done.
Conclusion
Menus, toolbars, and status bars are common and important graphical components of most GUI applications. You can use them to provide your user with a quick way to access the application’s options and functionalities. They also make your applications look polished and professional and provide a great experience to your users.
In this tutorial, you’ve learned how to:
- Programmatically create menus, toolbars, et status bars
- Use PyQt actions to populate your menus and toolbars
- Provide status information by using a status bar
Along the way, you’ve learned some best programming practices that are worth considering when it comes to adding and using menus, toolbars, and status bars in your GUI applications.
You’ve also coded a sample application in which you applied all your knowledge on menus and toolbars. You can get the full source code and other resources for that application by clicking on the box below:
[ad_2]