Changeset 284596 in webkit

Timestamp:

Oct 21, 2021, 2:53:50 AM (5 years ago)

Author:

Chris Lord

Message:

[GTK] Slow scrolling (not matching GTK native scroll amount)
​https://bugs.webkit.org/show_bug.cgi?id=197100

Reviewed by Simon Fraser.

Fix up behaviour with interrupting smooth scrolling, mainly on
keyboard-initiated scrolling, but also for the mouse-wheel. When
interrupting a smooth scroll, the animation curve is now changed from
ease-in-out to ease-out and the duration is recalculated.

No new tests, covered by existing tests.

• platform/ScrollAnimation.h:

(WebCore::ScrollAnimation::destinationOffset const):

• platform/ScrollAnimationSmooth.cpp:

(WebCore::ScrollAnimationSmooth::ScrollAnimationSmooth):
(WebCore::ScrollAnimationSmooth::startAnimatedScrollToDestination):
(WebCore::ScrollAnimationSmooth::retargetActiveAnimation):
(WebCore::ScrollAnimationSmooth::animateScroll):
(WebCore::ScrollAnimationSmooth::startOrRetargetAnimation): Deleted.

• platform/ScrollAnimationSmooth.h:
• platform/ScrollAnimator.cpp:

(WebCore::ScrollAnimator::scroll):

• platform/ScrollingEffectsController.cpp:

(WebCore::ScrollingEffectsController::retargetAnimatedScrollBy):
(WebCore::ScrollingEffectsController::handleWheelEvent):

• platform/ScrollingEffectsController.h:

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• platform/ScrollAnimation.h (modified) (1 diff)
• platform/ScrollAnimationSmooth.cpp (modified) (4 diffs)
• platform/ScrollAnimationSmooth.h (modified) (2 diffs)
• platform/ScrollAnimator.cpp (modified) (1 diff)
• platform/ScrollingEffectsController.cpp (modified) (2 diffs)
• platform/ScrollingEffectsController.h (modified) (1 diff)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2021-10-21  Chris Lord  <clord@igalia.com>
+
+        [GTK] Slow scrolling (not matching GTK native scroll amount)
+        https://bugs.webkit.org/show_bug.cgi?id=197100
+
+        Reviewed by Simon Fraser.
+
+        Fix up behaviour with interrupting smooth scrolling, mainly on
+        keyboard-initiated scrolling, but also for the mouse-wheel. When
+        interrupting a smooth scroll, the animation curve is now changed from
+        ease-in-out to ease-out and the duration is recalculated.
+
+        No new tests, covered by existing tests.
+
+        * platform/ScrollAnimation.h:
+        (WebCore::ScrollAnimation::destinationOffset const):
+        * platform/ScrollAnimationSmooth.cpp:
+        (WebCore::ScrollAnimationSmooth::ScrollAnimationSmooth):
+        (WebCore::ScrollAnimationSmooth::startAnimatedScrollToDestination):
+        (WebCore::ScrollAnimationSmooth::retargetActiveAnimation):
+        (WebCore::ScrollAnimationSmooth::animateScroll):
+        (WebCore::ScrollAnimationSmooth::startOrRetargetAnimation): Deleted.
+        * platform/ScrollAnimationSmooth.h:
+        * platform/ScrollAnimator.cpp:
+        (WebCore::ScrollAnimator::scroll):
+        * platform/ScrollingEffectsController.cpp:
+        (WebCore::ScrollingEffectsController::retargetAnimatedScrollBy):
+        (WebCore::ScrollingEffectsController::handleWheelEvent):
+        * platform/ScrollingEffectsController.h:
+
 2021-10-20  Brady Eidson  <beidson@apple.com>
 

trunk/Source/WebCore/platform/ScrollAnimation.h

@@ -79 +79 @@
     
     FloatPoint currentOffset() const { return m_currentOffset; }
+    virtual std::optional<FloatPoint> destinationOffset() const { return std::nullopt; }
 
     virtual void serviceAnimation(MonotonicTime) = 0;

trunk/Source/WebCore/platform/ScrollAnimationSmooth.cpp

@@ -42 +42 @@
 ScrollAnimationSmooth::ScrollAnimationSmooth(ScrollAnimationClient& client)
     : ScrollAnimation(Type::Smooth, client)
-    , m_easeInOutTimingFunction(CubicBezierTimingFunction::create(CubicBezierTimingFunction::TimingFunctionPreset::EaseInOut))
+    , m_timingFunction(CubicBezierTimingFunction::create())
 {
 }
@@ -50 +50 @@
 bool ScrollAnimationSmooth::startAnimatedScrollToDestination(const FloatPoint& fromOffset, const FloatPoint& destinationOffset)
 {
-    m_startOffset = fromOffset;
-    m_duration = durationFromDistance(destinationOffset - m_startOffset);
+    if (!isActive() && fromOffset == destinationOffset)
+        return false;
 
     auto extents = m_client.scrollExtentsForAnimation(*this);
-    return startOrRetargetAnimation(extents, destinationOffset);
+
+    m_startTime = MonotonicTime::now();
+    m_startOffset = fromOffset;
+    m_destinationOffset = destinationOffset.constrainedBetween(extents.minimumScrollOffset(), extents.maximumScrollOffset());
+    m_duration = durationFromDistance(m_destinationOffset - m_startOffset);
+    downcast<CubicBezierTimingFunction>(*m_timingFunction).setTimingFunctionPreset(CubicBezierTimingFunction::TimingFunctionPreset::EaseInOut);
+
+    if (!isActive())
+        didStart(MonotonicTime::now());
+
+    return true;
 }
 
