/** * 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 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 GtkActionGroup * create_or_ref_display_actions (gboolean include_common) { if (display_actions) return g_object_ref (display_actions); display_actions = gtk_action_group_new ("display-actions"); gtk_action_group_set_translation_domain (display_actions, NULL); gtk_action_group_set_translate_func (display_actions, _dia_translate, NULL, NULL); if (include_common) gtk_action_group_add_actions (display_actions, common_entries, G_N_ELEMENTS (common_entries), NULL); gtk_action_group_add_actions (display_actions, display_entries, G_N_ELEMENTS (display_entries), NULL); gtk_action_group_add_toggle_actions (display_actions, display_toggle_entries, G_N_ELEMENTS (display_toggle_entries), NULL); gtk_action_group_add_radio_actions (display_actions, display_select_radio_entries, G_N_ELEMENTS (display_select_radio_entries), 0, /* SELECT_REPLACE - first radio entry */ G_CALLBACK (select_style_callback), NULL); /* the initial reference */ return display_actions; }
Actions::Actions(Window *window): m_window(window) { m_actionGroup = gtk_action_group_new("actions"); gtk_action_group_set_translation_domain(m_actionGroup, NULL); gtk_action_group_add_actions(m_actionGroup, actionEntries, N_ACTIONS, window); for (int i = 0; i < N_ACTIONS; ++i) m_actions[i] = gtk_action_group_get_action(m_actionGroup, actionEntries[i].name); gtk_action_group_add_toggle_actions(m_actionGroup, toggleActionEntries, N_TOGGLE_ACTIONS, m_window); for (int i = 0; i < N_TOGGLE_ACTIONS; ++i) m_toggleActions[i] = GTK_TOGGLE_ACTION( gtk_action_group_get_action(m_actionGroup, toggleActionEntries[i].name)); gtk_action_group_add_radio_actions(m_actionGroup, windowLayoutEntries, 2, Window::LAYOUT_TOOLS_PANE_RIGHT, G_CALLBACK(changeWindowLayout), m_window); m_radioActionGroups[RADIO_ACTION_GROUP_WINDOW_LAYOUT] = GTK_RADIO_ACTION( gtk_action_group_get_action(m_actionGroup, windowLayoutEntries[0].name)); }
static void galeon_encoding_menu_set_window (GaleonEncodingMenu *menu, GaleonWindow *window) { GtkActionGroup *action_group; GtkWidget *widget; GList *encodings; g_return_if_fail (GALEON_IS_WINDOW (window)); menu->priv->window = window; menu->priv->merge = GTK_UI_MANAGER (window->merge); action_group = gtk_action_group_new ("EncodingActions"); gtk_action_group_set_translation_domain (action_group, NULL); menu->priv->action_group = action_group; gtk_action_group_add_actions (action_group, menu_entries, n_menu_entries, menu); gtk_action_group_add_toggle_actions (action_group, toggle_menu_entries, n_toggle_menu_entries, menu); encodings = galeon_encodings_get_encodings (menu->priv->encodings, LG_ALL); g_list_foreach (encodings, (GFunc) add_action, menu); g_list_free (encodings); gtk_ui_manager_insert_action_group (menu->priv->merge, action_group, 0); g_object_unref (action_group); widget = gtk_ui_manager_get_widget (menu->priv->merge, "/menubar/View"); g_signal_connect_object (widget, "activate", G_CALLBACK (update_encoding_menu_cb), menu, 0); }
gboolean e_plugin_ui_init (GtkUIManager *ui_manager, EMsgComposer *composer) { GtkhtmlEditor *editor; static GtkToggleActionEntry entries[] = { { "face-plugin", NULL, N_("Include _Face"), NULL, NULL, G_CALLBACK (action_toggle_face_cb), FALSE } }; if (get_include_face_by_default ()) { gchar *face = get_face_base64 (); /* activate it only if has a face image available */ entries[0].is_active = face && *face; g_free (face); } editor = GTKHTML_EDITOR (composer); /* Add actions to the "composer" action group. */ gtk_action_group_add_toggle_actions ( gtkhtml_editor_get_action_group (editor, "composer"), entries, G_N_ELEMENTS (entries), composer); return TRUE; }
GtkWidget *toolbar_init(GtkWindow *parent) { GtkWidget *vbox = gtk_vbox_new(FALSE, 0); GtkToolbar *toolbar; GtkActionGroup *ag = gtk_action_group_new("Actions"); gtk_action_group_add_actions(ag, action_items, G_N_ELEMENTS(action_items), parent); gtk_action_group_add_toggle_actions(ag, toggle_items, G_N_ELEMENTS(toggle_items), parent); GtkUIManager *ui = gtk_ui_manager_new(); g_object_set_data(G_OBJECT(parent), "ui_manager", ui); gtk_ui_manager_insert_action_group(ui, ag, 0); GtkAccelGroup *accel = gtk_ui_manager_get_accel_group(ui); gtk_window_add_accel_group(parent, accel); GError *error = NULL; if (!gtk_ui_manager_add_ui_from_string (ui, ui_xml, -1, &error)) { g_message ("building menus failed: %s", error->message); g_error_free (error); exit (-1); } GtkWidget *menubar = gtk_ui_manager_get_widget(ui, "/menubar"); gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(menubar), FALSE, TRUE, 0); toolbar = GTK_TOOLBAR(gtk_ui_manager_get_widget(ui, "/toolbar")); gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(toolbar), FALSE, TRUE, 0); /* Device selection GtkComboBox */ GtkToolItem *toolitem = gtk_tool_item_new(); GtkWidget *dev = dev_select_combo_box_new(parent); gtk_container_add(GTK_CONTAINER(toolitem), dev); gtk_toolbar_insert(toolbar, toolitem, 0); /* Time/Samples entry */ toolitem = gtk_tool_item_new(); GtkWidget *timesamples = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(timesamples), "100"); gtk_entry_set_alignment(GTK_ENTRY(timesamples), 1.0); gtk_widget_set_size_request(timesamples, 100, -1); gtk_container_add(GTK_CONTAINER(toolitem), timesamples); gtk_toolbar_insert(toolbar, toolitem, 7); /* Time unit combo box */ toolitem = gtk_tool_item_new(); GtkWidget *timeunit = gtk_combo_box_new_text(); gtk_combo_box_append_text(GTK_COMBO_BOX(timeunit), "samples"); gtk_combo_box_append_text(GTK_COMBO_BOX(timeunit), "ms"); gtk_combo_box_append_text(GTK_COMBO_BOX(timeunit), "s"); gtk_combo_box_set_active(GTK_COMBO_BOX(timeunit), 0); gtk_container_add(GTK_CONTAINER(toolitem), timeunit); gtk_toolbar_insert(toolbar, toolitem, 8); g_object_set_data(G_OBJECT(parent), "timesamples", timesamples); g_object_set_data(G_OBJECT(parent), "timeunit", timeunit); return GTK_WIDGET(vbox); }
static VALUE actiongroup_add_toggle_actions(VALUE self, VALUE entries) { guint i; VALUE toggle_action_procs; guint n_entries = (guint)RARRAY_LEN(entries); GtkToggleActionEntry* gentries = g_new0(GtkToggleActionEntry, n_entries); if (rb_ivar_defined(self, id_toggle_action_procs) == Qtrue){ toggle_action_procs = rb_ivar_get(self, id_toggle_action_procs); } else { toggle_action_procs = rb_hash_new(); } for (i = 0; i < n_entries; i++){ VALUE entry; int size; entry = RARRAY_PTR(entries)[i]; size = RARRAY_LEN(entry); if (size < 1) rb_raise(rb_eArgError, "wrong array parameter"); gentries[i].name = RVAL2CSTR_ACCEPT_NIL(RARRAY_PTR(entry)[0]); gentries[i].callback = G_CALLBACK(activate_toggle_action); if (size < 2) continue; if (NIL_P(RARRAY_PTR(entry)[1])){ gentries[i].stock_id = NULL; } else if (SYMBOL_P(RARRAY_PTR(entry)[1])){ gentries[i].stock_id = rb_id2name(SYM2ID(RARRAY_PTR(entry)[1])); } else if (TYPE(RARRAY_PTR(entry)[1]) == T_STRING){ gentries[i].stock_id = RVAL2CSTR(RARRAY_PTR(entry)[1]); } else{ rb_raise(rb_eArgError, "invalid argument %s (expect Symbol or String)", rb_class2name(CLASS_OF(RARRAY_PTR(entry)[1]))); } if (size < 3) continue; gentries[i].label = RVAL2CSTR_ACCEPT_NIL(RARRAY_PTR(entry)[2]); if (size < 4) continue; gentries[i].accelerator = RVAL2CSTR_ACCEPT_NIL(RARRAY_PTR(entry)[3]); if (size < 4) continue; gentries[i].tooltip = RVAL2CSTR_ACCEPT_NIL(RARRAY_PTR(entry)[4]); if (size < 5) continue; rb_hash_aset(toggle_action_procs, RARRAY_PTR(entry)[0], RARRAY_PTR(entry)[5]); if (size < 6) continue; gentries[i].is_active = RVAL2CBOOL(RARRAY_PTR(entry)[6]); } rb_ivar_set(self, id_toggle_action_procs, toggle_action_procs); gtk_action_group_add_toggle_actions(_SELF(self), gentries, n_entries, (gpointer)self); g_free(gentries); return self; }
/** * 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; const char *ui; 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); 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); action = gtk_action_group_get_action (action_group, NAUTILUS_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), eel_preferences_get_boolean (NAUTILUS_PREFERENCES_SHOW_HIDDEN_FILES)); g_signal_handlers_unblock_by_func (action, action_show_hidden_files_callback, window); eel_preferences_add_callback_while_alive (NAUTILUS_PREFERENCES_SHOW_HIDDEN_FILES, show_hidden_files_preference_callback, window, G_OBJECT (window)); window->details->ui_manager = gtk_ui_manager_new (); ui_manager = window->details->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); gtk_ui_manager_insert_action_group (ui_manager, action_group, 0); g_object_unref (action_group); /* owned by ui manager */ ui = nautilus_ui_string_get ("nautilus-shell-ui.xml"); gtk_ui_manager_add_ui_from_string (ui_manager, ui, -1, NULL); nautilus_window_initialize_trash_icon_monitor (window); nautilus_window_initialize_bookmarks_menu (window); }
static void gs_window_build_ui (GsWindow *window) { GtkWidget *menubar; g_return_if_fail (GS_IS_WINDOW (window)); window->priv->box = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), window->priv->box); gtk_widget_show (window->priv->box); window->priv->ui_manager = gtk_ui_manager_new (); window->priv->ui_actions = gtk_action_group_new ("MenuActions"); gtk_action_group_add_actions (window->priv->ui_actions, action_entries, G_N_ELEMENTS (action_entries), window); gtk_action_group_add_toggle_actions (window->priv->ui_actions, toggle_action_entries, G_N_ELEMENTS (toggle_action_entries), window); gtk_ui_manager_insert_action_group (window->priv->ui_manager, window->priv->ui_actions, 0); if (!gtk_ui_manager_add_ui_from_string (window->priv->ui_manager, UI_DEFINITION, -1, NULL)) { g_assert ("No se pudo cargar la UI"); } menubar = gtk_ui_manager_get_widget (window->priv->ui_manager, "/MainMenu"); g_assert (GTK_IS_WIDGET (menubar)); gtk_box_pack_start (GTK_BOX (window->priv->box), menubar, FALSE, FALSE, 0); gtk_widget_show (menubar); gtk_window_add_accel_group (GTK_WINDOW (window), gtk_ui_manager_get_accel_group (window->priv->ui_manager)); window->priv->graph = gs_graph_new (); gtk_widget_show (window->priv->graph); window->priv->hpaned = gtk_hpaned_new (); gtk_paned_pack1 (GTK_PANED (window->priv->hpaned), window->priv->graph, TRUE, FALSE); window->priv->plot_list_panel = gs_plot_list_panel_new (GS_WINDOW (window)); gtk_paned_pack2 (GTK_PANED (window->priv->hpaned), window->priv->plot_list_panel, TRUE, FALSE); gtk_widget_show (window->priv->plot_list_panel); gtk_widget_show (window->priv->hpaned); gtk_box_pack_start (GTK_BOX (window->priv->box), window->priv->hpaned, TRUE, TRUE, 0); window->priv->statusbar = gtk_statusbar_new (); gtk_box_pack_end (GTK_BOX (window->priv->box), window->priv->statusbar, FALSE, FALSE, 0); gtk_widget_show (window->priv->statusbar); }
static void log_build( GtkWidget *widget ) { Log *log = LOG( widget ); iWindow *iwnd = IWINDOW( widget ); LogClass *log_class = LOG_GET_CLASS( log ); GError *error; GtkWidget *mbar; GtkWidget *swin; PangoFontDescription *font_desc; IWINDOW_CLASS( parent_class )->build( widget ); gtk_action_group_add_actions( iwnd->action_group, log_class->actions, log_class->n_actions, GTK_WINDOW( log ) ); gtk_action_group_add_toggle_actions( iwnd->action_group, log_class->toggle_actions, log_class->n_toggle_actions, GTK_WINDOW( log ) ); if( !gtk_ui_manager_add_ui_from_string( iwnd->ui_manager, log_class->ui_description, -1, &error ) ) { g_message( "building menus failed: %s", error->message ); g_error_free( error ); exit( EXIT_FAILURE ); } mbar = gtk_ui_manager_get_widget( iwnd->ui_manager, log_class->menu_bar_name ); gtk_box_pack_start( GTK_BOX( iwnd->work ), mbar, FALSE, FALSE, 0 ); gtk_widget_show( mbar ); swin = gtk_scrolled_window_new( NULL, NULL ); gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( swin ), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC ); gtk_box_pack_start( GTK_BOX( iwnd->work ), swin, TRUE, TRUE, 0 ); gtk_widget_show( swin ); log->view = gtk_text_view_new(); gtk_text_view_set_editable( GTK_TEXT_VIEW( log->view ), FALSE ); gtk_text_view_set_cursor_visible( GTK_TEXT_VIEW( log->view ), FALSE ); font_desc = pango_font_description_from_string( "Monospace" ); gtk_widget_modify_font( log->view, font_desc ); pango_font_description_free( font_desc ); gtk_container_add( GTK_CONTAINER( swin ), log->view ); gtk_widget_show( log->view ); }
void libre_impuesto_window_actions_init (LibreImpuestoWindow *impuesto_window) { GtkActionGroup *action_group; GtkUIManager *ui_manager; gchar *filename; GError *error; gboolean ret_val; g_return_if_fail (IS_LIBRE_IMPUESTO_WINDOW (impuesto_window)); ui_manager = libre_impuesto_window_get_ui_manager (impuesto_window); action_group = libre_impuesto_add_action_group(ui_manager, "impuesto"); gtk_action_group_add_actions ( action_group, impuesto_entries, G_N_ELEMENTS (impuesto_entries), impuesto_window); gtk_action_group_add_toggle_actions ( action_group, impuesto_toggle_entries, G_N_ELEMENTS (impuesto_toggle_entries), impuesto_window); error = NULL; filename = g_build_filename (LIBRE_IMPUESTO_UIDIR, "libre-impuestos-menu.ui", NULL); ret_val = gtk_ui_manager_add_ui_from_file (ui_manager, filename, &error); g_free (filename); if (!ret_val) { g_critical("%s", error->message); } g_object_bind_property (impuesto_window, "headerbar-visible", libre_impuesto_window_get_action (impuesto_window, "show-headerbar"), "active", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); g_object_bind_property (impuesto_window, "sidebar-visible", libre_impuesto_window_get_action( impuesto_window, "show-sidebar"), "active", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); g_object_bind_property (impuesto_window, "statusbar-visible", libre_impuesto_window_get_action (impuesto_window, "show-statusbar"), "active", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); }
static void task_view_activate (PlannerView *view) { PlannerTaskViewPriv *priv; gboolean show_critical; gboolean show_nostd_days; gchar *filename; priv = PLANNER_TASK_VIEW (view)->priv; priv->actions = gtk_action_group_new ("TaskView"); gtk_action_group_set_translation_domain (priv->actions, GETTEXT_PACKAGE); gtk_action_group_add_actions (priv->actions, entries, G_N_ELEMENTS (entries), view); gtk_action_group_add_toggle_actions (priv->actions, toggle_entries, G_N_ELEMENTS (toggle_entries), view); gtk_ui_manager_insert_action_group (priv->ui_manager, priv->actions, 0); filename = mrp_paths_get_ui_dir ("task-view.ui"); priv->merged_id = gtk_ui_manager_add_ui_from_file (priv->ui_manager, filename, NULL); g_free (filename); gtk_ui_manager_ensure_update (priv->ui_manager); /* Set the initial UI state. */ show_critical = planner_conf_get_bool (CRITICAL_PATH_KEY, NULL); show_nostd_days = planner_conf_get_bool (NOSTDDAYS_PATH_KEY, NULL); planner_task_tree_set_highlight_critical (PLANNER_TASK_TREE (priv->tree), show_critical); planner_task_tree_set_nonstandard_days (PLANNER_TASK_TREE (priv->tree), show_nostd_days); gtk_toggle_action_set_active ( GTK_TOGGLE_ACTION (gtk_action_group_get_action (priv->actions, "HighlightCriticalTasks")), show_critical); gtk_toggle_action_set_active ( GTK_TOGGLE_ACTION (gtk_action_group_get_action (priv->actions, "NonstandardDays")), show_nostd_days); task_view_selection_changed_cb (PLANNER_TASK_TREE (priv->tree), view); gtk_widget_grab_focus (priv->tree); }
void menus_get_integrated_ui_menubar (GtkWidget **menubar, GtkWidget **toolbar, GtkAccelGroup **accel_group) { GError *error = NULL; gchar *uifile; _setup_global_actions (); g_return_if_fail (_ui_manager != NULL); /* the integrated ui menu */ display_actions = create_or_ref_display_actions (FALSE); g_return_if_fail (tool_actions != NULL); /* maybe better to put this into toolbox_actions? */ gtk_action_group_add_toggle_actions (display_actions, integrated_ui_view_toggle_entries, G_N_ELEMENTS (integrated_ui_view_toggle_entries), NULL); /* for stand-alone they are per display */ gtk_ui_manager_insert_action_group (_ui_manager, display_actions, 0); tool_actions = create_or_ref_tool_actions (); gtk_ui_manager_insert_action_group (_ui_manager, tool_actions, 0); uifile = build_ui_filename ("ui/integrated-ui.xml"); if (!gtk_ui_manager_add_ui_from_file (_ui_manager, uifile, &error)) { g_warning ("building integrated ui menus failed: %s", error->message); g_error_free (error); error = NULL; } g_free (uifile); if (!gtk_ui_manager_add_ui_from_string (_ui_manager, ui_info, -1, &error)) { g_warning ("built-in menus failed: %s", error->message); g_error_free (error); error = NULL; } add_plugin_actions (_ui_manager, NULL); /* after creating all menu items */ load_accels (); if (menubar) *menubar = gtk_ui_manager_get_widget (_ui_manager, INTEGRATED_MENU); if (toolbar) *toolbar = create_integrated_ui_toolbar (); if (accel_group) *accel_group = gtk_ui_manager_get_accel_group (_ui_manager); }
int main(int argc,char **argv) { Vnkb *vnkb; VnkbDocklet *docklet = g_new0(VnkbDocklet,1); vnkb = g_new0(Vnkb,1); vnkb->panel = docklet; gtk_init(&argc,&argv); vnkb->update_charset = vnkb_docklet_update_charset; vnkb->update_method = vnkb_docklet_update_method; vnkb->update_enabled = vnkb_docklet_update_enabled; vnkb->update_spelling = vnkb_docklet_update_spelling; vnkb->driver_changed = vnkb_docklet_driver_changed; docklet->docklet = egg_tray_icon_new("Gaim"); docklet->actions = gtk_action_group_new("MenuActions"); gtk_action_group_set_translation_domain(docklet->actions,GETTEXT_PACKAGE); gtk_action_group_add_actions(docklet->actions,entries,G_N_ELEMENTS(entries),vnkb); gtk_action_group_add_radio_actions(docklet->actions,im_entries,G_N_ELEMENTS(im_entries),0,G_CALLBACK(im_change_cb),vnkb); gtk_action_group_add_radio_actions(docklet->actions,cs_entries,G_N_ELEMENTS(cs_entries),0,G_CALLBACK(cs_change_cb),vnkb); gtk_action_group_add_toggle_actions(docklet->actions,toggle_entries,G_N_ELEMENTS(toggle_entries),vnkb); docklet->uim = gtk_ui_manager_new(); gtk_ui_manager_insert_action_group(docklet->uim,docklet->actions,0); gtk_ui_manager_add_ui_from_string(docklet->uim,xml,-1,NULL); docklet->menu = gtk_ui_manager_get_widget(docklet->uim,"/MainMenu"); vnkb_init(vnkb,GTK_WIDGET(docklet->docklet)); g_signal_connect(G_OBJECT(vnkb->button), "button-press-event", G_CALLBACK(button_press_hack), vnkb); //signal_connect(G_OBJECT(vnkb->button),"popup-menu",G_CALLBACK(button_popup_cb),NULL); //g_signal_connect(G_OBJECT(docklet), "embedded", G_CALLBACK(docklet_x11_embedded_cb), NULL); //g_signal_connect(G_OBJECT(docklet), "destroy", G_CALLBACK(docklet_x11_destroyed_cb), NULL); //g_signal_connect(G_OBJECT(box), "button-press-event", G_CALLBACK(docklet_x11_clicked_cb), NULL); /* ref the docklet before we bandy it about the place */ g_object_ref(G_OBJECT(docklet->docklet)); gtk_main(); return 0; }
static GdkPixbuf* notification_trayicon_create(void) { GdkPixbuf *trayicon_nomail; GtkActionGroup *action_group; trayicon_nomail = notification_pixbuf_get(NOTIFICATION_TRAYICON_NOMAIL); notification_trayicon_destroy(); trayicon = gtk_status_icon_new_from_pixbuf(trayicon_nomail); g_signal_connect(G_OBJECT(trayicon), "activate", G_CALLBACK(notification_trayicon_on_activate), NULL); g_signal_connect(G_OBJECT(trayicon), "popup-menu", G_CALLBACK(notification_trayicon_on_popup_menu), NULL); g_signal_connect(G_OBJECT(trayicon), "size-changed", G_CALLBACK(notification_trayicon_on_size_changed), NULL); /* Popup-Menu */ action_group = cm_menu_create_action_group("SysTrayiconPopup", trayicon_popup_menu_entries, G_N_ELEMENTS(trayicon_popup_menu_entries), NULL); gtk_action_group_add_toggle_actions(action_group, trayicon_popup_toggle_menu_entries, G_N_ELEMENTS(trayicon_popup_toggle_menu_entries), NULL); MENUITEM_ADDUI("/Menus", "SysTrayiconPopup", "SysTrayiconPopup", GTK_UI_MANAGER_MENU) MENUITEM_ADDUI("/Menus/SysTrayiconPopup", "GetMail", "SysTrayiconPopup/GetMail", GTK_UI_MANAGER_MENUITEM) MENUITEM_ADDUI("/Menus/SysTrayiconPopup", "GetMailAcc", "SysTrayiconPopup/GetMailAcc", GTK_UI_MANAGER_MENU) MENUITEM_ADDUI("/Menus/SysTrayiconPopup", "Separator1", "SysTrayiconPopup/---", GTK_UI_MANAGER_SEPARATOR) MENUITEM_ADDUI("/Menus/SysTrayiconPopup", "Email", "SysTrayiconPopup/Email", GTK_UI_MANAGER_MENUITEM) MENUITEM_ADDUI("/Menus/SysTrayiconPopup", "EmailAcc", "SysTrayiconPopup/EmailAcc", GTK_UI_MANAGER_MENU) MENUITEM_ADDUI("/Menus/SysTrayiconPopup", "Separator2", "SysTrayiconPopup/---", GTK_UI_MANAGER_SEPARATOR) MENUITEM_ADDUI("/Menus/SysTrayiconPopup", "OpenAB", "SysTrayiconPopup/OpenAB", GTK_UI_MANAGER_MENUITEM) MENUITEM_ADDUI("/Menus/SysTrayiconPopup", "Separator3", "SysTrayiconPopup/---", GTK_UI_MANAGER_SEPARATOR) MENUITEM_ADDUI("/Menus/SysTrayiconPopup", "ToggleOffline", "SysTrayiconPopup/ToggleOffline", GTK_UI_MANAGER_MENUITEM) #ifdef HAVE_LIBNOTIFY MENUITEM_ADDUI("/Menus/SysTrayiconPopup", "ShowBubbles", "SysTrayiconPopup/ShowBubbles", GTK_UI_MANAGER_MENUITEM) #endif MENUITEM_ADDUI("/Menus/SysTrayiconPopup", "Separator4", "SysTrayiconPopup/---", GTK_UI_MANAGER_SEPARATOR) MENUITEM_ADDUI("/Menus/SysTrayiconPopup", "Exit", "SysTrayiconPopup/Exit", GTK_UI_MANAGER_MENUITEM) traymenu_popup = gtk_menu_item_get_submenu(GTK_MENU_ITEM( gtk_ui_manager_get_widget(gtkut_ui_manager(), "/Menus/SysTrayiconPopup"))); return trayicon_nomail; }
static VALUE rg_add_toggle_actions(VALUE self, VALUE rbentries) { GtkActionGroup *group = _SELF(self); VALUE toggle_action_procs = rb_ivar_defined(self, id_toggle_action_procs) == Qtrue ? rb_ivar_get(self, id_toggle_action_procs) : rb_hash_new(); long n; GtkToggleActionEntry *entries = RVAL2GTKTOGGLEACTIONENTRIES(rbentries, n, toggle_action_procs); rb_ivar_set(self, id_toggle_action_procs, toggle_action_procs); gtk_action_group_add_toggle_actions(group, entries, n, (gpointer)self); g_free(entries); return self; }
void lmplayer_setup_toolbar(LmplayerObject *lmplayer) { GtkActionGroup *actions; actions = gtk_action_group_new("ToolbarActions"); gtk_action_group_add_actions(actions, entries, n_entries, lmplayer); gtk_action_group_add_toggle_actions(actions, toggle_entries, n_toggle_entries, lmplayer); lmplayer->menus = gtk_ui_manager_new(); gtk_ui_manager_insert_action_group(lmplayer->menus, actions, 0); gtk_window_add_accel_group(GTK_WINDOW(lmplayer->win), gtk_ui_manager_get_accel_group(lmplayer->menus)); g_object_unref(actions); gtk_ui_manager_add_ui_from_string(lmplayer->menus, ui_info, -1, NULL); }
static int create_menu_bar( GtkBox *parent, GtkAccelGroup **accel_group ) { GError *error = NULL; GtkActionGroup *menu_action_group; GtkWidget *menu_bar; guint ui_menu_id; /* FIXME: we should unref this at some point */ ui_manager_debugger = gtk_ui_manager_new(); /* Load actions */ menu_action_group = gtk_action_group_new( "DebuggerActionGroup" ); gtk_action_group_add_actions( menu_action_group, menu_data, ARRAY_SIZE( menu_data ), NULL ); gtk_action_group_add_toggle_actions( menu_action_group, menu_toggles, ARRAY_SIZE( menu_toggles ), NULL ); gtk_ui_manager_insert_action_group( ui_manager_debugger, menu_action_group, 0 ); g_object_unref( menu_action_group ); /* Load the menu */ ui_menu_id = gtk_ui_manager_add_ui_from_string( ui_manager_debugger, debugger_menu, sizeof( debugger_menu ), &error ); if( error ) { g_error_free( error ); return 1; } else if( !ui_menu_id ) return 1; *accel_group = gtk_ui_manager_get_accel_group( ui_manager_debugger ); menu_bar = gtk_ui_manager_get_widget( ui_manager_debugger, "/DebuggerMenu" ); gtk_box_pack_start( parent, menu_bar, FALSE, FALSE, 0 ); return 0; }
void ppg_action_factory_create (PpgActionFactory *factory, GtkWidget *widget, GtkActionGroup *action_group) { GtkAction *action; g_return_if_fail(factory != NULL); g_return_if_fail(factory->action_type || factory->action_func || factory->action_entries || factory->toggle_action_entries); g_return_if_fail(GTK_IS_WIDGET(widget)); g_return_if_fail(GTK_IS_ACTION_GROUP(action_group)); if (factory->action_type) { action = g_object_new(factory->action_type, NULL); gtk_action_group_add_action(action_group, action); g_object_unref(action); } else if (factory->action_func) { action = factory->action_func(widget); gtk_action_group_add_action(action_group, action); g_object_unref(action); } else if (factory->action_entries) { gtk_action_group_add_actions(action_group, factory->action_entries, factory->action_n_entries, widget); } else if (factory->toggle_action_entries) { gtk_action_group_add_toggle_actions(action_group, factory->toggle_action_entries, factory->action_n_entries, widget); } else { g_assert_not_reached(); } }
static void workrave_applet_fill(WorkraveApplet *applet) { mate_panel_applet_set_flags(applet->applet, MATE_PANEL_APPLET_HAS_HANDLE); mate_panel_applet_set_background_widget(applet->applet, GTK_WIDGET(applet->applet)); applet->timerbox_control = g_object_new(WORKRAVE_TIMERBOX_CONTROL_TYPE, NULL); applet->image = workrave_timerbox_control_get_image(applet->timerbox_control); g_signal_connect(G_OBJECT(applet->timerbox_control), "menu-changed", G_CALLBACK(on_menu_changed), applet); g_signal_connect(G_OBJECT(applet->timerbox_control), "alive-changed", G_CALLBACK(on_alive_changed), applet); workrave_timerbox_control_set_tray_icon_visible_when_not_running(applet->timerbox_control, TRUE); workrave_timerbox_control_set_tray_icon_mode(applet->timerbox_control, WORKRAVE_TIMERBOX_CONTROL_TRAY_ICON_MODE_ALWAYS); applet->action_group = gtk_action_group_new("WorkraveAppletActions"); gtk_action_group_set_translation_domain(applet->action_group, GETTEXT_PACKAGE); gtk_action_group_add_actions(applet->action_group, menu_actions, G_N_ELEMENTS (menu_actions), applet); gtk_action_group_add_toggle_actions(applet->action_group, toggle_actions, G_N_ELEMENTS (toggle_actions), applet); gtk_action_group_add_radio_actions (applet->action_group, mode_actions, G_N_ELEMENTS(mode_actions), 0, G_CALLBACK(on_menu_radio_changed), applet); gchar *ui_path = g_build_filename(WORKRAVE_MENU_UI_DIR, "workrave-menu.xml", NULL); mate_panel_applet_setup_menu_from_file(applet->applet, ui_path, applet->action_group); g_free(ui_path); gtk_container_add(GTK_CONTAINER(applet->applet), GTK_WIDGET(applet->image)); gtk_widget_show_all(GTK_WIDGET(applet->applet)); }
static int python_menu_init(char **error) { MainWindow *mainwin; guint id; mainwin = mainwindow_get_mainwindow(); if(!mainwin) { *error = g_strdup("Could not get main window"); return 0; } gtk_action_group_add_toggle_actions(mainwin->action_group, mainwindow_tools_python_toggle, 1, mainwin); gtk_action_group_add_actions(mainwin->action_group, mainwindow_tools_python_actions, 3, mainwin); MENUITEM_ADDUI_ID_MANAGER(mainwin->ui_manager, "/Menu/Tools", "ShowPythonConsole", "Tools/ShowPythonConsole", GTK_UI_MANAGER_MENUITEM, id) menu_id_list = g_slist_prepend(menu_id_list, GUINT_TO_POINTER(id)); MENUITEM_ADDUI_ID_MANAGER(mainwin->ui_manager, "/Menu/Tools", "PythonScripts", "Tools/PythonScripts", GTK_UI_MANAGER_MENU, id) menu_id_list = g_slist_prepend(menu_id_list, GUINT_TO_POINTER(id)); MENUITEM_ADDUI_ID_MANAGER(mainwin->ui_manager, "/Menu/Tools/PythonScripts", "Refresh", "Tools/PythonScripts/Refresh", GTK_UI_MANAGER_MENUITEM, id) menu_id_list = g_slist_prepend(menu_id_list, GUINT_TO_POINTER(id)); MENUITEM_ADDUI_ID_MANAGER(mainwin->ui_manager, "/Menu/Tools/PythonScripts", "Browse", "Tools/PythonScripts/Browse", GTK_UI_MANAGER_MENUITEM, id) menu_id_list = g_slist_prepend(menu_id_list, GUINT_TO_POINTER(id)); MENUITEM_ADDUI_ID_MANAGER(mainwin->ui_manager, "/Menu/Tools/PythonScripts", "Separator1", "Tools/PythonScripts/---", GTK_UI_MANAGER_SEPARATOR, id) menu_id_list = g_slist_prepend(menu_id_list, GUINT_TO_POINTER(id)); refresh_python_scripts_menus(NULL, NULL); return !0; }
int clip_GTK_ACTIONGROUPADDTOGGLEACTIONS(ClipMachine * ClipMachineMemory) { C_object *cagroup = _fetch_co_arg(ClipMachineMemory); ClipArrVar *carr = (ClipArrVar *) _clip_vptr(_clip_spar(ClipMachineMemory, 2)); guint n_actions = _clip_parni(ClipMachineMemory, 3); C_var *c = NEW(C_var); CHECKARG2(1, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType); CHECKCOBJ(cagroup, GTK_IS_ACTION_GROUP(cagroup->object)); CHECKARG(2, ARRAY_type_of_ClipVarType); CHECKARG(3, NUMERIC_type_of_ClipVarType); if (carr) { GtkToggleActionEntry *acts; gint i; acts = malloc(carr->count_of_ClipArrVar * sizeof(GtkToggleActionEntry)); memset(acts, 0, sizeof(GtkToggleActionEntry) * carr->count_of_ClipArrVar); for (i = 0; i < n_actions; i++) _map_to_toggle_action_entry(ClipMachineMemory, &carr->ClipVar_items_of_ClipArrVar[i], &acts[i]); c->ClipMachineMemory = ClipMachineMemory; gtk_action_group_add_toggle_actions(GTK_ACTION_GROUP(cagroup->object), acts, n_actions, c); free(acts); } return 0; err: return 1; }
static GtkUIManager * ui_manager_new (GtkWidget *window) { static const GtkActionEntry actions[] = { { "back", GTK_STOCK_GO_BACK, NULL, "<alt>Left", N_("Go back one page"), G_CALLBACK (back_callback) }, { "forward", GTK_STOCK_GO_FORWARD, NULL, "<alt>Right", N_("Go forward one page"), G_CALLBACK (forward_callback) }, { "reload", GTK_STOCK_REFRESH, N_("_Reload"), "<control>R", N_("Reload current page"), G_CALLBACK (reload_callback) }, { "stop", GTK_STOCK_CANCEL, N_("_Stop"), "Escape", N_("Stop loading this page"), G_CALLBACK (stop_callback) }, { "home", GTK_STOCK_HOME, NULL, "<alt>Home", N_("Go to the index page"), G_CALLBACK (home_callback) }, { "copy-location", GTK_STOCK_COPY, N_("C_opy location"), "", N_("Copy the location of this page to the clipboard"), G_CALLBACK (copy_location_callback) }, { "copy-selection", GTK_STOCK_COPY, NULL, "<control>C", NULL, G_CALLBACK (copy_selection_callback) }, { "zoom-in", GTK_STOCK_ZOOM_IN, NULL, "<control>plus", NULL, G_CALLBACK (zoom_in_callback) }, { "zoom-out", GTK_STOCK_ZOOM_OUT, NULL, "<control>minus", NULL, G_CALLBACK (zoom_out_callback) }, { "find", GTK_STOCK_FIND, NULL, "<control>F", N_("Find text in current page"), G_CALLBACK (find_callback) }, { "find-again", NULL, N_("Find _Again"), "<control>G", NULL, G_CALLBACK (find_again_callback) }, { "close", GTK_STOCK_CLOSE, NULL, "<control>W", NULL, G_CALLBACK (close_callback) }, { "quit", GTK_STOCK_QUIT, NULL, "<control>Q", NULL, G_CALLBACK (close_callback) } }; static const GtkToggleActionEntry toggle_actions[] = { { "show-index", NULL, N_("S_how Index"), "<control>I", N_("Toggle the visibility of the sidebar"), G_CALLBACK (show_index_callback), FALSE } }; GtkUIManager *ui_manager = gtk_ui_manager_new (); GtkActionGroup *group = gtk_action_group_new ("Actions"); GtkAction *action; GError *error = NULL; gtk_action_group_set_translation_domain (group, NULL); gtk_action_group_add_actions (group, actions, G_N_ELEMENTS (actions), NULL); gtk_action_group_add_toggle_actions (group, toggle_actions, G_N_ELEMENTS (toggle_actions), NULL); action = gimp_throbber_action_new ("website", "docs.gimp.org", _("Visit the GIMP documentation website"), GIMP_STOCK_USER_MANUAL); g_signal_connect_closure (action, "activate", g_cclosure_new (G_CALLBACK (website_callback), NULL, NULL), FALSE); gtk_action_group_add_action (group, action); g_object_unref (action); gtk_window_add_accel_group (GTK_WINDOW (window), gtk_ui_manager_get_accel_group (ui_manager)); gtk_accel_group_lock (gtk_ui_manager_get_accel_group (ui_manager)); gtk_ui_manager_insert_action_group (ui_manager, group, -1); g_object_unref (group); gtk_ui_manager_add_ui_from_string (ui_manager, "<ui>" " <toolbar name=\"help-browser-toolbar\">" " <toolitem action=\"reload\" />" " <toolitem action=\"stop\" />" " <toolitem action=\"home\" />" " <separator name=\"space\" />" " <toolitem action=\"website\" />" " </toolbar>" " <accelerator action=\"close\" />" " <accelerator action=\"quit\" />" "</ui>", -1, &error); if (error) { g_warning ("error parsing ui: %s", error->message); g_clear_error (&error); } gtk_ui_manager_add_ui_from_string (ui_manager, "<ui>" " <popup name=\"help-browser-popup\">" " <menuitem action=\"back\" />" " <menuitem action=\"forward\" />" " <menuitem action=\"reload\" />" " <menuitem action=\"stop\" />" " <separator />" " <menuitem action=\"home\" />" " <menuitem action=\"copy-location\" />" " <menuitem action=\"show-index\" />" " <separator />" " <menuitem action=\"find\" />" " <menuitem action=\"find-again\" />" " <separator />" " <menuitem action=\"zoom-in\" />" " <menuitem action=\"zoom-out\" />" " <separator />" " <menuitem action=\"close\" />" " </popup>" "</ui>", -1, &error); if (error) { g_warning ("error parsing ui: %s", error->message); g_clear_error (&error); } gtk_ui_manager_add_ui_from_string (ui_manager, "<ui>" " <popup name=\"help-browser-copy-popup\">" " <menuitem action=\"copy-selection\" />" " </popup>" "</ui>", -1, &error); if (error) { g_warning ("error parsing ui: %s", error->message); g_clear_error (&error); } return ui_manager; }
void e_book_shell_view_actions_init (EBookShellView *book_shell_view) { EBookShellContent *book_shell_content; EShellView *shell_view; EShellWindow *shell_window; EShellSearchbar *searchbar; EPreviewPane *preview_pane; EWebView *web_view; GtkActionGroup *action_group; GConfBridge *bridge; GtkAction *action; GObject *object; const gchar *key; shell_view = E_SHELL_VIEW (book_shell_view); shell_window = e_shell_view_get_shell_window (shell_view); book_shell_content = book_shell_view->priv->book_shell_content; searchbar = e_book_shell_content_get_searchbar (book_shell_content); preview_pane = e_book_shell_content_get_preview_pane (book_shell_content); web_view = e_preview_pane_get_web_view (preview_pane); /* Contact Actions */ action_group = ACTION_GROUP (CONTACTS); gtk_action_group_add_actions ( action_group, contact_entries, G_N_ELEMENTS (contact_entries), book_shell_view); e_action_group_add_popup_actions ( action_group, contact_popup_entries, G_N_ELEMENTS (contact_popup_entries)); gtk_action_group_add_toggle_actions ( action_group, contact_toggle_entries, G_N_ELEMENTS (contact_toggle_entries), book_shell_view); gtk_action_group_add_radio_actions ( action_group, contact_view_entries, G_N_ELEMENTS (contact_view_entries), -1, G_CALLBACK (action_contact_view_cb), book_shell_view); gtk_action_group_add_radio_actions ( action_group, contact_search_entries, G_N_ELEMENTS (contact_search_entries), -1, NULL, NULL); /* Advanced Search Action */ action = ACTION (CONTACT_SEARCH_ADVANCED_HIDDEN); gtk_action_set_visible (action, FALSE); e_shell_searchbar_set_search_option ( searchbar, GTK_RADIO_ACTION (action)); /* Lockdown Printing Actions */ action_group = ACTION_GROUP (LOCKDOWN_PRINTING); gtk_action_group_add_actions ( action_group, lockdown_printing_entries, G_N_ELEMENTS (lockdown_printing_entries), book_shell_view); e_action_group_add_popup_actions ( action_group, lockdown_printing_popup_entries, G_N_ELEMENTS (lockdown_printing_popup_entries)); /* Lockdown Save-to-Disk Actions */ action_group = ACTION_GROUP (LOCKDOWN_SAVE_TO_DISK); gtk_action_group_add_actions ( action_group, lockdown_save_to_disk_entries, G_N_ELEMENTS (lockdown_save_to_disk_entries), book_shell_view); e_action_group_add_popup_actions ( action_group, lockdown_save_to_disk_popup_entries, G_N_ELEMENTS (lockdown_save_to_disk_popup_entries)); /* Bind GObject properties to GConf keys. */ bridge = gconf_bridge_get (); object = G_OBJECT (ACTION (CONTACT_PREVIEW)); key = "/apps/evolution/addressbook/display/show_preview"; gconf_bridge_bind_property (bridge, key, object, "active"); object = G_OBJECT (ACTION (CONTACT_VIEW_VERTICAL)); key = "/apps/evolution/addressbook/display/layout"; gconf_bridge_bind_property (bridge, key, object, "current-value"); object = G_OBJECT (ACTION (CONTACT_PREVIEW_SHOW_MAPS)); key = "/apps/evolution/addressbook/display/preview_show_maps"; gconf_bridge_bind_property (bridge, key, object, "active"); /* Fine tuning. */ g_signal_connect ( ACTION (GAL_SAVE_CUSTOM_VIEW), "activate", G_CALLBACK (action_gal_save_custom_view_cb), book_shell_view); g_object_bind_property ( ACTION (CONTACT_PREVIEW), "active", ACTION (CONTACT_VIEW_CLASSIC), "sensitive", G_BINDING_SYNC_CREATE); g_object_bind_property ( ACTION (CONTACT_PREVIEW), "active", ACTION (CONTACT_VIEW_VERTICAL), "sensitive", G_BINDING_SYNC_CREATE); g_object_bind_property ( ACTION (CONTACT_PREVIEW), "active", ACTION (CONTACT_PREVIEW_SHOW_MAPS), "sensitive", G_BINDING_SYNC_CREATE); e_web_view_set_open_proxy (web_view, ACTION (CONTACT_OPEN)); e_web_view_set_print_proxy (web_view, ACTION (CONTACT_PRINT)); e_web_view_set_save_as_proxy (web_view, ACTION (CONTACT_SAVE_AS)); #ifndef WITH_CONTACT_MAPS gtk_action_set_visible (ACTION (CONTACT_PREVIEW_SHOW_MAPS), FALSE); gtk_action_set_visible (ACTION (ADDRESS_BOOK_MAP), FALSE); gtk_action_set_visible (ACTION (ADDRESS_BOOK_POPUP_MAP), FALSE); #endif }
static void remmina_main_init(RemminaMain *remminamain) { RemminaMainPriv *priv; GtkWidget *vbox; GtkWidget *menubar; GtkWidget *hbox; GtkWidget *quickconnect; GtkWidget *tool_item; GtkUIManager *uimanager; GtkActionGroup *action_group; GtkWidget *scrolledwindow; GtkWidget *tree; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GError *error; priv = g_new0(RemminaMainPriv, 1); remminamain->priv = priv; remminamain->priv->expanded_group = remmina_string_array_new_from_string(remmina_pref.expanded_group); /* Create main window */ g_signal_connect(G_OBJECT(remminamain), "delete-event", G_CALLBACK(remmina_main_on_delete_event), NULL); g_signal_connect(G_OBJECT(remminamain), "destroy", G_CALLBACK(remmina_main_destroy), NULL); g_signal_connect(G_OBJECT(remminamain), "window-state-event", G_CALLBACK(remmina_main_on_window_state_event), NULL); gtk_container_set_border_width(GTK_CONTAINER(remminamain), 0); gtk_window_set_title(GTK_WINDOW(remminamain), _("Remmina Remote Desktop Client")); gtk_window_set_default_size(GTK_WINDOW(remminamain), remmina_pref.main_width, remmina_pref.main_height); gtk_window_set_position(GTK_WINDOW(remminamain), GTK_WIN_POS_CENTER); if (remmina_pref.main_maximize) { gtk_window_maximize(GTK_WINDOW(remminamain)); } /* Create the main container */ #if GTK_VERSION == 3 vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); #elif GTK_VERSION == 2 vbox = gtk_vbox_new(FALSE, 0); #endif gtk_container_add(GTK_CONTAINER(remminamain), vbox); gtk_widget_show(vbox); /* Create the menubar and toolbar */ uimanager = gtk_ui_manager_new(); priv->uimanager = uimanager; action_group = gtk_action_group_new("RemminaMainActions"); gtk_action_group_set_translation_domain(action_group, NULL); gtk_action_group_add_actions(action_group, remmina_main_ui_menu_entries, G_N_ELEMENTS(remmina_main_ui_menu_entries), remminamain); gtk_action_group_add_toggle_actions(action_group, remmina_main_ui_toggle_menu_entries, G_N_ELEMENTS(remmina_main_ui_toggle_menu_entries), remminamain); gtk_action_group_add_radio_actions(action_group, remmina_main_ui_view_file_mode_entries, G_N_ELEMENTS(remmina_main_ui_view_file_mode_entries), remmina_pref.view_file_mode, G_CALLBACK(remmina_main_action_view_file_mode), remminamain); gtk_ui_manager_insert_action_group(uimanager, action_group, 0); g_object_unref(action_group); priv->main_group = action_group; action_group = gtk_action_group_new("RemminaMainFileSensitiveActions"); gtk_action_group_set_translation_domain(action_group, NULL); gtk_action_group_add_actions(action_group, remmina_main_ui_file_sensitive_menu_entries, G_N_ELEMENTS(remmina_main_ui_file_sensitive_menu_entries), remminamain); gtk_ui_manager_insert_action_group(uimanager, action_group, 0); g_object_unref(action_group); priv->file_sensitive_group = action_group; error = NULL; gtk_ui_manager_add_ui_from_string(uimanager, remmina_main_ui_xml, -1, &error); if (error) { g_message("building menus failed: %s", error->message); g_error_free(error); } remmina_plugin_manager_for_each_plugin(REMMINA_PLUGIN_TYPE_TOOL, remmina_main_add_tool_plugin, remminamain); menubar = gtk_ui_manager_get_widget(uimanager, "/MenuBar"); gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0); priv->toolbar = gtk_ui_manager_get_widget(uimanager, "/ToolBar"); #if GTK_VERSION == 3 gtk_style_context_add_class(gtk_widget_get_style_context(priv->toolbar), GTK_STYLE_CLASS_PRIMARY_TOOLBAR); #endif gtk_box_pack_start(GTK_BOX(vbox), priv->toolbar, FALSE, FALSE, 0); tool_item = gtk_ui_manager_get_widget(uimanager, "/ToolBar/ConnectionConnect"); gtk_tool_item_set_is_important (GTK_TOOL_ITEM(tool_item), TRUE); tool_item = gtk_ui_manager_get_widget(uimanager, "/ToolBar/ConnectionNew"); gtk_tool_item_set_is_important (GTK_TOOL_ITEM(tool_item), TRUE); remmina_main_create_quick_search(remminamain); gtk_window_add_accel_group(GTK_WINDOW(remminamain), gtk_ui_manager_get_accel_group(uimanager)); gtk_action_group_set_sensitive(priv->file_sensitive_group, FALSE); /* Add a Fast Connection box */ #if GTK_VERSION == 3 hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); #elif GTK_VERSION == 2 hbox = gtk_hbox_new(FALSE, 0); #endif priv->quickconnect_protocol = gtk_combo_box_text_new(); #if GTK_VERSION == 3 gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "RDP", "RDP"); gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "VNC", "VNC"); gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "NX", "NX"); gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "SSH", "SSH"); #elif GTK_VERSION == 2 gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "RDP"); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "VNC"); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "NX"); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "SSH"); #endif gtk_combo_box_set_active(GTK_COMBO_BOX(priv->quickconnect_protocol), 0); gtk_widget_show(priv->quickconnect_protocol); gtk_box_pack_start(GTK_BOX(hbox), priv->quickconnect_protocol, FALSE, FALSE, 0); priv->quickconnect_server = gtk_entry_new(); gtk_entry_set_width_chars(GTK_ENTRY(priv->quickconnect_server), 25); gtk_widget_show(priv->quickconnect_server); gtk_box_pack_start(GTK_BOX(hbox), priv->quickconnect_server, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(priv->quickconnect_server), "key-press-event", G_CALLBACK(remmina_main_quickconnect_on_key_press), remminamain); quickconnect = gtk_button_new_with_label("Connect !"); gtk_widget_show(quickconnect); gtk_box_pack_start(GTK_BOX(hbox), quickconnect, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(quickconnect), "clicked", G_CALLBACK(remmina_main_quickconnect_on_click), remminamain); gtk_container_add(GTK_CONTAINER(vbox), hbox); gtk_widget_show(hbox); /* Create the scrolled window for the file list */ scrolledwindow = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwindow); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(GTK_BOX(vbox), scrolledwindow, TRUE, TRUE, 0); /* Create the remmina file list */ tree = gtk_tree_view_new(); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, _("Name")); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, NAME_COLUMN); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "icon-name", PROTOCOL_COLUMN); g_object_set(G_OBJECT(renderer), "stock-size", GTK_ICON_SIZE_LARGE_TOOLBAR, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "text", NAME_COLUMN); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Group"), renderer, "text", GROUP_COLUMN, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, GROUP_COLUMN); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); priv->group_column = column; renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Server"), renderer, "text", SERVER_COLUMN, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, SERVER_COLUMN); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); gtk_container_add(GTK_CONTAINER(scrolledwindow), tree); gtk_widget_show(tree); gtk_tree_selection_set_select_function(gtk_tree_view_get_selection(GTK_TREE_VIEW(tree)), remmina_main_selection_func, remminamain, NULL); g_signal_connect(G_OBJECT(tree), "button-press-event", G_CALLBACK(remmina_main_file_list_on_button_press), remminamain); g_signal_connect(G_OBJECT(tree), "key-press-event", G_CALLBACK(remmina_main_file_list_on_key_press), remminamain); priv->file_list = tree; /* Create statusbar */ priv->statusbar = gtk_statusbar_new(); gtk_box_pack_start(GTK_BOX(vbox), priv->statusbar, FALSE, FALSE, 0); gtk_widget_show(priv->statusbar); /* Prepare the data */ remmina_main_load_files(remminamain, FALSE); /* Load the preferences */ if (remmina_pref.hide_toolbar) { gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(gtk_action_group_get_action(priv->main_group, "ViewToolbar")), FALSE); } if (remmina_pref.hide_statusbar) { gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(gtk_action_group_get_action(priv->main_group, "ViewStatusbar")), FALSE); } if (remmina_pref.show_quick_search) { gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(gtk_action_group_get_action(priv->main_group, "ViewQuickSearch")), TRUE); } if (remmina_pref.small_toolbutton) { gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(gtk_action_group_get_action(priv->main_group, "ViewSmallToolbutton")), TRUE); } /* Drag-n-drop support */ gtk_drag_dest_set(GTK_WIDGET(remminamain), GTK_DEST_DEFAULT_ALL, remmina_drop_types, 1, GDK_ACTION_COPY); g_signal_connect(G_OBJECT(remminamain), "drag-data-received", G_CALLBACK(remmina_main_on_drag_data_received), NULL); priv->initialized = TRUE; remmina_widget_pool_register(GTK_WIDGET(remminamain)); }
static void impl_activate (GeditPlugin *plugin, GeditWindow *window) { GtkUIManager *manager; WindowData *data; ActionData *action_data; GList *docs, *l; gedit_debug (DEBUG_PLUGINS); data = g_slice_new (WindowData); action_data = g_slice_new (ActionData); action_data->plugin = plugin; action_data->window = window; manager = gedit_window_get_ui_manager (window); data->action_group = gtk_action_group_new ("GeditSpellPluginActions"); gtk_action_group_set_translation_domain (data->action_group, GETTEXT_PACKAGE); gtk_action_group_add_actions_full (data->action_group, action_entries, G_N_ELEMENTS (action_entries), action_data, (GDestroyNotify) free_action_data); gtk_action_group_add_toggle_actions (data->action_group, toggle_action_entries, G_N_ELEMENTS (toggle_action_entries), window); gtk_ui_manager_insert_action_group (manager, data->action_group, -1); data->ui_id = gtk_ui_manager_new_merge_id (manager); data->message_cid = gtk_statusbar_get_context_id (GTK_STATUSBAR (gedit_window_get_statusbar (window)), "spell_plugin_message"); g_object_set_data_full (G_OBJECT (window), WINDOW_DATA_KEY, data, (GDestroyNotify) free_window_data); gtk_ui_manager_add_ui (manager, data->ui_id, MENU_PATH, "CheckSpell", "CheckSpell", GTK_UI_MANAGER_MENUITEM, FALSE); gtk_ui_manager_add_ui (manager, data->ui_id, MENU_PATH, "AutoSpell", "AutoSpell", GTK_UI_MANAGER_MENUITEM, FALSE); gtk_ui_manager_add_ui (manager, data->ui_id, MENU_PATH, "ConfigSpell", "ConfigSpell", GTK_UI_MANAGER_MENUITEM, FALSE); update_ui_real (window, data); docs = gedit_window_get_documents (window); for (l = docs; l != NULL; l = g_list_next (l)) { set_auto_spell_from_metadata (window, GEDIT_DOCUMENT (l->data), data->action_group); } data->tab_added_id = g_signal_connect (window, "tab-added", G_CALLBACK (tab_added_cb), NULL); data->tab_removed_id = g_signal_connect (window, "tab-removed", G_CALLBACK (tab_removed_cb), NULL); }
/* Returns a menubar widget made from the above menu */ static GtkWidget *_get_menubar_menu(GtkWidget *window, GtkWidget *notebook) { GtkAccelGroup *accel_group = NULL; GError *error = NULL; char *ui_description; GtkActionEntry entries[] = { {"actions", NULL, "_Actions", "<alt>a"}, {"options", NULL, "_Options", "<alt>o"}, {"displays", NULL, "_Query", "<alt>q"}, {"batch_job", NULL, "Batch Job", "", "Submit batch job", G_CALLBACK(create_create_popup)}, {"partition", NULL, "Partition", "", "Create partition", G_CALLBACK(create_create_popup)}, {"reservation", NULL, "Reservation", "", "Create reservation", G_CALLBACK(create_create_popup)}, {"search", GTK_STOCK_FIND, "Search", ""}, {"jobid", NULL, "Job ID", "", "Search for jobid", G_CALLBACK(create_search_popup)}, {"user_jobs", NULL, "Specific User's Job(s)", "", "Search for a specific users job(s)", G_CALLBACK(create_search_popup)}, {"state_jobs", NULL, "Job(s) in a Specific State", "", "Search for job(s) in a specific state", G_CALLBACK(create_search_popup)}, {"partition_name", NULL, "Slurm Partition Name", "", "Search for a specific SLURM partition", G_CALLBACK(create_search_popup)}, {"partition_state", NULL, "Slurm Partition State", "", "Search for SLURM partitions in a given state", G_CALLBACK(create_search_popup)}, {"reservation_name", NULL, "Reservation Name", "", "Search for reservation", G_CALLBACK(create_search_popup)}, {"tab_pos", NULL, "_Tab Position"}, {"create", GTK_STOCK_ADD, "Create"}, {"interval", GTK_STOCK_REFRESH, "Set Refresh _Interval", "<control>i", "Change Refresh Interval", G_CALLBACK(change_refresh_popup)}, {"refresh", GTK_STOCK_REFRESH, "Refresh", "F5", "Refreshes page", G_CALLBACK(refresh_main)}, {"config", GTK_STOCK_INFO, "_Config Info", "<control>c", "Displays info from slurm.conf file", G_CALLBACK(create_config_popup)}, {"dbconfig", GTK_STOCK_INFO, "_Database Config Info", "<control>d", "Displays info relevant to the " "configuration of the Slurm Database.", G_CALLBACK(create_dbconfig_popup)}, {"exit", GTK_STOCK_QUIT, "E_xit", "<control>x", "Exits Program", G_CALLBACK(_delete)}, {"help", NULL, "_Help", "<alt>h"}, {"about", GTK_STOCK_ABOUT, "Ab_out", "<control>o", "About", G_CALLBACK(about_popup)}, {"usage", GTK_STOCK_HELP, "Usage", "", "Usage", G_CALLBACK(usage_popup)}, //{"manual", GTK_STOCK_HELP, "_Manual", "<control>m"}, {"grid_specs", GTK_STOCK_EDIT, "Set Grid _Properties", "<control>p", "Change Grid Properties", G_CALLBACK(change_grid_popup)}, {"defaults", GTK_STOCK_EDIT, "_Set Default Settings", "<control>s", "Change Default Settings", G_CALLBACK(configure_defaults)}, }; GtkActionEntry bg_entries[] = { {"bg_block_name", NULL, "BG Block Name", "", "Search for a specific BG Block", G_CALLBACK(create_search_popup)}, {"bg_block_size", NULL, "BG Block Size", "", "Search for BG Blocks having given size in cnodes", G_CALLBACK(create_search_popup)}, {"bg_block_state", NULL, "BG Block State", "", "Search for BG Blocks having given state", G_CALLBACK(create_search_popup)}, {"node_name_bg", NULL, "Midplane(s) Name", "", "Search for a specific Midplane(s)", G_CALLBACK(create_search_popup)}, {"node_state_bg", NULL, "Midplane State", "", "Search for a Midplane in a given state", G_CALLBACK(create_search_popup)}, }; GtkActionEntry nonbg_entries[] = { {"node_name", NULL, "Node(s) Name", "", "Search for a specific Node(s)", G_CALLBACK(create_search_popup)}, {"node_state", NULL, "Node State", "", "Search for a Node in a given state", G_CALLBACK(create_search_popup)}, }; GtkActionEntry admin_entries[] = { {"reconfig", GTK_STOCK_REDO, "SLUR_M Reconfigure", "<control>m", "Reconfigures System", G_CALLBACK(_reconfigure)}, {"debugflags", GTK_STOCK_DIALOG_WARNING, "Slurmctld DebugFlags", "", "Set slurmctld DebugFlags", G_CALLBACK(_get_current_debug_flags)}, {"debuglevel", GTK_STOCK_DIALOG_WARNING, "Slurmctld Debug Level", "", "Set slurmctld debug level", G_CALLBACK(_get_current_debug)}, }; GtkRadioActionEntry radio_entries[] = { {"tab_top", GTK_STOCK_GOTO_TOP, "_Top", "<control>T", "Move tabs to top", GTK_POS_TOP}, {"tab_bottom", GTK_STOCK_GOTO_BOTTOM, "_Bottom", "<control>B", "Move tabs to the bottom", GTK_POS_BOTTOM}, {"tab_left", GTK_STOCK_GOTO_FIRST, "_Left", "<control>L", "Move tabs to the Left", GTK_POS_LEFT}, {"tab_right", GTK_STOCK_GOTO_LAST, "_Right", "<control>R", "Move tabs to the Right", GTK_POS_RIGHT} }; GtkToggleActionEntry toggle_entries[] = { {"grid", GTK_STOCK_SELECT_COLOR, "Show _Grid", "<control>g", "Visual display of cluster", G_CALLBACK(_set_grid), working_sview_config.show_grid}, {"hidden", GTK_STOCK_SELECT_COLOR, "Show _Hidden", "<control>h", "Display Hidden Partitions/Jobs", G_CALLBACK(_set_hidden), working_sview_config.show_hidden}, {"page_opts", GTK_STOCK_SELECT_COLOR, "Save Page Options", "<control>w", "Save Page Options", G_CALLBACK(_set_page_opts), working_sview_config.save_page_opts}, #ifdef WANT_TOPO_ON_MAIN_OPTIONS {"topoorder", GTK_STOCK_SELECT_COLOR, "Set Topology Grid", "<control>t", "Set Topology Grid", G_CALLBACK(_set_topogrid), working_sview_config.grid_topological}, #endif {"ruled", GTK_STOCK_SELECT_COLOR, "R_uled Tables", "<control>u", "Have ruled tables or not", G_CALLBACK(_set_ruled), working_sview_config.ruled_treeview}, {"admin", GTK_STOCK_PREFERENCES, "_Admin Mode", "<control>a", "Allows user to change or update information", G_CALLBACK(_set_admin_mode), working_sview_config.admin_mode} }; GtkRadioActionEntry debug_entries[] = { {"debug_quiet", NULL, "quiet(0)", "", "Quiet level", 0}, {"debug_fatal", NULL, "fatal(1)", "", "Fatal level", 1}, {"debug_error", NULL, "error(2)", "", "Error level", 2}, {"debug_info", NULL, "info(3)", "", "Info level", 3}, {"debug_verbose", NULL, "verbose(4)", "", "Verbose level", 4}, {"debug_debug", NULL, "debug(5)", "", "Debug debug level", 5}, {"debug_debug2", NULL, "debug2(6)", "", "Debug2 level", 6}, {"debug_debug3", NULL, "debug3(7)", "", "Debug3 level", 7}, {"debug_debug4", NULL, "debug4(8)", "", "Debug4 level", 8}, {"debug_debug5", NULL, "debug5(9)", "", "Debug5 level", 9}, }; char *all_debug_flags = debug_flags2str(0xFFFFFFFFFFFFFFFF); char *last = NULL; char *tok = strtok_r(all_debug_flags, ",", &last); /* set up the global debug_actions */ debug_actions = xmalloc(sizeof(GtkToggleActionEntry)); while (tok) { xrealloc(debug_actions, (debug_action_entries + 1) * sizeof(GtkToggleActionEntry)); debug_actions[debug_action_entries].name = debug_actions[debug_action_entries].label = debug_actions[debug_action_entries].tooltip = xstrdup(tok); debug_actions[debug_action_entries].callback = G_CALLBACK(_set_flags); debug_action_entries++; tok = strtok_r(NULL, ",", &last); } xfree(all_debug_flags); /* Make an accelerator group (shortcut keys) */ menu_action_group = gtk_action_group_new ("MenuActions"); gtk_action_group_add_actions(menu_action_group, entries, G_N_ELEMENTS(entries), window); gtk_action_group_add_actions(menu_action_group, bg_entries, G_N_ELEMENTS(bg_entries), window); gtk_action_group_add_actions(menu_action_group, nonbg_entries, G_N_ELEMENTS(nonbg_entries), window); gtk_action_group_add_radio_actions(menu_action_group, radio_entries, G_N_ELEMENTS(radio_entries), working_sview_config.tab_pos, G_CALLBACK(_tab_pos), notebook); gtk_action_group_add_toggle_actions(menu_action_group, debug_actions, debug_action_entries, NULL); gtk_action_group_add_radio_actions(menu_action_group, debug_entries, G_N_ELEMENTS(debug_entries), -1, G_CALLBACK(_set_debug), notebook); gtk_action_group_add_toggle_actions(menu_action_group, toggle_entries, G_N_ELEMENTS(toggle_entries), NULL); admin_action_group = gtk_action_group_new ("MenuAdminActions"); gtk_action_group_add_actions(admin_action_group, admin_entries, G_N_ELEMENTS(admin_entries), window); gtk_action_group_set_sensitive(admin_action_group, working_sview_config.admin_mode); g_ui_manager = gtk_ui_manager_new(); gtk_ui_manager_insert_action_group(g_ui_manager, menu_action_group, 0); gtk_ui_manager_insert_action_group(g_ui_manager, admin_action_group, 1); accel_group = gtk_ui_manager_get_accel_group(g_ui_manager); gtk_window_add_accel_group(GTK_WINDOW(window), accel_group); ui_description = _get_ui_description(); if (!(g_menu_id = gtk_ui_manager_add_ui_from_string( g_ui_manager, ui_description, -1, &error))) { xfree(ui_description); g_error("building menus failed: %s", error->message); g_error_free (error); exit (0); } xfree(ui_description); /* GList *action_list = */ /* gtk_action_group_list_actions(menu_action_group); */ /* GtkAction *action = NULL; */ /* int i=0; */ /* while ((action = g_list_nth_data(action_list, i++))) { */ /* g_print("got %s and %x\n", gtk_action_get_name(action), */ /* action); */ /* } */ /* Get the pointers to the correct action so if we ever need to change it we can effect the action directly so everything stays in sync. */ default_sview_config.action_admin = (GtkToggleAction *)gtk_action_group_get_action( menu_action_group, "admin"); default_sview_config.action_grid = (GtkToggleAction *)gtk_action_group_get_action( menu_action_group, "grid"); default_sview_config.action_hidden = (GtkToggleAction *)gtk_action_group_get_action( menu_action_group, "hidden"); default_sview_config.action_page_opts = (GtkToggleAction *)gtk_action_group_get_action( menu_action_group, "page_opts"); // default_sview_config.action_gridtopo = // (GtkToggleAction *)gtk_action_group_get_action( // menu_action_group, "topoorder"); default_sview_config.action_ruled = (GtkToggleAction *)gtk_action_group_get_action( menu_action_group, "ruled"); /* Pick the first one of the Radio, it is how GTK references the group in the future. */ default_sview_config.action_tab = (GtkRadioAction *)gtk_action_group_get_action( menu_action_group, "tab_top"); /* g_print("action grid is %x\n", default_sview_config.action_grid); */ /* Finally, return the actual menu bar created by the item factory. */ return gtk_ui_manager_get_widget (g_ui_manager, "/main"); }
void e_task_shell_view_actions_init (ETaskShellView *task_shell_view) { ETaskShellContent *task_shell_content; EShellView *shell_view; EShellWindow *shell_window; EShellSearchbar *searchbar; EPreviewPane *preview_pane; EWebView *web_view; GtkActionGroup *action_group; GSettings *settings; GtkAction *action; shell_view = E_SHELL_VIEW (task_shell_view); shell_window = e_shell_view_get_shell_window (shell_view); task_shell_content = task_shell_view->priv->task_shell_content; searchbar = e_task_shell_content_get_searchbar (task_shell_content); preview_pane = e_task_shell_content_get_preview_pane (task_shell_content); web_view = e_preview_pane_get_web_view (preview_pane); /* Task Actions */ action_group = ACTION_GROUP (TASKS); gtk_action_group_add_actions ( action_group, task_entries, G_N_ELEMENTS (task_entries), task_shell_view); e_action_group_add_popup_actions ( action_group, task_popup_entries, G_N_ELEMENTS (task_popup_entries)); gtk_action_group_add_toggle_actions ( action_group, task_toggle_entries, G_N_ELEMENTS (task_toggle_entries), task_shell_view); gtk_action_group_add_radio_actions ( action_group, task_view_entries, G_N_ELEMENTS (task_view_entries), -1, G_CALLBACK (action_task_view_cb), task_shell_view); gtk_action_group_add_radio_actions ( action_group, task_search_entries, G_N_ELEMENTS (task_search_entries), -1, NULL, NULL); /* Advanced Search Action */ action = ACTION (TASK_SEARCH_ADVANCED_HIDDEN); gtk_action_set_visible (action, FALSE); e_shell_searchbar_set_search_option ( searchbar, GTK_RADIO_ACTION (action)); /* Lockdown Printing Actions */ action_group = ACTION_GROUP (LOCKDOWN_PRINTING); gtk_action_group_add_actions ( action_group, lockdown_printing_entries, G_N_ELEMENTS (lockdown_printing_entries), task_shell_view); e_action_group_add_popup_actions ( action_group, lockdown_printing_popup_entries, G_N_ELEMENTS (lockdown_printing_popup_entries)); /* Lockdown Save-to-Disk Actions */ action_group = ACTION_GROUP (LOCKDOWN_SAVE_TO_DISK); gtk_action_group_add_actions ( action_group, lockdown_save_to_disk_entries, G_N_ELEMENTS (lockdown_save_to_disk_entries), task_shell_view); e_action_group_add_popup_actions ( action_group, lockdown_save_to_disk_popup_entries, G_N_ELEMENTS (lockdown_save_to_disk_popup_entries)); /* Bind GObject properties to settings keys. */ settings = g_settings_new ("org.gnome.evolution.calendar"); g_settings_bind ( settings, "show-task-preview", ACTION (TASK_PREVIEW), "active", G_SETTINGS_BIND_DEFAULT); g_settings_bind ( settings, "task-layout", ACTION (TASK_VIEW_VERTICAL), "current-value", G_SETTINGS_BIND_DEFAULT); g_object_unref (settings); /* Fine tuning. */ g_object_bind_property ( ACTION (TASK_PREVIEW), "active", ACTION (TASK_VIEW_CLASSIC), "sensitive", G_BINDING_SYNC_CREATE); g_object_bind_property ( ACTION (TASK_PREVIEW), "active", ACTION (TASK_VIEW_VERTICAL), "sensitive", G_BINDING_SYNC_CREATE); e_web_view_set_open_proxy (web_view, ACTION (TASK_OPEN)); e_web_view_set_print_proxy (web_view, ACTION (TASK_PRINT)); e_web_view_set_save_as_proxy (web_view, ACTION (TASK_SAVE_AS)); }
void e_composer_actions_init (EMsgComposer *composer) { GtkActionGroup *action_group; GtkAccelGroup *accel_group; GtkUIManager *ui_manager; EHTMLEditor *editor; EContentEditor *cnt_editor; gboolean visible; GIcon *gcr_gnupg_icon; g_return_if_fail (E_IS_MSG_COMPOSER (composer)); editor = e_msg_composer_get_editor (composer); cnt_editor = e_html_editor_get_content_editor (editor); ui_manager = e_html_editor_get_ui_manager (editor); /* Composer Actions */ action_group = composer->priv->composer_actions; gtk_action_group_set_translation_domain ( action_group, GETTEXT_PACKAGE); gtk_action_group_add_actions ( action_group, entries, G_N_ELEMENTS (entries), composer); gtk_action_group_add_toggle_actions ( action_group, toggle_entries, G_N_ELEMENTS (toggle_entries), composer); gtk_ui_manager_insert_action_group (ui_manager, action_group, 0); /* Asynchronous Actions */ action_group = composer->priv->async_actions; gtk_action_group_set_translation_domain ( action_group, GETTEXT_PACKAGE); gtk_action_group_add_actions ( action_group, async_entries, G_N_ELEMENTS (async_entries), composer); gtk_ui_manager_insert_action_group (ui_manager, action_group, 0); /* Character Set Actions */ action_group = composer->priv->charset_actions; gtk_action_group_set_translation_domain ( action_group, GETTEXT_PACKAGE); e_charset_add_radio_actions ( action_group, "charset-", composer->priv->charset, G_CALLBACK (action_charset_cb), composer); gtk_ui_manager_insert_action_group (ui_manager, action_group, 0); /* Fine Tuning */ g_object_set ( ACTION (ATTACH), "short-label", _("Attach"), NULL); g_object_set ( ACTION (PICTURE_GALLERY), "is-important", TRUE, NULL); g_object_set ( ACTION (SAVE_DRAFT), "short-label", _("Save Draft"), NULL); #define init_toolbar_option(x, always_visible) \ gtk_action_set_visible (ACTION (TOOLBAR_ ## x), always_visible); \ e_binding_bind_property ( \ ACTION (x), "active", \ ACTION (TOOLBAR_ ## x), "active", \ G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL); \ e_binding_bind_property ( \ ACTION (x), "label", \ ACTION (TOOLBAR_ ## x), "label", \ G_BINDING_SYNC_CREATE); \ e_binding_bind_property ( \ ACTION (x), "tooltip", \ ACTION (TOOLBAR_ ## x), "tooltip", \ G_BINDING_SYNC_CREATE); \ e_binding_bind_property ( \ ACTION (x), "sensitive", \ ACTION (TOOLBAR_ ## x), "sensitive", \ G_BINDING_SYNC_CREATE); \ g_signal_connect (ACTION (TOOLBAR_ ## x), "toggled", \ G_CALLBACK (composer_actions_toolbar_option_toggled_cb), composer); init_toolbar_option (PGP_SIGN, FALSE); init_toolbar_option (PGP_ENCRYPT, FALSE); init_toolbar_option (PRIORITIZE_MESSAGE, TRUE); init_toolbar_option (REQUEST_READ_RECEIPT, TRUE); init_toolbar_option (SMIME_SIGN, FALSE); init_toolbar_option (SMIME_ENCRYPT, FALSE); #undef init_toolbar_option /* Borrow a GnuPG icon from gcr to distinguish between GPG and S/MIME Sign/Encrypt actions */ gcr_gnupg_icon = g_themed_icon_new ("gcr-gnupg"); if (gcr_gnupg_icon) { GIcon *temp_icon; GIcon *action_icon; GEmblem *emblem; GtkAction *action; emblem = g_emblem_new (gcr_gnupg_icon); action = ACTION (TOOLBAR_PGP_SIGN); action_icon = g_themed_icon_new (gtk_action_get_icon_name (action)); temp_icon = g_emblemed_icon_new (action_icon, emblem); g_object_unref (action_icon); gtk_action_set_gicon (action, temp_icon); g_object_unref (temp_icon); action = ACTION (TOOLBAR_PGP_ENCRYPT); action_icon = g_themed_icon_new (gtk_action_get_icon_name (action)); temp_icon = g_emblemed_icon_new (action_icon, emblem); g_object_unref (action_icon); gtk_action_set_gicon (action, temp_icon); g_object_unref (temp_icon); g_object_unref (emblem); g_object_unref (gcr_gnupg_icon); } e_binding_bind_property ( cnt_editor, "html-mode", ACTION (PICTURE_GALLERY), "sensitive", G_BINDING_SYNC_CREATE); e_binding_bind_property ( cnt_editor, "editable", e_html_editor_get_action (editor, "edit-menu"), "sensitive", G_BINDING_SYNC_CREATE); e_binding_bind_property ( cnt_editor, "editable", e_html_editor_get_action (editor, "format-menu"), "sensitive", G_BINDING_SYNC_CREATE); e_binding_bind_property ( cnt_editor, "editable", e_html_editor_get_action (editor, "insert-menu"), "sensitive", G_BINDING_SYNC_CREATE); e_binding_bind_property ( cnt_editor, "editable", e_html_editor_get_action (editor, "options-menu"), "sensitive", G_BINDING_SYNC_CREATE); e_binding_bind_property ( cnt_editor, "editable", e_html_editor_get_action (editor, "picture-gallery"), "sensitive", G_BINDING_SYNC_CREATE); #if defined (ENABLE_SMIME) visible = TRUE; #else visible = FALSE; #endif gtk_action_set_visible (ACTION (SMIME_ENCRYPT), visible); gtk_action_set_visible (ACTION (SMIME_SIGN), visible); accel_group = gtk_ui_manager_get_accel_group (ui_manager); g_signal_connect (accel_group, "accel-activate", G_CALLBACK (composer_actions_accel_activate_cb), composer); }