1 /* GTK - The GIMP Toolkit
2 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 * Boston, MA 02111-1307, USA.
19 * GtkLayout: Widget for scrolling of arbitrary-sized areas.
21 * Copyright Owen Taylor, 1998
25 * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
26 * file for a list of people on the GTK+ Team. See the ChangeLog
27 * files for a list of changes. These files are distributed with
28 * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
31 #include "gdkconfig.h"
33 #include "gtklayout.h"
34 #include "gtksignal.h"
35 #include "gtkprivate.h"
38 typedef struct _GtkLayoutChild GtkLayoutChild;
40 struct _GtkLayoutChild {
54 static void gtk_layout_class_init (GtkLayoutClass *class);
55 static void gtk_layout_get_property (GObject *object,
59 static void gtk_layout_set_property (GObject *object,
63 static void gtk_layout_init (GtkLayout *layout);
65 static void gtk_layout_finalize (GObject *object);
66 static void gtk_layout_realize (GtkWidget *widget);
67 static void gtk_layout_unrealize (GtkWidget *widget);
68 static void gtk_layout_map (GtkWidget *widget);
69 static void gtk_layout_size_request (GtkWidget *widget,
70 GtkRequisition *requisition);
71 static void gtk_layout_size_allocate (GtkWidget *widget,
72 GtkAllocation *allocation);
73 static gint gtk_layout_expose (GtkWidget *widget,
74 GdkEventExpose *event);
76 static void gtk_layout_remove (GtkContainer *container,
78 static void gtk_layout_forall (GtkContainer *container,
79 gboolean include_internals,
81 gpointer callback_data);
82 static void gtk_layout_set_adjustments (GtkLayout *layout,
86 static void gtk_layout_allocate_child (GtkLayout *layout,
87 GtkLayoutChild *child);
90 static void gtk_layout_adjustment_changed (GtkAdjustment *adjustment,
93 static GtkWidgetClass *parent_class = NULL;
99 gtk_layout_new (GtkAdjustment *hadjustment,
100 GtkAdjustment *vadjustment)
104 layout = gtk_type_new (GTK_TYPE_LAYOUT);
106 gtk_layout_set_adjustments (layout, hadjustment, vadjustment);
108 return GTK_WIDGET (layout);
112 gtk_layout_get_hadjustment (GtkLayout *layout)
114 g_return_val_if_fail (GTK_IS_LAYOUT (layout), NULL);
116 return layout->hadjustment;
119 gtk_layout_get_vadjustment (GtkLayout *layout)
121 g_return_val_if_fail (GTK_IS_LAYOUT (layout), NULL);
123 return layout->vadjustment;
127 gtk_layout_set_adjustments (GtkLayout *layout,
131 gboolean need_adjust = FALSE;
133 g_return_if_fail (GTK_IS_LAYOUT (layout));
136 g_return_if_fail (GTK_IS_ADJUSTMENT (hadj));
138 hadj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
140 g_return_if_fail (GTK_IS_ADJUSTMENT (vadj));
142 vadj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
144 if (layout->hadjustment && (layout->hadjustment != hadj))
146 gtk_signal_disconnect_by_data (GTK_OBJECT (layout->hadjustment), layout);
147 gtk_object_unref (GTK_OBJECT (layout->hadjustment));
150 if (layout->vadjustment && (layout->vadjustment != vadj))
152 gtk_signal_disconnect_by_data (GTK_OBJECT (layout->vadjustment), layout);
153 gtk_object_unref (GTK_OBJECT (layout->vadjustment));
156 if (layout->hadjustment != hadj)
158 layout->hadjustment = hadj;
159 gtk_object_ref (GTK_OBJECT (layout->hadjustment));
160 gtk_object_sink (GTK_OBJECT (layout->hadjustment));
162 gtk_signal_connect (GTK_OBJECT (layout->hadjustment), "value_changed",
163 (GtkSignalFunc) gtk_layout_adjustment_changed,
168 if (layout->vadjustment != vadj)
170 layout->vadjustment = vadj;
171 gtk_object_ref (GTK_OBJECT (layout->vadjustment));
172 gtk_object_sink (GTK_OBJECT (layout->vadjustment));
174 gtk_signal_connect (GTK_OBJECT (layout->vadjustment), "value_changed",
175 (GtkSignalFunc) gtk_layout_adjustment_changed,
181 gtk_layout_adjustment_changed (NULL, layout);
185 gtk_layout_finalize (GObject *object)
187 GtkLayout *layout = GTK_LAYOUT (object);
189 gtk_object_unref (GTK_OBJECT (layout->hadjustment));
190 gtk_object_unref (GTK_OBJECT (layout->vadjustment));
192 G_OBJECT_CLASS (parent_class)->finalize (object);
196 gtk_layout_set_hadjustment (GtkLayout *layout,
197 GtkAdjustment *adjustment)
199 g_return_if_fail (GTK_IS_LAYOUT (layout));
201 gtk_layout_set_adjustments (layout, adjustment, layout->vadjustment);
202 g_object_notify (G_OBJECT (layout), "hadjustment");
207 gtk_layout_set_vadjustment (GtkLayout *layout,
208 GtkAdjustment *adjustment)
210 g_return_if_fail (GTK_IS_LAYOUT (layout));
212 gtk_layout_set_adjustments (layout, layout->hadjustment, adjustment);
213 g_object_notify (G_OBJECT (layout), "vadjustment");
218 gtk_layout_put (GtkLayout *layout,
219 GtkWidget *child_widget,
223 GtkLayoutChild *child;
225 g_return_if_fail (GTK_IS_LAYOUT (layout));
226 g_return_if_fail (GTK_IS_WIDGET (child_widget));
228 child = g_new (GtkLayoutChild, 1);
230 child->widget = child_widget;
234 layout->children = g_list_append (layout->children, child);
236 gtk_widget_set_parent (child_widget, GTK_WIDGET (layout));
237 if (GTK_WIDGET_REALIZED (layout))
238 gtk_widget_set_parent_window (child->widget, layout->bin_window);
240 if (GTK_WIDGET_REALIZED (layout))
241 gtk_widget_realize (child_widget);
243 if (GTK_WIDGET_VISIBLE (layout) && GTK_WIDGET_VISIBLE (child_widget))
245 if (GTK_WIDGET_MAPPED (layout))
246 gtk_widget_map (child_widget);
248 gtk_widget_queue_resize (child_widget);
253 gtk_layout_move (GtkLayout *layout,
254 GtkWidget *child_widget,
259 GtkLayoutChild *child;
261 g_return_if_fail (GTK_IS_LAYOUT (layout));
263 tmp_list = layout->children;
266 child = tmp_list->data;
267 tmp_list = tmp_list->next;
269 if (child->widget == child_widget)
274 if (GTK_WIDGET_VISIBLE (child_widget) && GTK_WIDGET_VISIBLE (layout))
275 gtk_widget_queue_resize (child_widget);
283 gtk_layout_set_adjustment_upper (GtkAdjustment *adj,
286 if (upper != adj->upper)
288 gdouble min = MAX (0., upper - adj->page_size);
289 gboolean value_changed = FALSE;
293 if (adj->value > min)
296 value_changed = TRUE;
299 gtk_signal_emit_by_name (GTK_OBJECT (adj), "changed");
301 gtk_signal_emit_by_name (GTK_OBJECT (adj), "value_changed");
306 gtk_layout_set_size (GtkLayout *layout,
312 g_return_if_fail (GTK_IS_LAYOUT (layout));
314 widget = GTK_WIDGET (layout);
316 if (width != layout->width)
318 layout->width = width;
319 g_object_notify (G_OBJECT (layout), "width");
321 if (height != layout->height)
323 layout->height = height;
324 g_object_notify (G_OBJECT (layout), "height");
327 gtk_layout_set_adjustment_upper (layout->hadjustment, layout->width);
328 gtk_layout_set_adjustment_upper (layout->vadjustment, layout->height);
330 if (GTK_WIDGET_REALIZED (layout))
332 width = MAX (width, widget->allocation.width);
333 height = MAX (height, widget->allocation.height);
334 gdk_window_resize (layout->bin_window, width, height);
339 * gtk_layout_get_size:
340 * @layout: a #GtkLayout
341 * @width: location to store the width set on @layout, or %NULL
342 * @height: location to store the height set on @layout, or %NULL
344 * Gets the size that has been set on the layout, and that determines
345 * the total extents of the layout's scrollbar area. See
346 * gtk_layout_set_size ().
349 gtk_layout_get_size (GtkLayout *layout,
353 g_return_if_fail (GTK_IS_LAYOUT (layout));
356 *width = layout->width;
358 *height = layout->height;
362 gtk_layout_freeze (GtkLayout *layout)
364 g_return_if_fail (GTK_IS_LAYOUT (layout));
366 layout->freeze_count++;
370 gtk_layout_thaw (GtkLayout *layout)
372 g_return_if_fail (GTK_IS_LAYOUT (layout));
374 if (layout->freeze_count)
375 if (!(--layout->freeze_count))
376 gtk_widget_draw (GTK_WIDGET (layout), NULL);
379 /* Basic Object handling procedures
382 gtk_layout_get_type (void)
384 static GtkType layout_type = 0;
388 static const GTypeInfo layout_info =
390 sizeof (GtkLayoutClass),
391 NULL, /* base_init */
392 NULL, /* base_finalize */
393 (GClassInitFunc) gtk_layout_class_init,
394 NULL, /* class_finalize */
395 NULL, /* class_data */
397 16, /* n_preallocs */
398 (GInstanceInitFunc) gtk_layout_init,
401 layout_type = g_type_register_static (GTK_TYPE_CONTAINER, "GtkLayout", &layout_info, 0);
408 gtk_layout_class_init (GtkLayoutClass *class)
410 GObjectClass *gobject_class;
411 GtkObjectClass *object_class;
412 GtkWidgetClass *widget_class;
413 GtkContainerClass *container_class;
415 gobject_class = (GObjectClass*) class;
416 object_class = (GtkObjectClass*) class;
417 widget_class = (GtkWidgetClass*) class;
418 container_class = (GtkContainerClass*) class;
420 parent_class = gtk_type_class (GTK_TYPE_CONTAINER);
422 gobject_class->set_property = gtk_layout_set_property;
423 gobject_class->get_property = gtk_layout_get_property;
424 gobject_class->finalize = gtk_layout_finalize;
426 g_object_class_install_property (gobject_class,
428 g_param_spec_object ("hadjustment",
429 _("Horizontal adjustment"),
430 _("The GtkAdjustment for the horizontal position."),
434 g_object_class_install_property (gobject_class,
436 g_param_spec_object ("vadjustment",
437 _("Vertical adjustment"),
438 _("The GtkAdjustment for the vertical position."),
442 g_object_class_install_property (gobject_class,
444 g_param_spec_uint ("width",
446 _("The width of the layout."),
451 g_object_class_install_property (gobject_class,
453 g_param_spec_uint ("height",
455 _("The height of the layout."),
460 widget_class->realize = gtk_layout_realize;
461 widget_class->unrealize = gtk_layout_unrealize;
462 widget_class->map = gtk_layout_map;
463 widget_class->size_request = gtk_layout_size_request;
464 widget_class->size_allocate = gtk_layout_size_allocate;
465 widget_class->expose_event = gtk_layout_expose;
467 container_class->remove = gtk_layout_remove;
468 container_class->forall = gtk_layout_forall;
470 class->set_scroll_adjustments = gtk_layout_set_adjustments;
472 widget_class->set_scroll_adjustments_signal =
473 gtk_signal_new ("set_scroll_adjustments",
475 GTK_CLASS_TYPE (object_class),
476 GTK_SIGNAL_OFFSET (GtkLayoutClass, set_scroll_adjustments),
477 gtk_marshal_VOID__OBJECT_OBJECT,
478 GTK_TYPE_NONE, 2, GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT);
482 gtk_layout_get_property (GObject *object,
487 GtkLayout *layout = GTK_LAYOUT (object);
491 case PROP_HADJUSTMENT:
492 g_value_set_object (value, G_OBJECT (layout->hadjustment));
494 case PROP_VADJUSTMENT:
495 g_value_set_object (value, G_OBJECT (layout->vadjustment));
498 g_value_set_uint (value, layout->width);
501 g_value_set_uint (value, layout->height);
504 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
510 gtk_layout_set_property (GObject *object,
515 GtkLayout *layout = GTK_LAYOUT (object);
519 case PROP_HADJUSTMENT:
520 gtk_layout_set_hadjustment (layout,
521 (GtkAdjustment*) g_value_get_object (value));
523 case PROP_VADJUSTMENT:
524 gtk_layout_set_vadjustment (layout,
525 (GtkAdjustment*) g_value_get_object (value));
528 gtk_layout_set_size (layout, g_value_get_uint (value),
532 gtk_layout_set_size (layout, layout->width,
533 g_value_get_uint (value));
536 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
543 gtk_layout_init (GtkLayout *layout)
545 layout->children = NULL;
548 layout->height = 100;
550 layout->hadjustment = NULL;
551 layout->vadjustment = NULL;
553 layout->bin_window = NULL;
555 layout->scroll_x = 0;
556 layout->scroll_y = 0;
557 layout->visibility = GDK_VISIBILITY_PARTIAL;
559 layout->freeze_count = 0;
566 gtk_layout_realize (GtkWidget *widget)
570 GdkWindowAttr attributes;
571 gint attributes_mask;
573 g_return_if_fail (GTK_IS_LAYOUT (widget));
575 layout = GTK_LAYOUT (widget);
576 GTK_WIDGET_SET_FLAGS (layout, GTK_REALIZED);
578 attributes.window_type = GDK_WINDOW_CHILD;
579 attributes.x = widget->allocation.x;
580 attributes.y = widget->allocation.y;
581 attributes.width = widget->allocation.width;
582 attributes.height = widget->allocation.height;
583 attributes.wclass = GDK_INPUT_OUTPUT;
584 attributes.visual = gtk_widget_get_visual (widget);
585 attributes.colormap = gtk_widget_get_colormap (widget);
586 attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK;
588 attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
590 widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
591 &attributes, attributes_mask);
592 gdk_window_set_user_data (widget->window, widget);
596 attributes.width = MAX (layout->width, widget->allocation.width);
597 attributes.height = MAX (layout->height, widget->allocation.height);
598 attributes.event_mask = GDK_EXPOSURE_MASK | GDK_SCROLL_MASK |
599 gtk_widget_get_events (widget);
601 layout->bin_window = gdk_window_new (widget->window,
602 &attributes, attributes_mask);
603 gdk_window_set_user_data (layout->bin_window, widget);
605 widget->style = gtk_style_attach (widget->style, widget->window);
606 gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);
607 gtk_style_set_background (widget->style, layout->bin_window, GTK_STATE_NORMAL);
609 tmp_list = layout->children;
612 GtkLayoutChild *child = tmp_list->data;
613 tmp_list = tmp_list->next;
615 gtk_widget_set_parent_window (child->widget, layout->bin_window);
620 gtk_layout_map (GtkWidget *widget)
625 g_return_if_fail (GTK_IS_LAYOUT (widget));
627 layout = GTK_LAYOUT (widget);
629 GTK_WIDGET_SET_FLAGS (widget, GTK_MAPPED);
631 tmp_list = layout->children;
634 GtkLayoutChild *child = tmp_list->data;
635 tmp_list = tmp_list->next;
637 if (GTK_WIDGET_VISIBLE (child->widget))
639 if (!GTK_WIDGET_MAPPED (child->widget))
640 gtk_widget_map (child->widget);
644 gdk_window_show (layout->bin_window);
645 gdk_window_show (widget->window);
649 gtk_layout_unrealize (GtkWidget *widget)
653 g_return_if_fail (GTK_IS_LAYOUT (widget));
655 layout = GTK_LAYOUT (widget);
657 gdk_window_set_user_data (layout->bin_window, NULL);
658 gdk_window_destroy (layout->bin_window);
659 layout->bin_window = NULL;
661 if (GTK_WIDGET_CLASS (parent_class)->unrealize)
662 (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
666 gtk_layout_size_request (GtkWidget *widget,
667 GtkRequisition *requisition)
672 g_return_if_fail (GTK_IS_LAYOUT (widget));
674 layout = GTK_LAYOUT (widget);
676 requisition->width = 0;
677 requisition->height = 0;
679 tmp_list = layout->children;
683 GtkLayoutChild *child = tmp_list->data;
684 GtkRequisition child_requisition;
686 tmp_list = tmp_list->next;
688 gtk_widget_size_request (child->widget, &child_requisition);
693 gtk_layout_size_allocate (GtkWidget *widget,
694 GtkAllocation *allocation)
699 g_return_if_fail (GTK_IS_LAYOUT (widget));
701 widget->allocation = *allocation;
703 layout = GTK_LAYOUT (widget);
705 tmp_list = layout->children;
709 GtkLayoutChild *child = tmp_list->data;
710 tmp_list = tmp_list->next;
712 gtk_layout_allocate_child (layout, child);
715 if (GTK_WIDGET_REALIZED (widget))
717 gdk_window_move_resize (widget->window,
718 allocation->x, allocation->y,
719 allocation->width, allocation->height);
721 gdk_window_resize (layout->bin_window,
722 MAX (layout->width, allocation->width),
723 MAX (layout->height, allocation->height));
726 layout->hadjustment->page_size = allocation->width;
727 layout->hadjustment->page_increment = allocation->width / 2;
728 layout->hadjustment->lower = 0;
729 layout->hadjustment->upper = MAX (allocation->width, layout->width);
730 gtk_signal_emit_by_name (GTK_OBJECT (layout->hadjustment), "changed");
732 layout->vadjustment->page_size = allocation->height;
733 layout->vadjustment->page_increment = allocation->height / 2;
734 layout->vadjustment->lower = 0;
735 layout->vadjustment->upper = MAX (allocation->height, layout->height);
736 gtk_signal_emit_by_name (GTK_OBJECT (layout->vadjustment), "changed");
740 gtk_layout_expose (GtkWidget *widget, GdkEventExpose *event)
744 g_return_val_if_fail (GTK_IS_LAYOUT (widget), FALSE);
746 layout = GTK_LAYOUT (widget);
748 if (event->window != layout->bin_window)
751 (* GTK_WIDGET_CLASS (parent_class)->expose_event) (widget, event);
759 gtk_layout_remove (GtkContainer *container,
764 GtkLayoutChild *child = NULL;
766 g_return_if_fail (GTK_IS_LAYOUT (container));
768 layout = GTK_LAYOUT (container);
770 tmp_list = layout->children;
773 child = tmp_list->data;
774 if (child->widget == widget)
776 tmp_list = tmp_list->next;
781 gtk_widget_unparent (widget);
783 layout->children = g_list_remove_link (layout->children, tmp_list);
784 g_list_free_1 (tmp_list);
790 gtk_layout_forall (GtkContainer *container,
791 gboolean include_internals,
792 GtkCallback callback,
793 gpointer callback_data)
796 GtkLayoutChild *child;
799 g_return_if_fail (GTK_IS_LAYOUT (container));
800 g_return_if_fail (callback != NULL);
802 layout = GTK_LAYOUT (container);
804 tmp_list = layout->children;
807 child = tmp_list->data;
808 tmp_list = tmp_list->next;
810 (* callback) (child->widget, callback_data);
814 /* Operations on children
818 gtk_layout_allocate_child (GtkLayout *layout,
819 GtkLayoutChild *child)
821 GtkAllocation allocation;
822 GtkRequisition requisition;
824 allocation.x = child->x;
825 allocation.y = child->y;
826 gtk_widget_get_child_requisition (child->widget, &requisition);
827 allocation.width = requisition.width;
828 allocation.height = requisition.height;
830 gtk_widget_size_allocate (child->widget, &allocation);
836 gtk_layout_adjustment_changed (GtkAdjustment *adjustment,
841 widget = GTK_WIDGET (layout);
843 if (layout->freeze_count)
846 if (GTK_WIDGET_REALIZED (layout))
848 gdk_window_move (layout->bin_window,
849 - layout->hadjustment->value,
850 - layout->vadjustment->value);
852 gdk_window_process_updates (layout->bin_window, TRUE);