bancaldo™

torna all’indice degli appunti

Stack

Il widget Gtk.Stack è un contenitore che mostra i suoi widget
uno alla volta. Le transizioni tra una “pagina” e l’altra, possono essere a scorrimento o sfumate
a seconda della preferenza. Tale animazione può essere settata con il metodo
Gtk.Stack.set_transition_type() e rispetta il settaggio “gtk-enable-animations” (Gtk.Setting).

Le properties principali del widget-parent contenitore sono:

Name	Type	Flags	Short Description
hhomogeneous	bool	r/w/en	Se il sizing orizzontale è omogeneo
homogeneous	bool	r/w/en	Se il sizing è Homogeneous
interpolate-size	bool	r/w/en	Se la larghezza debba o meno cambiare passando da un child all’altro con size diversi
transition-duration	int	r/w/en	La durata dell’animazione in millisecondi
transition-running	bool	r	Se la transizione è in corso d’opera o meno
transition-type	Gtk.StackTransitionType	r/w/en	Il tipo di animazione usata per la transizione
vhomogeneous	bool	r/w/en	Se il sizing Verticale è omogeneo
visible-child	Gtk.Widget	r/w/en	il widget attualmente visibile nello stack
visible-child-name	str	r/w/en	Il nome del widget attualmente visibile nello stack

Le properties principali dei child widgets sono:

Name	Type	Flags	Short Description
icon-name	str	None	r/w	Il nome dell’icona del child widget
name	str	None	r/w	Il nome del child widget
needs-attention	bool	False	r/w	Se il child widget necessita attenzione
position	int	0	r/w	L’indice del child widget nel parent widget
title	str	None	r/w	Il titolo del child widget

Metodi

Oltre ai soliti getter e setter relativi alle properties dell’oggetto Gtk.Stack, i principali
metodi sono:

new()

Crea un nuovo widget contenitore Gtk.Stack.

>>> import gi
... gi.require_version('Gtk', '3.0')
... from gi.repository import Gtk
... 
>>> stack = Gtk.Stack.new()

add_named(child, name)

Aggiunge una child-page allo stack. Il child è identificato dal nome.
Parametri:
child: il child (Gtk.Widget) da aggiungere allo stack;
name: il nome che identifica il child aggiunto allo stack;

add_titled(child, name, title)

Aggiunge una child-page allo stack. Il child è identificato dal nome.
Il titolo title sarà utilizzato dal Gtk.StackSwitcher (trattato più avanti)
per rappresentare il child nella tab bar.
Parametri:
child: il child (Gtk.Widget) da aggiungere allo stack;
name: il nome che identifica il child aggiunto allo stack;
title: il title da utilizzare per il child;

>>> label_1 = Gtk.Label("First page label")
>>> stack.add_titled(child=label_1, name="label_1", title="First page label")

get_child_by_name(name)

Ritorna il child widget che ha il nome passato come argomento, altrimenti None
se non ci sono children con quel nome.
Parametri:
name: il nome del child widget che vogliamo recuperare dallo stack;

>>> stack.get_child_by_name("label_1")
<Gtk.Label object at 0x0000000004f47400 (GtkLabel at 0x0000000004971260)>

get_hhomogeneous()

Ritorna True se lo stack ha un sizing orizzontale omogeneo.

get_homogeneous()

Ritorna True se lo stack ha un sizing omogeneo (sia orizzontale che verticale).

get_interpolate_size()

Ritorna True se lo stack esegue l’interpolazione tra le dimensioni dei children,
quando avviene lo switch tra le pagine.

get_transition_duration()

Ritorna la durata della transizione espressa in millisecondi.

get_transition_running()

Ritorna True se nello stack attualmente sta avvenendo una transizione

get_transition_type()

Ritorna il tipo di animazione (Gtk.StackTransitionType) che sarà usata nella transizione tra pagine.

get_vhomogeneous()

Ritorna True se lo stack ha un sizing verticale omogeneo.

get_visible_child()

Ritorna il child visibile corrente nello stack, o None, se non ci sono children visibili.

get_visible_child_name()

Ritorna il nome del child visibile corrente nello stack, o None se non ci sono children visibili.

set_hhomogeneous(hhomogeneous)

Setta se il Gtk.Stack debba avere un sizing orizzontale omogeneo o no. Se settiamo a True,
lo stack richiederà la stessa larghezza per tutti i suoi child widgets, altrimenti lo stack potrà
cambiare larghezza quando un child widget differente diventerà visibile.
Parametri:
hhomogeneous: il boolean che settato a True rende lo stack omogeneo orizzontalmente;

