Licence Informatique 1 - Introduction à GTK

Gtk est programmée en C, on manipule donc des structures et des fonctions C. Néanmoins, la bibliothèque Gtk a la particularité d'être pensée objet. Cela se traduit par le fait que les structures sont définies et organisées de façon hiérarchique, par héritage, qui traduit une relation de spécialisation/généralisation. Cela permet (notamment !) de ne pas avoir à définir plusieurs fois la même chose : une fenêtre de dialogue est une fenêtre particulière, une fenêtre est un objet graphique particulier. Ces trois objets partagent donc des caractéristiques communes (i.e., attributs communs et méthodes communes, ex., paramètre couleur, méthode d'affichage), qui sont définies au niveau de l'objet graphique, qui sont spécialisées et/ou enrichies d'abord au niveau fenêtre (ex., une fenêtre peut contenir différents objets, ce qui n'est pas le cas de tout objet graphique), puis au niveau fenêtre dialogue (ex., qui ne peut pas contenir de menu). L'objet graphique Gtk «de base» s'appelle GtkWidget. Tous les autres types Gtk sont donc des « cas particuliers » (i.e., héritent) de GtkWidget.

• Nommage
  Ne soyez pas effrayés par la syntaxe, considérez-la avec pragmatisme. D'une part, les objets (ou types) s'appellent tous « GtkQuelquechose » où Quelquechose est le mot anglais permettant de désigner la structure implémentée (ex., GtkLabel, GtkButton, GtkWindow,…). De même, les noms des fonctions sont tous de la forme gtk_quelquechose_action : ils sont préfixés par «gtk» ; ils comportent ensuite le type d'objet que la fonction qu'ils désignent concerne («window», «label», «button»,…) ; ils comportent enfin le mot anglais permettant de décrire l'action de la fonction (ex., « gtk_label_set_label » pour affecter le libellé d'un label, « gtk_button_new » pour créer un nouveau bouton, « gtk_window_set_title » pour donner un titre à une fenêtre). Il s'agit là de conventions de nommage classiques (à toujours adopter d'ailleurs !) : par exemple, les fonctions de manipulation de chaînes en C sont bien préfixées par «str» pour «string». Enfin, les noms de constantes obéissent aux mêmes conventions que les noms de fonction, mais sont écrits en caractères majuscules (convention également classique), de sorte à bien les distinguer. Par exemple, « GTK_WINDOW_TOPLEVEL » est une constante concernant le niveau des objets GtkWindow (cette valeur signifie que la fenêtre est une fenêtre principale).

  Quelques précisions : Gtk est construite à partir de la librairie Glib, qu'on utilise donc également. Tout objet Gtk est un objet Glib particulier (Gtk hérite de Glib) et certains objets qu'on sera amené à manipuler sont définis au niveau de Glib. Ces objets et les fonctions qui leur sont associées sont alors préfixés par «g» (et non plus par «gtk»). Par exemple, GObject et G_OBJECT désignent respectivement le type «objet générique Glib» et la macro de conversion de type associée (les macros de conversion de type sont abordées plus loin dans ce document).

• Typage
  La gestion des types par héritage implique quelques précautions de codage. Puisque tout est GtkWidget, on déclarera tous nos objets comme GtkWidget (même si l'on sait que l'on veut définir un label ou une fenêtre) :

  GtkWidget* pFenetre; //déclaration d'un pointeur sur GtkWidget
  

  Mais à la création de l'objet (son instanciation), puisque c'est bien un objet «fenêtre» que l'on souhaite (i.e., disposant des attributs de la structure fenêtre), il faudra faire appel à la fonction de création (constructeur) du type GtkWindow :

  pFenetre = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  

  De plus, si l'on utilise la variable pFenetre dans une fonction spécifique aux fenêtres, on précisera le type de pFenetre à l'appel de la fonction :

  gtk_window_set_title(GTK_WINDOW(pFenetre));
  

  Pour tout objet pObjet et pour tout type, la macro «GTK_QUELQUECHOSE(pObjet)» indique au compilateur qu'il doit considérer pour l'instruction courante la variable pObjet comme un pointeur sur le type QUELQUECHOSE. Vous utilisez déjà ce type de conversions, par exemple :

  • pour obtenir le code ASCII d'une valeur de type «char» ;
  • pour obtenir la partie entière d'une valeur flottante «float x=1.65;» ;
  • pour convertir une variable «int» en une variable «unsigned int» (le premier bit est alors interprété comme une puissance de 2, et non plus comme le signe), etc. :

    printf("Partie entière de %f = %d\$\$n", x, (int)x); // Affiche "Partie entière de 1.65 = 1"
    

• Pointage
  Qu'est-ce qu'un pointeur ? Il s'agit tout simplement d'une variable qui encode une adresse. Alors, pourquoi est-ce que l'on doit préciser le type d'objet pointé lorsque l'on déclare un pointeur, autrement dit, qu'est-ce qui différencie

  int* p;
  

  de

  float* p;
  

  En fait, du point de vue du contenu de la variable p, cela n'a pas d'incidence : p prend la place nécessaire au stockage d'une adresse mémoire (soit d'un entier) et contiendra donc toujours un entier. En revanche, le compilateur doit savoir, lorsque l'on fait référence non plus à p, mais à l'objet pointé par p, comment lire/traiter cet objet. L'objet pointé par p, désigné par *p, est ce qui est stocké en mémoire à l'adresse p (à partir de la case numéro p, si vous préférez). Selon l'objet codé (un entier, un réel, un tableau, une fenêtre Gtk,…), on n'aura ni le même nombre d'octets à lire, ni la même façon de les interpréter ! Voilà pourquoi on précise le type de la donnée pointée : c'est une façon de déclarer une variable par l'intermédiaire de son adresse.

  En Gtk, on va manipuler des pointeurs sur des types de la librairie Gtk, essentiellement des pointeurs sur le type GtkWidget (en déclaration) qu'il faudra penser ensuite à «convertir» conformément à l'objet qu'ils pointent réellement, et ce en fonction du contexte d'utilisation.

