w = allocation->width - border_width * 2;
h = allocation->height - border_width * 2;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
gdk_window_move_resize (widget->window,
allocation->x + border_width,
allocation->y + border_width,
child_allocation.width = MIN ((w - s * child_allocation.height) / c,
(h - c * child_allocation.height) / s);
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
gdk_window_move_resize (bin->offscreen_window,
child_allocation.x,
child_allocation.y,
w = allocation->width - border_width * 2;
h = allocation->height - border_width * 2;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
gdk_window_move_resize (widget->window,
allocation->x + border_width,
allocation->y + border_width,
child_allocation.height = child_requisition.height;
child_allocation.width = child_requisition.width;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
gdk_window_move_resize (bin->offscreen_window,
allocation->x + border_width,
allocation->y + border_width,
g_return_if_fail (allocation != NULL);
widget->allocation = *allocation;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
dial = GTK_DIAL (widget);
widget->allocation = *allocation;
dial = GTK_DIAL (widget);
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gdk_window_move_resize (widget->window,
widget->allocation = *allocation;
dial = GTK_DIAL (widget);
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gdk_window_move_resize (widget->window,
gtk_widget_set_parent (page_info->page, GTK_WIDGET (assistant));
gtk_widget_set_parent (page_info->title, GTK_WIDGET (assistant));
- if (GTK_WIDGET_REALIZED (GTK_WIDGET (assistant)))
+ if (gtk_widget_get_realized (GTK_WIDGET (assistant)))
{
gtk_widget_realize (page_info->page);
gtk_widget_realize (page_info->title);
widget->allocation = *allocation;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
gdk_window_move_resize (button->event_window,
widget->allocation.x + border_width,
widget->allocation.y + border_width,
priv = GTK_BUTTON_GET_PRIVATE (button);
- if (GTK_WIDGET_REALIZED (button) && !button->activate_timeout)
+ if (gtk_widget_get_realized (widget) && !button->activate_timeout)
{
time = gtk_get_current_event_time ();
if (gdk_keyboard_grab (button->event_window, TRUE, time) ==
priv->week_width = 0;
}
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gdk_window_move_resize (widget->window,
allocation->x, allocation->y,
GtkCalendarPrivate *priv = GTK_CALENDAR_GET_PRIVATE (widget);
gint i;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
for (i = 0; i < 4; i++)
{
gtk_calendar_style_set (GtkWidget *widget,
GtkStyle *previous_style)
{
- if (previous_style && GTK_WIDGET_REALIZED (widget))
+ if (previous_style && gtk_widget_get_realized (widget))
calendar_set_background (widget);
}
old_flags = calendar->display_flags;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
if ((flags ^ calendar->display_flags) & GTK_CALENDAR_NO_MONTH_CHANGE)
{
NULL);
widget->allocation = *allocation;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
gdk_window_move_resize (button->event_window,
allocation->x, allocation->y,
allocation->width, allocation->height);
gint last_button = 0;
gint i;
- if (!GTK_WIDGET_REALIZED (clist))
+ if (!gtk_widget_get_realized (GTK_WIDGET (clist)))
return;
button_allocation.x = clist->hoffset;
button = clist->column[column].button = gtk_button_new ();
gtk_widget_pop_composite_child ();
- if (GTK_WIDGET_REALIZED (clist) && clist->title_window)
+ if (gtk_widget_get_realized (GTK_WIDGET (clist)) && clist->title_window)
gtk_widget_set_parent_window (clist->column[column].button,
clist->title_window);
gtk_widget_set_parent (button, GTK_WIDGET (clist));
{
clist_row->foreground = *color;
clist_row->fg_set = TRUE;
- if (GTK_WIDGET_REALIZED (clist))
+ if (gtk_widget_get_realized (GTK_WIDGET (clist)))
gdk_colormap_alloc_color (gtk_widget_get_colormap (GTK_WIDGET (clist)),
&clist_row->foreground, FALSE, TRUE);
}
{
clist_row->background = *color;
clist_row->bg_set = TRUE;
- if (GTK_WIDGET_REALIZED (clist))
+ if (gtk_widget_get_realized (GTK_WIDGET (clist)))
gdk_colormap_alloc_color (gtk_widget_get_colormap (GTK_WIDGET (clist)),
&clist_row->background, FALSE, TRUE);
}
if (clist_row->cell[column].style)
{
- if (GTK_WIDGET_REALIZED (clist))
+ if (gtk_widget_get_realized (GTK_WIDGET (clist)))
gtk_style_detach (clist_row->cell[column].style);
g_object_unref (clist_row->cell[column].style);
}
{
g_object_ref (clist_row->cell[column].style);
- if (GTK_WIDGET_REALIZED (clist))
+ if (gtk_widget_get_realized (GTK_WIDGET (clist)))
clist_row->cell[column].style =
gtk_style_attach (clist_row->cell[column].style,
clist->clist_window);
if (clist_row->style)
{
- if (GTK_WIDGET_REALIZED (clist))
+ if (gtk_widget_get_realized (GTK_WIDGET (clist)))
gtk_style_detach (clist_row->style);
g_object_unref (clist_row->style);
}
{
g_object_ref (clist_row->style);
- if (GTK_WIDGET_REALIZED (clist))
+ if (gtk_widget_get_realized (GTK_WIDGET (clist)))
clist_row->style = gtk_style_attach (clist_row->style,
clist->clist_window);
}
GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
/* detach optional row/cell styles */
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
GtkCListRow *clist_row;
GList *list;
GTK_WIDGET_CLASS (parent_class)->style_set (widget, previous_style);
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gtk_style_set_background (widget->style, widget->window, widget->state);
gtk_style_set_background (widget->style, clist->title_window, GTK_STATE_SELECTED);
widget->allocation = *allocation;
border_width = GTK_CONTAINER (widget)->border_width;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gdk_window_move_resize (widget->window,
allocation->x + border_width,
clist->clist_window_width = clist_allocation.width;
clist->clist_window_height = clist_allocation.height;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gdk_window_move_resize (clist->clist_window,
clist_allocation.x,
clist->column_title_area.y = widget->style->ythickness;
clist->column_title_area.width = clist_allocation.width;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gdk_window_move_resize (clist->title_window,
clist->column_title_area.x,
{
ScrollData *scroll_data = data;
- if (!GTK_WIDGET_REALIZED (widget))
+ if (!gtk_widget_get_realized (widget))
{
if (gtk_widget_get_visible (widget))
{
{
ScrollData scroll_data;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
scroll_data.window = ALLOCATION_WINDOW (widget);
else
scroll_data.window = NULL;
dx = -value - clist->hoffset;
- if (GTK_WIDGET_REALIZED (clist))
+ if (gtk_widget_get_realized (GTK_WIDGET (clist)))
gdk_window_scroll (clist->title_window, dx, 0);
/* adjust the column button's allocations */
(clist, clist_row, i, GTK_CELL_EMPTY, NULL, 0, NULL, NULL);
if (clist_row->cell[i].style)
{
- if (GTK_WIDGET_REALIZED (clist))
+ if (gtk_widget_get_realized (GTK_WIDGET (clist)))
gtk_style_detach (clist_row->cell[i].style);
g_object_unref (clist_row->cell[i].style);
}
if (clist_row->style)
{
- if (GTK_WIDGET_REALIZED (clist))
+ if (gtk_widget_get_realized (GTK_WIDGET (clist)))
gtk_style_detach (clist_row->style);
g_object_unref (clist_row->style);
}
GTK_WIDGET_CLASS (gtk_color_button_parent_class)->style_set (widget, previous_style);
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
if (color_button->priv->pixbuf != NULL)
g_object_unref (color_button->priv->pixbuf);
widget = GTK_WIDGET (user_data);
- g_return_if_fail (GTK_WIDGET_REALIZED (widget));
+ g_return_if_fail (gtk_widget_get_realized (widget));
gdk_window_get_origin (widget->window, &root_x, &root_y);
GtkComboBox *combo_box = GTK_COMBO_BOX (widget);
GtkComboBoxPrivate *priv = combo_box->priv;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
if (priv->tree_view && priv->cell_view)
gtk_cell_view_set_background_color (GTK_CELL_VIEW (priv->cell_view),
GtkComboBox *combo_box = GTK_COMBO_BOX (data);
GtkComboBoxPrivate *priv = combo_box->priv;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
if (!priv->tree_view && priv->cell_view)
{
GtkTreePath *path = NULL, *ppath;
GtkWidget *toplevel;
- if (!GTK_WIDGET_REALIZED (combo_box))
+ if (!gtk_widget_get_realized (GTK_WIDGET (combo_box)))
return;
if (gtk_widget_get_mapped (priv->popup_widget))
return;
}
- if (!GTK_WIDGET_REALIZED (GTK_WIDGET (combo_box)))
+ if (!gtk_widget_get_realized (GTK_WIDGET (combo_box)))
return;
gtk_grab_remove (priv->popup_window);
container->border_width = border_width;
g_object_notify (G_OBJECT (container), "border-width");
- if (GTK_WIDGET_REALIZED (container))
+ if (gtk_widget_get_realized (GTK_WIDGET (container)))
gtk_widget_queue_resize (GTK_WIDGET (container));
}
}
if (resize_container)
{
if (gtk_widget_get_visible (GTK_WIDGET (resize_container)) &&
- (gtk_widget_is_toplevel (GTK_WIDGET (resize_container)) || GTK_WIDGET_REALIZED (resize_container)))
+ (gtk_widget_is_toplevel (GTK_WIDGET (resize_container)) ||
+ gtk_widget_get_realized (GTK_WIDGET (resize_container))))
{
switch (resize_container->resize_mode)
{
while (children)
{
- if (GTK_WIDGET_REALIZED (children->data))
+ if (gtk_widget_get_realized (children->data))
visible_children = g_list_prepend (visible_children, children->data);
children = children->next;
}
ctree = GTK_CTREE (widget);
clist = GTK_CLIST (widget);
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
GtkCTreeNode *node;
GtkCTreeNode *child;
(clist, &(ctree_row->row), i, GTK_CELL_EMPTY, NULL, 0, NULL, NULL);
if (ctree_row->row.cell[i].style)
{
- if (GTK_WIDGET_REALIZED (ctree))
+ if (gtk_widget_get_realized (GTK_WIDGET (ctree)))
gtk_style_detach (ctree_row->row.cell[i].style);
g_object_unref (ctree_row->row.cell[i].style);
}
if (ctree_row->row.style)
{
- if (GTK_WIDGET_REALIZED (ctree))
+ if (gtk_widget_get_realized (GTK_WIDGET (ctree)))
gtk_style_detach (ctree_row->row.style);
g_object_unref (ctree_row->row.style);
}
if (GTK_CTREE_ROW (node)->row.cell[column].style)
{
- if (GTK_WIDGET_REALIZED (ctree))
+ if (gtk_widget_get_realized (GTK_WIDGET (ctree)))
gtk_style_detach (GTK_CTREE_ROW (node)->row.cell[column].style);
g_object_unref (GTK_CTREE_ROW (node)->row.cell[column].style);
}
{
g_object_ref (GTK_CTREE_ROW (node)->row.cell[column].style);
- if (GTK_WIDGET_REALIZED (ctree))
+ if (gtk_widget_get_realized (GTK_WIDGET (ctree)))
GTK_CTREE_ROW (node)->row.cell[column].style =
gtk_style_attach (GTK_CTREE_ROW (node)->row.cell[column].style,
clist->clist_window);
if (GTK_CTREE_ROW (node)->row.style)
{
- if (GTK_WIDGET_REALIZED (ctree))
+ if (gtk_widget_get_realized (GTK_WIDGET (ctree)))
gtk_style_detach (GTK_CTREE_ROW (node)->row.style);
g_object_unref (GTK_CTREE_ROW (node)->row.style);
}
{
g_object_ref (GTK_CTREE_ROW (node)->row.style);
- if (GTK_WIDGET_REALIZED (ctree))
+ if (gtk_widget_get_realized (GTK_WIDGET (ctree)))
GTK_CTREE_ROW (node)->row.style =
gtk_style_attach (GTK_CTREE_ROW (node)->row.style,
clist->clist_window);
{
GTK_CTREE_ROW (node)->row.foreground = *color;
GTK_CTREE_ROW (node)->row.fg_set = TRUE;
- if (GTK_WIDGET_REALIZED (ctree))
+ if (gtk_widget_get_realized (GTK_WIDGET (ctree)))
gdk_colormap_alloc_color (gtk_widget_get_colormap (GTK_WIDGET (ctree)),
>K_CTREE_ROW (node)->row.foreground,
FALSE, TRUE);
{
GTK_CTREE_ROW (node)->row.background = *color;
GTK_CTREE_ROW (node)->row.bg_set = TRUE;
- if (GTK_WIDGET_REALIZED (ctree))
+ if (gtk_widget_get_realized (GTK_WIDGET (ctree)))
gdk_colormap_alloc_color (gtk_widget_get_colormap (GTK_WIDGET (ctree)),
>K_CTREE_ROW (node)->row.background,
FALSE, TRUE);
clist->column[ctree->tree_column].width + 3);
}
- if (GTK_WIDGET_REALIZED (ctree))
+ if (gtk_widget_get_realized (GTK_WIDGET (ctree)))
{
gint8 dashes[] = { 1, 1 };
switch (line_style)
{
case GTK_CTREE_LINES_SOLID:
- if (GTK_WIDGET_REALIZED (ctree))
+ if (gtk_widget_get_realized (GTK_WIDGET (ctree)))
gdk_gc_set_line_attributes (ctree->lines_gc, 1, GDK_LINE_SOLID,
GDK_CAP_BUTT, GDK_JOIN_MITER);
break;
case GTK_CTREE_LINES_DOTTED:
- if (GTK_WIDGET_REALIZED (ctree))
+ if (gtk_widget_get_realized (GTK_WIDGET (ctree)))
gdk_gc_set_line_attributes (ctree->lines_gc, 1,
GDK_LINE_ON_OFF_DASH, GDK_CAP_BUTT, GDK_JOIN_MITER);
gdk_gc_set_dashes (ctree->lines_gc, 0, dashes, G_N_ELEMENTS (dashes));
break;
case GTK_CTREE_LINES_TABBED:
- if (GTK_WIDGET_REALIZED (ctree))
+ if (gtk_widget_get_realized (GTK_WIDGET (ctree)))
gdk_gc_set_line_attributes (ctree->lines_gc, 1, GDK_LINE_SOLID,
GDK_CAP_BUTT, GDK_JOIN_MITER);
break;
gtk_drag_dest_unset (widget);
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
gtk_drag_dest_realized (widget, site);
g_signal_connect (widget, "realize",
GdkEvent *event)
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
- g_return_val_if_fail (GTK_WIDGET_REALIZED (widget), NULL);
+ g_return_val_if_fail (gtk_widget_get_realized (widget), NULL);
g_return_val_if_fail (targets != NULL, NULL);
return gtk_drag_begin_internal (widget, NULL, targets,
site->track_motion = old_site->track_motion;
}
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
gtk_drag_dest_realized (widget);
g_signal_connect (widget, "realize",
{
GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
- if (gtk_widget_is_toplevel (toplevel) && GTK_WIDGET_REALIZED (toplevel))
+ if (gtk_widget_is_toplevel (toplevel) && gtk_widget_get_realized (toplevel))
gdk_window_register_dnd (toplevel->window);
}
GdkEvent *event)
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
- g_return_val_if_fail (GTK_WIDGET_REALIZED (widget), NULL);
+ g_return_val_if_fail (gtk_widget_get_realized (widget), NULL);
g_return_val_if_fail (targets != NULL, NULL);
return gtk_drag_begin_internal (widget, NULL, targets,
widget->allocation = *allocation;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
if (gtk_widget_get_has_window (widget))
gdk_window_move_resize (widget->window,
icon_info = g_slice_new0 (EntryIconInfo);
priv->icons[icon_pos] = icon_info;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
realize_icon_info (widget, icon_pos);
return icon_info;
EntryIconInfo *icon_info = NULL;
gint i;
- if (GTK_WIDGET_REALIZED (widget) && !gtk_widget_get_mapped (widget))
+ if (gtk_widget_get_realized (widget) && !gtk_widget_get_mapped (widget))
{
GTK_WIDGET_CLASS (gtk_entry_parent_class)->map (widget);
gtk_widget_get_child_requisition (widget, &requisition);
_gtk_entry_get_borders (entry, &xborder, &yborder);
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
gdk_drawable_get_size (widget->window, NULL, &frame_height);
else
frame_height = requisition.height;
widget->allocation = *allocation;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
/* We call gtk_widget_get_child_requisition, since we want (for
* backwards compatibility reasons) the realization here to
GdkCursor *cursor;
gint i;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gdk_window_set_background (widget->window, &widget->style->base[GTK_WIDGET_STATE (widget)]);
gdk_window_set_background (entry->text_area, &widget->style->base[GTK_WIDGET_STATE (widget)]);
gtk_entry_recompute (entry);
- if (previous_style && GTK_WIDGET_REALIZED (widget))
+ if (previous_style && gtk_widget_get_realized (widget))
{
gdk_window_set_background (widget->window, &widget->style->base[GTK_WIDGET_STATE (widget)]);
gdk_window_set_background (entry->text_area, &widget->style->base[GTK_WIDGET_STATE (widget)]);
PangoLayoutLine *line;
PangoRectangle logical_rect;
- if (!GTK_WIDGET_REALIZED (entry))
+ if (!gtk_widget_get_realized (GTK_WIDGET (entry)))
return;
_gtk_entry_effective_inner_border (entry, &inner_border);
gint start, end;
gint n_targets;
- if (!GTK_WIDGET_REALIZED (entry))
+ if (!gtk_widget_get_realized (GTK_WIDGET (entry)))
return;
list = gtk_target_list_new (NULL, 0);
{
icon_info->nonactivatable = !activatable;
- if (GTK_WIDGET_REALIZED (GTK_WIDGET (entry)))
+ if (gtk_widget_get_realized (GTK_WIDGET (entry)))
update_cursors (GTK_WIDGET (entry));
g_object_notify (G_OBJECT (entry),
icon_info->pressed = FALSE;
icon_info->prelight = FALSE;
- if (GTK_WIDGET_REALIZED (GTK_WIDGET (entry)))
+ if (gtk_widget_get_realized (GTK_WIDGET (entry)))
update_cursors (GTK_WIDGET (entry));
gtk_widget_queue_draw (GTK_WIDGET (entry));
GtkBorder inner_border;
gint monitor_num, strong_x, height;
- g_return_if_fail (GTK_WIDGET_REALIZED (entry));
+ g_return_if_fail (gtk_widget_get_realized (widget));
gdk_window_get_origin (entry->text_area, x, y);
PopupInfo *info = user_data;
GtkEntry *entry = info->entry;
- if (GTK_WIDGET_REALIZED (entry))
+ if (gtk_widget_get_realized (GTK_WIDGET (entry)))
{
DisplayMode mode;
gboolean clipboard_contains_text;
if (visible_window != gtk_widget_get_has_window (widget))
{
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gboolean visible = gtk_widget_get_visible (widget);
{
priv->above_child = above_child;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
if (!gtk_widget_get_has_window (widget))
{
child_allocation.width = MAX (allocation->width - GTK_CONTAINER (widget)->border_width * 2, 0);
child_allocation.height = MAX (allocation->height - GTK_CONTAINER (widget)->border_width * 2, 0);
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
priv = GTK_EVENT_BOX_GET_PRIVATE (widget);
label_height = 0;
}
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
GdkRectangle rect;
widget = GTK_WIDGET (expander);
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
gdk_window_invalidate_rect (widget->window, &widget->allocation, FALSE);
}
GdkRectangle area;
gboolean finish = FALSE;
- if (GTK_WIDGET_REALIZED (expander))
+ if (gtk_widget_get_realized (GTK_WIDGET (expander)))
{
get_expander_bounds (expander, &area);
gdk_window_invalidate_rect (GTK_WIDGET (expander)->window, &area, TRUE);
g_object_get (settings, "gtk-enable-animations", &enable_animations, NULL);
- if (enable_animations && GTK_WIDGET_REALIZED (expander))
+ if (enable_animations && gtk_widget_get_realized (GTK_WIDGET (expander)))
{
gtk_expander_start_animation (expander);
}
gint monitor_num;
GdkRectangle monitor;
- g_return_if_fail (GTK_WIDGET_REALIZED (widget));
+ g_return_if_fail (gtk_widget_get_realized (widget));
gdk_window_get_origin (widget->window, x, y);
GdkCursor *cursor;
toplevel = get_toplevel (GTK_WIDGET (impl));
- if (!toplevel || !GTK_WIDGET_REALIZED (toplevel))
+ if (!toplevel || !gtk_widget_get_realized (GTK_WIDGET (toplevel)))
return;
display = gtk_widget_get_display (GTK_WIDGET (toplevel));
if (gtk_widget_get_has_window (widget))
{
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
gdk_window_move_resize (widget->window,
allocation->x,
allocation->y,
gboolean has_window)
{
g_return_if_fail (GTK_IS_FIXED (fixed));
- g_return_if_fail (!GTK_WIDGET_REALIZED (fixed));
+ g_return_if_fail (!gtk_widget_get_realized (GTK_WIDGET (fixed)));
if (has_window != gtk_widget_get_has_window (GTK_WIDGET (fixed)))
{
{
GtkHandleBox *hb = GTK_HANDLE_BOX (widget);
- if (GTK_WIDGET_REALIZED (widget) &&
+ if (gtk_widget_get_realized (widget) &&
gtk_widget_get_has_window (widget))
{
gtk_style_set_background (widget->style, widget->window,
widget->allocation = *allocation;
- if (GTK_WIDGET_REALIZED (hb))
+ if (gtk_widget_get_realized (widget))
gdk_window_move_resize (widget->window,
widget->allocation.x,
widget->allocation.y,
else
float_height += DRAG_HANDLE_SIZE;
- if (GTK_WIDGET_REALIZED (hb))
+ if (gtk_widget_get_realized (widget))
{
gdk_window_resize (hb->float_window,
float_width,
else
child_allocation.height -= DRAG_HANDLE_SIZE;
- if (GTK_WIDGET_REALIZED (hb))
+ if (gtk_widget_get_realized (widget))
gdk_window_move_resize (hb->bin_window,
0,
0,
if (hb->child_detached)
{
hb->child_detached = FALSE;
- if (GTK_WIDGET_REALIZED (hb))
+ if (gtk_widget_get_realized (widget))
{
gdk_window_hide (hb->float_window);
gdk_window_reparent (hb->bin_window, widget->window, 0, 0);
widget->allocation = *allocation;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
gdk_window_move_resize (priv->window,
allocation->x,
allocation->y,
{
GtkIconView *icon_view = GTK_ICON_VIEW (widget);
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gdk_window_set_background (widget->window, &widget->style->base[widget->state]);
gdk_window_set_background (icon_view->priv->bin_window, &widget->style->base[widget->state]);
{
GtkIconView *icon_view = GTK_ICON_VIEW (widget);
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gdk_window_set_background (widget->window, &widget->style->base[widget->state]);
gdk_window_set_background (icon_view->priv->bin_window, &widget->style->base[widget->state]);
widget->allocation = *allocation;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gdk_window_move_resize (widget->window,
allocation->x, allocation->y,
if (vadjustment->value > vadjustment->upper - vadjustment->page_size)
gtk_adjustment_set_value (vadjustment, MAX (0, vadjustment->upper - vadjustment->page_size));
- if (GTK_WIDGET_REALIZED (widget) &&
+ if (gtk_widget_get_realized (widget) &&
icon_view->priv->scroll_to_path)
{
GtkTreePath *path;
icon_view->priv->children = g_list_append (icon_view->priv->children, child);
- if (GTK_WIDGET_REALIZED (icon_view))
+ if (gtk_widget_get_realized (GTK_WIDGET (icon_view)))
gtk_widget_set_parent_window (child->widget, icon_view->priv->bin_window);
gtk_widget_set_parent (widget, GTK_WIDGET (icon_view));
gtk_icon_view_adjustment_changed (GtkAdjustment *adjustment,
GtkIconView *icon_view)
{
- if (GTK_WIDGET_REALIZED (icon_view))
+ if (gtk_widget_get_realized (GTK_WIDGET (icon_view)))
{
gdk_window_move (icon_view->priv->bin_window,
- icon_view->priv->hadjustment->value,
icon_view->priv->height != widget->requisition.height)
gtk_widget_queue_resize_no_redraw (widget);
- if (GTK_WIDGET_REALIZED (icon_view))
+ if (gtk_widget_get_realized (GTK_WIDGET (icon_view)))
gdk_window_resize (icon_view->priv->bin_window,
MAX (icon_view->priv->width, widget->allocation.width),
MAX (icon_view->priv->height, widget->allocation.height));
item = g_list_nth_data (icon_view->priv->items,
gtk_tree_path_get_indices(path)[0]);
- if (!GTK_WIDGET_REALIZED (icon_view) || !item || item->width < 0)
+ if (!item || item->width < 0 ||
+ !gtk_widget_get_realized (GTK_WIDGET (icon_view)))
{
if (icon_view->priv->scroll_to_path)
gtk_tree_row_reference_free (icon_view->priv->scroll_to_path);
g_object_notify (G_OBJECT (icon_view), "model");
- if (GTK_WIDGET_REALIZED (icon_view))
+ if (gtk_widget_get_realized (GTK_WIDGET (icon_view)))
gtk_widget_queue_resize (GTK_WIDGET (icon_view));
}
widget = GTK_WIDGET (icon_view);
- if (!GTK_WIDGET_REALIZED (widget))
+ if (!gtk_widget_get_realized (widget))
return NULL;
index = gtk_tree_path_get_indices (path)[0];
widget = GTK_WIDGET (invisible);
previous_screen = invisible->screen;
- was_realized = GTK_WIDGET_REALIZED (invisible);
+ was_realized = gtk_widget_get_realized (widget);
if (was_realized)
gtk_widget_unrealize (widget);
static void
gtk_label_update_cursor (GtkLabel *label)
{
+ GtkWidget *widget;
+
if (!label->select_info)
return;
- if (GTK_WIDGET_REALIZED (label))
+ widget = GTK_WIDGET (label);
+
+ if (gtk_widget_get_realized (widget))
{
GdkDisplay *display;
GdkCursor *cursor;
- if (gtk_widget_is_sensitive (GTK_WIDGET (label)))
+ if (gtk_widget_is_sensitive (widget))
{
- display = gtk_widget_get_display (GTK_WIDGET (label));
+ display = gtk_widget_get_display (widget);
if (label->select_info->active_link)
cursor = gdk_cursor_new_for_display (display, GDK_HAND2);
gint attributes_mask;
g_assert (label->select_info);
- g_assert (GTK_WIDGET_REALIZED (label));
+ widget = GTK_WIDGET (label);
+ g_assert (gtk_widget_get_realized (widget));
if (label->select_info->window)
return;
-
- widget = GTK_WIDGET (label);
attributes.x = widget->allocation.x;
attributes.y = widget->allocation.y;
gtk_widget_set_can_focus (GTK_WIDGET (label), TRUE);
- if (GTK_WIDGET_REALIZED (label))
+ if (gtk_widget_get_realized (GTK_WIDGET (label)))
gtk_label_create_window (label);
if (gtk_widget_get_mapped (GTK_WIDGET (label)))
label = GTK_LABEL (user_data);
widget = GTK_WIDGET (label);
- g_return_if_fail (GTK_WIDGET_REALIZED (label));
+ g_return_if_fail (gtk_widget_get_realized (widget));
screen = gtk_widget_get_screen (widget);
gdk_window_get_origin (widget->window, x, y);
layout->children = g_list_append (layout->children, child);
- if (GTK_WIDGET_REALIZED (layout))
+ if (gtk_widget_get_realized (GTK_WIDGET (layout)))
gtk_widget_set_parent_window (child->widget, layout->bin_window);
gtk_widget_set_parent (child_widget, GTK_WIDGET (layout));
if (layout->vadjustment)
gtk_layout_set_adjustment_upper (layout->vadjustment, layout->height, FALSE);
- if (GTK_WIDGET_REALIZED (layout))
+ if (gtk_widget_get_realized (widget))
{
width = MAX (width, widget->allocation.width);
height = MAX (height, widget->allocation.height);
{
GTK_WIDGET_CLASS (gtk_layout_parent_class)->style_set (widget, old_style);
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gtk_style_set_background (widget->style, GTK_LAYOUT (widget)->bin_window, GTK_STATE_NORMAL);
}
gtk_layout_allocate_child (layout, child);
}
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gdk_window_move_resize (widget->window,
allocation->x, allocation->y,
if (layout->freeze_count)
return;
- if (GTK_WIDGET_REALIZED (layout))
+ if (gtk_widget_get_realized (GTK_WIDGET (layout)))
{
gdk_window_move (layout->bin_window,
- layout->hadjustment->value,
gint monitor_num;
GdkRectangle monitor;
- g_return_if_fail (GTK_WIDGET_REALIZED (link_button));
+ g_return_if_fail (gtk_widget_get_realized (widget));
gdk_window_get_origin (widget->window, x, y);
time = gtk_get_current_event_time ();
}
- if (GTK_WIDGET_REALIZED (link_button))
+ if (gtk_widget_get_realized (GTK_WIDGET (link_button)))
{
GtkWidget *menu_item;
GList *children;
widget->allocation = *allocation;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
gdk_window_move_resize (widget->window,
allocation->x, allocation->y,
allocation->width, allocation->height);
gtk_list_style_set (GtkWidget *widget,
GtkStyle *previous_style)
{
- if (previous_style && GTK_WIDGET_REALIZED (widget))
+ if (previous_style && gtk_widget_get_realized (widget))
gdk_window_set_background (widget->window, &widget->style->base[GTK_WIDGET_STATE (widget)]);
}
g_return_if_fail (allocation != NULL);
widget->allocation = *allocation;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
gdk_window_move_resize (widget->window,
allocation->x, allocation->y,
allocation->width, allocation->height);
{
g_return_if_fail (widget != NULL);
- if (previous_style && GTK_WIDGET_REALIZED (widget))
+ if (previous_style && gtk_widget_get_realized (widget))
gdk_window_set_background (widget->window, &widget->style->base[GTK_WIDGET_STATE (widget)]);
}
{
g_object_ref (event_widget);
if (!gtk_widget_event (event_widget, event) &&
- GTK_WIDGET_REALIZED (event_widget))
+ gtk_widget_get_realized (event_widget))
gtk_widget_destroy (event_widget);
g_object_unref (event_widget);
}
else
g_object_set_data (G_OBJECT (data->attach_widget), I_(ATTACHED_MENUS), NULL);
- if (GTK_WIDGET_REALIZED (menu))
+ if (gtk_widget_get_realized (GTK_WIDGET (menu)))
gtk_widget_unrealize (GTK_WIDGET (menu));
g_slice_free (GtkMenuAttachData, data);
ai->top_attach = -1;
ai->bottom_attach = -1;
- if (GTK_WIDGET_REALIZED (menu_shell))
+ if (gtk_widget_get_realized (GTK_WIDGET (menu_shell)))
gtk_widget_set_parent_window (child, menu->bin_window);
GTK_MENU_SHELL_CLASS (gtk_menu_parent_class)->insert (menu_shell, child, position);
gtk_menu_style_set (GtkWidget *widget,
GtkStyle *previous_style)
{
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
GtkMenu *menu = GTK_MENU (widget);
height -= arrow_border.bottom;
}
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gdk_window_move_resize (widget->window,
allocation->x, allocation->y,
}
/* Resize the item window */
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gint i;
gint width, height;
gtk_menu_stop_navigating_submenu (menu);
- if (GTK_WIDGET_REALIZED (menu))
+ if (gtk_widget_get_realized (GTK_WIDGET (menu)))
{
child_window = gdk_window_get_pointer (menu->bin_window, NULL, NULL, NULL);
}
/* Scroll the menu: */
- if (GTK_WIDGET_REALIZED (menu))
+ if (gtk_widget_get_realized (widget))
gdk_window_move (menu->bin_window, 0, -offset);
- if (GTK_WIDGET_REALIZED (menu))
+ if (gtk_widget_get_realized (widget))
gdk_window_move_resize (menu->view_window,
x,
y,
{
GtkMenu *menu = GTK_MENU (menu_shell);
- if (GTK_WIDGET_REALIZED (GTK_WIDGET (menu)))
+ if (gtk_widget_get_realized (GTK_WIDGET (menu)))
gtk_menu_scroll_item_visible (menu_shell, menu_item);
GTK_MENU_SHELL_CLASS (gtk_menu_parent_class)->select_item (menu_shell, menu_item);
direction = gtk_widget_get_direction (widget);
widget->allocation = *allocation;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
gdk_window_move_resize (widget->window,
allocation->x, allocation->y,
allocation->width, allocation->height);
gtk_widget_size_allocate (bin->child, &child_allocation);
}
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
gdk_window_move_resize (menu_item->event_window,
allocation->x, allocation->y,
allocation->width, allocation->height);
gtk_widget_style_get (widget, "focus-line-width", &focus_width, NULL);
widget->allocation = *allocation;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
GdkRectangle position;
border_width = gtk_container_get_border_width (GTK_CONTAINER (widget));
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
gdk_window_move_resize (widget->window,
allocation->x,
allocation->y,
GTK_WIDGET_SET_FLAGS (widget, GTK_VISIBLE);
container = GTK_CONTAINER (widget);
- need_resize = container->need_resize || !GTK_WIDGET_REALIZED (widget);
+ need_resize = container->need_resize || !gtk_widget_get_realized (widget);
container->need_resize = FALSE;
if (need_resize)
gboolean claim,
guint32 time)
{
- GtkWidget *widget = GTK_WIDGET (old_editable);
- GdkDisplay *display = gtk_widget_get_display (widget);
+ GtkWidget *widget;
+ GdkDisplay *display;
g_return_if_fail (GTK_IS_OLD_EDITABLE (old_editable));
- g_return_if_fail (GTK_WIDGET_REALIZED (old_editable));
+ widget = GTK_WIDGET (old_editable);
+ g_return_if_fail (gtk_widget_get_realized (widget));
+ display = gtk_widget_get_display (widget);
old_editable->has_selection = FALSE;
if (claim)
{
GtkOldEditable *old_editable = GTK_OLD_EDITABLE (editable);
- if (GTK_WIDGET_REALIZED (editable))
+ if (gtk_widget_get_realized (GTK_WIDGET (editable)))
gtk_old_editable_claim_selection (old_editable, start != end, GDK_CURRENT_TIME);
gtk_old_editable_set_selection (old_editable, start, end);
border_width = GTK_CONTAINER (widget)->border_width;
widget->allocation = *allocation;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
gdk_window_move_resize (button->event_window,
allocation->x + border_width, allocation->y + border_width,
allocation->width - border_width * 2, allocation->height - border_width * 2);
gdk_window_invalidate_rect (widget->window, &paned->handle_pos, FALSE);
}
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
if (gtk_widget_get_mapped (widget))
gdk_window_show (paned->handle);
{
GtkAllocation child_allocation;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
gdk_window_hide (paned->handle);
if (paned->child1)
GtkPaned *paned = GTK_PANED (widget);
GdkCursor *cursor;
- if (GTK_WIDGET_REALIZED (paned))
+ if (gtk_widget_get_realized (widget))
{
if (gtk_widget_is_sensitive (widget))
cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget),
get_child_panes (GtkWidget *widget,
GList **panes)
{
- if (!widget || !GTK_WIDGET_REALIZED (widget))
+ if (!widget || !gtk_widget_get_realized (widget))
return;
if (GTK_IS_PANED (widget))
widget->allocation = *allocation;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
gdk_window_move_resize (path_bar->event_window,
allocation->x, allocation->y,
allocation->width, allocation->height);
{
g_return_val_if_fail (GTK_IS_PLUG (plug), 0);
- if (!GTK_WIDGET_REALIZED (plug))
+ if (!gtk_widget_get_realized (GTK_WIDGET (plug)))
gtk_widget_realize (GTK_WIDGET (plug));
return _gtk_plug_windowing_get_id (plug);
g_return_if_fail (GTK_IS_PLUG (plug));
g_return_if_fail (GTK_IS_SOCKET (socket_));
- g_return_if_fail (GTK_WIDGET_REALIZED (socket_));
+ g_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (socket_)));
widget = GTK_WIDGET (plug);
g_signal_emit (plug, plug_signals[EMBEDDED], 0);
g_object_notify (G_OBJECT (plug), "embedded");
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gdk_drawable_get_size (GDK_DRAWABLE (widget->window), &w, &h);
gdk_window_reparent (widget->window, plug->socket_window, -w, -h);
g_return_if_fail (GTK_IS_PLUG (plug));
g_return_if_fail (GTK_IS_SOCKET (socket_));
- g_return_if_fail (GTK_WIDGET_REALIZED (plug));
+ g_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (plug)));
widget = GTK_WIDGET (plug);
widget->allocation = *allocation;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
gdk_window_move_resize (widget->window,
allocation->x, allocation->y,
allocation->width, allocation->height);
widget->allocation = *allocation;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
if (preview->expand)
{
GdkCursor *cursor;
toplevel = get_toplevel (GTK_WIDGET (dialog));
- if (!toplevel || !GTK_WIDGET_REALIZED (toplevel))
+ if (!toplevel || !gtk_widget_get_realized (GTK_WIDGET (toplevel)))
return;
display = gtk_widget_get_display (GTK_WIDGET (toplevel));
{
widget->allocation = *allocation;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gdk_window_move_resize (widget->window,
allocation->x, allocation->y,
g_return_if_fail (GTK_IS_PROGRESS (progress));
- if (GTK_WIDGET_REALIZED (progress))
- {
- widget = GTK_WIDGET (progress);
+ widget = GTK_WIDGET (progress);
+ if (gtk_widget_get_realized (widget))
+ {
if (progress->offscreen_pixmap)
g_object_unref (progress->offscreen_pixmap);
range->need_recalc = TRUE;
gtk_range_calc_layout (range, range->adjustment->value);
- if (GTK_WIDGET_REALIZED (range))
+ if (gtk_widget_get_realized (widget))
gdk_window_move_resize (range->event_window,
widget->allocation.x,
widget->allocation.y,
{
GtkRange *range = GTK_RANGE (widget);
- if (GTK_WIDGET_REALIZED (range))
+ if (gtk_widget_get_realized (widget))
{
GtkAdjustment *adj = GTK_RANGE (range)->adjustment;
gdouble delta;
GdkCursor *cursor;
toplevel = get_toplevel (GTK_WIDGET (impl));
- if (!toplevel || !GTK_WIDGET_REALIZED (toplevel))
+ if (!toplevel || !gtk_widget_get_realized (GTK_WIDGET (toplevel)))
return;
display = gtk_widget_get_display (GTK_WIDGET (toplevel));
gint monitor_num;
GdkRectangle monitor;
- if (G_UNLIKELY (!GTK_WIDGET_REALIZED (widget)))
+ if (G_UNLIKELY (!gtk_widget_get_realized (widget)))
return;
gdk_window_get_origin (widget->window, x, y);
widget->allocation = *allocation;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gdk_window_move_resize (widget->window,
allocation->x, allocation->y,
g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
g_return_val_if_fail (selection != GDK_NONE, FALSE);
- g_return_val_if_fail (widget == NULL || GTK_WIDGET_REALIZED (widget), FALSE);
+ g_return_val_if_fail (widget == NULL || gtk_widget_get_realized (widget), FALSE);
g_return_val_if_fail (widget == NULL || gtk_widget_get_display (widget) == display, FALSE);
if (widget == NULL)
{
GdkDisplay *display;
- g_return_val_if_fail (widget == NULL || GTK_WIDGET_REALIZED (widget), FALSE);
+ g_return_val_if_fail (widget == NULL || gtk_widget_get_realized (widget), FALSE);
g_return_val_if_fail (selection != GDK_NONE, FALSE);
if (widget)
if (initialize)
gtk_selection_init ();
- if (!GTK_WIDGET_REALIZED (widget))
+ if (!gtk_widget_get_realized (widget))
gtk_widget_realize (widget);
/* Check to see if there are already any retrievals in progress for
g_return_val_if_fail (GTK_IS_SOCKET (socket), 0);
g_return_val_if_fail (GTK_WIDGET_ANCHORED (socket), 0);
- if (!GTK_WIDGET_REALIZED (socket))
+ if (!gtk_widget_get_realized (socket))
gtk_widget_realize (GTK_WIDGET (socket));
return (GdkNativeWindow) GDK_WINDOW_HWND (GTK_WIDGET (socket)->window);
g_return_if_fail (GTK_IS_SOCKET (socket));
g_return_if_fail (GTK_WIDGET_ANCHORED (socket));
- if (!GTK_WIDGET_REALIZED (socket))
+ if (!gtk_widget_get_realized (GTK_WIDGET (socket)))
gtk_widget_realize (GTK_WIDGET (socket));
_gtk_socket_add_window (socket, wid, TRUE);
g_return_if_fail (GTK_IS_SOCKET (socket));
g_return_if_fail (GTK_WIDGET_ANCHORED (socket));
- if (!GTK_WIDGET_REALIZED (socket))
+ if (!gtk_widget_get_realized (GTK_WIDGET (socket)))
gtk_widget_realize (GTK_WIDGET (socket));
_gtk_socket_add_window (socket, window_id, TRUE);
g_return_val_if_fail (GTK_IS_SOCKET (socket), 0);
g_return_val_if_fail (GTK_WIDGET_ANCHORED (socket), 0);
- if (!GTK_WIDGET_REALIZED (socket))
+ if (!gtk_widget_get_realized (GTK_WIDGET (socket)))
gtk_widget_realize (GTK_WIDGET (socket));
return _gtk_socket_windowing_get_id (socket);
GtkSocket *socket = GTK_SOCKET (widget);
widget->allocation = *allocation;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gdk_window_move_resize (widget->window,
allocation->x, allocation->y,
static void
gtk_spin_button_map (GtkWidget *widget)
{
- if (GTK_WIDGET_REALIZED (widget) && !gtk_widget_get_mapped (widget))
+ if (gtk_widget_get_realized (widget) && !gtk_widget_get_mapped (widget))
{
GTK_WIDGET_CLASS (gtk_spin_button_parent_class)->map (widget);
gdk_window_show (GTK_SPIN_BUTTON (widget)->panel);
GTK_WIDGET_CLASS (gtk_spin_button_parent_class)->size_allocate (widget, allocation);
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gdk_window_move_resize (GTK_SPIN_BUTTON (widget)->panel,
panel_allocation.x,
{
GtkSpinButton *spin = GTK_SPIN_BUTTON (widget);
- if (previous_style && GTK_WIDGET_REALIZED (widget))
+ if (previous_style && gtk_widget_get_realized (widget))
gtk_style_set_background (widget->style, spin->panel, GTK_STATE_NORMAL);
GTK_WIDGET_CLASS (gtk_spin_button_parent_class)->style_set (widget, previous_style);
priv->active = active;
g_object_notify (G_OBJECT (spinner), "active");
- if (active && GTK_WIDGET_REALIZED (GTK_WIDGET (spinner)) && priv->timeout == 0)
+ if (active && gtk_widget_get_realized (GTK_WIDGET (spinner)) && priv->timeout == 0)
{
gtk_spinner_add_timeout (spinner);
}
gtk_widget_queue_resize (statusbar->label);
gtk_widget_queue_draw (GTK_WIDGET (statusbar));
- if (GTK_WIDGET_REALIZED (statusbar))
+ if (gtk_widget_get_realized (GTK_WIDGET (statusbar)))
{
if (statusbar->has_resize_grip && statusbar->grip_window == NULL)
{
gint attributes_mask;
GdkRectangle rect;
- g_return_if_fail (GTK_WIDGET_REALIZED (statusbar));
- g_return_if_fail (statusbar->has_resize_grip);
-
widget = GTK_WIDGET (statusbar);
+ g_return_if_fail (gtk_widget_get_realized (widget));
+ g_return_if_fail (statusbar->has_resize_grip);
+
get_grip_rect (statusbar, &rect);
attributes.x = rect.x;
#ifdef GDK_WINDOWING_X11
if (visible)
gtk_widget_show (priv->tray_icon);
- else if (GTK_WIDGET_REALIZED (priv->tray_icon))
+ else if (gtk_widget_get_realized (priv->tray_icon))
{
gtk_widget_hide (priv->tray_icon);
gtk_widget_unrealize (priv->tray_icon);
_gtk_widget_get_cursor_gc (GtkWidget *widget)
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
- g_return_val_if_fail (GTK_WIDGET_REALIZED (widget), NULL);
+ g_return_val_if_fail (gtk_widget_get_realized (widget), NULL);
return get_insertion_cursor_gc (widget, TRUE);
}
text->word_wrap = (word_wrap != FALSE);
- if (GTK_WIDGET_REALIZED (text))
+ if (gtk_widget_get_realized (GTK_WIDGET (text)))
{
recompute_geometry (text);
gtk_widget_queue_draw (GTK_WIDGET (text));
text->line_wrap = (line_wrap != FALSE);
- if (GTK_WIDGET_REALIZED (text))
+ if (gtk_widget_get_realized (GTK_WIDGET (text)))
{
recompute_geometry (text);
gtk_widget_queue_draw (GTK_WIDGET (text));
g_return_if_fail (GTK_IS_TEXT (text));
if (text->freeze_count)
- if (!(--text->freeze_count) && GTK_WIDGET_REALIZED (text))
+ if (!(--text->freeze_count) && gtk_widget_get_realized (GTK_WIDGET (text)))
{
recompute_geometry (text);
gtk_widget_queue_draw (GTK_WIDGET (text));
{
GtkText *text = GTK_TEXT (widget);
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gdk_window_set_background (widget->window, &widget->style->base[GTK_WIDGET_STATE (widget)]);
gdk_window_set_background (text->text_area, &widget->style->base[GTK_WIDGET_STATE (widget)]);
{
GtkText *text = GTK_TEXT (widget);
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gdk_window_set_background (widget->window, &widget->style->base[GTK_WIDGET_STATE (widget)]);
gdk_window_set_background (text->text_area, &widget->style->base[GTK_WIDGET_STATE (widget)]);
GtkText *text = GTK_TEXT (widget);
widget->allocation = *allocation;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gdk_window_move_resize (widget->window,
allocation->x, allocation->y,
prop->length = length;
- if (GTK_WIDGET_REALIZED (text))
+ if (gtk_widget_get_realized (GTK_WIDGET (text)))
realize_property (text, prop);
return prop;
{
/* Next property just has last position, take it over */
- if (GTK_WIDGET_REALIZED (text))
+ if (gtk_widget_get_realized (GTK_WIDGET (text)))
unrealize_property (text, forward_prop);
forward_prop->flags = 0;
}
forward_prop->length += len;
- if (GTK_WIDGET_REALIZED (text))
+ if (gtk_widget_get_realized (GTK_WIDGET (text)))
realize_property (text, forward_prop);
}
else
MARK_LIST_PTR (&text->point) = g_list_remove_link (tmp, tmp);
text->point.offset = 0;
- if (GTK_WIDGET_REALIZED (text))
+ if (gtk_widget_get_realized (GTK_WIDGET (text)))
unrealize_property (text, prop);
destroy_text_property (prop);
text->point.offset = MARK_CURRENT_PROPERTY(&text->point)->length - 1;
- if (GTK_WIDGET_REALIZED (text))
+ if (gtk_widget_get_realized (GTK_WIDGET (text)))
unrealize_property (text, prop);
destroy_text_property (prop);
static void
find_cursor (GtkText* text, gboolean scroll)
{
- if (GTK_WIDGET_REALIZED (text))
+ if (gtk_widget_get_realized (GTK_WIDGET (text)))
{
find_line_containing_point (text, text->cursor_mark.index, scroll);
gtk_text_view_paste_done_handler,
text_view);
- if (GTK_WIDGET_REALIZED (text_view))
+ if (gtk_widget_get_realized (GTK_WIDGET (text_view)))
{
GtkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET (text_view),
GDK_SELECTION_PRIMARY);
gtk_text_view_target_list_notify (text_view->buffer, NULL, text_view);
- if (GTK_WIDGET_REALIZED (text_view))
+ if (gtk_widget_get_realized (GTK_WIDGET (text_view)))
{
GtkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET (text_view),
GDK_SELECTION_PRIMARY);
widget->allocation = *allocation;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gdk_window_move_resize (widget->window,
allocation->x, allocation->y,
/* widget->window doesn't get auto-redrawn as the layout is computed, so has to
* be invalidated
*/
- if (size_changed && GTK_WIDGET_REALIZED (widget))
+ if (size_changed && gtk_widget_get_realized (widget))
gdk_window_invalidate_rect (widget->window, NULL, FALSE);
}
DV(g_print(">Lines Validated ("G_STRLOC")\n"));
- if (GTK_WIDGET_REALIZED (text_view))
+ if (gtk_widget_get_realized (widget))
{
gtk_text_view_get_visible_rect (text_view, &visible_rect);
GtkTextView *text_view = GTK_TEXT_VIEW (widget);
PangoContext *ltr_context, *rtl_context;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gtk_text_view_set_background (text_view);
}
GtkTextView *text_view = GTK_TEXT_VIEW (widget);
GdkCursor *cursor;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gtk_text_view_set_background (text_view);
* into widget->allocation if the widget is not realized.
* FIXME someone figure out why this was.
*/
- if (!GTK_WIDGET_REALIZED (widget))
+ if (!gtk_widget_get_realized (widget))
{
if (gtk_widget_get_visible (widget))
{
{
ScrollData scroll_data;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
scroll_data.window = ALLOCATION_WINDOW (widget);
else
scroll_data.window = NULL;
*/
if (text_view->width_changed)
{
- if (GTK_WIDGET_REALIZED (text_view))
+ if (gtk_widget_get_realized (GTK_WIDGET (text_view)))
gdk_window_invalidate_rect (text_view->text_window->bin_window, NULL, FALSE);
text_view->width_changed = FALSE;
{
GSList *tmp_list;
- if (GTK_WIDGET_REALIZED (text_view))
+ if (gtk_widget_get_realized (GTK_WIDGET (text_view)))
{
if (dy != 0)
{
gtk_text_view_validate_onscreen (text_view);
/* process exposes */
- if (GTK_WIDGET_REALIZED (text_view))
+ if (gtk_widget_get_realized (GTK_WIDGET (text_view)))
{
DV (g_print ("Processing updates (%s)\n", G_STRLOC));
text_view = GTK_TEXT_VIEW (user_data);
widget = GTK_WIDGET (text_view);
- g_return_if_fail (GTK_WIDGET_REALIZED (text_view));
+ g_return_if_fail (gtk_widget_get_realized (widget));
screen = gtk_widget_get_screen (widget);
PopupInfo *info = user_data;
GtkTextView *text_view = info->text_view;
- if (GTK_WIDGET_REALIZED (text_view))
+ if (gtk_widget_get_realized (GTK_WIDGET (text_view)))
{
/* We implicitely rely here on the fact that if we are pasting ourself, we'll
* have text targets as well as the private GTK_TEXT_BUFFER_CONTENTS target.
GTK_WIDGET (text_view),
width, 0);
/* if the widget is already realized we need to realize the child manually */
- if (GTK_WIDGET_REALIZED (text_view))
+ if (gtk_widget_get_realized (GTK_WIDGET (text_view)))
text_window_realize (*winp, GTK_WIDGET (text_view));
}
else
0, height);
/* if the widget is already realized we need to realize the child manually */
- if (GTK_WIDGET_REALIZED (text_view))
+ if (gtk_widget_get_realized (GTK_WIDGET (text_view)))
text_window_realize (*winp, GTK_WIDGET (text_view));
}
else
text_view->children = g_slist_prepend (text_view->children,
vc);
- if (GTK_WIDGET_REALIZED (text_view))
+ if (gtk_widget_get_realized (GTK_WIDGET (text_view)))
text_view_child_set_parent_window (text_view, vc);
gtk_widget_set_parent (vc->widget, GTK_WIDGET (text_view));
{
g_return_if_fail (GTK_IS_TIPS_QUERY (tips_query));
g_return_if_fail (tips_query->in_query == FALSE);
- g_return_if_fail (GTK_WIDGET_REALIZED (tips_query));
+ g_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (tips_query)));
tips_query->in_query = TRUE;
gtk_signal_emit (GTK_OBJECT (tips_query), tips_query_signals[SIGNAL_START_QUERY]);
border_width = GTK_CONTAINER (toolbar)->border_width;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gdk_window_move_resize (priv->event_window,
allocation->x + border_width,
priv->max_homogeneous_pixels = -1;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
gtk_style_set_background (widget->style, widget->window, widget->state);
if (prev_style)
if (use_drag_window)
{
- if (!toolitem->priv->drag_window && GTK_WIDGET_REALIZED (toolitem))
+ if (!toolitem->priv->drag_window &&
+ gtk_widget_get_realized (GTK_WIDGET (toolitem)))
{
create_drag_window(toolitem);
if (gtk_widget_get_mapped (GTK_WIDGET (toolitem)))
gtk_tool_item_group_force_expose (GtkToolItemGroup *group)
{
GtkToolItemGroupPrivate* priv = group->priv;
+ GtkWidget *widget = GTK_WIDGET (group);
- if (GTK_WIDGET_REALIZED (priv->header))
+ if (gtk_widget_get_realized (priv->header))
{
GtkWidget *alignment = gtk_tool_item_group_get_alignment (group);
GdkRectangle area;
gdk_window_invalidate_rect (priv->header->window, &area, TRUE);
}
- if (GTK_WIDGET_REALIZED (group))
+ if (gtk_widget_get_realized (widget))
{
- GtkWidget *widget = GTK_WIDGET (group);
GtkWidget *parent = gtk_widget_get_parent (widget);
int x, y, width, height;
gtk_tray_icon_get_orientation_property (icon);
gtk_tray_icon_get_visual_property (icon);
- if (GTK_WIDGET_REALIZED (icon))
+ if (gtk_widget_get_realized (GTK_WIDGET (icon)))
{
if ((icon->priv->manager_visual == NULL &&
gtk_widget_get_visual (widget) == gdk_screen_get_system_visual (screen)) ||
tree = GTK_TREE (widget);
widget->allocation = *allocation;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
gdk_window_move_resize (widget->window,
allocation->x, allocation->y,
allocation->width, allocation->height);
int temp;
widget->allocation = *allocation;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
gdk_window_move_resize (widget->window,
allocation->x, allocation->y,
allocation->width, allocation->height);
GtkWidget *widget = GTK_WIDGET (tree_view);
gboolean rtl;
- if (!GTK_WIDGET_REALIZED (widget))
+ if (!gtk_widget_get_realized (widget))
return;
rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
else
gtk_tree_view_dy_to_top_row (tree_view);
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gdk_window_move_resize (widget->window,
allocation->x, allocation->y,
if (tree_view->priv->tree == NULL)
invalidate_empty_focus (tree_view);
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gboolean has_expand_column = FALSE;
for (tmp_list = tree_view->priv->columns; tmp_list; tmp_list = tmp_list->next)
GdkRectangle arrow;
gint x2;
- if (!GTK_WIDGET_REALIZED (tree_view))
+ if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
return FALSE;
if ((node->flags & GTK_RBNODE_IS_PARENT) == 0)
static void
install_presize_handler (GtkTreeView *tree_view)
{
- if (! GTK_WIDGET_REALIZED (tree_view))
+ if (! gtk_widget_get_realized (GTK_WIDGET (tree_view)))
return;
if (! tree_view->priv->presize_handler_timer)
static void
install_scroll_sync_handler (GtkTreeView *tree_view)
{
- if (! GTK_WIDGET_REALIZED (tree_view))
+ if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
return;
if (!tree_view->priv->scroll_sync_timer)
GList *list;
GtkTreeViewColumn *column;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gdk_window_set_back_pixmap (widget->window, NULL, FALSE);
gdk_window_set_background (tree_view->priv->bin_window, &widget->style->base[widget->state]);
tree_view->priv->children = g_list_append (tree_view->priv->children, child);
- if (GTK_WIDGET_REALIZED (tree_view))
+ if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
gtk_widget_set_parent_window (child->widget, tree_view->priv->bin_window);
gtk_widget_set_parent (child_widget, GTK_WIDGET (tree_view));
allocation.width = child->width = width;
allocation.height = child->height = height;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
gtk_widget_size_allocate (widget, &allocation);
}
&& tree_view->priv->fixed_height >= 0)
{
_gtk_rbtree_node_set_height (tree, node, tree_view->priv->fixed_height);
- if (GTK_WIDGET_REALIZED (tree_view))
+ if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
gtk_tree_view_node_queue_redraw (tree_view, tree, node);
}
else
}
done:
- if (GTK_WIDGET_REALIZED (tree_view) && !tree_view->priv->fixed_height_mode)
+ if (!tree_view->priv->fixed_height_mode &&
+ gtk_widget_get_realized (GTK_WIDGET (tree_view)))
install_presize_handler (tree_view);
if (free_path)
gtk_tree_path_free (path);
gint node_dy, height;
GtkTreePath *path = NULL;
- if (!GTK_WIDGET_REALIZED (tree_view))
+ if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
return;
/* just return if the node is visible, avoiding a costly expose */
{
GdkRectangle rect;
- if (!GTK_WIDGET_REALIZED (tree_view))
+ if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
return;
rect.x = 0;
{
GdkRectangle rect;
- if (!GTK_WIDGET_REALIZED (tree_view))
+ if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
return;
rect.x = 0;
GtkTreePath *cursor_path;
if ((tree_view->priv->tree == NULL) ||
- (! GTK_WIDGET_REALIZED (tree_view)))
+ (! gtk_widget_get_realized (GTK_WIDGET (tree_view))))
return;
cursor_path = NULL;
* into widget->allocation if the widget is not realized.
* FIXME someone figure out why this was.
*/
- if (!GTK_WIDGET_REALIZED (widget))
+ if (!gtk_widget_get_realized (widget))
{
if (gtk_widget_get_visible (widget))
{
{
ScrollData scroll_data;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
scroll_data.window = ALLOCATION_WINDOW (widget);
else
scroll_data.window = NULL;
gtk_tree_view_adjustment_changed (GtkAdjustment *adjustment,
GtkTreeView *tree_view)
{
- if (GTK_WIDGET_REALIZED (tree_view))
+ if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
{
gint dy;
if (tree_view->priv->selection)
_gtk_tree_selection_emit_changed (tree_view->priv->selection);
- if (GTK_WIDGET_REALIZED (tree_view))
+ if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
gtk_widget_queue_resize (GTK_WIDGET (tree_view));
}
else
GTK_TREE_VIEW_UNSET_FLAG (tree_view, GTK_TREE_VIEW_HEADERS_VISIBLE);
- if (GTK_WIDGET_REALIZED (tree_view))
+ if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
{
gdk_window_get_position (tree_view->priv->bin_window, &x, &y);
if (headers_visible)
tree_view->priv->columns = g_list_remove (tree_view->priv->columns, column);
tree_view->priv->n_columns--;
- if (GTK_WIDGET_REALIZED (tree_view))
+ if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
{
GList *list;
g_object_ref_sink (column);
if (tree_view->priv->n_columns == 0 &&
- GTK_WIDGET_REALIZED (tree_view) &&
+ gtk_widget_get_realized (GTK_WIDGET (tree_view)) &&
gtk_tree_view_get_headers_visible (tree_view))
{
gdk_window_show (tree_view->priv->header_window);
_gtk_tree_view_column_set_tree_view (column, tree_view);
- if (GTK_WIDGET_REALIZED (tree_view))
+ if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
{
GList *list;
base_el->next = column_list_el;
}
- if (GTK_WIDGET_REALIZED (tree_view))
+ if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
{
gtk_widget_queue_resize (GTK_WIDGET (tree_view));
gtk_tree_view_size_allocate_columns (GTK_WIDGET (tree_view), NULL);
GtkAdjustment *vadj;
g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
- g_return_if_fail (GTK_WIDGET_REALIZED (tree_view));
+ g_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (tree_view)));
hadj = tree_view->priv->hadjustment;
vadj = tree_view->priv->vadjustment;
* scrolling code, we short-circuit validate_visible_area's immplementation as
* it is much slower than just going to the point.
*/
- if (! gtk_widget_get_visible (GTK_WIDGET (tree_view)) ||
- ! GTK_WIDGET_REALIZED (tree_view) ||
+ if (!gtk_widget_get_visible (GTK_WIDGET (tree_view)) ||
+ !gtk_widget_get_realized (GTK_WIDGET (tree_view)) ||
GTK_WIDGET_ALLOC_NEEDED (tree_view) ||
GTK_RBNODE_FLAG_SET (tree_view->priv->tree->root, GTK_RBNODE_DESCENDANTS_INVALID))
{
g_return_if_fail (column == NULL || GTK_IS_TREE_VIEW_COLUMN (column));
g_return_if_fail (rect != NULL);
g_return_if_fail (!column || column->tree_view == (GtkWidget *) tree_view);
- g_return_if_fail (GTK_WIDGET_REALIZED (tree_view));
+ g_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (tree_view)));
gtk_widget_style_get (GTK_WIDGET (tree_view),
"vertical-separator", &vertical_separator,
widget = GTK_WIDGET (tree_view);
- if (!GTK_WIDGET_REALIZED (tree_view))
+ if (!gtk_widget_get_realized (widget))
return NULL;
depth = gtk_tree_path_get_depth (path);
g_assert (tree_view->priv->focus_column);
- if (! GTK_WIDGET_REALIZED (tree_view))
+ if (!gtk_widget_get_realized (GTK_WIDGET (tree_view)))
return FALSE;
if (_gtk_tree_view_find_node (tree_view, cursor_path, &cursor_tree, &cursor_node) ||
{
GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gdk_window_set_back_pixmap (widget->window, NULL, FALSE);
gdk_window_set_background (tree_view->priv->bin_window, &widget->style->base[widget->state]);
old_grid_lines = priv->grid_lines;
priv->grid_lines = grid_lines;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
if (grid_lines == GTK_TREE_VIEW_GRID_LINES_NONE &&
priv->grid_line_gc)
priv->tree_lines_enabled = enabled;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
if (!enabled && priv->tree_line_gc)
{
if (tree_column->visible &&
tree_column->button == NULL &&
tree_column->tree_view &&
- GTK_WIDGET_REALIZED (tree_column->tree_view))
+ gtk_widget_get_realized (tree_column->tree_view))
gtk_tree_view_column_create_button (tree_column);
if (! tree_column->button)
* if you show it before it's realized, it'll get the wrong window. */
if (tree_column->button &&
tree_column->tree_view != NULL &&
- GTK_WIDGET_REALIZED (tree_column->tree_view))
+ gtk_widget_get_realized (tree_column->tree_view))
{
if (tree_column->visible)
{
/* Queue a resize on the assumption that we always want to catch all changes
* and columns don't change all that often.
*/
- if (GTK_WIDGET_REALIZED (tree_column->tree_view))
+ if (gtk_widget_get_realized (tree_column->tree_view))
gtk_widget_queue_resize (tree_column->tree_view);
}
rtl = (gtk_widget_get_direction (GTK_WIDGET (tree_view)) == GTK_TEXT_DIR_RTL);
g_return_if_fail (GTK_IS_TREE_VIEW (tree_view));
- g_return_if_fail (GTK_WIDGET_REALIZED (tree_view));
+ g_return_if_fail (gtk_widget_get_realized (GTK_WIDGET (tree_view)));
g_return_if_fail (tree_view->priv->header_window != NULL);
g_return_if_fail (column->button != NULL);
tree_column->use_resized_width = FALSE;
if (tree_column->tree_view &&
- GTK_WIDGET_REALIZED (tree_column->tree_view) &&
+ gtk_widget_get_realized (tree_column->tree_view) &&
tree_column->column_type == GTK_TREE_VIEW_COLUMN_FIXED)
{
gtk_widget_queue_resize (tree_column->tree_view);
if (tree_column->visible &&
tree_column->tree_view != NULL &&
- GTK_WIDGET_REALIZED (tree_column->tree_view))
+ gtk_widget_get_realized (tree_column->tree_view))
{
if (min_width > tree_column->width)
gtk_widget_queue_resize (tree_column->tree_view);
if (tree_column->visible &&
tree_column->tree_view != NULL &&
- GTK_WIDGET_REALIZED (tree_column->tree_view))
+ gtk_widget_get_realized (tree_column->tree_view))
{
if (max_width != -1 && max_width < tree_column->width)
gtk_widget_queue_resize (tree_column->tree_view);
if (tree_column->visible &&
tree_column->tree_view != NULL &&
- GTK_WIDGET_REALIZED (tree_column->tree_view))
+ gtk_widget_get_realized (tree_column->tree_view))
{
/* We want to continue using the original width of the
* column that includes additional space added by the user
tree_column->width = 0;
if (tree_column->tree_view &&
- GTK_WIDGET_REALIZED (tree_column->tree_view))
+ gtk_widget_get_realized (tree_column->tree_view))
{
if (install_handler)
_gtk_tree_view_install_mark_rows_col_dirty (GTK_TREE_VIEW (tree_column->tree_view));
child_allocation.y = 0;
child_allocation.width = hadjustment->upper;
child_allocation.height = vadjustment->upper;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
GtkAllocation view_allocation;
gdk_window_move_resize (widget->window,
GtkViewport *viewport = GTK_VIEWPORT (data);
GtkBin *bin = GTK_BIN (data);
- if (bin->child && gtk_widget_get_visible (bin->child) &&
- GTK_WIDGET_REALIZED (viewport))
+ if (bin->child && gtk_widget_get_visible (bin->child) &&
+ gtk_widget_get_realized (GTK_WIDGET (viewport)))
{
GtkAdjustment *hadjustment = gtk_viewport_get_hadjustment (viewport);
GtkAdjustment *vadjustment = gtk_viewport_get_vadjustment (viewport);
gtk_viewport_style_set (GtkWidget *widget,
GtkStyle *previous_style)
{
- if (GTK_WIDGET_REALIZED (widget) &&
+ if (gtk_widget_get_realized (widget) &&
gtk_widget_get_has_window (widget))
{
GtkViewport *viewport = GTK_VIEWPORT (widget);
gtk_widget_set_style (widget, g_value_get_object (value));
break;
case PROP_EVENTS:
- if (!GTK_WIDGET_REALIZED (widget) && gtk_widget_get_has_window (widget))
+ if (!gtk_widget_get_realized (widget) && gtk_widget_get_has_window (widget))
gtk_widget_set_events (widget, g_value_get_flags (value));
break;
case PROP_EXTENSION_EVENTS:
widget->allocation.width = 1;
widget->allocation.height = 1;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
if (GTK_WIDGET_IN_REPARENT (widget))
gtk_widget_unmap (widget);
if (!gtk_widget_get_mapped (widget))
{
- if (!GTK_WIDGET_REALIZED (widget))
+ if (!gtk_widget_get_realized (widget))
gtk_widget_realize (widget);
g_signal_emit (widget, widget_signals[MAP], 0);
g_return_if_fail (GTK_WIDGET_ANCHORED (widget) ||
GTK_IS_INVISIBLE (widget));
- if (!GTK_WIDGET_REALIZED (widget))
+ if (!gtk_widget_get_realized (widget))
{
/*
if (GTK_IS_CONTAINER (widget) && gtk_widget_get_has_window (widget))
"inside a toplevel window is not going to work very well. "
"Widgets must be inside a toplevel container before realizing them.");
- if (widget->parent && !GTK_WIDGET_REALIZED (widget->parent))
+ if (widget->parent && !gtk_widget_get_realized (widget->parent))
gtk_widget_realize (widget->parent);
gtk_widget_ensure_style (widget);
if (g_object_get_qdata (G_OBJECT (widget), quark_input_shape_info))
gtk_widget_input_shape_combine_mask (widget, NULL, 0, 0);
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
g_object_ref (widget);
_gtk_tooltip_hide (widget);
g_return_if_fail (GTK_IS_WIDGET (widget));
- if (!GTK_WIDGET_REALIZED (widget))
+ if (!gtk_widget_get_realized (widget))
return;
/* Just return if the widget or one of its ancestors isn't mapped */
{
g_return_if_fail (GTK_IS_WIDGET (widget));
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
gtk_widget_queue_shallow_draw (widget);
_gtk_size_group_queue_resize (widget);
gtk_widget_invalidate_widget_windows (GtkWidget *widget,
GdkRegion *region)
{
- if (!GTK_WIDGET_REALIZED (widget))
+ if (!gtk_widget_get_realized (widget))
return;
if (gtk_widget_get_has_window (widget) && widget->parent)
GdkRectangle rect;
GdkRegion *region;
- if (!GTK_WIDGET_REALIZED (widget))
+ if (!gtk_widget_get_realized (widget))
return;
gtk_widget_get_draw_rectangle (widget, &rect);
}
if ((size_changed || position_changed) && widget->parent &&
- GTK_WIDGET_REALIZED (widget->parent) && GTK_CONTAINER (widget->parent)->reallocate_redraws)
+ gtk_widget_get_realized (widget->parent) && GTK_CONTAINER (widget->parent)->reallocate_redraws)
{
GdkRegion *invalidate = gdk_region_rectangle (&widget->parent->allocation);
gtk_widget_invalidate_widget_windows (widget->parent, invalidate);
g_return_val_if_fail (GTK_IS_WIDGET (dest_widget), FALSE);
ancestor = gtk_widget_common_ancestor (src_widget, dest_widget);
- if (!ancestor || !GTK_WIDGET_REALIZED (src_widget) || !GTK_WIDGET_REALIZED (dest_widget))
+ if (!ancestor || !gtk_widget_get_realized (src_widget) || !gtk_widget_get_realized (dest_widget))
return FALSE;
/* Translate from allocation relative to window relative */
{
widget->allocation = *allocation;
- if (GTK_WIDGET_REALIZED (widget) &&
+ if (gtk_widget_get_realized (widget) &&
gtk_widget_get_has_window (widget))
{
gdk_window_move_resize (widget->window,
}
#define WIDGET_REALIZED_FOR_EVENT(widget, event) \
- (event->type == GDK_FOCUS_CHANGE || GTK_WIDGET_REALIZED(widget))
+ (event->type == GDK_FOCUS_CHANGE || gtk_widget_get_realized(widget))
/**
* gtk_widget_event:
GdkEvent *event)
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), TRUE);
- g_return_val_if_fail (GTK_WIDGET_REALIZED (widget), TRUE);
+ g_return_val_if_fail (gtk_widget_get_realized (widget), TRUE);
g_return_val_if_fail (event != NULL, TRUE);
g_return_val_if_fail (event->type == GDK_EXPOSE, TRUE);
* the widget as we reparent it. if so we set a flag so
* that gtk_widget_unparent doesn't unrealize widget
*/
- if (GTK_WIDGET_REALIZED (widget) && GTK_WIDGET_REALIZED (new_parent))
+ if (gtk_widget_get_realized (widget) && gtk_widget_get_realized (new_parent))
GTK_PRIVATE_SET_FLAG (widget, GTK_IN_REPARENT);
g_object_ref (widget);
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
- return (GTK_WIDGET_FLAGS (widget) & GTK_REALIZED) != 0;
+ return (GTK_OBJECT_FLAGS (widget) & GTK_REALIZED) != 0;
}
/**
/* Enforce realized/mapped invariants
*/
- if (GTK_WIDGET_REALIZED (widget->parent))
+ if (gtk_widget_get_realized (widget->parent))
gtk_widget_realize (widget);
if (gtk_widget_get_visible (widget->parent) &&
gtk_widget_style_attach (GtkWidget *widget)
{
g_return_if_fail (GTK_IS_WIDGET (widget));
- g_return_if_fail (GTK_WIDGET_REALIZED (widget));
+ g_return_if_fail (gtk_widget_get_realized (widget));
widget->style = gtk_style_attach (widget->style, widget->window);
}
gtk_widget_real_style_set (GtkWidget *widget,
GtkStyle *previous_style)
{
- if (GTK_WIDGET_REALIZED (widget) &&
+ if (gtk_widget_get_realized (widget) &&
gtk_widget_get_has_window (widget))
gtk_style_set_background (widget->style, widget->window, widget->state);
}
{
GtkStyle *previous_style;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gtk_widget_reset_shapes (widget);
gtk_style_detach (widget->style);
widget->style = style;
g_object_ref (widget->style);
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
widget->style = gtk_style_attach (widget->style, widget->window);
gtk_widget_update_pango_context (widget);
_gtk_window_unset_focus_and_default (GTK_WINDOW (toplevel), widget);
}
- if (widget->parent && GTK_WIDGET_REALIZED (widget->parent))
+ if (widget->parent && gtk_widget_get_realized (widget->parent))
{
if (gtk_widget_get_mapped (widget->parent) &&
GTK_WIDGET_CHILD_VISIBLE (widget) &&
gint events)
{
g_return_if_fail (GTK_IS_WIDGET (widget));
- g_return_if_fail (!GTK_WIDGET_REALIZED (widget));
+ g_return_if_fail (!gtk_widget_get_realized (widget));
g_object_set_qdata (G_OBJECT (widget), quark_event_mask,
GINT_TO_POINTER (events));
g_object_set_qdata (G_OBJECT (widget), quark_event_mask,
GINT_TO_POINTER (old_events | events));
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
GList *window_list;
{
g_return_if_fail (GTK_IS_WIDGET (widget));
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
gtk_widget_set_extension_events_internal (widget, mode, NULL);
g_object_set_qdata (G_OBJECT (widget), quark_extension_event_mode,
GdkColormap *colormap)
{
g_return_if_fail (GTK_IS_WIDGET (widget));
- g_return_if_fail (!GTK_WIDGET_REALIZED (widget));
+ g_return_if_fail (!gtk_widget_get_realized (widget));
g_return_if_fail (GDK_IS_COLORMAP (colormap));
g_object_ref (colormap);
if (y)
*y = -1;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
gdk_window_get_pointer (widget->window, x, y, NULL);
gtk_widget_hide (widget);
GTK_WIDGET_UNSET_FLAGS (widget, GTK_VISIBLE);
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
gtk_widget_unrealize (widget);
G_OBJECT_CLASS (gtk_widget_parent_class)->dispose (object);
static void
gtk_widget_real_map (GtkWidget *widget)
{
- g_assert (GTK_WIDGET_REALIZED (widget));
+ g_assert (gtk_widget_get_realized (widget));
if (!gtk_widget_get_mapped (widget))
{
{
g_return_if_fail (GTK_IS_WIDGET (widget));
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
GdkScreen *screen = gdk_drawable_get_screen (widget->window);
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
GdkScreen *screen = gdk_drawable_get_screen (widget->window);
gtk_widget_reset_shapes (GtkWidget *widget)
{
g_return_if_fail (GTK_IS_WIDGET (widget));
- g_return_if_fail (GTK_WIDGET_REALIZED (widget));
+ g_return_if_fail (gtk_widget_get_realized (widget));
if (!GTK_WIDGET_HAS_SHAPE_MASK (widget))
gtk_reset_shapes_recurse (widget, widget->window);
return NULL;
/* the widget (and parent_window) must be realized to be drawable */
- if (widget->parent && !GTK_WIDGET_REALIZED (widget->parent))
+ if (widget->parent && !gtk_widget_get_realized (widget->parent))
gtk_widget_realize (widget->parent);
- if (!GTK_WIDGET_REALIZED (widget))
+ if (!gtk_widget_get_realized (widget))
gtk_widget_realize (widget);
/* determine snapshot rectangle */
if (priv_has_tooltip)
{
- if (GTK_WIDGET_REALIZED (widget) && !gtk_widget_get_has_window (widget))
+ if (gtk_widget_get_realized (widget) && !gtk_widget_get_has_window (widget))
gdk_window_set_events (widget->window,
gdk_window_get_events (widget->window) |
GDK_LEAVE_NOTIFY_MASK |
#define GTK_WIDGET_NO_WINDOW(wid) ((GTK_WIDGET_FLAGS (wid) & GTK_NO_WINDOW) != 0)
#endif
+#ifndef GTK_DISABLE_DEPRECATED
/**
* GTK_WIDGET_REALIZED:
* @wid: a #GtkWidget.
*
* Evaluates to %TRUE if the widget is realized.
+ *
+ * Deprecated: 2.20: Use gtk_widget_get_realized() instead.
*/
#define GTK_WIDGET_REALIZED(wid) ((GTK_WIDGET_FLAGS (wid) & GTK_REALIZED) != 0)
+#endif
#ifndef GTK_DISABLE_DEPRECATED
/**
_gtk_container_queue_resize (GTK_CONTAINER (widget));
- g_return_if_fail (!GTK_WIDGET_REALIZED (widget));
+ g_return_if_fail (!gtk_widget_get_realized (widget));
}
GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
widget->allocation = *allocation;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
gdk_window_move_resize (widget->window,
allocation->x, allocation->y,
allocation->width, allocation->height);
g_free (window->title);
window->title = new_title;
- if (GTK_WIDGET_REALIZED (window))
+ if (gtk_widget_get_realized (GTK_WIDGET (window)))
{
gdk_window_set_title (GTK_WIDGET (window)->window, window->title);
g_free (window->wmclass_class);
window->wmclass_class = g_strdup (wmclass_class);
- if (GTK_WIDGET_REALIZED (window))
+ if (gtk_widget_get_realized (GTK_WIDGET (window)))
g_warning ("gtk_window_set_wmclass: shouldn't set wmclass after window is realized!\n");
}
g_free (window->wm_role);
window->wm_role = new_role;
- if (GTK_WIDGET_REALIZED (window))
+ if (gtk_widget_get_realized (GTK_WIDGET (window)))
gdk_window_set_role (GTK_WIDGET (window)->window, window->wm_role);
g_object_notify (G_OBJECT (window), "role");
g_free (priv->startup_id);
priv->startup_id = g_strdup (startup_id);
- if (GTK_WIDGET_REALIZED (window))
+ if (gtk_widget_get_realized (GTK_WIDGET (window)))
{
guint32 timestamp = extract_time_from_startup_id (priv->startup_id);
widget = GTK_WIDGET (window);
/* adjust desired modality state */
- if (GTK_WIDGET_REALIZED (window))
+ if (gtk_widget_get_realized (widget))
{
if (window->modal)
gdk_window_set_modal_hint (widget->window, TRUE);
gtk_window_transient_parent_realized (GtkWidget *parent,
GtkWidget *window)
{
- if (GTK_WIDGET_REALIZED (window))
+ if (gtk_widget_get_realized (GTK_WIDGET (window)))
gdk_window_set_transient_for (window->window, parent->window);
}
gtk_window_transient_parent_unrealized (GtkWidget *parent,
GtkWidget *window)
{
- if (GTK_WIDGET_REALIZED (window))
+ if (gtk_widget_get_realized (GTK_WIDGET (window)))
gdk_property_delete (window->window,
gdk_atom_intern_static_string ("WM_TRANSIENT_FOR"));
}
gtk_window_set_transient_for (GtkWindow *window,
GtkWindow *parent)
{
- GtkWindowPrivate *priv = GTK_WINDOW_GET_PRIVATE (window);
+ GtkWindowPrivate *priv;
g_return_if_fail (GTK_IS_WINDOW (window));
g_return_if_fail (parent == NULL || GTK_IS_WINDOW (parent));
g_return_if_fail (window != parent);
+ priv = GTK_WINDOW_GET_PRIVATE (window);
+
if (window->transient_parent)
{
- if (GTK_WIDGET_REALIZED (window) &&
- GTK_WIDGET_REALIZED (window->transient_parent) &&
- (!parent || !GTK_WIDGET_REALIZED (parent)))
+ if (gtk_widget_get_realized (GTK_WIDGET (window)) &&
+ gtk_widget_get_realized (GTK_WIDGET (window->transient_parent)) &&
+ (!parent || !gtk_widget_get_realized (GTK_WIDGET (parent))))
gtk_window_transient_parent_unrealized (GTK_WIDGET (window->transient_parent),
GTK_WIDGET (window));
if (window->destroy_with_parent)
connect_parent_destroyed (window);
- if (GTK_WIDGET_REALIZED (window) &&
- GTK_WIDGET_REALIZED (parent))
+ if (gtk_widget_get_realized (GTK_WIDGET (window)) &&
+ gtk_widget_get_realized (GTK_WIDGET (parent)))
gtk_window_transient_parent_realized (GTK_WIDGET (parent),
GTK_WIDGET (window));
priv->opacity_set = TRUE;
priv->opacity = opacity;
- if (GTK_WIDGET_REALIZED (window))
+ if (gtk_widget_get_realized (GTK_WIDGET (window)))
gdk_window_set_opacity (GTK_WIDGET (window)->window, priv->opacity);
}
if (priv->skips_taskbar != setting)
{
priv->skips_taskbar = setting;
- if (GTK_WIDGET_REALIZED (window))
+ if (gtk_widget_get_realized (GTK_WIDGET (window)))
gdk_window_set_skip_taskbar_hint (GTK_WIDGET (window)->window,
priv->skips_taskbar);
g_object_notify (G_OBJECT (window), "skip-taskbar-hint");
if (priv->skips_pager != setting)
{
priv->skips_pager = setting;
- if (GTK_WIDGET_REALIZED (window))
+ if (gtk_widget_get_realized (GTK_WIDGET (window)))
gdk_window_set_skip_pager_hint (GTK_WIDGET (window)->window,
priv->skips_pager);
g_object_notify (G_OBJECT (window), "skip-pager-hint");
if (priv->urgent != setting)
{
priv->urgent = setting;
- if (GTK_WIDGET_REALIZED (window))
+ if (gtk_widget_get_realized (GTK_WIDGET (window)))
gdk_window_set_urgency_hint (GTK_WIDGET (window)->window,
priv->urgent);
g_object_notify (G_OBJECT (window), "urgency-hint");
if (priv->accept_focus != setting)
{
priv->accept_focus = setting;
- if (GTK_WIDGET_REALIZED (window))
+ if (gtk_widget_get_realized (GTK_WIDGET (window)))
gdk_window_set_accept_focus (GTK_WIDGET (window)->window,
priv->accept_focus);
g_object_notify (G_OBJECT (window), "accept-focus");
if (priv->focus_on_map != setting)
{
priv->focus_on_map = setting;
- if (GTK_WIDGET_REALIZED (window))
+ if (gtk_widget_get_realized (GTK_WIDGET (window)))
gdk_window_set_focus_on_map (GTK_WIDGET (window)->window,
priv->focus_on_map);
g_object_notify (G_OBJECT (window), "focus-on-map");
gtk_window_unrealize_icon (window);
- if (GTK_WIDGET_REALIZED (window))
+ if (gtk_widget_get_realized (GTK_WIDGET (window)))
gtk_window_realize_icon (window);
/* We could try to update our transient children, but I don't think
gtk_window_unrealize_icon (window);
- if (GTK_WIDGET_REALIZED (window))
+ if (gtk_widget_get_realized (GTK_WIDGET (window)))
gtk_window_realize_icon (window);
}
if (info && info->using_default_icon)
{
gtk_window_unrealize_icon (w);
- if (GTK_WIDGET_REALIZED (w))
+ if (gtk_widget_get_realized (GTK_WIDGET (w)))
gtk_window_realize_icon (w);
}
if (info && info->using_default_icon && info->using_themed_icon)
{
gtk_window_unrealize_icon (w);
- if (GTK_WIDGET_REALIZED (w))
+ if (gtk_widget_get_realized (GTK_WIDGET (w)))
gtk_window_realize_icon (w);
}
GTK_WIDGET_SET_FLAGS (widget, GTK_VISIBLE);
- need_resize = container->need_resize || !GTK_WIDGET_REALIZED (widget);
+ need_resize = container->need_resize || !gtk_widget_get_realized (widget);
container->need_resize = FALSE;
if (need_resize)
/* Then we guarantee we have a realize */
was_realized = FALSE;
- if (!GTK_WIDGET_REALIZED (widget))
+ if (!gtk_widget_get_realized (widget))
{
gtk_widget_realize (widget);
was_realized = TRUE;
_gtk_container_queue_resize (GTK_CONTAINER (widget));
- g_return_if_fail (!GTK_WIDGET_REALIZED (widget));
+ g_return_if_fail (!gtk_widget_get_realized (widget));
}
GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
gtk_window_paint (widget, NULL);
if (window->transient_parent &&
- GTK_WIDGET_REALIZED (window->transient_parent))
+ gtk_widget_get_realized (GTK_WIDGET (window->transient_parent)))
gdk_window_set_transient_for (widget->window,
GTK_WIDGET (window->transient_parent)->window);
gtk_widget_size_allocate (window->bin.child, &child_allocation);
}
- if (GTK_WIDGET_REALIZED (widget) && window->frame)
+ if (gtk_widget_get_realized (widget) && window->frame)
{
gdk_window_resize (window->frame,
allocation->width + window->frame_left + window->frame_right,
gboolean setting)
{
g_return_if_fail (GTK_IS_WINDOW (window));
- g_return_if_fail (!GTK_WIDGET_REALIZED (window));
+ g_return_if_fail (!gtk_widget_get_realized (GTK_WIDGET (window)));
window->has_frame = setting != FALSE;
}
window->frame_right = right;
window->frame_bottom = bottom;
- if (GTK_WIDGET_REALIZED (widget) && window->frame)
+ if (gtk_widget_get_realized (widget) && window->frame)
{
gint width = widget->allocation.width + left + right;
gint height = widget->allocation.height + top + bottom;
if (was_mapped)
gtk_widget_unmap (widget);
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
gtk_widget_unrealize (widget);
gtk_window_free_key_hash (window);
gtk_tree_path_free (path);
}
}
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
g_signal_emit_by_name (gailview, "selection_changed");
}
GdkRectangle cell_rect;
/* Get these three values in tree coords */
- if (GTK_WIDGET_REALIZED (GTK_WIDGET (tree_view)))
+ if (gtk_widget_get_realized (GTK_WIDGET (tree_view)))
gtk_tree_view_get_cell_area (tree_view, tree_path, tv_col, &cell_rect);
else
cell_rect.height = 0;
border_width = GTK_CONTAINER (widget)->border_width;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
gdk_window_move_resize (widget->window,
allocation->x + border_width,
allocation->y + border_width,
start_y += CHILD1_SIZE_SCALE * child_requisition.height;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
gdk_window_move_resize (offscreen_box->offscreen_window1,
child_allocation.x,
child_allocation.y,
start_y += CHILD2_SIZE_SCALE * child_requisition.height;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
gdk_window_move_resize (offscreen_box->offscreen_window2,
child_allocation.x,
child_allocation.y,
gint *old_value = g_object_get_data (G_OBJECT (adj), "old-value");
gint new_value = adj->value;
- if (GTK_WIDGET_REALIZED (darea))
+ if (gtk_widget_get_realized (darea))
{
gdk_window_scroll (darea->window, *old_value - new_value, 0);
*old_value = new_value;
gint *old_value = g_object_get_data (G_OBJECT (adj), "old-value");
gint new_value = adj->value;
- if (GTK_WIDGET_REALIZED (darea))
+ if (gtk_widget_get_realized (darea))
{
gdk_window_scroll (darea->window, 0, *old_value - new_value);
*old_value = new_value;
{
GtkWidget *toolbar;
- if (!GTK_WIDGET_REALIZED (window))
+ if (!gtk_widget_get_realized (window))
gtk_widget_realize (window);
toolbar = gtk_toolbar_new ();
gtk_widget_show_all (window);
- if (GTK_WIDGET_REALIZED (window))
+ if (gtk_widget_get_realized (window))
#if defined (GDK_WINDOWING_X11)
return GDK_WINDOW_XID (window->window);
#elif defined (GDK_WINDOWING_WIN32)