monolith

public

Star0

Fork 0

Watch0

6 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `944fc4782ac3`

tarball

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

2 files changed+116-13

design: settle one-tree layout and add fullscreen, expand and lane extent demos

Hidden windows keep their tree slots instead of following visible neighbours, which keeps the record of every relative position exact across tag views.

Modified file: design/decisions.md+6 additions−4 deletions@@ -16,16 +16,16 @@ Running log of settled decisions and open questions. Research backing lives in `
 - A "homeless" tag is immutable and always viewed. New windows land there unless a rule or launch context says otherwise. Hiding a window means moving it to an unviewed tag.
 - Windows are bound to an output. New homeless windows go to the output that was active when the spawn was requested.
 - Launch context. Windows are placed on the tag and output that were active when they were launched, not where focus is when they map. Child windows and windows of child processes inherit the parent's tag and output. A compositor `spawn` command is acceptable as the launch path.
-- Layout state is per tag-on-output.
+- Layout state is one tree per output, filtered by viewed tags (see Planner section).
 - Unplug moves windows to an output viewing their tag, otherwise the tag is disabled there. Replug restores windows that left because of the unplug.
 - Tag order is invocation order, remembered, with a reordering command.
 - Sticky flag exists. Scratchpads are floating sticky sets of windows. Addressing a scratchpad cycles on, next window, ..., off, with dimensions kept. A sticky scratchpad stays on the output it was last summoned to. A dismiss-scratchpad command takes an optional target, defaulting to the last active.
 - Tags are exposed through ext-workspace-v1, one group per output, one workspace per tag per output.
 
 ### Layout
-- Tree per tag-on-output, edited by the user, not derived from window count.
+- One tree per output, edited by the user, not derived from window count. Each tag starts as its own row.
 - Child splits run on the axis opposite their parent. Flipping orientation transposes the whole tree. Orientation is presentation only.
-- Viewing several tags stacks each tag's tree as a row (or column when flipped), in invocation order. Each tag keeps its own split ratios. No positional L/C/R merging.
+- Viewing several tags shows the projection of the shared tree. Windows can be interspersed freely. No positional L/C/R merging.
 - An "expand" command at any tree level lets one window or subtree fill its slot. Autotiling on merge is a possible experiment.
 - Floating windows allowed. No pure floating mode.
 - A "deck" monocle (stacked windows with visible edges, selected window popped out) is a later container mode.
@@ -88,7 +88,9 @@ Running log of settled decisions and open questions. Research backing lives in `
 - 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.
-- Open. Floating choreography (slot opens last, direct glide, slot opens first), whether landing may resize both axes at once, lane extent, and the layout model for interspersed tags.
+- Floating to tiled and fullscreen use a direct glide above the tiled layer. Expand is a tiled operation planned normally, siblings squeezed to zero-size lines.
+- One layout tree per output, tags filter it. Hidden windows keep their slots, visible moves swap visible slots only, containers collapse by the normal one-child rule counting hidden children, and a hidden only child is demoted into the grandparent. This replaces per-tag layouts and the row-stacking merge rule, row stacking is just the default arrangement.
+- Open. Lane extent.
 - Input hit-tests against final layout geometry, never animated geometry.
 - smithay is pinned by git rev. The repo uses jj.
 

Modified file: design/planner.html+110 additions−9 deletions@@ -107,6 +107,8 @@
 </ul>
 <p>Picking lanes is a small constrained colouring problem. For a pure reordering of a row, the lane count equals the length of the longest decreasing subsequence of the new order (Dilworth's theorem). Swapping two neighbours or rotating needs 2 lanes, and fully reversing four windows needs 4.</p>
 <div class="demo" id="d5"></div>
+<p><strong>Lane extent.</strong> Below, T fills the top 70% and A, B, C share a short bottom row. Reversing the row needs 3 lanes. Spanning only the involved band, each lane is a third of the short row, so the windows get thin but T never moves. Spanning the whole output, the lanes are thicker, but T is in the way and has to squeeze into a lane too.</p>
+<div class="demo" id="d12"></div>
 
 <h2>7. Four phases, the grid</h2>
 <p>Some transitions reverse windows along both axes at once. In <code>(A over D) | (C over B)</code> to <code>(A over B over C) | D</code>, D has to pass B and C horizontally while B and C swap vertical order. Lanes along either axis contradict the other reversal. The grid handles it.</p>
@@ -140,14 +142,20 @@
 <p class="note">Not shown. Outputs at different scales draw the same window at different sizes, since the planner works in logical coordinates and each output scales its part. If two outputs aren't adjacent in the global space, the window travels through empty space.</p>
 <div class="demo" id="d7"></div>
 
-<h2>12. Floating to tiled</h2>
+<h2>12. Floating, fullscreen and expand</h2>
 <p>A floating window joining the tiled layout travels above the tiled layer and is exempt from the overlap rule while it does. The mode button cycles three choreographies. Lifting out plays each one in reverse.</p>
 <ul>
-  <li><strong>Slot opens last</strong> (default). F travels one axis per phase until it hovers over where its slot will be. Only then does the gap open, and F lands into it as it widens, in the same final phase.</li>
-  <li><strong>Direct glide.</strong> F lerps straight into the slot while the gap opens, in one phase.</li>
-  <li><strong>Slot opens first.</strong> The gap opens while F is still travelling, then F lands. This was draft 2 behaviour.</li>
+  <li><strong>Direct glide</strong> (default). F lerps straight into the slot while the gap opens, in one phase.</li>
+  <li><strong>Slot opens last.</strong> F travels one axis per phase until it hovers over its slot, then the gap opens and F lands as it widens.</li>
+  <li><strong>Slot opens first.</strong> The gap opens while F is still travelling, then F lands.</li>
 </ul>
 <div class="demo" id="d10"></div>
+<h3>Fullscreen</h3>
+<p>Fullscreen uses the same direct glide. The window lifts above the tiled layer and lerps to cover the output in one phase. Its tiled slot stays where it is underneath, so leaving fullscreen glides back into it and nothing else moves either way.</p>
+<div class="demo" id="d13"></div>
+<h3>Expand</h3>
+<p>Expand is a tiled operation, not a glide. The expanded window or subtree grows to fill its slot while its siblings are squeezed to zero-size lines against the slot's edges, so it follows the normal planner rules, orthogonal included. Expanding a window inside its column is one vertical phase. Expanding it to the whole output changes both axes, so orthogonal style takes two.</p>
+<div class="demo" id="d14"></div>
 
 <h2>13. Fallbacks</h2>
 <p>The grid construction means no plan should ever need a fallback, and the stress test never reached one. Two remain wired in as safety nets for malformed input. <strong>Pinch</strong> shrinks a window to a point, jumps invisibly and regrows it. <strong>Lerp</strong> interpolates straight to the target and accepts overlap. Which one is the net is a matter of trying both.</p>
@@ -209,6 +217,16 @@
 <p>The last option is dwm's model (one client list, tags as a filter) with a tree in place of the list. The tree is the record of every relative position, permanently, because hidden windows never leave it. Nothing has to be restored. And for the planner, <strong>viewing or hiding any tag is always a single phase</strong>, because hidden windows are zero-weight seeds sitting at their own spot. Switching views never rearranges anything.</p>
 <p>Its cost is action at a distance. Intersperse A into tag 2's row below, then view tag 1 alone. A now sits under B and C, because in the tree it lives in the lower row. You changed tag 1's single view without ever viewing it alone.</p>
 <div class="demo" id="d8"></div>
+<p><strong>Hidden windows keep their slot.</strong> They are not coupled to visible neighbours. My earlier phrasing was wrong, and your version is the rule.</p>
+<ul>
+  <li>The tree never moves a hidden leaf. Moves in a filtered view swap the slots of visible windows only. Swap A and B below with tag 2 hidden, then show it again, and D is still between them.</li>
+  <li>Containers die by the normal rule, when one child is left, counting hidden children. A hidden only child is demoted into the grandparent at the container's position. Move C next to B below with tag 2 hidden. Row 2 is left holding only E, so it collapses and E becomes a full-width row of its own.</li>
+  <li>A container holding only hidden children survives as long as it has two or more, invisible until they return.</li>
+  <li>New windows insert next to the focused visible window.</li>
+  <li>Hidden windows keep their share of a container's size when visible siblings are resized.</li>
+</ul>
+<p>Tick "show hidden slots" to see where hidden windows will reappear.</p>
+<div class="demo" id="d11"></div>
 
 <h2>17. Decisions</h2>
 <h3>Settled</h3>
@@ -217,13 +235,14 @@
   <li>Window moves and block moves both exist as commands. Tag reordering moves rigid blocks.</li>
   <li>One curve per motion group, bounded by phase time rather than amount of motion.</li>
   <li>Seeds start as a line on the old boundary.</li>
+  <li>Floating to tiled and fullscreen use a direct glide. Expand is tiled and follows the planner.</li>
+  <li>One tree per output, tags filter it. Hidden windows keep their slots.</li>
   <li>The planner must never need a fallback. Pinch and lerp stay as safety nets to try.</li>
 </ul>
 <h3>Open</h3>
-<div class="q"><strong>Floating choreography.</strong> Slot opens last, direct glide, or slot opens first (section 12).</div>
-<div class="q"><strong>Landing in orthogonal style.</strong> The final "falls into place" step resizes both width and height at once. Is that an accepted exception, or must it also split into two phases?</div>
+
 <div class="q"><strong>Lane extent.</strong> Strips span only the band of the involved windows. Spanning the whole output gives thicker lanes for small windows, but disturbs more of the screen.</div>
-<div class="q"><strong>The layout model (section 16).</strong> One tree per output with tags as a filter, or something else. You raised the case of windows being closed and moved while others are hidden. In the one-tree model, hidden windows keep their slot, closing removes only that leaf, and moves are made relative to visible neighbours, so hidden siblings stay attached to whichever visible neighbour they were next to. That rule is what needs discussing.</div>
+<div class="q"><strong>Hidden-slot rules (section 16).</strong> Check the rules list against your intent, especially demotion and insertion next to the focused window.</div>
 </main>
 
 <script id="planner">
@@ -231,6 +250,7 @@ const G = 10;
 const EPS = 0.5;
 let PHASE_MS = 450;
 let STYLE = 'orthogonal';
+let LANE_REGION = null;
 
 const R = (x, y, w, h) => ({ x, y, w, h });
 const clone = L => { const o = {}; for (const k in L) o[k] = { ...L[k] }; return o; };
@@ -415,6 +435,7 @@ function lanes(from, to, list, movers, ax) {
     if (n < 2) continue;
     let lo = Infinity, hi = -Infinity;
     for (const id of set) for (const r of [from[id], to[id]]) { lo = Math.min(lo, r[ax]); hi = Math.max(hi, r[ax] + r[size]); }
+    if (LANE_REGION) { lo = LANE_REGION[ax]; hi = LANE_REGION[ax] + LANE_REGION[size]; }
     const diff = [], lt = [];
     for (let i = 0; i < n; i++) { diff.push(new Array(n).fill(false)); lt.push(new Array(n).fill(false)); }
     for (let i = 0; i < n; i++)
@@ -525,7 +546,7 @@ const edges = r => [r.x, r.x + r.w, r.y, r.y + r.h];
 </script>
 
 <script>
-const PAL = { A: '#e0774a', B: '#4aa3e0', C: '#7bc96f', D: '#c77be0', E: '#e0c24a', F: '#4ae0c2' };
+const PAL = { T: '#9aa3b5', A: '#e0774a', B: '#4aa3e0', C: '#7bc96f', D: '#c77be0', E: '#e0c24a', F: '#4ae0c2' };
 const demos = [];
 
 class Demo {
@@ -658,6 +679,7 @@ class Demo {
         }
       }
       for (const o2 of overlaps) { c.fillStyle = 'rgba(255,77,94,0.55)'; c.fillRect(o2.x, o2.y, o2.w, o2.h); c.strokeStyle = '#ff4d5e'; c.lineWidth = 2; c.strokeRect(o2.x, o2.y, o2.w, o2.h); }
+      if (this.overlay) for (const r of this.overlay()) { c.setLineDash([6, 4]); c.strokeStyle = '#8a909c'; c.lineWidth = 1.5; c.strokeRect(r.x, r.y, r.w, r.h); c.setLineDash([]); c.fillStyle = '#8a909c'; c.font = '13px system-ui'; c.textAlign = 'center'; c.textBaseline = 'middle'; c.fillText(r.id + ' (hidden)', r.x + r.w / 2, r.y + r.h / 2); }
       c.restore();
     }
   }
