MENU
  1. ホーム
  2. Python
  3. Tutti i metodi per creare e visualizzare un menu a comparsa con Python

Tutti i metodi per creare e visualizzare un menu a comparsa con Python

Python

Imparare a creare un menu a comparsa con Python è estremamente utile nello sviluppo di applicazioni GUI. In questo articolo, esploreremo in dettaglio come creare menu a comparsa utilizzando le principali librerie, tra cui Tkinter, PyQt, wxPython, Kivy e PyGTK. Confronteremo le caratteristiche e i vantaggi di ciascuna libreria e forniremo esempi di codice concreti per imparare a crearli. Questo articolo è utile per sviluppatori Python di tutti i livelli, dai principianti agli esperti.

Indice

Creare un menu a comparsa con Tkinter

Tkinter è una libreria GUI standard di Python, che permette di creare facilmente un menu a comparsa. Qui sotto spiegheremo i passaggi per creare un menu a comparsa di base.

Creare un menu a comparsa di base

Cominceremo mostrando un esempio di codice per creare un semplice menu a comparsa.

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("Esempio di menu a comparsa con Tkinter")

# Creazione del menu a comparsa
popup_menu = Menu(root, tearoff=0)
popup_menu.add_command(label="Opzione 1", command=lambda: print("Opzione 1 selezionata"))
popup_menu.add_command(label="Opzione 2", command=lambda: print("Opzione 2 selezionata"))
popup_menu.add_separator()
popup_menu.add_command(label="Esci", command=root.quit)

# Mostra il menu a comparsa con il tasto destro
root.bind("<Button-3>", show_popup)

root.mainloop()

Descrizione del codice

In questa sezione spiegheremo in dettaglio ogni parte del codice sopra riportato.

Importazione dei moduli necessari

Importiamo il modulo tkinter e il modulo Menu.

import tkinter as tk
from tkinter import Menu

Definizione della funzione per visualizzare il menu a comparsa

Definiamo la funzione show_popup che intercetta l’evento del click con il tasto destro del mouse e visualizza il menu a comparsa.

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

Impostazione della finestra principale

Creiamo la finestra principale e impostiamo il suo titolo.

root = tk.Tk()
root.title("Esempio di menu a comparsa con Tkinter")

Creazione del menu a comparsa

Creiamo il menu a comparsa e aggiungiamo le voci di menu.

popup_menu = Menu(root, tearoff=0)
popup_menu.add_command(label="Opzione 1", command=lambda: print("Opzione 1 selezionata"))
popup_menu.add_command(label="Opzione 2", command=lambda: print("Opzione 2 selezionata"))
popup_menu.add_separator()
popup_menu.add_command(label="Esci", command=root.quit)

Binding dell’evento

Associamo l’evento del click destro del mouse alla visualizzazione del menu a comparsa.

root.bind("<Button-3>", show_popup)

Seguendo questi passaggi, è possibile creare un menu a comparsa di base con Tkinter. Passiamo ora al prossimo argomento.

Creare un menu a comparsa con PyQt

PyQt è una libreria GUI molto potente per Python. In questa sezione esploreremo come creare un menu a comparsa utilizzando PyQt.

Creare un menu a comparsa di base

Di seguito viene mostrato un esempio di codice di base per creare un menu a comparsa con PyQt.

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

class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Esempio di menu a comparsa con PyQt")
        self.setGeometry(100, 100, 600, 400)

        # Aggiungiamo l'evento del click destro al finestra
        self.setContextMenuPolicy(Qt.CustomContextMenu)
        self.customContextMenuRequested.connect(self.show_popup)

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

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

        if action == option1:
            print("Opzione 1 selezionata")
        elif action == option2:
            print("Opzione 2 selezionata")
        elif action == exit_action:
            QApplication.quit()

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

Descrizione del codice

In questa sezione spiegheremo ogni parte del codice sopra riportato in dettaglio.

Importazione dei moduli necessari

Importiamo le classi necessarie da PyQt5.QtWidgets.

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

Impostazione della finestra principale

Creiamo la finestra principale estendendo la classe QMainWindow, impostando il titolo e le dimensioni della finestra.

class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Esempio di menu a comparsa con PyQt")
        self.setGeometry(100, 100, 600, 400)

Impostazione dell’evento di click destro

Aggiungiamo un evento per il click destro nella finestra, che farà apparire il menu a comparsa quando si preme con il tasto destro.

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

Creazione e visualizzazione del menu a comparsa

