1 /* GTK - The GIMP Toolkit
2 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
3 *
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.
8 *
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.
13 *
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.
18 */
19
20 /*
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/.
25 */
26
27 #include "config.h"
28 #include <math.h>
29 #include <gdk/gdkkeysyms.h>
30 #include "gtkbindings.h"
31 #include "gtkmarshalers.h"
32 #include "gtkscrolledwindow.h"
33 #include "gtkwindow.h"
34 #include "gtkprivate.h"
35 #include "gtkintl.h"
36 #include "gtkalias.h"
37
38
39 /* scrolled window policy and size requisition handling:
40 *
41 * gtk size requisition works as follows:
42 * a widget upon size-request reports the width and height that it finds
43 * to be best suited to display its contents, including children.
44 * the width and/or height reported from a widget upon size requisition
45 * may be overidden by the user by specifying a width and/or height
46 * other than 0 through gtk_widget_set_size_request().
47 *
48 * a scrolled window needs (for implementing all three policy types) to
49 * request its width and height based on two different rationales.
50 * 1) the user wants the scrolled window to just fit into the space
51 * that it gets allocated for a specifc dimension.
52 * 1.1) this does not apply if the user specified a concrete value
53 * value for that specific dimension by either specifying usize for the
54 * scrolled window or for its child.
55 * 2) the user wants the scrolled window to take as much space up as
56 * is desired by the child for a specifc dimension (i.e. POLICY_NEVER).
57 *
58 * also, kinda obvious:
59 * 3) a user would certainly not have choosen a scrolled window as a container
60 * for the child, if the resulting allocation takes up more space than the
61 * child would have allocated without the scrolled window.
62 *
63 * conclusions:
64 * A) from 1) follows: the scrolled window shouldn't request more space for a
65 * specifc dimension than is required at minimum.
66 * B) from 1.1) follows: the requisition may be overidden by usize of the scrolled
67 * window (done automatically) or by usize of the child (needs to be checked).
68 * C) from 2) follows: for POLICY_NEVER, the scrolled window simply reports the
69 * child's dimension.
70 * D) from 3) follows: the scrolled window child's minimum width and minimum height
71 * under A) at least correspond to the space taken up by its scrollbars.
72 */
73
74 #define DEFAULT_SCROLLBAR_SPACING 3
75
76 typedef struct {
77 gboolean window_placement_set;
78 GtkCornerType real_window_placement;
79 } GtkScrolledWindowPrivate;
80
81 #define GTK_SCROLLED_WINDOW_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_SCROLLED_WINDOW, GtkScrolledWindowPrivate))
82
83 enum {
84 PROP_0,
85 PROP_HADJUSTMENT,
86 PROP_VADJUSTMENT,
87 PROP_HSCROLLBAR_POLICY,
88 PROP_VSCROLLBAR_POLICY,
89 PROP_WINDOW_PLACEMENT,
90 PROP_WINDOW_PLACEMENT_SET,
91 PROP_SHADOW_TYPE
92 };
93
94 /* Signals */
95 enum
96 {
97 SCROLL_CHILD,
98 MOVE_FOCUS_OUT,
99 LAST_SIGNAL
100 };
101
102 static void gtk_scrolled_window_destroy (GtkObject *object);
103 static void gtk_scrolled_window_set_property (GObject *object,
104 guint prop_id,
105 const GValue *value,
106 GParamSpec *pspec);
107 static void gtk_scrolled_window_get_property (GObject *object,
108 guint prop_id,
109 GValue *value,
110 GParamSpec *pspec);
111
112 static void gtk_scrolled_window_screen_changed (GtkWidget *widget,
113 GdkScreen *previous_screen);
114 static gboolean gtk_scrolled_window_expose (GtkWidget *widget,
115 GdkEventExpose *event);
116 static void gtk_scrolled_window_size_request (GtkWidget *widget,
117 GtkRequisition *requisition);
118 static void gtk_scrolled_window_size_allocate (GtkWidget *widget,
119 GtkAllocation *allocation);
120 static gboolean gtk_scrolled_window_scroll_event (GtkWidget *widget,
121 GdkEventScroll *event);
122 static gboolean gtk_scrolled_window_focus (GtkWidget *widget,
123 GtkDirectionType direction);
124 static void gtk_scrolled_window_add (GtkContainer *container,
125 GtkWidget *widget);
126 static void gtk_scrolled_window_remove (GtkContainer *container,
127 GtkWidget *widget);
128 static void gtk_scrolled_window_forall (GtkContainer *container,
129 gboolean include_internals,
130 GtkCallback callback,
131 gpointer callback_data);
132 static gboolean gtk_scrolled_window_scroll_child (GtkScrolledWindow *scrolled_window,
133 GtkScrollType scroll,
134 gboolean horizontal);
135 static void gtk_scrolled_window_move_focus_out (GtkScrolledWindow *scrolled_window,
136 GtkDirectionType direction_type);
137
138 static void gtk_scrolled_window_relative_allocation(GtkWidget *widget,
139 GtkAllocation *allocation);
140 static void gtk_scrolled_window_adjustment_changed (GtkAdjustment *adjustment,
141 gpointer data);
142
143 static void gtk_scrolled_window_update_real_placement (GtkScrolledWindow *scrolled_window);
144
145 static guint signals[LAST_SIGNAL] = {0};
146
G_DEFINE_TYPE(GtkScrolledWindow,gtk_scrolled_window,GTK_TYPE_BIN)147 G_DEFINE_TYPE (GtkScrolledWindow, gtk_scrolled_window, GTK_TYPE_BIN)
148
149 static void
150 add_scroll_binding (GtkBindingSet *binding_set,
151 guint keyval,
152 GdkModifierType mask,
153 GtkScrollType scroll,
154 gboolean horizontal)
155 {
156 guint keypad_keyval = keyval - GDK_Left + GDK_KP_Left;
157
158 gtk_binding_entry_add_signal (binding_set, keyval, mask,
159 "scroll-child", 2,
160 GTK_TYPE_SCROLL_TYPE, scroll,
161 G_TYPE_BOOLEAN, horizontal);
162 gtk_binding_entry_add_signal (binding_set, keypad_keyval, mask,
163 "scroll-child", 2,
164 GTK_TYPE_SCROLL_TYPE, scroll,
165 G_TYPE_BOOLEAN, horizontal);
166 }
167
168 static void
add_tab_bindings(GtkBindingSet * binding_set,GdkModifierType modifiers,GtkDirectionType direction)169 add_tab_bindings (GtkBindingSet *binding_set,
170 GdkModifierType modifiers,
171 GtkDirectionType direction)
172 {
173 gtk_binding_entry_add_signal (binding_set, GDK_Tab, modifiers,
174 "move-focus-out", 1,
175 GTK_TYPE_DIRECTION_TYPE, direction);
176 gtk_binding_entry_add_signal (binding_set, GDK_KP_Tab, modifiers,
177 "move-focus-out", 1,
178 GTK_TYPE_DIRECTION_TYPE, direction);
179 }
180
181 static void
gtk_scrolled_window_class_init(GtkScrolledWindowClass * class)182 gtk_scrolled_window_class_init (GtkScrolledWindowClass *class)
183 {
184 GObjectClass *gobject_class = G_OBJECT_CLASS (class);
185 GtkObjectClass *object_class;
186 GtkWidgetClass *widget_class;
187 GtkContainerClass *container_class;
188 GtkBindingSet *binding_set;
189
190 object_class = (GtkObjectClass*) class;
191 widget_class = (GtkWidgetClass*) class;
192 container_class = (GtkContainerClass*) class;
193
194 gobject_class->set_property = gtk_scrolled_window_set_property;
195 gobject_class->get_property = gtk_scrolled_window_get_property;
196
197 object_class->destroy = gtk_scrolled_window_destroy;
198
199 widget_class->screen_changed = gtk_scrolled_window_screen_changed;
200 widget_class->expose_event = gtk_scrolled_window_expose;
201 widget_class->size_request = gtk_scrolled_window_size_request;
202 widget_class->size_allocate = gtk_scrolled_window_size_allocate;
203 widget_class->scroll_event = gtk_scrolled_window_scroll_event;
204 widget_class->focus = gtk_scrolled_window_focus;
205
206 container_class->add = gtk_scrolled_window_add;
207 container_class->remove = gtk_scrolled_window_remove;
208 container_class->forall = gtk_scrolled_window_forall;
209
210 class->scrollbar_spacing = -1;
211
212 class->scroll_child = gtk_scrolled_window_scroll_child;
213 class->move_focus_out = gtk_scrolled_window_move_focus_out;
214
215 g_object_class_install_property (gobject_class,
216 PROP_HADJUSTMENT,
217 g_param_spec_object ("hadjustment",
218 P_("Horizontal Adjustment"),
219 P_("The GtkAdjustment for the horizontal position"),
220 GTK_TYPE_ADJUSTMENT,
221 GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));
222 g_object_class_install_property (gobject_class,
223 PROP_VADJUSTMENT,
224 g_param_spec_object ("vadjustment",
225 P_("Vertical Adjustment"),
226 P_("The GtkAdjustment for the vertical position"),
227 GTK_TYPE_ADJUSTMENT,
228 GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));
229 g_object_class_install_property (gobject_class,
230 PROP_HSCROLLBAR_POLICY,
231 g_param_spec_enum ("hscrollbar-policy",
232 P_("Horizontal Scrollbar Policy"),
233 P_("When the horizontal scrollbar is displayed"),
234 GTK_TYPE_POLICY_TYPE,
235 GTK_POLICY_ALWAYS,
236 GTK_PARAM_READABLE | GTK_PARAM_WRITABLE));
237 g_object_class_install_property (gobject_class,
238 PROP_VSCROLLBAR_POLICY,
239 g_param_spec_enum ("vscrollbar-policy",
240 P_("Vertical Scrollbar Policy"),
241 P_("When the vertical scrollbar is displayed"),
242 GTK_TYPE_POLICY_TYPE,
243 GTK_POLICY_ALWAYS,
244 GTK_PARAM_READABLE | GTK_PARAM_WRITABLE));
245
246 g_object_class_install_property (gobject_class,
247 PROP_WINDOW_PLACEMENT,
248 g_param_spec_enum ("window-placement",
249 P_("Window Placement"),
250 P_("Where the contents are located with respect to the scrollbars. This property only takes effect if \"window-placement-set\" is TRUE."),
251 GTK_TYPE_CORNER_TYPE,
252 GTK_CORNER_TOP_LEFT,
253 GTK_PARAM_READABLE | GTK_PARAM_WRITABLE));
254
255 /**
256 * GtkScrolledWindow:window-placement-set:
257 *
258 * Whether "window-placement" should be used to determine the location
259 * of the contents with respect to the scrollbars. Otherwise, the
260 * "gtk-scrolled-window-placement" setting is used.
261 *
262 * Since: 2.10
263 */
264 g_object_class_install_property (gobject_class,
265 PROP_WINDOW_PLACEMENT_SET,
266 g_param_spec_boolean ("window-placement-set",
267 P_("Window Placement Set"),
268 P_("Whether \"window-placement\" should be used to determine the location of the contents with respect to the scrollbars."),
269 FALSE,
270 GTK_PARAM_READABLE | GTK_PARAM_WRITABLE));
271 g_object_class_install_property (gobject_class,
272 PROP_SHADOW_TYPE,
273 g_param_spec_enum ("shadow-type",
274 P_("Shadow Type"),
275 P_("Style of bevel around the contents"),
276 GTK_TYPE_SHADOW_TYPE,
277 GTK_SHADOW_NONE,
278 GTK_PARAM_READABLE | GTK_PARAM_WRITABLE));
279
280 /**
281 * GtkScrolledWindow:scrollbars-within-bevel:
282 *
283 * Whether to place scrollbars within the scrolled window's bevel.
284 *
285 * Since: 2.12
286 */
287 gtk_widget_class_install_style_property (widget_class,
288 g_param_spec_boolean ("scrollbars-within-bevel",
289 P_("Scrollbars within bevel"),
290 P_("Place scrollbars within the scrolled window's bevel"),
291 FALSE,
292 GTK_PARAM_READABLE));
293
294 gtk_widget_class_install_style_property (widget_class,
295 g_param_spec_int ("scrollbar-spacing",
296 P_("Scrollbar spacing"),
297 P_("Number of pixels between the scrollbars and the scrolled window"),
298 0,
299 G_MAXINT,
300 DEFAULT_SCROLLBAR_SPACING,
301 GTK_PARAM_READABLE));
302
303 /**
304 * GtkScrolledWindow::scroll-child:
305 * @scrolled_window: a #GtkScrolledWindow
306 * @scroll: a #GtkScrollType describing how much to scroll
307 * @horizontal: whether the keybinding scrolls the child
308 * horizontally or not
309 *
310 * The ::scroll-child signal is a
311 * <link linkend="keybinding-signals">keybinding signal</link>
312 * which gets emitted when a keybinding that scrolls is pressed.
313 * The horizontal or vertical adjustment is updated which triggers a
314 * signal that the scrolled windows child may listen to and scroll itself.
315 */
316 signals[SCROLL_CHILD] =
317 g_signal_new (I_("scroll-child"),
318 G_TYPE_FROM_CLASS (object_class),
319 G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
320 G_STRUCT_OFFSET (GtkScrolledWindowClass, scroll_child),
321 NULL, NULL,
322 _gtk_marshal_BOOLEAN__ENUM_BOOLEAN,
323 G_TYPE_BOOLEAN, 2,
324 GTK_TYPE_SCROLL_TYPE,
325 G_TYPE_BOOLEAN);
326 signals[MOVE_FOCUS_OUT] =
327 g_signal_new (I_("move-focus-out"),
328 G_TYPE_FROM_CLASS (object_class),
329 G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
330 G_STRUCT_OFFSET (GtkScrolledWindowClass, move_focus_out),
331 NULL, NULL,
332 _gtk_marshal_VOID__ENUM,
333 G_TYPE_NONE, 1,
334 GTK_TYPE_DIRECTION_TYPE);
335
336 binding_set = gtk_binding_set_by_class (class);
337
338 add_scroll_binding (binding_set, GDK_Left, GDK_CONTROL_MASK, GTK_SCROLL_STEP_BACKWARD, TRUE);
339 add_scroll_binding (binding_set, GDK_Right, GDK_CONTROL_MASK, GTK_SCROLL_STEP_FORWARD, TRUE);
340 add_scroll_binding (binding_set, GDK_Up, GDK_CONTROL_MASK, GTK_SCROLL_STEP_BACKWARD, FALSE);
341 add_scroll_binding (binding_set, GDK_Down, GDK_CONTROL_MASK, GTK_SCROLL_STEP_FORWARD, FALSE);
342
343 add_scroll_binding (binding_set, GDK_Page_Up, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_BACKWARD, TRUE);
344 add_scroll_binding (binding_set, GDK_Page_Down, GDK_CONTROL_MASK, GTK_SCROLL_PAGE_FORWARD, TRUE);
345 add_scroll_binding (binding_set, GDK_Page_Up, 0, GTK_SCROLL_PAGE_BACKWARD, FALSE);
346 add_scroll_binding (binding_set, GDK_Page_Down, 0, GTK_SCROLL_PAGE_FORWARD, FALSE);
347
348 add_scroll_binding (binding_set, GDK_Home, GDK_CONTROL_MASK, GTK_SCROLL_START, TRUE);
349 add_scroll_binding (binding_set, GDK_End, GDK_CONTROL_MASK, GTK_SCROLL_END, TRUE);
350 add_scroll_binding (binding_set, GDK_Home, 0, GTK_SCROLL_START, FALSE);
351 add_scroll_binding (binding_set, GDK_End, 0, GTK_SCROLL_END, FALSE);
352
353 add_tab_bindings (binding_set, GDK_CONTROL_MASK, GTK_DIR_TAB_FORWARD);
354 add_tab_bindings (binding_set, GDK_CONTROL_MASK | GDK_SHIFT_MASK, GTK_DIR_TAB_BACKWARD);
355
356 g_type_class_add_private (class, sizeof (GtkScrolledWindowPrivate));
357 }
358
359 static void
gtk_scrolled_window_init(GtkScrolledWindow * scrolled_window)360 gtk_scrolled_window_init (GtkScrolledWindow *scrolled_window)
361 {
362 gtk_widget_set_has_window (GTK_WIDGET (scrolled_window), FALSE);
363 gtk_widget_set_can_focus (GTK_WIDGET (scrolled_window), TRUE);
364
365 scrolled_window->hscrollbar = NULL;
366 scrolled_window->vscrollbar = NULL;
367 scrolled_window->hscrollbar_policy = GTK_POLICY_ALWAYS;
368 scrolled_window->vscrollbar_policy = GTK_POLICY_ALWAYS;
369 scrolled_window->hscrollbar_visible = FALSE;
370 scrolled_window->vscrollbar_visible = FALSE;
371 scrolled_window->focus_out = FALSE;
372 scrolled_window->window_placement = GTK_CORNER_TOP_LEFT;
373 gtk_scrolled_window_update_real_placement (scrolled_window);
374 }
375
376 /**
377 * gtk_scrolled_window_new:
378 * @hadjustment: (allow-none): horizontal adjustment
379 * @vadjustment: (allow-none): vertical adjustment
380 *
381 * Creates a new scrolled window.
382 *
383 * The two arguments are the scrolled window's adjustments; these will be
384 * shared with the scrollbars and the child widget to keep the bars in sync
385 * with the child. Usually you want to pass %NULL for the adjustments, which
386 * will cause the scrolled window to create them for you.
387 *
388 * Returns: a new scrolled window
389 */
390 GtkWidget*
gtk_scrolled_window_new(GtkAdjustment * hadjustment,GtkAdjustment * vadjustment)391 gtk_scrolled_window_new (GtkAdjustment *hadjustment,
392 GtkAdjustment *vadjustment)
393 {
394 GtkWidget *scrolled_window;
395
396 if (hadjustment)
397 g_return_val_if_fail (GTK_IS_ADJUSTMENT (hadjustment), NULL);
398
399 if (vadjustment)
400 g_return_val_if_fail (GTK_IS_ADJUSTMENT (vadjustment), NULL);
401
402 scrolled_window = g_object_new (GTK_TYPE_SCROLLED_WINDOW,
403 "hadjustment", hadjustment,
404 "vadjustment", vadjustment,
405 NULL);
406
407 return scrolled_window;
408 }
409
410 /**
411 * gtk_scrolled_window_set_hadjustment:
412 * @scrolled_window: a #GtkScrolledWindow
413 * @hadjustment: horizontal scroll adjustment
414 *
415 * Sets the #GtkAdjustment for the horizontal scrollbar.
416 */
417 void
gtk_scrolled_window_set_hadjustment(GtkScrolledWindow * scrolled_window,GtkAdjustment * hadjustment)418 gtk_scrolled_window_set_hadjustment (GtkScrolledWindow *scrolled_window,
419 GtkAdjustment *hadjustment)
420 {
421 GtkBin *bin;
422
423 g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
424 if (hadjustment)
425 g_return_if_fail (GTK_IS_ADJUSTMENT (hadjustment));
426 else
427 hadjustment = (GtkAdjustment*) g_object_new (GTK_TYPE_ADJUSTMENT, NULL);
428
429 bin = GTK_BIN (scrolled_window);
430
431 if (!scrolled_window->hscrollbar)
432 {
433 gtk_widget_push_composite_child ();
434 scrolled_window->hscrollbar = gtk_hscrollbar_new (hadjustment);
435 gtk_widget_set_composite_name (scrolled_window->hscrollbar, "hscrollbar");
436 gtk_widget_pop_composite_child ();
437
438 gtk_widget_set_parent (scrolled_window->hscrollbar, GTK_WIDGET (scrolled_window));
439 g_object_ref (scrolled_window->hscrollbar);
440 gtk_widget_show (scrolled_window->hscrollbar);
441 }
442 else
443 {
444 GtkAdjustment *old_adjustment;
445
446 old_adjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar));
447 if (old_adjustment == hadjustment)
448 return;
449
450 g_signal_handlers_disconnect_by_func (old_adjustment,
451 gtk_scrolled_window_adjustment_changed,
452 scrolled_window);
453 gtk_range_set_adjustment (GTK_RANGE (scrolled_window->hscrollbar),
454 hadjustment);
455 }
456 hadjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar));
457 g_signal_connect (hadjustment,
458 "changed",
459 G_CALLBACK (gtk_scrolled_window_adjustment_changed),
460 scrolled_window);
461 gtk_scrolled_window_adjustment_changed (hadjustment, scrolled_window);
462
463 if (bin->child)
464 gtk_widget_set_scroll_adjustments (bin->child,
465 gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar)),
466 gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar)));
467
468 g_object_notify (G_OBJECT (scrolled_window), "hadjustment");
469 }
470
471 /**
472 * gtk_scrolled_window_set_vadjustment:
473 * @scrolled_window: a #GtkScrolledWindow
474 * @vadjustment: vertical scroll adjustment
475 *
476 * Sets the #GtkAdjustment for the vertical scrollbar.
477 */
478 void
gtk_scrolled_window_set_vadjustment(GtkScrolledWindow * scrolled_window,GtkAdjustment * vadjustment)479 gtk_scrolled_window_set_vadjustment (GtkScrolledWindow *scrolled_window,
480 GtkAdjustment *vadjustment)
481 {
482 GtkBin *bin;
483
484 g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
485 if (vadjustment)
486 g_return_if_fail (GTK_IS_ADJUSTMENT (vadjustment));
487 else
488 vadjustment = (GtkAdjustment*) g_object_new (GTK_TYPE_ADJUSTMENT, NULL);
489
490 bin = GTK_BIN (scrolled_window);
491
492 if (!scrolled_window->vscrollbar)
493 {
494 gtk_widget_push_composite_child ();
495 scrolled_window->vscrollbar = gtk_vscrollbar_new (vadjustment);
496 gtk_widget_set_composite_name (scrolled_window->vscrollbar, "vscrollbar");
497 gtk_widget_pop_composite_child ();
498
499 gtk_widget_set_parent (scrolled_window->vscrollbar, GTK_WIDGET (scrolled_window));
500 g_object_ref (scrolled_window->vscrollbar);
501 gtk_widget_show (scrolled_window->vscrollbar);
502 }
503 else
504 {
505 GtkAdjustment *old_adjustment;
506
507 old_adjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar));
508 if (old_adjustment == vadjustment)
509 return;
510
511 g_signal_handlers_disconnect_by_func (old_adjustment,
512 gtk_scrolled_window_adjustment_changed,
513 scrolled_window);
514 gtk_range_set_adjustment (GTK_RANGE (scrolled_window->vscrollbar),
515 vadjustment);
516 }
517 vadjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar));
518 g_signal_connect (vadjustment,
519 "changed",
520 G_CALLBACK (gtk_scrolled_window_adjustment_changed),
521 scrolled_window);
522 gtk_scrolled_window_adjustment_changed (vadjustment, scrolled_window);
523
524 if (bin->child)
525 gtk_widget_set_scroll_adjustments (bin->child,
526 gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar)),
527 gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar)));
528
529 g_object_notify (G_OBJECT (scrolled_window), "vadjustment");
530 }
531
532 /**
533 * gtk_scrolled_window_get_hadjustment:
534 * @scrolled_window: a #GtkScrolledWindow
535 *
536 * Returns the horizontal scrollbar's adjustment, used to connect the
537 * horizontal scrollbar to the child widget's horizontal scroll
538 * functionality.
539 *
540 * Returns: (transfer none): the horizontal #GtkAdjustment
541 */
542 GtkAdjustment*
gtk_scrolled_window_get_hadjustment(GtkScrolledWindow * scrolled_window)543 gtk_scrolled_window_get_hadjustment (GtkScrolledWindow *scrolled_window)
544 {
545 g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), NULL);
546
547 return (scrolled_window->hscrollbar ?
548 gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar)) :
549 NULL);
550 }
551
552 /**
553 * gtk_scrolled_window_get_vadjustment:
554 * @scrolled_window: a #GtkScrolledWindow
555 *
556 * Returns the vertical scrollbar's adjustment, used to connect the
557 * vertical scrollbar to the child widget's vertical scroll functionality.
558 *
559 * Returns: (transfer none): the vertical #GtkAdjustment
560 */
561 GtkAdjustment*
gtk_scrolled_window_get_vadjustment(GtkScrolledWindow * scrolled_window)562 gtk_scrolled_window_get_vadjustment (GtkScrolledWindow *scrolled_window)
563 {
564 g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), NULL);
565
566 return (scrolled_window->vscrollbar ?
567 gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar)) :
568 NULL);
569 }
570
571 /**
572 * gtk_scrolled_window_get_hscrollbar:
573 * @scrolled_window: a #GtkScrolledWindow
574 *
575 * Returns the horizontal scrollbar of @scrolled_window.
576 *
577 * Returns: (transfer none): the horizontal scrollbar of the scrolled window,
578 * or %NULL if it does not have one.
579 *
580 * Since: 2.8
581 */
582 GtkWidget*
gtk_scrolled_window_get_hscrollbar(GtkScrolledWindow * scrolled_window)583 gtk_scrolled_window_get_hscrollbar (GtkScrolledWindow *scrolled_window)
584 {
585 g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), NULL);
586
587 return scrolled_window->hscrollbar;
588 }
589
590 /**
591 * gtk_scrolled_window_get_vscrollbar:
592 * @scrolled_window: a #GtkScrolledWindow
593 *
594 * Returns the vertical scrollbar of @scrolled_window.
595 *
596 * Returns: (transfer none): the vertical scrollbar of the scrolled window,
597 * or %NULL if it does not have one.
598 *
599 * Since: 2.8
600 */
601 GtkWidget*
gtk_scrolled_window_get_vscrollbar(GtkScrolledWindow * scrolled_window)602 gtk_scrolled_window_get_vscrollbar (GtkScrolledWindow *scrolled_window)
603 {
604 g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), NULL);
605
606 return scrolled_window->vscrollbar;
607 }
608
609 /**
610 * gtk_scrolled_window_set_policy:
611 * @scrolled_window: a #GtkScrolledWindow
612 * @hscrollbar_policy: policy for horizontal bar
613 * @vscrollbar_policy: policy for vertical bar
614 *
615 * Sets the scrollbar policy for the horizontal and vertical scrollbars.
616 *
617 * The policy determines when the scrollbar should appear; it is a value
618 * from the #GtkPolicyType enumeration. If %GTK_POLICY_ALWAYS, the
619 * scrollbar is always present; if %GTK_POLICY_NEVER, the scrollbar is
620 * never present; if %GTK_POLICY_AUTOMATIC, the scrollbar is present only
621 * if needed (that is, if the slider part of the bar would be smaller
622 * than the trough - the display is larger than the page size).
623 */
624 void
gtk_scrolled_window_set_policy(GtkScrolledWindow * scrolled_window,GtkPolicyType hscrollbar_policy,GtkPolicyType vscrollbar_policy)625 gtk_scrolled_window_set_policy (GtkScrolledWindow *scrolled_window,
626 GtkPolicyType hscrollbar_policy,
627 GtkPolicyType vscrollbar_policy)
628 {
629 GObject *object = G_OBJECT (scrolled_window);
630
631 g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
632
633 if ((scrolled_window->hscrollbar_policy != hscrollbar_policy) ||
634 (scrolled_window->vscrollbar_policy != vscrollbar_policy))
635 {
636 scrolled_window->hscrollbar_policy = hscrollbar_policy;
637 scrolled_window->vscrollbar_policy = vscrollbar_policy;
638
639 gtk_widget_queue_resize (GTK_WIDGET (scrolled_window));
640
641 g_object_freeze_notify (object);
642 g_object_notify (object, "hscrollbar-policy");
643 g_object_notify (object, "vscrollbar-policy");
644 g_object_thaw_notify (object);
645 }
646 }
647
648 /**
649 * gtk_scrolled_window_get_policy:
650 * @scrolled_window: a #GtkScrolledWindow
651 * @hscrollbar_policy: (out) (allow-none): location to store the policy
652 * for the horizontal scrollbar, or %NULL.
653 * @vscrollbar_policy: (out) (allow-none): location to store the policy
654 * for the vertical scrollbar, or %NULL.
655 *
656 * Retrieves the current policy values for the horizontal and vertical
657 * scrollbars. See gtk_scrolled_window_set_policy().
658 */
659 void
gtk_scrolled_window_get_policy(GtkScrolledWindow * scrolled_window,GtkPolicyType * hscrollbar_policy,GtkPolicyType * vscrollbar_policy)660 gtk_scrolled_window_get_policy (GtkScrolledWindow *scrolled_window,
661 GtkPolicyType *hscrollbar_policy,
662 GtkPolicyType *vscrollbar_policy)
663 {
664 g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
665
666 if (hscrollbar_policy)
667 *hscrollbar_policy = scrolled_window->hscrollbar_policy;
668 if (vscrollbar_policy)
669 *vscrollbar_policy = scrolled_window->vscrollbar_policy;
670 }
671
672 static void
gtk_scrolled_window_update_real_placement(GtkScrolledWindow * scrolled_window)673 gtk_scrolled_window_update_real_placement (GtkScrolledWindow *scrolled_window)
674 {
675 GtkScrolledWindowPrivate *priv = GTK_SCROLLED_WINDOW_GET_PRIVATE (scrolled_window);
676 GtkSettings *settings;
677
678 settings = gtk_widget_get_settings (GTK_WIDGET (scrolled_window));
679
680 if (priv->window_placement_set || settings == NULL)
681 priv->real_window_placement = scrolled_window->window_placement;
682 else
683 g_object_get (settings,
684 "gtk-scrolled-window-placement",
685 &priv->real_window_placement,
686 NULL);
687 }
688
689 static void
gtk_scrolled_window_set_placement_internal(GtkScrolledWindow * scrolled_window,GtkCornerType window_placement)690 gtk_scrolled_window_set_placement_internal (GtkScrolledWindow *scrolled_window,
691 GtkCornerType window_placement)
692 {
693 if (scrolled_window->window_placement != window_placement)
694 {
695 scrolled_window->window_placement = window_placement;
696
697 gtk_scrolled_window_update_real_placement (scrolled_window);
698 gtk_widget_queue_resize (GTK_WIDGET (scrolled_window));
699
700 g_object_notify (G_OBJECT (scrolled_window), "window-placement");
701 }
702 }
703
704 static void
gtk_scrolled_window_set_placement_set(GtkScrolledWindow * scrolled_window,gboolean placement_set,gboolean emit_resize)705 gtk_scrolled_window_set_placement_set (GtkScrolledWindow *scrolled_window,
706 gboolean placement_set,
707 gboolean emit_resize)
708 {
709 GtkScrolledWindowPrivate *priv = GTK_SCROLLED_WINDOW_GET_PRIVATE (scrolled_window);
710
711 if (priv->window_placement_set != placement_set)
712 {
713 priv->window_placement_set = placement_set;
714
715 gtk_scrolled_window_update_real_placement (scrolled_window);
716 if (emit_resize)
717 gtk_widget_queue_resize (GTK_WIDGET (scrolled_window));
718
719 g_object_notify (G_OBJECT (scrolled_window), "window-placement-set");
720 }
721 }
722
723 /**
724 * gtk_scrolled_window_set_placement:
725 * @scrolled_window: a #GtkScrolledWindow
726 * @window_placement: position of the child window
727 *
728 * Sets the placement of the contents with respect to the scrollbars
729 * for the scrolled window.
730 *
731 * The default is %GTK_CORNER_TOP_LEFT, meaning the child is
732 * in the top left, with the scrollbars underneath and to the right.
733 * Other values in #GtkCornerType are %GTK_CORNER_TOP_RIGHT,
734 * %GTK_CORNER_BOTTOM_LEFT, and %GTK_CORNER_BOTTOM_RIGHT.
735 *
736 * See also gtk_scrolled_window_get_placement() and
737 * gtk_scrolled_window_unset_placement().
738 */
739 void
gtk_scrolled_window_set_placement(GtkScrolledWindow * scrolled_window,GtkCornerType window_placement)740 gtk_scrolled_window_set_placement (GtkScrolledWindow *scrolled_window,
741 GtkCornerType window_placement)
742 {
743 g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
744
745 gtk_scrolled_window_set_placement_set (scrolled_window, TRUE, FALSE);
746 gtk_scrolled_window_set_placement_internal (scrolled_window, window_placement);
747 }
748
749 /**
750 * gtk_scrolled_window_get_placement:
751 * @scrolled_window: a #GtkScrolledWindow
752 *
753 * Gets the placement of the contents with respect to the scrollbars
754 * for the scrolled window. See gtk_scrolled_window_set_placement().
755 *
756 * Return value: the current placement value.
757 *
758 * See also gtk_scrolled_window_set_placement() and
759 * gtk_scrolled_window_unset_placement().
760 **/
761 GtkCornerType
gtk_scrolled_window_get_placement(GtkScrolledWindow * scrolled_window)762 gtk_scrolled_window_get_placement (GtkScrolledWindow *scrolled_window)
763 {
764 g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), GTK_CORNER_TOP_LEFT);
765
766 return scrolled_window->window_placement;
767 }
768
769 /**
770 * gtk_scrolled_window_unset_placement:
771 * @scrolled_window: a #GtkScrolledWindow
772 *
773 * Unsets the placement of the contents with respect to the scrollbars
774 * for the scrolled window. If no window placement is set for a scrolled
775 * window, it obeys the "gtk-scrolled-window-placement" XSETTING.
776 *
777 * See also gtk_scrolled_window_set_placement() and
778 * gtk_scrolled_window_get_placement().
779 *
780 * Since: 2.10
781 **/
782 void
gtk_scrolled_window_unset_placement(GtkScrolledWindow * scrolled_window)783 gtk_scrolled_window_unset_placement (GtkScrolledWindow *scrolled_window)
784 {
785 GtkScrolledWindowPrivate *priv = GTK_SCROLLED_WINDOW_GET_PRIVATE (scrolled_window);
786
787 g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
788
789 if (priv->window_placement_set)
790 {
791 priv->window_placement_set = FALSE;
792
793 gtk_widget_queue_resize (GTK_WIDGET (scrolled_window));
794
795 g_object_notify (G_OBJECT (scrolled_window), "window-placement-set");
796 }
797 }
798
799 /**
800 * gtk_scrolled_window_set_shadow_type:
801 * @scrolled_window: a #GtkScrolledWindow
802 * @type: kind of shadow to draw around scrolled window contents
803 *
804 * Changes the type of shadow drawn around the contents of
805 * @scrolled_window.
806 *
807 **/
808 void
gtk_scrolled_window_set_shadow_type(GtkScrolledWindow * scrolled_window,GtkShadowType type)809 gtk_scrolled_window_set_shadow_type (GtkScrolledWindow *scrolled_window,
810 GtkShadowType type)
811 {
812 g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
813 g_return_if_fail (type >= GTK_SHADOW_NONE && type <= GTK_SHADOW_ETCHED_OUT);
814
815 if (scrolled_window->shadow_type != type)
816 {
817 scrolled_window->shadow_type = type;
818
819 if (gtk_widget_is_drawable (GTK_WIDGET (scrolled_window)))
820 gtk_widget_queue_draw (GTK_WIDGET (scrolled_window));
821
822 gtk_widget_queue_resize (GTK_WIDGET (scrolled_window));
823
824 g_object_notify (G_OBJECT (scrolled_window), "shadow-type");
825 }
826 }
827
828 /**
829 * gtk_scrolled_window_get_shadow_type:
830 * @scrolled_window: a #GtkScrolledWindow
831 *
832 * Gets the shadow type of the scrolled window. See
833 * gtk_scrolled_window_set_shadow_type().
834 *
835 * Return value: the current shadow type
836 **/
837 GtkShadowType
gtk_scrolled_window_get_shadow_type(GtkScrolledWindow * scrolled_window)838 gtk_scrolled_window_get_shadow_type (GtkScrolledWindow *scrolled_window)
839 {
840 g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), GTK_SHADOW_NONE);
841
842 return scrolled_window->shadow_type;
843 }
844
845 static void
gtk_scrolled_window_destroy(GtkObject * object)846 gtk_scrolled_window_destroy (GtkObject *object)
847 {
848 GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (object);
849
850 if (scrolled_window->hscrollbar)
851 {
852 g_signal_handlers_disconnect_by_func (gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar)),
853 gtk_scrolled_window_adjustment_changed,
854 scrolled_window);
855 gtk_widget_unparent (scrolled_window->hscrollbar);
856 gtk_widget_destroy (scrolled_window->hscrollbar);
857 g_object_unref (scrolled_window->hscrollbar);
858 scrolled_window->hscrollbar = NULL;
859 }
860 if (scrolled_window->vscrollbar)
861 {
862 g_signal_handlers_disconnect_by_func (gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar)),
863 gtk_scrolled_window_adjustment_changed,
864 scrolled_window);
865 gtk_widget_unparent (scrolled_window->vscrollbar);
866 gtk_widget_destroy (scrolled_window->vscrollbar);
867 g_object_unref (scrolled_window->vscrollbar);
868 scrolled_window->vscrollbar = NULL;
869 }
870
871 GTK_OBJECT_CLASS (gtk_scrolled_window_parent_class)->destroy (object);
872 }
873
874 static void
gtk_scrolled_window_set_property(GObject * object,guint prop_id,const GValue * value,GParamSpec * pspec)875 gtk_scrolled_window_set_property (GObject *object,
876 guint prop_id,
877 const GValue *value,
878 GParamSpec *pspec)
879 {
880 GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (object);
881
882 switch (prop_id)
883 {
884 case PROP_HADJUSTMENT:
885 gtk_scrolled_window_set_hadjustment (scrolled_window,
886 g_value_get_object (value));
887 break;
888 case PROP_VADJUSTMENT:
889 gtk_scrolled_window_set_vadjustment (scrolled_window,
890 g_value_get_object (value));
891 break;
892 case PROP_HSCROLLBAR_POLICY:
893 gtk_scrolled_window_set_policy (scrolled_window,
894 g_value_get_enum (value),
895 scrolled_window->vscrollbar_policy);
896 break;
897 case PROP_VSCROLLBAR_POLICY:
898 gtk_scrolled_window_set_policy (scrolled_window,
899 scrolled_window->hscrollbar_policy,
900 g_value_get_enum (value));
901 break;
902 case PROP_WINDOW_PLACEMENT:
903 gtk_scrolled_window_set_placement_internal (scrolled_window,
904 g_value_get_enum (value));
905 break;
906 case PROP_WINDOW_PLACEMENT_SET:
907 gtk_scrolled_window_set_placement_set (scrolled_window,
908 g_value_get_boolean (value),
909 TRUE);
910 break;
911 case PROP_SHADOW_TYPE:
912 gtk_scrolled_window_set_shadow_type (scrolled_window,
913 g_value_get_enum (value));
914 break;
915 default:
916 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
917 break;
918 }
919 }
920
921 static void
gtk_scrolled_window_get_property(GObject * object,guint prop_id,GValue * value,GParamSpec * pspec)922 gtk_scrolled_window_get_property (GObject *object,
923 guint prop_id,
924 GValue *value,
925 GParamSpec *pspec)
926 {
927 GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (object);
928 GtkScrolledWindowPrivate *priv = GTK_SCROLLED_WINDOW_GET_PRIVATE (scrolled_window);
929
930 switch (prop_id)
931 {
932 case PROP_HADJUSTMENT:
933 g_value_set_object (value,
934 G_OBJECT (gtk_scrolled_window_get_hadjustment (scrolled_window)));
935 break;
936 case PROP_VADJUSTMENT:
937 g_value_set_object (value,
938 G_OBJECT (gtk_scrolled_window_get_vadjustment (scrolled_window)));
939 break;
940 case PROP_HSCROLLBAR_POLICY:
941 g_value_set_enum (value, scrolled_window->hscrollbar_policy);
942 break;
943 case PROP_VSCROLLBAR_POLICY:
944 g_value_set_enum (value, scrolled_window->vscrollbar_policy);
945 break;
946 case PROP_WINDOW_PLACEMENT:
947 g_value_set_enum (value, scrolled_window->window_placement);
948 break;
949 case PROP_WINDOW_PLACEMENT_SET:
950 g_value_set_boolean (value, priv->window_placement_set);
951 break;
952 case PROP_SHADOW_TYPE:
953 g_value_set_enum (value, scrolled_window->shadow_type);
954 break;
955 default:
956 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
957 break;
958 }
959 }
960
961 static void
traverse_container(GtkWidget * widget,gpointer data)962 traverse_container (GtkWidget *widget,
963 gpointer data)
964 {
965 if (GTK_IS_SCROLLED_WINDOW (widget))
966 {
967 gtk_scrolled_window_update_real_placement (GTK_SCROLLED_WINDOW (widget));
968 gtk_widget_queue_resize (widget);
969 }
970 else if (GTK_IS_CONTAINER (widget))
971 gtk_container_forall (GTK_CONTAINER (widget), traverse_container, NULL);
972 }
973
974 static void
gtk_scrolled_window_settings_changed(GtkSettings * settings)975 gtk_scrolled_window_settings_changed (GtkSettings *settings)
976 {
977 GList *list, *l;
978
979 list = gtk_window_list_toplevels ();
980
981 for (l = list; l; l = l->next)
982 gtk_container_forall (GTK_CONTAINER (l->data),
983 traverse_container, NULL);
984
985 g_list_free (list);
986 }
987
988 static void
gtk_scrolled_window_screen_changed(GtkWidget * widget,GdkScreen * previous_screen)989 gtk_scrolled_window_screen_changed (GtkWidget *widget,
990 GdkScreen *previous_screen)
991 {
992 GtkSettings *settings;
993 guint window_placement_connection;
994
995 gtk_scrolled_window_update_real_placement (GTK_SCROLLED_WINDOW (widget));
996
997 if (!gtk_widget_has_screen (widget))
998 return;
999
1000 settings = gtk_widget_get_settings (widget);
1001
1002 window_placement_connection =
1003 GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (settings),
1004 "gtk-scrolled-window-connection"));
1005
1006 if (window_placement_connection)
1007 return;
1008
1009 window_placement_connection =
1010 g_signal_connect (settings, "notify::gtk-scrolled-window-placement",
1011 G_CALLBACK (gtk_scrolled_window_settings_changed), NULL);
1012 g_object_set_data (G_OBJECT (settings),
1013 I_("gtk-scrolled-window-connection"),
1014 GUINT_TO_POINTER (window_placement_connection));
1015 }
1016
1017 static void
gtk_scrolled_window_paint(GtkWidget * widget,GdkRectangle * area)1018 gtk_scrolled_window_paint (GtkWidget *widget,
1019 GdkRectangle *area)
1020 {
1021 GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (widget);
1022
1023 if (scrolled_window->shadow_type != GTK_SHADOW_NONE)
1024 {
1025 GtkAllocation relative_allocation;
1026 gboolean scrollbars_within_bevel;
1027
1028 gtk_widget_style_get (widget, "scrollbars-within-bevel", &scrollbars_within_bevel, NULL);
1029
1030 if (!scrollbars_within_bevel)
1031 {
1032 gtk_scrolled_window_relative_allocation (widget, &relative_allocation);
1033
1034 relative_allocation.x -= widget->style->xthickness;
1035 relative_allocation.y -= widget->style->ythickness;
1036 relative_allocation.width += 2 * widget->style->xthickness;
1037 relative_allocation.height += 2 * widget->style->ythickness;
1038 }
1039 else
1040 {
1041 GtkContainer *container = GTK_CONTAINER (widget);
1042
1043 relative_allocation.x = container->border_width;
1044 relative_allocation.y = container->border_width;
1045 relative_allocation.width = widget->allocation.width - 2 * container->border_width;
1046 relative_allocation.height = widget->allocation.height - 2 * container->border_width;
1047 }
1048
1049 gtk_paint_shadow (widget->style, widget->window,
1050 GTK_STATE_NORMAL, scrolled_window->shadow_type,
1051 area, widget, "scrolled_window",
1052 widget->allocation.x + relative_allocation.x,
1053 widget->allocation.y + relative_allocation.y,
1054 relative_allocation.width,
1055 relative_allocation.height);
1056 }
1057 }
1058
1059 static gboolean
gtk_scrolled_window_expose(GtkWidget * widget,GdkEventExpose * event)1060 gtk_scrolled_window_expose (GtkWidget *widget,
1061 GdkEventExpose *event)
1062 {
1063 if (gtk_widget_is_drawable (widget))
1064 {
1065 gtk_scrolled_window_paint (widget, &event->area);
1066
1067 GTK_WIDGET_CLASS (gtk_scrolled_window_parent_class)->expose_event (widget, event);
1068 }
1069
1070 return FALSE;
1071 }
1072
1073 static void
gtk_scrolled_window_forall(GtkContainer * container,gboolean include_internals,GtkCallback callback,gpointer callback_data)1074 gtk_scrolled_window_forall (GtkContainer *container,
1075 gboolean include_internals,
1076 GtkCallback callback,
1077 gpointer callback_data)
1078 {
1079 g_return_if_fail (GTK_IS_SCROLLED_WINDOW (container));
1080 g_return_if_fail (callback != NULL);
1081
1082 GTK_CONTAINER_CLASS (gtk_scrolled_window_parent_class)->forall (container,
1083 include_internals,
1084 callback,
1085 callback_data);
1086 if (include_internals)
1087 {
1088 GtkScrolledWindow *scrolled_window;
1089
1090 scrolled_window = GTK_SCROLLED_WINDOW (container);
1091
1092 if (scrolled_window->vscrollbar)
1093 callback (scrolled_window->vscrollbar, callback_data);
1094 if (scrolled_window->hscrollbar)
1095 callback (scrolled_window->hscrollbar, callback_data);
1096 }
1097 }
1098
1099 static gboolean
gtk_scrolled_window_scroll_child(GtkScrolledWindow * scrolled_window,GtkScrollType scroll,gboolean horizontal)1100 gtk_scrolled_window_scroll_child (GtkScrolledWindow *scrolled_window,
1101 GtkScrollType scroll,
1102 gboolean horizontal)
1103 {
1104 GtkAdjustment *adjustment = NULL;
1105
1106 switch (scroll)
1107 {
1108 case GTK_SCROLL_STEP_UP:
1109 scroll = GTK_SCROLL_STEP_BACKWARD;
1110 horizontal = FALSE;
1111 break;
1112 case GTK_SCROLL_STEP_DOWN:
1113 scroll = GTK_SCROLL_STEP_FORWARD;
1114 horizontal = FALSE;
1115 break;
1116 case GTK_SCROLL_STEP_LEFT:
1117 scroll = GTK_SCROLL_STEP_BACKWARD;
1118 horizontal = TRUE;
1119 break;
1120 case GTK_SCROLL_STEP_RIGHT:
1121 scroll = GTK_SCROLL_STEP_FORWARD;
1122 horizontal = TRUE;
1123 break;
1124 case GTK_SCROLL_PAGE_UP:
1125 scroll = GTK_SCROLL_PAGE_BACKWARD;
1126 horizontal = FALSE;
1127 break;
1128 case GTK_SCROLL_PAGE_DOWN:
1129 scroll = GTK_SCROLL_PAGE_FORWARD;
1130 horizontal = FALSE;
1131 break;
1132 case GTK_SCROLL_PAGE_LEFT:
1133 scroll = GTK_SCROLL_STEP_BACKWARD;
1134 horizontal = TRUE;
1135 break;
1136 case GTK_SCROLL_PAGE_RIGHT:
1137 scroll = GTK_SCROLL_STEP_FORWARD;
1138 horizontal = TRUE;
1139 break;
1140 case GTK_SCROLL_STEP_BACKWARD:
1141 case GTK_SCROLL_STEP_FORWARD:
1142 case GTK_SCROLL_PAGE_BACKWARD:
1143 case GTK_SCROLL_PAGE_FORWARD:
1144 case GTK_SCROLL_START:
1145 case GTK_SCROLL_END:
1146 break;
1147 default:
1148 g_warning ("Invalid scroll type %u for GtkScrolledWindow::scroll-child", scroll);
1149 return FALSE;
1150 }
1151
1152 if ((horizontal && (!scrolled_window->hscrollbar || !scrolled_window->hscrollbar_visible)) ||
1153 (!horizontal && (!scrolled_window->vscrollbar || !scrolled_window->vscrollbar_visible)))
1154 return FALSE;
1155
1156 if (horizontal)
1157 {
1158 if (scrolled_window->hscrollbar)
1159 adjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar));
1160 }
1161 else
1162 {
1163 if (scrolled_window->vscrollbar)
1164 adjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar));
1165 }
1166
1167 if (adjustment)
1168 {
1169 gdouble value = adjustment->value;
1170
1171 switch (scroll)
1172 {
1173 case GTK_SCROLL_STEP_FORWARD:
1174 value += adjustment->step_increment;
1175 break;
1176 case GTK_SCROLL_STEP_BACKWARD:
1177 value -= adjustment->step_increment;
1178 break;
1179 case GTK_SCROLL_PAGE_FORWARD:
1180 value += adjustment->page_increment;
1181 break;
1182 case GTK_SCROLL_PAGE_BACKWARD:
1183 value -= adjustment->page_increment;
1184 break;
1185 case GTK_SCROLL_START:
1186 value = adjustment->lower;
1187 break;
1188 case GTK_SCROLL_END:
1189 value = adjustment->upper;
1190 break;
1191 default:
1192 g_assert_not_reached ();
1193 break;
1194 }
1195
1196 value = CLAMP (value, adjustment->lower, adjustment->upper - adjustment->page_size);
1197
1198 gtk_adjustment_set_value (adjustment, value);
1199
1200 return TRUE;
1201 }
1202
1203 return FALSE;
1204 }
1205
1206 static void
gtk_scrolled_window_move_focus_out(GtkScrolledWindow * scrolled_window,GtkDirectionType direction_type)1207 gtk_scrolled_window_move_focus_out (GtkScrolledWindow *scrolled_window,
1208 GtkDirectionType direction_type)
1209 {
1210 GtkWidget *toplevel;
1211
1212 /* Focus out of the scrolled window entirely. We do this by setting
1213 * a flag, then propagating the focus motion to the notebook.
1214 */
1215 toplevel = gtk_widget_get_toplevel (GTK_WIDGET (scrolled_window));
1216 if (!gtk_widget_is_toplevel (toplevel))
1217 return;
1218
1219 g_object_ref (scrolled_window);
1220
1221 scrolled_window->focus_out = TRUE;
1222 g_signal_emit_by_name (toplevel, "move-focus", direction_type);
1223 scrolled_window->focus_out = FALSE;
1224
1225 g_object_unref (scrolled_window);
1226 }
1227
1228 static void
gtk_scrolled_window_size_request(GtkWidget * widget,GtkRequisition * requisition)1229 gtk_scrolled_window_size_request (GtkWidget *widget,
1230 GtkRequisition *requisition)
1231 {
1232 GtkScrolledWindow *scrolled_window;
1233 GtkBin *bin;
1234 gint extra_width;
1235 gint extra_height;
1236 gint scrollbar_spacing;
1237 GtkRequisition hscrollbar_requisition;
1238 GtkRequisition vscrollbar_requisition;
1239 GtkRequisition child_requisition;
1240
1241 g_return_if_fail (GTK_IS_SCROLLED_WINDOW (widget));
1242 g_return_if_fail (requisition != NULL);
1243
1244 scrolled_window = GTK_SCROLLED_WINDOW (widget);
1245 bin = GTK_BIN (scrolled_window);
1246
1247 scrollbar_spacing = _gtk_scrolled_window_get_scrollbar_spacing (scrolled_window);
1248
1249 extra_width = 0;
1250 extra_height = 0;
1251 requisition->width = 0;
1252 requisition->height = 0;
1253
1254 gtk_widget_size_request (scrolled_window->hscrollbar,
1255 &hscrollbar_requisition);
1256 gtk_widget_size_request (scrolled_window->vscrollbar,
1257 &vscrollbar_requisition);
1258
1259 if (bin->child && gtk_widget_get_visible (bin->child))
1260 {
1261 gtk_widget_size_request (bin->child, &child_requisition);
1262
1263 if (scrolled_window->hscrollbar_policy == GTK_POLICY_NEVER)
1264 requisition->width += child_requisition.width;
1265 else
1266 {
1267 GtkWidgetAuxInfo *aux_info = _gtk_widget_get_aux_info (bin->child, FALSE);
1268
1269 if (aux_info && aux_info->width > 0)
1270 {
1271 requisition->width += aux_info->width;
1272 extra_width = -1;
1273 }
1274 else
1275 requisition->width += vscrollbar_requisition.width;
1276 }
1277
1278 if (scrolled_window->vscrollbar_policy == GTK_POLICY_NEVER)
1279 requisition->height += child_requisition.height;
1280 else
1281 {
1282 GtkWidgetAuxInfo *aux_info = _gtk_widget_get_aux_info (bin->child, FALSE);
1283
1284 if (aux_info && aux_info->height > 0)
1285 {
1286 requisition->height += aux_info->height;
1287 extra_height = -1;
1288 }
1289 else
1290 requisition->height += hscrollbar_requisition.height;
1291 }
1292 }
1293
1294 if (scrolled_window->hscrollbar_policy == GTK_POLICY_AUTOMATIC ||
1295 scrolled_window->hscrollbar_policy == GTK_POLICY_ALWAYS)
1296 {
1297 requisition->width = MAX (requisition->width, hscrollbar_requisition.width);
1298 if (!extra_height || scrolled_window->hscrollbar_policy == GTK_POLICY_ALWAYS)
1299 extra_height = scrollbar_spacing + hscrollbar_requisition.height;
1300 }
1301
1302 if (scrolled_window->vscrollbar_policy == GTK_POLICY_AUTOMATIC ||
1303 scrolled_window->vscrollbar_policy == GTK_POLICY_ALWAYS)
1304 {
1305 requisition->height = MAX (requisition->height, vscrollbar_requisition.height);
1306 if (!extra_height || scrolled_window->vscrollbar_policy == GTK_POLICY_ALWAYS)
1307 extra_width = scrollbar_spacing + vscrollbar_requisition.width;
1308 }
1309
1310 requisition->width += GTK_CONTAINER (widget)->border_width * 2 + MAX (0, extra_width);
1311 requisition->height += GTK_CONTAINER (widget)->border_width * 2 + MAX (0, extra_height);
1312
1313 if (scrolled_window->shadow_type != GTK_SHADOW_NONE)
1314 {
1315 requisition->width += 2 * widget->style->xthickness;
1316 requisition->height += 2 * widget->style->ythickness;
1317 }
1318 }
1319
1320 static void
gtk_scrolled_window_relative_allocation(GtkWidget * widget,GtkAllocation * allocation)1321 gtk_scrolled_window_relative_allocation (GtkWidget *widget,
1322 GtkAllocation *allocation)
1323 {
1324 GtkScrolledWindow *scrolled_window;
1325 GtkScrolledWindowPrivate *priv;
1326 gint scrollbar_spacing;
1327
1328 g_return_if_fail (widget != NULL);
1329 g_return_if_fail (allocation != NULL);
1330
1331 scrolled_window = GTK_SCROLLED_WINDOW (widget);
1332 scrollbar_spacing = _gtk_scrolled_window_get_scrollbar_spacing (scrolled_window);
1333
1334 priv = GTK_SCROLLED_WINDOW_GET_PRIVATE (scrolled_window);
1335
1336 allocation->x = GTK_CONTAINER (widget)->border_width;
1337 allocation->y = GTK_CONTAINER (widget)->border_width;
1338
1339 if (scrolled_window->shadow_type != GTK_SHADOW_NONE)
1340 {
1341 allocation->x += widget->style->xthickness;
1342 allocation->y += widget->style->ythickness;
1343 }
1344
1345 allocation->width = MAX (1, (gint)widget->allocation.width - allocation->x * 2);
1346 allocation->height = MAX (1, (gint)widget->allocation.height - allocation->y * 2);
1347
1348 if (scrolled_window->vscrollbar_visible)
1349 {
1350 GtkRequisition vscrollbar_requisition;
1351 gboolean is_rtl;
1352
1353 gtk_widget_get_child_requisition (scrolled_window->vscrollbar,
1354 &vscrollbar_requisition);
1355 is_rtl = gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL;
1356
1357 if ((!is_rtl &&
1358 (priv->real_window_placement == GTK_CORNER_TOP_RIGHT ||
1359 priv->real_window_placement == GTK_CORNER_BOTTOM_RIGHT)) ||
1360 (is_rtl &&
1361 (priv->real_window_placement == GTK_CORNER_TOP_LEFT ||
1362 priv->real_window_placement == GTK_CORNER_BOTTOM_LEFT)))
1363 allocation->x += (vscrollbar_requisition.width + scrollbar_spacing);
1364
1365 allocation->width = MAX (1, allocation->width - (vscrollbar_requisition.width + scrollbar_spacing));
1366 }
1367 if (scrolled_window->hscrollbar_visible)
1368 {
1369 GtkRequisition hscrollbar_requisition;
1370 gtk_widget_get_child_requisition (scrolled_window->hscrollbar,
1371 &hscrollbar_requisition);
1372
1373 if (priv->real_window_placement == GTK_CORNER_BOTTOM_LEFT ||
1374 priv->real_window_placement == GTK_CORNER_BOTTOM_RIGHT)
1375 allocation->y += (hscrollbar_requisition.height + scrollbar_spacing);
1376
1377 allocation->height = MAX (1, allocation->height - (hscrollbar_requisition.height + scrollbar_spacing));
1378 }
1379 }
1380
1381 static void
gtk_scrolled_window_size_allocate(GtkWidget * widget,GtkAllocation * allocation)1382 gtk_scrolled_window_size_allocate (GtkWidget *widget,
1383 GtkAllocation *allocation)
1384 {
1385 GtkScrolledWindow *scrolled_window;
1386 GtkScrolledWindowPrivate *priv;
1387 GtkBin *bin;
1388 GtkAllocation relative_allocation;
1389 GtkAllocation child_allocation;
1390 gboolean scrollbars_within_bevel;
1391 gint scrollbar_spacing;
1392
1393 g_return_if_fail (GTK_IS_SCROLLED_WINDOW (widget));
1394 g_return_if_fail (allocation != NULL);
1395
1396 scrolled_window = GTK_SCROLLED_WINDOW (widget);
1397 bin = GTK_BIN (scrolled_window);
1398
1399 scrollbar_spacing = _gtk_scrolled_window_get_scrollbar_spacing (scrolled_window);
1400 gtk_widget_style_get (widget, "scrollbars-within-bevel", &scrollbars_within_bevel, NULL);
1401
1402 priv = GTK_SCROLLED_WINDOW_GET_PRIVATE (scrolled_window);
1403
1404 widget->allocation = *allocation;
1405
1406 if (scrolled_window->hscrollbar_policy == GTK_POLICY_ALWAYS)
1407 scrolled_window->hscrollbar_visible = TRUE;
1408 else if (scrolled_window->hscrollbar_policy == GTK_POLICY_NEVER)
1409 scrolled_window->hscrollbar_visible = FALSE;
1410 if (scrolled_window->vscrollbar_policy == GTK_POLICY_ALWAYS)
1411 scrolled_window->vscrollbar_visible = TRUE;
1412 else if (scrolled_window->vscrollbar_policy == GTK_POLICY_NEVER)
1413 scrolled_window->vscrollbar_visible = FALSE;
1414
1415 if (bin->child && gtk_widget_get_visible (bin->child))
1416 {
1417 gboolean previous_hvis;
1418 gboolean previous_vvis;
1419 guint count = 0;
1420
1421 do
1422 {
1423 gtk_scrolled_window_relative_allocation (widget, &relative_allocation);
1424
1425 child_allocation.x = relative_allocation.x + allocation->x;
1426 child_allocation.y = relative_allocation.y + allocation->y;
1427 child_allocation.width = relative_allocation.width;
1428 child_allocation.height = relative_allocation.height;
1429
1430 previous_hvis = scrolled_window->hscrollbar_visible;
1431 previous_vvis = scrolled_window->vscrollbar_visible;
1432
1433 gtk_widget_size_allocate (bin->child, &child_allocation);
1434
1435 /* If, after the first iteration, the hscrollbar and the
1436 * vscrollbar flip visiblity, then we need both.
1437 */
1438 if (count &&
1439 previous_hvis != scrolled_window->hscrollbar_visible &&
1440 previous_vvis != scrolled_window->vscrollbar_visible)
1441 {
1442 scrolled_window->hscrollbar_visible = TRUE;
1443 scrolled_window->vscrollbar_visible = TRUE;
1444
1445 /* a new resize is already queued at this point,
1446 * so we will immediatedly get reinvoked
1447 */
1448 return;
1449 }
1450
1451 count++;
1452 }
1453 while (previous_hvis != scrolled_window->hscrollbar_visible ||
1454 previous_vvis != scrolled_window->vscrollbar_visible);
1455 }
1456 else
1457 {
1458 scrolled_window->hscrollbar_visible = scrolled_window->hscrollbar_policy == GTK_POLICY_ALWAYS;
1459 scrolled_window->vscrollbar_visible = scrolled_window->vscrollbar_policy == GTK_POLICY_ALWAYS;
1460 gtk_scrolled_window_relative_allocation (widget, &relative_allocation);
1461 }
1462
1463 if (scrolled_window->hscrollbar_visible)
1464 {
1465 GtkRequisition hscrollbar_requisition;
1466 gtk_widget_get_child_requisition (scrolled_window->hscrollbar,
1467 &hscrollbar_requisition);
1468
1469 if (!gtk_widget_get_visible (scrolled_window->hscrollbar))
1470 gtk_widget_show (scrolled_window->hscrollbar);
1471
1472 child_allocation.x = relative_allocation.x;
1473 if (priv->real_window_placement == GTK_CORNER_TOP_LEFT ||
1474 priv->real_window_placement == GTK_CORNER_TOP_RIGHT)
1475 child_allocation.y = (relative_allocation.y +
1476 relative_allocation.height +
1477 scrollbar_spacing +
1478 (scrolled_window->shadow_type == GTK_SHADOW_NONE ?
1479 0 : widget->style->ythickness));
1480 else
1481 child_allocation.y = GTK_CONTAINER (scrolled_window)->border_width;
1482
1483 child_allocation.width = relative_allocation.width;
1484 child_allocation.height = hscrollbar_requisition.height;
1485 child_allocation.x += allocation->x;
1486 child_allocation.y += allocation->y;
1487
1488 if (scrolled_window->shadow_type != GTK_SHADOW_NONE)
1489 {
1490 if (!scrollbars_within_bevel)
1491 {
1492 child_allocation.x -= widget->style->xthickness;
1493 child_allocation.width += 2 * widget->style->xthickness;
1494 }
1495 else if (GTK_CORNER_TOP_RIGHT == priv->real_window_placement ||
1496 GTK_CORNER_TOP_LEFT == priv->real_window_placement)
1497 {
1498 child_allocation.y -= widget->style->ythickness;
1499 }
1500 else
1501 {
1502 child_allocation.y += widget->style->ythickness;
1503 }
1504 }
1505
1506 gtk_widget_size_allocate (scrolled_window->hscrollbar, &child_allocation);
1507 }
1508 else if (gtk_widget_get_visible (scrolled_window->hscrollbar))
1509 gtk_widget_hide (scrolled_window->hscrollbar);
1510
1511 if (scrolled_window->vscrollbar_visible)
1512 {
1513 GtkRequisition vscrollbar_requisition;
1514 if (!gtk_widget_get_visible (scrolled_window->vscrollbar))
1515 gtk_widget_show (scrolled_window->vscrollbar);
1516
1517 gtk_widget_get_child_requisition (scrolled_window->vscrollbar,
1518 &vscrollbar_requisition);
1519
1520 if ((gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL &&
1521 (priv->real_window_placement == GTK_CORNER_TOP_RIGHT ||
1522 priv->real_window_placement == GTK_CORNER_BOTTOM_RIGHT)) ||
1523 (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR &&
1524 (priv->real_window_placement == GTK_CORNER_TOP_LEFT ||
1525 priv->real_window_placement == GTK_CORNER_BOTTOM_LEFT)))
1526 child_allocation.x = (relative_allocation.x +
1527 relative_allocation.width +
1528 scrollbar_spacing +
1529 (scrolled_window->shadow_type == GTK_SHADOW_NONE ?
1530 0 : widget->style->xthickness));
1531 else
1532 child_allocation.x = GTK_CONTAINER (scrolled_window)->border_width;
1533
1534 child_allocation.y = relative_allocation.y;
1535 child_allocation.width = vscrollbar_requisition.width;
1536 child_allocation.height = relative_allocation.height;
1537 child_allocation.x += allocation->x;
1538 child_allocation.y += allocation->y;
1539
1540 if (scrolled_window->shadow_type != GTK_SHADOW_NONE)
1541 {
1542 if (!scrollbars_within_bevel)
1543 {
1544 child_allocation.y -= widget->style->ythickness;
1545 child_allocation.height += 2 * widget->style->ythickness;
1546 }
1547 else if (GTK_CORNER_BOTTOM_LEFT == priv->real_window_placement ||
1548 GTK_CORNER_TOP_LEFT == priv->real_window_placement)
1549 {
1550 child_allocation.x -= widget->style->xthickness;
1551 }
1552 else
1553 {
1554 child_allocation.x += widget->style->xthickness;
1555 }
1556 }
1557
1558 gtk_widget_size_allocate (scrolled_window->vscrollbar, &child_allocation);
1559 }
1560 else if (gtk_widget_get_visible (scrolled_window->vscrollbar))
1561 gtk_widget_hide (scrolled_window->vscrollbar);
1562 }
1563
1564 static gboolean
gtk_scrolled_window_scroll_event(GtkWidget * widget,GdkEventScroll * event)1565 gtk_scrolled_window_scroll_event (GtkWidget *widget,
1566 GdkEventScroll *event)
1567 {
1568 GtkWidget *range;
1569
1570 g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (widget), FALSE);
1571 g_return_val_if_fail (event != NULL, FALSE);
1572
1573 if (event->direction == GDK_SCROLL_UP || event->direction == GDK_SCROLL_DOWN)
1574 range = GTK_SCROLLED_WINDOW (widget)->vscrollbar;
1575 else
1576 range = GTK_SCROLLED_WINDOW (widget)->hscrollbar;
1577
1578 if (range && gtk_widget_get_visible (range))
1579 {
1580 GtkAdjustment *adj = GTK_RANGE (range)->adjustment;
1581 gdouble delta, new_value;
1582
1583 delta = _gtk_range_get_wheel_delta (GTK_RANGE (range), event->direction);
1584
1585 new_value = CLAMP (adj->value + delta, adj->lower, adj->upper - adj->page_size);
1586
1587 gtk_adjustment_set_value (adj, new_value);
1588
1589 return TRUE;
1590 }
1591
1592 return FALSE;
1593 }
1594
1595 static gboolean
gtk_scrolled_window_focus(GtkWidget * widget,GtkDirectionType direction)1596 gtk_scrolled_window_focus (GtkWidget *widget,
1597 GtkDirectionType direction)
1598 {
1599 GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (widget);
1600 gboolean had_focus_child = GTK_CONTAINER (widget)->focus_child != NULL;
1601
1602 if (scrolled_window->focus_out)
1603 {
1604 scrolled_window->focus_out = FALSE; /* Clear this to catch the wrap-around case */
1605 return FALSE;
1606 }
1607
1608 if (gtk_widget_is_focus (widget))
1609 return FALSE;
1610
1611 /* We only put the scrolled window itself in the focus chain if it
1612 * isn't possible to focus any children.
1613 */
1614 if (GTK_BIN (widget)->child)
1615 {
1616 if (gtk_widget_child_focus (GTK_BIN (widget)->child, direction))
1617 return TRUE;
1618 }
1619
1620 if (!had_focus_child && gtk_widget_get_can_focus (widget))
1621 {
1622 gtk_widget_grab_focus (widget);
1623 return TRUE;
1624 }
1625 else
1626 return FALSE;
1627 }
1628
1629 static void
gtk_scrolled_window_adjustment_changed(GtkAdjustment * adjustment,gpointer data)1630 gtk_scrolled_window_adjustment_changed (GtkAdjustment *adjustment,
1631 gpointer data)
1632 {
1633 GtkScrolledWindow *scrolled_win;
1634
1635 g_return_if_fail (adjustment != NULL);
1636 g_return_if_fail (data != NULL);
1637
1638 scrolled_win = GTK_SCROLLED_WINDOW (data);
1639
1640 if (scrolled_win->hscrollbar &&
1641 adjustment == gtk_range_get_adjustment (GTK_RANGE (scrolled_win->hscrollbar)))
1642 {
1643 if (scrolled_win->hscrollbar_policy == GTK_POLICY_AUTOMATIC)
1644 {
1645 gboolean visible;
1646
1647 visible = scrolled_win->hscrollbar_visible;
1648 scrolled_win->hscrollbar_visible = (adjustment->upper - adjustment->lower >
1649 adjustment->page_size);
1650 if (scrolled_win->hscrollbar_visible != visible)
1651 gtk_widget_queue_resize (GTK_WIDGET (scrolled_win));
1652 }
1653 }
1654 else if (scrolled_win->vscrollbar &&
1655 adjustment == gtk_range_get_adjustment (GTK_RANGE (scrolled_win->vscrollbar)))
1656 {
1657 if (scrolled_win->vscrollbar_policy == GTK_POLICY_AUTOMATIC)
1658 {
1659 gboolean visible;
1660
1661 visible = scrolled_win->vscrollbar_visible;
1662 scrolled_win->vscrollbar_visible = (adjustment->upper - adjustment->lower >
1663 adjustment->page_size);
1664 if (scrolled_win->vscrollbar_visible != visible)
1665 gtk_widget_queue_resize (GTK_WIDGET (scrolled_win));
1666 }
1667 }
1668 }
1669
1670 static void
gtk_scrolled_window_add(GtkContainer * container,GtkWidget * child)1671 gtk_scrolled_window_add (GtkContainer *container,
1672 GtkWidget *child)
1673 {
1674 GtkScrolledWindow *scrolled_window;
1675 GtkBin *bin;
1676
1677 bin = GTK_BIN (container);
1678 g_return_if_fail (bin->child == NULL);
1679
1680 scrolled_window = GTK_SCROLLED_WINDOW (container);
1681
1682 bin->child = child;
1683 gtk_widget_set_parent (child, GTK_WIDGET (bin));
1684
1685 /* this is a temporary message */
1686 if (!gtk_widget_set_scroll_adjustments (child,
1687 gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar)),
1688 gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar))))
1689 g_warning ("gtk_scrolled_window_add(): cannot add non scrollable widget "
1690 "use gtk_scrolled_window_add_with_viewport() instead");
1691 }
1692
1693 static void
gtk_scrolled_window_remove(GtkContainer * container,GtkWidget * child)1694 gtk_scrolled_window_remove (GtkContainer *container,
1695 GtkWidget *child)
1696 {
1697 g_return_if_fail (GTK_IS_SCROLLED_WINDOW (container));
1698 g_return_if_fail (child != NULL);
1699 g_return_if_fail (GTK_BIN (container)->child == child);
1700
1701 gtk_widget_set_scroll_adjustments (child, NULL, NULL);
1702
1703 /* chain parent class handler to remove child */
1704 GTK_CONTAINER_CLASS (gtk_scrolled_window_parent_class)->remove (container, child);
1705 }
1706
1707 /**
1708 * gtk_scrolled_window_add_with_viewport:
1709 * @scrolled_window: a #GtkScrolledWindow
1710 * @child: the widget you want to scroll
1711 *
1712 * Used to add children without native scrolling capabilities. This
1713 * is simply a convenience function; it is equivalent to adding the
1714 * unscrollable child to a viewport, then adding the viewport to the
1715 * scrolled window. If a child has native scrolling, use
1716 * gtk_container_add() instead of this function.
1717 *
1718 * The viewport scrolls the child by moving its #GdkWindow, and takes
1719 * the size of the child to be the size of its toplevel #GdkWindow.
1720 * This will be very wrong for most widgets that support native scrolling;
1721 * for example, if you add a widget such as #GtkTreeView with a viewport,
1722 * the whole widget will scroll, including the column headings. Thus,
1723 * widgets with native scrolling support should not be used with the
1724 * #GtkViewport proxy.
1725 *
1726 * A widget supports scrolling natively if the
1727 * set_scroll_adjustments_signal field in #GtkWidgetClass is non-zero,
1728 * i.e. has been filled in with a valid signal identifier.
1729 */
1730 void
gtk_scrolled_window_add_with_viewport(GtkScrolledWindow * scrolled_window,GtkWidget * child)1731 gtk_scrolled_window_add_with_viewport (GtkScrolledWindow *scrolled_window,
1732 GtkWidget *child)
1733 {
1734 GtkBin *bin;
1735 GtkWidget *viewport;
1736
1737 g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
1738 g_return_if_fail (GTK_IS_WIDGET (child));
1739 g_return_if_fail (child->parent == NULL);
1740
1741 bin = GTK_BIN (scrolled_window);
1742
1743 if (bin->child != NULL)
1744 {
1745 g_return_if_fail (GTK_IS_VIEWPORT (bin->child));
1746 g_return_if_fail (GTK_BIN (bin->child)->child == NULL);
1747
1748 viewport = bin->child;
1749 }
1750 else
1751 {
1752 viewport =
1753 gtk_viewport_new (gtk_scrolled_window_get_hadjustment (scrolled_window),
1754 gtk_scrolled_window_get_vadjustment (scrolled_window));
1755 gtk_container_add (GTK_CONTAINER (scrolled_window), viewport);
1756 }
1757
1758 gtk_widget_show (viewport);
1759 gtk_container_add (GTK_CONTAINER (viewport), child);
1760 }
1761
1762 /*
1763 * _gtk_scrolled_window_get_spacing:
1764 * @scrolled_window: a scrolled window
1765 *
1766 * Gets the spacing between the scrolled window's scrollbars and
1767 * the scrolled widget. Used by GtkCombo
1768 *
1769 * Return value: the spacing, in pixels.
1770 */
1771 gint
_gtk_scrolled_window_get_scrollbar_spacing(GtkScrolledWindow * scrolled_window)1772 _gtk_scrolled_window_get_scrollbar_spacing (GtkScrolledWindow *scrolled_window)
1773 {
1774 GtkScrolledWindowClass *class;
1775
1776 g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), 0);
1777
1778 class = GTK_SCROLLED_WINDOW_GET_CLASS (scrolled_window);
1779
1780 if (class->scrollbar_spacing >= 0)
1781 return class->scrollbar_spacing;
1782 else
1783 {
1784 gint scrollbar_spacing;
1785
1786 gtk_widget_style_get (GTK_WIDGET (scrolled_window),
1787 "scrollbar-spacing", &scrollbar_spacing,
1788 NULL);
1789
1790 return scrollbar_spacing;
1791 }
1792 }
1793
1794 #define __GTK_SCROLLED_WINDOW_C__
1795 #include "gtkaliasdef.c"
1796