/* 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 (&argc, &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;
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 gtk_box_pack_start() en lisant la section suivante. Essayez de redimensionner la fenêtre, et observez son comportement.
Juste une remarque : il existe une autre constante utilisable avec 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.

Programmation GTK/Placement des widgets
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 à 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.

Programmation GTK/Théorie des boîtes de placement

La majeure partie du placement est faite 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 : 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é.
Pour créer une nouvelle boîte horizontale, on appelle codice_1, et pour les boîtes verticales, codice_2. Les fonctions codice_3 et codice_4 servent à placer les objets à l'intérieur de ces containers. La fonction codice_3 placera de haut en bas dans une boîte verticale et de gauche à droite dans une boîte horizontale. codice_4 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 codice_3. 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.
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.

Programmation GTK/Détails sur les boîtes