/* * The GMenu @menu is modified adding to the section @submodel_name * the item @item. */ void nautilus_gmenu_add_item_in_submodel (GMenu *menu, GMenuItem *item, const gchar *submodel_name, gboolean prepend) { GMenuModel *submodel; g_return_if_fail (G_IS_MENU (menu)); g_return_if_fail (G_IS_MENU_ITEM (item)); submodel = find_gmenu_model (G_MENU_MODEL (menu), submodel_name); g_return_if_fail (submodel != NULL); if (prepend) g_menu_prepend_item (G_MENU (submodel), item); else g_menu_append_item (G_MENU (submodel), item); g_object_unref (submodel); }
void nautilus_pop_up_context_menu (GtkWidget *parent, GMenu *menu, GdkEventButton *event) { GtkWidget *gtk_menu; int button; g_return_if_fail (G_IS_MENU (menu)); g_return_if_fail (GTK_IS_WIDGET (parent)); gtk_menu = gtk_menu_new_from_model (G_MENU_MODEL (menu)); gtk_menu_attach_to_widget (GTK_MENU (gtk_menu), parent, NULL); /* The event button needs to be 0 if we're popping up this menu from * a button release, else a 2nd click outside the menu with any button * other than the one that invoked the menu will be ignored (instead * of dismissing the menu). This is a subtle fragility of the GTK menu code. */ if (event) { button = event->type == GDK_BUTTON_RELEASE ? 0 : event->button; } else { button = 0; } gtk_menu_popup (GTK_MENU (gtk_menu), /* menu */ NULL, /* parent_menu_shell */ NULL, /* parent_menu_item */ NULL, /* popup_position_func */ NULL, /* popup_position_data */ button, /* button */ event ? event->time : gtk_get_current_event_time ()); /* activate_time */ g_object_ref_sink (gtk_menu); g_object_unref (gtk_menu); }
void nautilus_gmenu_replace_section (GMenu *menu, const gchar *section_id, GMenuModel *section) { GMenuModel *orig_section; GMenuItem *item; gint idx; orig_section = find_gmenu_model (G_MENU_MODEL (menu), section_id); g_return_if_fail (orig_section != NULL); g_menu_remove_all (G_MENU (orig_section)); for (idx = 0; idx < g_menu_model_get_n_items (section); idx++) { item = g_menu_item_new_from_model (section, idx); g_menu_append_item (G_MENU (orig_section), item); g_object_unref (item); } g_object_unref (orig_section); }
static void impl_deactivate (EogWindowActivatable *activatable) { const gchar * const empty_accels[1] = { NULL }; EogFitToWidthPlugin *plugin = EOG_FIT_TO_WIDTH_PLUGIN (activatable); GMenu *menu; GMenuModel *model; gint i; menu = eog_window_get_gear_menu_section (plugin->window, "plugins-section"); g_return_if_fail (G_IS_MENU (menu)); /* Remove menu entry */ model = G_MENU_MODEL (menu); for (i = 0; i < g_menu_model_get_n_items (model); i++) { gchar *id; if (g_menu_model_get_item_attribute (model, i, "id", "s", &id)) { const gboolean found = (g_strcmp0 (id, EOG_FIT_TO_WIDTH_PLUGIN_MENU_ID) == 0); g_free (id); if (found) { g_menu_remove (menu, i); break; } } } /* Unset accelerator */ gtk_application_set_accels_for_action(GTK_APPLICATION (EOG_APP), "win." EOG_FIT_TO_WIDTH_PLUGIN_ACTION, empty_accels); /* Finally remove action */ g_action_map_remove_action (G_ACTION_MAP (plugin->window), EOG_FIT_TO_WIDTH_PLUGIN_ACTION); }
static void initialize_app_menu (GApplication *application) { gboolean show_app_menu; GtkBuilder *builder; g_object_get (gtk_settings_get_default (), "gtk-shell-shows-app-menu", &show_app_menu, NULL); if (! show_app_menu) return; g_action_map_add_action_entries (G_ACTION_MAP (application), app_menu_entries, G_N_ELEMENTS (app_menu_entries), application); builder = _gtk_builder_new_from_resource ("app-menu.ui"); gtk_application_set_app_menu (GTK_APPLICATION (application), G_MENU_MODEL (gtk_builder_get_object (builder, "app-menu"))); g_object_unref (builder); }
static GtkWidget* get_popup (EogZoomEntry *zoom_entry) { GdkRectangle rect; if (zoom_entry->priv->popup) return zoom_entry->priv->popup; zoom_entry->priv->popup = gtk_popover_new_from_model (GTK_WIDGET (zoom_entry), G_MENU_MODEL (zoom_entry->priv->menu)); g_signal_connect (zoom_entry->priv->popup, "closed", G_CALLBACK (popup_menu_closed), zoom_entry); gtk_entry_get_icon_area (GTK_ENTRY (zoom_entry->priv->value_entry), GTK_ENTRY_ICON_SECONDARY, &rect); gtk_popover_set_relative_to (GTK_POPOVER (zoom_entry->priv->popup), zoom_entry->priv->value_entry); gtk_popover_set_pointing_to (GTK_POPOVER (zoom_entry->priv->popup), &rect); gtk_popover_set_position (GTK_POPOVER (zoom_entry->priv->popup), GTK_POS_BOTTOM); gtk_widget_set_size_request (zoom_entry->priv->popup, 150, -1); return zoom_entry->priv->popup; }
static void dss_app_startup (GApplication * app) { GtkBuilder *builder; GMenuModel *app_menu; const gchar *quit_accels[2] = { "<Ctrl>Q", NULL }; G_APPLICATION_CLASS (dss_app_parent_class)->startup (app); /* Setup app menu and accels */ g_action_map_add_action_entries (G_ACTION_MAP (app), app_entries, G_N_ELEMENTS (app_entries), app); gtk_application_set_accels_for_action (GTK_APPLICATION (app), "app.quit", quit_accels); builder = gtk_builder_new_from_resource (APPMENU_FILE); app_menu = G_MENU_MODEL (gtk_builder_get_object (builder, "appmenu")); gtk_application_set_app_menu (GTK_APPLICATION (app), app_menu); g_object_unref (builder); /* Initialize gstreamer only once per application */ gst_init (NULL, NULL); }
static void photos_base_model_refresh (PhotosBaseModel *self) { g_autoptr (GMenu) section = NULL; const gchar *action_id; const gchar *title; guint i; guint n_items; g_menu_remove_all (self->model); title = photos_base_manager_get_title (self->mngr); action_id = photos_base_manager_get_action_id (self->mngr); section = g_menu_new (); g_menu_append_section (self->model, title, G_MENU_MODEL (section)); n_items = g_list_model_get_n_items (G_LIST_MODEL (self->mngr)); for (i = 0; i < n_items; i++) { g_autoptr (GMenuItem) menu_item = NULL; g_autoptr (GObject) object = NULL; const gchar *id; g_autofree gchar *name = NULL; object = g_list_model_get_object (G_LIST_MODEL (self->mngr), i); if (!photos_filterable_is_search_criterion (PHOTOS_FILTERABLE (object))) continue; id = photos_filterable_get_id (PHOTOS_FILTERABLE (object)); g_object_get (object, "name", &name, NULL); menu_item = g_menu_item_new (name, NULL); g_menu_item_set_action_and_target (menu_item, action_id, "s", id); g_menu_append_item (section, menu_item); } }
static void initialize_app_menu (GApplication *application) { GooApplication *self = (GooApplication *) application; GtkBuilder *builder; g_action_map_add_action_entries (G_ACTION_MAP (application), goo_application_actions, G_N_ELEMENTS (goo_application_actions), application); builder = _gtk_builder_new_from_resource ("app-menu.ui"); gtk_application_set_app_menu (GTK_APPLICATION (application), G_MENU_MODEL (gtk_builder_get_object (builder, "app-menu"))); g_simple_action_set_state (G_SIMPLE_ACTION (g_action_map_lookup_action (G_ACTION_MAP (application), PREF_PLAYLIST_PLAYALL)), g_variant_new_boolean (g_settings_get_boolean (self->priv->settings, PREF_PLAYLIST_PLAYALL))); g_simple_action_set_state (G_SIMPLE_ACTION (g_action_map_lookup_action (G_ACTION_MAP (application), PREF_PLAYLIST_REPEAT)), g_variant_new_boolean (g_settings_get_boolean (self->priv->settings, PREF_PLAYLIST_REPEAT))); g_simple_action_set_state (G_SIMPLE_ACTION (g_action_map_lookup_action (G_ACTION_MAP (application), PREF_PLAYLIST_SHUFFLE)), g_variant_new_boolean (g_settings_get_boolean (self->priv->settings, PREF_PLAYLIST_SHUFFLE))); g_signal_connect (self->priv->settings, "changed::" PREF_PLAYLIST_PLAYALL, G_CALLBACK (pref_playlist_playall_changed), self); g_signal_connect (self->priv->settings, "changed::" PREF_PLAYLIST_SHUFFLE, G_CALLBACK (pref_playlist_shuffle_changed), self); g_signal_connect (self->priv->settings, "changed::" PREF_PLAYLIST_REPEAT, G_CALLBACK (pref_playlist_repeat_changed), self); g_object_unref (builder); }
void list_tools__gth_browser_construct_cb (GthBrowser *browser) { BrowserData *data; GtkBuilder *builder; GMenuModel *menu; GtkWidget *button; g_return_if_fail (GTH_IS_BROWSER (browser)); data = g_new0 (BrowserData, 1); data->browser = browser; g_object_set_data_full (G_OBJECT (browser), BROWSER_DATA_KEY, data, (GDestroyNotify) browser_data_free); g_action_map_add_action_entries (G_ACTION_MAP (browser), actions, G_N_ELEMENTS (actions), browser); builder = gtk_builder_new_from_resource ("/org/gnome/gThumb/list_tools/data/ui/tools-menu.ui"); gth_browser_add_menu_manager_for_menu (browser, GTH_BROWSER_MENU_MANAGER_TOOLS, G_MENU (gtk_builder_get_object (builder, "tools1"))); gth_browser_add_menu_manager_for_menu (browser, GTH_BROWSER_MENU_MANAGER_MORE_TOOLS, G_MENU (gtk_builder_get_object (builder, "tools2"))); gth_browser_add_menu_manager_for_menu (browser, GTH_BROWSER_MENU_MANAGER_TOOLS3, G_MENU (gtk_builder_get_object (builder, "tools3"))); menu = G_MENU_MODEL (gtk_builder_get_object (builder, "tools-menu")); /* browser tools */ button = _gtk_menu_button_new_for_header_bar (); g_signal_connect (button, "toggled", G_CALLBACK (tools_menu_button_toggled_cb), data); gtk_widget_set_tooltip_text (button, _("Tools")); gtk_container_add (GTK_CONTAINER (button), gtk_image_new_from_icon_name ("tools-symbolic", GTK_ICON_SIZE_MENU)); gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (button), menu); gtk_widget_show_all (button); gtk_box_pack_start (GTK_BOX (gth_browser_get_headerbar_section (browser, GTH_BROWSER_HEADER_SECTION_BROWSER_TOOLS)), button, FALSE, FALSE, 0); g_object_unref (builder); }
static gboolean mouse_press_handler( GtkWidget *widget, GdkEvent *event, gpointer data ) { GdkEventButton *btn_event = (GdkEventButton *)event; gboolean handled; handled = ( btn_event->type == GDK_BUTTON_PRESS && btn_event->button == 3 ); if(handled) { GMenu *menu; GMenuItem *add_menu_item; GMenuItem *loop_menu_item; GtkWidget *ctx_menu; menu = g_menu_new(); add_menu_item = g_menu_item_new(_("_Add…"), "app.open(true)"); loop_menu_item = g_menu_item_new(_("Loop"), "app.loop"); g_menu_append_item(menu, add_menu_item); g_menu_append_item(menu, loop_menu_item); g_menu_freeze(menu); ctx_menu = gtk_menu_new_from_model(G_MENU_MODEL(menu)); gtk_menu_attach_to_widget(GTK_MENU(ctx_menu), widget, NULL); gtk_widget_show_all(ctx_menu); gtk_menu_popup( GTK_MENU(ctx_menu), NULL, NULL, NULL, NULL, btn_event->button, btn_event->time ); } return handled; }
static void example_app_window_init (ExampleAppWindow *win) { ExampleAppWindowPrivate *priv; GtkBuilder *builder; GMenuModel *menu; GAction *action; priv = example_app_window_get_instance_private (win); gtk_widget_init_template (GTK_WIDGET (win)); priv->settings = g_settings_new ("org.gtk.exampleapp"); g_settings_bind (priv->settings, "transition", priv->stack, "transition-type", G_SETTINGS_BIND_DEFAULT); g_settings_bind (priv->settings, "show-words", priv->sidebar, "reveal-child", G_SETTINGS_BIND_DEFAULT); g_object_bind_property (priv->search, "active", priv->searchbar, "search-mode-enabled", G_BINDING_BIDIRECTIONAL); g_signal_connect (priv->sidebar, "notify::reveal-child", G_CALLBACK (words_changed), win); builder = gtk_builder_new_from_resource ("/org/gtk/exampleapp/gears-menu.ui"); menu = G_MENU_MODEL (gtk_builder_get_object (builder, "menu")); gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (priv->gears), menu); g_object_unref (builder); action = g_settings_create_action (priv->settings, "show-words"); g_action_map_add_action (G_ACTION_MAP (win), action); g_object_unref (action); }
void create_main_window (GsmApplication *app) { GtkApplicationWindow *main_window; GtkStack *stack; GtkMenuButton *process_menu_button; GMenuModel *process_menu_model; GdkDisplay *display; GdkMonitor *monitor; GdkRectangle monitor_geometry; const char* session; int width, height, xpos, ypos; GtkBuilder *builder = gtk_builder_new(); gtk_builder_add_from_resource (builder, "/org/gnome/gnome-system-monitor/data/interface.ui", NULL); gtk_builder_add_from_resource (builder, "/org/gnome/gnome-system-monitor/data/menus.ui", NULL); main_window = GTK_APPLICATION_WINDOW (gtk_builder_get_object (builder, "main_window")); gtk_window_set_application (GTK_WINDOW (main_window), app->gobj()); gtk_widget_set_name (GTK_WIDGET (main_window), "gnome-system-monitor"); app->main_window = main_window; session = g_getenv ("XDG_CURRENT_DESKTOP"); if (session && !strstr (session, "GNOME")){ GtkBox *mainbox; GtkHeaderBar *headerbar; mainbox = GTK_BOX (gtk_builder_get_object (builder, "main_box")); headerbar = GTK_HEADER_BAR (gtk_builder_get_object (builder, "header_bar")); gtk_style_context_remove_class (gtk_widget_get_style_context (GTK_WIDGET (headerbar)), "titlebar"); gtk_window_set_titlebar (GTK_WINDOW (main_window), NULL); gtk_header_bar_set_show_close_button (headerbar, FALSE); gtk_box_pack_start (mainbox, GTK_WIDGET (headerbar), FALSE, FALSE, 0); } g_settings_get (app->settings->gobj(), GSM_SETTING_WINDOW_STATE, "(iiii)", &width, &height, &xpos, &ypos); display = gdk_display_get_default (); monitor = gdk_display_get_monitor_at_point (display, xpos, ypos); if (monitor == NULL) { monitor = gdk_display_get_monitor (display, 0); } gdk_monitor_get_geometry (monitor, &monitor_geometry); width = CLAMP (width, 50, monitor_geometry.width); height = CLAMP (height, 50, monitor_geometry.height); xpos = CLAMP (xpos, 0, monitor_geometry.width - width); ypos = CLAMP (ypos, 0, monitor_geometry.height - height); gtk_window_set_default_size (GTK_WINDOW (main_window), width, height); gtk_window_move (GTK_WINDOW (main_window), xpos, ypos); if (app->settings->get_boolean (GSM_SETTING_MAXIMIZED)) gtk_window_maximize (GTK_WINDOW (main_window)); app->process_menu_button = process_menu_button = GTK_MENU_BUTTON (gtk_builder_get_object (builder, "process_menu_button")); process_menu_model = G_MENU_MODEL (gtk_builder_get_object (builder, "process-window-menu")); gtk_menu_button_set_menu_model (process_menu_button, process_menu_model); app->end_process_button = GTK_BUTTON (gtk_builder_get_object (builder, "end_process_button")); app->search_button = GTK_BUTTON (gtk_builder_get_object (builder, "search_button")); GActionEntry win_action_entries[] = { { "about", on_activate_about, NULL, NULL, NULL }, { "search", on_activate_search, "b", "false", NULL }, { "send-signal-stop", on_activate_send_signal, "i", NULL, NULL }, { "send-signal-cont", on_activate_send_signal, "i", NULL, NULL }, { "send-signal-end", on_activate_send_signal, "i", NULL, NULL }, { "send-signal-kill", on_activate_send_signal, "i", NULL, NULL }, { "priority", on_activate_priority, "i", "@i 0", change_priority_state }, { "memory-maps", on_activate_memory_maps, NULL, NULL, NULL }, { "open-files", on_activate_open_files, NULL, NULL, NULL }, { "process-properties", on_activate_process_properties, NULL, NULL, NULL }, { "refresh", on_activate_refresh, NULL, NULL, NULL }, { "show-page", on_activate_radio, "s", "'resources'", change_show_page_state }, { "show-whose-processes", on_activate_radio, "s", "'all'", change_show_processes_state }, { "show-dependencies", on_activate_toggle, NULL, "false", change_show_dependencies_state } }; g_action_map_add_action_entries (G_ACTION_MAP (main_window), win_action_entries, G_N_ELEMENTS (win_action_entries), app); GdkScreen* screen = gtk_widget_get_screen(GTK_WIDGET (main_window)); GdkVisual* visual = gdk_screen_get_rgba_visual(screen); /* use visual, if available */ if (visual) gtk_widget_set_visual(GTK_WIDGET (main_window), visual); /* create the main stack */ app->stack = stack = GTK_STACK (gtk_builder_get_object (builder, "stack")); create_proc_view(app, builder); create_sys_view (app, builder); create_disk_view (app, builder); g_settings_bind (app->settings->gobj (), GSM_SETTING_CURRENT_TAB, stack, "visible-child-name", G_SETTINGS_BIND_DEFAULT); g_signal_connect (G_OBJECT (stack), "notify::visible-child", G_CALLBACK (cb_change_current_page), app); g_signal_connect (G_OBJECT (main_window), "delete_event", G_CALLBACK (cb_main_window_delete), app); g_signal_connect (G_OBJECT (main_window), "window-state-event", G_CALLBACK (cb_main_window_state_changed), app); GAction *action; action = g_action_map_lookup_action (G_ACTION_MAP (main_window), "show-dependencies"); g_action_change_state (action, g_settings_get_value (app->settings->gobj (), GSM_SETTING_SHOW_DEPENDENCIES)); action = g_action_map_lookup_action (G_ACTION_MAP (main_window), "show-whose-processes"); g_action_change_state (action, g_settings_get_value (app->settings->gobj (), GSM_SETTING_SHOW_WHOSE_PROCESSES)); gtk_widget_show (GTK_WIDGET (main_window)); update_page_activities (app); g_object_unref (G_OBJECT (builder)); }
static void gdaui_dsn_editor_init (GdauiDsnEditor *config, G_GNUC_UNUSED GdauiDsnEditorClass *klass) { GtkWidget *grid; GtkWidget *label; GtkWidget *exp; gchar *str; g_return_if_fail (GDAUI_IS_DSN_EDITOR (config)); gtk_orientable_set_orientation (GTK_ORIENTABLE (config), GTK_ORIENTATION_VERTICAL); /* allocate private structure */ config->priv = g_new0 (GdauiDsnEditorPrivate, 1); config->priv->dsn_info = g_new0 (GdaDsnInfo, 1); config->priv->no_change_signal = TRUE; /* data source's name and icon */ GtkWidget *hbox_header; hbox_header = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start (GTK_BOX (config), hbox_header, FALSE, FALSE, 6); config->priv->icon = gtk_image_new (); gtk_widget_set_size_request (config->priv->icon, -1, SUPPORT_ICON_SIZE); gtk_box_pack_start (GTK_BOX (hbox_header), config->priv->icon, FALSE, FALSE, 0); config->priv->wname = gtk_label_new (""); gtk_box_pack_start (GTK_BOX (hbox_header), config->priv->wname, FALSE, FALSE, 10); GtkWidget *menu_button; menu_button = gtk_menu_button_new (); gtk_box_pack_end (GTK_BOX (hbox_header), menu_button, FALSE, FALSE, 0); GtkWidget *menu_icon; menu_icon = gtk_image_new_from_icon_name ("open-menu-symbolic", GTK_ICON_SIZE_MENU); gtk_button_set_image (GTK_BUTTON (menu_button), menu_icon); GMenu *smenu; smenu = g_menu_new (); gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (menu_button), G_MENU_MODEL (smenu)); GMenuItem *mitem; mitem = g_menu_item_new ("Test data source", "win.DSNTest"); g_menu_insert_item (smenu, -1, mitem); mitem = g_menu_item_new ("Reset data source's changes", "win.DSNReset"); g_menu_insert_item (smenu, -1, mitem); mitem = g_menu_item_new ("Duplicate data source", "win.DSNCopy"); g_menu_insert_item (smenu, -1, mitem); GtkWindow *win; win = gtk_application_get_active_window (GTK_APPLICATION (g_application_get_default ())); g_action_map_add_action_entries (G_ACTION_MAP (win), win_entries, G_N_ELEMENTS (win_entries), config); /* stack in a scrolled window */ GtkWidget *sw; sw = gtk_scrolled_window_new (NULL, NULL); gtk_widget_set_vexpand (sw, TRUE); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_NONE); gtk_box_pack_start (GTK_BOX (config), sw, TRUE, TRUE, 6); /* Stack */ config->priv->stack = gtk_stack_new (); gtk_stack_set_transition_type (GTK_STACK (config->priv->stack), GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT); gtk_container_add (GTK_CONTAINER (sw), config->priv->stack); /* set up widgets */ grid = gtk_grid_new (); gtk_grid_set_row_spacing (GTK_GRID (grid), 6); gtk_grid_set_column_spacing (GTK_GRID (grid), 6); gtk_widget_show (grid); label = gtk_label_new_with_mnemonic (_("_System wide data source:")); gtk_widget_set_halign (label, GTK_ALIGN_START); gtk_widget_set_hexpand (label, FALSE); g_object_set (G_OBJECT (label), "xalign", 0., NULL); gtk_widget_show (label); gtk_grid_attach (GTK_GRID (grid), label, 0, 1, 1, 1); config->priv->is_system = gtk_check_button_new (); gtk_widget_show (config->priv->is_system); g_signal_connect (G_OBJECT (config->priv->is_system), "toggled", G_CALLBACK (field_toggled_cb), config); gtk_grid_attach (GTK_GRID (grid), config->priv->is_system, 1, 1, 1, 1); str = g_strdup_printf ("%s <span foreground='red' weight='bold'>*</span>", _("_Provider:")); label = gtk_label_new (""); gtk_label_set_markup_with_mnemonic (GTK_LABEL (label), str); g_free (str); gtk_widget_set_halign (label, GTK_ALIGN_START); gtk_widget_set_hexpand (label, FALSE); g_object_set (G_OBJECT (label), "xalign", 0., NULL); gtk_widget_show (label); gtk_grid_attach (GTK_GRID (grid), label, 0, 2, 1, 1); config->priv->wprovider = gdaui_provider_selector_new (); gtk_widget_set_hexpand (config->priv->wprovider, TRUE); gtk_label_set_mnemonic_widget (GTK_LABEL (label), config->priv->wprovider); gtk_widget_show (config->priv->wprovider); g_signal_connect (G_OBJECT (config->priv->wprovider), "changed", G_CALLBACK (field_changed_cb), config); gtk_grid_attach (GTK_GRID (grid), config->priv->wprovider, 1, 2, 1, 1); label = gtk_label_new_with_mnemonic (_("_Description:")); gtk_widget_set_halign (label, GTK_ALIGN_START); gtk_widget_set_hexpand (label, FALSE); g_object_set (G_OBJECT (label), "xalign", 0., NULL); gtk_widget_show (label); gtk_grid_attach (GTK_GRID (grid), label, 0, 3, 1, 1); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER); config->priv->wdesc = gtk_text_view_new (); gtk_container_add (GTK_CONTAINER (sw), config->priv->wdesc); gtk_text_view_set_editable (GTK_TEXT_VIEW (config->priv->wdesc), TRUE); gtk_widget_set_vexpand (config->priv->wdesc, TRUE); gtk_label_set_mnemonic_widget (GTK_LABEL (label), config->priv->wdesc); g_signal_connect (gtk_text_view_get_buffer (GTK_TEXT_VIEW (config->priv->wdesc)), "changed", G_CALLBACK (field_changed_cb), config); gtk_grid_attach (GTK_GRID (grid), sw, 1, 3, 1, 1); config->priv->warning = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (config->priv->warning), _("<span foreground='red'>The database provider used by this data source is not available,\n" "editing the data source's attributes is disabled</span>")); gtk_widget_set_halign (config->priv->warning, GTK_ALIGN_CENTER); gtk_widget_set_hexpand (config->priv->warning, TRUE); g_object_set (G_OBJECT (config->priv->warning), "xalign", 0.5, NULL); gtk_label_set_justify (GTK_LABEL (config->priv->warning), GTK_JUSTIFY_CENTER); gtk_label_set_line_wrap (GTK_LABEL (config->priv->warning), TRUE); gtk_grid_attach (GTK_GRID (grid), config->priv->warning, 0, 8, 2, 1); gtk_stack_add_named (GTK_STACK (config->priv->stack), grid, PANE_DEFINITION); /* connection's spec */ config->priv->dsn_spec = _gdaui_provider_spec_editor_new (gdaui_provider_selector_get_provider (GDAUI_PROVIDER_SELECTOR (config->priv->wprovider))); g_signal_connect (G_OBJECT (config->priv->dsn_spec), "changed", G_CALLBACK (field_changed_cb), config); gtk_widget_show (config->priv->dsn_spec); gtk_stack_add_named (GTK_STACK (config->priv->stack), config->priv->dsn_spec, PANE_PARAMS); /* connection's authentication */ config->priv->dsn_auth = _gdaui_provider_auth_editor_new (gdaui_provider_selector_get_provider (GDAUI_PROVIDER_SELECTOR (config->priv->wprovider))); g_signal_connect (G_OBJECT (config->priv->dsn_auth), "changed", G_CALLBACK (field_changed_cb), config); gtk_widget_show (config->priv->dsn_auth); gtk_stack_add_named (GTK_STACK (config->priv->stack), config->priv->dsn_auth, PANE_AUTH); config->priv->no_change_signal = FALSE; }
int main (int argc, char **argv) { GtkWidget *window; GtkWidget *button; GtkWidget *grid; GtkWidget *entry; GtkWidget *menu_widget; GtkAccelGroup *accel_group; guint i; GMenu *menu; gtk_init (&argc, &argv); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_resize (GTK_WINDOW (window), 400, 300); grid = gtk_grid_new (); gtk_container_add (GTK_CONTAINER (window), grid); accel_group = gtk_accel_group_new (); gtk_window_add_accel_group (GTK_WINDOW (window), accel_group); /* Button next to entry */ entry = gtk_entry_new (); gtk_grid_attach (GTK_GRID (grid), entry, 0, 0, 1, 1); button = gtk_menu_button_new (); gtk_grid_attach (GTK_GRID (grid), button, 1, 0, 1, 1); /* Button with GtkMenu */ menu_widget = gtk_menu_new (); for (i = 5; i > 0; i--) { GtkWidget *item; if (i == 3) { item = gtk_menu_item_new_with_mnemonic ("_Copy"); } else { char *label; label = g_strdup_printf ("Item _%d", i); item = gtk_menu_item_new_with_mnemonic (label); g_free (label); } gtk_menu_item_set_use_underline (GTK_MENU_ITEM (item), TRUE); gtk_menu_attach (GTK_MENU (menu_widget), item, 0, 1, i - 1, i); } gtk_widget_show_all (menu_widget); button = gtk_menu_button_new (); gtk_menu_button_set_popup (GTK_MENU_BUTTON (button), menu_widget); gtk_grid_attach (GTK_GRID (grid), button, 1, 1, 1, 1); gtk_widget_show (create_prop_editor (G_OBJECT (button), 0)); /* Button with GMenuModel */ menu = g_menu_new (); for (i = 5; i > 0; i--) { char *label; GMenuItem *item; label = g_strdup_printf ("Item _%d", i); item = g_menu_item_new (label, NULL); if (i == 3) g_menu_item_set_attribute (item, "icon", "s", "preferences-desktop-locale-symbolic"); g_menu_insert_item (menu, i - 1, item); g_object_unref (item); g_free (label); } button = gtk_menu_button_new (); gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (button), G_MENU_MODEL (menu)); gtk_grid_attach (GTK_GRID (grid), button, 1, 2, 1, 1); gtk_widget_show_all (window); gtk_main (); return 0; }
static void app_startup_handler(GApplication *app, gpointer data) { gmpv_handle *ctx = data; const gchar *vid_area_style = ".gmpv-vid-area{background-color: black}"; GSettingsBackend *config_backend; GtkCssProvider *style_provider; gboolean css_loaded; gboolean use_opengl; gboolean config_migrated; gboolean mpvinput_enable; gboolean csd_enable; gboolean dark_theme_enable; gchar *config_file; gchar *mpvinput; setlocale(LC_NUMERIC, "C"); g_set_application_name(_("GNOME MPV")); gtk_window_set_default_icon_name(ICON_NAME); bindtextdomain(GETTEXT_PACKAGE, PACKAGE_LOCALEDIR); bind_textdomain_codeset(GETTEXT_PACKAGE, "UTF-8"); textdomain(GETTEXT_PACKAGE); config_file = get_config_file_path(); config_backend = g_keyfile_settings_backend_new ( config_file, CONFIG_ROOT_PATH, CONFIG_ROOT_GROUP ); use_opengl = get_use_opengl(); ctx->mpv_ctx = mpv_create(); ctx->files = NULL; ctx->opengl_ctx = NULL; ctx->opengl_ready = FALSE; ctx->paused = TRUE; ctx->loaded = FALSE; ctx->new_file = TRUE; ctx->sub_visible = TRUE; ctx->init_load = TRUE; ctx->playlist_move_dest = -1; ctx->log_level_list = NULL; ctx->keybind_list = NULL; ctx->config = g_settings_new_with_backend(APP_ID, config_backend); ctx->app = GTK_APPLICATION(app); ctx->gui = MAIN_WINDOW(main_window_new(ctx->app, use_opengl)); ctx->fs_control = NULL; ctx->playlist_store = PLAYLIST_WIDGET(ctx->gui->playlist)->list_store; config_migrated = migrate_config(ctx); style_provider = gtk_css_provider_new(); css_loaded = gtk_css_provider_load_from_data (style_provider, vid_area_style, -1, NULL); if(!css_loaded) { g_warning ("Failed to apply background color css"); } gtk_style_context_add_provider_for_screen ( gtk_window_get_screen(GTK_WINDOW(ctx->gui)), GTK_STYLE_PROVIDER(style_provider), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION ); g_object_unref(style_provider); csd_enable = g_settings_get_boolean (ctx->config, "csd-enable"); dark_theme_enable = g_settings_get_boolean (ctx->config, "dark-theme-enable"); mpvinput_enable = g_settings_get_boolean (ctx->config, "mpv-input-config-enable"); mpvinput = g_settings_get_string (ctx->config, "mpv-input-config-file"); if(csd_enable) { gtk_application_set_app_menu (ctx->app, G_MENU_MODEL(build_app_menu())); main_window_enable_csd(ctx->gui); } else { gtk_application_set_app_menu (ctx->app, NULL); gtk_application_set_menubar (ctx->app, G_MENU_MODEL(build_full_menu())); } gtk_widget_show_all(GTK_WIDGET(ctx->gui)); if(csd_enable) { control_box_set_fullscreen_btn_visible (CONTROL_BOX(ctx->gui->control_box), FALSE); } control_box_set_chapter_enabled (CONTROL_BOX(ctx->gui->control_box), FALSE); if(!main_window_get_use_opengl(ctx->gui)) { ctx->vid_area_wid = get_xid(ctx->gui->vid_area); } g_assert( main_window_get_use_opengl(ctx->gui) || ctx->vid_area_wid != -1 ); main_window_load_state(ctx->gui); setup_accelerators(ctx); setup_dnd_targets(ctx); actionctl_map_actions(ctx); connect_signals(ctx); load_keybind(ctx, mpvinput_enable?mpvinput:NULL, FALSE); mpris_init(ctx); media_keys_init(ctx); g_object_set( ctx->gui->settings, "gtk-application-prefer-dark-theme", dark_theme_enable, NULL ); g_timeout_add( SEEK_BAR_UPDATE_INTERVAL, (GSourceFunc)update_seek_bar, ctx ); if(config_migrated) { GtkWidget *dialog = gtk_message_dialog_new ( GTK_WINDOW(ctx->gui), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_INFO, GTK_BUTTONS_OK, _("Your configuration file has been " "moved to the new location at %s."), config_file ); gtk_dialog_run(GTK_DIALOG(dialog)); gtk_widget_destroy(dialog); } g_free(config_file); g_free(mpvinput); }
/*********************************************************************** Menu */ void bmd_construct_menu (GtkApplication *app, gpointer data) { GtkWidget *headerbar; // the application menu displayed in the GNOME panel GMenu *appmenu; GMenu *editmenu; GtkWidget *openbutton; GtkWidget *savebutton; // the menu displayed as a popover below the gears button GMenu *gearmenu; GtkWidget *gearmenubutton; GtkWidget *gearicon; bmd_widgets *a = (bmd_widgets *) data; // define keyboard accelerators const gchar *open_accels[2] = { "<Ctrl>O", NULL }; const gchar *save_accels[2] = { "<Ctrl>S", NULL }; const gchar *quit_accels[2] = { "<Ctrl>Q", NULL }; const gchar *add_accels[2] = { "<Ctrl>A", NULL }; const gchar *del_accels[2] = { "<Ctrl>D", NULL }; const gchar *find_accels[2] = { "<Ctrl>F", NULL }; const gchar *help_accels[2] = { "F1", NULL }; // create and fill in the application menu in the GNOME panel appmenu = g_menu_new(); g_menu_append (appmenu, "About", "app.about"); g_menu_append (appmenu, "Help", "app.help"); g_menu_append (appmenu, "_Quit", "app.quit"); gtk_application_set_app_menu (GTK_APPLICATION (app), G_MENU_MODEL (appmenu)); g_object_unref (appmenu); // create a headerbar headerbar = gtk_header_bar_new (); gtk_widget_show (headerbar); gtk_header_bar_set_title (GTK_HEADER_BAR (headerbar), "Book Management"); gtk_header_bar_set_subtitle (GTK_HEADER_BAR (headerbar), "Simple Demo Application"); gtk_header_bar_set_show_close_button (GTK_HEADER_BAR (headerbar), TRUE); gtk_window_set_titlebar (GTK_WINDOW (a->window), headerbar); // create an OPEN button, add it to the headerbar and connect the callbacks openbutton = gtk_button_new_with_label ("Open"); gtk_header_bar_pack_start (GTK_HEADER_BAR (headerbar), openbutton); gtk_actionable_set_action_name (GTK_ACTIONABLE (openbutton), "app.open"); // create the gear menu button gearmenubutton = gtk_menu_button_new(); gearicon = gtk_image_new_from_icon_name ("emblem-system-symbolic", GTK_ICON_SIZE_SMALL_TOOLBAR); gtk_button_set_image (GTK_BUTTON (gearmenubutton), gearicon); gtk_header_bar_pack_end (GTK_HEADER_BAR (headerbar), gearmenubutton); // create a menu for the gear button gearmenu = g_menu_new(); g_menu_append (gearmenu, "Save As ...", "app.saveAs"); editmenu = g_menu_new(); g_menu_append (editmenu, "_Find", "app.find"); g_menu_append (editmenu, "_Add", "app.add"); g_menu_append (editmenu, "_Delete", "app.delete"); g_menu_append_section (gearmenu, NULL, G_MENU_MODEL (editmenu)); gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (gearmenubutton), G_MENU_MODEL (gearmenu)); g_object_unref (editmenu); g_object_unref (gearmenu); // create an SAVE button, add it to the headerbar and connect the callbacks savebutton = gtk_button_new_with_label ("Save"); gtk_header_bar_pack_end (GTK_HEADER_BAR (headerbar), savebutton); gtk_actionable_set_action_name (GTK_ACTIONABLE (savebutton), "app.save"); // connect keyboard accelerators gtk_application_set_accels_for_action (GTK_APPLICATION (app), "app.open", open_accels); gtk_application_set_accels_for_action (GTK_APPLICATION (app), "app.save", save_accels); gtk_application_set_accels_for_action (GTK_APPLICATION (app), "app.quit", quit_accels); gtk_application_set_accels_for_action (GTK_APPLICATION (app), "app.add", add_accels); gtk_application_set_accels_for_action (GTK_APPLICATION (app), "app.delete", del_accels); gtk_application_set_accels_for_action (GTK_APPLICATION (app), "app.find", find_accels); gtk_application_set_accels_for_action (GTK_APPLICATION (app), "app.help", help_accels); }
static GMenuModel * irc_context_default_get_menu (IrcContext *self) { return G_MENU_MODEL(g_menu_new ()); }
static gboolean on_listview_button_press_event (GtkWidget *widget, GdkEventButton *event, gpointer user_data) { //printf("popup menu\n"); g_return_val_if_fail (user_data != NULL, FALSE); g_return_val_if_fail (event != NULL, FALSE); if (G_UNLIKELY (event->window != gtk_tree_view_get_bin_window (GTK_TREE_VIEW (widget)))) { // clicked outside of list (e.g. column header) return FALSE; } if (event->type == GDK_BUTTON_PRESS) { if (event->button == GDK_BUTTON_SECONDARY) { GtkTreeView *view = GTK_TREE_VIEW (widget); GtkTreePath *path = NULL; GtkTreeSelection *selection = gtk_tree_view_get_selection (view); if ((event->state & gtk_accelerator_get_default_mod_mask ()) == 0 && !gtk_tree_view_get_path_at_pos (view, event->x, event->y, &path, NULL, NULL, NULL)) { // clicked empty area gtk_tree_selection_unselect_all (selection); return FALSE; } if (!path) { return FALSE; } if (!gtk_tree_selection_path_is_selected (selection, path)) { gtk_tree_selection_unselect_all (selection); gtk_tree_selection_select_path (selection, path); } GtkBuilder *builder = gtk_builder_new_from_resource ("/org/fsearch/fsearch/menus.ui"); fill_open_with_menu (GTK_TREE_VIEW (widget), builder, path); GMenu *menu_root = G_MENU (gtk_builder_get_object (builder, "fsearch_listview_popup_menu")); GtkWidget *menu_widget = gtk_menu_new_from_model (G_MENU_MODEL (menu_root)); gtk_menu_attach_to_widget (GTK_MENU (menu_widget), GTK_WIDGET (widget), NULL); gtk_menu_popup (GTK_MENU (menu_widget), NULL, NULL, NULL, NULL, event->button, event->time); g_object_unref (builder); return TRUE; } } else if (event->type == GDK_2BUTTON_PRESS) { if (event->window == gtk_tree_view_get_bin_window (GTK_TREE_VIEW (widget))) { GtkTreeViewColumn *column = NULL; GtkTreePath *path = NULL; gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (widget), event->x, event->y, &path, &column, NULL, NULL); if (path) { gtk_tree_path_free(path); } } } return FALSE; }
static void do_appwindow (GSimpleAction *action, GVariant *parameter, gpointer user_data) { GtkWidget *window; GtkWidget *grid; GtkWidget *statusbar; GtkWidget *contents; GtkWidget *sw; GtkTextBuffer *buffer; GSimpleActionGroup *action_group; GtkBuilder *builder; GMenuModel *model; GtkWidget *menubar; GtkWidget *toolbar; /* 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); grid = gtk_grid_new (); gtk_widget_set_vexpand (grid, TRUE); gtk_widget_set_hexpand (grid, TRUE); gtk_container_add (GTK_CONTAINER (window), grid); action_group = g_simple_action_group_new (); builder = gtk_builder_new_from_string (xml, -1); g_action_map_add_action_entries (G_ACTION_MAP (action_group), demo_entries, G_N_ELEMENTS (demo_entries), window); gtk_widget_insert_action_group (window, "demo", G_ACTION_GROUP (action_group)); /* Create the menubar */ model = G_MENU_MODEL (gtk_builder_get_object (builder, "menubar")); menubar = gtk_menu_bar_new_from_model (model); gtk_grid_attach (GTK_GRID (grid), menubar, 0, 0, 1, 1); gtk_widget_set_hexpand (menubar, TRUE); /* Create the toolbar */ toolbar = create_toolbar (); gtk_grid_attach (GTK_GRID (grid), toolbar, 0, 1, 1, 1); gtk_widget_set_hexpand (toolbar, TRUE); /* Create document */ contents = gtk_text_view_new (); 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_grid_attach (GTK_GRID (grid), sw, 0, 2, 1, 1); gtk_widget_set_hexpand (sw, TRUE); gtk_widget_set_vexpand (sw, TRUE); gtk_window_set_default_size (GTK_WINDOW (window), 200, 200); 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_grid_attach (GTK_GRID (grid), statusbar, 0, 3, 1, 1); gtk_widget_set_hexpand (statusbar, TRUE); /* 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); g_object_unref (action_group); g_object_unref (builder); }
static void plug_man_startup (GApplication *application) { GtkBuilder *builder; G_APPLICATION_CLASS (plug_man_parent_class) ->startup (application); g_action_map_add_action_entries (G_ACTION_MAP (application), app_entries, G_N_ELEMENTS (app_entries), application); builder = gtk_builder_new (); gtk_builder_add_from_string (builder, "<interface>" " <menu id='app-menu'>" " <section>" " <item>" " <attribute name='label' translatable='yes'>_About Plugman</attribute>" " <attribute name='action'>app.about</attribute>" " </item>" " </section>" " <section>" " <item>" " <attribute name='label' translatable='yes'>_Quit</attribute>" " <attribute name='action'>app.quit</attribute>" " <attribute name='accel'><Primary>q</attribute>" " </item>" " </section>" " </menu>" " <menu id='menubar'>" " <submenu>" " <attribute name='label' translatable='yes'>_Edit</attribute>" " <section>" " <item>" " <attribute name='label' translatable='yes'>_Copy</attribute>" " <attribute name='action'>win.copy</attribute>" " </item>" " <item>" " <attribute name='label' translatable='yes'>_Paste</attribute>" " <attribute name='action'>win.paste</attribute>" " </item>" " </section>" " <item><link name='section' id='plugins'>" " </link></item>" " <section>" " <item>" " <attribute name='label' translatable='yes'>Plugins</attribute>" " <attribute name='action'>app.plugins</attribute>" " </item>" " </section>" " </submenu>" " <submenu>" " <attribute name='label' translatable='yes'>_View</attribute>" " <section>" " <item>" " <attribute name='label' translatable='yes'>_Fullscreen</attribute>" " <attribute name='action'>win.fullscreen</attribute>" " </item>" " </section>" " </submenu>" " </menu>" "</interface>", -1, NULL); gtk_application_set_app_menu (GTK_APPLICATION (application), G_MENU_MODEL (gtk_builder_get_object (builder, "app-menu"))); gtk_application_set_menubar (GTK_APPLICATION (application), G_MENU_MODEL (gtk_builder_get_object (builder, "menubar"))); g_object_set_data_full (G_OBJECT (application), "plugin-menu", gtk_builder_get_object (builder, "plugins"), g_object_unref); g_object_unref (builder); }
void main_window_enable_csd(MainWindow *wnd) { GIcon *open_icon; GIcon *fullscreen_icon; GIcon *menu_icon; open_icon = g_themed_icon_new_with_default_fallbacks ("list-add-symbolic"); fullscreen_icon = g_themed_icon_new_with_default_fallbacks ("view-fullscreen-symbolic"); menu_icon = g_themed_icon_new_with_default_fallbacks ("view-list-symbolic"); wnd->playlist_width = PLAYLIST_DEFAULT_WIDTH+PLAYLIST_CSD_OFFSET; wnd->open_hdr_btn = gtk_menu_button_new(); wnd->fullscreen_hdr_btn = gtk_button_new(); wnd->menu_hdr_btn = gtk_menu_button_new(); gtk_widget_set_can_focus(wnd->open_hdr_btn, FALSE); gtk_widget_set_can_focus(wnd->fullscreen_hdr_btn, FALSE); gtk_widget_set_can_focus(wnd->menu_hdr_btn, FALSE); gtk_button_set_image ( GTK_BUTTON(wnd->fullscreen_hdr_btn), gtk_image_new_from_gicon (fullscreen_icon, GTK_ICON_SIZE_MENU )); gtk_button_set_image ( GTK_BUTTON(wnd->open_hdr_btn), gtk_image_new_from_gicon (open_icon, GTK_ICON_SIZE_MENU )); gtk_button_set_image ( GTK_BUTTON(wnd->menu_hdr_btn), gtk_image_new_from_gicon (menu_icon, GTK_ICON_SIZE_MENU )); gtk_menu_button_set_menu_model ( GTK_MENU_BUTTON(wnd->open_hdr_btn), G_MENU_MODEL(open_btn_build_menu()) ); gtk_menu_button_set_menu_model ( GTK_MENU_BUTTON(wnd->menu_hdr_btn), G_MENU_MODEL(menu_btn_build_menu()) ); gtk_header_bar_pack_start (GTK_HEADER_BAR(wnd->header_bar), wnd->open_hdr_btn); gtk_header_bar_pack_end (GTK_HEADER_BAR(wnd->header_bar), wnd->menu_hdr_btn); gtk_header_bar_pack_end (GTK_HEADER_BAR(wnd->header_bar), wnd->fullscreen_hdr_btn); gtk_actionable_set_action_name (GTK_ACTIONABLE(wnd->fullscreen_hdr_btn), "app.fullscreen"); gtk_paned_set_position( GTK_PANED(wnd->vid_area_paned), MAIN_WINDOW_DEFAULT_WIDTH -PLAYLIST_DEFAULT_WIDTH -PLAYLIST_CSD_OFFSET ); gtk_window_set_titlebar(GTK_WINDOW(wnd), wnd->header_bar); gtk_window_set_title(GTK_WINDOW(wnd), g_get_application_name()); }
/** * Sets up the application when it first starts */ void startup (GApplication *app, gpointer user_data) { // get ezeedo from user data ezeedo_wrapper_structure *ezeedo; ezeedo = user_data; // define widgets GMenu *menu; GMenu *section; // define actions GSimpleAction *preferences_action; GSimpleAction *quit_action; // create application menu menu = g_menu_new (); // create section section = g_menu_new (); // contruct application menu g_menu_append (section, "About", "win.about"); g_menu_append (section, "Quit", "app.quit"); g_menu_append (menu, "Preferences", "app.preferences"); g_menu_append_section (menu, NULL, G_MENU_MODEL (section)); // create actions preferences_action = g_simple_action_new ("preferences", NULL); g_signal_connect (preferences_action, "activate", G_CALLBACK(show_preferences_dialog), ezeedo); g_action_map_add_action (G_ACTION_MAP(app), G_ACTION(preferences_action)); // activate ctrl-q const gchar* quit_accels[2] = { "<Ctrl>Q", NULL }; gtk_application_set_accels_for_action (GTK_APPLICATION(app), "app.quit", quit_accels); quit_action = g_simple_action_new ("quit", NULL); g_signal_connect (quit_action, "activate", G_CALLBACK (quit_application), ezeedo); g_action_map_add_action (G_ACTION_MAP(app), G_ACTION(quit_action)); // Set menu for the overall application gtk_application_set_app_menu (GTK_APPLICATION(app), G_MENU_MODEL(menu)); return; }
static GMenu *menu_btn_build_menu() { GMenu *menu; GMenu *playlist_submenu; GMenu *sub_submenu; GMenu *view_submenu; GMenuItem *playlist_section; GMenuItem *sub_section; GMenuItem *view_section; GMenuItem *load_sub_menu_item; GMenuItem *playlist_toggle_menu_item; GMenuItem *playlist_save_menu_item; GMenuItem *fullscreen_menu_item; GMenuItem *normal_size_menu_item; GMenuItem *double_size_menu_item; GMenuItem *half_size_menu_item; menu = g_menu_new(); playlist_submenu = g_menu_new(); sub_submenu = g_menu_new(); view_submenu = g_menu_new(); playlist_section = g_menu_item_new_section(NULL, G_MENU_MODEL(playlist_submenu)); sub_section = g_menu_item_new_section(NULL, G_MENU_MODEL(sub_submenu)); view_section = g_menu_item_new_section(NULL, G_MENU_MODEL(view_submenu)); playlist_toggle_menu_item = g_menu_item_new(_("_Toggle Playlist"), "app.playlist_toggle"); playlist_save_menu_item = g_menu_item_new(_("_Save Playlist"), "app.playlist_save"); load_sub_menu_item = g_menu_item_new(_("_Load Subtitle"), "app.loadsub"); fullscreen_menu_item = g_menu_item_new(_("_Fullscreen"), "app.fullscreen"); normal_size_menu_item = g_menu_item_new(_("_Normal Size"), "app.normalsize"); double_size_menu_item = g_menu_item_new(_("_Double Size"), "app.doublesize"); half_size_menu_item = g_menu_item_new(_("_Half Size"), "app.halfsize"); g_menu_append_item(playlist_submenu, playlist_toggle_menu_item); g_menu_append_item(playlist_submenu, playlist_save_menu_item); g_menu_append_item(sub_submenu, load_sub_menu_item); g_menu_append_item(view_submenu, fullscreen_menu_item); g_menu_append_item(view_submenu, normal_size_menu_item); g_menu_append_item(view_submenu, double_size_menu_item); g_menu_append_item(view_submenu, half_size_menu_item); g_menu_append_item(menu, playlist_section); g_menu_append_item(menu, sub_section); g_menu_append_item(menu, view_section); return menu; }
{ .name="quit", menu_quit_cb } }; GActionEntry entries_for_tilda_terminal[] = { { .name="copy", menu_copy_cb}, { .name="paste", menu_paste_cb} }; g_action_map_add_action_entries(G_ACTION_MAP(action_group), entries_for_tilda_window, G_N_ELEMENTS(entries_for_tilda_window), tw); g_action_map_add_action_entries(G_ACTION_MAP(action_group), entries_for_tilda_terminal, G_N_ELEMENTS(entries_for_tilda_terminal), tt); gtk_widget_insert_action_group(tw->window, "window", G_ACTION_GROUP(action_group)); GMenuModel *menu_model = G_MENU_MODEL(gtk_builder_get_object(builder, "menu")); GtkWidget *menu = gtk_menu_new_from_model(menu_model); gtk_menu_attach_to_widget(GTK_MENU(menu), tw->window, NULL); gtk_menu_set_accel_group(GTK_MENU(menu), tw->accel_group); gtk_menu_set_accel_path(GTK_MENU(menu), "<tilda>/context"); /* Disable auto hide */ tw->disable_auto_hide = TRUE; g_signal_connect (G_OBJECT(menu), "unmap", G_CALLBACK(on_popup_hide), tw); /* Display the menu */ gtk_menu_popup (GTK_MENU(menu), NULL, NULL, NULL, NULL, 3, gtk_get_current_event_time()); gtk_widget_show_all(menu); }
static void ring_main_window_init(RingMainWindow *win) { RingMainWindowPrivate *priv = RING_MAIN_WINDOW_GET_PRIVATE(win); gtk_widget_init_template(GTK_WIDGET(win)); /* set window icon */ GError *error = NULL; GdkPixbuf* icon = gdk_pixbuf_new_from_resource("/cx/ring/RingGnome/ring-symbol-blue", &error); if (icon == NULL) { g_debug("Could not load icon: %s", error->message); g_clear_error(&error); } else gtk_window_set_icon(GTK_WINDOW(win), icon); /* set menu icon */ GdkPixbuf* image_ring = gdk_pixbuf_new_from_resource_at_scale("/cx/ring/RingGnome/ring-symbol-blue", -1, 24, TRUE, &error); if (image_ring == NULL) { g_debug("Could not load icon: %s", error->message); g_clear_error(&error); } else gtk_image_set_from_pixbuf(GTK_IMAGE(priv->image_ring), image_ring); /* ring menu */ GtkBuilder *builder = gtk_builder_new_from_resource("/cx/ring/RingGnome/ringgearsmenu.ui"); GMenuModel *menu = G_MENU_MODEL(gtk_builder_get_object(builder, "menu")); gtk_menu_button_set_menu_model(GTK_MENU_BUTTON(priv->ring_menu), menu); g_object_unref(builder); /* settings icon */ gtk_image_set_from_icon_name(GTK_IMAGE(priv->image_settings), "emblem-system-symbolic", GTK_ICON_SIZE_LARGE_TOOLBAR); /* connect settings button signal */ g_signal_connect(priv->ring_settings, "clicked", G_CALLBACK(settings_clicked), win); /* add the call view to the main stack */ gtk_stack_add_named(GTK_STACK(priv->stack_main_view), priv->vbox_call_view, CALL_VIEW_NAME); if (has_ring_account()) { /* user has ring account, so show the call view right away */ gtk_stack_set_visible_child(GTK_STACK(priv->stack_main_view), priv->vbox_call_view); } else { /* user has to create the ring account */ show_account_creation(win); } /* init the settings views */ priv->account_settings_view = account_view_new(); gtk_stack_add_named(GTK_STACK(priv->stack_main_view), priv->account_settings_view, ACCOUNT_SETTINGS_VIEW_NAME); priv->media_settings_view = media_settings_view_new(); gtk_stack_add_named(GTK_STACK(priv->stack_main_view), priv->media_settings_view, MEDIA_SETTINGS_VIEW_NAME); priv->general_settings_view = general_settings_view_new(); gtk_stack_add_named(GTK_STACK(priv->stack_main_view), priv->general_settings_view, GENERAL_SETTINGS_VIEW_NAME); /* make the setting we will show first the active one */ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->radiobutton_general_settings), TRUE); priv->last_settings_view = priv->general_settings_view; /* connect the settings button signals to switch settings views */ g_signal_connect(priv->radiobutton_media_settings, "toggled", G_CALLBACK(show_media_settings), win); g_signal_connect(priv->radiobutton_account_settings, "toggled", G_CALLBACK(show_account_settings), win); g_signal_connect(priv->radiobutton_general_settings, "toggled", G_CALLBACK(show_general_settings), win); /* populate the notebook */ auto smart_view = recent_contacts_view_new(); gtk_container_add(GTK_CONTAINER(priv->scrolled_window_smartview), smart_view); auto contacts_view = contacts_view_new(); gtk_container_add(GTK_CONTAINER(priv->scrolled_window_contacts), contacts_view); auto history_view = history_view_new(); gtk_container_add(GTK_CONTAINER(priv->scrolled_window_history), history_view); /* welcome/default view */ priv->welcome_view = ring_welcome_view_new(); g_object_ref(priv->welcome_view); // gtk_stack_add_named(GTK_STACK(priv->stack_call_view), welcome_view, DEFAULT_VIEW_NAME); gtk_container_add(GTK_CONTAINER(priv->frame_call), priv->welcome_view); gtk_widget_show(priv->welcome_view); /* call/chat selection */ QObject::connect( RecentModel::instance().selectionModel(), &QItemSelectionModel::currentChanged, [win](const QModelIndex current, G_GNUC_UNUSED const QModelIndex & previous) { if (auto call = RecentModel::instance().getActiveCall(current)) { /* if the call is on hold, we want to put it off hold automatically * when switching to it */ if (call->state() == Call::State::HOLD) call << Call::Action::HOLD; } selection_changed(current, win); } ); /* connect to dataChanged of the RecentModel to see if we need to change the view */ QObject::connect( &RecentModel::instance(), &RecentModel::dataChanged, [win](const QModelIndex & topLeft, G_GNUC_UNUSED const QModelIndex & bottomRight, G_GNUC_UNUSED const QVector<int> & roles) { /* it is possible for dataChanged to be emitted inside of a dataChanged handler or * some other signal; since the connection is via a lambda, Qt would cause the * handler to be called directly. This is not behaviour we usually want, so we call our * function via g_idle so that it gets called after the initial handler is done. */ if (topLeft == RecentModel::instance().selectionModel()->currentIndex()) g_idle_add((GSourceFunc)selected_item_changed, win); } ); g_signal_connect(priv->button_placecall, "clicked", G_CALLBACK(search_entry_placecall), win); g_signal_connect(priv->search_entry, "activate", G_CALLBACK(search_entry_placecall), win); /* autocompletion */ priv->q_completion_model = new NumberCompletionModel(); /* autocompletion renderers */ GtkCellArea *completion_area = gtk_cell_area_box_new(); /* photo renderer */ GtkCellRenderer *renderer = gtk_cell_renderer_pixbuf_new(); gtk_cell_area_box_pack_start(GTK_CELL_AREA_BOX(completion_area), renderer, TRUE, /* expand */ TRUE, /* align */ TRUE); /* fixed size */ gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(completion_area), renderer, (GtkCellLayoutDataFunc)autocompletion_photo_render, NULL, NULL); /* name renderer */ renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL); gtk_cell_area_box_pack_start(GTK_CELL_AREA_BOX(completion_area), renderer, TRUE, /* expand */ TRUE, /* align */ TRUE); /* fixed size */ gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(completion_area), renderer, (GtkCellLayoutDataFunc)autocompletion_name_render, NULL, NULL); /* number renderer */ renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL); gtk_cell_area_box_pack_start(GTK_CELL_AREA_BOX(completion_area), renderer, TRUE, /* expand */ TRUE, /* align */ TRUE); /* fixed size */ gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(completion_area), renderer, (GtkCellLayoutDataFunc)autocompletion_number_render, NULL, NULL); /* account renderer */ renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, NULL); gtk_cell_area_box_pack_start(GTK_CELL_AREA_BOX(completion_area), renderer, TRUE, /* expand */ TRUE, /* align */ TRUE); /* fixed size */ gtk_cell_layout_set_cell_data_func(GTK_CELL_LAYOUT(completion_area), renderer, (GtkCellLayoutDataFunc)autocompletion_account_render, NULL, NULL); GtkEntryCompletion *entry_completion = gtk_entry_completion_new_with_area(completion_area); GtkQTreeModel *completion_model = gtk_q_tree_model_new( (QAbstractItemModel *)priv->q_completion_model, 1, Qt::DisplayRole, G_TYPE_STRING); gtk_entry_completion_set_model(entry_completion, GTK_TREE_MODEL(completion_model)); gtk_entry_set_completion(GTK_ENTRY(priv->search_entry), entry_completion); gtk_entry_completion_set_match_func( entry_completion, (GtkEntryCompletionMatchFunc) completion_match_func, NULL, NULL); /* connect signal to when text is entered in the entry */ g_signal_connect(priv->search_entry, "changed", G_CALLBACK(search_entry_text_changed), win); g_signal_connect(entry_completion, "match-selected", G_CALLBACK(select_autocompletion), win); /* connect to incoming call and focus */ QObject::connect( &CallModel::instance(), &CallModel::incomingCall, [=](Call* call) { CallModel::instance().selectionModel()->setCurrentIndex( CallModel::instance().getIndex(call), QItemSelectionModel::ClearAndSelect); } ); /* react to digit key press events */ g_signal_connect(win, "key-press-event", G_CALLBACK(dtmf_pressed), NULL); /* set the search entry placeholder text */ gtk_entry_set_placeholder_text(GTK_ENTRY(priv->search_entry), C_("Please try to make the translation 50 chars or less so that it fits into the layout", "Search contacts or enter number")); }
static void on_operations_icon_draw (GtkWidget *widget, cairo_t *cr, NautilusToolbar *self) { gfloat elapsed_progress = 0; gint remaining_progress = 0; gint total_progress; gdouble ratio; GList *progress_infos; GList *l; guint width; guint height; gboolean all_cancelled; GdkRGBA background = {.red = 0, .green = 0, .blue = 0, .alpha = 0.2 }; GdkRGBA foreground = {.red = 0, .green = 0, .blue = 0, .alpha = 0.7 }; all_cancelled = TRUE; progress_infos = get_filtered_progress_infos (self); for (l = progress_infos; l != NULL; l = l->next) { if (!nautilus_progress_info_get_is_cancelled (l->data)) { all_cancelled = FALSE; remaining_progress += nautilus_progress_info_get_remaining_time (l->data); elapsed_progress += nautilus_progress_info_get_elapsed_time (l->data); } } g_list_free (progress_infos); total_progress = remaining_progress + elapsed_progress; if (all_cancelled) { ratio = 1.0; } else { if (total_progress > 0) { ratio = MAX (0.05, elapsed_progress / total_progress); } else { ratio = 0.05; } } width = gtk_widget_get_allocated_width (widget); height = gtk_widget_get_allocated_height (widget); gdk_cairo_set_source_rgba(cr, &background); cairo_arc (cr, width / 2.0, height / 2.0, MIN (width, height) / 2.0, 0, 2 *G_PI); cairo_fill (cr); cairo_move_to (cr, width / 2.0, height / 2.0); gdk_cairo_set_source_rgba (cr, &foreground); cairo_arc (cr, width / 2.0, height / 2.0, MIN (width, height) / 2.0, -G_PI / 2.0, ratio * 2 * G_PI - G_PI / 2.0); cairo_fill (cr); } static void on_operations_button_toggled (NautilusToolbar *self) { unschedule_remove_finished_operations (self); if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (self->priv->operations_button))) { schedule_remove_finished_operations (self); } else { update_operations (self); } } static void nautilus_toolbar_init (NautilusToolbar *self) { GtkBuilder *builder; self->priv = nautilus_toolbar_get_instance_private (self); gtk_widget_init_template (GTK_WIDGET (self)); self->priv->path_bar = g_object_new (NAUTILUS_TYPE_PATH_BAR, NULL); gtk_container_add (GTK_CONTAINER (self->priv->path_bar_container), self->priv->path_bar); self->priv->location_entry = nautilus_location_entry_new (); gtk_container_add (GTK_CONTAINER (self->priv->location_entry_container), self->priv->location_entry); builder = gtk_builder_new_from_resource ("/org/gnome/nautilus/nautilus-toolbar-action-menu.xml"); self->priv->action_menu = G_MENU (gtk_builder_get_object (builder, "action-menu")); gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (self->priv->action_button), G_MENU_MODEL (self->priv->action_menu)); g_object_unref (builder); self->priv->progress_manager = nautilus_progress_info_manager_dup_singleton (); g_signal_connect (self->priv->progress_manager, "new-progress-info", G_CALLBACK (on_new_progress_info), self); update_operations (self); g_object_set_data (G_OBJECT (self->priv->back_button), "nav-direction", GUINT_TO_POINTER (NAUTILUS_NAVIGATION_DIRECTION_BACK)); g_object_set_data (G_OBJECT (self->priv->forward_button), "nav-direction", GUINT_TO_POINTER (NAUTILUS_NAVIGATION_DIRECTION_FORWARD)); g_signal_connect (self->priv->back_button, "button-press-event", G_CALLBACK (navigation_button_press_cb), self); g_signal_connect (self->priv->back_button, "button-release-event", G_CALLBACK (navigation_button_release_cb), self); g_signal_connect (self->priv->forward_button, "button-press-event", G_CALLBACK (navigation_button_press_cb), self); g_signal_connect (self->priv->forward_button, "button-release-event", G_CALLBACK (navigation_button_release_cb), self); gtk_widget_show_all (GTK_WIDGET (self)); toolbar_update_appearance (self); }
static void GyahtzeeCreateMainWindow (void) { GtkWidget *hbox, *vbox; GtkWidget *toolbar; GtkWidget *tmp; GtkWidget *dicebox; GtkAccelGroup *accel_group; GtkBuilder *builder; GtkUIManager *ui_manager; int i, j; window = gtk_application_window_new (application); gtk_window_set_application (GTK_WINDOW (window), application); gtk_window_set_title (GTK_WINDOW (window), _(appName)); gtk_window_set_hide_titlebar_when_maximized (GTK_WINDOW (window), TRUE); //games_conf_add_window (GTK_WINDOW (window), NULL); g_signal_connect (G_OBJECT (window), "delete_event", G_CALLBACK (quit_game), NULL); g_signal_connect (G_OBJECT (window), "key_press_event", G_CALLBACK (key_press), NULL); statusbar = gtk_statusbar_new (); ui_manager = gtk_ui_manager_new (); builder = gtk_builder_new (); gtk_builder_add_from_string (builder, builder_description, -1, NULL); games_stock_prepare_for_statusbar_tooltips (ui_manager, statusbar); /*---- Menus ----*/ create_menus (ui_manager); accel_group = gtk_ui_manager_get_accel_group (ui_manager); gtk_window_add_accel_group (GTK_WINDOW (window), accel_group); g_action_map_add_action_entries (G_ACTION_MAP (application), app_entries, G_N_ELEMENTS (app_entries), application); gtk_application_set_app_menu (GTK_APPLICATION (application), G_MENU_MODEL (gtk_builder_get_object (builder, "app-menu"))); /*---- Content ----*/ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_add (GTK_CONTAINER (window), vbox); gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox), statusbar, FALSE, FALSE, 0); gtk_widget_show (statusbar); /* Retreive dice pixmaps from memory or files */ LoadDicePixmaps (); /* Put all the dice in a vertical column */ dicebox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_box_pack_start (GTK_BOX (hbox), dicebox, FALSE, TRUE, 0); gtk_widget_show (dicebox); rollLabel = gtk_label_new (NULL); gtk_label_set_use_markup (GTK_LABEL (rollLabel), TRUE); gtk_widget_show (rollLabel); gtk_box_pack_start (GTK_BOX (dicebox), rollLabel, FALSE, TRUE, 5); mbutton = gtk_button_new_with_label (_("Roll!")); gtk_box_pack_end (GTK_BOX (dicebox), mbutton, FALSE, FALSE, 5); g_signal_connect (G_OBJECT (mbutton), "clicked", G_CALLBACK (roll_dice), NULL); gtk_widget_show (GTK_WIDGET (mbutton)); toolbar = gtk_toolbar_new (); gtk_orientable_set_orientation (GTK_ORIENTABLE (toolbar), GTK_ORIENTATION_VERTICAL); gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS); gtk_toolbar_set_show_arrow (GTK_TOOLBAR (toolbar), FALSE); gtk_box_pack_end (GTK_BOX (dicebox), toolbar, TRUE, TRUE, 0); for (i = 0; i < NUMBER_OF_DICE; i++) { tmp = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); for (j = 0; j < NUMBER_OF_PIXMAPS; j++) { gtk_box_pack_start (GTK_BOX (tmp), dicePixmaps[i][j][GAME_YAHTZEE], FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (tmp), dicePixmaps[i][j][GAME_KISMET], FALSE, FALSE, 0); } diceBox[i] = gtk_toggle_tool_button_new (); gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (diceBox[i]), tmp); g_signal_connect (G_OBJECT (diceBox[i]), "clicked", G_CALLBACK (modify_dice), &DiceValues[i]); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (diceBox[i]), -1); gtk_widget_show (GTK_WIDGET (diceBox[i])); gtk_widget_show (tmp); /*gtk_widget_show (dicePixmaps[i][0][game_type]);*/ } gtk_widget_show (toolbar); /* Scores displayed in score list */ ScoreList = create_score_list (); gtk_box_pack_end (GTK_BOX (hbox), ScoreList, TRUE, TRUE, 0); setup_score_list (ScoreList); gtk_widget_show (ScoreList); gtk_widget_show (hbox); gtk_widget_show (vbox); gtk_widget_show (window); GyahtzeeNewGame (); }
static void startup_cb (GApplication *application, gpointer data) { GtkBuilder *builder = gtk_builder_new (); GMenuModel *model; gboolean show_app_menu; const GActionEntry app_entries[] = { { "group-by", activate_action, "s", "\"script\"", NULL }, { "show-only-glyphs-in-font", activate_toggle_action, NULL, "false", change_toggle_state }, { "zoom-in", activate_action, NULL, NULL, NULL }, { "zoom-out", activate_action, NULL, NULL, NULL }, { "normal-size", activate_action, NULL, NULL, NULL }, { "find", activate_action, NULL, NULL, NULL }, { "help", activate_action, NULL, NULL, NULL }, { "about", activate_action, NULL, NULL, NULL }, { "close", activate_close, NULL, NULL, NULL }, }; g_action_map_add_action_entries (G_ACTION_MAP (application), app_entries, G_N_ELEMENTS (app_entries), application); gtk_builder_add_from_resource (builder, UI_RESOURCE, NULL); /* app menu */ g_object_get (gtk_settings_get_default (), "gtk-shell-shows-app-menu", &show_app_menu, NULL); if (show_app_menu) { model = G_MENU_MODEL (gtk_builder_get_object (builder, "app-menu")); gtk_application_set_app_menu (GTK_APPLICATION (application), model); } /* window menu */ #ifdef ENABLE_PRINTING model = G_MENU_MODEL (gtk_builder_get_object (builder, "printing")); g_menu_append (G_MENU (model), _("Page _Setup"), "win.page-setup"); /* g_menu_append (G_MENU (model), _("Print Preview"), "win.print-preview"); */ g_menu_append (G_MENU (model), _("_Print"), "win.print"); #endif model = G_MENU_MODEL (gtk_builder_get_object (builder, "go-chapter")); g_object_set_data (G_OBJECT (application), "go-chapter-menu", model); model = G_MENU_MODEL (gtk_builder_get_object (builder, "menubar")); gtk_application_set_menubar (GTK_APPLICATION (application), model); gtk_application_add_accelerator (GTK_APPLICATION (application), "<Primary>Page_Down", "win.next-chapter", NULL); gtk_application_add_accelerator (GTK_APPLICATION (application), "<Primary>Page_Up", "win.previous-chapter", NULL); gtk_application_add_accelerator (GTK_APPLICATION (application), "F1", "app.help", NULL); gtk_application_add_accelerator (GTK_APPLICATION (application), "<Primary>q", "app.close", NULL); gtk_application_add_accelerator (GTK_APPLICATION (application), "<Primary>w", "app.close", NULL); g_object_unref (builder); }
/*********************************************************************** Menu */ void bmd_construct_menu (GtkApplication *app, gpointer data) { GtkWidget *menubar; GMenu *menu, *filemenu, *editmenu, *helpmenu, *savemenu, *quitmenu; bmd_widgets *a = (bmd_widgets *) data; // define keyboard accelerators const gchar *open_accels[2] = { "<Ctrl>O", NULL }; const gchar *save_accels[2] = { "<Ctrl>S", NULL }; const gchar *quit_accels[2] = { "<Ctrl>Q", NULL }; const gchar *add_accels[2] = { "<Ctrl>A", NULL }; const gchar *del_accels[2] = { "<Ctrl>D", NULL }; const gchar *find_accels[2] = { "<Ctrl>F", NULL }; const gchar *help_accels[2] = { "F1", NULL }; /* map app entries to actions using the global structure */ g_action_map_add_action_entries (G_ACTION_MAP (app), app_entries, G_N_ELEMENTS (app_entries), (gpointer) a); /* create the menu */ menu = g_menu_new(); /* create the File menu */ filemenu = g_menu_new(); g_menu_append (filemenu, "_Open", "app.open"); savemenu = g_menu_new(); g_menu_append (savemenu, "_Save", "app.save"); g_menu_append (savemenu, "Save As ...", "app.saveAs"); g_menu_append_section (filemenu, NULL, G_MENU_MODEL (savemenu)); quitmenu = g_menu_new(); g_menu_append (quitmenu, "_Quit", "app.quit"); g_menu_append_section (filemenu, NULL, G_MENU_MODEL (quitmenu)); g_menu_insert_submenu (menu, 0, "_File", G_MENU_MODEL (filemenu)); g_object_unref (savemenu); g_object_unref (quitmenu); g_object_unref (filemenu); /* create the Edit menu */ editmenu = g_menu_new(); g_menu_append (editmenu, "_Find", "app.find"); g_menu_append (editmenu, "_Add", "app.add"); g_menu_append (editmenu, "_Delete", "app.delete"); g_menu_append_submenu (menu, "_Edit", G_MENU_MODEL (editmenu)); g_object_unref (editmenu); /* create the Help menu */ helpmenu = g_menu_new(); g_menu_append (helpmenu, "About", "app.about"); g_menu_append (helpmenu, "Help", "app.help"); g_menu_append_submenu (menu, "_Help", G_MENU_MODEL (helpmenu)); g_object_unref (helpmenu); /* create a menu bar and add the above menus */ menubar = gtk_menu_bar_new_from_model (G_MENU_MODEL (menu)); gtk_box_pack_start (GTK_BOX (a->box), menubar, FALSE, FALSE, 0); /* connect keyboard accelerators */ gtk_application_set_accels_for_action (GTK_APPLICATION (app), "app.open", open_accels); gtk_application_set_accels_for_action (GTK_APPLICATION (app), "app.save", save_accels); gtk_application_set_accels_for_action (GTK_APPLICATION (app), "app.quit", quit_accels); gtk_application_set_accels_for_action (GTK_APPLICATION (app), "app.add", add_accels); gtk_application_set_accels_for_action (GTK_APPLICATION (app), "app.delete", del_accels); gtk_application_set_accels_for_action (GTK_APPLICATION (app), "app.find", find_accels); gtk_application_set_accels_for_action (GTK_APPLICATION (app), "app.help", help_accels); }