From 993400742041418637e1b09b462e311665ce00fb Mon Sep 17 00:00:00 2001 From: Tristan Van Berkom Date: Wed, 8 Sep 2010 00:25:47 +0200 Subject: [PATCH] Completely removed requisition cache from GtkWidget instance structure. Since we have a new mechanism for requesting sizes: GtkSizeRequestIface; it makes no sense to maintain this cache on the GtkWidget structure... removing the requisition cache however does not break the old "size-request" signal which is there for backwards compatability reasons. In any case widget->requisition should not have been accessed, gtk_widget_get_child_requisition() would have been the correct way to consult the cache. This commit also deprecates the newly added gtk_widget_get_requisition() API and makes it fallback on gtk_size_request_get_size(). --- gtk/gtkarrow.c | 57 +++++++++++++++++++++++++++++++++++++++----- gtk/gtkcontainer.c | 1 - gtk/gtkfontsel.c | 9 +++---- gtk/gtkhandlebox.c | 8 +++++-- gtk/gtkiconview.c | 8 +++++-- gtk/gtkimage.c | 28 +++++++++++++--------- gtk/gtkmenu.c | 5 ++-- gtk/gtkmisc.c | 8 ------- gtk/gtkpathbar.c | 2 -- gtk/gtkprivate.h | 6 ++--- gtk/gtkruler.c | 4 ---- gtk/gtkseparator.c | 4 ---- gtk/gtksizegroup.c | 1 - gtk/gtksizerequest.c | 28 ++++++++++------------ gtk/gtkspinbutton.c | 56 ++++++++++++++++++++++++++++++------------- gtk/gtktextview.c | 3 ++- gtk/gtktreeview.c | 13 +++++++--- gtk/gtkwidget.c | 36 ++++++++++------------------ gtk/gtkwidget.h | 4 ---- 19 files changed, 167 insertions(+), 114 deletions(-) diff --git a/gtk/gtkarrow.c b/gtk/gtkarrow.c index ed1d69c9a..70abcc1ff 100644 --- a/gtk/gtkarrow.c +++ b/gtk/gtkarrow.c @@ -47,6 +47,7 @@ #include "config.h" #include #include "gtkarrow.h" +#include "gtksizerequest.h" #include "gtkprivate.h" #include "gtkintl.h" @@ -76,8 +77,17 @@ static void gtk_arrow_get_property (GObject *object, static gboolean gtk_arrow_expose (GtkWidget *widget, GdkEventExpose *event); +static void gtk_arrow_size_request_init (GtkSizeRequestIface *iface); +static void gtk_arrow_get_width (GtkSizeRequest *widget, + gint *minimum_size, + gint *natural_size); +static void gtk_arrow_get_height (GtkSizeRequest *widget, + gint *minimum_size, + gint *natural_size); -G_DEFINE_TYPE (GtkArrow, gtk_arrow, GTK_TYPE_MISC) +G_DEFINE_TYPE_WITH_CODE (GtkArrow, gtk_arrow, GTK_TYPE_MISC, + G_IMPLEMENT_INTERFACE (GTK_TYPE_SIZE_REQUEST, + gtk_arrow_size_request_init)) static void @@ -176,7 +186,6 @@ static void gtk_arrow_init (GtkArrow *arrow) { GtkArrowPrivate *priv; - gint xpad, ypad; arrow->priv = G_TYPE_INSTANCE_GET_PRIVATE (arrow, GTK_TYPE_ARROW, @@ -185,14 +194,50 @@ gtk_arrow_init (GtkArrow *arrow) gtk_widget_set_has_window (GTK_WIDGET (arrow), FALSE); - gtk_misc_get_padding (GTK_MISC (arrow), &xpad, &ypad); - GTK_WIDGET (arrow)->requisition.width = MIN_ARROW_SIZE + xpad * 2; - GTK_WIDGET (arrow)->requisition.height = MIN_ARROW_SIZE + ypad * 2; - priv->arrow_type = GTK_ARROW_RIGHT; priv->shadow_type = GTK_SHADOW_OUT; } +static void +gtk_arrow_size_request_init (GtkSizeRequestIface *iface) +{ + iface->get_width = gtk_arrow_get_width; + iface->get_height = gtk_arrow_get_height; +} + +static void +gtk_arrow_get_width (GtkSizeRequest *widget, + gint *minimum_size, + gint *natural_size) +{ + gint xpad; + + gtk_misc_get_padding (GTK_MISC (widget), &xpad, NULL); + + if (minimum_size) + *minimum_size = MIN_ARROW_SIZE + xpad * 2; + + if (natural_size) + *natural_size = MIN_ARROW_SIZE + xpad * 2; +} + +static void +gtk_arrow_get_height (GtkSizeRequest *widget, + gint *minimum_size, + gint *natural_size) +{ + gint ypad; + + gtk_misc_get_padding (GTK_MISC (widget), NULL, &ypad); + + if (minimum_size) + *minimum_size = MIN_ARROW_SIZE + ypad * 2; + + if (natural_size) + *natural_size = MIN_ARROW_SIZE + ypad * 2; +} + + /** * gtk_arrow_new: * @arrow_type: a valid #GtkArrowType. diff --git a/gtk/gtkcontainer.c b/gtk/gtkcontainer.c index 66b8c37bf..3599fe0cb 100644 --- a/gtk/gtkcontainer.c +++ b/gtk/gtkcontainer.c @@ -1408,7 +1408,6 @@ _gtk_container_queue_resize (GtkContainer *container) while (TRUE) { GTK_PRIVATE_SET_FLAG (widget, GTK_ALLOC_NEEDED); - 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); diff --git a/gtk/gtkfontsel.c b/gtk/gtkfontsel.c index 24331b557..50812d5bc 100644 --- a/gtk/gtkfontsel.c +++ b/gtk/gtkfontsel.c @@ -58,8 +58,9 @@ #include "gtkscrolledwindow.h" #include "gtkintl.h" #include "gtkaccessible.h" -#include "gtkprivate.h" #include "gtkbuildable.h" +#include "gtksizerequest.h" +#include "gtkprivate.h" struct _GtkFontSelectionPrivate { @@ -1168,7 +1169,7 @@ gtk_font_selection_update_preview (GtkFontSelection *fontsel) GtkFontSelectionPrivate *priv = fontsel->priv; GtkRcStyle *rc_style; gint new_height; - GtkRequisition old_requisition; + GtkRequisition old_requisition, new_requisition; GtkWidget *preview_entry = priv->preview_entry; const gchar *text; @@ -1180,10 +1181,10 @@ gtk_font_selection_update_preview (GtkFontSelection *fontsel) gtk_widget_modify_style (preview_entry, rc_style); g_object_unref (rc_style); - gtk_widget_size_request (preview_entry, NULL); + gtk_size_request_get_size (GTK_SIZE_REQUEST (preview_entry), &new_requisition, NULL); /* We don't ever want to be over MAX_PREVIEW_HEIGHT pixels high. */ - new_height = CLAMP (preview_entry->requisition.height, INITIAL_PREVIEW_HEIGHT, MAX_PREVIEW_HEIGHT); + new_height = CLAMP (new_requisition.height, INITIAL_PREVIEW_HEIGHT, MAX_PREVIEW_HEIGHT); if (new_height > old_requisition.height || new_height < old_requisition.height - 30) gtk_widget_set_size_request (preview_entry, -1, new_height); diff --git a/gtk/gtkhandlebox.c b/gtk/gtkhandlebox.c index 3769b6956..add2d3b97 100644 --- a/gtk/gtkhandlebox.c +++ b/gtk/gtkhandlebox.c @@ -32,6 +32,7 @@ #include "gtkmain.h" #include "gtkmarshalers.h" #include "gtkwindow.h" +#include "gtksizerequest.h" #include "gtkprivate.h" #include "gtkintl.h" @@ -406,6 +407,7 @@ gtk_handle_box_realize (GtkWidget *widget) GtkHandleBoxPrivate *priv = hb->priv; GtkWidget *child; GdkWindowAttr attributes; + GtkRequisition requisition; gint attributes_mask; gtk_widget_set_realized (widget, TRUE); @@ -443,10 +445,12 @@ gtk_handle_box_realize (GtkWidget *widget) if (child) gtk_widget_set_parent_window (child, priv->bin_window); + gtk_size_request_get_size (GTK_SIZE_REQUEST (widget), &requisition, NULL); + attributes.x = 0; attributes.y = 0; - attributes.width = widget->requisition.width; - attributes.height = widget->requisition.height; + attributes.width = requisition.width; + attributes.height = requisition.height; attributes.window_type = GDK_WINDOW_TOPLEVEL; attributes.wclass = GDK_INPUT_OUTPUT; attributes.visual = gtk_widget_get_visual (widget); diff --git a/gtk/gtkiconview.c b/gtk/gtkiconview.c index 9e9ed3dee..c3f9254b4 100644 --- a/gtk/gtkiconview.c +++ b/gtk/gtkiconview.c @@ -39,6 +39,7 @@ #include "gtkentry.h" #include "gtkcombobox.h" #include "gtktextbuffer.h" +#include "gtksizerequest.h" #include "gtktreednd.h" #include "gtkprivate.h" @@ -2803,6 +2804,7 @@ gtk_icon_view_layout (GtkIconView *icon_view) gint y = 0, maximum_width = 0; GList *icons; GtkWidget *widget; + GtkRequisition requisition; gint row; gint item_width; @@ -2862,8 +2864,10 @@ gtk_icon_view_layout (GtkIconView *icon_view) gtk_icon_view_set_adjustment_upper (icon_view->priv->vadjustment, icon_view->priv->height); - if (icon_view->priv->width != widget->requisition.width || - icon_view->priv->height != widget->requisition.height) + gtk_size_request_get_size (GTK_SIZE_REQUEST (widget), &requisition, NULL); + + if (icon_view->priv->width != requisition.width || + icon_view->priv->height != requisition.height) gtk_widget_queue_resize_no_redraw (widget); if (gtk_widget_get_realized (GTK_WIDGET (icon_view))) diff --git a/gtk/gtkimage.c b/gtk/gtkimage.c index 004a36df5..2989b7214 100644 --- a/gtk/gtkimage.c +++ b/gtk/gtkimage.c @@ -33,6 +33,7 @@ #include "gtkiconfactory.h" #include "gtkstock.h" #include "gtkicontheme.h" +#include "gtksizerequest.h" #include "gtkintl.h" #include "gtkprivate.h" @@ -150,6 +151,8 @@ struct _GtkImagePrivate * only used with GTK_IMAGE_GICON, GTK_IMAGE_ICON_NAME */ gint pixel_size; guint need_calc_size : 1; + gint required_width; + gint required_height; }; @@ -1820,9 +1823,9 @@ gtk_image_expose (GtkWidget *widget, xalign = 1.0 - xalign; x = floor (widget->allocation.x + xpad - + ((widget->allocation.width - widget->requisition.width) * xalign)); + + ((widget->allocation.width - priv->required_width) * xalign)); y = floor (widget->allocation.y + ypad - + ((widget->allocation.height - widget->requisition.height) * yalign)); + + ((widget->allocation.height - priv->required_height) * yalign)); mask_x = x; mask_y = y; @@ -2230,7 +2233,7 @@ gtk_image_calc_size (GtkImage *image) /* We update stock/icon set on every size request, because * the theme could have affected the size; for other kinds of - * image, we just update the requisition when the image data + * image, we just update the required width/height when the image data * is set. */ switch (priv->storage_type) @@ -2272,8 +2275,8 @@ gtk_image_calc_size (GtkImage *image) gtk_misc_get_padding (GTK_MISC (image), &xpad, &ypad); - widget->requisition.width = gdk_pixbuf_get_width (pixbuf) + xpad * 2; - widget->requisition.height = gdk_pixbuf_get_height (pixbuf) + ypad * 2; + priv->required_width = gdk_pixbuf_get_width (pixbuf) + xpad * 2; + priv->required_height = gdk_pixbuf_get_height (pixbuf) + ypad * 2; g_object_unref (pixbuf); } @@ -2284,13 +2287,15 @@ gtk_image_size_request (GtkWidget *widget, GtkRequisition *requisition) { GtkImage *image; + GtkImagePrivate *priv; image = GTK_IMAGE (widget); + priv = image->priv; gtk_image_calc_size (image); - /* Chain up to default that simply reads current requisition */ - GTK_WIDGET_CLASS (gtk_image_parent_class)->size_request (widget, requisition); + requisition->width = priv->required_width; + requisition->height = priv->required_height; } static void @@ -2326,13 +2331,14 @@ gtk_image_update_size (GtkImage *image, gint image_width, gint image_height) { - GtkWidget *widget = GTK_WIDGET (image); - gint xpad, ypad; + GtkWidget *widget = GTK_WIDGET (image); + GtkImagePrivate *priv = image->priv; + gint xpad, ypad; gtk_misc_get_padding (GTK_MISC (image), &xpad, &ypad); - widget->requisition.width = image_width + xpad * 2; - widget->requisition.height = image_height + ypad * 2; + priv->required_width = image_width + xpad * 2; + priv->required_height = image_height + ypad * 2; if (gtk_widget_get_visible (widget)) gtk_widget_queue_resize (widget); diff --git a/gtk/gtkmenu.c b/gtk/gtkmenu.c index 17716f2b6..8e433f979 100644 --- a/gtk/gtkmenu.c +++ b/gtk/gtkmenu.c @@ -2047,8 +2047,9 @@ gtk_menu_set_tearoff_hints (GtkMenu *menu, if (gtk_widget_get_visible (menu->tearoff_scrollbar)) { - gtk_widget_size_request (menu->tearoff_scrollbar, NULL); - width += menu->tearoff_scrollbar->requisition.width; + GtkRequisition requisition; + gtk_widget_size_request (menu->tearoff_scrollbar, &requisition); + width += requisition.width; } geometry_hints.min_width = width; diff --git a/gtk/gtkmisc.c b/gtk/gtkmisc.c index 94d3052b6..1f5a9557b 100644 --- a/gtk/gtkmisc.c +++ b/gtk/gtkmisc.c @@ -268,7 +268,6 @@ gtk_misc_set_padding (GtkMisc *misc, gint ypad) { GtkMiscPrivate *priv; - GtkRequisition *requisition; g_return_if_fail (GTK_IS_MISC (misc)); @@ -288,16 +287,9 @@ gtk_misc_set_padding (GtkMisc *misc, if (ypad != priv->ypad) g_object_notify (G_OBJECT (misc), "ypad"); - requisition = &(GTK_WIDGET (misc)->requisition); - requisition->width -= priv->xpad * 2; - requisition->height -= priv->ypad * 2; - priv->xpad = xpad; priv->ypad = ypad; - requisition->width += priv->xpad * 2; - requisition->height += priv->ypad * 2; - if (gtk_widget_is_drawable (GTK_WIDGET (misc))) gtk_widget_queue_resize (GTK_WIDGET (misc)); diff --git a/gtk/gtkpathbar.c b/gtk/gtkpathbar.c index 3c36f3814..84379127a 100644 --- a/gtk/gtkpathbar.c +++ b/gtk/gtkpathbar.c @@ -355,8 +355,6 @@ gtk_path_bar_size_request (GtkWidget *widget, border_width = gtk_container_get_border_width (GTK_CONTAINER (widget)); requisition->width += border_width * 2; requisition->height += border_width * 2; - - widget->requisition = *requisition; } static void diff --git a/gtk/gtkprivate.h b/gtk/gtkprivate.h index 8db5c4851..e4505420f 100644 --- a/gtk/gtkprivate.h +++ b/gtk/gtkprivate.h @@ -47,9 +47,8 @@ typedef enum PRIVATE_GTK_CHILD_VISIBLE = 1 << 10, /* If widget should be mapped when parent is mapped */ PRIVATE_GTK_REDRAW_ON_ALLOC = 1 << 11, /* If we should queue a draw on the entire widget when it is reallocated */ PRIVATE_GTK_ALLOC_NEEDED = 1 << 12, /* If we we should allocate even if the allocation is the same */ - PRIVATE_GTK_REQUEST_NEEDED = 1 << 13, /* Whether we need to call gtk_widget_size_request */ - PRIVATE_GTK_WIDTH_REQUEST_NEEDED = 1 << 14, /* Whether we need to call gtk_extended_layout_get_desired_width */ - PRIVATE_GTK_HEIGHT_REQUEST_NEEDED = 1 << 15 /* Whether we need to call gtk_extended_layout_get_desired_height */ + PRIVATE_GTK_WIDTH_REQUEST_NEEDED = 1 << 13, /* Whether we need to call gtk_extended_layout_get_desired_width */ + PRIVATE_GTK_HEIGHT_REQUEST_NEEDED = 1 << 14 /* Whether we need to call gtk_extended_layout_get_desired_height */ } GtkPrivateFlags; /* Macros for extracting a widgets private_flags from GtkWidget. @@ -67,7 +66,6 @@ typedef enum #define GTK_WIDGET_CHILD_VISIBLE(obj) ((GTK_PRIVATE_FLAGS (obj) & PRIVATE_GTK_CHILD_VISIBLE) != 0) #define GTK_WIDGET_REDRAW_ON_ALLOC(obj) ((GTK_PRIVATE_FLAGS (obj) & PRIVATE_GTK_REDRAW_ON_ALLOC) != 0) #define GTK_WIDGET_ALLOC_NEEDED(obj) ((GTK_PRIVATE_FLAGS (obj) & PRIVATE_GTK_ALLOC_NEEDED) != 0) -#define GTK_WIDGET_REQUEST_NEEDED(obj) ((GTK_PRIVATE_FLAGS (obj) & PRIVATE_GTK_REQUEST_NEEDED) != 0) #define GTK_WIDGET_WIDTH_REQUEST_NEEDED(obj) ((GTK_PRIVATE_FLAGS (obj) & PRIVATE_GTK_WIDTH_REQUEST_NEEDED) != 0) #define GTK_WIDGET_HEIGHT_REQUEST_NEEDED(obj) ((GTK_PRIVATE_FLAGS (obj) & PRIVATE_GTK_HEIGHT_REQUEST_NEEDED) != 0) diff --git a/gtk/gtkruler.c b/gtk/gtkruler.c index eff3bfe82..95aba88de 100644 --- a/gtk/gtkruler.c +++ b/gtk/gtkruler.c @@ -189,7 +189,6 @@ gtk_ruler_class_init (GtkRulerClass *class) static void gtk_ruler_init (GtkRuler *ruler) { - GtkWidget *widget = GTK_WIDGET (ruler); GtkRulerPrivate *priv; ruler->priv = G_TYPE_INSTANCE_GET_PRIVATE (ruler, @@ -199,9 +198,6 @@ gtk_ruler_init (GtkRuler *ruler) priv->orientation = GTK_ORIENTATION_HORIZONTAL; - widget->requisition.width = widget->style->xthickness * 2 + 1; - widget->requisition.height = widget->style->ythickness * 2 + RULER_WIDTH; - priv->backing_store = NULL; priv->xsrc = 0; priv->ysrc = 0; diff --git a/gtk/gtkseparator.c b/gtk/gtkseparator.c index 43f9ae5c9..927bfef9e 100644 --- a/gtk/gtkseparator.c +++ b/gtk/gtkseparator.c @@ -95,7 +95,6 @@ gtk_separator_class_init (GtkSeparatorClass *class) static void gtk_separator_init (GtkSeparator *separator) { - GtkWidget *widget = GTK_WIDGET (separator); GtkSeparatorPrivate *private; separator->priv = G_TYPE_INSTANCE_GET_PRIVATE (separator, @@ -106,9 +105,6 @@ gtk_separator_init (GtkSeparator *separator) gtk_widget_set_has_window (GTK_WIDGET (separator), FALSE); private->orientation = GTK_ORIENTATION_HORIZONTAL; - - widget->requisition.width = 1; - widget->requisition.height = widget->style->ythickness; } static void diff --git a/gtk/gtksizegroup.c b/gtk/gtksizegroup.c index 87f5c4858..59ddc6e98 100644 --- a/gtk/gtksizegroup.c +++ b/gtk/gtksizegroup.c @@ -187,7 +187,6 @@ real_queue_resize (GtkWidget *widget) GtkWidget *parent; GTK_PRIVATE_SET_FLAG (widget, GTK_ALLOC_NEEDED); - 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); diff --git a/gtk/gtksizerequest.c b/gtk/gtksizerequest.c index 77f99c40d..4af24144f 100644 --- a/gtk/gtksizerequest.c +++ b/gtk/gtksizerequest.c @@ -196,18 +196,14 @@ get_cache (GtkSizeRequest *widget, return cache; } - static void -do_size_request (GtkWidget *widget) +do_size_request (GtkWidget *widget, + GtkRequisition *requisition) { - if (GTK_WIDGET_REQUEST_NEEDED (widget)) - { - gtk_widget_ensure_style (widget); - GTK_PRIVATE_UNSET_FLAG (widget, GTK_REQUEST_NEEDED); - g_signal_emit_by_name (widget, - "size-request", - &widget->requisition); - } + /* Now we dont bother caching the deprecated "size-request" returns, + * just unconditionally invoke here just in case we run into legacy stuff */ + gtk_widget_ensure_style (widget); + g_signal_emit_by_name (widget, "size-request", requisition); } static void @@ -255,15 +251,16 @@ compute_size_for_orientation (GtkSizeRequest *request, if (!found_in_cache) { + GtkRequisition requisition = { 0, 0 }; gint min_size = 0, nat_size = 0; gint group_size, requisition_size; /* Unconditional size request runs but is often unhandled. */ - do_size_request (widget); + do_size_request (widget, &requisition); if (orientation == GTK_SIZE_GROUP_HORIZONTAL) { - requisition_size = widget->requisition.width; + requisition_size = requisition.width; if (for_size < 0) GTK_SIZE_REQUEST_GET_IFACE (request)->get_width (request, &min_size, &nat_size); @@ -273,7 +270,7 @@ compute_size_for_orientation (GtkSizeRequest *request, } else { - requisition_size = widget->requisition.height; + requisition_size = requisition.height; if (for_size < 0) GTK_SIZE_REQUEST_GET_IFACE (request)->get_height (request, &min_size, &nat_size); @@ -288,9 +285,8 @@ compute_size_for_orientation (GtkSizeRequest *request, G_OBJECT_TYPE_NAME (request), request, min_size, nat_size); } - /* Support for dangling "size-request" signals and forward derived - * classes that will not default to a ->get_width() that - * returns the values in the ->requisition cache. + /* Support for dangling "size-request" signal implementations on + * legacy widgets */ min_size = MAX (min_size, requisition_size); nat_size = MAX (nat_size, requisition_size); diff --git a/gtk/gtkspinbutton.c b/gtk/gtkspinbutton.c index 649b0daf6..5cc2ba024 100644 --- a/gtk/gtkspinbutton.c +++ b/gtk/gtkspinbutton.c @@ -40,6 +40,7 @@ #include "gtkmain.h" #include "gtkmarshalers.h" #include "gtksettings.h" +#include "gtksizerequest.h" #include "gtkprivate.h" #include "gtkintl.h" @@ -582,12 +583,15 @@ gtk_spin_button_realize (GtkWidget *widget) GtkSpinButton *spin_button = GTK_SPIN_BUTTON (widget); GtkSpinButtonPrivate *priv = spin_button->priv; GdkWindowAttr attributes; + GtkRequisition requisition; gint attributes_mask; gboolean return_val; gint arrow_size; arrow_size = spin_button_get_arrow_size (spin_button); + gtk_size_request_get_size (GTK_SIZE_REQUEST (spin_button), &requisition, NULL); + gtk_widget_set_events (widget, gtk_widget_get_events (widget) | GDK_KEY_RELEASE_MASK); GTK_WIDGET_CLASS (gtk_spin_button_parent_class)->realize (widget); @@ -605,10 +609,9 @@ gtk_spin_button_realize (GtkWidget *widget) attributes.x = (widget->allocation.width - arrow_size - 2 * widget->style->xthickness); - attributes.y = (widget->allocation.height - - widget->requisition.height) / 2; + attributes.y = (widget->allocation.height - requisition.height) / 2; attributes.width = arrow_size + 2 * widget->style->xthickness; - attributes.height = widget->requisition.height; + attributes.height = requisition.height; priv->panel = gdk_window_new (widget->window, &attributes, attributes_mask); @@ -736,6 +739,7 @@ gtk_spin_button_size_allocate (GtkWidget *widget, { GtkSpinButton *spin = GTK_SPIN_BUTTON (widget); GtkSpinButtonPrivate *priv = spin->priv; + GtkRequisition requisition; GtkAllocation panel_allocation; gint arrow_size; gint panel_width; @@ -743,6 +747,8 @@ gtk_spin_button_size_allocate (GtkWidget *widget, arrow_size = spin_button_get_arrow_size (spin); panel_width = arrow_size + 2 * widget->style->xthickness; + gtk_size_request_get_size (GTK_SIZE_REQUEST (widget), &requisition, NULL); + widget->allocation = *allocation; if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL) @@ -751,7 +757,7 @@ gtk_spin_button_size_allocate (GtkWidget *widget, panel_allocation.x = allocation->width - panel_width; panel_allocation.width = panel_width; - panel_allocation.height = MIN (widget->requisition.height, allocation->height); + panel_allocation.height = MIN (requisition.height, allocation->height); panel_allocation.y = 0; @@ -858,21 +864,25 @@ gtk_spin_button_draw_arrow (GtkSpinButton *spin_button, if (gtk_widget_is_drawable (widget)) { + GtkRequisition requisition; + width = spin_button_get_arrow_size (spin_button) + 2 * widget->style->xthickness; + gtk_size_request_get_size (GTK_SIZE_REQUEST (widget), &requisition, NULL); + if (arrow_type == GTK_ARROW_UP) { x = 0; y = 0; - height = widget->requisition.height / 2; + height = requisition.height / 2; } else { x = 0; - y = widget->requisition.height / 2; + y = requisition.height / 2; - height = (widget->requisition.height + 1) / 2; + height = (requisition.height + 1) / 2; } if (spin_button_at_limit (spin_button, arrow_type)) @@ -909,7 +919,7 @@ gtk_spin_button_draw_arrow (GtkSpinButton *spin_button, (arrow_type == GTK_ARROW_UP)? "spinbutton_up" : "spinbutton_down", x, y, width, height); - height = widget->requisition.height; + height = requisition.height; if (arrow_type == GTK_ARROW_DOWN) { @@ -953,6 +963,7 @@ gtk_spin_button_enter_notify (GtkWidget *widget, { GtkSpinButton *spin = GTK_SPIN_BUTTON (widget); GtkSpinButtonPrivate *priv = spin->priv; + GtkRequisition requisition; if (event->window == priv->panel) { @@ -963,7 +974,9 @@ gtk_spin_button_enter_notify (GtkWidget *widget, device = gdk_event_get_device ((GdkEvent *) event); gdk_window_get_device_position (priv->panel, device, &x, &y, NULL); - if (y <= widget->requisition.height / 2) + gtk_size_request_get_size (GTK_SIZE_REQUEST (widget), &requisition, NULL); + + if (y <= requisition.height / 2) priv->in_child = GTK_ARROW_UP; else priv->in_child = GTK_ARROW_DOWN; @@ -1132,6 +1145,8 @@ gtk_spin_button_button_press (GtkWidget *widget, { if (event->window == priv->panel) { + GtkRequisition requisition; + if (!gtk_widget_has_focus (widget)) gtk_widget_grab_focus (widget); priv->button = event->button; @@ -1139,7 +1154,9 @@ gtk_spin_button_button_press (GtkWidget *widget, if (GTK_ENTRY (widget)->editable) gtk_spin_button_update (spin); - if (event->y <= widget->requisition.height / 2) + gtk_size_request_get_size (GTK_SIZE_REQUEST (widget), &requisition, NULL); + + if (event->y <= requisition.height / 2) { if (event->button == 1) start_spinning (spin, GTK_ARROW_UP, priv->adjustment->step_increment); @@ -1183,12 +1200,16 @@ gtk_spin_button_button_release (GtkWidget *widget, if (event->button == 3) { + GtkRequisition requisition; + + gtk_size_request_get_size (GTK_SIZE_REQUEST (widget), &requisition, NULL); + if (event->y >= 0 && event->x >= 0 && - event->y <= widget->requisition.height && + event->y <= requisition.height && event->x <= arrow_size + 2 * widget->style->xthickness) { if (click_child == GTK_ARROW_UP && - event->y <= widget->requisition.height / 2) + event->y <= requisition.height / 2) { gdouble diff; @@ -1197,7 +1218,7 @@ gtk_spin_button_button_release (GtkWidget *widget, gtk_spin_button_real_spin (spin, diff); } else if (click_child == GTK_ARROW_DOWN && - event->y > widget->requisition.height / 2) + event->y > requisition.height / 2) { gdouble diff; @@ -1228,16 +1249,19 @@ gtk_spin_button_motion_notify (GtkWidget *widget, if (event->window == priv->panel) { gint y = event->y; + GtkRequisition requisition; gdk_event_request_motions (event); - - if (y <= widget->requisition.height / 2 && + + gtk_size_request_get_size (GTK_SIZE_REQUEST (widget), &requisition, NULL); + + if (y <= requisition.height / 2 && priv->in_child == GTK_ARROW_DOWN) { priv->in_child = GTK_ARROW_UP; gtk_widget_queue_draw (GTK_WIDGET (spin)); } - else if (y > widget->requisition.height / 2 && + else if (y > requisition.height / 2 && priv->in_child == GTK_ARROW_UP) { priv->in_child = GTK_ARROW_DOWN; diff --git a/gtk/gtktextview.c b/gtk/gtktextview.c index 050aebbb2..e79dec917 100644 --- a/gtk/gtktextview.c +++ b/gtk/gtktextview.c @@ -40,6 +40,7 @@ #include "gtkseparatormenuitem.h" #include "gtksettings.h" #include "gtkstock.h" +#include "gtksizerequest.h" #include "gtktextbufferrichtext.h" #include "gtktextdisplay.h" #include "gtktextview.h" @@ -3933,7 +3934,7 @@ changed_handler (GtkTextLayout *layout, GtkRequisition old_req; GtkRequisition new_req; - old_req = widget->requisition; + gtk_size_request_get_size (GTK_SIZE_REQUEST (widget), &old_req, NULL); /* Use this instead of gtk_widget_size_request wrapper * to avoid the optimization which just returns widget->requisition diff --git a/gtk/gtktreeview.c b/gtk/gtktreeview.c index a9da909b3..8e370bcc2 100644 --- a/gtk/gtktreeview.c +++ b/gtk/gtktreeview.c @@ -43,6 +43,7 @@ #include "gtkframe.h" #include "gtktreemodelsort.h" #include "gtktooltip.h" +#include "gtksizerequest.h" #include "gtkprivate.h" #define GTK_TREE_VIEW_PRIORITY_VALIDATE (GDK_PRIORITY_REDRAW + 5) @@ -5323,8 +5324,11 @@ gtk_tree_view_key_press (GtkWidget *widget, if (event->keyval == (rtl ? GDK_Right : GDK_Left) || event->keyval == (rtl ? GDK_KP_Right : GDK_KP_Left)) { + GtkRequisition button_req; gint old_width = column->resized_width; + gtk_size_request_get_size (GTK_SIZE_REQUEST (column->button), &button_req, NULL); + column->resized_width = MAX (column->resized_width, column->width); column->resized_width -= 2; @@ -5332,7 +5336,7 @@ gtk_tree_view_key_press (GtkWidget *widget, column->resized_width = 0; if (column->min_width == -1) - column->resized_width = MAX (column->button->requisition.width, + column->resized_width = MAX (button_req.width, column->resized_width); else column->resized_width = MAX (column->min_width, @@ -10486,6 +10490,7 @@ gtk_tree_view_new_column_width (GtkTreeView *tree_view, gint *x) { GtkTreeViewColumn *column; + GtkRequisition button_req; gint width; gboolean rtl; @@ -10498,8 +10503,10 @@ gtk_tree_view_new_column_width (GtkTreeView *tree_view, /* Clamp down the value */ if (column->min_width == -1) - width = MAX (column->button->requisition.width, - width); + { + gtk_size_request_get_size (GTK_SIZE_REQUEST (column->button), &button_req, NULL); + width = MAX (button_req.width, width); + } else width = MAX (column->min_width, width); diff --git a/gtk/gtkwidget.c b/gtk/gtkwidget.c index 6f34ec1b3..628dc9207 100644 --- a/gtk/gtkwidget.c +++ b/gtk/gtkwidget.c @@ -2856,8 +2856,6 @@ gtk_widget_init (GtkWidget *widget) widget->state = GTK_STATE_NORMAL; widget->saved_state = GTK_STATE_NORMAL; widget->name = NULL; - widget->requisition.width = 0; - widget->requisition.height = 0; widget->allocation.x = -1; widget->allocation.y = -1; widget->allocation.width = 1; @@ -2871,7 +2869,6 @@ gtk_widget_init (GtkWidget *widget) 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); @@ -3783,12 +3780,6 @@ gtk_widget_size_request (GtkWidget *widget, { g_return_if_fail (GTK_IS_WIDGET (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."); -#endif /* G_ENABLE_DEBUG */ - gtk_size_request_get_size (GTK_SIZE_REQUEST (widget), requisition, NULL); } @@ -3927,7 +3918,8 @@ gtk_widget_size_allocate (GtkWidget *widget, #endif /* G_ENABLE_DEBUG */ alloc_needed = GTK_WIDGET_ALLOC_NEEDED (widget); - if (!GTK_WIDGET_REQUEST_NEEDED (widget)) /* Preserve request/allocate ordering */ + if (!GTK_WIDGET_WIDTH_REQUEST_NEEDED (widget) && + !GTK_WIDGET_HEIGHT_REQUEST_NEEDED (widget)) /* Preserve request/allocate ordering */ GTK_PRIVATE_UNSET_FLAG (widget, GTK_ALLOC_NEEDED); old_allocation = widget->allocation; @@ -8887,8 +8879,8 @@ static void gtk_widget_real_size_request (GtkWidget *widget, GtkRequisition *requisition) { - requisition->width = widget->requisition.width; - requisition->height = widget->requisition.height; + requisition->width = 0; + requisition->height = 0; } /** @@ -10809,14 +10801,11 @@ gtk_widget_real_get_width (GtkSizeRequest *widget, 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 (widget)->requisition.width; + *minimum_size = 0; if (natural_size) - *natural_size = GTK_WIDGET (widget)->requisition.width; + *natural_size = 0; } static void @@ -10824,14 +10813,11 @@ gtk_widget_real_get_height (GtkSizeRequest *widget, 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 (widget)->requisition.height; + *minimum_size = 0; if (natural_size) - *natural_size = GTK_WIDGET (widget)->requisition.height; + *natural_size = 0; } static void @@ -11373,6 +11359,10 @@ gtk_widget_set_allocation (GtkWidget *widget, * Normally, gtk_widget_size_request() should be used. * * Since: 2.20 + * + * Deprecated: 3.0: The #GtkRequisition cache on the widget was + * removed, If you need to cache sizes across requests and allocations, + * add an explicit cache to the widget in question instead. */ void gtk_widget_get_requisition (GtkWidget *widget, @@ -11381,7 +11371,7 @@ gtk_widget_get_requisition (GtkWidget *widget, g_return_if_fail (GTK_IS_WIDGET (widget)); g_return_if_fail (requisition != NULL); - *requisition = widget->requisition; + gtk_size_request_get_size (GTK_SIZE_REQUEST (widget), requisition, NULL); } /** diff --git a/gtk/gtkwidget.h b/gtk/gtkwidget.h index 4b35ca3b2..e07ebd519 100644 --- a/gtk/gtkwidget.h +++ b/gtk/gtkwidget.h @@ -294,10 +294,6 @@ struct _GtkWidget */ GtkStyle *GSEAL (style); - /* The widget's desired size. - */ - GtkRequisition GSEAL (requisition); - /* The widget's allocated size. */ GtkAllocation GSEAL (allocation); -- 2.43.2