Cours GTK 2

Dans un premier temps, il faut déclarer un pointeur sur notre objet fenêtre. Bien que nous voulions créer un objet GtkWindow, il faut déclarer un objet GtkWidget.

GtkWidget *pWindow;

Par la suite, quel que soit l'objet à créer, il faudra toujours déclarer un GtkWidget.

Une fois l'objet pWindow déclaré, il faut l'initialiser. Pour cela, une fonction est à notre disposition :

GtkWidget* gtk_window_new(GtkWindowType type);

Le paramètre type définit le type de la fenêtre en cours de création, et peut prendre une des deux valeurs suivantes :

• GTK_WINDOW_TOPLEVEL : pour créer une fenêtre complète avec une zone réservée dans la barre des tâches ;
• GTK_WINDOW_POPUP : pour créer une fenêtre sans aucune décoration (barre de titre, bordure…).

La valeur de retour est le pointeur sur notre nouvel objet fenêtre. Cette fonction est donc à utiliser comme ceci :

pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);

La création de la fenêtre est maintenant terminée.

Un widget n'a pas de fonction spécifique liée à son affichage, mais utilise une fonction de GtkWidget qui est :

void gtk_widget_show(GtkWidget *widget);

Il suffit donc de passer en paramètre le widget que nous voulons afficher, ainsi pour afficher notre fenêtre, la ligne de code est :

gtk_widget_show(pWindow);

Au contraire, pour détruire la fenêtre, la fonction sera :

void gtk_widget_destroy(GtkWidget *widget);

Voici donc le code source complet de notre programme affichant une fenêtre.

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

int main(int argc,char **argv)
{ 
    /* Declaration du widget */
    GtkWidget *pWindow;
    gtk_init(&argc,&argv);
    
    /* Création de la fenêtre */
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    /* Affichage de la fenêtre */
    gtk_widget_show(pWindow);
    /* Destruction de la fenêtre */
    gtk_widget_destroy(pWindow);
    
    return EXIT_SUCCESS;
}

En essayant ce programme, vous ne verrez sûrement pas la fenêtre s'afficher. La raison est simple : la destruction de la fenêtre a lieu tout de suite après son affichage. Nous allons maintenant étudier la théorie de signaux afin que l'application ne se termine qu'au moment où l'utilisateur le demande.

Nous allons maintenant étudier comment faire réagir une application GTK+ aux actions de l'utilisateur.

Dans un premier temps, lorsque l'utilisateur interagit avec l'application (clique sur un bouton, ferme une fenêtre…), le widget concerné émet un signal (par exemple « destroy » lorsque l'on ferme une fenêtre). Chaque widget est associé à un ou plusieurs signaux et permet donc ainsi de programmer toutes les actions possibles.

Ce signal va ensuite être intercepté par une boucle évènementielle qui va vérifier qu'une action spécifique à ce signal et ce widget a bien été définie. Si tel est le cas, la fonction associée sera exécutée. Ce type de fonction s'appelle fonction callback.

Il faut donc créer une fonction callback pour chacun des événements susceptibles d'avoir lieu pendant l'exécution du programme et associer (ou connecter) cette fonction à un signal.

La première étape consiste donc à créer une fonction callback. Dans la majorité des cas, une fonction callback sera de cette forme :

void nom_de_la_fonction(GtkWidget *widget, gpointer data)

Le paramètre widget est le widget qui a émis le signal, et data est une donnée supplémentaire qui peut être utilisée.

Ensuite, pour connecter un signal à une fonction callback, GTK+ utilise une fonction de la bibliothèque GLib qui est :

gulong g_signal_connect(gpointer *object, const gchar *name, GCallback func, gpointer func_data );

Le premier paramètre object, correspond au widget qui émet le signal. Cependant, la variable demandée par g_signal_connect étant de type gpointer* (correspond à void* du C standard) et le widget de type GtkWidget*, il faut convertir ce dernier pour ne pas provoquer d'erreur lors de la compilation. Pour cela GTK+ (ou dans ce cas GLib) fournit une macro de conversion (G_OBJECT) qui sera à utiliser à chaque utilisation de cette fonction.

Le second paramètre name, est le signal qui doit être intercepté par la boucle évènementielle. Dans ce cours, certains signaux seront utilisés dans les exemples, mais la rubrique « En savoir plus » donnera une liste complète des signaux qui peuvent être émis par un widget.

Le troisième paramètre func, définit la fonction callback à associer au signal. Cette fois encore, il faudra utiliser une macro de conversion qui est G_CALLBACK(func).

Le dernier paramètre func_data, permet de spécifier une donnée quelconque à laquelle la fonction callback peut avoir accès pour effectuer son travail correctement.

Une fois que les signaux sont connectés, il faut lancer la boucle évènementielle en appelant cette fonction :

void gtk_main(void);

Cela aura pour effet de faire entrer GTK+ dans une boucle infinie qui ne pourra être stoppée que par l'appel de la fonction de fin de boucle qui est :

void gtk_main_quit(void);

Ces fonctions correspondent au minimum afin de pouvoir créer une application GTK+ correcte. D'autres fonctions permettent une utilisation avancée des signaux et de la boucle évènementielle et seront traitées dans un autre chapitre du cours.

Nous allons maintenant faire en sorte que la fenêtre crée reste visible jusqu'à que l'utilisateur clique sur la croix située à droite de la barre de titre.

La première étape est la déclaration de la fonction callback :

void OnDestroy(GtkWidget *pWidget, gpointer pData);

La seule action que doit faire cette fonction est d'arrêter la boucle évènementielle. La seule instruction à ajouter est donc gtk_main_quit();.

Il faut ensuite connecter le signal « destroy » de la fenêtre à cette fonction :

g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(OnDestroy), NULL);

Et pour terminer, il faut lancer la boucle évènementielle.

gtk_main();

Voici donc le code source complet de notre application affichant une fenêtre.

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

void OnDestroy(GtkWidget *pWidget, gpointer pData);

int main(int argc,char **argv)
{ 
    /* Déclaration du widget */
    GtkWidget *pWindow;
    gtk_init(&argc,&argv);
    
    /* Création de la fenêtre */
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    /* Connexion du signal "destroy" */
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(OnDestroy), NULL);
    /* Affichage de la fenêtre */
    gtk_widget_show(pWindow);
    /* Demarrage de la boucle évènementielle */
    gtk_main();
    
    return EXIT_SUCCESS;
}

void OnDestroy(GtkWidget *pWidget, gpointer pData)
{
    /* Arret de la boucle évènementielle */
    gtk_main_quit();
}

Résultat :

La première fonction étudiée permet de définir la position de la fenêtre avant son affichage. Son prototype est le suivant :

void gtk_window_set_position(GtkWindow* window, GtkWindowPosition position);

Le premier paramètre correspond à la fenêtre dont on veut spécifier la position. Ce paramètre étant de type GtkWindow*, il faudra convertir la fenêtre (de type GtkWidget*) avec la macro GTK_WINDOW.

Le deuxième paramètre est la position que l'on veut donner à la fenêtre. Les valeurs acceptées sont :

• GTK_WIN_POS_NONE : la fenêtre aura une position aléatoire lors de son affichage ;
• GTK_WIN_POS_CENTER : la fenêtre sera centrée à l'écran ;
• GTK_WIN_POS_MOUSE : le coin supérieur droit de la fenêtre correspondra à la position de la souris au moment de l'affichage ;
• GTK_WIN_POS_CENTER_ALWAYS : la fenêtre sera centrée et ne pourra être déplacée ;
• GTK_WIN_POS_CENTER_ON_PARENT : la fenêtre sera centrée par rapport à la fenêtre parente (notion abordée dans le prochain chapitre).

La deuxième fonction est utilisable à tout moment du programme et permet de donner la position exacte de la fenêtre :

void gtk_window_move(GtkWindow *window, gint x, gint y);

Le premier paramètre est toujours la fenêtre dont on veut modifier la position.

Les deux autres paramètres sont la nouvelle position de la fenêtre. Le paramètre x est la position suivante l'axe X (axe horizontal) et le paramètre y, la position suivant l'axe Y (axe vertical). Le type gint est le type int du C.

À l'inverse, pour connaître la position de la fenêtre, il faut utiliser cette fonction :

void gtk_window_get_position(GtkWindow *window, gint *root_x, gint *root_y);

Les paramètres correspondent aux mêmes valeurs que pour la fonction gtk_window_move.

Pour le programme exemple, le plus simple est d'utiliser la première fonction ainsi :

gtk_window_set_position(GTK_WINDOW(pWindow), GTK_WIN_POS_CENTER);

Cette fois-ci, une seule fonction est à notre disposition pour modifier le titre de la fenêtre. Cette dernière est très simple d'utilisation :

void gtk_window_set_title(GtkWindow* window, const gchar* title)

Le deuxième paramètre title est bien entendu le titre que l'on veut donner à la fenêtre (gchar correspond à char en C).

Pour l'exemple, la ligne de code sera :

gtk_window_set_title(GTK_WINDOW(pWindow), "Chapitre I.");

Pour connaître le titre d'une fenêtre, la fonction est :

G_CONST_RETURN gchar* gtk_window_get_title(GtkWindow *window);

La variable qui recevra la valeur de retour de cette fonction devra être de type const gchar*.

La fonction pour définir la taille par défaut de la fenêtre est :

void gtk_window_set_default_size(GtkWindow* window, gint width, gint height);

Le paramètre width est la largeur de la fenêtre tandis que le paramètre height est sa hauteur.

Pour notre exemple, la ligne de code sera :

gtk_window_set_default_size(GTK_WINDOW(pWindow), 320, 200);

Et très logiquement, la fonction pour connaître la taille par défaut de la fenêtre est :

void gtk_window_get_default_size(GtkWindow *window, gint *width, gint *height);

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

void OnDestroy(GtkWidget *pWidget, gpointer pData);

int main(int argc,char **argv)
{
    /* Déclaration du widget */
    GtkWidget *pWindow;
    gtk_init(&argc,&argv);
    
    /* Création de la fenêtre */
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    /* Définition de la position */
    gtk_window_set_position(GTK_WINDOW(pWindow), GTK_WIN_POS_CENTER);
    /* Définition de la taille de la fenêtre */
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 320, 200);
    /* Titre de la fenêtre */
    gtk_window_set_title(GTK_WINDOW(pWindow), "Chapitre I.");
    /* Connexion du signal "destroy" */
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(OnDestroy), NULL);
    /* Affichage de la fenêtre */
    gtk_widget_show(pWindow);
    /* Démarrage de la boucle évènementielle */
    gtk_main();
    
    return EXIT_SUCCESS; 
}

void OnDestroy(GtkWidget *pWidget, gpointer pData)
{
    /* Arrêt de la boucle évènementielle */
    gtk_main_quit();
}

Résultat :

Prototypes fonctions callback :

• activate-default

   

  Sélectionnez

  void user_function(GtkWindow *window, gpointer user_data);

• activate-focus

   

  Sélectionnez

  void user_function(GtkWindow *window, gpointer user_data);

• frame-event

   

  Sélectionnez

  gboolean user_function(GtkWindow *window, GdkEvent *event, gpointer user_data);

• keys-changed

   

  Sélectionnez

  void user_function(GtkWindow *window, gpointer user_data);

• move-focus

   

  Sélectionnez

  void user_function(GtkWindow *window, GtkDirectionType arg1, gpointer user_data);

• set-focus

void user_function(GtkWindow *window, GtkWidget *widget, gpointer user_data);

void gtk_window_set_resizable(GtkWindow *window, gboolean resizable);

Permet de définir si l'utilisateur peut modifier la taille de la fenêtre.

Entrée(s) :

• window : la fenêtre.
• resizable : TRUE si l'on peut modifier la taille, FALSE sinon.

Sortie : rien.

gboolean gtk_window_get_resizable(GtkWindow *window);

Pour savoir si la taille de la fenêtre est modifiable par l'utilisateur.

Entrée(s) :

• window : la fenêtre.

Sortie : TRUE si elle est modifiable, FALSE sinon.

void gtk_window_set_gravity(GtkWindow *window, GdkGravity gravity);

Permet de définir le point d'origine pour le placement de la fenêtre.

Entrée(s) :

• window : la fenêtre

• gravity : le point d'origine. Valeurs possibles :

  • GDK_GRAVITY_NORTH_WEST origine en haut à gauche de l'écran ;
  • GDK_GRAVITY_NORTH origine en haut au milieu de l'écran ;
  • GDK_GRAVITY_NORTH_EAST origine en haut à droite de l'écran ;
  • GDK_GRAVITY_WEST origine au milieu à gauche de l'écran ;
  • GDK_GRAVITY_CENTER origine au milieu de l'écran ;
  • GDK_GRAVITY_EAST origine au milieu à droite de l'écran ;
  • GDK_GRAVITY_SOUTH_WEST origine en bas à gauche de l'écran ;
  • GDK_GRAVITY_SOUTH origine en bas au milieu de l'écran ;
  • GDK_GRAVITY_SOUTH_EAST origine en bas à droite de l'écran ;
  • GDK_GRAVITY_STATIC l'origine est le coin supérieur droit de la fenêtre elle-même.

Sortie : rien.

GdkGravity gtk_window_get_gravity(GtkWindow *window);

Pour obtenir le point d'origine à l'écran.

Entrée(s) :

• window : la fenêtre.

Sortie  GdkGravity (énuméré plus haut).

void gtk_window_set_focus(GtkWindow *window, GtkWidget *focus);

Permet de définir le widget qui aura le focus.

Entrée(s) :

• window : la fenêtre contant le widget.
• focus : le widget à sélectionner.

Sortie : rien.

GtkWidget* gtk_window_get_focus(GtkWindow *window);

Pour connaître le widget qui a le focus.

Entrée(s) :

• window : la fenêtre.

Sortie : un pointeur sur le widget ayant le focus.

void gtk_window_set_default(GtkWindow *window, GtkWidget *default_widget);

Pour définir le widget qui aura le focus par défaut.

Entrée(s) :

• window : la fenêtre contant le widget.
• default_widget : le widget à sélectionner.

Sortie : rien.

void gtk_window_iconify(GtkWindow *window);

Permet de minimiser la fenêtre.

Entrée(s) :

• window : la fenêtre.

Sortie : rien.

void gtk_window_deiconify(GtkWindow *window);

Pour réafficher la fenêtre lorsque celle-ci est minimisée.

Entrée(s) :

• window : la fenêtre.

Sortie : rien.

void gtk_window_maximize(GtkWindow *window);

Permet de maximiser la fenêtre.

Entrée(s) :

• window : la fenêtre.

Sortie : rien.

void gtk_window_unmaximize(GtkWindow *window);

Redonne une fenêtre maximisée sa taille précédente.

Entrée(s) :

• window : la fenêtre.

Sortie : rien.

void gtk_window_set_decorated(GtkWindow *window, gboolean setting);

Pour afficher la barre de titre de la fenêtre.

Entrée(s) :

• window : la fenêtre.
• resizable :TRUE si l'on veut l'afficher, FALSE sinon.

Sortie : rien.

gboolean gtk_window_get_decorated(GtkWindow *window);

Pour savoir si la barre de titre d'une fenêtre est visible.

Entrée(s) :

• window : la fenêtre.

Sortie : TRUE si elle est visible, FALSE sinon.

void gtk_window_resize(GtkWindow *window, gint width, gint height);

Pour définir la nouvelle taille de la fenêtre.

Entrée(s) :

• window : la fenêtre.
• width : largeur.
• height : hauteur.

Sortie : rien.

