Cours GTK 2 http://gtk.developpez.com/cours/gtk2/?

page=page_3

Forums Tutoriels Magazine FAQs Blogs Chat Newsletter tudes Emploi Club
Contacts
p
u
Developpez.com b
l
i
Plus de 14 000 cours et tutoriels en informatique professionnelle c
i
t
consulter, tlcharger ou visionner en vido.

Accueil ALM Java .NET Dv. Web EDI Programmation SGBD Office Solutions d'entreprise Applications Mobiles Systmes

Accueil C Forums C FAQ C Tutoriels C Livres C Compilateurs et outils C Sources C Bibliothques C GTK+

ACCUEIL GTK+ FORUM GTK+ FAQ GTK+ TUTORIELS GTK+ SOURCES GTK+ BIBLIOTHEQUES LIVRES GTK+ OUTILS GTK+

Cours GTK 2

Table des matires

III. Les fentres

III-A. Crer et afficher une
fentre.
III-A-1. Cration d'une
fentre
III-A-2. Affichage de la
fentre.
III-A-3. Les signaux.
III-A-4. Exemple
III-B. Personnaliser une fentre
III-B-1. Position de la
fentre
III-B-2. Titre de la
fentre.
III-B-3. Taille de la
fentre
III-B-4. Programme
exemple
III-C. En savoir plus
III-C-1. Signaux
III-C-2. Fonctions
documentes
III-C-3. Fonctions non
documentes

III. Les fentres

Le premier lment d'une interface graphique est bien entendu la fentre. Il est donc tout fait
normal que ce soit le premier objet tudi dans le cadre de ce cours.

III-A. Crer et afficher une fentre.

Avant de commencer l'tude des fentres, il faut savoir que les objets graphiques de GTK+ sont
appels des widgets. Un widget est en fait une structure dfinissant les proprits d'un objet
associe une large panoplie de fonctions permettant de manipuler ces objets.

Ici, le terme est prendre au sens littral, mais aussi au sens Programmation Oriente Objet
(POO). En effet, bien que GTK+ soit crit en C, il introduit la notion d'hritage et les widgets de
GTK+ suivent une hirarchie bien dfinie. Ainsi tous les objets graphiques hritent des proprits
et des fonctions d'un widget de base qui s'appelle GtkWidget.

Ainsi le widget permettant d'afficher une fentre se nomme GtkWindow. Il a bien sr ses propres
fonctions, mais grce l'hritage il bnficie aussi des fonctions de plusieurs autres widgets.
Voici donc la position de GtkWindow dans la hirarchie GTK+ :

III-A-1. Cration d'une fentre

Dans un premier temps, il faut dclarer un pointeur sur notre objet fentre. Bien que nous
voulions crer un objet GtkWindow, il faut dclarer un objet GtkWidget.

Slectionnez
GtkWidget *pWindow;

Par la suite, quel que soit l'objet crer, il faudra toujours dclarer un GtkWidget.

Une fois l'objet pWindow dclarer, il faut l'initialiser. Pour cela, une fonction est notre
disposition :

Slectionnez
GtkWidget* gtk_window_new(GtkWindowType type);

1 sur 9 05/08/2015 05:17

Cours GTK 2 http://gtk.developpez.com/cours/gtk2/?page=page_3

Le paramtre type dfinit le type de la fentre en cours de cration, et peut prendre une des
deux valeurs suivantes :

GTK_WINDOW_TOPLEVEL : pour crer une fentre complte avec une zone rserve dans
la barre des tches ;
GTK_WINDOW_POPUP : pour crer une fentre sans aucune dcoration (barre de titre,
bordure).

La valeur de retour est le pointeur sur notre nouvel objet fentre. Cette fonction est donc
utiliser comme ceci :

Slectionnez
pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);

La cration de la fentre est maintenant termine.

III-A-2. Affichage de la fentre.

Un widget n'a pas de fonction spcifique lie son affichage, mais utilise une fonction de
GtkWidget qui est :

Slectionnez
void gtk_widget_show(GtkWidget *widget);

Il suffit donc de passer en paramtre le widget que nous voulons afficher, ainsi pour afficher
notre fentre, la ligne de code est :

Slectionnez
gtk_widget_show(pWindow);

Au contraire, pour dtruire la fentre, la fonction sera :

Slectionnez
void gtk_widget_destroy(GtkWidget *widget);

Voici donc le code source complet de notre programme affichant une fentre.

Slectionnez
#include <stdlib.h>
#include <gtk/gtk.h>

int main(int argc,char **argv)

{
/* Declaration du widget */
GtkWidget *pWindow;
gtk_init(&argc,&argv);

/* Cration de la fentre */
pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
/* Affichage de la fentre */
gtk_widget_show(pWindow);
/* Destruction de la fentre */
gtk_widget_destroy(pWindow);

return EXIT_SUCCESS;
}

En essayant ce programme, vous ne verrez srement pas la fentre s'afficher. La raison est
simple : la destruction de la fentre a lieu tout de suite aprs son affichage. Nous allons
maintenant tudier la thorie de signaux afin que l'application ne se termine qu'au moment o
l'utilisateur le demande.

III-A-3. Les signaux.

Nous allons maintenant tudier comment faire ragir une application GTK+ aux actions de
l'utilisateur.

Dans un premier temps, lorsque l'utilisateur interagi avec l'application (clique sur un bouton,
ferme une fentre), le widget concern met un signal (par exemple destroy lorsque l'on
ferme une fentre). Chaque widget est associ un ou plusieurs signaux et permet donc ainsi de
programmer toutes les actions possibles.

Ce signal va ensuite tre intercept par une boucle vnementielle qui va vrifier qu'une action
spcifique ce signal et ce widget a bien t dfinie. Si tel est le cas, la fonction associe sera
excute. Ce type de fonction s'appelle fonction callback.

Il faut donc crer une fonction callback pour chacun des vnements susceptible d'avoir lieu
pendant l'excution du programme et associer (ou connecter) cette fonction un signal.

La premire tape consiste donc crer une fonction callback. Dans la majorit des cas, une
fonction callback sera de cette forme :

Slectionnez
void nom_de_la_fonction(GtkWidget *widget, gpointer data)

Le paramtre widget est le widget qui a mis le signal, et data est une donne supplmentaire
qui peut tre utilise.

2 sur 9 05/08/2015 05:17

Cours GTK 2 http://gtk.developpez.com/cours/gtk2/?page=page_3

Ensuite, pour connecter un signal une fonction callback, GTK+ utilise une fonction de la
bibliothque GLib qui est :

Slectionnez
gulong g_signal_connect(gpointer *object, const gchar *name, GCallback func, gpointer func_data );

Le premier paramtre object, correspond au widget qui met le signal. Cependant, la variable
demande par g_signal_connect tant de type gpointer* (correspond void* du C standard) et le
widget de type GtkWidget*, il faut convertir ce dernier pour ne pas provoquer d'erreur lors de la
compilation. Pour cela GTK+ (ou dans ce cas GLib) fourni une macro de conversion (G_OBJECT)
qui sera utiliser chaque utilisation de cette fonction.

Le second paramtre name, est le signal qui doit tre intercept par la boucle vnementielle.
Dans ce cours, certains signaux seront utiliss dans les exemples, mais la rubrique En savoir
plus donnera une liste complte des signaux qui peuvent tre mis par un widget.

Le troisime paramtre func, dfinit la fonction callback associer au signal. Cette fois encore, il
faudra utiliser une macro de conversion qui est G_CALLBACK(func).

Le dernier paramtre func_data, permet de spcifier une donne quelconque laquelle la

fonction callback peut avoir accs pour effectuer son travail correctement.

Une fois que les signaux sont connects, il faut lancer la boucle vnementielle en appelant cette
fonction :

Slectionnez
void gtk_main(void);

Cela aura pour effet de faire entrer GTK+ dans une boucle infinie qui ne pourra tre stoppe que
par l'appel de la fonction de fin de boucle qui est :

Slectionnez
void gtk_main_quit(void);

Ces fonctions correspondent au minimum afin de pouvoir crer une application GTK+ correcte.
D'autres fonctions permettent une utilisation avance des signaux et de la boucle vnementielle
et seront traites dans un autre chapitre du cours.

III-A-4. Exemple

Nous allons maintenant faire en sorte que la fentre cre reste visible jusqu' que l'utilisateur
clique sur la croix situe droite de la barre de titre.

La premire tape est la dclaration de la fonction callback :

Slectionnez
void OnDestroy(GtkWidget *pWidget, gpointer pData);

La seule action que doit faire cette fonction est d'arrter la boucle vnementielle. La seule
instruction ajouter est donc gtk_main_quit();.

Il faut ensuite connecter le signal destroy de la fentre cette fonction :

Slectionnez
g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(OnDestroy), NULL);

Et pour terminer, il faut lancer la boucler vnementielle.

Slectionnez
gtk_main();

Voici donc le code source complet de notre application affichant une fentre.

Slectionnez
#include <stdlib.h>
#include <gtk/gtk.h>

void OnDestroy(GtkWidget *pWidget, gpointer pData);

int main(int argc,char **argv)

{
/* Dclaration du widget */
GtkWidget *pWindow;
gtk_init(&argc,&argv);

/* Cration de la fentre */
pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
/* Connexion du signal "destroy" */
g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(OnDestroy), NULL);
/* Affichage de la fentre */
gtk_widget_show(pWindow);
/* Demarrage de la boucle evenementielle */
gtk_main();

return EXIT_SUCCESS;
}

3 sur 9 05/08/2015 05:17

Cours GTK 2 http://gtk.developpez.com/cours/gtk2/?page=page_3

void OnDestroy(GtkWidget *pWidget, gpointer pData)

{
/* Arret de la boucle evenementielle */
gtk_main_quit();
}

Rsultat :

III-B. Personnaliser une fentre

Nous allons maintenant tudier quelques fonctions permettant de modifier l'aspect de la fentre
prcdemment cre. L'exemple final consistera crer une fentre de taille 320x200 au centre
de l'cran ayant pour titre Chapitre I.

III-B-1. Position de la fentre

La premire fonction tudie permet de dfinir la position de la fentre avant son affichage. Son
prototype est le suivant :

Slectionnez
void gtk_window_set_position(GtkWindow* window, GtkWindowPosition position);

Le premier paramtre correspond la fentre dont on veut spcifier la position. Ce paramtre

tant de type GtkWindow*, il faudra convertir la fentre (de type GtkWidget*) avec la macro
GTK_WINDOW.

Le deuxime paramtre est la position que l'on veut donner la fentre. Les valeurs acceptes
sont :

GTK_WIN_POS_NONE : la fentre aura une position alatoire lors de son affichage ;

GTK_WIN_POS_CENTER : la fentre sera centre l'cran ;
GTK_WIN_POS_MOUSE : le coin suprieur droit de la fentre correspondra la position de
la souris au moment de l'affichage ;
GTK_WIN_POS_CENTER_ALWAYS : la fentre sera centre et ne pourra tre dplace ;
GTK_WIN_POS_CENTER_ON_PARENT : la fentre sera centre par rapport la fentre
parente (notion aborde dans le prochain chapitre).

La deuxime fonction est utilisable tout moment du programme et permet de donner la position
exacte de la fentre :

Slectionnez
void gtk_window_move(GtkWindow *window, gint x, gint y);

Le premier paramtre est toujours la fentre dont on veut modifier la position.

Les deux autres paramtres sont la nouvelle position de la fentre. Le paramtre x est la position
suivante l'axe X (axe horizontal) et le paramtre y, la position suivant l'axe Y (axe vertical). Le
type gint est le type int du C.

l'inverse, pour connatre la position de la fentre, il faut utiliser cette fonction :

Slectionnez
void gtk_window_get_position(GtkWindow *window, gint *root_x, gint *root_y);

Les paramtres correspondent aux mmes valeurs que pour la fonction gtk_window_move.

Pour le programme exemple, le plus simple est d'utiliser la premire fonction ainsi :

Slectionnez
gtk_window_set_position(GTK_WINDOW(pWindow), GTK_WIN_POS_CENTER);

III-B-2. Titre de la fentre.

Cette fois-ci, une seule fonction est notre disposition pour modifier le titre de la fentre. Cette
dernire est trs simple d'utilisation :

Slectionnez
void gtk_window_set_title(GtkWindow* window, const gchar* title)

Le deuxime paramtre title est bien entendu le titre que l'on veut donner la fentre (gchar
correspond char en C).

4 sur 9 05/08/2015 05:17

Cours GTK 2 http://gtk.developpez.com/cours/gtk2/?page=page_3

Pour l'exemple, la ligne de code sera :

Slectionnez
gtk_window_set_title(GTK_WINDOW(pWindow), "Chapitre I.");

Pour connatre le titre d'une fentre, la fonction est :

Slectionnez
G_CONST_RETURN gchar* gtk_window_get_title(GtkWindow *window);

La variable qui recevra la valeur de retour de cette fonction devra tre de type const gchar*.

III-B-3. Taille de la fentre

La fonction pour dfinir la taille par dfaut de la fentre est :

Slectionnez
void gtk_window_set_default_size(GtkWindow* window, gint width, gint height);

Le paramtre width est la largeur de la fentre tandis que le paramtre height est sa hauteur.

Pour notre exemple, la ligne de code sera :

Slectionnez
gtk_window_set_default_size(GTK_WINDOW(pWindow), 320, 200);

Et trs logiquement, la fonction pour connatre la taille par dfaut de la fentre est :

Slectionnez
void gtk_window_get_default_size(GtkWindow *window, gint *width, gint *height);

III-B-4. Programme exemple

Slectionnez
#include <stdlib.h>
#include <gtk/gtk.h>

void OnDestroy(GtkWidget *pWidget, gpointer pData);

int main(int argc,char **argv)

{
/* Dclaration du widget */
GtkWidget *pWindow;
gtk_init(&argc,&argv);

/* Cration de la fentre */
pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
/* Dfinition de la position */
gtk_window_set_position(GTK_WINDOW(pWindow), GTK_WIN_POS_CENTER);
/* Dfinition de la taille de la fentre */
gtk_window_set_default_size(GTK_WINDOW(pWindow), 320, 200);
/* Titre de la fentre */
gtk_window_set_title(GTK_WINDOW(pWindow), "Chapitre I.");
/* Connexion du signal "destroy" */
g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(OnDestroy), NULL);
/* Affichage de la fenetre */
gtk_widget_show(pWindow);
/* Dmarrage de la boucle vnementielle */
gtk_main();

return EXIT_SUCCESS;
}

void OnDestroy(GtkWidget *pWidget, gpointer pData)

{
/* Arrt de la boucle vnementielle */
gtk_main_quit();
}

Rsultat :

III-C. En savoir plus

III-C-1. Signaux

5 sur 9 05/08/2015 05:17

Cours GTK 2 http://gtk.developpez.com/cours/gtk2/?page=page_3

Prototypes fonctions callback :

activate-default

Slectionnez
void user_function(GtkWindow *window, gpointer user_data);

activate-focus

Slectionnez
void user_function(GtkWindow *window, gpointer user_data);

frame-event

Slectionnez
gboolean user_function(GtkWindow *window, GdkEvent *event, gpointer user_data);

keys-changed

Slectionnez
void user_function(GtkWindow *window, gpointer user_data);

move-focus

Slectionnez
void user_function(GtkWindow *window, GtkDirectionType arg1, gpointer user_data);

set-focus

Slectionnez
void user_function(GtkWindow *window, GtkWidget *widget, gpointer user_data);

III-C-2. Fonctions documentes

Slectionnez
void gtk_window_set_resizable(GtkWindow *window, gboolean resizable);

Permet de dfinir si l'utilisateur peut modifier la taille de la fentre.

Entre(s) :

window : la fentre.
resizable : TRUE si l'on peut modifier la taille, FALSE sinon.

Sortie : rien.

Slectionnez
gboolean gtk_window_get_resizable(GtkWindow *window);

Pour savoir si la taille de la fentre est modifiable par l'utilisateur.

Entre(s) :

window : la fentre.

Sortie : TRUE si elle est modifiable, FALSE sinon.

Slectionnez
void gtk_window_set_gravity(GtkWindow *window, GdkGravity gravity);

Permet de dfinir le point d'origine pour le placement de la fentre.

Entre(s) :

window : la fentre

gravity : le point d'origine. Valeurs possibles :

GDK_GRAVITY_NORTH_WEST origine en haut gauche de l'cran ;

GDK_GRAVITY_NORTH origine en haut au milieu de l'cran ;
GDK_GRAVITY_NORTH_EAST origine en haut droite de l'cran ;
GDK_GRAVITY_WEST origine au milieu gauche de l'cran ;
GDK_GRAVITY_CENTER origine au milieu de l'cran ;
GDK_GRAVITY_EAST origine au milieu droite de l'cran ;
GDK_GRAVITY_SOUTH_WEST origine en bas gauche de l'cran ;
GDK_GRAVITY_SOUTH origine en bas au milieu de l'cran ;
GDK_GRAVITY_SOUTH_EAST origine en bas droite de l'cran ;
GDK_GRAVITY_STATIC l'origine est le coin suprieur droit de la fentre elle-mme.

Sortie : rien.

6 sur 9 05/08/2015 05:17

Cours GTK 2 http://gtk.developpez.com/cours/gtk2/?page=page_3

Slectionnez
GdkGravity gtk_window_get_gravity(GtkWindow *window);

Pour obtenir le point d'origine l'cran.

Entre(s) :

window : la fentre.

Sortie GdkGravity (numrer plus haut).

Slectionnez
void gtk_window_set_focus(GtkWindow *window, GtkWidget *focus);

Permet de dfinir le widget qui aura le focus.

Entre(s) :

window : la fentre contant le widget.

focus : le widget slectionner.

Sortie : rien.

Slectionnez
GtkWidget* gtk_window_get_focus(GtkWindow *window);

Pour connatre le widget qui a le focus.

Entre(s) :

window : la fentre.

Sortie : un pointeur sur le widget ayant le focus.

Slectionnez
void gtk_window_set_default(GtkWindow *window, GtkWidget *default_widget);

Pour dfinir le widget qui aura le focus par dfaut.

Entre(s) :

window : la fentre contant le widget.

default_widget : le widget slectionner.

Sortie : rien.

Slectionnez
void gtk_window_iconify(GtkWindow *window);

Permet de minimiser la fentre.

Entre(s) :

window : la fentre.

Sortie : rien.

Slectionnez
void gtk_window_deiconify(GtkWindow *window);

Pour rafficher la fentre lorsque celle-ci est minimise.

Entre(s) :

window : la fentre.

Sortie : rien.

Slectionnez
void gtk_window_maximize(GtkWindow *window);

Permet de maximiser la fentre.

Entre(s) :

window : la fentre.

Sortie : rien.

Slectionnez
void gtk_window_unmaximize(GtkWindow *window);

Redonne une fentre maximise sa taille prcdente.

Entre(s) :

7 sur 9 05/08/2015 05:17

Cours GTK 2 http://gtk.developpez.com/cours/gtk2/?page=page_3

window : la fentre.

Sortie : rien.

Slectionnez
void gtk_window_set_decorated(GtkWindow *window, gboolean setting);

Pour afficher la barre de titre de la fentre.

Entre(s) :

window : la fentre.
resizable :TRUE si l'on veut l'afficher, FALSE sinon.

Sortie : rien.

Slectionnez
gboolean gtk_window_get_decorated(GtkWindow *window);

Pour savoir si la barre de titre d'une fentre est visible.

Entre(s) :

window : la fentre.

Sortie : TRUE si elle est visible, FALSE sinon.

Slectionnez
void gtk_window_resize(GtkWindow *window, gint width, gint height);

Pour dfinir la nouvelle taille de la fentre.

Entre(s) :

window : la fentre.
width : largeur.
height : hauteur.

Sortie : rien.

III-C-3. Fonctions non documentes

