X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gtk%2Fgtklayout.c;h=73cdb62f2ac50fceb0166ec8a7389c904a01cb83;hb=4bb90a74433d2d38dcf63a2dbc549f549b51c3c3;hp=fab1875673ca35abf54d5a53fdfb00976258bb01;hpb=1e5d7c022596b7146638ef8bd74f544725f9bf2b;p=~andy%2Fgtk diff --git a/gtk/gtklayout.c b/gtk/gtklayout.c index fab187567..73cdb62f2 100644 --- a/gtk/gtklayout.c +++ b/gtk/gtklayout.c @@ -12,9 +12,7 @@ * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the - * Free Software Foundation, Inc., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. + * License along with this library. If not, see . * * GtkLayout: Widget for scrolling of arbitrary-sized areas. * @@ -29,12 +27,37 @@ */ #include "config.h" -#include "gdkconfig.h" #include "gtklayout.h" -#include "gtkprivate.h" + +#include "gdk/gdk.h" + +#include "gtkadjustment.h" #include "gtkintl.h" #include "gtkmarshalers.h" +#include "gtkprivate.h" +#include "gtkscrollable.h" + + +/** + * SECTION:gtklayout + * @Short_description: Infinite scrollable area containing child widgets + * and/or custom drawing + * @Title: GtkLayout + * @See_also: #GtkDrawingArea, #GtkScrolledWindow + * + * #GtkLayout is similar to #GtkDrawingArea in that it's a "blank slate" + * and doesn't do anything but paint a blank background by default. It's + * different in that it supports scrolling natively (you can add it to a + * #GtkScrolledWindow), and it can contain child widgets, since it's a + * #GtkContainer. However if you're just going to draw, a #GtkDrawingArea + * is a better choice since it has lower overhead. + * + * When handling expose events on a #GtkLayout, you must draw to + * GTK_LAYOUT (layout)->bin_window, rather than to + * GTK_WIDGET (layout)->window, as you would for a drawing + * area. + */ typedef struct _GtkLayoutChild GtkLayoutChild; @@ -47,6 +70,12 @@ struct _GtkLayoutPrivate GtkAdjustment *hadjustment; GtkAdjustment *vadjustment; + + /* GtkScrollablePolicy needs to be checked when + * driving the scrollable adjustment values */ + guint hscroll_policy : 1; + guint vscroll_policy : 1; + /* Properties */ GdkVisibilityState visibility; @@ -70,6 +99,8 @@ enum { PROP_0, PROP_HADJUSTMENT, PROP_VADJUSTMENT, + PROP_HSCROLL_POLICY, + PROP_VSCROLL_POLICY, PROP_WIDTH, PROP_HEIGHT }; @@ -88,19 +119,20 @@ static void gtk_layout_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec); -static GObject *gtk_layout_constructor (GType type, - guint n_properties, - GObjectConstructParam *properties); static void gtk_layout_finalize (GObject *object); static void gtk_layout_realize (GtkWidget *widget); static void gtk_layout_unrealize (GtkWidget *widget); static void gtk_layout_map (GtkWidget *widget); -static void gtk_layout_size_request (GtkWidget *widget, - GtkRequisition *requisition); +static void gtk_layout_get_preferred_width (GtkWidget *widget, + gint *minimum, + gint *natural); +static void gtk_layout_get_preferred_height (GtkWidget *widget, + gint *minimum, + gint *natural); static void gtk_layout_size_allocate (GtkWidget *widget, GtkAllocation *allocation); -static gint gtk_layout_expose (GtkWidget *widget, - GdkEventExpose *event); +static gint gtk_layout_draw (GtkWidget *widget, + cairo_t *cr); static void gtk_layout_add (GtkContainer *container, GtkWidget *widget); static void gtk_layout_remove (GtkContainer *container, @@ -109,9 +141,6 @@ static void gtk_layout_forall (GtkContainer *container, gboolean include_internals, GtkCallback callback, gpointer callback_data); -static void gtk_layout_set_adjustments (GtkLayout *layout, - GtkAdjustment *hadj, - GtkAdjustment *vadj); static void gtk_layout_set_child_property (GtkContainer *container, GtkWidget *child, guint property_id, @@ -126,14 +155,13 @@ static void gtk_layout_allocate_child (GtkLayout *layout, GtkLayoutChild *child); static void gtk_layout_adjustment_changed (GtkAdjustment *adjustment, GtkLayout *layout); -static void gtk_layout_style_set (GtkWidget *widget, - GtkStyle *old_style); +static void gtk_layout_style_updated (GtkWidget *widget); -static void gtk_layout_set_adjustment_upper (GtkAdjustment *adj, - gdouble upper, - gboolean always_emit_changed); +static void gtk_layout_set_hadjustment_values (GtkLayout *layout); +static void gtk_layout_set_vadjustment_values (GtkLayout *layout); -G_DEFINE_TYPE (GtkLayout, gtk_layout, GTK_TYPE_CONTAINER) +G_DEFINE_TYPE_WITH_CODE (GtkLayout, gtk_layout, GTK_TYPE_CONTAINER, + G_IMPLEMENT_INTERFACE (GTK_TYPE_SCROLLABLE, NULL)) /* Public interface */ @@ -166,10 +194,10 @@ gtk_layout_new (GtkAdjustment *hadjustment, /** * gtk_layout_get_bin_window: * @layout: a #GtkLayout - * + * * Retrieve the bin window of the layout used for drawing operations. - * - * Return value: a #GdkWindow + * + * Return value: (transfer none): a #GdkWindow * * Since: 2.14 **/ @@ -184,18 +212,20 @@ gtk_layout_get_bin_window (GtkLayout *layout) /** * gtk_layout_get_hadjustment: * @layout: a #GtkLayout - * + * * This function should only be called after the layout has been * placed in a #GtkScrolledWindow or otherwise configured for * scrolling. It returns the #GtkAdjustment used for communication * between the horizontal scrollbar and @layout. * * See #GtkScrolledWindow, #GtkScrollbar, #GtkAdjustment for details. - * - * Return value: horizontal scroll adjustment + * + * Return value: (transfer none): horizontal scroll adjustment + * + * Deprecated: 3.0: Use gtk_scrollable_get_hadjustment() **/ -GtkAdjustment* -gtk_layout_get_hadjustment (GtkLayout *layout) +GtkAdjustment* +gtk_layout_get_hadjustment (GtkLayout *layout) { g_return_val_if_fail (GTK_IS_LAYOUT (layout), NULL); @@ -204,91 +234,79 @@ gtk_layout_get_hadjustment (GtkLayout *layout) /** * gtk_layout_get_vadjustment: * @layout: a #GtkLayout - * + * * This function should only be called after the layout has been * placed in a #GtkScrolledWindow or otherwise configured for * scrolling. It returns the #GtkAdjustment used for communication * between the vertical scrollbar and @layout. * * See #GtkScrolledWindow, #GtkScrollbar, #GtkAdjustment for details. - * - * Return value: vertical scroll adjustment + * + * Return value: (transfer none): vertical scroll adjustment + * + * Deprecated: 3.0: Use gtk_scrollable_get_vadjustment() **/ -GtkAdjustment* -gtk_layout_get_vadjustment (GtkLayout *layout) +GtkAdjustment* +gtk_layout_get_vadjustment (GtkLayout *layout) { g_return_val_if_fail (GTK_IS_LAYOUT (layout), NULL); return layout->priv->vadjustment; } -static GtkAdjustment * -new_default_adjustment (void) +static void +gtk_layout_set_hadjustment_values (GtkLayout *layout) { - return GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0)); + GtkLayoutPrivate *priv = layout->priv; + GtkAllocation allocation; + GtkAdjustment *adj = priv->hadjustment; + gdouble old_value; + gdouble new_value; + gdouble new_upper; + + gtk_widget_get_allocation (GTK_WIDGET (layout), &allocation); + + old_value = gtk_adjustment_get_value (adj); + new_upper = MAX (allocation.width, priv->width); + + g_object_set (adj, + "lower", 0.0, + "upper", new_upper, + "page-size", (gdouble)allocation.width, + "step-increment", allocation.width * 0.1, + "page-increment", allocation.width * 0.9, + NULL); + + new_value = CLAMP (old_value, 0, new_upper - allocation.width); + if (new_value != old_value) + gtk_adjustment_set_value (adj, new_value); } -static void -gtk_layout_set_adjustments (GtkLayout *layout, - GtkAdjustment *hadj, - GtkAdjustment *vadj) +static void +gtk_layout_set_vadjustment_values (GtkLayout *layout) { - GtkLayoutPrivate *priv = layout->priv; - gboolean need_adjust = FALSE; - - if (hadj) - g_return_if_fail (GTK_IS_ADJUSTMENT (hadj)); - else if (priv->hadjustment) - hadj = new_default_adjustment (); - if (vadj) - g_return_if_fail (GTK_IS_ADJUSTMENT (vadj)); - else if (priv->vadjustment) - vadj = new_default_adjustment (); - - if (priv->hadjustment && (priv->hadjustment != hadj)) - { - g_signal_handlers_disconnect_by_func (priv->hadjustment, - gtk_layout_adjustment_changed, - layout); - g_object_unref (priv->hadjustment); - } - - if (priv->vadjustment && (priv->vadjustment != vadj)) - { - g_signal_handlers_disconnect_by_func (priv->vadjustment, - gtk_layout_adjustment_changed, - layout); - g_object_unref (priv->vadjustment); - } - - if (priv->hadjustment != hadj) - { - priv->hadjustment = hadj; - g_object_ref_sink (priv->hadjustment); - gtk_layout_set_adjustment_upper (priv->hadjustment, priv->width, FALSE); - - g_signal_connect (priv->hadjustment, "value-changed", - G_CALLBACK (gtk_layout_adjustment_changed), - layout); - need_adjust = TRUE; - } - - if (priv->vadjustment != vadj) - { - priv->vadjustment = vadj; - g_object_ref_sink (priv->vadjustment); - gtk_layout_set_adjustment_upper (priv->vadjustment, priv->height, FALSE); - - g_signal_connect (priv->vadjustment, "value-changed", - G_CALLBACK (gtk_layout_adjustment_changed), - layout); - need_adjust = TRUE; - } - - /* vadj or hadj can be NULL while constructing; don't emit a signal - then */ - if (need_adjust && vadj && hadj) - gtk_layout_adjustment_changed (NULL, layout); + GtkAllocation allocation; + GtkAdjustment *adj = layout->priv->vadjustment; + gdouble old_value; + gdouble new_value; + gdouble new_upper; + + gtk_widget_get_allocation (GTK_WIDGET (layout), &allocation); + + old_value = gtk_adjustment_get_value (adj); + new_upper = MAX (allocation.height, layout->priv->height); + + g_object_set (adj, + "lower", 0.0, + "upper", new_upper, + "page-size", (gdouble)allocation.height, + "step-increment", allocation.height * 0.1, + "page-increment", allocation.height * 0.9, + NULL); + + new_value = CLAMP (old_value, 0, new_upper - allocation.height); + if (new_value != old_value) + gtk_adjustment_set_value (adj, new_value); } static void @@ -303,6 +321,36 @@ gtk_layout_finalize (GObject *object) G_OBJECT_CLASS (gtk_layout_parent_class)->finalize (object); } +static void +gtk_layout_do_set_hadjustment (GtkLayout *layout, + GtkAdjustment *adjustment) +{ + GtkLayoutPrivate *priv; + + priv = layout->priv; + + if (adjustment && priv->hadjustment == adjustment) + return; + + if (priv->hadjustment != NULL) + { + g_signal_handlers_disconnect_by_func (priv->hadjustment, + gtk_layout_adjustment_changed, + layout); + g_object_unref (priv->hadjustment); + } + + if (adjustment == NULL) + adjustment = gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0); + + g_signal_connect (adjustment, "value-changed", + G_CALLBACK (gtk_layout_adjustment_changed), layout); + priv->hadjustment = g_object_ref_sink (adjustment); + gtk_layout_set_hadjustment_values (layout); + + g_object_notify (G_OBJECT (layout), "hadjustment"); +} + /** * gtk_layout_set_hadjustment: * @layout: a #GtkLayout @@ -311,22 +359,49 @@ gtk_layout_finalize (GObject *object) * Sets the horizontal scroll adjustment for the layout. * * See #GtkScrolledWindow, #GtkScrollbar, #GtkAdjustment for details. - * + * + * Deprecated: 3.0: Use gtk_scrollable_set_hadjustment() **/ -void +void gtk_layout_set_hadjustment (GtkLayout *layout, - GtkAdjustment *adjustment) + GtkAdjustment *adjustment) { - GtkLayoutPrivate *priv; - g_return_if_fail (GTK_IS_LAYOUT (layout)); + g_return_if_fail (adjustment == NULL || GTK_IS_ADJUSTMENT (adjustment)); + + gtk_layout_do_set_hadjustment (layout, adjustment); +} + +static void +gtk_layout_do_set_vadjustment (GtkLayout *layout, + GtkAdjustment *adjustment) +{ + GtkLayoutPrivate *priv; priv = layout->priv; - gtk_layout_set_adjustments (layout, adjustment, priv->vadjustment); - g_object_notify (G_OBJECT (layout), "hadjustment"); + if (adjustment && priv->vadjustment == adjustment) + return; + + if (priv->vadjustment != NULL) + { + g_signal_handlers_disconnect_by_func (priv->vadjustment, + gtk_layout_adjustment_changed, + layout); + g_object_unref (priv->vadjustment); + } + + if (adjustment == NULL) + adjustment = gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0); + + g_signal_connect (adjustment, "value-changed", + G_CALLBACK (gtk_layout_adjustment_changed), layout); + priv->vadjustment = g_object_ref_sink (adjustment); + gtk_layout_set_vadjustment_values (layout); + + g_object_notify (G_OBJECT (layout), "vadjustment"); } - + /** * gtk_layout_set_vadjustment: * @layout: a #GtkLayout @@ -335,20 +410,17 @@ gtk_layout_set_hadjustment (GtkLayout *layout, * Sets the vertical scroll adjustment for the layout. * * See #GtkScrolledWindow, #GtkScrollbar, #GtkAdjustment for details. - * + * + * Deprecated: 3.0: Use gtk_scrollable_set_vadjustment() **/ -void +void gtk_layout_set_vadjustment (GtkLayout *layout, - GtkAdjustment *adjustment) + GtkAdjustment *adjustment) { - GtkLayoutPrivate *priv; - g_return_if_fail (GTK_IS_LAYOUT (layout)); + g_return_if_fail (adjustment == NULL || GTK_IS_ADJUSTMENT (adjustment)); - priv = layout->priv; - - gtk_layout_set_adjustments (layout, priv->hadjustment, adjustment); - g_object_notify (G_OBJECT (layout), "vadjustment"); + gtk_layout_do_set_vadjustment (layout, adjustment); } static GtkLayoutChild* @@ -470,34 +542,6 @@ gtk_layout_move (GtkLayout *layout, gtk_layout_move_internal (layout, child_widget, TRUE, x, TRUE, y); } -static void -gtk_layout_set_adjustment_upper (GtkAdjustment *adj, - gdouble upper, - gboolean always_emit_changed) -{ - gboolean changed = FALSE; - gboolean value_changed = FALSE; - - gdouble min = MAX (0., upper - adj->page_size); - - if (upper != adj->upper) - { - adj->upper = upper; - changed = TRUE; - } - - if (adj->value > min) - { - adj->value = min; - value_changed = TRUE; - } - - if (changed || always_emit_changed) - gtk_adjustment_changed (adj); - if (value_changed) - gtk_adjustment_value_changed (adj); -} - /** * gtk_layout_set_size: * @layout: a #GtkLayout @@ -533,11 +577,6 @@ gtk_layout_set_size (GtkLayout *layout, } g_object_thaw_notify (G_OBJECT (layout)); - if (priv->hadjustment) - gtk_layout_set_adjustment_upper (priv->hadjustment, priv->width, FALSE); - if (priv->vadjustment) - gtk_layout_set_adjustment_upper (priv->vadjustment, priv->height, FALSE); - if (gtk_widget_get_realized (widget)) { GtkAllocation allocation; @@ -547,13 +586,18 @@ gtk_layout_set_size (GtkLayout *layout, height = MAX (height, allocation.height); gdk_window_resize (priv->bin_window, width, height); } + + gtk_layout_set_hadjustment_values (layout); + gtk_layout_set_vadjustment_values (layout); } /** * gtk_layout_get_size: * @layout: a #GtkLayout - * @width: (allow-none): location to store the width set on @layout, or %NULL - * @height: (allow-none): location to store the height set on @layout, or %NULL + * @width: (out) (allow-none): location to store the width set on + * @layout, or %NULL + * @height: (out) (allow-none): location to store the height set on + * @layout, or %NULL * * Gets the size that has been set on the layout, and that determines * the total extents of the layout's scrollbar area. See @@ -592,7 +636,6 @@ gtk_layout_class_init (GtkLayoutClass *class) gobject_class->set_property = gtk_layout_set_property; gobject_class->get_property = gtk_layout_get_property; gobject_class->finalize = gtk_layout_finalize; - gobject_class->constructor = gtk_layout_constructor; container_class->set_child_property = gtk_layout_set_child_property; container_class->get_child_property = gtk_layout_get_child_property; @@ -617,21 +660,11 @@ gtk_layout_class_init (GtkLayoutClass *class) 0, GTK_PARAM_READWRITE)); - g_object_class_install_property (gobject_class, - PROP_HADJUSTMENT, - g_param_spec_object ("hadjustment", - P_("Horizontal adjustment"), - P_("The GtkAdjustment for the horizontal position"), - GTK_TYPE_ADJUSTMENT, - GTK_PARAM_READWRITE)); - - g_object_class_install_property (gobject_class, - PROP_VADJUSTMENT, - g_param_spec_object ("vadjustment", - P_("Vertical adjustment"), - P_("The GtkAdjustment for the vertical position"), - GTK_TYPE_ADJUSTMENT, - GTK_PARAM_READWRITE)); + /* Scrollable interface */ + g_object_class_override_property (gobject_class, PROP_HADJUSTMENT, "hadjustment"); + g_object_class_override_property (gobject_class, PROP_VADJUSTMENT, "vadjustment"); + g_object_class_override_property (gobject_class, PROP_HSCROLL_POLICY, "hscroll-policy"); + g_object_class_override_property (gobject_class, PROP_VSCROLL_POLICY, "vscroll-policy"); g_object_class_install_property (gobject_class, PROP_WIDTH, @@ -654,37 +687,16 @@ gtk_layout_class_init (GtkLayoutClass *class) widget_class->realize = gtk_layout_realize; widget_class->unrealize = gtk_layout_unrealize; widget_class->map = gtk_layout_map; - widget_class->size_request = gtk_layout_size_request; + widget_class->get_preferred_width = gtk_layout_get_preferred_width; + widget_class->get_preferred_height = gtk_layout_get_preferred_height; widget_class->size_allocate = gtk_layout_size_allocate; - widget_class->expose_event = gtk_layout_expose; - widget_class->style_set = gtk_layout_style_set; + widget_class->draw = gtk_layout_draw; + widget_class->style_updated = gtk_layout_style_updated; container_class->add = gtk_layout_add; container_class->remove = gtk_layout_remove; container_class->forall = gtk_layout_forall; - class->set_scroll_adjustments = gtk_layout_set_adjustments; - - /** - * GtkLayout::set-scroll-adjustments - * @horizontal: the horizontal #GtkAdjustment - * @vertical: the vertical #GtkAdjustment - * - * Set the scroll adjustments for the layout. Usually scrolled containers - * like #GtkScrolledWindow will emit this signal to connect two instances - * of #GtkScrollbar to the scroll directions of the #GtkLayout. - */ - widget_class->set_scroll_adjustments_signal = - g_signal_new (I_("set-scroll-adjustments"), - G_OBJECT_CLASS_TYPE (gobject_class), - G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, - G_STRUCT_OFFSET (GtkLayoutClass, set_scroll_adjustments), - NULL, NULL, - _gtk_marshal_VOID__OBJECT_OBJECT, - G_TYPE_NONE, 2, - GTK_TYPE_ADJUSTMENT, - GTK_TYPE_ADJUSTMENT); - g_type_class_add_private (class, sizeof (GtkLayoutPrivate)); } @@ -705,6 +717,12 @@ gtk_layout_get_property (GObject *object, case PROP_VADJUSTMENT: g_value_set_object (value, priv->vadjustment); break; + case PROP_HSCROLL_POLICY: + g_value_set_enum (value, priv->hscroll_policy); + break; + case PROP_VSCROLL_POLICY: + g_value_set_enum (value, priv->vscroll_policy); + break; case PROP_WIDTH: g_value_set_uint (value, priv->width); break; @@ -729,12 +747,18 @@ gtk_layout_set_property (GObject *object, switch (prop_id) { case PROP_HADJUSTMENT: - gtk_layout_set_hadjustment (layout, - (GtkAdjustment*) g_value_get_object (value)); + gtk_layout_do_set_hadjustment (layout, g_value_get_object (value)); break; case PROP_VADJUSTMENT: - gtk_layout_set_vadjustment (layout, - (GtkAdjustment*) g_value_get_object (value)); + gtk_layout_do_set_vadjustment (layout, g_value_get_object (value)); + break; + case PROP_HSCROLL_POLICY: + priv->hscroll_policy = g_value_get_enum (value); + gtk_widget_queue_resize (GTK_WIDGET (layout)); + break; + case PROP_VSCROLL_POLICY: + priv->vscroll_policy = g_value_get_enum (value); + gtk_widget_queue_resize (GTK_WIDGET (layout)); break; case PROP_WIDTH: gtk_layout_set_size (layout, g_value_get_uint (value), @@ -829,32 +853,6 @@ gtk_layout_init (GtkLayout *layout) priv->freeze_count = 0; } -static GObject * -gtk_layout_constructor (GType type, - guint n_properties, - GObjectConstructParam *properties) -{ - GtkLayoutPrivate *priv; - GtkLayout *layout; - GObject *object; - GtkAdjustment *hadj, *vadj; - - object = G_OBJECT_CLASS (gtk_layout_parent_class)->constructor (type, - n_properties, - properties); - - layout = GTK_LAYOUT (object); - priv = layout->priv; - - hadj = priv->hadjustment ? priv->hadjustment : new_default_adjustment (); - vadj = priv->vadjustment ? priv->vadjustment : new_default_adjustment (); - - if (!priv->hadjustment || !priv->vadjustment) - gtk_layout_set_adjustments (layout, hadj, vadj); - - return object; -} - /* Widget methods */ @@ -880,32 +878,29 @@ gtk_layout_realize (GtkWidget *widget) attributes.height = allocation.height; attributes.wclass = GDK_INPUT_OUTPUT; attributes.visual = gtk_widget_get_visual (widget); - attributes.colormap = gtk_widget_get_colormap (widget); attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK; - attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP; + attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL; window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask); gtk_widget_set_window (widget, window); - gdk_window_set_back_pixmap (window, NULL, FALSE); - gdk_window_set_user_data (window, widget); + gtk_widget_register_window (widget, window); gtk_widget_get_allocation (widget, &allocation); - attributes.x = - priv->hadjustment->value, - attributes.y = - priv->vadjustment->value; + attributes.x = - gtk_adjustment_get_value (priv->hadjustment), + attributes.y = - gtk_adjustment_get_value (priv->vadjustment); attributes.width = MAX (priv->width, allocation.width); attributes.height = MAX (priv->height, allocation.height); - attributes.event_mask = GDK_EXPOSURE_MASK | GDK_SCROLL_MASK | + attributes.event_mask = GDK_EXPOSURE_MASK | GDK_SCROLL_MASK | + GDK_SMOOTH_SCROLL_MASK | gtk_widget_get_events (widget); priv->bin_window = gdk_window_new (window, &attributes, attributes_mask); - gdk_window_set_user_data (priv->bin_window, widget); - - gtk_widget_style_attach (widget); - gtk_style_set_background (gtk_widget_get_style (widget), priv->bin_window, GTK_STATE_NORMAL); + gtk_widget_register_window (widget, priv->bin_window); + gtk_style_context_set_background (gtk_widget_get_style_context (widget), priv->bin_window); tmp_list = priv->children; while (tmp_list) @@ -918,17 +913,16 @@ gtk_layout_realize (GtkWidget *widget) } static void -gtk_layout_style_set (GtkWidget *widget, - GtkStyle *old_style) +gtk_layout_style_updated (GtkWidget *widget) { GtkLayoutPrivate *priv; - GTK_WIDGET_CLASS (gtk_layout_parent_class)->style_set (widget, old_style); + GTK_WIDGET_CLASS (gtk_layout_parent_class)->style_updated (widget); if (gtk_widget_get_realized (widget)) { priv = GTK_LAYOUT (widget)->priv; - gtk_style_set_background (gtk_widget_get_style (widget), priv->bin_window, GTK_STATE_NORMAL); + gtk_style_context_set_background (gtk_widget_get_style_context (widget), priv->bin_window); } } @@ -964,38 +958,30 @@ gtk_layout_unrealize (GtkWidget *widget) GtkLayout *layout = GTK_LAYOUT (widget); GtkLayoutPrivate *priv = layout->priv; - gdk_window_set_user_data (priv->bin_window, NULL); + gtk_widget_unregister_window (widget, priv->bin_window); gdk_window_destroy (priv->bin_window); priv->bin_window = NULL; GTK_WIDGET_CLASS (gtk_layout_parent_class)->unrealize (widget); } -static void -gtk_layout_size_request (GtkWidget *widget, - GtkRequisition *requisition) +static void +gtk_layout_get_preferred_width (GtkWidget *widget, + gint *minimum, + gint *natural) { - GtkLayout *layout = GTK_LAYOUT (widget); - GtkLayoutPrivate *priv = layout->priv; - GList *tmp_list; - - requisition->width = 0; - requisition->height = 0; - - tmp_list = priv->children; - - while (tmp_list) - { - GtkLayoutChild *child = tmp_list->data; - GtkRequisition child_requisition; - - tmp_list = tmp_list->next; + *minimum = *natural = 0; +} - gtk_widget_size_request (child->widget, &child_requisition); - } +static void +gtk_layout_get_preferred_height (GtkWidget *widget, + gint *minimum, + gint *natural) +{ + *minimum = *natural = 0; } -static void +static void gtk_layout_size_allocate (GtkWidget *widget, GtkAllocation *allocation) { @@ -1026,30 +1012,19 @@ gtk_layout_size_allocate (GtkWidget *widget, MAX (priv->height, allocation->height)); } - priv->hadjustment->page_size = allocation->width; - priv->hadjustment->page_increment = allocation->width * 0.9; - priv->hadjustment->lower = 0; - /* set_adjustment_upper() emits ::changed */ - gtk_layout_set_adjustment_upper (priv->hadjustment, MAX (allocation->width, priv->width), TRUE); - - priv->vadjustment->page_size = allocation->height; - priv->vadjustment->page_increment = allocation->height * 0.9; - priv->vadjustment->lower = 0; - priv->vadjustment->upper = MAX (allocation->height, priv->height); - gtk_layout_set_adjustment_upper (priv->vadjustment, MAX (allocation->height, priv->height), TRUE); + gtk_layout_set_hadjustment_values (layout); + gtk_layout_set_vadjustment_values (layout); } -static gint -gtk_layout_expose (GtkWidget *widget, - GdkEventExpose *event) +static gboolean +gtk_layout_draw (GtkWidget *widget, + cairo_t *cr) { GtkLayout *layout = GTK_LAYOUT (widget); GtkLayoutPrivate *priv = layout->priv; - if (event->window != priv->bin_window) - return FALSE; - - GTK_WIDGET_CLASS (gtk_layout_parent_class)->expose_event (widget, event); + if (gtk_cairo_should_draw_window (cr, priv->bin_window)) + GTK_WIDGET_CLASS (gtk_layout_parent_class)->draw (widget, cr); return FALSE; } @@ -1124,7 +1099,8 @@ gtk_layout_allocate_child (GtkLayout *layout, allocation.x = child->x; allocation.y = child->y; - gtk_widget_get_child_requisition (child->widget, &requisition); + + gtk_widget_get_preferred_size (child->widget, &requisition, NULL); allocation.width = requisition.width; allocation.height = requisition.height; @@ -1145,9 +1121,7 @@ gtk_layout_adjustment_changed (GtkAdjustment *adjustment, if (gtk_widget_get_realized (GTK_WIDGET (layout))) { gdk_window_move (priv->bin_window, - - priv->hadjustment->value, - - priv->vadjustment->value); - - gdk_window_process_updates (priv->bin_window, TRUE); + - gtk_adjustment_get_value (priv->hadjustment), + - gtk_adjustment_get_value (priv->vadjustment)); } }