MENU
  1. Accueil
  2. Python
  3. Toutes les méthodes pour créer et afficher un menu contextuel en Python

Toutes les méthodes pour créer et afficher un menu contextuel en Python

Python

Apprendre à créer un menu contextuel en Python est extrêmement utile dans le développement d’applications GUI. Cet article explique en détail comment créer des menus contextuels en utilisant des bibliothèques populaires telles que Tkinter, PyQt, wxPython, Kivy, et PyGTK. Nous allons comparer les caractéristiques et avantages de chaque bibliothèque, tout en apprenant à travers des exemples de code concrets. Cela fournira des informations utiles à tous les développeurs Python, des débutants aux experts.

Sommaire

Création d’un menu contextuel avec Tkinter

Tkinter est une bibliothèque GUI standard incluse avec Python, ce qui permet de créer facilement des menus contextuels. Nous allons détailler ici les étapes pour créer un menu contextuel basique.

Création d’un menu contextuel basique

Voici un code simple pour créer un menu contextuel en Tkinter.

import tkinter as tk
from tkinter import Menu

def show_popup(event):
    popup_menu.post(event.x_root, event.y_root)

root = tk.Tk()
root.title("Exemple de menu contextuel Tkinter")

# Création du menu contextuel
popup_menu = Menu(root, tearoff=0)
popup_menu.add_command(label="Option 1", command=lambda: print("Option 1 sélectionnée"))
popup_menu.add_command(label="Option 2", command=lambda: print("Option 2 sélectionnée"))
popup_menu.add_separator()
popup_menu.add_command(label="Quitter", command=root.quit)

# Affichage du menu contextuel avec un clic droit
root.bind("", show_popup)

root.mainloop()

Explication du code

Cette section explique chaque partie du code ci-dessus en détail.

Importation des modules nécessaires

Nous importons les modules tkinter et Menu.

import tkinter as tk
from tkinter import Menu

Définition de la fonction d’affichage du menu contextuel

Nous définissons la fonction show_popup, qui capte l’événement du clic droit de la souris pour afficher le menu contextuel.

def show_popup(event):
    popup_menu.post(event.x_root, event.y_root)

Configuration de la fenêtre principale

Nous créons la fenêtre principale et définissons son titre.

root = tk.Tk()
root.title("Exemple de menu contextuel Tkinter")

Création du menu contextuel

Nous créons le menu contextuel et y ajoutons des options.

popup_menu = Menu(root, tearoff=0)
popup_menu.add_command(label="Option 1", command=lambda: print("Option 1 sélectionnée"))
popup_menu.add_command(label="Option 2", command=lambda: print("Option 2 sélectionnée"))
popup_menu.add_separator()
popup_menu.add_command(label="Quitter", command=root.quit)

Binding des événements

Nous lions l’événement du clic droit pour afficher le menu contextuel.

root.bind("", show_popup)

En suivant ces étapes, vous pouvez créer un menu contextuel basique avec Tkinter. Veuillez sélectionner le prochain sujet à explorer.

Création d’un menu contextuel avec PyQt

PyQt est une bibliothèque GUI très puissante disponible pour Python. Nous allons ici expliquer comment créer un menu contextuel avec PyQt.

Création d’un menu contextuel basique

Voici un exemple de code pour créer un menu contextuel avec PyQt.

import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QMenu

class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Exemple de menu contextuel PyQt")
        self.setGeometry(100, 100, 600, 400)

        # Ajout d'un événement clic droit sur la fenêtre
        self.setContextMenuPolicy(Qt.CustomContextMenu)
        self.customContextMenuRequested.connect(self.show_popup)

    def show_popup(self, position):
        popup_menu = QMenu(self)
        option1 = popup_menu.addAction("Option 1")
        option2 = popup_menu.addAction("Option 2")
        exit_action = popup_menu.addAction("Quitter")

        action = popup_menu.exec_(self.mapToGlobal(position))

        if action == option1:
            print("Option 1 sélectionnée")
        elif action == option2:
            print("Option 2 sélectionnée")
        elif action == exit_action:
            QApplication.quit()

