Maintenant que nous connaissons la théorie, clarifions un peu en progressant à travers le programme « Bonjour tout le monde ».
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é.
 void hello (GtkWidget *widget, gpointer *data)
 g_print ("Bonjour tout le monde\n");
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 codice_1, on l'informe que l'on ne veut pas que le signal "destroy" soit émis, afin de laisser notre application tourner. En retournant codice_2, on lui demande d'émettre "destroy" qui appellera à son tour notre gestionnaire du signal "destroy".
 gint delete_event(GtkWidget *widget, GdkEvent *event, gpointer data)
 g_print ("le signal delete_event est survenu.\n");
 return (FALSE); 
Voici une autre fonction de rappel qui ne fait que quitter l'application en appelant codice_3. Il n'y a pas grand chose de plus à dire car elle est plutôt triviale :
 void destroy (GtkWidget *widget, gpointer *data)
 gtk_main_quit ();
Je suppose que vous connaissez la fonction codice_4... oui, comme les autres programmes C, toutes les applications GTK en ont une.
 int main (int argc, char *argv[]) 
La partie qui suit déclare deux pointeurs sur des structures de type codice_5. Ceux-ci sont utilisés plus loin pour créer une fenêtre et un bouton.
 GtkWidget *window;
 GtkWidget *button;
Et revoici notre codice_6. 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 argc et argv pour faire comme si ces paramètres n'avaient jamais existé, laissant notre application analyser les paramètres restants.
 gtk_init (&argc, &argv);
Création d'une nouvelle fenêtre. C'est plutôt classique. La mémoire est allouée pour une structure codice_5 et 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é codice_8 vers la fin de notre programme.
 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
Voici maintenant un exemple de connexion d'un gestionnaire de signal à un objet : 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 codice_2 dans le gestionnaire "delete_event"), ou lorsqu'on utilise l'appel codice_10 en lui passant le widget window comme objet à détruire. Ici, on appelle juste la fonction codice_11 définie ci-dessus avec le paramètre codice_12, ce qui quitte GTK pour nous.
codice_13 et codice_14 sont des macros qui réalisent les conversions et les vérifications de types pour nous. Elles rendent aussi le code plus lisible.
 gtk_signal_connect (GTK_OBJECT (window), "destroy",
 GTK_SIGNAL_FUNC (destroy), NULL);
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 Configuration des attributs des widgets
À nouveau, codice_15 est une macro réalisant la conversion de type.
 gtk_container_border_width (GTK_CONTAINER (window), 10);
Cet appel crée un nouveau bouton. Il alloue l'espace mémoire pour une nouvelle structure codice_5, l'initialise et fait pointer button vers elle. Ce bouton portera le label « Bonjour tout le monde » lorsqu'il sera affiché.
 button = gtk_button_new_with_label ("Bonjour tout le monde");
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 codice_17 soit appelée. On ignore les paramètres et on ne passe donc que la valeur codice_12 à la fonction de rappel codice_17. Évidemment, le signal "clicked" est émis lorsqu'on clique sur le bouton avec la souris.
 gtk_signal_connect (GTK_OBJECT (button), "clicked",
 GTK_SIGNAL_FUNC (hello), NULL);
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 codice_17 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 codice_10 n'accepte que codice_22 comme paramètre, on utilise ici la fonction codice_23 à la place de codice_24.
 gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
 GTK_SIGNAL_FUNC (gtk_widget_destroy),
 GTK_OBJECT (window));
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.
 gtk_container_add (GTK_CONTAINER (window), button);
Maintenant, nous avons tout configuré comme on le souhaitait : 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 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.
 gtk_widget_show(button);
 gtk_widget_show (window);
Bien sûr, on appelle codice_25 qui attendra les événements venant du serveur X et demandera aux widgets d'émettre les signaux lorsque ces événements surviendront.
 gtk_main ();
Enfin, le return final. Il est exécuté lorsque codice_26 est appelé.
 return 0;
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 codice_17 est appelée avec le paramètre codice_12, puis le gestionnaire suivant de ce signal est à son tour appelé. Il appelle la fonction codice_10 en lui passant le widget 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 codice_11 qui ferme simplement GTK.
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 codice_31. S'il retourne codice_1, la fenêtre restera telle quelle et rien ne se passera. Retourner codice_2 forcera GTK à émettre le signal "destroy" qui, bien sûr, appelera la fonction de rappel codice_11 provoquant la sortie du GTK.
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.