monolith

public

Star0

Fork 0

Watch0

70 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `c7e08bac3e01`

tarball

atagen <boss@atagen.co>2026-10-17 02:46 UTC

14 files changed+134-94

monolith: gather subsystems into Services and idle state into Idle

Lock, capture, imports, Xwayland, launch tracking and the IPC server already had types of their own but sat as loose State fields. The idle notifier moves out of the protocol globals, since it is live state next to the inhibitor set it serves.

Modified file: crates/monolith/src/capture.rs+15 additions−9 deletions@@ -104,12 +104,15 @@ impl ImageCopyCaptureHandler for State {
     }
 
     fn new_session(&mut self, session: Session) {
-        self.captures.sessions.push(session);
+        self.services.captures.sessions.push(session);
     }
 
     fn frame(&mut self, session: &SessionRef, frame: Frame) {
         if session.user_data().get::<Delivered>().is_some() {
-            self.captures.waiting.push((session.clone(), frame));
+            self.services
+                .captures
+                .waiting
+                .push((session.clone(), frame));
             self.needs_redraw = true;
         } else {
             self.capture(session, frame);
@@ -117,7 +120,7 @@ impl ImageCopyCaptureHandler for State {
     }
 
     fn session_destroyed(&mut self, session: SessionRef) {
-        let c = &mut self.captures;
+        let c = &mut self.services.captures;
         c.sessions.retain(|s| *s != session);
         c.waiting.retain(|(s, _)| *s != session);
     }
@@ -126,17 +129,17 @@ impl ImageCopyCaptureHandler for State {
 impl State {
     /// Completes waiting frames whose target showed something new.
     pub fn complete_captures(&mut self) {
-        if self.captures.damaged.is_empty() {
+        if self.services.captures.damaged.is_empty() {
             return;
         }
-        let damaged = std::mem::take(&mut self.captures.damaged);
-        let (ready, waiting) = std::mem::take(&mut self.captures.waiting)
+        let damaged = std::mem::take(&mut self.services.captures.damaged);
+        let (ready, waiting) = std::mem::take(&mut self.services.captures.waiting)
             .into_iter()
             .partition::<Vec<_>, _>(|(s, _)| {
                 self.target(&s.source())
                     .is_some_and(|t| damaged.contains(&t))
             });
-        self.captures.waiting = waiting;
+        self.services.captures.waiting = waiting;
         for (session, frame) in ready {
             self.capture(&session, frame);
         }
@@ -275,7 +278,7 @@ impl State {
                 ));
             }
         }
-        match crate::lock::elements(&self.lock, &mut self.renderer, output) {
+        match crate::lock::elements(&self.services.lock, &mut self.renderer, output) {
             Some(locked) => elements.extend(locked),
             None => elements.extend(crate::scene::build(
                 &self.layout,
@@ -287,7 +290,10 @@ impl State {
                 &self.settings.config.decoration,
                 &mut self.borders,
                 Some(output),
-                self.xwayland.as_ref().map_or(&[], |x| &x.unmanaged),
+                self.services
+                    .xwayland
+                    .as_ref()
+                    .map_or(&[], |x| &x.unmanaged),
             )),
         }
         elements

Modified file: crates/monolith/src/commands.rs+3 additions−3 deletions@@ -173,14 +173,14 @@ impl State {
         cmd.args(args)
             .env("WAYLAND_DISPLAY", &self.core.socket_name)
             .stdin(Stdio::null());
-        if let Some(sock) = &self.ipc.path {
+        if let Some(sock) = &self.services.ipc.path {
             cmd.env("MONOLITH_SOCKET", sock);
         }
         if self.drm.is_some() {
             cmd.env("XDG_CURRENT_DESKTOP", "monolith")
                 .env("XDG_SESSION_TYPE", "wayland");
         }
-        if let Some(x) = &self.xwayland {
+        if let Some(x) = &self.services.xwayland {
             cmd.env("DISPLAY", format!(":{}", x.display));
         }
         let token = self.launch_token();
@@ -189,7 +189,7 @@ impl State {
         let mut child = cmd.spawn().map_err(|e| format!("{program}: {e}"))?;
         tracing::info!(pid = child.id(), ?argv, "spawned");
         let (output, tag) = self.launch_context();
-        self.launches.record(child.id(), output, tag);
+        self.services.launches.record(child.id(), output, tag);
         std::thread::spawn(move || child.wait());
         Ok(())
     }

Modified file: crates/monolith/src/drm.rs+8 additions−3 deletions@@ -3,6 +3,7 @@
 //! each rendered when its own vblank lands.
 
 use crate::scene::Draw;
+use crate::state::Services;
 use crate::state::{State, now_ns};
 use monolith_config::Vrr;
 use monolith_layout::{OutputId, Rect};
@@ -599,9 +600,13 @@ fn render_surface(state: &mut State, crtc: crtc::Handle, target: u64) -> bool {
         cursor,
         cursor_status,
         pointer_pos,
-        lock,
-        captures,
-        xwayland,
+        services:
+            Services {
+                lock,
+                captures,
+                xwayland,
+                ..
+            },
         ..
     } = state
     else {

Modified file: crates/monolith/src/globals.rs+1 additions−9 deletions@@ -6,14 +6,12 @@ use monolith_protocols::toplevel::ForeignToplevelState;
 use monolith_protocols::workspace::WorkspaceState;
 use monolith_render_vk::VulkanRenderer;
 use smithay::backend::renderer::ImportDma;
-use smithay::reexports::calloop::LoopHandle;
 use smithay::reexports::wayland_server::DisplayHandle;
 use smithay::wayland::compositor::CompositorState;
 use smithay::wayland::cursor_shape::CursorShapeManagerState;
 use smithay::wayland::dmabuf::{DmabufGlobal, DmabufState};
 use smithay::wayland::foreign_toplevel_list::ForeignToplevelListState;
 use smithay::wayland::idle_inhibit::IdleInhibitManagerState;
-use smithay::wayland::idle_notify::IdleNotifierState;
 use smithay::wayland::image_capture_source::{
     ImageCaptureSourceState, OutputCaptureSourceState, ToplevelCaptureSourceState,
 };
@@ -43,7 +41,6 @@ pub struct Protocols {
     pub wlr_data_control_state: WlrDataControlState,
     pub ext_data_control_state: ExtDataControlState,
     pub session_lock_state: SessionLockManagerState,
-    pub idle_notifier: IdleNotifierState<State>,
     pub shm_state: ShmState,
     pub dmabuf_state: DmabufState,
     pub data_device_state: DataDeviceState,
@@ -60,11 +57,7 @@ pub struct Protocols {
 }
 
 impl Protocols {
-    pub fn new(
-        dh: &DisplayHandle,
-        handle: LoopHandle<'static, State>,
-        renderer: &VulkanRenderer,
-    ) -> Self {
+    pub fn new(dh: &DisplayHandle, renderer: &VulkanRenderer) -> Self {
         let mut dmabuf_state = DmabufState::new();
         let dmabuf_global = dmabuf_state.create_global::<State>(dh, renderer.dmabuf_formats());
         let primary_selection_state = PrimarySelectionState::new::<State>(dh);
@@ -88,7 +81,6 @@ impl Protocols {
             ),
             primary_selection_state,
             session_lock_state: SessionLockManagerState::new::<State, _>(dh, |_| true),
-            idle_notifier: IdleNotifierState::new(dh, handle),
             shm_state: ShmState::new::<State>(dh, vec![]),
             dmabuf_state,
             data_device_state: DataDeviceState::new::<State>(dh),

Modified file: crates/monolith/src/handlers.rs+2 additions−2 deletions@@ -80,10 +80,10 @@ impl CompositorHandler for State {
             {
                 window.on_commit();
             }
-            if self.captures.wants_damage()
+            if self.services.captures.wants_damage()
                 && let Some(id) = self.window_id(&root)
             {
-                self.captures.window_damaged(id);
+                self.services.captures.window_damaged(id);
             }
         }
         if let Some(i) = self

Modified file: crates/monolith/src/idle.rs+28 additions−10 deletions@@ -2,26 +2,44 @@
 //! when the user went away and video players can keep the screen on.
 
 use crate::state::State;
-use smithay::reexports::wayland_server::Resource;
+use smithay::reexports::calloop::LoopHandle;
 use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
+use smithay::reexports::wayland_server::{DisplayHandle, Resource};
 use smithay::wayland::compositor::get_parent;
 use smithay::wayland::idle_inhibit::IdleInhibitHandler;
 use smithay::wayland::idle_notify::{IdleNotifierHandler, IdleNotifierState};
+use std::collections::HashSet;
+
+pub struct Idle {
+    pub notifier: IdleNotifierState<State>,
+    pub inhibitors: HashSet<WlSurface>,
+    pub inhibited: bool,
+}
+
+impl Idle {
+    pub fn new(dh: &DisplayHandle, handle: LoopHandle<'static, State>) -> Self {
+        Self {
+            notifier: IdleNotifierState::new(dh, handle),
+            inhibitors: HashSet::new(),
+            inhibited: false,
+        }
+    }
+}
 
 impl IdleNotifierHandler for State {
     fn idle_notifier_state(&mut self) -> &mut IdleNotifierState<Self> {
-        &mut self.protocols.idle_notifier
+        &mut self.services.idle.notifier
     }
 }
 
 impl IdleInhibitHandler for State {
     fn inhibit(&mut self, surface: WlSurface) {
-        self.inhibitors.insert(surface);
+        self.services.idle.inhibitors.insert(surface);
         self.update_inhibit();
     }
 
     fn uninhibit(&mut self, surface: WlSurface) {
-        self.inhibitors.remove(&surface);
+        self.services.idle.inhibitors.remove(&surface);
         self.update_inhibit();
     }
 }
@@ -29,14 +47,14 @@ impl IdleInhibitHandler for State {
 impl State {
     pub fn activity(&mut self) {
         let seat = self.seat.clone();
-        self.protocols.idle_notifier.notify_activity(&seat);
+        self.services.idle.notifier.notify_activity(&seat);
     }
 
     /// An inhibitor only counts while its surface is on screen, as the
     /// protocol asks, so a video on a hidden tag lets the screen blank.
     pub fn update_inhibit(&mut self) {
-        self.inhibitors.retain(|s| s.is_alive());
-        let shown = self.inhibitors.iter().any(|s| {
+        self.services.idle.inhibitors.retain(|s| s.is_alive());
+        let shown = self.services.idle.inhibitors.iter().any(|s| {
             let mut root = s.clone();
             while let Some(parent) = get_parent(&root) {
                 root = parent;
@@ -46,9 +64,9 @@ impl State {
                 .any(|w| crate::state::root(w).as_ref() == Some(&root))
                 || self.layer_maps_contain(&root)
         });
-        if shown != self.inhibited {
-            self.inhibited = shown;
-            self.protocols.idle_notifier.set_is_inhibited(shown);
+        if shown != self.services.idle.inhibited {
+            self.services.idle.inhibited = shown;
+            self.services.idle.notifier.set_is_inhibited(shown);
         }
     }
 }

Modified file: crates/monolith/src/import.rs+3 additions−3 deletions@@ -88,7 +88,7 @@ impl State {
             let _ = notifier.successful::<State>();
             return;
         }
-        self.imports.start(buffer).notifiers.push(notifier);
+        self.services.imports.start(buffer).notifiers.push(notifier);
     }
 
     /// A blocker for a commit whose dmabuf the renderer has not imported yet.
@@ -96,13 +96,13 @@ impl State {
         if self.renderer.has_dmabuf(buffer) {
             return None;
         }
-        let waiters = self.imports.start(buffer);
+        let waiters = self.services.imports.start(buffer);
         waiters.clients.push(client);
         Some(ImportBlocker(waiters.done.clone()))
     }
 
     fn imported(&mut self, buffer: Dmabuf, result: Result<VulkanTexture, String>) {
-        let Some(waiters) = self.imports.waiting.remove(&buffer.weak()) else {
+        let Some(waiters) = self.services.imports.waiting.remove(&buffer.weak()) else {
             return;
         };
         let result = result.and_then(|t| {

Modified file: crates/monolith/src/input.rs+2 additions−2 deletions@@ -38,7 +38,7 @@ impl State {
         if pressed == ButtonState::Released && self.drag.take().is_some() {
             return;
         }
-        if pressed == ButtonState::Pressed && !self.lock.active() {
+        if pressed == ButtonState::Pressed && !self.services.lock.active() {
             focus_under_pointer(self);
             if start_drag(self, button) {
                 return;
@@ -100,7 +100,7 @@ impl State {
                     let vt = (sym - xkb::keysyms::KEY_XF86Switch_VT_1 + 1) as i32;
                     return FilterResult::Intercept(Some(Action::Vt(vt)));
                 }
-                if state.lock.active() {
+                if state.services.lock.active() {
                     return FilterResult::Forward;
                 }
                 match state.settings.binds.find(mods, &handle.raw_syms()) {

Modified file: crates/monolith/src/ipc.rs+8 additions−8 deletions@@ -40,9 +40,9 @@ pub fn init(event_loop: &EventLoop<'static, State>, state: &mut State) -> std::i
     let listener = UnixListener::bind(&path)?;
     listener.set_nonblocking(true)?;
     tracing::info!(path = %path.display(), "control socket");
-    state.ipc.path = Some(path);
+    state.services.ipc.path = Some(path);
     let handle = event_loop.handle();
-    state.ipc.handle = Some(handle.clone());
+    state.services.ipc.handle = Some(handle.clone());
     handle
         .insert_source(
             Generic::new(listener, Interest::READ, Mode::Level),
@@ -62,7 +62,7 @@ pub fn init(event_loop: &EventLoop<'static, State>, state: &mut State) -> std::i
 }
 
 fn add_client(state: &mut State, stream: UnixStream) {
-    let Some(handle) = state.ipc.handle.clone() else {
+    let Some(handle) = state.services.ipc.handle.clone() else {
         return;
     };
     if stream.set_nonblocking(true).is_err() {
@@ -117,7 +117,7 @@ fn handle_line(state: &mut State, stream: &UnixStream, line: &[u8]) -> Option<En
                 return Some(Envelope::new(id, Reply::Error("cannot subscribe".into())));
             };
             send(&sub, &Envelope::new(None, Reply::Event(snapshot(state))));
-            state.ipc.subscribers.push(sub);
+            state.services.ipc.subscribers.push(sub);
             return None;
         }
     };
@@ -134,16 +134,16 @@ fn send(mut stream: &UnixStream, msg: &Envelope<Reply>) -> bool {
 
 /// Sends subscribers the new state whenever it differs from the last one.
 pub fn broadcast(state: &mut State) {
-    if state.ipc.subscribers.is_empty() {
+    if state.services.ipc.subscribers.is_empty() {
         return;
     }
     let now = snapshot(state);
-    if state.ipc.last.as_ref() == Some(&now) {
+    if state.services.ipc.last.as_ref() == Some(&now) {
         return;
     }
     let msg = Envelope::new(None, Reply::Event(now.clone()));
-    state.ipc.subscribers.retain(|s| send(s, &msg));
-    state.ipc.last = Some(now);
+    state.services.ipc.subscribers.retain(|s| send(s, &msg));
+    state.services.ipc.last = Some(now);
 }
 
 fn snapshot(state: &State) -> monolith_ipc::State {

Modified file: crates/monolith/src/lock.rs+15 additions−13 deletions@@ -55,8 +55,8 @@ impl SessionLockHandler for State {
 
     fn lock(&mut self, confirmation: SessionLocker) {
         tracing::info!("session lock requested");
-        self.lock.pending = Some(confirmation);
-        self.lock.blanked.clear();
+        self.services.lock.pending = Some(confirmation);
+        self.services.lock.blanked.clear();
         self.drag = None;
         self.sync_focus();
         self.needs_redraw = true;
@@ -64,7 +64,7 @@ impl SessionLockHandler for State {
 
     fn unlock(&mut self) {
         tracing::info!("session unlocked");
-        self.lock = Lock::default();
+        self.services.lock = Lock::default();
         self.sync_focus();
         self.needs_redraw = true;
     }
@@ -74,10 +74,11 @@ impl SessionLockHandler for State {
             return;
         };
         configure(&surface, &output);
-        self.lock
+        self.services
+            .lock
             .surfaces
             .retain(|(o, s)| o != &output && s.alive());
-        self.lock.surfaces.push((output, surface));
+        self.services.lock.surfaces.push((output, surface));
         self.sync_focus();
         self.needs_redraw = true;
     }
@@ -97,23 +98,23 @@ impl State {
     /// windows, so nothing private is left on screen when the locker is told
     /// it holds the session.
     pub fn confirm_lock(&mut self) {
-        if self.lock.pending.is_none() {
+        if self.services.lock.pending.is_none() {
             return;
         }
         let all = self
             .space
             .outputs()
-            .all(|o| self.lock.blanked.contains(&o.name()));
-        if all && let Some(locker) = self.lock.pending.take() {
+            .all(|o| self.services.lock.blanked.contains(&o.name()));
+        if all && let Some(locker) = self.services.lock.pending.take() {
             locker.lock();
-            self.lock.locked = true;
+            self.services.lock.locked = true;
             tracing::info!("session locked");
         }
     }
 
     /// Resends sizes after an output changed mode.
     pub fn reconfigure_lock(&self) {
-        for (output, surface) in &self.lock.surfaces {
+        for (output, surface) in &self.services.lock.surfaces {
             configure(surface, output);
         }
     }
@@ -121,9 +122,10 @@ impl State {
     pub fn lock_keyboard_focus(&self) -> Option<WlSurface> {
         let under = self.space.output_under(self.pointer_pos).next();
         under
-            .and_then(|o| self.lock.surface_on(o))
+            .and_then(|o| self.services.lock.surface_on(o))
             .or_else(|| {
-                self.lock
+                self.services
+                    .lock
                     .surfaces
                     .iter()
                     .map(|(_, s)| s)
@@ -138,7 +140,7 @@ impl State {
     ) -> Option<(WlSurface, Point<f64, Logical>)> {
         let output = self.space.output_under(pos).next()?;
         let origin = self.space.output_geometry(output)?.loc;
-        let surface = self.lock.surface_on(output)?;
+        let surface = self.services.lock.surface_on(output)?;
         under_from_surface_tree(
             surface.wl_surface(),
             pos - origin.to_f64(),

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

@@ -164,6 +164,7 @@ fn export_session(state: &State) {

164164 .arg("XDG_SESSION_TYPE=wayland")

165165 .args(

166166 state

167+ .services

167168 .xwayland

168169 .as_ref()

169170 .map(|x| format!("DISPLAY=:{}", x.display)),

Modified file: crates/monolith/src/nested/mod.rs+8 additions−3 deletions@@ -5,6 +5,7 @@
 
 mod input;
 
+use crate::state::Services;
 use crate::state::State;
 use calloop_wayland_source::WaylandSource;
 use monolith_layout::Rect;
@@ -179,9 +180,13 @@ pub fn render(state: &mut State) {
         borders,
         settings,
         output_id,
-        lock,
-        captures,
-        xwayland,
+        services:
+            Services {
+                lock,
+                captures,
+                xwayland,
+                ..
+            },
         ..
     } = state;
     let Some(host) = host.as_mut() else { return };

Modified file: crates/monolith/src/state.rs+31 additions−21 deletions@@ -62,8 +62,7 @@ pub struct State {
     pub drag: Option<crate::input::Drag>,
     /// Global logical position, shared by every backend.
     pub pointer_pos: Point<f64, Logical>,
-    pub ipc: crate::ipc::Server,
-    pub launches: crate::launch::Launches,
+    pub services: Services,
     pub list_handles: crate::toplevels::ListHandles,
     pub anim: Animator,
     pub borders: crate::scene::Borders,
@@ -75,14 +74,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 captures: crate::capture::Captures,
-    pub imports: crate::import::Imports,
     /// The render node clients get dmabufs for, known on bare metal.
     pub render_node: Option<smithay::backend::drm::DrmNode>,
-    pub lock: crate::lock::Lock,
-    pub inhibitors: HashSet<WlSurface>,
-    pub inhibited: bool,
     pub seat_state: SeatState<State>,
     pub seat: Seat<State>,
 }
@@ -96,6 +89,17 @@ pub struct Core {
     pub start: Instant,
 }
 
+/// Subsystems with state of their own.
+pub struct Services {
+    pub lock: crate::lock::Lock,
+    pub captures: crate::capture::Captures,
+    pub imports: crate::import::Imports,
+    pub xwayland: Option<crate::xwayland::Xwayland>,
+    pub launches: crate::launch::Launches,
+    pub ipc: crate::ipc::Server,
+    pub idle: crate::idle::Idle,
+}
+
 /// The config and what is derived from it, swapped whole on reload.
 pub struct Settings {
     pub config: Config,
@@ -151,8 +155,9 @@ impl State {
         layout.gaps = gaps(&config);
         let animation = config.animation.clone();
         let imports = crate::import::Imports::new(&handle, renderer.dmabuf_importer())?;
+        let idle = crate::idle::Idle::new(&dh, handle.clone());
         Ok(Self {
-            protocols: Protocols::new(&dh, handle.clone(), &renderer),
+            protocols: Protocols::new(&dh, &renderer),
             core: Core {
                 display: dh,
                 handle,
@@ -183,8 +188,15 @@ impl State {
             move_inverted: false,
             drag: None,
             pointer_pos: Point::default(),
-            ipc: crate::ipc::Server::default(),
-            launches: Default::default(),
+            services: Services {
+                lock: Default::default(),
+                captures: Default::default(),
+                imports,
+                xwayland: None,
+                launches: Default::default(),
+                ipc: Default::default(),
+                idle,
+            },
             list_handles: Default::default(),
             anim: Animator::new(animation),
             borders: Default::default(),
@@ -192,13 +204,7 @@ impl State {
             awaiting: HashSet::new(),
             placed_by_rule: HashSet::new(),
             layer_focus: None,
-            xwayland: None,
-            captures: Default::default(),
-            imports,
             render_node: None,
-            lock: Default::default(),
-            inhibitors: HashSet::new(),
-            inhibited: false,
             seat_state,
             seat,
         })
@@ -249,7 +255,7 @@ impl State {
                 .and_then(|c| c.get_credentials(&self.core.display).ok())
                 .map(|c| c.pid as u32),
         };
-        let launch = pid.and_then(|pid| self.launches.find(pid));
+        let launch = pid.and_then(|pid| self.services.launches.find(pid));
         let output = rule
             .output
             .as_deref()
@@ -517,7 +523,7 @@ impl State {
                 t.send_pending_configure();
             }
         }
-        let target: Option<Focus> = if self.lock.active() {
+        let target: Option<Focus> = if self.services.lock.active() {
             self.lock_keyboard_focus().map(Focus::from)
         } else {
             self.layer_keyboard_focus().map(Focus::from).or_else(|| {
@@ -597,10 +603,14 @@ impl State {
         &self,
         pos: Point<f64, Logical>,
     ) -> Option<(WlSurface, Point<f64, Logical>)> {
-        if self.lock.active() {
+        if self.services.lock.active() {
             return self.lock_surface_under(pos);
         }
-        let unmanaged = self.xwayland.iter().flat_map(|x| x.unmanaged.iter().rev());
+        let unmanaged = self
+            .services
+            .xwayland
+            .iter()
+            .flat_map(|x| x.unmanaged.iter().rev());
         for x in unmanaged {
             let geo = x.geometry();
             if let Some(s) = x.wl_surface()

Modified file: crates/monolith/src/xwayland.rs+9 additions−8 deletions@@ -113,7 +113,7 @@ pub fn init(state: &mut State) {
         }
     }
     tracing::info!("X11 clients will start Xwayland on :{number}");
-    state.xwayland = Some(Xwayland {
+    state.services.xwayland = Some(Xwayland {
         display: number,
         listeners,
         watch,
@@ -125,7 +125,7 @@ pub fn init(state: &mut State) {
 
 /// Waits for the next X client to knock.
 fn rearm(state: &mut State) {
-    let Some(x) = state.xwayland.as_mut() else {
+    let Some(x) = state.services.xwayland.as_mut() else {
         return;
     };
     x.running = false;
@@ -147,7 +147,7 @@ fn set_inherit(listeners: &[UnixListener], inherit: bool) {
 }
 
 fn start(state: &mut State, fired: usize) {
-    let Some(x) = state.xwayland.as_mut() else {
+    let Some(x) = state.services.xwayland.as_mut() else {
         return;
     };
     if x.running {
@@ -195,7 +195,7 @@ fn start(state: &mut State, fired: usize) {
                 match X11Wm::start_wm(state.core.handle.clone(), &dh, x11_socket, client.clone()) {
                     Ok(wm) => {
                         tracing::info!("Xwayland ready");
-                        if let Some(x) = state.xwayland.as_mut() {
+                        if let Some(x) = state.services.xwayland.as_mut() {
                             x.wm = Some(wm);
                         }
                     }
@@ -225,7 +225,8 @@ impl XWaylandShellHandler for State {
 
 impl XwmHandler for State {
     fn xwm_state(&mut self, _xwm: XwmId) -> &mut X11Wm {
-        self.xwayland
+        self.services
+            .xwayland
             .as_mut()
             .and_then(|x| x.wm.as_mut())
             .expect("X11 events only arrive while the WM runs")
@@ -245,7 +246,7 @@ impl XwmHandler for State {
     }
 
     fn mapped_override_redirect_window(&mut self, _xwm: XwmId, window: X11Surface) {
-        if let Some(x) = self.xwayland.as_mut() {
+        if let Some(x) = self.services.xwayland.as_mut() {
             x.unmanaged.retain(|w| w != &window);
             x.unmanaged.push(window);
         }
@@ -327,7 +328,7 @@ impl XwmHandler for State {
         for id in gone {
             self.remove_window(id);
         }
-        if let Some(x) = self.xwayland.as_mut() {
+        if let Some(x) = self.services.xwayland.as_mut() {
             x.wm = None;
             x.unmanaged.clear();
         }
@@ -363,7 +364,7 @@ impl State {
     }
 
     fn forget_x11(&mut self, window: &X11Surface) {
-        if let Some(x) = self.xwayland.as_mut() {
+        if let Some(x) = self.services.xwayland.as_mut() {
             x.unmanaged.retain(|w| w != window);
         }
         if let Some(id) = self.x11_window_id(window) {

monolith

Commit c7e08bac3e01

Commit `c7e08bac3e01`