Scrollbars and ScrollAnimators must always have a ScrollableArea
[WebKit-https.git] / Source / WebCore / platform / ScrollAnimator.cpp
1 /*
2  * Copyright (C) 2014-2015 Apple Inc.  All rights reserved.
3  * Copyright (c) 2010, Google Inc. All rights reserved.
4  * 
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions are
7  * met:
8  * 
9  *     * Redistributions of source code must retain the above copyright
10  * notice, this list of conditions and the following disclaimer.
11  *     * Redistributions in binary form must reproduce the above
12  * copyright notice, this list of conditions and the following disclaimer
13  * in the documentation and/or other materials provided with the
14  * distribution.
15  *     * Neither the name of Google Inc. nor the names of its
16  * contributors may be used to endorse or promote products derived from
17  * this software without specific prior written permission.
18  * 
19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30  */
31
32 #include "config.h"
33 #include "ScrollAnimator.h"
34
35 #include "FloatPoint.h"
36 #include "PlatformWheelEvent.h"
37 #include "ScrollableArea.h"
38 #include <algorithm>
39 #include <wtf/PassOwnPtr.h>
40
41 namespace WebCore {
42
43 #if !ENABLE(SMOOTH_SCROLLING) && !PLATFORM(IOS)
44 PassOwnPtr<ScrollAnimator> ScrollAnimator::create(ScrollableArea& scrollableArea)
45 {
46     return adoptPtr(new ScrollAnimator(scrollableArea));
47 }
48 #endif
49
50 ScrollAnimator::ScrollAnimator(ScrollableArea& scrollableArea)
51     : m_scrollableArea(scrollableArea)
52     , m_currentPosX(0)
53     , m_currentPosY(0)
54 {
55 }
56
57 ScrollAnimator::~ScrollAnimator()
58 {
59 }
60
61 bool ScrollAnimator::scroll(ScrollbarOrientation orientation, ScrollGranularity, float step, float multiplier)
62 {
63     float* currentPos = (orientation == HorizontalScrollbar) ? &m_currentPosX : &m_currentPosY;
64     float newPos = std::max(std::min(*currentPos + (step * multiplier), static_cast<float>(m_scrollableArea.scrollSize(orientation))), 0.0f);
65     float delta = *currentPos - newPos;
66     if (*currentPos == newPos)
67         return false;
68     *currentPos = newPos;
69
70     notifyPositionChanged(orientation == HorizontalScrollbar ? FloatSize(delta, 0) : FloatSize(0, delta));
71
72     return true;
73 }
74
75 void ScrollAnimator::scrollToOffsetWithoutAnimation(const FloatPoint& offset)
76 {
77     FloatSize delta = FloatSize(offset.x() - m_currentPosX, offset.y() - m_currentPosY);
78     m_currentPosX = offset.x();
79     m_currentPosY = offset.y();
80     notifyPositionChanged(delta);
81 }
82
83 #if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)
84 void ScrollAnimator::processWheelEventForScrollSnap(const PlatformWheelEvent& wheelEvent)
85 {
86     if (m_verticalScrollSnapAnimator)
87         m_verticalScrollSnapAnimator->handleWheelEvent(wheelEvent);
88     if (m_horizontalScrollSnapAnimator)
89         m_horizontalScrollSnapAnimator->handleWheelEvent(wheelEvent);
90 }
91 #endif
92
93 bool ScrollAnimator::handleWheelEvent(const PlatformWheelEvent& e)
94 {
95 #if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)
96     if (m_verticalScrollSnapAnimator) {
97         m_verticalScrollSnapAnimator->handleWheelEvent(e);
98         if (m_verticalScrollSnapAnimator->shouldOverrideWheelEvent(e))
99             return false;
100     }
101     if (m_horizontalScrollSnapAnimator) {
102         m_horizontalScrollSnapAnimator->handleWheelEvent(e);
103         if (m_horizontalScrollSnapAnimator->shouldOverrideWheelEvent(e))
104             return false;
105     }
106 #endif
107 #if PLATFORM(COCOA)
108     // Events in the PlatformWheelEventPhaseMayBegin phase have no deltas, and therefore never passes through the scroll handling logic below.
109     // This causes us to return with an 'unhandled' return state, even though this event was successfully processed.
110     //
111     // We receive at least one PlatformWheelEventPhaseMayBegin when starting main-thread scrolling (see FrameView::wheelEvent), which can
112     // fool the scrolling thread into attempting to handle the scroll, unless we treat the event as handled here.
113     if (e.phase() == PlatformWheelEventPhaseMayBegin)
114         return true;
115 #endif
116
117     Scrollbar* horizontalScrollbar = m_scrollableArea.horizontalScrollbar();
118     Scrollbar* verticalScrollbar = m_scrollableArea.verticalScrollbar();
119
120     // Accept the event if we have a scrollbar in that direction and can still
121     // scroll any further.
122     float deltaX = horizontalScrollbar ? e.deltaX() : 0;
123     float deltaY = verticalScrollbar ? e.deltaY() : 0;
124
125     bool handled = false;
126
127     ScrollGranularity granularity = ScrollByPixel;
128     IntSize maxForwardScrollDelta = m_scrollableArea.maximumScrollPosition() - m_scrollableArea.scrollPosition();
129     IntSize maxBackwardScrollDelta = m_scrollableArea.scrollPosition() - m_scrollableArea.minimumScrollPosition();
130     if ((deltaX < 0 && maxForwardScrollDelta.width() > 0)
131         || (deltaX > 0 && maxBackwardScrollDelta.width() > 0)
132         || (deltaY < 0 && maxForwardScrollDelta.height() > 0)
133         || (deltaY > 0 && maxBackwardScrollDelta.height() > 0)) {
134         handled = true;
135
136         if (deltaY) {
137             if (e.granularity() == ScrollByPageWheelEvent) {
138                 bool negative = deltaY < 0;
139                 deltaY = Scrollbar::pageStepDelta(m_scrollableArea.visibleHeight());
140                 if (negative)
141                     deltaY = -deltaY;
142             }
143             scroll(VerticalScrollbar, granularity, verticalScrollbar->pixelStep(), -deltaY);
144         }
145
146         if (deltaX) {
147             if (e.granularity() == ScrollByPageWheelEvent) {
148                 bool negative = deltaX < 0;
149                 deltaX = Scrollbar::pageStepDelta(m_scrollableArea.visibleWidth());
150                 if (negative)
151                     deltaX = -deltaX;
152             }
153             scroll(HorizontalScrollbar, granularity, horizontalScrollbar->pixelStep(), -deltaX);
154         }
155     }
156     return handled;
157 }
158
159 #if ENABLE(TOUCH_EVENTS)
160 bool ScrollAnimator::handleTouchEvent(const PlatformTouchEvent&)
161 {
162     return false;
163 }
164 #endif
165
166 void ScrollAnimator::setCurrentPosition(const FloatPoint& position)
167 {
168     m_currentPosX = position.x();
169     m_currentPosY = position.y();
170 }
171
172 FloatPoint ScrollAnimator::currentPosition() const
173 {
174     return FloatPoint(m_currentPosX, m_currentPosY);
175 }
176
177 void ScrollAnimator::notifyPositionChanged(const FloatSize& delta)
178 {
179     UNUSED_PARAM(delta);
180     m_scrollableArea.setScrollOffsetFromAnimation(IntPoint(m_currentPosX, m_currentPosY));
181 }
182
183 #if ENABLE(CSS_SCROLL_SNAP) && PLATFORM(MAC)
184 void ScrollAnimator::updateScrollAnimatorsAndTimers()
185 {
186     // FIXME: Currently, scroll snap animators are recreated even though the snap offsets alone can be updated.
187     if (m_scrollableArea.horizontalSnapOffsets()) {
188         m_horizontalScrollSnapAnimator = std::make_unique<AxisScrollSnapAnimator>(this, m_scrollableArea.horizontalSnapOffsets(), ScrollEventAxis::Horizontal);
189         m_horizontalScrollSnapTimer = std::make_unique<Timer>(*this, &ScrollAnimator::horizontalScrollSnapTimerFired);
190     } else if (m_horizontalScrollSnapAnimator) {
191         m_horizontalScrollSnapAnimator = nullptr;
192         m_horizontalScrollSnapTimer = nullptr;
193     }
194     if (m_scrollableArea.verticalSnapOffsets()) {
195         m_verticalScrollSnapAnimator = std::make_unique<AxisScrollSnapAnimator>(this, m_scrollableArea.verticalSnapOffsets(), ScrollEventAxis::Vertical);
196         m_verticalScrollSnapTimer = std::make_unique<Timer>(*this, &ScrollAnimator::verticalScrollSnapTimerFired);
197     } else if (m_verticalScrollSnapAnimator) {
198         m_verticalScrollSnapAnimator = nullptr;
199         m_verticalScrollSnapTimer = nullptr;
200     }
201 }
202
203 LayoutUnit ScrollAnimator::scrollOffsetInAxis(ScrollEventAxis axis)
204 {
205     FloatPoint currentPosition = this->currentPosition();
206     return axis == ScrollEventAxis::Horizontal ? currentPosition.x() : currentPosition.y();
207 }
208
209 void ScrollAnimator::immediateScrollInAxis(ScrollEventAxis axis, float delta)
210 {
211     FloatPoint currentPosition = this->currentPosition();
212     if (axis == ScrollEventAxis::Horizontal)
213         scrollToOffsetWithoutAnimation(FloatPoint(currentPosition.x() + delta, currentPosition.y()));
214     else
215         scrollToOffsetWithoutAnimation(FloatPoint(currentPosition.x(), currentPosition.y() + delta));
216 }
217
218 void ScrollAnimator::startScrollSnapTimer(ScrollEventAxis axis)
219 {
220     Timer* scrollSnapTimer = axis == ScrollEventAxis::Horizontal ? m_horizontalScrollSnapTimer.get() : m_verticalScrollSnapTimer.get();
221     if (!scrollSnapTimer->isActive())
222         scrollSnapTimer->startRepeating(1.0 / 60.0);
223 }
224
225 void ScrollAnimator::stopScrollSnapTimer(ScrollEventAxis axis)
226 {
227     Timer* scrollSnapTimer = axis == ScrollEventAxis::Horizontal ? m_horizontalScrollSnapTimer.get() : m_verticalScrollSnapTimer.get();
228     if (scrollSnapTimer->isActive())
229         scrollSnapTimer->stop();
230 }
231
232 void ScrollAnimator::horizontalScrollSnapTimerFired()
233 {
234     m_horizontalScrollSnapAnimator->scrollSnapAnimationUpdate();
235 }
236
237 void ScrollAnimator::verticalScrollSnapTimerFired()
238 {
239     m_verticalScrollSnapAnimator->scrollSnapAnimationUpdate();
240 }
241 #endif
242
243 } // namespace WebCore