# GMenu (Python)

Tiffany Antopolski
tiffany.antopolski@gmail.com 2012
Marta Maria Casetti
mmcasetti@gmail.com 2012
Una implementación sencilla de GMenu
Daniel Mustieles
daniel.mustieles@gmail.com 2011 - 2020
Nicolás Satragno
nsatragno@gmail.com 2012 - 2013
Jorge González
jorgegonz@svn.gnome.org 2011

# GMenu

Una GtkApplication con un GMenu sencillo y SimpleActions

# Código usado para generar este ejemplo

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étodos útiles para una «GSimpleAction» y un GMenu

En la línea 33, la señal `«activate»` de la acción `new_action` (no el menú) se conecta a la función de retorno de llamada `new_cb()` usando `action.connect(señal, función de retorno de llamada)`. Consulte la sección para obtener una explicación más detallada.

Métodos útiles para una «GSimpleAction»:

Para crear una acción nueva que no dependa del estado, es decir, una acción que no retenga o dependa de un estado dado a la acción en sí, use

action = Gio.SimpleAction.new("name", parameter_type)

donde `"name"` es el nombre de la acción y `parameter_type` es el tipo de parámetro que recibe la acción cuando se activa. Este puede ser `None`, o `GLib.VariantType.new('s')` si el parámetro es del tipo `str`, o en lugar de `'s'` un carácter como se describe aquí. Para crear una acción nueva con estado, use

action = Gio.SimpleAction.new_stateful("name", parameter_type, initial_state)

donde `initial_state` está definido como una GVariant: por ejemplo `Glib.Variant.new_string('start')`; para una lista de posibilidades consulte aquí.

`set_enabled(True)` configura la acción como habilitada; una acción debe habilitarse para poder activarse o para que llamantes exteriores cambien su estado. Sólo el que implementa la acción debe llamarlo. Los usuarios de la acción no deben intentar modificar su opción «enabled».

`set_state(estado)`, donde `estado` es una GVariant, establece el estado de la acción, actualizando la propiedad «state» a un valor dado. Sólo el que implementa la acción debe llamarlo; los usuarios de la acción, en cambio, deben llamar a `change_state(estado)` (donde `estado` es como se mencionó) para solicitar el cambio.

Métodos útiles para un GMenu:

Para insertar un elemento en el menú en una `posición`, use `insert(posición, etiqueta, acción_detallada)`, donde `etiqueta` es la etiqueta que aparecerá en el menú y `acción_detallada` es una cadena compuesta por el nombre de la acción a la que se la agrega el prefijo `app.`. Puede encontrar una discusión más detallada de esto en la .

Para agregar o anteponer un elemento en el menú use respectivamente `append(etiqueta, acción_detallada)` y `prepend(etiqueta, acción_detallada)`.

Otra manera de añadir elementos al menú es crearlos como `GMenuItem` y usar `insert_item(posición, elemento)`, `append_item(elemento)`, o `prepend_item(elemento)`; por lo que por ejemplo se podría tener:

about = Gio.MenuItem.new("About", "app.about") menu.append_item(about)

También se puede añadir una subsección completa a un menú usando `insert_section(posición, etiqueta, sección)`, `append_section(etiqueta, sección)`, o `prepend_section(etiqueta, sección)`, donde `etiqueta` es el título de la subsección.

Para añadir un submenú que se expanda y colapse, use `insert_submenu(posición, etiqueta, sección)`, `append_submenu(etiqueta, sección)`, o `prepend_submenu(etiqueta, sección)`, donde `etiqueta` es el título de la subsección.

Para eliminar un elemento del menú, use `remove(posición)`.

Para establecer una etiqueta para el menú, use `set_label(etiqueta)`.

# Referencias de la API

En este ejemplo se usa lo siguiente:

GMenu

GSimpleAction

GVariantType

GVariant