On crée un pointeur vers la structure GtkWidget.

Dans un premier temps, il faut déclarer le pointeur sur l'objet GtkLabel :

GtkWidget *pLabel;

Ensuite il faut initialiser cet objet. Pour cela, il n'existe qu'une seule fonction :

GtkWidget* gtk_label_new(const char* str);

Le paramètre str n'est autre que la chaîne de caractères qu'il faudra afficher.

Pour notre exemple, la ligne de code sera :

pLabel = gtk_label_new("Hello World!");

Pour pouvoir afficher le texte, il faut insérer le widget pLabel dans la fenêtre principale (widget pWindow). Pour cela, nous allons utiliser le fait que le widget GtkWindow dérive du widget GtkContainer. L'atout principal d'un GtkContainer est, comme son nom le laisse entendre, qu'il peut contenir et afficher un autre widget. Les widgets de ce type sont appelés des conteneurs. Il faudra donc différencier deux types d'objets :

• le widget conteneur (aussi appelé widget parent) ;
• le widget contenu (aussi appelé widget enfant) qui pourra par la suite devenir lui-même un conteneur s'il possède les propriétés de GtkContainer.

Étudions donc maintenant la fonction qui nous servira à insérer un widget dans un widget conteneur :

void gtk_container_add(GtkContainer *container, GtkWidget *widget);

Le premier paramètre, container, est le widget conteneur dans lequel on veut insérer le widget widget qui lui est passé en deuxième paramètre. Le premier paramètre de cette fonction est de type GtkContainer, alors que les widgets conteneurs seront tous de type GtkWidget. Il faudra donc à nouveau utiliser une macro de conversion qui cette fois est GTK_CONTAINER().

Pour notre exemple, la ligne de code sera :

gtk_container_add(GTK_CONTAINER(pWindow), pLabel);

#include <stdlib.h>
#include <gtk/gtk.h>
 
int main(int argc,char **argv)
{
    GtkWidget* pWindow;
    GtkWidget* pLabel;
 
    gtk_init(&argc,&argv);
 
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(pWindow), "Les labels");
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 320, 200);
 
    /* Creation du label */
    pLabel=gtk_label_new("Hello World!");
 
    /* On ajoute le label a l'intérieur de la fenêtre */
    gtk_container_add(GTK_CONTAINER(pWindow), pLabel);
 
    /* Affichage de la fenêtré et de tout ce qu'il contient */
    gtk_widget_show_all(pWindow);
 
    /* Connexion du signal
    /* On appelle directement la fonction de sortie de boucle */
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
    gtk_main();
 
    return EXIT_SUCCESS;
}

Résultat :

Pour vous montrer tout cela, nous allons reprendre l'exemple précédent en remplaçant « Hello Word » par « Texte à afficher », et cela ne marche pas! En effet vous obtenez cela :

Et en plus sur la console, vous avez le message d'erreur suivant :

** (Label2.exe) : WARNING **: Invalid UTF8 string passed to pango_layout_set_text()

Pour afficher du texte, Gtk utilise la librairie Pango qui s'occupe du rendu et de l'affichage du texte. Le but de Pango est de permettre l'internationalisation des applications, et pour cela Pango utilise l'encodage UTF8. Ce charset est codée sur 16 bits, ce qui offre la possibilité d'afficher plus 65000 caractères, permettant ainsi d'afficher des caractères accentués et bien plus (ex. : pour le grec, le chinois…).

Puisque Pango sait faire tout cela, pourquoi le test n'a-t-il pas fonctionné? Et bien, tout simplement parce que votre système d'exploitation n'utilise pas ce charset. Lorsque vous souhaitez afficher « Texte à afficher », Pango va avant tout vérifier l'encodage d'un caractère et si l'un de ces caractères n'est pas correct, Pango va arrêter son processus de rendu et envoyer un message d'erreur.

Le moyen le plus simple pour voir les effets d'une erreur d'encodage est de changer celui de votre navigateur. Modifiez les options de votre navigateur afin d'utiliser l'encodage UNICODE. Cette page web utilisant le charset iso-8859-1, les caractères accentués deviendront des carrés ou autre chose.

Une seule chose s'impose à nous : il faut convertir notre chaîne de caractères en UTF8. Pour cela, il faut utiliser une fonction de Glib qui est :

gchar* g_locale_to_utf8(const gchar *opsysstring, gsize len, gsize *bytes_read, gsize *bytes_written, GError **error);

La valeur de retour est le pointeur sur la chaîne de caractère fraîchement convertie. Si une erreur est survenue lors de la conversion, g_locale_to_utf8 renvoie NULL. Il faudra tout de même libérer le mémoire allouée par cette fonction lorsque la variable ne sera plus utile.

Le premier paramètre opsysstring est la chaîne de caractère à convertir et le second paramètre len correspond à la longueur de la chaîne. Ce paramètre sera en général égal à -1 (on laisse la bibliothèque calculer la longueur toute seule).

Les trois derniers paramètres sont utiles en cas d'erreur lors de la conversion. Tout d'abord bytes_read est le nombre d'octets qui ont été lus dans le texte à convertir, et bytes_writen le nombre d'octets qui ont été écrits dans la nouvelle chaîne de caractères.

Le dernier paramètre error, donne plus de précision en cas d'erreur. Voici la liste des messages d'erreur possibles :

• G_CONVERT_ERROR_NO_CONVERSION ;
• G_CONVERT_ERROR_ILLEGAL_SEQUENCE ;
• G_CONVERT_ERROR_FAILED ;
• G_CONVERT_ERROR_PARTIAL_INPUT ;
• G_CONVERT_ERROR_BAD_URI ;
• G_CONVERT_ERROR_NOT_ABSOLUTE_PATH.

Pour notre exemple, nous n'allons pas utiliser les trois derniers paramètres. En cas d'erreur, il n'y aura donc aucun moyen d'avoir plus de précision sur l'erreur survenue.

#include <stdlib.h>
#include <gtk/gtk.h>
 
int main(int argc,char **argv)
{
    GtkWidget* pWindow;
    GtkWidget* pLabel;
    gchar* sUtf8;
 
    gtk_init(&argc, &argv);
 
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(pWindow), "Les labels II");
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 320, 200);
 
    /* Creation du label avec     g_locale_to_utf8 */
    sUtf8 = g_locale_to_utf8("Texte à afficher", -1, NULL, NULL, NULL);
    pLabel=gtk_label_new(sUtf8);
    g_free(sUtf8);
 
    /* On ajoute le label a l'intérieur de la fenêtre */
    gtk_container_add(GTK_CONTAINER(pWindow), pLabel);
 
    /* Affichage de la fenêtre et de tout ce qu'il contient */
    gtk_widget_show_all(pWindow);
 
    /* Connexion du signal
    /* On appelle directement la fonction de sortie de boucle */
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
    gtk_main();
 
    return EXIT_SUCCESS;
}

Résultat :

Une fois encore, nous allons utiliser les propriétés de Pango (même si nous n'allons pas utiliser les fonctions de Pango directement).

Pour définir le format du texte, il suffit d'insérer des balises à l'intérieur même de notre texte. Pango s'occupe ensuite de rechercher les balises puis de formater le texte à notre convenance.

Les balises rapides servent à mettre le texte en gras, italique ou autre de manière très simple. Voici l'intégralité de ces balises :

Pour utiliser ces balises, il suffit d'encadrer le texte à modifier des balises de formatage. Par exemple, pour mettre le texte en gras, il faudra entrer : « Normal vs <b>Gras</b> ».

Mais cela ne suffit pas, il faut aussi dire que le texte utilise les balises Pango, ce qui est possible avec la fonction suivante :

void gtk_label_set_use_markup(GtkLabel *label, gboolean setting);

Il faut mettre le paramètre setting à TRUE, et le texte sera alors formaté en conséquence.

Un autre moyen de spécifier l'utilisation des balises est d'utiliser cette fonction :

void gtk_label_set_markup(GtkLabel *label, const gchar *str);

Cette fonction dit à Pango qu'il faut utiliser les balises, mais elle modifie aussi le label en affichant la chaîne de caractères str (deuxième paramètre).

Cette fois-ci, nous allons étudier la balise <span> en détail. Avec celle-ci, nous allons pouvoir changer la police de caractères, la couleur du texte et bien d'autres choses.

Cette balise s'utilise comme les précédentes si ce n'est qu'elle accepte des paramètres. Le tableau ci-dessous présente tous les paramètres et les effets sur le texte.

Tous ces paramètres peuvent être mis à l'intérieur d'une seule balise <span>.

Maintenant, nous allons voir comment aligner notre texte, lorsque celui-ci comporte plusieurs lignes. Comme d'habitude, GTK+ nous fournit une fonction très simple d'utilisation :

void gtk_label_set_justify(GtkLabel *label, GtkJustification jtype);

Le paramètre jtype correspond à l'alignement du texte et peut prendre une de ces valeurs :

• GTK_JUSTIFY_LEFT pour aligner le texte à gauche (par défaut) ;
• GTK_JUSTIFY_RIGHT pour aligner le texte à droite ;
• GTK_JUSTIFY_CENTER pour centrer le texte ;
• GTK_JUSTIFY_FILL pour justifier le texte.

Au contraire, pour obtenir l'alignement du texte, la fonction est :

GtkJustification gtk_label_get_justify(GtkLabel *label);

#include <stdlib.h>
#include <gtk/gtk.h>
 
int main(int argc,char **argv)
{
    GtkWidget* pWindow;
    GtkWidget* pLabel;
    gchar* sUtf8;
 
    gtk_init(&argc,&argv);
 
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(pWindow),"Les labels III");
    gtk_window_set_default_size(GTK_WINDOW(pWindow),320,200);
 
    /* Creation du label avec g_locale_to_utf8 */
    pLabel=gtk_label_new(NULL);
 
    /* On utilise les balises */
    sUtf8 = g_locale_to_utf8("<span face=\"Courier New\"><b>Courier New 10 Gras</b></span>\n"
        "<span font_desc=\"Times New Roman italic 12\" foreground=\"#0000FF\">Times New Roman 12 Italique</span>\n"
        "<span face=\"Sans\" size=\"16\"><u>Sans 16 Souligné</u></span>",
        -1, NULL, NULL, NULL);
    gtk_label_set_markup(GTK_LABEL(pLabel), sUtf8);
    g_free(sUtf8);
 
    /* On centre le texte */
    gtk_label_set_justify(GTK_LABEL(pLabel), GTK_JUSTIFY_CENTER);
 
     /* On ajoute le label à l'intérieur de la fenêtre */
     gtk_container_add(GTK_CONTAINER(pWindow),pLabel);
 
     /* Affichage de la fenêtre et de tout ce qu'il contient */
    gtk_widget_show_all(pWindow);
 
    /* Connexion du signal
    /* On appelle directement la fonction de sortie de boucle */
    g_signal_connect(G_OBJECT(pWindow),"destroy",G_CALLBACK(gtk_main_quit),0);
 
     gtk_main();
 
    return EXIT_SUCCESS;
}

Résultat :

Dans un premier temps, nous allons déclarer un pointeur vers une structure GtkWidget afin de pouvoir ensuite créer le bouton.

GtkWidget *pQuitBtn;

Ensuite, il faut initialiser le bouton. Pour cela, GTK+ permet l'utilisation de quatre fonctions différentes :

GtkWidget* gtk_button_new(void);
GtkWidget* gtk_button_new_with_label(const gchar *label);
GtkWidget* gtk_button_new_with_mnemonic(const gchar *label);
GtkWidget* gtk_button_new_from_stock(const gchar *stock_id);

La première fonction permet de créer un bouton vide. Cela permet de personnaliser complètement le bouton, car GtkButton dérive de GtkContainer. On peut donc inclure n'importe quel type de widget dans le bouton (label, image…).

La deuxième fonction s'occupe en plus d'insérer un label à l'intérieur du bouton. Le paramètre label correspond au texte à afficher. Comme pour le widget GtkLabel, si un caractère accentué est utilisé, il faudra appeler la fonction g_locale_to_utf8 pour avoir un affichage correct du texte (voir IV. Les labels pour plus de précision).

La troisième fonction ajoute à cela une nouvelle fonctionnalité. Elle permet, en plus d'afficher un label, de faire réagir le bouton à l'aide d'un raccourci clavier. La touche servant de raccourci est spécifiée dans le paramètre label. Il suffit de mettre « _ » devant la lettre souhaitée pour que la combinaison Atl+Touche active le bouton. Par exemple pour l'application de ce chapitre, le texte à afficher sera « Quitter » et si nous voulons que la combinaison de touches Atl+Q permette de quitter l'application, le paramètre label devra être « _Quitter ».

La quatrième fonction permet de créer un bouton avec un label, un raccourci clavier et une image. Cependant, pour faire cela, GTK+ utilise les GtkStockItem qui sont une structure contenant les informations sur le label et l'image à afficher. GTK+ comporte déjà beaucoup de GtkStockItem prédéfinis (en tout cas les plus courants). Le paramètre stock_id est donc l'identifiant du GtkStockItem à utiliser. Pour notre exemple, l'identifiant est GTK_STOCK_QUIT.

Pour cela, nous allons surveiller le signal « clicked » qui est émis lorsque l'utilisateur clique sur le bouton. Lorsque ce signal est reçu, nous allons appeler gtk_main_quit pour fermer l'application et détruire tous les widgets. La ligne de code est donc :

g_signal_connect(G_OBJECT(pQuitBtn), "clicked", G_CALLBACK(gtk_main_quit), NULL);

Comme pour le chapitre précédent, on utilise la fonction gtk_container_add pour insérer le bouton dans la fenêtre et gtk_widget_show_all pour afficher le tout.

#include <stdlib.h>
#include <gtk/gtk.h> 
#define EXEMPLE_1 0
#define EXEMPLE_2 1
#define EXEMPLE_3 2
void AddBtn(GtkWidget *pWindow, gint iExemple);
int main(int argc, char **argv)
{ 
    GtkWidget* pWindow;
    gtk_init(&argc, &argv);
    /* Creation de la fenetre */
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 320 ,200); 
 
    /* Connexion du signal "destroy" de la fenêtre */
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
    /* Insertion du bouton */
    AddBtn(pWindow, EXEMPLE_1);
    /* Affichage de la fenêtre */
    gtk_widget_show_all(pWindow); 
    /* Demarrage de la boucle évènementielle */
    gtk_main();
    return EXIT_SUCCESS; 
}
/*
  void AddBtn(GtkWidget *pWindow, gint iExemple)
  
  Fonction en charge d'insérer le bouton dans la fenêtre
 
  Parametre :
  - pWindow : fenetre parente
  - iExemple : mode de création 
  EXEMPLE_1 pour un bouton label
  EXEMPLE_2 pour un bouton EXEMPLE_1 + raccourci
  EXEMPLE_3 pour un bouton EXEMPLE_2 + image
*/
void AddBtn(GtkWidget *pWindow, gint iExemple)
{
    GtkWidget *pQuitBtn;
    switch(iExemple)
    {
    default:
    case EXEMPLE_1:
        /* Bouton avec un label */
        pQuitBtn = gtk_button_new_with_label("Quitter");
        gtk_window_set_title(GTK_WINDOW(pWindow), "Les boutons - Exemple 1");
        break;
    case EXEMPLE_2:
        /* Bouton avec un label et un raccourci */
        pQuitBtn = gtk_button_new_with_mnemonic("_Quitter");
        gtk_window_set_title(GTK_WINDOW(pWindow), "Les boutons - Exemple 2");
        break;
    case EXEMPLE_3:
        /* Bouton avec un label, un raccourci et une image */
        pQuitBtn = gtk_button_new_from_stock(GTK_STOCK_QUIT);
        gtk_window_set_title(GTK_WINDOW(pWindow), "Les boutons - Exemple 3");
        break;
    }
    /* Connexion du signal "clicked" du bouton */
    g_signal_connect(G_OBJECT(pQuitBtn), "clicked", G_CALLBACK(gtk_main_quit), NULL);
    /* Insertion du bouton dans la fenêtre */
    gtk_container_add(GTK_CONTAINER(pWindow), pQuitBtn);
}

