gtk_tut_it-4.html

gtk是linux一款强大的夸平台的图形化开发工具

        gtk_widget_show (box2);
        
        /* Gli argomenti sono: homogeneous, spacing, expand, fill, padding */
        box2 = make_box (FALSE, 0, TRUE, TRUE, 10);
        gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
        gtk_widget_show (box2);
        
        separator = gtk_hseparator_new ();
        /* Gli ultimi tre argomenti di gtk_box_pack_start sono: expand, fill, padding. */
        gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
        gtk_widget_show (separator);
        break;
    
    case 3:

        /* Questo dimostra la possibilita' di usare use gtk_box_pack_end() per
         * giustificare gli oggetti a destra. Per prima cosa creiamo una
         * nuova scatola come prima. */
        box2 = make_box (FALSE, 0, FALSE, FALSE, 0);
        /* creiamo l'etichetta che sara' aggiunta alla fine. */
        label = gtk_label_new ("end");
        /* impacchettiamola usando gtk_box_pack_end(), cosa' che viene inserita
         * sul lato destro della hbox creata nella chiamata a the make_box(). */
        gtk_box_pack_end (GTK_BOX (box2), label, FALSE, FALSE, 0);
        /* mostriamo l'etichetta. */
        gtk_widget_show (label);
        
        /* impacchettiamo box2 in box1 (the vbox, ricordate? :) */
        gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
        gtk_widget_show (box2);
        
        /* un separatore per il fondo */
        separator = gtk_hseparator_new ();
        /* Questo assegna esplicitamente al separatore l'ampiezza di 400 pixel
         * e l'altezza di 5 pixel. Cio' fa si' che la hbox che abbiamo creato sia
         * anche essa larga 400 pixel, e che l'etichetta finale sia separata dalle
         * altre etichette nella hbox. In caso contrario, tutti gli oggetti nella
         * hbox sarebbero impacchettati il piu' vicino possibile. */
        gtk_widget_set_usize (separator, 400, 5);
        /* impacchetta il separatore nella vbox (box1) creata vicino all'inizio 
         * di main() */
        gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
        gtk_widget_show (separator);    
    }
    
    /* Creare un'altra nuova hbox.. ricordate che ne possiamo usare quante ne vogliamo! */
    quitbox = gtk_hbox_new (FALSE, 0);
    
    /* Il nostro bottone di uscita. */
    button = gtk_button_new_with_label ("Quit");
    

    /* Configuriamo il segnale per distruggere la finestra.  Ricordate che
     * ciò manderà alla finestra il segnale "destroy", che verrà catturato 
     * dal nostro gestore di segnali che abbiamo definito in precedenza. */
    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
                               GTK_SIGNAL_FUNC (gtk_main_quit),
                               GTK_OBJECT (window));
    /* impacchetta il bottone in quitbox.
     * Gli ultimi tre argomenti di gtk_box_pack_start sono: expand, fill, padding. */
    gtk_box_pack_start (GTK_BOX (quitbox), button, TRUE, FALSE, 0);
    /* impacchetta quitbox nella vbox (box1) */
    gtk_box_pack_start (GTK_BOX (box1), quitbox, FALSE, FALSE, 0);
    
    /* impacchetta la vbox (box1), che ora contiene tutti i nostri oggetti,
     * nella finestra principale. */
    gtk_container_add (GTK_CONTAINER (window), box1);
    
    /* e mostra tutto quel che rimane */
    gtk_widget_show (button);
    gtk_widget_show (quitbox);
    
    gtk_widget_show (box1);
    /* Mostriamo la finestra alla fine in modo che tutto spunti fuori assieme. */
    gtk_widget_show (window);
    
    /* E, naturalmente, la nostra funzione main. */
    gtk_main ();

    /* Il controllo ritorna a questo punto quando viene chiamata gtk_main_quit(), 
     * ma non quando si usa gtk_exit. */
    
    return 0;
}
</PRE>
</CODE></BLOCKQUOTE>
<P>
<H2><A NAME="ss4.4">4.4 Impacchettamento con uso di Tabelle</A>
</H2>

<P>Diamo ora un'occhiata ad un altro modo di impacchettare - le Tabelle.
In certe situazioni, possono risultare estremamente utili.
<P>Usando le tabelle, creiamo una griglia in cui possiamo piazzare gli oggetti.
Gli oggetti possono occupare tanti spazi quanti ne specifichiamo.
<P>Naturalmente, la prima cosa da vedere &egrave; la funzione gtk_table_new:
<P>
<BLOCKQUOTE><CODE>
<PRE>
GtkWidget* gtk_table_new (gint rows,
                          gint columns,
                          gint homogeneous);
