monolith

public

Star0

Fork 0

Watch0

127 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `621fc9d239f8`

tarball

atagen <boss@atagen.co>2026-10-18 03:18 UTC

4 files changed+62-3

monolith: float dialogs and size-capped wayland windows at their own size

Only X11 windows were floated by type and size hints, so Wayland dialogs tiled. A floating Wayland window is now configured without a size and placed over its parent or output once its first buffer shows the size it chose, where it used to be forced to 60% of the output. A rule's floating now sets the state rather than toggling it, which tiled X11 dialogs that a rule asked to float.

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

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

359359 let mut mapped = Vec::new();

360360 for (id, rect, kind, _) in shown {

361361 if let Some(window) = self.wm.window(id).cloned()

362+ && !self.wm.get(id).is_some_and(|s| s.natural_size)

362363 && configure(&window, rect, kind, self.wm.layout.maximized(id))

363364 {

364365 let loc = (rect.x.round() as i32, rect.y.round() as i32);

Modified file: crates/monolith/src/windows.rs+43 additions−2 deletions@@ -50,8 +50,13 @@ impl State {
                 f64::from(r.size.h),
             )
         });
-        let id = self.wm.layout.add_window(output, tag, float);
-        if rule.floating == Some(true) {
+        let auto = float.is_some() || window.toplevel().is_some_and(crate::xdg::floats);
+        let floating = rule.floating.unwrap_or(auto);
+        let id = self
+            .wm
+            .layout
+            .add_window(output, tag, float.filter(|_| floating));
+        if floating != self.wm.layout.window(id).is_some_and(|w| w.floating) {
             self.wm.layout.toggle_floating(id);
         }
         if rule.sticky == Some(true) {
@@ -62,7 +67,11 @@ impl State {
         }
         self.view_if_first(id);
         let by_rule = rule.tag.is_some() || rule.output.is_some();
+        let natural_size = floating && window.toplevel().is_some();
         self.wm.insert(id, window, by_rule, app_id, title);
+        if let Some(s) = self.wm.get_mut(id) {
+            s.natural_size = natural_size;
+        }
         self.await_first_buffer(id);
         if self.wm.layout.visible(id) {
             self.wm.layout.focus(id);
@@ -98,12 +107,44 @@ impl State {
             return;
         };
         w.placed_by_rule = false;
+        if std::mem::take(&mut w.natural_size) {
+            let size = w.window.geometry().size;
+            if size.w > 0 && size.h > 0 {
+                self.float_at_natural_size(id, f64::from(size.w), f64::from(size.h));
+            }
+        }
+        let Some(w) = self.wm.get_mut(id) else {
+            return;
+        };
         if std::mem::take(&mut w.awaiting_buffer) {
             self.wm.anim.spawned(id, now_ns());
             self.apply_layout();
         }
     }
 
+    /// Centres a window over its parent, or else its output.
+    fn float_at_natural_size(&mut self, id: WindowId, w: f64, h: f64) {
+        let parent = self
+            .wm
+            .window(id)
+            .and_then(|win| win.toplevel()?.parent())
+            .and_then(|p| self.window_id(&p))
+            .and_then(|p| self.wm.get(p)?.placed)
+            .map(|(_, r, _)| r);
+        let output = self
+            .wm
+            .layout
+            .window(id)
+            .and_then(|win| win.output)
+            .and_then(|o| self.wm.layout.output(o))
+            .map(|o| o.area);
+        if let Some(around) = parent.or(output) {
+            let x = around.x + (around.w - w) / 2.0;
+            let y = around.y + (around.h - h) / 2.0;
+            self.wm.layout.set_float_rect(id, Rect::new(x, y, w, h));
+        }
+    }
+
     pub fn unmap_window(&mut self, surface: &WlSurface) {
         self.wm
             .unmapped

Modified file: crates/monolith/src/wm.rs+4 additions@@ -55,6 +55,9 @@ pub struct WindowState {
     pub placed: Option<(Kind, Rect, OutputId)>,
     /// Held on its seed until its first buffer lands.
     pub awaiting_buffer: bool,
+    /// Configured without a size until its first buffer shows the one it
+    /// picked.
+    pub natural_size: bool,
     /// A rule sent it somewhere, so activation tokens leave it alone.
     pub placed_by_rule: bool,
     pub list_handle: Option<ForeignToplevelHandle>,
@@ -110,6 +113,7 @@ impl Wm {
                 window,
                 placed: None,
                 awaiting_buffer: true,
+                natural_size: false,
                 placed_by_rule,
                 list_handle: None,
                 borders: None,

Modified file: crates/monolith/src/xdg.rs+14 additions−1 deletions@@ -6,10 +6,23 @@ use smithay::reexports::wayland_server::protocol::wl_seat::WlSeat;
 use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
 use smithay::utils::Serial;
 use smithay::wayland::shell::xdg::decoration::XdgDecorationHandler;
+use smithay::wayland::compositor::with_states;
 use smithay::wayland::shell::xdg::{
-    PopupSurface, PositionerState, ToplevelSurface, XdgShellHandler, XdgShellState,
+    PopupSurface, PositionerState, SurfaceCachedState, ToplevelSurface, XdgShellHandler,
+    XdgShellState,
 };
 
+/// Dialogs, and windows that cap their size and so could never fill a tile.
+pub fn floats(toplevel: &ToplevelSurface) -> bool {
+    let max = with_states(toplevel.wl_surface(), |s| {
+        s.cached_state
+            .get::<SurfaceCachedState>()
+            .current()
+            .max_size
+    });
+    toplevel.parent().is_some() || (max.w > 0 && max.h > 0)
+}
+
 impl XdgShellHandler for State {
     fn xdg_shell_state(&mut self) -> &mut XdgShellState {
         &mut self.protocols.xdg_shell_state

monolith

Commit 621fc9d239f8

Commit `621fc9d239f8`