Home > Gtk3, PyGObject, python > PyGObject: Gtk.ComboBox

PyGObject: Gtk.ComboBox

13 Aprile 2020

torna all’indice degli appunti

ComboBox

Il widget Gtk.ComboBox permette di selezionare un elemento da una lista.
Una volta selezionato l’elemento, il combobox lo visualizzerà.
Il combobox usa un pattern model-view e la lista degli elementi viene specificata
secondo il modello ad albero (tree-model).
Ci sono due modelli di dati da utilizzare:
il Gtk.ListStore e il Gtk.TreeStore.
Il Gtk.ListStore contiene semplici righe di dati (row), senza children,
mentre il Gtk.TreeStore può contenere dati con children.
La visualizzazione di tali elementi, si adatta al tipo di dato contenuto nel model grazie ai cell-renderers.
Questo è reso possibile dal fatto che Gtk.ComboBox implementa un’interfaccia
Gtk.CellLayout.
Di solito una combobox forza l’utente a scegliere tra gli elementi che dispone, ma dà la
possibilità di aggiungere una scelta, qualora questa non fosse presente, mettendo a disposizione
una Gtk.Entry. Quando la lista di elementi del combobox, riguarda semplici
testi, può essere conveniente utilizzare al posto del widget Gtk.ComboBox, un widget
Gtk.ComboBoxText.

Per creare una ComboBox si utilizza il costruttore Gtk.ComboBox(**kwargs).
Come per tutti gli altri widgets visti fino ad ora, è possibile settare i parametri del widget
anche successivamente alla sua costruzione, con i soliti metodi getter e setter
get_property(property_name) e set_property(property_name, property_value):

Le properties principali di una combobox sono le seguenti:

Name Type Flags Short Description
active int r/w/en l’item attivo al momento
active-id str r/w/en il valore dell’id di colonna per la riga attiva
button-sensitivity Gtk.SensitivityType r/w/en Se il dropdown button è sensibile quando il modulo è vuoto
cell-area Gtk.CellArea r/w/co il Gtk.CellArea usato per il layout delle celle
column-span-column int r/w/en la colonna del TreeModel che contiene i valori del column span
entry-text-column int r/w/en la colonna nel model del combobox da associare con le stringhe dalla entry
se il combobox è stato crato con la property “has-entry”=True
has-entry bool r/w/co se il combobox ha una entry
has-frame bool r/w/en se il combobox disegna un frame intorno al child
id-column int r/w/en La colonna nel model del combobox che fornisce gli ID per i valori nel model
model Gtk.TreeModelv r/w/en Il model per il combobox
popup-fixed-width bool r/w/en Se la larghezza del popup debba essere fissa rispetto alla larghezza allocata dal combobox
popup-shown bool r Se il dropdown del combobox viene visualizzato
row-span-column int r/w/en la colonna del TreeModel contenente i valori del row span
wrap-width int r/w/en La larghezza di Wrap per la collocazione degli elementi in una griglia
selection-mode Gtk.SelectionMode r/w/en il tipo di selection mode

La property selection-mode è un enum di tipo Gtk.SelectionMode
che può assumere i seguenti valori:

NONE (0): nessuna selezione possibile;
SINGLE (1): può essere selezionato 1 solo elemento, o nessuno;
BROWSE (2): può essere selezionato 1 solo elemento, ma è possibile anche deselezionarlo;
MULTIPLE (3): è possibile selezionare elementi multipli;

 
>>> import gi
... gi.require_version('Gtk', '3.0')
... from gi.repository import Gtk
>>> ComboBox = Gtk.ComboBox()
>>> ComboBox.set_property("selection-mode", Gtk.SelectionMode.NONE)
>>> ComboBox.get_property("selection-mode")
<enum GTK_SELECTION_NONE of type Gtk.SelectionMode>

Come per gli altri widgets esistono i metodi getter e setter specifici get_*property_name*()
e set_*property_name*(value):

Segnali

I segnali principali sono:

