static void
hildon_vvolumebar_init (HildonVVolumebar *vvolumebar)
{
HildonVolumebarPrivate *priv;
priv = HILDON_VOLUMEBAR_GET_PRIVATE (vvolumebar);
g_assert (priv);
priv->volumebar = HILDON_VOLUMEBAR_RANGE (hildon_volumebar_range_new
(GTK_ORIENTATION_VERTICAL));
gtk_widget_set_parent (GTK_WIDGET (priv->tbutton), GTK_WIDGET (vvolumebar));
gtk_widget_set_parent (GTK_WIDGET (priv->volumebar), GTK_WIDGET (vvolumebar));
gtk_scale_set_draw_value (GTK_SCALE (priv->volumebar), FALSE);
/* Signals */
g_signal_connect_swapped(G_OBJECT(priv->volumebar), "value-changed",
G_CALLBACK(hildon_volumebar_level_change),
vvolumebar);
g_signal_connect_swapped(priv->tbutton, "toggled",
G_CALLBACK(hildon_volumebar_mute_toggled), vvolumebar);
/* FIXME Not sure why this is here */
gtk_widget_show (GTK_WIDGET (priv->volumebar));
}
static void
gdl_dock_item_grip_instance_init (GdlDockItemGrip *grip)
{
GtkWidget *image;
GTK_WIDGET_SET_FLAGS (grip, GTK_NO_WINDOW);
grip->_priv = g_new0 (GdlDockItemGripPrivate, 1);
grip->_priv->icon_pixbuf_valid = FALSE;
grip->_priv->icon_pixbuf = NULL;
grip->_priv->title_layout = NULL;
gtk_widget_push_composite_child ();
grip->_priv->close_button = gtk_button_new ();
gtk_widget_pop_composite_child ();
GTK_WIDGET_UNSET_FLAGS (grip->_priv->close_button, GTK_CAN_FOCUS);
gtk_widget_set_parent (grip->_priv->close_button, GTK_WIDGET (grip));
gtk_button_set_relief (GTK_BUTTON (grip->_priv->close_button), GTK_RELIEF_NONE);
gtk_widget_show (grip->_priv->close_button);
image = gtk_image_new_from_stock (GDL_STOCK_CLOSE, GTK_ICON_SIZE_MENU);
gtk_container_add (GTK_CONTAINER (grip->_priv->close_button), image);
gtk_widget_show (image);
g_signal_connect (G_OBJECT (grip->_priv->close_button), "clicked",
G_CALLBACK (gdl_dock_item_grip_close_clicked), grip);
gtk_widget_push_composite_child ();
grip->_priv->iconify_button = gtk_button_new ();
gtk_widget_pop_composite_child ();
GTK_WIDGET_UNSET_FLAGS (grip->_priv->iconify_button, GTK_CAN_FOCUS);
gtk_widget_set_parent (grip->_priv->iconify_button, GTK_WIDGET (grip));
gtk_button_set_relief (GTK_BUTTON (grip->_priv->iconify_button), GTK_RELIEF_NONE);
gtk_widget_show (grip->_priv->iconify_button);
image = gtk_image_new_from_stock (GDL_STOCK_MENU_RIGHT, GTK_ICON_SIZE_MENU);
gtk_container_add (GTK_CONTAINER (grip->_priv->iconify_button), image);
gtk_widget_show (image);
g_signal_connect (G_OBJECT (grip->_priv->iconify_button), "clicked",
G_CALLBACK (gdl_dock_item_grip_iconify_clicked), grip);
grip->_priv->tooltips = gtk_tooltips_new ();
g_object_ref (grip->_priv->tooltips);
gtk_object_sink (GTK_OBJECT (grip->_priv->tooltips));
gtk_tooltips_set_tip (grip->_priv->tooltips, grip->_priv->iconify_button,
_("Iconify"), _("Iconify this dock"));
gtk_tooltips_set_tip (grip->_priv->tooltips, grip->_priv->close_button,
_("Close"), _("Close this dock"));
}
static GObject *
hildon_home_window_constructor (GType gtype,
guint n_params,
GObjectConstructParam *params)
{
GObject *retval;
HildonHomeWindow *window;
HildonHomeWindowPrivate *priv;
GtkWidget *widget;
retval =
G_OBJECT_CLASS (hildon_home_window_parent_class)->constructor (gtype,
n_params,
params);
widget = GTK_WIDGET (retval);
window = HILDON_HOME_WINDOW (retval);
priv = window->priv;
gtk_widget_push_composite_child ();
priv->titlebar = hildon_home_titlebar_new ();
g_object_ref (priv->titlebar);
gtk_object_sink (GTK_OBJECT (priv->titlebar));
gtk_widget_set_parent (priv->titlebar, widget);
gtk_widget_show (priv->titlebar);
gtk_widget_pop_composite_child ();
return retval;
}
GimpOverlayChild *
gimp_overlay_child_new (GimpOverlayBox *box,
GtkWidget *widget,
gdouble xalign,
gdouble yalign,
gdouble angle,
gdouble opacity)
{
GimpOverlayChild *child;
g_return_val_if_fail (GIMP_IS_OVERLAY_BOX (box), NULL);
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
child = g_slice_new0 (GimpOverlayChild);
child->widget = widget;
child->xalign = CLAMP (xalign, 0.0, 1.0);
child->yalign = CLAMP (yalign, 0.0, 1.0);
child->x = 0.0;
child->y = 0.0;
child->has_position = FALSE;
child->angle = angle;
child->opacity = CLAMP (opacity, 0.0, 1.0);
cairo_matrix_init_identity (&child->matrix);
if (gtk_widget_get_realized (GTK_WIDGET (box)))
gimp_overlay_child_realize (box, child);
gtk_widget_set_parent (widget, GTK_WIDGET (box));
return child;
}
void columns_add(Columns *cols, GtkWidget *child,
gint colstart, gint colspan)
{
ColumnsChild *childdata;
g_return_if_fail(cols != NULL);
g_return_if_fail(IS_COLUMNS(cols));
g_return_if_fail(child != NULL);
g_return_if_fail(child->parent == NULL);
childdata = g_new(ColumnsChild, 1);
childdata->widget = child;
childdata->colstart = colstart;
childdata->colspan = colspan;
childdata->force_left = FALSE;
cols->children = g_list_append(cols->children, childdata);
cols->taborder = g_list_append(cols->taborder, child);
gtk_widget_set_parent(child, GTK_WIDGET(cols));
if (GTK_WIDGET_REALIZED(cols))
gtk_widget_realize(child);
if (GTK_WIDGET_VISIBLE(cols) && GTK_WIDGET_VISIBLE(child)) {
if (GTK_WIDGET_MAPPED(cols))
gtk_widget_map(child);
gtk_widget_queue_resize(child);
}
}
/**
* gtk_image_menu_item_set_image:
* @image_menu_item: a #GtkImageMenuItem.
* @image: (allow-none): a widget to set as the image for the menu item.
*
* Sets the image of @image_menu_item to the given widget.
* Note that it depends on the show-menu-images setting whether
* the image will be displayed or not.
*
* Deprecated: 3.10
*/
void
gtk_image_menu_item_set_image (GtkImageMenuItem *image_menu_item,
GtkWidget *image)
{
GtkImageMenuItemPrivate *priv;
g_return_if_fail (GTK_IS_IMAGE_MENU_ITEM (image_menu_item));
priv = image_menu_item->priv;
if (image == priv->image)
return;
if (priv->image)
gtk_container_remove (GTK_CONTAINER (image_menu_item),
priv->image);
priv->image = image;
if (image == NULL)
return;
gtk_widget_set_parent (image, GTK_WIDGET (image_menu_item));
g_object_set (image,
"visible", show_image (image_menu_item),
"no-show-all", TRUE,
NULL);
gtk_image_set_pixel_size (GTK_IMAGE (image), 16);
g_object_notify (G_OBJECT (image_menu_item), "image");
}
static void
cb_reply_indicator_init (CbReplyIndicator *self)
{
GtkWidget *box;
GtkWidget *w;
gtk_widget_set_has_surface (GTK_WIDGET (self), FALSE);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
w = gtk_image_new_from_icon_name ("go-up-symbolic");
gtk_widget_set_hexpand (w, TRUE);
gtk_widget_set_halign (w, GTK_ALIGN_END);
gtk_container_add (GTK_CONTAINER (box), w);
gtk_container_add (GTK_CONTAINER (box), gtk_label_new (_("Show Conversation")));
w = gtk_image_new_from_icon_name ("go-up-symbolic");
gtk_widget_set_hexpand (w, TRUE);
gtk_widget_set_halign (w, GTK_ALIGN_START);
gtk_container_add (GTK_CONTAINER (box), w);
gtk_style_context_add_class (gtk_widget_get_style_context (box), "dim-label");
self->button = gtk_button_new ();
gtk_container_add (GTK_CONTAINER (self->button), box);
self->revealer = gtk_revealer_new ();
gtk_container_add (GTK_CONTAINER (self->revealer), self->button);
gtk_widget_set_parent (self->revealer, GTK_WIDGET (self));
g_signal_connect (self->button, "clicked", G_CALLBACK (button_clicked_cb), self);
}
void
gtk_pizza_put (GtkPizza *pizza,
GtkWidget *widget,
gint x,
gint y,
gint width,
gint height)
{
GtkPizzaChild *child_info;
g_return_if_fail (pizza != NULL);
g_return_if_fail (GTK_IS_PIZZA (pizza));
g_return_if_fail (widget != NULL);
child_info = g_new (GtkPizzaChild, 1);
child_info->widget = widget;
child_info->x = x;
child_info->y = y;
child_info->width = width;
child_info->height = height;
pizza->children = g_list_append (pizza->children, child_info);
if (GTK_WIDGET_REALIZED (pizza))
gtk_widget_set_parent_window (widget, pizza->bin_window);
gtk_widget_set_parent (widget, GTK_WIDGET (pizza));
if (!IS_ONSCREEN (x, y))
GTK_PRIVATE_SET_FLAG (widget, GTK_IS_OFFSCREEN);
gtk_widget_set_usize (widget, width, height);
}
void columns_add(Columns *cols, GtkWidget *child, gint colstart, gint colspan)
{
ColumnsChild *childdata;
g_return_if_fail(cols != NULL);
g_return_if_fail(IS_COLUMNS(cols));
g_return_if_fail(child != NULL);
g_return_if_fail(gtk_widget_get_parent(child) == NULL);
childdata = g_new(ColumnsChild, 1);
childdata->widget = child;
childdata->colstart = colstart;
childdata->colspan = colspan;
childdata->force_left = FALSE;
childdata->same_height_as = NULL;
cols->children = g_list_append(cols->children, childdata);
cols->taborder = g_list_append(cols->taborder, child);
gtk_widget_set_parent(child, GTK_WIDGET(cols));
#if GTK_CHECK_VERSION(2, 0, 0)
gtk_container_set_focus_chain(GTK_CONTAINER(cols), cols->taborder);
#endif
if (gtk_widget_get_realized(GTK_WIDGET(cols)))
gtk_widget_realize(child);
if (gtk_widget_get_visible(GTK_WIDGET(cols)) &&
gtk_widget_get_visible(child)) {
if (gtk_widget_get_mapped(GTK_WIDGET(cols)))
gtk_widget_map(child);
gtk_widget_queue_resize(child);
}
}
static void
gcal_month_view_add (GtkContainer *container,
GtkWidget *widget)
{
GcalMonthViewPrivate *priv;
GList *l;
gint day;
icaltimetype *date;
g_return_if_fail (GCAL_IS_MONTH_VIEW (container));
g_return_if_fail (GCAL_IS_EVENT_WIDGET (widget));
g_return_if_fail (gtk_widget_get_parent (widget) == NULL);
priv = GCAL_MONTH_VIEW (container)->priv;
/* Check if it's already added for date */
date = gcal_event_widget_get_date (GCAL_EVENT_WIDGET (widget));
day = date->day + ( - priv->days_delay);
g_free (date);
for (l = priv->days[day]; l != NULL; l = l->next)
{
if (g_strcmp0 (
gcal_event_widget_peek_uuid (GCAL_EVENT_WIDGET (widget)),
gcal_event_widget_peek_uuid (GCAL_EVENT_WIDGET (l->data))) == 0)
{
g_warning ("Trying to add an event with the same uuid to the view");
return;
}
}
priv->days[day] = g_list_append (priv->days[day], widget);
gtk_widget_set_parent (widget, GTK_WIDGET (container));
}
static GObject *
gimp_message_box_constructor (GType type,
guint n_params,
GObjectConstructParam *params)
{
GObject *object;
GimpMessageBox *box;
object = G_OBJECT_CLASS (parent_class)->constructor (type, n_params, params);
box = GIMP_MESSAGE_BOX (object);
if (box->stock_id)
{
gtk_widget_push_composite_child ();
box->image = gtk_image_new_from_stock (box->stock_id,
GTK_ICON_SIZE_DIALOG);
gtk_widget_pop_composite_child ();
gtk_misc_set_alignment (GTK_MISC (box->image), 0.0, 0.0);
gtk_widget_set_parent (box->image, GTK_WIDGET (box));
gtk_widget_show (box->image);
}
return object;
}
static void
exo_wrap_table_add (GtkContainer *container,
GtkWidget *widget)
{
ExoWrapTable *table = EXO_WRAP_TABLE (container);
/* take over ownership */
gtk_widget_set_parent (widget, GTK_WIDGET (table));
/* add the child to our internal list */
table->priv->children = g_list_append (table->priv->children, widget);
/* realize the widget if required */
if (gtk_widget_get_realized (GTK_WIDGET (container)))
gtk_widget_realize (widget);
/* map the widget if required */
if (gtk_widget_get_visible (GTK_WIDGET (container)) && gtk_widget_get_visible (widget))
{
if (gtk_widget_get_mapped (GTK_WIDGET (container)))
gtk_widget_map (widget);
}
/* queue a resize on the table */
gtk_widget_queue_resize (GTK_WIDGET (container));
}
static void
widget_overlay_add (GtkContainer *container, GtkWidget *widget)
{
WidgetOverlay *ovl = WIDGET_OVERLAY (container);
ChildData *cd;
cd = g_new0 (ChildData, 1);
gtk_widget_set_parent (widget, GTK_WIDGET (ovl));
cd->ovl = ovl;
cd->child = widget;
cd->halign = WIDGET_OVERLAY_ALIGN_CENTER;
cd->valign = WIDGET_OVERLAY_ALIGN_END;
cd->alpha = 1.;
cd->scale = 1.;
cd->ignore_events = FALSE;
cd->is_tooltip = FALSE;
ovl->priv->children = g_list_append (ovl->priv->children, cd);
if (ovl->priv->scale_child) {
ChildData *fcd;
fcd = get_first_child (ovl);
if (cd == fcd)
gtk_range_set_value (ovl->priv->scale_range, cd->scale);
ovl->priv->children = g_list_remove (ovl->priv->children, ovl->priv->scale_child);
ovl->priv->children = g_list_append (ovl->priv->children, ovl->priv->scale_child);
}
}
/**
* gtk_layout_put:
* @layout: a #GtkLayout
* @child_widget: child widget
* @x: X position of child widget
* @y: Y position of child widget
*
* Adds @child_widget to @layout, at position (@x,@y).
* @layout becomes the new parent container of @child_widget.
*
**/
void
gtk_layout_put (GtkLayout *layout,
GtkWidget *child_widget,
gint x,
gint y)
{
GtkLayoutPrivate *priv;
GtkLayoutChild *child;
g_return_if_fail (GTK_IS_LAYOUT (layout));
g_return_if_fail (GTK_IS_WIDGET (child_widget));
priv = layout->priv;
child = g_new (GtkLayoutChild, 1);
child->widget = child_widget;
child->x = x;
child->y = y;
priv->children = g_list_append (priv->children, child);
if (gtk_widget_get_realized (GTK_WIDGET (layout)))
gtk_widget_set_parent_window (child->widget, priv->bin_window);
gtk_widget_set_parent (child_widget, GTK_WIDGET (layout));
}
static void
awt_gtk_panel_add (GtkContainer *container, GtkWidget *widget)
{
AWTGtkPanel *panel = AWT_GTK_PANEL(container);
g_return_if_fail (panel != NULL);
g_return_if_fail (widget != NULL);
gtk_widget_set_parent (widget, GTK_WIDGET (panel));
/* Add at start of list using g_list_prepend to ensure widgets are added behind
other widgets if they are added later. */
panel->children = g_list_prepend (panel->children, widget);
if (GTK_WIDGET_REALIZED (panel))
gtk_widget_realize (widget);
if (GTK_WIDGET_VISIBLE (panel) && GTK_WIDGET_VISIBLE (widget))
{
if (GTK_WIDGET_MAPPED (panel))
gtk_widget_map (widget);
gtk_widget_queue_resize (GTK_WIDGET (panel));
}
}
static void
gd_stack_add (GtkContainer *container,
GtkWidget *child)
{
GdStack *stack = GD_STACK (container);
GdStackPrivate *priv = stack->priv;
GdStackChildInfo *child_info;
g_return_if_fail (child != NULL);
child_info = g_slice_new (GdStackChildInfo);
child_info->widget = child;
child_info->name = NULL;
child_info->title = NULL;
child_info->symbolic_icon_name = NULL;
priv->children = g_list_append (priv->children, child_info);
gtk_widget_set_parent_window (child, priv->bin_window);
gtk_widget_set_parent (child, GTK_WIDGET (stack));
g_signal_connect (child, "notify::visible",
G_CALLBACK (stack_child_visibility_notify_cb), stack);
gtk_widget_child_notify (child, "position");
if (priv->visible_child == NULL &&
gtk_widget_get_visible (child))
set_visible_child (stack, child_info);
else
gtk_widget_set_child_visible (child, FALSE);
if (priv->homogeneous || priv->visible_child == child_info)
gtk_widget_queue_resize (GTK_WIDGET (stack));
}
/**
* eel_gtk_container_child_add:
*
* @container: A GtkContainer widget.
* @child: A non NULL unparented child.
*
* Add a @child to a @container. The @child is realized, mapped
* and resized if needed. This is usually called from the "GtkContainer::add"
* method of the @container. The @child cannot be NULL.
*/
void
eel_gtk_container_child_add (GtkContainer *container,
GtkWidget *child)
{
GtkWidget *widget;
g_return_if_fail (GTK_IS_CONTAINER (container));
g_return_if_fail (GTK_IS_WIDGET (child));
widget = GTK_WIDGET (container);
gtk_widget_set_parent (child, widget);
if (gtk_widget_get_realized (widget))
{
gtk_widget_realize (child);
}
if (gtk_widget_get_mapped (widget)
&& gtk_widget_get_visible (child))
{
if (gtk_widget_get_mapped (widget))
{
gtk_widget_map (child);
}
gtk_widget_queue_resize (child);
}
}
void
cb_compose_images_load_image (CbComposeImages *self,
const char *image_path)
{
GFile *file;
GError *error = NULL;
GdkTexture *texture;
Image *image;
#if DEBUG
g_assert (!cb_compose_images_is_full (self));
#endif
file = g_file_new_for_path (image_path);
texture = gdk_texture_new_from_file (file, &error);
if (error != NULL)
{
g_warning (G_STRLOC ": Couldn't load image %s: %s",
image_path, error->message);
g_object_unref (file);
return;
}
g_array_set_size (self->images, self->images->len + 1);
image = &g_array_index (self->images, Image, self->images->len - 1);
image->path = g_strdup (image_path);
image->fraction = 0.0;
image->deleted = FALSE;
image->image = gtk_image_new_from_paintable (GDK_PAINTABLE (g_steal_pointer (&texture)));
gtk_image_set_can_shrink (GTK_IMAGE (image->image), TRUE);
gtk_widget_set_size_request (image->image, -1, MIN_IMAGE_HEIGHT);
gtk_widget_set_parent (image->image, GTK_WIDGET (self));
image->delete_button = gtk_button_new_from_icon_name ("window-close-symbolic");
gtk_style_context_add_class (gtk_widget_get_style_context (image->delete_button), "close-button");
g_signal_connect (image->delete_button, "clicked", G_CALLBACK (delete_button_clicked_cb), self);
gtk_widget_set_parent (image->delete_button, GTK_WIDGET (self));
image->progressbar = gtk_progress_bar_new ();
gtk_widget_hide (image->progressbar);
gtk_widget_set_parent (image->progressbar, GTK_WIDGET (self));
g_object_unref (file);
}
virtual bool set_parent(widget_attached_t to) {
widget_attached_t detached = 0;
if ((detached = this->attached_to())) {
gtk_widget_set_parent(detached, to);
return true;
}
return false;
}
static void
add (GtkContainer* container,
GtkWidget * child)
{
/* TODO: consider using a GQueue or GSequence for the children */
PRIV (container)->children = g_list_append (PRIV (container)->children, g_object_ref_sink (child));
gtk_widget_set_parent (child, GTK_WIDGET (container));
}
static void ygtk_fixed_add (GtkContainer *container, GtkWidget *widget)
{
YGtkFixed *fixed = YGTK_FIXED (container);
YGtkFixedChild *child = g_new0 (YGtkFixedChild, 1);
child->widget = widget;
child->width = child->height = 50;
fixed->children = g_slist_append (fixed->children, child);
gtk_widget_set_parent (widget, GTK_WIDGET (fixed));
}
gboolean mw_tooltip_timeout(GtkWidget *tv)
{
GtkAllocation allocation;
int scr_w,scr_h, w, h, x, y;
char *tooltiptext = NULL;
tooltiptext = get_tooltip_text();
tipwindow = gtk_window_new(GTK_WINDOW_POPUP);
gtk_widget_set_parent(tipwindow, tv);
gtk_widget_set_app_paintable(tipwindow, TRUE);
gtk_window_set_resizable(GTK_WINDOW(tipwindow), FALSE);
gtk_widget_set_name(tipwindow, "gtk-tooltips");
g_signal_connect(G_OBJECT(tipwindow), "expose_event",
G_CALLBACK(mw_paint_tip), NULL);
gtk_widget_ensure_style (tipwindow);
layout = gtk_widget_create_pango_layout (tipwindow, NULL);
pango_layout_set_wrap(layout, PANGO_WRAP_WORD);
pango_layout_set_width(layout, 300000);
pango_layout_set_markup(layout, tooltiptext, strlen(tooltiptext));
scr_w = gdk_screen_width();
scr_h = gdk_screen_height();
pango_layout_get_size (layout, &w, &h);
w = PANGO_PIXELS(w) + 8;
h = PANGO_PIXELS(h) + 8;
gdk_window_get_pointer(NULL, &x, &y, NULL);
if (!gtk_widget_get_has_window (mw.vbox))
{
gtk_widget_get_allocation (mw.vbox, &allocation);
y += allocation.y;
}
x -= ((w >> 1) + 4);
if ((x + w) > scr_w)
x -= (x + w) - scr_w;
else if (x < 0)
x = 0;
if ((y + h + 4) > scr_h)
y = y - h;
else
y = y + 6;
/*
g_object_unref(layout);
*/
g_free(tooltiptext);
gtk_widget_set_size_request(tipwindow, w, h);
gtk_window_move(GTK_WINDOW(tipwindow), x, y);
gtk_widget_show(tipwindow);
return FALSE;
}
/* Add an icon grid element and establish its initial visibility. */
static void panel_icon_grid_add(GtkContainer *container, GtkWidget *widget)
{
PanelIconGrid *ig = PANEL_ICON_GRID(container);
/* Insert at the tail of the child list. This keeps the graphics in the order they were added. */
ig->children = g_list_append(ig->children, widget);
/* Add the widget to the layout container. */
gtk_widget_set_parent(widget, GTK_WIDGET(container));
// gtk_widget_queue_resize(GTK_WIDGET(container));
}
static void
gtk_check_button_add (GtkContainer *container,
GtkWidget *widget)
{
_gtk_bin_set_child (GTK_BIN (container), widget);
if (gtk_widget_get_direction (GTK_WIDGET (container)) == GTK_TEXT_DIR_RTL)
gtk_widget_insert_after (widget, GTK_WIDGET (container), NULL);
else
gtk_widget_set_parent (widget, GTK_WIDGET (container));
}
int
clip_GTK_WIDGETSETPARENT(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_set_parent(cwid->widget, cpar->widget);
return 0;
err:
return 1;
}
static void
hildon_home_window_set_property (GObject *gobject,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
HildonHomeWindowPrivate *priv = HILDON_HOME_WINDOW_GET_PRIVATE (gobject);
switch (prop_id)
{
case PROP_MENU:
hildon_home_window_set_menu (HILDON_HOME_WINDOW (gobject),
GTK_MENU (g_value_get_object (value)));
break;
case PROP_WORK_AREA:
hildon_home_window_set_work_area (HILDON_HOME_WINDOW (gobject),
(GdkRectangle *)
g_value_get_pointer (value));
break;
case PROP_TITLE:
g_object_set (priv->titlebar,
"title", g_value_get_string (value),
NULL);
break;
case PROP_TITLEBAR:
{
GtkWidget *titlebar = GTK_WIDGET (g_value_get_object (value));
if (GTK_IS_WIDGET (titlebar))
{
if (priv->titlebar)
g_object_unref (priv->titlebar);
priv->titlebar = titlebar;
gtk_widget_push_composite_child ();
g_object_ref (priv->titlebar);
gtk_object_sink (GTK_OBJECT (priv->titlebar));
gtk_widget_set_parent (priv->titlebar,
GTK_WIDGET (gobject));
gtk_widget_show (priv->titlebar);
gtk_widget_pop_composite_child ();
}
}
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
break;
}
}
void ygtk_ratio_box_pack (YGtkRatioBox *box, GtkWidget *child, gfloat ratio)
{
YGtkRatioBoxChild* child_info;
child_info = g_new (YGtkRatioBoxChild, 1);
child_info->widget = child;
child_info->ratio = ratio;
box->children = g_list_append (box->children, child_info);
gtk_widget_freeze_child_notify (child);
gtk_widget_set_parent (child, GTK_WIDGET (box));
gtk_widget_thaw_child_notify (child);
}
void
gtk_offscreen_box_add2 (GtkOffscreenBox *offscreen_box,
GtkWidget *child)
{
g_return_if_fail (GTK_IS_OFFSCREEN_BOX (offscreen_box));
g_return_if_fail (GTK_IS_WIDGET (child));
if (offscreen_box->child2 == NULL)
{
gtk_widget_set_parent_window (child, offscreen_box->offscreen_window2);
gtk_widget_set_parent (child, GTK_WIDGET (offscreen_box));
offscreen_box->child2 = child;
}
}
static void
gtk_rotated_bin_add (GtkContainer *container,
GtkWidget *widget)
{
GtkRotatedBin *bin = GTK_ROTATED_BIN (container);
if (!bin->child)
{
gtk_widget_set_parent_window (widget, bin->offscreen_window);
gtk_widget_set_parent (widget, GTK_WIDGET (bin));
bin->child = widget;
}
else
g_warning ("GtkRotatedBin cannot have more than one child\n");
}
void wxNotebook::AddChildGTK(wxWindowGTK* child)
{
// Hack Alert! (Part I): This sets the notebook as the parent of the child
// widget, and takes care of some details such as updating the state and
// style of the child to reflect its new location. We do this early
// because without it GetBestSize (which is used to set the initial size
// of controls if an explicit size is not given) will often report
// incorrect sizes since the widget's style context is not fully known.
// See bug #901694 for details
// (http://sourceforge.net/tracker/?func=detail&aid=901694&group_id=9863&atid=109863)
gtk_widget_set_parent(child->m_widget, m_widget);
// NOTE: This should be considered a temporary workaround until we can
// work out the details and implement delaying the setting of the initial
// size of widgets until the size is really needed.
}