Avanti Indietro Indice

## 7. Alcuni Widget

## 7.1 L'Etichetta (Label)

Le etichette sono molto usate in GTK, e sono relativamente semplici. Le etichette non emettono segnali, dal momento che non hanno una finestra X a loro assegnata. Se avete la necessità di avere dei segnali o di fare delle operazioni di clipping, potete usare il widget EventBox.

Per creare una nuova etichetta, si usa:

> `

>     GtkWidget* gtk_label_new (char *str);

> `

In cui l'unico argomento è la stringa che si vuole sia mostrata.

Per cambiare il testo dell'etichetta dopo che è stata creata, si usa la funzione:

> `

>     void gtk_label_set (GtkLabel  *label,
>                         char      *str);

> `

in cui il primo argomento è l'etichetta creata in precedenza (di cui si fa il cast usando la macro GTK_LABEL()), mentre il secondo è la nuova stringa.

Nel caso, lo spazio necessario per la nuova stringa verrà regolato automaticamente.

Per ottenere la stringa corrente si usa:

> `

>     void gtk_label_get (GtkLabel  *label,
>                         char     **str);

> `

in cui il primo argomento è l'etichetta che avete creato, e il secondo è il valore di ritorno per la stringa.

## 7.2 Il Widget Suggerimenti (Tooltips)

I suggerimenti sono piccole stringhe di testo che spuntano quando lasciate il puntatore su un bottone o un altro widget per qualche secondo. Sono piuttosto semplici da usare, per cui ne darò la spiegazione senza corredarla di esempi. Se volede vedere un po' di codice, date un'occhiata al programma testgtk.c distribuito con GTK.

Con alcuni widget (per esempio con l'etichetta) i suggerimenti non funzionano.

La prima chiamata che si usa per creare un nuovo tooltip è la seguente. In una data funzione, è necessario chiamarla una sola volta: il `GtkTooltip` che viene restituito da questa funzione può essere usato per creare suggerimenti multipli.

> `

>     GtkTooltips *gtk_tooltips_new (void);

> `

Una volta creato un nuovo suggerimento e il widget su cui lo volete usare, basta usare la seguente chiamata per fare l'assegnazione:

> `

>     void gtk_tooltips_set_tip (GtkTooltips *tooltips,
>                                GtkWidget   *widget,
>                                const gchar *tip_text,
>                                const gchar *tip_private);

> `

Il primo argomento è il suggerimento che era già stato creato, che è seguito dal widget da cui volete che spunti il suggerimento e dal testo che volete venga mostrato. L'ultimo argomento può essere posto a NULL.

Ecco un piccolo esempio:

> `

>     GtkTooltips *tooltips;
>     GtkWidget *button;
>     ...
>     tooltips = gtk_tooltips_new ();
>     button = gtk_button_new_with_label ("button 1");
>     ...
>     gtk_tooltips_set_tips (tooltips, button, "This is button 1", NULL);

> `

Ci sono anche altre funzioni che si usano con i suggerimenti. Eccone una lista con una breve descrizione di quello che fanno.

> `

>     void gtk_tooltips_destroy    (GtkTooltips *tooltips);

> `

Distrugge un suggerimento esistente.

> `

>     void gtk_tooltips_enable     (GtkTooltips *tooltips);

> `

Abilita un gruppo di suggerimenti disbilitato.

> `

>     void gtk_tooltips_disable    (GtkTooltips *tooltips);

> `

Disabilita un gruppo di suggerimenti abilitato.

> `

>     void gtk_tooltips_set_delay  (GtkTooltips *tooltips,
>                                   gint         delay);

> `

Stabilisce quanti millisecondi si deve mantenere il puntatore sopra al widget prima che venga mostrato il suggerimento. Il valore di difetto è di 1000 millisecondi.

> `

>     void      gtk_tooltips_set_tips (GtkTooltips *tooltips,
>                                      GtkWidget   *widget,
>                                      gchar    *tips_text);

> `

Cambia il testo di un suggerimento già esistente.

> `

>     void gtk_tooltips_set_colors (GtkTooltips *tooltips,
>                                   GdkColor    *background,
>                                   GdkColor    *foreground);

> `

Assegna i colori di primo piano e di sfondo dei suggerimenti. (Non ho idea di come si specifichino i colori).

E questo è tutto riguardo alle funzioni relative ai suggerimenti. Più di quanto avreste mai voluto sapere :)

## 7.3 La Barra di Avanzamento (Progress Bar)

Le barre di avanzamento sono usate per mostrare lo stato di una operazione. Come potete vedere nel frammento di codice qui sotto, sono piuttosto semplici da usare. Ma prima vediamo come cominciare con la chiamata per creare una nuova progress bar.

> `

>     GtkWidget *gtk_progress_bar_new (void);

> `

Ora che la barra di avanzamento è stata creata, possiamo usarla..

> `

>     void gtk_progress_bar_update (GtkProgressBar *pbar, gfloat percentage);

> `

Il primo argomento è la barra di avanzamento su cui volete lavorare, e il secondo è la quantità 'completato', cioè la quantità di riempimento della progress bar fra 0 e 100% (un numero reale fra 0 e 1).

Le barre di avanzamento sono usate di solito con funzioni di timeout o altre di questo tipo (vedi alla sezione Timeouts, I/O and Idle Functions) per dare l'illusione del multitasking. Tutte usano la funzione gtk_progress_bar_update nello stesso modo.

Ecco un esempio di barra di avanzamento, in cui l'aggiornamento avviene usando dei timeout. Questo codice vi mostra anche come riinizializzare le barre di avanzamento.

> `

>     /* progressbar.c */

>     #include <gtk/gtk.h>

>     static int ptimer = 0;
>     int pstat = TRUE;

>     /* Questa funzione incrementa e aggiorna la barra di avanzamento, e la rimette
>        a zero se pstat è FALSE */
>     gint progress (gpointer data)
>     {
>         gfloat pvalue;

>         /* ottiene il valore corrente della status bar */
>         pvalue = GTK_PROGRESS_BAR (data)->percentage;

>         if ((pvalue >= 1.0) || (pstat == FALSE)) {
>             pvalue = 0.0;
>             pstat = TRUE;
>         }
>         pvalue += 0.01;

>         gtk_progress_bar_update (GTK_PROGRESS_BAR (data), pvalue);

>         return TRUE;
>     }

>     /* Questa funzione segnala la riinizializzazione della
>        barra di avanzamento */
>     void progress_r (void)
>     {
>         pstat = FALSE;
>     }

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

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

>         gtk_init (&argc, &argv);

>         window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

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

>         gtk_container_border_width (GTK_CONTAINER (window), 10);

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

>         label = gtk_label_new ("Progress Bar Example");
>         gtk_table_attach_defaults(GTK_TABLE(table), label, 0,2,0,1);
>         gtk_widget_show(label);
>         /* Crea una nuova barra di avanzamento, impacchettala nella tabella
>            e mostrala */
>         pbar = gtk_progress_bar_new ();
>         gtk_table_attach_defaults(GTK_TABLE(table), pbar, 0,2,1,2);
>         gtk_widget_show (pbar);

>         /* Attiva un timeout che gestisca l'aggiornamento automatico della barra */
>         ptimer = gtk_timeout_add (100, progress, pbar);

>         /* Questo bottone segnala alla barra che deve essere resettata */
>         button = gtk_button_new_with_label ("Reset");
>         gtk_signal_connect (GTK_OBJECT (button), "clicked",
>                             GTK_SIGNAL_FUNC (progress_r), NULL);
>         gtk_table_attach_defaults(GTK_TABLE(table), button, 0,1,2,3);
>         gtk_widget_show(button);

>         button = gtk_button_new_with_label ("Cancel");
>         gtk_signal_connect (GTK_OBJECT (button), "clicked",
>                             GTK_SIGNAL_FUNC (destroy), NULL);

>         gtk_table_attach_defaults(GTK_TABLE(table), button, 1,2,2,3);
>         gtk_widget_show (button);

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

>         gtk_main ();

>         return 0;
>     }

> `

In questo programmino ci sono quattro aree che riguardano il modo di uso generale delle Barre di Avanzamento; le vediamo ora nell'ordine.

> `

>     pbar = gtk_progress_bar_new ();

> `

Questo codice crea una nuova barra ciamata pbar.

> `

>     ptimer = gtk_timeout_add (100, progress, pbar);

> `

Questo codice usa dei timeout per abilitare degli intervalli di tempo uguali. Per usare le barre di avanzamento non è però necessario servirsi di timeout.

> `

>     pvalue = GTK_PROGRESS_BAR (data)->percentage;

> `

Qui si assegna a pvalue il valore corrente della percentuale di avanzamento.

> `

>     gtk_progress_bar_update (GTK_PROGRESS_BAR (data), pvalue);

> `

Infine, questo codice aggiorna la barra di avanzamento con il valore di pvalue.

Questo è tutto quanto c'è da sapere sulle barre di avanzamento, divertitevi.

## 7.4 Dialoghi

Il widget ``Dialogo'' è molto semplice: si tratta in realtà di una finestra con alcuni elementi pre-impacchettati. La struttura di un dialogo è la seguente:

> `

>     struct GtkDialog
>     {
>           GtkWindow window;

>           GtkWidget *vbox;
>           GtkWidget *action_area;
>     };

> `

Come potete vedere, crea semplicemente una finestra vi inserisce una vbox in cima, poi un separatore e infine una hbox come ``area di azione''.

Un Dialogo può essere utilizzato per messaggi per l'utente e altri scopi simili. E' un widget molto essenziale, che ha una sola funzione, e precisamente:

> `

>     GtkWidget* gtk_dialog_new (void);

> `

Per cui, per creare una nuova finestra di dialogo, uate:

> `

>     GtkWidget *window;
>     window = gtk_dialog_new ();

> `

Questa funzione crea una finestra di dialogo, dopodiché sta a voi utilizzarla. Potete mettere un bottone nella action_area facendo qualcosa del tipo:

> `

>     button = ...
>     gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button,
>                         TRUE, TRUE, 0);
>     gtk_widget_show (button);

> `

Potreste anche aggiungere, ad esempio, un'etichetta all'area della vbox, con qualcosa di questo genere:

> `

>     label = gtk_label_new ("Dialogs are groovy");
>     gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), label, TRUE,
>                         TRUE, 0);
>     gtk_widget_show (label);

> `

Per provare a usare una finestra di dialogo, potreste provare a mettere due bottoni nella action_area, per esempio un bottone ``Cancella'' ed un bottone ``OK'' e un'etichetta nella vbox che chieda qualcosa all'utente o segnali un errore. Poi potreste collegare un diverso segnale a ciascun bottone ed eseguire l'operazione che l'utente che viene scelta dall'utente.

## 7.5 Le Pixmap

Le Pixmap sono strutture dati che contengono immagini. Queste immagini possono poi essere utilizzate in varie occasioni, per esempio come icone sul desktop X-Window o come cusori. Una bitmap è una pixmap a due colori.

Per usare una pixmap in GTK, dobbiamo in primo luogo creare una struttura GdkPixmap utilizzando le routine disponibili nello strato GDK. Una Pixmap può essere creata a partire da dati presenti in memoria o letti da un file. Vedremo ora una ad una le chiamate utilizzate per creare una pixmap.

> `

>     GdkPixmap *gdk_bitmap_create_from_data( GdkWindow *window,
>                                             gchar     *data,
>                                             gint      width,
>                                             gint      height );

> `

Si usa questa routine per creare una pixmap ad un solo piano (2 colori) da dati disponibili in memoria. Ogni bit nei dati indica lo stato acceso o spento di un pixel. L'altezza (height) e la larghezza (width) sono espresse in pixel. GdkWindow è un puntatore alla finestra corrente, dal momento che le risorse di una pixmap hanno significato solo nel contesto dello schermo in cui deve essere mostrata.

> `

>     GdkPixmap* gdk_pixmap_create_from_data( GdkWindow  *window,
>                                             gchar      *data,
>                                             gint        width,
>                                             gint        height,
>                                             gint        depth,
>                                             GdkColor   *fg,
>                                             GdkColor   *bg );

> `

Questa è usata per creare una pixmap con la profondità data (depth, ossia numero di colori) usando i dati specificati. fg e bg indicano i colori da usare per il primo piano e per lo sfondo.

> `

>     GdkPixmap* gdk_pixmap_create_from_xpm( GdkWindow  *window,
>                                            GdkBitmap **mask,
>                                            GdkColor   *transparent_color,
>                                            const gchar *filename );

> `

Il formato XPM è una rappresentazione di pixmap leggibile per X Window. E' una rappresentazione molto diffusa, e sono disponibili parecchi programmi per creare immagini in questo formato. Il file specificato da ``filename'' deve contenere un'immagine in questo formato, che viene caricato nella struttura pixmap. La maschera (mask) specifica quali pixel della pixmap devono essere opachi. Tutti gli altri pixel sono colorati usando il colore specificato da transparent_color. Più sotto mostreremo un esempio di uso di questa funzione.

> `

>     GdkPixmap* gdk_pixmap_create_from_xpm_d (GdkWindow  *window,
>                                              GdkBitmap **mask,
>                                              GdkColor   *transparent_color,
>                                              gchar     **data);

> `

Si possono incorporare piccole immagini all'interno di un programma sotto forma di dati in formato XPM. In questo modo, invece di leggerli da un file, si possono usare questi dati per creare una pixmap. Un esempio di questo tipo di dati è

> `

>     /* XPM */
>     static const char * xpm_data[] = {
>     "16 16 3 1",
>     "       c None",
>     ".      c #000000000000",
>     "X      c #FFFFFFFFFFFF",
>     "                ",
>     "   ......       ",
>     "   .XXX.X.      ",
>     "   .XXX.XX.     ",
>     "   .XXX.XXX.    ",
>     "   .XXX.....    ",
>     "   .XXXXXXX.    ",
>     "   .XXXXXXX.    ",
>     "   .XXXXXXX.    ",
>     "   .XXXXXXX.    ",
>     "   .XXXXXXX.    ",
>     "   .XXXXXXX.    ",
>     "   .XXXXXXX.    ",
>     "   .........    ",
>     "                ",
>     "                "};

> `

> `

>     void gdk_pixmap_destroy( GdkPixmap  *pixmap );

> `

Quando abbiamo finito di usare una pixmap e pensiamo di non doverla riutilizzare presto, è una buona idea liberare queste risorse usando la funzione dk_pixmap_destroy. Le pixmap devono essere considerate una risorsa preziosa.

Quando abbiamo creato una pixmap, possiamo mostrarla come un widget GTK. E' necessario creare un widget pixmap che contenga una pixmap GDK. Questa operazione viene compiuta usando

> `

>     GtkWidget* gtk_pixmap_new( GdkPixmap  *pixmap,
>                                GdkBitmap  *mask );

> `

Le altre chiamate per i widget pixmap sono

> `

>     guint gtk_pixmap_get_type( void );
>     void  gtk_pixmap_set( GtkPixmap  *pixmap,
>                           GdkPixmap  *val,
>                           GdkBitmap  *mask);
>     void  gtk_pixmap_get( GtkPixmap  *pixmap,
>                           GdkPixmap **val,
>                           GdkBitmap **mask);

> `

La funzione gtk_pixmap_set viene usata per cambiare la pixmap che viene gestita correntemente dal widget. gtk_pixmap_set is used to change the pixmap that the widget is currently managing. ``val'' è la pixmap che è stata creata usando il GDK. Segue un esempio di uso di una pixmap in un bottone.

> `

>     /* pixmap.c */
>     #include <gtk/gtk.h>

>     /* dat XPM dell'icona Apri File */
>     static const char * xpm_data[] = {
>     "16 16 3 1",
>     "       c None",
>     ".      c #000000000000",
>     "X      c #FFFFFFFFFFFF",
>     "                ",
>     "   ......       ",
>     "   .XXX.X.      ",
>     "   .XXX.XX.     ",
>     "   .XXX.XXX.    ",
>     "   .XXX.....    ",
>     "   .XXXXXXX.    ",
>     "   .XXXXXXX.    ",
>     "   .XXXXXXX.    ",
>     "   .XXXXXXX.    ",
>     "   .XXXXXXX.    ",
>     "   .XXXXXXX.    ",
>     "   .XXXXXXX.    ",
>     "   .........    ",
>     "                ",
>     "                "};

>     /* quando invocata (con il segnale delete_event), termina l'applicazione. */
>     void close_application( GtkWidget *widget, gpointer data ) {
>         gtk_main_quit();
>     }

>     /* invocata se il bottone è clickato. Stampa semplicemente un messaggio */
>     void button_clicked( GtkWidget *widget, gpointer data ) {
>         printf( "button clicked\n" );
>     }

>     int main( int argc, char *argv[] )
>     {
>         /* i widget sono memorizzati nel tipo GtkWidget */
>         GtkWidget *window, *pixmapwid, *button;
>         GdkPixmap *pixmap;
>         GdkBitmap *mask;
>         GtkStyle *style;

>         /* crea la finestra principale, e collega il segnale delete_event
>            alla terminazione dell'applicazione */
>         gtk_init( &argc, &argv );
>         window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
>         gtk_signal_connect( GTK_OBJECT (window), "delete_event",
>                             GTK_SIGNAL_FUNC (close_application), NULL );
>         gtk_container_border_width( GTK_CONTAINER (window), 10 );
>         gtk_widget_show( window );

>         /* la pixmap proviene da gdk */
>         style = gtk_widget_get_style( window );
>         pixmap = gdk_pixmap_create_from_xpm_d( window->window,  &mask,
>                                                &style->bg[GTK_STATE_NORMAL],
>                                                (gchar **)xpm_data );

>         /* un widget pixmap per contenere la pixmap */
>         pixmapwid = gtk_pixmap_new( pixmap, mask );
>         gtk_widget_show( pixmapwid );

>         /* un bottone per contenere il widget pixmap */
>         button = gtk_button_new();
>         gtk_container_add( GTK_CONTAINER(button), pixmapwid );
>         gtk_container_add( GTK_CONTAINER(window), button );
>         gtk_widget_show( button );

>         gtk_signal_connect( GTK_OBJECT(button), "clicked",
>                             GTK_SIGNAL_FUNC(button_clicked), NULL );

>         /* mostra la finestra */
>         gtk_main ();

>         return 0;
>     }

> `

Per caricare una pixmap da un file XPM chiamato icon0.xpm che si trova nella direttorio corrente, avremmo creato la pixmap in questo modo:

> `

>         /* carica una pixmap da un file */
>         pixmap = gdk_pixmap_create_from_xpm( window->window, &mask,
>                                              &style->bg[GTK_STATE_NORMAL],
>                                              "./icon0.xpm" );
>         pixmapwid = gtk_pixmap_new( pixmap, mask );
>         gtk_widget_show( pixmapwid );
>         gtk_container_add( GTK_CONTAINER(window), pixmapwid );

> `

Usare le Sagome

Uno degli svantaggi di usare le pixmap è costituito dal fatto che l'oggetto mostrato è sempre rettangolare, a prescindere dall'immagine. Ci piacerebbe invece poter crare dei desktop e delle immagini con forme più naturali. Per esempio, per l'interfaccia di un gioco, potremmo volere avere dei pulsanti circolari. Il modo per ottenere questo effetto è di usare delle finestre sagomate.

Una finestra sagomata è semplicemente una pixmap in cui i pixel dello sfondo sono trasparenti. In questo modo, se l'immagine di sfondo è multicolore, possiamo evitare di sovrascriverla con un bordo rettangolare attorno all'icona. Il prossimo esempio mostra una carriola sul desktop.

> `

>     /* wheelbarrow.c */
>     #include <gtk/gtk.h>

>     /* XPM */
>     static char * WheelbarrowFull_xpm[] = {
>     "48 48 64 1",
>     "       c None",
>     ".      c #DF7DCF3CC71B",
>     "X      c #965875D669A6",
>     "o      c #71C671C671C6",
>     "O      c #A699A289A699",
>     "+      c #965892489658",
>     "@      c #8E38410330C2",
>     "#      c #D75C7DF769A6",
>     "$      c #F7DECF3CC71B",
>     "%      c #96588A288E38",
>     "&      c #A69992489E79",
>     "*      c #8E3886178E38",
>     "=      c #104008200820",
>     "-      c #596510401040",
>     ";      c #C71B30C230C2",
>     ":      c #C71B9A699658",
>     ">      c #618561856185",
>     ",      c #20811C712081",
>     "<      c #104000000000",
>     "1      c #861720812081",
>     "2      c #DF7D4D344103",
>     "3      c #79E769A671C6",
>     "4      c #861782078617",
>     "5      c #41033CF34103",
>     "6      c #000000000000",
>     "7      c #49241C711040",
>     "8      c #492445144924",
>     "9      c #082008200820",
>     "0      c #69A618611861",
>     "q      c #B6DA71C65144",
>     "w      c #410330C238E3",
>     "e      c #CF3CBAEAB6DA",
>     "r      c #71C6451430C2",
>     "t      c #EFBEDB6CD75C",
>     "y      c #28A208200820",
>     "u      c #186110401040",
>     "i      c #596528A21861",
>     "p      c #71C661855965",
>     "a      c #A69996589658",
>     "s      c #30C228A230C2",
>     "d      c #BEFBA289AEBA",
>     "f      c #596545145144",
>     "g      c #30C230C230C2",
>     "h      c #8E3882078617",
>     "j      c #208118612081",
>     "k      c #38E30C300820",
>     "l      c #30C2208128A2",
>     "z      c #38E328A238E3",
>     "x      c #514438E34924",
>     "c      c #618555555965",
>     "v      c #30C2208130C2",
>     "b      c #38E328A230C2",
>     "n      c #28A228A228A2",
>     "m      c #41032CB228A2",
>     "M      c #104010401040",
>     "N      c #492438E34103",
>     "B      c #28A2208128A2",
>     "V      c #A699596538E3",
>     "C      c #30C21C711040",
>     "Z      c #30C218611040",
>     "A      c #965865955965",
>     "S      c #618534D32081",
>     "D      c #38E31C711040",
>     "F      c #082000000820",
>     "                                                ",
>     "          .XoO                                  ",
>     "         +@#$%o&                                ",
>     "         *=-;#::o+                              ",
>     "           >,<12#:34                            ",
>     "             45671#:X3                          ",
>     "               +89<02qwo                        ",
>     "e*                >,67;ro                       ",
>     "ty>                 459@>+&&                    ",
>     "$2u+                  ><ipas8*                  ",
>     "%$;=*                *3:.Xa.dfg>                ",
>     "Oh$;ya             *3d.a8j,Xe.d3g8+             ",
>     " Oh$;ka          *3d$a8lz,,xxc:.e3g54           ",
>     "  Oh$;kO       *pd$%svbzz,sxxxxfX..&wn>         ",
>     "   Oh$@mO    *3dthwlsslszjzxxxxxxx3:td8M4       ",
>     "    Oh$@g& *3d$XNlvvvlllm,mNwxxxxxxxfa.:,B*     ",
>     "     Oh$@,Od.czlllllzlmmqV@V#V@fxxxxxxxf:%j5&   ",
>     "      Oh$1hd5lllslllCCZrV#r#:#2AxxxxxxxxxcdwM*  ",
>     "       OXq6c.%8vvvllZZiqqApA:mq:Xxcpcxxxxxfdc9* ",
>     "        2r<6gde3bllZZrVi7S@SV77A::qApxxxxxxfdcM ",
>     "        :,q-6MN.dfmZZrrSS:#riirDSAX@Af5xxxxxfevo",
>     "         +A26jguXtAZZZC7iDiCCrVVii7Cmmmxxxxxx%3g",
>     "          *#16jszN..3DZZZZrCVSA2rZrV7Dmmwxxxx&en",
>     "           p2yFvzssXe:fCZZCiiD7iiZDiDSSZwwxx8e*>",
>     "           OA1<jzxwwc:$d%NDZZZZCCCZCCZZCmxxfd.B ",
>     "            3206Bwxxszx%et.eaAp77m77mmmf3&eeeg* ",
>     "             @26MvzxNzvlbwfpdettttttttttt.c,n&  ",
>     "             *;16=lsNwwNwgsvslbwwvccc3pcfu<o    ",
>     "              p;<69BvwwsszslllbBlllllllu<5+     ",
>     "              OS0y6FBlvvvzvzss,u=Blllj=54       ",
>     "               c1-699Blvlllllu7k96MMMg4         ",
>     "               *10y8n6FjvllllB<166668           ",
>     "                S-kg+>666<M<996-y6n<8*          ",
>     "                p71=4 m69996kD8Z-66698&&        ",
>     "                &i0ycm6n4 ogk17,0<6666g         ",
>     "                 N-k-<>     >=01-kuu666>        ",
>     "                 ,6ky&      &46-10ul,66,        ",
>     "                 Ou0<>       o66y<ulw<66&       ",
>     "                  *kk5       >66By7=xu664       ",
>     "                   <<M4      466lj<Mxu66o       ",
>     "                   *>>       +66uv,zN666*       ",
>     "                              566,xxj669        ",
>     "                              4666FF666>        ",
>     "                               >966666M         ",
>     "                                oM6668+         ",
>     "                                  *4            ",
>     "                                                ",
>     "                                                "};

>     /* quando invocata (con il segnale delete_event), termina l'applicazione. */
>     void close_application( GtkWidget *widget, gpointer data ) {
>         gtk_main_quit();
>     }

>     int main (int argc, char *argv[])
>     {
>         /* il tipo di dato per i widget è GtkWidget */
>         GtkWidget *window, *pixmap, *fixed;
>         GdkPixmap *gdk_pixmap;
>         GdkBitmap *mask;
>         GtkStyle *style;
>         GdkGC *gc;

>         /* crea la finestra principale e collega il segnale delete_event per
>            terminare l'applicazione. Notare che non mettiamo un titolo
>            alla finestra. */
>         gtk_init (&argc, &argv);
>         window = gtk_window_new( GTK_WINDOW_POPUP );
>         gtk_signal_connect (GTK_OBJECT (window), "delete_event",
>                             GTK_SIGNAL_FUNC (close_application), NULL);
>         gtk_widget_show (window);

>         /* ora occupiamoci della pixmap e del widget pixmap */
>         style = gtk_widget_get_default_style();
>         gc = style->black_gc;
>         gdk_pixmap = gdk_pixmap_create_from_xpm_d( window->window, &mask,
>                                                  &style->bg[GTK_STATE_NORMAL],
>                                                  WheelbarrowFull_xpm );
>         pixmap = gtk_pixmap_new( gdk_pixmap, mask );
>         gtk_widget_show( pixmap );

>         /* Per mostrare la pixmap, usiamo un widget "fixed" in cui metterla */
>         fixed = gtk_fixed_new();
>         gtk_widget_set_usize( fixed, 200, 200 );
>         gtk_fixed_put( GTK_FIXED(fixed), pixmap, 0, 0 );
>         gtk_container_add( GTK_CONTAINER(window), fixed );
>         gtk_widget_show( fixed );

>         /* Questa maschera tutto tranne l'immagine stessa */
>         gtk_widget_shape_combine_mask( window, mask, 0, 0 );

>         /* mostra la finestra */
>         gtk_widget_set_uposition( window, 20, 400 );
>         gtk_widget_show( window );
>         gtk_main ();

>         return 0;
>     }

> `

Per rendere sensibile l'immagine della carriola, potremmo collegare il segnale di pressione del bottone in modo che venga compiuta una certa azione. Le prossime linee renderebbero l'immagine sensibile alla pressione di un bottone del mouse che fa sì che l'applicazione termini.

> `

>     gtk_widget_set_events( window,
>                            gtk_widget_get_events( window ) |
>                            GDK_BUTTON_PRESS_MASK );

>     gtk_signal_connect( GTK_OBJECT(window), "button_press_event",
>                         GTK_SIGNAL_FUNC(close_application), NULL );

> `

## 7.6 Righelli

I widget righello vengono usati per indicare la posizione del pontatore del mouse in una certa finestra. Una finestra può cioé avere un righello orizzontale che si estende per tutta la sua ampiezza e un righello verticale che ne comprende l'altezza. Un piccolo triangolo sui rghelli indica la posizione esatta del puntatore relativamente ai righelli.

I righelli devono essere in primo luogo creati. I righlli orizzontali e verticali vengono creati usando

> `

>     GtkWidget *gtk_hruler_new(void);    /* horizontal ruler */
>     GtkWidget *gtk_vruler_new(void);    /* vertical ruler   */

> `

Una volta che che si è creato il righello, si può l'unità di misura. Le unità di misura possono essere GTK_PIXELS, GTK_INCHES oppure GTK_CENTIMETERS. Ciò viene stabilito usando

> `

>     void gtk_ruler_set_metric( GtkRuler        *ruler,
>                                GtkMetricType   metric );

> `

La misura predefinita è GTK_PIXELS.

