GTK3 layouts e containers

logo3

Diversamente dalle solite GUI GTK+ permette il posizionamento automatico dei widget in righe, colonne o tabelle. La dimensione viene determinata automaticamente in funzione del loro contenuto.
Gli oggetti (widgets) sono organizzati gerarchicamente mediante containers, componenti invisibili che possono essere inseriti nella window o uno all’interno dell’altro.
Ci sono due tipi di containers: single-child, discendenti di GTK.Bin e multiple-child, discendenti di Gtk.Container.
Quelli più comuni sono i box, orizzontali o verticali (Gtk.Box), le tabelle (Gtk.Table) e le griglie (Gtk.Grid).

Box

i box sono un container invisibile per raggruppare widget. I widget possono essere raggruppati orizzontalmente da sinistra a destra o al contrario in funzione dell’uso di Gtk.Box.pack_start() o Gtk.Box.pack_end() o verticalmente. Naturalmente ci possono essere box dentro una box.

class Gtk.Box([homogenous[, spacing ]])
Un area rettangolare con una riga o una colonna di widget, in funzione dell’orientamento (Gtk.Orientation.HORIZONTAL (default) o Gtk.Orientation.VERTICAL).
Se homogeneous è True tutti i widget hanno la stessa dimensione; il default è False.
spacing è il numero di pixel tra i widget, il default è 0.
Gtk.Box usa il packing, che definisce l’inizio (start) e la fine (end) del box.

pack_start(child, expand, fill, padding)
dove child è il widget da aggiungere al box; se expand è True questo prende tutto lo spazio che può, altrimenti solo quello necessario.
Se fill è True il child ha le dimensioni del box, vale solo se expand è True.
padding è il numero di pixel tra widgets adiacenti.

pack_end(child, expand, fill, padding)
aggiunge il child alla fine del box.

set_homogeneous(homogeneous)
ovvio, no?

#!/usr/bin/python3

#box.py

from gi.repository import Gtk

class MyWindow(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self, title="Hello World")
        self.box = Gtk.Box(spacing=6)
        self.add(self.box)

        self.button1 = Gtk.Button(label="Hello")
        self.button1.connect("clicked", self.on_button1_clicked)
        self.box.pack_start(self.button1, True, True, 0)

        self.button2 = Gtk.Button(label="Goodbye")
        self.button2.connect("clicked", self.on_button2_clicked)
        self.box.pack_start(self.button2, True, True, 0)

    def on_button1_clicked(self, widget):
        print("Hello")

    def on_button2_clicked(self, widget):
        print("Goodbye")

win = MyWindow()
win.connect("delete-event", Gtk.main_quit)
win.show_all()
Gtk.main()

box

Vediamo se ho capito: modifico le righe 10 e 17, così:

mod

e la finestra diventa:

box-m

Grid

Gtk.Grid è il container che consente di avere più righe e colonne, senza doverne specificare il numero nel costruttore. Gli oggetti sono aggiunti con Gtk.Grid.attach(). È possibile aggiungerne uno dopo uno esistente con Gtk.Grid.attach_next_to().

class Gtk.Grid
crea un nuovo oggetto grid.

attach(child, left, top, width, height)
aggiunge child alla grid; la posizione è data da left, top, il numero di celle occupate da width, height.

attach_next_to(child, sibling, side, width, height)
aggiunge l’oggetto vicino a sibling; la posizione è una di Gtk.PositionType.LEFT, Gtk.PositionType.RIGHT, Gtk.PositionType.TOP e Gtk.PositionType.BOTTOM.

add(widget)
aggiunge l’oggetto nella direzione determinata da orientation.

#!/usr/bin/python3

#grid.py

from gi.repository import Gtk

class GridWindow(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self, title="Grid Example")
        grid = Gtk.Grid()
        self.add(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(button2, 1, 0, 2, 1)
        grid.attach_next_to(button3, button1, Gtk.PositionType.BOTTOM, 1, 2)
        grid.attach_next_to(button4, button3, Gtk.PositionType.RIGHT, 2, 1)
        grid.attach(button5, 1, 2, 1, 1)
        grid.attach_next_to(button6, button5, Gtk.PositionType.RIGHT, 1, 1)

win = GridWindow()
win.connect("delete-event", Gtk.main_quit)
win.show_all()
Gtk.main()

grid

Table

Gtk:Table è simile a Gtk.Grid, le dimensioni devono essere specificate nel costruttore. Per attaccare oggetti si usa Gtk.Table.attach(). Lo spazio tra le righe e le colonne sono fissate con Gtk.Table.set_row_spacing() e Gtk.Table.set_col_spacing().

Però la Table è deprecata, usare Grid. Allora niente esempio 😉

Annunci
Post a comment or leave a trackback: Trackback URL.

Rispondi

Inserisci i tuoi dati qui sotto o clicca su un'icona per effettuare l'accesso:

Logo WordPress.com

Stai commentando usando il tuo account WordPress.com. Chiudi sessione / Modifica )

Foto Twitter

Stai commentando usando il tuo account Twitter. Chiudi sessione / Modifica )

Foto di Facebook

Stai commentando usando il tuo account Facebook. Chiudi sessione / Modifica )

Google+ photo

Stai commentando usando il tuo account Google+. Chiudi sessione / Modifica )

Connessione a %s...

%d blogger hanno fatto clic su Mi Piace per questo: