Introduzione

*http://corsogtk.chipsy.it/

*

*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 :

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

}

*

*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),…)

*GtkObject

*GtkWidget

* GtkContainer

* GtkBin

* GtkWindow

* GtkDialog

* …

* GtkButton

* …

* GtkComboBox

* …

* …

* GtkBox

* GtkButtonBox

* GtkHButtonBox

* GtkVButtonBox

* GtkVBox

* GtkHBox

* GtkFixed

* GtkIconView

* GtkLayout

* GtkTable

* …

* …

*GtkWidget

*GtkEntry

* GtkSpinButton

*GtkProgress

* GtkProgressBar

*GtkSeparator

* GtkHSeparator

* GtkVSeparator

*…

Potete trovare una lista completa qui :

http://developer.gnome.org/gtk2/2.24/ch01.html

*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.

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

*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

* 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

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

"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

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

*

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

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

* 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.

* 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

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