Creiamo il menu a comparsa, aggiungiamo le voci di menu, e gestiamo le azioni in base alla selezione dell’utente.

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

        file_menu = popup_menu.addMenu("File")
        file_menu.addAction("Nuovo")
        file_menu.addAction("Apri")
        file_menu.addAction("Salva")

        edit_menu = popup_menu.addMenu("Modifica")
        edit_menu.addAction("Annulla")
        edit_menu.addAction("Ripristina")

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

        popup_menu.exec_(self.mapToGlobal(position))

Seguendo questi passaggi, è possibile creare un menu a comparsa di base con PyQt. Passiamo ora al prossimo argomento.

Creare un menu a comparsa con wxPython

wxPython è una libreria GUI cross-platform per Python. Qui spiegheremo come creare un menu a comparsa con wxPython.

Creare un menu a comparsa di base

Di seguito viene mostrato un esempio di codice di base per creare un menu a comparsa con wxPython.

import wx

class MyFrame(wx.Frame):
    def __init__(self):
        super().__init__(parent=None, title='Esempio di menu a comparsa wxPython', size=(600, 400))
        self.panel = wx.Panel(self)

        # Binding dell'evento click destro
        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, 'Opzione 1')
        option2 = popup_menu.Append(wx.ID_ANY, 'Opzione 2')
        popup_menu.AppendSeparator()
        exit_option = popup_menu.Append(wx.ID_EXIT, 'Esci')

        # Binding dell'evento handler
        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('Opzione 1 selezionata')

    def on_option2(self, event):
        print('Opzione 2 selezionata')

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

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

Descrizione del codice

In questa sezione spiegheremo ogni parte del codice sopra riportato in dettaglio.

Importazione dei moduli necessari

Importiamo il modulo wx necessario per utilizzare wxPython.

import wx

Impostazione della finestra principale

Creiamo la finestra principale estendendo la classe wx.Frame, impostando il titolo e le dimensioni della finestra.

class MyFrame(wx.Frame):
    def __init__(self):
        super().__init__(parent=None, title='Esempio di menu a comparsa wxPython', size=(600, 400))
        self.panel = wx.Panel(self)

Binding dell’evento click destro

Associa l’evento click destro alla visualizzazione del menu a comparsa.

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

Creazione e visualizzazione del menu a comparsa

Creiamo il menu a comparsa e aggiungiamo le voci di menu. Associa un handler per ogni voce del menu per eseguire l’azione corrispondente.

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

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

        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()

Definizione degli handler per gli eventi

Definiamo gli handler per ogni voce del menu in modo che venga eseguita l’azione corrispondente quando l’utente seleziona una voce.

    def on_option1(self, event):
        print('Opzione 1 selezionata')

    def on_option2(self, event):
        print('Opzione 2 selezionata')

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

Seguendo questi passaggi, è possibile creare un menu a comparsa di base con wxPython. Passiamo ora al prossimo argomento.

Creare un menu a comparsa con Kivy

Kivy è una libreria open-source cross-platform per la creazione di applicazioni GUI in Python. Qui esploreremo come creare un menu a comparsa con Kivy.

Creare un menu a comparsa di base

Di seguito viene mostrato un esempio di codice per creare un menu a comparsa di base con 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 a Comparsa'
        self.size_hint = (0.5, 0.5)

        layout = BoxLayout(orientation='vertical')
        btn1 = Button(text='Opzione 1')
        btn1.bind(on_press=self.option1)
        btn2 = Button(text='Opzione 2')
        btn2.bind(on_press=self.option2)
        close_btn = Button(text='Chiudi')
        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('Opzione 1 selezionata')
        self.dismiss()

    def option2(self, instance):
        print('Opzione 2 selezionata')
        self.dismiss()

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

        btn = Button(text='Mostra Menu a Comparsa')
        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()

Descrizione del codice

In questa sezione spiegheremo ogni parte del codice sopra riportato in dettaglio.

Importazione dei moduli necessari

Importiamo le classi principali dei widget di 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

Definizione della classe di pop-up

Creiamo una finestra pop-up personalizzata estendendo la classe Popup e impostando il titolo e le dimensioni.

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

Creazione del menu a comparsa

Posizioniamo i pulsanti nel layout e associamo la funzione di callback per ogni pulsante.

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

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

        self.add_widget(layout)

Gestione degli eventi di opzione

Definiamo le funzioni di callback che eseguono un’azione ogni volta che un’opzione viene selezionata.

    def option1(self, instance):
        print('Opzione 1 selezionata')
        self.dismiss()

    def option2(self, instance):
        print('Opzione 2 selezionata')
        self.dismiss()