> `

>     gtk_ruler_set_metric( GTK_RULER(ruler), GTK_PIXELS );

> `

Altre caratteritiche importanti di un righello sono il modo in cui vengono segnate le tacche delle unità di misura e dove viene posto inizialmente l'indicatore di posizione. Questi vengono stabiliti usando

> `

>     void  gtk_ruler_set_range  (GtkRuler       *ruler,
>                                 gfloat          lower,
>                                 gfloat          upper,
>                                 gfloat          position,
>                                 gfloat          max_size);

> `

Gli argomenti lower e upper definiscono l'estensione del righello, e max_size rappresenta il numero massimo che verrà mostrato. Position definisce l posizione iniziale dell'indicatore del puntatore all'interno del righello.

Quindi, un righello che può stare su una finestra di 800 pixel sarà:

> `

>     gtk_ruler_set_range( GTK_RULER(vruler), 0, 800, 0, 800);

> `

Sul righello saranno presenti dei segni da 0 a 800, con un numero ogni 100 pixel. Se avessimo invece voluto che il righello fosse andato da 7 a 16, avremmo scritto:

> `

>     gtk_ruler_set_range( GTK_RULER(vruler), 7, 16, 0, 20);

> `

L'indicatore sul righello è un piccolo segno triangolare che indica la posizione del puntatore rispetto al righello. Se il righello viene usato per seguire il movimento del mouse, il segnale di motion_notify_event dovrebbe venir connesso al metodo motion_notify_event del righello. Per seguire tutti i movimenti del mouse all'interno dell'area di una finestra, useremmo:

> `

>     #define EVENT_METHOD(i, x) GTK_WIDGET_CLASS(GTK_OBJECT(i)->klass)->x

>     gtk_signal_connect_object( GTK_OBJECT(area), "motion_notify_event",
>              (GtkSignalFunc)EVENT_METHOD(ruler, motion_notify_event),
>              GTK_OBJECT(ruler) );

> `

L'esempio seguente crea un'area di disegno con un reghello orizzontale nella parte superiore e un righello verticale nella parte sinistra. Le dimensioni di questa area di disegno sono di 600 e 400 pixel risettivamente per la larghezza e per l'altezza. Il righello orizzontale va da 7 a 13 con una tacca ogni 100 pixel, mentre quello verticale va da 0 a 400, ancora con una tacca ogni 100 pixel. La sistemazione dell'area di disegno e dei righelli viene fatta usando una tabella.

> `

>     /* rulers.c */

>     #include <gtk/gtk.h>

>     #define EVENT_METHOD(i, x) GTK_WIDGET_CLASS(GTK_OBJECT(i)->klass)->x

>     #define XSIZE  600
>     #define YSIZE  400

>     /* il controllo raggiunge questa routine quando si preme il bottone close
>      */
>     void close_application( GtkWidget *widget, gpointer data ) {
>         gtk_main_quit();
>     }

>     /* la routine principale
>      */
>     int main( int argc, char *argv[] ) {
>         GtkWidget *window, *table, *area, *hrule, *vrule;

>         /* inizializziamo gtk e creiamo la finestra principale */
>         gtk_init( &argc, &argv );

>         window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
>         gtk_signal_connect (GTK_OBJECT (window), "delete_event",
>                 GTK_SIGNAL_FUNC( close_application ), NULL);
>         gtk_container_border_width (GTK_CONTAINER (window), 10);

>         /* creiamo una tabella in cui mettere righelli e area di disegno */
>         table = gtk_table_new( 3, 2, FALSE );
>         gtk_container_add( GTK_CONTAINER(window), table );

>         area = gtk_drawing_area_new();
>         gtk_drawing_area_size( (GtkDrawingArea *)area, XSIZE, YSIZE );
>         gtk_table_attach( GTK_TABLE(table), area, 1, 2, 1, 2,
>                           GTK_EXPAND|GTK_FILL, GTK_FILL, 0, 0 );
>         gtk_widget_set_events( area, GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK );

>         /* Il righello orizzontale va nella parte superiore. Quando il mouse si muove
>          * nell'area di disegno, si passa un motion_notify_event al gestore appropriato
>          * per il righello. */

>         hrule = gtk_hruler_new();
>         gtk_ruler_set_metric( GTK_RULER(hrule), GTK_PIXELS );
>         gtk_ruler_set_range( GTK_RULER(hrule), 7, 13, 0, 20 );
>         gtk_signal_connect_object( GTK_OBJECT(area), "motion_notify_event",
>                                    (GtkSignalFunc)EVENT_METHOD(hrule, motion_notify_event),
>                                    GTK_OBJECT(hrule) );
>         /*  GTK_WIDGET_CLASS(GTK_OBJECT(hrule)->klass)->motion_notify_event, */
>         gtk_table_attach( GTK_TABLE(table), hrule, 1, 2, 0, 1,
>                           GTK_EXPAND|GTK_SHRINK|GTK_FILL, GTK_FILL, 0, 0 );

>         /* Il righello verticale va nella parte sinistra.  Quando il mouse si muove
>          * nell'area di disegno, si passa un motion_notify_event al gestore appropriato
>          * per il righello. */

>         vrule = gtk_vruler_new();
>         gtk_ruler_set_metric( GTK_RULER(vrule), GTK_PIXELS );
>         gtk_ruler_set_range( GTK_RULER(vrule), 0, YSIZE, 10, YSIZE );
>         gtk_signal_connect_object( GTK_OBJECT(area), "motion_notify_event",
>                                    (GtkSignalFunc)
>                                       GTK_WIDGET_CLASS(GTK_OBJECT(vrule)->klass)-motion_notify_event,
>                                    GTK_OBJECT(vrule) );
>         gtk_table_attach( GTK_TABLE(table), vrule, 0, 1, 1, 2,
>                           GTK_FILL, GTK_EXPAND|GTK_SHRINK|GTK_FILL, 0, 0 );

>         /* ora mostriamo tutto quanto */
>         gtk_widget_show( area );
>         gtk_widget_show( hrule );
>         gtk_widget_show( vrule );
>         gtk_widget_show( table );
>         gtk_widget_show( window );
>         gtk_main();

>         return 0;
>     }

> `

## 7.7 Barre di Stato (Statusbar)

Le barre di stato sono dei semplici widget usati per mostrare messaggi di test. Hanno la caratteristica di mantenere uno stack dei messggi che vi vengono mostrati, cosiccheé rimuovendo il messaggio corrente fa sì che torni ad essere mostrato il messaggio precedente..

Per permettere a parti diverse di una stessa applicazione di usare la stessa barra di stato per mostrare messaggi, questo widget emette degli 'Identificatori di Contesto' che vengono usati per identificare i diversi 'utenti'. Quello che viene mostrato è sempre il messaggio che si trova in cima allo stack, a prescindere in quale contesto si trovi. I messaggi vengono immagazzinati secondo l'ordine LIFO, e non secondo l'ordine stabilito dal contesto.

Una barra di stato viene creata con una chiamata a:

> `

>     GtkWidget* gtk_statusbar_new (void);

> `

Per richiedere un nuovo identificatore di contesto, si usa una chiamata alla seguente funzione con una breve descrizione testuale:

> `

>     guint gtk_statusbar_get_context_id (GtkStatusbar *statusbar,
>                                         const gchar  *context_description);

> `

Le seguenti sono tre funzioni che possono operare sulle barre di stato:

