const std = @import("std"); const pardes = @import("pardes.zig"); const tagline = @import("tagline.zig"); const dump = @import("dump.zig"); const config = @import("config.zig"); const panes = @import("panes.zig"); const animation = @import("animation.zig"); const Box = animation.Box; const Pardes = pardes.Pardes; const Pane = pardes.Pane; pub const Rect = struct { x: u16 = 0, y: u16 = 0, w: u16 = 0, h: u16 = 0 }; const MAX_COLS = pardes.MAX_COLS; const MAX_PANES = pardes.MAX_PANES; const BOX_H = pardes.BOX_H; pub const column_weight_unit: u64 = 1 << 32; pub const max_column_weight: u64 = std.math.maxInt(u64) / MAX_COLS; pub const MovePlacement = struct { preview_col: usize, /// The pane the moved one lands below; null when the column is empty /// and the moved pane takes it whole. above_id: ?usize, row: u16, above_y: u16, above_h: u16, }; pub const Dir = enum { left, right, up, down }; /// Move the keyboard to the nearest pane in `dir`; false when there is none. pub fn focusDir(p: *Pardes, from: usize, dir: Dir) bool { const b = nearest(p, from, dir) orelse return false; p.active = b; // a count typed before the hop was meant for the pane you left p.panes[b].?.body.normal.clear(); return true; } /// The pane next to `from` in `dir`, by the screen. pub fn nearest(p: *const Pardes, from: usize, dir: Dir) ?usize { const a = p.rects[from]; var best: ?usize = null; var best_d: i32 = 0; for (p.panes, 0..) |slot, i| { if (slot == null or i == from) continue; const r = p.rects[i]; const vov = a.y < r.y + r.h and r.y < a.y + a.h; const hov = a.x < r.x + r.w and r.x < a.x + a.w; const ok = switch (dir) { .left => r.x + r.w <= a.x and vov, .right => r.x >= a.x + a.w and vov, .up => r.y + r.h <= a.y and hov, .down => r.y >= a.y + a.h and hov, }; if (!ok) continue; const d: i32 = switch (dir) { .left => @as(i32, a.x) - @as(i32, r.x + r.w), .right => @as(i32, r.x) - @as(i32, a.x + a.w), .up => @as(i32, a.y) - @as(i32, r.y + r.h), .down => @as(i32, r.y) - @as(i32, a.y + a.h), }; if (best == null or d < best_d) { best = i; best_d = d; } } return best; } /// Window mode's labels, one a pane in reading order (columns left to /// right, each top to bottom); h, j, k and l move instead, d deletes and c /// collapses. ponytail: a pane past the 20th has no label and is reached /// by moving. pub const window_labels = "asfgqwertyuiopzxvbnm"; /// The letter window mode shows on pane `id`. pub fn windowLabel(p: *const Pardes, id: usize) ?u8 { var n: usize = 0; for (0..p.ncol) |c| for (p.col_panes[c][0..p.col_n[c]]) |pane| { if (n == window_labels.len) return null; if (pane == id) return window_labels[n]; n += 1; }; return null; } /// Window mode (SPC w, Ctrl-w): h/j/k/l (or the arrows) move an outline /// from pane to pane and nothing else gets the keys; Enter or Esc focuses /// the outlined pane, `:` its tag, and a pane's label letter that one. Up past a /// column's top pane goes on to its tag, as the Up word does. `d` is Del /// on the outlined pane and `c` Collapse, and the mode stays: a Del that /// closes it moves the outline to the pane its rows went to (after the k/j /// question, when Del asks one; Pardes.answerQuestion). Any other key /// changes nothing. pub fn windowKey(p: *Pardes, key: pardes.Key) void { const at = p.window_pick orelse return; if (p.panes[at] == null) { p.window_pick = null; return; } if (key.ctrl or key.alt) return; for (config.window_keys) |wk| if (pardes.hit(key, &.{ wk.letter, wk.arrow })) { const dir: Dir = switch (wk.cmd) { .Left => .left, .Down => .down, .Up => .up, else => .right, }; if (nearest(p, at, dir)) |next| { p.window_pick = next; } else if (dir == .up) { p.window_pick = null; p.active = at; pardes.exec.runBuiltin(p, .Up, at, "", null); } return; }; if (pardes.hit(key, config.window_collapse)) return pardes.exec.runBuiltin(p, .Collapse, at, "", null); if (pardes.hit(key, config.window_delete)) { // Del's focus follows the rows from the pane it closes, so the // outlined pane is the active one while it runs. p.active = at; pardes.exec.runBuiltin(p, .Del, at, "", null); if (p.panes[at] == null) p.window_pick = if (p.header_focus) null else p.active; return; } const chosen = if (key.cp == pardes.Key.enter or key.cp == pardes.Key.escape or key.cp == ':') at else for (0..p.panes.len) |id| { if (p.panes[id] != null and key.cp < 128 and windowLabel(p, id) == @as(u8, @intCast(key.cp))) break id; } else return; p.window_pick = null; p.active = chosen; p.panes[chosen].?.body.normal.clear(); if (key.cp == ':') tagline.enterTag(p, p.panes[chosen].?); } /// Column `c`'s serial, handed out the first time it is asked for. pub fn columnSerial(p: *Pardes, c: usize) u32 { if (p.col_serial[c] == 0) { p.col_serial[c] = p.next_column_serial; p.next_column_serial +%= 1; if (p.next_column_serial == 0) p.next_column_serial = 1; } return p.col_serial[c]; } pub fn columnBySerial(p: *const Pardes, serial: u32) ?usize { if (serial == 0) return null; for (0..p.ncol) |column| if (p.col_serial[column] == serial) return column; return null; } /// What releasing column `source`'s grip at `x` does: past a neighbour's /// middle it takes that column's place; short of it, as in acme, the /// column's left edge moves to `x - grab`, clamped as setColumnPairWidth /// clamps it. Still on the grip, or at the leftmost column, nothing moves. /// The drag preview and the release both ask here, so they cannot disagree. pub const ColumnDrop = union(enum) { stay, reorder: usize, edge: u16 }; pub fn columnDrop(p: *const Pardes, source: usize, x: u16, grab: u16) ColumnDrop { if (source >= p.ncol) return .stay; var insertion: usize = 0; for (0..p.ncol) |column| { if (column == source) continue; if (x >= p.col_x[column] + p.col_w[column] / 2) insertion += 1; } if (insertion != source) return .{ .reorder = insertion }; if (source == 0 or (x >= p.col_x[source] and x < p.col_x[source] + config.GUTTER)) return .stay; if (p.col_w[source - 1] + p.col_w[source] < 2 * config.MINW) return .stay; const lo = p.col_x[source - 1] + config.MINW; const hi = (p.col_x[source] + p.col_w[source]) -| config.MINW; return .{ .edge = std.math.clamp(x -| grab, lo, @max(lo, hi)) }; } /// Share out the width of columns `left` and `left + 1` so the left one is /// `left_width` cells, neither below MINW. A border drag and a column grip /// dropped inside its own place both end here. pub fn setColumnPairWidth(p: *Pardes, left: usize, left_width: u64) void { if (left + 1 >= p.ncol) return; const combined: u64 = p.col_w[left] + p.col_w[left + 1]; // The finder's edge sets its share (Finder.dragWidth). if (p.finder.column(p)) |fc| { if (fc == left + 1) return p.finder.dragWidth(p, left, combined -| left_width); if (fc == left) return p.finder.dragWidth(p, left + 1, left_width); } // Too narrow for both to keep MINW: any split would squeeze one away. if (combined < 2 * @as(u64, config.MINW)) return; const width = std.math.clamp(left_width, config.MINW, @max(@as(u64, config.MINW), combined -| config.MINW)); const pair = p.col_weight[left] + p.col_weight[left + 1]; if (pair <= 1 or combined == 0) return; const numerator = @as(u128, pair) * width + combined / 2; const share = std.math.clamp(@as(u64, @intCast(numerator / combined)), 1, pair - 1); p.col_weight[left] = share; p.col_weight[left + 1] = pair - share; } pub fn reorderColumn(p: *Pardes, from: usize, to: usize) void { if (from >= p.ncol or to >= p.ncol or from == to) return; const ids = p.col_panes[from]; const count = p.col_n[from]; const weight = p.col_weight[from]; const tag = p.col_tags[from]; const serial = p.col_serial[from]; var at = from; while (at != to) { const next = if (at < to) at + 1 else at - 1; p.col_panes[at] = p.col_panes[next]; p.col_n[at] = p.col_n[next]; p.col_weight[at] = p.col_weight[next]; p.col_tags[at] = p.col_tags[next]; p.col_serial[at] = p.col_serial[next]; at = next; } p.col_panes[to] = ids; p.col_n[to] = count; p.col_weight[to] = weight; p.col_tags[to] = tag; p.col_serial[to] = serial; if (p.header_column) |column| { if (column == from) p.header_column = to else if (from < to and column > from and column <= to) { p.header_column = column - 1; } else if (from > to and column >= to and column < from) p.header_column = column + 1; } p.pointer_tag_hit = null; p.look_hover_wait = null; p.look_hover_preview = null; compute(p); } pub fn targetColumn(p: *Pardes, cur_x: u16) usize { var tc: usize = if (p.ncol > 0) p.ncol - 1 else 0; for (0..p.ncol) |c| { if (cur_x >= p.col_x[c] and cur_x < p.col_x[c] + p.col_w[c]) { tc = c; break; } } return tc; } pub fn splitRowForExtent(y: u16, h: u16, cur_y: u16) ?u16 { return splitRowFor(y, h, cur_y, null); } /// As `splitRowForExtent`, each pane keeping at least `least` rows when /// given: a pane dragged by its grip within its own column is how a /// terminal resizes, and acme lets either window keep only its tag. fn splitRowFor(y: u16, h: u16, cur_y: u16, least: ?u16) ?u16 { if (h < 2) return null; const min_each: u16 = least orelse if (h >= config.MINH * 2) config.MINH else 1; const lo = y +| min_each; const hi = y + h - min_each; if (lo > hi) return y + h / 2; return std.math.clamp(cur_y, lo, hi); } /// Where pane `id` dragged by its grip to (`cur_x`, `cur_y`) lands. An /// owner's grip drags its group; an attachment's drags it alone, which /// within its group resizes it and anywhere else detaches it (movePane). /// Another group is one place: a pane dropped on it lands under all of it. pub fn movePlacement(p: *Pardes, id: usize, cur_x: u16, cur_y: u16) ?MovePlacement { const src = findPane(p, id) orelse return null; const span_end = if (ownerOf(p, id) == null) groupEnd(p, src.col, src.idx) else src.idx + 1; const own_root = groupRoot(p, id); const tc = targetColumn(p, cur_x); if (tc == src.col and p.col_n[src.col] == span_end - src.idx) return null; var span_h: u16 = 0; for (p.col_panes[src.col][src.idx..span_end]) |k| span_h +|= p.rects[k].h; if (tc == src.col) { const top = p.rects[id].y; // Dropped on itself it stays, unless dragged down from its top with // a pane above: its top moves down there, the pane above taking the // rows, as acme's window dragged by its button does. With no rule // between panes, that is how a terminal resizes them. if (cur_y >= top and cur_y < top + span_h and (src.idx == 0 or cur_y <= top)) return null; } var heights: [MAX_PANES]u16 = @splat(0); for (0..p.ncol) |c| { for (0..p.col_n[c]) |k| { const pid = p.col_panes[c][k]; heights[pid] = p.rects[pid].h; } } if (p.col_n[src.col] > span_end - src.idx) { const sib = if (src.idx > 0) p.col_panes[src.col][src.idx - 1] else p.col_panes[src.col][span_end]; heights[sib] +|= span_h; } var y: u16 = p.topBarHeight() + p.columnBarHeight(); if (p.col_n[tc] == 0) return .{ .preview_col = tc, .above_id = null, .row = y, .above_y = y, .above_h = 0 }; var last: ?MovePlacement = null; var k: usize = 0; while (k < p.col_n[tc]) { if (tc == src.col and k >= src.idx and k < span_end) { k += 1; continue; } // Its own group's panes are places of their own: that is how an // attachment's grip resizes it against its owner. const unit_end = if (groupRoot(p, p.col_panes[tc][k]) == own_root) k + 1 else groupEnd(p, tc, k); var h: u16 = 0; for (k..unit_end) |j| { if (tc == src.col and j >= src.idx and j < span_end) continue; h +|= heights[p.col_panes[tc][j]]; } const above = p.col_panes[tc][unit_end - 1]; k = unit_end; const row = splitRowFor(y, h, cur_y, if (tc == src.col) BOX_H else null) orelse { y +|= h; continue; }; const placement: MovePlacement = .{ .preview_col = tc, .above_id = above, .row = row, .above_y = y, .above_h = h, }; last = placement; if (cur_y < y + h) return placement; y +|= h; } return last; } /// Move pane `id`, and the group it owns, where movePlacement says. An /// attachment moved anywhere but within its own group is detached there. pub fn movePane(p: *Pardes, id: usize, cur_x: u16, cur_y: u16) void { const placement = movePlacement(p, id, cur_x, cur_y) orelse return; const src = findPane(p, id) orelse return; const owner = ownerOf(p, id); const own_root = groupRoot(p, id); const span_end = if (owner == null) groupEnd(p, src.col, src.idx) else src.idx + 1; const count = span_end - src.idx; var moved: [MAX_PANES]usize = undefined; @memcpy(moved[0..count], p.col_panes[src.col][src.idx..span_end]); const source_multi = p.col_n[src.col] > count; var heights: [MAX_PANES]u16 = @splat(0); for (0..p.ncol) |c| { for (0..p.col_n[c]) |k| { const pid = p.col_panes[c][k]; heights[pid] = p.rects[pid].h; } } var span_h: u16 = 0; for (moved[0..count]) |m| span_h +|= heights[m]; for (moved[0..count]) |m| removePane(p, m); if (source_multi) { const sib = if (src.idx > 0) p.col_panes[src.col][src.idx - 1] else p.col_panes[src.col][src.idx]; heights[sib] +|= span_h; } const above = placement.above_id orelse { for (moved[0..count], 0..) |m, j| insert(p, placement.preview_col, j, m); if (count > 1) setColumnWeights(p, placement.preview_col, &heights); if (source_multi) setColumnWeights(p, src.col, &heights); if (owner != null) p.panes[id].?.attached_to = null; return; }; const af = findPane(p, above) orelse return; const upper_h = @max(1, placement.row -| placement.above_y); var lower_h = @max(1, placement.above_h -| upper_h); const above_root = groupRoot(p, above); if (above_root != above and above_root != own_root) { // Dropped on another group: its owner gives the rows, keeping its tag. const pay = @min(placement.above_h -| upper_h, heights[above_root] -| BOX_H); heights[above_root] -= pay; lower_h = @max(1, pay); } else heights[above] = upper_h; // The group shares what it lands in as it shared what it had. var left = lower_h; for (moved[1..count]) |m| { const share: u16 = @intCast(@max(1, @as(u32, heights[m]) * lower_h / @max(1, span_h))); heights[m] = share; left -|= share; } heights[id] = @max(1, left); for (moved[0..count], 0..) |m, j| insert(p, af.col, af.idx + 1 + j, m); setColumnWeights(p, af.col, &heights); if (source_multi and src.col != af.col) setColumnWeights(p, src.col, &heights); if (owner) |o| { const pane = p.panes[id].?; // Still right under its owner's group: resized there. Anywhere // else it is a pane of its own. if (af.col != (findPane(p, o) orelse return).col or !descends(p, above, o)) pane.attached_to = null; } } pub fn setColumnWeights(p: *Pardes, col: usize, heights: *const [MAX_PANES]u16) void { if (col >= p.ncol) return; for (0..p.col_n[col]) |k| { const pid = p.col_panes[col][k]; if (p.panes[pid]) |pane| if (!pane.collapsed) { pane.vweight = @floatFromInt(@max(1, heights[pid])); }; } } /// Give a newly opened report enough rows to read, borrowing only space /// above the other panes' usable minima. Keep their tags and bodies visible. pub fn givePaneRows(p: *Pardes, id: usize, wanted: u16, context: usize) void { const at = findPane(p, id) orelse return; compute(p); var heights: [MAX_PANES]u16 = @splat(0); for (p.col_panes[at.col][0..p.col_n[at.col]]) |other| heights[other] = p.rects[other].h; var missing = wanted -| heights[id]; for (p.col_panes[at.col][0..p.col_n[at.col]]) |other| { if (other == id or p.panes[other].?.collapsed) continue; const body_rows: u16 = if (other == context) 6 else 3; const minimum = @max(minRows(p, other), p.panes[other].?.tag_rows + body_rows); const take = @min(missing, heights[other] -| minimum); heights[other] -= take; heights[id] += take; missing -= take; if (missing == 0) break; } setColumnWeights(p, at.col, &heights); p.sync(); } pub fn applyRowSplit(p: *Pardes, cc: usize, k: usize, cur_y: u16) void { if (k + 1 >= p.col_n[cc]) return; const a = p.panes[p.col_panes[cc][k]] orelse return; const b = p.panes[p.col_panes[cc][k + 1]] orelse return; const ra = p.rects[p.col_panes[cc][k]]; const rb = p.rects[p.col_panes[cc][k + 1]]; const combined: f32 = @floatFromInt(ra.h + rb.h); var nt: f32 = @floatFromInt(if (p.settings.tag_bottom) cur_y -| ra.y else (cur_y + 1) -| ra.y); // A terminal keeps its tag and two body rows (floorRows); a text pane // gives up all but its tag, as acme's do. const lo: f32 = @floatFromInt(@max(BOX_H, floorRows(p, p.col_panes[cc][k]))); const hi = combined - @as(f32, @floatFromInt(@max(BOX_H, floorRows(p, p.col_panes[cc][k + 1])))); nt = std.math.clamp(nt, @min(lo, @max(@as(f32, BOX_H), hi)), @max(@as(f32, BOX_H), hi)); if (combined <= 0) return; // Dragging a folded tag open is an explicit resize, so switch this pair // back to visible-height weights without consuming other folded weights. if ((a.collapsed and nt > BOX_H) or (b.collapsed and combined - nt > BOX_H)) { snapColWeights(p, cc); a.vweight = @floatFromInt(@max(1, ra.h)); b.vweight = @floatFromInt(@max(1, rb.h)); if (nt > BOX_H) a.collapsed = false; if (combined - nt > BOX_H) b.collapsed = false; } if (a.collapsed or b.collapsed) return; const pair = a.vweight + b.vweight; a.vweight = pair * (nt / combined); b.vweight = pair - a.vweight; } pub fn findPane(p: *const Pardes, id: usize) ?struct { col: usize, idx: usize } { for (0..p.ncol) |c| { for (0..p.col_n[c]) |k| { if (p.col_panes[c][k] == id) return .{ .col = c, .idx = k }; } } return null; } pub fn insert(p: *Pardes, c: usize, idx: usize, id: usize) void { var k = p.col_n[c]; while (k > idx) : (k -= 1) p.col_panes[c][k] = p.col_panes[c][k - 1]; p.col_panes[c][idx] = id; p.col_n[c] += 1; } /// Take a pane out of its column. The column stays, empty if this was its /// last pane, as acme's colclose leaves it (cols.c:186): only Delcol and /// Joincol take a column away. pub fn removePane(p: *Pardes, id: usize) void { const f = findPane(p, id) orelse return; const c = f.col; var k = f.idx; while (k + 1 < p.col_n[c]) : (k += 1) p.col_panes[c][k] = p.col_panes[c][k + 1]; p.col_n[c] -= 1; } /// Close column `c` once its panes are gone, its width to the one left of /// it (the first column's to its right), as acme's rowclose gives it. pub fn dropColumn(p: *Pardes, c: usize) void { const serial = columnSerial(p, c); dropColumnUnannounced(p, c); noteColumn(p, "delcol", serial); } /// dropColumn with no `delcol`, for a column never announced. pub fn dropColumnUnannounced(p: *Pardes, c: usize) void { std.debug.assert(p.col_n[c] == 0); tagline.exitHeader(p); // The finder's width was its share, no weight: nobody gets one, so the // others are as wide as before it came. A column whose weight would go // to the finder gives it to the column on the finder's other side. const finder = p.finder.column(p); const heir: ?usize = if (p.ncol <= 1 or finder == c) null else if (c > 0 and finder != c - 1) c - 1 else if (c + 1 < p.ncol and finder != c + 1) c + 1 else if (c > 1) c - 2 else if (c + 2 < p.ncol) c + 2 else null; if (heir) |h| p.col_weight[h] +|= p.col_weight[c]; p.col_tags[c].deinit(p.gpa); var j = c; while (j + 1 < p.ncol) : (j += 1) { p.col_panes[j] = p.col_panes[j + 1]; p.col_n[j] = p.col_n[j + 1]; p.col_weight[j] = p.col_weight[j + 1]; p.col_tags[j] = p.col_tags[j + 1]; p.col_serial[j] = p.col_serial[j + 1]; } p.ncol -= 1; p.col_tags[p.ncol] = .{ .what = .column, .gpa = p.gpa }; p.col_serial[p.ncol] = 0; } /// `newcol ` or `delcol ` in the log: the column's serial, /// as /layout and /col name it. pub fn noteColumn(p: *Pardes, what: []const u8, serial: u32) void { var buf: [16]u8 = undefined; pardes.ctlfs.events.notePath(p, what, std.fmt.bufPrint(&buf, "{d}", .{serial}) catch return); } /// Fold column `c` into the one on its right, its panes below theirs. pub fn joinCol(p: *Pardes, c: usize) void { if (c + 1 >= p.ncol) return; const dst = c + 1; joinPanes(p, c, dst); dropColumn(p, c); } /// Whether column `c` joined into the one on its right leaves every pane /// its tag and 2 rows (minimaFit), tried in place and undone: nothing is /// dropped or logged for a join that does not fit. pub fn joinFits(p: *Pardes, c: usize) bool { if (c + 1 >= p.ncol) return true; const dst = c + 1; const n = p.col_n[c]; const had = p.col_n[dst]; const weights = .{ p.col_weight[c], p.col_weight[dst] }; const panes_c = p.col_panes[c]; joinPanes(p, c, dst); const fits = minimaFit(p); p.col_n[dst] = had; p.col_n[c] = n; p.col_panes[c] = panes_c; p.col_weight[c] = weights[0]; p.col_weight[dst] = weights[1]; compute(p); return fits; } fn joinPanes(p: *Pardes, c: usize, dst: usize) void { for (0..p.col_n[c]) |k| p.col_panes[dst][p.col_n[dst] + k] = p.col_panes[c][k]; p.col_n[dst] += p.col_n[c]; p.col_n[c] = 0; // The width goes right, where the panes went. p.col_weight[dst] +|= p.col_weight[c]; p.col_weight[c] = 0; } /// Put new pane `id` in column `c` as acme's makenewwindow does /// (util.c:449-495): an empty column it takes whole; asked from a tag or /// from 9P (`origin` null, acme's t->w == nil) it takes the bottom half of /// the column's last pane (coladd with y < 0, cols.c:62-65). Asked from a /// pane's text, it goes under the text of the pane with the most blank rows /// when there are many, else it halves the biggest pane, or `origin` when /// that is in the column and not much smaller. pub fn acmePlace(p: *Pardes, c: usize, origin: ?usize, id: usize) void { compute(p); const n = p.col_n[c]; if (n == 0) { insert(p, c, 0, id); p.panes[id].?.vweight = 1; return; } var big: ?usize = null; var empty: ?usize = null; for (p.col_panes[c][0..n]) |k| { const pane = p.panes[k] orelse continue; // An attachment is its owner's: never halved for another pane. if (pane.collapsed or ownerOf(p, k) != null) continue; // `>=`: at a tie the one nearer the bottom, as acme picks. if (big == null or bodyRows(p, k) >= bodyRows(p, big.?)) big = k; if (empty == null or blankRows(p, k) >= blankRows(p, empty.?)) empty = k; } const v0 = big orelse { // Every pane folded: the new one goes last. insert(p, c, n, id); return; }; const y: u16 = y: { const o = origin orelse { var last = v0; for (p.col_panes[c][0..n]) |k| if (!p.panes[k].?.collapsed and ownerOf(p, k) == null) { last = k; }; break :y bodyTop(p, last) + bodyRows(p, last) / 2; }; const e = empty.?; const el = blankRows(p, e); if (el > 15 or (el > 3 and el > (bodyRows(p, v0) -| 1) / 2)) break :y bodyTop(p, e) + bodyRows(p, e) - el; // Asked from a results pane, it is its owner that is split. const root = groupRoot(p, o); const mine = if (findPane(p, root)) |f| f.col == c and !p.panes[root].?.collapsed else false; const v = if (mine and @as(u32, p.rects[root].h) * 3 > @as(u32, p.rects[v0].h) * 2) root else v0; break :y p.rects[v].y + p.rects[v].h / 2; }; splitAt(p, c, id, y); } /// The body rows a placement leaves every pane it makes or shrinks, under /// its tag (acme's minht keeps one). pub const min_body_rows = 2; /// The rows a placement, and a `size`, leave a pane: its tag at its width /// and `min_body_rows`. The one minimum both ask. pub fn minRows(p: *Pardes, id: usize) u16 { return p.wantedTagRows(id) + min_body_rows; } /// Whether every column has the rows for each of its unfolded panes' /// `minRows` (a folded one its tag row): the panes' own minima, not how /// the weights happen to share the rows, so a size that fits keeps fitting /// when it grows. One pane alone in its column always fits. pub fn minimaFit(p: *Pardes) bool { compute(p); const avail = p.screen_h -| (p.topBarHeight() + p.columnBarHeight()); for (0..p.ncol) |c| { if (p.col_n[c] < 2) continue; var need: u32 = 0; for (p.col_panes[c][0..p.col_n[c]]) |k| { const pane = p.panes[k] orelse continue; need += if (pane.collapsed) BOX_H else minRows(p, k); } if (need > avail) return false; } return true; } /// Whether every unfolded pane of column `c` has its `minRows` (a pane /// alone in its column always does). pub fn columnAtMinimums(p: *Pardes, c: usize) bool { compute(p); if (p.col_n[c] < 2) return true; for (p.col_panes[c][0..p.col_n[c]]) |k| { const pane = p.panes[k] orelse continue; if (!pane.collapsed and p.rects[k].h < minRows(p, k)) return false; } return true; } /// Shares column `c`'s rows out again so every unfolded pane has its /// `minRows`, as evenly as that allows; false, changing nothing, when the /// column has not the rows for all of them (or holds a folded pane). pub fn shareColumn(p: *Pardes, c: usize) bool { compute(p); const n = p.col_n[c]; if (n == 0) return false; const avail = p.screen_h -| (p.topBarHeight() + p.columnBarHeight()); var mins: [MAX_PANES]u16 = undefined; var need: u32 = 0; for (p.col_panes[c][0..n], 0..) |k, i| { const pane = p.panes[k] orelse return false; if (pane.collapsed) return false; p.rects[k].w = p.col_w[c]; mins[i] = minRows(p, k); need += mins[i]; } if (need > avail) return false; // Each its minimum, then what is left a row at a time to the smallest. var hs: [MAX_PANES]u16 = undefined; @memcpy(hs[0..n], mins[0..n]); var left = avail - need; while (left > 0) : (left -= 1) { var low: usize = 0; for (1..n) |i| if (hs[i] < hs[low]) { low = i; }; hs[low] += 1; } for (p.col_panes[c][0..n], 0..) |k, i| p.panes[k].?.vweight = @floatFromInt(hs[i]); compute(p); return true; } /// After a resize the minima fit: each unfolded pane the resize took below /// its `minRows` (it had them in `before`) gets them back, a row at a time /// from whichever pane of its column has the most above its own. A pane /// dragged short before keeps what it had. pub fn restoreMinima(p: *Pardes, before: *const [MAX_PANES]Rect) void { compute(p); for (0..p.ncol) |c| { const n = p.col_n[c]; if (n < 2) continue; var hs: [MAX_PANES]u16 = undefined; var mins: [MAX_PANES]u16 = undefined; var short = false; for (p.col_panes[c][0..n], 0..) |k, i| { const pane = p.panes[k] orelse return; if (pane.collapsed) break; hs[i] = p.rects[k].h; mins[i] = minRows(p, k); if (hs[i] < mins[i] and before[k].h >= mins[i]) short = true; } else { if (!short) continue; for (p.col_panes[c][0..n], 0..) |k, i| { if (hs[i] >= mins[i] or before[k].h < mins[i]) continue; while (hs[i] < mins[i]) { var giver: ?usize = null; var spare: u16 = 0; for (0..n) |j| if (j != i and hs[j] -| mins[j] > spare) { spare = hs[j] - mins[j]; giver = j; }; const g = giver orelse break; hs[g] -= 1; hs[i] += 1; } } for (p.col_panes[c][0..n], 0..) |k, i| p.panes[k].?.vweight = @floatFromInt(@max(1, hs[i])); } } compute(p); } /// After placing `id`: whether it, and every pane of its column that the /// placement shrank, still has its tag and `min_body_rows` (from `before`, /// the rects as they were). A pane alone in its column always has room: the /// window can be no taller. pub fn placedRoomy(p: *Pardes, id: usize, before: *const [MAX_PANES]Rect) bool { compute(p); const f = findPane(p, id) orelse return true; if (p.col_n[f.col] == 1) return true; for (p.col_panes[f.col][0..p.col_n[f.col]]) |k| { const pane = p.panes[k] orelse continue; if (pane.collapsed) continue; if (k != id and p.rects[k].h >= before[k].h) continue; if (p.rects[k].h < minRows(p, k)) return false; } return true; } /// Places `id` last in column `c`, where acme's coladd puts a new window, /// with half the rows of the column's tallest unfolded pane, when that /// leaves both their rows; false, and `id` in no column, when not. pub fn splitTallest(p: *Pardes, c: usize, id: usize) bool { compute(p); var tall: ?usize = null; for (p.col_panes[c][0..p.col_n[c]]) |k| { if (k == id or p.panes[k].?.collapsed or ownerOf(p, k) != null) continue; if (tall == null or p.rects[k].h > p.rects[tall.?].h) tall = k; } const v = tall orelse return false; const h = p.rects[v].h; // Its tag wraps at the column's width: measured there, not at none. p.rects[id].w = p.col_w[c]; if (h < minRows(p, v) + minRows(p, id)) return false; snapColWeights(p, c); insert(p, c, p.col_n[c], id); const given = std.math.clamp(h / 2, minRows(p, id), h - minRows(p, v)); p.panes[v].?.vweight = @floatFromInt(h - given); p.panes[id].?.vweight = @floatFromInt(given); return true; } /// acme's coladd at row `y` (cols.c:66-126): the new pane goes under the /// pane that `y` falls in, which keeps its rows above `y`. /// /// `y` in a group: the new pane goes under all of it, its rows from the /// group's owner, so nothing lands between a pane and its results. fn splitAt(p: *Pardes, c: usize, id: usize, y: u16) void { const n = p.col_n[c]; var k: usize = 0; while (k + 1 < n and y >= p.rects[p.col_panes[c][k]].y + p.rects[p.col_panes[c][k]].h) k += 1; const v = groupRoot(p, p.col_panes[c][k]); const r = p.rects[v]; snapColWeights(p, c); insert(p, c, groupEnd(p, c, k), id); const pane = p.panes[id].?; // Each keeps a tag and min_body_rows, where acme's minht keeps one. const lo = r.y +| minRows(p, v); const hi = (r.y + r.h) -| minRows(p, id); const row = splitRowForExtent(r.y, r.h, if (lo <= hi) std.math.clamp(y, lo, hi) else r.y + r.h / 2) orelse { pane.vweight = BOX_H + 1; return; }; // `y` fell in an unfolded pane: acmePlace picks from those. p.panes[v].?.vweight = @floatFromInt(@max(1, row - r.y)); pane.vweight = @floatFromInt(@max(1, (r.y + r.h) - row)); } fn bodyTop(p: *const Pardes, id: usize) u16 { return p.rects[id].y + p.panes[id].?.tag_rows; } fn bodyRows(p: *const Pardes, id: usize) u16 { return p.rects[id].h -| p.panes[id].?.tag_rows; } /// The rows at the bottom of a pane's body that show nothing: acme's /// maxlines - nlines. A picture or a PDF page fills its body. fn blankRows(p: *const Pardes, id: usize) u16 { const pane = p.panes[id].?; const rows = bodyRows(p, id); const used: usize = if (pane.file) |*f| // The empty line after a final newline shows nothing. (panes.File.nlines(p.gpa, f) -| @intFromBool(std.mem.endsWith(u8, f.content, "\n"))) -| f.scroll else if (pane.isTerminal()) @as(usize, panes.terminal.gridCursor(pane).y) + 1 else rows; return rows -| @as(u16, @intCast(@min(used, rows))); } pub fn canSplitColumn(p: *Pardes, source_id: usize) bool { if (source_id >= MAX_PANES or p.panes[source_id] == null) return false; const source = findPane(p, source_id) orelse return false; return canSplitCol(p, source.col); } fn canSplitCol(p: *Pardes, col: usize) bool { if (p.ncol >= MAX_COLS or col >= p.ncol) return false; // Refresh derived widths: public layout surgery may be chained between // syncs, and a cached width must never admit a now-too-narrow split. compute(p); if (p.col_w[col] < config.MINW * 2) return false; const weight = p.col_weight[col]; if (weight >= 2 and weight % 2 == 0) return true; for (0..p.ncol) |column| if (p.col_weight[column] > std.math.maxInt(u64) / 2) return false; return weight > 0; } /// An empty column beside column `col`, with half its width: acme's Newcol /// (rowadd, rows.c:51). The new column's index, or null with no room. /// A window with no column left (Delcol took the last, as acme lets it): /// its first one, empty; null when it has columns. pub fn firstColumn(p: *Pardes) ?usize { if (p.ncol != 0) return null; p.col_weight[0] = 2; p.col_tags[0] = .{ .what = .column, .gpa = p.gpa }; p.col_serial[0] = 0; p.col_n[0] = 0; p.ncol = 1; noteColumn(p, "newcol", columnSerial(p, 0)); return 0; } pub fn insertColumn(p: *Pardes, col: usize, before: bool) ?usize { const c = insertColumnUnannounced(p, col, before) orelse return null; noteColumn(p, "newcol", columnSerial(p, c)); return c; } /// insertColumn with no serial given and no `newcol`: a column that may /// yet be taken back (Newcol's trial), which then leaves no trace. pub fn insertColumnUnannounced(p: *Pardes, col: usize, before: bool) ?usize { if (!canSplitCol(p, col)) return null; var old_weight = p.col_weight[col]; if (old_weight < 2 or old_weight % 2 != 0) { old_weight *= 2; for (0..p.ncol) |column| p.col_weight[column] *= 2; } const source_weight = old_weight / 2; p.col_weight[col] = source_weight; const c = col + @intFromBool(!before); tagline.exitHeader(p); var j = p.ncol; while (j > c) : (j -= 1) { p.col_panes[j] = p.col_panes[j - 1]; p.col_n[j] = p.col_n[j - 1]; p.col_weight[j] = p.col_weight[j - 1]; p.col_tags[j] = p.col_tags[j - 1]; p.col_serial[j] = p.col_serial[j - 1]; } p.col_weight[c] = old_weight - source_weight; p.col_tags[c] = .{ .what = .column, .gpa = p.gpa }; p.col_serial[c] = 0; p.col_n[c] = 0; p.ncol += 1; return c; } /// Pane `id` alone in a new column beside `source_id`'s; `id` may be the /// source itself when its column keeps another pane. pub fn splitColumn(p: *Pardes, source_id: usize, id: usize, before: bool) bool { if (id >= MAX_PANES or p.panes[id] == null) return false; if (!canSplitColumn(p, source_id)) return false; const source = findPane(p, source_id) orelse return false; if (id == source_id) { if (p.col_n[source.col] <= 1) return false; _ = absorbVWeight(p, id, null); removePane(p, id); } else if (findPane(p, id) != null) return false; const c = insertColumn(p, source.col, before).?; insert(p, c, 0, id); return true; } pub fn snapColWeights(p: *Pardes, c: usize) void { for (0..p.col_n[c]) |k| { const pid = p.col_panes[c][k]; if (p.panes[pid]) |pp| if (!pp.collapsed) { pp.vweight = @floatFromInt(@max(1, p.rects[pid].h)); }; } } /// Hand a closing pane's rows to `to`. With none named they go up: past any /// results listing to the nearest pane above that is not one, or to the /// pane below when the closing one is first in its column. /// Give a closing pane's rows to `to`, or to the nearest document above it /// (the pane below for the top one); the pane that got them is returned. pub fn absorbVWeight(p: *Pardes, id: usize, to: ?usize) ?usize { const f = findPane(p, id) orelse return null; if (p.col_n[f.col] <= 1) return null; snapColWeights(p, f.col); var sib = to orelse if (f.idx > 0) p.col_panes[f.col][f.idx - 1] else p.col_panes[f.col][f.idx + 1]; var k = f.idx; while (to == null and k > 0) : (k -= 1) { sib = p.col_panes[f.col][k - 1]; // nor to a pane attached to another: rows go to owners if (p.panes[sib]) |pp| if (if (pp.file) |ff| panes.Output.fileTraits(ff.output).doc else true) if (ownerOf(p, sib) == null) break; } const s = p.panes[sib] orelse return null; s.vweight += @as(f32, @floatFromInt(@max(1, p.rects[id].h))); return sib; } pub fn splitParent(p: *Pardes, want: usize) usize { const need = 2 * (BOX_H + min_body_rows); if (p.rects[want].h >= need) return want; if (findPane(p, want)) |f| for (0..p.col_n[f.col]) |k| { if (p.rects[p.col_panes[f.col][k]].h >= need) return p.col_panes[f.col][k]; }; var tallest = want; for (0..p.ncol) |c| for (0..p.col_n[c]) |k| { const pid = p.col_panes[c][k]; if (p.rects[pid].h >= need) return pid; if (p.rects[pid].h > p.rects[tallest].h) tallest = pid; }; return tallest; } pub fn splitBelow(p: *Pardes, src_id: usize, nw: *Pane) void { const src = p.panes[src_id] orelse return; const src_h = p.rects[src_id].h; // Its tag may wrap to more than one row: the rows under it are its body. const tag_h = @max(BOX_H, src.tag_rows); const body: u16 = if (src_h > tag_h) src_h - tag_h else 1; 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 // 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))); if (findPane(p, src_id)) |f| for (0..p.col_n[f.col]) |k| { const pid = p.col_panes[f.col][k]; if (p.panes[pid]) |pp| if (pp != nw and !pp.collapsed) { pp.vweight = @floatFromInt(@max(1, p.rects[pid].h)); }; }; if (!src.collapsed) src.vweight = @floatFromInt(tag_h + keep); nw.vweight = @floatFromInt(@max(1, src_h -| (tag_h + keep))); if (nw.file) |f| if (!panes.Output.fileTraits(f.output).doc) { // trimmed: every row ends in a newline, and the empty line after // the last one is not a result const want: f32 = @floatFromInt(BOX_H + @max(min_body_rows, panes.File.lineCount(std.mem.trimEnd(u8, f.content, "\n")))); if (want < nw.vweight) { src.vweight += nw.vweight - want; nw.vweight = want; } }; } // ---- Attached panes ---- // // A results pane (+Search, +Callstack, +Diff, +Errors) is ATTACHED to the // pane it answers for, its owner (Pane.attached_to). The owner and what is // attached to it, and what is attached to those (a preview under a // +Search), are a GROUP: contiguous in one column, the owner first. A group // is one place to everything else in the layout: an unrelated pane is never // put inside it (acmePlace, splitAt, splitTallest), a pane dragged onto it // lands under all of it (movePlacement), and its owner's grip, Collapse and // Del take all of it (movePane, toggleCollapse, Pardes.removePane). An // attachment's rows come from its owner and go back to it, nobody else's. /// The slot of `id`'s owner, when `id` is attached to a live pane. pub fn ownerOf(p: *const Pardes, id: usize) ?usize { const serial = (p.panes[id] orelse return null).attached_to orelse return null; for (p.panes, 0..) |slot, i| if (slot) |pane| if (pane.serial == serial and i != id) return i; return null; } /// The owner at the top of `id`'s group: `id` itself when it is attached to /// nothing. Bounded: a dump could name a ring of owners. pub fn groupRoot(p: *const Pardes, id: usize) usize { var at = id; for (0..MAX_PANES) |_| at = ownerOf(p, at) orelse return at; return at; } /// Whether `id` is `root` or attached to it through any number of owners. fn descends(p: *const Pardes, id: usize, root: usize) bool { var at = id; for (0..MAX_PANES) |_| { if (at == root) return true; at = ownerOf(p, at) orelse return false; } return false; } /// One past the last pane of the group that pane `idx` of column `c` is /// in: `idx + 1` for a pane with nothing attached. pub fn groupEnd(p: *const Pardes, c: usize, idx: usize) usize { const root = groupRoot(p, p.col_panes[c][idx]); var k = idx + 1; while (k < p.col_n[c] and descends(p, p.col_panes[c][k], root) and p.col_panes[c][k] != root) k += 1; return k; } /// The attachments kept where they are attached: one whose owner is gone, /// or that something (a 9P move, a pane split into a column of its own, an /// owner moved by a route that does not carry its group) left anywhere but /// right under its owner's group, is an ordinary pane from then on, where /// it stands. Nothing moves. Top to bottom, so a nested attachment is /// judged after the one it hangs from. pub fn keepGroups(p: *Pardes) void { for (0..p.ncol) |c| for (p.col_panes[c][0..p.col_n[c]], 0..) |id, k| { const pane = p.panes[id] orelse continue; if (pane.attached_to == null) continue; const kept = if (ownerOf(p, id)) |owner| k > 0 and descends(p, p.col_panes[c][k - 1], owner) else false; if (kept) continue; pane.attached_to = null; }; } /// Attach new pane `id`, in no column yet, to `owner`: under the owner's /// group, `rows` of the owner's rows (tag included), from the owner and /// from no other pane. The owner keeps its own minimum, else its tag (acme /// lets a window shrink to it), so the attachment may get fewer. A folded /// owner is unfolded first. The rows are the attachment's from then on: /// nothing here ever resizes it again; the seam is the user's to drag. /// False, `id` in no column, when the owner has not the rows for its tag /// and the attachment's minimum. pub fn attach(p: *Pardes, owner: usize, id: usize, rows: u16) bool { return attachFrom(p, owner, id, rows, owner); } /// attach, the rows given by `giver`: the owner itself or a pane of its /// group (a +Preview added under a query pane later takes the text's rows, /// so the query pane, typed into, keeps its own). pub fn attachFrom(p: *Pardes, owner: usize, id: usize, rows: u16, giver: usize) bool { const o = p.panes[owner] orelse return false; const g = p.panes[giver] orelse return false; const nw = p.panes[id] orelse return false; if (o.collapsed) toggleCollapse(p, owner); if (g.collapsed) toggleCollapse(p, giver); compute(p); const f = findPane(p, owner) orelse return false; if (giver != owner and groupRoot(p, owner) != groupRoot(p, giver)) return false; // Its tag wraps at the column's width: measured there. p.rects[id].w = p.col_w[f.col]; const oh = p.rects[giver].h; const least = minRows(p, id); if (oh < least + BOX_H) return false; const giver_keeps = if (oh >= least + minRows(p, giver)) minRows(p, giver) else BOX_H; const give = std.math.clamp(rows, least, oh - giver_keeps); snapColWeights(p, f.col); insert(p, f.col, groupEnd(p, f.col, f.idx), id); g.vweight = @floatFromInt(oh - give); nw.vweight = @floatFromInt(give); nw.attached_to = o.serial; compute(p); return true; } /// Collapse on an owner with attachments: the whole group folds to its /// tags, every row it gave up to the one unfolded neighbour outside it, /// and unfolds again from that neighbour, as one pane's Collapse does. /// ponytail: unfolding opens every attachment, one folded alone before /// included; remembering which were is a bit a pane. fn collapseGroup(p: *Pardes, c: usize, start: usize, end: usize) void { const root = p.panes[p.col_panes[c][start]].?; const folding = !root.collapsed; snapColWeights(p, c); const neighbor = expandedNeighbor(p, c, start, .above) orelse expandedNeighbor(p, c, end - 1, .below); var spare: u16 = if (neighbor) |other| p.rects[other].h -| BOX_H else 0; for (p.col_panes[c][start..end]) |k| { const pane = p.panes[k] orelse continue; if (folding) { if (pane.collapsed) continue; const h = p.rects[k].h; pane.vweight = @floatFromInt(@max(1, h)); pane.collapsed = true; if (neighbor) |other| p.panes[other].?.vweight += @floatFromInt(h -| BOX_H); } else { if (!pane.collapsed) continue; const wanted: u16 = @intFromFloat(@min(@as(f32, @floatFromInt(std.math.maxInt(u16))), @max(1, @round(pane.vweight)))); const give = if (neighbor != null) @min(wanted -| BOX_H, spare) else 0; spare -= give; if (neighbor) |other| p.panes[other].?.vweight -= @floatFromInt(give); pane.vweight = @floatFromInt(@max(1, BOX_H + give)); pane.collapsed = false; } } compute(p); } pub fn columnFitsHalves(p: *Pardes, source_id: usize, min_cells: u16) bool { const f = findPane(p, source_id) orelse return false; compute(p); return p.col_w[f.col] >= min_cells * 2; } pub fn panelBox(rect: Rect) Box { return .{ .x = @floatFromInt(rect.x), .y = @floatFromInt(rect.y), .w = @floatFromInt(rect.w), .h = @floatFromInt(rect.h), }; } pub fn columnBoundary(width: u16, prefix: u128, total: u128) u16 { if (total == 0) return 0; const pixels = (@as(u128, width) * prefix + total / 2) / total; return @intCast(@min(@as(u128, width), pixels)); } pub fn toggleCollapse(p: *Pardes, id: usize) void { const pane = p.panes[id] orelse return; const at = findPane(p, id) orelse return; compute(p); // An owner folds and unfolds with what is attached to it. if (ownerOf(p, id) == null) { const end = groupEnd(p, at.col, at.idx); if (end > at.idx + 1) return collapseGroup(p, at.col, at.idx, end); } const was_collapsed = pane.collapsed; const old_height = p.rects[id].h; const remembered_height = pane.vweight; // Convert only visible panes to row weights. The toggle then changes one // pair, rather than letting the column redistribute the released space. snapColWeights(p, at.col); const neighbor = expandedNeighbor(p, at.col, at.idx, .above) orelse expandedNeighbor(p, at.col, at.idx, .below); if (was_collapsed) { if (neighbor) |other| { const wanted: u16 = @intFromFloat(@min(@as(f32, @floatFromInt(std.math.maxInt(u16))), @max(1, @round(remembered_height)))); const give = @min(wanted -| old_height, p.rects[other].h -| BOX_H); p.panes[other].?.vweight -= @floatFromInt(give); pane.vweight = @floatFromInt(@max(1, old_height + give)); } pane.collapsed = false; } else { // A folded pane's weight stores its former height, including its tag, // so Dump/Restore and a later expansion retain a useful target size. pane.vweight = @floatFromInt(@max(1, old_height)); pane.collapsed = true; if (neighbor) |other| p.panes[other].?.vweight += @floatFromInt(old_height -| BOX_H); } compute(p); } /// The nearest pane on one side of `index` in its column that is not folded /// to its tag: the one Collapse lends rows to and Del k / Del j gives them /// to. A folded pane only keeps its weight for later, so rows handed to it /// would spread over the whole column instead. pub fn expandedNeighbor(p: *const Pardes, col: usize, index: usize, side: enum { above, below }) ?usize { var k = index; while (if (side == .above) k > 0 else k + 1 < p.col_n[col]) { k = if (side == .above) k - 1 else k + 1; const id = p.col_panes[col][k]; if (p.panes[id]) |pane| if (!pane.collapsed) return id; } return null; } fn computeCollapsedColumn(p: *Pardes, c: usize, x: u16, width: u16, folded: usize) void { var y: u16 = p.topBarHeight() + p.columnBarHeight(); const available = p.screen_h -| y; var expanded_left: usize = 0; var weight: f32 = 0; for (p.col_panes[c][0..p.col_n[c]]) |id| if (p.panes[id]) |pane| { if (!pane.collapsed) { expanded_left += 1; weight += pane.vweight; } }; const expanded_height = available -| @as(u16, @intCast(folded)); var budget = expanded_height; var folded_left = folded; for (p.col_panes[c][0..p.col_n[c]]) |id| { const pane = p.panes[id] orelse continue; const room = p.screen_h -| y; const height: u16 = if (pane.collapsed) blk: { folded_left -= 1; break :blk @min(room, BOX_H); } else blk: { expanded_left -= 1; const limit = @min(budget, room -| @as(u16, @intCast(folded_left))); const share = @as(f32, @floatFromInt(expanded_height)) * pane.vweight / (if (weight > 0) weight else 1); const h = if (expanded_left == 0) limit else @min(limit -| @as(u16, @intCast(expanded_left)), @max(1, @as(u16, @intFromFloat(@round(share))))); budget -|= h; break :blk h; }; p.rects[id] = .{ .x = x, .y = y, .w = width, .h = height }; y +|= height; } } pub fn compute(p: *Pardes) void { p.rects = @splat(.{}); if (p.ncol == 0) return; keepGroups(p); for (0..p.ncol) |column| _ = columnSerial(p, column); // The finder column is as wide as its share says (Finder.width), not // by weight: the others share what it leaves by theirs, so it comes // and goes and each of them keeps its proportion, none rounded off. const finder = p.finder.column(p); const finder_w: u16 = if (finder != null) p.finder.width(p) else 0; const rest = p.screen_w -| finder_w; var wsum: u128 = 0; var last_plain: usize = p.ncol; for (0..p.ncol) |c| if (finder != c) { wsum += p.col_weight[c]; last_plain = c; }; if (wsum == 0) wsum = 1; // Round cumulative boundaries so widths still sum to the available screen. var prefix: u128 = 0; var offset: u16 = 0; for (0..p.ncol) |c| { const x = offset + columnBoundary(rest, prefix, wsum); const end: u16 = if (finder == c) end: { offset = finder_w; break :end x + finder_w; } else end: { prefix += p.col_weight[c]; break :end if (c == last_plain) offset + rest else offset + columnBoundary(rest, prefix, wsum); }; const cw = end -| x; p.col_x[c] = x; p.col_w[c] = cw; var folded: usize = 0; for (p.col_panes[c][0..p.col_n[c]]) |id| if (p.panes[id]) |pane| { if (pane.collapsed) folded += 1; }; if (folded > 0) { computeCollapsedColumn(p, c, x, cw, folded); continue; } var vsum: f32 = 0; for (0..p.col_n[c]) |k| { if (p.panes[p.col_panes[c][k]]) |pane| vsum += pane.vweight; } if (vsum <= 0) vsum = 1; var y: u16 = p.topBarHeight() + p.columnBarHeight(); const top = y; const avail_h = p.screen_h -| y; var hs: [MAX_PANES]u16 = undefined; const n = p.col_n[c]; for (0..n) |k| { const id = p.col_panes[c][k]; const pane = p.panes[id] orelse { hs[k] = 0; continue; }; const lastk = k + 1 == n; const fh = @as(f32, @floatFromInt(avail_h)) * pane.vweight / vsum; const room = p.screen_h -| y; hs[k] = if (lastk) room else @min(room, @max(1, @as(u16, @intFromFloat(@round(fh))))); y +|= hs[k]; } keepTerminalFloors(p, c, hs[0..n]); y = top; for (0..n) |k| { const id = p.col_panes[c][k]; if (p.panes[id] == null) continue; p.rects[id] = .{ .x = x, .y = y, .w = cw, .h = hs[k] }; y +|= hs[k]; } } } /// The fewest rows a pane is laid out with: a terminal keeps its tag and /// `min_body_rows` (a shorter one loses its prompt and reads busy for /// ever), a text pane may shrink to its tag, as acme's windows do. fn floorRows(p: *Pardes, id: usize) u16 { const pane = p.panes[id] orelse return 0; return if (pane.isTerminal()) @max(1, pane.tag_rows) + min_body_rows else 1; } /// Raises each terminal in column `c` below its floor to it, a row at a /// time from whichever pane has the most rows above its own floor. Where /// the column has not the rows, the terminal keeps what it could get. // ponytail: a row per step, O(panes x rows); a column holds few of both. fn keepTerminalFloors(p: *Pardes, c: usize, hs: []u16) void { for (hs, 0..) |*h, k| { const floor = floorRows(p, p.col_panes[c][k]); while (h.* < floor) { var giver: ?usize = null; var spare: u16 = 0; for (hs, 0..) |other, j| { if (j == k) continue; const extra = other -| floorRows(p, p.col_panes[c][j]); if (extra > spare) { spare = extra; giver = j; } } const g = giver orelse break; hs[g] -= 1; h.* += 1; } } } test "collapse transfers height upward and restores the original layout" { const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 32 }); defer p.deinit(); _ = try p.newShell(1, ""); _ = try p.newShell(2, ""); insert(p, 0, 1, 1); insert(p, 0, 2, 2); p.panes[0].?.vweight = 3; p.panes[1].?.vweight = 2; compute(p); const original = p.rects; toggleCollapse(p, 1); try std.testing.expectEqual(@as(u16, 1), p.rects[1].h); try std.testing.expectEqual(@as(f32, @floatFromInt(original[1].h)), p.panes[1].?.vweight); try std.testing.expectEqual(p.screen_h, p.rects[2].y + p.rects[2].h); try std.testing.expect(p.rects[0].h > original[0].h); try std.testing.expectEqualDeep(original[2], p.rects[2]); toggleCollapse(p, 1); try std.testing.expectEqualDeep(original, p.rects); toggleCollapse(p, 2); try std.testing.expectEqual(@as(u16, 1), p.rects[2].h); try std.testing.expectEqual(p.screen_h, p.rects[2].y + p.rects[2].h); } test "collapse changes only one neighbor at the top middle and bottom" { for (0..4) |target| { const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 58 }); defer p.deinit(); for (1..4) |id| { _ = try p.newShell(id, ""); insert(p, 0, id, id); } for ([_]f32{ 11, 7, 5, 3 }, 0..) |weight, id| p.panes[id].?.vweight = weight; compute(p); const original = p.rects; const recipient = if (target > 0) target - 1 else 1; for (0..5) |_| { toggleCollapse(p, target); try std.testing.expectEqual(@as(u16, BOX_H), p.rects[target].h); try std.testing.expectEqual(original[recipient].h + original[target].h - BOX_H, p.rects[recipient].h); for (0..4) |id| if (id != target and id != recipient) try std.testing.expectEqualDeep(original[id], p.rects[id]); toggleCollapse(p, target); try std.testing.expectEqualDeep(original, p.rects); } } } test "collapse skips folded neighbors and expansion reclaims only its neighbor" { const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 62 }); defer p.deinit(); for (1..5) |id| { _ = try p.newShell(id, ""); insert(p, 0, id, id); } compute(p); toggleCollapse(p, 1); toggleCollapse(p, 2); const original = p.rects; toggleCollapse(p, 3); try std.testing.expectEqual(original[0].h + original[3].h - BOX_H, p.rects[0].h); try std.testing.expectEqualDeep(original[4], p.rects[4]); for (1..4) |id| try std.testing.expectEqual(@as(u16, BOX_H), p.rects[id].h); toggleCollapse(p, 3); try std.testing.expectEqualDeep(original, p.rects); // With no expanded pane above, give the space to the first one below. toggleCollapse(p, 0); const with_folded_above = p.rects; toggleCollapse(p, 3); try std.testing.expectEqual(with_folded_above[4].h + with_folded_above[3].h - BOX_H, p.rects[4].h); for (0..3) |id| try std.testing.expectEqualDeep(with_folded_above[id], p.rects[id]); toggleCollapse(p, 3); try std.testing.expectEqualDeep(with_folded_above, p.rects); } test "collapse local transfers remain bounded through repeated tiny window resizes" { const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 58 }); defer p.deinit(); for (1..5) |id| { _ = try p.newShell(id, ""); insert(p, 0, id, id); } for (0..180) |step| { p.screen_h = @intCast((step * 17) % 81); p.settings.tag_bottom = step % 3 == 0; compute(p); toggleCollapse(p, step % 5); var used: u16 = 0; for (0..5) |id| { const pane = p.panes[id].?; const rect = p.rects[id]; try std.testing.expect(std.math.isFinite(pane.vweight) and pane.vweight > 0); try std.testing.expect(rect.h <= p.screen_h -| rect.y); if (pane.collapsed) try std.testing.expect(rect.h <= BOX_H); used += rect.h; } try std.testing.expect(used <= p.screen_h); } } test "collapse expansion is limited to space available in one neighbor" { const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 42 }); defer p.deinit(); // Text panes: a terminal would keep its tag and two rows (floorRows). for (1..4) |id| { p.newScratchBelow(0); try std.testing.expectEqual(id, p.col_panes[0][id]); } compute(p); toggleCollapse(p, 2); snapColWeights(p, 0); // An intervening resize gave most of the donor's space to another pane. p.panes[0].?.vweight += p.panes[1].?.vweight - 2; p.panes[1].?.vweight = 2; compute(p); const before = p.rects; toggleCollapse(p, 2); try std.testing.expectEqual(@as(u16, 2), p.rects[2].h); try std.testing.expectEqual(@as(u16, BOX_H), p.rects[1].h); try std.testing.expectEqualDeep(before[0], p.rects[0]); try std.testing.expectEqualDeep(before[3], p.rects[3]); } test "collapse single and all panes leave unused column space" { const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 32 }); defer p.deinit(); toggleCollapse(p, 0); try std.testing.expectEqual(@as(u16, 1), p.rects[0].h); _ = try p.newShell(1, ""); insert(p, 0, 1, 1); toggleCollapse(p, 1); try std.testing.expectEqual(@as(u16, 1), p.rects[0].h); try std.testing.expectEqual(@as(u16, 1), p.rects[1].h); try std.testing.expectEqual(p.rects[0].y + 1, p.rects[1].y); try std.testing.expect(p.rects[1].y + 1 < p.screen_h); toggleCollapse(p, 0); try std.testing.expectEqual(p.screen_h - 1, p.rects[1].y); } test "collapse survives tiny resizes and TagBottom" { const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 32 }); defer p.deinit(); _ = try p.newShell(1, ""); _ = try p.newShell(2, ""); insert(p, 0, 1, 1); insert(p, 0, 2, 2); p.panes[1].?.collapsed = true; for ([_]bool{ false, true }) |bottom| { p.settings.tag_bottom = bottom; { for (0..50) |height| { p.screen_h = @intCast(height); compute(p); var used: u16 = 0; for (p.col_panes[0][0..p.col_n[0]]) |id| { const rect = p.rects[id]; try std.testing.expect(rect.h <= p.screen_h -| rect.y); used += rect.h; } try std.testing.expect(used <= p.screen_h); if (height >= 5) try std.testing.expectEqual(@as(u16, 1), p.rects[1].h); } } } p.screen_h = 32; compute(p); try std.testing.expectEqual(@as(u16, 1), p.rects[1].h); } test "collapse can be expanded by dragging its boundary" { const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 32 }); defer p.deinit(); _ = try p.newShell(1, ""); insert(p, 0, 1, 1); toggleCollapse(p, 0); applyRowSplit(p, 0, 0, p.rects[0].y + 5); compute(p); try std.testing.expect(!p.panes[0].?.collapsed); try std.testing.expectEqual(@as(u16, 6), p.rects[0].h); toggleCollapse(p, 1); p.settings.tag_bottom = true; applyRowSplit(p, 0, 0, p.rects[1].y - 5); compute(p); try std.testing.expect(!p.panes[1].?.collapsed); try std.testing.expectEqual(@as(u16, 6), p.rects[1].h); } test "collapse dump restores folded state and retained expansion weight" { const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 32 }); defer p.deinit(); p.panes[0].?.vweight = 7; compute(p); const original_height = p.rects[0].h; toggleCollapse(p, 0); try dump.dumpState(p); const restored = try dump.initFromDump(std.testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 32 }, p.dump_out.?); defer restored.deinit(); try std.testing.expect(restored.panes[0].?.collapsed); try std.testing.expectEqual(@as(f32, @floatFromInt(original_height)), restored.panes[0].?.vweight); try std.testing.expectEqual(@as(u16, 1), restored.rects[0].h); toggleCollapse(restored, 0); try std.testing.expectEqual(restored.screen_h - restored.rects[0].y, restored.rects[0].h); } test "column reorder moves only crossed state and preserves weights" { const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 173, .rows = 20 }); defer p.deinit(); p.ncol = 4; p.col_n = @splat(0); for (0..4) |c| { p.col_weight[c] = c * 13 + 7; p.col_serial[c] = @intCast(c + 10); p.col_panes[c][0] = c; p.col_tags[c].cur_col = @intCast(c + 20); } compute(p); const original_weights = p.col_weight; const outer_x = p.col_x[0]; const outer_w = p.col_w[0]; p.header_focus = true; p.header_column = 1; p.header_scroll = 9; reorderColumn(p, 1, 3); try std.testing.expectEqual(original_weights[1], p.col_weight[3]); try std.testing.expectEqual(original_weights[2], p.col_weight[1]); try std.testing.expectEqual(@as(u32, 11), p.col_serial[3]); try std.testing.expectEqual(@as(?usize, 3), p.header_column); try std.testing.expectEqual(@as(i32, 21), tagline.focusedHeader(p).?.cur_col); try std.testing.expectEqual(@as(usize, 9), p.header_scroll); try std.testing.expectEqual(outer_x, p.col_x[0]); try std.testing.expectEqual(outer_w, p.col_w[0]); reorderColumn(p, 3, 1); try std.testing.expectEqualSlices(u64, original_weights[0..4], p.col_weight[0..4]); try std.testing.expectEqual(@as(i32, 21), p.col_tags[1].cur_col); } /// A test's attachment: an empty +Search in a new slot, in no column. fn testAttachment(p: *Pardes) !usize { const free = p.freeSlot().?; _ = try panes.Output.open(p, free, "/tmp", .search, "", try p.gpa.dupe(u8, "q\n")); return free; } test "an attachment takes its rows from its owner alone, keeps them, and moves, folds and closes with it" { const exec = pardes.exec; const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 160, .rows = 48 }); defer p.deinit(); _ = try p.setTestFile("alpha one\nbeta\nalphabet\ngamma\nalpha two\ndelta\nepsilon\nzeta\n"); p.newScratchBelow(0); p.newScratchBelow(0); const other_col = p.col_panes[0][2]; try std.testing.expect(splitColumn(p, other_col, other_col, false)); const below = p.col_panes[0][1]; p.active = 0; compute(p); const before = p.rects; const unrelated = [_]usize{ below, other_col }; // Under its owner, the rows asked for, the owner's and nobody else's. const s = try testAttachment(p); try std.testing.expect(attach(p, 0, s, 9)); try std.testing.expectEqual(@as(?usize, 0), ownerOf(p, s)); try std.testing.expectEqual(s, p.col_panes[0][1]); for (unrelated) |k| try std.testing.expectEqualDeep(before[k], p.rects[k]); try std.testing.expectEqual(before[0].h, p.rects[0].h + p.rects[s].h); try std.testing.expectEqual(before[0].y, p.rects[0].y); try std.testing.expectEqual(@as(u16, 9), p.rects[s].h); // A second level (a preview under a query pane): out of the first's rows. const pv = try testAttachment(p); try std.testing.expect(attach(p, s, pv, 4)); try std.testing.expectEqual(pv, p.col_panes[0][2]); try std.testing.expectEqual(@as(usize, 0), groupRoot(p, pv)); try std.testing.expectEqual(@as(usize, 3), groupEnd(p, 0, 0)); for (unrelated) |k| try std.testing.expectEqualDeep(before[k], p.rects[k]); try std.testing.expectEqual(@as(u16, 5), p.rects[s].h); // Its text changing never resizes it: nothing here fits it to content. const sf = &p.panes[s].?.file.?; var many: [2 + 4 * 30]u8 = @splat('\n'); for (0..30) |i| @memcpy(many[2 + 4 * i ..][0..3], "row"); many[0] = 'q'; panes.File.setContent(p, sf, try p.gpa.dupe(u8, &many)); compute(p); try std.testing.expectEqual(@as(u16, 5), p.rects[s].h); // An unrelated New, from the owner or from its attachment, never lands // inside the group. exec.runBuiltin(p, .New, 0, "", null); exec.runBuiltin(p, .New, s, "", null); var at = findPane(p, 0).?; try std.testing.expectEqual(s, p.col_panes[at.col][at.idx + 1]); try std.testing.expectEqual(pv, p.col_panes[at.col][at.idx + 2]); // The seam between owner and attachment is the user's: the pair alone. compute(p); const pre_drag = p.rects; applyRowSplit(p, at.col, at.idx, p.rects[s].y - 3); compute(p); try std.testing.expectEqual(pre_drag[0].h + pre_drag[s].h, p.rects[0].h + p.rects[s].h); for (p.col_panes[at.col][0..p.col_n[at.col]]) |k| if (k != 0 and k != s) try std.testing.expectEqualDeep(pre_drag[k], p.rects[k]); // Collapse folds the group and unfolds it. compute(p); const open = p.rects; exec.runBuiltin(p, .Collapse, 0, "", null); try std.testing.expect(p.panes[0].?.collapsed and p.panes[s].?.collapsed and p.panes[pv].?.collapsed); exec.runBuiltin(p, .Collapse, 0, "", null); try std.testing.expect(!p.panes[0].?.collapsed and !p.panes[s].?.collapsed); try std.testing.expectEqual(open[0].h + open[s].h + open[pv].h, p.rects[0].h + p.rects[s].h + p.rects[pv].h); // The owner's grip dragged to the other column takes its group along. movePane(p, 0, p.col_x[1] + 4, p.rects[other_col].y + p.rects[other_col].h / 2); at = findPane(p, 0).?; try std.testing.expectEqual(@as(usize, 1), at.col); try std.testing.expectEqual(s, p.col_panes[1][at.idx + 1]); try std.testing.expectEqual(pv, p.col_panes[1][at.idx + 2]); try std.testing.expectEqual(@as(?usize, 0), ownerOf(p, s)); // Del of the preview gives its rows to its owner, the query pane. compute(p); var pair = p.rects; exec.runBuiltin(p, .Del, pv, "", null); try std.testing.expect(p.panes[pv] == null); compute(p); try std.testing.expectEqual(pair[s].h + pair[pv].h, p.rects[s].h); // Del of the attachment gives its rows back to the owner, nobody else. pair = p.rects; exec.runBuiltin(p, .Del, s, "", null); try std.testing.expect(p.panes[s] == null); compute(p); try std.testing.expectEqual(pair[0].h + pair[s].h, p.rects[0].h); for (p.col_panes[1][0..p.col_n[1]]) |k| if (k != 0) try std.testing.expectEqualDeep(pair[k], p.rects[k]); // Del of the owner closes what is attached to it. const again = try testAttachment(p); try std.testing.expect(attach(p, 0, again, 6)); exec.runBuiltin(p, .Del, 0, "", null); try std.testing.expect(p.panes[0] == null and p.panes[again] == null); } test "an attachment survives Dump and Restore, and one left away from its owner is a pane of its own" { const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 100, .rows = 40 }); defer p.deinit(); _ = try p.setTestFile("alpha\nbeta\nalphabet\n"); const s = try testAttachment(p); try std.testing.expect(attach(p, 0, s, 8)); try std.testing.expectEqual(@as(?usize, 0), ownerOf(p, s)); try dump.dumpState(p); const restored = try dump.initFromDump(std.testing.allocator, .{ .tty_only = true, .cols = 100, .rows = 40 }, p.dump_out.?); defer restored.deinit(); try std.testing.expectEqual(@as(?usize, 0), ownerOf(restored, s)); // Unattach: a pane of its own where it stands. pardes.exec.runBuiltin(p, .Unattach, s, "", null); try std.testing.expect(p.panes[s].?.attached_to == null); // Put above its owner by a route that does not carry groups: detached. const t = try testAttachment(p); try std.testing.expect(attach(p, 0, t, 8)); try std.testing.expectEqual(@as(?usize, 0), ownerOf(p, t)); removePane(p, t); insert(p, 0, 0, t); compute(p); try std.testing.expect(p.panes[t].?.attached_to == null); }