GTK - Référence

Bourg-en-Bresse
Première année
Année scolaire 2003-2004
La bibliothèque GTK
La bibliothèque GTK
Polycopié de référence
Dans ce document vous trouverez les principaux élément de la bibliothèque GTK.
Table des matières
1 Introduction 2
2 Positionnement de Widgets 5
3 Les boutons 6
4 Les Widgets ajustables 7
5 Entrée de données 8
6 Les fenêtres 8
7 Les éléments d'affichage 11
8 Les listes et arbres 13
9 Les menus 15
10 Les zones de dessin 16
Eric Guérin
[email protected]
15 décembre 2004 1/20

Année scolaire 2003-2004
La bibliothèque GTK
Bourg-en-Bresse
Première année
1 Introduction
GTK (The Gimp Toolkit) est une librairie permettant de gérer une interface graphique. Initialement destinée au monde unix et à
X-Window, celle-ci a été portée sous Windows. De nombreux couplages avec des langages ont été faits (comme Perl ou Python).
Des outils de développement d'interface graphique rapide existent. Glade, par exemple permet de générer automatiquement du code
pour le C, Perl ou Python. De nombreux logiciels libres sont construits sur la base de GTK (Gimp, le projet Gnome, Glade, Gnumeric,
Abiword,. . .).
1.1 Mise en ÷uvre sous linux
La dernière version de GTK (GTK+ 2.0) fonctionne avec l'outil pkg-config. Si GTK est bien installé, la commande suivante doit
fonctionner :
$ pkg-config --cflags gtk+-2.0
De même, l'option --libs vous donne les options à inclure pour que les librairies nécessaires à l'édition des liens d'un programme
utilisant GTK fonctionne :
$ pkg-config --libs gtk+-2.0
Ainsi, le Makefile d'un programme utilsant GTK sera du type :
default: programme
programme: programme.o
gcc -Wall -g programme.c -o programme ‘pkg-config --cflags --libs gtk+-2.0‘
Ici, comme il n'y a qu'un code source, on peut compiler et faire l'édition des liens dans la même ligne de commande, d'où la présence
des deux options --cflags et --libs.
1.2 Mise en ÷uvre sous Windows
Vous devez d'abord installer toutes les librairies, ainsi qu'un compilateur adéquate. Je recommande MinGW et l'environnement MSYS
qui fournissent un environnement GNU assez complet.
Le Makefile ressemblera beaucoup à celui sous linux, la seule différence étant que les options -fnative-struct et/ou
-mms-bitfields doivent être activées.
Attention : Les versions des librairies sont différentes pour MinGW, Cygwin où d'autres compilateurs, veillez à bien lire la
documentation.
1.3 Widgets, signaux et évènements
GTK est une librairie d'interfaçage graphique. C'est une surcouche de Glib et GDK. L'interface est composée de Widgets (exemples :
une fenêtre, un bouton, un menu,. . .). Ces objets communiquent avec l'extérieur grâce à des signaux (gérés par Glib). Lorsque
l'utilisateur clique sur un bouton par exemple, le signal correspondant va être émis. Ce signal, s'il n'est pas connecté ne va avoir
aucune influence. Pour le connecter, il faut utiliser la fonction g_signal_connect :
gulong g_signal_connect( gpointer *object,
const gchar *name,
GCallback func,
gpointer func_data );
Le premier argument est l'objet concerné, le deuxième est le nom du signal, le troisième est le pointeur sur la fonction qui doit être
appelée. Le dernier argument concerne des données eventuelles passées à la fonction.
La fonction qui doit être appelée est du type :
void callback_func( GtkWidget *widget,
gpointer callback_data );
Les signaux qui sont liés à l'interfaçage graphique sont appelés évènements (events), ils sont gérés par GDK. En voici la liste :
2/20 15 décembre 2004 Eric Guérin
[email protected]

