bancaldo™

torna all’indice appunti

ToggleButton

Il widget Gtk.ToggleButton è molto simile al Gtk.Button, ma ha la particolarità di rimanere nello
stato in cui è, fino a che non viene ricliccato. Ovvero al click, rimane premuto fino a che non
viene ripremuto.
Quando lo stato del Gtk.ToggleButton cambia, viene emesso il segnale “toggled”.
Come per il Gtk.RadioButton è possibile ottenere lo stato del Gtk.ToggleButton, con il metodo
get_active():

Per creare un ToggleButton si utilizza il costruttore Gtk.ToggleButton(*args, **kwargs),
dove gli argomenti più significativi sono “”label” e “image”.
label: è una stringa di testo visualizzata nel ToggleButton
image: un oggetto Gtk.Image che rappresenta l’immagine sul
ToggleButton.

 
>>> tbutton = Gtk.ToggleButton()
>>> tbutton
<Gtk.ToggleButton object at 0xb4b9de3c (GtkToggleButton at 0x952b110)>

E’ possibile passare i parametri del widget in fase di costruzione, ma è possibile accedervi e
modificarli anche in seguito, utilizzando i metodi getter e setter get_property(property_name)
e set_property(property_name, property_value):

 
>>> tbutton.get_property("label")
>>> tbutton.set_property("label", "Button 1")
>>> tbutton.get_property("label")
'Button 1'

oppure con i metodi getter e setter specifici get_*property_name*() e
set_*property_name*(value):

 
>>> tbutton.set_label("ToggleButton 1")
>>> tbutton.get_label()
'ToggleButton 1'

Per creare un ToggleButton, esistono due metodi “scorciatoia”:
new_with_label(label): dove “label” è il testo del togglebutton;
new_with_mnemonic(label): dove “label” è il testo con l’underscore davanti al
carattere “mnemonic”;

>>> button1 = Gtk.ToggleButton.new_with_label(label="Button 1")
>>> button2 = Gtk.ToggleButton.new_with_mnemonic(label="B_utton 2")

Image

Per inserire un’immagine all’interno del widget, creiamo prima un oggetto Gtk.Image e lo settiamo
nel widget che lo conterrà. Per recuperarla, si userà il getter specifico get_image()

 
>>> image = Gtk.Image.new_from_file("OK24.png")
>>> button1.set_image(image)
>>> button1.get_image() == image
True

Segnali

Per connettere un widget ad una callback, in modo che, quando viene emesso un segnale specifico,
quest’ultima venga invocata, si utilizza il metodo connect(signal, callback).
Il segnale che fondamentalmente interessa il ToggleButton è “toggled” e viene emesso quando un
ToggleButton, che precedentemente non era selezionato, viene cliccato (clicked()).
Per conoscere lo stato di un ToggleButton, si utilizza il metodo get_active()

 
>>> def on_button_toggled(button):
...     if button.get_active():
...         state = "on"
...     else:
...         state = "off"
...     print("{} was turned {}".format(button.get_label(), state))
...     
>>> button1.connect("toggled", on_button_toggled)
60
>>> button1.clicked()
Button 1 was turned on
>>> button1.get_active()
True
>>> button1.clicked()
Button 1 was turned off
>>> button1.get_active()
False
>>> button2.get_active()
False

Metodi

Di seguito i metodi utilizzabili con il widget Gtk.ToggleButton:

new()

Metodo costruttore che crea un nuovo Gtk.ToggleButton. I parametri possono essere settati
successivamente con i metodi setter dedicati (ad es. set_label(label);

new_with_label(label)

Crea un nuovo Gtk.ToggleButton con una label di testo associata.
Parametri:
label: il testo della label del ToggleButton;

new_with_mnemonic(label)

Crea un nuovo Gtk.ToggleButton con una label di testo dove un underscore anticipa il carattere
che verrà utilizzato come “mnemonic”.

 
>>> button2 = Gtk.ToggleButton.new_with_mnemonic(label="B_utton 2")

dove “u” sarà il mnemonic character per la scorciatoia da tastiera (ALT+u).
Parametri:
label: il testo del ToggleButton contenente gli mnemonic;

get_active()

Ritorna lo stato del togglebutton.

get_inconsistent()

ritorna True, se il togglebutton si trova nello stato inconsistent, ovvero quella
fase nè selezionato, nè deselezionato.

set_active(is_active)

Setta lo stato del togglebutton. Se is_active è True, il togglebutton verrà visualizzato come
selezionato. False ovviamente setterà il togglebutton come deselezionato.
Parametri:
is_active: il boolean che seleziona/deseleziona il ToggleButton;

set_inconsistent(is_inconsistent)

Setta lo stato del togglebutton a inconsistent, se is_inconsistent è True.
Parametri:
is_inconsistent: il boolean che setta il ToggleButton in uno stato
“inconsistent”, ovvero nè selezionato, nè deselezionato;

toggled()

Emette un segnale di tipo “toggled”.

clicked()

Emette un segnale di tipo “clicked”.

Di seguito un codice d’esempio:

import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk

class GWindow(Gtk.Window):
    def __init__(self):
        super().__init__(title="ToggleButton Demo")
        self.set_border_width(10)
        self.set_size(300, 100)

        hbox = Gtk.Box(spacing=6)
        self.add(hbox)

        button1 = Gtk.ToggleButton("Button 1")
        button2 = Gtk.ToggleButton("B_utton 2", use_underline=True)
        button2.set_active(True)
        # bindings
        button1.connect("toggled", self.on_button_toggled)
        button2.connect("toggled", self.on_button_toggled)
        # layout
        hbox.pack_start(button1, True, True, 0)
        hbox.pack_start(button2, True, True, 0)

    def on_button_toggled(self, button):
        button.set_inconsistent(False)
        if button.get_active():
            state = "on"
        else:
            state = "off"
        print("{} was turned {}".format(button.get_label(), state))


if __name__ == "__main__":
    win = GWindow()
    win.connect("destroy", Gtk.main_quit)
    win.show_all()
    Gtk.main()

link di riferimento:

torna all’indice degli appunti
Gtk3 ToggleButton