gtk_tut_it.sgml

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

<!doctype linuxdoc system>
<article>
<title>GTK Tutorial
<author>Ian Main <tt><htmlurl url="mailto:[e-mail]"
			      name="&lt;[e-mail]&gt;"></tt>,
Tony Gale <tt><htmlurl url="mailto:[e-mail]"
			      name="&lt;[e-mail]&gt;"></tt>
<date>May 24th, 1998  - Traduzione aggiornata al 27 Maggio 1998

<abstract>Tradotto da Michel Morelli, <tt><htmlurl url="mailto:[e-mail]" name="[e-mail]"></tt>, Daniele Canazza, <tt><htmlurl url="mailto:[e-mail]" name="[e-mail]"></tt> e Antonio Schifano, <tt><htmlurl url="mailto:[e-mail]" name="[e-mail]"></tt>
</abstract>
<!-- ***************************************************************** -->
<sect>Introduzione
<!-- ***************************************************************** -->
<p>
GTK (GIMP Toolkit) &egrave; stato orginariamente sviluppato come toolkit per
il programma GIMP (General Image Manipulation Program). GTK &egrave; costruito
sulla base del kit di disegno di GIMP, il GDK (GIMP Drawing Kit) il quale
&egrave; costruito a sua volta attorno alle funzioni della Xlib. E' chiamato
``toolkit di GIMP'' perch&eacute; era inizialmente scritto per sviluppare GIMP,
ma ora viene utilizzato nello sviluppo di molti progetti software ``free''. 
Gli autori sono
<itemize>
<item> Peter Mattis   <tt><htmlurl url="mailto:[e-mail]"
                           name="[e-mail]"></tt>     
<item> Spencer Kimball <tt><htmlurl url="mailto:[e-mail]"
                           name="[e-mail]"></tt>
<item> Josh MacDonald <tt><htmlurl url="mailto:[e-mail]"
                           name="[e-mail]"></tt>
</itemize>

<p>
GTK &egrave; essenzialmente una API (application programmers interface)
orientata agli oggetti.
Anche se scritto completamente in C, &egrave; implementato usando l'idea delle
classi e delle funzioni di callback (puntatori a funzioni).

<p>
C'&egrave; anche una terza componente chiamata glib che contiene una serie di
implementazioni differenti di alcune chiamate di funzioni standard e anche
alcune funzioni aggiuntive, per esempio per la manipolazione delle liste 
collegate. Le funzioni sostitutive sono usate per migliorare la 
portabilit&agrave; di GTK. Alcune delle funzioni implementate qui non sono
disponibili o non sono standard,  altre sono uniche come g_strerror().
Altre contengono miglioramenti alle stesse della libc come g_malloc che ha 
delle utility di debugging migliorate.

<p>
Questo tutorial &egrave; un tentativo di documentare il meglio possibile la
libreria gtk e non pretende di essere completo. Questo tutorial suppone una
buona conoscenza del linugaggio C e di come creare programmi in C. Saranno
facilitati i lettori che hanno una precedente esperienza nella programmazione
in X. Se il GTK &egrave; il primo insieme di widget che studiate, vi prego di
dirmi come avete trovato questo tutorial e che tipo di problemi avete avuto.
Notate che c'&egrave; anche una versione per il C++ della libreria GTK (chiamata
GTK--), quindi se preferite utilizzare questo linguaggio al posto del C potreste
cercare questa versione al posto della GTK normale.
Ci sono poi un ``wrapper'' Objective C e un collegamento a Guile, ma non ne
seguo l'evoluzione.

<p>
Mi farebbe molto piacere conoscere qualsiasi problema che abbiate avuto
nell'imparare il GTK da questo documento e apprezzerei anche critiche sul come
migliorarlo.

<!-- ***************************************************************** -->
<sect>Iniziamo
<!-- ***************************************************************** -->
<p>
La prima cosa da fare &egrave; certamente quella di scaricare il GTK e installarlo.
Potete prendere l'ultima versione dal sito ftp.gtk.org in /pub/gtk. Un'altra
possibile sorgente di informazioni &egrave; il sito
<htmlurl url="http://www.gtk.org/" name="http://www.gtk.org/">. 

GTK usa il comando GNU autoconf per autoconfigurarsi. 
Una volta estratti i file dall'archivio tar, eseguite configure --help per
vedere una lista delle opzioni del comando configure.

<p>
Per iniziare la nostra introduzione a GTK, cominceremo con il pi&ugrave; semplice
programma possibile. Questo programma crea una finestra con dimensioni (in pixel)
di 200x200 e l'unica possibilit&agrave; di uscita &egrave; di ucciderlo usando la
shell o il Window Manager.

<tscreen><verb>
#include <gtk/gtk.h>

int main (int argc, char *argv[])
{
    GtkWidget *window;
    
    gtk_init (&amp;argc, &amp;argv);
    
    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    gtk_widget_show (window);
    
    gtk_main ();
    
    return 0;
}
</verb></tscreen>