Résultat :

iExemple = EXEMPLE_1

iExemple = EXEMPLE_2

iExemple = EXEMPLE_3

Prototypes fonctions callback :

• activate

  • Ce signal est émis lorsque le bouton a le focus et que l'on appuie sur la touche « Enter ».

     

    Sélectionnez

    void user_function(GtkButton *button, gpointer user_data);

• enter

  • Ce signal est émis lorsque le pointeur de la souris entre dans la zone du bouton.

     

    Sélectionnez

    void user_function(GtkButton *button, gpointer user_data);

• leave

  • Ce signal est émis lorsque le pointeur de la souris quitte la zone du bouton.

     

    Sélectionnez

    void user_function(GtkButton *button, gpointer user_data);

• pressed

  • Ce signal est émis au moment où l'on appuie sur le bouton.

     

    Sélectionnez

    void user_function(GtkButton *button, gpointer user_data);

• released

  • Ce signal est émis au moment où l'on relâche le bouton.

void user_function(GtkButton *button, gpointer user_data);

void gtk_button_pressed(GtkButton *button);

Emet le signal « pressed » pour le GtkButton concerné.

Entrée(s) :

• button : le bouton.

Sortie : rien.

void gtk_button_released(GtkButton *button);

Emet le signal « released » pour le GtkButton concerné.

Entrée(s) :

• button :le bouton.

Sortie : rien.

void gtk_button_clicked(GtkButton *button);

Emet le signal « clicked » pour le GtkButton concerné.

Entrée(s) :

• button : le bouton.

Sortie : rien.

void gtk_button_enter(GtkButton *button);

Emet le signal « enter » pour le GtkButton concerné.

Entrée(s) :

• button : le bouton.

Sortie : rien.

void gtk_button_leave(GtkButton *button);

Emet le signal « leave » pour le GtkButton concerné.

Entrée(s) :

• button : le bouton.

Sortie :rien.

void gtk_button_set_relief(GtkButton *button, GtkReliefStyle newstyle);

Définit le style du bouton.

Entrée(s) :

• button : le bouton.
• newstyle : style du bouton.

• Les différents styles sont :

  • GTK_RELIEF_NORMAL (par défaut) ;
  • GTK_RELIEF_HALF ;
  • GTK_RELIEF_NONE.

Sortie : rien.

GtkReliefStyle gtk_button_get_relief(GtkButton *button);

Récupère le style du bouton.

Entrée(s) :

• button : le bouton.

Sortie : GtkReliefStyle.

void gtk_button_set_label(GtkButton *button, const gchar *label);

Modifie le texte d'un bouton.

Entrée(s) :

• button : le bouton.
• label : le texte à afficher.

Sortie : rien.

G_CONST_RETURN gchar* gtk_button_get_label(GtkButton *button);

Récupère le texte d'un bouton.

Entrée(s) :

• button : le bouton.

Sortie : const gchar*.

gboolean gtk_button_get_use_stock(GtkButton *button);

Pour savoir si un bouton utilise les GtkStockItem.

Entrée(s) :

• button : le bouton.

Sortie : gboolean, TRUE si le bouton utilise un GtkStockItem, FALSE sinon.

void gtk_button_set_use_stock(GtkButton *button, gboolean use_stock);

Définit si le bouton utilise un objet GtkStockItem.

Entrée(s) :

• button : le bouton.
• use_stock : TRUE pour utiliser GtkStockItem, FALSE sinon.

Sortie : rien.

gboolean gtk_button_get_use_underline(GtkButton *button);

Pour savoir si un bouton utilise un raccourci clavier.

Entrée(s) :

• button : le bouton.

Sortie :gboolean, TRUE si le bouton utilise un raccourci, FALSE sinon.

void gtk_button_set_use_underline(GtkButton *button, gboolean use_underline);

Définit le bouton utilise un raccourci clavier.

Entrée(s) :

• button : le bouton.
• use_underline : TRUE pour utiliser le raccourci, FALSE sinon.

Sortie : rien.

Comme toujours, la création de ces widgets est très simple. Les fonctions suivantes permettent de créer respectivement une GtkHBox et une GtkVBox :

GtkWidget* gtk_hbox_new(gboolean homogeneous, gint spacing);
GtkWidget* gtk_vbox_new(gboolean homogeneous, gint spacing);

Le paramètre homogeneous définit si tous les widgets contenus dans la GtkBox utilisent un espace équivalent. C'est-à-dire que si ce paramètre est à TRUE, la zone d'affichage de la GtkBox sera divisée en x zone(s) de taille égale (x étant le nombre de widgets contenus).

Le paramètre spacing permet de définir l'espacement entre chacun des widgets contenus.

Les widgets GtkHBox et GtkVBox n'ont pas de fonctions spécifiques pour l'ajout de widget. Il faut, pour cela, utiliser les fonctions de GtkBox dont dérivent les différents types de box. Les fonctions les plus couramment utilisées sont :

void gtk_box_pack_start(GtkBox* box, GtkWidget* child, gboolean expand, gboolean fill, guint padding);
 
void gtk_box_pack_end(GtkBox* box, GtkWidget* child, gboolean expand, gboolean fill, guint padding);

La première fonction insère les widgets de haut en bas (pour les GtkVBox) ou de gauche à droite (pour les GtkHBox). La seconde fonction fait exactement le contraire, c'est-à-dire, de bas en haut pour les GtkVBox et de droite à gauche pour les GtkHBox.

Le paramètre box est bien entendu la GtkBox dans laquelle on veut insérer le widget child (2e paramètre).

Le paramètre expand n'est utile que si la GtkBox en question n'est pas définie comme homogène (homogeneous=FALSE lors de la création). Dans ce cas, tous les widgets qui auront été insérés avec la valeur expand=TRUE se partageront tout l'espace libre de la GtkBox (les widgets avec expand=FALSE n'utiliseront que l'espace qui leur est nécessaire).

Le paramètre fill permet de définir si le widget enfant occupe toute la zone qui lui est réservée.

Et enfin, le paramètre padding permet d'ajouter de l'espace autour du widget (en plus de celui défini par le paramètre spacing lors de la création de la GtkBox).

Pour vous montrer les effets des différents paramètres, voici un tableau avec des captures d'écran avec différentes configurations :

Pour montrer les possibilités qu'offrent les GtkBox, nous allons créer une fenêtre contenant quatre boutons organisés comme cela :

Maintenant, la question est de savoir comment organiser les différentes GtkBox pour avoir ce résultat. C'est très simple, nous avons besoin de deux GtkBox, la première verticale, la deuxième horizontale. Voici une image qui vous explique comment nous devons organiser nos deux GtkBox :

Ici, en rouge c'est la GtkVBox qui est directement ajoutée à la fenêtre principale. On va y empiler les widgets de haut en bas avec la fonction gtk_box_pack_start. On va tout d'abord placer le « Bouton 1 », ensuite pour pouvoir ajouter les autres boutons de gauche à droite, il faut ajouter la GtkHBox (en bleu), car on ne peut pas le faire avec la GtkVBox puisqu'elle est verticale. On ajoute donc ensuite « Bouton 2 » et « Bouton 3 » dans la GtkHBox, et pour finir, on ajoute « Bouton 4 » dans la GtkVBox.

Voilà, une fois que l'on a compris comment organiser les choses, on peut tout faire.

#include <stdlib.h>
#include <gtk/gtk.h>
 
int main(int argc, char **argv)
{
    GtkWidget *pWindow;
    GtkWidget *pVBox;
    GtkWidget *pHBox;
    GtkWidget *pButton[4];
 
    gtk_init(&argc,&argv);
 
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(pWindow), "Les GtkBox");
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 320, 200);
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
    /* Création de la GtkBox verticale */
    pVBox = gtk_vbox_new(TRUE, 0);
    /* Ajout de la GtkVBox dans la fenêtre */
    gtk_container_add(GTK_CONTAINER(pWindow), pVBox);
 
    /* Creation des boutons */
    pButton[0] = gtk_button_new_with_label("Bouton 1");
    pButton[1] = gtk_button_new_with_label("Bouton 2");
    pButton[2] = gtk_button_new_with_label("Bouton 3");
    pButton[3] = gtk_button_new_with_label("Bouton 4");
 
    /* Ajout de Bouton 1 dans la GtkVBox */
    gtk_box_pack_start(GTK_BOX(pVBox), pButton[0], TRUE, FALSE, 0);
 
    /* Création de la box horizontale */
    pHBox = gtk_hbox_new(TRUE, 0);
 
    /* Ajout de la GtkHBox dans la GtkVBox */
    gtk_box_pack_start(GTK_BOX(pVBox), pHBox, TRUE, TRUE, 0);
 
    /* Ajout des boutons 2 et 3 dans la GtkHBox */
    gtk_box_pack_start(GTK_BOX(pHBox), pButton[1], TRUE, TRUE, 0);
    gtk_box_pack_start(GTK_BOX(pHBox), pButton[2], TRUE, FALSE, 0);
 
    /* Ajout du dernier bouton dans la GtkVBox */
    gtk_box_pack_start(GTK_BOX(pVBox), pButton[3], TRUE, TRUE, 0);
 
    gtk_widget_show_all(pWindow);
 
    gtk_main();
 
    return EXIT_SUCCESS;
}

Résultat :

gboolean gtk_box_get_homogeneous(GtkBox *box);

Utilisée pour savoir si une GtkBox est homogène.

Entrée(s) :

• box : la GtkBox.

Sortie : TRUE si box est homogène, FALSE sinon.

void gtk_box_set_homogeneous(GtkBox *box, gboolean homogeneous);

Utilisée pour définir si une GtkBox est homogène ou pas.

Entrée(s) :

• box : la GtkBox.
• homogeneous : TRUE si l'on veut que box soit homogène, FALSE sinon.

Sortie : rien.

gint gtk_box_get_spacing(GtkBox *box);

Utilisée pour connaître l'espace entre les widgets d'une GtkBox.

Entrée(s) :

• box : la GtkBox.

Sortie : gint.

void gtk_box_set_spacing(GtkBox *box, gint spacing);

Utilisée pour définir l'espacement entre les widgets.

Entrée(s) :

• box : la GtkBox.
• spacing : espace entre les widgets.

Sortie : rien.

La fonction de création est :

GtkWidget* gtk_table_new(guint rows, guint columns, gboolean homogeneous);

Les paramètres rows et columns permettent de définir respectivement le nombre de lignes et de colonnes de la grille. Le paramètre homogeneous quant à lui définit, comme pour une GtkBox, si tous les widgets contenus dans la GtkTable utilisent un espace équivalent.

La première fonction étudiée est :

void gtk_table_attach( GtkTable *table, GtkWidget *child, 
 
    guint left_attach, guint right_attach, 
 
    guint top_attach, guint bottom_attach,
 
    GtkAttachOptions xoptions, GtkAttachOptions yoptions,
 
    guint xpadding, guint ypadding);

À première vue, cette fonction peut apparaître compliquée, mais elle est en réalité très simple. Le paramètre child représente le widget à attacher à la grille, les paramètres left_attach et right_attach, les positions à gauche et à droite du widget et les paramètres top_attach et bottom_attach, les positions supérieures et inférieures du widget.

Les paramètres xoptions et yoptions permettent de spécifier respectivement la façon dont le widget réagit horizontalement et verticalement au redimensionnement de la GtkTable. Ces paramètres peuvent prendre trois valeurs (que l'on peut associer) :

• GTK_EXPAND : spécifie que cette section de la grille s'étirera pour remplir l'espace disponible ;
• GTK_SHRINK : détermine ce qui se produira s'il y a un espace insuffisant pour répondre à la requête de taille du widget enfant, alors le widget se voit attribuer une allocation réduite, ce qui peut entraîner un effet de « bords coupés » ;
• GTK_FILL : spécifie que le widget enfant s'étirera pour remplir l'espace disponible, important que si GTK_EXPAND est défini.

Les deux derniers paramètres xpadding et ypadding définissent l'espace supplémentaire à ajouter aux bords du widget (à droite et à gauche pour le premier, au-dessus et en dessous pour le second).

Regardons maintenant les effets des paramètres xoptions et yoptions suivant différentes valeurs :

La deuxième fonction est :

void gtk_table_attach_defaults(GtkTable *table, GtkWidget *child, 
    guint left_attach, guint right_attach, 
    guint top_attach, guint bottom_attach );

Ceci est la version simplifiée de la première fonction, car elle définit automatiquement les paramètres xoptions et yoptions à GTK_EXPAND | GTK_FILL et les paramètres xpadding et ypadding à 0.

Il est possible de changer la taille de la grille après sa création à l'aide de cette fonction :

void gtk_table_resize(GtkTable *table, guint rows, guint columns);

Le paramètre table est la GtkTable à modifier, et les paramètres rows et columns les nouveaux nombres de lignes et de colonnes.

Ces deux fonctions permettent de changer l'espace d'une ligne ou d'une colonne spécifique :

gtk_table_set_row_spacing(GtkTable *table, guint row, guint spacing);
gtk_table_set_col_spacing(GtkTable *table, guint column, guint spacing);

La première définit l'espace autour d'une ligne tandis que la deuxième fait la même chose pour une colonne.

Celles-ci ont le même rôle que les deux précédentes fonctions, mais agissent sur l'ensemble de la GtkTable :

gtk_table_set_row_spacings(GtkTable *table, guint spacing);
gtk_table_set_col_spacings(GtkTable *table, guint spacing);

Et pour connaître ces espacements, nous avons quatre fonctions différentes :

guint gtk_table_get_row_spacing(GtkTable *table, guint row);
guint gtk_table_get_col_spacing(GtkTable *table, guint column);
guint gtk_table_get_default_row_spacing(GtkTable *table);
guint gtk_table_get_default_col_spacing(GtkTable *table);

Les deux premières fonctions permettent de connaître l'espace entre lignes numéro row (ou la colonne numéro column) et sa suivante. Les deux autres fonctions quant à elles, renvoient la valeur par défaut des espacements, c'est-à-dire la valeur qui sera utilisée au prochain ajout d'un widget.

Nous allons utiliser le même exemple que dans le chapitre sur les GtkBox, pour bien montrer la différence au niveau du code.

#include <stdlib.h>
#include <gtk/gtk.h>
 
int main(int argc, char **argv)
{
    GtkWidget *pWindow;
    GtkWidget *pTable;
    GtkWidget *pButton[4];
 
    gtk_init(&argc, &argv);
 
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 320, 200);
    gtk_window_set_title(GTK_WINDOW(pWindow), "Les GtkTable");
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
    /* Creation et insertion de la table 3 lignes 2 colonnes */
    pTable=gtk_table_new(3,2,TRUE);
    gtk_container_add(GTK_CONTAINER(pWindow), GTK_WIDGET(pTable));
 
    /* Creation des boutons */
    pButton[0]= gtk_button_new_with_label("Bouton 1");
    pButton[1]= gtk_button_new_with_label("Bouton 2");
    pButton[2]= gtk_button_new_with_label("Bouton 3");
    pButton[3]= gtk_button_new_with_label("Bouton 4");
 
    /* Insertion des boutons */
    gtk_table_attach(GTK_TABLE(pTable), pButton[0],
        0, 2, 0, 1,
        GTK_EXPAND | GTK_FILL, GTK_EXPAND,
        0, 0);
    gtk_table_attach_defaults(GTK_TABLE(pTable), pButton[1],
        0, 1, 1, 2);
    gtk_table_attach(GTK_TABLE(pTable), pButton[2],
        1, 2, 1, 2,
        GTK_EXPAND, GTK_EXPAND | GTK_FILL,
        0, 0);
    gtk_table_attach_defaults(GTK_TABLE(pTable), pButton[3],
        0, 2, 2, 3);
 
    gtk_widget_show_all(pWindow);
 
    gtk_main();
 
    return EXIT_SUCCESS;
}

