# GMenu (Python)

Tiffany Antopolski
tiffany.antopolski@gmail.com 2012
Marta Maria Casetti
mmcasetti@gmail.com 2012
Une implémentation simple de GMenu
Luc Rebert,
traduc@rebert.name 2011
Alain Lojewski,
allomervan@gmail.com 2011-2012
Luc Pionchon
pionchon.luc@gmail.com 2011
Bruno Brouard
annoa.b@gmail.com 2011-12
Luis Menina
liberforce@freeside.fr 2014

# GMenu

Une application Gtk avec un GMenu de base et des SimpleActions

# Code utilisé pour générer cet exemple

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)

# Méthodes utiles pour GSimpleAction et GMenu

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)`.

# Références API

Dans cet exemple, les éléments suivants sont utilisés :

GMenu

GSimpleAction

GVariantType

GVariant