Definizione della classe principale dell’applicazione

Definiamo la classe principale dell’applicazione che estende App di Kivy.

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

Seguendo questi passaggi, è possibile creare un menu a comparsa di base con Kivy. Passiamo ora al prossimo argomento.

Creare un menu a comparsa con PyGTK

PyGTK è una libreria che permette di utilizzare GTK con Python, ed è adatta per lo sviluppo di applicazioni GUI cross-platform. Qui esploreremo come creare un menu a comparsa con PyGTK.

Creare un menu a comparsa di base

Di seguito viene mostrato un esempio di codice di base per creare un menu a comparsa con 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="Esempio di menu a comparsa con PyGTK")
        self.set_default_size(600, 400)
        self.connect("destroy", Gtk.main_quit)

        # Creazione del pulsante e aggiunta alla finestra
        button = Gtk.Button(label="Clicca con il tasto destro per il menu")
        button.connect("button-press-event", self.on_button_press)
        self.add(button)

        # Creazione del menu a comparsa
        self.popup_menu = Gtk.Menu()
        option1 = Gtk.MenuItem(label="Opzione 1")
        option1.connect("activate", self.on_option1)
        self.popup_menu.append(option1)

        option2 = Gtk.MenuItem(label="Opzione 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="Esci")
        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 destro
            self.popup_menu.popup(None, None, None, None, event.button, event.time)

    def on_option1(self, widget):
        print("Opzione 1 selezionata")

    def on_option2(self, widget):
        print("Opzione 2 selezionata")

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

Descrizione del codice

In questa sezione spiegheremo ogni parte del codice sopra riportato in dettaglio.

Importazione dei moduli necessari

Importiamo i moduli gi e Gtk.

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

Impostazione della finestra principale

Creiamo la finestra principale estendendo la classe Gtk.Window, impostando il titolo e le dimensioni.

class MyWindow(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self, title="Esempio di menu a comparsa con PyGTK")
        self.set_default_size(600, 400)
        self.connect("destroy", Gtk.main_quit)

Creazione del pulsante e binding dell’evento

Aggiungiamo un pulsante alla finestra e associamo l’evento del click destro per aprire il menu a comparsa.

        button = Gtk.Button(label="Clicca con il tasto destro per il menu")
        button.connect("button-press-event", self.on_button_press)
        self.add(button)

Creazione del menu a comparsa

Creiamo il menu a comparsa e aggiungiamo gli elementi del menu, associando un evento per ciascun elemento.

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

        option2 = Gtk.MenuItem(label="Opzione 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="Esci")
        exit_option.connect("activate", Gtk.main_quit)
        self.popup_menu.append(exit_option)

        self.popup_menu.show_all()

Definizione degli handler per gli eventi

Definiamo gli handler per ogni voce del menu per eseguire le azioni corrispondenti.

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

    def on_option1(self, widget):
        print("Opzione 1 selezionata")

    def on_option2(self, widget):
        print("Opzione 2 selezionata")

Seguendo questi passaggi, è possibile creare un menu a comparsa di base con PyGTK. Passiamo ora al prossimo argomento.

Confronto tra le librerie

In questa sezione, confronteremo le caratteristiche, i vantaggi e gli svantaggi delle cinque principali librerie Python per GUI (Tkinter, PyQt, wxPython, Kivy, PyGTK).

Tkinter

Caratteristiche

  • Parte della libreria standard di Python, nessuna installazione aggiuntiva necessaria
  • Semplice e leggero
  • Adatto per creare applicazioni GUI di base

Vantaggi

  • Facile da imparare, ideale per i principianti
  • Documentazione ufficiale completa

Svantaggi

  • Non adatto per applicazioni GUI complesse
  • Difficile creare design moderni

PyQt

Caratteristiche

  • Consente l’uso della libreria Qt in Python
  • Permette di creare applicazioni GUI avanzate
  • Supporto cross-platform

Vantaggi

  • Molti widget e funzionalità
  • Design moderno e raffinato

Svantaggi

  • Licenza commerciale necessaria per l’uso commerciale
  • Alto costo di apprendimento

wxPython

Caratteristiche

  • Consente l’uso della libreria wxWidgets in Python
  • Offre un aspetto e un comportamento nativi

Vantaggi

  • Interfaccia utente nativa
  • Funzionalità avanzate e personalizzazione flessibile

Svantaggi

  • Configurazione complessa rispetto ad altre librerie
  • Documentazione dispersa

Kivy

Caratteristiche

  • Ottimo per lo sviluppo di applicazioni cross-platform
  • Supporta l’interazione touch

Vantaggi

  • Facilita lo sviluppo di applicazioni mobili
  • Open-source e gratuito

Svantaggi

  • Alto costo di apprendimento
  • Non sempre adatto per applicazioni desktop

PyGTK

Caratteristiche

  • Consente l’uso della libreria GTK in Python
  • Supporto cross-platform

Vantaggi

  • Supporto per numerosi widget e temi
  • Alta compatibilità con l’ambiente desktop Gnome

Svantaggi

  • Configurazione complessa rispetto ad altre librerie
  • Supporto incompleto su Windows

Attraverso questo confronto, è possibile scegliere la libreria più adatta al proprio progetto. Passiamo ora al prossimo argomento.

Esempi avanzati: Creare menu complessi

In questa sezione, esploreremo come creare un menu a comparsa complesso con più voci e sottomenu utilizzando ciascuna delle librerie.

Creare un menu complesso con 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("Esempio di menu complesso con Tkinter")

# Creazione del menu a comparsa
popup_menu = Menu(root, tearoff=0)
file_menu = Menu(popup_menu, tearoff=0)
file_menu.add_command(label="Nuovo")
file_menu.add_command(label="Apri")
file_menu.add_command(label="Salva")
popup_menu.add_cascade(label="File", menu=file_menu)

edit_menu = Menu(popup_menu, tearoff=0)
edit_menu.add_command(label="Annulla")
edit_menu.add_command(label="Ripristina")
popup_menu.add_cascade(label="Modifica", menu=edit_menu)

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

# Mostra il menu a comparsa con il tasto destro
root.bind("<Button-3>", show_popup)

root.mainloop()

Creare un menu complesso con PyQt

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

class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Esempio di menu complesso con PyQt")
        self.setGeometry(100, 100, 600, 400)

        # Aggiungiamo l'evento del click destro al finestra
        self.setContextMenuPolicy(Qt.CustomContextMenu)
        self.customContextMenuRequested.connect(self.show_popup)

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

        file_menu = popup_menu.addMenu("File")
        file_menu.addAction("Nuovo")
        file_menu.addAction("Apri")
        file_menu.addAction("Salva")

        edit_menu = popup_menu.addMenu("Modifica")
        edit_menu.addAction("Annulla")
        edit_menu.addAction("Ripristina")

        popup_menu.addSeparator()
        exit_action = popup_menu.addAction("Esci")
        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_())

Creare un menu complesso con wxPython

import wx

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

        # Binding dell'evento click destro
        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, 'Nuovo')
        file_menu.Append(wx.ID_ANY, 'Apri')
        file_menu.Append(wx.ID_ANY, 'Salva')
        popup_menu.AppendSubMenu(file_menu, 'File')

        edit_menu = wx.Menu()
        edit_menu.Append(wx.ID_ANY, 'Annulla')
        edit_menu.Append(wx.ID_ANY, 'Ripristina')
        popup_menu.AppendSubMenu(edit_menu, 'Modifica')

        popup_menu.AppendSeparator()
        exit_option = popup_menu.Append(wx.ID_EXIT, 'Esci')
        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()

