JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GtkMenuPeer_setupAccelGroup
(JNIEnv *env, jobject obj, jobject parent)
{
void *ptr1, *ptr2;
gdk_threads_enter ();
ptr1 = NSA_GET_PTR (env, obj);
if (!parent)
{
gtk_menu_set_accel_group (GTK_MENU (GTK_MENU_ITEM (ptr1)->submenu),
gtk_accel_group_new ());
}
else
{
GtkAccelGroup *parent_accel;
ptr2 = NSA_GET_PTR (env, parent);
parent_accel = gtk_menu_get_accel_group (GTK_MENU (GTK_MENU_ITEM (ptr2)->submenu));
gtk_menu_set_accel_group (GTK_MENU (GTK_MENU_ITEM (ptr1)->submenu),
parent_accel);
}
gdk_threads_leave ();
}
/**
* gnome_popup_menu_new_with_accelgroup
* @uiinfo: A #GnomeUIInfo array describing the new menu.
* @accelgroup: A #GtkAccelGroup describing the accelerator key structure.
*
* Creates a popup menu out of the specified @uiinfo array. Use
* gnome_popup_menu_do_popup() to pop the menu up, or attach it to a
* window with gnome_popup_menu_attach().
*
* Returns: A menu widget.
*/
GtkWidget *
gnome_popup_menu_new_with_accelgroup (GnomeUIInfo *uiinfo,
GtkAccelGroup *accelgroup)
{
GtkWidget *menu;
GtkAccelGroup *my_accelgroup;
/* We use our own callback marshaller so that it can fetch the
* popup user data from the popup menu and pass it on to the
* user-defined callbacks.
*/
menu = gtk_menu_new ();
if(accelgroup)
my_accelgroup = accelgroup;
else
my_accelgroup = gtk_accel_group_new();
gtk_menu_set_accel_group (GTK_MENU (menu), my_accelgroup);
if(!accelgroup)
g_object_unref (G_OBJECT (my_accelgroup));
gnome_popup_menu_append (menu, uiinfo);
return menu;
}
int
main (int argc,
char **argv)
{
hildon_gtk_init (&argc, &argv);
HildonProgram *program = hildon_program_get_instance ();
GtkWidget *window = hildon_window_new ();
hildon_program_add_window (program, HILDON_WINDOW (window));
GtkMenu *menu = GTK_MENU (gtk_menu_new ());
GtkAccelGroup *group = gtk_accel_group_new ();
gtk_menu_set_accel_group (menu, group);
GtkWidget *menu_item = gtk_image_menu_item_new_from_stock (GTK_STOCK_QUIT,
gtk_menu_get_accel_group (menu));
gtk_widget_show (menu_item);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
hildon_window_set_main_menu (HILDON_WINDOW (window), menu);
g_signal_connect_swapped (menu_item, "activate",
G_CALLBACK (gtk_object_destroy), window);
g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL);
gtk_widget_show_all (GTK_WIDGET (window));
gtk_main ();
return 0;
}
void ShowTrayMenu()
{
GtkWidget *menu;
GtkWidget *menu_item;
GtkWidget *icon;
int button, event_time;
menu = gtk_menu_new ();
//g_signal_connect (menu, "deactivate", G_CALLBACK(gtk_widget_destroy), NULL);
GtkAccelGroup *accel_group = gtk_accel_group_new();
gtk_menu_set_accel_group (GTK_MENU (menu), accel_group);
// ... add menu items with accelerators ...
menu_item = gtk_image_menu_item_new_with_mnemonic(_("Restore"));
g_signal_connect(menu_item, "activate", G_CALLBACK (on_tray_restore), NULL);
gtk_menu_append(menu, menu_item);
gtk_widget_show (menu_item); // Show the widget
icon = gtk_image_new_from_stock (GTK_STOCK_REFRESH, GTK_ICON_SIZE_MENU);
gtk_widget_show (icon);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item), icon);
menu_item = gtk_image_menu_item_new_with_mnemonic(_("Quit"));
g_signal_connect(menu_item, "activate", G_CALLBACK (on_tray_quit), NULL);
gtk_menu_append(menu, menu_item);
gtk_widget_show (menu_item); // Show the widget
icon = gtk_image_new_from_stock (GTK_STOCK_QUIT, GTK_ICON_SIZE_MENU);
gtk_widget_show (icon);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item), icon);
event_time = gtk_get_current_event_time ();
button = 0; //FIX: allow mouse button to trigger the submenu
gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, button, event_time);
}
static GtkWidget *create_mnu_room(GGZRoom *room)
{
GtkWidget *mnu_room;
GtkWidget *info;
GtkWidget *join;
GtkAccelGroup *accel_group;
accel_group = gtk_accel_group_new ();
mnu_room = gtk_menu_new ();
info = gtk_menu_item_new_with_label (_("Info"));
gtk_container_add (GTK_CONTAINER (mnu_room), info);
gtk_widget_add_accelerator (info, "activate", accel_group,
GDK_I, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
join = gtk_menu_item_new_with_label (_("Join"));
gtk_container_add (GTK_CONTAINER (mnu_room), join);
gtk_widget_add_accelerator (join, "activate", accel_group,
GDK_J, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
g_signal_connect (GTK_OBJECT (info), "activate",
G_CALLBACK (client_room_info_activate),
room);
g_signal_connect (GTK_OBJECT (join), "activate",
G_CALLBACK (client_room_join_activate),
room);
gtk_menu_set_accel_group (GTK_MENU (mnu_room), accel_group);
return mnu_room;
}
/**
* Go menu
*/
static GtkWidget *
gu_menubar_View(gu_window_t *gw, GtkAccelGroup *accel_group)
{
GtkWidget *M = gtk_menu_item_new_with_mnemonic("_View");
GtkWidget *m = gtk_menu_new();
GtkWidget *w;
gtk_menu_set_accel_group(GTK_MENU(m), accel_group);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(M), m);
gu_menu_add_toggle(m, "_Playdeck",
m_toggle_playdeck, gw, gw->gw_view_playdeck,
NULL, TRUE);
gu_menu_add_toggle(m, "_Statusbar",
m_toggle_statusbar, gw, gw->gw_view_statusbar,
NULL, TRUE);
gu_menu_add_sep(m);
w =
gu_menu_add_toggle(m, "_Fullscreen",
m_toggle_fullscreen, gw, gw->gw_view_statusbar,
gu_menu_accel_path("<Showtime-Main>/_View/_Fullscreen",
GDK_F11, 0),
TRUE);
g_signal_connect(G_OBJECT(gw->gw_window), "window-state-event",
G_CALLBACK(state_event), w);
return M;
}
static void
ol_menu_init ()
{
/* create accelerator group */
GtkAccelGroup *accel = ol_keybinding_get_accel_group ();
OlConfigProxy *config = ol_config_proxy_get_instance ();
popup_menu = ol_gui_get_widget ("pop-menu");
gtk_menu_set_accel_group (GTK_MENU (popup_menu), accel);
menu.lock = ol_gui_get_widget ("menu-lock");
if (menu.lock)
{
gtk_menu_item_set_accel_path (GTK_MENU_ITEM (menu.lock),
"<OSD Lyrics>/Lock");
}
menu.hide = ol_gui_get_widget ("menu-hide");
if (menu.hide)
{
gtk_menu_item_set_accel_path (GTK_MENU_ITEM (menu.hide),
"<OSD Lyrics>/Hide");
}
menu.preference = ol_gui_get_widget ("menu-prefernce");
menu.about = ol_gui_get_widget ("menu-about");
menu.quit = ol_gui_get_widget ("menu-quit");
menu.play = ol_gui_get_widget ("menu-play");
menu.pause = ol_gui_get_widget ("menu-pause");
menu.stop = ol_gui_get_widget ("menu-stop");
menu.prev = ol_gui_get_widget ("menu-prev");
menu.next = ol_gui_get_widget ("menu-next");
menu.switch_osd = ol_gui_get_widget ("menu-switch-osd");
menu.switch_scroll = ol_gui_get_widget ("menu-switch-scroll");
gtk_widget_show_all (popup_menu);
_locked_changed_cb (config, "OSD/locked", NULL);
_visible_changed_cb (config, ".visible", NULL);
_display_mode_osd_changed_cb (config, "General/display-mode-osd", NULL);
_display_mode_scroll_changed_cb (config, "General/display-mode-scroll", NULL);
g_signal_connect (config,
"changed::OSD/locked",
G_CALLBACK (_locked_changed_cb),
NULL);
g_signal_connect (config,
"changed::.visible",
G_CALLBACK (_visible_changed_cb),
NULL);
g_signal_connect (config,
"changed::General/display-mode-osd",
G_CALLBACK (_display_mode_osd_changed_cb),
NULL);
g_signal_connect (config,
"changed::General/display-mode-scroll",
G_CALLBACK (_display_mode_scroll_changed_cb),
NULL);
}
static GtkAccelGroup *ui_set_menu_item(GtkWidget **menu, GtkWidget **item,
char *name) {
*item = gtk_menu_item_new_with_mnemonic(name);
*menu = gtk_menu_new();
GtkAccelGroup *group = gtk_accel_group_new();
gtk_window_add_accel_group(GTK_WINDOW(mwin->main), group);
gtk_menu_set_accel_group(GTK_MENU(*menu), group);
return group;
}
/*
* Creates a new GtkWidget of class GtkMenu, performing any specialized
* initialization needed for the widget to work correctly in this environment.
* If a dialog box is used to initialize the widget, return NULL from this
* function, and call data->callback with your new widget when it is done.
* If the widget needs a special destroy handler, add a signal here.
*/
GtkWidget*
gb_menu_new(GbWidgetNewData *data)
{
GtkWidget *new_widget;
new_widget = gtk_menu_new ();
/* We create an accelerator table/group so that we can install accels
easily. */
gtk_menu_set_accel_group (GTK_MENU (new_widget), gtk_accel_group_new ());
return new_widget;
}
static void
toolkitview_refresh( vObject *vobject )
{
Toolkitview *kview = TOOLKITVIEW( vobject );
Toolkit *kit = TOOLKIT( VOBJECT( kview )->iobject );
Toolkitgroupview *kitgview = kview->kitgview;
GtkWidget *menu = kitgview->menu;
gboolean changed = FALSE;
#ifdef DEBUG
printf( "toolkitview_refresh: " );
iobject_print( VOBJECT( kview )->iobject );
#endif /*DEBUG*/
/* Make a button ready for the sub-menu.
*/
if( !kview->item ) {
kview->item = gtk_menu_item_new_with_label(
IOBJECT( kit )->name );
gtk_menu_shell_insert( GTK_MENU_SHELL( menu ),
kview->item,
ICONTAINER( kit )->pos + TOOLKITVIEW_MENU_OFFSET );
gtk_widget_show( kview->item );
kview->destroy_sid = g_signal_connect( kview->item,
"destroy",
G_CALLBACK( toolkitview_destroy_cb ), kview );
changed = TRUE;
}
if( !kview->menu ) {
iWindow *iwnd = IWINDOW( iwindow_get_root( menu ) );
char path[256];
kview->menu = gtk_menu_new();
gtk_menu_set_accel_group( GTK_MENU( kview->menu ),
iwnd->accel_group );
im_snprintf( path, 256,
"<mainw>/Toolkits/%s", IOBJECT( kit )->name );
gtk_menu_set_accel_path( GTK_MENU( kview->menu ), path );
changed = TRUE;
}
if( changed )
gtk_menu_item_set_submenu( GTK_MENU_ITEM( kview->item ),
kview->menu );
widget_visible( kview->item, ICONTAINER( kit )->children != NULL );
VOBJECT_CLASS( parent_class )->refresh( vobject );
}
GtkWidget *
gtk_model_menu_create_menu (GMenuModel *model,
GActionObservable *actions,
GtkAccelGroup *accels)
{
GtkWidget *menu;
menu = gtk_menu_new ();
gtk_menu_set_accel_group (GTK_MENU (menu), accels);
gtk_model_menu_bind (GTK_MENU_SHELL (menu), model, actions, accels, TRUE);
return menu;
}
GuiObject GuiMenuBar_addMenu2 (GuiObject bar, const wchar_t *title, long flags, GuiObject *menuTitle) {
GuiObject menu;
*menuTitle = gtk_menu_item_new_with_label (Melder_peekWcsToUtf8 (title));
menu = gtk_menu_new ();
GtkAccelGroup *ag = (GtkAccelGroup*)(GTK_IS_MENU_BAR (bar) ? g_object_get_data (G_OBJECT (bar), "accel-group") : gtk_menu_get_accel_group (GTK_MENU (bar)));
gtk_menu_set_accel_group (GTK_MENU (menu), ag);
if (flags & GuiMenu_INSENSITIVE)
gtk_widget_set_sensitive (menu, FALSE);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (*menuTitle), menu);
gtk_menu_shell_append (GTK_MENU_SHELL (bar), *menuTitle);
gtk_widget_show (menu);
gtk_widget_show (*menuTitle);
return menu;
}
/**
* Help menu
*/
static GtkWidget *
gu_menubar_Help(gu_window_t *gw, GtkAccelGroup *accel_group)
{
GtkWidget *M = gtk_menu_item_new_with_mnemonic("_Help");
GtkWidget *m = gtk_menu_new();
gtk_menu_set_accel_group(GTK_MENU(m), accel_group);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(M), m);
gu_menu_add_item(m, "_About Showtime",
m_about, gw, GTK_STOCK_ABOUT,
NULL, TRUE);
return M;
}
/**
* File menu
*/
static GtkWidget *
gu_menubar_File(gu_window_t *gw, GtkAccelGroup *accel_group)
{
GtkWidget *M = gtk_menu_item_new_with_mnemonic("_File");
GtkWidget *m = gtk_menu_new();
gtk_menu_set_accel_group(GTK_MENU(m), accel_group);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(M), m);
gu_menu_add_item(m, "_New Window",
m_openwindow, gw, GTK_STOCK_NEW,
gu_menu_accel_path("<Showtime-Main>/_File/NewWindow",
GDK_N, GDK_CONTROL_MASK), TRUE);
gu_menu_add_item(m, "New _Tab",
m_opentab, gw, GTK_STOCK_NEW,
gu_menu_accel_path("<Showtime-Main>/_File/NewTab",
GDK_T, GDK_CONTROL_MASK), TRUE);
gu_menu_add_item(m, "_Open File...",
m_openfile, gw, GTK_STOCK_OPEN,
gu_menu_accel_path("<Showtime-Main>/_File/OpenFile",
GDK_O, GDK_CONTROL_MASK), TRUE);
gu_menu_add_item(m, "_Open Directory...",
m_opendir, gw, GTK_STOCK_OPEN,
gu_menu_accel_path("<Showtime-Main>/_File/OpenDir",
GDK_D, GDK_CONTROL_MASK), TRUE);
gu_menu_add_item(m, "Close Win_dow",
m_closewindow, gw, GTK_STOCK_CLOSE,
gu_menu_accel_path("<Showtime-Main>/_File/CloseWindow",
GDK_W, GDK_SHIFT_MASK |
GDK_CONTROL_MASK), TRUE);
gu_menu_add_item(m, "_Close Tab",
m_closetab, gw, GTK_STOCK_CLOSE,
gu_menu_accel_path("<Showtime-Main>/_File/CloseTab",
GDK_W, GDK_CONTROL_MASK), TRUE);
gu_menu_add_sep(m);
gu_menu_add_item(m, "_Quit",
m_quit, gw, GTK_STOCK_QUIT,
gu_menu_accel_path("<Showtime-Main>/_File/Quit",
GDK_Q, GDK_CONTROL_MASK), TRUE);
return M;
}
int
clip_GTK_MENUSETACCELGROUP(ClipMachine * ClipMachineMemory)
{
C_widget *cmnu = _fetch_cw_arg(ClipMachineMemory);
C_widget *caccelgroup = _fetch_cwidget(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2));
CHECKCWID(cmnu, GTK_IS_MENU);
CHECKCWID(caccelgroup, GTK_IS_ACCEL_GROUP);
gtk_menu_set_accel_group(GTK_MENU(cmnu->widget), GTK_ACCEL_GROUP(caccelgroup->widget));
return 0;
err:
return 1;
}
/**
* Go menu
*/
static GtkWidget *
gu_menubar_Go(gu_window_t *gw, GtkAccelGroup *accel_group)
{
GtkWidget *M = gtk_menu_item_new_with_mnemonic("_Go");
GtkWidget *m = gtk_menu_new();
gtk_menu_set_accel_group(GTK_MENU(m), accel_group);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(M), m);
gu_menu_add_item(m, "_Playqueue",
m_openplayqueue, gw, GTK_STOCK_EXECUTE,
gu_menu_accel_path("<Showtime-Main>/_Go/Playqueue",
GDK_P, GDK_CONTROL_MASK), TRUE);
return M;
}
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GtkPopupMenuPeer_setupAccelGroup
(JNIEnv *env, jobject obj, jobject parent)
{
void *ptr1, *ptr2;
GtkMenu *menu;
ptr1 = NSA_GET_PTR (env, obj);
ptr2 = NSA_GET_PTR (env, parent);
gdk_threads_enter ();
menu = GTK_MENU (GTK_MENU_ITEM (ptr1)->submenu);
gtk_menu_set_accel_group (menu, gtk_accel_group_new ());
gtk_accel_group_attach (gtk_menu_get_accel_group (menu),
GTK_OBJECT (gtk_widget_get_toplevel (ptr2)));
gdk_threads_leave ();
}
/* Insert a menu into the menu bar. */
void EvalCcRqINSERTMENU (CrossCallInfo *pcci)
{
gint i;
gchar *title;
GtkWidget *parent_menu, *root_menu, *sub_menu;
GtkAccelGroup *accel_group;
printf("EvalCcRqINSERTMENU\n");
title = createMnemonicString((gchar *) pcci->p3);
parent_menu = GTK_WIDGET(pcci->p2);
sub_menu = GTK_WIDGET(pcci->p4);
if (GTK_IS_MENU_BAR(parent_menu))
{
printf("Adding to a menu bar.\n");
GtkWidget *frame = gtk_widget_get_parent(gtk_widget_get_parent(parent_menu));
if (!G_IS_OBJECT(frame))
frame = gtk_widget_get_parent(parent_menu);
accel_group = ((GtkAccelGroup*)gtk_accel_groups_from_object (G_OBJECT(frame))->data);
}
else
{
printf("We're not adding to a menu bar!?!\n");
accel_group = gtk_menu_get_accel_group (GTK_MENU(parent_menu));
}
gtk_menu_set_accel_group (GTK_MENU(sub_menu), accel_group);
root_menu = gtk_menu_item_new_with_mnemonic(title);
gtk_widget_set_sensitive(root_menu, (gboolean) pcci->p1);
gtk_widget_show (root_menu);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (root_menu), sub_menu);
if (GTK_IS_MENU_BAR(parent_menu))
{
gtk_menu_shell_insert(GTK_MENU_SHELL(parent_menu), root_menu, (gint) pcci->p5);
} else {
gtk_menu_insert(GTK_MENU(parent_menu), root_menu, (gint) pcci->p5);
}
rfree(title);
MakeReturn1Cci (pcci, (int64_t) sub_menu);
}
/* Create the popup menu and attach it to the progress bar. This will make sure
* that the accelerators will work from application load. */
static void
create_popup_menu (GtkWidget *menu,
GtkWidget *window,
GtkWidget *progress)
{
GtkWidget *pulse, *fill, *clear, *separator;
GtkAccelGroup *group;
/* Create a keyboard accelerator group for the application. */
group = gtk_accel_group_new ();
gtk_window_add_accel_group (GTK_WINDOW (window), group);
gtk_menu_set_accel_group (GTK_MENU (menu), group);
pulse = gtk_menu_item_new_with_label ("Pulse Progress");
fill = gtk_menu_item_new_with_label ("Set as Complete");
clear = gtk_menu_item_new_with_label ("Clear Progress");
separator = gtk_separator_menu_item_new ();
/* Add the necessary keyboard accelerators. */
gtk_widget_add_accelerator (pulse, "activate", group, GDK_P,
GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
gtk_widget_add_accelerator (fill, "activate", group, GDK_F,
GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
gtk_widget_add_accelerator (clear, "activate", group, GDK_C,
GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
g_signal_connect (G_OBJECT (pulse), "activate",
G_CALLBACK (pulse_activated), progress);
g_signal_connect (G_OBJECT (fill), "activate",
G_CALLBACK (fill_activated), progress);
g_signal_connect (G_OBJECT (clear), "activate",
G_CALLBACK (clear_activated), progress);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), pulse);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), separator);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), fill);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), clear);
gtk_menu_attach_to_widget (GTK_MENU (menu), progress, NULL);
gtk_widget_show_all (menu);
}
static void create_menu1(void)
{
GtkWidget *menu;
GtkWidget *item;
GtkAccelGroup *accel_group;
accel_group = gtk_accel_group_new();
menu = gtk_menu_new();
item =
#ifdef HAVE_GTK_310
gtk_menu_item_new_with_mnemonic("_Copy");
#else
gtk_image_menu_item_new_from_stock("gtk-copy", accel_group);
#endif
gtk_widget_show(item);
g_signal_connect(G_OBJECT(item), "clicked",
G_CALLBACK(on_copy_activate), NULL);
gtk_container_add(GTK_CONTAINER(menu), item);
gtk_menu_set_accel_group(GTK_MENU(menu), accel_group);
gtk_menu_popup((GtkMenu *)menu, NULL, NULL, NULL, NULL, 2,
gtk_get_current_event_time());
}
static void
create_popup_menu (ViewerCbInfo * info)
{
GtkWidget *popup_menu;
GtkWidget *menu_item;
GtkWidget *stock;
popup_menu = gtk_menu_new ();
gtk_menu_set_accel_group (GTK_MENU (popup_menu), info->accel_group);
if (info->base_uri) {
menu_item = gtk_image_menu_item_new_with_label (_("Copy SVG location"));
stock = gtk_image_new_from_stock (GTK_STOCK_COPY, GTK_ICON_SIZE_MENU);
gtk_widget_show (stock);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item), stock);
g_signal_connect (menu_item, "activate", G_CALLBACK (copy_svg_location), info);
gtk_widget_show (menu_item);
gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), menu_item);
gtk_widget_add_accelerator (menu_item, "activate", info->accel_group, GDK_C,
GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
}
menu_item = gtk_image_menu_item_new_from_stock (GTK_STOCK_SAVE, NULL);
g_signal_connect (menu_item, "activate", G_CALLBACK (save_svg), info);
gtk_widget_show (menu_item);
gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), menu_item);
gtk_widget_add_accelerator (menu_item, "activate", info->accel_group, GDK_S, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
menu_item = gtk_image_menu_item_new_with_label (_("Save as PNG"));
stock = gtk_image_new_from_stock (GTK_STOCK_SAVE_AS, GTK_ICON_SIZE_MENU);
gtk_widget_show (stock);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item), stock);
g_signal_connect (menu_item, "activate", G_CALLBACK (save_pixbuf), info);
gtk_widget_show (menu_item);
gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), menu_item);
gtk_widget_add_accelerator (menu_item, "activate", info->accel_group, GDK_S,
GDK_CONTROL_MASK | GDK_SHIFT_MASK, GTK_ACCEL_VISIBLE);
#if GTK_CHECK_VERSION(2,10,0)
menu_item = gtk_image_menu_item_new_from_stock (GTK_STOCK_PRINT, NULL);
g_signal_connect (menu_item, "activate", G_CALLBACK (print_pixbuf), info);
gtk_widget_show (menu_item);
gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), menu_item);
gtk_widget_add_accelerator (menu_item, "activate", info->accel_group, GDK_P, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
#endif
menu_item = gtk_image_menu_item_new_from_stock (GTK_STOCK_ZOOM_IN, NULL);
g_signal_connect (menu_item, "activate", G_CALLBACK (zoom_in), info);
gtk_widget_show (menu_item);
gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), menu_item);
gtk_widget_add_accelerator (menu_item, "activate", info->accel_group, GDK_plus,
GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
menu_item = gtk_image_menu_item_new_from_stock (GTK_STOCK_ZOOM_OUT, NULL);
g_signal_connect (menu_item, "activate", G_CALLBACK (zoom_out), info);
gtk_widget_show (menu_item);
gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), menu_item);
gtk_widget_add_accelerator (menu_item, "activate", info->accel_group, GDK_minus,
GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
info->popup_menu = popup_menu;
}
GtkWidget* mooMenuBar (GtkWidget* window)
{
GtkWidget *menubar, *game, *view, *help;
GtkWidget *gamemenu, *viewmenu, *helpmenu;
GtkWidget *newgame, *quit, *hint, *rules, *about;
GtkWidget *newgame_image, *quit_image,
*hint_image, *rules_image;
GtkWidget *separator;
GtkAccelGroup *accel_group;
accel_group = gtk_accel_group_new ();
gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
gtk_menu_set_accel_group (GTK_MENU (menubar), accel_group);
/*-------------------------------------------*\
* Create menubar: Game, View, Help *
\*-------------------------------------------*/
menubar = gtk_menu_bar_new ();
game = gtk_menu_item_new_with_mnemonic ("_Game");
gtk_widget_show (game);
gtk_container_add (GTK_CONTAINER (menubar), game);
/*-->Game Menu Starts Here<--*/
gamemenu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (game), gamemenu);
gtk_widget_set_size_request (menubar, -1, 25);
newgame = gtk_image_menu_item_new_with_mnemonic ("_New Game");
gtk_widget_show (newgame);
gtk_container_add (GTK_CONTAINER (gamemenu), newgame);
gtk_widget_add_accelerator (newgame, "activate", accel_group,
GDK_N, (GdkModifierType) GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
newgame_image = gtk_image_new_from_stock ("gtk-new", GTK_ICON_SIZE_MENU);
gtk_widget_show (newgame_image);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (newgame), newgame_image);
g_signal_connect ((gpointer) newgame, "activate",
G_CALLBACK (start_newgame), NULL);
separator = gtk_separator_menu_item_new ();
gtk_widget_show (separator);
gtk_container_add (GTK_CONTAINER (gamemenu), separator);
gtk_widget_set_sensitive (separator, FALSE);
quit = gtk_image_menu_item_new_with_mnemonic ("_Quit");
gtk_widget_show (quit);
gtk_container_add (GTK_CONTAINER (gamemenu), quit);
gtk_widget_add_accelerator (quit, "activate", accel_group,
GDK_Q, (GdkModifierType) GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
quit_image = gtk_image_new_from_stock ("gtk-quit", GTK_ICON_SIZE_MENU);
//create_pixmap (mainwindow, "Eket Mask.xpm");
gtk_widget_show (quit_image);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (quit), quit_image);
g_signal_connect ((gpointer) quit, "activate",
G_CALLBACK (gtk_main_quit),
NULL);
/*-->Game Menu Ends Here<--*/
/*-->View Menu Starts Here Here<--*/
view = gtk_menu_item_new_with_mnemonic ("_View");
gtk_widget_show (view);
gtk_container_add (GTK_CONTAINER (menubar), view);
viewmenu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (view), viewmenu);
hint = gtk_image_menu_item_new_with_mnemonic ("Show _Hint");
gtk_widget_show (hint);
gtk_container_add (GTK_CONTAINER (viewmenu), hint);
gtk_widget_add_accelerator (hint, "activate", accel_group,
GDK_h, (GdkModifierType) GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
hint_image = gtk_image_new_from_stock ("gtk-dialog-info", GTK_ICON_SIZE_MENU);
gtk_widget_show (hint_image);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (hint), hint_image);
g_signal_connect ((gpointer) hint, "activate",
G_CALLBACK (showHint),
NULL);
/*-->View Menu Ends Here<--*/
/*-->Help Menu Starts Here<--*/
help = gtk_menu_item_new_with_mnemonic ("_Help");
gtk_widget_show (help);
gtk_container_add (GTK_CONTAINER (menubar), help);
helpmenu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (help), helpmenu);
rules = gtk_image_menu_item_new_with_mnemonic ("_Rules");
gtk_widget_show (rules);
gtk_container_add (GTK_CONTAINER (helpmenu), rules);
gtk_widget_add_accelerator (rules, "activate", accel_group,
GDK_F1, (GdkModifierType) 0,
GTK_ACCEL_VISIBLE);
rules_image = gtk_image_new_from_stock ("gtk-help", GTK_ICON_SIZE_MENU);
gtk_widget_show (rules_image);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (rules), rules_image);
g_signal_connect ((gpointer) rules, "activate",
G_CALLBACK (mooRules), NULL);
separator = gtk_separator_menu_item_new ();
gtk_widget_show (separator);
gtk_container_add (GTK_CONTAINER (helpmenu), separator);
gtk_widget_set_sensitive (separator, FALSE);
about = gtk_image_menu_item_new_from_stock ("gtk-about", accel_group);
gtk_widget_show (about);
gtk_container_add (GTK_CONTAINER (helpmenu), about);
g_signal_connect ((gpointer) about, "activate",
G_CALLBACK (init_about),
NULL);
/*-->Help Menu Ends Here<--*/
return menubar;
}
int
main (int argc, char **argv)
{
static GtkWidget *window = NULL;
GtkWidget *box1;
GtkWidget *box2;
GtkWidget *button;
GtkWidget *optionmenu;
GtkWidget *separator;
gtk_init (&argc, &argv);
if (!window)
{
GtkWidget *menubar;
GtkWidget *menu;
GtkWidget *submenu;
GtkWidget *menuitem;
GtkAccelGroup *accel_group;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (window, "destroy",
G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect (window, "delete-event",
G_CALLBACK (gtk_true), NULL);
accel_group = gtk_accel_group_new ();
gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
gtk_window_set_title (GTK_WINDOW (window), "menus");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
box1 = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), box1);
gtk_widget_show (box1);
menubar = gtk_menu_bar_new ();
gtk_box_pack_start (GTK_BOX (box1), menubar, FALSE, TRUE, 0);
gtk_widget_show (menubar);
menu = create_menu (2, TRUE);
menuitem = gtk_menu_item_new_with_label ("test\nline2");
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
gtk_widget_show (menuitem);
menuitem = gtk_menu_item_new_with_label ("dynamic");
submenu = create_menu (3, TRUE);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
gtk_widget_show (menuitem);
g_timeout_add (250, change_item, submenu);
menuitem = gtk_menu_item_new_with_label ("bar");
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (4, TRUE));
gtk_menu_item_set_right_justified (GTK_MENU_ITEM (menuitem), TRUE);
gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
gtk_widget_show (menuitem);
box2 = gtk_vbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, TRUE, TRUE, 0);
gtk_widget_show (box2);
menu = create_menu (1, FALSE);
gtk_menu_set_accel_group (GTK_MENU (menu), accel_group);
menuitem = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
menuitem = gtk_check_menu_item_new_with_label ("Accelerate Me");
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
gtk_widget_add_accelerator (menuitem,
"activate",
accel_group,
GDK_F1,
0,
GTK_ACCEL_VISIBLE);
menuitem = gtk_check_menu_item_new_with_label ("Accelerator Locked");
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
gtk_widget_add_accelerator (menuitem,
"activate",
accel_group,
GDK_F2,
0,
GTK_ACCEL_VISIBLE | GTK_ACCEL_LOCKED);
menuitem = gtk_check_menu_item_new_with_label ("Accelerators Frozen");
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
gtk_widget_add_accelerator (menuitem,
"activate",
accel_group,
GDK_F2,
0,
GTK_ACCEL_VISIBLE);
gtk_widget_add_accelerator (menuitem,
"activate",
accel_group,
GDK_F3,
0,
GTK_ACCEL_VISIBLE);
optionmenu = gtk_option_menu_new ();
gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu), menu);
gtk_option_menu_set_history (GTK_OPTION_MENU (optionmenu), 3);
gtk_box_pack_start (GTK_BOX (box2), optionmenu, TRUE, TRUE, 0);
gtk_widget_show (optionmenu);
separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (box1), separator, FALSE, TRUE, 0);
gtk_widget_show (separator);
box2 = gtk_vbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (box2), 10);
gtk_box_pack_start (GTK_BOX (box1), box2, FALSE, TRUE, 0);
gtk_widget_show (box2);
button = gtk_button_new_with_label ("close");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK(gtk_widget_destroy), window);
gtk_box_pack_start (GTK_BOX (box2), button, TRUE, TRUE, 0);
GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
gtk_widget_grab_default (button);
gtk_widget_show (button);
}
if (!GTK_WIDGET_VISIBLE (window))
{
gtk_widget_show (window);
}
else
{
gtk_widget_destroy (window);
window = NULL;
}
gtk_main ();
return 0;
}
