Source/WebCore/platform/mac/ScrollAnimatorMac.mm

   1 /*
   2  * Copyright (C) 2010, 2011 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
  14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
  17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  23  * THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "config.h"
  27
  28 #if ENABLE(SMOOTH_SCROLLING)
  29
  30 #include "ScrollAnimatorMac.h"
  31
  32 #include "FloatPoint.h"
  33 #include "IntRect.h"
  34 #include "PlatformGestureEvent.h"
  35 #include "PlatformWheelEvent.h"
  36 #include "ScrollView.h"
  37 #include "ScrollableArea.h"
  38 #include "ScrollbarTheme.h"
  39 #include "ScrollbarThemeMac.h"
  40 #include <wtf/PassOwnPtr.h>
  41 #include <wtf/UnusedParam.h>
  42
  43 using namespace WebCore;
  44 using namespace std;
  45
  46 @interface NSObject (ScrollAnimationHelperDetails)
  47 - (id)initWithDelegate:(id)delegate;
  48 - (void)_stopRun;
  49 - (BOOL)_isAnimating;
  50 - (NSPoint)targetOrigin;
  51 @end
  52
  53 @interface ScrollAnimationHelperDelegate : NSObject
  54 {
  55     WebCore::ScrollAnimatorMac* _animator;
  56 }
  57 - (id)initWithScrollAnimator:(WebCore::ScrollAnimatorMac*)scrollAnimator;
  58 @end
  59
  60 static NSSize abs(NSSize size)
  61 {
  62     NSSize finalSize = size;
  63     if (finalSize.width < 0)
  64         finalSize.width = -finalSize.width;
  65     if (finalSize.height < 0)
  66         finalSize.height = -finalSize.height;
  67     return finalSize;
  68 }
  69
  70 @implementation ScrollAnimationHelperDelegate
  71
  72 - (id)initWithScrollAnimator:(WebCore::ScrollAnimatorMac*)scrollAnimator
  73 {
  74     self = [super init];
  75     if (!self)
  76         return nil;
  77
  78     _animator = scrollAnimator;
  79     return self;
  80 }
  81
  82 - (void)scrollAnimatorDestroyed
  83 {
  84     _animator = 0;
  85 }
  86
  87 - (NSRect)bounds
  88 {
  89     if (!_animator)
  90         return NSZeroRect;
  91
  92     WebCore::FloatPoint currentPosition = _animator->currentPosition();
  93     return NSMakeRect(currentPosition.x(), currentPosition.y(), 0, 0);
  94 }
  95
  96 - (void)_immediateScrollToPoint:(NSPoint)newPosition
  97 {
  98     if (!_animator)
  99         return;
 100     _animator->immediateScrollToPoint(newPosition);
 101 }
 102
 103 - (NSPoint)_pixelAlignProposedScrollPosition:(NSPoint)newOrigin
 104 {
 105     return newOrigin;
 106 }
 107
 108 - (NSSize)convertSizeToBase:(NSSize)size
 109 {
 110     return abs(size);
 111 }
 112
 113 - (NSSize)convertSizeFromBase:(NSSize)size
 114 {
 115     return abs(size);
 116 }
 117
 118 - (NSSize)convertSizeToBacking:(NSSize)size
 119 {
 120     return abs(size);
 121 }
 122
 123 - (NSSize)convertSizeFromBacking:(NSSize)size
 124 {
 125     return abs(size);
 126 }
 127
 128 - (id)superview
 129 {
 130     return nil;
 131 }
 132
 133 - (id)documentView
 134 {
 135     return nil;
 136 }
 137
 138 - (id)window
 139 {
 140     return nil;
 141 }
 142
 143 - (void)_recursiveRecomputeToolTips
 144 {
 145 }
 146
 147 @end
 148
 149 #if USE(WK_SCROLLBAR_PAINTER)
 150
 151 @interface ScrollbarPainterControllerDelegate : NSObject
 152 {
 153     WebCore::ScrollAnimatorMac* _animator;
 154 }
 155 - (id)initWithScrollAnimator:(WebCore::ScrollAnimatorMac*)scrollAnimator;
 156 @end
 157
 158 @implementation ScrollbarPainterControllerDelegate
 159
 160 - (id)initWithScrollAnimator:(WebCore::ScrollAnimatorMac*)scrollAnimator
 161 {
 162     self = [super init];
 163     if (!self)
 164         return nil;
 165
 166     _animator = scrollAnimator;
 167     return self;
 168 }
 169
 170 - (void)scrollAnimatorDestroyed
 171 {
 172     _animator = 0;
 173 }
 174
 175 - (NSRect)contentAreaRectForScrollerImpPair:(id)scrollerImpPair
 176 {
 177     UNUSED_PARAM(scrollerImpPair);
 178     if (!_animator)
 179         return NSZeroRect;
 180
 181     WebCore::IntSize contentsSize = _animator->scrollableArea()->contentsSize();
 182     return NSMakeRect(0, 0, contentsSize.width(), contentsSize.height());
 183 }
 184
 185 - (BOOL)inLiveResizeForScrollerImpPair:(id)scrollerImpPair
 186 {
 187     UNUSED_PARAM(scrollerImpPair);
 188     if (!_animator)
 189         return NO;
 190
 191     return _animator->scrollableArea()->inLiveResize();
 192 }
 193
 194 - (NSPoint)mouseLocationInContentAreaForScrollerImpPair:(id)scrollerImpPair
 195 {
 196     UNUSED_PARAM(scrollerImpPair);
 197     if (!_animator)
 198         return NSZeroPoint;
 199
 200     return _animator->scrollableArea()->currentMousePosition();
 201 }
 202
 203 - (NSPoint)scrollerImpPair:(id)scrollerImpPair convertContentPoint:(NSPoint)pointInContentArea toScrollerImp:(id)scrollerImp
 204 {
 205     UNUSED_PARAM(scrollerImpPair);
 206     if (!_animator)
 207         return NSZeroPoint;
 208
 209     WebCore::Scrollbar* scrollbar = 0;
 210     if (wkScrollbarPainterIsHorizontal((WKScrollbarPainterRef)scrollerImp))
 211         scrollbar = _animator->scrollableArea()->horizontalScrollbar();
 212     else
 213         scrollbar = _animator->scrollableArea()->verticalScrollbar();
 214
 215     // It is possible to have a null scrollbar here since it is possible for this delegate
 216     // method to be called between the moment when a scrollbar has been set to 0 and the
 217     // moment when its destructor has been called. We should probably de-couple some
 218     // of the clean-up work in ScrollbarThemeMac::unregisterScrollbar() to avoid this
 219     // issue.
 220     if (!scrollbar)
 221         return WebCore::IntPoint();
 222
 223     return scrollbar->convertFromContainingView(WebCore::IntPoint(pointInContentArea));
 224 }
 225
 226 - (void)scrollerImpPair:(id)scrollerImpPair setContentAreaNeedsDisplayInRect:(NSRect)rect
 227 {
 228     UNUSED_PARAM(scrollerImpPair);
 229     UNUSED_PARAM(rect);
 230 }
 231
 232 - (void)scrollerImpPair:(id)scrollerImpPair updateScrollerStyleForNewRecommendedScrollerStyle:(NSScrollerStyle)newRecommendedScrollerStyle
 233 {
 234     if (!_animator)
 235         return;
 236
 237     WKScrollbarPainterControllerRef painterController = (WKScrollbarPainterControllerRef)scrollerImpPair;
 238     WebCore::ScrollbarThemeMac* macTheme = (WebCore::ScrollbarThemeMac*)WebCore::ScrollbarTheme::nativeTheme();
 239
 240     WKScrollbarPainterRef oldVerticalPainter = wkVerticalScrollbarPainterForController(painterController);
 241     if (oldVerticalPainter) {
 242         WebCore::Scrollbar* verticalScrollbar = _animator->scrollableArea()->verticalScrollbar();
 243         WKScrollbarPainterRef newVerticalPainter = wkMakeScrollbarReplacementPainter(oldVerticalPainter,
 244                                                                                      newRecommendedScrollerStyle,
 245                                                                                      verticalScrollbar->controlSize(),
 246                                                                                      false);
 247         macTheme->setNewPainterForScrollbar(verticalScrollbar, newVerticalPainter);
 248         wkSetPainterForPainterController(painterController, newVerticalPainter, false);
 249
 250         // The different scrollbar styles have different thicknesses, so we must re-set the
 251         // frameRect to the new thickness, and the re-layout below will ensure the position
 252         // and length are properly updated.
 253         int thickness = macTheme->scrollbarThickness(verticalScrollbar->controlSize());
 254         verticalScrollbar->setFrameRect(WebCore::IntRect(0, 0, thickness, thickness));
 255     }
 256
 257     WKScrollbarPainterRef oldHorizontalPainter = wkHorizontalScrollbarPainterForController(painterController);
 258     if (oldHorizontalPainter) {
 259         WebCore::Scrollbar* horizontalScrollbar = _animator->scrollableArea()->horizontalScrollbar();
 260         WKScrollbarPainterRef newHorizontalPainter = wkMakeScrollbarReplacementPainter(oldHorizontalPainter,
 261                                                                                        newRecommendedScrollerStyle,
 262                                                                                        horizontalScrollbar->controlSize(),
 263                                                                                        true);
 264         macTheme->setNewPainterForScrollbar(horizontalScrollbar, newHorizontalPainter);
 265         wkSetPainterForPainterController(painterController, newHorizontalPainter, true);
 266
 267         // The different scrollbar styles have different thicknesses, so we must re-set the
 268         // frameRect to the new thickness, and the re-layout below will ensure the position
 269         // and length are properly updated.
 270         int thickness = macTheme->scrollbarThickness(horizontalScrollbar->controlSize());
 271         horizontalScrollbar->setFrameRect(WebCore::IntRect(0, 0, thickness, thickness));
 272     }
 273
 274     wkSetScrollbarPainterControllerStyle(painterController, newRecommendedScrollerStyle);
 275
 276     // The different scrollbar styles affect layout, so we must re-layout everything.
 277     _animator->scrollableArea()->scrollbarStyleChanged();
 278 }
 279
 280 @end
 281
 282 @interface ScrollbarPartAnimation : NSAnimation
 283 {
 284     RetainPtr<WKScrollbarPainterRef> _scrollerPainter;
 285     WebCore::ScrollbarPart _part;
 286     WebCore::ScrollAnimatorMac* _animator;
 287     CGFloat _initialAlpha;
 288     CGFloat _newAlpha;
 289 }
 290 - (id)initWithScrollbarPainter:(WKScrollbarPainterRef)scrollerPainter part:(WebCore::ScrollbarPart)part scrollAnimator:(WebCore::ScrollAnimatorMac*)scrollAnimator animateAlphaTo:(CGFloat)newAlpha duration:(NSTimeInterval)duration;
 291 @end
 292
 293 @implementation ScrollbarPartAnimation
 294
 295 - (id)initWithScrollbarPainter:(WKScrollbarPainterRef)scrollerPainter part:(WebCore::ScrollbarPart)part scrollAnimator:(WebCore::ScrollAnimatorMac*)scrollAnimator animateAlphaTo:(CGFloat)newAlpha duration:(NSTimeInterval)duration
 296 {
 297     self = [super initWithDuration:duration animationCurve:NSAnimationEaseInOut];
 298     if (!self)
 299         return nil;
 300
 301     _scrollerPainter = scrollerPainter;
 302     _part = part;
 303     _animator = scrollAnimator;
 304     _initialAlpha = _part == WebCore::ThumbPart ? wkScrollbarPainterKnobAlpha(_scrollerPainter.get()) : wkScrollbarPainterTrackAlpha(_scrollerPainter.get());
 305     _newAlpha = newAlpha;
 306
 307     return self;
 308 }
 309
 310 - (void)setCurrentProgress:(NSAnimationProgress)progress
 311 {
 312     [super setCurrentProgress:progress];
 313
 314     if (!_animator)
 315         return;
 316
 317     CGFloat currentAlpha;
 318     if (_initialAlpha > _newAlpha)
 319         currentAlpha = 1 - progress;
 320     else
 321         currentAlpha = progress;
 322
 323     if (_part == WebCore::ThumbPart)
 324         wkSetScrollbarPainterKnobAlpha(_scrollerPainter.get(), currentAlpha);
 325     else
 326         wkSetScrollbarPainterTrackAlpha(_scrollerPainter.get(), currentAlpha);
 327
 328     // Invalidate the scrollbars so that they paint the animation
 329     if (WebCore::Scrollbar* verticalScrollbar = _animator->scrollableArea()->verticalScrollbar())
 330         verticalScrollbar->invalidateRect(WebCore::IntRect(0, 0, verticalScrollbar->width(), verticalScrollbar->height()));
 331     if (WebCore::Scrollbar* horizontalScrollbar = _animator->scrollableArea()->horizontalScrollbar())
 332         horizontalScrollbar->invalidateRect(WebCore::IntRect(0, 0, horizontalScrollbar->width(), horizontalScrollbar->height()));
 333 }
 334
 335 - (void)scrollAnimatorDestroyed
 336 {
 337     [self stopAnimation];
 338     _animator = 0;
 339 }
 340
 341 @end
 342
 343 @interface ScrollbarPainterDelegate : NSObject<NSAnimationDelegate>
 344 {
 345     WebCore::ScrollAnimatorMac* _animator;
 346
 347     RetainPtr<ScrollbarPartAnimation> _verticalKnobAnimation;
 348     RetainPtr<ScrollbarPartAnimation> _horizontalKnobAnimation;
 349
 350     RetainPtr<ScrollbarPartAnimation> _verticalTrackAnimation;
 351     RetainPtr<ScrollbarPartAnimation> _horizontalTrackAnimation;
 352 }
 353 - (id)initWithScrollAnimator:(WebCore::ScrollAnimatorMac*)scrollAnimator;
 354 - (void)cancelAnimations;
 355 @end
 356
 357 @implementation ScrollbarPainterDelegate
 358
 359 - (id)initWithScrollAnimator:(WebCore::ScrollAnimatorMac*)scrollAnimator
 360 {
 361     self = [super init];
 362     if (!self)
 363         return nil;
 364
 365     _animator = scrollAnimator;
 366     return self;
 367 }
 368
 369 - (void)cancelAnimations
 370 {
 371     [_verticalKnobAnimation.get() stopAnimation];
 372     [_horizontalKnobAnimation.get() stopAnimation];
 373     [_verticalTrackAnimation.get() stopAnimation];
 374     [_horizontalTrackAnimation.get() stopAnimation];
 375 }
 376
 377 - (NSRect)convertRectToBacking:(NSRect)aRect
 378 {
 379     return aRect;
 380 }
 381
 382 - (NSRect)convertRectFromBacking:(NSRect)aRect
 383 {
 384     return aRect;
 385 }
 386
 387 - (CALayer *)layer
 388 {
 389     if (!_animator)
 390         return nil;
 391     if (!_animator->isDrawingIntoLayer())
 392         return nil;
 393
 394     // FIXME: This should attempt to return an actual layer.
 395     static CALayer *dummyLayer = [[CALayer alloc] init];
 396     return dummyLayer;
 397 }
 398
 399 - (void)setUpAnimation:(RetainPtr<ScrollbarPartAnimation>&)scrollbarPartAnimation scrollerPainter:(WKScrollbarPainterRef)scrollerPainter part:(WebCore::ScrollbarPart)part animateAlphaTo:(CGFloat)newAlpha duration:(NSTimeInterval)duration
 400 {
 401     // If the user has scrolled the page, then the scrollbars must be animated here.
 402     // This overrides the early returns.
 403     bool mustAnimate = _animator->haveScrolledSincePageLoad();
 404
 405     if (_animator->scrollbarPaintTimerIsActive() && !mustAnimate)
 406         return;
 407
 408     if (_animator->scrollableArea()->shouldSuspendScrollAnimations() && !mustAnimate) {
 409         _animator->startScrollbarPaintTimer();
 410         return;
 411     }
 412
 413     // At this point, we are definitely going to animate now, so stop the timer.
 414     _animator->stopScrollbarPaintTimer();
 415
 416     // If we are currently animating, stop
 417     if (scrollbarPartAnimation) {
 418         [scrollbarPartAnimation.get() stopAnimation];
 419         scrollbarPartAnimation = nil;
 420     }
 421
 422     [NSAnimationContext beginGrouping];
 423     [[NSAnimationContext currentContext] setDuration:duration];
 424     scrollbarPartAnimation.adoptNS([[ScrollbarPartAnimation alloc] initWithScrollbarPainter:scrollerPainter
 425                                                                     part:part
 426                                                                     scrollAnimator:_animator
 427                                                                     animateAlphaTo:newAlpha
 428                                                                     duration:duration]);
 429     [scrollbarPartAnimation.get() setAnimationBlockingMode:NSAnimationNonblocking];
 430     [scrollbarPartAnimation.get() startAnimation];
 431     [NSAnimationContext endGrouping];
 432 }
 433
 434 - (void)scrollerImp:(id)scrollerImp animateKnobAlphaTo:(CGFloat)newKnobAlpha duration:(NSTimeInterval)duration
 435 {
 436     if (!_animator)
 437         return;
 438
 439     WKScrollbarPainterRef scrollerPainter = (WKScrollbarPainterRef)scrollerImp;
 440     if (wkScrollbarPainterIsHorizontal(scrollerPainter))
 441         [self setUpAnimation:_horizontalKnobAnimation scrollerPainter:scrollerPainter part:WebCore::ThumbPart animateAlphaTo:newKnobAlpha duration:duration];
 442     else
 443         [self setUpAnimation:_verticalKnobAnimation scrollerPainter:scrollerPainter part:WebCore::ThumbPart animateAlphaTo:newKnobAlpha duration:duration];
 444 }
 445
 446 - (void)scrollerImp:(id)scrollerImp animateTrackAlphaTo:(CGFloat)newTrackAlpha duration:(NSTimeInterval)duration
 447 {
 448     if (!_animator)
 449         return;
 450
 451     WKScrollbarPainterRef scrollerPainter = (WKScrollbarPainterRef)scrollerImp;
 452     if (wkScrollbarPainterIsHorizontal(scrollerPainter))
 453         [self setUpAnimation:_horizontalTrackAnimation scrollerPainter:scrollerPainter part:WebCore::BackTrackPart animateAlphaTo:newTrackAlpha duration:duration];
 454     else
 455         [self setUpAnimation:_verticalTrackAnimation scrollerPainter:scrollerPainter part:WebCore::BackTrackPart animateAlphaTo:newTrackAlpha duration:duration];
 456 }
 457
 458 - (void)scrollerImp:(id)scrollerImp overlayScrollerStateChangedTo:(NSUInteger)newOverlayScrollerState
 459 {
 460     UNUSED_PARAM(scrollerImp);
 461     UNUSED_PARAM(newOverlayScrollerState);
 462 }
 463
 464 - (void)scrollAnimatorDestroyed
 465 {
 466     _animator = 0;
 467     [_verticalKnobAnimation.get() scrollAnimatorDestroyed];
 468     [_horizontalKnobAnimation.get() scrollAnimatorDestroyed];
 469     [_verticalTrackAnimation.get() scrollAnimatorDestroyed];
 470     [_horizontalTrackAnimation.get() scrollAnimatorDestroyed];
 471 }
 472
 473 @end
 474
 475 #endif // USE(WK_SCROLLBAR_PAINTER)
 476
 477 namespace WebCore {
 478
 479 PassOwnPtr<ScrollAnimator> ScrollAnimator::create(ScrollableArea* scrollableArea)
 480 {
 481     return adoptPtr(new ScrollAnimatorMac(scrollableArea));
 482 }
 483
 484 ScrollAnimatorMac::ScrollAnimatorMac(ScrollableArea* scrollableArea)
 485     : ScrollAnimator(scrollableArea)
 486 #if USE(WK_SCROLLBAR_PAINTER)
 487     , m_initialScrollbarPaintTimer(this, &ScrollAnimatorMac::initialScrollbarPaintTimerFired)
 488 #endif
 489 #if ENABLE(RUBBER_BANDING)
 490     , m_inScrollGesture(false)
 491     , m_momentumScrollInProgress(false)
 492     , m_ignoreMomentumScrolls(false)
 493     , m_lastMomemtumScrollTimestamp(0)
 494     , m_startTime(0)
 495     , m_snapRubberBandTimer(this, &ScrollAnimatorMac::snapRubberBandTimerFired)
 496 #endif
 497     , m_drawingIntoLayer(false)
 498     , m_haveScrolledSincePageLoad(false)
 499 {
 500     m_scrollAnimationHelperDelegate.adoptNS([[ScrollAnimationHelperDelegate alloc] initWithScrollAnimator:this]);
 501     m_scrollAnimationHelper.adoptNS([[NSClassFromString(@"NSScrollAnimationHelper") alloc] initWithDelegate:m_scrollAnimationHelperDelegate.get()]);
 502
 503 #if USE(WK_SCROLLBAR_PAINTER)
 504     m_scrollbarPainterControllerDelegate.adoptNS([[ScrollbarPainterControllerDelegate alloc] initWithScrollAnimator:this]);
 505     m_scrollbarPainterController = wkMakeScrollbarPainterController(m_scrollbarPainterControllerDelegate.get());
 506     m_scrollbarPainterDelegate.adoptNS([[ScrollbarPainterDelegate alloc] initWithScrollAnimator:this]);
 507 #endif
 508 }
 509
 510 ScrollAnimatorMac::~ScrollAnimatorMac()
 511 {
 512 #if USE(WK_SCROLLBAR_PAINTER)
 513     [m_scrollbarPainterControllerDelegate.get() scrollAnimatorDestroyed];
 514     [(id)m_scrollbarPainterController.get() setDelegate:nil];
 515     [m_scrollbarPainterDelegate.get() scrollAnimatorDestroyed];
 516     [m_scrollAnimationHelperDelegate.get() scrollAnimatorDestroyed];
 517 #endif
 518 }
 519
 520 bool ScrollAnimatorMac::scroll(ScrollbarOrientation orientation, ScrollGranularity granularity, float step, float multiplier)
 521 {
 522     m_haveScrolledSincePageLoad = true;
 523
 524     if (![[NSUserDefaults standardUserDefaults] boolForKey:@"AppleScrollAnimationEnabled"])
 525         return ScrollAnimator::scroll(orientation, granularity, step, multiplier);
 526
 527     if (granularity == ScrollByPixel)
 528         return ScrollAnimator::scroll(orientation, granularity, step, multiplier);
 529
 530     float currentPos = orientation == HorizontalScrollbar ? m_currentPosX : m_currentPosY;
 531     float newPos = std::max<float>(std::min<float>(currentPos + (step * multiplier), static_cast<float>(m_scrollableArea->scrollSize(orientation))), 0);
 532     if (currentPos == newPos)
 533         return false;
 534
 535     NSPoint newPoint;
 536     if ([m_scrollAnimationHelper.get() _isAnimating]) {
 537         NSPoint targetOrigin = [m_scrollAnimationHelper.get() targetOrigin];
 538         newPoint = orientation == HorizontalScrollbar ? NSMakePoint(newPos, targetOrigin.y) : NSMakePoint(targetOrigin.x, newPos);
 539     } else
 540         newPoint = orientation == HorizontalScrollbar ? NSMakePoint(newPos, m_currentPosY) : NSMakePoint(m_currentPosX, newPos);
 541
 542     [m_scrollAnimationHelper.get() scrollToPoint:newPoint];
 543     return true;
 544 }
 545
 546 void ScrollAnimatorMac::scrollToOffsetWithoutAnimation(const FloatPoint& offset)
 547 {
 548     [m_scrollAnimationHelper.get() _stopRun];
 549     immediateScrollToPoint(offset);
 550 }
 551
 552 float ScrollAnimatorMac::adjustScrollXPositionIfNecessary(float position) const
 553 {
 554     if (!m_scrollableArea->constrainsScrollingToContentEdge())
 555         return position;
 556
 557     return max<float>(min<float>(position, m_scrollableArea->contentsSize().width() - m_scrollableArea->visibleWidth()), 0);
 558 }
 559
 560 float ScrollAnimatorMac::adjustScrollYPositionIfNecessary(float position) const
 561 {
 562     if (!m_scrollableArea->constrainsScrollingToContentEdge())
 563         return position;
 564
 565     return max<float>(min<float>(position, m_scrollableArea->contentsSize().height() - m_scrollableArea->visibleHeight()), 0);
 566 }
 567
 568 FloatPoint ScrollAnimatorMac::adjustScrollPositionIfNecessary(const FloatPoint& position) const
 569 {
 570     if (!m_scrollableArea->constrainsScrollingToContentEdge())
 571         return position;
 572
 573     float newX = max<float>(min<float>(position.x(), m_scrollableArea->contentsSize().width() - m_scrollableArea->visibleWidth()), 0);
 574     float newY = max<float>(min<float>(position.y(), m_scrollableArea->contentsSize().height() - m_scrollableArea->visibleHeight()), 0);
 575
 576     return FloatPoint(newX, newY);
 577 }
 578
 579 void ScrollAnimatorMac::immediateScrollToPoint(const FloatPoint& newPosition)
 580 {
 581     FloatPoint adjustedPosition = adjustScrollPositionIfNecessary(newPosition);
 582
 583     if (adjustedPosition.x() == m_currentPosX && adjustedPosition.y() == m_currentPosY)
 584         return;
 585
 586     m_currentPosX = adjustedPosition.x();
 587     m_currentPosY = adjustedPosition.y();
 588     notityPositionChanged();
 589 }
 590
 591 void ScrollAnimatorMac::immediateScrollByDeltaX(float deltaX)
 592 {
 593     float newPosX = adjustScrollXPositionIfNecessary(m_currentPosX + deltaX);
 594
 595     if (newPosX == m_currentPosX)
 596         return;
 597
 598     m_currentPosX = newPosX;
 599     notityPositionChanged();
 600 }
 601
 602 void ScrollAnimatorMac::immediateScrollByDeltaY(float deltaY)
 603 {
 604     float newPosY = adjustScrollYPositionIfNecessary(m_currentPosY + deltaY);
 605
 606     if (newPosY == m_currentPosY)
 607         return;
 608
 609     m_currentPosY = newPosY;
 610     notityPositionChanged();
 611 }
 612
 613 void ScrollAnimatorMac::notityPositionChanged()
 614 {
 615 #if USE(WK_SCROLLBAR_PAINTER)
 616     wkContentAreaScrolled(m_scrollbarPainterController.get());
 617 #endif
 618     ScrollAnimator::notityPositionChanged();
 619 }
 620
 621 void ScrollAnimatorMac::contentAreaWillPaint() const
 622 {
 623 #if USE(WK_SCROLLBAR_PAINTER)
 624     wkContentAreaWillPaint(m_scrollbarPainterController.get());
 625 #endif
 626 }
 627
 628 void ScrollAnimatorMac::mouseEnteredContentArea() const
 629 {
 630 #if USE(WK_SCROLLBAR_PAINTER)
 631     wkMouseEnteredContentArea(m_scrollbarPainterController.get());
 632 #endif
 633 }
 634
 635 void ScrollAnimatorMac::mouseExitedContentArea() const
 636 {
 637 #if USE(WK_SCROLLBAR_PAINTER)
 638     wkMouseExitedContentArea(m_scrollbarPainterController.get());
 639 #endif
 640 }
 641
 642 void ScrollAnimatorMac::mouseMovedInContentArea() const
 643 {
 644 #if USE(WK_SCROLLBAR_PAINTER)
 645     wkMouseMovedInContentArea(m_scrollbarPainterController.get());
 646 #endif
 647 }
 648
 649 void ScrollAnimatorMac::willStartLiveResize()
 650 {
 651 #if USE(WK_SCROLLBAR_PAINTER)
 652     wkWillStartLiveResize(m_scrollbarPainterController.get());
 653 #endif
 654 }
 655
 656 void ScrollAnimatorMac::contentsResized() const
 657 {
 658 #if USE(WK_SCROLLBAR_PAINTER)
 659     wkContentAreaResized(m_scrollbarPainterController.get());
 660 #endif
 661 }
 662
 663 void ScrollAnimatorMac::willEndLiveResize()
 664 {
 665 #if USE(WK_SCROLLBAR_PAINTER)
 666     wkWillEndLiveResize(m_scrollbarPainterController.get());
 667 #endif
 668 }
 669
 670 void ScrollAnimatorMac::contentAreaDidShow() const
 671 {
 672 #if USE(WK_SCROLLBAR_PAINTER)
 673     wkContentAreaDidShow(m_scrollbarPainterController.get());
 674 #endif
 675 }
 676
 677 void ScrollAnimatorMac::contentAreaDidHide() const
 678 {
 679 #if USE(WK_SCROLLBAR_PAINTER)
 680     wkContentAreaDidHide(m_scrollbarPainterController.get());
 681 #endif
 682 }
 683
 684 void ScrollAnimatorMac::didBeginScrollGesture() const
 685 {
 686 #if USE(WK_SCROLLBAR_PAINTER)
 687     wkDidBeginScrollGesture(m_scrollbarPainterController.get());
 688 #endif
 689 }
 690
 691 void ScrollAnimatorMac::didEndScrollGesture() const
 692 {
 693 #if USE(WK_SCROLLBAR_PAINTER)
 694     wkDidEndScrollGesture(m_scrollbarPainterController.get());
 695 #endif
 696 }
 697
 698 void ScrollAnimatorMac::didAddVerticalScrollbar(Scrollbar* scrollbar)
 699 {
 700 #if USE(WK_SCROLLBAR_PAINTER)
 701     WKScrollbarPainterRef painter = static_cast<WebCore::ScrollbarThemeMac*>(WebCore::ScrollbarTheme::nativeTheme())->painterForScrollbar(scrollbar);
 702     wkScrollbarPainterSetDelegate(painter, m_scrollbarPainterDelegate.get());
 703     wkSetPainterForPainterController(m_scrollbarPainterController.get(), painter, false);
 704     if (scrollableArea()->inLiveResize())
 705         wkSetScrollbarPainterKnobAlpha(painter, 1);
 706 #else
 707     UNUSED_PARAM(scrollbar);
 708 #endif
 709 }
 710
 711 void ScrollAnimatorMac::willRemoveVerticalScrollbar(Scrollbar* scrollbar)
 712 {
 713 #if USE(WK_SCROLLBAR_PAINTER)
 714     WKScrollbarPainterRef painter = static_cast<WebCore::ScrollbarThemeMac*>(WebCore::ScrollbarTheme::nativeTheme())->painterForScrollbar(scrollbar);
 715     wkScrollbarPainterSetDelegate(painter, nil);
 716     wkSetPainterForPainterController(m_scrollbarPainterController.get(), nil, false);
 717 #else
 718     UNUSED_PARAM(scrollbar);
 719 #endif
 720 }
 721
 722 void ScrollAnimatorMac::didAddHorizontalScrollbar(Scrollbar* scrollbar)
 723 {
 724 #if USE(WK_SCROLLBAR_PAINTER)
 725     WKScrollbarPainterRef painter = static_cast<WebCore::ScrollbarThemeMac*>(WebCore::ScrollbarTheme::nativeTheme())->painterForScrollbar(scrollbar);
 726     wkScrollbarPainterSetDelegate(painter, m_scrollbarPainterDelegate.get());
 727     wkSetPainterForPainterController(m_scrollbarPainterController.get(), painter, true);
 728     if (scrollableArea()->inLiveResize())
 729         wkSetScrollbarPainterKnobAlpha(painter, 1);
 730 #else
 731     UNUSED_PARAM(scrollbar);
 732 #endif
 733 }
 734
 735 void ScrollAnimatorMac::willRemoveHorizontalScrollbar(Scrollbar* scrollbar)
 736 {
 737 #if USE(WK_SCROLLBAR_PAINTER)
 738     WKScrollbarPainterRef painter = static_cast<WebCore::ScrollbarThemeMac*>(WebCore::ScrollbarTheme::nativeTheme())->painterForScrollbar(scrollbar);
 739     wkScrollbarPainterSetDelegate(painter, nil);
 740     wkSetPainterForPainterController(m_scrollbarPainterController.get(), nil, true);
 741 #else
 742     UNUSED_PARAM(scrollbar);
 743 #endif
 744 }
 745
 746 void ScrollAnimatorMac::cancelAnimations()
 747 {
 748     m_haveScrolledSincePageLoad = false;
 749
 750 #if USE(WK_SCROLLBAR_PAINTER)
 751     if (scrollbarPaintTimerIsActive())
 752         stopScrollbarPaintTimer();
 753     [m_scrollbarPainterDelegate.get() cancelAnimations];
 754 #endif
 755 }
 756
 757 #if ENABLE(RUBBER_BANDING)
 758
 759 static const float scrollVelocityZeroingTimeout = 0.10f;
 760 static const float rubberbandStiffness = 20;
 761 static const float rubberbandDirectionLockStretchRatio = 1;
 762 static const float rubberbandMinimumRequiredDeltaBeforeStretch = 10;
 763 static const float rubberbandAmplitude = 0.31f;
 764 static const float rubberbandPeriod = 1.6f;
 765
 766 static float elasticDeltaForTimeDelta(float initialPosition, float initialVelocity, float elapsedTime)
 767 {
 768     float amplitude = rubberbandAmplitude;
 769     float period = rubberbandPeriod;
 770     float criticalDampeningFactor = expf((-elapsedTime * rubberbandStiffness) / period);
 771
 772     return (initialPosition + (-initialVelocity * elapsedTime * amplitude)) * criticalDampeningFactor;
 773 }
 774
 775 static float elasticDeltaForReboundDelta(float delta)
 776 {
 777     float stiffness = std::max(rubberbandStiffness, 1.0f);
 778     return delta / stiffness;
 779 }
 780
 781 static float reboundDeltaForElasticDelta(float delta)
 782 {
 783     return delta * rubberbandStiffness;
 784 }
 785
 786 static float scrollWheelMultiplier()
 787 {
 788     static float multiplier = -1;
 789     if (multiplier < 0) {
 790         multiplier = [[NSUserDefaults standardUserDefaults] floatForKey:@"NSScrollWheelMultiplier"];
 791         if (multiplier <= 0)
 792             multiplier = 1;
 793     }
 794     return multiplier;
 795 }
 796
 797 void ScrollAnimatorMac::handleWheelEvent(PlatformWheelEvent& wheelEvent)
 798 {
 799     m_haveScrolledSincePageLoad = true;
 800
 801     if (!wheelEvent.hasPreciseScrollingDeltas()) {
 802         ScrollAnimator::handleWheelEvent(wheelEvent);
 803         return;
 804     }
 805
 806     // FIXME: This is somewhat roundabout hack to allow forwarding wheel events
 807     // up to the parent scrollable area. It takes advantage of the fact that
 808     // the base class implemenatation of handleWheelEvent will not accept the
 809     // wheel event if there is nowhere to scroll.
 810     if (fabsf(wheelEvent.deltaY()) >= fabsf(wheelEvent.deltaX())) {
 811         if (!allowsVerticalStretching()) {
 812             ScrollAnimator::handleWheelEvent(wheelEvent);
 813             return;
 814         }
 815     } else {
 816         if (!allowsHorizontalStretching()) {
 817             ScrollAnimator::handleWheelEvent(wheelEvent);
 818             return;
 819         }
 820     }
 821
 822     wheelEvent.accept();
 823
 824     bool isMometumScrollEvent = (wheelEvent.momentumPhase() != PlatformWheelEventPhaseNone);
 825     if (m_ignoreMomentumScrolls && (isMometumScrollEvent || m_snapRubberBandTimer.isActive())) {
 826         if (wheelEvent.momentumPhase() == PlatformWheelEventPhaseEnded)
 827             m_ignoreMomentumScrolls = false;
 828         return;
 829     }
 830
 831     smoothScrollWithEvent(wheelEvent);
 832 }
 833
 834 void ScrollAnimatorMac::handleGestureEvent(const PlatformGestureEvent& gestureEvent)
 835 {
 836     if (gestureEvent.type() == PlatformGestureEvent::ScrollBeginType)
 837         beginScrollGesture();
 838     else
 839         endScrollGesture();
 840 }
 841
 842 bool ScrollAnimatorMac::pinnedInDirection(float deltaX, float deltaY)
 843 {
 844     FloatSize limitDelta;
 845     if (fabsf(deltaY) >= fabsf(deltaX)) {
 846         if (deltaY < 0) {
 847             // We are trying to scroll up.  Make sure we are not pinned to the top
 848             limitDelta.setHeight(m_scrollableArea->visibleContentRect().y() + + m_scrollableArea->scrollOrigin().y());
 849         } else {
 850             // We are trying to scroll down.  Make sure we are not pinned to the bottom
 851             limitDelta.setHeight(m_scrollableArea->contentsSize().height() - (m_scrollableArea->visibleContentRect().maxY() + m_scrollableArea->scrollOrigin().y()));
 852         }
 853     } else if (deltaX != 0) {
 854         if (deltaX < 0) {
 855             // We are trying to scroll left.  Make sure we are not pinned to the left
 856             limitDelta.setWidth(m_scrollableArea->visibleContentRect().x() + m_scrollableArea->scrollOrigin().x());
 857         } else {
 858             // We are trying to scroll right.  Make sure we are not pinned to the right
 859             limitDelta.setWidth(m_scrollableArea->contentsSize().width() - (m_scrollableArea->visibleContentRect().maxX() + m_scrollableArea->scrollOrigin().x()));
 860         }
 861     }
 862
 863     if ((deltaX != 0 || deltaY != 0) && (limitDelta.width() < 1 && limitDelta.height() < 1))
 864         return true;
 865     return false;
 866 }
 867
 868 bool ScrollAnimatorMac::allowsVerticalStretching() const
 869 {
 870     switch (m_scrollableArea->verticalScrollElasticity()) {
 871     case ScrollElasticityAutomatic: {
 872         Scrollbar* hScroller = m_scrollableArea->horizontalScrollbar();
 873         Scrollbar* vScroller = m_scrollableArea->verticalScrollbar();
 874         return (((vScroller && vScroller->enabled()) || (!hScroller || !hScroller->enabled())));
 875     }
 876     case ScrollElasticityNone:
 877         return false;
 878     case ScrollElasticityAllowed:
 879         return true;
 880     }
 881
 882     ASSERT_NOT_REACHED();
 883     return false;
 884 }
 885
 886 bool ScrollAnimatorMac::allowsHorizontalStretching() const
 887 {
 888     switch (m_scrollableArea->horizontalScrollElasticity()) {
 889     case ScrollElasticityAutomatic: {
 890         Scrollbar* hScroller = m_scrollableArea->horizontalScrollbar();
 891         Scrollbar* vScroller = m_scrollableArea->verticalScrollbar();
 892         return (((hScroller && hScroller->enabled()) || (!vScroller || !vScroller->enabled())));
 893     }
 894     case ScrollElasticityNone:
 895         return false;
 896     case ScrollElasticityAllowed:
 897         return true;
 898     }
 899
 900     ASSERT_NOT_REACHED();
 901     return false;
 902 }
 903
 904 void ScrollAnimatorMac::smoothScrollWithEvent(PlatformWheelEvent& wheelEvent)
 905 {
 906     m_haveScrolledSincePageLoad = true;
 907
 908     float deltaX = m_overflowScrollDelta.width();
 909     float deltaY = m_overflowScrollDelta.height();
 910
 911     // Reset overflow values because we may decide to remove delta at various points and put it into overflow.
 912     m_overflowScrollDelta = FloatSize();
 913
 914     float eventCoallescedDeltaX = -wheelEvent.deltaX();
 915     float eventCoallescedDeltaY = -wheelEvent.deltaY();
 916
 917     deltaX += eventCoallescedDeltaX;
 918     deltaY += eventCoallescedDeltaY;
 919
 920     // Slightly prefer scrolling vertically by applying the = case to deltaY
 921     if (fabsf(deltaY) >= fabsf(deltaX))
 922         deltaX = 0;
 923     else
 924         deltaY = 0;
 925
 926     bool isVerticallyStretched = false;
 927     bool isHorizontallyStretched = false;
 928     bool shouldStretch = false;
 929
 930     IntSize stretchAmount = m_scrollableArea->overhangAmount();
 931
 932     isHorizontallyStretched = stretchAmount.width();
 933     isVerticallyStretched = stretchAmount.height();
 934
 935     PlatformWheelEventPhase phase = wheelEvent.momentumPhase();
 936
 937     // If we are starting momentum scrolling then do some setup.
 938     if (!m_momentumScrollInProgress && (phase == PlatformWheelEventPhaseBegan || phase == PlatformWheelEventPhaseChanged))
 939         m_momentumScrollInProgress = true;
 940
 941     CFTimeInterval timeDelta = wheelEvent.timestamp() - m_lastMomemtumScrollTimestamp;
 942     if (m_inScrollGesture || m_momentumScrollInProgress) {
 943         if (m_lastMomemtumScrollTimestamp && timeDelta > 0 && timeDelta < scrollVelocityZeroingTimeout) {
 944             m_momentumVelocity.setWidth(eventCoallescedDeltaX / (float)timeDelta);
 945             m_momentumVelocity.setHeight(eventCoallescedDeltaY / (float)timeDelta);
 946             m_lastMomemtumScrollTimestamp = wheelEvent.timestamp();
 947         } else {
 948             m_lastMomemtumScrollTimestamp = wheelEvent.timestamp();
 949             m_momentumVelocity = FloatSize();
 950         }
 951
 952         if (isVerticallyStretched) {
 953             if (!isHorizontallyStretched && pinnedInDirection(deltaX, 0)) {
 954                 // Stretching only in the vertical.
 955                 if (deltaY != 0 && (fabsf(deltaX / deltaY) < rubberbandDirectionLockStretchRatio))
 956                     deltaX = 0;
 957                 else if (fabsf(deltaX) < rubberbandMinimumRequiredDeltaBeforeStretch) {
 958                     m_overflowScrollDelta.setWidth(m_overflowScrollDelta.width() + deltaX);
 959                     deltaX = 0;
 960                 } else
 961                     m_overflowScrollDelta.setWidth(m_overflowScrollDelta.width() + deltaX);
 962             }
 963         } else if (isHorizontallyStretched) {
 964             // Stretching only in the horizontal.
 965             if (pinnedInDirection(0, deltaY)) {
 966                 if (deltaX != 0 && (fabsf(deltaY / deltaX) < rubberbandDirectionLockStretchRatio))
 967                     deltaY = 0;
 968                 else if (fabsf(deltaY) < rubberbandMinimumRequiredDeltaBeforeStretch) {
 969                     m_overflowScrollDelta.setHeight(m_overflowScrollDelta.height() + deltaY);
 970                     deltaY = 0;
 971                 } else
 972                     m_overflowScrollDelta.setHeight(m_overflowScrollDelta.height() + deltaY);
 973             }
 974         } else {
 975             // Not stretching at all yet.
 976             if (pinnedInDirection(deltaX, deltaY)) {
 977                 if (fabsf(deltaY) >= fabsf(deltaX)) {
 978                     if (fabsf(deltaX) < rubberbandMinimumRequiredDeltaBeforeStretch) {
 979                         m_overflowScrollDelta.setWidth(m_overflowScrollDelta.width() + deltaX);
 980                         deltaX = 0;
 981                     } else
 982                         m_overflowScrollDelta.setWidth(m_overflowScrollDelta.width() + deltaX);
 983                 }
 984                 shouldStretch = true;
 985             }
 986         }
 987     }
 988
 989     if (deltaX != 0 || deltaY != 0) {
 990         if (!(shouldStretch || isVerticallyStretched || isHorizontallyStretched)) {
 991             if (deltaY != 0) {
 992                 deltaY *= scrollWheelMultiplier();
 993                 immediateScrollByDeltaY(deltaY);
 994             }
 995             if (deltaX != 0) {
 996                 deltaX *= scrollWheelMultiplier();
 997                 immediateScrollByDeltaX(deltaX);
 998             }
 999         } else {
1000             if (!allowsHorizontalStretching()) {
1001                 deltaX = 0;
1002                 eventCoallescedDeltaX = 0;
1003             } else if ((deltaX != 0) && !isHorizontallyStretched && !pinnedInDirection(deltaX, 0)) {
1004                 deltaX *= scrollWheelMultiplier();
1005
1006                 m_scrollableArea->setConstrainsScrollingToContentEdge(false);
1007                 immediateScrollByDeltaX(deltaX);
1008                 m_scrollableArea->setConstrainsScrollingToContentEdge(true);
1009
1010                 deltaX = 0;
1011             }
1012
1013             if (!allowsVerticalStretching()) {
1014                 deltaY = 0;
1015                 eventCoallescedDeltaY = 0;
1016             } else if ((deltaY != 0) && !isVerticallyStretched && !pinnedInDirection(0, deltaY)) {
1017                 deltaY *= scrollWheelMultiplier();
1018
1019                 m_scrollableArea->setConstrainsScrollingToContentEdge(false);
1020                 immediateScrollByDeltaY(deltaY);
1021                 m_scrollableArea->setConstrainsScrollingToContentEdge(true);
1022
1023                 deltaY = 0;
1024             }
1025
1026             IntSize stretchAmount = m_scrollableArea->overhangAmount();
1027
1028             if (m_momentumScrollInProgress) {
1029                 if ((pinnedInDirection(eventCoallescedDeltaX, eventCoallescedDeltaY) || (fabsf(eventCoallescedDeltaX) + fabsf(eventCoallescedDeltaY) <= 0)) && m_lastMomemtumScrollTimestamp) {
1030                     m_ignoreMomentumScrolls = true;
1031                     m_momentumScrollInProgress = false;
1032                     snapRubberBand();
1033                 }
1034             }
1035
1036             m_stretchScrollForce.setWidth(m_stretchScrollForce.width() + deltaX);
1037             m_stretchScrollForce.setHeight(m_stretchScrollForce.height() + deltaY);
1038
1039             FloatSize dampedDelta(ceilf(elasticDeltaForReboundDelta(m_stretchScrollForce.width())), ceilf(elasticDeltaForReboundDelta(m_stretchScrollForce.height())));
1040             FloatPoint origOrigin = (m_scrollableArea->visibleContentRect().location() + m_scrollableArea->scrollOrigin()) - stretchAmount;
1041             FloatPoint newOrigin = origOrigin + dampedDelta;
1042
1043             if (origOrigin != newOrigin) {
1044                 m_scrollableArea->setConstrainsScrollingToContentEdge(false);
1045                 immediateScrollToPoint(newOrigin);
1046                 m_scrollableArea->setConstrainsScrollingToContentEdge(true);
1047             }
1048         }
1049     }
1050
1051     if (m_momentumScrollInProgress && phase == PlatformWheelEventPhaseEnded) {
1052         m_momentumScrollInProgress = false;
1053         m_ignoreMomentumScrolls = false;
1054         m_lastMomemtumScrollTimestamp = 0;
1055     }
1056 }
1057
1058 void ScrollAnimatorMac::beginScrollGesture()
1059 {
1060     didBeginScrollGesture();
1061
1062     m_haveScrolledSincePageLoad = true;
1063     m_inScrollGesture = true;
1064     m_momentumScrollInProgress = false;
1065     m_ignoreMomentumScrolls = false;
1066     m_lastMomemtumScrollTimestamp = 0;
1067     m_momentumVelocity = FloatSize();
1068
1069     IntSize stretchAmount = m_scrollableArea->overhangAmount();
1070     m_stretchScrollForce.setWidth(reboundDeltaForElasticDelta(stretchAmount.width()));
1071     m_stretchScrollForce.setHeight(reboundDeltaForElasticDelta(stretchAmount.height()));
1072
1073     m_overflowScrollDelta = FloatSize();
1074
1075     if (m_snapRubberBandTimer.isActive())
1076         m_snapRubberBandTimer.stop();
1077 }
1078
1079 void ScrollAnimatorMac::endScrollGesture()
1080 {
1081     didEndScrollGesture();
1082
1083     snapRubberBand();
1084 }
1085
1086 void ScrollAnimatorMac::snapRubberBand()
1087 {
1088     CFTimeInterval timeDelta = [[NSProcessInfo processInfo] systemUptime] - m_lastMomemtumScrollTimestamp;
1089     if (m_lastMomemtumScrollTimestamp && timeDelta >= scrollVelocityZeroingTimeout)
1090         m_momentumVelocity = FloatSize();
1091
1092     m_inScrollGesture = false;
1093
1094     if (m_snapRubberBandTimer.isActive())
1095         return;
1096
1097     m_startTime = [NSDate timeIntervalSinceReferenceDate];
1098     m_startStretch = FloatSize();
1099     m_origOrigin = FloatPoint();
1100     m_origVelocity = FloatSize();
1101
1102     m_snapRubberBandTimer.startRepeating(1.0/60.0);
1103 }
1104
1105 static inline float roundTowardZero(float num)
1106 {
1107     return num > 0 ? ceilf(num - 0.5f) : floorf(num + 0.5f);
1108 }
1109
1110 static inline float roundToDevicePixelTowardZero(float num)
1111 {
1112     float roundedNum = roundf(num);
1113     if (fabs(num - roundedNum) < 0.125)
1114         num = roundedNum;
1115
1116     return roundTowardZero(num);
1117 }
1118
1119 void ScrollAnimatorMac::snapRubberBandTimerFired(Timer<ScrollAnimatorMac>*)
1120 {
1121     if (!m_momentumScrollInProgress || m_ignoreMomentumScrolls) {
1122         CFTimeInterval timeDelta = [NSDate timeIntervalSinceReferenceDate] - m_startTime;
1123
1124         if (m_startStretch == FloatSize()) {
1125             m_startStretch = m_scrollableArea->overhangAmount();
1126             if (m_startStretch == FloatSize()) {
1127                 m_snapRubberBandTimer.stop();
1128                 m_stretchScrollForce = FloatSize();
1129                 m_startTime = 0;
1130                 m_startStretch = FloatSize();
1131                 m_origOrigin = FloatPoint();
1132                 m_origVelocity = FloatSize();
1133
1134                 return;
1135             }
1136
1137             m_origOrigin = (m_scrollableArea->visibleContentRect().location() + m_scrollableArea->scrollOrigin()) - m_startStretch;
1138             m_origVelocity = m_momentumVelocity;
1139
1140             // Just like normal scrolling, prefer vertical rubberbanding
1141             if (fabsf(m_origVelocity.height()) >= fabsf(m_origVelocity.width()))
1142                 m_origVelocity.setWidth(0);
1143
1144             // Don't rubber-band horizontally if it's not possible to scroll horizontally
1145             Scrollbar* hScroller = m_scrollableArea->horizontalScrollbar();
1146             if (!hScroller || !hScroller->enabled())
1147                 m_origVelocity.setWidth(0);
1148
1149             // Don't rubber-band vertically if it's not possible to scroll horizontally
1150             Scrollbar* vScroller = m_scrollableArea->verticalScrollbar();
1151             if (!vScroller || !vScroller->enabled())
1152                 m_origVelocity.setHeight(0);
1153         }
1154
1155         FloatPoint delta(roundToDevicePixelTowardZero(elasticDeltaForTimeDelta(m_startStretch.width(), -m_origVelocity.width(), (float)timeDelta)),
1156                          roundToDevicePixelTowardZero(elasticDeltaForTimeDelta(m_startStretch.height(), -m_origVelocity.height(), (float)timeDelta)));
1157
1158         if (fabs(delta.x()) >= 1 || fabs(delta.y()) >= 1) {
1159             FloatPoint newOrigin = m_origOrigin + delta;
1160
1161             m_scrollableArea->setConstrainsScrollingToContentEdge(false);
1162             immediateScrollToPoint(newOrigin);
1163             m_scrollableArea->setConstrainsScrollingToContentEdge(true);
1164
1165             FloatSize newStretch = m_scrollableArea->overhangAmount();
1166
1167             m_stretchScrollForce.setWidth(reboundDeltaForElasticDelta(newStretch.width()));
1168             m_stretchScrollForce.setHeight(reboundDeltaForElasticDelta(newStretch.height()));
1169         } else {
1170             immediateScrollToPoint(m_origOrigin);
1171
1172             m_scrollableArea->didCompleteRubberBand(roundedIntSize(m_startStretch));
1173
1174             m_snapRubberBandTimer.stop();
1175             m_stretchScrollForce = FloatSize();
1176
1177             m_startTime = 0;
1178             m_startStretch = FloatSize();
1179             m_origOrigin = FloatPoint();
1180             m_origVelocity = FloatSize();
1181         }
1182     } else {
1183         m_startTime = [NSDate timeIntervalSinceReferenceDate];
1184         m_startStretch = FloatSize();
1185     }
1186 }
1187 #endif
1188
1189 #if USE(WK_SCROLLBAR_PAINTER)
1190 void ScrollAnimatorMac::startScrollbarPaintTimer()
1191 {
1192     m_initialScrollbarPaintTimer.startOneShot(0.1);
1193 }
1194
1195 bool ScrollAnimatorMac::scrollbarPaintTimerIsActive() const
1196 {
1197     return m_initialScrollbarPaintTimer.isActive();
1198 }
1199
1200 void ScrollAnimatorMac::stopScrollbarPaintTimer()
1201 {
1202     m_initialScrollbarPaintTimer.stop();
1203 }
1204
1205 void ScrollAnimatorMac::initialScrollbarPaintTimerFired(Timer<ScrollAnimatorMac>*)
1206 {
1207     wkScrollbarPainterForceFlashScrollers(m_scrollbarPainterController.get());
1208 }
1209 #endif
1210
1211 } // namespace WebCore
1212
1213 #endif // ENABLE(SMOOTH_SCROLLING)