monolith

public

Star0

Fork 0

Watch0

151 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `754ca2132943`

tarball

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

6 files changed+170-42

windows: ask a window that becomes floating for its own size

A toggled tiled window took the layout's default float rect, about 60 percent of the output, which dwarfs dialog-like content. Layout::Window::float_default now marks such rects. apply_layout asks xdg toplevels to pick a size with a configure that has none and no tiled states, centres them on the first commit after the ack, and uses the size hints of fixed-size windows directly. Fixed-size xdg windows use their committed geometry because GTK reports min and max sizes that disagree with it.

Modified file: crates/layout/src/lib.rs+6 additions@@ -61,6 +61,9 @@ pub struct Window {
     pub tag: TagId,
     pub floating: bool,
     pub float_rect: Option<Rect>,
+    /// `float_rect` is the layout's default, not a size the window or the
+    /// user chose.
+    pub float_default: bool,
     pub fullscreen: bool,
     pub sticky: bool,
     pub scratchpad: Option<usize>,
@@ -325,6 +328,7 @@ impl Layout {
             tag,
             floating: floating.is_some(),
             float_rect: floating,
+            float_default: false,
             fullscreen: false,
             sticky: false,
             scratchpad: None,
@@ -364,6 +368,7 @@ impl Layout {
             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;
             }
             self.outputs[o].floating.push(w);
             return;
@@ -629,6 +634,7 @@ impl Layout {
     pub fn set_float_rect(&mut self, w: WindowId, rect: Rect) {
         if let Some(win) = self.windows.get_mut(w) {
             win.float_rect = Some(rect);
+            win.float_default = false;
         }
     }
 

Modified file: crates/monolith/src/state.rs+3 additions−2 deletions@@ -247,6 +247,7 @@ impl State {
 
     /// Pushes the layout's target geometry into the space and to clients.
     pub fn apply_layout(&mut self) {
+        self.size_new_floats();
         let now = now_ns();
         let mut shown = Vec::new();
         let mut tracks = Vec::new();
@@ -364,9 +365,9 @@ impl State {
 
         let mut mapped = Vec::new();
         for (id, rect, kind, _) in shown {
+            let free = kind == Kind::Floating && self.wm.get(id).is_some_and(|s| s.natural_size);
             if let Some(window) = self.wm.window(id).cloned()
-                && !self.wm.get(id).is_some_and(|s| s.natural_size)
-                && configure(&window, rect, kind, self.wm.layout.maximized(id))
+                && (free || 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;

Modified file: crates/monolith/src/windows.rs+90 additions−2 deletions@@ -9,7 +9,9 @@ use smithay::desktop::Window;
 use smithay::reexports::calloop::timer::{TimeoutAction, Timer};
 use smithay::reexports::wayland_server::Resource;
 use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
-use smithay::utils::{Logical, Point, Rectangle};
+use smithay::utils::{Logical, Point, Rectangle, Serial};
+use smithay::wayland::compositor::with_states;
+use smithay::wayland::shell::xdg::XdgToplevelSurfaceData;
 use std::time::Duration;
 
 impl State {
@@ -108,7 +110,11 @@ impl State {
         let Some(w) = self.wm.get_mut(id) else {
             return;
         };
-        let natural = std::mem::take(&mut w.natural_size);
+        let natural = w.natural_size && w.natural_after.is_none_or(|s| acked(&w.window, s));
+        if natural {
+            w.natural_size = false;
+            w.natural_after = None;
+        }
         let reclassify = std::mem::take(&mut w.reclassify);
         let size = w.window.geometry().size;
         let sized = natural || (reclassify && self.float_if_hinted(id));
@@ -159,6 +165,74 @@ impl State {
         true
     }
 
+    /// Gives floats that landed on the layout's default rect their own size,
+    /// as when a tiled window is toggled. The client is told to pick one, and
+    /// its next commit after acking says which.
+    pub fn size_new_floats(&mut self) {
+        let stale: Vec<WindowId> = self
+            .wm
+            .iter()
+            .filter(|(id, s)| {
+                s.natural_size && !self.wm.layout.window(*id).is_some_and(|w| w.floating)
+            })
+            .map(|(id, _)| id)
+            .collect();
+        for id in stale {
+            if let Some(s) = self.wm.get_mut(id) {
+                s.natural_size = false;
+                s.natural_after = None;
+            }
+        }
+        let defaults: Vec<WindowId> = self
+            .wm
+            .layout
+            .windows()
+            .filter(|(_, w)| w.floating && w.float_default && w.scratchpad.is_none())
+            .map(|(id, _)| id)
+            .collect();
+        for id in defaults {
+            self.ask_natural_size(id);
+        }
+    }
+
+    fn ask_natural_size(&mut self, id: WindowId) {
+        let Some(window) = self
+            .wm
+            .get(id)
+            .filter(|s| !s.natural_size)
+            .map(|s| s.window.clone())
+        else {
+            return;
+        };
+        let geometry = window.geometry().size;
+        let current = (geometry.w > 0 && geometry.h > 0).then_some(geometry);
+        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(t)) => {
+                let serial = crate::wm::configure_free(t);
+                if let Some(w) = self.wm.get_mut(id)
+                    && serial.is_some()
+                {
+                    w.natural_size = true;
+                    w.natural_after = serial;
+                    return;
+                }
+                current
+            }
+            _ => None,
+        };
+        match size {
+            Some(size) => self.float_at_natural_size(id, f64::from(size.w), f64::from(size.h)),
+            None => {
+                let rect = self.wm.layout.window(id).and_then(|w| w.float_rect);
+                if let Some(rect) = rect {
+                    self.wm.layout.set_float_rect(id, rect);
+                }
+            }
+        }
+    }
+
     /// 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
@@ -322,3 +396,17 @@ impl State {
         self.wm.id_of(surface)
     }
 }
+
+/// Whether the client has acknowledged the configure with `serial` or a later
+/// one.
+fn acked(window: &Window, serial: Serial) -> bool {
+    let Some(t) = window.toplevel() else {
+        return true;
+    };
+    with_states(t.wl_surface(), |s| {
+        let data = s.data_map.get::<XdgToplevelSurfaceData>()?.lock().ok()?;
+        let last = data.last_acked.as_ref()?;
+        Some(last.serial.is_no_older_than(&serial))
+    })
+    .unwrap_or(false)
+}

Modified file: crates/monolith/src/wm.rs+45 additions−25 deletions@@ -10,11 +10,11 @@ use smithay::backend::renderer::element::solid::SolidColorBuffer;
 use smithay::desktop::{PopupManager, Space, Window};
 use smithay::reexports::wayland_protocols::xdg::shell::server::xdg_toplevel::State as XdgState;
 use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
-use smithay::utils::{Logical, Rectangle, Transform};
+use smithay::utils::{Logical, Rectangle, Serial, Transform};
 use smithay::wayland::compositor::with_states;
 use smithay::wayland::foreign_toplevel_list::ForeignToplevelHandle;
 use smithay::wayland::seat::WaylandFocus;
-use smithay::wayland::shell::xdg::XdgToplevelSurfaceData;
+use smithay::wayland::shell::xdg::{ToplevelState, ToplevelSurface, XdgToplevelSurfaceData};
 use std::collections::HashMap;
 
 pub struct Wm {
@@ -58,6 +58,9 @@ pub struct WindowState {
     /// Configured without a size until its first buffer shows the one it
     /// picked.
     pub natural_size: bool,
+    /// The configure that gave it free choice of size, whose ack the buffer
+    /// has to follow to show that choice.
+    pub natural_after: Option<Serial>,
     /// Tiled by default, but its size hints are only reliable at its first
     /// buffer and may turn it into a float.
     pub reclassify: bool,
@@ -117,6 +120,7 @@ impl Wm {
                 placed: None,
                 awaiting_buffer: true,
                 natural_size: false,
+                natural_after: None,
                 reclassify: false,
                 placed_by_rule,
                 list_handle: None,
@@ -231,29 +235,7 @@ pub fn configure(window: &Window, rect: Rect, kind: Kind, maximized: bool) -> bo
     if let Some(t) = window.toplevel() {
         t.with_pending_state(|s| {
             s.size = Some((w, h).into());
-            let tiled = [
-                XdgState::TiledLeft,
-                XdgState::TiledRight,
-                XdgState::TiledTop,
-                XdgState::TiledBottom,
-            ];
-            for st in tiled {
-                if kind == Kind::Tiled {
-                    s.states.set(st);
-                } else {
-                    s.states.unset(st);
-                }
-            }
-            if kind == Kind::Fullscreen {
-                s.states.set(XdgState::Fullscreen);
-            } else {
-                s.states.unset(XdgState::Fullscreen);
-            }
-            if maximized && kind == Kind::Tiled {
-                s.states.set(XdgState::Maximized);
-            } else {
-                s.states.unset(XdgState::Maximized);
-            }
+            set_states(s, kind, maximized);
         });
         if t.is_initial_configure_sent() {
             t.send_pending_configure();
@@ -262,6 +244,44 @@ pub fn configure(window: &Window, rect: Rect, kind: Kind, maximized: bool) -> bo
     true
 }
 
+/// Lets a floating toplevel pick its own size, returning the serial of the
+/// configure that says so. None if it was sent nothing.
+pub fn configure_free(t: &ToplevelSurface) -> Option<Serial> {
+    t.with_pending_state(|s| {
+        s.size = None;
+        set_states(s, Kind::Floating, false);
+    });
+    t.is_initial_configure_sent()
+        .then(|| t.send_pending_configure())
+        .flatten()
+}
+
+fn set_states(s: &mut ToplevelState, kind: Kind, maximized: bool) {
+    let tiled = [
+        XdgState::TiledLeft,
+        XdgState::TiledRight,
+        XdgState::TiledTop,
+        XdgState::TiledBottom,
+    ];
+    for st in tiled {
+        if kind == Kind::Tiled {
+            s.states.set(st);
+        } else {
+            s.states.unset(st);
+        }
+    }
+    if kind == Kind::Fullscreen {
+        s.states.set(XdgState::Fullscreen);
+    } else {
+        s.states.unset(XdgState::Fullscreen);
+    }
+    if maximized && kind == Kind::Tiled {
+        s.states.set(XdgState::Maximized);
+    } else {
+        s.states.unset(XdgState::Maximized);
+    }
+}
+
 /// A window's surface, for xdg toplevels and X11 windows alike.
 pub fn root(window: &Window) -> Option<WlSurface> {
     window.wl_surface().map(|s| s.into_owned())

Modified file: crates/monolith/src/xdg.rs+16 additions−7 deletions@@ -4,7 +4,7 @@ use smithay::reexports::wayland_protocols::xdg::decoration::zv1::server::zxdg_to
 use smithay::reexports::wayland_server::protocol::wl_output::WlOutput;
 use smithay::reexports::wayland_server::protocol::wl_seat::WlSeat;
 use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
-use smithay::utils::Serial;
+use smithay::utils::{Logical, Serial, Size};
 use smithay::wayland::shell::xdg::decoration::XdgDecorationHandler;
 use smithay::wayland::compositor::with_states;
 use smithay::wayland::shell::xdg::{
@@ -14,15 +14,24 @@ use smithay::wayland::shell::xdg::{
 
 /// 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
-    });
+    let (_, max) = size_hints(toplevel);
     toplevel.parent().is_some() || (max.w > 0 && max.h > 0)
 }
 
+/// The size of a window that asks for exactly one.
+pub fn fixed_size(toplevel: &ToplevelSurface) -> Option<Size<i32, Logical>> {
+    let (min, max) = size_hints(toplevel);
+    (min == max && min.w > 0 && min.h > 0).then_some(min)
+}
+
+fn size_hints(toplevel: &ToplevelSurface) -> (Size<i32, Logical>, Size<i32, Logical>) {
+    with_states(toplevel.wl_surface(), |s| {
+        let mut cached = s.cached_state.get::<SurfaceCachedState>();
+        let current = cached.current();
+        (current.min_size, current.max_size)
+    })
+}
+
 impl XdgShellHandler for State {
     fn xdg_shell_state(&mut self) -> &mut XdgShellState {
         &mut self.protocols.xdg_shell_state

Modified file: crates/monolith/src/xwayland.rs+10 additions−6 deletions@@ -9,7 +9,7 @@ use smithay::reexports::calloop::generic::Generic;
 use smithay::reexports::calloop::{Interest, Mode, PostAction, RegistrationToken};
 use smithay::reexports::rustix::io::{FdFlags, fcntl_getfd, fcntl_setfd};
 use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;
-use smithay::utils::{Logical, Rectangle};
+use smithay::utils::{Logical, Rectangle, Size};
 use smithay::wayland::xwayland_shell::{XWaylandShellHandler, XWaylandShellState};
 use smithay::xwayland::xwm::{Reorder, ResizeEdge, WmWindowProperty, WmWindowType, XwmId};
 use smithay::xwayland::{X11Surface, X11Wm, XWayland, XWaylandEvent, XwmHandler};
@@ -358,11 +358,15 @@ fn floats(window: &X11Surface) -> bool {
                 | WmWindowType::Menu
         )
     );
-    let fixed = matches!(
-        (window.min_size(), window.max_size()),
-        (Some(min), Some(max)) if min == max && min.w > 0
-    );
-    kind || fixed || window.is_transient_for().is_some()
+    kind || fixed_size(window).is_some() || window.is_transient_for().is_some()
+}
+
+/// The size of a window that asks for exactly one.
+pub fn fixed_size(window: &X11Surface) -> Option<Size<i32, Logical>> {
+    match (window.min_size(), window.max_size()) {
+        (Some(min), Some(max)) if min == max && min.w > 0 && min.h > 0 => Some(min),
+        _ => None,
+    }
 }
 
 impl State {

monolith

Commit 754ca2132943

Commit `754ca2132943`