</PRE>
</CODE></BLOCKQUOTE>
<P>Il primo argomento rappresenta il numero di righe da mettere nella tabella,
mentre il secondo &egrave; ovviamente il numero di colonne.
<P>L'argomento homogeneous ha a che fare con il modo in cui le caselle della tabella
sono dimensionate. Se homogeneous ha il valore TRUE, le caselle sono ridimensionate
fino alla dimensione del pi&ugrave; grande oggetto contenuto nella tabelle. Se &egrave; FALSE, la
dimensione delle caselle&egrave; decisa dal pi&ugrave; alto oggetto in una certa riga e dal pi&ugrave;
largo oggetto in una stessa colonna.
<P>Le righe e le colonne sono disposte a partire da 0 fino a n, dove n &egrave; il numero
che era stato specificato nella chiamata a gtk_table_new. Cos&igrave;, se specificate 
rows = 2 e columns = 2, lo schema avr&agrave; questo aspetto:
<P>
<BLOCKQUOTE><CODE>
<PRE>
 0          1          2
0+----------+----------+
 |          |          |
1+----------+----------+
 |          |          |
2+----------+----------+
</PRE>
</CODE></BLOCKQUOTE>
<P>Notate che il sistema di coordinate ha origine nel vertice in alto a sinistra. Per
mettere un oggetto in una tabella, usate la seguente funzione:
<P>
<BLOCKQUOTE><CODE>
<PRE>
void gtk_table_attach (GtkTable      *table,
                       GtkWidget     *child,
                       gint           left_attach,
                       gint           right_attach,
                       gint           top_attach,
                       gint           bottom_attach,
                       gint           xoptions,
                       gint           yoptions,
                       gint           xpadding,
                       gint           ypadding);
</PRE>
</CODE></BLOCKQUOTE>
                                       