> `

>     guint       gtk_statusbar_push           (GtkStatusbar *statusbar,
>                                              guint          context_id,
>                                              gchar         *text);

>     void       gtk_statusbar_pop            (GtkStatusbar *statusbar)
>                                              guint         context_id);
>     void       gtk_statusbar_remove         (GtkStatusbar *statusbar,
>                                              guint         context_id,
>                                              guint         message_id);

> `

La prima, gtk_statusbar_push, viene usata per aggiungere un nuovo messaggio alla barra di stato. Questa restituisce un identificatore di messaggio, che può essere passato successivamente alla funzione gtk_statusbar_remove per rimuovere dallo stack il messggio con identificatore di messaggio e di contesto dati.

La funzione gtk_statusbar_pop rimuove il messaggio che si trova in cima allo stack avente un dato identificatore di contesto.

Nel seguente esempio si crea una barra di stato e due bottoni, uno per mettere elementi sulla barra di stato e l'altro per riuovere l'ultimo elemento..

> `

>     /* statusbar.c */

>     #include <gtk/gtk.h>
>     #include <glib.h>

>     GtkWidget *status_bar;

>     void push_item (GtkWidget *widget, gpointer data)
>     {
>       static int count = 1;
>       char buff[20];

>       g_snprintf(buff, 20, "Item %d", count++);
>       gtk_statusbar_push( GTK_STATUSBAR(status_bar), (guint) &data, buff);

>       return;
>     }

>     void pop_item (GtkWidget *widget, gpointer data)
>     {
>       gtk_statusbar_pop( GTK_STATUSBAR(status_bar), (guint) &data );
>       return;
>     }

>     int main (int argc, char *argv[])
>     {

>         GtkWidget *window;
>         GtkWidget *vbox;
>         GtkWidget *button;

>         int context_id;

>         gtk_init (&argc, &argv);

>         /* creazione di una nuova finestra */
>         window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
>         gtk_widget_set_usize( GTK_WIDGET (window), 200, 100);
>         gtk_window_set_title(GTK_WINDOW (window), "GTK Statusbar Example");
>         gtk_signal_connect(GTK_OBJECT (window), "delete_event",
>                            (GtkSignalFunc) gtk_exit, NULL);

>         vbox = gtk_vbox_new(FALSE, 1);
>         gtk_container_add(GTK_CONTAINER(window), vbox);
>         gtk_widget_show(vbox);

>         status_bar = gtk_statusbar_new();
>         gtk_box_pack_start (GTK_BOX (vbox), status_bar, TRUE, TRUE, 0);
>         gtk_widget_show (status_bar);

>         context_id = gtk_statusbar_get_context_id( GTK_STATUSBAR(status_bar), "Statusbar example");

>         button = gtk_button_new_with_label("push item");
>         gtk_signal_connect(GTK_OBJECT(button), "clicked",
>             GTK_SIGNAL_FUNC (push_item), &context_id);
>         gtk_box_pack_start(GTK_BOX(vbox), button, TRUE, TRUE, 2);
>         gtk_widget_show(button);

>         button = gtk_button_new_with_label("pop last item");
>         gtk_signal_connect(GTK_OBJECT(button), "clicked",
>             GTK_SIGNAL_FUNC (pop_item), &context_id);
>         gtk_box_pack_start(GTK_BOX(vbox), button, TRUE, TRUE, 2);
>         gtk_widget_show(button);

>         /* la finestra va sempre mostrata come ultimo passo, in modo che venga
>          * sullo schermo tutta in una volta. */
>         gtk_widget_show(window);

>         gtk_main ();

>         return 0;
>     }

> `

## 7.8 Inserimento di testo

Questo widget permette diinserire e mostrare del testo in una casella contenente una sola linea. Il testo può essere assegnato con chiamate di funzione che permettono a nuovo testo di sostituire, seguire o precedere il contenuto corrente del widget di inserimento testo.

Per la creazione di un inserimento di testo, sono disponibili due funzioni:

> `

>     GtkWidget* gtk_entry_new (void);

>     GtkWidget* gtk_entry_new_with_max_length (guint16 max);

> `

La prima crea solamente un inserimento di testo, mentre la seconda lo crea imponendo un limite alla lunghezza del testo inseribile..

Per cambiaere il testo che si trova correntemente nel widget, sono disponibili diverse funzioni.

> `

>     void gtk_entry_set_text       (GtkEntry    *entry,
>                                    const gchar *text);
>     void gtk_entry_append_text    (GtkEntry    *entry,
>                                    const gchar *text);
>     void gtk_entry_prepend_text   (GtkEntry    *entry,
>                                    const gchar *text);

> `

La funzione gtk_entry_set_text assegna il contenuto del widget di inserimento, sostituendo il contenuto corrente. Le funzioni gtk_entry_append_text e gtk_entry_prepend_text permettono di antemporre o posporre un testo al testo corrente..

La prossima funzione permette di stabilire il punto di inserimento.

> `

>     void gtk_entry_set_position   (GtkEntry *entry,
>                                    gint     position);

> `

Usando la seguente funzione, è possibile estrarre il contenuto di un widget di inserimento. Ciò può essere utile nelle funzioni di ritorno come descritto più sotto.

> `

>     gchar* gtk_entry_get_text (GtkEntry *entry);

> `

Se non si vuole che qualcuno possa cambiare il contenuto di una entry sovrascrivendola, ne possiamo cambiare lo stato di "editabilità"..

> `

>     void gtk_entry_set_editable (GtkEntry *entry,
>                                  gboolean editable);

> `

Questa funzine ci permette di far passare un widget di inserimento dallo sato di editabile a quello di non editabile passando con l'argomento editable i valori TRUE o FALSE.

Se stiamo usando l'entry in un punto in cui non vogliamo che il testo sia visibile, per esempio quando si digita una password, possiamo usare la seguente funzione, che accetta un parametro booleano..

> `

>     void gtk_entry_set_visibility (GtkEntry *entry,
>                                    gboolean visible);

> `

Si può stabilire che una parte del testo risulti selezionata usado la seguente funzione. Si userà di solito questa possibilità dopo aver inserito nel widget un qualche valore predefinito, in modo che per l'utente sia semplice sostituirlo.

> `

>     void gtk_entry_select_region (GtkEntry *entry,
>                                   gint     start,
>                                   gint     end);

> `

Se vogliamo accorgerci del momento in cui l'utente ha inserito del testo, possiamo connettere il segnale `activate` o `changed`. `activate` viene reso attivo quando l'utente preme il tasto Enter mentre si trova nel widget. `changed` viene invece emesso ogni volta che il testo cambia, per esempio ogni volta che viene inserito o rimosso un carattere.

Il seguente codice mostra un esempio di utilizzo del widget di inserimento. .

