bancaldo™

torna all’indice degli appunti

CheckButton

Il widget Gtk.CheckButton è un widget composto da un toggle button con a fianco una Label.
Quindi, come il Gtk.CheckButton, ha la particolarità di rimanere nello stato in cui è, fino a che
non viene ricliccato.
Quando lo stato del Gtk.CheckButton cambia, viene emesso il segnale “toggled”.
Lo stato del Gtk.CheckButton, si ottiene con il metodo get_active():

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

 
>>> cbutton = Gtk.CheckButton()
>>> cbutton
<Gtk.CheckButton object at 0xb4b9de3c (GtkCheckButton 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):

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

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

 
>>> cbutton.set_label("CheckButton 1")
>>> cbutton.get_label()
'CheckButton 1'

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

>>> button1 = Gtk.CheckButton.new_with_label(label="Button 1")
>>> button2 = Gtk.CheckButton.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 CheckButton è “toggled”, ereditato dal widget
Gtk.ToggleButton. Viene emesso quando un CheckButton, che precedentemente non era selezionato,
viene cliccato (clicked()).
Per conoscere lo stato di un CheckButton, 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.CheckButton:

new()

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

new_with_label(label)

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

new_with_mnemonic(label)

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

 
>>> button2 = Gtk.CheckButton.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 CheckButton contenente gli mnemonic;

get_active()

Ritorna lo stato del checkbutton.

get_inconsistent()

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

set_active(is_active)

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

set_inconsistent(is_inconsistent)

Setta lo stato del checkbutton a inconsistent, se is_inconsistent è True.
Parametri:
is_inconsistent: il boolean che setta il CheckButton 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="CheckButton Demo")
        self.set_border_width(10)

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

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

    def on_button_toggled(self, button):
        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 CheckButton