<P>In cui il primo argomento (``table'') &egrave; la tabella che avete creato e il secondo
(``child'') &egrave; l'oggetto che volete piazzare nella tabella.
<P>Gli argomenti ``attach''  (right, left, top, bottom)  specificano dove mettere l'oggetto
e quante caselle adoperare. Se volete mettere un bottone nella casella in basso a destra
nella nostra tabella 2x2, e volete che esso riempia SOLO quella casella, dovete porre
left_attach = 1, right_attach = 2, top_attach = 1, bottom_attach = 2.
<P>Se invece volete che un oggetto si prenda tutta la riga pi&ugrave; in alto nella nostra tabella
2x2, dovreste usare left_attach = 0, right_attach =2, top_attach = 0, 
bottom_attach = 1.
<P>Gli argomenti  ``xoptions'' e ``yoptions'' sono usati per specificare le opzioni di impacchettamento;
di essi si pu&ograve; fare l'OR in modo di ottenere opzioni multiple.
<P>Le opzioni sono:
<UL>
<LI>GTK_FILL - Se la parte di tabella in cui si vuole inserire il widget &egrave; pi&ugrave; 
grande dell'oggetto, e se si specifica GTK_FILL, l'oggetto viene espanso fino ad
occupare tutto lo spazio disponibile.
</LI>
<LI>GTK_SHRINK - Se si alloca all'oggetto nella tabella meno spazio del necessario
(di solito succede quando l'utente ridimensiona la finestra), allora normalmente
l'oggetto verrebbe spinto fuori dal fondo della finestra fino a sparire.
Se invece si specifica GTK_SHRINK is specified, gli oggetti si rimpiccioliscono
assieme alla tabella.
</LI>
<LI>GTK_EXPAND - Questo fa s&igrave; che la tabella si espanda fino ad occupare tutto lo 
spazio che rimane nella finestra.</LI>
</UL>
<P>Il riempimento funziona come nelle scatole, con la creazione di un'area vuota
attorno all'oggetto la cui dimensione viene specificata in pixel.
<P>La funzione gtk_table_attach() ha UN MUCCHIO di opzioni. Quindi, ecco una scorciatoia:
<P>
<BLOCKQUOTE><CODE>
<PRE>
void gtk_table_attach_defaults (GtkTable   *table,
                                GtkWidget  *widget,
                                gint        left_attach,
                                gint        right_attach,
                                gint        top_attach,
                                gint        bottom_attach);
</PRE>
</CODE></BLOCKQUOTE>
<P>Le xoptions e yoptions vengono posti per difetto a GTK_FILL | GTK_EXPAND, e sia xpadding
che ypadding vengono posti a 0. Il resto degli argomenti sono identici a quelli della funzione
precedente.
<P>Ci sono poi le funzioni gtk_table_set_row_spacing() and gtk_table_set_col_spacing().
Queste mettono dello spazio fra le righe (o colonne)in corrispondenza di una specifica
riga (o colonna).
<P>
<BLOCKQUOTE><CODE>
<PRE>
void gtk_table_set_row_spacing (GtkTable      *table,
                                gint           row,
                                gint           spacing);
</PRE>
</CODE></BLOCKQUOTE>

e
<BLOCKQUOTE><CODE>
<PRE>
void       gtk_table_set_col_spacing  (GtkTable      *table,
                                       gint           column,
                                       gint           spacing);
</PRE>
</CODE></BLOCKQUOTE>
<P>Notate che per le colonne lo spazio viene posto alla destra della colonna, mentre
per le righe lo spazio viene posto al di sotto della riga.
<P>Si pu&ograve; poi inserire una spaziatura identica fra tutte le righe e/o colonne usando:
<P>
<BLOCKQUOTE><CODE>
<PRE>
void gtk_table_set_row_spacings (GtkTable *table,
                                 gint      spacing);
</PRE>
</CODE></BLOCKQUOTE>
<P>e
<BLOCKQUOTE><CODE>
<PRE>
void gtk_table_set_col_spacings (GtkTable  *table,
                                 gint       spacing);
</PRE>
</CODE></BLOCKQUOTE>
<P>Notate che con queste chiamate,  all'ultima riga e all'ultima colonna
non viene assegnata alcuna spaziatura.
<P>
<H2><A NAME="ss4.5">4.5 Esempio di Impacchettamento con Tabelle</A>
 </H2>

<P>In questo esempio creiamo una finestra avente tre bottoni disposti
in una tabella 2x2. I primi due bottoni li mettiamo nella riga superiore.
Un terzo bottone, quit, lo mettiamo nella riga inferioe, in modo da
comprendere entrambe le colonne. Ci&ograve; significa che dovremmo
avere qualcosa di questo tipo:
<P> <CENTER >
<IMG SRC="gtk_tut_table.gif" VSPACE="15" HSPACE="10" 
ALT="Table Packing Example Image" WIDTH="180" HEIGHT="120"
> </CENTER
 >
<P>Ecco il codice sorgente:
<P>
<BLOCKQUOTE><CODE>
<PRE>
/* table.c */
#include &lt;gtk/gtk.h>

/* la nostra funzione di ritorno.
 * i dati passati a questa funzione vengono stampati su stdout */
void callback (GtkWidget *widget, gpointer data)
{
    g_print ("Hello again - %s was pressed\n", (char *) data);
}

/* questa funzione fa uscire dal programma */
void delete_event (GtkWidget *widget, gpointer data)
{
    gtk_main_quit ();
}

int main (int argc, char *argv[])
{
    GtkWidget *window;
    GtkWidget *button;
    GtkWidget *table;

    gtk_init (&amp;argc, &amp;argv);

    /* creiamo una nova finestra */
    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

    /* predisponiamo il titolo per la finestra */
    gtk_window_set_title (GTK_WINDOW (window), "Table");

    /* creiamo un gestore per delete_event che esca immediatamente
     * da GTK. */
    gtk_signal_connect (GTK_OBJECT (window), "delete_event",
                        GTK_SIGNAL_FUNC (delete_event), NULL);

    /* regoliamo la larghezza del bordo della finestra. */
    gtk_container_border_width (GTK_CONTAINER (window), 20);

    /* creiamo una tabella 2x2 */
    table = gtk_table_new (2, 2, TRUE);

    /* mettiamo la tabella nella finesta principale */
    gtk_container_add (GTK_CONTAINER (window), table);

    /*creiamo il primo bottone */
    button = gtk_button_new_with_label ("button 1");
    /* quando viene premuto il bottone, chiamiamo la funzione di ritorno
     * con un puntatore a "button 1"come argomento */
    gtk_signal_connect (GTK_OBJECT (button), "clicked",
              GTK_SIGNAL_FUNC (callback), (gpointer) "button 1");


    /* inseriamo il bottone 1 nel quadrante in alto a sinistra della tabella */
    gtk_table_attach_defaults (GTK_TABLE(table), button, 0, 1, 0, 1);

    gtk_widget_show (button);

    /* creiamo il secondo bottone */

    button = gtk_button_new_with_label ("button 2");

    /* quando si preme il bottone, chiamamo la funzione di ritorno
     * con un puntatore a "button 2"come argomento */
    gtk_signal_connect (GTK_OBJECT (button), "clicked",
              GTK_SIGNAL_FUNC (callback), (gpointer) "button 2");
    /* inseriamo il secondo bottone nel quadrate in alto a destra della tbella */
    gtk_table_attach_defaults (GTK_TABLE(table), button, 1, 2, 0, 1);

    gtk_widget_show (button);

    /* creiamo il botone "Quit" */
    button = gtk_button_new_with_label ("Quit");

    /* quando viene premuto questo bottone, chiamiamo la funzione "delete_event"
     * e si esce dal programma */
    gtk_signal_connect (GTK_OBJECT (button), "clicked",
                        GTK_SIGNAL_FUNC (delete_event), NULL);

    /* inseriamo il pulsante quit nelle due casele in basso della tabella */
    gtk_table_attach_defaults (GTK_TABLE(table), button, 0, 2, 1, 2);

    gtk_widget_show (button);

    gtk_widget_show (table);
    gtk_widget_show (window);

    gtk_main ();

    return 0;
}
</PRE>
</CODE></BLOCKQUOTE>
<P>
<HR NOSHADE>
<A HREF="gtk_tut_it-5.html">Avanti</A>
<A HREF="gtk_tut_it-3.html">Indietro</A>
<A HREF="gtk_tut_it.html#toc4">Indice</A>
</BODY>
</HTML>