File: gtk_tut_fr-2.html

package info (click to toggle)
gtk%2B1.2 1.2.10-18
links: PTS
area: main
in suites: etch, etch-m68k
size: 14,468 kB
ctags: 12,966
sloc: ansic: 137,190; sh: 13,303; makefile: 1,170; perl: 328; awk: 274; lisp: 7
file content (593 lines) | stat: -rw-r--r-- 22,833 bytes
parent folder | download | duplicates (5)
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
<HTML>
<HEAD>
 <META NAME="GENERATOR" CONTENT="SGML-Tools 1.0.9">
 <TITLE>Didacticiel: Bien dbuter</TITLE>
 <LINK HREF="gtk_tut_fr-3.html" REL=next>
 <LINK HREF="gtk_tut_fr-1.html" REL=previous>
 <LINK HREF="gtk_tut_fr.html#toc2" REL=contents>
</HEAD>
<BODY BGCOLOR="#FFFFFF">
<A HREF="gtk_tut_fr-3.html">Page suivante</A>
<A HREF="gtk_tut_fr-1.html">Page prcdente</A>
<A HREF="gtk_tut_fr.html#toc2">Table des matires</A>
<HR NOSHADE>
<H2><A NAME="s2">2. Bien dbuter</A></H2>

<P>La premire chose  faire est, bien sr, de rcuprer les sources de
GTK et de les installer. Vous pouvez en obtenir la dernire version
sur <CODE>ftp.gimp.org</CODE> dans le rpertoire <CODE>/pub/gtk</CODE>. D'autres
sources d'informations se trouvent sur
<CODE>http://www.gimp.org/gtk</CODE>. GTK utilise <EM>autoconf</EM> de GNU
pour se configurer. Lorsque vous l'aurez dtarr, tapez
<EM>./configure --help</EM> pour consulter la liste des options.
<P>Pour commencer notre introduction  GTK, nous dbuterons avec le
programme le plus simple qui soit. Celui-ci crera une fentre de
200x200 pixels et ne pourra se terminer qu'en le tuant  partir du
shell.
<P>
<BLOCKQUOTE><CODE>
<PRE>
#include &lt;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;
}
</PRE>
</CODE></BLOCKQUOTE>
<P>Tous les programmes inclueront videmment le fichier
<CODE>gtk/gtk.h</CODE> qui dclare les variables, fonctions, structures,
etc. qui seront utilises par votre application GTK.
<P>La ligne &nbsp;:
<P>
<BLOCKQUOTE><CODE>
<PRE>
gtk_init (&amp;argc, &amp;argv);
</PRE>
</CODE></BLOCKQUOTE>
<P>appelle la fonction <EM>gtk_init(gint *argc, gchar ***argv)</EM> qui sera
appele dans toutes les applications GTK. Cette fonction configure
certaines choses pour nous, comme l'aspect visuel et les couleurs par
dfaut, puis appelle <EM>gdk_init(gint *argc, gchar ***argv)</EM>.  Cette
dernire initialise la bibliothque pour qu'elle puisse tre utilise,
configure les gestionnaires de signaux par dfaut et vrifie les
paramtres passs  notre application via la ligne de commande en
recherchant l'un des suivants&nbsp;:
<P>
<UL>
<LI> <CODE>--display</CODE></LI>
<LI> <CODE>--debug-level</CODE></LI>
<LI> <CODE>--no-xshm</CODE></LI>
<LI> <CODE>--sync</CODE></LI>
<LI> <CODE>--show-events</CODE></LI>
<LI> <CODE>--no-show-events</CODE></LI>
</UL>
<P>Elle les supprime alors de la liste des paramtres, en laissant tout
ce qu'elle ne reconnat pas pour que notre application l'analyse ou
l'ignore. Ceci cre un ensemble de paramtres standards accepts par
toutes les applications GTK.
<P>Les deux lignes de code suivantes crent et affichent une fentre.
<P>
<BLOCKQUOTE><CODE>
<PRE>
  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_widget_show (window);