> `

>     /* entry.c */

>     #include <gtk/gtk.h>

>     void enter_callback(GtkWidget *widget, GtkWidget *entry)
>     {
>       gchar *entry_text;
>       entry_text = gtk_entry_get_text(GTK_ENTRY(entry));
>       printf("Entry contents: %s\n", entry_text);
>     }

>     void entry_toggle_editable (GtkWidget *checkbutton,
>                                        GtkWidget *entry)
>     {
>       gtk_entry_set_editable(GTK_ENTRY(entry),
>                              GTK_TOGGLE_BUTTON(checkbutton)->active);
>     }

>     void entry_toggle_visibility (GtkWidget *checkbutton,
>                                        GtkWidget *entry)
>     {
>       gtk_entry_set_visibility(GTK_ENTRY(entry),
>                              GTK_TOGGLE_BUTTON(checkbutton)->active);
>     }

>     int main (int argc, char *argv[])
>     {

>         GtkWidget *window;
>         GtkWidget *vbox, *hbox;
>         GtkWidget *entry;
>         GtkWidget *button;
>         GtkWidget *check;

>         gtk_init (&argc, &argv);

>         /* creiamo una nuova finestra */
>         window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
>         gtk_widget_set_usize( GTK_WIDGET (window), 200, 100);
>         gtk_window_set_title(GTK_WINDOW (window), "GTK Entry");
>         gtk_signal_connect(GTK_OBJECT (window), "delete_event",
>                            (GtkSignalFunc) gtk_exit, NULL);

>         vbox = gtk_vbox_new (FALSE, 0);
>         gtk_container_add (GTK_CONTAINER (window), vbox);
>         gtk_widget_show (vbox);

>         entry = gtk_entry_new_with_max_length (50);
>         gtk_signal_connect(GTK_OBJECT(entry), "activate",
>                            GTK_SIGNAL_FUNC(enter_callback),
>                            entry);
>         gtk_entry_set_text (GTK_ENTRY (entry), "hello");
>         gtk_entry_append_text (GTK_ENTRY (entry), " world");
>         gtk_entry_select_region (GTK_ENTRY (entry),
>                                  0, GTK_ENTRY(entry)->text_length);
>         gtk_box_pack_start (GTK_BOX (vbox), entry, TRUE, TRUE, 0);
>         gtk_widget_show (entry);

>         hbox = gtk_hbox_new (FALSE, 0);
>         gtk_container_add (GTK_CONTAINER (vbox), hbox);
>         gtk_widget_show (hbox);

>         check = gtk_check_button_new_with_label("Editable");
>         gtk_box_pack_start (GTK_BOX (hbox), check, TRUE, TRUE, 0);
>         gtk_signal_connect (GTK_OBJECT(check), "toggled",
>                             GTK_SIGNAL_FUNC(entry_toggle_editable), entry);
>         gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(check), TRUE);
>         gtk_widget_show (check);

>         check = gtk_check_button_new_with_label("Visible");
>         gtk_box_pack_start (GTK_BOX (hbox), check, TRUE, TRUE, 0);
>         gtk_signal_connect (GTK_OBJECT(check), "toggled",
>                             GTK_SIGNAL_FUNC(entry_toggle_visibility), entry);
>         gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(check), TRUE);
>         gtk_widget_show (check);

>         button = gtk_button_new_with_label ("Close");
>         gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
>                                    GTK_SIGNAL_FUNC(gtk_exit),
>                                    GTK_OBJECT (window));
>         gtk_box_pack_start (GTK_BOX (vbox), button, TRUE, TRUE, 0);
>         GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
>         gtk_widget_grab_default (button);
>         gtk_widget_show (button);

>         gtk_widget_show(window);

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

> `

## 7.9 Selettori di Colore

Il widget selettore di colore è chiaramente un widget che permtte di scegliere interattivamente dei colori. Questo widget composto permette all'utente di selezionare un colore agendo su terne RGB (Red, Green, Blue) e HSV (Hue, Saturation, Value). Questo lo si può fare o agendo sui singoli valori tramite degli slider o inserendoli da tastiera, oppure selezionando direttamente il colore da un cerchio (valori H e S) e da una barra (valore V). Opzionalmente, è possibile anche stabilire il grado di trasparenza del colore. Il widget di selezione di colore emette per ora un solo segnale, "color_changed", che viene generato ogni volta che il colore corrente nel widget cambia, sia quando è l'utente a cambiarlo, sia quando viene modificato esplicitamente tramite una chiamata a gtk_color_selection_set_color().

Diamo ora un'occhiata a cosa ha da offrirci il widget di selezione di colore. Il widget è disponibile in due versioni, gtk_color_selection e gtk_color_selection_dialog:

> `

>     GtkWidget *gtk_color_selection_new(void);

> `

E' probabile che non userete questo costruttore direttamente. Infatti esso crea un widget GtkColorSelection orfano a cui dovrete assegnare un genitore voi stessi. Il widget GtkColorSelection eredita dal widget GtkVBox.

> `

>     GtkWidget *gtk_color_selection_dialog_new(const gchar *title);

> `

