monolith

public

Star0

Fork 0

Watch0

52 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `cce3ef7e0162`

tarball

atagen <boss@atagen.co>2026-10-16 22:41 UTC

15 files changed+622-50

monolith: start Xwayland lazily on the first X client

monolith claims an X display at startup and hands its sockets to XWayland::spawn as extra -listenfd arguments, so the connection that woke Xwayland is served by it. Spawning our own Xwayland was not an option, since xwayland-shell only trusts clients carrying smithay's private XWaylandClientData. Keyboard focus became an enum because Xwayland routes keys only to the window the WM gave X input focus.

Modified file: crates/monolith/Cargo.toml+1

@@ -32,6 +32,7 @@ smithay = { workspace = true, features = [

3232 "backend_libinput",

3333 "backend_udev",

3434 "backend_session_libseat",

35+ "xwayland",

3536 ] }

3637

 smithay-drm-extras = { git = "https://github.com/Smithay/smithay", rev = "023b78b1c5a05ca512767cacc07efca55fae8be4", default-features = false }

3738 xcursor = "0.3"

Modified file: crates/monolith/src/activation.rs+5 additions−1 deletions@@ -5,6 +5,7 @@
 use crate::state::State;
 use monolith_layout::{OutputId, TagId};
 use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
+use smithay::wayland::seat::WaylandFocus;
 use smithay::wayland::xdg_activation::{
     XdgActivationHandler, XdgActivationState, XdgActivationToken, XdgActivationTokenData,
 };
