LinuxFocus article number 303 http://linuxfocus.org

Özcan Güngör <ozcangungor(at)netscape.net> L'autore: Uso Linux dal 1997. Libertà, flessibilità e opensource. Queste sono le caratteristiche che mi piacciono. Tradotto in Italiano da: Alessandro Pellizzari <alex(at)neko.it>

Programmazione di GUI con GTK - parte 2 Premessa: In questo articolo discuteremo di box e tabelle. Con questi saremo in grado di posizionare i componenti nel giusto ordine dentro le finestre. Per poter comprendere questo articolo dovreste conoscere le seguenti caratteristiche del linguaggio C: Variabili Funzioni Puntatori Inoltre è consigliato leggere l'articolo precedente. _________________ _________________ _________________

Impacchettare Componenti nei Box

Impacchettare componenti significa posizionarli nel giusto ordine dentro le finestre. Uno dei metodi che GTK mette a disposizione è usando i box. L'idea principale dietro i box è di impacchettare i componenti in ordine verticale o orizzontale. Ci sono due tipi di box: box orizzontali e box verticali. Vediamo di spiegarli:

Box Orizzontali

In questo tipo di box i componenti vengono impacchettati orizzontalmente. La seguente funzione viene usata per creare un box orizzontale.

gtk_widget *box;
box=gtk_hbox_new(gboolean homogenous, gint spacing);

dove il parametro homogeneous viene usato per definire se i componenti vengono distribuiti in modo omogeneo o meno: se è TRUE i componenti si allargano in modo da avere una distanza uguale tra di loro, mentre se è FALSE vengono impacchettati fianco a fianco. spacing viene usato per definire lo spazio minimo tra i componenti.

Box Verticali

In questo tipo di box i componenti vengono impacchettati in verticale. La seguente funzione viene usata per creare un box verticale:

gtk_widget *box;
box=gtk_vbox_new(gboolean homogenous, gint spacing);

I parametri di questa funzione hanno lo stesso significato della funzione precedente.

Proprietà comuni dei Box

L'aggiunta di componenti può essere effettuata in due modi: il primo è:

gtk_box_pack_start(GtkBox *box,GtkWidget *child,
                  gboolean expand, gboolean fill, guint padding);

La funzione complementare a gtk_box_pack_start è gtk_box_pack_end:

gtk_box_pack_end(GtkBox *box,GtkWidget *child,
                gboolean expand, gboolean fill, guint padding);

Per inserire un box in una finestra usiamo la seguente funzione:

gtk_container_add (GtkContainer *container,GtkWidget *component);

gtk_container_add(GTK_CONTAINER(window),box);

gtk_box_set_homogeneous (GtkBox *box, gboolean homogenous);
gtk_box_set_spacing(GtkBox *box, gint spacing);

gtk_box_set_child_packing(GkBox *box,GtkWidget *shild,
       gboolean expand, gboolean  fill, guint padding,
       GtkPackType packingtype);

Per capire meglio quello che abbiamo spiegato, provate kutular.c.

Tabelle

Le tabelle, come nel codice HTML, ci aiutano a fissare i componenti in celle. Per poterlo fare è sufficiente creare una tabella con un numero sufficiente di righe e colonne. Quindi possiamo posizionare un componente in una cella o in un gruppo di celle (consentito solo se le celle sono affiancate). Per creare una tabella viene usata la seguente funzione:

GtkWidget *table;
GtkWidget* gtk_table_new(guint  row, guint column, gboolean homogenous);

Per aggiungere componenti a una tabella viene usala la seguente funzione:

void gtk_table_attach (GtkTable *table, GtkWidget *child,
         guint left_attach, guint left_attach, guint top_attach,
         guint bottom_attach, GtkAttachOptions xoptions,
         GtkAttachOptions yoptions, guint xpadding, guint ypadding);

xoptions e yoptions possono assumere tre diversi valori: GTK_FILL, GTK_EXPAND, GTK_SHRINK.
GTK_FILL fa in modo che il componente riempia la cella (o le celle). GTK_EXPAND fa in modo che venga centrato nella cella e GTK_SHRINK fa in modo che il componente venga ristretto alle dimensioni della cella se questa è più piccola. xoptions applica questi cambiamenti solo sull'asse x, mentre yoptions li applica solo all''asse y.

xpadding inserisce dello spazio a sinistra e a destra del componente lungo l'asse x mentre ypadding lo fa lungo l'asse y.

Ecco un codice di esempio:

#include <gtk/gtk.h>

void delete_event( GtkWidget *widget,GdkEvent  *event,gpointer data )
{
    gtk_main_quit ();
}

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

    gtk_init (&argc, &argv);

    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

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

    table = gtk_table_new (2, 2, TRUE);

    gtk_container_add (GTK_CONTAINER (window), table);

    button = gtk_button_new_with_label ("button 1");
    gtk_table_attach(GTK_TABLE(table), button, 0, 1, 0, 2,GTK_SHRINK,
                     GTK_SHRINK,0,0);
    gtk_widget_show (button);

    button = gtk_button_new_with_label ("button 2");
    gtk_table_attach (GTK_TABLE(table), button, 1, 2, 1, 2,
                      GTK_SHRINK,GTK_SHRINK,0,0);
    gtk_widget_show (button);

    button = gtk_button_new_with_label ("button 3");
    gtk_table_attach (GTK_TABLE(table), button, 1, 2, 0, 1,
                      GTK_SHRINK,GTK_SHRINK,0,0);
    gtk_widget_show (button);

    gtk_widget_show (table);
    gtk_widget_show (window);

    gtk_main ();

    return 0;
}

gtk_table_attach ha molti parametri, quindi una nuova funzione, più corta, è stata creata: gtk_table_attach_defaults. Questa esegue lo stesso compito ma con meno parametri.

void gtk_table_attach_defaults (GtkTable *table,GtkWidget *child,
                guint left_attach, guint right_attach, guint top_attach,
                guint bottom_attach);

La seguente funzione viene usata per cambiare il numero di righe e colonne in una tabella esistente:

void gtk_table_resize(GtkTable *table, guint rows, guint columns);

Usando le seguenti funzioni potete cambiare la spaziatura di una riga o di una colonna:

void gtk_table_set_row_spacing (GtkTable *table, guint row,
                               guint spacing);
void gtk_table_set_col_spacing (GtkTable *table, guint column,
                               guint spacing);

Le seguenti funzioni cambiano la spaziatura di intere righe o colonne:

void gtk_table_set_row_spacings (GtkTable *table, guint spacing);
void gtk_table_set_col_spacings (GtkTable *table, guint spacing);

Le seguenti funzioni cambiano il valore di homogeneous di una tabella esistente:

void gtk_table_set_homogeneous (GtkTable *table, gboolean homogenous);

Conclusioni

In questo articolo abbiamo imparato come impacchettare componenti e quindi abbiamo dato uno sguardo ad alcune funzioni per la modifica delle proprietà di box e tabelle. Sono sempre felice di ricevere domande, commenti e idee dai lettori. Mandatemi un'e-mail...

2005-01-14, generated by lfparser_pdf version 2.51