Il documento fornisce una guida introduttiva all'uso delle GTK, evidenziando la necessità di includere le librerie GTK e di inizializzare l'ambiente prima di avviare l'applicazione. Descrive inoltre la programmazione basata su eventi, l'uso dei widget e delle finestre, inclusi vari metodi e funzioni per gestire eventi, stili e dimensioni dei widget. Infine, illustra la struttura delle finestre e come aggiungere widget a esse, enfatizzando l'importanza di gestire correttamente gli eventi di chiusura per mantenere il ciclo principale dell'applicazione attivo.

1. * http://corsogtk.chipsy.it/
Introduzione

2. *

3. * Per poter iniziare a usare le GTK abbiamo
bisogno di dichiarare le sue librerie.
Per far questo inseriamo tra gli include la seguente
riga :
#include <gtk/gtk.h>
* Le gtk possono ricevere parametri per via
esterna (possiamo trovare una lista qui :
http://developer.gnome.org/gtk2/2.24/gtk-
windows.html) e per questo motivo dobbiamo
avviarle passandogli i parametri con cui è stato
chiamato il programma :

4. #include <gtk/gtk.h>
int main(int argc,char *argv[]) {
//Inizializzo le GTK
gtk_init (&argc, &argv);
/*
Qui ci va il corpo del nostro
programma
*/
//Avvio il loop principale delle GTK
gtk_main ();
return 0;
}

5. *

6. * Nelle GTK avremmo sempre a che fare con i Widget.
I Widget non sono altro che tutti gli oggetti del
programma che vengono mostrati a schermo,
Le GTK si basano sull’ereditarietà delle classi, dove ogni
diverso oggetto è una classe.
Possiamo vedere un chiaro esempio di ereditarietà con
queste 2 classi :
Il GtkEntry (padre) :
E il GtkSpinButton (figlio) :
Il GtkSpinButton gode di tutte le proprietà del padre
(accesso al testo, etc..).
Però per poter accedere alle proprietà del padre
dobbiamo prima farlo diventare del tipo del padre nel
seguente modo :
gtk_nome_funzione(GTK_PADRE(variabile_figlio),…)

7. * GtkObject
* GtkWidget
* GtkContainer
* GtkBin
* GtkWindow
* GtkDialog
*…
* GtkButton
*…
* GtkComboBox
*…
* …
* GtkBox
* GtkButtonBox
* GtkHButtonBox
* GtkVButtonBox
* GtkVBox
* GtkHBox
* GtkFixed
* GtkIconView
* GtkLayout
* GtkTable
*…
*…

8. * GtkWidget
* GtkEntry
* GtkSpinButton
* GtkProgress
* GtkProgressBar
* GtkSeparator
* GtkHSeparator
* GtkVSeparator
*…
Potete trovare una lista completa qui :
http://developer.gnome.org/gtk2/2.24/ch01.html

9. * Per poter utilizzare un widget (di qualunque tipo) come ogni
variabile va prima dichiarato..
Il tipo di variabile è lo stesso per tutti i Widget ed è sempre un
puntatore :
GtkWidget *mio_oggetto;
* Punto fondamentale del funzionamento delle GTK è il sistema ad
eventi, la programmazione a eventi si discosta dalla
programmazione struttura per il modo in cui vengono richiamate le
funzioni.

10. * In questo tipo di programmazione potremmo impostare che quando
avviene un determinato evento (es. pressione di un bottone) deve
essere avviata una determinata funzione.
Per poter collegare una funzione a un evento dobbiamo usare questa
funzione :
g_signal_connect(GTK_TIPO_OGGETTO_EVENTO(mio_oggetto),
"nome_evento", G_CALLBACK (mia_funzione), (gpointer)
argomento_utente)
La funzione verrà chiamata quando si verifica l’evento da noi scelto
legato a un determinato oggetto, inoltre alla funzione verrà passato un
argomento extra che noi scegliamo quando connettiamo la funzione
(possiamo mettere NULL se non vogliamo argomenti extra)

