Skip to main content

fc_ui/capabilities/motion/
gestures.rs

1use gpui::*;
2use std::time::{Duration, Instant};
3
4#[derive(Clone, Copy, Debug, PartialEq, Eq)]
5pub enum SwipeDirection {
6    Left,
7    Right,
8    Up,
9    Down,
10}
11
12#[derive(Clone, Debug)]
13pub struct SwipeGesture {
14    pub direction: SwipeDirection,
15    pub velocity: f32,
16    pub distance: f32,
17}
18
19#[derive(Clone, Debug)]
20pub struct LongPressGesture {
21    pub position: Point<Pixels>,
22    pub duration: Duration,
23}
24
25#[derive(Clone, Debug)]
26pub struct TapGesture {
27    pub position: Point<Pixels>,
28    pub count: u32,
29}
30
31#[derive(Clone, Debug)]
32pub struct PanGesture {
33    pub delta: Point<Pixels>,
34    pub velocity: Point<Pixels>,
35    pub total_distance: Point<Pixels>,
36}
37
38#[derive(Clone, Debug)]
39pub enum GestureEvent {
40    Swipe(SwipeGesture),
41    LongPress(LongPressGesture),
42    Tap(TapGesture),
43    PanStart(Point<Pixels>),
44    PanUpdate(PanGesture),
45    PanEnd(PanGesture),
46}
47
48const SWIPE_MIN_DISTANCE: f32 = 50.0;
49const SWIPE_MIN_VELOCITY: f32 = 200.0;
50const LONG_PRESS_DURATION: Duration = Duration::from_millis(500);
51const DOUBLE_TAP_INTERVAL: Duration = Duration::from_millis(300);
52const DOUBLE_TAP_MAX_DISTANCE: f32 = 8.0;
53const PAN_THRESHOLD: f32 = 5.0;
54
55#[derive(Clone, Debug)]
56pub struct GestureDetector {
57    press_start: Option<(Point<Pixels>, Instant)>,
58    last_position: Option<Point<Pixels>>,
59    last_move_time: Option<Instant>,
60    velocity: Point<Pixels>,
61    total_delta: Point<Pixels>,
62    is_panning: bool,
63    tap_count: u32,
64    last_tap_time: Option<Instant>,
65    last_tap_position: Option<Point<Pixels>>,
66    long_press_triggered: bool,
67    long_press_duration: Duration,
68    swipe_min_distance: f32,
69}
70
71impl Default for GestureDetector {
72    fn default() -> Self {
73        Self::new()
74    }
75}
76
77impl GestureDetector {
78    pub fn new() -> Self {
79        Self {
80            press_start: None,
81            last_position: None,
82            last_move_time: None,
83            velocity: point(px(0.0), px(0.0)),
84            total_delta: point(px(0.0), px(0.0)),
85            is_panning: false,
86            tap_count: 0,
87            last_tap_time: None,
88            last_tap_position: None,
89            long_press_triggered: false,
90            long_press_duration: LONG_PRESS_DURATION,
91            swipe_min_distance: SWIPE_MIN_DISTANCE,
92        }
93    }
94
95    pub fn with_long_press_duration(mut self, duration: Duration) -> Self {
96        self.long_press_duration = duration;
97        self
98    }
99
100    pub fn with_swipe_distance(mut self, distance: f32) -> Self {
101        self.swipe_min_distance = distance;
102        self
103    }
104
105    pub fn on_mouse_down(&mut self, position: Point<Pixels>) -> Vec<GestureEvent> {
106        let now = Instant::now();
107        self.press_start = Some((position, now));
108        self.last_position = Some(position);
109        self.last_move_time = Some(now);
110        self.velocity = point(px(0.0), px(0.0));
111        self.total_delta = point(px(0.0), px(0.0));
112        self.is_panning = false;
113        self.long_press_triggered = false;
114        Vec::new()
115    }
116
117    pub fn on_mouse_move(&mut self, position: Point<Pixels>) -> Vec<GestureEvent> {
118        let mut events = Vec::new();
119
120        let Some(last) = self.last_position else {
121            return events;
122        };
123        let Some((start, _)) = self.press_start else {
124            return events;
125        };
126
127        let delta = point(position.x - last.x, position.y - last.y);
128        self.total_delta = point(position.x - start.x, position.y - start.y);
129
130        // Velocity in px/second from the real elapsed time between moves.
131        let now = Instant::now();
132        let dt = self
133            .last_move_time
134            .map(|t| now.duration_since(t).as_secs_f32())
135            .unwrap_or(0.0);
136        self.velocity = if dt > 0.0 {
137            point(delta.x / dt, delta.y / dt)
138        } else {
139            point(px(0.0), px(0.0))
140        };
141        self.last_move_time = Some(now);
142
143        let total_distance =
144            (f32::from(self.total_delta.x).powi(2) + f32::from(self.total_delta.y).powi(2)).sqrt();
145
146        if !self.is_panning && total_distance > PAN_THRESHOLD {
147            self.is_panning = true;
148            events.push(GestureEvent::PanStart(start));
149        }
150
151        if self.is_panning {
152            events.push(GestureEvent::PanUpdate(PanGesture {
153                delta,
154                velocity: self.velocity,
155                total_distance: self.total_delta,
156            }));
157        }
158
159        self.last_position = Some(position);
160        events
161    }
162
163    pub fn on_mouse_up(&mut self, position: Point<Pixels>) -> Vec<GestureEvent> {
164        let mut events = Vec::new();
165
166        let Some((start, start_time)) = self.press_start.take() else {
167            return events;
168        };
169
170        let delta = point(position.x - start.x, position.y - start.y);
171        let distance = (f32::from(delta.x).powi(2) + f32::from(delta.y).powi(2)).sqrt();
172
173        if self.is_panning {
174            events.push(GestureEvent::PanEnd(PanGesture {
175                delta: point(
176                    position.x - self.last_position.unwrap_or(start).x,
177                    position.y - self.last_position.unwrap_or(start).y,
178                ),
179                velocity: self.velocity,
180                total_distance: delta,
181            }));
182
183            let vel_x = f32::from(self.velocity.x).abs();
184            let vel_y = f32::from(self.velocity.y).abs();
185            let max_vel = vel_x.max(vel_y);
186
187            if distance >= self.swipe_min_distance && max_vel >= SWIPE_MIN_VELOCITY {
188                let dx = f32::from(delta.x);
189                let dy = f32::from(delta.y);
190                let direction = if dx.abs() > dy.abs() {
191                    if dx > 0.0 {
192                        SwipeDirection::Right
193                    } else {
194                        SwipeDirection::Left
195                    }
196                } else if dy > 0.0 {
197                    SwipeDirection::Down
198                } else {
199                    SwipeDirection::Up
200                };
201
202                events.push(GestureEvent::Swipe(SwipeGesture {
203                    direction,
204                    velocity: max_vel,
205                    distance,
206                }));
207            }
208        } else {
209            let elapsed = start_time.elapsed();
210
211            if self.long_press_triggered {
212                // The long press already fired via `check_long_press`;
213                // releasing the press must not emit a tap.
214            } else if elapsed >= self.long_press_duration {
215                events.push(GestureEvent::LongPress(LongPressGesture {
216                    position,
217                    duration: elapsed,
218                }));
219            } else {
220                let is_double = match (self.last_tap_time, self.last_tap_position) {
221                    (Some(t), Some(p)) if t.elapsed() < DOUBLE_TAP_INTERVAL => {
222                        let dx = f32::from(position.x - p.x);
223                        let dy = f32::from(position.y - p.y);
224                        (dx * dx + dy * dy).sqrt() <= DOUBLE_TAP_MAX_DISTANCE
225                    }
226                    _ => false,
227                };
228
229                if is_double {
230                    self.tap_count += 1;
231                } else {
232                    self.tap_count = 1;
233                }
234
235                self.last_tap_time = Some(Instant::now());
236                self.last_tap_position = Some(position);
237
238                events.push(GestureEvent::Tap(TapGesture {
239                    position,
240                    count: self.tap_count,
241                }));
242            }
243        }
244
245        self.last_position = None;
246        self.is_panning = false;
247        events
248    }
249
250    pub fn check_long_press(&mut self) -> Option<GestureEvent> {
251        if self.long_press_triggered || self.is_panning {
252            return None;
253        }
254
255        let (position, start_time) = self.press_start?;
256
257        if start_time.elapsed() >= self.long_press_duration {
258            self.long_press_triggered = true;
259            Some(GestureEvent::LongPress(LongPressGesture {
260                position,
261                duration: start_time.elapsed(),
262            }))
263        } else {
264            None
265        }
266    }
267
268    pub fn is_pressed(&self) -> bool {
269        self.press_start.is_some()
270    }
271
272    pub fn is_panning(&self) -> bool {
273        self.is_panning
274    }
275
276    pub fn reset(&mut self) {
277        self.press_start = None;
278        self.last_position = None;
279        self.last_move_time = None;
280        self.is_panning = false;
281        self.long_press_triggered = false;
282    }
283}