[mono-project.git] / bockbuild / mac-sdk / patches / gtk / 0011-scrolledwindow-Kinetic-scrolling-support.patch
| blob | 0a27ac38a7f6431eec34fc359a6f205cace53251 |
1 From 5001b3d9a9b6445ac199156c0f91f28c2112e262 Mon Sep 17 00:00:00 2001
2 From: Carlos Garcia Campos <cgarcia@igalia.com>
3 Date: Fri, 11 Feb 2011 13:43:56 +0100
4 Subject: [PATCH 11/68] scrolledwindow: Kinetic scrolling support
6 If the scrolling doesn't start after a long press, the scrolling is
7 cancelled and events are handled by child widgets normally.
9 When clicked again close to the previous button press location
10 (assuming it had ~0 movement), the scrolled window will allow
11 the child to handle the events immediately.
13 This is so the user doesn't have to wait to the press-and-hold
14 timeout in order to operate on the scrolledwindow child.
16 The innermost scrolled window always gets to capture the events, all
17 scrolled windows above it just let the event go through. Ideally
18 reaching a limit on the innermost scrolled window would propagate
19 the dragging up the hierarchy in order to keep following the touch
20 coords, although that'd involve rather evil hacks just to cater
21 for broken UIs.
23 Conflicts:
25 docs/reference/gtk/gtk3-sections.txt
26 gtk/gtk.symbols
27 gtk/gtkscrolledwindow.c
28 gtk/gtkscrolledwindow.h
29 ---
30 gtk/gtk.symbols | 4 +
31 gtk/gtkscrolledwindow.c | 1061 ++++++++++++++++++++++++++++++++++++++++++++++-
32 gtk/gtkscrolledwindow.h | 8 +
33 3 files changed, 1058 insertions(+), 15 deletions(-)
35 diff --git a/gtk/gtk.symbols b/gtk/gtk.symbols
36 index 6d5d5b6..d13ca41 100644
37 --- a/gtk/gtk.symbols
38 +++ b/gtk/gtk.symbols
39 @@ -3730,6 +3730,8 @@ gtk_scrollbar_get_type G_GNUC_CONST
40 gtk_scrolled_window_add_with_viewport
41 gtk_scrolled_window_get_hadjustment
42 gtk_scrolled_window_get_hscrollbar
43 +gtk_scrolled_window_get_kinetic_scrolling
44 +gtk_scrolled_window_get_capture_button_press
45 gtk_scrolled_window_get_placement
46 gtk_scrolled_window_get_policy
47 gtk_scrolled_window_get_shadow_type
48 @@ -3738,6 +3740,8 @@ gtk_scrolled_window_get_vadjustment
49 gtk_scrolled_window_get_vscrollbar
50 gtk_scrolled_window_new
51 gtk_scrolled_window_set_hadjustment
52 +gtk_scrolled_window_set_kinetic_scrolling
53 +gtk_scrolled_window_set_capture_button_press
54 gtk_scrolled_window_set_placement
55 gtk_scrolled_window_set_policy
56 gtk_scrolled_window_set_shadow_type
57 diff --git a/gtk/gtkscrolledwindow.c b/gtk/gtkscrolledwindow.c
58 index 2288b2f..694d20a 100644
59 --- a/gtk/gtkscrolledwindow.c
60 +++ b/gtk/gtkscrolledwindow.c
61 @@ -33,6 +33,8 @@
62 #include "gtkwindow.h"
63 #include "gtkprivate.h"
64 #include "gtkintl.h"
65 +#include "gtkmain.h"
66 +#include "gtkdnd.h"
67 #include "gtkalias.h"
70 @@ -72,14 +74,58 @@
71 */
73 #define DEFAULT_SCROLLBAR_SPACING 3
74 +#define TOUCH_BYPASS_CAPTURED_THRESHOLD 30
75 +
76 +/* Kinetic scrolling */
77 +#define FRAME_INTERVAL (1000 / 60)
78 +#define MAX_OVERSHOOT_DISTANCE 50
79 +#define FRICTION_DECELERATION 0.003
80 +#define OVERSHOOT_INVERSE_ACCELERATION 0.003
81 +#define RELEASE_EVENT_TIMEOUT 1000
83 typedef struct {
84 - gboolean window_placement_set;
85 - GtkCornerType real_window_placement;
86 + gboolean window_placement_set;
87 + GtkCornerType real_window_placement;
88 +
89 + /* Kinetic scrolling */
90 + GdkEvent *button_press_event;
91 + GdkWindow *overshoot_window;
92 + guint pointer_grabbed : 1;
93 + guint kinetic_scrolling : 1;
94 + guint capture_button_press : 1;
95 + guint in_drag : 1;
96 + guint last_button_event_valid : 1;
97 +
98 + guint release_timeout_id;
99 + guint deceleration_id;
100 +
101 + gdouble last_button_event_x_root;
102 + gdouble last_button_event_y_root;
103 +
104 + gdouble last_motion_event_x_root;
105 + gdouble last_motion_event_y_root;
106 + guint32 last_motion_event_time;
107 +
108 + gdouble x_velocity;
109 + gdouble y_velocity;
110 +
111 + gdouble unclamped_hadj_value;
112 + gdouble unclamped_vadj_value;
113 } GtkScrolledWindowPrivate;
115 #define GTK_SCROLLED_WINDOW_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_SCROLLED_WINDOW, GtkScrolledWindowPrivate))
117 +typedef struct
118 +{
119 + GtkScrolledWindow *scrolled_window;
120 + gint64 last_deceleration_time;
121 +
122 + gdouble x_velocity;
123 + gdouble y_velocity;
124 + gdouble vel_cosine;
125 + gdouble vel_sine;
126 +} KineticScrollData;
127 +
128 enum {
129 PROP_0,
130 PROP_HADJUSTMENT,
131 @@ -88,7 +134,8 @@ enum {
132 PROP_VSCROLLBAR_POLICY,
133 PROP_WINDOW_PLACEMENT,
134 PROP_WINDOW_PLACEMENT_SET,
135 - PROP_SHADOW_TYPE
136 + PROP_SHADOW_TYPE,
137 + PROP_KINETIC_SCROLLING
138 };
140 /* Signals */
141 @@ -119,6 +166,8 @@ static void gtk_scrolled_window_size_allocate (GtkWidget *widge
142 GtkAllocation *allocation);
143 static gboolean gtk_scrolled_window_scroll_event (GtkWidget *widget,
144 GdkEventScroll *event);
145 +static gboolean gtk_scrolled_window_captured_event (GtkWidget *widget,
146 + GdkEvent *event);
147 static gboolean gtk_scrolled_window_focus (GtkWidget *widget,
148 GtkDirectionType direction);
149 static void gtk_scrolled_window_add (GtkContainer *container,
150 @@ -139,9 +188,24 @@ static void gtk_scrolled_window_relative_allocation(GtkWidget *widge
151 GtkAllocation *allocation);
152 static void gtk_scrolled_window_adjustment_changed (GtkAdjustment *adjustment,
153 gpointer data);
154 +static void gtk_scrolled_window_adjustment_value_changed (GtkAdjustment *adjustment,
155 + gpointer data);
157 static void gtk_scrolled_window_update_real_placement (GtkScrolledWindow *scrolled_window);
159 +static void gtk_scrolled_window_realize (GtkWidget *widget);
160 +static void gtk_scrolled_window_unrealize (GtkWidget *widget);
161 +static void gtk_scrolled_window_map (GtkWidget *widget);
162 +static void gtk_scrolled_window_unmap (GtkWidget *widget);
163 +static void gtk_scrolled_window_grab_notify (GtkWidget *widget,
164 + gboolean was_grabbed);
165 +
166 +static gboolean _gtk_scrolled_window_set_adjustment_value (GtkScrolledWindow *scrolled_window,
167 + GtkAdjustment *adjustment,
168 + gdouble value,
169 + gboolean allow_overshooting,
170 + gboolean snap_to_border);
171 +
172 static guint signals[LAST_SIGNAL] = {0};
174 G_DEFINE_TYPE (GtkScrolledWindow, gtk_scrolled_window, GTK_TYPE_BIN)
175 @@ -202,6 +266,11 @@ gtk_scrolled_window_class_init (GtkScrolledWindowClass *class)
176 widget_class->size_allocate = gtk_scrolled_window_size_allocate;
177 widget_class->scroll_event = gtk_scrolled_window_scroll_event;
178 widget_class->focus = gtk_scrolled_window_focus;
179 + widget_class->realize = gtk_scrolled_window_realize;
180 + widget_class->unrealize = gtk_scrolled_window_unrealize;
181 + widget_class->map = gtk_scrolled_window_map;
182 + widget_class->unmap = gtk_scrolled_window_unmap;
183 + widget_class->grab_notify = gtk_scrolled_window_grab_notify;
185 container_class->add = gtk_scrolled_window_add;
186 container_class->remove = gtk_scrolled_window_remove;
187 @@ -301,6 +370,22 @@ gtk_scrolled_window_class_init (GtkScrolledWindowClass *class)
188 GTK_PARAM_READABLE));
190 /**
191 + * GtkScrolledWindow:kinetic-scrolling:
192 + *
193 + * The kinetic scrolling behavior flags.
194 + *
195 + * Since: X.XX
196 + */
197 + g_object_class_install_property (gobject_class,
198 + PROP_KINETIC_SCROLLING,
199 + g_param_spec_boolean ("kinetic-scrolling",
200 + P_("Kinetic Scrolling"),
201 + P_("Kinetic scrolling mode."),
202 + TRUE,
203 + GTK_PARAM_READABLE |
204 + GTK_PARAM_WRITABLE));
205 +
206 + /**
207 * GtkScrolledWindow::scroll-child:
208 * @scrolled_window: a #GtkScrolledWindow
209 * @scroll: a #GtkScrollType describing how much to scroll
210 @@ -371,6 +456,12 @@ gtk_scrolled_window_init (GtkScrolledWindow *scrolled_window)
211 scrolled_window->focus_out = FALSE;
212 scrolled_window->window_placement = GTK_CORNER_TOP_LEFT;
213 gtk_scrolled_window_update_real_placement (scrolled_window);
214 +
215 + if (g_getenv ("GTK2_KINETIC_SCROLLING"))
216 + {
217 + gtk_scrolled_window_set_kinetic_scrolling (scrolled_window, TRUE);
218 + gtk_scrolled_window_set_capture_button_press (scrolled_window, TRUE);
219 + }
220 }
222 /**
223 @@ -458,8 +549,13 @@ gtk_scrolled_window_set_hadjustment (GtkScrolledWindow *scrolled_window,
224 "changed",
225 G_CALLBACK (gtk_scrolled_window_adjustment_changed),
226 scrolled_window);
227 + g_signal_connect (hadjustment,
228 + "value-changed",
229 + G_CALLBACK (gtk_scrolled_window_adjustment_value_changed),
230 + scrolled_window);
231 gtk_scrolled_window_adjustment_changed (hadjustment, scrolled_window);
232 -
233 + gtk_scrolled_window_adjustment_value_changed (hadjustment, scrolled_window);
234 +
235 if (bin->child)
236 gtk_widget_set_scroll_adjustments (bin->child,
237 gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar)),
238 @@ -519,7 +615,12 @@ gtk_scrolled_window_set_vadjustment (GtkScrolledWindow *scrolled_window,
239 "changed",
240 G_CALLBACK (gtk_scrolled_window_adjustment_changed),
241 scrolled_window);
242 + g_signal_connect (vadjustment,
243 + "value-changed",
244 + G_CALLBACK (gtk_scrolled_window_adjustment_value_changed),
245 + scrolled_window);
246 gtk_scrolled_window_adjustment_changed (vadjustment, scrolled_window);
247 + gtk_scrolled_window_adjustment_value_changed (vadjustment, scrolled_window);
249 if (bin->child)
250 gtk_widget_set_scroll_adjustments (bin->child,
251 @@ -842,10 +943,135 @@ gtk_scrolled_window_get_shadow_type (GtkScrolledWindow *scrolled_window)
252 return scrolled_window->shadow_type;
253 }
255 +/**
256 + * gtk_scrolled_window_set_kinetic_scrolling:
257 + * @scrolled_window: a #GtkScrolledWindow
258 + * @kinetic_scrolling: %TRUE to enable kinetic scrolling
259 + *
260 + * Turns kinetic scrolling on or off.
261 + * Kinetic scrolling only applies to devices with source
262 + * %GDK_SOURCE_TOUCHSCREEN.
263 + *
264 + * Since: X.XX
265 + **/
266 +void
267 +gtk_scrolled_window_set_kinetic_scrolling (GtkScrolledWindow *scrolled_window,
268 + gboolean kinetic_scrolling)
269 +{
270 + GtkScrolledWindowPrivate *priv;
271 +
272 + g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
273 +
274 + priv = GTK_SCROLLED_WINDOW_GET_PRIVATE (scrolled_window);
275 +
276 + if (priv->kinetic_scrolling == kinetic_scrolling)
277 + return;
278 +
279 + priv->kinetic_scrolling = kinetic_scrolling;
280 + if (priv->kinetic_scrolling)
281 + {
282 + _gtk_widget_set_captured_event_handler (GTK_WIDGET (scrolled_window),
283 + gtk_scrolled_window_captured_event);
284 + }
285 + else
286 + {
287 + _gtk_widget_set_captured_event_handler (GTK_WIDGET (scrolled_window), NULL);
288 + if (priv->release_timeout_id)
289 + {
290 + g_source_remove (priv->release_timeout_id);
291 + priv->release_timeout_id = 0;
292 + }
293 + if (priv->deceleration_id)
294 + {
295 + g_source_remove (priv->deceleration_id);
296 + priv->deceleration_id = 0;
297 + }
298 + }
299 + g_object_notify (G_OBJECT (scrolled_window), "kinetic-scrolling");
300 +}
301 +
302 +/**
303 + * gtk_scrolled_window_get_kinetic_scrolling:
304 + * @scrolled_window: a #GtkScrolledWindow
305 + *
306 + * Returns the specified kinetic scrolling behavior.
307 + *
308 + * Return value: the scrolling behavior flags.
309 + *
310 + * Since: X.XX
311 + */
312 +gboolean
313 +gtk_scrolled_window_get_kinetic_scrolling (GtkScrolledWindow *scrolled_window)
314 +{
315 + GtkScrolledWindowPrivate *priv;
316 +
317 + g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), FALSE);
318 +
319 + priv = GTK_SCROLLED_WINDOW_GET_PRIVATE (scrolled_window);
320 +
321 + return priv->kinetic_scrolling;
322 +}
323 +
324 +/**
325 + * gtk_scrolled_window_set_capture_button_press:
326 + * @scrolled_window: a #GtkScrolledWindow
327 + * @capture_button_press: %TRUE to capture button presses
328 + *
329 + * Changes the behaviour of @scrolled_window wrt. to the initial
330 + * event that possibly starts kinetic scrolling. When @capture_button_press
331 + * is set to %TRUE, the event is captured by the scrolled window, and
332 + * then later replayed if it is meant to go to the child widget.
333 + *
334 + * This should be enabled if any child widgets perform non-reversible
335 + * actions on #GtkWidget::button-press-event. If they don't, and handle
336 + * additionally handle #GtkWidget::grab-broken-event, it might be better
337 + * to set @capture_button_press to %FALSE.
338 + *
339 + * This setting only has an effect if kinetic scrolling is enabled.
340 + *
341 + * Since: X.XX
342 + */
343 +void
344 +gtk_scrolled_window_set_capture_button_press (GtkScrolledWindow *scrolled_window,
345 + gboolean capture_button_press)
346 +{
347 + GtkScrolledWindowPrivate *priv;
348 +
349 + g_return_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window));
350 +
351 + priv = GTK_SCROLLED_WINDOW_GET_PRIVATE (scrolled_window);
352 + priv->capture_button_press = capture_button_press;
353 +}
354 +
355 +/**
356 + * gtk_scrolled_window_get_capture_button_press:
357 + * @scrolled_window: a #GtkScrolledWindow
358 + *
359 + * Return whether button presses are captured during kinetic
360 + * scrolling. See gtk_scrolled_window_set_capture_button_press().
361 + *
362 + * Returns: %TRUE if button presses are captured during kinetic scrolling
363 + *
364 + * Since: X.XX
365 + */
366 +gboolean
367 +gtk_scrolled_window_get_capture_button_press (GtkScrolledWindow *scrolled_window)
368 +{
369 + GtkScrolledWindowPrivate *priv;
370 +
371 + g_return_val_if_fail (GTK_IS_SCROLLED_WINDOW (scrolled_window), FALSE);
372 +
373 + priv = GTK_SCROLLED_WINDOW_GET_PRIVATE (scrolled_window);
374 +
375 + return priv->capture_button_press;
376 +}
377 +
378 +
379 static void
380 gtk_scrolled_window_destroy (GtkObject *object)
381 {
382 GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (object);
383 + GtkScrolledWindowPrivate *priv = GTK_SCROLLED_WINDOW_GET_PRIVATE (scrolled_window);
385 if (scrolled_window->hscrollbar)
386 {
387 @@ -868,6 +1094,23 @@ gtk_scrolled_window_destroy (GtkObject *object)
388 scrolled_window->vscrollbar = NULL;
389 }
391 + if (priv->release_timeout_id)
392 + {
393 + g_source_remove (priv->release_timeout_id);
394 + priv->release_timeout_id = 0;
395 + }
396 + if (priv->deceleration_id)
397 + {
398 + g_source_remove (priv->deceleration_id);
399 + priv->deceleration_id = 0;
400 + }
401 +
402 + if (priv->button_press_event)
403 + {
404 + gdk_event_free (priv->button_press_event);
405 + priv->button_press_event = NULL;
406 + }
407 +
408 GTK_OBJECT_CLASS (gtk_scrolled_window_parent_class)->destroy (object);
409 }
411 @@ -912,6 +1155,10 @@ gtk_scrolled_window_set_property (GObject *object,
412 gtk_scrolled_window_set_shadow_type (scrolled_window,
413 g_value_get_enum (value));
414 break;
415 + case PROP_KINETIC_SCROLLING:
416 + gtk_scrolled_window_set_kinetic_scrolling (scrolled_window,
417 + g_value_get_boolean (value));
418 + break;
419 default:
420 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
421 break;
422 @@ -952,6 +1199,9 @@ gtk_scrolled_window_get_property (GObject *object,
423 case PROP_SHADOW_TYPE:
424 g_value_set_enum (value, scrolled_window->shadow_type);
425 break;
426 + case PROP_KINETIC_SCROLLING:
427 + g_value_set_boolean (value, priv->kinetic_scrolling);
428 + break;
429 default:
430 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
431 break;
432 @@ -1019,10 +1269,10 @@ gtk_scrolled_window_paint (GtkWidget *widget,
433 GdkRectangle *area)
434 {
435 GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (widget);
436 + GtkAllocation relative_allocation;
438 if (scrolled_window->shadow_type != GTK_SHADOW_NONE)
439 {
440 - GtkAllocation relative_allocation;
441 gboolean scrollbars_within_bevel;
443 gtk_widget_style_get (widget, "scrollbars-within-bevel", &scrollbars_within_bevel, NULL);
444 @@ -1378,6 +1628,111 @@ gtk_scrolled_window_relative_allocation (GtkWidget *widget,
445 }
446 }
448 +static gboolean
449 +_gtk_scrolled_window_get_overshoot (GtkScrolledWindow *scrolled_window,
450 + gint *overshoot_x,
451 + gint *overshoot_y)
452 +{
453 + GtkScrolledWindowPrivate *priv;
454 + GtkAdjustment *vadjustment, *hadjustment;
455 + gdouble lower, upper, x, y;
456 +
457 + priv = GTK_SCROLLED_WINDOW_GET_PRIVATE (scrolled_window);
458 +
459 + /* Vertical overshoot */
460 + vadjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar));
461 + lower = gtk_adjustment_get_lower (vadjustment);
462 + upper = gtk_adjustment_get_upper (vadjustment) -
463 + gtk_adjustment_get_page_size (vadjustment);
464 +
465 + if (priv->unclamped_vadj_value < lower)
466 + y = priv->unclamped_vadj_value - lower;
467 + else if (priv->unclamped_vadj_value > upper)
468 + y = priv->unclamped_vadj_value - upper;
469 + else
470 + y = 0;
471 +
472 + /* Horizontal overshoot */
473 + hadjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar));
474 + lower = gtk_adjustment_get_lower (hadjustment);
475 + upper = gtk_adjustment_get_upper (hadjustment) -
476 + gtk_adjustment_get_page_size (hadjustment);
477 +
478 + if (priv->unclamped_hadj_value < lower)
479 + x = priv->unclamped_hadj_value - lower;
480 + else if (priv->unclamped_hadj_value > upper)
481 + x = priv->unclamped_hadj_value - upper;
482 + else
483 + x = 0;
484 +
485 + if (overshoot_x)
486 + *overshoot_x = x;
487 +
488 + if (overshoot_y)
489 + *overshoot_y = y;
490 +
491 + return (x != 0 || y != 0);
492 +}
493 +
494 +static void
495 +_gtk_scrolled_window_allocate_overshoot_window (GtkScrolledWindow *scrolled_window)
496 +{
497 + GtkAllocation window_allocation, relative_allocation, allocation;
498 + GtkScrolledWindowPrivate *priv;
499 + GtkWidget *widget = GTK_WIDGET (scrolled_window);
500 + gint overshoot_x, overshoot_y;
501 +
502 + if (!gtk_widget_get_realized (widget))
503 + return;
504 +
505 + priv = GTK_SCROLLED_WINDOW_GET_PRIVATE (scrolled_window);
506 +
507 + gtk_widget_get_allocation (widget, &allocation);
508 + gtk_scrolled_window_relative_allocation (widget, &relative_allocation);
509 + _gtk_scrolled_window_get_overshoot (scrolled_window,
510 + &overshoot_x, &overshoot_y);
511 +
512 + window_allocation = relative_allocation;
513 + window_allocation.x += allocation.x;
514 + window_allocation.y += allocation.y;
515 +
516 + if (overshoot_x < 0)
517 + window_allocation.x += -overshoot_x;
518 +
519 + if (overshoot_y < 0)
520 + window_allocation.y += -overshoot_y;
521 +
522 + window_allocation.width -= ABS (overshoot_x);
523 + window_allocation.height -= ABS (overshoot_y);
524 +
525 + gdk_window_move_resize (priv->overshoot_window,
526 + window_allocation.x, window_allocation.y,
527 + window_allocation.width, window_allocation.height);
528 +}
529 +
530 +static void
531 +gtk_scrolled_window_allocate_child (GtkScrolledWindow *swindow,
532 + GtkAllocation *relative_allocation)
533 +{
534 + GtkWidget *widget = GTK_WIDGET (swindow), *child;
535 + GtkAllocation allocation;
536 + GtkAllocation child_allocation;
537 + gint overshoot_x, overshoot_y;
538 +
539 + child = gtk_bin_get_child (GTK_BIN (widget));
540 +
541 + gtk_widget_get_allocation (widget, &allocation);
542 +
543 + gtk_scrolled_window_relative_allocation (widget, relative_allocation);
544 + _gtk_scrolled_window_get_overshoot (swindow, &overshoot_x, &overshoot_y);
545 +
546 + child_allocation.x = child_allocation.y = 0;
547 + child_allocation.width = relative_allocation->width;
548 + child_allocation.height = relative_allocation->height;
549 +
550 + gtk_widget_size_allocate (child, &child_allocation);
551 +}
552 +
553 static void
554 gtk_scrolled_window_size_allocate (GtkWidget *widget,
555 GtkAllocation *allocation)
556 @@ -1389,7 +1744,7 @@ gtk_scrolled_window_size_allocate (GtkWidget *widget,
557 GtkAllocation child_allocation;
558 gboolean scrollbars_within_bevel;
559 gint scrollbar_spacing;
560 -
561 +
562 g_return_if_fail (GTK_IS_SCROLLED_WINDOW (widget));
563 g_return_if_fail (allocation != NULL);
565 @@ -1420,17 +1775,9 @@ gtk_scrolled_window_size_allocate (GtkWidget *widget,
567 do
568 {
569 - gtk_scrolled_window_relative_allocation (widget, &relative_allocation);
570 -
571 - child_allocation.x = relative_allocation.x + allocation->x;
572 - child_allocation.y = relative_allocation.y + allocation->y;
573 - child_allocation.width = relative_allocation.width;
574 - child_allocation.height = relative_allocation.height;
575 -
576 previous_hvis = scrolled_window->hscrollbar_visible;
577 previous_vvis = scrolled_window->vscrollbar_visible;
578 -
579 - gtk_widget_size_allocate (bin->child, &child_allocation);
580 + gtk_scrolled_window_allocate_child (scrolled_window, &relative_allocation);
582 /* If, after the first iteration, the hscrollbar and the
583 * vscrollbar flip visiblity, then we need both.
584 @@ -1442,6 +1789,8 @@ gtk_scrolled_window_size_allocate (GtkWidget *widget,
585 scrolled_window->hscrollbar_visible = TRUE;
586 scrolled_window->vscrollbar_visible = TRUE;
588 + gtk_scrolled_window_allocate_child (scrolled_window, &relative_allocation);
589 +
590 /* a new resize is already queued at this point,
591 * so we will immediatedly get reinvoked
592 */
593 @@ -1559,6 +1908,8 @@ gtk_scrolled_window_size_allocate (GtkWidget *widget,
594 }
595 else if (gtk_widget_get_visible (scrolled_window->vscrollbar))
596 gtk_widget_hide (scrolled_window->vscrollbar);
597 +
598 + _gtk_scrolled_window_allocate_overshoot_window (scrolled_window);
599 }
601 static gboolean
602 @@ -1639,6 +1990,555 @@ gtk_scrolled_window_scroll_event (GtkWidget *widget,
603 }
605 static gboolean
606 +_gtk_scrolled_window_set_adjustment_value (GtkScrolledWindow *scrolled_window,
607 + GtkAdjustment *adjustment,
608 + gdouble value,
609 + gboolean allow_overshooting,
610 + gboolean snap_to_border)
611 +{
612 + GtkScrolledWindowPrivate *priv;
613 + gdouble lower, upper, *prev_value;
614 +
615 + priv = GTK_SCROLLED_WINDOW_GET_PRIVATE (scrolled_window);
616 +
617 + lower = gtk_adjustment_get_lower (adjustment);
618 + upper = gtk_adjustment_get_upper (adjustment) -
619 + gtk_adjustment_get_page_size (adjustment);
620 +
621 + if (adjustment == gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar)))
622 + prev_value = &priv->unclamped_hadj_value;
623 + else if (adjustment == gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar)))
624 + prev_value = &priv->unclamped_vadj_value;
625 + else
626 + return FALSE;
627 +
628 + if (snap_to_border)
629 + {
630 + if (*prev_value < 0 && value > 0)
631 + value = 0;
632 + else if (*prev_value > upper && value < upper)
633 + value = upper;
634 + }
635 +
636 + if (allow_overshooting)
637 + {
638 + lower -= MAX_OVERSHOOT_DISTANCE;
639 + upper += MAX_OVERSHOOT_DISTANCE;
640 + }
641 +
642 + *prev_value = CLAMP (value, lower, upper);
643 + gtk_adjustment_set_value (adjustment, *prev_value);
644 +
645 + return (*prev_value != value);
646 +}
647 +
648 +static gboolean
649 +scrolled_window_deceleration_cb (gpointer user_data)
650 +{
651 + KineticScrollData *data = user_data;
652 + GtkScrolledWindow *scrolled_window = data->scrolled_window;
653 + GtkScrolledWindowPrivate *priv;
654 + GtkAdjustment *hadjustment, *vadjustment;
655 + gint old_overshoot_x, old_overshoot_y, overshoot_x, overshoot_y;
656 + gdouble value;
657 + gint64 current_time;
658 + guint elapsed;
659 +
660 + priv = GTK_SCROLLED_WINDOW_GET_PRIVATE (scrolled_window);
661 + hadjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar));
662 + vadjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar));
663 +
664 + _gtk_scrolled_window_get_overshoot (scrolled_window,
665 + &old_overshoot_x, &old_overshoot_y);
666 +
667 + current_time = g_get_monotonic_time ();
668 + elapsed = (current_time - data->last_deceleration_time) / 1000;
669 + data->last_deceleration_time = current_time;
670 +
671 + if (hadjustment && scrolled_window->hscrollbar_visible)
672 + {
673 + value = priv->unclamped_hadj_value + (data->x_velocity * elapsed);
674 +
675 + if (_gtk_scrolled_window_set_adjustment_value (scrolled_window,
676 + hadjustment,
677 + value, TRUE, TRUE))
678 + data->x_velocity = 0;
679 + }
680 + else
681 + data->x_velocity = 0;
682 +
683 + if (vadjustment && scrolled_window->vscrollbar_visible)
684 + {
685 + value = priv->unclamped_vadj_value + (data->y_velocity * elapsed);
686 +
687 + if (_gtk_scrolled_window_set_adjustment_value (scrolled_window,
688 + vadjustment,
689 + value, TRUE, TRUE))
690 + data->y_velocity = 0;
691 + }
692 + else
693 + data->y_velocity = 0;
694 +
695 + _gtk_scrolled_window_get_overshoot (scrolled_window,
696 + &overshoot_x, &overshoot_y);
697 +
698 + if (overshoot_x == 0)
699 + {
700 + if (old_overshoot_x != 0)
701 + {
702 + /* Overshooting finished snapping back */
703 + data->x_velocity = 0;
704 + }
705 + else if (data->x_velocity > 0)
706 + {
707 + data->x_velocity -= FRICTION_DECELERATION * elapsed * data->vel_sine;
708 + data->x_velocity = MAX (0, data->x_velocity);
709 + }
710 + else if (data->x_velocity < 0)
711 + {
712 + data->x_velocity += FRICTION_DECELERATION * elapsed * data->vel_sine;
713 + data->x_velocity = MIN (0, data->x_velocity);
714 + }
715 + }
716 + else if (overshoot_x < 0)
717 + data->x_velocity += OVERSHOOT_INVERSE_ACCELERATION * elapsed;
718 + else if (overshoot_x > 0)
719 + data->x_velocity -= OVERSHOOT_INVERSE_ACCELERATION * elapsed;
720 +
721 + if (overshoot_y == 0)
722 + {
723 + if (old_overshoot_y != 0)
724 + {
725 + /* Overshooting finished snapping back */
726 + data->y_velocity = 0;
727 + }
728 + else if (data->y_velocity > 0)
729 + {
730 + data->y_velocity -= FRICTION_DECELERATION * elapsed * data->vel_cosine;
731 + data->y_velocity = MAX (0, data->y_velocity);
732 + }
733 + else if (data->y_velocity < 0)
734 + {
735 + data->y_velocity += FRICTION_DECELERATION * elapsed * data->vel_cosine;
736 + data->y_velocity = MIN (0, data->y_velocity);
737 + }
738 + }
739 + else if (overshoot_y < 0)
740 + data->y_velocity += OVERSHOOT_INVERSE_ACCELERATION * elapsed;
741 + else if (overshoot_y > 0)
742 + data->y_velocity -= OVERSHOOT_INVERSE_ACCELERATION * elapsed;
743 +
744 + if (old_overshoot_x != overshoot_x ||
745 + old_overshoot_y != overshoot_y)
746 + _gtk_scrolled_window_allocate_overshoot_window (scrolled_window);
747 +
748 + if (overshoot_x != 0 || overshoot_y != 0 ||
749 + data->x_velocity != 0 || data->y_velocity != 0)
750 + return TRUE;
751 + else
752 + {
753 + priv->deceleration_id = 0;
754 + return FALSE;
755 + }
756 +}
757 +
758 +static void
759 +gtk_scrolled_window_cancel_deceleration (GtkScrolledWindow *scrolled_window)
760 +{
761 + GtkScrolledWindowPrivate *priv = GTK_SCROLLED_WINDOW_GET_PRIVATE (scrolled_window);
762 +
763 + if (priv->deceleration_id)
764 + {
765 + g_source_remove (priv->deceleration_id);
766 + priv->deceleration_id = 0;
767 + }
768 +}
769 +
770 +static void
771 +gtk_scrolled_window_start_deceleration (GtkScrolledWindow *scrolled_window)
772 +{
773 + GtkScrolledWindowPrivate *priv = GTK_SCROLLED_WINDOW_GET_PRIVATE (scrolled_window);
774 + KineticScrollData *data;
775 + gdouble angle;
776 +
777 + data = g_new0 (KineticScrollData, 1);
778 + data->scrolled_window = scrolled_window;
779 + data->last_deceleration_time = g_get_monotonic_time ();
780 + data->x_velocity = priv->x_velocity;
781 + data->y_velocity = priv->y_velocity;
782 +
783 + /* We use sine/cosine as a factor to deceleration x/y components
784 + * of the vector, so we care about the sign later.
785 + */
786 + angle = atan2 (ABS (data->x_velocity), ABS (data->y_velocity));
787 + data->vel_cosine = cos (angle);
788 + data->vel_sine = sin (angle);
789 +
790 + priv->deceleration_id =
791 + gdk_threads_add_timeout_full (G_PRIORITY_DEFAULT,
792 + FRAME_INTERVAL,
793 + scrolled_window_deceleration_cb,
794 + data, (GDestroyNotify) g_free);
795 +}
796 +
797 +static gboolean
798 +gtk_scrolled_window_release_captured_event (GtkScrolledWindow *scrolled_window)
799 +{
800 + GtkScrolledWindowPrivate *priv = GTK_SCROLLED_WINDOW_GET_PRIVATE (scrolled_window);
801 +
802 + /* Cancel the scrolling and send the button press
803 + * event to the child widget
804 + */
805 + if (!priv->button_press_event)
806 + return FALSE;
807 +
808 + if (priv->pointer_grabbed)
809 + {
810 + gtk_grab_remove (GTK_WIDGET (scrolled_window));
811 + priv->pointer_grabbed = FALSE;
812 + }
813 +
814 + if (priv->capture_button_press)
815 + {
816 + GtkWidget *event_widget;
817 +
818 + event_widget = gtk_get_event_widget (priv->button_press_event);
819 +
820 + if (!_gtk_propagate_captured_event (event_widget,
821 + priv->button_press_event,
822 + gtk_bin_get_child (GTK_BIN (scrolled_window))))
823 + gtk_propagate_event (event_widget, priv->button_press_event);
824 +
825 + gdk_event_free (priv->button_press_event);
826 + priv->button_press_event = NULL;
827 + }
828 +
829 + if (_gtk_scrolled_window_get_overshoot (scrolled_window, NULL, NULL))
830 + gtk_scrolled_window_start_deceleration (scrolled_window);
831 +
832 + return FALSE;
833 +}
834 +
835 +static gboolean
836 +gtk_scrolled_window_calculate_velocity (GtkScrolledWindow *scrolled_window,
837 + GdkEvent *event)
838 +{
839 + GtkScrolledWindowPrivate *priv;
840 + gdouble x_root, y_root;
841 + guint32 _time;
842 +
843 +#define STILL_THRESHOLD 40
844 +
845 + if (!gdk_event_get_root_coords (event, &x_root, &y_root))
846 + return FALSE;
847 +
848 + priv = GTK_SCROLLED_WINDOW_GET_PRIVATE (scrolled_window);
849 + _time = gdk_event_get_time (event);
850 +
851 + if (priv->last_motion_event_x_root != x_root ||
852 + priv->last_motion_event_y_root != y_root ||
853 + ABS (_time - priv->last_motion_event_time) > STILL_THRESHOLD)
854 + {
855 + priv->x_velocity = (priv->last_motion_event_x_root - x_root) /
856 + (gdouble) (_time - priv->last_motion_event_time);
857 + priv->y_velocity = (priv->last_motion_event_y_root - y_root) /
858 + (gdouble) (_time - priv->last_motion_event_time);
859 + }
860 +
861 + priv->last_motion_event_x_root = x_root;
862 + priv->last_motion_event_y_root = y_root;
863 + priv->last_motion_event_time = _time;
864 +
865 +#undef STILL_THRESHOLD
866 +
867 + return TRUE;
868 +}
869 +
870 +static gboolean
871 +gtk_scrolled_window_captured_button_release (GtkWidget *widget,
872 + GdkEvent *event)
873 +{
874 + GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (widget);
875 + GtkScrolledWindowPrivate *priv;
876 + GtkWidget *child;
877 + gboolean overshoot;
878 + gdouble x_root, y_root;
879 +
880 + if (event->button.button != 1)
881 + return FALSE;
882 +
883 + child = gtk_bin_get_child (GTK_BIN (widget));
884 + if (!child)
885 + return FALSE;
886 +
887 + priv = GTK_SCROLLED_WINDOW_GET_PRIVATE (scrolled_window);
888 + gtk_grab_remove (widget);
889 + priv->pointer_grabbed = FALSE;
890 +
891 + if (priv->release_timeout_id)
892 + {
893 + g_source_remove (priv->release_timeout_id);
894 + priv->release_timeout_id = 0;
895 + }
896 +
897 + overshoot = _gtk_scrolled_window_get_overshoot (scrolled_window, NULL, NULL);
898 +
899 + if (priv->in_drag)
900 + gdk_pointer_ungrab (gdk_event_get_time (event));
901 + else
902 + {
903 + /* There hasn't been scrolling at all, so just let the
904 + * child widget handle the button press normally
905 + */
906 + gtk_scrolled_window_release_captured_event (scrolled_window);
907 +
908 + if (!overshoot)
909 + return FALSE;
910 + }
911 + priv->in_drag = FALSE;
912 +
913 + if (priv->button_press_event)
914 + {
915 + gdk_event_free (priv->button_press_event);
916 + priv->button_press_event = NULL;
917 + }
918 +
919 + gtk_scrolled_window_calculate_velocity (scrolled_window, event);
920 +
921 + /* Zero out vector components without a visible scrollbar */
922 + if (!scrolled_window->hscrollbar_visible)
923 + priv->x_velocity = 0;
924 + if (!scrolled_window->vscrollbar_visible)
925 + priv->y_velocity = 0;
926 +
927 + if (priv->x_velocity != 0 || priv->y_velocity != 0 || overshoot)
928 + {
929 + gtk_scrolled_window_start_deceleration (scrolled_window);
930 + priv->x_velocity = priv->y_velocity = 0;
931 + priv->last_button_event_valid = FALSE;
932 + }
933 + else
934 + {
935 + gdk_event_get_root_coords (event, &x_root, &y_root);
936 + priv->last_button_event_x_root = x_root;
937 + priv->last_button_event_y_root = y_root;
938 + priv->last_button_event_valid = TRUE;
939 + }
940 +
941 + if (priv->capture_button_press)
942 + return TRUE;
943 + else
944 + return FALSE;
945 +}
946 +
947 +static gboolean
948 +gtk_scrolled_window_captured_motion_notify (GtkWidget *widget,
949 + GdkEvent *event)
950 +{
951 + GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (widget);
952 + GtkScrolledWindowPrivate *priv;
953 + gint old_overshoot_x, old_overshoot_y;
954 + gint new_overshoot_x, new_overshoot_y;
955 + GtkWidget *child;
956 + GtkAdjustment *hadjustment;
957 + GtkAdjustment *vadjustment;
958 + gdouble dx, dy;
959 + GdkModifierType state;
960 + gdouble x_root, y_root;
961 +
962 + gdk_event_get_state (event, &state);
963 + if (!(state & GDK_BUTTON1_MASK))
964 + return FALSE;
965 +
966 + child = gtk_bin_get_child (GTK_BIN (widget));
967 + if (!child)
968 + return FALSE;
969 +
970 + priv = GTK_SCROLLED_WINDOW_GET_PRIVATE (scrolled_window);
971 +
972 + /* Check if we've passed the drag threshold */
973 + gdk_event_get_root_coords (event, &x_root, &y_root);
974 + if (!priv->in_drag)
975 + {
976 + if (gtk_drag_check_threshold (widget,
977 + priv->last_button_event_x_root,
978 + priv->last_button_event_y_root,
979 + x_root, y_root))
980 + {
981 + if (priv->release_timeout_id)
982 + {
983 + g_source_remove (priv->release_timeout_id);
984 + priv->release_timeout_id = 0;
985 + }
986 +
987 + priv->last_button_event_valid = FALSE;
988 + priv->in_drag = TRUE;
989 + }
990 + else
991 + return TRUE;
992 + }
993 +
994 + gdk_pointer_grab (gtk_widget_get_window (widget),
995 + TRUE,
996 + GDK_BUTTON_RELEASE_MASK | GDK_BUTTON1_MOTION_MASK,
997 + NULL, NULL,
998 + gdk_event_get_time (event));
999 +
1000 + priv->last_button_event_valid = FALSE;
1001 +
1002 + if (priv->button_press_event)
1003 + {
1004 + gdk_event_free (priv->button_press_event);
1005 + priv->button_press_event = NULL;
1006 + }
1007 +
1008 + _gtk_scrolled_window_get_overshoot (scrolled_window,
1009 + &old_overshoot_x, &old_overshoot_y);
1010 +
1011 + hadjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar));
1012 + if (hadjustment && scrolled_window->hscrollbar_visible)
1013 + {
1014 + dx = (priv->last_motion_event_x_root - x_root) + priv->unclamped_hadj_value;
1015 + _gtk_scrolled_window_set_adjustment_value (scrolled_window, hadjustment,
1016 + dx, TRUE, FALSE);
1017 + }
1018 +
1019 + vadjustment = gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar));
1020 + if (vadjustment && scrolled_window->vscrollbar_visible)
1021 + {
1022 + dy = (priv->last_motion_event_y_root - y_root) + priv->unclamped_vadj_value;
1023 + _gtk_scrolled_window_set_adjustment_value (scrolled_window, vadjustment,
1024 + dy, TRUE, FALSE);
1025 + }
1026 +
1027 + _gtk_scrolled_window_get_overshoot (scrolled_window,
1028 + &new_overshoot_x, &new_overshoot_y);
1029 +
1030 + if (old_overshoot_x != new_overshoot_x ||
1031 + old_overshoot_y != new_overshoot_y)
1032 + _gtk_scrolled_window_allocate_overshoot_window (scrolled_window);
1033 +
1034 + gtk_scrolled_window_calculate_velocity (scrolled_window, event);
1035 +
1036 + return TRUE;
1037 +}
1038 +
1039 +static gboolean
1040 +gtk_scrolled_window_captured_button_press (GtkWidget *widget,
1041 + GdkEvent *event)
1042 +{
1043 + GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (widget);
1044 + GtkScrolledWindowPrivate *priv;
1045 + GtkWidget *child;
1046 + GtkWidget *event_widget;
1047 + gdouble x_root, y_root;
1048 +
1049 + /* If scrollbars are not visible, we don't do kinetic scrolling */
1050 + if (!scrolled_window->vscrollbar_visible &&
1051 + !scrolled_window->hscrollbar_visible)
1052 + return FALSE;
1053 +
1054 + priv = GTK_SCROLLED_WINDOW_GET_PRIVATE (scrolled_window);
1055 +
1056 + event_widget = gtk_get_event_widget (event);
1057 +
1058 + /* If there's another scrolled window between the widget
1059 + * receiving the event and this capturing scrolled window,
1060 + * let it handle the events.
1061 + */
1062 + if (widget != gtk_widget_get_ancestor (event_widget, GTK_TYPE_SCROLLED_WINDOW))
1063 + return FALSE;
1064 +
1065 + /* Check whether the button press is close to the previous one,
1066 + * take that as a shortcut to get the child widget handle events
1067 + */
1068 + gdk_event_get_root_coords (event, &x_root, &y_root);
1069 + if (priv->last_button_event_valid &&
1070 + ABS (x_root - priv->last_button_event_x_root) < TOUCH_BYPASS_CAPTURED_THRESHOLD &&
1071 + ABS (y_root - priv->last_button_event_y_root) < TOUCH_BYPASS_CAPTURED_THRESHOLD)
1072 + {
1073 + priv->last_button_event_valid = FALSE;
1074 + return FALSE;
1075 + }
1076 +
1077 + priv->last_button_event_x_root = priv->last_motion_event_x_root = x_root;
1078 + priv->last_button_event_y_root = priv->last_motion_event_y_root = y_root;
1079 + priv->last_motion_event_time = gdk_event_get_time (event);
1080 + priv->last_button_event_valid = TRUE;
1081 +
1082 + if (event->button.button != 1)
1083 + return FALSE;
1084 +
1085 + child = gtk_bin_get_child (GTK_BIN (widget));
1086 + if (!child)
1087 + return FALSE;
1088 +
1089 + if (scrolled_window->hscrollbar == event_widget ||
1090 + scrolled_window->vscrollbar == event_widget)
1091 + return FALSE;
1092 +
1093 + priv->pointer_grabbed = TRUE;
1094 + gtk_grab_add (widget);
1095 +
1096 + gtk_scrolled_window_cancel_deceleration (scrolled_window);
1097 +
1098 + /* Only set the timeout if we're going to store an event */
1099 + if (priv->capture_button_press)
1100 + priv->release_timeout_id =
1101 + gdk_threads_add_timeout (RELEASE_EVENT_TIMEOUT,
1102 + (GSourceFunc) gtk_scrolled_window_release_captured_event,
1103 + scrolled_window);
1104 +
1105 + priv->in_drag = FALSE;
1106 +
1107 + if (priv->capture_button_press)
1108 + {
1109 + /* Store the button press event in
1110 + * case we need to propagate it later
1111 + */
1112 + priv->button_press_event = gdk_event_copy (event);
1113 + return TRUE;
1114 + }
1115 + else
1116 + return FALSE;
1117 +}
1118 +
1119 +static gboolean
1120 +gtk_scrolled_window_captured_event (GtkWidget *widget,
1121 + GdkEvent *event)
1122 +{
1123 + gboolean retval = FALSE;
1124 + GtkScrolledWindowPrivate *priv = GTK_SCROLLED_WINDOW_GET_PRIVATE (widget);
1125 +
1126 + switch (event->type)
1127 + {
1128 + case GDK_BUTTON_PRESS:
1129 + retval = gtk_scrolled_window_captured_button_press (widget, event);
1130 + break;
1131 + case GDK_BUTTON_RELEASE:
1132 + if (priv->pointer_grabbed)
1133 + retval = gtk_scrolled_window_captured_button_release (widget, event);
1134 + else
1135 + priv->last_button_event_valid = FALSE;
1136 + break;
1137 + case GDK_MOTION_NOTIFY:
1138 + if (priv->pointer_grabbed)
1139 + retval = gtk_scrolled_window_captured_motion_notify (widget, event);
1140 + break;
1141 + case GDK_LEAVE_NOTIFY:
1142 + case GDK_ENTER_NOTIFY:
1143 + if (priv->in_drag &&
1144 + event->crossing.mode != GDK_CROSSING_GRAB)
1145 + retval = TRUE;
1146 + break;
1147 + default:
1148 + break;
1149 + }
1150 +
1151 + return retval;
1152 +}
1153 +
1154 +static gboolean
1155 gtk_scrolled_window_focus (GtkWidget *widget,
1156 GtkDirectionType direction)
1157 {
1158 @@ -1714,17 +2614,42 @@ gtk_scrolled_window_adjustment_changed (GtkAdjustment *adjustment,
1159 }
1161 static void
1162 +gtk_scrolled_window_adjustment_value_changed (GtkAdjustment *adjustment,
1163 + gpointer user_data)
1164 +{
1165 + GtkScrolledWindow *scrolled_window = user_data;
1166 + GtkScrolledWindowPrivate *priv = GTK_SCROLLED_WINDOW_GET_PRIVATE (scrolled_window);
1167 +
1168 + /* Allow overshooting for kinetic scrolling operations */
1169 + if (priv->pointer_grabbed || priv->deceleration_id)
1170 + return;
1171 +
1172 + /* Ensure GtkAdjustment and unclamped values are in sync */
1173 + if (scrolled_window->vscrollbar &&
1174 + adjustment == gtk_range_get_adjustment (GTK_RANGE (scrolled_window->vscrollbar)))
1175 + priv->unclamped_vadj_value = gtk_adjustment_get_value (adjustment);
1176 + else if (scrolled_window->hscrollbar &&
1177 + adjustment == gtk_range_get_adjustment (GTK_RANGE (scrolled_window->hscrollbar)))
1178 + priv->unclamped_hadj_value = gtk_adjustment_get_value (adjustment);
1179 +}
1180 +
1181 +static void
1182 gtk_scrolled_window_add (GtkContainer *container,
1183 GtkWidget *child)
1184 {
1185 GtkScrolledWindow *scrolled_window;
1186 + GtkScrolledWindowPrivate *priv;
1187 GtkBin *bin;
1189 bin = GTK_BIN (container);
1190 + priv = GTK_SCROLLED_WINDOW_GET_PRIVATE (container);
1191 g_return_if_fail (bin->child == NULL);
1193 scrolled_window = GTK_SCROLLED_WINDOW (container);
1195 + if (gtk_widget_get_realized (GTK_WIDGET (bin)))
1196 + gtk_widget_set_parent_window (child, priv->overshoot_window);
1197 +
1198 bin->child = child;
1199 gtk_widget_set_parent (child, GTK_WIDGET (bin));
1201 @@ -1837,5 +2762,111 @@ _gtk_scrolled_window_get_scrollbar_spacing (GtkScrolledWindow *scrolled_window)
1202 }
1203 }
1205 +static void
1206 +gtk_scrolled_window_realize (GtkWidget *widget)
1207 +{
1208 + GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (widget);
1209 + GtkScrolledWindowPrivate *priv = GTK_SCROLLED_WINDOW_GET_PRIVATE (scrolled_window);
1210 + GtkAllocation allocation, relative_allocation;
1211 + GdkWindowAttr attributes;
1212 + GtkWidget *child_widget;
1213 + gint attributes_mask;
1214 +
1215 + gtk_widget_set_realized (widget, TRUE);
1216 + gtk_widget_get_allocation (widget, &allocation);
1217 + gtk_scrolled_window_relative_allocation (widget, &relative_allocation);
1218 +
1219 + attributes.window_type = GDK_WINDOW_CHILD;
1220 + attributes.x = allocation.x + relative_allocation.x;
1221 + attributes.y = allocation.y + relative_allocation.y;
1222 + attributes.width = relative_allocation.width;
1223 + attributes.height = relative_allocation.height;
1224 + attributes.wclass = GDK_INPUT_OUTPUT;
1225 + attributes.visual = gtk_widget_get_visual (widget);
1226 + attributes.event_mask = GDK_VISIBILITY_NOTIFY_MASK |
1227 + GDK_BUTTON_MOTION_MASK;
1228 +
1229 + attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL;
1230 +
1231 + priv->overshoot_window =
1232 + gdk_window_new (gtk_widget_get_parent_window (widget),
1233 + &attributes, attributes_mask);
1234 +
1235 + gdk_window_set_user_data (priv->overshoot_window, widget);
1236 +
1237 + child_widget = gtk_bin_get_child (GTK_BIN (widget));
1238 +
1239 + if (child_widget)
1240 + gtk_widget_set_parent_window (child_widget,
1241 + priv->overshoot_window);
1242 +
1243 + GTK_WIDGET_CLASS (gtk_scrolled_window_parent_class)->realize (widget);
1244 +}
1245 +
1246 +static void
1247 +gtk_scrolled_window_unrealize (GtkWidget *widget)
1248 +{
1249 + GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (widget);
1250 + GtkScrolledWindowPrivate *priv = GTK_SCROLLED_WINDOW_GET_PRIVATE (scrolled_window);
1251 +
1252 + gdk_window_set_user_data (priv->overshoot_window, NULL);
1253 + gdk_window_destroy (priv->overshoot_window);
1254 + priv->overshoot_window = NULL;
1255 +
1256 + gtk_widget_set_realized (widget, FALSE);
1257 +
1258 + GTK_WIDGET_CLASS (gtk_scrolled_window_parent_class)->unrealize (widget);
1259 +}
1260 +
1261 +static void
1262 +gtk_scrolled_window_map (GtkWidget *widget)
1263 +{
1264 + GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (widget);
1265 + GtkScrolledWindowPrivate *priv = GTK_SCROLLED_WINDOW_GET_PRIVATE (scrolled_window);
1266 +
1267 + gdk_window_show (priv->overshoot_window);
1268 +
1269 + GTK_WIDGET_CLASS (gtk_scrolled_window_parent_class)->map (widget);
1270 +}
1271 +
1272 +static void
1273 +gtk_scrolled_window_unmap (GtkWidget *widget)
1274 +{
1275 + GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (widget);
1276 + GtkScrolledWindowPrivate *priv = GTK_SCROLLED_WINDOW_GET_PRIVATE (scrolled_window);
1277 +
1278 + gdk_window_hide (priv->overshoot_window);
1279 +
1280 + GTK_WIDGET_CLASS (gtk_scrolled_window_parent_class)->unmap (widget);
1281 +}
1282 +
1283 +static void
1284 +gtk_scrolled_window_grab_notify (GtkWidget *widget,
1285 + gboolean was_grabbed)
1286 +{
1287 + GtkScrolledWindow *scrolled_window = GTK_SCROLLED_WINDOW (widget);
1288 + GtkScrolledWindowPrivate *priv = GTK_SCROLLED_WINDOW_GET_PRIVATE (scrolled_window);
1289 +
1290 + if (priv->pointer_grabbed && !was_grabbed)
1291 + {
1292 + gdk_pointer_ungrab (gtk_get_current_event_time ());
1293 + priv->pointer_grabbed = FALSE;
1294 + priv->in_drag = FALSE;
1295 +
1296 + if (priv->release_timeout_id)
1297 + {
1298 + g_source_remove (priv->release_timeout_id);
1299 + priv->release_timeout_id = 0;
1300 + }
1301 +
1302 + if (_gtk_scrolled_window_get_overshoot (scrolled_window, NULL, NULL))
1303 + gtk_scrolled_window_start_deceleration (scrolled_window);
1304 + else
1305 + gtk_scrolled_window_cancel_deceleration (scrolled_window);
1306 +
1307 + priv->last_button_event_valid = FALSE;
1308 + }
1309 +}
1310 +
1311 #define __GTK_SCROLLED_WINDOW_C__
1312 #include "gtkaliasdef.c"
1313 diff --git a/gtk/gtkscrolledwindow.h b/gtk/gtkscrolledwindow.h
1314 index 5407547..1f555e0 100644
1315 --- a/gtk/gtkscrolledwindow.h
1316 +++ b/gtk/gtkscrolledwindow.h
1317 @@ -127,6 +127,14 @@ GtkShadowType gtk_scrolled_window_get_shadow_type (GtkScrolledWindow *scrolle
1318 void gtk_scrolled_window_add_with_viewport (GtkScrolledWindow *scrolled_window,
1319 GtkWidget *child);
1321 +void gtk_scrolled_window_set_kinetic_scrolling (GtkScrolledWindow *scrolled_window,
1322 + gboolean kinetic_scrolling);
1323 +gboolean gtk_scrolled_window_get_kinetic_scrolling (GtkScrolledWindow *scrolled_window);
1324 +
1325 +void gtk_scrolled_window_set_capture_button_press (GtkScrolledWindow *scrolled_window,
1326 + gboolean capture_button_press);
1327 +gboolean gtk_scrolled_window_get_capture_button_press (GtkScrolledWindow *scrolled_window);
1328 +
1329 gint _gtk_scrolled_window_get_scrollbar_spacing (GtkScrolledWindow *scrolled_window);
1332 --
1333 1.7.10.2 (Apple Git-33)