Creare un menu complesso con 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 a Comparsa'
        self.size_hint = (0.5, 0.5)

        layout = BoxLayout(orientation='vertical')

        file_btn = Button(text='File')
        file_btn.bind(on_press=self.show_file_menu)
        edit_btn = Button(text='Modifica')
        edit_btn.bind(on_press=self.show_edit_menu)
        close_btn = Button(text='Chiudi')
        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='Nuovo'))
        file_menu.add_widget(Button(text='Apri'))
        file_menu.add_widget(Button(text='Salva'))
        self.add_widget(file_menu)

    def show_edit_menu(self, instance):
        edit_menu = BoxLayout(orientation='vertical')
        edit_menu.add_widget(Button(text='Annulla'))
        edit_menu.add_widget(Button(text='Ripristina'))
        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='Mostra Menu a Comparsa')
        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()

Creare un menu complesso con 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="Esempio di menu complesso con PyGTK")
        self.set_default_size(600, 400)
        self.connect("destroy", Gtk.main_quit)

        # Creazione del pulsante e aggiunta alla finestra
        button = Gtk.Button(label="Clicca con il tasto destro per il menu")
        button.connect("button-press-event", self.on_button_press)
        self.add(button)

        # Creazione del menu a comparsa
        self.popup_menu = Gtk.Menu()

        file_menu = Gtk.Menu()
        file_menu_item = Gtk.MenuItem(label="File")
        file_menu_item.set_submenu(file_menu)
        new_item = Gtk.MenuItem(label="Nuovo")
        file_menu.append(new_item)
        open_item = Gtk.MenuItem(label="Apri")
        file_menu.append(open_item)
        save_item = Gtk.MenuItem(label="Salva")
        file_menu.append(save_item)

        edit_menu = Gtk.Menu()
        edit_menu_item = Gtk.MenuItem(label="Modifica")
        edit_menu_item.set_submenu(edit_menu)
        undo_item = Gtk.MenuItem(label="Annulla")
        edit_menu.append(undo_item)
        redo_item = Gtk.MenuItem(label="Ripristina")
        edit_menu.append(redo_item)

        self.popup_menu.append(file_menu_item)
        self.popup_menu.append(edit_menu_item)
        separator = Gtk.SeparatorMenuItem()
        self.popup_menu.append(separator)
        exit_option = Gtk.MenuItem(label="Esci")
        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 destro
            self.popup_menu.popup(None, None, None, None, event.button, event.time)

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