Résultat :

void gtk_table_set_homogeneous( GtkTable *table, gboolean homogeneous );

Permet de définir si la table est homogène ou pas.

Entrée(s) :

• table : la GtkTable.
• homogeneous : TRUE si l'on veut que table soit homogène, FALSE sinon.

Sortie : rien.

gboolean gtk_table_get_homogeneous(GtkTable *table);

Permet de savoir si la table est homogène.

Entrée(s) :

• table : la GtkTable.

Sortie : TRUE si table est homogène, FALSE sinon.

Il faut d'abord avoir le pointeur sur le premier élément de la liste. Pour cela, rien de plus simple :

GSList *premier = NULL;

Ensuite, il n'existe pas de fonction spécifique pour créer la liste, il suffit d'ajouter un élément à la liste. Plusieurs fonctions sont disponibles, mais nous allons en étudier deux.

GSList* g_slist_append(GSList *list, gpointer data);
GSList* g_slist_prepend(GSList *list, gpointer data);

La première g_slist_append ajoute un nouvel élément à la fin de la liste, alors que g_slist_prepend l'ajoute au début de la liste. La variable list est bien sûr la liste chaînée à laquelle on veut ajouter un élément comportant la donnée data. Il suffit de faire un cast pour donner le type de data. Si l'on veut que notre premier élément soit un widget, il suffira d'écrire la ligne de code suivante :

premier = g_slist_append(premier,(GtkWidget*) widget);

La valeur de retour est très importante : elle correspond à l'adresse du premier élément de la liste. En effet, au départ notre élément premier ne pointe nulle part (premier = NULL), il faut donc toujours récupérer cette adresse (surtout dans le cas de g_slist_prepend où le premier élément change).

Là aussi, nous n'allons étudier que deux fonctions :

GSList* g_slist_nth(GSList *list, guint n);
gpointer g_slist_nth_data(GSList *list, guint n);

List est bien sûr la liste à laquelle l'élément recherché appartient, et n est la position de l'élément dans la liste (le premier élément est à n=0). Avec ces deux fonctions, il suffit de connaître la position d'un élément pour récupérer la donnée qu'il contient.

La première fonction renvoie un pointeur sur une variable du type GSList. Il faudra donc utiliser l'opérateur -> pour récupérer la valeur data. La deuxième, par contre, renvoie directement la valeur de data.

Si la valeur donnée à n ne fait pas partie de la liste, la valeur de retour sera NULL.

Supposons qu'une variable de type GtkWidget soit stockée dans le premier élément d'une liste nommé liste, et que l'on veuille récupérer ce widget, il faudra alors coder :

temp_list = g_slist_nth(liste, 0);
widget = (GtkWidget*) (temp_list->data);

Ou

widget = (GtkWidget*) g_slist_nth_data(liste, 0);

Pour supprimer un élément définitivement d'une liste, la fonction à utiliser est la suivante :

GSList* g_slist_remove(GSList *list, gconstpointer data);

Cette fonction cherche le premier élément de la liste contenant la donnée data et le supprime. La valeur de retour est là aussi très importante, car elle correspond (toujours pareil) au nouveau premier élément de la liste. Si par hasard, plusieurs éléments contiennent la donnée data, seul le premier sera supprimé. Dans ce cas, pour tous les supprimer, il faut utiliser cette fonction (dont l'utilisation est identique à la première) :

GSList* g_slist_remove_all(GSList *list, gconstpointer data);

Pour supprimer une liste entière, la fonction est :

void g_slist_free(GSList *list);

Avec toutes ces fonctions, nous en savons suffisamment pour pouvoir utiliser une liste simple.

Là encore, il nous faut un pointeur sur le premier élément de la liste.

GList *premier = NULL;

Comme pour les GList, il n'y a pas de fonction spécifique, il suffit d'ajouter des éléments avec les fonctions suivantes :

GList* g_list_append(GList *list, gpointer data);
GList* g_list_prepend(GList *list, gpointer data);

Les paramètres sont identiques que pour son homologue GSList et la valeur de retour est toujours un pointeur sur le premier élément de la liste.

Une nouvelle fois, les fonctions ressemblent à celles des GSList :

GList* g_list_nth(GList *list, guint n);
gpointer g_list_nth_data(Glist *list, guint n);

Les fonctions de suppression sont toujours semblables :

GList* g_list_remove(GList *list, gconstpointer data);
GList* g_list_remove_all(GList *list, gconstpointer data);
void g_list_free(GList *list);

Bien sûr pour ces deux types de listes, d'autres fonctions existent pour ajouter, déplacer, ordonner, supprimer des éléments. Ces dernières sont (comme à l'accoutumée) dans la section en savoir plus.

Il n'y aura pas dans ce chapitre d'exemple d'utilisation, mais vous pourrez voir l'intérêt particulier de ces deux types de listes dans les chapitres suivants.

GSList* g_slist_insert(GSList *list, gpointer data, gint position);
GList* g_list_insert(GList *list, gpointer data, gint position);

Ajoute un nouvel élément dans une liste à la position demandée.

Entrée(s) :

• list : la liste.
• data : la valeur à ajouter.
• position : la position à laquelle sera ajouté l'élément. Si cette valeur est invalide (négative ou trop grande) l'élément sera ajouté à la fin de la liste.

Sortie : le pointeur sur le premier élément de la liste.

GSList* g_slist_insert_before(GSList *list, GSList *sibling, gpointer data);
GList* g_list_insert_before(GList *list, GList *sibling, gpointer data);

Ajoute un nouvel élément avant un autre élément.

Entrée(s) :

• list : la liste.
• sibling : élément avant lequel doit être insérée notre nouvelle valeur.
• data : valeur à ajouter.

Sortie : le pointeur sur le premier élément de la liste.

GSList* g_slist_remove_link(GSList *list, GSList *link);
GList* g_list_remove_link(GList *list, GList *link);

Supprime un élément d'une liste. L'élément supprimé deviendra le premier d'une nouvelle liste.

Entrée(s) :

• list : la liste.
• link : l'élément à supprimer de la liste.

Sortie : le pointeur sur le premier élément de la liste.

GSList* g_slist_delete_link(GSList *list, GSList *link);
GList* g_list_delete_link(GList *list, GList *link);

Supprime un élément d'une liste.

Entrée(s) :

• list : la liste.
• link : l'élément à supprimer.

Sortie :le pointeur sur le premier élément de la liste.

guint g_slist_length(GSList *list);
guint g_list_length(GList *list);

Pour connaître le nombre d'éléments d'un liste.

Entrée(s) :

• list : la liste.

Sortie : le nombre d'éléments de la liste.

GSList* g_slist_copy(GSList *list);
GList* g_list_copy(GList *list);

Crée une copie d'une liste.

Entrée(s) :

• list : la liste.

Sortie : le pointeur sur le premier élément de la nouvelle liste.

GSList* g_slist_reverse(GSList *list);
GList* g_list_reverse(GList *list);

Inverse les éléments d'une liste

Entrée(s) :

• list : la liste.

Sortie : le pointeur sur le premier élément de la liste.

GSList* g_slist_concat(GSList *list1, GSList *list2);
GList* g_list_concat(GList *list1, GList *list2);

Ajoute une liste à la fin d'une autre.

Entrée(s) :

• list1 : la liste de départ.
• list2 : liste à ajouter à la suite de list1.

Sortie : le pointeur sur le premier élément de la liste.

GList* g_list_first(GList *list);

Pour récupérer le premier élément d'une liste.

Entrée(s) :

• list : la liste.

Sortie : le pointeur sur le premier élément de la liste.

GSList* g_slist_last(GSList *list);
GList* g_list_last(GList *list);

Pour récupérer le dernier élément d'une liste.

Entrée(s) :

• list : la liste.

Sortie : le pointeur sur le dernier élément de la liste.

g_slist_next(list)
g_list_next(list)

Une macro permettant d'obtenir l'élément suivant d'une liste.

Entrée(s) :

• list : la liste.

Sortie : le pointeur sur l'élément suivant ou NULL si l'on est en fin de liste.

g_list_previous(list)

Une macro permettant d'obtenir l'élément précédent d'une liste.

Entrée(s) :

• list : la liste.

Sortie : un pointeur sur l'élément précédent ou NULL si on est en début de liste.

GSList* g_slist_find(GSList *list, gconstpointer data);
GList* g_list_find(GList *list, gconstpointer data);

Récupère l'élément contenant une certaine donnée.

Entrée(s) :

• list : la liste.
• data : la donnée à chercher.

Sortie : un pointeur sur l'élément trouvé ou NULL s'il n'y en a pas.

gint g_slist_position(GSList *list, GSList *llink);
gint g_list_position(GList *list, GList *llink);

Pour connaître la position d'un élément.

Entrée(s) :

• list : la liste.
• llink : l'élément à chercher.

Sortie : la position de l'élément dans la liste ou -1 s'il n'existe pas.

gint g_slist_index(GSList *list, gconstpointer data);
gint g_list_index(GList *list, gconstpointer data);

Pour connaître la position d'un élément contenant une certaine donnée.

Entrée(s) :

• list : la liste.
• data : la donnée à chercher.

Sortie : la position de l'élément dans la liste ou -1 s'il n'existe pas.

Pour créer un GtkEntry, nous avons à notre disposition deux fonctions différentes :

GtkWidget* gtk_entry_new(void);
GtkWidget* gtk_entry_new_with_max_length(gint max);

La première fonction crée un widget GtkEntry de base, tandis que la seconde permet en plus de définir le nombre maximum de caractères que l'utilisateur peut taper (paramètre max de type gint).

Nous allons maintenant comment utiliser les deux fonctions principales de ce widget.

void gtk_entry_set_text(GtkEntry *entry, const gchar *text);
G_CONST_RETURN gchar* gtk_entry_get_text(GtkEntry *entry);

La première fonction nous permet d'insérer du texte dans le GtkEntry. Le paramètre entry correspond bien sur au GtkEntry dans lequel on veut insérer le texte text. À noter, que cette fonction nécessite que entry soit de type GtkEntry*, il faudra donc utiliser la macro de conversion GTK_ENTRY().

La deuxième fonction permet de récupérer le texte qui a été tapé par l'utilisateur dans le GtkEntry entry. La valeur de retour est de type G_CONST_RETURN gchar*, c'est-à-dire qu'il faudra récupérer le texte dans une variable de type const gchar*. De plus, il est inutile d'allouer de la mémoire pour la variable qui va recevoir le texte, et donc de ne surtout pas libérer la mémoire, car cela rendrait votre application instable.

Comme exemple, nous allons créer une fenêtre comportant un GtkEntry, un GtkButton et un GtkLabel. Le but sera d'afficher le texte du GtkEntry dans le GtkLabel. Cette opération s'effectuera lorsque l'utilisateur appuie sur la touche ENTRÉE à la fin de sa saisie (interception du signal « activate ») ou lorsqu'il cliquera sur le GtkButton (interception du signal « clicked »).

Ensuite, les fonctions callback récupèreront le texte du GtkEntry pour l'afficher dans le GtkLabel. Si cette opération ne pose aucun problème pour le signal « activate » du GtkEntry, un problème existe lorsque l'on clique sur le GtkButton.

En effet, pour faire son travail correctement, la fonction callback doit connaître le GtkEntry et le GtkLabel. Dans le cas du signal « activate », le GtkEntry est envoyé en paramètre principal de la fonction callback (widget émetteur du signal) et l'on rajoute le GtkLabel en paramètre supplémentaire. Par contre, pour le signal « clicked », le widget émetteur est le GtkButton et l'on ne pourra passer qu'un seul widget en donnée supplémentaire.

La solution consiste à utiliser les listes du chapitre précédent (VII. Les listes chaînéesLes listes chaînées) ainsi qu'une fonction du widget GtkContainer :

GList* gtk_container_get_children(GtkContainer *container);

Cette fonction crée une liste doublement chaînée contenant tous les widgets qui ont été insérés dans le widget container. Dans notre cas, il nous suffira de passer la GtkBox contenant tous les widgets à la fonction callback pour avoir accès à tout ce dont nous avons besoin.

#include <stdlib.h>
#include <gtk/gtk.h>
 
void on_activate_entry(GtkWidget *pEntry, gpointer data);
void on_copier_button(GtkWidget *pButton, gpointer data);
 
int main(int argc, char **argv)
{
    GtkWidget *pWindow;
    GtkWidget *pVBox;
    GtkWidget *pEntry;
    GtkWidget *pButton;
    GtkWidget *pLabel;
 
    gtk_init(&argc, &argv);
 
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(pWindow), "Le widget GtkEntry");
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 320, 200);
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
    pVBox = gtk_vbox_new(TRUE, 0);
    gtk_container_add(GTK_CONTAINER(pWindow), pVBox);
 
    /* Creation du GtkEntry */
    pEntry = gtk_entry_new();
    /* Insertion du GtkEntry dans la GtkVBox */
    gtk_box_pack_start(GTK_BOX(pVBox), pEntry, TRUE, FALSE, 0);
 
    pButton = gtk_button_new_with_label("Copier");
    gtk_box_pack_start(GTK_BOX(pVBox), pButton, TRUE, FALSE, 0);
 
    pLabel = gtk_label_new(NULL);
    gtk_box_pack_start(GTK_BOX(pVBox), pLabel, TRUE, FALSE, 0);
 
    /* Connexion du signal "activate" du GtkEntry */
    g_signal_connect(G_OBJECT(pEntry), "activate", G_CALLBACK(on_activate_entry), (GtkWidget*) pLabel);
 
    /* Connexion du signal "clicked" du GtkButton */
    /* La donnée supplémentaire est la GtkVBox pVBox */
    g_signal_connect(G_OBJECT(pButton), "clicked", G_CALLBACK(on_copier_button), (GtkWidget*) pVBox);
 
    gtk_widget_show_all(pWindow);
 
    gtk_main();
 
    return EXIT_SUCCESS;
}
 
/* Fonction callback execute lors du signal "activate" */
void on_activate_entry(GtkWidget *pEntry, gpointer data)
{
    const gchar *sText;
 
    /* Recuperation du texte contenu dans le GtkEntry */
    sText = gtk_entry_get_text(GTK_ENTRY(pEntry));
 
    /* Modification du texte contenu dans le GtkLabel */
    gtk_label_set_text(GTK_LABEL((GtkWidget*)data), sText);
}
 
