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.
21 * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
22 * file for a list of people on the GTK+ Team. See the ChangeLog
23 * files for a list of changes. These files are distributed with
24 * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
29 #include <gdk/gdkkeysyms.h>
30 #include <gtk/gtkbindings.h>
31 #include <gtk/gtkmarshalers.h>
32 #include <gtk/gtkscrolledwindow.h>
33 #include <gtk/gtkintl.h>
34 #include <gtk/gtkalias.h>
37 /* scrolled window policy and size requisition handling:
39 * gtk size requisition works as follows:
40 * a widget upon size-request reports the width and height that it finds
41 * to be best suited to display its contents, including children.
42 * the width and/or height reported from a widget upon size requisition
43 * may be overidden by the user by specifying a width and/or height
44 * other than 0 through gtk_widget_set_usize().
46 * a scrolled window needs (for imlementing all three policy types) to
47 * request its width and height based on two different rationales.
48 * 1) the user wants the scrolled window to just fit into the space
49 * that it gets allocated for a specifc dimension.
50 * 1.1) this does not apply if the user specified a concrete value
51 * value for that specific dimension by either specifying usize for the
52 * scrolled window or for its child.
53 * 2) the user wants the scrolled window to take as much space up as
54 * is desired by the child for a specifc dimension (i.e. POLICY_NEVER).
56 * also, kinda obvious:
57 * 3) a user would certainly not have choosen a scrolled window as a container
58 * for the child, if the resulting allocation takes up more space than the
59 * child would have allocated without the scrolled window.
62 * A) from 1) follows: the scrolled window shouldn't request more space for a
63 * specifc dimension than is required at minimum.
64 * B) from 1.1) follows: the requisition may be overidden by usize of the scrolled
65 * window (done automatically) or by usize of the child (needs to be checked).
66 * C) from 2) follows: for POLICY_NEVER, the scrolled window simply reports the
68 * D) from 3) follows: the scrolled window child's minimum width and minimum height
69 * under A) at least correspond to the space taken up by its scrollbars.
72 #define DEFAULT_SCROLLBAR_SPACING 3
78 PROP_HSCROLLBAR_POLICY
,
79 PROP_VSCROLLBAR_POLICY
,
80 PROP_WINDOW_PLACEMENT
,
93 static void gtk_scrolled_window_class_init (GtkScrolledWindowClass
*klass
);
94 static void gtk_scrolled_window_init (GtkScrolledWindow
*scrolled_window
);
95 static void gtk_scrolled_window_destroy (GtkObject
*object
);
96 static void gtk_scrolled_window_finalize (GObject
*object
);
97 static void gtk_scrolled_window_set_property (GObject
*object
,
101 static void gtk_scrolled_window_get_property (GObject
*object
,
106 static gint
gtk_scrolled_window_expose (GtkWidget
*widget
,
107 GdkEventExpose
*event
);
108 static void gtk_scrolled_window_size_request (GtkWidget
*widget
,
109 GtkRequisition
*requisition
);
110 static void gtk_scrolled_window_size_allocate (GtkWidget
*widget
,
111 GtkAllocation
*allocation
);
112 static gint
gtk_scrolled_window_scroll_event (GtkWidget
*widget
,
113 GdkEventScroll
*event
);
114 static gint
gtk_scrolled_window_focus (GtkWidget
*widget
,
115 GtkDirectionType direction
);
116 static void gtk_scrolled_window_add (GtkContainer
*container
,
118 static void gtk_scrolled_window_remove (GtkContainer
*container
,
120 static void gtk_scrolled_window_forall (GtkContainer
*container
,
121 gboolean include_internals
,
122 GtkCallback callback
,
123 gpointer callback_data
);
124 static void gtk_scrolled_window_scroll_child (GtkScrolledWindow
*scrolled_window
,
125 GtkScrollType scroll
,
126 gboolean horizontal
);
127 static void gtk_scrolled_window_move_focus_out (GtkScrolledWindow
*scrolled_window
,
128 GtkDirectionType direction_type
);
130 static void gtk_scrolled_window_relative_allocation(GtkWidget
*widget
,
131 GtkAllocation
*allocation
);
132 static void gtk_scrolled_window_adjustment_changed (GtkAdjustment
*adjustment
,
135 static GtkContainerClass
*parent_class
= NULL
;
137 static guint signals
[LAST_SIGNAL
] = {0};
140 gtk_scrolled_window_get_type (void)
142 static GType scrolled_window_type
= 0;
144 if (!scrolled_window_type
)
146 static const GTypeInfo scrolled_window_info
=
148 sizeof (GtkScrolledWindowClass
),
149 NULL
, /* base_init */
150 NULL
, /* base_finalize */
151 (GClassInitFunc
) gtk_scrolled_window_class_init
,
152 NULL
, /* class_finalize */
153 NULL
, /* class_data */
154 sizeof (GtkScrolledWindow
),
156 (GInstanceInitFunc
) gtk_scrolled_window_init
,
159 scrolled_window_type
=
160 g_type_register_static (GTK_TYPE_BIN
, "GtkScrolledWindow",
161 &scrolled_window_info
, 0);
164 return scrolled_window_type
;
168 add_scroll_binding (GtkBindingSet
*binding_set
,
170 GdkModifierType mask
,
171 GtkScrollType scroll
,
174 guint keypad_keyval
= keyval
- GDK_Left
+ GDK_KP_Left
;
176 gtk_binding_entry_add_signal (binding_set
, keyval
, mask
,
178 GTK_TYPE_SCROLL_TYPE
, scroll
,
179 G_TYPE_BOOLEAN
, horizontal
);
180 gtk_binding_entry_add_signal (binding_set
, keypad_keyval
, mask
,
182 GTK_TYPE_SCROLL_TYPE
, scroll
,
183 G_TYPE_BOOLEAN
, horizontal
);
187 add_tab_bindings (GtkBindingSet
*binding_set
,
188 GdkModifierType modifiers
,
189 GtkDirectionType direction
)
191 gtk_binding_entry_add_signal (binding_set
, GDK_Tab
, modifiers
,
193 GTK_TYPE_DIRECTION_TYPE
, direction
);
194 gtk_binding_entry_add_signal (binding_set
, GDK_KP_Tab
, modifiers
,
196 GTK_TYPE_DIRECTION_TYPE
, direction
);
200 gtk_scrolled_window_class_init (GtkScrolledWindowClass
*class)
202 GObjectClass
*gobject_class
= G_OBJECT_CLASS (class);
203 GtkObjectClass
*object_class
;
204 GtkWidgetClass
*widget_class
;
205 GtkContainerClass
*container_class
;
206 GtkBindingSet
*binding_set
;
208 object_class
= (GtkObjectClass
*) class;
209 widget_class
= (GtkWidgetClass
*) class;
210 container_class
= (GtkContainerClass
*) class;
212 parent_class
= g_type_class_peek_parent (class);
214 gobject_class
->finalize
= gtk_scrolled_window_finalize
;
215 gobject_class
->set_property
= gtk_scrolled_window_set_property
;
216 gobject_class
->get_property
= gtk_scrolled_window_get_property
;
218 object_class
->destroy
= gtk_scrolled_window_destroy
;
220 widget_class
->expose_event
= gtk_scrolled_window_expose
;
221 widget_class
->size_request
= gtk_scrolled_window_size_request
;
222 widget_class
->size_allocate
= gtk_scrolled_window_size_allocate
;
223 widget_class
->scroll_event
= gtk_scrolled_window_scroll_event
;
224 widget_class
->focus
= gtk_scrolled_window_focus
;
226 container_class
->add
= gtk_scrolled_window_add
;
227 container_class
->remove
= gtk_scrolled_window_remove
;
228 container_class
->forall
= gtk_scrolled_window_forall
;
230 class->scrollbar_spacing
= -1;
232 class->scroll_child
= gtk_scrolled_window_scroll_child
;
233 class->move_focus_out
= gtk_scrolled_window_move_focus_out
;
235 g_object_class_install_property (gobject_class
,
237 g_param_spec_object ("hadjustment",
238 P_("Horizontal Adjustment"),
239 P_("The GtkAdjustment for the horizontal position"),
241 G_PARAM_READWRITE
| G_PARAM_CONSTRUCT
));
242 g_object_class_install_property (gobject_class
,
244 g_param_spec_object ("vadjustment",
245 P_("Vertical Adjustment"),
246 P_("The GtkAdjustment for the vertical position"),
248 G_PARAM_READWRITE
| G_PARAM_CONSTRUCT
));
249 g_object_class_install_property (gobject_class
,
250 PROP_HSCROLLBAR_POLICY
,
251 g_param_spec_enum ("hscrollbar_policy",
252 P_("Horizontal Scrollbar Policy"),
253 P_("When the horizontal scrollbar is displayed"),
254 GTK_TYPE_POLICY_TYPE
,
256 G_PARAM_READABLE
| G_PARAM_WRITABLE
));
257 g_object_class_install_property (gobject_class
,
258 PROP_VSCROLLBAR_POLICY
,
259 g_param_spec_enum ("vscrollbar_policy",
260 P_("Vertical Scrollbar Policy"),
261 P_("When the vertical scrollbar is displayed"),
262 GTK_TYPE_POLICY_TYPE
,
264 G_PARAM_READABLE
| G_PARAM_WRITABLE
));
266 g_object_class_install_property (gobject_class
,
267 PROP_WINDOW_PLACEMENT
,
268 g_param_spec_enum ("window_placement",
269 P_("Window Placement"),
270 P_("Where the contents are located with respect to the scrollbars"),
271 GTK_TYPE_CORNER_TYPE
,
273 G_PARAM_READABLE
| G_PARAM_WRITABLE
));
274 g_object_class_install_property (gobject_class
,
276 g_param_spec_enum ("shadow_type",
278 P_("Style of bevel around the contents"),
279 GTK_TYPE_SHADOW_TYPE
,
281 G_PARAM_READABLE
| G_PARAM_WRITABLE
));
283 gtk_widget_class_install_style_property (widget_class
,
284 g_param_spec_int ("scrollbar_spacing",
285 P_("Scrollbar spacing"),
286 P_("Number of pixels between the scrollbars and the scrolled window"),
289 DEFAULT_SCROLLBAR_SPACING
,
292 signals
[SCROLL_CHILD
] =
293 g_signal_new ("scroll_child",
294 G_TYPE_FROM_CLASS (object_class
),
295 G_SIGNAL_RUN_LAST
| G_SIGNAL_ACTION
,
296 G_STRUCT_OFFSET (GtkScrolledWindowClass
, scroll_child
),
298 _gtk_marshal_VOID__ENUM_BOOLEAN
,
300 GTK_TYPE_SCROLL_TYPE
,
302 signals
[MOVE_FOCUS_OUT
] =
303 g_signal_new ("move_focus_out",
304 G_TYPE_FROM_CLASS (object_class
),
305 G_SIGNAL_RUN_LAST
| G_SIGNAL_ACTION
,
306 G_STRUCT_OFFSET (GtkScrolledWindowClass
, move_focus_out
),
308 _gtk_marshal_VOID__ENUM
,
310 GTK_TYPE_DIRECTION_TYPE
);
312 binding_set
= gtk_binding_set_by_class (class);
314 add_scroll_binding (binding_set
, GDK_Left
, GDK_CONTROL_MASK
, GTK_SCROLL_STEP_BACKWARD
, TRUE
);
315 add_scroll_binding (binding_set
, GDK_Right
, GDK_CONTROL_MASK
, GTK_SCROLL_STEP_FORWARD
, TRUE
);
316 add_scroll_binding (binding_set
, GDK_Up
, GDK_CONTROL_MASK
, GTK_SCROLL_STEP_BACKWARD
, FALSE
);
317 add_scroll_binding (binding_set
, GDK_Down
, GDK_CONTROL_MASK
, GTK_SCROLL_STEP_FORWARD
, FALSE
);
319 add_scroll_binding (binding_set
, GDK_Page_Up
, GDK_CONTROL_MASK
, GTK_SCROLL_PAGE_BACKWARD
, TRUE
);
320 add_scroll_binding (binding_set
, GDK_Page_Down
, GDK_CONTROL_MASK
, GTK_SCROLL_PAGE_FORWARD
, TRUE
);
321 add_scroll_binding (binding_set
, GDK_Page_Up
, 0, GTK_SCROLL_PAGE_BACKWARD
, FALSE
);
322 add_scroll_binding (binding_set
, GDK_Page_Down
, 0, GTK_SCROLL_PAGE_FORWARD
, FALSE
);
324 add_scroll_binding (binding_set
, GDK_Home
, GDK_CONTROL_MASK
, GTK_SCROLL_START
, TRUE
);
325 add_scroll_binding (binding_set
, GDK_End
, GDK_CONTROL_MASK
, GTK_SCROLL_END
, TRUE
);
326 add_scroll_binding (binding_set
, GDK_Home
, 0, GTK_SCROLL_START
, FALSE
);
327 add_scroll_binding (binding_set
, GDK_End
, 0, GTK_SCROLL_END
, FALSE
);
329 add_tab_bindings (binding_set
, GDK_CONTROL_MASK
, GTK_DIR_TAB_FORWARD
);
330 add_tab_bindings (binding_set
, GDK_CONTROL_MASK
| GDK_SHIFT_MASK
, GTK_DIR_TAB_BACKWARD
);
334 gtk_scrolled_window_init (GtkScrolledWindow
*scrolled_window
)
336 GTK_WIDGET_SET_FLAGS (scrolled_window
, GTK_NO_WINDOW
| GTK_CAN_FOCUS
);
338 scrolled_window
->hscrollbar
= NULL
;
339 scrolled_window
->vscrollbar
= NULL
;
340 scrolled_window
->hscrollbar_policy
= GTK_POLICY_ALWAYS
;
341 scrolled_window
->vscrollbar_policy
= GTK_POLICY_ALWAYS
;
342 scrolled_window
->hscrollbar_visible
= FALSE
;
343 scrolled_window
->vscrollbar_visible
= FALSE
;
344 scrolled_window
->focus_out
= FALSE
;
345 scrolled_window
->window_placement
= GTK_CORNER_TOP_LEFT
;
350 gtk_scrolled_window_new (GtkAdjustment
*hadjustment
,
351 GtkAdjustment
*vadjustment
)
353 GtkWidget
*scrolled_window
;
356 g_return_val_if_fail (GTK_IS_ADJUSTMENT (hadjustment
), NULL
);
359 g_return_val_if_fail (GTK_IS_ADJUSTMENT (vadjustment
), NULL
);
361 scrolled_window
= gtk_widget_new (GTK_TYPE_SCROLLED_WINDOW
,
362 "hadjustment", hadjustment
,
363 "vadjustment", vadjustment
,
366 return scrolled_window
;
370 gtk_scrolled_window_set_hadjustment (GtkScrolledWindow
*scrolled_window
,
371 GtkAdjustment
*hadjustment
)
375 g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window
));
377 g_return_if_fail (GTK_IS_ADJUSTMENT (hadjustment
));
379 hadjustment
= (GtkAdjustment
*) g_object_new (GTK_TYPE_ADJUSTMENT
, NULL
);
381 bin
= GTK_BIN (scrolled_window
);
383 if (!scrolled_window
->hscrollbar
)
385 gtk_widget_push_composite_child ();
386 scrolled_window
->hscrollbar
= gtk_hscrollbar_new (hadjustment
);
387 gtk_widget_set_composite_name (scrolled_window
->hscrollbar
, "hscrollbar");
388 gtk_widget_pop_composite_child ();
390 gtk_widget_set_parent (scrolled_window
->hscrollbar
, GTK_WIDGET (scrolled_window
));
391 g_object_ref (scrolled_window
->hscrollbar
);
392 gtk_widget_show (scrolled_window
->hscrollbar
);
396 GtkAdjustment
*old_adjustment
;
398 old_adjustment
= gtk_range_get_adjustment (GTK_RANGE (scrolled_window
->hscrollbar
));
399 if (old_adjustment
== hadjustment
)
402 g_signal_handlers_disconnect_by_func (old_adjustment
,
403 gtk_scrolled_window_adjustment_changed
,
405 gtk_range_set_adjustment (GTK_RANGE (scrolled_window
->hscrollbar
),
408 hadjustment
= gtk_range_get_adjustment (GTK_RANGE (scrolled_window
->hscrollbar
));
409 g_signal_connect (hadjustment
,
411 G_CALLBACK (gtk_scrolled_window_adjustment_changed
),
413 gtk_scrolled_window_adjustment_changed (hadjustment
, scrolled_window
);
416 gtk_widget_set_scroll_adjustments (bin
->child
,
417 gtk_range_get_adjustment (GTK_RANGE (scrolled_window
->hscrollbar
)),
418 gtk_range_get_adjustment (GTK_RANGE (scrolled_window
->vscrollbar
)));
420 g_object_notify (G_OBJECT (scrolled_window
), "hadjustment");
424 gtk_scrolled_window_set_vadjustment (GtkScrolledWindow
*scrolled_window
,
425 GtkAdjustment
*vadjustment
)
429 g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window
));
431 g_return_if_fail (GTK_IS_ADJUSTMENT (vadjustment
));
433 vadjustment
= (GtkAdjustment
*) g_object_new (GTK_TYPE_ADJUSTMENT
, NULL
);
435 bin
= GTK_BIN (scrolled_window
);
437 if (!scrolled_window
->vscrollbar
)
439 gtk_widget_push_composite_child ();
440 scrolled_window
->vscrollbar
= gtk_vscrollbar_new (vadjustment
);
441 gtk_widget_set_composite_name (scrolled_window
->vscrollbar
, "vscrollbar");
442 gtk_widget_pop_composite_child ();
444 gtk_widget_set_parent (scrolled_window
->vscrollbar
, GTK_WIDGET (scrolled_window
));
445 g_object_ref (scrolled_window
->vscrollbar
);
446 gtk_widget_show (scrolled_window
->vscrollbar
);
450 GtkAdjustment
*old_adjustment
;
452 old_adjustment
= gtk_range_get_adjustment (GTK_RANGE (scrolled_window
->vscrollbar
));
453 if (old_adjustment
== vadjustment
)
456 g_signal_handlers_disconnect_by_func (old_adjustment
,
457 gtk_scrolled_window_adjustment_changed
,
459 gtk_range_set_adjustment (GTK_RANGE (scrolled_window
->vscrollbar
),
462 vadjustment
= gtk_range_get_adjustment (GTK_RANGE (scrolled_window
->vscrollbar
));
463 g_signal_connect (vadjustment
,
465 G_CALLBACK (gtk_scrolled_window_adjustment_changed
),
467 gtk_scrolled_window_adjustment_changed (vadjustment
, scrolled_window
);
470 gtk_widget_set_scroll_adjustments (bin
->child
,
471 gtk_range_get_adjustment (GTK_RANGE (scrolled_window
->hscrollbar
)),
472 gtk_range_get_adjustment (GTK_RANGE (scrolled_window
->vscrollbar
)));
474 g_object_notify (G_OBJECT (scrolled_window
), "vadjustment");
478 gtk_scrolled_window_get_hadjustment (GtkScrolledWindow
*scrolled_window
)
480 g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window
), NULL
);
482 return (scrolled_window
->hscrollbar
?
483 gtk_range_get_adjustment (GTK_RANGE (scrolled_window
->hscrollbar
)) :
488 gtk_scrolled_window_get_vadjustment (GtkScrolledWindow
*scrolled_window
)
490 g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window
), NULL
);
492 return (scrolled_window
->vscrollbar
?
493 gtk_range_get_adjustment (GTK_RANGE (scrolled_window
->vscrollbar
)) :
498 gtk_scrolled_window_set_policy (GtkScrolledWindow
*scrolled_window
,
499 GtkPolicyType hscrollbar_policy
,
500 GtkPolicyType vscrollbar_policy
)
502 GObject
*object
= G_OBJECT (scrolled_window
);
504 g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window
));
506 if ((scrolled_window
->hscrollbar_policy
!= hscrollbar_policy
) ||
507 (scrolled_window
->vscrollbar_policy
!= vscrollbar_policy
))
509 scrolled_window
->hscrollbar_policy
= hscrollbar_policy
;
510 scrolled_window
->vscrollbar_policy
= vscrollbar_policy
;
512 gtk_widget_queue_resize (GTK_WIDGET (scrolled_window
));
514 g_object_freeze_notify (object
);
515 g_object_notify (object
, "hscrollbar-policy");
516 g_object_notify (object
, "vscrollbar-policy");
517 g_object_thaw_notify (object
);
522 * gtk_scrolled_window_get_policy:
523 * @scrolled_window: a #GtkScrolledWindow
524 * @hscrollbar_policy: location to store the policy for the horizontal scrollbar, or %NULL.
525 * @vscrollbar_policy: location to store the policy for the horizontal scrollbar, or %NULL.
527 * Retrieves the current policy values for the horizontal and vertical
528 * scrollbars. See gtk_scrolled_window_set_policy().
531 gtk_scrolled_window_get_policy (GtkScrolledWindow
*scrolled_window
,
532 GtkPolicyType
*hscrollbar_policy
,
533 GtkPolicyType
*vscrollbar_policy
)
535 g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window
));
537 if (hscrollbar_policy
)
538 *hscrollbar_policy
= scrolled_window
->hscrollbar_policy
;
539 if (vscrollbar_policy
)
540 *vscrollbar_policy
= scrolled_window
->vscrollbar_policy
;
544 gtk_scrolled_window_set_placement (GtkScrolledWindow
*scrolled_window
,
545 GtkCornerType window_placement
)
547 g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window
));
549 if (scrolled_window
->window_placement
!= window_placement
)
551 scrolled_window
->window_placement
= window_placement
;
553 gtk_widget_queue_resize (GTK_WIDGET (scrolled_window
));
555 g_object_notify (G_OBJECT (scrolled_window
), "window-placement");
560 * gtk_scrolled_window_get_placement:
561 * @scrolled_window: a #GtkScrolledWindow
563 * Gets the placement of the scrollbars for the scrolled window. See
564 * gtk_scrolled_window_set_placement().
566 * Return value: the current placement value.
569 gtk_scrolled_window_get_placement (GtkScrolledWindow
*scrolled_window
)
571 g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window
), GTK_CORNER_TOP_LEFT
);
573 return scrolled_window
->window_placement
;
577 * gtk_scrolled_window_set_shadow_type:
578 * @scrolled_window: a #GtkScrolledWindow
579 * @type: kind of shadow to draw around scrolled window contents
581 * Changes the type of shadow drawn around the contents of
586 gtk_scrolled_window_set_shadow_type (GtkScrolledWindow
*scrolled_window
,
589 g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window
));
590 g_return_if_fail (type
>= GTK_SHADOW_NONE
&& type
<= GTK_SHADOW_ETCHED_OUT
);
592 if (scrolled_window
->shadow_type
!= type
)
594 scrolled_window
->shadow_type
= type
;
596 if (GTK_WIDGET_DRAWABLE (scrolled_window
))
597 gtk_widget_queue_draw (GTK_WIDGET (scrolled_window
));
599 gtk_widget_queue_resize (GTK_WIDGET (scrolled_window
));
601 g_object_notify (G_OBJECT (scrolled_window
), "shadow-type");
606 * gtk_scrolled_window_get_shadow_type:
607 * @scrolled_window: a #GtkScrolledWindow
609 * Gets the shadow type of the scrolled window. See
610 * gtk_scrolled_window_set_shadow_type().
612 * Return value: the current shadow type
615 gtk_scrolled_window_get_shadow_type (GtkScrolledWindow
*scrolled_window
)
617 g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window
), GTK_SHADOW_NONE
);
619 return scrolled_window
->shadow_type
;
623 gtk_scrolled_window_destroy (GtkObject
*object
)
625 GtkScrolledWindow
*scrolled_window
;
627 g_return_if_fail (GTK_IS_SCROLLED_WINDOW (object
));
629 scrolled_window
= GTK_SCROLLED_WINDOW (object
);
631 gtk_widget_unparent (scrolled_window
->hscrollbar
);
632 gtk_widget_unparent (scrolled_window
->vscrollbar
);
633 gtk_widget_destroy (scrolled_window
->hscrollbar
);
634 gtk_widget_destroy (scrolled_window
->vscrollbar
);
636 GTK_OBJECT_CLASS (parent_class
)->destroy (object
);
640 gtk_scrolled_window_finalize (GObject
*object
)
642 GtkScrolledWindow
*scrolled_window
= GTK_SCROLLED_WINDOW (object
);
644 g_object_unref (scrolled_window
->hscrollbar
);
645 g_object_unref (scrolled_window
->vscrollbar
);
647 G_OBJECT_CLASS (parent_class
)->finalize (object
);
651 gtk_scrolled_window_set_property (GObject
*object
,
656 GtkScrolledWindow
*scrolled_window
= GTK_SCROLLED_WINDOW (object
);
660 case PROP_HADJUSTMENT
:
661 gtk_scrolled_window_set_hadjustment (scrolled_window
,
662 g_value_get_object (value
));
664 case PROP_VADJUSTMENT
:
665 gtk_scrolled_window_set_vadjustment (scrolled_window
,
666 g_value_get_object (value
));
668 case PROP_HSCROLLBAR_POLICY
:
669 gtk_scrolled_window_set_policy (scrolled_window
,
670 g_value_get_enum (value
),
671 scrolled_window
->vscrollbar_policy
);
673 case PROP_VSCROLLBAR_POLICY
:
674 gtk_scrolled_window_set_policy (scrolled_window
,
675 scrolled_window
->hscrollbar_policy
,
676 g_value_get_enum (value
));
678 case PROP_WINDOW_PLACEMENT
:
679 gtk_scrolled_window_set_placement (scrolled_window
,
680 g_value_get_enum (value
));
682 case PROP_SHADOW_TYPE
:
683 gtk_scrolled_window_set_shadow_type (scrolled_window
,
684 g_value_get_enum (value
));
687 G_OBJECT_WARN_INVALID_PROPERTY_ID (object
, prop_id
, pspec
);
693 gtk_scrolled_window_get_property (GObject
*object
,
698 GtkScrolledWindow
*scrolled_window
= GTK_SCROLLED_WINDOW (object
);
702 case PROP_HADJUSTMENT
:
703 g_value_set_object (value
,
704 G_OBJECT (gtk_scrolled_window_get_hadjustment (scrolled_window
)));
706 case PROP_VADJUSTMENT
:
707 g_value_set_object (value
,
708 G_OBJECT (gtk_scrolled_window_get_vadjustment (scrolled_window
)));
710 case PROP_HSCROLLBAR_POLICY
:
711 g_value_set_enum (value
, scrolled_window
->hscrollbar_policy
);
713 case PROP_VSCROLLBAR_POLICY
:
714 g_value_set_enum (value
, scrolled_window
->vscrollbar_policy
);
716 case PROP_WINDOW_PLACEMENT
:
717 g_value_set_enum (value
, scrolled_window
->window_placement
);
719 case PROP_SHADOW_TYPE
:
720 g_value_set_enum (value
, scrolled_window
->shadow_type
);
723 G_OBJECT_WARN_INVALID_PROPERTY_ID (object
, prop_id
, pspec
);
729 gtk_scrolled_window_paint (GtkWidget
*widget
,
732 GtkAllocation relative_allocation
;
733 GtkScrolledWindow
*scrolled_window
= GTK_SCROLLED_WINDOW (widget
);
735 if (scrolled_window
->shadow_type
!= GTK_SHADOW_NONE
)
737 gtk_scrolled_window_relative_allocation (widget
, &relative_allocation
);
739 relative_allocation
.x
-= widget
->style
->xthickness
;
740 relative_allocation
.y
-= widget
->style
->ythickness
;
741 relative_allocation
.width
+= 2 * widget
->style
->xthickness
;
742 relative_allocation
.height
+= 2 * widget
->style
->ythickness
;
744 gtk_paint_shadow (widget
->style
, widget
->window
,
745 GTK_STATE_NORMAL
, scrolled_window
->shadow_type
,
746 area
, widget
, "scrolled_window",
747 widget
->allocation
.x
+ relative_allocation
.x
,
748 widget
->allocation
.y
+ relative_allocation
.y
,
749 relative_allocation
.width
,
750 relative_allocation
.height
);
755 gtk_scrolled_window_expose (GtkWidget
*widget
,
756 GdkEventExpose
*event
)
758 if (GTK_WIDGET_DRAWABLE (widget
))
760 gtk_scrolled_window_paint (widget
, &event
->area
);
762 (* GTK_WIDGET_CLASS (parent_class
)->expose_event
) (widget
, event
);
769 gtk_scrolled_window_forall (GtkContainer
*container
,
770 gboolean include_internals
,
771 GtkCallback callback
,
772 gpointer callback_data
)
774 g_return_if_fail (GTK_IS_SCROLLED_WINDOW (container
));
775 g_return_if_fail (callback
!= NULL
);
777 GTK_CONTAINER_CLASS (parent_class
)->forall (container
,
781 if (include_internals
)
783 GtkScrolledWindow
*scrolled_window
;
785 scrolled_window
= GTK_SCROLLED_WINDOW (container
);
787 if (scrolled_window
->vscrollbar
)
788 callback (scrolled_window
->vscrollbar
, callback_data
);
789 if (scrolled_window
->hscrollbar
)
790 callback (scrolled_window
->hscrollbar
, callback_data
);
795 gtk_scrolled_window_scroll_child (GtkScrolledWindow
*scrolled_window
,
796 GtkScrollType scroll
,
799 GtkAdjustment
*adjustment
= NULL
;
803 case GTK_SCROLL_STEP_UP
:
804 scroll
= GTK_SCROLL_STEP_BACKWARD
;
807 case GTK_SCROLL_STEP_DOWN
:
808 scroll
= GTK_SCROLL_STEP_FORWARD
;
811 case GTK_SCROLL_STEP_LEFT
:
812 scroll
= GTK_SCROLL_STEP_BACKWARD
;
815 case GTK_SCROLL_STEP_RIGHT
:
816 scroll
= GTK_SCROLL_STEP_FORWARD
;
819 case GTK_SCROLL_PAGE_UP
:
820 scroll
= GTK_SCROLL_PAGE_BACKWARD
;
823 case GTK_SCROLL_PAGE_DOWN
:
824 scroll
= GTK_SCROLL_PAGE_FORWARD
;
827 case GTK_SCROLL_PAGE_LEFT
:
828 scroll
= GTK_SCROLL_STEP_BACKWARD
;
831 case GTK_SCROLL_PAGE_RIGHT
:
832 scroll
= GTK_SCROLL_STEP_FORWARD
;
835 case GTK_SCROLL_STEP_BACKWARD
:
836 case GTK_SCROLL_STEP_FORWARD
:
837 case GTK_SCROLL_PAGE_BACKWARD
:
838 case GTK_SCROLL_PAGE_FORWARD
:
839 case GTK_SCROLL_START
:
843 g_warning ("Invalid scroll type %d for GtkSpinButton::change-value", scroll
);
849 if (scrolled_window
->hscrollbar
)
850 adjustment
= gtk_range_get_adjustment (GTK_RANGE (scrolled_window
->hscrollbar
));
854 if (scrolled_window
->vscrollbar
)
855 adjustment
= gtk_range_get_adjustment (GTK_RANGE (scrolled_window
->vscrollbar
));
860 gdouble value
= adjustment
->value
;
864 case GTK_SCROLL_STEP_FORWARD
:
865 value
+= adjustment
->step_increment
;
867 case GTK_SCROLL_STEP_BACKWARD
:
868 value
-= adjustment
->step_increment
;
870 case GTK_SCROLL_PAGE_FORWARD
:
871 value
+= adjustment
->page_increment
;
873 case GTK_SCROLL_PAGE_BACKWARD
:
874 value
-= adjustment
->page_increment
;
876 case GTK_SCROLL_START
:
877 value
= adjustment
->lower
;
880 value
= adjustment
->upper
;
883 g_assert_not_reached ();
887 value
= CLAMP (value
, adjustment
->lower
, adjustment
->upper
- adjustment
->page_size
);
889 gtk_adjustment_set_value (adjustment
, value
);
894 gtk_scrolled_window_move_focus_out (GtkScrolledWindow
*scrolled_window
,
895 GtkDirectionType direction_type
)
899 /* Focus out of the scrolled window entirely. We do this by setting
900 * a flag, then propagating the focus motion to the notebook.
902 toplevel
= gtk_widget_get_toplevel (GTK_WIDGET (scrolled_window
));
903 if (!GTK_WIDGET_TOPLEVEL (toplevel
))
906 g_object_ref (scrolled_window
);
908 scrolled_window
->focus_out
= TRUE
;
909 g_signal_emit_by_name (toplevel
, "move_focus", direction_type
);
910 scrolled_window
->focus_out
= FALSE
;
912 g_object_unref (scrolled_window
);
916 gtk_scrolled_window_size_request (GtkWidget
*widget
,
917 GtkRequisition
*requisition
)
919 GtkScrolledWindow
*scrolled_window
;
923 gint scrollbar_spacing
;
924 GtkRequisition hscrollbar_requisition
;
925 GtkRequisition vscrollbar_requisition
;
926 GtkRequisition child_requisition
;
928 g_return_if_fail (GTK_IS_SCROLLED_WINDOW (widget
));
929 g_return_if_fail (requisition
!= NULL
);
931 scrolled_window
= GTK_SCROLLED_WINDOW (widget
);
932 bin
= GTK_BIN (scrolled_window
);
934 scrollbar_spacing
= _gtk_scrolled_window_get_scrollbar_spacing (scrolled_window
);
938 requisition
->width
= 0;
939 requisition
->height
= 0;
941 gtk_widget_size_request (scrolled_window
->hscrollbar
,
942 &hscrollbar_requisition
);
943 gtk_widget_size_request (scrolled_window
->vscrollbar
,
944 &vscrollbar_requisition
);
946 if (bin
->child
&& GTK_WIDGET_VISIBLE (bin
->child
))
948 gtk_widget_size_request (bin
->child
, &child_requisition
);
950 if (scrolled_window
->hscrollbar_policy
== GTK_POLICY_NEVER
)
951 requisition
->width
+= child_requisition
.width
;
954 GtkWidgetAuxInfo
*aux_info
= _gtk_widget_get_aux_info (bin
->child
, FALSE
);
956 if (aux_info
&& aux_info
->width
> 0)
958 requisition
->width
+= aux_info
->width
;
962 requisition
->width
+= vscrollbar_requisition
.width
;
965 // if (scrolled_window->vscrollbar_policy == GTK_POLICY_NEVER)
966 // requisition->height += child_requisition.height;
969 GtkWidgetAuxInfo
*aux_info
= _gtk_widget_get_aux_info (bin
->child
, FALSE
);
971 if (aux_info
&& aux_info
->height
> 0)
973 requisition
->height
+= aux_info
->height
;
977 requisition
->height
+= hscrollbar_requisition
.height
;
981 if (scrolled_window
->hscrollbar_policy
== GTK_POLICY_AUTOMATIC
||
982 scrolled_window
->hscrollbar_policy
== GTK_POLICY_ALWAYS
)
984 requisition
->width
= MAX (requisition
->width
, hscrollbar_requisition
.width
);
985 if (!extra_height
|| scrolled_window
->hscrollbar_policy
== GTK_POLICY_ALWAYS
)
986 extra_height
= scrollbar_spacing
+ hscrollbar_requisition
.height
;
989 if (scrolled_window
->vscrollbar_policy
== GTK_POLICY_AUTOMATIC
||
990 scrolled_window
->vscrollbar_policy
== GTK_POLICY_ALWAYS
)
992 requisition
->height
= MAX (requisition
->height
, vscrollbar_requisition
.height
);
993 if (!extra_height
|| scrolled_window
->vscrollbar_policy
== GTK_POLICY_ALWAYS
)
994 extra_width
= scrollbar_spacing
+ vscrollbar_requisition
.width
;
997 requisition
->width
+= GTK_CONTAINER (widget
)->border_width
* 2 + MAX (0, extra_width
);
998 requisition
->height
+= GTK_CONTAINER (widget
)->border_width
* 2 + MAX (0, extra_height
);
1000 if (scrolled_window
->shadow_type
!= GTK_SHADOW_NONE
)
1002 requisition
->width
+= 2 * widget
->style
->xthickness
;
1003 requisition
->height
+= 2 * widget
->style
->ythickness
;
1008 gtk_scrolled_window_relative_allocation (GtkWidget
*widget
,
1009 GtkAllocation
*allocation
)
1011 GtkScrolledWindow
*scrolled_window
;
1012 gint scrollbar_spacing
;
1014 g_return_if_fail (widget
!= NULL
);
1015 g_return_if_fail (allocation
!= NULL
);
1017 scrolled_window
= GTK_SCROLLED_WINDOW (widget
);
1018 scrollbar_spacing
= _gtk_scrolled_window_get_scrollbar_spacing (scrolled_window
);
1020 allocation
->x
= GTK_CONTAINER (widget
)->border_width
;
1021 allocation
->y
= GTK_CONTAINER (widget
)->border_width
;
1023 if (scrolled_window
->shadow_type
!= GTK_SHADOW_NONE
)
1025 allocation
->x
+= widget
->style
->xthickness
;
1026 allocation
->y
+= widget
->style
->ythickness
;
1029 allocation
->width
= MAX (1, (gint
)widget
->allocation
.width
- allocation
->x
* 2);
1030 allocation
->height
= MAX (1, (gint
)widget
->allocation
.height
- allocation
->y
* 2);
1032 if (scrolled_window
->vscrollbar_visible
)
1034 GtkRequisition vscrollbar_requisition
;
1037 gtk_widget_get_child_requisition (scrolled_window
->vscrollbar
,
1038 &vscrollbar_requisition
);
1039 is_rtl
= gtk_widget_get_direction (widget
) == GTK_TEXT_DIR_RTL
;
1042 (scrolled_window
->window_placement
== GTK_CORNER_TOP_RIGHT
||
1043 scrolled_window
->window_placement
== GTK_CORNER_BOTTOM_RIGHT
)) ||
1045 (scrolled_window
->window_placement
== GTK_CORNER_TOP_LEFT
||
1046 scrolled_window
->window_placement
== GTK_CORNER_BOTTOM_LEFT
)))
1047 allocation
->x
+= (vscrollbar_requisition
.width
+ scrollbar_spacing
);
1049 allocation
->width
= MAX (1, allocation
->width
- (vscrollbar_requisition
.width
+ scrollbar_spacing
));
1051 if (scrolled_window
->hscrollbar_visible
)
1053 GtkRequisition hscrollbar_requisition
;
1054 gtk_widget_get_child_requisition (scrolled_window
->hscrollbar
,
1055 &hscrollbar_requisition
);
1057 if (scrolled_window
->window_placement
== GTK_CORNER_BOTTOM_LEFT
||
1058 scrolled_window
->window_placement
== GTK_CORNER_BOTTOM_RIGHT
)
1059 allocation
->y
+= (hscrollbar_requisition
.height
+ scrollbar_spacing
);
1061 allocation
->height
= MAX (1, allocation
->height
- (hscrollbar_requisition
.height
+ scrollbar_spacing
));
1066 gtk_scrolled_window_size_allocate (GtkWidget
*widget
,
1067 GtkAllocation
*allocation
)
1069 GtkScrolledWindow
*scrolled_window
;
1071 GtkAllocation relative_allocation
;
1072 GtkAllocation child_allocation
;
1073 gint scrollbar_spacing
;
1075 g_return_if_fail (GTK_IS_SCROLLED_WINDOW (widget
));
1076 g_return_if_fail (allocation
!= NULL
);
1078 scrolled_window
= GTK_SCROLLED_WINDOW (widget
);
1079 bin
= GTK_BIN (scrolled_window
);
1081 scrollbar_spacing
= _gtk_scrolled_window_get_scrollbar_spacing (scrolled_window
);
1083 widget
->allocation
= *allocation
;
1085 if (scrolled_window
->hscrollbar_policy
== GTK_POLICY_ALWAYS
)
1086 scrolled_window
->hscrollbar_visible
= TRUE
;
1087 else if (scrolled_window
->hscrollbar_policy
== GTK_POLICY_NEVER
)
1088 scrolled_window
->hscrollbar_visible
= FALSE
;
1089 if (scrolled_window
->vscrollbar_policy
== GTK_POLICY_ALWAYS
)
1090 scrolled_window
->vscrollbar_visible
= TRUE
;
1091 else if (scrolled_window
->vscrollbar_policy
== GTK_POLICY_NEVER
)
1092 scrolled_window
->vscrollbar_visible
= FALSE
;
1094 if (bin
->child
&& GTK_WIDGET_VISIBLE (bin
->child
))
1096 gboolean previous_hvis
;
1097 gboolean previous_vvis
;
1102 gtk_scrolled_window_relative_allocation (widget
, &relative_allocation
);
1104 child_allocation
.x
= relative_allocation
.x
+ allocation
->x
;
1105 child_allocation
.y
= relative_allocation
.y
+ allocation
->y
;
1106 child_allocation
.width
= relative_allocation
.width
;
1107 child_allocation
.height
= relative_allocation
.height
;
1109 previous_hvis
= scrolled_window
->hscrollbar_visible
;
1110 previous_vvis
= scrolled_window
->vscrollbar_visible
;
1112 gtk_widget_size_allocate (bin
->child
, &child_allocation
);
1114 /* If, after the first iteration, the hscrollbar and the
1115 * vscrollbar flip visiblity, then we need both.
1118 previous_hvis
!= scrolled_window
->hscrollbar_visible
&&
1119 previous_vvis
!= scrolled_window
->vscrollbar_visible
)
1121 scrolled_window
->hscrollbar_visible
= TRUE
;
1122 scrolled_window
->vscrollbar_visible
= TRUE
;
1124 /* a new resize is already queued at this point,
1125 * so we will immediatedly get reinvoked
1132 while (previous_hvis
!= scrolled_window
->hscrollbar_visible
||
1133 previous_vvis
!= scrolled_window
->vscrollbar_visible
);
1136 gtk_scrolled_window_relative_allocation (widget
, &relative_allocation
);
1138 if (scrolled_window
->hscrollbar_visible
)
1140 GtkRequisition hscrollbar_requisition
;
1141 gtk_widget_get_child_requisition (scrolled_window
->hscrollbar
,
1142 &hscrollbar_requisition
);
1144 if (!GTK_WIDGET_VISIBLE (scrolled_window
->hscrollbar
))
1145 gtk_widget_show (scrolled_window
->hscrollbar
);
1147 child_allocation
.x
= relative_allocation
.x
;
1148 if (scrolled_window
->window_placement
== GTK_CORNER_TOP_LEFT
||
1149 scrolled_window
->window_placement
== GTK_CORNER_TOP_RIGHT
)
1150 child_allocation
.y
= (relative_allocation
.y
+
1151 relative_allocation
.height
+
1153 (scrolled_window
->shadow_type
== GTK_SHADOW_NONE
?
1154 0 : widget
->style
->ythickness
));
1156 child_allocation
.y
= GTK_CONTAINER (scrolled_window
)->border_width
;
1158 child_allocation
.width
= relative_allocation
.width
;
1159 child_allocation
.height
= hscrollbar_requisition
.height
;
1160 child_allocation
.x
+= allocation
->x
;
1161 child_allocation
.y
+= allocation
->y
;
1163 if (scrolled_window
->shadow_type
!= GTK_SHADOW_NONE
)
1165 child_allocation
.x
-= widget
->style
->xthickness
;
1166 child_allocation
.width
+= 2 * widget
->style
->xthickness
;
1169 gtk_widget_size_allocate (scrolled_window
->hscrollbar
, &child_allocation
);
1171 else if (GTK_WIDGET_VISIBLE (scrolled_window
->hscrollbar
))
1172 gtk_widget_hide (scrolled_window
->hscrollbar
);
1174 if (scrolled_window
->vscrollbar_visible
)
1176 GtkRequisition vscrollbar_requisition
;
1177 if (!GTK_WIDGET_VISIBLE (scrolled_window
->vscrollbar
))
1178 gtk_widget_show (scrolled_window
->vscrollbar
);
1180 gtk_widget_get_child_requisition (scrolled_window
->vscrollbar
,
1181 &vscrollbar_requisition
);
1183 if ((gtk_widget_get_direction (widget
) == GTK_TEXT_DIR_RTL
&&
1184 (scrolled_window
->window_placement
== GTK_CORNER_TOP_RIGHT
||
1185 scrolled_window
->window_placement
== GTK_CORNER_BOTTOM_RIGHT
)) ||
1186 (gtk_widget_get_direction (widget
) == GTK_TEXT_DIR_LTR
&&
1187 (scrolled_window
->window_placement
== GTK_CORNER_TOP_LEFT
||
1188 scrolled_window
->window_placement
== GTK_CORNER_BOTTOM_LEFT
)))
1189 child_allocation
.x
= (relative_allocation
.x
+
1190 relative_allocation
.width
+
1192 (scrolled_window
->shadow_type
== GTK_SHADOW_NONE
?
1193 0 : widget
->style
->xthickness
));
1195 child_allocation
.x
= GTK_CONTAINER (scrolled_window
)->border_width
;
1197 child_allocation
.y
= relative_allocation
.y
;
1198 child_allocation
.width
= vscrollbar_requisition
.width
;
1199 child_allocation
.height
= relative_allocation
.height
;
1200 child_allocation
.x
+= allocation
->x
;
1201 child_allocation
.y
+= allocation
->y
;
1203 if (scrolled_window
->shadow_type
!= GTK_SHADOW_NONE
)
1205 child_allocation
.y
-= widget
->style
->ythickness
;
1206 child_allocation
.height
+= 2 * widget
->style
->ythickness
;
1209 gtk_widget_size_allocate (scrolled_window
->vscrollbar
, &child_allocation
);
1211 else if (GTK_WIDGET_VISIBLE (scrolled_window
->vscrollbar
))
1212 gtk_widget_hide (scrolled_window
->vscrollbar
);
1216 gtk_scrolled_window_scroll_event (GtkWidget
*widget
,
1217 GdkEventScroll
*event
)
1221 g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (widget
), FALSE
);
1222 g_return_val_if_fail (event
!= NULL
, FALSE
);
1224 if (event
->direction
== GDK_SCROLL_UP
|| event
->direction
== GDK_SCROLL_DOWN
)
1225 range
= GTK_SCROLLED_WINDOW (widget
)->vscrollbar
;
1227 range
= GTK_SCROLLED_WINDOW (widget
)->hscrollbar
;
1229 if (range
&& GTK_WIDGET_VISIBLE (range
))
1231 GtkAdjustment
*adj
= GTK_RANGE (range
)->adjustment
;
1232 gdouble delta
, new_value
;
1234 delta
= _gtk_range_get_wheel_delta (GTK_RANGE (range
), event
->direction
);
1236 new_value
= CLAMP (adj
->value
+ delta
, adj
->lower
, adj
->upper
- adj
->page_size
);
1238 gtk_adjustment_set_value (adj
, new_value
);
1247 gtk_scrolled_window_focus (GtkWidget
*widget
,
1248 GtkDirectionType direction
)
1250 GtkScrolledWindow
*scrolled_window
= GTK_SCROLLED_WINDOW (widget
);
1251 gboolean had_focus_child
= GTK_CONTAINER (widget
)->focus_child
!= NULL
;
1253 if (scrolled_window
->focus_out
)
1255 scrolled_window
->focus_out
= FALSE
; /* Clear this to catch the wrap-around case */
1259 if (gtk_widget_is_focus (widget
))
1262 /* We only put the scrolled window itself in the focus chain if it
1263 * isn't possible to focus any children.
1265 if (GTK_BIN (widget
)->child
)
1267 if (gtk_widget_child_focus (GTK_BIN (widget
)->child
, direction
))
1271 if (!had_focus_child
)
1273 gtk_widget_grab_focus (widget
);
1281 gtk_scrolled_window_adjustment_changed (GtkAdjustment
*adjustment
,
1284 GtkScrolledWindow
*scrolled_win
;
1286 g_return_if_fail (adjustment
!= NULL
);
1287 g_return_if_fail (data
!= NULL
);
1289 scrolled_win
= GTK_SCROLLED_WINDOW (data
);
1291 if (scrolled_win
->hscrollbar
&&
1292 adjustment
== gtk_range_get_adjustment (GTK_RANGE (scrolled_win
->hscrollbar
)))
1294 if (scrolled_win
->hscrollbar_policy
== GTK_POLICY_AUTOMATIC
)
1298 visible
= scrolled_win
->hscrollbar_visible
;
1299 scrolled_win
->hscrollbar_visible
= (adjustment
->upper
- adjustment
->lower
>
1300 adjustment
->page_size
);
1301 if (scrolled_win
->hscrollbar_visible
!= visible
)
1302 gtk_widget_queue_resize (GTK_WIDGET (scrolled_win
));
1305 else if (scrolled_win
->vscrollbar
&&
1306 adjustment
== gtk_range_get_adjustment (GTK_RANGE (scrolled_win
->vscrollbar
)))
1308 if (scrolled_win
->vscrollbar_policy
== GTK_POLICY_AUTOMATIC
)
1312 visible
= scrolled_win
->vscrollbar_visible
;
1313 scrolled_win
->vscrollbar_visible
= (adjustment
->upper
- adjustment
->lower
>
1314 adjustment
->page_size
);
1315 if (scrolled_win
->vscrollbar_visible
!= visible
)
1316 gtk_widget_queue_resize (GTK_WIDGET (scrolled_win
));
1322 gtk_scrolled_window_add (GtkContainer
*container
,
1325 GtkScrolledWindow
*scrolled_window
;
1328 bin
= GTK_BIN (container
);
1329 g_return_if_fail (bin
->child
== NULL
);
1331 scrolled_window
= GTK_SCROLLED_WINDOW (container
);
1334 gtk_widget_set_parent (child
, GTK_WIDGET (bin
));
1336 /* this is a temporary message */
1337 if (!gtk_widget_set_scroll_adjustments (child
,
1338 gtk_range_get_adjustment (GTK_RANGE (scrolled_window
->hscrollbar
)),
1339 gtk_range_get_adjustment (GTK_RANGE (scrolled_window
->vscrollbar
))))
1340 g_warning ("gtk_scrolled_window_add(): cannot add non scrollable widget "
1341 "use gtk_scrolled_window_add_with_viewport() instead");
1345 gtk_scrolled_window_remove (GtkContainer
*container
,
1348 g_return_if_fail (GTK_IS_SCROLLED_WINDOW (container
));
1349 g_return_if_fail (child
!= NULL
);
1350 g_return_if_fail (GTK_BIN (container
)->child
== child
);
1352 gtk_widget_set_scroll_adjustments (child
, NULL
, NULL
);
1354 /* chain parent class handler to remove child */
1355 GTK_CONTAINER_CLASS (parent_class
)->remove (container
, child
);
1359 gtk_scrolled_window_add_with_viewport (GtkScrolledWindow
*scrolled_window
,
1363 GtkWidget
*viewport
;
1365 g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window
));
1366 g_return_if_fail (GTK_IS_WIDGET (child
));
1367 g_return_if_fail (child
->parent
== NULL
);
1369 bin
= GTK_BIN (scrolled_window
);
1371 if (bin
->child
!= NULL
)
1373 g_return_if_fail (GTK_IS_VIEWPORT (bin
->child
));
1374 g_return_if_fail (GTK_BIN (bin
->child
)->child
== NULL
);
1376 viewport
= bin
->child
;
1381 gtk_viewport_new (gtk_scrolled_window_get_hadjustment (scrolled_window
),
1382 gtk_scrolled_window_get_vadjustment (scrolled_window
));
1383 gtk_container_add (GTK_CONTAINER (scrolled_window
), viewport
);
1386 gtk_widget_show (viewport
);
1387 gtk_container_add (GTK_CONTAINER (viewport
), child
);
1391 * _gtk_scrolled_window_get_spacing:
1392 * @scrolled_window: a scrolled window
1394 * Gets the spacing between the scrolled window's scrollbars and
1395 * the scrolled widget. Used by GtkCombo
1397 * Return value: the spacing, in pixels.
1400 _gtk_scrolled_window_get_scrollbar_spacing (GtkScrolledWindow
*scrolled_window
)
1402 GtkScrolledWindowClass
*class;
1404 g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window
), 0);
1406 class = GTK_SCROLLED_WINDOW_GET_CLASS (scrolled_window
);
1408 if (class->scrollbar_spacing
>= 0)
1409 return class->scrollbar_spacing
;
1412 gint scrollbar_spacing
;
1414 gtk_widget_style_get (GTK_WIDGET (scrolled_window
),
1415 "scrollbar_spacing", &scrollbar_spacing
,
1418 return scrollbar_spacing
;
1422 #define __GTK_SCROLLED_WINDOW_C__
1423 #include "gtkaliasdef.c"