Name Short Description
row-activated il segnale “row-activated” viene emesso quando una row viene attivata;
row-selected il segnale “row-selected” viene emesso quando una nuova row viene selezionata, deselezionata;
select-all il segnale “select-all” viene emesso quando tutti i children del combobox vengono selezionati (selection-mode=MULTIPLE);
selected-rows-changed il segnale “selected-rows-changed” viene emesso quando la selezione multipla cambia;
unselect-all il segnale “unselect-all” viene emesso quando vengono deselezionati tutti i children del combobox, (selection-mode=MULTIPLE).

Metodi

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

new()

Metodo costruttore che crea un nuovo Gtk.ComboBox.

new_with_area(area)

Metodo costruttore che crea un Gtk.ComboBox vuoto usando l’area per disporre le celle.
Parametri:
area: la Gtk.CellArea usata per disporre i cell renderers;

new_with_area_and_entry(area)

Metodo costruttore che crea un Gtk.ComboBox vuoto usando l’area per disporre le celle, con una
entry.
Parametri:
area: la Gtk.CellArea usata per disporre i cell renderers;

new_with_entry()

Metodo costruttore che crea un Gtk.ComboBox vuoto con una entry.

new_with_model(model)

Metodo costruttore che crea un Gtk.ComboBox con un model inizializzato al model specificato.
Parametri:
model: un Gtk.TreeModel da associare al combobox;

new_with_model_and_entry(model)

Metodo costruttore che crea un Gtk.ComboBox con un model inizializzato al model specificato e una
entry.
Parametri:
model: un Gtk.TreeModel da associare al combobox;

get_active()

Ritorna l’indice dell’elemento attivo, o -1 se non ci sono elementi attivi.
Se il model è un treemodel non-flat e l’elemento attivo non è un child immediato della root del
tree, questo metodo ritorna gtk_tree_path_get_indices (path)[0], dove “path” è il Gtk.TreePath
dell’elemento attivo.

get_active_id()

Ritorna l’ID della row attiva del combobox. Questo valore viene preso dalla row attiva e dalla
colonna specificata dalla property “id-column” (vedere Gtk.ComboBox.set_id_column()).
Se la property “id-column” non è settata, o se non c’è una row attiva, o se la row attiva ha
ID=None, il metodo ritorna None.

get_active_iter()

Ritorna l’iter per l’elemento attivo, se esiste.

get_button_sensitivity()

Ritorna True se il combobox ha i dropdown button sensibili anche in caso di model senza elementi.

get_column_span_column()

Ritorna l’indice della colonna con l’informazione “column span” relativa al combobox.

get_entry_text_column()

Ritorna l’indice della colonna che il combobox sta usando per gestire le stringhe di testo
inserite nella entry del combobox stesso.

get_has_entry()

Ritorna True se il combobox ha una entry, altrimenti False.

get_id_column()

Ritorna l’indice della colonna che il combobox sta usando per gestire gli IDs.

get_model()

Ritorna il Gtk.TreeModel che sta funzionando come sorgente dati per il combobox.

get_popup_fixed_width()

Ritorna True se il popup usa una larghezza fissa.

get_row_span_column()

Ritorna l’id della colonna con l’informazione relativa al “row span” del combobox.

get_wrap_width()

Ritorna la larghezza di wrap usata per determinare il numero di colonne per il popup menu.
Se il “wrap width” è > 1, il combobox è in table mode.

popdown()

Nasconde il menu o la dropdown list del combobox.

popup()

Visualizza il menu o la dropdown list del combobox.

popup_for_device(device)

Fa apparire il menu o la dropdown list per il device specificato; la popup window sarà “afferrata”
e solo il device ed i suoi pointer/keyboard associati saranno gli unici Gdk.Devices abilitati a
spedire eventi ad essa.
Parametri:
device: il Gdk.Device sul quale far apparire menu o dropdown list

set_active(index)

Setta come attivo l’elemento con l’indice specificato.
Parametri:
index: un indice del model corrispondente all’elemento che
vogliamo rendere attivo, o -1 per non avere elementi attivi;

