feat(input): touch screen gestures on the drawing

One finger already worked as the mouse. Two or more fingers now make a
gesture instead of fighting over the cursor: two drag to pan and pinch to
zoom about the fingers, three drag to orbit; a quick two-finger tap opens
the context menu, a three-finger tap zooms to the extents and a quick
three-finger swipe up shows the isometric view. While a gesture runs the
drawing area's own pointer handling keeps out, and the press the first
finger started is dropped.

Refs #906

Co-Authored-By: Claude Opus 5.5 <[email protected]>

src/input/mod.rs

@@ -1,3 +1,4 @@
 //! Device integrations. Camera ownership and CAD commands stay in the app.
 pub(crate) mod spacemouse;
+pub(crate) mod touch;
 pub(crate) mod trackpad;

src/input/touch.rs

@@ -0,0 +1,242 @@
+//! Touch screen gestures on the drawing. One finger needs nothing here: the
+//! window moves the cursor with it and the drawing area takes its press and
+//! lift as the left button. Two or more fingers become a gesture instead —
+//! two drag to pan and pinch to zoom, three drag to orbit; a quick tap with
+//! two opens the context menu, with three zooms to the extents, and three
+//! swiped up show the isometric view.
+
+use std::collections::BTreeMap;
+use std::time::{Duration, Instant};
+
+use iced::touch;
+use iced::{Point, Vector};
+
+/// What a touch event asks the view to do.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub(crate) enum TouchAction {
+    /// A second finger came down: drop the press the first one started.
+    Cancel,
+    Pan(Vector),
+    /// Scale the view by `factor` (above 1 zooms in) about `centre`, in
+    /// window coordinates.
+    Zoom { factor: f32, centre: Point },
+    Orbit(Vector),
+    Tap(usize),
+    SwipeUp,
+}
+
+struct Gesture {
+    started: Instant,
+    most_fingers: usize,
+    travel: f32,
+    /// How far the fingers moved together, without the jumps of fingers
+    /// landing or lifting.
+    swept: Vector,
+    centre: Point,
+    spread: f32,
+}
+
+/// A tap is quicker and stiller than this.
+const TAP_TIME: Duration = Duration::from_millis(300);
+const TAP_TRAVEL: f32 = 12.0;
+/// A swipe is a quick long sweep; a slower one is just an orbit.
+const SWIPE_TRAVEL: f32 = 80.0;
+const SWIPE_TIME: Duration = Duration::from_millis(500);
+/// The lift ending a gesture reaches the drawing area as a left release
+/// just before or after the gesture ends; this long after, it is let be.
+const SETTLE: Duration = Duration::from_millis(150);
+
+#[derive(Default)]
+pub(crate) struct TouchGestures {
+    fingers: BTreeMap<u64, Point>,
+    gesture: Option<Gesture>,
+    ended: Option<Instant>,
+}
+
+impl TouchGestures {
+    /// A gesture is running (or just ended), so the drawing area's own
+    /// pointer handling should keep out.
+    pub(crate) fn active(&self) -> bool {
+        self.gesture.is_some() || self.ended.is_some_and(|ended| ended.elapsed() < SETTLE)
+    }
+
+    /// Fingers on the screen.
+    pub(crate) fn fingers(&self) -> usize {
+        self.fingers.len()
+    }
+
+    fn centre_and_spread(&self) -> (Point, f32) {
+        let count = self.fingers.len().max(1) as f32;
+        let (x, y) = self
+            .fingers
+            .values()
+            .fold((0.0, 0.0), |(x, y), point| (x + point.x, y + point.y));
+        let centre = Point::new(x / count, y / count);
+        let spread = self
+            .fingers
+            .values()
+            .map(|point| point.distance(centre))
+            .sum::<f32>()
+            / count;
+        (centre, spread)
+    }
+
+    pub(crate) fn event(&mut self, event: touch::Event) -> Vec<TouchAction> {
+        match event {
+            touch::Event::FingerPressed { id, position } => {
+                self.fingers.insert(id.0, position);
+                if self.fingers.len() < 2 {
+                    return Vec::new();
+                }
+                let (centre, spread) = self.centre_and_spread();
+                match &mut self.gesture {
+                    Some(gesture) => {
+                        gesture.most_fingers = gesture.most_fingers.max(self.fingers.len());
+                        gesture.centre = centre;
+                        gesture.spread = spread;
+                        Vec::new()
+                    }
+                    None => {
+                        self.gesture = Some(Gesture {
+                            started: Instant::now(),
+                            most_fingers: self.fingers.len(),
+                            travel: 0.0,
+                            swept: Vector::new(0.0, 0.0),
+                            centre,
+                            spread,
+                        });
+                        vec![TouchAction::Cancel]
+                    }
+                }
+            }
+            touch::Event::FingerMoved { id, position } => {
+                if let Some(finger) = self.fingers.get_mut(&id.0) {
+                    *finger = position;
+                }
+                let count = self.fingers.len();
+                let (centre, spread) = self.centre_and_spread();
+                let Some(gesture) = self.gesture.as_mut() else {
+                    return Vec::new();
+                };
+                let delta = centre - gesture.centre;
+                gesture.travel += (delta.x * delta.x + delta.y * delta.y).sqrt();
+                gesture.swept = gesture.swept + delta;
+                let mut actions = Vec::new();
+                if count == 2 {
+                    actions.push(TouchAction::Pan(delta));
+                    if gesture.spread > 1.0 && spread > 1.0 {
+                        gesture.travel += (spread - gesture.spread).abs();
+                        actions.push(TouchAction::Zoom {
+                            factor: spread / gesture.spread,
+                            centre,
+                        });
+                    }
+                } else if count >= 3 {
+                    actions.push(TouchAction::Orbit(delta));
+                }
+                gesture.centre = centre;
+                gesture.spread = spread;
+                actions
+            }
+            touch::Event::FingerLifted { id, .. } | touch::Event::FingerLost { id, .. } => {
+                self.fingers.remove(&id.0);
+                if !self.fingers.is_empty() {
+                    // The rest carry on from where they are, without a jump.
+                    let (centre, spread) = self.centre_and_spread();
+                    if let Some(gesture) = self.gesture.as_mut() {
+                        gesture.centre = centre;
+                        gesture.spread = spread;
+                    }
+                    return Vec::new();
+                }
+                let Some(gesture) = self.gesture.take() else {
+                    return Vec::new();
+                };
+                self.ended = Some(Instant::now());
+                let swept = gesture.swept;
+                if gesture.started.elapsed() < TAP_TIME && gesture.travel < TAP_TRAVEL {
+                    vec![TouchAction::Tap(gesture.most_fingers)]
+                } else if gesture.most_fingers >= 3
+                    && gesture.started.elapsed() < SWIPE_TIME
+                    && swept.y < -SWIPE_TRAVEL
+                    && swept.y.abs() > 2.0 * swept.x.abs()
+                {
+                    vec![TouchAction::SwipeUp]
+                } else {
+                    Vec::new()
+                }
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn press(id: u64, x: f32, y: f32) -> touch::Event {
+        touch::Event::FingerPressed {
+            id: touch::Finger(id),
+            position: Point::new(x, y),
+        }
+    }
+    fn moved(id: u64, x: f32, y: f32) -> touch::Event {
+        touch::Event::FingerMoved {
+            id: touch::Finger(id),
+            position: Point::new(x, y),
+        }
+    }
+    fn lift(id: u64) -> touch::Event {
+        touch::Event::FingerLifted {
+            id: touch::Finger(id),
+            position: Point::ORIGIN,
+        }
+    }
+
+    #[test]
+    fn two_fingers_pan_pinch_and_tap() {
+        let mut touch = TouchGestures::default();
+        assert!(touch.event(press(1, 100.0, 100.0)).is_empty());
+        assert_eq!(touch.event(press(2, 200.0, 100.0)), vec![TouchAction::Cancel]);
+        assert!(touch.active());
+        // Both fingers slide right: a pan, no zoom.
+        touch.event(moved(1, 110.0, 100.0));
+        let actions = touch.event(moved(2, 210.0, 100.0));
+        assert!(matches!(actions[0], TouchAction::Pan(v) if (v.x - 5.0).abs() < 1e-3));
+        // They spread apart: zoom in.
+        let actions = touch.event(moved(2, 260.0, 100.0));
+        let zooms_in =
+            |a: &TouchAction| matches!(a, TouchAction::Zoom { factor, .. } if *factor > 1.0);
+        assert!(actions.iter().any(zooms_in));
+        touch.event(lift(1));
+        assert!(touch.event(lift(2)).is_empty());
+
+        // A quick still touch with two fingers is a tap.
+        touch.event(press(3, 100.0, 100.0));
+        touch.event(press(4, 150.0, 100.0));
+        touch.event(lift(3));
+        assert_eq!(touch.event(lift(4)), vec![TouchAction::Tap(2)]);
+    }
+
+    #[test]
+    fn three_fingers_orbit_and_swipe_up() {
+        let mut touch = TouchGestures::default();
+        touch.event(press(1, 100.0, 300.0));
+        touch.event(press(2, 150.0, 300.0));
+        touch.event(press(3, 200.0, 300.0));
+        let mut orbited = false;
+        for step in 1..=10 {
+            let y = 300.0 - 15.0 * step as f32;
+            for (id, x) in [(1, 100.0), (2, 150.0), (3, 200.0)] {
+                orbited |= touch
+                    .event(moved(id, x, y))
+                    .iter()
+                    .any(|a| matches!(a, TouchAction::Orbit(_)));
+            }
+        }
+        assert!(orbited);
+        touch.event(lift(1));
+        touch.event(lift(2));
+        assert_eq!(touch.event(lift(3)), vec![TouchAction::SwipeUp]);
+    }
+}