gtk_tut_it.txt

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

  Un terzo bottone, quit, lo mettiamo nella riga inferioe, in modo da
  comprendere entrambe le colonne. Cio significa che dovremmo avere
  qualcosa di questo tipo:

  <CENTER > <IMG SRC="gtk_tut_table.gif" VSPACE="15" HSPACE="10"
  ALT="Table Packing Example Image" WIDTH="180" HEIGHT="120" > </CENTER
  >

  Ecco il codice sorgente:











































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

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

  /* questa funzione fa uscire dal programma */
  void delete_event (GtkWidget *widget, gpointer data)
  {
      gtk_main_quit ();
  }

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

      gtk_init (&argc, &argv);

      /* creiamo una nova finestra */
      window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

      /* predisponiamo il titolo per la finestra */
      gtk_window_set_title (GTK_WINDOW (window), "Table");

      /* creiamo un gestore per delete_event che esca immediatamente
       * da GTK. */
      gtk_signal_connect (GTK_OBJECT (window), "delete_event",
                          GTK_SIGNAL_FUNC (delete_event), NULL);

      /* regoliamo la larghezza del bordo della finestra. */
      gtk_container_border_width (GTK_CONTAINER (window), 20);

      /* creiamo una tabella 2x2 */
      table = gtk_table_new (2, 2, TRUE);

      /* mettiamo la tabella nella finesta principale */
      gtk_container_add (GTK_CONTAINER (window), table);

      /*creiamo il primo bottone */
      button = gtk_button_new_with_label ("button 1");
      /* quando viene premuto il bottone, chiamiamo la funzione di ritorno
       * con un puntatore a "button 1"come argomento */
      gtk_signal_connect (GTK_OBJECT (button), "clicked",
                GTK_SIGNAL_FUNC (callback), (gpointer) "button 1");


      /* inseriamo il bottone 1 nel quadrante in alto a sinistra della tabella */
      gtk_table_attach_defaults (GTK_TABLE(table), button, 0, 1, 0, 1);

      gtk_widget_show (button);

      /* creiamo il secondo bottone */

      button = gtk_button_new_with_label ("button 2");

      /* quando si preme il bottone, chiamamo la funzione di ritorno
       * con un puntatore a "button 2"come argomento */
      gtk_signal_connect (GTK_OBJECT (button), "clicked",
                GTK_SIGNAL_FUNC (callback), (gpointer) "button 2");
      /* inseriamo il secondo bottone nel quadrate in alto a destra della tbella */
      gtk_table_attach_defaults (GTK_TABLE(table), button, 1, 2, 0, 1);

      gtk_widget_show (button);

      /* creiamo il botone "Quit" */
      button = gtk_button_new_with_label ("Quit");

      /* quando viene premuto questo bottone, chiamiamo la funzione "delete_event"
       * e si esce dal programma */
      gtk_signal_connect (GTK_OBJECT (button), "clicked",
                          GTK_SIGNAL_FUNC (delete_event), NULL);

      /* inseriamo il pulsante quit nelle due casele in basso della tabella */
      gtk_table_attach_defaults (GTK_TABLE(table), button, 0, 2, 1, 2);

      gtk_widget_show (button);

      gtk_widget_show (table);
      gtk_widget_show (window);

      gtk_main ();

      return 0;
  }





  55..  PPaannoorraammiiccaa ssuuii WWiiddggeett

  La procedura generale di creazione di un widget in GTK prevede i
  seguenti passi:

  1. gtk_*_new - una delle varie funzioni che servono per greare un
     nuovo widget.  In questa sezione le vedremo tutte in dettaglio.

  2. Connettere tutti i segnali che si vogliono usare alle funzione
     gestione appfropriate.

  3. Assegnare gli attributi all'oggetto.

  4. Impacchettare l'oggetto in un contenitore usando la chiamate
     appropriata, per esempio gtk_container_add() o
     gtk_box_pack_start().

  5. Mostrare l'oggetto con gtk_widget_show().

  gtk_widget_show() fa si che GTK sappia che abbiamo terminato di
  assegnare gli attributi dell'oggetto grafico, e che e pronto per
  essere visualizzato.  Si puo anche usare la funzione gtk_widget_hide
  per farlo sparire di nuovo.  L'ordine in cui mostrate gli oggetti
  grafici non e importante, ma io suggerisco di mostrare per ultima la
  finestra, in modo che questa spunti fuori gia completa, invece di
  vedere i singoli oggetti che arrivano sullo schermo a mano a mano che
  si formano. I figli di un oggetto grafico (anche una finestra e un
  oggetto grafico) non vengono infatti mostrati finche la finestra
  stessa non viene mostrata usando la funzione gtk_widget_show().


  55..11..  CCaassttiinngg

  Noterete andando avanti che GTK usa un sistema di casting di tipo.
  Questa operazione viene sempre effettuata usando delle macro che allo
  stesso tempo controllano la possibilita di effettuare il cast
  sull'elemento dato e lo effettuano realmente.  Alcune macro che avrete
  modo di incontrare sono:


  +o  GTK_WIDGET(widget)

  +o  GTK_OBJECT(object)

  +o  GTK_SIGNAL_FUNC(function)

  +o  GTK_CONTAINER(container)

  +o  GTK_WINDOW(window)

  +o  GTK_BOX(box)

  Tutte queste funzioni  sono usate per fare il cast di argomenti di
  funzione. Le vedrete negli esempi, e capirete se e il caso di usarle
  semplicemente guardando alle dichiarazioni delle funzioni.

  Come potrete vedere piu sotto nella gerarchia delle classi, tutti i
  GtkWidgets sono derivati dalla classe base GtkObject. Cio significa
  che potete usare un widget in ogni posto in cui una funzione richiede
  un oggetto - semplicemente usate la macro GTK_OBJECT().

  Per esempio:



       gtk_signal_connect(GTK_OBJECT(button), "clicked",
                          GTK_SIGNAL_FUNC(callback_function), callback_data);





  Questo fa il cast del bottone in un oggetto e fornisce alla chiamata
  di ritorno un cast al puntatore a funzione.

  Molti oggetti grafici sono anche contenitori. Se guardate alla
  gerarchia delle classi piu sotto, vedrete che molti oggetti grafici
  sono derivati dalla classe GtkContainer. Ognuna di queste classi puo
  essere usata, con la macro GTK_CONTAINER, come argomento per funzioni
  che richiedono un contenitore.

  Sfortunatamente, in questo tutorial non si parlera in modo estensivo
  di queste macro, ma raccomando di dare un'occhiata ai file header di
  GTK. Puo essere una cosa molto educativa. Infatti, non e difficile
  imparare come funziona un oggetto solo guardando le dichiarazioni
  delle funzioni.


  55..22..  GGeerraarrcchhiiaa ddeeggllii OOggggeettttii GGrraaffiiccii

  Ecco, per vostro riferimento, la gerarchia delle classi usata per
  implementare gli oggetti grafici.











    GtkObject
     +GtkData
     | +GtkAdjustment
     | `GtkTooltips
     `GtkWidget
       +GtkContainer
       | +GtkBin
       | | +GtkAlignment
       | | +GtkEventBox
       | | +GtkFrame
       | | | `GtkAspectFrame
       | | +GtkHandleBox
       | | +GtkItem
       | | | +GtkListItem
       | | | +GtkMenuItem
       | | | | `GtkCheckMenuItem
       | | | |   `GtkRadioMenuItem
       | | | `GtkTreeItem
       | | +GtkViewport
       | | `GtkWindow
       | |   +GtkColorSelectionDialog
       | |   +GtkDialog
       | |   | `GtkInputDialog
       | |   `GtkFileSelection
       | +GtkBox
       | | +GtkButtonBox
       | | | +GtkHButtonBox
       | | | `GtkVButtonBox
       | | +GtkHBox
       | | | +GtkCombo
       | | | `GtkStatusbar
       | | `GtkVBox
       | |   +GtkColorSelection
       | |   `GtkGammaCurve
       | +GtkButton
       | | +GtkOptionMenu
       | | `GtkToggleButton
       | |   `GtkCheckButton
       | |     `GtkRadioButton
       | +GtkCList
       | +GtkFixed
       | +GtkList
       | +GtkMenuShell
       | | +GtkMenuBar
       | | `GtkMenu
       | +GtkNotebook
       | +GtkPaned
       | | +GtkHPaned
       | | `GtkVPaned
       | +GtkScrolledWindow
       | +GtkTable
       | +GtkToolbar
       | `GtkTree
       +GtkDrawingArea
       | `GtkCurve
       +GtkEditable
       | +GtkEntry
       | | `GtkSpinButton
       | `GtkText
       +GtkMisc
       | +GtkArrow
       | +GtkImage
       | +GtkLabel
       | | `GtkTipsQuery
       | `GtkPixmap
       +GtkPreview
       +GtkProgressBar
       +GtkRange
       | +GtkScale
       | | +GtkHScale
       | | `GtkVScale
       | `GtkScrollbar
       |   +GtkHScrollbar
       |   `GtkVScrollbar
       +GtkRuler
       | +GtkHRuler
       | `GtkVRuler
       `GtkSeparator
         +GtkHSeparator
         `GtkVSeparator





  55..33..  OOggggeettttii sseennzzaa FFiinneessttrree

  Gli oggetti seguenti non hanno una finestra associata. Se volete
  catturare degli eventi, dovrete usare l'oggetto GtkEventBox. Vedete
  anche la sezione su ``Il Widget EventBox''



       GtkAlignment
       GtkArrow
       GtkBin
       GtkBox
       GtkImage
       GtkItem
       GtkLabel
       GtkPixmap
       GtkScrolledWindow
       GtkSeparator
       GtkTable
       GtkAspectFrame
       GtkFrame
       GtkVBox
       GtkHBox
       GtkVSeparator
       GtkHSeparator




  Proseguiremo la nostra esplorazione di GTK esaminando uno alla volta
  tutti gli oggetti, creando qualche semplice funzione per mostrarli.
  Un'altra buona sorgente e il programma testgtk.c che viene fornito con
  GTK. Potete trovarlo in gtk/testgtk.c.


  66..  IIll WWiiddggeett BBoottttoonnee ((BBuuttttoonn))

  66..11..  BBoottttoonnii NNoorrmmaallii

  Ormai abbiamo visto tutto quello che c'e da vedere riguardo
  all'oggetto ``bottone''. E' piuttosto semplice, ma ci sono due modi
  per crare un bottone.  Potete usare gtk_button_new_with_label() per
  creare un bottone con una etichetta, o usare gtk_button_new() per
  creare un bottone vuoto. In tal caso e poi vostro compito
  impacchettare un'etichetta o una pixmap sul bottone creato.  Per fare
  cio, create una nuova scatola, e poi impacchettateci i vostri oggetti
  usando la solita  gtk_box_pack_start, e infine usate la funzione
  gtk_container_add per impacchettare la scatola