/* These values identify the type of pixmap used in an item */
typedef enum {
        GNOME_APP_PIXMAP_NONE,          /* No pixmap specified */
        GNOME_APP_PIXMAP_STOCK,         /* Use a stock pixmap
                                           (GnomeStock) */
        GNOME_APP_PIXMAP_DATA,          /* Use a pixmap from inline
                                           xpm data */
        GNOME_APP_PIXMAP_FILENAME       /* Use a pixmap from the
                                           specified filename */
} GnomeUIPixmapType;

/* This is the structure that defines an item in a menu bar
 * or tool-bar.  The idea is to create an array of such
 * structures with the information needed to create menus or
 * tool-bars.  The most convenient way to create such a structure
 * is to use the GNOMEUIINFO_* macros provided below. */
typedef struct {
        GnomeUIInfoType type;     /* Type of item */
        gchar *label;             /* String to use in the label */
        gchar *hint;              /* For tool-bar items, the
                                     tool-tip. For menu items, the
                                     status bar message */
        gpointer moreinfo;        /* For an item, toggle-item, or 
                                     radio-item, this is a pointer
                                     to the function to call when
                                     the item is activated. For
                                     a subtree, a pointer to
                                     another array of GnomeUIInfo 
                                     structures. For a radio-item
                                     lead entry, a pointer to an
                                     array of GnomeUIInfo
                                     structures for the radio 
                                     item group. For a help item, 
                                     specifies the help node to
                                     load (i.e. the application's
                                     identifier) or NULL for the
                                     main program's name.  For
                                     builder data, points to the 
                                     GnomeUIBuilderData structure
                                     for the following items */
        gpointer user_data;       /* Data pointer to pass to
                                     callbacks */
        gpointer unused_data;     /* Reserved for future expansion, 
                                     should be NULL */
        GnomeUIPixmapType pixmap_type;  /* Type of pixmap for
                                           the item */
        gpointer pixmap_info;     /* Pointer to the pixmap
                                     information:
                                    
                                     For GNOME_APP_PIXMAP_STOCK, a 
                                     pointer to the stock icon name.
                                    
                                     For GNOME_APP_PIXMAP_DATA, a 
                                     pointer to the inline xpm data.
                                    
                                     For GNOME_APP_PIXMAP_FILENAME, a 
                                     pointer to the filename
                                     string. */
        guint accelerator_key;    /* Accelerator key, or 0 for none */
        GdkModifierType ac_mods;  /* Mask of modifier keys for the 
                                     accelerator */

        GtkWidget *widget;        /* Filled in by gnome_app_create*,
                                     you can use this to tweak the
                                     widgets once they have been
                                     created */
} GnomeUIInfo;

     GNOMEUIINFO_HELP("app_name"),
     GNOMEUIINFO_MENU_ABOUT_ITEM(callback, data),
     GNOMEUIINFO_END

/*
 * A simple Gnome program, outside of GNOME tree, not using i18n
 * uiinfo.c
 */
/* the very basic gnome include */
#include <gnome.h>

/* a callback for the buttons */
static void
a_callback(GtkWidget *button, gpointer data)
{
        /*just print a string so that we know we got there*/
        g_print("Inside Callback\n");
}

GnomeUIInfo file_menu[] = {
        GNOMEUIINFO_MENU_EXIT_ITEM(gtk_main_quit,NULL),
        GNOMEUIINFO_END
};

GnomeUIInfo some_menu[] = {
        GNOMEUIINFO_ITEM_NONE("_Menuitem","Just a menuitem",
                              a_callback),
        GNOMEUIINFO_SEPARATOR,
        GNOMEUIINFO_ITEM_NONE("M_enuitem2","Just a menuitem",
                              a_callback),
        GNOMEUIINFO_END
};

GnomeUIInfo menubar[] = {
        GNOMEUIINFO_MENU_FILE_TREE(file_menu),
        GNOMEUIINFO_SUBTREE("_Some menu",some_menu),
        GNOMEUIINFO_END
};

GnomeUIInfo toolbar[] = {
        GNOMEUIINFO_ITEM_STOCK("Exit","Exit the application",
                               gtk_main_quit,
                               GNOME_STOCK_PIXMAP_EXIT),
        GNOMEUIINFO_END
};

int
main(int argc, char *argv[])
{
        GtkWidget *app;
        GtkWidget *button;
        GtkWidget *hbox;
        GtkWidget *label;

        /* Initialize GNOME, this is very similar to gtk_init */
        gnome_init ("menu-basic-example", "0.1", argc, argv);
        
        /* Create a Gnome app widget, which sets up a basic
           window for your application */
        app = gnome_app_new ("menu-basic-example",
                             "Basic GNOME Application");

        /* bind "delete_event", which is the event we get when
           the user closes the window with the window manager,
           to gtk_main_quit, which is a function that causes
           the gtk_main loop to exit, and consequently to quit
           the application */
        gtk_signal_connect (GTK_OBJECT (app), "delete_event",
                            GTK_SIGNAL_FUNC (gtk_main_quit),
                            NULL);

        /*make a label as the contents*/
        label = gtk_label_new("BLAH BLAH BLAH BLAH BLAH");

        /*add the label as contents of the window*/
        gnome_app_set_contents (GNOME_APP (app), label);

        /*create the menus for the application*/
        gnome_app_create_menus (GNOME_APP (app), menubar);

        /*create the tool-bar for the application*/
        gnome_app_create_toolbar (GNOME_APP (app), toolbar);

        /* show everything inside this app widget and the app
           widget itself */
        gtk_widget_show_all(app);
        
        /* enter the main loop */
        gtk_main ();
        
        return 0;
}