</PRE>
</CODE></BLOCKQUOTE>
<P>Le paramtre <CODE>GTK_WINDOW_TOPLEVEL</CODE> prcise que l'on veut que la
fentre cre suive l'aspect et le placement dfinis par le
gestionnaire de fentres. Plutt que de crer une fentre de 0x0, une
fentre sans fentre fille est de 200x200 par dfaut&nbsp;: on peut
ainsi la manipuler facilement.
<P>La fonction <EM>gtk_widget_show()</EM> 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.
<P>
<BLOCKQUOTE><CODE>
<PRE>
gtk_main ();
</PRE>
</CODE></BLOCKQUOTE>
<P><EM>gtk_main()</EM> est un autre appel que vous verrez dans toute
application GTK. Lorsque le contrle atteind ce point, GTK se met en
attente d'vnements X (click sur un bouton, ou appui d'une touche, par
exemple), de timeouts ou d'entres-sorties fichier. Dans notre exemple
simple, cependant, les vnements sont ignors.
<P>
<P>
<H2><A NAME="ss2.1">2.1  Bonjour tout le monde  en GTK</A>
</H2>

<P>OK, crivons un programme avec un widget (bouton). C'est le classique  Bonjour tout le monde   la sauce GTK.
<P>
<BLOCKQUOTE><CODE>
<PRE>

#include &lt;gtk/gtk.h>

    /* fonction de rappel. Dans cet exemple, les paramtres sont ignors...
     *  Les fonctions de rappel sont dtailles 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 fentre soit dtruite. 
     * Utilis pour faire apparatre des botes de dialogue du type
     *  tes-vous sr de vouloir quitter ?  */
    
    /* Remplacez FALSE par TRUE et la fentre principale sera dtruite 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 dclarer les widgets. */

    GtkWidget *window;
    GtkWidget *button;
    
    /* Cette fonction est appele dans toutes les applications GTK. 
     * Les paramtres passs en ligne de commande sont analyss et 
     * retourns  l'application. */

    gtk_init (&amp;argc, &amp;argv);
    
    /* Cration d'une nouvelle fentre. */

    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
    
    /* Lorsque la fentre reoit le signal "delete_event" 
     * (envoy par le gestionnaire de fentres en utilisant l'option
     *  close  ou la barre de titre), on lui demande d'appeler la
     * fonction delete_event() dfinie plus haut. La donne passe en
     * paramtre  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 vnement arrive lorsqu'on appelle gtk_widget_destroy() sur la
     * fentre, 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 fentre. */

    gtk_container_border_width (GTK_CONTAINER (window), 10);
    
    /* Cration 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() dfinie plus haut en lui passant NULL en paramtre. */

    gtk_signal_connect (GTK_OBJECT (button), "clicked",
                        GTK_SIGNAL_FUNC (hello), NULL);
    
    /* Ceci provoquera la destruction de la fentre 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 fentres. */

    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
                               GTK_SIGNAL_FUNC (gtk_widget_destroy),
                               GTK_OBJECT (window));
    
    /* Insertion du bouton dans la fentre (container gtk). */

    gtk_container_add (GTK_CONTAINER (window), button);
    
    /* L'tape finale consiste  afficher ce nouveau widget... */

    gtk_widget_show (button);
    
    /* ... et la fentre. */

    gtk_widget_show (window);
    
    /* Toutes les applications GTK doivent avoir un gtk_main(). 
     * Le droulement du programme se termine l et attend qu'un
     * vnement survienne (touche presse ou vnement souris). */

    gtk_main ();
    
    return 0;
}
</PRE>
</CODE></BLOCKQUOTE>
<P>
<H2><A NAME="ss2.2">2.2 Compilation de  Bonjour tout le monde </A>
</H2>

<P>Supposons que vous avez sauvegard le code prcdent dans un fichier
nomm <EM>bonjour.c</EM>, pour le compiler tapez la commande
suivante&nbsp;:
<P>
<BLOCKQUOTE><CODE>
<PRE>
gcc -Wall -g bonjour.c -o bonjour_monde -L/usr/X11R6/lib \
    -lgtk -lgdk -lglib -lXext -lX11 -lm
