#include "gtkinvisible.h"
#include "gtkbuildable.h"
#include "gtkbuilderprivate.h"
+#include "gtkextendedlayout.h"
#include "gtkalias.h"
/**
*
* 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_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);
static void gtk_widget_set_usize_internal (GtkWidget *widget,
NULL /* interface data */
};
+ const GInterfaceInfo layout_info =
+ {
+ (GInterfaceInitFunc) gtk_widget_extended_layout_init,
+ (GInterfaceFinalizeFunc) NULL,
+ NULL /* interface data */
+ };
+
widget_type = g_type_register_static (GTK_TYPE_OBJECT, "GtkWidget",
&widget_info, G_TYPE_FLAG_ABSTRACT);
&accessibility_info) ;
g_type_add_interface_static (widget_type, GTK_TYPE_BUILDABLE,
&buildable_info) ;
-
+ g_type_add_interface_static (widget_type, GTK_TYPE_EXTENDED_LAYOUT,
+ &layout_info) ;
}
return widget_type;
/**
* GtkWidget::parent-set:
* @widget: the object on which the signal is emitted
- * @old_parent: the previous parent, or %NULL if the widget
+ * @old_parent: (allow-none): the previous parent, or %NULL if the widget
* just got its initial parent.
*
* The ::parent-set signal is emitted when a new parent
/**
* GtkWidget::hierarchy-changed:
* @widget: the object on which the signal is emitted
- * @previous_toplevel: the previous toplevel ancestor, or %NULL
+ * @previous_toplevel: (allow-none): the previous toplevel ancestor, or %NULL
* if the widget was previously unanchored
*
* The ::hierarchy-changed signal is emitted when the
/**
* GtkWidget::style-set:
* @widget: the object on which the signal is emitted
- * @previous_style: the previous style, or %NULL if the widget
+ * @previous_style: (allow-none): the previous style, or %NULL if the widget
* just got its initial style
*
* The ::style-set signal is emitted when a new style has been set
/**
* GtkWidget::screen-changed:
* @widget: the object on which the signal is emitted
- * @previous_screen: the previous screen, or %NULL if the
+ * @previous_screen: (allow-none): the previous screen, or %NULL if the
* widget was not associated with a screen before
*
* The ::screen-changed signal gets emitted when the
gtk_widget_set_style (widget, g_value_get_object (value));
break;
case PROP_EVENTS:
- if (!GTK_WIDGET_REALIZED (widget) && !GTK_WIDGET_NO_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:
tmp = (tooltip_window != NULL || tooltip_markup != NULL);
gtk_widget_real_set_has_tooltip (widget, tmp, FALSE);
- if (GTK_WIDGET_VISIBLE (widget))
+ if (gtk_widget_get_visible (widget))
gtk_widget_queue_tooltip_query (widget);
break;
case PROP_TOOLTIP_TEXT:
tmp = (tooltip_window != NULL || tooltip_markup != NULL);
gtk_widget_real_set_has_tooltip (widget, tmp, FALSE);
- if (GTK_WIDGET_VISIBLE (widget))
+ if (gtk_widget_get_visible (widget))
gtk_widget_queue_tooltip_query (widget);
break;
case PROP_DOUBLE_BUFFERED:
}
break;
case PROP_VISIBLE:
- g_value_set_boolean (value, (GTK_WIDGET_VISIBLE (widget) != FALSE));
+ g_value_set_boolean (value, (gtk_widget_get_visible (widget) != FALSE));
break;
case PROP_SENSITIVE:
- g_value_set_boolean (value, (GTK_WIDGET_SENSITIVE (widget) != FALSE));
+ g_value_set_boolean (value, (gtk_widget_get_sensitive (widget) != FALSE));
break;
case PROP_APP_PAINTABLE:
g_value_set_boolean (value, (gtk_widget_get_app_paintable (widget) != FALSE));
g_value_set_boolean (value, (gtk_widget_get_can_focus (widget) != FALSE));
break;
case PROP_HAS_FOCUS:
- g_value_set_boolean (value, (GTK_WIDGET_HAS_FOCUS (widget) != FALSE));
+ g_value_set_boolean (value, (gtk_widget_has_focus (widget) != FALSE));
break;
case PROP_IS_FOCUS:
g_value_set_boolean (value, (gtk_widget_is_focus (widget)));
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 ();
GtkWidget *parent;
parent = widget->parent;
- if (parent && GTK_WIDGET_DRAWABLE (parent))
+ if (parent && gtk_widget_is_drawable (parent))
gtk_widget_queue_draw_area (parent,
widget->allocation.x,
widget->allocation.y,
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);
{
g_return_if_fail (GTK_IS_WIDGET (widget));
- if (!GTK_WIDGET_VISIBLE (widget))
+ if (!gtk_widget_get_visible (widget))
{
g_object_ref (widget);
if (!gtk_widget_is_toplevel (widget))
static void
gtk_widget_real_show (GtkWidget *widget)
{
- if (!GTK_WIDGET_VISIBLE (widget))
+ if (!gtk_widget_get_visible (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);
{
g_return_if_fail (GTK_IS_WIDGET (widget));
- if (GTK_WIDGET_VISIBLE (widget))
+ if (gtk_widget_get_visible (widget))
{
GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
static void
gtk_widget_real_hide (GtkWidget *widget)
{
- if (GTK_WIDGET_VISIBLE (widget))
+ if (gtk_widget_get_visible (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_IS_WIDGET (widget));
- if ((GTK_WIDGET_FLAGS (widget) & GTK_NO_SHOW_ALL) != 0)
+ if (gtk_widget_get_no_show_all (widget))
return;
class = GTK_WIDGET_GET_CLASS (widget);
g_return_if_fail (GTK_IS_WIDGET (widget));
- if ((GTK_WIDGET_FLAGS (widget) & GTK_NO_SHOW_ALL) != 0)
+ if (gtk_widget_get_no_show_all (widget))
return;
class = GTK_WIDGET_GET_CLASS (widget);
gtk_widget_map (GtkWidget *widget)
{
g_return_if_fail (GTK_IS_WIDGET (widget));
- g_return_if_fail (GTK_WIDGET_VISIBLE (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);
- if (GTK_WIDGET_NO_WINDOW (widget))
+ if (!gtk_widget_get_has_window (widget))
gdk_window_invalidate_rect (widget->window, &widget->allocation, FALSE);
}
}
{
g_return_if_fail (GTK_IS_WIDGET (widget));
- if (GTK_WIDGET_MAPPED (widget))
+ if (gtk_widget_get_mapped (widget))
{
- if (GTK_WIDGET_NO_WINDOW (widget))
+ if (!gtk_widget_get_has_window (widget))
gdk_window_invalidate_rect (widget->window, &widget->allocation, FALSE);
_gtk_tooltip_hide (widget);
g_signal_emit (widget, widget_signals[UNMAP], 0);
if (window_list == NULL)
{
- if (!GTK_WIDGET_NO_WINDOW (widget))
+ if (gtk_widget_get_has_window (widget))
window_list = g_list_prepend (NULL, widget->window);
else
window_list = gdk_window_get_children (widget->window);
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_NO_WINDOW (widget))
+ if (GTK_IS_CONTAINER (widget) && gtk_widget_get_has_window (widget))
g_message ("gtk_widget_realize(%s)", G_OBJECT_TYPE_NAME (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 */
- if (!GTK_WIDGET_NO_WINDOW (widget))
+ if (gtk_widget_get_has_window (widget))
{
if (widget->parent)
{
{
GdkRectangle child_rect;
- if (!GTK_WIDGET_MAPPED (widget) ||
+ if (!gtk_widget_get_mapped (widget) ||
widget->window != widget->parent->window)
return;
gtk_widget_get_draw_rectangle (GtkWidget *widget,
GdkRectangle *rect)
{
- if (GTK_WIDGET_NO_WINDOW (widget))
+ if (!gtk_widget_get_has_window (widget))
{
GtkBorder *draw_border = NULL;
{
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);
{
g_return_if_fail (GTK_IS_WIDGET (widget));
- if (GTK_WIDGET_DRAWABLE (widget))
+ if (gtk_widget_is_drawable (widget))
{
if (area)
gtk_widget_queue_draw_area (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,
#ifdef G_ENABLE_DEBUG
if (requisition == &widget->requisition)
- g_warning ("gtk_widget_size_request() called on child widget with request equal\n to widget->requisition. gtk_widget_set_usize() may not work properly.");
+ g_warning ("gtk_widget_size_request() called on child widget with request equal\n"
+ "to widget->requisition. gtk_widget_set_usize() may not work properly.");
#endif /* G_ENABLE_DEBUG */
- _gtk_size_group_compute_requisition (widget, requisition);
+ 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_NO_WINDOW (widget) && widget->parent)
+ if (gtk_widget_get_has_window (widget) && widget->parent)
{
int x, y;
GdkRectangle rect;
GdkRegion *region;
- if (!GTK_WIDGET_REALIZED (widget))
+ if (!gtk_widget_get_realized (widget))
return;
gtk_widget_get_draw_rectangle (widget, &rect);
* need to convert to the coordinates that widget->allocation
* is in.
*/
- if (!GTK_WIDGET_NO_WINDOW (widget) && widget->parent)
+ if (gtk_widget_get_has_window (widget) && widget->parent)
{
int wx, wy;
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_NO_WINDOW (widget) && GTK_WIDGET_REDRAW_ON_ALLOC (widget) && position_changed)
+ if (!gtk_widget_get_has_window (widget) && GTK_WIDGET_REDRAW_ON_ALLOC (widget) && position_changed)
{
/* Invalidate union(old_allaction,widget->allocation) in widget->window
*/
}
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 */
- if (!GTK_WIDGET_NO_WINDOW (src_widget) && src_widget->parent)
+ if (gtk_widget_get_has_window (src_widget) && src_widget->parent)
{
gint wx, wy;
gdk_window_get_position (src_widget->window, &wx, &wy);
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 */
- if (!GTK_WIDGET_NO_WINDOW (dest_widget) && dest_widget->parent)
+ if (gtk_widget_get_has_window (dest_widget) && dest_widget->parent)
{
gint wx, wy;
gdk_window_get_position (dest_widget->window, &wx, &wy);
{
widget->allocation = *allocation;
- if (GTK_WIDGET_REALIZED (widget) &&
- !GTK_WIDGET_NO_WINDOW (widget))
+ if (gtk_widget_get_realized (widget) &&
+ gtk_widget_get_has_window (widget))
{
gdk_window_move_resize (widget->window,
allocation->x, allocation->y,
guint signal_id)
{
/* widgets must be onscreen for accels to take effect */
- return GTK_WIDGET_IS_SENSITIVE (widget) && GTK_WIDGET_DRAWABLE (widget) && gdk_window_is_viewable (widget->window);
+ return gtk_widget_is_sensitive (widget) &&
+ gtk_widget_is_drawable (widget) &&
+ gdk_window_is_viewable (widget->window);
}
/**
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
group_cycling = group_cycling != FALSE;
- if (!GTK_WIDGET_IS_SENSITIVE (widget))
+ if (!gtk_widget_is_sensitive (widget))
handled = TRUE;
else
g_signal_emit (widget,
}
#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);
gtk_widget_reparent_subwindows (GtkWidget *widget,
GdkWindow *new_window)
{
- if (GTK_WIDGET_NO_WINDOW (widget))
+ if (!gtk_widget_get_has_window (widget))
{
GList *children = gdk_window_get_children (widget->window);
GList *tmp_list;
{
g_assert (client_data != NULL);
- if (GTK_WIDGET_NO_WINDOW (widget))
+ if (!gtk_widget_get_has_window (widget))
{
if (widget->window)
g_object_unref (widget->window);
* 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);
return_val = gdk_rectangle_intersect (&widget->allocation, area, dest);
- if (return_val && intersection && !GTK_WIDGET_NO_WINDOW (widget))
+ if (return_val && intersection && gtk_widget_get_has_window (widget))
{
intersection->x -= widget->allocation.x;
intersection->y -= widget->allocation.y;
{
g_return_if_fail (GTK_IS_WIDGET (widget));
- if (!GTK_WIDGET_IS_SENSITIVE (widget))
+ if (!gtk_widget_is_sensitive (widget))
return;
g_object_ref (widget);
* toplevel window can request the focus if necessary.
* This is needed when the toplevel is a GtkPlug
*/
- if (!GTK_WIDGET_HAS_FOCUS (widget))
+ if (!gtk_widget_has_focus (widget))
_gtk_window_internal_set_focus (GTK_WINDOW (toplevel), focus_widget);
return;
if (can_focus != gtk_widget_get_can_focus (widget))
{
if (can_focus)
- GTK_WIDGET_SET_FLAGS (widget, GTK_CAN_FOCUS);
+ GTK_OBJECT_FLAGS (widget) |= GTK_CAN_FOCUS;
else
- GTK_WIDGET_UNSET_FLAGS (widget, GTK_CAN_FOCUS);
+ GTK_OBJECT_FLAGS (widget) &= ~(GTK_CAN_FOCUS);
gtk_widget_queue_resize (widget);
g_object_notify (G_OBJECT (widget), "can-focus");
{
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_HAS_FOCUS (widget);
+ return (GTK_OBJECT_FLAGS (widget) & GTK_HAS_FOCUS) != 0;
}
/**
if (can_default != gtk_widget_get_can_default (widget))
{
if (can_default)
- GTK_WIDGET_SET_FLAGS (widget, GTK_CAN_DEFAULT);
+ GTK_OBJECT_FLAGS (widget) |= GTK_CAN_DEFAULT;
else
- GTK_WIDGET_UNSET_FLAGS (widget, GTK_CAN_DEFAULT);
+ GTK_OBJECT_FLAGS (widget) &= ~(GTK_CAN_DEFAULT);
gtk_widget_queue_resize (widget);
g_object_notify (G_OBJECT (widget), "can-default");
{
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);
}
/**
if (receives_default != gtk_widget_get_receives_default (widget))
{
if (receives_default)
- GTK_WIDGET_SET_FLAGS (widget, GTK_RECEIVES_DEFAULT);
+ GTK_OBJECT_FLAGS (widget) |= GTK_RECEIVES_DEFAULT;
else
- GTK_WIDGET_UNSET_FLAGS (widget, GTK_RECEIVES_DEFAULT);
+ GTK_OBJECT_FLAGS (widget) &= ~(GTK_RECEIVES_DEFAULT);
g_object_notify (G_OBJECT (widget), "receives-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)
data.state_restoration = FALSE;
data.use_forall = FALSE;
if (widget->parent)
- data.parent_sensitive = (GTK_WIDGET_IS_SENSITIVE (widget->parent) != FALSE);
+ data.parent_sensitive = (gtk_widget_is_sensitive (widget->parent) != FALSE);
else
data.parent_sensitive = TRUE;
gtk_widget_propagate_state (widget, &data);
- if (GTK_WIDGET_DRAWABLE (widget))
+ if (gtk_widget_is_drawable (widget))
gtk_widget_queue_draw (widget);
}
}
{
g_return_if_fail (GTK_IS_WIDGET (widget));
- if (visible != GTK_WIDGET_VISIBLE (widget))
+ if (visible != gtk_widget_get_visible (widget))
{
if (visible)
gtk_widget_show (widget);
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
- return (GTK_WIDGET_FLAGS (widget) & GTK_VISIBLE) != 0;
+ return (GTK_OBJECT_FLAGS (widget) & GTK_VISIBLE) != 0;
}
/**
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_NO_WINDOW (widget);
+ return !((GTK_OBJECT_FLAGS (widget) & GTK_NO_WINDOW) != 0);
}
/**
{
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));
- realized = realized != FALSE;
-
- if (realized != gtk_widget_get_realized (widget))
- {
- if (realized)
- GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
- else
- GTK_WIDGET_UNSET_FLAGS (widget, GTK_REALIZED);
- }
+ if (realized)
+ GTK_OBJECT_FLAGS (widget) |= GTK_REALIZED;
+ else
+ 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));
- mapped = mapped != FALSE;
-
- if (mapped != gtk_widget_get_mapped (widget))
- {
- if (mapped)
- GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
- else
- GTK_WIDGET_UNSET_FLAGS (widget, GTK_MAPPED);
- }
+ if (mapped)
+ GTK_OBJECT_FLAGS (widget) |= GTK_MAPPED;
+ else
+ 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_DRAWABLE (widget))
+ if (gtk_widget_is_drawable (widget))
gtk_widget_queue_draw (widget);
g_object_notify (G_OBJECT (widget), "app-paintable");
{
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_if_fail (GTK_IS_WIDGET (widget));
+ double_buffered = (double_buffered != FALSE);
+
if (double_buffered != gtk_widget_get_double_buffered (widget))
{
if (double_buffered)
- GTK_WIDGET_SET_FLAGS (widget, GTK_DOUBLE_BUFFERED);
+ GTK_OBJECT_FLAGS (widget) |= GTK_DOUBLE_BUFFERED;
else
- GTK_WIDGET_UNSET_FLAGS (widget, GTK_DOUBLE_BUFFERED);
+ GTK_OBJECT_FLAGS (widget) &= ~(GTK_DOUBLE_BUFFERED);
g_object_notify (G_OBJECT (widget), "double-buffered");
}
{
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;
}
/**
sensitive = (sensitive != FALSE);
- if (sensitive == (GTK_WIDGET_SENSITIVE (widget) != FALSE))
+ if (sensitive == (gtk_widget_get_sensitive (widget) != FALSE))
return;
if (sensitive)
{
- GTK_WIDGET_SET_FLAGS (widget, GTK_SENSITIVE);
+ GTK_OBJECT_FLAGS (widget) |= GTK_SENSITIVE;
data.state = widget->saved_state;
}
else
{
- GTK_WIDGET_UNSET_FLAGS (widget, GTK_SENSITIVE);
- data.state = GTK_WIDGET_STATE (widget);
+ GTK_OBJECT_FLAGS (widget) &= ~(GTK_SENSITIVE);
+ data.state = gtk_widget_get_state (widget);
}
data.state_restoration = TRUE;
data.use_forall = TRUE;
if (widget->parent)
- data.parent_sensitive = (GTK_WIDGET_IS_SENSITIVE (widget->parent) != FALSE);
+ data.parent_sensitive = (gtk_widget_is_sensitive (widget->parent) != FALSE);
else
data.parent_sensitive = TRUE;
gtk_widget_propagate_state (widget, &data);
- if (GTK_WIDGET_DRAWABLE (widget))
+ if (gtk_widget_is_drawable (widget))
gtk_widget_queue_draw (widget);
g_object_notify (G_OBJECT (widget), "sensitive");
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
- return GTK_WIDGET_SENSITIVE (widget);
+ return (GTK_OBJECT_FLAGS (widget) & GTK_SENSITIVE) != 0;
}
/**
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
- return GTK_WIDGET_IS_SENSITIVE (widget);
+ return (gtk_widget_get_sensitive (widget) &&
+ (GTK_OBJECT_FLAGS (widget) & GTK_PARENT_SENSITIVE) != 0);
}
/**
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);
+ data.parent_sensitive = (gtk_widget_is_sensitive (parent) != FALSE);
+ data.use_forall = gtk_widget_is_sensitive (parent) != gtk_widget_is_sensitive (widget);
gtk_widget_propagate_state (widget, &data);
/* Enforce realized/mapped invariants
*/
- if (GTK_WIDGET_REALIZED (widget->parent))
+ if (gtk_widget_get_realized (widget->parent))
gtk_widget_realize (widget);
- if (GTK_WIDGET_VISIBLE (widget->parent) &&
- GTK_WIDGET_VISIBLE (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) &&
- !GTK_WIDGET_NO_WINDOW (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_VISIBLE (widget))
+ gtk_widget_get_visible (widget))
gtk_widget_map (widget);
else
gtk_widget_unmap (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
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
- if (!GTK_WIDGET_VISIBLE (widget) ||
- !GTK_WIDGET_IS_SENSITIVE (widget))
+ if (!gtk_widget_get_visible (widget) ||
+ !gtk_widget_is_sensitive (widget))
return FALSE;
/* child widgets must set CAN_FOCUS, containers
if (GTK_IS_WINDOW (widget) && aux_info->x_set && aux_info->y_set)
_gtk_window_reposition (GTK_WINDOW (widget), aux_info->x, aux_info->y);
- if (GTK_WIDGET_VISIBLE (widget) && widget->parent)
+ if (gtk_widget_get_visible (widget) && widget->parent)
gtk_widget_size_allocate (widget, &widget->allocation);
}
changed = TRUE;
}
- if (GTK_WIDGET_VISIBLE (widget) && changed)
+ if (gtk_widget_get_visible (widget) && changed)
gtk_widget_queue_resize (widget);
g_object_thaw_notify (G_OBJECT (widget));
/**
* gtk_widget_get_size_request:
* @widget: a #GtkWidget
- * @width: (out): return location for width, or %NULL
- * @height: (out): return location for height, or %NULL
+ * @width: (allow-none): (out): return location for width, or %NULL
+ * @height: (allow-none): (out): return location for height, or %NULL
*
* Gets the size request that was explicitly set for the widget using
* gtk_widget_set_size_request(). A value of -1 stored in @width or
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;
- if (GTK_WIDGET_NO_WINDOW (widget))
+ if (!gtk_widget_get_has_window (widget))
window_list = gdk_window_get_children (widget->window);
else
window_list = g_list_prepend (NULL, widget->window);
{
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);
- if (GTK_WIDGET_NO_WINDOW (widget))
+ if (!gtk_widget_get_has_window (widget))
{
if (x)
*x -= widget->allocation.x;
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
if (widget->parent)
gtk_container_remove (GTK_CONTAINER (widget->parent), widget);
- else if (GTK_WIDGET_VISIBLE (widget))
+ else if (gtk_widget_get_visible (widget))
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_NO_WINDOW (widget))
+ 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_NO_WINDOW (widget))
+ if (gtk_widget_get_has_window (widget))
gdk_window_hide (widget->window);
}
}
static void
gtk_widget_real_realize (GtkWidget *widget)
{
- g_assert (GTK_WIDGET_NO_WINDOW (widget));
+ 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)));
*/
NULL);
gtk_style_detach (widget->style);
- if (!GTK_WIDGET_NO_WINDOW (widget))
+ if (gtk_widget_get_has_window (widget))
{
gdk_window_set_user_data (widget->window, NULL);
gdk_window_destroy (widget->window);
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 (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))
+ if (gtk_widget_is_focus (widget) && !gtk_widget_is_sensitive (widget))
{
GtkWidget *window;
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);
- if (!GTK_WIDGET_IS_SENSITIVE (widget) && gtk_widget_has_grab (widget))
+ if (!gtk_widget_is_sensitive (widget) && gtk_widget_has_grab (widget))
gtk_grab_remove (widget);
g_signal_emit (widget, widget_signals[STATE_CHANGED], 0, old_state);
if (GTK_WIDGET_HAS_POINTER (widget) && !GTK_WIDGET_SHADOWED (widget))
{
- if (!GTK_WIDGET_IS_SENSITIVE (widget))
+ if (!gtk_widget_is_sensitive (widget))
_gtk_widget_synthesize_crossing (widget, NULL,
GDK_CROSSING_STATE_CHANGED);
else if (old_state == GTK_STATE_INSENSITIVE)
if (GTK_IS_CONTAINER (widget))
{
- data->parent_sensitive = (GTK_WIDGET_IS_SENSITIVE (widget) != FALSE);
+ data->parent_sensitive = (gtk_widget_is_sensitive (widget) != FALSE);
if (data->use_forall)
gtk_container_forall (GTK_CONTAINER (widget),
(GtkCallback) gtk_widget_propagate_state,
aux_info = g_object_get_qdata (G_OBJECT (widget), quark_aux_info);
if (!aux_info && create)
{
- aux_info = g_slice_new (GtkWidgetAuxInfo);
+ aux_info = g_slice_new0 (GtkWidgetAuxInfo);
aux_info->width = -1;
aux_info->height = -1;
- aux_info->x = 0;
- aux_info->y = 0;
- aux_info->x_set = FALSE;
- aux_info->y_set = FALSE;
+
g_object_set_qdata (G_OBJECT (widget), quark_aux_info, aux_info);
}
return aux_info;
}
+
/*****************************************
* gtk_widget_aux_info_destroy:
*
/**
* gtk_widget_shape_combine_mask:
* @widget: a #GtkWidget
- * @shape_mask: shape to be added, or %NULL to remove an existing shape
+ * @shape_mask: (allow-none): shape to be added, or %NULL to remove an existing shape
* @offset_x: X position of shape mask with respect to @window
* @offset_y: Y position of shape mask with respect to @window
*
g_return_if_fail (GTK_IS_WIDGET (widget));
/* set_shape doesn't work on widgets without gdk window */
- g_return_if_fail (!GTK_WIDGET_NO_WINDOW (widget));
+ g_return_if_fail (gtk_widget_get_has_window (widget));
if (!shape_mask)
{
g_return_if_fail (GTK_IS_WIDGET (widget));
/* set_shape doesn't work on widgets without gdk window */
- g_return_if_fail (!GTK_WIDGET_NO_WINDOW (widget));
+ g_return_if_fail (gtk_widget_get_has_window (widget));
if (!shape_mask)
{
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);
/**
* gtk_widget_get_snapshot:
* @widget: a #GtkWidget
- * @clip_rect: a #GdkRectangle or %NULL
+ * @clip_rect: (allow-none): a #GdkRectangle or %NULL
*
* Create a #GdkPixmap of the contents of the widget and its children.
*
GList *windows = NULL, *list;
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
- if (!GTK_WIDGET_VISIBLE (widget))
+ if (!gtk_widget_get_visible (widget))
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 */
width = widget->allocation.width;
height = widget->allocation.height;
- if (widget->parent && !GTK_WIDGET_NO_WINDOW (widget))
+ if (widget->parent && gtk_widget_get_has_window (widget))
{
/* grow snapshot rectangle to cover all widget windows */
parent_window = gtk_widget_get_parent_window (widget);
* gtk_widget_class_find_style_property:
* @klass: a #GtkWidgetClass
* @property_name: the name of the style property to find
- * @returns: the #GParamSpec of the style property or %NULL if @class has no
+ * @returns: (allow-none): the #GParamSpec of the style property or %NULL if @class has no
* style property with that name.
*
* Finds a style property of a widget class by name.
}
}
+/*
+ * GtkExtendedLayout implementation
+ */
+static void
+gtk_widget_real_get_desired_width (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 = GTK_WIDGET (layout)->requisition.width;
+
+ 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 = GTK_WIDGET (layout)->requisition.height;
+
+ if (natural_size)
+ *natural_size = GTK_WIDGET (layout)->requisition.height;
+}
+
+static void
+gtk_widget_real_get_height_for_width (GtkExtendedLayout *layout,
+ gint width,
+ gint *minimum_height,
+ gint *natural_height)
+{
+ gtk_extended_layout_get_desired_height (layout, minimum_height, natural_height);
+}
+
+static void
+gtk_widget_real_get_width_for_height (GtkExtendedLayout *layout,
+ gint height,
+ gint *minimum_width,
+ gint *natural_width)
+{
+ gtk_extended_layout_get_desired_width (layout, minimum_width, natural_width);
+}
+static void
+gtk_widget_extended_layout_init (GtkExtendedLayoutIface *iface)
+{
+ 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;
+}
+
+
/**
* gtk_widget_get_clipboard:
* @widget: a #GtkWidget
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
- return (GTK_WIDGET_FLAGS (widget) & GTK_NO_SHOW_ALL) != 0;
+ return (GTK_OBJECT_FLAGS (widget) & GTK_NO_SHOW_ALL) != 0;
}
/**
no_show_all = (no_show_all != FALSE);
- if (no_show_all == ((GTK_WIDGET_FLAGS (widget) & GTK_NO_SHOW_ALL) != 0))
+ if (no_show_all == gtk_widget_get_no_show_all (widget))
return;
if (no_show_all)
- GTK_WIDGET_SET_FLAGS (widget, GTK_NO_SHOW_ALL);
+ GTK_OBJECT_FLAGS (widget) |= GTK_NO_SHOW_ALL;
else
- GTK_WIDGET_UNSET_FLAGS (widget, GTK_NO_SHOW_ALL);
+ GTK_OBJECT_FLAGS (widget) &= ~(GTK_NO_SHOW_ALL);
g_object_notify (G_OBJECT (widget), "no-show-all");
}
if (priv_has_tooltip)
{
- if (GTK_WIDGET_REALIZED (widget) && GTK_WIDGET_NO_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 |
GDK_POINTER_MOTION_MASK |
GDK_POINTER_MOTION_HINT_MASK);
- if (!GTK_WIDGET_NO_WINDOW (widget))
+ if (gtk_widget_get_has_window (widget))
gtk_widget_add_events (widget,
GDK_LEAVE_NOTIFY_MASK |
GDK_POINTER_MOTION_MASK |
/**
* gtk_widget_set_tooltip_window:
* @widget: a #GtkWidget
- * @custom_window: a #GtkWindow, or %NULL
+ * @custom_window: (allow-none): a #GtkWindow, or %NULL
*
* Replaces the default, usually yellow, window used for displaying
* tooltips with @custom_window. GTK+ will take care of showing and
has_tooltip = (custom_window != NULL || tooltip_markup != NULL);
gtk_widget_real_set_has_tooltip (widget, has_tooltip, FALSE);
- if (has_tooltip && GTK_WIDGET_VISIBLE (widget))
+ if (has_tooltip && gtk_widget_get_visible (widget))
gtk_widget_queue_tooltip_query (widget);
}
/**
* gtk_widget_set_tooltip_markup:
* @widget: a #GtkWidget
- * @markup: the contents of the tooltip for @widget, or %NULL
+ * @markup: (allow-none): the contents of the tooltip for @widget, or %NULL
*
* Sets @markup as the contents of the tooltip, which is marked up with
* the <link linkend="PangoMarkupFormat">Pango text markup language</link>.
widget->allocation = *allocation;
}
+/**
+ * gtk_widget_get_requisition:
+ * @widget: a #GtkWidget
+ * @requisition: (out): a pointer to a #GtkRequisition to copy to
+ *
+ * Retrieves the widget's requisition.
+ *
+ * This function should only be used by widget implementations in
+ * order to figure whether the widget's requisition has actually
+ * changed after some internal state change (so that they can call
+ * gtk_widget_queue_resize() instead of gtk_widget_queue_draw()).
+ *
+ * Normally, gtk_widget_size_request() should be used.
+ *
+ * Since: 2.20
+ */
+void
+gtk_widget_get_requisition (GtkWidget *widget,
+ GtkRequisition *requisition)
+{
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+ g_return_if_fail (requisition != NULL);
+
+ *requisition = widget->requisition;
+}
+
/**
* gtk_widget_set_window:
* @widget: a #GtkWidget
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