/* Fonction callback executee lors du signal "clicked" */
void on_copier_button(GtkWidget *pButton, gpointer data)
{
    GtkWidget *pTempEntry;
    GtkWidget *pTempLabel;
    GList *pList;
    const gchar *sText;
 
    /* Récupération de la liste des éléments que contient la GtkVBox */
    pList = gtk_container_get_children(GTK_CONTAINER((GtkWidget*)data));
 
    /* Le premier élément est le GtkEntry */
    pTempEntry = GTK_WIDGET(pList->data);
 
    /* Passage à l élément suivant : le GtkButton */
    pList = g_list_next(pList);
 
    /* Passage à l élément suivant : le GtkLabel */
    pList = g_list_next(pList);
 
    /* Cet élément est le GtkLabel */
    pTempLabel = GTK_WIDGET(pList->data);
 
    /* Recuperation du texte contenu dans le GtkEntry */
    sText = gtk_entry_get_text(GTK_ENTRY(pTempEntry));
 
    /* Modification du texte contenu dans le GtkLabel */
    gtk_label_set_text(GTK_LABEL(pTempLabel), sText);
 
    /* Libération de la mémoire utilisée par la liste */
    g_list_free(pList);
}

Résultat :

Généralement, lorsque nous tapons un mot de passe, nous souhaitons que celui-ci reste secret. Le widget GtkEntry permet cela grâce à cette fonction :

void gtk_entry_set_visibility(GtkEntry *entry, gboolean visible);

Il suffit donc de mettre le paramètre visible à FALSE pour cacher le texte qui sera entré.

À l'inverse, pour savoir si le texte entré sera visible ou pas, il faut utiliser cette fonction :

gboolean gtk_entry_get_visibility(GtkEntry *entry);

La valeur de retour sera, bien sûr, égale à TRUE si le texte est visible et à FALSE dans le cas contraire.

Par défaut, lorsque l'on ajoute du texte à un GtkEntry qui a son paramètre visible à FALSE, GTK+ remplacera toutes les lettres par des '*'. Pour modifier celui-ci, il faut utiliser cette fonction :

void gtk_entry_set_invisible_char(GtkEntry *entry, gunichar ch);

Le paramètre ch correspond au caractère de remplacement que nous souhaitons. Celui-ci est de type gunichar qui correspond à l'encodage UCS-4. Bien que l'affichage de GTK+ se fasse avec l'encodage UTF-8, cela ne pose aucun problème, car cette fois-ci, la conversion est faite automatiquement.

Et pour terminer, la fonction permettant de connaître le caractère de remplacement est :

gunichar gtk_entry_get_invisble_char(GtkEntry *entry);

Cette fois, nous allons reprendre l'exemple précédent en activant le mode « mot de passe » et en limitant la saisie à huit caractères. Nous modifierons aussi le caractère de remplacement '*' par '$'.

#include <stdlib.h>
#include <gtk/gtk.h>
 
void on_activate_entry(GtkWidget *pEntry, gpointer data);
void on_copier_button(GtkWidget *pButton, gpointer data);
 
int main(int argc, char **argv)
{
    GtkWidget *pWindow;
    GtkWidget *pVBox;
    GtkWidget *pEntry;
    GtkWidget *pButton;
    GtkWidget *pLabel;
 
    gtk_init(&argc, &argv);
 
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(pWindow), "Le widget GtkEntry");
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 320, 200);
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
    pVBox = gtk_vbox_new(TRUE, 0);
    gtk_container_add(GTK_CONTAINER(pWindow), pVBox);
 
    /* Creation du GtkEntry avec 8 caracteres maximum */
    pEntry = gtk_entry_new_with_max_length(8);
    /* Mode mot de passe */
    gtk_entry_set_visibility(GTK_ENTRY(pEntry), FALSE);
    /* Modification du caractère affiché */
    gtk_entry_set_invisible_char(GTK_ENTRY(pEntry), '$');
    /* Insertion du GtkEntry dans la GtkVBox */
    gtk_box_pack_start(GTK_BOX(pVBox), pEntry, TRUE, FALSE, 0);
 
    pButton = gtk_button_new_with_label("Copier");
    gtk_box_pack_start(GTK_BOX(pVBox), pButton, TRUE, FALSE, 0);
 
    pLabel = gtk_label_new(NULL);
    gtk_box_pack_start(GTK_BOX(pVBox), pLabel, TRUE, FALSE, 0);
 
    /* Connexion du signal "activate" du GtkEntry */
    g_signal_connect(G_OBJECT(pEntry), "activate", G_CALLBACK(on_activate_entry), (GtkWidget*) pLabel);
 
    /* Connexion du signal "clicked" du GtkButton */
    /* La donnée supplémentaire est la GtkVBox pVBox */
    g_signal_connect(G_OBJECT(pButton), "clicked", G_CALLBACK(on_copier_button), (GtkWidget*) pVBox);
 
    gtk_widget_show_all(pWindow);
 
    gtk_main();
 
    return EXIT_SUCCESS;
}
 
/* Fonction callback execute lors du signal "activate" */
void on_activate_entry(GtkWidget *pEntry, gpointer data)
{
    const gchar *sText;
 
    /* Recuperation du texte contenu dans le GtkEntry */
    sText = gtk_entry_get_text(GTK_ENTRY(pEntry));
 
    /* Modification du texte contenu dans le GtkLabel */
    gtk_label_set_text(GTK_LABEL((GtkWidget*)data), sText);
}
 
/* Fonction callback executee lors du signal "clicked" */
void on_copier_button(GtkWidget *pButton, gpointer data)
{
    GtkWidget *pTempEntry;
    GtkWidget *pTempLabel;
    GList *pList;
    const gchar *sText;
 
    /* Recuperation de la liste des éléments que contient la GtkVBox */
    pList = gtk_container_get_children(GTK_CONTAINER((GtkWidget*)data));
 
    /* Le premier élément est le GtkEntry */
    pTempEntry = GTK_WIDGET(pList->data);
 
    /* Passage a l élément suivant : le GtkButton */
    pList = g_list_next(pList);
 
    /* Passage a l élément suivant : le GtkLabel */
    pList = g_list_next(pList);
 
    /* Cet élément est le GtkLabel */
    pTempLabel = GTK_WIDGET(pList->data);
 
    /* Recuperation du texte contenu dans le GtkEntry */
    sText = gtk_entry_get_text(GTK_ENTRY(pTempEntry));
 
    /* Modification du texte contenu dans le GtkLabel */
    gtk_label_set_text(GTK_LABEL(pTempLabel), sText);
 
    /* Liberation de la mémoire utilisée par la liste */
    g_list_free(pList);
}

Résultat :

Prototypes fonctions callback :

• activate

   

  Sélectionnez

  void user_function(GtkEntry *entry, gpointer user_data);

• copy-clipboard

   

  Sélectionnez

  void user_function(GtkEntry *entry, gpointer user_data);

• cut-clipboard

   

  Sélectionnez

  void user_function(GtkEntry *entry, gpointer user_data);

• delete-from-cursor

   

  Sélectionnez

  void user_function(GtkEntry *entry, GtkDeleteType arg1, gint arg2, gpointer user_data);

• insert-at-cursor

   

  Sélectionnez

  void user_function(GtkEntry *entry, gchar *arg1, gpointer user_data);

• move-cursor

   

  Sélectionnez

  void user_function(GtkEntry *entry, GtkMovementStep arg1, gint arg2, gboolean arg3, gpointer user_data);

• paste-clipboard

   

  Sélectionnez

  void user_function(GtkEntry *entry, gpointer user_data);

• populate-popup

   

  Sélectionnez

  void user_function(GtkEntry *entry, GtkMenu *arg1, gpointer user_data);

• toggle-overwrite

void user_function (GtkEntry *entry, gpointer user_data);

void gtk_entry_set_max_length(GtkEntry *entry, gint max);

Définit le nombre maximum de caractères que l'utilisateur peut saisir.

Entrée(s) :

• entry : le GtkEntry.
• max : le nombre de caractères.

Sortie : rien.

gint gtk_entry_get_max_length(GtkEntry *entry);

Récupère le nombre maximum de caractères que l'utilisateur peut saisir.

Entrée(s) :

• entry : le GtkEntry.

Sortie : le nombre maximum de caractères.

Le widget GtkFrame étant très simple, il n'y a qu'une seule fonction de création :

GtkWidget* gtk_frame_new(const gchar *label);

Le paramètre label est tout simplement le texte qui sera affiché en haut à gauche du cadre (position par défaut).

Il peut arriver que dans votre application, le texte du cadre nécessite une modification. Bien entendu, le widget GtkFrame est fourni avec toutes les fonctions nécessaires.

void gtk_frame_set_label(GtkFrame *frame, const gchar *label);

Le paramètre frame est le widget GtkFrame dont nous voulons modifier le texte, et label est le nouveau texte à inscrire. Cette fois encore, il faut utiliser une macro de conversion pour le premier paramètre qui est cette fois GTK_FRAME().

Pour récupérer le texte du GtkFrame, la fonction est :

G_CONST_RETURN gchar* gtk_frame_get_label(GtkFrame *frame);

Les cadres offrent aussi la possibilité de remplacer le texte par un widget quelconque (GtkImage, GtkStockItem…) grâce à cette fonction :

gtk_frame_set_label_widget(GtkFrame *frame, GtkWidget *label_widget);

Et comme toujours, la fonction permettant de connaître le widget affiché:

GtkWidget* gtk_frame_get_label_widget(GtkFrame *frame);

Par défaut, la position du texte est en haut à gauche du cadre, centré en hauteur par rapport à la ligne supérieure. Cela aussi peut être modifié avec cette fonction :

void gtk_frame_set_label_align(GtkFrame *frame, gfloat xalign, gfloat yalign);

Les valeurs xalign et yalign doivent être comprises entre 0.0 et 1.0.

Le paramètre xalign définit la position horizontale du texte. Une valeur de 0.0 positionne le texte à gauche du cadre, tandis qu'une valeur de 1.0 le positionne à droite. Évidemment, une valeur de 0.5 centrera le texte.

Quant à yalign, il permet de définir la position verticale du texte par rapport à la ligne supérieure du cadre. Une valeur de 0.0 mettra le nommeur en dessous de la ligne et une valeur de 1.0 le mettra au-dessus de la ligne.

On peut, bien sûr, connaître les valeurs de positionnement avec les fonctions suivantes :

void gtk_frame_get_label_align(GtkFrame *frame, gfloat *xalign, gfloat *yalign);

Le style du cadre correspond plus à la configuration visuelle des lignes du cadre et plus précisément encore l'ombre des lignes. Cette modification de fait avec cette fonction :

void gtk_frame_set_shadow_type(GtkFrame *frame, GtkShadowType type);

Le paramètre type peut prendre cinq valeurs différentes dont voici la liste avec leurs illustrations :

Et sans surprise, voici la fonction qui permet de connaître le type des lignes :

GtkShadowType gtk_frame_get_shadow_type(GtkFrame *frame);

GtkWidget* gtk_hseparator_new(void);
GtkWidget* gtk_vseparator_new(void);

La première fonction crée une ligne horizontale alors que la deuxième crée une ligne verticale.

Il n'y a rien de plus à propos de ce widget.

Afin de vous montrer l'avantage visuel de l'utilisation des GtkFrame et GtkSeparator, nous allons créer une fenêtre qui demande à l'utilisateur de saisir des informations le concernant (nom, prénom, adresse…).

Voilà à quoi ressemble la fenêtre sans l'utilisation des décorations :

Attention, ce programme ne fait rien du tout, c'est simplement pour montrer la différence entre avec et sans les décorations.

#include <stdlib.h>
#include <gtk/gtk.h>
 
int main(int argc, char **argv)
{
    GtkWidget *pWindow;
    GtkWidget *pVBox;
    GtkWidget *pFrame;
    GtkWidget *pVBoxFrame;
    GtkWidget *pSeparator;
    GtkWidget *pEntry;
    GtkWidget *pLabel;
    gchar *sUtf8;
 
    gtk_init(&argc, &argv);
 
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    /* On ajoute un espace de 5 sur les bords de la fenêtre */
    gtk_container_set_border_width(GTK_CONTAINER(pWindow), 5);
    gtk_window_set_title(GTK_WINDOW(pWindow), "GtkEntry et GtkSeparator");
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 320, 200);
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
    pVBox = gtk_vbox_new(TRUE, 0);
    gtk_container_add(GTK_CONTAINER(pWindow), pVBox);
 
    /* Creation du premier GtkFrame */
    pFrame = gtk_frame_new("Etat civil");
    gtk_box_pack_start(GTK_BOX(pVBox), pFrame, TRUE, FALSE, 0);
 
    /* Creation et insertion d une boite pour le premier GtkFrame */
    pVBoxFrame = gtk_vbox_new(TRUE, 0);
    gtk_container_add(GTK_CONTAINER(pFrame), pVBoxFrame);
 
    /* Creation et insertion des éléments contenus dans le premier GtkFrame */
    pLabel = gtk_label_new("Nom :");
    gtk_box_pack_start(GTK_BOX(pVBoxFrame), pLabel, TRUE, FALSE, 0);
    pEntry = gtk_entry_new();
    gtk_box_pack_start(GTK_BOX(pVBoxFrame), pEntry, TRUE, FALSE, 0);
 
    sUtf8 = g_locale_to_utf8("Prénom :", -1, NULL, NULL, NULL);
    pLabel = gtk_label_new(sUtf8);
    g_free(sUtf8);
    gtk_box_pack_start(GTK_BOX(pVBoxFrame), pLabel, TRUE, FALSE, 0);
    pEntry = gtk_entry_new();
    gtk_box_pack_start(GTK_BOX(pVBoxFrame), pEntry, TRUE, FALSE, 0);
 
    /* Creation d un GtkHSeparator */
    pSeparator = gtk_hseparator_new();
    gtk_box_pack_start(GTK_BOX(pVBoxFrame), pSeparator, TRUE, FALSE, 0);
 
    pLabel = gtk_label_new("Date de naissance :");
    gtk_box_pack_start(GTK_BOX(pVBoxFrame), pLabel, TRUE, FALSE, 0);
    pEntry = gtk_entry_new();
    gtk_box_pack_start(GTK_BOX(pVBoxFrame), pEntry, TRUE, FALSE, 0);
 
    /* Creation du deuxieme GtkFrame */
    pFrame = gtk_frame_new("Domicile");
    gtk_box_pack_start(GTK_BOX(pVBox), pFrame, TRUE, FALSE, 0);
 
    /* Creation et insertion d une boite pour le deuxieme GtkFrame */
    pVBoxFrame = gtk_vbox_new(TRUE, 0);
    gtk_container_add(GTK_CONTAINER(pFrame), pVBoxFrame);
 
    /* Creation et insertion des éléments contenus dans le deuxieme GtkFrame */
    pLabel = gtk_label_new("Adresse :");
    gtk_box_pack_start(GTK_BOX(pVBoxFrame), pLabel, TRUE, FALSE, 0);
    pEntry = gtk_entry_new();
    gtk_box_pack_start(GTK_BOX(pVBoxFrame), pEntry, TRUE, FALSE, 0);
 
    pLabel = gtk_label_new("Adresse :");
    gtk_box_pack_start(GTK_BOX(pVBoxFrame), pLabel, TRUE, FALSE, 0);
    pEntry = gtk_entry_new();
    gtk_box_pack_start(GTK_BOX(pVBoxFrame), pEntry, TRUE, FALSE, 0);
 
    pLabel = gtk_label_new("Code postal :");
    gtk_box_pack_start(GTK_BOX(pVBoxFrame), pLabel, TRUE, FALSE, 0);
    pEntry = gtk_entry_new();
    gtk_box_pack_start(GTK_BOX(pVBoxFrame), pEntry, TRUE, FALSE, 0);
 
    pLabel = gtk_label_new("Ville :");
    gtk_box_pack_start(GTK_BOX(pVBoxFrame), pLabel, TRUE, FALSE, 0);
    pEntry = gtk_entry_new();
    gtk_box_pack_start(GTK_BOX(pVBoxFrame), pEntry, TRUE, FALSE, 0);
 
    /* Creation du troisieme GtkFrame */
    sUtf8 = g_locale_to_utf8("Téléphones", -1, NULL, NULL, NULL);
    pFrame = gtk_frame_new(sUtf8);
    g_free(sUtf8);
    gtk_box_pack_start(GTK_BOX(pVBox), pFrame, TRUE, FALSE, 0);
 
    /* Creation et insertion d une boite pour le troisieme GtkFrame */
    pVBoxFrame = gtk_vbox_new(TRUE, 0);
    gtk_container_add(GTK_CONTAINER(pFrame), pVBoxFrame);
 
    /* Creation et insertion des éléments contenus dans le troisieme GtkFrame */
    pLabel = gtk_label_new("Domicile");
    gtk_box_pack_start(GTK_BOX(pVBoxFrame), pLabel, TRUE, FALSE, 0);
    pEntry = gtk_entry_new();
    gtk_box_pack_start(GTK_BOX(pVBoxFrame), pEntry, TRUE, FALSE, 0);
 
    pLabel = gtk_label_new("Professionnel");
    gtk_box_pack_start(GTK_BOX(pVBoxFrame), pLabel, TRUE, FALSE, 0);
    pEntry = gtk_entry_new();
    gtk_box_pack_start(GTK_BOX(pVBoxFrame), pEntry, TRUE, FALSE, 0);
 
    pLabel = gtk_label_new("Portable");
    gtk_box_pack_start(GTK_BOX(pVBoxFrame), pLabel, TRUE, FALSE, 0);
    pEntry = gtk_entry_new();
    gtk_box_pack_start(GTK_BOX(pVBoxFrame), pEntry, TRUE, FALSE, 0);
 
    gtk_widget_show_all(pWindow);
 
    gtk_main();
 
    return EXIT_SUCCESS;
}