11. * La classe Widget ha molte proprietà e funzione e
ovviamente tutti quanti i Widget che vedremo le
ereditano, ma essendo tante terremo conto solo di
quelle più importanti :
* gtk_widget_set_size_request (widget,int larghezza,int
altezza);
Con questa funzione possiamo dare a un determinato widget
le dimensioni che vogliamo (se il contenuto del widget è più
grande di queste dimensioni, il widget verrà ridimensionato
per poterle contenere)
Dando il valore -1 a un delle dimensioni questa verrà
impostata automaticamente
* gtk_widget_set_style (widget, GtkStyle *style)
Questa funzione serve per impostare uno stile a un
determinato widget, per maggiori approfondimenti clicca su
GtkStyle

12. * gtk_widget_show (widget);
Con questa funzione si mostra un widget, se non la si usa non
verrà visualizzato
* gtk_widget_show_all (widget);
Si mostra il widget e tutti i widget in esso contenuti, molto
utile con le finestre, quando si finisce di creare la finestra e
tutto il suo contenuto con questa funzione si può mostrare
tutto senza dover usare gtk_widget_show singolarmente su
ogni widget contenuto
* gtk_widget_hide (widget);
Nasconde un widget
* gtk_widget_hide_all (widget);
Nasconde un widget e tutti i widget in esso contenuti

13. * Oltre a funzioni esistono vari eventi legati ai widget :
* "button-press-event"
g_signal_connect(GTK_WIDGET(mio_oggetto), "button_press_event",
G_CALLBACK ( mouse_click ), NULL);
La funzione legata a questo evento viene richiamata quando si preme il
bottone del mouse sopra un widget.
Le funzione che dobbiamo collegare deve avere questa forma :
static gboolean mouse_click(GtkWidget *widget,GdkEventButton
*event,gpointer user_data) {
return TRUE;
}
L’attributo «event» è un puntatore a una struttura, se siete su codeblocks vi
basterà scrivere event-> e vi apparirà subito il contenuto, tra le variabili
dentro event degne di nota ci sono :
* x,y : posizione del cursore quando si ha cliccato relativo alla finestra
* x_root,y_root : posizione del cursore relativa allo schermo
* button : numero che identifica il bottone del mouse
Se fate restituire TRUE alla funzione l’evento si ripercuoterà pure agli oggetti
solo all’oggetto (ad esempio se clicchi su un bottone in una finestra, se metti
TRUE verrà chiamato pure il click sulla finestra)

14. "button-release-event"
* Uguale a quello appena visto ma quando il bottone del mouse non viene più
premuto
"delete-event"
* Quando il widget sta per venire distrutto, forma della funzione :
* gboolean nome_funzione(GtkWidget *widget,GdkEvent *event,gpointer user_data);
Se si restituisce TRUE il widget verrà eliminato, questa funzione è molto utile con
le finestre, perché le finestre quando vengono chiuse vengono distrutte e viene
richiamato questo evento.
"hide"
* Quando il widget viene nascosto :
* void user_function (GtkWidget *widget, gpointer user_data);
"key-press-event"
* Quando viene premuto un tasto della tastiera e il widget è selezionato :
* Gboolean user_function (GtkWidget *widget, GdkEvent *event, gpointer
user_data)
* Per ottenere il tasto premuto si usa : event->key->keyval
* Documentazione maggiore su : http://developer.gnome.org/gdk/stable/gdk-Event-
Structures.html#GdkEventKey

15. "key-release-event"
* Uguale a quello appena visto ma il tasto non viene più premuto
"motion-notify-event"
* Quando si passa il mouse su un widget :
* Gboolean user_function (GtkWidget *widget, GdkEvent *event,gpointer
user_data);
* Se la funzione ritorna TRUE l’evento si propaga anche a quelli sotto.
* In event si trovano le coordinate del mouse e altre informazioni
"show"
* Quando il widget viene mostrato :
* void user_function (GtkWidget *widget, gpointer user_data);

16. *

17. * Le finestre son il widget più importante delle GTK, e tutti
i widget che andremmo a inserire dovremmo metterli
dentro le finestre.
Esistono 2 tipi di finestre :
1. GTK_WINDOW_TOPLEVEL
Queste son le finestre classiche quelle che usiamo sempre, non
c’è molto da dire.
2. GTK_WINDOW_POPUP
Son delle finestre di «seconda categoria» non hanno decorazioni e
il gestore di finestre le ignora (non funzionano riduci a icona,
massimizza etc..)
Quando creiamo una finestra dobbiamo quindi dire che tipo
di finestra vogliamo usare :
GtkWidget *finestra;
finestra = gtk_window_new(GTK_WINDOW_TOPLEVEL);