Tutti i programmi GTK includeranno sicuramente &lt;gtk/gtk.h&gt; in cui vengono
dichiarate le variabili, le funzioni, le strutture, etc. che saranno usate nella
tua applicazione GTK.

<p>
La linea seguente: 

<tscreen><verb>
gtk_init (&amp;argc, &amp;argv);
</verb></tscreen>

invoca la funzione gtk_init(gint *argc, gchar ***argv) che sar&agrave; usata in
tutte le applicazioni GTK. Questa funzione sistema alcune cose al posto nostro,
come la visuale predefinita e la mappa dei colori, e  procede poi chiamando
gdk_init(gint *argc, gchar ***argv).
Questa funzione inizializza la libreria per l'uso, setta il gestore predefinito
dei segnali e guarda negli argomenti, passati via linea di comando alla vostra
applicazione, alla ricerca di uno di questi argomenti:
<itemize>
<item> <tt/--display/
<item> <tt/--debug-level/
<item> <tt/--no-xshm/
<item> <tt/--sync/
<item> <tt/--show-events/
<item> <tt/--no-show-events/
</itemize>
<p>
Rimuove poi questi argomenti dalla lista degli argomenti passati, lasciando
quelli non riconosciuti a disposizione della vostra applicazione che potr&agrave;
tenerne conto o ignorarli.
In questo modo si crea un set di argomenti standard accettato da tutte le
applicazioni GTK.

<p>
Le seguenti 2 linee di codice creano e mostrano la finestra.

<tscreen><verb>
  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_widget_show (window);
</verb></tscreen>

L'argomento GTK_WINDOW_TOPLEVEL specifica che noi vogliamo che la nostra finestra
si sottometta alle decorazioni del windows manager e alla posizione che quest'ultimo
indicher&agrave;. Invece di creare una finestra avente dimensioni 0x0, la dimensione
di una finestra senza figli (altri widget, come i bottoni, etc) &egrave; predefinita
a 200x200 cos&igrave; che si possa manipolarla.
La funzione gtk_widget_show()  fa s&igrave; che GTK sappia che abbiamo finito di
settare gli attributi di questo widget e che quindi quest'ultimo pu&ograve; essere
visualizzato.

<p>
L'ultima linea ci fa entrare nel ciclo principale del GTK.

<tscreen><verb>
gtk_main ();
</verb></tscreen>

gtk_main() &egrave; un'altra chiamata che vedrete in tutte le applicazioni GTK.
Quando il controllo raggiunge questo punto, l'applicazione si metter&agrave; a
dormire aspettando che si verifichino eventi di X (come la pressione di un bottone
o di un tasto), timeout o notifiche di Input/Output dai file
Nel nostro esempio, comunque, tutti gli eventi vengono ignorati.

<!-- ----------------------------------------------------------------- -->
<sect1>Hello World in GTK
<!-- ----------------------------------------------------------------- -->
<p>
Ok, ora un programma con un widget (un bottone). E' il classico ``Hello World''
alla GTK. 

<tscreen><verb>
/* helloworld.c */
#include <gtk/gtk.h>


/* E' una funzione di ritorno (callback). Gli argomenti passati sono ignorati in questo 
* esempio.
* Piu' informazioni sulle callback in seguito. */

void hello (GtkWidget *widget, gpointer data)
{
    g_print ("Hello World\n");
}

gint delete_event(GtkWidget *widget, gpointer data)
  {
      g_print ("delete event occured\n");
      /* Se si d&agrave; FALSE al gestore del segnale ``delete_event'', GTK emettera' il segnale
       * ``destroy''. Fornire TRUE significa non volere che la finestra sia distrutta. 
      * Questo e' utile per far uscire delle finestre di dialogo del tipo:
      * 'sei sicuro di voler uscire ?'
      * Cambia TRUE in FALSE e la finestra principale sara' distrutta con un "delete_event"
      */
    return (TRUE);

}


