Sehr Umfangreiche Webseite zum Programmieren in C Perl CGI, Skripting, Linux, Systemprogrammierung C C++ C/C++ ANSI C Linux Windows GUI gtk gtk+ Gimp Toolkit Menü und Dialogbox GUI gtk gtk+ Gimp Toolkit Menü und Dialogbox Menü und Dialogbox

Menüs mit GtkItemFactory           zurück Ein Kapitel tiefer zum Inhaltsverzeichnis

Damit man auch Anwenderfreundliche Programme schreiben kann, benötigen wir natürlich Menüs. GTK kennt mehrere Möglichkeiten Menüs zu erstellen. Vorerst wollen wir uns die einfachste Möglichkeit dazu ansehen.

GtkItemFactory
Logischerweise ist auch hier wieder der erste Schritt, das Menü-Widget zu erzeugen. Dies können Sie mit folgender Funktion realisiern ...

GtkItemFactory * gtk_item_factory_new(GtkType *Container_type,
                                      const gchar *path,
                                      GtkAccelGroup *accl_group);

Für den Containertyp können Sie folgende Arten von Menüs erzeugen ...

Der path ist ein eindeutiger Name in spitzen Klammern für die Menüleiste. Mit accl_group können Sie einen Zeiger auf eine Tastatur-Kürzel definieren.

Mit dem nächsten Schritt wird anschließend die Menüleiste erstellt. Dies geschieht mit der Funktion ...

void gtk_item_factory_create_items(GtkItemFactory *ifacrory,
                                   quint n_entries,
                                   GtkItemFactoryEntry *entries,
                                   gpointer callback_data);

ifactory ist ein Zeiger auf das kurz zuvor erzeugte GtkItemFactory. n_entries erhält die Anzahl der Menüeintrage. entries ist ein Zeiger auf die Struktur GtkItemFactoryEntry welche die Einträge in der Menüleiste beinhaltet. Folgende fünf Eintrage werden dabei für die Menüleiste gemacht. Der Reihe nach ...

Und so kann man sich einen solchen Eintrag vorzustellen ...

static GtkItemFactoryEntry menue[] =
       {
         { "/_File", NULL, NULL, 0, "<Branch>" },
         { "/File/_Neu", "<control>N", new_file, 0, NULL}
       };

Jetzt noch zu GtkAccelGroup womit wir einen Zeiger auf die eben genannte Struktur für die Tasten-Kürzel erstellen. Erzeugen können wir dies mit der Funktion ...

GtkAccelGroup *gtk_accel_group_new(void);

Diese Struktur müssen wir natürlich auch einem Widget (meist dem Fenster) zuordnen. Dies machen wir mit der Funktion ...

void gtk_accl_group_attach(GtkAcclGroup *accl_group,
                           GtkObjekt    *object);

Nun wird es Zeit für ein Programmbeispiel ...

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

GtkItemFactory *items;
GtkAccelGroup *accl;

/*Programmende*/
void ende_cb(GtkObject *object)
{
 gtk_main_quit();
}

void file_open(GtkWidget *widget, gpointer data)
{
 g_print("Datei öffnen\n");
}

void file_save(GtkWidget *widget, gpointer data)
{
 g_print("Datei speichern\n");
}

void file_close(GtkWidget *widget, gpointer data)
{
 g_print("Datei schließen\n");
}

void cut(GtkWidget *widget, gpointer data)
{
 g_print("Ausschneiden\n");
}

void copy(GtkWidget *widget, gpointer data)
{
 g_print("Kopieren\n");
}

void help(GtkWidget *widget, gpointer data)
{
 g_print("Hier gibt es keine Hilfe!\n");
}

/*Die Menüeintrage*/
static GtkItemFactoryEntry menue[]={
  { "/_Datei", NULL, NULL, 0, "<Branch>" },
  { "/Datei/Öffnen", "<control>O", file_open, 0, NULL},
  { "/Datei/Speichern", "<control>S", file_save, 0, NULL},
  { "/Datei/Schließen", "<control>C", file_close, 0, NULL},
  { "/Datei/Ende", "<control>Q", gtk_main_quit, 0, NULL},

  { "/Bearbeiten", NULL, NULL, 0, "<Branch>" },
  { "/Bearbeiten/Ausschneiden", "<control>X", cut, 0, NULL},
  { "/Bearbeiten/Kopieren", "<control>P", copy, 0, NULL},
  { "/?", NULL, NULL, 0, "<LastBranch>"},
  { "/?/Hilfe", NULL, help, 0, NULL},
  };

