Création de menus, de barres d'outils et de barres d'état – Real Python

By | novembre 16, 2020

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:

Création de barres de menus, de menus et de barres d'outils Python dans PyQt

UNE barre de menu est une région de la fenêtre principale d'une application GUI qui contient les menus. Les menus sont des listes déroulantes d'options qui offrent un accès pratique aux options de votre application. Par exemple, si vous créez un éditeur de texte, vous pouvez avoir certains des menus suivants dans votre barre de menus:

  • UNE Fichier menu qui fournit certaines des options de menu suivantes:
    • Nouveau pour créer un nouveau document
    • Ouvert pour ouvrir un document existant
    • Ouverte récente pour ouvrir des documents récents
    • sauvegarder pour enregistrer un document
    • Sortie pour quitter l'application
  • Un Éditer menu qui fournit certaines des options de menu suivantes:
    • Copie pour copier du texte
    • Pâte pour coller du texte
    • Couper pour couper du texte
  • UNE Aidez-moi menu qui fournit certaines des options de menu suivantes:
    • Contenu de l'aide pour accéder au manuel de l'utilisateur et au contenu d'aide
    • À propos pour lancer une boîte de dialogue À propos

Vous pouvez également ajouter certaines de ces options à un barre d'outils. Une barre d'outils est un panneau de boutons avec des icônes significatives qui fournissent un accès rapide aux options les plus couramment utilisées dans une application. Dans votre exemple d'éditeur de texte, vous pouvez ajouter des options telles que Nouveau, Ouvert, sauvegarder, Copie, et Pâte à une barre d'outils.

Dans cette section, vous apprendrez les bases de l'ajout de barres de menus, de menus et de barres d'outils à vos applications GUI avec Python et PyQt.

Avant d'aller plus loin, vous allez créer un exemple d'application PyQt que vous utiliserez tout au long de ce didacticiel. Dans chaque section, vous ajouterez de nouvelles fonctionnalités et fonctionnalités à cet exemple d'application. L'application sera une application de type fenêtre principale. Cela signifie qu'il aura une barre de menus, une barre d'outils, une barre d'état et un widget central.

Ouvrez votre éditeur de code ou IDE préféré et créez un fichier Python appelé sample_app.py. Ajoutez ensuite le code suivant:

importer sys

de PyQt5.QtCore importer Qt
de PyQt5.QtWidgets importer QApplication, QLabel, QMainWindow

classe La fenêtre(QMainWindow):
    """Fenêtre principale."""
    def __init__(soi, parent=Aucun):
        "" "Initialiseur." ""
        super().__init__(parent)
        soi.setWindowTitle("Menus et barres d'outils Python")
        soi.redimensionner(400, 200)
        soi.centralWidget = QLabel("Bonjour le monde")
        soi.centralWidget.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
        soi.setCentralWidget(soi.centralWidget)

si __Nom__ == "__principale__":
    app = QApplication(sys.argv)
    gagner = La fenêtre()
    gagner.montrer()
    sys.sortie(app.exec_())

Maintenant sample_app.py contient tout le code dont vous avez besoin pour créer votre exemple d'application PyQt. Dans ce cas, La fenêtre hérite de QMainWindow. Vous créez donc une application de type fenêtre principale.

Dans l'initialiseur de classe .__ init __ (), vous appelez d'abord l'initialiseur de la classe parente à l'aide de super(). Ensuite, vous définissez le titre de la fenêtre en utilisant .setWindowTitle () et redimensionner la fenêtre en utilisant .resize ().

Le widget central de la fenêtre est un QLabel objet que vous utiliserez pour afficher des messages en réponse à certaines actions de l'utilisateur. Ces messages s'afficheront au centre de la fenêtre. Pour ce faire, vous appelez .setAlignment () sur le QLabel objet avec quelques indicateurs d'alignement.

Si vous exécutez l'application à partir de votre ligne de commande, vous verrez la fenêtre suivante sur votre écran:

Exemple d'application PyQt

C'est ça! Vous avez créé une application de style fenêtre principale avec Python et PyQt. Vous utiliserez cet exemple d'application pour tous les exemples à venir de ce didacticiel.

Créer des barres d'outils

