monolith

public

Star0

Fork 0

Watch0

155 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `fd834695f723`

tarball

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

2 files changed+71-5

windows: glide once when a toggled float learns its size

A tiled window toggled to floating glided toward the default float rect while the client was still answering the configure, then snapped to its natural rect when the commit arrived. It now stays where it was drawn, through Layout::hold_float_rect, and glides once from there to the centred rect. A client that never answers is given its committed geometry after 300 ms.

Modified file: crates/layout/src/lib.rs+8 additions@@ -652,6 +652,14 @@ impl Layout {
         }
     }
 
+    /// Places a float without settling its size, so a window still deciding
+    /// on one is asked again after being tiled.
+    pub fn hold_float_rect(&mut self, w: WindowId, rect: Rect) {
+        if let Some(win) = self.windows.get_mut(w) {
+            win.float_rect = Some(rect);
+        }
+    }
+
     pub fn toggle_fullscreen(&mut self, w: WindowId) {
         if let Some(win) = self.windows.get_mut(w) {
             win.fullscreen = !win.fullscreen;

Modified file: crates/monolith/src/windows.rs+63 additions−5 deletions@@ -1,6 +1,6 @@
 use crate::anim::Ghost;
 use crate::state::{State, now_ns};
-use crate::wm::{LastFrame, identity, root};
+use crate::wm::{Kind, LastFrame, identity, root};
 use monolith_layout::{OutputId, Rect, WindowId};
 use monolith_render_vk::VulkanTexture;
 use smithay::backend::renderer::Renderer;
@@ -257,12 +257,17 @@ impl State {
             (Some(x), _) => crate::xwayland::fixed_size(x),
             (_, Some(t)) if crate::xdg::fixed_size(t).is_some() => current,
             (_, Some(t)) => {
+                let held = self.visual_rect(id);
                 let serial = crate::wm::configure_free(t);
                 if let Some(w) = self.wm.get_mut(id)
-                    && serial.is_some()
+                    && let Some(serial) = serial
                 {
                     w.natural_size = true;
-                    w.natural_after = serial;
+                    w.natural_after = Some(serial);
+                    if let Some(rect) = held {
+                        self.wm.layout.hold_float_rect(id, rect);
+                    }
+                    self.await_natural_size(id, serial);
                     return;
                 }
                 current
@@ -280,7 +285,51 @@ impl State {
         }
     }
 
-    /// Centres a window over its parent, or else its output.
+    /// Where a placed window is drawn right now.
+    fn visual_rect(&self, id: WindowId) -> Option<Rect> {
+        let now = now_ns();
+        let (kind, rect, o) = self.wm.get(id)?.placed?;
+        self.wm
+            .anim
+            .gliding(id, now)
+            .or_else(|| {
+                (kind == Kind::Tiled)
+                    .then(|| self.wm.anim.tiled(o, id, now))
+                    .flatten()
+            })
+            .or(Some(rect))
+    }
+
+    /// A client that never answers a request for its size takes whatever
+    /// size it has.
+    fn await_natural_size(&mut self, id: WindowId, serial: Serial) {
+        let timeout = Timer::from_duration(Duration::from_millis(300));
+        let _ = self.core.handle.insert_source(timeout, move |_, _, state| {
+            state.give_up_natural_size(id, serial);
+            TimeoutAction::Drop
+        });
+    }
+
+    fn give_up_natural_size(&mut self, id: WindowId, serial: Serial) {
+        let Some(w) = self.wm.get_mut(id) else {
+            return;
+        };
+        if !w.natural_size || w.natural_after != Some(serial) {
+            return;
+        }
+        w.natural_size = false;
+        w.natural_after = None;
+        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));
+        } else if let Some(rect) = self.wm.layout.window(id).and_then(|w| w.float_rect) {
+            self.wm.layout.set_float_rect(id, rect);
+        }
+        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) {
         let parent = self
             .wm
@@ -299,7 +348,16 @@ impl State {
         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));
+            let rect = Rect::new(x, y, 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();
+                let from = self.wm.anim.gliding(id, now).unwrap_or(from);
+                self.wm.anim.glide(id, from, rect, now);
+                if let Some(s) = self.wm.get_mut(id) {
+                    s.placed = Some((Kind::Floating, rect, o));
+                }
+            }
         }
     }

monolith

Commit fd834695f723

Commit `fd834695f723`