monolith

public

Star0

Fork 0

Watch0

167 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `86ef802692f5`

tarball

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

7 files changed+183-5

layout: split the anchor along its longer side on insert

Joining the anchor's container always grew the row or column it sat in, so a run of new windows never produced the dwindling layout users expect from a tiler. Tree::insert_split divides the anchor's own space instead, picking the axis from its arranged rect in Layout::place. general.autotile turns it off.

Modified file: crates/config/default.toml+3 additions@@ -9,6 +9,9 @@ startup = []
 # keeps super for itself.
 mod = "super"
 gaps = { inner = 8, outer = 8 }
+# A new window splits the one it opens beside along that window's longer side,
+# so windows dwindle. When off it joins the container of that window instead.
+autotile = true
 # What a window move does when it meets a neighbour. swap trades places,
 # merge joins its lane. invert-move does the other one for the next move.
 move = "swap"

Modified file: crates/config/src/lib.rs+4 additions@@ -31,6 +31,9 @@ pub struct General {
     #[serde(rename = "mod")]
     pub mod_key: Modifier,
     pub gaps: Gaps,
+    /// A new window splits the one it opens beside along that window's
+    /// longer side, instead of joining its container.
+    pub autotile: bool,
     /// What a window move does when it meets a neighbour.
     #[serde(rename = "move")]
     pub move_mode: MoveMode,
@@ -56,6 +59,7 @@ impl Default for General {
         Self {
             mod_key: Modifier::Super,
             gaps: Gaps::default(),
+            autotile: true,
             move_mode: MoveMode::Swap,
             focus_follows_mouse: false,
             mouse_follows_focus: false,

Modified file: crates/layout/src/lib.rs+26 additions−3 deletions@@ -130,6 +130,7 @@ pub struct Layout {
     last_scratchpad: Option<usize>,
     parked: HashMap<String, Parked>,
     pub gaps: Gaps,
+    pub autotile: bool,
 }
 
 impl Default for Layout {
@@ -151,6 +152,7 @@ impl Default for Layout {
             last_scratchpad: None,
             parked: HashMap::new(),
             gaps: Gaps::default(),
+            autotile: false,
         }
     }
 }
@@ -395,13 +397,34 @@ impl Layout {
                 .copied()
                 .find(|&h| tree.contains(h) && self.windows[h].tag == tag)
         });
+        let split = anchor
+            .filter(|_| self.autotile)
+            .and_then(|a| self.split_axis(o, a));
         let tree = &mut self.outputs[o].tree;
-        match anchor {
-            Some(a) => tree.insert_after(w, a),
-            None => tree.insert_row(w),
+        match (anchor, split) {
+            (Some(a), Some(axis)) => tree.insert_split(w, a, axis),
+            (Some(a), None) => tree.insert_after(w, a),
+            (None, _) => tree.insert_row(w),
         }
     }
 
+    /// The axis a window opening beside `anchor` should split it along, the
+    /// way the anchor is laid out right now. Hidden anchors have no shape.
+    fn split_axis(&self, o: OutputId, anchor: WindowId) -> Option<Axis> {
+        let rect = self
+            .arrange(o)
+            .tiled
+            .iter()
+            .find(|p| p.window == anchor && p.visible)?
+            .rect;
+        let axis = if rect.w > rect.h {
+            Axis::Horizontal
+        } else {
+            Axis::Vertical
+        };
+        (rect.w > 0.0 && rect.h > 0.0).then_some(axis)
+    }
+
     fn unplace(&mut self, w: WindowId) {
         let Some(o) = self.windows[w].output else {
             return;

Modified file: crates/layout/src/tests.rs+111 additions−2 deletions@@ -188,8 +188,14 @@ proptest! {
     #![proptest_config(ProptestConfig::with_cases(2000))]
 
     #[test]
-    fn random_commands_keep_the_model_sound(ops in prop::collection::vec(op(), 1..80)) {
-        let mut l = Layout::default();
+    fn random_commands_keep_the_model_sound(
+        ops in prop::collection::vec(op(), 1..80),
+        autotile in any::<bool>(),
+    ) {
+        let mut l = Layout {
+            autotile,
+            ..Layout::default()
+        };
         l.add_output("a", AREA);
         l.add_output("b", Rect::new(1000.0, 0.0, 800.0, 600.0));
         let tags = [l.homeless(), l.tag("1"), l.tag("2"), l.tag("3")];
@@ -502,3 +508,106 @@ fn fullscreen_leaves_its_transients_reachable() {
     assert!(!l.covered(stranger));
     assert_eq!(l.window(dialog).and_then(|w| w.parent), None);
 }
+
+fn rect_of(t: &Tree<u32>, w: u32, vis: impl Fn(u32) -> bool) -> Rect {
+    t.arrange(AREA, 0.0, vis)
+        .into_iter()
+        .find(|p| p.0 == w)
+        .unwrap()
+        .1
+}
+
+#[test]
+fn splitting_a_lone_window_shares_its_space() {
+    let (a, b, c) = (1, 2, 3);
+    let mut t: Tree<u32> = Tree::default();
+    t.insert_row(a);
+    t.insert_split(b, a, Axis::Horizontal);
+    t.check();
+    let (ra, rb) = (rect_of(&t, a, |_| true), rect_of(&t, b, |_| true));
+    assert_eq!((ra.w, rb.w, ra.h), (AREA.w / 2.0, AREA.w / 2.0, AREA.h));
+    assert!(ra.x < rb.x);
+
+    t.insert_split(c, b, Axis::Vertical);
+    t.check();
+    let (rb, rc) = (rect_of(&t, b, |_| true), rect_of(&t, c, |_| true));
+    assert_eq!(
+        (rb.h, rc.h, rb.w),
+        (AREA.h / 2.0, AREA.h / 2.0, AREA.w / 2.0)
+    );
+    assert!(rb.y < rc.y);
+    assert_eq!(rect_of(&t, a, |_| true), ra, "the sibling is undisturbed");
+}
+
+#[test]
+fn splitting_along_the_parents_axis_appends_a_sibling() {
+    let (a, b, c, d) = (1, 2, 3, 4);
+    let mut t: Tree<u32> = Tree::default();
+    t.insert_row(a);
+    t.insert_split(b, a, Axis::Horizontal);
+    t.insert_split(c, b, Axis::Vertical);
+    let before = rect_of(&t, a, |_| true);
+    t.insert_split(d, a, Axis::Horizontal);
+    t.check();
+    let all = |_| true;
+    let (ra, rd, rb) = (
+        rect_of(&t, a, all),
+        rect_of(&t, d, all),
+        rect_of(&t, b, all),
+    );
+    assert_eq!((ra.w, rd.w), (before.w / 2.0, before.w / 2.0));
+    assert!(ra.x < rd.x && rd.x < rb.x);
+    assert_eq!(rb.w, AREA.w / 2.0, "the neighbour keeps its share");
+}
+
+#[test]
+fn splitting_beside_hidden_windows_leaves_their_slots_alone() {
+    let (a, b, c, d) = (1, 2, 3, 4);
+    let mut t: Tree<u32> = Tree::default();
+    t.insert_row(a);
+    t.insert_after(b, a);
+    t.insert_after(c, a);
+    let tag_one = |w: u32| w == a || w == d;
+    assert_eq!(rect_of(&t, a, tag_one).h, AREA.h);
+
+    t.insert_split(d, a, Axis::Vertical);
+    t.check();
+    let (ra, rd) = (rect_of(&t, a, tag_one), rect_of(&t, d, tag_one));
+    assert_eq!((ra.h, rd.h, ra.w), (AREA.h / 2.0, AREA.h / 2.0, AREA.w));
+    assert!(ra.y < rd.y);
+
+    t.insert_split(d + 1, a, Axis::Horizontal);
+    t.check();
+    let shown = |w: u32| w == a || w == d + 1;
+    let (ra, re) = (rect_of(&t, a, shown), rect_of(&t, d + 1, shown));
+    assert_eq!((ra.w, re.w), (AREA.w / 2.0, AREA.w / 2.0));
+    assert!(ra.x < re.x);
+    assert_eq!(t.windows().count(), 5, "hidden windows stay in the tree");
+}
+
+#[test]
+fn autotile_dwindles_by_the_anchors_shape() {
+    let mut l = Layout {
+        autotile: true,
+        ..Layout::default()
+    };
+    let o = l.add_output("a", AREA);
+    let tag = l.tag("1");
+    l.view(o, tag);
+    let mut ids = Vec::new();
+    for _ in 0..4 {
+        let w = l.add_window(Some(o), Some(tag), None);
+        l.focus(w);
+        ids.push(w);
+        l.check();
+    }
+    let arr = l.arrange(o);
+    let r = |w| arr.tiled.iter().find(|p| p.window == w).unwrap().rect;
+    let [a, b, c, d] = [ids[0], ids[1], ids[2], ids[3]];
+    assert!(
+        r(a).x < r(b).x && r(a).h > r(b).h * 1.5,
+        "{a:?} left, {b:?} right"
+    );
+    assert!(r(b).y < r(c).y && r(b).x == r(c).x);
+    assert!(r(c).x < r(d).x && r(c).y == r(d).y);
+}

Modified file: crates/layout/src/tree.rs+37 additions@@ -147,6 +147,43 @@ impl<W: Copy + Eq + Hash> Tree<W> {
         }
     }
 
+    /// Inserts `w` after `anchor` by splitting `anchor` along `axis`. They
+    /// share the space `anchor` had, and its siblings keep theirs.
+    pub fn insert_split(&mut self, w: W, anchor: W, axis: Axis) {
+        let Some(&a) = self.leaves.get(&anchor) else {
+            return self.insert_row(w);
+        };
+        let size = self.size(a);
+        let n = self.new_leaf(w, size);
+        match self.position(a) {
+            Some((p, i)) if self.axis(p) == Some(axis) => {
+                self.halve(a, axis);
+                self.halve(n, axis);
+                self.attach(p, i + 1, n);
+            }
+            Some((p, i)) => {
+                self.unlink(p, i);
+                let c = self.new_container(axis);
+                self.attach(c, 0, a);
+                self.attach(c, 1, n);
+                self.attach(p, i, c);
+            }
+            None => {
+                let c = self.new_container(axis);
+                self.attach(c, 0, a);
+                self.attach(c, 1, n);
+                self.root = Some(c);
+            }
+        }
+        self.reveal(n, true);
+    }
+
+    fn halve(&mut self, leaf: NodeId, axis: Axis) {
+        if let Kind::Leaf(_, size) = &mut self.nodes[leaf].kind {
+            size[axis.index()] /= 2.0;
+        }
+    }
+
     /// Appends `w` as a row of its own along the stacking axis.
     pub fn insert_row(&mut self, w: W) {
         let size = self.root.map_or([1.0; 2], |r| self.size(r));

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

@@ -221,6 +221,7 @@ impl State {

221221 let input_changed = config.input != self.settings.config.input;

222222 self.settings.binds = Binds::new(&config);

223223 self.wm.layout.gaps = crate::state::gaps(&config);

224+ self.wm.layout.autotile = config.general.autotile;

224225 self.wm.anim.settings = config.animation.clone();

225226 self.settings.config = config;

226227 if keyboard_changed {

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

@@ -150,6 +150,7 @@ impl State {

150150

151151 let mut layout = Layout::default();

152152 layout.gaps = gaps(&config);

153+ layout.autotile = config.general.autotile;

153154 let animation = config.animation.clone();

154155 let imports = crate::import::Imports::new(

155156 &handle,

monolith

Commit 86ef802692f5

Commit `86ef802692f5`