monolith

public

Star0

Fork 0

Watch0

209 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `abe5e42a95d6`

tarball

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

4 files changed+260-16

input: resize from the nearest edge on Mod+right-drag

Mod+right-drag always grew a floating window from its bottom-right corner and ignored tiled windows. The pointer's cell in a 3x3 grid over the window now picks the edges, and tiled windows move the split next to those edges through the new Tree::move_split, which changes only the two tiles meeting at the split so it tracks the pointer.

Modified file: crates/layout/src/lib.rs+21 additions@@ -593,6 +593,27 @@ impl Layout {
         done
     }
 
+    /// Whether `w` is tiled with a visible window across the split on side `dir`.
+    pub fn has_split(&self, w: WindowId, dir: Dir) -> bool {
+        let Some(o) = self.windows.get(w).and_then(|w| w.output) else {
+            return false;
+        };
+        self.outputs[o].tree.has_split(w, dir, self.vis_on(o))
+    }
+
+    /// Moves the split on side `dir` of the tiled window `w` by `px`, positive
+    /// toward the right or bottom.
+    pub fn move_split(&mut self, w: WindowId, dir: Dir, px: f64) -> bool {
+        let Some(o) = self.windows.get(w).and_then(|w| w.output) else {
+            return false;
+        };
+        let area = inset(self.outputs[o].usable(), self.gaps.outer);
+        let mut tree = std::mem::take(&mut self.outputs[o].tree);
+        let moved = tree.move_split(w, dir, px, area, self.gaps.inner, self.vis_on(o));
+        self.outputs[o].tree = tree;
+        moved
+    }
+
     pub fn expand(&mut self, scope: ExpandScope) -> bool {
         let Some((w, o)) = self.focused_tiled() else {
             return false;

Modified file: crates/layout/src/tests.rs+36 additions@@ -677,3 +677,39 @@ fn floats_shrink_into_a_smaller_output_they_are_evicted_to() {
     assert!(r.x >= usable.x && r.right() <= usable.right());
     assert!(r.y >= usable.y && r.bottom() <= usable.bottom());
 }
+
+/// Dragging a split moves only the two tiles that meet at it, whichever of
+/// them the drag started from, and stops where one would vanish.
+#[test]
+fn dragging_a_split_moves_just_that_split() {
+    let mut l = Layout::default();
+    let o = l.add_output("a", AREA);
+    let a = l.add_window(Some(o), None, None);
+    let b = l.add_window(Some(o), None, None);
+    let c = l.add_window(Some(o), None, None);
+    let rect = |l: &Layout, w| {
+        l.arrange(o)
+            .tiled
+            .iter()
+            .find(|p| p.window == w)
+            .unwrap()
+            .rect
+    };
+    let before = [rect(&l, a), rect(&l, b), rect(&l, c)];
+    assert!(!l.has_split(a, Dir::Up));
+    assert!(!l.move_split(a, Dir::Up, 50.0));
+    assert!(l.has_split(a, Dir::Down));
+
+    assert!(l.move_split(a, Dir::Down, 40.0));
+    let (ra, rb) = (rect(&l, a), rect(&l, b));
+    assert!((ra.h - before[0].h - 40.0).abs() < 1e-6);
+    assert!((rb.h - before[1].h + 40.0).abs() < 1e-6);
+    assert_eq!(rect(&l, c).h, before[2].h);
+
+    assert!(l.move_split(b, Dir::Up, -40.0));
+    assert!((rect(&l, a).h - before[0].h).abs() < 1e-6);
+
+    l.move_split(a, Dir::Down, 1e6);
+    assert!(rect(&l, b).h > 1.0);
+    l.check();
+}

Modified file: crates/layout/src/tree.rs+94 additions@@ -426,6 +426,100 @@ impl<W: Copy + Eq + Hash> Tree<W> {
         false
     }
 
+    /// The lane a window's split on side `dir` lives in, as the child holding
+    /// the window, its parent and the index of the visible sibling across
+    /// the split.
+    fn split_across(
+        &self,
+        w: W,
+        dir: Dir,
+        vis: &impl Fn(W) -> bool,
+    ) -> Option<(NodeId, NodeId, usize)> {
+        let mut cur = *self.leaves.get(&w)?;
+        if !self.visible(cur, vis) {
+            return None;
+        }
+        while let Some((p, i)) = self.position(cur) {
+            if self.axis(p) == Some(dir.axis())
+                && let Some(j) = self.next_shown(p, i, dir, vis)
+            {
+                return Some((cur, p, j));
+            }
+            cur = p;
+        }
+        None
+    }
+
+    /// Whether the split on side `dir` of `w` has a visible window across it.
+    pub fn has_split(&self, w: W, dir: Dir, vis: impl Fn(W) -> bool) -> bool {
+        self.split_across(w, dir, &vis).is_some()
+    }
+
+    /// Moves the split on side `dir` of `w` by `px` along that side's axis,
+    /// positive toward the right or bottom. Only the two children meeting at
+    /// the split change, so the split follows the pointer.
+    pub fn move_split(
+        &mut self,
+        w: W,
+        dir: Dir,
+        px: f64,
+        area: Rect,
+        gap: f64,
+        vis: impl Fn(W) -> bool,
+    ) -> bool {
+        let Some((cur, p, j)) = self.split_across(w, dir, &vis) else {
+            return false;
+        };
+        let axis = dir.axis();
+        let other = self.children(p)[j];
+        let (first, second) = if dir.forward() {
+            (cur, other)
+        } else {
+            (other, cur)
+        };
+        let mut leaves = Vec::new();
+        self.shown_leaves(first, &vis, &mut leaves);
+        let (start, end) = self
+            .arrange(area, gap, &vis)
+            .iter()
+            .filter(|(l, _)| leaves.contains(l))
+            .map(|(_, r)| span(*r, axis))
+            .fold((f64::MAX, f64::MIN), |(s, e), (rs, rl)| {
+                (s.min(rs), e.max(rs + rl))
+            });
+        let ef = self.extent(first, axis, &vis);
+        let es = self.extent(second, axis, &vis);
+        if end <= start || ef <= 0.0 || es <= 0.0 {
+            return true;
+        }
+        let sum: f64 = self
+            .children(p)
+            .iter()
+            .filter(|&&c| self.visible(c, &vis))
+            .map(|&c| self.extent(c, axis, &vis))
+            .sum();
+        let min = MIN_SHARE * sum;
+        let du = (px * ef / (end - start)).clamp(-(ef - min).max(0.0), (es - min).max(0.0));
+        self.scale(first, axis, (ef + du) / ef);
+        self.scale(second, axis, (es - du) / es);
+        true
+    }
+
+    fn shown_leaves(&self, n: NodeId, vis: &impl Fn(W) -> bool, out: &mut Vec<W>) {
+        match &self.nodes[n].kind {
+            Kind::Leaf(w, _) => {
+                if vis(*w) {
+                    out.push(*w);
+                }
+            }
+            Kind::Container { children, .. } => {
+                for &c in children {
+                    self.shown_leaves(c, vis, out);
+                }
+            }
+        }
+    }
+
     /// Scales every window under `n` along `axis`, hidden ones too, so they
     /// keep their proportions for when they are shown again.
     fn scale(&mut self, n: NodeId, axis: Axis, by: f64) {

Modified file: crates/monolith/src/input.rs+109 additions−16 deletions@@ -2,7 +2,7 @@
 //! into these calls, with pointer positions in global logical coordinates.
 
 use crate::state::State;
-use monolith_layout::{MIN_FLOAT_SIZE, Rect, WindowId, clamp_float};
+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;
 use smithay::input::keyboard::{FilterResult, Keycode, xkb};
@@ -246,7 +246,7 @@ const BTN_LEFT: u32 = 0x110;
 const BTN_RIGHT: u32 = 0x111;
 
 /// The sides of a window a resize moves.
-#[derive(Clone, Copy, Default)]
+#[derive(Clone, Copy, Default, PartialEq, Eq)]
 pub struct Edges {
     left: bool,
     right: bool,
@@ -255,12 +255,52 @@ pub struct Edges {
 }
 
 impl Edges {
-    const BOTTOM_RIGHT: Self = Self {
-        left: false,
-        right: true,
-        top: false,
-        bottom: true,
-    };
+    /// The edges a drag from pos resizes, from the cell of a 3x3 grid over
+    /// the rect. The centre cell takes the nearest corner.
+    fn grid(r: Rect, pos: Point<f64, Logical>) -> Self {
+        let (fx, fy) = ((pos.x - r.x) / r.w, (pos.y - r.y) / r.h);
+        let third = |f: f64| match f {
+            f if f < 1.0 / 3.0 => -1,
+            f if f > 2.0 / 3.0 => 1,
+            _ => 0,
+        };
+        let (col, row) = match (third(fx), third(fy)) {
+            (0, 0) => (if fx < 0.5 { -1 } else { 1 }, if fy < 0.5 { -1 } else { 1 }),
+            cell => cell,
+        };
+        Self {
+            left: col < 0,
+            right: col > 0,
+            top: row < 0,
+            bottom: row > 0,
+        }
+    }
+
+    fn dirs(self) -> impl Iterator<Item = Dir> {
+        [
+            (Dir::Left, self.left),
+            (Dir::Right, self.right),
+            (Dir::Up, self.top),
+            (Dir::Down, self.bottom),
+        ]
+        .into_iter()
+        .filter_map(|(dir, on)| on.then_some(dir))
+    }
+
+    /// Drops the edges of a tiled window that have no split to move.
+    fn movable(self, layout: &Layout, id: WindowId) -> Self {
+        let has = |dir, on: bool| on && layout.has_split(id, dir);
+        Self {
+            left: has(Dir::Left, self.left),
+            right: has(Dir::Right, self.right),
+            top: has(Dir::Up, self.top),
+            bottom: has(Dir::Down, self.bottom),
+        }
+    }
+
+    fn any(self) -> bool {
+        self.left || self.right || self.top || self.bottom
+    }
 
     pub fn from_xdg(edge: xdg_toplevel::ResizeEdge) -> Option<Self> {
         use xdg_toplevel::ResizeEdge as E;
@@ -310,6 +350,8 @@ pub struct Drag {
     from: Point<f64, Logical>,
     rect: Rect,
     bounds: Rect,
+    /// A tiled window, whose splits follow the pointer instead of a rect.
+    tiled: bool,
     /// None moves the window.
     edges: Option<Edges>,
     /// The client's button, whose release is still the client's to see.
@@ -332,32 +374,67 @@ fn start_drag(state: &mut State, button: u32) -> bool {
     if !held {
         return false;
     }
-    let edges = (button == BTN_RIGHT).then_some(Edges::BOTTOM_RIGHT);
+    let edges = match button {
+        BTN_RIGHT => {
+            let Some(rect) = window_rect(&state.wm.layout, id) else {
+                return false;
+            };
+            Some(Edges::grid(rect, state.input.pointer_pos))
+        }
+        _ => None,
+    };
     begin_drag(state, id, edges, None)
 }
 
+fn window_rect(layout: &Layout, id: WindowId) -> Option<Rect> {
+    let win = layout.window(id)?;
+    if win.floating {
+        return win.float_rect;
+    }
+    layout
+        .arrange(win.output?)
+        .tiled
+        .iter()
+        .find(|p| p.window == id && p.visible)
+        .map(|p| p.rect)
+}
+
 impl State {
     /// Starts moving, or with `edges` resizing, a floating window at a
     /// client's request. Tiled windows are left alone.
     pub fn client_drag(&mut self, id: WindowId, edges: Option<Edges>, button: u32) {
-        begin_drag(self, id, edges, Some(button));
+        if self.wm.layout.window(id).is_some_and(|w| w.floating) {
+            begin_drag(self, id, edges, Some(button));
+        }
     }
 }
 
 fn begin_drag(state: &mut State, id: WindowId, edges: Option<Edges>, button: Option<u32>) -> bool {
     let layout = &state.wm.layout;
-    let Some((rect, bounds)) = layout
-        .window(id)
-        .filter(|w| w.floating && !w.fullscreen)
-        .and_then(|w| Some((w.float_rect?, layout.output(w.output?)?.usable())))
-    else {
+    let Some(win) = layout.window(id).filter(|w| !w.fullscreen) else {
+        return false;
+    };
+    let tiled = !win.floating;
+    let edges = if tiled {
+        edges.map(|e| e.movable(layout, id)).filter(|e| e.any())
+    } else {
+        edges
+    };
+    if tiled && edges.is_none() {
+        return false;
+    }
+    let (Some(rect), Some(out)) = (
+        window_rect(layout, id),
+        win.output.and_then(|o| layout.output(o)),
+    ) else {
         return false;
     };
     state.input.drag = Some(Drag {
         window: id,
         from: state.input.pointer_pos,
         rect,
-        bounds,
+        bounds: out.usable(),
+        tiled,
         edges,
         button,
     });
@@ -392,6 +469,22 @@ fn drag_to(state: &mut State, pos: Point<f64, Logical>) -> bool {
         return false;
     };
     let (dx, dy) = (pos.x - d.from.x, pos.y - d.from.y);
+    if let (true, Some(e)) = (d.tiled, d.edges) {
+        let id = d.window;
+        for dir in e.dirs() {
+            let px = if dir.axis() == Axis::Horizontal {
+                dx
+            } else {
+                dy
+            };
+            state.wm.layout.move_split(id, dir, px);
+        }
+        if let Some(d) = state.input.drag.as_mut() {
+            d.from = pos;
+        }
+        state.apply_layout();
+        return true;
+    }
     let r = d.rect;
     let rect = match d.edges {
         Some(e) => {

monolith

Commit abe5e42a95d6

Commit `abe5e42a95d6`