deps: Update smithay

src/shell/layout/tiling/grabs.rs

@@ -3,16 +3,17 @@
 use crate::{shell::layout::Orientation, utils::prelude::*};
 use atomic_float::AtomicF64;
 use smithay::{
-    reexports::wayland_server::DisplayHandle,
-    utils::{Logical, Size},
-    wayland::seat::{
-        AxisFrame, ButtonEvent, MotionEvent, PointerGrab, PointerGrabStartData, PointerInnerHandle,
+    input::pointer::{
+        AxisFrame, ButtonEvent, GrabStartData as PointerGrabStartData, MotionEvent, PointerGrab,
+        PointerInnerHandle,
     },
+    reexports::wayland_server::protocol::wl_surface::WlSurface,
+    utils::{Logical, Point, Size},
 };
 use std::sync::{atomic::Ordering, Arc};
 
 pub struct ResizeForkGrab {
-    pub start_data: PointerGrabStartData,
+    pub start_data: PointerGrabStartData<State>,
     pub orientation: Orientation,
     pub initial_size: Size<i32, Logical>,
     pub initial_ratio: f64,
@@ -22,13 +23,13 @@ pub struct ResizeForkGrab {
 impl PointerGrab<State> for ResizeForkGrab {
     fn motion(
         &mut self,
-        _data: &mut State,
-        _dh: &DisplayHandle,
+        data: &mut State,
         handle: &mut PointerInnerHandle<'_, State>,
+        _focus: Option<(WlSurface, Point<i32, Logical>)>,
         event: &MotionEvent,
     ) {
         // While the grab is active, no client has pointer focus
-        handle.motion(event.location, None, event.serial, event.time);
+        handle.motion(data, None, event);
 
         let delta = event.location - self.start_data.location;
         let delta = match self.orientation {
@@ -43,29 +44,27 @@ impl PointerGrab<State> for ResizeForkGrab {
 
     fn button(
         &mut self,
-        _data: &mut State,
-        _dh: &DisplayHandle,
+        data: &mut State,
         handle: &mut PointerInnerHandle<'_, State>,
         event: &ButtonEvent,
     ) {
-        handle.button(event.button, event.state, event.serial, event.time);
+        handle.button(data, event);
         if handle.current_pressed().is_empty() {
             // No more buttons are pressed, release the grab.
-            handle.unset_grab(event.serial, event.time);
+            handle.unset_grab(data, event.serial, event.time);
         }
     }
 
     fn axis(
         &mut self,
-        _data: &mut State,
-        _dh: &DisplayHandle,
+        data: &mut State,
         handle: &mut PointerInnerHandle<'_, State>,
         details: AxisFrame,
     ) {
-        handle.axis(details)
+        handle.axis(data, details)
     }
 
-    fn start_data(&self) -> &PointerGrabStartData {
+    fn start_data(&self) -> &PointerGrabStartData<State> {
         &self.start_data
     }
 }

src/shell/layout/tiling/mod.rs

@@ -9,14 +9,14 @@ use atomic_float::AtomicF64;
 use id_tree::{InsertBehavior, MoveBehavior, Node, NodeId, NodeIdError, RemoveBehavior, Tree};
 use smithay::{
     desktop::{layer_map_for_output, Kind, Space, Window},
+    input::{
+        pointer::{Focus, GrabStartData as PointerGrabStartData},
+        Seat,
+    },
     reexports::wayland_protocols::xdg::shell::server::xdg_toplevel::{
         ResizeEdge, State as XdgState,
     },
-    utils::{IsAlive, Rectangle},
-    wayland::{
-        seat::{Focus, PointerGrabStartData, Seat},
-        Serial,
-    },
+    utils::{IsAlive, Rectangle, Serial},
 };
 use std::{
     cell::RefCell,
@@ -233,18 +233,26 @@ impl TilingLayout {
     }
 
     pub fn resize_request(
-        &mut self,
-        space: &mut Space,
+        state: &mut State,
         window: &Window,
         seat: &Seat<State>,
         serial: Serial,
-        start_data: PointerGrabStartData,
+        start_data: PointerGrabStartData<State>,
         edges: ResizeEdge,
     ) {
+        // it is so stupid, that we have to do this here. TODO: Refactor grabs
+        let workspace = state
+            .common
+            .shell
+            .space_for_window_mut(window.toplevel().wl_surface())
+            .unwrap();
+        let space = &mut workspace.space;
+        let trees = &mut workspace.tiling_layer.trees;
+
         if let Some(pointer) = seat.get_pointer() {
             if let Some(info) = window.user_data().get::<RefCell<WindowInfo>>() {
                 let output = info.borrow().output;
-                let tree = TilingLayout::active_tree(&mut self.trees, output);
+                let tree = TilingLayout::active_tree(trees, output);
                 let mut node_id = info.borrow().node.clone();
 
                 while let Some((fork, child)) = TilingLayout::find_fork(tree, node_id) {
@@ -261,18 +269,19 @@ impl TilingLayout {
                             | (false, Orientation::Horizontal, ResizeEdge::Top)
                             | (true, Orientation::Vertical, ResizeEdge::Right)
                             | (false, Orientation::Vertical, ResizeEdge::Left) => {
-                                if let Some(output) = space.outputs().nth(output) {
+                                let output = space.outputs().nth(output).cloned();
+                                if let Some(output) = output {
                                     let grab = ResizeForkGrab {
                                         start_data,
                                         orientation: *orientation,
                                         initial_ratio: ratio.load(Ordering::SeqCst),
-                                        initial_size: layer_map_for_output(output)
+                                        initial_size: layer_map_for_output(&output)
                                             .non_exclusive_zone()
                                             .size,
                                         ratio: ratio.clone(),
                                     };
 
-                                    pointer.set_grab(grab, serial, Focus::Clear);
+                                    pointer.set_grab(state, grab, serial, Focus::Clear);
                                 }
                                 return;
                             }