monolith

public

Star0

Fork 0

Watch0

73 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `60956e3999de`

tarball

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

13 files changed+232-198

monolith: keep one WindowState per window with a surface index

A window's state was spread over six maps, and removing it cleaned only some of them, leaving stale ids in the awaiting set and the last placement. Each window now has one record in a SecondaryMap keyed by the layout's WindowId, and Wm::insert and Wm::remove are the only ways in and out. Lookups by surface go through an index instead of scanning every window. X11 windows join the index when xwayland-shell associates their surface, which can come after they map. scene::build takes the Wm, which drops it from ten arguments to seven.

Modified file: crates/monolith/src/activation.rs+3 additions−2 deletions@@ -52,9 +52,10 @@ impl XdgActivationHandler for State {
             return;
         };
         let ctx = data.user_data.get::<Context>();
-        if self.wm.awaiting.contains(&id)
+        if let Some(w) = self.wm.get(id)
+            && w.awaiting_buffer
+            && !w.placed_by_rule
             && let Some(ctx) = ctx
-            && !self.wm.placed_by_rule.contains(&id)
         {
             self.wm.layout.relocate(id, ctx.output, ctx.tag);
         }

Modified file: crates/monolith/src/anim.rs+5 additions@@ -237,6 +237,11 @@ impl Animator {
             || !self.spawns.is_empty()
     }
 
+    pub fn forget(&mut self, id: WindowId) {
+        self.glides.remove(&id);
+        self.spawns.remove(&id);
+    }
+
     pub fn prune(&mut self, now: u64) {
         self.glides.retain(|_, g| g.timeline.end_ns() > now);
         let phase = self.phase_ns();

Modified file: crates/monolith/src/capture.rs+15 additions−11 deletions@@ -87,7 +87,11 @@ impl ToplevelCaptureSourceHandler for State {
         source: ImageCaptureSource,
         toplevel: ForeignToplevelHandle,
     ) {
-        if let Some(id) = self.wm.list_handles.window(&toplevel) {
+        let id = self.wm.iter().find_map(|(id, w)| {
+            let h = w.list_handle.as_ref()?;
+            (h.identifier() == toplevel.identifier()).then_some(id)
+        });
+        if let Some(id) = id {
             source.user_data().insert_if_missing(|| id);
         }
     }
@@ -151,16 +155,13 @@ impl State {
             return Some(Target::Output(output.upgrade()?.name()));
         }
         let id = *data.get::<WindowId>()?;
-        self.wm
-            .windows
-            .contains_key(&id)
-            .then_some(Target::Window(id))
+        self.wm.get(id).map(|_| 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.wm.windows.get(id)?.geometry().size.into(),
+            Target::Window(id) => self.wm.window(*id)?.geometry().size.into(),
         };
         (size.0 > 0 && size.1 > 0).then_some(size)
     }
@@ -205,7 +206,13 @@ impl State {
                 };
                 self.output_elements(o, &output, session.draw_cursor())
             }
-            Target::Window(id) => window_elements(&mut self.renderer, &self.wm.windows[id]),
+            Target::Window(id) => match self.wm.window(*id) {
+                Some(window) => window_elements(&mut self.renderer, window),
+                None => {
+                    frame.fail(CaptureFailureReason::Stopped);
+                    return;
+                }
+            },
         };
         let buffer = frame.buffer();
         let result = match get_dmabuf(&buffer) {
@@ -284,14 +291,11 @@ 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.wm.layout,
+                &mut self.wm,
                 o,
-                &self.wm.windows,
-                &self.wm.anim,
                 &mut self.renderer,
                 now,
                 &self.settings.config.decoration,
-                &mut self.wm.borders,
                 Some(output),
                 self.services
                     .xwayland

Modified file: crates/monolith/src/commands.rs+2 additions−8 deletions@@ -62,14 +62,8 @@ impl State {
         match cmd {
             Command::Spawn { argv } => self.spawn(&argv)?,
             Command::Close => {
-                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)) => {
-                            let _ = x.close();
-                        }
-                        _ => {}
-                    }
+                if let Some(w) = focused.and_then(|w| self.wm.window(w)) {
+                    crate::wm::close(w);
                 }
             }
             Command::Quit => self.core.signal.stop(),

Modified file: crates/monolith/src/drm.rs+7 additions−18 deletions@@ -608,15 +608,7 @@ fn render_surface(state: &mut State, crtc: crtc::Handle, target: u64) -> bool {
     let State {
         backend: Backend::Drm(drm),
         renderer,
-        wm:
-            Wm {
-                layout,
-                windows,
-                anim,
-                borders,
-                space,
-                ..
-            },
+        wm,
         settings,
         core,
         cursor,
@@ -648,7 +640,7 @@ fn render_surface(state: &mut State, crtc: crtc::Handle, target: u64) -> bool {
         && match settings.config.output.vrr {
             Vrr::Off => false,
             Vrr::On => true,
-            Vrr::Fullscreen => layout.arrange(surface.id).fullscreen.is_some(),
+            Vrr::Fullscreen => wm.layout.arrange(surface.id).fullscreen.is_some(),
         };
     if want_vrr != surface.vrr_on {
         match surface.drm.with_compositor(|c| c.use_vrr(want_vrr)) {
@@ -668,7 +660,7 @@ fn render_surface(state: &mut State, crtc: crtc::Handle, target: u64) -> bool {
     }
     let began = std::time::Instant::now();
     let now = target;
-    let Some(area) = layout.output(surface.id).map(|o| o.area) else {
+    let Some(area) = wm.layout.output(surface.id).map(|o| o.area) else {
         return false;
     };
     let mut elements = Vec::new();
@@ -680,21 +672,18 @@ fn render_surface(state: &mut State, crtc: crtc::Handle, target: u64) -> bool {
     match crate::lock::elements(lock, renderer, &surface.output) {
         Some(locked) => elements.extend(locked),
         None => elements.extend(crate::scene::build(
-            layout,
+            wm,
             surface.id,
-            windows,
-            anim,
             renderer,
             now,
             &settings.config.decoration,
-            borders,
             Some(&surface.output),
             xwayland.as_ref().map_or(&[], |x| &x.unmanaged),
         )),
     }
     let scene_ns = scene_began.elapsed().as_nanos() as u64;
-    let animating = anim.active(now);
-    anim.prune(now);
+    let animating = wm.anim.active(now);
+    wm.anim.prune(now);
     let render_began = std::time::Instant::now();
     let cpu_began = thread_cpu_ns();
     let mut queue_ns = 0;
@@ -742,7 +731,7 @@ fn render_surface(state: &mut State, crtc: crtc::Handle, target: u64) -> bool {
         crate::lock::send_frames(lock, &output, elapsed);
         return animating && !surface.queued;
     }
-    for window in space.elements_for_output(&output) {
+    for window in wm.space.elements_for_output(&output) {
         window.send_frame(&output, elapsed, Some(Duration::ZERO), |_, _| {
             Some(output.clone())
         });

Modified file: crates/monolith/src/handlers.rs+8 additions−7 deletions@@ -72,13 +72,14 @@ impl CompositorHandler for State {
             while let Some(parent) = get_parent(&root) {
                 root = parent;
             }
-            if let Some(window) = self
-                .wm
-                .windows
-                .values()
-                .chain(&self.wm.unmapped)
-                .find(|w| crate::state::root(w).as_ref() == Some(&root))
-            {
+            let mapped = self.wm.id_of(&root).and_then(|id| self.wm.window(id));
+            let window = mapped.or_else(|| {
+                self.wm
+                    .unmapped
+                    .iter()
+                    .find(|w| crate::state::root(w).as_ref() == Some(&root))
+            });
+            if let Some(window) = window {
                 window.on_commit();
             }
             if self.services.captures.wants_damage()

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

@@ -173,7 +173,7 @@ fn snapshot(state: &State) -> monolith_ipc::State {

173173 let mut windows: Vec<monolith_ipc::Window> = l

174174 .windows()

175175 .map(|(id, w)| {

176- let (app_id, title) = state.wm.windows.get(&id).map(identity).unwrap_or_default();

176+ let (app_id, title) = state.wm.window(id).map(identity).unwrap_or_default();

177177 monolith_ipc::Window {

178178 id: slotmap::Key::data(&id).as_ffi(),

179179 app_id,

Modified file: crates/monolith/src/nested/mod.rs+5 additions−17 deletions@@ -8,7 +8,6 @@ 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;
@@ -175,15 +174,7 @@ pub fn render(state: &mut State) {
     let State {
         backend,
         renderer,
-        wm:
-            Wm {
-                layout,
-                windows,
-                anim,
-                borders,
-                space,
-                ..
-            },
+        wm,
         needs_redraw,
         core,
         settings,
@@ -242,14 +233,11 @@ pub fn render(state: &mut State) {
         let o = host.output_id;
         let elements = crate::lock::elements(lock, renderer, &host.output).unwrap_or_else(|| {
             crate::scene::build(
-                layout,
+                wm,
                 o,
-                windows,
-                anim,
                 renderer,
                 now,
                 &settings.config.decoration,
-                borders,
                 Some(&host.output),
                 xwayland.as_ref().map_or(&[], |x| &x.unmanaged),
             )
@@ -270,12 +258,12 @@ pub fn render(state: &mut State) {
             }
         }
     };
-    *needs_redraw = anim.active(now);
-    anim.prune(now);
+    *needs_redraw = wm.anim.active(now);
+    wm.anim.prune(now);
     lock.shown(&host.output);
     let elapsed = core.start.elapsed();
     crate::lock::send_frames(lock, &host.output, elapsed);
-    for window in space.elements().filter(|_| !lock.active()) {
+    for window in wm.space.elements().filter(|_| !lock.active()) {
         window.send_frame(&host.output, elapsed, Some(Duration::ZERO), |_, _| {
             Some(host.output.clone())
         });

Modified file: crates/monolith/src/scene.rs+10 additions−22 deletions@@ -1,9 +1,9 @@
 //! What a frame draws. The space holds final geometry for input, while the
 //! scene draws windows where the animator says they are right now.
 
-use crate::anim::Animator;
+use crate::wm::Wm;
 use monolith_config::Decoration;
-use monolith_layout::{Layout, OutputId, Rect, WindowId};
+use monolith_layout::{OutputId, Rect};
 use monolith_render_vk::{Effect, VulkanFrame, VulkanRenderer, VulkanTexture};
 use smithay::backend::renderer::element::memory::MemoryRenderBufferRenderElement;
 use smithay::backend::renderer::element::solid::{SolidColorBuffer, SolidColorRenderElement};
@@ -21,7 +21,6 @@ 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! {
     pub Draw<=VulkanRenderer>;
@@ -34,26 +33,18 @@ smithay::backend::renderer::element::render_elements! {
     Rescaled=RescaleRenderElement<WaylandSurfaceRenderElement<VulkanRenderer>>,
 }
 
-/// Border strips per window, kept between frames so unchanged borders cause
-/// no damage.
-#[derive(Default)]
-pub struct Borders(HashMap<WindowId, [SolidColorBuffer; 4]>);
-
 /// Elements for output `o` in its own coordinates, front to back.
-#[expect(clippy::too_many_arguments)]
 #[profiling::function]
 pub fn build(
-    layout: &Layout,
+    wm: &mut Wm,
     o: OutputId,
-    windows: &HashMap<WindowId, Window>,
-    anim: &Animator,
     renderer: &mut VulkanRenderer,
     now: u64,
     deco: &Decoration,
-    borders: &mut Borders,
     output: Option<&Output>,
     unmanaged: &[X11Surface],
 ) -> Vec<Draw> {
+    let (layout, anim, windows) = wm.parts();
     let Some(area) = layout.output(o).map(|out| out.area) else {
         return Vec::new();
     };
@@ -90,7 +81,6 @@ pub fn build(
         let glide = anim.gliding(w, now);
         above.push((w, local(glide.unwrap_or(area)), false, glide.is_some()));
     }
-    borders.0.retain(|id, _| windows.contains_key(id));
     let focused = layout.focused();
     let mut out = Vec::new();
     for x in unmanaged.iter().rev() {
@@ -112,11 +102,11 @@ pub fn build(
         }
     }
     for (id, r, framed, gliding) in tiled.into_iter().chain(above).rev() {
-        let Some(window) = windows.get(&id) else {
+        let Some(state) = windows.get_mut(id) else {
             continue;
         };
         let effect = anim.effect(id, now);
-        window_elements(&mut out, renderer, window, r, effect, gliding);
+        window_elements(&mut out, renderer, &state.window, r, effect, gliding);
         if framed && deco.border > 0 {
             let color = if focused == Some(id) {
                 deco.focused.0
@@ -124,7 +114,8 @@ pub fn build(
                 deco.unfocused.0
             };
             let alpha = effect.map_or(1.0, |e| e.progress);
-            border_elements(&mut out, borders, id, r, deco.border as i32, color, alpha);
+            let borders = &mut state.borders;
+            border_elements(&mut out, borders, r, deco.border as i32, color, alpha);
         }
     }
     for (g, r) in ghosts.into_iter().rev() {
@@ -242,8 +233,7 @@ fn window_elements(
 /// Four strips just outside `r`, in the gap, so the client keeps its size.
 fn border_elements(
     out: &mut Vec<Draw>,
-    borders: &mut Borders,
-    id: WindowId,
+    borders: &mut Option<[SolidColorBuffer; 4]>,
     r: Rect,
     b: i32,
     color: [f32; 4],
@@ -259,9 +249,7 @@ fn border_elements(
         ((x + w, y), (b, h)),
     ];
     let buffers = borders
-        .0
-        .entry(id)
-        .or_insert_with(|| std::array::from_fn(|_| SolidColorBuffer::new((0, 0), color)));
+        .get_or_insert_with(|| std::array::from_fn(|_| SolidColorBuffer::new((0, 0), color)));
     for (buffer, (at, size)) in buffers.iter_mut().zip(strips) {
         buffer.update(size, color);
         out.push(Draw::Border(SolidColorRenderElement::from_buffer(

Modified file: crates/monolith/src/state.rs+38 additions−47 deletions@@ -11,7 +11,7 @@ use monolith_render_vk::VulkanTexture;
 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::desktop::{Window, WindowSurfaceType};
 use smithay::input::keyboard::{Keycode, XkbConfig};
 use smithay::input::pointer::CursorImageStatus;
 use smithay::input::{Seat, SeatState};
@@ -149,20 +149,7 @@ impl State {
                 path: config_path,
             },
             renderer,
-            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,
-            },
+            wm: Wm::new(layout, Animator::new(animation)),
             backend: crate::backend::Backend::Starting,
             cursor: crate::cursor::Cursor::load(),
             cursor_status: CursorImageStatus::default_named(),
@@ -258,9 +245,6 @@ impl State {
             )
         });
         let id = self.wm.layout.add_window(output, tag, float);
-        if rule.tag.is_some() || rule.output.is_some() {
-            self.wm.placed_by_rule.insert(id);
-        }
         if rule.floating == Some(true) {
             self.wm.layout.toggle_floating(id);
         }
@@ -270,7 +254,8 @@ impl State {
         if let Some(name) = &rule.scratchpad {
             self.wm.layout.scratchpad_add(id, name);
         }
-        self.wm.windows.insert(id, window);
+        self.wm
+            .insert(id, window, rule.tag.is_some() || rule.output.is_some());
         self.await_first_buffer(id);
         if self.wm.layout.visible(id) {
             self.wm.layout.focus(id);
@@ -282,7 +267,6 @@ 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.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);
@@ -292,7 +276,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.wm.awaiting.is_empty() {
+        if !self.wm.any_awaiting() {
             return;
         }
         let has_buffer =
@@ -303,8 +287,11 @@ impl State {
     }
 
     fn first_buffer(&mut self, id: WindowId) {
-        self.wm.placed_by_rule.remove(&id);
-        if self.wm.awaiting.remove(&id) {
+        let Some(w) = self.wm.get_mut(id) else {
+            return;
+        };
+        w.placed_by_rule = false;
+        if std::mem::take(&mut w.awaiting_buffer) {
             self.wm.anim.spawned(id, now_ns());
             self.apply_layout();
         }
@@ -320,12 +307,11 @@ impl State {
     }
 
     pub fn remove_window(&mut self, id: WindowId) {
-        if let Some(window) = self.wm.windows.remove(&id) {
-            self.wm.space.unmap_elem(&window);
-            self.leave_ghost(id, &window);
+        if let Some(state) = self.wm.remove(id) {
+            self.wm.space.unmap_elem(&state.window);
+            self.leave_ghost(id, &state.window);
         }
         self.wm.layout.remove_window(id);
-        self.wm.placed_by_rule.remove(&id);
         self.apply_layout();
     }
 
@@ -379,11 +365,7 @@ impl State {
     }
 
     pub fn window_id(&self, surface: &WlSurface) -> Option<WindowId> {
-        self.wm
-            .windows
-            .iter()
-            .find(|(_, w)| root(w).as_ref() == Some(surface))
-            .map(|(id, _)| *id)
+        self.wm.id_of(surface)
     }
 
     /// Pushes the layout's target geometry into the space and to clients.
@@ -412,7 +394,7 @@ impl State {
                 .tiled
                 .iter()
                 .map(|p| p.window)
-                .filter(|w| self.wm.awaiting.contains(w))
+                .filter(|&w| self.wm.get(w).is_some_and(|s| s.awaiting_buffer))
                 .collect();
             let planned = if held.is_empty() {
                 arr.tiled.clone()
@@ -426,8 +408,8 @@ impl State {
 
         let mut glides = Vec::new();
         for &(id, rect, kind, _) in &shown {
-            match self.wm.last_kind.get(&id) {
-                Some(&(was, from, o)) if was != kind => {
+            match self.wm.get(id).and_then(|s| s.placed) {
+                Some((was, from, o)) if was != kind => {
                     let from = self
                         .wm
                         .anim
@@ -440,7 +422,7 @@ impl State {
                         .unwrap_or(from);
                     glides.push((id, from, rect));
                 }
-                Some(&(Kind::Floating, from, _)) if from != rect => self.wm.anim.stop_glide(id),
+                Some((Kind::Floating, from, _)) if from != rect => self.wm.anim.stop_glide(id),
                 _ => {}
             }
         }
@@ -469,31 +451,39 @@ impl State {
         for (id, from, to) in glides {
             self.wm.anim.glide(id, from, to, now);
         }
-        self.wm.last_kind = shown.iter().map(|&(id, r, k, o)| (id, (k, r, o))).collect();
+        for (_, s) in self.wm.iter_mut() {
+            s.placed = None;
+        }
+        for &(id, r, k, o) in &shown {
+            if let Some(s) = self.wm.get_mut(id) {
+                s.placed = Some((k, r, o));
+            }
+        }
 
         let mut mapped = Vec::new();
         for (id, rect, kind, _) in shown {
-            if let Some(window) = self.wm.windows.get(&id)
-                && configure(window, rect, kind, self.wm.layout.maximized(id))
+            if let Some(window) = self.wm.window(id).cloned()
+                && 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.wm.space.map_element(window.clone(), loc, false);
+                self.wm.space.map_element(window, loc, false);
                 mapped.push(id);
             }
         }
         let hidden: Vec<Window> = self
             .wm
-            .windows
             .iter()
             .filter(|(id, _)| !mapped.contains(id))
-            .map(|(_, w)| w.clone())
+            .map(|(_, w)| w.window.clone())
             .collect();
         for window in hidden {
             self.wm.space.unmap_elem(&window);
         }
-        for id in &mapped {
-            self.wm.space.raise_element(&self.wm.windows[id], false);
+        for id in mapped {
+            if let Some(window) = self.wm.window(id).cloned() {
+                self.wm.space.raise_element(&window, false);
+            }
         }
         self.sync_focus();
         self.update_inhibit();
@@ -502,8 +492,9 @@ impl State {
 
     pub fn sync_focus(&mut self) {
         let focused = self.wm.layout.focused();
-        for (id, window) in &self.wm.windows {
-            if window.set_activated(Some(*id) == focused)
+        for (id, s) in self.wm.iter() {
+            let window = &s.window;
+            if window.set_activated(Some(id) == focused)
                 && let Some(t) = window.toplevel()
                 && t.is_initial_configure_sent()
             {
@@ -514,7 +505,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.wm.windows.get(&id))?;
+                let w = focused.and_then(|id| self.wm.window(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())),

Modified file: crates/monolith/src/toplevels.rs+12 additions−46 deletions@@ -7,21 +7,8 @@ use monolith_protocols::toplevel::{
     Action, ForeignToplevelHandler, ForeignToplevelState, Snapshot, Toplevel,
 };
 use smithay::wayland::foreign_toplevel_list::{
-    ForeignToplevelHandle, ForeignToplevelListHandler, ForeignToplevelListState,
+    ForeignToplevelListHandler, ForeignToplevelListState,
 };
-use std::collections::HashMap;
-
-#[derive(Default)]
-pub struct ListHandles(HashMap<WindowId, ForeignToplevelHandle>);
-
-impl ListHandles {
-    pub fn window(&self, toplevel: &ForeignToplevelHandle) -> Option<WindowId> {
-        self.0
-            .iter()
-            .find(|(_, h)| h.identifier() == toplevel.identifier())
-            .map(|(id, _)| *id)
-    }
-}
 
 pub fn key(id: WindowId) -> u64 {
     slotmap::Key::data(&id).as_ffi()
@@ -39,7 +26,7 @@ impl ForeignToplevelHandler for State {
     }
 
     fn foreign_toplevel_action(&mut self, action: Action) {
-        let id_of = |k: u64| self.wm.windows.keys().copied().find(|&id| key(id) == k);
+        let id_of = |k: u64| self.wm.iter().map(|(id, _)| id).find(|&id| key(id) == k);
         match action {
             Action::Activate(k) => {
                 let Some(id) = id_of(k) else { return };
@@ -54,15 +41,8 @@ impl ForeignToplevelHandler for State {
                 self.wm.layout.focus(id);
             }
             Action::Close(k) => {
-                let Some(window) = id_of(k).and_then(|id| self.wm.windows.get(&id)) else {
-                    return;
-                };
-                match (window.toplevel(), window.x11_surface()) {
-                    (Some(t), _) => t.send_close(),
-                    (_, Some(x)) => {
-                        let _ = x.close();
-                    }
-                    _ => {}
+                if let Some(window) = id_of(k).and_then(|id| self.wm.window(id)) {
+                    crate::wm::close(window);
                 }
                 return;
             }
@@ -92,17 +72,10 @@ 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.wm.list_handles.0);
-        handles.retain(|id, h| {
-            let keep = self.wm.windows.contains_key(id);
-            if !keep {
-                self.protocols.toplevel_list.remove_toplevel(h);
-            }
-            keep
-        });
-        for (id, window) in &self.wm.windows {
-            let (app_id, title) = identity(window);
-            match handles.get(id) {
+        let list = &mut self.protocols.toplevel_list;
+        for (_, w) in self.wm.iter_mut() {
+            let (app_id, title) = identity(&w.window);
+            match &w.list_handle {
                 Some(h) => {
                     if h.title() != title || h.app_id() != app_id {
                         h.send_title(&title);
@@ -110,16 +83,10 @@ impl State {
                         h.send_done();
                     }
                 }
-                None => {
-                    let h = self
-                        .protocols
-                        .toplevel_list
-                        .new_toplevel::<State>(title, app_id);
-                    handles.insert(*id, h);
-                }
+                None => w.list_handle = Some(list.new_toplevel::<State>(title, app_id)),
             }
         }
-        self.wm.list_handles.0 = handles;
+        list.cleanup_closed_handles();
 
         if !self.protocols.foreign_toplevels.has_clients() {
             return;
@@ -127,10 +94,9 @@ impl State {
         let focused = self.wm.layout.focused();
         let toplevels = self
             .wm
-            .windows
             .iter()
-            .map(|(&id, window)| {
-                let (app_id, title) = identity(window);
+            .map(|(id, w)| {
+                let (app_id, title) = identity(&w.window);
                 let w = self.wm.layout.window(id);
                 Toplevel {
                     key: key(id),

Modified file: crates/monolith/src/wm.rs+118 additions−12 deletions@@ -1,29 +1,135 @@
-//! The window model: the layout and what monolith keeps per window beside it.
+//! The window model: the layout, and one record per window for everything
+//! monolith keeps beside it.
 
 use crate::anim::Animator;
-use crate::state::Kind;
+use crate::state::{Kind, root};
 use monolith_layout::{Layout, OutputId, Rect, WindowId};
+use slotmap::SecondaryMap;
+use smithay::backend::renderer::element::solid::SolidColorBuffer;
 use smithay::desktop::{PopupManager, Space, Window};
 use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
-use std::collections::{HashMap, HashSet};
+use smithay::wayland::foreign_toplevel_list::ForeignToplevelHandle;
+use std::collections::HashMap;
 
 pub struct Wm {
     pub layout: Layout,
-    pub windows: HashMap<WindowId, Window>,
+    windows: SecondaryMap<WindowId, WindowState>,
+    by_surface: HashMap<WlSurface, WindowId>,
     /// 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>,
 }
+
+pub struct WindowState {
+    pub window: Window,
+    /// How the last layout pass placed it, to spot switches between tiled,
+    /// floating and fullscreen.
+    pub placed: Option<(Kind, Rect, OutputId)>,
+    /// Held on its seed until its first buffer lands.
+    pub awaiting_buffer: bool,
+    /// A rule sent it somewhere, so activation tokens leave it alone.
+    pub placed_by_rule: bool,
+    pub list_handle: Option<ForeignToplevelHandle>,
+    pub borders: Option<[SolidColorBuffer; 4]>,
+}
+
+/// Asks a window to close, through xdg-shell or X11.
+pub fn close(window: &Window) {
+    match (window.toplevel(), window.x11_surface()) {
+        (Some(t), _) => t.send_close(),
+        (_, Some(x)) => {
+            if let Err(e) = x.close() {
+                tracing::debug!("closing an X11 window failed: {e}");
+            }
+        }
+        _ => {}
+    }
+}
+
+impl Wm {
+    pub fn new(layout: Layout, anim: Animator) -> Self {
+        Self {
+            layout,
+            windows: SecondaryMap::new(),
+            by_surface: HashMap::new(),
+            unmapped: Vec::new(),
+            space: Space::default(),
+            popups: PopupManager::default(),
+            anim,
+            layer_focus: None,
+        }
+    }
+
+    pub fn insert(&mut self, id: WindowId, window: Window, placed_by_rule: bool) {
+        self.windows.insert(
+            id,
+            WindowState {
+                window,
+                placed: None,
+                awaiting_buffer: true,
+                placed_by_rule,
+                list_handle: None,
+                borders: None,
+            },
+        );
+        self.index(id);
+    }
+
+    /// Drops every trace of a window. The layout and space are the caller's.
+    pub fn remove(&mut self, id: WindowId) -> Option<WindowState> {
+        let state = self.windows.remove(id)?;
+        self.by_surface.retain(|_, w| *w != id);
+        if let Some(h) = &state.list_handle {
+            h.send_closed();
+        }
+        self.anim.forget(id);
+        Some(state)
+    }
+
+    /// Indexes a window by its surface. X11 windows only have one once
+    /// xwayland-shell associates it, which may be after they are mapped.
+    pub fn index(&mut self, id: WindowId) {
+        if let Some(surface) = self.windows.get(id).and_then(|w| root(&w.window)) {
+            self.by_surface.insert(surface, id);
+        }
+    }
+
+    pub fn id_of(&self, surface: &WlSurface) -> Option<WindowId> {
+        self.by_surface.get(surface).copied()
+    }
+
+    pub fn get(&self, id: WindowId) -> Option<&WindowState> {
+        self.windows.get(id)
+    }
+
+    pub fn get_mut(&mut self, id: WindowId) -> Option<&mut WindowState> {
+        self.windows.get_mut(id)
+    }
+
+    pub fn window(&self, id: WindowId) -> Option<&Window> {
+        self.windows.get(id).map(|w| &w.window)
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = (WindowId, &WindowState)> {
+        self.windows.iter()
+    }
+
+    pub fn iter_mut(&mut self) -> impl Iterator<Item = (WindowId, &mut WindowState)> {
+        self.windows.iter_mut()
+    }
+
+    /// The layout and animator to read alongside the records to write, which
+    /// a frame needs at once.
+    pub fn parts(&mut self) -> (&Layout, &Animator, &mut SecondaryMap<WindowId, WindowState>) {
+        (&self.layout, &self.anim, &mut self.windows)
+    }
+
+    pub fn any_awaiting(&self) -> bool {
+        self.windows.values().any(|w| w.awaiting_buffer)
+    }
+}

Modified file: crates/monolith/src/xwayland.rs+8 additions−7 deletions@@ -217,7 +217,10 @@ impl XWaylandShellHandler for State {
         &mut self.protocols.xwayland_shell_state
     }
 
-    fn surface_associated(&mut self, _xwm: XwmId, surface: WlSurface, _window: X11Surface) {
+    fn surface_associated(&mut self, _xwm: XwmId, surface: WlSurface, window: X11Surface) {
+        if let Some(id) = self.x11_window_id(&window) {
+            self.wm.index(id);
+        }
         self.on_buffer(&surface);
         self.needs_redraw = true;
     }
@@ -321,10 +324,9 @@ impl XwmHandler for State {
         tracing::info!("Xwayland exited");
         let gone: Vec<_> = self
             .wm
-            .windows
             .iter()
-            .filter(|(_, w)| w.x11_surface().is_some())
-            .map(|(id, _)| *id)
+            .filter(|(_, w)| w.window.x11_surface().is_some())
+            .map(|(id, _)| id)
             .collect();
         for id in gone {
             self.remove_window(id);
@@ -359,10 +361,9 @@ fn floats(window: &X11Surface) -> bool {
 impl State {
     pub fn x11_window_id(&self, window: &X11Surface) -> Option<monolith_layout::WindowId> {
         self.wm
-            .windows
             .iter()
-            .find(|(_, w)| w.x11_surface() == Some(window))
-            .map(|(id, _)| *id)
+            .find(|(_, w)| w.window.x11_surface() == Some(window))
+            .map(|(id, _)| id)
     }
 
     fn forget_x11(&mut self, window: &X11Surface) {

monolith

Commit 60956e3999de

Commit `60956e3999de`