Remove the Timer parameters from timer callbacks
[WebKit-https.git] / Source / WebCore / platform / Scrollbar.cpp
1 /*
2  * Copyright (C) 2004, 2006, 2008 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. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27 #include "Scrollbar.h"
28
29 #include "FrameView.h"
30 #include "GraphicsContext.h"
31 #include "PlatformMouseEvent.h"
32 #include "ScrollAnimator.h"
33 #include "ScrollView.h"
34 #include "ScrollableArea.h"
35 #include "ScrollbarTheme.h"
36 #include <algorithm>
37
38 #if PLATFORM(GTK)
39 // The position of the scrollbar thumb affects the appearance of the steppers, so
40 // when the thumb moves, we have to invalidate them for painting.
41 #define THUMB_POSITION_AFFECTS_BUTTONS
42 #endif
43
44 namespace WebCore {
45
46 #if !PLATFORM(EFL)
47 PassRefPtr<Scrollbar> Scrollbar::createNativeScrollbar(ScrollableArea* scrollableArea, ScrollbarOrientation orientation, ScrollbarControlSize size)
48 {
49     return adoptRef(new Scrollbar(scrollableArea, orientation, size));
50 }
51 #endif
52
53 int Scrollbar::maxOverlapBetweenPages()
54 {
55     static int maxOverlapBetweenPages = ScrollbarTheme::theme()->maxOverlapBetweenPages();
56     return maxOverlapBetweenPages;
57 }
58
59 Scrollbar::Scrollbar(ScrollableArea* scrollableArea, ScrollbarOrientation orientation, ScrollbarControlSize controlSize,
60                      ScrollbarTheme* theme, bool isCustomScrollbar)
61     : m_scrollableArea(scrollableArea)
62     , m_orientation(orientation)
63     , m_controlSize(controlSize)
64     , m_theme(theme)
65     , m_visibleSize(0)
66     , m_totalSize(0)
67     , m_currentPos(0)
68     , m_dragOrigin(0)
69     , m_lineStep(0)
70     , m_pageStep(0)
71     , m_pixelStep(1)
72     , m_hoveredPart(NoPart)
73     , m_pressedPart(NoPart)
74     , m_pressedPos(0)
75     , m_scrollPos(0)
76     , m_draggingDocument(false)
77     , m_documentDragPos(0)
78     , m_enabled(true)
79     , m_scrollTimer(*this, &Scrollbar::autoscrollTimerFired)
80     , m_overlapsResizer(false)
81     , m_suppressInvalidation(false)
82     , m_isAlphaLocked(false)
83     , m_isCustomScrollbar(isCustomScrollbar)
84 {
85     if (!m_theme)
86         m_theme = ScrollbarTheme::theme();
87
88     m_theme->registerScrollbar(this);
89
90     // FIXME: This is ugly and would not be necessary if we fix cross-platform code to actually query for
91     // scrollbar thickness and use it when sizing scrollbars (rather than leaving one dimension of the scrollbar
92     // alone when sizing).
93     int thickness = m_theme->scrollbarThickness(controlSize);
94     Widget::setFrameRect(IntRect(0, 0, thickness, thickness));
95
96     if (m_scrollableArea)
97         m_currentPos = static_cast<float>(m_scrollableArea->scrollPosition(this));
98 }
99
100 Scrollbar::~Scrollbar()
101 {
102     stopTimerIfNeeded();
103     
104     m_theme->unregisterScrollbar(this);
105 }
106
107 ScrollbarOverlayStyle Scrollbar::scrollbarOverlayStyle() const
108 {
109     return m_scrollableArea ? m_scrollableArea->scrollbarOverlayStyle() : ScrollbarOverlayStyleDefault;
110 }
111
112 bool Scrollbar::isScrollableAreaActive() const
113 {
114     return m_scrollableArea && m_scrollableArea->isActive();
115 }
116
117 bool Scrollbar::isScrollViewScrollbar() const
118 {
119     return parent() && parent()->isScrollViewScrollbar(this);
120 }
121
122 void Scrollbar::offsetDidChange()
123 {
124     ASSERT(m_scrollableArea);
125
126     float position = static_cast<float>(m_scrollableArea->scrollPosition(this));
127     if (position == m_currentPos)
128         return;
129
130     int oldThumbPosition = theme()->thumbPosition(this);
131     m_currentPos = position;
132     updateThumbPosition();
133     if (m_pressedPart == ThumbPart)
134         setPressedPos(m_pressedPos + theme()->thumbPosition(this) - oldThumbPosition);    
135 }
136
137 void Scrollbar::setProportion(int visibleSize, int totalSize)
138 {
139     if (visibleSize == m_visibleSize && totalSize == m_totalSize)
140         return;
141
142     m_visibleSize = visibleSize;
143     m_totalSize = totalSize;
144
145     updateThumbProportion();
146 }
147
148 void Scrollbar::setSteps(int lineStep, int pageStep, int pixelsPerStep)
149 {
150     m_lineStep = lineStep;
151     m_pageStep = pageStep;
152     m_pixelStep = 1.0f / pixelsPerStep;
153 }
154
155 void Scrollbar::updateThumb()
156 {
157 #ifdef THUMB_POSITION_AFFECTS_BUTTONS
158     invalidate();
159 #else
160     theme()->invalidateParts(this, ForwardTrackPart | BackTrackPart | ThumbPart);
161 #endif
162 }
163
164 void Scrollbar::updateThumbPosition()
165 {
166     updateThumb();
167 }
168
169 void Scrollbar::updateThumbProportion()
170 {
171     updateThumb();
172 }
173
174 void Scrollbar::paint(GraphicsContext* context, const IntRect& damageRect)
175 {
176     if (context->updatingControlTints() && theme()->supportsControlTints()) {
177         invalidate();
178         return;
179     }
180
181     if (context->paintingDisabled() || !frameRect().intersects(damageRect))
182         return;
183
184     if (!theme()->paint(this, context, damageRect))
185         Widget::paint(context, damageRect);
186 }
187
188 void Scrollbar::autoscrollTimerFired()
189 {
190     autoscrollPressedPart(theme()->autoscrollTimerDelay());
191 }
192
193 static bool thumbUnderMouse(Scrollbar* scrollbar)
194 {
195     int thumbPos = scrollbar->theme()->trackPosition(scrollbar) + scrollbar->theme()->thumbPosition(scrollbar);
196     int thumbLength = scrollbar->theme()->thumbLength(scrollbar);
197     return scrollbar->pressedPos() >= thumbPos && scrollbar->pressedPos() < thumbPos + thumbLength;
198 }
199
200 void Scrollbar::autoscrollPressedPart(double delay)
201 {
202     // Don't do anything for the thumb or if nothing was pressed.
203     if (m_pressedPart == ThumbPart || m_pressedPart == NoPart)
204         return;
205
206     // Handle the track.
207     if ((m_pressedPart == BackTrackPart || m_pressedPart == ForwardTrackPart) && thumbUnderMouse(this)) {
208         theme()->invalidatePart(this, m_pressedPart);
209         setHoveredPart(ThumbPart);
210         return;
211     }
212
213     // Handle the arrows and track.
214     if (m_scrollableArea && m_scrollableArea->scroll(pressedPartScrollDirection(), pressedPartScrollGranularity()))
215         startTimerIfNeeded(delay);
216 }
217
218 void Scrollbar::startTimerIfNeeded(double delay)
219 {
220     // Don't do anything for the thumb.
221     if (m_pressedPart == ThumbPart)
222         return;
223
224     // Handle the track.  We halt track scrolling once the thumb is level
225     // with us.
226     if ((m_pressedPart == BackTrackPart || m_pressedPart == ForwardTrackPart) && thumbUnderMouse(this)) {
227         theme()->invalidatePart(this, m_pressedPart);
228         setHoveredPart(ThumbPart);
229         return;
230     }
231
232     // We can't scroll if we've hit the beginning or end.
233     ScrollDirection dir = pressedPartScrollDirection();
234     if (dir == ScrollUp || dir == ScrollLeft) {
235         if (m_currentPos == 0)
236             return;
237     } else {
238         if (m_currentPos == maximum())
239             return;
240     }
241
242     m_scrollTimer.startOneShot(delay);
243 }
244
245 void Scrollbar::stopTimerIfNeeded()
246 {
247     if (m_scrollTimer.isActive())
248         m_scrollTimer.stop();
249 }
250
251 ScrollDirection Scrollbar::pressedPartScrollDirection()
252 {
253     if (m_orientation == HorizontalScrollbar) {
254         if (m_pressedPart == BackButtonStartPart || m_pressedPart == BackButtonEndPart || m_pressedPart == BackTrackPart)
255             return ScrollLeft;
256         return ScrollRight;
257     } else {
258         if (m_pressedPart == BackButtonStartPart || m_pressedPart == BackButtonEndPart || m_pressedPart == BackTrackPart)
259             return ScrollUp;
260         return ScrollDown;
261     }
262 }
263
264 ScrollGranularity Scrollbar::pressedPartScrollGranularity()
265 {
266     if (m_pressedPart == BackButtonStartPart || m_pressedPart == BackButtonEndPart ||  m_pressedPart == ForwardButtonStartPart || m_pressedPart == ForwardButtonEndPart)
267         return ScrollByLine;
268     return ScrollByPage;
269 }
270
271 void Scrollbar::moveThumb(int pos, bool draggingDocument)
272 {
273     if (!m_scrollableArea)
274         return;
275
276     int delta = pos - m_pressedPos;
277
278     if (draggingDocument) {
279         if (m_draggingDocument)
280             delta = pos - m_documentDragPos;
281         m_draggingDocument = true;
282         FloatPoint currentPosition = m_scrollableArea->scrollAnimator()->currentPosition();
283         int destinationPosition = (m_orientation == HorizontalScrollbar ? currentPosition.x() : currentPosition.y()) + delta;
284         if (delta > 0)
285             destinationPosition = std::min(destinationPosition + delta, maximum());
286         else if (delta < 0)
287             destinationPosition = std::max(destinationPosition + delta, 0);
288         m_scrollableArea->scrollToOffsetWithoutAnimation(m_orientation, destinationPosition);
289         m_documentDragPos = pos;
290         return;
291     }
292
293     if (m_draggingDocument) {
294         delta += m_pressedPos - m_documentDragPos;
295         m_draggingDocument = false;
296     }
297
298     // Drag the thumb.
299     int thumbPos = theme()->thumbPosition(this);
300     int thumbLen = theme()->thumbLength(this);
301     int trackLen = theme()->trackLength(this);
302     int maxPos = trackLen - thumbLen;
303     if (delta > 0)
304         delta = std::min(maxPos - thumbPos, delta);
305     else if (delta < 0)
306         delta = std::max(-thumbPos, delta);
307     
308     if (delta) {
309         float newPosition = static_cast<float>(thumbPos + delta) * maximum() / (trackLen - thumbLen);
310         m_scrollableArea->scrollToOffsetWithoutAnimation(m_orientation, newPosition);
311     }
312 }
313
314 void Scrollbar::setHoveredPart(ScrollbarPart part)
315 {
316     if (part == m_hoveredPart)
317         return;
318
319     if ((m_hoveredPart == NoPart || part == NoPart) && theme()->invalidateOnMouseEnterExit())
320         invalidate();  // Just invalidate the whole scrollbar, since the buttons at either end change anyway.
321     else if (m_pressedPart == NoPart) {  // When there's a pressed part, we don't draw a hovered state, so there's no reason to invalidate.
322         theme()->invalidatePart(this, part);
323         theme()->invalidatePart(this, m_hoveredPart);
324     }
325     m_hoveredPart = part;
326 }
327
328 void Scrollbar::setPressedPart(ScrollbarPart part)
329 {
330     if (m_pressedPart != NoPart)
331         theme()->invalidatePart(this, m_pressedPart);
332     m_pressedPart = part;
333     if (m_pressedPart != NoPart)
334         theme()->invalidatePart(this, m_pressedPart);
335     else if (m_hoveredPart != NoPart)  // When we no longer have a pressed part, we can start drawing a hovered state on the hovered part.
336         theme()->invalidatePart(this, m_hoveredPart);
337 }
338
339 #if !PLATFORM(IOS)
340 bool Scrollbar::mouseMoved(const PlatformMouseEvent& evt)
341 {
342     if (m_pressedPart == ThumbPart) {
343         if (theme()->shouldSnapBackToDragOrigin(this, evt)) {
344             if (m_scrollableArea)
345                 m_scrollableArea->scrollToOffsetWithoutAnimation(m_orientation, m_dragOrigin);
346         } else {
347             moveThumb(m_orientation == HorizontalScrollbar ? 
348                       convertFromContainingWindow(evt.position()).x() :
349                       convertFromContainingWindow(evt.position()).y(), theme()->shouldDragDocumentInsteadOfThumb(this, evt));
350         }
351         return true;
352     }
353
354     if (m_pressedPart != NoPart)
355         m_pressedPos = (orientation() == HorizontalScrollbar ? convertFromContainingWindow(evt.position()).x() : convertFromContainingWindow(evt.position()).y());
356
357     ScrollbarPart part = theme()->hitTest(this, evt.position());
358     if (part != m_hoveredPart) {
359         if (m_pressedPart != NoPart) {
360             if (part == m_pressedPart) {
361                 // The mouse is moving back over the pressed part.  We
362                 // need to start up the timer action again.
363                 startTimerIfNeeded(theme()->autoscrollTimerDelay());
364                 theme()->invalidatePart(this, m_pressedPart);
365             } else if (m_hoveredPart == m_pressedPart) {
366                 // The mouse is leaving the pressed part.  Kill our timer
367                 // if needed.
368                 stopTimerIfNeeded();
369                 theme()->invalidatePart(this, m_pressedPart);
370             }
371         } 
372         
373         setHoveredPart(part);
374     } 
375
376     return true;
377 }
378 #endif
379
380 void Scrollbar::mouseEntered()
381 {
382     if (m_scrollableArea)
383         m_scrollableArea->mouseEnteredScrollbar(this);
384 }
385
386 bool Scrollbar::mouseExited()
387 {
388     if (m_scrollableArea)
389         m_scrollableArea->mouseExitedScrollbar(this);
390     setHoveredPart(NoPart);
391     return true;
392 }
393
394 bool Scrollbar::mouseUp(const PlatformMouseEvent& mouseEvent)
395 {
396     setPressedPart(NoPart);
397     m_pressedPos = 0;
398     m_draggingDocument = false;
399     stopTimerIfNeeded();
400
401     if (m_scrollableArea) {
402         // m_hoveredPart won't be updated until the next mouseMoved or mouseDown, so we have to hit test
403         // to really know if the mouse has exited the scrollbar on a mouseUp.
404         ScrollbarPart part = theme()->hitTest(this, mouseEvent.position());
405         if (part == NoPart)
406             m_scrollableArea->mouseExitedScrollbar(this);
407     }
408
409     return true;
410 }
411
412 bool Scrollbar::mouseDown(const PlatformMouseEvent& evt)
413 {
414     // Early exit for right click
415     if (evt.button() == RightButton)
416         return true; // FIXME: Handled as context menu by Qt right now.  Should just avoid even calling this method on a right click though.
417
418     setPressedPart(theme()->hitTest(this, evt.position()));
419     int pressedPos = (orientation() == HorizontalScrollbar ? convertFromContainingWindow(evt.position()).x() : convertFromContainingWindow(evt.position()).y());
420     
421     if ((m_pressedPart == BackTrackPart || m_pressedPart == ForwardTrackPart) && theme()->shouldCenterOnThumb(this, evt)) {
422         setHoveredPart(ThumbPart);
423         setPressedPart(ThumbPart);
424         m_dragOrigin = m_currentPos;
425         int thumbLen = theme()->thumbLength(this);
426         int desiredPos = pressedPos;
427         // Set the pressed position to the middle of the thumb so that when we do the move, the delta
428         // will be from the current pixel position of the thumb to the new desired position for the thumb.
429         m_pressedPos = theme()->trackPosition(this) + theme()->thumbPosition(this) + thumbLen / 2;
430         moveThumb(desiredPos);
431         return true;
432     } else if (m_pressedPart == ThumbPart)
433         m_dragOrigin = m_currentPos;
434     
435     m_pressedPos = pressedPos;
436
437     autoscrollPressedPart(theme()->initialAutoscrollTimerDelay());
438     return true;
439 }
440
441 void Scrollbar::setFrameRect(const IntRect& rect)
442 {
443     // Get our window resizer rect and see if we overlap. Adjust to avoid the overlap
444     // if necessary.
445     IntRect adjustedRect(rect);
446     bool overlapsResizer = false;
447     ScrollView* view = parent();
448     if (view && !rect.isEmpty() && !view->windowResizerRect().isEmpty()) {
449         IntRect resizerRect = view->convertFromContainingWindow(view->windowResizerRect());
450         if (rect.intersects(resizerRect)) {
451             if (orientation() == HorizontalScrollbar) {
452                 int overlap = rect.maxX() - resizerRect.x();
453                 if (overlap > 0 && resizerRect.maxX() >= rect.maxX()) {
454                     adjustedRect.setWidth(rect.width() - overlap);
455                     overlapsResizer = true;
456                 }
457             } else {
458                 int overlap = rect.maxY() - resizerRect.y();
459                 if (overlap > 0 && resizerRect.maxY() >= rect.maxY()) {
460                     adjustedRect.setHeight(rect.height() - overlap);
461                     overlapsResizer = true;
462                 }
463             }
464         }
465     }
466     if (overlapsResizer != m_overlapsResizer) {
467         m_overlapsResizer = overlapsResizer;
468         if (view)
469             view->adjustScrollbarsAvoidingResizerCount(m_overlapsResizer ? 1 : -1);
470     }
471
472     Widget::setFrameRect(adjustedRect);
473 }
474
475 void Scrollbar::setParent(ScrollView* parentView)
476 {
477     if (!parentView && m_overlapsResizer && parent())
478         parent()->adjustScrollbarsAvoidingResizerCount(-1);
479     Widget::setParent(parentView);
480 }
481
482 void Scrollbar::setEnabled(bool e)
483
484     if (m_enabled == e)
485         return;
486     m_enabled = e;
487     theme()->updateEnabledState(this);
488     invalidate();
489 }
490
491 bool Scrollbar::isOverlayScrollbar() const
492 {
493     return m_theme->usesOverlayScrollbars();
494 }
495
496 bool Scrollbar::shouldParticipateInHitTesting()
497 {
498     // Non-overlay scrollbars should always participate in hit testing.
499     if (!isOverlayScrollbar())
500         return true;
501     return m_scrollableArea->scrollAnimator()->shouldScrollbarParticipateInHitTesting(this);
502 }
503
504 bool Scrollbar::isWindowActive() const
505 {
506     return m_scrollableArea && m_scrollableArea->isActive();
507 }
508
509 void Scrollbar::invalidateRect(const IntRect& rect)
510 {
511     if (suppressInvalidation())
512         return;
513
514     if (m_scrollableArea)
515         m_scrollableArea->invalidateScrollbar(this, rect);
516 }
517
518 IntRect Scrollbar::convertToContainingView(const IntRect& localRect) const
519 {
520     if (m_scrollableArea)
521         return m_scrollableArea->convertFromScrollbarToContainingView(this, localRect);
522
523     return Widget::convertToContainingView(localRect);
524 }
525
526 IntRect Scrollbar::convertFromContainingView(const IntRect& parentRect) const
527 {
528     if (m_scrollableArea)
529         return m_scrollableArea->convertFromContainingViewToScrollbar(this, parentRect);
530
531     return Widget::convertFromContainingView(parentRect);
532 }
533
534 IntPoint Scrollbar::convertToContainingView(const IntPoint& localPoint) const
535 {
536     if (m_scrollableArea)
537         return m_scrollableArea->convertFromScrollbarToContainingView(this, localPoint);
538
539     return Widget::convertToContainingView(localPoint);
540 }
541
542 IntPoint Scrollbar::convertFromContainingView(const IntPoint& parentPoint) const
543 {
544     if (m_scrollableArea)
545         return m_scrollableArea->convertFromContainingViewToScrollbar(this, parentPoint);
546
547     return Widget::convertFromContainingView(parentPoint);
548 }
549
550 bool Scrollbar::supportsUpdateOnSecondaryThread() const
551 {
552     // It's unfortunate that this needs to be done with an ifdef. Ideally there would be a way to feature-detect
553     // the necessary support within AppKit.
554 #if ENABLE(ASYNC_SCROLLING) && PLATFORM(MAC) && __MAC_OS_X_VERSION_MIN_REQUIRED >= 101000
555     return !m_scrollableArea->forceUpdateScrollbarsOnMainThreadForPerformanceTesting()
556         && (m_scrollableArea->hasLayerForVerticalScrollbar() || m_scrollableArea->hasLayerForHorizontalScrollbar());
557 #else
558     return false;
559 #endif
560 }
561
562 ScrollView* Scrollbar::root() const
563 {
564     return Widget::root();
565 }
566
567 } // namespace WebCore