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

PyGObject: Gtk.Grid

13 Aprile 2020

torna all’indice appunti

Grid

Il widget Gtk.Grid è un widget contenitore (come Gtk.Box) che impacchetta i widgets su una
griglia, posizionandoli in righe e colonne.
I widget verranno inseriti utilizzando il metodo attach().
E’ possibile inserire un widget child vicino ad un altro, con il metodo attach_next_to().
Il Gtk.Grid, può essere utilizzato come un Gtk.Box semplicemente utilizzando il metodo add()
ereditato da Gtk.Container, dal quale derivano entrambi. Ovviamente se l’esigenza è di creare una
singola riga di widget, è preferibile l’utilizzo di Gtk.Box.

Per creare una Grid si utilizza il costruttore Gtk.Grid(**kwargs).

Le properties più significative sono:

Name Type Flags Short Description
baseline-row int r/w/en un intero che indica su quale row allineare la baseline quando valign=Gtk.Align.BASELINE
column-homogeneous bool r/w/en un boolean che settato a True permette di avere le colonne, tutte della stessa larghezza
column-spacing int r/w/en un intero che indica quanto spazio lasciare tra una colonna e l’altra
row-homogeneous bool r/w/en un boolean che settato a True permette di avere le righe, tutte della stessa altezza
row-spacing int r/w/en un intero che indica quanto spazio lasciare tra una riga e l’altra

Le properties relative ai child contenuti nella griglia, sono invece:

Name Type Default Flags Short Description
height int 1 r/w il numero di righe che occupa il child (span)
left-attach int 0 r/w il numero di colonna a cui attaccare il bordo sinistro del child
top-attach int 0 r/w il numero di riga a cui attaccare il bordo superiore del child
width int 1 r/w il numero di colonne occupate dal widget (span)

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
>>> grid = Gtk.Grid(row_spacing=5)
>>> grid.get_property("row-spacing")
5
>>> grid.set_property("row-spacing", 10)
>>> grid.get_property("row-spacing")
10

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

 
>>> grid.get_column_homogeneous()
False
>>> grid.set_column_homogeneous(True)
>>> grid.get_column_homogeneous()
True

Metodi

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

new()

Il metodo costruttore che crea un nuovo widget Gtk.Grid.

attach(child, left, top, width, height)

Aggiunge un child widget al grid.
Parametri:
child: l’oggetto Gtk.Widget da aggiungere alla griglia;
left: il numero (int) di colonna al quale inserire il child;
top: il numero (int) di riga nel quale inserire il child;
width: il numero (int) di celle che occuperà il child orizzontalmente (span);
height: il numero (int) di celle che il child occuperà verticalmente (span);

 
>>> grid = Gtk.Grid(row_spacing=5)
>>> button1 = Gtk.Button(label="Button 1")
>>> grid.attach(child=button1, left=0, top=0, width=1, height=1)

attach_next_to(child, sibling, side, width, height)

Aggiunge un widget (child) al grid vicino al widget di riferimento (sibling), secondo il side
desiderato (sinstra/alto verso destra/basso e viceversa).
Il “side” è un enum di tipo Gtk.PositionType
che indica il lato al quale affiancheremo il child; può assumere i seguenti valori:
LEFT (0): il child viene affiancato sul lato sinistro;
RIGHT (1): il child viene affiancato sul lato destro del sibling;
TOP (2): il child viene posizionato sopra al sibling;
BOTTOM (3): il child viene posizionato sotto al sibling;

 
>>> button2 = Gtk.Button(label="Button 2")
>>> grid.attach_next_to(child=button2, sibling=button1, side=Gtk.PositionType.RIGHT,
...                     width=1, height=1)

Parametri:
child: l’oggetto Gtk.Widget da aggiungere alla griglia;
sibling: l’oggetto Gtk.Widget di riferimento. Se sibling=None, child viene inserito ad inizio/fine a seconda del side;
side:
width (int) – the number of columns that child will span
width: il numero (int) di celle che occuperà il child orizzontalmente (span);
height: il numero (int) di celle che il child occuperà verticalmente (span);

get_baseline_row()

Ritorna l’indice della row che definisce la baseline del grid.

get_child_at(left, top)

Ritorna il child alla posizione data.

 
>>> grid.get_child_at(left=0, top=0).get_label()
'Button 1'
>>> grid.get_child_at(left=1, top=0).get_label()
'Button 2'

Parametri:
left: (int) il lato sinistro della cella;
top: (int) la parte superiore della cella;

get_column_homogeneous()

Ritorna il valore della property “column-homogeneous”.
True, se le colonne hanno tutte la stessa larghezza, altrimenti False.

get_column_spacing()

Ritorna il valore della property “column-spacing”, ovvero lo spazio che c’è tra le colonne.

get_row_baseline_position(row)