if __name__ == "__main__":
    app = QApplication(sys.argv)
    mainWin = MainWindow()
    mainWin.show()
    sys.exit(app.exec_())

Explication du code

Cette section explique chaque partie du code ci-dessus en détail.

Importation des modules nécessaires

Nous importons les classes nécessaires depuis PyQt5.QtWidgets.

import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QMenu

Configuration de la fenêtre principale

Nous créons la fenêtre principale en héritant de la classe QMainWindow, et définissons son titre et sa taille.

class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Exemple de menu contextuel PyQt")
        self.setGeometry(100, 100, 600, 400)

Configuration de l’événement de clic droit

Nous ajoutons l’événement clic droit à la fenêtre, et configurons le menu contextuel pour s’afficher lors d’un clic droit.

        self.setContextMenuPolicy(Qt.CustomContextMenu)
        self.customContextMenuRequested.connect(self.show_popup)

Création et affichage du menu contextuel

Nous créons le menu contextuel et y ajoutons des actions. Lorsqu’une action est sélectionnée, un traitement est effectué.

    def show_popup(self, position):
        popup_menu = QMenu(self)
        option1 = popup_menu.addAction("Option 1")
        option2 = popup_menu.addAction("Option 2")
        exit_action = popup_menu.addAction("Quitter")

        action = popup_menu.exec_(self.mapToGlobal(position))

        if action == option1:
            print("Option 1 sélectionnée")
        elif action == option2:
            print("Option 2 sélectionnée")
        elif action == exit_action:
            QApplication.quit()

En suivant ces étapes, vous pouvez créer un menu contextuel basique avec PyQt. Sélectionnez le prochain sujet à explorer.

Création d’un menu contextuel avec wxPython

wxPython est une bibliothèque GUI multiplateforme disponible pour Python. Nous allons ici expliquer comment créer un menu contextuel avec wxPython.

Création d’un menu contextuel basique

Voici un exemple de code pour créer un menu contextuel avec wxPython.

import wx

class MyFrame(wx.Frame):
    def __init__(self):
        super().__init__(parent=None, title='Exemple de menu contextuel wxPython', size=(600, 400))
        self.panel = wx.Panel(self)

        # Binding de l'événement clic droit
        self.panel.Bind(wx.EVT_RIGHT_DOWN, self.show_popup)

    def show_popup(self, event):
        popup_menu = wx.Menu()

        option1 = popup_menu.Append(wx.ID_ANY, 'Option 1')
        option2 = popup_menu.Append(wx.ID_ANY, 'Option 2')
        popup_menu.AppendSeparator()
        exit_option = popup_menu.Append(wx.ID_EXIT, 'Quitter')

        # Binding des gestionnaires d'événements
        self.Bind(wx.EVT_MENU, self.on_option1, option1)
        self.Bind(wx.EVT_MENU, self.on_option2, option2)
        self.Bind(wx.EVT_MENU, self.on_exit, exit_option)

        self.PopupMenu(popup_menu, event.GetPosition())
        popup_menu.Destroy()

    def on_option1(self, event):
        print('Option 1 sélectionnée')

    def on_option2(self, event):
        print('Option 2 sélectionnée')

    def on_exit(self, event):
        self.Close()

if __name__ == '__main__':
    app = wx.App(False)
    frame = MyFrame()
    frame.Show()
    app.MainLoop()

Explication du code

Cette section explique chaque partie du code ci-dessus en détail.

Importation des modules nécessaires

Nous importons le module wx.

import wx

Configuration de la fenêtre principale

Nous créons la fenêtre principale en héritant de la classe wx.Frame, et définissons son titre et sa taille.

class MyFrame(wx.Frame):
    def __init__(self):
        super().__init__(parent=None, title='Exemple de menu contextuel wxPython', size=(600, 400))
        self.panel = wx.Panel(self)

Configuration de l’événement clic droit

Nous lions l’événement clic droit au panneau pour afficher le menu contextuel lorsqu’un clic droit est effectué.

        self.panel.Bind(wx.EVT_RIGHT_DOWN, self.show_popup)

Création et affichage du menu contextuel

