X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gtk%2Fgtklayout.c;h=401b4a52a3852b03b7573aac6a4deb77e432209f;hb=10862a344aa8fb44e6045343ddf65eb0d14cc1b2;hp=ec1ffc55791833ca626488f92d3e5fb621647d0c;hpb=4e2b60ac4d32c5bef5b192a12a59f8c2a3124f81;p=~andy%2Fgtk diff --git a/gtk/gtklayout.c b/gtk/gtklayout.c index ec1ffc557..401b4a52a 100644 --- a/gtk/gtklayout.c +++ b/gtk/gtklayout.c @@ -28,12 +28,14 @@ * GTK+ at ftp://ftp.gtk.org/pub/gtk/. */ +#include #include "gdkconfig.h" #include "gtklayout.h" -#include "gtksignal.h" #include "gtkprivate.h" #include "gtkintl.h" +#include "gtkmarshalers.h" +#include "gtkalias.h" typedef struct _GtkLayoutChild GtkLayoutChild; @@ -51,49 +53,80 @@ enum { PROP_HEIGHT }; -static void gtk_layout_class_init (GtkLayoutClass *class); -static void gtk_layout_get_property (GObject *object, - guint prop_id, - GValue *value, - GParamSpec *pspec); -static void gtk_layout_set_property (GObject *object, - guint prop_id, - const GValue *value, - GParamSpec *pspec); -static void gtk_layout_init (GtkLayout *layout); - -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_size_allocate (GtkWidget *widget, - GtkAllocation *allocation); -static gint gtk_layout_expose (GtkWidget *widget, - GdkEventExpose *event); - -static void gtk_layout_remove (GtkContainer *container, - GtkWidget *widget); -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_allocate_child (GtkLayout *layout, - GtkLayoutChild *child); - - -static void gtk_layout_adjustment_changed (GtkAdjustment *adjustment, - GtkLayout *layout); - -static GtkWidgetClass *parent_class = NULL; +enum { + CHILD_PROP_0, + CHILD_PROP_X, + CHILD_PROP_Y +}; + +static void gtk_layout_get_property (GObject *object, + guint prop_id, + GValue *value, + GParamSpec *pspec); +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_size_allocate (GtkWidget *widget, + GtkAllocation *allocation); +static gint gtk_layout_expose (GtkWidget *widget, + GdkEventExpose *event); +static void gtk_layout_add (GtkContainer *container, + GtkWidget *widget); +static void gtk_layout_remove (GtkContainer *container, + GtkWidget *widget); +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, + const GValue *value, + GParamSpec *pspec); +static void gtk_layout_get_child_property (GtkContainer *container, + GtkWidget *child, + guint property_id, + GValue *value, + GParamSpec *pspec); +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_set_adjustment_upper (GtkAdjustment *adj, + gdouble upper, + gboolean always_emit_changed); + +G_DEFINE_TYPE (GtkLayout, gtk_layout, GTK_TYPE_CONTAINER) /* Public interface */ +/** + * gtk_layout_new: + * @hadjustment: horizontal scroll adjustment, or %NULL + * @vadjustment: vertical scroll adjustment, or %NULL + * + * Creates a new #GtkLayout. Unless you have a specific adjustment + * you'd like the layout to use for scrolling, pass %NULL for + * @hadjustment and @vadjustment. + * + * Return value: a new #GtkLayout + **/ GtkWidget* gtk_layout_new (GtkAdjustment *hadjustment, @@ -101,13 +134,27 @@ gtk_layout_new (GtkAdjustment *hadjustment, { GtkLayout *layout; - layout = gtk_type_new (GTK_TYPE_LAYOUT); - - gtk_layout_set_adjustments (layout, hadjustment, vadjustment); + layout = g_object_new (GTK_TYPE_LAYOUT, + "hadjustment", hadjustment, + "vadjustment", vadjustment, + NULL); return GTK_WIDGET (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 + **/ GtkAdjustment* gtk_layout_get_hadjustment (GtkLayout *layout) { @@ -115,6 +162,19 @@ gtk_layout_get_hadjustment (GtkLayout *layout) return layout->hadjustment; } +/** + * 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 + **/ GtkAdjustment* gtk_layout_get_vadjustment (GtkLayout *layout) { @@ -123,6 +183,12 @@ gtk_layout_get_vadjustment (GtkLayout *layout) return layout->vadjustment; } +static GtkAdjustment * +new_default_adjustment (void) +{ + return GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0)); +} + static void gtk_layout_set_adjustments (GtkLayout *layout, GtkAdjustment *hadj, @@ -134,50 +200,56 @@ gtk_layout_set_adjustments (GtkLayout *layout, if (hadj) g_return_if_fail (GTK_IS_ADJUSTMENT (hadj)); - else - hadj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0)); + else if (layout->hadjustment) + hadj = new_default_adjustment (); if (vadj) g_return_if_fail (GTK_IS_ADJUSTMENT (vadj)); - else - vadj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0)); + else if (layout->vadjustment) + vadj = new_default_adjustment (); if (layout->hadjustment && (layout->hadjustment != hadj)) { - gtk_signal_disconnect_by_data (GTK_OBJECT (layout->hadjustment), layout); - gtk_object_unref (GTK_OBJECT (layout->hadjustment)); + g_signal_handlers_disconnect_by_func (layout->hadjustment, + gtk_layout_adjustment_changed, + layout); + g_object_unref (layout->hadjustment); } if (layout->vadjustment && (layout->vadjustment != vadj)) { - gtk_signal_disconnect_by_data (GTK_OBJECT (layout->vadjustment), layout); - gtk_object_unref (GTK_OBJECT (layout->vadjustment)); + g_signal_handlers_disconnect_by_func (layout->vadjustment, + gtk_layout_adjustment_changed, + layout); + g_object_unref (layout->vadjustment); } if (layout->hadjustment != hadj) { layout->hadjustment = hadj; - gtk_object_ref (GTK_OBJECT (layout->hadjustment)); - gtk_object_sink (GTK_OBJECT (layout->hadjustment)); + g_object_ref_sink (layout->hadjustment); + gtk_layout_set_adjustment_upper (layout->hadjustment, layout->width, FALSE); - gtk_signal_connect (GTK_OBJECT (layout->hadjustment), "value_changed", - (GtkSignalFunc) gtk_layout_adjustment_changed, - layout); + g_signal_connect (layout->hadjustment, "value_changed", + G_CALLBACK (gtk_layout_adjustment_changed), + layout); need_adjust = TRUE; } if (layout->vadjustment != vadj) { layout->vadjustment = vadj; - gtk_object_ref (GTK_OBJECT (layout->vadjustment)); - gtk_object_sink (GTK_OBJECT (layout->vadjustment)); + g_object_ref_sink (layout->vadjustment); + gtk_layout_set_adjustment_upper (layout->vadjustment, layout->height, FALSE); - gtk_signal_connect (GTK_OBJECT (layout->vadjustment), "value_changed", - (GtkSignalFunc) gtk_layout_adjustment_changed, - layout); + g_signal_connect (layout->vadjustment, "value_changed", + G_CALLBACK (gtk_layout_adjustment_changed), + layout); need_adjust = TRUE; } - if (need_adjust) + /* 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); } @@ -186,12 +258,22 @@ gtk_layout_finalize (GObject *object) { GtkLayout *layout = GTK_LAYOUT (object); - gtk_object_unref (GTK_OBJECT (layout->hadjustment)); - gtk_object_unref (GTK_OBJECT (layout->vadjustment)); + g_object_unref (layout->hadjustment); + g_object_unref (layout->vadjustment); - G_OBJECT_CLASS (parent_class)->finalize (object); + G_OBJECT_CLASS (gtk_layout_parent_class)->finalize (object); } +/** + * gtk_layout_set_hadjustment: + * @layout: a #GtkLayout + * @adjustment: new scroll adjustment + * + * Sets the horizontal scroll adjustment for the layout. + * + * See #GtkScrolledWindow, #GtkScrollbar, #GtkAdjustment for details. + * + **/ void gtk_layout_set_hadjustment (GtkLayout *layout, GtkAdjustment *adjustment) @@ -202,7 +284,16 @@ gtk_layout_set_hadjustment (GtkLayout *layout, g_object_notify (G_OBJECT (layout), "hadjustment"); } - +/** + * gtk_layout_set_vadjustment: + * @layout: a #GtkLayout + * @adjustment: new scroll adjustment + * + * Sets the vertical scroll adjustment for the layout. + * + * See #GtkScrolledWindow, #GtkScrollbar, #GtkAdjustment for details. + * + **/ void gtk_layout_set_vadjustment (GtkLayout *layout, GtkAdjustment *adjustment) @@ -213,7 +304,38 @@ gtk_layout_set_vadjustment (GtkLayout *layout, g_object_notify (G_OBJECT (layout), "vadjustment"); } +static GtkLayoutChild* +get_child (GtkLayout *layout, + GtkWidget *widget) +{ + GList *children; + + children = layout->children; + while (children) + { + GtkLayoutChild *child; + + child = children->data; + children = children->next; + + if (child->widget == widget) + return child; + } + + return NULL; +} +/** + * gtk_layout_put: + * @layout: a #GtkLayout + * @child_widget: child widget + * @x: X position of child widget + * @y: Y position of child widget + * + * Adds @child_widget to @layout, at position (@x,@y). + * @layout becomes the new parent container of @child_widget. + * + **/ void gtk_layout_put (GtkLayout *layout, GtkWidget *child_widget, @@ -233,75 +355,110 @@ gtk_layout_put (GtkLayout *layout, layout->children = g_list_append (layout->children, child); - gtk_widget_set_parent (child_widget, GTK_WIDGET (layout)); if (GTK_WIDGET_REALIZED (layout)) gtk_widget_set_parent_window (child->widget, layout->bin_window); - if (GTK_WIDGET_REALIZED (layout)) - gtk_widget_realize (child_widget); - - if (GTK_WIDGET_VISIBLE (layout) && GTK_WIDGET_VISIBLE (child_widget)) + gtk_widget_set_parent (child_widget, GTK_WIDGET (layout)); +} + +static void +gtk_layout_move_internal (GtkLayout *layout, + GtkWidget *widget, + gboolean change_x, + gint x, + gboolean change_y, + gint y) +{ + GtkLayoutChild *child; + + g_return_if_fail (GTK_IS_LAYOUT (layout)); + g_return_if_fail (GTK_IS_WIDGET (widget)); + g_return_if_fail (widget->parent == GTK_WIDGET (layout)); + + child = get_child (layout, widget); + + g_assert (child); + + gtk_widget_freeze_child_notify (widget); + + if (change_x) { - if (GTK_WIDGET_MAPPED (layout)) - gtk_widget_map (child_widget); + child->x = x; + gtk_widget_child_notify (widget, "x"); + } - gtk_widget_queue_resize (child_widget); + if (change_y) + { + child->y = y; + gtk_widget_child_notify (widget, "y"); } + + gtk_widget_thaw_child_notify (widget); + + if (GTK_WIDGET_VISIBLE (widget) && GTK_WIDGET_VISIBLE (layout)) + gtk_widget_queue_resize (GTK_WIDGET (widget)); } +/** + * gtk_layout_move: + * @layout: a #GtkLayout + * @child_widget: a current child of @layout + * @x: X position to move to + * @y: Y position to move to + * + * Moves a current child of @layout to a new position. + * + **/ void gtk_layout_move (GtkLayout *layout, GtkWidget *child_widget, gint x, gint y) { - GList *tmp_list; - GtkLayoutChild *child; - g_return_if_fail (GTK_IS_LAYOUT (layout)); + g_return_if_fail (GTK_IS_WIDGET (child_widget)); + g_return_if_fail (child_widget->parent == GTK_WIDGET (layout)); - tmp_list = layout->children; - while (tmp_list) - { - child = tmp_list->data; - tmp_list = tmp_list->next; - - if (child->widget == child_widget) - { - child->x = x; - child->y = y; - - if (GTK_WIDGET_VISIBLE (child_widget) && GTK_WIDGET_VISIBLE (layout)) - gtk_widget_queue_resize (child_widget); - - return; - } - } + gtk_layout_move_internal (layout, child_widget, TRUE, x, TRUE, y); } static void gtk_layout_set_adjustment_upper (GtkAdjustment *adj, - gdouble upper) + 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) { - gdouble min = MAX (0., upper - adj->page_size); - gboolean value_changed = FALSE; - adj->upper = upper; + changed = TRUE; + } - if (adj->value > min) - { - adj->value = min; - value_changed = TRUE; - } - - gtk_signal_emit_by_name (GTK_OBJECT (adj), "changed"); - if (value_changed) - gtk_signal_emit_by_name (GTK_OBJECT (adj), "value_changed"); + 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 + * @width: width of entire scrollable area + * @height: height of entire scrollable area + * + * Sets the size of the scrollable area of the layout. + * + **/ void gtk_layout_set_size (GtkLayout *layout, guint width, @@ -310,9 +467,10 @@ gtk_layout_set_size (GtkLayout *layout, GtkWidget *widget; g_return_if_fail (GTK_IS_LAYOUT (layout)); - + widget = GTK_WIDGET (layout); + g_object_freeze_notify (G_OBJECT (layout)); if (width != layout->width) { layout->width = width; @@ -323,9 +481,12 @@ gtk_layout_set_size (GtkLayout *layout, layout->height = height; g_object_notify (G_OBJECT (layout), "height"); } + g_object_thaw_notify (G_OBJECT (layout)); - gtk_layout_set_adjustment_upper (layout->hadjustment, layout->width); - gtk_layout_set_adjustment_upper (layout->vadjustment, layout->height); + if (layout->hadjustment) + gtk_layout_set_adjustment_upper (layout->hadjustment, layout->width, FALSE); + if (layout->vadjustment) + gtk_layout_set_adjustment_upper (layout->vadjustment, layout->height, FALSE); if (GTK_WIDGET_REALIZED (layout)) { @@ -358,6 +519,12 @@ gtk_layout_get_size (GtkLayout *layout, *height = layout->height; } +/** + * gtk_layout_freeze: + * @layout: a #GtkLayout + * + * This is a deprecated function, it doesn't do anything useful. + **/ void gtk_layout_freeze (GtkLayout *layout) { @@ -366,116 +533,127 @@ gtk_layout_freeze (GtkLayout *layout) layout->freeze_count++; } +/** + * gtk_layout_thaw: + * @layout: a #GtkLayout + * + * This is a deprecated function, it doesn't do anything useful. + **/ void gtk_layout_thaw (GtkLayout *layout) { g_return_if_fail (GTK_IS_LAYOUT (layout)); if (layout->freeze_count) - if (!(--layout->freeze_count)) - gtk_widget_draw (GTK_WIDGET (layout), NULL); -} - -/* Basic Object handling procedures - */ -GtkType -gtk_layout_get_type (void) -{ - static GtkType layout_type = 0; - - if (!layout_type) { - static const GTypeInfo layout_info = - { - sizeof (GtkLayoutClass), - NULL, /* base_init */ - NULL, /* base_finalize */ - (GClassInitFunc) gtk_layout_class_init, - NULL, /* class_finalize */ - NULL, /* class_data */ - sizeof (GtkLayout), - 16, /* n_preallocs */ - (GInstanceInitFunc) gtk_layout_init, - }; - - layout_type = g_type_register_static (GTK_TYPE_CONTAINER, "GtkLayout", &layout_info, 0); + if (!(--layout->freeze_count)) + { + gtk_widget_queue_draw (GTK_WIDGET (layout)); + gdk_window_process_updates (GTK_WIDGET (layout)->window, TRUE); + } } - return layout_type; } +/* Basic Object handling procedures + */ static void gtk_layout_class_init (GtkLayoutClass *class) { GObjectClass *gobject_class; - GtkObjectClass *object_class; GtkWidgetClass *widget_class; GtkContainerClass *container_class; gobject_class = (GObjectClass*) class; - object_class = (GtkObjectClass*) class; widget_class = (GtkWidgetClass*) class; container_class = (GtkContainerClass*) class; - parent_class = gtk_type_class (GTK_TYPE_CONTAINER); - 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; + + gtk_container_class_install_child_property (container_class, + CHILD_PROP_X, + g_param_spec_int ("x", + P_("X position"), + P_("X position of child widget"), + G_MININT, + G_MAXINT, + 0, + GTK_PARAM_READWRITE)); + + gtk_container_class_install_child_property (container_class, + CHILD_PROP_Y, + g_param_spec_int ("y", + P_("Y position"), + P_("Y position of child widget"), + G_MININT, + G_MAXINT, + 0, + GTK_PARAM_READWRITE)); + g_object_class_install_property (gobject_class, PROP_HADJUSTMENT, g_param_spec_object ("hadjustment", - _("Horizontal adjustment"), - _("The GtkAdjustment for the horizontal position."), + P_("Horizontal adjustment"), + P_("The GtkAdjustment for the horizontal position"), GTK_TYPE_ADJUSTMENT, - G_PARAM_READWRITE)); + GTK_PARAM_READWRITE)); g_object_class_install_property (gobject_class, PROP_VADJUSTMENT, g_param_spec_object ("vadjustment", - _("Vertical adjustment"), - _("The GtkAdjustment for the vertical position."), + P_("Vertical adjustment"), + P_("The GtkAdjustment for the vertical position"), GTK_TYPE_ADJUSTMENT, - G_PARAM_READWRITE)); + GTK_PARAM_READWRITE)); g_object_class_install_property (gobject_class, PROP_WIDTH, g_param_spec_uint ("width", - _("Width"), - _("The width of the layout."), + P_("Width"), + P_("The width of the layout"), 0, G_MAXINT, 100, - G_PARAM_READWRITE)); + GTK_PARAM_READWRITE)); g_object_class_install_property (gobject_class, PROP_HEIGHT, g_param_spec_uint ("height", - _("Height"), - _("The height of the layout."), + P_("Height"), + P_("The height of the layout"), 0, G_MAXINT, 100, - G_PARAM_READWRITE)); + GTK_PARAM_READWRITE)); 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->size_allocate = gtk_layout_size_allocate; widget_class->expose_event = gtk_layout_expose; + widget_class->style_set = gtk_layout_style_set; + 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; widget_class->set_scroll_adjustments_signal = - gtk_signal_new ("set_scroll_adjustments", - GTK_RUN_LAST, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkLayoutClass, set_scroll_adjustments), - gtk_marshal_VOID__OBJECT_OBJECT, - GTK_TYPE_NONE, 2, GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT); + 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); } static void @@ -489,10 +667,10 @@ gtk_layout_get_property (GObject *object, switch (prop_id) { case PROP_HADJUSTMENT: - g_value_set_object (value, G_OBJECT (layout->hadjustment)); + g_value_set_object (value, layout->hadjustment); break; case PROP_VADJUSTMENT: - g_value_set_object (value, G_OBJECT (layout->vadjustment)); + g_value_set_object (value, layout->vadjustment); break; case PROP_WIDTH: g_value_set_uint (value, layout->width); @@ -538,6 +716,57 @@ gtk_layout_set_property (GObject *object, } } +static void +gtk_layout_set_child_property (GtkContainer *container, + GtkWidget *child, + guint property_id, + const GValue *value, + GParamSpec *pspec) +{ + switch (property_id) + { + case CHILD_PROP_X: + gtk_layout_move_internal (GTK_LAYOUT (container), + child, + TRUE, g_value_get_int (value), + FALSE, 0); + break; + case CHILD_PROP_Y: + gtk_layout_move_internal (GTK_LAYOUT (container), + child, + FALSE, 0, + TRUE, g_value_get_int (value)); + break; + default: + GTK_CONTAINER_WARN_INVALID_CHILD_PROPERTY_ID (container, property_id, pspec); + break; + } +} + +static void +gtk_layout_get_child_property (GtkContainer *container, + GtkWidget *child, + guint property_id, + GValue *value, + GParamSpec *pspec) +{ + GtkLayoutChild *layout_child; + + layout_child = get_child (GTK_LAYOUT (container), child); + + switch (property_id) + { + case CHILD_PROP_X: + g_value_set_int (value, layout_child->x); + break; + case CHILD_PROP_Y: + g_value_set_int (value, layout_child->y); + break; + default: + GTK_CONTAINER_WARN_INVALID_CHILD_PROPERTY_ID (container, property_id, pspec); + break; + } +} static void gtk_layout_init (GtkLayout *layout) @@ -559,6 +788,30 @@ gtk_layout_init (GtkLayout *layout) layout->freeze_count = 0; } +static GObject * +gtk_layout_constructor (GType type, + guint n_properties, + GObjectConstructParam *properties) +{ + GtkLayout *layout; + GObject *object; + GtkAdjustment *hadj, *vadj; + + object = G_OBJECT_CLASS (gtk_layout_parent_class)->constructor (type, + n_properties, + properties); + + layout = GTK_LAYOUT (object); + + hadj = layout->hadjustment ? layout->hadjustment : new_default_adjustment (); + vadj = layout->vadjustment ? layout->vadjustment : new_default_adjustment (); + + if (!layout->hadjustment || !layout->vadjustment) + gtk_layout_set_adjustments (layout, hadj, vadj); + + return object; +} + /* Widget methods */ @@ -589,10 +842,11 @@ gtk_layout_realize (GtkWidget *widget) widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask); + gdk_window_set_back_pixmap (widget->window, NULL, FALSE); gdk_window_set_user_data (widget->window, widget); - attributes.x = 0; - attributes.y = 0; + attributes.x = - layout->hadjustment->value, + attributes.y = - layout->vadjustment->value; attributes.width = MAX (layout->width, widget->allocation.width); attributes.height = MAX (layout->height, widget->allocation.height); attributes.event_mask = GDK_EXPOSURE_MASK | GDK_SCROLL_MASK | @@ -603,7 +857,6 @@ gtk_layout_realize (GtkWidget *widget) gdk_window_set_user_data (layout->bin_window, widget); widget->style = gtk_style_attach (widget->style, widget->window); - gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL); gtk_style_set_background (widget->style, layout->bin_window, GTK_STATE_NORMAL); tmp_list = layout->children; @@ -616,6 +869,18 @@ gtk_layout_realize (GtkWidget *widget) } } +static void +gtk_layout_style_set (GtkWidget *widget, GtkStyle *old_style) +{ + if (GTK_WIDGET_CLASS (gtk_layout_parent_class)->style_set) + (* GTK_WIDGET_CLASS (gtk_layout_parent_class)->style_set) (widget, old_style); + + if (GTK_WIDGET_REALIZED (widget)) + { + gtk_style_set_background (widget->style, GTK_LAYOUT (widget)->bin_window, GTK_STATE_NORMAL); + } +} + static void gtk_layout_map (GtkWidget *widget) { @@ -658,8 +923,8 @@ gtk_layout_unrealize (GtkWidget *widget) gdk_window_destroy (layout->bin_window); layout->bin_window = NULL; - if (GTK_WIDGET_CLASS (parent_class)->unrealize) - (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget); + if (GTK_WIDGET_CLASS (gtk_layout_parent_class)->unrealize) + (* GTK_WIDGET_CLASS (gtk_layout_parent_class)->unrealize) (widget); } static void @@ -724,16 +989,16 @@ gtk_layout_size_allocate (GtkWidget *widget, } layout->hadjustment->page_size = allocation->width; - layout->hadjustment->page_increment = allocation->width / 2; + layout->hadjustment->page_increment = allocation->width * 0.9; layout->hadjustment->lower = 0; - layout->hadjustment->upper = MAX (allocation->width, layout->width); - gtk_signal_emit_by_name (GTK_OBJECT (layout->hadjustment), "changed"); + /* set_adjustment_upper() emits ::changed */ + gtk_layout_set_adjustment_upper (layout->hadjustment, MAX (allocation->width, layout->width), TRUE); layout->vadjustment->page_size = allocation->height; - layout->vadjustment->page_increment = allocation->height / 2; + layout->vadjustment->page_increment = allocation->height * 0.9; layout->vadjustment->lower = 0; layout->vadjustment->upper = MAX (allocation->height, layout->height); - gtk_signal_emit_by_name (GTK_OBJECT (layout->vadjustment), "changed"); + gtk_layout_set_adjustment_upper (layout->vadjustment, MAX (allocation->height, layout->height), TRUE); } static gint @@ -748,13 +1013,20 @@ gtk_layout_expose (GtkWidget *widget, GdkEventExpose *event) if (event->window != layout->bin_window) return FALSE; - (* GTK_WIDGET_CLASS (parent_class)->expose_event) (widget, event); + (* GTK_WIDGET_CLASS (gtk_layout_parent_class)->expose_event) (widget, event); return FALSE; } -/* Container method +/* Container methods */ +static void +gtk_layout_add (GtkContainer *container, + GtkWidget *widget) +{ + gtk_layout_put (GTK_LAYOUT (container), widget, 0, 0); +} + static void gtk_layout_remove (GtkContainer *container, GtkWidget *widget) @@ -836,10 +1108,6 @@ static void gtk_layout_adjustment_changed (GtkAdjustment *adjustment, GtkLayout *layout) { - GtkWidget *widget; - - widget = GTK_WIDGET (layout); - if (layout->freeze_count) return; @@ -852,3 +1120,6 @@ gtk_layout_adjustment_changed (GtkAdjustment *adjustment, gdk_window_process_updates (layout->bin_window, TRUE); } } + +#define __GTK_LAYOUT_C__ +#include "gtkaliasdef.c"