*
* GtkWidget is the base class all widgets in GTK+ derive from. It manages the
* widget lifecycle, states and style.
+ *
* <refsect2 id="style-properties">
* <para>
* <structname>GtkWidget</structname> introduces <firstterm>style
static void gtk_widget_buildable_parser_finished (GtkBuildable *buildable,
GtkBuilder *builder);
-static void gtk_widget_layout_interface_init (GtkExtendedLayoutIface *iface);
-static void gtk_widget_real_get_desired_size (GtkExtendedLayout *layout,
- GtkRequisition *minimum_size,
- GtkRequisition *natural_size);
+static void gtk_widget_extended_layout_init (GtkExtendedLayoutIface *iface);
+static void gtk_widget_real_get_desired_width (GtkExtendedLayout *layout,
+ gint *minimum_size,
+ gint *natural_size);
+static void gtk_widget_real_get_desired_height (GtkExtendedLayout *layout,
+ gint *minimum_size,
+ gint *natural_size);
static void gtk_widget_queue_tooltip_query (GtkWidget *widget);
const GInterfaceInfo layout_info =
{
- (GInterfaceInitFunc) gtk_widget_layout_interface_init,
+ (GInterfaceInitFunc) gtk_widget_extended_layout_init,
(GInterfaceFinalizeFunc) NULL,
NULL /* interface data */
};
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:
g_value_set_boolean (value, (gtk_widget_get_receives_default (widget) != FALSE));
break;
case PROP_COMPOSITE_CHILD:
- g_value_set_boolean (value, (GTK_WIDGET_FLAGS (widget) & GTK_COMPOSITE_CHILD) != 0 );
+ g_value_set_boolean (value, (GTK_OBJECT_FLAGS (widget) & GTK_COMPOSITE_CHILD) != 0 );
break;
case PROP_STYLE:
g_value_set_object (value, gtk_widget_get_style (widget));
if (escaped && !pango_parse_markup (escaped, -1, 0, NULL, &text, NULL, NULL))
g_assert (NULL == text); /* text should still be NULL in case of markup errors */
- g_value_set_string (value, text);
- g_free (text);
+ g_value_take_string (value, text);
}
break;
case PROP_TOOLTIP_MARKUP:
widget->window = NULL;
widget->parent = NULL;
- GTK_WIDGET_SET_FLAGS (widget,
- GTK_SENSITIVE |
- GTK_PARENT_SENSITIVE |
- (composite_child_stack ? GTK_COMPOSITE_CHILD : 0) |
- GTK_DOUBLE_BUFFERED);
+ GTK_OBJECT_FLAGS (widget) |= GTK_SENSITIVE;
+ GTK_OBJECT_FLAGS (widget) |= GTK_PARENT_SENSITIVE;
+ GTK_OBJECT_FLAGS (widget) |= composite_child_stack ? GTK_COMPOSITE_CHILD : 0;
+ gtk_widget_set_double_buffered (widget, TRUE);
GTK_PRIVATE_SET_FLAG (widget, GTK_REDRAW_ON_ALLOC);
GTK_PRIVATE_SET_FLAG (widget, GTK_REQUEST_NEEDED);
+ GTK_PRIVATE_SET_FLAG (widget, GTK_WIDTH_REQUEST_NEEDED);
+ GTK_PRIVATE_SET_FLAG (widget, GTK_HEIGHT_REQUEST_NEEDED);
GTK_PRIVATE_SET_FLAG (widget, GTK_ALLOC_NEEDED);
widget->style = gtk_widget_get_default_style ();
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);
GTK_WIDGET_SET_FLAGS (widget, GTK_VISIBLE);
if (widget->parent &&
- GTK_WIDGET_MAPPED (widget->parent) &&
+ gtk_widget_get_mapped (widget->parent) &&
GTK_WIDGET_CHILD_VISIBLE (widget) &&
- !GTK_WIDGET_MAPPED (widget))
+ !gtk_widget_get_mapped (widget))
gtk_widget_map (widget);
}
}
g_return_if_fail (GTK_IS_WIDGET (widget));
/* make sure we will get event */
- if (!GTK_WIDGET_MAPPED (widget) &&
+ if (!gtk_widget_get_mapped (widget) &&
gtk_widget_is_toplevel (widget))
{
gtk_widget_show (widget);
{
GTK_WIDGET_UNSET_FLAGS (widget, GTK_VISIBLE);
- if (GTK_WIDGET_MAPPED (widget))
+ if (gtk_widget_get_mapped (widget))
gtk_widget_unmap (widget);
}
}
g_return_if_fail (gtk_widget_get_visible (widget));
g_return_if_fail (GTK_WIDGET_CHILD_VISIBLE (widget));
- if (!GTK_WIDGET_MAPPED (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_IS_WIDGET (widget));
- if (GTK_WIDGET_MAPPED (widget))
+ if (gtk_widget_get_mapped (widget))
{
if (!gtk_widget_get_has_window (widget))
gdk_window_invalidate_rect (widget->window, &widget->allocation, FALSE);
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_signal_emit (widget, widget_signals[UNREALIZE], 0);
- GTK_WIDGET_UNSET_FLAGS (widget, GTK_REALIZED | GTK_MAPPED);
+ gtk_widget_set_realized (widget, FALSE);
+ gtk_widget_set_mapped (widget, FALSE);
g_object_unref (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 */
for (w = widget; w != NULL; w = w->parent)
- if (!GTK_WIDGET_MAPPED (w))
+ if (!gtk_widget_get_mapped (w))
return;
/* Find the correct widget */
{
GdkRectangle child_rect;
- if (!GTK_WIDGET_MAPPED (widget) ||
+ if (!gtk_widget_get_mapped (widget) ||
widget->window != widget->parent->window)
return;
{
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);
* Also remember that the size request is not necessarily the size
* a widget will actually be allocated.
*
- * See also gtk_widget_get_child_requisition().
+ * Deprecated: 3.0: Use gtk_extended_layout_get_desired_size() instead.
**/
void
gtk_widget_size_request (GtkWidget *widget,
"to widget->requisition. gtk_widget_set_usize() may not work properly.");
#endif /* G_ENABLE_DEBUG */
- _gtk_size_group_compute_desired_size (widget, requisition, NULL);
+ gtk_extended_layout_get_desired_size (GTK_EXTENDED_LAYOUT (widget), FALSE, requisition, NULL);
}
/**
* since the last time a resize was queued. In general, only container
* implementations have this information; applications should use
* gtk_widget_size_request().
+ *
+ *
+ * Deprecated: 3.0: Use gtk_extended_layout_get_desired_size() instead.
**/
void
gtk_widget_get_child_requisition (GtkWidget *widget,
GtkRequisition *requisition)
{
- _gtk_size_group_get_child_requisition (widget, requisition);
+ gtk_extended_layout_get_desired_size (GTK_EXTENDED_LAYOUT (widget), FALSE, requisition, NULL);
}
static gboolean
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);
g_signal_emit (widget, widget_signals[SIZE_ALLOCATE], 0, &real_allocation);
- if (GTK_WIDGET_MAPPED (widget))
+ if (gtk_widget_get_mapped (widget))
{
if (!gtk_widget_get_has_window (widget) && GTK_WIDGET_REDRAW_ON_ALLOC (widget) && position_changed)
{
}
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);
{
GtkWidget *ancestor;
GdkWindow *window;
+ GList *dest_list = NULL;
g_return_val_if_fail (GTK_IS_WIDGET (src_widget), FALSE);
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 */
window = src_widget->window;
while (window != ancestor->window)
{
- gint dx, dy;
-
- gdk_window_get_position (window, &dx, &dy);
-
- src_x += dx;
- src_y += dy;
-
- window = gdk_window_get_parent (window);
+ gdouble dx, dy;
+
+ gdk_window_coords_to_parent (window, src_x, src_y, &dx, &dy);
+
+ src_x = dx;
+ src_y = dy;
+
+ window = gdk_window_get_effective_parent (window);
if (!window) /* Handle GtkHandleBox */
return FALSE;
window = dest_widget->window;
while (window != ancestor->window)
{
- gint dx, dy;
-
- gdk_window_get_position (window, &dx, &dy);
-
- src_x -= dx;
- src_y -= dy;
-
- window = gdk_window_get_parent (window);
-
+ dest_list = g_list_prepend (dest_list, window);
+
+ window = gdk_window_get_effective_parent (window);
+
if (!window) /* Handle GtkHandleBox */
- return FALSE;
+ {
+ g_list_free (dest_list);
+ return FALSE;
+ }
+ }
+
+ while (dest_list)
+ {
+ gdouble dx, dy;
+
+ gdk_window_coords_from_parent (dest_list->data, src_x, src_y, &dx, &dy);
+
+ src_x = dx;
+ src_y = dy;
+
+ dest_list = g_list_remove (dest_list, dest_list->data);
}
/* Translate from window relative to allocation 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_CAN_FOCUS) != 0;
+ return (GTK_OBJECT_FLAGS (widget) & GTK_CAN_FOCUS) != 0;
}
/**
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
- return (GTK_WIDGET_FLAGS (widget) & GTK_CAN_DEFAULT) != 0;
+ return (GTK_OBJECT_FLAGS (widget) & GTK_CAN_DEFAULT) != 0;
}
/**
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
- return (GTK_WIDGET_FLAGS (widget) & GTK_HAS_DEFAULT) != 0;
+ return (GTK_OBJECT_FLAGS (widget) & GTK_HAS_DEFAULT) != 0;
+}
+
+void
+_gtk_widget_set_has_default (GtkWidget *widget,
+ gboolean has_default)
+{
+ if (has_default)
+ GTK_OBJECT_FLAGS (widget) |= GTK_HAS_DEFAULT;
+ else
+ GTK_OBJECT_FLAGS (widget) &= ~(GTK_HAS_DEFAULT);
}
/**
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
- return (GTK_WIDGET_FLAGS (widget) & GTK_RECEIVES_DEFAULT) != 0;
+ return (GTK_OBJECT_FLAGS (widget) & GTK_RECEIVES_DEFAULT) != 0;
}
/**
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
- return (GTK_WIDGET_FLAGS (widget) & GTK_HAS_GRAB) != 0;
+ return (GTK_OBJECT_FLAGS (widget) & GTK_HAS_GRAB) != 0;
+}
+
+void
+_gtk_widget_set_has_grab (GtkWidget *widget,
+ gboolean has_grab)
+{
+ if (has_grab)
+ GTK_OBJECT_FLAGS (widget) |= GTK_HAS_GRAB;
+ else
+ GTK_OBJECT_FLAGS (widget) &= ~(GTK_HAS_GRAB);
}
/**
{
g_return_if_fail (GTK_IS_WIDGET (widget));
- if (state == GTK_WIDGET_STATE (widget))
+ if (state == gtk_widget_get_state (widget))
return;
if (state == GTK_STATE_INSENSITIVE)
g_return_if_fail (GTK_IS_WIDGET (widget));
if (has_window)
- GTK_WIDGET_UNSET_FLAGS (widget, GTK_NO_WINDOW);
+ GTK_OBJECT_FLAGS (widget) &= ~(GTK_NO_WINDOW);
else
- GTK_WIDGET_SET_FLAGS (widget, GTK_NO_WINDOW);
+ GTK_OBJECT_FLAGS (widget) |= GTK_NO_WINDOW;
}
/**
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
- return (GTK_WIDGET_FLAGS (widget) & GTK_TOPLEVEL) != 0;
+ return (GTK_OBJECT_FLAGS (widget) & GTK_TOPLEVEL) != 0;
+}
+
+void
+_gtk_widget_set_is_toplevel (GtkWidget *widget,
+ gboolean is_toplevel)
+{
+ if (is_toplevel)
+ GTK_OBJECT_FLAGS (widget) |= GTK_TOPLEVEL;
+ else
+ GTK_OBJECT_FLAGS (widget) &= ~(GTK_TOPLEVEL);
}
/**
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
- return ((GTK_WIDGET_FLAGS (widget) & GTK_VISIBLE) != 0 &&
- (GTK_WIDGET_FLAGS (widget) & GTK_MAPPED) != 0);
+ return (gtk_widget_get_visible (widget) &&
+ gtk_widget_get_mapped (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;
}
/**
g_return_if_fail (GTK_IS_WIDGET (widget));
if (realized)
- GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
+ GTK_OBJECT_FLAGS (widget) |= GTK_REALIZED;
else
- GTK_WIDGET_UNSET_FLAGS (widget, GTK_REALIZED);
+ GTK_OBJECT_FLAGS (widget) &= ~(GTK_REALIZED);
}
/**
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
- return (GTK_WIDGET_FLAGS (widget) & GTK_MAPPED) != 0;
+ return (GTK_OBJECT_FLAGS (widget) & GTK_MAPPED) != 0;
}
/**
g_return_if_fail (GTK_IS_WIDGET (widget));
if (mapped)
- GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
+ GTK_OBJECT_FLAGS (widget) |= GTK_MAPPED;
else
- GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
+ GTK_OBJECT_FLAGS (widget) &= ~(GTK_MAPPED);
}
/**
if (gtk_widget_get_app_paintable (widget) != app_paintable)
{
if (app_paintable)
- GTK_WIDGET_SET_FLAGS (widget, GTK_APP_PAINTABLE);
+ GTK_OBJECT_FLAGS (widget) |= GTK_APP_PAINTABLE;
else
- GTK_WIDGET_UNSET_FLAGS (widget, GTK_APP_PAINTABLE);
+ GTK_OBJECT_FLAGS (widget) &= ~(GTK_APP_PAINTABLE);
if (gtk_widget_is_drawable (widget))
gtk_widget_queue_draw (widget);
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
- return (GTK_WIDGET_FLAGS (widget) & GTK_APP_PAINTABLE) != 0;
+ return (GTK_OBJECT_FLAGS (widget) & GTK_APP_PAINTABLE) != 0;
}
/**
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
- return (GTK_WIDGET_FLAGS (widget) & GTK_DOUBLE_BUFFERED) != 0;
+ return (GTK_OBJECT_FLAGS (widget) & GTK_DOUBLE_BUFFERED) != 0;
}
/**
else
{
GTK_OBJECT_FLAGS (widget) &= ~(GTK_SENSITIVE);
- data.state = GTK_WIDGET_STATE (widget);
+ data.state = gtk_widget_get_state (widget);
}
data.state_restoration = TRUE;
data.use_forall = TRUE;
g_object_ref_sink (widget);
widget->parent = parent;
- if (GTK_WIDGET_STATE (parent) != GTK_STATE_NORMAL)
- data.state = GTK_WIDGET_STATE (parent);
+ if (gtk_widget_get_state (parent) != GTK_STATE_NORMAL)
+ data.state = gtk_widget_get_state (parent);
else
- data.state = GTK_WIDGET_STATE (widget);
+ data.state = gtk_widget_get_state (widget);
data.state_restoration = FALSE;
data.parent_sensitive = (gtk_widget_is_sensitive (parent) != FALSE);
data.use_forall = gtk_widget_is_sensitive (parent) != gtk_widget_is_sensitive (widget);
/* 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_get_visible (widget))
{
if (GTK_WIDGET_CHILD_VISIBLE (widget) &&
- GTK_WIDGET_MAPPED (widget->parent))
+ gtk_widget_get_mapped (widget->parent))
gtk_widget_map (widget);
gtk_widget_queue_resize (widget);
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);
}
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
- return (GTK_WIDGET_FLAGS (widget) & GTK_RC_STYLE) != 0;
+ return (GTK_OBJECT_FLAGS (widget) & GTK_RC_STYLE) != 0;
}
/**
initial_emission = !gtk_widget_has_rc_style (widget) && !GTK_WIDGET_USER_STYLE (widget);
- GTK_WIDGET_UNSET_FLAGS (widget, GTK_RC_STYLE);
+ GTK_OBJECT_FLAGS (widget) &= ~(GTK_RC_STYLE);
GTK_PRIVATE_SET_FLAG (widget, GTK_USER_STYLE);
gtk_widget_set_style_internal (widget, style, initial_emission);
initial_emission = !gtk_widget_has_rc_style (widget) && !GTK_WIDGET_USER_STYLE (widget);
GTK_PRIVATE_UNSET_FLAG (widget, GTK_USER_STYLE);
- GTK_WIDGET_SET_FLAGS (widget, GTK_RC_STYLE);
+ GTK_OBJECT_FLAGS (widget) |= GTK_RC_STYLE;
if (gtk_widget_has_screen (widget))
new_style = gtk_rc_get_style (widget);
gtk_widget_modify_style (widget, rc_style);
}
+/**
+ * gtk_widget_modify_symbolic_color:
+ * @widget: a #GtkWidget
+ * @name: the name of the symbolic color to modify
+ * @color: (allow-none): the color to assign (does not need to be allocated),
+ * or %NULL to undo the effect of previous calls to
+ * of gtk_widget_modify_symbolic_color().
+ *
+ * Sets a symbolic color for a widget.
+ * All other style values are left untouched. See also
+ * gtk_widget_modify_style().
+ *
+ * Since: 2.22
+ **/
+void
+gtk_widget_modify_symbolic_color (GtkWidget *widget,
+ const gchar *name,
+ const GdkColor *color)
+{
+ GtkRcStyle *rc_style = gtk_widget_get_modifier_style (widget);
+
+ _gtk_rc_style_set_symbolic_color (rc_style, name, color);
+
+ gtk_widget_modify_style (widget, rc_style);
+}
+
/**
* gtk_widget_modify_fg:
* @widget: a #GtkWidget
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);
retval = gtk_icon_set_render_icon (icon_set,
widget->style,
gtk_widget_get_direction (widget),
- GTK_WIDGET_STATE (widget),
+ gtk_widget_get_state (widget),
size,
widget,
detail);
_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_MAPPED (widget->parent) &&
+ if (gtk_widget_get_mapped (widget->parent) &&
GTK_WIDGET_CHILD_VISIBLE (widget) &&
gtk_widget_get_visible (widget))
gtk_widget_map (widget);
* around the window using keyboard shortcuts. @direction indicates
* what kind of motion is taking place (up, down, left, right, tab
* forward, tab backward). gtk_widget_child_focus() emits the
- * #GtkWidget::focus" signal; widgets override the default handler
+ * #GtkWidget::focus signal; widgets override the default handler
* for this signal in order to implement appropriate focus behavior.
*
* The default ::focus handler for a widget should return %TRUE if
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);
const gchar *name)
{
g_return_if_fail (GTK_IS_WIDGET (widget));
- g_return_if_fail ((GTK_WIDGET_FLAGS (widget) & GTK_COMPOSITE_CHILD) != 0);
+ g_return_if_fail ((GTK_OBJECT_FLAGS (widget) & GTK_COMPOSITE_CHILD) != 0);
g_return_if_fail (name != NULL);
if (!quark_composite_name)
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
- if (((GTK_WIDGET_FLAGS (widget) & GTK_COMPOSITE_CHILD) != 0) && widget->parent)
+ if (((GTK_OBJECT_FLAGS (widget) & GTK_COMPOSITE_CHILD) != 0) && widget->parent)
return _gtk_container_child_composite_name (GTK_CONTAINER (widget->parent),
widget);
else
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_MAPPED (widget))
+ if (!gtk_widget_get_mapped (widget))
{
- GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
+ gtk_widget_set_mapped (widget, TRUE);
if (gtk_widget_get_has_window (widget))
gdk_window_show (widget->window);
static void
gtk_widget_real_unmap (GtkWidget *widget)
{
- if (GTK_WIDGET_MAPPED (widget))
+ if (gtk_widget_get_mapped (widget))
{
- GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
+ gtk_widget_set_mapped (widget, FALSE);
if (gtk_widget_get_has_window (widget))
gdk_window_hide (widget->window);
{
g_assert (!gtk_widget_get_has_window (widget));
- GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
+ gtk_widget_set_realized (widget, TRUE);
if (widget->parent)
{
widget->window = gtk_widget_get_parent_window (widget);
static void
gtk_widget_real_unrealize (GtkWidget *widget)
{
- if (GTK_WIDGET_MAPPED (widget))
+ if (gtk_widget_get_mapped (widget))
gtk_widget_real_unmap (widget);
- GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
+ gtk_widget_set_mapped (widget, FALSE);
/* printf ("unrealizing %s\n", g_type_name (G_TYPE_FROM_INSTANCE (widget)));
*/
gtk_selection_remove_all (widget);
- GTK_WIDGET_UNSET_FLAGS (widget, GTK_REALIZED);
+ gtk_widget_set_realized (widget, FALSE);
}
static void
{
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);
while (from_ancestor != NULL)
{
- from_ancestor = gdk_window_get_parent (from_ancestor);
+ from_ancestor = gdk_window_get_effective_parent (from_ancestor);
if (from_ancestor == NULL)
break;
from_ancestors = g_list_prepend (from_ancestors, from_ancestor);
while (to_ancestor != NULL)
{
- to_ancestor = gdk_window_get_parent (to_ancestor);
+ to_ancestor = gdk_window_get_effective_parent (to_ancestor);
if (to_ancestor == NULL)
break;
to_ancestors = g_list_prepend (to_ancestors, to_ancestor);
{
if (from_ancestor != NULL)
{
- from_ancestor = gdk_window_get_parent (from_ancestor);
+ from_ancestor = gdk_window_get_effective_parent (from_ancestor);
if (from_ancestor == to_window)
break;
if (from_ancestor)
}
if (to_ancestor != NULL)
{
- to_ancestor = gdk_window_get_parent (to_ancestor);
+ to_ancestor = gdk_window_get_effective_parent (to_ancestor);
if (to_ancestor == from_window)
break;
if (to_ancestor)
gtk_widget_propagate_state (GtkWidget *widget,
GtkStateData *data)
{
- guint8 old_state = GTK_WIDGET_STATE (widget);
+ guint8 old_state = gtk_widget_get_state (widget);
guint8 old_saved_state = widget->saved_state;
/* don't call this function with state==GTK_STATE_INSENSITIVE,
if (data->parent_sensitive)
- GTK_WIDGET_SET_FLAGS (widget, GTK_PARENT_SENSITIVE);
+ GTK_OBJECT_FLAGS (widget) |= GTK_PARENT_SENSITIVE;
else
- GTK_WIDGET_UNSET_FLAGS (widget, GTK_PARENT_SENSITIVE);
+ GTK_OBJECT_FLAGS (widget) &= ~(GTK_PARENT_SENSITIVE);
if (gtk_widget_is_sensitive (widget))
{
if (data->state_restoration)
- GTK_WIDGET_STATE (widget) = widget->saved_state;
+ widget->state = widget->saved_state;
else
- GTK_WIDGET_STATE (widget) = data->state;
+ widget->state = data->state;
}
else
{
if (data->state != GTK_STATE_INSENSITIVE)
widget->saved_state = data->state;
}
- else if (GTK_WIDGET_STATE (widget) != GTK_STATE_INSENSITIVE)
- widget->saved_state = GTK_WIDGET_STATE (widget);
- GTK_WIDGET_STATE (widget) = GTK_STATE_INSENSITIVE;
+ else if (gtk_widget_get_state (widget) != GTK_STATE_INSENSITIVE)
+ widget->saved_state = gtk_widget_get_state (widget);
+ widget->state = GTK_STATE_INSENSITIVE;
}
if (gtk_widget_is_focus (widget) && !gtk_widget_is_sensitive (widget))
gtk_window_set_focus (GTK_WINDOW (window), NULL);
}
- if (old_state != GTK_WIDGET_STATE (widget) ||
+ if (old_state != gtk_widget_get_state (widget) ||
old_saved_state != widget->saved_state)
{
g_object_ref (widget);
return aux_info;
}
+
/*****************************************
* gtk_widget_aux_info_destroy:
*
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 */
* GtkExtendedLayout implementation
*/
static void
-gtk_widget_real_get_desired_size (GtkExtendedLayout *layout,
- GtkRequisition *minimum_size,
- GtkRequisition *natural_size)
+gtk_widget_real_get_desired_width (GtkExtendedLayout *layout,
+ gint *minimum_size,
+ gint *natural_size)
{
- GtkWidget *widget = GTK_WIDGET (layout);
- GtkRequisition requisition = widget->requisition;
+ /* Set the initial values so that unimplemented classes will fall back
+ * on the "size-request" collected values (see gtksizegroup.c:do_size_request()).
+ */
+ if (minimum_size)
+ *minimum_size = GTK_WIDGET (layout)->requisition.width;
- g_signal_emit (widget, widget_signals[SIZE_REQUEST], 0, &requisition);
+ if (natural_size)
+ *natural_size = GTK_WIDGET (layout)->requisition.width;
+}
+static void
+gtk_widget_real_get_desired_height (GtkExtendedLayout *layout,
+ gint *minimum_size,
+ gint *natural_size)
+{
+ /* Set the initial values so that unimplemented classes will fall back
+ * on the "size-request" collected values (see gtksizegroup.c:do_size_request()).
+ */
if (minimum_size)
- *minimum_size = requisition;
+ *minimum_size = GTK_WIDGET (layout)->requisition.height;
+
if (natural_size)
- *natural_size = requisition;
+ *natural_size = GTK_WIDGET (layout)->requisition.height;
}
static void
gint *minimum_height,
gint *natural_height)
{
- GtkRequisition minimum_size;
- GtkRequisition natural_size;
-
- g_return_if_fail (GTK_IS_WIDGET (layout));
-
-#if 0
- TODO: integrate height-for-width with size-groups
-#else
- gtk_widget_get_desired_size (GTK_WIDGET(layout),
- minimum_height ? &minimum_size : NULL,
- natural_height ? &natural_size : NULL);
-
- if (minimum_height)
- *minimum_height = minimum_size.height;
- if (natural_height)
- *natural_height = natural_size.height;
-#endif
+ gtk_extended_layout_get_desired_height (layout, minimum_height, natural_height);
}
static void
gint height,
gint *minimum_width,
gint *natural_width)
-{
- GtkRequisition minimum_size;
- GtkRequisition natural_size;
-
- g_return_if_fail (GTK_IS_WIDGET (layout));
-
-#if 0
- TODO: integrate width-for-height with size-groups
-#else
- gtk_widget_get_desired_size (GTK_WIDGET(layout),
- minimum_width ? &minimum_size : NULL,
- natural_width ? &natural_size : NULL);
-
- if (minimum_width)
- *minimum_width = minimum_size.width;
- if (natural_width)
- *natural_width = natural_size.width;
-#endif
-}
-
-/**
- * gtk_widget_get_desired_size:
- * @widget: a #GtkWidget
- * @minimum_size: location for storing the @widget's minimum size, or %NULL
- * @natural_size: location for storing the @widget's preferred size, or %NULL
- *
- * Retreives a widget's desired size, considering restrictions imposed by
- * #GtkSizeGroup<!-- -->s. See also: gtk_extended_layout_get_desired_size().
- *
- * Since: 2.20
- */
-void
-gtk_widget_get_desired_size (GtkWidget *widget,
- GtkRequisition *minimum_size,
- GtkRequisition *natural_size)
-{
- g_return_if_fail (GTK_IS_WIDGET (widget));
- _gtk_size_group_compute_desired_size (widget, minimum_size, natural_size);
+{
+ gtk_extended_layout_get_desired_width (layout, minimum_width, natural_width);
}
static void
-gtk_widget_layout_interface_init (GtkExtendedLayoutIface *iface)
+gtk_widget_extended_layout_init (GtkExtendedLayoutIface *iface)
{
- iface->get_desired_size = gtk_widget_real_get_desired_size;
+ iface->get_desired_width = gtk_widget_real_get_desired_width;
+ iface->get_desired_height = gtk_widget_real_get_desired_height;
iface->get_width_for_height = gtk_widget_real_get_width_for_height;
iface->get_height_for_width = gtk_widget_real_get_height_for_width;
}
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 |
return widget->window;
}
+static void
+_gtk_widget_set_has_focus (GtkWidget *widget,
+ gboolean has_focus)
+{
+ if (has_focus)
+ GTK_OBJECT_FLAGS (widget) |= GTK_HAS_FOCUS;
+ else
+ GTK_OBJECT_FLAGS (widget) &= ~(GTK_HAS_FOCUS);
+}
+
+/**
+ * gtk_widget_send_focus_change:
+ * @widget: a #GtkWidget
+ * @event: a #GdkEvent of type GDK_FOCUS_CHANGE
+ *
+ * Sends the focus change @event to @widget
+ *
+ * This function is not meant to be used by applications. The only time it
+ * should be used is when it is necessary for a #GtkWidget to assign focus
+ * to a widget that is semantically owned by the first widget even though
+ * it's not a direct child - for instance, a search entry in a floating
+ * window similar to the quick search in #GtkTreeView.
+ *
+ * An example of its usage is:
+ *
+ * |[
+ * GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+ *
+ * fevent->focus_change.type = GDK_FOCUS_CHANGE;
+ * fevent->focus_change.in = TRUE;
+ * fevent->focus_change.window = gtk_widget_get_window (widget);
+ * if (fevent->focus_change.window != NULL)
+ * g_object_ref (fevent->focus_change.window);
+ *
+ * gtk_widget_send_focus_change (widget, fevent);
+ *
+ * gdk_event_free (event);
+ * ]|
+ *
+ * Return value: the return value from the event signal emission: %TRUE
+ * if the event was handled, and %FALSE otherwise
+ *
+ * Since: 2.20
+ */
+gboolean
+gtk_widget_send_focus_change (GtkWidget *widget,
+ GdkEvent *event)
+{
+ gboolean res;
+
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
+ g_return_val_if_fail (event != NULL && event->type == GDK_FOCUS_CHANGE, FALSE);
+
+ g_object_ref (widget);
+
+ _gtk_widget_set_has_focus (widget, event->focus_change.in);
+
+ res = gtk_widget_event (widget, event);
+
+ g_object_notify (G_OBJECT (widget), "has-focus");
+
+ g_object_unref (widget);
+
+ return res;
+}
+
#define __GTK_WIDGET_C__
#include "gtkaliasdef.c"
projects / ~andy / gtk / blobdiff