Seguendo questi passaggi, è possibile creare un menu a comparsa complesso con ciascuna delle librerie. Passiamo ora al prossimo argomento.

Esercizi: Crea il tuo menu a comparsa

In questa sezione, offriamo alcuni esercizi per permettere ai lettori di mettere in pratica la creazione di menu a comparsa utilizzando le librerie precedentemente trattate. Usa le conoscenze acquisite per completare i seguenti esercizi.

Esercizio 1: Crea un menu a comparsa personalizzato con Tkinter

  • Aggiungi voci di menu come “Apri file”, “Salva file”, “Chiudi”
  • Implementa una funzionalità per visualizzare una finestra di dialogo quando si seleziona l’opzione “Apri file”

Suggerimento:

from tkinter import filedialog

def open_file():
    filedialog.askopenfilename()

Esercizio 2: Crea un menu a comparsa con icone in PyQt

  • Aggiungi icone a ciascuna voce del menu
  • Imposta icone per le voci “Nuovo”, “Apri”, “Salva”, “Esci” e implementa le azioni corrispondenti

Suggerimento:

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

Esercizio 3: Aggiungi voci dinamiche in wxPython

  • Aggiungi una nuova voce di menu ogni volta che fai clic con il tasto destro
  • Aggiungi una voce di menu “Aggiungi opzione” che incrementa un contatore e visualizza “Opzione X selezionata”

Suggerimento:

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

Esercizio 4: Aggiungi widget personalizzati al menu in Kivy

  • Aggiungi widget personalizzati come slider o campi di testo al menu a comparsa
  • Aggiungi l’opzione “Regola volume” per permettere all’utente di regolare il volume tramite uno slider

Suggerimento:

from kivy.uix.slider import Slider

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

Esercizio 5: Mostra un menu contestuale in PyGTK

  • Visualizza un menu a comparsa solo quando si fa clic con il tasto destro su uno specifico widget
  • Mostra solo le opzioni “Copia” e “Incolla” quando il focus è su un campo di testo

Suggerimento:

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

Completando questi esercizi, avrai l’opportunità di esercitarti nella creazione di menu a comparsa con diverse librerie Python, migliorando le tue competenze nello sviluppo di interfacce utente. Passiamo ora all’ultimo argomento.

Conclusioni

In questo articolo, abbiamo esplorato diversi modi per creare menu a comparsa con Python. Abbiamo visto come utilizzare le principali librerie GUI come Tkinter, PyQt, wxPython, Kivy e PyGTK per creare menu semplici e complessi. Inoltre, abbiamo confrontato le caratteristiche, i vantaggi e gli svantaggi di ciascuna libreria, fornendo indicazioni su come scegliere quella più adatta al proprio progetto.

Infine, attraverso esercizi pratici, abbiamo approfondito l’uso delle librerie, aiutandoti a sviluppare le competenze necessarie per creare applicazioni GUI più funzionali e user-friendly. Speriamo che questo articolo ti sia stato utile nello sviluppo delle tue competenze di programmazione GUI con Python.

Python
Applicazioni GUI Esempi di Codice Kivy Menu Popup PyGTK PyQt Python Python GUI Sviluppo GUI tkinter wxPython
Indice