set_homogeneous(homogeneous)
Setta se il Gtk.Stack debba avere un sizing omogeneo (sia verticale che orizzontale) o no.
Se settiamo a True, lo stack richiederà lo stesso spazio per tutti i suoi child
widgets, altrimenti lo stack potrà cambiare dimensioni quando un child widget differente diventerà
visibile.
Parametri:
homogeneous: il boolean che settato a True rende
lo stack omogeneo (sia orizzontalmente che verticalmente);

set_interpolate_size(interpolate_size)

Setta se lo stack interpolerà le sue dimensioni quando cambia il child visibile.
Se la property di Gtk.Stack “:interpolate-size”=True, lo stack stesso interpolerà le proprie
dimensioni, tra quelle attuali e quelle che prenderà dopo la modifica del child visibile,
in accordo con la durata della transizione.
Parametri:
interpolate_size: Il boolean che settato a True
esegue l’interpolazione;

set_transition_duration(duration)

Setta la durata della transizione tra le “pagine”.
Parametri:
duration: la durata della transizione in millisecondi;

set_transition_type(transition)

Setta il tipo di animazione che sarà usata per la transizione tra pagine, nello stack.
Sono disponibili diversi tipi di animazioni a scorrimento e sfumate.
Parametri:
transition: l’oggetto Gtk.StackTransitionType
corrispondente all’animazione desiderata.

set_vhomogeneous(vhomogeneous)
Setta se il Gtk.Stack debba avere un sizing verticale omogeneo o no. Se settiamo a True,
lo stack richiederà la stessa altezza per tutti i suoi child widgets, altrimenti lo stack potrà
cambiare altezza quando un child widget differente diventerà visibile.
Parametri:
vhomogeneous: il boolean che settato a True rende lo stack omogeneo verticalmente;

set_visible_child(child)
Rende un widget il child visibile dello stack.
Se il widget è diverso dal child visibile corrente, avverrà la transizione in accordo con il
transition type corrente. Nota: il child widget deve essere esso stesso visibile
(Gtk.Widget.show()) per poter diventare il child visibile dello stack!
Parametri:
child: il child widget che vogliamo rendere visibile;

set_visible_child_full(name, transition)

Rende il widget con il nome passato come argomento, il child visibile dello stack e decide quale
transizione utilizzare.
Nota: il child widget deve essere esso stesso visibile (Gtk.Widget.show()) per
poter diventare il child visibile dello stack!
Parametri:
name: il nome del child widget che vogliamo rendere visibile;
transition: l’oggetto Gtk.StackTransitionType corrispondente all’animazione desiderata.

set_visible_child_name(name)

Rende il widget con il nome passato come argomento, il child visibile dello stack.
Se il widget è diverso dal child visibile corrente, avverrà la transizione in accordo con il
transition type corrente.
Nota: il child widget deve essere esso stesso visibile (Gtk.Widget.show()) per
poter diventare il child visibile dello stack!
Parametri:
name: il nome del child widget da rendere visibile;

StackSwitcher

Il widget Gtk.StackSwitcher agisce come controller dei widget Gtk.Stack.
In pratica visualizza una riga di bottoni per spostarsi tra le pagine associate allo stack widget.
I contenuti dei bottoni derivano dalle properties dei child del Gtk.Stack; la visibilità dei
bottoni nel widget Gtk.StackSwitcher è controllata dalla visibilità del child, nel Gtk.Stack.
E’ possibile associare multipli widget Gtk.StackSwitcher con lo stesso Gtk.Stack.

Le properties principali del widget StackSwitcher sono:

Name	Type	Flags	Short Description
icon-size	int	r/w/en	Symbolic size to use for named icon
stack	Gtk.Stack	r/w/c	Stack

Metodi

Oltre ai soliti getter e setter relativi alle properties dell’oggetto Gtk.StackSwitcher,
i principali metodi sono:

new()

Crea un nuovo widget Gtk.StackSwitcher.

get_stack()

Ritorna il widget stack, settato con il metodo Gtk.StackSwitcher.set_stack().

set_stack(stack)

Setta il widget stack che sarà controllato dal widget StackSwitcher.
Parametri:
stack: il widget Gtk.Stack da controllare o None;

Di seguito un codice di esempio:

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


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

        stack = Gtk.Stack.new()
        stack.set_transition_type(Gtk.StackTransitionType.SLIDE_LEFT_RIGHT)
        stack.set_transition_duration(1000)

        checkbutton = Gtk.CheckButton(label="First page checkbutton")
        stack.add_titled(child=checkbutton, name="check", title="Check Button")

        label = Gtk.Label(label="Second page label")
        stack.add_titled(child=label, name="label", title="Label")

        stack_switcher = Gtk.StackSwitcher.new()
        stack_switcher.set_stack(stack)

        # layout
        vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=6)
        vbox.pack_start(stack_switcher, True, True, 0)
        vbox.pack_start(stack, True, True, 0)
        self.add(vbox)


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 Stack
Gtk3 StackSwitcher