18. * Possiamo modificare le nostre finestre come meglio
preferiamo :
* gtk_window_set_title (finestra, "Titolo finestra");
Con questa funzione possiamo modificare il titolo della finestra
* gtk_window_set_position (finestra,GTK_WIN_POS_CENTER_ALWAYS);
Con questa funzione possiamo impostare dove vogliamo che si trovi la nostra
finestra :
* GTK_WIN_POS_NONE
* GTK_WIN_POS_CENTER
* GTK_WIN_POS_MOUSE
* GTK_WIN_POS_CENTER_ALWAYS
* GTK_WIN_POS_CENTER_ON_PARENT
* gtk_window_set_resizable (finestra,TRUE);
Con questa funzione diciamo alle GTK se la finestra può essere
ridimensionata dall’utente (Attento! Le finestre si auto ridimensionano lo
stesso in base al contenuto)

19. * gtk_window_set_modal (finestra,FALSE);
Una finestra modale, è una finestra che quando è visualizzata non permette
di interagire con le altre finestre (come ad esempio un messaggio di
errore,informazione,etc..)
* gtk_window_set_decorated (finestra, TRUE);
Imposta se deve essere visualizzata la decorazione della finestra (titolo e
pulsanti riduci,ingrandisci,chiudi);
* gtk_window_set_icon (finestra, GdkPixbuf *);
Imposta l’icona scelta alla finestra, il secondo parametro lo vedremmo
nelle lezioni successive…
Un modo alternativo per impostare l’icona è quella di scrivere
l’indirizzo del file dell’icona tra i define del programma :
#define gtk_window_set_icon_from_file nome_file
Il nome del file deve essere in codifica UTF8, non c’è bisogno che verifichiate
se la codifica è corretta se non usate lettere accentate.

20. * gtk_container_add (GTK_CONTAINER(finestra), widget);
Questa funzione serve per inserire dei widget dentro la nostra
finestra, la funzione appartiene alla classe padre GtkContainer
e per questo motivo dobbiamo fare un cast per poterla usare.
Il primo parametro è la finestra in cui mettere il widget,
Il secondo parametro è il widget da inserire.
Per finire una piccola precisazione :
Quando una finestra viene chiusa, questa finestra viene
distrutta, non nascosta. Come evitarne la distruzione l’ho
spiegato un paio di slide fa’.
Una cosa importante è che anche se il programma è
composto da una sola finestra se questa viene distrutta, il
programma non termina ma rimane quello da terminare.
Per risolvere questo problema, possiamo connettere un
evento alla finestra principale :
g_signal_connect(GTK_OBJECT(finestra_principale
), "destroy", G_CALLBACK ( gtk_main_quit ),
NULL);
La funzione gtk_main_quit è una funzione delle gtk che
termina il ciclo principale chiudendo il programma

21. Note sulle finestre :
Le finestre a differenza degli altri widget per poter ricevere gli
eventi legati alla tastiera e al mouse vanno prima abilitate, per
fare questo dobbiamo usare :
gtk_widget_set_events(GTK_WIDGET(finestra),
eventi_da_ricevere );
Il primo parametro è la finestra da autorizzare, il secondo quali
eventi può ricevere, son dei flag con un solo bit attivo quindi
dobbiamo usare un or bitwise per mettere più di un’evento :
gtk_widget_set_events(GTK_WIDGET(win),
gtk_widget_get_events(win) | GDK_POINTER_MOTION_MASK |
GDK_BUTTON_PRESS_MASK);
* Questi son i flag da usare per ogni evento :
* GDK_POINTER_MOTION_MASK : "motion-notify-event"
* GDK_BUTTON_PRESS_MASK : "button-press-event"
* GDK_BUTTON_RELEASE_MASK : "button-release-event"
* GDK_KEY_PRESS_MASK : "key-press-event"
* GDK_KEY_RELEASE_MASK : "key-release-event"
* GDK_ALL_EVENTS_MAS : tutti quanti