/* Un'altra callback */
void destroy (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;
    
    /* Questa e' una chiamata presente in tutte le applicazioni GTK. Gli argomenti della
        linea di comando vengono scorsi e restituiti alla applicazione  */
    gtk_init (&amp;argc, &amp;argv);
    
    /* Crea una nuova finestra */
    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    
    /* Quando alla finestra viene passato il segnale ``delete_event'' (questo 
     * segnale viene passato Windows Manager di solito con l'opzione 'close' 
     * o con la barra del titolo (title bar)) noi chiediamo che la funzione 
     * delete_event() (definita sopra) venga invocata.
     * Il dato passato come argomento alla funzione di ritorno &eacute; NULL
     * ed &eacute; ignorato dalla funzione stessa. */
    gtk_signal_connect (GTK_OBJECT (window), "delete_event",
			GTK_SIGNAL_FUNC (delete_event), NULL);
    
    /* Qui connettiamo l'evento ``destroy'' al gestore del segnale.
     * Questo evento accade quando noi chiamimo la funzione gtk_widget_destroy() 
     * sulla finestra o se ritorniamo FALSE dalla callback ``delete_event''. */
    gtk_signal_connect (GTK_OBJECT (window), "destroy",
                        GTK_SIGNAL_FUNC (destroy), NULL);

    /* Setta il bordo interno della finestra */
    gtk_container_border_width (GTK_CONTAINER (window), 10);
    
    /* Crea un nuovo bottone avente etichetta (label)  uguale a ``Hello World'' */
    button = gtk_button_new_with_label ("Hello World");
    
    /* Quando il bottone riceve il segnale ``clicked'', invochera' la funzione 
     * hello() passando NULL come argomento della funzione. La funzione
     * hello() &eacute; definita sopra. */
    gtk_signal_connect (GTK_OBJECT (button), "clicked",
			GTK_SIGNAL_FUNC (hello), NULL);
    
    /* Questo far&agrave; s&igrave; che la finestra venga distrutta dalla chiamata
     * gtk_widget_destroy(window) quando il bottone verr&agrave; premuto. Ancora,
     * questo segnale (``destroy'') puo' arrivare da qui o dal windows 
     * manager */
    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
			       GTK_SIGNAL_FUNC (gtk_widget_destroy),
			       GTK_OBJECT (window));
    
    /* Questo inserisce il bottone nella finestra 
     * (un contenitore GTK) */
    gtk_container_add (GTK_CONTAINER (window), button);
    
    /* Il passo finale &eacute; il mostrare questo nuovo widget appena creato */
    gtk_widget_show (button);
    
    /* e la finestra */
    gtk_widget_show (window);
    
    /* Tutte le applicazioni GTK devono avere la funzione gtk_main(). 
     * Il controllo finisce qui e attende un evento (come la pressione
     * di un tasto o l'evento di un mouse). */
    gtk_main ();
    
    return 0;
}
</verb></tscreen>

<!-- ----------------------------------------------------------------- -->
<sect1>Compilare hello World
<!-- ----------------------------------------------------------------- -->
<p>
Per compilare si utilizza :

<tscreen><verb>

gcc -Wall -g helloworld.c -o hello_world `gtk-config --cflags` \
    `gtk-config --libs`
</verb></tscreen>
(N.d.T.: se lanciato da linea di comando, il precedente comando di
compilazione va messo su di una unica linea eliminando il backslash) 
<p>
In questo modo, si usa il progamma <tt>gtk-config</>, che viene
distribuito con gtk. Questo programma 'sa' che opzioni di compilatore
sono necessarie per compilare i programmi che usano gtk.
<tt>gtk-config --cflags</> d&agrave; come risultato una lista di directory
in cui i file di include devono essere cercati, e <tt>gtk-config --libs</>
fornisce invece la lista delle librerie che devono essere linkate con le
directory in cui devono essere cercate.

<p>
Le librerie che normalmente vengono linkate sono:
<itemize>
<item> la libreria glib (-lglib), contiene varie funzioni, ma solo 
g_print() &eacute; usato in questo esempio. GTK si appoggia a questa
libreria, quindi essa viene sempre, comunque, linkata. Vedi comunque
la  sezione sulla <ref id="sec_glib" name="glib"> per altri dettagli.
<item>La libreria GDK (-lgdk), la copertura della X11.
<item>La libreria GTK (-lgtk), la libreria dei widget, basata sulla GDK.
<item>La libreria Xlib(-lX11) la quale &egrave; usata dalla GDK.
<item>La libreria Xext(-lXext). Questa contiene il codice per le pixmap a
memoria condivisa e altre estensioni di X.
<item>La libreria matematica (-lm). Questa &eacute; usata dalla GTK per
vari scopi.
</itemize>

<!-- ----------------------------------------------------------------- -->
<sect1>Teoria dei segnali e delle funzioni di ritorno (callback)
<p>
Prima di guardare in dettaglio ``Hello World'', parleremo un po' degli eventi
e delle funzioni di ritorno. GTK  &egrave; un toolkit guidato dagli eventi,
il che significa che se ne star&agrave; a dorimire in gtk_main finch&eacute;
non succede un evento ed il controllo viene passato alla funzione appropriata.

<p>
Questo passaggio di controllo &egrave; basato sull'idea dei segnali.
Quando si ha un evento, come la pressione di un bottone del mouse, verr&agrave;
emesso il segnale appropriato, per esempio dal widget che &eacute; stato premuto.
Questo &egrave; il modo in cui GTK fa molto del suo utile lavoro. Per far
s&igrave; che un bottone esegua una azione, prepareremo un gestore del segnale
che catturi questi segnali e chiami la funzione corretta. Questo viene fatto
usando una funzione del tipo: