PyGObject: Gtk.Box
Box
Il widget Gtk.Box è un widget che permette di impacchettare i widgets orizzontalmente o
verticalmente a seconda di come è stata settata la property “orientation”.
All’interno del box verrà allocata la stessa dimensione per tutti i widgets contenuti.
I widget verranno inseriti da sinistra verso destra o dall’alto verso il basso, se verrà
utilizzato il metodo pack_start(), o viceversa da destra verso sinistra e dal
basso verso l’alto, se verrà utilizzato il metodo pack_end().
Se non vogliamo che lo stesso quantitativo di spazio sia garantito a tutti i widgets del box,
possiamo chiamare il metodo Gtk.Box.set_homogeneous(False).
Per creare una Box si utilizza il costruttore Gtk.Box(*args, **kwargs).
Le properties più significative sono:
| Name | Type | Flags | Short Description |
|---|---|---|---|
| baseline-position | Gtk.BaselinePosition | r/w/en | La posizione della baseline dei widget allineati in caso di spazio extra disponibile |
| homogeneous | bool | r/w/en | se i children devono avere la stessa dimensione |
| spacing | int | r/w/en | lo spazio tra i children |
Le properties relative ai chidren contenuti nel Gtk.Box, sono:
| Name | Type | Default | Flags | Short Description |
|---|---|---|---|---|
| expand | bool | False | r/w | se i children devono ricevere spazio extra quando il parent aumenta |
| fill | bool | True | r/w | se lo spazio extra dato al child viene usato dallo stesso o come padding |
| pack-type | Gtk.PackType | Gtk.PackType.START | r/w | un Gtk.PackType che indica se il child è impacchettato con riferimento al parent “start” o “end” |
| padding | int | 0 | r/w | Spazio extra da mettere tra il child e i suoi vicini, in pixels |
| position | int | 0 | r/w | L’indice della posizione del child nel parent |
Ovviamente è 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):
>>> import gi
... gi.require_version('Gtk', '3.0')
... from gi.repository import Gtk
>>> box = Gtk.Box(spacing=6)
>>> box.set_property("spacing", 10)
>>> box.get_property("spacing")
10
oppure con i metodi getter e setter specifici get_*property_name*() e
set_*property_name*(value):
>>> box.get_homogeneous() False >>> box.set_homogeneous(True) >>> box.get_homogeneous() True
Metodi
Di seguito i metodi utilizzabili con il widget Gtk.Box:
new(orientation, spacing)
Il metodo costruttore che crea un nuovo Gtk.Box.
Parametri:
orientation: l’oggetto Gtk.Orientation che definisce il tipo di
orientamento del box. Può essere Gtk.Orientation.VERTICAL o Gtk.Orientation.VERTICAL;
spacing: i pixels di spazio tra un widget e l’altro nel box;
get_baseline_position()
Ritorna l’oggetto Gtk.BaselinePosition settato con il metodo Gtk.Box.set_baseline_position().
get_center_widget()
Ritorna il widget centrale o None in caso non sia stato settato.
get_homogeneous()
Ritorna True se il box è homogeneous, ovvero se riserva lo stesso spazio per
tutti i children.
get_spacing()
Ritorna il valore della property “spacing”, ovvero lo spazio tra un child e l’altro nel box.
pack_end(child, expand, fill, padding)
Aggiunge un child (child) al box con direzione da destra verso sinistra, in caso di box
orizzontale, o dal basso verso l’alto, in caso di verticale.
Se un child è già presente, viene aggiunto alla sua sinistra (box orizzontale), o sopra (box verticale).
Parametri:
child: l’oggetto Gtk.Widget da aggiungere al box;
expand: un boolean che settato a True, permette al widget di
prendersi lo spazio extra del box, o di dividerselo con gli altri child con lo stesso settaggio;
fill: un boolean che settato a True, riempie lo spazio extra dedicatogli
con l’opzione expand=True, invece che centrarsi nel padding. Se expand=False, questo settaggio
non ha effetto.
padding: i pixels di extra spazio da mettere tra un child e i vicini;
pack_start(child, expand, fill, padding)
Aggiunge un child (child) al box con direzione sinistra verso destra, in caso di box orizzontale,
o dall’alto verso il basso, in caso di verticale.
Se un child è già presente, viene aggiunto alla sua destra (box orizzontale), o sotto (box verticale).
Parametri:
child: l’oggetto Gtk.Widget da aggiungere al box;
expand: un boolean che settato a True, permette al widget di prendersi
lo spazio extra del box, o di dividerselo con gli altri child con il mesdesimo settaggio;
fill: un boolean che settato a True, riempie lo spazio extra dedicatogli
con l’opzione expand=True, invece che centrarsi nel padding.
Se expand=False, questo settaggio non ha effetto.
padding: un intero che indica i pixels di extra spazio da mettere
tra un child e i propri vicini;
query_child_packing(child)
Ritorna una namedtuple con i parametri relativi all’impacchettamento di un widget nel box.
>>> for label in ("YES", "NO", "QUIT"):
... button = Gtk.Button.new_with_label(label)
... box.pack_start(button, True, True, 0)
>>> box.query_child_packing(button)
(expand=True, fill=True, padding=0, pack_type=<enum GTK_PACK_START of type Gtk.PackType>)
Parametri:
child: l’oggetto Gtk.Widget del quale vogliamo sapere le informazioni
relative all’impacchettamento nel box;
reorder_child(child, position)
Muove il child (Gtk.Widget) nella nuova posizione indicata da “position”.
Parametri:
child: l’oggetto Gtk.Widget da spostare;
position: l’indice (int) della nuova posizione all’interno della
lista dei widgets del box, lista che riguarda l’impacchettamento di tipo Gtk.PackType.START
e Gtk.PackType.END.
set_baseline_position(position)
Setta la posizione della baseline del box (lo spazio lineare contenente i children), quando c’è
più spazio verticale di quello necessario alla baseline stessa.
position: è un Enum di tipo Gtk.BaselinePosition
e può assumere i seguenti valori:
TOP (0): allinea la baseline in alto;
CENTER (1): allinea la baseline al centro dell’extra spazio disponibile;
BOTTOM (2): allinea la baseline in basso;
>>> box.set_baseline_position(Gtk.BaselinePosition.CENTER) >>> box.get_baseline_position() <enum GTK_BASELINE_POSITION_CENTER of type Gtk.BaselinePosition>
Parametri:
position: il tipo di baseline position che vogliamo settare;
set_center_widget(widget)
Setta il widget che vogliamo centrare rispetto all’intera larghezza del box.
Parametri:
widget: l’oggetto Gtk.Widget da centrare o None;
set_child_packing(child, expand, fill, padding, pack_type)
Setta il modo con cui viene impacchettato il widget, all’interno del box.
Parametri:
child: l’oggetto Gtk.Widget per il quale vogliamo settare l’impacchettamento;
expand: un boolean che settato a True, permette al widget di prendersi
lo spazio extra del box, o di dividerselo con gli altri child con il mesdesimo settaggio;
fill: un boolean che settato a True, riempie lo spazio extra dedicatogli
con l’opzione expand=True, invece che centrarsi nel padding.
Se expand=False, questo settaggio non ha effetto.
padding: un intero che indica i pixels di extra spazio da mettere
tra un child e i propri vicini;
pack_type: un Enum di tipo Gtk.PackType
che indica il lato di inserimento del widget, se da sinistra/alto verso destra/basso o viceversa.
Può assumere i seguenti valori:
START (0): l’impacchettamento va da sinistra verso destra e dall’alto verso il basso;
END (1): l’impacchettamento va da destra verso sinistra e dal basso verso l’alto;
set_homogeneous(homogeneous)
Setta la property “homogeneous” che specifica se lo spazio nel box deve essere distribuito in
maniera equa su tutti i children.
Parametri:
homogeneous: il boolean che settato a True, alloca lo spazio del box
in maniera identica su tutti i children;
set_spacing(spacing)
Setta la property “spacing” del box, ovvero la distanza in pixel, tra un child e l’altro,
all’interno del box.
Parametri:
spacing: l’intero che indica i pixel di spazio da interporre tra un widget e l’altro nel box;
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="Box example")
self.box = Gtk.Box(spacing=6)
self.box.set_homogeneous(True)
for label in ("yellow", "red", "black", "blue", "white"):
button = Gtk.Button(label=label)
button.connect("clicked", self.on_button_clicked)
self.box.pack_start(button, True, True, 0)
self.add(self.box)
@staticmethod
def on_button_clicked(button):
print("INFO: '%s' button clicked!" % button.get_label())
if __name__ == "__main__":
win = GWindow()
win.connect("destroy", Gtk.main_quit)
win.show_all()
Gtk.main()
link di riferimento:
Commenti recenti