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; }
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 VALUE actiongroup_add_radio_actions(int argc, VALUE *argv, VALUE self) { VALUE entries, value, proc; guint i; guint n_entries; GtkRadioActionEntry* gentries; rb_scan_args(argc, argv, "12", &entries, &value, &proc); if (NIL_P(value)) value = -1; if (NIL_P(proc) && rb_block_given_p()){ proc = rb_block_proc(); G_RELATIVE(self, proc); } n_entries = (guint)RARRAY_LEN(entries); gentries = g_new0(GtkRadioActionEntry, n_entries); 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]); 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; gentries[i].value = NUM2INT(RARRAY_PTR(entry)[5]); } gtk_action_group_add_radio_actions(_SELF(self), gentries, n_entries, NUM2INT(value), G_CALLBACK(activate_radio_action), (gpointer)proc); g_free(gentries); return self; }
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; }
static void gnc_plugin_page_invoice_init (GncPluginPageInvoice *plugin_page) { GncPluginPage *parent; GtkActionGroup *action_group; gboolean use_new; /* Init parent declared variables */ parent = GNC_PLUGIN_PAGE(plugin_page); use_new = gnc_prefs_get_bool (GNC_PREFS_GROUP_INVOICE, GNC_PREF_USE_NEW); g_object_set(G_OBJECT(plugin_page), "page-name", _("Invoice"), "page-uri", "default:", "ui-description", "gnc-plugin-page-invoice-ui.xml", "use-new-window", use_new, (char *)NULL); /* change me when the system supports multiple books */ gnc_plugin_page_add_book(parent, gnc_get_current_book()); /* Create menu and toolbar information */ action_group = gnc_plugin_page_create_action_group(parent, "GncPluginPageInvoiceActions"); gtk_action_group_add_actions (action_group, gnc_plugin_page_invoice_actions, gnc_plugin_page_invoice_n_actions, plugin_page); gtk_action_group_add_radio_actions (action_group, radio_entries, n_radio_entries, REG_STYLE_LEDGER, G_CALLBACK(gnc_plugin_page_invoice_cmd_sort_changed), plugin_page); gnc_plugin_init_short_names (action_group, toolbar_labels); }
static VALUE rg_add_radio_actions(int argc, VALUE *argv, VALUE self) { GtkActionGroup *group = _SELF(self); VALUE rbentries, rbvalue, proc; long n; GtkRadioActionEntry *entries; gint value; rb_scan_args(argc, argv, "12", &rbentries, &rbvalue, &proc); value = NIL_P(rbvalue) ? -1 : NUM2INT(rbvalue); if (NIL_P(proc) && rb_block_given_p()) { proc = rb_block_proc(); /* TODO: How do we remove this proc when all the radio actions passed * have been removed? */ G_RELATIVE(self, proc); } entries = RVAL2GTKRADIOACTIONENTRIES(rbentries, n); gtk_action_group_add_radio_actions(group, entries, n, value, G_CALLBACK(activate_radio_action), (gpointer)proc); g_free(entries); return self; }
int clip_GTK_ACTIONGROUPADDRADIOACTIONS(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); gint value = _clip_parni(ClipMachineMemory, 4); ClipVar *cfunc = _clip_spar(ClipMachineMemory, 5); 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); CHECKARG(4, NUMERIC_type_of_ClipVarType); CHECKARG2(5, PCODE_type_of_ClipVarType, CCODE_type_of_ClipVarType); if (carr) { GtkRadioActionEntry *acts; gint i; acts = malloc(carr->count_of_ClipArrVar * sizeof(GtkRadioActionEntry)); memset(acts, 0, sizeof(GtkRadioActionEntry) * carr->count_of_ClipArrVar); for (i = 0; i < n_actions; i++) _map_to_radio_action_entry(ClipMachineMemory, &carr->ClipVar_items_of_ClipArrVar[i], &acts[i]); c->ClipMachineMemory = ClipMachineMemory; c->co = cagroup; _clip_mclone(ClipMachineMemory, &c->cfunc, cfunc); gtk_action_group_add_radio_actions(GTK_ACTION_GROUP(cagroup->object), acts, n_actions, value, (GCallback) call_b, c); free(acts); } return 0; err: return 1; }
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)); }
int vwin_menu_add_radios (windata_t *vwin, const gchar *path, GtkRadioActionEntry *entries, int n, int deflt, GCallback callback) { guint id = gtk_ui_manager_new_merge_id(vwin->ui); GtkActionGroup *actions; int i; actions = gtk_action_group_new("Radios"); gtk_action_group_set_translation_domain(actions, "gretl"); gtk_action_group_add_radio_actions(actions, entries, n, deflt, callback, vwin); for (i=0; i<n; i++) { gtk_ui_manager_add_ui(vwin->ui, id, path, entries[i].name, entries[i].name, GTK_UI_MANAGER_MENUITEM, FALSE); } gtk_ui_manager_insert_action_group(vwin->ui, actions, 0); g_object_unref(actions); return id; }
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)); }
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 build_ui (EmerillonWindow *self) { GtkAction *action; GtkWidget *vbox; GtkWidget *menubar; GtkToolItem *throbber; GtkWidget *viewport; GtkWidget *hpaned; GtkWidget *embed_view; ClutterActor *scale; GError *error = NULL; /* Action entries. */ self->priv->main_actions = gtk_action_group_new ("MenuActionsWindow"); gtk_action_group_set_translation_domain (self->priv->main_actions, GETTEXT_PACKAGE); gtk_action_group_add_actions (self->priv->main_actions, action_entries, G_N_ELEMENTS (action_entries), self); /* Toggle entries. */ gtk_action_group_add_toggle_actions (self->priv->main_actions, toggle_entries, G_N_ELEMENTS (toggle_entries), self); /* Radio entries. */ gtk_action_group_add_radio_actions (self->priv->main_actions, radio_entries, G_N_ELEMENTS (radio_entries), 0, G_CALLBACK (cmd_map_change_map), self); /* Short labels. */ action = gtk_action_group_get_action (self->priv->main_actions, "ViewZoomIn"); g_object_set (action, "short_label", _("In"), NULL); action = gtk_action_group_get_action (self->priv->main_actions, "ViewZoomOut"); g_object_set (action, "short_label", _("Out"), NULL); /* UI manager. */ self->priv->ui_manager = gtk_ui_manager_new (); gtk_ui_manager_insert_action_group (self->priv->ui_manager, self->priv->main_actions, 0); if (!gtk_ui_manager_add_ui_from_file (self->priv->ui_manager, EMERILLON_DATADIR "/emerillon-ui.xml", &error)) { g_warning ("building menus failed: %s", error->message); g_error_free (error); return; } g_signal_connect (self->priv->ui_manager, "connect_proxy", G_CALLBACK (connect_proxy_cb), self); g_signal_connect (self->priv->ui_manager, "disconnect_proxy", G_CALLBACK (disconnect_proxy_cb), self); gtk_window_add_accel_group (GTK_WINDOW (self), gtk_ui_manager_get_accel_group (self->priv->ui_manager)); /* Main box. */ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_add (GTK_CONTAINER (self), vbox); gtk_widget_show (vbox); /* Menu. */ menubar = gtk_ui_manager_get_widget (self->priv->ui_manager, "/MainMenu"); g_assert (GTK_IS_WIDGET (menubar)); gtk_box_pack_start (GTK_BOX (vbox), menubar, FALSE, FALSE, 0); gtk_widget_show (menubar); /* Toolbar. */ self->priv->toolbar = gtk_ui_manager_get_widget (self->priv->ui_manager, "/Toolbar"); gtk_style_context_add_class (gtk_widget_get_style_context (self->priv->toolbar), "primary-toolbar"); self->priv->throbber = gtk_spinner_new (); throbber = gtk_tool_item_new (); gtk_container_add (GTK_CONTAINER (throbber), self->priv->throbber); gtk_widget_show (GTK_WIDGET (self->priv->throbber)); gtk_widget_show (GTK_WIDGET (throbber)); gtk_toolbar_insert (GTK_TOOLBAR (self->priv->toolbar), throbber, -1); gtk_box_pack_start (GTK_BOX (vbox), self->priv->toolbar, FALSE, FALSE, 0); gtk_widget_show (self->priv->toolbar); /* Statusbar. */ self->priv->statusbar = gtk_statusbar_new (); gtk_box_pack_end (GTK_BOX (vbox), GTK_WIDGET (self->priv->statusbar), FALSE, FALSE, 0); gtk_widget_show (self->priv->statusbar); self->priv->tooltip_message_context_id = gtk_statusbar_get_context_id ( GTK_STATUSBAR (self->priv->statusbar), "tooltip-message"); /* Viewport. */ viewport = gtk_frame_new (NULL); /* Map. */ embed_view = gtk_champlain_embed_new (); gtk_container_add (GTK_CONTAINER (viewport), embed_view); /* FIXME: workaround for a champlain-gtk bug, replace with _show(). */ gtk_widget_show_all (embed_view); self->priv->view = gtk_champlain_embed_get_view (GTK_CHAMPLAIN_EMBED (embed_view)); g_signal_connect (self->priv->view, "notify::zoom-level", G_CALLBACK (zoom_changed_cb), self); g_signal_connect (self->priv->view, "notify::map-source", G_CALLBACK (zoom_changed_cb), self); g_signal_connect (self->priv->view, "notify::state", G_CALLBACK (state_changed_cb), self); g_object_set (self->priv->view, "zoom-level", 1, "kinetic-mode", TRUE, NULL); champlain_view_center_on (self->priv->view, 40, 0); scale = champlain_scale_new (); champlain_scale_connect_view (CHAMPLAIN_SCALE (scale), self->priv->view); /* align to the bottom left */ champlain_view_bin_layout_add (self->priv->view, scale, CLUTTER_BIN_ALIGNMENT_START, CLUTTER_BIN_ALIGNMENT_END); /* Sidebar. */ self->priv->sidebar = emerillon_sidebar_new (); gtk_widget_set_size_request (self->priv->sidebar, 200, -1); /* Horizontal pane. */ hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL); gtk_paned_pack1 (GTK_PANED (hpaned), self->priv->sidebar, FALSE, FALSE); gtk_paned_pack2 (GTK_PANED (hpaned), viewport, TRUE, FALSE); gtk_widget_show (self->priv->sidebar); gtk_widget_show (viewport); g_signal_connect_after (self->priv->sidebar, "show", G_CALLBACK (sidebar_visibility_changed_cb), self); g_signal_connect_after (self->priv->sidebar, "hide", G_CALLBACK (sidebar_visibility_changed_cb), self); gtk_box_pack_start (GTK_BOX (vbox), hpaned, TRUE, TRUE, 0); gtk_widget_show (hpaned); update_ui_visibility (self); }
static void rb_static_playlist_source_constructed (GObject *object) { RBStaticPlaylistSource *source; RBStaticPlaylistSourcePrivate *priv; RBPlaylistSource *psource; RBEntryView *songs; RBShell *shell; RhythmDBEntryType *entry_type; RB_CHAIN_GOBJECT_METHOD (rb_static_playlist_source_parent_class, constructed, object); source = RB_STATIC_PLAYLIST_SOURCE (object); priv = RB_STATIC_PLAYLIST_SOURCE_GET_PRIVATE (source); psource = RB_PLAYLIST_SOURCE (source); priv->base_model = rb_playlist_source_get_query_model (RB_PLAYLIST_SOURCE (psource)); g_object_set (priv->base_model, "show-hidden", TRUE, NULL); g_object_ref (priv->base_model); g_signal_connect_object (priv->base_model, "filter-entry-drop", G_CALLBACK (rb_static_playlist_source_filter_entry_drop), source, 0); priv->paned = gtk_vpaned_new (); g_object_get (source, "shell", &shell, NULL); priv->action_group = _rb_display_page_register_action_group (RB_DISPLAY_PAGE (source), "StaticPlaylistActions", NULL, 0, shell); if (gtk_action_group_get_action (priv->action_group, rb_static_playlist_source_radio_actions[0].name) == NULL) { gtk_action_group_add_radio_actions (priv->action_group, rb_static_playlist_source_radio_actions, G_N_ELEMENTS (rb_static_playlist_source_radio_actions), 0, NULL, NULL); rb_source_search_basic_create_for_actions (priv->action_group, rb_static_playlist_source_radio_actions, G_N_ELEMENTS (rb_static_playlist_source_radio_actions)); } priv->default_search = rb_source_search_basic_new (RHYTHMDB_PROP_SEARCH_MATCH); g_object_unref (shell); g_object_get (source, "entry-type", &entry_type, NULL); priv->browser = rb_library_browser_new (rb_playlist_source_get_db (RB_PLAYLIST_SOURCE (source)), entry_type); if (entry_type != NULL) { g_object_unref (entry_type); } gtk_paned_pack1 (GTK_PANED (priv->paned), GTK_WIDGET (priv->browser), TRUE, FALSE); g_signal_connect_object (priv->browser, "notify::output-model", G_CALLBACK (rb_static_playlist_source_browser_changed_cb), source, 0); rb_library_browser_set_model (priv->browser, priv->base_model, FALSE); rb_static_playlist_source_do_query (source); /* reparent the entry view */ songs = rb_source_get_entry_view (RB_SOURCE (source)); g_object_ref (songs); gtk_container_remove (GTK_CONTAINER (source), GTK_WIDGET (songs)); gtk_paned_pack2 (GTK_PANED (priv->paned), GTK_WIDGET (songs), TRUE, FALSE); gtk_container_add (GTK_CONTAINER (source), priv->paned); rb_source_bind_settings (RB_SOURCE (source), GTK_WIDGET (songs), priv->paned, GTK_WIDGET (priv->browser)); g_object_unref (songs); /* watch these to find out when things are dropped into the entry view */ g_signal_connect_object (priv->base_model, "row-inserted", G_CALLBACK (rb_static_playlist_source_row_inserted), source, 0); g_signal_connect_object (priv->base_model, "non-entry-dropped", G_CALLBACK (rb_static_playlist_source_non_entry_dropped), source, 0); g_signal_connect_object (priv->base_model, "rows-reordered", G_CALLBACK (rb_static_playlist_source_rows_reordered), source, 0); gtk_widget_show_all (GTK_WIDGET (source)); }
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; }
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)); }
/** * 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 fm_main_win_init(FmMainWin *self) { GtkWidget *vbox, *menubar, *toolitem, *next_btn, *scroll; GtkUIManager* ui; GtkActionGroup* act_grp; GtkAction* act; GtkAccelGroup* accel_grp; ++n_wins; vbox = gtk_vbox_new(FALSE, 0); self->hpaned = gtk_hpaned_new(); gtk_paned_set_position(GTK_PANED(self->hpaned), 150); /* places left pane */ self->places_view = fm_places_view_new(); scroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(scroll), self->places_view); gtk_paned_add1(GTK_PANED(self->hpaned), scroll); /* folder view */ self->folder_view = fm_folder_view_new( FM_FV_ICON_VIEW ); fm_folder_view_set_show_hidden(FM_FOLDER_VIEW(self->folder_view), FALSE); fm_folder_view_sort(FM_FOLDER_VIEW(self->folder_view), GTK_SORT_DESCENDING, COL_FILE_NAME); fm_folder_view_set_selection_mode(FM_FOLDER_VIEW(self->folder_view), GTK_SELECTION_MULTIPLE); g_signal_connect(self->folder_view, "clicked", on_file_clicked, self); g_signal_connect(self->folder_view, "status", on_status, self); g_signal_connect(self->folder_view, "sel-changed", on_sel_changed, self); gtk_paned_add2(GTK_PANED(self->hpaned), self->folder_view); /* link places view with folder view. */ g_signal_connect_swapped(self->places_view, "chdir", G_CALLBACK(fm_main_win_chdir), self); /* create menu bar and toolbar */ ui = gtk_ui_manager_new(); act_grp = gtk_action_group_new("Main"); gtk_action_group_add_actions(act_grp, main_win_actions, G_N_ELEMENTS(main_win_actions), self); gtk_action_group_add_toggle_actions(act_grp, main_win_toggle_actions, G_N_ELEMENTS(main_win_toggle_actions), self); gtk_action_group_add_radio_actions(act_grp, main_win_mode_actions, G_N_ELEMENTS(main_win_mode_actions), FM_FV_ICON_VIEW, on_change_mode, self); gtk_action_group_add_radio_actions(act_grp, main_win_sort_type_actions, G_N_ELEMENTS(main_win_sort_type_actions), GTK_SORT_ASCENDING, on_sort_type, self); gtk_action_group_add_radio_actions(act_grp, main_win_sort_by_actions, G_N_ELEMENTS(main_win_sort_by_actions), 0, on_sort_by, self); accel_grp = gtk_ui_manager_get_accel_group(ui); gtk_window_add_accel_group(GTK_WINDOW(self), accel_grp); gtk_ui_manager_insert_action_group(ui, act_grp, 0); gtk_ui_manager_add_ui_from_string(ui, main_menu_xml, -1, NULL); menubar = gtk_ui_manager_get_widget(ui, "/menubar"); self->toolbar = gtk_ui_manager_get_widget(ui, "/toolbar"); /* FIXME: should make these optional */ gtk_toolbar_set_icon_size(GTK_TOOLBAR(self->toolbar), GTK_ICON_SIZE_SMALL_TOOLBAR); gtk_toolbar_set_style(GTK_TOOLBAR(self->toolbar), GTK_TOOLBAR_ICONS); /* create 'Next' button manually and add a popup menu to it */ toolitem = g_object_new(GTK_TYPE_MENU_TOOL_BUTTON, NULL); gtk_toolbar_insert(GTK_TOOLBAR(self->toolbar), toolitem, 2); gtk_widget_show(GTK_WIDGET(toolitem)); act = gtk_ui_manager_get_action(ui, "/menubar/GoMenu/Next"); gtk_activatable_set_related_action(GTK_ACTIVATABLE(toolitem), act); /* set up history menu */ self->nav_history = fm_nav_history_new(); self->history_menu = gtk_menu_new(); gtk_menu_tool_button_set_menu(GTK_MENU_TOOL_BUTTON(toolitem), self->history_menu); g_signal_connect(toolitem, "show-menu", G_CALLBACK(on_show_history_menu), self); self->popup = gtk_ui_manager_get_widget(ui, "/popup"); gtk_box_pack_start( (GtkBox*)vbox, menubar, FALSE, TRUE, 0 ); gtk_box_pack_start( (GtkBox*)vbox, self->toolbar, FALSE, TRUE, 0 ); /* load bookmarks menu */ load_bookmarks(self, ui); /* the location bar */ self->location = fm_path_entry_new(); g_signal_connect(self->location, "activate", on_entry_activate, self); g_signal_connect(self->folder_view, "loaded", G_CALLBACK(on_view_loaded), (gpointer) self); toolitem = gtk_tool_item_new(); gtk_container_add( GTK_CONTAINER(toolitem), self->location ); gtk_tool_item_set_expand(GTK_TOOL_ITEM(toolitem), TRUE); gtk_toolbar_insert((GtkToolbar*)self->toolbar, toolitem, gtk_toolbar_get_n_items(GTK_TOOLBAR(self->toolbar)) - 1 ); gtk_box_pack_start( (GtkBox*)vbox, self->hpaned, TRUE, TRUE, 0 ); /* status bar */ self->statusbar = gtk_statusbar_new(); gtk_box_pack_start( (GtkBox*)vbox, self->statusbar, FALSE, TRUE, 0 ); self->statusbar_ctx = gtk_statusbar_get_context_id(GTK_STATUSBAR(self->statusbar), "status"); self->statusbar_ctx2 = gtk_statusbar_get_context_id(GTK_STATUSBAR(self->statusbar), "status2"); g_object_unref(act_grp); self->ui = ui; gtk_container_add( (GtkContainer*)self, vbox ); gtk_widget_show_all(vbox); fm_folder_view_set_show_hidden(FM_FOLDER_VIEW(self->folder_view), FALSE); fm_main_win_chdir(self, fm_path_get_home()); gtk_widget_grab_focus(self->folder_view); }
void create_main_window (ProcData *procdata) { gint width, height; GtkWidget *app; GtkAction *action; GtkWidget *menubar; GtkWidget *main_box; GtkWidget *notebook; GtkWidget *tab_label1, *tab_label2, *tab_label3; GtkWidget *vbox1; GtkWidget *sys_box, *devices_box; GtkWidget *sysinfo_box, *sysinfo_label; app = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(app), _("System Monitor")); GdkScreen* screen = gtk_widget_get_screen(app); GdkColormap* colormap = gdk_screen_get_rgba_colormap(screen); /* use rgba colormap, if available */ if (colormap) gtk_widget_set_default_colormap(colormap); main_box = gtk_vbox_new (FALSE, 0); gtk_container_add(GTK_CONTAINER(app), main_box); width = procdata->config.width; height = procdata->config.height; gtk_window_set_default_size (GTK_WINDOW (app), width, height); gtk_window_set_resizable (GTK_WINDOW (app), TRUE); /* create the menubar */ procdata->uimanager = gtk_ui_manager_new (); /* show tooltips in the statusbar */ g_signal_connect (procdata->uimanager, "connect_proxy", G_CALLBACK (connect_proxy_cb), procdata); g_signal_connect (procdata->uimanager, "disconnect_proxy", G_CALLBACK (disconnect_proxy_cb), procdata); gtk_window_add_accel_group (GTK_WINDOW (app), gtk_ui_manager_get_accel_group (procdata->uimanager)); if (!gtk_ui_manager_add_ui_from_string (procdata->uimanager, ui_info, -1, NULL)) { g_error("building menus failed"); } procdata->action_group = gtk_action_group_new ("ProcmanActions"); gtk_action_group_set_translation_domain (procdata->action_group, NULL); gtk_action_group_add_actions (procdata->action_group, menu_entries, G_N_ELEMENTS (menu_entries), procdata); gtk_action_group_add_toggle_actions (procdata->action_group, toggle_menu_entries, G_N_ELEMENTS (toggle_menu_entries), procdata); gtk_action_group_add_radio_actions (procdata->action_group, radio_menu_entries, G_N_ELEMENTS (radio_menu_entries), procdata->config.whose_process, G_CALLBACK(cb_radio_processes), procdata); gtk_ui_manager_insert_action_group (procdata->uimanager, procdata->action_group, 0); menubar = gtk_ui_manager_get_widget (procdata->uimanager, "/MenuBar"); gtk_box_pack_start (GTK_BOX (main_box), menubar, FALSE, FALSE, 0); /* create the main notebook */ procdata->notebook = notebook = gtk_notebook_new (); gtk_box_pack_start (GTK_BOX (main_box), notebook, TRUE, TRUE, 0); sysinfo_box = gtk_hbox_new(TRUE, 0); // procman_create_sysinfo_view(); sysinfo_label = gtk_label_new(_("System")); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), sysinfo_box, sysinfo_label); vbox1 = create_proc_view (procdata); tab_label1 = gtk_label_new (_("Processes")); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), vbox1, tab_label1); sys_box = create_sys_view (procdata); tab_label2 = gtk_label_new (_("Resources")); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), sys_box, tab_label2); devices_box = create_disk_view (procdata); tab_label3 = gtk_label_new (_("File Systems")); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), devices_box, tab_label3); g_signal_connect (G_OBJECT (notebook), "switch-page", G_CALLBACK (cb_switch_page), procdata); g_signal_connect (G_OBJECT (notebook), "change-current-page", G_CALLBACK (cb_change_current_page), procdata); gtk_widget_show_all(notebook); // need to make page switch work gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), procdata->config.current_tab); cb_change_current_page (GTK_NOTEBOOK (notebook), procdata->config.current_tab, procdata); g_signal_connect (G_OBJECT (app), "delete_event", G_CALLBACK (cb_app_delete), procdata); /* create the statusbar */ procdata->statusbar = gtk_statusbar_new(); gtk_box_pack_end(GTK_BOX(main_box), procdata->statusbar, FALSE, FALSE, 0); procdata->tip_message_cid = gtk_statusbar_get_context_id (GTK_STATUSBAR (procdata->statusbar), "tip_message"); action = gtk_action_group_get_action (procdata->action_group, "ShowDependencies"); gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), procdata->config.show_tree); gtk_widget_show_all(app); procdata->app = app; }
void create_main_window (ProcData *procdata) { gint i; gint width, height, xpos, ypos; GtkWidget *app; GtkAction *action; GtkWidget *menubar; GtkWidget *main_box; GtkWidget *notebook; GtkWidget *tab_label1, *tab_label2, *tab_label3; GtkWidget *vbox1; GtkWidget *sys_box, *devices_box; GtkWidget *sysinfo_box, *sysinfo_label; app = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(app), _("System Monitor")); GdkScreen* screen = gtk_widget_get_screen(app); /* use visual, if available */ GdkVisual* visual = gdk_screen_get_rgba_visual(screen); if (visual) gtk_widget_set_visual(app, visual); main_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_add(GTK_CONTAINER(app), main_box); width = procdata->config.width; height = procdata->config.height; xpos = procdata->config.xpos; ypos = procdata->config.ypos; gtk_window_set_default_size (GTK_WINDOW (app), width, height); gtk_window_move(GTK_WINDOW (app), xpos, ypos); gtk_window_set_resizable (GTK_WINDOW (app), TRUE); if (procdata->config.maximized) { gtk_window_maximize(GTK_WINDOW(app)); } /* create the menubar */ procdata->uimanager = gtk_ui_manager_new (); /* show tooltips in the statusbar */ g_signal_connect (procdata->uimanager, "connect_proxy", G_CALLBACK (connect_proxy_cb), procdata); g_signal_connect (procdata->uimanager, "disconnect_proxy", G_CALLBACK (disconnect_proxy_cb), procdata); gtk_window_add_accel_group (GTK_WINDOW (app), gtk_ui_manager_get_accel_group (procdata->uimanager)); if (!gtk_ui_manager_add_ui_from_string (procdata->uimanager, ui_info, -1, NULL)) { g_error("building menus failed"); } procdata->action_group = gtk_action_group_new ("ProcmanActions"); gtk_action_group_set_translation_domain (procdata->action_group, NULL); gtk_action_group_add_actions (procdata->action_group, menu_entries, G_N_ELEMENTS (menu_entries), procdata); gtk_action_group_add_toggle_actions (procdata->action_group, toggle_menu_entries, G_N_ELEMENTS (toggle_menu_entries), procdata); gtk_action_group_add_radio_actions (procdata->action_group, radio_menu_entries, G_N_ELEMENTS (radio_menu_entries), procdata->config.whose_process, G_CALLBACK(cb_radio_processes), procdata); gtk_action_group_add_radio_actions (procdata->action_group, priority_menu_entries, G_N_ELEMENTS (priority_menu_entries), NORMAL_PRIORITY, G_CALLBACK(cb_renice), procdata); gtk_ui_manager_insert_action_group (procdata->uimanager, procdata->action_group, 0); menubar = gtk_ui_manager_get_widget (procdata->uimanager, "/MenuBar"); gtk_box_pack_start (GTK_BOX (main_box), menubar, FALSE, FALSE, 0); /* create the main notebook */ procdata->notebook = notebook = gtk_notebook_new (); gtk_box_pack_start (GTK_BOX (main_box), notebook, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (notebook), 12); sysinfo_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); // procman_create_sysinfo_view(); sysinfo_label = gtk_label_new(_("System")); gtk_notebook_append_page(GTK_NOTEBOOK(notebook), sysinfo_box, sysinfo_label); vbox1 = create_proc_view (procdata); tab_label1 = gtk_label_new (_("Processes")); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), vbox1, tab_label1); sys_box = create_sys_view (procdata); tab_label2 = gtk_label_new (_("Resources")); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), sys_box, tab_label2); devices_box = create_disk_view (procdata); tab_label3 = gtk_label_new (_("File Systems")); gtk_notebook_append_page (GTK_NOTEBOOK (notebook), devices_box, tab_label3); g_signal_connect (G_OBJECT (notebook), "switch-page", G_CALLBACK (cb_switch_page), procdata); g_signal_connect (G_OBJECT (notebook), "change-current-page", G_CALLBACK (cb_change_current_page), procdata); gtk_widget_show_all(notebook); // need to make page switch work gtk_notebook_set_current_page (GTK_NOTEBOOK (notebook), procdata->config.current_tab); cb_change_current_page (GTK_NOTEBOOK (notebook), procdata->config.current_tab, procdata); g_signal_connect (G_OBJECT (app), "delete_event", G_CALLBACK (cb_app_delete), procdata); GtkAccelGroup *accel_group; GClosure *goto_tab_closure[4]; accel_group = gtk_accel_group_new (); gtk_window_add_accel_group (GTK_WINDOW(app), accel_group); for (i = 0; i < 4; ++i) { goto_tab_closure[i] = g_cclosure_new_swap (G_CALLBACK (cb_proc_goto_tab), GINT_TO_POINTER (i), NULL); gtk_accel_group_connect (accel_group, '0'+(i+1), GDK_MOD1_MASK, GTK_ACCEL_VISIBLE, goto_tab_closure[i]); } /* create the statusbar */ procdata->statusbar = gtk_statusbar_new(); gtk_box_pack_start(GTK_BOX(main_box), procdata->statusbar, FALSE, FALSE, 0); procdata->tip_message_cid = gtk_statusbar_get_context_id (GTK_STATUSBAR (procdata->statusbar), "tip_message"); action = gtk_action_group_get_action (procdata->action_group, "ShowDependencies"); gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action), procdata->config.show_tree); gtk_widget_show_all(app); procdata->app = app; }
/** * 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); }
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; }
GtkWidget * build_root_selection_frame(ASFileBrowserRootSelFrame *data, GtkWidget *dirlist) { GtkTable *table; GtkWidget *btn ; GtkActionGroup *action_group ; GtkWidget *path_combo ; GtkWidget *path_entry = NULL; GtkWidget* file_chooser_btn ; #define ROOT_SELECTION_ENTRIES_NUM 6 static GtkRadioActionEntry root_sel_entries[ROOT_SELECTION_ENTRIES_NUM] = { {"root_PrivateAfterStep", NULL, "Private AfterStep", NULL, "Private directory conmtaining AfterStep files. Typically ~/.afterstep", root_PrivateAfterStep}, {"root_SharedAfterStep", NULL, "Shared AfterStep" , NULL, "System-wide shared directory conmtaining AfterStep files. Typically /usr/local/share/afterstep", root_SharedAfterStep}, {"root_Home", NULL, "Home" , NULL, "Private Home directory", root_Home}, {"root_UsrShare", NULL, "/usr/share" , NULL, "System-wide shared files directory /usr/share", root_UsrShare}, {"root_UsrLocalShare", NULL, "/usr/local/share" , NULL, "System-wide shared files directory /usr/local/share", root_UsrLocalShare}, {"root_Other", NULL, "Other : " , NULL, "Custom location in the filesystem tree", root_Other}, } ; int root_sel_cells[ROOT_SELECTION_ENTRIES_NUM][4] = { {0, 1, 0, 1}, {1, 2, 0, 1}, {2, 3, 0, 1}, {3, 4, 0, 1}, {4, 5, 0, 1}, {0, 1, 1, 2} }; int i ; GtkWidget *frame = gtk_frame_new( NULL ); GtkWidget *hbox = gtk_hbox_new( FALSE, 0 ); GtkWidget *label = gtk_label_new( "Select directory tree to browse : "); GtkWidget *checkbox = gtk_check_button_new_with_label( "( hide and show entire filesystem )" ); gtk_box_pack_start (GTK_BOX (hbox), label, TRUE, TRUE, 5); gtk_box_pack_end (GTK_BOX (hbox), checkbox, TRUE, TRUE, 5); gtk_widget_show_all (hbox); gtk_widget_show (hbox); gtk_frame_set_label_widget( GTK_FRAME(frame), hbox ); table = GTK_TABLE(gtk_table_new( 5, 2, FALSE )); g_signal_connect ((gpointer) checkbox, "clicked", G_CALLBACK (on_hide_contents_toggle), data); gtk_container_add (GTK_CONTAINER (frame), GTK_WIDGET(table)); gtk_container_set_border_width( GTK_CONTAINER (frame), 5 ); gtk_container_set_border_width( GTK_CONTAINER (table), 5 ); gtk_table_set_row_spacings( table, 5 ); gtk_table_set_col_spacings( table, 5 ); action_group = gtk_action_group_new( "RootSelection" ); gtk_action_group_add_radio_actions( action_group, root_sel_entries, ROOT_SELECTION_ENTRIES_NUM, root_PrivateAfterStep, G_CALLBACK(root_selection_changed), data ); for( i = 0 ; i < ROOT_SELECTION_ENTRIES_NUM ; ++i ) { btn = gtk_toggle_button_new_with_label(root_sel_entries[i].name); gtk_table_attach_defaults (table, btn, root_sel_cells[i][0], root_sel_cells[i][1], root_sel_cells[i][2], root_sel_cells[i][3]); gtk_action_connect_proxy(gtk_action_group_get_action(action_group,root_sel_entries[i].name), btn ); } path_combo = gtk_combo_box_entry_new_text(); colorize_gtk_edit(path_combo); file_chooser_btn = gtk_button_new_with_label( "Browse" ); colorize_gtk_edit(path_combo); hbox = gtk_hbox_new( FALSE, 0 ); gtk_box_pack_start (GTK_BOX (hbox), path_combo, TRUE, TRUE, 0); gtk_box_pack_end (GTK_BOX (hbox), file_chooser_btn, FALSE, FALSE, 0); gtk_widget_show_all (hbox); gtk_table_attach_defaults (table, hbox, 1, 5, 1, 2 ); if( GTK_IS_CONTAINER(path_combo) ) gtk_container_forall( GTK_CONTAINER(path_combo), find_combobox_entry, &path_entry ); /* if above succeeded then path_entry should be not NULL here : */ /* TODO : insert proper change handlers and data pointers here : */ if( path_entry ) g_signal_connect ( G_OBJECT (path_entry), "activate", G_CALLBACK (NULL), (gpointer) NULL); g_signal_connect (G_OBJECT(path_combo), "changed", G_CALLBACK (NULL), (gpointer) NULL); gtk_widget_show_all (GTK_WIDGET(table)); gtk_widget_show (GTK_WIDGET(table)); gtk_widget_set_size_request ( frame, -1, -1); colorize_gtk_widget( frame, get_colorschemed_style_normal() ); data->table = GTK_WIDGET(table) ; data->action_group = action_group ; data->path_combo = path_combo ; data->path_entry = path_entry ; data->file_chooser_btn = file_chooser_btn ; data->target_dirlist = dirlist ; return frame; }
/* 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_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; GSettings *settings; GtkAction *action; 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 GSettings keys. */ settings = e_util_ref_settings ("org.gnome.evolution.addressbook"); g_settings_bind ( settings, "show-preview", ACTION (CONTACT_PREVIEW), "active", G_SETTINGS_BIND_DEFAULT); g_settings_bind ( settings, "layout", ACTION (CONTACT_VIEW_VERTICAL), "current-value", G_SETTINGS_BIND_DEFAULT); g_settings_bind ( settings, "preview-show-maps", ACTION (CONTACT_PREVIEW_SHOW_MAPS), "active", G_SETTINGS_BIND_DEFAULT); g_object_unref (settings); /* Fine tuning. */ e_binding_bind_property ( ACTION (CONTACT_PREVIEW), "active", ACTION (CONTACT_VIEW_CLASSIC), "sensitive", G_BINDING_SYNC_CREATE); e_binding_bind_property ( ACTION (CONTACT_PREVIEW), "active", ACTION (CONTACT_VIEW_VERTICAL), "sensitive", G_BINDING_SYNC_CREATE); e_binding_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 }
void e_task_shell_view_update_search_filter (ETaskShellView *task_shell_view) { ETaskShellContent *task_shell_content; EShellView *shell_view; EShellWindow *shell_window; EShellSearchbar *searchbar; EActionComboBox *combo_box; GtkActionGroup *action_group; GtkRadioAction *radio_action; GList *list, *iter; GSList *group; gint ii; shell_view = E_SHELL_VIEW (task_shell_view); shell_window = e_shell_view_get_shell_window (shell_view); action_group = ACTION_GROUP (TASKS_FILTER); e_action_group_remove_all_actions (action_group); /* Add the standard filter actions. No callback is needed * because changes in the EActionComboBox are detected and * handled by EShellSearchbar. */ gtk_action_group_add_radio_actions ( action_group, task_filter_entries, G_N_ELEMENTS (task_filter_entries), TASK_FILTER_ANY_CATEGORY, NULL, NULL); /* Retrieve the radio group from an action we just added. */ list = gtk_action_group_list_actions (action_group); radio_action = GTK_RADIO_ACTION (list->data); group = gtk_radio_action_get_group (radio_action); g_list_free (list); /* Build the category actions. */ list = e_util_dup_searchable_categories (); for (iter = list, ii = 0; iter != NULL; iter = iter->next, ii++) { const gchar *category_name = iter->data; gchar *filename; GtkAction *action; gchar *action_name; action_name = g_strdup_printf ( "task-filter-category-%d", ii); radio_action = gtk_radio_action_new ( action_name, category_name, NULL, NULL, ii); g_free (action_name); /* Convert the category icon file to a themed icon name. */ filename = e_categories_dup_icon_file_for (category_name); if (filename != NULL && *filename != '\0') { gchar *basename; gchar *cp; basename = g_path_get_basename (filename); /* Lose the file extension. */ if ((cp = strrchr (basename, '.')) != NULL) *cp = '\0'; g_object_set ( radio_action, "icon-name", basename, NULL); g_free (basename); } g_free (filename); gtk_radio_action_set_group (radio_action, group); group = gtk_radio_action_get_group (radio_action); /* The action group takes ownership of the action. */ action = GTK_ACTION (radio_action); gtk_action_group_add_action (action_group, action); g_object_unref (radio_action); } g_list_free_full (list, g_free); task_shell_content = task_shell_view->priv->task_shell_content; searchbar = e_task_shell_content_get_searchbar (task_shell_content); combo_box = e_shell_searchbar_get_filter_combo_box (searchbar); e_shell_view_block_execute_search (shell_view); /* Use any action in the group; doesn't matter which. */ e_action_combo_box_set_action (combo_box, radio_action); ii = TASK_FILTER_UNMATCHED; e_action_combo_box_add_separator_after (combo_box, ii); ii = TASK_FILTER_TASKS_WITH_ATTACHMENTS; e_action_combo_box_add_separator_after (combo_box, ii); e_shell_view_unblock_execute_search (shell_view); }
static GObject * gam_app_constructor (GType type, guint n_construct_properties, GObjectConstructParam *construct_params) { GObject *object; GamApp *gam_app; GamAppPrivate *priv; GtkWidget *main_box, *mixer, *label; GError *error; snd_ctl_t *ctl_handle; gint result, index = 0; gchar *card; object = (* G_OBJECT_CLASS (parent_class)->constructor) (type, n_construct_properties, construct_params); gam_app = GAM_APP (object); priv = GAM_APP_GET_PRIVATE (gam_app); g_signal_connect (G_OBJECT (gam_app), "delete_event", G_CALLBACK (gam_app_delete), NULL); gtk_window_set_icon_from_file (GTK_WINDOW (gam_app), PIXMAP_ICONDIR"/gnome-alsamixer-icon.png", NULL); // Build the main menu and toolbar gtk_action_group_add_actions (priv->main_action_group, action_entries, G_N_ELEMENTS (action_entries), gam_app); gtk_action_group_add_radio_actions (priv->main_action_group, radio_action_entries, G_N_ELEMENTS (radio_action_entries), VIEW_ALL, G_CALLBACK (gam_app_view_mixers_cb), gam_app); gtk_ui_manager_insert_action_group (priv->ui_manager, priv->main_action_group, 0); gtk_window_add_accel_group (GTK_WINDOW (gam_app), priv->ui_accel_group); error = NULL; if (!gtk_ui_manager_add_ui_from_string (priv->ui_manager, ui_description, -1, &error)) { g_message ("building ui failed: %s", error->message); g_error_free (error); exit (EXIT_FAILURE); } g_signal_connect (G_OBJECT (priv->ui_manager), "connect_proxy", G_CALLBACK (gam_app_ui_connect_proxy_cb), gam_app); g_signal_connect (G_OBJECT (priv->ui_manager), "disconnect_proxy", G_CALLBACK (gam_app_ui_disconnect_proxy_cb), gam_app); do { card = g_strdup_printf ("hw:%d", index++); result = snd_ctl_open (&ctl_handle, card, 0); if (result == 0) { snd_ctl_close(ctl_handle); mixer = gam_mixer_new (gam_app, card); if (gam_mixer_get_visible (GAM_MIXER (mixer))) gtk_widget_show (mixer); g_signal_connect (G_OBJECT (mixer), "display_name_changed", G_CALLBACK (gam_app_mixer_display_name_changed_cb), gam_app); g_signal_connect (G_OBJECT (mixer), "visibility_changed", G_CALLBACK (gam_app_mixer_visibility_changed_cb), gam_app); label = gtk_label_new (gam_mixer_get_display_name (GAM_MIXER (mixer))); gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT); gtk_notebook_append_page (GTK_NOTEBOOK (priv->notebook), mixer, label); gam_mixer_update_visibility(mixer); } g_free (card); } while (result == 0); priv->num_cards = index - 1; // Pack widgets into window main_box = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (gam_app), main_box); gtk_box_pack_start (GTK_BOX (main_box), gtk_ui_manager_get_widget (priv->ui_manager, "/MainMenu"), FALSE, FALSE, 0); gtk_box_pack_end (GTK_BOX (main_box), priv->status_bar, FALSE, FALSE, 0); gtk_widget_show_all (GTK_WIDGET (main_box)); gtk_box_pack_start (GTK_BOX (main_box), priv->notebook, TRUE, TRUE, 0); g_signal_connect (G_OBJECT (priv->notebook), "switch-page", G_CALLBACK (gam_app_notebook_switch_page_cb), gam_app); gam_app_notebook_switch_page_cb(NULL, NULL, 0, gam_app); gtk_widget_show (priv->notebook); gam_app_load_prefs (gam_app); /*gconf_client_notify_add (priv->gconf_client, "/apps/gnomealsamixer/preferences/tab_position", (GConfClientNotifyFunc) pawed_app_gconf_notify_func, pawed_app, NULL, NULL);*/ return object; }
gboolean gui_init( gboolean withDebug, gboolean withFullscreen ) { if( gtk_gui_init_ok ) { int i; GError *error = NULL; dreamcast_register_module( >k_gui_module ); gtk_gui_alloc_resources(); global_action_group = gtk_action_group_new("MenuActions"); gtk_action_group_set_translation_domain( global_action_group, NULL ); gtk_action_group_add_actions( global_action_group, ui_actions, G_N_ELEMENTS(ui_actions), NULL ); gtk_action_group_add_toggle_actions( global_action_group, ui_toggle_actions, G_N_ELEMENTS(ui_toggle_actions), NULL ); for( i=0; i<=MAX_QUICK_STATE; i++ ) { ui_radio_actions[i].name = g_strdup_printf("QuickState%d", i); ui_radio_actions[i].stock_id = NULL; ui_radio_actions[i].label = g_strdup_printf(_("State _%d"), i ); ui_radio_actions[i].accelerator = NULL; ui_radio_actions[i].tooltip = g_strdup_printf(_("Use quick save state %d"),i); ui_radio_actions[i].value = i; } gtk_action_group_add_radio_actions( global_action_group, ui_radio_actions, G_N_ELEMENTS(ui_radio_actions), dreamcast_get_quick_state(), G_CALLBACK(quick_state_action_callback), NULL ); gtk_gui_enable_action("AudioSettings", FALSE); gtk_gui_enable_action("NetworkSettings", FALSE); gtk_gui_enable_action("VideoSettings", FALSE); global_ui_manager = gtk_ui_manager_new(); gtk_ui_manager_set_add_tearoffs(global_ui_manager, TRUE); gtk_ui_manager_insert_action_group( global_ui_manager, global_action_group, 0 ); if (!gtk_ui_manager_add_ui_from_string (global_ui_manager, ui_description, -1, &error)) { g_message ("building menus failed: %s", error->message); g_error_free (error); exit(1); } GtkAccelGroup *accel_group = gtk_ui_manager_get_accel_group (global_ui_manager); GtkWidget *menubar = gtk_ui_manager_get_widget(global_ui_manager, "/MainMenu"); GtkWidget *toolbar = gtk_ui_manager_get_widget(global_ui_manager, "/MainToolbar"); GtkWidget *gdrommenuitem = gtk_ui_manager_get_widget(global_ui_manager, "/MainMenu/FileMenu/GdromSettings"); GtkWidget *gdrommenu = gdrom_menu_new(); gtk_menu_item_set_submenu( GTK_MENU_ITEM(gdrommenuitem), gdrommenu ); main_win = main_window_new( lxdream_package_name, menubar, toolbar, accel_group ); if( withDebug ) { gtk_gui_show_debugger(); } if (withFullscreen) { main_window_set_fullscreen(main_win, TRUE); //manually call full-screen state code for non-compliant window managers main_window_show_gui(main_win, TRUE); } register_gdrom_disc_change_hook( gtk_gui_disc_changed, NULL ); return TRUE; } else { return FALSE; } }
void liferea_shell_create (GtkApplication *app, const gchar *overrideWindowState) { GtkUIManager *ui_manager; GtkAccelGroup *accel_group; GError *error = NULL; gboolean toggle; gchar *id; debug_enter ("liferea_shell_create"); g_object_new (LIFEREA_SHELL_TYPE, NULL); shell->priv->window = GTK_WINDOW (liferea_shell_lookup ("mainwindow")); gtk_window_set_application (GTK_WINDOW (shell->priv->window), app); /* 1.) menu creation */ debug0 (DEBUG_GUI, "Setting up menues"); shell->priv->itemlist = itemlist_create (); /* Prepare some toggle button states */ conf_get_bool_value (REDUCED_FEEDLIST, &toggle); liferea_shell_feedlist_toggle_entries[0].is_active = toggle; ui_manager = gtk_ui_manager_new (); shell->priv->generalActions = gtk_action_group_new ("GeneralActions"); gtk_action_group_set_translation_domain (shell->priv->generalActions, PACKAGE); gtk_action_group_add_actions (shell->priv->generalActions, liferea_shell_action_entries, G_N_ELEMENTS (liferea_shell_action_entries), shell->priv); gtk_action_group_add_toggle_actions (shell->priv->generalActions, liferea_shell_action_toggle_entries, G_N_ELEMENTS (liferea_shell_action_toggle_entries), shell->priv); gtk_action_group_add_radio_actions (shell->priv->generalActions, liferea_shell_view_radio_entries, G_N_ELEMENTS (liferea_shell_view_radio_entries), itemlist_get_view_mode (), (GCallback)on_view_activate, (gpointer)TRUE); gtk_action_group_add_toggle_actions (shell->priv->generalActions, liferea_shell_feedlist_toggle_entries, G_N_ELEMENTS (liferea_shell_feedlist_toggle_entries), shell->priv); gtk_ui_manager_insert_action_group (ui_manager, shell->priv->generalActions, 0); shell->priv->addActions = gtk_action_group_new ("AddActions"); gtk_action_group_set_translation_domain (shell->priv->addActions, PACKAGE); gtk_action_group_add_actions (shell->priv->addActions, liferea_shell_add_action_entries, G_N_ELEMENTS (liferea_shell_add_action_entries), shell->priv); gtk_ui_manager_insert_action_group (ui_manager, shell->priv->addActions, 0); shell->priv->feedActions = gtk_action_group_new ("FeedActions"); gtk_action_group_set_translation_domain (shell->priv->feedActions, PACKAGE); gtk_action_group_add_actions (shell->priv->feedActions, liferea_shell_feed_action_entries, G_N_ELEMENTS (liferea_shell_feed_action_entries), shell->priv); gtk_ui_manager_insert_action_group (ui_manager, shell->priv->feedActions, 0); shell->priv->readWriteActions = gtk_action_group_new("ReadWriteActions"); gtk_action_group_set_translation_domain (shell->priv->readWriteActions, PACKAGE); gtk_action_group_add_actions (shell->priv->readWriteActions, liferea_shell_read_write_action_entries, G_N_ELEMENTS (liferea_shell_read_write_action_entries), shell->priv); gtk_ui_manager_insert_action_group (ui_manager, shell->priv->readWriteActions, 0); shell->priv->itemActions = gtk_action_group_new ("ItemActions"); gtk_action_group_set_translation_domain (shell->priv->itemActions, PACKAGE); gtk_action_group_add_actions (shell->priv->itemActions, liferea_shell_item_action_entries, G_N_ELEMENTS (liferea_shell_item_action_entries), shell->priv); gtk_ui_manager_insert_action_group (ui_manager, shell->priv->itemActions, 0); accel_group = gtk_ui_manager_get_accel_group (ui_manager); gtk_window_add_accel_group (GTK_WINDOW (shell->priv->window), accel_group); g_object_unref (accel_group); g_signal_connect (gtk_accel_map_get (), "changed", G_CALLBACK (on_accel_change), NULL); if (!gtk_ui_manager_add_ui_from_string (ui_manager, liferea_shell_ui_desc, -1, &error)) g_error ("building menus failed: %s", error->message); shell->priv->menubar = gtk_ui_manager_get_widget (ui_manager, "/MainwindowMenubar"); shell->priv->toolbar = gtk_ui_manager_get_widget (ui_manager, "/maintoolbar"); /* Ensure GTK3 toolbar shadows... */ gtk_style_context_add_class (gtk_widget_get_style_context (shell->priv->toolbar), "primary-toolbar"); /* what a pain, why is there no markup for this option? */ g_object_set (G_OBJECT (gtk_ui_manager_get_widget (ui_manager, "/maintoolbar/newFeedButton")), "is_important", TRUE, NULL); g_object_set (G_OBJECT (gtk_ui_manager_get_widget (ui_manager, "/maintoolbar/nextUnreadButton")), "is_important", TRUE, NULL); g_object_set (G_OBJECT (gtk_ui_manager_get_widget (ui_manager, "/maintoolbar/MarkAsReadButton")), "is_important", TRUE, NULL); g_object_set (G_OBJECT (gtk_ui_manager_get_widget (ui_manager, "/maintoolbar/UpdateAllButton")), "is_important", TRUE, NULL); g_object_set (G_OBJECT (gtk_ui_manager_get_widget (ui_manager, "/maintoolbar/SearchButton")), "is_important", TRUE, NULL); /* 2.) setup containers */ debug0 (DEBUG_GUI, "Setting up widget containers"); gtk_box_pack_start (GTK_BOX (liferea_shell_lookup ("vbox1")), shell->priv->toolbar, FALSE, FALSE, 0); gtk_box_reorder_child (GTK_BOX (liferea_shell_lookup ("vbox1")), shell->priv->toolbar, 0); gtk_box_pack_start (GTK_BOX (liferea_shell_lookup ("vbox1")), shell->priv->menubar, FALSE, FALSE, 0); gtk_box_reorder_child (GTK_BOX (liferea_shell_lookup ("vbox1")), shell->priv->menubar, 0); gtk_widget_show_all(GTK_WIDGET(shell->priv->toolbar)); g_signal_connect ((gpointer) liferea_shell_lookup ("itemtabs"), "key_press_event", G_CALLBACK (on_key_press_event_null_cb), NULL); g_signal_connect ((gpointer) liferea_shell_lookup ("itemtabs"), "key_release_event", G_CALLBACK (on_key_press_event_null_cb), NULL); g_signal_connect ((gpointer) liferea_shell_lookup ("itemtabs"), "scroll_event", G_CALLBACK (on_notebook_scroll_event_null_cb), NULL); g_signal_connect (G_OBJECT (shell->priv->window), "delete_event", G_CALLBACK(on_close), shell->priv); g_signal_connect (G_OBJECT (shell->priv->window), "window_state_event", G_CALLBACK(on_window_state_event), shell->priv); g_signal_connect (G_OBJECT (shell->priv->window), "key_press_event", G_CALLBACK(on_key_press_event), shell->priv); /* 3.) setup status bar */ debug0 (DEBUG_GUI, "Setting up status bar"); shell->priv->statusbar = GTK_STATUSBAR (liferea_shell_lookup ("statusbar")); shell->priv->statusbarLocked = FALSE; shell->priv->statusbarLockTimer = 0; shell->priv->statusbar_feedsinfo = gtk_label_new(""); gtk_widget_show(shell->priv->statusbar_feedsinfo); gtk_box_pack_start (GTK_BOX (shell->priv->statusbar), shell->priv->statusbar_feedsinfo, FALSE, FALSE, 5); /* 4.) setup tabs */ debug0 (DEBUG_GUI, "Setting up tabbed browsing"); shell->priv->tabs = browser_tabs_create (GTK_NOTEBOOK (liferea_shell_lookup ("browsertabs"))); /* 5.) setup feed list */ debug0 (DEBUG_GUI, "Setting up feed list"); shell->priv->feedlistView = GTK_TREE_VIEW (liferea_shell_lookup ("feedlist")); feed_list_view_init (shell->priv->feedlistView); /* 6.) setup menu sensivity */ debug0 (DEBUG_GUI, "Initialising menues"); /* On start, no item or feed is selected, so Item menu should be insensitive: */ liferea_shell_update_item_menu (FALSE); /* necessary to prevent selection signals when filling the feed list and setting the 2/3 pane mode view */ gtk_widget_set_sensitive (GTK_WIDGET (shell->priv->feedlistView), FALSE); /* 7.) setup item view */ debug0 (DEBUG_GUI, "Setting up item view"); shell->priv->itemview = itemview_create (GTK_WIDGET (shell->priv->window)); /* 8.) load icons as required */ debug0 (DEBUG_GUI, "Loading icons"); icons_load (); /* 9.) update and restore all menu elements */ liferea_shell_update_toolbar (); liferea_shell_update_history_actions (); liferea_shell_setup_URL_receiver (); liferea_shell_restore_state (overrideWindowState); gtk_widget_set_sensitive (GTK_WIDGET (shell->priv->feedlistView), TRUE); /* 10.) After main window is realized get theme colors and set up feed list and tray icon */ render_init_theme_colors (GTK_WIDGET (shell->priv->window)); shell->priv->feedlist = feedlist_create (); g_signal_connect (shell->priv->feedlist, "new-items", G_CALLBACK (liferea_shell_update_unread_stats), shell->priv->feedlist); /* 11.) Restore latest selection */ // FIXME: Move to feed list code if (conf_get_str_value (LAST_NODE_SELECTED, &id)) { feed_list_view_select (node_from_id (id)); g_free (id); } /* 12. Setup shell plugins */ shell->priv->extensions = peas_extension_set_new (PEAS_ENGINE (liferea_plugins_engine_get_default ()), LIFEREA_TYPE_SHELL_ACTIVATABLE, "shell", shell, NULL); g_signal_connect (shell->priv->extensions, "extension-added", G_CALLBACK (on_extension_added), shell); g_signal_connect (shell->priv->extensions, "extension-removed", G_CALLBACK (on_extension_removed), shell); peas_extension_set_call (shell->priv->extensions, "activate"); /* 14. Rebuild search folders if needed */ if (searchFolderRebuild) vfolder_foreach (vfolder_rebuild); debug_exit ("liferea_shell_create"); }
GtkWidget *init_menus ( GtkWidget *vbox ) { GtkWidget *menubar; GtkActionGroup *actions; /* remind of GtkActionEntry : name, stock_id, label, accelerator, tooltip, callback */ GtkActionEntry entries[] = { /* File menu */ {"FileMenuAction", NULL, _("_File"), NULL, NULL, NULL}, #ifdef GTKOSXAPPLICATION { "NewAction", GTK_STOCK_NEW, _("_New account file..."), "<Meta>N", NULL, G_CALLBACK ( gsb_file_new ) }, {"OpenAction", GTK_STOCK_OPEN, _("_Open..."), "<Meta>O", NULL, G_CALLBACK ( gsb_file_open_menu ) }, {"RecentFilesAction", NULL, _("_Recently opened files"), NULL, NULL, NULL }, {"SaveAction", GTK_STOCK_SAVE, _("_Save"), "<Meta>S", NULL, G_CALLBACK ( gsb_file_save ) }, #else { "NewAction", GTK_STOCK_NEW, _("_New account file..."), NULL, NULL, G_CALLBACK ( gsb_file_new ) }, {"OpenAction", GTK_STOCK_OPEN, _("_Open..."), NULL, NULL, G_CALLBACK ( gsb_file_open_menu ) }, {"RecentFilesAction", NULL, _("_Recently opened files"), NULL, NULL, NULL }, {"SaveAction", GTK_STOCK_SAVE, _("_Save"), NULL, NULL, G_CALLBACK ( gsb_file_save ) }, #endif {"SaveAsAction", GTK_STOCK_SAVE_AS, _("_Save as..."), NULL, NULL, G_CALLBACK ( gsb_file_save_as ) }, {"ImportFileAction", GTK_STOCK_CONVERT, _("_Import file..."), NULL, NULL, G_CALLBACK ( importer_fichier ) }, { "ExportFileAction", GTK_STOCK_CONVERT, _("_Export accounts as QIF/CSV file..."), NULL, NULL, G_CALLBACK ( export_accounts ) }, {"CreateArchiveAction", GTK_STOCK_CLEAR, _("Archive transactions..."), NULL, NULL, G_CALLBACK ( gsb_assistant_archive_run_by_menu ) }, {"ExportArchiveAction", GTK_STOCK_HARDDISK, _("_Export an archive as GSB/QIF/CSV file..."), NULL, NULL, G_CALLBACK ( gsb_assistant_archive_export_run ) }, {"DebugFileAction", GTK_STOCK_FIND, _("_Debug account file..."), "", NULL, G_CALLBACK ( gsb_debug ) }, {"ObfuscateAction", GTK_STOCK_FIND, _("_Obfuscate account file..."), "", NULL, G_CALLBACK ( file_obfuscate_run ) }, {"ObfuscateQifAction", GTK_STOCK_FIND, _("_Obfuscate QIF file..."), "", NULL, G_CALLBACK ( file_obfuscate_qif_run ) }, #ifdef GTKOSXAPPLICATION {"CloseAction", GTK_STOCK_CLOSE, _("_Close"), "<Meta>W", NULL, G_CALLBACK ( gsb_file_close ) }, #else {"CloseAction", GTK_STOCK_CLOSE, _("_Close"), NULL, NULL, G_CALLBACK ( gsb_file_close ) }, #endif {"QuitAction", GTK_STOCK_QUIT, _("_Quit"), NULL, NULL, G_CALLBACK ( gsb_main_grisbi_close ) }, /* Editmenu */ {"EditMenuAction", NULL, _("_Edit"), NULL, NULL, NULL }, {"EditTransactionAction", GTK_STOCK_EDIT, _("_Edit transaction"), "", NULL, G_CALLBACK ( gsb_data_mix_edit_current_transaction ) }, {"NewTransactionAction", GTK_STOCK_NEW, _("_New transaction"), "", NULL, G_CALLBACK ( gsb_data_mix_new_transaction_by_menu ) }, {"RemoveTransactionAction", GTK_STOCK_DELETE, _("_Remove transaction"), "", NULL, G_CALLBACK ( gsb_data_mix_delete_current_transaction ) }, {"TemplateTransactionAction", GTK_STOCK_COPY, _("Use selected transaction as a template"), "", NULL, G_CALLBACK ( gsb_transactions_list_clone_template ) }, {"CloneTransactionAction", GTK_STOCK_COPY, _("_Clone transaction"), "", NULL, G_CALLBACK ( gsb_data_mix_clone_current_transaction ) }, {"ConvertToScheduledAction", GTK_STOCK_CONVERT, _("Convert to _scheduled transaction"), NULL, NULL, G_CALLBACK ( schedule_selected_transaction ) }, {"MoveToAnotherAccountAction", NULL, _("_Move transaction to another account"), NULL, NULL, NULL }, {"NewAccountAction", GTK_STOCK_NEW, _("_New account"), "", NULL, G_CALLBACK ( gsb_assistant_account_run ) }, {"RemoveAccountAction", GTK_STOCK_DELETE, _("_Remove current account"), "", NULL, G_CALLBACK ( gsb_account_delete ) }, {"PrefsAction", GTK_STOCK_PREFERENCES, _("_Preferences"), NULL, NULL, G_CALLBACK ( preferences ) }, /* View menu */ {"ViewMenuAction", NULL, _("_View"), NULL, NULL, NULL }, {"InitwidthColAction", NULL, _("Reset the column width"), NULL, NULL, G_CALLBACK ( gsb_menu_reinit_largeur_col_menu ) }, /* Help menu */ {"HelpMenuAction", NULL, _("_Help"), NULL, NULL, NULL }, #ifdef GTKOSXAPPLICATION {"ManualAction", GTK_STOCK_HELP, _("_Manual"), "<Meta>H", NULL, G_CALLBACK ( help_manual ) }, #else {"ManualAction", GTK_STOCK_HELP, _("_Manual"), NULL, NULL, G_CALLBACK ( help_manual ) }, #endif {"QuickStartAction", NULL, _("_Quick start"), NULL, NULL, G_CALLBACK ( help_quick_start ) }, {"TranslationAction", NULL, _("_Translation"), NULL, NULL, G_CALLBACK ( help_translation ) }, {"AboutAction", GTK_STOCK_ABOUT, _("_About Grisbi..."), NULL, NULL, G_CALLBACK ( a_propos ) }, {"GrisbiWebsiteAction", NULL, _("_Grisbi website"), NULL, NULL, G_CALLBACK ( help_website ) }, {"ReportBugAction", NULL, _("_Report a bug"), NULL, NULL, G_CALLBACK ( help_bugreport ) }, {"TipAction", GTK_STOCK_DIALOG_INFO, _("_Tip of the day"), NULL, NULL, G_CALLBACK ( force_display_tip ) }, }; GtkRadioActionEntry radio_entries[] = { /* Name, StockID, Label, Accelerator, Tooltip, Value */ {"ShowOneLineAction", NULL, _("Show _one line per transaction"), NULL, NULL, ONE_LINE_PER_TRANSACTION }, {"ShowTwoLinesAction", NULL, _("Show _two lines per transaction"), NULL, NULL, TWO_LINES_PER_TRANSACTION }, {"ShowThreeLinesAction", NULL, _("Show _three lines per transaction"), NULL, NULL, THREE_LINES_PER_TRANSACTION }, {"ShowFourLinesAction", NULL, _("Show _four lines per transaction"), NULL, NULL, FOUR_LINES_PER_TRANSACTION }, }; GtkToggleActionEntry toggle_entries[] = { {"DebugModeAction", NULL, _("Debug mode"), NULL, NULL, G_CALLBACK ( gsb_debug_start_log ), etat.debug_mode }, {"ShowTransactionFormAction", NULL, _("Show transaction _form"), NULL, NULL, G_CALLBACK ( gsb_gui_toggle_show_form ), conf.formulaire_toujours_affiche }, #ifdef GTKOSXAPPLICATION {"ShowReconciledAction", NULL, _("Show _reconciled"), "<Meta>R", NULL, G_CALLBACK ( gsb_gui_toggle_show_reconciled ), 0 }, {"ShowArchivedAction", NULL, _("Show _lines archives"), "<Meta>L", NULL, G_CALLBACK ( gsb_gui_toggle_show_archived ), 0 }, #else {"ShowReconciledAction", NULL, _("Show _reconciled"), "<Alt>R", NULL, G_CALLBACK ( gsb_gui_toggle_show_reconciled ), 0 }, {"ShowArchivedAction", NULL, _("Show _lines archives"), "<Alt>L", NULL, G_CALLBACK ( gsb_gui_toggle_show_archived ), 0 }, #endif {"ShowClosedAction", NULL, _("Show _closed accounts"), NULL, NULL, G_CALLBACK ( gsb_gui_toggle_show_closed_accounts ), conf.show_closed_accounts } }; ui_manager = gtk_ui_manager_new (); actions = gtk_action_group_new ( "Actions" ); gtk_action_group_add_actions (actions, entries, G_N_ELEMENTS ( entries ), (gpointer) run.window ); gtk_action_group_add_radio_actions ( actions, radio_entries, G_N_ELEMENTS ( radio_entries ), -1, G_CALLBACK ( gsb_gui_toggle_line_view_mode ), NULL ); gtk_action_group_add_toggle_actions ( actions, toggle_entries, G_N_ELEMENTS ( toggle_entries ), NULL ); gtk_ui_manager_insert_action_group ( ui_manager, actions, 0 ); merge_id = gtk_ui_manager_add_ui_from_string ( ui_manager, ui_manager_buffer, -1, NULL ); #ifndef GTKOSXAPPLICATION gtk_window_add_accel_group ( GTK_WINDOW ( run.window ), gtk_ui_manager_get_accel_group ( ui_manager ) ); #endif /* GTKOSXAPPLICATION */ menubar = gtk_ui_manager_get_widget ( ui_manager, "/menubar" ); gtk_box_pack_start ( GTK_BOX ( vbox ), menubar, FALSE, TRUE, 0 ); /* return */ return menubar; }
GtkWidget * alleyoop_new (ValgrindTool tool, const char **argv, const char **srcdir) { GtkWidget *menubar, *widget, *vbox; GtkActionGroup *actions; GtkAccelGroup *accels; GError *err = NULL; Alleyoop *grind; char *title; int i; grind = g_object_new (ALLEYOOP_TYPE, NULL); if (argv && argv[0] != NULL) title = g_strdup_printf ("Alleyoop - [%s]", argv[0]); else title = g_strdup ("Alleyoop"); //gnome_app_construct ((GnomeApp *) grind, "alleyoop", title); gtk_window_set_title ((GtkWindow *) grind, title); gtk_window_set_default_size ((GtkWindow *) grind, 300, 400); g_free (title); grind->tool = tool; grind->argv = argv; grind->srcdir = srcdir; vbox = gtk_vbox_new (FALSE, 0); /* construct the menus */ grind->ui = gtk_ui_manager_new (); actions = gtk_action_group_new ("MenuActions"); gtk_action_group_add_actions (actions, normal_menu_items, G_N_ELEMENTS (normal_menu_items), grind); gtk_action_group_add_radio_actions (actions, radio_menu_items, G_N_ELEMENTS (radio_menu_items), tool, G_CALLBACK (tool_selected_cb), grind); gtk_ui_manager_insert_action_group (grind->ui, actions, 0); accels = gtk_ui_manager_get_accel_group (grind->ui); gtk_window_add_accel_group ((GtkWindow *) grind, accels); if (!gtk_ui_manager_add_ui_from_string (grind->ui, menu_xml, -1, &err)) { g_message ("Building menus failed: %s", err->message); g_error_free (err); exit (EXIT_FAILURE); } menubar = gtk_ui_manager_get_widget (grind->ui, "/MainMenu"); gtk_widget_show (menubar); /* pack in the menubar */ gtk_box_pack_start (GTK_BOX (vbox), menubar, FALSE, FALSE, 0); widget = alleyoop_toolbar_new (grind); gtk_widget_set_sensitive (grind->toolbar_run, TRUE); gtk_widget_set_sensitive (grind->toolbar_kill, FALSE); gtk_widget_show (widget); /* pack in the toolbar */ gtk_box_pack_start (GTK_BOX (vbox), widget, FALSE, FALSE, 0); grind->view = widget = vg_default_view_new (); vg_tool_view_set_argv ((VgToolView *) widget, argv); vg_tool_view_set_srcdir ((VgToolView *) widget, srcdir); gtk_widget_show (widget); /* pack in the view */ gtk_box_pack_start (GTK_BOX (vbox), widget, TRUE, TRUE, 0); /* create the prefs dialog (we just don't display it) */ grind->prefs = alleyoop_prefs_new (); g_signal_connect (grind->prefs, "response", G_CALLBACK (prefs_response_cb), grind); g_signal_connect (grind->prefs, "delete-event", G_CALLBACK (prefs_delete_event), grind); gtk_widget_show (vbox); gtk_container_add ((GtkContainer *) grind, vbox); return (GtkWidget *) grind; }