Une barre d'outils est un panneau mobile qui contient des boutons et d'autres widgets pour fournir un accès rapide aux options les plus courantes d'une application GUI. Les boutons de la barre d'outils peuvent afficher des icônes, du texte ou les deux pour représenter la tâche qu'ils exécutent. La classe de base des barres d'outils dans PyQt est QToolBar. Cette classe vous permettra de créer des barres d'outils personnalisées pour vos applications GUI.

Lorsque vous ajoutez une barre d'outils à une application de style fenêtre principale, la position par défaut est en haut de la fenêtre. Cependant, vous pouvez placer une barre d'outils dans l'une des quatre zones de barre d'outils suivantes:

Zone de la barre d'outils Position dans la fenêtre principale
Qt.LeftToolBarArea Côté gauche
Qt.RightToolBarArea Côté droit
Qt.TopToolBarArea Haut
Qt.BottomToolBarArea Bas

Les zones de la barre d'outils sont définies comme des constantes dans PyQt. Si vous avez besoin de les utiliser, vous devez importer Qt de PyQt5.QtCore puis utilisez des noms complets comme dans Qt.LeftToolBarArea.

Il existe trois façons d'ajouter des barres d'outils à votre application de fenêtre principale dans PyQt:

  1. QMainWindow.addToolBar (titre) crée un nouveau et vide QToolBar objet et définit son titre de fenêtre sur Titre. Cette méthode insère la barre d'outils dans la zone de barre d'outils supérieure et renvoie la barre d'outils nouvellement créée.

  2. QMainWindow.addToolBar (barre d'outils) insère un QToolBar objet (barre d'outils) dans la zone supérieure de la barre d'outils.

  3. QMainWindow.addToolBar (zone, barre d'outils) insère un QToolBar objet (barre d'outils) dans la zone de barre d'outils spécifiée (surface). Si la fenêtre principale a déjà des barres d'outils, alors barre d'outils est placé après la dernière barre d'outils existante. Si barre d'outils existe déjà dans la fenêtre principale, il ne sera alors déplacé que vers surface.

Si vous utilisez l'une des deux dernières options, vous devez créer vous-même la barre d'outils. Pour ce faire, vous pouvez utiliser l'un des constructeurs suivants:

  1. QToolBar (parent)
  2. QToolBar (titre, parent)

Dans les deux cas, parent représente le QWidget objet qui détiendra la propriété de la barre d'outils. Vous définissez généralement la propriété de la barre d'outils sur la fenêtre dans laquelle vous allez utiliser la barre d'outils. Dans le deuxième constructeur, Titre sera une chaîne avec le titre de la fenêtre de la barre d'outils. PyQt utilise ce titre de fenêtre pour créer un menu contextuel par défaut qui vous permet de masquer et d'afficher vos barres d'outils.

Vous pouvez maintenant revenir à votre exemple d'application et ajouter la méthode suivante à La fenêtre:

de PyQt5.QtWidgets importer QToolBar
# Snip ...

classe La fenêtre(QMainWindow):
    # Snip ...
    def _createToolBars(soi):
        # Utiliser un titre
        fileToolBar = soi.addToolBar("Fichier")
        # Utilisation d'un objet QToolBar
        editToolBar = QToolBar("Éditer", soi)
        soi.addToolBar(editToolBar)
        # Utilisation d'un objet QToolBar et d'une zone de barre d'outils
        helpToolBar = QToolBar("Aidez-moi", soi)
        soi.addToolBar(Qt.LeftToolBarArea, helpToolBar)

Tout d'abord, vous importez QToolBar de PyQt5.QtWidgets. Puis dans ._createToolBars (), vous créez d'abord le Fichier barre d'outils utilisation .addToolBar () avec un titre. Ensuite, vous créez un QToolBar objet avec le titre "Éditer" et ajoutez-le à la barre d'outils en utilisant .addToolBar () sans passer une zone de barre d'outils. Dans ce cas, le Éditer la barre d'outils est placée dans la zone supérieure de la barre d'outils. Enfin, vous créez le Aidez-moi barre d'outils et placez-la dans la zone de gauche de la barre d'outils en utilisant Qt.LeftToolBarArea.

La dernière étape pour faire ce travail est d'appeler ._createToolBars () depuis l'initialiseur de La fenêtre:

classe La fenêtre(QMainWindow):
    """Fenêtre principale."""
    def __init__(soi, parent=Aucun):
        # Snip ...
        soi._createToolBars()

L'appel à ._createToolBars () à l'intérieur de l'initialiseur de La fenêtre créera trois barres d'outils et les ajoutera à votre fenêtre principale. Voici à quoi ressemble votre application maintenant:

Barres d'outils PyQt

Vous avez maintenant deux barres d'outils juste en dessous de la barre de menus et une barre d'outils sur le côté gauche de la fenêtre. Chaque barre d'outils a une double ligne pointillée. Lorsque vous déplacez la souris sur les lignes pointillées, le pointeur se transforme en main. Si vous cliquez et maintenez sur la ligne pointillée, vous pouvez déplacer la barre d'outils vers n'importe quelle autre position ou zone de barre d'outils de la fenêtre.

Si vous cliquez avec le bouton droit sur une barre d'outils, PyQt affichera un menu contextuel qui vous permettra de masquer et d'afficher les barres d'outils existantes en fonction de vos besoins.

Jusqu'à présent, vous avez trois barres d'outils dans la fenêtre de votre application. Ces barres d'outils sont encore vides. Vous devrez ajouter des boutons de barre d'outils pour les rendre fonctionnelles. Pour ce faire, vous pouvez utiliser PyQt Actions, qui sont des instances de QAction. Vous apprendrez à créer des actions dans PyQt dans une section ultérieure. Pour l'instant, vous apprendrez à utiliser les icônes et autres ressources dans vos applications PyQt.

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.

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.

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:

Barre de menus PyQt avec icônes

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.

Création d'actions pour les menus et les barres d'outils Python dans PyQt

PyQt Actions sont des objets qui représentent une commande, une opération ou une action donnée dans une application. Ils sont utiles lorsque vous devez fournir les mêmes fonctionnalités pour différents composants de l'interface graphique, tels que les options de menu, les boutons de la barre d'outils et les raccourcis clavier.

Vous pouvez créer des actions en instanciant QAction. Une fois que vous avez créé une action, vous devez l'ajouter à un widget pour pouvoir l'utiliser dans la pratique.

Vous devez également connecter vos actions à certaines fonctionnalités. En d'autres termes, vous devez les connecter à la fonction ou à la méthode que vous souhaitez exécuter lorsque l'action est déclenchée. Cela permettra à votre application d'effectuer des opérations en réponse aux actions de l'utilisateur dans l'interface graphique.

Les actions sont assez polyvalentes. Ils vous permettent de réutiliser et de synchroniser les mêmes fonctionnalités dans les options de menu, les boutons de la barre d'outils et les raccourcis clavier. Cela fournit un comportement cohérent dans toute l'application.

Par exemple, les utilisateurs peuvent s'attendre à ce que l'application effectue la même action lorsqu'ils cliquent sur le bouton Ouvert… option de menu, cliquez sur Ouvert bouton de la barre d'outils ou appuyez sur Ctrl+O sur leur clavier.

QAction fournit une abstraction qui vous permet de suivre les éléments suivants:

  • Le texte sur les options de menu
  • Le texte sur les boutons de la barre d'outils
  • Le conseil d'aide sur une option de barre d'outils (info-bulle)
  • L'astuce d'aide Qu'est-ce que c'est
  • Le conseil d'aide sur une barre d'état (conseil de statut)
  • Le raccourci clavier associé aux options
  • L'icône associée aux options du menu et de la barre d'outils
  • Les actions activée ou désactivée Etat
  • Les actions sur ou de Etat

Pour créer des actions, vous devez instancier QAction. Il existe au moins trois façons générales de le faire:

  1. QAction (parent)
  2. QAction (texte, parent)
  3. QAction (icône, texte, parent)

Dans les trois cas, parent représente l'objet qui détient la propriété de l'action. Cet argument peut être n'importe quel QObject. Une bonne pratique consiste à créer des actions en tant qu'enfants de la fenêtre dans laquelle vous allez les utiliser.

Dans les deuxième et troisième constructeurs, texte contient le texte que l'action affichera sur une option de menu ou un bouton de barre d'outils.

Le texte d'une action s'affiche différemment sur les options de menu et les boutons de la barre d'outils. Par exemple, le texte &Ouvert... s'affiche comme Ouvert… dans une option de menu et comme Ouvert dans un bouton de la barre d'outils.

