input/dnd: Special case xwayland instead of working around it for all clients

Author: Drakulix

src/desktop/space/wayland/x11.rs

@@ -1,7 +1,3 @@
-use std::borrow::Cow;
-
-use wayland_server::protocol::wl_surface::WlSurface;
-
 use crate::{
     backend::renderer::{
         element::{
@@ -12,19 +8,11 @@ use crate::{
     },
     desktop::{space::SpaceElement, WindowSurfaceType},
     utils::{Logical, Physical, Point, Rectangle, Scale},
-    wayland::seat::WaylandFocus,
     xwayland::X11Surface,
 };
 
 use super::{output_update, WindowOutputUserData};
 
-impl WaylandFocus for X11Surface {
-    #[inline]
-    fn wl_surface(&self) -> Option<Cow<'_, WlSurface>> {
-        X11Surface::wl_surface(self).map(Cow::Owned)
-    }
-}
-
 impl SpaceElement for X11Surface {
     fn bbox(&self) -> Rectangle<i32, Logical> {
         let geo = X11Surface::geometry(self);

src/input/dnd/grab.rs

@@ -3,6 +3,11 @@ use std::{fmt, sync::Arc};
 #[cfg(feature = "wayland_frontend")]
 use wayland_server::DisplayHandle;
 
+#[cfg(feature = "xwayland")]
+use crate::{wayland::seat::WaylandFocus, xwayland::XWaylandClientData};
+#[cfg(feature = "xwayland")]
+use wayland_server::Resource;
+
 use crate::{
     input::{
         dnd::OfferData,
@@ -323,12 +328,7 @@ where
         focus: Option<(<D as SeatHandler>::PointerFocus, Point<f64, Logical>)>,
         event: &PointerMotionEvent,
     ) {
-        // While the grab is active, we still honor the implicit grab target
-        handle.motion(
-            data,
-            self.pointer_start_data.as_ref().unwrap().focus.clone(),
-            event,
-        );
+        handle.motion(data, self.ptr_focus(), event);
 
         self.last_position = event.location;
 
@@ -342,26 +342,13 @@ where
         _focus: Option<(<D as SeatHandler>::PointerFocus, Point<f64, Logical>)>,
         event: &RelativeMotionEvent,
     ) {
-        handle.relative_motion(
-            data,
-            self.pointer_start_data.as_ref().unwrap().focus.clone(),
-            event,
-        );
+        handle.relative_motion(data, self.ptr_focus(), event);
     }
 
     fn button(&mut self, data: &mut D, handle: &mut PointerInnerHandle<'_, D>, event: &ButtonEvent) {
         handle.button(data, event);
 
         if handle.current_pressed().is_empty() {
-            handle.motion(
-                data,
-                None,
-                &PointerMotionEvent {
-                    location: self.last_position,
-                    serial: event.serial,
-                    time: event.time,
-                },
-            );
             // the user dropped, proceed to the drop
             handle.unset_grab(self, data, event.serial, event.time, true);
         }
@@ -496,6 +483,8 @@ where
             return;
         }
 
+        handle.motion(data, self.touch_focus(), event, seq);
+
         self.last_position = event.location;
 
         self.update_focus(
@@ -505,13 +494,6 @@ where
             SERIAL_COUNTER.next_serial(),
             event.time,
         );
-
-        handle.motion(
-            data,
-            self.touch_start_data.as_ref().unwrap().focus.clone(),
-            event,
-            seq,
-        );
     }
 
     fn frame(&mut self, data: &mut D, handle: &mut TouchInnerHandle<'_, D>, seq: Serial) {
@@ -549,3 +531,79 @@ where
         self.drop(data, DndTarget::Touch);
     }
 }
+
+#[cfg(not(feature = "xwayland"))]
+impl<D, S> DnDGrab<D, S, D::PointerFocus>
+where
+    D: DndGrabHandler,
+    D: SeatHandler,
+    <D as SeatHandler>::PointerFocus: DndFocus<D> + 'static,
+    D: 'static,
+    S: Source,
+{
+    fn ptr_focus(&self) -> Option<(<D as SeatHandler>::PointerFocus, Point<f64, Logical>)> {
+        None
+    }
+}
+
+#[cfg(not(feature = "xwayland"))]
+impl<D, S> DnDGrab<D, S, D::TouchFocus>
+where
+    D: DndGrabHandler,
+    D: SeatHandler,
+    <D as SeatHandler>::TouchFocus: DndFocus<D> + 'static,
+    D: 'static,
+    S: Source,
+{
+    fn touch_focus(&self) -> Option<(<D as SeatHandler>::TouchFocus, Point<f64, Logical>)> {
+        None
+    }
+}
+
+#[cfg(feature = "xwayland")]
+impl<D, S> DnDGrab<D, S, D::PointerFocus>
+where
+    D: DndGrabHandler,
+    D: SeatHandler,
+    <D as SeatHandler>::PointerFocus: DndFocus<D> + 'static,
+    D: 'static,
+    S: Source,
+{
+    fn ptr_focus(&self) -> Option<(<D as SeatHandler>::PointerFocus, Point<f64, Logical>)> {
+        // While the grab is active, we don't want any focus except for xwayland
+        self.pointer_start_data
+            .as_ref()?
+            .focus
+            .clone()
+            .filter(|(focus, _)| {
+                focus.wl_surface().is_some_and(|s| {
+                    s.client()
+                        .is_some_and(|c| c.get_data::<XWaylandClientData>().is_some())
+                })
+            })
+    }
+}
+
+#[cfg(feature = "xwayland")]
+impl<D, S> DnDGrab<D, S, D::TouchFocus>
+where
+    D: DndGrabHandler,
+    D: SeatHandler,
+    <D as SeatHandler>::TouchFocus: DndFocus<D> + 'static,
+    D: 'static,
+    S: Source,
+{
+    fn touch_focus(&self) -> Option<(<D as SeatHandler>::TouchFocus, Point<f64, Logical>)> {
+        // While the grab is active, we don't want any focus except for xwayland
+        self.touch_start_data
+            .as_ref()?
+            .focus
+            .clone()
+            .filter(|(focus, _)| {
+                focus.wl_surface().is_some_and(|s| {
+                    s.client()
+                        .is_some_and(|c| c.get_data::<XWaylandClientData>().is_some())
+                })
+            })
+    }
+}

src/input/dnd/mod.rs

@@ -8,6 +8,8 @@ use smallvec::SmallVec;
 #[cfg(feature = "wayland_frontend")]
 use wayland_server::DisplayHandle;
 
+#[cfg(feature = "xwayland")]
+use crate::wayland::seat::WaylandFocus;
 use crate::{
     input::{Seat, SeatHandler},
     utils::{IsAlive, Logical, Point, Serial},
@@ -83,6 +85,47 @@ pub trait OfferData: Send + 'static {
     fn validated(&self) -> bool;
 }
 
+// We sadly have to duplicate this whole trait for code in `DnDGrab`,
+// because conditional trait bounds are not a thing (yet? rust-lang/rust#115590)
+#[cfg(feature = "xwayland")]
+/// A potential Drag'n'Drop target
+pub trait DndFocus<D: SeatHandler>: WaylandFocus + IsAlive + PartialEq {
+    /// OfferData implementation returned by this target
+    type OfferData<S>: OfferData
+    where
+        S: Source;
+
+    /// An active Drag'n'Drop operation has entered the client
+    fn enter<S: Source>(
+        &self,
+        data: &mut D,
+        #[cfg(feature = "wayland_frontend")] dh: &DisplayHandle,
+        source: Arc<S>,
+        seat: &Seat<D>,
+        location: Point<f64, Logical>,
+        serial: &Serial,
+    ) -> Option<Self::OfferData<S>>;
+
+    /// An active Drag'n'Drop operation, which has previously
+    /// entered the client, has been moved
+    fn motion<S: Source>(
+        &self,
+        data: &mut D,
+        offer: Option<&mut Self::OfferData<S>>,
+        seat: &Seat<D>,
+        location: Point<f64, Logical>,
+        time: u32,
+    );
+
+    /// An active Drag'n'Drop operation, which has previously
+    /// entered the client, left again.
+    fn leave<S: Source>(&self, data: &mut D, offer: Option<&mut Self::OfferData<S>>, seat: &Seat<D>);
+
+    /// An active Drag'n'Drop operation, which has previously
+    /// entered the client, has been dropped.
+    fn drop<S: Source>(&self, data: &mut D, offer: Option<&mut Self::OfferData<S>>, seat: &Seat<D>);
+}
+#[cfg(not(feature = "xwayland"))]
 /// A potential Drag'n'Drop target
 pub trait DndFocus<D: SeatHandler>: IsAlive + PartialEq {
     /// OfferData implementation returned by this target

src/xwayland/xwm/surface.rs

@@ -11,7 +11,10 @@ use crate::{
         Seat, SeatHandler,
     },
     utils::{user_data::UserDataMap, Client, IsAlive, Logical, Rectangle, Serial, Size},
-    wayland::{compositor, seat::keyboard::enter_internal},
+    wayland::{
+        compositor,
+        seat::{keyboard::enter_internal, WaylandFocus},
+    },
 };
 #[cfg(feature = "desktop")]
 use crate::{
@@ -22,6 +25,7 @@ use crate::{
 use atomic_float::AtomicF64;
 use encoding_rs::WINDOWS_1252;
 use std::{
+    borrow::Cow,
     collections::HashSet,
     sync::{
         atomic::{AtomicBool, Ordering},
@@ -1342,3 +1346,9 @@ impl<D: SeatHandler + 'static> TouchTarget<D> for X11Surface {
         }
     }
 }
+
+impl WaylandFocus for X11Surface {
+    fn wl_surface(&self) -> Option<Cow<'_, WlSurface>> {
+        X11Surface::wl_surface(self).map(Cow::Owned)
+    }
+}