static void assistant_instert_book_options_page (hierarchy_data *data) { GtkWidget *vbox = gtk_vbox_new (FALSE, 0); data->options = gnc_option_db_new_for_type (QOF_ID_BOOK); qof_book_load_options (gnc_get_current_book (), gnc_option_db_load, data->options); gnc_option_db_clean (data->options); data->optionwin = gnc_options_dialog_new_modal (TRUE, _("New Book Options")); gnc_options_dialog_build_contents_full (data->optionwin, data->options, FALSE); gnc_options_dialog_set_close_cb (data->optionwin, book_options_dialog_close_cb, (gpointer)data->options); gnc_options_dialog_set_new_book_option_values (data->options); gtk_widget_reparent (gnc_options_dialog_notebook (data->optionwin), vbox); gtk_widget_show_all (vbox); gtk_assistant_insert_page (GTK_ASSISTANT(data->dialog), vbox, 2); gtk_assistant_set_page_title (GTK_ASSISTANT(data->dialog), vbox, _("New Book Options")); gtk_assistant_set_page_complete (GTK_ASSISTANT(data->dialog), vbox, TRUE); }
static GObject * cc_keyboard_panel_constructor (GType gtype, guint n_properties, GObjectConstructParam *properties) { GObject *obj; CcKeyboardPanel *self; CcKeyboardPanelPrivate *priv; GtkWidget *widget; obj = G_OBJECT_CLASS (cc_keyboard_panel_parent_class)->constructor (gtype, n_properties, properties); self = CC_KEYBOARD_PANEL (obj); priv = self->priv; keyboard_general_init (CC_PANEL (self), priv->builder); keyboard_shortcuts_init (CC_PANEL (self), priv->builder); widget = (GtkWidget *) gtk_builder_get_object (priv->builder, "keyboard_notebook"); gtk_widget_reparent (widget, (GtkWidget *) self); return obj; }
void iupdrvReparent(Ihandle* ih) { GtkFixed* fixed = gtkGetFixedParent(ih); GtkWidget* widget = (GtkWidget*)iupAttribGet(ih, "_IUP_EXTRAPARENT"); if (!widget) widget = ih->handle; gtk_widget_reparent(widget, (GtkWidget*)fixed); }
static void carrick_list_drag_begin (GtkWidget *widget, GdkDragContext *context, CarrickList *list) { CarrickListPrivate *priv = list->priv; gint x, y; carrick_service_item_set_active (CARRICK_SERVICE_ITEM (widget), FALSE); /* save old place in list for drag-failures */ gtk_container_child_get (GTK_CONTAINER (priv->box), widget, "position", &priv->drag_position, NULL); priv->drop_position = priv->drag_position; /* remove widget from list and setup dnd popup window */ priv->drag_window = gtk_window_new (GTK_WINDOW_POPUP); gtk_widget_set_size_request (priv->drag_window, widget->allocation.width, widget->allocation.height); gtk_widget_get_pointer (widget, &x, &y); gtk_widget_reparent (widget, priv->drag_window); gtk_drag_set_icon_widget (context, priv->drag_window, x, y); }
// helper to create a dropdown menu item void wxToolBarTool::CreateDropDown() { gtk_tool_item_set_homogeneous(m_item, false); GtkWidget* box; GtkWidget* arrow; if (GetToolBar()->HasFlag(wxTB_LEFT | wxTB_RIGHT)) { box = gtk_vbox_new(false, 0); arrow = gtk_arrow_new(GTK_ARROW_RIGHT, GTK_SHADOW_NONE); } else { box = gtk_hbox_new(false, 0); arrow = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_NONE); } GtkWidget* tool_button = GTK_BIN(m_item)->child; gtk_widget_reparent(tool_button, box); GtkWidget* arrow_button = gtk_toggle_button_new(); gtk_button_set_relief(GTK_BUTTON(arrow_button), gtk_tool_item_get_relief_style(GTK_TOOL_ITEM(m_item))); gtk_container_add(GTK_CONTAINER(arrow_button), arrow); gtk_container_add(GTK_CONTAINER(box), arrow_button); gtk_widget_show_all(box); gtk_container_add(GTK_CONTAINER(m_item), box); g_signal_connect(arrow_button, "toggled", G_CALLBACK(arrow_toggled), this); g_signal_connect(arrow_button, "button_press_event", G_CALLBACK(arrow_button_press_event), this); }
void gMainWindow::embedMenuBar(GtkWidget *border) { if (menuBar) { // layout is automatically destroyed ? layout = GTK_FIXED(gtk_fixed_new()); g_object_ref(G_OBJECT(menuBar)); if (gtk_widget_get_parent(GTK_WIDGET(menuBar))) gtk_container_remove(GTK_CONTAINER(gtk_widget_get_parent(GTK_WIDGET(menuBar))), GTK_WIDGET(menuBar)); gtk_fixed_put(layout, GTK_WIDGET(menuBar), 0, 0); g_object_unref(G_OBJECT(menuBar)); gtk_widget_reparent(widget, GTK_WIDGET(layout)); gtk_container_add(GTK_CONTAINER(border), GTK_WIDGET(layout)); gtk_widget_show(GTK_WIDGET(menuBar)); gtk_widget_show(GTK_WIDGET(layout)); gtk_widget_show(GTK_WIDGET(widget)); gMenu::updateFont(this); gMenu::updateColor(this); checkMenuBar(); } }
void wxFrame::SetToolBar(wxToolBar *toolbar) { bool hadTbar = m_frameToolBar != NULL; wxFrameBase::SetToolBar(toolbar); if ( m_frameToolBar ) { // insert into toolbar area if not already there if ((m_frameToolBar->m_widget->parent) && (m_frameToolBar->m_widget->parent != m_mainWidget)) { GetChildren().DeleteObject( m_frameToolBar ); gtk_widget_reparent( m_frameToolBar->m_widget, m_mainWidget ); GtkUpdateSize(); } } else // toolbar unset { // still need to update size if it had been there before if ( hadTbar ) { GtkUpdateSize(); } } }
static void main_window_init (MainWindow *app) { GtkBuilder *builder; GError *error = NULL; GtkBox *main_window_outer_vbox; builder = gtk_builder_new(); if(!gtk_builder_add_from_file(builder, UI_FILE, &error)) { g_warning("%s", error->message); exit(1); } main_window_outer_vbox = GTK_BOX(gtk_builder_get_object(builder, "main_window_outer_vbox")); gtk_widget_reparent(GTK_WIDGET(main_window_outer_vbox), GTK_WIDGET(app)); ui->connect_dialog = GTK_WIDGET(gtk_builder_get_object(builder,"connect_dialog")); ui->connect_server_combobox_entry = GTK_ENTRY(gtk_builder_get_object(builder,"connect_server_combobox_entry")); ui->connect_username_combobox_entry = GTK_ENTRY(gtk_builder_get_object(builder,"connect_username_combobox_entry")); gtk_builder_connect_signals(builder, NULL); g_object_unref(G_OBJECT(builder)); gtk_widget_show(GTK_WIDGET(main_window_outer_vbox)); }
/** * go_combo_popup_reparent * @popup: Popup * @new_parent: New parent * @unrealize: Unrealize popup if TRUE. * * Reparent the popup, taking care of the refcounting * * Compare with gtk_menu_reparent in gtk/gtkmenu.c */ static void go_combo_popup_reparent (GtkWidget *popup, GtkWidget *new_parent, gboolean unrealize) { #if GLIB_CHECK_VERSION(2,10,0) && GTK_CHECK_VERSION(2,8,14) gboolean was_floating = g_object_is_floating (popup); g_object_ref_sink (popup); #else gboolean was_floating = GTK_OBJECT_FLOATING (popup); g_object_ref (popup); gtk_object_sink (GTK_OBJECT (popup)); #endif if (unrealize) { g_object_ref (popup); gtk_container_remove (GTK_CONTAINER (popup->parent), popup); gtk_container_add (GTK_CONTAINER (new_parent), popup); g_object_unref (popup); } else gtk_widget_reparent (GTK_WIDGET (popup), new_parent); gtk_widget_set_size_request (new_parent, -1, -1); if (was_floating) { #if GLIB_CHECK_VERSION(2,10,0) && GTK_CHECK_VERSION(2,8,14) g_object_force_floating (G_OBJECT (popup)); #else GTK_OBJECT_SET_FLAGS (GTK_OBJECT (popup), GTK_FLOATING); #endif } else g_object_unref (popup); }
static void set_xml_string(GelUIGeneric *self, const gchar *xml_string) { g_return_if_fail(GEL_UI_IS_GENERIC(self)); g_return_if_fail(xml_string != NULL); GelUIGenericPrivate *priv = self->priv; g_return_if_fail(priv->builder == NULL); priv->builder = gtk_builder_new(); GError *error = NULL; if (!gtk_builder_add_from_string(priv->builder, xml_string, -1, &error)) { g_warning(_("Cannot load UI from string: %s"), error->message); g_error_free(error); return; } GtkWidget *w = GTK_WIDGET(gtk_builder_get_object(priv->builder, "main-widget")); if (w == NULL) { g_warning(_("Cannot find widget 'main-widget' on UI")); return; } gtk_widget_reparent(w, (GtkWidget *) self); gtk_box_set_child_packing ((GtkBox *) self, w, TRUE, TRUE, 0, GTK_PACK_START); g_object_notify(G_OBJECT(self), "xml-string"); }
static void cc_region_panel_init (CcRegionPanel * self) { CcRegionPanelPrivate *priv; GtkWidget *prefs_widget; const char *desktop; GError *error = NULL; priv = self->priv = REGION_PANEL_PRIVATE (self); desktop = g_getenv ("XDG_CURRENT_DESKTOP"); priv->builder = gtk_builder_new (); gtk_builder_add_from_file (priv->builder, CINNAMONCC_UI_DIR "/cinnamon-region-panel.ui", &error); if (error != NULL) { g_warning ("Error loading UI file: %s", error->message); g_error_free (error); return; } prefs_widget = (GtkWidget *) gtk_builder_get_object (priv->builder, "vbox1"); gtk_widget_set_size_request (GTK_WIDGET (prefs_widget), -1, 400); gtk_widget_reparent (prefs_widget, GTK_WIDGET (self)); setup_xkb_tabs (priv->builder); }
// helper to create a dropdown menu item void wxToolBarTool::CreateDropDown() { gtk_tool_item_set_homogeneous(m_item, false); GtkOrientation orient = GTK_ORIENTATION_HORIZONTAL; GtkArrowType arrowType = GTK_ARROW_DOWN; if (GetToolBar()->HasFlag(wxTB_LEFT | wxTB_RIGHT)) { orient = GTK_ORIENTATION_VERTICAL; arrowType = GTK_ARROW_RIGHT; } GtkWidget* box = gtk_box_new(orient, 0); GtkWidget* arrow = gtk_arrow_new(arrowType, GTK_SHADOW_NONE); GtkWidget* tool_button = gtk_bin_get_child(GTK_BIN(m_item)); gtk_widget_reparent(tool_button, box); GtkWidget* arrow_button = gtk_toggle_button_new(); gtk_button_set_relief(GTK_BUTTON(arrow_button), gtk_tool_item_get_relief_style(GTK_TOOL_ITEM(m_item))); gtk_container_add(GTK_CONTAINER(arrow_button), arrow); gtk_container_add(GTK_CONTAINER(box), arrow_button); gtk_widget_show_all(box); gtk_container_add(GTK_CONTAINER(m_item), box); g_signal_connect(arrow_button, "toggled", G_CALLBACK(arrow_toggled), this); g_signal_connect(arrow_button, "button_press_event", G_CALLBACK(arrow_button_press_event), this); }
GtkWidget * mca_info_panel_init (MCAInfoPanel *g_ipnl, cmd_callback_t exec_ipnl_event, status_callback_t proc_status) { GtkWidget *panel, *event_box; ipnl = g_ipnl; ipnl->notify_timeout = 15; ipnl->wnd_exit = exit_wnd_create(ipnl); ipnl->wnd_help = help_wnd_create(ipnl); ipnl->event_cb = exec_ipnl_event; ipnl->status_cb = proc_status; //ipnl->tray_icon = init_status_icon(ipnl); ipnl->tray_icon = tray_icon_create(ipnl); ipnl->is_wnd_help_up = FALSE; ipnl->is_wnd_exit_up = FALSE; ipnl->is_wnd_panel_up = FALSE; panel = info_panel_internal_create(ipnl); /*if (!info_panel_menu_init(panel)){ g_print("Unable to init menu\n"); }*/ event_box = gtk_event_box_new (); //gtk_container_add (GTK_CONTAINER (event_box), image); /* g_signal_connect (G_OBJECT (event_box), "button_press_event", G_CALLBACK (info_panel_on_button_press), panel); */ gtk_widget_reparent(GTK_WIDGET(panel), GTK_WIDGET(event_box)); ipnl->wnd_ipnl = mca_info_panel_host(event_box); return event_box; }
void wxFrame::SetToolBar(wxToolBar *toolbar) { m_frameToolBar = toolbar; if (toolbar) { if (toolbar->IsVertical()) { // Vertical toolbar and m_wxwindow go into an hbox, inside the // vbox (m_mainWidget). hbox is created on demand. GtkWidget* hbox = gtk_widget_get_parent(m_wxwindow); if (!GTK_IS_HBOX(hbox)) { hbox = gtk_hbox_new(false, 0); gtk_widget_show(hbox); gtk_container_add(GTK_CONTAINER(m_mainWidget), hbox); gtk_widget_reparent(m_wxwindow, hbox); } gtk_widget_reparent(toolbar->m_widget, hbox); gtk_box_set_child_packing(GTK_BOX(hbox), toolbar->m_widget, false, false, 0, GTK_PACK_START); int pos = 0; // left if (toolbar->HasFlag(wxTB_RIGHT)) pos = 1; // right gtk_box_reorder_child(GTK_BOX(hbox), toolbar->m_widget, pos); } else { // Horizontal toolbar goes into vbox (m_mainWidget) gtk_widget_reparent(toolbar->m_widget, m_mainWidget); gtk_box_set_child_packing(GTK_BOX(m_mainWidget), toolbar->m_widget, false, false, 0, GTK_PACK_START); int pos = 0; // top if (m_frameMenuBar) pos = 1; // below menubar if (toolbar->HasFlag(wxTB_BOTTOM)) pos += 2; // below client area (m_wxwindow) gtk_box_reorder_child( GTK_BOX(m_mainWidget), toolbar->m_widget, pos); } // reset size request to allow native sizing to work gtk_widget_set_size_request(toolbar->m_widget, -1, -1); } // make sure next size_allocate causes a wxSizeEvent m_oldClientWidth = 0; }
static void cc_mouse_panel_init (CcMousePanel *self) { CcMousePanelPrivate *priv; GtkBuilder *dialog; GError *error = NULL; priv = self->priv = MOUSE_PANEL_PRIVATE (self); priv->builder = gtk_builder_new (); gtk_builder_add_from_file (priv->builder, CINNAMONCC_UI_DIR "/cinnamon-mouse-properties.ui", &error); if (error != NULL) { g_warning ("Error loading UI file: %s", error->message); return; } gtk_builder_add_from_file (priv->builder, CINNAMONCC_UI_DIR "/cinnamon-mouse-test.ui", &error); if (error != NULL) { g_warning ("Error loading UI file: %s", error->message); return; } dialog = priv->builder; priv->prefs_widget = gnome_mouse_properties_init (priv->builder); priv->test_widget = gnome_mouse_test_init (priv->builder); priv->widget = gtk_notebook_new (); gtk_notebook_set_show_tabs (GTK_NOTEBOOK (priv->widget), FALSE); gtk_notebook_set_show_border (GTK_NOTEBOOK (priv->widget), FALSE); gtk_widget_reparent (WID ("prefs_widget"), priv->widget); gtk_widget_reparent (WID ("test_widget"), priv->widget); gtk_container_add (GTK_CONTAINER (self), priv->widget); gtk_widget_show (priv->widget); g_idle_add (add_shell_test_button_cb, self); }
void EditorActionCreateNoteParagraph::redo (GtkWidget *& to_focus) { // Restore the live widget to the editor. gtk_widget_reparent (textview, parent_vbox); gtk_box_reorder_child (GTK_BOX(parent_vbox), textview, offset_at_delete); // Let the restored textview be earmarked to grab focus. to_focus = textview; }
void thunar_progress_dialog_add_job (ThunarProgressDialog *dialog, ThunarJob *job, const gchar *icon_name, const gchar *title) { GtkWidget *viewport; GtkWidget *view; _thunar_return_if_fail (THUNAR_IS_PROGRESS_DIALOG (dialog)); _thunar_return_if_fail (THUNAR_IS_JOB (job)); _thunar_return_if_fail (g_utf8_validate (title, -1, NULL)); view = thunar_progress_view_new_with_job (job); thunar_progress_view_set_icon_name (THUNAR_PROGRESS_VIEW (view), icon_name); thunar_progress_view_set_title (THUNAR_PROGRESS_VIEW (view), title); gtk_box_pack_start (GTK_BOX (dialog->content_box), view, FALSE, TRUE, 0); gtk_widget_show (view); /* use the first job's icon-name for the dialog */ if (dialog->views == NULL) gtk_window_set_icon_name (GTK_WINDOW (dialog), icon_name); /* add the view to the list of known views */ dialog->views = g_list_prepend (dialog->views, view); /* check if we need to wrap the views in a scroll window (starting * at SCROLLVIEW_THRESHOLD parallel operations */ if (g_list_length (dialog->views) == SCROLLVIEW_THRESHOLD) { /* create a scrolled window and add it to the dialog */ dialog->scrollwin = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (dialog->scrollwin), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_container_add (GTK_CONTAINER (dialog->vbox), dialog->scrollwin); gtk_widget_show (dialog->scrollwin); /* create a viewport for the content box */ viewport = gtk_viewport_new (gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (dialog->scrollwin)), gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (dialog->scrollwin))); gtk_viewport_set_shadow_type (GTK_VIEWPORT (viewport), GTK_SHADOW_NONE); gtk_container_add (GTK_CONTAINER (dialog->scrollwin), viewport); gtk_widget_show (viewport); /* move the content box into the viewport */ gtk_widget_reparent (dialog->content_box, viewport); } g_signal_connect_swapped (view, "need-attention", G_CALLBACK (thunar_progress_dialog_view_needs_attention), dialog); g_signal_connect_swapped (view, "finished", G_CALLBACK (thunar_progress_dialog_job_finished), dialog); if (dialog->status_icon != NULL) thunar_progress_dialog_update_status_icon (dialog); }
void part_browser_reparent (gpointer *br, GtkWidget *new_parent) { Browser *b; g_return_if_fail (br != NULL); b = (Browser *)br; gtk_widget_reparent (GTK_WIDGET (b->viewport), new_parent); }
static void connect_dialog_init (ConnectDialog *dialog) { gchar *path = locate_data_file ("connect-dialog.glade"); g_assert(path != NULL); GtkBuilder *xml = gtk_builder_new (); g_assert (gtk_builder_add_from_file ( xml, path, NULL) != 0); g_free (path); #define GW(name) ((dialog->name) = GTK_WIDGET (gtk_builder_get_object (xml, #name))) GW(toplevel); GW(server_list); #undef GW g_object_unref (xml); dialog->server_store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER); gtk_tree_view_set_model (GTK_TREE_VIEW (dialog->server_list), GTK_TREE_MODEL (dialog->server_store)); GtkCellRenderer *renderer = gtk_cell_renderer_text_new (); GtkTreeViewColumn *column = gtk_tree_view_column_new_with_attributes ("name", renderer, "text", 0, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->server_list), column); GtkWidget *button = gtk_button_new_with_mnemonic (_("C_onnect")); gtk_dialog_add_button (GTK_DIALOG (dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE); gtk_dialog_add_action_widget (GTK_DIALOG (dialog), button, GTK_RESPONSE_OK); gtk_container_set_border_width (GTK_CONTAINER (dialog), 6); GtkWidget *content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog)); gtk_widget_reparent (dialog->toplevel, content_area); g_signal_connect (G_OBJECT (dialog->server_list), "row-activated", G_CALLBACK (row_activated), dialog); g_signal_connect ( G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (dialog->server_list))), "changed", G_CALLBACK (selection_changed), dialog); for (GSList *netlist = network_list; netlist; netlist = g_slist_next (netlist)) { GtkTreeIter iter; ircnet *net = netlist->data; gtk_list_store_append (dialog->server_store, &iter); gtk_list_store_set (dialog->server_store, &iter, 0, net->name, 1, net, -1); } gtk_window_set_default_size (GTK_WINDOW (dialog), 320, 240); gtk_window_set_modal (GTK_WINDOW (dialog), TRUE); gtk_window_set_title (GTK_WINDOW (dialog), _("Connect")); gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog), GTK_RESPONSE_OK, FALSE); g_signal_connect (G_OBJECT (dialog), "response", G_CALLBACK (dialog_response), NULL); g_signal_connect (G_OBJECT (dialog), "key-press-event", G_CALLBACK (dialog_escape_key_handler_destroy), NULL); }
/*! * Set "toolbars detachable" setting. */ void EV_GnomeToolbar::setDetachable(gboolean detachable) { if (detachable && GTK_IS_TOOLBAR(gtk_bin_get_child(GTK_BIN(m_wHandleBox)))) { // not detachable -> detachable GtkWidget *box = gtk_handle_box_new(); gtk_handle_box_set_shadow_type(GTK_HANDLE_BOX(box), GTK_SHADOW_NONE); gtk_widget_reparent(m_wToolbar, box); gtk_container_add(GTK_CONTAINER(m_wHandleBox), box); if (!isHidden()) { gtk_widget_show(box); } } else if (!detachable && GTK_IS_HANDLE_BOX(gtk_bin_get_child(GTK_BIN(m_wHandleBox)))) { // detachable -> not detachable GtkWidget *box = gtk_bin_get_child(GTK_BIN(m_wHandleBox)); g_object_ref(G_OBJECT(box)); gtk_container_remove(GTK_CONTAINER(m_wHandleBox), box); gtk_widget_reparent(m_wToolbar, m_wHandleBox); g_object_unref(G_OBJECT(box)); } }
int clip_GTK_WIDGETREPARENT(ClipMachine * cm) { C_widget *cwid = _fetch_cw_arg(cm); C_widget *cpar = _fetch_cwidget(cm,_clip_spar(cm,2)); CHECKCWID(cwid,GTK_IS_WIDGET); CHECKARG2(2,MAP_t,NUMERIC_t); CHECKCWID(cwid,GTK_IS_WIDGET); gtk_widget_reparent(cwid->widget, cpar->widget); return 0; err: return 1; }
static void cc_notifications_panel_init (CcNotificationsPanel *panel) { GtkWidget *w; GError *error = NULL; g_resources_register (cc_notifications_get_resource ()); panel->known_applications = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, g_free); panel->builder = gtk_builder_new (); if (gtk_builder_add_from_resource (panel->builder, "/org/gnome/control-center/notifications/notifications.ui", &error) == 0) { g_error ("Error loading UI file: %s", error->message); g_error_free (error); return; } panel->master_settings = g_settings_new (MASTER_SCHEMA); g_settings_bind (panel->master_settings, "show-banners", gtk_builder_get_object (panel->builder, "ccnotify-switch-banners"), "active", G_SETTINGS_BIND_DEFAULT); g_settings_bind (panel->master_settings, "show-in-lock-screen", gtk_builder_get_object (panel->builder, "ccnotify-switch-lock-screen"), "active", G_SETTINGS_BIND_DEFAULT); panel->list_box = egg_list_box_new (); w = GTK_WIDGET (gtk_builder_get_object (panel->builder, "ccnotify-app-scrolledwindow")); egg_list_box_add_to_scrolled (panel->list_box, GTK_SCROLLED_WINDOW (w)); egg_list_box_set_selection_mode (panel->list_box, GTK_SELECTION_NONE); egg_list_box_set_sort_func (panel->list_box, sort_apps, NULL, NULL); egg_list_box_set_separator_funcs (panel->list_box, update_separator_func, NULL, NULL); g_signal_connect (panel->list_box, "child-activated", G_CALLBACK (select_app), panel); gtk_widget_set_visible (GTK_WIDGET (panel->list_box), TRUE); build_app_store (panel); w = GTK_WIDGET (gtk_builder_get_object (panel->builder, "ccnotify-main-grid")); gtk_widget_reparent (w, GTK_WIDGET (panel)); gtk_widget_show (w); }
void EditorActionDeleteParagraph::undo (GtkWidget *& to_focus) { // Restore the live widget to the editor. GtkWidget * widget_to_restore = paragraph->textview; if (paragraph->type == eatCreateNoteParagraph) { EditorActionCreateNoteParagraph * note_paragraph = static_cast <EditorActionCreateNoteParagraph *> (paragraph); widget_to_restore = note_paragraph->hbox; } gtk_widget_reparent (widget_to_restore, paragraph->parent_vbox); gtk_box_reorder_child (GTK_BOX(paragraph->parent_vbox), widget_to_restore, offset); // Let the restored textview be earmarked to grab focus. to_focus = paragraph->textview; }
static void gtk_widget_reparent_(GtkWidget* dst, GtkWidget* src) { GtkWidget *child = gtk_widget_get_child_(src); #if 1 gtk_widget_reparent(child, dst); #else g_object_ref(child); gtk_container_remove(GTK_CONTAINER(src), child); gtk_container_add(GTK_CONTAINER(dst), child); g_object_unref(child); #endif }
void tmp_circumvent_delete_event (GtkWidget *widget, gpointer user_data) { GtkWidget *box = g_object_get_data (G_OBJECT (widget), "data_box"); GtkWidget *parent = g_object_get_data (G_OBJECT (widget), "data_parent"); gboolean *flag = g_object_get_data (G_OBJECT (widget), "data_flag"); GtkWidget *window = gtk_widget_get_parent(box); gtk_widget_reparent(box, parent); gtk_widget_destroy(window); *flag = !(*flag); }
GtkWidget *gui_detach_box_from_parent (GtkWidget *box, GtkWidget *parent, gboolean *flag, gchar *window_title, gint x, gint y) { /* * This function detaches the box from its parent. If the flag=FALSE, than * it creates a new window and packs the box inside the window, otherwise * it packs the box in its original place inside the main window. */ GtkWidget *window; gchar *glade_pixmap_file = g_build_filename (PHOEBE_GLADE_PIXMAP_DIR, "ico.png", NULL); if(*flag){ window = gtk_widget_get_parent (box); gtk_widget_reparent(box, parent); gtk_widget_destroy(window); gui_status("%s reatached.", window_title); } else{ window = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_object_set_data (G_OBJECT (window), "data_box", (gpointer) box); g_object_set_data (G_OBJECT (window), "data_parent", (gpointer) parent); g_object_set_data (G_OBJECT (window), "data_flag", (gpointer) flag); gtk_window_set_icon (GTK_WINDOW(window), gdk_pixbuf_new_from_file(glade_pixmap_file, NULL)); gtk_window_set_title (GTK_WINDOW (window), window_title); gtk_widget_reparent(box, window); gtk_widget_set_size_request (window, x, y); gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); g_signal_connect (GTK_WIDGET(window), "delete-event", G_CALLBACK (tmp_circumvent_delete_event), NULL); gtk_widget_show_all (window); gui_status("%s detached.", window_title); } *flag = !(*flag); return window; }
static void thunar_progress_dialog_job_finished (ThunarProgressDialog *dialog, ThunarProgressView *view) { guint n_views; _thunar_return_if_fail (THUNAR_IS_PROGRESS_DIALOG (dialog)); _thunar_return_if_fail (THUNAR_IS_PROGRESS_VIEW (view)); /* remove the view from the list */ dialog->views = g_list_remove (dialog->views, view); /* destroy the widget */ gtk_widget_destroy (GTK_WIDGET (view)); /* determine the number of views left */ n_views = g_list_length (dialog->views); /* check if we've just removed the 4th view and are now left with * SCROLLVIEW_THRESHOLD-1 of them, in which case we drop the scroll window */ if (n_views == SCROLLVIEW_THRESHOLD-1) { /* reparent the content box */ gtk_widget_reparent (dialog->content_box, dialog->vbox); /* destroy the scroll win */ gtk_widget_destroy (dialog->scrollwin); } /* check if we have less than SCROLLVIEW_THRESHOLD views * and need to shrink the window */ if (n_views < SCROLLVIEW_THRESHOLD) { /* try to shrink the window */ gtk_window_resize (GTK_WINDOW (dialog), 450, 10); } /* check if we still have at least one view */ if (dialog->views != NULL) { /* update the status icon */ if (dialog->status_icon != NULL) thunar_progress_dialog_update_status_icon (dialog); } else { /* destroy the dialog as there are no views left */ gtk_widget_destroy (GTK_WIDGET (dialog)); } }
void destroy_page_window (GtkWidget *window, gpointer data) { WidgetPageData *pageData = (WidgetPageData *)data; window = window; /* Put widget back into a page */ gtk_widget_reparent (pageData->widget, pageData->parent); /* Select it */ gtk_notebook_set_current_page (GTK_NOTEBOOK(notebook), pageData->pageNo); /* Free return data */ g_free (data); }
static void security_combo_changed (GtkWidget *combo, gpointer user_data) { NMAWirelessDialog *self = NMA_WIRELESS_DIALOG (user_data); NMAWirelessDialogPrivate *priv = NMA_WIRELESS_DIALOG_GET_PRIVATE (self); GtkWidget *vbox; GList *elt, *children; GtkTreeIter iter; GtkTreeModel *model; WirelessSecurity *sec = NULL; GtkWidget *sec_widget; vbox = GTK_WIDGET (gtk_builder_get_object (priv->builder, "security_vbox")); g_assert (vbox); size_group_clear (priv->group); /* 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)); if (!gtk_combo_box_get_active_iter (GTK_COMBO_BOX (combo), &iter)) { g_warning ("%s: no active security combo box item.", __func__); return; } gtk_tree_model_get (model, &iter, S_SEC_COLUMN, &sec, -1); if (!sec) return; sec_widget = wireless_security_get_widget (sec); g_assert (sec_widget); size_group_add_permanent (priv->group, priv->builder); wireless_security_add_to_size_group (sec, priv->group); if (gtk_widget_get_parent (sec_widget)) gtk_widget_reparent (sec_widget, vbox); else gtk_container_add (GTK_CONTAINER (vbox), sec_widget); wireless_security_unref (sec); /* Re-validate */ wireless_security_changed_cb (NULL, sec); }
void GtkAReViWidget::dock(void) { if (isDocked()) return; if (isDockable()) { gtk_widget_reparent(_wndDockSrc, _dockDst->accessWidget(_dockDstWidget)); hide(); _docked=true; } else if (!GTK_IS_WIDGET(_wndDockSrc)) _wndDockSrc=NULL; }