</PRE>
</CODE></BLOCKQUOTE>
<P>Les bibliothques invoques ci-dessus doivent toutes tre dans vos
chemins de recherche par dfaut, sinon, ajoutez <CODE>-L&lt;library
directory&gt;</CODE> pour que <EM>gcc</EM> recherche dans ces rpertoires les
bibliothques ncessaires. Sur mon systme Debian GNU/Linux, par exemple,
je dois ajouter <CODE>-L/usr/X11R6/lib</CODE> pour qu'il trouve les
bibliothques X11 (NdT&nbsp;: et c'est pareil sur mon systme Red Hat
Linux...).
<P>L'ordre des bibliothques est important. L'diteur de liens doit
connatre les fonctions d'une bibliothque dont il a besoin avant de
les traiter.
<P>Si vous compilez en utilisant des bibliothques statiques, l'ordre
dans lequel vous listez les bibliothques devient trs
important. L'exemple donn ci-dessus devrait fonctionner dans tous les
cas.
<P>Les bibliothques que l'on utilise sont&nbsp;:
<UL>
<LI>La bibliothque glib (<CODE>-lglib</CODE>), qui contient diverses
fonctions. Seule <EM>g_print()</EM> est utilise dans cet exemple. GTK est
construit au dessus de <EM>glib</EM> et vous aurez donc toujours besoin de
celle-ci. Voir la section concernant 
<A HREF="gtk_tut_fr-17.html#sec_glib">glib</A>
pour plus de dtails.
 </LI>