Dans le troisième constructeur, icône est un QIcon objet contenant l'icône de l'action. Cette icône sera affichée sur le côté gauche du texte dans une option de menu. La position de l'icône dans un bouton de barre d'outils dépend de la barre d'outils .toolButtonStyle property, qui peut prendre l'une des valeurs suivantes:

Style Affichage des boutons
Qt.ToolButtonIconOnly Seule l'icône
Qt.ToolButtonTextOnly Seul le texte
Qt.ToolButtonTextBesideIcon Texte à côté de l'icône
Qt.ToolButtonTextUnderIcon Texte sous l'icône
Qt.ToolButtonFollowStyle Suit le style général de la plateforme sous-jacente

Vous pouvez également définir le texte et l'icône de l'action en utilisant leurs méthodes de setter, .Définir le texte() et .setIcon ().

Voici comment créer des actions pour votre exemple d’application à l’aide des différents constructeurs de QAction:

de PyQt5.QtWidgets importer QAction
# Snip ...

classe La fenêtre(QMainWindow):
    # Snip ...
    def _createActions(soi):
        # Création d'une action à l'aide du premier constructeur
        soi.newAction = QAction(soi)
        soi.newAction.Définir le texte("&Nouveau")
        # Création d'actions à l'aide du deuxième constructeur
        soi.openAction = QAction("&Ouvert...", soi)
        soi.saveAction = QAction("&Sauvegarder", soi)
        soi.exitAction = QAction("&Sortie", soi)
        soi.copyAction = QAction("&Copie", soi)
        soi.pasteAction = QAction("&Pâte", soi)
        soi.cutAction = QAction("Couper", soi)
        soi.helpContentAction = QAction("& Contenu de l'aide", soi)
        soi.aboutAction = QAction("&À propos", soi)

Dans ._createActions (), vous créez quelques actions pour votre exemple d'application. Ces actions vous permettront d’ajouter des options aux menus et aux barres d’outils de l’application.

Notez que vous créez des actions en tant qu'attributs d'instance, afin que vous puissiez y accéder de l'extérieur ._createActions () en utilisant soi. De cette façon, vous pourrez utiliser ces actions dans vos menus et vos barres d’outils.

La prochaine étape consiste à appeler ._createActions () former l'initialiseur de La fenêtre:

classe La fenêtre(QMainWindow):
    """Fenêtre principale."""
    def __init__(soi, parent=Aucun):
        # Snip ...
        soi._createActions()
        soi._createMenuBar()
        soi._createToolBars()

Si vous exécutez l'application maintenant, vous ne verrez aucun changement sur l'interface graphique. En effet, les actions ne s'affichent pas tant qu'elles ne sont pas ajoutées à un menu ou à une barre d'outils. Notez que vous appelez ._createActions () avant d'appeler ._createMenuBar () et ._createToolBars () car vous utiliserez ces actions dans vos menus et barres d'outils.

Si vous ajoutez une action à un menu, l'action devient une option de menu. Si vous ajoutez une action à une barre d'outils, l'action devient un bouton de barre d'outils. C'est le sujet des prochaines sections.

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:

  1. Fichier
  2. Éditer
  3. 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.

Si vous exécutez votre exemple d'application maintenant, la fenêtre suivante s'affichera à l'écran:

Barres d'outils PyQt avec boutons

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.

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.

Désormais, si vous exécutez l'application, vous obtiendrez le résultat suivant:

Barre d'outils PyQt avec widgets

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:

Personnalisation de la barre d'outils PyQt

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.

Organisation des options du menu et de la barre d'outils

Pour ajouter de la clarté et améliorer l'expérience utilisateur dans vos applications GUI, vous pouvez organiser les options de menu et les boutons de la barre d'outils à l'aide de séparateurs. Un séparateur s'affiche sous la forme d'une ligne horizontale qui délimite ou sépare les options de menu ou sous la forme d'une ligne verticale qui sépare les boutons de la barre d'outils.

Pour insérer ou ajouter un séparateur à un objet menu, sous-menu ou barre d'outils, vous pouvez appeler .addSeparator () sur l'un de ces objets.

