Implement Mod+MMB view offset gesture

3 files changed, 230 insertions, 9 deletions

diff --git a/src/input/mod.rs b/src/input/mod.rs
index 69650a12..8206890c 100644
--- a/src/input/mod.rs
+++ b/src/input/mod.rs
@@ -17,10 +17,10 @@ use smithay::backend::input::{
 use smithay::backend::libinput::LibinputInputBackend;
 use smithay::input::keyboard::{keysyms, FilterResult, Keysym, ModifiersState};
 use smithay::input::pointer::{
-    AxisFrame, ButtonEvent, CursorImageStatus, Focus, GestureHoldBeginEvent, GestureHoldEndEvent,
-    GesturePinchBeginEvent, GesturePinchEndEvent, GesturePinchUpdateEvent, GestureSwipeBeginEvent,
-    GestureSwipeEndEvent, GestureSwipeUpdateEvent, GrabStartData as PointerGrabStartData,
-    MotionEvent, RelativeMotionEvent,
+    AxisFrame, ButtonEvent, CursorIcon, CursorImageStatus, Focus, GestureHoldBeginEvent,
+    GestureHoldEndEvent, GesturePinchBeginEvent, GesturePinchEndEvent, GesturePinchUpdateEvent,
+    GestureSwipeBeginEvent, GestureSwipeEndEvent, GestureSwipeUpdateEvent,
+    GrabStartData as PointerGrabStartData, MotionEvent, RelativeMotionEvent,
 };
 use smithay::input::touch::{DownEvent, MotionEvent as TouchMotionEvent, UpEvent};
 use smithay::utils::{Logical, Point, SERIAL_COUNTER};
@@ -28,6 +28,7 @@ use smithay::wayland::pointer_constraints::{with_pointer_constraint, PointerCons
 use smithay::wayland::tablet_manager::{TabletDescriptor, TabletSeatTrait};
 
 use self::resize_grab::ResizeGrab;
+use self::view_offset_grab::ViewOffsetGrab;
 use crate::niri::State;
 use crate::ui::screenshot_ui::ScreenshotUi;
 use crate::utils::spawning::spawn;
@@ -36,6 +37,7 @@ use crate::utils::{center, get_monotonic_time, ResizeEdge};
 pub mod resize_grab;
 pub mod scroll_tracker;
 pub mod swipe_tracker;
+pub mod view_offset_grab;
 
 pub const DOUBLE_CLICK_TIME: Duration = Duration::from_millis(400);
 
@@ -1144,7 +1146,7 @@ impl State {
                                 };
                                 let grab = ResizeGrab::new(start_data, window.clone());
                                 pointer.set_grab(self, grab, serial, Focus::Clear);
-                                self.niri.interactive_resize_ongoing = true;
+                                self.niri.pointer_grab_ongoing = true;
                                 self.niri.cursor_manager.set_cursor_image(
                                     CursorImageStatus::Named(edges.cursor_icon()),
                                 );
@@ -1163,6 +1165,32 @@ impl State {
                 // FIXME: granular.
                 self.niri.queue_redraw_all();
             }
+
+            if event.button() == Some(MouseButton::Middle) && !pointer.is_grabbed() {
+                let mods = self.niri.seat.get_keyboard().unwrap().modifier_state();
+                let mod_down = match self.backend.mod_key() {
+                    CompositorMod::Super => mods.logo,
+                    CompositorMod::Alt => mods.alt,
+                };
+                if mod_down {
+                    if let Some(output) = self.niri.output_under_cursor() {
+                        self.niri.layout.view_offset_gesture_begin(&output, false);
+
+                        let location = pointer.current_location();
+                        let start_data = PointerGrabStartData {
+                            focus: None,
+                            button: event.button_code(),
+                            location,
+                        };
+                        let grab = ViewOffsetGrab::new(start_data);
+                        pointer.set_grab(self, grab, serial, Focus::Clear);
+                        self.niri.pointer_grab_ongoing = true;
+                        self.niri
+                            .cursor_manager
+                            .set_cursor_image(CursorImageStatus::Named(CursorIcon::AllScroll));
+                    }
+                }
+            }
         };
 
         self.update_pointer_focus();
@@ -1593,7 +1621,7 @@ impl State {
 
                 if let Some(output) = self.niri.output_under_cursor() {
                     if cx.abs() > cy.abs() {
-                        self.niri.layout.view_offset_gesture_begin(&output);
+                        self.niri.layout.view_offset_gesture_begin(&output, true);
                     } else {
                         self.niri.layout.workspace_switch_gesture_begin(&output);
                     }
@@ -1618,7 +1646,7 @@ impl State {
         let res = self
             .niri
             .layout
-            .view_offset_gesture_update(delta_x, timestamp);
+            .view_offset_gesture_update(delta_x, timestamp, true);
         if let Some(output) = res {
             if let Some(output) = output {
                 self.niri.queue_redraw(&output);
@@ -1659,7 +1687,10 @@ impl State {
             handled = true;
         }
 
-        let res = self.niri.layout.view_offset_gesture_end(event.cancelled());
+        let res = self
+            .niri
+            .layout
+            .view_offset_gesture_end(event.cancelled(), Some(true));
         if let Some(output) = res {
             self.niri.queue_redraw(&output);
             handled = true;
diff --git a/src/input/resize_grab.rs b/src/input/resize_grab.rs
index 8c761558..38483ca6 100644
--- a/src/input/resize_grab.rs
+++ b/src/input/resize_grab.rs
@@ -22,7 +22,7 @@ impl ResizeGrab {
 
     fn on_ungrab(&mut self, state: &mut State) {
         state.niri.layout.interactive_resize_end(&self.window);
-        state.niri.interactive_resize_ongoing = false;
+        state.niri.pointer_grab_ongoing = false;
         state
             .niri
             .cursor_manager
diff --git a/src/input/view_offset_grab.rs b/src/input/view_offset_grab.rs
new file mode 100644
index 00000000..4e2d2785
--- /dev/null
+++ b/src/input/view_offset_grab.rs
@@ -0,0 +1,190 @@
+use std::time::Duration;
+
+use smithay::input::pointer::{
+    AxisFrame, ButtonEvent, CursorImageStatus, GestureHoldBeginEvent, GestureHoldEndEvent,
+    GesturePinchBeginEvent, GesturePinchEndEvent, GesturePinchUpdateEvent, GestureSwipeBeginEvent,
+    GestureSwipeEndEvent, GestureSwipeUpdateEvent, GrabStartData as PointerGrabStartData,
+    MotionEvent, PointerGrab, PointerInnerHandle, RelativeMotionEvent,
+};
+use smithay::input::SeatHandler;
+use smithay::utils::{Logical, Point};
+
+use crate::niri::State;
+
+pub struct ViewOffsetGrab {
+    start_data: PointerGrabStartData<State>,
+    last_location: Point<f64, Logical>,
+}
+
+impl ViewOffsetGrab {
+    pub fn new(start_data: PointerGrabStartData<State>) -> Self {
+        Self {
+            last_location: start_data.location,
+            start_data,
+        }
+    }
+
+    fn on_ungrab(&mut self, state: &mut State) {
+        let res = state
+            .niri
+            .layout
+            .view_offset_gesture_end(false, Some(false));
+        if let Some(output) = res {
+            state.niri.queue_redraw(&output);
+        }
+
+        state.niri.pointer_grab_ongoing = false;
+        state
+            .niri
+            .cursor_manager
+            .set_cursor_image(CursorImageStatus::default_named());
+    }
+}
+
+impl PointerGrab<State> for ViewOffsetGrab {
+    fn motion(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        _focus: Option<(<State as SeatHandler>::PointerFocus, Point<i32, Logical>)>,
+        event: &MotionEvent,
+    ) {
+        // While the grab is active, no client has pointer focus.
+        handle.motion(data, None, event);
+
+        let timestamp = Duration::from_millis(u64::from(event.time));
+        let delta = event.location - self.last_location;
+        self.last_location = event.location;
+
+        let res = data
+            .niri
+            .layout
+            .view_offset_gesture_update(-delta.x, timestamp, false);
+        if let Some(output) = res {
+            if let Some(output) = output {
+                data.niri.queue_redraw(&output);
+            }
+        } else {
+            // The resize is no longer ongoing.
+            handle.unset_grab(self, data, event.serial, event.time, true);
+        }
+    }
+
+    fn relative_motion(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        _focus: Option<(<State as SeatHandler>::PointerFocus, Point<i32, Logical>)>,
+        event: &RelativeMotionEvent,
+    ) {
+        // While the grab is active, no client has pointer focus.
+        handle.relative_motion(data, None, event);
+    }
+
+    fn button(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &ButtonEvent,
+    ) {
+        handle.button(data, event);
+
+        if handle.current_pressed().is_empty() {
+            // No more buttons are pressed, release the grab.
+            handle.unset_grab(self, data, event.serial, event.time, true);
+        }
+    }
+
+    fn axis(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        details: AxisFrame,
+    ) {
+        handle.axis(data, details);
+    }
+
+    fn frame(&mut self, data: &mut State, handle: &mut PointerInnerHandle<'_, State>) {
+        handle.frame(data);
+    }
+
+    fn gesture_swipe_begin(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GestureSwipeBeginEvent,
+    ) {
+        handle.gesture_swipe_begin(data, event);
+    }
+
+    fn gesture_swipe_update(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GestureSwipeUpdateEvent,
+    ) {
+        handle.gesture_swipe_update(data, event);
+    }
+
+    fn gesture_swipe_end(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GestureSwipeEndEvent,
+    ) {
+        handle.gesture_swipe_end(data, event);
+    }
+
+    fn gesture_pinch_begin(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GesturePinchBeginEvent,
+    ) {
+        handle.gesture_pinch_begin(data, event);
+    }
+
+    fn gesture_pinch_update(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GesturePinchUpdateEvent,
+    ) {
+        handle.gesture_pinch_update(data, event);
+    }
+
+    fn gesture_pinch_end(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GesturePinchEndEvent,
+    ) {
+        handle.gesture_pinch_end(data, event);
+    }
+
+    fn gesture_hold_begin(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GestureHoldBeginEvent,
+    ) {
+        handle.gesture_hold_begin(data, event);
+    }
+
+    fn gesture_hold_end(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GestureHoldEndEvent,
+    ) {
+        handle.gesture_hold_end(data, event);
+    }
+
+    fn start_data(&self) -> &PointerGrabStartData<State> {
+        &self.start_data
+    }
+
+    fn unset(&mut self, data: &mut State) {
+        self.on_ungrab(data);
+    }
+}