bancaldo™

torna all’indice degli appunti

RadioButton

Il widget Gtk.RadioButton eredita da Gtk.ToggleButton, ma ha la particolarità di lavorare in gruppo.
In un gruppo di più RadioButtons, solo un RadioButton può essere selezionato, deselezionando di
conseguenza gli altri. Viene generalmente collegato ad una callback che viene invocata quando lo
stesso widget viene premuto e viene di fatto emesso il segnale “toggled”.

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

 
>>> rbutton = Gtk.RadioButton()
>>> rbutton
<Gtk.RadioButton object at 0xb4b9de3c (GtkRadioButton 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):

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

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

 
>>> rbutton.set_label("RadioButton 1")
>>> rbutton.get_label()
'RadioButton 1'

La property principale, oltre a quelle ereditate dai vari widget, come ad esempio Gtk.ToggleButton
e Gtk.Button, sono:

Name	Type	Flags	Short Description
group	Gtk.RadioButton	w	il gruppo di radio button a cui appartiene questo widget

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 radiobutton è “toggled” e viene emesso quando un
radiobutton, che precedentemente non era selezionato, viene cliccato (clicked()).
Per conoscere lo stato di un radiobutton, 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 = Gtk.RadioButton.new_with_label_from_widget(None, "Button 1")
>>> button2 = Gtk.RadioButton.new_with_label_from_widget(button1, "Button 2")
>>> button1.connect("toggled", on_button_toggled)
60
>>> button2.connect("toggled", on_button_toggled)
61
>>> button1.toggled()
Button 1 was turned on
>>> button1.get_active()
True
>>> button2.get_active()
False
>>> button2.clicked()
Button 1 was turned off
Button 2 was turned on
>>> button1.clicked()
Button 2 was turned off
Button 1 was turned on

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

Metodi

Per creare un RadioButton, esistono due metodi “scorciatoia”, new_from_widget(radio_group_member)
e new_with_label_from_widget(radio_group_member, label):

“radio_group_member”: ovviamente è il widget già presente nel gruppo del quale vogliamo che il radiobutton faccia parte;
“label”: è il testo del radiobutton;
Ovviamente il primo elemento del gruppo, non avrà widget di riferimento, quindi il l’argomento “radio_group_member” sarà None.

>>> button1 = Gtk.RadioButton.new_with_label_from_widget(radio_group_member=None, label="Button 1")
>>> button2 = Gtk.RadioButton.new_from_widget(radio_group_member=button1)
>>> button1.get_group() == button2.get_group()
True

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

new(group)

Metodo costruttore che crea un nuovo Gtk.RadioButton.
Parametri:
group: un gruppo di radiobutton esistenti ([Gtk.RadioButton, ]),
o None, se stiamo crando un nuovo gruppo;

new_from_widget(radio_group_member)

Metodo costruttore che crea un nuovo Gtk.RadioButton, aggiungendolo allo stesso gruppo di
radio_group_member, che è un Gtk.RadioButton esistente.
Parametri:
radio_group_member: un Gtk.RadioButton esistente;

new_with_label(group, label)

Metodo costruttore che crea un nuovo Gtk.RadioButton con una label di testo associata.
Parametri:
group: un gruppo di radiobutton esistenti ([Gtk.RadioButton, ]),
o None, se stiamo crando un nuovo gruppo;
label: il testo visualizzato a fianco del radiobutton

new_with_label_from_widget(radio_group_member, label)

Metodo costruttore che crea un nuovo Gtk.RadioButton con una label di testo aggiungendolo allo
stesso gruppo a cui appartiene radio_group_member.
Parametri:
radio_group_member: un Gtk.RadioButton esistente;
label: il testo visualizzato a fianco del radiobutton;

new_with_mnemonic(group, label)

Metodo costruttore che crea un nuovo Gtk.RadioButton contenente una label con mnemonic,
aggiungendolo al gruppo specificato. La Label sarà creata usando Gtk.Label.new_with_mnemonic(),
in modo tale che la sottolineatura nella label, indichi il “mnemonic” del radiobutton.
Parametri:
group: un gruppo di radiobutton esistenti ([Gtk.RadioButton, ]),
o None, se stiamo crando un nuovo gruppo;
label: il testo visualizzato a fianco del radiobutton, comprensivo
di sottolineature identificanti gli “mnemonic” del radiobutton;

new_with_mnemonic_from_widget(radio_group_member, label)

Metodo costruttore come il precedente, ma il primo parametro non sarà un gruppo, ma un
Gtk.RadioButton, dal quale attingere il gruppo. Passando None, verrà creato un nuovo gruppo.
Parametri:
radio_group_member: un Gtk.RadioButton esistente;
label: il testo visualizzato a fianco del radiobutton, comprensivo
di sottolineature identificanti gli “mnemonic” del radiobutton;

get_group()

Ritorna il gruppo assegnato al RadioButton, ovvero una lista di radiobuttons dello stesso gruppo:

 
>>> button1.get_group()
[<Gtk.RadioButton object at 0xb4b44fa4 (GtkRadioButton at 0x9ba8220)>, <Gtk.RadioButton object at 0xb72407d4 (GtkRadioButton at 0x9ba8100)>]
>>> button1.get_group() == button2.get_group()
True

join_group(group_source)

Unisce un Gtk.RadioButton al gruppo di un altro Gtk.RadioButton.
Parametri:
group_source: un oggetto Gtk.RadioButton al cui gruppo vogliamo unire
il radiobutton corrente. Passando None, il radiobutton corrente viene rimosso dall’eventuale
gruppo di appartenenza.

 
>>> button3 = Gtk.RadioButton.new()
>>> button3.set_label("Button 3")
>>> button3.get_group()
[<Gtk.RadioButton object at 0xb355c284 (GtkRadioButton at 0x9ba8340)>]
>>> button3.join_group(button1)
>>> for b in button3.get_group():
...     print(b.get_label())
...     
Button 3
Button 2
Button 1

set_group(group)

Setta il gruppo del Gtk.RadioButton. Attenzione che questo non modificherà automaticamente il
layout della nostra interfaccia, quindi per mostrare questa modifica, sarà necessario riadattare
l’interfaccia stessa.
Parametri:
group: un gruppo di radiobutton esistente, o None.

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, controller=None):
        self.controller = controller
        super().__init__(title="RadioButton Demo")
        self.set_border_width(10) # sets space around the inner widget (hbox)

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

        image = Gtk.Image.new_from_file("OK24.png")
        button1 = Gtk.RadioButton.new_with_label_from_widget(None, "Button 1")
        button1.set_image(image)

        button2 = Gtk.RadioButton.new_from_widget(button1)
        button2.set_label("Button 2")
        button3 = Gtk.RadioButton.new_with_label_from_widget(button1,
                                                             "Button 3")
        # Bindings
        button1.connect("toggled", self.on_button_toggled)
        button2.connect("toggled", self.on_button_toggled)
        button3.connect("toggled", self.on_button_toggled)
        # Layout
        hbox.pack_start(button1, False, False, 0)
        hbox.pack_start(button2, False, False, 0)
        hbox.pack_start(button3, False, False, 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 RadioButton