99b32fd8b4eae3e3105230f5f3c20f45b47fc0c1
[WebKit-https.git] / 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 "AccessibilityScrollbar.h"
30 #include "AXObjectCache.h"
31 #include "EventHandler.h"
32 #include "Frame.h"
33 #include "FrameView.h"
34 #include "GraphicsContext.h"
35 #include "PlatformMouseEvent.h"
36 #include "ScrollbarClient.h"
37 #include "ScrollbarTheme.h"
38
39 #include <algorithm>
40
41 using namespace std;
42
43 #if PLATFORM(CHROMIUM) && OS(LINUX) || PLATFORM(GTK)
44 // The position of the scrollbar thumb affects the appearance of the steppers, so
45 // when the thumb moves, we have to invalidate them for painting.
46 #define THUMB_POSITION_AFFECTS_BUTTONS
47 #endif
48
49 namespace WebCore {
50
51 #if !PLATFORM(EFL)
52 PassRefPtr<Scrollbar> Scrollbar::createNativeScrollbar(ScrollbarClient* client, ScrollbarOrientation orientation, ScrollbarControlSize size)
53 {
54     return adoptRef(new Scrollbar(client, orientation, size));
55 }
56 #endif
57
58 int Scrollbar::maxOverlapBetweenPages()
59 {
60     static int maxOverlapBetweenPages = ScrollbarTheme::nativeTheme()->maxOverlapBetweenPages();
61     return maxOverlapBetweenPages;
62 }
63
64 Scrollbar::Scrollbar(ScrollbarClient* client, ScrollbarOrientation orientation, ScrollbarControlSize controlSize,
65                      ScrollbarTheme* theme)
66     : m_client(client)
67     , m_orientation(orientation)
68     , m_controlSize(controlSize)
69     , m_theme(theme)
70     , m_visibleSize(0)
71     , m_totalSize(0)
72     , m_currentPos(0)
73     , m_dragOrigin(0)
74     , m_lineStep(0)
75     , m_pageStep(0)
76     , m_pixelStep(1)
77     , m_hoveredPart(NoPart)
78     , m_pressedPart(NoPart)
79     , m_pressedPos(0)
80     , m_enabled(true)
81     , m_scrollTimer(this, &Scrollbar::autoscrollTimerFired)
82     , m_overlapsResizer(false)
83     , m_suppressInvalidation(false)
84 {
85     if (!m_theme)
86         m_theme = ScrollbarTheme::nativeTheme();
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
97 Scrollbar::~Scrollbar()
98 {
99     stopTimerIfNeeded();
100     
101     m_theme->unregisterScrollbar(this);
102 }
103
104 bool Scrollbar::setValue(int v)
105 {
106     v = max(min(v, m_totalSize - m_visibleSize), 0);
107     if (value() == v)
108         return false; // Our value stayed the same.
109     setCurrentPos(v);
110     return true;
111 }
112
113 void Scrollbar::setProportion(int visibleSize, int totalSize)
114 {
115     if (visibleSize == m_visibleSize && totalSize == m_totalSize)
116         return;
117
118     m_visibleSize = visibleSize;
119     m_totalSize = totalSize;
120
121     updateThumbProportion();
122 }
123
124 void Scrollbar::setSteps(int lineStep, int pageStep, int pixelsPerStep)
125 {
126     m_lineStep = lineStep;
127     m_pageStep = pageStep;
128     m_pixelStep = 1.0f / pixelsPerStep;
129 }
130
131 bool Scrollbar::scroll(ScrollDirection direction, ScrollGranularity granularity, float multiplier)
132 {
133 #if HAVE(ACCESSIBILITY)
134     if (AXObjectCache::accessibilityEnabled()) {
135         if (parent() && parent()->isFrameView()) {
136             Document* document = static_cast<FrameView*>(parent())->frame()->document();
137             AXObjectCache* cache = document->axObjectCache();
138             AccessibilityScrollbar* axObject = static_cast<AccessibilityScrollbar*>(cache->getOrCreate(ScrollBarRole));
139             axObject->setScrollbar(this);
140             cache->postNotification(axObject, document, AXObjectCache::AXValueChanged, true);
141         }
142     }
143 #endif
144
145     // Ignore perpendicular scrolls.
146     if ((m_orientation == HorizontalScrollbar) ? (direction == ScrollUp || direction == ScrollDown) : (direction == ScrollLeft || direction == ScrollRight))
147         return false;
148     float step = 0;
149     switch (granularity) {
150     case ScrollByLine:     step = m_lineStep;  break;
151     case ScrollByPage:     step = m_pageStep;  break;
152     case ScrollByDocument: step = m_totalSize; break;
153     case ScrollByPixel:    step = m_pixelStep; break;
154     }
155     if (direction == ScrollUp || direction == ScrollLeft)
156         multiplier = -multiplier;
157
158     return setCurrentPos(max(min(m_currentPos + (step * multiplier), static_cast<float>(m_totalSize - m_visibleSize)), 0.0f));
159 }
160
161 void Scrollbar::updateThumb()
162 {
163 #ifdef THUMB_POSITION_AFFECTS_BUTTONS
164     invalidate();
165 #else
166     theme()->invalidateParts(this, ForwardTrackPart | BackTrackPart | ThumbPart);
167 #endif
168 }
169
170 void Scrollbar::updateThumbPosition()
171 {
172     updateThumb();
173 }
174
175 void Scrollbar::updateThumbProportion()
176 {
177     updateThumb();
178 }
179
180 void Scrollbar::paint(GraphicsContext* context, const IntRect& damageRect)
181 {
182     if (context->updatingControlTints() && theme()->supportsControlTints()) {
183         invalidate();
184         return;
185     }
186
187     if (context->paintingDisabled() || !frameRect().intersects(damageRect))
188         return;
189
190     if (!theme()->paint(this, context, damageRect))
191         Widget::paint(context, damageRect);
192 }
193
194 void Scrollbar::autoscrollTimerFired(Timer<Scrollbar>*)
195 {
196     autoscrollPressedPart(theme()->autoscrollTimerDelay());
197 }
198
199 static bool thumbUnderMouse(Scrollbar* scrollbar)
200 {
201     int thumbPos = scrollbar->theme()->trackPosition(scrollbar) + scrollbar->theme()->thumbPosition(scrollbar);
202     int thumbLength = scrollbar->theme()->thumbLength(scrollbar);
203     return scrollbar->pressedPos() >= thumbPos && scrollbar->pressedPos() < thumbPos + thumbLength;
204 }
205
206 void Scrollbar::autoscrollPressedPart(double delay)
207 {
208     // Don't do anything for the thumb or if nothing was pressed.
209     if (m_pressedPart == ThumbPart || m_pressedPart == NoPart)
210         return;
211
212     // Handle the track.
213     if ((m_pressedPart == BackTrackPart || m_pressedPart == ForwardTrackPart) && thumbUnderMouse(this)) {
214         theme()->invalidatePart(this, m_pressedPart);
215         setHoveredPart(ThumbPart);
216         return;
217     }
218
219     // Handle the arrows and track.
220     if (scroll(pressedPartScrollDirection(), pressedPartScrollGranularity()))
221         startTimerIfNeeded(delay);
222 }
223
224 void Scrollbar::startTimerIfNeeded(double delay)
225 {
226     // Don't do anything for the thumb.
227     if (m_pressedPart == ThumbPart)
228         return;
229
230     // Handle the track.  We halt track scrolling once the thumb is level
231     // with us.
232     if ((m_pressedPart == BackTrackPart || m_pressedPart == ForwardTrackPart) && thumbUnderMouse(this)) {
233         theme()->invalidatePart(this, m_pressedPart);
234         setHoveredPart(ThumbPart);
235         return;
236     }
237
238     // We can't scroll if we've hit the beginning or end.
239     ScrollDirection dir = pressedPartScrollDirection();
240     if (dir == ScrollUp || dir == ScrollLeft) {
241         if (m_currentPos == 0)
242             return;
243     } else {
244         if (m_currentPos == maximum())
245             return;
246     }
247
248     m_scrollTimer.startOneShot(delay);
249 }
250
251 void Scrollbar::stopTimerIfNeeded()
252 {
253     if (m_scrollTimer.isActive())
254         m_scrollTimer.stop();
255 }
256
257 ScrollDirection Scrollbar::pressedPartScrollDirection()
258 {
259     if (m_orientation == HorizontalScrollbar) {
260         if (m_pressedPart == BackButtonStartPart || m_pressedPart == BackButtonEndPart || m_pressedPart == BackTrackPart)
261             return ScrollLeft;
262         return ScrollRight;
263     } else {
264         if (m_pressedPart == BackButtonStartPart || m_pressedPart == BackButtonEndPart || m_pressedPart == BackTrackPart)
265             return ScrollUp;
266         return ScrollDown;
267     }
268 }
269
270 ScrollGranularity Scrollbar::pressedPartScrollGranularity()
271 {
272     if (m_pressedPart == BackButtonStartPart || m_pressedPart == BackButtonEndPart ||  m_pressedPart == ForwardButtonStartPart || m_pressedPart == ForwardButtonEndPart)
273         return ScrollByLine;
274     return ScrollByPage;
275 }
276
277 void Scrollbar::moveThumb(int pos)
278 {
279     // Drag the thumb.
280     int thumbPos = theme()->thumbPosition(this);
281     int thumbLen = theme()->thumbLength(this);
282     int trackLen = theme()->trackLength(this);
283     int maxPos = trackLen - thumbLen;
284     int delta = pos - m_pressedPos;
285     if (delta > 0)
286         delta = min(maxPos - thumbPos, delta);
287     else if (delta < 0)
288         delta = max(-thumbPos, delta);
289     if (delta)
290         setCurrentPos(static_cast<float>(thumbPos + delta) * maximum() / (trackLen - thumbLen));
291 }
292
293 bool Scrollbar::setCurrentPos(float pos)
294 {
295     if (pos == m_currentPos)
296         return false;
297
298     int oldValue = value();
299     int oldThumbPos = theme()->thumbPosition(this);
300     m_currentPos = pos;
301     updateThumbPosition();
302     if (m_pressedPart == ThumbPart)
303         setPressedPos(m_pressedPos + theme()->thumbPosition(this) - oldThumbPos);
304
305     if (value() != oldValue && client())
306         client()->valueChanged(this);
307     return true;
308 }
309
310 void Scrollbar::setHoveredPart(ScrollbarPart part)
311 {
312     if (part == m_hoveredPart)
313         return;
314
315     if ((m_hoveredPart == NoPart || part == NoPart) && theme()->invalidateOnMouseEnterExit())
316         invalidate();  // Just invalidate the whole scrollbar, since the buttons at either end change anyway.
317     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.
318         theme()->invalidatePart(this, part);
319         theme()->invalidatePart(this, m_hoveredPart);
320     }
321     m_hoveredPart = part;
322 }
323
324 void Scrollbar::setPressedPart(ScrollbarPart part)
325 {
326     if (m_pressedPart != NoPart)
327         theme()->invalidatePart(this, m_pressedPart);
328     m_pressedPart = part;
329     if (m_pressedPart != NoPart)
330         theme()->invalidatePart(this, m_pressedPart);
331     else if (m_hoveredPart != NoPart)  // When we no longer have a pressed part, we can start drawing a hovered state on the hovered part.
332         theme()->invalidatePart(this, m_hoveredPart);
333 }
334
335 bool Scrollbar::mouseMoved(const PlatformMouseEvent& evt)
336 {
337     if (m_pressedPart == ThumbPart) {
338         if (theme()->shouldSnapBackToDragOrigin(this, evt))
339             setCurrentPos(m_dragOrigin);
340         else {
341             moveThumb(m_orientation == HorizontalScrollbar ? 
342                       convertFromContainingWindow(evt.pos()).x() :
343                       convertFromContainingWindow(evt.pos()).y());
344         }
345         return true;
346     }
347
348     if (m_pressedPart != NoPart)
349         m_pressedPos = (orientation() == HorizontalScrollbar ? convertFromContainingWindow(evt.pos()).x() : convertFromContainingWindow(evt.pos()).y());
350
351     ScrollbarPart part = theme()->hitTest(this, evt);    
352     if (part != m_hoveredPart) {
353         if (m_pressedPart != NoPart) {
354             if (part == m_pressedPart) {
355                 // The mouse is moving back over the pressed part.  We
356                 // need to start up the timer action again.
357                 startTimerIfNeeded(theme()->autoscrollTimerDelay());
358                 theme()->invalidatePart(this, m_pressedPart);
359             } else if (m_hoveredPart == m_pressedPart) {
360                 // The mouse is leaving the pressed part.  Kill our timer
361                 // if needed.
362                 stopTimerIfNeeded();
363                 theme()->invalidatePart(this, m_pressedPart);
364             }
365         } 
366         
367         setHoveredPart(part);
368     } 
369
370     return true;
371 }
372
373 bool Scrollbar::mouseExited()
374 {
375     setHoveredPart(NoPart);
376     return true;
377 }
378
379 bool Scrollbar::mouseUp()
380 {
381     setPressedPart(NoPart);
382     m_pressedPos = 0;
383     stopTimerIfNeeded();
384
385     if (parent() && parent()->isFrameView())
386         static_cast<FrameView*>(parent())->frame()->eventHandler()->setMousePressed(false);
387
388     return true;
389 }
390
391 bool Scrollbar::mouseDown(const PlatformMouseEvent& evt)
392 {
393     // Early exit for right click
394     if (evt.button() == RightButton)
395         return true; // FIXME: Handled as context menu by Qt right now.  Should just avoid even calling this method on a right click though.
396
397     setPressedPart(theme()->hitTest(this, evt));
398     int pressedPos = (orientation() == HorizontalScrollbar ? convertFromContainingWindow(evt.pos()).x() : convertFromContainingWindow(evt.pos()).y());
399     
400     if ((m_pressedPart == BackTrackPart || m_pressedPart == ForwardTrackPart) && theme()->shouldCenterOnThumb(this, evt)) {
401         setHoveredPart(ThumbPart);
402         setPressedPart(ThumbPart);
403         m_dragOrigin = m_currentPos;
404         int thumbLen = theme()->thumbLength(this);
405         int desiredPos = pressedPos;
406         // Set the pressed position to the middle of the thumb so that when we do the move, the delta
407         // will be from the current pixel position of the thumb to the new desired position for the thumb.
408         m_pressedPos = theme()->trackPosition(this) + theme()->thumbPosition(this) + thumbLen / 2;
409         moveThumb(desiredPos);
410         return true;
411     } else if (m_pressedPart == ThumbPart)
412         m_dragOrigin = m_currentPos;
413     
414     m_pressedPos = pressedPos;
415
416     autoscrollPressedPart(theme()->initialAutoscrollTimerDelay());
417     return true;
418 }
419
420 void Scrollbar::setFrameRect(const IntRect& rect)
421 {
422     // Get our window resizer rect and see if we overlap.  Adjust to avoid the overlap
423     // if necessary.
424     IntRect adjustedRect(rect);
425     bool overlapsResizer = false;
426     ScrollView* view = parent();
427     if (view && !rect.isEmpty() && !view->windowResizerRect().isEmpty()) {
428         IntRect resizerRect = view->convertFromContainingWindow(view->windowResizerRect());
429         if (rect.intersects(resizerRect)) {
430             if (orientation() == HorizontalScrollbar) {
431                 int overlap = rect.right() - resizerRect.x();
432                 if (overlap > 0 && resizerRect.right() >= rect.right()) {
433                     adjustedRect.setWidth(rect.width() - overlap);
434                     overlapsResizer = true;
435                 }
436             } else {
437                 int overlap = rect.bottom() - resizerRect.y();
438                 if (overlap > 0 && resizerRect.bottom() >= rect.bottom()) {
439                     adjustedRect.setHeight(rect.height() - overlap);
440                     overlapsResizer = true;
441                 }
442             }
443         }
444     }
445     if (overlapsResizer != m_overlapsResizer) {
446         m_overlapsResizer = overlapsResizer;
447         if (view)
448             view->adjustScrollbarsAvoidingResizerCount(m_overlapsResizer ? 1 : -1);
449     }
450
451     Widget::setFrameRect(adjustedRect);
452 }
453
454 void Scrollbar::setParent(ScrollView* parentView)
455 {
456     if (!parentView && m_overlapsResizer && parent())
457         parent()->adjustScrollbarsAvoidingResizerCount(-1);
458     Widget::setParent(parentView);
459 }
460
461 void Scrollbar::setEnabled(bool e)
462
463     if (m_enabled == e)
464         return;
465     m_enabled = e;
466     invalidate();
467 }
468
469 bool Scrollbar::isWindowActive() const
470 {
471     return m_client && m_client->isActive();
472 }
473  
474 void Scrollbar::invalidateRect(const IntRect& rect)
475 {
476     if (suppressInvalidation())
477         return;
478     if (m_client)
479         m_client->invalidateScrollbarRect(this, rect);
480 }
481
482 IntRect Scrollbar::convertToContainingView(const IntRect& localRect) const
483 {
484     if (m_client)
485         return m_client->convertFromScrollbarToContainingView(this, localRect);
486
487     return Widget::convertToContainingView(localRect);
488 }
489
490 IntRect Scrollbar::convertFromContainingView(const IntRect& parentRect) const
491 {
492     if (m_client)
493         return m_client->convertFromContainingViewToScrollbar(this, parentRect);
494
495     return Widget::convertFromContainingView(parentRect);
496 }
497
498 IntPoint Scrollbar::convertToContainingView(const IntPoint& localPoint) const
499 {
500     if (m_client)
501         return m_client->convertFromScrollbarToContainingView(this, localPoint);
502
503     return Widget::convertToContainingView(localPoint);
504 }
505
506 IntPoint Scrollbar::convertFromContainingView(const IntPoint& parentPoint) const
507 {
508     if (m_client)
509         return m_client->convertFromContainingViewToScrollbar(this, parentPoint);
510
511     return Widget::convertFromContainingView(parentPoint);
512 }
513
514 }