GTK+ par l'exemple

Pour vous initier aux joies de la programmation d'interfaces graphiques, plutôt que de faire un catalogue de toutes les fonctions de la bibliothèque, ce qui serait long et vite ennuyeux, je vous propose de construire pas à pas une application : un éditeur de texte. Pas un simple éditeur de texte, histoire de faire le tour des possibilités de GTK+, nous allons y ajouter pas à pas les fonctionnalités suivantes :

• création, ouverture, enregistrement de fichiers textes ;
• possibilité d'ouvrir plusieurs fichiers grâce à une navigation par onglets ;
• ouverture rapide d'un fichier grâce à une liste de fichiers.

Rien d'impressionnant par rapport à un traitement de texte, mais plus évolué et plus pratique qu'un simple éditeur de texte. Ce tutoriel est organisé de façon à ajouter une nouvelle fonctionnalité à chaque étape tout en apprenant à maîtriser un ou plusieurs éléments de GTK+.

Le but de ce tutoriel est d'apprendre à maîtriser GTK+ en partant de zéro, ou presque, en effet avant de vouloir créer une interface graphique, il vaut mieux bien connaître le langage C en mode console. Pour cela je vous renvoie au cours de la rubrique C.

I-C-1. Historique▲

I-C-2. Structure▲

I-C-3. Pourquoi utiliser GTK+ ?▲

I-D-1. Windows▲

I-D-2. Linux▲

gcc -Werror -Wall -W -O2 -ansi -pedantic `pkg-config --cflags --libs gtk+-2.0` *.c

Voici quelques choix qui ont été faits par l'équipe de développement de GTK+ :

• les noms de fonctions sont de la forme gtk_type_du_widget_action, ceci rend les noms des fonctions très explicites, en contrepartie ils peuvent être très longs ;
• tous les objets manipulés sont des GtkWidget, pour que GTK+ vérifie qu'il s'agit du bon type d'objet lors de l'appel à une fonction, chaque type de widget possède une macro de la forme GTK_TYPE_DU_WIDGET à utiliser pour transtyper vos widgets ;
• la gestion des événements qui modifient le comportement de l'application (clic de souris, pression d'une touche du clavier…) se fait grâce à l'utilisation de fonctions de rappel (callback). Pour cela, on connecte les widgets à des fonctions qui seront appelées lorsque l'événement survient.

La POO ou Programmation Orientée Objet est un mode de programmation basée sur des objets. GTK+ utilisant ce principe (2), je vais vous en expliquer les principes de base.
Plutôt que le déroulement du programme soit régi par une suite d'instruction, en POO il est régi par la création, l'interaction et la destruction d'objets, en résumé la vie des objets qui le composent. Un objet est une entité (le parallèle avec la vie courante est simple, un objet pourrait être un ordinateur), en C on pourrait se représenter un objet comme une structure de données.
Un objet est composé de propriétés (ce qui correspond à nos variables) et de méthodes (des fonctions). Pour créer un objet, on fait appel à son constructeur, il s'agit d'une fonction qui a pour but de créer et d'initialiser l'objet. À la fin de sa vie, l'objet doit être détruit, c'est le but du destructeur.
Dans la vie courante, on peut créer des objets complexes à partir de briques de base, il est possible de créer de nouveaux objets en se basant sur un ou plusieurs objets : ce mécanisme est appelé héritage (on parle d'héritage multiple lorsqu'il met en jeu plusieurs objets parents). L'objet ainsi obtenu hérite des propriétés et des méthodes de ses parents tout en pouvant modifier leur comportement et créer ses propres propriétés et méthodes.
Lorsque l'on souhaite créer un patron pour de futures classes, plutôt que de créer une classe de base qui ne sera jamais instanciée, il est possible de créer une interface.
Le dernier concept de POO qui va nous servir dans ce tutoriel est le polymorphisme. Ceci permet à un objet (prenons par exemple camion), de se comporter comme l'un de ses parents (dans le cas du camion, il peut être vu comme un véhicule, au même titre qu'une voiture). Ceci est aussi valable pour des classes implémentant la même interface.
Pour vous initier aux joies de la programmation orientée objet en C, je vous conseille le tutoriel de CGI : POO en C

Un programme qui utilise GTK+ est un programme écrit en C avant tout, il contient donc le code de base de tout programme C :

#include <stdlib.h>

int main (int argc, char **argv)
{
  /* ... */
  return EXIT_SUCCESS;
}

Pour pouvoir utiliser les fonctions de GTK+, il faut bien sûr inclure le fichier d'en-tête correspondant :

#include <gtk/gtk.h>

La première chose à faire est d'initialiser la machinerie GTK+ grâce à la fonction gtk_init :

void gtk_init (int *argc, char ***argv);

Cette fonction reçoit les arguments passés en ligne de commande, ceux qui sont spécifiques à GTK+ sont ensuite retirés de la liste; d'où l'utilisation des pointeurs.
Ensuite, il nous faut créer tous les widgets dont nous avons besoin, si nécessaire modifier leurs paramètres par défaut, les connecter à des fonctions callback et ensuite demander leur affichage (tout ceci sera explicité dans la suite du tutoriel). Une fois la fenêtre principale créée, il suffit de lancer la boucle principale de GTK+ :

void gtk_main (void);

Cette fonction est une boucle sans fin (seule la fonction gtk_main_quit permet d'en sortir) qui se charge de gérer le déroulement de notre programme (affichage des widgets, envoi de signaux…).
Voici donc notre premier programme en C/GTK+ qui ne fait rien :

#include <stdlib.h>
#include <gtk/gtk.h>

int main (int argc, char **argv)
{
  /* Initialisation de GTK+ */
  gtk_init (&argc, &argv);

  /* Creation de la fenetre principale de notre application */

  /* Lancement de la boucle principale */
  gtk_main();
  return EXIT_SUCCESS;
}

En plus de ne rien faire, notre programme ne peut être terminé que de façon brutale (Ctrl+C) puisque nous n'appelons pas la fonction gtk_main_quit.

chapitre1.zip