gtk_tut_it.txt

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

  GTK Tutorial
  Ian Main <[e-mail]>, Tony Gale <[e-mail]>
  May 24th, 1998  - Traduzione aggiornata al 27 Maggio 1998

  Tradotto da Michel Morelli, [e-mail], Daniele
  Canazza, [e-mail] e Antonio Schifano, [e-mail]

  11..  IInnttrroodduuzziioonnee

  GTK (GIMP Toolkit) e stato orginariamente sviluppato come toolkit per
  il programma GIMP (General Image Manipulation Program). GTK e
  costruito sulla base del kit di disegno di GIMP, il GDK (GIMP Drawing
  Kit) il quale e costruito a sua volta attorno alle funzioni della
  Xlib. E' chiamato ``toolkit di GIMP'' perche era inizialmente scritto
  per sviluppare GIMP, ma ora viene utilizzato nello sviluppo di molti
  progetti software ``free''.  Gli autori sono

  +o  Peter Mattis   [e-mail]

  +o  Spencer Kimball [e-mail]

  +o  Josh MacDonald [e-mail]


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


  C'e 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 portabilita 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.


  Questo tutorial e 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 e 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'e 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.


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


  22..  IInniizziiaammoo

  La prima cosa da fare e 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 e il sito
  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.


  Per iniziare la nostra introduzione a GTK, cominceremo con il piu
  semplice programma possibile. Questo programma crea una finestra con
  dimensioni (in pixel) di 200x200 e l'unica possibilita di uscita e di
  ucciderlo usando la shell o il Window Manager.



       #include <gtk/gtk.h>

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

           gtk_init (&argc, &argv);

           window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
           gtk_widget_show (window);

           gtk_main ();

           return 0;
       }




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


  La linea seguente:



       gtk_init (&argc, &argv);




  invoca la funzione gtk_init(gint *argc, gchar ***argv) che sara 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:

  +o  --display

  +o  --debug-level

  +o  --no-xshm

  +o  --sync

  +o  --show-events

  +o  --no-show-events

  Rimuove poi questi argomenti dalla lista degli argomenti passati,
  lasciando quelli non riconosciuti a disposizione della vostra
  applicazione che potra tenerne conto o ignorarli.  In questo modo si
  crea un set di argomenti standard accettato da tutte le applicazioni
  GTK.


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



         window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
         gtk_widget_show (window);




  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 indichera. Invece di creare una
  finestra avente dimensioni 0x0, la dimensione di una finestra senza
  figli (altri widget, come i bottoni, etc) e predefinita a 200x200 cosi
  che si possa manipolarla.  La funzione gtk_widget_show()  fa si che
  GTK sappia che abbiamo finito di settare gli attributi di questo
  widget e che quindi quest'ultimo puo essere visualizzato.


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



       gtk_main ();




  gtk_main() e un'altra chiamata che vedrete in tutte le applicazioni
  GTK.  Quando il controllo raggiunge questo punto, l'applicazione si
  mettera 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.


  22..11..  HHeelllloo WWoorrlldd iinn GGTTKK

  Ok, ora un programma con un widget (un bottone). E' il classico
  ``Hello World'' alla GTK.


















  /* 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 da 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 (&argc, &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 e NULL
       * ed e 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() e definita sopra. */
      gtk_signal_connect (GTK_OBJECT (button), "clicked",
                          GTK_SIGNAL_FUNC (hello), NULL);

      /* Questo fara si che la finestra venga distrutta dalla chiamata
       * gtk_widget_destroy(window) quando il bottone verra 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 e 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;
  }





  22..22..  CCoommppiillaarree hheelllloo WWoorrlldd

  Per compilare si utilizza :




       gcc -Wall -g helloworld.c -o hello_world `gtk-config --cflags` \
           `gtk-config --libs`




  (N.d.T.: se lanciato da linea di comando, il precedente comando di
  compilazione va messo su di una unica linea eliminando il backslash)

  In questo modo, si usa il progamma gtk-config, che viene distribuito
  con gtk. Questo programma 'sa' che opzioni di compilatore sono
  necessarie per compilare i programmi che usano gtk.  gtk-config
  --cflags da come risultato una lista di directory in cui i file di
  include devono essere cercati, e gtk-config --libs fornisce invece la
  lista delle librerie che devono essere linkate con le directory in cui
  devono essere cercate.


  Le librerie che normalmente vengono linkate sono:

  +o  la libreria glib (-lglib), contiene varie funzioni, ma solo
     g_print() e usato in questo esempio. GTK si appoggia a questa
     libreria, quindi essa viene sempre, comunque, linkata. Vedi
     comunque la  sezione sulla ``glib'' per altri dettagli.

  +o  La libreria GDK (-lgdk), la copertura della X11.

  +o  La libreria GTK (-lgtk), la libreria dei widget, basata sulla GDK.

  +o  La libreria Xlib(-lX11) la quale e usata dalla GDK.

  +o  La libreria Xext(-lXext). Questa contiene il codice per le pixmap a
     memoria condivisa e altre estensioni di X.

  +o  La libreria matematica (-lm). Questa e usata dalla GTK per vari
     scopi.


  22..33..  TTeeoorriiaa ddeeii sseeggnnaallii ee ddeellllee ffuunnzziioonnii ddii rriittoorrnnoo ((ccaallllbbaacckk))

  Prima di guardare in dettaglio ``Hello World'', parleremo un po' degli
  eventi e delle funzioni di ritorno. GTK  e un toolkit guidato dagli
  eventi, il che significa che se ne stara a dorimire in gtk_main finche
  non succede un evento ed il controllo viene passato alla funzione
  appropriata.


  Questo passaggio di controllo e basato sull'idea dei segnali.  Quando
  si ha un evento, come la pressione di un bottone del mouse, verra
  emesso il segnale appropriato, per esempio dal widget che e stato
  premuto.  Questo e il modo in cui GTK fa molto del suo utile lavoro.
  Per far si 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:



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




  in cui il primo argomento e il widget che emettera il segnale, il
  secondo e il nome del segnale che si vuole catturare, il terzo e la
  funzione che verra invocata quando il segnale sara catturato e il
  quarto e il dato che potra essere passato a questa funzione.

  La funzione specificata come terzo argomento e chiamata ``funzione di
  ritorno (callback)'', e dovrebbe essere della forma:



       void callback_func(GtkWidget *widget, gpointer callback_data);