Mon, 3 Aug 1998 20:08:46 +0200 [Vincent]

* French version of the Gtk+ tutorial contributed by Eric Jacoboni <jaco@dotcom.fr>

2 files changed, 17200 insertions, 0 deletions

diff --git a/docs/gtk_tut_fr.sgml b/docs/gtk_tut_fr.sgml
new file mode 100644
index 000000000..0d23ced88
--- /dev/null
+++ b/docs/gtk_tut_fr.sgml
@@ -0,0 +1,8600 @@
+<!doctype linuxdoc system>
+<article>
+<title>Didacticiel
+<author>Ian Main, <tt><htmlurl url="mailto:slow@intergate.bc.ca"
+			      name="slow@intergate.bc.ca"></tt>
+<date>January 24, 1998.
+
+   
+<sect>Introduction
+<p>
+GTK (GIMP Toolkit) a été d'abord développé pour être une boîte à
+outils pour GIMP (General Image Manipulation Program).  GTK est
+construit sur GDK (GIMP Drawing Kit) qui est, avant tout, une
+encapsulation des fonctions Xlib. On l'appelle « GIMP toolkit » car il
+fut créé pour développer GIMP, mais il est désormais utilisé dans
+plusieurs projets de logiciels libres. Les auteurs sont&nbsp;:
+<itemize>
+<item> Peter Mattis   <tt><htmlurl url="mailto:petm@xcf.berkeley.edu"
+			   name="petm@xcf.berkeley.edu"></tt>
+<item> Spencer Kimball <tt><htmlurl url="mailto:spencer@xcf.berkeley.edu"
+			   name="spencer@xcf.berkeley.edu"></tt>
+<item> Josh MacDonald <tt><htmlurl url="mailto:jmacd@xcf.berkeley.edu"
+			   name="jmacd@xcf.berkeley.edu"></tt>
+</itemize>
+
+<p>
+GTK est essentiellement une interface de programmation (API) orientée
+objet.  Bien qu'il soit entièrement écrit en C, il est implanté en
+utilisant la notion de classes et de fonctions de rappel (pointeurs
+de fonctions).
+<p>
+Un troisième composant, appelé glib, remplace certains appels
+standard et comporte quelques fonctions supplémentaires pour gérer les
+listes chaînées, etc. Les fonctions de remplacement sont utilisées
+pour accroître la portabilité de GTK car certaines de ces fonctions,
+comme g_strerror(), ne sont pas disponibles ou ne sont pas standard
+sur d'autres Unix. D'autres comportent des améliorations par rapport
+aux versions de la libc&nbsp;: g_malloc(), par exemple, facilite le
+débuggage.<p>
+ 
+Ce didacticiel tente de décrire du mieux possible GTK, mais il n'est pas
+exhaustif. Il suppose une bonne connaissance du langage C, et de la façon de
+créer des programmes C. Il serait très précieux au lecteur d'avoir déjà une
+expérience de la programmation X, mais cela n'est pas nécessaire. Si
+l'apprentissage de GTK marque vos débuts dans l'approche des widgets, n'hésitez
+pas à faire des commentaires sur ce didacticiel et sur les problèmes qu'il vous
+a posé.  Il y a aussi une API C++ pour GTK (GTK--), si vous préférez utiliser
+ce langage, consultez plutôt la documentation qui la concerne. Une
+encapsulation en Objective C et des liaisons Guile sont également disponibles,
+mais ne seront pas abordées ici.
+<p>
+J'apprécierais beaucoup avoir un écho des problèmes que vous avez
+rencontré pour apprendre GTK à partir de ce document. De plus, toute
+suggestion sur son amélioration est la bienvenue.
+
+<sect>Bien débuter
+<p>
+La première chose à faire est, bien sûr, de récupérer les sources de
+GTK et de les installer. Vous pouvez en obtenir la dernière version
+sur <tt/ftp.gimp.org/ dans le répertoire <tt>/pub/gtk</tt>. D'autres
+sources d'informations se trouvent sur
+<tt>http://www.gimp.org/gtk</tt>. GTK utilise <em/autoconf/ de GNU
+pour se configurer. Lorsque vous l'aurez détarré, tapez
+<em>./configure --help</em> pour consulter la liste des options.
+<p>
+Pour commencer notre introduction à GTK, nous débuterons avec le
+programme le plus simple qui soit. Celui-ci créera une fenêtre de
+200x200 pixels et ne pourra se terminer qu'en le tuant à partir du
+shell.
+
+<tscreen><verb>
+#include <gtk/gtk.h>
+
+int main (int argc, char *argv[])
+{
+    GtkWidget *window;
+    
+    gtk_init (&amp;argc, &amp;argv);
+    
+    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+    gtk_widget_show (window);
+    
+    gtk_main ();
+    
+    return 0;
+}
+</verb></tscreen>
+
+Tous les programmes inclueront évidemment le fichier
+<tt>gtk/gtk.h</tt> qui déclare les variables, fonctions, structures,
+etc. qui seront utilisées par votre application GTK.
+<p>
+La ligne &nbsp;:
+
+<tscreen><verb>
+gtk_init (&amp;argc, &amp;argv);
+</verb></tscreen>
+
+appelle la fonction <em/gtk_init(gint *argc, gchar ***argv)/ qui sera
+appelée dans toutes les applications GTK. Cette fonction configure
+certaines choses pour nous, comme l'aspect visuel et les couleurs par
+défaut, puis appelle <em/gdk_init(gint *argc, gchar ***argv)/.  Cette
+dernière initialise la bibliothèque pour qu'elle puisse être utilisée,
+configure les gestionnaires de signaux par défaut et vérifie les
+paramètres passés à notre application via la ligne de commande en
+recherchant l'un des suivants&nbsp;:
+
+<itemize>
+<item> <tt/--display/
+<item> <tt/--debug-level/
+<item> <tt/--no-xshm/
+<item> <tt/--sync/
+<item> <tt/--show-events/
+<item> <tt/--no-show-events/
+</itemize>
+<p>
+Elle les supprime alors de la liste des paramètres, en laissant tout
+ce qu'elle ne reconnaît pas pour que notre application l'analyse ou
+l'ignore. Ceci crée un ensemble de paramètres standards acceptés par
+toutes les applications GTK.
+<p>
+Les deux lignes de code suivantes créent et affichent une fenêtre.
+
+<tscreen><verb>
+  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  gtk_widget_show (window);
+</verb></tscreen>
+
+Le paramètre <tt/GTK_WINDOW_TOPLEVEL/ précise que l'on veut que la
+fenêtre créée suive l'aspect et le placement définis par le
+gestionnaire de fenêtres. Plutôt que de créer une fenêtre de 0x0, une
+fenêtre sans fenêtre fille est de 200x200 par défaut&nbsp;: on peut
+ainsi la manipuler facilement.
+<p>
+La fonction <em/gtk_widget_show()/ informe GTK que l'on a configuré
+le widget et qu'il peut l'afficher.
+<p>
+La ligne suivante lance la boucle principale de traitement de GTK.
+
+<tscreen><verb>
+gtk_main ();
+</verb></tscreen>
+
+<em/gtk_main()/ est un autre appel que vous verrez dans toute
+application GTK. Lorsque le contrôle atteind ce point, GTK se met en
+attente d'événements X (click sur un bouton, ou appui d'une touche, par
+exemple), de timeouts ou d'entrées-sorties fichier. Dans notre exemple
+simple, cependant, les événements sont ignorés.
+
+
+<sect1>« Bonjour tout le monde » en GTK
+<p>
+OK, écrivons un programme avec un widget (bouton). C'est le classique « Bonjour tout le monde » à la sauce GTK.
+
+<tscreen><verb>
+
+#include <gtk/gtk.h>
+
+    /* fonction de rappel. Dans cet exemple, les paramètres sont ignorés...
+     *  Les fonctions de rappel sont détaillées plus loin. */
+
+void hello (GtkWidget *widget, gpointer data)
+{
+    g_print ("Bonjour tout le monde.\n");
+}
+
+gint delete_event(GtkWidget *widget, GdkEvent *event, gpointer data)
+{
+    g_print ("le signal delete_event est survenu.\n");
+
+    /* Si l'on renvoit TRUE dans le gestionnaire du signal "delete_event",
+     * GTK émettra le signal "destroy". Retourner FALSE signifie que l'on
+     * ne veut pas que la fenêtre soit détruite. 
+     * Utilisé pour faire apparaître des boîtes de dialogue du type
+     * « Êtes-vous sûr de vouloir quitter ? » */
+    
+    /* Remplacez FALSE par TRUE et la fenêtre principale sera détruite par
+     * un signal « delete_event ». */
+    
+    return (FALSE); 
+}
+
+/* Autre fonction de rappel */
+
+void destroy (GtkWidget *widget, gpointer data)
+{
+    gtk_main_quit ();
+}
+
+int main (int argc, char *argv[])
+{
+    /* GtkWidget est le type pour déclarer les widgets. */
+
+    GtkWidget *window;
+    GtkWidget *button;
+    
+    /* Cette fonction est appelée dans toutes les applications GTK. 
+     * Les paramètres passés en ligne de commande sont analysés et 
+     * retournés à l'application. */
+
+    gtk_init (&amp;argc, &amp;argv);
+    
+    /* Création d'une nouvelle fenêtre. */
+
+    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+    
+    /* Lorsque la fenêtre reçoit le signal "delete_event" 
+     * (envoyé par le gestionnaire de fenêtres en utilisant l'option
+     * « close » ou la barre de titre), on lui demande d'appeler la
+     * fonction delete_event() définie plus haut. La donnée passée en
+     * paramètre à la fonction de rappel est NULL et est ignoré dans le
+     * rappel. */
+
+    gtk_signal_connect (GTK_OBJECT (window), "delete_event",
+			GTK_SIGNAL_FUNC (delete_event), NULL);
+    
+    /* Ici, on connecte l'évenement "destroy" à un gestionnaire de signal.
+     * Cet événement arrive lorsqu'on appelle gtk_widget_destroy() sur la
+     * fenêtre, ou si l'on retourne TRUE dans le rappel "delete_event". */
+
+    gtk_signal_connect (GTK_OBJECT (window), "destroy",
+			GTK_SIGNAL_FUNC (destroy), NULL);
+    
+    /* Configuration de la largeur du contour de la fenêtre. */
+
+    gtk_container_border_width (GTK_CONTAINER (window), 10);
+    
+    /* Création d'un nouveau bouton portant le label 
+     * "Bonjour tout le monde". */
+
+    button = gtk_button_new_with_label ("Bonjour tout le monde");
+    
+    /* Quand le bouton recevra le signal "clicked", il appellera la
+     * fonction hello() définie plus haut en lui passant NULL en paramètre. */
+
+    gtk_signal_connect (GTK_OBJECT (button), "clicked",
+			GTK_SIGNAL_FUNC (hello), NULL);
+    
+    /* Ceci provoquera la destruction de la fenêtre par appel de la
+     * fonction gtk_widget_destroy(window) lors du signal "clicked".  
+     * Le signal de destruction pourrait venir de là, ou du 
+     * gestionnaire de fenêtres. */
+
+    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+			       GTK_SIGNAL_FUNC (gtk_widget_destroy),
+			       GTK_OBJECT (window));
+    
+    /* Insertion du bouton dans la fenêtre (container gtk). */
+
+    gtk_container_add (GTK_CONTAINER (window), button);
+    
+    /* L'étape finale consiste à afficher ce nouveau widget... */
+
+    gtk_widget_show (button);
+    
+    /* ... et la fenêtre. */
+
+    gtk_widget_show (window);
+    
+    /* Toutes les applications GTK doivent avoir un gtk_main().	
+     * Le déroulement du programme se termine là et attend qu'un
+     * événement survienne (touche pressée ou événement souris). */
+
+    gtk_main ();
+    
+    return 0;
+}
+</verb></tscreen>
+
+<sect1>Compilation de « Bonjour tout le monde »
+<p>
+Supposons que vous avez sauvegardé le code précédent dans un fichier
+nommé <em/bonjour.c/, pour le compiler tapez la commande
+suivante&nbsp;:
+
+<tscreen><verb>
+gcc -Wall -g bonjour.c -o bonjour_monde -L/usr/X11R6/lib \
+    -lgtk -lgdk -lglib -lXext -lX11 -lm
+</verb></tscreen>
+<p>
+Les bibliothèques invoquées ci-dessus doivent toutes être dans vos
+chemins de recherche par défaut, sinon, ajoutez <tt/-L&lt;library
+directory&gt;/ pour que <em/gcc/ recherche dans ces répertoires les
+bibliothèques nécessaires. Sur mon système Debian GNU/Linux, par exemple,
+je dois ajouter <tt>-L/usr/X11R6/lib</> pour qu'il trouve les
+bibliothèques X11 (NdT&nbsp;: et c'est pareil sur mon système Red Hat
+Linux...).
+<p>
+L'ordre des bibliothèques est important. L'éditeur de liens doit
+connaître les fonctions d'une bibliothèque dont il a besoin avant de
+les traiter.
+<p>
+Si vous compilez en utilisant des bibliothèques statiques, l'ordre
+dans lequel vous listez les bibliothèques devient très
+important. L'exemple donné ci-dessus devrait fonctionner dans tous les
+cas.
+<p>
+Les bibliothèques que l'on utilise sont&nbsp;:
+<itemize>
+<item>La bibliothèque glib (<tt/-lglib/), qui contient diverses
+fonctions. Seule <em/g_print()/ est utilisée dans cet exemple. GTK est
+construit au dessus de <em/glib/ et vous aurez donc toujours besoin de
+celle-ci. Voir la section concernant <ref id="sec_glib" name="glib">
+pour plus de détails.
+ 
+<item>La bibliothèque GDK (<tt/-lgdk/), l'enveloppe de Xlib.
+
+<item>La bibliothèque GTK (<tt/-lgtk/), la bibliothèque des widgets,
+construite au dessus de GDK.
+
+<item>La bibliothèque Xlib (<tt/-lX11/ utilisée par GDK.
+
+<item>La bibliothèque Xext (<tt/-lXext/). Cette dernière contient le
+code pour les pixmaps en mémoire partagée et les autres extensions X.
+
+<item>La bibliothèque mathématique (<tt/-lm/).  Elle est utilisée pour
+différentes raisons par GTK.
+</itemize>
+
+<sect1>Théorie des signaux et des rappels
+<p>
+Avant de voir en détail le programme « Bonjour tout le monde », nous
+parlerons d'abord des événements et des fonctions de rappel.  GTK est
+dirigé par les événements, ce qui signifie qu'il restera inactif dans
+<em/gtk_main/ jusqu'à ce qu'un événement survienne et que le contrôle
+soit passé à la fonction appropriée.
+<p>
+Ce passage du contrôle est réalisé en utilisant le concept de « signal
+». Lorsqu'un événement survient, comme l'appui sur un bouton, le
+signal approprié sera « émis » par le widget qui a été pressé. C'est
+de cette façon que GTK réalise la plupart de son travail. Pour qu'un
+bouton réalise une action, on configure un gestionnaire de signal pour
+capturer ces signaux et appeler la fonction adéquate.  Ceci est fait
+en utilisant une fonction comme&nbsp;:
+
+<tscreen><verb>
+gint gtk_signal_connect (GtkObject *object,
+                         gchar *name,
+			 GtkSignalFunc func,
+			 gpointer func_data);
+</verb></tscreen>
+<p>
+Où le premier paramètre est le widget qui émettra le signal, et le
+deuxième est le nom du signal que l'on souhaite intercepter. Le
+troisième paramètre est la fonction que l'on veut appeler quand le
+signal est capturé, et le quatrième sont les données que l'on souhaite
+passer à cette fonction.
+<p>
+La fonction spécifiée par le troisième paramètre s'appelle une «
+fonction de rappel » et doit être de la forme&nbsp;:
+
+<tscreen><verb>
+void callback_func(GtkWidget *widget, gpointer *callback_data);
+</verb></tscreen>
+<p>
+Où le premier paramètre sera un pointeur vers le widget qui a émis le
+signal, et le second un pointeur vers les données passées par le
+dernier paramètre de la fonction <em/gtk_signal_connect()/ décrite
+plus haut.
+<p>
+Un autre appel utilisé dans l'exemple « Bonjour tout le monde » est&nbsp;:
+
+<tscreen><verb>
+gint gtk_signal_connect_object (GtkObject *object,
+                                gchar  *name,
+				GtkSignalFunc func,
+				GtkObject *slot_object);
+</verb></tscreen>
+<p>
+<em/gtk_signal_connect_object()/ est la même chose que
+<em/gtk_signal_connect()/ sauf que la fonction de rappel utilise un
+seul paramètre&nbsp;: un pointeur vers un objet GTK. Lorsqu'on utilise
+cette fonction pour connecter des signaux, le rappel doit être de
+cette forme&nbsp;:
+
+<tscreen><verb>
+void callback_func (GtkObject *object);
+</verb></tscreen>
+<p>
+Où l'objet est d'ordinaire un widget. En général, on ne configure pas
+de rappels pour <em/gtk_signal_connect_object/. D'habitude, ceux-ci sont
+utilisés pour appeler une fonction GTK acceptant un simple widget ou
+objet comme paramètre, comme dans notre exemple.
+
+La raison pour laquelle il y a deux fonctions pour connecter les
+signaux est simplement de permettre aux fonctions de rappel d'avoir un
+nombre différent de paramètres. De nombreuses fonctions de la
+bibliothèque GTK n'acceptent qu'un simple pointeur vers un
+<em/GtkWidget/ comme paramètre et vous pouvez donc  utiliser
+<em/gtk_signal_connect_object()/ pour celles-ci, tandis que pour vos
+fonctions vous pouvez avoir besoin d'avoir de fournir plus de données
+aux fonctions de rappel.
+
+<sect1>« Bonjour tout le monde » pas à pas
+<p>
+Maintenant que nous connaissons la théorie, clarifions un peu en progressant à travers le programme « Bonjour tout le monde ».
+<p>
+Voici la fonction de rappel appelée lorsque le bouton est « clicked
+». Dans notre exemple, on ignore le widget et les données mais il
+n'est pas difficile de faire quelque chose avec. Le prochain exemple
+utilisera le paramètre des données pour nous dire quel bouton a été
+pressé.
+
+<tscreen><verb>
+void hello (GtkWidget *widget, gpointer *data)
+{
+    g_print ("Bonjour tout le monde\n");
+}
+</verb></tscreen>
+
+<p>
+Cette fonction de rappel est un peu spéciale. L'événement
+"delete_event" survient lorsque le gestionnaire de fenêtres l'envoie à
+l'application. On doit choisir ce qu'il faut faire de ces
+événements. On peut les ignorer, leur donner une réponse, ou
+simplement quitter l'application.
+
+La valeur que l'on retourne dans cette fonction de rappel permet à GTK
+de savoir ce qu'il a à faire. En retournant FALSE, on l'informe que
+l'on ne veut pas que le signal "destroy" soit émis, afin de laisser
+notre application tourner. En retournant TRUE, on lui demande
+d'émettre "destroy" qui appellera à son tour notre gestionnaire du
+signal "destroy".
+
+<tscreen><verb>
+gint delete_event(GtkWidget *widget, GdkEvent *event, gpointer data)
+{
+    g_print ("le signal delete_event est survenu.\n");
+
+    return (FALSE); 
+}
+</verb></tscreen>
+
+<p>
+Voici une autre fonction de rappel qui ne fait que quitter
+l'application en appelant <em/gtk_main_quit()/.  Il n'y a pas grand
+chose de plus à dire car elle est plutôt triviale&nbsp;:
+
+<tscreen><verb>
+void destroy (GtkWidget *widget, gpointer *data)
+{
+    gtk_main_quit ();
+}
+</verb></tscreen>
+<p>
+Je suppose que vous connaissez la fonction <em/main()/... oui, comme
+les autres programmes C, toutes les applications GTK en ont une.
+
+<tscreen><verb> 
+int main (int argc, char *argv[]) 
+{ 
+</verb></tscreen>
+<p>
+La partie qui suit déclare deux pointeurs sur des structures de type
+<em/GtkWidget/.  Ceux-ci sont utilisés plus loin pour créer une
+fenêtre et un bouton.
+
+<tscreen><verb>
+    GtkWidget *window;
+    GtkWidget *button;
+</verb></tscreen>
+<p>
+Et revoici notre <em/gtk_init/.  Comme précédemment, il initialise le toolkit
+et analyse les paramètres de la ligne de commande. Il supprime chaque
+paramètre reconnu de la liste et modifie <em/argc/ et <em/argv/ pour
+faire comme si ces paramètres n'avaient jamais existé, laissant notre
+application analyser les paramètres restants.
+
+<tscreen><verb>
+    gtk_init (&amp;argc, &amp;argv);
+</verb></tscreen>
+<p>
+Création d'une nouvelle fenêtre. C'est plutôt classique. La mémoire
+est allouée pour une structure <em/GtkWidget/ et <em/window/ pointe
+donc sur celle-ci. Cela configure une nouvelle fenêtre, mais celle-ci
+ne sera pas affichée tant que l'on n'a pas appelé
+<em/gtk_widget_show(window)/ vers la fin de notre programme.
+
+<tscreen><verb>
+    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+</verb></tscreen>
+<p>
+Voici maintenant un exemple de connexion d'un gestionnaire de signal à
+un objet&nbsp;: la fenêtre. Le signal "destroy" est capturé. Il est
+émis lorsqu'on utilise le gestionnaire de fenêtres pour tuer la
+fenêtre (et que l'on retourne TRUE dans le gestionnaire
+"delete_event"), ou lorsqu'on utilise l'appel
+<em/gtk_widget_destroy()/ en lui passant le widget <em/window/ comme
+objet à détruire.  Ici, on appelle juste la fonction <em/destroy()/
+définie ci-dessus avec le paramètre NULL, ce qui quitte GTK pour
+nous.
+<p>
+<tt/GTK_OBJECT/ et <tt/GTK_SIGNAL_FUNC/ sont des macros qui réalisent
+les conversions et les vérifications de types pour nous. Elles rendent
+aussi le code plus lisible.
+
+<tscreen><verb>
+    gtk_signal_connect (GTK_OBJECT (window), "destroy",
+			GTK_SIGNAL_FUNC (destroy), NULL);
+</verb></tscreen>
+<p>
+La fonction suivante sert à configurer un attribut d'un objet
+container. Elle configure simplement la fenêtre pour qu'elle ait une
+zone vide autour d'elle de 10 pixels de large où aucun widget ne
+pourra se trouver. Il existe d'autres fonctions similaires que nous
+verrons dans la section sur la
+<ref id="sec_setting_widget_attributes" 
+name="Configuration des attributs des widgets">
+<p>
+À nouveau, <tt/GTK_CONTAINER/ est une macro réalisant la conversion de type.
+<tscreen><verb>
+    gtk_container_border_width (GTK_CONTAINER (window), 10);
+</verb></tscreen>
+<p>
+Cet appel crée un nouveau bouton. Il alloue l'espace mémoire pour une
+nouvelle structure GtkWidget, l'initialise et fait pointer <em/button/
+vers elle. Ce bouton portera le label « Bonjour tout le monde »
+lorsqu'il sera affiché.
+
+<tscreen><verb>
+    button = gtk_button_new_with_label ("Bonjour tout le monde");
+</verb></tscreen>
+<p>
+Maintenant, prenons ce bouton et faisons lui faire quelque chose
+d'utile. On lui attache un gestionnaire de signal pour que, lorsqu'il
+émettra le signal "clicked", notre fonction <em/hello()/ soit
+appelée. On ignore les paramètres et on ne passe donc que la valeur
+NULL à la fonction de rappel <em/hello()/.  Évidemment, le signal
+"clicked" est émis lorsqu'on clique sur le bouton avec la souris.
+
+<tscreen><verb>
+    gtk_signal_connect (GTK_OBJECT (button), "clicked",
+			GTK_SIGNAL_FUNC (hello), NULL);
+</verb></tscreen>
+<p>
+On utilisera aussi ce bouton pour quitter notre programme, ce qui
+permettra d'illustrer la façon dont le signal "destroy" peut venir
+soit du gestionnaire de fenêtres, soit de notre programme. Quand le
+bouton est "clicked" comme cela est décrit plus haut, il appelle
+d'abord la fonction de rappel <em/hello()/ puis celle-ci dans l'ordre
+dans lequel elles sont configurées. On peut avoir autant de fonctions
+de rappel que l'on désire, elles seront exécutées selon leur ordre de
+connexion. Puisque la fonction <em/gtk_widget_destroy()/ n'accepte que
+<em/GtkWidget *widget/ comme paramètre, on utilise ici la fonction
+<em/gtk_signal_connect_object()/ à la place de
+<em/gtk_signal_connect()/.
+
+<tscreen><verb>
+    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+			       GTK_SIGNAL_FUNC (gtk_widget_destroy),
+			       GTK_OBJECT (window));
+</verb></tscreen>
+<p>
+Voici un appel de placement, qui sera expliqué en détail plus tard,
+mais qui est plutôt facile à comprendre. Il indique simplement à GTK
+que le bouton doit être placé dans la fenêtre où il s'affichera.
+
+<tscreen><verb> gtk_container_add (GTK_CONTAINER (window), button);
+</verb></tscreen>
+<p>
+Maintenant, nous avons tout configuré comme on le souhaitait&nbsp;:
+les gestionnaires de signaux sont en place et le bouton est mis dans
+la fenêtre où il doit se trouver. On demande alors à GTK de « montrer
+» les widgets à l'écran. Le widget <em/window/ est affiché en dernier
+afin que la fenêtre entière surgisse d'un coup plutôt que voir d'abord
+la fenêtre s'afficher puis ensuite le bouton apparaître à
+l'intérieur. Il faut dire qu'avec des exemples simples comme celui-ci,
+vous ne ferez pas la différence.  
+<tscreen><verb> 
+    gtk_widget_show(button);
+
+    gtk_widget_show (window);
+</verb></tscreen>
+<p>
+Bien sûr, on appelle <em/gtk_main()/ qui attendra les événements
+venant du serveur X et demandera aux widgets d'émettre les signaux
+lorsque ces événements surviendront.
+<tscreen><verb>
+    gtk_main ();
+</verb></tscreen>
+Enfin, le <em/return/ final. Il est exécuté lorsque <em/gtk_quit()/ est appelé.
+<tscreen><verb>
+    return 0;
+</verb></tscreen>
+<p>
+Lorsque l'on clique sur un bouton GTK, le widget émet un
+signal "clicked". Afin de pouvoir utiliser cette information, notre
+programme configure un gestionnaire pour capturer ce signal. Ce
+gestionnaire appelle la fonction de notre choix. Dans notre exemple,
+lorsque le bouton que l'on a créé est "clicked", la fonction
+<em/hello()/ est appelée avec le paramètre NULL, puis le gestionnaire
+suivant de ce signal est à son tour appelé. Il appelle la fonction
+<em/gtk_widget_destroy()/ en lui passant le widget <em/window/ comme
+paramètre, ce qui provoque la destruction de celui-ci. Ceci
+force la fenêtre à envoyer un signal "destroy", qui est capturé à son
+tour et appelle notre fonction de rappel <em/destroy()/ qui ferme
+simplement GTK.
+<p>
+Une autre façon de procéder consiste à utiliser le gestionnaire de
+fenêtres pour détruire la fenêtre. Cela provoquera l'émission du
+signal "delete_event" qui sera pris en charge par notre gestionnaire
+<em/delete_event()/. S'il retourne FALSE, la fenêtre restera telle
+quelle et rien ne se passera. Retourner TRUE forcera GTK à émettre
+le signal "destroy" qui, bien sûr, appelera la fonction de rappel
+<em/destroy()/ provoquant la sortie du GTK.  <p> 
+On remarquera que ces signaux ne sont pas les mêmes que les signaux
+systèmes Unix et ne sont pas implantés en utilisant ceux-ci, bien que
+la terminologie employée soit presque identique.
+
+
+<sect>Continuons
+<p>
+<sect1>Types de données
+<p>
+Vous avez probablement noté certaines choses qui nécessitent des
+explications dans les exemples précédents. les <em/gint/, <em/gchar/,
+etc. que vous avez pu voir sont des redéfinitions de <em/int/ et
+<em/char/, respectivement. Leur raison d'être est de s'affranchir des
+dépendances ennuyeuses concernant la taille des types de données
+simples lorsqu'on réalise des calculs. Un bon exemple est <em/gint32/
+qui désignera un entier codé sur 32 bits pour toutes les plateformes,
+que ce soit une station Alpha 64 bits ou un PC i386 32 bits. Les
+redéfinitions de type sont très simples et intuitives. Elles sont
+toutes décrites dans le fichier <em>glib/glib.h</em> (qui est inclus
+par <em/gtk.h/).
+<p>
+On notera aussi la possibilité d'utiliser un <em/GtkWidget/ lorsque la
+fonction attend un <em/GtkObject/. GTK possède une architecture
+orientée objet, et un widget est un objet.
+
+<sect1>Compléments sur les gestionnaires de signaux
+<p>
+Regardons à nouveau la déclaration de <em/gtk_signal_connect/.
+
+<tscreen><verb>
+gint gtk_signal_connect (GtkObject *object, gchar *name,
+			 GtkSignalFunc func, gpointer func_data);
+</verb></tscreen>
+
+Vous avez remarqué que le valeur de retour est de type <em/gint/ ? Il
+s'agit d'un marqueur qui identifie votre fonction de rappel. Comme on
+le disait plus haut, on peut avoir autant de fonctions de rappel que
+l'on a besoin, par signal et par objet, et chacune sera exécutée à son
+tour, dans l'ordre dans lequel elle a été attachée. Ce marqueur vous
+permet d'ôter ce rappel de la liste en faisant&nbsp&;: 
+
+<tscreen><verb>
+      void gtk_signal_disconnect (GtkObject *object, gint id);
+</verb></tscreen> 
+
+Ainsi, en passant le widget dont on veut supprimer le gestionnaire et
+le marqueur ou identificateur retourné par l'une des fonctions
+<em/signal_connect/, on peut déconnecter un gestionnaire de signal.
+<p>
+Une autre fonction permettant de supprimer tous les gestionnaires de
+signaux pour un objet est&nbsp;: 
+
+<tscreen><verb>
+      gtk_signal_handlers_destroy (GtkObject *object); 
+</verb></tscreen>
+<p>
+Cet appel n'a pas trop besoin d'explications. Il ôte simplement tous
+les gestionnaires de signaux de l'objet passé en paramètre.
+
+
+<sect1>Un « Bonjour tout le monde » amélioré
+<p>
+Étudions une version légèrement améliorée avec de meilleurs exemples
+de fonctions de rappel. Ceci permettra aussi d'introduire le sujet
+suivant&nbsp;: le placement des wigdets.
+
+<tscreen><verb>
+#include <gtk/gtk.h>
+
+/* Notre nouveau rappel amélioré. La donnée passée à cette fonction est
+ * imprimée sur stdout. */
+
+void rappel (GtkWidget *widget, gpointer *data)
+{
+    g_print ("Re-Bonjour - %s a été pressé\n", (char *) data);
+}
+
+/* Un autre rappel */
+
+void delete_event (GtkWidget *widget, GdkEvent *event, gpointer *data)
+{
+    gtk_main_quit ();
+}
+
+int main (int argc, char *argv[])
+{
+    /* GtkWidget est le type pour déclarer les widgets */
+
+    GtkWidget *window;
+    GtkWidget *button;
+    GtkWidget *box1;
+
+    /* Cette fonction est appelée dans toutes les applications GTK. 
+     * Les paramètre passés en ligne de commande sont analysés et 
+     * retournés à l'application. */
+
+    gtk_init (&amp;argc, &amp;argv);
+
+    /* Création d'une nouvelle fenêtre. */
+
+    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+    /* Nouvel appel qui intitule notre nouvelle fenêtre 
+     * "Salut les boutons !" */
+
+    gtk_window_set_title (GTK_WINDOW (window), "Salut les boutons !");
+
+    /* Configuration d'un gestionnaire pour "delete_event" afin de
+     * quitter immédiatement GTK. */
+
+    gtk_signal_connect (GTK_OBJECT (window), "delete_event",
+			GTK_SIGNAL_FUNC (delete_event), NULL);
+
+
+    /* Configuration de la largeur du contour de la fenêtre. */
+    
+    gtk_container_border_width (GTK_CONTAINER (window), 10);
+
+    /* Création d'une boîte pour y placer les widgets.
+     * Ceci est décrit en détails plus loin dans la section 
+     * « placement ». La boîte n'est pas matérialisée, elle est juste
+     * utilisée comme moyen d'arranger les widgets. */
+
+    box1 = gtk_hbox_new(FALSE, 0);
+
+    /* On met la boîte dans la fenêtre principale. */
+
+    gtk_container_add (GTK_CONTAINER (window), box1);
+
+    /* On crée un nouveau bouton portant le label « Bouton 1 ». */
+
+    button = gtk_button_new_with_label ("Bouton 1");
+
+    /* Lorsque le bouton est cliqué, on appelle la fonction « rappel » 
+     * avec un pointeur sur la chaîne « Bouton 1 » comme paramètre. */
+
+    gtk_signal_connect (GTK_OBJECT (button), "clicked",
+			GTK_SIGNAL_FUNC (rappel), (gpointer) "Bouton 1");
+
+    /* Au lieu d'utiliser gtk_container_add, on place ce bouton dans
+     * la boîte invisible qui a été placée dans la fenêtre. */
+
+    gtk_box_pack_start(GTK_BOX(box1), button, TRUE, TRUE, 0);
+
+    /* N'oubliez jamais cette étape qui indique à GTK que la configuration
+     * de ce bouton est terminée et qu'il peut être affiché. */
+
+    gtk_widget_show(button);
+
+    /* On fait la même chose pour créer un deuxième bouton. */
+
+    button = gtk_button_new_with_label ("Bouton 2");
+
+    /* On appelle la même fonction de rappel avec un paramètre différent,
+     * un pointeur sur la chaîne « Bouton 2 ». */
+
+    gtk_signal_connect (GTK_OBJECT (button), "clicked",
+			GTK_SIGNAL_FUNC (rappel), (gpointer) "Bouton 2");
+
+    gtk_box_pack_start(GTK_BOX(box1), button, TRUE, TRUE, 0);
+
+    /* L'ordre dans lequel on affiche les boutons n'est pas vraiment
+     * important, mais il est préférable d'afficher la fenêtre en dernier
+     * pour qu'elle surgisse d'un coup. */
+
+    gtk_widget_show(button);
+
+    gtk_widget_show(box1);
+
+    gtk_widget_show (window);
+
+    /* Le reste est dans gtk_main et on attend que la fête commence ! */
+
+    gtk_main ();
+
+    return 0;
+}
+</verb></tscreen>
+<p>
+Compilez ce programme en utilisant les mêmes paramètres que pour
+l'exemple précédent. Vous remarquerez que, maintenant, il est plus
+difficile de quitter le programme&nbsp;: vous devez utiliser le
+gestionnaire de fenêtres ou une commande shell pour le détruire. Un
+bon exercice pour le lecteur serait d'insérer un troisième bouton «
+Quitter » qui permettrait de sortir du programme. Vous pouvez aussi
+jouer avec les options de <em/gtk_box_pack_start()/ en lisant la
+section suivante. Essayez de redimensionner la fenêtre, et observez
+son comportement.
+<p>
+Juste une remarque&nbsp;: il existe une autre constante utilisable
+avec <em/gtk_window_new()/ - GTK_WINDOW_DIALOG.  Ceci permet
+d'interagir de façon un peu différente avec le gestionnaire de
+fenêtres et doit être utilisé pour les fenêtres temporaires comme les
+boîtes de dialogue, par exemple.
+
+<sect>Placement des widgets
+<p>
+Lorsqu'on crée une application, on veut mettre plus qu'un simple
+bouton dans une fenêtre. Notre premier exemple « Bonjour le monde »
+n'utilisait qu'un seul widget et on pouvait donc simplement faire un
+appel à <em/gtk_container_add/ pour « placer » le widget dans la
+fenêtre. Mais si l'on désire en mettre plus, comment peut-on contrôler
+l'endroit où le widget sera positionné ? C'est ici que le placement
+entre en jeu.
+
+<sect1>Théorie des boîtes de placement
+<p>
+La majeure partie du placement est faites en créant des boîtes comme
+dans l'exemple ci-dessus. Ce sont des widgets containers invisibles où
+l'on peut placer nos widgets. Elles existent sous deux formes&nbsp;:
+boîtes horizontales et boîtes verticales. Lorsque l'on place des
+widgets dans une boîte horizontale, les objets sont insérés
+horizontalement de gauche à droite ou de droite à gauche selon l'appel
+utilisé. Dans une boîte verticale, les widgets sont placés de haut en
+bas ou vice versa. On peut utiliser n'importe quelle combinaison de
+boîtes à l'intérieur ou à côté d'autres boîtes pour créer l'effet
+désiré.
+<p>
+Pour créer une nouvelle boîte horizontale, on appelle
+<em/gtk_hbox_new()/, et pour les boîtes verticales,
+<em/gtk_vbox_new()/. Les fonctions <em/gtk_box_pack_start()/ et
+<em/gtk_box_pack_end()/ servent à placer les objets à l'intérieur de
+ces containers.  La fonction <em/gtk_box_pack_start()/ placera de haut
+en bas dans une boîte verticale et de gauche à droite dans une boîte
+horizontale.  <em/gtk_box_pack_end()/ fera le contraire en plaçant de
+bas en haut et de droite à gauche. En utilisant ces fonctions, on peut
+aligner à droite ou à gauche nos widgets et même les mélanger de
+n'importe quelle façon pour obtenir l'effet désiré. Dans la plupart de
+nos exemples, on utilisera <em/gtk_box_pack_start()/. Un objet peut
+être un autre container ou un widget. En fait, de nombreux widgets
+(dont les boutons) sont eux-mêmes des containers, mais on utilise
+généralement seulement un label dans un bouton.
+<p>
+En utilisant ces appels, GTK sait où vous voulez placer vos widgets et
+il peut donc les dimensionner automatiquement et faire d'autres choses
+bien pratiques. Il existe aussi plusieurs options permettant de
+préciser comment les widgets doivent être placés. Comme vous pouvez
+l'imaginer, cette méthode nous donne pas mal de liberté pour placer et
+créer les widgets.
+
+<sect1>Détails sur les boîtes
+<p>
+À cause de cette liberté, le placement des boîtes avec GTK peut
+paraître déroutant au premier abord. Il existe beaucoup d'options et
+il n'est pas tout de suite évident de comprendre comment elles
+s'accordent toutes ensemble. En fait, il y a 5 styles de base
+différents.
+
+<p>
+<?  
+<IMG ALIGN="center" SRC="packbox1.gif"
+VSPACE="15" HSPACE="10" ALT="Box Packing Example Image" WIDTH="528"
+HEIGHT="235">
+>
+
+Chaque ligne contient une boîte horizontale (<em/hbox/) contenant
+plusieurs boutons. L'appel à <em/gtk_box_pack/ indique la façon dont
+sont placés tous les boutons dans la hbox.  Chaque bouton est placé
+dans la hbox de la même façon (mêmes paramètres que la fonction
+<em/gtk_box_pack_start()/).
+<p>
+Voici la déclaration de la fonction <em/gtk_box_pack_start/.
+
+<tscreen><verb>
+void gtk_box_pack_start (GtkBox    *box,
+			 GtkWidget *child,
+			 gint	    expand,
+			 gint	    fill,
+			 gint	    padding);
+</verb></tscreen>
+
+Le premier paramètre est la boîte dans laquelle on place l'objet, le
+second est cet objet. Tous les objets sont tous des boutons jusqu'à
+maintenant, on place donc des boutons dans des boîtes.
+<p>
+Le paramètre <em/expand/ de <em/gtk_box_pack_start()/ ou
+<em/gtk_box_pack_end()/ contrôle la façon dont le widget est placé
+dans la boîte. S'il vaut TRUE, les widgets sont disposés dans la boîte
+de façon à en occuper tout l'espace. S'il vaut FALSE, la boîte est
+rétrécie pour correspondre à la taille du widget. Mettre <em/expand/ à
+FALSE vous permettra d'aligner à droite et à gauche vos
+widgets. Sinon, ils s'élargiront pour occuper toute la boîte. Le même
+effet pourrait être obtenu en utilisant uniquement une des deux
+fonctions <em/gtk_box_pack_start/ ou <em/pack_end/.
+<p>
+Le paramètre <em/fill/ des fonctions <em/gtk_box_pack/ contrôle si de
+l'espace supplémentaire doit être alloué aux objets eux-mêmes (TRUE),
+ou si on doit rajouter de l'espace (<em/padding/) dans la boîte autour
+des objets (FALSE). Il n'a de sens que si le paramètre <em/expand/
+vaut TRUE.
+<p>
+Lorsque l'on crée une nouvelle boîte, on utilise une fonction comme&nbsp;:
+
+<tscreen><verb>
+GtkWidget * gtk_hbox_new (gint homogeneous,
+			  gint spacing);
+</verb></tscreen>
+
+Le paramètre <em/homogeneous/ de <em/gtk_hbox_new/ (et c'est la même
+chose pour <em/gtk_vbox_new/) vérifie que chaque objet de la boîte ait
+la même taille (i.e. la même largeur dans une hbox, la même hauteur
+dans une vbox). S'il vaut TRUE, le paramètre <em/expand/ des fonctions
+<em/gtk_box_pack/ sera toujours mis à TRUE.
+<p>
+Quelle est alors la différence entre les paramètres <em/spacing/
+(configuré lorsque la boîte est créée) et <em/padding/ (configuré
+lorque les éléments sont placés) ? <em/spacing/ ajoute de l'espace
+entre les objets, et <em/padding/ en ajoute de chaque côté d'un
+objet. La figure suivante devrait éclairer tout cela&nbsp;:
+
+<?
+<IMG ALIGN="center" SRC="packbox2.gif"
+VSPACE="15" HSPACE="10" ALT="Box Packing Example Image" WIDTH="509"
+HEIGHT="213">
+>
+
+Voici le code utilisé pour créer les images ci-dessus. J'y ai mis beaucoup de
+commentaires en espérant que vous n'aurez pas de problème pour le
+relire. Compilez-le et jouez avec les différents paramètres.
+
+<sect1>Programme de démonstration des placements
+<p>
+
+<tscreen><verb>
+#include "gtk/gtk.h"
+
+void
+delete_event (GtkWidget *widget, GdkEvent *event, gpointer *data)
+{
+    gtk_main_quit ();
+}
+
+/* Construction d'une nouvelle hbox remplie de boutons. Les paramètres qui 
+ * nous intéressent sont passés à cette fonction.
+ * On n'affiche pas la boîte, mais tout ce qu'elle contient. */
+
+GtkWidget *make_box (gint homogeneous, gint spacing,
+		     gint expand, gint fill, gint padding) 
+{
+    GtkWidget *box;
+    GtkWidget *button;
+    char padstr[80];
+    
+    /* Création d'une hbox avec les paramètres homogeneous et spacing
+     * voulus. */
+
+    box = gtk_hbox_new (homogeneous, spacing);
+    
+    /* Création d'une série de boutons configurés de façon appropriée */
+
+    button = gtk_button_new_with_label ("gtk_box_pack");
+    gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
+    gtk_widget_show (button);
+    
+    button = gtk_button_new_with_label ("(box,");
+    gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
+    gtk_widget_show (button);
+    
+    button = gtk_button_new_with_label ("button,");
+    gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
+    gtk_widget_show (button);
+    
+    /* Création d'un bouton portant un label dépendant de la valeur
+     * du paramètre expand. */
+
+    if (expand == TRUE)
+	    button = gtk_button_new_with_label ("TRUE,");
+    else
+	    button = gtk_button_new_with_label ("FALSE,");
+    
+    gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
+    gtk_widget_show (button);
+    
+    /* Même chose que ci-dessus mais sous forme abrégée. */
+
+    button = gtk_button_new_with_label (fill ? "TRUE," : "FALSE,");
+    gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
+    gtk_widget_show (button);
+    
+    /* Récupération du paramètre padding sous forme de chaîne. */
+
+    sprintf (padstr, "%d);", padding);
+    
+    button = gtk_button_new_with_label (padstr);
+    gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
+    gtk_widget_show (button);
+    
+    return box;
+}
+
+int main (int argc, char *argv[])
+{
+    GtkWidget *window;
+    GtkWidget *button;
+    GtkWidget *box1;
+    GtkWidget *box2;
+    GtkWidget *separator;
+    GtkWidget *label;
+    GtkWidget *quitbox;
+    int which;
+    
+    /* Initialisation, à ne jamais oublier ! :) */
+
+    gtk_init (&amp;argc, &amp;argv);
+   
+    if (argc != 2) {
+	fprintf (stderr, "usage : %s num, où num vaut 1, 2, ou 3.\n", *argv);
+
+	/* Nettoyage dans GTK et sortie avec un code d'erreur de 1 */
+	gtk_exit (1);
+    }
+    
+    which = atoi (argv[1]);
+
+    /* Création de notre fenêtre. */
+
+    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+    /* Il ne faut jamais oublier de connecter le signal "destroy" à la
+     * fenêtre principale. C'est très important pour disposer d'un 
+     * comportement intuitif adéquat. */
+
+    gtk_signal_connect (GTK_OBJECT (window), "delete_event",
+			GTK_SIGNAL_FUNC (delete_event), NULL);
+
+    gtk_container_border_width (GTK_CONTAINER (window), 10);
+    
+
+    /* Création d'une boîte verticale (vbox) pour y placer les boîtes
+     * horizontales.
+     * Ceci permet de placer les boîtes horizontales contenant les boutons
+     * les unes au dessus des autres dans cette vbox. */
+
+    box1 = gtk_vbox_new (FALSE, 0);
+    
+    /* L'exemple à afficher. Ils correspondent aux images ci-dessus. */
+
+    switch (which) {
+    case 1:
+	/* Création d'un label. */
+
+	label = gtk_label_new ("gtk_hbox_new (FALSE, 0);");
+	
+	/* Alignement du label à gauche.  On précisera cette fonction ainsi
+         * que les autres dans la section sur les attributs des widgets. */
+
+	gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
+
+	/* Placement du label dans la boîte verticale (vbox box1). Il ne
+         * faut pas oublier que les widgets qui s'ajoutent à une vbox sont
+         * placés les uns au dessus des autres. */
+
+	gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
+	
+	/* Affichage du label */
+
+	gtk_widget_show (label);
+	
+	/* On appelle notre fonction de construction de boîte :
+         * homogeneous = FALSE, spacing = 0,
+	 * expand = FALSE, fill = FALSE, padding = 0 */
+
+	box2 = make_box (FALSE, 0, FALSE, FALSE, 0);
+	gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
+	gtk_widget_show (box2);
+
+	/* On appelle notre fonction de construction de boîte :
+         * homogeneous = FALSE, spacing = 0,
+	 * expand = FALSE, fill = FALSE, padding = 0 */
+
+	box2 = make_box (FALSE, 0, TRUE, FALSE, 0);
+	gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
+	gtk_widget_show (box2);
+	
+	/* Paramètres : homogeneous = FALSE, spacing = 0, 
+         * expand = TRUE, fill = TRUE, padding = 0 */
+
+	box2 = make_box (FALSE, 0, TRUE, TRUE, 0);
+	gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
+	gtk_widget_show (box2);
+	
+	/* Création d'un séparateur, on verra cela plus tard, mais ils sont
+         * simples à utiliser. */
+
+	separator = gtk_hseparator_new ();
+	
+	/* Placement du séparateur dans la vbox. Ne pas oublier que tous les
+         * widgets sont placés dans une vbox et qu'il seront placés 
+         * verticalement. */
+
+	gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
+	gtk_widget_show (separator);
+	
+	/* Création d'un nouveau label et affichage de celui-ci. */
+
+	label = gtk_label_new ("gtk_hbox_new (TRUE, 0);");
+	gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
+	gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
+	gtk_widget_show (label);
+	
+	/* Paramètres : homogeneous = TRUE, spacing = 0, 
+         * expand = TRUE, fill = FALSE, padding = 0 */
+
+	box2 = make_box (TRUE, 0, TRUE, FALSE, 0);
+	gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
+	gtk_widget_show (box2);
+	
+	/* Paramètres : homogeneous = TRUE, spacing = 0, 
+         * expand = TRUE, fill = TRUE, padding = 0 */
+
+	box2 = make_box (TRUE, 0, TRUE, TRUE, 0);
+	gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
+	gtk_widget_show (box2);
+	
+	/* Un autre séparateur */
+
+	separator = gtk_hseparator_new ();
+
+	/* Les 3 derniers paramètres de gtk_box_pack_start sont : 
+         * expand = FALSE, fill = TRUE, padding = 5. */
+
+	gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
+	gtk_widget_show (separator);
+	
+	break;
+
+    case 2:
+
+	/* Création d'un label, box1 est une vbox identique à 
+         * celle créée au début de main() */
+
+	label = gtk_label_new ("gtk_hbox_new (FALSE, 10);");
+	gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
+	gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
+	gtk_widget_show (label);
+	
+	/* Paramètres : homogeneous = FALSE, spacing = 10, 
+         * expand = TRUE, fill = FALSE, padding = 0 */
+
+	box2 = make_box (FALSE, 10, TRUE, FALSE, 0);
+	gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
+	gtk_widget_show (box2);
+	
+	/* Paramètres : homogeneous = FALSE, spacing = 10, 
+         * expand = TRUE, fill = TRUE, padding = 0 */
+
+	box2 = make_box (FALSE, 10, TRUE, TRUE, 0);
+	gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
+	gtk_widget_show (box2);
+	
+	separator = gtk_hseparator_new ();
+
+        /* Les 3 derniers paramètres de gtk_box_pack_start sont : 
+         * expand = FALSE, fill = TRUE, padding = 5. */
+
+	gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
+	gtk_widget_show (separator);
+	
+	label = gtk_label_new ("gtk_hbox_new (FALSE, 0);");
+	gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
+	gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
+	gtk_widget_show (label);
+	
+        /* Paramètres : homogeneous = FALSE, spacing = 0, 
+         * expand = TRUE, fill = FALSE, padding = 10 */
+
+	box2 = make_box (FALSE, 0, TRUE, FALSE, 10);
+	gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
+	gtk_widget_show (box2);
+	
+	/* Paramètres : homogeneous = FALSE, spacing = 0, 
+         * expand = TRUE, fill = TRUE, padding = 10 */
+
+	box2 = make_box (FALSE, 0, TRUE, TRUE, 10);
+	gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
+	gtk_widget_show (box2);
+	
+	separator = gtk_hseparator_new ();
+
+        /* Les 3 derniers paramètres de gtk_box_pack_start sont : 
+         * expand = FALSE, fill = TRUE, padding = 5. */
+        
+	gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
+	gtk_widget_show (separator);
+	break;
+    
+    case 3:
+
+        /* Ceci est une démonstration de la possibilité d'utiliser 
+         * gtk_box_pack_end() pour aligner les widgets à droite.
+         * On crée d'abord une nouvelle boîte comme d'habitude. */
+
+	box2 = make_box (FALSE, 0, FALSE, FALSE, 0);
+
+	/* On crée le label qui sera mis à la fin. */
+
+	label = gtk_label_new ("end");
+
+	/* On le place en utilisant gtk_box_pack_end(), il est ainsi
+         * mis à droite de la hbox créée par l'appel à make_box(). */
+
+	gtk_box_pack_end (GTK_BOX (box2), label, FALSE, FALSE, 0);
+
+	/* Affichage du label. */
+
+	gtk_widget_show (label);
+	
+	/* Placement de box2 dans box1 (la vbox, vous vous rappelez ? :) */
+
+	gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
+	gtk_widget_show (box2);
+	
+	/* Séparateur pour le bas. */
+
+	separator = gtk_hseparator_new ();
+
+	/* Configuration du séparateur en 400x5 pixels. 
+         * La hbox que l'on a créée aura donc 400 pixels de large, 
+         * et le label "end" sera séparé des autres de la hbox.
+         * Sinon, tous les widgets de la hbox seraient placés les plus
+         * près possible les uns des autres. */
+
+	gtk_widget_set_usize (separator, 400, 5);
+
+	/* Placement du séparateur dans la vbox (box1) 
+         * créée au debut de main(). */
+
+	gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
+	gtk_widget_show (separator);    
+    }
+    
+    /* Création d'une nouvelle hbox.. vous pouvez en utiliser autant que
+     * que vous en avez besoin ! */
+
+    quitbox = gtk_hbox_new (FALSE, 0);
+    
+    /* Notre bouton pour quitter. */
+
+    button = gtk_button_new_with_label ("Quit");
+    
+    /* Configuration du signal pour détruire la fenêtre. Ceci enverra le
+     * signal "destroy" à la fenêtre. Ce signal sera à son tour capturé
+     * par notre gestionnaire de signal défini plus haut. */
+
+    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+			       GTK_SIGNAL_FUNC (gtk_widget_destroy),
+			       GTK_OBJECT (window));
+
+    /* Placement du bouton dans la « quitbox ».
+     * Les 3 derniers paramètres de gtk_box_pack_start sont : 
+     * expand = TRUE, fill = FALSE, padding = 0. */
+
+    gtk_box_pack_start (GTK_BOX (quitbox), button, TRUE, FALSE, 0);
+
+    /* Placement de la quitbox dans la vbox (box1) */
+
+    gtk_box_pack_start (GTK_BOX (box1), quitbox, FALSE, FALSE, 0);
+    
+    /* Placement de la vbox (box1), qui contient maintenant tous nos
+     * widgets, dans la fenêtre principale. */
+
+    gtk_container_add (GTK_CONTAINER (window), box1);
+    
+    /* Affichage */
+
+    gtk_widget_show (button);
+    gtk_widget_show (quitbox);
+    
+    gtk_widget_show (box1);
+
+    /* Affichage de la fenêtre en dernier */
+
+    gtk_widget_show (window);
+    
+    /* Ne pas oublier notre fonction principale. */
+
+    gtk_main ();
+
+    /* Le contrôle revient ici lorsque gtk_main_quit() est appelée,
+     * jusqu'à ce que  gtk_exit() soitutilisée. */
+    
+    return 0;
+}
+</verb></tscreen>
+
+<p>
+<sect1>Placement avec les tables
+<p>
+Étudions une autre méthode de placement&nbsp;: les tables. Elles
+peuvent s'avérer très utiles dans certaines situations.
+
+En utilisant des tables, on crée une grille dans laquelle on peut
+placer les widgets. Ceux-ci peuvent occuper tous les endroits que l'on
+désire.
+
+La première chose à faire est, bien sûr, d'étudier la fonction
+<em/gtk_table_new/&nbsp;:
+
+<tscreen><verb>
+GtkWidget* gtk_table_new (gint rows,
+                          gint columns,
+                          gint homogeneous);
+</verb></tscreen>
+<p>
+Le premier paramètre est le nombre de lignes de la table et le
+deuxième, le nombre de colonnes.
+
+Le paramètre <em/homogeneous/ s'occupe de la façon dont les cases de
+la table seront dimensionnées. Si homogeneous vaut TRUE, les cases
+prennent la taille du plus grand widget de la table. S'il vaut FALSE,
+la taille des cases dépend du widget le plus haut de la ligne et du
+plus large de cette colonne.
+
+Le nombre de lignes et colonnes va de 0 à n, où n est le nombre spécifié dans
+l'appel à <em/gtk_table_new/. Ainsi, avec <em/rows/ = 2 et
+<em/columns/ = 2, la table ressemblera à ceci&nbsp;:
+
+<tscreen><verb>
+ 0          1          2
+0+----------+----------+
+ |          |          |
+1+----------+----------+
+ |          |          |
+2+----------+----------+
+</verb></tscreen>
+<p>
+On notera que le système de coordonnées part du coin en haut à
+gauche. Pour placer un widget dans une case, ou utilise la fonction
+suivante&nbsp;:
+
+<tscreen><verb>
+void gtk_table_attach (GtkTable      *table,
+                       GtkWidget     *child,
+		       gint           left_attach,
+		       gint           right_attach,
+		       gint           top_attach,
+		       gint           bottom_attach,
+		       gint           xoptions,
+		       gint           yoptions,
+		       gint           xpadding,
+		       gint           ypadding);
+</verb></tscreen>				       
+<p>
+Où le premier paramètre (<em/table/) est la table que l'on a créée et
+le second (<em/child/) est le widget que l'on veut placer dans la
+table.
+
+Les paramètres <em/left_attach/ et <em/right_attach/ spécifient
+l'emplacement du widget et le nombre de cases à utiliser. Par exemple,
+si on veut placer un bouton dans le coin inférieur droit de la table
+décrite plus haut et que l'on désire ne remplir QUE cette case,
+<em/left_attach/ vaudra 1, <em/right_attach/ vaudra 2; <em/top_attach/
+vaudra 1 et <em/bottom_attach/ vaudra 2.
+
+Si on veut un widget occupant toute la ligne supérieure de notre table, on utilisera
+les valeurs 0, 2, 0, 1.
+
+Les paramètres <em/xoptions/ et <em/yoptions/ servent à préciser les
+options de placement et peuvent être combinées par un OU logique pour
+permettre des options multiples.
+
+Ces options sont&nbsp;:
+<itemize>
+<item>GTK_FILL - Si la case de la table est plus large que le widget, et que
+GTK_FILL est spécifié, le widget s'élargira pour occuper toute la place
+disponible.
+
+<item>GTK_SHRINK - Si la table a moins de place qu'il ne lui en faut
+(généralement, à cause d'un redimensionnement de la fenêtre par
+l'utilisateur), les widgets sont alors simplement poussés vers le bas
+de la fenêtre et disparaissent. Si GTK_SHRINK est spécifié, les
+widgets se réduiront en même temps que la table.
+
+<item>GTK_EXPAND - Cette option provoque l'extension de la table pour
+qu'elle utilise tout l'espace restant dans la fenêtre.
+</itemize>
+
+Le paramêtres de <em/padding/ jouent le même rôle que pour les boîtes,
+il créent une zone libre, spécifiée en pixels, autour du widget.
+
+gtk_table_attach() a BEAUCOUP d'options.  Voici donc une fonction-raccourci&nbsp;:
+
+<tscreen><verb>
+void gtk_table_attach_defaults (GtkTable   *table,
+                                GtkWidget  *widget,
+				gint        left_attach,
+				gint        right_attach,
+				gint        top_attach,
+				gint        bottom_attach);
+</verb></tscreen>
+
+<em/xoptions/ et <em/options/ valent par défaut GTK_FILL | GTK_EXPAND,
+et <em/xpadding/ et <em/ypadding/ valent 0. Les autres paramètres sont
+les mêmes que ceux de la fonction précédente.
+
+Il existe aussi les fonctions <em/gtk_table_set_row_spacing()/ et
+<em/gtk_table_set_col_spacing()/. Elles permettent de placer des
+espaces après une ligne ou une colonne.
+
+<tscreen><verb>
+void gtk_table_set_row_spacing (GtkTable      *table,
+                                gint           row,
+				gint           spacing);
+</verb></tscreen>
+et
+<tscreen><verb>
+void gtk_table_set_col_spacing  (GtkTable      *table,
+                                 gint           column,
+				 gint           spacing);
+</verb></tscreen>
+
+Pour les colonnes, l'espace est ajouté à droite de la colonne et pour
+les lignes, il est ajouté en dessous.
+
+On peut aussi configurer un espacement pour toutes les lignes et/ou
+colonnes avec&nbsp;:
+
+<tscreen><verb>
+void gtk_table_set_row_spacings (GtkTable *table,
+                                 gint      spacing);
+</verb></tscreen>
+<p>
+Et,
+<tscreen><verb>
+void gtk_table_set_col_spacings (GtkTable  *table,
+                                 gint       spacing);
+</verb></tscreen>
+<p>
+Avec ces appels, la dernière ligne et la dernière colonne n'ont pas
+d'espace supplémentaire.
+
+<sect1>Exemple de placement avec table
+<p>
+Pour le moment, étudiez l'exemple sur les tables (testgtk.c) distribué
+avec les sources de GTK.
+
+<sect>Vue d'ensemble des widgets
+<p>
+<p>
+Les étapes pour créer un widget en GTK sont&nbsp;:
+<enum>
+<item> <em/gtk_*_new()/ - une des fonctions disponibles pour créer un
+nouveau widget. Ces fonctions sont décrites dans cette section.
+
+<item> Connexion de tous les signaux que l'on souhaite utiliser avec
+les gestionnaires adéquats.
+
+<item> Configuration des attributs du widget.
+
+<item> Placement du widget dans un container en utilisant un appel approprié comme
+<em/gtk_container_add()/ ou <em/gtk_box_pack_start()/.
+
+<item> Affichage du widget grâce à <em/gtk_widget_show()/.
+</enum>
+<p>
+<em/gtk_widget_show()/ permet à GTK de savoir que l'on a fini de
+configurer les attributs du widget et qu'il est prêt à être
+affiché. On peut aussi utiliser <em/gtk_widget_hide()/ pour le faire
+disparaître. L'ordre dans lequel on affiche les widgets n'est pas
+important, mais il est préférable d'afficher la fenêtre en dernier
+pour qu'elle surgisse d'un seul coup plutôt que de voir les différents
+widgets apparaître à l'écran au fur et à mesure. Les fils d'un widget
+(une fenêtre est aussi un widget) ne seront pas affichés tant que la
+fenêtre elle-même n'est pas affichée par la fonction
+<em/gtk_widget_show()/.
+
+<sect1> Conversions de types
+<p>
+Vous remarquerez, au fur et à mesure que vous progressez, que GTK
+utilise un système de coercition de type. Celle-ci est toujours
+réalisée en utilisant des macros qui vérifient si l'objet donné peut
+être converti et qui réalisent cette coercition. Les macros que vous
+rencontrerez le plus sont&nbsp;:
+
+<itemize>
+<item> GTK_WIDGET(widget)
+<item> GTK_OBJECT(object)
+<item> GTK_SIGNAL_FUNC(function)
+<item> GTK_CONTAINER(container)
+<item> GTK_WINDOW(window)
+<item> GTK_BOX(box)
+</itemize>
+
+Elles sont toutes utilisées pour convertir les paramètres des
+fonctions. Vous les verrez dans les exemples et, en règle générale,
+vous saurez les utiliser simplement en regardant la
+déclaration d'une fonction.
+
+Comme vous pouvez le voir dans la hiérarchie de classes ci-dessous,
+tous les <em/GtkWidgets/ dérivent d'une classe de base
+<em/GtkObject/. Ceci signifie que vous pouvez utiliser un widget à
+chaque fois qu'une fonction requiert un objet - il suffit d'utiliser
+la macro GTK_OBJECT().
+
+Par exemple&nbsp;:
+
+<tscreen><verb>
+gtk_signal_connect(GTK_OBJECT(button), "clicked",
+                   GTK_SIGNAL_FUNC(fonction_rappel), donnee_de_rappel);
+</verb></tscreen> 
+
+Cet appel convertit le bouton en objet et fournit une conversion pour
+le pointeur de fonction vers la fonction de rappel.
+
+De nombreux widgets sont aussi des containers. Si vous regardez la
+hiérarchie de classe ci-dessous, vous remarquerez que beaucoup de
+widgets viennent de la classe <em/GtkContainer/. N'importe lequel de
+ces widgets peut être utilisé avec la macro GTK_CONTAINER pour être
+passé en paramètre à une fonction qui attend un container.
+
+Malheureusement, ces macros ne peuvent être couvertes en détail dans
+ce didacticiel, Je vous recommande donc de jeter un coup d'oeil sur
+les fichier en-têtes GTK&nbsp;: ils peuvent s'avérer très
+instructifs. En fait, il n'est pas difficile de comprendre comment
+fonctionne un widget, il suffit d'étudier les déclarations des
+fonctions.
+
+<p>
+<sect1>La hiérarchie des widgets
+<p>
+Voici l'arbre de la hiérarchie de classes utilisées pour implanter les widgets.
+
+<tscreen><verb>
+    GtkObject
+    +-- GtkData
+    |	\-- GtkAdjustment
+    |
+    \-- GtkWidget
+	+-- GtkContainer
+	|   +-- GtkBin
+	|   |	+-- GtkAlignment
+	|   |	+-- GtkFrame
+	|   |	|   *-- GtkAspectFrame
+	|   |	|
+	|   |	+-- GtkItem
+	|   |	|   +-- GtkListItem
+	|   |	|   +-- GtkMenuItem
+	|   |	|   |	+-- GtkCheckMenuItem
+	|   |	|   |	    *-- GtkRadioMenuItem
+	|   |	|   |
+	|   |	|   *-- GtkTreeItem
+	|   |	|
+	|   |	+-- GtkViewport
+	|   |	\-- GtkWindow
+	|   |	    +-- GtkDialog
+	|   |	    \-- GtkFileSelection
+	|   |
+	|   +-- GtkBox
+	|   |	+-- GtkHBox
+	|   |	\-- GtkVBox
+	|   |	    +-- GtkColorSelection
+	|   |	    \-- GtkCurve
+	|   |
+	|   +-- GtkButton
+	|   |	+-- GtkOptionMenu
+	|   |	\-- GtkToggleButton
+	|   |	    \-- GtkCheckButton
+	|   |		\-- GtkRadioButton
+	|   |
+	|   +-- GtkList
+	|   +-- GtkMenuShell
+	|   |	+-- GtkMenu
+	|   |	\-- GtkMenuBar
+	|   |
+	|   +-- GtkNotebook
+	|   +-- GtkScrolledWindow
+	|   +-- GtkTable
+	|   \-- GtkTree
+	|
+	+-- GtkDrawingArea
+	+-- GtkEntry
+	+-- GtkMisc
+	|   +-- GtkArrow
+	|   +-- GtkImage
+	|   +-- GtkLabel
+	|   \-- GtkPixmap
+	|
+	+-- GtkPreview
+	+-- GtkProgressBar
+	+-- GtkRange
+	|   +-- GtkScale
+	|   |	+-- GtkHScale
+	|   |	\-- GtkVScale
+	|   |
+	|   \-- GtkScrollbar
+	|	+-- GtkHScrollbar
+	|	\-- GtkVScrollbar
+	|
+	+-- GtkRuler
+	|   +-- GtkHRuler
+	|   \-- GtkVRuler
+	|
+	\-- GtkSeparator
+	    +-- GtkHSeparator
+	    \-- GtkVSeparator
+
+</verb></tscreen>
+<p>
+
+<sect1>Widgets sans fenêtre
+<p>
+Les widgets suivants n'ont pas de fenêtre associée. Si vous voulez
+capturer des événements, vous devez utiliser <em/GtkEventBox/.
+Reportez-vous à la section sur
+<ref id="sec_The_EventBox_Widget" name="Le widget EventBox">
+
+<tscreen><verb>
+GtkAlignment
+GtkArrow
+GtkBin
+GtkBox
+GtkImage
+GtkItem
+GtkLabel
+GtkPaned
+GtkPixmap
+GtkScrolledWindow
+GtkSeparator
+GtkTable
+GtkViewport
+GtkAspectFrame
+GtkFrame
+GtkVPaned
+GtkHPaned
+GtkVBox
+GtkHBox
+GtkVSeparator
+GtkHSeparator
+</verb></tscreen>
+<p>
+Nous continuerons notre exploration de GTK en examinant chaque widget
+tour à tour, créant quelques fonctions simples pour les afficher. Une
+autre source intéressante est le programme <em/testgtk.c/ livré avec
+GTK. Il se trouve dans le répertoire <em>gtk/</em>
+
+<sect>Widgets boutons
+<p>
+<sect1>Boutons normaux
+<p>
+On a déjà presque vu tout ce qu'il y avait à voir sur le widget
+bouton. Il est très simple. Cependant, il y a deux façons de créer un
+bouton. On peut utiliser <em/gtk_button_new_with_label()/ pour créer
+un bouton avec un label, ou <em/gtk_button_new()/ pour créer un bouton
+vide. Dans ce dernier cas, c'est à vous de placer un label ou un
+pixmap sur celui-ci. Pour ce faire, créez une boîte, puis placez vos
+objets dans celle-ci en utilisant la fonction habituelle
+<em/gtk_box_pack_start/, utilisez alors <em/gtk_container_add/ pour
+placer la boîte dans le bouton.
+<p>
+Voici un exemple d'utilisation de <em/gtk_button_new()/ pour créer un
+bouton contenant une image et un label. J'ai séparé du reste le code
+qui crée une boîte pour que vous puissiez l'utiliser dans vos
+programmes.
+
+
+<tscreen><verb>
+#include <gtk/gtk.h>
+
+
+/* Création d'une hbox avec une image et un label. Cette fonction 
+ * retourne la boîte... */
+
+GtkWidget *xpm_label_box (GtkWidget *parent, gchar *xpm_filename, 
+                          gchar *label_text)
+{
+    GtkWidget *box1;
+    GtkWidget *label;
+    GtkWidget *pixmapwid;
+    GdkPixmap *pixmap;
+    GdkBitmap *mask;
+    GtkStyle *style;
+
+    /* Création de la boite pour un xpm et un label */
+
+    box1 = gtk_hbox_new (FALSE, 0);
+    gtk_container_border_width (GTK_CONTAINER (box1), 2);
+
+    /* Choix d'un style de bouton... Je suppose que c'est pour obtenir
+     * la couleur du fond. Si quelqu'un connaît la vraie raison, qu'il
+     * m'éclaire sur ce point. */
+
+    style = gtk_widget_get_style(parent);
+
+    /* Chargement de xpm pour créer une image */
+
+    pixmap = gdk_pixmap_create_from_xpm (parent->window, &amp;mask,
+					 &amp;style->bg[GTK_STATE_NORMAL],
+					 xpm_filename);
+    pixmapwid = gtk_pixmap_new (pixmap, mask);
+
+    /* Création d'un label  */
+
+    label = gtk_label_new (label_text);
+
+    /* placement de l'image et du label dans la boîte */
+
+    gtk_box_pack_start (GTK_BOX (box1),
+			pixmapwid, FALSE, FALSE, 3);
+
+    gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 3);
+
+    gtk_widget_show(pixmapwid);
+    gtk_widget_show(label);
+
+    return (box1);
+}
+
+/* Notre fonction de rappel habituelle */
+
+void callback (GtkWidget *widget, gpointer *data)
+{
+    g_print ("Bonjour - %s a été pressé\n", (char *) data);
+}
+
+
+int main (int argc, char *argv[])
+{
+    /* GtkWidget est le type utilisé pour déclarer les widgets */
+
+    GtkWidget *window;
+    GtkWidget *button;
+    GtkWidget *box1;
+
+    gtk_init (&amp;argc, &amp;argv);
+
+    /* Création d'une fenêtre */
+
+    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+    gtk_window_set_title (GTK_WINDOW (window), "Pixmap'd Buttons!");
+
+    /* Il est préférable de faire cela pour toutes les fenêtres */
+
+    gtk_signal_connect (GTK_OBJECT (window), "destroy",
+			GTK_SIGNAL_FUNC (gtk_exit), NULL);
+
+
+    /* Configuration du bord de la fenêtre */
+
+    gtk_container_border_width (GTK_CONTAINER (window), 10);
+
+    /* Création d'un bouton */
+
+    button = gtk_button_new ();
+
+    /* Vous devriez être habitué à voir ces fonctions maintenant */
+
+    gtk_signal_connect (GTK_OBJECT (button), "clicked",
+			GTK_SIGNAL_FUNC (callback), (gpointer) "cool button");
+
+    /* Appel de notre fonction de création de boîte */
+
+    box1 = xpm_label_box(window, "info.xpm", "cool button");
+
+    /* Placement et affichage de tous nos widgets */
+
+    gtk_widget_show(box1);
+
+    gtk_container_add (GTK_CONTAINER (button), box1);
+
+    gtk_widget_show(button);
+
+    gtk_container_add (GTK_CONTAINER (window), button);
+
+    gtk_widget_show (window);
+
+    /* Le reste est dans gtk_main */
+    gtk_main ();
+
+    return 0;
+}
+</verb></tscreen>
+
+La fonction <em/xpm_label_box()/ peut être utilisée pour placer des
+xpms et des labels sur tout widget qui peut être container.
+
+<sect1> Boutons commutateurs
+<p>
+Les boutons commutateurs ressemblent beaucoup aux boutons normaux, sauf
+qu'ils seront toujours alternativement dans un état ou dans un
+autre. Le changement d'état s'effectue par un click. Ils peuvent être
+enfoncés et, lorsqu'on clique dessus, ils se relèvent.  Re-cliquez,
+et ils se renfoncent.
+
+Les boutons commutateurs sont la base des cases à cocher ou des boutons
+radio, donc la plupart des appels utilisés pour les boutons commutateurs
+sont hérités par les cases à cocher et les boutons radio. J'insisterai
+là dessus quand nous les aborderons.
+
+Création d'un bouton commutateur : 
+
+<tscreen><verb>
+GtkWidget* gtk_toggle_button_new (void);
+
+GtkWidget* gtk_toggle_button_new_with_label (gchar *label);
+</verb></tscreen>
+<p>
+Comme vous pouvez l'imaginer, elles fonctionnent comme celles des
+boutons normaux. La première crée un bouton commutateur vide et la
+deuxième un bouton commutateur contenant déjà un label.
+<p>
+Pour récupérer l'état d'un commutateur et cela comprend aussi les
+cases à cocher et les boutons radio, on utilise une macro comme nous
+le montrons dans l'exemple qui suit et qui teste l'état du commutateur
+dans une fonction de rappel. Le signal qui nous intéresse et qui est
+émis par les boutons commutateurs (ce qui comprend aussi les cases à
+cocher et les boutons radio), est le signal "toggled". Pour vérifier
+l'état de ces boutons, on configure un gestionnaire de signal qui
+capture "toggled" et utilise la macro pour déterminer l'état. La
+fonction de rappel ressemblera à ceci&nbsp;:
+
+<tscreen><verb>
+void rappel_bouton_commutateur (GtkWidget *widget, gpointer data)
+{
+    if (GTK_TOGGLE_BUTTON(widget)->active) 
+    {
+        /* Si l'on est ici, c'est que le bouton est relâché. */
+    
+    } else {
+    
+        /* le bouton est enfoncé */
+    }
+}
+</verb></tscreen>
+
+<!--
+
+COMMENTED!
+
+<tscreen><verb>
+guint gtk_toggle_button_get_type (void);
+</verb></tscreen>
+<p>
+No idea... they all have this, but I dunno what it is :)
+
+
+<tscreen><verb>
+void gtk_toggle_button_set_mode (GtkToggleButton *toggle_button,
+                                 gint draw_indicator);
+</verb></tscreen>
+<p>
+No idea.
+-->
+
+<p>
+L'appel qui suit peut être utilisé pour configurer l'état d'un bouton
+commutateur et de ses descendants, les cases à cocher et les boutons
+radio. On lui passe notre bouton en premier paramètre et TRUE ou
+FALSE pour spécifier s'il doit être relâché ou enfoncé. Par défaut, il
+est relâché (FALSE).
+
+<tscreen><verb>
+void gtk_toggle_button_set_state (GtkToggleButton *toggle_button,
+                                  gint state);
+</verb></tscreen>
+<p>
+On notera que lorsqu'on utilise cette fonction, et que l'état est
+modifié, cela force le bouton à émettre un signal "clicked".
+
+<tscreen><verb>
+void gtk_toggle_button_toggled (GtkToggleButton *toggle_button);
+</verb></tscreen>
+<p>
+Cet appel ne fait que commuter le bouton et émettre le signal "toggled".
+
+<sect1> Cases à cocher
+<p>
+Les cases à cocher héritent de nombreuses propriétés et fonctions des
+boutons commutateurs, mais ont un aspect différent. Au lieu d'être des
+boutons contenant du texte, ce sont de petits carrés avec un texte sur
+leur droite. Il sont souvent utilisés pour valider ou non des options
+dans les applications.
+
+Les deux fonctions de création sont identiques à celles des boutons normaux.
+
+<tscreen><verb>
+GtkWidget* gtk_check_button_new (void);
+
+GtkWidget* gtk_check_button_new_with_label (gchar *label);
+</verb></tscreen>
+
+La fonction <em/new_with_label/ crée une case à cocher avec un texte à
+coté d'elle.
+
+La vérification de l'état d'une case à cocher est identique à celle
+des boutons commutateurs.
+
+<sect1> Boutons radio
+<p>
+Les boutons radio ressemblent aux cases à cocher sauf qu'ils sont
+groupés de façon à ce qu'un seul d'entre-eux puisse être sélectionné à
+un moment donné. Ils sont utilisés par les applications lorsqu'il
+s'agit d'effectuer un choix dans une liste d'options.
+
+La création d'un bouton radio s'effectue grâce à l'un des appels
+suivants&nbsp;:
+
+<tscreen><verb>
+GtkWidget* gtk_radio_button_new (GSList *group);
+
+GtkWidget* gtk_radio_button_new_with_label (GSList *group,
+                                            gchar *label);
+</verb></tscreen>
+<p>
+On notera le paramètre supplémentaire de ces fonctions. Elles
+nécessitent un groupe pour réaliser correctement leur tâche. Le
+premier appel doit passer NULL au premier paramètre puis on peut créer un
+groupe en utilisant&nbsp;:
+
+<tscreen><verb>
+GSList* gtk_radio_button_group (GtkRadioButton *radio_button);
+</verb></tscreen>
+
+<p>
+On passe alors ce groupe en premier paramètre des appels suivants aux fonctions de création.  Il est préférable, aussi, de préciser quel bouton doit être choisi par défaut avec la fonction&nbsp;:
+
+<tscreen><verb>
+void gtk_toggle_button_set_state (GtkToggleButton *toggle_button,
+                                  gint state);
+</verb></tscreen>
+<p>
+Celle-ci est décrite dans la section sur les boutons commutateurs et fonctionne
+exactement de la même façon.
+<p>
+[Mettre ici un exemple d'utilisation de tout cela car je crois que cela ferait
+beaucoup de bien...]
+
+
+<sect> Widgets divers
+<p>
+<sect1> Labels
+<p>
+Les labels sont très utilisés dans GTK et sont relativement
+simples. Ils n'émettent pas de signaux car ils n'ont pas de fenêtre X
+qui leur est associée. Si vous avez besoin de capturer des signaux ou
+de faire des coupures (« clippings »), utilisez un widget EventBox.
+
+Pour créer un label, on utilise&nbsp;:
+
+<tscreen><verb>
+GtkWidget* gtk_label_new (char *str);
+</verb></tscreen>
+
+Où l'unique paramètre est la chaîne de caractères que l'on veut que le
+label affiche.
+
+Pour changer le texte d'un label après sa création, on utilise la fonction&nbsp;:
+
+<tscreen><verb>
+void gtk_label_set (GtkLabel  *label,
+		    char      *str);
+</verb></tscreen>
+<p>
+où le premier paramètre est le label que l'on veut modifier, que l'on
+convertit en utilisant la macro GTK_LABEL(), et le second est la
+nouvelle chaîne.
+
+L'espace nécessaire à la nouvelle chaîne sera automatiquement ajusté
+si nécessaire.
+
+Pour récupérer la chaîne courante, on utilise la fonction&nbsp;:
+
+<tscreen><verb>
+void gtk_label_get (GtkLabel  *label,
+		    char     **str);
+</verb></tscreen>
+
+où le premier paramètre est le label dont on veut récupérer la chaîne
+et le second sert à retourner cette chaîne.
+
+<sect1>Le widget bulle d'aide
+<p>
+Ce sont les petits textes qui surgissent lorsque vous laissez votre
+pointeur sur un bouton ou un autre widget pendant quelques secondes.
+Ils sont faciles à utiliser, on ne donnera donc pas d'exemple. Si vous
+voulez voir du code, consultez le programme <em/testgtk.c/ distribué
+avec GTK.
+<p>
+Certains widgets (comme les labels) ne fonctionnent pas avec les
+bulles d'aide.
+<p>
+Le premier appel que vous utiliserez sera pour créer une nouvelle
+bulle d'aide. Vous n'avez besoin que de le faire une fois dans une
+fonction donnée. Le <em/GtkTooltip/ que cette fonction retourne peut
+être utilisé pour créer plusieurs bulles d'aide.
+
+<tscreen><verb>
+GtkTooltips *gtk_tooltips_new (void);
+</verb></tscreen>
+
+Lorsque vous avez créé une nouvelle bulle d'aide et le widget sur lequel vous
+voulez l'utiliser, vous n'avez qu'à faire cet appel pour la configurer&nbsp;:
+
+<tscreen><verb>
+void gtk_tooltips_set_tips   (GtkTooltips *tooltips,
+			      GtkWidget   *widget,
+			      gchar	  *tips_text);
+</verb></tscreen>
+
+Les paramètres sont la bulle d'aide déjà créée, suivi du widget pour
+lequel vous voulez voir apparaître cette bulle et le texte que vous
+voulez qu'elle contienne.
+<p>
+Voici un petit exemple&nbsp;:
+
+<tscreen><verb>
+GtkTooltips *tooltips;
+GtkWidget *button;
+...
+tooltips = gtk_tooltips_new ();
+button = gtk_button_new_with_label ("bouton 1");
+...
+gtk_tooltips_set_tips (tooltips, button, "C'est le bouton 1");
+</verb></tscreen>
+
+
+D'autres fonctions peuvent être utilisées avec les bulles d'aide. Je ne ferais que les énumérer et les décrire brièvement.
+
+<tscreen><verb>
+void gtk_tooltips_destroy    (GtkTooltips *tooltips);
+</verb></tscreen>
+
+Destruction de bulles d'aide.
+
+<tscreen><verb>
+void gtk_tooltips_enable     (GtkTooltips *tooltips);
+</verb></tscreen>
+
+Activation d'un ensemble de bulles d'aide désactivées.
+
+<tscreen><verb>
+void gtk_tooltips_disable    (GtkTooltips *tooltips);
+</verb></tscreen>
+
+Désactivation d'un ensemble de bulles d'aide activées.
+
+<tscreen><verb>
+void gtk_tooltips_set_delay  (GtkTooltips *tooltips,
+			      gint	   delay);
+
+</verb></tscreen> Configure le nombre de millisecondes pendant lequel
+le pointeur soit se trouver sur le widget avant que la bulle d'aide
+n'apparaisse. Par défaut, ce délai est de 1000 millisecondes, soit 1
+seconde.
+
+<tscreen><verb>
+void	  gtk_tooltips_set_tips (GtkTooltips *tooltips,
+			         GtkWidget   *widget,
+			         gchar	  *tips_text);
+</verb></tscreen>
+
+Change le texte d'une bulle d'aide déjà créée.
+
+<tscreen><verb>
+void gtk_tooltips_set_colors (GtkTooltips *tooltips,
+			      GdkColor	  *background,
+			      GdkColor	  *foreground);
+</verb></tscreen>
+
+Configure les couleurs de fond et de premier plan des bulles
+d'aides. Je ne sais toujours pas comment spécifier les couleurs...
+<p>
+Et c'est tout concernant les fonctions associées aux bulles
+d'aide. C'est plus que vous ne vouliez sûrement en savoir :)
+
+<sect1> Barres de progression
+<p>
+Les barres de progression sont utilisées pour afficher la progression
+d'une opération. Elles sont très simple à utiliser comme vous pourrez
+le constater en étudiant le code ci-dessous. Commençons d'abord par
+l'appel permettant de créer une nouvelle barre.
+
+<tscreen><verb>
+GtkWidget *gtk_progress_bar_new (void);
+</verb></tscreen>
+
+Maintenant que la barre est créée, nous pouvons l'utiliser. 
+
+<tscreen><verb>
+void gtk_progress_bar_update (GtkProgressBar *pbar, gfloat percentage);
+</verb></tscreen>
+
+Le premier paramètre est la barre de progression sur laquelle on veut
+agir, et le second est le pourcentage « effectué », signifiant le
+remplissage de la barres de 0 à 100 % (réel compris entre 0 et 1).
+
+Les barres de progression sont généralement utilisées avec les délais
+d'expiration ou autres fonctions identiques (voir la section sur <ref
+id="sec_timeouts" name="Expirations, fonctions d'E/S et d'attente">)
+pour donner l'illusion du multi-tâches. Toutes emploient la fonction
+<em/gtk_progress_bar_update/ de la même façon.
+
+Voici un exemple de barre de progression mise à jour par des
+expirations. Ce code montre aussi comment réinitialiser une barre.
+
+<tscreen><verb>
+#include <gtk/gtk.h>
+
+static int ptimer = 0;
+int pstat = TRUE;
+
+/* Cette fonction incrémente et met à jour la barre de progression,
+ * elle la réinitialise si pstat vaut FALSE */
+
+gint progress (gpointer data)
+{
+    gfloat pvalue;
+    
+    /* récupération de la valeur courante de la barre */
+
+    pvalue = GTK_PROGRESS_BAR (data)->percentage;
+    
+    if ((pvalue >= 1.0) || (pstat == FALSE)) {
+	pvalue = 0.0;
+	pstat = TRUE;
+    }
+    pvalue += 0.01;
+    
+    gtk_progress_bar_update (GTK_PROGRESS_BAR (data), pvalue);
+    
+    return TRUE;
+}
+
+/* Cette fonction signale une réinitialisation de la barre */
+
+void progress_r (void)
+{  
+    pstat = FALSE;  
+}
+
+void destroy (GtkWidget *widget, gpointer *data)
+{
+    gtk_main_quit ();
+}
+
+int main (int argc, char *argv[])
+{
+    GtkWidget *window;
+    GtkWidget *button;
+    GtkWidget *label;
+    GtkWidget *table;
+    GtkWidget *pbar;
+    
+    gtk_init (&amp;argc, &amp;argv);
+    
+    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+    
+    gtk_signal_connect (GTK_OBJECT (window), "delete_event",
+			GTK_SIGNAL_FUNC (destroy), NULL);
+    
+    gtk_container_border_width (GTK_CONTAINER (window), 10);
+    
+    table = gtk_table_new(3,2,TRUE);
+    gtk_container_add (GTK_CONTAINER (window), table);
+    
+    label = gtk_label_new ("Exemple de barre de progression");
+    gtk_table_attach_defaults(GTK_TABLE(table), label, 0,2,0,1);
+    gtk_widget_show(label);
+    
+    /* Crée une barre, la place dans la table et l'affiche */
+
+    pbar = gtk_progress_bar_new ();
+    gtk_table_attach_defaults(GTK_TABLE(table), pbar, 0,2,1,2);
+    gtk_widget_show (pbar);
+    
+    /* Configure le délai d'expiration pour gérer automatiquement la
+     *  mise à jour de la barre */ 
+
+    ptimer = gtk_timeout_add (100, progress, pbar);
+    
+    /* Ce bouton indique à la barre qu'elle doit se réinitialiser */
+
+    button = gtk_button_new_with_label ("Reset");
+    gtk_signal_connect (GTK_OBJECT (button), "clicked",
+			GTK_SIGNAL_FUNC (progress_r), NULL);
+    gtk_table_attach_defaults(GTK_TABLE(table), button, 0,1,2,3);
+    gtk_widget_show(button);
+    
+    button = gtk_button_new_with_label ("Annuler");
+    gtk_signal_connect (GTK_OBJECT (button), "clicked",
+			GTK_SIGNAL_FUNC (destroy), NULL);
+    
+    gtk_table_attach_defaults(GTK_TABLE(table), button, 1,2,2,3);
+    gtk_widget_show (button);
+    
+    gtk_widget_show(table);
+    gtk_widget_show(window);
+    
+    gtk_main ();
+    
+    return 0;
+}
+</verb></tscreen>
+
+Dans ce petit programme, il y a quatre parties concernant le
+fonctionnement général des barres de progression, nous les étudierons
+dans l'ordre de leurs appels.
+
+<tscreen><verb>
+pbar = gtk_progress_bar_new ();
+</verb></tscreen>
+
+Cet appel crée une nouvelle barre, nommée <em/pbar/.
+
+<tscreen><verb>
+ptimer = gtk_timeout_add (100, progress, pbar);
+</verb></tscreen>
+
+Cet appel utilise des délais d'expiration pour permettre un intervalle
+de temps constant. ces délais ne sont pas nécessaires à l'utilisation
+des barres de progression.
+
+<tscreen><verb>
+pvalue = GTK_PROGRESS_BAR (data)->percentage;
+</verb></tscreen>
+
+Ce code assigne à <em/pvalue/ la valeur du pourcentage de la barre.
+
+<tscreen><verb>
+gtk_progress_bar_update (GTK_PROGRESS_BAR (data), pvalue);
+</verb></tscreen>
+
+Finalement, ce code met à jour la barre avec la valeur de <em/pvalue/.
+
+Et c'est tout ce qu'il y a à savoir sur les barres de
+progression. Amusez-vous bien.
+
+<sect1> Boîtes de dialogue
+<p>
+
+Les widgets boîtes de dialogue sont très simples&nbsp;: ce sont
+simplement des fenêtres avec plusieurs choses déjà placées dedans. La
+structure d'une boîte de dialogue est&nbsp;:
+
+<tscreen><verb>
+struct GtkDialog
+{
+      GtkWindow window;
+    
+      GtkWidget *vbox;
+      GtkWidget *action_area;
+};
+</verb></tscreen>
+
+Comme vous le voyez, cela crée simplement une fenêtre et la place dans
+une vbox suivie d'un séparateur et d'une hbox pour la « zone d'action ».
+
+Le widget boîte de dialogue peut servir à produire des messages pour
+l'utilisateur ainsi qu'à d'autres tâches. Il est vraiment rudimentaire
+et il n'y a qu'une seule fonction pour les boîtes de dialogue&nbsp;:
+
+<tscreen><verb>
+GtkWidget* gtk_dialog_new (void);
+</verb></tscreen>
+
+Ainsi, pour créer un nouveau dialogue, on utilise&nbsp;:
+
+<tscreen><verb>
+GtkWidget window;
+window = gtk_dialog_new ();
+</verb></tscreen>
+
+Ceci créera la boîte de dialogue et c'est maintenant à vous de
+l'utiliser. Vous pouvez, par exemple, placer un bouton dans la zone
+d'action en faisant quelque chose comme&nbsp;:
+
+<tscreen><verb>
+button = ...
+gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button,
+		    TRUE, TRUE, 0);
+gtk_widget_show (button);
+</verb></tscreen>
+
+Et vous pouvez aussi ajouter un label à la zone de la vboxb&nbsp;:
+
+<tscreen><verb>
+label = gtk_label_new ("Les boîtes de dialogues sont pratiques");
+gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), label, TRUE,
+		    TRUE, 0);
+gtk_widget_show (label);
+</verb></tscreen>
+
+Comme exemple d'utilisation d'une boîte de dialogue, vous pourriez
+mettre deux boutons dans la zone d'action (un bouton « Annuler » et un
+bouton « Ok ») et un label dans la zone de la vbox posant une question
+à l'utilisateur ou signalant une erreur, etc. Vous pouvez alors
+attacher un signal différent à chacun des boutons et réaliser
+l'opération que l'utilisateur a choisie.
+
+
+<sect1> Pixmaps
+<p>
+Les pixmaps sont des structures de données contenant des
+images. Celles-ci peuvent être utilisées à différents endroits, mais
+le plus souvent comme icônes dans le bureau X Window. Un bitmap est un
+pixmap de 2 couleurs.
+
+Pour utiliser des pixmaps avec GTK, on doit d'abord construire une
+structure <em/GdkPixmap/ en utilisant les fonctions de la couche
+GDK. Les pixmaps peuvent soit être créés à partir de données en
+memoire, ou à partir de données lues dans un fichier. Nous utiliserons
+chacun des appels pour créer un pixmap.
+
+<tscreen><verb>
+GdkPixmap *gdk_bitmap_create_from_data( GdkWindow *window,
+                                        gchar     *data,
+                                        gint      width,
+                                        gint      height );
+</verb></tscreen>
+<p>
+Cette fonction sert à créer un pixmap mono-plan (2 couleurs) à partir
+de données en mémoire. Chaque bit de la donnée <em/data/. <em/width/
+et <em/height/ sont exprimés en pixels. Le pointeur vers un
+<em/GdkWindow/ pointe sur la fenêtre courante car les ressources d'un
+pixmap n'ont de signification que dans le contexte de l'écran où il
+doit s'afficher.
+
+<tscreen><verb>
+GdkPixmap* gdk_pixmap_create_from_data( GdkWindow  *window,
+                                        gchar      *data,
+                                        gint        width,
+                                        gint        height,
+                                        gint        depth,
+                                        GdkColor   *fg,
+                                        GdkColor   *bg );
+</verb></tscreen>
+
+Cette fonction est utilisée pour créer un pixmap d'une profondeur
+donnée (nombre de couleurs) à partir de la donnée spécifiée pas
+<em/data/. <em/fg/ et <em/bg/ sont les couleurs à utiliser pour
+l'avant et l'arrière-plan.
+
+<tscreen><verb>
+GdkPixmap* gdk_pixmap_create_from_xpm( GdkWindow  *window,
+                                       GdkBitmap **mask,
+                                       GdkColor   *transparent_color,
+                                       const gchar *filename );
+</verb></tscreen>
+
+Le format XPM est une représentation des pixmaps reconnue par le système X Window. Il est largement utilisé et de nombreux utilitaires pour créer des fichiers d'images à ce format sont disponibles. Le fichier <em/filename/ doit contenir une image dans ce format qui sera chargée dans la structure pixmap. Le masque <em/mask/ indique quels sont les bits opaques du pixmap. Tous les autres bits sont colorisés en utilisant la couleur spécifiée par <em/transparent_color/. Un exemple d'utilisation est présenté ci-dessous.
+
+<tscreen><verb>
+GdkPixmap* gdk_pixmap_create_from_xpm_d (GdkWindow  *window,
+                                         GdkBitmap **mask,
+                                         GdkColor   *transparent_color,
+                                         gchar     **data);
+</verb></tscreen>
+
+De petites images peuvent être intégrées dans un programme sous la forme de
+données <em/data/ au format XPM. Un pixmap est créé en utilisant ces données au
+lieu de les lire dans un fichier. Un exemple de telles données est&nbsp;:
+
+<tscreen><verb>
+/* XPM */
+static const char * xpm_data[] = {
+"16 16 3 1",
+"       c None",
+".      c #000000000000",
+"X      c #FFFFFFFFFFFF",
+"                ",
+"   ......       ",
+"   .XXX.X.      ",
+"   .XXX.XX.     ",
+"   .XXX.XXX.    ",
+"   .XXX.....    ",
+"   .XXXXXXX.    ",
+"   .XXXXXXX.    ",
+"   .XXXXXXX.    ",
+"   .XXXXXXX.    ",
+"   .XXXXXXX.    ",
+"   .XXXXXXX.    ",
+"   .XXXXXXX.    ",
+"   .........    ",
+"                ",
+"                "};
+</verb></tscreen>
+
+<tscreen><verb>
+void gdk_pixmap_destroy( GdkPixmap  *pixmap );
+</verb></tscreen>
+<p>
+Lorsqu'on a utilisé un pixmap et que l'on en a plus besoin tout de suite, il est préférable de libérer la ressource en utilisant un appel à <em/gdk_pixmap_destroy/.  Les pixmaps doivent être considérées comme une ressource précieuse.
+
+Quand le pixmap est créé, on peut l'afficher comme un widget GTK. On
+doit créer un widget pixmap qui contiendra le pixmap GDK. Ceci est
+réalisé de la façon suivante&nbsp;:
+
+<tscreen><verb>
+GtkWidget* gtk_pixmap_new( GdkPixmap  *pixmap,
+                           GdkBitmap  *mask );
+</verb></tscreen>
+<p>
+Les autres fonctions pour les widgets pixmap sont&nbsp;:
+
+<tscreen><verb>
+guint gtk_pixmap_get_type( void );
+void  gtk_pixmap_set( GtkPixmap  *pixmap,
+                      GdkPixmap  *val,
+                      GdkBitmap  *mask);
+void  gtk_pixmap_get( GtkPixmap  *pixmap,
+                      GdkPixmap **val,
+                      GdkBitmap **mask);
+</verb></tscreen>
+<p>
+<em/gtk_pixmap_set/ sert à changer le pixmap pris en charge par le widget. <em/val/ est le pixmap créé par le GDK.
+
+Voici un exemple illustrant l'utilisation d'un pixmap dans un bouton&nbsp;:
+
+<tscreen><verb>
+
+#include <gtk/gtk.h>
+
+
+/* données XPM d'une icône "Ouvrir fichier" */
+static const char * xpm_data[] = {
+"16 16 3 1",
+"       c None",
+".      c #000000000000",
+"X      c #FFFFFFFFFFFF",
+"                ",
+"   ......       ",
+"   .XXX.X.      ",
+"   .XXX.XX.     ",
+"   .XXX.XXX.    ",
+"   .XXX.....    ",
+"   .XXXXXXX.    ",
+"   .XXXXXXX.    ",
+"   .XXXXXXX.    ",
+"   .XXXXXXX.    ",
+"   .XXXXXXX.    ",
+"   .XXXXXXX.    ",
+"   .XXXXXXX.    ",
+"   .........    ",
+"                ",
+"                "};
+
+
+/* Termine l'application lorsqu'elle est appelée 
+ * via le signal "delete_event" */
+
+void close_application( GtkWidget *widget, GdkEvent *event, gpointer *data ) 
+{
+    gtk_main_quit();
+}
+
+
+/* Invoquée lorsque le bouton est cliqué. Affiche simplement 
+ * un message. */
+
+void button_clicked( GtkWidget *widget, gpointer *data ) 
+{
+    printf( "bouton cliqué\n" );
+}
+
+
+int main( int argc, char *argv[] )
+{
+    /* GtkWidget est le type pour déclarer les widgets */
+
+    GtkWidget *window, *pixmapwid, *button;
+    GdkPixmap *pixmap;
+    GdkBitmap *mask;
+    GtkStyle *style;
+    
+    /* Crée la fenêtre principale et attache le signal "delete_event" pour 
+     * terminer l'application */
+
+    gtk_init( &amp;argc, &amp;argv );
+    window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
+    gtk_signal_connect( GTK_OBJECT (window), "delete_event",
+                        GTK_SIGNAL_FUNC (close_application), NULL );
+    gtk_container_border_width( GTK_CONTAINER (window), 10 );
+    gtk_widget_show( window );
+
+    /* Utilisation de GDK pour créer le pixmap */
+
+    style = gtk_widget_get_style( window );
+    pixmap = gdk_pixmap_create_from_xpm_d( window->window,  &amp;mask,
+                                           &amp;style->bg[GTK_STATE_NORMAL],
+                                           (gchar **)xpm_data );
+
+    /* Création d'un widget pixmap GTK pour contenir le pixmap GDK */
+
+    pixmapwid = gtk_pixmap_new( pixmap, mask );
+    gtk_widget_show( pixmapwid );
+
+    /* Création d'un bouton pour contenir le widget pixmap */
+
+    button = gtk_button_new();
+    gtk_container_add( GTK_CONTAINER(button), pixmapwid );
+    gtk_container_add( GTK_CONTAINER(window), button );
+    gtk_widget_show( button );
+
+    gtk_signal_connect( GTK_OBJECT(button), "clicked",
+                        GTK_SIGNAL_FUNC(button_clicked), NULL );
+
+    /* Affichage de la fenêtre */
+    gtk_main ();
+          
+    return 0;
+}
+</verb></tscreen>
+
+
+Pour charger un fichier à partir d'un fichier XPM appelé
+<em/icon0.xpm/ se trouvant dans le répertoire courant, on aurait créé
+le pixmap ainsi&nbsp;:
+
+<tscreen><verb>
+    /* Charge un pixmap à partir d'un fichier */
+
+    pixmap = gdk_pixmap_create_from_xpm( window->window, &amp;mask,
+                                         &amp;style->bg[GTK_STATE_NORMAL],
+                                         "./icon0.xpm" );
+    pixmapwid = gtk_pixmap_new( pixmap, mask );
+    gtk_widget_show( pixmapwid );
+    gtk_container_add( GTK_CONTAINER(window), pixmapwid );
+</verb></tscreen>
+
+
+Utilisation des formes
+<p>
+Un désavantage de l'utilisation des pixmaps est que l'objet affiché
+est toujours rectangulaire, quelle que soit l'image. On voudrait
+pouvoir créer des bureaux et des applications avec des icônes ayant
+des formes plus naturelles. Par exemple, pour une interface de jeu, on
+aimerait avoir des boutons ronds à pousser. Pour faire cela, on doit
+utiliser des fenêtres avec des formes.
+
+Une fenêtre avec forme est simplement un pixmap dont les pixels du
+fond sont transparents. Ainsi, lorsque l'image d'arrière-plan est
+multicolore, on ne la cache pas avec le bord de notre icône. L'exemple
+suivant affiche une image de brouette sur le bureau.
+
+<tscreen><verb>
+
+#include <gtk/gtk.h>
+
+/* XPM */
+static char * WheelbarrowFull_xpm[] = {
+"48 48 64 1",
+"       c None",
+".      c #DF7DCF3CC71B",
+"X      c #965875D669A6",
+"o      c #71C671C671C6",
+"O      c #A699A289A699",
+"+      c #965892489658",
+"@      c #8E38410330C2",
+"#      c #D75C7DF769A6",
+"$      c #F7DECF3CC71B",
+"%      c #96588A288E38",
+"&amp;      c #A69992489E79",
+"*      c #8E3886178E38",
+"=      c #104008200820",
+"-      c #596510401040",
+";      c #C71B30C230C2",
+":      c #C71B9A699658",
+">      c #618561856185",
+",      c #20811C712081",
+"<      c #104000000000",
+"1      c #861720812081",
+"2      c #DF7D4D344103",
+"3      c #79E769A671C6",
+"4      c #861782078617",
+"5      c #41033CF34103",
+"6      c #000000000000",
+"7      c #49241C711040",
+"8      c #492445144924",
+"9      c #082008200820",
+"0      c #69A618611861",
+"q      c #B6DA71C65144",
+"w      c #410330C238E3",
+"e      c #CF3CBAEAB6DA",
+"r      c #71C6451430C2",
+"t      c #EFBEDB6CD75C",
+"y      c #28A208200820",
+"u      c #186110401040",
+"i      c #596528A21861",
+"p      c #71C661855965",
+"a      c #A69996589658",
+"s      c #30C228A230C2",
+"d      c #BEFBA289AEBA",
+"f      c #596545145144",
+"g      c #30C230C230C2",
+"h      c #8E3882078617",
+"j      c #208118612081",
+"k      c #38E30C300820",
+"l      c #30C2208128A2",
+"z      c #38E328A238E3",
+"x      c #514438E34924",
+"c      c #618555555965",
+"v      c #30C2208130C2",
+"b      c #38E328A230C2",
+"n      c #28A228A228A2",
+"m      c #41032CB228A2",
+"M      c #104010401040",
+"N      c #492438E34103",
+"B      c #28A2208128A2",
+"V      c #A699596538E3",
+"C      c #30C21C711040",
+"Z      c #30C218611040",
+"A      c #965865955965",
+"S      c #618534D32081",
+"D      c #38E31C711040",
+"F      c #082000000820",
+"                                                ",
+"          .XoO                                  ",
+"         +@#$%o&amp;                                ",
+"         *=-;#::o+                              ",
+"           >,<12#:34                            ",
+"             45671#:X3                          ",
+"               +89<02qwo                        ",
+"e*                >,67;ro                       ",
+"ty>                 459@>+&amp;&amp;                    ",
+"$2u+                  ><ipas8*                  ",
+"%$;=*                *3:.Xa.dfg>                ",
+"Oh$;ya             *3d.a8j,Xe.d3g8+             ",
+" Oh$;ka          *3d$a8lz,,xxc:.e3g54           ",
+"  Oh$;kO       *pd$%svbzz,sxxxxfX..&amp;wn>         ",
+"   Oh$@mO    *3dthwlsslszjzxxxxxxx3:td8M4       ",
+"    Oh$@g&amp; *3d$XNlvvvlllm,mNwxxxxxxxfa.:,B*     ",
+"     Oh$@,Od.czlllllzlmmqV@V#V@fxxxxxxxf:%j5&amp;   ",
+"      Oh$1hd5lllslllCCZrV#r#:#2AxxxxxxxxxcdwM*  ",
+"       OXq6c.%8vvvllZZiqqApA:mq:Xxcpcxxxxxfdc9* ",
+"        2r<6gde3bllZZrVi7S@SV77A::qApxxxxxxfdcM ",
+"        :,q-6MN.dfmZZrrSS:#riirDSAX@Af5xxxxxfevo",
+"         +A26jguXtAZZZC7iDiCCrVVii7Cmmmxxxxxx%3g",
+"          *#16jszN..3DZZZZrCVSA2rZrV7Dmmwxxxx&amp;en",
+"           p2yFvzssXe:fCZZCiiD7iiZDiDSSZwwxx8e*>",
+"           OA1<jzxwwc:$d%NDZZZZCCCZCCZZCmxxfd.B ",
+"            3206Bwxxszx%et.eaAp77m77mmmf3&amp;eeeg* ",
+"             @26MvzxNzvlbwfpdettttttttttt.c,n&amp;  ",
+"             *;16=lsNwwNwgsvslbwwvccc3pcfu<o    ",
+"              p;<69BvwwsszslllbBlllllllu<5+     ",
+"              OS0y6FBlvvvzvzss,u=Blllj=54       ",
+"               c1-699Blvlllllu7k96MMMg4         ",
+"               *10y8n6FjvllllB<166668           ",
+"                S-kg+>666<M<996-y6n<8*          ",
+"                p71=4 m69996kD8Z-66698&amp;&amp;        ",
+"                &amp;i0ycm6n4 ogk17,0<6666g         ",
+"                 N-k-<>     >=01-kuu666>        ",
+"                 ,6ky&amp;      &amp;46-10ul,66,        ",
+"                 Ou0<>       o66y<ulw<66&amp;       ",
+"                  *kk5       >66By7=xu664       ",
+"                   <<M4      466lj<Mxu66o       ",
+"                   *>>       +66uv,zN666*       ",
+"                              566,xxj669        ",
+"                              4666FF666>        ",
+"                               >966666M         ",
+"                                oM6668+         ",
+"                                  *4            ",
+"                                                ",
+"                                                "};
+
+
+/* Termine l'application lorsqu'elle est appelée 
+ * (via le signal "delete_event"). */
+
+void close_application( GtkWidget *widget, GdkEvent *event, gpointer *data ) 
+{
+    gtk_main_quit();
+}
+
+
+int main (int argc, char *argv[])
+{
+    GtkWidget *window, *pixmap, *fixed;
+    GdkPixmap *gdk_pixmap;
+    GdkBitmap *mask;
+    GtkStyle *style;
+    GdkGC *gc;
+    
+    /* crée la fenêtre principale et attache le signal "delete_event"
+     * pour terminer l'application. On notera que la fenêtre principale
+     * n'a pas de barre de titre car nous la faisons surgir. */
+
+    gtk_init (&amp;argc, &amp;argv);
+    window = gtk_window_new( GTK_WINDOW_POPUP );
+    gtk_signal_connect (GTK_OBJECT (window), "delete_event",
+                        GTK_SIGNAL_FUNC (close_application), NULL);
+    gtk_widget_show (window);
+
+    /* Création du pixmap et du widget pixmap */
+
+    style = gtk_widget_get_default_style();
+    gc = style->black_gc;
+    gdk_pixmap = gdk_pixmap_create_from_xpm_d( window->window, &amp;mask,
+                                             &amp;style->bg[GTK_STATE_NORMAL],
+                                             WheelbarrowFull_xpm );
+    pixmap = gtk_pixmap_new( gdk_pixmap, mask );
+    gtk_widget_show( pixmap );
+
+    /* Pour afficher le pixmap, on utilise un widget fixe pour placer
+     * le pixmap */
+
+    fixed = gtk_fixed_new();
+    gtk_widget_set_usize( fixed, 200, 200 );
+    gtk_fixed_put( GTK_FIXED(fixed), pixmap, 0, 0 );
+    gtk_container_add( GTK_CONTAINER(window), fixed );
+    gtk_widget_show( fixed );
+
+    /* On masque tout sauf l'image elle-même */
+
+    gtk_widget_shape_combine_mask( window, mask, 0, 0 );
+    
+    /* Affichage de la fenêtre */
+
+    gtk_widget_set_uposition( window, 20, 400 );
+    gtk_widget_show( window );
+    gtk_main ();
+          
+    return 0;
+}
+</verb></tscreen>
+<p>
+Pour rendre l'image de la brouette sensible aux clics, on peut lui
+attacher le signal "button_press_event" pour lui faire faire quelque
+chose. Les quelques lignes suivantes font que l'image sera sensible à
+un clic souris qui provoquera l'arrêt de l'application.
+
+<tscreen><verb>
+gtk_widget_set_events( window,
+                       gtk_widget_get_events( window ) |
+		       GDK_BUTTON_PRESS_MASK );
+
+gtk_signal_connect( GTK_OBJECT(window), "button_press_event",
+                    GTK_SIGNAL_FUNC(close_application), NULL );
+</verb></tscreen>
+
+
+<sect> Widgets containers
+
+<sect1> Bloc-notes
+<p>
+Le widget bloc-notes est un ensemble de « pages » qui se
+chevauchent. Chaque page contient des informations
+différentes. Récemment, ce widget est devenu plus commun dans la
+programmation des interfaces graphiques et c'est un bon moyen de
+montrer des blocs d'information similaires qui justifient une
+séparation de leur affichage.
+
+Le premier appel de fonction que l'on doit connaître est, vous
+l'aviez deviné, celui qui crée un widget bloc-notes.
+
+<tscreen><verb>
+GtkWidget* gtk_notebook_new (void);
+</verb></tscreen>
+
+Lorsque le bloc-notes a été créé, il y a 12 fonctions permettant de
+travailler sur les blocs-notes. Étudions-les séparément.
+
+La première permet de positionner les indicateurs de pages. Ceux-ci
+(désignés par le mot « tab » (signet)), peuvent se trouver en haut, en
+bas, à gauche ou à droite des pages.
+
+<tscreen><verb>
+void gtk_notebook_set_tab_pos (GtkNotebook *notebook, GtkPositionType pos);
+</verb></tscreen>
+
+<em/GtkPositionType/ peut prendre les valeurs suivantes qu'il n'est
+pas nécessaire d'expliquer&nbsp;:
+<itemize>
+<item> GTK_POS_LEFT
+<item> GTK_POS_RIGHT
+<item> GTK_POS_TOP
+<item> GTK_POS_BOTTOM
+</itemize>
+
+GTK_POS_TOP est la valeur par défaut.
+
+La fonction suivante permet d'ajouter des pages à un bloc-notes. Il y
+a trois façons d'ajouter des pages. Regardons les deux premières qui
+sont très semblables.
+
+<tscreen><verb>
+void gtk_notebook_append_page (GtkNotebook *notebook, GtkWidget *child, 
+                               GtkWidget *tab_label);
+
+void gtk_notebook_prepend_page (GtkNotebook *notebook, GtkWidget *child, 
+                                GtkWidget *tab_label);
+</verb></tscreen>
+
+Ces fonctions ajoutent des pages au bloc-notes<em/*notebook/ en les
+insérant à la fin (<em/append/) ou au début
+(<em/prepend/). <em/*child/ est le widget qui est placé dans la page
+du bloc-notes, et <em/*tab_label/ est le label de la page qui est
+ajoutée.
+
+La troisième fonction ajoutant une page à un bloc-notes conserve
+toutes les propriétés des deux précédentes, mais elle nous permet en
+plus de spécifier la position où l'on désire insérer cette page.
+
+<tscreen><verb>
+void gtk_notebook_insert_page (GtkNotebook *notebook, GtkWidget *child, 
+                               GtkWidget *tab_label, gint position);
+</verb></tscreen>
+
+Les paramètres sont les mêmes que <em/_append_/ et <em/_prepend_/ sauf
+qu'il y en a un de plus&nbsp;: <em/position/. Celui-ci sert à
+spécifier l'endroit où cette page sera insérée.
+
+Maintenant que nous savons insérer une page, voyons comment en supprimer une.
+
+<tscreen><verb>
+void gtk_notebook_remove_page (GtkNotebook *notebook, gint page_num);
+</verb></tscreen>
+
+Cette fonction ôte la page spécifiée par <em/page_num/ du widget
+<em/*notebook/.
+
+Pour connaître la page courante d'un bloc-notes, on dispose de la
+fonction&nbsp;:
+
+<tscreen><verb>
+gint gtk_notebook_current_page (GtkNotebook *notebook);
+</verb></tscreen>
+
+Les deux fonctions suivantes permettent de passer à la page suivante
+ou précédente d'un bloc-notes. Il suffit de faire l'appel de la
+fonction adéquate avec le widget sur lequel on veut
+opérer. Remarque&nbsp;: lorsqu'on est sur la dernière page du
+bloc-notes et que l'on appelle <em/gtk_notebook_next_page/, on revient
+à la première page. De même, si l'on est sur la première page et que
+l'onappelle <em/gtk_notebook_prev_page/, on se retrouve sur sa
+dernière page.
+
+<tscreen><verb>
+void gtk_notebook_next_page (GtkNoteBook *notebook);
+void gtk_notebook_prev_page (GtkNoteBook *notebook);
+</verb></tscreen>
+
+La fonction qui suit permet de choisir la page « active ». Si vous
+voulez ouvrir le bloc-notes à la page 5, par exemple, vous utiliserez
+cette fonction. Sans elle, le bloc-notes s'ouvre sur sa première page
+par défaut.
+
+<tscreen><verb>
+void gtk_notebook_set_page (GtkNotebook *notebook, gint page_num);
+</verb></tscreen>
+
+Les deux fonctions suivantes ajoutent ou ôtent les indicateurs de page
+et le contour du bloc-notes, respectivement.
+
+<tscreen><verb>
+void gtk_notebook_set_show_tabs (GtkNotebook *notebook, gint show_tabs);
+void gtk_notebook_set_show_border (GtkNotebook *notebook, gint show_border);
+</verb></tscreen>
+
+<em/show_tabs/ et <em/show_border/ peuvent valoir TRUE ou FALSE (0 ou 1).
+
+Voyons maintenant un exemple, il est tiré du code de <em/testgtk.c/ de
+la distribution GTK et montre l'utilisation des 13 fonctions. Ce petit
+programme crée une fenêtre contenant un bloc-notes et six boutons. Le
+bloc-notes contient 11 pages, ajoutées par trois moyens
+différents&nbsp;: à la fin, au milieu et au début. Les boutons
+permettent de faire tourner les indicateurs de page, ajouter/ôter les
+indicateurs et le contour, ôter une page, passer à la page suivante et
+précédente, et sortir du programme.
+
+
+<tscreen><verb>
+
+#include <gtk/gtk.h>
+
+/* Rotation des indicateurs de page  */
+
+void rotate_book (GtkButton *button, GtkNotebook *notebook)
+{
+    gtk_notebook_set_tab_pos (notebook, (notebook->tab_pos +1) %4);
+}
+
+/* Ajout/Suppression des indicateurs de pages et des contours */
+
+void tabsborder_book (GtkButton *button, GtkNotebook *notebook)
+{
+    gint tval = FALSE;
+    gint bval = FALSE;
+    if (notebook->show_tabs == 0)
+	    tval = TRUE; 
+    if (notebook->show_border == 0)
+	    bval = TRUE;
+    
+    gtk_notebook_set_show_tabs (notebook, tval);
+    gtk_notebook_set_show_border (notebook, bval);
+}
+
+/* Suppression d'une page */
+
+void remove_book (GtkButton *button, GtkNotebook *notebook)
+{
+    gint page;
+    
+    page = gtk_notebook_current_page(notebook);
+    gtk_notebook_remove_page (notebook, page);
+
+    /* Il faut rafraîchir  le widget --
+     * ce qui force le widget à se redessiner. */
+
+      gtk_widget_draw(GTK_WIDGET(notebook), NULL);
+}
+
+void delete (GtkWidget *widget, GdkEvent *event, gpointer *data)
+{
+    gtk_main_quit ();
+}
+
+int main (int argc, char *argv[])
+{
+    GtkWidget *window;
+    GtkWidget *button;
+    GtkWidget *table;
+    GtkWidget *notebook;
+    GtkWidget *frame;
+    GtkWidget *label;
+    GtkWidget *checkbutton;
+    int i;
+    char bufferf[32];
+    char bufferl[32];
+    
+    gtk_init (&amp;argc, &amp;argv);
+    
+    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+    
+    gtk_signal_connect (GTK_OBJECT (window), "delete_event",
+			GTK_SIGNAL_FUNC (delete), NULL);
+    
+    gtk_container_border_width (GTK_CONTAINER (window), 10);
+    
+    table = gtk_table_new(2,6,TRUE);
+    gtk_container_add (GTK_CONTAINER (window), table);
+    
+    /* Création d'un bloc-notes, placement des indicateurs de page. */
+
+    notebook = gtk_notebook_new ();
+    gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
+    gtk_table_attach_defaults(GTK_TABLE(table), notebook, 0,6,0,1);
+    gtk_widget_show(notebook);
+    
+    /* Ajoute un groupe de pages à la fin du bloc-notes. */
+
+    for (i=0; i < 5; i++) {
+	sprintf(bufferf, "Append Frame %d", i+1);
+	sprintf(bufferl, "Page %d", i+1);
+	
+	frame = gtk_frame_new (bufferf);
+	gtk_container_border_width (GTK_CONTAINER (frame), 10);
+	gtk_widget_set_usize (frame, 100, 75);
+	gtk_widget_show (frame);
+	
+	label = gtk_label_new (bufferf);
+	gtk_container_add (GTK_CONTAINER (frame), label);
+	gtk_widget_show (label);
+	
+	label = gtk_label_new (bufferl);
+	gtk_notebook_append_page (GTK_NOTEBOOK (notebook), frame, label);
+    }
+    
+    
+    /* Ajoute une page à un endroit précis. */
+
+    checkbutton = gtk_check_button_new_with_label ("Cochez moi !");
+    gtk_widget_set_usize(checkbutton, 100, 75);
+    gtk_widget_show (checkbutton);
+    
+    label = gtk_label_new ("Emplacement de la nouvelle page");
+    gtk_container_add (GTK_CONTAINER (checkbutton), label);
+    gtk_widget_show (label);
+    label = gtk_label_new ("Ajout de page");
+    gtk_notebook_insert_page (GTK_NOTEBOOK (notebook), checkbutton, label, 2);
+    
+    /* Ajout de pages au début du bloc-notes */
+
+    for (i=0; i < 5; i++) {
+	sprintf(bufferf, "Prepend Frame %d", i+1);
+	sprintf(bufferl, "Page %d", i+1);
+	
+	frame = gtk_frame_new (bufferf);
+	gtk_container_border_width (GTK_CONTAINER (frame), 10);
+	gtk_widget_set_usize (frame, 100, 75);
+	gtk_widget_show (frame);
+	
+	label = gtk_label_new (bufferf);
+	gtk_container_add (GTK_CONTAINER (frame), label);
+	gtk_widget_show (label);
+	
+	label = gtk_label_new (bufferl);
+	gtk_notebook_prepend_page (GTK_NOTEBOOK(notebook), frame, label);
+    }
+    
+    /* Configuration de la page de départ (page 4) */
+
+    gtk_notebook_set_page (GTK_NOTEBOOK(notebook), 3);
+    
+    
+    /* Création des boutons */
+
+    button = gtk_button_new_with_label ("Fermer");
+    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+			       GTK_SIGNAL_FUNC (delete), NULL);
+    gtk_table_attach_defaults(GTK_TABLE(table), button, 0,1,1,2);
+    gtk_widget_show(button);
+    
+    button = gtk_button_new_with_label ("Page suivante");
+    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+			       (GtkSignalFunc) gtk_notebook_next_page,
+			       GTK_OBJECT (notebook));
+    gtk_table_attach_defaults(GTK_TABLE(table), button, 1,2,1,2);
+    gtk_widget_show(button);
+    
+    button = gtk_button_new_with_label ("Page précédente");
+    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+			       (GtkSignalFunc) gtk_notebook_prev_page,
+			       GTK_OBJECT (notebook));
+    gtk_table_attach_defaults(GTK_TABLE(table), button, 2,3,1,2);
+    gtk_widget_show(button);
+    
+    button = gtk_button_new_with_label ("Position des indicateurs");
+    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+			       (GtkSignalFunc) rotate_book, GTK_OBJECT(notebook));
+    gtk_table_attach_defaults(GTK_TABLE(table), button, 3,4,1,2);
+    gtk_widget_show(button);
+    
+    button = gtk_button_new_with_label ("Indicateurs/Contours oui/non");
+    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+			       (GtkSignalFunc) tabsborder_book,
+			       GTK_OBJECT (notebook));
+    gtk_table_attach_defaults(GTK_TABLE(table), button, 4,5,1,2);
+    gtk_widget_show(button);
+    
+    button = gtk_button_new_with_label ("Oter page");
+    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+			       (GtkSignalFunc) remove_book,
+			       GTK_OBJECT(notebook));
+    gtk_table_attach_defaults(GTK_TABLE(table), button, 5,6,1,2);
+    gtk_widget_show(button);
+    
+    gtk_widget_show(table);
+    gtk_widget_show(window);
+    
+    gtk_main ();
+    
+    return 0;
+}
+</verb></tscreen>
+<p>
+En espérant que ceci vous aide à créer des blocs-notes pour vos
+applications GTK.
+
+
+<sect1> Fenêtres avec barres de défilement
+<p>
+Les fenêtres avec barres de défilement servent à créer des zones
+défilantes à l'intérieur d'une vraie fenêtre. On peut insérer
+n'importe quel widget dans ces fenêtres, ils seront accessibles quelle
+que soit leur taille en utilisant les barres de défilement.
+
+
+La fonction suivante sert à créer une fenêtre avec barre de
+défilement&nbsp;:
+
+<tscreen><verb>
+GtkWidget* gtk_scrolled_window_new (GtkAdjustment *hadjustment,
+                                    GtkAdjustment *vadjustment);
+</verb></tscreen>
+<p>
+Le premier paramètre est l'ajustement horizontal, et le second
+l'ajustement vertical. Ils sont presque toujours positionnés à NULL.
+
+<tscreen><verb>
+void gtk_scrolled_window_set_policy      (GtkScrolledWindow *scrolled_window,
+                                          GtkPolicyType      hscrollbar_policy,
+			                  GtkPolicyType      vscrollbar_policy);
+</verb></tscreen>
+
+Cela permet de configurer le fonctionnement des barres de
+défilement. Le premier paramètre est la fenêtre à défilement que l'on
+veut modifier, le second configure le fonctionnement de la barre
+horizontale et le troisième celui de la barre verticale.
+
+Ce fonctionnement peut être GTK_POLICY AUTOMATIC ou GTK_POLICY_ALWAYS.
+GTK_POLICY_AUTOMATIC décidera automatiquement de votre besoin en
+barres de défilement, alors que GTK_POLICY_ALWAYS mettra toujours
+celles-ci.
+
+Voici un exemple simple qui place 100 boutons commutateurs dans une
+fenêtre à défilement. Je n'ai commenté que les parties qui sont
+nouvelles pour vous.
+
+<tscreen><verb>
+#include <gtk/gtk.h>
+
+void destroy(GtkWidget *widget, gpointer *data)
+{
+    gtk_main_quit();
+}
+
+int main (int argc, char *argv[])
+{
+    static GtkWidget *window;
+    GtkWidget *scrolled_window;
+    GtkWidget *table;
+    GtkWidget *button;
+    char buffer[32];
+    int i, j;
+    
+    gtk_init (&amp;argc, &amp;argv);
+    
+    /* Création d'une boîte de dialogue pour y placer la fenêtre à défilement.
+     * Une boîte de dialogue est une fenêtre comme les autres sauf qu'elle contient
+     * une vbox et un séparateur horizontal. Ce n'est qu'un raccourci pour créer des
+     * zones de dialogue. */
+
+    window = gtk_dialog_new ();
+    gtk_signal_connect (GTK_OBJECT (window), "destroy",
+			(GtkSignalFunc) destroy, NULL);
+    gtk_window_set_title (GTK_WINDOW (window), "dialog");
+    gtk_container_border_width (GTK_CONTAINER (window), 0);
+    
+    /* Création d'une fenêtre à défilement. */
+
+    scrolled_window = gtk_scrolled_window_new (NULL, NULL);
+    
+    gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10);
+    
+    /* La gestion des barres est soit GTK_POLICY AUTOMATIC, soit  GTK_POLICY_ALWAYS.
+     * GTK_POLICY_AUTOMATIC décide automatiquement s'il faut ou non des barres,
+     * GTK_POLICY_ALWAYS met toujours des barres
+     * Le premier paramètre correspond à la barre horizontale,
+     * le second à la barre verticale. */
+
+    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
+                                    GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
+
+    /* Création d'une boîte de dialogue */
+
+    gtk_box_pack_start (GTK_BOX (GTK_DIALOG(window)->vbox), scrolled_window, 
+			TRUE, TRUE, 0);
+    gtk_widget_show (scrolled_window);
+    
+    /* Création d'une table de 10x10 cases. */
+
+    table = gtk_table_new (10, 10, FALSE);
+    
+    /* Configure l'espace des lignes et des colonnes de 10 pixels */
+
+    gtk_table_set_row_spacings (GTK_TABLE (table), 10);
+    gtk_table_set_col_spacings (GTK_TABLE (table), 10);
+    
+    /* Place la table fans la fenêtre à défilement */
+
+    gtk_container_add (GTK_CONTAINER (scrolled_window), table);
+    gtk_widget_show (table);
+    
+    /* Crée une grille de boutons commutateurs dans la table */
+
+    for (i = 0; i < 10; i++)
+	    for (j = 0; j < 10; j++) {
+		sprintf (buffer, "bouton (%d,%d)\n", i, j);
+		button = gtk_toggle_button_new_with_label (buffer);
+		gtk_table_attach_defaults (GTK_TABLE (table), button,
+					   i, i+1, j, j+1);
+		gtk_widget_show (button);
+	    }
+    
+    /* Ajoute un bouton « Fermer » en bas de la boîte de dialogue */
+
+    button = gtk_button_new_with_label ("Fermer");
+    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+			       (GtkSignalFunc) gtk_widget_destroy,
+			       GTK_OBJECT (window));
+    
+    /* On met ce bouton en « bouton par défaut ». */
+    
+    GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
+    gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button, TRUE, TRUE, 0);
+    
+    /* Récupère le bouton par défaut. Le fait de presser la touche « Entrée »
+     * activera le bouton. */
+
+    gtk_widget_grab_default (button);
+    gtk_widget_show (button);
+    
+    gtk_widget_show (window);
+    
+    gtk_main();
+    
+    return(0);
+}
+</verb></tscreen>
+<p>
+Essayez de changer la taille de la fenêtre et faites attention aux
+réactions des barres de défilement. On peut aussi utiliser la fonction
+<em/gtk_widget_set_usize()/ pour configurer la taille par défaut de la
+fenêtre et des autres widgets.
+
+
+<sect>Widgets listes
+<p>
+Le widget <em/GtkList/ sert de container vertical pour des widgets <em/GtkListItem/.
+
+Un widget <em/GtkList/ possède sa propre fenêtre pour recevoir les
+événements et sa propre couleur de fond qui est habituellement
+blanche. Comme il est directement dérivé de <em/GtkContainer/, il peut
+être traité comme tel en utilisant la macro GTK_CONTAINER(List)&nbsp;:
+voir le widget <em/GtkContainer/ pour en savoir plus.
+
+On doit d'abord connaître l'utilisation des <em/GList/ et des
+fonctions <em/g_list_*()/ qui leur sont liées pour pouvoir utiliser
+pleinement le widget <em/GtkList/.
+
+Un champ de la structure d'un widget <em/GtkList/ nous intéresse particulièrement&nbsp;:
+
+<tscreen><verb>
+struct _GtkList
+{
+  ...
+  GList *selection;
+  guint selection_mode;
+  ...
+}; 
+</verb></tscreen>
+
+Le champ <em/selection/ d'un <em/GtkList/ pointe sur une liste chaînée
+de tous les items qui sont sélectionnés, ou vaut NULL si aucune
+sélection n'est faite. Ainsi, pour connaître la sélection courante, on
+consulte le champ <em/GTK_LIST()->selection/ mais on ne doit pas le
+modifier car ses champs internes sont gérés par les fonctions
+<em/gtk_list_*()/.
+
+Le champ <em/selection_mode/ détermine les options de sélection d'un
+<em/GtkList/ et donc le contenu du champ du
+<em/GTK_LIST()->selection/&nbsp;:
+
+<em/selection_mode/ peut avoir l'une des valeurs suivantes&nbsp;:
+<itemize>
+<item> GTK_SELECTION_SINGLE - <em/selection/ vaut NULL ou contient un
+pointeur vers un seul item sélectionné.
+
+<item> GTK_SELECTION_BROWSE - <em/selection/ vaut NULL si la liste ne
+contient aucun widget ou seulement des widgets non sensitifs. Sinon, ce
+champ contient un pointeur vers une seule structure Glist, et donc
+vers exactement un item.
+
+<item> GTK_SELECTION_MULTIPLE - <em/selection/ vaut NULL si aucun item
+n'est sélectionné ou pointe vers le premier item sélectionné. Ce
+dernier point à son tour vers le second item, etc.
+
+<item> GTK_SELECTION_EXTENDED - <em/selection/ vaut toujours NULL.
+</itemize>
+<p>
+La valeur par défaut est GTK_SELECTION_MULTIPLE.
+
+<sect1>Signaux
+<p>
+<tscreen><verb>
+void GtkList::selection_changed (GtkList *LIST)
+</verb></tscreen>
+
+Ce signal sera invoqué à chaque fois que le champ sélection d'un
+GtkList a changé. Cela arrive lorsqu'un fils d'un GtkList a été
+sélectionné ou désélectionné.
+
+<tscreen><verb>
+void GtkList::select_child (GtkList *LIST, GtkWidget *CHILD)
+</verb></tscreen>
+
+Ce signal est invoqué lorsqu'un fils du GtkList va être
+sélectionné. Ceci arrive principalement lors d'appels à
+<em/gtk_list_select_item(), gtk_list_select_child()/ et lors d'appuis
+de boutons. Quelques fois, il est indirectement déclenché lorsque des
+fils sont ajoutés ou supprimés du GtkList.
+
+<tscreen><verb>
+void GtkList::unselect_child (GtkList *LIST, GtkWidget *CHILD)
+</verb></tscreen>
+
+Ce signal est invoqué lorsqu'un fils du GtkList va être
+désélectionné. Cela arrive principalement lors d'appels à
+<em/gtk_list_unselect_item(), gtk_list_unselect_child()/, et lors
+d'appuis de boutons. Quelques fois, il est indirectement déclenché
+lorsque des fils sont ajoutés ou supprimés du GtkList.
+
+
+<sect1>Fonctions
+<p>
+<tscreen><verb>
+guint gtk_list_get_type (void)
+</verb></tscreen>
+
+Retourne l'identificateur de type « GtkList ».
+
+<tscreen><verb>
+GtkWidget* gtk_list_new (void)
+</verb></tscreen>
+
+Crée un nouvel objet « GtkList ». Le nouveau widget est retourné sous
+la forme d'un pointeur vers un objet « GtkWidget ». NULL est retourné
+en cas d'erreur.
+
+<tscreen><verb>
+void gtk_list_insert_items (GtkList *LIST, GList *ITEMS, gint POSITION)
+</verb></tscreen>
+
+Insère des items dans <em/LIST/, à partir de <em/POSITION/.
+<em/ITEMS/ est une liste doublement chaînée où chaque noeud doit
+pointer vers un nouveau <em/GtkListItem/. Les noeuds <em/GList/ de
+<em/ITEMS/ sont pris en charge par <em/LIST/.
+
+
+<tscreen><verb>
+void gtk_list_append_items (GtkList *LIST, GList *ITEMS)
+</verb></tscreen>
+
+Insère des items à la fin de <em/LIST/ selon le même principe que
+<em/gtk_list_insert_items/. Les noeuds <em/GList/ de <em/ITEMS/ sont
+pris en charge par <em/LIST/.
+
+<tscreen><verb>
+void gtk_list_prepend_items (GtkList *LIST, GList *ITEMS)
+</verb></tscreen>
+
+Insère des items au début de <em/LIST/ selon le même principe que
+<em/gtk_list_insert_items/. Les noeuds <em/GList/ de <em/ITEMS/ sont
+pris en charge par <em/LIST/.
+
+<tscreen><verb>
+void gtk_list_remove_items (GtkList *LIST, GList *ITEMS)
+</verb></tscreen>
+
+Ôte des items de <em/LIST/. <em/ITEMS/ est une liste doublement
+chaînée dont chaque noeud pointe vers un fils direct de <em/LIST/. Il
+est de la responsabilité de l'appelant de faire un appel à
+<em/g_list_free(ITEMS)/ après cela. L'appelant doit aussi détruire
+lui-même les items.
+
+<tscreen><verb>
+void gtk_list_clear_items (GtkList *LIST, gint START, gint END)
+</verb></tscreen>
+
+Ôte et détruit des items de <em/LIST/. Un widget est concerné si sa
+position courante dans <em/LIST/ est dans l'intervalle spécifié par
+<em/START/ et <em/END/.
+
+<tscreen><verb>
+void gtk_list_select_item (GtkList *LIST, gint ITEM)
+</verb></tscreen>
+
+Invoque le signal <em/GtkList::select_child/ pour un item spécifié par
+sa position courante dans <em/LIST/.
+
+<tscreen><verb>
+void gtk_list_unselect_item (GtkList *LIST, gint ITEM)
+</verb></tscreen>
+
+Invoque le signal <em/GtkList::unselect_child/ pour un item spécifié par
+sa position courante dans <em/LIST/.
+
+<tscreen><verb>
+void gtk_list_select_child (GtkList *LIST, GtkWidget *CHILD)
+</verb></tscreen>
+
+Invoque le signal <em/GtkList::select_child/ pour le fils <em/CHILD/ spécifié.
+
+<tscreen><verb>
+void gtk_list_unselect_child (GtkList *LIST, GtkWidget *CHILD)
+</verb></tscreen>
+
+Invoque le signal <em/GtkList::unselect_child/ pour le fils <em/CHILD/ spécifié.
+
+<tscreen><verb>
+gint gtk_list_child_position (GtkList *LIST, GtkWidget *CHILD)
+</verb></tscreen>
+
+Retourne la position de <em/CHILD/ dans <em/LIST/. Retourne -1 en cas d'erreur.
+
+<tscreen><verb>
+void gtk_list_set_selection_mode (GtkList *LIST, GtkSelectionMode MODE)
+</verb></tscreen>
+
+Configure <em/LIST/ dans le mode de sélection <em/MODE/ qui peut être
+GTK_SELECTION_SINGLE, GTK_SELECTION_BROWSE, GTK_SELECTION_MULTIPLE ou
+GTK_SELECTION_EXTENDED.
+
+<tscreen><verb>
+GtkList* GTK_LIST (gpointer OBJ)
+</verb></tscreen>
+
+Convertit un pointeur générique en « <\em GtkList*\ ». Voir
+<em/Standard Macros::/, pour plus d'informations.
+
+<tscreen><verb>
+GtkListClass* GTK_LIST_CLASS (gpointer CLASS)
+</verb></tscreen>
+
+Convertit un pointeur générique en « GtkListClass* ».  Voir
+<em/Standard Macros::/, pour plus d'informations.
+
+<tscreen><verb>
+gint GTK_IS_LIST (gpointer OBJ)
+</verb></tscreen>
+
+Détermine si un pointeur générique référence un objet « GtkList ». Voir
+<em/Standard Macros::/, pour plus d'informations.
+
+<sect1>Exemple
+<p>
+Voici un programme affichant les changements de sélection dans une
+<em/GtkList/ et permettant d'« emprisonner » des items en les
+sélectionnant avec le bouton droit de la souris.
+
+<tscreen><verb>
+/* Compilez ce programme avec :
+ * $ gcc -L/usr/X11R6/lib/ -I/usr/local/include/ -lgtk -lgdk -lglib -lX11 -lm -Wall main.c
+ */
+#include        <gtk/gtk.h>
+#include        <stdio.h>
+
+/* Chaîne pour stocker les données dans les items de la liste. */
+
+const   gchar   *list_item_data_key="list_item_data";
+
+
+/* prototypes des gestionnaires de signaux que l'on connectera au widget GtkList. */
+
+static  void    sigh_print_selection    (GtkWidget      *gtklist,
+                                         gpointer       func_data);
+static  void    sigh_button_event       (GtkWidget      *gtklist,
+                                         GdkEventButton *event,
+                                         GtkWidget      *frame);
+
+
+/* fonction principale pour configurer l'interface utilisateur */
+
+gint main (int argc, gchar *argv[])
+{                                  
+    GtkWidget       *separator;
+    GtkWidget       *window;
+    GtkWidget       *vbox;
+    GtkWidget       *scrolled_window;
+    GtkWidget       *frame;
+    GtkWidget       *gtklist;
+    GtkWidget       *button;
+    GtkWidget       *list_item;
+    GList           *dlist;
+    guint           i;
+    gchar           buffer[64];
+    
+    
+    /* initialise gtk (et donc gdk) */
+
+    gtk_init(&amp;argc, &amp;argv);
+    
+    
+    /* Création d'une fenêtre pour placer tous les widgets.
+     * Connexion de  gtk_main_quit() à l'événement "destroy" de
+     * la fenêtre afin de prendre en charge les événements « fermeture d'une
+     * fenêtre » du gestionnaire de fenêtre. */
+
+    window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
+    gtk_window_set_title(GTK_WINDOW(window), "Exemple de widget GtkList");
+    gtk_signal_connect(GTK_OBJECT(window),
+		       "destroy",
+		       GTK_SIGNAL_FUNC(gtk_main_quit),
+		       NULL);
+    
+    
+    /* À l'intérieur de la fenêtre, on a besoin d'une boîte pour placer 
+     * verticalement les widgets. */
+
+    vbox=gtk_vbox_new(FALSE, 5);
+    gtk_container_border_width(GTK_CONTAINER(vbox), 5);
+    gtk_container_add(GTK_CONTAINER(window), vbox);
+    gtk_widget_show(vbox);
+    
+    /* Fenêtre à défilement pour placer le widget GtkList à l'intérieur. */
+
+    scrolled_window=gtk_scrolled_window_new(NULL, NULL);
+    gtk_widget_set_usize(scrolled_window, 250, 150);
+    gtk_container_add(GTK_CONTAINER(vbox), scrolled_window);
+    gtk_widget_show(scrolled_window);
+    
+    /* Création du widget GtkList
+     * Connexion du gestionnaire de signal sigh_print_selection() au signal
+     * "selection_changed" du GtkList pour afficher les items sélectionnés
+     * à chaque fois que la sélection change. */
+
+    gtklist=gtk_list_new();
+    gtk_container_add(GTK_CONTAINER(scrolled_window), gtklist);
+    gtk_widget_show(gtklist);
+    gtk_signal_connect(GTK_OBJECT(gtklist),
+		       "selection_changed",
+		       GTK_SIGNAL_FUNC(sigh_print_selection),
+		       NULL);
+    
+    /* Création d'une « Prison » pour y mettre un item. */
+
+    frame=gtk_frame_new("Prison");
+    gtk_widget_set_usize(frame, 200, 50);
+    gtk_container_border_width(GTK_CONTAINER(frame), 5);
+    gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_OUT);
+    gtk_container_add(GTK_CONTAINER(vbox), frame);
+    gtk_widget_show(frame);
+    
+    /* Connexion du gestionnaire de signal sigh_button_event() au signal
+     * « mise au arrêts » des items du GtkList. */
+
+    gtk_signal_connect(GTK_OBJECT(gtklist),
+		       "button_release_event",
+		       GTK_SIGNAL_FUNC(sigh_button_event),
+		       frame);
+    
+    /* Création d'un séparateur. */
+
+    separator=gtk_hseparator_new();
+    gtk_container_add(GTK_CONTAINER(vbox), separator);
+    gtk_widget_show(separator);
+    
+    /* Création d'un bouton et connexion de son signal "clicked" à la
+     * destruction de la fenêtre. */
+
+    button=gtk_button_new_with_label("Fermeture");
+    gtk_container_add(GTK_CONTAINER(vbox), button);
+    gtk_widget_show(button);
+    gtk_signal_connect_object(GTK_OBJECT(button),
+			      "clicked",
+			      GTK_SIGNAL_FUNC(gtk_widget_destroy),
+			      GTK_OBJECT(window));
+    
+    
+    /* Création de 5 items, chacun ayant son propre label.
+     * Ajout de ceux-ci au GtkList en utilisant gtk_container_add().
+     * On interroge le texte du label et on l'associe avec
+     * list_item_data_key à chaque item. */
+    
+    for (i=0; i<5; i++) {
+	GtkWidget       *label;
+	gchar           *string;
+	
+	sprintf(buffer, "ListItemContainer avec Label #%d", i);
+	label=gtk_label_new(buffer);
+	list_item=gtk_list_item_new();
+	gtk_container_add(GTK_CONTAINER(list_item), label);
+	gtk_widget_show(label);
+	gtk_container_add(GTK_CONTAINER(gtklist), list_item);
+	gtk_widget_show(list_item);
+	gtk_label_get(GTK_LABEL(label), &amp;string);
+	gtk_object_set_data(GTK_OBJECT(list_item),
+			    list_item_data_key,
+			    string);
+    }
+    /* Création de 5 autres labels. Cette fois-ci, on utilise
+     * gtk_list_item_new_with_label(). On ne peut interroger la chaîne
+     * des labels car on n'a pas les pointeurs de labels et on associe
+     * donc simplement le list_item_data_key de chaque item ayant la même 
+     * chaîne de texte pour l'ajouter au items que l'on place dans une liste
+     * doublement chaînée (GList). On les ajoute alors par un simple appel à
+     * gtk_list_append_items().
+     * Comme on utilise g_list_prepend() pour mettre les items dans la liste
+     * doublement chaînée, leur ordre sera décroissant (au lieu d'être croissant si
+     * on utilisait g_list_append()). */
+     
+    dlist=NULL;
+    for (; i<10; i++) {
+	sprintf(buffer, "Item avec le label %d", i);
+	list_item=gtk_list_item_new_with_label(buffer);
+	dlist=g_list_prepend(dlist, list_item);
+	gtk_widget_show(list_item);
+	gtk_object_set_data(GTK_OBJECT(list_item),
+			    list_item_data_key,
+			    "Item avec label intégré");
+    }
+    gtk_list_append_items(GTK_LIST(gtklist), dlist);
+    
+    /* Enfin, on veut voir la fenêtre... */
+    
+    gtk_widget_show(window);
+    
+    /* Lancement de la boucle principale de gtk */
+    
+    gtk_main();
+    
+    /* On arrive ici après que gtk_main_quit() ait été appelée lorsque
+     * la fenêtre principale a été détruite. */
+
+}
+
+/* Gestionnaire de signal connecté aux événements boutons presser/relâcher
+ * du GtkList. */
+
+void
+sigh_button_event       (GtkWidget      *gtklist,
+                         GdkEventButton *event,
+                         GtkWidget      *frame)
+{
+    /* On ne fait quelque chose que si le troisième bouton (celui de droite) a été
+     * relâché. */
+
+    if (event->type==GDK_BUTTON_RELEASE &amp;&amp;
+	event->button==3) {
+	GList           *dlist, *free_list;
+	GtkWidget       *new_prisoner;
+	
+	/* On recherche l'item sélectionné à ce moment précis. 
+         * Ce sera notre prisonnier ! */
+
+	dlist=GTK_LIST(gtklist)->selection;
+	if (dlist)
+		new_prisoner=GTK_WIDGET(dlist->data);
+	else
+		new_prisoner=NULL;
+	
+	/* On recherche les items déjà prisonniers et on les
+         * remet dans la liste.
+	 * Il ne faut pas oublier de libérer la liste doublement
+         * chaînée que gtk_container_children() retourne. */
+	
+	dlist=gtk_container_children(GTK_CONTAINER(frame));
+	free_list=dlist;
+	while (dlist) {
+	    GtkWidget       *list_item;
+	    
+	    list_item=dlist->data;
+	    
+	    gtk_widget_reparent(list_item, gtklist);
+	    
+	    dlist=dlist->next;
+	}
+	g_list_free(free_list);
+	
+	/* Si l'on a un nouveau prisonnier, on l'ôte du GtkList et on le place
+         * dans le cadre « Prison ». On doit désélectionner l'item avant.
+
+	if (new_prisoner) {
+	    GList   static_dlist;
+	    
+	    static_dlist.data=new_prisoner;
+	    static_dlist.next=NULL;
+	    static_dlist.prev=NULL;
+	    
+	    gtk_list_unselect_child(GTK_LIST(gtklist),
+				    new_prisoner);
+	    gtk_widget_reparent(new_prisoner, frame);
+	}
+    }
+}
+
+/* Gestionnaire de signal appelé lorsque le GtkList
+ * émet le signal "selection_changed". */
+
+void
+sigh_print_selection    (GtkWidget      *gtklist,
+                         gpointer       func_data)
+{
+    GList   *dlist;
+    
+    /* Recherche dans la liste doublement chaînée des items sélectionnés
+     * du GtkList, à faire en lecture seulement ! */
+
+    dlist=GTK_LIST(gtklist)->selection;
+    
+    /* S'il n'y a pas d'items sélectionné, il n'y a rien d'autre à faire que
+     * de le dire à l'utilisateur. */
+
+    if (!dlist) {
+	g_print("Sélection nettoyée\n");
+	return;
+    }
+    /* Ok, on a une sélection et on l'affiche. */
+
+    g_print("La sélection est ");
+    
+    /* On récupère l'item dans la liste doublement chaînée 
+     * puis on interroge la donnée associée par list_item_data_key
+     * et on l'affiche. */
+
+    while (dlist) {
+	GtkObject       *list_item;
+	gchar           *item_data_string;
+	
+	list_item=GTK_OBJECT(dlist->data);
+	item_data_string=gtk_object_get_data(list_item,
+					     list_item_data_key);
+	g_print("%s ", item_data_string);
+	
+	dlist=dlist->next;
+    }
+    g_print("\n");
+}
+</verb></tscreen>
+
+<sect1>Widget item de liste
+<p>
+Le widget <em/GtkListItem/ sert de container pour contenir un fils,
+lui fournissant des fonctions de sélection/déséselection exactement
+comme le widget GtkList les demande pour ses fils.
+
+Un <em/GtkListItem/ a sa propre fenêtre pour recevoir les événements et a
+sa propre couleur de fond, habituellement blanche.
+
+Comme il est directement dérivé d'un <em/GtkItem/, il peut être traité
+comme tel en utilisant la macro GTK_ITEM(ListItem), reportez-vous à la
+section sur le widget GtkItem pour plus de détail sur celui-ci.
+Habituellement, un <em/GtkListItem/ contient juste un label pour
+identifier, par exemple, un nom de fichier dans un <em/GtkList/ -- la
+fonction appropriée <em/gtk_list_item_new_with_label()/ est donc
+fournie. Le même effet peut être obtenu en créant un <em/GtkLabel/ à
+part, en configurant son alignement avec <em/xalign/=0 et
+<em/yalign/=0.5 suivi d'un ajout ultérieur au <em/GtkListItem/.
+
+Tout comme on n'est pas forcé d'ajouter un <em/GtkLabel/ à un
+<em/GtkListItem/, on peut aussi ajouter un <em/GtkVBox/ ou un
+<em/GtkArrow/ etc. à un <em/GtkListItem/.
+
+<sect1>Signaux
+<p>
+Un <em/GtkListItem/ ne crée pas de nouveaux signaux par lui-même, mais
+hérite de ceux d'un <em/GtkItem/. Voir <em/GtkItem::/, pour plus
+d'informations.
+
+
+<sect1>Fonctions
+<p>
+
+<tscreen><verb>
+guint gtk_list_item_get_type (void)
+</verb></tscreen>
+
+Retourne l'identificateur du type « GtkListItem ».
+
+<tscreen><verb>
+GtkWidget* gtk_list_item_new (void)
+</verb></tscreen>
+
+Création d'un objet <em/GtkListItem/. Le nouveau widget est retourné
+sous la forme d'un pointeur vers un objet <em/GtkWidget/. NULL est
+retourné en cas d'erreur.
+
+<tscreen><verb>
+GtkWidget* gtk_list_item_new_with_label (gchar *LABEL)
+</verb></tscreen>
+
+Création d'un objet <em/GtkListItem/ ayant un simple <em/GtkLabel/
+comme seul fils. Le nouveau widget est retourné sous la forme d'un
+pointeur vers un objet <em/GtkWidget/. NULL est retourné en cas
+d'erreur.
+
+<tscreen><verb>
+void gtk_list_item_select (GtkListItem *LIST_ITEM)
+</verb></tscreen>
+
+Cette fonction est surtout un emballage de <em/gtk_item_select
+(GTK_ITEM (list_item))/ qui émettra le signal <em/GtkItem::select/.
+Voir <em/GtkItem::/, pour plus d'informations.
+
+<tscreen><verb>
+void gtk_list_item_deselect (GtkListItem *LIST_ITEM)
+</verb></tscreen>
+
+Cette fonction est surtout un emballage de <em/gtk_item_deselect
+(GTK_ITEM (list_item))/ qui émettra le signal
+<em/GtkItem::deselect/. Voir <em/GtkItem::/, pour plus d'informations.
+
+<tscreen><verb>
+GtkListItem* GTK_LIST_ITEM (gpointer OBJ)
+</verb></tscreen>
+
+Convertit un pointeur générique en <em/GtkListItem*/. Voir
+<em/Standard Macros::/ pour plus d'informations.
+
+<tscreen><verb>
+GtkListItemClass* GTK_LIST_ITEM_CLASS (gpointer CLASS)
+</verb></tscreen>
+
+Convertit un pointeur générique en <em/GtkListItemClass*/. Voir
+<em/Standard Macros::/ pour plus d'informations.
+
+<tscreen><verb>
+gint GTK_IS_LIST_ITEM (gpointer OBJ)
+</verb></tscreen>
+
+Détermine si un pointeur générique se réfère à un objet
+<em/GtkListItem/.  Voir <em/Standard Macros::/ pour plus
+d'informations.
+ 
+<sect1>Exemple
+<p>
+L'exemple des GtkList couvre aussi l'utilisation des 
+GtkListItem. Étudiez-le attentivement.
+
+
+<sect>Widgets sélections de fichiers
+<p>
+Le widget sélection de fichier est un moyen simple et rapide pour
+afficher un fichier dans une boîte de dialogue. Il est complet, avec
+des boutons Ok, Annuler et Aide. C'est un bon moyen de raccourcir les
+temps de programmation.
+
+Pour créer une boîte de sélection de fichier, on utilise&nbsp;:
+
+<tscreen><verb>
+GtkWidget* gtk_file_selection_new (gchar *title);
+</verb></tscreen>
+
+Pour configurer le nom de fichier, par exemple pour aller dans un
+répertoire précis ou donner un nom de fichier par défaut, on utilise
+la fonction&nbsp;:
+
+<tscreen><verb>
+void gtk_file_selection_set_filename (GtkFileSelection *filesel, gchar *filename);
+</verb></tscreen>
+
+Pour récupérer le texte que l'utilisateur a entré, ou sur lequel il a
+cliqué, on utilisera la fonction&nbsp;:
+
+<tscreen><verb>
+gchar* gtk_file_selection_get_filename (GtkFileSelection *filesel);
+</verb></tscreen>
+
+Des pointeurs permettent d'accéder aux widgets contenus dans la widget
+de sélection de fichiers. Ce sont&nbsp;:
+
+<itemize>
+<item>dir_list
+<item>file_list
+<item>selection_entry
+<item>selection_text
+<item>main_vbox
+<item>ok_button
+<item>cancel_button
+<item>help_button
+</itemize>
+
+Le plus souvent, on utilise les pointeurs <em/ok_button, cancel_button/, et
+<em/help_button/ pour préciser leurs utilisations.
+
+Voici un exemple emprunté à <em/testgtk.c/ et modifié pour fonctionner
+tout seul. Comme vous le verrez, il n'y a pas grand chose à faire pour
+créer un wigdget de sélection de fichier. Cependant, dans cet exemple,
+si le bouton Aide apparaît à l'écran, il ne fait rien car aucun signal
+ne lui est attaché.
+
+<tscreen><verb>
+#include <gtk/gtk.h>
+
+/* Récupère le nom de fichier sélectionné et l'affiche sur la console. */
+
+void file_ok_sel (GtkWidget *w, GtkFileSelection *fs)
+{
+    g_print ("%s\n", gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs)));
+}
+
+void destroy (GtkWidget *widget, gpointer *data)
+{
+    gtk_main_quit ();
+}
+
+int main (int argc, char *argv[])
+{
+    GtkWidget *filew;
+    
+    gtk_init (&amp;argc, &amp;argv);
+    
+    /* Création d'un widget de sélection de fichier. */
+
+    filew = gtk_file_selection_new ("File selection");
+    
+    gtk_signal_connect (GTK_OBJECT (filew), "destroy",
+			(GtkSignalFunc) destroy, &amp;filew);
+
+    /* Connexion de ok_button à la fonction file_ok_sel() */
+
+    gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (filew)->ok_button),
+			"clicked", (GtkSignalFunc) file_ok_sel, filew );
+    
+    /* Connexion de cancel_button pour détruire le widget */
+
+    gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (filew)->cancel_button),
+			       "clicked", (GtkSignalFunc) gtk_widget_destroy,
+			       GTK_OBJECT (filew));
+    
+    /* Configuration du nom de fichier, comme s'il s'agissait d'un dialogue de
+     * sauvegarde et que nous donnions un nom de fichier par défaut. */
+
+    gtk_file_selection_set_filename (GTK_FILE_SELECTION(filew), 
+				     "penguin.png");
+    
+    gtk_widget_show(filew);
+    gtk_main ();
+    return 0;
+}
+</verb></tscreen>
+
+<sect>Widgets Menu
+<p>
+Il y a deux façons de créer des menus, la facile et la compliquée. Les
+deux ont leur utilité, mais on peut généralement utiliser l'<em/usine
+à menus/ (c'est la méthode facile...). La méthode « compliquée »
+consiste à créer tous les menus en utilisant directement les
+appels. La méthode facile consiste à utiliser les appels
+<em/gtk_menu_factory/. C'est beaucoup plus simple, mais chaque
+approche a ses avantages et inconvénients.
+
+L'usine à menus est beaucoup plus facile à utiliser, elle facilite
+aussi l'ajout d'autres menus. Par contre, écrire quelques fonctions
+permettant de créer des menus en utilisant la méthode manuelle peut
+être le début d'un long chemin avant une quelconque utilisation. Avec
+l'usine à menus, il n'est pas possible d'ajouter des images ou des « /
+» aux menus.
+<p>
+<sect1>Création manuelle de menus
+<p>
+Selon la tradition pédagogique, nous commencerons par le plus compliqué <tt/:)/
+<p>
+Regardons les fonctions utilisées pour créer les menus. La première sert à créer un nouveau menu.
+
+<tscreen><verb>
+GtkWidget *gtk_menu_bar_new()
+</verb></tscreen>
+
+Cette fonction crée une nouvelle barre de menu. On utilise la fonction
+<em/gtk_container_add/ pour la placer dans une fenêtre, ou les
+fonctions <em/box_pack/ pour la placer dans une boîte - la même que
+pour les boutons.
+
+<tscreen><verb>
+GtkWidget *gtk_menu_new();
+</verb></tscreen>
+
+Cette fonction retourne un pointeur vers un nouveau menu, il n'est
+jamais montré (avec <em/gtk_widget_show/), il ne fait que contenir les
+items du menu. Ceci deviendra plus clair lorsque nous étudierons
+l'exemple ci-dessous.
+<p>
+Les deux appels suivants servent à créer des items de menu qui seront
+placés dans le menu.
+
+<tscreen><verb>
+GtkWidget *gtk_menu_item_new()
+</verb></tscreen>
+
+et
+
+<tscreen><verb>
+GtkWidget *gtk_menu_item_new_with_label(const char *label)
+</verb></tscreen>
+
+Ces appels servent à créer les menus qui doivent être affichés. On
+doit bien faire la différence entre un « menu » qui est créé avec
+<em/gtk_menu_new()/ et un « item de menu » créé avec les fonctions
+<em/gtk_menu_item_new()/. L'item de menu sera un véritable bouton avec
+une action associée alors qu'un menu sera un container contenant les
+items.
+
+
+<tscreen><verb>
+gtk_menu_item_append()
+
+gtk_menu_item_set_submenu()
+</verb></tscreen>
+
+Les fonctions <em/gtk_menu_new_with_label()/ et <em/gtk_menu_new()/
+sont telles que vous les attendiez après avoir étudié les
+boutons. L'une crée un nouvel item de menu contenant déjà un label, et
+l'autre ne fait que créer un item de menu vide.
+<p>
+Voici les étapes pour créer une barre de menu avec des menus attachés&nbsp;:
+<itemize>
+<item>Créer un nouveau menu avec <em/gtk_menu_new()/ <item>Créer un
+item de menu avec <em/gtk_menu_item_new()/.  Ce sera la racine du
+menu, le texte apparaissant ici sera aussi sur la barre de menu.
+<item>Utiliser plusieurs appels à <em/gtk_menu_item_new()/ pour
+chaque item que l'on désire dans le menu. Utiliser
+<em/gtk_menu_item_append()/ pour placer chacun de ces items les uns
+après les autres. Cela crée une liste d'items de menu.
+<item>Utiliser <em/gtk_menu_item_set_submenu()/ pour attacher les
+items de menus nouvellement créés à l'item de menu racine (celui créé
+à la seconde étape).
+<item>Créer une nouvelle barre de menu avec
+<em/gtk_menu_bar_new()/. Cette étape ne doit être faite qu'une fois
+lorsque l'on crée une série de menu sur une seule barre de menus.
+<item>Utiliser <em/gtk_menu_bar_append()/ pour placer le menu racine
+dans la barre de menu.
+</itemize>
+<p>
+La création d'un menu surgissant est presque identique. La différence
+est que le menu n'est pas posté « automatiquement » par une barre de
+menu, mais explicitement en appelant la fonction <em/gtk_menu_popup()/
+par un événement « bouton pressé ».
+
+Suivez ces étapes&nbsp;
+<itemize>
+<item>Créer une fonction de gestion d'événement. Elle doit avoir le prototype
+<tscreen>
+static gint handler(GtkWidget *widget, GdkEvent *event);
+</tscreen>
+et elle utilisera l'événement <em/event/ pour savoir où faire surgir
+le menu.  
+<item>Ce gestionnaire, si l'événement est un appui sur un
+bouton souris, traite <em/event/ comme un événement bouton (ce qu'il
+est) et l'utilise, de la façon indiquée dans le code d'exemple, pour
+passer l'information à <em/gtk_menu_popup()/.
+
+<item> Lier ce gestionnaire à un widget avec&nbsp;:
+<tscreen>
+gtk_signal_connect_object(GTK_OBJECT(widget), "event",
+                          GTK_SIGNAL_FUNC (handler), GTK_OBJECT(menu));
+</tscreen>
+où <em/widget/ est le widget auquel vous le liez, <em/handler/ est
+le gestionnaire, et <em/menu/ est un menu créé avec
+<em/gtk_menu_new()/. Cela peut être un menu qui est aussi posté par
+une barre de menu, comme le montre l'exemple.
+</itemize>
+<p>
+<sect1>Exemple de menu manuel
+<p>
+<tscreen><verb>
+
+#include <gtk/gtk.h>
+
+static gint button_press (GtkWidget *, GdkEvent *);
+static void menuitem_response (GtkWidget *, gchar *);
+
+
+int main (int argc, char *argv[])
+{
+
+    GtkWidget *window;
+    GtkWidget *menu;
+    GtkWidget *menu_bar;
+    GtkWidget *root_menu;
+    GtkWidget *menu_items;
+    GtkWidget *vbox;
+    GtkWidget *button;
+    char buf[128];
+    int i;
+
+    gtk_init (&amp;argc, &amp;argv);
+
+    /* Création d'un fenêtre */
+
+    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+    gtk_window_set_title(GTK_WINDOW (window), "Test de Menu GTK");
+    gtk_signal_connect(GTK_OBJECT (window), "delete_event",
+                       (GtkSignalFunc) gtk_exit, NULL);
+
+    /* Initialise le widget menu -- Attention : n'appelez jamais 
+     * gtk_show_widget() pour le widget menu !!!
+     * C'est le menu qui contient les items de menu, celui qui surgira 
+     * lorsque vous cliquez sur le « menu racine » de l'application. */
+
+    menu = gtk_menu_new();
+
+    /* Voici le menu racine dont le label sera le nom du menu affiché sur la barre
+     * de menu. Il n'a pas de gestionnaire de signal attaché car il ne fait 
+     * qu'afficher le reste du menu lorsqu'il est pressé. */
+
+    root_menu = gtk_menu_item_new_with_label("Menu racine");
+
+    gtk_widget_show(root_menu);
+
+    /* Puis, on crée une petite boucle créant trois entrées pour « menu test »
+     * Notez l'appel à gtk_menu_append(). Ici, on ajoute une liste d'items à
+     * notre menu. Normalement, on devrait aussi capturer le signal "clicked" 
+     * pour chacun des items et configurer une fonction de rappel pour lui, 
+     * mais on l'a omis ici pour gagner de la place. */
+
+    for(i = 0; i < 3; i++)
+        {
+            /* Copie des noms dans buf. */
+
+            sprintf(buf, "Sous-menu Test - %d", i);
+
+            /* Création d'un nouveau item de menu avec un nom... */
+
+            menu_items = gtk_menu_item_new_with_label(buf);
+
+            /* ...et ajout de celui-ci dans le menu. */
+
+            gtk_menu_append(GTK_MENU (menu), menu_items);
+
+	    /* On fait quelque chose d'intéressant lorsque l'item est
+             * sélectionné. */
+
+            gtk_signal_connect (GTK_OBJECT(menu_items), "activate",
+                GTK_SIGNAL_FUNC(menuitem_response), (gpointer)
+	        g_strdup(buf));
+		      
+            /* Affichage du widget. */
+
+            gtk_widget_show(menu_items);
+        }
+
+    /* Maintenant, on spécifié que nous voulons que notre nouveau « menu »
+     * soit le menu du « menu racine ». */
+
+    gtk_menu_item_set_submenu(GTK_MENU_ITEM (root_menu), menu);
+
+    /* Création d'une vbox pour y mettre un menu et un bouton. */
+
+    vbox = gtk_vbox_new(FALSE, 0);
+    gtk_container_add(GTK_CONTAINER(window), vbox);
+    gtk_widget_show(vbox);
+
+    /* Création d'une barre de menus pour contenir les menus. Puis, on
+     * l'ajoute à notre fenêtre principale. */
+
+    menu_bar = gtk_menu_bar_new();
+    gtk_box_pack_start(GTK_BOX(vbox), menu_bar, FALSE, FALSE, 2);
+    gtk_widget_show(menu_bar);
+
+    /* Création d'un bouton pour y attacher le menu. */
+
+    button = gtk_button_new_with_label("Pressez moi");
+    gtk_signal_connect_object(GTK_OBJECT(button), "event",
+	GTK_SIGNAL_FUNC (button_press), GTK_OBJECT(menu));
+    gtk_box_pack_end(GTK_BOX(vbox), button, TRUE, TRUE, 2);
+    gtk_widget_show(button);
+
+    /* Finalement, on ajoute l'item de menu à la barre de menu --
+     * c'est l'item de menu racine sur lequel je me suis déchaîné ;-) */
+
+    gtk_menu_bar_append(GTK_MENU_BAR (menu_bar), root_menu);
+
+    /* Affichage de la fenêtre. */
+
+    gtk_widget_show(window);
+
+    gtk_main ();
+
+    return 0;
+}
+
+
+
+/* On répond à un appui sur le bouton en postant un nouveau menu passé comme 
+ * un widget.
+ *
+ * On remarque que le paramètre "widget" est le menu à poster, PAS le bouton
+ * qui a été pressé. */
+
+
+static gint button_press (GtkWidget *widget, GdkEvent *event)
+{
+
+    if (event->type == GDK_BUTTON_PRESS) {
+        GdkEventButton *bevent = (GdkEventButton *) event; 
+        gtk_menu_popup (GTK_MENU(widget), NULL, NULL, NULL, NULL,
+                        bevent->button, bevent->time);
+
+        /* On indique à l'appelant que l'on a géré cet événement. */
+
+        return TRUE;
+    }
+
+    /* On indique à l'appelant que l'on n'a pas géré cet événement. */
+
+    return FALSE;
+}
+
+
+/* Affiche une chaîne lorsqu'un item de menu est choisi. */
+
+static void menuitem_response (GtkWidget *widget, gchar *string)
+{
+    printf("%s\n", string);
+}
+</verb></tscreen>
+
+Vous pouvez aussi configurer un item de menu pour qu'il ne soit pas
+sélectionnable et, en utilisant une table de raccourcis clavier, lier
+des touches aux fonctions du menu.
+<p>
+<sect1>Utilisation de GtkMenuFactory
+<p>
+Maintenant que nous avons exploré la voie difficile, nous allons voir
+l'utilisation des appels <em/gtk_menu_factory./
+<p>
+<sect1>Exemple d'usine à menu
+<p>
+Voici un exemple utilisant l'usine à menu de GTK. Le premier
+fichier est <em/menus.h/.  Nous séparerons <em/menus.c/ et <em/main.c/ à
+cause des variables globales utilisées dans le fichier <em/menus.c/.
+
+<tscreen><verb>
+#ifndef __MENUS_H__
+#define __MENUS_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+void get_main_menu (GtkWidget **menubar, GtkAcceleratorTable **table);
+void menus_create(GtkMenuEntry *entries, int nmenu_entries);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __MENUS_H__ */
+</verb></tscreen>
+<p>
+Voici le fichier <em/menus.c/&nbsp;:
+
+<tscreen><verb>
+
+#include <gtk/gtk.h>
+#include <strings.h>
+
+#include "main.h"
+
+
+static void menus_remove_accel(GtkWidget * widget, gchar * signal_name, gchar * path);
+static gint menus_install_accel(GtkWidget * widget, gchar * signal_name, gchar key, gchar modifiers, gchar * path);
+void menus_init(void);
+void menus_create(GtkMenuEntry * entries, int nmenu_entries);
+
+
+/* Structure GtkMenuEntry utilisée pour créer les menus. Le premier champ 
+ * est la chaîne de définition du menu. Le second, la touche de raccourci 
+ * utilisée pour accéder à cette fonction du menu avec le clavier. 
+ * Le troisième est la fonction de rappel à utiliser lorsque l'item de menu 
+ * est choisi (par la touche de raccourci ou avec la souris). Le dernier 
+ * élément est la donnée à passer à la fonction de rappel. */
+ 
+
+static GtkMenuEntry menu_items[] =
+{
+	{"<Main>/Fichier/Nouveau", "<control>N", NULL, NULL},
+	{"<Main>/Fichier/Ouvrir", "<control>O", NULL, NULL},
+	{"<Main>/Fichier/Sauver", "<control>S", NULL, NULL},
+	{"<Main>/Fichier/Sauver sous", NULL, NULL, NULL},
+	{"<Main>/Fichier/<separator>", NULL, NULL, NULL},
+	{"<Main>/Fichier/Quitter", "<control>Q", file_quit_cmd_callback, "OK, c'est fini"},
+	{"<Main>/Options/Test", NULL, NULL, NULL}
+};
+
+/* Calcul du nombre d'éléments de menu_item */
+
+static int nmenu_items = sizeof(menu_items) / sizeof(menu_items[0]);
+
+static int initialize = TRUE;
+static GtkMenuFactory *factory = NULL;
+static GtkMenuFactory *subfactory[1];
+static GHashTable *entry_ht = NULL;
+
+void get_main_menu(GtkWidget ** menubar, GtkAcceleratorTable ** table)
+{
+    if (initialize)
+	    menus_init();
+    
+    if (menubar)
+	    *menubar = subfactory[0]->widget;
+    if (table)
+	    *table = subfactory[0]->table;
+}
+
+void menus_init(void)
+{
+    if (initialize) {
+	initialize = FALSE;
+	
+	factory = gtk_menu_factory_new(GTK_MENU_FACTORY_MENU_BAR);
+	subfactory[0] = gtk_menu_factory_new(GTK_MENU_FACTORY_MENU_BAR);
+	
+	gtk_menu_factory_add_subfactory(factory, subfactory[0], "<Main>");
+	menus_create(menu_items, nmenu_items);
+    }
+}
+
+void menus_create(GtkMenuEntry * entries, int nmenu_entries)
+{
+    char *accelerator;
+    int i;
+    
+    if (initialize)
+	    menus_init();
+    
+    if (entry_ht)
+	    for (i = 0; i < nmenu_entries; i++) {
+		accelerator = g_hash_table_lookup(entry_ht, entries[i].path);
+		if (accelerator) {
+		    if (accelerator[0] == '\0')
+			    entries[i].accelerator = NULL;
+		    else
+			    entries[i].accelerator = accelerator;
+		}
+	    }
+    gtk_menu_factory_add_entries(factory, entries, nmenu_entries);
+    
+    for (i = 0; i < nmenu_entries; i++)
+	    if (entries[i].widget) {
+		gtk_signal_connect(GTK_OBJECT(entries[i].widget), "install_accelerator",
+				   (GtkSignalFunc) menus_install_accel,
+				   entries[i].path);
+		gtk_signal_connect(GTK_OBJECT(entries[i].widget), "remove_accelerator",
+				   (GtkSignalFunc) menus_remove_accel,
+				   entries[i].path);
+	    }
+}
+
+static gint menus_install_accel(GtkWidget * widget, gchar * signal_name, gchar key, gchar modifiers, gchar * path)
+{
+    char accel[64];
+    char *t1, t2[2];
+    
+    accel[0] = '\0';
+    if (modifiers & GDK_CONTROL_MASK)
+	    strcat(accel, "<control>");
+    if (modifiers & GDK_SHIFT_MASK)
+	    strcat(accel, "<shift>");
+    if (modifiers & GDK_MOD1_MASK)
+	    strcat(accel, "<alt>");
+    
+    t2[0] = key;
+    t2[1] = '\0';
+    strcat(accel, t2);
+    
+    if (entry_ht) {
+	t1 = g_hash_table_lookup(entry_ht, path);
+	g_free(t1);
+    } else
+	    entry_ht = g_hash_table_new(g_string_hash, g_string_equal);
+    
+    g_hash_table_insert(entry_ht, path, g_strdup(accel));
+    
+    return TRUE;
+}
+
+static void menus_remove_accel(GtkWidget * widget, gchar * signal_name, gchar * path)
+{
+    char *t;
+    
+    if (entry_ht) {
+	t = g_hash_table_lookup(entry_ht, path);
+	g_free(t);
+	
+	g_hash_table_insert(entry_ht, path, g_strdup(""));
+    }
+}
+
+void menus_set_sensitive(char *path, int sensitive)
+{
+    GtkMenuPath *menu_path;
+    
+    if (initialize)
+	    menus_init();
+    
+    menu_path = gtk_menu_factory_find(factory, path);
+    if (menu_path)
+	    gtk_widget_set_sensitive(menu_path->widget, sensitive);
+    else
+	    g_warning("Impossible de configurer la sensitivité d'un menu qui n'existe pas : %s", path);
+}
+
+</verb></tscreen>
+<p>
+Voici <em/main.h/&nbsp;:
+
+<tscreen><verb>
+#ifndef __MAIN_H__
+#define __MAIN_H__
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+void file_quit_cmd_callback(GtkWidget *widget, gpointer data);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __MAIN_H__ */
+
+</verb></tscreen>
+<p>
+Et, enfin, <em/main.c/&nbsp;:
+
+<tscreen><verb>
+#include <gtk/gtk.h>
+
+#include "main.h"
+#include "menus.h"
+
+
+int main(int argc, char *argv[])
+{
+    GtkWidget *window;
+    GtkWidget *main_vbox;
+    GtkWidget *menubar;
+    
+    GtkAcceleratorTable *accel;
+    
+    gtk_init(&amp;argc, &amp;argv);
+    
+    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+    gtk_signal_connect(GTK_OBJECT(window), "destroy", 
+		       GTK_SIGNAL_FUNC(file_quit_cmd_callback), 
+		       "WM destroy");
+    gtk_window_set_title(GTK_WINDOW(window), "Usine à menu");
+    gtk_widget_set_usize(GTK_WIDGET(window), 300, 200);
+    
+    main_vbox = gtk_vbox_new(FALSE, 1);
+    gtk_container_border_width(GTK_CONTAINER(main_vbox), 1);
+    gtk_container_add(GTK_CONTAINER(window), main_vbox);
+    gtk_widget_show(main_vbox);
+    
+    get_main_menu(&amp;menubar, &amp;accel);
+    gtk_window_add_accelerator_table(GTK_WINDOW(window), accel);
+    gtk_box_pack_start(GTK_BOX(main_vbox), menubar, FALSE, TRUE, 0);
+    gtk_widget_show(menubar);
+    
+    gtk_widget_show(window);
+    gtk_main();
+    
+    return(0);
+}
+
+/* Juste une démonstration du fonctionnement des fonctions de rappel 
+ * lorsqu'on utilise l'usine à menus. Souvent, on met tous les rappels
+ * des menus dans un fichier séparé, ce qui assure une meilleure 
+ * organisation. */ 
+
+void file_quit_cmd_callback (GtkWidget *widget, gpointer data)
+{
+    g_print ("%s\n", (char *) data);
+    gtk_exit(0);
+}
+</verb></tscreen>
+<p>
+Un <em/makefile/ pour que cela soit plus facile à compiler&nbsp;:
+
+<tscreen><verb>
+CC      = gcc
+PROF    = -g
+C_FLAGS =  -Wall $(PROF) -L/usr/local/include -DDEBUG
+L_FLAGS =  $(PROF) -L/usr/X11R6/lib -L/usr/local/lib 
+L_POSTFLAGS = -lgtk -lgdk -lglib -lXext -lX11 -lm
+PROGNAME = at
+
+O_FILES = menus.o main.o
+
+$(PROGNAME): $(O_FILES)
+	rm -f $(PROGNAME)
+	$(CC) $(L_FLAGS) -o $(PROGNAME) $(O_FILES) $(L_POSTFLAGS)
+
+.c.o: 
+	$(CC) -c $(C_FLAGS) $<
+
+clean: 
+	rm -f core *.o $(PROGNAME) nohup.out
+distclean: clean 
+	rm -f *~
+</verb></tscreen>
+<p>
+Pour l'instant, il n'y a que cet exemple. Une explication et de nombreux commentaires seront intégrés plus tard.
+
+
+<sect>Widgets non documentés
+<p>
+On a besoin de leurs auteurs! :). Participez à notre didacticiel.
+
+Si vous devez utiliser un de ces widgets non documentés, je vous recommande fortement de consulter leurs fichiers en-têtes respectifs dans la distribution GTK. Les noms de fonctions du GTK sont très parlantes. Lorsque vous avez compris comment les choses fonctionnent, il n'est pas difficile de savoir comment utiliser un widget à partir des déclarations de ses fonctions.  Cela, avec quelques exemples de codes pris ailleurs, devrait ne pas poser de problème.
+
+Lorsque vous avez compris toutes les fonctions d'un nouveau widget non documenté, pensez à écrire un didacticiel pour que les autres puissent bénéficier du temps que vous y avez passé.
+
+<sect1>Entrées de texte
+<p>
+
+<sect1>Sélections de couleurs
+<p>
+
+<sect1>Contrôle d'intervalle
+<p>
+
+<sect1>Règles
+<p>
+
+<sect1>Boîtes de texte
+<p>
+
+<sect1>Prévisualisation
+<p>
+(Ceci peut devoir être réécrit pour suivre le style du reste de ce
+didacticiel).
+
+<tscreen><verb>
+
+Les prévisualisateurs servent à plusieurs choses dans GIMP/GTK. La
+plus importante est celle-ci&nbsp;: les images de haute qualité peuvent
+occuper des dizaines de mega-octets en mémoire - facilement ! Toute
+opération sur une image aussi grosse implique un temps de traitement
+élevé. Si cela vous prend 5 à 10 essais (i.e. 10 à 20 étapes puisque
+vous devez recommencer lorsque vous avez fait une erreur) pour choisir
+la bonne modification, cela prendra littéralement des heures pour
+produire la bonne image - pour peu que vous ne manquiez pas de mémoire
+avant. Ceux qui on passé des heures dans les chambres noires de
+développement couleur connaissent cette sensation. Les
+prévisualisations sont notre planche de salut !
+
+L'aspect pénible de l'attente n'est pas le seul problème. souvent, il
+est utile de comparer les versions « Avant » et « Après » côte à côte
+ou, au pire l'une après l'autre. Si vous travaillez avec de grosses
+images et des attentes de 10 secondes, l'obtention des versions «
+Avant » et « Après » est, pour le moins, difficile. Pour des images de
+30Mo (4"x6", 600dpi, 24 bits), la comparaison côte à côte est
+impossible pour la plupart des gens, et la comparaison séquentielle
+n'est guère mieux. Les prévisualisations sont notre planche de salut !
+
+Mais il y a plus. Les prévisualisations permettent les
+pré-prévisualisations côte à côte. En d'autres termes, vous écrivez un
+plug-in (par exemple la simulation filterpack) qui aurait plusieurs
+prévisualisations de ce-que-ce-serait-si-vous-faisiez-ceci. Une approche
+comme celle ci agit comme une sorte de palette de prévisualisation et
+est très pratique pour les petites modifications. Utilisons les
+prévisualisations !
+
+Encore plus&nbsp;: pour certains plug-ins une intervention humaine en
+temps réel, spécifique aux images, peut s'avérer nécessaire. Dans le
+plug-in SuperNova, par exemple, on demande à l'utilisateur d'entrer
+les coordonnées du centre de la future supernova. La façon la plus
+simple de faire cela, vraiment, est de présenter une prévisualisation
+à l'utilisateur et de lui demander de choisir interactivement le
+point. Utilisons les prévisualisations !
+
+Enfin, quelques utilisations diverses&nbsp;: on peut utiliser les
+prévisualisations, même lorsqu'on ne travaille pas avec de grosses
+images. Elles sont utiles, par exemple, lorsqu'on veut avoir un rendu
+de motifs complexes. (Testez le vénérable plug-in Diffraction et
+d'autres !). Comme autre exemple, regardez le plug-in de rotation de
+couleur (travail en cours). Vous pouvez aussi utiliser les
+prévisualisations pour des petits logos dans vos plug-ins et même pour
+une photo de vous, l'Auteur. Utilisons les prévisualisations !
+
+Quand ne pas utiliser les prévisualisations
+
+N'utilisez pas les prévisualisations pour les graphes, les tracés,
+etc. GDK est bien plus rapide pour ça. N'utilisez les que pour les
+images !
+
+Utilisons les prévisualisations !
+
+Vous pouvez mettre une prévisualisation dans à peu près n'importe
+quoi. Dans une vbox, une hbox, un bouton, etc. Mais elles donnent leur
+meilleur d'elles-mêmes dans des cadres resserrés autour d'elles. Les
+prévisualisations n'ont, par elles-mêmes, aucun contour et semblent
+plates sans eux. (Bien sûr, si c'est cet aspect que vous
+voulez...). Les cadres serrés fournissent les bordures nécessaires.
+
+                               [Image][Image]
+
+Les prévisualisations sont, à bien des égards, comme tous les autres
+widgets de GTK (avec tout ce que cela implique) sauf qu'il disposent
+d'une fonctionnalité supplémentaire&nbsp;: ils doivent être remplis
+avec une image ! Nous traiterons d'abord exclusivement de l'aspect GTK
+des prévisualisations, puis nous verrons comment les remplir.
+
+
+                              /* Création d'un widget prévisualisation,
+                               * configuration de sa taille et affichage */
+GtkWidget *preview;
+preview=gtk_preview_new(GTK_PREVIEW_COLOR)
+                              /* Autre option :
+                              GTK_PREVIEW_GRAYSCALE);*/
+
+gtk_preview_size (GTK_PREVIEW (preview), WIDTH, HEIGHT);
+gtk_widget_show(preview);
+my_preview_rendering_function(preview);
+
+Ah oui, comme je le disais, les prévisualisations rendent mieux dans
+des cadres&nbsp;:
+
+GtkWidget *create_a_preview(int        Width,
+                            int        Height,
+                            int        Colorfulness)
+{
+  GtkWidget *preview;
+  GtkWidget *frame;
+  
+  frame = gtk_frame_new(NULL);
+  gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
+  gtk_container_border_width (GTK_CONTAINER(frame),0);
+  gtk_widget_show(frame);
+
+  preview=gtk_preview_new (Colorfulness?GTK_PREVIEW_COLOR
+                                       :GTK_PREVIEW_GRAYSCALE);
+  gtk_preview_size (GTK_PREVIEW (preview), Width, Height);
+  gtk_container_add(GTK_CONTAINER(frame),preview);
+  gtk_widget_show(preview);
+
+  my_preview_rendering_function(preview);
+  return frame;
+}
+
+Ceci est ma prévisualisation de base. Cette fonction retourne le cadre
+« père », on peut ainsi le placer ailleurs dans notre interface. Bien
+sûr, on peut passer le cadre « père » en paramètre à cette
+fonction. Dans de nombreuses situations, toutefois, le contenu de la
+prévisualisation est changée continuellement par notre application. En
+ce cas, on peut passer un pointeur vers une prévisualisation à la
+fonction <em/create_a_preview()/ et avoir ainsi un contrôle sur elle
+plus tard.
+
+Un point plus important qui pourra un jour vous faire économiser
+beaucoup de temps. Quelques fois, il est souhaitable de mettre un
+label à votre prévisualisation. Par exemple, on peut nommer la
+prévisualisation contenant l'image originale « Original » et celle
+contenant l'image modifiée « Moins Originale ». Il peut vous arriver
+de placer la prévisualisation avec le label approprié dans une
+vbox. L'effet inattendu est que si le label est plus large que la
+prévisualisation (taille de cette dernière, taille de la fonte du
+label, etc), le cadre s'élargit et ne convient plus à la
+prévisualisation. Le même problème se passera probablement dans
+d'autres situations aussi.
+
+                                   [Image]
+
+La solution consiste à placer la prévisualisation et le label dans une
+table de 2x2 en les attachant avec les paramètres suivants (c'est
+l'une des possibilités, bien sûr. La clé consiste à ne pas mettre
+GTK_FILL dans le second attachement)«nbsp;:
+
+gtk_table_attach(GTK_TABLE(table),label,0,1,0,1,
+                 0,
+                 GTK_EXPAND|GTK_FILL,
+                 0,0);
+gtk_table_attach(GTK_TABLE(table),frame,0,1,1,2,
+                 GTK_EXPAND,
+                 GTK_EXPAND,
+                 0,0);
+
+
+Et voici le résultat&nbsp;:
+
+                                   [Image]
+
+Divers
+
+Rendre une prévisualisation cliquable se fait très facilement en la plaçant dans un bouton. Cela ajoute aussi une bordure agréable autour de la prévisualisation et vous n'avez même pas besoin de la mettre dans un cadre.  Voir le plug-in Filter Pack Simulation comme exemple.
+
+Remplir une prévisualisation
+
+Afin de nous familiariser avec les bases de ce remplissage, créons le motif suivant&nbsp;:
+
+                                   [Image]
+
+void
+my_preview_rendering_function(GtkWidget     *preview)
+{
+#define SIZE 100
+#define HALF (SIZE/2)
+
+  guchar *row=(guchar *) malloc(3*SIZE); /* 3 bits par point */
+  gint i, j;                             /* Coordonnées      */
+  double r, alpha, x, y;
+
+  if (preview==NULL) return; /* J'ajoute généralement ceci quand je */
+                             /* veux éviter des plantages stupides  */
+                             /* Vous devez vous assurer que tout a  */
+                             /* été correctement initialisé !       */
+
+  for (j=0; j < ABS(cos(2*alpha)) ) { /* Sommes-nous dans la forme ? */
+                                         /* glib.h contient ABS(x).   */
+        row[i*3+0] = sqrt(1-r)*255;      /* Definit rouge             */
+        row[i*3+1] = 128;                /* Definit vert              */
+        row[i*3+2] = 224;                /* Definit bleu              */
+      }                                  /* "+0" est pour l'alignement ! */
+      else {
+        row[i*3+0] = r*255;
+        row[i*3+1] = ABS(sin((float)i/SIZE*2*PI))*255;
+        row[i*3+2] = ABS(sin((float)j/SIZE*2*PI))*255;
+      }
+    }
+    gtk_preview_draw_row( GTK_PREVIEW(preview),row,0,j,SIZE);
+
+    /* Insère "row" dans "preview" en partant du point de */
+    /* coordonnées (0,j) première colonne, j_ième ligne allant de SIZE */
+    /* pixels vers la droite */
+  }
+
+  free(row); /* on récupère un peu d'espace */
+  gtk_widget_draw(preview,NULL); /* qu'est-ce que ça fait ? */
+  gdk_flush(); /* et ça ?  */
+}
+
+Ceux qui n'utilisent pas GIMP en ont suffisamment vu pour faire
+déjà beaucoup de choses. Pour ceux qui l'utilisent, j'ai quelques
+précisions à ajouter.
+
+Prévisualisation d'image
+
+Il est pratique de conserver une version réduite de l'image ayant
+juste assez de pixels pour remplir la prévisualisation. Ceci est
+possible en choisissant chaque énième pixel où n est le ratio de la
+taille de l'image par rapport à la taille de la visualisation. Toutes
+les opérations suivantes (y compris le remplissage des
+prévisualisations) sont alors réalisées seulement sur le nombre réduit
+de pixels. Ce qui suit est mon implantation de la réduction d'image
+(Gardez à l'esprit que je n'ai que quelques notions de base en C !).
+
+(ATTENTION : CODE NON TESTÉ !!!)
+
+typedef struct {
+  gint      width;
+  gint      height;
+  gint      bbp;
+  guchar    *rgb;
+  guchar    *mask;
+} ReducedImage;
+
+enum {
+  SELECTION_ONLY,
+  SELCTION_IN_CONTEXT,
+  ENTIRE_IMAGE
+};
+
+ReducedImage *Reduce_The_Image(GDrawable *drawable,
+                               GDrawable *mask,
+                               gint LongerSize,
+                               gint Selection)
+{
+  /* Cette fonction réduit l'image à la taille de prévisualisation choisie */
+  /* La taille de la prévisualisation est déterminée par LongerSize, i.e.  */
+  /* la plus grande des deux dimensions. Ne fonctionne qu'avec des images  */
+  /* RGB !                                                                 */
+
+  gint RH, RW;          /* Hauteur et Largeur réduites                     */
+  gint width, height;   /* Largeur et Hauteur de la surface à réduire      */
+  gint bytes=drawable->bpp;
+  ReducedImage *temp=(ReducedImage *)malloc(sizeof(ReducedImage));
+
+  guchar *tempRGB, *src_row, *tempmask, *src_mask_row,R,G,B;
+  gint i, j, whichcol, whichrow, x1, x2, y1, y2;
+  GPixelRgn srcPR, srcMask;
+  gint NoSelectionMade=TRUE; /* Suppose que l'on traite l'image entière    */
+
+  gimp_drawable_mask_bounds (drawable->id, &amp;x1, &amp;y1, &amp;x2, &amp;y2);
+  width  = x2-x1;
+  height = y2-y1;
+  /* S'il y a une SELECTION, on récupère ses frontières ! */
+
+  if (width != drawable->width &amp;&amp; height != drawable->height)
+    NoSelectionMade=FALSE;
+  /* On vérifie si l'utilisateur a rendu une sélection active         */
+  /* Ceci sera important plus tard, lorsqu'on créera un masque réduit */
+
+  /* Si on veut prévisualiser l'image entière, supprimer ce qui suit ! */
+  /* Bien sûr, s'il n'y a pas de sélection, cela n'a aucun effet !     */
+  if (Selection==ENTIRE_IMAGE) {
+    x1=0;
+    x2=drawable->width;
+    y1=0;
+    y2=drawable->height;
+  }
+
+  /* Si on veut prévisualiser une sélection avec une surface qui l'entoure, */
+  /* on doit l'agrandir un petit peu. Considérez ça comme une devinette.   */
+
+  if (Selection==SELECTION_IN_CONTEXT) {
+    x1=MAX(0,                x1-width/2.0);
+    x2=MIN(drawable->width,  x2+width/2.0);
+    y1=MAX(0,                y1-height/2.0);
+    y2=MIN(drawable->height, y2+height/2.0);
+  }
+
+  /* Calcul de la largeur et de la hauteur de la surface à réduire. */
+
+  width  = x2-x1;
+  height = y2-y1;
+
+  /* Les lignes ci-dessous déterminent la dimension qui sera le coté */
+  /* le plus long. Cette idée est empruntée au plug-in Supernova.    */
+  /* Je soupçonne que j'aurais pu y penser moi-même, mais la vérité  */
+  /* doit être dite. Le plagiat pue !                                */
+
+  if (width>height) {
+    RW=LongerSize;
+    RH=(float) height * (float) LongerSize/ (float) width;
+  }
+  else {
+    RH=LongerSize;
+    RW=(float)width * (float) LongerSize/ (float) height;
+  }
+
+  /* L'image entière est réduite dans une chaîne ! */
+
+  tempRGB   = (guchar *) malloc(RW*RH*bytes);
+  tempmask  = (guchar *) malloc(RW*RH);
+
+  gimp_pixel_rgn_init (&amp;srcPR, drawable, x1, y1, width, height, FALSE, FALSE);
+  gimp_pixel_rgn_init (&amp;srcMask, mask, x1, y1, width, height, FALSE, FALSE);
+
+  /* Réservation pour sauver une ligne d'image et une ligne du masque */
+  src_row       = (guchar *) malloc (width*bytes);
+  src_mask_row  = (guchar *) malloc (width);
+
+  for (i=0; i < RH; i++) {
+    whichrow=(float)i*(float)height/(float)RH;
+    gimp_pixel_rgn_get_row (&amp;srcPR, src_row, x1, y1+whichrow, width);
+    gimp_pixel_rgn_get_row (&amp;srcMask, src_mask_row, x1, y1+whichrow, width);
+
+    for (j=0; j < RW; j++) {
+      whichcol=(float)j*(float)width/(float)RW;
+
+      /* Pas de sélection = chaque point est complètement sélectionné ! */
+
+      if (NoSelectionMade)
+        tempmask[i*RW+j]=255;
+      else
+        tempmask[i*RW+j]=src_mask_row[whichcol];
+
+      /* Ajout de la ligne à la longue chaîne qui contient maintenant */
+      /* l'image !                                                    */
+
+      tempRGB[i*RW*bytes+j*bytes+0]=src_row[whichcol*bytes+0];
+      tempRGB[i*RW*bytes+j*bytes+1]=src_row[whichcol*bytes+1];
+      tempRGB[i*RW*bytes+j*bytes+2]=src_row[whichcol*bytes+2];
+
+      /* On s'accroche aussi à l'alpha */
+      if (bytes==4)
+        tempRGB[i*RW*bytes+j*bytes+3]=src_row[whichcol*bytes+3];
+    }
+  }
+  temp->bpp=bytes;
+  temp->width=RW;
+  temp->height=RH;
+  temp->rgb=tempRGB;
+  temp->mask=tempmask;
+  return temp;
+}
+
+La suite est une fonction de prévisualisation qui utilise le même type
+<em/ReducedImage/ !  On remarque qu'elle utilise une fausse
+transparence (au moyen de <em/fake_transparancy/ qui est défini comme
+suit&nbsp;:
+
+gint fake_transparency(gint i, gint j)
+{
+  if ( ((i%20)- 10) * ((j%20)- 10)>0   )
+    return 64;
+  else
+    return 196;
+}
+
+Voici maintenant la fonction de prévisualisation«nbsp;:
+
+void
+my_preview_render_function(GtkWidget     *preview,
+                           gint          changewhat,
+                           gint          changewhich)
+{
+  gint Inten, bytes=drawable->bpp;
+  gint i, j, k;
+  float partial;
+  gint RW=reduced->width;
+  gint RH=reduced->height;
+  guchar *row=malloc(bytes*RW);;
+
+
+  for (i=0; i < RH; i++) {
+    for (j=0; j < RW; j++) {
+
+      row[j*3+0] = reduced->rgb[i*RW*bytes + j*bytes + 0];
+      row[j*3+1] = reduced->rgb[i*RW*bytes + j*bytes + 1];
+      row[j*3+2] = reduced->rgb[i*RW*bytes + j*bytes + 2];
+
+      if (bytes==4)
+        for (k=0; k<3; k++) {
+          float transp=reduced->rgb[i*RW*bytes+j*bytes+3]/255.0;
+          row[3*j+k]=transp*a[3*j+k]+(1-transp)*fake_transparency(i,j);
+        }
+    }
+    gtk_preview_draw_row( GTK_PREVIEW(preview),row,0,i,RW);
+  }
+
+  free(a);
+  gtk_widget_draw(preview,NULL);
+  gdk_flush();
+}
+
+Fonctions applicables
+
+guint           gtk_preview_get_type           (void);
+/* Aucune idée */
+void            gtk_preview_uninit             (void);
+/* Aucune idée */
+GtkWidget*      gtk_preview_new                (GtkPreviewType   type);
+/* Décrite ci-dessous */
+void            gtk_preview_size               (GtkPreview      *preview,
+                                                gint             width,
+                                                gint             height);
+/* Permet de changer la taille d'une prévisualisation existante */
+/* Apparamment, il y a un bug dans GTK qui rend ce traitement   */
+/* hasardeux. Une méthode pour corriger ce problème consiste à  */
+/* changer manuellement la taille de la fenêtre contenant la    */
+/* prévisualisation après avoir changé la taille de la          */
+/* prévisualisation.                                            */
+
+void            gtk_preview_put                (GtkPreview      *preview,
+                                                GdkWindow       *window,
+                                                GdkGC           *gc,
+                                                gint             srcx,
+                                                gint             srcy,
+                                                gint             destx,
+                                                gint             desty,
+                                                gint             width,
+                                                gint             height);
+/* Aucune idée */
+
+void            gtk_preview_put_row            (GtkPreview      *preview,
+                                                guchar          *src,
+                                                guchar          *dest,
+                                                gint             x,
+                                                gint             y,
+                                                gint             w);
+/* Aucune idée */
+
+void            gtk_preview_draw_row           (GtkPreview      *preview,
+                                                guchar          *data,
+                                                gint             x,
+                                                gint             y,
+                                                gint             w);
+/* Décrite dans le texte */
+
+void            gtk_preview_set_expand         (GtkPreview      *preview,
+                                                gint             expand);
+/* Aucune idée */
+
+/* Aucune piste pour celles qui suivent mais devrait être */
+/* un standard pour la plupart des widgets.               */
+
+void            gtk_preview_set_gamma          (double           gamma);
+void            gtk_preview_set_color_cube     (guint            nred_shades,
+                                                guint            ngreen_shades,
+                                                guint            nblue_shades,
+                                                guint            ngray_shades);
+void            gtk_preview_set_install_cmap   (gint             install_cmap);
+void            gtk_preview_set_reserved       (gint             nreserved);
+GdkVisual*      gtk_preview_get_visual         (void);
+GdkColormap*    gtk_preview_get_cmap           (void);
+GtkPreviewInfo* gtk_preview_get_info           (void);
+
+That's all, folks!
+
+</verb></tscreen>
+
+
+<sect1>Courbes
+<p>
+
+
+<sect>Widget EventBox <label id="sec_The_EventBox_Widget">
+<p>
+Il n'est disponible que dans <em/gtk+970916.tar.gz/ et les
+distributions ultérieures.  <p> Certains widgets GTK n'ont pas de
+fenêtre X associée, il se dessinent donc sur leurs parents. À cause de
+cela, ils ne peuvent recevoir d'événements et, s'ils ont une taille
+incorrecte, ils ne peuvent pas se mettre en place correctement&nbsp;: on peut
+alors avoir des surimpressions douteuses, etc. Si vous avez besoin de
+ces widgets, <em/EventBox/ est fait pour vous.
+
+Au premier abord, le widget <em/EventBox/ peut apparaître comme
+totalement dénué d'intérêt. Il ne dessine rien à l'écran et ne répond
+à aucun évenement. Cependant, il joue un rôle - il fournit une fenêtre
+X pour son widget fils. Ceci est important car de nombreux widgets GTK
+n'ont pas de fenêtre X associée. Ne pas avoir de fenêtre permet
+d'économiser de la mémoire mais a aussi quelques inconvénients. Un
+widget sans fenêtre ne peut recevoir d'événement, et ne réalise aucune
+mise en place de ce qu'il contient. Bien que le nom « EventBox »
+insiste sur la fonction de gestion d'événement, le widget peut aussi
+être utilisé pour la mise en place (et plus... voir l'exemple
+ci-dessous).
+
+<p>
+Pour créer un widget EventBox, on utilise&nbsp;:
+
+<tscreen><verb>
+GtkWidget* gtk_event_box_new (void);
+</verb></tscreen>
+
+<p>
+Un widget fils peut alors être ajouté à cet <em/EventBox/&nbsp;:
+
+<tscreen><verb>
+gtk_container_add (GTK_CONTAINER(event_box), widget);
+</verb></tscreen>
+
+<p>
+L'exemple suivant montre l'utilisation d'un <em/EventBox/ - un label
+est créé et mis en place sur une petite boîte, et configuré pour qu'un
+clic souris sur le label provoque la fin du programme.
+
+<tscreen><verb>
+#include <gtk/gtk.h>
+
+int 
+main (int argc, char *argv[])
+{
+    GtkWidget *window;
+    GtkWidget *event_box;
+    GtkWidget *label;
+    
+    gtk_init (&amp;argc, &amp;argv);
+    
+    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+    
+    gtk_window_set_title (GTK_WINDOW (window), "Event Box");
+    
+    gtk_signal_connect (GTK_OBJECT (window), "destroy",
+			GTK_SIGNAL_FUNC (gtk_exit), NULL);
+    
+    gtk_container_border_width (GTK_CONTAINER (window), 10);
+    
+    /* Création d'un EventBox et ajout de celui-ci dans la fenêtre. */
+    
+    event_box = gtk_event_box_new ();
+    gtk_container_add (GTK_CONTAINER(window), event_box);
+    gtk_widget_show (event_box);
+    
+    /* Création d'un long label */
+    
+    label = gtk_label_new ("Cliquez ici pour quitter, quitter, quitter, quitter, quitter");
+    gtk_container_add (GTK_CONTAINER (event_box), label);
+    gtk_widget_show (label);
+    
+    /* Placement serré. */
+
+    gtk_widget_set_usize (label, 110, 20);
+    
+    /* Attachement d'une action à celui-ci. */
+
+    gtk_widget_set_events (event_box, GDK_BUTTON_PRESS_MASK);
+    gtk_signal_connect (GTK_OBJECT(event_box), "button_press_event",
+			GTK_SIGNAL_FUNC (gtk_exit), NULL);
+    
+    /* Encore une fois, vous avez besoin d'une fenêtre X pour... */
+    
+    gtk_widget_realize (event_box);
+    gdk_window_set_cursor (event_box->window, gdk_cursor_new (GDK_HAND1));
+    
+    gtk_widget_show (window);
+    
+    gtk_main ();
+    
+    return 0;
+}
+</verb></tscreen>
+
+<sect>Configuration des attributs de widget<label
+id="sec_setting_widget_attributes">
+<p>
+Cette section décrit les fonctions opérant sur les widgets. Elles
+peuvent être utilisées pour configurer le style, l'espacement, la
+taille, etc.
+
+(Je devrais peut être faire une section uniquement consacrée aux
+raccourcis clavier.)
+
+<tscreen><verb>
+void       gtk_widget_install_accelerator (GtkWidget           *widget,
+					   GtkAcceleratorTable *table,
+					   gchar               *signal_name,
+					   gchar                key,
+					   guint8               modifiers);
+
+void       gtk_widget_remove_accelerator  (GtkWidget           *widget,
+					   GtkAcceleratorTable *table,
+					   gchar               *signal_name);
+
+void       gtk_widget_activate            (GtkWidget           *widget);
+
+void       gtk_widget_set_name            (GtkWidget           *widget,
+					   gchar               *name);
+gchar*     gtk_widget_get_name            (GtkWidget           *widget);
+
+void       gtk_widget_set_sensitive       (GtkWidget           *widget,
+					   gint                 sensitive);
+
+void       gtk_widget_set_style           (GtkWidget           *widget,
+					   GtkStyle            *style);
+					   
+GtkStyle*    gtk_widget_get_style     (GtkWidget *widget);
+
+GtkStyle*    gtk_widget_get_default_style    (void);
+
+void       gtk_widget_set_uposition       (GtkWidget           *widget,
+					   gint                 x,
+					   gint                 y);
+void       gtk_widget_set_usize           (GtkWidget           *widget,
+					   gint                 width,
+					   gint                 height);
+
+void       gtk_widget_grab_focus          (GtkWidget           *widget);
+
+void       gtk_widget_show                (GtkWidget           *widget);
+
+void       gtk_widget_hide                (GtkWidget           *widget);
+</verb></tscreen>
+
+
+
+<sect>Temporisations, fonctions d'E/S et d'attente<label id="sec_timeouts">
+<p>
+<sect1>Temporisations
+<p>
+Vous pouvez vous demander comment faire pour que GTK fasse quelque
+chose d'utile lorsqu'il est dans <em/gtk_main/. En fait, on a
+plusieurs options. L'utilisation des fonctions suivantes permet de
+créer une temporisation qui sera appelée tous les
+<em/interval/ millisecondes.
+
+<tscreen><verb>
+gint gtk_timeout_add (guint32 interval,
+		      GtkFunction function,
+		      gpointer data);
+</verb></tscreen>
+
+Le premier paramètre est le nombre de millisecondes entre les appels à
+notre fonction. Le deuxième est la fonction à appeler et le troisième
+est la donnée passée à cette fonction de rappel. La valeur retournée
+est un « marqueur » de type entier qui pourra être utilisé pour
+arrêter la temporisation en appelant&nbsp;:
+
+<tscreen><verb>
+void gtk_timeout_remove (gint tag);
+</verb></tscreen>
+
+On peut aussi stopper la fonction de temporisation en faisant
+retourner zéro ou FALSE à notre fonction de rappel. Évidemment, cela
+veut dire que si vous voulez que votre fonction continue à être
+appelée, elle doit retourner une valeur non nulle, ou TRUE.
+
+La déclaration de votre fonction de rappel doit ressembler à ça&nbsp;:
+
+<tscreen><verb>
+gint timeout_callback (gpointer data);
+</verb></tscreen>
+
+<sect1>Surveillance des E/S
+<p>
+Une autre caractéristique intéressante du GTK est la possibilité de
+vérifier les données d'un descripteur de fichier (celles retournées
+par <em/open/(2) ou <em/socket/(2)). C'est particulièrement pratique pour les
+applications réseau. La fonction suivante permet cette
+vérification&nbsp;:
+
+<tscreen><verb>
+gint gdk_input_add (gint source,
+		    GdkInputCondition condition,
+		    GdkInputFunction  function,
+		    gpointer data);
+</verb></tscreen>
+
+Le premier paramètre est le descripteur de fichier que l'on veut
+étudier, le second spécifie ce qu'on veut que le GDK recherche. Cela
+peut être&nbsp;:
+<p>
+GDK_INPUT_READ - Appel <em/function/ lorsqu'il y a une donnée prête à
+être lue dans le descripteur de fichier.
+<p>
+GDK_INPUT_WRITE - Appel de <em/function/ lorsque le descripteur de
+fichier est prêt pour une écriture.
+<p>
+Je suis sûr que vous vous doutez, maintenant, que le troisième
+paramètre est la fonction que l'on veut appeler lorsque les conditions
+ci-dessus sont satisfaites. Le dernier paramètre est la donnée à
+passer à cette fonction.
+<p>
+La valeur retournée est un marqueur qui pourra être utilisé pour dire
+au GDK de cesser de surveiller ce descripteur à l'aide de la fonction&nbsp;:
+<p>
+<tscreen><verb>
+void gdk_input_remove (gint tag);
+</verb></tscreen>
+<p>
+La fonction de rappel doit être déclarée de la façon suivante&nbsp;:
+<p>
+<tscreen><verb>
+void input_callback (gpointer data, gint source, 
+                     GdkInputCondition condition);
+</verb></tscreen>
+<p>
+
+<sect1>Fonctions d'attente
+<p>
+Que se passe-t'il si vous avez une fonction qui doit être appelée
+lorsque rien d'autre ne se passe ? On utilise la fonction suivante qui force
+GTK à appeler <em/function/ lorsqu'on est en phase d'inaction&nbsp;;
+
+<tscreen><verb>
+gint gtk_idle_add (GtkFunction function,
+		   gpointer data);
+</verb></tscreen>
+
+<tscreen><verb>
+void gtk_idle_remove (gint tag);
+</verb></tscreen>
+<p>
+Je n'expliquerai pas la signification des paramètres car ils
+ressemblent beaucoup à ceux déjà vus ci-dessus. La fonction pointée
+par le premier paramètre de <em/gtk_idle_add()/ sera appelée à chaque
+occasion. Comme pour les autres, retourner FALSE empêchera la fonction
+d'attente d'être appelée.
+
+<sect>Gestion des sélections
+
+<sect1>Introduction
+<p>
+Un type de communication inter-processus gérée par GTK est les
+<em>sélections</em>. Une sélection identifie un morceau de données,
+par exemple une portion de texte sélectionnée par l'utilisateur avec
+la souris. Seule une application sur un écran (le <em/propriétaire/)
+peut posséder une sélection particulière à un moment donné, ainsi
+lorsqu'une sélection est réclamée par une application, le propriétaire
+précédent doit indiquer à l'utilisateur que la sélection a été
+abandonnée. Les autres applications peuvent demander le contenu d'une
+sélection sous différentes formes appelées <em/cibles/. Il peut y
+avoir un nombre quelconque de sélections, mais la plupart des
+applications X n'en gèrent qu'une, la <em/sélection primaire/.
+
+<p>
+Dans la plupart des cas, une application GTK n'a pas besoin de gérer elle-même
+les sélections. Les widgets standards, comme le widget Entrée de texte,
+possèdent déjà la capacité de réclamer la sélection lorsqu'il le faut (par
+exemple, lorsque l'utilisateur glisse au dessus d'un texte) et de récupérer le
+contenu de la sélection détenue par un autre widget ou une autre application
+(par exemple, lorsque l'utilisateur clique avec le deuxième bouton de la
+souris). Cependant, il peut il y avoir des cas dans lesquels vous voulez donner
+aux autres widgets la possibilité de fournir la sélection, ou vous désirez
+récupérer des cibles non supportées par défaut.
+
+<p>
+Un concept fondamental dans la compréhension du fonctionnement des
+sélections est celui d'<em/atome/. Un atome est un entier qui définit
+de façon unique une chaîne (sur un affichage particulier). Certains
+atomes sont prédéfinis par le serveur X et, dans certains cas, des
+constantes définies dans <em/gtk.h/ correspondent à ces atomes. Par
+exemple, la constante GDK_PRIMARY_SELECTION correspond à la chaîne
+"PRIMARY".  Dans d'autres cas, on doit utiliser les fonctions
+<em/gdk_atom_intern()/, pour obtenir l'atome correspondant à une
+chaîne, et <em/gdk_atom_name()/, pour obtenir le nom d'un atome. Les
+sélections et les cibles sont identifiés par des atomes.
+
+<sect1>Récupération de la sélection
+<p>
+La récupération de la sélection est un processus asynchrone. Pour démarrer le processus, on appelle&nbsp;:
+
+<tscreen><verb>
+gint gtk_selection_convert   (GtkWidget 	  *widget, 
+			      GdkAtom    	   selection, 
+			      GdkAtom    	   target,
+			      guint32    	   time)
+</verb</tscreen>
+
+Cela <em>convertit</em> la sélection dans la forme spécifiée par
+<em/target/. Si tout est possible, le paramètre <em/time/ sera le
+moment de l'événement qui a déclenché la sélection. Ceci aide à
+s'assurer que les événements arrivent dans l'ordre où l'utilisateur
+les a demandé. Cependant, si cela n'est pas possible (par exemple,
+lorsque la conversion a été déclenchée par un signal "clicked"), alors
+on peut utiliser la macro GDK_CURRENT_TIME.
+
+<p>
+Quand le propriétaire de la sélection répond à la requête, un signal
+"selection_received" est envoyé à notre application. Le gestionnaire
+de ce signal reçoit un pointeur vers une structure
+<tt/GtkSelectionData/ définie ainsi&nbsp;:
+
+<tscreen><verb>
+struct _GtkSelectionData
+{
+  GdkAtom selection;
+  GdkAtom target;
+  GdkAtom type;
+  gint    format;
+  guchar *data;
+  gint    length;
+};
+</verb></tscreen>
+
+<em/selection/ et <em/target/ sont les valeurs que l'on a donné dans
+notre appel <em/gtk_selection_convert()/. <em/type/ est un atome qui
+identifie le type de données retourné par le propriétaire de la
+sélection. Quelques valeurs possibles sont&nbsp;: "STRING", une chaîne
+de caractères latin-1, "ATOM", une série d'atomes, "INTEGER", un
+entier, etc. La plupart des cibles ne peuvent retourner qu'un
+type. <em/format/ donne la longueur des unités (les caractères, par
+exemple) en bits. Habituellement, on ne se préoccupe pas de cela
+lorsqu'on reçoit des données. <em/data/ est un pointeur vers la donnée
+retournée et <em/length/ donne la longueur en octets de la donnée
+retournée. Si <em/length/ est négative, cela indique qu'une erreur est
+survenue et que la sélection ne peut être récupérée. Ceci peut arriver
+si aucune application n'est propriétaire de la sélection, ou si vous
+avez demandé une cible que l'application ne sait pas gérer. Le tampon
+est garanti d'être un octet plus long que <em/length/ ; l'octet
+supplémentaire sera toujours zéro, et il n'est donc pas nécessaire de
+faire une copie de chaîne simplement pour qu'elle soit terminée par
+zéro (comme doivent l'être toutes les chaînes C).
+
+<p>
+Dans l'exemple qui suit, on récupère la cible spéciale "TARGETS", qui
+est une liste de toutes les cibles en lesquelles la sélection peut
+être convertie.
+
+<tscreen><verb>
+#include <gtk/gtk.h>
+
+void selection_received (GtkWidget *widget, 
+			 GtkSelectionData *selection_data, 
+			 gpointer data);
+
+/* Gestionnaire de signal invoqué lorsque l'utilisateur clique sur 
+ * le bouton « Obtenir les cibles ». */
+
+void get_targets (GtkWidget *widget, gpointer data)
+{
+  static GdkAtom targets_atom = GDK_NONE;
+
+  /* Obtention de l'atome correspondant à la chaîne "TARGETS" */
+
+  if (targets_atom == GDK_NONE)
+    targets_atom = gdk_atom_intern ("TARGETS", FALSE);
+
+  /* Demande de la cible "TARGETS" pour la sélection primaire */
+
+  gtk_selection_convert (widget, GDK_SELECTION_PRIMARY, targets_atom,
+			 GDK_CURRENT_TIME);
+}
+
+/* Gestionnaire de signal appelé quand le propriétaire des sélections
+ * retourne la donnée. */
+
+void selection_received (GtkWidget *widget, GtkSelectionData *selection_data, 
+		    gpointer data)
+{
+  GdkAtom *atoms;
+  GList *item_list;
+  int i;
+
+  /* **** IMPORTANT **** On vérifie si la récupération s'est bien passée. */
+
+  if (selection_data->length < 0)
+    {
+      g_print ("Selection retrieval failed\n");
+      return;
+    }
+
+  /* On s'assure que l'on a obtenu la donnée sous la forme attendue. */
+
+  if (selection_data->type != GDK_SELECTION_TYPE_ATOM)
+    {
+      g_print ("La sélection \"TARGETS\" n'a pas été retournée sous la forme d'atomes !\n");
+      return;
+    }
+  
+  /* Affichage des atomes reçus. */
+
+  atoms = (GdkAtom *)selection_data->data;
+
+  item_list = NULL;
+  for (i=0; i<selection_data->length/sizeof(GdkAtom); i++)
+    {
+      char *name;
+      name = gdk_atom_name (atoms[i]);
+      if (name != NULL)
+	g_print ("%s\n",name);
+      else
+	g_print ("(atome incorrect)\n");
+    }
+
+  return;
+}
+
+int 
+main (int argc, char *argv[])
+{
+  GtkWidget *window;
+  GtkWidget *button;
+  
+  gtk_init (&amp;argc, &amp;argv);
+
+  /* Création de la fenêtre de l'application. */
+
+  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  gtk_window_set_title (GTK_WINDOW (window), "Sélections");
+  gtk_container_border_width (GTK_CONTAINER (window), 10);
+
+  gtk_signal_connect (GTK_OBJECT (window), "destroy",
+		      GTK_SIGNAL_FUNC (gtk_exit), NULL);
+
+  /* Création d'un bouton pour obtenir les cibles */
+
+  button = gtk_button_new_with_label ("Obtenir les cibles");
+  gtk_container_add (GTK_CONTAINER (window), button);
+
+  gtk_signal_connect (GTK_OBJECT(button), "clicked",
+		      GTK_SIGNAL_FUNC (get_targets), NULL);
+  gtk_signal_connect (GTK_OBJECT(button), "selection_received",
+		      GTK_SIGNAL_FUNC (selection_received), NULL);
+
+  gtk_widget_show (button);
+  gtk_widget_show (window);
+  
+  gtk_main ();
+  
+  return 0;
+}
+</verb></tscreen>
+
+<sect1>Fournir la sélection 
+<p>
+
+Fournir la sélection est un peu plus compliqué. On doit enregistrer
+les gestionnaires qui seront appelés lorsque notre sélection est
+demandée. Pour chaque paire sélection/cible que l'on gèrera, on fera
+un appel à&nbsp;:
+
+<tscreen><verb>
+void gtk_selection_add_handler (GtkWidget           *widget, 
+				GdkAtom              selection,
+				GdkAtom              target,
+				GtkSelectionFunction function,
+				GtkRemoveFunction    remove_func,
+				gpointer             data);
+</verb></tscreen>
+
+<em/widget/, <em/selection/ et <em/target/ identifient les requêtes
+que ce gestionnaire gèrera. S'il ne vaut pas NULL, <em/remove_func/
+sera appelé lorsque le gestionnaire de signal est supprimé. Ceci est
+utile, par exemple, pour des langages interprétés qui doivent garder
+une trace du nombre de références à <em/data/.
+
+<p>
+La fonction de rappel <em/function/ doit avoir la signature suivante&nbsp;:
+
+<tscreen><verb>
+typedef void (*GtkSelectionFunction) (GtkWidget *widget, 
+                                      GtkSelectionData *selection_data,
+				      gpointer data);
+
+</verb></tscreen>
+
+Le <em/GtkSelectionData/ est le même qu'au dessus, mais, cette fois,
+nous sommes responsables de l'initialisation de ses champs <em/type/,
+<em/format/, <em/data/, et <em/length/. (Le champ <em/format/ est
+important ici - le serveur X l'utilise pour savoir si la donnée doit
+être échangée par octet ou non. Habituellement, ce sera 8 (un
+caractère), ou 32 (un entier)). Cette initialisation est faite en
+utilisant l'appel&nbsp;:
+
+<tscreen><verb>
+void gtk_selection_data_set (GtkSelectionData *selection_data,
+			     GdkAtom           type,
+			     gint              format,
+			     guchar           *data,
+			     gint              length);
+</verb></tscreen>
+
+Cette fonction s'occupe de faire une copie correcte des données afin
+que l'on n'ait pas à se soucier du reste. (On ne doit pas remplir ces
+champs à la main).
+
+<p>
+Lorsque cela est demandé par l'utilisateur, on réclame la possession
+de la sélection en appelant&nbsp;:
+
+<tscreen><verb>
+gint gtk_selection_owner_set (GtkWidget 	  *widget,
+			      GdkAtom    	   selection,
+			      guint32    	   time);
+</verb></tscreen>
+
+Si une autre application réclame la possession de la sélection, on
+recevra un "selection_clear_event".
+
+Comme exemple de fourniture de sélection, l'exemple suivant ajoute une
+fonctionnalité de sélection à un bouton commutateur. Lorsque ce bouton
+est appuyé, le programme réclame la sélection primaire. La seule cible
+supportée (à part certaines cibles fournies par GTK lui-même, comme
+« TARGETS ») est « STRING ». Lorsque celle-ci est demandée, on
+retourne une représentation de l'heure sous forme de chaîne.
+
+<tscreen><verb>
+#include <gtk/gtk.h>
+#include <time.h>
+
+/* Fonction de rappel appelée lorsque l'utilisateur commute la sélection. */
+
+void selection_toggled (GtkWidget *widget, gint *have_selection)
+{
+  if (GTK_TOGGLE_BUTTON(widget)->active)
+    {
+      *have_selection = gtk_selection_owner_set (widget,
+						 GDK_SELECTION_PRIMARY,
+						 GDK_CURRENT_TIME);
+      /* Si la demande de sélection échoue, on remet le bouton en position sortie. */
+
+      if (!*have_selection)
+	gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON(widget), FALSE);
+    }
+  else
+    {
+      if (*have_selection)
+	{
+	  /* Avant de nettoyer la selection en mettant son propriétaire à NULL, 
+           * on vérifie que nous sommes bien son propriétaire actuel. */
+
+	  if (gdk_selection_owner_get (GDK_SELECTION_PRIMARY) == widget->window)
+	    gtk_selection_owner_set (NULL, GDK_SELECTION_PRIMARY,
+				     GDK_CURRENT_TIME);
+	  *have_selection = FALSE;
+	}
+    }
+}
+
+/* Appelée lorsqu'une autre application demande la sélection. */
+
+gint selection_clear (GtkWidget *widget, GdkEventSelection *event,
+		 gint *have_selection)
+{
+  *have_selection = FALSE;
+  gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON(widget), FALSE);
+
+  return TRUE;
+}
+
+/* Fournit l'heure comme sélection. */
+
+void selection_handle (GtkWidget *widget, 
+		  GtkSelectionData *selection_data,
+		  gpointer data)
+{
+  gchar *timestr;
+  time_t current_time;
+
+  current_time = time (NULL);
+  timestr = asctime (localtime(&amp;current_time)); 
+
+  /* Lorsqu'on retourne une chaîne, elle ne doit pas se terminer par
+   * 0, ce sera fait pour nous. */
+
+  gtk_selection_data_set (selection_data, GDK_SELECTION_TYPE_STRING,
+			  8, timestr, strlen(timestr));
+}
+
+int main (int argc, char *argv[])
+{
+  GtkWidget *window;
+
+  GtkWidget *selection_button;
+
+  static int have_selection = FALSE;
+  
+  gtk_init (&amp;argc, &amp;argv);
+
+  /* Création de la fenêtre principale. */
+
+  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  gtk_window_set_title (GTK_WINDOW (window), "Event Box");
+  gtk_container_border_width (GTK_CONTAINER (window), 10);
+
+  gtk_signal_connect (GTK_OBJECT (window), "destroy",
+		      GTK_SIGNAL_FUNC (gtk_exit), NULL);
+
+  /* Création d'un bouton commutateur pour qu'il agisse comme une sélection. */
+
+  selection_button = gtk_toggle_button_new_with_label ("Demande de sélection");
+  gtk_container_add (GTK_CONTAINER (window), selection_button);
+  gtk_widget_show (selection_button);
+
+  gtk_signal_connect (GTK_OBJECT(selection_button), "toggled",
+		      GTK_SIGNAL_FUNC (selection_toggled), &amp;have_selection);
+  gtk_signal_connect (GTK_OBJECT(selection_button), "selection_clear_event",
+		      GTK_SIGNAL_FUNC (selection_clear), &amp;have_selection);
+
+  gtk_selection_add_handler (selection_button, GDK_SELECTION_PRIMARY,
+			     GDK_SELECTION_TYPE_STRING,
+			     selection_handle, NULL, NULL);
+
+  gtk_widget_show (selection_button);
+  gtk_widget_show (window);
+  
+  gtk_main ();
+  
+  return 0;
+}
+</verb></tscreen>
+
+
+
+<sect>glib<label id="sec_glib">
+<p>
+La <em/glib/ fournit de nombreuses fonctions et définitions utiles,
+prêtes à être utilisées lorsqu'on crée des applications GDK et GTK. Je
+les énumèrerais toutes avec une brève explication. Beaucoup sont des
+répliques des fonctions standards de la <em/libc/, et je ne les
+détaillerais donc pas trop. Ceci doit surtout servir de référence afin
+de savoir ce qui est disponible pour être utilisé.
+
+<sect1>Définitions
+<p>
+Les définitions pour les bornes de la plupart des types standards sont&nbsp;:
+
+<tscreen><verb>
+G_MINFLOAT
+G_MAXFLOAT
+G_MINDOUBLE
+G_MAXDOUBLE
+G_MINSHORT
+G_MAXSHORT
+G_MININT
+G_MAXINT
+G_MINLONG
+G_MAXLONG
+</verb></tscreen>
+
+Voici aussi les redéfinitions de types. Celles qui ne sont pas
+spécifiées sont configurées dynamiquement selon l'architecture. Évitez
+surtout de compter sur la taille d'un pointeur si vous voulez un
+programme portable ! Un pointeur sur un Alpha fait 8 octets, mais il
+en fait 4 sur un Intel.
+
+<tscreen><verb>
+char   gchar;
+short  gshort;
+long   glong;
+int    gint;
+char   gboolean;
+
+unsigned char   guchar;
+unsigned short  gushort;
+unsigned long   gulong;
+unsigned int    guint;
+
+float   gfloat;
+double  gdouble;
+long double gldouble;
+
+void* gpointer;
+
+gint8
+guint8
+gint16
+guint16
+gint32
+guint32
+</verb></tscreen>
+
+<sect1>Listes doublement chaînées
+<p>
+Les fonctions suivantes servent à créer, gérer et détruire des listes
+doublement chaînées. Je suppose que vous savez ce qu'est une liste
+chaînée car leur explication n'entre pas dans le cadre de ce
+document. Bien sûr, il n'y a pas besoin de les connaître pour une
+utilisation générale de GTK, mais c'est bien de savoir comment elles
+fonctionnent.
+
+<tscreen><verb>
+GList* g_list_alloc       (void);
+
+void   g_list_free        (GList     *list);
+
+void   g_list_free_1      (GList     *list);
+
+GList* g_list_append      (GList     *list,
+                           gpointer   data);
+			   
+GList* g_list_prepend     (GList     *list,
+                           gpointer   data);
+			
+GList* g_list_insert      (GList     *list,
+                           gpointer   data,
+			   gint       position);
+
+GList* g_list_remove      (GList     *list,
+                           gpointer   data);
+			   
+GList* g_list_remove_link (GList     *list,
+                           GList     *link);
+
+GList* g_list_reverse     (GList     *list);
+
+GList* g_list_nth         (GList     *list,
+                           gint       n);
+			   
+GList* g_list_find        (GList     *list,
+                           gpointer   data);
+
+GList* g_list_last        (GList     *list);
+
+GList* g_list_first       (GList     *list);
+
+gint   g_list_length      (GList     *list);
+
+void   g_list_foreach     (GList     *list,
+                           GFunc      func,
+			   gpointer   user_data);
+</verb></tscreen>					      
+
+
+<sect1>Listes simplement chaînées
+<p>
+La plupart des fonctions pour les listes simplement chaînées
+ci-dessous sont identiques à celles vues plus haut. Voici une liste
+complète&nbsp;:
+
+<tscreen><verb>
+GSList* g_slist_alloc       (void);
+
+void    g_slist_free        (GSList   *list);
+
+void    g_slist_free_1      (GSList   *list);
+
+GSList* g_slist_append      (GSList   *list,
+                             gpointer  data);
+		
+GSList* g_slist_prepend     (GSList   *list,
+                             gpointer  data);
+			     
+GSList* g_slist_insert      (GSList   *list,
+                             gpointer  data,
+		             gint      position);
+			     
+GSList* g_slist_remove      (GSList   *list,
+                             gpointer  data);
+			     
+GSList* g_slist_remove_link (GSList   *list,
+                             GSList   *link);
+			     
+GSList* g_slist_reverse     (GSList   *list);
+
+GSList* g_slist_nth         (GSList   *list,
+                             gint      n);
+			     
+GSList* g_slist_find        (GSList   *list,
+                             gpointer  data);
+			     
+GSList* g_slist_last        (GSList   *list);
+
+gint    g_slist_length      (GSList   *list);
+
+void    g_slist_foreach     (GSList   *list,
+                             GFunc     func,
+			     gpointer  user_data);
+	
+</verb></tscreen>
+
+<sect1>Gestion de la mémoire
+<p>
+<tscreen><verb>
+gpointer g_malloc      (gulong    size);
+</verb></tscreen>
+
+Remplace <em/malloc()/.  On n'a pas besoin de vérifier la valeur de
+retour car cela est fait pour nous dans cette fonction.
+
+<tscreen><verb>
+gpointer g_malloc0     (gulong    size);
+</verb></tscreen>
+
+Identique à la précédente, mais initialise la mémoire à zéro avant de
+retourner un pointeur vers la zone réservée.
+
+<tscreen><verb>
+gpointer g_realloc     (gpointer  mem,
+                        gulong    size);
+</verb></tscreen>
+
+Réalloue <em/size/ octets de mémoire à partir de <em/mem/. Évidemment,
+la mémoire doit avoir été allouée auparavant.
+
+<tscreen><verb>
+void     g_free        (gpointer  mem);
+</verb></tscreen>
+
+Libère la mémoire. Facile.
+ 
+<tscreen><verb>
+void     g_mem_profile (void);
+</verb></tscreen>
+
+Produit un profil de la mémoire utilisée, mais requiert l'ajout de
+<em/#define MEM_PROFILE/ au début de <em>glib/gmem.c</em>,
+de refaire un <em/make/ et un <em/make install/.
+
+<tscreen><verb>
+void     g_mem_check   (gpointer  mem);
+</verb></tscreen>
+
+Vérifie qu'un emplacement mémoire est valide. Nécessite que l'on
+ajoute <em/#define MEM_CHECK/ au début de <em/gmem.c/ que l'on refasse
+un <em/make/ et un <em/make install/.
+
+<sect1>Timers
+<p>
+Fonctions des timers...
+
+<tscreen><verb>
+GTimer* g_timer_new     (void);
+
+void    g_timer_destroy (GTimer  *timer);
+
+void    g_timer_start   (GTimer  *timer);
+
+void    g_timer_stop    (GTimer  *timer);
+
+void    g_timer_reset   (GTimer  *timer);
+
+gdouble g_timer_elapsed (GTimer  *timer,
+                         gulong  *microseconds);
+</verb></tscreen>			 
+
+<sect1>Gestion des chaînes
+<p>
+Un ensemble complet de fonction de gestion des chaînes. Elles semblent
+toutes très intéressantes et sont sûrement meilleures, à bien des
+égards, que les fonctions C standards, mais elle nécessitent de la
+documentation.
+
+<tscreen><verb>
+GString* g_string_new       (gchar   *init);
+void     g_string_free      (GString *string,
+                             gint     free_segment);
+			     
+GString* g_string_assign    (GString *lval,
+                             gchar   *rval);
+			     
+GString* g_string_truncate  (GString *string,
+                             gint     len);
+			     
+GString* g_string_append    (GString *string,
+                             gchar   *val);
+			    
+GString* g_string_append_c  (GString *string,
+                             gchar    c);
+	
+GString* g_string_prepend   (GString *string,
+                             gchar   *val);
+			     
+GString* g_string_prepend_c (GString *string,
+                             gchar    c);
+	
+void     g_string_sprintf   (GString *string,
+                             gchar   *fmt,
+			     ...);
+	
+void     g_string_sprintfa  (GString *string,
+                             gchar   *fmt,
+			     ...);
+</verb></tscreen>							  
+
+<sect1>Utilitaires et fonctions d'erreurs
+<p>
+<tscreen><verb>
+gchar* g_strdup    (const gchar *str);
+</verb></tscreen>
+
+Remplace la fonction <em/strdup/. Elle copie le contenu de la chaîne
+d'origine dans la mémoire venant d'être allouée et retourne un
+pointeur sur cette zone.
+
+<tscreen><verb>
+gchar* g_strerror  (gint errnum);
+</verb></tscreen>
+
+Je recommande de l'utiliser pour tous les messages d'erreur. Elle est
+beaucoup plus propre et plus portable que <em/perror()/ ou les
+autres. La sortie est habituellement de la forme&nbsp;:
+
+<tscreen><verb>
+nom du programme:fonction qui a échoué:fichier ou autre descripteur:strerror
+</verb></tscreen>
+
+Voici un exemple d'appel utilisé dans le programme « Bonjour tout le monde ! »&nbsp;:
+
+<tscreen><verb>
+g_print("bonjour_monde:open:%s:%s\n", filename, g_strerror(errno));
+</verb></tscreen>
+
+<tscreen><verb>
+void g_error   (gchar *format, ...);
+</verb></tscreen>
+
+Affiche un message d'erreur. Le format est comme <em/printf/, mais il
+ajoute « ** ERROR **: » au début du message et sort du programme. À
+n'utiliser que pour les erreurs fatales.
+
+<tscreen><verb>
+void g_warning (gchar *format, ...);
+</verb></tscreen>
+
+Comme au dessus, mais ajoute « ** WARNING **: », et ne termine pas le
+programme.
+
+<tscreen><verb>
+void g_message (gchar *format, ...);
+</verb></tscreen>
+Affiche  « message: » avant la chaîne passée en paramètre.
+
+<tscreen><verb>
+void g_print   (gchar *format, ...);
+</verb></tscreen>
+
+Remplace <em/printf()/.
+
+Enfin la dernière fonction&nbsp;:
+
+<tscreen><verb>
+gchar* g_strsignal (gint signum);
+</verb></tscreen>
+
+Affiche le nom du signal système Unix correspondant au numéro de
+signal. Utile pour les fonctions génériques de gestion de signaux.
+
+Tout ce qui est ci-dessus est plus ou moins volé à <em/glib.h/. Si
+quelqu'un s'occupe de documenter une fonction, qu'il m'envoit un
+courrier !
+
+
+<sect>Fichiers rc de GTK
+<p>
+GTK a sa propre méthode pour gérer les configurations par défaut des
+applications, en utilisant des fichiers <tt/rc/. Ceux-ci peuvent être
+utilisés pour configurer les couleurs de presque tous les widgets, et
+pour mettre des pixmaps sur le fond de certains widgets.
+
+<sect1>Fonctions pour les fichiers rc
+<p>
+Au démarrage de votre application, ajoutez un appel à&nbsp;:
+<tscreen><verb>
+void gtk_rc_parse (char *filename);
+</verb></tscreen>
+<p>
+en lui passant le nom de votre fichier rc. Ceci forcera GTK à analyser
+ce fichier et à utiliser les configurations de styles pour les types
+de widgets qui y sont définis.
+<p>
+Si vous voulez avoir un ensemble particulier de widgets qui prenne le
+pas sur le style des autres, ou une autre division logique de widgets,
+utilisez un appel à&nbsp;:
+<tscreen><verb>
+void gtk_widget_set_name (GtkWidget *widget,
+                          gchar *name);
+</verb></tscreen>
+<p>
+En lui passant comme premier paramètre le widget que vous avez créé,
+et le nom que vous voulez lui donner comme second paramètre. Ceci vous
+permettra de changer les attributs de ce widget par son nom dans le
+fichier rc.
+<p>
+Si vous utilisez un appel comme celui-ci&nbsp;:
+
+<tscreen><verb>
+button = gtk_button_new_with_label ("Bouton Spécial");
+gtk_widget_set_name (button, "bouton special");
+</verb></tscreen>
+<p>
+Ce bouton s'appelle « bouton special » et peut être accédé par son nom
+dans le fichier rc en tant que « bouton special.GtkButton ».  [<---
+Vérifiez !]
+<p>
+Le fichier rc ci-dessous configure les propriétés de la fenêtre
+principale et fait hériter tous les fils de celle-ci du style décrit
+par « bouton_principal ». Le code utilisé dans l'application
+est&nbsp;:
+
+<tscreen><verb>
+window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+gtk_widget_set_name (window, "fenetre principale");
+</verb></tscreen>
+<p>
+Et le style est défini dans le fichier rc avec&nbsp;:
+
+<tscreen><verb>
+widget "fenetre principale.*GtkButton*" style "bouton_principal"
+</verb></tscreen>
+<p>
+Ce qui configure tous les widgets <em/GtkButton/ de « fenêtre
+principale » avec le style « bouton_principal » défini dans le fichier
+rc.
+<p>
+Ainsi que vous pouvez le voir, il s'agit d'un système puissant et
+flexible. Utilisez votre imagination pour en tirer le meilleur.
+
+<sect1>Format des fichiers rc de GTK
+<p>
+Le format du fichier GTK est illustré dans l'exemple suivant. Il
+s'agit du fichier <em/testgtkrc/ de la distribution GTK mais j'ai
+ajouté quelques commentaires et autres choses. Vous pouvez inclure
+cette explication à votre application pour permettre à l'utilisateur
+de régler finement son application.
+<p>
+Il y a plusieurs directives pour changer les attributs d'un widget.
+<itemize>
+<item>fg - configure la couleur de premier plan d'un widget.
+<item>bg - configure la couleur d'arrière plan d'un widget.
+<item>bg_pixmap - configure l'arrière plan d'un widget avec un pixmap.
+<item>font - configure la fonte à utiliser pour un widget.
+</itemize>
+<p>
+De plus, un widget peut se trouver dans différents états et l'on peut
+configurer des couleurs, pixmaps et fontes différentes pour chacun
+d'eux. Ces états sont&nbsp;:
+<itemize>
+<item>NORMAL - L'état normal d'un widget, sans la souris au dessus de
+lui, non pressé, etc.  
+<item>PRELIGHT - Lorsque la souris se trouve au dessus du widget, les
+couleurs définies pour cet état sont actives.
+<item>ACTIVE - Lorsque le widget est pressé ou cliqué, il devient
+actif et les attributs associés à cet état sont appliqués.
+<item>INSENSITIVE - Quand un widget est configuré pour être
+insensible et qu'il ne peut être activé, il prend ces attributs.
+<item>SELECTED - Lorsqu'un objet est choisi, il prend ces attributs.
+</itemize>
+<p>
+Lorsqu'on utilise les mots-clés « <em/fg/ » et « <em/bg/ » pour
+configurer les couleurs des widgets, le format est&nbsp;:
+
+<tscreen><verb> fg[<STATE>] = { Red, Green, Blue } </verb></tscreen>
+<p>
+Où STATE est l'un des états vus plus haut (PRELIGHT, ACTIVE etc), et
+où <em/Red/, <em/Green/ et <em/Blue/ sont des valeurs comprises entre
+0 et 1.0. { 1.0, 1.0, 1.0 } représente la couleur blanche.  Ces
+valeurs doivent être de type réel ou elles seront considérées comme
+valant 0, ainsi un simple « 1 » ne marchera pas, il faut mettre « 1.0
+». Un « 0 » simple convient car ce n'est pas un problème s'il n'est
+pas reconnu puisque toutes les valeurs non reconnues sont mises à 0.
+<p>
+<em/bg_pixmap/ est très similaire, sauf que les couleurs sont
+remplacées par un nom de fichier.
+
+<em/pixmap_path/ est une liste de chemins séparés par des « : ». Ces
+chemins seront parcourus pour chaque pixmap que l'on spécifie.
+
+<p>
+La directive <em/font/ est simplement&nbsp;:
+<tscreen><verb>
+font = "<font name>"
+</verb></tscreen>
+<p>
+Où la seule partie difficile est d'arriver à comprendre la chaîne
+contenant le nom de la fonte. L'utilisation de <em/xfontsel/ ou d'un
+autre utilitaire semblable peut aider.
+<p>
+« <em/widget_class/ » configure le style d'une classe de widgets. Ces
+classes sont listées dans la section sur la hiérarchie des widgets.
+<p>
+La directive « <em/widget/ » configure un ensemble spécifique de
+widgets selon un style donné, annulant tout style de configuration
+pour la classe de widget donnée. Ces widgets sont enregistrés dans
+l'application en utilisant l'appel <em/gtk_widget_set_name()/. Ceci
+vous permet de spécifier les attributs d'un widget, widget par widget,
+au lieu de configurer les attributs d'une classe entière de
+widgets. Je vous demande instamment de documenter tous ces widgets
+spéciaux pour que les utilisateurs puisse les adapter à leurs besoins.
+<p>
+Lorsque le mot-clé « <em/parent/ » est utilisé comme attribut, le
+widget prendra les attributs de son parent dans l'application.
+<p>
+Lorsqu'on définit un style, on peut assigner les attributs d'un style
+déjà défini à ce nouveau style.
+
+<tscreen><verb>
+style "bouton_principal" = "button"
+{
+  font = "-adobe-helvetica-medium-r-normal--*-100-*-*-*-*-*-*"
+  bg[PRELIGHT] = { 0.75, 0, 0 }
+}
+</verb></tscreen>
+<p>
+Cet exemple prend le style "button" et crée un nouveau style
+"bouton_principal"en changeant simplement la fonte et la couleur de
+fond pour l'état PRELIGHT.
+<p>
+Bien sûr, un bon nombre de ces attributs ne s'applique pas à tous les
+widgets. C'est une question de bon sens. Tout ce qui peut s'appliquer
+s'applique.
+
+<sect1>Exemple de fichier rc
+<p>
+
+<tscreen><verb>
+# pixmap_path "<dir 1>:<dir 2>:<dir 3>:..."
+#
+pixmap_path "/usr/include/X11R6/pixmaps:/home/imain/pixmaps"
+#
+# style <name> [= <name>]
+# {
+#   <option>
+# }
+#
+# widget <widget_set> style <style_name>
+# widget_class <widget_class_set> style <style_name>
+
+
+# Voici une liste des états possibles. Remarquez que certains ne s'appliquent
+# pas à certains widgets.
+#
+# NORMAL - L'état normal d'un widget, sans la souris au dessus de lui, 
+# non pressé, etc.
+#
+# PRELIGHT - Lorsque la souris se trouve au dessus du widget, les couleurs 
+# définies pour cet état sont actives.
+#
+# ACTIVE - Lorsque le widget est pressé ou cliqué, il devient actif et les 
+# attributs associés à cet état sont appliqués.
+#
+# INSENSITIVE - Quand un widget est configuré pour être insensible, et qu'il 
+# ne peut être activé, il prend ces attributs.
+#
+# SELECTED - Lorsqu'un objet est choisi, il prend ces attributs.
+#
+# Avec ces états, on peut configurer les attributs des widgets dans chacun
+# de ces états en utilisant les directives suivantes.
+#
+# fg - configure la couleur de premier plan d'un widget.
+# bg - configure la couleur d'arrière plan d'un widget.
+# bg_pixmap - configure l'arrière plan d'un widget avec un pixmap.
+# font - configure la fonte à utiliser pour un widget.
+
+# Configuration d'un style appelé "button". Le nom n'est pas important
+# car il est assigné aux widgets réels à la fin du fichier.
+
+style "window"
+{
+  #Configure l'espace autour de la fenêtre avec le pixmap spécifié.
+  #bg_pixmap[<STATE>] = "<pixmap filename>"
+  bg_pixmap[NORMAL] = "warning.xpm"
+}
+
+style "scale"
+{
+  #Configure la couleur de premier plan (celle de la fonte) à rouge
+  #lorsqu'on est dans l'état "NORMAL".
+  
+  fg[NORMAL] = { 1.0, 0, 0 }
+  
+  #Configure le pixmap d'arrière plan de ce widget à celui de son parent.
+  bg_pixmap[NORMAL] = "<parent>"
+}
+
+style "button"
+{
+  # Voici tous les états possibles pour un bouton. Le seul qui ne peut
+  # s'appliquer est l'état SELECTED.
+  
+  fg[PRELIGHT] = { 0, 1.0, 1.0 }
+  bg[PRELIGHT] = { 0, 0, 1.0 }
+  bg[ACTIVE] = { 1.0, 0, 0 }
+  fg[ACTIVE] = { 0, 1.0, 0 }
+  bg[NORMAL] = { 1.0, 1.0, 0 }
+  fg[NORMAL] = { .99, 0, .99 }
+  bg[INSENSITIVE] = { 1.0, 1.0, 1.0 }
+  fg[INSENSITIVE] = { 1.0, 0, 1.0 }
+}
+
+# Dans cet exemple, on hérite des attributs du style "button" puis on 
+# écrase la fonte et la couleur de fond pour créer un nouveau style
+# "main_button".
+
+style "main_button" = "button"
+{
+  font = "-adobe-helvetica-medium-r-normal--*-100-*-*-*-*-*-*"
+  bg[PRELIGHT] = { 0.75, 0, 0 }
+}
+
+style "toggle_button" = "button"
+{
+  fg[NORMAL] = { 1.0, 0, 0 }
+  fg[ACTIVE] = { 1.0, 0, 0 }
+  
+  # Configure le pixmap de fond du toggle_button à celui de son widget
+  # parent (comme défini dans l'application).
+  bg_pixmap[NORMAL] = "<parent>"
+}
+
+style "text"
+{
+  bg_pixmap[NORMAL] = "marble.xpm"
+  fg[NORMAL] = { 1.0, 1.0, 1.0 }
+}
+
+style "ruler"
+{
+  font = "-adobe-helvetica-medium-r-normal--*-80-*-*-*-*-*-*"
+}
+
+# pixmap_path "~/.pixmaps"
+
+# Configuration des types de widget pour utiliser les styles définis
+# plus haut.
+# Les types de widget sont listés dans la hiérarchie des classes, mais
+# peut probablement être listée dans ce document pour que l'utilisateur
+# puisse s'y référer.
+
+widget_class "GtkWindow" style "window"
+widget_class "GtkDialog" style "window"
+widget_class "GtkFileSelection" style "window"
+widget_class "*Gtk*Scale" style "scale"
+widget_class "*GtkCheckButton*" style "toggle_button"
+widget_class "*GtkRadioButton*" style "toggle_button"
+widget_class "*GtkButton*" style "button"
+widget_class "*Ruler" style "ruler"
+widget_class "*GtkText" style "text"
+
+# Configure tous les boutons fils de la "main window" avec le style
+# main_button. Ceci doit être documenté pour en tirer profit.
+widget "main window.*GtkButton*" style "main_button"
+</verb></tscreen>
+
+<sect>Écriture de vos propres widgets 
+<p>
+<sect1>Vue d'ensemble
+<p>
+Bien que la distribution GTK fournisse de nombreux types de widgets
+qui devraient couvrir la plupart des besoins de base, il peut arriver
+un moment où vous aurez besoin de créer votre propre type de
+widget. Comme GTK utilise l'héritage de widget de façon intensive et
+qu'il y a déjà un widget ressemblant à celui que vous voulez, il est
+souvent possible de créer un nouveau type de widget en seulement
+quelques lignes de code. Mais, avant de travailler sur un nouveau
+widget, il faut vérifier d'abord que quelqu'un ne l'a pas déjà
+écrit. Ceci éviter la duplication des efforts et maintient au minimum
+le nombre de widgets, ce qui permet de garder la cohérence du code et
+de l'interface des différentes applications. Un effet de bord est que,
+lorsque l'on a créé un nouveau widget, il faut l'annoncer afin que les
+autres puissent en bénéficier. Le meilleur endroit pour faire cela
+est, sans doute, la <tt>gtk-list</tt>.
+
+<sect1>Anatomie d'un widget
+
+<p>
+Afin de créer un nouveau widget, il importe de comprendre comment
+fonctionnent les objets GTK. Cette section ne se veut être qu'un
+rapide survol. Consultez la documentation de référence pour plus de
+détails.
+
+<p>
+Les widgets sont implantés selon une méthode orientée
+objet. Cependant, ils sont écrits en C standard. Ceci améliore
+beaucoup la portabilité et la stabilité, par contre cela signifie que
+celui qui écrit des widgets doit faire attention à certains détails
+d'implantation. Les informations communes à toutes les instances d'une
+classe de widget (tous les widgets boutons, par exemple) sont stockées
+dans la <em/structure de la classe/.  Il n'y en a qu'une copie dans
+laquelle sont stockées les informations sur les signaux de la
+classe (fonctionnement identique aux fonctions virtuelles en C). Pour
+permettre l'héritage, le premier champ de la structure de classe doit
+être une copie de la structure de classe du père. La déclaration de la
+structure de classe de <em/GtkButton/ ressemble à ceci&nbsp;:
+
+<tscreen><verb>
+struct _GtkButtonClass
+{
+  GtkContainerClass parent_class;
+
+  void (* pressed)  (GtkButton *button);
+  void (* released) (GtkButton *button);
+  void (* clicked)  (GtkButton *button);
+  void (* enter)    (GtkButton *button);
+  void (* leave)    (GtkButton *button);
+};
+</verb></tscreen>
+
+<p>
+Lorsqu'un bouton est traité comme un container (par exemple, lorsqu'il
+change de taille), sa structure de classe peut être convertie en
+<em/GtkContainerClass/ et les champs adéquats utilisés pour gérer les
+signaux.
+
+<p>
+Il y a aussi une structure pour chaque widget créé sur une base
+d'instance. Cette structure a des champs pour stocker les informations
+qui sont différentes pour chaque instance du widget. Nous l'appelerons
+<em/structure d'objet/. Pour la classe <em/Button/, elle ressemble
+à&nbsp;:
+
+<tscreen><verb>
+struct _GtkButton
+{
+  GtkContainer container;
+
+  GtkWidget *child;
+
+  guint in_button : 1;
+  guint button_down : 1;
+};
+</verb></tscreen>
+
+<p>
+Notez que, comme pour la structure de classe, le premier champ est la
+structure d'objet de la classe parente, cette structure peut donc être
+convertie dans la structure d'objet de la classe parente si besoin
+est.
+
+<sect1> Création d'un widget composé
+
+<sect2> Introduction
+
+<p>
+Un type de widget qui peut être intéressant à créer est un widget qui
+est simplement un agrégat d'autres widgets GTK. Ce type de widget ne
+fait rien qui ne pourrait être fait sans créer de nouveaux widgets,
+mais offre une méthode pratique pour empaqueter les éléments d'une
+interface utilisateur afin de la réutiliser facilement. Les widgets
+<em/FileSelection/ et <em/ColorSelection/ de la distribution standard
+sont des exemples de ce type de widget.
+
+<p>
+L'exemple de widget que nous allons créer dans cette section créera un
+widget <em/Tictactoe/, un tableau de 3x3 boutons commutateurs qui
+déclenche un signal lorsque tous les boutons d'une ligne, d'une
+colonne, ou d'une diagonale sont pressés.
+
+<sect2> Choix d'une classe parent
+
+<p>
+La classe parent d'un widget composé est, typiquement, la classe
+container contenant tous les éléments du widget composé. Par exemple,
+la classe parent du widget <em/FileSelection/ est la classe
+<em/Dialog/. Comme nos boutons seront mis sous la forme d'un tableau,
+il semble naturel d'utiliser la classe <em/GtkTable/ comme
+parent. Malheureusement, cela ne peut marcher. La création d'un widget
+est divisée en deux fonctions -- <em/WIDGETNAME_new()/ que
+l'utilisateur appelle, et <em/WIDGETNAME_init()/ qui réalise le
+travail d'initialisation du widget indépendamment des paramètre passés
+à la fonction <tt/_new()/. Les widgets fils n'appellent que la
+fonction <em/_init/ de leur widget parent. Mais cette division du
+travail ne fonctionne pas bien avec les tableaux qui, lorsqu'ils sont
+créés, ont besoin de connaître leue nombre de lignes et de
+colonnes. Sauf à dupliquer la plupart des fonctionnalités de
+<em/gtk_table_new()/ dans notre widget <em/Tictactoe/, nous ferions
+mieux d'éviter de le dériver de <em/GtkTable/. Pour cette raison, nous
+la dériverons plutôt de <em/GtkVBox/ et nous placerons notre table
+dans la VBox.
+
+<sect2> The header file
+
+<p>
+Chaque classe de widget possède un fichier en-tête qui déclare les
+structures d'objet et de classe pour ce widget, en plus de fonctions
+publiques. Quelques caractéristiques méritent d'être indiquées. Afin
+d'éviter des définitions multiples, on enveloppe le fichier en-tête
+avec&nbsp:
+
+<tscreen><verb>
+#ifndef __TICTACTOE_H__
+#define __TICTACTOE_H__
+.
+.
+.
+#endif /* __TICTACTOE_H__ */
+</verb></tscreen>
+
+Et, pour faire plaisir aux programmes C++ qui inclueront ce fichier, on l'enveloppe aussi dans&nbsp;:
+
+<tscreen><verb>
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+.
+.
+.
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+</verb></tscreen>
+
+En plus des fonctions et structures, nous déclarons trois macros
+standard, <tt/TICTACTOE(obj)/, <tt/TICTACTOE_CLASS(class)/, et
+<tt/IS_TICTACTOE(obj)/, qui, respectivement, convertissent un pointeur
+en un pointeur vers une structure d'objet ou de classe, et vérifient
+si un objet est un widget Tictactoe.
+
+<p>
+Voici le fichier en-tête complet&nbsp;:
+
+<tscreen><verb>
+
+#ifndef __TICTACTOE_H__
+#define __TICTACTOE_H__
+
+#include <gdk/gdk.h>
+#include <gtk/gtkvbox.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#define TICTACTOE(obj)          GTK_CHECK_CAST (obj, tictactoe_get_type (), Tictactoe)
+#define TICTACTOE_CLASS(klass)  GTK_CHECK_CLASS_CAST (klass, tictactoe_get_type (), TictactoeClass)
+#define IS_TICTACTOE(obj)       GTK_CHECK_TYPE (obj, tictactoe_get_type ())
+
+
+typedef struct _Tictactoe       Tictactoe;
+typedef struct _TictactoeClass  TictactoeClass;
+
+struct _Tictactoe
+{
+  GtkVBox vbox;
+  
+  GtkWidget *buttons[3][3];
+};
+
+struct _TictactoeClass
+{
+  GtkVBoxClass parent_class;
+
+  void (* tictactoe) (Tictactoe *ttt);
+};
+
+guint          tictactoe_get_type        (void);
+GtkWidget*     tictactoe_new             (void);
+void	       tictactoe_clear           (Tictactoe *ttt);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __TICTACTOE_H__ */
+
+</verb></tscreen>
+
+<sect2>La fonction  <tt/_get_type()/
+
+<p>
+Continuons maintenant avec l'implantation de notre widget. La fonction
+centrale pour chaque widget est <em/WIDGETNAME_get_type()/. Cette
+fonction, lorsqu'elle est appelée pour la première fois, informe le
+GTK de la classe et récupère un ID permettant d'identifier celle-ci de
+façon unique. Lors des appels suivants, elle ne fait que retourner cet
+ID.
+
+<tscreen><verb>
+guint
+tictactoe_get_type ()
+{
+  static guint ttt_type = 0;
+
+  if (!ttt_type)
+    {
+      GtkTypeInfo ttt_info =
+      {
+	"Tictactoe",
+	sizeof (Tictactoe),
+	sizeof (TictactoeClass),
+	(GtkClassInitFunc) tictactoe_class_init,
+	(GtkObjectInitFunc) tictactoe_init,
+	(GtkArgFunc) NULL,
+      };
+
+      ttt_type = gtk_type_unique (gtk_vbox_get_type (), &amp;ttt_info);
+    }
+
+  return ttt_type;
+}
+</verb></tscreen>
+
+<p>
+La structure <em/GtkTypeInfo/ est définie de la façon suivante&nbsp;:
+
+<tscreen><verb>
+struct _GtkTypeInfo
+{
+  gchar *type_name;
+  guint object_size;
+  guint class_size;
+  GtkClassInitFunc class_init_func;
+  GtkObjectInitFunc object_init_func;
+  GtkArgFunc arg_func;
+};
+</verb></tscreen>
+
+<p>
+Les champs de cette structure s'expliquent d'eux-mêmes. Nous
+ignorerons le champ <em/arg_func/ ici&nbsp;: il a un rôle important
+permettant aux options des widgets d'être correctement initialisées à
+partir des langages interprétés, mais cette fonctionnalité est encore
+très peu implantée. Lorsque GTK dispose d'une copie correctement
+remplie de cette structure, il sait comment créer des objets d'un type
+particulier de widget.
+
+<sect2>La fonction <em/_class_init()/
+
+<p>
+La fonction <em/WIDGETNAME_class_init()/ initialise les champs de la
+structure de classe du widget et configure tous les signaux de cette
+classe. Pour notre widget Tictactoe, cet appel est&nbsp;:
+
+<tscreen><verb>
+
+enum {
+  TICTACTOE_SIGNAL,
+  LAST_SIGNAL
+};
+
+static gint tictactoe_signals[LAST_SIGNAL] = { 0 };
+
+static void
+tictactoe_class_init (TictactoeClass *class)
+{
+  GtkObjectClass *object_class;
+
+  object_class = (GtkObjectClass*) class;
+  
+  tictactoe_signals[TICTACTOE_SIGNAL] = gtk_signal_new ("tictactoe",
+					 GTK_RUN_FIRST,
+					 object_class->type,
+					 GTK_SIGNAL_OFFSET (TictactoeClass, tictactoe),
+					 gtk_signal_default_marshaller, GTK_ARG_NONE, 0);
+
+
+  gtk_object_class_add_signals (object_class, tictactoe_signals, LAST_SIGNAL);
+
+  class->tictactoe = NULL;
+}
+</verb></tscreen>
+
+<p>
+Notre widget n'a qu'un signal&nbsp;: "tictactoe", invoqué lorsqu'une
+ligne, une colonne ou une diagonale est complètement remplie. Tous les
+widgets composés n'ont pas besoin de signaux. Si vous lisez ceci pour
+la première fois, vous pouvez passer directement à la section suivante
+car les choses vont se compliquer un peu
+
+La fonction :
+
+<tscreen><verb>
+gint   gtk_signal_new                     (gchar               *name,
+					   GtkSignalRunType     run_type,
+					   gint                 object_type,
+					   gint                 function_offset,
+					   GtkSignalMarshaller  marshaller,
+					   GtkArgType           return_val,
+					   gint                 nparams,
+					   ...);
+</verb></tscreen>
+
+crée un nouveau signal. Les paramètres sont :
+
+<itemize>
+<item> <em/name/ : Le nom du signal signal.
+<item> <em/run_type/ : Indique si le gestionnaire par défaut doit être
+lancé avant ou après le gestionnaire de l'utilisateur. Le plus
+souvent, ce sera <tt/GTK_RUN_FIRST/, ou <tt/GTK_RUN_LAST/, bien qu'il
+y ait d'autres possibilités.
+
+<item> <em/object_type/ : L'ID de l'objet auquel s'applique ce signal
+(il s'appliquera aussi au descendants de l'objet).
+
+<item> <em/function_offset/ : L'offset d'un pointeur vers le
+gestionnaire par défaut dans la structure de classe.
+
+<item> <em/marshaller/ : Fonction utilisée pour invoquer le
+gestionnaire de signal. Pour les gestionnaires de signaux n'ayant pas
+d'autres paramètres que l'objet émetteur et les données utilisateur,
+on peut utiliser la fonction prédéfinie
+<em/gtk_signal_default_marshaller()/.
+
+<item> <em/return_val/ : Type de la valeur retournée.
+
+<item> <em/nparams/ : Nombre de paramètres du gestionnaire de signal
+(autres que les deux par défaut mentionnés plus haut).
+
+<item> <em/.../ : Types des paramètres.
+</itemize>
+
+Lorsque l'on spécifie les types, on utilise l'énumération
+<em/GtkArgType/&nbsp;:
+
+<tscreen><verb>
+typedef enum
+{
+  GTK_ARG_INVALID,
+  GTK_ARG_NONE,
+  GTK_ARG_CHAR,
+  GTK_ARG_SHORT,
+  GTK_ARG_INT,
+  GTK_ARG_LONG,
+  GTK_ARG_POINTER,
+  GTK_ARG_OBJECT,
+  GTK_ARG_FUNCTION,
+  GTK_ARG_SIGNAL
+} GtkArgType;
+</verb></tscreen>
+
+<p>
+<em/gtk_signal_new()/ retourne un identificateur entier pour le
+signal, que l'on stocke dans le tableau <em/tictactoe_signals/, indicé
+par une énumération (conventionnellement, les éléments de
+l'énumération sont le nom du signal, en majuscules, mais, ici, il y
+aurait un conflit avec la macro <tt/TICTACTOE()/, nous l'appellerons
+donc <tt/TICTACTOE_SIGNAL/ à la place.
+
+Après avoir créé nos signaux, nous devons demander à GTK d'associer
+ceux-ci à la classe Tictactoe. Ceci est fait en appelant
+<em/gtk_object_class_add_signals()/. Puis nous configurons le pointeur
+qui pointe sur le gestionnaire par défaut du signal "tictactoe" à
+NULL, pour indiquer qu'il n'y a pas d'action par défaut.
+
+<sect2>La fonction <em/_init()/
+<p>
+
+Chaque classe de widget a aussi besoin d'une fonction pour initialiser
+la structure d'objet. Habituellement, cette fonction a le rôle, plutôt
+limité, d'initialiser les champs de la structure avec des valeurs par
+défaut. Cependant, pour les widgets composés, cette fonction crée
+aussi les widgets composants.
+
+<tscreen><verb>
+
+static void
+tictactoe_init (Tictactoe *ttt)
+{
+  GtkWidget *table;
+  gint i,j;
+  
+  table = gtk_table_new (3, 3, TRUE);
+  gtk_container_add (GTK_CONTAINER(ttt), table);
+  gtk_widget_show (table);
+
+  for (i=0;i<3; i++)
+    for (j=0;j<3; j++)
+      {
+	ttt->buttons[i][j] = gtk_toggle_button_new ();
+	gtk_table_attach_defaults (GTK_TABLE(table), ttt->buttons[i][j], 
+				   i, i+1, j, j+1);
+	gtk_signal_connect (GTK_OBJECT (ttt->buttons[i][j]), "toggled",
+			    GTK_SIGNAL_FUNC (tictactoe_toggle), ttt);
+	gtk_widget_set_usize (ttt->buttons[i][j], 20, 20);
+	gtk_widget_show (ttt->buttons[i][j]);
+      }
+}
+</verb></tscreen>
+
+<sect2> Et le reste...
+<p>
+
+Il reste une fonction que chaque widget (sauf pour les types widget de
+base, comme <em/GtkBin/, qui ne peuvent être instanciés) à besoin
+d'avoir -- celle que l'utilisateur appelle pour créer un objet de ce
+type. Elle est conventionnellement appelée <em/WIDGETNAME_new()/. Pour
+certains widgets, par pour ceux de Tictactoe, cette fonction prend des
+paramètres et réalise certaines initialisations dépendantes des
+paramètres. Les deux autres fonctions sont spécifiques au widget
+Tictactoe.
+
+<p>
+<em/tictactoe_clear()/ est une fonction publique qui remet tous les
+boutons du widget en position relâchée. Notez l'utilisation de
+<em/gtk_signal_handler_block_by_data()/ pour empêcher notre
+gestionnaire de signaux des boutons commutateurs d'être déclenché sans
+besoin.
+
+<p>
+<em/tictactoe_toggle()/ est le gestionnaire de signal invoqué
+lorsqu'on clique sur un bouton. Il vérifie s'il y a des combinaisons
+gagnantes concernant le bouton qui vient d'être commuté et, si c'est
+le cas, émet le signal "tictactoe".
+
+<tscreen><verb>  
+GtkWidget*
+tictactoe_new ()
+{
+  return GTK_WIDGET ( gtk_type_new (tictactoe_get_type ()));
+}
+
+void	       
+tictactoe_clear (Tictactoe *ttt)
+{
+  int i,j;
+
+  for (i=0;i<3;i++)
+    for (j=0;j<3;j++)
+      {
+	gtk_signal_handler_block_by_data (GTK_OBJECT(ttt->buttons[i][j]), ttt);
+	gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (ttt->buttons[i][j]),
+				     FALSE);
+	gtk_signal_handler_unblock_by_data (GTK_OBJECT(ttt->buttons[i][j]), ttt);
+      }
+}
+
+static void
+tictactoe_toggle (GtkWidget *widget, Tictactoe *ttt)
+{
+  int i,k;
+
+  static int rwins[8][3] = { { 0, 0, 0 }, { 1, 1, 1 }, { 2, 2, 2 },
+			     { 0, 1, 2 }, { 0, 1, 2 }, { 0, 1, 2 },
+			     { 0, 1, 2 }, { 0, 1, 2 } };
+  static int cwins[8][3] = { { 0, 1, 2 }, { 0, 1, 2 }, { 0, 1, 2 },
+			     { 0, 0, 0 }, { 1, 1, 1 }, { 2, 2, 2 },
+			     { 0, 1, 2 }, { 2, 1, 0 } };
+
+  int success, found;
+
+  for (k=0; k<8; k++)
+    {
+      success = TRUE;
+      found = FALSE;
+
+      for (i=0;i<3;i++)
+	{
+	  success = success &amp;&amp; 
+	    GTK_TOGGLE_BUTTON(ttt->buttons[rwins[k][i]][cwins[k][i]])->active;
+	  found = found ||
+	    ttt->buttons[rwins[k][i]][cwins[k][i]] == widget;
+	}
+      
+      if (success &amp;&amp; found)
+	{
+	  gtk_signal_emit (GTK_OBJECT (ttt), 
+			   tictactoe_signals[TICTACTOE_SIGNAL]);
+	  break;
+	}
+    }
+}
+</verb></tscreen>
+
+<p>
+
+Enfin, un exemple de programme utilisant notre widget Tictactoe&nbsp;
+
+<tscreen><verb>
+#include <gtk/gtk.h>
+#include "tictactoe.h"
+
+/* Invoqué lorsqu'une ligne, une colonne ou une diagonale est complète */
+
+void win (GtkWidget *widget, gpointer data)
+{
+  g_print ("Ouais !\n");
+  tictactoe_clear (TICTACTOE (widget));
+}
+
+int main (int argc, char *argv[])
+{
+  GtkWidget *window;
+  GtkWidget *ttt;
+  
+  gtk_init (&amp;argc, &amp;argv);
+
+  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  
+  gtk_window_set_title (GTK_WINDOW (window), "Aspect Frame");
+  
+  gtk_signal_connect (GTK_OBJECT (window), "destroy",
+		      GTK_SIGNAL_FUNC (gtk_exit), NULL);
+  
+  gtk_container_border_width (GTK_CONTAINER (window), 10);
+
+  /* Création d'un widget Tictactoe */
+  ttt = tictactoe_new ();
+  gtk_container_add (GTK_CONTAINER (window), ttt);
+  gtk_widget_show (ttt);
+
+  /* On lui attache le signal "tictactoe" */
+  gtk_signal_connect (GTK_OBJECT (ttt), "tictactoe",
+		      GTK_SIGNAL_FUNC (win), NULL);
+
+  gtk_widget_show (window);
+  
+  gtk_main ();
+  
+  return 0;
+}
+
+</verb></tscreen>
+
+<sect1> Création d'un widget à partir de zéro
+
+<sect2> Introduction
+
+<p>
+
+Dans cette section, nous en apprendrons plus sur la façon dont les
+widgets s'affichent eux-mêmes à l'écran et comment ils interagissent
+avec les événements. Comme exemple, nous créerons un widget d'appel
+télephonique interactif avec un pointeur que l'utilisateur pourra
+déplacer pour initialiser la valeur.
+
+<sect2>Afficher un widget à l'écran
+<p>
+Il y a plusieurs étapes mises en jeu lors de l'affichage. Lorsque le widget est
+créé par l'appel <em/WIDGETNAME_new()/, plusieurs autres fonctions
+supplémentaires sont requises.
+
+<itemize>
+<item> <em/WIDGETNAME_realize()/ s'occupe de créer une fenêtre X pour le
+widget, s'il en a une.
+<item> <em/WIDGETNAME_map()/ est invoquée après l'appel de
+<em/gtk_widget_show()/. Elle s'assure que le widget est bien tracé à l'écran
+(<em/mappé/). Dans le cas d'une classe container, elle doit aussi appeler des
+fonctions <em/map()/> pour chaque widget fils.
+<item> <em/WIDGETNAME_draw()/ est invoquée lorsque <em/gtk_widget_draw()/ est
+appelé pour le widget ou l'un de ces ancêtres. Elle réalise les véritables
+appels aux fonctions de dessin pour tracer le widget à l'écran. Pour les
+widgets containers, cette fonction doit appeler <em/gtk_widget_draw()/ pour ses
+widgets fils.
+<item> <em/WIDGETNAME_expose()/ est un gestionnaire pour les événements
+d'exposition du widget. Il réalise les appels nécessaires aux fonctions de
+dessin pour tracer la partie exposée à l'écran. Pour les widgets containers,
+cette fonction doit générer les événements d'exposition pour ses widgets
+enfants n'ayant pas leurs propres fenêtres (s'ils ont leurs propres fenêtres, X
+génèrera les événements d'exposition nécessaires).
+</itemize>
+
+<p>
+Vous avez pu noter que les deux dernières fonctions sont assez similaires --
+chacune se charge de tracer le widget à l'écran. En fait, de nombreux types de
+widgets ne se préoccupent pas vraiment de la différence entre les deux. La
+fonction <em/draw()/ par défaut de la classe widget génère simplement un
+événement d'exposition synthétique pour la zone à redessiner. Cependant,
+certains types de widgets peuvent économiser du travail en faisant la
+différence entre les deux fonctions. Par exemple, si un widget a plusieurs
+fenêtres X et puisque les événements d'exposition identifient la fenêtre
+exposée, il peut redessiner seulement la fenêtre concernée, ce qui n'est pas
+possible avec des appels à <em/draw()/.
+
+<p>
+Les widgets container, même s'ils ne se soucient pas eux-mêmes de la
+différence, ne peuvent pas utiliser simplement la fonction <em/draw()/ car
+leurs widgets enfants tiennent compte de cette différence. Cependant, ce serait
+du gaspillage de dupliquer le code de tracé pour les deux
+fonctions. Conventionnellement, de tels widgets possèdent une fonction nommée
+<em/WIDGETNAME_paint()/ qui réalise le véritable travail de tracé du widget et
+qui est appelée par les fonctions <tt/draw()/ et <tt/expose()/.
+
+<p>
+Dans notre exemple, comme le widget d'appel n'est pas un widget container et
+n'a qu'une fenêtre, nous pouvons utiliser l'approche la plus simple&nbsp;:
+utiliser la fonction <em/draw()/ par défaut et n'implanter que la fonction
+<em/expose()/.
+
+<sect2>Origines du widget Dial
+
+<p>
+Exactement comme les animaux terrestres ne sont que des variantes des premiers
+amphibiens qui rampèrent hors de la boue, les widgets GTK sont des variantes
+d'autres widgets, déjà écrits. Ainsi, bien que cette section s'appelle « créer
+un widget à partir de zéro », le widget Dial commence réellement avec le code
+source du widget Range. Celui-ci a été pris comme point de départ car ce serait
+bien que notre Dial ait la même interface que les widgets Scale qui ne sont que
+des descendants spécialisés du widget Range. Par conséquent, bien que le code
+source soit présenté ci-dessous sous une forme achevée, cela n'implique pas
+qu'il a été écrit <em/deus ex machina/. De plus, si vous ne savez pas comment
+fonctionnent les widgets Scale du point de vue du programmeur de l'application,
+il est préférable de les étudier avant de continuer.
+
+<sect2>Les bases
+
+<p>
+Un petite partie de notre widget devrait ressembler au widget Tictactoe. Nous
+avons d'abord le fichier en-tête&nbsp;:
+
+<tscreen><verb>
+/* GTK - The GIMP Toolkit
+ * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef __GTK_DIAL_H__
+#define __GTK_DIAL_H__
+
+#include <gdk/gdk.h>
+#include <gtk/gtkadjustment.h>
+#include <gtk/gtkwidget.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+#define GTK_DIAL(obj)          GTK_CHECK_CAST (obj, gtk_dial_get_type (), GtkDial)
+#define GTK_DIAL_CLASS(klass)  GTK_CHECK_CLASS_CAST (klass, gtk_dial_get_type (), GtkDialClass)
+#define GTK_IS_DIAL(obj)       GTK_CHECK_TYPE (obj, gtk_dial_get_type ())
+
+
+typedef struct _GtkDial        GtkDial;
+typedef struct _GtkDialClass   GtkDialClass;
+
+struct _GtkDial
+{
+  GtkWidget widget;
+
+  /* politique de mise à jour  
+     (GTK_UPDATE_[CONTINUOUS/DELAYED/DISCONTINUOUS]) */
+
+  guint policy : 2;
+
+  /* Le bouton qui est pressé, 0 si aucun */
+  guint8 button;
+
+  /* Dimensions des composants de dial */
+  gint radius;
+  gint pointer_width;
+
+  /* ID du timer de mise à jour, 0 si aucun */
+  guint32 timer;
+
+  /* Angle courant*/
+  gfloat angle;
+
+  /* Anciennes valeurs d'ajustement stockées. On sait donc quand quelque
+     chose change */
+  gfloat old_value;
+  gfloat old_lower;
+  gfloat old_upper;
+
+  /* L'objet ajustment qui stocke les données de cet appel */
+  GtkAdjustment *adjustment;
+};
+
+struct _GtkDialClass
+{
+  GtkWidgetClass parent_class;
+};
+
+
+GtkWidget*     gtk_dial_new                    (GtkAdjustment *adjustment);
+guint          gtk_dial_get_type               (void);
+GtkAdjustment* gtk_dial_get_adjustment         (GtkDial      *dial);
+void           gtk_dial_set_update_policy      (GtkDial      *dial,
+						GtkUpdateType  policy);
+
+void           gtk_dial_set_adjustment         (GtkDial      *dial,
+						GtkAdjustment *adjustment);
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GTK_DIAL_H__ */
+
+</verb></tscreen>
+
+Comme il y a plus de choses à faire avec ce widget par rapport à l'autre, nous
+avons plus de champs dans la structure de données, mais à part ça, les choses
+sont plutôt similaires.
+
+<p>
+
+Puis, après avoir inclus les fichiers en-tête et déclaré quelques constantes,
+nous devons fournir quelques fonctions pour donner des informations sur le
+widget et pour l'initialiser&nbsp;:
+
+<tscreen><verb>
+#include <math.h>
+#include <stdio.h>
+#include <gtk/gtkmain.h>
+#include <gtk/gtksignal.h>
+
+#include "gtkdial.h"
+
+#define SCROLL_DELAY_LENGTH  300
+#define DIAL_DEFAULT_SIZE 100
+
+/* Déclararations des prototypes */
+
+[ omis pour gagner de la place ]
+
+/* Données locales */
+
+static GtkWidgetClass *parent_class = NULL;
+
+guint
+gtk_dial_get_type ()
+{
+  static guint dial_type = 0;
+
+  if (!dial_type)
+    {
+      GtkTypeInfo dial_info =
+      {
+	"GtkDial",
+	sizeof (GtkDial),
+	sizeof (GtkDialClass),
+	(GtkClassInitFunc) gtk_dial_class_init,
+	(GtkObjectInitFunc) gtk_dial_init,
+	(GtkArgFunc) NULL,
+      };
+
+      dial_type = gtk_type_unique (gtk_widget_get_type (), &amp;dial_info);
+    }
+
+  return dial_type;
+}
+
+static void
+gtk_dial_class_init (GtkDialClass *class)
+{
+  GtkObjectClass *object_class;
+  GtkWidgetClass *widget_class;
+
+  object_class = (GtkObjectClass*) class;
+  widget_class = (GtkWidgetClass*) class;
+
+  parent_class = gtk_type_class (gtk_widget_get_type ());
+
+  object_class->destroy = gtk_dial_destroy;
+
+  widget_class->realize = gtk_dial_realize;
+  widget_class->expose_event = gtk_dial_expose;
+  widget_class->size_request = gtk_dial_size_request;
+  widget_class->size_allocate = gtk_dial_size_allocate;
+  widget_class->button_press_event = gtk_dial_button_press;
+  widget_class->button_release_event = gtk_dial_button_release;
+  widget_class->motion_notify_event = gtk_dial_motion_notify;
+}
+
+static void
+gtk_dial_init (GtkDial *dial)
+{
+  dial->button = 0;
+  dial->policy = GTK_UPDATE_CONTINUOUS;
+  dial->timer = 0;
+  dial->radius = 0;
+  dial->pointer_width = 0;
+  dial->angle = 0.0;
+  dial->old_value = 0.0;
+  dial->old_lower = 0.0;
+  dial->old_upper = 0.0;
+  dial->adjustment = NULL;
+}
+
+GtkWidget*
+gtk_dial_new (GtkAdjustment *adjustment)
+{
+  GtkDial *dial;
+
+  dial = gtk_type_new (gtk_dial_get_type ());
+
+  if (!adjustment)
+    adjustment = (GtkAdjustment*) gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
+
+  gtk_dial_set_adjustment (dial, adjustment);
+
+  return GTK_WIDGET (dial);
+}
+
+static void
+gtk_dial_destroy (GtkObject *object)
+{
+  GtkDial *dial;
+
+  g_return_if_fail (object != NULL);
+  g_return_if_fail (GTK_IS_DIAL (object));
+
+  dial = GTK_DIAL (object);
+
+  if (dial->adjustment)
+    gtk_object_unref (GTK_OBJECT (dial->adjustment));
+
+  if (GTK_OBJECT_CLASS (parent_class)->destroy)
+    (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
+}
+</verb></tscreen>
+
+Notez que cette fonction <em/init()/ fait moins de choses que pour le widget
+Tictactoe car ce n'est pas un widget composé et que la fonction <em/new()/ en
+fait plus car elle a maintenant un paramètre. Notez aussi que lorsque nous
+stockons un pointeur vers l'objet Adjustement, nous incrémentons son nombre de
+références (et nous le décrémentons lorsque nous ne l'utilisons plus) afin que
+GTK puisse savoir quand il pourra être détruit sans danger.
+
+<p>
+Il y a aussi quelques fonctions pour manipuler les options du widget&nbsp;:
+
+<tscreen><verb>
+GtkAdjustment*
+gtk_dial_get_adjustment (GtkDial *dial)
+{
+  g_return_val_if_fail (dial != NULL, NULL);
+  g_return_val_if_fail (GTK_IS_DIAL (dial), NULL);
+
+  return dial->adjustment;
+}
+
+void
+gtk_dial_set_update_policy (GtkDial      *dial,
+			     GtkUpdateType  policy)
+{
+  g_return_if_fail (dial != NULL);
+  g_return_if_fail (GTK_IS_DIAL (dial));
+
+  dial->policy = policy;
+}
+
+void
+gtk_dial_set_adjustment (GtkDial      *dial,
+			  GtkAdjustment *adjustment)
+{
+  g_return_if_fail (dial != NULL);
+  g_return_if_fail (GTK_IS_DIAL (dial));
+
+  if (dial->adjustment)
+    {
+      gtk_signal_disconnect_by_data (GTK_OBJECT (dial->adjustment), (gpointer) dial);
+      gtk_object_unref (GTK_OBJECT (dial->adjustment));
+    }
+
+  dial->adjustment = adjustment;
+  gtk_object_ref (GTK_OBJECT (dial->adjustment));
+
+  gtk_signal_connect (GTK_OBJECT (adjustment), "changed",
+		      (GtkSignalFunc) gtk_dial_adjustment_changed,
+		      (gpointer) dial);
+  gtk_signal_connect (GTK_OBJECT (adjustment), "value_changed",
+		      (GtkSignalFunc) gtk_dial_adjustment_value_changed,
+		      (gpointer) dial);
+
+  dial->old_value = adjustment->value;
+  dial->old_lower = adjustment->lower;
+  dial->old_upper = adjustment->upper;
+
+  gtk_dial_update (dial);
+}
+</verb></tscreen>
+
+<sect2> <em/gtk_dial_realize()/
+
+<p>
+Nous arrivons maintenant à quelques nouveaux types de fonctions. D'abord, nous
+avons une fonction qui réalise la création de la fenêtre X. Notez que l'on
+passe un masque à la fonction <em/gdk_window_new()/ pour spécifier quels sont
+les champs de la structure GdkWindowAttr qui contiennent des données (les
+autres recevront des valeurs par défaut). Notez aussi la façon dont est créé le
+masque d'événement du widget. On appelle <em/gtk_widget_get_events()/ pour
+récupérer le masque d'événement que l'utilisateur a spécifié pour ce widget
+(avec <em/gtk_widget_set_events()/) et ajouter les événements qui nous
+intéressent.
+
+<p>
+Après avoir créé la fenêtre, nous configurons son style et son fond et mettons
+un pointeur vers le widget dans le champ user de la GdkWindow. Cette dernière
+étape permet à GTK de distribuer les événements pour cette fenêtre au widget
+correct.
+
+<tscreen><verb>
+static void
+gtk_dial_realize (GtkWidget *widget)
+{
+  GtkDial *dial;
+  GdkWindowAttr attributes;
+  gint attributes_mask;
+
+  g_return_if_fail (widget != NULL);
+  g_return_if_fail (GTK_IS_DIAL (widget));
+
+  GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
+  dial = GTK_DIAL (widget);
+
+  attributes.x = widget->allocation.x;
+  attributes.y = widget->allocation.y;
+  attributes.width = widget->allocation.width;
+  attributes.height = widget->allocation.height;
+  attributes.wclass = GDK_INPUT_OUTPUT;
+  attributes.window_type = GDK_WINDOW_CHILD;
+  attributes.event_mask = gtk_widget_get_events (widget) | 
+    GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | 
+    GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK |
+    GDK_POINTER_MOTION_HINT_MASK;
+  attributes.visual = gtk_widget_get_visual (widget);
+  attributes.colormap = gtk_widget_get_colormap (widget);
+
+  attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
+  widget->window = gdk_window_new (widget->parent->window, &amp;attributes, attributes_mask);
+
+  widget->style = gtk_style_attach (widget->style, widget->window);
+
+  gdk_window_set_user_data (widget->window, widget);
+
+  gtk_style_set_background (widget->style, widget->window, GTK_STATE_ACTIVE);
+}
+</verb></tscreen>
+
+<sect2>Négotiation de la taille
+
+<p>
+Avant le premier affichage de la fenêtre contenant un widget et à chaque fois
+que la forme de la fenêtre change, GTK demande à chaque widget fils la taille
+qu'il désire avoir. Cette requête est gérée par la fonction
+<em/gtk_dial_size_request()/. Comme notre widget n'est pas un widget container,
+et n'a pas de contraintes réelles sur sa taille, nous ne faisons que retourner
+une valeur raisonnable par défaut.
+
+<tscreen><verb>
+static void 
+gtk_dial_size_request (GtkWidget      *widget,
+		       GtkRequisition *requisition)
+{
+  requisition->width = DIAL_DEFAULT_SIZE;
+  requisition->height = DIAL_DEFAULT_SIZE;
+}
+</verb></tscreen>
+
+<p>
+Lorsque tous les widgets on demandé une taille idéale, le forme de la fenêtre
+est calculée et chaque widget fils est averti de sa taille. Habituellement, ce
+sera autant que la taille requise, mais si, par exemple, l'utilisateur a
+redimensionné la fenêtre, cette taille peut occasionnellement être plus petite
+que la taille requise. La notification de la taille est gérée par la fonction
+<em/gtk_dial_size_allocate()/. Notez qu'en même temps qu'elle calcule les
+tailles de certains composants pour une utilisation future, cette routine fait
+aussi le travail de base consistant à déplacer les widgets X Window dans leur
+nouvelles positions et tailles.
+
+<tscreen><verb>
+static void
+gtk_dial_size_allocate (GtkWidget     *widget,
+			GtkAllocation *allocation)
+{
+  GtkDial *dial;
+
+  g_return_if_fail (widget != NULL);
+  g_return_if_fail (GTK_IS_DIAL (widget));
+  g_return_if_fail (allocation != NULL);
+
+  widget->allocation = *allocation;
+  if (GTK_WIDGET_REALIZED (widget))
+    {
+      dial = GTK_DIAL (widget);
+
+      gdk_window_move_resize (widget->window,
+			      allocation->x, allocation->y,
+			      allocation->width, allocation->height);
+
+      dial->radius = MAX(allocation->width,allocation->height) * 0.45;
+      dial->pointer_width = dial->radius / 5;
+    }
+}
+</verb></tscreen>.
+
+<sect2> <em/gtk_dial_expose()/
+
+<p>
+Comme cela est mentionné plus haut, tout le dessin de ce widget est réalisé
+dans le gestionnaire pour les événements d'exposition. Il n'y a pas grand chose
+de plus à dire là dessus, sauf constater l'utilisation de la fonction
+<em/gtk_draw_polygon/ pour dessiner le pointeur avec une forme en trois
+dimensions selon les couleurs stockées dans le style du widget. 
+style.
+
+<tscreen><verb>
+static gint
+gtk_dial_expose (GtkWidget      *widget,
+		 GdkEventExpose *event)
+{
+  GtkDial *dial;
+  GdkPoint points[3];
+  gdouble s,c;
+  gdouble theta;
+  gint xc, yc;
+  gint tick_length;
+  gint i;
+
+  g_return_val_if_fail (widget != NULL, FALSE);
+  g_return_val_if_fail (GTK_IS_DIAL (widget), FALSE);
+  g_return_val_if_fail (event != NULL, FALSE);
+
+  if (event->count > 0)
+    return FALSE;
+  
+  dial = GTK_DIAL (widget);
+
+  gdk_window_clear_area (widget->window,
+			 0, 0,
+			 widget->allocation.width,
+			 widget->allocation.height);
+
+  xc = widget->allocation.width/2;
+  yc = widget->allocation.height/2;
+
+  /* Draw ticks */
+
+  for (i=0; i<25; i++)
+    {
+      theta = (i*M_PI/18. - M_PI/6.);
+      s = sin(theta);
+      c = cos(theta);
+
+      tick_length = (i%6 == 0) ? dial->pointer_width : dial->pointer_width/2;
+      
+      gdk_draw_line (widget->window,
+		     widget->style->fg_gc[widget->state],
+		     xc + c*(dial->radius - tick_length),
+		     yc - s*(dial->radius - tick_length),
+		     xc + c*dial->radius,
+		     yc - s*dial->radius);
+    }
+
+  /* Draw pointer */
+
+  s = sin(dial->angle);
+  c = cos(dial->angle);
+
+
+  points[0].x = xc + s*dial->pointer_width/2;
+  points[0].y = yc + c*dial->pointer_width/2;
+  points[1].x = xc + c*dial->radius;
+  points[1].y = yc - s*dial->radius;
+  points[2].x = xc - s*dial->pointer_width/2;
+  points[2].y = yc - c*dial->pointer_width/2;
+
+  gtk_draw_polygon (widget->style,
+		    widget->window,
+		    GTK_STATE_NORMAL,
+		    GTK_SHADOW_OUT,
+		    points, 3,
+		    TRUE);
+  
+  return FALSE;
+}
+</verb></tscreen>
+
+<sect2>Gestion des événements
+
+<p>
+Le reste du code du widget gère différents types d'événements et n'est pas
+trop différent de ce que l'on trouve dans la plupart des applications GTK. Deux
+types d'événements peuvent survenir -- l'utilisateur peut cliquer sur le widget
+avec la souris et faire glisser pour déplacer le pointeur, ou bien la valeur de
+l'objet Adjustment peut changer à cause d'une circonstance extérieure.
+
+<p>
+Lorsque l'utilisateur clique sur le widget, on vérifie si le clic s'est bien
+passé près du pointeur et si c'est le cas, on stocke alors le bouton avec
+lequel l'utilisateur a cliqué dans le champ <em/button/ de la structure du
+widget et on récupère tous les événements souris avec un appel à
+<em/gtk_grab_add()/. Un déplacement ultérieur de la souris provoque le recalcul
+de la valeur de contrôle (par la fonction <em/gtk_dial_update_mouse/). Selon la
+politique qui a été choisie, les événements "value_changed" sont, soit générés
+instantanément (<em/GTK_UPDATE_CONTINUOUS/), après un délai ajouté au timer
+avec <em/gtk_timeout_add()/ (<em/GTK_UPDATE_DELAYED/), ou seulement lorsque le
+bouton est relâché (<em/GTK_UPDATE_DISCONTINUOUS/).
+
+<tscreen><verb>
+static gint
+gtk_dial_button_press (GtkWidget      *widget,
+		       GdkEventButton *event)
+{
+  GtkDial *dial;
+  gint dx, dy;
+  double s, c;
+  double d_parallel;
+  double d_perpendicular;
+
+  g_return_val_if_fail (widget != NULL, FALSE);
+  g_return_val_if_fail (GTK_IS_DIAL (widget), FALSE);
+  g_return_val_if_fail (event != NULL, FALSE);
+
+  dial = GTK_DIAL (widget);
+
+  /* Détermine si le bouton pressé est dans la région du pointeur.
+     On fait cela en calculant les distances parallèle et perpendiculaire
+     du point où la souris a été pressée par rapport à la ligne passant
+     par le pointeur */
+  
+  dx = event->x - widget->allocation.width / 2;
+  dy = widget->allocation.height / 2 - event->y;
+  
+  s = sin(dial->angle);
+  c = cos(dial->angle);
+  
+  d_parallel = s*dy + c*dx;
+  d_perpendicular = fabs(s*dx - c*dy);
+  
+  if (!dial->button &&
+      (d_perpendicular < dial->pointer_width/2) &&
+      (d_parallel > - dial->pointer_width))
+    {
+      gtk_grab_add (widget);
+
+      dial->button = event->button;
+
+      gtk_dial_update_mouse (dial, event->x, event->y);
+    }
+
+  return FALSE;
+}
+
+static gint
+gtk_dial_button_release (GtkWidget      *widget,
+			  GdkEventButton *event)
+{
+  GtkDial *dial;
+
+  g_return_val_if_fail (widget != NULL, FALSE);
+  g_return_val_if_fail (GTK_IS_DIAL (widget), FALSE);
+  g_return_val_if_fail (event != NULL, FALSE);
+
+  dial = GTK_DIAL (widget);
+
+  if (dial->button == event->button)
+    {
+      gtk_grab_remove (widget);
+
+      dial->button = 0;
+
+      if (dial->policy == GTK_UPDATE_DELAYED)
+	gtk_timeout_remove (dial->timer);
+      
+      if ((dial->policy != GTK_UPDATE_CONTINUOUS) &&
+	  (dial->old_value != dial->adjustment->value))
+	gtk_signal_emit_by_name (GTK_OBJECT (dial->adjustment), "value_changed");
+    }
+
+  return FALSE;
+}
+
+static gint
+gtk_dial_motion_notify (GtkWidget      *widget,
+			 GdkEventMotion *event)
+{
+  GtkDial *dial;
+  GdkModifierType mods;
+  gint x, y, mask;
+
+  g_return_val_if_fail (widget != NULL, FALSE);
+  g_return_val_if_fail (GTK_IS_DIAL (widget), FALSE);
+  g_return_val_if_fail (event != NULL, FALSE);
+
+  dial = GTK_DIAL (widget);
+
+  if (dial->button != 0)
+    {
+      x = event->x;
+      y = event->y;
+
+      if (event->is_hint || (event->window != widget->window))
+	gdk_window_get_pointer (widget->window, &amp;x, &amp;y, &amp;mods);
+
+      switch (dial->button)
+	{
+	case 1:
+	  mask = GDK_BUTTON1_MASK;
+	  break;
+	case 2:
+	  mask = GDK_BUTTON2_MASK;
+	  break;
+	case 3:
+	  mask = GDK_BUTTON3_MASK;
+	  break;
+	default:
+	  mask = 0;
+	  break;
+	}
+
+      if (mods & mask)
+	gtk_dial_update_mouse (dial, x,y);
+    }
+
+  return FALSE;
+}
+
+static gint
+gtk_dial_timer (GtkDial *dial)
+{
+  g_return_val_if_fail (dial != NULL, FALSE);
+  g_return_val_if_fail (GTK_IS_DIAL (dial), FALSE);
+
+  if (dial->policy == GTK_UPDATE_DELAYED)
+    gtk_signal_emit_by_name (GTK_OBJECT (dial->adjustment), "value_changed");
+
+  return FALSE;
+}
+
+static void
+gtk_dial_update_mouse (GtkDial *dial, gint x, gint y)
+{
+  gint xc, yc;
+  gfloat old_value;
+
+  g_return_if_fail (dial != NULL);
+  g_return_if_fail (GTK_IS_DIAL (dial));
+
+  xc = GTK_WIDGET(dial)->allocation.width / 2;
+  yc = GTK_WIDGET(dial)->allocation.height / 2;
+
+  old_value = dial->adjustment->value;
+  dial->angle = atan2(yc-y, x-xc);
+
+  if (dial->angle < -M_PI/2.)
+    dial->angle += 2*M_PI;
+
+  if (dial->angle < -M_PI/6)
+    dial->angle = -M_PI/6;
+
+  if (dial->angle > 7.*M_PI/6.)
+    dial->angle = 7.*M_PI/6.;
+
+  dial->adjustment->value = dial->adjustment->lower + (7.*M_PI/6 - dial->angle) *
+    (dial->adjustment->upper - dial->adjustment->lower) / (4.*M_PI/3.);
+
+  if (dial->adjustment->value != old_value)
+    {
+      if (dial->policy == GTK_UPDATE_CONTINUOUS)
+	{
+	  gtk_signal_emit_by_name (GTK_OBJECT (dial->adjustment), "value_changed");
+	}
+      else
+	{
+	  gtk_widget_draw (GTK_WIDGET(dial), NULL);
+
+	  if (dial->policy == GTK_UPDATE_DELAYED)
+	    {
+	      if (dial->timer)
+		gtk_timeout_remove (dial->timer);
+
+	      dial->timer = gtk_timeout_add (SCROLL_DELAY_LENGTH,
+					     (GtkFunction) gtk_dial_timer,
+					     (gpointer) dial);
+	    }
+	}
+    }
+}
+</verb></tscreen>
+
+<p>
+Les changements de l'Adjustement par des moyens extérieurs sont communiqués à
+notre widget par les signaux "changed" et "value_changed". Les gestionnaires
+pour ces fonctions appellent <em/gtk_dial_update()/ pour valider les
+paramètres, calculer le nouvel angle du pointeur et redessiner le widget (en
+appelant <em/gtk_widget_draw()/).
+
+<tscreen><verb>
+static void
+gtk_dial_update (GtkDial *dial)
+{
+  gfloat new_value;
+  
+  g_return_if_fail (dial != NULL);
+  g_return_if_fail (GTK_IS_DIAL (dial));
+
+  new_value = dial->adjustment->value;
+  
+  if (new_value < dial->adjustment->lower)
+    new_value = dial->adjustment->lower;
+
+  if (new_value > dial->adjustment->upper)
+    new_value = dial->adjustment->upper;
+
+  if (new_value != dial->adjustment->value)
+    {
+      dial->adjustment->value = new_value;
+      gtk_signal_emit_by_name (GTK_OBJECT (dial->adjustment), "value_changed");
+    }
+
+  dial->angle = 7.*M_PI/6. - (new_value - dial->adjustment->lower) * 4.*M_PI/3. /
+    (dial->adjustment->upper - dial->adjustment->lower);
+
+  gtk_widget_draw (GTK_WIDGET(dial), NULL);
+}
+
+static void
+gtk_dial_adjustment_changed (GtkAdjustment *adjustment,
+			      gpointer       data)
+{
+  GtkDial *dial;
+
+  g_return_if_fail (adjustment != NULL);
+  g_return_if_fail (data != NULL);
+
+  dial = GTK_DIAL (data);
+
+  if ((dial->old_value != adjustment->value) ||
+      (dial->old_lower != adjustment->lower) ||
+      (dial->old_upper != adjustment->upper))
+    {
+      gtk_dial_update (dial);
+
+      dial->old_value = adjustment->value;
+      dial->old_lower = adjustment->lower;
+      dial->old_upper = adjustment->upper;
+    }
+}
+
+static void
+gtk_dial_adjustment_value_changed (GtkAdjustment *adjustment,
+				    gpointer       data)
+{
+  GtkDial *dial;
+
+  g_return_if_fail (adjustment != NULL);
+  g_return_if_fail (data != NULL);
+
+  dial = GTK_DIAL (data);
+
+  if (dial->old_value != adjustment->value)
+    {
+      gtk_dial_update (dial);
+
+      dial->old_value = adjustment->value;
+    }
+}
+</verb></tscreen>
+
+<sect2>Améliorations possibles
+
+<p>
+
+Le widget Dial décrit jusqu'à maintenant exécute à peu près 670 lignes de
+code. Bien que cela puisse sembler beaucoup, nous en avons vraiment fait
+beaucoup avec ce code, notamment parce que la majeure partie de cette longueur
+est due aux en-têtes et à la préparation. Cependant, certaines améliorations
+peuvent être apportées à ce widget&nbsp;:
+
+<itemize>
+<item> Si vous testez ce widget, vous vous apercevrez qu'il y a un peu de
+scintillement lorsque le pointeur est déplacé. Ceci est dû au fait que le
+widget entier est effacé, puis redessiné  à chaque mouvement du
+pointeur. Souvent, la meilleure façon de gérer ce problème est de dessiner sur
+un pixmap non affiché, puis de copier le résultat final sur l'écran en une
+seule étape (le widget <em/ProgressBar/ se dessine de cette façon).
+
+<item> L'utilisateur devrait pouvoir utiliser les flèches du curseur vers le
+haut et vers le bas pour incrémenter et décrémenter la valeur.
+
+<item> Ce serait bien si le widget avait des boutons pour augmenter et diminuer
+la valeur dans de petites ou de grosses proportions. Bien qu'il serait possible
+d'utiliser les widgets <em/Button/ pour cela, nous voudrions aussi que les
+boutons s'auto-répètent lorsqu'ils sont maintenus appuyés, comme font les
+flèches d'une barre de défilement. La majeure partie du code pour implanter ce
+type de comportement peut se trouver dans le widget <em/GtkRange/.
+
+<item> Le widget Dial pourrait être fait dans un widget container avec un seul
+widget fils positionnée en bas, entre les boutons mentionnés
+ci-dessus. L'utilisateur pourrait alors ajouter au choix, un widget label ou
+entrée pour afficher la valeur courante de l'appel.
+
+</itemize>
+
+<sect1>En savoir plus
+
+<p>
+Seule une petite partie des nombreux détails de la création des widgets a pu
+être décrite. Si vous désirez écrire vos propres widgets, la meilleure source
+d'exemples est le source de GTK lui-même. Posez-vous quelques questions sur les
+widgets que vous voulez écrire&nbsp;: est-ce un widget container ? possède-t-il
+sa propre fenêtre ? est-ce une modification d'un widget existant ? Puis,
+trouvez un widget identique et commencez à faire les modifications. Bonne
+chance !
+
+<sect>Scribble, un programme simple de dessin
+
+<sect1>Présentation
+
+<p>
+Dans cette section, nous construirons un programme simple de dessin. Ce
+faisant, nous examinerons comment gérer les événements souris, comment dessiner
+dans une fenêtre, et comment mieux dessiner en utilisant un pixmap en arrière
+plan. Après avoir créé ce programme, nous l'étendrons en lui ajoutant le
+support des périphériques <em/Xinput/, comme les tables de tracé. GTK dispose
+de routines de support qui facilitent beaucoup l'obtention des informations
+étendues (comme la pression et l'inclinaison du stylet) à partir de tels
+périphériques.
+
+<sect1>Gestion d'événement
+
+<p>
+Les signaux GTK que nous avons déjà vus concernent les actions de haut niveau,
+comme la sélection d'un choix d'un menu. Cependant, il est quelques fois utile
+de connaître les cas de bas niveau, comme le déplacement de la souris, ou la
+pression d'une touche. Il existe aussi des signaux GTK correspondant à ces
+<em/événements/ bas niveau. Les gestionnaires de ces signaux ont un paramètre
+supplémentaire qui est un pointeur vers une structure contenant des
+informations sur l'événement. Par exemple, les gestionnaires des événements de
+déplacement recoivent un paramètre vers une structure <em/GdkEventMotion/ qui
+ressemble (en partie) à ceci&nbsp;:
+
+<tscreen><verb>
+struct _GdkEventMotion
+{
+  GdkEventType type;
+  GdkWindow *window;
+  guint32 time;
+  gdouble x;
+  gdouble y;
+  ...
+  guint state;
+  ...
+};
+</verb></tscreen>
+
+<em/type/ sera initialisé avec le type de l'événement, ici
+<em/GDK_MOTION_NOTIFY/, <em/window/ est la fenêtre dans laquelle l'événement
+est survenu. <em/x/ et <em/y/ donnent les coordonnées de l'événement et
+<em/state/ spécifie l'état du modificateur lorsque l'événement s'est produit
+(c'est-à-dire quelles sont les touches de modification et les boutons souris
+qui ont été pressés). Il s'agit d'un OU bit à bit de l'une des valeurs
+suivantes&nbsp;: 
+
+<tscreen><verb>
+GDK_SHIFT_MASK  
+GDK_LOCK_MASK   
+GDK_CONTROL_MASK
+GDK_MOD1_MASK   
+GDK_MOD2_MASK   
+GDK_MOD3_MASK   
+GDK_MOD4_MASK   
+GDK_MOD5_MASK   
+GDK_BUTTON1_MASK
+GDK_BUTTON2_MASK
+GDK_BUTTON3_MASK
+GDK_BUTTON4_MASK
+GDK_BUTTON5_MASK
+</verb></tscreen>
+
+<p>
+Comme pour les autres signaux, on appelle <em/gtk_signal_connect()/ pour
+déterminer ce qui se passe lorsqu'un événement survient. Mais nous devons aussi
+faire en sorte que GTK sache de quels événements nous voulons être
+avertis. Pour ce faire, on appelle la fonction&nbsp;:
+
+<tscreen><verb>
+void       gtk_widget_set_events          (GtkWidget           *widget,
+					   gint                 events);
+</verb></tscreen>
+
+Le deuxième champ spécifie les événements qui nous intéressent. Il s'agit d'un
+OU bit à bit de constantes qui indiquent différent types d'événements. Pour 
+référence ultérieure, les types d'événements sont&nbsp;:
+
+<tscreen><verb>
+GDK_EXPOSURE_MASK
+GDK_POINTER_MOTION_MASK
+GDK_POINTER_MOTION_HINT_MASK
+GDK_BUTTON_MOTION_MASK     
+GDK_BUTTON1_MOTION_MASK    
+GDK_BUTTON2_MOTION_MASK    
+GDK_BUTTON3_MOTION_MASK    
+GDK_BUTTON_PRESS_MASK      
+GDK_BUTTON_RELEASE_MASK    
+GDK_KEY_PRESS_MASK         
+GDK_KEY_RELEASE_MASK       
+GDK_ENTER_NOTIFY_MASK      
+GDK_LEAVE_NOTIFY_MASK      
+GDK_FOCUS_CHANGE_MASK      
+GDK_STRUCTURE_MASK         
+GDK_PROPERTY_CHANGE_MASK   
+GDK_PROXIMITY_IN_MASK      
+GDK_PROXIMITY_OUT_MASK     
+</verb></tscreen>
+
+Il y a quelques points subtils qui doivent être observés lorsqu'on appelle
+<em/gtk_widget_set_events()/. D'abord, elle doit être appelée avant que la
+fenêtre X d'un widget GTK soit créée. En pratique, cela signifie que l'on doit
+l'appeler immédiatement après avoir créé le widget. Ensuite, le widget doit
+avoir une fenêtre X associée. Pour des raisons d'efficacité, de nombreux types
+de widgets n'ont pas de fenêtre propre, mais se dessinent dans la fenêtre de
+leur parent. Ces widgets sont&nbsp;:
+
+<tscreen><verb>
+GtkAlignment
+GtkArrow
+GtkBin
+GtkBox
+GtkImage
+GtkItem
+GtkLabel
+GtkPaned
+GtkPixmap
+GtkScrolledWindow
+GtkSeparator
+GtkTable
+GtkViewport
+GtkAspectFrame
+GtkFrame
+GtkVPaned
+GtkHPaned
+GtkVBox
+GtkHBox
+GtkVSeparator
+GtkHSeparator
+</verb></tscreen>
+
+Pour capturer les événements pour ces widgets, on doit utiliser un widget
+<em/EventBox/. Voir la section sur <ref id="sec_The_EventBox_Widget" name="Le
+widget EventBox"> pour plus de détails.
+
+<p>
+Pour notre programme de dessin, on veut savoir quand le bouton de la souris est
+pressé et quand la souris est déplacée, nous indiquons donc
+<em/GDK_POINTER_MOTION_MASK/ et <em/GDK_BUTTON_PRESS_MASK/. On veut aussi
+savoir quand il est nécessaire de redessiner notre fenêtre, on indique donc
+<em/GDK_EXPOSURE_MASK/. Bien que nous voulions être avertis via un événement
+<em/Configure/ lorsque la taille de notre fenêtre change, on n'a pas besoin de
+préciser le flag <em/GDK_STRUCTURE_MASK/ correspondant car il est
+automatiquement spécifié pour chaque fenêtre.
+
+<p>
+Il arrive cependant qu'il puisse y avoir un problème en indiquant seulement
+<em/GDK_POINTER_MOTION_MASK/. Cela fera que le serveur ajoutera un nouvel
+événement de déplacement à la file des événements à chaque fois que
+l'utilisateur déplace la souris. Si cela nous prend 0,1 seconde pour gérer un
+événement de déplacement, si le serveur X n'ajoute un nouvel événement de
+déplacement dans la queue que toutes les 0,05 secondes, nous serons vite à la
+traîne de l'utilisateur. Si l'utilisateur dessine pendant 5 secondes, cela nous
+prendra 5 secondes de plus pour le traiter après qu'il ait relâché le bouton de
+la souris ! Ce que l'on voudrait, c'est ne récupérer qu'un événement de
+déplacement pour chaque événement que l'on traite. Pour cela, il faut préciser
+<em/GDK_POINTER_MOTION_HINT_MASK/.
+
+<p>
+Avec <em/GDK_POINTER_MOTION_HINT_MASK/, le serveur nous envoit un événement de
+déplacement la première fois que la pointeur se déplace après être entré dans
+la fenêtre, ou après un événement d'appui ou de relâchement d'un bouton. Les
+événements de déplacement suivants seront supprimés jusqu'à ce que l'on demande
+explicitement la position du pointeur en utilisant la fonction&nbsp;:
+
+<tscreen><verb>
+GdkWindow*    gdk_window_get_pointer     (GdkWindow       *window,
+					  gint            *x,
+					  gint            *y,
+					  GdkModifierType *mask);
+</verb></tscreen>
+
+(Il existe une autre fonction, <em/gtk_widget_get_pointer()/ qui possède une
+interface simple, mais n'est pas très utile car elle ne fait que récupérer la
+position de la souris et ne se préoccupe pas de savoir si les boutons sont
+pressés).
+
+<p>
+Le code pour configurer les événements pour notre fenêtre ressemble alors
+à&nbsp;:
+
+<tscreen><verb>
+  gtk_signal_connect (GTK_OBJECT (drawing_area), "expose_event",
+		      (GtkSignalFunc) expose_event, NULL);
+  gtk_signal_connect (GTK_OBJECT(drawing_area),"configure_event",
+		      (GtkSignalFunc) configure_event, NULL);
+  gtk_signal_connect (GTK_OBJECT (drawing_area), "motion_notify_event",
+		      (GtkSignalFunc) motion_notify_event, NULL);
+  gtk_signal_connect (GTK_OBJECT (drawing_area), "button_press_event",
+		      (GtkSignalFunc) button_press_event, NULL);
+
+  gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK
+			 | GDK_LEAVE_NOTIFY_MASK
+			 | GDK_BUTTON_PRESS_MASK
+			 | GDK_POINTER_MOTION_MASK
+			 | GDK_POINTER_MOTION_HINT_MASK);
+</verb></tscreen>
+
+Nous garderons les gestionnaires de "expose_event" et "configure_event" pour
+plus tard. Les gestionnaires de "motion_notify_event" et "button_press_event"
+sont très simples&nbsp;:
+
+<tscreen><verb>
+static gint
+button_press_event (GtkWidget *widget, GdkEventButton *event)
+{
+  if (event->button == 1 &amp;&amp; pixmap != NULL)
+      draw_brush (widget, event->x, event->y);
+
+  return TRUE;
+}
+
+static gint
+motion_notify_event (GtkWidget *widget, GdkEventMotion *event)
+{
+  int x, y;
+  GdkModifierType state;
+
+  if (event->is_hint)
+    gdk_window_get_pointer (event->window, &amp;x, &amp;y, &amp;state);
+  else
+    {
+      x = event->x;
+      y = event->y;
+      state = event->state;
+    }
+    
+  if (state &amp; GDK_BUTTON1_MASK &amp;&amp; pixmap != NULL)
+    draw_brush (widget, x, y);
+  
+  return TRUE;
+}
+</verb></tscreen>
+
+
+<sect1>Le widget DrawingArea et le dessin
+
+<p>
+Revenons au processus de dessin sur l'écran. Le widget que l'on utilise pour
+ceci est le widget <em/DrawingArea/. Un tel widget est essentiellement une
+fenêtre X et rien de plus. Il s'agit d'une toile vide sur laquelle nous pouvons
+dessiner ce que nous voulons. 
+
+Une zone de dessin est créée avec l'appel&nbsp;:
+
+<tscreen><verb>
+GtkWidget* gtk_drawing_area_new        (void);
+</verb></tscreen>
+
+Une taille par défaut peut être donnée au widget par l'appel&nbsp;:
+
+<tscreen><verb>
+void       gtk_drawing_area_size       (GtkDrawingArea      *darea,
+					gint                 width,
+					gint                 height);
+</verb></tscreen>
+
+Cette taille par défaut peu être surchargée en appelant
+<em/gtk_widget_set_usize()/ et celle-ci, à son tour, peut être surchargée si
+l'utilisateur modifie manuellement la taille de la fenêtre contenant la zone de
+dessin.
+
+<p>
+Il faut noter que lorsque l'on crée un widget <em/DrawingArea/, nous sommes
+<em>complètement</em> responsable du dessin du contenu. Si notre fenêtre est
+cachée puis redécouverte, nous recevrons un événement d'exposition et devrons
+redessiner ce qui a été caché auparavant.
+
+<p>
+Devoir se rappeler tout ce qui a été dessiné à l'écran pour pouvoir
+correctement le redessiner peut s'avérer, c'est le moins que l'on puisse dire,
+pénible. De plus, cela peut être visible si des portions de la fenêtre sont
+effacées puis redessinées étape par étape. La solution à ce problème est
+d'utiliser un <em/pixmap d'arrière-plan/ qui n'est pas sur l'écran. Au lieu de
+dessiner directement à l'écran, on dessine sur une image stockée dans la
+mémoire du serveur et qui n'est pas affichée, puis, lorsque l'image change ou
+lorsque de nouvelles portions de l'image sont affichées, on copie les parties
+adéquates sur l'écran.
+
+<p>
+Pour créer un pixmap mémoire, on appelle la fonction&nbsp;:
+
+<tscreen><verb>
+GdkPixmap* gdk_pixmap_new               (GdkWindow  *window,
+					 gint        width,
+					 gint        height,
+					 gint        depth);
+</verb></tscreen>
+
+Le paramètre <em/windows/ indique une fenêtre GTK de laquelle ce pixmap tire
+certaines de ses propriétés. <em/width/ et <em/height/ précisent la taille du
+pixmap. <em/depth/ précise la  <em/profondeur de couleur/, c'est-à-dire le
+nombre de bits par pixel, de la nouvelle fenêtre. Si cette profondeur vaut
+<em/-1/, elle correspondra à celle de <em/window/.
+
+<p>
+Nous créons le pixmap dans notre gestionnaire "configure_event". Cet événement
+est généré à chaque fois que la fenêtre change de taille, y compris lorsqu'elle
+initialement créée.
+
+<tscreen><verb>
+/* Pixmap d'arrière-plan pour la zone de dessin */
+static GdkPixmap *pixmap = NULL;
+
+/* Création d'un nouveau pixmap d'arrière-plan de la taille voulue */
+static gint
+configure_event (GtkWidget *widget, GdkEventConfigure *event)
+{
+  if (pixmap)
+    {
+      gdk_pixmap_destroy(pixmap);
+    }
+  pixmap = gdk_pixmap_new(widget->window,
+			  widget->allocation.width,
+			  widget->allocation.height,
+			  -1);
+  gdk_draw_rectangle (pixmap,
+		      widget->style->white_gc,
+		      TRUE,
+		      0, 0,
+		      widget->allocation.width,
+		      widget->allocation.height);
+
+  return TRUE;
+}
+</verb></tscreen>
+
+L'appel à <em/gdk_draw_rectangle()/ remet le pixmap à blanc. Nous en dirons un
+peu plus dans un moment.
+
+<p>
+Notre gestionnaire d'événement d'exposition copie alors simplement la partie
+concernées du pixmap sur l'écran (on détermine la zone qu'il faut redessiner en
+utilisant le champ <em/event->area/ de l'événement d'exposition)&nbsp;:
+
+<tscreen><verb>
+/* Remplit l'écran à partir du pixmap d'arrière-plan */
+static gint
+expose_event (GtkWidget *widget, GdkEventExpose *event)
+{
+  gdk_draw_pixmap(widget->window,
+		  widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
+		  pixmap,
+		  event->area.x, event->area.y,
+		  event->area.x, event->area.y,
+		  event->area.width, event->area.height);
+
+  return FALSE;
+}
+</verb></tscreen>
+
+Nous avons vu comment garder l'écran à jour avec notre pixmap, mais comment
+dessine-t-on réellement ce que l'on veut dans le pixmap ? Il existe un grand
+nombre d'appels dans la bibliothèque GDK de GTK pour dessiner sur des
+<em>dessinables</em>. Un dessinable est simplement quelque chose sur lequel on
+peut dessiner. Cela peut être une fenêtre, un pixmap, ou un bitmap (une image
+en noir et blanc). Nous avons déjà vu plus haut deux de ces appels,
+<em/gdk_draw_rectangle()/ et <em/gdk_draw_pixmap()/. La liste complète
+est&nbsp;:
+
+<tscreen><verb>
+gdk_draw_line ()
+gdk_draw_rectangle ()
+gdk_draw_arc ()
+gdk_draw_polygon ()
+gdk_draw_string ()
+gdk_draw_text ()
+gdk_draw_pixmap ()
+gdk_draw_bitmap ()
+gdk_draw_image ()
+gdk_draw_points ()
+gdk_draw_segments ()
+</verb></tscreen>
+
+Consultez la documentation de référence ou le fichier en-tête
+<em/&lt;gdk/gdk.h&gt;/ pour plus de détails sur ces fonctions.  Celles-ci
+partagent toutes les mêmes deux paramêtres. Le premier est le dessinable sur
+lequel dessiner, le second est un <em/contexte graphique/ (GC).
+
+<p>
+Un contexte graphique encapsule l'information sur des choses comme les couleurs
+de premier et d'arrière plan et la largeur de ligne. GDK possède un ensemble
+complet de fonctions pour créer et manipuler les contextes graphiques, mais,
+pour simplifier, nous n'utiliserons que les contextes graphiques
+prédéfinis. Chaque widget a un style associé (qui peut être modifié dans un
+fichier gtkrc, voir la section sur les fichiers rc de GTK). Celui-ci, entre
+autres choses, stocke plusieurs contextes graphiques. Quelques exemples d'accès
+à ces contextes sont&nbsp;:
+
+<tscreen><verb>
+widget->style->white_gc
+widget->style->black_gc
+widget->style->fg_gc[GTK_STATE_NORMAL]
+widget->style->bg_gc[GTK_WIDGET_STATE(widget)]
+</verb></tscreen>
+
+Les champs <em/fg_gc, bg_gc, dark_gc/ et <em/light_gc/ sont indexés par un
+paramètre de type <em/GtkStateType/ qui peut prendre les valeurs&nbsp;:
+
+<tscreen><verb>
+GTK_STATE_NORMAL,
+GTK_STATE_ACTIVE,
+GTK_STATE_PRELIGHT,
+GTK_STATE_SELECTED,
+GTK_STATE_INSENSITIVE
+</verb></tscreen>
+
+Par exemple, pour <em/GTK_STATE_SELECTED/, la couleur de premier plan par
+défaut est blanc et la couleur d'arrière plan par défaut est bleu foncé.
+
+<p>
+Notre fonction <em/draw_brush()/, qui réalise le dessin à l'écran est alors&nbsp;:
+
+<tscreen><verb>
+/* Dessine un rectangle à l'écran */
+static void
+draw_brush (GtkWidget *widget, gdouble x, gdouble y)
+{
+  GdkRectangle update_rect;
+
+  update_rect.x = x - 5;
+  update_rect.y = y - 5;
+  update_rect.width = 10;
+  update_rect.height = 10;
+  gdk_draw_rectangle (pixmap,
+		      widget->style->black_gc,
+		      TRUE,
+		      update_rect.x, update_rect.y,
+		      update_rect.width, update_rect.height);
+  gtk_widget_draw (widget, &amp;update_rect);
+}
+</verb></tscreen>
+
+Après avoir dessiné le rectangle représentant la brosse sur le pixmap, nous
+appelons la fonction&nbsp;:
+
+<tscreen><verb>
+void       gtk_widget_draw                (GtkWidget           *widget,
+					   GdkRectangle        *area);
+</verb></tscreen>
+
+qui indique à X que la zone donnée par le paramètre <em/area/ a besoin d'être
+mise à jour. X génèrera éventuellement un événement d'exposition (en combinant
+peut-être les zones passés dans plusieurs appels à <em/gtk_widget_draw()/) ce
+qui forcera notre gestionnaire d'événement d'exposition à copier les parties
+adéquates à l'écran.
+
+<p>
+Nous avons maintenant couvert entièrement le programme de dessin, sauf quelques
+détails banals comme la création de la fenêtre principale. Le code source
+complet est disponible à l'endroit où vous avez obtenu ce didacticiel.
+
+<sect1>Ajouter le support XInput
+
+<p>
+Il est maintenant possible d'acheter des périphériques bon marché, comme les
+tablettes graphiques qui permettent d'exprimer beaucoup plus facilement son
+talent qu'avec une souris. La façon la plus simple pour utiliser de tels
+périphériques est simplement de le faire comme un remplacement de la souris,
+mais cela ne tire pas partie des nombreux avantages de ces périphériques,
+comme&nbsp;:
+
+<itemize>
+<item> Sensibilité à la pression ;
+<item> rapport d'inclinaison ;
+<item> positionnement au dessous du pixel ;
+<item> entrées multiples (par exemple, un stylet avec pointe et gomme).
+</itemize>
+
+Pour des informations sur l'extension XInput, voir <url
+url="http://www.msc.cornell.edu/~otaylor/xinput/XInput-HOWTO.html"
+name="XInput-HOWTO">.
+
+<p>
+Si l'on examine la définition complète de, par exemple, la structure
+<em/GdkEventMotion/, on voit qu'elle possède des champs pour supporter des
+informations étendues sur les périphériques.
+
+<tscreen><verb>
+struct _GdkEventMotion
+{
+  GdkEventType type;
+  GdkWindow *window;
+  guint32 time;
+  gdouble x;
+  gdouble y;
+  gdouble pressure;
+  gdouble xtilt;
+  gdouble ytilt;
+  guint state;
+  gint16 is_hint;
+  GdkInputSource source;
+  guint32 deviceid;
+};
+</verb></tscreen>
+
+<em/pressure/ indique la pression comme un nombre réel compris entre 0 et 1.
+<em/xtilt/ et <em/ytilt/ peuvent prendre des valeurs entre -1 et 1,
+correspondant au degré d'inclinaison dans chaque direction, <em/source/ et
+<em/deviceid/ précisent de deux façons différentes le périphérique pour lequel
+l'événement est survenus. <em/source/ donne une simple information sur le type
+du périphérique. Il peut prendre l'une des valeurs suivantes&nbsp;:
+
+<tscreen><verb>
+GDK_SOURCE_MOUSE
+GDK_SOURCE_PEN
+GDK_SOURCE_ERASER
+GDK_SOURCE_CURSOR
+</verb></tscreen>
+
+<tt/deviceid/ précise un ID numérique unique pour le périphérique. Il peut être
+utilisé pour trouver des informations supplémentaires sur le périphérique en
+utilisant l'appel <em/gdk_input_list_devices()/ (voir ci-dessous). La valeur
+spéciale <em/GDK_CORE_POINTER/ sert à désigner le périphérique de pointage
+principal (habituellement la souris).
+
+<sect2>Valider l'information supplémentaire sur un périphérique
+
+<p>
+Pour indiquer à GTK que l'on désire obtenir des informations supplémentaires
+sur le périphérique, on a simplement besoin d'ajouter une ligne à nos
+programmes. 
+
+<tscreen><verb>
+gtk_widget_set_extension_events (drawing_area, GDK_EXTENSION_EVENTS_CURSOR);
+</verb></tscreen>
+
+En donnant la valeur <em/GDK_EXTENSION_EVENTS_CURSOR/, on indique que nous
+désirons les événements d'extension, mais seulement si l'on ne doit pas
+dessiner notre propre curseur. Voir la section <ref
+id="sec_Further_Sophistications" name="Sophistications supplémentaires">
+ci-dessous pour des plus de détails sur le dessin du curseur. Nous pourrions
+aussi donner les valeurs <em/GDK_EXTENSION_EVENTS_ALL/ si nous voulons dessiner
+notre propre curseur, ou <tt/GDK_EXTENSION_EVENTS_NONE/ pour revenir à la
+situation par défaut.
+
+<p>
+Toutefois, nous ne sommes pas complètement à la fin de l'histoire. Par défaut,
+aucun périphérique d'extension n'est autorisé. Nous avons besoin d'un mécanisme
+pour que les utilisateurs puissent autoriser et configurer leur extensions. GTK
+dispose du widget <em/InputDialog/ pour automatiser cette tâche. La procédure
+suivante gère un widget InputDialog. Elle crée le dialogue s'il n'est pas
+présent et le place au premier plan sinon.
+
+<tscreen><verb>
+void
+input_dialog_destroy (GtkWidget *w, gpointer data)
+{
+  *((GtkWidget **)data) = NULL;
+}
+
+void
+create_input_dialog ()
+{
+  static GtkWidget *inputd = NULL;
+
+  if (!inputd)
+    {
+      inputd = gtk_input_dialog_new();
+
+      gtk_signal_connect (GTK_OBJECT(inputd), "destroy",
+			  (GtkSignalFunc)input_dialog_destroy, &amp;inputd);
+      gtk_signal_connect_object (GTK_OBJECT(GTK_INPUT_DIALOG(inputd)->close_button),
+				 "clicked",
+				 (GtkSignalFunc)gtk_widget_hide,
+				 GTK_OBJECT(inputd));
+      gtk_widget_hide ( GTK_INPUT_DIALOG(inputd)->save_button);
+
+      gtk_widget_show (inputd);
+    }
+  else
+    {
+      if (!GTK_WIDGET_MAPPED(inputd))
+	gtk_widget_show(inputd);
+      else
+	gdk_window_raise(inputd->window);
+    }
+}
+</verb></tscreen>
+
+(vous pouvez remarquer la façon dont nous gérons ce dialogue. En le connectant
+au signal "destroy", nous nous assurons que nous ne garderons pas un pointeur
+sur le dialogue après l'avoir détruit -- cela pourrait provoquer une erreur de
+segmentation).
+
+
+<p>
+InputDialog a deux boutons "Close" et "Save", qui n'ont pas d'actions qui leur
+sont assignées par défaut. Dans la fonction ci-dessus, nous associons à "Close"
+le masquage du dialogue et nous cachons le bouton "Save" car nous n'implantons
+pas la sauvegarde des options XInput dans ce programme.
+
+<sect2>Utiliser l'information supplémentaire d'un périphérique
+
+<p>
+Lorsque l'on a validé le périphérique, on peut simplement utiliser
+l'information supplémentaire des champs des structures d'événement. En fait, il
+est toujours prident d'utiliser ces informations car ces champs auront des
+valeurs par défaut judicieuses même lorsque les événements supplémentaires ne
+sont pas autorisés.
+
+<p>
+La seule modification consiste à appeler <em/gdk_input_window_get_pointer()/ au
+lieu de <em/gdk_window_get_pointer/. Cela est nécessaire car
+<em/gdk_window_get_pointer/ ne retourne pas l'information supplémentaire.
+
+<tscreen><verb>
+void gdk_input_window_get_pointer     (GdkWindow       *window,
+				       guint32         deviceid,
+				       gdouble         *x,
+				       gdouble         *y,
+				       gdouble         *pressure,
+				       gdouble         *xtilt,
+				       gdouble         *ytilt,
+				       GdkModifierType *mask);
+</verb></tscreen>
+
+Lorsque l'on appelle cette fonction, on doit préciser l'ID du périphérique
+ainsi que la fenêtre. Habituellement, on aura obtenu cet ID par le champ
+<em/deviceid/ d'une structure d'événement. Cette fonction retournera une valeur
+cohérente lorsque les événements ne sont pas autorisés (dans ce cas,
+<em/event->deviceid/ aura la valeur <em/GDK_CORE_POINTER/).
+
+La structure de base des gestionnaires d'événements de déplacement et de bouton
+pressé ne change donc pas trop -- il faut juste ajouter le code permettant de
+traiter l'information supplémentaire.
+
+<tscreen><verb>
+static gint
+button_press_event (GtkWidget *widget, GdkEventButton *event)
+{
+  print_button_press (event->deviceid);
+  
+  if (event->button == 1 &amp;&amp; pixmap != NULL)
+    draw_brush (widget, event->source, event->x, event->y, event->pressure);
+
+  return TRUE;
+}
+
+static gint
+motion_notify_event (GtkWidget *widget, GdkEventMotion *event)
+{
+  gdouble x, y;
+  gdouble pressure;
+  GdkModifierType state;
+
+  if (event->is_hint)
+    gdk_input_window_get_pointer (event->window, event->deviceid,
+				  &amp;x, &amp;y, &amp;pressure, NULL, NULL, &amp;state);
+  else
+    {
+      x = event->x;
+      y = event->y;
+      pressure = event->pressure;
+      state = event->state;
+    }
+    
+  if (state &amp; GDK_BUTTON1_MASK &amp;&amp; pixmap != NULL)
+    draw_brush (widget, event->source, x, y, pressure);
+  
+  return TRUE;
+}
+</verb></tscreen>
+
+On doit aussi faire quelquechose de cette nouvelle information. Notre nouvelle
+fonction <em/draw_brush()/ dessine avec une couleur différente pour chaque
+<em/event->source/ et change la taille du pinceau selon la pression.
+
+<tscreen><verb>
+/* Dessine un rectangle à l'écran, la taille dépend de la pression,
+   et la couleur dépend du type de périphérique */
+static void
+draw_brush (GtkWidget *widget, GdkInputSource source,
+	    gdouble x, gdouble y, gdouble pressure)
+{
+  GdkGC *gc;
+  GdkRectangle update_rect;
+
+  switch (source)
+    {
+    case GDK_SOURCE_MOUSE:
+      gc = widget->style->dark_gc[GTK_WIDGET_STATE (widget)];
+      break;
+    case GDK_SOURCE_PEN:
+      gc = widget->style->black_gc;
+      break;
+    case GDK_SOURCE_ERASER:
+      gc = widget->style->white_gc;
+      break;
+    default:
+      gc = widget->style->light_gc[GTK_WIDGET_STATE (widget)];
+    }
+
+  update_rect.x = x - 10 * pressure;
+  update_rect.y = y - 10 * pressure;
+  update_rect.width = 20 * pressure;
+  update_rect.height = 20 * pressure;
+  gdk_draw_rectangle (pixmap, gc, TRUE,
+		      update_rect.x, update_rect.y,
+		      update_rect.width, update_rect.height);
+  gtk_widget_draw (widget, &amp;update_rect);
+}
+</verb></tscreen>
+
+<sect2>En savoir plus sur un périphérique
+
+<p>
+Notre programme affichera le nom du périphérique qui a généré chaque appui de
+bouton. Pour trouver le nom d'un périphérique, nous appelons la fonction&nbsp;:
+
+<tscreen><verb>
+GList *gdk_input_list_devices               (void);
+</verb></tscreen>
+
+qui retourne une GList (un type de liste chaînée de la bibliothèque glib) de
+structures GdkDeviceInfo. La structure GdkDeviceInfo est définie de la façon
+suivante&nbsp;:
+
+<tscreen><verb>
+struct _GdkDeviceInfo
+{
+  guint32 deviceid;
+  gchar *name;
+  GdkInputSource source;
+  GdkInputMode mode;
+  gint has_cursor;
+  gint num_axes;
+  GdkAxisUse *axes;
+  gint num_keys;
+  GdkDeviceKey *keys;
+};
+</verb></tscreen>
+
+La plupart de ces champs sont des informations de configuration que l'on peut
+ignorer sauf si l'on implante la sauvegarde de la configuration XInput. Celui
+qui nous intéresse est <em/name/ qui est, tout simplement, le nom que X donne
+au périphérique. L'autre champ, qui n'est pas une information de configuration,
+est <em/has_cursor/. Si <em/has_cursor/ est faux, on doit dessiner notre propre
+curseur, mais puisque nous avons précisé <em/GDK_EXTENSION_EVENTS_CURSOR/, nous
+n'avons pas à nous en préoccuper.
+
+<p>
+Notre fonction <em/print_button_press()/ ne fait parcourir la liste retournée
+jusqu'à trouver une correspondance, puis affiche le nom du périphérique.
+
+<tscreen><verb>
+static void
+print_button_press (guint32 deviceid)
+{
+  GList *tmp_list;
+
+  /* gdk_input_list_devices retourne une liste interne, nous ne devons donc
+    pas la libérer après */
+  tmp_list = gdk_input_list_devices();
+
+  while (tmp_list)
+    {
+      GdkDeviceInfo *info = (GdkDeviceInfo *)tmp_list->data;
+
+      if (info->deviceid == deviceid)
+	{
+	  printf("Bouton pressé sur le périphérique '%s'\n", info->name);
+	  return;
+	}
+
+      tmp_list = tmp_list->next;
+    }
+}
+</verb></tscreen>
+
+Ceci termine les modifications de notre programme « XInputize ». Comme pour la
+première version, le code complet est disponible à l'endroit où vous avez
+obtenu ce didacticiel.
+
+<sect2>Sophistications supplémentaires<label id="sec_Further_Sophistications">
+
+<p>
+Bien que notre programme supporte maintenant XInput, il y manque des
+caractéristiques que l'on souhaite trouver dans les applications
+complètes. D'abord, l'utilisateur ne veut probablement pas avoir à configurer
+ses périphériques à chaque fois qu'il lance le programme et nous devons donc
+lui permettre de sauvegarder la configuration du périphérique. Ceci est réalisé
+en parcourant ce que retourne <em/gdk_input_list_devices()/ et en écrivant la
+configuration dans un fichier.
+
+<p>
+Pour restaurer un état au prochain démarrage du programme, GDK dispose de
+fonctions pour changer la configuration des périphériques&nbsp;:
+
+<tscreen><verb>
+gdk_input_set_extension_events()
+gdk_input_set_source()
+gdk_input_set_mode()
+gdk_input_set_axes()
+gdk_input_set_key()
+</verb></tscreen>
+
+(La liste retournée par <em/gdk_input_list_devices()/ ne doit pas être modifiée 
+directement). Un exemple est donné dans le programme de dessin <em/gsumi/
+(disponible à l'adresse <htmlurl
+url="http://www.msc.cornell.edu/~otaylor/gsumi/"
+name="http://www.msc.cornell.edu/~otaylor/gsumi/">). De plus, ce serait
+pratique d'avoir une méthode standard pour faire cela pour toutes les
+applications. Ceci appartient probablement à un niveau légèrement supérieur à
+GTK, peut-être dans la bibliothèque GNOME.
+
+<p>
+Une autre grosse omission que nous avons mentionnée plus haut est l'absence de
+dessin du curseur. Les plates-formes autres qu'XFree86 n'autorisent pas encore
+l'utilisation simultanée d'un périphérique comme pointeur de base et comme
+pointeur d'une application. Lisez le <url
+url="http://www.msc.cornell.edu/~otaylor/xinput/XInput-HOWTO.html"
+name="XInput-HOWTO"> pour plus d'informations là-dessus. Ceci signifie que les
+applications qui veulent atteindre le plus de monde possible doivent dessiner
+leur propre curseur.
+
+<p>
+Une application qui dessine son propre curseur doit faire deux choses&nbsp;:
+déterminer si le périphérique courant a besoin ou non d'un curseur dessiné et
+déterminer si le périphérique courant est à proximité (si celui-ci est une
+tablette de dessin, il est pratique de faire disparaître le curseur lorsque le
+stylet est en dehors de la tablette. Lorsque le périphérique voit le stylet, on 
+dit qu'il est « à proximité »). La première vérification est faite en
+recherchant dans la liste des périphériques, comme nous l'avons fait pour
+obtenir le nom du périphérique. La deuxième est réalisée en choisissant des
+événements "proximity_out". Une exemple de dessin d'un curseur personnel est
+donné dans le programme <em/testinput/ de la distribution GTK.
+
+
+<sect>Conseils pour l'écriture d'applications GTK
+<p>
+Cette section est simplement un regroupement de lignes de conduites générales
+et sages, ainsi que d'astuces pour créer des applications GTK correctes. Elle
+est totalement inutile pour l'instant car il ne s'agit que d'une phrase :)
+
+Utilisez <em/autoconf/ et <em/automake/ de GNU !  Ce sont vos amis :) J'ai en
+projet de les présenter brièvement ici.
+
+<sect>Contributions
+
+<p>
+Ce document, comme beaucoup d'autres beaux logiciels, a été créé (NdT&nbsp;: et 
+traduit) par des
+volontaires bénévoles. Si vous vous y connaissez sur certains aspects de GTK
+qui ne sont pas encore documentés, soyez gentils de contribuer à ce document.
+
+<p>
+Si vous décidez de contribuer, envoyez-moi (Ian Main) votre texte à
+<tt><htmlurl url="mailto:slow@intergate.bc.ca"
+name="slow@intergate.bc.ca"></tt>. La totalité de ce document est libre et
+tout ajout que vous pourriez y faire doit l'être également. Ainsi, tout le
+monde peut utiliser n'importe quelle partie de vos exemples dans les
+programmes, les copies de ce document peuvent être distribuées à volonté, etc.
+<p>
+Merci.
+
+
+<sect>Remerciements
+<p>
+Je voudrai remercier les personnes suivantes pour leurs contributions à ce texte&nbsp;:
+
+<itemize>
+<item>Bawer Dagdeviren, <tt><htmlurl url="mailto:chamele0n@geocities.com"
+name="chamele0n@geocities.com"></tt> pour le didacticiel sur les menus.
+
+<item>Raph Levien, <tt><htmlurl url="mailto:raph@acm.org"
+name="raph@acm.org"></tt>
+pour <em/bonjour tout le monde/ à la GTK, le placement des widgets et pour sa
+sagesse. Il a aussi généreusement donné un abri à ce didacticiel.
+
+<item>Peter Mattis, <tt><htmlurl url="mailto:petm@xcf.berkeley.edu"
+name="petm@xcf.berkeley.edu"></tt> pour le programme GTK le plus simple et pour
+sa capacité à le faire :)
+
+<item>Werner Koch <tt><htmlurl url="mailto:werner.koch@guug.de"
+name="werner.koch@guug.de"></tt> pour la conversion du texte original en SGML,
+et pour la hiérarchie des classes de widget.
+
+<item>Mark Crichton <tt><htmlurl url="mailto:crichton@expert.cc.purdue.edu"
+name="crichton@expert.cc.purdue.edu"></tt> pour le code de l'usine à menus et
+pour le didacticiel de placement des tables.
+
+<item>Owen Taylor <tt><htmlurl url="mailto:owt1@cornell.edu"
+name="owt1@cornell.edu"></tt> pour la section sur le widget EventBox (et le
+patch de la distribution). Il est aussi responsable des sections sur l'écriture
+de vos propres widgets GTK et de l'application exemple. Merci beaucoup à Owen
+pour toute son aide !
+
+<item>Mark VanderBoom <tt><htmlurl url="mailto:mvboom42@calvin.edu"
+name="mvboom42@calvin.edu"></tt> pour son merveilleux travail sur les widgets
+Notebook, Progress Bar, Dialog et File selection. Merci beaucoup, Mark ! Ton
+aide a été très précieuse.
+
+<item>Tim Janik <tt><htmlurl url="mailto:timj@psynet.net"
+name="timj@psynet.net"></tt> pour son beau travail sur le widget Lists.
+Merci Tim :)
+
+<item>Rajat Datta <tt><htmlurl url="mailto:rajat@ix.netcom.com"
+name="rajat@ix.netcom.com"</tt> pour son excellent travail sur le didacticiel
+sur les Pixmaps.
+
+<item>Michael K. Johnson <tt><htmlurl url="mailto:johnsonm@redhat.com"
+name="johnsonm@redhat.com"></tt> pour ses infos et le code pour les menus.
+
+</itemize>
+<p>
+Et à tous ceux d'entre vous qui ont commenté et aidé à améliorer ce document.
+<p>
+Merci.
+
+<sect>Copyright
+<p>
+Ce didacticiel est  Copyright (C) 1997 Ian Main 
+<p>
+Ce programme est un logiciel libre ; vous pouvez le redistribuer et/ou le
+modifier sous les termes de la licence publique générale GNU telle qu'elle est
+publiée par la Free Software Foundation ; soit la version 2 de la licence, ou
+(comme vous voulez) toute version ultérieure.
+<p>
+Ce programme est distribué dans l'espoir qu'il sera utile, mais SANS AUCUNE
+GARANTIE ; même sans la garantie de COMMERCIALITÉ ou d'ADÉQUATION A UN BUT
+PARTICULIER. Voir la licence publique générale GNU pour plus de détails.
+<p>
+Vous devriez avoir reçu une copie de la licence publique générale GNU avec ce
+programme ; si ce n'est pas le cas, écrivez à la Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+<sect1>Notes du traducteur
+Ce document a été adapté en Français par <url url="mailto:jaco@dotcom.fr"
+name="Éric Jacoboni">. Toute remarque sur cette adaptation sera la bienvenue.
+<p>
+Merci à <url url="mailto:kheops@linux-kheops.com" name="Joël Bernier"> pour
+avoir initié cette adaptation, et à <url url="mailto:vincent@debian.org"
+	    name="Vincent Renardias"> pour sa relecture.
+</article>
diff --git a/docs/tutorial/gtk_tut_fr.sgml b/docs/tutorial/gtk_tut_fr.sgml
new file mode 100644
index 000000000..0d23ced88
--- /dev/null
+++ b/docs/tutorial/gtk_tut_fr.sgml
@@ -0,0 +1,8600 @@
+<!doctype linuxdoc system>
+<article>
+<title>Didacticiel
+<author>Ian Main, <tt><htmlurl url="mailto:slow@intergate.bc.ca"
+			      name="slow@intergate.bc.ca"></tt>
+<date>January 24, 1998.
+
+   
+<sect>Introduction
+<p>
+GTK (GIMP Toolkit) a été d'abord développé pour être une boîte à
+outils pour GIMP (General Image Manipulation Program).  GTK est
+construit sur GDK (GIMP Drawing Kit) qui est, avant tout, une
+encapsulation des fonctions Xlib. On l'appelle « GIMP toolkit » car il
+fut créé pour développer GIMP, mais il est désormais utilisé dans
+plusieurs projets de logiciels libres. Les auteurs sont&nbsp;:
+<itemize>
+<item> Peter Mattis   <tt><htmlurl url="mailto:petm@xcf.berkeley.edu"
+			   name="petm@xcf.berkeley.edu"></tt>
+<item> Spencer Kimball <tt><htmlurl url="mailto:spencer@xcf.berkeley.edu"
+			   name="spencer@xcf.berkeley.edu"></tt>
+<item> Josh MacDonald <tt><htmlurl url="mailto:jmacd@xcf.berkeley.edu"
+			   name="jmacd@xcf.berkeley.edu"></tt>
+</itemize>
+
+<p>
+GTK est essentiellement une interface de programmation (API) orientée
+objet.  Bien qu'il soit entièrement écrit en C, il est implanté en
+utilisant la notion de classes et de fonctions de rappel (pointeurs
+de fonctions).
+<p>
+Un troisième composant, appelé glib, remplace certains appels
+standard et comporte quelques fonctions supplémentaires pour gérer les
+listes chaînées, etc. Les fonctions de remplacement sont utilisées
+pour accroître la portabilité de GTK car certaines de ces fonctions,
+comme g_strerror(), ne sont pas disponibles ou ne sont pas standard
+sur d'autres Unix. D'autres comportent des améliorations par rapport
+aux versions de la libc&nbsp;: g_malloc(), par exemple, facilite le
+débuggage.<p>
+ 
+Ce didacticiel tente de décrire du mieux possible GTK, mais il n'est pas
+exhaustif. Il suppose une bonne connaissance du langage C, et de la façon de
+créer des programmes C. Il serait très précieux au lecteur d'avoir déjà une
+expérience de la programmation X, mais cela n'est pas nécessaire. Si
+l'apprentissage de GTK marque vos débuts dans l'approche des widgets, n'hésitez
+pas à faire des commentaires sur ce didacticiel et sur les problèmes qu'il vous
+a posé.  Il y a aussi une API C++ pour GTK (GTK--), si vous préférez utiliser
+ce langage, consultez plutôt la documentation qui la concerne. Une
+encapsulation en Objective C et des liaisons Guile sont également disponibles,
+mais ne seront pas abordées ici.
+<p>
+J'apprécierais beaucoup avoir un écho des problèmes que vous avez
+rencontré pour apprendre GTK à partir de ce document. De plus, toute
+suggestion sur son amélioration est la bienvenue.
+
+<sect>Bien débuter
+<p>
+La première chose à faire est, bien sûr, de récupérer les sources de
+GTK et de les installer. Vous pouvez en obtenir la dernière version
+sur <tt/ftp.gimp.org/ dans le répertoire <tt>/pub/gtk</tt>. D'autres
+sources d'informations se trouvent sur
+<tt>http://www.gimp.org/gtk</tt>. GTK utilise <em/autoconf/ de GNU
+pour se configurer. Lorsque vous l'aurez détarré, tapez
+<em>./configure --help</em> pour consulter la liste des options.
+<p>
+Pour commencer notre introduction à GTK, nous débuterons avec le
+programme le plus simple qui soit. Celui-ci créera une fenêtre de
+200x200 pixels et ne pourra se terminer qu'en le tuant à partir du
+shell.
+
+<tscreen><verb>
+#include <gtk/gtk.h>
+
+int main (int argc, char *argv[])
+{
+    GtkWidget *window;
+    
+    gtk_init (&amp;argc, &amp;argv);
+    
+    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+    gtk_widget_show (window);
+    
+    gtk_main ();
+    
+    return 0;
+}
+</verb></tscreen>
+
+Tous les programmes inclueront évidemment le fichier
+<tt>gtk/gtk.h</tt> qui déclare les variables, fonctions, structures,
+etc. qui seront utilisées par votre application GTK.
+<p>
+La ligne &nbsp;:
+
+<tscreen><verb>
+gtk_init (&amp;argc, &amp;argv);
+</verb></tscreen>
+
+appelle la fonction <em/gtk_init(gint *argc, gchar ***argv)/ qui sera
+appelée dans toutes les applications GTK. Cette fonction configure
+certaines choses pour nous, comme l'aspect visuel et les couleurs par
+défaut, puis appelle <em/gdk_init(gint *argc, gchar ***argv)/.  Cette
+dernière initialise la bibliothèque pour qu'elle puisse être utilisée,
+configure les gestionnaires de signaux par défaut et vérifie les
+paramètres passés à notre application via la ligne de commande en
+recherchant l'un des suivants&nbsp;:
+
+<itemize>
+<item> <tt/--display/
+<item> <tt/--debug-level/
+<item> <tt/--no-xshm/
+<item> <tt/--sync/
+<item> <tt/--show-events/
+<item> <tt/--no-show-events/
+</itemize>
+<p>
+Elle les supprime alors de la liste des paramètres, en laissant tout
+ce qu'elle ne reconnaît pas pour que notre application l'analyse ou
+l'ignore. Ceci crée un ensemble de paramètres standards acceptés par
+toutes les applications GTK.
+<p>
+Les deux lignes de code suivantes créent et affichent une fenêtre.
+
+<tscreen><verb>
+  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  gtk_widget_show (window);
+</verb></tscreen>
+
+Le paramètre <tt/GTK_WINDOW_TOPLEVEL/ précise que l'on veut que la
+fenêtre créée suive l'aspect et le placement définis par le
+gestionnaire de fenêtres. Plutôt que de créer une fenêtre de 0x0, une
+fenêtre sans fenêtre fille est de 200x200 par défaut&nbsp;: on peut
+ainsi la manipuler facilement.
+<p>
+La fonction <em/gtk_widget_show()/ informe GTK que l'on a configuré
+le widget et qu'il peut l'afficher.
+<p>
+La ligne suivante lance la boucle principale de traitement de GTK.
+
+<tscreen><verb>
+gtk_main ();
+</verb></tscreen>
+
+<em/gtk_main()/ est un autre appel que vous verrez dans toute
+application GTK. Lorsque le contrôle atteind ce point, GTK se met en
+attente d'événements X (click sur un bouton, ou appui d'une touche, par
+exemple), de timeouts ou d'entrées-sorties fichier. Dans notre exemple
+simple, cependant, les événements sont ignorés.
+
+
+<sect1>« Bonjour tout le monde » en GTK
+<p>
+OK, écrivons un programme avec un widget (bouton). C'est le classique « Bonjour tout le monde » à la sauce GTK.
+
+<tscreen><verb>
+
+#include <gtk/gtk.h>
+
+    /* fonction de rappel. Dans cet exemple, les paramètres sont ignorés...
+     *  Les fonctions de rappel sont détaillées plus loin. */
+
+void hello (GtkWidget *widget, gpointer data)
+{
+    g_print ("Bonjour tout le monde.\n");
+}
+
+gint delete_event(GtkWidget *widget, GdkEvent *event, gpointer data)
+{
+    g_print ("le signal delete_event est survenu.\n");
+
+    /* Si l'on renvoit TRUE dans le gestionnaire du signal "delete_event",
+     * GTK émettra le signal "destroy". Retourner FALSE signifie que l'on
+     * ne veut pas que la fenêtre soit détruite. 
+     * Utilisé pour faire apparaître des boîtes de dialogue du type
+     * « Êtes-vous sûr de vouloir quitter ? » */
+    
+    /* Remplacez FALSE par TRUE et la fenêtre principale sera détruite par
+     * un signal « delete_event ». */
+    
+    return (FALSE); 
+}
+
+/* Autre fonction de rappel */
+
+void destroy (GtkWidget *widget, gpointer data)
+{
+    gtk_main_quit ();
+}
+
+int main (int argc, char *argv[])
+{
+    /* GtkWidget est le type pour déclarer les widgets. */
+
+    GtkWidget *window;
+    GtkWidget *button;
+    
+    /* Cette fonction est appelée dans toutes les applications GTK. 
+     * Les paramètres passés en ligne de commande sont analysés et 
+     * retournés à l'application. */
+
+    gtk_init (&amp;argc, &amp;argv);
+    
+    /* Création d'une nouvelle fenêtre. */
+
+    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+    
+    /* Lorsque la fenêtre reçoit le signal "delete_event" 
+     * (envoyé par le gestionnaire de fenêtres en utilisant l'option
+     * « close » ou la barre de titre), on lui demande d'appeler la
+     * fonction delete_event() définie plus haut. La donnée passée en
+     * paramètre à la fonction de rappel est NULL et est ignoré dans le
+     * rappel. */
+
+    gtk_signal_connect (GTK_OBJECT (window), "delete_event",
+			GTK_SIGNAL_FUNC (delete_event), NULL);
+    
+    /* Ici, on connecte l'évenement "destroy" à un gestionnaire de signal.
+     * Cet événement arrive lorsqu'on appelle gtk_widget_destroy() sur la
+     * fenêtre, ou si l'on retourne TRUE dans le rappel "delete_event". */
+
+    gtk_signal_connect (GTK_OBJECT (window), "destroy",
+			GTK_SIGNAL_FUNC (destroy), NULL);
+    
+    /* Configuration de la largeur du contour de la fenêtre. */
+
+    gtk_container_border_width (GTK_CONTAINER (window), 10);
+    
+    /* Création d'un nouveau bouton portant le label 
+     * "Bonjour tout le monde". */
+
+    button = gtk_button_new_with_label ("Bonjour tout le monde");
+    
+    /* Quand le bouton recevra le signal "clicked", il appellera la
+     * fonction hello() définie plus haut en lui passant NULL en paramètre. */
+
+    gtk_signal_connect (GTK_OBJECT (button), "clicked",
+			GTK_SIGNAL_FUNC (hello), NULL);
+    
+    /* Ceci provoquera la destruction de la fenêtre par appel de la
+     * fonction gtk_widget_destroy(window) lors du signal "clicked".  
+     * Le signal de destruction pourrait venir de là, ou du 
+     * gestionnaire de fenêtres. */
+
+    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+			       GTK_SIGNAL_FUNC (gtk_widget_destroy),
+			       GTK_OBJECT (window));
+    
+    /* Insertion du bouton dans la fenêtre (container gtk). */
+
+    gtk_container_add (GTK_CONTAINER (window), button);
+    
+    /* L'étape finale consiste à afficher ce nouveau widget... */
+
+    gtk_widget_show (button);
+    
+    /* ... et la fenêtre. */
+
+    gtk_widget_show (window);
+    
+    /* Toutes les applications GTK doivent avoir un gtk_main().	
+     * Le déroulement du programme se termine là et attend qu'un
+     * événement survienne (touche pressée ou événement souris). */
+
+    gtk_main ();
+    
+    return 0;
+}
+</verb></tscreen>
+
+<sect1>Compilation de « Bonjour tout le monde »
+<p>
+Supposons que vous avez sauvegardé le code précédent dans un fichier
+nommé <em/bonjour.c/, pour le compiler tapez la commande
+suivante&nbsp;:
+
+<tscreen><verb>
+gcc -Wall -g bonjour.c -o bonjour_monde -L/usr/X11R6/lib \
+    -lgtk -lgdk -lglib -lXext -lX11 -lm
+</verb></tscreen>
+<p>
+Les bibliothèques invoquées ci-dessus doivent toutes être dans vos
+chemins de recherche par défaut, sinon, ajoutez <tt/-L&lt;library
+directory&gt;/ pour que <em/gcc/ recherche dans ces répertoires les
+bibliothèques nécessaires. Sur mon système Debian GNU/Linux, par exemple,
+je dois ajouter <tt>-L/usr/X11R6/lib</> pour qu'il trouve les
+bibliothèques X11 (NdT&nbsp;: et c'est pareil sur mon système Red Hat
+Linux...).
+<p>
+L'ordre des bibliothèques est important. L'éditeur de liens doit
+connaître les fonctions d'une bibliothèque dont il a besoin avant de
+les traiter.
+<p>
+Si vous compilez en utilisant des bibliothèques statiques, l'ordre
+dans lequel vous listez les bibliothèques devient très
+important. L'exemple donné ci-dessus devrait fonctionner dans tous les
+cas.
+<p>
+Les bibliothèques que l'on utilise sont&nbsp;:
+<itemize>
+<item>La bibliothèque glib (<tt/-lglib/), qui contient diverses
+fonctions. Seule <em/g_print()/ est utilisée dans cet exemple. GTK est
+construit au dessus de <em/glib/ et vous aurez donc toujours besoin de
+celle-ci. Voir la section concernant <ref id="sec_glib" name="glib">
+pour plus de détails.
+ 
+<item>La bibliothèque GDK (<tt/-lgdk/), l'enveloppe de Xlib.
+
+<item>La bibliothèque GTK (<tt/-lgtk/), la bibliothèque des widgets,
+construite au dessus de GDK.
+
+<item>La bibliothèque Xlib (<tt/-lX11/ utilisée par GDK.
+
+<item>La bibliothèque Xext (<tt/-lXext/). Cette dernière contient le
+code pour les pixmaps en mémoire partagée et les autres extensions X.
+
+<item>La bibliothèque mathématique (<tt/-lm/).  Elle est utilisée pour
+différentes raisons par GTK.
+</itemize>
+
+<sect1>Théorie des signaux et des rappels
+<p>
+Avant de voir en détail le programme « Bonjour tout le monde », nous
+parlerons d'abord des événements et des fonctions de rappel.  GTK est
+dirigé par les événements, ce qui signifie qu'il restera inactif dans
+<em/gtk_main/ jusqu'à ce qu'un événement survienne et que le contrôle
+soit passé à la fonction appropriée.
+<p>
+Ce passage du contrôle est réalisé en utilisant le concept de « signal
+». Lorsqu'un événement survient, comme l'appui sur un bouton, le
+signal approprié sera « émis » par le widget qui a été pressé. C'est
+de cette façon que GTK réalise la plupart de son travail. Pour qu'un
+bouton réalise une action, on configure un gestionnaire de signal pour
+capturer ces signaux et appeler la fonction adéquate.  Ceci est fait
+en utilisant une fonction comme&nbsp;:
+
+<tscreen><verb>
+gint gtk_signal_connect (GtkObject *object,
+                         gchar *name,
+			 GtkSignalFunc func,
+			 gpointer func_data);
+</verb></tscreen>
+<p>
+Où le premier paramètre est le widget qui émettra le signal, et le
+deuxième est le nom du signal que l'on souhaite intercepter. Le
+troisième paramètre est la fonction que l'on veut appeler quand le
+signal est capturé, et le quatrième sont les données que l'on souhaite
+passer à cette fonction.
+<p>
+La fonction spécifiée par le troisième paramètre s'appelle une «
+fonction de rappel » et doit être de la forme&nbsp;:
+
+<tscreen><verb>
+void callback_func(GtkWidget *widget, gpointer *callback_data);
+</verb></tscreen>
+<p>
+Où le premier paramètre sera un pointeur vers le widget qui a émis le
+signal, et le second un pointeur vers les données passées par le
+dernier paramètre de la fonction <em/gtk_signal_connect()/ décrite
+plus haut.
+<p>
+Un autre appel utilisé dans l'exemple « Bonjour tout le monde » est&nbsp;:
+
+<tscreen><verb>
+gint gtk_signal_connect_object (GtkObject *object,
+                                gchar  *name,
+				GtkSignalFunc func,
+				GtkObject *slot_object);
+</verb></tscreen>
+<p>
+<em/gtk_signal_connect_object()/ est la même chose que
+<em/gtk_signal_connect()/ sauf que la fonction de rappel utilise un
+seul paramètre&nbsp;: un pointeur vers un objet GTK. Lorsqu'on utilise
+cette fonction pour connecter des signaux, le rappel doit être de
+cette forme&nbsp;:
+
+<tscreen><verb>
+void callback_func (GtkObject *object);
+</verb></tscreen>
+<p>
+Où l'objet est d'ordinaire un widget. En général, on ne configure pas
+de rappels pour <em/gtk_signal_connect_object/. D'habitude, ceux-ci sont
+utilisés pour appeler une fonction GTK acceptant un simple widget ou
+objet comme paramètre, comme dans notre exemple.
+
+La raison pour laquelle il y a deux fonctions pour connecter les
+signaux est simplement de permettre aux fonctions de rappel d'avoir un
+nombre différent de paramètres. De nombreuses fonctions de la
+bibliothèque GTK n'acceptent qu'un simple pointeur vers un
+<em/GtkWidget/ comme paramètre et vous pouvez donc  utiliser
+<em/gtk_signal_connect_object()/ pour celles-ci, tandis que pour vos
+fonctions vous pouvez avoir besoin d'avoir de fournir plus de données
+aux fonctions de rappel.
+
+<sect1>« Bonjour tout le monde » pas à pas
+<p>
+Maintenant que nous connaissons la théorie, clarifions un peu en progressant à travers le programme « Bonjour tout le monde ».
+<p>
+Voici la fonction de rappel appelée lorsque le bouton est « clicked
+». Dans notre exemple, on ignore le widget et les données mais il
+n'est pas difficile de faire quelque chose avec. Le prochain exemple
+utilisera le paramètre des données pour nous dire quel bouton a été
+pressé.
+
+<tscreen><verb>
+void hello (GtkWidget *widget, gpointer *data)
+{
+    g_print ("Bonjour tout le monde\n");
+}
+</verb></tscreen>
+
+<p>
+Cette fonction de rappel est un peu spéciale. L'événement
+"delete_event" survient lorsque le gestionnaire de fenêtres l'envoie à
+l'application. On doit choisir ce qu'il faut faire de ces
+événements. On peut les ignorer, leur donner une réponse, ou
+simplement quitter l'application.
+
+La valeur que l'on retourne dans cette fonction de rappel permet à GTK
+de savoir ce qu'il a à faire. En retournant FALSE, on l'informe que
+l'on ne veut pas que le signal "destroy" soit émis, afin de laisser
+notre application tourner. En retournant TRUE, on lui demande
+d'émettre "destroy" qui appellera à son tour notre gestionnaire du
+signal "destroy".
+
+<tscreen><verb>
+gint delete_event(GtkWidget *widget, GdkEvent *event, gpointer data)
+{
+    g_print ("le signal delete_event est survenu.\n");
+
+    return (FALSE); 
+}
+</verb></tscreen>
+
+<p>
+Voici une autre fonction de rappel qui ne fait que quitter
+l'application en appelant <em/gtk_main_quit()/.  Il n'y a pas grand
+chose de plus à dire car elle est plutôt triviale&nbsp;:
+
+<tscreen><verb>
+void destroy (GtkWidget *widget, gpointer *data)
+{
+    gtk_main_quit ();
+}
+</verb></tscreen>
+<p>
+Je suppose que vous connaissez la fonction <em/main()/... oui, comme
+les autres programmes C, toutes les applications GTK en ont une.
+
+<tscreen><verb> 
+int main (int argc, char *argv[]) 
+{ 
+</verb></tscreen>
+<p>
+La partie qui suit déclare deux pointeurs sur des structures de type
+<em/GtkWidget/.  Ceux-ci sont utilisés plus loin pour créer une
+fenêtre et un bouton.
+
+<tscreen><verb>
+    GtkWidget *window;
+    GtkWidget *button;
+</verb></tscreen>
+<p>
+Et revoici notre <em/gtk_init/.  Comme précédemment, il initialise le toolkit
+et analyse les paramètres de la ligne de commande. Il supprime chaque
+paramètre reconnu de la liste et modifie <em/argc/ et <em/argv/ pour
+faire comme si ces paramètres n'avaient jamais existé, laissant notre
+application analyser les paramètres restants.
+
+<tscreen><verb>
+    gtk_init (&amp;argc, &amp;argv);
+</verb></tscreen>
+<p>
+Création d'une nouvelle fenêtre. C'est plutôt classique. La mémoire
+est allouée pour une structure <em/GtkWidget/ et <em/window/ pointe
+donc sur celle-ci. Cela configure une nouvelle fenêtre, mais celle-ci
+ne sera pas affichée tant que l'on n'a pas appelé
+<em/gtk_widget_show(window)/ vers la fin de notre programme.
+
+<tscreen><verb>
+    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+</verb></tscreen>
+<p>
+Voici maintenant un exemple de connexion d'un gestionnaire de signal à
+un objet&nbsp;: la fenêtre. Le signal "destroy" est capturé. Il est
+émis lorsqu'on utilise le gestionnaire de fenêtres pour tuer la
+fenêtre (et que l'on retourne TRUE dans le gestionnaire
+"delete_event"), ou lorsqu'on utilise l'appel
+<em/gtk_widget_destroy()/ en lui passant le widget <em/window/ comme
+objet à détruire.  Ici, on appelle juste la fonction <em/destroy()/
+définie ci-dessus avec le paramètre NULL, ce qui quitte GTK pour
+nous.
+<p>
+<tt/GTK_OBJECT/ et <tt/GTK_SIGNAL_FUNC/ sont des macros qui réalisent
+les conversions et les vérifications de types pour nous. Elles rendent
+aussi le code plus lisible.
+
+<tscreen><verb>
+    gtk_signal_connect (GTK_OBJECT (window), "destroy",
+			GTK_SIGNAL_FUNC (destroy), NULL);
+</verb></tscreen>
+<p>
+La fonction suivante sert à configurer un attribut d'un objet
+container. Elle configure simplement la fenêtre pour qu'elle ait une
+zone vide autour d'elle de 10 pixels de large où aucun widget ne
+pourra se trouver. Il existe d'autres fonctions similaires que nous
+verrons dans la section sur la
+<ref id="sec_setting_widget_attributes" 
+name="Configuration des attributs des widgets">
+<p>
+À nouveau, <tt/GTK_CONTAINER/ est une macro réalisant la conversion de type.
+<tscreen><verb>
+    gtk_container_border_width (GTK_CONTAINER (window), 10);
+</verb></tscreen>
+<p>
+Cet appel crée un nouveau bouton. Il alloue l'espace mémoire pour une
+nouvelle structure GtkWidget, l'initialise et fait pointer <em/button/
+vers elle. Ce bouton portera le label « Bonjour tout le monde »
+lorsqu'il sera affiché.
+
+<tscreen><verb>
+    button = gtk_button_new_with_label ("Bonjour tout le monde");
+</verb></tscreen>
+<p>
+Maintenant, prenons ce bouton et faisons lui faire quelque chose
+d'utile. On lui attache un gestionnaire de signal pour que, lorsqu'il
+émettra le signal "clicked", notre fonction <em/hello()/ soit
+appelée. On ignore les paramètres et on ne passe donc que la valeur
+NULL à la fonction de rappel <em/hello()/.  Évidemment, le signal
+"clicked" est émis lorsqu'on clique sur le bouton avec la souris.
+
+<tscreen><verb>
+    gtk_signal_connect (GTK_OBJECT (button), "clicked",
+			GTK_SIGNAL_FUNC (hello), NULL);
+</verb></tscreen>
+<p>
+On utilisera aussi ce bouton pour quitter notre programme, ce qui
+permettra d'illustrer la façon dont le signal "destroy" peut venir
+soit du gestionnaire de fenêtres, soit de notre programme. Quand le
+bouton est "clicked" comme cela est décrit plus haut, il appelle
+d'abord la fonction de rappel <em/hello()/ puis celle-ci dans l'ordre
+dans lequel elles sont configurées. On peut avoir autant de fonctions
+de rappel que l'on désire, elles seront exécutées selon leur ordre de
+connexion. Puisque la fonction <em/gtk_widget_destroy()/ n'accepte que
+<em/GtkWidget *widget/ comme paramètre, on utilise ici la fonction
+<em/gtk_signal_connect_object()/ à la place de
+<em/gtk_signal_connect()/.
+
+<tscreen><verb>
+    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+			       GTK_SIGNAL_FUNC (gtk_widget_destroy),
+			       GTK_OBJECT (window));
+</verb></tscreen>
+<p>
+Voici un appel de placement, qui sera expliqué en détail plus tard,
+mais qui est plutôt facile à comprendre. Il indique simplement à GTK
+que le bouton doit être placé dans la fenêtre où il s'affichera.
+
+<tscreen><verb> gtk_container_add (GTK_CONTAINER (window), button);
+</verb></tscreen>
+<p>
+Maintenant, nous avons tout configuré comme on le souhaitait&nbsp;:
+les gestionnaires de signaux sont en place et le bouton est mis dans
+la fenêtre où il doit se trouver. On demande alors à GTK de « montrer
+» les widgets à l'écran. Le widget <em/window/ est affiché en dernier
+afin que la fenêtre entière surgisse d'un coup plutôt que voir d'abord
+la fenêtre s'afficher puis ensuite le bouton apparaître à
+l'intérieur. Il faut dire qu'avec des exemples simples comme celui-ci,
+vous ne ferez pas la différence.  
+<tscreen><verb> 
+    gtk_widget_show(button);
+
+    gtk_widget_show (window);
+</verb></tscreen>
+<p>
+Bien sûr, on appelle <em/gtk_main()/ qui attendra les événements
+venant du serveur X et demandera aux widgets d'émettre les signaux
+lorsque ces événements surviendront.
+<tscreen><verb>
+    gtk_main ();
+</verb></tscreen>
+Enfin, le <em/return/ final. Il est exécuté lorsque <em/gtk_quit()/ est appelé.
+<tscreen><verb>
+    return 0;
+</verb></tscreen>
+<p>
+Lorsque l'on clique sur un bouton GTK, le widget émet un
+signal "clicked". Afin de pouvoir utiliser cette information, notre
+programme configure un gestionnaire pour capturer ce signal. Ce
+gestionnaire appelle la fonction de notre choix. Dans notre exemple,
+lorsque le bouton que l'on a créé est "clicked", la fonction
+<em/hello()/ est appelée avec le paramètre NULL, puis le gestionnaire
+suivant de ce signal est à son tour appelé. Il appelle la fonction
+<em/gtk_widget_destroy()/ en lui passant le widget <em/window/ comme
+paramètre, ce qui provoque la destruction de celui-ci. Ceci
+force la fenêtre à envoyer un signal "destroy", qui est capturé à son
+tour et appelle notre fonction de rappel <em/destroy()/ qui ferme
+simplement GTK.
+<p>
+Une autre façon de procéder consiste à utiliser le gestionnaire de
+fenêtres pour détruire la fenêtre. Cela provoquera l'émission du
+signal "delete_event" qui sera pris en charge par notre gestionnaire
+<em/delete_event()/. S'il retourne FALSE, la fenêtre restera telle
+quelle et rien ne se passera. Retourner TRUE forcera GTK à émettre
+le signal "destroy" qui, bien sûr, appelera la fonction de rappel
+<em/destroy()/ provoquant la sortie du GTK.  <p> 
+On remarquera que ces signaux ne sont pas les mêmes que les signaux
+systèmes Unix et ne sont pas implantés en utilisant ceux-ci, bien que
+la terminologie employée soit presque identique.
+
+
+<sect>Continuons
+<p>
+<sect1>Types de données
+<p>
+Vous avez probablement noté certaines choses qui nécessitent des
+explications dans les exemples précédents. les <em/gint/, <em/gchar/,
+etc. que vous avez pu voir sont des redéfinitions de <em/int/ et
+<em/char/, respectivement. Leur raison d'être est de s'affranchir des
+dépendances ennuyeuses concernant la taille des types de données
+simples lorsqu'on réalise des calculs. Un bon exemple est <em/gint32/
+qui désignera un entier codé sur 32 bits pour toutes les plateformes,
+que ce soit une station Alpha 64 bits ou un PC i386 32 bits. Les
+redéfinitions de type sont très simples et intuitives. Elles sont
+toutes décrites dans le fichier <em>glib/glib.h</em> (qui est inclus
+par <em/gtk.h/).
+<p>
+On notera aussi la possibilité d'utiliser un <em/GtkWidget/ lorsque la
+fonction attend un <em/GtkObject/. GTK possède une architecture
+orientée objet, et un widget est un objet.
+
+<sect1>Compléments sur les gestionnaires de signaux
+<p>
+Regardons à nouveau la déclaration de <em/gtk_signal_connect/.
+
+<tscreen><verb>
+gint gtk_signal_connect (GtkObject *object, gchar *name,
+			 GtkSignalFunc func, gpointer func_data);
+</verb></tscreen>
+
+Vous avez remarqué que le valeur de retour est de type <em/gint/ ? Il
+s'agit d'un marqueur qui identifie votre fonction de rappel. Comme on
+le disait plus haut, on peut avoir autant de fonctions de rappel que
+l'on a besoin, par signal et par objet, et chacune sera exécutée à son
+tour, dans l'ordre dans lequel elle a été attachée. Ce marqueur vous
+permet d'ôter ce rappel de la liste en faisant&nbsp&;: 
+
+<tscreen><verb>
+      void gtk_signal_disconnect (GtkObject *object, gint id);
+</verb></tscreen> 
+
+Ainsi, en passant le widget dont on veut supprimer le gestionnaire et
+le marqueur ou identificateur retourné par l'une des fonctions
+<em/signal_connect/, on peut déconnecter un gestionnaire de signal.
+<p>
+Une autre fonction permettant de supprimer tous les gestionnaires de
+signaux pour un objet est&nbsp;: 
+
+<tscreen><verb>
+      gtk_signal_handlers_destroy (GtkObject *object); 
+</verb></tscreen>
+<p>
+Cet appel n'a pas trop besoin d'explications. Il ôte simplement tous
+les gestionnaires de signaux de l'objet passé en paramètre.
+
+
+<sect1>Un « Bonjour tout le monde » amélioré
+<p>
+Étudions une version légèrement améliorée avec de meilleurs exemples
+de fonctions de rappel. Ceci permettra aussi d'introduire le sujet
+suivant&nbsp;: le placement des wigdets.
+
+<tscreen><verb>
+#include <gtk/gtk.h>
+
+/* Notre nouveau rappel amélioré. La donnée passée à cette fonction est
+ * imprimée sur stdout. */
+
+void rappel (GtkWidget *widget, gpointer *data)
+{
+    g_print ("Re-Bonjour - %s a été pressé\n", (char *) data);
+}
+
+/* Un autre rappel */
+
+void delete_event (GtkWidget *widget, GdkEvent *event, gpointer *data)
+{
+    gtk_main_quit ();
+}
+
+int main (int argc, char *argv[])
+{
+    /* GtkWidget est le type pour déclarer les widgets */
+
+    GtkWidget *window;
+    GtkWidget *button;
+    GtkWidget *box1;
+
+    /* Cette fonction est appelée dans toutes les applications GTK. 
+     * Les paramètre passés en ligne de commande sont analysés et 
+     * retournés à l'application. */
+
+    gtk_init (&amp;argc, &amp;argv);
+
+    /* Création d'une nouvelle fenêtre. */
+
+    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+    /* Nouvel appel qui intitule notre nouvelle fenêtre 
+     * "Salut les boutons !" */
+
+    gtk_window_set_title (GTK_WINDOW (window), "Salut les boutons !");
+
+    /* Configuration d'un gestionnaire pour "delete_event" afin de
+     * quitter immédiatement GTK. */
+
+    gtk_signal_connect (GTK_OBJECT (window), "delete_event",
+			GTK_SIGNAL_FUNC (delete_event), NULL);
+
+
+    /* Configuration de la largeur du contour de la fenêtre. */
+    
+    gtk_container_border_width (GTK_CONTAINER (window), 10);
+
+    /* Création d'une boîte pour y placer les widgets.
+     * Ceci est décrit en détails plus loin dans la section 
+     * « placement ». La boîte n'est pas matérialisée, elle est juste
+     * utilisée comme moyen d'arranger les widgets. */
+
+    box1 = gtk_hbox_new(FALSE, 0);
+
+    /* On met la boîte dans la fenêtre principale. */
+
+    gtk_container_add (GTK_CONTAINER (window), box1);
+
+    /* On crée un nouveau bouton portant le label « Bouton 1 ». */
+
+    button = gtk_button_new_with_label ("Bouton 1");
+
+    /* Lorsque le bouton est cliqué, on appelle la fonction « rappel » 
+     * avec un pointeur sur la chaîne « Bouton 1 » comme paramètre. */
+
+    gtk_signal_connect (GTK_OBJECT (button), "clicked",
+			GTK_SIGNAL_FUNC (rappel), (gpointer) "Bouton 1");
+
+    /* Au lieu d'utiliser gtk_container_add, on place ce bouton dans
+     * la boîte invisible qui a été placée dans la fenêtre. */
+
+    gtk_box_pack_start(GTK_BOX(box1), button, TRUE, TRUE, 0);
+
+    /* N'oubliez jamais cette étape qui indique à GTK que la configuration
+     * de ce bouton est terminée et qu'il peut être affiché. */
+
+    gtk_widget_show(button);
+
+    /* On fait la même chose pour créer un deuxième bouton. */
+
+    button = gtk_button_new_with_label ("Bouton 2");
+
+    /* On appelle la même fonction de rappel avec un paramètre différent,
+     * un pointeur sur la chaîne « Bouton 2 ». */
+
+    gtk_signal_connect (GTK_OBJECT (button), "clicked",
+			GTK_SIGNAL_FUNC (rappel), (gpointer) "Bouton 2");
+
+    gtk_box_pack_start(GTK_BOX(box1), button, TRUE, TRUE, 0);
+
+    /* L'ordre dans lequel on affiche les boutons n'est pas vraiment
+     * important, mais il est préférable d'afficher la fenêtre en dernier
+     * pour qu'elle surgisse d'un coup. */
+
+    gtk_widget_show(button);
+
+    gtk_widget_show(box1);
+
+    gtk_widget_show (window);
+
+    /* Le reste est dans gtk_main et on attend que la fête commence ! */
+
+    gtk_main ();
+
+    return 0;
+}
+</verb></tscreen>
+<p>
+Compilez ce programme en utilisant les mêmes paramètres que pour
+l'exemple précédent. Vous remarquerez que, maintenant, il est plus
+difficile de quitter le programme&nbsp;: vous devez utiliser le
+gestionnaire de fenêtres ou une commande shell pour le détruire. Un
+bon exercice pour le lecteur serait d'insérer un troisième bouton «
+Quitter » qui permettrait de sortir du programme. Vous pouvez aussi
+jouer avec les options de <em/gtk_box_pack_start()/ en lisant la
+section suivante. Essayez de redimensionner la fenêtre, et observez
+son comportement.
+<p>
+Juste une remarque&nbsp;: il existe une autre constante utilisable
+avec <em/gtk_window_new()/ - GTK_WINDOW_DIALOG.  Ceci permet
+d'interagir de façon un peu différente avec le gestionnaire de
+fenêtres et doit être utilisé pour les fenêtres temporaires comme les
+boîtes de dialogue, par exemple.
+
+<sect>Placement des widgets
+<p>
+Lorsqu'on crée une application, on veut mettre plus qu'un simple
+bouton dans une fenêtre. Notre premier exemple « Bonjour le monde »
+n'utilisait qu'un seul widget et on pouvait donc simplement faire un
+appel à <em/gtk_container_add/ pour « placer » le widget dans la
+fenêtre. Mais si l'on désire en mettre plus, comment peut-on contrôler
+l'endroit où le widget sera positionné ? C'est ici que le placement
+entre en jeu.
+
+<sect1>Théorie des boîtes de placement
+<p>
+La majeure partie du placement est faites en créant des boîtes comme
+dans l'exemple ci-dessus. Ce sont des widgets containers invisibles où
+l'on peut placer nos widgets. Elles existent sous deux formes&nbsp;:
+boîtes horizontales et boîtes verticales. Lorsque l'on place des
+widgets dans une boîte horizontale, les objets sont insérés
+horizontalement de gauche à droite ou de droite à gauche selon l'appel
+utilisé. Dans une boîte verticale, les widgets sont placés de haut en
+bas ou vice versa. On peut utiliser n'importe quelle combinaison de
+boîtes à l'intérieur ou à côté d'autres boîtes pour créer l'effet
+désiré.
+<p>
+Pour créer une nouvelle boîte horizontale, on appelle
+<em/gtk_hbox_new()/, et pour les boîtes verticales,
+<em/gtk_vbox_new()/. Les fonctions <em/gtk_box_pack_start()/ et
+<em/gtk_box_pack_end()/ servent à placer les objets à l'intérieur de
+ces containers.  La fonction <em/gtk_box_pack_start()/ placera de haut
+en bas dans une boîte verticale et de gauche à droite dans une boîte
+horizontale.  <em/gtk_box_pack_end()/ fera le contraire en plaçant de
+bas en haut et de droite à gauche. En utilisant ces fonctions, on peut
+aligner à droite ou à gauche nos widgets et même les mélanger de
+n'importe quelle façon pour obtenir l'effet désiré. Dans la plupart de
+nos exemples, on utilisera <em/gtk_box_pack_start()/. Un objet peut
+être un autre container ou un widget. En fait, de nombreux widgets
+(dont les boutons) sont eux-mêmes des containers, mais on utilise
+généralement seulement un label dans un bouton.
+<p>
+En utilisant ces appels, GTK sait où vous voulez placer vos widgets et
+il peut donc les dimensionner automatiquement et faire d'autres choses
+bien pratiques. Il existe aussi plusieurs options permettant de
+préciser comment les widgets doivent être placés. Comme vous pouvez
+l'imaginer, cette méthode nous donne pas mal de liberté pour placer et
+créer les widgets.
+
+<sect1>Détails sur les boîtes
+<p>
+À cause de cette liberté, le placement des boîtes avec GTK peut
+paraître déroutant au premier abord. Il existe beaucoup d'options et
+il n'est pas tout de suite évident de comprendre comment elles
+s'accordent toutes ensemble. En fait, il y a 5 styles de base
+différents.
+
+<p>
+<?  
+<IMG ALIGN="center" SRC="packbox1.gif"
+VSPACE="15" HSPACE="10" ALT="Box Packing Example Image" WIDTH="528"
+HEIGHT="235">
+>
+
+Chaque ligne contient une boîte horizontale (<em/hbox/) contenant
+plusieurs boutons. L'appel à <em/gtk_box_pack/ indique la façon dont
+sont placés tous les boutons dans la hbox.  Chaque bouton est placé
+dans la hbox de la même façon (mêmes paramètres que la fonction
+<em/gtk_box_pack_start()/).
+<p>
+Voici la déclaration de la fonction <em/gtk_box_pack_start/.
+
+<tscreen><verb>
+void gtk_box_pack_start (GtkBox    *box,
+			 GtkWidget *child,
+			 gint	    expand,
+			 gint	    fill,
+			 gint	    padding);
+</verb></tscreen>
+
+Le premier paramètre est la boîte dans laquelle on place l'objet, le
+second est cet objet. Tous les objets sont tous des boutons jusqu'à
+maintenant, on place donc des boutons dans des boîtes.
+<p>
+Le paramètre <em/expand/ de <em/gtk_box_pack_start()/ ou
+<em/gtk_box_pack_end()/ contrôle la façon dont le widget est placé
+dans la boîte. S'il vaut TRUE, les widgets sont disposés dans la boîte
+de façon à en occuper tout l'espace. S'il vaut FALSE, la boîte est
+rétrécie pour correspondre à la taille du widget. Mettre <em/expand/ à
+FALSE vous permettra d'aligner à droite et à gauche vos
+widgets. Sinon, ils s'élargiront pour occuper toute la boîte. Le même
+effet pourrait être obtenu en utilisant uniquement une des deux
+fonctions <em/gtk_box_pack_start/ ou <em/pack_end/.
+<p>
+Le paramètre <em/fill/ des fonctions <em/gtk_box_pack/ contrôle si de
+l'espace supplémentaire doit être alloué aux objets eux-mêmes (TRUE),
+ou si on doit rajouter de l'espace (<em/padding/) dans la boîte autour
+des objets (FALSE). Il n'a de sens que si le paramètre <em/expand/
+vaut TRUE.
+<p>
+Lorsque l'on crée une nouvelle boîte, on utilise une fonction comme&nbsp;:
+
+<tscreen><verb>
+GtkWidget * gtk_hbox_new (gint homogeneous,
+			  gint spacing);
+</verb></tscreen>
+
+Le paramètre <em/homogeneous/ de <em/gtk_hbox_new/ (et c'est la même
+chose pour <em/gtk_vbox_new/) vérifie que chaque objet de la boîte ait
+la même taille (i.e. la même largeur dans une hbox, la même hauteur
+dans une vbox). S'il vaut TRUE, le paramètre <em/expand/ des fonctions
+<em/gtk_box_pack/ sera toujours mis à TRUE.
+<p>
+Quelle est alors la différence entre les paramètres <em/spacing/
+(configuré lorsque la boîte est créée) et <em/padding/ (configuré
+lorque les éléments sont placés) ? <em/spacing/ ajoute de l'espace
+entre les objets, et <em/padding/ en ajoute de chaque côté d'un
+objet. La figure suivante devrait éclairer tout cela&nbsp;:
+
+<?
+<IMG ALIGN="center" SRC="packbox2.gif"
+VSPACE="15" HSPACE="10" ALT="Box Packing Example Image" WIDTH="509"
+HEIGHT="213">
+>
+
+Voici le code utilisé pour créer les images ci-dessus. J'y ai mis beaucoup de
+commentaires en espérant que vous n'aurez pas de problème pour le
+relire. Compilez-le et jouez avec les différents paramètres.
+
+<sect1>Programme de démonstration des placements
+<p>
+
+<tscreen><verb>
+#include "gtk/gtk.h"
+
+void
+delete_event (GtkWidget *widget, GdkEvent *event, gpointer *data)
+{
+    gtk_main_quit ();
+}
+
+/* Construction d'une nouvelle hbox remplie de boutons. Les paramètres qui 
+ * nous intéressent sont passés à cette fonction.
+ * On n'affiche pas la boîte, mais tout ce qu'elle contient. */
+
+GtkWidget *make_box (gint homogeneous, gint spacing,
+		     gint expand, gint fill, gint padding) 
+{
+    GtkWidget *box;
+    GtkWidget *button;
+    char padstr[80];
+    
+    /* Création d'une hbox avec les paramètres homogeneous et spacing
+     * voulus. */
+
+    box = gtk_hbox_new (homogeneous, spacing);
+    
+    /* Création d'une série de boutons configurés de façon appropriée */
+
+    button = gtk_button_new_with_label ("gtk_box_pack");
+    gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
+    gtk_widget_show (button);
+    
+    button = gtk_button_new_with_label ("(box,");
+    gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
+    gtk_widget_show (button);
+    
+    button = gtk_button_new_with_label ("button,");
+    gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
+    gtk_widget_show (button);
+    
+    /* Création d'un bouton portant un label dépendant de la valeur
+     * du paramètre expand. */
+
+    if (expand == TRUE)
+	    button = gtk_button_new_with_label ("TRUE,");
+    else
+	    button = gtk_button_new_with_label ("FALSE,");
+    
+    gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
+    gtk_widget_show (button);
+    
+    /* Même chose que ci-dessus mais sous forme abrégée. */
+
+    button = gtk_button_new_with_label (fill ? "TRUE," : "FALSE,");
+    gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
+    gtk_widget_show (button);
+    
+    /* Récupération du paramètre padding sous forme de chaîne. */
+
+    sprintf (padstr, "%d);", padding);
+    
+    button = gtk_button_new_with_label (padstr);
+    gtk_box_pack_start (GTK_BOX (box), button, expand, fill, padding);
+    gtk_widget_show (button);
+    
+    return box;
+}
+
+int main (int argc, char *argv[])
+{
+    GtkWidget *window;
+    GtkWidget *button;
+    GtkWidget *box1;
+    GtkWidget *box2;
+    GtkWidget *separator;
+    GtkWidget *label;
+    GtkWidget *quitbox;
+    int which;
+    
+    /* Initialisation, à ne jamais oublier ! :) */
+
+    gtk_init (&amp;argc, &amp;argv);
+   
+    if (argc != 2) {
+	fprintf (stderr, "usage : %s num, où num vaut 1, 2, ou 3.\n", *argv);
+
+	/* Nettoyage dans GTK et sortie avec un code d'erreur de 1 */
+	gtk_exit (1);
+    }
+    
+    which = atoi (argv[1]);
+
+    /* Création de notre fenêtre. */
+
+    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+    /* Il ne faut jamais oublier de connecter le signal "destroy" à la
+     * fenêtre principale. C'est très important pour disposer d'un 
+     * comportement intuitif adéquat. */
+
+    gtk_signal_connect (GTK_OBJECT (window), "delete_event",
+			GTK_SIGNAL_FUNC (delete_event), NULL);
+
+    gtk_container_border_width (GTK_CONTAINER (window), 10);
+    
+
+    /* Création d'une boîte verticale (vbox) pour y placer les boîtes
+     * horizontales.
+     * Ceci permet de placer les boîtes horizontales contenant les boutons
+     * les unes au dessus des autres dans cette vbox. */
+
+    box1 = gtk_vbox_new (FALSE, 0);
+    
+    /* L'exemple à afficher. Ils correspondent aux images ci-dessus. */
+
+    switch (which) {
+    case 1:
+	/* Création d'un label. */
+
+	label = gtk_label_new ("gtk_hbox_new (FALSE, 0);");
+	
+	/* Alignement du label à gauche.  On précisera cette fonction ainsi
+         * que les autres dans la section sur les attributs des widgets. */
+
+	gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
+
+	/* Placement du label dans la boîte verticale (vbox box1). Il ne
+         * faut pas oublier que les widgets qui s'ajoutent à une vbox sont
+         * placés les uns au dessus des autres. */
+
+	gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
+	
+	/* Affichage du label */
+
+	gtk_widget_show (label);
+	
+	/* On appelle notre fonction de construction de boîte :
+         * homogeneous = FALSE, spacing = 0,
+	 * expand = FALSE, fill = FALSE, padding = 0 */
+
+	box2 = make_box (FALSE, 0, FALSE, FALSE, 0);
+	gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
+	gtk_widget_show (box2);
+
+	/* On appelle notre fonction de construction de boîte :
+         * homogeneous = FALSE, spacing = 0,
+	 * expand = FALSE, fill = FALSE, padding = 0 */
+
+	box2 = make_box (FALSE, 0, TRUE, FALSE, 0);
+	gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
+	gtk_widget_show (box2);
+	
+	/* Paramètres : homogeneous = FALSE, spacing = 0, 
+         * expand = TRUE, fill = TRUE, padding = 0 */
+
+	box2 = make_box (FALSE, 0, TRUE, TRUE, 0);
+	gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
+	gtk_widget_show (box2);
+	
+	/* Création d'un séparateur, on verra cela plus tard, mais ils sont
+         * simples à utiliser. */
+
+	separator = gtk_hseparator_new ();
+	
+	/* Placement du séparateur dans la vbox. Ne pas oublier que tous les
+         * widgets sont placés dans une vbox et qu'il seront placés 
+         * verticalement. */
+
+	gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
+	gtk_widget_show (separator);
+	
+	/* Création d'un nouveau label et affichage de celui-ci. */
+
+	label = gtk_label_new ("gtk_hbox_new (TRUE, 0);");
+	gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
+	gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
+	gtk_widget_show (label);
+	
+	/* Paramètres : homogeneous = TRUE, spacing = 0, 
+         * expand = TRUE, fill = FALSE, padding = 0 */
+
+	box2 = make_box (TRUE, 0, TRUE, FALSE, 0);
+	gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
+	gtk_widget_show (box2);
+	
+	/* Paramètres : homogeneous = TRUE, spacing = 0, 
+         * expand = TRUE, fill = TRUE, padding = 0 */
+
+	box2 = make_box (TRUE, 0, TRUE, TRUE, 0);
+	gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
+	gtk_widget_show (box2);
+	
+	/* Un autre séparateur */
+
+	separator = gtk_hseparator_new ();
+
+	/* Les 3 derniers paramètres de gtk_box_pack_start sont : 
+         * expand = FALSE, fill = TRUE, padding = 5. */
+
+	gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
+	gtk_widget_show (separator);
+	
+	break;
+
+    case 2:
+
+	/* Création d'un label, box1 est une vbox identique à 
+         * celle créée au début de main() */
+
+	label = gtk_label_new ("gtk_hbox_new (FALSE, 10);");
+	gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
+	gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
+	gtk_widget_show (label);
+	
+	/* Paramètres : homogeneous = FALSE, spacing = 10, 
+         * expand = TRUE, fill = FALSE, padding = 0 */
+
+	box2 = make_box (FALSE, 10, TRUE, FALSE, 0);
+	gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
+	gtk_widget_show (box2);
+	
+	/* Paramètres : homogeneous = FALSE, spacing = 10, 
+         * expand = TRUE, fill = TRUE, padding = 0 */
+
+	box2 = make_box (FALSE, 10, TRUE, TRUE, 0);
+	gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
+	gtk_widget_show (box2);
+	
+	separator = gtk_hseparator_new ();
+
+        /* Les 3 derniers paramètres de gtk_box_pack_start sont : 
+         * expand = FALSE, fill = TRUE, padding = 5. */
+
+	gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
+	gtk_widget_show (separator);
+	
+	label = gtk_label_new ("gtk_hbox_new (FALSE, 0);");
+	gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
+	gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 0);
+	gtk_widget_show (label);
+	
+        /* Paramètres : homogeneous = FALSE, spacing = 0, 
+         * expand = TRUE, fill = FALSE, padding = 10 */
+
+	box2 = make_box (FALSE, 0, TRUE, FALSE, 10);
+	gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
+	gtk_widget_show (box2);
+	
+	/* Paramètres : homogeneous = FALSE, spacing = 0, 
+         * expand = TRUE, fill = TRUE, padding = 10 */
+
+	box2 = make_box (FALSE, 0, TRUE, TRUE, 10);
+	gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
+	gtk_widget_show (box2);
+	
+	separator = gtk_hseparator_new ();
+
+        /* Les 3 derniers paramètres de gtk_box_pack_start sont : 
+         * expand = FALSE, fill = TRUE, padding = 5. */
+        
+	gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
+	gtk_widget_show (separator);
+	break;
+    
+    case 3:
+
+        /* Ceci est une démonstration de la possibilité d'utiliser 
+         * gtk_box_pack_end() pour aligner les widgets à droite.
+         * On crée d'abord une nouvelle boîte comme d'habitude. */
+
+	box2 = make_box (FALSE, 0, FALSE, FALSE, 0);
+
+	/* On crée le label qui sera mis à la fin. */
+
+	label = gtk_label_new ("end");
+
+	/* On le place en utilisant gtk_box_pack_end(), il est ainsi
+         * mis à droite de la hbox créée par l'appel à make_box(). */
+
+	gtk_box_pack_end (GTK_BOX (box2), label, FALSE, FALSE, 0);
+
+	/* Affichage du label. */
+
+	gtk_widget_show (label);
+	
+	/* Placement de box2 dans box1 (la vbox, vous vous rappelez ? :) */
+
+	gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, FALSE, 0);
+	gtk_widget_show (box2);
+	
+	/* Séparateur pour le bas. */
+
+	separator = gtk_hseparator_new ();
+
+	/* Configuration du séparateur en 400x5 pixels. 
+         * La hbox que l'on a créée aura donc 400 pixels de large, 
+         * et le label "end" sera séparé des autres de la hbox.
+         * Sinon, tous les widgets de la hbox seraient placés les plus
+         * près possible les uns des autres. */
+
+	gtk_widget_set_usize (separator, 400, 5);
+
+	/* Placement du séparateur dans la vbox (box1) 
+         * créée au debut de main(). */
+
+	gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 5);
+	gtk_widget_show (separator);    
+    }
+    
+    /* Création d'une nouvelle hbox.. vous pouvez en utiliser autant que
+     * que vous en avez besoin ! */
+
+    quitbox = gtk_hbox_new (FALSE, 0);
+    
+    /* Notre bouton pour quitter. */
+
+    button = gtk_button_new_with_label ("Quit");
+    
+    /* Configuration du signal pour détruire la fenêtre. Ceci enverra le
+     * signal "destroy" à la fenêtre. Ce signal sera à son tour capturé
+     * par notre gestionnaire de signal défini plus haut. */
+
+    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+			       GTK_SIGNAL_FUNC (gtk_widget_destroy),
+			       GTK_OBJECT (window));
+
+    /* Placement du bouton dans la « quitbox ».
+     * Les 3 derniers paramètres de gtk_box_pack_start sont : 
+     * expand = TRUE, fill = FALSE, padding = 0. */
+
+    gtk_box_pack_start (GTK_BOX (quitbox), button, TRUE, FALSE, 0);
+
+    /* Placement de la quitbox dans la vbox (box1) */
+
+    gtk_box_pack_start (GTK_BOX (box1), quitbox, FALSE, FALSE, 0);
+    
+    /* Placement de la vbox (box1), qui contient maintenant tous nos
+     * widgets, dans la fenêtre principale. */
+
+    gtk_container_add (GTK_CONTAINER (window), box1);
+    
+    /* Affichage */
+
+    gtk_widget_show (button);
+    gtk_widget_show (quitbox);
+    
+    gtk_widget_show (box1);
+
+    /* Affichage de la fenêtre en dernier */
+
+    gtk_widget_show (window);
+    
+    /* Ne pas oublier notre fonction principale. */
+
+    gtk_main ();
+
+    /* Le contrôle revient ici lorsque gtk_main_quit() est appelée,
+     * jusqu'à ce que  gtk_exit() soitutilisée. */
+    
+    return 0;
+}
+</verb></tscreen>
+
+<p>
+<sect1>Placement avec les tables
+<p>
+Étudions une autre méthode de placement&nbsp;: les tables. Elles
+peuvent s'avérer très utiles dans certaines situations.
+
+En utilisant des tables, on crée une grille dans laquelle on peut
+placer les widgets. Ceux-ci peuvent occuper tous les endroits que l'on
+désire.
+
+La première chose à faire est, bien sûr, d'étudier la fonction
+<em/gtk_table_new/&nbsp;:
+
+<tscreen><verb>
+GtkWidget* gtk_table_new (gint rows,
+                          gint columns,
+                          gint homogeneous);
+</verb></tscreen>
+<p>
+Le premier paramètre est le nombre de lignes de la table et le
+deuxième, le nombre de colonnes.
+
+Le paramètre <em/homogeneous/ s'occupe de la façon dont les cases de
+la table seront dimensionnées. Si homogeneous vaut TRUE, les cases
+prennent la taille du plus grand widget de la table. S'il vaut FALSE,
+la taille des cases dépend du widget le plus haut de la ligne et du
+plus large de cette colonne.
+
+Le nombre de lignes et colonnes va de 0 à n, où n est le nombre spécifié dans
+l'appel à <em/gtk_table_new/. Ainsi, avec <em/rows/ = 2 et
+<em/columns/ = 2, la table ressemblera à ceci&nbsp;:
+
+<tscreen><verb>
+ 0          1          2
+0+----------+----------+
+ |          |          |
+1+----------+----------+
+ |          |          |
+2+----------+----------+
+</verb></tscreen>
+<p>
+On notera que le système de coordonnées part du coin en haut à
+gauche. Pour placer un widget dans une case, ou utilise la fonction
+suivante&nbsp;:
+
+<tscreen><verb>
+void gtk_table_attach (GtkTable      *table,
+                       GtkWidget     *child,
+		       gint           left_attach,
+		       gint           right_attach,
+		       gint           top_attach,
+		       gint           bottom_attach,
+		       gint           xoptions,
+		       gint           yoptions,
+		       gint           xpadding,
+		       gint           ypadding);
+</verb></tscreen>				       
+<p>
+Où le premier paramètre (<em/table/) est la table que l'on a créée et
+le second (<em/child/) est le widget que l'on veut placer dans la
+table.
+
+Les paramètres <em/left_attach/ et <em/right_attach/ spécifient
+l'emplacement du widget et le nombre de cases à utiliser. Par exemple,
+si on veut placer un bouton dans le coin inférieur droit de la table
+décrite plus haut et que l'on désire ne remplir QUE cette case,
+<em/left_attach/ vaudra 1, <em/right_attach/ vaudra 2; <em/top_attach/
+vaudra 1 et <em/bottom_attach/ vaudra 2.
+
+Si on veut un widget occupant toute la ligne supérieure de notre table, on utilisera
+les valeurs 0, 2, 0, 1.
+
+Les paramètres <em/xoptions/ et <em/yoptions/ servent à préciser les
+options de placement et peuvent être combinées par un OU logique pour
+permettre des options multiples.
+
+Ces options sont&nbsp;:
+<itemize>
+<item>GTK_FILL - Si la case de la table est plus large que le widget, et que
+GTK_FILL est spécifié, le widget s'élargira pour occuper toute la place
+disponible.
+
+<item>GTK_SHRINK - Si la table a moins de place qu'il ne lui en faut
+(généralement, à cause d'un redimensionnement de la fenêtre par
+l'utilisateur), les widgets sont alors simplement poussés vers le bas
+de la fenêtre et disparaissent. Si GTK_SHRINK est spécifié, les
+widgets se réduiront en même temps que la table.
+
+<item>GTK_EXPAND - Cette option provoque l'extension de la table pour
+qu'elle utilise tout l'espace restant dans la fenêtre.
+</itemize>
+
+Le paramêtres de <em/padding/ jouent le même rôle que pour les boîtes,
+il créent une zone libre, spécifiée en pixels, autour du widget.
+
+gtk_table_attach() a BEAUCOUP d'options.  Voici donc une fonction-raccourci&nbsp;:
+
+<tscreen><verb>
+void gtk_table_attach_defaults (GtkTable   *table,
+                                GtkWidget  *widget,
+				gint        left_attach,
+				gint        right_attach,
+				gint        top_attach,
+				gint        bottom_attach);
+</verb></tscreen>
+
+<em/xoptions/ et <em/options/ valent par défaut GTK_FILL | GTK_EXPAND,
+et <em/xpadding/ et <em/ypadding/ valent 0. Les autres paramètres sont
+les mêmes que ceux de la fonction précédente.
+
+Il existe aussi les fonctions <em/gtk_table_set_row_spacing()/ et
+<em/gtk_table_set_col_spacing()/. Elles permettent de placer des
+espaces après une ligne ou une colonne.
+
+<tscreen><verb>
+void gtk_table_set_row_spacing (GtkTable      *table,
+                                gint           row,
+				gint           spacing);
+</verb></tscreen>
+et
+<tscreen><verb>
+void gtk_table_set_col_spacing  (GtkTable      *table,
+                                 gint           column,
+				 gint           spacing);
+</verb></tscreen>
+
+Pour les colonnes, l'espace est ajouté à droite de la colonne et pour
+les lignes, il est ajouté en dessous.
+
+On peut aussi configurer un espacement pour toutes les lignes et/ou
+colonnes avec&nbsp;:
+
+<tscreen><verb>
+void gtk_table_set_row_spacings (GtkTable *table,
+                                 gint      spacing);
+</verb></tscreen>
+<p>
+Et,
+<tscreen><verb>
+void gtk_table_set_col_spacings (GtkTable  *table,
+                                 gint       spacing);
+</verb></tscreen>
+<p>
+Avec ces appels, la dernière ligne et la dernière colonne n'ont pas
+d'espace supplémentaire.
+
+<sect1>Exemple de placement avec table
+<p>
+Pour le moment, étudiez l'exemple sur les tables (testgtk.c) distribué
+avec les sources de GTK.
+
+<sect>Vue d'ensemble des widgets
+<p>
+<p>
+Les étapes pour créer un widget en GTK sont&nbsp;:
+<enum>
+<item> <em/gtk_*_new()/ - une des fonctions disponibles pour créer un
+nouveau widget. Ces fonctions sont décrites dans cette section.
+
+<item> Connexion de tous les signaux que l'on souhaite utiliser avec
+les gestionnaires adéquats.
+
+<item> Configuration des attributs du widget.
+
+<item> Placement du widget dans un container en utilisant un appel approprié comme
+<em/gtk_container_add()/ ou <em/gtk_box_pack_start()/.
+
+<item> Affichage du widget grâce à <em/gtk_widget_show()/.
+</enum>
+<p>
+<em/gtk_widget_show()/ permet à GTK de savoir que l'on a fini de
+configurer les attributs du widget et qu'il est prêt à être
+affiché. On peut aussi utiliser <em/gtk_widget_hide()/ pour le faire
+disparaître. L'ordre dans lequel on affiche les widgets n'est pas
+important, mais il est préférable d'afficher la fenêtre en dernier
+pour qu'elle surgisse d'un seul coup plutôt que de voir les différents
+widgets apparaître à l'écran au fur et à mesure. Les fils d'un widget
+(une fenêtre est aussi un widget) ne seront pas affichés tant que la
+fenêtre elle-même n'est pas affichée par la fonction
+<em/gtk_widget_show()/.
+
+<sect1> Conversions de types
+<p>
+Vous remarquerez, au fur et à mesure que vous progressez, que GTK
+utilise un système de coercition de type. Celle-ci est toujours
+réalisée en utilisant des macros qui vérifient si l'objet donné peut
+être converti et qui réalisent cette coercition. Les macros que vous
+rencontrerez le plus sont&nbsp;:
+
+<itemize>
+<item> GTK_WIDGET(widget)
+<item> GTK_OBJECT(object)
+<item> GTK_SIGNAL_FUNC(function)
+<item> GTK_CONTAINER(container)
+<item> GTK_WINDOW(window)
+<item> GTK_BOX(box)
+</itemize>
+
+Elles sont toutes utilisées pour convertir les paramètres des
+fonctions. Vous les verrez dans les exemples et, en règle générale,
+vous saurez les utiliser simplement en regardant la
+déclaration d'une fonction.
+
+Comme vous pouvez le voir dans la hiérarchie de classes ci-dessous,
+tous les <em/GtkWidgets/ dérivent d'une classe de base
+<em/GtkObject/. Ceci signifie que vous pouvez utiliser un widget à
+chaque fois qu'une fonction requiert un objet - il suffit d'utiliser
+la macro GTK_OBJECT().
+
+Par exemple&nbsp;:
+
+<tscreen><verb>
+gtk_signal_connect(GTK_OBJECT(button), "clicked",
+                   GTK_SIGNAL_FUNC(fonction_rappel), donnee_de_rappel);
+</verb></tscreen> 
+
+Cet appel convertit le bouton en objet et fournit une conversion pour
+le pointeur de fonction vers la fonction de rappel.
+
+De nombreux widgets sont aussi des containers. Si vous regardez la
+hiérarchie de classe ci-dessous, vous remarquerez que beaucoup de
+widgets viennent de la classe <em/GtkContainer/. N'importe lequel de
+ces widgets peut être utilisé avec la macro GTK_CONTAINER pour être
+passé en paramètre à une fonction qui attend un container.
+
+Malheureusement, ces macros ne peuvent être couvertes en détail dans
+ce didacticiel, Je vous recommande donc de jeter un coup d'oeil sur
+les fichier en-têtes GTK&nbsp;: ils peuvent s'avérer très
+instructifs. En fait, il n'est pas difficile de comprendre comment
+fonctionne un widget, il suffit d'étudier les déclarations des
+fonctions.
+
+<p>
+<sect1>La hiérarchie des widgets
+<p>
+Voici l'arbre de la hiérarchie de classes utilisées pour implanter les widgets.
+
+<tscreen><verb>
+    GtkObject
+    +-- GtkData
+    |	\-- GtkAdjustment
+    |
+    \-- GtkWidget
+	+-- GtkContainer
+	|   +-- GtkBin
+	|   |	+-- GtkAlignment
+	|   |	+-- GtkFrame
+	|   |	|   *-- GtkAspectFrame
+	|   |	|
+	|   |	+-- GtkItem
+	|   |	|   +-- GtkListItem
+	|   |	|   +-- GtkMenuItem
+	|   |	|   |	+-- GtkCheckMenuItem
+	|   |	|   |	    *-- GtkRadioMenuItem
+	|   |	|   |
+	|   |	|   *-- GtkTreeItem
+	|   |	|
+	|   |	+-- GtkViewport
+	|   |	\-- GtkWindow
+	|   |	    +-- GtkDialog
+	|   |	    \-- GtkFileSelection
+	|   |
+	|   +-- GtkBox
+	|   |	+-- GtkHBox
+	|   |	\-- GtkVBox
+	|   |	    +-- GtkColorSelection
+	|   |	    \-- GtkCurve
+	|   |
+	|   +-- GtkButton
+	|   |	+-- GtkOptionMenu
+	|   |	\-- GtkToggleButton
+	|   |	    \-- GtkCheckButton
+	|   |		\-- GtkRadioButton
+	|   |
+	|   +-- GtkList
+	|   +-- GtkMenuShell
+	|   |	+-- GtkMenu
+	|   |	\-- GtkMenuBar
+	|   |
+	|   +-- GtkNotebook
+	|   +-- GtkScrolledWindow
+	|   +-- GtkTable
+	|   \-- GtkTree
+	|
+	+-- GtkDrawingArea
+	+-- GtkEntry
+	+-- GtkMisc
+	|   +-- GtkArrow
+	|   +-- GtkImage
+	|   +-- GtkLabel
+	|   \-- GtkPixmap
+	|
+	+-- GtkPreview
+	+-- GtkProgressBar
+	+-- GtkRange
+	|   +-- GtkScale
+	|   |	+-- GtkHScale
+	|   |	\-- GtkVScale
+	|   |
+	|   \-- GtkScrollbar
+	|	+-- GtkHScrollbar
+	|	\-- GtkVScrollbar
+	|
+	+-- GtkRuler
+	|   +-- GtkHRuler
+	|   \-- GtkVRuler
+	|
+	\-- GtkSeparator
+	    +-- GtkHSeparator
+	    \-- GtkVSeparator
+
+</verb></tscreen>
+<p>
+
+<sect1>Widgets sans fenêtre
+<p>
+Les widgets suivants n'ont pas de fenêtre associée. Si vous voulez
+capturer des événements, vous devez utiliser <em/GtkEventBox/.
+Reportez-vous à la section sur
+<ref id="sec_The_EventBox_Widget" name="Le widget EventBox">
+
+<tscreen><verb>
+GtkAlignment
+GtkArrow
+GtkBin
+GtkBox
+GtkImage
+GtkItem
+GtkLabel
+GtkPaned
+GtkPixmap
+GtkScrolledWindow
+GtkSeparator
+GtkTable
+GtkViewport
+GtkAspectFrame
+GtkFrame
+GtkVPaned
+GtkHPaned
+GtkVBox
+GtkHBox
+GtkVSeparator
+GtkHSeparator
+</verb></tscreen>
+<p>
+Nous continuerons notre exploration de GTK en examinant chaque widget
+tour à tour, créant quelques fonctions simples pour les afficher. Une
+autre source intéressante est le programme <em/testgtk.c/ livré avec
+GTK. Il se trouve dans le répertoire <em>gtk/</em>
+
+<sect>Widgets boutons
+<p>
+<sect1>Boutons normaux
+<p>
+On a déjà presque vu tout ce qu'il y avait à voir sur le widget
+bouton. Il est très simple. Cependant, il y a deux façons de créer un
+bouton. On peut utiliser <em/gtk_button_new_with_label()/ pour créer
+un bouton avec un label, ou <em/gtk_button_new()/ pour créer un bouton
+vide. Dans ce dernier cas, c'est à vous de placer un label ou un
+pixmap sur celui-ci. Pour ce faire, créez une boîte, puis placez vos
+objets dans celle-ci en utilisant la fonction habituelle
+<em/gtk_box_pack_start/, utilisez alors <em/gtk_container_add/ pour
+placer la boîte dans le bouton.
+<p>
+Voici un exemple d'utilisation de <em/gtk_button_new()/ pour créer un
+bouton contenant une image et un label. J'ai séparé du reste le code
+qui crée une boîte pour que vous puissiez l'utiliser dans vos
+programmes.
+
+
+<tscreen><verb>
+#include <gtk/gtk.h>
+
+
+/* Création d'une hbox avec une image et un label. Cette fonction 
+ * retourne la boîte... */
+
+GtkWidget *xpm_label_box (GtkWidget *parent, gchar *xpm_filename, 
+                          gchar *label_text)
+{
+    GtkWidget *box1;
+    GtkWidget *label;
+    GtkWidget *pixmapwid;
+    GdkPixmap *pixmap;
+    GdkBitmap *mask;
+    GtkStyle *style;
+
+    /* Création de la boite pour un xpm et un label */
+
+    box1 = gtk_hbox_new (FALSE, 0);
+    gtk_container_border_width (GTK_CONTAINER (box1), 2);
+
+    /* Choix d'un style de bouton... Je suppose que c'est pour obtenir
+     * la couleur du fond. Si quelqu'un connaît la vraie raison, qu'il
+     * m'éclaire sur ce point. */
+
+    style = gtk_widget_get_style(parent);
+
+    /* Chargement de xpm pour créer une image */
+
+    pixmap = gdk_pixmap_create_from_xpm (parent->window, &amp;mask,
+					 &amp;style->bg[GTK_STATE_NORMAL],
+					 xpm_filename);
+    pixmapwid = gtk_pixmap_new (pixmap, mask);
+
+    /* Création d'un label  */
+
+    label = gtk_label_new (label_text);
+
+    /* placement de l'image et du label dans la boîte */
+
+    gtk_box_pack_start (GTK_BOX (box1),
+			pixmapwid, FALSE, FALSE, 3);
+
+    gtk_box_pack_start (GTK_BOX (box1), label, FALSE, FALSE, 3);
+
+    gtk_widget_show(pixmapwid);
+    gtk_widget_show(label);
+
+    return (box1);
+}
+
+/* Notre fonction de rappel habituelle */
+
+void callback (GtkWidget *widget, gpointer *data)
+{
+    g_print ("Bonjour - %s a été pressé\n", (char *) data);
+}
+
+
+int main (int argc, char *argv[])
+{
+    /* GtkWidget est le type utilisé pour déclarer les widgets */
+
+    GtkWidget *window;
+    GtkWidget *button;
+    GtkWidget *box1;
+
+    gtk_init (&amp;argc, &amp;argv);
+
+    /* Création d'une fenêtre */
+
+    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+
+    gtk_window_set_title (GTK_WINDOW (window), "Pixmap'd Buttons!");
+
+    /* Il est préférable de faire cela pour toutes les fenêtres */
+
+    gtk_signal_connect (GTK_OBJECT (window), "destroy",
+			GTK_SIGNAL_FUNC (gtk_exit), NULL);
+
+
+    /* Configuration du bord de la fenêtre */
+
+    gtk_container_border_width (GTK_CONTAINER (window), 10);
+
+    /* Création d'un bouton */
+
+    button = gtk_button_new ();
+
+    /* Vous devriez être habitué à voir ces fonctions maintenant */
+
+    gtk_signal_connect (GTK_OBJECT (button), "clicked",
+			GTK_SIGNAL_FUNC (callback), (gpointer) "cool button");
+
+    /* Appel de notre fonction de création de boîte */
+
+    box1 = xpm_label_box(window, "info.xpm", "cool button");
+
+    /* Placement et affichage de tous nos widgets */
+
+    gtk_widget_show(box1);
+
+    gtk_container_add (GTK_CONTAINER (button), box1);
+
+    gtk_widget_show(button);
+
+    gtk_container_add (GTK_CONTAINER (window), button);
+
+    gtk_widget_show (window);
+
+    /* Le reste est dans gtk_main */
+    gtk_main ();
+
+    return 0;
+}
+</verb></tscreen>
+
+La fonction <em/xpm_label_box()/ peut être utilisée pour placer des
+xpms et des labels sur tout widget qui peut être container.
+
+<sect1> Boutons commutateurs
+<p>
+Les boutons commutateurs ressemblent beaucoup aux boutons normaux, sauf
+qu'ils seront toujours alternativement dans un état ou dans un
+autre. Le changement d'état s'effectue par un click. Ils peuvent être
+enfoncés et, lorsqu'on clique dessus, ils se relèvent.  Re-cliquez,
+et ils se renfoncent.
+
+Les boutons commutateurs sont la base des cases à cocher ou des boutons
+radio, donc la plupart des appels utilisés pour les boutons commutateurs
+sont hérités par les cases à cocher et les boutons radio. J'insisterai
+là dessus quand nous les aborderons.
+
+Création d'un bouton commutateur : 
+
+<tscreen><verb>
+GtkWidget* gtk_toggle_button_new (void);
+
+GtkWidget* gtk_toggle_button_new_with_label (gchar *label);
+</verb></tscreen>
+<p>
+Comme vous pouvez l'imaginer, elles fonctionnent comme celles des
+boutons normaux. La première crée un bouton commutateur vide et la
+deuxième un bouton commutateur contenant déjà un label.
+<p>
+Pour récupérer l'état d'un commutateur et cela comprend aussi les
+cases à cocher et les boutons radio, on utilise une macro comme nous
+le montrons dans l'exemple qui suit et qui teste l'état du commutateur
+dans une fonction de rappel. Le signal qui nous intéresse et qui est
+émis par les boutons commutateurs (ce qui comprend aussi les cases à
+cocher et les boutons radio), est le signal "toggled". Pour vérifier
+l'état de ces boutons, on configure un gestionnaire de signal qui
+capture "toggled" et utilise la macro pour déterminer l'état. La
+fonction de rappel ressemblera à ceci&nbsp;:
+
+<tscreen><verb>
+void rappel_bouton_commutateur (GtkWidget *widget, gpointer data)
+{
+    if (GTK_TOGGLE_BUTTON(widget)->active) 
+    {
+        /* Si l'on est ici, c'est que le bouton est relâché. */
+    
+    } else {
+    
+        /* le bouton est enfoncé */
+    }
+}
+</verb></tscreen>
+
+<!--
+
+COMMENTED!
+
+<tscreen><verb>
+guint gtk_toggle_button_get_type (void);
+</verb></tscreen>
+<p>
+No idea... they all have this, but I dunno what it is :)
+
+
+<tscreen><verb>
+void gtk_toggle_button_set_mode (GtkToggleButton *toggle_button,
+                                 gint draw_indicator);
+</verb></tscreen>
+<p>
+No idea.
+-->
+
+<p>
+L'appel qui suit peut être utilisé pour configurer l'état d'un bouton
+commutateur et de ses descendants, les cases à cocher et les boutons
+radio. On lui passe notre bouton en premier paramètre et TRUE ou
+FALSE pour spécifier s'il doit être relâché ou enfoncé. Par défaut, il
+est relâché (FALSE).
+
+<tscreen><verb>
+void gtk_toggle_button_set_state (GtkToggleButton *toggle_button,
+                                  gint state);
+</verb></tscreen>
+<p>
+On notera que lorsqu'on utilise cette fonction, et que l'état est
+modifié, cela force le bouton à émettre un signal "clicked".
+
+<tscreen><verb>
+void gtk_toggle_button_toggled (GtkToggleButton *toggle_button);
+</verb></tscreen>
+<p>
+Cet appel ne fait que commuter le bouton et émettre le signal "toggled".
+
+<sect1> Cases à cocher
+<p>
+Les cases à cocher héritent de nombreuses propriétés et fonctions des
+boutons commutateurs, mais ont un aspect différent. Au lieu d'être des
+boutons contenant du texte, ce sont de petits carrés avec un texte sur
+leur droite. Il sont souvent utilisés pour valider ou non des options
+dans les applications.
+
+Les deux fonctions de création sont identiques à celles des boutons normaux.
+
+<tscreen><verb>
+GtkWidget* gtk_check_button_new (void);
+
+GtkWidget* gtk_check_button_new_with_label (gchar *label);
+</verb></tscreen>
+
+La fonction <em/new_with_label/ crée une case à cocher avec un texte à
+coté d'elle.
+
+La vérification de l'état d'une case à cocher est identique à celle
+des boutons commutateurs.
+
+<sect1> Boutons radio
+<p>
+Les boutons radio ressemblent aux cases à cocher sauf qu'ils sont
+groupés de façon à ce qu'un seul d'entre-eux puisse être sélectionné à
+un moment donné. Ils sont utilisés par les applications lorsqu'il
+s'agit d'effectuer un choix dans une liste d'options.
+
+La création d'un bouton radio s'effectue grâce à l'un des appels
+suivants&nbsp;:
+
+<tscreen><verb>
+GtkWidget* gtk_radio_button_new (GSList *group);
+
+GtkWidget* gtk_radio_button_new_with_label (GSList *group,
+                                            gchar *label);
+</verb></tscreen>
+<p>
+On notera le paramètre supplémentaire de ces fonctions. Elles
+nécessitent un groupe pour réaliser correctement leur tâche. Le
+premier appel doit passer NULL au premier paramètre puis on peut créer un
+groupe en utilisant&nbsp;:
+
+<tscreen><verb>
+GSList* gtk_radio_button_group (GtkRadioButton *radio_button);
+</verb></tscreen>
+
+<p>
+On passe alors ce groupe en premier paramètre des appels suivants aux fonctions de création.  Il est préférable, aussi, de préciser quel bouton doit être choisi par défaut avec la fonction&nbsp;:
+
+<tscreen><verb>
+void gtk_toggle_button_set_state (GtkToggleButton *toggle_button,
+                                  gint state);
+</verb></tscreen>
+<p>
+Celle-ci est décrite dans la section sur les boutons commutateurs et fonctionne
+exactement de la même façon.
+<p>
+[Mettre ici un exemple d'utilisation de tout cela car je crois que cela ferait
+beaucoup de bien...]
+
+
+<sect> Widgets divers
+<p>
+<sect1> Labels
+<p>
+Les labels sont très utilisés dans GTK et sont relativement
+simples. Ils n'émettent pas de signaux car ils n'ont pas de fenêtre X
+qui leur est associée. Si vous avez besoin de capturer des signaux ou
+de faire des coupures (« clippings »), utilisez un widget EventBox.
+
+Pour créer un label, on utilise&nbsp;:
+
+<tscreen><verb>
+GtkWidget* gtk_label_new (char *str);
+</verb></tscreen>
+
+Où l'unique paramètre est la chaîne de caractères que l'on veut que le
+label affiche.
+
+Pour changer le texte d'un label après sa création, on utilise la fonction&nbsp;:
+
+<tscreen><verb>
+void gtk_label_set (GtkLabel  *label,
+		    char      *str);
+</verb></tscreen>
+<p>
+où le premier paramètre est le label que l'on veut modifier, que l'on
+convertit en utilisant la macro GTK_LABEL(), et le second est la
+nouvelle chaîne.
+
+L'espace nécessaire à la nouvelle chaîne sera automatiquement ajusté
+si nécessaire.
+
+Pour récupérer la chaîne courante, on utilise la fonction&nbsp;:
+
+<tscreen><verb>
+void gtk_label_get (GtkLabel  *label,
+		    char     **str);
+</verb></tscreen>
+
+où le premier paramètre est le label dont on veut récupérer la chaîne
+et le second sert à retourner cette chaîne.
+
+<sect1>Le widget bulle d'aide
+<p>
+Ce sont les petits textes qui surgissent lorsque vous laissez votre
+pointeur sur un bouton ou un autre widget pendant quelques secondes.
+Ils sont faciles à utiliser, on ne donnera donc pas d'exemple. Si vous
+voulez voir du code, consultez le programme <em/testgtk.c/ distribué
+avec GTK.
+<p>
+Certains widgets (comme les labels) ne fonctionnent pas avec les
+bulles d'aide.
+<p>
+Le premier appel que vous utiliserez sera pour créer une nouvelle
+bulle d'aide. Vous n'avez besoin que de le faire une fois dans une
+fonction donnée. Le <em/GtkTooltip/ que cette fonction retourne peut
+être utilisé pour créer plusieurs bulles d'aide.
+
+<tscreen><verb>
+GtkTooltips *gtk_tooltips_new (void);
+</verb></tscreen>
+
+Lorsque vous avez créé une nouvelle bulle d'aide et le widget sur lequel vous
+voulez l'utiliser, vous n'avez qu'à faire cet appel pour la configurer&nbsp;:
+
+<tscreen><verb>
+void gtk_tooltips_set_tips   (GtkTooltips *tooltips,
+			      GtkWidget   *widget,
+			      gchar	  *tips_text);
+</verb></tscreen>
+
+Les paramètres sont la bulle d'aide déjà créée, suivi du widget pour
+lequel vous voulez voir apparaître cette bulle et le texte que vous
+voulez qu'elle contienne.
+<p>
+Voici un petit exemple&nbsp;:
+
+<tscreen><verb>
+GtkTooltips *tooltips;
+GtkWidget *button;
+...
+tooltips = gtk_tooltips_new ();
+button = gtk_button_new_with_label ("bouton 1");
+...
+gtk_tooltips_set_tips (tooltips, button, "C'est le bouton 1");
+</verb></tscreen>
+
+
+D'autres fonctions peuvent être utilisées avec les bulles d'aide. Je ne ferais que les énumérer et les décrire brièvement.
+
+<tscreen><verb>
+void gtk_tooltips_destroy    (GtkTooltips *tooltips);
+</verb></tscreen>
+
+Destruction de bulles d'aide.
+
+<tscreen><verb>
+void gtk_tooltips_enable     (GtkTooltips *tooltips);
+</verb></tscreen>
+
+Activation d'un ensemble de bulles d'aide désactivées.
+
+<tscreen><verb>
+void gtk_tooltips_disable    (GtkTooltips *tooltips);
+</verb></tscreen>
+
+Désactivation d'un ensemble de bulles d'aide activées.
+
+<tscreen><verb>
+void gtk_tooltips_set_delay  (GtkTooltips *tooltips,
+			      gint	   delay);
+
+</verb></tscreen> Configure le nombre de millisecondes pendant lequel
+le pointeur soit se trouver sur le widget avant que la bulle d'aide
+n'apparaisse. Par défaut, ce délai est de 1000 millisecondes, soit 1
+seconde.
+
+<tscreen><verb>
+void	  gtk_tooltips_set_tips (GtkTooltips *tooltips,
+			         GtkWidget   *widget,
+			         gchar	  *tips_text);
+</verb></tscreen>
+
+Change le texte d'une bulle d'aide déjà créée.
+
+<tscreen><verb>
+void gtk_tooltips_set_colors (GtkTooltips *tooltips,
+			      GdkColor	  *background,
+			      GdkColor	  *foreground);
+</verb></tscreen>
+
+Configure les couleurs de fond et de premier plan des bulles
+d'aides. Je ne sais toujours pas comment spécifier les couleurs...
+<p>
+Et c'est tout concernant les fonctions associées aux bulles
+d'aide. C'est plus que vous ne vouliez sûrement en savoir :)
+
+<sect1> Barres de progression
+<p>
+Les barres de progression sont utilisées pour afficher la progression
+d'une opération. Elles sont très simple à utiliser comme vous pourrez
+le constater en étudiant le code ci-dessous. Commençons d'abord par
+l'appel permettant de créer une nouvelle barre.
+
+<tscreen><verb>
+GtkWidget *gtk_progress_bar_new (void);
+</verb></tscreen>
+
+Maintenant que la barre est créée, nous pouvons l'utiliser. 
+
+<tscreen><verb>
+void gtk_progress_bar_update (GtkProgressBar *pbar, gfloat percentage);
+</verb></tscreen>
+
+Le premier paramètre est la barre de progression sur laquelle on veut
+agir, et le second est le pourcentage « effectué », signifiant le
+remplissage de la barres de 0 à 100 % (réel compris entre 0 et 1).
+
+Les barres de progression sont généralement utilisées avec les délais
+d'expiration ou autres fonctions identiques (voir la section sur <ref
+id="sec_timeouts" name="Expirations, fonctions d'E/S et d'attente">)
+pour donner l'illusion du multi-tâches. Toutes emploient la fonction
+<em/gtk_progress_bar_update/ de la même façon.
+
+Voici un exemple de barre de progression mise à jour par des
+expirations. Ce code montre aussi comment réinitialiser une barre.
+
+<tscreen><verb>
+#include <gtk/gtk.h>
+
+static int ptimer = 0;
+int pstat = TRUE;
+
+/* Cette fonction incrémente et met à jour la barre de progression,
+ * elle la réinitialise si pstat vaut FALSE */
+
+gint progress (gpointer data)
+{
+    gfloat pvalue;
+    
+    /* récupération de la valeur courante de la barre */
+
+    pvalue = GTK_PROGRESS_BAR (data)->percentage;
+    
+    if ((pvalue >= 1.0) || (pstat == FALSE)) {
+	pvalue = 0.0;
+	pstat = TRUE;
+    }
+    pvalue += 0.01;
+    
+    gtk_progress_bar_update (GTK_PROGRESS_BAR (data), pvalue);
+    
+    return TRUE;
+}
+
+/* Cette fonction signale une réinitialisation de la barre */
+
+void progress_r (void)
+{  
+    pstat = FALSE;  
+}
+
+void destroy (GtkWidget *widget, gpointer *data)
+{
+    gtk_main_quit ();
+}
+
+int main (int argc, char *argv[])
+{
+    GtkWidget *window;
+    GtkWidget *button;
+    GtkWidget *label;
+    GtkWidget *table;
+    GtkWidget *pbar;
+    
+    gtk_init (&amp;argc, &amp;argv);
+    
+    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+    
+    gtk_signal_connect (GTK_OBJECT (window), "delete_event",
+			GTK_SIGNAL_FUNC (destroy), NULL);
+    
+    gtk_container_border_width (GTK_CONTAINER (window), 10);
+    
+    table = gtk_table_new(3,2,TRUE);
+    gtk_container_add (GTK_CONTAINER (window), table);
+    
+    label = gtk_label_new ("Exemple de barre de progression");
+    gtk_table_attach_defaults(GTK_TABLE(table), label, 0,2,0,1);
+    gtk_widget_show(label);
+    
+    /* Crée une barre, la place dans la table et l'affiche */
+
+    pbar = gtk_progress_bar_new ();
+    gtk_table_attach_defaults(GTK_TABLE(table), pbar, 0,2,1,2);
+    gtk_widget_show (pbar);
+    
+    /* Configure le délai d'expiration pour gérer automatiquement la
+     *  mise à jour de la barre */ 
+
+    ptimer = gtk_timeout_add (100, progress, pbar);
+    
+    /* Ce bouton indique à la barre qu'elle doit se réinitialiser */
+
+    button = gtk_button_new_with_label ("Reset");
+    gtk_signal_connect (GTK_OBJECT (button), "clicked",
+			GTK_SIGNAL_FUNC (progress_r), NULL);
+    gtk_table_attach_defaults(GTK_TABLE(table), button, 0,1,2,3);
+    gtk_widget_show(button);
+    
+    button = gtk_button_new_with_label ("Annuler");
+    gtk_signal_connect (GTK_OBJECT (button), "clicked",
+			GTK_SIGNAL_FUNC (destroy), NULL);
+    
+    gtk_table_attach_defaults(GTK_TABLE(table), button, 1,2,2,3);
+    gtk_widget_show (button);
+    
+    gtk_widget_show(table);
+    gtk_widget_show(window);
+    
+    gtk_main ();
+    
+    return 0;
+}
+</verb></tscreen>
+
+Dans ce petit programme, il y a quatre parties concernant le
+fonctionnement général des barres de progression, nous les étudierons
+dans l'ordre de leurs appels.
+
+<tscreen><verb>
+pbar = gtk_progress_bar_new ();
+</verb></tscreen>
+
+Cet appel crée une nouvelle barre, nommée <em/pbar/.
+
+<tscreen><verb>
+ptimer = gtk_timeout_add (100, progress, pbar);
+</verb></tscreen>
+
+Cet appel utilise des délais d'expiration pour permettre un intervalle
+de temps constant. ces délais ne sont pas nécessaires à l'utilisation
+des barres de progression.
+
+<tscreen><verb>
+pvalue = GTK_PROGRESS_BAR (data)->percentage;
+</verb></tscreen>
+
+Ce code assigne à <em/pvalue/ la valeur du pourcentage de la barre.
+
+<tscreen><verb>
+gtk_progress_bar_update (GTK_PROGRESS_BAR (data), pvalue);
+</verb></tscreen>
+
+Finalement, ce code met à jour la barre avec la valeur de <em/pvalue/.
+
+Et c'est tout ce qu'il y a à savoir sur les barres de
+progression. Amusez-vous bien.
+
+<sect1> Boîtes de dialogue
+<p>
+
+Les widgets boîtes de dialogue sont très simples&nbsp;: ce sont
+simplement des fenêtres avec plusieurs choses déjà placées dedans. La
+structure d'une boîte de dialogue est&nbsp;:
+
+<tscreen><verb>
+struct GtkDialog
+{
+      GtkWindow window;
+    
+      GtkWidget *vbox;
+      GtkWidget *action_area;
+};
+</verb></tscreen>
+
+Comme vous le voyez, cela crée simplement une fenêtre et la place dans
+une vbox suivie d'un séparateur et d'une hbox pour la « zone d'action ».
+
+Le widget boîte de dialogue peut servir à produire des messages pour
+l'utilisateur ainsi qu'à d'autres tâches. Il est vraiment rudimentaire
+et il n'y a qu'une seule fonction pour les boîtes de dialogue&nbsp;:
+
+<tscreen><verb>
+GtkWidget* gtk_dialog_new (void);
+</verb></tscreen>
+
+Ainsi, pour créer un nouveau dialogue, on utilise&nbsp;:
+
+<tscreen><verb>
+GtkWidget window;
+window = gtk_dialog_new ();
+</verb></tscreen>
+
+Ceci créera la boîte de dialogue et c'est maintenant à vous de
+l'utiliser. Vous pouvez, par exemple, placer un bouton dans la zone
+d'action en faisant quelque chose comme&nbsp;:
+
+<tscreen><verb>
+button = ...
+gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button,
+		    TRUE, TRUE, 0);
+gtk_widget_show (button);
+</verb></tscreen>
+
+Et vous pouvez aussi ajouter un label à la zone de la vboxb&nbsp;:
+
+<tscreen><verb>
+label = gtk_label_new ("Les boîtes de dialogues sont pratiques");
+gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->vbox), label, TRUE,
+		    TRUE, 0);
+gtk_widget_show (label);
+</verb></tscreen>
+
+Comme exemple d'utilisation d'une boîte de dialogue, vous pourriez
+mettre deux boutons dans la zone d'action (un bouton « Annuler » et un
+bouton « Ok ») et un label dans la zone de la vbox posant une question
+à l'utilisateur ou signalant une erreur, etc. Vous pouvez alors
+attacher un signal différent à chacun des boutons et réaliser
+l'opération que l'utilisateur a choisie.
+
+
+<sect1> Pixmaps
+<p>
+Les pixmaps sont des structures de données contenant des
+images. Celles-ci peuvent être utilisées à différents endroits, mais
+le plus souvent comme icônes dans le bureau X Window. Un bitmap est un
+pixmap de 2 couleurs.
+
+Pour utiliser des pixmaps avec GTK, on doit d'abord construire une
+structure <em/GdkPixmap/ en utilisant les fonctions de la couche
+GDK. Les pixmaps peuvent soit être créés à partir de données en
+memoire, ou à partir de données lues dans un fichier. Nous utiliserons
+chacun des appels pour créer un pixmap.
+
+<tscreen><verb>
+GdkPixmap *gdk_bitmap_create_from_data( GdkWindow *window,
+                                        gchar     *data,
+                                        gint      width,
+                                        gint      height );
+</verb></tscreen>
+<p>
+Cette fonction sert à créer un pixmap mono-plan (2 couleurs) à partir
+de données en mémoire. Chaque bit de la donnée <em/data/. <em/width/
+et <em/height/ sont exprimés en pixels. Le pointeur vers un
+<em/GdkWindow/ pointe sur la fenêtre courante car les ressources d'un
+pixmap n'ont de signification que dans le contexte de l'écran où il
+doit s'afficher.
+
+<tscreen><verb>
+GdkPixmap* gdk_pixmap_create_from_data( GdkWindow  *window,
+                                        gchar      *data,
+                                        gint        width,
+                                        gint        height,
+                                        gint        depth,
+                                        GdkColor   *fg,
+                                        GdkColor   *bg );
+</verb></tscreen>
+
+Cette fonction est utilisée pour créer un pixmap d'une profondeur
+donnée (nombre de couleurs) à partir de la donnée spécifiée pas
+<em/data/. <em/fg/ et <em/bg/ sont les couleurs à utiliser pour
+l'avant et l'arrière-plan.
+
+<tscreen><verb>
+GdkPixmap* gdk_pixmap_create_from_xpm( GdkWindow  *window,
+                                       GdkBitmap **mask,
+                                       GdkColor   *transparent_color,
+                                       const gchar *filename );
+</verb></tscreen>
+
+Le format XPM est une représentation des pixmaps reconnue par le système X Window. Il est largement utilisé et de nombreux utilitaires pour créer des fichiers d'images à ce format sont disponibles. Le fichier <em/filename/ doit contenir une image dans ce format qui sera chargée dans la structure pixmap. Le masque <em/mask/ indique quels sont les bits opaques du pixmap. Tous les autres bits sont colorisés en utilisant la couleur spécifiée par <em/transparent_color/. Un exemple d'utilisation est présenté ci-dessous.
+
+<tscreen><verb>
+GdkPixmap* gdk_pixmap_create_from_xpm_d (GdkWindow  *window,
+                                         GdkBitmap **mask,
+                                         GdkColor   *transparent_color,
+                                         gchar     **data);
+</verb></tscreen>
+
+De petites images peuvent être intégrées dans un programme sous la forme de
+données <em/data/ au format XPM. Un pixmap est créé en utilisant ces données au
+lieu de les lire dans un fichier. Un exemple de telles données est&nbsp;:
+
+<tscreen><verb>
+/* XPM */
+static const char * xpm_data[] = {
+"16 16 3 1",
+"       c None",
+".      c #000000000000",
+"X      c #FFFFFFFFFFFF",
+"                ",
+"   ......       ",
+"   .XXX.X.      ",
+"   .XXX.XX.     ",
+"   .XXX.XXX.    ",
+"   .XXX.....    ",
+"   .XXXXXXX.    ",
+"   .XXXXXXX.    ",
+"   .XXXXXXX.    ",
+"   .XXXXXXX.    ",
+"   .XXXXXXX.    ",
+"   .XXXXXXX.    ",
+"   .XXXXXXX.    ",
+"   .........    ",
+"                ",
+"                "};
+</verb></tscreen>
+
+<tscreen><verb>
+void gdk_pixmap_destroy( GdkPixmap  *pixmap );
+</verb></tscreen>
+<p>
+Lorsqu'on a utilisé un pixmap et que l'on en a plus besoin tout de suite, il est préférable de libérer la ressource en utilisant un appel à <em/gdk_pixmap_destroy/.  Les pixmaps doivent être considérées comme une ressource précieuse.
+
+Quand le pixmap est créé, on peut l'afficher comme un widget GTK. On
+doit créer un widget pixmap qui contiendra le pixmap GDK. Ceci est
+réalisé de la façon suivante&nbsp;:
+
+<tscreen><verb>
+GtkWidget* gtk_pixmap_new( GdkPixmap  *pixmap,
+                           GdkBitmap  *mask );
+</verb></tscreen>
+<p>
+Les autres fonctions pour les widgets pixmap sont&nbsp;:
+
+<tscreen><verb>
+guint gtk_pixmap_get_type( void );
+void  gtk_pixmap_set( GtkPixmap  *pixmap,
+                      GdkPixmap  *val,
+                      GdkBitmap  *mask);
+void  gtk_pixmap_get( GtkPixmap  *pixmap,
+                      GdkPixmap **val,
+                      GdkBitmap **mask);
+</verb></tscreen>
+<p>
+<em/gtk_pixmap_set/ sert à changer le pixmap pris en charge par le widget. <em/val/ est le pixmap créé par le GDK.
+
+Voici un exemple illustrant l'utilisation d'un pixmap dans un bouton&nbsp;:
+
+<tscreen><verb>
+
+#include <gtk/gtk.h>
+
+
+/* données XPM d'une icône "Ouvrir fichier" */
+static const char * xpm_data[] = {
+"16 16 3 1",
+"       c None",
+".      c #000000000000",
+"X      c #FFFFFFFFFFFF",
+"                ",
+"   ......       ",
+"   .XXX.X.      ",
+"   .XXX.XX.     ",
+"   .XXX.XXX.    ",
+"   .XXX.....    ",
+"   .XXXXXXX.    ",
+"   .XXXXXXX.    ",
+"   .XXXXXXX.    ",
+"   .XXXXXXX.    ",
+"   .XXXXXXX.    ",
+"   .XXXXXXX.    ",
+"   .XXXXXXX.    ",
+"   .........    ",
+"                ",
+"                "};
+
+
+/* Termine l'application lorsqu'elle est appelée 
+ * via le signal "delete_event" */
+
+void close_application( GtkWidget *widget, GdkEvent *event, gpointer *data ) 
+{
+    gtk_main_quit();
+}
+
+
+/* Invoquée lorsque le bouton est cliqué. Affiche simplement 
+ * un message. */
+
+void button_clicked( GtkWidget *widget, gpointer *data ) 
+{
+    printf( "bouton cliqué\n" );
+}
+
+
+int main( int argc, char *argv[] )
+{
+    /* GtkWidget est le type pour déclarer les widgets */
+
+    GtkWidget *window, *pixmapwid, *button;
+    GdkPixmap *pixmap;
+    GdkBitmap *mask;
+    GtkStyle *style;
+    
+    /* Crée la fenêtre principale et attache le signal "delete_event" pour 
+     * terminer l'application */
+
+    gtk_init( &amp;argc, &amp;argv );
+    window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
+    gtk_signal_connect( GTK_OBJECT (window), "delete_event",
+                        GTK_SIGNAL_FUNC (close_application), NULL );
+    gtk_container_border_width( GTK_CONTAINER (window), 10 );
+    gtk_widget_show( window );
+
+    /* Utilisation de GDK pour créer le pixmap */
+
+    style = gtk_widget_get_style( window );
+    pixmap = gdk_pixmap_create_from_xpm_d( window->window,  &amp;mask,
+                                           &amp;style->bg[GTK_STATE_NORMAL],
+                                           (gchar **)xpm_data );
+
+    /* Création d'un widget pixmap GTK pour contenir le pixmap GDK */
+
+    pixmapwid = gtk_pixmap_new( pixmap, mask );
+    gtk_widget_show( pixmapwid );
+
+    /* Création d'un bouton pour contenir le widget pixmap */
+
+    button = gtk_button_new();
+    gtk_container_add( GTK_CONTAINER(button), pixmapwid );
+    gtk_container_add( GTK_CONTAINER(window), button );
+    gtk_widget_show( button );
+
+    gtk_signal_connect( GTK_OBJECT(button), "clicked",
+                        GTK_SIGNAL_FUNC(button_clicked), NULL );
+
+    /* Affichage de la fenêtre */
+    gtk_main ();
+          
+    return 0;
+}
+</verb></tscreen>
+
+
+Pour charger un fichier à partir d'un fichier XPM appelé
+<em/icon0.xpm/ se trouvant dans le répertoire courant, on aurait créé
+le pixmap ainsi&nbsp;:
+
+<tscreen><verb>
+    /* Charge un pixmap à partir d'un fichier */
+
+    pixmap = gdk_pixmap_create_from_xpm( window->window, &amp;mask,
+                                         &amp;style->bg[GTK_STATE_NORMAL],
+                                         "./icon0.xpm" );
+    pixmapwid = gtk_pixmap_new( pixmap, mask );
+    gtk_widget_show( pixmapwid );
+    gtk_container_add( GTK_CONTAINER(window), pixmapwid );
+</verb></tscreen>
+
+
+Utilisation des formes
+<p>
+Un désavantage de l'utilisation des pixmaps est que l'objet affiché
+est toujours rectangulaire, quelle que soit l'image. On voudrait
+pouvoir créer des bureaux et des applications avec des icônes ayant
+des formes plus naturelles. Par exemple, pour une interface de jeu, on
+aimerait avoir des boutons ronds à pousser. Pour faire cela, on doit
+utiliser des fenêtres avec des formes.
+
+Une fenêtre avec forme est simplement un pixmap dont les pixels du
+fond sont transparents. Ainsi, lorsque l'image d'arrière-plan est
+multicolore, on ne la cache pas avec le bord de notre icône. L'exemple
+suivant affiche une image de brouette sur le bureau.
+
+<tscreen><verb>
+
+#include <gtk/gtk.h>
+
+/* XPM */
+static char * WheelbarrowFull_xpm[] = {
+"48 48 64 1",
+"       c None",
+".      c #DF7DCF3CC71B",
+"X      c #965875D669A6",
+"o      c #71C671C671C6",
+"O      c #A699A289A699",
+"+      c #965892489658",
+"@      c #8E38410330C2",
+"#      c #D75C7DF769A6",
+"$      c #F7DECF3CC71B",
+"%      c #96588A288E38",
+"&amp;      c #A69992489E79",
+"*      c #8E3886178E38",
+"=      c #104008200820",
+"-      c #596510401040",
+";      c #C71B30C230C2",
+":      c #C71B9A699658",
+">      c #618561856185",
+",      c #20811C712081",
+"<      c #104000000000",
+"1      c #861720812081",
+"2      c #DF7D4D344103",
+"3      c #79E769A671C6",
+"4      c #861782078617",
+"5      c #41033CF34103",
+"6      c #000000000000",
+"7      c #49241C711040",
+"8      c #492445144924",
+"9      c #082008200820",
+"0      c #69A618611861",
+"q      c #B6DA71C65144",
+"w      c #410330C238E3",
+"e      c #CF3CBAEAB6DA",
+"r      c #71C6451430C2",
+"t      c #EFBEDB6CD75C",
+"y      c #28A208200820",
+"u      c #186110401040",
+"i      c #596528A21861",
+"p      c #71C661855965",
+"a      c #A69996589658",
+"s      c #30C228A230C2",
+"d      c #BEFBA289AEBA",
+"f      c #596545145144",
+"g      c #30C230C230C2",
+"h      c #8E3882078617",
+"j      c #208118612081",
+"k      c #38E30C300820",
+"l      c #30C2208128A2",
+"z      c #38E328A238E3",
+"x      c #514438E34924",
+"c      c #618555555965",
+"v      c #30C2208130C2",
+"b      c #38E328A230C2",
+"n      c #28A228A228A2",
+"m      c #41032CB228A2",
+"M      c #104010401040",
+"N      c #492438E34103",
+"B      c #28A2208128A2",
+"V      c #A699596538E3",
+"C      c #30C21C711040",
+"Z      c #30C218611040",
+"A      c #965865955965",
+"S      c #618534D32081",
+"D      c #38E31C711040",
+"F      c #082000000820",
+"                                                ",
+"          .XoO                                  ",
+"         +@#$%o&amp;                                ",
+"         *=-;#::o+                              ",
+"           >,<12#:34                            ",
+"             45671#:X3                          ",
+"               +89<02qwo                        ",
+"e*                >,67;ro                       ",
+"ty>                 459@>+&amp;&amp;                    ",
+"$2u+                  ><ipas8*                  ",
+"%$;=*                *3:.Xa.dfg>                ",
+"Oh$;ya             *3d.a8j,Xe.d3g8+             ",
+" Oh$;ka          *3d$a8lz,,xxc:.e3g54           ",
+"  Oh$;kO       *pd$%svbzz,sxxxxfX..&amp;wn>         ",
+"   Oh$@mO    *3dthwlsslszjzxxxxxxx3:td8M4       ",
+"    Oh$@g&amp; *3d$XNlvvvlllm,mNwxxxxxxxfa.:,B*     ",
+"     Oh$@,Od.czlllllzlmmqV@V#V@fxxxxxxxf:%j5&amp;   ",
+"      Oh$1hd5lllslllCCZrV#r#:#2AxxxxxxxxxcdwM*  ",
+"       OXq6c.%8vvvllZZiqqApA:mq:Xxcpcxxxxxfdc9* ",
+"        2r<6gde3bllZZrVi7S@SV77A::qApxxxxxxfdcM ",
+"        :,q-6MN.dfmZZrrSS:#riirDSAX@Af5xxxxxfevo",
+"         +A26jguXtAZZZC7iDiCCrVVii7Cmmmxxxxxx%3g",
+"          *#16jszN..3DZZZZrCVSA2rZrV7Dmmwxxxx&amp;en",
+"           p2yFvzssXe:fCZZCiiD7iiZDiDSSZwwxx8e*>",
+"           OA1<jzxwwc:$d%NDZZZZCCCZCCZZCmxxfd.B ",
+"            3206Bwxxszx%et.eaAp77m77mmmf3&amp;eeeg* ",
+"             @26MvzxNzvlbwfpdettttttttttt.c,n&amp;  ",
+"             *;16=lsNwwNwgsvslbwwvccc3pcfu<o    ",
+"              p;<69BvwwsszslllbBlllllllu<5+     ",
+"              OS0y6FBlvvvzvzss,u=Blllj=54       ",
+"               c1-699Blvlllllu7k96MMMg4         ",
+"               *10y8n6FjvllllB<166668           ",
+"                S-kg+>666<M<996-y6n<8*          ",
+"                p71=4 m69996kD8Z-66698&amp;&amp;        ",
+"                &amp;i0ycm6n4 ogk17,0<6666g         ",
+"                 N-k-<>     >=01-kuu666>        ",
+"                 ,6ky&amp;      &amp;46-10ul,66,        ",
+"                 Ou0<>       o66y<ulw<66&amp;       ",
+"                  *kk5       >66By7=xu664       ",
+"                   <<M4      466lj<Mxu66o       ",
+"                   *>>       +66uv,zN666*       ",
+"                              566,xxj669        ",
+"                              4666FF666>        ",
+"                               >966666M         ",
+"                                oM6668+         ",
+"                                  *4            ",
+"                                                ",
+"                                                "};
+
+
+/* Termine l'application lorsqu'elle est appelée 
+ * (via le signal "delete_event"). */
+
+void close_application( GtkWidget *widget, GdkEvent *event, gpointer *data ) 
+{
+    gtk_main_quit();
+}
+
+
+int main (int argc, char *argv[])
+{
+    GtkWidget *window, *pixmap, *fixed;
+    GdkPixmap *gdk_pixmap;
+    GdkBitmap *mask;
+    GtkStyle *style;
+    GdkGC *gc;
+    
+    /* crée la fenêtre principale et attache le signal "delete_event"
+     * pour terminer l'application. On notera que la fenêtre principale
+     * n'a pas de barre de titre car nous la faisons surgir. */
+
+    gtk_init (&amp;argc, &amp;argv);
+    window = gtk_window_new( GTK_WINDOW_POPUP );
+    gtk_signal_connect (GTK_OBJECT (window), "delete_event",
+                        GTK_SIGNAL_FUNC (close_application), NULL);
+    gtk_widget_show (window);
+
+    /* Création du pixmap et du widget pixmap */
+
+    style = gtk_widget_get_default_style();
+    gc = style->black_gc;
+    gdk_pixmap = gdk_pixmap_create_from_xpm_d( window->window, &amp;mask,
+                                             &amp;style->bg[GTK_STATE_NORMAL],
+                                             WheelbarrowFull_xpm );
+    pixmap = gtk_pixmap_new( gdk_pixmap, mask );
+    gtk_widget_show( pixmap );
+
+    /* Pour afficher le pixmap, on utilise un widget fixe pour placer
+     * le pixmap */
+
+    fixed = gtk_fixed_new();
+    gtk_widget_set_usize( fixed, 200, 200 );
+    gtk_fixed_put( GTK_FIXED(fixed), pixmap, 0, 0 );
+    gtk_container_add( GTK_CONTAINER(window), fixed );
+    gtk_widget_show( fixed );
+
+    /* On masque tout sauf l'image elle-même */
+
+    gtk_widget_shape_combine_mask( window, mask, 0, 0 );
+    
+    /* Affichage de la fenêtre */
+
+    gtk_widget_set_uposition( window, 20, 400 );
+    gtk_widget_show( window );
+    gtk_main ();
+          
+    return 0;
+}
+</verb></tscreen>
+<p>
+Pour rendre l'image de la brouette sensible aux clics, on peut lui
+attacher le signal "button_press_event" pour lui faire faire quelque
+chose. Les quelques lignes suivantes font que l'image sera sensible à
+un clic souris qui provoquera l'arrêt de l'application.
+
+<tscreen><verb>
+gtk_widget_set_events( window,
+                       gtk_widget_get_events( window ) |
+		       GDK_BUTTON_PRESS_MASK );
+
+gtk_signal_connect( GTK_OBJECT(window), "button_press_event",
+                    GTK_SIGNAL_FUNC(close_application), NULL );
+</verb></tscreen>
+
+
+<sect> Widgets containers
+
+<sect1> Bloc-notes
+<p>
+Le widget bloc-notes est un ensemble de « pages » qui se
+chevauchent. Chaque page contient des informations
+différentes. Récemment, ce widget est devenu plus commun dans la
+programmation des interfaces graphiques et c'est un bon moyen de
+montrer des blocs d'information similaires qui justifient une
+séparation de leur affichage.
+
+Le premier appel de fonction que l'on doit connaître est, vous
+l'aviez deviné, celui qui crée un widget bloc-notes.
+
+<tscreen><verb>
+GtkWidget* gtk_notebook_new (void);
+</verb></tscreen>
+
+Lorsque le bloc-notes a été créé, il y a 12 fonctions permettant de
+travailler sur les blocs-notes. Étudions-les séparément.
+
+La première permet de positionner les indicateurs de pages. Ceux-ci
+(désignés par le mot « tab » (signet)), peuvent se trouver en haut, en
+bas, à gauche ou à droite des pages.
+
+<tscreen><verb>
+void gtk_notebook_set_tab_pos (GtkNotebook *notebook, GtkPositionType pos);
+</verb></tscreen>
+
+<em/GtkPositionType/ peut prendre les valeurs suivantes qu'il n'est
+pas nécessaire d'expliquer&nbsp;:
+<itemize>
+<item> GTK_POS_LEFT
+<item> GTK_POS_RIGHT
+<item> GTK_POS_TOP
+<item> GTK_POS_BOTTOM
+</itemize>
+
+GTK_POS_TOP est la valeur par défaut.
+
+La fonction suivante permet d'ajouter des pages à un bloc-notes. Il y
+a trois façons d'ajouter des pages. Regardons les deux premières qui
+sont très semblables.
+
+<tscreen><verb>
+void gtk_notebook_append_page (GtkNotebook *notebook, GtkWidget *child, 
+                               GtkWidget *tab_label);
+
+void gtk_notebook_prepend_page (GtkNotebook *notebook, GtkWidget *child, 
+                                GtkWidget *tab_label);
+</verb></tscreen>
+
+Ces fonctions ajoutent des pages au bloc-notes<em/*notebook/ en les
+insérant à la fin (<em/append/) ou au début
+(<em/prepend/). <em/*child/ est le widget qui est placé dans la page
+du bloc-notes, et <em/*tab_label/ est le label de la page qui est
+ajoutée.
+
+La troisième fonction ajoutant une page à un bloc-notes conserve
+toutes les propriétés des deux précédentes, mais elle nous permet en
+plus de spécifier la position où l'on désire insérer cette page.
+
+<tscreen><verb>
+void gtk_notebook_insert_page (GtkNotebook *notebook, GtkWidget *child, 
+                               GtkWidget *tab_label, gint position);
+</verb></tscreen>
+
+Les paramètres sont les mêmes que <em/_append_/ et <em/_prepend_/ sauf
+qu'il y en a un de plus&nbsp;: <em/position/. Celui-ci sert à
+spécifier l'endroit où cette page sera insérée.
+
+Maintenant que nous savons insérer une page, voyons comment en supprimer une.
+
+<tscreen><verb>
+void gtk_notebook_remove_page (GtkNotebook *notebook, gint page_num);
+</verb></tscreen>
+
+Cette fonction ôte la page spécifiée par <em/page_num/ du widget
+<em/*notebook/.
+
+Pour connaître la page courante d'un bloc-notes, on dispose de la
+fonction&nbsp;:
+
+<tscreen><verb>
+gint gtk_notebook_current_page (GtkNotebook *notebook);
+</verb></tscreen>
+
+Les deux fonctions suivantes permettent de passer à la page suivante
+ou précédente d'un bloc-notes. Il suffit de faire l'appel de la
+fonction adéquate avec le widget sur lequel on veut
+opérer. Remarque&nbsp;: lorsqu'on est sur la dernière page du
+bloc-notes et que l'on appelle <em/gtk_notebook_next_page/, on revient
+à la première page. De même, si l'on est sur la première page et que
+l'onappelle <em/gtk_notebook_prev_page/, on se retrouve sur sa
+dernière page.
+
+<tscreen><verb>
+void gtk_notebook_next_page (GtkNoteBook *notebook);
+void gtk_notebook_prev_page (GtkNoteBook *notebook);
+</verb></tscreen>
+
+La fonction qui suit permet de choisir la page « active ». Si vous
+voulez ouvrir le bloc-notes à la page 5, par exemple, vous utiliserez
+cette fonction. Sans elle, le bloc-notes s'ouvre sur sa première page
+par défaut.
+
+<tscreen><verb>
+void gtk_notebook_set_page (GtkNotebook *notebook, gint page_num);
+</verb></tscreen>
+
+Les deux fonctions suivantes ajoutent ou ôtent les indicateurs de page
+et le contour du bloc-notes, respectivement.
+
+<tscreen><verb>
+void gtk_notebook_set_show_tabs (GtkNotebook *notebook, gint show_tabs);
+void gtk_notebook_set_show_border (GtkNotebook *notebook, gint show_border);
+</verb></tscreen>
+
+<em/show_tabs/ et <em/show_border/ peuvent valoir TRUE ou FALSE (0 ou 1).
+
+Voyons maintenant un exemple, il est tiré du code de <em/testgtk.c/ de
+la distribution GTK et montre l'utilisation des 13 fonctions. Ce petit
+programme crée une fenêtre contenant un bloc-notes et six boutons. Le
+bloc-notes contient 11 pages, ajoutées par trois moyens
+différents&nbsp;: à la fin, au milieu et au début. Les boutons
+permettent de faire tourner les indicateurs de page, ajouter/ôter les
+indicateurs et le contour, ôter une page, passer à la page suivante et
+précédente, et sortir du programme.
+
+
+<tscreen><verb>
+
+#include <gtk/gtk.h>
+
+/* Rotation des indicateurs de page  */
+
+void rotate_book (GtkButton *button, GtkNotebook *notebook)
+{
+    gtk_notebook_set_tab_pos (notebook, (notebook->tab_pos +1) %4);
+}
+
+/* Ajout/Suppression des indicateurs de pages et des contours */
+
+void tabsborder_book (GtkButton *button, GtkNotebook *notebook)
+{
+    gint tval = FALSE;
+    gint bval = FALSE;
+    if (notebook->show_tabs == 0)
+	    tval = TRUE; 
+    if (notebook->show_border == 0)
+	    bval = TRUE;
+    
+    gtk_notebook_set_show_tabs (notebook, tval);
+    gtk_notebook_set_show_border (notebook, bval);
+}
+
+/* Suppression d'une page */
+
+void remove_book (GtkButton *button, GtkNotebook *notebook)
+{
+    gint page;
+    
+    page = gtk_notebook_current_page(notebook);
+    gtk_notebook_remove_page (notebook, page);
+
+    /* Il faut rafraîchir  le widget --
+     * ce qui force le widget à se redessiner. */
+
+      gtk_widget_draw(GTK_WIDGET(notebook), NULL);
+}
+
+void delete (GtkWidget *widget, GdkEvent *event, gpointer *data)
+{
+    gtk_main_quit ();
+}
+
+int main (int argc, char *argv[])
+{
+    GtkWidget *window;
+    GtkWidget *button;
+    GtkWidget *table;
+    GtkWidget *notebook;
+    GtkWidget *frame;
+    GtkWidget *label;
+    GtkWidget *checkbutton;
+    int i;
+    char bufferf[32];
+    char bufferl[32];
+    
+    gtk_init (&amp;argc, &amp;argv);
+    
+    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+    
+    gtk_signal_connect (GTK_OBJECT (window), "delete_event",
+			GTK_SIGNAL_FUNC (delete), NULL);
+    
+    gtk_container_border_width (GTK_CONTAINER (window), 10);
+    
+    table = gtk_table_new(2,6,TRUE);
+    gtk_container_add (GTK_CONTAINER (window), table);
+    
+    /* Création d'un bloc-notes, placement des indicateurs de page. */
+
+    notebook = gtk_notebook_new ();
+    gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
+    gtk_table_attach_defaults(GTK_TABLE(table), notebook, 0,6,0,1);
+    gtk_widget_show(notebook);
+    
+    /* Ajoute un groupe de pages à la fin du bloc-notes. */
+
+    for (i=0; i < 5; i++) {
+	sprintf(bufferf, "Append Frame %d", i+1);
+	sprintf(bufferl, "Page %d", i+1);
+	
+	frame = gtk_frame_new (bufferf);
+	gtk_container_border_width (GTK_CONTAINER (frame), 10);
+	gtk_widget_set_usize (frame, 100, 75);
+	gtk_widget_show (frame);
+	
+	label = gtk_label_new (bufferf);
+	gtk_container_add (GTK_CONTAINER (frame), label);
+	gtk_widget_show (label);
+	
+	label = gtk_label_new (bufferl);
+	gtk_notebook_append_page (GTK_NOTEBOOK (notebook), frame, label);
+    }
+    
+    
+    /* Ajoute une page à un endroit précis. */
+
+    checkbutton = gtk_check_button_new_with_label ("Cochez moi !");
+    gtk_widget_set_usize(checkbutton, 100, 75);
+    gtk_widget_show (checkbutton);
+    
+    label = gtk_label_new ("Emplacement de la nouvelle page");
+    gtk_container_add (GTK_CONTAINER (checkbutton), label);
+    gtk_widget_show (label);
+    label = gtk_label_new ("Ajout de page");
+    gtk_notebook_insert_page (GTK_NOTEBOOK (notebook), checkbutton, label, 2);
+    
+    /* Ajout de pages au début du bloc-notes */
+
+    for (i=0; i < 5; i++) {
+	sprintf(bufferf, "Prepend Frame %d", i+1);
+	sprintf(bufferl, "Page %d", i+1);
+	
+	frame = gtk_frame_new (bufferf);
+	gtk_container_border_width (GTK_CONTAINER (frame), 10);
+	gtk_widget_set_usize (frame, 100, 75);
+	gtk_widget_show (frame);
+	
+	label = gtk_label_new (bufferf);
+	gtk_container_add (GTK_CONTAINER (frame), label);
+	gtk_widget_show (label);
+	
+	label = gtk_label_new (bufferl);
+	gtk_notebook_prepend_page (GTK_NOTEBOOK(notebook), frame, label);
+    }
+    
+    /* Configuration de la page de départ (page 4) */
+
+    gtk_notebook_set_page (GTK_NOTEBOOK(notebook), 3);
+    
+    
+    /* Création des boutons */
+
+    button = gtk_button_new_with_label ("Fermer");
+    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+			       GTK_SIGNAL_FUNC (delete), NULL);
+    gtk_table_attach_defaults(GTK_TABLE(table), button, 0,1,1,2);
+    gtk_widget_show(button);
+    
+    button = gtk_button_new_with_label ("Page suivante");
+    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+			       (GtkSignalFunc) gtk_notebook_next_page,
+			       GTK_OBJECT (notebook));
+    gtk_table_attach_defaults(GTK_TABLE(table), button, 1,2,1,2);
+    gtk_widget_show(button);
+    
+    button = gtk_button_new_with_label ("Page précédente");
+    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+			       (GtkSignalFunc) gtk_notebook_prev_page,
+			       GTK_OBJECT (notebook));
+    gtk_table_attach_defaults(GTK_TABLE(table), button, 2,3,1,2);
+    gtk_widget_show(button);
+    
+    button = gtk_button_new_with_label ("Position des indicateurs");
+    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+			       (GtkSignalFunc) rotate_book, GTK_OBJECT(notebook));
+    gtk_table_attach_defaults(GTK_TABLE(table), button, 3,4,1,2);
+    gtk_widget_show(button);
+    
+    button = gtk_button_new_with_label ("Indicateurs/Contours oui/non");
+    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+			       (GtkSignalFunc) tabsborder_book,
+			       GTK_OBJECT (notebook));
+    gtk_table_attach_defaults(GTK_TABLE(table), button, 4,5,1,2);
+    gtk_widget_show(button);
+    
+    button = gtk_button_new_with_label ("Oter page");
+    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+			       (GtkSignalFunc) remove_book,
+			       GTK_OBJECT(notebook));
+    gtk_table_attach_defaults(GTK_TABLE(table), button, 5,6,1,2);
+    gtk_widget_show(button);
+    
+    gtk_widget_show(table);
+    gtk_widget_show(window);
+    
+    gtk_main ();
+    
+    return 0;
+}
+</verb></tscreen>
+<p>
+En espérant que ceci vous aide à créer des blocs-notes pour vos
+applications GTK.
+
+
+<sect1> Fenêtres avec barres de défilement
+<p>
+Les fenêtres avec barres de défilement servent à créer des zones
+défilantes à l'intérieur d'une vraie fenêtre. On peut insérer
+n'importe quel widget dans ces fenêtres, ils seront accessibles quelle
+que soit leur taille en utilisant les barres de défilement.
+
+
+La fonction suivante sert à créer une fenêtre avec barre de
+défilement&nbsp;:
+
+<tscreen><verb>
+GtkWidget* gtk_scrolled_window_new (GtkAdjustment *hadjustment,
+                                    GtkAdjustment *vadjustment);
+</verb></tscreen>
+<p>
+Le premier paramètre est l'ajustement horizontal, et le second
+l'ajustement vertical. Ils sont presque toujours positionnés à NULL.
+
+<tscreen><verb>
+void gtk_scrolled_window_set_policy      (GtkScrolledWindow *scrolled_window,
+                                          GtkPolicyType      hscrollbar_policy,
+			                  GtkPolicyType      vscrollbar_policy);
+</verb></tscreen>
+
+Cela permet de configurer le fonctionnement des barres de
+défilement. Le premier paramètre est la fenêtre à défilement que l'on
+veut modifier, le second configure le fonctionnement de la barre
+horizontale et le troisième celui de la barre verticale.
+
+Ce fonctionnement peut être GTK_POLICY AUTOMATIC ou GTK_POLICY_ALWAYS.
+GTK_POLICY_AUTOMATIC décidera automatiquement de votre besoin en
+barres de défilement, alors que GTK_POLICY_ALWAYS mettra toujours
+celles-ci.
+
+Voici un exemple simple qui place 100 boutons commutateurs dans une
+fenêtre à défilement. Je n'ai commenté que les parties qui sont
+nouvelles pour vous.
+
+<tscreen><verb>
+#include <gtk/gtk.h>
+
+void destroy(GtkWidget *widget, gpointer *data)
+{
+    gtk_main_quit();
+}
+
+int main (int argc, char *argv[])
+{
+    static GtkWidget *window;
+    GtkWidget *scrolled_window;
+    GtkWidget *table;
+    GtkWidget *button;
+    char buffer[32];
+    int i, j;
+    
+    gtk_init (&amp;argc, &amp;argv);
+    
+    /* Création d'une boîte de dialogue pour y placer la fenêtre à défilement.
+     * Une boîte de dialogue est une fenêtre comme les autres sauf qu'elle contient
+     * une vbox et un séparateur horizontal. Ce n'est qu'un raccourci pour créer des
+     * zones de dialogue. */
+
+    window = gtk_dialog_new ();
+    gtk_signal_connect (GTK_OBJECT (window), "destroy",
+			(GtkSignalFunc) destroy, NULL);
+    gtk_window_set_title (GTK_WINDOW (window), "dialog");
+    gtk_container_border_width (GTK_CONTAINER (window), 0);
+    
+    /* Création d'une fenêtre à défilement. */
+
+    scrolled_window = gtk_scrolled_window_new (NULL, NULL);
+    
+    gtk_container_border_width (GTK_CONTAINER (scrolled_window), 10);
+    
+    /* La gestion des barres est soit GTK_POLICY AUTOMATIC, soit  GTK_POLICY_ALWAYS.
+     * GTK_POLICY_AUTOMATIC décide automatiquement s'il faut ou non des barres,
+     * GTK_POLICY_ALWAYS met toujours des barres
+     * Le premier paramètre correspond à la barre horizontale,
+     * le second à la barre verticale. */
+
+    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
+                                    GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
+
+    /* Création d'une boîte de dialogue */
+
+    gtk_box_pack_start (GTK_BOX (GTK_DIALOG(window)->vbox), scrolled_window, 
+			TRUE, TRUE, 0);
+    gtk_widget_show (scrolled_window);
+    
+    /* Création d'une table de 10x10 cases. */
+
+    table = gtk_table_new (10, 10, FALSE);
+    
+    /* Configure l'espace des lignes et des colonnes de 10 pixels */
+
+    gtk_table_set_row_spacings (GTK_TABLE (table), 10);
+    gtk_table_set_col_spacings (GTK_TABLE (table), 10);
+    
+    /* Place la table fans la fenêtre à défilement */
+
+    gtk_container_add (GTK_CONTAINER (scrolled_window), table);
+    gtk_widget_show (table);
+    
+    /* Crée une grille de boutons commutateurs dans la table */
+
+    for (i = 0; i < 10; i++)
+	    for (j = 0; j < 10; j++) {
+		sprintf (buffer, "bouton (%d,%d)\n", i, j);
+		button = gtk_toggle_button_new_with_label (buffer);
+		gtk_table_attach_defaults (GTK_TABLE (table), button,
+					   i, i+1, j, j+1);
+		gtk_widget_show (button);
+	    }
+    
+    /* Ajoute un bouton « Fermer » en bas de la boîte de dialogue */
+
+    button = gtk_button_new_with_label ("Fermer");
+    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+			       (GtkSignalFunc) gtk_widget_destroy,
+			       GTK_OBJECT (window));
+    
+    /* On met ce bouton en « bouton par défaut ». */
+    
+    GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
+    gtk_box_pack_start (GTK_BOX (GTK_DIALOG (window)->action_area), button, TRUE, TRUE, 0);
+    
+    /* Récupère le bouton par défaut. Le fait de presser la touche « Entrée »
+     * activera le bouton. */
+
+    gtk_widget_grab_default (button);
+    gtk_widget_show (button);
+    
+    gtk_widget_show (window);
+    
+    gtk_main();
+    
+    return(0);
+}
+</verb></tscreen>
+<p>
+Essayez de changer la taille de la fenêtre et faites attention aux
+réactions des barres de défilement. On peut aussi utiliser la fonction
+<em/gtk_widget_set_usize()/ pour configurer la taille par défaut de la
+fenêtre et des autres widgets.
+
+
+<sect>Widgets listes
+<p>
+Le widget <em/GtkList/ sert de container vertical pour des widgets <em/GtkListItem/.
+
+Un widget <em/GtkList/ possède sa propre fenêtre pour recevoir les
+événements et sa propre couleur de fond qui est habituellement
+blanche. Comme il est directement dérivé de <em/GtkContainer/, il peut
+être traité comme tel en utilisant la macro GTK_CONTAINER(List)&nbsp;:
+voir le widget <em/GtkContainer/ pour en savoir plus.
+
+On doit d'abord connaître l'utilisation des <em/GList/ et des
+fonctions <em/g_list_*()/ qui leur sont liées pour pouvoir utiliser
+pleinement le widget <em/GtkList/.
+
+Un champ de la structure d'un widget <em/GtkList/ nous intéresse particulièrement&nbsp;:
+
+<tscreen><verb>
+struct _GtkList
+{
+  ...
+  GList *selection;
+  guint selection_mode;
+  ...
+}; 
+</verb></tscreen>
+
+Le champ <em/selection/ d'un <em/GtkList/ pointe sur une liste chaînée
+de tous les items qui sont sélectionnés, ou vaut NULL si aucune
+sélection n'est faite. Ainsi, pour connaître la sélection courante, on
+consulte le champ <em/GTK_LIST()->selection/ mais on ne doit pas le
+modifier car ses champs internes sont gérés par les fonctions
+<em/gtk_list_*()/.
+
+Le champ <em/selection_mode/ détermine les options de sélection d'un
+<em/GtkList/ et donc le contenu du champ du
+<em/GTK_LIST()->selection/&nbsp;:
+
+<em/selection_mode/ peut avoir l'une des valeurs suivantes&nbsp;:
+<itemize>
+<item> GTK_SELECTION_SINGLE - <em/selection/ vaut NULL ou contient un
+pointeur vers un seul item sélectionné.
+
+<item> GTK_SELECTION_BROWSE - <em/selection/ vaut NULL si la liste ne
+contient aucun widget ou seulement des widgets non sensitifs. Sinon, ce
+champ contient un pointeur vers une seule structure Glist, et donc
+vers exactement un item.
+
+<item> GTK_SELECTION_MULTIPLE - <em/selection/ vaut NULL si aucun item
+n'est sélectionné ou pointe vers le premier item sélectionné. Ce
+dernier point à son tour vers le second item, etc.
+
+<item> GTK_SELECTION_EXTENDED - <em/selection/ vaut toujours NULL.
+</itemize>
+<p>
+La valeur par défaut est GTK_SELECTION_MULTIPLE.
+
+<sect1>Signaux
+<p>
+<tscreen><verb>
+void GtkList::selection_changed (GtkList *LIST)
+</verb></tscreen>
+
+Ce signal sera invoqué à chaque fois que le champ sélection d'un
+GtkList a changé. Cela arrive lorsqu'un fils d'un GtkList a été
+sélectionné ou désélectionné.
+
+<tscreen><verb>
+void GtkList::select_child (GtkList *LIST, GtkWidget *CHILD)
+</verb></tscreen>
+
+Ce signal est invoqué lorsqu'un fils du GtkList va être
+sélectionné. Ceci arrive principalement lors d'appels à
+<em/gtk_list_select_item(), gtk_list_select_child()/ et lors d'appuis
+de boutons. Quelques fois, il est indirectement déclenché lorsque des
+fils sont ajoutés ou supprimés du GtkList.
+
+<tscreen><verb>
+void GtkList::unselect_child (GtkList *LIST, GtkWidget *CHILD)
+</verb></tscreen>
+
+Ce signal est invoqué lorsqu'un fils du GtkList va être
+désélectionné. Cela arrive principalement lors d'appels à
+<em/gtk_list_unselect_item(), gtk_list_unselect_child()/, et lors
+d'appuis de boutons. Quelques fois, il est indirectement déclenché
+lorsque des fils sont ajoutés ou supprimés du GtkList.
+
+
+<sect1>Fonctions
+<p>
+<tscreen><verb>
+guint gtk_list_get_type (void)
+</verb></tscreen>
+
+Retourne l'identificateur de type « GtkList ».
+
+<tscreen><verb>
+GtkWidget* gtk_list_new (void)
+</verb></tscreen>
+
+Crée un nouvel objet « GtkList ». Le nouveau widget est retourné sous
+la forme d'un pointeur vers un objet « GtkWidget ». NULL est retourné
+en cas d'erreur.
+
+<tscreen><verb>
+void gtk_list_insert_items (GtkList *LIST, GList *ITEMS, gint POSITION)
+</verb></tscreen>
+
+Insère des items dans <em/LIST/, à partir de <em/POSITION/.
+<em/ITEMS/ est une liste doublement chaînée où chaque noeud doit
+pointer vers un nouveau <em/GtkListItem/. Les noeuds <em/GList/ de
+<em/ITEMS/ sont pris en charge par <em/LIST/.
+
+
+<tscreen><verb>
+void gtk_list_append_items (GtkList *LIST, GList *ITEMS)
+</verb></tscreen>
+
+Insère des items à la fin de <em/LIST/ selon le même principe que
+<em/gtk_list_insert_items/. Les noeuds <em/GList/ de <em/ITEMS/ sont
+pris en charge par <em/LIST/.
+
+<tscreen><verb>
+void gtk_list_prepend_items (GtkList *LIST, GList *ITEMS)
+</verb></tscreen>
+
+Insère des items au début de <em/LIST/ selon le même principe que
+<em/gtk_list_insert_items/. Les noeuds <em/GList/ de <em/ITEMS/ sont
+pris en charge par <em/LIST/.
+
+<tscreen><verb>
+void gtk_list_remove_items (GtkList *LIST, GList *ITEMS)
+</verb></tscreen>
+
+Ôte des items de <em/LIST/. <em/ITEMS/ est une liste doublement
+chaînée dont chaque noeud pointe vers un fils direct de <em/LIST/. Il
+est de la responsabilité de l'appelant de faire un appel à
+<em/g_list_free(ITEMS)/ après cela. L'appelant doit aussi détruire
+lui-même les items.
+
+<tscreen><verb>
+void gtk_list_clear_items (GtkList *LIST, gint START, gint END)
+</verb></tscreen>
+
+Ôte et détruit des items de <em/LIST/. Un widget est concerné si sa
+position courante dans <em/LIST/ est dans l'intervalle spécifié par
+<em/START/ et <em/END/.
+
+<tscreen><verb>
+void gtk_list_select_item (GtkList *LIST, gint ITEM)
+</verb></tscreen>
+
+Invoque le signal <em/GtkList::select_child/ pour un item spécifié par
+sa position courante dans <em/LIST/.
+
+<tscreen><verb>
+void gtk_list_unselect_item (GtkList *LIST, gint ITEM)
+</verb></tscreen>
+
+Invoque le signal <em/GtkList::unselect_child/ pour un item spécifié par
+sa position courante dans <em/LIST/.
+
+<tscreen><verb>
+void gtk_list_select_child (GtkList *LIST, GtkWidget *CHILD)
+</verb></tscreen>
+
+Invoque le signal <em/GtkList::select_child/ pour le fils <em/CHILD/ spécifié.
+
+<tscreen><verb>
+void gtk_list_unselect_child (GtkList *LIST, GtkWidget *CHILD)
+</verb></tscreen>
+
+Invoque le signal <em/GtkList::unselect_child/ pour le fils <em/CHILD/ spécifié.
+
+<tscreen><verb>
+gint gtk_list_child_position (GtkList *LIST, GtkWidget *CHILD)
+</verb></tscreen>
+
+Retourne la position de <em/CHILD/ dans <em/LIST/. Retourne -1 en cas d'erreur.
+
+<tscreen><verb>
+void gtk_list_set_selection_mode (GtkList *LIST, GtkSelectionMode MODE)
+</verb></tscreen>
+
+Configure <em/LIST/ dans le mode de sélection <em/MODE/ qui peut être
+GTK_SELECTION_SINGLE, GTK_SELECTION_BROWSE, GTK_SELECTION_MULTIPLE ou
+GTK_SELECTION_EXTENDED.
+
+<tscreen><verb>
+GtkList* GTK_LIST (gpointer OBJ)
+</verb></tscreen>
+
+Convertit un pointeur générique en « <\em GtkList*\ ». Voir
+<em/Standard Macros::/, pour plus d'informations.
+
+<tscreen><verb>
+GtkListClass* GTK_LIST_CLASS (gpointer CLASS)
+</verb></tscreen>
+
+Convertit un pointeur générique en « GtkListClass* ».  Voir
+<em/Standard Macros::/, pour plus d'informations.
+
+<tscreen><verb>
+gint GTK_IS_LIST (gpointer OBJ)
+</verb></tscreen>
+
+Détermine si un pointeur générique référence un objet « GtkList ». Voir
+<em/Standard Macros::/, pour plus d'informations.
+
+<sect1>Exemple
+<p>
+Voici un programme affichant les changements de sélection dans une
+<em/GtkList/ et permettant d'« emprisonner » des items en les
+sélectionnant avec le bouton droit de la souris.
+
+<tscreen><verb>
+/* Compilez ce programme avec :
+ * $ gcc -L/usr/X11R6/lib/ -I/usr/local/include/ -lgtk -lgdk -lglib -lX11 -lm -Wall main.c
+ */
+#include        <gtk/gtk.h>
+#include        <stdio.h>
+
+/* Chaîne pour stocker les données dans les items de la liste. */
+
+const   gchar   *list_item_data_key="list_item_data";
+
+
+/* prototypes des gestionnaires de signaux que l'on connectera au widget GtkList. */
+
+static  void    sigh_print_selection    (GtkWidget      *gtklist,
+                                         gpointer       func_data);
+static  void    sigh_button_event       (GtkWidget      *gtklist,
+                                         GdkEventButton *event,
+                                         GtkWidget      *frame);
+
+
+/* fonction principale pour configurer l'interface utilisateur */
+
+gint main (int argc, gchar *argv[])
+{                                  
+    GtkWidget       *separator;
+    GtkWidget       *window;
+    GtkWidget       *vbox;
+    GtkWidget       *scrolled_window;
+    GtkWidget       *frame;
+    GtkWidget       *gtklist;
+    GtkWidget       *button;
+    GtkWidget       *list_item;
+    GList           *dlist;
+    guint           i;
+    gchar           buffer[64];
+    
+    
+    /* initialise gtk (et donc gdk) */
+
+    gtk_init(&amp;argc, &amp;argv);
+    
+    
+    /* Création d'une fenêtre pour placer tous les widgets.
+     * Connexion de  gtk_main_quit() à l'événement "destroy" de
+     * la fenêtre afin de prendre en charge les événements « fermeture d'une
+     * fenêtre » du gestionnaire de fenêtre. */
+
+    window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
+    gtk_window_set_title(GTK_WINDOW(window), "Exemple de widget GtkList");
+    gtk_signal_connect(GTK_OBJECT(window),
+		       "destroy",
+		       GTK_SIGNAL_FUNC(gtk_main_quit),
+		       NULL);
+    
+    
+    /* À l'intérieur de la fenêtre, on a besoin d'une boîte pour placer 
+     * verticalement les widgets. */
+
+    vbox=gtk_vbox_new(FALSE, 5);
+    gtk_container_border_width(GTK_CONTAINER(vbox), 5);
+    gtk_container_add(GTK_CONTAINER(window), vbox);
+    gtk_widget_show(vbox);
+    
+    /* Fenêtre à défilement pour placer le widget GtkList à l'intérieur. */
+
+    scrolled_window=gtk_scrolled_window_new(NULL, NULL);
+    gtk_widget_set_usize(scrolled_window, 250, 150);
+    gtk_container_add(GTK_CONTAINER(vbox), scrolled_window);
+    gtk_widget_show(scrolled_window);
+    
+    /* Création du widget GtkList
+     * Connexion du gestionnaire de signal sigh_print_selection() au signal
+     * "selection_changed" du GtkList pour afficher les items sélectionnés
+     * à chaque fois que la sélection change. */
+
+    gtklist=gtk_list_new();
+    gtk_container_add(GTK_CONTAINER(scrolled_window), gtklist);
+    gtk_widget_show(gtklist);
+    gtk_signal_connect(GTK_OBJECT(gtklist),
+		       "selection_changed",
+		       GTK_SIGNAL_FUNC(sigh_print_selection),
+		       NULL);
+    
+    /* Création d'une « Prison » pour y mettre un item. */
+
+    frame=gtk_frame_new("Prison");
+    gtk_widget_set_usize(frame, 200, 50);
+    gtk_container_border_width(GTK_CONTAINER(frame), 5);
+    gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_OUT);
+    gtk_container_add(GTK_CONTAINER(vbox), frame);
+    gtk_widget_show(frame);
+    
+    /* Connexion du gestionnaire de signal sigh_button_event() au signal
+     * « mise au arrêts » des items du GtkList. */
+
+    gtk_signal_connect(GTK_OBJECT(gtklist),
+		       "button_release_event",
+		       GTK_SIGNAL_FUNC(sigh_button_event),
+		       frame);
+    
+    /* Création d'un séparateur. */
+
+    separator=gtk_hseparator_new();
+    gtk_container_add(GTK_CONTAINER(vbox), separator);
+    gtk_widget_show(separator);
+    
+    /* Création d'un bouton et connexion de son signal "clicked" à la
+     * destruction de la fenêtre. */
+
+    button=gtk_button_new_with_label("Fermeture");
+    gtk_container_add(GTK_CONTAINER(vbox), button);
+    gtk_widget_show(button);
+    gtk_signal_connect_object(GTK_OBJECT(button),
+			      "clicked",
+			      GTK_SIGNAL_FUNC(gtk_widget_destroy),
+			      GTK_OBJECT(window));
+    
+    
+    /* Création de 5 items, chacun ayant son propre label.
+     * Ajout de ceux-ci au GtkList en utilisant gtk_container_add().
+     * On interroge le texte du label et on l'associe avec
+     * list_item_data_key à chaque item. */
+    
+    for (i=0; i<5; i++) {
+	GtkWidget       *label;
+	gchar           *string;
+	
+	sprintf(buffer, "ListItemContainer avec Label #%d", i);
+	label=gtk_label_new(buffer);
+	list_item=gtk_list_item_new();
+	gtk_container_add(GTK_CONTAINER(list_item), label);
+	gtk_widget_show(label);
+	gtk_container_add(GTK_CONTAINER(gtklist), list_item);
+	gtk_widget_show(list_item);
+	gtk_label_get(GTK_LABEL(label), &amp;string);
+	gtk_object_set_data(GTK_OBJECT(list_item),
+			    list_item_data_key,
+			    string);
+    }
+    /* Création de 5 autres labels. Cette fois-ci, on utilise
+     * gtk_list_item_new_with_label(). On ne peut interroger la chaîne
+     * des labels car on n'a pas les pointeurs de labels et on associe
+     * donc simplement le list_item_data_key de chaque item ayant la même 
+     * chaîne de texte pour l'ajouter au items que l'on place dans une liste
+     * doublement chaînée (GList). On les ajoute alors par un simple appel à
+     * gtk_list_append_items().
+     * Comme on utilise g_list_prepend() pour mettre les items dans la liste
+     * doublement chaînée, leur ordre sera décroissant (au lieu d'être croissant si
+     * on utilisait g_list_append()). */
+     
+    dlist=NULL;
+    for (; i<10; i++) {
+	sprintf(buffer, "Item avec le label %d", i);
+	list_item=gtk_list_item_new_with_label(buffer);
+	dlist=g_list_prepend(dlist, list_item);
+	gtk_widget_show(list_item);
+	gtk_object_set_data(GTK_OBJECT(list_item),
+			    list_item_data_key,
+			    "Item avec label intégré");
+    }
+    gtk_list_append_items(GTK_LIST(gtklist), dlist);
+    
+    /* Enfin, on veut voir la fenêtre... */
+    
+    gtk_widget_show(window);
+    
+    /* Lancement de la boucle principale de gtk */
+    
+    gtk_main();
+    
+    /* On arrive ici après que gtk_main_quit() ait été appelée lorsque
+     * la fenêtre principale a été détruite. */
+
+}
+
+/* Gestionnaire de signal connecté aux événements boutons presser/relâcher
+ * du GtkList. */
+
+void
+sigh_button_event       (GtkWidget      *gtklist,
+                         GdkEventButton *event,
+                         GtkWidget      *frame)
+{
+    /* On ne fait quelque chose que si le troisième bouton (celui de droite) a été
+     * relâché. */
+
+    if (event->type==GDK_BUTTON_RELEASE &amp;&amp;
+	event->button==3) {
+	GList           *dlist, *free_list;
+	GtkWidget       *new_prisoner;
+	
+	/* On recherche l'item sélectionné à ce moment précis. 
+         * Ce sera notre prisonnier ! */
+
+	dlist=GTK_LIST(gtklist)->selection;
+	if (dlist)
+		new_prisoner=GTK_WIDGET(dlist->data);
+	else
+		new_prisoner=NULL;
+	
+	/* On recherche les items déjà prisonniers et on les
+         * remet dans la liste.
+	 * Il ne faut pas oublier de libérer la liste doublement
+         * chaînée que gtk_container_children() retourne. */
+	
+	dlist=gtk_container_children(GTK_CONTAINER(frame));
+	free_list=dlist;
+	while (dlist) {
+	    GtkWidget       *list_item;
+	    
+	    list_item=dlist->data;
+	    
+	    gtk_widget_reparent(list_item, gtklist);
+	    
+	    dlist=dlist->next;
+	}
+	g_list_free(free_list);
+	
+	/* Si l'on a un nouveau prisonnier, on l'ôte du GtkList et on le place
+         * dans le cadre « Prison ». On doit désélectionner l'item avant.
+
+	if (new_prisoner) {
+	    GList   static_dlist;
+	    
+	    static_dlist.data=new_prisoner;
+	    static_dlist.next=NULL;
+	    static_dlist.prev=NULL;
+	    
+	    gtk_list_unselect_child(GTK_LIST(gtklist),
+				    new_prisoner);
+	    gtk_widget_reparent(new_prisoner, frame);
+	}
+    }
+}
+
+/* Gestionnaire de signal appelé lorsque le GtkList
+ * émet le signal "selection_changed". */
+
+void
+sigh_print_selection    (GtkWidget      *gtklist,
+                         gpointer       func_data)
+{
+    GList   *dlist;
+    
+    /* Recherche dans la liste doublement chaînée des items sélectionnés
+     * du GtkList, à faire en lecture seulement ! */
+
+    dlist=GTK_LIST(gtklist)->selection;
+    
+    /* S'il n'y a pas d'items sélectionné, il n'y a rien d'autre à faire que
+     * de le dire à l'utilisateur. */
+
+    if (!dlist) {
+	g_print("Sélection nettoyée\n");
+	return;
+    }
+    /* Ok, on a une sélection et on l'affiche. */
+
+    g_print("La sélection est ");
+    
+    /* On récupère l'item dans la liste doublement chaînée 
+     * puis on interroge la donnée associée par list_item_data_key
+     * et on l'affiche. */
+
+    while (dlist) {
+	GtkObject       *list_item;
+	gchar           *item_data_string;
+	
+	list_item=GTK_OBJECT(dlist->data);
+	item_data_string=gtk_object_get_data(list_item,
+					     list_item_data_key);
+	g_print("%s ", item_data_string);
+	
+	dlist=dlist->next;
+    }
+    g_print("\n");
+}
+</verb></tscreen>
+
+<sect1>Widget item de liste
+<p>
+Le widget <em/GtkListItem/ sert de container pour contenir un fils,
+lui fournissant des fonctions de sélection/déséselection exactement
+comme le widget GtkList les demande pour ses fils.
+
+Un <em/GtkListItem/ a sa propre fenêtre pour recevoir les événements et a
+sa propre couleur de fond, habituellement blanche.
+
+Comme il est directement dérivé d'un <em/GtkItem/, il peut être traité
+comme tel en utilisant la macro GTK_ITEM(ListItem), reportez-vous à la
+section sur le widget GtkItem pour plus de détail sur celui-ci.
+Habituellement, un <em/GtkListItem/ contient juste un label pour
+identifier, par exemple, un nom de fichier dans un <em/GtkList/ -- la
+fonction appropriée <em/gtk_list_item_new_with_label()/ est donc
+fournie. Le même effet peut être obtenu en créant un <em/GtkLabel/ à
+part, en configurant son alignement avec <em/xalign/=0 et
+<em/yalign/=0.5 suivi d'un ajout ultérieur au <em/GtkListItem/.
+
+Tout comme on n'est pas forcé d'ajouter un <em/GtkLabel/ à un
+<em/GtkListItem/, on peut aussi ajouter un <em/GtkVBox/ ou un
+<em/GtkArrow/ etc. à un <em/GtkListItem/.
+
+<sect1>Signaux
+<p>
+Un <em/GtkListItem/ ne crée pas de nouveaux signaux par lui-même, mais
+hérite de ceux d'un <em/GtkItem/. Voir <em/GtkItem::/, pour plus
+d'informations.
+
+
+<sect1>Fonctions
+<p>
+
+<tscreen><verb>
+guint gtk_list_item_get_type (void)
+</verb></tscreen>
+
+Retourne l'identificateur du type « GtkListItem ».
+
+<tscreen><verb>
+GtkWidget* gtk_list_item_new (void)
+</verb></tscreen>
+
+Création d'un objet <em/GtkListItem/. Le nouveau widget est retourné
+sous la forme d'un pointeur vers un objet <em/GtkWidget/. NULL est
+retourné en cas d'erreur.
+
+<tscreen><verb>
+GtkWidget* gtk_list_item_new_with_label (gchar *LABEL)
+</verb></tscreen>
+
+Création d'un objet <em/GtkListItem/ ayant un simple <em/GtkLabel/
+comme seul fils. Le nouveau widget est retourné sous la forme d'un
+pointeur vers un objet <em/GtkWidget/. NULL est retourné en cas
+d'erreur.
+
+<tscreen><verb>
+void gtk_list_item_select (GtkListItem *LIST_ITEM)
+</verb></tscreen>
+
+Cette fonction est surtout un emballage de <em/gtk_item_select
+(GTK_ITEM (list_item))/ qui émettra le signal <em/GtkItem::select/.
+Voir <em/GtkItem::/, pour plus d'informations.
+
+<tscreen><verb>
+void gtk_list_item_deselect (GtkListItem *LIST_ITEM)
+</verb></tscreen>
+
+Cette fonction est surtout un emballage de <em/gtk_item_deselect
+(GTK_ITEM (list_item))/ qui émettra le signal
+<em/GtkItem::deselect/. Voir <em/GtkItem::/, pour plus d'informations.
+
+<tscreen><verb>
+GtkListItem* GTK_LIST_ITEM (gpointer OBJ)
+</verb></tscreen>
+
+Convertit un pointeur générique en <em/GtkListItem*/. Voir
+<em/Standard Macros::/ pour plus d'informations.
+
+<tscreen><verb>
+GtkListItemClass* GTK_LIST_ITEM_CLASS (gpointer CLASS)
+</verb></tscreen>
+
+Convertit un pointeur générique en <em/GtkListItemClass*/. Voir
+<em/Standard Macros::/ pour plus d'informations.
+
+<tscreen><verb>
+gint GTK_IS_LIST_ITEM (gpointer OBJ)
+</verb></tscreen>
+
+Détermine si un pointeur générique se réfère à un objet
+<em/GtkListItem/.  Voir <em/Standard Macros::/ pour plus
+d'informations.
+ 
+<sect1>Exemple
+<p>
+L'exemple des GtkList couvre aussi l'utilisation des 
+GtkListItem. Étudiez-le attentivement.
+
+
+<sect>Widgets sélections de fichiers
+<p>
+Le widget sélection de fichier est un moyen simple et rapide pour
+afficher un fichier dans une boîte de dialogue. Il est complet, avec
+des boutons Ok, Annuler et Aide. C'est un bon moyen de raccourcir les
+temps de programmation.
+
+Pour créer une boîte de sélection de fichier, on utilise&nbsp;:
+
+<tscreen><verb>
+GtkWidget* gtk_file_selection_new (gchar *title);
+</verb></tscreen>
+
+Pour configurer le nom de fichier, par exemple pour aller dans un
+répertoire précis ou donner un nom de fichier par défaut, on utilise
+la fonction&nbsp;:
+
+<tscreen><verb>
+void gtk_file_selection_set_filename (GtkFileSelection *filesel, gchar *filename);
+</verb></tscreen>
+
+Pour récupérer le texte que l'utilisateur a entré, ou sur lequel il a
+cliqué, on utilisera la fonction&nbsp;:
+
+<tscreen><verb>
+gchar* gtk_file_selection_get_filename (GtkFileSelection *filesel);
+</verb></tscreen>
+
+Des pointeurs permettent d'accéder aux widgets contenus dans la widget
+de sélection de fichiers. Ce sont&nbsp;:
+
+<itemize>
+<item>dir_list
+<item>file_list
+<item>selection_entry
+<item>selection_text
+<item>main_vbox
+<item>ok_button
+<item>cancel_button
+<item>help_button
+</itemize>
+
+Le plus souvent, on utilise les pointeurs <em/ok_button, cancel_button/, et
+<em/help_button/ pour préciser leurs utilisations.
+
+Voici un exemple emprunté à <em/testgtk.c/ et modifié pour fonctionner
+tout seul. Comme vous le verrez, il n'y a pas grand chose à faire pour
+créer un wigdget de sélection de fichier. Cependant, dans cet exemple,
+si le bouton Aide apparaît à l'écran, il ne fait rien car aucun signal
+ne lui est attaché.
+
+<tscreen><verb>
+#include <gtk/gtk.h>
+
+/* Récupère le nom de fichier sélectionné et l'affiche sur la console. */
+
+void file_ok_sel (GtkWidget *w, GtkFileSelection *fs)
+{
+    g_print ("%s\n", gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs)));
+}
+
+void destroy (GtkWidget *widget, gpointer *data)
+{
+    gtk_main_quit ();
+}
+
+int main (int argc, char *argv[])
+{
+    GtkWidget *filew;
+    
+    gtk_init (&amp;argc, &amp;argv);
+    
+    /* Création d'un widget de sélection de fichier. */
+
+    filew = gtk_file_selection_new ("File selection");
+    
+    gtk_signal_connect (GTK_OBJECT (filew), "destroy",
+			(GtkSignalFunc) destroy, &amp;filew);
+
+    /* Connexion de ok_button à la fonction file_ok_sel() */
+
+    gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (filew)->ok_button),
+			"clicked", (GtkSignalFunc) file_ok_sel, filew );
+    
+    /* Connexion de cancel_button pour détruire le widget */
+
+    gtk_signal_connect_object (GTK_OBJECT (GTK_FILE_SELECTION (filew)->cancel_button),
+			       "clicked", (GtkSignalFunc) gtk_widget_destroy,
+			       GTK_OBJECT (filew));
+    
+    /* Configuration du nom de fichier, comme s'il s'agissait d'un dialogue de
+     * sauvegarde et que nous donnions un nom de fichier par défaut. */
+
+    gtk_file_selection_set_filename (GTK_FILE_SELECTION(filew), 
+				     "penguin.png");
+    
+    gtk_widget_show(filew);
+    gtk_main ();
+    return 0;
+}
+</verb></tscreen>
+
+<sect>Widgets Menu
+<p>
+Il y a deux façons de créer des menus, la facile et la compliquée. Les
+deux ont leur utilité, mais on peut généralement utiliser l'<em/usine
+à menus/ (c'est la méthode facile...). La méthode « compliquée »
+consiste à créer tous les menus en utilisant directement les
+appels. La méthode facile consiste à utiliser les appels
+<em/gtk_menu_factory/. C'est beaucoup plus simple, mais chaque
+approche a ses avantages et inconvénients.
+
+L'usine à menus est beaucoup plus facile à utiliser, elle facilite
+aussi l'ajout d'autres menus. Par contre, écrire quelques fonctions
+permettant de créer des menus en utilisant la méthode manuelle peut
+être le début d'un long chemin avant une quelconque utilisation. Avec
+l'usine à menus, il n'est pas possible d'ajouter des images ou des « /
+» aux menus.
+<p>
+<sect1>Création manuelle de menus
+<p>
+Selon la tradition pédagogique, nous commencerons par le plus compliqué <tt/:)/
+<p>
+Regardons les fonctions utilisées pour créer les menus. La première sert à créer un nouveau menu.
+
+<tscreen><verb>
+GtkWidget *gtk_menu_bar_new()
+</verb></tscreen>
+
+Cette fonction crée une nouvelle barre de menu. On utilise la fonction
+<em/gtk_container_add/ pour la placer dans une fenêtre, ou les
+fonctions <em/box_pack/ pour la placer dans une boîte - la même que
+pour les boutons.
+
+<tscreen><verb>
+GtkWidget *gtk_menu_new();
+</verb></tscreen>
+
+Cette fonction retourne un pointeur vers un nouveau menu, il n'est
+jamais montré (avec <em/gtk_widget_show/), il ne fait que contenir les
+items du menu. Ceci deviendra plus clair lorsque nous étudierons
+l'exemple ci-dessous.
+<p>
+Les deux appels suivants servent à créer des items de menu qui seront
+placés dans le menu.
+
+<tscreen><verb>
+GtkWidget *gtk_menu_item_new()
+</verb></tscreen>
+
+et
+
+<tscreen><verb>
+GtkWidget *gtk_menu_item_new_with_label(const char *label)
+</verb></tscreen>
+
+Ces appels servent à créer les menus qui doivent être affichés. On
+doit bien faire la différence entre un « menu » qui est créé avec
+<em/gtk_menu_new()/ et un « item de menu » créé avec les fonctions
+<em/gtk_menu_item_new()/. L'item de menu sera un véritable bouton avec
+une action associée alors qu'un menu sera un container contenant les
+items.
+
+
+<tscreen><verb>
+gtk_menu_item_append()
+
+gtk_menu_item_set_submenu()
+</verb></tscreen>
+
+Les fonctions <em/gtk_menu_new_with_label()/ et <em/gtk_menu_new()/
+sont telles que vous les attendiez après avoir étudié les
+boutons. L'une crée un nouvel item de menu contenant déjà un label, et
+l'autre ne fait que créer un item de menu vide.
+<p>
+Voici les étapes pour créer une barre de menu avec des menus attachés&nbsp;:
+<itemize>
+<item>Créer un nouveau menu avec <em/gtk_menu_new()/ <item>Créer un
+item de menu avec <em/gtk_menu_item_new()/.  Ce sera la racine du
+menu, le texte apparaissant ici sera aussi sur la barre de menu.
+<item>Utiliser plusieurs appels à <em/gtk_menu_item_new()/ pour
+chaque item que l'on désire dans le menu. Utiliser
+<em/gtk_menu_item_append()/ pour placer chacun de ces items les uns
+après les autres. Cela crée une liste d'items de menu.
+<item>Utiliser <em/gtk_menu_item_set_submenu()/ pour attacher les
+items de menus nouvellement créés à l'item de menu racine (celui créé
+à la seconde étape).
+<item>Créer une nouvelle barre de menu avec
+<em/gtk_menu_bar_new()/. Cette étape ne doit être faite qu'une fois
+lorsque l'on crée une série de menu sur une seule barre de menus.
+<item>Utiliser <em/gtk_menu_bar_append()/ pour placer le menu racine
+dans la barre de menu.
+</itemize>
+<p>
+La création d'un menu surgissant est presque identique. La différence
+est que le menu n'est pas posté « automatiquement » par une barre de
+menu, mais explicitement en appelant la fonction <em/gtk_menu_popup()/
+par un événement « bouton pressé ».
+
+Suivez ces étapes&nbsp;
+<itemize>
+<item>Créer une fonction de gestion d'événement. Elle doit avoir le prototype
+<tscreen>
+static gint handler(GtkWidget *widget, GdkEvent *event);
+</tscreen>
+et elle utilisera l'événement <em/event/ pour savoir où faire surgir
+le menu.  
+<item>Ce gestionnaire, si l'événement est un appui sur un
+bouton souris, traite <em/event/ comme un événement bouton (ce qu'il
+est) et l'utilise, de la façon indiquée dans le code d'exemple, pour
+passer l'information à <em/gtk_menu_popup()/.
+
+<item> Lier ce gestionnaire à un widget avec&nbsp;:
+<tscreen>
+gtk_signal_connect_object(GTK_OBJECT(widget), "event",
+                          GTK_SIGNAL_FUNC (handler), GTK_OBJECT(menu));
+</tscreen>
+où <em/widget/ est le widget auquel vous le liez, <em/handler/ est
+le gestionnaire, et <em/menu/ est un menu créé avec
+<em/gtk_menu_new()/. Cela peut être un menu qui est aussi posté par
+une barre de menu, comme le montre l'exemple.
+</itemize>
+<p>
+<sect1>Exemple de menu manuel
+<p>
+<tscreen><verb>
+
+#include <gtk/gtk.h>
+
+static gint button_press (GtkWidget *, GdkEvent *);
+static void menuitem_response (GtkWidget *, gchar *);
+
+
+int main (int argc, char *argv[])
+{
+
+    GtkWidget *window;
+    GtkWidget *menu;
+    GtkWidget *menu_bar;
+    GtkWidget *root_menu;
+    GtkWidget *menu_items;
+    GtkWidget *vbox;
+    GtkWidget *button;
+    char buf[128];
+    int i;
+
+    gtk_init (&amp;argc, &amp;argv);
+
+    /* Création d'un fenêtre */
+
+    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+    gtk_window_set_title(GTK_WINDOW (window), "Test de Menu GTK");
+    gtk_signal_connect(GTK_OBJECT (window), "delete_event",
+                       (GtkSignalFunc) gtk_exit, NULL);
+
+    /* Initialise le widget menu -- Attention : n'appelez jamais 
+     * gtk_show_widget() pour le widget menu !!!
+     * C'est le menu qui contient les items de menu, celui qui surgira 
+     * lorsque vous cliquez sur le « menu racine » de l'application. */
+
+    menu = gtk_menu_new();
+
+    /* Voici le menu racine dont le label sera le nom du menu affiché sur la barre
+     * de menu. Il n'a pas de gestionnaire de signal attaché car il ne fait 
+     * qu'afficher le reste du menu lorsqu'il est pressé. */
+
+    root_menu = gtk_menu_item_new_with_label("Menu racine");
+
+    gtk_widget_show(root_menu);
+
+    /* Puis, on crée une petite boucle créant trois entrées pour « menu test »
+     * Notez l'appel à gtk_menu_append(). Ici, on ajoute une liste d'items à
+     * notre menu. Normalement, on devrait aussi capturer le signal "clicked" 
+     * pour chacun des items et configurer une fonction de rappel pour lui, 
+     * mais on l'a omis ici pour gagner de la place. */
+
+    for(i = 0; i < 3; i++)
+        {
+            /* Copie des noms dans buf. */
+
+            sprintf(buf, "Sous-menu Test - %d", i);
+
+            /* Création d'un nouveau item de menu avec un nom... */
+
+            menu_items = gtk_menu_item_new_with_label(buf);
+
+            /* ...et ajout de celui-ci dans le menu. */
+
+            gtk_menu_append(GTK_MENU (menu), menu_items);
+
+	    /* On fait quelque chose d'intéressant lorsque l'item est
+             * sélectionné. */
+
+            gtk_signal_connect (GTK_OBJECT(menu_items), "activate",
+                GTK_SIGNAL_FUNC(menuitem_response), (gpointer)
+	        g_strdup(buf));
+		      
+            /* Affichage du widget. */
+
+            gtk_widget_show(menu_items);
+        }
+
+    /* Maintenant, on spécifié que nous voulons que notre nouveau « menu »
+     * soit le menu du « menu racine ». */
+
+    gtk_menu_item_set_submenu(GTK_MENU_ITEM (root_menu), menu);
+
+    /* Création d'une vbox pour y mettre un menu et un bouton. */
+
+    vbox = gtk_vbox_new(FALSE, 0);
+    gtk_container_add(GTK_CONTAINER(window), vbox);
+    gtk_widget_show(vbox);
+
+    /* Création d'une barre de menus pour contenir les menus. Puis, on
+     * l'ajoute à notre fenêtre principale. */
+
+    menu_bar = gtk_menu_bar_new();
+    gtk_box_pack_start(GTK_BOX(vbox), menu_bar, FALSE, FALSE, 2);
+    gtk_widget_show(menu_bar);
+
+    /* Création d'un bouton pour y attacher le menu. */
+
+    button = gtk_button_new_with_label("Pressez moi");
+    gtk_signal_connect_object(GTK_OBJECT(button), "event",
+	GTK_SIGNAL_FUNC (button_press), GTK_OBJECT(menu));
+    gtk_box_pack_end(GTK_BOX(vbox), button, TRUE, TRUE, 2);
+    gtk_widget_show(button);
+
+    /* Finalement, on ajoute l'item de menu à la barre de menu --
+     * c'est l'item de menu racine sur lequel je me suis déchaîné ;-) */
+
+    gtk_menu_bar_append(GTK_MENU_BAR (menu_bar), root_menu);
+
+    /* Affichage de la fenêtre. */
+
+    gtk_widget_show(window);
+
+    gtk_main ();
+
+    return 0;
+}
+
+
+
+/* On répond à un appui sur le bouton en postant un nouveau menu passé comme 
+ * un widget.
+ *
+ * On remarque que le paramètre "widget" est le menu à poster, PAS le bouton
+ * qui a été pressé. */
+
+
+static gint button_press (GtkWidget *widget, GdkEvent *event)
+{
+
+    if (event->type == GDK_BUTTON_PRESS) {
+        GdkEventButton *bevent = (GdkEventButton *) event; 
+        gtk_menu_popup (GTK_MENU(widget), NULL, NULL, NULL, NULL,
+                        bevent->button, bevent->time);
+
+        /* On indique à l'appelant que l'on a géré cet événement. */
+
+        return TRUE;
+    }
+
+    /* On indique à l'appelant que l'on n'a pas géré cet événement. */
+
+    return FALSE;
+}
+
+
+/* Affiche une chaîne lorsqu'un item de menu est choisi. */
+
+static void menuitem_response (GtkWidget *widget, gchar *string)
+{
+    printf("%s\n", string);
+}
+</verb></tscreen>
+
+Vous pouvez aussi configurer un item de menu pour qu'il ne soit pas
+sélectionnable et, en utilisant une table de raccourcis clavier, lier
+des touches aux fonctions du menu.
+<p>
+<sect1>Utilisation de GtkMenuFactory
+<p>
+Maintenant que nous avons exploré la voie difficile, nous allons voir
+l'utilisation des appels <em/gtk_menu_factory./
+<p>
+<sect1>Exemple d'usine à menu
+<p>
+Voici un exemple utilisant l'usine à menu de GTK. Le premier
+fichier est <em/menus.h/.  Nous séparerons <em/menus.c/ et <em/main.c/ à
+cause des variables globales utilisées dans le fichier <em/menus.c/.
+
+<tscreen><verb>
+#ifndef __MENUS_H__
+#define __MENUS_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+void get_main_menu (GtkWidget **menubar, GtkAcceleratorTable **table);
+void menus_create(GtkMenuEntry *entries, int nmenu_entries);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __MENUS_H__ */
+</verb></tscreen>
+<p>
+Voici le fichier <em/menus.c/&nbsp;:
+
+<tscreen><verb>
+
+#include <gtk/gtk.h>
+#include <strings.h>
+
+#include "main.h"
+
+
+static void menus_remove_accel(GtkWidget * widget, gchar * signal_name, gchar * path);
+static gint menus_install_accel(GtkWidget * widget, gchar * signal_name, gchar key, gchar modifiers, gchar * path);
+void menus_init(void);
+void menus_create(GtkMenuEntry * entries, int nmenu_entries);
+
+
+/* Structure GtkMenuEntry utilisée pour créer les menus. Le premier champ 
+ * est la chaîne de définition du menu. Le second, la touche de raccourci 
+ * utilisée pour accéder à cette fonction du menu avec le clavier. 
+ * Le troisième est la fonction de rappel à utiliser lorsque l'item de menu 
+ * est choisi (par la touche de raccourci ou avec la souris). Le dernier 
+ * élément est la donnée à passer à la fonction de rappel. */
+ 
+
+static GtkMenuEntry menu_items[] =
+{
+	{"<Main>/Fichier/Nouveau", "<control>N", NULL, NULL},
+	{"<Main>/Fichier/Ouvrir", "<control>O", NULL, NULL},
+	{"<Main>/Fichier/Sauver", "<control>S", NULL, NULL},
+	{"<Main>/Fichier/Sauver sous", NULL, NULL, NULL},
+	{"<Main>/Fichier/<separator>", NULL, NULL, NULL},
+	{"<Main>/Fichier/Quitter", "<control>Q", file_quit_cmd_callback, "OK, c'est fini"},
+	{"<Main>/Options/Test", NULL, NULL, NULL}
+};
+
+/* Calcul du nombre d'éléments de menu_item */
+
+static int nmenu_items = sizeof(menu_items) / sizeof(menu_items[0]);
+
+static int initialize = TRUE;
+static GtkMenuFactory *factory = NULL;
+static GtkMenuFactory *subfactory[1];
+static GHashTable *entry_ht = NULL;
+
+void get_main_menu(GtkWidget ** menubar, GtkAcceleratorTable ** table)
+{
+    if (initialize)
+	    menus_init();
+    
+    if (menubar)
+	    *menubar = subfactory[0]->widget;
+    if (table)
+	    *table = subfactory[0]->table;
+}
+
+void menus_init(void)
+{
+    if (initialize) {
+	initialize = FALSE;
+	
+	factory = gtk_menu_factory_new(GTK_MENU_FACTORY_MENU_BAR);
+	subfactory[0] = gtk_menu_factory_new(GTK_MENU_FACTORY_MENU_BAR);
+	
+	gtk_menu_factory_add_subfactory(factory, subfactory[0], "<Main>");
+	menus_create(menu_items, nmenu_items);
+    }
+}
+
+void menus_create(GtkMenuEntry * entries, int nmenu_entries)
+{
+    char *accelerator;
+    int i;
+    
+    if (initialize)
+	    menus_init();
+    
+    if (entry_ht)
+	    for (i = 0; i < nmenu_entries; i++) {
+		accelerator = g_hash_table_lookup(entry_ht, entries[i].path);
+		if (accelerator) {
+		    if (accelerator[0] == '\0')
+			    entries[i].accelerator = NULL;
+		    else
+			    entries[i].accelerator = accelerator;
+		}
+	    }
+    gtk_menu_factory_add_entries(factory, entries, nmenu_entries);
+    
+    for (i = 0; i < nmenu_entries; i++)
+	    if (entries[i].widget) {
+		gtk_signal_connect(GTK_OBJECT(entries[i].widget), "install_accelerator",
+				   (GtkSignalFunc) menus_install_accel,
+				   entries[i].path);
+		gtk_signal_connect(GTK_OBJECT(entries[i].widget), "remove_accelerator",
+				   (GtkSignalFunc) menus_remove_accel,
+				   entries[i].path);
+	    }
+}
+
+static gint menus_install_accel(GtkWidget * widget, gchar * signal_name, gchar key, gchar modifiers, gchar * path)
+{
+    char accel[64];
+    char *t1, t2[2];
+    
+    accel[0] = '\0';
+    if (modifiers & GDK_CONTROL_MASK)
+	    strcat(accel, "<control>");
+    if (modifiers & GDK_SHIFT_MASK)
+	    strcat(accel, "<shift>");
+    if (modifiers & GDK_MOD1_MASK)
+	    strcat(accel, "<alt>");
+    
+    t2[0] = key;
+    t2[1] = '\0';
+    strcat(accel, t2);
+    
+    if (entry_ht) {
+	t1 = g_hash_table_lookup(entry_ht, path);
+	g_free(t1);
+    } else
+	    entry_ht = g_hash_table_new(g_string_hash, g_string_equal);
+    
+    g_hash_table_insert(entry_ht, path, g_strdup(accel));
+    
+    return TRUE;
+}
+
+static void menus_remove_accel(GtkWidget * widget, gchar * signal_name, gchar * path)
+{
+    char *t;
+    
+    if (entry_ht) {
+	t = g_hash_table_lookup(entry_ht, path);
+	g_free(t);
+	
+	g_hash_table_insert(entry_ht, path, g_strdup(""));
+    }
+}
+
+void menus_set_sensitive(char *path, int sensitive)
+{
+    GtkMenuPath *menu_path;
+    
+    if (initialize)
+	    menus_init();
+    
+    menu_path = gtk_menu_factory_find(factory, path);
+    if (menu_path)
+	    gtk_widget_set_sensitive(menu_path->widget, sensitive);
+    else
+	    g_warning("Impossible de configurer la sensitivité d'un menu qui n'existe pas : %s", path);
+}
+
+</verb></tscreen>
+<p>
+Voici <em/main.h/&nbsp;:
+
+<tscreen><verb>
+#ifndef __MAIN_H__
+#define __MAIN_H__
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+void file_quit_cmd_callback(GtkWidget *widget, gpointer data);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __MAIN_H__ */
+
+</verb></tscreen>
+<p>
+Et, enfin, <em/main.c/&nbsp;:
+
+<tscreen><verb>
+#include <gtk/gtk.h>
+
+#include "main.h"
+#include "menus.h"
+
+
+int main(int argc, char *argv[])
+{
+    GtkWidget *window;
+    GtkWidget *main_vbox;
+    GtkWidget *menubar;
+    
+    GtkAcceleratorTable *accel;
+    
+    gtk_init(&amp;argc, &amp;argv);
+    
+    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+    gtk_signal_connect(GTK_OBJECT(window), "destroy", 
+		       GTK_SIGNAL_FUNC(file_quit_cmd_callback), 
+		       "WM destroy");
+    gtk_window_set_title(GTK_WINDOW(window), "Usine à menu");
+    gtk_widget_set_usize(GTK_WIDGET(window), 300, 200);
+    
+    main_vbox = gtk_vbox_new(FALSE, 1);
+    gtk_container_border_width(GTK_CONTAINER(main_vbox), 1);
+    gtk_container_add(GTK_CONTAINER(window), main_vbox);
+    gtk_widget_show(main_vbox);
+    
+    get_main_menu(&amp;menubar, &amp;accel);
+    gtk_window_add_accelerator_table(GTK_WINDOW(window), accel);
+    gtk_box_pack_start(GTK_BOX(main_vbox), menubar, FALSE, TRUE, 0);
+    gtk_widget_show(menubar);
+    
+    gtk_widget_show(window);
+    gtk_main();
+    
+    return(0);
+}
+
+/* Juste une démonstration du fonctionnement des fonctions de rappel 
+ * lorsqu'on utilise l'usine à menus. Souvent, on met tous les rappels
+ * des menus dans un fichier séparé, ce qui assure une meilleure 
+ * organisation. */ 
+
+void file_quit_cmd_callback (GtkWidget *widget, gpointer data)
+{
+    g_print ("%s\n", (char *) data);
+    gtk_exit(0);
+}
+</verb></tscreen>
+<p>
+Un <em/makefile/ pour que cela soit plus facile à compiler&nbsp;:
+
+<tscreen><verb>
+CC      = gcc
+PROF    = -g
+C_FLAGS =  -Wall $(PROF) -L/usr/local/include -DDEBUG
+L_FLAGS =  $(PROF) -L/usr/X11R6/lib -L/usr/local/lib 
+L_POSTFLAGS = -lgtk -lgdk -lglib -lXext -lX11 -lm
+PROGNAME = at
+
+O_FILES = menus.o main.o
+
+$(PROGNAME): $(O_FILES)
+	rm -f $(PROGNAME)
+	$(CC) $(L_FLAGS) -o $(PROGNAME) $(O_FILES) $(L_POSTFLAGS)
+
+.c.o: 
+	$(CC) -c $(C_FLAGS) $<
+
+clean: 
+	rm -f core *.o $(PROGNAME) nohup.out
+distclean: clean 
+	rm -f *~
+</verb></tscreen>
+<p>
+Pour l'instant, il n'y a que cet exemple. Une explication et de nombreux commentaires seront intégrés plus tard.
+
+
+<sect>Widgets non documentés
+<p>
+On a besoin de leurs auteurs! :). Participez à notre didacticiel.
+
+Si vous devez utiliser un de ces widgets non documentés, je vous recommande fortement de consulter leurs fichiers en-têtes respectifs dans la distribution GTK. Les noms de fonctions du GTK sont très parlantes. Lorsque vous avez compris comment les choses fonctionnent, il n'est pas difficile de savoir comment utiliser un widget à partir des déclarations de ses fonctions.  Cela, avec quelques exemples de codes pris ailleurs, devrait ne pas poser de problème.
+
+Lorsque vous avez compris toutes les fonctions d'un nouveau widget non documenté, pensez à écrire un didacticiel pour que les autres puissent bénéficier du temps que vous y avez passé.
+
+<sect1>Entrées de texte
+<p>
+
+<sect1>Sélections de couleurs
+<p>
+
+<sect1>Contrôle d'intervalle
+<p>
+
+<sect1>Règles
+<p>
+
+<sect1>Boîtes de texte
+<p>
+
+<sect1>Prévisualisation
+<p>
+(Ceci peut devoir être réécrit pour suivre le style du reste de ce
+didacticiel).
+
+<tscreen><verb>
+
+Les prévisualisateurs servent à plusieurs choses dans GIMP/GTK. La
+plus importante est celle-ci&nbsp;: les images de haute qualité peuvent
+occuper des dizaines de mega-octets en mémoire - facilement ! Toute
+opération sur une image aussi grosse implique un temps de traitement
+élevé. Si cela vous prend 5 à 10 essais (i.e. 10 à 20 étapes puisque
+vous devez recommencer lorsque vous avez fait une erreur) pour choisir
+la bonne modification, cela prendra littéralement des heures pour
+produire la bonne image - pour peu que vous ne manquiez pas de mémoire
+avant. Ceux qui on passé des heures dans les chambres noires de
+développement couleur connaissent cette sensation. Les
+prévisualisations sont notre planche de salut !
+
+L'aspect pénible de l'attente n'est pas le seul problème. souvent, il
+est utile de comparer les versions « Avant » et « Après » côte à côte
+ou, au pire l'une après l'autre. Si vous travaillez avec de grosses
+images et des attentes de 10 secondes, l'obtention des versions «
+Avant » et « Après » est, pour le moins, difficile. Pour des images de
+30Mo (4"x6", 600dpi, 24 bits), la comparaison côte à côte est
+impossible pour la plupart des gens, et la comparaison séquentielle
+n'est guère mieux. Les prévisualisations sont notre planche de salut !
+
+Mais il y a plus. Les prévisualisations permettent les
+pré-prévisualisations côte à côte. En d'autres termes, vous écrivez un
+plug-in (par exemple la simulation filterpack) qui aurait plusieurs
+prévisualisations de ce-que-ce-serait-si-vous-faisiez-ceci. Une approche
+comme celle ci agit comme une sorte de palette de prévisualisation et
+est très pratique pour les petites modifications. Utilisons les
+prévisualisations !
+
+Encore plus&nbsp;: pour certains plug-ins une intervention humaine en
+temps réel, spécifique aux images, peut s'avérer nécessaire. Dans le
+plug-in SuperNova, par exemple, on demande à l'utilisateur d'entrer
+les coordonnées du centre de la future supernova. La façon la plus
+simple de faire cela, vraiment, est de présenter une prévisualisation
+à l'utilisateur et de lui demander de choisir interactivement le
+point. Utilisons les prévisualisations !
+
+Enfin, quelques utilisations diverses&nbsp;: on peut utiliser les
+prévisualisations, même lorsqu'on ne travaille pas avec de grosses
+images. Elles sont utiles, par exemple, lorsqu'on veut avoir un rendu
+de motifs complexes. (Testez le vénérable plug-in Diffraction et
+d'autres !). Comme autre exemple, regardez le plug-in de rotation de
+couleur (travail en cours). Vous pouvez aussi utiliser les
+prévisualisations pour des petits logos dans vos plug-ins et même pour
+une photo de vous, l'Auteur. Utilisons les prévisualisations !
+
+Quand ne pas utiliser les prévisualisations
+
+N'utilisez pas les prévisualisations pour les graphes, les tracés,
+etc. GDK est bien plus rapide pour ça. N'utilisez les que pour les
+images !
+
+Utilisons les prévisualisations !
+
+Vous pouvez mettre une prévisualisation dans à peu près n'importe
+quoi. Dans une vbox, une hbox, un bouton, etc. Mais elles donnent leur
+meilleur d'elles-mêmes dans des cadres resserrés autour d'elles. Les
+prévisualisations n'ont, par elles-mêmes, aucun contour et semblent
+plates sans eux. (Bien sûr, si c'est cet aspect que vous
+voulez...). Les cadres serrés fournissent les bordures nécessaires.
+
+                               [Image][Image]
+
+Les prévisualisations sont, à bien des égards, comme tous les autres
+widgets de GTK (avec tout ce que cela implique) sauf qu'il disposent
+d'une fonctionnalité supplémentaire&nbsp;: ils doivent être remplis
+avec une image ! Nous traiterons d'abord exclusivement de l'aspect GTK
+des prévisualisations, puis nous verrons comment les remplir.
+
+
+                              /* Création d'un widget prévisualisation,
+                               * configuration de sa taille et affichage */
+GtkWidget *preview;
+preview=gtk_preview_new(GTK_PREVIEW_COLOR)
+                              /* Autre option :
+                              GTK_PREVIEW_GRAYSCALE);*/
+
+gtk_preview_size (GTK_PREVIEW (preview), WIDTH, HEIGHT);
+gtk_widget_show(preview);
+my_preview_rendering_function(preview);
+
+Ah oui, comme je le disais, les prévisualisations rendent mieux dans
+des cadres&nbsp;:
+
+GtkWidget *create_a_preview(int        Width,
+                            int        Height,
+                            int        Colorfulness)
+{
+  GtkWidget *preview;
+  GtkWidget *frame;
+  
+  frame = gtk_frame_new(NULL);
+  gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
+  gtk_container_border_width (GTK_CONTAINER(frame),0);
+  gtk_widget_show(frame);
+
+  preview=gtk_preview_new (Colorfulness?GTK_PREVIEW_COLOR
+                                       :GTK_PREVIEW_GRAYSCALE);
+  gtk_preview_size (GTK_PREVIEW (preview), Width, Height);
+  gtk_container_add(GTK_CONTAINER(frame),preview);
+  gtk_widget_show(preview);
+
+  my_preview_rendering_function(preview);
+  return frame;
+}
+
+Ceci est ma prévisualisation de base. Cette fonction retourne le cadre
+« père », on peut ainsi le placer ailleurs dans notre interface. Bien
+sûr, on peut passer le cadre « père » en paramètre à cette
+fonction. Dans de nombreuses situations, toutefois, le contenu de la
+prévisualisation est changée continuellement par notre application. En
+ce cas, on peut passer un pointeur vers une prévisualisation à la
+fonction <em/create_a_preview()/ et avoir ainsi un contrôle sur elle
+plus tard.
+
+Un point plus important qui pourra un jour vous faire économiser
+beaucoup de temps. Quelques fois, il est souhaitable de mettre un
+label à votre prévisualisation. Par exemple, on peut nommer la
+prévisualisation contenant l'image originale « Original » et celle
+contenant l'image modifiée « Moins Originale ». Il peut vous arriver
+de placer la prévisualisation avec le label approprié dans une
+vbox. L'effet inattendu est que si le label est plus large que la
+prévisualisation (taille de cette dernière, taille de la fonte du
+label, etc), le cadre s'élargit et ne convient plus à la
+prévisualisation. Le même problème se passera probablement dans
+d'autres situations aussi.
+
+                                   [Image]
+
+La solution consiste à placer la prévisualisation et le label dans une
+table de 2x2 en les attachant avec les paramètres suivants (c'est
+l'une des possibilités, bien sûr. La clé consiste à ne pas mettre
+GTK_FILL dans le second attachement)«nbsp;:
+
+gtk_table_attach(GTK_TABLE(table),label,0,1,0,1,
+                 0,
+                 GTK_EXPAND|GTK_FILL,
+                 0,0);
+gtk_table_attach(GTK_TABLE(table),frame,0,1,1,2,
+                 GTK_EXPAND,
+                 GTK_EXPAND,
+                 0,0);
+
+
+Et voici le résultat&nbsp;:
+
+                                   [Image]
+
+Divers
+
+Rendre une prévisualisation cliquable se fait très facilement en la plaçant dans un bouton. Cela ajoute aussi une bordure agréable autour de la prévisualisation et vous n'avez même pas besoin de la mettre dans un cadre.  Voir le plug-in Filter Pack Simulation comme exemple.
+
+Remplir une prévisualisation
+
+Afin de nous familiariser avec les bases de ce remplissage, créons le motif suivant&nbsp;:
+
+                                   [Image]
+
+void
+my_preview_rendering_function(GtkWidget     *preview)
+{
+#define SIZE 100
+#define HALF (SIZE/2)
+
+  guchar *row=(guchar *) malloc(3*SIZE); /* 3 bits par point */
+  gint i, j;                             /* Coordonnées      */
+  double r, alpha, x, y;
+
+  if (preview==NULL) return; /* J'ajoute généralement ceci quand je */
+                             /* veux éviter des plantages stupides  */
+                             /* Vous devez vous assurer que tout a  */
+                             /* été correctement initialisé !       */
+
+  for (j=0; j < ABS(cos(2*alpha)) ) { /* Sommes-nous dans la forme ? */
+                                         /* glib.h contient ABS(x).   */
+        row[i*3+0] = sqrt(1-r)*255;      /* Definit rouge             */
+        row[i*3+1] = 128;                /* Definit vert              */
+        row[i*3+2] = 224;                /* Definit bleu              */
+      }                                  /* "+0" est pour l'alignement ! */
+      else {
+        row[i*3+0] = r*255;
+        row[i*3+1] = ABS(sin((float)i/SIZE*2*PI))*255;
+        row[i*3+2] = ABS(sin((float)j/SIZE*2*PI))*255;
+      }
+    }
+    gtk_preview_draw_row( GTK_PREVIEW(preview),row,0,j,SIZE);
+
+    /* Insère "row" dans "preview" en partant du point de */
+    /* coordonnées (0,j) première colonne, j_ième ligne allant de SIZE */
+    /* pixels vers la droite */
+  }
+
+  free(row); /* on récupère un peu d'espace */
+  gtk_widget_draw(preview,NULL); /* qu'est-ce que ça fait ? */
+  gdk_flush(); /* et ça ?  */
+}
+
+Ceux qui n'utilisent pas GIMP en ont suffisamment vu pour faire
+déjà beaucoup de choses. Pour ceux qui l'utilisent, j'ai quelques
+précisions à ajouter.
+
+Prévisualisation d'image
+
+Il est pratique de conserver une version réduite de l'image ayant
+juste assez de pixels pour remplir la prévisualisation. Ceci est
+possible en choisissant chaque énième pixel où n est le ratio de la
+taille de l'image par rapport à la taille de la visualisation. Toutes
+les opérations suivantes (y compris le remplissage des
+prévisualisations) sont alors réalisées seulement sur le nombre réduit
+de pixels. Ce qui suit est mon implantation de la réduction d'image
+(Gardez à l'esprit que je n'ai que quelques notions de base en C !).
+
+(ATTENTION : CODE NON TESTÉ !!!)
+
+typedef struct {
+  gint      width;
+  gint      height;
+  gint      bbp;
+  guchar    *rgb;
+  guchar    *mask;
+} ReducedImage;
+
+enum {
+  SELECTION_ONLY,
+  SELCTION_IN_CONTEXT,
+  ENTIRE_IMAGE
+};
+
+ReducedImage *Reduce_The_Image(GDrawable *drawable,
+                               GDrawable *mask,
+                               gint LongerSize,
+                               gint Selection)
+{
+  /* Cette fonction réduit l'image à la taille de prévisualisation choisie */
+  /* La taille de la prévisualisation est déterminée par LongerSize, i.e.  */
+  /* la plus grande des deux dimensions. Ne fonctionne qu'avec des images  */
+  /* RGB !                                                                 */
+
+  gint RH, RW;          /* Hauteur et Largeur réduites                     */
+  gint width, height;   /* Largeur et Hauteur de la surface à réduire      */
+  gint bytes=drawable->bpp;
+  ReducedImage *temp=(ReducedImage *)malloc(sizeof(ReducedImage));
+
+  guchar *tempRGB, *src_row, *tempmask, *src_mask_row,R,G,B;
+  gint i, j, whichcol, whichrow, x1, x2, y1, y2;
+  GPixelRgn srcPR, srcMask;
+  gint NoSelectionMade=TRUE; /* Suppose que l'on traite l'image entière    */
+
+  gimp_drawable_mask_bounds (drawable->id, &amp;x1, &amp;y1, &amp;x2, &amp;y2);
+  width  = x2-x1;
+  height = y2-y1;
+  /* S'il y a une SELECTION, on récupère ses frontières ! */
+
+  if (width != drawable->width &amp;&amp; height != drawable->height)
+    NoSelectionMade=FALSE;
+  /* On vérifie si l'utilisateur a rendu une sélection active         */
+  /* Ceci sera important plus tard, lorsqu'on créera un masque réduit */
+
+  /* Si on veut prévisualiser l'image entière, supprimer ce qui suit ! */
+  /* Bien sûr, s'il n'y a pas de sélection, cela n'a aucun effet !     */
+  if (Selection==ENTIRE_IMAGE) {
+    x1=0;
+    x2=drawable->width;
+    y1=0;
+    y2=drawable->height;
+  }
+
+  /* Si on veut prévisualiser une sélection avec une surface qui l'entoure, */
+  /* on doit l'agrandir un petit peu. Considérez ça comme une devinette.   */
+
+  if (Selection==SELECTION_IN_CONTEXT) {
+    x1=MAX(0,                x1-width/2.0);
+    x2=MIN(drawable->width,  x2+width/2.0);
+    y1=MAX(0,                y1-height/2.0);
+    y2=MIN(drawable->height, y2+height/2.0);
+  }
+
+  /* Calcul de la largeur et de la hauteur de la surface à réduire. */
+
+  width  = x2-x1;
+  height = y2-y1;
+
+  /* Les lignes ci-dessous déterminent la dimension qui sera le coté */
+  /* le plus long. Cette idée est empruntée au plug-in Supernova.    */
+  /* Je soupçonne que j'aurais pu y penser moi-même, mais la vérité  */
+  /* doit être dite. Le plagiat pue !                                */
+
+  if (width>height) {
+    RW=LongerSize;
+    RH=(float) height * (float) LongerSize/ (float) width;
+  }
+  else {
+    RH=LongerSize;
+    RW=(float)width * (float) LongerSize/ (float) height;
+  }
+
+  /* L'image entière est réduite dans une chaîne ! */
+
+  tempRGB   = (guchar *) malloc(RW*RH*bytes);
+  tempmask  = (guchar *) malloc(RW*RH);
+
+  gimp_pixel_rgn_init (&amp;srcPR, drawable, x1, y1, width, height, FALSE, FALSE);
+  gimp_pixel_rgn_init (&amp;srcMask, mask, x1, y1, width, height, FALSE, FALSE);
+
+  /* Réservation pour sauver une ligne d'image et une ligne du masque */
+  src_row       = (guchar *) malloc (width*bytes);
+  src_mask_row  = (guchar *) malloc (width);
+
+  for (i=0; i < RH; i++) {
+    whichrow=(float)i*(float)height/(float)RH;
+    gimp_pixel_rgn_get_row (&amp;srcPR, src_row, x1, y1+whichrow, width);
+    gimp_pixel_rgn_get_row (&amp;srcMask, src_mask_row, x1, y1+whichrow, width);
+
+    for (j=0; j < RW; j++) {
+      whichcol=(float)j*(float)width/(float)RW;
+
+      /* Pas de sélection = chaque point est complètement sélectionné ! */
+
+      if (NoSelectionMade)
+        tempmask[i*RW+j]=255;
+      else
+        tempmask[i*RW+j]=src_mask_row[whichcol];
+
+      /* Ajout de la ligne à la longue chaîne qui contient maintenant */
+      /* l'image !                                                    */
+
+      tempRGB[i*RW*bytes+j*bytes+0]=src_row[whichcol*bytes+0];
+      tempRGB[i*RW*bytes+j*bytes+1]=src_row[whichcol*bytes+1];
+      tempRGB[i*RW*bytes+j*bytes+2]=src_row[whichcol*bytes+2];
+
+      /* On s'accroche aussi à l'alpha */
+      if (bytes==4)
+        tempRGB[i*RW*bytes+j*bytes+3]=src_row[whichcol*bytes+3];
+    }
+  }
+  temp->bpp=bytes;
+  temp->width=RW;
+  temp->height=RH;
+  temp->rgb=tempRGB;
+  temp->mask=tempmask;
+  return temp;
+}
+
+La suite est une fonction de prévisualisation qui utilise le même type
+<em/ReducedImage/ !  On remarque qu'elle utilise une fausse
+transparence (au moyen de <em/fake_transparancy/ qui est défini comme
+suit&nbsp;:
+
+gint fake_transparency(gint i, gint j)
+{
+  if ( ((i%20)- 10) * ((j%20)- 10)>0   )
+    return 64;
+  else
+    return 196;
+}
+
+Voici maintenant la fonction de prévisualisation«nbsp;:
+
+void
+my_preview_render_function(GtkWidget     *preview,
+                           gint          changewhat,
+                           gint          changewhich)
+{
+  gint Inten, bytes=drawable->bpp;
+  gint i, j, k;
+  float partial;
+  gint RW=reduced->width;
+  gint RH=reduced->height;
+  guchar *row=malloc(bytes*RW);;
+
+
+  for (i=0; i < RH; i++) {
+    for (j=0; j < RW; j++) {
+
+      row[j*3+0] = reduced->rgb[i*RW*bytes + j*bytes + 0];
+      row[j*3+1] = reduced->rgb[i*RW*bytes + j*bytes + 1];
+      row[j*3+2] = reduced->rgb[i*RW*bytes + j*bytes + 2];
+
+      if (bytes==4)
+        for (k=0; k<3; k++) {
+          float transp=reduced->rgb[i*RW*bytes+j*bytes+3]/255.0;
+          row[3*j+k]=transp*a[3*j+k]+(1-transp)*fake_transparency(i,j);
+        }
+    }
+    gtk_preview_draw_row( GTK_PREVIEW(preview),row,0,i,RW);
+  }
+
+  free(a);
+  gtk_widget_draw(preview,NULL);
+  gdk_flush();
+}
+
+Fonctions applicables
+
+guint           gtk_preview_get_type           (void);
+/* Aucune idée */
+void            gtk_preview_uninit             (void);
+/* Aucune idée */
+GtkWidget*      gtk_preview_new                (GtkPreviewType   type);
+/* Décrite ci-dessous */
+void            gtk_preview_size               (GtkPreview      *preview,
+                                                gint             width,
+                                                gint             height);
+/* Permet de changer la taille d'une prévisualisation existante */
+/* Apparamment, il y a un bug dans GTK qui rend ce traitement   */
+/* hasardeux. Une méthode pour corriger ce problème consiste à  */
+/* changer manuellement la taille de la fenêtre contenant la    */
+/* prévisualisation après avoir changé la taille de la          */
+/* prévisualisation.                                            */
+
+void            gtk_preview_put                (GtkPreview      *preview,
+                                                GdkWindow       *window,
+                                                GdkGC           *gc,
+                                                gint             srcx,
+                                                gint             srcy,
+                                                gint             destx,
+                                                gint             desty,
+                                                gint             width,
+                                                gint             height);
+/* Aucune idée */
+
+void            gtk_preview_put_row            (GtkPreview      *preview,
+                                                guchar          *src,
+                                                guchar          *dest,
+                                                gint             x,
+                                                gint             y,
+                                                gint             w);
+/* Aucune idée */
+
+void            gtk_preview_draw_row           (GtkPreview      *preview,
+                                                guchar          *data,
+                                                gint             x,
+                                                gint             y,
+                                                gint             w);
+/* Décrite dans le texte */
+
+void            gtk_preview_set_expand         (GtkPreview      *preview,
+                                                gint             expand);
+/* Aucune idée */
+
+/* Aucune piste pour celles qui suivent mais devrait être */
+/* un standard pour la plupart des widgets.               */
+
+void            gtk_preview_set_gamma          (double           gamma);
+void            gtk_preview_set_color_cube     (guint            nred_shades,
+                                                guint            ngreen_shades,
+                                                guint            nblue_shades,
+                                                guint            ngray_shades);
+void            gtk_preview_set_install_cmap   (gint             install_cmap);
+void            gtk_preview_set_reserved       (gint             nreserved);
+GdkVisual*      gtk_preview_get_visual         (void);
+GdkColormap*    gtk_preview_get_cmap           (void);
+GtkPreviewInfo* gtk_preview_get_info           (void);
+
+That's all, folks!
+
+</verb></tscreen>
+
+
+<sect1>Courbes
+<p>
+
+
+<sect>Widget EventBox <label id="sec_The_EventBox_Widget">
+<p>
+Il n'est disponible que dans <em/gtk+970916.tar.gz/ et les
+distributions ultérieures.  <p> Certains widgets GTK n'ont pas de
+fenêtre X associée, il se dessinent donc sur leurs parents. À cause de
+cela, ils ne peuvent recevoir d'événements et, s'ils ont une taille
+incorrecte, ils ne peuvent pas se mettre en place correctement&nbsp;: on peut
+alors avoir des surimpressions douteuses, etc. Si vous avez besoin de
+ces widgets, <em/EventBox/ est fait pour vous.
+
+Au premier abord, le widget <em/EventBox/ peut apparaître comme
+totalement dénué d'intérêt. Il ne dessine rien à l'écran et ne répond
+à aucun évenement. Cependant, il joue un rôle - il fournit une fenêtre
+X pour son widget fils. Ceci est important car de nombreux widgets GTK
+n'ont pas de fenêtre X associée. Ne pas avoir de fenêtre permet
+d'économiser de la mémoire mais a aussi quelques inconvénients. Un
+widget sans fenêtre ne peut recevoir d'événement, et ne réalise aucune
+mise en place de ce qu'il contient. Bien que le nom « EventBox »
+insiste sur la fonction de gestion d'événement, le widget peut aussi
+être utilisé pour la mise en place (et plus... voir l'exemple
+ci-dessous).
+
+<p>
+Pour créer un widget EventBox, on utilise&nbsp;:
+
+<tscreen><verb>
+GtkWidget* gtk_event_box_new (void);
+</verb></tscreen>
+
+<p>
+Un widget fils peut alors être ajouté à cet <em/EventBox/&nbsp;:
+
+<tscreen><verb>
+gtk_container_add (GTK_CONTAINER(event_box), widget);
+</verb></tscreen>
+
+<p>
+L'exemple suivant montre l'utilisation d'un <em/EventBox/ - un label
+est créé et mis en place sur une petite boîte, et configuré pour qu'un
+clic souris sur le label provoque la fin du programme.
+
+<tscreen><verb>
+#include <gtk/gtk.h>
+
+int 
+main (int argc, char *argv[])
+{
+    GtkWidget *window;
+    GtkWidget *event_box;
+    GtkWidget *label;
+    
+    gtk_init (&amp;argc, &amp;argv);
+    
+    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+    
+    gtk_window_set_title (GTK_WINDOW (window), "Event Box");
+    
+    gtk_signal_connect (GTK_OBJECT (window), "destroy",
+			GTK_SIGNAL_FUNC (gtk_exit), NULL);
+    
+    gtk_container_border_width (GTK_CONTAINER (window), 10);
+    
+    /* Création d'un EventBox et ajout de celui-ci dans la fenêtre. */
+    
+    event_box = gtk_event_box_new ();
+    gtk_container_add (GTK_CONTAINER(window), event_box);
+    gtk_widget_show (event_box);
+    
+    /* Création d'un long label */
+    
+    label = gtk_label_new ("Cliquez ici pour quitter, quitter, quitter, quitter, quitter");
+    gtk_container_add (GTK_CONTAINER (event_box), label);
+    gtk_widget_show (label);
+    
+    /* Placement serré. */
+
+    gtk_widget_set_usize (label, 110, 20);
+    
+    /* Attachement d'une action à celui-ci. */
+
+    gtk_widget_set_events (event_box, GDK_BUTTON_PRESS_MASK);
+    gtk_signal_connect (GTK_OBJECT(event_box), "button_press_event",
+			GTK_SIGNAL_FUNC (gtk_exit), NULL);
+    
+    /* Encore une fois, vous avez besoin d'une fenêtre X pour... */
+    
+    gtk_widget_realize (event_box);
+    gdk_window_set_cursor (event_box->window, gdk_cursor_new (GDK_HAND1));
+    
+    gtk_widget_show (window);
+    
+    gtk_main ();
+    
+    return 0;
+}
+</verb></tscreen>
+
+<sect>Configuration des attributs de widget<label
+id="sec_setting_widget_attributes">
+<p>
+Cette section décrit les fonctions opérant sur les widgets. Elles
+peuvent être utilisées pour configurer le style, l'espacement, la
+taille, etc.
+
+(Je devrais peut être faire une section uniquement consacrée aux
+raccourcis clavier.)
+
+<tscreen><verb>
+void       gtk_widget_install_accelerator (GtkWidget           *widget,
+					   GtkAcceleratorTable *table,
+					   gchar               *signal_name,
+					   gchar                key,
+					   guint8               modifiers);
+
+void       gtk_widget_remove_accelerator  (GtkWidget           *widget,
+					   GtkAcceleratorTable *table,
+					   gchar               *signal_name);
+
+void       gtk_widget_activate            (GtkWidget           *widget);
+
+void       gtk_widget_set_name            (GtkWidget           *widget,
+					   gchar               *name);
+gchar*     gtk_widget_get_name            (GtkWidget           *widget);
+
+void       gtk_widget_set_sensitive       (GtkWidget           *widget,
+					   gint                 sensitive);
+
+void       gtk_widget_set_style           (GtkWidget           *widget,
+					   GtkStyle            *style);
+					   
+GtkStyle*    gtk_widget_get_style     (GtkWidget *widget);
+
+GtkStyle*    gtk_widget_get_default_style    (void);
+
+void       gtk_widget_set_uposition       (GtkWidget           *widget,
+					   gint                 x,
+					   gint                 y);
+void       gtk_widget_set_usize           (GtkWidget           *widget,
+					   gint                 width,
+					   gint                 height);
+
+void       gtk_widget_grab_focus          (GtkWidget           *widget);
+
+void       gtk_widget_show                (GtkWidget           *widget);
+
+void       gtk_widget_hide                (GtkWidget           *widget);
+</verb></tscreen>
+
+
+
+<sect>Temporisations, fonctions d'E/S et d'attente<label id="sec_timeouts">
+<p>
+<sect1>Temporisations
+<p>
+Vous pouvez vous demander comment faire pour que GTK fasse quelque
+chose d'utile lorsqu'il est dans <em/gtk_main/. En fait, on a
+plusieurs options. L'utilisation des fonctions suivantes permet de
+créer une temporisation qui sera appelée tous les
+<em/interval/ millisecondes.
+
+<tscreen><verb>
+gint gtk_timeout_add (guint32 interval,
+		      GtkFunction function,
+		      gpointer data);
+</verb></tscreen>
+
+Le premier paramètre est le nombre de millisecondes entre les appels à
+notre fonction. Le deuxième est la fonction à appeler et le troisième
+est la donnée passée à cette fonction de rappel. La valeur retournée
+est un « marqueur » de type entier qui pourra être utilisé pour
+arrêter la temporisation en appelant&nbsp;:
+
+<tscreen><verb>
+void gtk_timeout_remove (gint tag);
+</verb></tscreen>
+
+On peut aussi stopper la fonction de temporisation en faisant
+retourner zéro ou FALSE à notre fonction de rappel. Évidemment, cela
+veut dire que si vous voulez que votre fonction continue à être
+appelée, elle doit retourner une valeur non nulle, ou TRUE.
+
+La déclaration de votre fonction de rappel doit ressembler à ça&nbsp;:
+
+<tscreen><verb>
+gint timeout_callback (gpointer data);
+</verb></tscreen>
+
+<sect1>Surveillance des E/S
+<p>
+Une autre caractéristique intéressante du GTK est la possibilité de
+vérifier les données d'un descripteur de fichier (celles retournées
+par <em/open/(2) ou <em/socket/(2)). C'est particulièrement pratique pour les
+applications réseau. La fonction suivante permet cette
+vérification&nbsp;:
+
+<tscreen><verb>
+gint gdk_input_add (gint source,
+		    GdkInputCondition condition,
+		    GdkInputFunction  function,
+		    gpointer data);
+</verb></tscreen>
+
+Le premier paramètre est le descripteur de fichier que l'on veut
+étudier, le second spécifie ce qu'on veut que le GDK recherche. Cela
+peut être&nbsp;:
+<p>
+GDK_INPUT_READ - Appel <em/function/ lorsqu'il y a une donnée prête à
+être lue dans le descripteur de fichier.
+<p>
+GDK_INPUT_WRITE - Appel de <em/function/ lorsque le descripteur de
+fichier est prêt pour une écriture.
+<p>
+Je suis sûr que vous vous doutez, maintenant, que le troisième
+paramètre est la fonction que l'on veut appeler lorsque les conditions
+ci-dessus sont satisfaites. Le dernier paramètre est la donnée à
+passer à cette fonction.
+<p>
+La valeur retournée est un marqueur qui pourra être utilisé pour dire
+au GDK de cesser de surveiller ce descripteur à l'aide de la fonction&nbsp;:
+<p>
+<tscreen><verb>
+void gdk_input_remove (gint tag);
+</verb></tscreen>
+<p>
+La fonction de rappel doit être déclarée de la façon suivante&nbsp;:
+<p>
+<tscreen><verb>
+void input_callback (gpointer data, gint source, 
+                     GdkInputCondition condition);
+</verb></tscreen>
+<p>
+
+<sect1>Fonctions d'attente
+<p>
+Que se passe-t'il si vous avez une fonction qui doit être appelée
+lorsque rien d'autre ne se passe ? On utilise la fonction suivante qui force
+GTK à appeler <em/function/ lorsqu'on est en phase d'inaction&nbsp;;
+
+<tscreen><verb>
+gint gtk_idle_add (GtkFunction function,
+		   gpointer data);
+</verb></tscreen>
+
+<tscreen><verb>
+void gtk_idle_remove (gint tag);
+</verb></tscreen>
+<p>
+Je n'expliquerai pas la signification des paramètres car ils
+ressemblent beaucoup à ceux déjà vus ci-dessus. La fonction pointée
+par le premier paramètre de <em/gtk_idle_add()/ sera appelée à chaque
+occasion. Comme pour les autres, retourner FALSE empêchera la fonction
+d'attente d'être appelée.
+
+<sect>Gestion des sélections
+
+<sect1>Introduction
+<p>
+Un type de communication inter-processus gérée par GTK est les
+<em>sélections</em>. Une sélection identifie un morceau de données,
+par exemple une portion de texte sélectionnée par l'utilisateur avec
+la souris. Seule une application sur un écran (le <em/propriétaire/)
+peut posséder une sélection particulière à un moment donné, ainsi
+lorsqu'une sélection est réclamée par une application, le propriétaire
+précédent doit indiquer à l'utilisateur que la sélection a été
+abandonnée. Les autres applications peuvent demander le contenu d'une
+sélection sous différentes formes appelées <em/cibles/. Il peut y
+avoir un nombre quelconque de sélections, mais la plupart des
+applications X n'en gèrent qu'une, la <em/sélection primaire/.
+
+<p>
+Dans la plupart des cas, une application GTK n'a pas besoin de gérer elle-même
+les sélections. Les widgets standards, comme le widget Entrée de texte,
+possèdent déjà la capacité de réclamer la sélection lorsqu'il le faut (par
+exemple, lorsque l'utilisateur glisse au dessus d'un texte) et de récupérer le
+contenu de la sélection détenue par un autre widget ou une autre application
+(par exemple, lorsque l'utilisateur clique avec le deuxième bouton de la
+souris). Cependant, il peut il y avoir des cas dans lesquels vous voulez donner
+aux autres widgets la possibilité de fournir la sélection, ou vous désirez
+récupérer des cibles non supportées par défaut.
+
+<p>
+Un concept fondamental dans la compréhension du fonctionnement des
+sélections est celui d'<em/atome/. Un atome est un entier qui définit
+de façon unique une chaîne (sur un affichage particulier). Certains
+atomes sont prédéfinis par le serveur X et, dans certains cas, des
+constantes définies dans <em/gtk.h/ correspondent à ces atomes. Par
+exemple, la constante GDK_PRIMARY_SELECTION correspond à la chaîne
+"PRIMARY".  Dans d'autres cas, on doit utiliser les fonctions
+<em/gdk_atom_intern()/, pour obtenir l'atome correspondant à une
+chaîne, et <em/gdk_atom_name()/, pour obtenir le nom d'un atome. Les
+sélections et les cibles sont identifiés par des atomes.
+
+<sect1>Récupération de la sélection
+<p>
+La récupération de la sélection est un processus asynchrone. Pour démarrer le processus, on appelle&nbsp;:
+
+<tscreen><verb>
+gint gtk_selection_convert   (GtkWidget 	  *widget, 
+			      GdkAtom    	   selection, 
+			      GdkAtom    	   target,
+			      guint32    	   time)
+</verb</tscreen>
+
+Cela <em>convertit</em> la sélection dans la forme spécifiée par
+<em/target/. Si tout est possible, le paramètre <em/time/ sera le
+moment de l'événement qui a déclenché la sélection. Ceci aide à
+s'assurer que les événements arrivent dans l'ordre où l'utilisateur
+les a demandé. Cependant, si cela n'est pas possible (par exemple,
+lorsque la conversion a été déclenchée par un signal "clicked"), alors
+on peut utiliser la macro GDK_CURRENT_TIME.
+
+<p>
+Quand le propriétaire de la sélection répond à la requête, un signal
+"selection_received" est envoyé à notre application. Le gestionnaire
+de ce signal reçoit un pointeur vers une structure
+<tt/GtkSelectionData/ définie ainsi&nbsp;:
+
+<tscreen><verb>
+struct _GtkSelectionData
+{
+  GdkAtom selection;
+  GdkAtom target;
+  GdkAtom type;
+  gint    format;
+  guchar *data;
+  gint    length;
+};
+</verb></tscreen>
+
+<em/selection/ et <em/target/ sont les valeurs que l'on a donné dans
+notre appel <em/gtk_selection_convert()/. <em/type/ est un atome qui
+identifie le type de données retourné par le propriétaire de la
+sélection. Quelques valeurs possibles sont&nbsp;: "STRING", une chaîne
+de caractères latin-1, "ATOM", une série d'atomes, "INTEGER", un
+entier, etc. La plupart des cibles ne peuvent retourner qu'un
+type. <em/format/ donne la longueur des unités (les caractères, par
+exemple) en bits. Habituellement, on ne se préoccupe pas de cela
+lorsqu'on reçoit des données. <em/data/ est un pointeur vers la donnée
+retournée et <em/length/ donne la longueur en octets de la donnée
+retournée. Si <em/length/ est négative, cela indique qu'une erreur est
+survenue et que la sélection ne peut être récupérée. Ceci peut arriver
+si aucune application n'est propriétaire de la sélection, ou si vous
+avez demandé une cible que l'application ne sait pas gérer. Le tampon
+est garanti d'être un octet plus long que <em/length/ ; l'octet
+supplémentaire sera toujours zéro, et il n'est donc pas nécessaire de
+faire une copie de chaîne simplement pour qu'elle soit terminée par
+zéro (comme doivent l'être toutes les chaînes C).
+
+<p>
+Dans l'exemple qui suit, on récupère la cible spéciale "TARGETS", qui
+est une liste de toutes les cibles en lesquelles la sélection peut
+être convertie.
+
+<tscreen><verb>
+#include <gtk/gtk.h>
+
+void selection_received (GtkWidget *widget, 
+			 GtkSelectionData *selection_data, 
+			 gpointer data);
+
+/* Gestionnaire de signal invoqué lorsque l'utilisateur clique sur 
+ * le bouton « Obtenir les cibles ». */
+
+void get_targets (GtkWidget *widget, gpointer data)
+{
+  static GdkAtom targets_atom = GDK_NONE;
+
+  /* Obtention de l'atome correspondant à la chaîne "TARGETS" */
+
+  if (targets_atom == GDK_NONE)
+    targets_atom = gdk_atom_intern ("TARGETS", FALSE);
+
+  /* Demande de la cible "TARGETS" pour la sélection primaire */
+
+  gtk_selection_convert (widget, GDK_SELECTION_PRIMARY, targets_atom,
+			 GDK_CURRENT_TIME);
+}
+
+/* Gestionnaire de signal appelé quand le propriétaire des sélections
+ * retourne la donnée. */
+
+void selection_received (GtkWidget *widget, GtkSelectionData *selection_data, 
+		    gpointer data)
+{
+  GdkAtom *atoms;
+  GList *item_list;
+  int i;
+
+  /* **** IMPORTANT **** On vérifie si la récupération s'est bien passée. */
+
+  if (selection_data->length < 0)
+    {
+      g_print ("Selection retrieval failed\n");
+      return;
+    }
+
+  /* On s'assure que l'on a obtenu la donnée sous la forme attendue. */
+
+  if (selection_data->type != GDK_SELECTION_TYPE_ATOM)
+    {
+      g_print ("La sélection \"TARGETS\" n'a pas été retournée sous la forme d'atomes !\n");
+      return;
+    }
+  
+  /* Affichage des atomes reçus. */
+
+  atoms = (GdkAtom *)selection_data->data;
+
+  item_list = NULL;
+  for (i=0; i<selection_data->length/sizeof(GdkAtom); i++)
+    {
+      char *name;
+      name = gdk_atom_name (atoms[i]);
+      if (name != NULL)
+	g_print ("%s\n",name);
+      else
+	g_print ("(atome incorrect)\n");
+    }
+
+  return;
+}
+
+int 
+main (int argc, char *argv[])
+{
+  GtkWidget *window;
+  GtkWidget *button;
+  
+  gtk_init (&amp;argc, &amp;argv);
+
+  /* Création de la fenêtre de l'application. */
+
+  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  gtk_window_set_title (GTK_WINDOW (window), "Sélections");
+  gtk_container_border_width (GTK_CONTAINER (window), 10);
+
+  gtk_signal_connect (GTK_OBJECT (window), "destroy",
+		      GTK_SIGNAL_FUNC (gtk_exit), NULL);
+
+  /* Création d'un bouton pour obtenir les cibles */
+
+  button = gtk_button_new_with_label ("Obtenir les cibles");
+  gtk_container_add (GTK_CONTAINER (window), button);
+
+  gtk_signal_connect (GTK_OBJECT(button), "clicked",
+		      GTK_SIGNAL_FUNC (get_targets), NULL);
+  gtk_signal_connect (GTK_OBJECT(button), "selection_received",
+		      GTK_SIGNAL_FUNC (selection_received), NULL);
+
+  gtk_widget_show (button);
+  gtk_widget_show (window);
+  
+  gtk_main ();
+  
+  return 0;
+}
+</verb></tscreen>
+
+<sect1>Fournir la sélection 
+<p>
+
+Fournir la sélection est un peu plus compliqué. On doit enregistrer
+les gestionnaires qui seront appelés lorsque notre sélection est
+demandée. Pour chaque paire sélection/cible que l'on gèrera, on fera
+un appel à&nbsp;:
+
+<tscreen><verb>
+void gtk_selection_add_handler (GtkWidget           *widget, 
+				GdkAtom              selection,
+				GdkAtom              target,
+				GtkSelectionFunction function,
+				GtkRemoveFunction    remove_func,
+				gpointer             data);
+</verb></tscreen>
+
+<em/widget/, <em/selection/ et <em/target/ identifient les requêtes
+que ce gestionnaire gèrera. S'il ne vaut pas NULL, <em/remove_func/
+sera appelé lorsque le gestionnaire de signal est supprimé. Ceci est
+utile, par exemple, pour des langages interprétés qui doivent garder
+une trace du nombre de références à <em/data/.
+
+<p>
+La fonction de rappel <em/function/ doit avoir la signature suivante&nbsp;:
+
+<tscreen><verb>
+typedef void (*GtkSelectionFunction) (GtkWidget *widget, 
+                                      GtkSelectionData *selection_data,
+				      gpointer data);
+
+</verb></tscreen>
+
+Le <em/GtkSelectionData/ est le même qu'au dessus, mais, cette fois,
+nous sommes responsables de l'initialisation de ses champs <em/type/,
+<em/format/, <em/data/, et <em/length/. (Le champ <em/format/ est
+important ici - le serveur X l'utilise pour savoir si la donnée doit
+être échangée par octet ou non. Habituellement, ce sera 8 (un
+caractère), ou 32 (un entier)). Cette initialisation est faite en
+utilisant l'appel&nbsp;:
+
+<tscreen><verb>
+void gtk_selection_data_set (GtkSelectionData *selection_data,
+			     GdkAtom           type,
+			     gint              format,
+			     guchar           *data,
+			     gint              length);
+</verb></tscreen>
+
+Cette fonction s'occupe de faire une copie correcte des données afin
+que l'on n'ait pas à se soucier du reste. (On ne doit pas remplir ces
+champs à la main).
+
+<p>
+Lorsque cela est demandé par l'utilisateur, on réclame la possession
+de la sélection en appelant&nbsp;:
+
+<tscreen><verb>
+gint gtk_selection_owner_set (GtkWidget 	  *widget,
+			      GdkAtom    	   selection,
+			      guint32    	   time);
+</verb></tscreen>
+
+Si une autre application réclame la possession de la sélection, on
+recevra un "selection_clear_event".
+
+Comme exemple de fourniture de sélection, l'exemple suivant ajoute une
+fonctionnalité de sélection à un bouton commutateur. Lorsque ce bouton
+est appuyé, le programme réclame la sélection primaire. La seule cible
+supportée (à part certaines cibles fournies par GTK lui-même, comme
+« TARGETS ») est « STRING ». Lorsque celle-ci est demandée, on
+retourne une représentation de l'heure sous forme de chaîne.
+
+<tscreen><verb>
+#include <gtk/gtk.h>
+#include <time.h>
+
+/* Fonction de rappel appelée lorsque l'utilisateur commute la sélection. */
+
+void selection_toggled (GtkWidget *widget, gint *have_selection)
+{
+  if (GTK_TOGGLE_BUTTON(widget)->active)
+    {
+      *have_selection = gtk_selection_owner_set (widget,
+						 GDK_SELECTION_PRIMARY,
+						 GDK_CURRENT_TIME);
+      /* Si la demande de sélection échoue, on remet le bouton en position sortie. */
+
+      if (!*have_selection)
+	gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON(widget), FALSE);
+    }
+  else
+    {
+      if (*have_selection)
+	{
+	  /* Avant de nettoyer la selection en mettant son propriétaire à NULL, 
+           * on vérifie que nous sommes bien son propriétaire actuel. */
+
+	  if (gdk_selection_owner_get (GDK_SELECTION_PRIMARY) == widget->window)
+	    gtk_selection_owner_set (NULL, GDK_SELECTION_PRIMARY,
+				     GDK_CURRENT_TIME);
+	  *have_selection = FALSE;
+	}
+    }
+}
+
+/* Appelée lorsqu'une autre application demande la sélection. */
+
+gint selection_clear (GtkWidget *widget, GdkEventSelection *event,
+		 gint *have_selection)
+{
+  *have_selection = FALSE;
+  gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON(widget), FALSE);
+
+  return TRUE;
+}
+
+/* Fournit l'heure comme sélection. */
+
+void selection_handle (GtkWidget *widget, 
+		  GtkSelectionData *selection_data,
+		  gpointer data)
+{
+  gchar *timestr;
+  time_t current_time;
+
+  current_time = time (NULL);
+  timestr = asctime (localtime(&amp;current_time)); 
+
+  /* Lorsqu'on retourne une chaîne, elle ne doit pas se terminer par
+   * 0, ce sera fait pour nous. */
+
+  gtk_selection_data_set (selection_data, GDK_SELECTION_TYPE_STRING,
+			  8, timestr, strlen(timestr));
+}
+
+int main (int argc, char *argv[])
+{
+  GtkWidget *window;
+
+  GtkWidget *selection_button;
+
+  static int have_selection = FALSE;
+  
+  gtk_init (&amp;argc, &amp;argv);
+
+  /* Création de la fenêtre principale. */
+
+  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  gtk_window_set_title (GTK_WINDOW (window), "Event Box");
+  gtk_container_border_width (GTK_CONTAINER (window), 10);
+
+  gtk_signal_connect (GTK_OBJECT (window), "destroy",
+		      GTK_SIGNAL_FUNC (gtk_exit), NULL);
+
+  /* Création d'un bouton commutateur pour qu'il agisse comme une sélection. */
+
+  selection_button = gtk_toggle_button_new_with_label ("Demande de sélection");
+  gtk_container_add (GTK_CONTAINER (window), selection_button);
+  gtk_widget_show (selection_button);
+
+  gtk_signal_connect (GTK_OBJECT(selection_button), "toggled",
+		      GTK_SIGNAL_FUNC (selection_toggled), &amp;have_selection);
+  gtk_signal_connect (GTK_OBJECT(selection_button), "selection_clear_event",
+		      GTK_SIGNAL_FUNC (selection_clear), &amp;have_selection);
+
+  gtk_selection_add_handler (selection_button, GDK_SELECTION_PRIMARY,
+			     GDK_SELECTION_TYPE_STRING,
+			     selection_handle, NULL, NULL);
+
+  gtk_widget_show (selection_button);
+  gtk_widget_show (window);
+  
+  gtk_main ();
+  
+  return 0;
+}
+</verb></tscreen>
+
+
+
+<sect>glib<label id="sec_glib">
+<p>
+La <em/glib/ fournit de nombreuses fonctions et définitions utiles,
+prêtes à être utilisées lorsqu'on crée des applications GDK et GTK. Je
+les énumèrerais toutes avec une brève explication. Beaucoup sont des
+répliques des fonctions standards de la <em/libc/, et je ne les
+détaillerais donc pas trop. Ceci doit surtout servir de référence afin
+de savoir ce qui est disponible pour être utilisé.
+
+<sect1>Définitions
+<p>
+Les définitions pour les bornes de la plupart des types standards sont&nbsp;:
+
+<tscreen><verb>
+G_MINFLOAT
+G_MAXFLOAT
+G_MINDOUBLE
+G_MAXDOUBLE
+G_MINSHORT
+G_MAXSHORT
+G_MININT
+G_MAXINT
+G_MINLONG
+G_MAXLONG
+</verb></tscreen>
+
+Voici aussi les redéfinitions de types. Celles qui ne sont pas
+spécifiées sont configurées dynamiquement selon l'architecture. Évitez
+surtout de compter sur la taille d'un pointeur si vous voulez un
+programme portable ! Un pointeur sur un Alpha fait 8 octets, mais il
+en fait 4 sur un Intel.
+
+<tscreen><verb>
+char   gchar;
+short  gshort;
+long   glong;
+int    gint;
+char   gboolean;
+
+unsigned char   guchar;
+unsigned short  gushort;
+unsigned long   gulong;
+unsigned int    guint;
+
+float   gfloat;
+double  gdouble;
+long double gldouble;
+
+void* gpointer;
+
+gint8
+guint8
+gint16
+guint16
+gint32
+guint32
+</verb></tscreen>
+
+<sect1>Listes doublement chaînées
+<p>
+Les fonctions suivantes servent à créer, gérer et détruire des listes
+doublement chaînées. Je suppose que vous savez ce qu'est une liste
+chaînée car leur explication n'entre pas dans le cadre de ce
+document. Bien sûr, il n'y a pas besoin de les connaître pour une
+utilisation générale de GTK, mais c'est bien de savoir comment elles
+fonctionnent.
+
+<tscreen><verb>
+GList* g_list_alloc       (void);
+
+void   g_list_free        (GList     *list);
+
+void   g_list_free_1      (GList     *list);
+
+GList* g_list_append      (GList     *list,
+                           gpointer   data);
+			   
+GList* g_list_prepend     (GList     *list,
+                           gpointer   data);
+			
+GList* g_list_insert      (GList     *list,
+                           gpointer   data,
+			   gint       position);
+
+GList* g_list_remove      (GList     *list,
+                           gpointer   data);
+			   
+GList* g_list_remove_link (GList     *list,
+                           GList     *link);
+
+GList* g_list_reverse     (GList     *list);
+
+GList* g_list_nth         (GList     *list,
+                           gint       n);
+			   
+GList* g_list_find        (GList     *list,
+                           gpointer   data);
+
+GList* g_list_last        (GList     *list);
+
+GList* g_list_first       (GList     *list);
+
+gint   g_list_length      (GList     *list);
+
+void   g_list_foreach     (GList     *list,
+                           GFunc      func,
+			   gpointer   user_data);
+</verb></tscreen>					      
+
+
+<sect1>Listes simplement chaînées
+<p>
+La plupart des fonctions pour les listes simplement chaînées
+ci-dessous sont identiques à celles vues plus haut. Voici une liste
+complète&nbsp;:
+
+<tscreen><verb>
+GSList* g_slist_alloc       (void);
+
+void    g_slist_free        (GSList   *list);
+
+void    g_slist_free_1      (GSList   *list);
+
+GSList* g_slist_append      (GSList   *list,
+                             gpointer  data);
+		
+GSList* g_slist_prepend     (GSList   *list,
+                             gpointer  data);
+			     
+GSList* g_slist_insert      (GSList   *list,
+                             gpointer  data,
+		             gint      position);
+			     
+GSList* g_slist_remove      (GSList   *list,
+                             gpointer  data);
+			     
+GSList* g_slist_remove_link (GSList   *list,
+                             GSList   *link);
+			     
+GSList* g_slist_reverse     (GSList   *list);
+
+GSList* g_slist_nth         (GSList   *list,
+                             gint      n);
+			     
+GSList* g_slist_find        (GSList   *list,
+                             gpointer  data);
+			     
+GSList* g_slist_last        (GSList   *list);
+
+gint    g_slist_length      (GSList   *list);
+
+void    g_slist_foreach     (GSList   *list,
+                             GFunc     func,
+			     gpointer  user_data);
+	
+</verb></tscreen>
+
+<sect1>Gestion de la mémoire
+<p>
+<tscreen><verb>
+gpointer g_malloc      (gulong    size);
+</verb></tscreen>
+
+Remplace <em/malloc()/.  On n'a pas besoin de vérifier la valeur de
+retour car cela est fait pour nous dans cette fonction.
+
+<tscreen><verb>
+gpointer g_malloc0     (gulong    size);
+</verb></tscreen>
+
+Identique à la précédente, mais initialise la mémoire à zéro avant de
+retourner un pointeur vers la zone réservée.
+
+<tscreen><verb>
+gpointer g_realloc     (gpointer  mem,
+                        gulong    size);
+</verb></tscreen>
+
+Réalloue <em/size/ octets de mémoire à partir de <em/mem/. Évidemment,
+la mémoire doit avoir été allouée auparavant.
+
+<tscreen><verb>
+void     g_free        (gpointer  mem);
+</verb></tscreen>
+
+Libère la mémoire. Facile.
+ 
+<tscreen><verb>
+void     g_mem_profile (void);
+</verb></tscreen>
+
+Produit un profil de la mémoire utilisée, mais requiert l'ajout de
+<em/#define MEM_PROFILE/ au début de <em>glib/gmem.c</em>,
+de refaire un <em/make/ et un <em/make install/.
+
+<tscreen><verb>
+void     g_mem_check   (gpointer  mem);
+</verb></tscreen>
+
+Vérifie qu'un emplacement mémoire est valide. Nécessite que l'on
+ajoute <em/#define MEM_CHECK/ au début de <em/gmem.c/ que l'on refasse
+un <em/make/ et un <em/make install/.
+
+<sect1>Timers
+<p>
+Fonctions des timers...
+
+<tscreen><verb>
+GTimer* g_timer_new     (void);
+
+void    g_timer_destroy (GTimer  *timer);
+
+void    g_timer_start   (GTimer  *timer);
+
+void    g_timer_stop    (GTimer  *timer);
+
+void    g_timer_reset   (GTimer  *timer);
+
+gdouble g_timer_elapsed (GTimer  *timer,
+                         gulong  *microseconds);
+</verb></tscreen>			 
+
+<sect1>Gestion des chaînes
+<p>
+Un ensemble complet de fonction de gestion des chaînes. Elles semblent
+toutes très intéressantes et sont sûrement meilleures, à bien des
+égards, que les fonctions C standards, mais elle nécessitent de la
+documentation.
+
+<tscreen><verb>
+GString* g_string_new       (gchar   *init);
+void     g_string_free      (GString *string,
+                             gint     free_segment);
+			     
+GString* g_string_assign    (GString *lval,
+                             gchar   *rval);
+			     
+GString* g_string_truncate  (GString *string,
+                             gint     len);
+			     
+GString* g_string_append    (GString *string,
+                             gchar   *val);
+			    
+GString* g_string_append_c  (GString *string,
+                             gchar    c);
+	
+GString* g_string_prepend   (GString *string,
+                             gchar   *val);
+			     
+GString* g_string_prepend_c (GString *string,
+                             gchar    c);
+	
+void     g_string_sprintf   (GString *string,
+                             gchar   *fmt,
+			     ...);
+	
+void     g_string_sprintfa  (GString *string,
+                             gchar   *fmt,
+			     ...);
+</verb></tscreen>							  
+
+<sect1>Utilitaires et fonctions d'erreurs
+<p>
+<tscreen><verb>
+gchar* g_strdup    (const gchar *str);
+</verb></tscreen>
+
+Remplace la fonction <em/strdup/. Elle copie le contenu de la chaîne
+d'origine dans la mémoire venant d'être allouée et retourne un
+pointeur sur cette zone.
+
+<tscreen><verb>
+gchar* g_strerror  (gint errnum);
+</verb></tscreen>
+
+Je recommande de l'utiliser pour tous les messages d'erreur. Elle est
+beaucoup plus propre et plus portable que <em/perror()/ ou les
+autres. La sortie est habituellement de la forme&nbsp;:
+
+<tscreen><verb>
+nom du programme:fonction qui a échoué:fichier ou autre descripteur:strerror
+</verb></tscreen>
+
+Voici un exemple d'appel utilisé dans le programme « Bonjour tout le monde ! »&nbsp;:
+
+<tscreen><verb>
+g_print("bonjour_monde:open:%s:%s\n", filename, g_strerror(errno));
+</verb></tscreen>
+
+<tscreen><verb>
+void g_error   (gchar *format, ...);
+</verb></tscreen>
+
+Affiche un message d'erreur. Le format est comme <em/printf/, mais il
+ajoute « ** ERROR **: » au début du message et sort du programme. À
+n'utiliser que pour les erreurs fatales.
+
+<tscreen><verb>
+void g_warning (gchar *format, ...);
+</verb></tscreen>
+
+Comme au dessus, mais ajoute « ** WARNING **: », et ne termine pas le
+programme.
+
+<tscreen><verb>
+void g_message (gchar *format, ...);
+</verb></tscreen>
+Affiche  « message: » avant la chaîne passée en paramètre.
+
+<tscreen><verb>
+void g_print   (gchar *format, ...);
+</verb></tscreen>
+
+Remplace <em/printf()/.
+
+Enfin la dernière fonction&nbsp;:
+
+<tscreen><verb>
+gchar* g_strsignal (gint signum);
+</verb></tscreen>
+
+Affiche le nom du signal système Unix correspondant au numéro de
+signal. Utile pour les fonctions génériques de gestion de signaux.
+
+Tout ce qui est ci-dessus est plus ou moins volé à <em/glib.h/. Si
+quelqu'un s'occupe de documenter une fonction, qu'il m'envoit un
+courrier !
+
+
+<sect>Fichiers rc de GTK
+<p>
+GTK a sa propre méthode pour gérer les configurations par défaut des
+applications, en utilisant des fichiers <tt/rc/. Ceux-ci peuvent être
+utilisés pour configurer les couleurs de presque tous les widgets, et
+pour mettre des pixmaps sur le fond de certains widgets.
+
+<sect1>Fonctions pour les fichiers rc
+<p>
+Au démarrage de votre application, ajoutez un appel à&nbsp;:
+<tscreen><verb>
+void gtk_rc_parse (char *filename);
+</verb></tscreen>
+<p>
+en lui passant le nom de votre fichier rc. Ceci forcera GTK à analyser
+ce fichier et à utiliser les configurations de styles pour les types
+de widgets qui y sont définis.
+<p>
+Si vous voulez avoir un ensemble particulier de widgets qui prenne le
+pas sur le style des autres, ou une autre division logique de widgets,
+utilisez un appel à&nbsp;:
+<tscreen><verb>
+void gtk_widget_set_name (GtkWidget *widget,
+                          gchar *name);
+</verb></tscreen>
+<p>
+En lui passant comme premier paramètre le widget que vous avez créé,
+et le nom que vous voulez lui donner comme second paramètre. Ceci vous
+permettra de changer les attributs de ce widget par son nom dans le
+fichier rc.
+<p>
+Si vous utilisez un appel comme celui-ci&nbsp;:
+
+<tscreen><verb>
+button = gtk_button_new_with_label ("Bouton Spécial");
+gtk_widget_set_name (button, "bouton special");
+</verb></tscreen>
+<p>
+Ce bouton s'appelle « bouton special » et peut être accédé par son nom
+dans le fichier rc en tant que « bouton special.GtkButton ».  [<---
+Vérifiez !]
+<p>
+Le fichier rc ci-dessous configure les propriétés de la fenêtre
+principale et fait hériter tous les fils de celle-ci du style décrit
+par « bouton_principal ». Le code utilisé dans l'application
+est&nbsp;:
+
+<tscreen><verb>
+window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+gtk_widget_set_name (window, "fenetre principale");
+</verb></tscreen>
+<p>
+Et le style est défini dans le fichier rc avec&nbsp;:
+
+<tscreen><verb>
+widget "fenetre principale.*GtkButton*" style "bouton_principal"
+</verb></tscreen>
+<p>
+Ce qui configure tous les widgets <em/GtkButton/ de « fenêtre
+principale » avec le style « bouton_principal » défini dans le fichier
+rc.
+<p>
+Ainsi que vous pouvez le voir, il s'agit d'un système puissant et
+flexible. Utilisez votre imagination pour en tirer le meilleur.
+
+<sect1>Format des fichiers rc de GTK
+<p>
+Le format du fichier GTK est illustré dans l'exemple suivant. Il
+s'agit du fichier <em/testgtkrc/ de la distribution GTK mais j'ai
+ajouté quelques commentaires et autres choses. Vous pouvez inclure
+cette explication à votre application pour permettre à l'utilisateur
+de régler finement son application.
+<p>
+Il y a plusieurs directives pour changer les attributs d'un widget.
+<itemize>
+<item>fg - configure la couleur de premier plan d'un widget.
+<item>bg - configure la couleur d'arrière plan d'un widget.
+<item>bg_pixmap - configure l'arrière plan d'un widget avec un pixmap.
+<item>font - configure la fonte à utiliser pour un widget.
+</itemize>
+<p>
+De plus, un widget peut se trouver dans différents états et l'on peut
+configurer des couleurs, pixmaps et fontes différentes pour chacun
+d'eux. Ces états sont&nbsp;:
+<itemize>
+<item>NORMAL - L'état normal d'un widget, sans la souris au dessus de
+lui, non pressé, etc.  
+<item>PRELIGHT - Lorsque la souris se trouve au dessus du widget, les
+couleurs définies pour cet état sont actives.
+<item>ACTIVE - Lorsque le widget est pressé ou cliqué, il devient
+actif et les attributs associés à cet état sont appliqués.
+<item>INSENSITIVE - Quand un widget est configuré pour être
+insensible et qu'il ne peut être activé, il prend ces attributs.
+<item>SELECTED - Lorsqu'un objet est choisi, il prend ces attributs.
+</itemize>
+<p>
+Lorsqu'on utilise les mots-clés « <em/fg/ » et « <em/bg/ » pour
+configurer les couleurs des widgets, le format est&nbsp;:
+
+<tscreen><verb> fg[<STATE>] = { Red, Green, Blue } </verb></tscreen>
+<p>
+Où STATE est l'un des états vus plus haut (PRELIGHT, ACTIVE etc), et
+où <em/Red/, <em/Green/ et <em/Blue/ sont des valeurs comprises entre
+0 et 1.0. { 1.0, 1.0, 1.0 } représente la couleur blanche.  Ces
+valeurs doivent être de type réel ou elles seront considérées comme
+valant 0, ainsi un simple « 1 » ne marchera pas, il faut mettre « 1.0
+». Un « 0 » simple convient car ce n'est pas un problème s'il n'est
+pas reconnu puisque toutes les valeurs non reconnues sont mises à 0.
+<p>
+<em/bg_pixmap/ est très similaire, sauf que les couleurs sont
+remplacées par un nom de fichier.
+
+<em/pixmap_path/ est une liste de chemins séparés par des « : ». Ces
+chemins seront parcourus pour chaque pixmap que l'on spécifie.
+
+<p>
+La directive <em/font/ est simplement&nbsp;:
+<tscreen><verb>
+font = "<font name>"
+</verb></tscreen>
+<p>
+Où la seule partie difficile est d'arriver à comprendre la chaîne
+contenant le nom de la fonte. L'utilisation de <em/xfontsel/ ou d'un
+autre utilitaire semblable peut aider.
+<p>
+« <em/widget_class/ » configure le style d'une classe de widgets. Ces
+classes sont listées dans la section sur la hiérarchie des widgets.
+<p>
+La directive « <em/widget/ » configure un ensemble spécifique de
+widgets selon un style donné, annulant tout style de configuration
+pour la classe de widget donnée. Ces widgets sont enregistrés dans
+l'application en utilisant l'appel <em/gtk_widget_set_name()/. Ceci
+vous permet de spécifier les attributs d'un widget, widget par widget,
+au lieu de configurer les attributs d'une classe entière de
+widgets. Je vous demande instamment de documenter tous ces widgets
+spéciaux pour que les utilisateurs puisse les adapter à leurs besoins.
+<p>
+Lorsque le mot-clé « <em/parent/ » est utilisé comme attribut, le
+widget prendra les attributs de son parent dans l'application.
+<p>
+Lorsqu'on définit un style, on peut assigner les attributs d'un style
+déjà défini à ce nouveau style.
+
+<tscreen><verb>
+style "bouton_principal" = "button"
+{
+  font = "-adobe-helvetica-medium-r-normal--*-100-*-*-*-*-*-*"
+  bg[PRELIGHT] = { 0.75, 0, 0 }
+}
+</verb></tscreen>
+<p>
+Cet exemple prend le style "button" et crée un nouveau style
+"bouton_principal"en changeant simplement la fonte et la couleur de
+fond pour l'état PRELIGHT.
+<p>
+Bien sûr, un bon nombre de ces attributs ne s'applique pas à tous les
+widgets. C'est une question de bon sens. Tout ce qui peut s'appliquer
+s'applique.
+
+<sect1>Exemple de fichier rc
+<p>
+
+<tscreen><verb>
+# pixmap_path "<dir 1>:<dir 2>:<dir 3>:..."
+#
+pixmap_path "/usr/include/X11R6/pixmaps:/home/imain/pixmaps"
+#
+# style <name> [= <name>]
+# {
+#   <option>
+# }
+#
+# widget <widget_set> style <style_name>
+# widget_class <widget_class_set> style <style_name>
+
+
+# Voici une liste des états possibles. Remarquez que certains ne s'appliquent
+# pas à certains widgets.
+#
+# NORMAL - L'état normal d'un widget, sans la souris au dessus de lui, 
+# non pressé, etc.
+#
+# PRELIGHT - Lorsque la souris se trouve au dessus du widget, les couleurs 
+# définies pour cet état sont actives.
+#
+# ACTIVE - Lorsque le widget est pressé ou cliqué, il devient actif et les 
+# attributs associés à cet état sont appliqués.
+#
+# INSENSITIVE - Quand un widget est configuré pour être insensible, et qu'il 
+# ne peut être activé, il prend ces attributs.
+#
+# SELECTED - Lorsqu'un objet est choisi, il prend ces attributs.
+#
+# Avec ces états, on peut configurer les attributs des widgets dans chacun
+# de ces états en utilisant les directives suivantes.
+#
+# fg - configure la couleur de premier plan d'un widget.
+# bg - configure la couleur d'arrière plan d'un widget.
+# bg_pixmap - configure l'arrière plan d'un widget avec un pixmap.
+# font - configure la fonte à utiliser pour un widget.
+
+# Configuration d'un style appelé "button". Le nom n'est pas important
+# car il est assigné aux widgets réels à la fin du fichier.
+
+style "window"
+{
+  #Configure l'espace autour de la fenêtre avec le pixmap spécifié.
+  #bg_pixmap[<STATE>] = "<pixmap filename>"
+  bg_pixmap[NORMAL] = "warning.xpm"
+}
+
+style "scale"
+{
+  #Configure la couleur de premier plan (celle de la fonte) à rouge
+  #lorsqu'on est dans l'état "NORMAL".
+  
+  fg[NORMAL] = { 1.0, 0, 0 }
+  
+  #Configure le pixmap d'arrière plan de ce widget à celui de son parent.
+  bg_pixmap[NORMAL] = "<parent>"
+}
+
+style "button"
+{
+  # Voici tous les états possibles pour un bouton. Le seul qui ne peut
+  # s'appliquer est l'état SELECTED.
+  
+  fg[PRELIGHT] = { 0, 1.0, 1.0 }
+  bg[PRELIGHT] = { 0, 0, 1.0 }
+  bg[ACTIVE] = { 1.0, 0, 0 }
+  fg[ACTIVE] = { 0, 1.0, 0 }
+  bg[NORMAL] = { 1.0, 1.0, 0 }
+  fg[NORMAL] = { .99, 0, .99 }
+  bg[INSENSITIVE] = { 1.0, 1.0, 1.0 }
+  fg[INSENSITIVE] = { 1.0, 0, 1.0 }
+}
+
+# Dans cet exemple, on hérite des attributs du style "button" puis on 
+# écrase la fonte et la couleur de fond pour créer un nouveau style
+# "main_button".
+
+style "main_button" = "button"
+{
+  font = "-adobe-helvetica-medium-r-normal--*-100-*-*-*-*-*-*"
+  bg[PRELIGHT] = { 0.75, 0, 0 }
+}
+
+style "toggle_button" = "button"
+{
+  fg[NORMAL] = { 1.0, 0, 0 }
+  fg[ACTIVE] = { 1.0, 0, 0 }
+  
+  # Configure le pixmap de fond du toggle_button à celui de son widget
+  # parent (comme défini dans l'application).
+  bg_pixmap[NORMAL] = "<parent>"
+}
+
+style "text"
+{
+  bg_pixmap[NORMAL] = "marble.xpm"
+  fg[NORMAL] = { 1.0, 1.0, 1.0 }
+}
+
+style "ruler"
+{
+  font = "-adobe-helvetica-medium-r-normal--*-80-*-*-*-*-*-*"
+}
+
+# pixmap_path "~/.pixmaps"
+
+# Configuration des types de widget pour utiliser les styles définis
+# plus haut.
+# Les types de widget sont listés dans la hiérarchie des classes, mais
+# peut probablement être listée dans ce document pour que l'utilisateur
+# puisse s'y référer.
+
+widget_class "GtkWindow" style "window"
+widget_class "GtkDialog" style "window"
+widget_class "GtkFileSelection" style "window"
+widget_class "*Gtk*Scale" style "scale"
+widget_class "*GtkCheckButton*" style "toggle_button"
+widget_class "*GtkRadioButton*" style "toggle_button"
+widget_class "*GtkButton*" style "button"
+widget_class "*Ruler" style "ruler"
+widget_class "*GtkText" style "text"
+
+# Configure tous les boutons fils de la "main window" avec le style
+# main_button. Ceci doit être documenté pour en tirer profit.
+widget "main window.*GtkButton*" style "main_button"
+</verb></tscreen>
+
+<sect>Écriture de vos propres widgets 
+<p>
+<sect1>Vue d'ensemble
+<p>
+Bien que la distribution GTK fournisse de nombreux types de widgets
+qui devraient couvrir la plupart des besoins de base, il peut arriver
+un moment où vous aurez besoin de créer votre propre type de
+widget. Comme GTK utilise l'héritage de widget de façon intensive et
+qu'il y a déjà un widget ressemblant à celui que vous voulez, il est
+souvent possible de créer un nouveau type de widget en seulement
+quelques lignes de code. Mais, avant de travailler sur un nouveau
+widget, il faut vérifier d'abord que quelqu'un ne l'a pas déjà
+écrit. Ceci éviter la duplication des efforts et maintient au minimum
+le nombre de widgets, ce qui permet de garder la cohérence du code et
+de l'interface des différentes applications. Un effet de bord est que,
+lorsque l'on a créé un nouveau widget, il faut l'annoncer afin que les
+autres puissent en bénéficier. Le meilleur endroit pour faire cela
+est, sans doute, la <tt>gtk-list</tt>.
+
+<sect1>Anatomie d'un widget
+
+<p>
+Afin de créer un nouveau widget, il importe de comprendre comment
+fonctionnent les objets GTK. Cette section ne se veut être qu'un
+rapide survol. Consultez la documentation de référence pour plus de
+détails.
+
+<p>
+Les widgets sont implantés selon une méthode orientée
+objet. Cependant, ils sont écrits en C standard. Ceci améliore
+beaucoup la portabilité et la stabilité, par contre cela signifie que
+celui qui écrit des widgets doit faire attention à certains détails
+d'implantation. Les informations communes à toutes les instances d'une
+classe de widget (tous les widgets boutons, par exemple) sont stockées
+dans la <em/structure de la classe/.  Il n'y en a qu'une copie dans
+laquelle sont stockées les informations sur les signaux de la
+classe (fonctionnement identique aux fonctions virtuelles en C). Pour
+permettre l'héritage, le premier champ de la structure de classe doit
+être une copie de la structure de classe du père. La déclaration de la
+structure de classe de <em/GtkButton/ ressemble à ceci&nbsp;:
+
+<tscreen><verb>
+struct _GtkButtonClass
+{
+  GtkContainerClass parent_class;
+
+  void (* pressed)  (GtkButton *button);
+  void (* released) (GtkButton *button);
+  void (* clicked)  (GtkButton *button);
+  void (* enter)    (GtkButton *button);
+  void (* leave)    (GtkButton *button);
+};
+</verb></tscreen>
+
+<p>
+Lorsqu'un bouton est traité comme un container (par exemple, lorsqu'il
+change de taille), sa structure de classe peut être convertie en
+<em/GtkContainerClass/ et les champs adéquats utilisés pour gérer les
+signaux.
+
+<p>
+Il y a aussi une structure pour chaque widget créé sur une base
+d'instance. Cette structure a des champs pour stocker les informations
+qui sont différentes pour chaque instance du widget. Nous l'appelerons
+<em/structure d'objet/. Pour la classe <em/Button/, elle ressemble
+à&nbsp;:
+
+<tscreen><verb>
+struct _GtkButton
+{
+  GtkContainer container;
+
+  GtkWidget *child;
+
+  guint in_button : 1;
+  guint button_down : 1;
+};
+</verb></tscreen>
+
+<p>
+Notez que, comme pour la structure de classe, le premier champ est la
+structure d'objet de la classe parente, cette structure peut donc être
+convertie dans la structure d'objet de la classe parente si besoin
+est.
+
+<sect1> Création d'un widget composé
+
+<sect2> Introduction
+
+<p>
+Un type de widget qui peut être intéressant à créer est un widget qui
+est simplement un agrégat d'autres widgets GTK. Ce type de widget ne
+fait rien qui ne pourrait être fait sans créer de nouveaux widgets,
+mais offre une méthode pratique pour empaqueter les éléments d'une
+interface utilisateur afin de la réutiliser facilement. Les widgets
+<em/FileSelection/ et <em/ColorSelection/ de la distribution standard
+sont des exemples de ce type de widget.
+
+<p>
+L'exemple de widget que nous allons créer dans cette section créera un
+widget <em/Tictactoe/, un tableau de 3x3 boutons commutateurs qui
+déclenche un signal lorsque tous les boutons d'une ligne, d'une
+colonne, ou d'une diagonale sont pressés.
+
+<sect2> Choix d'une classe parent
+
+<p>
+La classe parent d'un widget composé est, typiquement, la classe
+container contenant tous les éléments du widget composé. Par exemple,
+la classe parent du widget <em/FileSelection/ est la classe
+<em/Dialog/. Comme nos boutons seront mis sous la forme d'un tableau,
+il semble naturel d'utiliser la classe <em/GtkTable/ comme
+parent. Malheureusement, cela ne peut marcher. La création d'un widget
+est divisée en deux fonctions -- <em/WIDGETNAME_new()/ que
+l'utilisateur appelle, et <em/WIDGETNAME_init()/ qui réalise le
+travail d'initialisation du widget indépendamment des paramètre passés
+à la fonction <tt/_new()/. Les widgets fils n'appellent que la
+fonction <em/_init/ de leur widget parent. Mais cette division du
+travail ne fonctionne pas bien avec les tableaux qui, lorsqu'ils sont
+créés, ont besoin de connaître leue nombre de lignes et de
+colonnes. Sauf à dupliquer la plupart des fonctionnalités de
+<em/gtk_table_new()/ dans notre widget <em/Tictactoe/, nous ferions
+mieux d'éviter de le dériver de <em/GtkTable/. Pour cette raison, nous
+la dériverons plutôt de <em/GtkVBox/ et nous placerons notre table
+dans la VBox.
+
+<sect2> The header file
+
+<p>
+Chaque classe de widget possède un fichier en-tête qui déclare les
+structures d'objet et de classe pour ce widget, en plus de fonctions
+publiques. Quelques caractéristiques méritent d'être indiquées. Afin
+d'éviter des définitions multiples, on enveloppe le fichier en-tête
+avec&nbsp:
+
+<tscreen><verb>
+#ifndef __TICTACTOE_H__
+#define __TICTACTOE_H__
+.
+.
+.
+#endif /* __TICTACTOE_H__ */
+</verb></tscreen>
+
+Et, pour faire plaisir aux programmes C++ qui inclueront ce fichier, on l'enveloppe aussi dans&nbsp;:
+
+<tscreen><verb>
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+.
+.
+.
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+</verb></tscreen>
+
+En plus des fonctions et structures, nous déclarons trois macros
+standard, <tt/TICTACTOE(obj)/, <tt/TICTACTOE_CLASS(class)/, et
+<tt/IS_TICTACTOE(obj)/, qui, respectivement, convertissent un pointeur
+en un pointeur vers une structure d'objet ou de classe, et vérifient
+si un objet est un widget Tictactoe.
+
+<p>
+Voici le fichier en-tête complet&nbsp;:
+
+<tscreen><verb>
+
+#ifndef __TICTACTOE_H__
+#define __TICTACTOE_H__
+
+#include <gdk/gdk.h>
+#include <gtk/gtkvbox.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#define TICTACTOE(obj)          GTK_CHECK_CAST (obj, tictactoe_get_type (), Tictactoe)
+#define TICTACTOE_CLASS(klass)  GTK_CHECK_CLASS_CAST (klass, tictactoe_get_type (), TictactoeClass)
+#define IS_TICTACTOE(obj)       GTK_CHECK_TYPE (obj, tictactoe_get_type ())
+
+
+typedef struct _Tictactoe       Tictactoe;
+typedef struct _TictactoeClass  TictactoeClass;
+
+struct _Tictactoe
+{
+  GtkVBox vbox;
+  
+  GtkWidget *buttons[3][3];
+};
+
+struct _TictactoeClass
+{
+  GtkVBoxClass parent_class;
+
+  void (* tictactoe) (Tictactoe *ttt);
+};
+
+guint          tictactoe_get_type        (void);
+GtkWidget*     tictactoe_new             (void);
+void	       tictactoe_clear           (Tictactoe *ttt);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* __TICTACTOE_H__ */
+
+</verb></tscreen>
+
+<sect2>La fonction  <tt/_get_type()/
+
+<p>
+Continuons maintenant avec l'implantation de notre widget. La fonction
+centrale pour chaque widget est <em/WIDGETNAME_get_type()/. Cette
+fonction, lorsqu'elle est appelée pour la première fois, informe le
+GTK de la classe et récupère un ID permettant d'identifier celle-ci de
+façon unique. Lors des appels suivants, elle ne fait que retourner cet
+ID.
+
+<tscreen><verb>
+guint
+tictactoe_get_type ()
+{
+  static guint ttt_type = 0;
+
+  if (!ttt_type)
+    {
+      GtkTypeInfo ttt_info =
+      {
+	"Tictactoe",
+	sizeof (Tictactoe),
+	sizeof (TictactoeClass),
+	(GtkClassInitFunc) tictactoe_class_init,
+	(GtkObjectInitFunc) tictactoe_init,
+	(GtkArgFunc) NULL,
+      };
+
+      ttt_type = gtk_type_unique (gtk_vbox_get_type (), &amp;ttt_info);
+    }
+
+  return ttt_type;
+}
+</verb></tscreen>
+
+<p>
+La structure <em/GtkTypeInfo/ est définie de la façon suivante&nbsp;:
+
+<tscreen><verb>
+struct _GtkTypeInfo
+{
+  gchar *type_name;
+  guint object_size;
+  guint class_size;
+  GtkClassInitFunc class_init_func;
+  GtkObjectInitFunc object_init_func;
+  GtkArgFunc arg_func;
+};
+</verb></tscreen>
+
+<p>
+Les champs de cette structure s'expliquent d'eux-mêmes. Nous
+ignorerons le champ <em/arg_func/ ici&nbsp;: il a un rôle important
+permettant aux options des widgets d'être correctement initialisées à
+partir des langages interprétés, mais cette fonctionnalité est encore
+très peu implantée. Lorsque GTK dispose d'une copie correctement
+remplie de cette structure, il sait comment créer des objets d'un type
+particulier de widget.
+
+<sect2>La fonction <em/_class_init()/
+
+<p>
+La fonction <em/WIDGETNAME_class_init()/ initialise les champs de la
+structure de classe du widget et configure tous les signaux de cette
+classe. Pour notre widget Tictactoe, cet appel est&nbsp;:
+
+<tscreen><verb>
+
+enum {
+  TICTACTOE_SIGNAL,
+  LAST_SIGNAL
+};
+
+static gint tictactoe_signals[LAST_SIGNAL] = { 0 };
+
+static void
+tictactoe_class_init (TictactoeClass *class)
+{
+  GtkObjectClass *object_class;
+
+  object_class = (GtkObjectClass*) class;
+  
+  tictactoe_signals[TICTACTOE_SIGNAL] = gtk_signal_new ("tictactoe",
+					 GTK_RUN_FIRST,
+					 object_class->type,
+					 GTK_SIGNAL_OFFSET (TictactoeClass, tictactoe),
+					 gtk_signal_default_marshaller, GTK_ARG_NONE, 0);
+
+
+  gtk_object_class_add_signals (object_class, tictactoe_signals, LAST_SIGNAL);
+
+  class->tictactoe = NULL;
+}
+</verb></tscreen>
+
+<p>
+Notre widget n'a qu'un signal&nbsp;: "tictactoe", invoqué lorsqu'une
+ligne, une colonne ou une diagonale est complètement remplie. Tous les
+widgets composés n'ont pas besoin de signaux. Si vous lisez ceci pour
+la première fois, vous pouvez passer directement à la section suivante
+car les choses vont se compliquer un peu
+
+La fonction :
+
+<tscreen><verb>
+gint   gtk_signal_new                     (gchar               *name,
+					   GtkSignalRunType     run_type,
+					   gint                 object_type,
+					   gint                 function_offset,
+					   GtkSignalMarshaller  marshaller,
+					   GtkArgType           return_val,
+					   gint                 nparams,
+					   ...);
+</verb></tscreen>
+
+crée un nouveau signal. Les paramètres sont :
+
+<itemize>
+<item> <em/name/ : Le nom du signal signal.
+<item> <em/run_type/ : Indique si le gestionnaire par défaut doit être
+lancé avant ou après le gestionnaire de l'utilisateur. Le plus
+souvent, ce sera <tt/GTK_RUN_FIRST/, ou <tt/GTK_RUN_LAST/, bien qu'il
+y ait d'autres possibilités.
+
+<item> <em/object_type/ : L'ID de l'objet auquel s'applique ce signal
+(il s'appliquera aussi au descendants de l'objet).
+
+<item> <em/function_offset/ : L'offset d'un pointeur vers le
+gestionnaire par défaut dans la structure de classe.
+
+<item> <em/marshaller/ : Fonction utilisée pour invoquer le
+gestionnaire de signal. Pour les gestionnaires de signaux n'ayant pas
+d'autres paramètres que l'objet émetteur et les données utilisateur,
+on peut utiliser la fonction prédéfinie
+<em/gtk_signal_default_marshaller()/.
+
+<item> <em/return_val/ : Type de la valeur retournée.
+
+<item> <em/nparams/ : Nombre de paramètres du gestionnaire de signal
+(autres que les deux par défaut mentionnés plus haut).
+
+<item> <em/.../ : Types des paramètres.
+</itemize>
+
+Lorsque l'on spécifie les types, on utilise l'énumération
+<em/GtkArgType/&nbsp;:
+
+<tscreen><verb>
+typedef enum
+{
+  GTK_ARG_INVALID,
+  GTK_ARG_NONE,
+  GTK_ARG_CHAR,
+  GTK_ARG_SHORT,
+  GTK_ARG_INT,
+  GTK_ARG_LONG,
+  GTK_ARG_POINTER,
+  GTK_ARG_OBJECT,
+  GTK_ARG_FUNCTION,
+  GTK_ARG_SIGNAL
+} GtkArgType;
+</verb></tscreen>
+
+<p>
+<em/gtk_signal_new()/ retourne un identificateur entier pour le
+signal, que l'on stocke dans le tableau <em/tictactoe_signals/, indicé
+par une énumération (conventionnellement, les éléments de
+l'énumération sont le nom du signal, en majuscules, mais, ici, il y
+aurait un conflit avec la macro <tt/TICTACTOE()/, nous l'appellerons
+donc <tt/TICTACTOE_SIGNAL/ à la place.
+
+Après avoir créé nos signaux, nous devons demander à GTK d'associer
+ceux-ci à la classe Tictactoe. Ceci est fait en appelant
+<em/gtk_object_class_add_signals()/. Puis nous configurons le pointeur
+qui pointe sur le gestionnaire par défaut du signal "tictactoe" à
+NULL, pour indiquer qu'il n'y a pas d'action par défaut.
+
+<sect2>La fonction <em/_init()/
+<p>
+
+Chaque classe de widget a aussi besoin d'une fonction pour initialiser
+la structure d'objet. Habituellement, cette fonction a le rôle, plutôt
+limité, d'initialiser les champs de la structure avec des valeurs par
+défaut. Cependant, pour les widgets composés, cette fonction crée
+aussi les widgets composants.
+
+<tscreen><verb>
+
+static void
+tictactoe_init (Tictactoe *ttt)
+{
+  GtkWidget *table;
+  gint i,j;
+  
+  table = gtk_table_new (3, 3, TRUE);
+  gtk_container_add (GTK_CONTAINER(ttt), table);
+  gtk_widget_show (table);
+
+  for (i=0;i<3; i++)
+    for (j=0;j<3; j++)
+      {
+	ttt->buttons[i][j] = gtk_toggle_button_new ();
+	gtk_table_attach_defaults (GTK_TABLE(table), ttt->buttons[i][j], 
+				   i, i+1, j, j+1);
+	gtk_signal_connect (GTK_OBJECT (ttt->buttons[i][j]), "toggled",
+			    GTK_SIGNAL_FUNC (tictactoe_toggle), ttt);
+	gtk_widget_set_usize (ttt->buttons[i][j], 20, 20);
+	gtk_widget_show (ttt->buttons[i][j]);
+      }
+}
+</verb></tscreen>
+
+<sect2> Et le reste...
+<p>
+
+Il reste une fonction que chaque widget (sauf pour les types widget de
+base, comme <em/GtkBin/, qui ne peuvent être instanciés) à besoin
+d'avoir -- celle que l'utilisateur appelle pour créer un objet de ce
+type. Elle est conventionnellement appelée <em/WIDGETNAME_new()/. Pour
+certains widgets, par pour ceux de Tictactoe, cette fonction prend des
+paramètres et réalise certaines initialisations dépendantes des
+paramètres. Les deux autres fonctions sont spécifiques au widget
+Tictactoe.
+
+<p>
+<em/tictactoe_clear()/ est une fonction publique qui remet tous les
+boutons du widget en position relâchée. Notez l'utilisation de
+<em/gtk_signal_handler_block_by_data()/ pour empêcher notre
+gestionnaire de signaux des boutons commutateurs d'être déclenché sans
+besoin.
+
+<p>
+<em/tictactoe_toggle()/ est le gestionnaire de signal invoqué
+lorsqu'on clique sur un bouton. Il vérifie s'il y a des combinaisons
+gagnantes concernant le bouton qui vient d'être commuté et, si c'est
+le cas, émet le signal "tictactoe".
+
+<tscreen><verb>  
+GtkWidget*
+tictactoe_new ()
+{
+  return GTK_WIDGET ( gtk_type_new (tictactoe_get_type ()));
+}
+
+void	       
+tictactoe_clear (Tictactoe *ttt)
+{
+  int i,j;
+
+  for (i=0;i<3;i++)
+    for (j=0;j<3;j++)
+      {
+	gtk_signal_handler_block_by_data (GTK_OBJECT(ttt->buttons[i][j]), ttt);
+	gtk_toggle_button_set_state (GTK_TOGGLE_BUTTON (ttt->buttons[i][j]),
+				     FALSE);
+	gtk_signal_handler_unblock_by_data (GTK_OBJECT(ttt->buttons[i][j]), ttt);
+      }
+}
+
+static void
+tictactoe_toggle (GtkWidget *widget, Tictactoe *ttt)
+{
+  int i,k;
+
+  static int rwins[8][3] = { { 0, 0, 0 }, { 1, 1, 1 }, { 2, 2, 2 },
+			     { 0, 1, 2 }, { 0, 1, 2 }, { 0, 1, 2 },
+			     { 0, 1, 2 }, { 0, 1, 2 } };
+  static int cwins[8][3] = { { 0, 1, 2 }, { 0, 1, 2 }, { 0, 1, 2 },
+			     { 0, 0, 0 }, { 1, 1, 1 }, { 2, 2, 2 },
+			     { 0, 1, 2 }, { 2, 1, 0 } };
+
+  int success, found;
+
+  for (k=0; k<8; k++)
+    {
+      success = TRUE;
+      found = FALSE;
+
+      for (i=0;i<3;i++)
+	{
+	  success = success &amp;&amp; 
+	    GTK_TOGGLE_BUTTON(ttt->buttons[rwins[k][i]][cwins[k][i]])->active;
+	  found = found ||
+	    ttt->buttons[rwins[k][i]][cwins[k][i]] == widget;
+	}
+      
+      if (success &amp;&amp; found)
+	{
+	  gtk_signal_emit (GTK_OBJECT (ttt), 
+			   tictactoe_signals[TICTACTOE_SIGNAL]);
+	  break;
+	}
+    }
+}
+</verb></tscreen>
+
+<p>
+
+Enfin, un exemple de programme utilisant notre widget Tictactoe&nbsp;
+
+<tscreen><verb>
+#include <gtk/gtk.h>
+#include "tictactoe.h"
+
+/* Invoqué lorsqu'une ligne, une colonne ou une diagonale est complète */
+
+void win (GtkWidget *widget, gpointer data)
+{
+  g_print ("Ouais !\n");
+  tictactoe_clear (TICTACTOE (widget));
+}
+
+int main (int argc, char *argv[])
+{
+  GtkWidget *window;
+  GtkWidget *ttt;
+  
+  gtk_init (&amp;argc, &amp;argv);
+
+  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  
+  gtk_window_set_title (GTK_WINDOW (window), "Aspect Frame");
+  
+  gtk_signal_connect (GTK_OBJECT (window), "destroy",
+		      GTK_SIGNAL_FUNC (gtk_exit), NULL);
+  
+  gtk_container_border_width (GTK_CONTAINER (window), 10);
+
+  /* Création d'un widget Tictactoe */
+  ttt = tictactoe_new ();
+  gtk_container_add (GTK_CONTAINER (window), ttt);
+  gtk_widget_show (ttt);
+
+  /* On lui attache le signal "tictactoe" */
+  gtk_signal_connect (GTK_OBJECT (ttt), "tictactoe",
+		      GTK_SIGNAL_FUNC (win), NULL);
+
+  gtk_widget_show (window);
+  
+  gtk_main ();
+  
+  return 0;
+}
+
+</verb></tscreen>
+
+<sect1> Création d'un widget à partir de zéro
+
+<sect2> Introduction
+
+<p>
+
+Dans cette section, nous en apprendrons plus sur la façon dont les
+widgets s'affichent eux-mêmes à l'écran et comment ils interagissent
+avec les événements. Comme exemple, nous créerons un widget d'appel
+télephonique interactif avec un pointeur que l'utilisateur pourra
+déplacer pour initialiser la valeur.
+
+<sect2>Afficher un widget à l'écran
+<p>
+Il y a plusieurs étapes mises en jeu lors de l'affichage. Lorsque le widget est
+créé par l'appel <em/WIDGETNAME_new()/, plusieurs autres fonctions
+supplémentaires sont requises.
+
+<itemize>
+<item> <em/WIDGETNAME_realize()/ s'occupe de créer une fenêtre X pour le
+widget, s'il en a une.
+<item> <em/WIDGETNAME_map()/ est invoquée après l'appel de
+<em/gtk_widget_show()/. Elle s'assure que le widget est bien tracé à l'écran
+(<em/mappé/). Dans le cas d'une classe container, elle doit aussi appeler des
+fonctions <em/map()/> pour chaque widget fils.
+<item> <em/WIDGETNAME_draw()/ est invoquée lorsque <em/gtk_widget_draw()/ est
+appelé pour le widget ou l'un de ces ancêtres. Elle réalise les véritables
+appels aux fonctions de dessin pour tracer le widget à l'écran. Pour les
+widgets containers, cette fonction doit appeler <em/gtk_widget_draw()/ pour ses
+widgets fils.
+<item> <em/WIDGETNAME_expose()/ est un gestionnaire pour les événements
+d'exposition du widget. Il réalise les appels nécessaires aux fonctions de
+dessin pour tracer la partie exposée à l'écran. Pour les widgets containers,
+cette fonction doit générer les événements d'exposition pour ses widgets
+enfants n'ayant pas leurs propres fenêtres (s'ils ont leurs propres fenêtres, X
+génèrera les événements d'exposition nécessaires).
+</itemize>
+
+<p>
+Vous avez pu noter que les deux dernières fonctions sont assez similaires --
+chacune se charge de tracer le widget à l'écran. En fait, de nombreux types de
+widgets ne se préoccupent pas vraiment de la différence entre les deux. La
+fonction <em/draw()/ par défaut de la classe widget génère simplement un
+événement d'exposition synthétique pour la zone à redessiner. Cependant,
+certains types de widgets peuvent économiser du travail en faisant la
+différence entre les deux fonctions. Par exemple, si un widget a plusieurs
+fenêtres X et puisque les événements d'exposition identifient la fenêtre
+exposée, il peut redessiner seulement la fenêtre concernée, ce qui n'est pas
+possible avec des appels à <em/draw()/.
+
+<p>
+Les widgets container, même s'ils ne se soucient pas eux-mêmes de la
+différence, ne peuvent pas utiliser simplement la fonction <em/draw()/ car
+leurs widgets enfants tiennent compte de cette différence. Cependant, ce serait
+du gaspillage de dupliquer le code de tracé pour les deux
+fonctions. Conventionnellement, de tels widgets possèdent une fonction nommée
+<em/WIDGETNAME_paint()/ qui réalise le véritable travail de tracé du widget et
+qui est appelée par les fonctions <tt/draw()/ et <tt/expose()/.
+
+<p>
+Dans notre exemple, comme le widget d'appel n'est pas un widget container et
+n'a qu'une fenêtre, nous pouvons utiliser l'approche la plus simple&nbsp;:
+utiliser la fonction <em/draw()/ par défaut et n'implanter que la fonction
+<em/expose()/.
+
+<sect2>Origines du widget Dial
+
+<p>
+Exactement comme les animaux terrestres ne sont que des variantes des premiers
+amphibiens qui rampèrent hors de la boue, les widgets GTK sont des variantes
+d'autres widgets, déjà écrits. Ainsi, bien que cette section s'appelle « créer
+un widget à partir de zéro », le widget Dial commence réellement avec le code
+source du widget Range. Celui-ci a été pris comme point de départ car ce serait
+bien que notre Dial ait la même interface que les widgets Scale qui ne sont que
+des descendants spécialisés du widget Range. Par conséquent, bien que le code
+source soit présenté ci-dessous sous une forme achevée, cela n'implique pas
+qu'il a été écrit <em/deus ex machina/. De plus, si vous ne savez pas comment
+fonctionnent les widgets Scale du point de vue du programmeur de l'application,
+il est préférable de les étudier avant de continuer.
+
+<sect2>Les bases
+
+<p>
+Un petite partie de notre widget devrait ressembler au widget Tictactoe. Nous
+avons d'abord le fichier en-tête&nbsp;:
+
+<tscreen><verb>
+/* GTK - The GIMP Toolkit
+ * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the Free
+ * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef __GTK_DIAL_H__
+#define __GTK_DIAL_H__
+
+#include <gdk/gdk.h>
+#include <gtk/gtkadjustment.h>
+#include <gtk/gtkwidget.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+#define GTK_DIAL(obj)          GTK_CHECK_CAST (obj, gtk_dial_get_type (), GtkDial)
+#define GTK_DIAL_CLASS(klass)  GTK_CHECK_CLASS_CAST (klass, gtk_dial_get_type (), GtkDialClass)
+#define GTK_IS_DIAL(obj)       GTK_CHECK_TYPE (obj, gtk_dial_get_type ())
+
+
+typedef struct _GtkDial        GtkDial;
+typedef struct _GtkDialClass   GtkDialClass;
+
+struct _GtkDial
+{
+  GtkWidget widget;
+
+  /* politique de mise à jour  
+     (GTK_UPDATE_[CONTINUOUS/DELAYED/DISCONTINUOUS]) */
+
+  guint policy : 2;
+
+  /* Le bouton qui est pressé, 0 si aucun */
+  guint8 button;
+
+  /* Dimensions des composants de dial */
+  gint radius;
+  gint pointer_width;
+
+  /* ID du timer de mise à jour, 0 si aucun */
+  guint32 timer;
+
+  /* Angle courant*/
+  gfloat angle;
+
+  /* Anciennes valeurs d'ajustement stockées. On sait donc quand quelque
+     chose change */
+  gfloat old_value;
+  gfloat old_lower;
+  gfloat old_upper;
+
+  /* L'objet ajustment qui stocke les données de cet appel */
+  GtkAdjustment *adjustment;
+};
+
+struct _GtkDialClass
+{
+  GtkWidgetClass parent_class;
+};
+
+
+GtkWidget*     gtk_dial_new                    (GtkAdjustment *adjustment);
+guint          gtk_dial_get_type               (void);
+GtkAdjustment* gtk_dial_get_adjustment         (GtkDial      *dial);
+void           gtk_dial_set_update_policy      (GtkDial      *dial,
+						GtkUpdateType  policy);
+
+void           gtk_dial_set_adjustment         (GtkDial      *dial,
+						GtkAdjustment *adjustment);
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+#endif /* __GTK_DIAL_H__ */
+
+</verb></tscreen>
+
+Comme il y a plus de choses à faire avec ce widget par rapport à l'autre, nous
+avons plus de champs dans la structure de données, mais à part ça, les choses
+sont plutôt similaires.
+
+<p>
+
+Puis, après avoir inclus les fichiers en-tête et déclaré quelques constantes,
+nous devons fournir quelques fonctions pour donner des informations sur le
+widget et pour l'initialiser&nbsp;:
+
+<tscreen><verb>
+#include <math.h>
+#include <stdio.h>
+#include <gtk/gtkmain.h>
+#include <gtk/gtksignal.h>
+
+#include "gtkdial.h"
+
+#define SCROLL_DELAY_LENGTH  300
+#define DIAL_DEFAULT_SIZE 100
+
+/* Déclararations des prototypes */
+
+[ omis pour gagner de la place ]
+
+/* Données locales */
+
+static GtkWidgetClass *parent_class = NULL;
+
+guint
+gtk_dial_get_type ()
+{
+  static guint dial_type = 0;
+
+  if (!dial_type)
+    {
+      GtkTypeInfo dial_info =
+      {
+	"GtkDial",
+	sizeof (GtkDial),
+	sizeof (GtkDialClass),
+	(GtkClassInitFunc) gtk_dial_class_init,
+	(GtkObjectInitFunc) gtk_dial_init,
+	(GtkArgFunc) NULL,
+      };
+
+      dial_type = gtk_type_unique (gtk_widget_get_type (), &amp;dial_info);
+    }
+
+  return dial_type;
+}
+
+static void
+gtk_dial_class_init (GtkDialClass *class)
+{
+  GtkObjectClass *object_class;
+  GtkWidgetClass *widget_class;
+
+  object_class = (GtkObjectClass*) class;
+  widget_class = (GtkWidgetClass*) class;
+
+  parent_class = gtk_type_class (gtk_widget_get_type ());
+
+  object_class->destroy = gtk_dial_destroy;
+
+  widget_class->realize = gtk_dial_realize;
+  widget_class->expose_event = gtk_dial_expose;
+  widget_class->size_request = gtk_dial_size_request;
+  widget_class->size_allocate = gtk_dial_size_allocate;
+  widget_class->button_press_event = gtk_dial_button_press;
+  widget_class->button_release_event = gtk_dial_button_release;
+  widget_class->motion_notify_event = gtk_dial_motion_notify;
+}
+
+static void
+gtk_dial_init (GtkDial *dial)
+{
+  dial->button = 0;
+  dial->policy = GTK_UPDATE_CONTINUOUS;
+  dial->timer = 0;
+  dial->radius = 0;
+  dial->pointer_width = 0;
+  dial->angle = 0.0;
+  dial->old_value = 0.0;
+  dial->old_lower = 0.0;
+  dial->old_upper = 0.0;
+  dial->adjustment = NULL;
+}
+
+GtkWidget*
+gtk_dial_new (GtkAdjustment *adjustment)
+{
+  GtkDial *dial;
+
+  dial = gtk_type_new (gtk_dial_get_type ());
+
+  if (!adjustment)
+    adjustment = (GtkAdjustment*) gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
+
+  gtk_dial_set_adjustment (dial, adjustment);
+
+  return GTK_WIDGET (dial);
+}
+
+static void
+gtk_dial_destroy (GtkObject *object)
+{
+  GtkDial *dial;
+
+  g_return_if_fail (object != NULL);
+  g_return_if_fail (GTK_IS_DIAL (object));
+
+  dial = GTK_DIAL (object);
+
+  if (dial->adjustment)
+    gtk_object_unref (GTK_OBJECT (dial->adjustment));
+
+  if (GTK_OBJECT_CLASS (parent_class)->destroy)
+    (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
+}
+</verb></tscreen>
+
+Notez que cette fonction <em/init()/ fait moins de choses que pour le widget
+Tictactoe car ce n'est pas un widget composé et que la fonction <em/new()/ en
+fait plus car elle a maintenant un paramètre. Notez aussi que lorsque nous
+stockons un pointeur vers l'objet Adjustement, nous incrémentons son nombre de
+références (et nous le décrémentons lorsque nous ne l'utilisons plus) afin que
+GTK puisse savoir quand il pourra être détruit sans danger.
+
+<p>
+Il y a aussi quelques fonctions pour manipuler les options du widget&nbsp;:
+
+<tscreen><verb>
+GtkAdjustment*
+gtk_dial_get_adjustment (GtkDial *dial)
+{
+  g_return_val_if_fail (dial != NULL, NULL);
+  g_return_val_if_fail (GTK_IS_DIAL (dial), NULL);
+
+  return dial->adjustment;
+}
+
+void
+gtk_dial_set_update_policy (GtkDial      *dial,
+			     GtkUpdateType  policy)
+{
+  g_return_if_fail (dial != NULL);
+  g_return_if_fail (GTK_IS_DIAL (dial));
+
+  dial->policy = policy;
+}
+
+void
+gtk_dial_set_adjustment (GtkDial      *dial,
+			  GtkAdjustment *adjustment)
+{
+  g_return_if_fail (dial != NULL);
+  g_return_if_fail (GTK_IS_DIAL (dial));
+
+  if (dial->adjustment)
+    {
+      gtk_signal_disconnect_by_data (GTK_OBJECT (dial->adjustment), (gpointer) dial);
+      gtk_object_unref (GTK_OBJECT (dial->adjustment));
+    }
+
+  dial->adjustment = adjustment;
+  gtk_object_ref (GTK_OBJECT (dial->adjustment));
+
+  gtk_signal_connect (GTK_OBJECT (adjustment), "changed",
+		      (GtkSignalFunc) gtk_dial_adjustment_changed,
+		      (gpointer) dial);
+  gtk_signal_connect (GTK_OBJECT (adjustment), "value_changed",
+		      (GtkSignalFunc) gtk_dial_adjustment_value_changed,
+		      (gpointer) dial);
+
+  dial->old_value = adjustment->value;
+  dial->old_lower = adjustment->lower;
+  dial->old_upper = adjustment->upper;
+
+  gtk_dial_update (dial);
+}
+</verb></tscreen>
+
+<sect2> <em/gtk_dial_realize()/
+
+<p>
+Nous arrivons maintenant à quelques nouveaux types de fonctions. D'abord, nous
+avons une fonction qui réalise la création de la fenêtre X. Notez que l'on
+passe un masque à la fonction <em/gdk_window_new()/ pour spécifier quels sont
+les champs de la structure GdkWindowAttr qui contiennent des données (les
+autres recevront des valeurs par défaut). Notez aussi la façon dont est créé le
+masque d'événement du widget. On appelle <em/gtk_widget_get_events()/ pour
+récupérer le masque d'événement que l'utilisateur a spécifié pour ce widget
+(avec <em/gtk_widget_set_events()/) et ajouter les événements qui nous
+intéressent.
+
+<p>
+Après avoir créé la fenêtre, nous configurons son style et son fond et mettons
+un pointeur vers le widget dans le champ user de la GdkWindow. Cette dernière
+étape permet à GTK de distribuer les événements pour cette fenêtre au widget
+correct.
+
+<tscreen><verb>
+static void
+gtk_dial_realize (GtkWidget *widget)
+{
+  GtkDial *dial;
+  GdkWindowAttr attributes;
+  gint attributes_mask;
+
+  g_return_if_fail (widget != NULL);
+  g_return_if_fail (GTK_IS_DIAL (widget));
+
+  GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
+  dial = GTK_DIAL (widget);
+
+  attributes.x = widget->allocation.x;
+  attributes.y = widget->allocation.y;
+  attributes.width = widget->allocation.width;
+  attributes.height = widget->allocation.height;
+  attributes.wclass = GDK_INPUT_OUTPUT;
+  attributes.window_type = GDK_WINDOW_CHILD;
+  attributes.event_mask = gtk_widget_get_events (widget) | 
+    GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | 
+    GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK |
+    GDK_POINTER_MOTION_HINT_MASK;
+  attributes.visual = gtk_widget_get_visual (widget);
+  attributes.colormap = gtk_widget_get_colormap (widget);
+
+  attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
+  widget->window = gdk_window_new (widget->parent->window, &amp;attributes, attributes_mask);
+
+  widget->style = gtk_style_attach (widget->style, widget->window);
+
+  gdk_window_set_user_data (widget->window, widget);
+
+  gtk_style_set_background (widget->style, widget->window, GTK_STATE_ACTIVE);
+}
+</verb></tscreen>
+
+<sect2>Négotiation de la taille
+
+<p>
+Avant le premier affichage de la fenêtre contenant un widget et à chaque fois
+que la forme de la fenêtre change, GTK demande à chaque widget fils la taille
+qu'il désire avoir. Cette requête est gérée par la fonction
+<em/gtk_dial_size_request()/. Comme notre widget n'est pas un widget container,
+et n'a pas de contraintes réelles sur sa taille, nous ne faisons que retourner
+une valeur raisonnable par défaut.
+
+<tscreen><verb>
+static void 
+gtk_dial_size_request (GtkWidget      *widget,
+		       GtkRequisition *requisition)
+{
+  requisition->width = DIAL_DEFAULT_SIZE;
+  requisition->height = DIAL_DEFAULT_SIZE;
+}
+</verb></tscreen>
+
+<p>
+Lorsque tous les widgets on demandé une taille idéale, le forme de la fenêtre
+est calculée et chaque widget fils est averti de sa taille. Habituellement, ce
+sera autant que la taille requise, mais si, par exemple, l'utilisateur a
+redimensionné la fenêtre, cette taille peut occasionnellement être plus petite
+que la taille requise. La notification de la taille est gérée par la fonction
+<em/gtk_dial_size_allocate()/. Notez qu'en même temps qu'elle calcule les
+tailles de certains composants pour une utilisation future, cette routine fait
+aussi le travail de base consistant à déplacer les widgets X Window dans leur
+nouvelles positions et tailles.
+
+<tscreen><verb>
+static void
+gtk_dial_size_allocate (GtkWidget     *widget,
+			GtkAllocation *allocation)
+{
+  GtkDial *dial;
+
+  g_return_if_fail (widget != NULL);
+  g_return_if_fail (GTK_IS_DIAL (widget));
+  g_return_if_fail (allocation != NULL);
+
+  widget->allocation = *allocation;
+  if (GTK_WIDGET_REALIZED (widget))
+    {
+      dial = GTK_DIAL (widget);
+
+      gdk_window_move_resize (widget->window,
+			      allocation->x, allocation->y,
+			      allocation->width, allocation->height);
+
+      dial->radius = MAX(allocation->width,allocation->height) * 0.45;
+      dial->pointer_width = dial->radius / 5;
+    }
+}
+</verb></tscreen>.
+
+<sect2> <em/gtk_dial_expose()/
+
+<p>
+Comme cela est mentionné plus haut, tout le dessin de ce widget est réalisé
+dans le gestionnaire pour les événements d'exposition. Il n'y a pas grand chose
+de plus à dire là dessus, sauf constater l'utilisation de la fonction
+<em/gtk_draw_polygon/ pour dessiner le pointeur avec une forme en trois
+dimensions selon les couleurs stockées dans le style du widget. 
+style.
+
+<tscreen><verb>
+static gint
+gtk_dial_expose (GtkWidget      *widget,
+		 GdkEventExpose *event)
+{
+  GtkDial *dial;
+  GdkPoint points[3];
+  gdouble s,c;
+  gdouble theta;
+  gint xc, yc;
+  gint tick_length;
+  gint i;
+
+  g_return_val_if_fail (widget != NULL, FALSE);
+  g_return_val_if_fail (GTK_IS_DIAL (widget), FALSE);
+  g_return_val_if_fail (event != NULL, FALSE);
+
+  if (event->count > 0)
+    return FALSE;
+  
+  dial = GTK_DIAL (widget);
+
+  gdk_window_clear_area (widget->window,
+			 0, 0,
+			 widget->allocation.width,
+			 widget->allocation.height);
+
+  xc = widget->allocation.width/2;
+  yc = widget->allocation.height/2;
+
+  /* Draw ticks */
+
+  for (i=0; i<25; i++)
+    {
+      theta = (i*M_PI/18. - M_PI/6.);
+      s = sin(theta);
+      c = cos(theta);
+
+      tick_length = (i%6 == 0) ? dial->pointer_width : dial->pointer_width/2;
+      
+      gdk_draw_line (widget->window,
+		     widget->style->fg_gc[widget->state],
+		     xc + c*(dial->radius - tick_length),
+		     yc - s*(dial->radius - tick_length),
+		     xc + c*dial->radius,
+		     yc - s*dial->radius);
+    }
+
+  /* Draw pointer */
+
+  s = sin(dial->angle);
+  c = cos(dial->angle);
+
+
+  points[0].x = xc + s*dial->pointer_width/2;
+  points[0].y = yc + c*dial->pointer_width/2;
+  points[1].x = xc + c*dial->radius;
+  points[1].y = yc - s*dial->radius;
+  points[2].x = xc - s*dial->pointer_width/2;
+  points[2].y = yc - c*dial->pointer_width/2;
+
+  gtk_draw_polygon (widget->style,
+		    widget->window,
+		    GTK_STATE_NORMAL,
+		    GTK_SHADOW_OUT,
+		    points, 3,
+		    TRUE);
+  
+  return FALSE;
+}
+</verb></tscreen>
+
+<sect2>Gestion des événements
+
+<p>
+Le reste du code du widget gère différents types d'événements et n'est pas
+trop différent de ce que l'on trouve dans la plupart des applications GTK. Deux
+types d'événements peuvent survenir -- l'utilisateur peut cliquer sur le widget
+avec la souris et faire glisser pour déplacer le pointeur, ou bien la valeur de
+l'objet Adjustment peut changer à cause d'une circonstance extérieure.
+
+<p>
+Lorsque l'utilisateur clique sur le widget, on vérifie si le clic s'est bien
+passé près du pointeur et si c'est le cas, on stocke alors le bouton avec
+lequel l'utilisateur a cliqué dans le champ <em/button/ de la structure du
+widget et on récupère tous les événements souris avec un appel à
+<em/gtk_grab_add()/. Un déplacement ultérieur de la souris provoque le recalcul
+de la valeur de contrôle (par la fonction <em/gtk_dial_update_mouse/). Selon la
+politique qui a été choisie, les événements "value_changed" sont, soit générés
+instantanément (<em/GTK_UPDATE_CONTINUOUS/), après un délai ajouté au timer
+avec <em/gtk_timeout_add()/ (<em/GTK_UPDATE_DELAYED/), ou seulement lorsque le
+bouton est relâché (<em/GTK_UPDATE_DISCONTINUOUS/).
+
+<tscreen><verb>
+static gint
+gtk_dial_button_press (GtkWidget      *widget,
+		       GdkEventButton *event)
+{
+  GtkDial *dial;
+  gint dx, dy;
+  double s, c;
+  double d_parallel;
+  double d_perpendicular;
+
+  g_return_val_if_fail (widget != NULL, FALSE);
+  g_return_val_if_fail (GTK_IS_DIAL (widget), FALSE);
+  g_return_val_if_fail (event != NULL, FALSE);
+
+  dial = GTK_DIAL (widget);
+
+  /* Détermine si le bouton pressé est dans la région du pointeur.
+     On fait cela en calculant les distances parallèle et perpendiculaire
+     du point où la souris a été pressée par rapport à la ligne passant
+     par le pointeur */
+  
+  dx = event->x - widget->allocation.width / 2;
+  dy = widget->allocation.height / 2 - event->y;
+  
+  s = sin(dial->angle);
+  c = cos(dial->angle);
+  
+  d_parallel = s*dy + c*dx;
+  d_perpendicular = fabs(s*dx - c*dy);
+  
+  if (!dial->button &&
+      (d_perpendicular < dial->pointer_width/2) &&
+      (d_parallel > - dial->pointer_width))
+    {
+      gtk_grab_add (widget);
+
+      dial->button = event->button;
+
+      gtk_dial_update_mouse (dial, event->x, event->y);
+    }
+
+  return FALSE;
+}
+
+static gint
+gtk_dial_button_release (GtkWidget      *widget,
+			  GdkEventButton *event)
+{
+  GtkDial *dial;
+
+  g_return_val_if_fail (widget != NULL, FALSE);
+  g_return_val_if_fail (GTK_IS_DIAL (widget), FALSE);
+  g_return_val_if_fail (event != NULL, FALSE);
+
+  dial = GTK_DIAL (widget);
+
+  if (dial->button == event->button)
+    {
+      gtk_grab_remove (widget);
+
+      dial->button = 0;
+
+      if (dial->policy == GTK_UPDATE_DELAYED)
+	gtk_timeout_remove (dial->timer);
+      
+      if ((dial->policy != GTK_UPDATE_CONTINUOUS) &&
+	  (dial->old_value != dial->adjustment->value))
+	gtk_signal_emit_by_name (GTK_OBJECT (dial->adjustment), "value_changed");
+    }
+
+  return FALSE;
+}
+
+static gint
+gtk_dial_motion_notify (GtkWidget      *widget,
+			 GdkEventMotion *event)
+{
+  GtkDial *dial;
+  GdkModifierType mods;
+  gint x, y, mask;
+
+  g_return_val_if_fail (widget != NULL, FALSE);
+  g_return_val_if_fail (GTK_IS_DIAL (widget), FALSE);
+  g_return_val_if_fail (event != NULL, FALSE);
+
+  dial = GTK_DIAL (widget);
+
+  if (dial->button != 0)
+    {
+      x = event->x;
+      y = event->y;
+
+      if (event->is_hint || (event->window != widget->window))
+	gdk_window_get_pointer (widget->window, &amp;x, &amp;y, &amp;mods);
+
+      switch (dial->button)
+	{
+	case 1:
+	  mask = GDK_BUTTON1_MASK;
+	  break;
+	case 2:
+	  mask = GDK_BUTTON2_MASK;
+	  break;
+	case 3:
+	  mask = GDK_BUTTON3_MASK;
+	  break;
+	default:
+	  mask = 0;
+	  break;
+	}
+
+      if (mods & mask)
+	gtk_dial_update_mouse (dial, x,y);
+    }
+
+  return FALSE;
+}
+
+static gint
+gtk_dial_timer (GtkDial *dial)
+{
+  g_return_val_if_fail (dial != NULL, FALSE);
+  g_return_val_if_fail (GTK_IS_DIAL (dial), FALSE);
+
+  if (dial->policy == GTK_UPDATE_DELAYED)
+    gtk_signal_emit_by_name (GTK_OBJECT (dial->adjustment), "value_changed");
+
+  return FALSE;
+}
+
+static void
+gtk_dial_update_mouse (GtkDial *dial, gint x, gint y)
+{
+  gint xc, yc;
+  gfloat old_value;
+
+  g_return_if_fail (dial != NULL);
+  g_return_if_fail (GTK_IS_DIAL (dial));
+
+  xc = GTK_WIDGET(dial)->allocation.width / 2;
+  yc = GTK_WIDGET(dial)->allocation.height / 2;
+
+  old_value = dial->adjustment->value;
+  dial->angle = atan2(yc-y, x-xc);
+
+  if (dial->angle < -M_PI/2.)
+    dial->angle += 2*M_PI;
+
+  if (dial->angle < -M_PI/6)
+    dial->angle = -M_PI/6;
+
+  if (dial->angle > 7.*M_PI/6.)
+    dial->angle = 7.*M_PI/6.;
+
+  dial->adjustment->value = dial->adjustment->lower + (7.*M_PI/6 - dial->angle) *
+    (dial->adjustment->upper - dial->adjustment->lower) / (4.*M_PI/3.);
+
+  if (dial->adjustment->value != old_value)
+    {
+      if (dial->policy == GTK_UPDATE_CONTINUOUS)
+	{
+	  gtk_signal_emit_by_name (GTK_OBJECT (dial->adjustment), "value_changed");
+	}
+      else
+	{
+	  gtk_widget_draw (GTK_WIDGET(dial), NULL);
+
+	  if (dial->policy == GTK_UPDATE_DELAYED)
+	    {
+	      if (dial->timer)
+		gtk_timeout_remove (dial->timer);
+
+	      dial->timer = gtk_timeout_add (SCROLL_DELAY_LENGTH,
+					     (GtkFunction) gtk_dial_timer,
+					     (gpointer) dial);
+	    }
+	}
+    }
+}
+</verb></tscreen>
+
+<p>
+Les changements de l'Adjustement par des moyens extérieurs sont communiqués à
+notre widget par les signaux "changed" et "value_changed". Les gestionnaires
+pour ces fonctions appellent <em/gtk_dial_update()/ pour valider les
+paramètres, calculer le nouvel angle du pointeur et redessiner le widget (en
+appelant <em/gtk_widget_draw()/).
+
+<tscreen><verb>
+static void
+gtk_dial_update (GtkDial *dial)
+{
+  gfloat new_value;
+  
+  g_return_if_fail (dial != NULL);
+  g_return_if_fail (GTK_IS_DIAL (dial));
+
+  new_value = dial->adjustment->value;
+  
+  if (new_value < dial->adjustment->lower)
+    new_value = dial->adjustment->lower;
+
+  if (new_value > dial->adjustment->upper)
+    new_value = dial->adjustment->upper;
+
+  if (new_value != dial->adjustment->value)
+    {
+      dial->adjustment->value = new_value;
+      gtk_signal_emit_by_name (GTK_OBJECT (dial->adjustment), "value_changed");
+    }
+
+  dial->angle = 7.*M_PI/6. - (new_value - dial->adjustment->lower) * 4.*M_PI/3. /
+    (dial->adjustment->upper - dial->adjustment->lower);
+
+  gtk_widget_draw (GTK_WIDGET(dial), NULL);
+}
+
+static void
+gtk_dial_adjustment_changed (GtkAdjustment *adjustment,
+			      gpointer       data)
+{
+  GtkDial *dial;
+
+  g_return_if_fail (adjustment != NULL);
+  g_return_if_fail (data != NULL);
+
+  dial = GTK_DIAL (data);
+
+  if ((dial->old_value != adjustment->value) ||
+      (dial->old_lower != adjustment->lower) ||
+      (dial->old_upper != adjustment->upper))
+    {
+      gtk_dial_update (dial);
+
+      dial->old_value = adjustment->value;
+      dial->old_lower = adjustment->lower;
+      dial->old_upper = adjustment->upper;
+    }
+}
+
+static void
+gtk_dial_adjustment_value_changed (GtkAdjustment *adjustment,
+				    gpointer       data)
+{
+  GtkDial *dial;
+
+  g_return_if_fail (adjustment != NULL);
+  g_return_if_fail (data != NULL);
+
+  dial = GTK_DIAL (data);
+
+  if (dial->old_value != adjustment->value)
+    {
+      gtk_dial_update (dial);
+
+      dial->old_value = adjustment->value;
+    }
+}
+</verb></tscreen>
+
+<sect2>Améliorations possibles
+
+<p>
+
+Le widget Dial décrit jusqu'à maintenant exécute à peu près 670 lignes de
+code. Bien que cela puisse sembler beaucoup, nous en avons vraiment fait
+beaucoup avec ce code, notamment parce que la majeure partie de cette longueur
+est due aux en-têtes et à la préparation. Cependant, certaines améliorations
+peuvent être apportées à ce widget&nbsp;:
+
+<itemize>
+<item> Si vous testez ce widget, vous vous apercevrez qu'il y a un peu de
+scintillement lorsque le pointeur est déplacé. Ceci est dû au fait que le
+widget entier est effacé, puis redessiné  à chaque mouvement du
+pointeur. Souvent, la meilleure façon de gérer ce problème est de dessiner sur
+un pixmap non affiché, puis de copier le résultat final sur l'écran en une
+seule étape (le widget <em/ProgressBar/ se dessine de cette façon).
+
+<item> L'utilisateur devrait pouvoir utiliser les flèches du curseur vers le
+haut et vers le bas pour incrémenter et décrémenter la valeur.
+
+<item> Ce serait bien si le widget avait des boutons pour augmenter et diminuer
+la valeur dans de petites ou de grosses proportions. Bien qu'il serait possible
+d'utiliser les widgets <em/Button/ pour cela, nous voudrions aussi que les
+boutons s'auto-répètent lorsqu'ils sont maintenus appuyés, comme font les
+flèches d'une barre de défilement. La majeure partie du code pour implanter ce
+type de comportement peut se trouver dans le widget <em/GtkRange/.
+
+<item> Le widget Dial pourrait être fait dans un widget container avec un seul
+widget fils positionnée en bas, entre les boutons mentionnés
+ci-dessus. L'utilisateur pourrait alors ajouter au choix, un widget label ou
+entrée pour afficher la valeur courante de l'appel.
+
+</itemize>
+
+<sect1>En savoir plus
+
+<p>
+Seule une petite partie des nombreux détails de la création des widgets a pu
+être décrite. Si vous désirez écrire vos propres widgets, la meilleure source
+d'exemples est le source de GTK lui-même. Posez-vous quelques questions sur les
+widgets que vous voulez écrire&nbsp;: est-ce un widget container ? possède-t-il
+sa propre fenêtre ? est-ce une modification d'un widget existant ? Puis,
+trouvez un widget identique et commencez à faire les modifications. Bonne
+chance !
+
+<sect>Scribble, un programme simple de dessin
+
+<sect1>Présentation
+
+<p>
+Dans cette section, nous construirons un programme simple de dessin. Ce
+faisant, nous examinerons comment gérer les événements souris, comment dessiner
+dans une fenêtre, et comment mieux dessiner en utilisant un pixmap en arrière
+plan. Après avoir créé ce programme, nous l'étendrons en lui ajoutant le
+support des périphériques <em/Xinput/, comme les tables de tracé. GTK dispose
+de routines de support qui facilitent beaucoup l'obtention des informations
+étendues (comme la pression et l'inclinaison du stylet) à partir de tels
+périphériques.
+
+<sect1>Gestion d'événement
+
+<p>
+Les signaux GTK que nous avons déjà vus concernent les actions de haut niveau,
+comme la sélection d'un choix d'un menu. Cependant, il est quelques fois utile
+de connaître les cas de bas niveau, comme le déplacement de la souris, ou la
+pression d'une touche. Il existe aussi des signaux GTK correspondant à ces
+<em/événements/ bas niveau. Les gestionnaires de ces signaux ont un paramètre
+supplémentaire qui est un pointeur vers une structure contenant des
+informations sur l'événement. Par exemple, les gestionnaires des événements de
+déplacement recoivent un paramètre vers une structure <em/GdkEventMotion/ qui
+ressemble (en partie) à ceci&nbsp;:
+
+<tscreen><verb>
+struct _GdkEventMotion
+{
+  GdkEventType type;
+  GdkWindow *window;
+  guint32 time;
+  gdouble x;
+  gdouble y;
+  ...
+  guint state;
+  ...
+};
+</verb></tscreen>
+
+<em/type/ sera initialisé avec le type de l'événement, ici
+<em/GDK_MOTION_NOTIFY/, <em/window/ est la fenêtre dans laquelle l'événement
+est survenu. <em/x/ et <em/y/ donnent les coordonnées de l'événement et
+<em/state/ spécifie l'état du modificateur lorsque l'événement s'est produit
+(c'est-à-dire quelles sont les touches de modification et les boutons souris
+qui ont été pressés). Il s'agit d'un OU bit à bit de l'une des valeurs
+suivantes&nbsp;: 
+
+<tscreen><verb>
+GDK_SHIFT_MASK  
+GDK_LOCK_MASK   
+GDK_CONTROL_MASK
+GDK_MOD1_MASK   
+GDK_MOD2_MASK   
+GDK_MOD3_MASK   
+GDK_MOD4_MASK   
+GDK_MOD5_MASK   
+GDK_BUTTON1_MASK
+GDK_BUTTON2_MASK
+GDK_BUTTON3_MASK
+GDK_BUTTON4_MASK
+GDK_BUTTON5_MASK
+</verb></tscreen>
+
+<p>
+Comme pour les autres signaux, on appelle <em/gtk_signal_connect()/ pour
+déterminer ce qui se passe lorsqu'un événement survient. Mais nous devons aussi
+faire en sorte que GTK sache de quels événements nous voulons être
+avertis. Pour ce faire, on appelle la fonction&nbsp;:
+
+<tscreen><verb>
+void       gtk_widget_set_events          (GtkWidget           *widget,
+					   gint                 events);
+</verb></tscreen>
+
+Le deuxième champ spécifie les événements qui nous intéressent. Il s'agit d'un
+OU bit à bit de constantes qui indiquent différent types d'événements. Pour 
+référence ultérieure, les types d'événements sont&nbsp;:
+
+<tscreen><verb>
+GDK_EXPOSURE_MASK
+GDK_POINTER_MOTION_MASK
+GDK_POINTER_MOTION_HINT_MASK
+GDK_BUTTON_MOTION_MASK     
+GDK_BUTTON1_MOTION_MASK    
+GDK_BUTTON2_MOTION_MASK    
+GDK_BUTTON3_MOTION_MASK    
+GDK_BUTTON_PRESS_MASK      
+GDK_BUTTON_RELEASE_MASK    
+GDK_KEY_PRESS_MASK         
+GDK_KEY_RELEASE_MASK       
+GDK_ENTER_NOTIFY_MASK      
+GDK_LEAVE_NOTIFY_MASK      
+GDK_FOCUS_CHANGE_MASK      
+GDK_STRUCTURE_MASK         
+GDK_PROPERTY_CHANGE_MASK   
+GDK_PROXIMITY_IN_MASK      
+GDK_PROXIMITY_OUT_MASK     
+</verb></tscreen>
+
+Il y a quelques points subtils qui doivent être observés lorsqu'on appelle
+<em/gtk_widget_set_events()/. D'abord, elle doit être appelée avant que la
+fenêtre X d'un widget GTK soit créée. En pratique, cela signifie que l'on doit
+l'appeler immédiatement après avoir créé le widget. Ensuite, le widget doit
+avoir une fenêtre X associée. Pour des raisons d'efficacité, de nombreux types
+de widgets n'ont pas de fenêtre propre, mais se dessinent dans la fenêtre de
+leur parent. Ces widgets sont&nbsp;:
+
+<tscreen><verb>
+GtkAlignment
+GtkArrow
+GtkBin
+GtkBox
+GtkImage
+GtkItem
+GtkLabel
+GtkPaned
+GtkPixmap
+GtkScrolledWindow
+GtkSeparator
+GtkTable
+GtkViewport
+GtkAspectFrame
+GtkFrame
+GtkVPaned
+GtkHPaned
+GtkVBox
+GtkHBox
+GtkVSeparator
+GtkHSeparator
+</verb></tscreen>
+
+Pour capturer les événements pour ces widgets, on doit utiliser un widget
+<em/EventBox/. Voir la section sur <ref id="sec_The_EventBox_Widget" name="Le
+widget EventBox"> pour plus de détails.
+
+<p>
+Pour notre programme de dessin, on veut savoir quand le bouton de la souris est
+pressé et quand la souris est déplacée, nous indiquons donc
+<em/GDK_POINTER_MOTION_MASK/ et <em/GDK_BUTTON_PRESS_MASK/. On veut aussi
+savoir quand il est nécessaire de redessiner notre fenêtre, on indique donc
+<em/GDK_EXPOSURE_MASK/. Bien que nous voulions être avertis via un événement
+<em/Configure/ lorsque la taille de notre fenêtre change, on n'a pas besoin de
+préciser le flag <em/GDK_STRUCTURE_MASK/ correspondant car il est
+automatiquement spécifié pour chaque fenêtre.
+
+<p>
+Il arrive cependant qu'il puisse y avoir un problème en indiquant seulement
+<em/GDK_POINTER_MOTION_MASK/. Cela fera que le serveur ajoutera un nouvel
+événement de déplacement à la file des événements à chaque fois que
+l'utilisateur déplace la souris. Si cela nous prend 0,1 seconde pour gérer un
+événement de déplacement, si le serveur X n'ajoute un nouvel événement de
+déplacement dans la queue que toutes les 0,05 secondes, nous serons vite à la
+traîne de l'utilisateur. Si l'utilisateur dessine pendant 5 secondes, cela nous
+prendra 5 secondes de plus pour le traiter après qu'il ait relâché le bouton de
+la souris ! Ce que l'on voudrait, c'est ne récupérer qu'un événement de
+déplacement pour chaque événement que l'on traite. Pour cela, il faut préciser
+<em/GDK_POINTER_MOTION_HINT_MASK/.
+
+<p>
+Avec <em/GDK_POINTER_MOTION_HINT_MASK/, le serveur nous envoit un événement de
+déplacement la première fois que la pointeur se déplace après être entré dans
+la fenêtre, ou après un événement d'appui ou de relâchement d'un bouton. Les
+événements de déplacement suivants seront supprimés jusqu'à ce que l'on demande
+explicitement la position du pointeur en utilisant la fonction&nbsp;:
+
+<tscreen><verb>
+GdkWindow*    gdk_window_get_pointer     (GdkWindow       *window,
+					  gint            *x,
+					  gint            *y,
+					  GdkModifierType *mask);
+</verb></tscreen>
+
+(Il existe une autre fonction, <em/gtk_widget_get_pointer()/ qui possède une
+interface simple, mais n'est pas très utile car elle ne fait que récupérer la
+position de la souris et ne se préoccupe pas de savoir si les boutons sont
+pressés).
+
+<p>
+Le code pour configurer les événements pour notre fenêtre ressemble alors
+à&nbsp;:
+
+<tscreen><verb>
+  gtk_signal_connect (GTK_OBJECT (drawing_area), "expose_event",
+		      (GtkSignalFunc) expose_event, NULL);
+  gtk_signal_connect (GTK_OBJECT(drawing_area),"configure_event",
+		      (GtkSignalFunc) configure_event, NULL);
+  gtk_signal_connect (GTK_OBJECT (drawing_area), "motion_notify_event",
+		      (GtkSignalFunc) motion_notify_event, NULL);
+  gtk_signal_connect (GTK_OBJECT (drawing_area), "button_press_event",
+		      (GtkSignalFunc) button_press_event, NULL);
+
+  gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK
+			 | GDK_LEAVE_NOTIFY_MASK
+			 | GDK_BUTTON_PRESS_MASK
+			 | GDK_POINTER_MOTION_MASK
+			 | GDK_POINTER_MOTION_HINT_MASK);
+</verb></tscreen>
+
+Nous garderons les gestionnaires de "expose_event" et "configure_event" pour
+plus tard. Les gestionnaires de "motion_notify_event" et "button_press_event"
+sont très simples&nbsp;:
+
+<tscreen><verb>
+static gint
+button_press_event (GtkWidget *widget, GdkEventButton *event)
+{
+  if (event->button == 1 &amp;&amp; pixmap != NULL)
+      draw_brush (widget, event->x, event->y);
+
+  return TRUE;
+}
+
+static gint
+motion_notify_event (GtkWidget *widget, GdkEventMotion *event)
+{
+  int x, y;
+  GdkModifierType state;
+
+  if (event->is_hint)
+    gdk_window_get_pointer (event->window, &amp;x, &amp;y, &amp;state);
+  else
+    {
+      x = event->x;
+      y = event->y;
+      state = event->state;
+    }
+    
+  if (state &amp; GDK_BUTTON1_MASK &amp;&amp; pixmap != NULL)
+    draw_brush (widget, x, y);
+  
+  return TRUE;
+}
+</verb></tscreen>
+
+
+<sect1>Le widget DrawingArea et le dessin
+
+<p>
+Revenons au processus de dessin sur l'écran. Le widget que l'on utilise pour
+ceci est le widget <em/DrawingArea/. Un tel widget est essentiellement une
+fenêtre X et rien de plus. Il s'agit d'une toile vide sur laquelle nous pouvons
+dessiner ce que nous voulons. 
+
+Une zone de dessin est créée avec l'appel&nbsp;:
+
+<tscreen><verb>
+GtkWidget* gtk_drawing_area_new        (void);
+</verb></tscreen>
+
+Une taille par défaut peut être donnée au widget par l'appel&nbsp;:
+
+<tscreen><verb>
+void       gtk_drawing_area_size       (GtkDrawingArea      *darea,
+					gint                 width,
+					gint                 height);
+</verb></tscreen>
+
+Cette taille par défaut peu être surchargée en appelant
+<em/gtk_widget_set_usize()/ et celle-ci, à son tour, peut être surchargée si
+l'utilisateur modifie manuellement la taille de la fenêtre contenant la zone de
+dessin.
+
+<p>
+Il faut noter que lorsque l'on crée un widget <em/DrawingArea/, nous sommes
+<em>complètement</em> responsable du dessin du contenu. Si notre fenêtre est
+cachée puis redécouverte, nous recevrons un événement d'exposition et devrons
+redessiner ce qui a été caché auparavant.
+
+<p>
+Devoir se rappeler tout ce qui a été dessiné à l'écran pour pouvoir
+correctement le redessiner peut s'avérer, c'est le moins que l'on puisse dire,
+pénible. De plus, cela peut être visible si des portions de la fenêtre sont
+effacées puis redessinées étape par étape. La solution à ce problème est
+d'utiliser un <em/pixmap d'arrière-plan/ qui n'est pas sur l'écran. Au lieu de
+dessiner directement à l'écran, on dessine sur une image stockée dans la
+mémoire du serveur et qui n'est pas affichée, puis, lorsque l'image change ou
+lorsque de nouvelles portions de l'image sont affichées, on copie les parties
+adéquates sur l'écran.
+
+<p>
+Pour créer un pixmap mémoire, on appelle la fonction&nbsp;:
+
+<tscreen><verb>
+GdkPixmap* gdk_pixmap_new               (GdkWindow  *window,
+					 gint        width,
+					 gint        height,
+					 gint        depth);
+</verb></tscreen>
+
+Le paramètre <em/windows/ indique une fenêtre GTK de laquelle ce pixmap tire
+certaines de ses propriétés. <em/width/ et <em/height/ précisent la taille du
+pixmap. <em/depth/ précise la  <em/profondeur de couleur/, c'est-à-dire le
+nombre de bits par pixel, de la nouvelle fenêtre. Si cette profondeur vaut
+<em/-1/, elle correspondra à celle de <em/window/.
+
+<p>
+Nous créons le pixmap dans notre gestionnaire "configure_event". Cet événement
+est généré à chaque fois que la fenêtre change de taille, y compris lorsqu'elle
+initialement créée.
+
+<tscreen><verb>
+/* Pixmap d'arrière-plan pour la zone de dessin */
+static GdkPixmap *pixmap = NULL;
+
+/* Création d'un nouveau pixmap d'arrière-plan de la taille voulue */
+static gint
+configure_event (GtkWidget *widget, GdkEventConfigure *event)
+{
+  if (pixmap)
+    {
+      gdk_pixmap_destroy(pixmap);
+    }
+  pixmap = gdk_pixmap_new(widget->window,
+			  widget->allocation.width,
+			  widget->allocation.height,
+			  -1);
+  gdk_draw_rectangle (pixmap,
+		      widget->style->white_gc,
+		      TRUE,
+		      0, 0,
+		      widget->allocation.width,
+		      widget->allocation.height);
+
+  return TRUE;
+}
+</verb></tscreen>
+
+L'appel à <em/gdk_draw_rectangle()/ remet le pixmap à blanc. Nous en dirons un
+peu plus dans un moment.
+
+<p>
+Notre gestionnaire d'événement d'exposition copie alors simplement la partie
+concernées du pixmap sur l'écran (on détermine la zone qu'il faut redessiner en
+utilisant le champ <em/event->area/ de l'événement d'exposition)&nbsp;:
+
+<tscreen><verb>
+/* Remplit l'écran à partir du pixmap d'arrière-plan */
+static gint
+expose_event (GtkWidget *widget, GdkEventExpose *event)
+{
+  gdk_draw_pixmap(widget->window,
+		  widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
+		  pixmap,
+		  event->area.x, event->area.y,
+		  event->area.x, event->area.y,
+		  event->area.width, event->area.height);
+
+  return FALSE;
+}
+</verb></tscreen>
+
+Nous avons vu comment garder l'écran à jour avec notre pixmap, mais comment
+dessine-t-on réellement ce que l'on veut dans le pixmap ? Il existe un grand
+nombre d'appels dans la bibliothèque GDK de GTK pour dessiner sur des
+<em>dessinables</em>. Un dessinable est simplement quelque chose sur lequel on
+peut dessiner. Cela peut être une fenêtre, un pixmap, ou un bitmap (une image
+en noir et blanc). Nous avons déjà vu plus haut deux de ces appels,
+<em/gdk_draw_rectangle()/ et <em/gdk_draw_pixmap()/. La liste complète
+est&nbsp;:
+
+<tscreen><verb>
+gdk_draw_line ()
+gdk_draw_rectangle ()
+gdk_draw_arc ()
+gdk_draw_polygon ()
+gdk_draw_string ()
+gdk_draw_text ()
+gdk_draw_pixmap ()
+gdk_draw_bitmap ()
+gdk_draw_image ()
+gdk_draw_points ()
+gdk_draw_segments ()
+</verb></tscreen>
+
+Consultez la documentation de référence ou le fichier en-tête
+<em/&lt;gdk/gdk.h&gt;/ pour plus de détails sur ces fonctions.  Celles-ci
+partagent toutes les mêmes deux paramêtres. Le premier est le dessinable sur
+lequel dessiner, le second est un <em/contexte graphique/ (GC).
+
+<p>
+Un contexte graphique encapsule l'information sur des choses comme les couleurs
+de premier et d'arrière plan et la largeur de ligne. GDK possède un ensemble
+complet de fonctions pour créer et manipuler les contextes graphiques, mais,
+pour simplifier, nous n'utiliserons que les contextes graphiques
+prédéfinis. Chaque widget a un style associé (qui peut être modifié dans un
+fichier gtkrc, voir la section sur les fichiers rc de GTK). Celui-ci, entre
+autres choses, stocke plusieurs contextes graphiques. Quelques exemples d'accès
+à ces contextes sont&nbsp;:
+
+<tscreen><verb>
+widget->style->white_gc
+widget->style->black_gc
+widget->style->fg_gc[GTK_STATE_NORMAL]
+widget->style->bg_gc[GTK_WIDGET_STATE(widget)]
+</verb></tscreen>
+
+Les champs <em/fg_gc, bg_gc, dark_gc/ et <em/light_gc/ sont indexés par un
+paramètre de type <em/GtkStateType/ qui peut prendre les valeurs&nbsp;:
+
+<tscreen><verb>
+GTK_STATE_NORMAL,
+GTK_STATE_ACTIVE,
+GTK_STATE_PRELIGHT,
+GTK_STATE_SELECTED,
+GTK_STATE_INSENSITIVE
+</verb></tscreen>
+
+Par exemple, pour <em/GTK_STATE_SELECTED/, la couleur de premier plan par
+défaut est blanc et la couleur d'arrière plan par défaut est bleu foncé.
+
+<p>
+Notre fonction <em/draw_brush()/, qui réalise le dessin à l'écran est alors&nbsp;:
+
+<tscreen><verb>
+/* Dessine un rectangle à l'écran */
+static void
+draw_brush (GtkWidget *widget, gdouble x, gdouble y)
+{
+  GdkRectangle update_rect;
+
+  update_rect.x = x - 5;
+  update_rect.y = y - 5;
+  update_rect.width = 10;
+  update_rect.height = 10;
+  gdk_draw_rectangle (pixmap,
+		      widget->style->black_gc,
+		      TRUE,
+		      update_rect.x, update_rect.y,
+		      update_rect.width, update_rect.height);
+  gtk_widget_draw (widget, &amp;update_rect);
+}
+</verb></tscreen>
+
+Après avoir dessiné le rectangle représentant la brosse sur le pixmap, nous
+appelons la fonction&nbsp;:
+
+<tscreen><verb>
+void       gtk_widget_draw                (GtkWidget           *widget,
+					   GdkRectangle        *area);
+</verb></tscreen>
+
+qui indique à X que la zone donnée par le paramètre <em/area/ a besoin d'être
+mise à jour. X génèrera éventuellement un événement d'exposition (en combinant
+peut-être les zones passés dans plusieurs appels à <em/gtk_widget_draw()/) ce
+qui forcera notre gestionnaire d'événement d'exposition à copier les parties
+adéquates à l'écran.
+
+<p>
+Nous avons maintenant couvert entièrement le programme de dessin, sauf quelques
+détails banals comme la création de la fenêtre principale. Le code source
+complet est disponible à l'endroit où vous avez obtenu ce didacticiel.
+
+<sect1>Ajouter le support XInput
+
+<p>
+Il est maintenant possible d'acheter des périphériques bon marché, comme les
+tablettes graphiques qui permettent d'exprimer beaucoup plus facilement son
+talent qu'avec une souris. La façon la plus simple pour utiliser de tels
+périphériques est simplement de le faire comme un remplacement de la souris,
+mais cela ne tire pas partie des nombreux avantages de ces périphériques,
+comme&nbsp;:
+
+<itemize>
+<item> Sensibilité à la pression ;
+<item> rapport d'inclinaison ;
+<item> positionnement au dessous du pixel ;
+<item> entrées multiples (par exemple, un stylet avec pointe et gomme).
+</itemize>
+
+Pour des informations sur l'extension XInput, voir <url
+url="http://www.msc.cornell.edu/~otaylor/xinput/XInput-HOWTO.html"
+name="XInput-HOWTO">.
+
+<p>
+Si l'on examine la définition complète de, par exemple, la structure
+<em/GdkEventMotion/, on voit qu'elle possède des champs pour supporter des
+informations étendues sur les périphériques.
+
+<tscreen><verb>
+struct _GdkEventMotion
+{
+  GdkEventType type;
+  GdkWindow *window;
+  guint32 time;
+  gdouble x;
+  gdouble y;
+  gdouble pressure;
+  gdouble xtilt;
+  gdouble ytilt;
+  guint state;
+  gint16 is_hint;
+  GdkInputSource source;
+  guint32 deviceid;
+};
+</verb></tscreen>
+
+<em/pressure/ indique la pression comme un nombre réel compris entre 0 et 1.
+<em/xtilt/ et <em/ytilt/ peuvent prendre des valeurs entre -1 et 1,
+correspondant au degré d'inclinaison dans chaque direction, <em/source/ et
+<em/deviceid/ précisent de deux façons différentes le périphérique pour lequel
+l'événement est survenus. <em/source/ donne une simple information sur le type
+du périphérique. Il peut prendre l'une des valeurs suivantes&nbsp;:
+
+<tscreen><verb>
+GDK_SOURCE_MOUSE
+GDK_SOURCE_PEN
+GDK_SOURCE_ERASER
+GDK_SOURCE_CURSOR
+</verb></tscreen>
+
+<tt/deviceid/ précise un ID numérique unique pour le périphérique. Il peut être
+utilisé pour trouver des informations supplémentaires sur le périphérique en
+utilisant l'appel <em/gdk_input_list_devices()/ (voir ci-dessous). La valeur
+spéciale <em/GDK_CORE_POINTER/ sert à désigner le périphérique de pointage
+principal (habituellement la souris).
+
+<sect2>Valider l'information supplémentaire sur un périphérique
+
+<p>
+Pour indiquer à GTK que l'on désire obtenir des informations supplémentaires
+sur le périphérique, on a simplement besoin d'ajouter une ligne à nos
+programmes. 
+
+<tscreen><verb>
+gtk_widget_set_extension_events (drawing_area, GDK_EXTENSION_EVENTS_CURSOR);
+</verb></tscreen>
+
+En donnant la valeur <em/GDK_EXTENSION_EVENTS_CURSOR/, on indique que nous
+désirons les événements d'extension, mais seulement si l'on ne doit pas
+dessiner notre propre curseur. Voir la section <ref
+id="sec_Further_Sophistications" name="Sophistications supplémentaires">
+ci-dessous pour des plus de détails sur le dessin du curseur. Nous pourrions
+aussi donner les valeurs <em/GDK_EXTENSION_EVENTS_ALL/ si nous voulons dessiner
+notre propre curseur, ou <tt/GDK_EXTENSION_EVENTS_NONE/ pour revenir à la
+situation par défaut.
+
+<p>
+Toutefois, nous ne sommes pas complètement à la fin de l'histoire. Par défaut,
+aucun périphérique d'extension n'est autorisé. Nous avons besoin d'un mécanisme
+pour que les utilisateurs puissent autoriser et configurer leur extensions. GTK
+dispose du widget <em/InputDialog/ pour automatiser cette tâche. La procédure
+suivante gère un widget InputDialog. Elle crée le dialogue s'il n'est pas
+présent et le place au premier plan sinon.
+
+<tscreen><verb>
+void
+input_dialog_destroy (GtkWidget *w, gpointer data)
+{
+  *((GtkWidget **)data) = NULL;
+}
+
+void
+create_input_dialog ()
+{
+  static GtkWidget *inputd = NULL;
+
+  if (!inputd)
+    {
+      inputd = gtk_input_dialog_new();
+
+      gtk_signal_connect (GTK_OBJECT(inputd), "destroy",
+			  (GtkSignalFunc)input_dialog_destroy, &amp;inputd);
+      gtk_signal_connect_object (GTK_OBJECT(GTK_INPUT_DIALOG(inputd)->close_button),
+				 "clicked",
+				 (GtkSignalFunc)gtk_widget_hide,
+				 GTK_OBJECT(inputd));
+      gtk_widget_hide ( GTK_INPUT_DIALOG(inputd)->save_button);
+
+      gtk_widget_show (inputd);
+    }
+  else
+    {
+      if (!GTK_WIDGET_MAPPED(inputd))
+	gtk_widget_show(inputd);
+      else
+	gdk_window_raise(inputd->window);
+    }
+}
+</verb></tscreen>
+
+(vous pouvez remarquer la façon dont nous gérons ce dialogue. En le connectant
+au signal "destroy", nous nous assurons que nous ne garderons pas un pointeur
+sur le dialogue après l'avoir détruit -- cela pourrait provoquer une erreur de
+segmentation).
+
+
+<p>
+InputDialog a deux boutons "Close" et "Save", qui n'ont pas d'actions qui leur
+sont assignées par défaut. Dans la fonction ci-dessus, nous associons à "Close"
+le masquage du dialogue et nous cachons le bouton "Save" car nous n'implantons
+pas la sauvegarde des options XInput dans ce programme.
+
+<sect2>Utiliser l'information supplémentaire d'un périphérique
+
+<p>
+Lorsque l'on a validé le périphérique, on peut simplement utiliser
+l'information supplémentaire des champs des structures d'événement. En fait, il
+est toujours prident d'utiliser ces informations car ces champs auront des
+valeurs par défaut judicieuses même lorsque les événements supplémentaires ne
+sont pas autorisés.
+
+<p>
+La seule modification consiste à appeler <em/gdk_input_window_get_pointer()/ au
+lieu de <em/gdk_window_get_pointer/. Cela est nécessaire car
+<em/gdk_window_get_pointer/ ne retourne pas l'information supplémentaire.
+
+<tscreen><verb>
+void gdk_input_window_get_pointer     (GdkWindow       *window,
+				       guint32         deviceid,
+				       gdouble         *x,
+				       gdouble         *y,
+				       gdouble         *pressure,
+				       gdouble         *xtilt,
+				       gdouble         *ytilt,
+				       GdkModifierType *mask);
+</verb></tscreen>
+
+Lorsque l'on appelle cette fonction, on doit préciser l'ID du périphérique
+ainsi que la fenêtre. Habituellement, on aura obtenu cet ID par le champ
+<em/deviceid/ d'une structure d'événement. Cette fonction retournera une valeur
+cohérente lorsque les événements ne sont pas autorisés (dans ce cas,
+<em/event->deviceid/ aura la valeur <em/GDK_CORE_POINTER/).
+
+La structure de base des gestionnaires d'événements de déplacement et de bouton
+pressé ne change donc pas trop -- il faut juste ajouter le code permettant de
+traiter l'information supplémentaire.
+
+<tscreen><verb>
+static gint
+button_press_event (GtkWidget *widget, GdkEventButton *event)
+{
+  print_button_press (event->deviceid);
+  
+  if (event->button == 1 &amp;&amp; pixmap != NULL)
+    draw_brush (widget, event->source, event->x, event->y, event->pressure);
+
+  return TRUE;
+}
+
+static gint
+motion_notify_event (GtkWidget *widget, GdkEventMotion *event)
+{
+  gdouble x, y;
+  gdouble pressure;
+  GdkModifierType state;
+
+  if (event->is_hint)
+    gdk_input_window_get_pointer (event->window, event->deviceid,
+				  &amp;x, &amp;y, &amp;pressure, NULL, NULL, &amp;state);
+  else
+    {
+      x = event->x;
+      y = event->y;
+      pressure = event->pressure;
+      state = event->state;
+    }
+    
+  if (state &amp; GDK_BUTTON1_MASK &amp;&amp; pixmap != NULL)
+    draw_brush (widget, event->source, x, y, pressure);
+  
+  return TRUE;
+}
+</verb></tscreen>
+
+On doit aussi faire quelquechose de cette nouvelle information. Notre nouvelle
+fonction <em/draw_brush()/ dessine avec une couleur différente pour chaque
+<em/event->source/ et change la taille du pinceau selon la pression.
+
+<tscreen><verb>
+/* Dessine un rectangle à l'écran, la taille dépend de la pression,
+   et la couleur dépend du type de périphérique */
+static void
+draw_brush (GtkWidget *widget, GdkInputSource source,
+	    gdouble x, gdouble y, gdouble pressure)
+{
+  GdkGC *gc;
+  GdkRectangle update_rect;
+
+  switch (source)
+    {
+    case GDK_SOURCE_MOUSE:
+      gc = widget->style->dark_gc[GTK_WIDGET_STATE (widget)];
+      break;
+    case GDK_SOURCE_PEN:
+      gc = widget->style->black_gc;
+      break;
+    case GDK_SOURCE_ERASER:
+      gc = widget->style->white_gc;
+      break;
+    default:
+      gc = widget->style->light_gc[GTK_WIDGET_STATE (widget)];
+    }
+
+  update_rect.x = x - 10 * pressure;
+  update_rect.y = y - 10 * pressure;
+  update_rect.width = 20 * pressure;
+  update_rect.height = 20 * pressure;
+  gdk_draw_rectangle (pixmap, gc, TRUE,
+		      update_rect.x, update_rect.y,
+		      update_rect.width, update_rect.height);
+  gtk_widget_draw (widget, &amp;update_rect);
+}
+</verb></tscreen>
+
+<sect2>En savoir plus sur un périphérique
+
+<p>
+Notre programme affichera le nom du périphérique qui a généré chaque appui de
+bouton. Pour trouver le nom d'un périphérique, nous appelons la fonction&nbsp;:
+
+<tscreen><verb>
+GList *gdk_input_list_devices               (void);
+</verb></tscreen>
+
+qui retourne une GList (un type de liste chaînée de la bibliothèque glib) de
+structures GdkDeviceInfo. La structure GdkDeviceInfo est définie de la façon
+suivante&nbsp;:
+
+<tscreen><verb>
+struct _GdkDeviceInfo
+{
+  guint32 deviceid;
+  gchar *name;
+  GdkInputSource source;
+  GdkInputMode mode;
+  gint has_cursor;
+  gint num_axes;
+  GdkAxisUse *axes;
+  gint num_keys;
+  GdkDeviceKey *keys;
+};
+</verb></tscreen>
+
+La plupart de ces champs sont des informations de configuration que l'on peut
+ignorer sauf si l'on implante la sauvegarde de la configuration XInput. Celui
+qui nous intéresse est <em/name/ qui est, tout simplement, le nom que X donne
+au périphérique. L'autre champ, qui n'est pas une information de configuration,
+est <em/has_cursor/. Si <em/has_cursor/ est faux, on doit dessiner notre propre
+curseur, mais puisque nous avons précisé <em/GDK_EXTENSION_EVENTS_CURSOR/, nous
+n'avons pas à nous en préoccuper.
+
+<p>
+Notre fonction <em/print_button_press()/ ne fait parcourir la liste retournée
+jusqu'à trouver une correspondance, puis affiche le nom du périphérique.
+
+<tscreen><verb>
+static void
+print_button_press (guint32 deviceid)
+{
+  GList *tmp_list;
+
+  /* gdk_input_list_devices retourne une liste interne, nous ne devons donc
+    pas la libérer après */
+  tmp_list = gdk_input_list_devices();
+
+  while (tmp_list)
+    {
+      GdkDeviceInfo *info = (GdkDeviceInfo *)tmp_list->data;
+
+      if (info->deviceid == deviceid)
+	{
+	  printf("Bouton pressé sur le périphérique '%s'\n", info->name);
+	  return;
+	}
+
+      tmp_list = tmp_list->next;
+    }
+}
+</verb></tscreen>
+
+Ceci termine les modifications de notre programme « XInputize ». Comme pour la
+première version, le code complet est disponible à l'endroit où vous avez
+obtenu ce didacticiel.
+
+<sect2>Sophistications supplémentaires<label id="sec_Further_Sophistications">
+
+<p>
+Bien que notre programme supporte maintenant XInput, il y manque des
+caractéristiques que l'on souhaite trouver dans les applications
+complètes. D'abord, l'utilisateur ne veut probablement pas avoir à configurer
+ses périphériques à chaque fois qu'il lance le programme et nous devons donc
+lui permettre de sauvegarder la configuration du périphérique. Ceci est réalisé
+en parcourant ce que retourne <em/gdk_input_list_devices()/ et en écrivant la
+configuration dans un fichier.
+
+<p>
+Pour restaurer un état au prochain démarrage du programme, GDK dispose de
+fonctions pour changer la configuration des périphériques&nbsp;:
+
+<tscreen><verb>
+gdk_input_set_extension_events()
+gdk_input_set_source()
+gdk_input_set_mode()
+gdk_input_set_axes()
+gdk_input_set_key()
+</verb></tscreen>
+
+(La liste retournée par <em/gdk_input_list_devices()/ ne doit pas être modifiée 
+directement). Un exemple est donné dans le programme de dessin <em/gsumi/
+(disponible à l'adresse <htmlurl
+url="http://www.msc.cornell.edu/~otaylor/gsumi/"
+name="http://www.msc.cornell.edu/~otaylor/gsumi/">). De plus, ce serait
+pratique d'avoir une méthode standard pour faire cela pour toutes les
+applications. Ceci appartient probablement à un niveau légèrement supérieur à
+GTK, peut-être dans la bibliothèque GNOME.
+
+<p>
+Une autre grosse omission que nous avons mentionnée plus haut est l'absence de
+dessin du curseur. Les plates-formes autres qu'XFree86 n'autorisent pas encore
+l'utilisation simultanée d'un périphérique comme pointeur de base et comme
+pointeur d'une application. Lisez le <url
+url="http://www.msc.cornell.edu/~otaylor/xinput/XInput-HOWTO.html"
+name="XInput-HOWTO"> pour plus d'informations là-dessus. Ceci signifie que les
+applications qui veulent atteindre le plus de monde possible doivent dessiner
+leur propre curseur.
+
+<p>
+Une application qui dessine son propre curseur doit faire deux choses&nbsp;:
+déterminer si le périphérique courant a besoin ou non d'un curseur dessiné et
+déterminer si le périphérique courant est à proximité (si celui-ci est une
+tablette de dessin, il est pratique de faire disparaître le curseur lorsque le
+stylet est en dehors de la tablette. Lorsque le périphérique voit le stylet, on 
+dit qu'il est « à proximité »). La première vérification est faite en
+recherchant dans la liste des périphériques, comme nous l'avons fait pour
+obtenir le nom du périphérique. La deuxième est réalisée en choisissant des
+événements "proximity_out". Une exemple de dessin d'un curseur personnel est
+donné dans le programme <em/testinput/ de la distribution GTK.
+
+
+<sect>Conseils pour l'écriture d'applications GTK
+<p>
+Cette section est simplement un regroupement de lignes de conduites générales
+et sages, ainsi que d'astuces pour créer des applications GTK correctes. Elle
+est totalement inutile pour l'instant car il ne s'agit que d'une phrase :)
+
+Utilisez <em/autoconf/ et <em/automake/ de GNU !  Ce sont vos amis :) J'ai en
+projet de les présenter brièvement ici.
+
+<sect>Contributions
+
+<p>
+Ce document, comme beaucoup d'autres beaux logiciels, a été créé (NdT&nbsp;: et 
+traduit) par des
+volontaires bénévoles. Si vous vous y connaissez sur certains aspects de GTK
+qui ne sont pas encore documentés, soyez gentils de contribuer à ce document.
+
+<p>
+Si vous décidez de contribuer, envoyez-moi (Ian Main) votre texte à
+<tt><htmlurl url="mailto:slow@intergate.bc.ca"
+name="slow@intergate.bc.ca"></tt>. La totalité de ce document est libre et
+tout ajout que vous pourriez y faire doit l'être également. Ainsi, tout le
+monde peut utiliser n'importe quelle partie de vos exemples dans les
+programmes, les copies de ce document peuvent être distribuées à volonté, etc.
+<p>
+Merci.
+
+
+<sect>Remerciements
+<p>
+Je voudrai remercier les personnes suivantes pour leurs contributions à ce texte&nbsp;:
+
+<itemize>
+<item>Bawer Dagdeviren, <tt><htmlurl url="mailto:chamele0n@geocities.com"
+name="chamele0n@geocities.com"></tt> pour le didacticiel sur les menus.
+
+<item>Raph Levien, <tt><htmlurl url="mailto:raph@acm.org"
+name="raph@acm.org"></tt>
+pour <em/bonjour tout le monde/ à la GTK, le placement des widgets et pour sa
+sagesse. Il a aussi généreusement donné un abri à ce didacticiel.
+
+<item>Peter Mattis, <tt><htmlurl url="mailto:petm@xcf.berkeley.edu"
+name="petm@xcf.berkeley.edu"></tt> pour le programme GTK le plus simple et pour
+sa capacité à le faire :)
+
+<item>Werner Koch <tt><htmlurl url="mailto:werner.koch@guug.de"
+name="werner.koch@guug.de"></tt> pour la conversion du texte original en SGML,
+et pour la hiérarchie des classes de widget.
+
+<item>Mark Crichton <tt><htmlurl url="mailto:crichton@expert.cc.purdue.edu"
+name="crichton@expert.cc.purdue.edu"></tt> pour le code de l'usine à menus et
+pour le didacticiel de placement des tables.
+
+<item>Owen Taylor <tt><htmlurl url="mailto:owt1@cornell.edu"
+name="owt1@cornell.edu"></tt> pour la section sur le widget EventBox (et le
+patch de la distribution). Il est aussi responsable des sections sur l'écriture
+de vos propres widgets GTK et de l'application exemple. Merci beaucoup à Owen
+pour toute son aide !
+
+<item>Mark VanderBoom <tt><htmlurl url="mailto:mvboom42@calvin.edu"
+name="mvboom42@calvin.edu"></tt> pour son merveilleux travail sur les widgets
+Notebook, Progress Bar, Dialog et File selection. Merci beaucoup, Mark ! Ton
+aide a été très précieuse.
+
+<item>Tim Janik <tt><htmlurl url="mailto:timj@psynet.net"
+name="timj@psynet.net"></tt> pour son beau travail sur le widget Lists.
+Merci Tim :)
+
+<item>Rajat Datta <tt><htmlurl url="mailto:rajat@ix.netcom.com"
+name="rajat@ix.netcom.com"</tt> pour son excellent travail sur le didacticiel
+sur les Pixmaps.
+
+<item>Michael K. Johnson <tt><htmlurl url="mailto:johnsonm@redhat.com"
+name="johnsonm@redhat.com"></tt> pour ses infos et le code pour les menus.
+
+</itemize>
+<p>
+Et à tous ceux d'entre vous qui ont commenté et aidé à améliorer ce document.
+<p>
+Merci.
+
+<sect>Copyright
+<p>
+Ce didacticiel est  Copyright (C) 1997 Ian Main 
+<p>
+Ce programme est un logiciel libre ; vous pouvez le redistribuer et/ou le
+modifier sous les termes de la licence publique générale GNU telle qu'elle est
+publiée par la Free Software Foundation ; soit la version 2 de la licence, ou
+(comme vous voulez) toute version ultérieure.
+<p>
+Ce programme est distribué dans l'espoir qu'il sera utile, mais SANS AUCUNE
+GARANTIE ; même sans la garantie de COMMERCIALITÉ ou d'ADÉQUATION A UN BUT
+PARTICULIER. Voir la licence publique générale GNU pour plus de détails.
+<p>
+Vous devriez avoir reçu une copie de la licence publique générale GNU avec ce
+programme ; si ce n'est pas le cas, écrivez à la Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+<sect1>Notes du traducteur
+Ce document a été adapté en Français par <url url="mailto:jaco@dotcom.fr"
+name="Éric Jacoboni">. Toute remarque sur cette adaptation sera la bienvenue.
+<p>
+Merci à <url url="mailto:kheops@linux-kheops.com" name="Joël Bernier"> pour
+avoir initié cette adaptation, et à <url url="mailto:vincent@debian.org"
+	    name="Vincent Renardias"> pour sa relecture.
+</article>