Résultat :

Pour ce widget, il y a toute une panoplie de fonction de création. Nous n'allons en étudier que quelques-unes, car certaines font appel à des notions par encore vues. Voici donc les fonctions étudiées :

GtkWidget* gtk_image_new (void);
GtkWidget* gtk_image_new_from_file(const gchar *filename);
GtkWidget* gtk_image_new_from_stock(const gchar *stock_id, GtkIconSize size);

La première crée une image, mais complètement vide.

La deuxième crée l'image à partir du fichier filename. Gtk+ est capable d'utiliser les images qui sont au format PNG, JPEG, TIFF. Le chemin du fichier filename peut être relatif ou absolu. Si le chemin spécifié est incorrect ou que le format de l'image est invalide, l'image de retour sera celle-ci :

La troisième fonction, récupère l'image qui est associée à un objet GtkStockItem afin de l'afficher. Le paramètre size peut prendre sept valeurs différentes pour définir la taille de l'image à afficher :

Cette étape intervient lorsque vous avez créé une image vide ou lorsque vous voulez changer d'image. Les deux fonctions étudiées ici sont :

void gtk_image_set_from_file(GtkImage *image, const gchar *filename);
void gtk_image_set_from_stock(GtkImage *image, const gchar *stock_id, GtkIconSize size);

Les paramètres sont les mêmes que lors de la création d'un widget GtkImage, sauf qu'il faut préciser à quel widget il faut appliquer l'image.

Notre exemple comprendra deux composants. Tout d'abord une zone ou est affichée l'image, puis un bouton contenant l'image du GtkStockItem GTK_STOCK_QUIT, pour quitter l'application.

#include <stdlib.h>
#include <gtk/gtk.h>
 
int main(int argc, char **argv)
{
    GtkWidget *pWindow;
    GtkWidget *pVBox;
    GtkWidget *pImage;
    GtkWidget *pQuitImage;
    GtkWidget *pQuitBtn;
 
    gtk_init(&argc, &argv);
 
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 320, 200);
    gtk_window_set_title(GTK_WINDOW(pWindow), "GtkImage");
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
    pVBox = gtk_vbox_new(FALSE, 0);
    gtk_container_add(GTK_CONTAINER(pWindow), pVBox);
 
    /* Chargement d'une image à partir d'un fichier */
    pImage = gtk_image_new_from_file("./gtk.png");
    gtk_box_pack_start(GTK_BOX(pVBox), pImage, FALSE, FALSE, 5);
 
    pQuitBtn = gtk_button_new();
    gtk_box_pack_start(GTK_BOX(pVBox), pQuitBtn, TRUE, FALSE, 5);
    g_signal_connect(G_OBJECT(pQuitBtn), "clicked", G_CALLBACK(gtk_main_quit), NULL);
 
    /* Chargement d'une image à partir d'un GtkStockItem */
    pQuitImage = gtk_image_new_from_stock(GTK_STOCK_QUIT, GTK_ICON_SIZE_LARGE_TOOLBAR);
    gtk_container_add(GTK_CONTAINER(pQuitBtn), pQuitImage);
 
    gtk_widget_show_all(pWindow);
 
    gtk_main();
 
    return EXIT_SUCCESS;
}

Résultat :

Comme nous pouvons le voir sur l'image ci-dessus, une boite de dialogue est constituée de trois éléments :

• une GtkVBox globale (en rouge) qui contiendra tous les widgets affichés ;
• une GtkHSeparator (en vert) qui sert de séparation entre la zone de saisie et la zone des boutons ;
• une GtkHBox (en bleu) qui contiendra les boutons de réponse.

On peut donc ainsi distinguer deux zones différentes :

• la zone de travail au-dessus de la GtkHSeparator ;
• la zone de réponse au-dessous de la GtkHSeparator.

La fonction de création est un peu plus complexe que d'habitude :

GtkWidget* gtk_dialog_new_with_buttons(const gchar *title, GtkWindow *parent, GtkDialogFlags flags, const gchar *first_button_text, ...);

Le premier paramètre title n'est autre que le titre de la boite de dialogue.

Le deuxième paramètre parent sert à désigner la fenêtre parente. Cette valeur peut être égale à NULL.

Le troisième paramètre flags permet de définir certains paramètres de la boite de dialogue. Ce paramètre peut prendre trois valeurs différentes :

• GTK_DIALOG_MODAL : créer une boite de dialogue modale, c'est-à-dire que tant que l'utilisateur n'a pas cliqué sur un des boutons de réponse, les autres fenêtres seront figées ;
• GTK_DIALOG_DESTROY_WITH_PARENT : la boite de dialogue est détruite si la fenêtre parente est détruite ;
• GTK_DIALOG_NO_SEPARATOR : la ligne de séparation entre la zone de travail et la zone de réponse n'est pas affichée.

Enfin, le dernier paramètre est plutôt une liste de paramètres permettant de définir les boutons de la boite de dialogue ainsi que les réponses qui leur sont associées. Pour chaque bouton que nous voulons ajouter, il faut définir le texte du bouton et le type de réponse qui sera envoyé lorsque nous cliquerons sur le bouton.

Le texte du bouton peut, comme pour tous les boutons, être un texte normal, un texte avec raccourci (Rappel : c'est de la forme « _Quitter ») ou même un GtkStockItem.

La valeur de la réponse, peut être un élément de type GtkResponseType ou bien une valeur entière positive que nous pouvons définir nous-mêmes. Le plus simple étant bien sûr d'utiliser les valeurs classiques définies par le type GtkResponseType dont voici la liste :

• GTK_RESPONSE_NONE ;
• GTK_RESPONSE_REJECT ;
• GTK_RESPONSE_ACCEPT ;
• GTK_RESPONSE_DELETE_EVENT ;
• GTK_RESPONSE_OK ;
• GTK_RESPONSE_CANCEL ;
• GTK_RESPONSE_CLOSE ;
• GTK_RESPONSE_YES ;
• GTK_RESPONSE_NO ;
• GTK_RESPONSE_APPLY ;
• GTK_RESPONSE_HELP.

Une fois que tous les boutons ont été définis, il faut le dire à notre fonction de création. Pour cela, il suffit de terminer la liste des paramètres par NULL.

La majeure partie des éléments de la boite de dialogue sont maintenant créés. Il reste cependant à ajouter les éléments de la zone de travail pour que la boite soit complète. Une fois que tous les éléments à ajouter dans la zone de travail sont créés, il suffit de les ajouter dans la boite de dialogue avec la fonction gtk_box_pack_start.

La question est maintenant de savoir comment passer la GtkVBox en paramètre à la fonction gtk_box_pack_start. Nous allons tout simplement utiliser l'opérateur -> pour l'élément GtkDialog de cette manière :

GTK_DIALOG(nom_de_la_boite)->vbox;

La boite de dialogue est maintenant complète.

L'affichage de la boite de dialogue comporte deux étapes. Tout d'abord, il faut demander d'afficher tout le contenu de la GtkVBox qui est incluse dans la boite de dialogue avec la fonction gtk_widget_show_all.

Ensuite il faut afficher la boite de dialogue en elle-même et attendre la réponse de l'utilisateur avec cette fonction :

gint gtk_dialog_run(GtkDialog *dialog);

Le paramètre de cette fonction étant de type GtkDialog il faut utiliser la macro de conversion GTK_DIALOG().

Cette fonction affiche l'intégralité de la boite de dialogue, mais rentre aussi dans une boucle récursive qui ne s'arrêtera que lorsque l'utilisateur cliquera sur un des boutons. La valeur de retour correspond à la valeur associée au bouton cliqué. Si, par hasard, l'utilisateur quitte la boite de dialogue en cliquant sur la croix de celle-ci, gtk_dialog_run renvoie GTK_RESPONSE_NONE.

Une fois la valeur de retour connue, il ne reste plus qu'à agir en conséquence.

L'exemple de ce chapitre est constitué d'une fenêtre principale dans laquelle nous allons ajouter un GtkButton et un GtkLabel. Lorsque l'utilisateur clique sur le GtkButton, une boite de dialogue apparaîtra et demandera à l'utilisateur de saisir son nom.

Cette boite de dialogue sera constituée d'une GtkEntry, d'un GtkButton « OK » et d'un GtkButton « Annuler ». Si l'utilisateur clique sur « OK » le contenu de la GtkEntry sera copié dans le GtkLabel de la fenêtre principale tandis que s'il clique sur « Annuler » on affichera « Vous n'avez rien saisi. » dans le GtkLabel.

#include <stdlib.h>
#include <gtk/gtk.h>
 
static GtkWidget *pLabel;
static GtkWidget *pWindow;
 
void lancer_boite(void);
 
int main(int argc, char **argv)
{
    GtkWidget *pVBox;
    GtkWidget *pButton;
 
    gtk_init(&argc, &argv);
 
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(pWindow), "GtkDialog");
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 320, 200);
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
    pVBox = gtk_vbox_new(TRUE, 0);
    gtk_container_add(GTK_CONTAINER(pWindow), pVBox);
 
    pButton = gtk_button_new_with_label("Cliquez ici pour saisir votre nom");
    gtk_box_pack_start(GTK_BOX(pVBox), pButton, FALSE, TRUE, 0);
 
    pLabel = gtk_label_new(NULL);
    gtk_box_pack_start(GTK_BOX(pVBox), pLabel, FALSE, FALSE, 0);
 
    /* Connexion du signal "clicked" pour ouvrir la boite de dialogue */
    g_signal_connect(G_OBJECT(pButton), "clicked", G_CALLBACK(lancer_boite), NULL);
 
    gtk_widget_show_all(pWindow);
 
    gtk_main();
 
    return EXIT_SUCCESS;
}
 
void lancer_boite(void)
{
    GtkWidget* pBoite;
    GtkWidget* pEntry;
    const gchar* sNom;
 
    /* Création de la boite de dialogue */
    /* 1 bouton Valider */
    /* 1 bouton Annuler */
    pBoite = gtk_dialog_new_with_buttons("Saisie du nom",
        GTK_WINDOW(pWindow),
        GTK_DIALOG_MODAL,
        GTK_STOCK_OK,GTK_RESPONSE_OK,
        GTK_STOCK_CANCEL,GTK_RESPONSE_CANCEL,
        NULL);
 
    /* Création de la zone de saisie */
    pEntry = gtk_entry_new();
    gtk_entry_set_text(GTK_ENTRY(pEntry), "Saisissez votre nom");
    /* Insertion de la zone de saisie dans la boite de dialogue */
    /* Rappel : paramètre 1 de gtk_box_pack_start de type GtkBox */
    gtk_box_pack_start(GTK_BOX(GTK_DIALOG(pBoite)->vbox), pEntry, TRUE, FALSE, 0);
 
    /* Affichage des éléments de la boite de dialogue */
    gtk_widget_show_all(GTK_DIALOG(pBoite)->vbox);
 
    /* On lance la boite de dialogue et on récupéré la réponse */
    switch (gtk_dialog_run(GTK_DIALOG(pBoite)))
    {
        /* L utilisateur valide */
        case GTK_RESPONSE_OK:
            sNom = gtk_entry_get_text(GTK_ENTRY(pEntry));
            gtk_label_set_text(GTK_LABEL(pLabel), sNom);
            break;
        /* L utilisateur annule */
        case GTK_RESPONSE_CANCEL:
        case GTK_RESPONSE_NONE:
        default:
            gtk_label_set_text(GTK_LABEL(pLabel), "Vous n'avez rien saisi !");
            break;
    }
 
    /* Destruction de la boite de dialogue */
    gtk_widget_destroy(pBoite);
}

Résultat :

L'unique fonction de ce widget est la fonction permettant de créer la boite de dialogue :

GtkWidget* gtk_message_dialog_new(GtkWindow *parent, GtkDialogFlags flags, GtkMessageType type, GtkButtonsType buttons, const gchar *message_format, ...);

Les paramètres parents et flags sont identiques à ceux du widget GtkDialog, nous ne reviendrons donc pas dessus et allons nous concentrer sur les nouveaux paramètres.

Le tout premier type permet de définir le texte qui sera affiché dans la barre de titre de la boite de dialogue ainsi que l'icône correspondant. Ce paramètre est de type GtkMessageType et peut prendre une des quatre valeurs suivantes :

Le deuxième nouveau paramètre buttons permet de définir les boutons qui seront présents en bas de la boite de dialogue. Les valeurs autorisées sont les suivantes :

Et le dernier paramètre message_format est tout simplement le texte qui sera affiché à l'intérieur de la boite de dialogue. Ce texte peut être formaté comme il est possible de le faire avec la fonction printf.

Nous allons créer une fenêtre comportant deux boutons. Le premier permettra d'afficher les informations habituelles d'une boite de dialogue « À propos… ». Le deuxième offrira la possibilité de quitter le programme, en passant par une demande de confirmation à l'utilisateur.

#include <stdlib.h>
#include <gtk/gtk.h>
 
void on_about_btn(GtkWidget *pBtn, gpointer data);
void on_quitter_btn(GtkWidget *pBtn, gpointer data);
 
