monolith

public

Star0

Fork 0

Watch0

72 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `a76842e12aca`

tarball

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

16 files changed+276-212

monolith: move the window model into Wm

Layout, the smithay windows and space, popups, the animator and every per-window side table now sit together. This is a pure move, so the following change can merge the side tables into one record per window without also chasing field paths.

Modified file: crates/monolith/src/activation.rs+8 additions−8 deletions@@ -52,17 +52,17 @@ impl XdgActivationHandler for State {
             return;
         };
         let ctx = data.user_data.get::<Context>();
-        if self.awaiting.contains(&id)
+        if self.wm.awaiting.contains(&id)
             && let Some(ctx) = ctx
-            && !self.placed_by_rule.contains(&id)
+            && !self.wm.placed_by_rule.contains(&id)
         {
-            self.layout.relocate(id, ctx.output, ctx.tag);
+            self.wm.layout.relocate(id, ctx.output, ctx.tag);
         }
         let may_focus = ctx.is_some_and(|c| c.may_focus) && data.timestamp.elapsed() < FRESH;
-        if may_focus && self.layout.visible(id) {
-            self.layout.focus(id);
+        if may_focus && self.wm.layout.visible(id) {
+            self.wm.layout.focus(id);
         } else {
-            self.layout.mark_urgent(id);
+            self.wm.layout.mark_urgent(id);
         }
         self.apply_layout();
     }
@@ -71,8 +71,8 @@ impl XdgActivationHandler for State {
 impl State {
     /// Where a launch starting now should put its window.
     pub fn launch_context(&self) -> (Option<OutputId>, TagId) {
-        let output = self.layout.active_output();
-        let tag = output.map_or(self.layout.homeless(), |o| self.layout.launch_tag(o));
+        let output = self.wm.layout.active_output();
+        let tag = output.map_or(self.wm.layout.homeless(), |o| self.wm.layout.launch_tag(o));
         (output, tag)
     }
 

Modified file: crates/monolith/src/capture.rs+14 additions−10 deletions@@ -87,7 +87,7 @@ impl ToplevelCaptureSourceHandler for State {
         source: ImageCaptureSource,
         toplevel: ForeignToplevelHandle,
     ) {
-        if let Some(id) = self.list_handles.window(&toplevel) {
+        if let Some(id) = self.wm.list_handles.window(&toplevel) {
             source.user_data().insert_if_missing(|| id);
         }
     }
@@ -151,13 +151,16 @@ impl State {
             return Some(Target::Output(output.upgrade()?.name()));
         }
         let id = *data.get::<WindowId>()?;
-        self.windows.contains_key(&id).then_some(Target::Window(id))
+        self.wm
+            .windows
+            .contains_key(&id)
+            .then_some(Target::Window(id))
     }
 
     fn target_size(&self, target: &Target) -> Option<(i32, i32)> {
         let size: (i32, i32) = match target {
             Target::Output(name) => self.output_named(name)?.1.current_mode()?.size.into(),
-            Target::Window(id) => self.windows.get(id)?.geometry().size.into(),
+            Target::Window(id) => self.wm.windows.get(id)?.geometry().size.into(),
         };
         (size.0 > 0 && size.1 > 0).then_some(size)
     }
@@ -202,7 +205,7 @@ impl State {
                 };
                 self.output_elements(o, &output, session.draw_cursor())
             }
-            Target::Window(id) => window_elements(&mut self.renderer, &self.windows[id]),
+            Target::Window(id) => window_elements(&mut self.renderer, &self.wm.windows[id]),
         };
         let buffer = frame.buffer();
         let result = match get_dmabuf(&buffer) {
@@ -268,7 +271,7 @@ impl State {
     pub fn output_elements(&mut self, o: OutputId, output: &Output, cursor: bool) -> Vec<Draw> {
         let now = now_ns();
         let mut elements = Vec::new();
-        if cursor && let Some(area) = self.layout.output(o).map(|out| out.area) {
+        if cursor && let Some(area) = self.wm.layout.output(o).map(|out| out.area) {
             let local = self.pointer_pos - Point::from((area.x, area.y));
             if local.x >= 0.0 && local.y >= 0.0 && local.x < area.w && local.y < area.h {
                 elements.extend(self.cursor.elements(
@@ -281,14 +284,14 @@ impl State {
         match crate::lock::elements(&self.services.lock, &mut self.renderer, output) {
             Some(locked) => elements.extend(locked),
             None => elements.extend(crate::scene::build(
-                &self.layout,
+                &self.wm.layout,
                 o,
-                &self.windows,
-                &self.anim,
+                &self.wm.windows,
+                &self.wm.anim,
                 &mut self.renderer,
                 now,
                 &self.settings.config.decoration,
-                &mut self.borders,
+                &mut self.wm.borders,
                 Some(output),
                 self.services
                     .xwayland
@@ -300,7 +303,8 @@ impl State {
     }
 
     fn output_named(&self, name: &str) -> Option<(OutputId, Output)> {
-        self.layout
+        self.wm
+            .layout
             .outputs()
             .filter_map(|(o, _)| Some((o, self.backend.output(o)?)))
             .find(|(_, out)| out.name() == name)

Modified file: crates/monolith/src/commands.rs+34 additions−33 deletions@@ -50,19 +50,19 @@ fn dir(d: monolith_ipc::Dir) -> Dir {
 
 impl State {
     pub fn run(&mut self, cmd: Command) -> Result<(), String> {
-        let output = self.layout.active_output();
-        let focused = self.layout.focused();
+        let output = self.wm.layout.active_output();
+        let focused = self.wm.layout.focused();
         let inverted = std::mem::take(&mut self.move_inverted);
         let merge = (self.settings.config.general.move_mode == MoveMode::Merge) != inverted;
         let on_focused = |state: &mut Self, f: fn(&mut monolith_layout::Layout, WindowId)| {
             if let Some(w) = focused {
-                f(&mut state.layout, w);
+                f(&mut state.wm.layout, w);
             }
         };
         match cmd {
             Command::Spawn { argv } => self.spawn(&argv)?,
             Command::Close => {
-                if let Some(w) = focused.and_then(|w| self.windows.get(&w)) {
+                if let Some(w) = focused.and_then(|w| self.wm.windows.get(&w)) {
                     match (w.toplevel(), w.x11_surface()) {
                         (Some(t), _) => t.send_close(),
                         (_, Some(x)) => {
@@ -75,19 +75,19 @@ impl State {
             Command::Quit => self.core.signal.stop(),
             Command::Reload => self.reload()?,
             Command::Focus { dir: d } => {
-                self.layout.focus_dir(dir(d));
+                self.wm.layout.focus_dir(dir(d));
             }
             Command::Move { dir: d } if merge => {
-                self.layout.merge_window(dir(d));
+                self.wm.layout.merge_window(dir(d));
             }
             Command::Move { dir: d } => {
-                self.layout.move_window(dir(d));
+                self.wm.layout.move_window(dir(d));
             }
             Command::MoveContainer { dir: d } => {
-                self.layout.move_container(dir(d));
+                self.wm.layout.move_container(dir(d));
             }
             Command::Maximize => {
-                self.layout.expand(ExpandScope::All);
+                self.wm.layout.expand(ExpandScope::All);
             }
             Command::InvertMove => self.move_inverted = !inverted,
             Command::Resize { axis, delta } => {
@@ -95,73 +95,74 @@ impl State {
                     monolith_ipc::Axis::Horizontal => Axis::Horizontal,
                     monolith_ipc::Axis::Vertical => Axis::Vertical,
                 };
-                self.layout.resize(axis, delta);
+                self.wm.layout.resize(axis, delta);
             }
             Command::Expand { scope } => {
-                self.layout.expand(match scope {
+                self.wm.layout.expand(match scope {
                     monolith_ipc::ExpandScope::Window => ExpandScope::Window,
                     monolith_ipc::ExpandScope::Container => ExpandScope::Container,
                 });
             }
-            Command::Flip => output.into_iter().for_each(|o| self.layout.flip(o)),
+            Command::Flip => output.into_iter().for_each(|o| self.wm.layout.flip(o)),
             Command::Float => on_focused(self, |l, w| l.toggle_floating(w)),
             Command::Fullscreen => on_focused(self, |l, w| l.toggle_fullscreen(w)),
             Command::Sticky => on_focused(self, |l, w| l.toggle_sticky(w)),
             Command::View { tag } => {
-                let t = self.layout.tag(&tag);
-                output.into_iter().for_each(|o| self.layout.view(o, t));
+                let t = self.wm.layout.tag(&tag);
+                output.into_iter().for_each(|o| self.wm.layout.view(o, t));
             }
             Command::ToggleView { tag } => {
-                let t = self.layout.tag(&tag);
+                let t = self.wm.layout.tag(&tag);
                 output
                     .into_iter()
-                    .for_each(|o| self.layout.toggle_view(o, t));
+                    .for_each(|o| self.wm.layout.toggle_view(o, t));
             }
             Command::ViewEverywhere { tag } => {
-                let t = self.layout.tag(&tag);
-                self.layout.view_everywhere(t);
+                let t = self.wm.layout.tag(&tag);
+                self.wm.layout.view_everywhere(t);
             }
             Command::Tag { tag } => {
-                let t = self.layout.tag(&tag);
+                let t = self.wm.layout.tag(&tag);
                 if let Some(w) = focused {
-                    self.layout.set_tag(w, t);
+                    self.wm.layout.set_tag(w, t);
                 }
             }
             Command::ReorderTag { tag, index } => {
                 let t = self
+                    .wm
                     .layout
                     .tag_id(&tag)
                     .ok_or_else(|| format!("no tag {tag}"))?;
-                self.layout.reorder_tag(t, index);
+                self.wm.layout.reorder_tag(t, index);
             }
             Command::FocusOutput { dir: d } => {
-                if let Some(o) = output.and_then(|o| self.layout.output_towards(o, dir(d))) {
-                    self.layout.set_active_output(o);
-                    if let Some(w) = self.layout.focused_on(o) {
-                        self.layout.focus(w);
+                if let Some(o) = output.and_then(|o| self.wm.layout.output_towards(o, dir(d))) {
+                    self.wm.layout.set_active_output(o);
+                    if let Some(w) = self.wm.layout.focused_on(o) {
+                        self.wm.layout.focus(w);
                     }
                 }
             }
             Command::SendToOutput { dir: d } => {
                 if let (Some(w), Some(o)) = (
                     focused,
-                    output.and_then(|o| self.layout.output_towards(o, dir(d))),
+                    output.and_then(|o| self.wm.layout.output_towards(o, dir(d))),
                 ) {
-                    self.layout.send_to_output(w, o);
+                    self.wm.layout.send_to_output(w, o);
                 }
             }
             Command::Scratchpad { name } => {
                 if let Some(w) = focused {
-                    self.layout.scratchpad_add(w, &name);
+                    self.wm.layout.scratchpad_add(w, &name);
                 }
             }
             Command::Summon { name } => {
-                if !self.layout.scratchpads().iter().any(|s| s.name == name) {
+                if !self.wm.layout.scratchpads().iter().any(|s| s.name == name) {
                     return Err(format!("no scratchpad {name}"));
                 }
-                self.layout.summon(&name);
+                self.wm.layout.summon(&name);
             }
-            Command::Dismiss { name } => self.layout.dismiss(name.as_deref()),
+            Command::Dismiss { name } => self.wm.layout.dismiss(name.as_deref()),
         }
         self.apply_layout();
         Ok(())
@@ -200,8 +201,8 @@ impl State {
         let config = Config::load(self.settings.path.as_deref()).map_err(|e| e.to_string())?;
         let keyboard_changed = config.keyboard != self.settings.config.keyboard;
         self.settings.binds = Binds::new(&config);
-        self.layout.gaps = crate::state::gaps(&config);
-        self.anim.settings = config.animation.clone();
+        self.wm.layout.gaps = crate::state::gaps(&config);
+        self.wm.anim.settings = config.animation.clone();
         self.settings.config = config;
         if keyboard_changed {
             self.reconfigure_keyboard();

Modified file: crates/monolith/src/drm.rs+15 additions−11 deletions@@ -6,6 +6,7 @@ use crate::backend::Backend;
 use crate::scene::Draw;
 use crate::state::Services;
 use crate::state::{State, now_ns};
+use crate::wm::Wm;
 use monolith_config::Vrr;
 use monolith_layout::{OutputId, Rect};
 use smithay::backend::allocator::Fourcc;
@@ -342,8 +343,7 @@ fn connect(state: &mut State, connector: connector::Info, crtc: crtc::Handle) {
     let State {
         backend: Backend::Drm(drm),
         renderer,
-        layout,
-        space,
+        wm: Wm { layout, space, .. },
         core,
         ..
     } = state
@@ -446,8 +446,8 @@ fn disconnect(state: &mut State, crtc: crtc::Handle) {
         drm.handle.remove(token);
     }
     tracing::info!(name = surface.output.name(), "output disconnected");
-    state.space.unmap_output(&surface.output);
-    state.layout.remove_output(surface.id);
+    state.wm.space.unmap_output(&surface.output);
+    state.wm.layout.remove_output(surface.id);
 }
 
 impl Drm {
@@ -608,12 +608,16 @@ fn render_surface(state: &mut State, crtc: crtc::Handle, target: u64) -> bool {
     let State {
         backend: Backend::Drm(drm),
         renderer,
-        layout,
-        windows,
-        anim,
-        borders,
+        wm:
+            Wm {
+                layout,
+                windows,
+                anim,
+                borders,
+                space,
+                ..
+            },
         settings,
-        space,
         core,
         cursor,
         cursor_status,
@@ -769,7 +773,7 @@ fn on_input(state: &mut State, event: InputEvent<LibinputInputBackend>) {
             state.cursor_moved = true;
         }
         InputEvent::PointerMotionAbsolute { event } => {
-            let Some(area) = state.layout.outputs().next().map(|(_, o)| o.area) else {
+            let Some(area) = state.wm.layout.outputs().next().map(|(_, o)| o.area) else {
                 return;
             };
             let p = event.position_transformed((area.w as i32, area.h as i32).into());
@@ -814,7 +818,7 @@ fn clamp(
     let inside = |a: &Rect, p: Point<f64, smithay::utils::Logical>| {
         p.x >= a.x && p.y >= a.y && p.x < a.right() && p.y < a.bottom()
     };
-    let areas: Vec<Rect> = state.layout.outputs().map(|(_, o)| o.area).collect();
+    let areas: Vec<Rect> = state.wm.layout.outputs().map(|(_, o)| o.area).collect();
     if areas.iter().any(|a| inside(a, pos)) {
         return pos;
     }

Modified file: crates/monolith/src/handlers.rs+19 additions−12 deletions@@ -73,9 +73,10 @@ impl CompositorHandler for State {
                 root = parent;
             }
             if let Some(window) = self
+                .wm
                 .windows
                 .values()
-                .chain(&self.unmapped)
+                .chain(&self.wm.unmapped)
                 .find(|w| crate::state::root(w).as_ref() == Some(&root))
             {
                 window.on_commit();
@@ -87,11 +88,12 @@ impl CompositorHandler for State {
             }
         }
         if let Some(i) = self
+            .wm
             .unmapped
             .iter()
             .position(|w| w.toplevel().is_some_and(|t| t.wl_surface() == surface))
         {
-            let window = self.unmapped.remove(i);
+            let window = self.wm.unmapped.remove(i);
             let toplevel = window.toplevel().cloned();
             self.map_window(window, None);
             if let Some(t) = toplevel {
@@ -99,8 +101,8 @@ impl CompositorHandler for State {
             }
         }
         self.on_buffer(surface);
-        self.popups.commit(surface);
-        if let Some(PopupKind::Xdg(popup)) = self.popups.find_popup(surface)
+        self.wm.popups.commit(surface);
+        if let Some(PopupKind::Xdg(popup)) = self.wm.popups.find_popup(surface)
             && !popup.is_initial_configure_sent()
         {
             let _ = popup.send_configure();
@@ -141,7 +143,7 @@ impl XdgShellHandler for State {
     }
 
     fn new_toplevel(&mut self, surface: ToplevelSurface) {
-        self.unmapped.push(Window::new_wayland_window(surface));
+        self.wm.unmapped.push(Window::new_wayland_window(surface));
     }
 
     fn toplevel_destroyed(&mut self, surface: ToplevelSurface) {
@@ -158,7 +160,7 @@ impl XdgShellHandler for State {
 
     fn new_popup(&mut self, surface: PopupSurface, positioner: PositionerState) {
         surface.with_pending_state(|s| s.geometry = positioner.get_geometry());
-        let _ = self.popups.track_popup(PopupKind::Xdg(surface));
+        let _ = self.wm.popups.track_popup(PopupKind::Xdg(surface));
     }
 
     fn reposition_request(
@@ -361,9 +363,13 @@ fn server_side(toplevel: &ToplevelSurface) {
 impl State {
     fn set_fullscreen(&mut self, surface: &WlSurface, on: bool) {
         if let Some(id) = self.window_id(surface)
-            && self.layout.window(id).is_some_and(|w| w.fullscreen != on)
+            && self
+                .wm
+                .layout
+                .window(id)
+                .is_some_and(|w| w.fullscreen != on)
         {
-            self.layout.toggle_fullscreen(id);
+            self.wm.layout.toggle_fullscreen(id);
             self.apply_layout();
         }
     }
@@ -383,6 +389,7 @@ impl WorkspaceHandler for State {
                 Action::Create { group, name } => (group, name),
             };
             let Some(o) = self
+                .wm
                 .layout
                 .outputs()
                 .find(|(_, out)| out.name == *group)
@@ -390,12 +397,12 @@ impl WorkspaceHandler for State {
             else {
                 continue;
             };
-            let t = self.layout.tag(tag);
+            let t = self.wm.layout.tag(tag);
             match action {
-                Action::Activate { .. } | Action::Create { .. } => self.layout.view(o, t),
+                Action::Activate { .. } | Action::Create { .. } => self.wm.layout.view(o, t),
                 Action::Deactivate { .. } => {
-                    if self.layout.is_viewed(o, t) {
-                        self.layout.toggle_view(o, t);
+                    if self.wm.layout.is_viewed(o, t) {
+                        self.wm.layout.toggle_view(o, t);
                     }
                 }
             }

Modified file: crates/monolith/src/idle.rs+2 additions−1 deletions@@ -59,7 +59,8 @@ impl State {
             while let Some(parent) = get_parent(&root) {
                 root = parent;
             }
-            self.space
+            self.wm
+                .space
                 .elements()
                 .any(|w| crate::state::root(w).as_ref() == Some(&root))
                 || self.layer_maps_contain(&root)

Modified file: crates/monolith/src/input.rs+9 additions−7 deletions@@ -115,7 +115,7 @@ impl State {
         );
         match action {
             Some(Some(Action::Run(cmd))) => {
-                self.layer_focus = None;
+                self.wm.layer_focus = None;
                 if let Err(e) = self.run(cmd) {
                     tracing::warn!("bind failed: {e}");
                 }
@@ -143,22 +143,23 @@ fn focus_under_pointer(state: &mut State) {
     if let Some((layer, surface, _)) = state.layer_under(pos, &layers)
         && layer.can_receive_keyboard_focus()
     {
-        state.layer_focus = Some(surface);
+        state.wm.layer_focus = Some(surface);
         state.sync_focus();
         return;
     }
-    if state.layer_focus.take().is_some() {
+    if state.wm.layer_focus.take().is_some() {
         state.sync_focus();
     }
     let id = state
+        .wm
         .space
         .element_under(pos)
         .and_then(|(w, _)| crate::state::root(w))
         .and_then(|s| state.window_id(&s));
     if let Some(id) = id
-        && state.layout.focused() != Some(id)
+        && state.wm.layout.focused() != Some(id)
     {
-        state.layout.focus(id);
+        state.wm.layout.focus(id);
         state.apply_layout();
     }
 }
@@ -188,10 +189,11 @@ fn start_drag(state: &mut State, button: u32) -> bool {
             Modifier::Ctrl => m.ctrl,
             Modifier::Shift => m.shift,
         });
-    let Some(id) = state.layout.focused() else {
+    let Some(id) = state.wm.layout.focused() else {
         return false;
     };
     let Some(rect) = state
+        .wm
         .layout
         .window(id)
         .filter(|w| w.floating && !w.fullscreen)
@@ -223,7 +225,7 @@ fn drag_to(state: &mut State, pos: Point<f64, Logical>) -> bool {
         Rect::new(r.x + dx, r.y + dy, r.w, r.h)
     };
     let id = d.window;
-    state.layout.set_float_rect(id, rect);
+    state.wm.layout.set_float_rect(id, rect);
     state.apply_layout();
     true
 }

Modified file: crates/monolith/src/ipc.rs+2 additions−2 deletions@@ -147,7 +147,7 @@ pub fn broadcast(state: &mut State) {
 }
 
 fn snapshot(state: &State) -> monolith_ipc::State {
-    let l = &state.layout;
+    let l = &state.wm.layout;
     let focused = l.focused();
     let tags = l
         .tags()
@@ -173,7 +173,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).map(identity).unwrap_or_default();
+            let (app_id, title) = state.wm.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/layers.rs+15 additions−14 deletions@@ -35,8 +35,8 @@ impl WlrLayerShellHandler for State {
         let output = output
             .as_ref()
             .and_then(Output::from_resource)
-            .or_else(|| self.space.output_under(self.pointer_pos).next().cloned())
-            .or_else(|| self.space.outputs().next().cloned());
+            .or_else(|| self.wm.space.output_under(self.pointer_pos).next().cloned())
+            .or_else(|| self.wm.space.outputs().next().cloned());
         let Some(output) = output else {
             surface.send_close();
             return;
@@ -49,11 +49,11 @@ impl WlrLayerShellHandler for State {
     }
 
     fn new_popup(&mut self, _parent: WlrLayerSurface, popup: PopupSurface) {
-        let _ = self.popups.track_popup(PopupKind::Xdg(popup));
+        let _ = self.wm.popups.track_popup(PopupKind::Xdg(popup));
     }
 
     fn layer_destroyed(&mut self, surface: WlrLayerSurface) {
-        let outputs: Vec<Output> = self.space.outputs().cloned().collect();
+        let outputs: Vec<Output> = self.wm.space.outputs().cloned().collect();
         for output in outputs {
             let mut map = layer_map_for_output(&output);
             let gone = map
@@ -64,8 +64,8 @@ impl WlrLayerShellHandler for State {
                 map.unmap_layer(&layer);
             }
         }
-        if self.layer_focus.as_ref() == Some(surface.wl_surface()) {
-            self.layer_focus = None;
+        if self.wm.layer_focus.as_ref() == Some(surface.wl_surface()) {
+            self.wm.layer_focus = None;
         }
         self.reserve_layers();
     }
@@ -77,6 +77,7 @@ impl State {
     /// Returns false for surfaces that are not layer surfaces.
     pub fn layer_commit(&mut self, surface: &WlSurface) -> bool {
         let Some(output) = self
+            .wm
             .space
             .outputs()
             .find(|o| {
@@ -109,13 +110,13 @@ impl State {
 
     /// Keeps tiled windows out of the space bars reserve.
     pub fn reserve_layers(&mut self) {
-        let outputs: Vec<OutputId> = self.layout.outputs().map(|(o, _)| o).collect();
+        let outputs: Vec<OutputId> = self.wm.layout.outputs().map(|(o, _)| o).collect();
         let mut changed = false;
         for o in outputs {
             let Some(output) = self.backend.output(o) else {
                 continue;
             };
-            let Some(area) = self.layout.output(o).map(|out| out.area) else {
+            let Some(area) = self.wm.layout.output(o).map(|out| out.area) else {
                 continue;
             };
             let mut map = layer_map_for_output(&output);
@@ -128,7 +129,7 @@ impl State {
                 right: (area.w - f64::from(zone.loc.x + zone.size.w)).max(0.0),
             };
             drop(map);
-            if self.layout.set_reserved(o, reserved) {
+            if self.wm.layout.set_reserved(o, reserved) {
                 tracing::debug!(
                     output = output.name(),
                     ?zone,
@@ -148,7 +149,7 @@ impl State {
     /// The layer surface that should hold the keyboard, if any. One asking
     /// for exclusive focus above the windows wins over everything.
     pub fn layer_keyboard_focus(&self) -> Option<WlSurface> {
-        for output in self.space.outputs() {
+        for output in self.wm.space.outputs() {
             let map = layer_map_for_output(output);
             let exclusive = map
                 .layers_on(Layer::Overlay)
@@ -160,11 +161,11 @@ impl State {
                 return Some(l.wl_surface().clone());
             }
         }
-        self.layer_focus.clone().filter(|s| s.is_alive())
+        self.wm.layer_focus.clone().filter(|s| s.is_alive())
     }
 
     pub fn layer_maps_contain(&self, surface: &WlSurface) -> bool {
-        self.space.outputs().any(|o| {
+        self.wm.space.outputs().any(|o| {
             layer_map_for_output(o)
                 .layer_for_surface(surface, WindowSurfaceType::TOPLEVEL)
                 .is_some()
@@ -177,8 +178,8 @@ impl State {
         pos: Point<f64, Logical>,
         layers: &[Layer],
     ) -> Option<(LayerSurface, WlSurface, Point<f64, Logical>)> {
-        let output = self.space.output_under(pos).next()?;
-        let origin = self.space.output_geometry(output)?.loc;
+        let output = self.wm.space.output_under(pos).next()?;
+        let origin = self.wm.space.output_geometry(output)?.loc;
         let local = pos - origin.to_f64();
         let map = layer_map_for_output(output);
         layers.iter().find_map(|&layer| {

Modified file: crates/monolith/src/lock.rs+4 additions−3 deletions@@ -102,6 +102,7 @@ impl State {
             return;
         }
         let all = self
+            .wm
             .space
             .outputs()
             .all(|o| self.services.lock.blanked.contains(&o.name()));
@@ -120,7 +121,7 @@ impl State {
     }
 
     pub fn lock_keyboard_focus(&self) -> Option<WlSurface> {
-        let under = self.space.output_under(self.pointer_pos).next();
+        let under = self.wm.space.output_under(self.pointer_pos).next();
         under
             .and_then(|o| self.services.lock.surface_on(o))
             .or_else(|| {
@@ -138,8 +139,8 @@ impl State {
         &self,
         pos: Point<f64, Logical>,
     ) -> Option<(WlSurface, Point<f64, Logical>)> {
-        let output = self.space.output_under(pos).next()?;
-        let origin = self.space.output_geometry(output)?.loc;
+        let output = self.wm.space.output_under(pos).next()?;
+        let origin = self.wm.space.output_geometry(output)?.loc;
         let surface = self.services.lock.surface_on(output)?;
         under_from_surface_tree(
             surface.wl_surface(),

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

@@ -19,6 +19,7 @@ mod nested;

1919 mod scene;

2020 mod state;

2121 mod toplevels;

22+mod wm;

2223 mod xwayland;

2324

2425 #[cfg(feature = "spans")]

Modified file: crates/monolith/src/nested/mod.rs+12 additions−7 deletions@@ -8,6 +8,7 @@ mod input;
 use crate::backend::Backend;
 use crate::state::Services;
 use crate::state::State;
+use crate::wm::Wm;
 use calloop_wayland_source::WaylandSource;
 use monolith_layout::{OutputId, Rect};
 use monolith_render_vk::VulkanAllocator;
@@ -132,14 +133,14 @@ pub fn init(
         Some((0, 0).into()),
     );
     output.set_preferred(mode);
-    state.space.map_output(&output, (0, 0));
+    state.wm.space.map_output(&output, (0, 0));
     let area = Rect::new(
         0.0,
         0.0,
         f64::from(DEFAULT_SIZE.0),
         f64::from(DEFAULT_SIZE.1),
     );
-    let output_id = state.layout.add_output("nested", area);
+    let output_id = state.wm.layout.add_output("nested", area);
 
     state.backend = Backend::Nested(Box::new(Host {
         output_id,
@@ -174,13 +175,17 @@ pub fn render(state: &mut State) {
     let State {
         backend,
         renderer,
-        space,
+        wm:
+            Wm {
+                layout,
+                windows,
+                anim,
+                borders,
+                space,
+                ..
+            },
         needs_redraw,
         core,
-        layout,
-        windows,
-        anim,
-        borders,
         settings,
         services:
             Services {

Modified file: crates/monolith/src/state.rs+79 additions−83 deletions@@ -2,6 +2,7 @@ use crate::anim::{Animator, Ghost};
 use crate::commands::Binds;
 use crate::focus::Focus;
 use crate::globals::Protocols;
+use crate::wm::Wm;
 use monolith_config::Config;
 use monolith_layout::{Layout, OutputId, Rect, WindowId};
 use monolith_protocols::workspace::{Group, Snapshot, Workspace};
@@ -39,8 +40,7 @@ pub struct State {
     pub settings: Settings,
     pub protocols: Protocols,
     pub renderer: VulkanRenderer,
-    pub space: Space<Window>,
-    pub popups: PopupManager,
+    pub wm: Wm,
     pub backend: crate::backend::Backend,
     pub cursor: crate::cursor::Cursor,
     pub cursor_status: CursorImageStatus,
@@ -48,28 +48,12 @@ pub struct State {
     /// The pointer moved, which on its own only redraws the cursor.
     pub cursor_moved: bool,
 
-    pub layout: Layout,
-    pub windows: HashMap<WindowId, Window>,
-    /// Toplevels that have not committed yet. Rules need their app_id and
-    /// title, which clients set after creating the toplevel.
-    pub unmapped: Vec<Window>,
     pub suppressed: Vec<Keycode>,
     pub move_inverted: bool,
     pub drag: Option<crate::input::Drag>,
     /// Global logical position, shared by every backend.
     pub pointer_pos: Point<f64, Logical>,
     pub services: Services,
-    pub list_handles: crate::toplevels::ListHandles,
-    pub anim: Animator,
-    pub borders: crate::scene::Borders,
-    /// How each shown window was placed by the last layout pass, to spot
-    /// switches between tiled, floating and fullscreen.
-    pub last_kind: HashMap<WindowId, (Kind, Rect, OutputId)>,
-    pub awaiting: HashSet<WindowId>,
-    /// Windows a rule sent somewhere, which activation tokens leave alone.
-    pub placed_by_rule: HashSet<WindowId>,
-    /// A layer surface given the keyboard by a click, like a launcher.
-    pub layer_focus: Option<WlSurface>,
     pub seat_state: SeatState<State>,
     pub seat: Seat<State>,
 }
@@ -165,16 +149,25 @@ impl State {
                 path: config_path,
             },
             renderer,
-            space: Space::default(),
-            popups: PopupManager::default(),
+            wm: Wm {
+                layout,
+                windows: HashMap::new(),
+                unmapped: Vec::new(),
+                space: Space::default(),
+                popups: PopupManager::default(),
+                anim: Animator::new(animation),
+                borders: Default::default(),
+                last_kind: HashMap::new(),
+                awaiting: HashSet::new(),
+                placed_by_rule: HashSet::new(),
+                list_handles: Default::default(),
+                layer_focus: None,
+            },
             backend: crate::backend::Backend::Starting,
             cursor: crate::cursor::Cursor::load(),
             cursor_status: CursorImageStatus::default_named(),
             needs_redraw: true,
             cursor_moved: false,
-            layout,
-            windows: HashMap::new(),
-            unmapped: Vec::new(),
             suppressed: Vec::new(),
             move_inverted: false,
             drag: None,
@@ -188,13 +181,6 @@ impl State {
                 ipc: Default::default(),
                 idle,
             },
-            list_handles: Default::default(),
-            anim: Animator::new(animation),
-            borders: Default::default(),
-            last_kind: HashMap::new(),
-            awaiting: HashSet::new(),
-            placed_by_rule: HashSet::new(),
-            layer_focus: None,
             seat_state,
             seat,
         })
@@ -202,8 +188,8 @@ impl State {
 
     /// Runs after every batch of events, so many client commits produce one frame.
     pub fn after_dispatch(&mut self) {
-        self.space.refresh();
-        self.popups.cleanup();
+        self.wm.space.refresh();
+        self.wm.popups.cleanup();
         match self.backend {
             crate::backend::Backend::Drm(_) => crate::drm::render(self),
             crate::backend::Backend::Nested(_) => crate::nested::render(self),
@@ -227,7 +213,7 @@ impl State {
             };
             host.output
                 .change_current_state(Some(mode), None, None, None);
-            self.layout.set_output_area(o, area);
+            self.wm.layout.set_output_area(o, area);
             self.reserve_layers();
             self.reconfigure_lock();
             self.apply_layout();
@@ -252,14 +238,15 @@ impl State {
             .output
             .as_deref()
             .and_then(|name| {
-                self.layout
+                self.wm
+                    .layout
                     .outputs()
                     .find(|(_, o)| o.name == name)
                     .map(|(id, _)| id)
             })
             .or(launch.and_then(|l| l.0));
         let tag = match rule.tag.as_deref() {
-            Some(t) => Some(self.layout.tag(t)),
+            Some(t) => Some(self.wm.layout.tag(t)),
             None => launch.map(|l| l.1),
         };
         let float = float.map(|r| {
@@ -270,23 +257,23 @@ impl State {
                 f64::from(r.size.h),
             )
         });
-        let id = self.layout.add_window(output, tag, float);
+        let id = self.wm.layout.add_window(output, tag, float);
         if rule.tag.is_some() || rule.output.is_some() {
-            self.placed_by_rule.insert(id);
+            self.wm.placed_by_rule.insert(id);
         }
         if rule.floating == Some(true) {
-            self.layout.toggle_floating(id);
+            self.wm.layout.toggle_floating(id);
         }
         if rule.sticky == Some(true) {
-            self.layout.toggle_sticky(id);
+            self.wm.layout.toggle_sticky(id);
         }
         if let Some(name) = &rule.scratchpad {
-            self.layout.scratchpad_add(id, name);
+            self.wm.layout.scratchpad_add(id, name);
         }
-        self.windows.insert(id, window);
+        self.wm.windows.insert(id, window);
         self.await_first_buffer(id);
-        if self.layout.visible(id) {
-            self.layout.focus(id);
+        if self.wm.layout.visible(id) {
+            self.wm.layout.focus(id);
         }
         self.apply_layout();
     }
@@ -295,7 +282,7 @@ impl State {
     /// spawn animation never plays over an empty slot. Clients that are slow
     /// to draw get it anyway after a while.
     fn await_first_buffer(&mut self, id: WindowId) {
-        self.awaiting.insert(id);
+        self.wm.awaiting.insert(id);
         let timeout = Timer::from_duration(Duration::from_millis(300));
         let _ = self.core.handle.insert_source(timeout, move |_, _, state| {
             state.first_buffer(id);
@@ -305,7 +292,7 @@ impl State {
 
     /// Called on commits, starts the spawn of a window that now has a buffer.
     pub fn on_buffer(&mut self, surface: &WlSurface) {
-        if self.awaiting.is_empty() {
+        if self.wm.awaiting.is_empty() {
             return;
         }
         let has_buffer =
@@ -316,44 +303,48 @@ impl State {
     }
 
     fn first_buffer(&mut self, id: WindowId) {
-        self.placed_by_rule.remove(&id);
-        if self.awaiting.remove(&id) {
-            self.anim.spawned(id, now_ns());
+        self.wm.placed_by_rule.remove(&id);
+        if self.wm.awaiting.remove(&id) {
+            self.wm.anim.spawned(id, now_ns());
             self.apply_layout();
         }
     }
 
     pub fn unmap_window(&mut self, surface: &WlSurface) {
-        self.unmapped.retain(|w| root(w).as_ref() != Some(surface));
+        self.wm
+            .unmapped
+            .retain(|w| root(w).as_ref() != Some(surface));
         if let Some(id) = self.window_id(surface) {
             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);
+        if let Some(window) = self.wm.windows.remove(&id) {
+            self.wm.space.unmap_elem(&window);
             self.leave_ghost(id, &window);
         }
-        self.layout.remove_window(id);
-        self.placed_by_rule.remove(&id);
+        self.wm.layout.remove_window(id);
+        self.wm.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) {
-        let Some(o) = self.layout.window(id).and_then(|w| w.output) else {
+        let Some(o) = self.wm.layout.window(id).and_then(|w| w.output) else {
             return;
         };
         let tiled = self
+            .wm
             .layout
             .output(o)
             .is_some_and(|out| out.tree.contains(id));
-        if !tiled || !self.layout.visible(id) {
+        if !tiled || !self.wm.layout.visible(id) {
             return;
         }
         let Some(seed) = self
+            .wm
             .layout
             .arrange_hiding(o, &[id])
             .tiled
@@ -374,7 +365,7 @@ impl State {
         })
         .flatten();
         if let Some((texture, scale, transform)) = snapshot {
-            self.anim.add_ghost(Ghost {
+            self.wm.anim.add_ghost(Ghost {
                 id,
                 output: o,
                 seed: seed.rect,
@@ -388,7 +379,8 @@ impl State {
     }
 
     pub fn window_id(&self, surface: &WlSurface) -> Option<WindowId> {
-        self.windows
+        self.wm
+            .windows
             .iter()
             .find(|(_, w)| root(w).as_ref() == Some(surface))
             .map(|(id, _)| *id)
@@ -399,10 +391,10 @@ impl State {
         let now = now_ns();
         let mut shown = Vec::new();
         let mut tracks = Vec::new();
-        let outputs: Vec<OutputId> = self.layout.outputs().map(|(o, _)| o).collect();
+        let outputs: Vec<OutputId> = self.wm.layout.outputs().map(|(o, _)| o).collect();
         for o in outputs {
-            let arr = self.layout.arrange(o);
-            let area = self.layout.output(o).map(|o| o.area).unwrap_or_default();
+            let arr = self.wm.layout.arrange(o);
+            let area = self.wm.layout.output(o).map(|o| o.area).unwrap_or_default();
             for p in &arr.tiled {
                 if p.visible && arr.fullscreen != Some(p.window) {
                     shown.push((p.window, p.rect, Kind::Tiled, o));
@@ -420,12 +412,12 @@ impl State {
                 .tiled
                 .iter()
                 .map(|p| p.window)
-                .filter(|w| self.awaiting.contains(w))
+                .filter(|w| self.wm.awaiting.contains(w))
                 .collect();
             let planned = if held.is_empty() {
                 arr.tiled.clone()
             } else {
-                self.layout.arrange_hiding(o, &held).tiled
+                self.wm.layout.arrange_hiding(o, &held).tiled
             };
             let targets: Vec<(WindowId, Rect)> =
                 planned.iter().map(|p| (p.window, p.rect)).collect();
@@ -434,71 +426,74 @@ impl State {
 
         let mut glides = Vec::new();
         for &(id, rect, kind, _) in &shown {
-            match self.last_kind.get(&id) {
+            match self.wm.last_kind.get(&id) {
                 Some(&(was, from, o)) if was != kind => {
                     let from = self
+                        .wm
                         .anim
                         .gliding(id, now)
                         .or_else(|| {
                             (was == Kind::Tiled)
-                                .then(|| self.anim.tiled(o, id, now))
+                                .then(|| self.wm.anim.tiled(o, id, now))
                                 .flatten()
                         })
                         .unwrap_or(from);
                     glides.push((id, from, rect));
                 }
-                Some(&(Kind::Floating, from, _)) if from != rect => self.anim.stop_glide(id),
+                Some(&(Kind::Floating, from, _)) if from != rect => self.wm.anim.stop_glide(id),
                 _ => {}
             }
         }
-        let gap = self.layout.gaps.inner;
+        let gap = self.wm.layout.gaps.inner;
         for (o, targets) in tracks {
             let new: Vec<WindowId> = targets
                 .iter()
                 .map(|t| t.0)
-                .filter(|&id| self.anim.tiled(o, id, now).is_none())
+                .filter(|&id| self.wm.anim.tiled(o, id, now).is_none())
                 .collect();
             let seeds: HashMap<WindowId, Rect> = if new.is_empty() {
                 HashMap::new()
             } else {
-                self.layout
+                self.wm
+                    .layout
                     .arrange_hiding(o, &new)
                     .tiled
                     .into_iter()
                     .map(|p| (p.window, p.rect))
                     .collect()
             };
-            self.anim.retarget(o, now, &targets, gap, |id| {
+            self.wm.anim.retarget(o, now, &targets, gap, |id| {
                 seeds.get(&id).copied().unwrap_or_default()
             });
         }
         for (id, from, to) in glides {
-            self.anim.glide(id, from, to, now);
+            self.wm.anim.glide(id, from, to, now);
         }
-        self.last_kind = shown.iter().map(|&(id, r, k, o)| (id, (k, r, o))).collect();
+        self.wm.last_kind = shown.iter().map(|&(id, r, k, o)| (id, (k, r, o))).collect();
 
         let mut mapped = Vec::new();
         for (id, rect, kind, _) in shown {
-            if let Some(window) = self.windows.get(&id)
-                && configure(window, rect, kind, self.layout.maximized(id))
+            if let Some(window) = self.wm.windows.get(&id)
+                && configure(window, rect, kind, self.wm.layout.maximized(id))
             {
                 let loc = (rect.x.round() as i32, rect.y.round() as i32);
                 let loc = Point::from(loc) - window.geometry().loc;
-                self.space.map_element(window.clone(), loc, false);
+                self.wm.space.map_element(window.clone(), loc, false);
                 mapped.push(id);
             }
         }
         let hidden: Vec<Window> = self
+            .wm
             .windows
             .iter()
             .filter(|(id, _)| !mapped.contains(id))
             .map(|(_, w)| w.clone())
             .collect();
         for window in hidden {
-            self.space.unmap_elem(&window);
+            self.wm.space.unmap_elem(&window);
         }
         for id in &mapped {
-            self.space.raise_element(&self.windows[id], false);
+            self.wm.space.raise_element(&self.wm.windows[id], false);
         }
         self.sync_focus();
         self.update_inhibit();
@@ -506,8 +501,8 @@ impl State {
     }
 
     pub fn sync_focus(&mut self) {
-        let focused = self.layout.focused();
-        for (id, window) in &self.windows {
+        let focused = self.wm.layout.focused();
+        for (id, window) in &self.wm.windows {
             if window.set_activated(Some(*id) == focused)
                 && let Some(t) = window.toplevel()
                 && t.is_initial_configure_sent()
@@ -519,7 +514,7 @@ impl State {
             self.lock_keyboard_focus().map(Focus::from)
         } else {
             self.layer_keyboard_focus().map(Focus::from).or_else(|| {
-                let w = focused.and_then(|id| self.windows.get(&id))?;
+                let w = focused.and_then(|id| self.wm.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())),
@@ -537,7 +532,7 @@ impl State {
         if !self.protocols.workspaces.has_clients() {
             return;
         }
-        let l = &self.layout;
+        let l = &self.wm.layout;
         let occupied: HashSet<(OutputId, monolith_layout::TagId)> = l
             .windows()
             .filter(|(_, w)| w.scratchpad.is_none())
@@ -609,11 +604,11 @@ impl State {
                 return Some((s, (p + geo.loc).to_f64()));
             }
         }
-        let fullscreen = self.layout.outputs().any(|(o, out)| {
+        let fullscreen = self.wm.layout.outputs().any(|(o, out)| {
             let a = out.area;
             (a.x..a.right()).contains(&pos.x)
                 && (a.y..a.bottom()).contains(&pos.y)
-                && self.layout.arrange(o).fullscreen.is_some()
+                && self.wm.layout.arrange(o).fullscreen.is_some()
         });
         let above: &[Layer] = if fullscreen {
             &[Layer::Overlay]
@@ -623,7 +618,8 @@ impl State {
         let layer = |layers| self.layer_under(pos, layers).map(|(_, s, p)| (s, p));
         layer(above)
             .or_else(|| {
-                self.space
+                self.wm
+                    .space
                     .element_under(pos)
                     .and_then(|(window, location)| {
                         window

Modified file: crates/monolith/src/toplevels.rs+24 additions−18 deletions@@ -39,22 +39,22 @@ impl ForeignToplevelHandler for State {
     }
 
     fn foreign_toplevel_action(&mut self, action: Action) {
-        let id_of = |k: u64| self.windows.keys().copied().find(|&id| key(id) == k);
+        let id_of = |k: u64| self.wm.windows.keys().copied().find(|&id| key(id) == k);
         match action {
             Action::Activate(k) => {
                 let Some(id) = id_of(k) else { return };
-                if !self.layout.visible(id)
-                    && let Some(w) = self.layout.window(id)
+                if !self.wm.layout.visible(id)
+                    && let Some(w) = self.wm.layout.window(id)
                     && let Some(o) = w.output
                     && w.scratchpad.is_none()
                 {
                     let tag = w.tag;
-                    self.layout.toggle_view(o, tag);
+                    self.wm.layout.toggle_view(o, tag);
                 }
-                self.layout.focus(id);
+                self.wm.layout.focus(id);
             }
             Action::Close(k) => {
-                let Some(window) = id_of(k).and_then(|id| self.windows.get(&id)) else {
+                let Some(window) = id_of(k).and_then(|id| self.wm.windows.get(&id)) else {
                     return;
                 };
                 match (window.toplevel(), window.x11_surface()) {
@@ -68,15 +68,20 @@ impl ForeignToplevelHandler for State {
             }
             Action::Maximize(k, on) => {
                 let Some(id) = id_of(k) else { return };
-                if self.layout.maximized(id) != on {
-                    self.layout.focus(id);
-                    self.layout.expand(monolith_layout::ExpandScope::All);
+                if self.wm.layout.maximized(id) != on {
+                    self.wm.layout.focus(id);
+                    self.wm.layout.expand(monolith_layout::ExpandScope::All);
                 }
             }
             Action::Fullscreen(k, on) => {
                 let Some(id) = id_of(k) else { return };
-                if self.layout.window(id).is_some_and(|w| w.fullscreen != on) {
-                    self.layout.toggle_fullscreen(id);
+                if self
+                    .wm
+                    .layout
+                    .window(id)
+                    .is_some_and(|w| w.fullscreen != on)
+                {
+                    self.wm.layout.toggle_fullscreen(id);
                 }
             }
         }
@@ -87,15 +92,15 @@ impl ForeignToplevelHandler for State {
 impl State {
     /// Brings both window lists in line with the windows.
     pub fn publish_toplevels(&mut self) {
-        let mut handles = std::mem::take(&mut self.list_handles.0);
+        let mut handles = std::mem::take(&mut self.wm.list_handles.0);
         handles.retain(|id, h| {
-            let keep = self.windows.contains_key(id);
+            let keep = self.wm.windows.contains_key(id);
             if !keep {
                 self.protocols.toplevel_list.remove_toplevel(h);
             }
             keep
         });
-        for (id, window) in &self.windows {
+        for (id, window) in &self.wm.windows {
             let (app_id, title) = identity(window);
             match handles.get(id) {
                 Some(h) => {
@@ -114,18 +119,19 @@ impl State {
                 }
             }
         }
-        self.list_handles.0 = handles;
+        self.wm.list_handles.0 = handles;
 
         if !self.protocols.foreign_toplevels.has_clients() {
             return;
         }
-        let focused = self.layout.focused();
+        let focused = self.wm.layout.focused();
         let toplevels = self
+            .wm
             .windows
             .iter()
             .map(|(&id, window)| {
                 let (app_id, title) = identity(window);
-                let w = self.layout.window(id);
+                let w = self.wm.layout.window(id);
                 Toplevel {
                     key: key(id),
                     title,
@@ -136,7 +142,7 @@ impl State {
                         .into_iter()
                         .collect(),
                     activated: focused == Some(id),
-                    maximized: self.layout.maximized(id),
+                    maximized: self.wm.layout.maximized(id),
                     fullscreen: w.is_some_and(|w| w.fullscreen),
                 }
             })

Added file: crates/monolith/src/wm.rs+29 additions@@ -0,0 +1,29 @@
+//! The window model: the layout and what monolith keeps per window beside it.
+
+use crate::anim::Animator;
+use crate::state::Kind;
+use monolith_layout::{Layout, OutputId, Rect, WindowId};
+use smithay::desktop::{PopupManager, Space, Window};
+use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
+use std::collections::{HashMap, HashSet};
+
+pub struct Wm {
+    pub layout: Layout,
+    pub windows: HashMap<WindowId, Window>,
+    /// Toplevels that have not committed yet. Rules need their app_id and
+    /// title, which clients set after creating the toplevel.
+    pub unmapped: Vec<Window>,
+    pub space: Space<Window>,
+    pub popups: PopupManager,
+    pub anim: Animator,
+    pub borders: crate::scene::Borders,
+    /// How each shown window was placed by the last layout pass, to spot
+    /// switches between tiled, floating and fullscreen.
+    pub last_kind: HashMap<WindowId, (Kind, Rect, OutputId)>,
+    pub awaiting: HashSet<WindowId>,
+    /// Windows a rule sent somewhere, which activation tokens leave alone.
+    pub placed_by_rule: HashSet<WindowId>,
+    pub list_handles: crate::toplevels::ListHandles,
+    /// A layer surface given the keyboard by a click, like a launcher.
+    pub layer_focus: Option<WlSurface>,
+}

Modified file: crates/monolith/src/xwayland.rs+9 additions−3 deletions@@ -320,6 +320,7 @@ impl XwmHandler for State {
     fn disconnected(&mut self, _xwm: XwmId) {
         tracing::info!("Xwayland exited");
         let gone: Vec<_> = self
+            .wm
             .windows
             .iter()
             .filter(|(_, w)| w.x11_surface().is_some())
@@ -357,7 +358,8 @@ fn floats(window: &X11Surface) -> bool {
 
 impl State {
     pub fn x11_window_id(&self, window: &X11Surface) -> Option<monolith_layout::WindowId> {
-        self.windows
+        self.wm
+            .windows
             .iter()
             .find(|(_, w)| w.x11_surface() == Some(window))
             .map(|(id, _)| *id)
@@ -375,9 +377,13 @@ impl State {
 
     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
+                .wm
+                .layout
+                .window(id)
+                .is_some_and(|w| w.fullscreen != on)
         {
-            self.layout.toggle_fullscreen(id);
+            self.wm.layout.toggle_fullscreen(id);
             self.apply_layout();
         }
     }

monolith

Commit a76842e12aca

Commit `a76842e12aca`