int main(int argc, char **argv)
{
 GtkWidget *fenster;
 GtkItemFactory *items;
 GtkAccelGroup *accl;
 GtkWidget *box;
 GtkWidget *menu_bar;
 gint n_menue = sizeof(menue) /sizeof(menue[0]);

 /*Gtk initialisieren*/
 gtk_init(&argc, &argv);
 /*Ein neues Fenster erstellen*/
 fenster = gtk_window_new(GTK_WINDOW_TOPLEVEL);
 accl=gtk_accel_group_new();
 items=gtk_item_factory_new(GTK_TYPE_MENU_BAR, "<main>", accl);
 gtk_item_factory_create_items(items, n_menue, menue, NULL);
 gtk_accel_group_attach(accl, GTK_OBJECT(fenster));
 menu_bar=gtk_item_factory_get_widget(items, "<main>");
 /*Buttons erstellen*/
 gtk_window_set_default_size(GTK_WINDOW(fenster), 320, 300);

 /*Neue Box erstellen*/
 box = gtk_vbox_new(FALSE,0);

 /*Signale registrieren*/
 gtk_signal_connect(GTK_OBJECT(fenster), "destroy",
                    GTK_SIGNAL_FUNC(ende_cb), NULL);

 /*Fensterposition*/
 gtk_window_set_position(GTK_WINDOW(fenster),GTK_WIN_POS_CENTER);

// gtk_container_set_border_width(GTK_CONTAINER(fenster),15);

 gtk_box_pack_start(GTK_BOX(box), menu_bar, FALSE, TRUE, 0);


 gtk_container_add(GTK_CONTAINER(fenster),box);

 /*Zeigs uns.....*/
 gtk_widget_show_all(fenster);

 gtk_main();

 return 0;
}

Und so könnte es aussehen ...

Dialogboxen mit GtkFileSelection           zurück Ein Kapitel tiefer zum Inhaltsverzeichnis

Viele Applikationen die Sie schreiben werden, werden auch die Möglichkeit benötigen, Daten zu öffnen mit sogenannten Dialogboxen. Theoretisch könnten Sie ja auch die Konsole dafür verwenden. Aber dann benötigten wir keine GUI. Im Normalfall sperren Dialogboxen, während Sie eine Datei selektieren, die aktuelle Anwendung aus der Sie gestartet wurden. Man kann diesen Modularen Modus aber auch ausschalten.

Eine Dialogbox erzeugen Sie mit der Funktion ...

GtkWidget *gtk_file_selection_new(const gchar *title);

title ist dabei die Überschrift der Dialogbox. Nun benötigen wir nur noch die Funktionen zum Abfragen der Ausgewählten Datei ...

gchar *gtk_file_selection_get_filename(GtkFileSelection *select);

Natürlich gibt es auch das Gegenstück zu dieser Funktion mit ...

void  gtk_file_selection_set_filename(GtkFileSelection *select,
                                      const gchar *filename);

Nun wollen wir uns ein einfaches Beispiel dazu ansehen ...

#include <gtk/gtk.h>

/*Programmende*/
void ende_cb(GtkObject *object)
{
 gtk_main_quit();
}

/*Ausgewählte Datei auf Konsole ausgeben*/
void get_filename(GtkWidget *widget, GtkFileSelection *sel)
{
 g_print("Folgende Datei wurde ausgewählt : %s\n",
          gtk_file_selection_get_filename(GTK_FILE_SELECTION(sel)));
}


int main(int argc, char **argv)
{
 GtkWidget *file_select;

 /*Gtk initialisieren*/
 gtk_init(&argc, &argv);

 file_select = gtk_file_selection_new("Auswahl");

 /*Signale einrichten*/
 gtk_signal_connect(GTK_OBJECT(file_select), "destroy",
                    (GtkSignalFunc) ende_cb, &file_select);
 gtk_signal_connect(GTK_OBJECT(GTK_FILE_SELECTION(file_select)->ok_button),
                    "clicked", (GtkSignalFunc) get_filename, file_select);
 gtk_signal_connect_object(GTK_OBJECT(GTK_FILE_SELECTION(file_select)->cancel_button),
                           "clicked", (GtkSignalFunc) ende_cb, GTK_OBJECT(file_select));

 //gtk_file_selection_set_filename(GTK_FILE_SELECTION(file_select),"name.txt");
 gtk_widget_show(file_select);

 gtk_main();

 return 0;
}

Und so könnte es aussehen ...

So einfach können Sie die altbewährte Dialogbox erstellen und verwenden. Sollten Sie aber eine eigene Dialogbox erstellen wollen, sollten Sie sich die Funktion gtk_dialog_new() und dessen weiteren Funktionen ansehen.

Weiter mit Empfehlenswerter Literatur und Links