/** * thunar_history_set_action_group: * @history : a #ThunarHistory. * @action_group : a #GtkActionGroup or %NULL. * * Attaches @history to the specified @action_group, * and thereby registers the actions "back" and * "forward" provided by @history on the given * @action_group. **/ void thunar_history_set_action_group (ThunarHistory *history, GtkActionGroup *action_group) { _thunar_return_if_fail (THUNAR_IS_HISTORY (history)); _thunar_return_if_fail (action_group == NULL || GTK_IS_ACTION_GROUP (action_group)); /* verify that we don't already use that action group */ if (G_UNLIKELY (history->action_group == action_group)) return; /* disconnect from the previous action group */ if (G_UNLIKELY (history->action_group != NULL)) { gtk_action_group_remove_action (history->action_group, history->action_back); gtk_action_group_remove_action (history->action_group, history->action_forward); g_object_unref (G_OBJECT (history->action_group)); } /* activate the new action group */ history->action_group = action_group; /* connect to the new action group */ if (G_LIKELY (action_group != NULL)) { g_object_ref (G_OBJECT (action_group)); gtk_action_group_add_action_with_accel (action_group, history->action_back, "<alt>Left"); gtk_action_group_add_action_with_accel (action_group, history->action_forward, "<alt>Right"); } /* notify listeners */ g_object_notify (G_OBJECT (history), "action-group"); }
void nautilus_navigation_window_initialize_actions (NautilusNavigationWindow *window) { GtkActionGroup *action_group; GtkUIManager *ui_manager; GtkAction *action; action_group = gtk_action_group_new ("NavigationActions"); gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE); window->details->navigation_action_group = action_group; gtk_action_group_add_actions (action_group, navigation_entries, G_N_ELEMENTS (navigation_entries), window); gtk_action_group_add_toggle_actions (action_group, navigation_toggle_entries, G_N_ELEMENTS (navigation_toggle_entries), window); action = g_object_new (NAUTILUS_TYPE_NAVIGATION_ACTION, "name", "Back", "label", _("_Back"), "stock_id", GTK_STOCK_GO_BACK, "tooltip", _("Go to the previous visited location"), "arrow-tooltip", _("Back history"), "window", window, "direction", NAUTILUS_NAVIGATION_DIRECTION_BACK, "is_important", TRUE, NULL); g_signal_connect (action, "activate", G_CALLBACK (action_back_callback), window); gtk_action_group_add_action_with_accel (action_group, action, "<alt>Left"); g_object_unref (action); action = g_object_new (NAUTILUS_TYPE_NAVIGATION_ACTION, "name", "Forward", "label", _("_Forward"), "stock_id", GTK_STOCK_GO_FORWARD, "tooltip", _("Go to the next visited location"), "arrow-tooltip", _("Forward history"), "window", window, "direction", NAUTILUS_NAVIGATION_DIRECTION_FORWARD, "is_important", TRUE, NULL); g_signal_connect (action, "activate", G_CALLBACK (action_forward_callback), window); gtk_action_group_add_action_with_accel (action_group, action, "<alt>Right"); g_object_unref (action); action = gtk_action_group_get_action (action_group, NAUTILUS_ACTION_SEARCH); g_object_set (action, "short_label", _("_Search"), NULL); ui_manager = nautilus_window_get_ui_manager (NAUTILUS_WINDOW (window)); gtk_ui_manager_insert_action_group (ui_manager, action_group, 0); g_object_unref (action_group); /* owned by ui_manager */ }
static void create_game_menus (GtkUIManager * ui_manager) { GtkActionGroup *action_group; games_stock_init (); action_group = gtk_action_group_new ("actions"); gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE); gtk_action_group_add_actions (action_group, action_entry, G_N_ELEMENTS (action_entry), app); gtk_ui_manager_insert_action_group (ui_manager, action_group, 0); gtk_ui_manager_add_ui_from_string (ui_manager, ui_description, -1, NULL); gtk_window_add_accel_group (GTK_WINDOW (app), gtk_ui_manager_get_accel_group (ui_manager)); new_game_action = gtk_action_group_get_action (action_group, "NewGame"); hint_action = gtk_action_group_get_action (action_group, "Hint"); undo_action = gtk_action_group_get_action (action_group, "UndoMove"); fullscreen_action = GTK_ACTION (games_fullscreen_action_new ("Fullscreen", GTK_WINDOW (app))); gtk_action_group_add_action_with_accel (action_group, fullscreen_action, NULL); }
/** * create_game_menus * @ap: application pointer * * Description: * Creates the menus for application @ap * **/ void create_game_menus (GtkUIManager * ui_manager) { GtkActionGroup *action_group; games_stock_init (); action_group = gtk_action_group_new ("actions"); gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE); gtk_action_group_add_actions (action_group, action_entry, G_N_ELEMENTS (action_entry), app); gtk_action_group_add_toggle_actions (action_group, toggle_action_entry, G_N_ELEMENTS (toggle_action_entry), app); gtk_ui_manager_insert_action_group (ui_manager, action_group, 0); gtk_ui_manager_add_ui_from_string (ui_manager, ui_description, -1, NULL); scores_action = gtk_action_group_get_action (action_group, "Scores"); teleport_action = gtk_action_group_get_action (action_group, "Teleport"); random_action = gtk_action_group_get_action (action_group, "Random"); wait_action = gtk_action_group_get_action (action_group, "Wait"); toolbar_toggle_action = gtk_action_group_get_action (action_group, "ShowToolbar"); fullscreen_action = GTK_ACTION (games_fullscreen_action_new ("Fullscreen", GTK_WINDOW (app))); gtk_action_group_add_action_with_accel (action_group, fullscreen_action, NULL); return; }
void actions_toggle_add(GtkActionGroup *act_group, const struct _actionhooks *ahs, int count) { int i; GtkToggleAction *action; char *nel = malloc(max_path); for (i = 0; i < count; i++) { char *label = gettext(ahs[i].label); action = gtk_toggle_action_new(ahs[i].name, label, ahs[i].tooltip == NULL ? label : gettext(ahs[i].tooltip), ahs[i].icon == NULL ? ahs[i].name : ahs[i].icon); sprintf(nel, "<Actions>/actions/%s", ahs[i].name); gtk_action_set_accel_path(GTK_ACTION(action), nel); //gtk_action_connect_accelerator(action); g_signal_connect(G_OBJECT(action), "activate", ahs[i].handler, GINT_TO_POINTER(ahs[i].parameter)); gtk_action_group_add_action_with_accel(act_group, GTK_ACTION(action), NULL); } free(nel); }
static void formhistory_app_add_browser_cb (MidoriApp* app, MidoriBrowser* browser, MidoriExtension* extension) { GtkAccelGroup* acg = gtk_accel_group_new (); GtkActionGroup* action_group = midori_browser_get_action_group (browser); GtkAction* action = gtk_action_new ("FormHistoryToggleState", _("Toggle form history state"), _("Activate or deactivate form history for the current tab."), NULL); gtk_window_add_accel_group (GTK_WINDOW (browser), acg); g_object_set_data (G_OBJECT (browser), "FormHistoryExtension", extension); g_signal_connect (action, "activate", G_CALLBACK (formhistory_toggle_state_cb), browser); gtk_action_group_add_action_with_accel (action_group, action, "<Ctrl><Shift>F"); gtk_action_set_accel_group (action, acg); gtk_action_connect_accelerator (action); if (midori_extension_get_boolean (extension, "always-load")) { GList* tabs = midori_browser_get_tabs (browser); for (; tabs; tabs = g_list_next (tabs)) formhistory_add_tab_cb (browser, tabs->data, extension); g_list_free (tabs); g_signal_connect (browser, "add-tab", G_CALLBACK (formhistory_add_tab_cb), extension); } g_signal_connect (extension, "deactivate", G_CALLBACK (formhistory_deactivate_cb), browser); }
static void empathy_mic_menu_add_microphone (EmpathyMicMenu *self, const gchar *name, const gchar *description, guint source_idx, gboolean is_monitor) { EmpathyMicMenuPrivate *priv = self->priv; GtkRadioAction *action; GSList *group; action = gtk_radio_action_new (name, description, NULL, NULL, source_idx); gtk_action_group_add_action_with_accel (priv->action_group, GTK_ACTION (action), NULL); /* Set MONITOR_KEY on the action to non-NULL if it's a monitor * because we don't want to show monitors if we can help it. */ if (is_monitor) { g_object_set_data (G_OBJECT (action), MONITOR_KEY, GUINT_TO_POINTER (TRUE)); } group = gtk_radio_action_get_group (GTK_RADIO_ACTION (priv->anchor_action)); gtk_radio_action_set_group (GTK_RADIO_ACTION (action), group); g_queue_push_tail (priv->microphones, action); g_signal_connect (action, "activate", G_CALLBACK (empathy_mic_menu_activate_cb), self); }
void gimp_action_group_add_enum_actions (GimpActionGroup *group, const gchar *msg_context, const GimpEnumActionEntry *entries, guint n_entries, GCallback callback) { gint i; g_return_if_fail (GIMP_IS_ACTION_GROUP (group)); for (i = 0; i < n_entries; i++) { GimpEnumAction *action; const gchar *label; const gchar *tooltip = NULL; if (! gimp_action_group_check_unique_action (group, entries[i].name)) continue; if (msg_context) { label = g_dpgettext2 (NULL, msg_context, entries[i].label); if (entries[i].tooltip) tooltip = g_dpgettext2 (NULL, msg_context, entries[i].tooltip); } else { label = gettext (entries[i].label); tooltip = gettext (entries[i].tooltip); } action = gimp_enum_action_new (entries[i].name, label, tooltip, entries[i].icon_name, entries[i].value, entries[i].value_variable); if (callback) g_signal_connect (action, "selected", callback, group->user_data); gtk_action_group_add_action_with_accel (GTK_ACTION_GROUP (group), GTK_ACTION (action), entries[i].accelerator); g_signal_emit (group, signals[ACTION_ADDED], 0, action); if (entries[i].help_id) g_object_set_qdata_full (G_OBJECT (action), GIMP_HELP_ID, g_strdup (entries[i].help_id), (GDestroyNotify) g_free); g_object_unref (action); } }
static void glide_window_add_accelerator (GlideWindow *w, GtkActionGroup *group, GtkAccelGroup *accels, const gchar *action, const gchar *accel) { GtkAction *a = GTK_ACTION (GLIDE_WINDOW_UI_OBJECT (w, action)); gtk_action_set_accel_group (a, accels); gtk_action_group_add_action_with_accel (group, a, accel); gtk_action_connect_accelerator (a); }
static VALUE rg_add_action(int argc, VALUE *argv, VALUE self) { VALUE action, accelerator; rb_scan_args(argc, argv, "11", &action, &accelerator); gtk_action_group_add_action_with_accel(_SELF(self), RVAL2GTKACTION(action), RVAL2CSTR_ACCEPT_NIL(accelerator)); G_CHILD_ADD(self, action); return self; }
static VALUE rg_add_action(int argc, VALUE *argv, VALUE self) { VALUE action, accelerator; rb_scan_args(argc, argv, "11", &action, &accelerator); gtk_action_group_add_action_with_accel(_SELF(self), GTK_ACTION(RVAL2GOBJ(action)), NIL_P(accelerator) ? NULL : RVAL2CSTR(accelerator)); G_CHILD_ADD(self, action); return self; }
/** * _rb_action_group_add_source_actions: * @group: a #GtkActionGroup * @shell: the #RBShell * @actions: array of GtkActionEntry structures for the action group * @num_actions: number of actions in the @actions array * * Adds actions to an action group where the action callback is * called with the current selected source. This can safely be called * multiple times on the same action group. */ void _rb_action_group_add_source_actions (GtkActionGroup *group, GObject *shell, GtkActionEntry *actions, int num_actions) { int i; for (i = 0; i < num_actions; i++) { GtkAction *action; const char *label; const char *tooltip; SourceActionData *source_action_data; if (gtk_action_group_get_action (group, actions[i].name) != NULL) { /* action was already added */ continue; } label = gtk_action_group_translate_string (group, actions[i].label); tooltip = gtk_action_group_translate_string (group, actions[i].tooltip); action = gtk_action_new (actions[i].name, label, tooltip, NULL); if (actions[i].stock_id != NULL) { g_object_set (action, "stock-id", actions[i].stock_id, NULL); if (gtk_icon_theme_has_icon (gtk_icon_theme_get_default (), actions[i].stock_id)) { g_object_set (action, "icon-name", actions[i].stock_id, NULL); } } if (actions[i].callback) { GClosure *closure; source_action_data = g_slice_new0 (SourceActionData); source_action_data->callback = (SourceActionCallback) actions[i].callback; source_action_data->shell = shell; g_object_add_weak_pointer (shell, &source_action_data->shell); closure = g_cclosure_new (G_CALLBACK (source_action_cb), source_action_data, (GClosureNotify) source_action_data_destroy); g_signal_connect_closure (action, "activate", closure, FALSE); } gtk_action_group_add_action_with_accel (group, action, actions[i].accelerator); g_object_unref (action); } }
void gimp_action_group_add_procedure_actions (GimpActionGroup *group, const GimpProcedureActionEntry *entries, guint n_entries, GCallback callback) { gint i; g_return_if_fail (GIMP_IS_ACTION_GROUP (group)); for (i = 0; i < n_entries; i++) { GimpProcedureAction *action; if (! gimp_action_group_check_unique_action (group, entries[i].name)) continue; action = gimp_procedure_action_new (entries[i].name, entries[i].label, entries[i].tooltip, entries[i].icon_name, entries[i].procedure); if (callback) g_signal_connect (action, "selected", callback, group->user_data); gtk_action_group_add_action_with_accel (GTK_ACTION_GROUP (group), GTK_ACTION (action), entries[i].accelerator); g_signal_emit (group, signals[ACTION_ADDED], 0, action); if (entries[i].help_id) g_object_set_qdata_full (G_OBJECT (action), GIMP_HELP_ID, g_strdup (entries[i].help_id), (GDestroyNotify) g_free); g_object_unref (action); } }
int clip_GTK_ACTIONGROUPADDACTIONWITHACCEL(ClipMachine * ClipMachineMemory) { C_object *cagroup = _fetch_co_arg(ClipMachineMemory); C_object *caction = _fetch_cobject(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2)); gchar *accel = _clip_parc(ClipMachineMemory, 3); CHECKARG2(1, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType); CHECKCOBJ(cagroup, GTK_IS_ACTION_GROUP(cagroup->object)); CHECKARG2(2, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType); CHECKCOBJ(caction, GTK_IS_ACTION(caction->object)); CHECKARG(3, CHARACTER_type_of_ClipVarType); LOCALE_TO_UTF(accel); gtk_action_group_add_action_with_accel(GTK_ACTION_GROUP(cagroup->object), GTK_ACTION(caction->object), accel); FREE_TEXT(accel); return 0; err: return 1; }
static void gimp_color_button_init (GimpColorButton *button, GimpColorButtonClass *klass) { GtkActionGroup *group; GtkUIManager *ui_manager; gint i; button->title = NULL; button->dialog = NULL; button->color_area = g_object_new (GIMP_TYPE_COLOR_AREA, "drag-mask", GDK_BUTTON1_MASK, NULL); g_signal_connect (button->color_area, "color-changed", G_CALLBACK (gimp_color_button_area_changed), button); gtk_container_add (GTK_CONTAINER (button), button->color_area); gtk_widget_show (button->color_area); /* right-click opens a popup */ button->popup_menu = ui_manager = gtk_ui_manager_new (); group = gtk_action_group_new ("color-button"); for (i = 0; i < G_N_ELEMENTS (actions); i++) { const gchar *label = gettext (actions[i].label); const gchar *tooltip = gettext (actions[i].tooltip); GtkAction *action; action = g_object_new (klass->get_action_type (button), "name", actions[i].name, "label", label, "tooltip", tooltip, "stock-id", actions[i].stock_id, NULL); if (actions[i].callback) g_signal_connect (action, "activate", actions[i].callback, button); gtk_action_group_add_action_with_accel (group, action, actions[i].accelerator); g_object_unref (action); } gtk_ui_manager_insert_action_group (ui_manager, group, -1); g_object_unref (group); gtk_ui_manager_add_ui_from_string (ui_manager, "<ui>\n" " <popup action=\"color-button-popup\">\n" " <menuitem action=\"" GIMP_COLOR_BUTTON_COLOR_FG "\" />\n" " <menuitem action=\"" GIMP_COLOR_BUTTON_COLOR_BG "\" />\n" " <separator />\n" " <menuitem action=\"" GIMP_COLOR_BUTTON_COLOR_BLACK "\" />\n" " <menuitem action=\"" GIMP_COLOR_BUTTON_COLOR_WHITE "\" />\n" " </popup>\n" "</ui>\n", -1, NULL); }
static void popup_menu (tilda_window *tw, tilda_term *tt) { DEBUG_FUNCTION ("popup_menu"); DEBUG_ASSERT (tw != NULL); DEBUG_ASSERT (tt != NULL); GtkAction *action; GtkActionGroup *action_group; GtkUIManager *ui_manager; GError *error = NULL; GtkWidget *menu; /* Just use a static string here to initialize the GtkUIManager, * rather than installing and reading from a file all the time. */ static const gchar menu_str[] = "<ui>" "<popup name=\"popup-menu\">" "<menuitem action=\"new-tab\" />" "<menuitem action=\"close-tab\" />" "<separator />" "<menuitem action=\"copy\" />" "<menuitem action=\"paste\" />" "<separator />" "<menuitem action=\"fullscreen\" />" "<separator />" "<menuitem action=\"preferences\" />" "<separator />" "<menuitem action=\"quit\" />" "</popup>" "</ui>"; /* Create the action group */ action_group = gtk_action_group_new ("popup-menu-action-group"); /* Add Actions and connect callbacks */ action = gtk_action_new ("new-tab", _("_New Tab"), NULL, GTK_STOCK_ADD); gtk_action_group_add_action_with_accel (action_group, action, config_getstr("addtab_key")); g_signal_connect (G_OBJECT(action), "activate", G_CALLBACK(menu_add_tab_cb), tw); action = gtk_action_new ("close-tab", _("_Close Tab"), NULL, GTK_STOCK_CLOSE); gtk_action_group_add_action_with_accel (action_group, action, config_getstr("closetab_key")); g_signal_connect (G_OBJECT(action), "activate", G_CALLBACK(menu_close_tab_cb), tw); action = gtk_action_new ("copy", NULL, NULL, GTK_STOCK_COPY); gtk_action_group_add_action_with_accel (action_group, action, config_getstr("copy_key")); g_signal_connect (G_OBJECT(action), "activate", G_CALLBACK(menu_copy_cb), tt); action = gtk_action_new ("paste", NULL, NULL, GTK_STOCK_PASTE); gtk_action_group_add_action_with_accel (action_group, action, config_getstr("paste_key")); g_signal_connect (G_OBJECT(action), "activate", G_CALLBACK(menu_paste_cb), tt); action = gtk_action_new ("fullscreen", _("Toggle fullscreen"), NULL, NULL); gtk_action_group_add_action (action_group, action); g_signal_connect (G_OBJECT(action), "activate", G_CALLBACK(menu_fullscreen_cb), tw); action = gtk_action_new ("preferences", NULL, NULL, GTK_STOCK_PREFERENCES); gtk_action_group_add_action (action_group, action); g_signal_connect (G_OBJECT(action), "activate", G_CALLBACK(menu_preferences_cb), tw); action = gtk_action_new ("quit", NULL, NULL, GTK_STOCK_QUIT); gtk_action_group_add_action_with_accel (action_group, action, config_getstr("quit_key")); g_signal_connect (G_OBJECT(action), "activate", G_CALLBACK(menu_quit_cb), tw); /* Create and add actions to the GtkUIManager */ ui_manager = gtk_ui_manager_new (); gtk_ui_manager_insert_action_group (ui_manager, action_group, 0); gtk_ui_manager_add_ui_from_string (ui_manager, menu_str, -1, &error); /* Check for an error (REALLY REALLY unlikely, unless the developers screwed up */ if (error) { DEBUG_ERROR ("GtkUIManager problem\n"); g_printerr ("Error message: %s\n", error->message); g_error_free (error); } /* Get the popup menu out of the GtkUIManager */ menu = gtk_ui_manager_get_widget (ui_manager, "/ui/popup-menu"); /* Disable auto hide */ tw->disable_auto_hide = TRUE; g_signal_connect (G_OBJECT(menu), "unmap", G_CALLBACK(on_popup_hide), tw); /* Display the menu */ gtk_menu_popup (GTK_MENU(menu), NULL, NULL, NULL, NULL, 3, gtk_get_current_event_time()); gtk_widget_show_all(menu); }
GtkAction * create_action_by_descriptor(const gchar *name, struct action_descriptor *data) { int state = data->attr.key_state & (GDK_SHIFT_MASK|GDK_CONTROL_MASK|GDK_ALT_MASK); int f; // Trace("%s: %d",name,data->ui_type); switch(data->ui_type) { case UI_CALLBACK_TYPE_TOGGLE: data->action = GTK_ACTION(gtk_toggle_action_new(name, gettext(data->attr.label ? data->attr.label : data->name), gettext(data->attr.tooltip), data->attr.stock_id)); break; case UI_CALLBACK_TYPE_DEFAULT: data->action = gtk_action_new(name, gettext(data->attr.label ? data->attr.label : data->name), gettext(data->attr.tooltip),data->attr.stock_id); break; case UI_CALLBACK_TYPE_SCROLL: if(data->sub >= 0 && data->sub <= G_N_ELEMENTS(action_scroll)) action_scroll[data->sub] = data->action = gtk_action_new(name, gettext(data->attr.label ? data->attr.label : data->name), gettext(data->attr.tooltip),data->attr.stock_id); break; case UI_CALLBACK_TYPE_SCRIPT: if(data->script.text) g_object_set_data_full(G_OBJECT(data->action),"script_text",g_strdup(data->script.text),g_free); if(data->callback) g_signal_connect(G_OBJECT(data->action),"activate",G_CALLBACK(data->callback),topwindow); else g_signal_connect(G_OBJECT(data->action),"activate",G_CALLBACK(action_script_activated),topwindow); data->callback = 0; break; default: Trace("Invalid action type %d in %s",data->ui_type,data->name); return NULL; } // Trace("%s(%s), callback: %p action: %p",__FUNCTION__,name,data->callback,data->action); if(data->callback) g_signal_connect(G_OBJECT(data->action),data->ui_type == UI_CALLBACK_TYPE_TOGGLE ? "toggled" : "activate",G_CALLBACK(data->callback),data->user_data); // Check for special keyboard action for(f=0;f<G_N_ELEMENTS(keyboard_action);f++) { if(data->attr.key_value == keyboard_action[f].keyval && (state == keyboard_action[f].state)) { keyboard_action[f].action = data->action; gtk_action_group_add_action(action_group[data->group],data->action); return data->action; } } // Check for PF actions if(data->attr.key_value >= GDK_F1 && data->attr.key_value <= GDK_F12 && !(state & (GDK_CONTROL_MASK|GDK_ALT_MASK))) { f = data->attr.key_value - GDK_F1; if(state&GDK_SHIFT_MASK) pf_action[f].shift = data->action; else pf_action[f].normal = data->action; gtk_action_group_add_action(action_group[data->group],data->action); return data->action; } // Register action if(data->attr.accel) gtk_action_group_add_action_with_accel(action_group[data->group],data->action,data->attr.accel); else gtk_action_group_add_action(action_group[data->group],data->action); return data->action; }
int main(int argc, char **argv) { GtkWidget *menubar, *pri_vbox, *tabla, *scroll; GtkAccelGroup *accel_group; GtkUIManager *ui_manager; GtkAction *action; LIBXML_TEST_VERSION karakter_betoltes("ruin.xml"); //return 0; gtk_init(&argc, &argv); action_group = gtk_action_group_new("main_menu"); action = gtk_action_new("uj-karakter", "Új karakter", "Új karakter létrehozása", GTK_STOCK_NEW); gtk_action_group_add_action_with_accel(action_group, action, "<Control>N"); action = gtk_action_new("karakter-megnyitas", "Karakter megnyitása", "Elmentett karakter megnyitása", GTK_STOCK_OPEN); gtk_action_group_add_action_with_accel(action_group, action, "<Control>O"); action = gtk_action_new("karakter-mentes", "Karakter mentése", "Karakter adatainak mentése", GTK_STOCK_SAVE); gtk_action_group_add_action_with_accel(action_group, action, "<Control>S"); action = gtk_action_new("kilepes", "Kilépés", "Kilépés a programból", GTK_STOCK_QUIT); gtk_action_group_add_action_with_accel(action_group, action, "<Control>Q"); g_signal_connect(G_OBJECT(action), "activate", G_CALLBACK(kilepes_func), NULL); action = gtk_action_new("karakter-menu", "Karakter", "Karakter", NULL); gtk_action_group_add_action(action_group, action); gtk_action_group_add_radio_actions(action_group, menu_items, nezet_menu_szama, 0, G_CALLBACK(nezet_menu), NULL); action = gtk_action_new("nezet-menu", "Nézet", "Nézet", NULL); gtk_action_group_add_action(action_group, action); ui_manager = gtk_ui_manager_new(); gtk_ui_manager_set_add_tearoffs(ui_manager, FALSE); gtk_ui_manager_insert_action_group(ui_manager, action_group, 0); gtk_ui_manager_add_ui_from_file(ui_manager, "magus_kargen_res.ui", NULL); accel_group = gtk_accel_group_new(); main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); g_signal_connect(G_OBJECT(main_window), "destroy", G_SIGNAL_FUNC(main_window_destroy), NULL); gtk_window_add_accel_group(GTK_WINDOW(main_window), accel_group); gtk_window_set_title(GTK_WINDOW(main_window), "M.A.G.U.S. - Reneszánsz karakternyilvántartó"); menubar = gtk_ui_manager_get_widget(ui_manager, "/menu"); book = gtk_notebook_new(); gtk_notebook_set_scrollable(GTK_NOTEBOOK(book), TRUE); gtk_notebook_popup_enable(GTK_NOTEBOOK(book)); g_signal_connect(GTK_OBJECT(book), "change-current-page", G_SIGNAL_FUNC(lapvaltas), NULL); /* Azonnal látható és hallható dolgok */ scroll = gtk_scrolled_window_new(NULL, NULL); tabla = gtk_table_new(18, 2, FALSE); azonnal_lathato_dolgok_lap(GTK_TABLE(tabla)); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), tabla); gtk_notebook_append_page(GTK_NOTEBOOK(book), scroll, gtk_label_new(EGYBOL_LATHATO_HALLHATO_DOLGOK)); /* A játékos és a karakter adatai */ scroll = gtk_scrolled_window_new(NULL, NULL); tabla = gtk_table_new(4, 2, FALSE); jatekos_es_karakter_lap(GTK_TABLE(tabla)); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), tabla); gtk_notebook_append_page(GTK_NOTEBOOK(book), scroll, gtk_label_new(A_JATEKOS_ES_A_KARAKTER_ADATAI)); /* Képességek */ scroll = gtk_scrolled_window_new(NULL, NULL); tabla = gtk_table_new(10, 2, FALSE); kepessegek_lap(GTK_TABLE(tabla)); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), tabla); gtk_notebook_append_page(GTK_NOTEBOOK(book), scroll, gtk_label_new(KEPESSEGEK)); /* Főbb adatok */ scroll = gtk_scrolled_window_new(NULL, NULL); tabla = gtk_table_new(26, 4, FALSE); fobb_adatok_lap(GTK_TABLE(tabla)); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), tabla); gtk_notebook_append_page(GTK_NOTEBOOK(book), scroll, gtk_label_new(A_KARAKTER_FOBB_ADATAI)); /* Megjelenés */ scroll = gtk_scrolled_window_new(NULL, NULL); tabla = gtk_table_new(10, 4, FALSE); megjelenes_lap(GTK_TABLE(tabla)); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), tabla); gtk_notebook_append_page(GTK_NOTEBOOK(book), scroll, gtk_label_new(MEGJELENES)); /* Állandó érzelmek */ scroll = gtk_scrolled_window_new(NULL, NULL); tabla = gtk_table_new(15, 2, FALSE); erzelmek_lap(GTK_TABLE(tabla)); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), tabla); gtk_notebook_append_page(GTK_NOTEBOOK(book), scroll, gtk_label_new(ALLANDO_ERZELMEK)); /* Szimpatikus viszonyok. Ide majd egy TableView kene */ gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(SZIMPATIKUS_VISZONYOK)); /* Kapcsolatok, ismertseg. Ide majd egy TableView kene */ gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(ISMERTSEG)); /* Kulonleges kepessegek, hatranyok. Ide is TableView kene */ gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(KULONLEGES_KEPESSEGEK)); /* Tapasztalati pontok, átváltás */ scroll = gtk_scrolled_window_new(NULL, NULL); tabla = gtk_table_new(3, 2, FALSE); tapasztalat_lap(GTK_TABLE(tabla)); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), tabla); gtk_notebook_append_page(GTK_NOTEBOOK(book), scroll, gtk_label_new(TAPASZTALATI_PONTOK)); /* Képzettségek. Ide majd egy TableView kell */ gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(KEPZETTSEGEK)); /* Nyelvek. Ide is TableView */ gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(NYELVEK)); /* Harcértékek */ scroll = gtk_scrolled_window_new(NULL, NULL); tabla = gtk_table_new(5, 4, FALSE); harcertekek_lap(GTK_TABLE(tabla)); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), tabla); gtk_notebook_append_page(GTK_NOTEBOOK(book), scroll, gtk_label_new(HARCERTEKEK)); /* Életerő */ scroll = gtk_scrolled_window_new(NULL, NULL); tabla = gtk_table_new(3, 4, FALSE); eletero_lap(GTK_TABLE(tabla)); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), tabla); gtk_notebook_append_page(GTK_NOTEBOOK(book), scroll, gtk_label_new(ELETERO)); /* Pszi */ scroll = gtk_scrolled_window_new(NULL, NULL); tabla = gtk_table_new(5, 2, FALSE); pszi_lap(GTK_TABLE(tabla)); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), tabla); gtk_notebook_append_page(GTK_NOTEBOOK(book), scroll, gtk_label_new(PSZI)); /* Mágia */ gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(MAGIA)); /* Fegyverek és pajzsok. Ide két TableView kell. */ gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(FEGYVEREK_PAJZS)); /* Állatok, csatlósok, szolgák. Ide sok TableView kell */ gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(ALLATOK_CSATLOSOK)); /* Mesterek és tanítók. Ide két TableView kell */ gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(MESTEREK)); /* Földbirtokok. Ide is TableView kell */ gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(BIRTOKOK_BEFEKTETESEK)); gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(ALAKULATOK)); gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(ISKOLAK)); gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(MUVEK)); gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(ERTEKEK)); gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(RUHAK)); gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(VARAZSTARGYAK)); gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(FELSZERELES)); gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(VARAZSLATOK)); gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(TANULAS)); gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(SEBESULESEK)); gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(BETEGSEGEK)); gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(VARAZSLAT_KUTATAS)); gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(KULONLEGES_DOLGOK)); gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(MEGJEGYZESEK)); gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(TORTENET)); gtk_notebook_append_page(GTK_NOTEBOOK(book), gtk_table_new(1, 1, FALSE), gtk_label_new(KEPEK)); pri_vbox = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(pri_vbox), menubar, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(pri_vbox), book, TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(main_window), pri_vbox); gtk_widget_show_all(main_window); gtk_window_maximize(GTK_WINDOW(main_window)); gtk_main(); xmlCleanupParser(); return 0; }
static void anjuta_docman_update_documents_menu (AnjutaDocman* docman) { AnjutaDocmanPriv *priv = docman->priv; GtkUIManager* ui = GTK_UI_MANAGER (anjuta_shell_get_ui (ANJUTA_PLUGIN (priv->plugin)->shell, NULL)); GList *actions, *l; gint n, i; guint id; GSList *group = NULL; g_return_if_fail (priv->documents_action_group != NULL); if (priv->documents_merge_id != 0) gtk_ui_manager_remove_ui (ui, priv->documents_merge_id); actions = gtk_action_group_list_actions (priv->documents_action_group); for (l = actions; l != NULL; l = l->next) { g_signal_handlers_disconnect_by_func (GTK_ACTION (l->data), G_CALLBACK (on_document_toggled), docman); gtk_action_group_remove_action (priv->documents_action_group, GTK_ACTION (l->data)); } g_list_free (actions); n = gtk_notebook_get_n_pages (GTK_NOTEBOOK (docman)); id = (n > 0) ? gtk_ui_manager_new_merge_id (ui) : 0; for (i = 0; i < n; i++) { AnjutaDocmanPage* page; GtkRadioAction *action; gchar *action_name; const gchar *tab_name; gchar *accel; page = anjuta_docman_get_nth_page (docman, i); /* NOTE: the action is associated to the position of the tab in * the notebook not to the tab itself! This is needed to work * around the gtk+ bug #170727: gtk leaves around the accels * of the action. Since the accel depends on the tab position * the problem is worked around, action with the same name always * get the same accel. */ action_name = g_strdup_printf ("Tab_%d", i); tab_name = gtk_label_get_label (GTK_LABEL (page->label)); /* alt + 1, 2, 3... 0 to switch to the first ten tabs */ accel = (i < 10) ? g_strdup_printf ("<alt>%d", (i + 1) % 10) : NULL; action = gtk_radio_action_new (action_name, tab_name, NULL, NULL, i); if (group != NULL) gtk_radio_action_set_group (action, group); /* note that group changes each time we add an action, so it must be updated */ group = gtk_radio_action_get_group (action); gtk_action_group_add_action_with_accel (priv->documents_action_group, GTK_ACTION (action), accel); g_signal_connect (action, "toggled", G_CALLBACK (on_document_toggled), docman); gtk_ui_manager_add_ui (ui, id, MENU_PLACEHOLDER, action_name, action_name, GTK_UI_MANAGER_MENUITEM, FALSE); if (i == gtk_notebook_get_current_page (GTK_NOTEBOOK (docman))) gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), TRUE); g_object_unref (action); g_free (action_name); g_free (accel); } anjuta_docman_update_documents_menu_status (docman); priv->documents_merge_id = id; }
int main ( int argc, char **argv ) { int k; GtkWidget *window, *child, *box, *menu, *subMenu; GtkAction *action[2]; GtkUIManager *manager; gtk_init ( &argc, &argv ); window = gtk_window_new ( GTK_WINDOW_TOPLEVEL ); box = gtk_vbox_new ( 0, 0 ); gtk_container_add ( GTK_CONTAINER ( window ), box ); /* menuBar = gtk_menu_bar_new(); gtk_container_add( GTK_CONTAINER( box ), menuBar ); menu = gtk_menu_item_new_with_label( "Menu" ); gtk_container_add( GTK_CONTAINER( menuBar ), menu ); subMenu = gtk_menu_new(); gtk_menu_item_set_submenu( menu, subMenu ); */ { /* actionGroup name -entries ... -toggleEntries ... -radioEntries $name addEntries $name addToggleEntries $name addRadioEntries */ GtkActionGroup *action_group = gtk_action_group_new ( "MenuActions" ); gtk_action_group_add_actions ( action_group, entries, G_N_ELEMENTS ( entries ), window ); gtk_action_group_add_toggle_actions ( action_group, toggle_entries, G_N_ELEMENTS ( toggle_entries ), window ); gtk_action_group_add_radio_actions ( action_group, radio_entries, G_N_ELEMENTS ( radio_entries ), 0, func1, window ); /* uiManager addUI ui_description -groups $name $manager addGroup */ manager = gtk_ui_manager_new (); gtk_ui_manager_insert_action_group ( manager , action_group, 0 ); } { /* $manager setAccelWindow window */ GtkAccelGroup *accel_group = gtk_ui_manager_get_accel_group ( manager ); gtk_window_add_accel_group ( GTK_WINDOW ( window ), accel_group ); } { /* $manager setUiDescription xxx */ GError *error = NULL; if ( !gtk_ui_manager_add_ui_from_string ( manager, ui_description, -1, &error ) ) { g_message ( "building menus failed: %s", error->message ); g_error_free ( error ); exit ( 1 ); } } { /* $manager getWidget name */ GtkWidget *menuBar = gtk_ui_manager_get_widget ( manager, "/MainMenu" ); gtk_box_pack_start ( GTK_BOX ( box ), menuBar, FALSE, FALSE, 0 ); } gtk_widget_show_all ( window ); /* action[0] = GTK_ACTION( gtk_action_new( "name", "label", "tooltip", NULL ) ); action[1] = GTK_ACTION( gtk_action_new( "name2", "label2", "tooltip2", "gtk-quit" ) ); g_signal_connect( action[0], "activate", G_CALLBACK( func1 ), NULL); g_signal_connect( action[1], "activate", G_CALLBACK( func2 ), NULL); */ /* accelGroup = gtk_accel_group_new(); */ #if 0 group = gtk_action_group_new ( "global" ); gtk_action_group_add_actions ( group, entries, 1, window ); manager = gtk_ui_manager_new (); gtk_ui_manager_insert_action_group ( manager, group, 0 ); accelGroup = gtk_ui_manager_get_accel_group ( manager ); gtk_window_add_accel_group ( GTK_WINDOW ( window ), accelGroup ); for ( k = 0; k < 2; ++k ) { child = gtk_action_create_menu_item ( action[k] ); gtk_container_add ( GTK_CONTAINER ( subMenu ), child ); child = gtk_action_create_tool_item ( action[k] ); gtk_container_add ( GTK_CONTAINER ( box ), child ); } gtk_action_group_add_action_with_accel ( group, action[0], "<control>w" ); gtk_action_group_add_action_with_accel ( group, action[1], NULL ); #endif gtk_widget_show_all ( window ); gtk_main(); return 0; }
GSList * gimp_action_group_add_radio_actions (GimpActionGroup *group, const gchar *msg_context, const GimpRadioActionEntry *entries, guint n_entries, GSList *radio_group, gint value, GCallback callback) { GtkRadioAction *first_action = NULL; gint i; g_return_val_if_fail (GIMP_IS_ACTION_GROUP (group), NULL); for (i = 0; i < n_entries; i++) { GtkRadioAction *action; const gchar *label; const gchar *tooltip = NULL; if (! gimp_action_group_check_unique_action (group, entries[i].name)) continue; if (msg_context) { label = g_dpgettext2 (NULL, msg_context, entries[i].label); if (entries[i].tooltip) tooltip = g_dpgettext2 (NULL, msg_context, entries[i].tooltip); } else { label = gettext (entries[i].label); tooltip = gettext (entries[i].tooltip); } action = gimp_radio_action_new (entries[i].name, label, tooltip, entries[i].icon_name, entries[i].value); if (i == 0) first_action = action; gtk_radio_action_set_group (action, radio_group); radio_group = gtk_radio_action_get_group (action); if (value == entries[i].value) gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), TRUE); gtk_action_group_add_action_with_accel (GTK_ACTION_GROUP (group), GTK_ACTION (action), entries[i].accelerator); g_signal_emit (group, signals[ACTION_ADDED], 0, action); if (entries[i].help_id) g_object_set_qdata_full (G_OBJECT (action), GIMP_HELP_ID, g_strdup (entries[i].help_id), (GDestroyNotify) g_free); g_object_unref (action); } if (callback && first_action) g_signal_connect (first_action, "changed", callback, group->user_data); return radio_group; }
static void set_up_tree_view (TotemYouTubePlugin *self, GtkBuilder *builder, guint key) { GtkUIManager *ui_manager; GtkActionGroup *action_group; GtkAction *action, *menu_item; GtkWidget *vscroll, *tree_view; GtkTreeViewColumn *column; GtkCellRenderer *renderer; /* Add the cell renderer. This can't be done with GtkBuilder, because it unavoidably sets the expand parameter to FALSE */ /* TODO: Depends on bug #453692 */ renderer = GTK_CELL_RENDERER (totem_cell_renderer_video_new (TRUE)); column = GTK_TREE_VIEW_COLUMN (gtk_builder_get_object (builder, (key == SEARCH_TREE_VIEW) ? "yt_treeview_search_column" : "yt_treeview_related_column")); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_attributes (column, renderer, "thumbnail", 0, "title", 1, NULL); /* Give the video lists a handle to Totem and connect their scrollbar signals */ if (key == SEARCH_TREE_VIEW) { tree_view = GTK_WIDGET (gtk_builder_get_object (builder, "yt_treeview_search")); vscroll = gtk_scrolled_window_get_vscrollbar (GTK_SCROLLED_WINDOW (gtk_builder_get_object (builder, "yt_scrolled_window_search"))); self->list_store[key] = GTK_LIST_STORE (gtk_builder_get_object (builder, "yt_list_store_search")); self->tree_view[key] = GTK_TREE_VIEW (tree_view); self->progress_bar[key] = GTK_PROGRESS_BAR (gtk_builder_get_object (builder, "yt_progress_bar_search")); } else { tree_view = GTK_WIDGET (gtk_builder_get_object (builder, "yt_treeview_related")); vscroll = gtk_scrolled_window_get_vscrollbar (GTK_SCROLLED_WINDOW (gtk_builder_get_object (builder, "yt_scrolled_window_related"))); self->list_store[key] = GTK_LIST_STORE (gtk_builder_get_object (builder, "yt_list_store_related")); self->tree_view[key] = GTK_TREE_VIEW (tree_view); self->progress_bar[key] = GTK_PROGRESS_BAR (gtk_builder_get_object (builder, "yt_progress_bar_related")); } g_object_set (tree_view, "totem", self->totem, NULL); g_signal_connect (vscroll, "button-press-event", G_CALLBACK (button_press_event_cb), self); g_signal_connect (vscroll, "button-release-event", G_CALLBACK (button_release_event_cb), self); /* Add the extra popup menu options. This is done here rather than in the UI file, because it's done for multiple treeviews; * if it were done in the UI file, the same action group would be used multiple times, which GTK+ doesn't like. */ ui_manager = totem_video_list_get_ui_manager (TOTEM_VIDEO_LIST (tree_view)); action_group = gtk_action_group_new ("youtube-action-group"); action = gtk_action_new ("open-in-web-browser", _("_Open in Web Browser"), _("Open the video in your web browser"), "gtk-jump-to"); gtk_action_group_add_action_with_accel (action_group, action, NULL); gtk_ui_manager_insert_action_group (ui_manager, action_group, 1); gtk_ui_manager_add_ui (ui_manager, gtk_ui_manager_new_merge_id (ui_manager), "/ui/totem-video-list-popup/", "open-in-web-browser", "open-in-web-browser", GTK_UI_MANAGER_MENUITEM, FALSE); menu_item = gtk_ui_manager_get_action (ui_manager, "/ui/totem-video-list-popup/open-in-web-browser"); g_signal_connect (menu_item, "activate", G_CALLBACK (open_in_web_browser_activate_cb), self); /* Connect to more scroll events */ #if GTK_CHECK_VERSION(3, 0, 0) self->vadjust[key] = gtk_scrollable_get_vadjustment(GTK_SCROLLABLE(tree_view)); #else self->vadjust[key] = gtk_tree_view_get_vadjustment(GTK_TREE_VIEW(tree_view)); #endif g_signal_connect (self->vadjust[key], "value-changed", G_CALLBACK (value_changed_cb), self); self->cancel_button = GTK_WIDGET (gtk_builder_get_object (builder, "yt_cancel_button")); }
/*! \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; } } }
/** * nemo_window_initialize_menus * * Create and install the set of menus for this window. * @window: A recently-created NemoWindow. */ void nemo_window_initialize_menus (NemoWindow *window) { GtkActionGroup *action_group; GtkUIManager *ui_manager; GtkAction *action; gint i; if (window->details->ui_manager == NULL){ window->details->ui_manager = gtk_ui_manager_new (); } ui_manager = window->details->ui_manager; /* shell actions */ action_group = gtk_action_group_new ("ShellActions"); gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE); window->details->main_action_group = action_group; gtk_action_group_add_actions (action_group, main_entries, G_N_ELEMENTS (main_entries), window); gtk_action_group_add_toggle_actions (action_group, main_toggle_entries, G_N_ELEMENTS (main_toggle_entries), window); gtk_action_group_add_radio_actions (action_group, main_radio_entries, G_N_ELEMENTS (main_radio_entries), 0, G_CALLBACK (sidebar_radio_entry_changed_cb), window); action = gtk_action_group_get_action (action_group, NEMO_ACTION_UP); g_object_set (action, "short_label", _("_Up"), NULL); action = gtk_action_group_get_action (action_group, NEMO_ACTION_HOME); g_object_set (action, "short_label", _("_Home"), NULL); action = gtk_action_group_get_action (action_group, NEMO_ACTION_EDIT_LOCATION); g_object_set (action, "short_label", _("_Location"), NULL); action = gtk_action_group_get_action (action_group, NEMO_ACTION_SHOW_HIDDEN_FILES); g_signal_handlers_block_by_func (action, action_show_hidden_files_callback, window); gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), g_settings_get_boolean (nemo_preferences, NEMO_PREFERENCES_SHOW_HIDDEN_FILES)); g_signal_handlers_unblock_by_func (action, action_show_hidden_files_callback, window); g_signal_connect_swapped (nemo_preferences, "changed::" NEMO_PREFERENCES_SHOW_HIDDEN_FILES, G_CALLBACK(show_hidden_files_preference_callback), window); /* Alt+N for the first 10 tabs */ for (i = 0; i < 10; ++i) { gchar action_name[80]; gchar accelerator[80]; snprintf(action_name, sizeof (action_name), "Tab%d", i); action = gtk_action_new (action_name, NULL, NULL, NULL); g_object_set_data (G_OBJECT (action), "num", GINT_TO_POINTER (i)); g_signal_connect (action, "activate", G_CALLBACK (action_tab_change_action_activate_callback), window); snprintf(accelerator, sizeof (accelerator), "<alt>%d", (i+1)%10); gtk_action_group_add_action_with_accel (action_group, action, accelerator); g_object_unref (action); gtk_ui_manager_add_ui (ui_manager, gtk_ui_manager_new_merge_id (ui_manager), "/", action_name, action_name, GTK_UI_MANAGER_ACCELERATOR, FALSE); } gtk_ui_manager_insert_action_group (ui_manager, action_group, 0); g_object_unref (action_group); /* owned by ui_manager */ gtk_window_add_accel_group (GTK_WINDOW (window), gtk_ui_manager_get_accel_group (ui_manager)); g_signal_connect (ui_manager, "connect_proxy", G_CALLBACK (connect_proxy_cb), window); g_signal_connect (ui_manager, "disconnect_proxy", G_CALLBACK (disconnect_proxy_cb), window); /* add the UI */ gtk_ui_manager_add_ui_from_resource (ui_manager, "/org/nemo/nemo-shell-ui.xml", NULL); nemo_window_initialize_trash_icon_monitor (window); nemo_window_initialize_go_menu (window); }
static void add_extension_menu_items (CajaWindow *window, guint merge_id, GtkActionGroup *action_group, GList *menu_items, const char *subdirectory) { GtkUIManager *ui_manager; GList *l; ui_manager = window->details->ui_manager; for (l = menu_items; l; l = l->next) { CajaMenuItem *item; CajaMenu *menu; GtkAction *action; char *path; item = CAJA_MENU_ITEM (l->data); g_object_get (item, "menu", &menu, NULL); action = caja_action_from_menu_item (item); gtk_action_group_add_action_with_accel (action_group, action, NULL); path = g_build_path ("/", POPUP_PATH_EXTENSION_ACTIONS, subdirectory, NULL); gtk_ui_manager_add_ui (ui_manager, merge_id, path, gtk_action_get_name (action), gtk_action_get_name (action), (menu != NULL) ? GTK_UI_MANAGER_MENU : GTK_UI_MANAGER_MENUITEM, FALSE); g_free (path); path = g_build_path ("/", MENU_PATH_EXTENSION_ACTIONS, subdirectory, NULL); gtk_ui_manager_add_ui (ui_manager, merge_id, path, gtk_action_get_name (action), gtk_action_get_name (action), (menu != NULL) ? GTK_UI_MANAGER_MENU : GTK_UI_MANAGER_MENUITEM, FALSE); g_free (path); /* recursively fill the menu */ if (menu != NULL) { char *subdir; GList *children; children = caja_menu_get_items (menu); subdir = g_build_path ("/", subdirectory, "/", gtk_action_get_name (action), NULL); add_extension_menu_items (window, merge_id, action_group, children, subdir); caja_menu_item_list_free (children); g_free (subdir); } } }
/** * nautilus_window_initialize_menus * * Create and install the set of menus for this window. * @window: A recently-created NautilusWindow. */ void nautilus_window_initialize_menus (NautilusWindow *window) { GtkActionGroup *action_group; GtkUIManager *ui_manager; GtkAction *action; gint i; window->details->ui_manager = gtk_ui_manager_new (); ui_manager = window->details->ui_manager; /* shell actions */ action_group = gtk_action_group_new ("ShellActions"); gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE); window->details->main_action_group = action_group; gtk_action_group_add_actions (action_group, main_entries, G_N_ELEMENTS (main_entries), window); gtk_action_group_add_toggle_actions (action_group, main_toggle_entries, G_N_ELEMENTS (main_toggle_entries), window); gtk_action_group_add_radio_actions (action_group, view_radio_entries, G_N_ELEMENTS (view_radio_entries), -1, G_CALLBACK (action_view_radio_changed), window); action = nautilus_option_menu_action_new ("Zoom Options", _("Zoom"), _("Zoom Options"), NULL); gtk_action_group_add_action (action_group, action); g_object_unref (action); nautilus_window_menus_set_visibility_for_app_menu (window); window->details->app_menu_visibility_id = g_signal_connect_swapped (gtk_settings_get_for_screen (gtk_widget_get_screen (GTK_WIDGET (window))), "notify::gtk-shell-shows-app-menu", G_CALLBACK (nautilus_window_menus_set_visibility_for_app_menu), window); action = gtk_action_group_get_action (action_group, NAUTILUS_ACTION_UP); g_object_set (action, "short_label", _("_Up"), NULL); action = gtk_action_group_get_action (action_group, NAUTILUS_ACTION_HOME); g_object_set (action, "short_label", _("_Home"), NULL); /* Alt+N for the first 10 tabs */ for (i = 0; i < 10; ++i) { gchar action_name[80]; gchar accelerator[80]; snprintf(action_name, sizeof (action_name), "Tab%d", i); action = gtk_action_new (action_name, NULL, NULL, NULL); g_object_set_data (G_OBJECT (action), "num", GINT_TO_POINTER (i)); g_signal_connect (action, "activate", G_CALLBACK (action_tab_change_action_activate_callback), window); snprintf(accelerator, sizeof (accelerator), "<alt>%d", (i+1)%10); gtk_action_group_add_action_with_accel (action_group, action, accelerator); g_object_unref (action); gtk_ui_manager_add_ui (ui_manager, gtk_ui_manager_new_merge_id (ui_manager), "/", action_name, action_name, GTK_UI_MANAGER_ACCELERATOR, FALSE); } gtk_ui_manager_insert_action_group (ui_manager, action_group, 0); g_object_unref (action_group); /* owned by ui_manager */ gtk_window_add_accel_group (GTK_WINDOW (window), gtk_ui_manager_get_accel_group (ui_manager)); g_signal_connect (ui_manager, "connect-proxy", G_CALLBACK (connect_proxy_cb), window); /* add the UI */ gtk_ui_manager_add_ui_from_resource (ui_manager, "/org/gnome/nautilus/nautilus-shell-ui.xml", NULL); /* set actions for option menu items */ populate_option_menu_items (window); }