monolith

public

Star0

Fork 0

Watch0

91 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `4cbf881c67bd`

tarball

atagen <boss@atagen.co>2026-10-17 04:56 UTC

3 files changed+239-230

layout: move output parking and scratchpads into their own modules

Both are self-contained state machines on top of placement, and lib.rs had passed 1000 lines with them inline.

Modified file: crates/layout/src/lib.rs+3 additions−230 deletions@@ -2,6 +2,8 @@
 //! tiling tree per output filtered by those views, floating windows,
 //! scratchpads, focus, and restoring windows when an output comes back.
 
+mod outputs;
+mod scratchpad;
 mod tree;
 
 #[cfg(test)]
@@ -10,6 +12,7 @@ mod tests;
 pub use monolith_planner::Rect;
 pub use tree::{Axis, Dir, Tree};
 
+use outputs::Parked;
 use slotmap::{SlotMap, new_key_type};
 use std::collections::HashMap;
 
@@ -90,14 +93,6 @@ pub struct Scratchpad {
     pub output: Option<OutputId>,
 }
 
-#[derive(Clone, Debug)]
-struct Parked {
-    tree: Tree<WindowId>,
-    viewed: Vec<TagId>,
-    floating: Vec<WindowId>,
-    area: Rect,
-}
-
 #[derive(Clone, Debug, Default)]
 pub struct Arrangement {
     /// Every tiled window on the output. Hidden ones are zero-size seeds.
@@ -220,139 +215,6 @@ impl Layout {
         }
     }
 
-    /// Adds an output. One that was unplugged before gets back its tree,
-    /// views and the windows that had to leave it.
-    pub fn add_output(&mut self, name: &str, area: Rect) -> OutputId {
-        let id = self.outputs.insert(Output {
-            name: name.into(),
-            area,
-            reserved: Insets::default(),
-            tree: Tree::default(),
-            viewed: Vec::new(),
-            floating: Vec::new(),
-        });
-        if let Some(parked) = self.parked.remove(name) {
-            self.restore(id, parked);
-        }
-        self.active.get_or_insert(id);
-        let detached: Vec<WindowId> = self
-            .windows
-            .iter()
-            .filter(|(_, w)| w.output.is_none())
-            .map(|(id, _)| id)
-            .collect();
-        for w in detached {
-            self.windows[w].output = Some(id);
-            self.place(w);
-        }
-        id
-    }
-
-    fn restore(&mut self, id: OutputId, parked: Parked) {
-        let name = self.outputs[id].name.clone();
-        let ours = |l: &Self, w: WindowId| {
-            l.windows
-                .get(w)
-                .is_some_and(|x| x.evicted_from.as_deref() == Some(&name) && x.scratchpad.is_none())
-        };
-        let mut tree = parked.tree;
-        tree.retain(|w| ours(self, w) && !self.windows[w].floating);
-        let floating: Vec<WindowId> = parked
-            .floating
-            .into_iter()
-            .filter(|&w| ours(self, w) && self.windows[w].floating)
-            .collect();
-        for w in tree
-            .windows()
-            .chain(floating.iter().copied())
-            .collect::<Vec<_>>()
-        {
-            self.unplace(w);
-            let win = &mut self.windows[w];
-            if let (Some(from), Some(rect)) = (win.output, win.float_rect) {
-                win.float_rect = Some(translate(rect, self.outputs[from].area, parked.area));
-            }
-            win.output = Some(id);
-            win.evicted_from = None;
-        }
-        let out = &mut self.outputs[id];
-        out.tree = tree;
-        out.floating = floating;
-        out.viewed = parked
-            .viewed
-            .into_iter()
-            .filter(|&t| self.tags.contains_key(t))
-            .collect();
-    }
-
-    /// Removes an output. Its windows move to an output viewing their tag,
-    /// or the active one, and remember where they came from.
-    pub fn remove_output(&mut self, o: OutputId) {
-        let Some(out) = self.outputs.remove(o) else {
-            return;
-        };
-        self.parked.insert(
-            out.name.clone(),
-            Parked {
-                tree: out.tree,
-                viewed: out.viewed,
-                floating: out.floating,
-                area: out.area,
-            },
-        );
-        if self.active == Some(o) {
-            self.active = self.outputs.keys().next();
-        }
-        for sp in &mut self.scratchpads {
-            if sp.output == Some(o) {
-                sp.output = self.active;
-            }
-        }
-        let leaving: Vec<WindowId> = self
-            .windows
-            .iter()
-            .filter(|(_, w)| w.output == Some(o))
-            .map(|(id, _)| id)
-            .collect();
-        for w in leaving {
-            let tag = self.windows[w].tag;
-            let target = self
-                .outputs
-                .keys()
-                .find(|&t| self.is_viewed(t, tag))
-                .or(self.active);
-            let win = &mut self.windows[w];
-            if let (Some(t), Some(rect)) = (target, win.float_rect) {
-                win.float_rect = Some(translate(rect, out.area, self.outputs[t].area));
-            }
-            win.output = target;
-            if win.scratchpad.is_some() {
-                continue;
-            }
-            win.evicted_from = Some(out.name.clone());
-            if target.is_some() {
-                self.place(w);
-            }
-        }
-    }
-
-    pub fn set_output_area(&mut self, o: OutputId, area: Rect) {
-        if let Some(out) = self.outputs.get_mut(o) {
-            out.area = area;
-        }
-    }
-
-    /// Returns whether anything changed.
-    pub fn set_reserved(&mut self, o: OutputId, reserved: Insets) -> bool {
-        match self.outputs.get_mut(o) {
-            Some(out) if out.reserved != reserved => {
-                out.reserved = reserved;
-                true
-            }
-            _ => false,
-        }
-    }
-
     pub fn is_viewed(&self, o: OutputId, tag: TagId) -> bool {
         tag == self.homeless
             || self
@@ -760,95 +622,6 @@ impl Layout {
         }
     }
 
