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 :

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 "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 :

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_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 :

  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é).

chapitre12.zip