Questo è il più comune fra i costruttori di selettori di colore. Esso crea un GtkColorSelectionDialog, che eredita da GtkDialog. Esso consiste di un GtkFrame che contiene un widget GtkColorSelection, un GtkHSeparator e un GtkHBox con tre bottoni, "Ok", "Cancel" e "Help". Si arriva a questi bottoni accedendo ai widget "ok_button", "cancel_button" e "help_button" nella struttura GtkColorSelectionDialog (cioè (GTK_COLOR_SELECTION_DIALOG(colorseldialog)->ok_button).

> `

>     void gtk_color_selection_set_update_policy(GtkColorSelection *colorsel,
>                                                GtkUpdateType policy);

> `

Questa funzione stabilisce la politica di aggiornamento. Quella predefinita è GTK_UPDATE_CONTINOUS, che significa che il colore viene aggiornato continuamente mano a mano che l'utente trascina gli slider o preme e trascina il mouse nel cerchio della hue-saturation o nella relativa barra. Se si hanno problemi di prestazioni, si può decidere di usare la politica GTK_UPDATE_DISCONTINOUS o GTK_UPDATE_DELAYED.

> `

>     void gtk_color_selection_set_opacity(GtkColorSelection *colorsel,
>                                          gint use_opacity);

> `

Il widget di selezione di colore permette anche di variare l'opacità di un colore (conosciuta anche come canale alfa). Questa caratteristica è normalmente disabilitata. Chiamare la precedente funzione, con use_opacity uguale a TRUE abilita la manipolazione dell'opacità. Analogamente, mettendo use_opacity uguale a FALSE la disabiliterà.

> `

>     void gtk_color_selection_set_color(GtkColorSelection *colorsel,
>                                        gdouble *color);

> `

Si può assegnare esplicitamente un colore chiamando questa funzione con un puntatore ad un vettore di colori (gdouble). La lunghezza del vettore dipende dall'attivazione o meno del controllo dell'opacità. La posizione 0 contiene la componente rossa, la 1 \ il verde, la 2 il blu e la 3 contiene l'opacità (se questa \ attivata, come si è detto per gtk_color_selection_set_opacity()). Tutti i valori sono compresi fra 0.0 e 1.0.

> `

>     void gtk_color_selection_get_color(GtkColorSelection *colorsel,
>                                        gdouble *color);

> `

Questa funzione viene usata per ottenere il colore corrente, tipicamente quando si è ricevuto il segnale "color_changed". Color è un puntatore al vettore di colori da riempire. Vedi la descrizione di questo vettore nella funzione gtk_color_selection_set_color().

Ecco un semplice esempio che mostra l'uso di GtkColorSelectionDialog. Il programma mostra una finestra che contiene un'area di disegno. Cliccandoci sopra, si apre un dialogo di selezione di colore, e se si modifica il colore nella finestra di dialogo verrà cambiato anche il colore dello sfondo.

> `

>     #include <glib.h>
>     #include <gdk/gdk.h>
>     #include <gtk/gtk.h>

>     GtkWidget *colorseldlg = NULL;
>     GtkWidget *drawingarea = NULL;

>     /* gestore del cambiamento del colore */

>     void color_changed_cb (GtkWidget *widget, GtkColorSelection *colorsel)
>     {
>       gdouble color[3];
>       GdkColor gdk_color;
>       GdkColormap *colormap;

>       /* recupera la colormap dell'area di disegno */

>       colormap = gdk_window_get_colormap (drawingarea->window);

>       /* recupera il colore corrente */

>       gtk_color_selection_get_color (colorsel,color);

>       /* adattamento ad un intero unsigned di 16 bit (0..65535)
>        * e inseriscili nella struttura GdkColor */

>       gdk_color.red = (guint16)(color[0]*65535.0);
>       gdk_color.green = (guint16)(color[1]*65535.0);
>       gdk_color.blue = (guint16)(color[2]*65535.0);

>       /* Alloca il colore */

>       gdk_color_alloc (colormap, &gdk_color);

>       /* assegna il colore di sfondo della finestra */

>       gdk_window_set_background (drawingarea->window, &gdk_color);

>       /* pulisce la finestra */

>       gdk_window_clear (drawingarea->window);
>     }

>     /* gestore per l'area di disegno */

>     gint area_event (GtkWidget *widget, GdkEvent *event, gpointer client_data)
>     {
>       gint handled = FALSE;
>       GtkWidget *colorsel;

>       /* controlliamo se abbiamo ricevuto un evento di pressione di pulsante */

>       if (event->type == GDK_BUTTON_PRESS && colorseldlg == NULL)
>         {
>           /* Si , c'e' l'evento e ancora non c'e' alcun colorseldlg! */

>           handled = TRUE;

>           /* Creiamo una finestra di dialogo per la selezione del colore */

>           colorseldlg = gtk_color_selection_dialog_new("Select background color");

>           /* Otteniamo il widget GtkColorSelection */

>           colorsel = GTK_COLOR_SELECTION_DIALOG(colorseldlg)->colorsel;

>           /* Facciamo la connessione al segnale "color_changed",
>            * ed assegnamo i dati-utente al widget di selezione di colore */

>           gtk_signal_connect(GTK_OBJECT(colorsel), "color_changed",
>             (GtkSignalFunc)color_changed_cb, (gpointer)colorsel);

>           /* Mostriamo il dialogo */

>           gtk_widget_show(colorseldlg);
>         }

>       return handled;
>     }

>     /* Chiusura ed uscita dal getore */

>     void destroy_window (GtkWidget *widget, gpointer client_data)
>     {
>       gtk_main_quit ();
>     }

>     /* Main */

>     gint main (gint argc, gchar *argv[])
>     {
>       GtkWidget *window;

>       /* Inizialliziamo il toolkit, remuoviamo gli argomenti sulla linea di
>        * comando legati a gtk */

>       gtk_init (&argc,&argv);

>       /* creiamo la finestra base, con titolo e politiche */

>       window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
>       gtk_window_set_title (GTK_WINDOW(window), "Color selection test");
>       gtk_window_set_policy (GTK_WINDOW(window), TRUE, TRUE, TRUE);

>       /* colleghiamo gli eventi "delete" e "destroy" per poter uscire */

>       gtk_signal_connect (GTK_OBJECT(window), "delete_event",
>         (GtkSignalFunc)destroy_window, (gpointer)window);

>       gtk_signal_connect (GTK_OBJECT(window), "destroy",
>         (GtkSignalFunc)destroy_window, (gpointer)window);

>       /* crea un'area di disegna, stabilisce le dimensioni e raccogli
>        * gli eventi */

>       drawingarea = gtk_drawing_area_new ();

>       gtk_drawing_area_size (GTK_DRAWING_AREA(drawingarea), 200, 200);

>       gtk_widget_set_events (drawingarea, GDK_BUTTON_PRESS_MASK);

>       gtk_signal_connect (GTK_OBJECT(drawingarea), "event",
>         (GtkSignalFunc)area_event, (gpointer)drawingarea);

>       /* aggiungi l'area di disegno alla finestra e mostrale entrambe */

>       gtk_container_add (GTK_CONTAINER(window), drawingarea);

>       gtk_widget_show (drawingarea);
>       gtk_widget_show (window);

>       /* entra nel ciclo principale di gtk (che non cede mai il controllo */

>       gtk_main ();

>       /* soddisfa i compilatori brontoloni */

>       return 0;
>     }

> `

## 7.10 Selezione di File (File Selections)

Il widget Selezione di File è un modo rapido e semplice per mostrare una finestra di dialogo `File'. Questa si presenta completa di bottoni Ok, Cancel e Help, un buon modo per tagliare i tempi di programmazione.

Per creare una nuova finestra di selezione file usate:

> `

>     GtkWidget* gtk_file_selection_new (gchar *title);

> `

Per assegnare il nome del file, ad esempio per predisporre una certa directory o per dare un certo nome di file per difetto, usate la seguente funzione:

> `

>     void gtk_file_selection_set_filename (GtkFileSelection *filesel, gchar *filename);

> `

Per recuperare il testo che l'utente ha inserito o che ha selezionato con il mouse, si usa la funzione:

> `

>     gchar* gtk_file_selection_get_filename (GtkFileSelection *filesel);

> `

Ci sono anche dei puntatori ai widget che sono contenuti all'interno del widget di selezione file. Si tratta di:

- dir_list
- file_list
- selection_entry
- selection_text
- main_vbox
- ok_button
- cancel_button
- help_button

Molto probabilmente potreste voler usare i puntatori a ok_button, cancel_button e help_button per segnalarne l'uso.

Ecco un esempio rubato da testgtk.c, nodificato per essere eseguito da solo. Come potrete vedere, non c'è molto più che la creazione di un widget di selezione file. In questo esempio, il bottone Help non fa nulla mentre è mostrato allo schermo, dal momento che non c'è alcun segnale collegato con esso.

> `

>     /* filesel.c */

>     #include <gtk/gtk.h>

>     /* Recupera il nome di file selezionato e stampalo a console */
>     void file_ok_sel (GtkWidget *w, GtkFileSelection *fs)
>     {
>         g_print ("%s\n", gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs)));
>     }

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

>     int main (int argc, char *argv[])
>     {
>         GtkWidget *filew;

>         gtk_init (&argc, &argv);

>         /* Crea un nuovo widget di selezione file */
>         filew = gtk_file_selection_new ("File selection");

>         gtk_signal_connect (GTK_OBJECT (filew), "destroy",
>                             (GtkSignalFunc) destroy, &filew);
>         /* Connette ok_button alla funzione file_ok_sel */
>         gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (filew)->ok_button),
>                             "clicked", (GtkSignalFunc) file_ok_sel, filew );

>         /* Connette cancel_button alla funzione di distruzione del widget */
>         gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (filew)->cancel_button),
>                                    "clicked", (GtkSignalFunc) gtk_widget_destroy,
>                                    GTK_OBJECT (filew));

>         /* Preassegnamo un nome di file, come se stessimo dando un valore per difetto in
>         dialogo di tipo `` salva con nome '' */
>         gtk_file_selection_set_filename (GTK_FILE_SELECTION(filew),
>                                          "penguin.png");

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

> `

Avanti Indietro Indice