GTK+ par l'exemple


précédentsommairesuivant

XII. Les menus

XII-A. Aperçu

Image non disponible
Cliquez pour agrandir

XII-B. Création du menu

Pour simplifier nous avons utilisé des boutons pour permettre à l'utilisateur de créer un document, ouvrir un fichier... Mais il est plus courant d'utiliser un menu pour afficher ces options. GTK+ propose trois manières de créer un menu :

  • GtkItemFactory : cette méthode est obsolète depuis la version 2.4 de GTK+
  • GtkUIManager : c'est ce qu'on appel une usine à gaz, pour en savoir plus, vous pouvez vous reporter au tutoriel Utilisation de GtkUIManager
  • GtkMenu : c'est ce widget que nous allons étudier, il permet de créer un menu manuellement (à l'opposé de GtkUIManager).

Un menu, selon GTK+, est composé de plusieurs éléments :

  • GtkMenuBar : la barre de menu elle-même
  • GtkMenu : la partie déroulante qui contient les différents éléments
  • GtkMenuItem : c'est sur ce widget que l'utilisateur clique pour lancer une action.

Pour commencer, faisons l'inventaire de ce que nous avons besoin :

  • Un GtkMenuBar qui sert de base au menu
  • Un GtkMenu, pour commencer nous nous aurons d'un menu Fichier
  • Six GtkMenuItem pour remplacer nos six boutons.

Commençons par la création du menu, nous mettons ce code dans un nouveau fichier dont seul la fonction menu_new sera accessible :

menu.c
Sélectionnez
GtkMenuBar *menu_new (gpointer user_data)
{
  GtkWidget *p_menu_bar = NULL;

  p_menu_bar = gtk_menu_bar_new ();
  /* ... */  
  return GTK_MENU_BAR (p_menu_bar);
}

Le paramètre user_data nous servira lors de la connexion des callbacks (nous en avons besoin pour les fonctions cb_new et cb_open).
Ensuite, nous allons créer notre sous menu Fichier :

menu.c
Sélectionnez
  /* Menu "Fichier" */
  {
    GtkWidget *p_menu = NULL;
    GtkWidget *p_menu_item = NULL;

    p_menu = gtk_menu_new ();
    p_menu_item = gtk_menu_item_new_with_mnemonic ("_Fichier");
    /* ... */
    gtk_menu_item_set_submenu (GTK_MENU_ITEM (p_menu_item), p_menu);
    gtk_menu_shell_append (GTK_MENU_SHELL (p_menu_bar), p_menu_item);
  }
  return GTK_MENU_BAR (p_menu_bar);

Un sous menu est en fait un GtkMenuItem auquel on assigne un GtkMenu. Il faut bien sûr terminer la création du sous-menu en l'ajoutant à la barre de menu.
Pour finir, nous créons les éléments du menu, les GtkItemMenu. Il existe plusieurs types d'éléments (comparable aux différents types de bouton), pour commencer nous n'utiliserons que le type de base. Comme cette opération est répétitive, nous allons créer une fonction pour le faire :

menu.c
Sélectionnez
static void menu_item_new (GtkMenu *p_menu, const gchar *title, GCallback callback, gpointer user_data)
{
  GtkWidget *p_menu_item = NULL;

  p_menu_item = gtk_menu_item_new_with_mnemonic (title);
  gtk_menu_shell_append (GTK_MENU_SHELL (p_menu), p_menu_item);
  g_signal_connect (G_OBJECT (p_menu_item), "activate", callback, user_data);
}

Pour permettre à l'utilisateur d'accéder aux différents éléments du menu à l'aide de la touche <Alt>, nous utilisons des mnémoniques, par exemple pour quitter l'éditeur il suffit de faite Alt+F puis Q. Et voici le code pour créer nos six éléments du menu :

menu.c
Sélectionnez
  menu_item_new (GTK_MENU (p_menu), "_Nouveau", G_CALLBACK (cb_new), user_data);
  menu_item_new (GTK_MENU (p_menu), "_Ouvrir", G_CALLBACK (cb_open), user_data);
  menu_item_new (GTK_MENU (p_menu), "_Enregistrer", G_CALLBACK (cb_save), user_data);
  menu_item_new (GTK_MENU (p_menu), "Enregistrer _sous", G_CALLBACK (cb_saveas), user_data);
  menu_item_new (GTK_MENU (p_menu), "_Fermer", G_CALLBACK (cb_close), user_data);
  menu_item_new (GTK_MENU (p_menu), "_Quitter", G_CALLBACK (cb_quit), user_data);

Voilà, notre menu est créé ! il nous reste plus qu'à l'intégrer à notre fenêtre :

main.c
Sélectionnez
  gtk_box_pack_start (GTK_BOX (p_main_box), GTK_WIDGET (menu_new (p_text_view)), FALSE, FALSE, 0);

Le problème c'est que nous avons besoin de passer le GtkTextView lors de la création du menu (qui est utilisé par les fonctions cb_new et cb_open) or celui-ci est créé après le menu (puisque nous créons les widgets dans l'ordre où il faut les intégrer à l'interface (8)), nous devons créer le GtkTextView (seul l'appel à gtk_text_view_new est déplacé).

XII-C. Code source


précédentsommairesuivant
Nous n'aurions pas eu ce problème si nous commencions par créer tous les widgets puis les intégrions à la fenêtre. Le problème avec cette méthode c'est que l'on a besoin des variables désignant les widgets jusqu'à la fin de la fonction, ce qui nous empêcherait de découper le code sous forme de blocs dans lesquels nous créons chaque élément.

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

  

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2006-2008 Nicolas Joseph. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.