src/third_party/WebKit/Source/platform/scroll/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 "platform/scroll/Scrollbar.h"
  28
  29 #include <algorithm>
  30 #include "platform/graphics/GraphicsContext.h"
  31 #include "platform/PlatformGestureEvent.h"
  32 #include "platform/PlatformMouseEvent.h"
  33 #include "platform/scroll/ScrollAnimator.h"
  34 #include "platform/scroll/ScrollView.h"
  35 #include "platform/scroll/ScrollableArea.h"
  36 #include "platform/scroll/ScrollbarTheme.h"
  37
  38 #if ((OS(POSIX) && !OS(MACOSX)) || OS(WIN))
  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 blink {
  45
  46 PassRefPtr<Scrollbar> Scrollbar::create(ScrollableArea* scrollableArea, ScrollbarOrientation orientation, ScrollbarControlSize size)
  47 {
  48     return adoptRef(new Scrollbar(scrollableArea, orientation, size));
  49 }
  50
  51 Scrollbar::Scrollbar(ScrollableArea* scrollableArea, ScrollbarOrientation orientation, ScrollbarControlSize controlSize, ScrollbarTheme* theme)
  52     : m_scrollableArea(scrollableArea)
  53     , m_orientation(orientation)
  54     , m_controlSize(controlSize)
  55     , m_theme(theme)
  56     , m_visibleSize(0)
  57     , m_totalSize(0)
  58     , m_currentPos(0)
  59     , m_dragOrigin(0)
  60     , m_hoveredPart(NoPart)
  61     , m_pressedPart(NoPart)
  62     , m_pressedPos(0)
  63     , m_scrollPos(0)
  64     , m_draggingDocument(false)
  65     , m_documentDragPos(0)
  66     , m_enabled(true)
  67     , m_scrollTimer(this, &Scrollbar::autoscrollTimerFired)
  68     , m_overlapsResizer(false)
  69     , m_suppressInvalidation(false)
  70     , m_isAlphaLocked(false)
  71 {
  72     if (!m_theme)
  73         m_theme = ScrollbarTheme::theme();
  74
  75     m_theme->registerScrollbar(this);
  76
  77     // FIXME: This is ugly and would not be necessary if we fix cross-platform code to actually query for
  78     // scrollbar thickness and use it when sizing scrollbars (rather than leaving one dimension of the scrollbar
  79     // alone when sizing).
  80     int thickness = m_theme->scrollbarThickness(controlSize);
  81     Widget::setFrameRect(IntRect(0, 0, thickness, thickness));
  82
  83     m_currentPos = scrollableAreaCurrentPos();
  84 }
  85
  86 Scrollbar::~Scrollbar()
  87 {
  88     stopTimerIfNeeded();
  89
  90     m_theme->unregisterScrollbar(this);
  91 }
  92
  93 void Scrollbar::removeFromParent()
  94 {
  95     if (parent())
  96         toScrollView(parent())->removeChild(this);
  97 }
  98
  99 ScrollView* Scrollbar::parentScrollView() const
 100 {
 101     return parent() && parent()->isScrollView() ? toScrollView(parent()) : 0;
 102 }
 103
 104 ScrollbarOverlayStyle Scrollbar::scrollbarOverlayStyle() const
 105 {
 106     return m_scrollableArea ? m_scrollableArea->scrollbarOverlayStyle() : ScrollbarOverlayStyleDefault;
 107 }
 108
 109 void Scrollbar::getTickmarks(Vector<IntRect>& tickmarks) const
 110 {
 111     if (m_scrollableArea)
 112         m_scrollableArea->getTickmarks(tickmarks);
 113 }
 114
 115 bool Scrollbar::isScrollableAreaActive() const
 116 {
 117     return m_scrollableArea && m_scrollableArea->isActive();
 118 }
 119
 120 bool Scrollbar::isScrollViewScrollbar() const
 121 {
 122     return parent() && parent()->isFrameView() && toScrollView(parent())->isScrollViewScrollbar(this);
 123 }
 124
 125 bool Scrollbar::isLeftSideVerticalScrollbar() const
 126 {
 127     if (m_orientation == VerticalScrollbar && m_scrollableArea)
 128         return m_scrollableArea->shouldPlaceVerticalScrollbarOnLeft();
 129     return false;
 130 }
 131
 132 void Scrollbar::offsetDidChange()
 133 {
 134     ASSERT(m_scrollableArea);
 135
 136     float position = scrollableAreaCurrentPos();
 137     if (position == m_currentPos)
 138         return;
 139
 140     int oldThumbPosition = theme()->thumbPosition(this);
 141     m_currentPos = position;
 142     updateThumbPosition();
 143     if (m_pressedPart == ThumbPart)
 144         setPressedPos(m_pressedPos + theme()->thumbPosition(this) - oldThumbPosition);
 145 }
 146
 147 void Scrollbar::setProportion(int visibleSize, int totalSize)
 148 {
 149     if (visibleSize == m_visibleSize && totalSize == m_totalSize)
 150         return;
 151
 152     m_visibleSize = visibleSize;
 153     m_totalSize = totalSize;
 154
 155     updateThumbProportion();
 156 }
 157
 158 void Scrollbar::updateThumb()
 159 {
 160 #ifdef THUMB_POSITION_AFFECTS_BUTTONS
 161     invalidate();
 162 #else
 163     theme()->invalidateParts(this, ForwardTrackPart | BackTrackPart | ThumbPart);
 164 #endif
 165 }
 166
 167 void Scrollbar::updateThumbPosition()
 168 {
 169     updateThumb();
 170 }
 171
 172 void Scrollbar::updateThumbProportion()
 173 {
 174     updateThumb();
 175 }
 176
 177 void Scrollbar::paint(GraphicsContext* context, const IntRect& damageRect)
 178 {
 179     if (!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, FROM_HERE);
 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         float destinationPosition = (m_orientation == HorizontalScrollbar ? currentPosition.x() : currentPosition.y()) + delta;
 282         destinationPosition = m_scrollableArea->clampScrollPosition(m_orientation, destinationPosition);
 283         m_scrollableArea->scrollToOffsetWithoutAnimation(m_orientation, destinationPosition);
 284         m_documentDragPos = pos;
 285         return;
 286     }
 287
 288     if (m_draggingDocument) {
 289         delta += m_pressedPos - m_documentDragPos;
 290         m_draggingDocument = false;
 291     }
 292
 293     // Drag the thumb.
 294     int thumbPos = theme()->thumbPosition(this);
 295     int thumbLen = theme()->thumbLength(this);
 296     int trackLen = theme()->trackLength(this);
 297     if (delta > 0)
 298         delta = std::min(trackLen - thumbLen - thumbPos, delta);
 299     else if (delta < 0)
 300         delta = std::max(-thumbPos, delta);
 301
 302     float minPos = m_scrollableArea->minimumScrollPosition(m_orientation);
 303     float maxPos = m_scrollableArea->maximumScrollPosition(m_orientation);
 304     if (delta) {
 305         float newPosition = static_cast<float>(thumbPos + delta) * (maxPos - minPos) / (trackLen - thumbLen) + minPos;
 306         m_scrollableArea->scrollToOffsetWithoutAnimation(m_orientation, newPosition);
 307     }
 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::gestureEvent(const PlatformGestureEvent& evt)
 336 {
 337     switch (evt.type()) {
 338     case PlatformEvent::GestureTapDown:
 339         setPressedPart(theme()->hitTest(this, evt.position()));
 340         m_pressedPos = orientation() == HorizontalScrollbar ? convertFromContainingWindow(evt.position()).x() : convertFromContainingWindow(evt.position()).y();
 341         return true;
 342     case PlatformEvent::GestureTapDownCancel:
 343     case PlatformEvent::GestureScrollBegin:
 344         if (m_pressedPart != ThumbPart)
 345             return false;
 346         m_scrollPos = m_pressedPos;
 347         return true;
 348     case PlatformEvent::GestureScrollUpdate:
 349     case PlatformEvent::GestureScrollUpdateWithoutPropagation:
 350         if (m_pressedPart != ThumbPart)
 351             return false;
 352         m_scrollPos += orientation() == HorizontalScrollbar ? evt.deltaX() : evt.deltaY();
 353         moveThumb(m_scrollPos, false);
 354         return true;
 355     case PlatformEvent::GestureScrollEnd:
 356     case PlatformEvent::GestureLongPress:
 357     case PlatformEvent::GestureFlingStart:
 358         m_scrollPos = 0;
 359         m_pressedPos = 0;
 360         setPressedPart(NoPart);
 361         return false;
 362     case PlatformEvent::GestureTap: {
 363         if (m_pressedPart != ThumbPart && m_pressedPart != NoPart && m_scrollableArea
 364             && m_scrollableArea->scroll(pressedPartScrollDirection(), pressedPartScrollGranularity())) {
 365             return true;
 366         }
 367         m_scrollPos = 0;
 368         m_pressedPos = 0;
 369         setPressedPart(NoPart);
 370         return false;
 371     }
 372     default:
 373         // By default, we assume that gestures don't deselect the scrollbar.
 374         return true;
 375     }
 376 }
 377
 378 void Scrollbar::mouseMoved(const PlatformMouseEvent& evt)
 379 {
 380     if (m_pressedPart == ThumbPart) {
 381         if (theme()->shouldSnapBackToDragOrigin(this, evt)) {
 382             if (m_scrollableArea)
 383                 m_scrollableArea->scrollToOffsetWithoutAnimation(m_orientation, m_dragOrigin + m_scrollableArea->minimumScrollPosition(m_orientation));
 384         } else {
 385             moveThumb(m_orientation == HorizontalScrollbar ?
 386                       convertFromContainingWindow(evt.position()).x() :
 387                       convertFromContainingWindow(evt.position()).y(), theme()->shouldDragDocumentInsteadOfThumb(this, evt));
 388         }
 389         return;
 390     }
 391
 392     if (m_pressedPart != NoPart)
 393         m_pressedPos = orientation() == HorizontalScrollbar ? convertFromContainingWindow(evt.position()).x() : convertFromContainingWindow(evt.position()).y();
 394
 395     ScrollbarPart part = theme()->hitTest(this, evt.position());
 396     if (part != m_hoveredPart) {
 397         if (m_pressedPart != NoPart) {
 398             if (part == m_pressedPart) {
 399                 // The mouse is moving back over the pressed part.  We
 400                 // need to start up the timer action again.
 401                 startTimerIfNeeded(theme()->autoscrollTimerDelay());
 402                 theme()->invalidatePart(this, m_pressedPart);
 403             } else if (m_hoveredPart == m_pressedPart) {
 404                 // The mouse is leaving the pressed part.  Kill our timer
 405                 // if needed.
 406                 stopTimerIfNeeded();
 407                 theme()->invalidatePart(this, m_pressedPart);
 408             }
 409         }
 410
 411         setHoveredPart(part);
 412     }
 413
 414     return;
 415 }
 416
 417 void Scrollbar::mouseEntered()
 418 {
 419     if (m_scrollableArea)
 420         m_scrollableArea->mouseEnteredScrollbar(this);
 421 }
 422
 423 void Scrollbar::mouseExited()
 424 {
 425     if (m_scrollableArea)
 426         m_scrollableArea->mouseExitedScrollbar(this);
 427     setHoveredPart(NoPart);
 428 }
 429
 430 void Scrollbar::mouseUp(const PlatformMouseEvent& mouseEvent)
 431 {
 432     setPressedPart(NoPart);
 433     m_pressedPos = 0;
 434     m_draggingDocument = false;
 435     stopTimerIfNeeded();
 436
 437     if (m_scrollableArea) {
 438         // m_hoveredPart won't be updated until the next mouseMoved or mouseDown, so we have to hit test
 439         // to really know if the mouse has exited the scrollbar on a mouseUp.
 440         ScrollbarPart part = theme()->hitTest(this, mouseEvent.position());
 441         if (part == NoPart)
 442             m_scrollableArea->mouseExitedScrollbar(this);
 443     }
 444 }
 445
 446 void Scrollbar::mouseDown(const PlatformMouseEvent& evt)
 447 {
 448     // Early exit for right click
 449     if (evt.button() == RightButton)
 450         return;
 451
 452     setPressedPart(theme()->hitTest(this, evt.position()));
 453     int pressedPos = orientation() == HorizontalScrollbar ? convertFromContainingWindow(evt.position()).x() : convertFromContainingWindow(evt.position()).y();
 454
 455     if ((m_pressedPart == BackTrackPart || m_pressedPart == ForwardTrackPart) && theme()->shouldCenterOnThumb(this, evt)) {
 456         setHoveredPart(ThumbPart);
 457         setPressedPart(ThumbPart);
 458         m_dragOrigin = m_currentPos;
 459         int thumbLen = theme()->thumbLength(this);
 460         int desiredPos = pressedPos;
 461         // Set the pressed position to the middle of the thumb so that when we do the move, the delta
 462         // will be from the current pixel position of the thumb to the new desired position for the thumb.
 463         m_pressedPos = theme()->trackPosition(this) + theme()->thumbPosition(this) + thumbLen / 2;
 464         moveThumb(desiredPos);
 465         return;
 466     } else if (m_pressedPart == ThumbPart)
 467         m_dragOrigin = m_currentPos;
 468
 469     m_pressedPos = pressedPos;
 470
 471     autoscrollPressedPart(theme()->initialAutoscrollTimerDelay());
 472 }
 473
 474 void Scrollbar::setFrameRect(const IntRect& rect)
 475 {
 476     // Get our window resizer rect and see if we overlap. Adjust to avoid the overlap
 477     // if necessary.
 478     IntRect adjustedRect(rect);
 479     bool overlapsResizer = false;
 480     ScrollView* view = parentScrollView();
 481     if (view && !rect.isEmpty() && !view->windowResizerRect().isEmpty()) {
 482         IntRect resizerRect = view->convertFromContainingWindow(view->windowResizerRect());
 483         if (rect.intersects(resizerRect)) {
 484             if (orientation() == HorizontalScrollbar) {
 485                 int overlap = rect.maxX() - resizerRect.x();
 486                 if (overlap > 0 && resizerRect.maxX() >= rect.maxX()) {
 487                     adjustedRect.setWidth(rect.width() - overlap);
 488                     overlapsResizer = true;
 489                 }
 490             } else {
 491                 int overlap = rect.maxY() - resizerRect.y();
 492                 if (overlap > 0 && resizerRect.maxY() >= rect.maxY()) {
 493                     adjustedRect.setHeight(rect.height() - overlap);
 494                     overlapsResizer = true;
 495                 }
 496             }
 497         }
 498     }
 499     if (overlapsResizer != m_overlapsResizer) {
 500         m_overlapsResizer = overlapsResizer;
 501         if (view)
 502             view->adjustScrollbarsAvoidingResizerCount(m_overlapsResizer ? 1 : -1);
 503     }
 504
 505     Widget::setFrameRect(adjustedRect);
 506 }
 507
 508 void Scrollbar::setParent(Widget* parentView)
 509 {
 510     if (!parentView && m_overlapsResizer && parentScrollView())
 511         parentScrollView()->adjustScrollbarsAvoidingResizerCount(-1);
 512     Widget::setParent(parentView);
 513 }
 514
 515 void Scrollbar::setEnabled(bool e)
 516 {
 517     if (m_enabled == e)
 518         return;
 519     m_enabled = e;
 520     theme()->updateEnabledState(this);
 521     invalidate();
 522 }
 523
 524 bool Scrollbar::isOverlayScrollbar() const
 525 {
 526     return m_theme->usesOverlayScrollbars();
 527 }
 528
 529 bool Scrollbar::shouldParticipateInHitTesting()
 530 {
 531     // Non-overlay scrollbars should always participate in hit testing.
 532     if (!isOverlayScrollbar())
 533         return true;
 534     return m_scrollableArea->scrollAnimator()->shouldScrollbarParticipateInHitTesting(this);
 535 }
 536
 537 bool Scrollbar::isWindowActive() const
 538 {
 539     return m_scrollableArea && m_scrollableArea->isActive();
 540 }
 541
 542 void Scrollbar::invalidateRect(const IntRect& rect)
 543 {
 544     if (suppressInvalidation())
 545         return;
 546
 547     if (m_scrollableArea)
 548         m_scrollableArea->invalidateScrollbar(this, rect);
 549 }
 550
 551 IntRect Scrollbar::convertToContainingView(const IntRect& localRect) const
 552 {
 553     if (m_scrollableArea)
 554         return m_scrollableArea->convertFromScrollbarToContainingView(this, localRect);
 555
 556     return Widget::convertToContainingView(localRect);
 557 }
 558
 559 IntRect Scrollbar::convertFromContainingView(const IntRect& parentRect) const
 560 {
 561     if (m_scrollableArea)
 562         return m_scrollableArea->convertFromContainingViewToScrollbar(this, parentRect);
 563
 564     return Widget::convertFromContainingView(parentRect);
 565 }
 566
 567 IntPoint Scrollbar::convertToContainingView(const IntPoint& localPoint) const
 568 {
 569     if (m_scrollableArea)
 570         return m_scrollableArea->convertFromScrollbarToContainingView(this, localPoint);
 571
 572     return Widget::convertToContainingView(localPoint);
 573 }
 574
 575 IntPoint Scrollbar::convertFromContainingView(const IntPoint& parentPoint) const
 576 {
 577     if (m_scrollableArea)
 578         return m_scrollableArea->convertFromContainingViewToScrollbar(this, parentPoint);
 579
 580     return Widget::convertFromContainingView(parentPoint);
 581 }
 582
 583 float Scrollbar::scrollableAreaCurrentPos() const
 584 {
 585     if (!m_scrollableArea)
 586         return 0;
 587
 588     if (m_orientation == HorizontalScrollbar)
 589         return m_scrollableArea->scrollPosition().x() - m_scrollableArea->minimumScrollPosition().x();
 590
 591     return m_scrollableArea->scrollPosition().y() - m_scrollableArea->minimumScrollPosition().y();
 592 }
 593
 594 } // namespace blink