Merge 92002 - Scroll animation refinements.

Source/WebCore/platform/ScrollAnimatorNone.cpp

 /*
  * Copyright (c) 2011, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 26 matching lines @@
 #include "FloatPoint.h"
 #include "NotImplemented.h"
 #include "OwnArrayPtr.h"
 #include "ScrollableArea.h"
 #include "ScrollbarTheme.h"
 #include "TraceEvent.h"
 #include <algorithm>
 #include <wtf/CurrentTime.h>
 #include <wtf/PassOwnPtr.h>
 
+using namespace std;
+
 namespace WebCore {
 
 static double kTickTime = .0166;
 
 // This is used to set the timer delay - it needs to be slightly smaller than the tick count to leave some overhead.
 static double kAnimationTimerDelay = 0.015;
 
 PassOwnPtr<ScrollAnimator> ScrollAnimator::create(ScrollableArea* scrollableArea)
 {
     if (scrollableArea && scrollableArea->scrollAnimatorEnabled())
         return adoptPtr(new ScrollAnimatorNone(scrollableArea));
     return adoptPtr(new ScrollAnimator(scrollableArea));
 }
 
 ScrollAnimatorNone::Parameters::Parameters()
     : m_isEnabled(false)
 {
 }
 
-ScrollAnimatorNone::Parameters::Parameters(bool isEnabled, double animationTime, Curve attackCurve, double attackTime, Curve releaseCurve, double releaseTime)
+ScrollAnimatorNone::Parameters::Parameters(bool isEnabled, double animationTime, double repeatMinimumSustainTime, Curve attackCurve, double attackTime, Curve releaseCurve, double releaseTime)
     : m_isEnabled(isEnabled)
     , m_animationTime(animationTime)
+    , m_repeatMinimumSustainTime(repeatMinimumSustainTime)
     , m_attackCurve(attackCurve)
     , m_attackTime(attackTime)
     , m_releaseCurve(releaseCurve)
     , m_releaseTime(releaseTime)
 {
 }
 
 double ScrollAnimatorNone::PerAxisData::curveAt(Curve curve, double t)
 {
     switch (curve) {
@@ skipping 73 matching lines @@
     m_attackCurve = Quadratic;
 
     m_releasePosition = 0;
     m_releaseTime = 0;
     m_releaseCurve = Quadratic;
 }
 
 
 bool ScrollAnimatorNone::PerAxisData::updateDataFromParameters(ScrollbarOrientation orientation, float step, float multiplier, float scrollableSize, double currentTime, Parameters* parameters)
 {
-    m_animationTime = parameters->m_animationTime;
+    if (parameters->m_animationTime > m_animationTime)
+        m_animationTime = parameters->m_animationTime;
     m_attackTime = parameters->m_attackTime;
     m_releaseTime = parameters->m_releaseTime;
     m_attackCurve = parameters->m_attackCurve;
     m_releaseCurve = parameters->m_releaseCurve;
 
     // Prioritize our way out of over constraint.
     if (m_attackTime + m_releaseTime > m_animationTime) {
         if (m_releaseTime > m_animationTime)
             m_releaseTime = m_animationTime;
         m_attackTime = m_animationTime - m_releaseTime;
     }
 
     m_orientation = orientation;
 
-    if (!m_desiredPosition)
+    if (!m_startTime)
         m_desiredPosition = *m_currentPosition;
     float newPosition = m_desiredPosition + (step * multiplier);
 
     if (newPosition < 0 || newPosition > scrollableSize)
-        newPosition = std::max(std::min(newPosition, scrollableSize), 0.0f);
+        newPosition = max(min(newPosition, scrollableSize), 0.0f);
 
     if (newPosition == m_desiredPosition)
         return false;
 
     m_desiredPosition = newPosition;
 
     if (!m_startTime) {
         // FIXME: This should be the time from the event that got us here.
         m_startTime = currentTime - kTickTime / 2;
         m_startPosition = *m_currentPosition;
         m_lastAnimationTime = currentTime;
     }
     m_startVelocity = m_currentVelocity;
 
     double remainingDelta = m_desiredPosition - *m_currentPosition;
 
     double attackAreaLeft = 0;
 
     double deltaTime = m_lastAnimationTime - m_startTime;
+    double attackTimeLeft = max(0., m_attackTime - deltaTime);
     double timeLeft = m_animationTime - deltaTime;
-    if (timeLeft < m_releaseTime) {
-        m_animationTime = deltaTime + m_releaseTime;
-        timeLeft = m_releaseTime;
+    double minTimeLeft = m_releaseTime + min(parameters->m_repeatMinimumSustainTime, m_animationTime - m_releaseTime - attackTimeLeft);
+    if (timeLeft < minTimeLeft) {
+        m_animationTime = deltaTime + minTimeLeft;
+        timeLeft = minTimeLeft;
     }
-    double releaseTimeLeft = std::min(timeLeft, m_releaseTime);
-    double attackTimeLeft = std::max(0., m_attackTime - deltaTime);
-    double sustainTimeLeft = std::max(0., timeLeft - releaseTimeLeft - attackTimeLeft);
+
+    double releaseTimeLeft = min(timeLeft, m_releaseTime);
+    double sustainTimeLeft = max(0., timeLeft - releaseTimeLeft - attackTimeLeft);
 
     if (attackTimeLeft) {
         double attackSpot = deltaTime / m_attackTime;
         attackAreaLeft = attackTimeLeft / (curveDerivativeAt(m_attackCurve, 1) - curveDerivativeAt(m_attackCurve, attackSpot));
     }
 
     double releaseSpot = (m_releaseTime - releaseTimeLeft) / m_releaseTime;
     double releaseAreaLeft  = releaseTimeLeft / (curveDerivativeAt(m_releaseCurve, 1) - curveDerivativeAt(m_releaseCurve, releaseSpot));
 
     m_desiredVelocity = remainingDelta / (attackAreaLeft + sustainTimeLeft + releaseAreaLeft);
@@ skipping 62 matching lines @@
     if (!m_scrollableArea->scrollAnimatorEnabled())
         return ScrollAnimator::scroll(orientation, granularity, step, multiplier);
 
     // FIXME: get the type passed in. MouseWheel could also be by line, but should still have different
     // animation parameters than the keyboard.
     Parameters parameters;
     switch (granularity) {
     case ScrollByDocument:
         break;
     case ScrollByLine:
-        parameters = Parameters(true, 10 * kTickTime, Quadratic, 3 * kTickTime, Quadratic, 3 * kTickTime);
+        parameters = Parameters(true, 10 * kTickTime, 7 * kTickTime, Quadratic, 3 * kTickTime, Quadratic, 3 * kTickTime);
         break;
     case ScrollByPage:
-        parameters = Parameters(true, 15 * kTickTime, Quadratic, 5 * kTickTime, Quadratic, 5 * kTickTime);
+        parameters = Parameters(true, 15 * kTickTime, 10 * kTickTime, Quadratic, 5 * kTickTime, Quadratic, 5 * kTickTime);
         break;
     case ScrollByPixel:
-        parameters = Parameters(true, 11 * kTickTime, Quadratic, 3 * kTickTime, Quadratic, 3 * kTickTime);
+        parameters = Parameters(true, 11 * kTickTime, 2 * kTickTime, Quadratic, 3 * kTickTime, Quadratic, 3 * kTickTime);
         break;
     default:
         break;
     }
 
     // If the individual input setting is disabled, bail.
     if (!parameters.m_isEnabled)
         return ScrollAnimator::scroll(orientation, granularity, step, multiplier);
 
     // This is an animatable scroll. Calculate the scroll delta.
@@ skipping 41 matching lines @@
 
 void ScrollAnimatorNone::stopAnimationTimerIfNeeded(PerAxisData* data)
 {
     if (data->m_animationTimer.isActive())
         data->m_animationTimer.stop();
 }
 
 } // namespace WebCore
 
 #endif // ENABLE(SMOOTH_SCROLLING)