src/third_party/WebKit/Source/platform/scroll/ScrollView.cpp

   1 /*
   2  * Copyright (C) 2006, 2007, 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/ScrollView.h"
  28
  29 #include "platform/graphics/GraphicsContextStateSaver.h"
  30 #include "platform/graphics/GraphicsLayer.h"
  31 #include "platform/HostWindow.h"
  32 #include "platform/scroll/ScrollbarTheme.h"
  33 #include "wtf/StdLibExtras.h"
  34
  35 namespace blink {
  36
  37 ScrollView::ScrollView()
  38     : m_horizontalScrollbarMode(ScrollbarAuto)
  39     , m_verticalScrollbarMode(ScrollbarAuto)
  40     , m_horizontalScrollbarLock(false)
  41     , m_verticalScrollbarLock(false)
  42     , m_scrollbarsAvoidingResizer(0)
  43     , m_scrollbarsSuppressed(false)
  44     , m_inUpdateScrollbars(false)
  45     , m_drawPanScrollIcon(false)
  46     , m_clipsRepaints(true)
  47 {
  48 }
  49
  50 ScrollView::~ScrollView()
  51 {
  52 }
  53
  54 void ScrollView::addChild(PassRefPtr<Widget> prpChild)
  55 {
  56     Widget* child = prpChild.get();
  57     ASSERT(child != this && !child->parent());
  58     child->setParent(this);
  59     m_children.add(prpChild);
  60 }
  61
  62 void ScrollView::removeChild(Widget* child)
  63 {
  64     ASSERT(child->parent() == this);
  65     child->setParent(0);
  66     m_children.remove(child);
  67 }
  68
  69 void ScrollView::setHasHorizontalScrollbar(bool hasBar)
  70 {
  71     if (hasBar && !m_horizontalScrollbar) {
  72         m_horizontalScrollbar = createScrollbar(HorizontalScrollbar);
  73         addChild(m_horizontalScrollbar.get());
  74         didAddScrollbar(m_horizontalScrollbar.get(), HorizontalScrollbar);
  75         m_horizontalScrollbar->styleChanged();
  76     } else if (!hasBar && m_horizontalScrollbar) {
  77         willRemoveScrollbar(m_horizontalScrollbar.get(), HorizontalScrollbar);
  78         removeChild(m_horizontalScrollbar.get());
  79         m_horizontalScrollbar = nullptr;
  80     }
  81 }
  82
  83 void ScrollView::setHasVerticalScrollbar(bool hasBar)
  84 {
  85     if (hasBar && !m_verticalScrollbar) {
  86         m_verticalScrollbar = createScrollbar(VerticalScrollbar);
  87         addChild(m_verticalScrollbar.get());
  88         didAddScrollbar(m_verticalScrollbar.get(), VerticalScrollbar);
  89         m_verticalScrollbar->styleChanged();
  90     } else if (!hasBar && m_verticalScrollbar) {
  91         willRemoveScrollbar(m_verticalScrollbar.get(), VerticalScrollbar);
  92         removeChild(m_verticalScrollbar.get());
  93         m_verticalScrollbar = nullptr;
  94     }
  95 }
  96
  97 PassRefPtr<Scrollbar> ScrollView::createScrollbar(ScrollbarOrientation orientation)
  98 {
  99     return Scrollbar::create(this, orientation, RegularScrollbar);
 100 }
 101
 102 void ScrollView::setScrollbarModes(ScrollbarMode horizontalMode, ScrollbarMode verticalMode,
 103                                    bool horizontalLock, bool verticalLock)
 104 {
 105     bool needsUpdate = false;
 106
 107     if (horizontalMode != horizontalScrollbarMode() && !m_horizontalScrollbarLock) {
 108         m_horizontalScrollbarMode = horizontalMode;
 109         needsUpdate = true;
 110     }
 111
 112     if (verticalMode != verticalScrollbarMode() && !m_verticalScrollbarLock) {
 113         m_verticalScrollbarMode = verticalMode;
 114         needsUpdate = true;
 115     }
 116
 117     if (horizontalLock)
 118         setHorizontalScrollbarLock();
 119
 120     if (verticalLock)
 121         setVerticalScrollbarLock();
 122
 123     if (!needsUpdate)
 124         return;
 125
 126     updateScrollbars(scrollOffset());
 127
 128     if (!layerForScrolling())
 129         return;
 130     blink::WebLayer* layer = layerForScrolling()->platformLayer();
 131     if (!layer)
 132         return;
 133     layer->setUserScrollable(userInputScrollable(HorizontalScrollbar), userInputScrollable(VerticalScrollbar));
 134 }
 135
 136 void ScrollView::scrollbarModes(ScrollbarMode& horizontalMode, ScrollbarMode& verticalMode) const
 137 {
 138     horizontalMode = m_horizontalScrollbarMode;
 139     verticalMode = m_verticalScrollbarMode;
 140 }
 141
 142 void ScrollView::setCanHaveScrollbars(bool canScroll)
 143 {
 144     ScrollbarMode newHorizontalMode;
 145     ScrollbarMode newVerticalMode;
 146
 147     scrollbarModes(newHorizontalMode, newVerticalMode);
 148
 149     if (canScroll && newVerticalMode == ScrollbarAlwaysOff)
 150         newVerticalMode = ScrollbarAuto;
 151     else if (!canScroll)
 152         newVerticalMode = ScrollbarAlwaysOff;
 153
 154     if (canScroll && newHorizontalMode == ScrollbarAlwaysOff)
 155         newHorizontalMode = ScrollbarAuto;
 156     else if (!canScroll)
 157         newHorizontalMode = ScrollbarAlwaysOff;
 158
 159     setScrollbarModes(newHorizontalMode, newVerticalMode);
 160 }
 161
 162 void ScrollView::setClipsRepaints(bool clipsRepaints)
 163 {
 164     m_clipsRepaints = clipsRepaints;
 165 }
 166
 167 IntSize ScrollView::unscaledVisibleContentSize(IncludeScrollbarsInRect scrollbarInclusion) const
 168 {
 169     return scrollbarInclusion == ExcludeScrollbars ? excludeScrollbars(frameRect().size()) : frameRect().size();
 170 }
 171
 172 IntSize ScrollView::excludeScrollbars(const IntSize& size) const
 173 {
 174     int verticalScrollbarWidth = 0;
 175     int horizontalScrollbarHeight = 0;
 176
 177     if (Scrollbar* verticalBar = verticalScrollbar())
 178         verticalScrollbarWidth = !verticalBar->isOverlayScrollbar() ? verticalBar->width() : 0;
 179     if (Scrollbar* horizontalBar = horizontalScrollbar())
 180         horizontalScrollbarHeight = !horizontalBar->isOverlayScrollbar() ? horizontalBar->height() : 0;
 181
 182     return IntSize(std::max(0, size.width() - verticalScrollbarWidth),
 183         std::max(0, size.height() - horizontalScrollbarHeight));
 184
 185 }
 186
 187 IntRect ScrollView::visibleContentRect(IncludeScrollbarsInRect scollbarInclusion) const
 188 {
 189     FloatSize visibleContentSize = unscaledVisibleContentSize(scollbarInclusion);
 190     visibleContentSize.scale(1 / visibleContentScaleFactor());
 191     return IntRect(IntPoint(m_scrollOffset), expandedIntSize(visibleContentSize));
 192 }
 193
 194 IntSize ScrollView::contentsSize() const
 195 {
 196     return m_contentsSize;
 197 }
 198
 199 void ScrollView::setContentsSize(const IntSize& newSize)
 200 {
 201     if (contentsSize() == newSize)
 202         return;
 203     m_contentsSize = newSize;
 204     updateScrollbars(scrollOffset());
 205     updateOverhangAreas();
 206 }
 207
 208 IntPoint ScrollView::maximumScrollPosition() const
 209 {
 210     IntPoint maximumOffset(contentsWidth() - visibleWidth() - scrollOrigin().x(), contentsHeight() - visibleHeight() - scrollOrigin().y());
 211     maximumOffset.clampNegativeToZero();
 212     return maximumOffset;
 213 }
 214
 215 IntPoint ScrollView::minimumScrollPosition() const
 216 {
 217     return IntPoint(-scrollOrigin().x(), -scrollOrigin().y());
 218 }
 219
 220 IntPoint ScrollView::adjustScrollPositionWithinRange(const IntPoint& scrollPoint) const
 221 {
 222     if (!constrainsScrollingToContentEdge())
 223         return scrollPoint;
 224
 225     IntPoint newScrollPosition = scrollPoint.shrunkTo(maximumScrollPosition());
 226     newScrollPosition = newScrollPosition.expandedTo(minimumScrollPosition());
 227     return newScrollPosition;
 228 }
 229
 230 void ScrollView::adjustScrollbarOpacity()
 231 {
 232     if (m_horizontalScrollbar && layerForHorizontalScrollbar()) {
 233         bool isOpaqueScrollbar = !m_horizontalScrollbar->isOverlayScrollbar();
 234         layerForHorizontalScrollbar()->setContentsOpaque(isOpaqueScrollbar);
 235     }
 236     if (m_verticalScrollbar && layerForVerticalScrollbar()) {
 237         bool isOpaqueScrollbar = !m_verticalScrollbar->isOverlayScrollbar();
 238         layerForVerticalScrollbar()->setContentsOpaque(isOpaqueScrollbar);
 239     }
 240 }
 241
 242 int ScrollView::scrollSize(ScrollbarOrientation orientation) const
 243 {
 244     Scrollbar* scrollbar = ((orientation == HorizontalScrollbar) ? m_horizontalScrollbar : m_verticalScrollbar).get();
 245
 246     // If no scrollbars are present, the content may still be scrollable.
 247     if (!scrollbar) {
 248         IntSize scrollSize = m_contentsSize - visibleContentRect().size();
 249         scrollSize.clampNegativeToZero();
 250         return orientation == HorizontalScrollbar ? scrollSize.width() : scrollSize.height();
 251     }
 252
 253     return scrollbar->totalSize() - scrollbar->visibleSize();
 254 }
 255
 256 void ScrollView::notifyPageThatContentAreaWillPaint() const
 257 {
 258 }
 259
 260 void ScrollView::setScrollOffset(const IntPoint& offset)
 261 {
 262     scrollTo(toIntSize(adjustScrollPositionWithinRange(offset)));
 263 }
 264
 265 void ScrollView::scrollTo(const IntSize& newOffset)
 266 {
 267     IntSize scrollDelta = newOffset - m_scrollOffset;
 268     if (scrollDelta == IntSize())
 269         return;
 270     m_scrollOffset = newOffset;
 271
 272     if (scrollbarsSuppressed())
 273         return;
 274
 275     if (isFrameView())
 276         m_pendingScrollDelta += scrollDelta;
 277     else
 278         scrollContents(scrollDelta);
 279 }
 280
 281 void ScrollView::setScrollPosition(const IntPoint& scrollPoint, ScrollBehavior scrollBehavior)
 282 {
 283     IntPoint newScrollPosition = adjustScrollPositionWithinRange(scrollPoint);
 284
 285     if (newScrollPosition == scrollPosition())
 286         return;
 287
 288     if (scrollBehavior == ScrollBehaviorInstant)
 289         updateScrollbars(IntSize(newScrollPosition.x(), newScrollPosition.y()));
 290     else
 291         programmaticallyScrollSmoothlyToOffset(newScrollPosition);
 292 }
 293
 294 bool ScrollView::scroll(ScrollDirection direction, ScrollGranularity granularity)
 295 {
 296     ScrollDirection physicalDirection =
 297         toPhysicalDirection(direction, isVerticalDocument(), isFlippedDocument());
 298
 299     return ScrollableArea::scroll(physicalDirection, granularity);
 300 }
 301
 302 IntSize ScrollView::overhangAmount() const
 303 {
 304     IntSize stretch;
 305
 306     IntPoint currentScrollPosition = scrollPosition();
 307     IntPoint minScrollPosition = minimumScrollPosition();
 308     IntPoint maxScrollPosition = maximumScrollPosition();
 309
 310     if (currentScrollPosition.x() < minScrollPosition.x())
 311         stretch.setWidth(currentScrollPosition.x() - minScrollPosition.x());
 312     if (currentScrollPosition.x() > maxScrollPosition.x())
 313         stretch.setWidth(currentScrollPosition.x() - maxScrollPosition.x());
 314
 315     if (currentScrollPosition.y() < minScrollPosition.y())
 316         stretch.setHeight(currentScrollPosition.y() - minScrollPosition.y());
 317     if (currentScrollPosition.y() > maxScrollPosition.y())
 318         stretch.setHeight(currentScrollPosition.y() - maxScrollPosition.y());
 319
 320     return stretch;
 321 }
 322
 323 void ScrollView::windowResizerRectChanged()
 324 {
 325     updateScrollbars(scrollOffset());
 326 }
 327
 328 static bool useOverlayScrollbars()
 329 {
 330     // FIXME: Need to detect the presence of CSS custom scrollbars, which are non-overlay regardless the ScrollbarTheme.
 331     return ScrollbarTheme::theme()->usesOverlayScrollbars();
 332 }
 333
 334 void ScrollView::computeScrollbarExistence(bool& newHasHorizontalScrollbar, bool& newHasVerticalScrollbar, const IntSize& docSize, ComputeScrollbarExistenceOption option) const
 335 {
 336     bool hasHorizontalScrollbar = m_horizontalScrollbar;
 337     bool hasVerticalScrollbar = m_verticalScrollbar;
 338
 339     newHasHorizontalScrollbar = hasHorizontalScrollbar;
 340     newHasVerticalScrollbar = hasVerticalScrollbar;
 341
 342     ScrollbarMode hScroll = m_horizontalScrollbarMode;
 343     ScrollbarMode vScroll = m_verticalScrollbarMode;
 344
 345     if (hScroll != ScrollbarAuto)
 346         newHasHorizontalScrollbar = (hScroll == ScrollbarAlwaysOn);
 347     if (vScroll != ScrollbarAuto)
 348         newHasVerticalScrollbar = (vScroll == ScrollbarAlwaysOn);
 349
 350     if (m_scrollbarsSuppressed || (hScroll != ScrollbarAuto && vScroll != ScrollbarAuto))
 351         return;
 352
 353     if (hScroll == ScrollbarAuto)
 354         newHasHorizontalScrollbar = docSize.width() > visibleWidth();
 355     if (vScroll == ScrollbarAuto)
 356         newHasVerticalScrollbar = docSize.height() > visibleHeight();
 357
 358     if (useOverlayScrollbars())
 359         return;
 360
 361     IntSize fullVisibleSize = visibleContentRect(IncludeScrollbars).size();
 362
 363     bool attemptToRemoveScrollbars = (option == FirstPass
 364         && docSize.width() <= fullVisibleSize.width() && docSize.height() <= fullVisibleSize.height());
 365     if (attemptToRemoveScrollbars) {
 366         if (hScroll == ScrollbarAuto)
 367             newHasHorizontalScrollbar = false;
 368         if (vScroll == ScrollbarAuto)
 369             newHasVerticalScrollbar = false;
 370     }
 371
 372     // If we ever turn one scrollbar off, always turn the other one off too.
 373     // Never ever try to both gain/lose a scrollbar in the same pass.
 374     if (!newHasHorizontalScrollbar && hasHorizontalScrollbar && vScroll != ScrollbarAlwaysOn)
 375         newHasVerticalScrollbar = false;
 376     if (!newHasVerticalScrollbar && hasVerticalScrollbar && hScroll != ScrollbarAlwaysOn)
 377         newHasHorizontalScrollbar = false;
 378 }
 379
 380 void ScrollView::updateScrollbarGeometry()
 381 {
 382     if (m_horizontalScrollbar) {
 383         int clientWidth = visibleWidth();
 384         IntRect oldRect(m_horizontalScrollbar->frameRect());
 385         IntRect hBarRect((shouldPlaceVerticalScrollbarOnLeft() && m_verticalScrollbar) ? m_verticalScrollbar->width() : 0,
 386                         height() - m_horizontalScrollbar->height(),
 387                         width() - (m_verticalScrollbar ? m_verticalScrollbar->width() : 0),
 388                         m_horizontalScrollbar->height());
 389         m_horizontalScrollbar->setFrameRect(hBarRect);
 390         if (!m_scrollbarsSuppressed && oldRect != m_horizontalScrollbar->frameRect())
 391             m_horizontalScrollbar->invalidate();
 392
 393         if (m_scrollbarsSuppressed)
 394             m_horizontalScrollbar->setSuppressInvalidation(true);
 395         m_horizontalScrollbar->setEnabled(contentsWidth() > clientWidth);
 396         m_horizontalScrollbar->setProportion(clientWidth, contentsWidth());
 397         m_horizontalScrollbar->offsetDidChange();
 398         if (m_scrollbarsSuppressed)
 399             m_horizontalScrollbar->setSuppressInvalidation(false);
 400     }
 401
 402     if (m_verticalScrollbar) {
 403         int clientHeight = visibleHeight();
 404         IntRect oldRect(m_verticalScrollbar->frameRect());
 405         IntRect vBarRect(shouldPlaceVerticalScrollbarOnLeft() ? 0 : (width() - m_verticalScrollbar->width()),
 406                          0,
 407                          m_verticalScrollbar->width(),
 408                          height() - (m_horizontalScrollbar ? m_horizontalScrollbar->height() : 0));
 409         m_verticalScrollbar->setFrameRect(vBarRect);
 410         if (!m_scrollbarsSuppressed && oldRect != m_verticalScrollbar->frameRect())
 411             m_verticalScrollbar->invalidate();
 412
 413         if (m_scrollbarsSuppressed)
 414             m_verticalScrollbar->setSuppressInvalidation(true);
 415         m_verticalScrollbar->setEnabled(contentsHeight() > clientHeight);
 416         m_verticalScrollbar->setProportion(clientHeight, contentsHeight());
 417         m_verticalScrollbar->offsetDidChange();
 418         if (m_scrollbarsSuppressed)
 419             m_verticalScrollbar->setSuppressInvalidation(false);
 420     }
 421 }
 422
 423 bool ScrollView::adjustScrollbarExistence(ComputeScrollbarExistenceOption option)
 424 {
 425     ASSERT(m_inUpdateScrollbars);
 426
 427     // If we came in here with the view already needing a layout, then go ahead and do that
 428     // first.  (This will be the common case, e.g., when the page changes due to window resizing for example).
 429     // This layout will not re-enter updateScrollbars and does not count towards our max layout pass total.
 430     if (!m_scrollbarsSuppressed)
 431         scrollbarExistenceDidChange();
 432
 433     bool hasHorizontalScrollbar = m_horizontalScrollbar;
 434     bool hasVerticalScrollbar = m_verticalScrollbar;
 435
 436     bool newHasHorizontalScrollbar = false;
 437     bool newHasVerticalScrollbar = false;
 438     computeScrollbarExistence(newHasHorizontalScrollbar, newHasVerticalScrollbar, contentsSize(), option);
 439
 440     bool scrollbarExistenceChanged = hasHorizontalScrollbar != newHasHorizontalScrollbar || hasVerticalScrollbar != newHasVerticalScrollbar;
 441     if (!scrollbarExistenceChanged)
 442         return false;
 443
 444     setHasHorizontalScrollbar(newHasHorizontalScrollbar);
 445     setHasVerticalScrollbar(newHasVerticalScrollbar);
 446
 447     if (m_scrollbarsSuppressed)
 448         return true;
 449
 450     if (!useOverlayScrollbars())
 451         contentsResized();
 452     scrollbarExistenceDidChange();
 453     return true;
 454 }
 455
 456 void ScrollView::updateScrollbars(const IntSize& desiredOffset)
 457 {
 458     if (scrollbarsDisabled()) {
 459         setScrollOffsetFromUpdateScrollbars(desiredOffset);
 460         return;
 461     }
 462
 463     if (m_inUpdateScrollbars)
 464         return;
 465     InUpdateScrollbarsScope inUpdateScrollbarsScope(this);
 466
 467     IntSize oldVisibleSize = visibleSize();
 468
 469     bool scrollbarExistenceChanged = false;
 470     int maxUpdateScrollbarsPass = useOverlayScrollbars() || m_scrollbarsSuppressed ? 1 : 3;
 471     for (int updateScrollbarsPass = 0; updateScrollbarsPass < maxUpdateScrollbarsPass; updateScrollbarsPass++) {
 472         if (!adjustScrollbarExistence(updateScrollbarsPass ? Incremental : FirstPass))
 473             break;
 474         scrollbarExistenceChanged = true;
 475     }
 476
 477     updateScrollbarGeometry();
 478
 479     if (scrollbarExistenceChanged) {
 480         // FIXME: Is frameRectsChanged really necessary here? Have any frame rects changed?
 481         frameRectsChanged();
 482         positionScrollbarLayers();
 483         updateScrollCorner();
 484     }
 485
 486     // FIXME: We don't need to do this if we are composited.
 487     IntSize newVisibleSize = visibleSize();
 488     if (newVisibleSize.width() > oldVisibleSize.width()) {
 489         if (shouldPlaceVerticalScrollbarOnLeft())
 490             invalidateRect(IntRect(0, 0, newVisibleSize.width() - oldVisibleSize.width(), newVisibleSize.height()));
 491         else
 492             invalidateRect(IntRect(oldVisibleSize.width(), 0, newVisibleSize.width() - oldVisibleSize.width(), newVisibleSize.height()));
 493     }
 494     if (newVisibleSize.height() > oldVisibleSize.height())
 495         invalidateRect(IntRect(0, oldVisibleSize.height(), newVisibleSize.width(), newVisibleSize.height() - oldVisibleSize.height()));
 496
 497     setScrollOffsetFromUpdateScrollbars(desiredOffset);
 498 }
 499
 500 void ScrollView::setScrollOffsetFromUpdateScrollbars(const IntSize& offset)
 501 {
 502     IntPoint adjustedScrollPosition = IntPoint(offset);
 503
 504     if (!isRubberBandInProgress())
 505         adjustedScrollPosition = adjustScrollPositionWithinRange(adjustedScrollPosition);
 506
 507     if (adjustedScrollPosition != scrollPosition() || scrollOriginChanged()) {
 508         ScrollableArea::scrollToOffsetWithoutAnimation(adjustedScrollPosition);
 509         resetScrollOriginChanged();
 510     }
 511 }
 512
 513 const int panIconSizeLength = 16;
 514
 515 IntRect ScrollView::rectToCopyOnScroll() const
 516 {
 517     IntRect scrollViewRect = convertToContainingWindow(IntRect((shouldPlaceVerticalScrollbarOnLeft() && verticalScrollbar()) ? verticalScrollbar()->width() : 0, 0, visibleWidth(), visibleHeight()));
 518     if (hasOverlayScrollbars()) {
 519         int verticalScrollbarWidth = (verticalScrollbar() && !hasLayerForVerticalScrollbar()) ? verticalScrollbar()->width() : 0;
 520         int horizontalScrollbarHeight = (horizontalScrollbar() && !hasLayerForHorizontalScrollbar()) ? horizontalScrollbar()->height() : 0;
 521
 522         scrollViewRect.setWidth(scrollViewRect.width() - verticalScrollbarWidth);
 523         scrollViewRect.setHeight(scrollViewRect.height() - horizontalScrollbarHeight);
 524     }
 525     return scrollViewRect;
 526 }
 527
 528 void ScrollView::scrollContentsIfNeeded()
 529 {
 530     if (m_pendingScrollDelta.isZero())
 531         return;
 532     IntSize scrollDelta = m_pendingScrollDelta;
 533     m_pendingScrollDelta = IntSize();
 534     scrollContents(scrollDelta);
 535 }
 536
 537 void ScrollView::scrollContents(const IntSize& scrollDelta)
 538 {
 539     HostWindow* window = hostWindow();
 540     if (!window)
 541         return;
 542
 543     IntRect clipRect = windowClipRect();
 544     IntRect updateRect = clipRect;
 545     updateRect.intersect(rectToCopyOnScroll());
 546
 547     if (m_drawPanScrollIcon) {
 548         // FIXME: the pan icon is broken when accelerated compositing is on, since it will draw under the compositing layers.
 549         // https://bugs.webkit.org/show_bug.cgi?id=47837
 550         int panIconDirtySquareSizeLength = 2 * (panIconSizeLength + std::max(abs(scrollDelta.width()), abs(scrollDelta.height()))); // We only want to repaint what's necessary
 551         IntPoint panIconDirtySquareLocation = IntPoint(m_panScrollIconPoint.x() - (panIconDirtySquareSizeLength / 2), m_panScrollIconPoint.y() - (panIconDirtySquareSizeLength / 2));
 552         IntRect panScrollIconDirtyRect = IntRect(panIconDirtySquareLocation, IntSize(panIconDirtySquareSizeLength, panIconDirtySquareSizeLength));
 553         panScrollIconDirtyRect.intersect(clipRect);
 554         window->invalidateContentsAndRootView(panScrollIconDirtyRect);
 555     }
 556
 557     if (!scrollContentsFastPath(-scrollDelta))
 558         scrollContentsSlowPath(updateRect);
 559
 560     // Invalidate the overhang areas if they are visible.
 561     updateOverhangAreas();
 562
 563     // This call will move children with native widgets (plugins) and invalidate them as well.
 564     frameRectsChanged();
 565 }
 566
 567 void ScrollView::scrollContentsSlowPath(const IntRect& updateRect)
 568 {
 569     hostWindow()->invalidateContentsForSlowScroll(updateRect);
 570 }
 571
 572 IntPoint ScrollView::rootViewToContents(const IntPoint& rootViewPoint) const
 573 {
 574     IntPoint viewPoint = convertFromContainingWindow(rootViewPoint);
 575     return viewPoint + scrollOffset();
 576 }
 577
 578 IntPoint ScrollView::contentsToRootView(const IntPoint& contentsPoint) const
 579 {
 580     IntPoint viewPoint = contentsPoint - scrollOffset();
 581     return convertToContainingWindow(viewPoint);
 582 }
 583
 584 IntRect ScrollView::rootViewToContents(const IntRect& rootViewRect) const
 585 {
 586     IntRect viewRect = convertFromContainingWindow(rootViewRect);
 587     viewRect.move(scrollOffset());
 588     return viewRect;
 589 }
 590
 591 IntRect ScrollView::contentsToRootView(const IntRect& contentsRect) const
 592 {
 593     IntRect viewRect = contentsRect;
 594     viewRect.move(-scrollOffset());
 595     return convertToContainingWindow(viewRect);
 596 }
 597
 598 IntPoint ScrollView::windowToContents(const IntPoint& windowPoint) const
 599 {
 600     IntPoint viewPoint = convertFromContainingWindow(windowPoint);
 601     return viewPoint + scrollOffset();
 602 }
 603
 604 FloatPoint ScrollView::windowToContents(const FloatPoint& windowPoint) const
 605 {
 606     FloatPoint viewPoint = convertFromContainingWindow(windowPoint);
 607     return viewPoint + scrollOffset();
 608 }
 609
 610 IntPoint ScrollView::contentsToWindow(const IntPoint& contentsPoint) const
 611 {
 612     IntPoint viewPoint = contentsPoint - scrollOffset();
 613     return convertToContainingWindow(viewPoint);
 614 }
 615
 616 IntRect ScrollView::windowToContents(const IntRect& windowRect) const
 617 {
 618     IntRect viewRect = convertFromContainingWindow(windowRect);
 619     viewRect.move(scrollOffset());
 620     return viewRect;
 621 }
 622
 623 IntRect ScrollView::contentsToWindow(const IntRect& contentsRect) const
 624 {
 625     IntRect viewRect = contentsRect;
 626     viewRect.move(-scrollOffset());
 627     return convertToContainingWindow(viewRect);
 628 }
 629
 630 IntRect ScrollView::contentsToScreen(const IntRect& rect) const
 631 {
 632     HostWindow* window = hostWindow();
 633     if (!window)
 634         return IntRect();
 635     return window->rootViewToScreen(contentsToRootView(rect));
 636 }
 637
 638 bool ScrollView::containsScrollbarsAvoidingResizer() const
 639 {
 640     return !m_scrollbarsAvoidingResizer;
 641 }
 642
 643 void ScrollView::adjustScrollbarsAvoidingResizerCount(int overlapDelta)
 644 {
 645     int oldCount = m_scrollbarsAvoidingResizer;
 646     m_scrollbarsAvoidingResizer += overlapDelta;
 647     if (parent())
 648         toScrollView(parent())->adjustScrollbarsAvoidingResizerCount(overlapDelta);
 649     else if (!scrollbarsSuppressed()) {
 650         // If we went from n to 0 or from 0 to n and we're the outermost view,
 651         // we need to invalidate the windowResizerRect(), since it will now need to paint
 652         // differently.
 653         if ((oldCount > 0 && m_scrollbarsAvoidingResizer == 0) ||
 654             (oldCount == 0 && m_scrollbarsAvoidingResizer > 0))
 655             invalidateRect(windowResizerRect());
 656     }
 657 }
 658
 659 void ScrollView::setParent(Widget* parentView)
 660 {
 661     if (parentView == parent())
 662         return;
 663
 664     if (m_scrollbarsAvoidingResizer && parent())
 665         toScrollView(parent())->adjustScrollbarsAvoidingResizerCount(-m_scrollbarsAvoidingResizer);
 666
 667     Widget::setParent(parentView);
 668
 669     if (m_scrollbarsAvoidingResizer && parent())
 670         toScrollView(parent())->adjustScrollbarsAvoidingResizerCount(m_scrollbarsAvoidingResizer);
 671 }
 672
 673 void ScrollView::setScrollbarsSuppressed(bool suppressed, bool repaintOnUnsuppress)
 674 {
 675     if (suppressed == m_scrollbarsSuppressed)
 676         return;
 677
 678     m_scrollbarsSuppressed = suppressed;
 679
 680     if (repaintOnUnsuppress && !suppressed) {
 681         if (m_horizontalScrollbar)
 682             m_horizontalScrollbar->invalidate();
 683         if (m_verticalScrollbar)
 684             m_verticalScrollbar->invalidate();
 685
 686         // Invalidate the scroll corner too on unsuppress.
 687         invalidateRect(scrollCornerRect());
 688     }
 689 }
 690
 691 Scrollbar* ScrollView::scrollbarAtWindowPoint(const IntPoint& windowPoint)
 692 {
 693     IntPoint viewPoint = convertFromContainingWindow(windowPoint);
 694     return scrollbarAtViewPoint(viewPoint);
 695 }
 696
 697 Scrollbar* ScrollView::scrollbarAtViewPoint(const IntPoint& viewPoint)
 698 {
 699     if (m_horizontalScrollbar && m_horizontalScrollbar->shouldParticipateInHitTesting() && m_horizontalScrollbar->frameRect().contains(viewPoint))
 700         return m_horizontalScrollbar.get();
 701     if (m_verticalScrollbar && m_verticalScrollbar->shouldParticipateInHitTesting() && m_verticalScrollbar->frameRect().contains(viewPoint))
 702         return m_verticalScrollbar.get();
 703     return 0;
 704 }
 705
 706 void ScrollView::setFrameRect(const IntRect& newRect)
 707 {
 708     IntRect oldRect = frameRect();
 709
 710     if (newRect == oldRect)
 711         return;
 712
 713     Widget::setFrameRect(newRect);
 714
 715     updateScrollbars(scrollOffset());
 716
 717     frameRectsChanged();
 718 }
 719
 720 void ScrollView::frameRectsChanged()
 721 {
 722     HashSet<RefPtr<Widget> >::const_iterator end = m_children.end();
 723     for (HashSet<RefPtr<Widget> >::const_iterator current = m_children.begin(); current != end; ++current)
 724         (*current)->frameRectsChanged();
 725 }
 726
 727 static void positionScrollbarLayer(GraphicsLayer* graphicsLayer, Scrollbar* scrollbar)
 728 {
 729     if (!graphicsLayer || !scrollbar)
 730         return;
 731
 732     IntRect scrollbarRect = scrollbar->frameRect();
 733     graphicsLayer->setPosition(scrollbarRect.location());
 734
 735     if (scrollbarRect.size() == graphicsLayer->size())
 736         return;
 737
 738     graphicsLayer->setSize(scrollbarRect.size());
 739
 740     if (graphicsLayer->hasContentsLayer()) {
 741         graphicsLayer->setContentsRect(IntRect(0, 0, scrollbarRect.width(), scrollbarRect.height()));
 742         return;
 743     }
 744
 745     graphicsLayer->setDrawsContent(true);
 746     graphicsLayer->setNeedsDisplay();
 747 }
 748
 749 static void positionScrollCornerLayer(GraphicsLayer* graphicsLayer, const IntRect& cornerRect)
 750 {
 751     if (!graphicsLayer)
 752         return;
 753     graphicsLayer->setDrawsContent(!cornerRect.isEmpty());
 754     graphicsLayer->setPosition(cornerRect.location());
 755     if (cornerRect.size() != graphicsLayer->size())
 756         graphicsLayer->setNeedsDisplay();
 757     graphicsLayer->setSize(cornerRect.size());
 758 }
 759
 760 void ScrollView::positionScrollbarLayers()
 761 {
 762     positionScrollbarLayer(layerForHorizontalScrollbar(), horizontalScrollbar());
 763     positionScrollbarLayer(layerForVerticalScrollbar(), verticalScrollbar());
 764     positionScrollCornerLayer(layerForScrollCorner(), scrollCornerRect());
 765 }
 766
 767 bool ScrollView::userInputScrollable(ScrollbarOrientation orientation) const
 768 {
 769     ScrollbarMode mode = (orientation == HorizontalScrollbar) ?
 770         m_horizontalScrollbarMode : m_verticalScrollbarMode;
 771
 772     return mode == ScrollbarAuto || mode == ScrollbarAlwaysOn;
 773 }
 774
 775 bool ScrollView::shouldPlaceVerticalScrollbarOnLeft() const
 776 {
 777     return false;
 778 }
 779
 780 void ScrollView::contentRectangleForPaintInvalidation(const IntRect& rect)
 781 {
 782     IntRect paintRect = rect;
 783     if (clipsPaintInvalidations())
 784         paintRect.intersect(visibleContentRect());
 785     if (paintRect.isEmpty())
 786         return;
 787
 788     if (HostWindow* window = hostWindow())
 789         window->invalidateContentsAndRootView(contentsToWindow(paintRect));
 790 }
 791
 792 IntRect ScrollView::scrollCornerRect() const
 793 {
 794     IntRect cornerRect;
 795
 796     if (hasOverlayScrollbars())
 797         return cornerRect;
 798
 799     if (m_horizontalScrollbar && width() - m_horizontalScrollbar->width() > 0) {
 800         cornerRect.unite(IntRect(shouldPlaceVerticalScrollbarOnLeft() ? 0 : m_horizontalScrollbar->width(),
 801                                  height() - m_horizontalScrollbar->height(),
 802                                  width() - m_horizontalScrollbar->width(),
 803                                  m_horizontalScrollbar->height()));
 804     }
 805
 806     if (m_verticalScrollbar && height() - m_verticalScrollbar->height() > 0) {
 807         cornerRect.unite(IntRect(shouldPlaceVerticalScrollbarOnLeft() ? 0 : (width() - m_verticalScrollbar->width()),
 808                                  m_verticalScrollbar->height(),
 809                                  m_verticalScrollbar->width(),
 810                                  height() - m_verticalScrollbar->height()));
 811     }
 812
 813     return cornerRect;
 814 }
 815
 816 bool ScrollView::isScrollCornerVisible() const
 817 {
 818     return !scrollCornerRect().isEmpty();
 819 }
 820
 821 void ScrollView::scrollbarStyleChanged()
 822 {
 823     adjustScrollbarOpacity();
 824     contentsResized();
 825     updateScrollbars(scrollOffset());
 826     positionScrollbarLayers();
 827 }
 828
 829 void ScrollView::updateScrollCorner()
 830 {
 831 }
 832
 833 void ScrollView::paintScrollCorner(GraphicsContext* context, const IntRect& cornerRect)
 834 {
 835     ScrollbarTheme::theme()->paintScrollCorner(context, cornerRect);
 836 }
 837
 838 void ScrollView::paintScrollbar(GraphicsContext* context, Scrollbar* bar, const IntRect& rect)
 839 {
 840     bar->paint(context, rect);
 841 }
 842
 843 void ScrollView::invalidateScrollCornerRect(const IntRect& rect)
 844 {
 845     invalidateRect(rect);
 846 }
 847
 848 void ScrollView::paintScrollbars(GraphicsContext* context, const IntRect& rect)
 849 {
 850     if (m_horizontalScrollbar && !layerForHorizontalScrollbar())
 851         paintScrollbar(context, m_horizontalScrollbar.get(), rect);
 852     if (m_verticalScrollbar && !layerForVerticalScrollbar())
 853         paintScrollbar(context, m_verticalScrollbar.get(), rect);
 854
 855     if (layerForScrollCorner())
 856         return;
 857     paintScrollCorner(context, scrollCornerRect());
 858 }
 859
 860 void ScrollView::paintPanScrollIcon(GraphicsContext* context)
 861 {
 862     DEFINE_STATIC_REF(Image, panScrollIcon, (Image::loadPlatformResource("panIcon")));
 863     IntPoint iconGCPoint = m_panScrollIconPoint;
 864     if (parent())
 865         iconGCPoint = toScrollView(parent())->windowToContents(iconGCPoint);
 866     context->drawImage(panScrollIcon, iconGCPoint);
 867 }
 868
 869 void ScrollView::paint(GraphicsContext* context, const IntRect& rect)
 870 {
 871     notifyPageThatContentAreaWillPaint();
 872
 873     IntRect documentDirtyRect = rect;
 874     IntRect visibleAreaWithoutScrollbars(location(), visibleContentRect().size());
 875     documentDirtyRect.intersect(visibleAreaWithoutScrollbars);
 876
 877     if (!documentDirtyRect.isEmpty()) {
 878         GraphicsContextStateSaver stateSaver(*context);
 879
 880         context->translate(x() - scrollX(), y() - scrollY());
 881         context->clip(visibleContentRect());
 882
 883         documentDirtyRect.moveBy(-location() + scrollPosition());
 884         paintContents(context, documentDirtyRect);
 885     }
 886
 887     calculateAndPaintOverhangAreas(context, rect);
 888
 889     // Now paint the scrollbars.
 890     if (!m_scrollbarsSuppressed && (m_horizontalScrollbar || m_verticalScrollbar)) {
 891         GraphicsContextStateSaver stateSaver(*context);
 892         IntRect scrollViewDirtyRect = rect;
 893         IntRect visibleAreaWithScrollbars(location(), visibleContentRect(IncludeScrollbars).size());
 894         scrollViewDirtyRect.intersect(visibleAreaWithScrollbars);
 895         context->translate(x(), y());
 896         scrollViewDirtyRect.moveBy(-location());
 897         context->clip(IntRect(IntPoint(), visibleAreaWithScrollbars.size()));
 898
 899         paintScrollbars(context, scrollViewDirtyRect);
 900     }
 901
 902     // Paint the panScroll Icon
 903     if (m_drawPanScrollIcon)
 904         paintPanScrollIcon(context);
 905 }
 906
 907 void ScrollView::calculateOverhangAreasForPainting(IntRect& horizontalOverhangRect, IntRect& verticalOverhangRect)
 908 {
 909     int verticalScrollbarWidth = (verticalScrollbar() && !verticalScrollbar()->isOverlayScrollbar())
 910         ? verticalScrollbar()->width() : 0;
 911     int horizontalScrollbarHeight = (horizontalScrollbar() && !horizontalScrollbar()->isOverlayScrollbar())
 912         ? horizontalScrollbar()->height() : 0;
 913
 914     int physicalScrollY = scrollPosition().y() + scrollOrigin().y();
 915     if (physicalScrollY < 0) {
 916         horizontalOverhangRect = frameRect();
 917         horizontalOverhangRect.setHeight(-physicalScrollY);
 918         horizontalOverhangRect.setWidth(horizontalOverhangRect.width() - verticalScrollbarWidth);
 919     } else if (contentsHeight() && physicalScrollY > contentsHeight() - visibleHeight()) {
 920         int height = physicalScrollY - (contentsHeight() - visibleHeight());
 921         horizontalOverhangRect = frameRect();
 922         horizontalOverhangRect.setY(frameRect().maxY() - height - horizontalScrollbarHeight);
 923         horizontalOverhangRect.setHeight(height);
 924         horizontalOverhangRect.setWidth(horizontalOverhangRect.width() - verticalScrollbarWidth);
 925     }
 926
 927     int physicalScrollX = scrollPosition().x() + scrollOrigin().x();
 928     if (physicalScrollX < 0) {
 929         verticalOverhangRect.setWidth(-physicalScrollX);
 930         verticalOverhangRect.setHeight(frameRect().height() - horizontalOverhangRect.height() - horizontalScrollbarHeight);
 931         verticalOverhangRect.setX(frameRect().x());
 932         if (horizontalOverhangRect.y() == frameRect().y())
 933             verticalOverhangRect.setY(frameRect().y() + horizontalOverhangRect.height());
 934         else
 935             verticalOverhangRect.setY(frameRect().y());
 936     } else if (contentsWidth() && physicalScrollX > contentsWidth() - visibleWidth()) {
 937         int width = physicalScrollX - (contentsWidth() - visibleWidth());
 938         verticalOverhangRect.setWidth(width);
 939         verticalOverhangRect.setHeight(frameRect().height() - horizontalOverhangRect.height() - horizontalScrollbarHeight);
 940         verticalOverhangRect.setX(frameRect().maxX() - width - verticalScrollbarWidth);
 941         if (horizontalOverhangRect.y() == frameRect().y())
 942             verticalOverhangRect.setY(frameRect().y() + horizontalOverhangRect.height());
 943         else
 944             verticalOverhangRect.setY(frameRect().y());
 945     }
 946 }
 947
 948 void ScrollView::updateOverhangAreas()
 949 {
 950     HostWindow* window = hostWindow();
 951     if (!window)
 952         return;
 953
 954     IntRect horizontalOverhangRect;
 955     IntRect verticalOverhangRect;
 956     calculateOverhangAreasForPainting(horizontalOverhangRect, verticalOverhangRect);
 957     if (!horizontalOverhangRect.isEmpty())
 958         window->invalidateContentsAndRootView(horizontalOverhangRect);
 959     if (!verticalOverhangRect.isEmpty())
 960         window->invalidateContentsAndRootView(verticalOverhangRect);
 961 }
 962
 963 void ScrollView::paintOverhangAreas(GraphicsContext* context, const IntRect& horizontalOverhangRect, const IntRect& verticalOverhangRect, const IntRect& dirtyRect)
 964 {
 965     ScrollbarTheme::theme()->paintOverhangBackground(context, horizontalOverhangRect, verticalOverhangRect, dirtyRect);
 966     ScrollbarTheme::theme()->paintOverhangShadows(context, scrollOffset(), horizontalOverhangRect, verticalOverhangRect, dirtyRect);
 967 }
 968
 969 void ScrollView::calculateAndPaintOverhangAreas(GraphicsContext* context, const IntRect& dirtyRect)
 970 {
 971     IntRect horizontalOverhangRect;
 972     IntRect verticalOverhangRect;
 973     calculateOverhangAreasForPainting(horizontalOverhangRect, verticalOverhangRect);
 974
 975     if (dirtyRect.intersects(horizontalOverhangRect) || dirtyRect.intersects(verticalOverhangRect))
 976         paintOverhangAreas(context, horizontalOverhangRect, verticalOverhangRect, dirtyRect);
 977 }
 978
 979 void ScrollView::calculateAndPaintOverhangBackground(GraphicsContext* context, const IntRect& dirtyRect)
 980 {
 981     IntRect horizontalOverhangRect;
 982     IntRect verticalOverhangRect;
 983     calculateOverhangAreasForPainting(horizontalOverhangRect, verticalOverhangRect);
 984
 985     if (dirtyRect.intersects(horizontalOverhangRect) || dirtyRect.intersects(verticalOverhangRect))
 986         ScrollbarTheme::theme()->paintOverhangBackground(context, horizontalOverhangRect, verticalOverhangRect, dirtyRect);
 987 }
 988
 989 bool ScrollView::isPointInScrollbarCorner(const IntPoint& windowPoint)
 990 {
 991     if (!scrollbarCornerPresent())
 992         return false;
 993
 994     IntPoint viewPoint = convertFromContainingWindow(windowPoint);
 995
 996     if (m_horizontalScrollbar) {
 997         int horizontalScrollbarYMin = m_horizontalScrollbar->frameRect().y();
 998         int horizontalScrollbarYMax = m_horizontalScrollbar->frameRect().y() + m_horizontalScrollbar->frameRect().height();
 999         int horizontalScrollbarXMin = m_horizontalScrollbar->frameRect().x() + m_horizontalScrollbar->frameRect().width();
1000
1001         return viewPoint.y() > horizontalScrollbarYMin && viewPoint.y() < horizontalScrollbarYMax && viewPoint.x() > horizontalScrollbarXMin;
1002     }
1003
1004     int verticalScrollbarXMin = m_verticalScrollbar->frameRect().x();
1005     int verticalScrollbarXMax = m_verticalScrollbar->frameRect().x() + m_verticalScrollbar->frameRect().width();
1006     int verticalScrollbarYMin = m_verticalScrollbar->frameRect().y() + m_verticalScrollbar->frameRect().height();
1007
1008     return viewPoint.x() > verticalScrollbarXMin && viewPoint.x() < verticalScrollbarXMax && viewPoint.y() > verticalScrollbarYMin;
1009 }
1010
1011 bool ScrollView::scrollbarCornerPresent() const
1012 {
1013     return (m_horizontalScrollbar && width() - m_horizontalScrollbar->width() > 0)
1014         || (m_verticalScrollbar && height() - m_verticalScrollbar->height() > 0);
1015 }
1016
1017 IntRect ScrollView::convertFromScrollbarToContainingView(const Scrollbar* scrollbar, const IntRect& localRect) const
1018 {
1019     // Scrollbars won't be transformed within us
1020     IntRect newRect = localRect;
1021     newRect.moveBy(scrollbar->location());
1022     return newRect;
1023 }
1024
1025 IntRect ScrollView::convertFromContainingViewToScrollbar(const Scrollbar* scrollbar, const IntRect& parentRect) const
1026 {
1027     IntRect newRect = parentRect;
1028     // Scrollbars won't be transformed within us
1029     newRect.moveBy(-scrollbar->location());
1030     return newRect;
1031 }
1032
1033 // FIXME: test these on windows
1034 IntPoint ScrollView::convertFromScrollbarToContainingView(const Scrollbar* scrollbar, const IntPoint& localPoint) const
1035 {
1036     // Scrollbars won't be transformed within us
1037     IntPoint newPoint = localPoint;
1038     newPoint.moveBy(scrollbar->location());
1039     return newPoint;
1040 }
1041
1042 IntPoint ScrollView::convertFromContainingViewToScrollbar(const Scrollbar* scrollbar, const IntPoint& parentPoint) const
1043 {
1044     IntPoint newPoint = parentPoint;
1045     // Scrollbars won't be transformed within us
1046     newPoint.moveBy(-scrollbar->location());
1047     return newPoint;
1048 }
1049
1050 void ScrollView::setParentVisible(bool visible)
1051 {
1052     if (isParentVisible() == visible)
1053         return;
1054
1055     Widget::setParentVisible(visible);
1056
1057     if (!isSelfVisible())
1058         return;
1059
1060     HashSet<RefPtr<Widget> >::iterator end = m_children.end();
1061     for (HashSet<RefPtr<Widget> >::iterator it = m_children.begin(); it != end; ++it)
1062         (*it)->setParentVisible(visible);
1063 }
1064
1065 void ScrollView::show()
1066 {
1067     if (!isSelfVisible()) {
1068         setSelfVisible(true);
1069         if (isParentVisible()) {
1070             HashSet<RefPtr<Widget> >::iterator end = m_children.end();
1071             for (HashSet<RefPtr<Widget> >::iterator it = m_children.begin(); it != end; ++it)
1072                 (*it)->setParentVisible(true);
1073         }
1074     }
1075
1076     Widget::show();
1077 }
1078
1079 void ScrollView::hide()
1080 {
1081     if (isSelfVisible()) {
1082         if (isParentVisible()) {
1083             HashSet<RefPtr<Widget> >::iterator end = m_children.end();
1084             for (HashSet<RefPtr<Widget> >::iterator it = m_children.begin(); it != end; ++it)
1085                 (*it)->setParentVisible(false);
1086         }
1087         setSelfVisible(false);
1088     }
1089
1090     Widget::hide();
1091 }
1092
1093 void ScrollView::addPanScrollIcon(const IntPoint& iconPosition)
1094 {
1095     HostWindow* window = hostWindow();
1096     if (!window)
1097         return;
1098     m_drawPanScrollIcon = true;
1099     m_panScrollIconPoint = IntPoint(iconPosition.x() - panIconSizeLength / 2 , iconPosition.y() - panIconSizeLength / 2) ;
1100     window->invalidateContentsAndRootView(IntRect(m_panScrollIconPoint, IntSize(panIconSizeLength, panIconSizeLength)));
1101 }
1102
1103 void ScrollView::removePanScrollIcon()
1104 {
1105     HostWindow* window = hostWindow();
1106     if (!window)
1107         return;
1108     m_drawPanScrollIcon = false;
1109     window->invalidateContentsAndRootView(IntRect(m_panScrollIconPoint, IntSize(panIconSizeLength, panIconSizeLength)));
1110 }
1111
1112 void ScrollView::setScrollOrigin(const IntPoint& origin, bool updatePositionAtAll, bool updatePositionSynchronously)
1113 {
1114     if (scrollOrigin() == origin)
1115         return;
1116
1117     ScrollableArea::setScrollOrigin(origin);
1118
1119     // Update if the scroll origin changes, since our position will be different if the content size did not change.
1120     if (updatePositionAtAll && updatePositionSynchronously)
1121         updateScrollbars(scrollOffset());
1122 }
1123
1124 } // namespace blink