monolith

public

Star0

Fork 0

Watch0

25 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `4444c779eb48`

tarball

atagen <boss@atagen.co>2026-10-16 12:08 UTC

10 files changed+139-32

layout: add merge moves with a configurable default and a one-shot inversion

A layout like A [B/C] could only be reached by routing through the root and flipping, because moves could swap or step out of containers but never form a new stack around a neighbour. general.move picks whether a move swaps or merges, and invert-move flips that for the next move only, so no lingering mode changes moves silently. move-block becomes move-container since interspersed tags made it a container move all along, and expand all becomes maximize, setting the xdg maximized state.

Modified file: crates/config/default.toml+10 additions−6 deletions@@ -9,6 +9,9 @@ startup = []
 # keeps super for itself.
 mod = "super"
 gaps = { inner = 8, outer = 8 }
+# 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"
 
 [animation]
 enabled = true
@@ -37,18 +40,19 @@ repeat_rate = 25
 "Mod+Shift+j" = "move down"
 "Mod+Shift+k" = "move up"
 "Mod+Shift+l" = "move right"
-"Mod+Ctrl+h" = "move-block left"
-"Mod+Ctrl+j" = "move-block down"
-"Mod+Ctrl+k" = "move-block up"
-"Mod+Ctrl+l" = "move-block right"
+"Mod+Ctrl+h" = "move-container left"
+"Mod+Ctrl+j" = "move-container down"
+"Mod+Ctrl+k" = "move-container up"
+"Mod+Ctrl+l" = "move-container right"
+"Mod+m" = "invert-move"
 "Mod+Alt+h" = "resize horizontal -0.05"
 "Mod+Alt+l" = "resize horizontal 0.05"
 "Mod+Alt+k" = "resize vertical -0.05"
 "Mod+Alt+j" = "resize vertical 0.05"
 
 "Mod+e" = "expand window"
-"Mod+Shift+w" = "expand block"
-"Mod+w" = "expand all"
+"Mod+Shift+w" = "expand container"
+"Mod+w" = "maximize"
 "Mod+o" = "flip"
 "Mod+f" = "fullscreen"
 "Mod+Shift+space" = "float"

Modified file: crates/config/src/lib.rs+14 additions@@ -26,6 +26,19 @@ pub struct General {
     #[serde(rename = "mod")]
     pub mod_key: Modifier,
     pub gaps: Gaps,
+    /// What a window move does when it meets a neighbour.
+    #[serde(rename = "move")]
+    pub move_mode: MoveMode,
+}
+
+#[derive(Deserialize, Debug, Clone, Copy, PartialEq, Eq, Default)]
+#[serde(rename_all = "lowercase")]
+pub enum MoveMode {
+    /// Trade places with it.
+    #[default]
+    Swap,
+    /// Join its lane, stacking with it if it is alone.
+    Merge,
 }
 
 impl Default for General {
@@ -33,6 +46,7 @@ impl Default for General {
         Self {
             mod_key: Modifier::Super,
             gaps: Gaps::default(),
+            move_mode: MoveMode::Swap,
         }
     }
 }

Modified file: crates/ipc/src/lib.rs+15 additions−8 deletions@@ -46,8 +46,7 @@ pub enum Axis {
 pub enum ExpandScope {
     #[default]
     Window,
-    Block,
-    All,
+    Container,
 }
 
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
@@ -65,7 +64,7 @@ pub enum Command {
     Move {
         dir: Dir,
     },
-    MoveBlock {
+    MoveContainer {
         dir: Dir,
     },
     Resize {
@@ -75,6 +74,11 @@ pub enum Command {
     Expand {
         scope: ExpandScope,
     },
+    /// Expands every container above the focused window towards it.
+    Maximize,
+    /// Makes the next window move do the opposite of the configured default,
+    /// swap or merge. Again before moving cancels it.
+    InvertMove,
     Flip,
     Float,
     Fullscreen,
@@ -126,7 +130,7 @@ impl fmt::Display for ParseError {
 impl std::error::Error for ParseError {}
 
 impl Command {
-    /// Parses the word form, as in `["move-block", "left"]`.
+    /// Parses the word form, as in `["move-container", "left"]`.
     pub fn parse<S: AsRef<str>>(words: &[S]) -> Result<Self, ParseError> {
         let words: Vec<&str> = words.iter().map(AsRef::as_ref).collect();
         let Some((&name, args)) = words.split_first() else {
@@ -162,12 +166,14 @@ impl Command {
             "quit" => none(Command::Quit)?,
             "reload" => none(Command::Reload)?,
             "flip" => none(Command::Flip)?,
+            "maximize" => none(Command::Maximize)?,
+            "invert-move" => none(Command::InvertMove)?,
             "float" => none(Command::Float)?,
             "fullscreen" => none(Command::Fullscreen)?,
             "sticky" => none(Command::Sticky)?,
             "focus" => Command::Focus { dir: dir()? },
             "move" => Command::Move { dir: dir()? },
-            "move-block" => Command::MoveBlock { dir: dir()? },
+            "move-container" => Command::MoveContainer { dir: dir()? },
             "focus-output" => Command::FocusOutput { dir: dir()? },
             "send-to-output" => Command::SendToOutput { dir: dir()? },
             "resize" => {
@@ -187,9 +193,8 @@ impl Command {
             "expand" => Command::Expand {
                 scope: match args {
                     [] | ["window"] => ExpandScope::Window,
-                    ["block"] => ExpandScope::Block,
-                    ["all"] => ExpandScope::All,
-                    _ => return Err(err("takes window, block or all")),
+                    ["container"] => ExpandScope::Container,
+                    _ => return Err(err("takes window or container")),
                 },
             },
             "view" => Command::View { tag: one()? },
@@ -274,6 +279,8 @@ pub enum Answer {
 
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Default)]
 pub struct State {
+    /// The next window move does the opposite of the configured default.
+    pub move_inverted: bool,
     pub tags: Vec<Tag>,
     pub outputs: Vec<Output>,
     pub windows: Vec<Window>,

Modified file: crates/layout/src/lib.rs+22 additions−4 deletions@@ -24,7 +24,7 @@ pub const HOMELESS: &str = "homeless";
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum ExpandScope {
     Window,
-    Block,
+    Container,
     All,
 }
 
@@ -594,16 +594,34 @@ impl Layout {
         moved
     }
 
-    pub fn move_block(&mut self, dir: Dir) -> bool {
+    pub fn move_container(&mut self, dir: Dir) -> bool {
         let Some((w, o)) = self.focused_tiled() else {
             return false;
         };
         let mut tree = std::mem::take(&mut self.outputs[o].tree);
-        let moved = tree.move_block(w, dir, self.vis_on(o));
+        let moved = tree.move_container(w, dir, self.vis_on(o));
         self.outputs[o].tree = tree;
         moved
     }
 
+    pub fn merge_window(&mut self, dir: Dir) -> bool {
+        let Some((w, o)) = self.focused_tiled() else {
+            return false;
+        };
+        let mut tree = std::mem::take(&mut self.outputs[o].tree);
+        let merged = tree.merge_window(w, dir, self.vis_on(o));
+        self.outputs[o].tree = tree;
+        merged
+    }
+
+    /// Whether a tiled window fills its output through expansion.
+    pub fn maximized(&self, w: WindowId) -> bool {
+        let Some(o) = self.windows.get(w).and_then(|w| w.output) else {
+            return false;
+        };
+        self.outputs[o].tree.maximized(w)
+    }
+
     pub fn resize(&mut self, axis: Axis, delta: f64) -> bool {
         let Some((w, o)) = self.focused_tiled() else {
             return false;
@@ -620,7 +638,7 @@ impl Layout {
         };
         let (skip, count) = match scope {
             ExpandScope::Window => (0, 1),
-            ExpandScope::Block => (1, 1),
+            ExpandScope::Container => (1, 1),
             ExpandScope::All => (0, usize::MAX),
         };
         self.outputs[o].tree.toggle_expand(w, skip, count)

Modified file: crates/layout/src/tests.rs+13 additions−2 deletions@@ -10,6 +10,7 @@ enum Op {
     Focus(u8),
     Move(Dir),
     Block(Dir),
+    Merge(Dir),
     View(u8),
     ToggleView(u8),
     Retag(u8, u8),
@@ -39,6 +40,7 @@ fn op() -> impl Strategy<Value = Op> {
         3 => any::<u8>().prop_map(Op::Focus),
         4 => dir().prop_map(Op::Move),
         2 => dir().prop_map(Op::Block),
+        3 => dir().prop_map(Op::Merge),
         1 => (0u8..4).prop_map(Op::View),
         2 => (0u8..4).prop_map(Op::ToggleView),
         1 => (any::<u8>(), 0u8..4).prop_map(|(w, t)| Op::Retag(w, t)),
@@ -81,7 +83,10 @@ fn apply(l: &mut Layout, tags: &[TagId], op: &Op) {
             l.move_window(d);
         }
         Op::Block(d) => {
-            l.move_block(d);
+            l.move_container(d);
+        }
+        Op::Merge(d) => {
+            l.merge_window(d);
         }
         Op::View(t) => active.into_iter().for_each(|o| l.view(o, tags[t as usize])),
         Op::ToggleView(t) => active
@@ -92,7 +97,13 @@ fn apply(l: &mut Layout, tags: &[TagId], op: &Op) {
             .for_each(|w| l.set_tag(w, tags[t as usize])),
         Op::Float(i) => nth(l, i).into_iter().for_each(|w| l.toggle_floating(w)),
         Op::Expand(s) => {
-            l.expand([ExpandScope::Window, ExpandScope::Block, ExpandScope::All][s as usize]);
+            l.expand(
+                [
+                    ExpandScope::Window,
+                    ExpandScope::Container,
+                    ExpandScope::All,
+                ][s as usize],
+            );
         }
         Op::Flip => active.into_iter().for_each(|o| l.flip(o)),
         Op::Resize(h, d) => {

Modified file: crates/layout/src/tree.rs+40 additions−4 deletions@@ -183,7 +183,7 @@ impl<W: Copy + Eq + Hash> Tree<W> {
 
     /// Moves the container holding `w` as a rigid block. A window sitting
     /// directly in the root is its own block.
-    pub fn move_block(&mut self, w: W, dir: Dir, vis: impl Fn(W) -> bool) -> bool {
+    pub fn move_container(&mut self, w: W, dir: Dir, vis: impl Fn(W) -> bool) -> bool {
         let Some(&n) = self.leaves.get(&w) else {
             return false;
         };
@@ -194,6 +194,43 @@ impl<W: Copy + Eq + Hash> Tree<W> {
         self.move_node(block, dir, &vis, false)
     }
 
+    /// Moves a window to the end of the next visible lane in `dir`, stepping
+    /// up a level when its container has none that way. A lone window there
+    /// becomes a stack with it.
+    pub fn merge_window(&mut self, w: W, dir: Dir, vis: impl Fn(W) -> bool) -> bool {
+        let Some(&n) = self.leaves.get(&w) else {
+            return false;
+        };
+        let mut cur = n;
+        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)
+            {
+                self.join_lane(n, p, j);
+                return true;
+            }
+            cur = p;
+        }
+        false
+    }
+
+    /// Whether every container above `w` is expanded towards it.
+    pub fn maximized(&self, w: W) -> bool {
+        let Some(&leaf) = self.leaves.get(&w) else {
+            return false;
+        };
+        let mut cur = leaf;
+        let mut any = false;
+        while let Some(p) = self.nodes[cur].parent {
+            if self.expanded(p) != Some(cur) {
+                return false;
+            }
+            any = true;
+            cur = p;
+        }
+        any
+    }
+
     /// Transposes the whole tree.
     pub fn flip(&mut self) {
         self.stack = self.stack.other();
@@ -417,9 +454,8 @@ impl<W: Copy + Eq + Hash> Tree<W> {
         (j < self.children(p).len()).then_some(j)
     }
 
-    /// Moves `n` to the end of the lane at `p`'s child `j`, which holds only
-    /// hidden windows, so it shares that lane when they come back instead of
-    /// opening a new one beside it. A lone window becomes a lane of its own.
+    /// Moves `n` to the end of the lane at `p`'s child `j`. A lone window
+    /// there becomes a lane of its own, perpendicular to `p`.
     fn join_lane(&mut self, n: NodeId, p: NodeId, j: usize) {
         let lane = self.children(p)[j].node;
         let lane = if self.axis(lane).is_some() {

Modified file: crates/monolith/src/commands.rs+13 additions−5 deletions@@ -1,5 +1,5 @@
 use crate::state::State;
-use monolith_config::{Config, Mods};
+use monolith_config::{Config, Mods, MoveMode};
 use monolith_ipc::Command;
 use monolith_layout::{Axis, Dir, ExpandScope, WindowId};
 use smithay::input::keyboard::{Keysym, ModifiersState, xkb};
@@ -52,6 +52,8 @@ impl State {
     pub fn run(&mut self, cmd: Command) -> Result<(), String> {
         let output = self.layout.active_output();
         let focused = self.layout.focused();
+        let inverted = std::mem::take(&mut self.move_inverted);
+        let merge = (self.config.general.move_mode == MoveMode::Merge) != inverted;
         let on_focused = |state: &mut Self, f: fn(&mut monolith_layout::Layout, WindowId)| {
             if let Some(w) = focused {
                 f(&mut state.layout, w);
@@ -72,12 +74,19 @@ impl State {
             Command::Focus { dir: d } => {
                 self.layout.focus_dir(dir(d));
             }
+            Command::Move { dir: d } if merge => {
+                self.layout.merge_window(dir(d));
+            }
             Command::Move { dir: d } => {
                 self.layout.move_window(dir(d));
             }
-            Command::MoveBlock { dir: d } => {
-                self.layout.move_block(dir(d));
+            Command::MoveContainer { dir: d } => {
+                self.layout.move_container(dir(d));
+            }
+            Command::Maximize => {
+                self.layout.expand(ExpandScope::All);
             }
+            Command::InvertMove => self.move_inverted = !inverted,
             Command::Resize { axis, delta } => {
                 let axis = match axis {
                     monolith_ipc::Axis::Horizontal => Axis::Horizontal,
@@ -88,8 +97,7 @@ impl State {
             Command::Expand { scope } => {
                 self.layout.expand(match scope {
                     monolith_ipc::ExpandScope::Window => ExpandScope::Window,
-                    monolith_ipc::ExpandScope::Block => ExpandScope::Block,
-                    monolith_ipc::ExpandScope::All => ExpandScope::All,
+                    monolith_ipc::ExpandScope::Container => ExpandScope::Container,
                 });
             }
             Command::Flip => output.into_iter().for_each(|o| self.layout.flip(o)),

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

@@ -202,6 +202,7 @@ fn snapshot(state: &State) -> monolith_ipc::State {

202202 .collect();

203203 windows.sort_by_key(|w| w.id);

204204 monolith_ipc::State {

205+ move_inverted: state.move_inverted,

205206 tags,

206207 outputs,

207208 windows,

Modified file: crates/monolith/src/state.rs+9 additions−2 deletions@@ -54,6 +54,7 @@ pub struct State {
     pub config_path: Option<PathBuf>,
     pub binds: Binds,
     pub suppressed: Vec<Keycode>,
+    pub move_inverted: bool,
     pub drag: Option<crate::input::Drag>,
     pub ipc: crate::ipc::Server,
     pub launches: crate::launch::Launches,
@@ -137,6 +138,7 @@ impl State {
             config_path,
             binds,
             suppressed: Vec::new(),
+            move_inverted: false,
             drag: None,
             ipc: crate::ipc::Server::default(),
             launches: Default::default(),
@@ -359,7 +361,7 @@ impl State {
         let mut mapped = Vec::new();
         for (id, rect, kind, _) in shown {
             if let Some(window) = self.windows.get(&id)
-                && configure(window, rect, kind)
+                && configure(window, rect, kind, self.layout.maximized(id))
             {
                 let loc = (rect.x.round() as i32, rect.y.round() as i32);
                 let loc = Point::from(loc) - window.geometry().loc;
@@ -470,7 +472,7 @@ pub enum Kind {
 
 /// Sets a window's pending size and states. Returns false for windows
 /// squeezed to a line by an expanded sibling, which are not shown.
-fn configure(window: &Window, rect: Rect, kind: Kind) -> bool {
+fn configure(window: &Window, rect: Rect, kind: Kind, maximized: bool) -> bool {
     let (x, y) = (rect.x.round(), rect.y.round());
     let w = (rect.right().round() - x) as i32;
     let h = (rect.bottom().round() - y) as i32;
@@ -498,6 +500,11 @@ fn configure(window: &Window, rect: Rect, kind: Kind) -> bool {
             } else {
                 s.states.unset(XdgState::Fullscreen);
             }
+            if maximized && kind == Kind::Tiled {
+                s.states.set(XdgState::Maximized);
+            } else {
+                s.states.unset(XdgState::Maximized);
+            }
         });
         if t.is_initial_configure_sent() {
             t.send_pending_configure();

Modified file: design/decisions.md+2 additions−1 deletions@@ -85,7 +85,8 @@ Running log of settled decisions and open questions. Research backing lives in `
 ### Planner (see `planner.html`)
 - Orthogonal style (one axis per window per phase) is the default and flagship look. Direct is a toggle.
 - Shared-separator rule, plans of 1 to 4 phases, the 4-phase grid guarantees a plan for any input. Pinch and lerp are safety nets only.
-- Window moves and block moves both exist as commands. Tag reordering plans with rigid blocks.
+- Window moves and container moves both exist as commands. A window move either swaps with its neighbour or merges into its lane, chosen by `general.move`, and `invert-move` does the other one for the next move only. The default lives in config rather than in a runtime toggle. Moving a tag directionally was rejected because interspersed tags have no single shape to move. Tag reordering only changes tag order.
+- `expand all` became `maximize`, which also sets the xdg maximized state.
 - One curve per motion group.
 - Floating windows travel above the tiled layer, exempt from the overlap rule.
 - Seeds start as a line on the old boundary between neighbours.

monolith

Commit 4444c779eb48

Commit `4444c779eb48`