static void inner_auth_combo_changed_cb (GtkWidget *combo, gpointer user_data) { EAPMethod *parent = (EAPMethod *) user_data; EAPMethodPEAP *method = (EAPMethodPEAP *) parent; GtkWidget *vbox; EAPMethod *eap = NULL; GList *elt, *children; GtkTreeModel *model; GtkTreeIter iter; GtkWidget *eap_widget; vbox = GTK_WIDGET (gtk_builder_get_object (parent->builder, "eap_peap_inner_auth_vbox")); g_assert (vbox); /* Remove any previous wireless security widgets */ children = gtk_container_get_children (GTK_CONTAINER (vbox)); for (elt = children; elt; elt = g_list_next (elt)) gtk_container_remove (GTK_CONTAINER (vbox), GTK_WIDGET (elt->data)); model = gtk_combo_box_get_model (GTK_COMBO_BOX (combo)); gtk_combo_box_get_active_iter (GTK_COMBO_BOX (combo), &iter); gtk_tree_model_get (model, &iter, I_METHOD_COLUMN, &eap, -1); g_assert (eap); eap_widget = eap_method_get_widget (eap); g_assert (eap_widget); gtk_widget_unparent (eap_widget); if (method->size_group) eap_method_add_to_size_group (eap, method->size_group); gtk_container_add (GTK_CONTAINER (vbox), eap_widget); eap_method_unref (eap); wireless_security_changed_cb (combo, method->sec_parent); }
static void gtk_application_window_update_menubar (GtkApplicationWindow *window) { gboolean should_have_menubar; gboolean have_menubar; have_menubar = window->priv->menubar != NULL; should_have_menubar = window->priv->show_menubar && (g_menu_model_get_n_items (G_MENU_MODEL (window->priv->app_menu_section)) || g_menu_model_get_n_items (G_MENU_MODEL (window->priv->menubar_section))); if (have_menubar && !should_have_menubar) { gtk_widget_unparent (window->priv->menubar); window->priv->menubar = NULL; gtk_widget_queue_resize (GTK_WIDGET (window)); } if (!have_menubar && should_have_menubar) { GMenu *combined; combined = g_menu_new (); g_menu_append_section (combined, NULL, G_MENU_MODEL (window->priv->app_menu_section)); g_menu_append_section (combined, NULL, G_MENU_MODEL (window->priv->menubar_section)); window->priv->menubar = gtk_menu_bar_new_from_model (G_MENU_MODEL (combined)); gtk_widget_set_parent (window->priv->menubar, GTK_WIDGET (window)); gtk_widget_show_all (window->priv->menubar); g_object_unref (combined); gtk_widget_queue_resize (GTK_WIDGET (window)); } }
bool wxNotebook::InsertPage( size_t position, wxNotebookPage* win, const wxString& text, bool select, int imageId ) { wxCHECK_MSG( m_widget != NULL, false, wxT("invalid notebook") ); wxCHECK_MSG( win->GetParent() == this, false, wxT("Can't add a page whose parent is not the notebook!") ); wxCHECK_MSG( position <= GetPageCount(), false, wxT("invalid page index in wxNotebookPage::InsertPage()") ); // Hack Alert! (Part II): See above in wxNotebook::AddChildGTK // why this has to be done. gtk_widget_unparent(win->m_widget); if (m_themeEnabled) win->SetThemeEnabled(true); GtkNotebook *notebook = GTK_NOTEBOOK(m_widget); wxGtkNotebookPage* pageData = new wxGtkNotebookPage; m_pages.Insert(win, position); m_pagesData.Insert(position, pageData); // set the label image and text // this must be done before adding the page, as GetPageText // and GetPageImage will otherwise return wrong values in // the page-changed event that results from inserting the // first page. pageData->m_imageIndex = imageId; pageData->m_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1); gtk_container_set_border_width(GTK_CONTAINER(pageData->m_box), 2); pageData->m_image = NULL; if (imageId != -1) { if (HasImageList()) { const wxBitmap* bitmap = GetImageList()->GetBitmapPtr(imageId); pageData->m_image = gtk_image_new_from_pixbuf(bitmap->GetPixbuf()); gtk_box_pack_start(GTK_BOX(pageData->m_box), pageData->m_image, false, false, m_padding); } else { wxFAIL_MSG("invalid notebook imagelist"); } } /* set the label text */ pageData->m_label = gtk_label_new(wxGTK_CONV(wxStripMenuCodes(text))); gtk_box_pack_end(GTK_BOX(pageData->m_box), pageData->m_label, false, false, m_padding); gtk_widget_show_all(pageData->m_box); gtk_notebook_insert_page(notebook, win->m_widget, pageData->m_box, position); /* apply current style */ #ifdef __WXGTK3__ GTKApplyStyle(pageData->m_label, NULL); #else GtkRcStyle *style = GTKCreateWidgetStyle(); if ( style ) { gtk_widget_modify_style(pageData->m_label, style); g_object_unref(style); } #endif if (select && GetPageCount() > 1) { SetSelection( position ); } InvalidateBestSize(); return true; }
static void pkg_channel_page_init (PkgChannelPage *page) { PkgChannelPagePrivate *priv; gchar *path; GtkTreeViewColumn *column; GtkCellRenderer *cell; ENTRY; page->priv = G_TYPE_INSTANCE_GET_PRIVATE(page, PKG_TYPE_CHANNEL_PAGE, PkgChannelPagePrivate); priv = page->priv; #define EXTRACT_WIDGET(_n, _w) \ G_STMT_START { \ priv->_w = (gpointer)gtk_builder_get_object(priv->builder, _n); \ } G_STMT_END path = pkg_path_for_data("ui", "pkg-channel-page.ui", NULL); priv->builder = gtk_builder_new(); gtk_builder_add_from_file(priv->builder, path, NULL); g_free(path); EXTRACT_WIDGET("page-label", page_label); EXTRACT_WIDGET("channel-page", container); EXTRACT_WIDGET("target", target); EXTRACT_WIDGET("args", args); EXTRACT_WIDGET("working-dir", working_dir); EXTRACT_WIDGET("env", env); EXTRACT_WIDGET("pid", pid); EXTRACT_WIDGET("kill-pid", kill_pid); EXTRACT_WIDGET("exit-status", exit_status); EXTRACT_WIDGET("muted", muted); EXTRACT_WIDGET("sources", sources); gtk_widget_unparent(priv->container); gtk_container_add(GTK_CONTAINER(page), priv->container); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, _("ID")); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->sources), column); cell = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, cell, TRUE); gtk_tree_view_column_add_attribute(column, cell, "text", COLUMN_IDSTR); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, _("Plugin")); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->sources), column); cell = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, cell, TRUE); gtk_tree_view_column_add_attribute(column, cell, "text", COLUMN_PLUGIN); priv->model = gtk_list_store_new(3, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING); gtk_tree_view_set_model(GTK_TREE_VIEW(priv->sources), GTK_TREE_MODEL(priv->model)); EXIT; }
// part_browser_create // // Creates a new part browser. This is only called once per schematic window. GtkWidget * part_browser_create (SchematicView *schematic_view) { Browser *br; GtkBuilder *gui; GError *perror = NULL; char *msg; GtkWidget *w, *view; GtkCellRenderer *cell_text; GtkTreeViewColumn *cell_column; static GtkTargetEntry dnd_types[] = { { "x-application/oregano-part", 0, DRAG_PART_INFO } }; static int dnd_num_types = sizeof (dnd_types) / sizeof (dnd_types[0]); GtkTreePath *path; if ((gui = gtk_builder_new ()) == NULL) { oregano_error (_("Could not create part browser")); return NULL; } else gtk_builder_set_translation_domain (gui, NULL); br = g_new0 (Browser, 1); br->preview = NULL; br->schematic_view = schematic_view; br->hidden = FALSE; schematic_view_set_browser (schematic_view, br); if (gtk_builder_add_from_file (gui, OREGANO_UIDIR "/part-browser.ui", &perror) <= 0) { msg = perror->message; oregano_error_with_title (_("Could not create part browser"), msg); g_error_free (perror); return NULL; } view = GTK_WIDGET (gtk_builder_get_object (gui, "viewport1")); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (view), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW (view), 115); w = goo_canvas_new (); gtk_container_add (GTK_CONTAINER (view), GTK_WIDGET (w)); br->canvas = w; g_signal_connect (w, "realize", (GCallback) preview_realized, br); //gtk_widget_set_size_request (w, PREVIEW_WIDTH, // PREVIEW_HEIGHT + PREVIEW_TEXT_HEIGHT); goo_canvas_set_bounds (GOO_CANVAS (w), 0, 0, PREVIEW_WIDTH, (PREVIEW_HEIGHT + PREVIEW_TEXT_HEIGHT)); br->description = GOO_CANVAS_TEXT (goo_canvas_text_new ( goo_canvas_get_root_item (GOO_CANVAS (br->canvas)), "", 0.0, PREVIEW_HEIGHT - 9.0, 100.0, GOO_CANVAS_ANCHOR_NORTH_WEST, "font", "sans 9", NULL)); // Set up dnd. g_signal_connect (G_OBJECT (br->canvas), "drag_data_get", G_CALLBACK (drag_data_get), br); gtk_drag_source_set (br->canvas, GDK_BUTTON1_MASK | GDK_BUTTON3_MASK, dnd_types, dnd_num_types, GDK_ACTION_MOVE); br->filter_entry = GTK_ENTRY (gtk_builder_get_object (gui, "part_search")); g_signal_connect (G_OBJECT (br->filter_entry), "changed", G_CALLBACK (part_search_change), br); g_signal_connect (G_OBJECT (br->filter_entry), "activate", G_CALLBACK (part_search_activate), br); // Buttons. w = GTK_WIDGET (gtk_builder_get_object (gui, "place_button")); g_signal_connect (G_OBJECT (w), "clicked", G_CALLBACK (place_cmd), br); // Update the libraries option menu br->library = g_list_nth_data (oregano.libraries, 0); part_browser_setup_libs (br, gui); // Parts list. w = GTK_WIDGET (gtk_builder_get_object (gui, "parts_list")); br->list = w; // Create the List Model for TreeView, this is a Real model br->real_model = GTK_TREE_MODEL (gtk_list_store_new (1, G_TYPE_STRING)); cell_text = gtk_cell_renderer_text_new (); cell_column = gtk_tree_view_column_new_with_attributes ( "", cell_text, "text", 0, NULL); // Create the sort model for the items, this sort the real model br->sort_model = gtk_tree_model_sort_new_with_model ( GTK_TREE_MODEL (br->real_model)); gtk_tree_sortable_set_sort_column_id ( GTK_TREE_SORTABLE (br->sort_model), 0, GTK_SORT_ASCENDING); // Create the filter sorted model. This filter items based on user // request for fast item search br->filter_model = gtk_tree_model_filter_new (br->sort_model, NULL); gtk_tree_model_filter_set_visible_func ( GTK_TREE_MODEL_FILTER (br->filter_model), part_list_filter_func, br, NULL); // If we have TreeFilter use it, if not, just use sorting model only if (br->filter_model) gtk_tree_view_set_model (GTK_TREE_VIEW (w), br->filter_model); else gtk_tree_view_set_model (GTK_TREE_VIEW (w), br->sort_model); gtk_tree_view_append_column (GTK_TREE_VIEW (w), cell_column); update_list (br); // Set up TreeView dnd. g_signal_connect (G_OBJECT (w), "drag_data_get", G_CALLBACK (drag_data_get), br); gtk_drag_source_set (w, GDK_BUTTON1_MASK | GDK_BUTTON3_MASK, dnd_types, dnd_num_types, GDK_ACTION_MOVE); g_signal_connect (G_OBJECT (w), "cursor_changed", G_CALLBACK (select_row), br); g_signal_connect (G_OBJECT (w), "row_activated", G_CALLBACK (part_selected), br); br->viewport = GTK_WIDGET (gtk_builder_get_object (gui, "part_browser_vbox")); path = gtk_tree_path_new_first (); gtk_tree_view_set_cursor (GTK_TREE_VIEW (w), path, NULL, FALSE); gtk_tree_path_free (path); gtk_widget_unparent (br->viewport); return br->viewport; }
/// Sets up the tabs for the action cue static void stack_action_cue_set_tabs(StackCue *cue, GtkNotebook *notebook) { StackActionCue *acue = STACK_ACTION_CUE(cue); // Create the tab GtkWidget *label = gtk_label_new("Action"); // Load the UI GtkBuilder *builder = gtk_builder_new_from_file("StackActionCue.ui"); acue->builder = builder; acue->action_tab = GTK_WIDGET(gtk_builder_get_object(builder, "acpGrid")); // Set up callbacks gtk_builder_add_callback_symbol(builder, "acp_cue_changed", G_CALLBACK(acp_cue_changed)); gtk_builder_add_callback_symbol(builder, "acp_action_changed", G_CALLBACK(acp_action_changed)); // Connect the signals gtk_builder_connect_signals(builder, (gpointer)cue); // Add an extra reference to the action tab - we're about to remove it's // parent and we don't want it to get garbage collected g_object_ref(acue->action_tab); // The tab has a parent window in the UI file - unparent the tab container from it gtk_widget_unparent(acue->action_tab); // Append the tab (and show it, because it starts off hidden...) gtk_notebook_append_page(notebook, acue->action_tab, label); gtk_widget_show(acue->action_tab); // Set the values: cue StackCue *target_cue = stack_cue_get_by_uid(acue->target); if (target_cue) { char cue_number[32]; stack_cue_id_to_string(target_cue->id, cue_number, 32); // Build the string std::string button_text; button_text = std::string(cue_number) + ": " + std::string(target_cue->name); // Set the button text gtk_button_set_label(GTK_BUTTON(gtk_builder_get_object(builder, "acpCue")), button_text.c_str()); } // Update action option switch (acue->action) { case STACK_ACTION_CUE_PLAY: gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gtk_builder_get_object(builder, "acpActionTypePlay")), true); break; case STACK_ACTION_CUE_PAUSE: gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gtk_builder_get_object(builder, "acpActionTypePause")), true); break; case STACK_ACTION_CUE_STOP: gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(gtk_builder_get_object(builder, "acpActionTypeStop")), true); break; } }
static VALUE rg_unparent(VALUE self) { gtk_widget_unparent(_SELF(self)); return self; }
/** * pkg_sources_page_init: * @page: A #PkgSourcesPage. * * Initializes the newly created #PkgSourcesPage instance. * * Returns: None. * Side effects: None. */ static void pkg_sources_page_init (PkgSourcesPage *page) /* IN */ { PkgSourcesPagePrivate *priv; GtkTreeViewColumn *column; GtkCellRenderer *cell; gchar *path; ENTRY; page->priv = G_TYPE_INSTANCE_GET_PRIVATE(page, PKG_TYPE_SOURCES_PAGE, PkgSourcesPagePrivate); priv = page->priv; #define EXTRACT_WIDGET(_n, _f) \ priv->_f = GTK_WIDGET(gtk_builder_get_object(priv->builder, _n)) path = pkg_path_for_data("ui", "pkg-sources-page.ui", NULL); priv->builder = gtk_builder_new(); gtk_builder_add_from_file(priv->builder, path, NULL); g_free(path); EXTRACT_WIDGET("sources-page", container); EXTRACT_WIDGET("treeview", treeview); EXTRACT_WIDGET("add", add); EXTRACT_WIDGET("remove", remove); EXTRACT_WIDGET("combo", combo); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, _("ID")); cell = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, cell, TRUE); gtk_tree_view_column_add_attribute(column, cell, "text", 1); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->treeview), column); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, _("Type")); cell = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, cell, TRUE); gtk_tree_view_column_add_attribute(column, cell, "text", 2); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->treeview), column); priv->model = gtk_list_store_new(4, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); gtk_tree_view_set_model(GTK_TREE_VIEW(priv->treeview), GTK_TREE_MODEL(priv->model)); cell = gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(priv->combo), cell, TRUE); gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(priv->combo), cell, "text", 0); priv->types = gtk_list_store_new(1, G_TYPE_STRING); gtk_combo_box_set_model(GTK_COMBO_BOX(priv->combo), GTK_TREE_MODEL(priv->types)); g_signal_connect(priv->combo, "changed", G_CALLBACK(pkg_sources_page_combo_changed_cb), page); g_signal_connect(priv->add, "clicked", G_CALLBACK(pkg_sources_page_add_clicked_cb), page); g_signal_connect(priv->remove, "clicked", G_CALLBACK(pkg_sources_page_remove_clicked_cb), page); g_signal_connect(gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->treeview)), "changed", G_CALLBACK(pkg_sources_page_selection_changed_cb), page); gtk_widget_unparent(priv->container); gtk_container_add(GTK_CONTAINER(page), priv->container); EXIT; }
/** * gtk_ellipsis_set_label_widget: * @ellipsis: a #GtkEllipsis * @label: the new label widget * * Set the label widget for the ellipsis. This is the widget * that will appear embedded alongside the ellipsis arrow. * * Since: 2.4 **/ void gtk_ellipsis_set_label_widget (GtkEllipsis *ellipsis, GtkWidget *label) { GtkEllipsisPrivate *priv; g_return_if_fail (GTK_IS_ELLIPSIS (ellipsis)); g_return_if_fail (label == NULL || GTK_IS_WIDGET (label)); g_return_if_fail (label == NULL || label->parent == NULL); priv = ellipsis->priv; if (priv->label == label) return; if (priv->label) { gtk_widget_set_state (priv->label, GTK_STATE_NORMAL); gtk_widget_unparent (priv->label); } priv->label = label; if (label) { gfloat xalign, yalign; gtk_misc_get_alignment (>K_LABEL (label)->misc, &xalign, &yalign); gtk_misc_set_alignment (>K_LABEL (label)->misc, 0.0, yalign); gtk_widget_set_parent (label, GTK_WIDGET (ellipsis)); if (!priv->ellipsis_label) { GdkColor *link_color, active_bg_color; GtkWidget *child; PangoAttrList *attrs; PangoAttribute *uline; child = gtk_label_new ("..."); /* Change the foreground color for all states but selected. */ gtk_widget_style_get (GTK_WIDGET (child), "link-color", &link_color, NULL); if (!link_color) { GtkStyle *style = gtk_widget_get_style (child); active_bg_color = style->bg[GTK_STATE_SELECTED]; link_color = &active_bg_color; } gtk_widget_modify_fg (child, GTK_STATE_NORMAL, link_color); gtk_widget_modify_fg (child, GTK_STATE_ACTIVE, link_color); gtk_widget_modify_fg (child, GTK_STATE_PRELIGHT, link_color); if (link_color != &active_bg_color) gdk_color_free (link_color); /* Add an underline. */ attrs = gtk_label_get_attributes (GTK_LABEL (label)); attrs = attrs ? pango_attr_list_copy (attrs) : pango_attr_list_new (); uline = pango_attr_underline_new (PANGO_UNDERLINE_SINGLE); uline->start_index = 0; uline->end_index = G_MAXUINT; pango_attr_list_insert (attrs, uline); gtk_label_set_attributes (GTK_LABEL (child), attrs); pango_attr_list_unref (attrs); gtk_widget_show (child); gtk_widget_set_parent (child, GTK_WIDGET (ellipsis)); priv->ellipsis_label = child; } if (priv->prelight) { gtk_widget_set_state (label, GTK_STATE_PRELIGHT); gtk_widget_set_state (priv->ellipsis_label, GTK_STATE_PRELIGHT); } } else { if (priv->ellipsis_label) { gtk_widget_destroy (priv->ellipsis_label); priv->ellipsis_label = NULL; } } if (GTK_WIDGET_VISIBLE (ellipsis)) gtk_widget_queue_resize (GTK_WIDGET (ellipsis)); g_object_freeze_notify (G_OBJECT (ellipsis)); g_object_notify (G_OBJECT (ellipsis), "label-widget"); g_object_notify (G_OBJECT (ellipsis), "label"); g_object_thaw_notify (G_OBJECT (ellipsis)); }