Add tap-and-hold as the touch equivalent of right-click cancel

Touchscreens have no secondary button, so there was no way to cancel
a pending/completed connection or room selection on touch -- only
2-finger pinch/pan was handled in touchEvent; single-finger touch fell
straight through to Qt's synthesized mouse events with no equivalent
of right-click. Track a single-finger touch's start position and time;
if held roughly in place (within 15px) for 500ms without lifting,
fire the same cancel path as right-click. A normal tap still flows
through unchanged since the synthesized mouse press/release isn't
touched.

Factored the cancel logic (previously duplicated for connections) into
a shared cancelPendingSelection(), and used it to fix the same
plain-right-click-never-reaches-Cancel bug for SELECT_ROOMS that was
already fixed for the connection modes -- its "Cancel" block in the
mode switch was equally unreachable via a plain right-click.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AHGhPpZVqQD9o39ryopvXu

Author: nschimme

src/display/MapCanvasData.h

@@ -17,6 +17,7 @@
 #include "prespammedpath.h"
 
 #include <cassert>
+#include <chrono>
 #include <map>
 #include <memory>
 #include <optional>
@@ -242,6 +243,15 @@ struct NODISCARD PinchState
     float lastFactor = 1.f;
 };
 
+// Tracks a single-finger touch to detect tap-and-hold, the touch equivalent of a
+// right-click, since touchscreens have no secondary button to cancel a selection with.
+struct NODISCARD TouchHoldState
+{
+    glm::vec2 startPos;
+    std::chrono::steady_clock::time_point startTime;
+    bool fired = false;
+};
+
 struct NODISCARD MagnificationState
 {
     float lastValue = 1.f;
@@ -300,6 +310,7 @@ struct NODISCARD MapCanvasInputState
     // and each other, so they are managed independently.
     std::optional<PinchState> m_pinchState;
     std::optional<MagnificationState> m_magnificationState;
+    std::optional<TouchHoldState> m_touchHoldState;
 
     SharedRoomSelection m_roomSelection;
 

src/display/mapcanvas.cpp

@@ -25,6 +25,7 @@
 #include "connectionselection.h"
 
 #include <array>
+#include <chrono>
 #include <cmath>
 #include <cstddef>
 #include <cstdint>
@@ -48,6 +49,9 @@
 namespace {
 constexpr float GESTURE_EPSILON = 1e-6f;
 constexpr float PINCH_DISTANCE_THRESHOLD = 1e-3f;
+// Touch equivalent of a right-click: a single finger held roughly in place this long.
+constexpr auto TAP_HOLD_DURATION = std::chrono::milliseconds(500);
+constexpr float TAP_HOLD_MAX_MOVEMENT_PIXELS = 15.f;
 } // namespace
 
 using NonOwningPointer = MapCanvas *;
@@ -158,6 +162,29 @@ void MapCanvas::slot_setCanvasMouseMode(const CanvasMouseModeEnum mode)
     selectionChanged();
 }
 
+void MapCanvas::cancelPendingSelection()
+{
+    switch (m_canvasMouseMode) {
+    case CanvasMouseModeEnum::CREATE_CONNECTIONS:
+    case CanvasMouseModeEnum::CREATE_ONEWAY_CONNECTIONS:
+    case CanvasMouseModeEnum::SELECT_CONNECTIONS:
+        endInteraction();
+        slot_clearConnectionSelection();
+        break;
+    case CanvasMouseModeEnum::SELECT_ROOMS:
+        endInteraction();
+        slot_clearRoomSelection();
+        break;
+    case CanvasMouseModeEnum::NONE:
+    case CanvasMouseModeEnum::MOVE:
+    case CanvasMouseModeEnum::RAYPICK_ROOMS:
+    case CanvasMouseModeEnum::CREATE_ROOMS:
+    case CanvasMouseModeEnum::SELECT_INFOMARKS:
+    case CanvasMouseModeEnum::CREATE_INFOMARKS:
+        break;
+    }
+}
+
 void MapCanvas::slot_setRoomSelection(const SigRoomSelection &selection)
 {
     if (!selection.isValid()) {
@@ -333,12 +360,38 @@ void MapCanvas::touchEvent(QTouchEvent *const event)
             endPanning();
         }
         event->accept();
-    } else {
-        if (points.size() > 2) {
-            // Explicitly ignore more than 2 touch points for pinch zoom.
-            qDebug() << "MapCanvas::touchEvent: ignoring" << points.size() << "touch points";
+    } else if (points.size() == 1) {
+        // Tap-and-hold: the touch equivalent of a right-click, since a touchscreen has
+        // no secondary button to cancel a pending/completed selection with. The tap
+        // itself still falls through to Qt's synthesized mouse press/release below, so
+        // a normal tap keeps working as a first/second click.
+        const auto &p = points[0];
+        const glm::vec2 pos{p.position().x(), p.position().y()};
+
+        if (event->type() == QEvent::TouchBegin || p.state() == QEventPoint::Pressed) {
+            m_touchHoldState = TouchHoldState{pos, std::chrono::steady_clock::now(), false};
+        } else if (m_touchHoldState) {
+            auto &hold = *m_touchHoldState;
+            if (glm::distance(pos, hold.startPos) > TAP_HOLD_MAX_MOVEMENT_PIXELS) {
+                m_touchHoldState.reset();
+            } else if (!hold.fired
+                      && std::chrono::steady_clock::now() - hold.startTime >= TAP_HOLD_DURATION) {
+                hold.fired = true;
+                cancelPendingSelection();
+            }
+        }
+
+        if (event->type() == QEvent::TouchEnd || p.state() == QEventPoint::Released) {
+            m_touchHoldState.reset();
         }
 
+        endPinch();
+        QOpenGLWindow::touchEvent(event);
+    } else {
+        // Explicitly ignore more than 2 touch points for pinch zoom.
+        qDebug() << "MapCanvas::touchEvent: ignoring" << points.size() << "touch points";
+
+        m_touchHoldState.reset();
         endPinch();
         QOpenGLWindow::touchEvent(event);
     }
@@ -546,14 +599,11 @@ void MapCanvas::mousePressEvent(QMouseEvent *const event)
             slot_setInfomarkSelection(getInfomarkSelection(getSel1()));
 
             selectionChanged();
-        } else if (m_canvasMouseMode == CanvasMouseModeEnum::CREATE_CONNECTIONS
-                  || m_canvasMouseMode == CanvasMouseModeEnum::CREATE_ONEWAY_CONNECTIONS
-                  || m_canvasMouseMode == CanvasMouseModeEnum::SELECT_CONNECTIONS) {
+        } else {
             // A plain right-click never reaches the mode switch below (this branch
-            // returns first), so cancelling a pending/completed connection selection
-            // has to happen here.
-            endInteraction();
-            slot_clearConnectionSelection();
+            // returns first), so cancelling a pending/completed selection for modes
+            // that support it has to happen here.
+            cancelPendingSelection();
         }
         emit sig_customContextMenuRequested(event->position().toPoint());
         m_mouseRightPressed = false;

src/display/mapcanvas.h

@@ -226,6 +226,10 @@ class NODISCARD_QOBJECT MapCanvas final : public QOpenGLWindow,
 
     NODISCARD std::shared_ptr<InfomarkSelection> getInfomarkSelection(const MouseSel &sel);
 
+    // Cancels whatever pending/completed selection the current mode supports cancelling
+    // (connection or room selection). Shared by right-click and touch tap-and-hold.
+    void cancelPendingSelection();
+
 public:
     void setMvp(const glm::mat4 &viewProj);
     void setViewportAndMvp(int width, int height);