Menús y barras de herramientas

Menús

Existen dos formas de crear menús: Una sencilla y otra un poco más complicada, ya que utiliza el método manual. La forma sencilla utiliza la factoría de menús (GtkItemFactory), que facilita la creación de menús. El método manual crea todos los menús usando las llamadas directamente. Aunque usando GtkItemFactory facilita la creación de menús, no es posible añadir imágenes o el carácter '/'.

Creación Manual de Menús

Para crear un Menú, se necesitan los siguientes widgets:

  • Item del menú: lo que el usuario selecciona, ej. "Guardar".

  • Menú: actúa como contenedor de los item del menú, ej. "Archivo".

  • Barra de menús: un contenedor para cada menú individual.

Las siguientes funciones se usan para crear menús y barras de menús:

	    GtkWidget *gtk_menu_bar_new (void); // crea una barra de menus. 
	    GtkWidget *gtk_menu_new (void);  // devuelve un puntero al nuevo menú. No es necesario
	                                     // mostrarlo (con gtk_widget_show()), ya que es simplemente
	                                     // un contenedor para los items del menú.
	  

Las siguientes funciones crean items de menú que son colocados dentro del menú y de la barra de menús.

	    GtkWidget *gtk_menu_item_new (void); // crea un item de menú sin título
	    GtkWidget *gtk_menu_item_new_with_label (const char *label); // crea un item de menú con título
	    GtkWidget *gtk_menu_item_new_with_mnemnonic (const char *label); // crea un item de menú con carácter mnemónico
	  

Una vez se han creado los items de menú, hay que colocarlos dentro del widget menú usando la función gtk_menu_append. Además, para saber cuándo el item ha sido seleccionado por el usuario es necesario conectar la señal activada.

En el siguiente ejemplo, se muestra el código necesario para crear un menú Archivo estándar, con las opciones Abrir, Guardar y Salir.

	    file_menu = gtk_menu_new ();    /* Crea un menú */

	    /* Crea items de menú */
	    open_item = gtk_menu_item_new_with_label ("Abrir");
	    save_item = gtk_menu_item_new_with_label ("Guardar");
	    quit_item = gtk_menu_item_new_with_label ("Salir");

	    /* Añade los items al menú */
	    gtk_menu_append (GTK_MENU (file_menu), open_item);
	    gtk_menu_append (GTK_MENU (file_menu), save_item);
	    gtk_menu_append (GTK_MENU (file_menu), quit_item);

	    /* Attach the callback functions to the activate signal */
	    g_signal_connect_swapped (G_OBJECT (open_item), "activate",
	                              G_CALLBACK (menuitem_response),
	                              (gpointer) "file.open");
	    g_signal_connect_swapped (G_OBJECT (save_item), "activate",
	                              G_CALLBACK (menuitem_response),
	                              (gpointer) "file.save");

	    /* We can attach the Quit menu item to our exit function */
	    g_signal_connect_swapped (G_OBJECT (quit_item), "activate",
	                              G_CALLBACK (destroy),
	                              (gpointer) "file.quit");

	    /* Es necesario mostrar los items de menú */
	    gtk_widget_show (open_item);
	    gtk_widget_show (save_item);
	    gtk_widget_show (quit_item);
	  

El siguiente paso de este ejemplo es la creación de una barra de menús y un item para la opción Archivo, al que se le añadirá el menú (file_menu).

	    /* Crea una barra de menús */
	    menu_bar = gtk_menu_bar_new ();
	    gtk_container_add (GTK_CONTAINER (window), menu_bar);
	    gtk_widget_show (menu_bar);

	    /* Crea el item "Archivo" */
	    file_item = gtk_menu_item_new_with_label ("Archivo");
	    gtk_widget_show (file_item);
	  

Para asociar el menú con el item Archivo (file_item) se usa la siguiente función:

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

Siguiendo el ejemplo, el código sería:

	    gtk_menu_item_set_submenu (GTK_MENU_ITEM (file_item), file_menu);
	  

Lo siguiente es asociar el menú (file_menu) con la opción Archivo (file_item), para ello se necesita la función:

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

En el ejemplo:

	    gtk_menu_item_set_submenu (GTK_MENU_ITEM (file_item), file_menu);
	  

Por último, se añade el menú a la barra de menús, usando la función:

	    void gtk_menu_bar_append (GtkMenuBar *menu_bar,
	                              GtkWidget  *menu_item);
	  

En el ejemplo:

	    gtk_menu_bar_append (GTK_MENU_BAR (menu_bar), file_item);
	  

Para alinear el menú a la derecha de la barra de menús, como por ejemplo el menú Ayuda, se usa la función void gtk_menu_item_right_justify.

Para que queden claros todos los conceptos, a continuación se resumen los pasos a seguir para la creación de una barra de menús con menús.

  1. Crear un menú con la función gtk_menu_new

  2. Crear los items que van a estar en el menú con la función gtk_menu_item_new

  3. Colocar los items creados en el menú usando la función gtk_menu_append

  4. Crear un item de menú con la función gtk_menu_item_new. Este será el menú raíz, es decir, el texto que aparece en la barra de menús.

  5. Asociar el menú al menú raíz usando la función gtk_menu_item_set_submenu.

  6. Crear una barra de menús con gtk_menu_bar_new que contendrá al menú raíz.

  7. Colocar el menú raíz en la barra de menús usando gtk_menu_bar_append.

Menú PopUp (colgante)

Los pasos a seguir para crear un menú popup son muy similares a lo comentado en el apartado anterior. La única diferencia es que el menú popup no se encuentra dentro de una barra de menús, sino que aparece, por ejemplo, porque se ha pulsado el botón izquierdo del ratón.

Para saber cuándo desplegar el menú popup, se necesita crear una función de manejo del evento. Esta función necesita tener el siguiente prototipo:

	    static gint handler (GtkWidget *widget, GdkEvent  *event);
	  

El argumento event especificará cuándo desplegar el menú popup.

Si el evento, en un manejador de eventos, es la pulsación de uno de los botones del ratón, se debe usar como se muestra en el código de ejemplo para pasar información a gtk_menu_popup.

Para asociar un manejador de eventos a un widget determinado, se usa la siguiente función:

	    g_signal_connect_swapped (G_OBJECT (widget), "event",
	                              G_CALLBACK (handler),
	                              G_OBJECT (menu));
	  

widget es el widget que se va a asociar al menú, mientras que handler es la función de manejo del evento, y menu es el menú popup creado con la función gtk_menu_new.

GtkToolbar

Factorías de menús (GtkItemFactory)

GtkCombo