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));
}