Par exemple, vous pouvez utiliser un séparateur pour séparer le Sortie option sur votre Fichier menu parmi le reste des options juste pour préciser que Sortie n'est pas logiquement lié au reste des options du menu. Vous pouvez également utiliser un séparateur pour séparer les Trouver et remplacer option sur votre Éditer menu parmi les autres options suivant la même règle.

Accédez à votre exemple d'application et mettez à jour ._createMenuBar () comme dans le code suivant:

classe La fenêtre(QMainWindow):
    # Snip ...
    def _createMenuBar(soi):
        # Menu Fichier
        # Snip ...
        Menu Fichier.addAction(soi.saveAction)
        # Ajout d'un séparateur
        Menu Fichier.addSeparator()
        Menu Fichier.addAction(soi.exitAction)
        # Modifier le menu
        # Snip ...
        modifierMenu.addAction(soi.cutAction)
        # Ajout d'un séparateur
        modifierMenu.addSeparator()
        # Sous-menu Rechercher et remplacer dans le menu Edition
        trouverMenu = modifierMenu.addMenu("Trouver et remplacer")
        # Snip ...

Dans la première ligne en surbrillance, vous ajoutez un séparateur entre le sauvegarder et le Sortie options dans le Fichier menu. Dans la deuxième ligne en surbrillance, vous ajoutez un séparateur qui sépare le Trouver et remplacer option parmi les autres options du Éditer menu. Voici comment fonctionnent ces ajouts:

Menus PyQt avec séparateurs

Votre Fichier Le menu affiche maintenant une ligne horizontale qui sépare le Éditer option parmi les autres options du menu. le Éditer Le menu affiche également un séparateur à la fin de la liste déroulante d'options. L'utilisation cohérente du séparateur peut améliorer subtilement la clarté de vos menus et barres d'outils, rendant vos applications GUI plus conviviales.

À titre d'exercice, vous pouvez accéder à la définition de ._createToolBars () et ajoutez un séparateur qui sépare le QSpinBox objet parmi les autres options de la barre d'outils.

Connexion des signaux et des emplacements dans les menus et les barres d'outils

Dans PyQt, vous utilisez des signaux et des slots pour fournir des fonctionnalités à vos applications GUI. Les widgets PyQt émettent signaux chaque fois qu'un événement tel qu'un clic de souris, une pression sur une touche ou un redimensionnement de fenêtre se produit sur eux.

UNE fente est un appel Python que vous pouvez connecter au signal d'un widget pour effectuer certaines actions en réponse aux événements utilisateur. If a signal and a slot are connected, then the slot will be called automatically every time the signal is emitted. If a given signal isn’t connected to a slot, then nothing will happen when the signal is emitted.

To make your menu options and toolbar buttons launch some operations when the user clicks on them, you need to connect the signals of the underlying actions with some custom or built-in slots.

QAction objects can emit a variety of signals. However, the most commonly used signal in menus and toolbars is .triggered(). This signal is emitted every time the user clicks a menu option or a toolbar button. To connect .triggered() with a slot, you can use the following syntax:

action = QAction("Action Text", parent)
# Connect action's triggered() with a slot
action.triggered.connect(fente)

In this example, fente is a Python callable. In other words, fente can be a function, a method, a class, or an instance of a class that implements .__call__().

You already have a set of actions in your sample application. Now you need to code the slots that you’ll call every time the user clicks a menu option or a toolbar button. Go to the definition of La fenêtre and add the following methods:

classe La fenêtre(QMainWindow):
    # Snip...
    def newFile(soi):
        # Logic for creating a new file goes here...
        soi.centralWidget.setText("File > New clicked")

    def openFile(soi):
        # Logic for opening an existing file goes here...
        soi.centralWidget.setText("File > Open... clicked")

    def saveFile(soi):
        # Logic for saving a file goes here...
        soi.centralWidget.setText("File > Save clicked")

    def copyContent(soi):
        # Logic for copying content goes here...
        soi.centralWidget.setText("Edit > Copy clicked")

    def pasteContent(soi):
        # Logic for pasting content goes here...
        soi.centralWidget.setText("Edit > Pate clicked")

    def cutContent(soi):
        # Logic for cutting content goes here...
        soi.centralWidget.setText("Edit > Cut clicked")

    def helpContent(soi):
        # Logic for launching help goes here...
        soi.centralWidget.setText("Help > Help Content... clicked")

    def about(soi):
        # Logic for showing an about dialog content goes here...
        soi.centralWidget.setText("Help > About... clicked")

