bancaldo™

torna all’indice appunti

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:

Segnali

I segnale relativi al Gio.SimpleAction sono:

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