set_active_id(active_id)

Cambia la row attiva del combobox con quella della stringa ID uguale ad “active_id”, o,
se active_id=None, disattiva la row corrente.
Le Rows che hanno la stringa ID=None non possono essere rese attive da questo metodo.
Se la property “id-column” del combobox non è settata, o se nessuna row ha l’ID specificato,
allora il metodo non fa nulla e ritorna False. Ritorna True, invece in caso di successo.
Parametri:
active_id: la stringa cheindica l’ID della row da selezionare, o None;

set_active_iter(iter)

Setta l’elemento che ha l’iter specificato com attivo. Se iter=None viene disattivato l’elemento
attivo corrente.
Parametri:
iter: il Gtk.TreeIter o None;

set_button_sensitivity(sensitivity)

Setta il tipo di sensitività del dropdown button del combobox secondo il valore specificato.
sensitivity (enum Gtk.SensitivityType) può assumere i seguenti valori:
AUTO (0): la freccia (dropdown button) diventa “insensitive” quando si giunge alla fine;
ON (1): la freccia (dropdown button) è sempre “sensitive”;
OFF (2): la freccia (dropdown button) è sempre “insensitive”;
Parametri:
sensitivity: l’enum Gtk.SensitivityType che specifica la
sensitività del dropdown button (freccia);

set_column_span_column(column_span)

Setta la colonna con l’informazione “column span”. La colonna “column span” contiene quindi un
intero che indica su quante colonne verrà disposto un elemento.
Parametri:
column_span: l’indice della colonna nella quale inseriremo
l’informazione “column span”;

set_entry_text_column(text_column)

Setta la colonna del model che gestisce le stringhe della text_column (entry).
La colonna text_column nel model del combobox deve essere di tipo GObject.TYPE_STRING.
Ha rilevanza solo se il combobox è stato creato con la property “has-entry”=True.
Parametri:
text_column: l’indice della colonna nel model che gestirà i testi
della entry;

set_id_column(id_column)

Setta la colonna del model da usare per gestire le string IDs.
La colonna id_column nel model deve essere di tipo GObject.TYPE_STRING.
Parametri:
id_column: l’indice della colonna nel model che gestisce
le string IDs;

set_model(model)

Setta il model usato dal combobox. Verrà eliminato il model precedente.
Se model=None, non ci sarà nessun model settato per il combobox.
Questo metodo non azzera i cell renderers, quindi in caso si vogliano settare dei nuovi
cellrenderers per il nuovo model, bisognerà chiamare il metodo Gtk.CellLayout.clear().
Parametri:
model: il Gtk.TreeModel o None;

set_popup_fixed_width(fixed)

Specifica se la larghezza del popup debba essere una larghezza fissa.
Parametri:
fixed: se usare un popup a larghezza fissa;

set_row_separator_func(func, *data)

Setta la funzione di row separator, che è usata per determinare se una row debba essere disegnata
come separator. Se la funzione “row separator” è None, nessun separators verrà visualizzato
(comportamento di default).
Parametri:
func: la funzione Gtk.TreeViewRowSeparatorFunc;
data: i dati da passare alla funzione o None;

set_row_span_column(row_span)

Setta la colonna con l’informazione “row span”. La colonna “row span” contiene quindi un
intero che indica su quante righe verrà disposto un elemento.
Parametri:
row_span: l’indice della colonna nella quale inseriremo
l’informazione “row span”;

set_wrap_width(width)

Setta la larghezza di wrap del combobox. Il wrap è in sostanza il numero di colonne su cui
vogliamo venga disposto il popup, in una tabella
Parametri:
width: il numero di colonne per il wrap;

Di seguito un codice d’esempio:

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


class ComboBoxRowWithData(Gtk.ComboBoxRow):
    def __init__(self, name, role):
        super(Gtk.ComboBoxRow, self).__init__()
        self.name = name
        self.role = role
        label_name = Gtk.Label(label=self.name, xalign=0)
        label_role = Gtk.Label(label=self.role, xalign=1)
        hbox = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=10)
        hbox.pack_start(label_name, True, True, 0)
        hbox.pack_start(label_role, True, True, 0)
        self.add(hbox)