Nous créons le menu contextuel, ajoutons des options et lions des gestionnaires d’événements pour chaque option.

    def show_popup(self, event):
        popup_menu = wx.Menu()

        option1 = popup_menu.Append(wx.ID_ANY, 'Option 1')
        option2 = popup_menu.Append(wx.ID_ANY, 'Option 2')
        popup_menu.AppendSeparator()
        exit_option = popup_menu.Append(wx.ID_EXIT, 'Quitter')

        self.Bind(wx.EVT_MENU, self.on_option1, option1)
        self.Bind(wx.EVT_MENU, self.on_option2, option2)
        self.Bind(wx.EVT_MENU, self.on_exit, exit_option)

        self.PopupMenu(popup_menu, event.GetPosition())
        popup_menu.Destroy()

Définition des gestionnaires d’événements

Nous définissons des gestionnaires d’événements pour chaque option du menu contextuel.

    def on_option1(self, event):
        print('Option 1 sélectionnée')

    def on_option2(self, event):
        print('Option 2 sélectionnée')

    def on_exit(self, event):
        self.Close()

En suivant ces étapes, vous pouvez créer un menu contextuel basique avec wxPython. Sélectionnez le prochain sujet à explorer.

Création d’un menu contextuel avec Kivy

Kivy est une bibliothèque GUI open-source multiplateforme disponible pour Python. Nous allons ici expliquer comment créer un menu contextuel avec Kivy.

Création d’un menu contextuel basique

Voici un exemple de code pour créer un menu contextuel avec Kivy.

from kivy.app import App
from kivy.uix.button import Button
from kivy.uix.gridlayout import GridLayout
from kivy.uix.popup import Popup
from kivy.uix.label import Label
from kivy.uix.boxlayout import BoxLayout

class MyPopup(Popup):
    def __init__(self, **kwargs):
        super(MyPopup, self).__init__(**kwargs)
        self.title = 'Menu contextuel'
        self.size_hint = (0.5, 0.5)

        layout = BoxLayout(orientation='vertical')
        btn1 = Button(text='Option 1')
        btn1.bind(on_press=self.option1)
        btn2 = Button(text='Option 2')
        btn2.bind(on_press=self.option2)
        close_btn = Button(text='Fermer')
        close_btn.bind(on_press=self.dismiss)

        layout.add_widget(btn1)
        layout.add_widget(btn2)
        layout.add_widget(close_btn)

        self.add_widget(layout)

    def option1(self, instance):
        print('Option 1 sélectionnée')
        self.dismiss()

    def option2(self, instance):
        print('Option 2 sélectionnée')
        self.dismiss()

class MyGrid(GridLayout):
    def __init__(self, **kwargs):
        super(MyGrid, self).__init__(**kwargs)
        self.cols = 1
        self.popup = MyPopup()

        btn = Button(text='Afficher le menu contextuel')
        btn.bind(on_press=self.show_popup)
        self.add_widget(btn)

    def show_popup(self, instance):
        self.popup.open()

class MyApp(App):
    def build(self):
        return MyGrid()

if __name__ == '__main__':
    MyApp().run()

Explication du code

Cette section explique chaque partie du code ci-dessus en détail.

Importation des modules nécessaires

Nous importons les principales classes de widget Kivy.

from kivy.app import App
from kivy.uix.button import Button
from kivy.uix.gridlayout import GridLayout
from kivy.uix.popup import Popup
from kivy.uix.label import Label
from kivy.uix.boxlayout import BoxLayout

Définition de la classe Popup

Nous créons une fenêtre contextuelle en héritant de la classe Popup et nous définissons son titre et sa taille.

class MyPopup(Popup):
    def __init__(self, **kwargs):
        super(MyPopup, self).__init__(**kwargs)
        self.title = 'Menu contextuel'
        self.size_hint = (0.5, 0.5)

Création du menu contextuel

Nous ajoutons des boutons au menu contextuel et associons des fonctions de rappel à chaque bouton.

        layout = BoxLayout(orientation='vertical')
        btn1 = Button(text='Option 1')
        btn1.bind(on_press=self.option1)
        btn2 = Button(text='Option 2')
        btn2.bind(on_press=self.option2)
        close_btn = Button(text='Fermer')
        close_btn.bind(on_press=self.dismiss)

        layout.add_widget(btn1)
        layout.add_widget(btn2)
        layout.add_widget(close_btn)

        self.add_widget(layout)

