Contenitori e struttura dei widget

Requisition

La requisition di un widget consiste in una altezza e larghezza, la dimensione di cui il widget vorrebbe assumere. Questo viene rappresentato tramite una struttura GtkRequisition:

typedef struct _GtkRequisition    GtkRequisition;

struct _GtkRequisition
{
  gint16 width;
  gint16 height;
};

Widget differenti scelgono le dimensioni da richiedere in modi diversi. GtkLabel, ad esempio, chiede una dimensione sufficiente a mostrare il testo dell'etichetta. La maggior parte dei widget contenitori basano la loro richiesta di dimensioni su quella richiesta dai widget contenuti. Ad esempio, se posizionate alcuni pulsanti in un contenitore questo chiederà di essere largo a sufficienza per contenerli tutti quanti.

La prima fase della modellazione è di iniziare con il widget di primo livello come la GtkWindow. Dato che si tratta di un contenitore, GtkWindow chiede ai widget contenuti al suo interno la dimensione che desiderano assumere, i quali, eventualmente, la richiederanno ai propri figli, ricorsivamente. Completata l'interrogazione su tutti i widget, GtkWindow otterrà finalmente indietro un GtkRequisition al proprio figlio. Basandosi sulla tipologia della GtkWindow, questa può essere in grado o meno di espandersi per accontentare le richieste di dimensione.

Allocation

A questo punto inizia la seconda fase della modellazione. GtkWindow decide quanto spazio è attualmente disponibile per i widget al suo interno, e comunica questa decisione al proprio figlio. Questa viene denominata la allocation del figlio, rappresentata dalla seguente struttura:

typedef struct _GtkAllocation     GtkAllocation;

struct _GtkAllocation
{
  gint16 x;
  gint16 y;
  guint16 width;
  guint16 height;
};

I membri width e height sono identici al GtkRequisition. Questi rappresentano la dimensione del widget. Un GtkAllocation include inoltre le coordinate del figlio rispetto al padre. I GtkAllocation vengono assegnati ai widget figli dai rispettivi padri.

I widget devono rispettare il GtkAllocation fornitogli. GtkRequisition è unicamente una richiesta. I widget devono essere in grado di gestire qualunque dimensione.

Avendo mostrato il processo di creazione, è facile comprendere quale ruolo ricoprano i contenitori. Il loro scopo è quello di assemblare le requisition di ciascun figlio in un'unica richiesta per passare al widget padre superiore. Quindi suddividere le allocation ricevuta fra i figli. Come accade questo esattamente è dipendente dal contenitore particolare.

Dettagli sul modello GtkBox

L'inserimento viene controllato da tre parametri, che sono identici sia se iniziamo dall'inizio del contenitore che dalla fine. Il significato di questi è piuttosto complicato, poiché interagiscono con l'impostazione homogeneous del contenitore e di tutti gli altri widget inseriti.

Ecco come un GtkBox calcola la sua richiesta di spazio per la direzione interessata (orizzontale per il GtkHBox, verticale per il GtkVBox) :

1. La dimensione totale richiesta da ciascun widget viene considerata come la richiesta di ciascun widget sommata a due volte il valore del padding utilizzato durante l'inserimento del widget. Il padding di un widget è l'ammontare dello spazio vuoto da lasciare su entrambi i lati di questo. In breve, Dimensione Widget = (Dimenesione Richiesta dal Widget) + (2 * (Padding del widget)).

2. Se il contenitore è omogeneo, la dimensione di base richiesta per l'intero contenitore è uguale alla dimensione (richiesta + padding) del widget contenuto più grande, moltiplicato il numero di widget presenti. In un contenitore omogeneo, tutti i widget sono grandi quanto quello più grande.

3. Se il contenitore non è omogeneo, la dimensione di base richiesta per l'intero contenitore è la somma della dimensione (richiesta + padding) di ciascun widget contenuto.

4. Lo spacing all'interno di tutto il contenitore determina la quantità di spazio vuoto da lasciare tra ciascun widget contenuto. Questo valore viene quindi moltiplicato per il numero di widget meno uno, e aggiunto alla richiesta di dimensione globale. Notare che lo spacing non è proprio di un widget contenuto, è lo spazio fra questi e non è influenzato dai parametri expand e fill. Il padding, in altre parole, è lo spazio attorno ciascun widget contenuto ed è influenzato dai parametri di impacchettamento di questo.

5. Tutti i contenitori hanno uno spessore del bordo. Due volte lo spessore del bordo viene aggiunto alla richiesta di dimensione totale, che rappresenta il bordo su ciascuno dei lati del contenitore. In questo modo, la dimensione totale richiesta per un GtkBox è: (Somma delle dimensioni dei widget contenuti) + (Spacing * (Numero di widget - 1)) + (2 * (Spessore del bordo)).

Dopo aver calcolato la richiesta di dimensione e inviatola al contenitore superiore, il GtkBox riceverà la sua dimensione di allocation da distribuire tra i widget contenuti, in questo modo:

1. Lo spazio sufficiente per lo spessore del bordo e la spaziatura fra i widget vengono sottratti dalla dimensione restituita. Lo spazio rimanente è disponibile per i widget contenuti. Questo spazio viene suddiviso in due sezioni: l'ammontare effettivamente richiesto dal widget (richiesta + padding) più gli "extra". Extra = (Dimensione Allocation) - (Somma delle dimensioni dei widget contenuti).

2. Se il contenitore non è omogeneo, lo spazio "extra" viene suddiviso fra i widget che hanno il parametro expand uguale a TRUE. Questi widget possono espandersi fino a occupare lo spazio disponibile. Se nessuno dei widget si può espandere, lo spazio "extra" viene utilizzato al centro del contenitore, fra i widget inseriti partendo dall'inizio e quelli inseriti alla fine.

3. Se il contenitore è omogeneo, lo spazio extra viene distribuito in base alle necessità. I widget che hanno richiesto maggiore spazio ricevono un "extra" inferiore, in modo tale che alla fine tutti abbiano lo stesso ammontare di spazio disponibile. Il parametro expand viene ignorato dai contenitori omogenei. Lo spazio extra è distribuito fra tutti i widget contenuti, non solo a quelli che possono espandersi.

4. Quando un widget richiede maggiore spazio extra, esistono due possibilità. Può essere aggiunto maggiore padding attorno al widget, oppure il widget viene espanso. Il parametro fill determina quale di questi casi verrà a verificarsi. Se uguale a TRUE, il widget contenuto si espanderà fino a riempire lo spazio. Se fill invece è uguale a FALSE, il padding del widget verrà incrementato fino a riempire lo spazio. Notare che fill non ha alcun effetto se il parametro expand è impostato uguale a FALSE e il contenitore non è omogeneo, poichè il widget non riceverà mai spazio aggiuntivo da occupare

Puff!!! Ma chi è che vuole pensare a tutte queste cose? Fortunatamente, esistono alcuni modelli di utilizzao, quindi non dovrete ogni volta risolvere particolari equazioni per capire come utilizzare un widget. Gli autori del Tutorial di GTK+ suddividonoo questa pratica in cinque casi pratici. Seguiamo adesso i loro consigli.

Utilizzare un contenitore non omogeneo

Esistono tre modi interessanti per inserire un widget in un contenitore non omogeneo. Primo, potete inserire tutti i widget alla fine del contenitore, mantenendo la loro dimensione naturale. Questo significa impostare il parametro expand uguale a FALSE:

  gtk_box_pack_start(GTK_BOX(box),
                     widget,
                     FALSE, FALSE, 0);

Il risultato è mostrato in Figura 6 . Il parametro expand è l'unico che conta in questo caso. Nessun widget contenuto riceve dello spazio extra, quindi non è possibile per loro riempirlo anche se fill è impostato a TRUE.

Potete disseminare i widget all'interno del contenitore, permettendogli di mantenere le loro dimensioni naturali come mostrato in Figura 7 . Questo significa porre il parametro expand uguale a TRUE:

  gtk_box_pack_start(GTK_BOX(box),
                     widget,
                     TRUE, FALSE, 0);

Infine potete riempire il contenitore con i widget (facendo sì che quelli di maggiori dimensioni ottengono minore spazio) impostando il parametro fill uguale a TRUE:

  gtk_box_pack_start(GTK_BOX(box),
                     widget,
                     TRUE, TRUE, 0);

Questa tipologia è mostrata in Figura 8

Utilizzare un contenitore omogeneo

Esistono unicamente due modi interessanti per utilizzare un contenitore omogeneo. Ricordate sempre che il parametro expand è irrilevante per i contenitore di questo tipo. Quindi questi due casi corrispondono alle possibili impostazioni del parametro fill.

Se fill è posto uguale a FALSE, quello che otterrete è la Figura 9 . Notare che il contenitore è suddiviso logicamente in tre settori uguali, ma solo il widget più grande occupa tutto lo spazio messo a disposizione per ciascuno di questi. Gli altri ricevono maggior padding per riempire lo spazio restante. Se fill è posto invece uguale a TRUE, ottenete la Figura 10 , dove tutti i widget assumono la stessa identica dimensione.

Sommario su contenimento dei widget

La Figura 11 mostra tutte e cinque le tecniche di contenimento. (Sono inserite in un GtkVBox omegeneo con il parametro fill posto uguale a TRUE e una spaziatura di due pixel). Questo dovrebbe mostrare le varie differenze. Tenete bene in mente che è possibile modificare i parametri di padding e spacing, per incrementare/decrementare lo spazio vuoto fra i widget contenuti. Ad ogni modo, è possibile creare facilmente una disposizione terrificante utilizzando incoerentemente la spaziatura. È una buona idea cercare di tenere i widget allineati e coerentemente spaziati.