int main(int argc, char **argv)
{
    GtkWidget *pWindow;
    GtkWidget *pVBox;
    GtkWidget *pQuitterBtn;
    GtkWidget *pAboutBtn;
 
    gtk_init(&argc,&argv);
 
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(pWindow), "GtkMessageDialog");
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 320, 200);
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
    pVBox = gtk_vbox_new(TRUE,0);
    gtk_container_add(GTK_CONTAINER(pWindow),pVBox);
 
    pAboutBtn = gtk_button_new_with_label("À propos...");
    gtk_box_pack_start(GTK_BOX(pVBox), pAboutBtn, TRUE, FALSE,0);
    g_signal_connect(G_OBJECT(pAboutBtn), "clicked", G_CALLBACK(on_about_btn), (GtkWidget*) pWindow);
 
    pQuitterBtn = gtk_button_new_from_stock (GTK_STOCK_QUIT);
    gtk_box_pack_start(GTK_BOX(pVBox), pQuitterBtn, TRUE, FALSE, 0);
    g_signal_connect(G_OBJECT(pQuitterBtn), "clicked", G_CALLBACK(on_quitter_btn), (GtkWidget*) pWindow);
 
    gtk_widget_show_all(pWindow);
 
    gtk_main();
 
    return EXIT_SUCCESS;
}
 
void on_about_btn(GtkWidget *pBtn, gpointer data)
{
    GtkWidget *pAbout;
    gchar *sSite = "http://gtk.developpez.com";
 
    /* Création de la boite de message */
    /* Type : Information -> GTK_MESSAGE_INFO */
    /* Bouton : 1 OK -> GTK_BUTTONS_OK */
    pAbout = gtk_message_dialog_new (GTK_WINDOW(data),
        GTK_DIALOG_MODAL,
        GTK_MESSAGE_INFO,
        GTK_BUTTONS_OK,
        "Cours GTK+ 2.0\n%s",
        sSite);
 
    /* Affichage de la boite de message */
    gtk_dialog_run(GTK_DIALOG(pAbout));
 
    /* Destruction de la boite de message */
    gtk_widget_destroy(pAbout);
}
 
void on_quitter_btn(GtkWidget* widget, gpointer data)
{
    GtkWidget *pQuestion;
 
    /* Création de la boite de message */
    /* Type : Question -> GTK_MESSAGE_QUESTION */
    /* Boutons : 1 OUI, 1 NON -> GTK_BUTTONS_YES_NO */
    pQuestion = gtk_message_dialog_new (GTK_WINDOW(data),
        GTK_DIALOG_MODAL,
        GTK_MESSAGE_QUESTION,
        GTK_BUTTONS_YES_NO,
        "Voulez-vous vraiment\nquitter ce programme?");
 
    /* Affichage et attente d une réponse */
    switch(gtk_dialog_run(GTK_DIALOG(pQuestion)))
    {
        case GTK_RESPONSE_YES:
            /* OUI -> on quitte l application */
            gtk_main_quit();
            break;
        case GTK_RESPONSE_NO:
            /* NON -> on détruit la boite de message */
            gtk_widget_destroy(pQuestion);
            break;
    }
}

Résultat :

GtkWidget* gtk_dialog_new();

Permet de créer une boite de dialogue vierge.

Entrée(s) : rien.

Sortie : pointeur sur la boite de dialogue.

void gtk_dialog_add_buttons(GtkDialog *dialog, const gchar *first_button_text, ...);

Ajoute des boutons à la boite de dialogue.

Entrée(s) :

• dialog : la boite de dialogue.
• first_button_text… : texte et réponse des boutons.

Sortie : rien.

GtkWidget* gtk_dialog_add_button(GtkDialog *dialog, const gchar *button_text, gint response_id);

Ajoute un bouton à la boite de dialogue.

Entrée(s) :

• dialog : la boite de dialogue.
• button_text : texte du bouton.
• response_id : valeur de retour du bouton .

Sortie : pointeur sur le nouveau bouton.

gboolean gtk_dialog_get_has_separator(GtkDialog *dialog);

Pour savoir si la boite de dialogue possède une barre de séparation.

Entrée(s) :

• dialog : la boite de dialogue.

Sortie : TRUE si la barre de séparation est présente, FALSE sinon.

void gtk_dialog_set_has_separator(GtkDialog *dialog, gboolean setting);

Définit si la boite de dialogue possède une barre de séparation

Entrée(s) :

• dialog : la boite de dialogue en question
• setting : TRUE pour l'ajouter, FALSE sinon.

Sortie : rien.

Vous allez voir ici, il n'y a rien de bien compliqué vu que c'est toujours le même principe :

GtkWidget* gtk_toggle_button_new(void);
GtkWidget* gtk_toggle_button_new_with_label(const gchar* label);
GtkWidget* gtk_toggle_button_new_with_mnemonics(const gchar* label);

La première fonction crée un nouveau bouton vide, alors que la seconde ajoute du texte à l'intérieur et la troisième ajoute en plus un raccourci clavier.

Il peut être intéressant de connaître l'état du bouton pour agir en conséquence. Une fois encore, rien de plus simple on utilise la fonction :

gboolean gtk_toggle_button_get_active(GtkToggleButton *toggle_button);

Cette dernière nous renvoie TRUE si le bouton est enfoncé et FALSE sinon. Afin de pouvoir utiliser le paramètre toggle_button qui est le bouton dont on veut connaître l'état, il faut utiliser la macro GTK_TOGGLE_BUTTON().

Pour modifier l'état du bouton, c'est aussi simple :

void gtk_toggle_button_set_active(GtkToggleButton *toggle_button, gboolean is_active);

Il suffit de mettre le paramètre is_active à TRUE si l'on veut enfoncer le bouton ou à FALSE pour le relâcher.

Il existe cependant un troisième état qui n'est pas accessible en cliquant sur le bouton, mais par une fonction spécifique. Ce troisième état, vous le connaissez sûrement. Le meilleur exemple est celui des éditeurs de texte :

Vous avez une phrase dans laquelle il y a du texte normal et du texte en gras. Si vous sélectionnez le texte en gras, le bouton permettant justement de le mettre en gras s'enfonce (en général B). Par contre si vous sélectionnez le texte normal, ce même bouton repasse à son état relâché. Venons-en au troisième état, qui apparaît lorsque vous sélectionnez la phrase entière. Le bouton ne change pas d'état, mais seulement d'aspect, il donne l'impression d'être inactif.

Ce changement d'aspect doit se faire manuellement, et s'effectue avec cette fonction :

void gtk_toggle_button_set_inconsistent(GtkToggleButton *toggle_button, gboolean setting);

Il suffit de mettre le paramètre setting à TRUE pour donner au bouton l'aspect inactif.

Et pour connaître l'aspect du bouton, il y a tout naturellement la fonction :

gboolean gtk_toggle_button_get_inconsistent(GtkToggleButton *toggle_button);

Évidemment, toutes les fonctions du widget GtkButton sont utilisables avec ce type de bouton.

Nous allons construire une application contenant un GtkToggleButton qui changera d'état (bien sûr) lorsque nous cliquerons dessus, mais aussi lorsque nous cliquerons sur un deuxième bouton (le changement d'état entraînera la modification du label). De plus, il y aura un troisième bouton pour changer l'aspect du bouton (idem, on change aussi le label).

La création des widgets étant classique, nous n'allons donc pas revenir dessus.

Il va donc nous falloir trois fonctions callback. La première pour changer le texte lorsque l'on clique sur le GtkToggleButton, la deuxième pour changer son état lorsque l'on clique sur le deuxième bouton, et la troisième pour changer l'aspect.

Pour la première fonction callback, il faut intercepter le signal « toggled » qui est émis lorsque le bouton change d'état :

g_signal_connect(G_OBJECT(pToggleBtn), "toggled", G_CALLBACK(OnToggle), NULL);

Dans cette fonction nous allons récupérer l'état du bouton ainsi que son aspect afin de changer le label en fonction des valeurs de retour.

Pour la deuxième, on interceptera le signal « clicked » :

g_signal_connect(G_OBJECT(pEtatBtn), "clicked", G_CALLBACK(OnEtatBtn), pToggleBtn);

Lorsque l'on changera l'état du bouton toggle, le signal « toggled » sera émis pour celui-ci et le texte se changera automatiquement.

Pour la troisième, le signal à intercepter et le même (« clicked ») :

g_signal_connect(G_OBJECT(pAspectBtn), "clicked", G_CALLBACK(OnAspectBtn), pToggleBtn);

Cette fois, lorsque l'on change l'aspect du bouton, le signal « toggled » n'est pas émis et le texte ne changera donc pas. Il faut donc émettre soit même ce signal avec la fonction :

void gtk_toggle_button_toggled (GtkToggleButton *toggle_button);

Cette fonction ne change en aucun cas l'état du bouton, elle ne fait qu'émettre le signal.

Mais le plus simple est de regarder le code source suivant.

#include <stdlib.h>
#include <gtk/gtk.h>
 
void OnToggle(GtkWidget *pToggle, gpointer data);
void OnEtatBtn(GtkWidget *pWidget, gpointer pToggle);
void OnAspectBtn(GtkWidget *pWidget, gpointer pToggle);
 
int main(int argc, char **argv)
{
    GtkWidget *pWindow;
    GtkWidget *pToggleBtn;
    GtkWidget *pEtatBtn;
    GtkWidget *pAspectBtn;
    GtkWidget *pVBox;
    gchar *sLabel;
 
    gtk_init(&argc,&argv);
 
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(pWindow), "GtkToggleButton");
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 320, 200);
 
    pVBox = gtk_vbox_new(TRUE, 0);
    gtk_container_add(GTK_CONTAINER(pWindow), pVBox);
 
    /* Création du label du bouton */
    sLabel = g_locale_to_utf8("Etat : Relâché - Aspect : Normal", -1, NULL, NULL, NULL);
    /* Création du bouton GtkToggleButton */
    pToggleBtn = gtk_toggle_button_new_with_label(sLabel);
    /* Le label sLabel n'est plus utile */
    g_free(sLabel);
 
    gtk_box_pack_start(GTK_BOX(pVBox), pToggleBtn, FALSE, FALSE, 0);
 
    pEtatBtn = gtk_button_new_with_label("CHANGER ETAT");
    gtk_box_pack_start(GTK_BOX(pVBox), pEtatBtn, FALSE, FALSE, 0);
 
    pAspectBtn = gtk_button_new_with_label("CHANGER ASPECT");
    gtk_box_pack_start(GTK_BOX(pVBox), pAspectBtn, FALSE, FALSE, 0);
 
    gtk_widget_show_all(pWindow);
 
    /* Connexion des signaux */
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
    g_signal_connect(G_OBJECT(pToggleBtn), "toggled", G_CALLBACK(OnToggle), NULL);
    g_signal_connect(G_OBJECT(pEtatBtn), "clicked", G_CALLBACK(OnEtatBtn), pToggleBtn);
    g_signal_connect(G_OBJECT(pAspectBtn), "clicked", G_CALLBACK(OnAspectBtn), pToggleBtn);
 
    gtk_main();
 
    return EXIT_SUCCESS;
}
 
void OnEtatBtn(GtkWidget *pWidget, gpointer pToggle)
{
    gboolean bEtat;
 
    /* Recuperation de l'état du bouton */
    bEtat = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(pToggle));
 
    /* Modification de l'état du bouton */
    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pToggle), (bEtat ^ TRUE));
}
 
void OnAspectBtn(GtkWidget *pEtatBtn, gpointer pToggle)
{
    gboolean bInconsistent;
 
    /* Récupération de l aspect du bouton */
    bInconsistent = gtk_toggle_button_get_inconsistent(GTK_TOGGLE_BUTTON(pToggle));
 
    /* Modification de l'aspect du bouton */
    gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON(pToggle), (bInconsistent ^ TRUE));
 
    /* On émet le signal "toggle" pour changer le texte du bouton */
    gtk_toggle_button_toggled(GTK_TOGGLE_BUTTON(pToggle));
}
 
void OnToggle(GtkWidget *pToggle, gpointer data)
{
    gboolean bEtat;
    gboolean bInconsistent;
    gchar *sLabel;
    gchar *sLabelUtf8;
 
    /* Récupération de l'état du bouton */
    bEtat = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(pToggle));
    /* Recuperation de l aspect du bouton */
    bInconsistent = gtk_toggle_button_get_inconsistent(GTK_TOGGLE_BUTTON(pToggle));
 
    /* Construction du label du bouton */
    sLabel = g_strdup_printf("Etat : %s - Aspect : %s",
        bEtat ? "Enfoncé" : "Relâché",
        bInconsistent ? "Modifié" : "Normal");
    /* Encodage du label en UTF8 */
    sLabelUtf8 = g_locale_to_utf8(sLabel, -1, NULL, NULL, NULL);
 
    /* Modification du label du bouton */
    gtk_button_set_label(GTK_BUTTON(pToggle), sLabelUtf8);
 
    /* Les chaînes sLabel et sLabelUtf8 n'ont plus d'utilité */
    g_free(sLabel);
    g_free(sLabelUtf8);
}

Résultat :

Une fois encore, la syntaxe et l'utilisation des fonctions de création restent classiques :

GtkWidget* gtk_check_button_new(void);
GtkWidget* gtk_check_button_new_with_label(const gchar *label);
GtkWidget* gtk_check_button_new_with_mnemonic(const gchar *label);

Il n'existe pas d'autres fonctions pour ce widget, il faut donc utiliser les fonctions des widgets GtkToggleButton et GtkButton pour récupérer les propriétés du widget (état, aspect, label…).

Nous n'allons pas ici créer de programme exemple pour ce widget, car il suffit de remplacer gtk_toggle_button_new_with_label par gtk_check_button_new_with_label dans l'exemple précédent pour obtenir ceci :

Afin de grouper les boutons radio, GTK+ utilise les listes simplement chaînées de GLib. Pour créer le premier bouton radio du groupe, il faut obligatoirement passer par une de ces fonctions :

GtkWidget* gtk_radio_button_new(GSList *group);
GtkWidget* gtk_radio_button_new_with_label(GSList *group, const gchar *label);
GtkWidget* gtk_radio_button_new_with_mnemonic(GSList *group, const gchar *label);

Au moment de la création, le bouton radio est automatiquement ajouté à la liste group. Cependant, ce paramètre n'est pas obligatoire. Nous pouvons très bien mettre NULL comme valeur et cela marchera de la même manière, sauf que nous n'aurons pas de pointeur sur la liste. La valeur de retour de cette fonction sera aussi copiée dans la variable data de la liste chaînée.

Ensuite pour rajouter les autres boutons au groupe, il y a plusieurs possibilités. La première est d'utiliser une des trois fonctions précédentes, mais ce n'est pas tout, car autant pour le premier bouton du groupe, il n'est pas nécessaire d'avoir une liste, autant pour les autres boutons cela devient obligatoire. Pour cela, GTK+ nous fournit une fonction qui permet d'obtenir la liste dans laquelle les boutons du groupe sont ajoutés :

GSList* gtk_radio_button_get_group(GtkRadioButton *radio_button);

Avec cette fonction, nous pouvons donc connaître la liste à laquelle appartient le bouton radio_button, ce qui va nous permettre d'ajouter de nouveau bouton au groupe. Mais là où cela se complique, c'est qu'il faut récupérer la liste avant chaque ajout de bouton avec le dernier bouton ajouté comme paramètre. Voici ce que cela donnerait pour un groupe de trois boutons :

pRadio1 = gtk_radio_button_new_with_label(NULL, "Radio 1");
pGroup = gtk_radio_button_get_group(GTK_RADIO_BUTTON(pRadio1));
pRadio2 = gtk_radio_button_new_with_label(pGroup, "Radio 2");
pGroup = gtk_radio_button_get_group(GTK_RADIO_BUTTON(pRadio2));
pRadio3 = gtk_radio_button_new_with_label(pGroup, "Radio 3");

