void wxMenu::Init() { m_popupShown = false; m_accel = gtk_accel_group_new(); m_menu = gtk_menu_new(); // NB: keep reference to the menu so that it is not destroyed behind // our back by GTK+ e.g. when it is removed from menubar: g_object_ref_sink(m_menu); m_owner = NULL; // Tearoffs are entries, just like separators. So if we want this // menu to be a tear-off one, we just append a tearoff entry // immediately. if ( m_style & wxMENU_TEAROFF ) { GtkWidget *tearoff = gtk_tearoff_menu_item_new(); gtk_menu_shell_append(GTK_MENU_SHELL(m_menu), tearoff); } // append the title as the very first entry if we have it if ( !m_title.empty() ) { Append(wxGTK_TITLE_ID, m_title); AppendSeparator(); } // "show" occurs for sub-menus which are not showing, so use "map" instead g_signal_connect(m_menu, "map", G_CALLBACK(menu_map), this); g_signal_connect(m_menu, "hide", G_CALLBACK(menu_hide), this); }
void wxMenu::Init() { m_accel = gtk_accel_group_new(); m_menu = gtk_menu_new(); // NB: keep reference to the menu so that it is not destroyed behind // our back by GTK+ e.g. when it is removed from menubar: gtk_widget_ref(m_menu); m_owner = NULL; // Tearoffs are entries, just like separators. So if we want this // menu to be a tear-off one, we just append a tearoff entry // immediately. if ( m_style & wxMENU_TEAROFF ) { GtkWidget *tearoff = gtk_tearoff_menu_item_new(); gtk_menu_append(GTK_MENU(m_menu), tearoff); } m_prevRadio = NULL; // append the title as the very first entry if we have it if ( !m_title.empty() ) { Append(wxGTK_TITLE_ID, m_title); AppendSeparator(); } }
void create_freq_menu(void) { GtkWidget *menuitem; int i; if (menu != NULL) { gtk_widget_destroy(menu); } if (!nstations) { menu = NULL; return; } menu = gtk_menu_new(); gtk_menu_set_title(GTK_MENU(menu),"frequency menu"); menuitem = gtk_tearoff_menu_item_new(); gtk_menu_append(GTK_MENU(menu),menuitem); gtk_widget_show(menuitem); for (i=0; i < nstations; i++) { menuitem = gtk_menu_item_new_with_label(stations[i].station_name); gtk_menu_append(GTK_MENU(menu),menuitem); gtk_signal_connect(GTK_OBJECT(menuitem),"activate", GTK_SIGNAL_FUNC(freq_menu_activated),GINT_TO_POINTER(i)); } gtk_widget_show_all(menu); }
static void pipe_menu_recreate (GtkWidget *item, gchar *command) { gchar *stdout_for_cmd; gchar *cache_entries = g_object_get_data (G_OBJECT(item), "cached"); GtkWidget *submenu; submenu = gtk_menu_item_get_submenu (GTK_MENU_ITEM(item)); if (submenu) { if (strcmp (cache_entries, "yes") != 0) { gtk_widget_destroy (submenu); submenu = NULL; } } if (!submenu) { submenu = gtk_menu_new(); if (g_spawn_command_line_sync (parse_expand_tilde(command), &stdout_for_cmd, NULL, NULL, NULL)) { GError *error = NULL; DeskmenuObject *dm_object = g_object_get_data (G_OBJECT(item), "menu"); dm_object->current_menu = submenu; dm_object->make_from_pipe = TRUE; if (gtk_menu_get_tearoff_state (GTK_MENU(dm_object->menu))) { gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu), gtk_tearoff_menu_item_new()); } GMarkupParseContext *context = g_markup_parse_context_new (&parser, 0, dm_object, NULL); g_markup_parse_context_parse (context, (const gchar *)stdout_for_cmd, strlen((const char *)stdout_for_cmd), &error); g_markup_parse_context_free (context); if (error) { g_print("%s", error->message); //spit out the message manually if (dm_object->current_item) { //force reset deskmenu_free_item(dm_object); } g_error_free (error); } g_free(stdout_for_cmd); dm_object->make_from_pipe = FALSE; } else { GtkWidget *empty_item = gtk_menu_item_new_with_label ("Unable to get output"); gtk_widget_set_sensitive (empty_item, FALSE); gtk_menu_shell_append (GTK_MENU_SHELL (submenu), empty_item); } gtk_widget_show_all(submenu); gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), submenu); } }
/** * Adds a teaoroff menuitem if there isn't one already and the gconf option is set */ void gul_gui_setup_tearoff (GtkMenuShell *ms) { gboolean has_tearoff = eel_gconf_get_boolean ("/desktop/gnome/interface/menus_have_tearoff"); if (has_tearoff && !gul_gui_menu_shell_has_tearoff (ms)) { GtkWidget *tearoff = gtk_tearoff_menu_item_new (); gtk_widget_show (tearoff); gtk_menu_shell_prepend (ms, tearoff); } }
static GtkWidget * CreateMenuBar(void) { GtkWidget *menubar; GtkWidget *game_item, *game_menu; GtkWidget *info_item, *info_menu; GtkWidget *tearoff; menubar = gtk_menu_bar_new(); game_item = gtk_menu_item_new_with_label("Game"); game_menu = gtk_menu_new(); tearoff = gtk_tearoff_menu_item_new(); gtk_menu_append(GTK_MENU(game_menu), tearoff); new_menu_item(game_menu, DIALOG_NEWGAME); pausebutton = new_menu_item(game_menu, DIALOG_PAUSEGAME); new_menu_item(game_menu, DIALOG_WARPLEVEL); new_menu_item(game_menu, DIALOG_HIGHSCORE); new_menu_item(game_menu, DIALOG_QUITGAME); gtk_menu_bar_append(GTK_MENU_BAR(menubar), game_item); gtk_menu_item_set_submenu(GTK_MENU_ITEM(game_item), game_menu); info_item = gtk_menu_item_new_with_label("Info"); info_menu = gtk_menu_new(); tearoff = gtk_tearoff_menu_item_new(); gtk_menu_append(GTK_MENU(info_menu), tearoff); new_menu_item(info_menu, DIALOG_STORY); new_menu_item(info_menu, DIALOG_RULES); new_menu_item(info_menu, DIALOG_ABOUT); gtk_menu_bar_append(GTK_MENU_BAR(menubar), info_item); gtk_menu_item_set_submenu(GTK_MENU_ITEM(info_item), info_menu); return menubar; }
static GtkWidget * build_menu(GtkWidget *sheet, Register_Window *rw) { GtkWidget *menu; GtkWidget *item; // GtkAccelGroup *accel_group; int i; if(sheet==NULL || rw==NULL) { printf("Warning build_menu(%x,%x)\n",(unsigned int)sheet,(unsigned int)rw); return NULL; } menu=gtk_menu_new(); /* accel_group = gtk_accel_group_new (); gtk_accel_group_attach (accel_group, GTK_OBJECT (rw->gui_obj.window)); gtk_menu_set_accel_group (GTK_MENU (menu), accel_group); */ item = gtk_tearoff_menu_item_new (); gtk_menu_append (GTK_MENU (menu), item); gtk_widget_show (item); for (i=0; i < (sizeof(menu_items)/sizeof(menu_items[0])) ; i++){ item=gtk_menu_item_new_with_label(menu_items[i].name); gtk_signal_connect(GTK_OBJECT(item),"activate", (GtkSignalFunc) popup_activated, &menu_items[i]); GTK_WIDGET_SET_FLAGS (item, GTK_SENSITIVE | GTK_CAN_FOCUS); if(rw->type == REGISTER_EEPROM && menu_items[i].id!=MENU_ADD_WATCH) { GTK_WIDGET_UNSET_FLAGS (item, GTK_SENSITIVE | GTK_CAN_FOCUS); } gtk_widget_show(item); gtk_menu_append(GTK_MENU(menu),item); } return menu; }
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GtkMenuPeer_addTearOff (JNIEnv *env, jobject obj) { void *ptr1; GtkWidget *menu, *item; gdk_threads_enter (); ptr1 = NSA_GET_PTR (env, obj); menu = gtk_menu_item_get_submenu (GTK_MENU_ITEM (ptr1)); item = gtk_tearoff_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); gtk_widget_show (item); gdk_threads_leave (); }
void go_combo_box_construct (GOComboBox *combo, GtkWidget *display_widget, GtkWidget *popdown_container, G_GNUC_UNUSED GtkWidget *popdown_focus) { GtkWidget *tearable; GtkWidget *vbox; g_return_if_fail (GO_IS_COMBO_BOX (combo)); gtk_box_set_spacing (GTK_BOX (combo), 0); gtk_box_set_homogeneous (GTK_BOX (combo), FALSE); combo->priv->popdown_container = popdown_container; combo->priv->display_widget = NULL; vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5); tearable = gtk_tearoff_menu_item_new (); g_signal_connect (tearable, "enter-notify-event", G_CALLBACK (cb_tearable_enter_leave), GINT_TO_POINTER (TRUE)); g_signal_connect (tearable, "leave-notify-event", G_CALLBACK (cb_tearable_enter_leave), GINT_TO_POINTER (FALSE)); g_signal_connect (tearable, "button-release-event", G_CALLBACK (cb_tearable_button_release), (gpointer) combo); g_signal_connect (tearable, "parent-set", G_CALLBACK (cb_tearable_parent_changed), (gpointer) combo); gtk_box_pack_start (GTK_BOX (vbox), tearable, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox), popdown_container, TRUE, TRUE, 0); combo->priv->tearable = tearable; g_object_set (tearable, "no-show-all", TRUE, NULL); go_combo_box_set_tearable (combo, FALSE); go_combo_box_set_relief (combo, GTK_RELIEF_NORMAL); go_combo_box_set_display (combo, display_widget); gtk_container_add (GTK_CONTAINER (combo->priv->frame), vbox); gtk_widget_show_all (combo->priv->frame); }
GtkWidget *DialogPeer::CreateFileMenu() { GtkWidget *menushell, *window; GtkWidget *menu, *menuitem; window = GTK_WIDGET(g_datalist_get_data(&widset, "window-widget")); menushell = gtk_menu_item_new_with_mnemonic(_("_File")); menu = gtk_menu_new(); gtk_menu_item_set_submenu(GTK_MENU_ITEM(menushell), menu); menuitem = gtk_menu_item_new_with_label(_("Attach File")); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); g_signal_connect_swapped(menuitem, "activate", G_CALLBACK(AttachRegular), this); gtk_widget_add_accelerator(menuitem, "activate", accel, GDK_S, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); menuitem = gtk_menu_item_new_with_label(_("Attach Folder")); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); g_signal_connect_swapped(menuitem, "activate", G_CALLBACK(AttachFolder), this); gtk_widget_add_accelerator(menuitem, "activate", accel, GDK_D, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); menuitem = gtk_menu_item_new_with_label(_("Request Shared Resources")); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); g_signal_connect_swapped(menuitem, "activate", G_CALLBACK(AskSharedFiles), grpinf); gtk_widget_add_accelerator(menuitem, "activate", accel, GDK_R, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); menuitem = gtk_tearoff_menu_item_new(); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); menuitem = gtk_menu_item_new_with_label(_("Close")); gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem); g_signal_connect_swapped(menuitem, "activate", G_CALLBACK(gtk_widget_destroy), window); gtk_widget_add_accelerator(menuitem, "activate", accel, GDK_W, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); g_datalist_set_data(&widset, "file-menu",menu); return menushell; }
/**** Tearoff menu item constructor ****/ int clip_GTK_TEAROFFMENUITEMNEW(ClipMachine * ClipMachineMemory) { ClipVar *cv = _clip_spar(ClipMachineMemory, 1); GtkWidget *wid = NULL; C_widget *cwid; CHECKOPT(1, MAP_type_of_ClipVarType); wid = gtk_tearoff_menu_item_new(); if (!wid) goto err; cwid = _register_widget(ClipMachineMemory, wid, cv); _clip_mclone(ClipMachineMemory, RETPTR(ClipMachineMemory), &cwid->obj); return 0; err: return 1; }
static GtkWidget * create_menu (gint depth, gboolean tearoff) { GtkWidget *menu; GtkWidget *menuitem; GSList *group; char buf[32]; int i, j; if (depth < 1) return NULL; menu = gtk_menu_new (); group = NULL; if (tearoff) { menuitem = gtk_tearoff_menu_item_new (); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); gtk_widget_show (menuitem); } for (i = 0, j = 1; i < 5; i++, j++) { sprintf (buf, "item %2d - %d", depth, j); menuitem = gtk_radio_menu_item_new_with_label (group, buf); group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (menuitem)); gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); gtk_widget_show (menuitem); if (i == 3) gtk_widget_set_sensitive (menuitem, FALSE); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), create_menu (depth - 1, TRUE)); } return menu; }
static void menushell_build_children (GladeXML *xml, GtkWidget *w, GladeWidgetInfo *info) { int i, j; MateUIInfo infos[2] = { { MATE_APP_UI_ITEM }, MATEUIINFO_END }; for (i = 0; i < info->n_children; i++) { GladeChildInfo *cinfo = &info->children[i]; GladeWidgetInfo *cwinfo = cinfo->child; GtkWidget *child; gchar *stock_name = NULL; for (j = 0; j < cwinfo->n_properties; j++) { if (!strcmp (cwinfo->properties[j].name, "stock_item")) { stock_name = cwinfo->properties[j].value; break; } } if (!stock_name) { /* this is a normal menu item */ child = glade_xml_build_widget (xml, cwinfo); gtk_menu_shell_append (GTK_MENU_SHELL (w), child); continue; } /* load the template MateUIInfo for this item */ if (!get_stock_uiinfo (stock_name, &infos[0])) { /* failure ... */ if (!strncmp (stock_name, "MATEUIINFO_", 12)) stock_name += 12; child = gtk_menu_item_new_with_label (stock_name); glade_xml_set_common_params (xml, child, cwinfo); gtk_menu_shell_append (GTK_MENU_SHELL(w), child); continue; } /* we now have the template for this item. Now fill it in */ for (j = 0; j < cwinfo->n_properties; j++) { const char *name = cwinfo->properties[j].name; const char *value = cwinfo->properties[j].value; if (!strcmp (name, "label")) infos[0].label = _(value); else if (!strcmp (name, "tooltip")) infos[0].hint = _(value); } mate_app_fill_menu (GTK_MENU_SHELL(w), infos, glade_xml_ensure_accel(xml), TRUE, i); child = infos[0].widget; gtk_menu_item_remove_submenu(GTK_MENU_ITEM(child)); glade_xml_set_common_params(xml, child, cwinfo); } #if 0 if (uline) glade_xml_pop_uline_accel(xml); #endif #if 0 if (strcmp(info->classname, "GtkMenuBar") != 0 && mate_preferences_get_menus_have_tearoff()) { GtkWidget *tearoff = gtk_tearoff_menu_item_new(); gtk_menu_prepend(GTK_MENU(w), tearoff); gtk_widget_show(tearoff); } #endif }
/*! \brief Translate a resource tree into a menu structure * * \param [in] menu The GHidMainMenu widget to be acted on * \param [in] shall The base menu shell (a menu bar or popup menu) * \param [in] res The base of the resource tree * */ void ghid_main_menu_real_add_resource (GHidMainMenu *menu, GtkMenuShell *shell, const Resource *res) { int i, j; const Resource *tmp_res; gchar mnemonic = 0; for (i = 0; i < res->c; ++i) { const gchar *accel = NULL; char *menu_label; const char *res_val; const Resource *sub_res = res->v[i].subres; GtkAction *action = NULL; switch (resource_type (res->v[i])) { case 101: /* name, subres: passthrough */ ghid_main_menu_real_add_resource (menu, shell, sub_res); break; case 1: /* no name, subres */ tmp_res = resource_subres (sub_res, "a"); /* accelerator */ res_val = resource_value (sub_res, "m"); /* mnemonic */ if (res_val) mnemonic = res_val[0]; /* The accelerator resource will have two values, like * a={"Ctrl-Q" "Ctrl<Key>q"} * The first Gtk ignores. The second needs to be translated. */ if (tmp_res) accel = check_unique_accel (translate_accelerator (tmp_res->v[1].value)); /* Now look for the first unnamed value (not a subresource) to * figure out the name of the menu or the menuitem. */ res_val = "button"; for (j = 0; j < sub_res->c; ++j) if (resource_type (sub_res->v[j]) == 10) { res_val = _(sub_res->v[j].value); break; } /* Hack '_' in based on mnemonic value */ if (!mnemonic) menu_label = g_strdup (res_val); else { char *post_ = strchr (res_val, mnemonic); if (post_ == NULL) menu_label = g_strdup (res_val); else { GString *tmp = g_string_new (""); g_string_append_len (tmp, res_val, post_ - res_val); g_string_append_c (tmp, '_'); g_string_append (tmp, post_); menu_label = g_string_free (tmp, FALSE); } } /* If the subresource we're processing also has unnamed * subresources, it's a submenu, not a regular menuitem. */ if (sub_res->flags & FLAG_S) { /* SUBMENU */ GtkWidget *submenu = gtk_menu_new (); GtkWidget *item = gtk_menu_item_new_with_mnemonic (menu_label); GtkWidget *tearoff = gtk_tearoff_menu_item_new (); gtk_menu_shell_append (shell, item); gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), submenu); /* add tearoff to menu */ gtk_menu_shell_append (GTK_MENU_SHELL (submenu), tearoff); /* recurse on the newly-added submenu */ ghid_main_menu_real_add_resource (menu, GTK_MENU_SHELL (submenu), sub_res); } else { /* NON-SUBMENU: MENU ITEM */ const char *checked = resource_value (sub_res, "checked"); const char *label = resource_value (sub_res, "sensitive"); const char *tip = resource_value (sub_res, "tip"); if (checked) { /* TOGGLE ITEM */ gchar *name = g_strdup_printf ("MainMenuAction%d", action_counter++); action = GTK_ACTION (gtk_toggle_action_new (name, menu_label, tip, NULL)); /* checked=foo is a binary flag (checkbox) * checked=foo,bar is a flag compared to a value (radio) */ gtk_toggle_action_set_draw_as_radio (GTK_TOGGLE_ACTION (action), !!strchr (checked, ',')); } else if (label && strcmp (label, "false") == 0) { /* INSENSITIVE ITEM */ GtkWidget *item = gtk_menu_item_new_with_label (menu_label); gtk_widget_set_sensitive (item, FALSE); gtk_menu_shell_append (shell, item); } else { /* NORMAL ITEM */ gchar *name = g_strdup_printf ("MainMenuAction%d", action_counter++); action = gtk_action_new (name, menu_label, tip, NULL); } } /* Connect accelerator, if there is one */ if (action) { GtkWidget *item; gtk_action_set_accel_group (action, menu->accel_group); gtk_action_group_add_action_with_accel (menu->action_group, action, accel); gtk_action_connect_accelerator (action); g_signal_connect (G_OBJECT (action), "activate", menu->action_cb, (gpointer) sub_res); g_object_set_data (G_OBJECT (action), "resource", (gpointer) sub_res); item = gtk_action_create_menu_item (action); gtk_menu_shell_append (shell, item); menu->actions = g_list_append (menu->actions, action); menu->special_key_cb (accel, action, sub_res); } /* Scan rest of resource in case there is more work */ for (j = 0; j < sub_res->c; j++) { const char *res_name; /* named value = X resource */ if (resource_type (sub_res->v[j]) == 110) { res_name = sub_res->v[j].name; /* translate bg, fg to background, foreground */ if (strcmp (res_name, "fg") == 0) res_name = "foreground"; if (strcmp (res_name, "bg") == 0) res_name = "background"; /* ignore special named values (m, a, sensitive) */ if (strcmp (res_name, "m") == 0 || strcmp (res_name, "a") == 0 || strcmp (res_name, "sensitive") == 0 || strcmp (res_name, "tip") == 0) break; /* log checked and active special values */ if (action && strcmp (res_name, "checked") == 0) g_object_set_data (G_OBJECT (action), "checked-flag", sub_res->v[j].value); else if (action && strcmp (res_name, "active") == 0) g_object_set_data (G_OBJECT (action), "active-flag", sub_res->v[j].value); else /* if we got this far it is supposed to be an X * resource. For now ignore it and warn the user */ Message (_("The gtk gui currently ignores \"%s\"" "as part of a menuitem resource.\n" "Feel free to provide patches\n"), sub_res->v[j].value); } } break; case 10: /* no name, value */ /* If we get here, the resource is "-" or "@foo" for some foo */ if (res->v[i].value[0] == '@') { GList *children; int pos; children = gtk_container_get_children (GTK_CONTAINER (shell)); pos = g_list_length (children); g_list_free (children); if (strcmp (res->v[i].value, "@layerview") == 0) { menu->layer_view_shell = shell; menu->layer_view_pos = pos; } else if (strcmp (res->v[i].value, "@layerpick") == 0) { menu->layer_pick_shell = shell; menu->layer_pick_pos = pos; } else if (strcmp (res->v[i].value, "@routestyles") == 0) { menu->route_style_shell = shell; menu->route_style_pos = pos; } else Message (_("GTK GUI currently ignores \"%s\" in the menu\n" "resource file.\n"), res->v[i].value); } else if (strcmp (res->v[i].value, "-") == 0) { GtkWidget *item = gtk_separator_menu_item_new (); gtk_menu_shell_append (shell, item); } else if (i > 0) { /* This is an action-less menuitem. It is really only useful * when you're starting to build a new menu and you're looking * to get the layout right. */ GtkWidget *item = gtk_menu_item_new_with_label (_(res->v[i].value)); gtk_menu_shell_append (shell, item); } break; } } }
GtkWidget *menubar_new (GtkWidget *Window) { GtkWidget *Menu; GtkItemFactory *ItemFactory; GtkAccelGroup *AccelGroup; gchar *AccelRC; guint NbMenuEntries = sizeof (MenuEntries) / sizeof (MenuEntries[0]); MsgBarToggleDisplay = FALSE; ToolBarToggleDisplay = FALSE; ToggleWordwrap = FALSE; AccelGroup = gtk_accel_group_new(); ItemFactory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", AccelGroup); gtk_item_factory_create_items (ItemFactory, NbMenuEntries, MenuEntries, NULL); gtk_window_add_accel_group (GTK_WINDOW (Window), AccelGroup); Menu = gtk_tearoff_menu_item_new (); gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget (ItemFactory, "<main>/File")), Menu); Menu = gtk_tearoff_menu_item_new (); gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget (ItemFactory, "<main>/File/Recent Files")), Menu); Menu = gtk_tearoff_menu_item_new (); gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget (ItemFactory, "<main>/Edit")), Menu); Menu = gtk_tearoff_menu_item_new (); gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget (ItemFactory, "<main>/Tools")), Menu); Menu = gtk_tearoff_menu_item_new (); gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget (ItemFactory, "<main>/Tools/Conversions")), Menu); Menu = gtk_tearoff_menu_item_new (); gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget (ItemFactory, "<main>/Settings")), Menu); Menu = gtk_tearoff_menu_item_new (); gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget (ItemFactory, "<main>/Settings/Doc Tabs")), Menu); if (MSGBAR_DISPLAY) gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_item_factory_get_widget (ItemFactory, "<main>/Settings/Msg Bar")), TRUE); if (TOOLBAR_DISPLAY) gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_item_factory_get_widget (ItemFactory, "<main>/Settings/Tool Bar")), TRUE); if (TOGGLE_WORDWRAP) gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_item_factory_get_widget (ItemFactory, "<main>/Settings/Wordwrap")), TRUE); if (TAB_POSITION == 1) gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_item_factory_get_widget (ItemFactory, "<main>/Settings/Doc Tabs/Top")), TRUE); if (TAB_POSITION == 2) gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_item_factory_get_widget (ItemFactory, "<main>/Settings/Doc Tabs/Bottom")), TRUE); if (TAB_POSITION == 3) gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_item_factory_get_widget (ItemFactory, "<main>/Settings/Doc Tabs/Left")), TRUE); if (TAB_POSITION == 4) gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_item_factory_get_widget (ItemFactory, "<main>/Settings/Doc Tabs/Right")), TRUE); Menu = gtk_tearoff_menu_item_new (); gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget (ItemFactory, "<main>/Settings/Scroll Bar")), Menu); if (SCROLLBAR_POSITION == 1) gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_item_factory_get_widget (ItemFactory, "<main>/Settings/Scroll Bar/Left")), TRUE); if (SCROLLBAR_POSITION == 2) gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (gtk_item_factory_get_widget (ItemFactory, "<main>/Settings/Scroll Bar/Right")), TRUE); Menu = gtk_tearoff_menu_item_new (); gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget (ItemFactory, "<main>/Languages")), Menu); Menu = gtk_tearoff_menu_item_new (); gtk_menu_prepend (GTK_MENU(gtk_item_factory_get_widget (ItemFactory, "<main>/Help")), Menu); Menu = gtk_item_factory_get_widget (ItemFactory, "<main>"); AccelRC = g_strconcat (g_get_home_dir (), PATH_SEP_STRING, CONF_DIR, PATH_SEP_STRING, "AccelRC", NULL); gtk_item_factory_parse_rc (AccelRC); g_free (AccelRC); init_recent_files (); init_languages_menu (); gtk_menu_bar_set_shadow_type (GTK_MENU_BAR(Menu), GTK_SHADOW_NONE); return (Menu); }
void FillBSPMenu(){ GtkWidget *item, *menu; // menu points to a GtkMenu (not an item) epair_t *ep; GList *lst; int i; menu = GTK_WIDGET( g_object_get_data( G_OBJECT( g_qeglobals_gui.d_main_window ), "menu_bsp" ) ); while ( ( lst = gtk_container_children( GTK_CONTAINER( menu ) ) ) != NULL ) gtk_container_remove( GTK_CONTAINER( menu ), GTK_WIDGET( lst->data ) ); if ( g_PrefsDlg.m_bDetachableMenus ) { item = gtk_tearoff_menu_item_new(); gtk_menu_append( GTK_MENU( menu ), item ); gtk_widget_set_sensitive( item, TRUE ); gtk_widget_show( item ); } if ( g_qeglobals.bBSPFrontendPlugin ) { CString str = g_BSPFrontendTable.m_pfnGetBSPMenu(); char cTemp[1024]; strcpy( cTemp, str ); char* token = strtok( cTemp, ",;" ); if ( token && *token == ' ' ) { while ( *token == ' ' ) token++; } i = 0; // first token is menu name item = gtk_menu_get_attach_widget( GTK_MENU( menu ) ); gtk_label_set_text( GTK_LABEL( GTK_BIN( item )->child ), token ); token = strtok( NULL, ",;" ); while ( token != NULL ) { g_BSPFrontendCommands = g_slist_append( g_BSPFrontendCommands, g_strdup( token ) ); item = gtk_menu_item_new_with_label( token ); gtk_widget_show( item ); gtk_container_add( GTK_CONTAINER( menu ), item ); gtk_signal_connect( GTK_OBJECT( item ), "activate", GTK_SIGNAL_FUNC( HandleCommand ), GINT_TO_POINTER( CMD_BSPCOMMAND + i ) ); token = strtok( NULL, ",;" ); i++; } } else { i = 0; for ( ep = g_qeglobals.d_project_entity->epairs; ep; ep = ep->next ) { if ( strncmp( ep->key, "bsp_", 4 ) == 0 ) { bsp_commands[i] = ep->key; item = gtk_menu_item_new_with_label( ep->key + 4 ); gtk_widget_show( item ); gtk_container_add( GTK_CONTAINER( menu ), item ); gtk_signal_connect( GTK_OBJECT( item ), "activate", GTK_SIGNAL_FUNC( HandleCommand ), GINT_TO_POINTER( CMD_BSPCOMMAND + i ) ); i++; } } } }
static void start_element (GMarkupParseContext *context, const gchar *element_name, const gchar **attr_names, const gchar **attr_values, gpointer user_data, GError **error) { DeskmenuObject *dm_object = user_data; DeskmenuElementType element_type; const gchar **ncursor = attr_names, **vcursor = attr_values; GtkWidget *item, *menu; gint w, h; element_type = GPOINTER_TO_INT (g_hash_table_lookup (element_hash, element_name)); if ((dm_object->menu && !dm_object->current_menu) || (!dm_object->menu && element_type != DESKMENU_ELEMENT_MENU)) { gint line_num, char_num; g_markup_parse_context_get_position (context, &line_num, &char_num); g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE, "Error on line %d char %d: Element '%s' declared outside of " "toplevel menu element", line_num, char_num, element_name); return; } switch (element_type) { case DESKMENU_ELEMENT_MENU: if (dm_object->current_item != NULL) { gint line_num, char_num; g_markup_parse_context_get_position (context, &line_num, &char_num); g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE, "Error on line %d char %d: Element 'menu' cannot be nested " "inside of an item element", line_num, char_num); return; } if (!dm_object->menu) { /*if (strcmp (*ncursor, "size") == 0) { deskmenu->w = g_strdup (*vcursor); deskmenu->h = g_strdup (*vcursor); } else { gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, deskmenu->w, deskmenu->h); }*/ dm_object->menu = gtk_menu_new (); g_object_set_data (G_OBJECT (dm_object->menu), "parent menu", NULL); dm_object->current_menu = dm_object->menu; } else { gchar *name = NULL; gchar *icon = NULL; gboolean name_exec = FALSE; gboolean icon_file = FALSE; while (*ncursor) { if (strcmp (*ncursor, "name") == 0) name = g_strdup (*vcursor); else if (strcmp (*ncursor, "icon") == 0) icon = g_strdup (*vcursor); else if ((strcmp (*ncursor, "mode") == 0) && (strcmp (*vcursor, "exec") == 0)) name_exec = TRUE; else if ((strcmp (*ncursor, "mode1") == 0) && (strcmp (*vcursor, "file") == 0)) icon_file = TRUE; else g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE, "Unknown attribute: %s", *ncursor); ncursor++; vcursor++; } if (name_exec) { GtkWidget *label; GHook *hook; item = gtk_image_menu_item_new (); label = gtk_label_new_with_mnemonic (NULL); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); g_object_set_data (G_OBJECT (label), "exec", g_strdup (name)); gtk_container_add (GTK_CONTAINER (item), label); hook = g_hook_alloc (dm_object->show_hooks); hook->data = (gpointer) label; hook->func = (GHookFunc *) launcher_name_exec_update; g_hook_append (dm_object->show_hooks, hook); } else { if (name) item = gtk_image_menu_item_new_with_mnemonic (name); else item = gtk_image_menu_item_new_with_mnemonic (""); } if (icon) { if (icon_file) { gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM(item), gtk_image_new_from_pixbuf (gdk_pixbuf_new_from_file_at_size (parse_expand_tilde(icon), w, h, NULL))); } else { gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), gtk_image_new_from_icon_name (icon, GTK_ICON_SIZE_MENU)); } } gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu), item); menu = gtk_menu_new (); g_object_set_data (G_OBJECT (menu), "parent menu", dm_object->current_menu); dm_object->current_menu = menu; gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), dm_object->current_menu); if (!dm_object->make_from_pipe) { GtkWidget *pin = gtk_tearoff_menu_item_new(); gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu), pin); //add a pin menu item dm_object->pin_items = g_slist_prepend (dm_object->pin_items, pin); } else { if (gtk_menu_get_tearoff_state (GTK_MENU(dm_object->menu))) { GtkWidget *pin = gtk_tearoff_menu_item_new(); gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu), pin); //add a pin menu item } } g_free (name); g_free (icon); } break; case DESKMENU_ELEMENT_SEPARATOR: if (dm_object->current_item != NULL) { gint line_num, char_num; g_markup_parse_context_get_position (context, &line_num, &char_num); g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE, "Error on line %d char %d: Element 'menu' cannot be nested " "inside of an item element", line_num, char_num); return; } else { gchar *name = NULL; gchar *icon = NULL; gboolean name_exec = FALSE; gboolean icon_file = FALSE; gboolean decorate = FALSE; gint w, h; item = gtk_separator_menu_item_new(); while (*ncursor) { if (strcmp (*ncursor, "name") == 0) { name = g_strdup (*vcursor); if (!decorate) { decorate = TRUE; } } else if (strcmp (*ncursor, "icon") == 0) { icon = g_strdup (*vcursor); if (!decorate) { decorate = TRUE; } } else if ((strcmp (*ncursor, "mode") == 0) && (strcmp (*vcursor, "exec") == 0)) name_exec = TRUE; else if ((strcmp (*ncursor, "mode1") == 0) && (strcmp (*vcursor, "file") == 0)) icon_file = TRUE; else g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE, "Unknown attribute: %s", *ncursor); ncursor++; vcursor++; } if (decorate) { GtkWidget *box = gtk_hbox_new (FALSE, 3); gtk_container_add (GTK_CONTAINER(item), GTK_WIDGET(box)); if (name_exec) { GtkWidget *label; GHook *hook; label = gtk_label_new_with_mnemonic (NULL); g_object_set_data (G_OBJECT (label), "exec", g_strdup (name)); gtk_box_pack_end (GTK_BOX(box), label, TRUE, FALSE, 0); hook = g_hook_alloc (dm_object->show_hooks); hook->data = (gpointer) label; hook->func = (GHookFunc *) launcher_name_exec_update; g_hook_append (dm_object->show_hooks, hook); } else { gtk_box_pack_end (GTK_BOX(box), gtk_label_new_with_mnemonic (name), TRUE, FALSE, 0); } if (icon) { GtkWidget *image; if (icon_file) { gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h); image = gtk_image_new_from_pixbuf (gdk_pixbuf_new_from_file_at_size (parse_expand_tilde(icon), w, h, NULL)); } else { image = gtk_image_new_from_icon_name (icon, GTK_ICON_SIZE_MENU); } gtk_box_pack_start (GTK_BOX(box), image, FALSE, FALSE, 0); } gtk_widget_set_state (item, GTK_STATE_PRELIGHT); /*derive colors from menu hover*/ g_free (name); g_free (icon); } gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu), item); } break; case DESKMENU_ELEMENT_ITEM: if (dm_object->current_item != NULL) { gint line_num, char_num; g_markup_parse_context_get_position (context, &line_num, &char_num); g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE, "Error on line %d char %d: Element 'item' cannot be nested " "inside of another item element", line_num, char_num); return; } dm_object->current_item = g_slice_new0 (DeskmenuItem); while (*ncursor) { if (strcmp (*ncursor, "type") == 0) dm_object->current_item->type = GPOINTER_TO_INT (g_hash_table_lookup (item_hash, *vcursor)); else g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE, "Unknown attribute: %s", *ncursor); ncursor++; vcursor++; } break; case DESKMENU_ELEMENT_NAME: while (*ncursor) { if ((strcmp (*ncursor, "mode") == 0) && (strcmp (*vcursor, "exec") == 0)) dm_object->current_item->name_exec = TRUE; ncursor++; vcursor++; } /* no break here to let it fall through */ case DESKMENU_ELEMENT_ICON: while (*ncursor) { if ((strcmp (*ncursor, "mode1") == 0) && (strcmp (*vcursor, "file") == 0)) dm_object->current_item->icon_file = TRUE; ncursor++; vcursor++; } /* no break here to let it fall through */ case DESKMENU_ELEMENT_VPICON: while (*ncursor) { if ((strcmp (*ncursor, "mode1") == 0) && (strcmp (*vcursor, "file") == 0)) dm_object->current_item->vpicon_file = TRUE; ncursor++; vcursor++; } /* no break here to let it fall through */ case DESKMENU_ELEMENT_COMMAND: while (*ncursor) { if ((strcmp (*ncursor, "mode2") == 0) && (strcmp (*vcursor, "pipe") == 0)) dm_object->current_item->command_pipe = TRUE; if (dm_object->current_item->command_pipe == TRUE && (strcmp (*ncursor, "cache") == 0) && (strcmp (*vcursor, "true") == 0)) dm_object->current_item->cache_output = TRUE; ncursor++; vcursor++; } /* no break here to let it fall through */ case DESKMENU_ELEMENT_WRAP: if (dm_object->current_item) dm_object->current_item->current_element = element_type; break; case DESKMENU_ELEMENT_THISVP: if (dm_object->current_item) dm_object->current_item->current_element = element_type; break; case DESKMENU_ELEMENT_MINIONLY: if (dm_object->current_item) dm_object->current_item->current_element = element_type; break; case DESKMENU_ELEMENT_QUANTITY: if (dm_object->current_item) dm_object->current_item->current_element = element_type; break; case DESKMENU_ELEMENT_SORT: if (dm_object->current_item) dm_object->current_item->current_element = element_type; break; case DESKMENU_ELEMENT_AGE: if (dm_object->current_item) dm_object->current_item->current_element = element_type; break; default: g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_UNKNOWN_ELEMENT, "Unknown element: %s", element_name); break; } }
void make_menus(Viewer *viewer, GtkWidget *parent) { GtkWidget *menubar = gtk_menu_bar_new(); viewer->menu_bar = menubar; gtk_box_pack_start(GTK_BOX(parent), menubar, FALSE, FALSE, 0); GtkWidget *file_menuitem = gtk_menu_item_new_with_mnemonic("_File"); gtk_menu_bar_append(GTK_MENU_BAR(menubar), file_menuitem); viewer->file_menu = gtk_menu_new(); gtk_menu_item_set_submenu(GTK_MENU_ITEM(file_menuitem), viewer->file_menu); ///////////////////// GtkWidget *renderers_menuitem = gtk_menu_item_new_with_mnemonic("_Renderers"); gtk_menu_bar_append(GTK_MENU_BAR(menubar), renderers_menuitem); viewer->renderers_menu = gtk_menu_new(); gtk_menu_item_set_submenu(GTK_MENU_ITEM(renderers_menuitem), viewer->renderers_menu); if (1) { // tearoff GtkWidget *tearoff = gtk_tearoff_menu_item_new(); gtk_menu_append (GTK_MENU(viewer->renderers_menu), tearoff); gtk_widget_show (tearoff); // separator GtkWidget *sep = gtk_separator_menu_item_new (); gtk_menu_append (GTK_MENU(viewer->renderers_menu), sep); gtk_widget_show (sep); // select all item GtkWidget *select_all_mi = gtk_menu_item_new_with_mnemonic ("Select _All"); gtk_menu_append (GTK_MENU(viewer->renderers_menu), select_all_mi); gtk_widget_show (select_all_mi); // remove all item GtkWidget *select_none_mi = gtk_menu_item_new_with_mnemonic ("Select _None"); gtk_menu_append (GTK_MENU(viewer->renderers_menu), select_none_mi); gtk_widget_show (select_none_mi); g_signal_connect (G_OBJECT (select_all_mi), "activate", G_CALLBACK (on_select_all_renderers_activate), viewer); g_signal_connect (G_OBJECT (select_none_mi), "activate", G_CALLBACK (on_select_no_renderers_activate), viewer); } ///////////////////// GtkWidget *event_handlers_menuitem = gtk_menu_item_new_with_mnemonic("_Input"); gtk_menu_bar_append(GTK_MENU_BAR(menubar), event_handlers_menuitem); viewer->event_handlers_menu = gtk_menu_new(); gtk_menu_item_set_submenu(GTK_MENU_ITEM(event_handlers_menuitem), viewer->event_handlers_menu); if (1) { // tearoff GtkWidget *tearoff = gtk_tearoff_menu_item_new(); gtk_menu_append (GTK_MENU(viewer->event_handlers_menu), tearoff); gtk_widget_show (tearoff); // separator GtkWidget *sep = gtk_separator_menu_item_new (); gtk_menu_append (GTK_MENU(viewer->event_handlers_menu), sep); gtk_widget_show (sep); // select all item GtkWidget *select_all_mi = gtk_menu_item_new_with_mnemonic ("Select _All"); gtk_menu_append (GTK_MENU(viewer->event_handlers_menu), select_all_mi); gtk_widget_show (select_all_mi); // remove all item GtkWidget *select_none_mi = gtk_menu_item_new_with_mnemonic ("Select _None"); gtk_menu_append (GTK_MENU(viewer->event_handlers_menu), select_none_mi); gtk_widget_show (select_none_mi); g_signal_connect (G_OBJECT (select_all_mi), "activate", G_CALLBACK (on_select_all_event_handlers_activate), viewer); g_signal_connect (G_OBJECT (select_none_mi), "activate", G_CALLBACK (on_select_no_event_handlers_activate), viewer); } ///////////////////// GtkWidget *mode_menuitem = gtk_menu_item_new_with_mnemonic("_Mode"); gtk_menu_bar_append(GTK_MENU_BAR(menubar), mode_menuitem); viewer->mode_menu = gtk_menu_new(); gtk_menu_item_set_submenu(GTK_MENU_ITEM(mode_menuitem), viewer->mode_menu); }
static VALUE rg_initialize(VALUE self) { RBGTK_INITIALIZE(self, gtk_tearoff_menu_item_new()); return Qnil; }