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);
}