Slectionnez
void gtk_window_set_wmclass(GtkWindow *window, const gchar *wmclass_name, const gchar
void gtk_window_set_policy(GtkWindow *window, gintallow_shrink, gintallow_grow, gintauto_shrink);
void gtk_window_add_accel_group(GtkWindow *window, GtkAccelGroup *accel_group);
void gtk_window_remove_accel_group(GtkWindow *window, GtkAccelGroup *accel_group);
gboolean gtk_window_activate_focus(GtkWindow *window);
gboolean gtk_window_activate_default(GtkWindow *window);
void gtk_window_set_modal(GtkWindow *window, gboolean modal);
void gtk_window_set_geometry_hints(GtkWindow *window, GtkWidget *geometry_widget, GdkGeometry
void gtk_window_set_transient_for(GtkWindow *window, GtkWindow *parent);
void gtk_window_set_destroy_with_parent(GtkWindow *window, gboolean setting);
GList* gtk_window_list_toplevels(void);
void gtk_window_add_mnemonic(GtkWindow *window, guintkeyval, GtkWidget *target);
void gtk_window_remove_mnemonic(GtkWindow *window, guintkeyval, GtkWidget *target);
gboolean gtk_window_mnemonic_activate(GtkWindow *window, guintkeyval, GdkModifierType modifier);
void gtk_window_present(GtkWindow *window);
void gtk_window_stick(GtkWindow *window);
void gtk_window_unstick(GtkWindow *window);
void gtk_window_begin_resize_drag(GtkWindow *window, GdkWindowEdge edge, gint button, gintroot_x, gin
void gtk_window_begin_move_drag(GtkWindow *window, gintbutton, gintroot_x, gintroot_y, guint32 timest
void gtk_window_set_frame_dimensions(GtkWindow *window, gintleft, ginttop, gintright, gintbottom);
void gtk_window_set_has_frame(GtkWindow *window, gboolean setting);
void gtk_window_set_mnemonic_modifier(GtkWindow *window, GdkModifierType modifier);
void gtk_window_set_role(GtkWindow *window, const gchar *role);
void gtk_window_set_type_hint(GtkWindow *window, GdkWindowTypeHinthint);
GList* gtk_window_get_default_icon_list(void);
gboolean gtk_window_get_destroy_with_parent(GtkWindow *window);
void gtk_window_get_frame_dimensions(GtkWindow *window, gint*left, gint*top, gint*right, gint
gboolean gtk_window_get_has_frame(GtkWindow *window);
GdkPixbuf* gtk_window_get_icon(GtkWindow *window);
GList* gtk_window_get_icon_list(GtkWindow *window);
GdkModifierType gtk_window_get_mnemonic_modifier(GtkWindow *window);
gboolean gtk_window_get_modal(GtkWindow *window);
G_CONST_RETURN gchar* gtk_window_get_role(GtkWindow *window);
GtkWindow* gtk_window_get_transient_for(GtkWindow *window);
GdkWindowTypeHint gtk_window_get_type_hint(GtkWindow *window);
gboolean gtk_window_parse_geometry(GtkWindow *window, const gchar *geometry);
void gtk_window_reshow_with_initial_size(GtkWindow *window);
void gtk_window_set_default_icon_list(GList *list);
void gtk_window_set_icon(GtkWindow *window, GdkPixbuf *icon);
void gtk_window_set_icon_list(GtkWindow *window, GList *list);
void gtk_decorated_window_init(GtkWindow *window);
void gtk_decorated_window_calculate_frame_size(GtkWindow *window);
void gtk_decorated_window_set_title(GtkWindow *window, const gchar *title);
void gtk_decorated_window_move_resize_window(GtkWindow *window, gintx, ginty, gintwidth, gintheight);

Les sources prsentes sur cette page sont libres de droits et vous pouvez les utiliser votre
convenance. Par contre, la page de prsentation constitue une uvre intellectuelle protge par les droits
d'auteur. Copyright 2013 developpez. Aucune reproduction, mme partielle, ne peut tre faite de ce
site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de
l'auteur. Sinon vous encourez selon la loi jusqu' trois ans de prison et jusqu' 300 000 de dommages

8 sur 9 05/08/2015 05:17

Cours GTK 2 http://gtk.developpez.com/cours/gtk2/?page=page_3

et intrts.

Responsable bnvole de la rubrique GTK+ : Francis Walter - Contacter par email

Nous contacter Participez Hbergement Informations lgales Partenaire : Hbergement Web

Copyright 2000-2015 - www.developpez.com

9 sur 9 05/08/2015 05:17