These methods will play the role of the slots of your sample application. They’ll be called every time the user clicks the corresponding menu option or toolbar button.

Once you have the slots that provide the functionality, you need to connect them with the action’s .triggered() signal. This way, the application will perform actions in response to the user events. To make these connections, go to the sample application and add the following method to La fenêtre:

classe La fenêtre(QMainWindow):
    # Snip...
    def _connectActions(soi):
        # Connect File actions
        soi.newAction.triggered.connect(soi.newFile)
        soi.openAction.triggered.connect(soi.openFile)
        soi.saveAction.triggered.connect(soi.saveFile)
        soi.exitAction.triggered.connect(soi.close)
        # Connect Edit actions
        soi.copyAction.triggered.connect(soi.copyContent)
        soi.pasteAction.triggered.connect(soi.pasteContent)
        soi.cutAction.triggered.connect(soi.cutContent)
        # Connect Help actions
        soi.helpContentAction.triggered.connect(soi.helpContent)
        soi.aboutAction.triggered.connect(soi.about)

This method will connect all your actions’ .triggered() signals with their respective slots or callbacks. With this update, your sample application will display a message on the QLabel object that you set as a central widget telling you what menu option or toolbar button was clicked.

In the case of exitAction, you connect its triggered() signal with the built-in slot QMainWindow.close(). This way, if you select File → Exit, then your application will close.

Finally, go to the initializer of La fenêtre and add a call to ._connectActions():

classe La fenêtre(QMainWindow):
    """Main Window."""
    def __init__(soi, parent=None):
        # Snip...
        # self._createContextMenu()
        soi._connectActions()

With this final update, you can run the application again. Here’s how all these changes work:

PyQt Connect Signals and Slots

If you click a menu option, a toolbar button, or a context menu option, then the label at the center of the application’s window shows a message indicating the action that was executed. This functionality isn’t very useful outside of a learning context, but it gives you an idea of how to make your applications perform real-world actions when the user interacts with the GUI.

Finally, when you select File → Exit, the application closes because the .triggered() signal of exitAction is connected to the built-in slot QMainWindow.close().

As an exercise, you can try to create custom slots for the Find… et Replace… options in the Find and Replace submenu and then connect their .triggered() signals to those slots to make them live. You can also experiment with the slots that you coded in this section and try to do new things with them.

Defining Keyboard Shortcuts for Menu and Toolbar Options

Keyboard shortcuts are an important feature in a GUI application. A keyboard shortcut is a key combination that you can press in your keyboard to quickly access some of the most common options in an application.

Here are some examples of keyboard shortcuts:

  • Ctrl+C copies something to the clipboard.
  • Ctrl+V pastes something from the clipboard.
  • Ctrl+Z undoes the last operation.
  • Ctrl+O opens files.
  • Ctrl+S saves files.

In the section below, you’ll learn how to add keyboard shortcuts to your application to improve your user’s productivity and experience.

Using Key Sequences

So far, you’ve learned that QAction is a versatile class for populating menus and toolbars. QAction also provides a user-friendly way of defining keyboard shortcuts for your menu options and toolbar buttons.

QAction implements .setShortcut(). This method takes a QKeySequence object as an argument and returns a keyboard shortcut.

QKeySequence provides several constructors. In this tutorial, you’ll learn about two of them:

  1. QKeySequence(ks, format) takes a string-based key sequence (ks) and a format (format) as arguments and creates a QKeySequence object.

  2. QKeySequence(key) takes a StandardKey constant as an argument and creates a QKeySequence object that matches that key sequences on the underlying platform.

The first constructor recognizes the following strings:

  • "Ctrl"
  • "Shift"
  • "Alt"
  • "Meta"

You can create string-based key sequences by combining these strings with letters, punctuation marks, digits, named keys (Up, Down, Accueil), and function keys ("Ctrl+S", "Ctrl+5", "Alt+Home", "Alt+F4"). You can pass up to four of these string-based key sequences in a comma-separated list.

The second constructor is handy if you’re developing a multi-platform application and want to stick to the standard keyboard shortcuts for each platform. For example, QKeySequence.Copy will return the platform’s standard keyboard shortcut for copying objects to the clipboard.

