HACK: xwm: filter out unmanaged windows on xdnd

Author: Drakulix

src/desktop/space/wayland/x11.rs

@@ -10,7 +10,7 @@ use crate::{
         },
         ImportAll, Renderer,
     },
-    desktop::{space::SpaceElement, utils::under_from_surface_tree, WindowSurfaceType},
+    desktop::{space::SpaceElement, WindowSurfaceType},
     utils::{Logical, Physical, Point, Rectangle, Scale},
     wayland::seat::WaylandFocus,
     xwayland::X11Surface,
@@ -32,11 +32,7 @@ impl SpaceElement for X11Surface {
     }
 
     fn is_in_input_region(&self, point: &Point<f64, Logical>) -> bool {
-        if let Some(surface) = X11Surface::wl_surface(self).as_ref() {
-            under_from_surface_tree(surface, *point, (0, 0), WindowSurfaceType::ALL).is_some()
-        } else {
-            false
-        }
+        X11Surface::surface_under(self, *point, (0, 0), WindowSurfaceType::all()).is_some()
     }
 
     fn set_activate(&self, activated: bool) {

src/desktop/wayland/window.rs

@@ -339,20 +339,29 @@ impl Window {
         surface_type: WindowSurfaceType,
     ) -> Option<(wl_surface::WlSurface, Point<i32, Logical>)> {
         let point = point.into();
-        if let Some(surface) = self.wl_surface() {
-            if surface_type.contains(WindowSurfaceType::POPUP) {
-                for (popup, location) in PopupManager::popups_for_surface(&surface) {
-                    let offset = self.geometry().loc + location - popup.geometry().loc;
-                    if let Some(result) =
-                        under_from_surface_tree(popup.wl_surface(), point, offset, surface_type)
-                    {
-                        return Some(result);
+
+        match &self.0.surface {
+            WindowSurface::Wayland(surface) => {
+                let surface = surface.wl_surface();
+                if surface_type.contains(WindowSurfaceType::POPUP) {
+                    for (popup, location) in PopupManager::popups_for_surface(&surface) {
+                        let offset = self.geometry().loc + location - popup.geometry().loc;
+                        if let Some(result) =
+                            under_from_surface_tree(popup.wl_surface(), point, offset, surface_type)
+                        {
+                            return Some(result);
+                        }
                     }
                 }
-            }
 
-            if surface_type.contains(WindowSurfaceType::TOPLEVEL) {
-                return under_from_surface_tree(&surface, point, (0, 0), surface_type);
+                if surface_type.contains(WindowSurfaceType::TOPLEVEL) {
+                    return under_from_surface_tree(&surface, point, (0, 0), surface_type);
+                }
+            }
+            WindowSurface::X11(surface) => {
+                if surface_type.contains(WindowSurfaceType::TOPLEVEL) {
+                    return surface.surface_under(point, (0, 0), surface_type);
+                }
             }
         }
 

src/xwayland/xwm/dnd.rs

@@ -4,7 +4,10 @@ use std::{
     collections::HashMap,
     fmt,
     os::fd::OwnedFd,
-    sync::{atomic::Ordering, Arc, Mutex, Weak},
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc, Mutex, Weak,
+    },
 };
 
 use atomic_float::AtomicF64;
@@ -52,6 +55,7 @@ pub struct XWmDnd {
     pub selection: XWmSelection,
     pub active_offer: Option<XwmActiveOffer>,
     pub active_drag: Option<XwmActiveDrag>,
+    pub xdnd_active: Arc<AtomicBool>,
 }
 
 impl XWmDnd {
@@ -71,6 +75,7 @@ impl XWmDnd {
             selection,
             active_offer: None,
             active_drag: None,
+            xdnd_active: Arc::new(AtomicBool::new(false)),
         })
     }
 
@@ -131,12 +136,14 @@ impl XWmDnd {
 
                 let active_drag = xwm.dnd.active_drag.take().unwrap();
                 active_drag.state.lock().unwrap().x11 = X11State::Finished;
+                xwm.dnd.xdnd_active.store(false, Ordering::Release);
             }
         }
 
         if event.owner == x11rb::NONE {
             trace!("XDND selection went away");
             xwm.dnd.active_drag.take();
+            xwm.dnd.xdnd_active.store(false, Ordering::Release);
             return Ok(());
         }
 
@@ -228,6 +235,7 @@ impl XWmDnd {
             state,
             pending_transfers: xwm.dnd.selection.pending_transfers.clone(),
         });
+        xwm.dnd.xdnd_active.store(true, Ordering::Release);
 
         // create the DndGrab
         match (ptr_grab, touch_grab) {
@@ -518,6 +526,7 @@ impl XWmDnd {
             if matches!(&state.wayland, &WlState::Cancelled | &WlState::Finished) {
                 std::mem::drop(state);
                 self.active_drag.take();
+                self.xdnd_active.store(false, Ordering::Release);
             }
         }
         Ok(())
@@ -1085,6 +1094,7 @@ impl<D: XwmHandler + SeatHandler> DndFocus<D> for X11Surface {
             // the x11 source was presumably dropped on an x11 window, so we are done here.
             if let Some(active_drag) = xwm.dnd.active_drag.take() {
                 active_drag.state.lock().unwrap().x11 = X11State::Finished;
+                xwm.dnd.xdnd_active.store(false, Ordering::Release);
             }
             return;
         };

src/xwayland/xwm/mod.rs

@@ -1344,6 +1344,7 @@ where
                 Arc::downgrade(&conn),
                 xwm.atoms,
                 geometry,
+                xwm.dnd.xdnd_active.clone(),
             );
             surface.update_properties()?;
             xwm.windows.push(surface.clone());

src/xwayland/xwm/surface.rs

@@ -1,5 +1,6 @@
 use crate::{
     backend::input::KeyState,
+    desktop::{utils::under_from_surface_tree, WindowSurfaceType},
     input::{
         keyboard::{KeyboardTarget, KeysymHandle, ModifiersState},
         pointer::{
@@ -10,14 +11,17 @@ use crate::{
         touch::TouchTarget,
         Seat, SeatHandler,
     },
-    utils::{user_data::UserDataMap, Client, IsAlive, Logical, Rectangle, Serial, Size},
+    utils::{user_data::UserDataMap, Client, IsAlive, Logical, Point, Rectangle, Serial, Size},
     wayland::{compositor, seat::keyboard::enter_internal},
 };
 use atomic_float::AtomicF64;
 use encoding_rs::WINDOWS_1252;
 use std::{
     collections::HashSet,
-    sync::{atomic::Ordering, Arc, Mutex, Weak},
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc, Mutex, Weak,
+    },
 };
 use tracing::warn;
 use wayland_server::protocol::wl_surface::WlSurface;
@@ -48,6 +52,7 @@ pub struct X11Surface {
     pub(super) conn: Weak<RustConnection>,
     pub(super) atoms: super::Atoms,
     pub(crate) state: Arc<Mutex<SharedSurfaceState>>,
+    pub(super) xdnd_active: Arc<AtomicBool>,
     user_data: Arc<UserDataMap>,
 }
 
@@ -182,6 +187,7 @@ impl X11Surface {
         conn: Weak<RustConnection>,
         atoms: super::Atoms,
         geometry: Rectangle<i32, Logical>,
+        xdnd_active: Arc<AtomicBool>,
     ) -> X11Surface {
         X11Surface {
             xwm: xwm.map(|wm| wm.id),
@@ -212,6 +218,7 @@ impl X11Surface {
                 opacity: None,
                 pending_enter: None,
             })),
+            xdnd_active,
             user_data: Arc::new(UserDataMap::new()),
         }
     }
@@ -1018,6 +1025,33 @@ impl X11Surface {
         }
         Ok(0)
     }
+
+    /// Returns the topmost (sub-)surface under a given position of the surface.
+    ///
+    /// In case the window is not mapped or is unmanaged while an XDND operation is on-going the point [`None`] is returned.
+    ///
+    /// - `point` has to be the position to query, relative to (0, 0) of the given surface + `location`.
+    /// - `location` can be used to offset the returned point.
+    /// - `surface_type` can be used to filter the underlying surface tree
+    #[cfg(feature = "desktop")]
+    pub fn surface_under(
+        &self,
+        point: Point<f64, Logical>,
+        location: impl Into<Point<i32, Logical>>,
+        surface_type: WindowSurfaceType,
+    ) -> Option<(WlSurface, Point<i32, Logical>)> {
+        if !surface_type.contains(WindowSurfaceType::TOPLEVEL) {
+            return None;
+        }
+        if self.xdnd_active.load(Ordering::Acquire) && self.is_override_redirect() {
+            return None;
+        }
+        if let Some(surface) = X11Surface::wl_surface(self).as_ref() {
+            return under_from_surface_tree(surface, point, location, surface_type);
+        }
+
+        return None;
+    }
 }
 
 /// Trait for objects, that represent an x11 window in some shape or form