Programmation GTK/Bien débuter
Installation.
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 :
D'autres sources d'informations se trouvent sur http://www.gtk.org/. 
Premier programme.
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.
 #include <gtk/gtk.h>
 int main (int argc, char *argv[])
 GtkWidget *window;
 gtk_init (&argc, &argv);
 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 gtk_widget_show (window);
 gtk_main ();
 return 0;
Vous pouvez compiler le programme ci-dessus à l'aide de la commande :
 gcc base.c -o base `pkg-config --cflags --libs gtk+-2.0`
Les explications concernant les options inhabituelles de compilation seront abordées dans 
../Compilation de Bonjour tout le monde/.
Tous les programmes incluront évidemment le fichier gtk/gtk.h qui déclare les variables, fonctions, structures, etc. qui seront utilisées par votre application GTK.
La ligne :
gtk_init (&argc, &argv);
appelle la fonction 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 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 :
 * --display
 * --debug-level
 * --no-xshm
 * --sync
 * --show-events
 * --no-show-events
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+.
Les deux lignes de code suivantes créent et affichent une fenêtre.
 window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 gtk_widget_show (window);
Le paramètre 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 : on peut ainsi la manipuler facilement.
La fonction gtk_widget_show() informe GTK que l'on a configuré le widget et qu'il peut l'afficher.
La ligne suivante lance la boucle principale de traitement de GTK.
gtk_main ();
gtk_main() est un autre appel que vous verrez dans toute application GTK. Lorsque le contrôle atteint ce point, GTK+ se met en attente d'événements X (clic sur un bouton, ou appui d'une touche, par exemple), de délais écoulés (timeouts) ou d'entrées-sorties fichier. Dans notre exemple simple, cependant, les événements sont ignorés.

Programmation GTK/Bonjour tout le monde
Bon maintenant, écrivons un programme avec un widget (bouton). C'est le classique « Bonjour tout le monde » à la sauce GTK.
 #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 FALSE dans le gestionnaire du signal "delete_event",
 * GTK émettra le signal "destroy". Retourner TRUE 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 TRUE par FALSE et la fenêtre principale sera détruite par
 * un signal « delete_event ». */
 return TRUE;

/* 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 (&argc, &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;

Programmation GTK/Compilation de Bonjour tout le monde