With this general background on how to define keyboard shortcuts for actions in PyQt, you can get back to your sample application and add some shortcuts. To do this, you need to update ._createActions():

de PyQt5.QtGui importer QKeySequence
# Snip...

classe La fenêtre(QMainWindow):
    # Snip...
    def _createActions(soi):
        # File actions
        # Snip...
        # Using string-based key sequences
        soi.newAction.setShortcut("Ctrl+N")
        soi.openAction.setShortcut("Ctrl+O")
        soi.saveAction.setShortcut("Ctrl+S")
        # Edit actions
        # Snip...
        # Using standard keys
        soi.copyAction.setShortcut(QKeySequence.Copy)
        soi.pasteAction.setShortcut(QKeySequence.Paste)
        soi.cutAction.setShortcut(QKeySequence.Cut)
        # Snip...

You first need to import QKeySequence. Inside ._createActions(), the first three highlighted lines create keyboard shortcuts using a string-based key sequence. This is a quick way of adding keyboard shortcuts to your action. In the second three highlighted lines, you use QKeySequence to supply standard keyboard shortcuts.

If you run the sample application with these additions, then your menus will look like this:

PyQt Keyboard Shortcuts

Your menu options now show a keyboard shortcut on their right side. If you press any of these key combinations, then you’ll execute the corresponding action.

Using Keyboard Accelerators

There’s another alternative that you can use to add keyboard shortcuts, or keyboard accelerators, to the menu options of your applications.

You might have noticed that when you set the text for a menu or a menu option, you commonly insert an ampersand symbol (&) in the text. You do this so the letter immediately after the ampersand will be underlined when displayed in the text of the menu or menu option. For example, if you place an ampersand before the letter F in the title of a Fichier menu ("&File"), then the F will be underlined when the menu title is displayed.

In the case of a menu bar, using the ampersand allows you to invoke any menu by pressing Alt in combination with the underlined letter in the menu title.

Once you’ve launched a menu, you can access any menu option by pressing the underlined letter in the text of the option. For example, in Fichier you can access the Exit option by pressing the letter E.

This feature will allow you to provide quick keyboard accelerators for users who prefer to use their keyboard to work with your applications. This technique is especially useful for options that don’t provide an explicit keyboard shortcut.

Creating Menus and Toolbars: Best Practices and Tips

When you’re creating menus and toolbars with Python and PyQt, you should follow some standards that are generally considered best practices in GUI programming. Here’s a quick list:

  1. Arrange your menus in the generally accepted order. For example, if you have a Fichier menu, then it should be the first menu from left to right. If you have an Edit menu, then it should be the second. Help should be the rightmost menu, and so on.

  2. Populate your menus with common options for the type of application you’re developing. For example, in a text editor, Fichier menus commonly include options like New, Ouvert, Save, et Exit. Edit menus often include options like Copy, Paste, Cut, Undo, and so on.

  3. Use standard keyboard shortcuts for common options. Par exemple, utilisez Ctrl+C pour Copy, Ctrl+V pour Paste, Ctrl+X pour Cut, and so on.

  4. Use separators to separate unrelated options. These visual cues will make your application easier to navigate.

  5. Add ellipses (...) to the title of options that launch additional dialogs. Par exemple, utilisez Save As… instead of Save As, About… instead of À propos, and so on.

  6. Use ampersands (&) in your menu options to provide convenient keyboard accelerators. For example, "&Open instead of "Open", "&Exit" instead of "Exit".

If you follow these guidelines, then your GUI applications will provide a familiar and inviting experience for your users.

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:

  1. Temporary indicators take up almost the entire status bar for a short time to display tooltip texts, menu entries, and other time-sensitive information.

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

  3. 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 your QMainWindow 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:

PyQt Status Bar

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:

  1. message holds a status indicator message as a string.
  2. 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:

PyQt Status Message

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:

  1. widget holds the widget object that you want to add to the status bar. Some commonly used widgets on this role are QLabel, QToolButton, et QProgressBar.
  2. stretch is used to compute a suitable size for the widget as the status bar grows and shrinks. It defaults to 0, 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.

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:

PyQt Status Bar With Permanent Widgets

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.

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:

PyQt Help Tips

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: