====== Menüleisten ======

{{ :gui:gtk:menu_toolbar.jpg|Menü- und Werkzeugleiste}}\\ Es ist zum Standard bei Anwendungen geworden, diese mit einer Menüleiste auszustatten. Dort gibt es klassischerweise die Menüs "Datei", "Bearbeiten" und "Ansicht", oft auch mehr. Oft benutzte Funktionen, auf die man schnell zugreifen sollte, packt man am besten in eine Werkzeugleiste. Dort findet man oft Icons, die für die Funktionen stehen.

===== Menüs =====

{{ :gui:gtk:menubar.jpeg|Menübar }}
Das Zentrum eines GTK-Menüs ((besser: "Menüleiste")) bildet die ''GtkMenuBar''. In die ''GtkMenuBar'' packt man dann ''GtkMenuItem''s. Um ein aufklappendes Menü zu erzeugen benutzt man ein ''GtkMenu''. Dieses verbindet man mit einem ''GtkMenuItem'' in der ''GtkMenuBar''. In das ''GtkMenu'' kann man dann wieder ''GtkMenuItem''s packen.


Kommen wir zur Umsetzung: Als Basis benutzt bitte das leere Fenster aus dem Kapitel [[:gui:gtk:firststeps|Erste Schritte mit GTK+]] und erweitert es mit einer vertikalen Box.

Um eine Menüleiste mit einem Menu ("Datei") und einem Eintrag ("Beenden") zu erstellen, benötigen wir zudem 4 weitere ''GtkWidgets'':


<code cpp>
GtkWidget *menubar,  /*die Menüleiste an sich: wird später in die vertikale Box gepackt*/
          *filemenu, /*das "Datei"-Menü, in das wir das Beenden-Item stecken.*/
          *fileitem, /*das "Datei"-Item: kommt in die Menüleiste und wird mit "filemenu" verknüpft*/
          *quititem; /*das "Beenden"-Item*/
</code>
Als nächstes erstellen wir ''menubar'' und ''filemenu'', mit der Gtk üblichen ''*_new '' Funktion:
<code cpp>
menubar = gtk_menu_bar_new();
filemenu = gtk_menu_new();
</code>
==== Menü-Items ====

Nun kommen die ''GtkMenuItem''s an die Reihe. Allerdings sollte man hier zwischen verschiedenen Typen unterscheiden:
^Typ^Beschreibung^Funktion zum Erstellen^
|__GtkMenuItem__|Ein einfaches Item, nur mit Text|<code cpp>gtk_menu_item_new_with_label(const gchar *text)
gtk_menu_item_new_with_mnemonic(const gchar *text)</code>|
|__GtkImageMenuItem__|Ein Item mit einem kleinen Icon, welches über eine GTK_STOCK_ID gesetzt werden kann ((es kann auch über ein externes Bild gesetzt werden))|<code cpp>gtk_image_menu_item_new(void)
gtk_image_menu_item_new_from_stock(const gchar *stock, GtkAccelGroup *ag)</code>|
|__GtkSeparatorMenuItem__|Ein einfacher Trennstrich, um bestimmte Bereiche zu gruppieren.|<code cpp>gtk_separator_menu_item_new()</code>|
|__GtkCheckMenuItem__|Ein Item mit einem abhakbaren Kästchen (Check Box)|<code cpp>gtk_check_menu_item_new_with_label(const gchar *text)
gtk_check_menu_item_new_with_mnemonic(const gchar *text)</code>|
|__GtkTearoffMenuItem__|Ein Item zum Ablösen des GtkMenus von der Menüleiste, dargestellt als durchzogene, gepunktete Linie.|<code cpp>gtk_tearoff_menu_item_new()</code>|

==== Mnemonics ====
Bei mehreren oben aufgelisteten MenuItems tauchen ''Mnemonics'' auf. Als ''Mnemonic'' bezeichnet man in GTK die Hervorhebung eines Buchstaben durch einen Unterstrich. Ist das Menü offen, so kann der Benutzer durch Drücken der Taste des unterstrichenen Buchstabens das jeweilige Menü-Item aktivieren, also die Aktion ausführen. Folgende Funktion erstellt ein Menü-Item mit dem Label (=Text) "__D__atei":
<code cpp>fileitem = gtk_menu_item_new_with_mnemonic("_Datei");</code>
Wie ihr seht, geht dem jeweiligen Buchstaben, der mit einem Mnemonic((englisch etwa: Abkürzung, Eselsbrücke, Gedänchtnisstütze)) verziert werden soll, ein Unterstrich vor. Bemüht euch bei der Vergabe von Mnemonics darum, dass sie auch dem Benutzer einleuchtend sind und er nicht erst auf den unterstrichenen Buchstaben achten muss.

==== Gtk Stocks ====

Auch müssten euch bei der obigen Tabelle Funktionen aufgefallen sein, die auf ''*_from_stock'' enden. Diese erwarten dann die Angabe einer "STOCK_ID". Zunächst einmal: //Was sind Gtk Stocks?//


Oft sieht man in GTK und [[http://www.gnome.org|GNOME]]-Anwendungen (Image-)Menü-Items mit Icons, die immer gleich sind. Oft werden diese über GTK-STOCKS ((stock: englisch: Vorrat, Lager)) realisiert. Praktisch sind die GtkStocks eine ganze Reihe von [[c:pre:define|Defines]], die immer mit ''GTK_STOCK_*'' beginnen.


Bei Menü-Items benutzt für die Verwendung von Stocks das GtkImageMenuItem. Um dann ein Beenden-Item, wie ganz oben auf dem Bild zu sehen zu erzeugen, genügt folgender Aufruf:
<code cpp>quititem = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, NULL);</code>
Eine vollständige Liste von Gtk Stocks (auch mit schönen Bildchen =)) findet ihr in der [[http://library.gnome.org/devel/gtk/stable/gtk-Stock-Items.html|GTK-Referenz]].

==== Zusammenpacken... ====

Nun haben wir grundlegendsten Bestandteile einer Menüleiste erstellt, doch haben wir noch lange nicht eine fertige Menüleiste!


Zunächst sei noch einmal ein Blick auf das oben gezeigte Diagramm empfohlen, um zu verstehen, was wir in was packen müssen.


Als erstes Setzen wir unser Beenden-Item (das mit dem Gtk Stock) in unser GtkMenu, welches später über "__D__atei" erreichbar sein soll. Folgende Zeile reicht da vollkommen aus:
<code cpp>gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), quititem); </code>


Als nächstes Packen wir unser "__D__atei" Item (fileitem) in unsere GtkMenuBar:
<code cpp>gtk_menu_shell_append(GTK_MENU_SHELL(menubar), fileitem); </code>


Zum Schluss müssen wir nur noch festlegen, dass beim Klicken des ''__D__atei'' Items auf das ''Datei''-Menü (mit unserem Beenden-Item) erscheint:
<code cpp>gtk_menu_item_set_submenu(GTK_MENU_ITEM(fileitem), filemenu); </code>


Um das alles auch im Fenster sehen zu können, müsst ihr natürlich noch die GtkMenuBar ''menubar'' in die vertikale Box packen.

==== Signale ====

Noch ein kurzer Blick auf die Verwendung von Signalen bei Menü-Items. Um unser kleines Programm bei Klick auf das Beenden Symbol wirklich zu beenden, müssen wir es natürlich verknüpfen, und zwar mit ''gtk_main_quit''((Dieses beendet den GtkMainLoop, der Programmablauf geht dann nach dem Aufruf von gtk_main() weiter.)):
<code cpp>g_signal_connect(quititem, "activate", G_CALLBACK(gtk_main_quit), NULL);</code>
Wie unschwer zu erkennen ist, benutzt jedes ''GtkMenuItem'' das "activate" Signal.

===== Last but not least... =====
Für die Faulen unter euch, hier noch einmal der vollständige Code (bis jetzt, wir wollen diesen noch um eine Werkzeugleiste erweitern):
<code cpp>
#include <gtk/gtk.h>
 
int main(int argc, char *argv[])
{
    GtkWidget *window;
    GtkWidget *vbox;
    GtkWidget *menubar,  /* die Menüleiste an sich: wird später in die vertikale Box gepackt */
	      *filemenu, /* das "Datei"-Menü, in das wir das Beenden-Item stecken. */
    	      *fileitem, /* das "Datei"-Item: kommt in die Menüleiste und wird mit "filemenu" verknüpft */
    	      *quititem; /* das "Beenden"-Item */
 
    gtk_init(&argc, &argv);
 
    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    
    vbox = gtk_vbox_new(FALSE, 0);
    gtk_container_add(GTK_CONTAINER(window), vbox);
    
    /* Erstellen der Menüleiste und der anderen Menü Bestandteile */
    menubar = gtk_menu_bar_new();
    filemenu = gtk_menu_new();
    fileitem = gtk_menu_item_new_with_mnemonic("_Datei");
    quititem = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, NULL);
	
    /* Packen */
    gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), quititem); 
    gtk_menu_shell_append(GTK_MENU_SHELL(menubar), fileitem); 
    gtk_menu_item_set_submenu(GTK_MENU_ITEM(fileitem), filemenu); 
	
    gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
	
    /* Ein neues Signal */
    g_signal_connect(quititem, "activate", G_CALLBACK(gtk_main_quit), NULL);
 
    g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
    gtk_widget_show_all(window);
    gtk_main();
    return 0;
}</code>




=====  =====

In der nächsten Lektion werdet ihr dann die Werkzeugleisten kennen lernen. Dafür werden wir den obenstehenden Quelltext erweitern.




<html><center></html> **[[ gui:gtk:dialogs |zurück]] || [[gui:gtk:start|hoch zur Startseite]] || [[ gui:gtk:toolbars |weiter]]**<html></center></html>
----
[[http://forum.proggen.org/viewtopic.php?f=39&t=847|Diskussion]]