Avanti Indietro Indice

## 8. Widget Contenitore

## 8.1 Il widget Blocco Note (Notebook)

Il widget Blocco note è un insieme di pagine sovrapposte l'una con l'altra, ognuna contente cose diverse. Questo widget è diventato molto comune nella programmazione delle interfacce utente ed è un buon metodo per mostrare informazioni tra loro correlate ma che debbano essere mostrate separatamente.

La prima funzione da invocare che si deve conoscere, come si può intuire, è usata per creare un nuovo Blocco Note.

> `

>     GtkWidget* gtk_notebook_new (void);

> `

Una volta che il notebook è sato creato, ci sono 12 funzioni che possono operare sul widget notebook. Guardiamole individualmente.

La prima che vediamo riguarda come posizionare l'indicatore di pagina. Questi inidicatori di pagina o ``linguette'' (come possono anche essere chiamati) possono essere posizionati in quattro posti: alto, basso, sinistra.destra.

> `

>     void gtk_notebook_set_tab_pos (GtkNotebook *notebook, GtkPositionType pos);

> `

GtkPositionType sarà uno dei seguenti valori (molto autoesplicativi)

- GTK_POS_LEFT
- GTK_POS_RIGHT
- GTK_POS_TOP
- GTK_POS_BOTTOM

GTK_POS_TOP e' il valore predefinito.

Ora vediamo come aggiugere le pagine al Blocco Note. Ci sono 3 modi per farlo. Diamo un'occhiata ai primi due insieme, viste che sono molto simili.

> `

>     void gtk_notebook_append_page (GtkNotebook *notebook, GtkWidget *child, GtkWidget *tab_label);

>     void gtk_notebook_prepend_page (GtkNotebook *notebook, GtkWidget *child, GtkWidget *tab_label);

> `

Queste funzioni aggiungono pagine al notebook inserendole rispettivamente alla fine (append) o all'inizio (prepend). *child è il widget che è posto nella pagina del notebook e *tab_label e la intestazione della pagina stessa.

L'ultima funzione per aggiungere una pagina al notebook contiene tutte le proprietà delle precedenti due, ma permette di specificare dove posizionare la pagina che si vuole inserire.

> `

>     void gtk_notebook_insert_page (GtkNotebook *notebook, GtkWidget *child, GtkWidget *tab_label, gint position);

> `

I parametri sono gli stessi di _append_ e _prepend_ tranne che per il parametro in più: ``position''. Questo parametro viene usato per specificare in che posizione ineserire la pagina.

Ora che conosciamo come aggiungere le pagine, vediamo come poter toglierne una.

> `

>     void gtk_notebook_remove_page (GtkNotebook *notebook, gint page_num);

> `

Questa funzione prende il numero della pagina specificata dal campo page_num e rimuove la pagina corrispondente dal Blocco Note.

Per trovare qual'è la pagina corrente nel notebook bisogna usare la funzione:

> `

>     gint gtk_notebook_current_page (GtkNotebook *notebook);

> `

Le prossime due funzioni sono semplicemente delle chiamate che muovono la pagina del notebook avanti o indietro. Semplicemente forniscono le chiamate alle rispettive funzioni del widget notebook su si può operare. NB: quando un notebook è correntemente sull'ultima pagina e viene invocata la funzione gtk_notebook_next_page, il notebook ritornerà automaticamente alla prima pagina. Logicamente succede anche il contrario quando invochi gtk_notebook_prev_page e ti trovi sulla prima pagina.

> `

>     void gtk_notebook_next_page (GtkNoteBook *notebook);
>     void gtk_notebook_prev_page (GtkNoteBook *notebook);

> `

La prossima funzione stabilisce la pagina ``attiva''. Se si vuole che la pagina principale del notebook sia per esempio la 5 (ad esempio) si può usare questa funzione. Se non si usa questa funzione la pagina principale sarà la 1.

> `

>     void gtk_notebook_set_page (GtkNotebook *notebook, gint page_num);

> `

