static void pragha_system_titlebar_changed_cb (PraghaPreferences *preferences, GParamSpec *pspec, PraghaApplication *pragha) { PraghaToolbar *toolbar; GtkWidget *window, *parent, *menubar; GtkAction *action; window = pragha_application_get_window (pragha); toolbar = pragha_application_get_toolbar (pragha); menubar = pragha_application_get_menubar (pragha); g_object_ref(toolbar); parent = gtk_widget_get_parent (GTK_WIDGET(menubar)); if (pragha_preferences_get_system_titlebar (preferences)) { gtk_widget_hide(GTK_WIDGET(window)); action = pragha_application_get_menu_action (pragha, "/Menubar/ViewMenu/Fullscreen"); gtk_action_set_sensitive (GTK_ACTION (action), TRUE); action = pragha_application_get_menu_action (pragha, "/Menubar/ViewMenu/Playback controls below"); gtk_action_set_sensitive (GTK_ACTION (action), TRUE); gtk_window_set_titlebar (GTK_WINDOW (window), NULL); gtk_window_set_title (GTK_WINDOW(window), _("Pragha Music Player")); gtk_box_pack_start (GTK_BOX(parent), GTK_WIDGET(toolbar), FALSE, FALSE, 0); gtk_box_reorder_child(GTK_BOX(parent), GTK_WIDGET(toolbar), 1); pragha_toolbar_set_style(toolbar, TRUE); gtk_widget_show(GTK_WIDGET(window)); } else { gtk_widget_hide(GTK_WIDGET(window)); pragha_preferences_set_controls_below(preferences, FALSE); action = pragha_application_get_menu_action (pragha, "/Menubar/ViewMenu/Fullscreen"); gtk_action_set_sensitive (GTK_ACTION (action), FALSE); action = pragha_application_get_menu_action (pragha, "/Menubar/ViewMenu/Playback controls below"); gtk_action_set_sensitive (GTK_ACTION (action), FALSE); gtk_container_remove (GTK_CONTAINER(parent), GTK_WIDGET(toolbar)); gtk_window_set_titlebar (GTK_WINDOW (window), GTK_WIDGET(toolbar)); pragha_toolbar_set_style(toolbar, FALSE); gtk_widget_show(GTK_WIDGET(window)); } g_object_unref(toolbar); }
void glade_gtk_window_add_child (GladeWidgetAdaptor * adaptor, GObject * object, GObject * child) { GtkWidget *bin_child; gchar *special_child_type; special_child_type = g_object_get_data (child, "special-child-type"); if (special_child_type && !strcmp (special_child_type, "titlebar")) { gtk_window_set_titlebar (GTK_WINDOW (object), GTK_WIDGET (child)); } else { /* Get a placeholder out of the way before adding the child */ bin_child = gtk_bin_get_child (GTK_BIN (object)); if (bin_child) { if (GLADE_IS_PLACEHOLDER (bin_child)) gtk_container_remove (GTK_CONTAINER (object), bin_child); else { g_critical ("Cant add more than one widget to a GtkWindow"); return; } } gtk_container_add (GTK_CONTAINER (object), GTK_WIDGET (child)); } }
void glade_gtk_window_set_property (GladeWidgetAdaptor * adaptor, GObject * object, const gchar * id, const GValue * value) { GladeWidget *gwidget = glade_widget_get_from_gobject (object); if (!strcmp (id, "glade-window-icon-name")) { glade_widget_property_set_sensitive (gwidget, "icon", FALSE, NOT_SELECTED_MSG); glade_widget_property_set_sensitive (gwidget, "icon-name", FALSE, NOT_SELECTED_MSG); if (g_value_get_boolean (value)) glade_widget_property_set_sensitive (gwidget, "icon-name", TRUE, NULL); else glade_widget_property_set_sensitive (gwidget, "icon", TRUE, NULL); } else if (!strcmp (id, "use-csd")) { if (g_value_get_boolean (value)) { GtkWidget *titlebar; titlebar = gtk_window_get_titlebar (GTK_WINDOW (object)); if (!titlebar) titlebar = glade_placeholder_new (); g_object_set_data (G_OBJECT (titlebar), "special-child-type", "titlebar"); gtk_window_set_titlebar (GTK_WINDOW (object), titlebar); glade_widget_property_set_sensitive (gwidget, "title", FALSE, CSD_DISABLED_MESSAGE); glade_widget_property_set_sensitive (gwidget, "decorated", FALSE, CSD_DISABLED_MESSAGE); glade_widget_property_set_sensitive (gwidget, "hide-titlebar-when-maximized", FALSE, CSD_DISABLED_MESSAGE); } else { gtk_window_set_titlebar (GTK_WINDOW (object), NULL); glade_widget_property_set_sensitive (gwidget, "title", TRUE, NULL); glade_widget_property_set_sensitive (gwidget, "decorated", TRUE, NULL); glade_widget_property_set_sensitive (gwidget, "hide-titlebar-when-maximized", TRUE, NULL); } } else GWA_GET_CLASS (GTK_TYPE_CONTAINER)->set_property (adaptor, object, id, value); }
GtkWidget * create_header_bar (GtkWidget *dialog, const gchar *title) { static GtkWidget *header_bar = NULL; header_bar = gtk_header_bar_new(); gtk_header_bar_set_show_close_button (GTK_HEADER_BAR (header_bar), FALSE); gtk_header_bar_set_title (GTK_HEADER_BAR (header_bar), title); gtk_header_bar_set_has_subtitle (GTK_HEADER_BAR (header_bar), FALSE); gtk_window_set_titlebar (GTK_WINDOW (dialog), header_bar); return header_bar; }
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); } }
/* Create a new window loading a file */ static void sereneplayer_new_window (GApplication *app, GFile *file) { GtkWidget *window; GtkWidget *headerbar; GtkWidget *canvas; GtkBuilder *builder; GError* error = NULL; SereneplayerPrivate *priv = SERENEPLAYER_APPLICATION(app)->priv; /* Load UI from file */ builder = gtk_builder_new (); if (!gtk_builder_add_from_file (builder, UI_FILE, &error)) { g_critical ("Couldn't load builder file: %s", error->message); g_error_free (error); } /* Auto-connect signal handlers */ gtk_builder_connect_signals (builder, app); /* Get the window object from the ui file */ window = GTK_WIDGET (gtk_builder_get_object (builder, TOP_WINDOW)); if (!window) { g_critical ("Widget \"%s\" is missing in file %s.", TOP_WINDOW, UI_FILE); } headerbar = GTK_WIDGET (gtk_builder_get_object (builder, HEADERBAR)); gtk_window_set_titlebar (GTK_WINDOW (window), headerbar); canvas = GTK_WIDGET (gtk_builder_get_object (builder, CANVAS)); /* ANJUTA: Widgets initialization for sereneplayer.ui - DO NOT REMOVE */ g_object_unref (builder); gtk_window_set_application (GTK_WINDOW (window), GTK_APPLICATION (app)); if (file != NULL) { /* TODO: Add code here to open the file in the new window */ } MplayerWrap *mwrap = mplayerwrap_new(canvas); gtk_widget_show_all (GTK_WIDGET (window)); }
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); }
void ManageDB_sidebar(GtkApplication *application){ GtkWidget *sidebar; GtkWidget *stack; GtkWidget *box; GtkWidget *widget; GtkWidget *header; windowdb = gtk_application_window_new (application); header = gtk_header_bar_new (); gtk_header_bar_set_show_close_button (GTK_HEADER_BAR(header), TRUE); gtk_window_set_titlebar (GTK_WINDOW(windowdb), header); gtk_window_set_title(GTK_WINDOW(windowdb), "Gerenciamento do Banco de Dados"); gtk_window_set_default_size (GTK_WINDOW (windowdb), 500, 500); g_signal_connect (windowdb, "destroy", G_CALLBACK (gtk_widget_destroyed), &windowdb); box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); sidebar = gtk_stack_sidebar_new (); gtk_box_pack_start (GTK_BOX (box), sidebar, FALSE, FALSE, 0); stack = gtk_stack_new (); gtk_stack_set_transition_type (GTK_STACK (stack), GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN); gtk_stack_sidebar_set_stack (GTK_STACK_SIDEBAR (sidebar), GTK_STACK (stack)); /* Separator between sidebar and stack */ widget = gtk_separator_new (GTK_ORIENTATION_VERTICAL); gtk_box_pack_start (GTK_BOX(box), widget, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (box), stack, TRUE, TRUE, 0); /* Precisamos adicionar as ações... */ Welcome_side(widget, stack); Create_side(widget, stack); Backup_side(widget, stack); Restore_side(widget, stack); Delete_side(widget, stack); Advanced_side(widget, stack); gtk_container_add (GTK_CONTAINER (windowdb), box); gtk_widget_show_all (windowdb); }
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 budgie_popover_init(BudgiePopover *self) { GtkWidget *empty = NULL; self->top = FALSE; /* We don't override as we need some GtkWindow rendering */ g_signal_connect(self, "draw", G_CALLBACK(budgie_popover_draw), self); g_signal_connect(self, "key-press-event", G_CALLBACK(focus_lose), self); self->focus_id = g_signal_connect(self, "focus-out-event", G_CALLBACK(focus_lose), self); empty = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1); gtk_window_set_titlebar(GTK_WINDOW(self), empty); /* Skip, no decorations, etc */ gtk_window_set_skip_taskbar_hint(GTK_WINDOW(self), TRUE); gtk_window_set_skip_pager_hint(GTK_WINDOW(self), TRUE); }
static void _gth_window_add_header_bar (GthWindow *self) { self->priv->headerbar = gtk_header_bar_new (); gtk_widget_show (self->priv->headerbar); gtk_header_bar_set_show_close_button (GTK_HEADER_BAR (self->priv->headerbar), TRUE); g_object_add_weak_pointer (G_OBJECT (self->priv->headerbar), &self->priv->headerbar); #if GTK_CHECK_VERSION(3,12,0) { gboolean shell_shows_app_menu; char *decoration_layout; g_object_get (gtk_settings_get_default (), "gtk-shell-shows-app-menu", &shell_shows_app_menu, "gtk-decoration-layout", &decoration_layout, NULL); if (! shell_shows_app_menu && ((decoration_layout == NULL) || (strstr (decoration_layout, "menu") == NULL))) { gboolean left_part_is_empty; char *new_layout; /* add 'menu' to the left */ left_part_is_empty = (decoration_layout == NULL) || (decoration_layout[0] == '\0') || (decoration_layout[0] == ':'); new_layout = g_strconcat ("menu", (left_part_is_empty ? "" : ","), decoration_layout, NULL); gtk_header_bar_set_decoration_layout (GTK_HEADER_BAR (self->priv->headerbar), new_layout); g_free (new_layout); } g_free (decoration_layout); } #endif self->priv->title = gth_window_title_new (); gtk_widget_show (self->priv->title); gtk_header_bar_set_custom_title (GTK_HEADER_BAR (self->priv->headerbar), self->priv->title); self->priv->headerbar_container = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_widget_show (self->priv->headerbar_container); gtk_box_pack_start (GTK_BOX (self->priv->headerbar_container), self->priv->headerbar, TRUE, TRUE, 0); gtk_window_set_titlebar (GTK_WINDOW (self), self->priv->headerbar_container); }
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); }
static void gtimer_window_construct_ui (GTimerWindow *window) { GtkWidget *headerbar; GtkWidget *gtimer_face; g_return_if_fail (GTIMER_IS_WINDOW (window)); headerbar = gtk_header_bar_new (); gtk_header_bar_set_show_close_button (GTK_HEADER_BAR (headerbar), TRUE); gtk_header_bar_set_title (GTK_HEADER_BAR (headerbar), g_get_application_name ()); gtk_window_set_titlebar (GTK_WINDOW (window), headerbar); gtimer_face = gtimer_face_new (); gtk_container_add (GTK_CONTAINER (window), gtimer_face); gtk_widget_show_all (GTK_WIDGET (window)); }
static void setup_accels_actions_headerbar (PtWindow *win) { /* Actions */ g_action_map_add_action_entries (G_ACTION_MAP (win), win_actions, G_N_ELEMENTS (win_actions), win); enable_win_actions (win, FALSE); /* GtkHeader workaround for glade 3.16 + Menu button */ GtkBuilder *builder; GMenuModel *model; GtkWidget *hbar; GtkWidget *menu_button; builder = gtk_builder_new_from_resource ("/org/gnome/parlatype/window-headerbar.ui"); hbar = GTK_WIDGET (gtk_builder_get_object (builder, "headerbar")); win->priv->button_open = GTK_WIDGET (gtk_builder_get_object (builder, "button_open")); win->priv->button_play = GTK_WIDGET (gtk_builder_get_object (builder, "button_play")); menu_button = GTK_WIDGET (gtk_builder_get_object (builder, "menu_button")); gtk_window_set_titlebar (GTK_WINDOW (win), hbar); gtk_builder_connect_signals (builder, win); builder = gtk_builder_new_from_resource ("/org/gnome/parlatype/menus.ui"); model = G_MENU_MODEL (gtk_builder_get_object (builder, "winmenu")); gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (menu_button), model); g_object_unref (builder); /* Accels */ GtkAccelGroup *accels; accels = gtk_accel_group_new (); gtk_window_add_accel_group (GTK_WINDOW (win), accels); gtk_widget_add_accelerator (menu_button, "clicked", accels, GDK_KEY_F10, 0, GTK_ACCEL_VISIBLE); }
void glade_gtk_window_remove_child (GladeWidgetAdaptor * adaptor, GObject * object, GObject * child) { gchar *special_child_type; GtkWidget *placeholder; placeholder = glade_placeholder_new (); special_child_type = g_object_get_data (child, "special-child-type"); if (special_child_type && !strcmp (special_child_type, "titlebar")) { g_object_set_data (G_OBJECT (placeholder), "special-child-type", "titlebar"); gtk_window_set_titlebar (GTK_WINDOW (object), placeholder); } else { gtk_container_remove (GTK_CONTAINER (object), GTK_WIDGET (child)); gtk_container_add (GTK_CONTAINER (object), placeholder); } }
GtkWidget * do_paint (GtkWidget *toplevel) { static GtkWidget *window = NULL; if (!window) { GtkWidget *draw_area, *headerbar, *colorbutton; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); draw_area = drawing_area_new (); gtk_container_add (GTK_CONTAINER (window), draw_area); headerbar = gtk_header_bar_new (); gtk_header_bar_set_title (GTK_HEADER_BAR (headerbar), "Paint"); gtk_header_bar_set_show_title_buttons (GTK_HEADER_BAR (headerbar), TRUE); colorbutton = gtk_color_button_new (); g_signal_connect (colorbutton, "color-set", G_CALLBACK (color_button_color_set), draw_area); g_signal_connect (draw_area, "color-set", G_CALLBACK (drawing_area_color_set), colorbutton); gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (colorbutton), &(GdkRGBA) { 0, 0, 0, 1 }); gtk_header_bar_pack_end (GTK_HEADER_BAR (headerbar), colorbutton); gtk_window_set_titlebar (GTK_WINDOW (window), headerbar); g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window); } if (!gtk_widget_get_visible (window)) gtk_widget_show (window); else gtk_widget_destroy (window); return window; }
void glade_gtk_window_replace_child (GladeWidgetAdaptor * adaptor, GtkWidget * container, GtkWidget * current, GtkWidget * new_widget) { gchar *special_child_type; special_child_type = g_object_get_data (G_OBJECT (current), "special-child-type"); if (special_child_type && !strcmp (special_child_type, "titlebar")) { g_object_set_data (G_OBJECT (new_widget), "special-child-type", "titlebar"); gtk_window_set_titlebar (GTK_WINDOW (container), new_widget); return; } /* Chain Up */ GWA_GET_CLASS (GTK_TYPE_CONTAINER)->replace_child (adaptor, G_OBJECT (container), G_OBJECT (current), G_OBJECT (new_widget)); }
static void gtk_shortcuts_window_init (GtkShortcutsWindow *self) { GtkShortcutsWindowPrivate *priv = gtk_shortcuts_window_get_instance_private (self); GtkToggleButton *search_button; GtkBox *menu_box; GtkBox *box; GtkArrow *arrow; GtkWidget *scroller; GtkWidget *label; GtkWidget *empty; PangoAttrList *attributes; gtk_window_set_resizable (GTK_WINDOW (self), FALSE); gtk_window_set_type_hint (GTK_WINDOW (self), GDK_WINDOW_TYPE_HINT_DIALOG); g_signal_connect (self, "key-press-event", G_CALLBACK (window_key_press_event_cb), NULL); priv->keywords = g_hash_table_new_full (NULL, NULL, NULL, g_free); priv->search_items_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL); priv->search_text_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); priv->search_image_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); priv->header_bar = g_object_new (GTK_TYPE_HEADER_BAR, "show-close-button", TRUE, "visible", TRUE, NULL); gtk_window_set_titlebar (GTK_WINDOW (self), GTK_WIDGET (priv->header_bar)); search_button = g_object_new (GTK_TYPE_TOGGLE_BUTTON, "child", g_object_new (GTK_TYPE_IMAGE, "visible", TRUE, "icon-name", "edit-find-symbolic", NULL), "visible", TRUE, NULL); gtk_container_add (GTK_CONTAINER (priv->header_bar), GTK_WIDGET (search_button)); priv->main_box = g_object_new (GTK_TYPE_BOX, "orientation", GTK_ORIENTATION_VERTICAL, "visible", TRUE, NULL); GTK_CONTAINER_CLASS (gtk_shortcuts_window_parent_class)->add (GTK_CONTAINER (self), GTK_WIDGET (priv->main_box)); priv->search_bar = g_object_new (GTK_TYPE_SEARCH_BAR, "visible", TRUE, NULL); g_object_bind_property (priv->search_bar, "search-mode-enabled", search_button, "active", G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL); gtk_container_add (GTK_CONTAINER (priv->main_box), GTK_WIDGET (priv->search_bar)); priv->stack = g_object_new (GTK_TYPE_STACK, "expand", TRUE, "homogeneous", TRUE, "transition-type", GTK_STACK_TRANSITION_TYPE_CROSSFADE, "visible", TRUE, NULL); gtk_container_add (GTK_CONTAINER (priv->main_box), GTK_WIDGET (priv->stack)); priv->title_stack = g_object_new (GTK_TYPE_STACK, "visible", TRUE, NULL); gtk_header_bar_set_custom_title (priv->header_bar, GTK_WIDGET (priv->title_stack)); label = gtk_label_new (_("Shortcuts")); gtk_widget_show (label); gtk_style_context_add_class (gtk_widget_get_style_context (label), GTK_STYLE_CLASS_TITLE); gtk_stack_add_named (priv->title_stack, label, "title"); label = gtk_label_new (_("Search Results")); gtk_widget_show (label); gtk_style_context_add_class (gtk_widget_get_style_context (label), GTK_STYLE_CLASS_TITLE); gtk_stack_add_named (priv->title_stack, label, "search"); priv->menu_button = g_object_new (GTK_TYPE_MENU_BUTTON, "focus-on-click", FALSE, "visible", TRUE, "relief", GTK_RELIEF_NONE, NULL); gtk_stack_add_named (priv->title_stack, GTK_WIDGET (priv->menu_button), "sections"); menu_box = g_object_new (GTK_TYPE_BOX, "orientation", GTK_ORIENTATION_HORIZONTAL, "spacing", 6, "visible", TRUE, NULL); gtk_container_add (GTK_CONTAINER (priv->menu_button), GTK_WIDGET (menu_box)); priv->menu_label = g_object_new (GTK_TYPE_LABEL, "visible", TRUE, NULL); gtk_container_add (GTK_CONTAINER (menu_box), GTK_WIDGET (priv->menu_label)); G_GNUC_BEGIN_IGNORE_DEPRECATIONS; arrow = g_object_new (GTK_TYPE_ARROW, "arrow-type", GTK_ARROW_DOWN, "visible", TRUE, NULL); gtk_container_add (GTK_CONTAINER (menu_box), GTK_WIDGET (arrow)); G_GNUC_END_IGNORE_DEPRECATIONS; priv->popover = g_object_new (GTK_TYPE_POPOVER, "border-width", 6, "relative-to", priv->menu_button, "position", GTK_POS_BOTTOM, NULL); gtk_menu_button_set_popover (priv->menu_button, GTK_WIDGET (priv->popover)); priv->list_box = g_object_new (GTK_TYPE_LIST_BOX, "selection-mode", GTK_SELECTION_NONE, "visible", TRUE, NULL); g_signal_connect_object (priv->list_box, "row-activated", G_CALLBACK (gtk_shortcuts_window__list_box__row_activated), self, G_CONNECT_SWAPPED); gtk_container_add (GTK_CONTAINER (priv->popover), GTK_WIDGET (priv->list_box)); priv->search_entry = GTK_SEARCH_ENTRY (gtk_search_entry_new ()); gtk_widget_show (GTK_WIDGET (priv->search_entry)); gtk_container_add (GTK_CONTAINER (priv->search_bar), GTK_WIDGET (priv->search_entry)); g_object_set (priv->search_entry, "placeholder-text", _("Search Shortcuts"), "width-chars", 40, NULL); g_signal_connect_object (priv->search_entry, "search-changed", G_CALLBACK (gtk_shortcuts_window__entry__changed), self, G_CONNECT_SWAPPED); g_signal_connect_object (priv->search_bar, "notify::search-mode-enabled", G_CALLBACK (gtk_shortcuts_window__search_mode__changed), self, G_CONNECT_SWAPPED); scroller = g_object_new (GTK_TYPE_SCROLLED_WINDOW, "visible", TRUE, NULL); box = g_object_new (GTK_TYPE_BOX, "border-width", 24, "halign", GTK_ALIGN_CENTER, "spacing", 24, "orientation", GTK_ORIENTATION_VERTICAL, "visible", TRUE, NULL); gtk_container_add (GTK_CONTAINER (scroller), GTK_WIDGET (box)); gtk_stack_add_named (priv->stack, scroller, "internal-search"); priv->search_shortcuts = g_object_new (GTK_TYPE_BOX, "halign", GTK_ALIGN_CENTER, "spacing", 6, "orientation", GTK_ORIENTATION_VERTICAL, "visible", TRUE, NULL); gtk_container_add (GTK_CONTAINER (box), GTK_WIDGET (priv->search_shortcuts)); priv->search_gestures = g_object_new (GTK_TYPE_BOX, "halign", GTK_ALIGN_CENTER, "spacing", 6, "orientation", GTK_ORIENTATION_VERTICAL, "visible", TRUE, NULL); gtk_container_add (GTK_CONTAINER (box), GTK_WIDGET (priv->search_gestures)); empty = g_object_new (GTK_TYPE_GRID, "visible", TRUE, "row-spacing", 12, "margin", 12, "hexpand", TRUE, "vexpand", TRUE, "halign", GTK_ALIGN_CENTER, "valign", GTK_ALIGN_CENTER, NULL); gtk_style_context_add_class (gtk_widget_get_style_context (empty), GTK_STYLE_CLASS_DIM_LABEL); gtk_grid_attach (GTK_GRID (empty), g_object_new (GTK_TYPE_IMAGE, "visible", TRUE, "icon-name", "edit-find-symbolic", "pixel-size", 72, NULL), 0, 0, 1, 1); attributes = pango_attr_list_new (); pango_attr_list_insert (attributes, pango_attr_weight_new (PANGO_WEIGHT_BOLD)); pango_attr_list_insert (attributes, pango_attr_scale_new (1.44)); label = g_object_new (GTK_TYPE_LABEL, "visible", TRUE, "label", _("No Results Found"), "attributes", attributes, NULL); pango_attr_list_unref (attributes); gtk_grid_attach (GTK_GRID (empty), label, 0, 1, 1, 1); label = g_object_new (GTK_TYPE_LABEL, "visible", TRUE, "label", _("Try a different search"), NULL); gtk_grid_attach (GTK_GRID (empty), label, 0, 2, 1, 1); gtk_stack_add_named (priv->stack, empty, "no-search-results"); g_signal_connect_object (priv->stack, "notify::visible-child", G_CALLBACK (update_title_stack), self, G_CONNECT_SWAPPED); }
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)); }
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()); }
bool wxTopLevelWindowGTK::Create( wxWindow *parent, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& sizeOrig, long style, const wxString &name ) { wxSize size(sizeOrig); if (!size.IsFullySpecified()) size.SetDefaults(GetDefaultSize()); wxTopLevelWindows.Append( this ); if (!PreCreation( parent, pos, size ) || !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name )) { wxFAIL_MSG( wxT("wxTopLevelWindowGTK creation failed") ); return false; } m_title = title; // NB: m_widget may be !=NULL if it was created by derived class' Create, // e.g. in wxTaskBarIconAreaGTK if (m_widget == NULL) { m_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL); if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG) { // Tell WM that this is a dialog window and make it center // on parent by default (this is what GtkDialog ctor does): gtk_window_set_type_hint(GTK_WINDOW(m_widget), GDK_WINDOW_TYPE_HINT_DIALOG); gtk_window_set_position(GTK_WINDOW(m_widget), GTK_WIN_POS_CENTER_ON_PARENT); } else { if (style & wxFRAME_TOOL_WINDOW) { gtk_window_set_type_hint(GTK_WINDOW(m_widget), GDK_WINDOW_TYPE_HINT_UTILITY); // On some WMs, like KDE, a TOOL_WINDOW will still show // on the taskbar, but on Gnome a TOOL_WINDOW will not. // For consistency between WMs and with Windows, we // should set the NO_TASKBAR flag which will apply // the set_skip_taskbar_hint if it is available, // ensuring no taskbar entry will appear. style |= wxFRAME_NO_TASKBAR; } } g_object_ref(m_widget); } wxWindow *topParent = wxGetTopLevelParent(m_parent); if (topParent && (((GTK_IS_WINDOW(topParent->m_widget)) && (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)) || (style & wxFRAME_FLOAT_ON_PARENT))) { gtk_window_set_transient_for( GTK_WINDOW(m_widget), GTK_WINDOW(topParent->m_widget) ); } if (style & wxFRAME_NO_TASKBAR) { gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), TRUE); } if (style & wxSTAY_ON_TOP) { gtk_window_set_keep_above(GTK_WINDOW(m_widget), TRUE); } if (style & wxMAXIMIZE) gtk_window_maximize(GTK_WINDOW(m_widget)); #if 0 if (!name.empty()) gtk_window_set_role( GTK_WINDOW(m_widget), wxGTK_CONV( name ) ); #endif gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) ); gtk_widget_set_can_focus(m_widget, false); g_signal_connect (m_widget, "delete_event", G_CALLBACK (gtk_frame_delete_callback), this); // m_mainWidget is a GtkVBox, holding the bars and client area (m_wxwindow) m_mainWidget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); gtk_widget_show( m_mainWidget ); gtk_widget_set_can_focus(m_mainWidget, false); gtk_container_add( GTK_CONTAINER(m_widget), m_mainWidget ); // m_wxwindow is the client area m_wxwindow = wxPizza::New(); gtk_widget_show( m_wxwindow ); gtk_box_pack_start(GTK_BOX(m_mainWidget), m_wxwindow, true, true, 0); // we donm't allow the frame to get the focus as otherwise // the frame will grab it at arbitrary focus changes gtk_widget_set_can_focus(m_wxwindow, false); if (m_parent) m_parent->AddChild( this ); g_signal_connect(m_wxwindow, "size_allocate", G_CALLBACK(size_allocate), this); PostCreation(); #ifndef __WXGTK3__ if (pos != wxDefaultPosition) gtk_widget_set_uposition( m_widget, m_x, m_y ); #endif // for some reported size corrections g_signal_connect (m_widget, "map_event", G_CALLBACK (gtk_frame_map_callback), this); // for iconized state g_signal_connect (m_widget, "window_state_event", G_CALLBACK (gtk_frame_window_state_callback), this); // for wxMoveEvent g_signal_connect (m_widget, "configure_event", G_CALLBACK (gtk_frame_configure_callback), this); // activation g_signal_connect_after (m_widget, "focus_in_event", G_CALLBACK (gtk_frame_focus_in_callback), this); g_signal_connect_after (m_widget, "focus_out_event", G_CALLBACK (gtk_frame_focus_out_callback), this); // We need to customize the default GTK+ logic for key processing to make // it conforming to wxWidgets event processing order. g_signal_connect (m_widget, "key_press_event", G_CALLBACK (wxgtk_tlw_key_press_event), NULL); #ifdef GDK_WINDOWING_X11 #ifdef __WXGTK3__ if (GDK_IS_X11_SCREEN(gtk_window_get_screen(GTK_WINDOW(m_widget)))) #endif { gtk_widget_add_events(m_widget, GDK_PROPERTY_CHANGE_MASK); g_signal_connect(m_widget, "property_notify_event", G_CALLBACK(property_notify_event), this); } #endif // GDK_WINDOWING_X11 // translate wx decorations styles into Motif WM hints (they are recognized // by other WMs as well) // always enable moving the window as we have no separate flag for enabling // it m_gdkFunc = GDK_FUNC_MOVE; if ( style & wxCLOSE_BOX ) m_gdkFunc |= GDK_FUNC_CLOSE; if ( style & wxMINIMIZE_BOX ) m_gdkFunc |= GDK_FUNC_MINIMIZE; if ( style & wxMAXIMIZE_BOX ) m_gdkFunc |= GDK_FUNC_MAXIMIZE; if ( (style & wxSIMPLE_BORDER) || (style & wxNO_BORDER) ) { m_gdkDecor = 0; gtk_window_set_decorated(GTK_WINDOW(m_widget), false); } else // have border { m_gdkDecor = GDK_DECOR_BORDER; if ( style & wxCAPTION ) m_gdkDecor |= GDK_DECOR_TITLE; #if defined(GDK_WINDOWING_WAYLAND) && GTK_CHECK_VERSION(3,10,0) else if ( GDK_IS_WAYLAND_DISPLAY(gtk_widget_get_display(m_widget)) && gtk_check_version(3,10,0) == NULL) { gtk_window_set_titlebar(GTK_WINDOW(m_widget), gtk_header_bar_new()); } #endif if ( style & wxSYSTEM_MENU ) m_gdkDecor |= GDK_DECOR_MENU; if ( style & wxMINIMIZE_BOX ) m_gdkDecor |= GDK_DECOR_MINIMIZE; if ( style & wxMAXIMIZE_BOX ) m_gdkDecor |= GDK_DECOR_MAXIMIZE; if ( style & wxRESIZE_BORDER ) { m_gdkFunc |= GDK_FUNC_RESIZE; m_gdkDecor |= GDK_DECOR_RESIZEH; } } m_decorSize = GetCachedDecorSize(); int w, h; GTKDoGetSize(&w, &h); if (style & wxRESIZE_BORDER) { gtk_window_set_default_size(GTK_WINDOW(m_widget), w, h); #ifndef __WXGTK3__ gtk_window_set_policy(GTK_WINDOW(m_widget), 1, 1, 1); #endif } else { gtk_window_set_resizable(GTK_WINDOW(m_widget), false); // gtk_window_set_default_size() does not work for un-resizable windows, // unless you set the size hints, but that causes Ubuntu's WM to make // the window resizable even though GDK_FUNC_RESIZE is not set. gtk_widget_set_size_request(m_widget, w, h); } return true; }
/** * gs_shell_setup: */ void gs_shell_setup (GsShell *shell, GsPluginLoader *plugin_loader, GCancellable *cancellable) { GsShellPrivate *priv = gs_shell_get_instance_private (shell); GtkWidget *widget; g_return_if_fail (GS_IS_SHELL (shell)); priv->plugin_loader = g_object_ref (plugin_loader); g_signal_connect (priv->plugin_loader, "updates-changed", G_CALLBACK (gs_shell_updates_changed_cb), shell); priv->cancellable = g_object_ref (cancellable); gs_shell_monitor_permission (shell); /* get UI */ priv->builder = gtk_builder_new_from_resource ("/org/gnome/Software/gnome-software.ui"); priv->main_window = GTK_WINDOW (gtk_builder_get_object (priv->builder, "window_software")); g_signal_connect (priv->main_window, "map", G_CALLBACK (gs_shell_main_window_mapped_cb), shell); /* add application specific icons to search path */ gtk_icon_theme_append_search_path (gtk_icon_theme_get_default (), GS_DATA G_DIR_SEPARATOR_S "icons"); g_signal_connect (priv->main_window, "delete-event", G_CALLBACK (main_window_closed_cb), shell); /* fix up the header bar */ widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "header")); g_object_ref (widget); gtk_container_remove (GTK_CONTAINER (gtk_widget_get_parent (widget)), widget); gtk_window_set_titlebar (GTK_WINDOW (priv->main_window), widget); g_object_unref (widget); /* global keynav */ g_signal_connect_after (priv->main_window, "key_press_event", G_CALLBACK (window_key_press_event), shell); /* mouse hardware back button */ g_signal_connect_after (priv->main_window, "button_press_event", G_CALLBACK (window_button_press_event), shell); /* setup buttons */ widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "button_back")); g_signal_connect (widget, "clicked", G_CALLBACK (gs_shell_back_button_cb), shell); widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "button_all")); g_object_set_data (G_OBJECT (widget), "gnome-software::overview-mode", GINT_TO_POINTER (GS_SHELL_MODE_OVERVIEW)); g_signal_connect (widget, "clicked", G_CALLBACK (gs_shell_overview_button_cb), shell); widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "button_installed")); g_object_set_data (G_OBJECT (widget), "gnome-software::overview-mode", GINT_TO_POINTER (GS_SHELL_MODE_INSTALLED)); g_signal_connect (widget, "clicked", G_CALLBACK (gs_shell_overview_button_cb), shell); widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "button_updates")); g_object_set_data (G_OBJECT (widget), "gnome-software::overview-mode", GINT_TO_POINTER (GS_SHELL_MODE_UPDATES)); g_signal_connect (widget, "clicked", G_CALLBACK (gs_shell_overview_button_cb), shell); priv->shell_overview = GS_SHELL_OVERVIEW (gtk_builder_get_object (priv->builder, "shell_overview")); gs_shell_overview_setup (priv->shell_overview, shell, priv->plugin_loader, priv->builder, priv->cancellable); priv->shell_updates = GS_SHELL_UPDATES (gtk_builder_get_object (priv->builder, "shell_updates")); gs_shell_updates_setup (priv->shell_updates, shell, priv->plugin_loader, priv->builder, priv->cancellable); priv->shell_installed = GS_SHELL_INSTALLED (gtk_builder_get_object (priv->builder, "shell_installed")); gs_shell_installed_setup (priv->shell_installed, shell, priv->plugin_loader, priv->builder, priv->cancellable); priv->shell_moderate = GS_SHELL_MODERATE (gtk_builder_get_object (priv->builder, "shell_moderate")); gs_shell_moderate_setup (priv->shell_moderate, shell, priv->plugin_loader, priv->builder, priv->cancellable); priv->shell_search = GS_SHELL_SEARCH (gtk_builder_get_object (priv->builder, "shell_search")); gs_shell_search_setup (priv->shell_search, shell, priv->plugin_loader, priv->builder, priv->cancellable); priv->shell_details = GS_SHELL_DETAILS (gtk_builder_get_object (priv->builder, "shell_details")); gs_shell_details_setup (priv->shell_details, shell, priv->plugin_loader, priv->builder, priv->cancellable); priv->shell_category = GS_SHELL_CATEGORY (gtk_builder_get_object (priv->builder, "shell_category")); gs_shell_category_setup (priv->shell_category, shell, priv->plugin_loader, priv->builder, priv->cancellable); priv->shell_extras = GS_SHELL_EXTRAS (gtk_builder_get_object (priv->builder, "shell_extras")); gs_shell_extras_setup (priv->shell_extras, shell, priv->plugin_loader, priv->builder, priv->cancellable); /* set up search */ widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "entry_search")); g_signal_connect (GTK_EDITABLE (widget), "activate", G_CALLBACK (gs_shell_search_activated_cb), shell); g_signal_connect (priv->main_window, "key-press-event", G_CALLBACK (window_keypress_handler), shell); widget = GTK_WIDGET (gtk_builder_get_object (priv->builder, "entry_search")); g_signal_connect (widget, "key-press-event", G_CALLBACK (entry_keypress_handler), shell); g_signal_connect (widget, "search-changed", G_CALLBACK (search_changed_handler), shell); /* load content */ g_signal_connect (priv->shell_overview, "refreshed", G_CALLBACK (initial_overview_load_done), shell); }
static gboolean headerbarui_init () { GtkWindow *mainwin; GtkWidget *menubar; GtkWidget *menubtn_image; GtkBuilder *builder; mainwin = GTK_WINDOW (gtkui_plugin->get_mainwin ()); menubar = lookup_widget (GTK_WIDGET(mainwin), "menubar"); g_assert_nonnull(mainwin); g_assert_nonnull(menubar); builder = gtk_builder_new_from_resource("/org/deadbeef/headerbarui/headerbar.ui"); headerbar = gtk_builder_get_object(builder, "headerbar1"); volbutton = gtk_builder_get_object(builder, "volumebutton1"); headerbar_menubtn = gtk_builder_get_object(builder, "menubutton1"); headerbar_seekbar = gtk_builder_get_object(builder, "scale1"); headerbar_playbtn = gtk_builder_get_object(builder, "playbtn"); headerbar_pausebtn = gtk_builder_get_object(builder, "pausebtn"); gtk_widget_show(headerbar); gtk_window_set_titlebar(mainwin, GTK_WIDGET(headerbar)); if (!headerbarui_flag_embed_menubar) { GtkMenu *menu; gtk_widget_hide(menubar); headerbarui_update_menubutton(); gtk_widget_set_can_focus(headerbar_menubtn, FALSE); gtk_widget_show (headerbar_menubtn); } else { gtk_widget_destroy(headerbar_menubtn); gtk_widget_reparent(menubar, headerbar); } if (!headerbarui_flag_show_seek_bar) { gtk_widget_hide(headerbar_seekbar); } float volume = deadbeef->volume_get_min_db()-deadbeef->volume_get_db(); g_assert_false((volume>0)); gtk_scale_button_set_adjustment(GTK_SCALE_BUTTON (volbutton), gtk_adjustment_new (volume, 0, (int)-deadbeef->volume_get_min_db (), 5, 5, 0)); gtk_widget_show(volbutton); gtk_builder_add_callback_symbols(builder, "on_volbutton_value_changed", on_volbutton_value_changed, "on_nextbtn_clicked", on_nextbtn_clicked, "on_prevbtn_clicked", on_prevbtn_clicked, "on_pausebtn_clicked", on_pausebtn_clicked, "on_playbtn_clicked", on_playbtn_clicked, "on_stopbtn_clicked", on_stopbtn_clicked, "on_seekbar_format_value", on_seekbar_format_value, "on_seekbar_button_press_event", on_seekbar_button_press_event, "on_seekbar_button_release_event", on_seekbar_button_release_event, NULL); gtk_builder_connect_signals(builder, NULL); return FALSE; }
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; }
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); }
/* Gobj */ static void bjb_window_base_constructed (GObject *obj) { BjbWindowBase *self = BJB_WINDOW_BASE (obj); BjbWindowBasePriv *priv; gboolean maximized; const gint32 *position; const gint32 *size; gsize n_elements; GVariant *variant; G_OBJECT_CLASS (bjb_window_base_parent_class)->constructed (obj); priv = self->priv; priv->settings = bjb_app_get_settings ((gpointer) g_application_get_default ()); gtk_window_set_position (GTK_WINDOW (self),GTK_WIN_POS_CENTER); gtk_window_set_title (GTK_WINDOW (self), _(BIJIBEN_MAIN_WIN_TITLE)); variant = g_settings_get_value (G_SETTINGS (priv->settings), "window-size"); size = g_variant_get_fixed_array (variant, &n_elements, sizeof (gint32)); if (n_elements == 2) gtk_window_set_default_size (GTK_WINDOW (self), size[0], size[1]); g_variant_unref (variant); variant = g_settings_get_value (G_SETTINGS (priv->settings), "window-position"); position = g_variant_get_fixed_array (variant, &n_elements, sizeof (gint32)); if (n_elements == 2) gtk_window_move (GTK_WINDOW (self), position[0], position[1]); g_variant_unref (variant); maximized = g_settings_get_boolean (G_SETTINGS (priv->settings), "window-maximized"); if (maximized) gtk_window_maximize (GTK_WINDOW (self)); /* We probably want to offer a no entry window at first (startup) */ priv->entry = NULL ; priv->controller = bjb_controller_new (bijiben_get_manager (BIJIBEN_APPLICATION(g_application_get_default())), GTK_WINDOW (obj), priv->entry ); /* Shared toolbar */ priv->view = bjb_main_view_new (GTK_WIDGET (obj), priv->controller); priv->main_toolbar = bjb_main_toolbar_new (priv->view, priv->controller); gtk_window_set_titlebar (GTK_WINDOW (self), GTK_WIDGET (priv->main_toolbar)); /* Search entry toolbar */ priv->search_bar = bjb_search_toolbar_new (GTK_WIDGET (obj), priv->controller); gtk_box_pack_start (GTK_BOX (priv->vbox), GTK_WIDGET (priv->search_bar), FALSE, FALSE, 0); /* UI : stack for different views */ priv->stack = GTK_STACK (gtk_stack_new ()); gtk_box_pack_start (GTK_BOX (priv->vbox), GTK_WIDGET (priv->stack), TRUE, TRUE, 0); priv->spinner = gtk_spinner_new (); gtk_stack_add_named (priv->stack, priv->spinner, "spinner"); gtk_stack_set_visible_child_name (priv->stack, "spinner"); gtk_widget_show (priv->spinner); gtk_spinner_start (GTK_SPINNER (priv->spinner)); priv->no_note = bjb_empty_results_box_new (); gtk_stack_add_named (priv->stack, priv->no_note, "empty"); gtk_stack_add_named (priv->stack, GTK_WIDGET (priv->view), "main-view"); gtk_widget_show (GTK_WIDGET (priv->stack)); /* Connection to window signals */ g_signal_connect (GTK_WIDGET (self), "destroy", G_CALLBACK (bjb_window_base_destroy), self); g_signal_connect (self, "window-state-event", G_CALLBACK (bjb_application_window_state_changed), priv->settings); g_signal_connect (self, "configure-event", G_CALLBACK (bjb_application_window_configured), self); /* Keys */ g_signal_connect (GTK_WIDGET (self), "key-press-event", G_CALLBACK(on_key_pressed_cb), self); /* If a note is requested at creation, show it * This is a specific type of window not associated with any view */ if (priv->note == NULL) { bjb_window_base_switch_to (self, BJB_WINDOW_BASE_MAIN_VIEW); } else { priv->detached = TRUE; bjb_window_base_switch_to_item (self, BIJI_ITEM (priv->note)); } /* For some reason, do not gtk_widget_show _self_ * or gtk_application_get_menu_bar will run, * fire a warning, while app menu will not show up * you have been warned! * * This is probably due to the fact that, * at startup, we still are * inside... drums... gapplication startup () */ gtk_widget_show (priv->vbox); }
static void gb_shortcuts_dialog_init (GbShortcutsDialog *self) { GbShortcutsDialogPrivate *priv = gb_shortcuts_dialog_get_instance_private (self); GtkToggleButton *search_button; GtkScrolledWindow *scroller; GtkBox *main_box; GtkBox *menu_box; GtkBox *box; GtkArrow *arrow; GtkSearchEntry *entry; gtk_window_set_resizable (GTK_WINDOW (self), FALSE); priv->keywords = g_hash_table_new_full (NULL, NULL, NULL, g_free); priv->search_items_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL); priv->search_text_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); priv->search_image_group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL); priv->header_bar = g_object_new (GTK_TYPE_HEADER_BAR, "show-close-button", TRUE, "visible", TRUE, NULL); gtk_window_set_titlebar (GTK_WINDOW (self), GTK_WIDGET (priv->header_bar)); search_button = g_object_new (GTK_TYPE_TOGGLE_BUTTON, "child", g_object_new (GTK_TYPE_IMAGE, "visible", TRUE, "icon-name", "edit-find-symbolic", NULL), "visible", TRUE, NULL); gtk_container_add (GTK_CONTAINER (priv->header_bar), GTK_WIDGET (search_button)); main_box = g_object_new (GTK_TYPE_BOX, "orientation", GTK_ORIENTATION_VERTICAL, "visible", TRUE, NULL); gtk_container_add (GTK_CONTAINER (self), GTK_WIDGET (main_box)); priv->search_bar = g_object_new (EGG_TYPE_SEARCH_BAR, "visible", TRUE, NULL); g_object_bind_property (priv->search_bar, "search-mode-enabled", search_button, "active", G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL); gtk_container_add (GTK_CONTAINER (main_box), GTK_WIDGET (priv->search_bar)); priv->stack = g_object_new (GTK_TYPE_STACK, "expand", TRUE, "homogeneous", TRUE, "transition-type", GTK_STACK_TRANSITION_TYPE_CROSSFADE, "visible", TRUE, NULL); gtk_container_add (GTK_CONTAINER (main_box), GTK_WIDGET (priv->stack)); priv->menu_button = g_object_new (GTK_TYPE_MENU_BUTTON, "focus-on-click", FALSE, "visible", TRUE, NULL); gtk_style_context_add_class (gtk_widget_get_style_context (GTK_WIDGET (priv->menu_button)), "flat"); gtk_header_bar_set_custom_title (priv->header_bar, GTK_WIDGET (priv->menu_button)); menu_box = g_object_new (GTK_TYPE_BOX, "orientation", GTK_ORIENTATION_HORIZONTAL, "spacing", 6, "visible", TRUE, NULL); gtk_container_add (GTK_CONTAINER (priv->menu_button), GTK_WIDGET (menu_box)); priv->menu_label = g_object_new (GTK_TYPE_LABEL, "visible", TRUE, NULL); gtk_container_add (GTK_CONTAINER (menu_box), GTK_WIDGET (priv->menu_label)); G_GNUC_BEGIN_IGNORE_DEPRECATIONS; arrow = g_object_new (GTK_TYPE_ARROW, "arrow-type", GTK_ARROW_DOWN, "visible", TRUE, NULL); gtk_container_add (GTK_CONTAINER (menu_box), GTK_WIDGET (arrow)); G_GNUC_END_IGNORE_DEPRECATIONS; priv->popover = g_object_new (GTK_TYPE_POPOVER, "border-width", 6, "relative-to", priv->menu_button, "position", GTK_POS_BOTTOM, NULL); gtk_menu_button_set_popover (priv->menu_button, GTK_WIDGET (priv->popover)); scroller = g_object_new (GB_TYPE_SCROLLED_WINDOW, "min-content-width", 150, "max-content-width", 300, "min-content-height", 10, "max-content-height", 300, "shadow-type", GTK_SHADOW_IN, "visible", TRUE, NULL); gtk_container_add (GTK_CONTAINER (priv->popover), GTK_WIDGET (scroller)); priv->list_box = g_object_new (GTK_TYPE_LIST_BOX, "selection-mode", GTK_SELECTION_NONE, "visible", TRUE, NULL); g_signal_connect_object (priv->list_box, "row-activated", G_CALLBACK (gb_shortcuts_dialog__list_box__row_activated), self, G_CONNECT_SWAPPED); gtk_container_add (GTK_CONTAINER (scroller), GTK_WIDGET (priv->list_box)); entry = GTK_SEARCH_ENTRY (egg_search_bar_get_entry (priv->search_bar)); g_object_set (entry, "placeholder-text", _("Search Shortcuts"), "width-chars", 40, NULL); g_signal_connect_object (entry, "changed", G_CALLBACK (gb_shortcuts_dialog__entry__changed), self, G_CONNECT_SWAPPED); g_signal_connect_object (priv->stack, "notify::visible-child", G_CALLBACK (gb_shortcuts_dialog__stack__notify_visible_child), self, G_CONNECT_SWAPPED); scroller = g_object_new (GTK_TYPE_SCROLLED_WINDOW, "visible", TRUE, NULL); box = g_object_new (GTK_TYPE_BOX, "border-width", 24, "halign", GTK_ALIGN_CENTER, "spacing", 24, "orientation", GTK_ORIENTATION_VERTICAL, "visible", TRUE, NULL); gtk_container_add (GTK_CONTAINER (scroller), GTK_WIDGET (box)); gtk_stack_add_titled (priv->stack, GTK_WIDGET (scroller), "internal-search", _("Search Results")); priv->search_shortcuts = g_object_new (GTK_TYPE_BOX, "halign", GTK_ALIGN_CENTER, "spacing", 6, "orientation", GTK_ORIENTATION_VERTICAL, "visible", TRUE, NULL); gtk_container_add (GTK_CONTAINER (box), GTK_WIDGET (priv->search_shortcuts)); priv->search_gestures = g_object_new (GTK_TYPE_BOX, "halign", GTK_ALIGN_CENTER, "spacing", 6, "orientation", GTK_ORIENTATION_VERTICAL, "visible", TRUE, NULL); gtk_container_add (GTK_CONTAINER (box), GTK_WIDGET (priv->search_gestures)); }
MidiogreApp *midiogre_app_init(void) { MidiogreApp *app; GtkWidget *header; GtkWidget *separator; GtkWidget *scrolled; GtkWidget *label,*frame; GtkWidget *button; GtkBox *box; gint i; GError *err; /* Allocate app */ app = calloc(1, sizeof(MidiogreApp)); /* Setup window */ app->window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL)); gtk_window_set_default_size(GTK_WINDOW(app->window), 600, 400); g_signal_connect(app->window, "destroy", G_CALLBACK(gtk_widget_destroyed), NULL); g_signal_connect(app->window, "key-release-event", G_CALLBACK(key_event), NULL); gtk_window_set_icon(app->window,gdk_pixbuf_new_from_resource("/org/prozum/midiogre/midiogre_logo.png",&err)); /* Setup header bar */ header = gtk_header_bar_new(); gtk_header_bar_set_title (GTK_HEADER_BAR(header), "Midiogre"); gtk_window_set_titlebar(app->window, header); /* Setup close button */ button = gtk_button_new(); gtk_container_add (GTK_CONTAINER(button), gtk_image_new_from_resource("/org/prozum/midiogre/icons/window-close-symbolic.symbolic.png")); gtk_header_bar_pack_end(GTK_HEADER_BAR(header), button); g_signal_connect_swapped(button, "clicked", G_CALLBACK(gtk_main_quit), app->window); /* Add seperator */ separator = gtk_separator_new(GTK_ORIENTATION_VERTICAL); gtk_header_bar_pack_end(GTK_HEADER_BAR(header), separator); /* Setup folder button */ button = gtk_button_new(); gtk_container_add (GTK_CONTAINER(button), gtk_image_new_from_resource("/org/prozum/midiogre/icons/document-open-symbolic.symbolic.png")); gtk_header_bar_pack_end(GTK_HEADER_BAR(header), button); g_signal_connect_swapped(button, "clicked", G_CALLBACK(folder_chooser), app->window); /* Global horizontal box */ app->win_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0)); gtk_container_add(GTK_CONTAINER(app->window), GTK_WIDGET(app->win_box)); /* Scroll container for sidepanel */ scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(app->win_box, scrolled, FALSE, FALSE, 0); /* Sidepanel box */ app->panel_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 0)); gtk_container_add(GTK_CONTAINER (scrolled), GTK_WIDGET(app->panel_box)); gtk_container_set_border_width(GTK_CONTAINER(app->panel_box), 10); /* Frame with favorit info */ frame = gtk_frame_new("Favorite"); gtk_box_pack_start(app->panel_box, frame, FALSE, FALSE, 0); app->fav_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 0)); gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(app->fav_box)); /* Current favorite */ app->fav_title_label = GTK_LABEL(gtk_label_new("")); gtk_label_set_max_width_chars(app->fav_title_label, 20); gtk_label_set_width_chars(app->fav_title_label, 20); gtk_box_pack_start(app->fav_box, GTK_WIDGET(app->fav_title_label), FALSE, FALSE, 0); app->fav_artist_label = GTK_LABEL(gtk_label_new("No favorite selected!")); gtk_label_set_max_width_chars(app->fav_artist_label, 20); gtk_label_set_width_chars(app->fav_artist_label, 20); gtk_box_pack_start(app->fav_box, GTK_WIDGET(app->fav_artist_label), FALSE, FALSE, 0); app->fav_album_label = GTK_LABEL(gtk_label_new("")); gtk_label_set_max_width_chars(app->fav_album_label, 20); gtk_label_set_width_chars(app->fav_album_label, 20); gtk_box_pack_start(app->fav_box, GTK_WIDGET(app->fav_album_label), FALSE, FALSE, 0); /* Frame with search criteria widgets */ frame = gtk_frame_new("Search"); gtk_box_pack_start(app->panel_box, frame, FALSE, FALSE, 0); app->search_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 10)); gtk_container_set_border_width(GTK_CONTAINER(app->search_box), 10); gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(app->search_box)); /* Title entry */ frame = gtk_frame_new("Title"); gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0); box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0)); gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(box)); gtk_container_set_border_width(GTK_CONTAINER(box), 10); app->title_entry = GTK_ENTRY(gtk_entry_new()); gtk_box_pack_start(box, GTK_WIDGET(app->title_entry), TRUE, FALSE, 0); /* Artist entry */ frame = gtk_frame_new("Artist"); gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0); gtk_container_set_border_width(GTK_CONTAINER(box), 10); box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0)); gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(box)); gtk_container_set_border_width(GTK_CONTAINER(box), 10); app->artist_entry = GTK_ENTRY(gtk_entry_new()); gtk_box_pack_start(box, GTK_WIDGET(app->artist_entry), TRUE, FALSE, 0); /* Album entry */ frame = gtk_frame_new("Album"); gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0); box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0)); gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(box)); gtk_container_set_border_width(GTK_CONTAINER(box), 10); app->album_entry = GTK_ENTRY(gtk_entry_new()); gtk_box_pack_start(box, GTK_WIDGET(app->album_entry), TRUE, FALSE, 0); /* Instrument class buttons */ frame = gtk_frame_new("Instrument Classes"); gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0); app->instr_grid = GTK_GRID(gtk_grid_new()); #if GTK_MINOR_VERSION >= 12 gtk_widget_set_margin_start(GTK_WIDGET(app->instr_grid), 10); gtk_widget_set_margin_end(GTK_WIDGET(app->instr_grid), 10); #else gtk_widget_set_margin_left(GTK_WIDGET(app->instr_grid), 10); gtk_widget_set_margin_right(GTK_WIDGET(app->instr_grid), 10); #endif gtk_widget_set_margin_bottom(GTK_WIDGET(app->instr_grid), 10); gtk_widget_set_margin_top(GTK_WIDGET(app->instr_grid), 10); gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(app->instr_grid)); for (i = 0; i < INSTR_CLASSES; i++) { label = gtk_label_new(instrument_classes[i]); gtk_widget_set_halign(GTK_WIDGET(label), GTK_ALIGN_START); gtk_grid_attach(app->instr_grid, label, 1, i + 1, 1, 1); app->instr_buttons[i] = GTK_CHECK_BUTTON(gtk_check_button_new()); gtk_widget_set_halign(GTK_WIDGET(app->instr_buttons[i]), GTK_ALIGN_END); gtk_grid_attach(app->instr_grid, GTK_WIDGET(app->instr_buttons[i]), 2, i + 1, 1, 1); } /* Result spinbutton */ frame = gtk_frame_new("Max result"); gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0); box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0)); gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(box)); gtk_container_set_border_width(GTK_CONTAINER(box), 10); app->result_spinbutton = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(1, 100, 1)); gtk_spin_button_set_value(app->result_spinbutton, 25); gtk_box_pack_start(box, GTK_WIDGET(app->result_spinbutton), TRUE, TRUE, 0); /* Search button */ app->search_button = GTK_BUTTON(gtk_button_new_with_label("Search")); gtk_box_pack_start(app->search_box, GTK_WIDGET(app->search_button), FALSE, FALSE, 0); g_signal_connect_swapped(app->search_button, "clicked", G_CALLBACK(search_event), app); /* Songboxes notebook (Tabsview) */ app->song_notebook = GTK_NOTEBOOK(gtk_notebook_new()); gtk_widget_set_hexpand(GTK_WIDGET(app->song_notebook), TRUE); gtk_box_pack_start(app->win_box, GTK_WIDGET(app->song_notebook), TRUE, TRUE, 0); /* Add song boxes */ app->songboxes[SONGBOX_ALPHA] = songbox_new(app->song_notebook, "Alphabetical"); app->songboxes[SONGBOX_FPRNT] = songbox_new(app->song_notebook, "Fingerprint"); app->songboxes[SONGBOX_BEST] = songbox_new(app->song_notebook, "Best Match"); app->songboxes[SONGBOX_POP] = songbox_new(app->song_notebook, "Popularity"); app->songboxes[SONGBOX_NEW] = songbox_new(app->song_notebook, "Newest"); /* Show all widgets */ gtk_widget_show_all(GTK_WIDGET(app->window)); /* Allocate song queue */ app->songs[SONGBOX_ALPHA] = g_queue_new(); app->songs[SONGBOX_FPRNT] = g_queue_new(); app->songs[SONGBOX_BEST] = g_queue_new(); app->songs[SONGBOX_POP] = g_queue_new(); app->songs[SONGBOX_NEW] = g_queue_new(); return app; }
/*********************************************************************** 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); }
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(inspectedPage()->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); 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)); }