void ScrollableArea::willEndLiveResize() { if (!m_inLiveResize) return; m_inLiveResize = false; scrollAnimator()->willEndLiveResize(); }
void ScrollableArea::didAddHorizontalScrollbar(Scrollbar* scrollbar) { scrollAnimator()->didAddHorizontalScrollbar(scrollbar); // <rdar://problem/9797253> AppKit resets the scrollbar's style when you attach a scrollbar setScrollbarOverlayStyle(scrollbarOverlayStyle()); }
void ScrollableArea::scrollPositionChanged(const IntPoint& position) { IntPoint oldPosition = scrollPosition(); // Tell the derived class to scroll its contents. setScrollOffset(position); Scrollbar* verticalScrollbar = this->verticalScrollbar(); // Tell the scrollbars to update their thumb postions. if (Scrollbar* horizontalScrollbar = this->horizontalScrollbar()) { horizontalScrollbar->offsetDidChange(); if (horizontalScrollbar->isOverlayScrollbar() && !hasLayerForHorizontalScrollbar()) { if (!verticalScrollbar) horizontalScrollbar->invalidate(); else { // If there is both a horizontalScrollbar and a verticalScrollbar, // then we must also invalidate the corner between them. IntRect boundsAndCorner = horizontalScrollbar->boundsRect(); boundsAndCorner.setWidth(boundsAndCorner.width() + verticalScrollbar->width()); horizontalScrollbar->invalidateRect(boundsAndCorner); } } } if (verticalScrollbar) { verticalScrollbar->offsetDidChange(); if (verticalScrollbar->isOverlayScrollbar() && !hasLayerForVerticalScrollbar()) verticalScrollbar->invalidate(); } if (scrollPosition() != oldPosition) scrollAnimator()->notifyContentAreaScrolled(); }
ScrollResultOneDimensional ScrollableArea::userScroll(ScrollDirectionPhysical direction, ScrollGranularity granularity, float delta) { ScrollbarOrientation orientation; if (direction == ScrollUp || direction == ScrollDown) orientation = VerticalScrollbar; else orientation = HorizontalScrollbar; if (!userInputScrollable(orientation)) return ScrollResultOneDimensional(false, delta); cancelProgrammaticScrollAnimation(); float step = 0; switch (granularity) { case ScrollByLine: step = lineStep(orientation); break; case ScrollByPage: step = pageStep(orientation); break; case ScrollByDocument: step = documentStep(orientation); break; case ScrollByPixel: case ScrollByPrecisePixel: step = pixelStep(orientation); break; } if (direction == ScrollUp || direction == ScrollLeft) delta = -delta; return scrollAnimator()->userScroll(orientation, granularity, step, delta); }
void ScrollableArea::willStartLiveResize() { if (m_inLiveResize) return; m_inLiveResize = true; scrollAnimator()->willStartLiveResize(); }
void ScrollableArea::scrollToOffsetWithoutAnimation(ScrollbarOrientation orientation, float offset) { auto currentOffset = scrollOffsetFromPosition(IntPoint(scrollAnimator().currentPosition())); if (orientation == HorizontalScrollbar) scrollToOffsetWithoutAnimation(FloatPoint(offset, currentOffset.y())); else scrollToOffsetWithoutAnimation(FloatPoint(currentOffset.x(), offset)); }
bool ScrollableArea::handleWheelEvent(const PlatformWheelEvent& wheelEvent) { // ctrl+wheel events are used to trigger zooming, not scrolling. if (wheelEvent.modifiers() & PlatformEvent::CtrlKey) return false; cancelProgrammaticScrollAnimation(); return scrollAnimator()->handleWheelEvent(wheelEvent); }
ScrollResult ScrollableArea::handleWheel(const PlatformWheelEvent& wheelEvent) { // Wheel events which do not scroll are used to trigger zooming. if (!wheelEvent.canScroll()) return ScrollResult(); cancelProgrammaticScrollAnimation(); return scrollAnimator()->handleWheelEvent(wheelEvent); }
void ScrollableArea::userScrollHelper(const DoublePoint& position, ScrollBehavior scrollBehavior) { cancelProgrammaticScrollAnimation(); // Smooth user scrolls (keyboard, wheel clicks) are handled via the userScroll method. // TODO(bokan): The userScroll method should probably be modified to call this method // and ScrollAnimator to have a simpler animateToOffset method like the // ProgrammaticScrollAnimator. ASSERT(scrollBehavior == ScrollBehaviorInstant); scrollAnimator()->scrollToOffsetWithoutAnimation(toFloatPoint(position)); }
void ScrollableArea::scrollPositionChanged(const DoublePoint& position, ScrollType scrollType) { TRACE_EVENT0("blink", "ScrollableArea::scrollPositionChanged"); DoublePoint oldPosition = scrollPositionDouble(); DoublePoint truncatedPosition = shouldUseIntegerScrollOffset() ? flooredIntPoint(position) : position; // Tell the derived class to scroll its contents. setScrollOffset(truncatedPosition, scrollType); Scrollbar* verticalScrollbar = this->verticalScrollbar(); // Tell the scrollbars to update their thumb postions. if (Scrollbar* horizontalScrollbar = this->horizontalScrollbar()) { horizontalScrollbar->offsetDidChange(); if (horizontalScrollbar->isOverlayScrollbar() && !hasLayerForHorizontalScrollbar()) { if (!verticalScrollbar) horizontalScrollbar->invalidate(); else { // If there is both a horizontalScrollbar and a verticalScrollbar, // then we must also invalidate the corner between them. IntRect boundsAndCorner = horizontalScrollbar->boundsRect(); boundsAndCorner.setWidth(boundsAndCorner.width() + verticalScrollbar->width()); horizontalScrollbar->invalidateRect(boundsAndCorner); } } } if (verticalScrollbar) { verticalScrollbar->offsetDidChange(); if (verticalScrollbar->isOverlayScrollbar() && !hasLayerForVerticalScrollbar()) verticalScrollbar->invalidate(); } if (scrollPositionDouble() != oldPosition) { // FIXME: Pass in DoubleSize. crbug.com/414283. scrollAnimator()->notifyContentAreaScrolled(toFloatSize(scrollPositionDouble() - oldPosition)); } scrollAnimator()->setCurrentPosition(toFloatPoint(position)); }
bool VisualViewport::didSetScaleOrLocation(float scale, const FloatPoint& location) { if (!mainFrame()) return false; bool valuesChanged = false; if (scale != m_scale) { m_scale = scale; valuesChanged = true; frameHost().chromeClient().pageScaleFactorChanged(); enqueueResizeEvent(); } ScrollOffset clampedOffset = clampScrollOffset(toScrollOffset(location)); if (clampedOffset != m_offset) { m_offset = clampedOffset; scrollAnimator().setCurrentOffset(m_offset); // SVG runs with accelerated compositing disabled so no // ScrollingCoordinator. if (ScrollingCoordinator* coordinator = frameHost().page().scrollingCoordinator()) coordinator->scrollableAreaScrollLayerDidChange(this); if (!frameHost().settings().inertVisualViewport()) { if (Document* document = mainFrame()->document()) document->enqueueScrollEventForNode(document); } enqueueScrollEvent(); mainFrame()->view()->didChangeScrollOffset(); valuesChanged = true; } if (!valuesChanged) return false; InspectorInstrumentation::didUpdateLayout(mainFrame()); mainFrame()->loader().saveScrollState(); clampToBoundaries(); return true; }
RenderLayerScrollableArea::RenderLayerScrollableArea(RenderLayer& layer) : m_layer(layer) , m_scrollsOverflow(false) , m_scrollDimensionsDirty(true) , m_inOverflowRelayout(false) , m_nextTopmostScrollChild(0) , m_topmostScrollChild(0) , m_needsCompositedScrolling(false) { ScrollableArea::setConstrainsScrollingToContentEdge(false); Node* node = box().node(); if (node && node->isElementNode()) { // We save and restore only the scrollOffset as the other scroll values are recalculated. Element* element = toElement(node); m_scrollOffset = element->savedLayerScrollOffset(); if (!m_scrollOffset.isZero()) scrollAnimator()->setCurrentPosition(FloatPoint(m_scrollOffset.width(), m_scrollOffset.height())); element->setSavedLayerScrollOffset(IntSize()); } }
bool ScrollableArea::scroll(ScrollDirection direction, ScrollGranularity granularity, float multiplier) { ScrollbarOrientation orientation; Scrollbar* scrollbar; if (direction == ScrollUp || direction == ScrollDown) { orientation = VerticalScrollbar; scrollbar = verticalScrollbar(); } else { orientation = HorizontalScrollbar; scrollbar = horizontalScrollbar(); } if (!scrollbar) return false; float step = 0; switch (granularity) { case ScrollByLine: step = scrollbar->lineStep(); break; case ScrollByPage: step = scrollbar->pageStep(); break; case ScrollByDocument: step = scrollbar->totalSize(); break; case ScrollByPixel: case ScrollByPrecisePixel: step = scrollbar->pixelStep(); break; case ScrollByPixelVelocity: break; } if (granularity != ScrollByPixelVelocity && (direction == ScrollUp || direction == ScrollLeft)) multiplier = -multiplier; return scrollAnimator()->scroll(orientation, granularity, step, multiplier); }
void ScrollableArea::mouseExitedScrollbar(Scrollbar* scrollbar) const { scrollAnimator()->mouseExitedScrollbar(scrollbar); }
void ScrollableArea::willRemoveVerticalScrollbar(Scrollbar* scrollbar) { scrollAnimator()->willRemoveVerticalScrollbar(scrollbar); }
void ScrollableArea::verticalScrollbarLayerDidChange() { scrollAnimator().verticalScrollbarLayerDidChange(); }
bool ScrollableArea::handleWheelEvent(const PlatformWheelEvent& wheelEvent) { return scrollAnimator()->handleWheelEvent(wheelEvent); }
void ScrollableArea::scrollToOffsetWithoutAnimation(const FloatPoint& offset) { scrollAnimator()->scrollToOffsetWithoutAnimation(offset); }
void ScrollableArea::notifyScrollPositionChanged(const IntPoint& position) { scrollPositionChanged(position); scrollAnimator()->setCurrentPosition(position); }
void ScrollableArea::scrollToOffsetWithoutAnimation(const FloatPoint& offset) { cancelProgrammaticScrollAnimation(); scrollAnimator()->scrollToOffsetWithoutAnimation(offset); }
void ScrollableArea::contentAreaWillPaint() const { scrollAnimator()->contentAreaWillPaint(); }
void ScrollableArea::scrollToXOffsetWithoutAnimation(float x) { scrollToOffsetWithoutAnimation(FloatPoint(x, scrollAnimator()->currentPosition().y())); }
void ScrollableArea::contentsResized() { scrollAnimator()->contentsResized(); }
void ScrollableArea::contentAreaDidHide() const { scrollAnimator()->contentAreaDidHide(); }
void ScrollableArea::mouseMovedInContentArea() const { scrollAnimator()->mouseMovedInContentArea(); }
void ScrollableArea::scrollToYOffsetWithoutAnimation(float y) { scrollToOffsetWithoutAnimation(FloatPoint(scrollAnimator()->currentPosition().x(), y)); }
void ScrollableArea::willRemoveHorizontalScrollbar(Scrollbar* scrollbar) { scrollAnimator()->willRemoveHorizontalScrollbar(scrollbar); }
void ScrollableArea::horizontalScrollbarLayerDidChange() { scrollAnimator().horizontalScrollbarLayerDidChange(); }
void ScrollableArea::mouseExitedContentArea() const { scrollAnimator()->mouseEnteredContentArea(); }
void ScrollableArea::handleGestureEvent(const PlatformGestureEvent& gestureEvent) { scrollAnimator()->handleGestureEvent(gestureEvent); }