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