Gestion des événements pour chaque option

Nous définissons des fonctions qui seront appelées lorsque chaque option sera sélectionnée.

    def option1(self, instance):
        print('Option 1 sélectionnée')
        self.dismiss()

    def option2(self, instance):
        print('Option 2 sélectionnée')
        self.dismiss()

Définition de la classe principale de l’application

Nous définissons la classe principale de l’application en héritant de App.

class MyApp(App):
    def build(self):
        return MyGrid()

En suivant ces étapes, vous pouvez créer un menu contextuel basique avec Kivy. Sélectionnez le prochain sujet à explorer.

Création d’un menu contextuel avec PyGTK

PyGTK est une bibliothèque permettant d’utiliser GTK avec Python, et est idéale pour le développement GUI multiplateforme. Voici comment créer un menu contextuel avec PyGTK.

Création d’un menu contextuel basique

Voici un exemple de code pour créer un menu contextuel avec PyGTK.

import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk

class MyWindow(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self, title="Exemple de menu contextuel PyGTK")
        self.set_default_size(600, 400)
        self.connect("destroy", Gtk.main_quit)

        # Création d'un bouton et ajout à la fenêtre
        button = Gtk.Button(label="Clic droit pour le menu contextuel")
        button.connect("button-press-event", self.on_button_press)
        self.add(button)

        # Création du menu contextuel
        self.popup_menu = Gtk.Menu()
        option1 = Gtk.MenuItem(label="Option 1")
        option1.connect("activate", self.on_option1)
        self.popup_menu.append(option1)

        option2 = Gtk.MenuItem(label="Option 2")
        option2.connect("activate", self.on_option2)
        self.popup_menu.append(option2)

        separator = Gtk.SeparatorMenuItem()
        self.popup_menu.append(separator)

        exit_option = Gtk.MenuItem(label="Quitter")
        exit_option.connect("activate", Gtk.main_quit)
        self.popup_menu.append(exit_option)

        self.popup_menu.show_all()

    def on_button_press(self, widget, event):
        if event.button == 3:  # Clic droit
            self.popup_menu.popup(None, None, None, None, event.button, event.time)

    def on_option1(self, widget):
        print("Option 1 sélectionnée")

    def on_option2(self, widget):
        print("Option 2 sélectionnée")

win = MyWindow()
win.show_all()
Gtk.main()

Explication du code

Cette section explique chaque partie du code ci-dessus en détail.

Importation des modules nécessaires

Nous importons les modules gi et Gtk.

import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk

Configuration de la fenêtre principale

Nous créons la fenêtre principale en héritant de Gtk.Window, et définissons son titre et sa taille.

class MyWindow(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self, title="Exemple de menu contextuel PyGTK")
        self.set_default_size(600, 400)
        self.connect("destroy", Gtk.main_quit)

Création du bouton et configuration de l’événement

Nous ajoutons un bouton à la fenêtre et lions l’événement du clic droit pour afficher le menu contextuel.

        button = Gtk.Button(label="Clic droit pour le menu contextuel")
        button.connect("button-press-event", self.on_button_press)
        self.add(button)

Création du menu contextuel

Nous créons le menu contextuel, ajoutons des options et lions des gestionnaires d’événements pour chaque option.

        self.popup_menu = Gtk.Menu()
        option1 = Gtk.MenuItem(label="Option 1")
        option1.connect("activate", self.on_option1)
        self.popup_menu.append(option1)

        option2 = Gtk.MenuItem(label="Option 2")
        option2.connect("activate", self.on_option2)
        self.popup_menu.append(option2)

        separator = Gtk.SeparatorMenuItem()
        self.popup_menu.append(separator)

        exit_option = Gtk.MenuItem(label="Quitter")
        exit_option.connect("activate", Gtk.main_quit)
        self.popup_menu.append(exit_option)

        self.popup_menu.show_all()

Gestion des événements pour chaque option