<LI>La bibliothque GDK (<CODE>-lgdk</CODE>), l'enveloppe de Xlib.
</LI>
<LI>La bibliothque GTK (<CODE>-lgtk</CODE>), la bibliothque des widgets,
construite au dessus de GDK.
</LI>
<LI>La bibliothque Xlib (<CODE>-lX11</CODE> utilise par GDK.
</LI>
<LI>La bibliothque Xext (<CODE>-lXext</CODE>). Cette dernire contient le
code pour les pixmaps en mmoire partage et les autres extensions X.
</LI>
<LI>La bibliothque mathmatique (<CODE>-lm</CODE>).  Elle est utilise pour
diffrentes raisons par GTK.</LI>
</UL>
<P>
<H2><A NAME="ss2.3">2.3 Thorie des signaux et des rappels</A>
</H2>

<P>Avant de voir en dtail le programme  Bonjour tout le monde , nous
parlerons d'abord des vnements et des fonctions de rappel.  GTK est
dirig par les vnements, ce qui signifie qu'il restera inactif dans
<EM>gtk_main</EM> jusqu' ce qu'un vnement survienne et que le contrle
soit pass  la fonction approprie.
<P>Ce passage du contrle est ralis en utilisant le concept de  signal
. Lorsqu'un vnement survient, comme l'appui sur un bouton, le
signal appropri sera  mis  par le widget qui a t press. C'est
de cette faon que GTK ralise la plupart de son travail. Pour qu'un
bouton ralise une action, on configure un gestionnaire de signal pour
capturer ces signaux et appeler la fonction adquate.  Ceci est fait
en utilisant une fonction comme&nbsp;:
<P>
<BLOCKQUOTE><CODE>
<PRE>
gint gtk_signal_connect (GtkObject *object,
                         gchar *name,
                         GtkSignalFunc func,
                         gpointer func_data);
</PRE>
</CODE></BLOCKQUOTE>
<P>O le premier paramtre est le widget qui mettra le signal, et le
deuxime est le nom du signal que l'on souhaite intercepter. Le
troisime paramtre est la fonction que l'on veut appeler quand le
signal est captur, et le quatrime sont les donnes que l'on souhaite
passer  cette fonction.
<P>La fonction spcifie par le troisime paramtre s'appelle une 
fonction de rappel  et doit tre de la forme&nbsp;:
<P>
<BLOCKQUOTE><CODE>
<PRE>
void callback_func(GtkWidget *widget, gpointer *callback_data);
</PRE>
</CODE></BLOCKQUOTE>
<P>O le premier paramtre sera un pointeur vers le widget qui a mis le
signal, et le second un pointeur vers les donnes passes par le
dernier paramtre de la fonction <EM>gtk_signal_connect()</EM> dcrite
plus haut.
<P>Un autre appel utilis dans l'exemple  Bonjour tout le monde  est&nbsp;:
<P>
<BLOCKQUOTE><CODE>
<PRE>
gint gtk_signal_connect_object (GtkObject *object,
                                gchar  *name,
                                GtkSignalFunc func,
                                GtkObject *slot_object);
</PRE>
</CODE></BLOCKQUOTE>
<P><EM>gtk_signal_connect_object()</EM> est la mme chose que
<EM>gtk_signal_connect()</EM> sauf que la fonction de rappel utilise un
seul paramtre&nbsp;: un pointeur vers un objet GTK. Lorsqu'on utilise
cette fonction pour connecter des signaux, le rappel doit tre de
cette forme&nbsp;:
<P>
<BLOCKQUOTE><CODE>
<PRE>
void callback_func (GtkObject *object);
</PRE>
</CODE></BLOCKQUOTE>
<P>O l'objet est d'ordinaire un widget. En gnral, on ne configure pas
de rappels pour <EM>gtk_signal_connect_object</EM>. D'habitude, ceux-ci sont
utiliss pour appeler une fonction GTK acceptant un simple widget ou
objet comme paramtre, comme dans notre exemple.
<P>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 diffrent de paramtres. De nombreuses fonctions de la
bibliothque GTK n'acceptent qu'un simple pointeur vers un
<EM>GtkWidget</EM> comme paramtre et vous pouvez donc  utiliser
<EM>gtk_signal_connect_object()</EM> pour celles-ci, tandis que pour vos
fonctions vous pouvez avoir besoin d'avoir de fournir plus de donnes
aux fonctions de rappel.
<P>
<H2><A NAME="ss2.4">2.4  Bonjour tout le monde  pas  pas</A>
</H2>

<P>Maintenant que nous connaissons la thorie, clarifions un peu en progressant  travers le programme  Bonjour tout le monde .
<P>Voici la fonction de rappel appele lorsque le bouton est  clicked
. Dans notre exemple, on ignore le widget et les donnes mais il
n'est pas difficile de faire quelque chose avec. Le prochain exemple
utilisera le paramtre des donnes pour nous dire quel bouton a t
press.
<P>
<BLOCKQUOTE><CODE>
<PRE>
void hello (GtkWidget *widget, gpointer *data)
{
    g_print ("Bonjour tout le monde\n");
}
</PRE>
</CODE></BLOCKQUOTE>
<P>
<P>Cette fonction de rappel est un peu spciale. L'vnement
"delete_event" survient lorsque le gestionnaire de fentres l'envoie 
l'application. On doit choisir ce qu'il faut faire de ces
vnements. On peut les ignorer, leur donner une rponse, ou
simplement quitter l'application.
<P>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".
<P>
<BLOCKQUOTE><CODE>
<PRE>
gint delete_event(GtkWidget *widget, GdkEvent *event, gpointer data)
{
    g_print ("le signal delete_event est survenu.\n");

    return (FALSE); 
}
</PRE>
</CODE></BLOCKQUOTE>
<P>
<P>Voici une autre fonction de rappel qui ne fait que quitter
l'application en appelant <EM>gtk_main_quit()</EM>.  Il n'y a pas grand
chose de plus  dire car elle est plutt triviale&nbsp;:
<P>
<BLOCKQUOTE><CODE>
<PRE>
void destroy (GtkWidget *widget, gpointer *data)
{
    gtk_main_quit ();
}
</PRE>
</CODE></BLOCKQUOTE>
<P>Je suppose que vous connaissez la fonction <EM>main()</EM>... oui, comme
les autres programmes C, toutes les applications GTK en ont une.
<P>
<BLOCKQUOTE><CODE>
<PRE>
 
int main (int argc, char *argv[]) 
{ 
</PRE>
</CODE></BLOCKQUOTE>
<P>La partie qui suit dclare deux pointeurs sur des structures de type
<EM>GtkWidget</EM>.  Ceux-ci sont utiliss plus loin pour crer une
fentre et un bouton.
<P>
<BLOCKQUOTE><CODE>
<PRE>
    GtkWidget *window;
    GtkWidget *button;
</PRE>
</CODE></BLOCKQUOTE>
<P>Et revoici notre <EM>gtk_init</EM>.  Comme prcdemment, il initialise le toolkit
et analyse les paramtres de la ligne de commande. Il supprime chaque
paramtre reconnu de la liste et modifie <EM>argc</EM> et <EM>argv</EM> pour
faire comme si ces paramtres n'avaient jamais exist, laissant notre
application analyser les paramtres restants.
<P>
<BLOCKQUOTE><CODE>
<PRE>
    gtk_init (&amp;argc, &amp;argv);
</PRE>
</CODE></BLOCKQUOTE>
<P>Cration d'une nouvelle fentre. C'est plutt classique. La mmoire
est alloue pour une structure <EM>GtkWidget</EM> et <EM>window</EM> pointe
donc sur celle-ci. Cela configure une nouvelle fentre, mais celle-ci
ne sera pas affiche tant que l'on n'a pas appel
<EM>gtk_widget_show(window)</EM> vers la fin de notre programme.
<P>
<BLOCKQUOTE><CODE>
<PRE>
    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
</PRE>
</CODE></BLOCKQUOTE>
<P>Voici maintenant un exemple de connexion d'un gestionnaire de signal 
un objet&nbsp;: la fentre. Le signal "destroy" est captur. Il est
mis lorsqu'on utilise le gestionnaire de fentres pour tuer la
fentre (et que l'on retourne TRUE dans le gestionnaire
"delete_event"), ou lorsqu'on utilise l'appel
<EM>gtk_widget_destroy()</EM> en lui passant le widget <EM>window</EM> comme
objet  dtruire.  Ici, on appelle juste la fonction <EM>destroy()</EM>
dfinie ci-dessus avec le paramtre NULL, ce qui quitte GTK pour
nous.
<P><CODE>GTK_OBJECT</CODE> et <CODE>GTK_SIGNAL_FUNC</CODE> sont des macros qui ralisent
les conversions et les vrifications de types pour nous. Elles rendent
aussi le code plus lisible.
<P>
<BLOCKQUOTE><CODE>
<PRE>
    gtk_signal_connect (GTK_OBJECT (window), "destroy",
                        GTK_SIGNAL_FUNC (destroy), NULL);
</PRE>
</CODE></BLOCKQUOTE>
<P>La fonction suivante sert  configurer un attribut d'un objet
container. Elle configure simplement la fentre 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
<A HREF="gtk_tut_fr-14.html#sec_setting_widget_attributes">Configuration des attributs des widgets</A><P> nouveau, <CODE>GTK_CONTAINER</CODE> est une macro ralisant la conversion de type.
<BLOCKQUOTE><CODE>
<PRE>
    gtk_container_border_width (GTK_CONTAINER (window), 10);
</PRE>
</CODE></BLOCKQUOTE>
<P>Cet appel cre un nouveau bouton. Il alloue l'espace mmoire pour une
nouvelle structure GtkWidget, l'initialise et fait pointer <EM>button</EM>
vers elle. Ce bouton portera le label  Bonjour tout le monde 
lorsqu'il sera affich.
<P>
<BLOCKQUOTE><CODE>
<PRE>
    button = gtk_button_new_with_label ("Bonjour tout le monde");
</PRE>
</CODE></BLOCKQUOTE>
<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()</EM> soit
appele. On ignore les paramtres et on ne passe donc que la valeur
NULL  la fonction de rappel <EM>hello()</EM>.  videmment, le signal
"clicked" est mis lorsqu'on clique sur le bouton avec la souris.
<P>
<BLOCKQUOTE><CODE>
<PRE>
    gtk_signal_connect (GTK_OBJECT (button), "clicked",
                        GTK_SIGNAL_FUNC (hello), NULL);
</PRE>
</CODE></BLOCKQUOTE>
<P>On utilisera aussi ce bouton pour quitter notre programme, ce qui
permettra d'illustrer la faon dont le signal "destroy" peut venir
soit du gestionnaire de fentres, soit de notre programme. Quand le
bouton est "clicked" comme cela est dcrit plus haut, il appelle
d'abord la fonction de rappel <EM>hello()</EM> puis celle-ci dans l'ordre
dans lequel elles sont configures. On peut avoir autant de fonctions
de rappel que l'on dsire, elles seront excutes selon leur ordre de
connexion. Puisque la fonction <EM>gtk_widget_destroy()</EM> n'accepte que
<EM>GtkWidget *widget</EM> comme paramtre, on utilise ici la fonction
<EM>gtk_signal_connect_object()</EM>  la place de
<EM>gtk_signal_connect()</EM>.
<P>
<BLOCKQUOTE><CODE>
<PRE>
    gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
                               GTK_SIGNAL_FUNC (gtk_widget_destroy),
                               GTK_OBJECT (window));
</PRE>
</CODE></BLOCKQUOTE>
<P>Voici un appel de placement, qui sera expliqu en dtail plus tard,
mais qui est plutt facile  comprendre. Il indique simplement  GTK
que le bouton doit tre plac dans la fentre o il s'affichera.
<P>
<BLOCKQUOTE><CODE>
<PRE>
 gtk_container_add (GTK_CONTAINER (window), button);
</PRE>
</CODE></BLOCKQUOTE>
<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 fentre o il doit se trouver. On demande alors  GTK de  montrer
 les widgets  l'cran. Le widget <EM>window</EM> est affich en dernier
afin que la fentre entire surgisse d'un coup plutt que voir d'abord
la fentre s'afficher puis ensuite le bouton apparatre 
l'intrieur. Il faut dire qu'avec des exemples simples comme celui-ci,
vous ne ferez pas la diffrence.  
<BLOCKQUOTE><CODE>
<PRE>
 
    gtk_widget_show(button);

    gtk_widget_show (window);
</PRE>
</CODE></BLOCKQUOTE>
<P>Bien sr, on appelle <EM>gtk_main()</EM> qui attendra les vnements
venant du serveur X et demandera aux widgets d'mettre les signaux
lorsque ces vnements surviendront.
<BLOCKQUOTE><CODE>
<PRE>
    gtk_main ();
</PRE>
</CODE></BLOCKQUOTE>

Enfin, le <EM>return</EM> final. Il est excut lorsque <EM>gtk_quit()</EM> est appel.
<BLOCKQUOTE><CODE>
<PRE>
    return 0;
</PRE>
</CODE></BLOCKQUOTE>
<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()</EM> est appele avec le paramtre NULL, puis le gestionnaire
suivant de ce signal est  son tour appel. Il appelle la fonction
<EM>gtk_widget_destroy()</EM> en lui passant le widget <EM>window</EM> comme
paramtre, ce qui provoque la destruction de celui-ci. Ceci
force la fentre  envoyer un signal "destroy", qui est captur  son
tour et appelle notre fonction de rappel <EM>destroy()</EM> qui ferme
simplement GTK.
<P>Une autre faon de procder consiste  utiliser le gestionnaire de
fentres pour dtruire la fentre. Cela provoquera l'mission du
signal "delete_event" qui sera pris en charge par notre gestionnaire
<EM>delete_event()</EM>. S'il retourne FALSE, la fentre restera telle
quelle et rien ne se passera. Retourner TRUE forcera GTK  mettre
le signal "destroy" qui, bien sr, appelera la fonction de rappel
<EM>destroy()</EM> provoquant la sortie du GTK.  
<P> 
On remarquera que ces signaux ne sont pas les mmes que les signaux
systmes Unix et ne sont pas implants en utilisant ceux-ci, bien que
la terminologie employe soit presque identique.
<P>
<P>
<HR NOSHADE>
<A HREF="gtk_tut_fr-3.html">Page suivante</A>
<A HREF="gtk_tut_fr-1.html">Page prcdente</A>
<A HREF="gtk_tut_fr.html#toc2">Table des matires</A>
</BODY>
</HTML>