monolith

public

Star0

Fork 0

Watch0

239 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `c1b89405f8fd`

tarball

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

5 files changed+52-3

input: stretch windows during a mouse resize and configure on release

Every motion event of a resize drag sent a configure, and a split drag sent one to each neighbouring tile, so clients redrew dozens of times a second at sizes nobody kept. The windows a drag reshapes now hold their size and are drawn stretched from their last buffer, and the final size goes out once when the button is released.

Modified file: crates/monolith/src/input.rs+12 additions@@ -2,6 +2,7 @@
 //! into these calls, with pointer positions in global logical coordinates.
 
 use crate::state::{Input, State};
+use crate::wm::Resizing;
 use monolith_layout::{Axis, Dir, Layout, MIN_FLOAT_SIZE, Rect, WindowId, clamp_float};
 use smithay::backend::input::{ButtonState, InputTime, KeyState};
 use smithay::backend::session::Session;
@@ -55,6 +56,9 @@ impl State {
                 .drag
                 .take_if(|d| d.button.is_none_or(|b| b == button));
             if ended.is_some() {
+                if self.wm.resizing.take().is_some() {
+                    self.apply_layout();
+                }
                 let pos = self.input.pointer_pos;
                 let over = self.surface_under(pos).is_some();
                 self.input.hover = self.edge_at(pos, over).map(|(_, e)| e);
@@ -551,6 +555,14 @@ fn begin_drag(state: &mut State, id: WindowId, edges: Option<Edges>, button: Opt
     ) else {
         return false;
     };
+    state.wm.resizing = win
+        .output
+        .filter(|_| edges.is_some())
+        .map(|output| Resizing {
+            output,
+            window: id,
+            tiled,
+        });
     state.input.drag = Some(Drag {
         window: id,
         from: state.input.pointer_pos,

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

@@ -78,6 +78,7 @@ impl SessionLockHandler for State {

7878 self.services.lock.pending = Some(confirmation);

7979 self.services.lock.blanked.clear();

8080 self.input.drag = None;

81+ self.wm.resizing = None;

8182 self.sync_focus();

8283 self.dirty.redraw = true;

8384 }

Modified file: crates/monolith/src/scene.rs+9 additions−2 deletions@@ -47,7 +47,9 @@ pub fn build(
         anim,
         windows,
         last_frames,
+        resizing,
     } = wm.parts();
+    let stretched = |w, tiled| resizing.is_some_and(|r| r.holds(w, tiled, o));
     let Some(area) = layout.output(o).map(|out| out.area) else {
         return Vec::new();
     };
@@ -82,13 +84,18 @@ pub fn build(
             Some(r) => above.push((p.window, local(r), true, true)),
             None => {
                 let r = anim.tiled(o, p.window, now).unwrap_or(p.rect);
-                tiled.push((p.window, local(r), true, false));
+                tiled.push((p.window, local(r), true, stretched(p.window, true)));
             }
         }
     }
     let float = |&(w, r): &(WindowId, Rect)| {
         let glide = anim.gliding(w, now);
-        (w, local(glide.unwrap_or(r)), true, glide.is_some())
+        (
+            w,
+            local(glide.unwrap_or(r)),
+            true,
+            glide.is_some() || stretched(w, false),
+        )
     };
     let (over, under): (Vec<_>, Vec<_>) =
         arr.floating.iter().partition(|f| arr.over.contains(&f.0));

Modified file: crates/monolith/src/state.rs+9 additions−1 deletions@@ -396,12 +396,20 @@ impl State {
         let mut mapped = Vec::new();
         for (id, rect, kind, o) in shown {
             let free = kind == Kind::Floating && self.wm.get(id).is_some_and(|s| s.natural_size);
+            let held = self
+                .wm
+                .resizing
+                .is_some_and(|r| r.holds(id, kind == Kind::Tiled, o))
+                && rect.w >= 1.0
+                && rect.h >= 1.0;
             let scale = self
                 .backend
                 .output(o)
                 .map_or(1.0, |o| o.current_scale().fractional_scale());
             if let Some(window) = self.wm.window(id).cloned()
-                && (free || configure(&window, rect, kind, self.wm.layout.maximized(id), scale))
+                && (free
+                    || held
+                    || configure(&window, rect, kind, self.wm.layout.maximized(id), scale))
             {
                 let loc = (rect.x.round() as i32, rect.y.round() as i32);
                 self.wm.space.map_element(window, loc, false);

Modified file: crates/monolith/src/wm.rs+21 additions@@ -33,6 +33,24 @@ pub struct Wm {
     pub layer_focus: Option<WlSurface>,
     /// What closed windows still show while their ghost animates.
     pub last_frames: HashMap<WindowId, LastFrame>,
+    pub resizing: Option<Resizing>,
+}
+
+/// A mouse resize in progress. The windows it reshapes keep their size and
+/// are drawn stretched until the button is released, rather than being sent
+/// a configure for every motion event.
+#[derive(Clone, Copy)]
+pub struct Resizing {
+    pub output: OutputId,
+    pub window: WindowId,
+    /// Moving a split reshapes every tile on the output, not just one.
+    pub tiled: bool,
+}
+
+impl Resizing {
+    pub fn holds(&self, id: WindowId, tiled: bool, o: OutputId) -> bool {
+        self.output == o && if self.tiled { tiled } else { id == self.window }
+    }
 }
 
 pub struct LastFrame {
@@ -51,6 +69,7 @@ pub struct Parts<'a> {
     pub anim: &'a Animator,
     pub windows: &'a mut SecondaryMap<WindowId, WindowState>,
     pub last_frames: &'a HashMap<WindowId, LastFrame>,
+    pub resizing: Option<Resizing>,
 }
 
 pub struct WindowState {
@@ -120,6 +139,7 @@ impl Wm {
             anim,
             layer_focus: None,
             last_frames: HashMap::new(),
+            resizing: None,
         }
     }
 
@@ -211,6 +231,7 @@ impl Wm {
             anim: &self.anim,
             windows: &mut self.windows,
             last_frames: &self.last_frames,
+            resizing: self.resizing,
         }
     }

monolith

Commit c1b89405f8fd

Commit `c1b89405f8fd`