monolith

public

Star0

Fork 0

Watch0

292 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `243161cd0662`

tarball

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

4 files changed+57-18

windows: place floats clear of bars and at their fixed or ruled size

float_rect_for and Layout::place centred on the full output area and never clamped, so a dialog on a parent near an edge ended up off screen or under the bar while scratchpads and drags used the usable area. A fixed-size dialog took its current geometry, which is the 60% default before it has drawn, and a window reclassified as a float at its first buffer never got its rule's size or position.

Modified file: crates/layout/src/lib.rs+8 additions−4 deletions@@ -403,10 +403,14 @@ impl Layout {
             return;
         }
         if win.floating {
-            if win.float_rect.is_none() {
-                let rect = centred(self.outputs[o].area, 0.6);
-                self.windows[w].float_rect = Some(rect);
-                self.windows[w].float_default = true;
+            let usable = self.outputs[o].usable();
+            let win = &mut self.windows[w];
+            match win.float_rect {
+                Some(rect) => win.float_rect = Some(clamp_float(rect, usable)),
+                None => {
+                    win.float_rect = Some(centred(usable, 0.6));
+                    win.float_default = true;
+                }
             }
             self.outputs[o].floating.push(w);
             return;

Modified file: crates/layout/src/scratchpad.rs+2 additions−3 deletions@@ -24,7 +24,7 @@ impl Layout {
             }
         };
         self.scratchpads[s].windows.push(w);
-        let area = self.windows[w].output.map(|o| self.outputs[o].area);
+        let area = self.windows[w].output.map(|o| self.outputs[o].usable());
         let win = &mut self.windows[w];
         win.scratchpad = Some(s);
         win.floating = true;
@@ -56,13 +56,12 @@ impl Layout {
         sp.output = Some(o);
         let w = sp.windows[next];
         self.last_scratchpad = Some(s);
-        let area = self.outputs[o].area;
         let usable = self.outputs[o].usable();
         let win = &mut self.windows[w];
         if win.output != Some(o) {
             win.float_rect = match (from, win.float_rect) {
                 (Some(from), Some(r)) => Some(translate(r, from, usable)),
-                _ => Some(centred(area, 0.6)),
+                _ => Some(centred(usable, 0.6)),
             };
             win.output = Some(o);
         }

Modified file: crates/layout/src/tests.rs+23 additions@@ -884,3 +884,26 @@ fn a_modal_brings_its_parent_up_beneath_it() {
     l.remove_window(dialog);
     assert_eq!(l.focused(), Some(parent));
 }
+
+/// Floats start inside what the bars leave of their output, whether they came
+/// with a rect hanging off its edge or take the default one.
+#[test]
+fn new_floats_land_inside_the_bars() {
+    let mut l = Layout::default();
+    let o = l.add_output("a", AREA);
+    let bar = Insets {
+        top: 40.0,
+        ..Insets::default()
+    };
+    l.set_reserved(o, bar);
+    let usable = l.output(o).unwrap().usable();
+
+    let hanging = l.add_window(None, None, Some(Rect::new(900.0, -30.0, 300.0, 200.0)));
+    let r = l.window(hanging).and_then(|w| w.float_rect).unwrap();
+    assert!(r.x >= usable.x && r.right() <= usable.right() && r.y >= usable.y);
+
+    let plain = l.add_window(None, None, None);
+    l.toggle_floating(plain);
+    let r = l.window(plain).and_then(|w| w.float_rect).unwrap();
+    assert_eq!(r.y + r.h / 2.0, usable.y + usable.h / 2.0);
+}

Modified file: crates/monolith/src/windows.rs+24 additions−11 deletions@@ -2,7 +2,7 @@ use crate::anim::Ghost;
 use crate::state::{State, now_ns};
 use crate::wm::{Kind, LastFrame, identity, root};
 use monolith_config::At;
-use monolith_layout::{OutputId, Rect, TagId, WindowId};
+use monolith_layout::{OutputId, Rect, TagId, WindowId, clamp_float};
 use monolith_render_vk::VulkanTexture;
 use smithay::backend::renderer::Renderer;
 use smithay::backend::renderer::utils::{import_surface_tree, with_renderer_surface_state};
@@ -232,10 +232,14 @@ impl State {
         }
         let reclassify = std::mem::take(&mut w.reclassify);
         let size = w.window.geometry().size;
-        let sized = natural || (reclassify && self.float_if_hinted(id));
+        let reclassified = reclassify && self.float_if_hinted(id);
+        let sized = natural || reclassified;
         if sized && size.w > 0 && size.h > 0 {
             self.float_at_natural_size(id, f64::from(size.w), f64::from(size.h));
         }
+        if reclassified {
+            self.float_by_rule(id);
+        }
         if !self.release_hold(id) && sized {
             self.apply_layout();
         }
@@ -321,9 +325,10 @@ impl State {
         };
         let geometry = window.geometry().size;
         let current = (geometry.w > 0 && geometry.h > 0).then_some(geometry);
+        let fixed = window.toplevel().and_then(crate::xdg::fixed_size);
         let size = match (window.x11_surface(), window.toplevel()) {
             (Some(x), _) => crate::xwayland::fixed_size(x),
-            (_, Some(t)) if crate::xdg::fixed_size(t).is_some() => current,
+            (_, Some(_)) if fixed.is_some() => fixed,
             (_, Some(t)) => {
                 let held = self.visual_rect(id);
                 let serial = crate::wm::configure_free(t);
@@ -426,7 +431,8 @@ impl State {
     }
 
     /// Where a floating window of this size goes. A rule can pick the spot,
-    /// otherwise it is centred over its parent, or else its output.
+    /// otherwise it is centred over its parent, or else its output, and kept
+    /// clear of the bars.
     fn float_rect_for(&self, id: WindowId, w: f64, h: f64) -> Option<Rect> {
         let rule = self.wm.get(id).map(|s| &s.rule);
         let (w, h) = rule.map_or((w, h), |r| r.clamp_size(w, h));
@@ -442,22 +448,29 @@ impl State {
             .layout
             .window(id)
             .and_then(|win| win.output)
-            .and_then(|o| self.wm.layout.output(o))
-            .map(|o| o.area);
+            .and_then(|o| self.wm.layout.output(o))?;
+        let usable = output.usable();
         let at = rule.and_then(|r| r.at);
         let around = if at.is_some() {
-            output
+            usable
         } else {
-            parent.or(output)
-        }?;
+            parent.unwrap_or(usable)
+        };
         let (x, y) = match at {
-            Some(At::Position(x, y)) => (around.x + f64::from(x), around.y + f64::from(y)),
+            Some(At::Position(x, y)) => {
+                return Some(Rect::new(
+                    output.area.x + f64::from(x),
+                    output.area.y + f64::from(y),
+                    w,
+                    h,
+                ));
+            }
             _ => (
                 around.x + (around.w - w) / 2.0,
                 around.y + (around.h - h) / 2.0,
             ),
         };
-        Some(Rect::new(x, y, w, h))
+        Some(clamp_float(Rect::new(x, y, w, h), usable))
     }
 
     /// Sizes a window to what its client picked. One already floating glides

monolith

Commit 243161cd0662

Commit `243161cd0662`