Ce système peut donc s'avérer lourd lors de la création du groupe, surtout s'il contient un grand nombre de boutons. Heureusement, les concepteurs de GTK+ ont pensé à nous simplifier la vie en ajoutant ces trois fonctions :

GtkWidget* gtk_radio_button_new_from_widget(GtkRadioButton *group);
GtkWidget* gtk_radio_button_new_with_label_from_widget(GtkRadioButton *group, const gchar *label);
GtkWidget* gtk_radio_button_new_with_mnemonic_from_widget(GtkRadioButton *group, const gchar *label);

Cette fois group ne correspond pas à la liste, mais à un des boutons du groupe. À chaque appel d'une de ces fonctions, GTK+ va s'occuper de récupérer correctement la liste à laquelle appartient le bouton group et ajouter le nouveau bouton. Cela aura pour conséquence, dans le cas d'un groupe de trois boutons, de réduire le nombre de lignes de code de 5 à 3 (et oui, une ligne de code c'est une ligne de code).

Nous savons maintenant tout ce qu'il faut pour créer un groupe de GtkRadioButton.

Le programme exemple se présente sous la forme d'un mini sondage à trois choix :

• Pour ;
• Contre ;
• Sans opinion.

La possibilité de choisir parmi une de ces valeurs est rendue possible par l'utilisation des GtkRadioButton. Un autre bouton (tout ce qu'il y a de plus normal) permet de valider le choix fait par l'utilisateur ainsi que d'afficher le résultat dans une boite de dialogue.

#include <stdlib.h>
#include <gtk/gtk.h>
 
void OnValider(GtkWidget *pBtn, gpointer data);
 
int main(int argc, char **argv)
{
    GtkWidget *pWindow;
    GtkWidget *pVBox;
    GtkWidget *pRadio1;
    GtkWidget *pRadio2;
    GtkWidget *pRadio3;
    GtkWidget *pValider;
    GtkWidget *pLabel;
 
    gtk_init(&argc, &argv);
 
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(pWindow), "GtkRadioButton");
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 320, 200);
 
    pVBox = gtk_vbox_new(TRUE, 0);
    gtk_container_add(GTK_CONTAINER(pWindow),pVBox);
 
    pLabel = gtk_label_new("Votre choix :");
    gtk_box_pack_start(GTK_BOX(pVBox), pLabel, FALSE, FALSE, 0);
 
    /* Création du premier bouton radio */
    pRadio1 = gtk_radio_button_new_with_label(NULL, "Pour");
    gtk_box_pack_start(GTK_BOX (pVBox), pRadio1, FALSE, FALSE, 0);
    /* Ajout du deuxieme */
    pRadio2 = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON (pRadio1), "Contre");
    gtk_box_pack_start(GTK_BOX (pVBox), pRadio2, FALSE, FALSE, 0);
    /* Ajout du troisième */
    pRadio3 = gtk_radio_button_new_with_label_from_widget(GTK_RADIO_BUTTON (pRadio1), "Sans opinion");
    gtk_box_pack_start(GTK_BOX (pVBox), pRadio3, FALSE, FALSE, 0);
 
    pValider = gtk_button_new_from_stock(GTK_STOCK_OK);
    gtk_box_pack_start(GTK_BOX (pVBox), pValider, FALSE, FALSE, 0);
 
    gtk_widget_show_all(pWindow);
 
    /* Connexion des signaux */
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
    g_signal_connect(G_OBJECT(pValider), "clicked", G_CALLBACK(OnValider), pRadio1);
 
    gtk_main();
 
    return EXIT_SUCCESS;
}
 
void OnValider(GtkWidget *pBtn, gpointer data)
{
    GtkWidget *pInfo;
    GtkWidget *pWindow;
    GSList *pList;
    const gchar *sLabel;
 
    /* Récupération de la liste des boutons */
    pList = gtk_radio_button_get_group(GTK_RADIO_BUTTON(data));
 
    /* Parcours de la liste */
    while(pList)
    {
        /* Le bouton est-il sélectionné */
        if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(pList->data)))
        {
            /* OUI -> on copie le label du bouton */
            sLabel = gtk_button_get_label(GTK_BUTTON(pList->data));
            /* On met la liste a NULL pour sortir de la boucle */
            pList = NULL;
        }
        else
        {
            /* NON -> on passe au bouton suivant */
            pList = g_slist_next(pList);
        }
    }
 
    /* On récupère la fenêtre principale */
    /*
    /* À partir d'un widget, gtk_widget_get_toplevel
    /* remonte jusqu'à la fenêtre mère qui nous est
    /* utile pour l'affichage de la boite de dialogue
    */
    pWindow = gtk_widget_get_toplevel(GTK_WIDGET(data));
 
    pInfo = gtk_message_dialog_new(GTK_WINDOW(pWindow),
        GTK_DIALOG_MODAL,
        GTK_MESSAGE_INFO,
        GTK_BUTTONS_OK,
        "Vous avez choisi : %s", sLabel);
 
    gtk_dialog_run(GTK_DIALOG(pInfo));
 
    gtk_widget_destroy(pInfo);
}

Résultat :

GtkToggleButton

void gtk_toggle_button_set_mode(GtkToggleButton *toggle_button, gboolean draw_indicator);

gboolean gtk_toggle_button_get_mode(GtkToggleButton *toggle_button);

GtkRadioButton

void gtk_radio_button_set_group(GtkRadioButton *radio_button, GSList *group);

Dans un premier temps, le plus simple est de voir comment seront disposés ces trois widgets dans notre futur menu.

Nous avons tous d'abord le widget GtkMenuBar (en rouge) qui est l'élément principal de notre menu. Il contient des éléments de type GtkMenuItem (en bleu) qui peuvent ouvrir des éléments GtkMenu (en vert) contenant aussi des GtkMenuItem.

Du point de vue du fonctionnement, les éléments GtkMenuItem peuvent soit ouvrir un sous-menu (élément GtkMenu) soit exécuter l'action qui lui est associée par l'intermédiaire d'une fonction callback. Il ne reste maintenant plus qu'à créer notre menu.

La création d'un menu doit passer par au moins six étapes différentes :

• Étape 1 : création de l'élément GtkMenuBar qui sera la barre de menu;
• Étape 2 : création d'un élément GtkMenu qui sera un menu ;
• Étape 3 : création des éléments GtkMenuItem à insérer dans le menu ;
• Étape 4 : création de l'élément GtkMenuItem qui ira dans l'élément GtkMenuBar ;
• Étape 5 : association de cet élément avec le menu créé précédemment ;
• Étape 6 : ajout de l'élément GtkMenuItem dans la barre GtkMenuBar.

Si par la suite, vous souhaitez ajouter d'autres menus, il suffit de recommencer à partir de l'étape 2. Étudions maintenant les fonctions qui vont nous permettre de coder le menu.

Étape 1 : création de l'élément GtkMenuBar

• Cette étape, rapide et simple, se résume en l'utilisation d'une seule fonction :

GtkWidget* gtk_menu_bar_new(void);

Étape 2 : création d'un élément GtkMenu qui sera un menu

• Cette fois aussi, une seule fonction est utilisée :

GtkWidget* gtk_menu_new(void);

Étape 3 : création des éléments GtkMenuItem à insérer dans le menu

• Dans un premier temps, il faut créer le GtkMenuItem grâce à l'une de ces trois fonctions :

GtkWidget* gtk_menu_item_new(void);
GtkWidget* gtk_menu_item_new_with_label(const gchar* label);
GtkWidget* gtk_menu_item_new_with_mnemonic(const gchar* label);

Nous reconnaissons la syntaxe de ces constructeurs qui est semblable à celles des boutons. La première fonction créer un élément vide, la deuxième un élément avec un texte (label), et la troisième un élément avec un texte associé à un raccourci.

Maintenant que l'élément est créé, il faut l'insérer dans le menu. Pour cela, il existe plusieurs fonctions possibles, mais nous n'allons en voir que deux :

void gtk_menu_shell_append(GtkMenuShell *menu_shell, GtkWidget *child);
void gtk_menu_shell_prepend(GtkMenuShell *menu_shell, GtkWidget *child);

Ces fonctions ne font pas partie du widget GtkMenu, mais de GtkMenuShell qui est le widget dont GtkMenu dérive. La première fonction ajoute les éléments de haut en bas alors que la seconde les ajoute de bas en haut. Le paramètre menu_shell est le menu dans lequel nous voulons ajouter l'élément et le paramètre child est l'élément à ajouter. Pour le premier paramètre, il faudra utiliser la macro de conversion GTK_MENU_SHELL().

Cette étape peut s'avérer longue à coder, car il faudra la répéter pour chaque élément que nous voulons ajouter au menu.

Étape 4 : création de l'élément GtkMenuItem qui ira dans l'élément GtkMenuBar

• Il suffit d'utiliser une des trois fonctions de création du widget GtkMenuItem.

Étape 5 : association de cet élément avec le menu créé précédemment

• Il faut maintenant dire que lorsque l'utilisateur cliquera sur l'élément créer pendant l'étape 4, il faudra ouvrir le menu qui a été créé précédemment. La fonction adéquate est celle-ci :

void gtk_menu_item_set_submenu(GtkMenuItem *menu_item, GtkWidget *submenu);

Cette fonction va donc associer le GtkMenuItem menu_item au GtkMenu submenu. Comme d'habitude, il faudra convertir le premier paramètre, cette fois-ci à l'aide de la macro GTK_MENU_ITEM().

Étape 6 : ajout de l'élément GtkMenuItem dans la barre GtkMenuBar

• GtkMenuBar dérivant aussi de GtkMenuShell, nous allons utiliser la même fonction que lors de l'étape 3 (gtk_menu_shell_append) pour ajouter le sous-menu au menu principal.

Notre exemple comportera deux menus. Le premier « Fichier », proposera des fonctions inactives (« Nouveau », « Ouvrir », « Enregistrer », « Fermer ») et une fonction active (« Quitter »), alors que le second « ? » proposera la fonction « À propos de… ».

#include <stdlib.h>
#include <gtk/gtk.h>
 
void OnQuitter(GtkWidget* widget, gpointer data);
void OnAbout(GtkWidget* widget, gpointer data);
 
int main(int argc, char **argv)
{
    GtkWidget *pWindow;
    GtkWidget *pVBox;
    GtkWidget *pMenuBar;
    GtkWidget *pMenu;
    GtkWidget *pMenuItem;
 
    gtk_init(&argc, &argv);
 
    /* Création de la fenêtre */
    pWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_title(GTK_WINDOW(pWindow), "GtkMenu");
    gtk_window_set_default_size(GTK_WINDOW(pWindow), 320, 200);
    g_signal_connect(G_OBJECT(pWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
    /* Création de la GtkVBox */
    pVBox = gtk_vbox_new(FALSE, 0);
    gtk_container_add(GTK_CONTAINER(pWindow), pVBox);
 
    /**** Création du menu ****/
 
    /* ÉTAPE 1 */
    pMenuBar = gtk_menu_bar_new();
    /** Premier sous-menu **/
    /* ÉTAPE 2 */
    pMenu = gtk_menu_new();
    /* ÉTAPE 3 */
    pMenuItem = gtk_menu_item_new_with_label("Nouveau");
    gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);
 
    pMenuItem = gtk_menu_item_new_with_label("Ouvrir");
    gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);
 
    pMenuItem = gtk_menu_item_new_with_label("Enregistrer");
    gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);
 
    pMenuItem = gtk_menu_item_new_with_label("Fermer");
    gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);
 
    pMenuItem = gtk_menu_item_new_with_label("Quitter");
    g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(OnQuitter),(GtkWidget*) pWindow);
    gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);
    /* ÉTAPE 4 */
    pMenuItem = gtk_menu_item_new_with_label("Fichier");
    /* ÉTAPE 5 */
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), pMenu);
    /* ÉTAPE 6 */
    gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem);
 
    /** Second sous-menu **/
    /* ÉTAPE 2 */
    pMenu = gtk_menu_new();
    /* ÉTAPE 3 */
    pMenuItem = gtk_menu_item_new_with_label("À propos de...");
    g_signal_connect(G_OBJECT(pMenuItem), "activate", G_CALLBACK(OnAbout),(GtkWidget*) pWindow);
    gtk_menu_shell_append(GTK_MENU_SHELL(pMenu), pMenuItem);
    /* ÉTAPE 4 */
    pMenuItem = gtk_menu_item_new_with_label("?");
    /* ÉTAPE 5 */
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(pMenuItem), pMenu);
    /* ÉTAPE 6 */
    gtk_menu_shell_append(GTK_MENU_SHELL(pMenuBar), pMenuItem);
 
    /* Ajout du menu a la fenêtre */
    gtk_box_pack_start(GTK_BOX(pVBox), pMenuBar, FALSE, FALSE, 0);
 
    gtk_widget_show_all(pWindow);
 
    gtk_main();
 
    return EXIT_SUCCESS;
}
 
void OnQuitter(GtkWidget* widget, gpointer data)
{
    GtkWidget *pQuestion;
 
    pQuestion = gtk_message_dialog_new(GTK_WINDOW(data),
        GTK_DIALOG_MODAL,
        GTK_MESSAGE_QUESTION,
        GTK_BUTTONS_YES_NO,
        "Voulez vous vraiment\n"
        "quitter le programme?");
 
    switch(gtk_dialog_run(GTK_DIALOG(pQuestion)))
    {
        case GTK_RESPONSE_YES:
            gtk_main_quit();
            break;
        case GTK_RESPONSE_NONE:
        case GTK_RESPONSE_NO:
            gtk_widget_destroy(pQuestion);
            break;
    }
}
 
void OnAbout(GtkWidget* widget, gpointer data)
{
    GtkWidget *pAbout;
 
    pAbout = gtk_message_dialog_new(GTK_WINDOW(data),
        GTK_DIALOG_MODAL,
        GTK_MESSAGE_INFO,
        GTK_BUTTONS_OK,
        "Cours GTK+ 2.0\n"
        "http://gtk.developpez.com");
 
    gtk_dialog_run(GTK_DIALOG(pAbout));
 
    gtk_widget_destroy(pAbout);
}

Résultat :

Pour créer un GtkImageMenuItem, on a à disposition quatre fonctions :

GtkWidget* gtk_image_menu_item_new(void);
GtkWidget* gtk_image_menu_item_new_from_stock(const gchar *stock_id, GtkAccelGroup *accel_group);
GtkWidget* gtk_image_menu_item_new_with_label(const gchar *label);
GtkWidget* gtk_image_menu_item_new_with_mnemonic(const gchar *label);

On retrouve encore les mêmes types de fonctions de création, aussi je passe sur l'explication des paramètres. La seule nouveauté est peut-être le GtkAccelGroup *accel_group de gtk_image_menu_item_new_from_stock, qui sert à ajouter l'entrée à un GtkAccelGroup précédemment créé en utilisant le raccourci par défaut de l'icône stock.

Maintenant, il s'agit de définir une icône pour notre entrée, pour cela, on a :

void gtk_image_menu_item_set_image(GtkImageMenuItem *image_menu_item, GtkWidget *image);

Cette fonction permet de définir l'icône (généralement on utilisera un GtkImage) qui sera affichée par l'entrée passée en paramètre. Cette fonction peut aussi servir à remplacer l'icône que gtk_image_menu_item_new_from_stock définit pour l'entrée lors de sa création.

La dernière fonction spécifique des GtkImageMenuItem est :

GtkWidget* gtk_image_menu_item_get_image(GtkImageMenuItem *image_menu_item);

Elle sert, comme vous l'aurez deviné, à récupérer ce qui sert d'icône à l'entrée.