@@ -63 +73 @@
 
     auto extents = m_client.scrollExtentsForAnimation(*this);
-    return startOrRetargetAnimation(extents, newOffset);
-}
 
-bool ScrollAnimationSmooth::startOrRetargetAnimation(const ScrollExtents& extents, const FloatPoint& destinationOffset)
-{
-    m_destinationOffset = destinationOffset.constrainedBetween(extents.minimumScrollOffset(), extents.maximumScrollOffset());
-    bool needToScroll = m_startOffset != m_destinationOffset;
+    m_startTime = MonotonicTime::now();
+    m_startOffset = m_currentOffset;
+    m_destinationOffset = newOffset.constrainedBetween(extents.minimumScrollOffset(), extents.maximumScrollOffset());
+    m_duration = durationFromDistance(m_destinationOffset - m_startOffset);
+    downcast<CubicBezierTimingFunction>(*m_timingFunction).setTimingFunctionPreset(CubicBezierTimingFunction::TimingFunctionPreset::EaseOut);
+    m_timingFunction = CubicBezierTimingFunction::create(CubicBezierTimingFunction::TimingFunctionPreset::EaseOut);
 
-    if (needToScroll && !isActive())
-        didStart(MonotonicTime::now());
+    if (m_currentOffset == m_destinationOffset)
+        return false;
 
-    return needToScroll;
+    return true;
 }
 
@@ -109 +119 @@
 
     double fractionComplete = (currentTime - m_startTime) / m_duration;
-    double progress = m_easeInOutTimingFunction->transformProgress(fractionComplete, m_duration.value());
+    double progress = m_timingFunction->transformProgress(fractionComplete, m_duration.value());
 
     m_currentOffset = {

trunk/Source/WebCore/platform/ScrollAnimationSmooth.h

@@ -42 +42 @@
     bool retargetActiveAnimation(const FloatPoint& newOffset) final;
 
-    const FloatPoint& destinationOffset() const { return m_destinationOffset; }
+    std::optional<FloatPoint> destinationOffset() const final { return m_destinationOffset; }
 
 private:
-
-    bool startOrRetargetAnimation(const ScrollExtents&, const FloatPoint& destinationOffset);
 
     void updateScrollExtents() final;
@@ -60 +58 @@
     FloatPoint m_destinationOffset;
 
-    RefPtr<TimingFunction> m_easeInOutTimingFunction;
+    RefPtr<TimingFunction> m_timingFunction;
 };
 

trunk/Source/WebCore/platform/ScrollAnimator.cpp

@@ -90 +90 @@
 
     if (m_scrollableArea.scrollAnimatorEnabled() && platformAllowsScrollAnimation() && !behavior.contains(ScrollBehavior::NeverAnimate)) {
+        if (m_scrollController.retargetAnimatedScrollBy(delta))
+            return true;
+
         auto startOffset = offsetFromPosition(m_currentPosition);
         auto extents = scrollExtents();

trunk/Source/WebCore/platform/ScrollingEffectsController.cpp

@@ -119 +119 @@
 }
 
+bool ScrollingEffectsController::retargetAnimatedScrollBy(FloatSize offset)
+{
+    if (!is<ScrollAnimationSmooth>(m_currentAnimation.get()))
+        return false;
+
+    LOG_WITH_STREAM(ScrollAnimations, stream << "ScrollingEffectsController " << this << " retargetAnimatedScrollBy " << offset);
+
+    ASSERT(m_currentAnimation->isActive());
+    if (auto destinationOffset = m_currentAnimation->destinationOffset())
+        return m_currentAnimation->retargetActiveAnimation(*destinationOffset + offset);
+
+    return false;
+}
+
 void ScrollingEffectsController::stopAnimatedScroll()
 {
@@ -352 +366 @@
 #if ENABLE(SMOOTH_SCROLLING)
     if (m_client.scrollAnimationEnabled() && !m_inScrollGesture) {
-        if (is<ScrollAnimationSmooth>(m_currentAnimation.get())) {
-            auto lastDestinationOffset = downcast<ScrollAnimationSmooth>(*m_currentAnimation).destinationOffset();
-            retargetAnimatedScroll(lastDestinationOffset + FloatSize { deltaX, deltaY });
-        } else
+        if (!retargetAnimatedScrollBy({ deltaX, deltaY }))
             startAnimatedScrollToDestination(scrollOffset, scrollOffset + FloatSize { deltaX, deltaY });
         return true;

trunk/Source/WebCore/platform/ScrollingEffectsController.h

@@ -136 +136 @@
     bool startAnimatedScrollToDestination(FloatPoint startOffset, FloatPoint destinationOffset);
     bool retargetAnimatedScroll(FloatPoint newDestinationOffset);
+    bool retargetAnimatedScrollBy(FloatSize);
     void stopAnimatedScroll();