Merge pull request #408 from taj-ny/swipe-angle

core: make swipe triggers angle-based

Author: taj-ny

src/CMakeLists.txt

@@ -88,6 +88,7 @@ if (INPUTACTIONS_BUILD_HYPRLAND OR INPUTACTIONS_BUILD_KWIN OR INPUTACTIONS_BUILD
         libinputactions/triggers/MotionTrigger.cpp
         libinputactions/triggers/PressTrigger.cpp
         libinputactions/triggers/StrokeTrigger.cpp
+        libinputactions/triggers/SwipeTrigger.cpp
         libinputactions/triggers/Trigger.cpp
         libinputactions/triggers/WheelTrigger.cpp
         libinputactions/variables/LocalVariable.cpp

src/libinputactions/config/parsers/core.cpp

@@ -52,6 +52,7 @@
 #include <libinputactions/triggers/KeyboardShortcutTrigger.h>
 #include <libinputactions/triggers/PressTrigger.h>
 #include <libinputactions/triggers/StrokeTrigger.h>
+#include <libinputactions/triggers/SwipeTrigger.h>
 #include <libinputactions/triggers/WheelTrigger.h>
 #include <libinputactions/variables/Variable.h>
 #include <libinputactions/variables/VariableManager.h>
@@ -436,11 +437,14 @@ void NodeParser<InputDeviceProperties>::parse(const Node *node, InputDevicePrope
     loadSetter(result, &InputDeviceProperties::setGrab, node->at("grab"));
     loadSetter(result, &InputDeviceProperties::setHandleLibevdevEvents, node->at("handle_libevdev_events"));
     loadSetter(result, &InputDeviceProperties::setIgnore, node->at("ignore"));
+    loadSetter(result, &InputDeviceProperties::setMotionThreshold, node->at("motion_threshold"));
     loadSetter(result, &InputDeviceProperties::setMouseMotionTimeout, node->at("motion_timeout"));
     loadSetter(result, &InputDeviceProperties::setMousePressTimeout, node->at("press_timeout"));
     loadSetter(result, &InputDeviceProperties::setMouseUnblockButtonsOnTimeout, node->at("unblock_buttons_on_timeout"));
     loadSetter(result, &InputDeviceProperties::setTouchpadButtonPad, node->at("buttonpad"));
     loadSetter(result, &InputDeviceProperties::setTouchpadClickTimeout, node->at("click_timeout"));
+    loadSetter(result, &InputDeviceProperties::setTouchpadMotionThreshold2, node->at("motion_threshold_2"));
+    loadSetter(result, &InputDeviceProperties::setTouchpadMotionThreshold2, node->at("motion_threshold_3"));
 
     if (const auto *pressureRangesNode = node->mapAt("pressure_ranges")) {
         loadSetter(result, &InputDeviceProperties::setFingerPressure, pressureRangesNode->at("finger"));
@@ -587,8 +591,20 @@ void NodeParser<std::unique_ptr<Trigger>>::parse(const Node *node, std::unique_p
     } else if (type == "stroke") {
         result = std::make_unique<StrokeTrigger>(node->at("strokes", true)->as<std::vector<Stroke>>(true));
     } else if (type == "swipe") {
-        result = std::make_unique<DirectionalMotionTrigger>(TriggerType::Swipe,
-                                                            static_cast<TriggerDirection>(node->at("direction", true)->as<SwipeDirection>()));
+        if (const auto *directionNode = node->at("direction")) {
+            result = std::make_unique<SwipeTrigger>(directionNode->as<SwipeTriggerDirection>());
+        } else {
+            const auto *angleNode = node->at("angle", true);
+            const auto angles = parseSeparatedString2<qreal>(angleNode, '-');
+            if (angles.first > 360 || angles.second > 360) {
+                throw InvalidValueConfigException(angleNode, "The angle may not be greater than 360.");
+            }
+
+            auto swipeTrigger = std::make_unique<SwipeTrigger>(angles.first, angles.second);
+            loadSetter(swipeTrigger.get(), &SwipeTrigger::setBidirectional, node->at("bidirectional"));
+            result = std::move(swipeTrigger);
+        }
+
     } else if (type == "tap") {
         result = std::make_unique<Trigger>(TriggerType::Tap);
     } else if (type == "wheel") {

src/libinputactions/config/parsers/enums.cpp

@@ -24,6 +24,7 @@
 #include <libinputactions/globals.h>
 #include <libinputactions/interfaces/CursorShapeProvider.h>
 #include <libinputactions/triggers/DirectionalMotionTrigger.h>
+#include <libinputactions/triggers/SwipeTrigger.h>
 #include <unordered_map>
 
 namespace InputActions
@@ -81,6 +82,22 @@ NODEPARSER_ENUM(SwipeDirection, "swipe direction",
                     {"left_right", SwipeDirection::LeftRight},
                     {"any", SwipeDirection::Any},
                 }))
+NODEPARSER_ENUM(SwipeTriggerDirection, "swipe direction",
+                (std::unordered_map<QString, SwipeTriggerDirection>{
+                    {"left", SwipeTriggerDirection::Left},
+                    {"right", SwipeTriggerDirection::Right},
+                    {"up", SwipeTriggerDirection::Up},
+                    {"down", SwipeTriggerDirection::Down},
+                    {"left_up", SwipeTriggerDirection::LeftUp},
+                    {"left_down", SwipeTriggerDirection::LeftDown},
+                    {"right_up", SwipeTriggerDirection::RightUp},
+                    {"right_down", SwipeTriggerDirection::RightDown},
+                    {"up_down", SwipeTriggerDirection::UpDown},
+                    {"left_right", SwipeTriggerDirection::LeftRight},
+                    {"left_up_right_down", SwipeTriggerDirection::LeftUpRightDown},
+                    {"left_down_right_up", SwipeTriggerDirection::LeftDownRightUp},
+                    {"any", SwipeTriggerDirection::Any},
+                }))
 NODEPARSER_ENUM(TriggerSpeed, "trigger speed",
                 (std::unordered_map<QString, TriggerSpeed>{
                     {"fast", TriggerSpeed::Fast},

src/libinputactions/handlers/MotionTriggerHandler.cpp

@@ -28,17 +28,13 @@
 #include <libinputactions/input/Delta.h>
 #include <libinputactions/input/devices/InputDevice.h>
 #include <libinputactions/triggers/StrokeTrigger.h>
+#include <libinputactions/triggers/SwipeTrigger.h>
 
 Q_LOGGING_CATEGORY(INPUTACTIONS_HANDLER_MOTION, "inputactions.handler.motion", QtWarningMsg)
 
 namespace InputActions
 {
 
-/**
- * Minimum amount of deltas required to accurately detect axis changes.
- */
-static const size_t AXIS_CHANGE_MIN_DELTA_COUNT = 10;
-
 static const qreal CIRCLE_COASTING_FRICTION = 0.02;
 static const std::chrono::milliseconds CIRCLE_COASTING_TIMER_INTERVAL{30L};
 static const qreal PI_2 = M_PI * 2;
@@ -81,8 +77,15 @@ bool MotionTriggerHandler::handleMotion(const InputDevice *device, const PointDe
 
     qCDebug(INPUTACTIONS_HANDLER_MOTION).nospace() << "Event (type: Motion, delta: " << delta.unaccelerated() << ")";
 
-    m_deltas.push_back(delta.unaccelerated());
-    m_totalSwipeDelta += delta.unaccelerated();
+    const auto hasStroke = hasActiveTriggers(TriggerType::Stroke);
+    const auto hasSwipe = hasActiveTriggers(TriggerType::Swipe);
+
+    if (hasStroke) {
+        m_deltas.push_back(delta.unaccelerated());
+    }
+    if (hasSwipe) {
+        m_swipeDeltas.insert(m_swipeDeltas.begin(), delta.unaccelerated());
+    }
 
     TriggerSpeed speed{};
     if (!determineSpeed(TriggerType::Swipe, delta.unacceleratedHypot(), speed)) {
@@ -91,9 +94,8 @@ bool MotionTriggerHandler::handleMotion(const InputDevice *device, const PointDe
 
     std::map<TriggerType, const TriggerUpdateEvent *> events;
     DirectionalMotionTriggerUpdateEvent circleEvent;
-    DirectionalMotionTriggerUpdateEvent swipeEvent;
+    SwipeTriggerUpdateEvent swipeEvent;
     MotionTriggerUpdateEvent strokeEvent;
-    bool axisChanged{};
 
     // Block the event even if the result says not to do so.
     bool block{};
@@ -161,57 +163,50 @@ bool MotionTriggerHandler::handleMotion(const InputDevice *device, const PointDe
         // TODO: Cancel if motion is a straight line
     }
 
-    if (hasActiveTriggers(TriggerType::Swipe)) {
-        if (m_deltas.size() < 2) {
-            // One delta may not be enough to determine the direction
-            return true;
-        }
+    if (hasSwipe) {
+        const auto motionThreshold = currentMotionThreshold(device);
+        bool motionThresholdReached{};
 
-        if (m_currentSwipeAxis == Axis::None) {
-            m_currentSwipeAxis = std::abs(m_totalSwipeDelta.x()) >= std::abs(m_totalSwipeDelta.y()) ? Axis::Horizontal : Axis::Vertical;
-        } else if (m_deltas.size() >= AXIS_CHANGE_MIN_DELTA_COUNT) { // Make sure we have enough data to detect axis change
-            const std::vector<QPointF> lastDeltas(m_deltas.end() - AXIS_CHANGE_MIN_DELTA_COUNT, m_deltas.end());
-            QPointF sum;
-            for (const auto &delta : lastDeltas) {
-                sum += {std::abs(delta.x()), std::abs(delta.y())};
+        QPointF totalDelta;
+        auto it = m_swipeDeltas.begin();
+        for (; it != m_swipeDeltas.end(); ++it) {
+            totalDelta += *it;
+            if (Math::hypot(totalDelta) < motionThreshold) {
+                continue;
             }
 
-            if (std::min(sum.x(), sum.y()) / std::max(sum.x(), sum.y()) <= 0.2 // Must be a sharp turn
-                && ((m_currentSwipeAxis == Axis::Horizontal && sum.y() > sum.x()) || (m_currentSwipeAxis == Axis::Vertical && sum.x() > sum.y()))) {
-                m_currentSwipeAxis = m_currentSwipeAxis == Axis::Horizontal ? Axis::Vertical : Axis::Horizontal;
-                axisChanged = true;
-                qCDebug(INPUTACTIONS_HANDLER_MOTION, "Swipe axis changed");
-            }
+            motionThresholdReached = true;
+            break;
         }
 
-        SwipeDirection direction{};
-        switch (m_currentSwipeAxis) {
-            case Axis::Vertical:
-                direction = m_totalSwipeDelta.y() < 0 ? SwipeDirection::Up : SwipeDirection::Down;
-                break;
-            case Axis::Horizontal:
-                direction = m_totalSwipeDelta.x() < 0 ? SwipeDirection::Left : SwipeDirection::Right;
-                break;
-            default:
-                Q_UNREACHABLE();
+        if (!motionThresholdReached) {
+            return hasActiveBlockingTriggers(TriggerType::Swipe);
         }
+        m_swipeDeltas.erase(++it, m_swipeDeltas.end());
+
+        // Up should be 90°, not 270°
+        auto currentDelta = delta.unaccelerated();
+        currentDelta.setY(-currentDelta.y());
+        totalDelta.setY(-totalDelta.y());
 
-        swipeEvent.setDelta(m_currentSwipeAxis == Axis::Vertical ? Delta(delta.accelerated().y(), delta.unaccelerated().y())
-                                                                 : Delta(delta.accelerated().x(), delta.unaccelerated().x()));
-        swipeEvent.setDirection(static_cast<TriggerDirection>(direction));
+        swipeEvent.setAngle(Math::atan2deg360(currentDelta));
+        swipeEvent.setAverageAngle(Math::atan2deg360(totalDelta / m_swipeDeltas.size()));
+        swipeEvent.setDelta(Delta(delta.acceleratedHypot(), delta.unacceleratedHypot()));
         swipeEvent.setPointDelta({delta.accelerated() * m_swipeDeltaMultiplier, delta.unaccelerated() * m_swipeDeltaMultiplier});
         swipeEvent.setSpeed(speed);
         events[TriggerType::Swipe] = &swipeEvent;
     }
 
-    if (hasActiveTriggers(TriggerType::Stroke)) {
+    if (hasStroke) {
         strokeEvent.setDelta(device->type() == InputDeviceType::Mouse ? delta.acceleratedHypot() : delta.unacceleratedHypot()); // backwards compatibility
         strokeEvent.setSpeed(speed);
         events[TriggerType::Stroke] = &strokeEvent;
     }
 
     const auto result = updateTriggers(events);
-    if (axisChanged && !result.success) {
+    if (result.success) {
+        m_swipeUpdates++;
+    } else if (hasSwipe && m_swipeUpdates > 0) {
         activateTriggers(TriggerType::Swipe);
         return handleMotion(device, delta);
     }
@@ -256,18 +251,23 @@ bool MotionTriggerHandler::determineSpeed(TriggerType type, qreal delta, Trigger
     return true;
 }
 
+qreal MotionTriggerHandler::currentMotionThreshold(const InputDevice *device) const
+{
+    return device->properties().motionThreshold();
+}
+
 void MotionTriggerHandler::reset()
 {
     TriggerHandler::reset();
-    m_currentSwipeAxis = Axis::None;
-    m_totalSwipeDelta = {};
     m_speed = {};
     m_isDeterminingSpeed = false;
     m_circleIsFirstEvent = true;
     m_deltas.clear();
     m_sampledInputEvents = m_accumulatedAbsoluteSampledDelta = m_circlePreviousAngle = m_circlePreviousDistance = m_circleFilterDelta = m_circleAdaptiveDelta
         = m_circleTotalDelta = 0;
     m_circleCoastingTimer.stop();
+    m_swipeDeltas.clear();
+    m_swipeUpdates = 0;
 }
 
 void MotionTriggerHandler::onCircleCoastingTimerTick()

src/libinputactions/handlers/MotionTriggerHandler.h

@@ -82,6 +82,8 @@ class MotionTriggerHandler : public InputTriggerHandler
      */
     bool determineSpeed(TriggerType type, qreal delta, TriggerSpeed &speed, TriggerDirection direction = UINT32_MAX);
 
+    virtual qreal currentMotionThreshold(const InputDevice *device) const;
+
     void reset() override;
 
 private slots:
@@ -91,8 +93,11 @@ private slots:
     void onEndingTriggers(TriggerTypes types);
 
 private:
-    Axis m_currentSwipeAxis = Axis::None;
-    QPointF m_totalSwipeDelta;
+    /**
+     * Contains latest events whose sum is roughly equal to (but never less than) the motion threshold, any events over the threshold are discarded.
+     */
+    std::vector<QPointF> m_swipeDeltas;
+    uint32_t m_swipeUpdates{};
 
     bool m_isDeterminingSpeed = false;
     uint8_t m_sampledInputEvents = 0;
@@ -114,6 +119,7 @@ private slots:
     uint8_t m_inputEventsToSample = 3;
 
     friend class MockTouchpadTriggerHandler;
+    friend class TestMotionTriggerHandler;
 };
 
 }

src/libinputactions/handlers/TouchpadTriggerHandler.cpp

@@ -44,6 +44,7 @@ TouchpadTriggerHandler::TouchpadTriggerHandler(InputDevice *device)
 
 bool TouchpadTriggerHandler::pointerAxis(const MotionEvent &event)
 {
+    m_libinputFingers = 2;
     bool isFirstEvent{};
     switch (m_state) {
         case State::Motion:
@@ -141,6 +142,7 @@ bool TouchpadTriggerHandler::pointerButton(const PointerButtonEvent &event)
 
 bool TouchpadTriggerHandler::pointerMotion(const MotionEvent &event)
 {
+    m_libinputFingers = 1;
     switch (m_state) {
         case State::Motion:
         case State::None:
@@ -253,6 +255,7 @@ bool TouchpadTriggerHandler::touchpadGestureLifecyclePhase(const TouchpadGesture
     switch (event.phase()) {
         case TouchpadGestureLifecyclePhase::Begin: {
             g_variableManager->getVariable(BuiltinVariables::Fingers)->set(event.fingers());
+            m_libinputFingers = event.fingers();
 
             // 1- and 2-finger hold gestures have almost no delay and are used to stop kinetic scrolling, there's no reason to block them
             m_gestureBeginBlocked = !(event.triggers() & TriggerType::Press && event.fingers() <= 2);
@@ -299,6 +302,17 @@ bool TouchpadTriggerHandler::touchpadSwipe(const MotionEvent &event)
     return handleMotion(event.sender(), event.delta());
 }
 
+qreal TouchpadTriggerHandler::currentMotionThreshold(const InputDevice *device) const
+{
+    const auto &properties = device->properties();
+    if (m_libinputFingers == 1) {
+        return properties.motionThreshold();
+    } else if (m_libinputFingers == 2) {
+        return properties.touchpadMotionThreshold2();
+    }
+    return properties.touchpadMotionThreshold3();
+}
+
 bool TouchpadTriggerHandler::canTap()
 {
     return std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - m_firstTouchPoint.downTimestamp).count()

src/libinputactions/handlers/TouchpadTriggerHandler.h

@@ -54,6 +54,8 @@ class TouchpadTriggerHandler : public MultiTouchMotionTriggerHandler
     bool touchpadPinch(const TouchpadPinchEvent &event) override;
     bool touchpadSwipe(const MotionEvent &event) override;
 
+    qreal currentMotionThreshold(const InputDevice *device) const override;
+
 private slots:
     void onLibinputTapTimeout();
 
@@ -70,6 +72,10 @@ private slots:
     PointDelta m_pointerAxisDelta;
 
     TouchPoint m_firstTouchPoint;
+    /**
+     * Finger count derived from libinput events, not evdev.
+     */
+    uint8_t m_libinputFingers{};
 
     enum State
     {

src/libinputactions/handlers/TriggerHandler.h

@@ -59,7 +59,7 @@ class TriggerHandler : public QObject
     /**
      * Cancels all active triggers and activates triggers of the specified types eligible for activation.
      */
-    TriggerManagementOperationResult activateTriggers(TriggerTypes types, const TriggerActivationEvent &event);
+    TEST_VIRTUAL TriggerManagementOperationResult activateTriggers(TriggerTypes types, const TriggerActivationEvent &event);
     /**
      * @see activateTriggers(const TriggerTypes &, const TriggerActivationEvent *)
      */
@@ -68,7 +68,7 @@ class TriggerHandler : public QObject
     /**
      * Updates triggers of multiple types in order as added to the handler.
      */
-    TriggerManagementOperationResult updateTriggers(const std::map<TriggerType, const TriggerUpdateEvent *> &events);
+    TEST_VIRTUAL TriggerManagementOperationResult updateTriggers(const std::map<TriggerType, const TriggerUpdateEvent *> &events);
     /**
      * Updates triggers of a single type.
      * @warning Do not use this to update multiple trigger types, as it will prevent conflict resolution from working
@@ -106,11 +106,11 @@ class TriggerHandler : public QObject
     /**
      * @return Whether there are any triggers of the specified types.
      */
-    bool hasActiveTriggers(TriggerTypes types = TriggerType::All);
+    TEST_VIRTUAL bool hasActiveTriggers(TriggerTypes types = TriggerType::All);
     /**
      * @return Whether there are any blocking triggers of the specified types.
      */
-    bool hasActiveBlockingTriggers(TriggerTypes types = TriggerType::All);
+    TEST_VIRTUAL bool hasActiveBlockingTriggers(TriggerTypes types = TriggerType::All);
 
     /**
      * Creates a trigger activation event with information that can be provided by the input device(s).

src/libinputactions/helpers/Math.cpp

@@ -31,6 +31,15 @@ qreal atan2deg(const QPointF &point)
     return radToDeg(atan2(point));
 }
 
+qreal atan2deg360(const QPointF &point)
+{
+    const auto angle = atan2deg(point);
+    if (angle < 0) {
+        return angle + 360;
+    }
+    return angle;
+}
+
 qreal radToDeg(qreal rad)
 {
     return 180.0 / M_PI * rad;

src/libinputactions/helpers/Math.h

@@ -25,9 +25,13 @@ namespace InputActions::Math
 
 qreal atan2(const QPointF &point);
 /**
- * @return [0°, 180°]
+ * @return [-180°, 180°]
  */
 qreal atan2deg(const QPointF &point);
+/**
+ * @return [0°, 360°]
+ */
+qreal atan2deg360(const QPointF &point);
 qreal radToDeg(qreal rad);
 
 qreal hypot(const QPointF &point);