Une fois la fenêtre affichée… que se passe-t-il ? Et si l'utilisateur ferme la fenêtre ?

Poursuivons l'exemple précédent et considérons le programme C suivant :

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

int main(int argc, char** argv)
{
  // Declaration des variables
  GtkWidget* pFenetre;
  // Initialisation de l'environnement gtk
  gtk_init(&argc, &argv);
  // Creation d'une fenêtre
  pFenetre = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  // Titre de la fenêtre
  gtk_window_set_title(GTK_WINDOW(pFenetre), "Ze hello world window...");
  // Affichage de la fenêtre
  gtk_widget_show(pFenetre);
  // (1) /Association de la fonction gtk_main_quit au signal destroy de la fenêtre
  gtk_signal_connect(GTK_OBJECT(pFenetre), "destroy", G_CALLBACK(gtk_main_quit), NULL);
  // Lancement de la boucle événementielle
  gtk_main();
  return EXIT_SUCCESS;
}

Il a le même effet que le code précédent… à la différence près qu'ici, lorsque l'on ferme la fenêtre, on quitte l'application.

1. gtk_signal_connect(GTK_OBJECT(pFenetre), "destroy", G_CALLBACK(gtk_main_quit), NULL);

   C'est la fonction gtk_signal_connect qui permet d'associer une fonction de callback (troisième argument, ici, la fonction gtk_main_quit) à un objet graphique (premier argument, ici, pFenetre), qui est appelée lorsqu'un certain signal donné (deuxième argument, ici, "destroy") est émis par cet objet. Ainsi, dès que la fenêtre pointée par pFenetre émet le signal "destroy" (si l'on clique sur le coin Nord-Est de la fenêtre par exemple), la boucle événementielle capte celui-ci. Elle regarde alors si une action est attachée à l'objet émetteur pour ce signal. Ici, c'est le cas : la fonction gtk_main_quit est attachée à pFenetre pour le signal de destruction. On appelle alors cette fonction… ce qui a pour effet, en l'occurrence, de quitter la boucle événementielle et donc, l'application.

La fonction gtk_signal_connect est définie au niveau du type GtkObject. Par respect de la signature de la fonction, il faut penser à préciser :

• que l'objet passé en paramètre est un GtkObject (utilisation de la macro GTK_OBJECT) ;
• que la fonction passée en paramètre est un GCallback de la bibliothèque Glib (utilisation de la macro G_CALLBACK).

Nous verrons plus tard l'usage du dernier paramètre de la fonction gtk_signal_connect (mis à NULL dans cet exemple). Une chose à retenir dès maintenant : chaque type Gtk émet un ensemble de signaux prédéfinis. En effet, à tous ne surviennent pas les mêmes événements : on ne clique pas sur une fenêtre tandis que l'on clique sur un bouton, on ne détruit pas un bouton tandis qu'on détruit une fenêtre. Pour chaque signal défini pour un type d'objet et pour chaque objet de ce type, on peut associer une fonction de callback.

Si dans l'exemple précédent, on a associé au couple (objet pFenetre, signal de destruction) une fonction existante, on peut bien entendu aussi définir de nouvelles fonctions. De nouveau, nous poursuivons l'exemple précédent :

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

// Déclarations de fonctions
void cb_exit();

// Définitions de fonctions

int main(int argc, char** argv)
{
  // Declaration des variables
  GtkWidget* pFenetre;
  // Initialisation de l’environnement gtk
  gtk_init(&argc, &argv);
  // Creation d’une fenêtre
  pFenetre = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  // Titre de la fenêtre
  gtk_window_set_title(GTK_WINDOW(pFenetre), "Ze hello world window...");
  // Affichage de la fenêtre
  gtk_widget_show(pFenetre);
  // (1) Association de la fonction gtk_main_quit au signal destroy de la fenêtre
  //gtk_signal_connect(GTK_OBJECT(pFenetre), "destroy", G_CALLBACK(gtk_main_quit), NULL);
  gtk_signal_connect(GTK_OBJECT(pFenetre), "destroy", G_CALLBACK(cb_exit), NULL);
  // Lancement de la boucle événementielle
  gtk_main();

  return EXIT_SUCCESS;
}

// Callback de destruction associé à la fenêtre
void  cb_exit() {
  gtk_main_quit();
}

Dans cet exemple, on définit une nouvelle fonction « cb_quitter ». Cette fonction a pour effet d'appeler gtk_main_quit(). En associant cette fonction au couple (pFenetre, "destroy"), on obtient exactement le même résultat que dans l'exemple précédent : lorsque la fenêtre pFenetre est détruite, elle émet le signal "destroy" ; la boucle infinie capte ce signal et voit qu'elle doit appeler la fonction cb_quitter ; celle-ci appelle alors gtk_main_quit() et l'on sort de la boucle infinie, puis de l'application.

La seule contrainte pour les fonctions de callback : leur signature. Pour le moment, les fonctions que l'on souhaite associer à un couple (objet, signal) pourront avoir la signature suivante :

• type retour : void (pas de retour)
• arguments : aucun (pas d'argument)

  D'autres types de signatures sont possibles, qui seront vues dans un cours ultérieur.

1. Si l'on commente la ligne «gtk_main_quit();» dans la fonction «cb_quitter», que se passe-t-il ?
2. Si l'on commente la ligne «gtk_signal_connect(…)» dans la fonction «main», que se passe-t-il ?