PyGObject: Gio.SimpleAction
SimpleAction
Una Gio.SimpleAction, come indica il nome, è una semplice implementazione dell’interfaccia di
Gio.Action, quindi rappresenta il modo più semplice per creare una Action.
La principale interfaccia di una Action è che può essere attivata con Gio.Action.activate().
Tale metodo causa l’emissione del segnale “activate”.
Una Action può opzionalmente avere uno stato, che può essere settato utilizzando il metodo
Gio.Action.change_state().
La classe Gio.Action è responsabile della memorizzazione del nome dell’azione, del tipo di
parametro, dello stato opzionale e dell’emissione del segnale appropriato quando lo stato cambia.
L’utilizzo delle Actions è un modo per associare un particolare attività ad un nome, tale attività
verrà eseguita dall’applicazione o da un widget, semplicemente facendo riferimento a tale nome.
In questo modo si possono tenere separate la logica dell’azione, dalla UI.
Un tipico esempio di utilizzo di Actions è dato dai Menu.
Le properties principali sono quelle ereditate da Gio.Action:
Name | Type | Flags | Short Description |
---|---|---|---|
enabled | bool | r | Se la Action può essere attivata |
name | str | r | Il nome usato per invocare la Action |
parameter-type | GLib.VariantType | r | Il tipo di GLib.Variant passato al metodo activate() |
state | GLib.Variant | r | Lo stato in cui si trova la Action |
state-type | GLib.VariantType | r | Il tipo di stato tenuto dalla Action |
Segnali
I segnale relativi al Gio.SimpleAction sono:
Name | Short Description |
---|---|
activate | Indica che la Action è stata appena attivata |
change-state | Indica che la Action ha appena ricevuto una richiesta di cambiare il proprio stato |
Il segnale activate si aspetta due parametri, simple_action” e “parameter”.
Basterà connettere la action al segnale “activate” con un handler che tenga presente di questi
parametri:
>>> import gi ... gi.require_version('Gtk', '3.0') ... from gi.repository import Gtk ... from gi.repository import Gio >>> action = Gio.SimpleAction.new(name='Bancaldo', parameter_type=None) action.connect("activate", lambda a, p: print("INFO: action '%s' activated!" % a.get_name())) 8 >>> action.activate() INFO: action 'Bancaldo' activated!
Il segnale change-state si aspetta due parametri, simple_action” e “value”.
Basterà connettere la action al segnale “activate” con un handler che tenga presente di questi
parametri:
>>> variant = GLib.Variant.new_boolean(True) >>> stateful_action = Gio.SimpleAction.new_stateful(name="BancaldoStateful", ... parameter_type=None, ... state=variant) >>> stateful_action.connect("change-state", lambda a, v: print("INFO: '%s' state changed to %s!" % (a.get_name(), v))) 10 >>> stateful_action.change_state(GLib.Variant.new_boolean(True)) INFO: 'BancaldoStateful' state changed to true! >>> stateful_action.change_state(GLib.Variant.new_boolean(False)) INFO: 'BancaldoStateful' state changed to false!
Metodi
Oltre ai soliti getter e setter relativi alle properties dell’oggetto Gtk.SimpleAction,
i principali metodi sono:
new(name, parameter_type)
Crea una nuova Action stateless.
Per creare una Action che abbia uno stato, utilizzare il metodo Gio.SimpleAction.new_stateful().
>>> action = Gio.SimpleAction.new(name='Bancaldo', parameter_type=None) >>> action.get_state() >>>
Parametri:
name: il nome della Action;
parameter_type: il tipo di parametro (GLib.VariantType o None) che
sarà passato agli handlers del segnale “activate” dell’oggetto Gio.SimpleAction, o None
per none passare nessun parametro;
new_stateful(name, parameter_type, state)
Crea una nuova stateful Action.
Ovviamente tutti i futuri valori di “state”, devono essere dello stesso GLib.Variant definito
in fase di costruzione.
>>> from gi.repository import GLib >>> variant = GLib.Variant.new_boolean(True) >>> stateful_action = Gio.SimpleAction.new_stateful(name="BancaldoStateful", ... parameter_type=None, ... state=variant) >>> stateful_action.get_state() GLib.Variant('b', true)
Parametri:
name: il nome della Action;
parameter_type: il tipo di parametro (GLib.VariantType o None) che
sarà passato agli handlers del segnale “activate” dell’oggetto Gio.SimpleAction, o None
per none passare nessun parametro;
state: lo stato iniziale (GLib.Variant) della Action;
set_enabled(enabled)
Abilita o disabilita una Action. Ovviamente una Action deve essere abilitata per poter essere
attivata o cambiare il proprio stato dall’esterno.
Parametri:
enabled: il boolean che abilita/disabilita la Action;
set_state(value)
Setta lo stato della Action. Questo metodo aggiorna direttamente la property “state”.
Non dovrebbe essere chiamato dall’utente per modificare lo stato della Action; è
preferibile utilizzare il metodo Gio.Action.change_state().
>>> new_state = GLib.Variant.new_boolean(False) >>> stateful_action.set_state(new_state) >>> stateful_action.get_state() GLib.Variant('b', false)
Parametri:
value: il nuovo GLib.Variant con cui modificheremo lo stato;
set_state_hint(state_hint)
Setta l’hint (suggerimento) dello stato, per la Action.
Parametri:
state_hint: il GLib.Variant (o None) che rappresenta lo state hint
della Action.
>>> state_hint = GLib.Variant.new_string("Bancaldo's Boolean") >>> stateful_action.set_state_hint(state_hint) >>> stateful_action.get_state_hint() GLib.Variant('s', "Bancaldo's Boolean")
Ecco un codice di esempio:
#!/usr/bin/env python3 import gi gi.require_version('Gtk', '3.0') from gi.repository import Gtk from gi.repository import Gio class AppWindow(Gtk.ApplicationWindow): def __init__(self): super().__init__() self.set_default_size(200, 100) # actions act_file = Gio.SimpleAction.new(name='FileNew', parameter_type=None) act_quit = Gio.SimpleAction.new(name='FileQuit', parameter_type=None) act_info = Gio.SimpleAction.new(name='AboutInfo', parameter_type=None) self.add_action(act_file) self.add_action(act_quit) self.add_action(act_info) # model menu menu_model = Gio.Menu.new() # 1st menu menu_file = Gio.Menu.new() file_new = Gio.MenuItem.new('New', 'win.FileNew') file_quit = Gio.MenuItem.new('Quit', 'win.FileQuit') menu_file.append_item(file_new) menu_file.append_item(file_quit) # 2nd menu menu_about = Gio.Menu.new() about_info = Gio.MenuItem.new('Info', 'win.AboutInfo') menu_about.append_item(about_info) menu_model.append_submenu('File', menu_file) menu_model.append_submenu('About', menu_about) menu_bar = Gtk.MenuBar.new_from_model(menu_model) # layout layout = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) layout.pack_start(menu_bar, False, False, 0) self.add(layout) # bindings act_file.connect('activate', self.on_menu) act_quit.connect('activate', self.on_quit) act_info.connect('activate', self.on_menu) self.connect('destroy', Gtk.main_quit) def on_menu(self, action, value): print('INFO: menu <%s>' % action.props.name) @staticmethod def on_quit(action, param): Gtk.main_quit() if __name__ == '__main__': win = AppWindow() win.connect("destroy", Gtk.main_quit) win.show_all() Gtk.main()
link di riferimento:
torna all’indice degli appunti
Gtk3 Gio.Action
GLib.Variant
GLib.VariantType
Commenti recenti