int main (int argc, char *argv[]) { GtkWidget *window; GtkWidget *box; GtkWidget *footer; GtkWidget *button; GtkWidget *content; GtkCssProvider *provider; gtk_init (NULL, NULL); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_style_context_add_class (gtk_widget_get_style_context (window), "main"); provider = gtk_css_provider_new (); gtk_css_provider_load_from_data (provider, css, -1, NULL); gtk_style_context_add_provider_for_screen (gtk_widget_get_screen (window), GTK_STYLE_PROVIDER (provider), GTK_STYLE_PROVIDER_PRIORITY_USER); change_header (NULL, window); box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_add (GTK_CONTAINER (window), box); footer = gtk_header_bar_new (); button = gtk_button_new_with_label ("Title"); g_signal_connect (button, "clicked", G_CALLBACK (change_title), footer); gtk_header_bar_pack_start (GTK_HEADER_BAR (footer), button); gtk_header_bar_set_custom_title (GTK_HEADER_BAR (footer), gtk_check_button_new_with_label ("Middle")); button = gtk_toggle_button_new_with_label ("Custom"); g_signal_connect (button, "clicked", G_CALLBACK (change_header), window); gtk_header_bar_pack_start (GTK_HEADER_BAR (footer), button); gtk_header_bar_set_custom_title (GTK_HEADER_BAR (footer), gtk_check_button_new_with_label ("Middle")); button = gtk_button_new_with_label ("Subtitle"); g_signal_connect (button, "clicked", G_CALLBACK (change_subtitle), NULL); gtk_header_bar_pack_end (GTK_HEADER_BAR (footer), button); button = gtk_button_new_with_label ("Fullscreen"); gtk_header_bar_pack_end (GTK_HEADER_BAR (footer), button); g_signal_connect (button, "clicked", G_CALLBACK (toggle_fullscreen), window); gtk_box_pack_end (GTK_BOX (box), footer, FALSE, FALSE, 0); content = gtk_image_new_from_icon_name ("start-here-symbolic", GTK_ICON_SIZE_DIALOG); gtk_image_set_pixel_size (GTK_IMAGE (content), 512); gtk_box_pack_start (GTK_BOX (box), content, FALSE, TRUE, 0); gtk_widget_show_all (window); gtk_main (); gtk_widget_destroy (window); return 0; }
static void gs_shell_set_header_start_widget (GsShell *shell, GtkWidget *widget) { GsShellPrivate *priv = gs_shell_get_instance_private (shell); GtkWidget *old_widget; GtkWidget *header; old_widget = priv->header_start_widget; header = GTK_WIDGET (gtk_builder_get_object (priv->builder, "header")); if (priv->header_start_widget == widget) return; if (widget != NULL) { g_object_ref (widget); gtk_header_bar_pack_start (GTK_HEADER_BAR (header), widget); } priv->header_start_widget = widget; if (old_widget != NULL) { gtk_container_remove (GTK_CONTAINER (header), old_widget); g_object_unref (old_widget); } }
void WebInspectorProxy::createInspectorWindow() { if (m_client.openWindow(this)) return; ASSERT(!m_inspectorWindow); m_inspectorWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL); GtkWidget* inspectedViewParent = gtk_widget_get_toplevel(m_page->viewWidget()); if (WebCore::widgetIsOnscreenToplevelWindow(inspectedViewParent)) gtk_window_set_transient_for(GTK_WINDOW(m_inspectorWindow), GTK_WINDOW(inspectedViewParent)); #if GTK_CHECK_VERSION(3, 10, 0) m_headerBar = gtk_header_bar_new(); gtk_header_bar_set_show_close_button(GTK_HEADER_BAR(m_headerBar), TRUE); m_dockBottomButton = gtk_button_new(); g_object_add_weak_pointer(G_OBJECT(m_dockBottomButton), reinterpret_cast<void**>(&m_dockBottomButton)); g_signal_connect(m_dockBottomButton, "clicked", G_CALLBACK(dockButtonClicked), this); gtk_widget_set_sensitive(m_dockBottomButton, canAttach()); gtk_button_set_relief(GTK_BUTTON(m_dockBottomButton), GTK_RELIEF_NONE); gtk_button_set_image(GTK_BUTTON(m_dockBottomButton), gtk_image_new_from_resource("/org/webkitgtk/inspector/UserInterface/Images/DockBottom.svg")); gtk_header_bar_pack_start(GTK_HEADER_BAR(m_headerBar), m_dockBottomButton); gtk_widget_show(m_dockBottomButton); m_dockRightButton = gtk_button_new(); g_object_add_weak_pointer(G_OBJECT(m_dockRightButton), reinterpret_cast<void**>(&m_dockRightButton)); g_signal_connect(m_dockRightButton, "clicked", G_CALLBACK(dockButtonClicked), this); gtk_widget_set_sensitive(m_dockRightButton, canAttach()); gtk_button_set_relief(GTK_BUTTON(m_dockRightButton), GTK_RELIEF_NONE); gtk_button_set_image(GTK_BUTTON(m_dockRightButton), gtk_image_new_from_resource("/org/webkitgtk/inspector/UserInterface/Images/DockRight.svg")); gtk_header_bar_pack_start(GTK_HEADER_BAR(m_headerBar), m_dockRightButton); gtk_widget_show(m_dockRightButton); gtk_window_set_titlebar(GTK_WINDOW(m_inspectorWindow), m_headerBar); gtk_widget_show(m_headerBar); #endif updateInspectorWindowTitle(); gtk_window_set_default_size(GTK_WINDOW(m_inspectorWindow), initialWindowWidth, initialWindowHeight); gtk_container_add(GTK_CONTAINER(m_inspectorWindow), m_inspectorView); gtk_widget_show(m_inspectorView); g_object_add_weak_pointer(G_OBJECT(m_inspectorWindow), reinterpret_cast<void**>(&m_inspectorWindow)); gtk_window_present(GTK_WINDOW(m_inspectorWindow)); }
static void ekiga_window_init_actions_toolbar (EkigaWindow *mw) { GtkWidget *image = NULL; GtkWidget *button = NULL; GtkWidget *switcher = NULL; g_return_if_fail (EKIGA_IS_WINDOW (mw)); mw->priv->actions_toolbar = gtk_header_bar_new (); gtk_window_set_titlebar (GTK_WINDOW (mw), mw->priv->actions_toolbar); /* Start packing buttons */ button = gtk_button_new (); image = gtk_image_new_from_icon_name ("call-start-symbolic", GTK_ICON_SIZE_MENU); gtk_button_set_image (GTK_BUTTON (button), image); gtk_widget_set_tooltip_text (GTK_WIDGET (button), _("Call the selected contact")); gtk_actionable_set_detailed_action_name (GTK_ACTIONABLE (button), "win.call"); gtk_header_bar_pack_start (GTK_HEADER_BAR (mw->priv->actions_toolbar), button); mw->priv->preview_button = gtk_toggle_button_new (); image = gtk_image_new_from_icon_name ("camera-web-symbolic", GTK_ICON_SIZE_MENU); gtk_button_set_image (GTK_BUTTON (mw->priv->preview_button), image); gtk_widget_set_tooltip_text (GTK_WIDGET (mw->priv->preview_button), _("Display images from your camera device")); gtk_actionable_set_detailed_action_name (GTK_ACTIONABLE (mw->priv->preview_button), "win.enable-preview"); gtk_header_bar_pack_start (GTK_HEADER_BAR (mw->priv->actions_toolbar), mw->priv->preview_button); switcher = gtk_stack_switcher_new (); gtk_stack_switcher_set_stack (GTK_STACK_SWITCHER (switcher), GTK_STACK (mw->priv->main_stack)); gtk_header_bar_set_custom_title (GTK_HEADER_BAR (mw->priv->actions_toolbar), switcher); gtk_widget_set_margin_end (GTK_WIDGET (switcher), 6); mw->priv->menu_button = gtk_menu_button_new (); g_object_set (G_OBJECT (mw->priv->menu_button), "use-popover", true, NULL); image = gtk_image_new_from_icon_name ("open-menu-symbolic", GTK_ICON_SIZE_MENU); gtk_button_set_image (GTK_BUTTON (mw->priv->menu_button), image); gtk_header_bar_pack_end (GTK_HEADER_BAR (mw->priv->actions_toolbar), mw->priv->menu_button); gtk_widget_show_all (mw->priv->actions_toolbar); gtk_header_bar_set_show_close_button (GTK_HEADER_BAR (mw->priv->actions_toolbar), TRUE); }
/** * g_paste_ui_header_new: * @topwin: the main #GtkWindow * @client: a #GPasteClient instance * * Create a new instance of #GPasteUiHeader * * Returns: a newly allocated #GPasteUiHeader * free it with g_object_unref */ G_PASTE_VISIBLE GtkWidget * g_paste_ui_header_new (GtkWindow *topwin, GPasteClient *client) { g_return_val_if_fail (GTK_IS_WINDOW (topwin), NULL); g_return_val_if_fail (_G_PASTE_IS_CLIENT (client), NULL); GtkWidget *self = gtk_widget_new (G_PASTE_TYPE_UI_HEADER, NULL); GtkHeaderBar *bar = GTK_HEADER_BAR (self); gtk_header_bar_pack_start (bar, g_paste_ui_switch_new (topwin, client)); gtk_header_bar_pack_start (bar, g_paste_ui_reexec_new (topwin, client)); gtk_header_bar_pack_end (bar, g_paste_ui_about_new (gtk_window_get_application (topwin))); gtk_header_bar_pack_end (bar, g_paste_ui_new_item_new (topwin, client)); return self; }
static void example_app_window_init (ExampleAppWindow *win) { gtk_widget_init_template (GTK_WIDGET (win)); ExampleAppWindowPrivate *priv = example_app_window_get_instance_private (win); gtk_header_bar_set_decoration_layout (GTK_HEADER_BAR (priv->header), ":"); priv->open_button = gtk_button_new_from_icon_name ("document-open-symbolic", GTK_ICON_SIZE_BUTTON); gtk_widget_set_valign (priv->open_button, GTK_ALIGN_CENTER); gtk_header_bar_pack_start (GTK_HEADER_BAR (priv->header), priv->open_button); gtk_widget_show (priv->open_button); g_signal_connect (priv->open_button, "clicked", (GCallback) on_open_clicked, win); priv->save_button = gtk_button_new_from_icon_name ("document-save-symbolic", GTK_ICON_SIZE_BUTTON); gtk_widget_set_valign (priv->save_button, GTK_ALIGN_CENTER); gtk_header_bar_pack_start (GTK_HEADER_BAR (priv->header), priv->save_button); gtk_widget_show (priv->save_button); g_signal_connect (priv->save_button, "clicked", (GCallback) on_save_clicked, win); priv->cancel_button = gtk_button_new_from_icon_name ("process-error-symbolic", GTK_ICON_SIZE_BUTTON); gtk_widget_set_valign (priv->cancel_button, GTK_ALIGN_CENTER); gtk_header_bar_pack_end (GTK_HEADER_BAR (priv->header), priv->cancel_button); gtk_widget_show (priv->cancel_button); g_signal_connect (priv->cancel_button, "clicked", (GCallback) on_cancel_clicked, win); priv->destroy_button = gtk_button_new_from_icon_name ("edit-delete-symbolic", GTK_ICON_SIZE_BUTTON); gtk_widget_set_valign (priv->destroy_button, GTK_ALIGN_CENTER); gtk_header_bar_pack_end (GTK_HEADER_BAR (priv->header), priv->destroy_button); gtk_widget_show (priv->destroy_button); g_signal_connect (priv->destroy_button, "clicked", (GCallback) on_destroy_clicked, win); }
static void glade_gtk_header_bar_set_size (GObject * object, const GValue * value) { GList *l, *next, *children; GtkWidget *child; guint new_size, old_size, i; g_return_if_fail (GTK_IS_HEADER_BAR (object)); d(g_message ("Setting size to %d", g_value_get_int (value))); if (glade_util_object_is_loading (object)) return; children = gtk_container_get_children (GTK_CONTAINER (object)); l = children; while (l) { next = l->next; if (l->data == gtk_header_bar_get_custom_title (GTK_HEADER_BAR (object)) || (!glade_widget_get_from_gobject (l->data) && !GLADE_IS_PLACEHOLDER (l->data))) children = g_list_delete_link (children, l); l = next; } old_size = g_list_length (children); new_size = g_value_get_int (value); if (old_size == new_size) { g_list_free (children); return; } for (i = old_size; i < new_size; i++) { GtkWidget *placeholder = glade_placeholder_new (); gtk_header_bar_pack_start (GTK_HEADER_BAR (object), placeholder); } for (l = g_list_last (children); l && old_size > new_size; l = l->prev) { child = l->data; if (glade_widget_get_from_gobject (child) || !GLADE_IS_PLACEHOLDER (child)) continue; gtk_container_remove (GTK_CONTAINER (object), child); old_size--; } g_list_free (children); }
static void setup_header_bar (GtkWidget *window, VteTerminal *vtterm, gboolean show_maximized_title) { /* * Using the default GtkHeaderBar title/subtitle widget makes the bar * too thick to look nice for a terminal, so set a custom widget. */ GtkWidget *hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5); const gchar *title = gtk_window_get_title (GTK_WINDOW (window)); GtkWidget *label = gtk_label_new (title ? title : "dwt"); g_object_bind_property (G_OBJECT (vtterm), "window-title", G_OBJECT (label), "label", G_BINDING_DEFAULT); GtkWidget *header = gtk_header_bar_new (); gtk_header_bar_set_show_close_button (GTK_HEADER_BAR (header), TRUE); gtk_header_bar_set_has_subtitle (GTK_HEADER_BAR (header), FALSE); gtk_header_bar_set_custom_title (GTK_HEADER_BAR (header), label); GtkWidget *button = gtk_button_new_from_icon_name ("tab-new-symbolic", GTK_ICON_SIZE_BUTTON); gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE); gtk_actionable_set_action_name (GTK_ACTIONABLE (button), "app.new-terminal"); gtk_header_bar_pack_start (GTK_HEADER_BAR (header), button); GtkWidget *revealer = gtk_revealer_new (); gtk_container_add (GTK_CONTAINER (revealer), gtk_image_new_from_icon_name ("software-update-urgent-symbolic", GTK_ICON_SIZE_BUTTON)); gtk_revealer_set_transition_duration (GTK_REVEALER (revealer), 500); gtk_revealer_set_transition_type (GTK_REVEALER (revealer), GTK_REVEALER_TRANSITION_TYPE_CROSSFADE); gtk_header_bar_pack_end (GTK_HEADER_BAR (header), revealer); g_signal_connect (G_OBJECT (vtterm), "bell", G_CALLBACK (header_bar_term_beeped), revealer); g_object_bind_property (G_OBJECT (window), "urgency-hint", G_OBJECT (revealer), "reveal-child", G_BINDING_DEFAULT); gtk_window_set_titlebar (GTK_WINDOW (window), header); /* Hide the header bar when the window is maximized. */ if (!show_maximized_title) { g_object_bind_property (G_OBJECT (window), "is-maximized", G_OBJECT (header), "visible", G_BINDING_INVERT_BOOLEAN); } }
static void change_header (GtkButton *button, gpointer data) { GtkWidget *window = GTK_WIDGET (data); GtkWidget *label; GtkWidget *widget; GtkWidget *image; GtkWidget *box; if (button && gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button))) { header = gtk_event_box_new (); gtk_style_context_add_class (gtk_widget_get_style_context (header), "titlebar"); gtk_style_context_add_class (gtk_widget_get_style_context (header), "header-bar"); box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10); g_object_set (box, "margin", 10, NULL); gtk_container_add (GTK_CONTAINER (header), box); label = gtk_label_new ("Label"); gtk_box_pack_start (GTK_BOX (box), label, FALSE, TRUE); widget = gtk_level_bar_new (); gtk_level_bar_set_value (GTK_LEVEL_BAR (widget), 0.4); gtk_box_pack_start (GTK_BOX (box), widget, TRUE, TRUE); gtk_widget_show_all (header); } else { header = gtk_header_bar_new (); gtk_style_context_add_class (gtk_widget_get_style_context (header), "titlebar"); gtk_header_bar_set_title (GTK_HEADER_BAR (header), "Example header"); widget = gtk_button_new_with_label ("_Close"); gtk_button_set_use_underline (GTK_BUTTON (widget), TRUE); gtk_style_context_add_class (gtk_widget_get_style_context (widget), "suggested-action"); g_signal_connect (widget, "clicked", G_CALLBACK (gtk_main_quit), NULL); gtk_header_bar_pack_end (GTK_HEADER_BAR (header), widget); widget= gtk_button_new (); image = gtk_image_new_from_icon_name ("bookmark-new-symbolic", GTK_ICON_SIZE_BUTTON); g_signal_connect (widget, "clicked", G_CALLBACK (on_bookmark_clicked), window); gtk_container_add (GTK_CONTAINER (widget), image); gtk_header_bar_pack_start (GTK_HEADER_BAR (header), widget); gtk_widget_show_all (header); } gtk_window_set_titlebar (GTK_WINDOW (window), header); }
static void cc_sharing_panel_setup_personal_file_sharing_dialog (CcSharingPanel *self) { CcSharingPanelPrivate *priv = self->priv; GSettings *settings; GtkWidget *networks, *grid, *w; cc_sharing_panel_bind_switch_to_widgets (WID ("personal-file-sharing-require-password-switch"), WID ("personal-file-sharing-password-entry"), WID ("personal-file-sharing-password-label"), NULL); cc_sharing_panel_setup_label_with_hostname (self, WID ("personal-file-sharing-label")); /* the password cannot be read, so just make sure the entry is not empty */ gtk_entry_set_text (GTK_ENTRY (WID ("personal-file-sharing-password-entry")), "password"); settings = g_settings_new (FILE_SHARING_SCHEMA_ID); g_settings_bind_with_mapping (settings, "require-password", WID ("personal-file-sharing-require-password-switch"), "active", G_SETTINGS_BIND_DEFAULT, file_sharing_get_require_password, file_sharing_set_require_password, NULL, NULL); g_signal_connect (WID ("personal-file-sharing-password-entry"), "notify::text", G_CALLBACK (file_sharing_password_changed), NULL); networks = cc_sharing_networks_new (self->priv->sharing_proxy, "gnome-user-share-webdav"); grid = WID ("grid2"); gtk_grid_attach (GTK_GRID (grid), networks, 0, 3, 2, 1); gtk_widget_show (networks); w = cc_sharing_switch_new (networks); gtk_header_bar_pack_start (GTK_HEADER_BAR (WID ("personal-file-sharing-headerbar")), w); self->priv->personal_file_sharing_switch = w; cc_sharing_panel_bind_networks_to_label (self, networks, WID ("personal-file-sharing-status-label")); }
void glade_gtk_header_bar_post_create (GladeWidgetAdaptor *adaptor, GObject *container, GladeCreateReason reason) { GladeWidget *parent = glade_widget_get_from_gobject (container); GladeProject *project = glade_widget_get_project (parent); if (reason == GLADE_CREATE_LOAD) { g_signal_connect (project, "parse-finished", G_CALLBACK (glade_gtk_header_bar_parse_finished), container); } else if (reason == GLADE_CREATE_USER) { gtk_header_bar_pack_start (GTK_HEADER_BAR (container), glade_placeholder_new ()); } }
static void garu_headerbar_init_control_buttons (GaruHeaderbar *self) { GtkWidget *box, *prev_button, *play_button, *stop_button, *next_button; box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); /* previous */ prev_button = garu_utils_new_icon_button ("media-skip-backward-symbolic", FALSE, FALSE); g_signal_connect (prev_button, "clicked", G_CALLBACK (garu_headerbar_prev_button_clicked), self); gtk_box_pack_start (GTK_BOX (box), prev_button, FALSE, FALSE, 0); /* play */ play_button = garu_utils_new_icon_button ("media-playback-start-symbolic", FALSE, FALSE); g_signal_connect (play_button, "clicked", G_CALLBACK (garu_headerbar_play_button_clicked), self); gtk_box_pack_start (GTK_BOX (box), play_button, FALSE, FALSE, 0); /* stop */ stop_button = garu_utils_new_icon_button ("media-playback-stop-symbolic", FALSE, FALSE); gtk_widget_set_sensitive (stop_button, FALSE); g_signal_connect (stop_button, "clicked", G_CALLBACK (garu_headerbar_stop_button_clicked), self); gtk_box_pack_start (GTK_BOX (box), stop_button, FALSE, FALSE, 0); /* next */ next_button = garu_utils_new_icon_button ("media-skip-forward-symbolic", FALSE, FALSE); g_signal_connect (next_button, "clicked", G_CALLBACK (garu_headerbar_next_button_clicked), self); gtk_box_pack_start (GTK_BOX (box), next_button, FALSE, FALSE, 0); gtk_header_bar_pack_start (GTK_HEADER_BAR (self), box); gtk_widget_show_all (box); self->prev_button = prev_button; self->play_button = play_button; self->stop_button = stop_button; self->next_button = next_button; }
GtkWidget * totem_interface_create_header_button (GtkWidget *header, GtkWidget *button, const char *icon_name, GtkPackType pack_type) { GtkWidget *image; GtkStyleContext *context; image = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_MENU); gtk_button_set_image (GTK_BUTTON (button), image); context = gtk_widget_get_style_context (button); gtk_style_context_add_class (context, "image-button"); g_object_set (G_OBJECT (button), "valign", GTK_ALIGN_CENTER, NULL); if (pack_type == GTK_PACK_END) gtk_header_bar_pack_end (GTK_HEADER_BAR (header), button); else gtk_header_bar_pack_start (GTK_HEADER_BAR (header), button); return button; }
static void bjb_selection_toolbar_init (BjbSelectionToolbar *self) { BjbSelectionToolbarPrivate *priv; GtkWidget *widget; self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, BJB_TYPE_SELECTION_TOOLBAR, BjbSelectionToolbarPrivate); priv = self->priv; widget = GTK_WIDGET (self); gtk_revealer_set_transition_type ( GTK_REVEALER (self), GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP); priv->bar = GTK_HEADER_BAR (gtk_header_bar_new ()); gtk_container_add (GTK_CONTAINER (self), GTK_WIDGET (priv->bar)); /* Trash notes */ priv->toolbar_trash = gtk_button_new_with_label (_("Delete")); gtk_header_bar_pack_start (priv->bar, priv->toolbar_trash); /* Notes color */ priv->toolbar_color = bjb_color_button_new (); gtk_widget_set_tooltip_text (GTK_WIDGET (priv->toolbar_color), _("Note color")); gtk_header_bar_pack_end (priv->bar, priv->toolbar_color); /* Notes tags */ priv->toolbar_tag = gtk_button_new_with_label (_("Add to Collection")); gtk_header_bar_pack_end (priv->bar, priv->toolbar_tag); gtk_widget_show_all (widget); bjb_selection_toolbar_fade_out (self); }
static void GyahtzeeCreateMainWindow (GApplication *app, gpointer user_data) { GtkWidget *hbox, *vbox; GtkWidget *toolbar; GtkWidget *tmp; GtkWidget *dicebox; GtkWidget *undo_button; GtkWidget *menu_button; GtkWidget *icon; GtkBuilder *builder; GMenuModel *appmenu; 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), FALSE); gtk_window_set_icon_name (GTK_WINDOW (window), "org.gnome.Tali"); //games_conf_add_window (GTK_WINDOW (window), NULL); g_signal_connect (GTK_WIDGET (window), "key_press_event", G_CALLBACK (key_press), NULL); g_action_map_add_action_entries (G_ACTION_MAP (application), app_entries, G_N_ELEMENTS (app_entries), application); const gchar *vaccels_help[] = {"F1", NULL}; const gchar *vaccels_new[] = {"<Primary>n", NULL}; const gchar *vaccels_roll[] = {"<Primary>r", NULL}; const gchar *vaccels_undo[] = {"<Primary>z", NULL}; gtk_application_set_accels_for_action (application, "app.help", vaccels_help); gtk_application_set_accels_for_action (application, "app.new-game", vaccels_new); gtk_application_set_accels_for_action (application, "app.roll", vaccels_roll); gtk_application_set_accels_for_action (application, "app.undo", vaccels_undo); scores_action = g_action_map_lookup_action (G_ACTION_MAP (application), "scores"); undo_action = g_action_map_lookup_action (G_ACTION_MAP (application), "undo"); update_undo_sensitivity (); /*--- Headerbar ---*/ hbar = gtk_header_bar_new (); gtk_header_bar_set_show_close_button (GTK_HEADER_BAR (hbar), TRUE); gtk_header_bar_set_title (GTK_HEADER_BAR (hbar), _(appName)); gtk_widget_show (hbar); gtk_window_set_titlebar (GTK_WINDOW (window), hbar); if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL) undo_button = gtk_button_new_from_icon_name ("edit-undo-rtl-symbolic", GTK_ICON_SIZE_BUTTON); else undo_button = gtk_button_new_from_icon_name ("edit-undo-symbolic", GTK_ICON_SIZE_BUTTON); gtk_widget_set_valign (undo_button, GTK_ALIGN_CENTER); gtk_actionable_set_action_name (GTK_ACTIONABLE (undo_button), "app.undo"); gtk_widget_set_tooltip_text (undo_button, _("Undo your most recent move")); gtk_widget_show (undo_button); gtk_header_bar_pack_start (GTK_HEADER_BAR (hbar), undo_button); builder = gtk_builder_new_from_resource ("/org/gnome/Tali/ui/menus.ui"); appmenu = (GMenuModel *) gtk_builder_get_object (builder, "app-menu"); menu_button = gtk_menu_button_new(); icon = gtk_image_new_from_icon_name ("open-menu-symbolic", GTK_ICON_SIZE_BUTTON); gtk_button_set_image (GTK_BUTTON (menu_button), icon); gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (menu_button), appmenu); gtk_widget_show (menu_button); gtk_header_bar_pack_end (GTK_HEADER_BAR (hbar), menu_button); /*---- 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); /* 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 (GTK_BUTTON (mbutton), "clicked", G_CALLBACK (roll_button_pressed_cb), 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 (GTK_TOOL_BUTTON (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); }
static void pragha_toolbar_init (PraghaToolbar *toolbar) { PraghaPreferences *preferences; GtkToolItem *prev_button, *play_button, *stop_button, *next_button; GtkToolItem *unfull_button, *shuffle_button, *repeat_button; GtkWidget *vol_button; const GBindingFlags binding_flags = G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL; preferences = pragha_preferences_get(); /* Setup Left control buttons */ prev_button = gtk_tool_button_new (NULL, NULL); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON(prev_button), "media-skip-backward"); gtk_widget_set_tooltip_text(GTK_WIDGET(prev_button), _("Previous Track")); toolbar->prev_button = prev_button; play_button = gtk_tool_button_new (NULL, NULL); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON(play_button), "media-playback-start"); gtk_widget_set_tooltip_text(GTK_WIDGET(play_button), _("Play / Pause Track")); toolbar->play_button = play_button; stop_button = gtk_tool_button_new (NULL, NULL); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON(stop_button), "media-playback-stop"); gtk_widget_set_tooltip_text(GTK_WIDGET(stop_button), _("Stop playback")); toolbar->stop_button = stop_button; next_button = gtk_tool_button_new (NULL, NULL); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON(next_button), "media-skip-forward"); gtk_widget_set_tooltip_text(GTK_WIDGET(next_button), _("Next Track")); toolbar->next_button = next_button; #if GTK_CHECK_VERSION (3, 12, 0) gtk_header_bar_pack_start(GTK_HEADER_BAR(toolbar), GTK_WIDGET(prev_button)); gtk_header_bar_pack_start(GTK_HEADER_BAR(toolbar), GTK_WIDGET(play_button)); gtk_header_bar_pack_start(GTK_HEADER_BAR(toolbar), GTK_WIDGET(stop_button)); gtk_header_bar_pack_start(GTK_HEADER_BAR(toolbar), GTK_WIDGET(next_button)); #else gtk_tool_insert_generic_item(GTK_TOOLBAR(toolbar), GTK_WIDGET(prev_button)); gtk_tool_insert_generic_item(GTK_TOOLBAR(toolbar), GTK_WIDGET(play_button)); gtk_tool_insert_generic_item(GTK_TOOLBAR(toolbar), GTK_WIDGET(stop_button)); gtk_tool_insert_generic_item(GTK_TOOLBAR(toolbar), GTK_WIDGET(next_button)); #endif /* Song info Box */ #if !GTK_CHECK_VERSION (3, 12, 0) GtkToolItem *boxitem = gtk_tool_item_new (); gtk_tool_item_set_expand (GTK_TOOL_ITEM(boxitem), TRUE); gtk_toolbar_insert (GTK_TOOLBAR(toolbar), GTK_TOOL_ITEM(boxitem), -1); GtkWidget *box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_container_add (GTK_CONTAINER(boxitem), box); GtkWidget *playing = pragha_toolbar_get_song_box (toolbar); gtk_box_pack_start (GTK_BOX(box), playing, TRUE, TRUE, 5); #endif /* Setup Right control buttons */ unfull_button = gtk_tool_button_new (NULL, NULL); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON(unfull_button), "view-restore"); gtk_widget_set_tooltip_text(GTK_WIDGET(unfull_button), _("Leave Fullscreen")); toolbar->unfull_button = unfull_button; shuffle_button = gtk_toggle_tool_button_new(); gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(shuffle_button), "media-playlist-shuffle"); gtk_widget_set_tooltip_text(GTK_WIDGET(shuffle_button), _("Play songs in a random order")); repeat_button = gtk_toggle_tool_button_new (); gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(repeat_button), "media-playlist-repeat"); gtk_widget_set_tooltip_text(GTK_WIDGET(repeat_button), _("Repeat playback list at the end")); vol_button = gtk_volume_button_new(); g_object_set(vol_button, "use-symbolic", FALSE, NULL); gtk_button_set_relief(GTK_BUTTON(vol_button), GTK_RELIEF_NONE); g_object_set(G_OBJECT(vol_button), "size", GTK_ICON_SIZE_LARGE_TOOLBAR, NULL); toolbar->vol_button = vol_button; toolbar->extra_button_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); #if GTK_CHECK_VERSION (3, 12, 0) gtk_header_bar_pack_end(GTK_HEADER_BAR(toolbar), GTK_WIDGET(toolbar->extra_button_box)); gtk_header_bar_pack_end(GTK_HEADER_BAR(toolbar), GTK_WIDGET(vol_button)); gtk_header_bar_pack_end(GTK_HEADER_BAR(toolbar), GTK_WIDGET(repeat_button)); gtk_header_bar_pack_end(GTK_HEADER_BAR(toolbar), GTK_WIDGET(shuffle_button)); gtk_header_bar_pack_end(GTK_HEADER_BAR(toolbar), GTK_WIDGET(unfull_button)); #else gtk_tool_insert_generic_item(GTK_TOOLBAR(toolbar), GTK_WIDGET(unfull_button)); gtk_tool_insert_generic_item(GTK_TOOLBAR(toolbar), GTK_WIDGET(shuffle_button)); gtk_tool_insert_generic_item(GTK_TOOLBAR(toolbar), GTK_WIDGET(repeat_button)); gtk_tool_insert_generic_item(GTK_TOOLBAR(toolbar), GTK_WIDGET(vol_button)); gtk_tool_insert_generic_item(GTK_TOOLBAR(toolbar), GTK_WIDGET(toolbar->extra_button_box)); #endif /* Connect signals */ g_signal_connect(G_OBJECT(prev_button), "clicked", G_CALLBACK(prev_button_handler), toolbar); g_signal_connect(G_OBJECT(play_button), "clicked", G_CALLBACK(play_button_handler), toolbar); g_signal_connect(G_OBJECT(stop_button), "clicked", G_CALLBACK(stop_button_handler), toolbar); g_signal_connect(G_OBJECT(next_button), "clicked", G_CALLBACK(next_button_handler), toolbar); g_signal_connect(G_OBJECT(unfull_button), "clicked", G_CALLBACK(unfull_button_handler), toolbar); /*g_signal_connect(G_OBJECT (prev_button), "key-press-event", G_CALLBACK(panel_button_key_press), toolbar); g_signal_connect(G_OBJECT (play_button), "key-press-event", G_CALLBACK(panel_button_key_press), toolbar); g_signal_connect(G_OBJECT (stop_button), "key-press-event", G_CALLBACK(panel_button_key_press), toolbar); g_signal_connect(G_OBJECT (next_button), "key-press-event", G_CALLBACK(panel_button_key_press), toolbar); g_signal_connect(G_OBJECT (next_button), "key-press-event", G_CALLBACK(panel_button_key_press), toolbar); g_signal_connect(G_OBJECT (unfull_button), "key-press-event", G_CALLBACK(panel_button_key_press), toolbar); g_signal_connect(G_OBJECT (shuffle_button), "key-press-event", G_CALLBACK(panel_button_key_press), toolbar); g_signal_connect(G_OBJECT (repeat_button), "key-press-event", G_CALLBACK(panel_button_key_press), toolbar); g_signal_connect(G_OBJECT (vol_button), "key-press-event", G_CALLBACK(panel_button_key_press), toolbar);*/ g_signal_connect (G_OBJECT (vol_button), "value-changed", G_CALLBACK (vol_button_value_changed), toolbar); g_object_bind_property(preferences, "shuffle", shuffle_button, "active", binding_flags); g_object_bind_property(preferences, "repeat", repeat_button, "active", binding_flags); /* Fix styling */ #if GTK_CHECK_VERSION (3, 12, 0) pragha_toolbar_set_style(toolbar, pragha_preferences_get_gnome_style (preferences)); #endif gtk_widget_show(GTK_WIDGET(prev_button)); gtk_widget_show(GTK_WIDGET(play_button)); gtk_widget_show(GTK_WIDGET(stop_button)); gtk_widget_show(GTK_WIDGET(next_button)); gtk_widget_show(GTK_WIDGET(shuffle_button)); gtk_widget_show(GTK_WIDGET(repeat_button)); gtk_widget_show(GTK_WIDGET(vol_button)); gtk_widget_hide(GTK_WIDGET(toolbar->unfull_button)); gtk_widget_show(GTK_WIDGET(toolbar)); g_object_unref(preferences); }
int main (int argc, char *argv[]) { GtkWidget *window; GtkWidget *box; GtkWidget *header; GtkWidget *footer; GtkWidget *button; GtkWidget *image; GtkWidget *content; GtkCssProvider *provider; gtk_init (NULL, NULL); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); header = gtk_header_bar_new (); gtk_style_context_add_class (gtk_widget_get_style_context (header), "titlebar"); provider = gtk_css_provider_new (); gtk_css_provider_load_from_data (provider, css, -1, NULL); gtk_style_context_add_provider_for_screen (gtk_widget_get_screen (window), GTK_STYLE_PROVIDER (provider), GTK_STYLE_PROVIDER_PRIORITY_USER); gtk_header_bar_set_title (GTK_HEADER_BAR (header), "Example header"); button = gtk_button_new_from_stock (GTK_STOCK_CLOSE); gtk_style_context_add_class (gtk_widget_get_style_context (button), "suggested-action"); g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL); gtk_header_bar_pack_end (GTK_HEADER_BAR (header), button); button = gtk_button_new (); image = gtk_image_new_from_icon_name ("bookmark-new-symbolic", GTK_ICON_SIZE_BUTTON); gtk_container_add (GTK_CONTAINER (button), image); gtk_header_bar_pack_start (GTK_HEADER_BAR (header), button); gtk_window_set_titlebar (GTK_WINDOW (window), header); box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_add (GTK_CONTAINER (window), box); footer = gtk_header_bar_new (); button = gtk_button_new_with_label ("Start"); g_signal_connect (button, "clicked", G_CALLBACK (change_title), footer); gtk_header_bar_pack_start (GTK_HEADER_BAR (footer), button); gtk_header_bar_set_custom_title (GTK_HEADER_BAR (footer), gtk_check_button_new_with_label ("Middle")); button = gtk_button_new_with_label ("End 1"); g_signal_connect (button, "clicked", G_CALLBACK (change_subtitle), header); gtk_header_bar_pack_end (GTK_HEADER_BAR (footer), button); gtk_header_bar_pack_end (GTK_HEADER_BAR (footer), gtk_button_new_with_label ("End 2")); gtk_box_pack_end (GTK_BOX (box), footer, FALSE, FALSE, 0); content = gtk_image_new_from_icon_name ("start-here-symbolic", GTK_ICON_SIZE_DIALOG); gtk_image_set_pixel_size (GTK_IMAGE (content), 512); gtk_box_pack_start (GTK_BOX (box), content, FALSE, TRUE, 0); gtk_widget_show_all (window); gtk_main (); return 0; }
static void on_activate (GApplication *app, gpointer data) { static GtkWidget *window = NULL; if (window == NULL) { GtkWidget *header, *sidebar_toggle, *animation_switch; GtkWidget *hbox, *revealer, *sidebar, *img; window = gtk_application_window_new (GTK_APPLICATION (app)); gtk_window_set_default_size (GTK_WINDOW (window), 400, 300); /* titlebar */ header = gtk_header_bar_new (); gtk_header_bar_set_show_title_buttons (GTK_HEADER_BAR (header), TRUE); gtk_window_set_titlebar (GTK_WINDOW (window), header); sidebar_toggle = gtk_toggle_button_new_with_label ("Show Sidebar"); gtk_header_bar_pack_start (GTK_HEADER_BAR (header), sidebar_toggle); animation_switch = gtk_switch_new (); gtk_widget_set_valign (animation_switch, GTK_ALIGN_CENTER); gtk_header_bar_pack_end (GTK_HEADER_BAR (header), animation_switch); gtk_header_bar_pack_end (GTK_HEADER_BAR (header), gtk_label_new ("Animations")); /* content */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_container_add (GTK_CONTAINER (window), hbox); revealer = gtk_revealer_new (); gtk_revealer_set_transition_type (GTK_REVEALER (revealer), GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT); gtk_container_add (GTK_CONTAINER (hbox), revealer); sidebar = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_widget_set_size_request (sidebar, 150, -1); gtk_style_context_add_class (gtk_widget_get_style_context (sidebar), GTK_STYLE_CLASS_SIDEBAR); gtk_container_add (GTK_CONTAINER (revealer), sidebar); img = gtk_image_new (); g_object_set (img, "icon-name", "face-smile-symbolic", "pixel-size", 128, "hexpand", TRUE, "halign", GTK_ALIGN_CENTER, "valign", GTK_ALIGN_CENTER, NULL); gtk_container_add (GTK_CONTAINER (hbox), img); g_object_bind_property (sidebar_toggle, "active", revealer, "reveal-child", G_BINDING_SYNC_CREATE); g_object_bind_property (gtk_settings_get_default(), "gtk-enable-animations", animation_switch, "active", G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL); } gtk_window_present (GTK_WINDOW (window)); }
static void ev_previewer_toolbar_constructed (GObject *object) { EvPreviewerToolbar *ev_previewer_toolbar = EV_PREVIEWER_TOOLBAR (object); EvPreviewerToolbarPrivate *priv; GtkWidget *hbox; GtkBuilder *builder; G_OBJECT_CLASS (ev_previewer_toolbar_parent_class)->constructed (object); priv = ev_previewer_toolbar_get_instance_private (ev_previewer_toolbar); builder = gtk_builder_new_from_resource ("/org/gnome/evince/previewer/ui/previewer.ui"); hbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL); gtk_widget_set_halign (hbox, GTK_ALIGN_CENTER); gtk_button_box_set_layout (GTK_BUTTON_BOX (hbox), GTK_BUTTONBOX_EXPAND); gtk_box_set_homogeneous (GTK_BOX (hbox), FALSE); priv->previous_button = GTK_WIDGET (gtk_builder_get_object (builder, "go-previous-page")); gtk_box_pack_start (GTK_BOX (hbox), priv->previous_button, FALSE, FALSE, 0); gtk_widget_show (priv->previous_button); priv->next_button = GTK_WIDGET (gtk_builder_get_object (builder, "go-next-page")); gtk_box_pack_start (GTK_BOX (hbox), priv->next_button, FALSE, FALSE, 0); gtk_widget_show (priv->next_button); gtk_header_bar_pack_start (GTK_HEADER_BAR (ev_previewer_toolbar), hbox); gtk_widget_show (hbox); /* Page selector */ priv->page_selector = GTK_WIDGET (g_object_new (EV_TYPE_PAGE_ACTION_WIDGET, NULL)); gtk_widget_set_tooltip_text (priv->page_selector, _("Select page or search in the index")); atk_object_set_name (gtk_widget_get_accessible (priv->page_selector), _("Select page")); ev_page_action_widget_set_model (EV_PAGE_ACTION_WIDGET (priv->page_selector), ev_previewer_window_get_document_model (priv->window)); gtk_header_bar_pack_start (GTK_HEADER_BAR (ev_previewer_toolbar), priv->page_selector); gtk_widget_show (priv->page_selector); /* Print */ priv->print_button = GTK_WIDGET (gtk_builder_get_object (builder, "print")); gtk_header_bar_pack_end (GTK_HEADER_BAR (ev_previewer_toolbar), priv->print_button); gtk_widget_show (priv->print_button); /* Zoom */ hbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL); gtk_widget_set_halign (hbox, GTK_ALIGN_CENTER); gtk_button_box_set_layout (GTK_BUTTON_BOX (hbox), GTK_BUTTONBOX_EXPAND); gtk_box_set_homogeneous (GTK_BOX (hbox), FALSE); priv->zoom_in_button = GTK_WIDGET (gtk_builder_get_object (builder, "zoom-in")); gtk_box_pack_start (GTK_BOX (hbox), priv->zoom_in_button, FALSE, FALSE, 0); gtk_widget_show (priv->zoom_in_button); priv->zoom_default_button = GTK_WIDGET (gtk_builder_get_object (builder, "zoom-default")); gtk_box_pack_start (GTK_BOX (hbox), priv->zoom_default_button, FALSE, FALSE, 0); gtk_widget_show (priv->zoom_default_button); priv->zoom_out_button = GTK_WIDGET (gtk_builder_get_object (builder, "zoom-out")); gtk_box_pack_start (GTK_BOX (hbox), priv->zoom_out_button, FALSE, FALSE, 0); gtk_widget_show (priv->zoom_out_button); gtk_header_bar_pack_end (GTK_HEADER_BAR (ev_previewer_toolbar), hbox); gtk_widget_show (hbox); g_object_unref (builder); }
static void cc_sharing_panel_setup_media_sharing_dialog (CcSharingPanel *self) { CcSharingPanelPrivate *priv = self->priv; gchar **folders, **list; GtkWidget *box, *networks, *grid, *w; char *path; path = g_find_program_in_path ("rygel"); if (path == NULL) { gtk_widget_hide (WID ("media-sharing-button")); return; } g_free (path); g_signal_connect (WID ("media-sharing-dialog"), "response", G_CALLBACK (cc_sharing_panel_media_sharing_dialog_response), self); cc_media_sharing_get_preferences (&folders); box = WID ("shared-folders-listbox"); gtk_list_box_set_header_func (GTK_LIST_BOX (box), cc_list_box_update_header_func, NULL, NULL); cc_list_box_setup_scrolling (GTK_LIST_BOX (box), 3); list = folders; while (list && *list) { GtkWidget *row; row = cc_sharing_panel_new_media_sharing_row (*list, self); gtk_list_box_insert (GTK_LIST_BOX (box), row, -1); list++; } gtk_list_box_insert (GTK_LIST_BOX (box), cc_sharing_panel_new_add_media_sharing_row (self), -1); cc_list_box_adjust_scrolling (GTK_LIST_BOX (box)); g_signal_connect (G_OBJECT (box), "row-activated", G_CALLBACK (cc_sharing_panel_add_folder), self); g_strfreev (folders); networks = cc_sharing_networks_new (self->priv->sharing_proxy, "rygel"); grid = WID ("grid4"); gtk_grid_attach (GTK_GRID (grid), networks, 0, 4, 2, 1); gtk_widget_show (networks); w = cc_sharing_switch_new (networks); gtk_header_bar_pack_start (GTK_HEADER_BAR (WID ("media-sharing-headerbar")), w); self->priv->media_sharing_switch = w; cc_sharing_panel_bind_networks_to_label (self, networks, WID ("media-sharing-status-label")); }
/** * Creates empty main application window */ GtkWidget *create_mainwindow (ezeedo_wrapper_structure *ezeedo) { // define widgets GtkWidget *window; GtkWidget *headerbar; GtkWidget *windowmenu_button; GtkWidget *stack; GtkWidget *stackswitcher; GtkWidget *todo_stack; GtkWidget *todo_paned; GtkWidget *todolist_scrollbox; GtkWidget *todolist_box; GtkWidget *categories_scrollbox; GtkWidget *categories_box; GtkWidget *task_entry; GtkWidget *done_stack; GtkWidget *donelist_scrollbox; GtkWidget *donelist_box; GtkWidget *archive_button; // define action GSimpleAction *about_action; // get window size and position from gsettings store GSettings *settings; gint width; gint height; gint x; gint y; gint sidebar_size; settings = g_settings_new ("org.y20k.ezeedo"); width = g_settings_get_int (settings, "main-window-width"); height = g_settings_get_int (settings, "main-window-height"); x = g_settings_get_int (settings, "main-window-position-y"); y = g_settings_get_int (settings, "main-window-position-y"); sidebar_size = g_settings_get_int (settings, "sidebar-size"); g_object_unref (settings); // create main window with title and default size window = gtk_application_window_new (ezeedo->application); gtk_window_set_title (GTK_WINDOW (window), "Ezeedo"); gtk_window_set_icon_name (GTK_WINDOW (window), EZEEDOICON); gtk_window_set_default_size (GTK_WINDOW (window), width, height); gtk_window_move (GTK_WINDOW (window), x, y); // create headerbar and stack switcher headerbar = gtk_header_bar_new (); gtk_header_bar_set_show_close_button (GTK_HEADER_BAR(headerbar), true); stackswitcher = gtk_stack_switcher_new (); // create stack for todo and done stack = gtk_stack_new (); // create stack for todolist todo_stack = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); // create paned container for left and right columns of todo tab todo_paned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL); gtk_paned_set_position (GTK_PANED(todo_paned), sidebar_size); // create categories scrollbox and box for left pane categories_scrollbox = gtk_scrolled_window_new (NULL, NULL); categories_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); // create todolist scrollbox and box for right pane todolist_scrollbox = gtk_scrolled_window_new (NULL, NULL); todolist_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); // create task entry task_entry = gtk_entry_new (); gtk_widget_set_margin_start (GTK_WIDGET(task_entry), 10); gtk_widget_set_margin_end (GTK_WIDGET(task_entry), 10); gtk_widget_set_margin_top (GTK_WIDGET(task_entry), 10); gtk_widget_set_margin_bottom (GTK_WIDGET(task_entry), 10); gtk_entry_set_placeholder_text (GTK_ENTRY(task_entry), "Enter new task"); gtk_entry_set_max_length (GTK_ENTRY(task_entry), TASKLENGTH); gtk_widget_grab_focus (task_entry); // create stack for donelist done_stack = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); // create donelist scrollbox and box donelist_scrollbox = gtk_scrolled_window_new (NULL, NULL); donelist_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); // create archive button archive_button = gtk_button_new_with_label ("Archive all done tasks"); gtk_widget_set_margin_start (GTK_WIDGET (archive_button), 10); gtk_widget_set_margin_end (GTK_WIDGET (archive_button), 10); gtk_widget_set_margin_top (GTK_WIDGET (archive_button), 10); gtk_widget_set_margin_bottom (GTK_WIDGET (archive_button), 10); // add some widgets to ezeedo wrapper structure ezeedo->window = window; ezeedo->todo_paned = todo_paned; ezeedo->categories_box = categories_box; ezeedo->todolist_box = todolist_box; ezeedo->donelist_box = donelist_box; // create window menu windowmenu_button = create_windowmenu (ezeedo); // create about action and connect about action signal about_action = g_simple_action_new ("about", NULL); g_action_map_add_action (G_ACTION_MAP (window), G_ACTION (about_action)); g_signal_connect (about_action, "activate", G_CALLBACK (show_about_window), window); // detect entry signal g_signal_connect (task_entry, "activate", G_CALLBACK (add_task_entry), ezeedo); // detect archive button pressed g_signal_connect (archive_button, "clicked", G_CALLBACK (display_info_dialog), "Task archival is not supported yet."); // detect window close g_signal_connect (G_OBJECT (window), "delete-event", G_CALLBACK (close_window), ezeedo); // construct headerbar for main window gtk_window_set_titlebar (GTK_WINDOW(window), headerbar); gtk_header_bar_pack_start (GTK_HEADER_BAR(headerbar), stackswitcher); gtk_header_bar_pack_end (GTK_HEADER_BAR(headerbar), windowmenu_button); // add stack to main window gtk_container_add (GTK_CONTAINER(window), stack); // set stack switcher and populate stack with todolist and donelist gtk_stack_switcher_set_stack (GTK_STACK_SWITCHER(stackswitcher), GTK_STACK(stack)); gtk_stack_add_titled (GTK_STACK(stack), todo_stack, "To do", "To do"); gtk_stack_add_titled (GTK_STACK(stack), done_stack, "Done", "Done"); // construct main todo stack gtk_container_add (GTK_CONTAINER(todo_stack), todo_paned); gtk_paned_add1 (GTK_PANED(todo_paned), categories_scrollbox); gtk_paned_add2 (GTK_PANED(todo_paned), todolist_scrollbox); // add box to scrollable box gtk_container_add (GTK_CONTAINER(todolist_scrollbox), todolist_box); // add task entry to todo stack gtk_container_add (GTK_CONTAINER(todo_stack), task_entry); // add box to scrollable box gtk_container_add (GTK_CONTAINER(categories_scrollbox), categories_box); // construct main donelist stack gtk_container_add (GTK_CONTAINER(done_stack), donelist_scrollbox); gtk_container_add (GTK_CONTAINER(donelist_scrollbox), donelist_box); return (window); }
static void cc_sharing_panel_setup_screen_sharing_dialog (CcSharingPanel *self) { CcSharingPanelPrivate *priv = self->priv; GSettings *settings; GtkWidget *networks, *box, *w; cc_sharing_panel_bind_switch_to_widgets (WID ("require-password-radiobutton"), WID ("password-grid"), NULL); cc_sharing_panel_setup_label_with_hostname (self, WID ("screen-sharing-label")); /* settings bindings */ settings = g_settings_new (VINO_SCHEMA_ID); g_settings_bind (settings, "view-only", WID ("remote-control-switch"), "active", G_SETTINGS_BIND_DEFAULT | G_SETTINGS_BIND_INVERT_BOOLEAN); g_settings_bind (settings, "prompt-enabled", WID ("approve-connections-radiobutton"), "active", G_SETTINGS_BIND_DEFAULT); g_settings_bind_with_mapping (settings, "authentication-methods", WID ("require-password-radiobutton"), "active", G_SETTINGS_BIND_DEFAULT, vino_get_authtype, vino_set_authtype, NULL, NULL); g_settings_bind_with_mapping (settings, "vnc-password", WID ("remote-control-password-entry"), "text", G_SETTINGS_BIND_DEFAULT, vino_get_password, vino_set_password, NULL, NULL); g_object_bind_property (WID ("show-password-checkbutton"), "active", WID ("remote-control-password-entry"), "visibility", G_BINDING_SYNC_CREATE); /* make sure the password entry is hidden by default */ g_signal_connect (priv->screen_sharing_dialog, "show", G_CALLBACK (screen_sharing_show_cb), self); g_signal_connect (priv->screen_sharing_dialog, "hide", G_CALLBACK (screen_sharing_hide_cb), self); /* accept at most 8 bytes in password entry */ g_signal_connect (WID ("remote-control-password-entry"), "insert-text", G_CALLBACK (screen_sharing_password_insert_text_cb), self); networks = cc_sharing_networks_new (self->priv->sharing_proxy, "vino-server"); box = WID ("remote-control-box"); gtk_box_pack_end (GTK_BOX (box), networks, TRUE, TRUE, 0); gtk_widget_show (networks); w = cc_sharing_switch_new (networks); gtk_header_bar_pack_start (GTK_HEADER_BAR (WID ("screen-sharing-headerbar")), w); self->priv->screen_sharing_switch = w; cc_sharing_panel_bind_networks_to_label (self, networks, WID ("screen-sharing-status-label")); }
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()); }
GtkWidget * reader_window_new(GtkApplication *application, CainteoirSettings *settings, CainteoirSpeechSynthesizers *synthesizers, const gchar *filename) { ReaderWindow *reader = READER_WINDOW(g_object_new(READER_TYPE_WINDOW, "application", application, nullptr)); ReaderWindowPrivate *priv = READER_WINDOW_PRIVATE(reader); priv->self = GTK_WIDGET(reader); priv->settings = CAINTEOIR_SETTINGS(g_object_ref(G_OBJECT(settings))); priv->tts = CAINTEOIR_SPEECH_SYNTHESIZERS(g_object_ref(G_OBJECT(synthesizers))); priv->application = READER_APPLICATION(application); gtk_window_set_default_size(GTK_WINDOW(reader), INDEX_PANE_WIDTH + DOCUMENT_PANE_WIDTH + 5, 300); gtk_window_set_title(GTK_WINDOW(reader), i18n("Cainteoir Text-to-Speech")); GtkWidget *layout = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); gtk_container_add(GTK_CONTAINER(reader), layout); priv->header = gtk_header_bar_new(); gtk_header_bar_set_title(GTK_HEADER_BAR(priv->header), i18n("Cainteoir Text-to-Speech")); if (cainteoir_settings_get_boolean(priv->settings, "window", "have-csd", TRUE)) { // Use client-side decorations (e.g. on Gnome Shell and Unity) ... gtk_header_bar_set_show_close_button(GTK_HEADER_BAR(priv->header), TRUE); gtk_window_set_titlebar(GTK_WINDOW(reader), priv->header); } else { // Don't use client-side decorations (e.g. on KDE) ... gtk_box_pack_start(GTK_BOX(layout), priv->header, FALSE, FALSE, 0); } priv->actions = create_action_group(priv); gtk_widget_insert_action_group(GTK_WIDGET(reader), "cainteoir", G_ACTION_GROUP(priv->actions)); priv->view = reader_document_view_new(priv->settings); gtk_box_pack_start(GTK_BOX(layout), priv->view, TRUE, TRUE, 0); reader_document_view_set_index_pane_close_action_name(READER_DOCUMENT_VIEW(priv->view), "cainteoir.side-pane"); GtkWidget *bottombar = gtk_toolbar_new(); gtk_widget_set_size_request(bottombar, -1, 45); gtk_style_context_add_class(gtk_widget_get_style_context(bottombar), "bottombar"); gtk_box_pack_start(GTK_BOX(layout), bottombar, FALSE, FALSE, 0); GtkToolItem *record = gtk_tool_button_new(gtk_image_new_from_icon_name("media-record-symbolic", GTK_ICON_SIZE_SMALL_TOOLBAR), nullptr); gtk_toolbar_insert(GTK_TOOLBAR(bottombar), record, -1); gtk_actionable_set_action_name(GTK_ACTIONABLE(record), "cainteoir.record"); priv->play_stop = gtk_tool_button_new(nullptr, nullptr); gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(priv->play_stop), "media-playback-start-symbolic"); gtk_toolbar_insert(GTK_TOOLBAR(bottombar), priv->play_stop, -1); gtk_actionable_set_action_name(GTK_ACTIONABLE(priv->play_stop), "cainteoir.play-stop"); GtkToolItem *open = gtk_tool_button_new(gtk_image_new_from_icon_name("document-open-symbolic", GTK_ICON_SIZE_SMALL_TOOLBAR), nullptr); gtk_toolbar_insert(GTK_TOOLBAR(bottombar), open, -1); gtk_actionable_set_action_name(GTK_ACTIONABLE(open), "cainteoir.open"); GtkToolItem *timebar = gtk_tool_item_new(); gtk_tool_item_set_expand(GTK_TOOL_ITEM(timebar), TRUE); gtk_toolbar_insert(GTK_TOOLBAR(bottombar), timebar, -1); priv->timebar = cainteoir_timebar_new(); gtk_style_context_add_class(gtk_widget_get_style_context(priv->timebar), "timebar"); gtk_container_add(GTK_CONTAINER(timebar), priv->timebar); priv->previous = gtk_button_new(); gtk_button_set_image(GTK_BUTTON(priv->previous), gtk_image_new_from_icon_name("go-previous-symbolic", GTK_ICON_SIZE_SMALL_TOOLBAR)); gtk_header_bar_pack_start(GTK_HEADER_BAR(priv->header), priv->previous); gtk_actionable_set_action_name(GTK_ACTIONABLE(priv->previous), "cainteoir.view-previous"); GtkWidget *menu_button = gtk_menu_button_new(); gtk_button_set_image(GTK_BUTTON(menu_button), gtk_image_new_from_icon_name(HAMBURGER_MENU_ICON, GTK_ICON_SIZE_SMALL_TOOLBAR)); gtk_menu_button_set_menu_model(GTK_MENU_BUTTON(menu_button), create_main_menu()); gtk_header_bar_pack_end(GTK_HEADER_BAR(priv->header), menu_button); g_signal_connect(reader, "window-state-event", G_CALLBACK(on_window_state_changed), priv->settings); g_signal_connect(reader, "delete_event", G_CALLBACK(on_window_delete), priv); g_signal_connect(reader, "show", G_CALLBACK(on_window_show), priv); g_signal_connect(priv->tts, "speaking", G_CALLBACK(on_speaking), priv); g_signal_connect(priv->tts, "text-range-changed", G_CALLBACK(on_text_range_changed), priv); gtk_window_resize(GTK_WINDOW(reader), cainteoir_settings_get_integer(priv->settings, "window", "width", 700), cainteoir_settings_get_integer(priv->settings, "window", "height", 445)); gtk_window_move(GTK_WINDOW(reader), cainteoir_settings_get_integer(priv->settings, "window", "left", 0), cainteoir_settings_get_integer(priv->settings, "window", "top", 0)); if (cainteoir_settings_get_boolean(priv->settings, "window", "maximized", FALSE)) gtk_window_maximize(GTK_WINDOW(reader)); if (filename) reader_window_load_document(reader, filename); else { gchar *prev_filename = cainteoir_settings_get_string(priv->settings, "document", "filename", nullptr); if (prev_filename) { reader_window_load_document(reader, prev_filename); g_free(prev_filename); } } gchar *anchor = cainteoir_settings_get_string(priv->settings, "highlight", "anchor", "none"); if (anchor) { if (!strcmp(anchor, "top")) reader_window_set_highlight_anchor(reader, GTK_ALIGN_START); else if (!strcmp(anchor, "middle")) reader_window_set_highlight_anchor(reader, GTK_ALIGN_CENTER); else if (!strcmp(anchor, "bottom")) reader_window_set_highlight_anchor(reader, GTK_ALIGN_END); g_free(anchor); } return GTK_WIDGET(reader); }
/*********************************************************************** 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); }
PocketvoxSetup* pocketvox_setup_new() { PocketvoxSetup *setup = (PocketvoxSetup *)g_object_new(TYPE_POCKETVOX_SETUP, NULL); setup->priv = G_TYPE_INSTANCE_GET_PRIVATE (setup, TYPE_POCKETVOX_SETUP, PocketvoxSetupPrivate); PocketvoxSetupPrivate *priv = setup->priv; bindtextdomain (GETTEXT_PACKAGE, PROGRAMNAME_LOCALEDIR); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); textdomain(GETTEXT_PACKAGE); priv->settings = g_settings_new("org.pocketvox.config"); //Build the window priv->window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_position(GTK_WINDOW(priv->window), GTK_WIN_POS_CENTER_ALWAYS); gtk_window_set_title(GTK_WINDOW(priv->window), "pocketvox-gtk"); gtk_window_set_default_size(GTK_WINDOW(priv->window), 500, 350); gtk_window_set_icon_name(GTK_WINDOW(priv->window), "pocketvox"); gtk_container_set_border_width(GTK_CONTAINER(priv->window), 5); g_signal_connect_swapped(priv->window, "delete-event", G_CALLBACK(pocketvox_setup_save_and_quit), setup); GtkWidget *bar = gtk_header_bar_new(); gtk_header_bar_set_show_close_button(GTK_HEADER_BAR(bar), TRUE); gtk_window_set_titlebar(GTK_WINDOW(priv->window), bar); //add a vertical box GtkWidget *box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); gtk_container_add(GTK_CONTAINER(priv->window), box); //a button for all GtkWidget* button_notification = gtk_button_new_with_label(_("Notifications")); GtkWidget* button_user = gtk_button_new_with_label(_("Users")); GtkWidget* button_pocketsphinx = gtk_button_new_with_label(_("Pocketsphinx")); GtkWidget* button_gstreamer = gtk_button_new_with_label(_("Gstreamer")); gtk_widget_set_tooltip_text(button_notification, _("Display notifications parameters")); gtk_widget_set_tooltip_text(button_user, _("Display user parameters")); gtk_widget_set_tooltip_text(button_pocketsphinx, _("Display pocketsphinx parameters")); gtk_widget_set_tooltip_text(button_gstreamer, _("Display gstreamer parameters")); gtk_button_set_relief(GTK_BUTTON(button_notification), GTK_RELIEF_NONE); gtk_button_set_relief(GTK_BUTTON(button_user), GTK_RELIEF_NONE); gtk_button_set_relief(GTK_BUTTON(button_pocketsphinx), GTK_RELIEF_NONE); gtk_button_set_relief(GTK_BUTTON(button_gstreamer), GTK_RELIEF_NONE); GtkWidget *grid_button = gtk_grid_new(); gtk_grid_attach(GTK_GRID(grid_button), button_user, 0, 0, 1, 1); gtk_grid_attach(GTK_GRID(grid_button), button_notification, 0, 1, 1, 1); gtk_grid_attach(GTK_GRID(grid_button), button_pocketsphinx, 0, 2, 1, 1); gtk_grid_attach(GTK_GRID(grid_button), button_gstreamer, 0, 3, 1, 1); GtkWidget* grid_notification = pocketvox_setup_get_notification_grid(setup); GtkWidget* grid_user = pocketvox_setup_get_user_grid(setup); GtkWidget* grid_pocketsphinx = pocketvox_setup_get_pocketsphinx_grid(setup); GtkWidget* grid_gstreamer = pocketvox_setup_get_gstreamer_grid(setup); //connect all signals (TODO) g_signal_connect_swapped(button_notification, "clicked", G_CALLBACK(gtk_widget_show), grid_notification); g_signal_connect_swapped(button_notification, "clicked", G_CALLBACK(gtk_widget_hide), grid_user); g_signal_connect_swapped(button_notification, "clicked", G_CALLBACK(gtk_widget_hide), grid_pocketsphinx); g_signal_connect_swapped(button_notification, "clicked", G_CALLBACK(gtk_widget_hide), grid_gstreamer); g_signal_connect_swapped(button_pocketsphinx, "clicked", G_CALLBACK(gtk_widget_hide), grid_notification); g_signal_connect_swapped(button_pocketsphinx, "clicked", G_CALLBACK(gtk_widget_hide), grid_user); g_signal_connect_swapped(button_pocketsphinx, "clicked", G_CALLBACK(gtk_widget_show), grid_pocketsphinx); g_signal_connect_swapped(button_pocketsphinx, "clicked", G_CALLBACK(gtk_widget_hide), grid_gstreamer); g_signal_connect_swapped(button_user, "clicked", G_CALLBACK(gtk_widget_hide), grid_notification); g_signal_connect_swapped(button_user, "clicked", G_CALLBACK(gtk_widget_show), grid_user); g_signal_connect_swapped(button_user, "clicked", G_CALLBACK(gtk_widget_hide), grid_pocketsphinx); g_signal_connect_swapped(button_user, "clicked", G_CALLBACK(gtk_widget_hide), grid_gstreamer); g_signal_connect_swapped(button_gstreamer, "clicked", G_CALLBACK(gtk_widget_hide), grid_notification); g_signal_connect_swapped(button_gstreamer, "clicked", G_CALLBACK(gtk_widget_hide), grid_user); g_signal_connect_swapped(button_gstreamer, "clicked", G_CALLBACK(gtk_widget_hide), grid_pocketsphinx); g_signal_connect_swapped(button_gstreamer, "clicked", G_CALLBACK(gtk_widget_show), grid_gstreamer); //add GtkWidget* gridBox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); gtk_box_pack_start(GTK_BOX(gridBox), grid_user, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(gridBox), grid_notification, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(gridBox), grid_pocketsphinx, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(gridBox), grid_gstreamer, TRUE, TRUE, 0); GtkWidget* separator = gtk_separator_new(GTK_ORIENTATION_VERTICAL); gtk_widget_show(separator); GtkWidget *hgridBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start(GTK_BOX(hgridBox), grid_button, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(hgridBox), separator, FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(hgridBox), gridBox, TRUE, TRUE, 0); GtkWidget *stack = gtk_stack_new(); gtk_stack_set_transition_type(GTK_STACK(stack) , GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT); gtk_stack_set_transition_duration(GTK_STACK(stack), 1000); gtk_stack_add_titled(GTK_STACK(stack), hgridBox, "Setup", _("Configuration")); GtkWidget* scrolledWindow = gtk_scrolled_window_new(NULL, NULL); //return void pocketvox_setup_get_modules_grid(setup); gtk_container_add(GTK_CONTAINER(scrolledWindow), priv->listBox); gtk_widget_show_all(scrolledWindow); gtk_stack_add_titled(GTK_STACK(stack), scrolledWindow, "Modules", _("Modules")); //adding a task switcher GtkWidget* stackSwitcher = gtk_stack_switcher_new(); gtk_stack_switcher_set_stack(GTK_STACK_SWITCHER(stackSwitcher), GTK_STACK(stack)); gtk_header_bar_set_custom_title(GTK_HEADER_BAR(bar), stackSwitcher); GtkWidget *add_module_button = gtk_button_new_from_icon_name("gtk-new", GTK_ICON_SIZE_MENU); GtkWidget *remove_module_button = gtk_button_new_from_icon_name("gtk-delete", GTK_ICON_SIZE_MENU); gtk_button_set_relief(GTK_BUTTON(add_module_button), GTK_RELIEF_NONE); gtk_button_set_relief(GTK_BUTTON(remove_module_button), GTK_RELIEF_NONE); gtk_header_bar_pack_start(GTK_HEADER_BAR(bar), add_module_button); gtk_header_bar_pack_start(GTK_HEADER_BAR(bar), remove_module_button); g_signal_connect_swapped(remove_module_button, "clicked", G_CALLBACK(pocketvox_setup_remove_module), setup); g_signal_connect_swapped(add_module_button, "clicked", G_CALLBACK(pocketvox_setup_add_module_callback), setup); g_signal_connect_swapped(stack, "notify::visible-child", G_CALLBACK(pocketvox_stack_child_changed), add_module_button); g_signal_connect_swapped(stack, "notify::visible-child", G_CALLBACK(pocketvox_stack_child_changed), remove_module_button); //add them to the vbox gtk_box_pack_start(GTK_BOX(box), stack, TRUE, TRUE, 0); gtk_widget_show(grid_user); gtk_widget_hide(grid_notification); gtk_widget_hide(grid_pocketsphinx); gtk_widget_hide(grid_gstreamer); gtk_widget_show(gridBox); gtk_widget_show_all(grid_button); gtk_widget_show(hgridBox); gtk_widget_show(box); gtk_widget_show(stack); gtk_widget_show(stackSwitcher); gtk_widget_show_all(bar); //get the setup return setup; }