Bourg-en-Bresse
Première année
Année scolaire 2003-2004
La bibliothèque GTK
event
button_press_event
button_release_event
scroll_event
motion_notify_event
delete_event
destroy_event
expose_event
key_press_event
key_release_event
enter_notify_event
leave_notify_event
configure_event
focus_in_event
focus_out_event
map_event
unmap_event
property_notify_event
selection_clear_event
selection_request_event
selection_notify_event
proximity_in_event
proximity_out_event
visibility_notify_event
client_event
no_expose_event
window_state_event
Il existe aussi des évènements liés au drag-and-drop qui sont déclenchés par le widget source ou destination :
selection_received
selection_get
drag_begin_event
drag_end_event
drag_data_delete
drag_motion
drag_drop
drag_data_get
drag_data_received
Dans le cas des évènements, on utilisera comme fonction de retour le type suivant :
gint callback_func( GtkWidget *widget,
GdkEvent *event,
gpointer callback_data );
Exemple de connexion de l'évènement button_press_event d'un bouton à la fonction button_press_callback :
g_signal_connect (G_OBJECT (button), "button_press_event",
G_CALLBACK (button_press_callback), NULL);
1.4 Forçage de type
Dans l'exemple précédent, on utilise des macros prédéfinies G_OBJECT et G_CALLBACK pour faire des forçages de type. Par
exemple, G_CALLBACK est définie ainsi :
#define G_CALLBACK(f) ((GCallback) (f))
Cela fait apparaître un forçage de type comme une fonction mais ne vous y trompez pas !
1.5 Exemple complet
Le code ci dessous permet de générer une interface très simple contenant une fenêtre, un bouton qui lorsque l'on
clique dessus ferme la fenêtre (capture d'écran ci-contre).
Ici, pas vraiment de surprise, on doit inclure gtk.h qui se charge lui-même d'inclure bien d'autres fichiers.
#include <gtk/gtk.h>
Définition d'une fonction de retour, ici les données passées en argument sont tout simplement ignorées.
static void hello( GtkWidget *widget,
gpointer data )
{
g_print ("Hello World\n");
}
Dans la gestion d'un évènement de type delete_event, on doit retourner FALSE si l'on veut que l'évènement
destroy_event soit déclenché, et TRUE pour ne pas le déclencher.
Eric Guérin
[email protected]
15 décembre 2004 3/20

Année scolaire 2003-2004
La bibliothèque GTK
Bourg-en-Bresse
Première année
static gboolean delete_event( GtkWidget *widget,
GdkEvent *event,
gpointer data )
{
g_print ("delete event occurred\n");
return TRUE;
}
Lorsque l'évènement destroy_event est capté, une bonne idée est de mettre fin au programme. . .
static void destroy( GtkWidget *widget,
gpointer data )
{
gtk_main_quit ();
}
int main( int argc,
char *argv[] )
{
Les deux pointeur suivants vont servir à stocker les Widgets d'une fenêtre et d'un bouton.
GtkWidget *window;
GtkWidget *button;
La fonction gtk_init doit être appelée à chaque début de programme en GTK. Elle traite les arguments en ligne
de commande destinés à GTK et initialise l'environnement. Exemple d'option en ligne de commande : --gtk-debug. Les options
destinées à GTK seront lues et supprimées de la liste.
gtk_init (&argc, &argv);
On affecte window grâce à la fonction gtk_window_new. Plusieurs types de fenêtres peuvent être créés grâce
à l'argument passé à cette fonction.
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
On connecte les évènements delete_event et destroy_event à la fenêtre grâce aux fonctions de retour
définies précédemment.
g_signal_connect (G_OBJECT (window), "delete_event",
G_CALLBACK (delete_event), NULL);
g_signal_connect (G_OBJECT (window), "destroy",
G_CALLBACK (destroy), NULL);
On donne une largeur au bord de la fenêtre.
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
Création du bouton avec la connexion aux fonctions de retour.
button = gtk_button_new_with_label ("Hello World");
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (hello), NULL);
g_signal_connect_swapped (G_OBJECT (button), "clicked",
G_CALLBACK (gtk_widget_destroy),
G_OBJECT (window));
Le bouton se trouve (physiquement) dans la fenêtre.
gtk_container_add (GTK_CONTAINER (window), button);
On montre les Widgets et on appelle gtk_main qui lance le début de l'attente d'évènements.
4/20 15 décembre 2004 Eric Guérin
[email protected]

Bourg-en-Bresse
Première année
Année scolaire 2003-2004
La bibliothèque GTK
gtk_widget_show (button);
gtk_widget_show (window);
gtk_main ();
return 0;
}
2 Positionnement de Widgets
Plutôt que de dire qu'un Widget se trouve de manière stricte à tel endroit dans une fenêtre, GTK est basé sur une hiérarchie
de conteneurs. Ces conteneurs permettent de placer les Widgets verticalement, horizontalement ou bien en tables. Des options
autorisent de modifier l'alignement des objets, et le comportement en cas de redimensionnement. Il est à noter que ce genre de
positionnement hiérarchique est maintenant très utilisé (comme dans la librairie Swing de java). Il permet de beaucoup mieux gérer
les redimensionnements de fenêtres, et par conséquent les diverses résolutions graphiques disponibles.
2.1 Positionnement vertical ou horizontal
Deux étapes sont nécessaires pour mettre en ÷uvre ce type de positionnement :
1. La création de la boîte
GtkWidget *gtk_hbox_new ( gboolean homogeneous,
gint spacing );
GtkWidget *gtk_vbox_new ( gboolean homogeneous,
gint spacing );
2. L'ajout de Widgets dans la boîte
void gtk_box_pack_start( GtkBox *box,
GtkWidget *child,
gboolean expand,
gboolean fill,
guint padding );
2.2 Positionnement en tables
Là encore, il y a deux étapes :
1. La création de la table
GtkWidget *gtk_table_new( guint rows,
guint columns,
gboolean homogeneous );
2. L'ajout de Widgets dans la table
void gtk_table_attach( GtkTable *table,
GtkWidget *child,
guint left_attach,
guint right_attach,
guint top_attach,
guint bottom_attach,
GtkAttachOptions xoptions,
GtkAttachOptions yoptions,
guint xpadding,
guint ypadding );
En créant une table de 2 lignes et 2 colonnes, les coordonnées iront de 0 à deux pour x et y. On peut donc faire déborder un widget
sur plusieurs cases du tableau.
2.3 Autres gestionnaires de positionnement
Il existe d'autres gestionnaires de positionnement, vous les aborderez en TP.
Eric Guérin
[email protected]
15 décembre 2004 5/20