Whole document tree

3. Proseguiamo

3.1 Tipi di Dato

Ci sono alcune cose che avrete probabilmente notato nei precedenti esempi che hanno bisogno di una spiegazione. I gint, gchar ecc. che vedete sono tipi di dato (typedef) riferiti rispettivamente a int e char. Questo viene fatto per rimediare alle scomode dipendenze dalle dimensioni di semplici tipi di dato quando si fanno dei calcoli. Un buon esempio è ``gint32'' il quale sarà un tipo di dato riferito ad un intero a 32 bit per tutte le piattaforme, sia per gli x86 che per gli per gli alpha a 64 bit. I tipi di dato sono ben spiegati più avanti e molto intuitivi. Sono definiti in glib/glib.h (il quale viene incluso da gtk.h).

Noterete anche la possibilità di utilizzare un GtkWidget quando la funzione richiede un GtkObject. GTK è una libreria orienta agli oggetti ed un widget è un oggetto.

3.2 Altri Dettagli sui Segnali

Diamo un'altra occhiata alla dichiarazione della funzione gtk_signal_connect.

gint gtk_signal_connect (GtkObject *object, gchar *name,
                         GtkSignalFunc func, gpointer func_data);

Questo identificatore vi permette di rimuovere una funzione dalla lista delle funzioni di ritorno tramite la seguente chiamata

void gtk_signal_disconnect (GtkObject *object,
                            gint id);

Un'altra funzione, usata per rimuovere tutti i segnali di un widget in una volta sola è:

gtk_signal_handlers_destroy (GtkObject *object);

Questa chiamata è abbastanza auto esplicativa. Semplicemente rimuove tutti i segnali collegati al widget che si passa alla funzione come argomento.

3.3 Miglioriamo Hello World

Diamo un'occhiata ad una versione migliorata di Hello World con altri esempi sulle callback. Questo ci introdurrà anche al nostro prossimo argomento, l'impacchettamento dei widget.

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

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

/* Un'altra callback */
void delete_event (GtkWidget *widget, gpointer data)
{
    gtk_main_quit ();
}

int main (int argc, char *argv[])
{
    /* GtkWidget e' il tipo di dato per i widget */
    GtkWidget *window;
    GtkWidget *button;
    GtkWidget *box1;

    /* Questa funzione e' invocata in tutte le applicazioni GTK, gli 
       argomenti sono analizzati e restituiti all'applicazione. */
    gtk_init (&argc, &argv);

    /* Crea una nuova finestra */
    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

    /* Questa e' una nuova chiamata. Assegna "Hello Buttons" come titolo 
       della nostra finestra */
    gtk_window_set_title (GTK_WINDOW (window), "Hello Buttons!");

    /* Qui settiamo il gestore per il segnale "delete_event" che
       immediatamente esce dalla applicazione.
    gtk_signal_connect (GTK_OBJECT (window), "delete_event",
                        GTK_SIGNAL_FUNC (delete_event), NULL);


    /* predispone il bordo della finestra */
    gtk_container_border_width (GTK_CONTAINER (window), 10);

    /* creiamo una scatola dove mettere tutti i widget. Questa è descritta
       dettagliatamente nella sezione "packing". La scatola non è realmente
       visibile, è solamente usata per sistemare i widget. */
    box1 = gtk_hbox_new(FALSE, 0);

    /* Inseriamo la scatola nella finestra */
    gtk_container_add (GTK_CONTAINER (window), box1);

    /* Creiamo un nuovo bottone con etichetta "Button 1" */
    button = gtk_button_new_with_label ("Button 1");

    /* Quando il bottone e' premuto, noi invocheremo la funzione di callback,
       con un puntatore alla stringa "button 1" come proprio argomento) */
    gtk_signal_connect (GTK_OBJECT (button), "clicked",
                        GTK_SIGNAL_FUNC (callback), (gpointer) "button 1");

    /* invece di aggiungerlo alla finestra, lo inseriamo nella scatola invisibile,
       la quale e' stata inserita nella finstra. */
    gtk_box_pack_start(GTK_BOX(box1), button, TRUE, TRUE, 0);

    /* Ricordati sempre questo passo. Dice a GTK che la preparazione di questo 
       bottone e' finita e che quindi puo' essere mostrato. */
    gtk_widget_show(button);

    /* Facciamo la stessa cosa per il secondo bottone. */
    button = gtk_button_new_with_label ("Button 2");

    /* Chiamiamo la stessa funzione ma passandogli un argomento differente,
       gli passiamo un puntatore alla stringa "button 2" */
    gtk_signal_connect (GTK_OBJECT (button), "clicked",
                        GTK_SIGNAL_FUNC (callback), (gpointer) "button 2");

    gtk_box_pack_start(GTK_BOX(box1), button, TRUE, TRUE, 0);

    /* L'ordine nel quale i bottoni sono visualizzati non e' realmente importante,
       ma io ti raccomando di mostrare per ultima la finestra cosi' che tutto 
       sia visualizzato in una volta sola */
    gtk_widget_show(button);

    gtk_widget_show(box1);

    gtk_widget_show (window);

    /* e ora ci mettiamo in gtk_main e aspettiamo che il diverimento inizi.
    gtk_main ();

    return 0;
}

Compilate questo programma usando gli stessi argomenti di link del nostro primo esempio. Noterete che questa volta non c'è un modo semplice per uscire dal programma, si deve usare il nostro window manager o la linea di comando per uccidere l'applicazione. Un buon esercizio per il lettore è quello di inserire un tezo bottone ``quit'' che faccia uscire dal programma. Potete anche divertirvi con le opzioni di gtk_box_pack_start() mentre leggete il prossimo capitolo. Provate a ridimensionare la finestra ed a osservare cosa succede.

Solo una piccola nota: c'è un'altra definizione di gtk_window_new() - GTK_WINDOW_DIALOG. Questa interagisce con il window manager in un modo un po' diverso, e dovrebbe essere usata per finestre temporanee.