monolith

public

Star0

Fork 0

Watch0

230 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `20a4ebbb7f15`

tarball

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

2 files changed+59-9

windows: size and place floating windows by rule

float_at_natural_size always centred a float over its parent or output at the size its client picked, so config could neither fix a size nor a spot. WindowState now keeps the matching Placement, and float_rect_for applies its size, position, centring and bounds to rule sized windows at map and to natural sizes at first buffer.

Modified file: crates/monolith/src/windows.rs+50 additions−9 deletions@@ -1,6 +1,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, WindowId};
 use monolith_render_vk::VulkanTexture;
 use smithay::backend::renderer::Renderer;
@@ -70,13 +71,19 @@ impl State {
         }
         self.view_if_first(id);
         let by_rule = rule.tag.is_some() || rule.output.is_some();
-        let natural_size = floating && !fullscreen && window.toplevel().is_some();
+        let natural_size =
+            floating && !fullscreen && window.toplevel().is_some() && rule.size.is_none();
         let reclassify = !floating && rule.floating.is_none() && window.toplevel().is_some();
-        self.wm.insert(id, window, by_rule, app_id, title);
+        let shaped = rule.at.is_some() || rule.min_size.is_some() || rule.max_size.is_some();
+        let positioned = rule.size.is_some() || (shaped && !natural_size && !fullscreen);
+        self.wm.insert(id, window, by_rule, app_id, title, rule);
         if let Some(s) = self.wm.get_mut(id) {
             s.natural_size = natural_size;
             s.reclassify = reclassify;
         }
+        if positioned {
+            self.float_by_rule(id);
+        }
         self.await_first_buffer(id);
         if self.wm.layout.visible(id) && !self.wm.layout.covered(id) {
             self.wm.layout.focus(id);
@@ -320,9 +327,27 @@ impl State {
         self.apply_layout();
     }
 
-    /// Centres a window over its parent, or else its output. One already
-    /// floating glides there from where it is drawn.
-    fn float_at_natural_size(&mut self, id: WindowId, w: f64, h: f64) {
+    /// Gives a floating window the size and spot its rules ask for, keeping
+    /// whichever of the two they leave out.
+    fn float_by_rule(&mut self, id: WindowId) {
+        let Some(win) = self.wm.layout.window(id).filter(|win| win.floating) else {
+            return;
+        };
+        let held = win.float_rect.map(|r| (r.w, r.h));
+        let size = self.wm.get(id).and_then(|s| s.rule.size);
+        let Some((w, h)) = size.map(|(w, h)| (f64::from(w), f64::from(h))).or(held) else {
+            return;
+        };
+        if let Some(rect) = self.float_rect_for(id, w, h) {
+            self.wm.layout.set_float_rect(id, rect);
+        }
+    }
+
+    /// 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.
+    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));
         let parent = self
             .wm
             .layout
@@ -337,10 +362,26 @@ impl State {
             .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;
-            let rect = Rect::new(x, y, w, h);
+        let at = rule.and_then(|r| r.at);
+        let around = if at.is_some() {
+            output
+        } else {
+            parent.or(output)
+        }?;
+        let (x, y) = match at {
+            Some(At::Position(x, y)) => (around.x + f64::from(x), around.y + f64::from(y)),
+            _ => (
+                around.x + (around.w - w) / 2.0,
+                around.y + (around.h - h) / 2.0,
+            ),
+        };
+        Some(Rect::new(x, y, w, h))
+    }
+
+    /// Sizes a window to what its client picked. One already floating glides
+    /// there from where it is drawn.
+    fn float_at_natural_size(&mut self, id: WindowId, w: f64, h: f64) {
+        if let Some(rect) = self.float_rect_for(id, w, h) {
             self.wm.layout.set_float_rect(id, rect);
             if let Some((Kind::Floating, from, o)) = self.wm.get(id).and_then(|s| s.placed) {
                 let now = now_ns();

Modified file: crates/monolith/src/wm.rs+9 additions@@ -3,6 +3,7 @@
 
 use crate::anim::Animator;
 
+use monolith_config::Placement;
 use monolith_layout::{Layout, OutputId, Rect, WindowId};
 use monolith_render_vk::VulkanTexture;
 use slotmap::SecondaryMap;
@@ -76,6 +77,11 @@ pub struct WindowState {
     pub borders: Option<[SolidColorBuffer; 4]>,
     pub app_id: String,
     pub title: String,
+    /// The title it mapped with, which `initial_title` rules match.
+    pub initial_title: String,
+    /// What the rules matching it say. Tearing presentation will read
+    /// `tearing` from here.
+    pub rule: Placement,
 }
 
 impl WindowState {
@@ -124,6 +130,7 @@ impl Wm {
         placed_by_rule: bool,
         app_id: String,
         title: String,
+        rule: Placement,
     ) {
         self.windows.insert(
             id,
@@ -139,7 +146,9 @@ impl Wm {
                 list_handle: None,
                 borders: None,
                 app_id,
+                initial_title: title.clone(),
                 title,
+                rule,
             },
         );
         self.index(id);

monolith

Commit 20a4ebbb7f15

Commit `20a4ebbb7f15`