gtk_tut_it.txt

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

  Dove il primo argomento sara un puntatore al widget che emette il
  segnale e il secondo un puntatore al dato passato come ultimo
  argomento della funzione gtk_signal_connect() come descritto sopra.

  Un'altra chiamata usata nell'esempio Hello World e:




  gint gtk_signal_connect_object (GtkObject *object,
                                  gchar  *name,
                                  GtkSignalFunc func,
                                  GtkObject *slot_object);




  gtk_signal_connect_object() e uguale a gtk_signal_connect() eccetto
  che la funzione di callback usa solo un argomento, un puntatore ad
  un'oggetto GTK.  Cosi quando si usa questa funzione per connettere i
  segnali, la callback dovrebbe essere della forma :



       void callback_func (GtkObject *object);




  dove object e normalmente un widget. Generalmente, non si assegna una
  callback per gtk_signal_connect_object.  Queste sono invocate,
  usualmente, per chiamare una funzione GTK che accetta un widget
  singolo o un oggetto come argomento, come nel caso dell'esempio Hello
  World.

  Lo scopo di avere due funzioni per connettere i segnali e
  semplicemente quello di permettere alla funzione di callback di avere
  un numero di argomenti diverso. Molte funzioni della libreria GTK
  accettano solo un singolo puntatore ad un widget GTK come argomento,
  cosi per queste si puo usare la funzione gtk_signal_connect_object(),
  mentre per le vostre funzioni potreste aver bisogno di passare dati
  supplementari alle funzioni di ritorno.


  22..44..  AAttttrraavveerrssoo HHeelllloo WWoorrlldd ppaassssoo ppeerr ppaassssoo

  Ora che conosciamo la teoria che vi e dietro, iniziamo ad essere piu
  chiari camminando attraverso il programma di Hello World.

  Questa e la funzione di callback che sara invocata quando il bottone
  viene cliccato.  Noi, in questo esempio, ignoriamo sia il widget che i
  dati passati, ma non e difficile farci invece qualcosa. Il prossimo
  esempio usera l'argomento passato per dire quale bottone e stato
  premuto.



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





  Questa callback e un po' speciale. L'evento ``delete'' avviene quanto
  il Window Manager manda questo evento all'applicazione. Qui abbiamo
  una scelta da fare: cosa fare di questo evento. Possiamo ignorarlo,
  creare qualche tipo di risposta, o semplicemente terminare
  l'applicazione.

  Il valore che si restituisce in questa callback fa si che la GTK
  sappia cosa fare. Restituire TRUE significa che non vogliamo che il
  segnale ``destroy'' sia emesso, quindi far si che la nostra
  applicazione proceda normalmente.  Ritornare FALSE vuole dire far
  emettere il segnale ``destroy'' il quale chiamera la nostra funzione
  di callback che gestisce il segnale ``destroy''.



       gint delete_event(GtkWidget *widget, gpointer data)
       {
          g_print ("delete event occured\n");

          return (TRUE);
       }




  Questa e un'altra funzione di callback la quale fa uscire dal
  programma chiamando gtk_main_quit(). Questa funzione dice a GTK che
  deve uscire da gtk_main quando gli viene restituito il controllo.



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




  Ritengo che conosciate la funzione main()... si, come tutte le altre
  applicazioni anche le applicazioni GTK hanno questa funzione.



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




  Questa parte dichiara un puntatore ad una struttura di tipo GtkWidget.
  Queste sono usate piu sotto per creare una finestra ed un bottone.



           GtkWidget *window;
           GtkWidget *button;




  Qui vi e ancora la nostra gtk_init. Come prima questa inizializza il
  toolkit e analizza gli argomenti trovati nella linea di comando. Tutti
  gli argomenti riconosciuti nella linea di comando sono rimossi dalla
  lista degli argomenti e vengono cosi modificati argc e argv per far si
  che sembri che questi non siano mai esisiti e permettere alla vostra
  applicazione di analizzare gli argomenti rimasti.



           gtk_init (&argc, &argv);




  Crea una nuova finestra. Questo viene spiegato abbastanza
  approfonditamente piu avanti. Viene allocata la memoria per la
  struttura GtkWidget *window cosi che si punti ad una struttura valida.
  In questo modo si predispone la nuova finestra, ma non la si
  visualizza fino a sotto dove, quasi alla fine del nostro programma,
  invochiamo gtk_widget_show(window).


           window = gtk_window_new (GTK_WINDOW_TOPLEVEL);




  Questo e un esempio di come connettere un gestore dei segnali con un
  oggetto, in questo caso la finestra. Qui viene catturato il segnale
  ``destroy''. Questo viene emesso quando usiamo il Window Manager per
  uccidere la finestra (e noi restituiamo TRUE dal gestore di
  ``delete_event'') o quando emettiamo la chiamata gtk_widget_destroy()
  passando l'oggetto finestra come oggetto da distruggere.  Sistemando
  le cose cosi, trattiamo entrambi i casi con una singola chiamata. Qui
  e giusto invocare la funzione destroy() definita sopra con NULL come
  argomento, la quale termina l'applicazione GTK per noi.  Questo ci
  permettera di utilizzare il Window Manager per uccidere il programma.

  GTK_OBJECT e GTK_SIGNAL_FUNC sono macro che interpretano il casting e
  il controllo di tipo per noi, cosi da rendere piu' leggibile il
  codice.



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




  La prossima funzione e usata per settare un attributo di un oggetto
  contenitore. Questo sistema la finestra cosi da avere un'area vuota
  all'interno della finestrra larga 10 pixel dove non potra andare
  nessun widget. Ci sono altre funzioni simili che vedremo nella sezione
  ``Settare gli attributi del Widget.''

  E ancora, GTK_CONTAINER e una macro per interpretare il casting di
  tipo.



           gtk_container_border_width (GTK_CONTAINER (window), 10);




  Questa chiamata crea un nuovo bottone. Alloca spazio in memoria per un
  nuovo GtkWidget, inizializzandolo e facendo si che il puntatore a
  bottone punti ad esso.  Quando sara visualizzato, avra etichetta
  ``Hello World''.



           button = gtk_button_new_with_label ("Hello World");




  Qui prendiamo il bottone e gli facciamo fare qualcosa di utile.  Gli
  colleghiamo un gestore di segnale  in modo che quando emettera il
  segnale ``clicked'', verra invocata la nostra funzione hello(). Il
  dato passato alla funzione e ignorato, cosicche alla funzione di
  callback hello() passiamo semplicemente NULL. Evidentemente il segnale
  ``clicked'' viene emesso quando premiamo il bottone con il mouse.



           gtk_signal_connect (GTK_OBJECT (button), "clicked",
                               GTK_SIGNAL_FUNC (hello), NULL);




  Usiamo questo bottone anche per uscire dal programma. Questo
  illustrera come il segnale ``destroy'' puo arrivare sia dal Window
  Manager che dal nostro programma. Quando il bottone viene cliccato
  come descritto sopra, chiamera la funzione di callback hello() e poi
  quest'ultima nell'ordine in cui sono definite. Si possono cioe avere
  tante funzioni di callback quante sono necessarie, e saranno eseguite
  nell'ordine in cui sono connesse.  Visto che la funzione
  gtk_widget_destroy() accetta come argomento solo un GtkWidget *widget,
  usiamo la funzione gtk_signal_connect_object() al posto della normale
  gtk_signal_connect().



           gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
                                      GTK_SIGNAL_FUNC (gtk_widget_destroy),
                                      GTK_OBJECT (window));




  Questa e una chiamata di ``impacchettamento'' che sara spiegata piu
  avanti. Ma e molto facile da capire. Semplicemente dice alla libreria
  GTK che il bottone e da mettere nella finestra dove sara visualizzato.



           gtk_container_add (GTK_CONTAINER (window), button);




  A questo punto abbiamo predisposto tutto quello che ci eravamo
  prefissati.  Con tutti i gestori di segnale a posto e il bottone messo
  nella finestra in cui dovrebbe essere, possiamo dire a GTK di mostrare
  gli oggetti sullo schermo.  L'oggetto finestra viene mostrato per
  ultimo cosi che la finestra completa di tutti i suoi oggetti verra
  mostrata tutta in una volta, invece di vedere prima la finestra
  spoglia e poi la comparsa del bottone all'interno di essa. Per quanto,
  con questi semplici esempi, questo l'avrete gia notato.


           gtk_widget_show (button);

           gtk_widget_show (window);




  E naturalmente chiamiamo gtk_main(), la quale aspetta l'arrivo degli
  eventi dal server X e chiama l'oggetto interessato per fargli emettere
  il segnale corrispondente.


      gtk_main ();




  E il return finale. Il controllo ritorna qui dopo che viene invocata
  gtk_quit().



           return 0;




  Ora, quando premiamo il bottone del mouse su un bottone GTK, questo
  oggetto emette il segnale ``clicked''. Per poter utilizzare queste
  informazioni, il nostro programma predispone un gestore di segnale per
  catturare quel segnale, il quale avvia la funzione da noi scelta. Nel
  nostro esempio, quando il bottone creato viene cliccato, la funzione
  hello() viene invocata con argomento NULL, dopoodiche viene invocato
  il successivo gestore di questo segnale.  Questo chiama la funziona
  gtk_widget_destroy(), passandole l'oggetto-finestra (window) come
  argomento, che distruggera la finestra. Questo fa si che la finestra
  emetta il segnale ``destroy'' che viene catturato e che fa invocare la
  funzione di ritorno destroy(), che semplicemente esce dal programma
  GTK.

  Un'altro modo in cui possono andare le cose e l'uso del window manager
  per uccidere la finestra. Questo causera' l'emissione del segnale
  ``delete_event'' che automaticamente chiamera il gestore del segnale
  ``delete_event''. Se qui noi restituiamo il valore TRUE, la finestra
  non verra toccata e tutto procedera come se nulla fosse successo. Dare
  invece il valore FALSE causera l'emissione da parte di GTK del segnale
  ``destroy'' il quale, a sua volta, invochera la callback ``destroy'',
  uscendo dall'applicazione.

  Nota che questi segnali non sono gli stessi del sistema Unix e che non
  sono implementati usando quei segnali, anche se la terminologia e
  praticamente identica.


  33..  PPrroosseegguuiiaammoo



  33..11..  TTiippii ddii DDaattoo

  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 e ``gint32'' il quale sara 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 piu avanti e
  molto intuitivi. Sono definiti in glib/glib.h (il quale viene incluso
  da gtk.h).

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




  33..22..  AAllttrrii DDeettttaaggllii ssuuii SSeeggnnaallii

  Diamo un'altra occhiata alla dichiarazione della funzione
  gtk_signal_connect.



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




  Notate il valore di ritorno definito come gint? Questo e un identifi-
  catore per la vostra funzione di callback. Come detto sopra, si pos-
  sono avere piu funzioni di ritorno per ogni segnale e per ogni ogetto
  a seconda delle necessita, ed ognuna sara eseguita in sequenza,
  nell'ordine in cui e stata collegata.

  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);




  Cosi, passando il widget da cui si vuole rimuovere il gestore di seg-
  nale e l'identificativo restituito da una delle funzioni signal_con-
  nect, si puo rimuovere il gestore di segnale che si desidera dal wid-
  get.

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