C++ gtk_widget_reparent函数代码示例

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