Nous définissons des fonctions qui seront appelées lorsque chaque option sera sélectionnée.

    def on_button_press(self, widget, event):
        if event.button == 3:  # Clic droit
            self.popup_menu.popup(None, None, None, None, event.button, event.time)

    def on_option1(self, widget):
        print("Option 1 sélectionnée")

    def on_option2(self, widget):
        print("Option 2 sélectionnée")

En suivant ces étapes, vous pouvez créer un menu contextuel basique avec PyGTK. Sélectionnez le prochain sujet à explorer.

Comparaison des bibliothèques

Nous comparons maintenant les caractéristiques et les avantages des cinq bibliothèques GUI principales de Python : Tkinter, PyQt, wxPython, Kivy et PyGTK.

Tkinter

Caractéristiques

  • Fait partie de la bibliothèque standard de Python, pas d’installation nécessaire
  • Simple et léger
  • Idéal pour des applications GUI basiques

Avantages

  • Faible coût d’apprentissage, adapté aux débutants
  • Documentation officielle complète

Inconvénients

  • Pas adapté pour des applications GUI complexes
  • Difficile de créer des designs modernes

PyQt

Caractéristiques

  • Permet d’utiliser la bibliothèque Qt avec Python
  • Permet de créer des applications GUI avancées
  • Compatible multiplateforme

Avantages

  • Riche en widgets et fonctionnalités
  • Permet de créer des designs modernes et sophistiqués

Inconvénients

  • Licence nécessaire pour une utilisation commerciale
  • Coût d’apprentissage élevé

wxPython

Caractéristiques

  • Permet d’utiliser la bibliothèque wxWidgets avec Python
  • Fournit une interface native

Avantages

  • Fournit une interface native
  • Flexible et hautement personnalisable

Inconvénients

  • Configuration plus complexe par rapport aux autres bibliothèques
  • Documentation dispersée

Kivy

Caractéristiques

  • Idéal pour le développement d’applications multiplateformes
  • Soutient les interactions tactiles

Avantages

  • Facilite le développement d’applications mobiles
  • Open source et gratuit

Inconvénients

  • Coût d’apprentissage élevé
  • Peut ne pas être adapté aux applications de bureau

PyGTK

Caractéristiques

  • Compatible multiplateforme

Avantages

  • Prise en charge de nombreux widgets et thèmes

  • Haute compatibilité avec l’environnement de bureau GNOME

Inconvénients

  • Configuration plus complexe par rapport aux autres bibliothèques

  • Support limité sous Windows

À travers cette comparaison, vous pouvez choisir la bibliothèque qui convient le mieux à votre projet. Sélectionnez le prochain sujet à explorer.

Exemples avancés : Créer des menus complexes

Dans cette section, nous allons vous montrer comment créer des menus contextuels complexes avec plusieurs options et sous-menus en utilisant chaque bibliothèque.

Création d’un menu complexe avec Tkinter

import tkinter as tk
from tkinter import Menu

def show_popup(event):
    popup_menu.post(event.x_root, event.y_root)

root = tk.Tk()
root.title("Exemple de menu contextuel complexe Tkinter")

# Création du menu contextuel
popup_menu = Menu(root, tearoff=0)
file_menu = Menu(popup_menu, tearoff=0)
file_menu.add_command(label="Nouveau")
file_menu.add_command(label="Ouvrir")
file_menu.add_command(label="Enregistrer")
popup_menu.add_cascade(label="Fichier", menu=file_menu)

edit_menu = Menu(popup_menu, tearoff=0)
edit_menu.add_command(label="Annuler")
edit_menu.add_command(label="Rétablir")
popup_menu.add_cascade(label="Édition", menu=edit_menu)

popup_menu.add_separator()
popup_menu.add_command(label="Quitter", command=root.quit)

# Affichage du menu contextuel avec clic droit
root.bind("", show_popup)

root.mainloop()

Création d’un menu complexe avec PyQt

import sys
from PyQt5.QtWidgets import QApplication, QMainWindow, QMenu