@@ -27,7 +28,10 @@ impl XdgActivationHandler for State {
 
     fn token_created(&mut self, _token: XdgActivationToken, data: XdgActivationTokenData) -> bool {
         let keyboard = self.seat.get_keyboard();
-        let focused = keyboard.as_ref().and_then(|k| k.current_focus());
+        let focused = keyboard
+            .as_ref()
+            .and_then(|k| k.current_focus())
+            .and_then(|f| f.wl_surface().map(|s| s.into_owned()));
         let may_focus = data.surface.is_some() && data.surface == focused;
         let (output, tag) = self.launch_context();
         data.user_data.insert_if_missing(|| Context {

Modified file: crates/monolith/src/capture.rs+1

@@ -220,6 +220,7 @@ impl State {

220220 &self.config.decoration,

221221 &mut self.borders,

222222 Some(output),

223+ self.xwayland.as_ref().map_or(&[], |x| &x.unmanaged),

223224 )),

224225 }

225226 elements

Modified file: crates/monolith/src/commands.rs+11 additions−5 deletions@@ -62,11 +62,14 @@ impl State {
         match cmd {
             Command::Spawn { argv } => self.spawn(&argv)?,
             Command::Close => {
-                if let Some(t) = focused
-                    .and_then(|w| self.windows.get(&w))
-                    .and_then(|w| w.toplevel())
-                {
-                    t.send_close();
+                if let Some(w) = focused.and_then(|w| self.windows.get(&w)) {
+                    match (w.toplevel(), w.x11_surface()) {
+                        (Some(t), _) => t.send_close(),
+                        (_, Some(x)) => {
+                            let _ = x.close();
+                        }
+                        _ => {}
+                    }
                 }
             }
             Command::Quit => self.signal.stop(),
@@ -177,6 +180,9 @@ impl State {
             cmd.env("XDG_CURRENT_DESKTOP", "monolith")
                 .env("XDG_SESSION_TYPE", "wayland");
         }
+        if let Some(x) = &self.xwayland {
+            cmd.env("DISPLAY", format!(":{}", x.display));
+        }
         let token = self.launch_token();
         cmd.env("XDG_ACTIVATION_TOKEN", &token)
             .env("DESKTOP_STARTUP_ID", &token);

Modified file: crates/monolith/src/drm.rs+2 additions@@ -592,6 +592,7 @@ fn render_surface(state: &mut State, crtc: crtc::Handle, target: u64) -> bool {
         pointer_pos,
         lock,
         captures,
+        xwayland,
         ..
     } = state
     else {
@@ -652,6 +653,7 @@ fn render_surface(state: &mut State, crtc: crtc::Handle, target: u64) -> bool {
             &config.decoration,
             borders,
             Some(&surface.output),
+            xwayland.as_ref().map_or(&[], |x| &x.unmanaged),
         )),
     }
     let scene_ns = scene_began.elapsed().as_nanos() as u64;

Added file: crates/monolith/src/focus.rs+92 additions@@ -0,0 +1,92 @@
+//! Keyboard focus targets. X11 windows need their own target, since
+//! Xwayland only routes keys to the window the WM gave X input focus.
+
+use crate::state::State;
+use smithay::backend::input::KeyState;
+use smithay::input::Seat;
+use smithay::input::keyboard::{KeyboardTarget, KeysymHandle, ModifiersState};
+use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
+use smithay::utils::{IsAlive, Serial};
+use smithay::wayland::seat::WaylandFocus;
+use smithay::xwayland::X11Surface;
+use std::borrow::Cow;
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum Focus {
+    Surface(WlSurface),
+    X11(Box<X11Surface>),
+}
+
+impl From<WlSurface> for Focus {
+    fn from(s: WlSurface) -> Self {
+        Focus::Surface(s)
+    }
+}
+
+impl IsAlive for Focus {
+    fn alive(&self) -> bool {
+        match self {
+            Focus::Surface(s) => s.alive(),
+            Focus::X11(x) => x.alive(),
+        }
+    }
+}
+
+impl WaylandFocus for Focus {
+    fn wl_surface(&self) -> Option<Cow<'_, WlSurface>> {
+        match self {
+            Focus::Surface(s) => Some(Cow::Borrowed(s)),
+            Focus::X11(x) => x.wl_surface().map(Cow::Owned),
+        }
+    }
+}
+
+impl KeyboardTarget<State> for Focus {
+    fn enter(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        keys: Vec<KeysymHandle<'_>>,
+        serial: Serial,
+    ) {
+        match self {
+            Focus::Surface(s) => KeyboardTarget::enter(s, seat, data, keys, serial),
+            Focus::X11(x) => KeyboardTarget::enter(x.as_ref(), seat, data, keys, serial),
+        }
+    }
+
+    fn leave(&self, seat: &Seat<State>, data: &mut State, serial: Serial) {
+        match self {
+            Focus::Surface(s) => KeyboardTarget::leave(s, seat, data, serial),
+            Focus::X11(x) => KeyboardTarget::leave(x.as_ref(), seat, data, serial),
+        }
+    }
+
+    fn key(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        key: KeysymHandle<'_>,
+        state: KeyState,
+        serial: Serial,
+        time: smithay::backend::input::InputTime,
+    ) {
+        match self {
+            Focus::Surface(s) => KeyboardTarget::key(s, seat, data, key, state, serial, time),
+            Focus::X11(x) => KeyboardTarget::key(x.as_ref(), seat, data, key, state, serial, time),
+        }
+    }
+
+    fn modifiers(
+        &self,
+        seat: &Seat<State>,
+        data: &mut State,
+        modifiers: ModifiersState,
+        serial: Serial,
+    ) {
+        match self {
+            Focus::Surface(s) => KeyboardTarget::modifiers(s, seat, data, modifiers, serial),
+            Focus::X11(x) => KeyboardTarget::modifiers(x.as_ref(), seat, data, modifiers, serial),
+        }
+    }
+}

Modified file: crates/monolith/src/handlers.rs+11 additions−5 deletions@@ -25,6 +25,7 @@ use smithay::wayland::dmabuf::{
     DmabufGlobal, DmabufHandler, DmabufState, ImportNotifier, get_dmabuf,
 };
 use smithay::wayland::output::OutputHandler;
+use smithay::wayland::seat::WaylandFocus;
 use smithay::wayland::selection::SelectionHandler;
 use smithay::wayland::selection::primary_selection::{
     PrimarySelectionHandler, PrimarySelectionState, set_primary_focus,
@@ -51,6 +52,9 @@ impl CompositorHandler for State {
     }
 
     fn client_compositor_state<'a>(&self, client: &'a Client) -> &'a CompositorClientState {
+        if let Some(x) = client.get_data::<smithay::xwayland::XWaylandClientData>() {
+            return &x.compositor_state;
+        }
         &client
             .get_data::<ClientState>()
             .expect("every client has ClientState")
@@ -73,7 +77,7 @@ impl CompositorHandler for State {
                 .windows
                 .values()
                 .chain(&self.unmapped)
-                .find(|w| w.toplevel().is_some_and(|t| t.wl_surface() == &root))
+                .find(|w| crate::state::root(w).as_ref() == Some(&root))
             {
                 window.on_commit();
             }
@@ -85,7 +89,7 @@ impl CompositorHandler for State {
         {
             let window = self.unmapped.remove(i);
             let toplevel = window.toplevel().cloned();
-            self.map_window(window);
+            self.map_window(window, None);
             if let Some(t) = toplevel {
                 t.send_configure();
             }
@@ -174,7 +178,7 @@ impl XdgShellHandler for State {
 }
 
 impl SeatHandler for State {
-    type KeyboardFocus = WlSurface;
+    type KeyboardFocus = crate::focus::Focus;
     type PointerFocus = WlSurface;
     type TouchFocus = WlSurface;
 
@@ -187,8 +191,10 @@ impl SeatHandler for State {
         self.needs_redraw = true;
     }
 
-    fn focus_changed(&mut self, seat: &Seat<Self>, focused: Option<&WlSurface>) {
-        let client = focused.and_then(|s| self.display.get_client(s.id()).ok());
+    fn focus_changed(&mut self, seat: &Seat<Self>, focused: Option<&crate::focus::Focus>) {
+        let client = focused
+            .and_then(|f| f.wl_surface())
+            .and_then(|s| self.display.get_client(s.id()).ok());
         set_data_device_focus(&self.display, seat, client.clone());
         set_primary_focus(&self.display, seat, client);
     }

Modified file: crates/monolith/src/idle.rs+1−1

@@ -43,7 +43,7 @@ impl State {

4343 }

4444 self.space

4545 .elements()

46- .any(|w| w.toplevel().is_some_and(|t| t.wl_surface() == &root))

46+ .any(|w| crate::state::root(w).as_ref() == Some(&root))

4747 || self.layer_maps_contain(&root)

4848 });

4949 if shown != self.inhibited {

Modified file: crates/monolith/src/input.rs+2 additions−2 deletions@@ -153,8 +153,8 @@ fn focus_under_pointer(state: &mut State) {
     let id = state
         .space
         .element_under(pos)
-        .and_then(|(w, _)| w.toplevel())
-        .and_then(|t| state.window_id(t.wl_surface()));
+        .and_then(|(w, _)| crate::state::root(w))
+        .and_then(|s| state.window_id(&s));
     if let Some(id) = id
         && state.layout.focused() != Some(id)
     {

Modified file: crates/monolith/src/ipc.rs+1 additions−6 deletions@@ -172,12 +172,7 @@ fn snapshot(state: &State) -> monolith_ipc::State {
     let mut windows: Vec<monolith_ipc::Window> = l
         .windows()
         .map(|(id, w)| {
-            let (app_id, title) = state
-                .windows
-                .get(&id)
-                .and_then(|w| w.toplevel())
-                .map(identity)
-                .unwrap_or_default();
+            let (app_id, title) = state.windows.get(&id).map(identity).unwrap_or_default();
             monolith_ipc::Window {
                 id: slotmap::Key::data(&id).as_ffi(),
                 app_id,

Modified file: crates/monolith/src/main.rs+9 additions@@ -4,6 +4,7 @@ mod capture;
 mod commands;
 mod cursor;
 mod drm;
+mod focus;
 mod handlers;
 mod idle;
 mod input;
@@ -14,6 +15,7 @@ mod lock;
 mod nested;
 mod scene;
 mod state;
+mod xwayland;
 
 #[cfg(feature = "spans")]
 mod slow_spans;
@@ -140,6 +142,12 @@ fn export_session(state: &State) {
         ))
         .arg("XDG_CURRENT_DESKTOP=monolith")
         .arg("XDG_SESSION_TYPE=wayland")
+        .args(
+            state
+                .xwayland
+                .as_ref()
+                .map(|x| format!("DISPLAY=:{}", x.display)),
+        )
         .stdin(std::process::Stdio::null())
         .spawn();
     match result {
@@ -172,6 +180,7 @@ fn run(
         None => nested::init(&mut event_loop, &mut state)?,
     }
     ipc::init(&event_loop, &mut state)?;
+    xwayland::init(&mut state);
     tracing::info!(socket = ?state.socket_name, device = state.renderer.device_name(), "monolith running");
 
     if gpu.is_some() {

Modified file: crates/monolith/src/nested/mod.rs+2 additions@@ -181,6 +181,7 @@ pub fn render(state: &mut State) {
         output_id,
         lock,
         captures,
+        xwayland,
         ..
     } = state;
     let Some(host) = host.as_mut() else { return };
@@ -236,6 +237,7 @@ pub fn render(state: &mut State) {
                 &config.decoration,
                 borders,
                 Some(&host.output),
+                xwayland.as_ref().map_or(&[], |x| &x.unmanaged),
             )
         });
         match host

Modified file: crates/monolith/src/scene.rs+17 additions−2 deletions@@ -8,6 +8,7 @@ use monolith_render_vk::{Effect, VulkanFrame, VulkanRenderer, VulkanTexture};
 use smithay::backend::renderer::element::memory::MemoryRenderBufferRenderElement;
 use smithay::backend::renderer::element::solid::{SolidColorBuffer, SolidColorRenderElement};
 use smithay::backend::renderer::element::surface::WaylandSurfaceRenderElement;
+use smithay::backend::renderer::element::surface::render_elements_from_surface_tree;
 use smithay::backend::renderer::element::texture::TextureRenderElement;
 use smithay::backend::renderer::element::utils::{CropRenderElement, RescaleRenderElement};
 use smithay::backend::renderer::element::{AsRenderElements, Element, Id, Kind, RenderElement};
@@ -19,6 +20,7 @@ use smithay::output::Output;
 use smithay::utils::user_data::UserDataMap;
 use smithay::utils::{Buffer, Logical, Physical, Point, Rectangle, Scale, Size, Transform};
 use smithay::wayland::shell::wlr_layer::Layer;
+use smithay::xwayland::X11Surface;
 use std::collections::HashMap;
 
 smithay::backend::renderer::element::render_elements! {
@@ -50,6 +52,7 @@ pub fn build(
     deco: &Decoration,
     borders: &mut Borders,
     output: Option<&Output>,
+    unmanaged: &[X11Surface],
 ) -> Vec<Draw> {
     let Some(area) = layout.output(o).map(|out| out.area) else {
         return Vec::new();
@@ -90,6 +93,18 @@ pub fn build(
     borders.0.retain(|id, _| windows.contains_key(id));
     let focused = layout.focused();
     let mut out = Vec::new();
+    for x in unmanaged.iter().rev() {
+        let Some(surface) = x.wl_surface() else {
+            continue;
+        };
+        let loc = x.geometry().loc;
+        let at = Point::<i32, Physical>::from((loc.x - area.x as i32, loc.y - area.y as i32));
+        out.extend(
+            render_elements_from_surface_tree(renderer, &surface, at, 1.0, 1.0, Kind::Unspecified)
+                .into_iter()
+                .map(Draw::Surface),
+        );
+    }
     if let Some(output) = output {
         crate::layers::elements(&mut out, renderer, output, Layer::Overlay);
         if !fullscreen_at_rest {
@@ -185,7 +200,7 @@ fn window_elements(
             .filter_map(|e| CropRenderElement::from_element(e, 1.0, crop))
             .map(Draw::Cropped),
     );
-    let Some(root) = window.toplevel().map(|t| t.wl_surface().clone()) else {
+    let Some(root) = crate::state::root(window) else {
         return;
     };
     let context = renderer.context_id();
@@ -302,7 +317,7 @@ fn effect_elements(
     (at, size): ((i32, i32), (i32, i32)),
     effect: Effect,
 ) {
-    let Some(root) = window.toplevel().map(|t| t.wl_surface().clone()) else {
+    let Some(root) = crate::state::root(window) else {
         return;
     };
     let root_id = Id::from_wayland_resource(&root);

Modified file: crates/monolith/src/state.rs+85 additions−28 deletions@@ -1,5 +1,6 @@
 use crate::anim::{Animator, Ghost};
 use crate::commands::Binds;
+use crate::focus::Focus;
 use crate::nested::Host;
 use monolith_config::Config;
 use monolith_layout::{Layout, OutputId, Rect, WindowId};
@@ -9,6 +10,7 @@ use monolith_render_vk::VulkanTexture;
 use smithay::backend::renderer::ImportDma;
 use smithay::backend::renderer::Renderer;
 use smithay::backend::renderer::utils::{import_surface_tree, with_renderer_surface_state};
+use smithay::desktop::utils::under_from_surface_tree;
 use smithay::desktop::{PopupManager, Space, Window, WindowSurfaceType};
 use smithay::input::keyboard::{Keycode, XkbConfig};
 use smithay::input::pointer::CursorImageStatus;
@@ -21,7 +23,7 @@ use smithay::reexports::wayland_protocols::xdg::shell::server::xdg_toplevel::Sta
 use smithay::reexports::wayland_server::backend::{ClientData, ClientId, DisconnectReason};
 use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
 use smithay::reexports::wayland_server::{Display, DisplayHandle, Resource};
-use smithay::utils::{Clock, Logical, Monotonic, Point, SERIAL_COUNTER, Size};
+use smithay::utils::{Clock, Logical, Monotonic, Point, Rectangle, SERIAL_COUNTER, Size};
 use smithay::wayland::compositor::{CompositorClientState, CompositorState, with_states};
 use smithay::wayland::dmabuf::{DmabufGlobal, DmabufState};
 use smithay::wayland::idle_inhibit::IdleInhibitManagerState;
@@ -29,6 +31,7 @@ use smithay::wayland::idle_notify::IdleNotifierState;
 use smithay::wayland::image_capture_source::{ImageCaptureSourceState, OutputCaptureSourceState};
 use smithay::wayland::image_copy_capture::ImageCopyCaptureState;
 use smithay::wayland::output::OutputManagerState;
+use smithay::wayland::seat::WaylandFocus;
 use smithay::wayland::selection::data_device::DataDeviceState;
 use smithay::wayland::selection::ext_data_control::DataControlState as ExtDataControlState;
 use smithay::wayland::selection::primary_selection::PrimarySelectionState;
@@ -40,6 +43,7 @@ use smithay::wayland::shell::xdg::{XdgShellState, XdgToplevelSurfaceData};
 use smithay::wayland::shm::ShmState;
 use smithay::wayland::socket::ListeningSocketSource;
 use smithay::wayland::xdg_activation::XdgActivationState;
+use smithay::wayland::xwayland_shell::XWaylandShellState;
 use std::collections::{HashMap, HashSet};
 use std::ffi::OsString;
 use std::path::PathBuf;
@@ -90,6 +94,8 @@ pub struct State {
     pub placed_by_rule: HashSet<WindowId>,
     /// A layer surface given the keyboard by a click, like a launcher.
     pub layer_focus: Option<WlSurface>,
+    pub xwayland: Option<crate::xwayland::Xwayland>,
+    pub xwayland_shell_state: XWaylandShellState,
     pub captures: crate::capture::Captures,
     /// The render node clients get dmabufs for, known on bare metal.
     pub render_node: Option<smithay::backend::drm::DrmNode>,
@@ -205,6 +211,8 @@ impl State {
             awaiting: HashSet::new(),
             placed_by_rule: HashSet::new(),
             layer_focus: None,
+            xwayland: None,
+            xwayland_shell_state: XWaylandShellState::new::<State>(&dh),
             captures: Default::default(),
             render_node: None,
             lock: Default::default(),
@@ -277,14 +285,18 @@ impl State {
 
     /// Adds a toplevel to the layout on its first commit, where its app_id
     /// and title are known and the initial configure can carry its size.
-    pub fn map_window(&mut self, window: Window) {
-        let (app_id, title) = window.toplevel().map(identity).unwrap_or_default();
+    pub fn map_window(&mut self, window: Window, float: Option<Rectangle<i32, Logical>>) {
+        let (app_id, title) = identity(&window);
         let rule = self.config.placement(&app_id, &title);
-        let launch = window
-            .toplevel()
-            .and_then(|t| t.wl_surface().client())
-            .and_then(|c| c.get_credentials(&self.display).ok())
-            .and_then(|c| self.launches.find(c.pid as u32));
+        let pid = match window.x11_surface() {
+            Some(x) => x.pid(),
+            None => window
+                .toplevel()
+                .and_then(|t| t.wl_surface().client())
+                .and_then(|c| c.get_credentials(&self.display).ok())
+                .map(|c| c.pid as u32),
+        };
+        let launch = pid.and_then(|pid| self.launches.find(pid));
         let output = rule
             .output
             .as_deref()
@@ -299,7 +311,15 @@ impl State {
             Some(t) => Some(self.layout.tag(t)),
             None => launch.map(|l| l.1),
         };
-        let id = self.layout.add_window(output, tag, None);
+        let float = float.map(|r| {
+            Rect::new(
+                f64::from(r.loc.x),
+                f64::from(r.loc.y),
+                f64::from(r.size.w),
+                f64::from(r.size.h),
+            )
+        });
+        let id = self.layout.add_window(output, tag, float);
         if rule.tag.is_some() || rule.output.is_some() {
             self.placed_by_rule.insert(id);
         }
@@ -353,19 +373,22 @@ impl State {
     }
 
     pub fn unmap_window(&mut self, surface: &WlSurface) {
-        self.unmapped
-            .retain(|w| w.toplevel().is_some_and(|t| t.wl_surface() != surface));
+        self.unmapped.retain(|w| root(w).as_ref() != Some(surface));
         if let Some(id) = self.window_id(surface) {
-            if let Some(window) = self.windows.remove(&id) {
-                self.space.unmap_elem(&window);
-                self.leave_ghost(id, &window);
-            }
-            self.layout.remove_window(id);
-            self.placed_by_rule.remove(&id);
-            self.apply_layout();
+            self.remove_window(id);
         }
     }
 
+    pub fn remove_window(&mut self, id: WindowId) {
+        if let Some(window) = self.windows.remove(&id) {
+            self.space.unmap_elem(&window);
+            self.leave_ghost(id, &window);
+        }
+        self.layout.remove_window(id);
+        self.placed_by_rule.remove(&id);
+        self.apply_layout();
+    }
+
     /// Keeps a visible tiled window's last frame shrinking to its seed while
     /// its neighbours close over it.
     fn leave_ghost(&mut self, id: WindowId, window: &Window) {
@@ -388,7 +411,7 @@ impl State {
         else {
             return;
         };
-        let Some(surface) = window.toplevel().map(|t| t.wl_surface().clone()) else {
+        let Some(surface) = root(window) else {
             return;
         };
         let _ = import_surface_tree(&mut self.renderer, &surface);
@@ -416,7 +439,7 @@ impl State {
     pub fn window_id(&self, surface: &WlSurface) -> Option<WindowId> {
         self.windows
             .iter()
-            .find(|(_, w)| w.toplevel().is_some_and(|t| t.wl_surface() == surface))
+            .find(|(_, w)| root(w).as_ref() == Some(surface))
             .map(|(id, _)| *id)
     }
 
@@ -541,14 +564,15 @@ impl State {
                 t.send_pending_configure();
             }
         }
-        let target = if self.lock.active() {
-            self.lock_keyboard_focus()
+        let target: Option<Focus> = if self.lock.active() {
+            self.lock_keyboard_focus().map(Focus::from)
         } else {
-            self.layer_keyboard_focus().or_else(|| {
-                focused
-                    .and_then(|id| self.windows.get(&id))
-                    .and_then(|w| w.toplevel())
-                    .map(|t| t.wl_surface().clone())
+            self.layer_keyboard_focus().map(Focus::from).or_else(|| {
+                let w = focused.and_then(|id| self.windows.get(&id))?;
+                match w.x11_surface() {
+                    Some(x) => Some(Focus::X11(Box::new(x.clone()))),
+                    None => w.toplevel().map(|t| Focus::from(t.wl_surface().clone())),
+                }
             })
         };
         if let Some(keyboard) = self.seat.get_keyboard()
@@ -611,6 +635,21 @@ impl State {
         if self.lock.active() {
             return self.lock_surface_under(pos);
         }
+        let unmanaged = self.xwayland.iter().flat_map(|x| x.unmanaged.iter().rev());
+        for x in unmanaged {
+            let geo = x.geometry();
+            if let Some(s) = x.wl_surface()
+                && geo.to_f64().contains(pos)
+                && let Some((s, p)) = under_from_surface_tree(
+                    &s,
+                    pos - geo.loc.to_f64(),
+                    (0, 0),
+                    WindowSurfaceType::ALL,
+                )
+            {
+                return Some((s, (p + geo.loc).to_f64()));
+            }
+        }
         let fullscreen = self.layout.outputs().any(|(o, out)| {
             let a = out.area;
             (a.x..a.right()).contains(&pos.x)
@@ -653,6 +692,12 @@ fn configure(window: &Window, rect: Rect, kind: Kind, maximized: bool) -> bool {
     if w < 1 || h < 1 {
         return false;
     }
+    let (x0, y0) = (x as i32, y as i32);
+    if let Some(x) = window.x11_surface() {
+        let _ = x.configure(Rectangle::new((x0, y0).into(), (w, h).into()));
+        let _ = x.set_fullscreen(kind == Kind::Fullscreen);
+        let _ = x.set_maximized(maximized && kind == Kind::Tiled);
+    }
     if let Some(t) = window.toplevel() {
         t.with_pending_state(|s| {
             s.size = Some((w, h).into());
@@ -691,7 +736,19 @@ pub fn now_ns() -> u64 {
     Duration::from(Clock::<Monotonic>::new().now()).as_nanos() as u64
 }
 
-pub fn identity(t: &smithay::wayland::shell::xdg::ToplevelSurface) -> (String, String) {
+/// A window's surface, for xdg toplevels and X11 windows alike.
+pub fn root(window: &Window) -> Option<WlSurface> {
+    window.wl_surface().map(|s| s.into_owned())
+}
+
+/// A window's app id and title. X11 windows give their class.
+pub fn identity(window: &Window) -> (String, String) {
+    if let Some(x) = window.x11_surface() {
+        return (x.class(), x.title());
+    }
+    let Some(t) = window.toplevel() else {
+        return Default::default();
+    };
     with_states(t.wl_surface(), |s| {
         let data = s
             .data_map

Added file: crates/monolith/src/xwayland.rs+382 additions@@ -0,0 +1,382 @@
+//! Lazy Xwayland. monolith owns an X display socket from startup and only
+//! starts Xwayland when a client connects, handing it the socket so the
+//! connection that woke it is served. Xwayland exits once its last client
+//! leaves and the socket is watched again.
+
+use crate::state::State;
+use smithay::desktop::Window;
+use smithay::reexports::calloop::generic::Generic;
+use smithay::reexports::calloop::{Interest, Mode, PostAction, RegistrationToken};
+use smithay::reexports::rustix::io::{FdFlags, fcntl_getfd, fcntl_setfd};
+use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
+use smithay::utils::{Logical, Rectangle};
+use smithay::wayland::xwayland_shell::{XWaylandShellHandler, XWaylandShellState};
+use smithay::xwayland::xwm::{Reorder, ResizeEdge, WmWindowType, XwmId};
+use smithay::xwayland::{X11Surface, X11Wm, XWayland, XWaylandEvent, XwmHandler};
+use std::os::fd::AsFd;
+use std::os::linux::net::SocketAddrExt;
+use std::os::unix::net::{SocketAddr, UnixListener};
+use std::process::Stdio;
+
+pub struct Xwayland {
+    pub display: u32,
+    listeners: Vec<UnixListener>,
+    watch: Vec<(usize, RegistrationToken)>,
+    running: bool,
+    pub wm: Option<X11Wm>,
+    /// Override-redirect windows such as menus and tooltips, bottom to top.
+    pub unmanaged: Vec<X11Surface>,
+}
+
+impl Drop for Xwayland {
+    fn drop(&mut self) {
+        let _ = std::fs::remove_file(socket_path(self.display));
+        let _ = std::fs::remove_file(lock_path(self.display));
+    }
+}
+
+fn socket_path(n: u32) -> String {
+    format!("/tmp/.X11-unix/X{n}")
+}
+
+fn lock_path(n: u32) -> String {
+    format!("/tmp/.X{n}-lock")
+}
+
+/// Claims the first free X display, taking over stale locks left by dead
+/// servers.
+fn claim() -> Option<(u32, Vec<UnixListener>)> {
+    let _ = std::fs::create_dir_all("/tmp/.X11-unix");
+    for n in 0..64 {
+        let lock = lock_path(n);
+        let created = std::fs::OpenOptions::new()
+            .write(true)
+            .create_new(true)
+            .open(&lock);
+        let file = match created {
+            Ok(f) => f,
+            Err(_) => {
+                let owner = std::fs::read_to_string(&lock)
+                    .ok()
+                    .and_then(|s| s.trim().parse::<u32>().ok());
+                let stale = owner
+                    .is_some_and(|pid| !std::path::Path::new(&format!("/proc/{pid}")).exists());
+                if !stale || std::fs::remove_file(&lock).is_err() {
+                    continue;
+                }
+                match std::fs::OpenOptions::new()
+                    .write(true)
+                    .create_new(true)
+                    .open(&lock)
+                {
+                    Ok(f) => f,
+                    Err(_) => continue,
+                }
+            }
+        };
+        use std::io::Write;
+        let _ = writeln!(&file, "{:>10}", std::process::id());
+        let path = socket_path(n);
+        let _ = std::fs::remove_file(&path);
+        let Ok(fs) = UnixListener::bind(&path) else {
+            let _ = std::fs::remove_file(&lock);
+            continue;
+        };
+        let mut listeners = vec![fs];
+        if let Ok(addr) = SocketAddr::from_abstract_name(path.as_bytes())
+            && let Ok(abs) = UnixListener::bind_addr(&addr)
+        {
+            listeners.push(abs);
+        }
+        return Some((n, listeners));
+    }
+    None
+}
+
+pub fn init(state: &mut State) {
+    let Some((number, listeners)) = claim() else {
+        tracing::warn!("no free X display, X11 clients will not run");
+        return;
+    };
+    let mut watch = Vec::new();
+    for (i, l) in listeners.iter().enumerate() {
+        let Ok(l) = l.try_clone() else { continue };
+        let token = state.handle.insert_source(
+            Generic::new(l, Interest::READ, Mode::Level),
+            move |_, _, state| {
+                start(state, i);
+                Ok(PostAction::Disable)
+            },
+        );
+        if let Ok(t) = token {
+            watch.push((i, t));
+        }
+    }
+    tracing::info!("X11 clients will start Xwayland on :{number}");
+    state.xwayland = Some(Xwayland {
+        display: number,
+        listeners,
+        watch,
+        running: false,
+        wm: None,
+        unmanaged: Vec::new(),
+    });
+}
+
+/// Waits for the next X client to knock.
+fn rearm(state: &mut State) {
+    let Some(x) = state.xwayland.as_mut() else {
+        return;
+    };
+    x.running = false;
+    for (_, t) in &x.watch {
+        let _ = state.handle.enable(t);
+    }
+}
+
+fn set_inherit(listeners: &[UnixListener], inherit: bool) {
+    for l in listeners {
+        let flags = fcntl_getfd(l.as_fd()).unwrap_or(FdFlags::CLOEXEC);
+        let flags = if inherit {
+            flags - FdFlags::CLOEXEC
+        } else {
+            flags | FdFlags::CLOEXEC
+        };
+        let _ = fcntl_setfd(l.as_fd(), flags);
+    }
+}
+
+fn start(state: &mut State, fired: usize) {
+    let Some(x) = state.xwayland.as_mut() else {
+        return;
+    };
+    if x.running {
+        return;
+    }
+    x.running = true;
+    for (i, t) in &x.watch {
+        if *i != fired {
+            state.handle.disable(t).ok();
+        }
+    }
+    let mut args = Vec::new();
+    for l in &x.listeners {
+        args.push("-listenfd".to_string());
+        args.push(std::os::fd::AsRawFd::as_raw_fd(l).to_string());
+    }
+    // smithay only passes on the sockets it creates itself, so ours are
+    // made inheritable just for this one spawn.
+    set_inherit(&x.listeners, true);
+    let spawned = XWayland::spawn(
+        &state.display,
+        None,
+        std::iter::empty::<(String, String)>(),
+        args,
+        false,
+        Stdio::null(),
+        Stdio::null(),
+        |_| {},
+    );
+    set_inherit(&x.listeners, false);
+    let (xwayland, client) = match spawned {
+        Ok(s) => s,
+        Err(e) => {
+            tracing::error!("cannot start Xwayland, X11 clients will not run: {e}");
+            return;
+        }
+    };
+    tracing::info!("starting Xwayland");
+    let inserted = state
+        .handle
+        .insert_source(xwayland, move |event, _, state| match event {
+            XWaylandEvent::Ready { x11_socket, .. } => {
+                let dh = state.display.clone();
+                match X11Wm::start_wm(state.handle.clone(), &dh, x11_socket, client.clone()) {
+                    Ok(wm) => {
+                        tracing::info!("Xwayland ready");
+                        if let Some(x) = state.xwayland.as_mut() {
+                            x.wm = Some(wm);
+                        }
+                    }
+                    Err(e) => tracing::error!("cannot manage Xwayland windows: {e}"),
+                }
+            }
+            XWaylandEvent::Error => {
+                tracing::warn!("Xwayland failed to start");
+                rearm(state);
+            }
+        });
+    if let Err(e) = inserted {
+        tracing::error!("cannot watch Xwayland: {e}");
+    }
+}
+
+impl XWaylandShellHandler for State {
+    fn xwayland_shell_state(&mut self) -> &mut XWaylandShellState {
+        &mut self.xwayland_shell_state
+    }
+
+    fn surface_associated(&mut self, _xwm: XwmId, surface: WlSurface, _window: X11Surface) {
+        self.on_buffer(&surface);
+        self.needs_redraw = true;
+    }
+}
+
+impl XwmHandler for State {
+    fn xwm_state(&mut self, _xwm: XwmId) -> &mut X11Wm {
+        self.xwayland
+            .as_mut()
+            .and_then(|x| x.wm.as_mut())
+            .expect("X11 events only arrive while the WM runs")
+    }
+
+    fn new_window(&mut self, _xwm: XwmId, _window: X11Surface) {}
+
+    fn new_override_redirect_window(&mut self, _xwm: XwmId, _window: X11Surface) {}
+
+    fn map_window_request(&mut self, _xwm: XwmId, window: X11Surface) {
+        if let Err(e) = window.set_mapped(true) {
+            tracing::warn!("cannot map X11 window: {e}");
+            return;
+        }
+        let float = floats(&window).then(|| window.geometry());
+        self.map_window(Window::new_x11_window(window), float);
+    }
+
+    fn mapped_override_redirect_window(&mut self, _xwm: XwmId, window: X11Surface) {
+        if let Some(x) = self.xwayland.as_mut() {
+            x.unmanaged.retain(|w| w != &window);
+            x.unmanaged.push(window);
+        }
+        self.needs_redraw = true;
+    }
+
+    fn unmapped_window(&mut self, _xwm: XwmId, window: X11Surface) {
+        self.forget_x11(&window);
+        if !window.is_override_redirect() {
+            let _ = window.set_mapped(false);
+        }
+    }
+
+    fn destroyed_window(&mut self, _xwm: XwmId, window: X11Surface) {
+        self.forget_x11(&window);
+    }
+
+    fn configure_request(
+        &mut self,
+        _xwm: XwmId,
+        window: X11Surface,
+        x: Option<i32>,
+        y: Option<i32>,
+        w: Option<u32>,
+        h: Option<u32>,
+        _reorder: Option<Reorder>,
+    ) {
+        if self.x11_window_id(&window).is_some() {
+            let _ = window.configure(None);
+            return;
+        }
+        let mut geo = window.geometry();
+        geo.loc.x = x.unwrap_or(geo.loc.x);
+        geo.loc.y = y.unwrap_or(geo.loc.y);
+        geo.size.w = w.map_or(geo.size.w, |w| w as i32);
+        geo.size.h = h.map_or(geo.size.h, |h| h as i32);
+        let _ = window.configure(geo);
+    }
+
+    fn configure_notify(
+        &mut self,
+        _xwm: XwmId,
+        window: X11Surface,
+        _geometry: Rectangle<i32, Logical>,
+        _above: Option<smithay::xwayland::xwm::X11Window>,
+    ) {
+        if window.is_override_redirect() {
+            self.needs_redraw = true;
+        }
+    }
+
+    fn resize_request(
+        &mut self,
+        _xwm: XwmId,
+        _window: X11Surface,
+        _button: u32,
+        _edge: ResizeEdge,
+    ) {
+    }
+
+    fn move_request(&mut self, _xwm: XwmId, _window: X11Surface, _button: u32) {}
+
+    fn fullscreen_request(&mut self, _xwm: XwmId, window: X11Surface) {
+        self.x11_fullscreen(&window, true);
+    }
+
+    fn unfullscreen_request(&mut self, _xwm: XwmId, window: X11Surface) {
+        self.x11_fullscreen(&window, false);
+    }
+
+    fn disconnected(&mut self, _xwm: XwmId) {
+        tracing::info!("Xwayland exited");
+        let gone: Vec<_> = self
+            .windows
+            .iter()
+            .filter(|(_, w)| w.x11_surface().is_some())
+            .map(|(id, _)| *id)
+            .collect();
+        for id in gone {
+            self.remove_window(id);
+        }
+        if let Some(x) = self.xwayland.as_mut() {
+            x.wm = None;
+            x.unmanaged.clear();
+        }
+        rearm(self);
+    }
+}
+
+/// Dialogs, splash screens and fixed-size windows float at their own size.
+fn floats(window: &X11Surface) -> bool {
+    let kind = matches!(
+        window.window_type(),
+        Some(
+            WmWindowType::Dialog
+                | WmWindowType::Splash
+                | WmWindowType::Utility
+                | WmWindowType::Toolbar
+                | WmWindowType::Menu
+        )
+    );
+    let fixed = matches!(
+        (window.min_size(), window.max_size()),
+        (Some(min), Some(max)) if min == max && min.w > 0
+    );
+    kind || fixed || window.is_transient_for().is_some()
+}
+
+impl State {
+    pub fn x11_window_id(&self, window: &X11Surface) -> Option<monolith_layout::WindowId> {
+        self.windows
+            .iter()
+            .find(|(_, w)| w.x11_surface() == Some(window))
+            .map(|(id, _)| *id)
+    }
+
+    fn forget_x11(&mut self, window: &X11Surface) {
+        if let Some(x) = self.xwayland.as_mut() {
+            x.unmanaged.retain(|w| w != window);
+        }
+        if let Some(id) = self.x11_window_id(window) {
+            self.remove_window(id);
+        }
+        self.needs_redraw = true;
+    }
+
+    fn x11_fullscreen(&mut self, window: &X11Surface, on: bool) {
+        if let Some(id) = self.x11_window_id(window)
+            && self.layout.window(id).is_some_and(|w| w.fullscreen != on)
+        {
+            self.layout.toggle_fullscreen(id);
+            self.apply_layout();
+        }
+    }
+}

monolith

Commit cce3ef7e0162

Commit `cce3ef7e0162`