class NamedSwitch(Gtk.Switch):
    __gproperties__ = {"name": (str,  # type
                                "switch name",  # nick
                                "the setting the switch enables",  # desc
                                "",  # default
                                GObject.ParamFlags.READWRITE, ),
                       }

    def __init__(self):
        super().__init__()

    def do_get_property(self, prop):
        print("INFO: getting property '%s'" % prop)
        return self.name

    def do_set_property(self, prop, value):
        print("INFO: setting property '%s' to %s" % (prop, value))
        self.name = value


class GWindow(Gtk.Window):
    def __init__(self):
        super().__init__(title="ComboBox Demo")
        self.set_border_width(10)

        box_outer = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=6)
        self.add(box_outer)

        ComboBox = Gtk.ComboBox()
        ComboBox.set_selection_mode(Gtk.SelectionMode.NONE)
        box_outer.pack_start(ComboBox, True, True, 0)
        # build first row
        row1 = Gtk.ComboBoxRow()
        hbox1 = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=50)
        mod_label = "Modificatore Difesa"
        label = Gtk.Label(label=mod_label, xalign=0)
        hbox1.pack_start(label, True, True, 0)
        switch1 = NamedSwitch()
        switch1.set_property("name", mod_label)
        switch1.props.valign = Gtk.Align.CENTER
        hbox1.pack_start(switch1, False, True, 0)
        row1.add(hbox1)
        ComboBox.add(row1)
        # build second row
        row2 = Gtk.ComboBoxRow()
        hbox2 = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=50)
        trq_label = "Utilizzo Trequartista"
        label2 = Gtk.Label(label=trq_label, xalign=0)
        hbox2.pack_start(label2, True, True, 0)
        switch2 = NamedSwitch()
        switch2.set_property("name", trq_label)
        switch2.props.valign = Gtk.Align.CENTER
        hbox2.pack_start(switch2, False, True, 0)
        row2.add(hbox2)
        ComboBox.add(row2)
        # build third row
        row3 = Gtk.ComboBoxRow()
        hbox3 = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=50)
        row3.add(hbox3)
        label = Gtk.Label(label="Modulo", xalign=0)
        combo = Gtk.ComboBoxText()
        for index, mod in enumerate(["343", "352", "442", "433"]):
            combo.insert(index, "%s" % index, mod)
        hbox3.pack_start(label, True, True, 0)
        hbox3.pack_start(combo, False, True, 0)
        ComboBox.add(row3)

        ComboBox2 = Gtk.ComboBox()
        names = [('HANDANOVIC', 'Goalkeeper'), ('SKRINIAR', 'Defender'),
                   ('GODIN', 'Defender'), ('DE VRIJ', 'Defender'), ]
        for name, role in names:
            initial_role = ""
            item = ComboBoxRowWithData(name, role)
            if role != initial_role:
                item.set_header(Gtk.Label(label="role"))
            ComboBox2.add(item)

        box_outer.pack_start(ComboBox2, True, True, 0)
        ComboBox2.show_all()

        # sorting
        ComboBox2.set_sort_func(self.sort_func)
        # binding
        ComboBox2.connect('row-activated', self.on_row_activated)
        switch1.connect("notify::active", self.on_switch_activated)
        switch2.connect("notify::active", self.on_switch_activated)

    @staticmethod
    def on_row_activated(ComboBox_widget, row):
        print("INFO: %s selezionato" % row.name)

    @staticmethod
    def sort_func(row_1, row_2, data=None):
        return row_1.name.lower() > row_2.name.lower()

    @staticmethod
    def on_switch_activated(switch, gparam):
        if switch.get_active():
            state = "ON"
        else:
            state = "OFF"
        print("INFO: '%s' %s" % (switch.get_property("name"), 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 ComboBox

Categorie:Gtk3, PyGObject, python Tag: , ,
I commenti sono chiusi.