static void set_up_tree_view (TotemYouTubePlugin *self, GtkBuilder *builder, guint key) { GtkUIManager *ui_manager; GtkActionGroup *action_group; GtkAction *action, *menu_item; GtkWidget *vscroll, *tree_view; GtkTreeViewColumn *column; GtkCellRenderer *renderer; /* Add the cell renderer. This can't be done with GtkBuilder, because it unavoidably sets the expand parameter to FALSE */ /* TODO: Depends on bug #453692 */ renderer = GTK_CELL_RENDERER (totem_cell_renderer_video_new (TRUE)); column = GTK_TREE_VIEW_COLUMN (gtk_builder_get_object (builder, (key == SEARCH_TREE_VIEW) ? "yt_treeview_search_column" : "yt_treeview_related_column")); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_attributes (column, renderer, "thumbnail", 0, "title", 1, NULL); /* Give the video lists a handle to Totem and connect their scrollbar signals */ if (key == SEARCH_TREE_VIEW) { tree_view = GTK_WIDGET (gtk_builder_get_object (builder, "yt_treeview_search")); vscroll = gtk_scrolled_window_get_vscrollbar (GTK_SCROLLED_WINDOW (gtk_builder_get_object (builder, "yt_scrolled_window_search"))); self->list_store[key] = GTK_LIST_STORE (gtk_builder_get_object (builder, "yt_list_store_search")); self->tree_view[key] = GTK_TREE_VIEW (tree_view); self->progress_bar[key] = GTK_PROGRESS_BAR (gtk_builder_get_object (builder, "yt_progress_bar_search")); } else { tree_view = GTK_WIDGET (gtk_builder_get_object (builder, "yt_treeview_related")); vscroll = gtk_scrolled_window_get_vscrollbar (GTK_SCROLLED_WINDOW (gtk_builder_get_object (builder, "yt_scrolled_window_related"))); self->list_store[key] = GTK_LIST_STORE (gtk_builder_get_object (builder, "yt_list_store_related")); self->tree_view[key] = GTK_TREE_VIEW (tree_view); self->progress_bar[key] = GTK_PROGRESS_BAR (gtk_builder_get_object (builder, "yt_progress_bar_related")); } g_object_set (tree_view, "totem", self->totem, NULL); g_signal_connect (vscroll, "button-press-event", G_CALLBACK (button_press_event_cb), self); g_signal_connect (vscroll, "button-release-event", G_CALLBACK (button_release_event_cb), self); /* Add the extra popup menu options. This is done here rather than in the UI file, because it's done for multiple treeviews; * if it were done in the UI file, the same action group would be used multiple times, which GTK+ doesn't like. */ ui_manager = totem_video_list_get_ui_manager (TOTEM_VIDEO_LIST (tree_view)); action_group = gtk_action_group_new ("youtube-action-group"); action = gtk_action_new ("open-in-web-browser", _("_Open in Web Browser"), _("Open the video in your web browser"), "gtk-jump-to"); gtk_action_group_add_action_with_accel (action_group, action, NULL); gtk_ui_manager_insert_action_group (ui_manager, action_group, 1); gtk_ui_manager_add_ui (ui_manager, gtk_ui_manager_new_merge_id (ui_manager), "/ui/totem-video-list-popup/", "open-in-web-browser", "open-in-web-browser", GTK_UI_MANAGER_MENUITEM, FALSE); menu_item = gtk_ui_manager_get_action (ui_manager, "/ui/totem-video-list-popup/open-in-web-browser"); g_signal_connect (menu_item, "activate", G_CALLBACK (open_in_web_browser_activate_cb), self); /* Connect to more scroll events */ #if GTK_CHECK_VERSION(3, 0, 0) self->vadjust[key] = gtk_scrollable_get_vadjustment(GTK_SCROLLABLE(tree_view)); #else self->vadjust[key] = gtk_tree_view_get_vadjustment(GTK_TREE_VIEW(tree_view)); #endif g_signal_connect (self->vadjust[key], "value-changed", G_CALLBACK (value_changed_cb), self); self->cancel_button = GTK_WIDGET (gtk_builder_get_object (builder, "yt_cancel_button")); }
/* Do the actual applet initialization */ static void init_wtapplet (PanelApplet *applet) { WTApplet *wtapplet = g_new0 (WTApplet, 1); wtapplet->applet = applet; wtapplet->prefs = loadPreferences(wtapplet); wtapplet->activescreen = wnck_screen_get_default(); wnck_screen_force_update(wtapplet->activescreen); wtapplet->activeworkspace = wnck_screen_get_active_workspace(wtapplet->activescreen); wtapplet->activewindow = wnck_screen_get_active_window(wtapplet->activescreen); wtapplet->umaxedwindow = getUpperMaximized(wtapplet); wtapplet->rootwindow = getRootWindow(wtapplet->activescreen); wtapplet->prefbuilder = gtk_builder_new(); wtapplet->box = GTK_BOX(gtk_hbox_new(FALSE, 0)); wtapplet->icon = GTK_IMAGE(gtk_image_new()); wtapplet->title = GTK_LABEL(gtk_label_new(NULL)); wtapplet->eb_icon = GTK_EVENT_BOX(gtk_event_box_new()); wtapplet->eb_title = GTK_EVENT_BOX(gtk_event_box_new()); wtapplet->orient = panel_applet_get_orient(wtapplet->applet); wtapplet->size_hints = g_new(gint,2); // Widgets to eventboxes, eventboxes to box gtk_widget_set_can_focus(GTK_WIDGET(wtapplet->icon), TRUE); gtk_widget_set_can_focus(GTK_WIDGET(wtapplet->title), TRUE); gtk_container_add (GTK_CONTAINER (wtapplet->eb_icon), GTK_WIDGET(wtapplet->icon)); gtk_container_add (GTK_CONTAINER (wtapplet->eb_title), GTK_WIDGET(wtapplet->title)); gtk_event_box_set_visible_window (wtapplet->eb_icon, FALSE); gtk_event_box_set_visible_window (wtapplet->eb_title, FALSE); // Rotate & place elements setAlignment(wtapplet, (gfloat)wtapplet->prefs->alignment); placeWidgets(wtapplet); // Add box to applet gtk_container_add (GTK_CONTAINER(wtapplet->applet), GTK_WIDGET(wtapplet->box)); // Set event handling (icon & title clicks) g_signal_connect(G_OBJECT (wtapplet->eb_icon), "button-press-event", G_CALLBACK (icon_clicked), wtapplet); g_signal_connect(G_OBJECT (wtapplet->eb_title), "button-press-event", G_CALLBACK (title_clicked), wtapplet); // Global window tracking g_signal_connect(wtapplet->activescreen, "active-window-changed", G_CALLBACK (active_window_changed), wtapplet); // <-- this thing is crashing with compiz !!! g_signal_connect(wtapplet->activescreen, "viewports-changed", G_CALLBACK (viewports_changed), wtapplet); g_signal_connect(wtapplet->activescreen, "active-workspace-changed", G_CALLBACK (active_workspace_changed), wtapplet); g_signal_connect(wtapplet->activescreen, "window-closed", G_CALLBACK (window_closed), wtapplet); g_signal_connect(wtapplet->activescreen, "window-opened", G_CALLBACK (window_opened), wtapplet); // g_signal_connect(G_OBJECT (wtapplet->title), "size-request", G_CALLBACK (applet_title_size_request), wtapplet); g_signal_connect(G_OBJECT (wtapplet->applet), "size-allocate", G_CALLBACK (applet_size_allocate), wtapplet); g_signal_connect(G_OBJECT (wtapplet->applet), "change-background", G_CALLBACK (applet_change_background), wtapplet); g_signal_connect(G_OBJECT (wtapplet->applet), "change-orient", G_CALLBACK (applet_change_orient), wtapplet); g_signal_connect(G_OBJECT (wtapplet->applet), "change-size", G_CALLBACK (applet_change_pixel_size), wtapplet); // Track active window changes wtapplet->active_handler_state = g_signal_connect(G_OBJECT (wtapplet->activewindow), "state-changed", G_CALLBACK (active_window_state_changed), wtapplet); wtapplet->active_handler_name = g_signal_connect(G_OBJECT (wtapplet->activewindow), "name-changed", G_CALLBACK (active_window_nameicon_changed), wtapplet); wtapplet->active_handler_icon = g_signal_connect(G_OBJECT (wtapplet->activewindow), "icon-changed", G_CALLBACK (active_window_nameicon_changed), wtapplet); // Setup applet right-click menu GtkActionGroup *action_group = gtk_action_group_new ("WindowButtons Applet Actions"); gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE); gtk_action_group_add_actions (action_group, windowtitle_menu_actions, G_N_ELEMENTS (windowtitle_menu_actions), wtapplet); panel_applet_setup_menu (applet, windowtitle_menu_items, action_group); panel_applet_set_background_widget (wtapplet->applet, GTK_WIDGET (wtapplet->applet)); // Automatic background update toggleExpand (wtapplet); toggleHidden (wtapplet); // Properly hide or show stuff updateTitle (wtapplet); }
static GtkWidget * do_appwindow (void) { GtkWidget *window; GtkWidget *table; GtkWidget *toolbar; GtkWidget *handlebox; GtkWidget *statusbar; GtkWidget *contents; GtkWidget *sw; GtkTextBuffer *buffer; #if GTK_CHECK_VERSION(3, 0, 0) GtkActionGroup *action_group; GtkUIManager *ui_manager; #else GtkAccelGroup *accel_group; GtkItemFactory *item_factory; #endif /* Create the toplevel window */ ++window_count; aspect_on = FALSE; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "Application Window"); g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (destroy_cb), NULL); table = gtk_table_new (1, 4, FALSE); gtk_container_add (GTK_CONTAINER (window), table); #if GTK_CHECK_VERSION(3, 0, 0) action_group = gtk_action_group_new("ActionGroups"); gtk_action_group_add_actions(action_group, entries, G_N_ELEMENTS(entries), NULL); ui_manager = gtk_ui_manager_new(); gtk_ui_manager_insert_action_group(ui_manager, action_group, 0); gtk_ui_manager_add_ui_from_string(ui_manager, ui_definition, -1, NULL); gtk_table_attach (GTK_TABLE (table), gtk_ui_manager_get_widget (ui_manager, "/MainMenuBar"), /* X direction */ /* Y direction */ 0, 1, 0, 1, GTK_EXPAND | GTK_FILL, 0, 0, 0); gtk_window_add_accel_group (GTK_WINDOW (window), gtk_ui_manager_get_accel_group (ui_manager)); #else /* Create the menubar */ accel_group = gtk_accel_group_new (); gtk_window_add_accel_group (GTK_WINDOW (window), accel_group); g_object_unref (accel_group); item_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", accel_group); /* Set up item factory to go away with the window */ g_object_ref (item_factory); g_object_ref_sink (item_factory); g_object_unref (item_factory); g_object_set_data_full (G_OBJECT (window), "<main>", item_factory, (GDestroyNotify) g_object_unref); /* create menu items */ gtk_item_factory_create_items (item_factory, G_N_ELEMENTS (menu_items), menu_items, window); gtk_table_attach (GTK_TABLE (table), gtk_item_factory_get_widget (item_factory, "<main>"), /* X direction */ /* Y direction */ 0, 1, 0, 1, GTK_EXPAND | GTK_FILL, 0, 0, 0); #endif /* Create document */ sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN); gtk_table_attach (GTK_TABLE (table), sw, /* X direction */ /* Y direction */ 0, 1, 2, 3, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); gtk_window_set_default_size (GTK_WINDOW (window), 200, 200); contents = gtk_text_view_new (); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (contents), PANGO_WRAP_WORD); gtk_container_add (GTK_CONTAINER (sw), contents); /* Create the toolbar */ toolbar = gtk_toolbar_new (); GtkToolItem *newButton = gtk_tool_button_new_from_stock(GTK_STOCK_NEW); gtk_tool_item_set_tooltip_text(newButton, "Open another one of these windows"); g_signal_connect(G_OBJECT(newButton), "clicked", G_CALLBACK(do_appwindow), window); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), newButton, -1); /*-1 means append to end of toolbar*/ GtkToolItem *lockButton = gtk_tool_button_new_from_stock(GTK_STOCK_OPEN); gtk_tool_item_set_tooltip_text(lockButton, "This is a demo button that locks up the demo"); g_signal_connect(G_OBJECT(lockButton), "clicked", G_CALLBACK(sleep_cb), window); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), lockButton, -1); /*-1 means append to end of toolbar*/ GtkToolItem *decoButton = gtk_tool_button_new_from_stock(GTK_STOCK_OPEN); gtk_tool_item_set_tooltip_text(decoButton, "This is a demo button that toggles window decorations"); g_signal_connect(G_OBJECT(decoButton), "clicked", G_CALLBACK(toggle_decorated_cb), window); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), decoButton, -1); /*-1 means append to end of toolbar*/ GtkToolItem *lockRatioButton = gtk_tool_button_new_from_stock(GTK_STOCK_OPEN); gtk_tool_item_set_tooltip_text(lockRatioButton, "This is a demo button that locks the aspect ratio using a hint"); g_signal_connect(G_OBJECT(lockRatioButton), "clicked", G_CALLBACK(toggle_aspect_ratio), window); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), lockRatioButton, -1); /*-1 means append to end of toolbar*/ GtkToolItem *quitButton = gtk_tool_button_new_from_stock(GTK_STOCK_QUIT); gtk_tool_item_set_tooltip_text(quitButton, "This is a demo button with a 'quit' icon"); g_signal_connect(G_OBJECT(quitButton), "clicked", G_CALLBACK(clicked_toolbar_cb), window); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), quitButton, -1); /*-1 means append to end of toolbar*/ handlebox = gtk_handle_box_new (); gtk_container_add (GTK_CONTAINER (handlebox), toolbar); gtk_table_attach (GTK_TABLE (table), handlebox, /* X direction */ /* Y direction */ 0, 1, 1, 2, GTK_EXPAND | GTK_FILL, 0, 0, 0); /* Create statusbar */ statusbar = gtk_statusbar_new (); gtk_table_attach (GTK_TABLE (table), statusbar, /* X direction */ /* Y direction */ 0, 1, 3, 4, GTK_EXPAND | GTK_FILL, 0, 0, 0); /* Show text widget info in the statusbar */ buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (contents)); gtk_text_buffer_set_text (buffer, "This demo demonstrates various kinds of windows that " "window managers and window manager themes should handle. " "Be sure to tear off the menu and toolbar, those are also " "a special kind of window.", -1); g_signal_connect_object (buffer, "changed", G_CALLBACK (update_statusbar), statusbar, 0); g_signal_connect_object (buffer, "mark_set", /* cursor moved */ G_CALLBACK (mark_set_callback), statusbar, 0); update_statusbar (buffer, GTK_STATUSBAR (statusbar)); gtk_widget_show_all (window); return window; }
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; }
static gboolean charpicker_applet_fill (MatePanelApplet *applet) { MatePanelAppletOrient orientation; charpick_data *curr_data; GdkAtom utf8_atom; GList *list; gchar *string; GtkActionGroup *action_group; gchar *ui_path; g_set_application_name (_("Character Palette")); gtk_window_set_default_icon_name ("accessories-character-map"); mate_panel_applet_set_background_widget (applet, GTK_WIDGET (applet)); mate_panel_applet_set_flags (applet, MATE_PANEL_APPLET_EXPAND_MINOR); curr_data = g_new0 (charpick_data, 1); curr_data->last_index = NO_LAST_INDEX; curr_data->applet = GTK_WIDGET (applet); curr_data->about_dialog = NULL; curr_data->add_edit_dialog = NULL; curr_data->settings = mate_panel_applet_settings_new (applet, "org.mate.panel.applet.charpick"); get_chartable (curr_data); string = g_settings_get_string (curr_data->settings, "current-list"); if (string) { list = curr_data->chartable; while (list) { if (g_ascii_strcasecmp (list->data, string) == 0) curr_data->charlist = list->data; list = g_list_next (list); } /* FIXME: yeah leak, but this code is full of leaks and evil point shuffling. This should really be rewritten -George */ if (curr_data->charlist == NULL) curr_data->charlist = string; else g_free (string); } else { curr_data->charlist = curr_data->chartable->data; } curr_data->panel_size = mate_panel_applet_get_size (applet); orientation = mate_panel_applet_get_orient (applet); curr_data->panel_vertical = (orientation == MATE_PANEL_APPLET_ORIENT_LEFT) || (orientation == MATE_PANEL_APPLET_ORIENT_RIGHT); build_table (curr_data); g_signal_connect (G_OBJECT (curr_data->applet), "key_press_event", G_CALLBACK (key_press_event), curr_data); utf8_atom = gdk_atom_intern ("UTF8_STRING", FALSE); gtk_selection_add_target (curr_data->applet, GDK_SELECTION_PRIMARY, utf8_atom, 0); gtk_selection_add_target (curr_data->applet, GDK_SELECTION_CLIPBOARD, utf8_atom, 0); g_signal_connect (G_OBJECT (curr_data->applet), "selection_get", G_CALLBACK (charpick_selection_handler), curr_data); g_signal_connect (G_OBJECT (curr_data->applet), "selection_clear_event", G_CALLBACK (selection_clear_cb), curr_data); make_applet_accessible (GTK_WIDGET (applet)); /* session save signal */ g_signal_connect (G_OBJECT (applet), "change_orient", G_CALLBACK (applet_change_orient), curr_data); g_signal_connect (G_OBJECT (applet), "size_allocate", G_CALLBACK (applet_size_allocate), curr_data); g_signal_connect (G_OBJECT (applet), "destroy", G_CALLBACK (applet_destroy), curr_data); gtk_widget_show_all (GTK_WIDGET (applet)); action_group = gtk_action_group_new ("Charpicker Applet Actions"); gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE); gtk_action_group_add_actions (action_group, charpick_applet_menu_actions, G_N_ELEMENTS (charpick_applet_menu_actions), curr_data); ui_path = g_build_filename (CHARPICK_MENU_UI_DIR, "charpick-applet-menu.xml", NULL); mate_panel_applet_setup_menu_from_file (MATE_PANEL_APPLET (applet), ui_path, action_group); g_free (ui_path); if (mate_panel_applet_get_locked_down (MATE_PANEL_APPLET (applet))) { GtkAction *action; action = gtk_action_group_get_action (action_group, "Preferences"); gtk_action_set_visible (action, FALSE); } g_object_unref (action_group); register_stock_for_edit (); populate_menu (curr_data); return TRUE; }
void e_composer_private_constructed (EMsgComposer *composer) { EMsgComposerPrivate *priv = composer->priv; EFocusTracker *focus_tracker; EComposerHeader *header; EShell *shell; EClientCache *client_cache; EHTMLEditor *editor; EHTMLEditorView *view; GtkUIManager *ui_manager; GtkAction *action; GtkWidget *container; GtkWidget *widget; GtkWidget *send_widget; GtkWindow *window; GSettings *settings; const gchar *path; gchar *filename, *gallery_path; gint ii; GError *error = NULL; editor = e_msg_composer_get_editor (composer); ui_manager = e_html_editor_get_ui_manager (editor); view = e_html_editor_get_view (editor); settings = e_util_ref_settings ("org.gnome.evolution.mail"); shell = e_msg_composer_get_shell (composer); client_cache = e_shell_get_client_cache (shell); /* Each composer window gets its own window group. */ window = GTK_WINDOW (composer); priv->window_group = gtk_window_group_new (); gtk_window_group_add_window (priv->window_group, window); priv->async_actions = gtk_action_group_new ("async"); priv->charset_actions = gtk_action_group_new ("charset"); priv->composer_actions = gtk_action_group_new ("composer"); priv->extra_hdr_names = g_ptr_array_new (); priv->extra_hdr_values = g_ptr_array_new (); priv->charset = e_composer_get_default_charset (); priv->is_from_new_message = FALSE; priv->set_signature_from_message = FALSE; priv->disable_signature = FALSE; priv->busy = FALSE; priv->saved_editable = FALSE; priv->drop_occured = FALSE; priv->dnd_is_uri = FALSE; priv->check_if_signature_is_changed = FALSE; priv->ignore_next_signature_change = FALSE; priv->dnd_history_saved = FALSE; priv->focused_entry = NULL; e_composer_actions_init (composer); filename = e_composer_find_data_file ("evolution-composer.ui"); gtk_ui_manager_add_ui_from_file (ui_manager, filename, &error); g_free (filename); /* We set the send button as important to have a label */ path = "/main-toolbar/pre-main-toolbar/send"; send_widget = gtk_ui_manager_get_widget (ui_manager, path); gtk_tool_item_set_is_important (GTK_TOOL_ITEM (send_widget), TRUE); composer_setup_charset_menu (composer); if (error != NULL) { /* Henceforth, bad things start happening. */ g_critical ("%s", error->message); g_clear_error (&error); } /* Configure an EFocusTracker to manage selection actions. */ focus_tracker = e_focus_tracker_new (GTK_WINDOW (composer)); action = e_html_editor_get_action (editor, "cut"); e_focus_tracker_set_cut_clipboard_action (focus_tracker, action); action = e_html_editor_get_action (editor, "copy"); e_focus_tracker_set_copy_clipboard_action (focus_tracker, action); action = e_html_editor_get_action (editor, "paste"); e_focus_tracker_set_paste_clipboard_action (focus_tracker, action); action = e_html_editor_get_action (editor, "select-all"); e_focus_tracker_set_select_all_action (focus_tracker, action); action = e_html_editor_get_action (editor, "undo"); e_focus_tracker_set_undo_action (focus_tracker, action); action = e_html_editor_get_action (editor, "redo"); e_focus_tracker_set_redo_action (focus_tracker, action); priv->focus_tracker = focus_tracker; widget = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_add (GTK_CONTAINER (composer), widget); gtk_widget_show (widget); container = widget; /* Construct the main menu and toolbar. */ widget = e_html_editor_get_managed_widget (editor, "/main-menu"); gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0); gtk_widget_show (widget); widget = e_html_editor_get_managed_widget (editor, "/main-toolbar"); gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0); gtk_widget_show (widget); /* Construct the header table. */ widget = e_composer_header_table_new (client_cache); gtk_container_set_border_width (GTK_CONTAINER (widget), 6); gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0); priv->header_table = g_object_ref (widget); gtk_widget_show (widget); header = e_composer_header_table_get_header ( E_COMPOSER_HEADER_TABLE (widget), E_COMPOSER_HEADER_SUBJECT); e_binding_bind_property ( view, "spell-checker", header->input_widget, "spell-checker", G_BINDING_SYNC_CREATE); /* Construct the editing toolbars. We'll have to reparent * the embedded EHTMLEditorView a little further down. */ widget = GTK_WIDGET (editor); gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0); gtk_widget_show (widget); /* Construct the attachment paned. */ widget = e_attachment_paned_new (); gtk_box_pack_start (GTK_BOX (container), widget, TRUE, TRUE, 0); priv->attachment_paned = g_object_ref_sink (widget); gtk_widget_show (widget); e_binding_bind_property ( view, "editable", widget, "sensitive", G_BINDING_SYNC_CREATE); container = e_attachment_paned_get_content_area ( E_ATTACHMENT_PANED (priv->attachment_paned)); widget = gtk_paned_new (GTK_ORIENTATION_VERTICAL); gtk_box_pack_start (GTK_BOX (container), widget, TRUE, TRUE, 0); gtk_widget_show (widget); container = widget; widget = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW (widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_size_request (widget, -1, GALLERY_INITIAL_HEIGHT); gtk_paned_pack1 (GTK_PANED (container), widget, FALSE, FALSE); priv->gallery_scrolled_window = g_object_ref (widget); gtk_widget_show (widget); /* Reparent the scrolled window containing the web view * widget into the content area of the top attachment pane. */ widget = GTK_WIDGET (view); widget = gtk_widget_get_parent (widget); gtk_widget_reparent (widget, container); /* Construct the picture gallery. */ container = priv->gallery_scrolled_window; /* FIXME This should be an EMsgComposer property. */ gallery_path = g_settings_get_string ( settings, "composer-gallery-path"); widget = e_picture_gallery_new (gallery_path); gtk_container_add (GTK_CONTAINER (container), widget); priv->gallery_icon_view = g_object_ref_sink (widget); g_free (gallery_path); e_signal_connect_notify_swapped ( view, "notify::mode", G_CALLBACK (composer_update_gallery_visibility), composer); g_signal_connect_swapped ( ACTION (PICTURE_GALLERY), "toggled", G_CALLBACK (composer_update_gallery_visibility), composer); /* Initial sync */ composer_update_gallery_visibility (composer); /* Bind headers to their corresponding actions. */ for (ii = 0; ii < E_COMPOSER_NUM_HEADERS; ii++) { EComposerHeaderTable *table; EComposerHeader *header; GtkAction *action; table = E_COMPOSER_HEADER_TABLE (priv->header_table); header = e_composer_header_table_get_header (table, ii); switch (ii) { case E_COMPOSER_HEADER_FROM: e_widget_undo_attach ( GTK_WIDGET (e_composer_from_header_get_name_entry (E_COMPOSER_FROM_HEADER (header))), focus_tracker); e_widget_undo_attach ( GTK_WIDGET (e_composer_from_header_get_address_entry (E_COMPOSER_FROM_HEADER (header))), focus_tracker); action = ACTION (VIEW_FROM_OVERRIDE); e_binding_bind_property ( header, "override-visible", action, "active", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); continue; case E_COMPOSER_HEADER_BCC: action = ACTION (VIEW_BCC); break; case E_COMPOSER_HEADER_CC: action = ACTION (VIEW_CC); break; case E_COMPOSER_HEADER_REPLY_TO: action = ACTION (VIEW_REPLY_TO); e_widget_undo_attach ( GTK_WIDGET (header->input_widget), focus_tracker); break; case E_COMPOSER_HEADER_SUBJECT: e_widget_undo_attach ( GTK_WIDGET (header->input_widget), focus_tracker); continue; default: continue; } e_binding_bind_property ( header, "sensitive", action, "sensitive", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); e_binding_bind_property ( header, "visible", action, "active", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); } /* Disable actions that start asynchronous activities while an * asynchronous activity is in progress. We enforce this with * a simple inverted binding to EMsgComposer's "busy" property. */ e_binding_bind_property ( composer, "busy", priv->async_actions, "sensitive", G_BINDING_SYNC_CREATE | G_BINDING_INVERT_BOOLEAN); e_binding_bind_property ( composer, "busy", priv->header_table, "sensitive", G_BINDING_SYNC_CREATE | G_BINDING_INVERT_BOOLEAN); g_object_unref (settings); }
static GtkWidget * normal_contents (void) { GtkWidget *table; GtkWidget *handlebox; GtkWidget *statusbar; GtkWidget *contents; GtkWidget *sw; GtkActionGroup *action_group; GtkUIManager *ui_manager; table = gtk_table_new (1, 4, FALSE); /* Create the menubar */ action_group = gtk_action_group_new ("mainmenu"); gtk_action_group_add_actions (action_group, menu_items, G_N_ELEMENTS (menu_items), NULL); gtk_action_group_add_actions (action_group, tool_items, G_N_ELEMENTS (tool_items), NULL); ui_manager = gtk_ui_manager_new (); gtk_ui_manager_insert_action_group (ui_manager, action_group, 0); /* create menu items */ gtk_ui_manager_add_ui_from_string (ui_manager, menu_item_string, -1, NULL); gtk_table_attach (GTK_TABLE (table), gtk_ui_manager_get_widget (ui_manager, "/ui/menubar"), /* X direction */ /* Y direction */ 0, 1, 0, 1, GTK_EXPAND | GTK_FILL, 0, 0, 0); handlebox = gtk_handle_box_new (); gtk_container_add (GTK_CONTAINER (handlebox), gtk_ui_manager_get_widget (ui_manager, "/ui/toolbar")); gtk_table_attach (GTK_TABLE (table), handlebox, /* X direction */ /* Y direction */ 0, 1, 1, 2, GTK_EXPAND | GTK_FILL, 0, 0, 0); /* Create document */ sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN); gtk_table_attach (GTK_TABLE (table), sw, /* X direction */ /* Y direction */ 0, 1, 2, 3, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); contents = gtk_text_view_new (); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (contents), PANGO_WRAP_WORD); gtk_container_add (GTK_CONTAINER (sw), contents); /* Create statusbar */ statusbar = gtk_statusbar_new (); gtk_table_attach (GTK_TABLE (table), statusbar, /* X direction */ /* Y direction */ 0, 1, 3, 4, GTK_EXPAND | GTK_FILL, 0, 0, 0); gtk_widget_show_all (table); g_object_unref (ui_manager); return table; }
int lassi_tray_init(LassiTrayInfo *i, LassiServer *server) { GtkActionEntry entries[] = { #if GTK_CHECK_VERSION(2,14,0) {"Help", GTK_STOCK_HELP, NULL, NULL, NULL, G_CALLBACK (on_help_activate)}, #endif {"Preferences", GTK_STOCK_PREFERENCES, NULL, NULL, NULL, G_CALLBACK (on_prefs_activate)}, {"Quit", GTK_STOCK_QUIT, NULL, NULL, NULL, G_CALLBACK (gtk_main_quit)} }; GtkActionGroup *actions; GError *error = NULL; g_assert(i); g_assert(server); memset(i, 0, sizeof(*i)); i->server = server; notify_init("Mango Lassi"); i->status_icon = gtk_status_icon_new_from_icon_name(ICON_IDLE); i->ui_manager = gtk_ui_manager_new (); actions = gtk_action_group_new ("mango-lassi-popup"); gtk_action_group_add_actions (actions, entries, G_N_ELEMENTS (entries), i); gtk_ui_manager_insert_action_group (i->ui_manager, actions, -1); gtk_ui_manager_add_ui_from_string (i->ui_manager, "<popup>" "<menuitem action='Preferences'/>" #if GTK_CHECK_VERSION(2,14,0) "<menuitem action='Help'/>" #endif "<separator />" "<menuitem action='Quit'/>" "</popup>", -1, &error); if (error) { GtkWidget* dialog = gtk_message_dialog_new (NULL, 0, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "%s", _("Initialization Error")); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog), _("Cannot initialize the user interface: %s"), error->message); g_error_free (error); gtk_dialog_run (GTK_DIALOG (dialog)); gtk_widget_destroy (dialog); return 1; } i->menu = gtk_ui_manager_get_widget (i->ui_manager, "/ui/popup"); g_signal_connect(G_OBJECT(i->status_icon), "popup_menu", G_CALLBACK(on_tray_popup_menu), i); g_signal_connect(G_OBJECT(i->status_icon), "activate", G_CALLBACK(on_tray_activate), i); lassi_tray_update(i, 0); return 0; }
GtkWidget *gui_build_interface(void) { GtkWidget *vbox; GtkWidget *menubar; GtkActionGroup *action_group; GtkAccelGroup *accel_group; GError *error = NULL; gchar *icon_file; player_init(); gmap = guimap_new(); register_pixmaps(); app_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); /* The name of the application */ gtk_window_set_title(GTK_WINDOW(app_window), _("Pioneers")); vbox = gtk_vbox_new(FALSE, 0); gtk_widget_show(vbox); gtk_container_add(GTK_CONTAINER(app_window), vbox); action_group = gtk_action_group_new("MenuActions"); gtk_action_group_set_translation_domain(action_group, PACKAGE); gtk_action_group_add_actions(action_group, entries, G_N_ELEMENTS(entries), app_window); gtk_action_group_add_toggle_actions(action_group, toggle_entries, G_N_ELEMENTS(toggle_entries), app_window); ui_manager = gtk_ui_manager_new(); gtk_ui_manager_insert_action_group(ui_manager, action_group, 0); accel_group = gtk_ui_manager_get_accel_group(ui_manager); gtk_window_add_accel_group(GTK_WINDOW(app_window), accel_group); error = NULL; if (!gtk_ui_manager_add_ui_from_string (ui_manager, ui_description, -1, &error)) { g_message("building menus failed: %s", error->message); g_error_free(error); return NULL; } icon_file = g_build_filename(DATADIR, "pixmaps", PIONEERS_ICON_FILE, NULL); if (g_file_test(icon_file, G_FILE_TEST_EXISTS)) { gtk_window_set_default_icon_from_file(icon_file, NULL); } else { /* Missing pixmap, main icon file */ g_warning("Pixmap not found: %s", icon_file); } g_free(icon_file); color_chat_enabled = config_get_int_with_default("settings/color_chat", TRUE); color_messages_enabled = config_get_int_with_default("settings/color_messages", TRUE); log_set_func_message_color_enable(color_messages_enabled); set_color_summary(config_get_int_with_default ("settings/color_summary", TRUE)); set_silent_mode(config_get_int_with_default ("settings/silent_mode", FALSE)); set_announce_player(config_get_int_with_default ("settings/announce_player", TRUE)); legend_page_enabled = config_get_int_with_default("settings/legend_page", FALSE); menubar = gtk_ui_manager_get_widget(ui_manager, "/MainMenu"); gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0); toolbar = gtk_ui_manager_get_widget(ui_manager, "/MainToolbar"); gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox), build_main_interface(), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox), build_status_bar(), FALSE, FALSE, 0); gtk_toggle_action_set_active(GTK_TOGGLE_ACTION (gtk_ui_manager_get_action (ui_manager, "ui/MainMenu/SettingsMenu/ShowHideToolbar")), config_get_int_with_default ("settings/show_toolbar", TRUE)); g_signal_connect(G_OBJECT(app_window), "key_press_event", G_CALLBACK(hotkeys_handler), NULL); gtk_widget_show(app_window); frontend_gui_register_action(getAction(GUI_CONNECT), GUI_CONNECT); frontend_gui_register_action(getAction(GUI_DISCONNECT), GUI_DISCONNECT); #ifdef ADMIN_GTK /** @todo RC 2005-05-26 Admin interface: Not tested */ frontend_gui_register_action(gtk_ui_manager_get_action (manager, "ui/MainMenu/GameMenu/GameAdmin"), GUI_ADMIN); #endif frontend_gui_register_action(getAction(GUI_CHANGE_NAME), GUI_CHANGE_NAME); frontend_gui_register_action(getAction(GUI_ROLL), GUI_ROLL); frontend_gui_register_action(getAction(GUI_TRADE), GUI_TRADE); frontend_gui_register_action(getAction(GUI_UNDO), GUI_UNDO); frontend_gui_register_action(getAction(GUI_FINISH), GUI_FINISH); frontend_gui_register_action(getAction(GUI_ROAD), GUI_ROAD); frontend_gui_register_action(getAction(GUI_SHIP), GUI_SHIP); frontend_gui_register_action(getAction(GUI_MOVE_SHIP), GUI_MOVE_SHIP); frontend_gui_register_action(getAction(GUI_BRIDGE), GUI_BRIDGE); frontend_gui_register_action(getAction(GUI_SETTLEMENT), GUI_SETTLEMENT); frontend_gui_register_action(getAction(GUI_CITY), GUI_CITY); frontend_gui_register_action(getAction(GUI_BUY_DEVELOP), GUI_BUY_DEVELOP); frontend_gui_register_action(getAction(GUI_CITY_WALL), GUI_CITY_WALL); #if 0 frontend_gui_register_destroy(gtk_ui_manager_get_action (manager, "GameQuit"), GUI_QUIT); #endif gui_toolbar_show_button("BuildShip", FALSE); gui_toolbar_show_button("MoveShip", FALSE); gui_toolbar_show_button("BuildBridge", FALSE); gui_toolbar_show_accelerators(config_get_int_with_default ("settings/toolbar_show_accelerators", TRUE)); gtk_ui_manager_ensure_update(ui_manager); gtk_widget_show(app_window); g_signal_connect(G_OBJECT(app_window), "delete_event", G_CALLBACK(quit_cb), NULL); return app_window; }
static void show_view_activate (PlannerView *view) { PlannerShowViewPriv *priv; gboolean show_critical, show_nostd_days, show_guidelines; gchar *filename; priv = PLANNER_SHOW_VIEW (view)->priv; priv->actions = gtk_action_group_new ("ShowView"); gtk_action_group_set_translation_domain (priv->actions, GETTEXT_PACKAGE); gtk_action_group_add_actions (priv->actions, entries, G_N_ELEMENTS (entries), view); gtk_action_group_add_toggle_actions (priv->actions, toggle_entries, G_N_ELEMENTS (toggle_entries), view); gtk_ui_manager_insert_action_group (priv->ui_manager, priv->actions, 0); filename = mrp_paths_get_ui_dir ("show-view.ui"); priv->merged_id = gtk_ui_manager_add_ui_from_file (priv->ui_manager, filename, NULL); g_free (filename); gtk_ui_manager_ensure_update (priv->ui_manager); /* Set the initial UI state. */ show_critical = planner_gantt_chart_get_highlight_critical_tasks ( PLANNER_GANTT_CHART (priv->gantt)); show_nostd_days = planner_gantt_chart_get_nonstandard_days ( PLANNER_GANTT_CHART (priv->gantt)); show_guidelines = planner_gantt_chart_get_show_guidelines ( PLANNER_GANTT_CHART (priv->gantt)); planner_task_tree_set_highlight_critical (PLANNER_TASK_TREE (priv->tree), show_critical); planner_task_tree_set_nonstandard_days (PLANNER_TASK_TREE (priv->tree), show_nostd_days); gtk_toggle_action_set_active ( GTK_TOGGLE_ACTION (gtk_action_group_get_action (priv->actions, "HighlightCriticalTasks")), show_critical); gtk_toggle_action_set_active ( GTK_TOGGLE_ACTION (gtk_action_group_get_action (priv->actions, "NonstandardDays")), show_nostd_days); gtk_toggle_action_set_active ( GTK_TOGGLE_ACTION (gtk_action_group_get_action (priv->actions, "ShowGuideLines")), show_guidelines); show_view_selection_changed_cb (PLANNER_TASK_TREE (priv->tree), PLANNER_SHOW_VIEW (view)); show_view_update_zoom_sensitivity (PLANNER_SHOW_VIEW (view)); gtk_widget_grab_focus (priv->gantt); }
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; }
int main (int argc, char **argv) { /**********************************************************************************/ /* DAEMON SETUP */ /* Our process ID and Session ID */ pid_t pid, sid; /* Fork off the parent process */ pid = fork(); if (pid < 0) exit(EXIT_FAILURE); /* If we got a good PID, then we can exit the parent process. */ if (pid > 0) exit(EXIT_SUCCESS); /* Change the file mode mask */ umask(0); /* Open any logs here */ /* Create a new SID for the child process */ sid = setsid(); if (sid < 0) exit(EXIT_FAILURE); /* Change the current working directory */ if ((chdir("/")) < 0) exit(EXIT_FAILURE); /* Close out the standard file descriptors */ close(STDIN_FILENO); close(STDOUT_FILENO); close(STDERR_FILENO); /**********************************************************************************/ /* PROGRAM */ /* define variables gtk*/ GtkWidget *window; GtkWidget *indicator_menu; GtkActionGroup *action_group; GtkUIManager *uim; GError *error = NULL; AppIndicator *indicator; /* define custum variables */ int status = atoi(argv[1]); /* gtk init with no args */ gtk_init (0, NULL); /* main window */ window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "Gnus Indicator"); g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (gtk_main_quit), NULL); /* Menus */ action_group = gtk_action_group_new ("AppActions"); gtk_action_group_add_actions (action_group, entries, n_entries, window); uim = gtk_ui_manager_new (); gtk_ui_manager_insert_action_group (uim, action_group, 0); if (!gtk_ui_manager_add_ui_from_string (uim, ui_info, -1, &error)) { g_message ("Failed to build menus: %s\n", error->message); g_error_free (error); error = NULL; } /* Indicator */ indicator_menu = gtk_ui_manager_get_widget (uim, "/ui/IndicatorPopup"); indicator = app_indicator_new ("example-simple-client", "/usr/share/pixmaps/gnome-gnus.png", APP_INDICATOR_CATEGORY_APPLICATION_STATUS); app_indicator_set_attention_icon(indicator, "/usr/share/pixmaps/gnome-gnus-new.png"); app_indicator_set_menu (indicator, GTK_MENU (indicator_menu)); /* set status */ if(status == 0) app_indicator_set_status (indicator, APP_INDICATOR_STATUS_ACTIVE); else if(status == 1) app_indicator_set_status (indicator, APP_INDICATOR_STATUS_ATTENTION); else app_indicator_set_status (indicator, APP_INDICATOR_STATUS_PASSIVE); gtk_main(); return 0; }
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; }
gboolean workspace_switcher_applet_fill(MatePanelApplet* applet) { PagerData* pager; GtkActionGroup* action_group; gchar* ui_path; gboolean display_names; #if GTK_CHECK_VERSION (3, 0, 0) GtkCssProvider *provider; #endif pager = g_new0(PagerData, 1); pager->applet = GTK_WIDGET(applet); mate_panel_applet_set_flags(MATE_PANEL_APPLET(pager->applet), MATE_PANEL_APPLET_EXPAND_MINOR); setup_gsettings(pager); pager->n_rows = g_settings_get_int(pager->settings, "num-rows"); pager->n_rows = CLAMP(pager->n_rows, 1, MAX_REASONABLE_ROWS); display_names = g_settings_get_boolean(pager->settings, "display-workspace-names"); pager->wrap_workspaces = g_settings_get_boolean(pager->settings, "wrap-workspaces"); if (display_names) { pager->display_mode = WNCK_PAGER_DISPLAY_NAME; } else { pager->display_mode = WNCK_PAGER_DISPLAY_CONTENT; } pager->display_all = g_settings_get_boolean(pager->settings, "display-all-workspaces"); switch (mate_panel_applet_get_orient(applet)) { case MATE_PANEL_APPLET_ORIENT_LEFT: case MATE_PANEL_APPLET_ORIENT_RIGHT: pager->orientation = GTK_ORIENTATION_VERTICAL; break; case MATE_PANEL_APPLET_ORIENT_UP: case MATE_PANEL_APPLET_ORIENT_DOWN: default: pager->orientation = GTK_ORIENTATION_HORIZONTAL; break; } #ifdef WNCK_CHECK_VERSION #if WNCK_CHECK_VERSION (3, 0, 0) pager->pager = wnck_pager_new(); #else pager->pager = wnck_pager_new(NULL); #endif #else pager->pager = wnck_pager_new(NULL); #endif pager->screen = NULL; pager->wm = PAGER_WM_UNKNOWN; wnck_pager_set_shadow_type(WNCK_PAGER(pager->pager), GTK_SHADOW_IN); #if GTK_CHECK_VERSION (3, 0, 0) GtkStyleContext *context; context = gtk_widget_get_style_context (GTK_WIDGET (applet)); gtk_style_context_add_class (context, "wnck-applet"); context = gtk_widget_get_style_context (pager->pager); gtk_style_context_add_class (context, "wnck-pager"); provider = gtk_css_provider_new (); gtk_css_provider_load_from_data (provider, ".wnck-pager:selected {\n" "background-color: #4A90D9; }", -1, NULL); gtk_style_context_add_provider (context, GTK_STYLE_PROVIDER (provider), GTK_STYLE_PROVIDER_PRIORITY_FALLBACK); g_object_unref (provider); #endif g_signal_connect(G_OBJECT(pager->pager), "destroy", G_CALLBACK(destroy_pager), pager); gtk_container_add(GTK_CONTAINER(pager->applet), pager->pager); gtk_widget_show(pager->pager); g_signal_connect(G_OBJECT(pager->applet), "realize", G_CALLBACK(applet_realized), pager); g_signal_connect(G_OBJECT(pager->applet), "unrealize", G_CALLBACK(applet_unrealized), pager); g_signal_connect(G_OBJECT(pager->applet), "change_orient", G_CALLBACK(applet_change_orient), pager); #if !GTK_CHECK_VERSION (3, 0, 0) g_signal_connect(G_OBJECT(pager->applet), "scroll-event", G_CALLBACK(applet_scroll), pager); #endif g_signal_connect(G_OBJECT(pager->applet), "change_background", G_CALLBACK(applet_change_background), pager); gtk_widget_show(pager->applet); mate_panel_applet_set_background_widget(MATE_PANEL_APPLET(pager->applet), GTK_WIDGET(pager->applet)); action_group = gtk_action_group_new("WorkspaceSwitcher Applet Actions"); gtk_action_group_set_translation_domain(action_group, GETTEXT_PACKAGE); gtk_action_group_add_actions(action_group, pager_menu_actions, G_N_ELEMENTS(pager_menu_actions), pager); ui_path = g_build_filename(WNCK_MENU_UI_DIR, "workspace-switcher-menu.xml", NULL); mate_panel_applet_setup_menu_from_file(MATE_PANEL_APPLET(pager->applet), ui_path, action_group); g_free(ui_path); if (mate_panel_applet_get_locked_down(MATE_PANEL_APPLET(pager->applet))) { GtkAction *action; action = gtk_action_group_get_action(action_group, "PagerPreferences"); gtk_action_set_visible(action, FALSE); } g_object_unref(action_group); return TRUE; }
static void mail_browser_constructed (GObject *object) { EMailBrowser *browser; EMailReader *reader; EMailBackend *backend; EMailSession *session; EShellBackend *shell_backend; EShell *shell; EFocusTracker *focus_tracker; GtkAccelGroup *accel_group; GtkActionGroup *action_group; GtkAction *action; GtkUIManager *ui_manager; GtkWidget *container; GtkWidget *display; GtkWidget *widget; const gchar *domain; const gchar *id; guint merge_id; /* Chain up to parent's constructed() method. */ G_OBJECT_CLASS (e_mail_browser_parent_class)->constructed (object); browser = E_MAIL_BROWSER (object); reader = E_MAIL_READER (object); backend = e_mail_reader_get_backend (reader); session = e_mail_backend_get_session (backend); shell_backend = E_SHELL_BACKEND (backend); shell = e_shell_backend_get_shell (shell_backend); ui_manager = gtk_ui_manager_new (); browser->priv->ui_manager = ui_manager; domain = GETTEXT_PACKAGE; gtk_application_add_window ( GTK_APPLICATION (shell), GTK_WINDOW (object)); /* The message list is a widget, but it is not shown in the browser. * Unfortunately, the widget is inseparable from its model, and the * model is all we need. */ browser->priv->message_list = message_list_new (session); g_object_ref_sink (browser->priv->message_list); g_signal_connect_swapped ( browser->priv->message_list, "message-selected", G_CALLBACK (mail_browser_message_selected_cb), object); g_signal_connect_swapped ( browser->priv->message_list, "message-list-built", G_CALLBACK (mail_browser_message_list_built_cb), object); display = e_mail_display_new (e_mail_backend_get_remote_content (backend)); e_mail_display_set_mode ( E_MAIL_DISPLAY (display), browser->priv->display_mode); g_signal_connect_swapped ( display, "popup-event", G_CALLBACK (mail_browser_popup_event_cb), object); g_signal_connect_swapped ( display, "status-message", G_CALLBACK (mail_browser_status_message_cb), object); widget = e_preview_pane_new (E_WEB_VIEW (display)); browser->priv->preview_pane = g_object_ref (widget); gtk_widget_show (widget); action_group = gtk_action_group_new (ACTION_GROUP_STANDARD); gtk_action_group_set_translation_domain (action_group, domain); gtk_action_group_add_actions ( action_group, mail_browser_entries, G_N_ELEMENTS (mail_browser_entries), object); e_action_group_add_popup_actions ( action_group, mail_browser_popup_entries, G_N_ELEMENTS (mail_browser_popup_entries)); gtk_ui_manager_insert_action_group (ui_manager, action_group, 0); /* For easy access. Takes ownership of the reference. */ g_object_set_data_full ( object, ACTION_GROUP_STANDARD, action_group, (GDestroyNotify) g_object_unref); action_group = gtk_action_group_new (ACTION_GROUP_SEARCH_FOLDERS); gtk_action_group_set_translation_domain (action_group, domain); gtk_ui_manager_insert_action_group (ui_manager, action_group, 0); /* For easy access. Takes ownership of the reference. */ g_object_set_data_full ( object, ACTION_GROUP_SEARCH_FOLDERS, action_group, (GDestroyNotify) g_object_unref); e_mail_reader_init (reader, TRUE, TRUE); e_load_ui_manager_definition (ui_manager, E_MAIL_READER_UI_DEFINITION); gtk_ui_manager_add_ui_from_string (ui_manager, ui, -1, NULL); merge_id = gtk_ui_manager_new_merge_id (ui_manager); e_mail_reader_create_charset_menu (reader, ui_manager, merge_id); accel_group = gtk_ui_manager_get_accel_group (ui_manager); gtk_window_add_accel_group (GTK_WINDOW (object), accel_group); g_signal_connect_swapped ( ui_manager, "connect-proxy", G_CALLBACK (mail_browser_connect_proxy_cb), object); e_mail_reader_connect_remote_content (reader); /* Configure an EFocusTracker to manage selection actions. */ focus_tracker = e_focus_tracker_new (GTK_WINDOW (object)); action = e_mail_reader_get_action (reader, "cut-clipboard"); e_focus_tracker_set_cut_clipboard_action (focus_tracker, action); action = e_mail_reader_get_action (reader, "copy-clipboard"); e_focus_tracker_set_copy_clipboard_action (focus_tracker, action); action = e_mail_reader_get_action (reader, "paste-clipboard"); e_focus_tracker_set_paste_clipboard_action (focus_tracker, action); action = e_mail_reader_get_action (reader, "select-all"); e_focus_tracker_set_select_all_action (focus_tracker, action); browser->priv->focus_tracker = focus_tracker; /* Construct window widgets. */ widget = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_add (GTK_CONTAINER (object), widget); gtk_widget_show (widget); container = widget; widget = gtk_statusbar_new (); gtk_box_pack_end (GTK_BOX (container), widget, FALSE, FALSE, 0); browser->priv->statusbar = g_object_ref (widget); gtk_widget_show (widget); widget = gtk_ui_manager_get_widget (ui_manager, "/main-menu"); gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0); browser->priv->main_menu = g_object_ref (widget); gtk_widget_show (widget); widget = gtk_ui_manager_get_widget (ui_manager, "/main-toolbar"); gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0); browser->priv->main_toolbar = g_object_ref (widget); gtk_widget_show (widget); gtk_style_context_add_class ( gtk_widget_get_style_context (widget), GTK_STYLE_CLASS_PRIMARY_TOOLBAR); gtk_box_pack_start ( GTK_BOX (container), browser->priv->preview_pane, TRUE, TRUE, 0); id = "org.gnome.evolution.mail.browser"; e_plugin_ui_register_manager (ui_manager, id, object); e_plugin_ui_enable_manager (ui_manager, id); e_extensible_load_extensions (E_EXTENSIBLE (object)); }
void gui_create_tasks(GUI *appGUI) { GtkWidget *vbox1; GtkWidget *vbox2; GtkWidget *table; GtkWidget *label; GtkWidget *top_scrolledwindow; GtkWidget *hseparator; GtkWidget *close_button; GtkCellRenderer *renderer; GtkWidget *top_viewport; GtkWidget *bottom_viewport; GtkTextBuffer *text_buffer; GError *error = NULL; GtkActionGroup *action_group = NULL; gchar tmpbuf[BUFFER_SIZE]; const gchar *ui_info = " <toolbar name=\"toolbar\">\n" " <toolitem name=\"add\" action=\"add\" />\n" " <toolitem name=\"delete\" action=\"delete\" />\n" " <separator name=\"sep1\" />\n" " <toolitem name=\"edit\" action=\"edit\" />\n" " </toolbar>\n"; GtkActionEntry entries[] = { { "add", OSMO_STOCK_TASKS_ADD, _("New task"), NULL, _("New task"), NULL }, { "edit", OSMO_STOCK_TASKS_EDIT, _("Edit task"), NULL, _("Edit task"), NULL }, { "delete", OSMO_STOCK_TASKS_REMOVE, _("Remove task"), NULL, _("Remove task"), NULL }, }; guint n_entries = G_N_ELEMENTS (entries); appGUI->tsk->filter_index = 0; label = gtk_label_new(NULL); gtk_label_set_angle (GTK_LABEL(label), -90.0); sprintf(tmpbuf, "<b>%s</b>", _("Tasks")); gtk_label_set_markup (GTK_LABEL (label), tmpbuf); vbox1 = gtk_vbox_new (FALSE, 1); gtk_widget_show (vbox1); gtk_container_set_border_width (GTK_CONTAINER (vbox1), 8); gtk_notebook_append_page(GTK_NOTEBOOK(appGUI->notebook), vbox1, label); appGUI->tsk->vbox = GTK_BOX(vbox1); /*-------------------------------------------------------------------------------------*/ action_group = gtk_action_group_new ("_actions"); gtk_action_group_add_actions (action_group, entries, n_entries, NULL); gtk_action_group_set_sensitive(action_group, TRUE); appGUI->tsk->tasks_uim_widget = gtk_ui_manager_new (); gtk_ui_manager_insert_action_group (appGUI->tsk->tasks_uim_widget, action_group, 0); g_signal_connect (appGUI->tsk->tasks_uim_widget, "add_widget", G_CALLBACK (add_tasks_toolbar_widget), appGUI); if (!gtk_ui_manager_add_ui_from_string (appGUI->tsk->tasks_uim_widget, ui_info, -1, &error)) { g_message ("building toolbar failed: %s", error->message); g_error_free (error); } gtk_ui_manager_ensure_update (appGUI->tsk->tasks_uim_widget); gtk_toolbar_set_style (appGUI->tsk->tasks_toolbar, GTK_TOOLBAR_ICONS); gtk_toolbar_set_tooltips (appGUI->tsk->tasks_toolbar, config.enable_tooltips); /*-------------------------------------------------------------------------------------*/ /* assign callbacks */ g_signal_connect (G_OBJECT(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/add")), "clicked", G_CALLBACK(tasks_add_item_cb), appGUI); g_signal_connect (G_OBJECT(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/edit")), "clicked", G_CALLBACK(tasks_edit_item_cb), appGUI); g_signal_connect (G_OBJECT(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/delete")), "clicked", G_CALLBACK(tasks_remove_item_cb), appGUI); /*-------------------------------------------------------------------------------------*/ gtk_widget_set_sensitive(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/edit"), FALSE); gtk_widget_set_sensitive(gtk_ui_manager_get_widget (appGUI->tsk->tasks_uim_widget, "/toolbar/delete"), FALSE); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 6); table = gtk_table_new (1, 4, FALSE); gtk_widget_show (table); gtk_box_pack_start (GTK_BOX (vbox1), table, FALSE, TRUE, 0); gtk_table_set_col_spacings (GTK_TABLE (table), 8); sprintf(tmpbuf, "<b>%s:</b>", _("Category filter")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_use_markup (GTK_LABEL (label), TRUE); appGUI->tsk->cf_combobox = gtk_combo_box_new_text (); gtk_widget_show (appGUI->tsk->cf_combobox); gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (appGUI->tsk->cf_combobox), FALSE); GTK_WIDGET_UNSET_FLAGS(appGUI->tsk->cf_combobox, GTK_CAN_FOCUS); gtk_table_attach (GTK_TABLE (table), appGUI->tsk->cf_combobox, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (GTK_FILL), 0, 0); g_signal_connect(appGUI->tsk->cf_combobox, "changed", G_CALLBACK(category_filter_cb), appGUI); g_signal_connect(G_OBJECT(appGUI->tsk->cf_combobox), "focus", G_CALLBACK(category_combo_box_focus_cb), NULL); appGUI->tsk->n_items_label = gtk_label_new (""); gtk_widget_show (appGUI->tsk->n_items_label); gtk_widget_set_size_request (appGUI->tsk->n_items_label, 100, -1); gtk_table_attach (GTK_TABLE (table), appGUI->tsk->n_items_label, 3, 4, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_use_markup (GTK_LABEL (appGUI->tsk->n_items_label), TRUE); hseparator = gtk_hseparator_new (); gtk_widget_show (hseparator); gtk_box_pack_start (GTK_BOX (vbox1), hseparator, FALSE, TRUE, 6); /*-------------------------------------------------------------------------------------*/ appGUI->tsk->tasks_paned = gtk_vpaned_new(); gtk_widget_show (appGUI->tsk->tasks_paned); gtk_paned_set_position(GTK_PANED(appGUI->tsk->tasks_paned), 99999); gtk_box_pack_start(GTK_BOX(vbox1), appGUI->tsk->tasks_paned, TRUE, TRUE, 0); top_viewport = gtk_viewport_new (NULL, NULL); gtk_widget_show (top_viewport); gtk_viewport_set_shadow_type (GTK_VIEWPORT (top_viewport), GTK_SHADOW_NONE); gtk_paned_pack1 (GTK_PANED (appGUI->tsk->tasks_paned), top_viewport, FALSE, TRUE); top_scrolledwindow = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (top_scrolledwindow); gtk_container_add (GTK_CONTAINER (top_viewport), top_scrolledwindow); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (top_scrolledwindow), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (top_scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); appGUI->tsk->tasks_list_store = gtk_list_store_new(TASKS_NUM_COLUMNS, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_UINT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); appGUI->tsk->tasks_filter = gtk_tree_model_filter_new(GTK_TREE_MODEL(appGUI->tsk->tasks_list_store), NULL); gtk_tree_model_filter_set_visible_func (GTK_TREE_MODEL_FILTER(appGUI->tsk->tasks_filter), (GtkTreeModelFilterVisibleFunc)tasks_list_filter_cb, appGUI, NULL); appGUI->tsk->tasks_sort = gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(appGUI->tsk->tasks_filter)); appGUI->tsk->tasks_list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(appGUI->tsk->tasks_sort)); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(appGUI->tsk->tasks_list), config.tasks_rules_hint); gtk_widget_show (appGUI->tsk->tasks_list); GTK_WIDGET_SET_FLAGS (appGUI->tsk->tasks_list, GTK_CAN_DEFAULT); gtk_widget_modify_fg(GTK_WIDGET(appGUI->tsk->tasks_list), GTK_STATE_SELECTED, (& GTK_WIDGET(appGUI->tsk->tasks_list)->style->base[GTK_STATE_SELECTED])); gtk_widget_modify_fg(GTK_WIDGET(appGUI->tsk->tasks_list), GTK_STATE_NORMAL, (& GTK_WIDGET(appGUI->tsk->tasks_list)->style->bg[GTK_STATE_NORMAL])); g_signal_connect(G_OBJECT(appGUI->tsk->tasks_list), "button_press_event", G_CALLBACK(list_dbclick_cb), appGUI); appGUI->tsk->tasks_list_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (appGUI->tsk->tasks_list)); g_signal_connect(G_OBJECT(appGUI->tsk->tasks_list_selection), "changed", G_CALLBACK(tasks_item_selected), appGUI); /* create columns */ renderer = gtk_cell_renderer_toggle_new(); appGUI->tsk->tasks_columns[COLUMN_DONE] = gtk_tree_view_column_new_with_attributes (_("Done"), renderer, "active", COLUMN_DONE, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_DONE]); g_signal_connect (renderer, "toggled", G_CALLBACK (done_toggled), appGUI); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[COLUMN_DUE_DATE] = gtk_tree_view_column_new_with_attributes(_("Due date"), renderer, "text", COLUMN_DUE_DATE, "strikethrough", COLUMN_DONE, "foreground", COLUMN_COLOR, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_DUE_DATE], config.visible_due_date_column); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_DUE_DATE]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[COLUMN_DUE_DATE_JULIAN] = gtk_tree_view_column_new_with_attributes(NULL, renderer, "text", COLUMN_DUE_DATE_JULIAN, "strikethrough", COLUMN_DONE, "foreground", COLUMN_COLOR, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_DUE_DATE_JULIAN], FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_DUE_DATE_JULIAN]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[COLUMN_START_DATE_JULIAN] = gtk_tree_view_column_new_with_attributes(NULL, renderer, "text", COLUMN_START_DATE_JULIAN, "strikethrough", COLUMN_DONE, "foreground", COLUMN_COLOR, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_START_DATE_JULIAN], FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_START_DATE_JULIAN]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[COLUMN_PRIORITY] = gtk_tree_view_column_new_with_attributes(_("Priority"), renderer, "text", COLUMN_PRIORITY, "strikethrough", COLUMN_DONE, "foreground", COLUMN_COLOR, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_PRIORITY], config.visible_priority_column); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_PRIORITY]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[COLUMN_CATEGORY] = gtk_tree_view_column_new_with_attributes(_("Category"), renderer, "text", COLUMN_CATEGORY, "strikethrough", COLUMN_DONE, "foreground", COLUMN_COLOR, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_CATEGORY], config.visible_category_column); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_CATEGORY]); renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL); gtk_cell_renderer_set_fixed_size(renderer, 0, -1); appGUI->tsk->tasks_columns[COLUMN_SUMMARY] = gtk_tree_view_column_new_with_attributes(_("Summary"), renderer, "text", COLUMN_SUMMARY, "strikethrough", COLUMN_DONE, "foreground", COLUMN_COLOR, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_SUMMARY]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[COLUMN_DESCRIPTION] = gtk_tree_view_column_new_with_attributes(_("Description"), renderer, "text", COLUMN_DESCRIPTION, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_DESCRIPTION], FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_DESCRIPTION]); renderer = gtk_cell_renderer_text_new(); appGUI->tsk->tasks_columns[COLUMN_COLOR] = gtk_tree_view_column_new_with_attributes(NULL, renderer, "text", COLUMN_COLOR, NULL); gtk_tree_view_column_set_visible (appGUI->tsk->tasks_columns[COLUMN_COLOR], FALSE); gtk_tree_view_append_column(GTK_TREE_VIEW(appGUI->tsk->tasks_list), appGUI->tsk->tasks_columns[COLUMN_COLOR]); /* configure list options */ gtk_container_add (GTK_CONTAINER (top_scrolledwindow), appGUI->tsk->tasks_list); gtk_tree_view_set_enable_search (GTK_TREE_VIEW(appGUI->tsk->tasks_list), FALSE); /* configure sorting */ gtk_tree_sortable_set_sort_func((GtkTreeSortable *)appGUI->tsk->tasks_sort, 0, (GtkTreeIterCompareFunc)custom_tasks_sort_function, NULL, NULL); gtk_tree_sortable_set_sort_column_id((GtkTreeSortable *)appGUI->tsk->tasks_sort, COLUMN_DUE_DATE, config.tasks_sorting_order); gtk_tree_sortable_set_sort_column_id((GtkTreeSortable *)appGUI->tsk->tasks_sort, COLUMN_PRIORITY, config.tasks_sorting_order); gtk_tree_sortable_set_sort_column_id((GtkTreeSortable *)appGUI->tsk->tasks_sort, COLUMN_DONE, config.tasks_sorting_order); /*----------------------------------------------------------------------------*/ bottom_viewport = gtk_viewport_new (NULL, NULL); gtk_widget_show (bottom_viewport); gtk_viewport_set_shadow_type (GTK_VIEWPORT (bottom_viewport), GTK_SHADOW_NONE); gtk_paned_pack2 (GTK_PANED (appGUI->tsk->tasks_paned), bottom_viewport, TRUE, TRUE); vbox2 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox2); gtk_container_set_border_width (GTK_CONTAINER (vbox2), 0); gtk_container_add (GTK_CONTAINER (bottom_viewport), vbox2); appGUI->tsk->panel_hbox = gtk_hbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (vbox2), appGUI->tsk->panel_hbox, FALSE, FALSE, 0); gtk_widget_show(appGUI->tsk->panel_hbox); sprintf(tmpbuf, "%s:", _("Task details")); label = gtk_label_new (tmpbuf); gtk_widget_show (label); gtk_box_pack_start (GTK_BOX (appGUI->tsk->panel_hbox), label, FALSE, FALSE, 0); if (config.default_stock_icons) { close_button = gui_stock_button(GTK_STOCK_CLOSE, FALSE); } else { close_button = gui_stock_button(OSMO_STOCK_BUTTON_CLOSE, FALSE); } GTK_WIDGET_UNSET_FLAGS(close_button, GTK_CAN_FOCUS); gtk_button_set_relief (GTK_BUTTON(close_button), GTK_RELIEF_NONE); gtk_tooltips_set_tip (appGUI->osmo_tooltips, close_button, _("Close description panel"), NULL); gtk_box_pack_end (GTK_BOX (appGUI->tsk->panel_hbox), close_button, FALSE, FALSE, 0); g_signal_connect (G_OBJECT (close_button), "clicked", G_CALLBACK (panel_close_desc_cb), appGUI); appGUI->tsk->panel_scrolledwindow = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (appGUI->tsk->panel_scrolledwindow); gtk_box_pack_start (GTK_BOX (vbox2), appGUI->tsk->panel_scrolledwindow, TRUE, TRUE, 0); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (appGUI->tsk->panel_scrolledwindow), GTK_SHADOW_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (appGUI->tsk->panel_scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); appGUI->tsk->tasks_desc_textview = gtk_text_view_new (); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (appGUI->tsk->tasks_desc_textview), GTK_WRAP_WORD); gtk_text_view_set_pixels_above_lines(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), 4); gtk_text_view_set_left_margin(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), 4); gtk_text_view_set_right_margin(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), 4); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), FALSE); gtk_text_view_set_editable(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview), FALSE); gtk_widget_show (appGUI->tsk->tasks_desc_textview); gtk_container_add (GTK_CONTAINER (appGUI->tsk->panel_scrolledwindow), appGUI->tsk->tasks_desc_textview); text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(appGUI->tsk->tasks_desc_textview)); gtk_text_buffer_create_tag (text_buffer, "italic", "style", PANGO_STYLE_ITALIC, NULL); appGUI->tsk->font_tag_object = gtk_text_buffer_create_tag (text_buffer, "info_font", "font", (gchar *) config.task_info_font, NULL); }
static void create_window (void) { GtkWidget *bar; GtkWidget *table; GtkWidget *contents; GtkUIManager *ui; GtkWidget *sw; GtkActionGroup *actions; GError *error; GtkWindowGroup *group; main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); group = gtk_window_group_new (); gtk_window_group_add_window (group, GTK_WINDOW (main_window)); g_object_unref (group); gtk_window_set_default_size (GTK_WINDOW (main_window), 400, 600); g_signal_connect (main_window, "delete-event", G_CALLBACK (gtk_main_quit), NULL); actions = gtk_action_group_new ("Actions"); gtk_action_group_add_actions (actions, entries, n_entries, NULL); ui = gtk_ui_manager_new (); gtk_ui_manager_insert_action_group (ui, actions, 0); gtk_window_add_accel_group (GTK_WINDOW (main_window), gtk_ui_manager_get_accel_group (ui)); gtk_container_set_border_width (GTK_CONTAINER (main_window), 0); error = NULL; if (!gtk_ui_manager_add_ui_from_string (ui, ui_info, -1, &error)) { g_message ("building menus failed: %s", error->message); g_error_free (error); } table = gtk_table_new (1, 3, FALSE); gtk_container_add (GTK_CONTAINER (main_window), table); bar = gtk_ui_manager_get_widget (ui, "/MenuBar"); gtk_widget_show (bar); gtk_table_attach (GTK_TABLE (table), bar, /* X direction */ /* Y direction */ 0, 1, 0, 1, GTK_EXPAND | GTK_FILL, 0, 0, 0); /* Create document */ sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN); gtk_table_attach (GTK_TABLE (table), sw, /* X direction */ /* Y direction */ 0, 1, 1, 2, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); contents = gtk_text_view_new (); gtk_widget_grab_focus (contents); gtk_container_add (GTK_CONTAINER (sw), contents); /* Create statusbar */ statusbar = gtk_statusbar_new (); gtk_table_attach (GTK_TABLE (table), statusbar, /* X direction */ /* Y direction */ 0, 1, 2, 3, GTK_EXPAND | GTK_FILL, 0, 0, 0); /* Show text widget info in the statusbar */ buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (contents)); g_signal_connect_object (buffer, "changed", G_CALLBACK (buffer_changed_callback), NULL, 0); g_signal_connect_object (buffer, "mark_set", /* cursor moved */ G_CALLBACK (mark_set_callback), NULL, 0); g_signal_connect_object (main_window, "window_state_event", G_CALLBACK (update_resize_grip), statusbar, 0); update_ui (); gtk_widget_show_all (main_window); }
static gboolean accessx_status_applet_fill(MatePanelApplet* applet) { AccessxStatusApplet* sapplet; AtkObject* atk_object; GtkActionGroup* action_group; gchar* ui_path; gboolean was_realized = FALSE; sapplet = create_applet(applet); if (!gtk_widget_get_realized(sapplet->box)) { g_signal_connect_after(G_OBJECT(sapplet->box), "realize", G_CALLBACK(accessx_status_applet_realize), sapplet); } else { accessx_status_applet_initialize(sapplet); was_realized = TRUE; } g_object_connect(sapplet->applet, "signal::destroy", accessx_status_applet_destroy, sapplet, "signal::change_orient", accessx_status_applet_reorient, sapplet, "signal::change_size", accessx_status_applet_resize, sapplet, #if !GTK_CHECK_VERSION (3, 0, 0) "signal::change_background", accessx_status_applet_background, sapplet, #endif NULL); g_signal_connect(sapplet->applet, "button_press_event", G_CALLBACK(button_press_cb), sapplet); g_signal_connect(sapplet->applet, "key_press_event", G_CALLBACK(key_press_cb), sapplet); action_group = gtk_action_group_new("Accessx Applet Actions"); gtk_action_group_set_translation_domain(action_group, GETTEXT_PACKAGE); gtk_action_group_add_actions(action_group, accessx_status_applet_menu_actions, G_N_ELEMENTS(accessx_status_applet_menu_actions), sapplet); ui_path = g_build_filename(ACCESSX_MENU_UI_DIR, "accessx-status-applet-menu.xml", NULL); mate_panel_applet_setup_menu_from_file(sapplet->applet, ui_path, action_group); g_free(ui_path); if (mate_panel_applet_get_locked_down(sapplet->applet)) { GtkAction* action = gtk_action_group_get_action(action_group, "Dialog"); gtk_action_set_visible(action, FALSE); } g_object_unref(action_group); gtk_widget_set_tooltip_text(GTK_WIDGET(sapplet->applet), _("Keyboard Accessibility Status")); atk_object = gtk_widget_get_accessible(GTK_WIDGET(sapplet->applet)); atk_object_set_name(atk_object, _("AccessX Status")); atk_object_set_description(atk_object, _("Displays current state of keyboard accessibility features")); gtk_widget_show_all(GTK_WIDGET(sapplet->applet)); if (was_realized) { accessx_status_applet_reset(sapplet); } mate_panel_applet_set_background_widget (sapplet->applet, GTK_WIDGET (sapplet->applet)); return TRUE; }
gboolean applet_main (MyPanelApplet *applet_widget, const gchar *iid, gpointer data) { streamer_applet *applet; char *zErrMsg; int res, i; char ui[24576]; if (strcmp (iid, APPLET_ID) != 0) return FALSE; // i18n setlocale (LC_ALL, ""); bindtextdomain (PACKAGE_NAME, LOCALEDIR); bind_textdomain_codeset(PACKAGE_NAME, "utf-8"); textdomain (PACKAGE_NAME); // Init applet = g_malloc0(sizeof(streamer_applet)); applet->applet = applet_widget; memset(&applet->xml_listen_url[0], '\0', 1024); memset(&applet->xml_bitrate[0], '\0', 1024); memset(&applet->xml_server_name[0], '\0', 1024); memset(&applet->xml_genre[0], '\0', 1024); memset(&applet->url[0], '\0', 1024); memset(&applet->ui_fav[0], '\0', 10240); memset(&applet->ui_recent[0], '\0', 10240); applet->timestamp = time(NULL); applet->xml_curr_entries = 0; applet->icecast_total_entries = 0; applet->status = 0; for (i=0; i<10; i++) { memset(&applet->hash_fav[i].hash[0], '\0', 64); memset(&applet->hash_recent[i].hash[0], '\0', 64); } applet->settings.show_notifications = 0; applet->settings.duration_notifications = 5; #ifdef HAVE_GNOME_2 applet->bonobo_counter = 0; #endif // Check home dir, copy skel database char applet_home_dir[1024], skel_file[1024], local_file[1024]; struct stat stat_buf; struct passwd *pw = getpwuid(getuid()); sprintf(&applet_home_dir[0], "%s/%s", pw->pw_dir, APPLET_HOME_DIR); int stat_res = stat(&applet_home_dir[0], &stat_buf); int errsv = errno; if ((stat_res == 0) && (!S_ISDIR(stat_buf.st_mode))){ push_notification(_("Streamer Applet Error"), _("Cannot access configuration directory. Exiting."), NULL, DEFAULT_NOTIFICATION_DURATION); return FALSE; } else if (stat_res == -1) { if (errsv == ENOENT) { int mkdir_res = mkdir(&applet_home_dir[0], 0755); if (mkdir_res == 1) { push_notification(_("Streamer Applet Error"), _("Cannot create configuration directory. Exiting."), NULL, DEFAULT_NOTIFICATION_DURATION); return FALSE; } } else { push_notification(_("Streamer Applet Error"), _("Cannot verify configuration directory. Exiting."), NULL, DEFAULT_NOTIFICATION_DURATION); return FALSE; } } sprintf(&skel_file[0], "%s/%s", APPLET_SKEL_PATH, APPLET_SQLITE_DB_FILENAME); sprintf(&local_file[0], "%s/%s/%s", pw->pw_dir, APPLET_HOME_DIR, APPLET_SQLITE_DB_FILENAME); stat_res = stat(&local_file[0], &stat_buf); errsv = errno; if ((stat_res == 0) && (!S_ISREG(stat_buf.st_mode))){ push_notification(_("Streamer Applet Error"), _("Database file is not a regular file. Exiting."), NULL, DEFAULT_NOTIFICATION_DURATION); } else if (stat_res == -1) { if (errsv == ENOENT) { if (!cp(&local_file[0], &skel_file[0])) { push_notification(_("Streamer Applet Error"), _("Cannot copy database file to configuration directory. Exiting."), NULL, DEFAULT_NOTIFICATION_DURATION); return FALSE; } } else { push_notification(_("Streamer Applet Error"), _("Cannot verify database file. Exiting."), NULL, DEFAULT_NOTIFICATION_DURATION); return FALSE; } } // Test DB connection, upgrade DB if necessary if (!sqlite_connect(applet)) { push_notification(_("Streamer Applet Error"), _("Unable to connect to DB. Exiting."), NULL, DEFAULT_NOTIFICATION_DURATION); return FALSE; } zErrMsg = 0; res = sqlite3_exec(applet->sqlite, "SELECT version FROM version", cb_sql_version, (void*) applet, &zErrMsg); if (res != SQLITE_OK) { push_notification(_("Streamer Applet Error"), zErrMsg, NULL, DEFAULT_NOTIFICATION_DURATION); sqlite3_free(zErrMsg); return FALSE; } if (applet->db_version == 1) { // Upgrade DB to version 2 sqlite_insert(applet, "CREATE TABLE custom_stations (server_name VARCHAR(255), listen_url VARCHAR(255), bitrate VARCHAR(255), genre VARCHAR(255))"); sqlite_insert(applet, "ALTER TABLE stations RENAME TO icecast_stations"); sqlite_insert(applet, "UPDATE version SET version=2"); } else if (applet->db_version == 2) { // Upgrade DB to version 3 sqlite_insert(applet, "CREATE TABLE rbrowser_stations (server_name VARCHAR(255), listen_url VARCHAR(255), bitrate VARCHAR(255), genre VARCHAR(255))"); sqlite_insert(applet, "UPDATE version SET version=3"); } sqlite3_close(applet->sqlite); // Init GStreamer gstreamer_init(applet); // Get an image char image_file[1024]; sprintf(&image_file[0], "%s/%s", APPLET_ICON_PATH, APPLET_ICON_PAUSE); applet->image = gtk_image_new_from_file (&image_file[0]); // Put the image into a container (it needs to receive actions) applet->event_box = gtk_event_box_new(); gtk_container_add (GTK_CONTAINER (applet->event_box), applet->image); // Put the container into the applet gtk_container_add (GTK_CONTAINER (applet->applet), applet->event_box); // Define menu action group #ifdef HAVE_MATE applet->action_group = gtk_action_group_new ("Streamer_Applet_Actions"); gtk_action_group_set_translation_domain(applet->action_group, PACKAGE_NAME); gtk_action_group_add_actions (applet->action_group, applet_menu_actions_mate, G_N_ELEMENTS (applet_menu_actions_mate), applet); #endif // Get last 10 entried from Recent & Fav, then fetch last URL if (!sqlite_connect(applet)) return FALSE; zErrMsg = 0; memset(&applet->ui_recent[0], '\0', 1); res = sqlite3_exec(applet->sqlite, "SELECT server_name, listen_url FROM recent GROUP BY listen_url ORDER BY unix_timestamp DESC LIMIT 10", cb_sql_recent_10, (void*) applet, &zErrMsg); if (res != SQLITE_OK) { push_notification(_("Streamer Applet Error"), zErrMsg, NULL, DEFAULT_NOTIFICATION_DURATION); sqlite3_free(zErrMsg); return FALSE; } memset(&applet->ui_fav[0], '\0', 1); res = sqlite3_exec(applet->sqlite, "SELECT server_name, listen_url FROM favourites LIMIT 10", cb_sql_fav_10, (void*) applet, &zErrMsg); if (res != SQLITE_OK) { push_notification(_("Streamer Applet Error"), zErrMsg, NULL, DEFAULT_NOTIFICATION_DURATION); sqlite3_free(zErrMsg); return FALSE; } res = sqlite3_exec(applet->sqlite, "SELECT * FROM recent ORDER BY unix_timestamp DESC LIMIT 1", cb_sql_recent, (void*) applet, &zErrMsg); if (res != SQLITE_OK) { push_notification(_("Streamer Applet Error"), zErrMsg, NULL, DEFAULT_NOTIFICATION_DURATION); sqlite3_free(zErrMsg); return FALSE; } sqlite3_free(zErrMsg); sqlite3_close(applet->sqlite); // Build menu sprintf(&ui[0], "%s %s %s %s %s", ui1, &applet->ui_recent[0], ui2, &applet->ui_fav[0], ui3); #ifdef HAVE_MATE mate_panel_applet_setup_menu(applet->applet, &ui[0], applet->action_group); #elif HAVE_GNOME_2 BonoboUIVerb bnb1 = BONOBO_UI_UNSAFE_VERB ("All", G_CALLBACK (menu_cb_all)); applet->applet_menu_actions_gnome[applet->bonobo_counter] = bnb1; applet->bonobo_counter++; BonoboUIVerb bnb1a = BONOBO_UI_UNSAFE_VERB ("Settings", G_CALLBACK (menu_cb_settings)); applet->applet_menu_actions_gnome[applet->bonobo_counter] = bnb1a; applet->bonobo_counter++; BonoboUIVerb bnb2 = BONOBO_UI_UNSAFE_VERB ("About", G_CALLBACK (menu_cb_about)); applet->applet_menu_actions_gnome[applet->bonobo_counter] = bnb2; applet->bonobo_counter++; BonoboUIVerb bnb3 = BONOBO_UI_VERB_END; applet->applet_menu_actions_gnome[applet->bonobo_counter] = bnb3; applet->bonobo_counter++; panel_applet_setup_menu(applet->applet, &ui[0], applet->applet_menu_actions_gnome, applet); #endif // Merge menu //GError **error; //char ui[10240]; //sprintf(&ui[0], "<menu action='SubMenu1'>\n<menuitem action='All'/>\n<menuitem action='All'/></menu>"); //guint merge_id = gtk_ui_manager_add_ui_from_string (applet->applet->priv->ui_manager, &ui[0], -1, error); // Settings: Prepare DConf - GNOME2 only #ifdef HAVE_GNOME_2 if (!panel_applet_gconf_get_bool(PANEL_APPLET(applet->applet), "have_settings", NULL)) { panel_applet_gconf_set_bool(PANEL_APPLET(applet->applet), "have_settings", TRUE, NULL); panel_applet_gconf_set_int(PANEL_APPLET(applet->applet), APPLET_KEY_OPTION_1, 0, NULL); panel_applet_gconf_set_int(PANEL_APPLET(applet->applet), APPLET_KEY_OPTION_2, 5, NULL); } #endif // Load settings #ifdef HAVE_MATE applet->gsettings = g_settings_new_with_path(APPLET_GSETTINGS_SCHEMA, APPLET_GSETTINGS_PATH); applet->settings.show_notifications = g_settings_get_int(applet->gsettings, APPLET_KEY_OPTION_1); applet->settings.duration_notifications = g_settings_get_int(applet->gsettings, APPLET_KEY_OPTION_2); #elif HAVE_GNOME_2 applet->settings.show_notifications = panel_applet_gconf_get_int(PANEL_APPLET(applet->applet), APPLET_KEY_OPTION_1, NULL); applet->settings.duration_notifications = panel_applet_gconf_get_int(PANEL_APPLET(applet->applet), APPLET_KEY_OPTION_2, NULL); #endif // Signals g_signal_connect(G_OBJECT(applet->event_box), "button_press_event", G_CALLBACK (on_left_click), (gpointer)applet); g_signal_connect(G_OBJECT(applet->applet), "change_background", G_CALLBACK (applet_back_change), (gpointer)applet); g_signal_connect(G_OBJECT(applet->applet), "destroy", G_CALLBACK(applet_destroy), (gpointer)applet); // Tooltip gtk_widget_set_tooltip_text (GTK_WIDGET (applet->applet), _("No stream selected. Right-click to load one.")); // Show applet gtk_widget_show_all (GTK_WIDGET (applet->applet)); // Run applet->loop = g_main_loop_new (NULL, FALSE); g_main_loop_run (applet->loop); return TRUE; }
int main (int argc, char **argv) { GtkWidget *window; GtkWidget *main_hbox; GtkWidget *vseparator; GtkWidget *button; GtkWidget *main_vbox; GtkWidget *menubar; GtkWidget *vbox; GtkWidget *label; GtkAccelGroup *accel_group; PangoFontDescription *font_desc; int i; char *p; p = progname = argv[0]; while (*p) { if (*p == '/') progname = p+1; p++; } gtk_init (&argc, &argv); for (i=1; i<argc; i++) { if (!strcmp(argv[i], "--data-file") || !strcmp(argv[i], "-f")) { i++; if (i < argc) data_file = argv[i]; else usage(); } else { usage(); } } window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_resizable (GTK_WINDOW (window), TRUE); gtk_window_set_default_size (GTK_WINDOW (window), 350, 350); g_signal_connect (window, "destroy", G_CALLBACK (exit_callback), NULL); gtk_window_set_title (GTK_WINDOW(window), "KanjiPad"); main_vbox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER (window), main_vbox); gtk_widget_show (main_vbox); /* Menu */ GtkActionGroup *action_group; /* Packing group for our Actions */ GtkUIManager *menu_manager; /* The magic widget! */ GError *error; /* For reporting exceptions or errors */ GtkWidget *toolbar; /* The actual toolbar */ action_group = gtk_action_group_new ("MainMenu"); gtk_action_group_add_actions (action_group, entries, n_entries, NULL); gtk_action_group_add_toggle_actions (action_group, toggle_entries, n_toggle_entries, NULL); menu_manager = gtk_ui_manager_new (); gtk_ui_manager_insert_action_group (menu_manager, action_group, 0); error = NULL; gtk_ui_manager_add_ui_from_file (menu_manager, "ui.xml", &error); if (error){ g_message ("building menus failed: %s", error->message); g_error_free (error); } //Add the menu bar menubar = gtk_ui_manager_get_widget (menu_manager, "/MainMenu"); gtk_box_pack_start (GTK_BOX (main_vbox), menubar, FALSE, FALSE, 0); /*accel_group = gtk_accel_group_new (); factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", accel_group); gtk_item_factory_create_items (factory, nmenu_items, menu_items, NULL);*/ /* create a menubar */ /*menubar = gtk_item_factory_get_widget (factory, "<main>"); gtk_box_pack_start (GTK_BOX (main_vbox), menubar, FALSE, TRUE, 0); gtk_widget_show (menubar);*/ /* Install the accelerator table in the main window */ //gtk_window_add_accel_group (GTK_WINDOW (window), accel_group); main_hbox = gtk_hbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER(window), main_hbox); gtk_box_pack_start (GTK_BOX(main_vbox), main_hbox, TRUE, TRUE, 0); gtk_widget_show (main_hbox); /* toolbar = gtk_ui_manager_get_widget (menu_manager, "/MainToolbar"); gtk_box_pack_start (GTK_BOX (main_hbox), toolbar, FALSE, FALSE, 0); gtk_window_add_accel_group (GTK_WINDOW (window), gtk_ui_manager_get_accel_group (menu_manager)); */ /* Area for user to draw characters in */ pad_area = pad_area_create (); gtk_box_pack_start (GTK_BOX (main_hbox), pad_area->widget, TRUE, TRUE, 0); gtk_widget_show (pad_area->widget); vseparator = gtk_vseparator_new(); gtk_box_pack_start (GTK_BOX (main_hbox), vseparator, FALSE, FALSE, 0); gtk_widget_show (vseparator); /* Area in which to draw guesses */ vbox = gtk_vbox_new (FALSE, 0); gtk_box_pack_start (GTK_BOX (main_hbox), vbox, FALSE, FALSE, 0); gtk_widget_show (vbox); karea = gtk_drawing_area_new(); g_signal_connect (karea, "configure_event", G_CALLBACK (karea_configure_event), NULL); g_signal_connect (karea, "expose_event", G_CALLBACK (karea_expose_event), NULL); g_signal_connect (karea, "button_press_event", G_CALLBACK (karea_button_press_event), NULL); gtk_widget_set_events (karea, GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK); #ifdef G_OS_WIN32 font_desc = pango_font_description_from_string ("MS Gothic 18"); #else font_desc = pango_font_description_from_string ("Sans 18"); #endif gtk_widget_modify_font (karea, font_desc); gtk_box_pack_start (GTK_BOX (vbox), karea, TRUE, TRUE, 0); gtk_widget_show (karea); /* Buttons */ label = gtk_label_new ("\xe5\xbc\x95"); /* We have to set the alignment here, since GTK+ will fail * to get the width of the string appropriately... */ gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_widget_modify_font (label, font_desc); gtk_widget_show (label); lookup_button = button = gtk_button_new (); gtk_container_add (GTK_CONTAINER (button), label); g_signal_connect (button, "clicked", G_CALLBACK (look_up_callback), NULL); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); label = gtk_label_new ("\xe6\x88\xbb"); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_widget_modify_font (label, font_desc); gtk_widget_show (label); undo_button = button = gtk_button_new (); gtk_container_add (GTK_CONTAINER (button), label); g_signal_connect (button, "clicked", G_CALLBACK (undo_callback), NULL); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); label = gtk_label_new ("\xe6\xb6\x88"); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_widget_modify_font (label, font_desc); gtk_widget_show (label); clear_button = button = gtk_button_new (); gtk_container_add (GTK_CONTAINER (button), label); g_signal_connect (button, "clicked", G_CALLBACK (clear_callback), NULL); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); gtk_widget_show (button); gtk_widget_show(window); pango_font_description_free (font_desc); init_engine(); update_sensitivity (); gtk_main(); return 0; }
static gboolean analyzer_ui_init (void) { GtkActionGroup *action_group; char *path; ui = g_slice_new0 (AnalyzerUI); path = g_build_filename (DATADIR, "codecanalyzer", "ui", "mainwindow.xml", NULL); ui->builder = make_builder (path); g_free (path); ui->main_window = get_widget_from_builder (ui->builder, "Codecanalyzer-main-window"); ui->main_vbox = get_widget_from_builder (ui->builder, "MainVBox"); ui->child_vbox1 = get_widget_from_builder (ui->builder, "child_vbox1"); ui->child_vbox2 = get_widget_from_builder (ui->builder, "child_vbox2"); ui->child_vbox3 = get_widget_from_builder (ui->builder, "child_vbox3"); ui->menubar_vbox = get_widget_from_builder (ui->builder, "menubar_vbox"); ui->stream_chooser = get_widget_from_builder (ui->builder, "StreamChooser"); ui->numframes_chooser = get_widget_from_builder (ui->builder, "NumFrameEntryButton"); ui->analyze_button = get_widget_from_builder (ui->builder, "AnalyzeButton"); ui->cancel_button = get_widget_from_builder (ui->builder, "CancelButton"); ui->hbox1_in_vbox2 = get_widget_from_builder (ui->builder, "hbox1_in_vbox2"); ui->child_hbox_in_vbox1_2 = get_widget_from_builder (ui->builder, "child_hbox_in_vbox1_2"); ui->thumbnails_scroll_window = get_widget_from_builder (ui->builder, "thumbnails_scrolled_window"); ui->thumbnails_view_port = get_widget_from_builder (ui->builder, "thumbnails_view_port"); ui->general_info_frame = get_widget_from_builder (ui->builder, "general_info_frame"); ui->general_info_vbox = get_widget_from_builder (ui->builder, "general_info_vbox"); ui->general_info_treeview = get_widget_from_builder (ui->builder, "general_info_treeview"); ui->parsed_info_hbox = get_widget_from_builder (ui->builder, "parsed_info_hbox"); ui->parsed_info_vbox = get_widget_from_builder (ui->builder, "parsed_info_vbox"); ui->parsed_info_frame = get_widget_from_builder (ui->builder, "parsed_info_frame"); ui->parsed_info_button_box = get_widget_from_builder (ui->builder, "parsed_info_button_box"); /* Create menu */ action_group = gtk_action_group_new ("ActionGroup"); gtk_action_group_add_actions (action_group, entries_actiongroup, G_N_ELEMENTS (entries_actiongroup), NULL); ui->menu_manager = gtk_ui_manager_new (); gtk_ui_manager_insert_action_group (ui->menu_manager, action_group, 0); path = g_build_filename (DATADIR, "codecanalyzer", "ui", "menu.xml", NULL); gtk_ui_manager_add_ui_from_file (ui->menu_manager, path, NULL); g_free (path); ui->menubar = gtk_ui_manager_get_widget (ui->menu_manager, "/MainMenu"); gtk_box_pack_start (GTK_BOX (ui->menubar_vbox), ui->menubar, FALSE, FALSE, 0); gtk_window_add_accel_group (GTK_WINDOW (ui->main_window), gtk_ui_manager_get_accel_group (ui->menu_manager)); ui->notebook_hash = g_hash_table_new (g_str_hash, g_str_equal); ui->prev_page = NULL; ui->num_frames = 0; gtk_window_maximize (GTK_WINDOW (ui->main_window)); path = g_build_filename (DATADIR, "codecanalyzer", "pixmaps", "codecanalyzer-logo.png", NULL); if (!gtk_window_set_icon_from_file (GTK_WINDOW (ui->main_window), path, NULL)) g_warning ("Failed to load the icon image.. "); g_free (path); return TRUE; }
/** * Add menu items to the "Recent files" submenu. */ gboolean affiche_derniers_fichiers_ouverts ( void ) { gint i; GtkActionGroup * action_group; efface_derniers_fichiers_ouverts (); if ( conf.nb_derniers_fichiers_ouverts > conf.nb_max_derniers_fichiers_ouverts ) { conf.nb_derniers_fichiers_ouverts = conf.nb_max_derniers_fichiers_ouverts; } if ( ! conf.nb_derniers_fichiers_ouverts || ! conf.nb_max_derniers_fichiers_ouverts ) { return FALSE; } action_group = gtk_action_group_new ( "Group2" ); for ( i = 0 ; i < conf.nb_derniers_fichiers_ouverts ; i++ ) { gchar *tmp_name; GtkAction *action; tmp_name = g_strdup_printf ( "LastFile%d", i ); action = gtk_action_new ( tmp_name, tab_noms_derniers_fichiers_ouverts[i], "", "" ); g_free ( tmp_name ); g_signal_connect ( action, "activate", G_CALLBACK ( gsb_file_open_direct_menu ), GINT_TO_POINTER ( i ) ); gtk_action_group_add_action ( action_group, action ); } gtk_ui_manager_insert_action_group ( ui_manager, action_group, 1 ); recent_files_merge_id = gtk_ui_manager_new_merge_id ( ui_manager ); for ( i=0 ; i < conf.nb_derniers_fichiers_ouverts ; i++ ) { gchar *tmp_name; gchar *tmp_label; tmp_name = g_strdup_printf ( "LastFile%d", i ); tmp_label = g_strdup_printf ( "_%d LastFile%d", i, i ); gtk_ui_manager_add_ui ( ui_manager, recent_files_merge_id, "/menubar/FileMenu/RecentFiles/", tmp_label, tmp_name, GTK_UI_MANAGER_MENUITEM, FALSE ); g_free ( tmp_name ); g_free ( tmp_label ); } /* add a separator */ gtk_ui_manager_add_ui ( ui_manager, merge_id, "/menubar/FileMenu/Open/", NULL, NULL, GTK_UI_MANAGER_SEPARATOR, FALSE ); gtk_ui_manager_ensure_update ( ui_manager ); #ifdef GTKOSXAPPLICATION grisbi_osx_app_update_menus_cb ( ); #endif /* GTKOSXAPPLICATION */ return FALSE; }
gboolean window_list_applet_fill (PanelApplet *applet) { TasklistData *tasklist; GtkActionGroup *action_group; GtkAction *action; gchar *ui_path; tasklist = g_new0 (TasklistData, 1); tasklist->applet = GTK_WIDGET (applet); panel_applet_set_flags (PANEL_APPLET (tasklist->applet), PANEL_APPLET_EXPAND_MAJOR | PANEL_APPLET_EXPAND_MINOR | PANEL_APPLET_HAS_HANDLE); panel_applet_add_preferences (applet, "/schemas/apps/window_list_applet/prefs", NULL); setup_gconf (tasklist); tasklist->include_all_workspaces = g_settings_get_boolean (tasklist->settings, "display-all-workspaces"); tasklist->grouping = g_settings_get_enum (tasklist->settings, "group-windows"); tasklist->move_unminimized_windows = g_settings_get_boolean (tasklist->settings, "move-unminimized-windows"); tasklist->size = panel_applet_get_size (applet); switch (panel_applet_get_orient (applet)) { case PANEL_APPLET_ORIENT_LEFT: case PANEL_APPLET_ORIENT_RIGHT: tasklist->orientation = GTK_ORIENTATION_VERTICAL; break; case PANEL_APPLET_ORIENT_UP: case PANEL_APPLET_ORIENT_DOWN: default: tasklist->orientation = GTK_ORIENTATION_HORIZONTAL; break; } tasklist->tasklist = wnck_tasklist_new (); wnck_tasklist_set_orientation (tasklist->tasklist, tasklist->orientation); wnck_tasklist_set_icon_loader (WNCK_TASKLIST (tasklist->tasklist), icon_loader_func, tasklist, NULL); g_signal_connect (G_OBJECT (tasklist->tasklist), "destroy", G_CALLBACK (destroy_tasklist), tasklist); g_signal_connect (G_OBJECT (tasklist->applet), "size_allocate", G_CALLBACK (applet_size_allocate), tasklist); tasklist_update (tasklist); gtk_widget_show (tasklist->tasklist); gtk_container_add (GTK_CONTAINER (tasklist->applet), tasklist->tasklist); g_signal_connect (G_OBJECT (tasklist->applet), "realize", G_CALLBACK (applet_realized), tasklist); g_signal_connect (G_OBJECT (tasklist->applet), "change_orient", G_CALLBACK (applet_change_orient), tasklist); g_signal_connect (G_OBJECT (tasklist->applet), "change_size", G_CALLBACK (applet_change_pixel_size), tasklist); g_signal_connect (G_OBJECT (tasklist->applet), "change_background", G_CALLBACK (applet_change_background), tasklist); panel_applet_set_background_widget (PANEL_APPLET (tasklist->applet), GTK_WIDGET (tasklist->applet)); action_group = gtk_action_group_new ("Tasklist Applet Actions"); gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE); gtk_action_group_add_actions (action_group, tasklist_menu_actions, G_N_ELEMENTS (tasklist_menu_actions), tasklist); ui_path = g_build_filename (WNCK_MENU_UI_DIR, "window-list-menu.xml", NULL); panel_applet_setup_menu_from_file (PANEL_APPLET (tasklist->applet), ui_path, action_group); g_free (ui_path); action = gtk_action_group_get_action (action_group, "TasklistPreferences"); g_object_bind_property (tasklist->applet, "locked-down", action, "visible", G_BINDING_DEFAULT|G_BINDING_INVERT_BOOLEAN|G_BINDING_SYNC_CREATE); g_object_unref (action_group); gtk_widget_show (tasklist->applet); return TRUE; }
/* 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"); }
PUSS_EXPORT void* puss_plugin_create(Puss* app) { GTree* sections; GtkSourceLanguageManager* lm; const gchar* const* ids; const gchar* const* id; GtkSourceLanguage* lang; const gchar* name; gchar* action_name; GtkAction* action; const gchar* section; GList* section_list; GtkUIManager* ui_mgr; IToolMenuAction* tool_menu_interface; GString* gstr; gchar* ui_info; GError* err; tool_menu_interface = app->extend_query("puss_controls", INTERFACE_TOOL_MENU_ACTION); if( !tool_menu_interface ) return 0; bindtextdomain(TEXT_DOMAIN, app->get_locale_path()); bind_textdomain_codeset(TEXT_DOMAIN, "UTF-8"); g_self = g_new0(LanguageSelector, 1); g_self->app = app; g_self->action_group = gtk_action_group_new("puss_language_selector_action_group"); // set select language menu sections = g_tree_new_full((GCompareDataFunc)&g_ascii_strcasecmp, 0, 0, (GDestroyNotify)g_list_free); lm = gtk_source_language_manager_get_default(); ids = gtk_source_language_manager_get_language_ids(lm); g_self->last_favory_lang = gtk_source_language_manager_get_language(lm, "cpp"); for( id=ids; *id; ++id ) { lang = gtk_source_language_manager_get_language(lm, *id); if( lang ) { name = gtk_source_language_get_name(lang); action_name = g_strdup_printf("pls_lang_%s", name); action = gtk_action_new(action_name, name, NULL, NULL); g_signal_connect(action, "activate", G_CALLBACK(&pls_lang_active), lang); gtk_action_group_add_action(g_self->action_group, action); g_object_unref(action); g_free(action_name); section = gtk_source_language_get_section(lang); section_list = (GList*)g_tree_lookup(sections, section); if( section_list ) { g_tree_steal(sections, section); } else { action_name = g_strdup_printf("pls_sec_%s", section); action = GTK_ACTION(gtk_action_new(action_name, section, NULL, NULL)); gtk_action_group_add_action(g_self->action_group, action); g_object_unref(action); g_free(action_name); } section_list = g_list_insert_sorted(section_list, (gchar*)name, (GCompareFunc)&g_ascii_strcasecmp); g_tree_insert(sections, (gchar*)section, section_list); } } // insert language selector menu-tool-button // action = gtk_action_new("language_selector_open", _("Language"), _("select high-light source language, default use last"), GTK_STOCK_SELECT_COLOR); gtk_action_group_add_action(g_self->action_group, action); g_object_unref(action); action = GTK_ACTION( g_object_new(tool_menu_interface->get_type () , "name", "language_selector_toolmenu_open" , "label", _("Language") , "tooltip", _("select high-light source language, default use last") , "stock-id", GTK_STOCK_SELECT_COLOR , NULL) ); g_signal_connect(action, "activate", G_CALLBACK(&pls_lang_active), 0); gtk_action_group_add_action(g_self->action_group, action); g_object_unref(action); ui_mgr = GTK_UI_MANAGER(gtk_builder_get_object(app->get_ui_builder(), "main_ui_manager")); gtk_ui_manager_insert_action_group(ui_mgr, g_self->action_group, 0); // main selector menu gstr= g_string_new(NULL); g_tree_foreach(sections, (GTraverseFunc)&fill_language_section, gstr); g_tree_destroy(sections); ui_info = g_strdup_printf( "<ui>" " <menubar name='main_menubar'>" " <menu action='view_menu'>\n" " <placeholder name='view_menu_extend_place'>" " <menu action='language_selector_open'>" " %s" " <placeholder name='pls_favory_menu_place'>" " </placeholder>" " </menu>" " </placeholder>" " </menu>" " </menubar>" "" " <toolbar name='main_toolbar'>" " <placeholder name='main_toolbar_view_place'>" " <toolitem action='language_selector_toolmenu_open'>" " <menu action='language_selector_toolmenu_open'>" " %s" " <placeholder name='pls_favory_toolmenu_place'>" " </placeholder>" " </menu>" " </toolitem>" " </placeholder>" " </toolbar>" "</ui>" , gstr->str , gstr->str ); //g_print(ui_info); err = 0; g_self->merge_id = gtk_ui_manager_add_ui_from_string(ui_mgr, ui_info, -1, &err); if( err ) { g_printerr("%s", err->message); g_error_free(err); } g_free(ui_info); g_string_free(gstr, TRUE); gtk_ui_manager_ensure_update(ui_mgr); fill_favory_language_menu(); return g_self; }
void gweather_applet_create (GWeatherApplet *gw_applet) { GtkActionGroup *action_group; gchar *ui_path; AtkObject *atk_obj; gw_applet->gweather_pref.location = NULL; gw_applet->gweather_pref.update_interval = 1800; gw_applet->gweather_pref.update_enabled = TRUE; gw_applet->gweather_pref.detailed = FALSE; gw_applet->gweather_pref.radar_enabled = TRUE; gw_applet->gweather_pref.temperature_unit = TEMP_UNIT_INVALID; gw_applet->gweather_pref.speed_unit = SPEED_UNIT_INVALID; gw_applet->gweather_pref.pressure_unit = PRESSURE_UNIT_INVALID; gw_applet->gweather_pref.distance_unit = DISTANCE_UNIT_INVALID; panel_applet_set_flags (gw_applet->applet, PANEL_APPLET_EXPAND_MINOR); panel_applet_set_background_widget(gw_applet->applet, GTK_WIDGET(gw_applet->applet)); g_set_application_name (_("Weather Report")); gtk_window_set_default_icon_name ("weather-storm"); gw_applet->container = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_container_add (GTK_CONTAINER (gw_applet->applet), gw_applet->container); g_signal_connect (G_OBJECT(gw_applet->applet), "change_orient", G_CALLBACK(change_orient_cb), gw_applet); g_signal_connect (G_OBJECT(gw_applet->applet), "size_allocate", G_CALLBACK(size_allocate_cb), gw_applet); g_signal_connect (G_OBJECT(gw_applet->applet), "destroy", G_CALLBACK (applet_destroy), gw_applet); g_signal_connect (G_OBJECT(gw_applet->applet), "button_press_event", G_CALLBACK(clicked_cb), gw_applet); g_signal_connect (G_OBJECT(gw_applet->applet), "key_press_event", G_CALLBACK(key_press_cb), gw_applet); gtk_widget_set_tooltip_text (GTK_WIDGET(gw_applet->applet), _("GNOME Weather")); atk_obj = gtk_widget_get_accessible (GTK_WIDGET (gw_applet->applet)); if (GTK_IS_ACCESSIBLE (atk_obj)) atk_object_set_name (atk_obj, _("GNOME Weather")); gw_applet->size = panel_applet_get_size (gw_applet->applet); gw_applet->orient = panel_applet_get_orient (gw_applet->applet); action_group = gtk_action_group_new ("GWeather Applet Actions"); gtk_action_group_set_translation_domain (action_group, GETTEXT_PACKAGE); gtk_action_group_add_actions (action_group, weather_applet_menu_actions, G_N_ELEMENTS (weather_applet_menu_actions), gw_applet); ui_path = g_build_filename (GWEATHER_MENU_UI_DIR, "gweather-applet-menu.xml", NULL); panel_applet_setup_menu_from_file (gw_applet->applet, ui_path, action_group); g_free (ui_path); if (panel_applet_get_locked_down (gw_applet->applet)) { GtkAction *action; action = gtk_action_group_get_action (action_group, "Props"); gtk_action_set_visible (action, FALSE); } g_object_unref (action_group); place_widgets(gw_applet); #ifdef HAVE_NETWORKMANAGER setup_network_monitor (gw_applet); #endif }
static void populate_window(ChmSee *self) { GtkWidget* vbox = gtk_vbox_new(FALSE, 0); GladeXML *glade; glade = glade_xml_new(get_resource_path(GLADE_FILE), "main_vbox", NULL); if (glade == NULL) { g_error("Cannot find glade file!"); exit(1); } g_object_set_data(G_OBJECT (self), "glade", glade); GtkWidget *main_vbox; main_vbox = get_widget(self, "main_vbox"); gtk_container_add(GTK_CONTAINER (self), vbox); GtkActionGroup* action_group = gtk_action_group_new ("MenuActions"); selfp->action_group = action_group; gtk_action_group_add_actions (action_group, entries, G_N_ELEMENTS (entries), self); gtk_action_group_add_toggle_actions (action_group, toggle_entries, G_N_ELEMENTS (toggle_entries), self); gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "NewTab"), FALSE); gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "CloseTab"), FALSE); gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "Home"), FALSE); gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "Back"), FALSE); gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "Forward"), FALSE); gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "SidePane"), FALSE); gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "ZoomIn"), FALSE); gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "ZoomOut"), FALSE); gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "ZoomReset"), FALSE); GtkUIManager* ui_manager = gtk_ui_manager_new (); selfp->ui_manager = ui_manager; gtk_ui_manager_insert_action_group (ui_manager, action_group, 0); GtkAccelGroup* accel_group = gtk_ui_manager_get_accel_group (ui_manager); gtk_window_add_accel_group (GTK_WINDOW (self), accel_group); GError* error = NULL; if (!gtk_ui_manager_add_ui_from_string (ui_manager, ui_description, -1, &error)) { g_message ("building menus failed: %s", error->message); g_error_free (error); exit (EXIT_FAILURE); } GtkWidget* menubar = gtk_handle_box_new(); selfp->menubar = menubar; gtk_container_add(GTK_CONTAINER(menubar), gtk_ui_manager_get_widget (ui_manager, "/MainMenu")); gtk_box_pack_start (GTK_BOX (vbox), menubar, FALSE, FALSE, 0); GtkWidget* toolbar = gtk_handle_box_new(); selfp->toolbar = toolbar; gtk_container_add(GTK_CONTAINER(toolbar), gtk_ui_manager_get_widget(ui_manager, "/toolbar")); gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0); GtkWidget* ui_chmfile = chmsee_ui_chmfile_new(); selfp->ui_chmfile = ui_chmfile; gtk_box_pack_start(GTK_BOX(vbox), ui_chmfile, TRUE, TRUE, 0); gtk_container_set_focus_child(GTK_CONTAINER(vbox), ui_chmfile); g_signal_connect_swapped(ui_chmfile, "model_changed", G_CALLBACK(on_ui_chmfile_model_changed), self); g_signal_connect_swapped(ui_chmfile, "html_changed", G_CALLBACK(on_ui_chmfile_html_changed), self); g_signal_connect_swapped(ui_chmfile, "notify::link-message", G_CALLBACK(on_ui_chmfile_html_link_message_notify), self); gtk_tool_button_set_icon_widget( GTK_TOOL_BUTTON(gtk_ui_manager_get_widget(ui_manager, "/toolbar/sidepane")), gtk_image_new_from_file(get_resource_path("show-pane.png"))); gtk_box_pack_start (GTK_BOX (vbox), main_vbox, FALSE, FALSE, 0); gtk_widget_show_all(vbox); accel_group = g_object_new(GTK_TYPE_ACCEL_GROUP, NULL); gtk_window_add_accel_group(GTK_WINDOW (self), accel_group); /* status bar */ selfp->statusbar = glade_xml_get_widget(glade, "statusbar"); selfp->scid_default = gtk_statusbar_get_context_id(GTK_STATUSBAR (selfp->statusbar), "default"); update_status_bar(self, _("Ready!")); }
GtkUIManager * gl_ui_new (glWindow *window) { GtkUIManager *ui; GtkActionGroup *actions; GError *error = NULL; GtkWidget *recent_menu; gl_debug (DEBUG_UI, "START"); g_return_val_if_fail (window && GL_IS_WINDOW (window), NULL); gl_debug (DEBUG_UI, "window = %p", window); ui = gtk_ui_manager_new (); g_signal_connect (ui, "connect_proxy", G_CALLBACK (connect_proxy_cb), window); g_signal_connect (ui, "disconnect_proxy", G_CALLBACK (disconnect_proxy_cb), window); actions = gtk_action_group_new ("Actions"); gtk_action_group_set_translation_domain (actions, NULL); gtk_action_group_add_actions (actions, entries, n_entries, GTK_WINDOW (window)); gtk_action_group_add_toggle_actions (actions, toggle_entries, n_toggle_entries, window); gtk_action_group_add_toggle_actions (actions, ui_toggle_entries, n_ui_toggle_entries, ui); gtk_ui_manager_insert_action_group (ui, actions, 0); gtk_window_add_accel_group (GTK_WINDOW (window), gtk_ui_manager_get_accel_group (ui)); gl_debug (DEBUG_UI, "Creating ui from string"); if (!gtk_ui_manager_add_ui_from_string (ui, ui_info, strlen (ui_info), &error)) { g_message ("building menus failed: %s", error->message); g_error_free (error); } /* Set the toolbar styles according to prefs */ set_app_main_toolbar_style (ui); set_app_drawing_toolbar_style (ui); /* Set view grid and markup visibility according to prefs */ set_view_style (ui); /* add an Open Recents Submenu */ recent_menu = gl_recent_create_menu (); g_signal_connect (G_OBJECT (recent_menu), "item-activated", G_CALLBACK (gl_ui_cmd_file_open_recent), window); gtk_menu_item_set_submenu (GTK_MENU_ITEM (gtk_ui_manager_get_widget (ui, "/MenuBar/FileMenu/FileRecentsMenu")), recent_menu); set_additional_properties (ui); gl_ui_util_set_verb_list_sensitive (ui, doc_verbs, FALSE); gl_ui_util_set_verb_list_sensitive (ui, paste_verbs, FALSE); gl_debug (DEBUG_UI, "END"); return ui; }
/** * 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); }