summaryrefslogtreecommitdiff
path: root/src/layout.zig
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-10 05:42:57 -0300
committerGabriel Schneider <[email protected]>2026-11-10 05:48:17 -0300
commit8903d352237919455996831047017ae57f2a83ef (patch)
tree9876a3597a55b0b5fc16e535c1edd44eaed71e11 /src/layout.zig
parent29e6abf9ccb07b1c10997588e1cf4cfc1ed53021 (diff)
downloadpardes-8903d352237919455996831047017ae57f2a83ef.tar.gz
pardes-8903d352237919455996831047017ae57f2a83ef.zip
layout: exec.placeNew moves into layout.zig as layout.placeNew, with NewPane, the type only it switches on, and acmeColumn and columnOf, which only it calls, before canSplitCol, since 29 of its 41 references are layout's own (acmePlace, takeRoom, splitTallest, placedRoomy); callers name layout, and Dir, mini and Store, which imported exec for it alone, import layout instead
Co-Authored-By: Claude Fable 5.1 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNAtZenFv4weoMD3cge
Diffstat (limited to 'src/layout.zig')
-rw-r--r--src/layout.zig118
1 files changed, 117 insertions, 1 deletions
diff --git a/src/layout.zig b/src/layout.zig
index 1d93c993..fca4c846 100644
--- a/src/layout.zig
+++ b/src/layout.zig
@@ -855,6 +855,122 @@ fn blankRows(p: *const Pardes, id: usize) u16 {
return rows -| @as(u16, @intCast(@min(used, rows)));
}
+/// What a new pane is, and who asked: each rule places them differently.
+/// `scratch` is New's, `fs` 9P's pane/new, `errors` a +Errors pane.
+pub const NewPane = enum { scratch, fs, shell, doc, command, errors };
+
+/// Put new pane `id` in the layout: every new pane comes through here, as
+/// acme's makenewwindow places it, and every one but a command pane takes
+/// the keyboard. `from` is the pane that asked, `origin` the text it asked
+/// from: null when a column tag, the workspace tag or 9P asked (acme's
+/// t->w == nil).
+pub fn placeNew(p: *Pardes, from: usize, origin: ?usize, id: usize, kind: NewPane) void {
+ const v = p.view();
+ // No column left (the last one Delcol'd): a pane made from the workspace
+ // tag opens one to go in.
+ _ = firstColumn(p);
+ const asked = if (p.exec_column != null) null else origin;
+ compute(p);
+ const before = v.rects;
+ const before_min = minima(p);
+ switch (kind) {
+ // New: the bottom half of the last pane in its own column
+ // (look.c:921-923, et->col).
+ .scratch => acmePlace(p, p.exec_column orelse columnOf(p, from), null, id),
+ // +Errors, a command's output: the last column (util.c:94-98); a
+ // command run from a column's tag, that column.
+ .command => acmePlace(p, p.exec_column orelse v.ncol - 1, null, id),
+ .errors => acmePlace(p, v.ncol - 1, null, id),
+ // makenewwindow(nil) for 9P's new (acme.c:877), else (t).
+ .fs => acmePlace(p, acmeColumn(p, from), null, id),
+ .shell, .doc => acmePlace(p, acmeColumn(p, from), asked, id),
+ }
+ // No pane is made shorter than its tag and two rows: where the place
+ // chosen has not the room, the column's tallest pane gives it, and
+ // where none can, the pane is refused, and closed at the step's end
+ // (Pardes.unplaced) once whatever made it is done with it.
+ if (!placedRoomy(p, id, &before)) if (findPane(p, id)) |f| {
+ removePane(p, id);
+ for (v.cols[f.col].panes[0..p.view().cols[f.col].n]) |k| v.rects[k] = before[k];
+ snapColWeights(p, f.col);
+ if (!splitTallest(p, f.col, id) or !placedRoomy(p, id, &before)) {
+ if (findPane(p, id) != null) {
+ removePane(p, id);
+ for (v.cols[f.col].panes[0..p.view().cols[f.col].n]) |k| v.rects[k] = before[k];
+ snapColWeights(p, f.col);
+ }
+ // No pane to halve, but the column has the rows for the new
+ // one's minimum above the others': it takes them from those with
+ // the most to spare (a pane dragged short keeps its own), so
+ // what is refused is only what the documented arithmetic cannot
+ // hold.
+ // +Errors and 9P's pane/new go wherever there is room, last
+ // column first, as acme takes rows from a window that has them
+ // before saying there are none; with none, +Errors's maker says
+ // the text some other way (appendErrors), and pane/new is
+ // refused.
+ if (takeRoom(p, f.col, id)) {} else if (kind == .errors or kind == .fs) {
+ var c = v.ncol;
+ while (c > 0) {
+ c -= 1;
+ if (c == f.col) continue;
+ for (v.cols[c].panes[0..p.view().cols[c].n]) |k| v.rects[k] = before[k];
+ snapColWeights(p, c);
+ if (v.cols[c].n == 0) {
+ insert(p, c, 0, id);
+ break;
+ }
+ if (splitTallest(p, c, id) and placedRoomy(p, id, &before)) break;
+ if (findPane(p, id) != null) removePane(p, id);
+ } else {
+ insert(p, f.col, v.cols[f.col].n, id);
+ p.unplaced.set(id);
+ // Refused holding no weight: its column's rows come
+ // back as they were.
+ p.panes[id].?.vweight = 0;
+ // No pane anywhere can give it rows: pane/new is refused.
+ if (kind == .fs) p.reportError(from, "placement", error.NoPaneRoom);
+ return;
+ }
+ } else {
+ insert(p, f.col, v.cols[f.col].n, id);
+ // Refused, it closes at the step's end holding no weight, so
+ // its column's rows come back as they were, none rounded off.
+ p.panes[id].?.vweight = 0;
+ p.unplaced.set(id);
+ p.reportError(from, "placement", error.NoPaneRoom);
+ return;
+ }
+ }
+ };
+ // Placed: no pane the rows' rounding took under its minimum stays
+ // there. Only those: a pane dragged short before keeps its rows, and
+ // the others keep theirs, as acme's coladd moves only the window it
+ // splits (cols.c:41-108). The new pane had nothing to keep: it is
+ // lifted to its minimum too.
+ var settled = before;
+ settled[id].h = std.math.maxInt(u16);
+ restoreMinimaFrom(p, &settled, &before_min);
+ if (kind == .command) return;
+ tagline.exitHeader(p);
+ v.active = id;
+ if (findPane(p, id)) |f| p.setActiveColumn(f.col);
+}
+
+/// acme's makenewwindow column (util.c:456-467): the column a command came
+/// from (its tag's), else the active column, else the keyboard's pane's,
+/// else the asking pane's.
+fn acmeColumn(p: *Pardes, from: usize) usize {
+ if (p.exec_column) |c| return c;
+ if (activeColumn(p)) |c| return c;
+ if (findPane(p, p.view().active)) |f| return f.col;
+ return columnOf(p, from);
+}
+
+fn columnOf(p: *Pardes, id: usize) usize {
+ return if (findPane(p, id)) |f| f.col else p.view().ncol - 1;
+}
+
/// Whether column `col` has the width and the weight to halve for a new
/// column beside it.
pub fn canSplitCol(p: *Pardes, col: usize) bool {
@@ -977,7 +1093,7 @@ pub fn splitBelow(p: *Pardes, src_id: usize, nw: *Pane) void {
const cur: u16 = if (!src.isTerminal()) body / 2 else panes.terminal.gridCursor(src).y + 1;
// cap keep so a content-full source still leaves the new pane a tag +
// a few body rows (an Alt-n from a full shell was born 0 rows tall)
- // ...and the source min_body_rows of its own (exec.placeNew), when it
+ // ...and the source min_body_rows of its own (placeNew), when it
// has them: a boot layout splits before any row is laid out.
const least = @min(min_body_rows, body);
const keep = std.math.clamp(cur, least, @max(least, body -| (BOX_H + 3)));