monolith

public

Star0

Fork 0

Watch0

331 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `1c1f70798e98`

tarball

atagen <boss@atagen.co>2026-10-22 05:51 UTC

3 files changed+41-6

layout: carry the windows an extended window covers when retagging it

Retagging only the extended window broke the block move_window keeps whole. Its expansion stopped applying on the old tag, so every window it covered popped into view where the user had just been, and it landed on the new tag as a plain tile. set_tag now retags the shown windows in Tree::group, including covered members on other viewed tags, since extending over them already treated them as part of the block.

Modified file: crates/layout/src/lib.rs+14 additions−6 deletions@@ -729,13 +729,21 @@ impl Layout {
         }
     }
 
-    /// Retags a window. It keeps its slot and disappears if the new tag is
-    /// not viewed.
+    /// Retags a window along with the windows it is extended over. They keep
+    /// their slots and disappear if the new tag is not viewed.
     pub fn set_tag(&mut self, w: WindowId, tag: TagId) {
-        if self.tags.contains_key(tag)
-            && let Some(win) = self.windows.get_mut(w)
-        {
-            win.tag = tag;
+        let Some(win) = self.windows.get(w) else {
+            return;
+        };
+        if !self.tags.contains_key(tag) {
+            return;
+        }
+        let group = match win.output {
+            Some(o) => self.outputs[o].tree.group_windows(w, self.vis_on(o)),
+            None => vec![w],
+        };
+        for g in group {
+            self.windows[g].tag = tag;
         }
     }
 

Modified file: crates/layout/src/tests.rs+16 additions@@ -350,6 +350,22 @@ fn extended_windows_move_their_group() {
     assert!(rect(c).right() <= rect(b).x && rect(b).y == rect(c).y);
 }
 
+#[test]
+fn retagging_an_extended_window_leaves_hidden_members() {
+    let (a, b, c, d) = (1, 2, 3, 4);
+    let shown = |w| w != d;
+    let mut t: Tree<u32> = Tree::default();
+    t.insert_row(a);
+    t.insert_after(b, a);
+    t.insert_after(c, b);
+    t.insert_after(d, c);
+    assert!(t.toggle_expand(b, 0, 1, shown));
+    let mut group = t.group_windows(b, shown);
+    group.sort();
+    assert_eq!(group, [a, b, c]);
+    assert_eq!(t.group_windows(a, shown), [a]);
+}
+
 /// A window alone on screen in a container of hidden ones expands among the
 /// windows it is shown beside, not inside the container nobody can see.
 #[test]

Modified file: crates/layout/src/tree.rs+11 additions@@ -298,6 +298,17 @@ impl<W: Copy + Eq + Hash> Tree<W> {
         self.group(w, &vis).is_some()
     }
 
+    /// The shown windows in the block `w` moves as, `w` alone when it is not
+    /// extended.
+    pub fn group_windows(&self, w: W, vis: impl Fn(W) -> bool) -> Vec<W> {
+        let Some(g) = self.group(w, &vis) else {
+            return vec![w];
+        };
+        let mut out = Vec::new();
+        self.shown_leaves(g, &vis, &mut out);
+        out
+    }
+
     /// Whether a visible window extended over `w` takes all its room.
     pub fn eclipsed(&self, w: W, vis: impl Fn(W) -> bool) -> bool {
         let Some(&leaf) = self.leaves.get(&w) else {

monolith

Commit 1c1f70798e98

Commit `1c1f70798e98`