fc_ui/capabilities/motion/
gestures.rs1use 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 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 } 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}