Une application Gtk avec un GMenu de base et des SimpleActions
from gi.repository import Gtk
from gi.repository import Gio
import sys
class MyWindow(Gtk.ApplicationWindow):
def __init__(self, app):
Gtk.Window.__init__(self, title="GMenu Example", application=app)
class MyApplication(Gtk.Application):
def __init__(self):
Gtk.Application.__init__(self)
def do_activate(self):
win = MyWindow(self)
win.show_all()
def do_startup(self):
# start the application
Gtk.Application.do_startup(self)
# create a menu
menu = Gio.Menu()
# append to the menu three options
menu.append("New", "app.new")
menu.append("About", "app.about")
menu.append("Quit", "app.quit")
# set the menu as menu of the application
self.set_app_menu(menu)
# create an action for the option "new" of the menu
new_action = Gio.SimpleAction.new("new", None)
# connect it to the callback function new_cb
new_action.connect("activate", self.new_cb)
# add the action to the application
self.add_action(new_action)
# option "about"
about_action = Gio.SimpleAction.new("about", None)
about_action.connect("activate", self.about_cb)
self.add_action(about_action)
# option "quit"
quit_action = Gio.SimpleAction.new("quit", None)
quit_action.connect("activate", self.quit_cb)
self.add_action(quit_action)
# callback function for "new"
def new_cb(self, action, parameter):
print("This does nothing. It is only a demonstration.")
# callback function for "about"
def about_cb(self, action, parameter):
print("No AboutDialog for you. This is only a demonstration.")
# callback function for "quit"
def quit_cb(self, action, parameter):
print("You have quit.")
self.quit()
app = MyApplication()
exit_status = app.run(sys.argv)
sys.exit(exit_status)
In line 33 the signal "activate" from the action new_action (not the menu!) is connected to the callback function new_cb() using action.connect(signal, callback function). See for a more detailed explanation.
Méthodes utiles pour GSimpleAction :
Pour créer une nouvelle action qui est stateless, c-à-d. une action qui ne retient ni ne dépend d'un état définit par l'action elle-même, utilisez
action = Gio.SimpleAction.new(« nom », parameter_type)
où « nom » est le nom de l'action et parameter_type est le type de paramètre que l'action reçoit quand elle est activée. Ce peut être None, ou GLib.VariantType.new('s') si le paramètre est du type str, ou au lieu de 's', un caractère tel que décrit ici.
action = Gio.SimpleAction.new_stateful(« nom », parameter_type, initial_state)
where initial_state is defined as a GVariant - for instance Glib.Variant.new_string('start'); for a list of possibilities see here.
La méthode set_enabled(True) définit l'action à enabled ; une action doit être en position enabled pour pouvoir être activée ou pour voir son état modifié par des appels extérieurs. La fonction ne peut être appelée que par l'implémenteur de l'action. Les utilisateurs de l'action ne doivent pas tenter de modifier son drapeau enabled.
La fonction set_state(state), où state est une GVariant, définit l'état de l'action en mettant à jour la propriété « state » à la valeur donnée. Elle ne peut être appelée que par l'implémenteur de l'action ; par contre, les utilisateurs peuvent appeler change_state(state) (où state est une GVariant) pour demander le changement d'état.
Méthodes utiles pour un GMenu :
Pour insérer un élément dans le menu à la position, utilisez la méthode insert(position, label, detailed_action), où label est l'étiquette qui s'affiche dans le menu et detailed_action est une chaîne de caractères composée du nom de l'action à laquelle vous ajoutez le préfixe app.. Pour de plus amples détails, consultez .
Pour joindre ou ajouter un élément dans le menu, utilisez respectivement les méthodes append(label, detailed_action) et prepend(label, detailed_action).
Une autre méthode pour ajouter des éléments au menu est de les créer comme des éléments GMenuItem et d'utiliser l'une des fonctions insert_item(position, item), append_item(item), ou prepend_item(item) ; par exemple :
about = Gio.MenuItem.new("About", "app.about")
menu.append_item(about)
Nous pouvons aussi ajouter une sous-section entière dans un menu avec insert_section(position, label, section), append_section(label, section), ou prepend_section(label, section), où label est le titre de la sous-section.
Pour ajouter un sous-menu qui va s'étendre et se contracter, utilisez l'une des méthodes insert_submenu(position, label, section), append_submenu(label, section), ou bien prepend_submenu(label, section), où label est le titre du sous-menu.
To remove an item from the menu, use remove(position).
Pour définir une étiquette pour le menu, utilisez la méthode set_label(label).
Dans cet exemple, les éléments suivants sont utilisés :
GMenu
GSimpleAction
GVariantType
GVariant