Update Smithay, adjusting for API changes

The main changes are those related to pointer gestures. Which are a bit
verbose but not too difficult.

Cargo.lock

@@ -1063,17 +1063,6 @@ version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
 
-[[package]]
-name = "errno"
-version = "0.2.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f639046355ee4f37944e44f60642c6f3a7efa3cf6b78c78a0d989a8ce6c396a1"
-dependencies = [
- "errno-dragonfly",
- "libc",
- "winapi",
-]
-
 [[package]]
 name = "errno"
 version = "0.3.2"
@@ -2230,13 +2219,13 @@ checksum = "f7012b1bbb0719e1097c47611d3898568c546d597c2e74d66f6087edd5233ff4"
 
 [[package]]
 name = "libseat"
-version = "0.1.7"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "845e5c255462c9bc7c71c17b996766b76e3c66f2ddd5846bfbc83f18382aa648"
+checksum = "54a0adf8d8607a73a5b74cbe4132f57cb349e4bf860103cd089461bbcbc9907e"
 dependencies = [
- "errno 0.2.8",
+ "errno",
  "libseat-sys",
- "slog",
+ "log",
 ]
 
 [[package]]
@@ -3579,7 +3568,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4d69718bf81c6127a49dc64e44a742e8bb9213c0ff8869a22c308f84c1d4ab06"
 dependencies = [
  "bitflags 1.3.2",
- "errno 0.3.2",
+ "errno",
  "io-lifetimes",
  "libc",
  "linux-raw-sys 0.3.8",
@@ -3593,7 +3582,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0a962918ea88d644592894bc6dc55acc6c0956488adcebbfb6e273506b7fd6e5"
 dependencies = [
  "bitflags 2.3.3",
- "errno 0.3.2",
+ "errno",
  "libc",
  "linux-raw-sys 0.4.3",
  "windows-sys 0.48.0",
@@ -3754,12 +3743,6 @@ dependencies = [
  "autocfg",
 ]
 
-[[package]]
-name = "slog"
-version = "2.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8347046d4ebd943127157b94d63abb990fcf729dc4e9978927fdf4ac3c998d06"
-
 [[package]]
 name = "slotmap"
 version = "1.0.6"
@@ -3778,7 +3761,7 @@ checksum = "62bb4feee49fdd9f707ef802e22365a35de4b7b299de4763d44bfea899442ff9"
 [[package]]
 name = "smithay"
 version = "0.3.0"
-source = "git+https://github.com/smithay//smithay?rev=02ccc8ca17#02ccc8ca17fbc655d2247124fe628d276cb5179a"
+source = "git+https://github.com/smithay//smithay?rev=36a0ec69b1#36a0ec69b1a2331b1a2d0e046b026cb85d7d132c"
 dependencies = [
  "appendlist",
  "ash",

Cargo.toml

@@ -87,4 +87,4 @@ debug = true
 lto = "fat"
 
 [patch."https://github.com/Smithay/smithay.git"]
-smithay = { git = "https://github.com/smithay//smithay", rev = "02ccc8ca17" }
+smithay = { git = "https://github.com/smithay//smithay", rev = "36a0ec69b1" }

src/backend/kms/mod.rs

@@ -507,7 +507,11 @@ impl State {
                                                 surface
                                                     .output
                                                     .current_mode()
-                                                    .map(|mode| mode.refresh as u32)
+                                                    .map(|mode| {
+                                                        Duration::from_secs_f64(
+                                                            1_000.0 / mode.refresh as f64,
+                                                        )
+                                                    })
                                                     .unwrap_or_default(),
                                                 seq as u64,
                                                 flags,
@@ -1002,19 +1006,20 @@ fn get_surface_dmabuf_feedback(
         .collect::<HashSet<_>>();
 
     let surface = compositor.surface();
-    let planes = surface.planes().unwrap();
+    let planes = surface.planes();
     // We limit the scan-out trache to formats we can also render from
     // so that there is always a fallback render path available in case
     // the supplied buffer can not be scanned out directly
-    let planes_formats = surface
+    let planes_formats = planes
-        .supported_formats(planes.primary.handle)
+        .primary
-        .unwrap()
+        .formats
-        .into_iter()
+        .iter()
+        .cloned()
         .chain(
             planes
                 .overlay
                 .iter()
-                .flat_map(|p| surface.supported_formats(p.handle).unwrap()),
+                .flat_map(|p| p.formats.iter().cloned()),
         )
         .collect::<HashSet<_>>()
         .intersection(&combined_formats)
@@ -1330,9 +1335,7 @@ impl KmsState {
                         let driver = drm
                             .get_driver()
                             .with_context(|| "Failed to query drm driver")?;
-                        let mut planes = drm_surface
+                        let mut planes = drm_surface.planes().clone();
-                            .planes()
-                            .with_context(|| "Failed to query drm planes")?;
                         // QUIRK: Using an overlay plane on a nvidia card breaks the display controller (wtf...)
                         if driver
                             .name()

src/backend/winit.rs

@@ -30,7 +30,7 @@ use smithay::{
     utils::Transform,
     wayland::dmabuf::DmabufFeedbackBuilder,
 };
-use std::cell::RefCell;
+use std::{cell::RefCell, time::Duration};
 use tracing::{error, info, warn};
 
 #[cfg(feature = "debug")]
@@ -94,7 +94,7 @@ impl WinitState {
                         state.clock.now(),
                         self.output
                             .current_mode()
-                            .map(|mode| mode.refresh as u32)
+                            .map(|mode| Duration::from_secs_f64(1_000.0 / mode.refresh as f64))
                             .unwrap_or_default(),
                         0,
                         wp_presentation_feedback::Kind::Vsync,

src/backend/x11.rs

@@ -39,7 +39,7 @@ use smithay::{
     utils::{DeviceFd, Transform},
     wayland::dmabuf::DmabufFeedbackBuilder,
 };
-use std::{cell::RefCell, os::unix::io::OwnedFd};
+use std::{cell::RefCell, os::unix::io::OwnedFd, time::Duration};
 use tracing::{debug, error, info, warn};
 
 #[cfg(feature = "debug")]
@@ -260,7 +260,7 @@ impl Surface {
                         state.clock.now(),
                         self.output
                             .current_mode()
-                            .map(|mode| mode.refresh as u32)
+                            .map(|mode| Duration::from_secs_f64(1_000.0 / mode.refresh as f64))
                             .unwrap_or_default(),
                         0,
                         wp_presentation_feedback::Kind::Vsync,

src/shell/element/mod.rs

@@ -25,7 +25,12 @@ use smithay::{
     desktop::{space::SpaceElement, PopupManager, WindowSurfaceType},
     input::{
         keyboard::{KeyboardTarget, KeysymHandle, ModifiersState},
-        pointer::{AxisFrame, ButtonEvent, MotionEvent, PointerTarget, RelativeMotionEvent},
+        pointer::{
+            AxisFrame, ButtonEvent, GestureHoldBeginEvent, GestureHoldEndEvent,
+            GesturePinchBeginEvent, GesturePinchEndEvent, GesturePinchUpdateEvent,
+            GestureSwipeBeginEvent, GestureSwipeEndEvent, GestureSwipeUpdateEvent, MotionEvent,
+            PointerTarget, RelativeMotionEvent,
+        },
         Seat,
     },
     output::Output,
@@ -909,6 +914,127 @@ impl PointerTarget<State> for CosmicMapped {
             _ => {}
         }
     }
+    fn gesture_swipe_begin(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        event: &GestureSwipeBeginEvent,
+    ) {
+        match &self.element {
+            CosmicMappedInternal::Stack(s) => {
+                PointerTarget::gesture_swipe_begin(s, seat, data, event)
+            }
+            CosmicMappedInternal::Window(w) => {
+                PointerTarget::gesture_swipe_begin(w, seat, data, event)
+            }
+            _ => {}
+        }
+    }
+    fn gesture_swipe_update(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        event: &GestureSwipeUpdateEvent,
+    ) {
+        match &self.element {
+            CosmicMappedInternal::Stack(s) => {
+                PointerTarget::gesture_swipe_update(s, seat, data, event)
+            }
+            CosmicMappedInternal::Window(w) => {
+                PointerTarget::gesture_swipe_update(w, seat, data, event)
+            }
+            _ => {}
+        }
+    }
+    fn gesture_swipe_end(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        event: &GestureSwipeEndEvent,
+    ) {
+        match &self.element {
+            CosmicMappedInternal::Stack(s) => {
+                PointerTarget::gesture_swipe_end(s, seat, data, event)
+            }
+            CosmicMappedInternal::Window(w) => {
+                PointerTarget::gesture_swipe_end(w, seat, data, event)
+            }
+            _ => {}
+        }
+    }
+    fn gesture_pinch_begin(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        event: &GesturePinchBeginEvent,
+    ) {
+        match &self.element {
+            CosmicMappedInternal::Stack(s) => {
+                PointerTarget::gesture_pinch_begin(s, seat, data, event)
+            }
+            CosmicMappedInternal::Window(w) => {
+                PointerTarget::gesture_pinch_begin(w, seat, data, event)
+            }
+            _ => {}
+        }
+    }
+    fn gesture_pinch_update(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        event: &GesturePinchUpdateEvent,
+    ) {
+        match &self.element {
+            CosmicMappedInternal::Stack(s) => {
+                PointerTarget::gesture_pinch_update(s, seat, data, event)
+            }
+            CosmicMappedInternal::Window(w) => {
+                PointerTarget::gesture_pinch_update(w, seat, data, event)
+            }
+            _ => {}
+        }
+    }
+    fn gesture_pinch_end(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        event: &GesturePinchEndEvent,
+    ) {
+        match &self.element {
+            CosmicMappedInternal::Stack(s) => {
+                PointerTarget::gesture_pinch_end(s, seat, data, event)
+            }
+            CosmicMappedInternal::Window(w) => {
+                PointerTarget::gesture_pinch_end(w, seat, data, event)
+            }
+            _ => {}
+        }
+    }
+    fn gesture_hold_begin(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        event: &GestureHoldBeginEvent,
+    ) {
+        match &self.element {
+            CosmicMappedInternal::Stack(s) => {
+                PointerTarget::gesture_hold_begin(s, seat, data, event)
+            }
+            CosmicMappedInternal::Window(w) => {
+                PointerTarget::gesture_hold_begin(w, seat, data, event)
+            }
+            _ => {}
+        }
+    }
+    fn gesture_hold_end(&self, seat: &Seat<State>, data: &mut State, event: &GestureHoldEndEvent) {
+        match &self.element {
+            CosmicMappedInternal::Stack(s) => PointerTarget::gesture_hold_end(s, seat, data, event),
+            CosmicMappedInternal::Window(w) => {
+                PointerTarget::gesture_hold_end(w, seat, data, event)
+            }
+            _ => {}
+        }
+    }
 }
 
 impl WaylandFocus for CosmicMapped {

src/shell/element/stack.rs

@@ -32,8 +32,10 @@ use smithay::{
     input::{
         keyboard::{KeyboardTarget, KeysymHandle, ModifiersState},
         pointer::{
-            AxisFrame, ButtonEvent, GrabStartData as PointerGrabStartData, MotionEvent,
+            AxisFrame, ButtonEvent, GestureHoldBeginEvent, GestureHoldEndEvent,
-            PointerTarget, RelativeMotionEvent,
+            GesturePinchBeginEvent, GesturePinchEndEvent, GesturePinchUpdateEvent,
+            GestureSwipeBeginEvent, GestureSwipeEndEvent, GestureSwipeUpdateEvent,
+            GrabStartData as PointerGrabStartData, MotionEvent, PointerTarget, RelativeMotionEvent,
         },
         Seat,
     },
@@ -1179,6 +1181,113 @@ impl PointerTarget<State> for CosmicStack {
             _ => {}
         }
     }
+
+    fn gesture_swipe_begin(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        event: &GestureSwipeBeginEvent,
+    ) {
+        self.0.with_program(|p| {
+            if p.current_focus() == Focus::Window {
+                let window = &p.windows.lock().unwrap()[p.active.load(Ordering::SeqCst)];
+                window.gesture_swipe_begin(seat, data, event)
+            }
+        })
+    }
+
+    fn gesture_swipe_update(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        event: &GestureSwipeUpdateEvent,
+    ) {
+        self.0.with_program(|p| {
+            if p.current_focus() == Focus::Window {
+                let window = &p.windows.lock().unwrap()[p.active.load(Ordering::SeqCst)];
+                window.gesture_swipe_update(seat, data, event)
+            }
+        })
+    }
+
+    fn gesture_swipe_end(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        event: &GestureSwipeEndEvent,
+    ) {
+        self.0.with_program(|p| {
+            if p.current_focus() == Focus::Window {
+                let window = &p.windows.lock().unwrap()[p.active.load(Ordering::SeqCst)];
+                window.gesture_swipe_end(seat, data, event)
+            }
+        })
+    }
+
+    fn gesture_pinch_begin(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        event: &GesturePinchBeginEvent,
+    ) {
+        self.0.with_program(|p| {
+            if p.current_focus() == Focus::Window {
+                let window = &p.windows.lock().unwrap()[p.active.load(Ordering::SeqCst)];
+                window.gesture_pinch_begin(seat, data, event)
+            }
+        })
+    }
+
+    fn gesture_pinch_update(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        event: &GesturePinchUpdateEvent,
+    ) {
+        self.0.with_program(|p| {
+            if p.current_focus() == Focus::Window {
+                let window = &p.windows.lock().unwrap()[p.active.load(Ordering::SeqCst)];
+                window.gesture_pinch_update(seat, data, event)
+            }
+        })
+    }
+
+    fn gesture_pinch_end(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        event: &GesturePinchEndEvent,
+    ) {
+        self.0.with_program(|p| {
+            if p.current_focus() == Focus::Window {
+                let window = &p.windows.lock().unwrap()[p.active.load(Ordering::SeqCst)];
+                window.gesture_pinch_end(seat, data, event)
+            }
+        })
+    }
+
+    fn gesture_hold_begin(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        event: &GestureHoldBeginEvent,
+    ) {
+        self.0.with_program(|p| {
+            if p.current_focus() == Focus::Window {
+                let window = &p.windows.lock().unwrap()[p.active.load(Ordering::SeqCst)];
+                window.gesture_hold_begin(seat, data, event)
+            }
+        })
+    }
+
+    fn gesture_hold_end(&self, seat: &Seat<State>, data: &mut State, event: &GestureHoldEndEvent) {
+        self.0.with_program(|p| {
+            if p.current_focus() == Focus::Window {
+                let window = &p.windows.lock().unwrap()[p.active.load(Ordering::SeqCst)];
+                window.gesture_hold_end(seat, data, event)
+            }
+        })
+    }
 }
 
 render_elements! {

src/shell/element/surface.rs

@@ -17,7 +17,16 @@ use smithay::{
         },
         PopupManager, Window,
     },
-    input::{keyboard::KeyboardTarget, pointer::PointerTarget},
+    input::{
+        keyboard::{KeyboardTarget, KeysymHandle, ModifiersState},
+        pointer::{
+            AxisFrame, ButtonEvent, GestureHoldBeginEvent, GestureHoldEndEvent,
+            GesturePinchBeginEvent, GesturePinchEndEvent, GesturePinchUpdateEvent,
+            GestureSwipeBeginEvent, GestureSwipeEndEvent, GestureSwipeUpdateEvent, MotionEvent,
+            PointerTarget, RelativeMotionEvent,
+        },
+        Seat,
+    },
     output::Output,
     reexports::{
         wayland_protocols::{
@@ -34,12 +43,15 @@ use smithay::{
     wayland::{
         compositor::{with_states, SurfaceData},
         seat::WaylandFocus,
-        shell::xdg::{ToplevelSurface, XdgToplevelSurfaceData},
+        shell::xdg::{SurfaceCachedState, ToplevelSurface, XdgToplevelSurfaceData},
     },
     xwayland::{xwm::X11Relatable, X11Surface},
 };
 
-use crate::{state::SurfaceDmabufFeedback, wayland::handlers::decoration::PreferredDecorationMode};
+use crate::{
+    state::{State, SurfaceDmabufFeedback},
+    wayland::handlers::decoration::PreferredDecorationMode,
+};
 
 space_elements! {
     #[derive(Debug, Clone, PartialEq)]
@@ -363,13 +375,7 @@ impl CosmicSurface {
         match self {
             CosmicSurface::Wayland(window) => {
                 Some(with_states(window.toplevel().wl_surface(), |states| {
-                    let attrs = states
+                    states.cached_state.current::<SurfaceCachedState>().min_size
-                        .data_map
-                        .get::<XdgToplevelSurfaceData>()
-                        .unwrap()
-                        .lock()
-                        .unwrap();
-                    attrs.min_size
                 }))
                 .filter(|size| !(size.w == 0 && size.h == 0))
             }
@@ -389,13 +395,7 @@ impl CosmicSurface {
         match self {
             CosmicSurface::Wayland(window) => {
                 Some(with_states(window.toplevel().wl_surface(), |states| {
-                    let attrs = states
+                    states.cached_state.current::<SurfaceCachedState>().max_size
-                        .data_map
-                        .get::<XdgToplevelSurfaceData>()
-                        .unwrap()
-                        .lock()
-                        .unwrap();
-                    attrs.max_size
                 }))
                 .filter(|size| !(size.w == 0 && size.h == 0))
             }
@@ -638,12 +638,12 @@ impl CosmicSurface {
     }
 }
 
-impl KeyboardTarget<crate::state::State> for CosmicSurface {
+impl KeyboardTarget<State> for CosmicSurface {
     fn enter(
         &self,
-        seat: &smithay::input::Seat<crate::state::State>,
+        seat: &Seat<State>,
-        data: &mut crate::state::State,
+        data: &mut State,
-        keys: Vec<smithay::input::keyboard::KeysymHandle<'_>>,
+        keys: Vec<KeysymHandle<'_>>,
         serial: smithay::utils::Serial,
     ) {
         match self {
@@ -657,12 +657,7 @@ impl KeyboardTarget<crate::state::State> for CosmicSurface {
         }
     }
 
-    fn leave(
+    fn leave(&self, seat: &Seat<State>, data: &mut State, serial: smithay::utils::Serial) {
-        &self,
-        seat: &smithay::input::Seat<crate::state::State>,
-        data: &mut crate::state::State,
-        serial: smithay::utils::Serial,
-    ) {
         match self {
             CosmicSurface::Wayland(window) => KeyboardTarget::leave(window, seat, data, serial),
             CosmicSurface::X11(surface) => KeyboardTarget::leave(surface, seat, data, serial),
@@ -672,9 +667,9 @@ impl KeyboardTarget<crate::state::State> for CosmicSurface {
 
     fn key(
         &self,
-        seat: &smithay::input::Seat<crate::state::State>,
+        seat: &Seat<State>,
-        data: &mut crate::state::State,
+        data: &mut State,
-        key: smithay::input::keyboard::KeysymHandle<'_>,
+        key: KeysymHandle<'_>,
         state: smithay::backend::input::KeyState,
         serial: smithay::utils::Serial,
         time: u32,
@@ -692,9 +687,9 @@ impl KeyboardTarget<crate::state::State> for CosmicSurface {
 
     fn modifiers(
         &self,
-        seat: &smithay::input::Seat<crate::state::State>,
+        seat: &Seat<State>,
-        data: &mut crate::state::State,
+        data: &mut State,
-        modifiers: smithay::input::keyboard::ModifiersState,
+        modifiers: ModifiersState,
         serial: smithay::utils::Serial,
     ) {
         match self {
@@ -709,13 +704,8 @@ impl KeyboardTarget<crate::state::State> for CosmicSurface {
     }
 }
 
-impl PointerTarget<crate::state::State> for CosmicSurface {
+impl PointerTarget<State> for CosmicSurface {
-    fn enter(
+    fn enter(&self, seat: &Seat<State>, data: &mut State, event: &MotionEvent) {
-        &self,
-        seat: &smithay::input::Seat<crate::state::State>,
-        data: &mut crate::state::State,
-        event: &smithay::input::pointer::MotionEvent,
-    ) {
         match self {
             CosmicSurface::Wayland(window) => PointerTarget::enter(window, seat, data, event),
             CosmicSurface::X11(surface) => PointerTarget::enter(surface, seat, data, event),
@@ -723,12 +713,7 @@ impl PointerTarget<crate::state::State> for CosmicSurface {
         }
     }
 
-    fn motion(
+    fn motion(&self, seat: &Seat<State>, data: &mut State, event: &MotionEvent) {
-        &self,
-        seat: &smithay::input::Seat<crate::state::State>,
-        data: &mut crate::state::State,
-        event: &smithay::input::pointer::MotionEvent,
-    ) {
         match self {
             CosmicSurface::Wayland(window) => PointerTarget::motion(window, seat, data, event),
             CosmicSurface::X11(surface) => PointerTarget::motion(surface, seat, data, event),
@@ -736,12 +721,7 @@ impl PointerTarget<crate::state::State> for CosmicSurface {
         }
     }
 
-    fn relative_motion(
+    fn relative_motion(&self, seat: &Seat<State>, data: &mut State, event: &RelativeMotionEvent) {
-        &self,
-        seat: &smithay::input::Seat<crate::state::State>,
-        data: &mut crate::state::State,
-        event: &smithay::input::pointer::RelativeMotionEvent,
-    ) {
         match self {
             CosmicSurface::Wayland(window) => {
                 PointerTarget::relative_motion(window, seat, data, event)
@@ -753,12 +733,7 @@ impl PointerTarget<crate::state::State> for CosmicSurface {
         }
     }
 
-    fn button(
+    fn button(&self, seat: &Seat<State>, data: &mut State, event: &ButtonEvent) {
-        &self,
-        seat: &smithay::input::Seat<crate::state::State>,
-        data: &mut crate::state::State,
-        event: &smithay::input::pointer::ButtonEvent,
-    ) {
         match self {
             CosmicSurface::Wayland(window) => PointerTarget::button(window, seat, data, event),
             CosmicSurface::X11(surface) => PointerTarget::button(surface, seat, data, event),
@@ -766,12 +741,7 @@ impl PointerTarget<crate::state::State> for CosmicSurface {
         }
     }
 
-    fn axis(
+    fn axis(&self, seat: &Seat<State>, data: &mut State, frame: AxisFrame) {
-        &self,
-        seat: &smithay::input::Seat<crate::state::State>,
-        data: &mut crate::state::State,
-        frame: smithay::input::pointer::AxisFrame,
-    ) {
         match self {
             CosmicSurface::Wayland(window) => PointerTarget::axis(window, seat, data, frame),
             CosmicSurface::X11(surface) => PointerTarget::axis(surface, seat, data, frame),
@@ -781,8 +751,8 @@ impl PointerTarget<crate::state::State> for CosmicSurface {
 
     fn leave(
         &self,
-        seat: &smithay::input::Seat<crate::state::State>,
+        seat: &Seat<State>,
-        data: &mut crate::state::State,
+        data: &mut State,
         serial: smithay::utils::Serial,
         time: u32,
     ) {
@@ -794,6 +764,137 @@ impl PointerTarget<crate::state::State> for CosmicSurface {
             _ => unreachable!(),
         }
     }
+
+    fn gesture_swipe_begin(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        event: &GestureSwipeBeginEvent,
+    ) {
+        match self {
+            CosmicSurface::Wayland(window) => {
+                PointerTarget::gesture_swipe_begin(window, seat, data, event)
+            }
+            CosmicSurface::X11(surface) => {
+                PointerTarget::gesture_swipe_begin(surface, seat, data, event)
+            }
+            _ => unreachable!(),
+        }
+    }
+
+    fn gesture_swipe_update(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        event: &GestureSwipeUpdateEvent,
+    ) {
+        match self {
+            CosmicSurface::Wayland(window) => {
+                PointerTarget::gesture_swipe_update(window, seat, data, event)
+            }
+            CosmicSurface::X11(surface) => {
+                PointerTarget::gesture_swipe_update(surface, seat, data, event)
+            }
+            _ => unreachable!(),
+        }
+    }
+
+    fn gesture_swipe_end(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        event: &GestureSwipeEndEvent,
+    ) {
+        match self {
+            CosmicSurface::Wayland(window) => {
+                PointerTarget::gesture_swipe_end(window, seat, data, event)
+            }
+            CosmicSurface::X11(surface) => {
+                PointerTarget::gesture_swipe_end(surface, seat, data, event)
+            }
+            _ => unreachable!(),
+        }
+    }
+
+    fn gesture_pinch_begin(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        event: &GesturePinchBeginEvent,
+    ) {
+        match self {
+            CosmicSurface::Wayland(window) => {
+                PointerTarget::gesture_pinch_begin(window, seat, data, event)
+            }
+            CosmicSurface::X11(surface) => {
+                PointerTarget::gesture_pinch_begin(surface, seat, data, event)
+            }
+            _ => unreachable!(),
+        }
+    }
+
+    fn gesture_pinch_update(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        event: &GesturePinchUpdateEvent,
+    ) {
+        match self {
+            CosmicSurface::Wayland(window) => {
+                PointerTarget::gesture_pinch_update(window, seat, data, event)
+            }
+            CosmicSurface::X11(surface) => {
+                PointerTarget::gesture_pinch_update(surface, seat, data, event)
+            }
+            _ => unreachable!(),
+        }
+    }
+
+    fn gesture_pinch_end(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        event: &GesturePinchEndEvent,
+    ) {
+        match self {
+            CosmicSurface::Wayland(window) => {
+                PointerTarget::gesture_pinch_end(window, seat, data, event)
+            }
+            CosmicSurface::X11(surface) => {
+                PointerTarget::gesture_pinch_end(surface, seat, data, event)
+            }
+            _ => unreachable!(),
+        }
+    }
+
+    fn gesture_hold_begin(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        event: &GestureHoldBeginEvent,
+    ) {
+        match self {
+            CosmicSurface::Wayland(window) => {
+                PointerTarget::gesture_hold_begin(window, seat, data, event)
+            }
+            CosmicSurface::X11(surface) => {
+                PointerTarget::gesture_hold_begin(surface, seat, data, event)
+            }
+            _ => unreachable!(),
+        }
+    }
+
+    fn gesture_hold_end(&self, seat: &Seat<State>, data: &mut State, event: &GestureHoldEndEvent) {
+        match self {
+            CosmicSurface::Wayland(window) => {
+                PointerTarget::gesture_hold_end(window, seat, data, event)
+            }
+            CosmicSurface::X11(surface) => {
+                PointerTarget::gesture_hold_end(surface, seat, data, event)
+            }
+            _ => unreachable!(),
+        }
+    }
 }
 
 impl WaylandFocus for CosmicSurface {

src/shell/element/window.rs

@@ -24,7 +24,12 @@ use smithay::{
     desktop::space::SpaceElement,
     input::{
         keyboard::{KeyboardTarget, KeysymHandle, ModifiersState},
-        pointer::{AxisFrame, ButtonEvent, MotionEvent, PointerTarget, RelativeMotionEvent},
+        pointer::{
+            AxisFrame, ButtonEvent, GestureHoldBeginEvent, GestureHoldEndEvent,
+            GesturePinchBeginEvent, GesturePinchEndEvent, GesturePinchUpdateEvent,
+            GestureSwipeBeginEvent, GestureSwipeEndEvent, GestureSwipeUpdateEvent, MotionEvent,
+            PointerTarget, RelativeMotionEvent,
+        },
         Seat,
     },
     output::Output,
@@ -590,6 +595,105 @@ impl PointerTarget<State> for CosmicWindow {
             _ => {}
         }
     }
+
+    fn gesture_swipe_begin(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        event: &GestureSwipeBeginEvent,
+    ) {
+        self.0.with_program(|p| {
+            if !p.has_ssd(false) || p.current_focus() == Focus::Window {
+                PointerTarget::gesture_swipe_begin(&p.window, seat, data, event)
+            }
+        })
+    }
+
+    fn gesture_swipe_update(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        event: &GestureSwipeUpdateEvent,
+    ) {
+        self.0.with_program(|p| {
+            if !p.has_ssd(false) || p.current_focus() == Focus::Window {
+                PointerTarget::gesture_swipe_update(&p.window, seat, data, event)
+            }
+        })
+    }
+
+    fn gesture_swipe_end(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        event: &GestureSwipeEndEvent,
+    ) {
+        self.0.with_program(|p| {
+            if !p.has_ssd(false) || p.current_focus() == Focus::Window {
+                PointerTarget::gesture_swipe_end(&p.window, seat, data, event)
+            }
+        })
+    }
+
+    fn gesture_pinch_begin(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        event: &GesturePinchBeginEvent,
+    ) {
+        self.0.with_program(|p| {
+            if !p.has_ssd(false) || p.current_focus() == Focus::Window {
+                PointerTarget::gesture_pinch_begin(&p.window, seat, data, event)
+            }
+        })
+    }
+
+    fn gesture_pinch_update(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        event: &GesturePinchUpdateEvent,
+    ) {
+        self.0.with_program(|p| {
+            if !p.has_ssd(false) || p.current_focus() == Focus::Window {
+                PointerTarget::gesture_pinch_update(&p.window, seat, data, event)
+            }
+        })
+    }
+
+    fn gesture_pinch_end(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        event: &GesturePinchEndEvent,
+    ) {
+        self.0.with_program(|p| {
+            if !p.has_ssd(false) || p.current_focus() == Focus::Window {
+                PointerTarget::gesture_pinch_end(&p.window, seat, data, event)
+            }
+        })
+    }
+
+    fn gesture_hold_begin(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        event: &GestureHoldBeginEvent,
+    ) {
+        self.0.with_program(|p| {
+            if !p.has_ssd(false) || p.current_focus() == Focus::Window {
+                PointerTarget::gesture_hold_begin(&p.window, seat, data, event)
+            }
+        })
+    }
+
+    fn gesture_hold_end(&self, seat: &Seat<State>, data: &mut State, event: &GestureHoldEndEvent) {
+        self.0.with_program(|p| {
+            if !p.has_ssd(false) || p.current_focus() == Focus::Window {
+                PointerTarget::gesture_hold_end(&p.window, seat, data, event)
+            }
+        })
+    }
 }
 
 render_elements! {

src/shell/focus/target.rs

@@ -11,7 +11,12 @@ use smithay::{
     desktop::{LayerSurface, PopupKind},
     input::{
         keyboard::{KeyboardTarget, KeysymHandle, ModifiersState},
-        pointer::{AxisFrame, ButtonEvent, MotionEvent, PointerTarget, RelativeMotionEvent},
+        pointer::{
+            AxisFrame, ButtonEvent, GestureHoldBeginEvent, GestureHoldEndEvent,
+            GesturePinchBeginEvent, GesturePinchEndEvent, GesturePinchUpdateEvent,
+            GestureSwipeBeginEvent, GestureSwipeEndEvent, GestureSwipeUpdateEvent, MotionEvent,
+            PointerTarget, RelativeMotionEvent,
+        },
         Seat,
     },
     output::WeakOutput,
@@ -198,6 +203,215 @@ impl PointerTarget<State> for PointerFocusTarget {
             PointerFocusTarget::ResizeFork(f) => PointerTarget::leave(f, seat, data, serial, time),
         }
     }
+    fn gesture_swipe_begin(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        event: &GestureSwipeBeginEvent,
+    ) {
+        match self {
+            PointerFocusTarget::Element(w) => {
+                PointerTarget::gesture_swipe_begin(w, seat, data, event)
+            }
+            PointerFocusTarget::Fullscreen(w) => {
+                PointerTarget::gesture_swipe_begin(w, seat, data, event)
+            }
+            PointerFocusTarget::LayerSurface(l) => {
+                PointerTarget::gesture_swipe_begin(l, seat, data, event)
+            }
+            PointerFocusTarget::Popup(p) => {
+                PointerTarget::gesture_swipe_begin(p.wl_surface(), seat, data, event)
+            }
+            PointerFocusTarget::OverrideRedirect(s) => {
+                PointerTarget::gesture_swipe_begin(s, seat, data, event)
+            }
+            PointerFocusTarget::ResizeFork(f) => {
+                PointerTarget::gesture_swipe_begin(f, seat, data, event)
+            }
+        }
+    }
+    fn gesture_swipe_update(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        event: &GestureSwipeUpdateEvent,
+    ) {
+        match self {
+            PointerFocusTarget::Element(w) => {
+                PointerTarget::gesture_swipe_update(w, seat, data, event)
+            }
+            PointerFocusTarget::Fullscreen(w) => {
+                PointerTarget::gesture_swipe_update(w, seat, data, event)
+            }
+            PointerFocusTarget::LayerSurface(l) => {
+                PointerTarget::gesture_swipe_update(l, seat, data, event)
+            }
+            PointerFocusTarget::Popup(p) => {
+                PointerTarget::gesture_swipe_update(p.wl_surface(), seat, data, event)
+            }
+            PointerFocusTarget::OverrideRedirect(s) => {
+                PointerTarget::gesture_swipe_update(s, seat, data, event)
+            }
+            PointerFocusTarget::ResizeFork(f) => {
+                PointerTarget::gesture_swipe_update(f, seat, data, event)
+            }
+        }
+    }
+    fn gesture_swipe_end(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        event: &GestureSwipeEndEvent,
+    ) {
+        match self {
+            PointerFocusTarget::Element(w) => {
+                PointerTarget::gesture_swipe_end(w, seat, data, event)
+            }
+            PointerFocusTarget::Fullscreen(w) => {
+                PointerTarget::gesture_swipe_end(w, seat, data, event)
+            }
+            PointerFocusTarget::LayerSurface(l) => {
+                PointerTarget::gesture_swipe_end(l, seat, data, event)
+            }
+            PointerFocusTarget::Popup(p) => {
+                PointerTarget::gesture_swipe_end(p.wl_surface(), seat, data, event)
+            }
+            PointerFocusTarget::OverrideRedirect(s) => {
+                PointerTarget::gesture_swipe_end(s, seat, data, event)
+            }
+            PointerFocusTarget::ResizeFork(f) => {
+                PointerTarget::gesture_swipe_end(f, seat, data, event)
+            }
+        }
+    }
+    fn gesture_pinch_begin(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        event: &GesturePinchBeginEvent,
+    ) {
+        match self {
+            PointerFocusTarget::Element(w) => {
+                PointerTarget::gesture_pinch_begin(w, seat, data, event)
+            }
+            PointerFocusTarget::Fullscreen(w) => {
+                PointerTarget::gesture_pinch_begin(w, seat, data, event)
+            }
+            PointerFocusTarget::LayerSurface(l) => {
+                PointerTarget::gesture_pinch_begin(l, seat, data, event)
+            }
+            PointerFocusTarget::Popup(p) => {
+                PointerTarget::gesture_pinch_begin(p.wl_surface(), seat, data, event)
+            }
+            PointerFocusTarget::OverrideRedirect(s) => {
+                PointerTarget::gesture_pinch_begin(s, seat, data, event)
+            }
+            PointerFocusTarget::ResizeFork(f) => {
+                PointerTarget::gesture_pinch_begin(f, seat, data, event)
+            }
+        }
+    }
+    fn gesture_pinch_update(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        event: &GesturePinchUpdateEvent,
+    ) {
+        match self {
+            PointerFocusTarget::Element(w) => {
+                PointerTarget::gesture_pinch_update(w, seat, data, event)
+            }
+            PointerFocusTarget::Fullscreen(w) => {
+                PointerTarget::gesture_pinch_update(w, seat, data, event)
+            }
+            PointerFocusTarget::LayerSurface(l) => {
+                PointerTarget::gesture_pinch_update(l, seat, data, event)
+            }
+            PointerFocusTarget::Popup(p) => {
+                PointerTarget::gesture_pinch_update(p.wl_surface(), seat, data, event)
+            }
+            PointerFocusTarget::OverrideRedirect(s) => {
+                PointerTarget::gesture_pinch_update(s, seat, data, event)
+            }
+            PointerFocusTarget::ResizeFork(f) => {
+                PointerTarget::gesture_pinch_update(f, seat, data, event)
+            }
+        }
+    }
+    fn gesture_pinch_end(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        event: &GesturePinchEndEvent,
+    ) {
+        match self {
+            PointerFocusTarget::Element(w) => {
+                PointerTarget::gesture_pinch_end(w, seat, data, event)
+            }
+            PointerFocusTarget::Fullscreen(w) => {
+                PointerTarget::gesture_pinch_end(w, seat, data, event)
+            }
+            PointerFocusTarget::LayerSurface(l) => {
+                PointerTarget::gesture_pinch_end(l, seat, data, event)
+            }
+            PointerFocusTarget::Popup(p) => {
+                PointerTarget::gesture_pinch_end(p.wl_surface(), seat, data, event)
+            }
+            PointerFocusTarget::OverrideRedirect(s) => {
+                PointerTarget::gesture_pinch_end(s, seat, data, event)
+            }
+            PointerFocusTarget::ResizeFork(f) => {
+                PointerTarget::gesture_pinch_end(f, seat, data, event)
+            }
+        }
+    }
+    fn gesture_hold_begin(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        event: &GestureHoldBeginEvent,
+    ) {
+        match self {
+            PointerFocusTarget::Element(w) => {
+                PointerTarget::gesture_hold_begin(w, seat, data, event)
+            }
+            PointerFocusTarget::Fullscreen(w) => {
+                PointerTarget::gesture_hold_begin(w, seat, data, event)
+            }
+            PointerFocusTarget::LayerSurface(l) => {
+                PointerTarget::gesture_hold_begin(l, seat, data, event)
+            }
+            PointerFocusTarget::Popup(p) => {
+                PointerTarget::gesture_hold_begin(p.wl_surface(), seat, data, event)
+            }
+            PointerFocusTarget::OverrideRedirect(s) => {
+                PointerTarget::gesture_hold_begin(s, seat, data, event)
+            }
+            PointerFocusTarget::ResizeFork(f) => {
+                PointerTarget::gesture_hold_begin(f, seat, data, event)
+            }
+        }
+    }
+    fn gesture_hold_end(&self, seat: &Seat<State>, data: &mut State, event: &GestureHoldEndEvent) {
+        match self {
+            PointerFocusTarget::Element(w) => PointerTarget::gesture_hold_end(w, seat, data, event),
+            PointerFocusTarget::Fullscreen(w) => {
+                PointerTarget::gesture_hold_end(w, seat, data, event)
+            }
+            PointerFocusTarget::LayerSurface(l) => {
+                PointerTarget::gesture_hold_end(l, seat, data, event)
+            }
+            PointerFocusTarget::Popup(p) => {
+                PointerTarget::gesture_hold_end(p.wl_surface(), seat, data, event)
+            }
+            PointerFocusTarget::OverrideRedirect(s) => {
+                PointerTarget::gesture_hold_end(s, seat, data, event)
+            }
+            PointerFocusTarget::ResizeFork(f) => {
+                PointerTarget::gesture_hold_end(f, seat, data, event)
+            }
+        }
+    }
 }
 
 impl KeyboardTarget<State> for KeyboardFocusTarget {

src/shell/grabs/mod.rs

@@ -1,7 +1,9 @@
 use smithay::{
     input::pointer::{
-        AxisFrame, ButtonEvent, GrabStartData as PointerGrabStartData, MotionEvent, PointerGrab,
+        AxisFrame, ButtonEvent, GestureHoldBeginEvent, GestureHoldEndEvent, GesturePinchBeginEvent,
-        PointerInnerHandle, RelativeMotionEvent,
+        GesturePinchEndEvent, GesturePinchUpdateEvent, GestureSwipeBeginEvent,
+        GestureSwipeEndEvent, GestureSwipeUpdateEvent, GrabStartData as PointerGrabStartData,
+        MotionEvent, PointerGrab, PointerInnerHandle, RelativeMotionEvent,
     },
     reexports::wayland_protocols::xdg::shell::server::xdg_toplevel,
     utils::{Logical, Point},
@@ -150,6 +152,102 @@ impl PointerGrab<State> for ResizeGrab {
         }
     }
 
+    fn gesture_swipe_begin(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GestureSwipeBeginEvent,
+    ) {
+        match self {
+            ResizeGrab::Floating(grab) => grab.gesture_swipe_begin(data, handle, event),
+            ResizeGrab::Tiling(grab) => grab.gesture_swipe_begin(data, handle, event),
+        }
+    }
+
+    fn gesture_swipe_update(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GestureSwipeUpdateEvent,
+    ) {
+        match self {
+            ResizeGrab::Floating(grab) => grab.gesture_swipe_update(data, handle, event),
+            ResizeGrab::Tiling(grab) => grab.gesture_swipe_update(data, handle, event),
+        }
+    }
+
+    fn gesture_swipe_end(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GestureSwipeEndEvent,
+    ) {
+        match self {
+            ResizeGrab::Floating(grab) => grab.gesture_swipe_end(data, handle, event),
+            ResizeGrab::Tiling(grab) => grab.gesture_swipe_end(data, handle, event),
+        }
+    }
+
+    fn gesture_pinch_begin(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GesturePinchBeginEvent,
+    ) {
+        match self {
+            ResizeGrab::Floating(grab) => grab.gesture_pinch_begin(data, handle, event),
+            ResizeGrab::Tiling(grab) => grab.gesture_pinch_begin(data, handle, event),
+        }
+    }
+
+    fn gesture_pinch_update(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GesturePinchUpdateEvent,
+    ) {
+        match self {
+            ResizeGrab::Floating(grab) => grab.gesture_pinch_update(data, handle, event),
+            ResizeGrab::Tiling(grab) => grab.gesture_pinch_update(data, handle, event),
+        }
+    }
+
+    fn gesture_pinch_end(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GesturePinchEndEvent,
+    ) {
+        match self {
+            ResizeGrab::Floating(grab) => grab.gesture_pinch_end(data, handle, event),
+            ResizeGrab::Tiling(grab) => grab.gesture_pinch_end(data, handle, event),
+        }
+    }
+
+    fn gesture_hold_begin(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GestureHoldBeginEvent,
+    ) {
+        match self {
+            ResizeGrab::Floating(grab) => grab.gesture_hold_begin(data, handle, event),
+            ResizeGrab::Tiling(grab) => grab.gesture_hold_begin(data, handle, event),
+        }
+    }
+
+    fn gesture_hold_end(
+        &mut self,
+        data: &mut State,
+        handle: &mut PointerInnerHandle<'_, State>,
+        event: &GestureHoldEndEvent,
+    ) {
+        match self {
+            ResizeGrab::Floating(grab) => grab.gesture_hold_end(data, handle, event),
+            ResizeGrab::Tiling(grab) => grab.gesture_hold_end(data, handle, event),
+        }
+    }
+
     fn start_data(&self) -> &PointerGrabStartData<State> {
         match self {
             ResizeGrab::Floating(grab) => grab.start_data(),

src/shell/grabs/moving.rs

@@ -25,8 +25,11 @@ use smithay::{
     desktop::space::SpaceElement,
     input::{
         pointer::{
-            AxisFrame, ButtonEvent, GrabStartData as PointerGrabStartData, MotionEvent,
+            AxisFrame, ButtonEvent, GestureHoldBeginEvent, GestureHoldEndEvent,
-            PointerGrab, PointerInnerHandle, RelativeMotionEvent,
+            GesturePinchBeginEvent, GesturePinchEndEvent, GesturePinchUpdateEvent,
+            GestureSwipeBeginEvent, GestureSwipeEndEvent, GestureSwipeUpdateEvent,
+            GrabStartData as PointerGrabStartData, MotionEvent, PointerGrab, PointerInnerHandle,
+            RelativeMotionEvent,
         },
         Seat,
     },
@@ -308,6 +311,78 @@ impl PointerGrab<State> for MoveGrab {
         handle.axis(state, details);
     }
 
+    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
     }

src/shell/layout/floating/grabs/resize.rs

@@ -9,8 +9,10 @@ use crate::{
 use smithay::{
     desktop::space::SpaceElement,
     input::pointer::{
-        AxisFrame, ButtonEvent, GrabStartData as PointerGrabStartData, MotionEvent, PointerGrab,
+        AxisFrame, ButtonEvent, GestureHoldBeginEvent, GestureHoldEndEvent, GesturePinchBeginEvent,
-        PointerInnerHandle, RelativeMotionEvent,
+        GesturePinchEndEvent, GesturePinchUpdateEvent, GestureSwipeBeginEvent,
+        GestureSwipeEndEvent, GestureSwipeUpdateEvent, GrabStartData as PointerGrabStartData,
+        MotionEvent, PointerGrab, PointerInnerHandle, RelativeMotionEvent,
     },
     utils::{IsAlive, Logical, Point, Rectangle, Size},
 };
@@ -162,6 +164,78 @@ impl PointerGrab<State> for ResizeSurfaceGrab {
         handle.axis(data, details)
     }
 
+    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
     }

src/shell/layout/tiling/grabs/resize.rs

@@ -10,8 +10,11 @@ use smithay::{
     backend::input::ButtonState,
     input::{
         pointer::{
-            AxisFrame, ButtonEvent, Focus, GrabStartData as PointerGrabStartData, MotionEvent,
+            AxisFrame, ButtonEvent, Focus, GestureHoldBeginEvent, GestureHoldEndEvent,
-            PointerGrab, PointerInnerHandle, PointerTarget, RelativeMotionEvent,
+            GesturePinchBeginEvent, GesturePinchEndEvent, GesturePinchUpdateEvent,
+            GestureSwipeBeginEvent, GestureSwipeEndEvent, GestureSwipeUpdateEvent,
+            GrabStartData as PointerGrabStartData, MotionEvent, PointerGrab, PointerInnerHandle,
+            PointerTarget, RelativeMotionEvent,
         },
         Seat,
     },
@@ -99,6 +102,14 @@ impl PointerTarget<State> for ResizeForkTarget {
     ) {
     }
     fn axis(&self, _seat: &Seat<State>, _data: &mut State, _frame: AxisFrame) {}
+    fn gesture_swipe_begin(&self, _: &Seat<State>, _: &mut State, _: &GestureSwipeBeginEvent) {}
+    fn gesture_swipe_update(&self, _: &Seat<State>, _: &mut State, _: &GestureSwipeUpdateEvent) {}
+    fn gesture_swipe_end(&self, _: &Seat<State>, _: &mut State, _: &GestureSwipeEndEvent) {}
+    fn gesture_pinch_begin(&self, _: &Seat<State>, _: &mut State, _: &GesturePinchBeginEvent) {}
+    fn gesture_pinch_update(&self, _: &Seat<State>, _: &mut State, _: &GesturePinchUpdateEvent) {}
+    fn gesture_pinch_end(&self, _: &Seat<State>, _: &mut State, _: &GesturePinchEndEvent) {}
+    fn gesture_hold_begin(&self, _: &Seat<State>, _: &mut State, _: &GestureHoldBeginEvent) {}
+    fn gesture_hold_end(&self, _: &Seat<State>, _: &mut State, _: &GestureHoldEndEvent) {}
 }
 
 pub struct ResizeForkGrab {
@@ -223,6 +234,78 @@ impl PointerGrab<State> for ResizeForkGrab {
         handle.axis(data, details)
     }
 
+    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
     }

src/utils/iced.rs

@@ -44,7 +44,12 @@ use smithay::{
     desktop::space::{RenderZindex, SpaceElement},
     input::{
         keyboard::{KeyboardTarget, KeysymHandle, ModifiersState},
-        pointer::{AxisFrame, ButtonEvent, MotionEvent, PointerTarget, RelativeMotionEvent},
+        pointer::{
+            AxisFrame, ButtonEvent, GestureHoldBeginEvent, GestureHoldEndEvent,
+            GesturePinchBeginEvent, GesturePinchEndEvent, GesturePinchUpdateEvent,
+            GestureSwipeBeginEvent, GestureSwipeEndEvent, GestureSwipeUpdateEvent, MotionEvent,
+            PointerTarget, RelativeMotionEvent,
+        },
         Seat,
     },
     output::Output,
@@ -461,6 +466,63 @@ impl<P: Program + Send + 'static> PointerTarget<crate::state::State> for IcedEle
             .queue_event(Event::Mouse(MouseEvent::CursorLeft));
         let _ = internal.update(true);
     }
+
+    fn gesture_swipe_begin(
+        &self,
+        _: &Seat<crate::state::State>,
+        _: &mut crate::state::State,
+        _: &GestureSwipeBeginEvent,
+    ) {
+    }
+    fn gesture_swipe_update(
+        &self,
+        _: &Seat<crate::state::State>,
+        _: &mut crate::state::State,
+        _: &GestureSwipeUpdateEvent,
+    ) {
+    }
+    fn gesture_swipe_end(
+        &self,
+        _: &Seat<crate::state::State>,
+        _: &mut crate::state::State,
+        _: &GestureSwipeEndEvent,
+    ) {
+    }
+    fn gesture_pinch_begin(
+        &self,
+        _: &Seat<crate::state::State>,
+        _: &mut crate::state::State,
+        _: &GesturePinchBeginEvent,
+    ) {
+    }
+    fn gesture_pinch_update(
+        &self,
+        _: &Seat<crate::state::State>,
+        _: &mut crate::state::State,
+        _: &GesturePinchUpdateEvent,
+    ) {
+    }
+    fn gesture_pinch_end(
+        &self,
+        _: &Seat<crate::state::State>,
+        _: &mut crate::state::State,
+        _: &GesturePinchEndEvent,
+    ) {
+    }
+    fn gesture_hold_begin(
+        &self,
+        _: &Seat<crate::state::State>,
+        _: &mut crate::state::State,
+        _: &GestureHoldBeginEvent,
+    ) {
+    }
+    fn gesture_hold_end(
+        &self,
+        _: &Seat<crate::state::State>,
+        _: &mut crate::state::State,
+        _: &GestureHoldEndEvent,
+    ) {
+    }
 }
 
 impl<P: Program + Send + 'static> KeyboardTarget<crate::state::State> for IcedElement<P> {