@@ -895,7 +917,7 @@ for (const [id, names] of [
 { // d10 floating to tiled
   const W = 640, H = 300, d = new Demo('d10', W, H, { floating: ['F'] }), I = inner(W, H);
   const FL = R(220, 40, 220, 130);
-  const modes = ['slot opens last', 'direct glide', 'slot opens first'];
+  const modes = ['direct glide', 'slot opens last', 'slot opens first'];
   let tiled = false, mode = 0;
   const tiledL = () => splitX(I, ['A', 'B', 'F', 'C']);
   const floatL = () => ({ ...splitX(I, ['A', 'B', 'C']), F: FL });
@@ -949,6 +971,85 @@ for (const [id, names] of [
   const mb = d.button('mode: ' + modes[0], () => { mode = (mode + 1) % modes.length; mb.textContent = 'mode: ' + modes[mode]; });
 }
 
+{ // d11 one tree, hidden slots
+  const W = 640, H = 320, d = new Demo('d11', W, H), I = inner(W, H);
+  const tagOf = { A: 1, B: 1, C: 1, D: 2, E: 2 };
+  const view = { 1: true, 2: true };
+  let tree, ghosts = false;
+  const reset = () => { tree = { dir: 'col', kids: [{ dir: 'row', kids: ['A', 'D', 'B'] }, { dir: 'row', kids: ['C', 'E'] }] }; view[2] = true; };
+  reset();
+  const L = () => { const o = {}; layoutTree(tree, I, id => view[tagOf[id]], o); return o; };
+  const parentOf = (node, id, par = null) => {
+    if (typeof node === 'string') return node === id ? par : null;
+    for (const k of node.kids) { const r = parentOf(k, id, node); if (r) return r; }
+    return null;
+  };
+  const collapse = node => {
+    if (typeof node === 'string') return node;
+    node.kids = node.kids.map(collapse).filter(k => typeof k === 'string' || k.kids.length);
+    return node.kids.length === 1 ? node.kids[0] : node;
+  };
+  const swap = (a, b) => { const pa = parentOf(tree, a), pb = parentOf(tree, b); const ia = pa.kids.indexOf(a), ib = pb.kids.indexOf(b); pa.kids[ia] = b; pb.kids[ib] = a; };
+  const moveAfter = (id, target) => {
+    const p = parentOf(tree, id); p.kids.splice(p.kids.indexOf(id), 1);
+    tree = collapse(tree);
+    const pt = parentOf(tree, target); pt.kids.splice(pt.kids.indexOf(target) + 1, 0, id);
+  };
+  d.overlay = () => {
+    if (!ghosts) return [];
+    const full = {}; layoutTree(tree, I, () => true, full);
+    return Object.keys(full).filter(id => !view[tagOf[id]]).map(id => ({ ...full[id], id }));
+  };
+  d.set(L());
+  d.button('Hide / show tag 2 (D, E)', () => { view[2] = !view[2]; d.go(L()); });
+  d.button('Swap A and B', () => { swap('A', 'B'); d.go(L()); });
+  d.button('Move C next to B', () => { if (parentOf(tree, 'C') !== parentOf(tree, 'B')) { moveAfter('C', 'B'); d.go(L()); } });
+  d.button('Reset', () => { reset(); d.go(L()); });
+  d.check('show hidden slots', false, v => ghosts = v);
+}
+
+{ // d12 lane extent
+  const W = 640, H = 320, d = new Demo('d12', W, H), I = inner(W, H);
+  let order = ['A', 'B', 'C'], whole = false;
+  const L = () => { const r = splitY(I, ['top', 'bot'], [7, 3]); return { T: r.top, ...splitX(r.bot, order) }; };
+  d.set(L());
+  d.button('Reverse bottom row', () => {
+    order = [...order].reverse();
+    const tgt = L();
+    d.go(tgt, { planFn: from => { LANE_REGION = whole ? I : null; try { return plan(from, tgt); } finally { LANE_REGION = null; } } });
+  });
+  const mb = d.button('lanes span: involved band', () => { whole = !whole; mb.textContent = 'lanes span: ' + (whole ? 'whole output' : 'involved band'); });
+}
+
+{ // d13 fullscreen
+  const W = 640, H = 300, d = new Demo('d13', W, H, { floating: ['B'] }), I = inner(W, H);
+  let full = false;
+  const L = () => { const o = splitX(I, ['A', 'B', 'C']); if (full) o.B = R(0, 0, W, H); return o; };
+  d.set(L());
+  d.button('Fullscreen B', () => {
+    full = !full;
+    const tgt = L();
+    d.go(tgt, { planFn: from => ({ kind: full ? 'glide to fullscreen' : 'glide back to slot', keys: [from, tgt], durs: [PHASE_MS] }) });
+  });
+}
+
+{ // d14 expand
+  const W = 640, H = 300, d = new Demo('d14', W, H), I = inner(W, H);
+  let col = false, root = false;
+  const L = () => {
+    const cols = splitX(I, ['A', 'R']);
+    const area = root ? I : cols.R;
+    const o = root ? { A: R(I.x, I.y, 0, I.h) } : { A: cols.A };
+    if (col) Object.assign(o, { B: R(area.x, area.y, area.w, 0), C: area, D: R(area.x, area.y + area.h, area.w, 0) });
+    else Object.assign(o, splitY(area, ['B', 'C', 'D']));
+    return o;
+  };
+  d.set(L());
+  d.button('Expand C in its column', () => { col = !col; d.go(L()); });
+  d.button('Expand the column to the output', () => { root = !root; d.go(L()); });
+  d.button('Expand C all the way', () => { const on = !(col && root); col = on; root = on; d.go(L()); });
+}
+
 document.getElementById('phaseMs').oninput = e => { PHASE_MS = +e.target.value; document.getElementById('phaseMsOut').textContent = PHASE_MS + ' ms'; };
 document.getElementById('style').onchange = e => { STYLE = e.target.value; };
 const loop = now => { for (const d of demos) d.frame(now); requestAnimationFrame(loop); };

monolith

Commit 944fc4782ac3

Commit `944fc4782ac3`