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; }