class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Exemple de menu contextuel complexe PyQt")
        self.setGeometry(100, 100, 600, 400)

        # Ajout d'un événement clic droit sur la fenêtre
        self.setContextMenuPolicy(Qt.CustomContextMenu)
        self.customContextMenuRequested.connect(self.show_popup)

    def show_popup(self, position):
        popup_menu = QMenu(self)

        file_menu = popup_menu.addMenu("Fichier")
        file_menu.addAction("Nouveau")
        file_menu.addAction("Ouvrir")
        file_menu.addAction("Enregistrer")

        edit_menu = popup_menu.addMenu("Édition")
        edit_menu.addAction("Annuler")
        edit_menu.addAction("Rétablir")

        popup_menu.addSeparator()
        exit_action = popup_menu.addAction("Quitter")
        exit_action.triggered.connect(QApplication.quit)

        popup_menu.exec_(self.mapToGlobal(position))

if __name__ == "__main__":
    app = QApplication(sys.argv)
    mainWin = MainWindow()
    mainWin.show()
    sys.exit(app.exec_())

Création d’un menu complexe avec wxPython

import wx

class MyFrame(wx.Frame):
    def __init__(self):
        super().__init__(parent=None, title='Exemple de menu contextuel complexe wxPython', size=(600, 400))
        self.panel = wx.Panel(self)

        # Binding de l'événement clic droit
        self.panel.Bind(wx.EVT_RIGHT_DOWN, self.show_popup)

    def show_popup(self, event):
        popup_menu = wx.Menu()

        file_menu = wx.Menu()
        file_menu.Append(wx.ID_ANY, 'Nouveau')
        file_menu.Append(wx.ID_ANY, 'Ouvrir')
        file_menu.Append(wx.ID_ANY, 'Enregistrer')
        popup_menu.AppendSubMenu(file_menu, 'Fichier')

        edit_menu = wx.Menu()
        edit_menu.Append(wx.ID_ANY, 'Annuler')
        edit_menu.Append(wx.ID_ANY, 'Rétablir')
        popup_menu.AppendSubMenu(edit_menu, 'Édition')

        popup_menu.AppendSeparator()
        exit_option = popup_menu.Append(wx.ID_EXIT, 'Quitter')
        self.Bind(wx.EVT_MENU, self.on_exit, exit_option)

        self.PopupMenu(popup_menu, event.GetPosition())
        popup_menu.Destroy()

    def on_exit(self, event):
        self.Close()

if __name__ == '____main__':
    app = wx.App(False)
    frame = MyFrame()
    frame.Show()
    app.MainLoop()

Création d’un menu complexe avec Kivy

from kivy.app import App
from kivy.uix.button import Button
from kivy.uix.gridlayout import GridLayout
from kivy.uix.popup import Popup
from kivy.uix.label import Label
from kivy.uix.boxlayout import BoxLayout

class MyPopup(Popup):
    def __init__(self, **kwargs):
        super(MyPopup, self).__init__(**kwargs)
        self.title = 'Menu contextuel'
        self.size_hint = (0.5, 0.5)

        layout = BoxLayout(orientation='vertical')

        file_btn = Button(text='Fichier')
        file_btn.bind(on_press=self.show_file_menu)
        edit_btn = Button(text='Édition')
        edit_btn.bind(on_press=self.show_edit_menu)
        close_btn = Button(text='Fermer')
        close_btn.bind(on_press=self.dismiss)

        layout.add_widget(file_btn)
        layout.add_widget(edit_btn)
        layout.add_widget(close_btn)

        self.add_widget(layout)

    def show_file_menu(self, instance):
        file_menu = BoxLayout(orientation='vertical')
        file_menu.add_widget(Button(text='Nouveau'))
        file_menu.add_widget(Button(text='Ouvrir'))
        file_menu.add_widget(Button(text='Enregistrer'))
        self.add_widget(file_menu)

    def show_edit_menu(self, instance):
        edit_menu = BoxLayout(orientation='vertical')
        edit_menu.add_widget(Button(text='Annuler'))
        edit_menu.add_widget(Button(text='Rétablir'))
        self.add_widget(edit_menu)