Ritorna la posizione della baseline della singola row, se settata con
Gtk.Grid.set_row_baseline_position(), oppure il valore di default Gtk.BaselinePosition.CENTER.
Parametri:
row: è l’indice della row della quale vogliamo conoscere la posizione della baseline;

get_row_homogeneous()

Ritorna il valore della property “row-homogeneous”.
True, se le righe hanno tutte la stessa altezza, altrimenti False.

get_row_spacing()

Ritorna il valore della property “row-spacing”, ovvero lo spazio che c’è tra una riga e l’altra.

insert_column(position)

Inserisce una colonna nella posizione specificata.
I widget che sono attaccati a questa posizione saranno spostati a destra, mentre quelli che
occupano questa posizione per via dello span, accresceranno la loro dimensione per occupare anche
la nuova colonna aggiunta.
Parametri:
position: la posizione nella quale vogliamo inserire una colonna;

insert_next_to(sibling, side)

Inserisce una riga o una colonna alla posizione specificata. La nuova riga/colonna sarà inserita
vicino al widget di riferimento e sarà una riga, se side sarà uno tra Gtk.PositionType.TOP o
Gtk.PositionType.BOTTOM, o sarà una colonna, se side sarà uno tra Gtk.PositionType.LEFT e
Gtk.PositionType.RIGHT.
Parametri:
sibling: il child (Gtk.Widget) di riferimento vicino al quale inseriremo
la riga/colonna, a seconda del side;
side: un enum di tipo Gtk.PositionType che
specifica se ad essere inserita vicino a child, sarà una riga o una colonna;

insert_row(position)

Inserisce una riga nella posizione specificata.
I widget che sono attaccati a questa posizione saranno spostati in basso, mentre quelli che
occupano questa posizione per via dello span, accresceranno la loro dimensione per occupare anche
la nuova riga aggiunta.
Parametri:
position: la posizione nella quale vogliamo inserire una riga;

remove_column(position)

Rimuove la colonna dalla grid.
I widgets di questa colonna vengono rimossi, quelli dopo si spostano verso sinistra e i widgets
con span sulla colonna rimossa, riducono la propria larghezza di una cella.
Parametri:
position: l’indice della colonna da rimuovere;

remove_row(position)

Rimuove la riga dalla grid.
I widgets di questa riga vengono rimossi, quelli dopo si spostano verso l’alto e i widgets con
span sulla riga rimossa, riducono la propria altezza di una cella.
Parametri:
position: l’indice della riga da rimuovere;

set_baseline_row(row)

Setta quale riga definisce la baseline globale dell’intera griglia (anche le singole righe hanno
la loro baseline locale).
Parametri:
row: l’indice della riga che sarà la baseline globale;

set_column_homogeneous(homogeneous)

Definisce se le colonne debbano avere la stessa larghezza (True), o meno (False).
Parametri:
homogeneous: il boolean che modifica la property “column-homogeneous”;

set_column_spacing(spacing)

Setta quando spazio lasciare tra una colonna e l’altra.
Parametri:
spacing: un intero che definisce lo spazio tra le colonne;

set_row_baseline_position(row, pos)

Setta la posizione della baseline locale della singola row, quando è assegnato più spazio
del necessario.
Parametri:
row: l’indice della riga sulla quale definire la posizione della baseline;
pos: un enum di tipo Gtk.BaselinePosition
e può assumere i valori:
TOP (0): allinea la baseline locale della row in alto;
CENTER (1): allinea la baseline al centro (default);
BOTTOM (2): allinea la baseline in basso;

set_row_homogeneous(homogeneous)

Definisce se le righe debbano avere la stessa altezza (True), o meno (False).
Parametri:
homogeneous: il boolean che modifica la property “row-homogeneous”;

set_row_spacing(spacing)

Setta quando spazio lasciare tra una riga e l’altra.
Parametri:
spacing: un intero che definisce lo spazio tra le righe;

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="Grid Example")

        grid = Gtk.Grid()

        button1 = Gtk.Button(label="Button 1")
        button2 = Gtk.Button(label="Button 2")
        button3 = Gtk.Button(label="Button 3")
        button4 = Gtk.Button(label="Button 4")
        button5 = Gtk.Button(label="Button 5")
        button6 = Gtk.Button(label="Button 6")

        grid.add(button1)
        grid.attach(child=button2, left=1, top=0, width=2, height=1)
        grid.attach_next_to(child=button3, sibling=button1,
                            side=Gtk.PositionType.BOTTOM, width=1, height=2)
        grid.attach_next_to(child=button4, sibling=button3,
                            side=Gtk.PositionType.RIGHT, width=2, height=1)
        grid.attach(child=button5, left=1, top=2, width=1, height=1)
        grid.attach_next_to(child=button6, sibling=button5,
                            side=Gtk.PositionType.RIGHT, width=1, height=1)
        self.add(grid)


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 Grid

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