hds619.net » Blog

Mi scuso in anticipo per l’abbandono sia del blog in generale sia della guida andando nello specifico, purtroppo ho avuto un sacco di impegni sia realmente che virtualmente, da questo momento in poi il fine settimana sarò un po’ più libero e dedicherò qualche minuto a voi.
Ho scoperto, con piacere, che alcune persone hanno trovato questa guida a puntate utile. Sono molto soddisfatto di ciò, vuol dire che non sono proprio una frana a spiegare le cose

Nell’ultima puntata, qualche secolo fa, avevo preannunciato che in questa avremmo iniziato a parlare dei contenitori.
Benissimo, non perdiamo altro tempo e iniziamo!

Box

Dunque il tipo box, o meglio, GtkBox, è uno dei tipi più semplici per “impacchettare” i widget. Vi chiederete forse “che vuol dire impacchettare? a che serve?”. Iniziamo a rispondere alla prima domanda, impacchettare vuol dire inserire uno o più widget dentro un altro; mentre per quanto riguarda lo scopo possiam dire che i vari contenitori servono per dare un aspetto migliore all’interfaccia, ovvero a posizionare per bene i widget.. ad esempio se si vuole fare un interfaccia con il titolo su una riga e sotto seguito da due bottoni uno di fianco all’altro.

Vediamo subito un esempio che rende tutto più chiaro:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

#include <gtk/gtk.h>
 
int main (int argc, char *argv[])
{
 GtkWidget *window, *hbox, *vbox, *widget;
 
 gtk_init (&argc, &argv);
 
 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 gtk_window_set_title (GTK_WINDOW (window), "Test con i Box");
 gtk_window_set_default_size (GTK_WINDOW (window), 300, 100);
 gtk_container_set_border_width (GTK_CONTAINER (window), 3);
 
 vbox = gtk_vbox_new (FALSE, 2);
 gtk_container_add (GTK_CONTAINER (window), vbox);
 
 hbox = gtk_hbox_new (FALSE, 0);
 gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
 
 widget = gtk_label_new ("Ciao BOX!");
 gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, FALSE, 0);
 
 hbox = gtk_hbox_new (FALSE, 0);
 gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
 
 widget = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
 gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
 g_signal_connect (G_OBJECT (widget), "clicked", G_CALLBACK (gtk_main_quit), NULL);
 
 widget = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
 gtk_box_pack_start (GTK_BOX (hbox), widget, TRUE, TRUE, 0);
 g_signal_connect (G_OBJECT (widget), "clicked", G_CALLBACK (gtk_main_quit), NULL);
 
 gtk_widget_show_all (window);
 gtk_main ();
 
 return 0;
}

Innanzitutto, prima di spiegare il codice, bisogna notare che esistono due tipi di box: orizzontali e verticali. La differenza tra i due si può immaginare: se vengono impacchettati widget in un box orizzontale saranno messi uno di fianco all’altro, mentre se si impacchettano widget in un box verticale verranno messi uno sotto ( o sopra ) l’altro.

In questo codice noi vediamo il box principale che è verticale, al cui interno abbiamo inserito dei box orizzontali. La funzione gtk_box_pack_start permette di inserire un widget in un box allineandolo all’inizio del box, riceve come parametri:

1.  il box in cui inserire il widget
2. il widget da inserire
3. TRUE se si vuole che il widget venga “espanso” occupando tutto lo spazio possibile, altrimenti FALSE
4. TRUE se si vuole che il widget venga “attaccato” all’inizio del box
5. Spazio aggiuntivo in pixel con i widget “vicini”, una specie di bordo.

Naturalmente esistono altre funzioni per impacchettare i widget e li potete trovare con relativa descrizione ( in inglese ) qui.

Lasciando stare ora l’impacchettamento,  guardiamo la creazione che è molto più veloce. Come si può vedere nel codice ho utilizzato due semplici funzioni per creare un box: gtk_hbox_new, gtk_vbox_new. Si può intuire che la prima sia per creare box orizzontali, mentre la seconda verticali. Ricevono entrambe come parametri:

1. TRUE se si vuole che i widget inseriti abbiano tutti lo stesso spazio nel box.
2. Distanza in pixel tra i vari widget inseriti.

Esiste però un altro tipo di box di cui non ho ancora parlato, ed è un box specifico per i pulsanti e il loro allineamento, il suo nome è GtkButtonBox. Anche lui può essere orizzontale e verticale.. vediamo un esempio:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#include <gtk/gtk.h>
 
int main (int argc, char *argv[])
{
  GtkWidget *window, *button, *button_box;
  int i = 0;
 
  gtk_init (&argc, &argv);
 
  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_window_set_default_size (GTK_WINDOW (window), 400, -1);
 
  button_box = gtk_hbutton_box_new ();
  gtk_button_box_set_layout (GTK_BUTTON_BOX (button_box), GTK_BUTTONBOX_EDGE);
  gtk_container_add (GTK_CONTAINER (window), button_box);
 
  while ( i++ < 3 ) {
          button = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
          gtk_box_pack_start_defaults (GTK_BOX (button_box), button);
          g_signal_connect (G_OBJECT (button), "clicked",
                            G_CALLBACK (gtk_main_quit), NULL);
  }
 
  gtk_widget_show_all (window);
 
  gtk_main ();
  return 0;
}

A differenza dei normali box, la creazione di un nuovo button box non richiede argomenti, ma richiede invece, eventualmente, il tipo di layout che dovranno avere i pulsanti inseriti al suo interno. I layout disponibili sono:

• GTK_BUTTONBOX_DEFAULT_STYLE -> Layout di default
• GTK_BUTTONBOX_SPREAD -> I pulsanti avranno tutti lo stesso spazio sia tra di loro sia riguardo i bordi.
• GTK_BUTTONBOX_EDGE -> Come per il layout SPREAD, solo che non c’è spazio ai bordi
• GTK_BUTTONBOX_START -> I pulsanti vengono allineati tutti all’inizio
• GTK_BUTTONBOX_END -> I pulsanti vengono allineati tutti alla fine
• GTK_BUTTONBOX_CENTER -> I pulsanti vengono allineati tutti al centro

Fine Nona Puntata
Bene, preferisco fermarmi qui, così la prossima volta potremmo affrontare con più calma le tabelle e tutto il resto sui contenitori.
Ciauz