class MyGrid(GridLayout):
    def __init__(self, **kwargs):
        super(MyGrid, self).__init__(**kwargs)
        self.cols = 1
        self.popup = MyPopup()

        btn = Button(text='Afficher le menu contextuel')
        btn.bind(on_press=self.show_popup)
        self.add_widget(btn)

    def show_popup(self, instance):
        self.popup.open()

class MyApp(App):
    def build(self):
        return MyGrid()

if __name__ == '__main__':
    MyApp().run()

En suivant ces étapes, vous pouvez créer des menus contextuels complexes avec chaque bibliothèque. Sélectionnez le prochain sujet à explorer.

Exercices : Créez votre propre menu contextuel

Voici quelques exercices pour vous entraîner à créer des menus contextuels avec chaque bibliothèque. Utilisez vos connaissances pour résoudre les défis suivants.

Exercice 1 : Créer un menu contextuel personnalisé avec Tkinter

  • Ajoutez des options telles que « Ouvrir un fichier », « Enregistrer un fichier » et « Fermer ».

  • Implémentez une fonctionnalité pour afficher une boîte de dialogue de fichier lorsque l’option « Ouvrir un fichier » est sélectionnée.

Indice :

from tkinter import filedialog

def open_file():
    filedialog.askopenfilename()

Exercice 2 : Créer un menu contextuel avec des icônes avec PyQt

  • Ajoutez des icônes à chaque élément du menu.

  • Associez une icône à chaque option comme « Nouveau », « Ouvrir », « Enregistrer », « Quitter ».

Indice :

new_action = QAction(QIcon('new_icon.png'), 'Nouveau', self)

Exercice 3 : Ajouter dynamiquement des éléments de menu avec wxPython

  • Implémentez une fonctionnalité où un nouvel élément de menu est ajouté chaque fois qu’un clic droit est effectué.

  • Ajoutez un nouvel élément de menu « Ajouter une option », qui affiche « Option X sélectionnée » lorsque cliqué (X augmente dynamiquement).

Indice :

def on_add_option(self, event):
    option_count = len(self.popup_menu.GetMenuItems())
    new_option = self.popup_menu.Append(wx.ID_ANY, f'Option {option_count + 1}')
    self.Bind(wx.EVT_MENU, lambda e: print(f'Option {option_count + 1} sélectionnée'), new_option)

Exercice 4 : Ajouter des widgets personnalisés au menu contextuel avec Kivy

  • Ajoutez un widget personnalisé au menu contextuel (par exemple, un curseur ou un champ de texte).

  • Ajoutez une option « Ajuster le volume », permettant de régler le volume à l’aide d’un curseur.

Indice :

from kivy.uix.slider import Slider

volume_slider = Slider(min=0, max=100, value=50)
layout.add_widget(volume_slider)

Exercice 5 : Afficher un menu contextuel en fonction du contexte avec PyGTK

  • Créez un menu contextuel qui ne s’affiche que sur un widget spécifique lorsque vous faites un clic droit.

  • Affichez uniquement les options « Copier » et « Coller » lorsqu’un champ de texte a le focus.

Indice :

if widget == self.text_entry:
    self.popup_menu.popup(None, None, None, None, event.button, event.time)

Ces exercices vous aideront à vous familiariser avec la création de menus contextuels dans chaque bibliothèque. Sélectionnez le prochain sujet à explorer.

Conclusion

Dans cet article, nous avons exploré différentes façons de créer des menus contextuels en Python à l’aide de cinq bibliothèques GUI principales : Tkinter, PyQt, wxPython, Kivy et PyGTK. Nous avons détaillé la création de menus simples à complexes, ainsi que les avantages et inconvénients de chaque bibliothèque.

Grâce aux exercices pratiques, vous avez approfondi votre compréhension de l’utilisation de chaque bibliothèque et avez acquis des compétences utiles pour le développement d’applications GUI. Utilisez ces connaissances pour créer des applications plus conviviales et fonctionnelles.

Nous espérons que cet article vous a été utile dans le développement de vos compétences en GUI avec Python.

Python
Python Exemples de Code menu contextuel tkinter Applications GUI Développement GUI PyQt Kivy PyGTK wxPython Python GUI
Sommaire