summaryrefslogtreecommitdiffstats
path: root/widget/SwipeTracker.cpp
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
commit36d22d82aa202bb199967e9512281e9a53db42c9 (patch)
tree105e8c98ddea1c1e4784a60a5a6410fa416be2de /widget/SwipeTracker.cpp
parentInitial commit. (diff)
downloadfirefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.tar.xz
firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.zip
Adding upstream version 115.7.0esr.upstream/115.7.0esr
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'widget/SwipeTracker.cpp')
-rw-r--r--widget/SwipeTracker.cpp265
1 files changed, 265 insertions, 0 deletions
diff --git a/widget/SwipeTracker.cpp b/widget/SwipeTracker.cpp
new file mode 100644
index 0000000000..c12368a1bc
--- /dev/null
+++ b/widget/SwipeTracker.cpp
@@ -0,0 +1,265 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "SwipeTracker.h"
+
+#include "InputData.h"
+#include "mozilla/FlushType.h"
+#include "mozilla/PresShell.h"
+#include "mozilla/StaticPrefs_widget.h"
+#include "mozilla/StaticPrefs_browser.h"
+#include "mozilla/TimeStamp.h"
+#include "mozilla/TouchEvents.h"
+#include "mozilla/dom/SimpleGestureEventBinding.h"
+#include "nsAlgorithm.h"
+#include "nsIWidget.h"
+#include "nsRefreshDriver.h"
+#include "UnitTransforms.h"
+
+// These values were tweaked to make the physics feel similar to the native
+// swipe.
+static const double kSpringForce = 250.0;
+static const double kSwipeSuccessThreshold = 0.25;
+
+namespace mozilla {
+
+static already_AddRefed<nsRefreshDriver> GetRefreshDriver(nsIWidget& aWidget) {
+ nsIWidgetListener* widgetListener = aWidget.GetWidgetListener();
+ PresShell* presShell =
+ widgetListener ? widgetListener->GetPresShell() : nullptr;
+ nsPresContext* presContext =
+ presShell ? presShell->GetPresContext() : nullptr;
+ RefPtr<nsRefreshDriver> refreshDriver =
+ presContext ? presContext->RefreshDriver() : nullptr;
+ return refreshDriver.forget();
+}
+
+SwipeTracker::SwipeTracker(nsIWidget& aWidget,
+ const PanGestureInput& aSwipeStartEvent,
+ uint32_t aAllowedDirections,
+ uint32_t aSwipeDirection)
+ : mWidget(aWidget),
+ mRefreshDriver(GetRefreshDriver(mWidget)),
+ mAxis(0.0, 0.0, 0.0, kSpringForce, 1.0),
+ mEventPosition(RoundedToInt(ViewAs<LayoutDevicePixel>(
+ aSwipeStartEvent.mPanStartPoint,
+ PixelCastJustification::LayoutDeviceIsScreenForUntransformedEvent))),
+ mLastEventTimeStamp(aSwipeStartEvent.mTimeStamp),
+ mAllowedDirections(aAllowedDirections),
+ mSwipeDirection(aSwipeDirection),
+ mGestureAmount(0.0),
+ mCurrentVelocity(0.0),
+ mEventsAreControllingSwipe(true),
+ mEventsHaveStartedNewGesture(false),
+ mRegisteredWithRefreshDriver(false) {
+ SendSwipeEvent(eSwipeGestureStart, 0, 0.0, aSwipeStartEvent.mTimeStamp);
+ ProcessEvent(aSwipeStartEvent, /* aProcessingFirstEvent = */ true);
+}
+
+void SwipeTracker::Destroy() { UnregisterFromRefreshDriver(); }
+
+SwipeTracker::~SwipeTracker() {
+ MOZ_RELEASE_ASSERT(!mRegisteredWithRefreshDriver,
+ "Destroy needs to be called before deallocating");
+}
+
+double SwipeTracker::SwipeSuccessTargetValue() const {
+ return (mSwipeDirection == dom::SimpleGestureEvent_Binding::DIRECTION_RIGHT)
+ ? -1.0
+ : 1.0;
+}
+
+double SwipeTracker::ClampToAllowedRange(double aGestureAmount) const {
+ // gestureAmount needs to stay between -1 and 0 when swiping right and
+ // between 0 and 1 when swiping left.
+ double min =
+ (mSwipeDirection == dom::SimpleGestureEvent_Binding::DIRECTION_RIGHT)
+ ? -1.0
+ : 0.0;
+ double max =
+ (mSwipeDirection == dom::SimpleGestureEvent_Binding::DIRECTION_LEFT)
+ ? 1.0
+ : 0.0;
+ return clamped(aGestureAmount, min, max);
+}
+
+bool SwipeTracker::ComputeSwipeSuccess() const {
+ double targetValue = SwipeSuccessTargetValue();
+
+ // If the fingers were moving away from the target direction when they were
+ // lifted from the touchpad, abort the swipe.
+ if (mCurrentVelocity * targetValue <
+ -StaticPrefs::widget_swipe_velocity_twitch_tolerance()) {
+ return false;
+ }
+
+ return (mGestureAmount * targetValue +
+ mCurrentVelocity * targetValue *
+ StaticPrefs::widget_swipe_success_velocity_contribution()) >=
+ kSwipeSuccessThreshold;
+}
+
+nsEventStatus SwipeTracker::ProcessEvent(
+ const PanGestureInput& aEvent, bool aProcessingFirstEvent /* = false */) {
+ // If the fingers have already been lifted or the swipe direction is where
+ // navigation is impossible, don't process this event for swiping.
+ if (!mEventsAreControllingSwipe || !SwipingInAllowedDirection()) {
+ // Return nsEventStatus_eConsumeNoDefault for events from the swipe gesture
+ // and nsEventStatus_eIgnore for events of subsequent scroll gestures.
+ if (aEvent.mType == PanGestureInput::PANGESTURE_MAYSTART ||
+ aEvent.mType == PanGestureInput::PANGESTURE_START) {
+ mEventsHaveStartedNewGesture = true;
+ }
+ return mEventsHaveStartedNewGesture ? nsEventStatus_eIgnore
+ : nsEventStatus_eConsumeNoDefault;
+ }
+
+ double delta = -aEvent.mPanDisplacement.x /
+ mWidget.GetDefaultScaleInternal() /
+ StaticPrefs::widget_swipe_whole_page_pixel_size();
+ mGestureAmount = ClampToAllowedRange(mGestureAmount + delta);
+ if (aEvent.mType != PanGestureInput::PANGESTURE_END) {
+ if (!aProcessingFirstEvent) {
+ double elapsedSeconds = std::max(
+ 0.008, (aEvent.mTimeStamp - mLastEventTimeStamp).ToSeconds());
+ mCurrentVelocity = delta / elapsedSeconds;
+ }
+ mLastEventTimeStamp = aEvent.mTimeStamp;
+ }
+
+ const bool computedSwipeSuccess = ComputeSwipeSuccess();
+ double eventAmount = mGestureAmount;
+ // If ComputeSwipeSuccess returned false because the users fingers were
+ // moving slightly away from the target direction then we do not want to
+ // display the UI as if we were at the success threshold as that would
+ // give a false indication that navigation would happen.
+ if (!computedSwipeSuccess && (eventAmount >= kSwipeSuccessThreshold ||
+ eventAmount <= -kSwipeSuccessThreshold)) {
+ eventAmount = 0.999 * kSwipeSuccessThreshold;
+ if (mGestureAmount < 0.f) {
+ eventAmount = -eventAmount;
+ }
+ }
+
+ SendSwipeEvent(eSwipeGestureUpdate, 0, eventAmount, aEvent.mTimeStamp);
+
+ if (aEvent.mType == PanGestureInput::PANGESTURE_END) {
+ mEventsAreControllingSwipe = false;
+ if (computedSwipeSuccess) {
+ // Let's use same timestamp as previous event because this is caused by
+ // the preceding event.
+ SendSwipeEvent(eSwipeGesture, mSwipeDirection, 0.0, aEvent.mTimeStamp);
+ UnregisterFromRefreshDriver();
+ NS_DispatchToMainThread(
+ NS_NewRunnableFunction("SwipeTracker::SwipeFinished",
+ [swipeTracker = RefPtr<SwipeTracker>(this),
+ timeStamp = aEvent.mTimeStamp] {
+ swipeTracker->SwipeFinished(timeStamp);
+ }));
+ } else {
+ StartAnimating(eventAmount, 0.0);
+ }
+ }
+
+ return nsEventStatus_eConsumeNoDefault;
+}
+
+void SwipeTracker::StartAnimating(double aStartValue, double aTargetValue) {
+ mAxis.SetPosition(aStartValue);
+ mAxis.SetDestination(aTargetValue);
+ mAxis.SetVelocity(mCurrentVelocity);
+
+ mLastAnimationFrameTime = TimeStamp::Now();
+
+ // Add ourselves as a refresh driver observer. The refresh driver
+ // will call WillRefresh for each animation frame until we
+ // unregister ourselves.
+ MOZ_RELEASE_ASSERT(!mRegisteredWithRefreshDriver,
+ "We only want a single refresh driver registration");
+ if (mRefreshDriver) {
+ mRefreshDriver->AddRefreshObserver(this, FlushType::Style,
+ "Swipe animation");
+ mRegisteredWithRefreshDriver = true;
+ }
+}
+
+void SwipeTracker::WillRefresh(mozilla::TimeStamp aTime) {
+ TimeStamp now = TimeStamp::Now();
+ mAxis.Simulate(now - mLastAnimationFrameTime);
+ mLastAnimationFrameTime = now;
+
+ bool isFinished =
+ mAxis.IsFinished(1.0 / StaticPrefs::widget_swipe_whole_page_pixel_size());
+ mGestureAmount = (isFinished ? mAxis.GetDestination() : mAxis.GetPosition());
+ SendSwipeEvent(eSwipeGestureUpdate, 0, mGestureAmount, now);
+
+ if (isFinished) {
+ UnregisterFromRefreshDriver();
+ SwipeFinished(now);
+ }
+}
+
+void SwipeTracker::CancelSwipe(const TimeStamp& aTimeStamp) {
+ SendSwipeEvent(eSwipeGestureEnd, 0, 0.0, aTimeStamp);
+}
+
+void SwipeTracker::SwipeFinished(const TimeStamp& aTimeStamp) {
+ SendSwipeEvent(eSwipeGestureEnd, 0, 0.0, aTimeStamp);
+ mWidget.SwipeFinished();
+}
+
+void SwipeTracker::UnregisterFromRefreshDriver() {
+ if (mRegisteredWithRefreshDriver) {
+ MOZ_ASSERT(mRefreshDriver, "How were we able to register, then?");
+ mRefreshDriver->RemoveRefreshObserver(this, FlushType::Style);
+ mRegisteredWithRefreshDriver = false;
+ }
+}
+
+/* static */ WidgetSimpleGestureEvent SwipeTracker::CreateSwipeGestureEvent(
+ EventMessage aMsg, nsIWidget* aWidget,
+ const LayoutDeviceIntPoint& aPosition, const TimeStamp& aTimeStamp) {
+ // XXX Why isn't this initialized with nsCocoaUtils::InitInputEvent()?
+ WidgetSimpleGestureEvent geckoEvent(true, aMsg, aWidget);
+ geckoEvent.mModifiers = 0;
+ // XXX How about geckoEvent.mTime?
+ geckoEvent.mTimeStamp = aTimeStamp;
+ geckoEvent.mRefPoint = aPosition;
+ geckoEvent.mButtons = 0;
+ return geckoEvent;
+}
+
+bool SwipeTracker::SendSwipeEvent(EventMessage aMsg, uint32_t aDirection,
+ double aDelta, const TimeStamp& aTimeStamp) {
+ WidgetSimpleGestureEvent geckoEvent =
+ CreateSwipeGestureEvent(aMsg, &mWidget, mEventPosition, aTimeStamp);
+ geckoEvent.mDirection = aDirection;
+ geckoEvent.mDelta = aDelta;
+ geckoEvent.mAllowedDirections = mAllowedDirections;
+ return mWidget.DispatchWindowEvent(geckoEvent);
+}
+
+// static
+bool SwipeTracker::CanTriggerSwipe(const PanGestureInput& aPanInput) {
+ if (StaticPrefs::widget_disable_swipe_tracker()) {
+ return false;
+ }
+
+ if (aPanInput.mType != PanGestureInput::PANGESTURE_START) {
+ return false;
+ }
+
+ // Only initiate horizontal tracking for events whose horizontal element is
+ // at least eight times larger than its vertical element. This minimizes
+ // performance problems with vertical scrolls (by minimizing the possibility
+ // that they'll be misinterpreted as horizontal swipes), while still
+ // tolerating a small vertical element to a true horizontal swipe. The number
+ // '8' was arrived at by trial and error.
+ return std::abs(aPanInput.mPanDisplacement.x) >
+ std::abs(aPanInput.mPanDisplacement.y) * 8;
+}
+
+} // namespace mozilla