Un ultimo appunto: notare che i parametri expand e fill sono rilevanti unicamente quando la dimensione assegnata al contenitore è maggiore di quella richiesta dai widget contenuti. Per questo motivo tali parametri determinano unicamente come distribuire lo spazio extra. Tipicamente questo appare quando l'utente modifica la finestra ridimensionandola maggiormente rispetto alla dimensione di partenza. Per questo dovete sempre tentare di rimensionare la finestra, per assicurarvi che i contenitori svolgano al meglio il loro compito.

GtkTable: un esempio

Il codice seguente crea una tabella con quattro celle e tre widget al suo interno. Uno di questi occupa due celle. I widget sono inseriti utilizzando parametri diversi:

  GtkWidget* window;
  GtkWidget* button;
  GtkWidget* container;

  window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

  container = gtk_table_new(2, 2, FALSE);

  gtk_container_add(GTK_CONTAINER(window), container);

  gtk_window_set_title(GTK_WINDOW(window), "Table Attaching");

  gtk_container_set_border_width(GTK_CONTAINER(container), 10);

  gtk_window_set_policy(GTK_WINDOW(window), TRUE, TRUE, TRUE);

  gtk_signal_connect(GTK_OBJECT(window),
                     "delete_event",
                     GTK_SIGNAL_FUNC(delete_event_cb),
                     NULL);

  button = gtk_button_new_with_label("1. Doesn't shrink or expand");
  gtk_table_attach(GTK_TABLE(container),
                   button,
                   0, 1,
                   0, 1,
                   GTK_FILL,
                   GTK_FILL,
                   0,
                   0);

  button = gtk_button_new_with_label("2. Expands and shrink vertically");
  gtk_table_attach(GTK_TABLE(container),
                   button,
                   0, 1,
                   1, 2,
                   GTK_FILL,
                   GTK_FILL | GTK_EXPAND | GTK_SHRINK,
                   0,
                   0);

  button = gtk_button_new_with_label("3. Expands and shrinks in both directions");
  gtk_table_attach(GTK_TABLE(container),
                   button,
                   1, 2,
                   0, 2,
                   GTK_FILL | GTK_EXPAND | GTK_SHRINK,
                   GTK_FILL | GTK_EXPAND | GTK_SHRINK,
                   0,
                   0);

È molto istruttivo osservare la tabella risultante quando la finestra viene ridimensionata. Per prima cosa, un piccolo elenco dei widget che sono stati inseriti:

1. Il primo widget riceverà sempre lo spazio richiesto. Non si espanderà né si ridurrà mai.

2. Il secondo si può espandere unicamente in verticale.

3. Il terzo può espandersi in qualunque direzione.

La dimensione naturale della finestra è mostrata nella Figura 13 . Notare che alcune celle devono rimanere allineate. (Ricordate che un pulsante con una etichetta richiederà spazio sufficiente per contenere l'intero testo dell'etichetta). Il flag GTK_FILL obbliga la GtkTable ad allocare spazio extra per i widget, invece di lasciare spazio vuoto fra di essi.

Adesso immaginate che l'utente ridimensioni la finestra, espandendola, in verticale. Notare che lo spazio extra viene fornito ai widget con il flag GTK_EXPAND attivato per le direzione verticale (i widget due e tre del nostro esempio) mentre il widget nell'angolo in alto a sinitra rimane invariato. La Figura 14 mostra questo stato.

Successivamente immaginate che l'utente ridimensioni nuovamente la finestra, questa volta in orizzontale. Unicamente il widget numero tre può espandersi in questa direzione, come viene mostrato in Figura 15 .

La Figura 16 mostra cosa accade se l'utente ha ridotto la tabella verticalmente, fino a che non c'è più spazio sufficiente per soddisfare le richieste dei widget al suo interno. Il widget numero due si ridurrà, mentre il numero uno otterrà tutto lo spazio verticale di cui ha bisogno.

Infine, Figura 17 mostra il risultato di una riduzione orizzontale. Il widget numero tre è quello che ha la peggio.

È una buona idea tentare di ridimensionare la finestra durante la sua creazione, per assicurarsi che tutto sia creato nel modo migliore.

Utilizzare gtk_table_attach_defaults()

Dato che gtk_table_attach() è piuttosto complicata, esiste una versione chiamata gtk_table_attach_defaults(), che semplifica questo tipo di operazione. Questa versione inserisce un widget con le opzioni GTK_EXPAND e GTK_FILL e nessun padding.

È una grande tentazione utilizzare gtk_table_attach_defaults() tutte le volte per ridurre i tempi, ma non dovreste farlo. Infatti, sembra strano a dirlo ma questa viene utilizzata raramente. Questa funzione è utile unicamente se le impostazioni di default che fornisce sono esattamente quelle di cui avete bisogno. La maggior parte delle volte, dovete controllare attentamente i parametri di inserimento in una tabella per ottenere un buon risultato quando questa viene ridimensionata.

#include <gtk/gtktable.h>