Implement vertical middle mouse gesture

2 files changed, 67 insertions, 20 deletions

diff --git a/src/layout/mod.rs b/src/layout/mod.rs
index b8b13560..b74ef729 100644
--- a/src/layout/mod.rs
+++ b/src/layout/mod.rs
@@ -2002,7 +2002,7 @@ impl<W: LayoutElement> Layout<W> {
         }
     }
 
-    pub fn workspace_switch_gesture_begin(&mut self, output: &Output) {
+    pub fn workspace_switch_gesture_begin(&mut self, output: &Output, is_touchpad: bool) {
         let monitors = match &mut self.monitor_set {
             MonitorSet::Normal { monitors, .. } => monitors,
             MonitorSet::NoOutputs { .. } => unreachable!(),
@@ -2011,11 +2011,11 @@ impl<W: LayoutElement> Layout<W> {
         for monitor in monitors {
             // Cancel the gesture on other outputs.
             if &monitor.output != output {
-                monitor.workspace_switch_gesture_end(true);
+                monitor.workspace_switch_gesture_end(true, None);
                 continue;
             }
 
-            monitor.workspace_switch_gesture_begin();
+            monitor.workspace_switch_gesture_begin(is_touchpad);
         }
     }
 
@@ -2023,6 +2023,7 @@ impl<W: LayoutElement> Layout<W> {
         &mut self,
         delta_y: f64,
         timestamp: Duration,
+        is_touchpad: bool,
     ) -> Option<Option<Output>> {
         let monitors = match &mut self.monitor_set {
             MonitorSet::Normal { monitors, .. } => monitors,
@@ -2030,7 +2031,9 @@ impl<W: LayoutElement> Layout<W> {
         };
 
         for monitor in monitors {
-            if let Some(refresh) = monitor.workspace_switch_gesture_update(delta_y, timestamp) {
+            if let Some(refresh) =
+                monitor.workspace_switch_gesture_update(delta_y, timestamp, is_touchpad)
+            {
                 if refresh {
                     return Some(Some(monitor.output.clone()));
                 } else {
@@ -2042,14 +2045,18 @@ impl<W: LayoutElement> Layout<W> {
         None
     }
 
-    pub fn workspace_switch_gesture_end(&mut self, cancelled: bool) -> Option<Output> {
+    pub fn workspace_switch_gesture_end(
+        &mut self,
+        cancelled: bool,
+        is_touchpad: Option<bool>,
+    ) -> Option<Output> {
         let monitors = match &mut self.monitor_set {
             MonitorSet::Normal { monitors, .. } => monitors,
             MonitorSet::NoOutputs { .. } => return None,
         };
 
         for monitor in monitors {
-            if monitor.workspace_switch_gesture_end(cancelled) {
+            if monitor.workspace_switch_gesture_end(cancelled, is_touchpad) {
                 return Some(monitor.output.clone());
             }
         }
@@ -2750,14 +2757,17 @@ mod tests {
         WorkspaceSwitchGestureBegin {
             #[proptest(strategy = "1..=5usize")]
             output_idx: usize,
+            is_touchpad: bool,
         },
         WorkspaceSwitchGestureUpdate {
             #[proptest(strategy = "-400f64..400f64")]
             delta: f64,
             timestamp: Duration,
+            is_touchpad: bool,
         },
         WorkspaceSwitchGestureEnd {
             cancelled: bool,
+            is_touchpad: Option<bool>,
         },
         InteractiveResizeBegin {
             #[proptest(strategy = "1..=5usize")]
@@ -3135,19 +3145,29 @@ mod tests {
                     // We don't handle cancels in this gesture.
                     layout.view_offset_gesture_end(false, is_touchpad);
                 }
-                Op::WorkspaceSwitchGestureBegin { output_idx: id } => {
+                Op::WorkspaceSwitchGestureBegin {
+                    output_idx: id,
+                    is_touchpad,
+                } => {
                     let name = format!("output{id}");
                     let Some(output) = layout.outputs().find(|o| o.name() == name).cloned() else {
                         return;
                     };
 
-                    layout.workspace_switch_gesture_begin(&output);
+                    layout.workspace_switch_gesture_begin(&output, is_touchpad);
                 }
-                Op::WorkspaceSwitchGestureUpdate { delta, timestamp } => {
-                    layout.workspace_switch_gesture_update(delta, timestamp);
+                Op::WorkspaceSwitchGestureUpdate {
+                    delta,
+                    timestamp,
+                    is_touchpad,
+                } => {
+                    layout.workspace_switch_gesture_update(delta, timestamp, is_touchpad);
                 }
-                Op::WorkspaceSwitchGestureEnd { cancelled } => {
-                    layout.workspace_switch_gesture_end(cancelled);
+                Op::WorkspaceSwitchGestureEnd {
+                    cancelled,
+                    is_touchpad,
+                } => {
+                    layout.workspace_switch_gesture_end(cancelled, is_touchpad);
                 }
                 Op::InteractiveResizeBegin { window, edges } => {
                     layout.interactive_resize_begin(window, edges);
diff --git a/src/layout/monitor.rs b/src/layout/monitor.rs
index 911e0480..423b2ef9 100644
--- a/src/layout/monitor.rs
+++ b/src/layout/monitor.rs
@@ -54,10 +54,12 @@ pub enum WorkspaceSwitch {
 #[derive(Debug)]
 pub struct WorkspaceSwitchGesture {
     /// Index of the workspace where the gesture was started.
-    pub center_idx: usize,
+    center_idx: usize,
     /// Current, fractional workspace index.
     pub current_idx: f64,
-    pub tracker: SwipeTracker,
+    tracker: SwipeTracker,
+    /// Whether the gesture is controlled by the touchpad.
+    is_touchpad: bool,
 }
 
 pub type MonitorRenderElement<R> =
@@ -973,7 +975,7 @@ impl<W: LayoutElement> Monitor<W> {
         }
     }
 
-    pub fn workspace_switch_gesture_begin(&mut self) {
+    pub fn workspace_switch_gesture_begin(&mut self, is_touchpad: bool) {
         let center_idx = self.active_workspace_idx;
         let current_idx = self
             .workspace_switch
@@ -985,6 +987,7 @@ impl<W: LayoutElement> Monitor<W> {
             center_idx,
             current_idx,
             tracker: SwipeTracker::new(),
+            is_touchpad,
         };
         self.workspace_switch = Some(WorkspaceSwitch::Gesture(gesture));
     }
@@ -993,14 +996,24 @@ impl<W: LayoutElement> Monitor<W> {
         &mut self,
         delta_y: f64,
         timestamp: Duration,
+        is_touchpad: bool,
     ) -> Option<bool> {
         let Some(WorkspaceSwitch::Gesture(gesture)) = &mut self.workspace_switch else {
             return None;
         };
 
+        if gesture.is_touchpad != is_touchpad {
+            return None;
+        }
+
         gesture.tracker.push(delta_y, timestamp);
 
-        let pos = gesture.tracker.pos() / WORKSPACE_GESTURE_MOVEMENT;
+        let total_height = if gesture.is_touchpad {
+            WORKSPACE_GESTURE_MOVEMENT
+        } else {
+            self.workspaces[0].view_size().h
+        };
+        let pos = gesture.tracker.pos() / total_height;
 
         let min = gesture.center_idx.saturating_sub(1) as f64;
         let max = (gesture.center_idx + 1).min(self.workspaces.len() - 1) as f64;
@@ -1015,20 +1028,34 @@ impl<W: LayoutElement> Monitor<W> {
         Some(true)
     }
 
-    pub fn workspace_switch_gesture_end(&mut self, cancelled: bool) -> bool {
+    pub fn workspace_switch_gesture_end(
+        &mut self,
+        cancelled: bool,
+        is_touchpad: Option<bool>,
+    ) -> bool {
         let Some(WorkspaceSwitch::Gesture(gesture)) = &mut self.workspace_switch else {
             return false;
         };
 
+        if is_touchpad.map_or(false, |x| gesture.is_touchpad != x) {
+            return false;
+        }
+
         if cancelled {
             self.workspace_switch = None;
             self.clean_up_workspaces();
             return true;
         }
 
-        let mut velocity = gesture.tracker.velocity() / WORKSPACE_GESTURE_MOVEMENT;
-        let current_pos = gesture.tracker.pos() / WORKSPACE_GESTURE_MOVEMENT;
-        let pos = gesture.tracker.projected_end_pos() / WORKSPACE_GESTURE_MOVEMENT;
+        let total_height = if gesture.is_touchpad {
+            WORKSPACE_GESTURE_MOVEMENT
+        } else {
+            self.workspaces[0].view_size().h
+        };
+
+        let mut velocity = gesture.tracker.velocity() / total_height;
+        let current_pos = gesture.tracker.pos() / total_height;
+        let pos = gesture.tracker.projected_end_pos() / total_height;
 
         let min = gesture.center_idx.saturating_sub(1) as f64;
         let max = (gesture.center_idx + 1).min(self.workspaces.len() - 1) as f64;