| /* |
| * Copyright (c) 2010, 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 |
| * copyright notice, this list of conditions and the following disclaimer |
| * in the documentation and/or other materials provided with the |
| * distribution. |
| * * Neither the name of Google Inc. nor the names of its |
| * contributors may be used to endorse or promote products derived from |
| * this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "config.h" |
| |
| #if ENABLE(SMOOTH_SCROLLING) |
| |
| #include "ScrollAnimatorWin.h" |
| |
| #include "FloatPoint.h" |
| #include "ScrollableArea.h" |
| #include "ScrollbarTheme.h" |
| #include <algorithm> |
| #include <wtf/CurrentTime.h> |
| #include <wtf/PassOwnPtr.h> |
| |
| namespace WebCore { |
| |
| PassOwnPtr<ScrollAnimator> ScrollAnimator::create(ScrollableArea* scrollableArea) |
| { |
| return adoptPtr(new ScrollAnimatorWin(scrollableArea)); |
| } |
| |
| const double ScrollAnimatorWin::animationTimerDelay = 0.01; |
| |
| ScrollAnimatorWin::PerAxisData::PerAxisData(ScrollAnimatorWin* parent, float* currentPos) |
| : m_currentPos(currentPos) |
| , m_desiredPos(0) |
| , m_currentVelocity(0) |
| , m_desiredVelocity(0) |
| , m_lastAnimationTime(0) |
| , m_animationTimer(parent, &ScrollAnimatorWin::animationTimerFired) |
| { |
| } |
| |
| |
| ScrollAnimatorWin::ScrollAnimatorWin(ScrollableArea* scrollableArea) |
| : ScrollAnimator(scrollableArea) |
| , m_horizontalData(this, &m_currentPosX) |
| , m_verticalData(this, &m_currentPosY) |
| { |
| } |
| |
| ScrollAnimatorWin::~ScrollAnimatorWin() |
| { |
| stopAnimationTimerIfNeeded(&m_horizontalData); |
| stopAnimationTimerIfNeeded(&m_verticalData); |
| } |
| |
| bool ScrollAnimatorWin::scroll(ScrollbarOrientation orientation, ScrollGranularity granularity, float step, float multiplier) |
| { |
| // Don't animate jumping to the beginning or end of the document. |
| if (granularity == ScrollByDocument) |
| return ScrollAnimator::scroll(orientation, granularity, step, multiplier); |
| |
| // This is an animatable scroll. Calculate the scroll delta. |
| PerAxisData* data = (orientation == VerticalScrollbar) ? &m_verticalData : &m_horizontalData; |
| float newPos = std::max(std::min(data->m_desiredPos + (step * multiplier), static_cast<float>(m_scrollableArea->scrollSize(orientation))), 0.0f); |
| if (newPos == data->m_desiredPos) |
| return false; |
| data->m_desiredPos = newPos; |
| |
| // Calculate the animation velocity. |
| if (*data->m_currentPos == data->m_desiredPos) |
| return false; |
| bool alreadyAnimating = data->m_animationTimer.isActive(); |
| // There are a number of different sources of scroll requests. We want to |
| // make both keyboard and wheel-generated scroll requests (which can come at |
| // unpredictable rates) and autoscrolling from holding down the mouse button |
| // on a scrollbar part (where the request rate can be obtained from the |
| // scrollbar theme) feel smooth, responsive, and similar. |
| // |
| // When autoscrolling, the scrollbar's autoscroll timer will call us to |
| // increment the desired position by |step| (with |multiplier| == 1) every |
| // ScrollbarTheme::nativeTheme()->autoscrollTimerDelay() seconds. If we set |
| // the desired velocity to exactly this rate, smooth scrolling will neither |
| // race ahead (and then have to slow down) nor increasingly lag behind, but |
| // will be smooth and synchronized. |
| // |
| // Note that because of the acceleration period, the current position in |
| // this case would lag the desired one by a small, constant amount (see |
| // comments on animateScroll()); the exact amount is given by |
| // lag = |step| - v(0.5tA + tD) |
| // Where |
| // v = The steady-state velocity, |
| // |step| / ScrollbarTheme::nativeTheme()->autoscrollTimerDelay() |
| // tA = accelerationTime() |
| // tD = The time we pretend has already passed when starting to scroll, |
| // |animationTimerDelay| |
| // |
| // This lag provides some buffer against timer jitter so we're less likely |
| // to hit the desired position and stop (and thus have to re-accelerate, |
| // causing a visible hitch) while waiting for the next autoscroll increment. |
| // |
| // Thus, for autoscroll-timer-triggered requests, the ideal steady-state |
| // distance to travel in each time interval is: |
| // float animationStep = step; |
| // Note that when we're not already animating, this is exactly the same as |
| // the distance to the target position. We'll return to that in a moment. |
| // |
| // For keyboard and wheel scrolls, we don't know when the next increment |
| // will be requested. If we set the target velocity based on how far away |
| // from the target position we are, then for keyboard/wheel events that come |
| // faster than the autoscroll delay, we'll asymptotically approach the |
| // velocity needed to stay smoothly in sync with the user's actions; for |
| // events that come slower, we'll scroll one increment and then pause until |
| // the next event fires. |
| float animationStep = fabs(newPos - *data->m_currentPos); |
| // If a key is held down (or the wheel continually spun), then once we have |
| // reached a velocity close to the steady-state velocity, we're likely to |
| // hit the desired position at around the same time we'd expect the next |
| // increment to occur -- bad because it leads to hitching as described above |
| // (if autoscroll-based requests didn't result in a small amount of constant |
| // lag). So if we're called again while already animating, we want to trim |
| // the animationStep slightly to maintain lag like what's described above. |
| // (I say "maintain" since we'll already be lagged due to the acceleration |
| // during the first scroll period.) |
| // |
| // Remember that trimming won't cause us to fall steadily further behind |
| // here, because the further behind we are, the larger the base step value |
| // above. Given the scrolling algorithm in animateScroll(), the practical |
| // effect will actually be that, assuming a constant trim factor, we'll lag |
| // by a constant amount depending on the rate at which increments occur |
| // compared to the autoscroll timer delay. The exact lag is given by |
| // lag = |step| * ((r / k) - 1) |
| // Where |
| // r = The ratio of the autoscroll repeat delay, |
| // ScrollbarTheme::nativeTheme()->autoscrollTimerDelay(), to the |
| // key/wheel repeat delay (i.e. > 1 when keys repeat faster) |
| // k = The velocity trim constant given below |
| // |
| // We want to choose the trim factor such that for calls that come at the |
| // autoscroll timer rate, we'll wind up with the same lag as in the |
| // "perfect" case described above (or, to put it another way, we'll end up |
| // with |animationStep| == |step| * |multiplier| despite the actual distance |
| // calculated above being larger than that). This will result in "perfect" |
| // behavior for autoscrolling without having to special-case it. |
| if (alreadyAnimating) |
| animationStep /= (2.0 - ((1.0 / ScrollbarTheme::nativeTheme()->autoscrollTimerDelay()) * (0.5 * accelerationTime() + animationTimerDelay))); |
| // The result of all this is that single keypresses or wheel flicks will |
| // scroll in the same time period as single presses of scrollbar elements; |
| // holding the mouse down on a scrollbar part will scroll as fast as |
| // possible without hitching; and other repeated scroll events will also |
| // scroll with the same time lag as holding down the mouse on a scrollbar |
| // part. |
| data->m_desiredVelocity = animationStep / ScrollbarTheme::nativeTheme()->autoscrollTimerDelay(); |
| |
| // If we're not already scrolling, start. |
| if (!alreadyAnimating) |
| animateScroll(data); |
| return true; |
| } |
| |
| void ScrollAnimatorWin::scrollToOffsetWithoutAnimation(const FloatPoint& offset) |
| { |
| stopAnimationTimerIfNeeded(&m_horizontalData); |
| stopAnimationTimerIfNeeded(&m_verticalData); |
| |
| *m_horizontalData.m_currentPos = offset.x(); |
| m_horizontalData.m_desiredPos = offset.x(); |
| m_horizontalData.m_currentVelocity = 0; |
| m_horizontalData.m_desiredVelocity = 0; |
| |
| *m_verticalData.m_currentPos = offset.y(); |
| m_verticalData.m_desiredPos = offset.y(); |
| m_verticalData.m_currentVelocity = 0; |
| m_verticalData.m_desiredVelocity = 0; |
| |
| notityPositionChanged(); |
| } |
| |
| double ScrollAnimatorWin::accelerationTime() |
| { |
| // We elect to use ScrollbarTheme::nativeTheme()->autoscrollTimerDelay() as |
| // the length of time we'll take to accelerate from 0 to our target |
| // velocity. Choosing a larger value would produce a more pronounced |
| // acceleration effect. |
| return ScrollbarTheme::nativeTheme()->autoscrollTimerDelay(); |
| } |
| |
| void ScrollAnimatorWin::animationTimerFired(Timer<ScrollAnimatorWin>* timer) |
| { |
| animateScroll((timer == &m_horizontalData.m_animationTimer) ? &m_horizontalData : &m_verticalData); |
| } |
| |
| void ScrollAnimatorWin::stopAnimationTimerIfNeeded(PerAxisData* data) |
| { |
| if (data->m_animationTimer.isActive()) |
| data->m_animationTimer.stop(); |
| } |
| |
| void ScrollAnimatorWin::animateScroll(PerAxisData* data) |
| { |
| // Note on smooth scrolling perf versus non-smooth scrolling perf: |
| // The total time to perform a complete scroll is given by |
| // t = t0 + 0.5tA - tD + tS |
| // Where |
| // t0 = The time to perform the scroll without smooth scrolling |
| // tA = The acceleration time, |
| // ScrollbarTheme::nativeTheme()->autoscrollTimerDelay() (see below) |
| // tD = |animationTimerDelay| |
| // tS = A value less than or equal to the time required to perform a |
| // single scroll increment, i.e. the work done due to calling |
| // client()->valueChanged() (~0 for simple pages, larger for complex |
| // pages). |
| // |
| // Because tA and tD are fairly small, the total lag (as users perceive it) |
| // is negligible for simple pages and roughly tS for complex pages. Without |
| // knowing in advance how large tS is it's hard to do better than this. |
| // Perhaps we could try to remember previous values and forward-compensate. |
| |
| |
| // We want to update the scroll position based on the time it's been since |
| // our last update. This may be longer than our ideal time, especially if |
| // the page is complex or the system is slow. |
| // |
| // To avoid feeling laggy, if we've just started smooth scrolling we pretend |
| // we've already accelerated for one ideal interval, so that we'll scroll at |
| // least some distance immediately. |
| double lastScrollInterval = data->m_currentVelocity ? (WTF::currentTime() - data->m_lastAnimationTime) : animationTimerDelay; |
| |
| // Figure out how far we've actually traveled and update our current |
| // velocity. |
| float distanceTraveled; |
| if (data->m_currentVelocity < data->m_desiredVelocity) { |
| // We accelerate at a constant rate until we reach the desired velocity. |
| float accelerationRate = data->m_desiredVelocity / accelerationTime(); |
| |
| // Figure out whether contant acceleration has caused us to reach our |
| // target velocity. |
| float potentialVelocityChange = accelerationRate * lastScrollInterval; |
| float potentialNewVelocity = data->m_currentVelocity + potentialVelocityChange; |
| if (potentialNewVelocity > data->m_desiredVelocity) { |
| // We reached the target velocity at some point between our last |
| // update and now. The distance traveled can be calculated in two |
| // pieces: the distance traveled while accelerating, and the |
| // distance traveled after reaching the target velocity. |
| float actualVelocityChange = data->m_desiredVelocity - data->m_currentVelocity; |
| float accelerationInterval = actualVelocityChange / accelerationRate; |
| // The distance traveled under constant acceleration is the area |
| // under a line segment with a constant rising slope. Break this |
| // into a triangular portion atop a rectangular portion and sum. |
| distanceTraveled = ((data->m_currentVelocity + (actualVelocityChange / 2)) * accelerationInterval); |
| // The distance traveled at the target velocity is simply |
| // (target velocity) * (remaining time after accelerating). |
| distanceTraveled += (data->m_desiredVelocity * (lastScrollInterval - accelerationInterval)); |
| data->m_currentVelocity = data->m_desiredVelocity; |
| } else { |
| // Constant acceleration through the entire time interval. |
| distanceTraveled = (data->m_currentVelocity + (potentialVelocityChange / 2)) * lastScrollInterval; |
| data->m_currentVelocity = potentialNewVelocity; |
| } |
| } else { |
| // We've already reached the target velocity, so the distance we've |
| // traveled is simply (current velocity) * (elapsed time). |
| distanceTraveled = data->m_currentVelocity * lastScrollInterval; |
| // If our desired velocity has decreased, drop the current velocity too. |
| data->m_currentVelocity = data->m_desiredVelocity; |
| } |
| |
| // Now update the scroll position based on the distance traveled. |
| if (distanceTraveled >= fabs(data->m_desiredPos - *data->m_currentPos)) { |
| // We've traveled far enough to reach the desired position. Stop smooth |
| // scrolling. |
| *data->m_currentPos = data->m_desiredPos; |
| data->m_currentVelocity = 0; |
| data->m_desiredVelocity = 0; |
| } else { |
| // Not yet at the target position. Travel towards it and set up the |
| // next update. |
| if (*data->m_currentPos > data->m_desiredPos) |
| distanceTraveled = -distanceTraveled; |
| *data->m_currentPos += distanceTraveled; |
| data->m_animationTimer.startOneShot(animationTimerDelay); |
| data->m_lastAnimationTime = WTF::currentTime(); |
| } |
| |
| notityPositionChanged(); |
| } |
| |
| } // namespace WebCore |
| |
| #endif // ENABLE(SMOOTH_SCROLLING) |