Le prossime due funzioni aggiungono o rimuovono, rispettivamente, le intestazioni e i bordi delle pagine.

> `

>     void gtk_notebook_set_show_tabs (GtkNotebook *notebook, gint show_tabs);
>     void gtk_notebook_set_show_border (GtkNotebook *notebook, gint show_border);

> `

show_tabs e show_border posso avere come valore TRUE o FALSE (0 or 1).

Diamo ora una occhiata ad un esempio. Si tratta di una espansione del codice preso dal file testgtk.c che è compreso in tutte le distribuzioni, e mostra tutte le 13 funzioni. Questo piccolo programma crea una finestra con un notebook e 6 bottoni. Il notebook contiene 11 pagine, aggiunte nei 3 modi differenti (alla fine, all'inizio o in qualsiasi posizione). I bottoni permettono di girare le intestazioni, aggiungere/rimuovere le intestazioni e i bordi, rimuovere una pagina, cambiare la pagina avanti e indietro e uscire dal programma.

> `

>     /* notebook.c */

>     #include <gtk/gtk.h>

>     /* Queta funzione ruota le posizione delle linguette delle pagine */
>     void rotate_book (GtkButton *button, GtkNotebook *notebook)
>     {
>         gtk_notebook_set_tab_pos (notebook, (notebook->tab_pos +1) %4);
>     }

>     /* Aggiunge e rimuove le linguette e i bordi */
>     void tabsborder_book (GtkButton *button, GtkNotebook *notebook)
>     {
>         gint tval = FALSE;
>         gint bval = FALSE;
>         if (notebook->show_tabs == 0)
>                 tval = TRUE;
>         if (notebook->show_border == 0)
>                 bval = TRUE;

>         gtk_notebook_set_show_tabs (notebook, tval);
>         gtk_notebook_set_show_border (notebook, bval);
>     }

>     /* Rimuove una pagina */
>     void remove_book (GtkButton *button, GtkNotebook *notebook)
>     {
>         gint page;

>         page = gtk_notebook_current_page(notebook);
>         gtk_notebook_remove_page (notebook, page);
>         /* E' necessario fare un refresh del widget --
>            Questo forza il widget a ridisegnarsi. */
>         gtk_widget_draw(GTK_WIDGET(notebook), NULL);
>     }

>     void delete (GtkWidget *widget, gpointer data)
>     {
>         gtk_main_quit ();
>     }

>     int main (int argc, char *argv[])
>     {
>         GtkWidget *window;
>         GtkWidget *button;
>         GtkWidget *table;
>         GtkWidget *notebook;
>         GtkWidget *frame;
>         GtkWidget *label;
>         GtkWidget *checkbutton;
>         int i;
>         char bufferf[32];
>         char bufferl[32];

>         gtk_init (&argc, &argv);

>         window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

>         gtk_signal_connect (GTK_OBJECT (window), "destroy",
>                             GTK_SIGNAL_FUNC (destroy), NULL);

>         gtk_container_border_width (GTK_CONTAINER (window), 10);

>         table = gtk_table_new(2,6,TRUE);
>         gtk_container_add (GTK_CONTAINER (window), table);

>         /* Crea un nuovo notebook, e tabilisce la posizione delle linguette */
>         notebook = gtk_notebook_new ();
>         gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
>         gtk_table_attach_defaults(GTK_TABLE(table), notebook, 0,6,0,1);
>         gtk_widget_show(notebook);

>         /* appende una parte delle pagine */
>         for (i=0; i < 5; i++) {
>             sprintf(bufferf, "Append Frame %d", i+1);
>             sprintf(bufferl, "Page %d", i+1);

>             frame = gtk_frame_new (bufferf);
>             gtk_container_border_width (GTK_CONTAINER (frame), 10);
>             gtk_widget_set_usize (frame, 100, 75);
>             gtk_widget_show (frame);

>             label = gtk_label_new (bufferf);
>             gtk_container_add (GTK_CONTAINER (frame), label);
>             gtk_widget_show (label);

>             label = gtk_label_new (bufferl);
>             gtk_notebook_append_page (GTK_NOTEBOOK (notebook), frame, label);
>         }

>         /* Ora aggiungiamo una pagina in una certa posizione */
>         checkbutton = gtk_check_button_new_with_label ("Check me please!");
>         gtk_widget_set_usize(checkbutton, 100, 75);
>         gtk_widget_show (checkbutton);

>         label = gtk_label_new ("Add spot");
>         gtk_container_add (GTK_CONTAINER (checkbutton), label);
>         gtk_widget_show (label);
>         label = gtk_label_new ("Add page");
>         gtk_notebook_insert_page (GTK_NOTEBOOK (notebook), checkbutton, label, 2);

>         /* Ora finalmente aggiungiamo le pagine all'inizio */
>         for (i=0; i < 5; i++) {
>             sprintf(bufferf, "Prepend Frame %d", i+1);
>             sprintf(bufferl, "PPage %d", i+1);

>             frame = gtk_frame_new (bufferf);
>             gtk_container_border_width (GTK_CONTAINER (frame), 10);
>             gtk_widget_set_usize (frame, 100, 75);
>             gtk_widget_show (frame);

>             label = gtk_label_new (bufferf);
>             gtk_container_add (GTK_CONTAINER (frame), label);
>             gtk_widget_show (label);

>             label = gtk_label_new (bufferl);
>             gtk_notebook_prepend_page (GTK_NOTEBOOK(notebook), frame, label);
>         }

>         /* Stabilisce quale sarà la prima pagina che sarà visualizzata. */
>         gtk_notebook_set_page (GTK_NOTEBOOK(notebook), 3);

>         /* Crea un set di bottoni */
>         button = gtk_button_new_with_label ("close");
>         gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
>                                    GTK_SIGNAL_FUNC (delete), NULL);
>         gtk_table_attach_defaults(GTK_TABLE(table), button, 0,1,1,2);
>         gtk_widget_show(button);

>         button = gtk_button_new_with_label ("next page");
>         gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
>                                    (GtkSignalFunc) gtk_notebook_next_page,
>                                    GTK_OBJECT (notebook));
>         gtk_table_attach_defaults(GTK_TABLE(table), button, 1,2,1,2);
>         gtk_widget_show(button);

>         button = gtk_button_new_with_label ("prev page");
>         gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
>                                    (GtkSignalFunc) gtk_notebook_prev_page,
>                                    GTK_OBJECT (notebook));
>         gtk_table_attach_defaults(GTK_TABLE(table), button, 2,3,1,2);
>         gtk_widget_show(button);

>         button = gtk_button_new_with_label ("tab position");
>         gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
>                                    (GtkSignalFunc) rotate_book, GTK_OBJECT(notebook));
>         gtk_table_attach_defaults(GTK_TABLE(table), button, 3,4,1,2);
>         gtk_widget_show(button);

>         button = gtk_button_new_with_label ("tabs/border on/off");
>         gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
>                                    (GtkSignalFunc) tabsborder_book,
>                                    GTK_OBJECT (notebook));
>         gtk_table_attach_defaults(GTK_TABLE(table), button, 4,5,1,2);
>         gtk_widget_show(button);

>         button = gtk_button_new_with_label ("remove page");
>         gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
>                                    (GtkSignalFunc) remove_book,
>                                    GTK_OBJECT(notebook));
>         gtk_table_attach_defaults(GTK_TABLE(table), button, 5,6,1,2);
>         gtk_widget_show(button);

>         gtk_widget_show(table);
>         gtk_widget_show(window);

>         gtk_main ();

>         return 0;
>     }

> `

E speriamo che questo vi aiuti a creare i Blocco Note per le vostre applicazioni GTK!

## 8.2 Finestre Scorribili (Scrolled Windows)

Le Finestre Scorribili sono usate per creare areee scorribili in una vera finestra. Si può inserire qualsiasi tipo di widget in questo tipo di finestra, e possono poi essere accessibili a prescindere dalle dimensioni usando le barre di scorrimento.

La funzione seguente è usata per creare una nuova scrolled window.

> `

>     GtkWidget* gtk_scrolled_window_new (GtkAdjustment *hadjustment,
>                                         GtkAdjustment *vadjustment);

> `

Il primo argomento è l'aggiustamento (di quanto scendere ogni volta) orizzontale e il secondo è quello verticale. A questi si assegna quasi sempre il valore NULL.

> `

>     void gtk_scrolled_window_set_policy (GtkScrolledWindow *scrolled_window,
>                                          GtkPolicyType      hscrollbar_policy,
>                          GtkPolicyType      vscrollbar_policy);

> `

Questa funzione stabilisce la politica da usare nella barra di scorrimento. Il primo argomento è la finestra scorribile interessata. Il secondo stabilisce la politica per la barra di scorrimento orizzontale e il terzo è quello per la politca verticale.

La politica può essere GTK_POLICY AUTOMATIC o GTK_POLICY_ALWAYS. GTK_POLICY_AUTOMATIC decide automaticamente se la barra di scorrimento deve essere visualizzata, mentre con GTK_POLICY_ALWAYS la barra verrà sempre mostrata.

> `

>     /* scrolledwin.c */

>     #include <gtk/gtk.h>

>     void destroy(GtkWidget *widget, gpointer data)
>     {
>         gtk_main_quit();
>     }

>     int main (int argc, char *argv[])
>     {
>         static GtkWidget *window;
>         GtkWidget *scrolled_window;
>         GtkWidget *table;
>         GtkWidget *button;
>         char buffer[32];
>         int i, j;

>         gtk_init (&argc, &argv);

>         /* Crea una nuove finestra di dialogo in cui la scrolled window sarà
>             inserita. Una finestra di dialogo è semplicemente come una
>             finestra normale, ma ha anche un vbox e un separatore orizzontale
>             già inseriti per difetto. E'un modo semplice per
>             creare finestre di dialogo. */
>         window = gtk_dialog_new ();
>         gtk_signal_connect (GTK_OBJECT (window), "destroy",
>                             (GtkSignalFunc) destroy, NULL);
>         gtk_window_set_title (GTK_WINDOW (window), "dialog");
>         gtk_container_border_width (GTK_CONTAINER (window), 0);
>         gtk_widget_set_usize(window, 300, 300);

>         /* crea una nuova finestra scorribile. */
>         scrolled_window = gtk_scrolled_window_new (NULL, NULL);

>         gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10);

>         /* la politica è GTK_POLICY AUTOMATIC per lo scorrimento orizzontale e
>             GTK_POLICY_ALWAYS per quello verticale.  */
>         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
>                                         GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);

>         /* La finestra di dialogo è creata con un vbox già inserito.*/
>         gtk_box_pack_start (GTK_BOX (GTK_DIALOG(window)->vbox), scrolled_window,
>                             TRUE, TRUE, 0);
>         gtk_widget_show (scrolled_window);

>         /* crea una tablella di10 x 10. */
>         table = gtk_table_new (10, 10, FALSE);

>         /* setta lo spazio tra ogni cella di 10 pixel sia verticale sia orizzontale*/
>         gtk_table_set_row_spacings (GTK_TABLE (table), 10);
>         gtk_table_set_col_spacings (GTK_TABLE (table), 10);

>         /* inserisce la tabella nella finestra scorribile*/
>         gtk_container_add (GTK_CONTAINER (scrolled_window), table);
>         gtk_widget_show (table);

>         /* questo semplicemente crea una griglia di bottoni nella tabelle per
>            dimostrare il comportamento della finestra scorribile */
>         for (i = 0; i < 10; i++)
>            for (j = 0; j < 10; j++) {
>               sprintf (buffer, "button (%d,%d)\n", i, j);
>               button = gtk_toggle_button_new_with_label (buffer);
>               gtk_table_attach_defaults (GTK_TABLE (table), button,
>                                          i, i+1, j, j+1);
>               gtk_widget_show (button);
>            }

>         /* Aggiunge un bottone "close" alla fine della finestra */
>         button = gtk_button_new_with_label ("close");
>         gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
>                                    (GtkSignalFunc) gtk_widget_destroy,
>                                    GTK_OBJECT (window));

>         /* questo fa sì che questo bottone sia quello predefinito */

>         GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
>         gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button, TRUE, TRUE, 0);

>         /* Questo ottiene il bottone predefinito. Premendo semplicemente l'"enter" il
>             bottone si avvierà */
>         gtk_widget_grab_default (button);
>         gtk_widget_show (button);

>         gtk_widget_show (window);

>         gtk_main();

>         return(0);
>     }

> `

Prova a giocare con il ridemensionamento della finestra. Noterete la reazione della barra di scorrimento. Potete anche usare la funzione gtk_widget_set_usize() per assegnare la dimensione predefinita della finestra o di un widget.

## 8.3 Il widget "Finestra Frazionata" (Paned Window)

Le finestre frazionate tornano utili quando si vuole dividere un'area in due parti,

le cui dimensioni relative siano sotto il controllo dell'utente. Fra le due zone

viene disgnato un separatore dotato di una maniglia che l'utente può

trascinare per cambiare la proporzione fra le aree. La divisione può

essere sia di tipo orizzontale (HPaned) che verticale (VPaned).

Per creare una finestra frazionata, si chiama una delle seguenti:

> `

>     GtkWidget* gtk_hpaned_new (void)
>     GtkWidget* gtk_vpaned_new (void)

> `

Dopo aver creato il widget della finestra frazionata, si devono aggiungere dei

widget figli alle due parti. Per farlo, si usano le funzioni:

> `

>     void gtk_paned_add1 (GtkPaned *paned, GtkWidget *child)
>     void gtk_paned_add2 (GtkPaned *paned, GtkWidget *child)

> `

`gtk_paned_add1()` inserisce il widget figlo alla parte di sinistra o superiore

della finestra. `gtk_paned_add2()` lo inserisce invece nella parte destra o

inferore.

Per fare un esempio, creeremo una parte dell'interfaccia utente di un immaginario

programma di email. Si divide una finestra in due verticalmente,

con la parte superiore in cui si mette la lista dei messaggi, e quella inferiore con

il testo. La maggior parte del programma è piuttosto banale. Un paio

di punti da notare sono: Non si può scrivere su un widget di testo prima

che esso venga "realizato". Questa operazione può essere fatta con una

chiamata alla funzione `gtk_widget_realize()`, ma per far vedere un metodo

alternativo, connetteremo una funzione al segnale "realize" per aggiungere il testo.

Inoltre, dobbiamo aggiungere l'opzione `GTK_SHRINK` ad alcuni degli

elementi della tabella che contiene la finestra del testo e le barre di scorrimento, in

modo che quando si riducono le dimensioni della parte inferiore, le parti coinvolte

risultino proporzionalmente rimpicciolite invece di venir spinte fuori dal fondo

della finestra.

> `

>     /* paned.c */

>     #include <gtk/gtk.h>

>     /*Creiamo la lista dei "messaggi" */
>     GtkWidget *
>     create_list (void)
>     {

>         GtkWidget *scrolled_window;
>         GtkWidget *list;
>         GtkWidget *list_item;

>         int i;
>         char buffer[16];

>         /* Creiamo una nuova finestra scorribile con barre di scorrimento solo

>          * se necessarie */
>         scrolled_window = gtk_scrolled_window_new (NULL, NULL);
>         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
>                                         GTK_POLICY_AUTOMATIC,
>                                         GTK_POLICY_AUTOMATIC);

>         /* Creiamo una nuova lista e la mettiamo nella finestra scorribile */
>         list = gtk_list_new ();
>         gtk_container_add (GTK_CONTAINER(scrolled_window), list);
>         gtk_widget_show (list);

>         /* Aggiungiamo un po' di messaggi alla fiestra */
>         for (i=0; i<10; i++) {

>             sprintf(buffer,"Message #%d",i);
>             list_item = gtk_list_item_new_with_label (buffer);
>             gtk_container_add (GTK_CONTAINER(list), list_item);
>             gtk_widget_show (list_item);

>         }

>         return scrolled_window;
>     }

>     /* Aggiungiamo un po' di testo al nostro widget di testo - questa e' una

>     funzione di callback che viene invocata quando la finestra viene "realizzata".

>     Potremmo anche forzare la finestra ad essere realizzata con la funzione

>      gtk_widget_realize, ma dovrebbe prima essere parte di una certa cerarchia */

>     void
>     realize_text (GtkWidget *text, gpointer data)
>     {
>         gtk_text_freeze (GTK_TEXT (text));
>         gtk_text_insert (GTK_TEXT (text), NULL, &text->style->black, NULL,
>         "From: pathfinder@nasa.gov\n"
>         "To: mom@nasa.gov\n"
>         "Subject: Made it!\n"
>         "\n"
>         "We just got in this morning. The weather has been\n"
>         "great - clear but cold, and there are lots of fun sights.\n"
>         "Sojourner says hi. See you soon.\n"
>         " -Path\n", -1);

>         gtk_text_thaw (GTK_TEXT (text));
>     }

>     /* Creiamo un'area di testo scorribile che mostra un "messaggio" */
>     GtkWidget *
>     create_text (void)
>     {
>         GtkWidget *table;
>         GtkWidget *text;
>         GtkWidget *hscrollbar;
>         GtkWidget *vscrollbar;

>         /*Creiamo una tabella in cui mettere il widget di testo e le barre di scorrimento */
>         table = gtk_table_new (2, 2, FALSE);

>         /* Mettiamo un widget di testo nella parte superiore destra. Notate l'uso di
>          * GTK_SHRINK nella direzione y */
>         text = gtk_text_new (NULL, NULL);
>         gtk_table_attach (GTK_TABLE (table), text, 0, 1, 0, 1,
>                           GTK_FILL | GTK_EXPAND,
>                           GTK_FILL | GTK_EXPAND | GTK_SHRINK, 0, 0);
>         gtk_widget_show (text);

>         /* Mettiamo una HScrollbar nella parte in basso a sinistra */
>         hscrollbar = gtk_hscrollbar_new (GTK_TEXT (text)->hadj);
>         gtk_table_attach (GTK_TABLE (table), hscrollbar, 0, 1, 1, 2,
>                           GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
>         gtk_widget_show (hscrollbar);

>         /* Aggiungiamo una VScrollbar in alto a sinistra */
>         vscrollbar = gtk_vscrollbar_new (GTK_TEXT (text)->vadj);
>         gtk_table_attach (GTK_TABLE (table), vscrollbar, 1, 2, 0, 1,
>                           GTK_FILL, GTK_EXPAND | GTK_FILL | GTK_SHRINK, 0, 0);
>         gtk_widget_show (vscrollbar);

>         /* Aggiungiamo un gestore per mettere un messaggio nel wiget di testo

>          * viene reaizzato */
>         gtk_signal_connect (GTK_OBJECT (text), "realize",
>                             GTK_SIGNAL_FUNC (realize_text), NULL);

>         return table;
>     }

>     int
>     main (int argc, char *argv[])
>     {
>         GtkWidget *window;
>         GtkWidget *vpaned;
>         GtkWidget *list;
>         GtkWidget *text;

>         gtk_init (&argc, &argv);

>         window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
>         gtk_window_set_title (GTK_WINDOW (window), "Paned Windows");
>         gtk_signal_connect (GTK_OBJECT (window), "destroy",
>                             GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
>         gtk_container_border_width (GTK_CONTAINER (window), 10);

>         /* Creiamo un widget frazionato verticalmente e aggiungiamolo alla

>          * finestra di piu' alto livello */

>         vpaned = gtk_vpaned_new ();
>         gtk_container_add (GTK_CONTAINER(window), vpaned);
>         gtk_widget_show (vpaned);

>         /* Creiamo il contenuto delle de parti della finestra */

>         list = create_list ();
>         gtk_paned_add1 (GTK_PANED(vpaned), list);
>         gtk_widget_show (list);

>         text = create_text ();
>         gtk_paned_add2 (GTK_PANED(vpaned), text);
>         gtk_widget_show (text);
>         gtk_widget_show (window);
>         gtk_main ();
>         return 0;
>     }

> `

## 8.4 Cornici ad aspetto fisso (Aspect Frames)

Il widget aspect frame \ analogo al widget "cornice", tranne che per il

fatto che è in grado di forzare le finestre figlie ad avere un certo aspetto,

cioè un certo rapporto fra altezza e larghezza, aggiungendo se necessario

dello spazio in più. Ciò può tornare utile se per esempio

si vuole fare l'anteprima di un'immagine: le dimensioni dell'anteprima devono

variare se l'utente ridimensiona la finestra, ma le proporzioni devono essere

sempre quelle dell'immagine originale.

Per creare una nuova cornice ad aspetto fisso, si usa:

> `

>     GtkWidget* gtk_aspect_frame_new  (const gchar *label,
>                                             gfloat xalign,
>                                             gfloat yalign,
>                                             gfloat ratio,
>                                             gint obey_child)

> `

`xalign` e `yalign` specificano l'allineamento come si fa con il widget di

allineamento. Se `obey_child` è TRUE, le proporzioni di una finestra

figlia saranno le stesse delle misure ideali richieste. In caso contrario, vengono

stabilite da `ratio`.

Per cambiare le opzioni di una finestra esistente, si può usare: To change the options of an existing aspect frame, you can use:

> `

>     void gtk_aspect_frame_set (GtkAspectFrame *aspect_frame,
>                                gfloat xalign,
>                                gfloat yalign,
>                                gfloat ratio,
>                                gint obey_child)

> `

Per fare un esempio, il seguente programma usa un Aspect Frame per rendere

disponibile un'area disegnabile che sia sempre di proporzioni 2:1, in quasiasi

modo l'utente ridimensioni la finestra di base.

> `

>     /* aspectframe.c */

>     #include <gtk/gtk.h>

>     int
>     main (int argc, char *argv[])
>     {
>         GtkWidget *window;
>         GtkWidget *aspect_frame;
>         GtkWidget *drawing_area;
>         gtk_init (&argc, &argv);

>         window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
>         gtk_window_set_title (GTK_WINDOW (window), "Aspect Frame");
>         gtk_signal_connect (GTK_OBJECT (window), "destroy",
>         GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
>         gtk_container_border_width (GTK_CONTAINER (window), 10);

>         /* Creiamo aspect_frame e lo mettiamo nella finestra di base */

>         aspect_frame = gtk_aspect_frame_new ("2x1", /* etichetta */
>                                              0.5, /* x del centro */
>                                              0.5, /* y del centro */
>                                              2, /* xsize/ysize = 2 */
>                                              FALSE /* ignora le proporzioni del figlio */);

>         gtk_container_add (GTK_CONTAINER(window), aspect_frame);
>         gtk_widget_show (aspect_frame);

>         /* Aggiungamo un widget figlio alla nostra cornice */

>         drawing_area = gtk_drawing_area_new ();

>         /* Chiediamo una finestra 200x200, anche se l'AspectFrame ce ne dara' una
>          * di 200x100 perche' forziamo l'aspetto 2:1 */
>         gtk_widget_set_usize (drawing_area, 200, 200);
>         gtk_container_add (GTK_CONTAINER(aspect_frame), drawing_area);
>         gtk_widget_show (drawing_area);

>         gtk_widget_show (window);
>         gtk_main ();
>         return 0;
>     }

> `

Avanti Indietro Indice