gtk_tut_it.txt

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

      gtk_container_border_width (GTK_CONTAINER (window), 10);

      /* Creiamo una scatola verticale (vbox) in cui impacchettare quelle
       * orizzontali. Questo ci permette di impilare le scatole orizzontali
       * piene di bottoni una sull'altra in questa vbox. */

      box1 = gtk_vbox_new (FALSE, 0);

      /* Decide quale esempio si deve mostrare. Corrispondono alle figure precedenti */
      switch (which) {
      case 1:
          /* creare una nuova etichetta. */
          label = gtk_label_new ("gtk_hbox_new (FALSE, 0);");

          /* allineare l'etichetta al lato sinistro. Discuteremo questa e altre
           * funzioni nella sezione dedicata agli attributi degli oggetti grafici. */
          gtk_misc_set_alignment (GTK_MISC (label), 0, 0);

          /* Impacchettare l'etichetta nella scatola verticale (vbox box1).
           * Ricordare che gli oggetti che vengono aggiunti in una vbox vengono
           * impacchettati uno sopra all'altro in ordine. */
          gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);

          /* mostrare l'etichetta */
          gtk_widget_show (label);

          /* chiamare la nostra funzione make_box - homogeneous = FALSE,
           * spacing = 0, expand = FALSE, fill = FALSE, padding = 0 */
          box2 = make_box (FALSE, 0, FALSE, FALSE, 0);
          gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
          gtk_widget_show (box2);

          /* chiamare la nostra funzione make_box - homogeneous = FALSE, spacing = 0,
           * expand = FALSE, fill = FALSE, padding = 0 */
          box2 = make_box (FALSE, 0, TRUE, FALSE, 0);
          gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
          gtk_widget_show (box2);

          /* Gli argomenti sono: homogeneous, spacing, expand, fill, padding */
          box2 = make_box (FALSE, 0, TRUE, TRUE, 0);
          gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
          gtk_widget_show (box2);

          /* Questo crea un separatore. Li conosceremo meglio in seguito,
           * comunque sono piuttosto semplici. */
          separator = gtk_hseparator_new ();

          /* Impacchetta il separatore nella vbox. Ricordare che stiamo impacchettando
           * ognuno di questi oggetti in una vbox, cosicche essi verranno
           * impacchettati verticalmente. */
          gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
          gtk_widget_show (separator);

          /* crea un'altra nuova etichetta e mostrala. */
          label = gtk_label_new ("gtk_hbox_new (TRUE, 0);");
          gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
          gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
          gtk_widget_show (label);

          /* Gli argomenti sono: homogeneous, spacing, expand, fill, padding */
          box2 = make_box (TRUE, 0, TRUE, FALSE, 0);
          gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
          gtk_widget_show (box2);

          /* Gli argomenti sono: homogeneous, spacing, expand, fill, padding */
          box2 = make_box (TRUE, 0, TRUE, TRUE, 0);
          gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
          gtk_widget_show (box2);

          /* ancora un nuovo separatore. */
          separator = gtk_hseparator_new ();
          /* Gli ultimi 3 argumenti per gtk_box_pack_start sono: expand, fill, padding. */
          gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
          gtk_widget_show (separator);

          break;

      case 2:

          /* creare una nuova etichetta, ricordare che box1 e' la vbox creata
           * vicino all'inizio di main() */
          label = gtk_label_new ("gtk_hbox_new (FALSE, 10);");
          gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
          gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
          gtk_widget_show (label);

          /* Gli argomenti sono: homogeneous, spacing, expand, fill, padding */
          box2 = make_box (FALSE, 10, TRUE, FALSE, 0);
          gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
          gtk_widget_show (box2);

          /* Gli argomenti sono: homogeneous, spacing, expand, fill, padding */
          box2 = make_box (FALSE, 10, TRUE, TRUE, 0);
          gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
          gtk_widget_show (box2);

          separator = gtk_hseparator_new ();
          /* Gli ultimi tre arcomenti di gtk_box_pack_start sono: expand, fill, padding. */
          gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
          gtk_widget_show (separator);

          label = gtk_label_new ("gtk_hbox_new (FALSE, 0);");
          gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
          gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
          gtk_widget_show (label);
          /* Gli argomenti sono: homogeneous, spacing, expand, fill, padding */
          box2 = make_box (FALSE, 0, TRUE, FALSE, 10);
          gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
          gtk_widget_show (box2);

          /* Gli argomenti sono: homogeneous, spacing, expand, fill, padding */
          box2 = make_box (FALSE, 0, TRUE, TRUE, 10);
          gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
          gtk_widget_show (box2);

          separator = gtk_hseparator_new ();
          /* Gli ultimi tre argomenti di gtk_box_pack_start sono: expand, fill, padding. */
          gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
          gtk_widget_show (separator);
          break;

      case 3:

          /* Questo dimostra la possibilita' di usare use gtk_box_pack_end() per
           * giustificare gli oggetti a destra. Per prima cosa creiamo una
           * nuova scatola come prima. */
          box2 = make_box (FALSE, 0, FALSE, FALSE, 0);
          /* creiamo l'etichetta che sara' aggiunta alla fine. */
          label = gtk_label_new ("end");
          /* impacchettiamola usando gtk_box_pack_end(), cosa' che viene inserita
           * sul lato destro della hbox creata nella chiamata a the make_box(). */
          gtk_box_pack_end (GTK_BOX (box2), label, FALSE, FALSE, 0);
          /* mostriamo l'etichetta. */
          gtk_widget_show (label);

          /* impacchettiamo box2 in box1 (the vbox, ricordate? :) */
          gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
          gtk_widget_show (box2);

          /* un separatore per il fondo */
          separator = gtk_hseparator_new ();
          /* Questo assegna esplicitamente al separatore l'ampiezza di 400 pixel
           * e l'altezza di 5 pixel. Cio' fa si' che la hbox che abbiamo creato sia
           * anche essa larga 400 pixel, e che l'etichetta finale sia separata dalle
           * altre etichette nella hbox. In caso contrario, tutti gli oggetti nella
           * hbox sarebbero impacchettati il piu' vicino possibile. */
          gtk_widget_set_usize (separator, 400, 5);
          /* impacchetta il separatore nella vbox (box1) creata vicino all'inizio
           * di main() */
          gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
          gtk_widget_show (separator);
      }

      /* Creare un'altra nuova hbox.. ricordate che ne possiamo usare quante ne vogliamo! */
      quitbox = gtk_hbox_new (FALSE, 0);

      /* Il nostro bottone di uscita. */
      button = gtk_button_new_with_label ("Quit");


      /* Configuriamo il segnale per distruggere la finestra.  Ricordate che
       * cio mandera alla finestra il segnale "destroy", che verra catturato
       * dal nostro gestore di segnali che abbiamo definito in precedenza. */
      gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
                                 GTK_SIGNAL_FUNC (gtk_main_quit),
                                 GTK_OBJECT (window));
      /* impacchetta il bottone in quitbox.
       * Gli ultimi tre argomenti di gtk_box_pack_start sono: expand, fill, padding. */
      gtk_box_pack_start (GTK_BOX (quitbox), button, TRUE, FALSE, 0);
      /* impacchetta quitbox nella vbox (box1) */
      gtk_box_pack_start (GTK_BOX (box1), quitbox, FALSE, FALSE, 0);
      /* impacchetta la vbox (box1), che ora contiene tutti i nostri oggetti,
       * nella finestra principale. */
      gtk_container_add (GTK_CONTAINER (window), box1);

      /* e mostra tutto quel che rimane */
      gtk_widget_show (button);
      gtk_widget_show (quitbox);

      gtk_widget_show (box1);
      /* Mostriamo la finestra alla fine in modo che tutto spunti fuori assieme. */
      gtk_widget_show (window);

      /* E, naturalmente, la nostra funzione main. */
      gtk_main ();

      /* Il controllo ritorna a questo punto quando viene chiamata gtk_main_quit(),
       * ma non quando si usa gtk_exit. */

      return 0;
  }





  44..44..  IImmppaacccchheettttaammeennttoo ccoonn uussoo ddii TTaabbeellllee

  Diamo ora un'occhiata ad un altro modo di impacchettare - le Tabelle.
  In certe situazioni, possono risultare estremamente utili.

  Usando le tabelle, creiamo una griglia in cui possiamo piazzare gli
  oggetti.  Gli oggetti possono occupare tanti spazi quanti ne
  specifichiamo.

  Naturalmente, la prima cosa da vedere e la funzione gtk_table_new:



       GtkWidget* gtk_table_new (gint rows,
                                 gint columns,
                                 gint homogeneous);




  Il primo argomento rappresenta il numero di righe da mettere nella
  tabella, mentre il secondo e ovviamente il numero di colonne.

  L'argomento homogeneous ha a che fare con il modo in cui le caselle
  della tabella sono dimensionate. Se homogeneous ha il valore TRUE, le
  caselle sono ridimensionate fino alla dimensione del piu grande
  oggetto contenuto nella tabelle. Se e FALSE, la dimensione delle
  casellee decisa dal piu alto oggetto in una certa riga e dal piu largo
  oggetto in una stessa colonna.

  Le righe e le colonne sono disposte a partire da 0 fino a n, dove n e
  il numero che era stato specificato nella chiamata a gtk_table_new.
  Cosi, se specificate rows = 2 e columns = 2, lo schema avra questo
  aspetto:







   0          1          2
  0+----------+----------+
   |          |          |
  1+----------+----------+
   |          |          |
  2+----------+----------+




  Notate che il sistema di coordinate ha origine nel vertice in alto a
  sinistra. Per mettere un oggetto in una tabella, usate la seguente
  funzione:



       void gtk_table_attach (GtkTable      *table,
                              GtkWidget     *child,
                              gint           left_attach,
                              gint           right_attach,
                              gint           top_attach,
                              gint           bottom_attach,
                              gint           xoptions,
                              gint           yoptions,
                              gint           xpadding,
                              gint           ypadding);





  In cui il primo argomento (``table'') e la tabella che avete creato e
  il secondo (``child'') e l'oggetto che volete piazzare nella tabella.

  Gli argomenti ``attach''  (right, left, top, bottom)  specificano dove
  mettere l'oggetto e quante caselle adoperare. Se volete mettere un
  bottone nella casella in basso a destra nella nostra tabella 2x2, e
  volete che esso riempia SOLO quella casella, dovete porre left_attach
  = 1, right_attach = 2, top_attach = 1, bottom_attach = 2.

  Se invece volete che un oggetto si prenda tutta la riga piu in alto
  nella nostra tabella 2x2, dovreste usare left_attach = 0, right_attach
  =2, top_attach = 0, bottom_attach = 1.

  Gli argomenti  ``xoptions'' e ``yoptions'' sono usati per specificare
  le opzioni di impacchettamento; di essi si puo fare l'OR in modo di
  ottenere opzioni multiple.

  Le opzioni sono:

  +o  GTK_FILL - Se la parte di tabella in cui si vuole inserire il
     widget e piu grande dell'oggetto, e se si specifica GTK_FILL,
     l'oggetto viene espanso fino ad occupare tutto lo spazio
     disponibile.

  +o  GTK_SHRINK - Se si alloca all'oggetto nella tabella meno spazio del
     necessario (di solito succede quando l'utente ridimensiona la
     finestra), allora normalmente l'oggetto verrebbe spinto fuori dal
     fondo della finestra fino a sparire.  Se invece si specifica
     GTK_SHRINK is specified, gli oggetti si rimpiccioliscono assieme
     alla tabella.

  +o  GTK_EXPAND - Questo fa si che la tabella si espanda fino ad
     occupare tutto lo spazio che rimane nella finestra.


  Il riempimento funziona come nelle scatole, con la creazione di
  un'area vuota attorno all'oggetto la cui dimensione viene specificata
  in pixel.

  La funzione gtk_table_attach() ha UN MUCCHIO di opzioni. Quindi, ecco
  una scorciatoia:



       void gtk_table_attach_defaults (GtkTable   *table,
                                       GtkWidget  *widget,
                                       gint        left_attach,
                                       gint        right_attach,
                                       gint        top_attach,
                                       gint        bottom_attach);




  Le xoptions e yoptions vengono posti per difetto a GTK_FILL |
  GTK_EXPAND, e sia xpadding che ypadding vengono posti a 0. Il resto
  degli argomenti sono identici a quelli della funzione precedente.

  Ci sono poi le funzioni gtk_table_set_row_spacing() and
  gtk_table_set_col_spacing().  Queste mettono dello spazio fra le righe
  (o colonne)in corrispondenza di una specifica riga (o colonna).



       void gtk_table_set_row_spacing (GtkTable      *table,
                                       gint           row,
                                       gint           spacing);




  e


       void       gtk_table_set_col_spacing  (GtkTable      *table,
                                              gint           column,
                                              gint           spacing);




  Notate che per le colonne lo spazio viene posto alla destra della
  colonna, mentre per le righe lo spazio viene posto al di sotto della
  riga.

  Si puo poi inserire una spaziatura identica fra tutte le righe e/o
  colonne usando:



       void gtk_table_set_row_spacings (GtkTable *table,
                                        gint      spacing);




  e




  void gtk_table_set_col_spacings (GtkTable  *table,
                                   gint       spacing);




  Notate che con queste chiamate,  all'ultima riga e all'ultima colonna
  non viene assegnata alcuna spaziatura.


  44..55..  EEsseemmppiioo ddii IImmppaacccchheettttaammeennttoo ccoonn TTaabbeellllee

  In questo esempio creiamo una finestra avente tre bottoni disposti in
  una tabella 2x2. I primi due bottoni li mettiamo nella riga superiore.