-    /// Adds a window to a named scratchpad, creating it. Scratchpad windows
-    /// float and are shown only by summoning.
-    pub fn scratchpad_add(&mut self, w: WindowId, name: &str) {
-        let Some(win) = self.windows.get(w) else {
-            return;
-        };
-        if let Some(s) = win.scratchpad {
-            self.leave_scratchpad(s, w);
-        }
-        self.unplace(w);
-        let s = match self.scratchpads.iter().position(|sp| sp.name == name) {
-            Some(s) => s,
-            None => {
-                self.scratchpads.push(Scratchpad {
-                    name: name.into(),
-                    windows: Vec::new(),
-                    shown: None,
-                    output: None,
-                });
-                self.scratchpads.len() - 1
-            }
-        };
-        self.scratchpads[s].windows.push(w);
-        let area = self.windows[w].output.map(|o| self.outputs[o].area);
-        let win = &mut self.windows[w];
-        win.scratchpad = Some(s);
-        win.floating = true;
-        if win.float_rect.is_none() {
-            win.float_rect = area.map(|a| centred(a, 0.6));
-        }
-    }
-
-    /// Cycles a scratchpad through off, each window, and off again, on the
-    /// active output.
-    pub fn summon(&mut self, name: &str) -> Option<WindowId> {
-        let s = self.scratchpads.iter().position(|sp| sp.name == name)?;
-        let o = self.active?;
-        let sp = &mut self.scratchpads[s];
-        let next = match sp.shown {
-            None => 0,
-            Some(i) => i + 1,
-        };
-        if next >= sp.windows.len() {
-            sp.shown = None;
-            return None;
-        }
-        let from = sp.output.map(|f| self.outputs[f].area);
-        sp.shown = Some(next);
-        sp.output = Some(o);
-        let w = sp.windows[next];
-        self.last_scratchpad = Some(s);
-        let area = self.outputs[o].area;
-        let win = &mut self.windows[w];
-        if win.output != Some(o) {
-            win.float_rect = match (from, win.float_rect) {
-                (Some(from), Some(r)) => Some(translate(r, from, area)),
-                _ => Some(centred(area, 0.6)),
-            };
-            win.output = Some(o);
-        }
-        self.focus(w);
-        Some(w)
-    }
-
-    /// Hides a scratchpad, by default the last one summoned.
-    pub fn dismiss(&mut self, name: Option<&str>) {
-        let s = match name {
-            Some(name) => self.scratchpads.iter().position(|sp| sp.name == name),
-            None => self.last_scratchpad,
-        };
-        if let Some(sp) = s.and_then(|s| self.scratchpads.get_mut(s)) {
-            sp.shown = None;
-        }
-    }
-
-    fn leave_scratchpad(&mut self, s: usize, w: WindowId) {
-        let sp = &mut self.scratchpads[s];
-        let Some(i) = sp.windows.iter().position(|&x| x == w) else {
-            return;
-        };
-        sp.windows.remove(i);
-        sp.shown = match sp.shown {
-            Some(j) if j == i => None,
-            Some(j) if j > i => Some(j - 1),
-            other => other,
-        };
-        self.windows[w].scratchpad = None;
-    }
-
     /// Target geometry for everything on `o`, in output-local logical
     /// coordinates offset by the output's area.
     pub fn arrange(&self, o: OutputId) -> Arrangement {

Added file: crates/layout/src/outputs.rs+144 additions@@ -0,0 +1,144 @@
+use crate::{Insets, Layout, Output, OutputId, Rect, TagId, Tree, WindowId, translate};
+
+#[derive(Clone, Debug)]
+pub(crate) struct Parked {
+    tree: Tree<WindowId>,
+    viewed: Vec<TagId>,
+    floating: Vec<WindowId>,
+    area: Rect,
+}
+
+impl Layout {
+    /// Adds an output. One that was unplugged before gets back its tree,
+    /// views and the windows that had to leave it.
+    pub fn add_output(&mut self, name: &str, area: Rect) -> OutputId {
+        let id = self.outputs.insert(Output {
+            name: name.into(),
+            area,
+            reserved: Insets::default(),
+            tree: Tree::default(),
+            viewed: Vec::new(),
+            floating: Vec::new(),
+        });
+        if let Some(parked) = self.parked.remove(name) {
+            self.restore(id, parked);
+        }
+        self.active.get_or_insert(id);
+        let detached: Vec<WindowId> = self
+            .windows
+            .iter()
+            .filter(|(_, w)| w.output.is_none())
+            .map(|(id, _)| id)
+            .collect();
+        for w in detached {
+            self.windows[w].output = Some(id);
+            self.place(w);
+        }
+        id
+    }
+
+    fn restore(&mut self, id: OutputId, parked: Parked) {
+        let name = self.outputs[id].name.clone();
+        let ours = |l: &Self, w: WindowId| {
+            l.windows
+                .get(w)
+                .is_some_and(|x| x.evicted_from.as_deref() == Some(&name) && x.scratchpad.is_none())
+        };
+        let mut tree = parked.tree;
+        tree.retain(|w| ours(self, w) && !self.windows[w].floating);
+        let floating: Vec<WindowId> = parked
+            .floating
+            .into_iter()
+            .filter(|&w| ours(self, w) && self.windows[w].floating)
+            .collect();
+        for w in tree
+            .windows()
+            .chain(floating.iter().copied())
+            .collect::<Vec<_>>()
+        {
+            self.unplace(w);
+            let win = &mut self.windows[w];
+            if let (Some(from), Some(rect)) = (win.output, win.float_rect) {
+                win.float_rect = Some(translate(rect, self.outputs[from].area, parked.area));
+            }
+            win.output = Some(id);
+            win.evicted_from = None;
+        }
+        let out = &mut self.outputs[id];
+        out.tree = tree;
+        out.floating = floating;
+        out.viewed = parked
+            .viewed
+            .into_iter()
+            .filter(|&t| self.tags.contains_key(t))
+            .collect();
+    }
+
+    /// Removes an output. Its windows move to an output viewing their tag,
+    /// or the active one, and remember where they came from.
+    pub fn remove_output(&mut self, o: OutputId) {
+        let Some(out) = self.outputs.remove(o) else {
+            return;
+        };
+        self.parked.insert(
+            out.name.clone(),
+            Parked {
+                tree: out.tree,
+                viewed: out.viewed,
+                floating: out.floating,
+                area: out.area,
+            },
+        );
+        if self.active == Some(o) {
+            self.active = self.outputs.keys().next();
+        }
+        for sp in &mut self.scratchpads {
+            if sp.output == Some(o) {
+                sp.output = self.active;
+            }
+        }
+        let leaving: Vec<WindowId> = self
+            .windows
+            .iter()
+            .filter(|(_, w)| w.output == Some(o))
+            .map(|(id, _)| id)
+            .collect();
+        for w in leaving {
+            let tag = self.windows[w].tag;
+            let target = self
+                .outputs
+                .keys()
+                .find(|&t| self.is_viewed(t, tag))
+                .or(self.active);
+            let win = &mut self.windows[w];
+            if let (Some(t), Some(rect)) = (target, win.float_rect) {
+                win.float_rect = Some(translate(rect, out.area, self.outputs[t].area));
+            }
+            win.output = target;
+            if win.scratchpad.is_some() {
+                continue;
+            }
+            win.evicted_from = Some(out.name.clone());
+            if target.is_some() {
+                self.place(w);
+            }
+        }
+    }
+
+    pub fn set_output_area(&mut self, o: OutputId, area: Rect) {
+        if let Some(out) = self.outputs.get_mut(o) {
+            out.area = area;
+        }
+    }
+
+    /// Returns whether anything changed.
+    pub fn set_reserved(&mut self, o: OutputId, reserved: Insets) -> bool {
+        match self.outputs.get_mut(o) {
+            Some(out) if out.reserved != reserved => {
+                out.reserved = reserved;
+                true
+            }
+            _ => false,
+        }
+    }
+}

Added file: crates/layout/src/scratchpad.rs+92 additions@@ -0,0 +1,92 @@
+use crate::{Layout, Scratchpad, WindowId, centred, translate};
+
+impl Layout {
+    /// Adds a window to a named scratchpad, creating it. Scratchpad windows
+    /// float and are shown only by summoning.
+    pub fn scratchpad_add(&mut self, w: WindowId, name: &str) {
+        let Some(win) = self.windows.get(w) else {
+            return;
+        };
+        if let Some(s) = win.scratchpad {
+            self.leave_scratchpad(s, w);
+        }
+        self.unplace(w);
+        let s = match self.scratchpads.iter().position(|sp| sp.name == name) {
+            Some(s) => s,
+            None => {
+                self.scratchpads.push(Scratchpad {
+                    name: name.into(),
+                    windows: Vec::new(),
+                    shown: None,
+                    output: None,
+                });
+                self.scratchpads.len() - 1
+            }
+        };
+        self.scratchpads[s].windows.push(w);
+        let area = self.windows[w].output.map(|o| self.outputs[o].area);
+        let win = &mut self.windows[w];
+        win.scratchpad = Some(s);
+        win.floating = true;
+        if win.float_rect.is_none() {
+            win.float_rect = area.map(|a| centred(a, 0.6));
+        }
+    }
+
+    /// Cycles a scratchpad through off, each window, and off again, on the
+    /// active output.
+    pub fn summon(&mut self, name: &str) -> Option<WindowId> {
+        let s = self.scratchpads.iter().position(|sp| sp.name == name)?;
+        let o = self.active?;
+        let sp = &mut self.scratchpads[s];
+        let next = match sp.shown {
+            None => 0,
+            Some(i) => i + 1,
+        };
+        if next >= sp.windows.len() {
+            sp.shown = None;
+            return None;
+        }
+        let from = sp.output.map(|f| self.outputs[f].area);
+        sp.shown = Some(next);
+        sp.output = Some(o);
+        let w = sp.windows[next];
+        self.last_scratchpad = Some(s);
+        let area = self.outputs[o].area;
+        let win = &mut self.windows[w];
+        if win.output != Some(o) {
+            win.float_rect = match (from, win.float_rect) {
+                (Some(from), Some(r)) => Some(translate(r, from, area)),
+                _ => Some(centred(area, 0.6)),
+            };
+            win.output = Some(o);
+        }
+        self.focus(w);
+        Some(w)
+    }
+
+    /// Hides a scratchpad, by default the last one summoned.
+    pub fn dismiss(&mut self, name: Option<&str>) {
+        let s = match name {
+            Some(name) => self.scratchpads.iter().position(|sp| sp.name == name),
+            None => self.last_scratchpad,
+        };
+        if let Some(sp) = s.and_then(|s| self.scratchpads.get_mut(s)) {
+            sp.shown = None;
+        }
+    }
+
+    pub(crate) fn leave_scratchpad(&mut self, s: usize, w: WindowId) {
+        let sp = &mut self.scratchpads[s];
+        let Some(i) = sp.windows.iter().position(|&x| x == w) else {
+            return;
+        };
+        sp.windows.remove(i);
+        sp.shown = match sp.shown {
+            Some(j) if j == i => None,
+            Some(j) if j > i => Some(j - 1),
+            other => other,
+        };
+        self.windows[w].scratchpad = None;
+    }
+}

monolith

Commit 4cbf881c67bd

Commit `4cbf881c67bd`