summaryrefslogtreecommitdiff
path: root/src/views.zig
diff options
context:
space:
mode:
Diffstat (limited to 'src/views.zig')
-rw-r--r--src/views.zig1048
1 files changed, 1048 insertions, 0 deletions
diff --git a/src/views.zig b/src/views.zig
new file mode 100644
index 00000000..b1786f83
--- /dev/null
+++ b/src/views.zig
@@ -0,0 +1,1048 @@
+//! Views: several clients on one session, kakoune's way (docs/next-daemon.md,
+//! "Phase 4 notes"). Each view has its own layout, focus, selections and
+//! scroll over the panes every view shares: their text, terminals, tags,
+//! registers and messages.
+//!
+//! The core still sees one view, the live one, in the fields it always had:
+//! a view's share of the session (`fields`) and of each pane (`PaneView`) is
+//! copied out when another view goes live (`park`) and back when it is live
+//! again (`unpark`). No line of the core reads a view through an
+//! indirection, and one view never parks: today's single client runs
+//! exactly as before.
+//!
+//! A parked view is in no digest (Pardes.replica's `parked`, Pane's `pv`):
+//! a slot is written whenever its view goes out, so the live view's slot is
+//! stale by design, and a parked view that diverged shows when it is live
+//! again. The pump draws the other views by going into each and back
+//! (`drawOthers`), which leaves every digested field as it was; a replica
+//! that draws nothing skips it.
+const std = @import("std");
+const pardes = @import("pardes.zig");
+const Pardes = pardes.Pardes;
+const Pane = pardes.Pane;
+const Text = pardes.panes.Text;
+const File = pardes.panes.File;
+const layout = pardes.layout;
+const MAX_PANES = pardes.MAX_PANES;
+
+/// Views at once: a window or terminal each.
+pub const max = 4;
+
+/// The session's fields that are each view's own: its screen and layout,
+/// its focus, its pointer and gestures, its jumps, its key prefixes, and
+/// what drawing it keeps (animations, the presentation of its panels).
+pub const fields = [_][:0]const u8{
+ "screen_w", "screen_h", "cell_pixels", "row_metrics",
+ "ncol", "col_weight", "col_panes", "col_n",
+ "col_tags", "col_serial", "finder", "rects",
+ "col_x", "col_w", "presentation", "active",
+ "jumps", "njumps", "jcur", "jump_force",
+ "active_column", "lifts", "lift_serials", "cursor_glide",
+ "cursor_view", "cursor_crossing", "cursor_held", "shell_continuous",
+ "input_ns", "native_images", "native_image_patches", "windowed",
+ "drag", "mouse_grab", "window_focused", "focus_told",
+ "hover_col", "hover_row", "pointer_raw_col", "pointer_raw_row",
+ "pointer_body_hit", "pointer_tag_hit", "raw_hover_intent", "pointer_inside",
+ "last_click", "click_as", "chord_hold", "wheel_guard",
+ "ctrl_w_pending", "register", "leader_on", "window_pick",
+ "leader_keys", "leader_n", "header_focus", "header_column",
+ "header_drag", "header_sweep", "header_scroll", "header_top",
+ "ov_pinch_scale", "ov_touch_scroll_delta", "chord_arg", "clip_pending",
+};
+
+/// A pane's fields that are each view's own: where it is in the view's
+/// layout, which of its texts has the keyboard, how far it is scrolled, and
+/// what the view's step measured of it (its tag's rows, its bands).
+const pane_fields = [_][:0]const u8{ "focus", "vweight", "collapsed", "attached_to", "hscroll", "tag_scroll", "tag_top", "tag_rows", "view", "notices", "pan" };
+
+/// The body's: its cursor, selections and mode. Its undo stays the pane's.
+const body_fields = [_][:0]const u8{ "mode", "cur_pinned", "cur_row", "cur_col", "msel", "vsel", "sels", "nsel", "select", "sticky_col", "restore_cursor", "last_edit", "reg_wait", "normal", "find_op", "find_ch" };
+
+pub const View = Part(Pardes, &fields);
+
+/// Named field by field, not taken from Pane's type: a pane holds its own.
+pub const PaneView = struct {
+ focus: Pane.Focus = .body,
+ vweight: f32 = 1,
+ collapsed: bool = false,
+ attached_to: ?u32 = null,
+ hscroll: i32 = 0,
+ tag_scroll: u16 = 0,
+ tag_top: u16 = 0,
+ tag_rows: u16 = 1,
+ view: Pane.SessionView = .{},
+ notices: Pane.Notices = .{},
+ pan: u16 = 0,
+ body: Part(Text, &body_fields) = .{},
+ /// A document's scroll and size; a terminal's size is its pty's, which
+ /// every view shows (sized by its last typist, `Pardes.sync`).
+ scroll: usize = 0,
+ cols: u16 = 1,
+ rows: u16 = 1,
+
+ /// In a dump (`Dumped`): what a pane's step works out again. Its `view`
+ /// is dumped: the step after `unpark` reads it before it syncs.
+ pub const replica = .{ .derived = .{ "notices", "pan" } };
+};
+
+/// A view not live: its share of the session, and the serial of each pane
+/// slot when it went out, by which the panes closed since leave its layout.
+pub const Parked = struct {
+ view: View,
+ serials: [MAX_PANES]u32 = @splat(0),
+};
+
+/// What a session's dump keeps of a view's share: all of it but what
+/// drawing keeps (Pardes.replica's local fields: its animations, its
+/// panels as presented).
+const kept = blk: {
+ @setEvalBranchQuota(100_000);
+ var names: []const [:0]const u8 = &.{};
+ for (fields) |name| {
+ const local = for (Pardes.replica.local) |l| {
+ if (std.mem.eql(u8, l, name)) break true;
+ } else false;
+ if (!local) names = names ++ &[_][:0]const u8{name};
+ }
+ const out: [names.len][:0]const u8 = names[0..names.len].*;
+ break :blk out;
+};
+
+/// A view not live as a session's dump keeps it (dump.zig): its share of
+/// the session, its slots' serials, and its share of each pane. The live
+/// view is the core's own fields; its slot is stale, and no part of it.
+pub const Dumped = struct {
+ k: u8,
+ view: Part(Pardes, &kept),
+ serials: [MAX_PANES]u32 = @splat(0),
+ panes: []const Share = &.{},
+
+ pub const Share = struct { id: u16, pv: PaneView };
+};
+
+fn bit(k: usize) u8 {
+ return @as(u8, 1) << @intCast(k);
+}
+
+/// The views not live, as a dump keeps them: the slices `gpa`'s, what
+/// they hold the session's.
+pub fn dumped(p: *const Pardes, gpa: std.mem.Allocator) ![]Dumped {
+ var out: std.ArrayList(Dumped) = .empty;
+ errdefer {
+ for (out.items) |d| gpa.free(d.panes);
+ out.deinit(gpa);
+ }
+ for (0..max) |k| {
+ if (k == p.view or !isOpen(p, @intCast(k))) continue;
+ const slot = p.parked[k] orelse continue;
+ var d: Dumped = .{ .k = @intCast(k), .view = undefined, .serials = slot.serials };
+ copy(&kept, &d.view, &slot.view);
+ var shares: std.ArrayList(Dumped.Share) = .empty;
+ errdefer shares.deinit(gpa);
+ // A view not live has a share of every pane: written when it went
+ // out, made with one made since (`installed`). `pv_known` says
+ // which shares own their selections, not which there are.
+ for (p.panes, 0..) |s, id| if (s) |pane| {
+ try shares.append(gpa, .{ .id = @intCast(id), .pv = pane.pv[k] });
+ };
+ d.panes = try shares.toOwnedSlice(gpa);
+ try out.append(gpa, d);
+ }
+ return out.toOwnedSlice(gpa);
+}
+
+/// The views a dump kept (`dumped`) parked again in `p`, a session just
+/// loaded with its live view: each its slot, each pane its share in it
+/// (one a view had none of as the live view has it). What they hold is the
+/// session's then, the slices the caller's; a failure moves nothing. A
+/// view the core says open that the dump has none of is not.
+pub fn undumped(p: *Pardes, others: []const Dumped) !void {
+ var take: u8 = 0;
+ for (others) |d| if (d.k < max and d.k != p.view and isOpen(p, d.k) and take & bit(d.k) == 0) {
+ take |= bit(d.k);
+ };
+ var made: u8 = 0;
+ errdefer for (0..max) |k| if (made & bit(k) != 0) {
+ p.gpa.destroy(p.parked[k].?);
+ p.parked[k] = null;
+ };
+ if (take != 0) for (0..max) |k| if ((take | bit(p.view)) & bit(k) != 0 and p.parked[k] == null) {
+ const slot = try p.gpa.create(Parked);
+ slot.* = .{ .view = .{ .screen_w = p.screen_w, .screen_h = p.screen_h } };
+ p.parked[k] = slot;
+ made |= bit(k);
+ };
+ // Nothing fails from here.
+ p.views_open &= take | bit(p.view);
+ p.views_away &= p.views_open;
+ // The live view's slot owning nothing, as `installed` makes it.
+ for (p.panes) |s| if (s) |pane| {
+ if (take != 0) pane.pv[p.view] = fresh(pane);
+ pane.pv_known |= bit(p.view);
+ };
+ var left = take;
+ for (others) |d| {
+ var view = d.view;
+ if (left & bit(d.k) == 0) {
+ // Refused (another build's, or twice): what it holds goes.
+ for (&view.col_tags) |*t| t.deinit(p.gpa);
+ if (view.chord_arg) |arg| p.gpa.free(arg);
+ for (d.panes) |sh| if (sh.pv.body.sels.len > 0) p.gpa.free(sh.pv.body.sels);
+ continue;
+ }
+ left &= ~bit(d.k);
+ const slot = p.parked[d.k].?;
+ slot.serials = d.serials;
+ copy(&kept, &slot.view, &view);
+ for (d.panes) |sh| {
+ const pane = (if (sh.id < MAX_PANES) p.panes[sh.id] else null) orelse {
+ if (sh.pv.body.sels.len > 0) p.gpa.free(sh.pv.body.sels);
+ continue;
+ };
+ if (pane.pv_known & bit(d.k) != 0) {
+ if (sh.pv.body.sels.len > 0) p.gpa.free(sh.pv.body.sels);
+ continue;
+ }
+ pane.pv[d.k] = sh.pv;
+ pane.pv_known |= bit(d.k);
+ }
+ for (p.panes) |s| if (s) |pane| if (pane.pv_known & bit(d.k) == 0) {
+ pane.pv[d.k] = fresh(pane);
+ pane.pv_known |= bit(d.k);
+ };
+ }
+}
+
+/// The live view alone, as view 0: every other closed. A session loaded
+/// for one client (a Restore, `-l`) is one view.
+pub fn only(p: *Pardes) void {
+ p.views_away = 0;
+ for (0..max) |k| if (k != p.view) close(p, @intCast(k));
+ emptied(p, p.view);
+ const k = p.view;
+ if (k == 0) return;
+ std.mem.swap(?*Parked, &p.parked[0], &p.parked[k]);
+ for (p.panes) |s| if (s) |pane| {
+ // The live slot is stale: as `installed` makes it, owning nothing.
+ pane.pv[0] = fresh(pane);
+ pane.pv_known = if (pane.pv_known & bit(k) != 0) 1 else 0;
+ if (pane.sized_by == k) pane.sized_by = 0;
+ if (pane.prompt_view == k) pane.prompt_view = 0;
+ };
+ p.view = 0;
+ p.views_open = 1;
+}
+
+/// The fields of `T` named, as a struct of their own, each of its type and
+/// default.
+fn Part(comptime T: type, comptime names: []const [:0]const u8) type {
+ @setEvalBranchQuota(100_000);
+ const s = @typeInfo(T).@"struct";
+ var types: [names.len]type = undefined;
+ var attrs: [names.len]std.lang.Type.Struct.FieldAttributes = undefined;
+ for (names, 0..) |name, i| {
+ const at = for (s.field_names, 0..) |n, j| {
+ if (std.mem.eql(u8, n, name)) break j;
+ } else @compileError("views: " ++ @typeName(T) ++ " has no field " ++ name);
+ types[i] = s.field_types[at];
+ attrs[i] = .{ .default_value_ptr = s.field_attrs[at].default_value_ptr };
+ }
+ return @Struct(.auto, null, names, &types, &attrs);
+}
+
+fn copy(comptime names: []const [:0]const u8, dst: anytype, src: anytype) void {
+ inline for (names) |name| @field(dst, name) = @field(src, name);
+}
+
+pub fn isOpen(p: *const Pardes, k: u8) bool {
+ return k < max and p.views_open & (@as(u8, 1) << @intCast(k)) != 0;
+}
+
+/// Kept for its client's rejoin (`away`).
+pub fn isAway(p: *const Pardes, k: u8) bool {
+ return k < max and p.views_away & (@as(u8, 1) << @intCast(k)) != 0;
+}
+
+/// The views someone looks at: open, none kept for a rejoin.
+pub fn count(p: *const Pardes) usize {
+ return @popCount(p.views_open & ~p.views_away);
+}
+
+/// An open view but `k` someone looks at (`count`), if there is one.
+fn looked(p: *const Pardes, k: u8) ?u8 {
+ for (0..max) |i| if (i != k and isOpen(p, @intCast(i)) and !isAway(p, @intCast(i))) return @intCast(i);
+ return null;
+}
+
+/// More than one view: the one test the single client's path pays.
+pub fn several(p: *const Pardes) bool {
+ return p.views_open & (p.views_open -% 1) != 0;
+}
+
+/// Pane `pane`'s share of the live view.
+fn extract(pane: *const Pane) PaneView {
+ var v: PaneView = .{ .cols = pane.cols, .rows = pane.rows };
+ copy(&pane_fields, &v, pane);
+ copy(&body_fields, &v.body, &pane.body);
+ if (pane.file) |f| v.scroll = f.scroll;
+ return v;
+}
+
+/// Its share of view `v` put back.
+fn apply(pane: *Pane, v: *const PaneView) void {
+ copy(&pane_fields, pane, v);
+ copy(&body_fields, &pane.body, &v.body);
+ if (!pane.isTerminal()) {
+ pane.cols = v.cols;
+ pane.rows = v.rows;
+ }
+ const f = if (pane.file) |*file| file else return;
+ // The text may have changed while the view was out: what it held is
+ // brought back inside it.
+ const lines = File.nlines(pane.gpa, f);
+ f.scroll = @min(v.scroll, lines -| 1);
+ if (pane.body.cur_row >= lines) {
+ pane.body.vsel.active = false;
+ pane.body.msel.active = false;
+ pane.body.nsel = 0;
+ }
+ _ = pardes.edit.clampFileCursor(&pane.body);
+}
+
+/// A copy of the live view's share for another view, owning nothing of the
+/// live one's (its extra selections stay behind).
+fn fresh(pane: *const Pane) PaneView {
+ var v = extract(pane);
+ v.body.sels = &.{};
+ v.body.nsel = 0;
+ return v;
+}
+
+/// A new pane is in each other view as it was made, there to be shown.
+pub fn installed(p: *Pardes, pane: *Pane) void {
+ pane.sized_by = p.view;
+ if (!several(p)) return;
+ // The live view's slot too, owning nothing: a pane closed before its
+ // view next parks is torn down with that slot never written, and
+ // `tornDown` frees what the slots of the views not live hold.
+ for (0..max) |k| if (isOpen(p, @intCast(k))) {
+ pane.pv[k] = fresh(pane);
+ };
+ pane.pv_known = p.views_open;
+}
+
+/// A pane going: the other views' selections of it go too.
+pub fn tornDown(p: *Pardes, pane: *Pane) void {
+ for (0..max) |k| if (k != p.view and pane.pv_known & (@as(u8, 1) << @intCast(k)) != 0) {
+ const sels = pane.pv[k].body.sels;
+ if (sels.len > 0) p.gpa.free(sels);
+ pane.pv[k].body.sels = &.{};
+ };
+}
+
+fn park(p: *Pardes) void {
+ const slot = p.parked[p.view].?;
+ copy(&fields, &slot.view, p);
+ for (p.panes, 0..) |s, id| {
+ const pane = s orelse {
+ slot.serials[id] = 0;
+ continue;
+ };
+ slot.serials[id] = pane.serial;
+ pane.pv[p.view] = extract(pane);
+ }
+}
+
+fn unpark(p: *Pardes, k: u8) void {
+ const slot = p.parked[k].?;
+ copy(&fields, p, &slot.view);
+ p.view = k;
+ for (p.panes) |s| if (s) |pane| {
+ apply(pane, &pane.pv[k]);
+ // The live body owns the selections now; the slot, stale while its
+ // view is live, holds none (a pane closed before the view parks
+ // again would otherwise free them twice).
+ pane.pv[k].body.sels = &.{};
+ pane.pv[k].body.nsel = 0;
+ };
+ // The panes closed while it was out (a slot empty or another pane's
+ // now) leave its layout, and its keyboard leaves them.
+ for (0..p.ncol) |c| {
+ var n: usize = 0;
+ for (p.col_panes[c][0..p.col_n[c]]) |id| {
+ const pane = p.panes[id] orelse continue;
+ if (pane.serial != slot.serials[id]) continue;
+ p.col_panes[c][n] = id;
+ n += 1;
+ }
+ p.col_n[c] = n;
+ }
+ if (layout.findPane(p, p.active) == null) {
+ for (0..p.ncol) |c| if (p.col_n[c] > 0) {
+ p.active = p.col_panes[c][0];
+ break;
+ };
+ }
+ layout.compute(p);
+ // Its terminals' cursors moved while it was out: each pan follows.
+ for (p.panes, 0..) |s, id| if (s) |pane| {
+ pane.pan = pardes.panes.terminal.panFor(p, pane, p.rects[id]);
+ };
+}
+
+/// The pane with the keyboard is one the live view shows: focused where its
+/// layout has it not (a Look at a file another view opened, a jump, a 9P
+/// focus), it goes into the view's active column, as kakoune shows a buffer
+/// in the window that asked for it.
+pub fn show(p: *Pardes) void {
+ if (p.panes[p.active] == null or layout.findPane(p, p.active) != null) return;
+ const c = layout.firstColumn(p) orelse layout.columnBySerial(p, p.active_column) orelse p.ncol - 1;
+ layout.acmePlace(p, c, null, p.active);
+}
+
+/// Into view `k`: the live one parked, `k`'s put in its place.
+pub fn to(p: *Pardes, k: u8) void {
+ std.debug.assert(isOpen(p, k));
+ if (k == p.view) return;
+ park(p);
+ unpark(p, k);
+ emptied(p, k);
+}
+
+/// View `k` is live: its slot, stale until it parks again (written whole
+/// then), keeps no pointer to what it handed the live fields. A rollback
+/// copy walks every slot (src/rollback.zig): one left there, freed by the
+/// live view and the memory another's since, would be saved and its old
+/// bytes put back over the other's. (A pane's share holds no pointer but
+/// its selections, which `unpark` hands over.)
+fn emptied(p: *Pardes, k: u8) void {
+ const slot = p.parked[k] orelse return;
+ slot.view = .{ .screen_w = p.screen_w, .screen_h = p.screen_h };
+ slot.view.col_tags = @splat(.{ .what = .column, .gpa = p.gpa });
+}
+
+/// A new view, as the live one is laid out and focused, with its panes
+/// where they are scrolled and its cursors where they are; the rest of it
+/// (column tags, gestures, animations) as a session starts. Null when there
+/// are `max` already.
+pub fn open(p: *Pardes) ?u8 {
+ const k: u8 = for (0..max) |i| {
+ if (!isOpen(p, @intCast(i))) break @intCast(i);
+ } else return null;
+ // Each live view parks too: its slot is made with the first other.
+ for ([_]u8{ p.view, k }) |i| if (p.parked[i] == null) {
+ const slot = p.gpa.create(Parked) catch return null;
+ slot.* = .{ .view = .{ .screen_w = p.screen_w, .screen_h = p.screen_h } };
+ p.parked[i] = slot;
+ };
+ const slot = p.parked[k].?;
+ slot.* = .{ .view = .{ .screen_w = p.screen_w, .screen_h = p.screen_h } };
+ inline for (sized ++ laid_out ++ .{ "windowed", "native_images", "native_image_patches" }) |name|
+ @field(slot.view, name) = @field(p, name);
+ slot.view.col_tags = @splat(.{ .what = .column, .gpa = p.gpa });
+ for (p.panes, 0..) |s, id| {
+ const pane = s orelse continue;
+ slot.serials[id] = pane.serial;
+ pane.pv[k] = fresh(pane);
+ pane.pv_known |= @as(u8, 1) << @intCast(k);
+ }
+ p.views_open |= @as(u8, 1) << @intCast(k);
+ return k;
+}
+
+/// How a view is laid out and focused: what a new one takes of the live
+/// one (`open`), and what one going leaves the view that stays (`closeKeeping`).
+const laid_out = .{ "ncol", "col_weight", "col_panes", "col_n", "col_serial", "finder", "active", "active_column", "jumps", "njumps", "jcur" };
+const sized = .{ "screen_w", "screen_h", "cell_pixels", "row_metrics" };
+
+/// View `k` gone, and the view that stays live laid out as `k` was: its
+/// columns, its focus, its panes where they were scrolled and its cursors
+/// where they were. For a session's last client while no one else watches
+/// it (replica.Peers.leave): the client's rejoin (an Upgrade's, a diverged
+/// one's) copies the live view (`open`), so it finds its own again.
+pub fn closeKeeping(p: *Pardes, k: u8) void {
+ if (!isOpen(p, k) or count(p) == 1) return;
+ to(p, k);
+ // Never into one kept for a rejoin (`away`): that one is its client's.
+ const other = looked(p, k).?;
+ const slot = p.parked[other].?;
+ // Its size too: the terminals it sized keep theirs, no shell redrawn for
+ // a size it is given back at the rejoin.
+ inline for (sized ++ laid_out) |name| @field(slot.view, name) = @field(p, name);
+ for (p.panes, 0..) |s, id| {
+ const pane = s orelse {
+ slot.serials[id] = 0;
+ continue;
+ };
+ if (pane.pv_known & (@as(u8, 1) << @intCast(other)) != 0 and pane.pv[other].body.sels.len > 0) p.gpa.free(pane.pv[other].body.sels);
+ slot.serials[id] = pane.serial;
+ pane.pv[other] = fresh(pane);
+ pane.pv_known |= @as(u8, 1) << @intCast(other);
+ }
+ close(p, k);
+}
+
+/// View `k` gone, and all it held; the live one moves to another first.
+/// The last view someone looks at stays: a session without a client keeps
+/// its own. One kept for a rejoin (`away`) goes whenever it is closed.
+pub fn close(p: *Pardes, k: u8) void {
+ if (!isOpen(p, k) or @popCount(p.views_open) == 1 or (!isAway(p, k) and count(p) == 1)) return;
+ if (k == p.view) {
+ const other: u8 = looked(p, k) orelse for (0..max) |i| {
+ if (i != k and isOpen(p, @intCast(i))) break @intCast(i);
+ } else unreachable;
+ park(p);
+ unpark(p, other);
+ emptied(p, other);
+ }
+ const v = &p.parked[k].?.view;
+ for (&v.col_tags) |*t| t.deinit(p.gpa);
+ if (v.chord_arg) |a| p.gpa.free(a);
+ v.presentation.deinit(p.gpa);
+ for (p.panes) |s| if (s) |pane| {
+ const sels = pane.pv[k].body.sels;
+ if (sels.len > 0) p.gpa.free(sels);
+ pane.pv[k].body.sels = &.{};
+ pane.pv_known &= ~(@as(u8, 1) << @intCast(k));
+ // A name it was drafting goes with it.
+ if (pane.prompt == .name and pane.prompt_view == k) pane.closePrompt();
+ };
+ p.views_open &= ~(@as(u8, 1) << @intCast(k));
+ p.views_away &= ~(@as(u8, 1) << @intCast(k));
+}
+
+/// View `k`'s client gone a moment, to join again for it (an Upgrade's
+/// rejoin, a divergence's): the view kept as it is, layout, focus and the
+/// panes opened in it, until its client is back (Pardes.rejoinView) or a
+/// join wants its place (Pardes.openView). Dumped with the rest, so an
+/// Upgrade's new build has it too. The live view is never one: the session
+/// goes into another someone looks at, or into a copy of this one of its own.
+pub fn away(p: *Pardes, k: u8) void {
+ if (!isOpen(p, k)) return;
+ if (k == p.view) if (looked(p, k) orelse open(p)) |other| to(p, other);
+ p.views_away |= bit(k);
+}
+
+/// The session's end: what each view not live holds.
+pub fn deinit(p: *Pardes) void {
+ for (0..max) |i| {
+ const k: u8 = @intCast(i);
+ const slot = p.parked[k] orelse continue;
+ if (k != p.view and isOpen(p, k)) {
+ const v = &slot.view;
+ for (&v.col_tags) |*t| t.deinit(p.gpa);
+ if (v.chord_arg) |a| p.gpa.free(a);
+ v.presentation.deinit(p.gpa);
+ }
+ p.gpa.destroy(slot);
+ }
+}
+
+/// What drawing a view keeps of its own (its animations, its panels as
+/// presented), kept from a frame drawn while it was out.
+const drawn_fields = [_][:0]const u8{ "presentation", "lifts", "lift_serials", "cursor_glide", "cursor_view", "cursor_crossing", "cursor_held", "shell_continuous" };
+
+/// Each view but the live one drawn and presented, the live one put back
+/// after exactly as it was: no digested field moves, so a replica that
+/// draws nothing (and skips this) stays the same. A view drawn keeps only
+/// what its drawing made (`drawn_fields`); whatever its unpark brought
+/// inside a changed text is not kept, and is done again when it is next
+/// live. Before the live one's frame: the surface after the pump is its.
+pub fn drawOthers(p: *Pardes, h: pardes.Host) !void {
+ const live = p.view;
+ const v = h.vtable;
+ park(p);
+ defer {
+ copy(&fields, p, &p.parked[live].?.view);
+ emptied(p, live);
+ p.view = live;
+ for (p.panes) |s| if (s) |pane| {
+ const pv = &pane.pv[live];
+ copy(&pane_fields, pane, pv);
+ copy(&body_fields, &pane.body, &pv.body);
+ if (!pane.isTerminal()) {
+ pane.cols = pv.cols;
+ pane.rows = pv.rows;
+ }
+ if (pane.file) |*f| f.scroll = pv.scroll;
+ };
+ }
+ for (0..max) |i| {
+ const k: u8 = @intCast(i);
+ if (k == live or !isOpen(p, k) or (p.undrawn | p.views_away) & bit(k) != 0) continue;
+ // No post_present: what a shell acknowledges there moves the
+ // session's pointer and hover, which are the live view's to move;
+ // a view's panels are acknowledged when it is live and drawn.
+ try drawParked(p, k, .{ .ctx = h.ctx, .f = v.present });
+ }
+}
+
+pub const Present = struct { ctx: ?*anyopaque, f: ?*const fn (?*anyopaque, *const pardes.Surface) void };
+
+/// Parked view `k` unparked, drawn and presented. `unpark` hands each
+/// slot's selections to its body; drawn, the view is out again, and they
+/// are the slot's again (else a frame drawn would take them from a view,
+/// and a replica that draws nothing would keep them).
+fn drawParked(p: *Pardes, k: u8, present: Present) !void {
+ try unparked(p, k, present, drawLive);
+ copy(&drawn_fields, &p.parked[k].?.view, p);
+}
+
+fn drawLive(present: Present, p: *Pardes) anyerror!void {
+ _ = p.frame_arena.reset(.{ .retain_with_limit = pardes.memory.limits.frame_kept });
+ const surface = try p.render(p.frame_arena.allocator());
+ if (present.f) |f| f(present.ctx, surface);
+}
+
+/// `f(ctx, p)` with parked view `k` unparked, its slot's selections its own
+/// again after (`drawParked`).
+fn unparked(p: *Pardes, k: u8, ctx: anytype, comptime f: fn (@TypeOf(ctx), *Pardes) anyerror!void) !void {
+ var sels: [MAX_PANES]struct { []Text.SelRange, u16 } = undefined;
+ for (p.panes, 0..) |s, id| if (s) |pane| {
+ sels[id] = .{ pane.pv[k].body.sels, pane.pv[k].body.nsel };
+ };
+ unpark(p, k);
+ defer for (p.panes, 0..) |s, id| if (s) |pane| {
+ pane.pv[k].body.sels = sels[id][0];
+ pane.pv[k].body.nsel = sels[id][1];
+ };
+ try f(ctx, p);
+}
+
+/// View `k` drawn and presented outside any step, by a replica client
+/// (src/replica.zig) whose own it is: as `drawOthers` draws one, the live
+/// view put back after exactly as it was, so the replica's digest is the
+/// authority's still. No post_present, as there.
+pub fn drawOne(p: *Pardes, k: u8, present: Present) !void {
+ if (k == p.view or !isOpen(p, k)) return drawLive(present, p);
+ const Draw = struct {
+ fn draw(pr: Present, q: *Pardes, kk: u8) anyerror!void {
+ try drawParked(q, kk, pr);
+ }
+ };
+ try withParked(p, k, present, Draw.draw);
+}
+
+/// `f(ctx, p)` with view `k` live, outside any step, and the live view put
+/// back after exactly as it was, as `drawOne` draws one: what a replica
+/// client's frontend reads of its own view (its pointer's cells, its size)
+/// while another client's input was the session's last. `f` reads only.
+pub fn within(p: *Pardes, k: u8, ctx: anytype, comptime f: fn (@TypeOf(ctx), *Pardes) anyerror!void) !void {
+ if (k == p.view or !isOpen(p, k)) return f(ctx, p);
+ const Read = struct {
+ fn read(x: @TypeOf(ctx), q: *Pardes, kk: u8) anyerror!void {
+ try unparked(q, kk, x, f);
+ }
+ };
+ try withParked(p, k, ctx, Read.read);
+}
+
+/// The live view parked, `f(ctx, p, k)`, and the live view put back after
+/// exactly as it was.
+fn withParked(p: *Pardes, k: u8, ctx: anytype, comptime f: fn (@TypeOf(ctx), *Pardes, u8) anyerror!void) !void {
+ const live = p.view;
+ park(p);
+ defer {
+ copy(&fields, p, &p.parked[live].?.view);
+ // Its slot and its panes' shares, stale while it is live, keep no
+ // pointer to what they handed back, as `unpark` leaves them: a
+ // replica's rollback copy walks them (`emptied`).
+ emptied(p, live);
+ p.view = live;
+ for (p.panes) |s| if (s) |pane| {
+ const pv = &pane.pv[live];
+ copy(&pane_fields, pane, pv);
+ copy(&body_fields, &pane.body, &pv.body);
+ if (!pane.isTerminal()) {
+ pane.cols = pv.cols;
+ pane.rows = pv.rows;
+ }
+ if (pane.file) |*file| file.scroll = pv.scroll;
+ pv.body.sels = &.{};
+ pv.body.nsel = 0;
+ };
+ }
+ try f(ctx, p, k);
+}
+
+// ---- tests ----
+
+const testing = std.testing;
+const Key = pardes.Key;
+
+fn typeKeys(p: *Pardes, text: []const u8) void {
+ for (text) |c| p.update(.{ .key = .{ .cp = c, .text = &[_]u8{c} } });
+}
+
+fn escape(p: *Pardes) void {
+ p.update(.{ .key = .{ .cp = Key.escape } });
+}
+
+fn numbered(gpa: std.mem.Allocator, n: usize) ![]u8 {
+ var out: std.ArrayList(u8) = .empty;
+ for (1..n + 1) |i| try out.print(gpa, "line {d}\n", .{i});
+ return out.toOwnedSlice(gpa);
+}
+
+/// The cursor put on `row`, as a jump puts it, and the step after.
+fn cursorTo(p: *Pardes, pane: *Pane, row: i32) void {
+ pane.body.vsel.active = false;
+ pane.body.nsel = 0;
+ pane.body.cur_row = row;
+ pane.body.cur_col = 0;
+ pane.body.cur_pinned = true;
+ pane.ensureCursorVisible();
+ p.sync();
+}
+
+test "each view has its own cursor and scroll, and an edit in one is in the other" {
+ const gpa = testing.allocator;
+ const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 80, .rows = 24 });
+ defer p.deinit();
+ const text = try numbered(gpa, 200);
+ defer gpa.free(text);
+ const pane = try p.setTestFile(text);
+ try testing.expectEqual(@as(?u8, 1), p.openView());
+ cursorTo(p, pane, 119);
+ const scrolled = pane.file.?.scroll;
+ try testing.expect(scrolled > 0);
+ // The other view is where the session was when it came.
+ p.toView(1);
+ try testing.expectEqual(@as(i32, 0), pane.body.cur_row);
+ try testing.expectEqual(@as(usize, 0), pane.file.?.scroll);
+ typeKeys(p, "ix");
+ escape(p);
+ try testing.expectEqual(Text.Mode.normal, pane.body.mode);
+ p.toView(0);
+ try testing.expectEqual(@as(i32, 119), pane.body.cur_row);
+ try testing.expectEqual(scrolled, pane.file.?.scroll);
+ try testing.expect(std.mem.startsWith(u8, pane.file.?.content, "xline 1\n"));
+ // Its mode is its own: insert here leaves the other in normal.
+ typeKeys(p, "i");
+ try testing.expectEqual(Text.Mode.insert, pane.body.mode);
+ p.toView(1);
+ try testing.expectEqual(Text.Mode.normal, pane.body.mode);
+}
+
+test "each view has its own layout and focus over the same panes" {
+ const gpa = testing.allocator;
+ const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 100, .rows = 30 });
+ defer p.deinit();
+ _ = try p.setTestFile("one\ntwo\n");
+ const k = p.openView().?;
+ const ncol = p.ncol;
+ p.toView(k);
+ p.update(.{ .command = "Newcol" });
+ p.update(.{ .command = "New" });
+ const made = p.active;
+ try testing.expect(made != 0);
+ try testing.expectEqual(ncol + 1, p.ncol);
+ p.toView(0);
+ try testing.expectEqual(ncol, p.ncol);
+ try testing.expectEqual(@as(usize, 0), p.active);
+ try testing.expect(layout.findPane(p, made) == null);
+ try testing.expectEqual(pardes.Rect{}, p.rects[made]);
+ // The pane is the session's: focused here, this view shows it too.
+ p.active = made;
+ p.sync();
+ try testing.expect(layout.findPane(p, made) != null);
+ try testing.expect(p.rects[made].h > 0);
+ // Closed here, it leaves the other view's layout, and its keyboard.
+ try p.removePane(made, null);
+ p.sync();
+ p.toView(k);
+ try testing.expect(layout.findPane(p, made) == null);
+ try testing.expect(p.panes[p.active] != null);
+ try testing.expect(layout.findPane(p, p.active) != null);
+}
+
+test "registers are the session's: yanked in one view, put in another" {
+ const gpa = testing.allocator;
+ const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 80, .rows = 24 });
+ defer p.deinit();
+ const pane = try p.setTestFile("alpha\nbeta\n");
+ const k = p.openView().?;
+ typeKeys(p, "xy");
+ p.toView(k);
+ cursorTo(p, pane, 1);
+ typeKeys(p, "p");
+ try testing.expectEqualStrings("alpha\nbeta\nalpha\n", pane.file.?.content);
+}
+
+test "a terminal shown at two sizes takes the size of the view that typed into it last" {
+ const gpa = testing.allocator;
+ const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 80, .rows = 24 });
+ defer p.deinit();
+ const term = p.panes[p.active].?;
+ try testing.expect(term.isTerminal());
+ const small = .{ term.cols, term.rows };
+ const k = p.openView().?;
+ p.toView(k);
+ p.update(.{ .resize = .{ .cols = 120, .rows = 40 } });
+ // Shown bigger here, it keeps the size of the view that typed last.
+ try testing.expect(p.rects[p.active].w > 80);
+ try testing.expectEqual(small, .{ term.cols, term.rows });
+ p.update(.{ .key = .{ .cp = Key.right } });
+ try testing.expect(term.cols > small[0] and term.rows > small[1]);
+ const big = .{ term.cols, term.rows };
+ p.toView(0);
+ p.sync();
+ try testing.expectEqual(big, .{ term.cols, term.rows });
+ p.update(.{ .key = .{ .cp = Key.right } });
+ try testing.expectEqual(small, .{ term.cols, term.rows });
+ // That view gone, the one left sizes it.
+ p.toView(k);
+ p.closeView(0);
+ try testing.expectEqual(k, p.view);
+ try testing.expectEqual(big, .{ term.cols, term.rows });
+}
+
+test "a view closing leaves the others as they were" {
+ const gpa = testing.allocator;
+ const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 100, .rows = 30 });
+ defer p.deinit();
+ const text = try numbered(gpa, 100);
+ defer gpa.free(text);
+ const pane = try p.setTestFile(text);
+ const a = p.openView().?;
+ const b = p.openView().?;
+ try testing.expectEqual(@as(usize, 3), count(p));
+ p.toView(b);
+ p.update(.{ .command = "Newcol" });
+ cursorTo(p, pane, 40);
+ typeKeys(p, "xy");
+ p.toView(a);
+ cursorTo(p, pane, 70);
+ p.toView(0);
+ cursorTo(p, pane, 10);
+ const ncol = p.ncol;
+ // The live one closing: the session goes into another.
+ p.toView(b);
+ p.closeView(b);
+ try testing.expect(p.view != b);
+ try testing.expectEqual(@as(usize, 2), count(p));
+ p.toView(a);
+ try testing.expectEqual(@as(i32, 70), pane.body.cur_row);
+ p.closeView(0);
+ try testing.expectEqual(a, p.view);
+ try testing.expectEqual(ncol, p.ncol);
+ // The last stays.
+ p.closeView(a);
+ try testing.expectEqual(@as(usize, 1), count(p));
+ try testing.expectEqual(@as(i32, 70), pane.body.cur_row);
+}
+
+test "the last client's view going leaves the session its layout, which a rejoin copies" {
+ const gpa = testing.allocator;
+ const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 100, .rows = 30 });
+ defer p.deinit();
+ const text = try numbered(gpa, 100);
+ defer gpa.free(text);
+ const pane = try p.setTestFile(text);
+ const k = p.openView().?;
+ p.toView(k);
+ p.update(.{ .resize = .{ .cols = 120, .rows = 40 } });
+ p.update(.{ .command = "Newcol" });
+ p.update(.{ .command = "New" });
+ const made = p.active;
+ const ncol = p.ncol;
+ p.active = 0;
+ p.sync();
+ cursorTo(p, pane, 60);
+ p.leaveView(k);
+ try testing.expectEqual(@as(usize, 1), count(p));
+ try testing.expectEqual(ncol, p.ncol);
+ try testing.expect(layout.findPane(p, made) != null);
+ try testing.expectEqual(@as(i32, 60), pane.body.cur_row);
+ try testing.expectEqual(@as(u16, 120), p.screen_w);
+ // Its client back (a view copied from the live one): all of it again.
+ const again = p.openView().?;
+ p.toView(again);
+ try testing.expectEqual(ncol, p.ncol);
+ try testing.expect(layout.findPane(p, made) != null);
+ try testing.expectEqual(@as(usize, 0), p.active);
+ try testing.expectEqual(@as(i32, 60), pane.body.cur_row);
+}
+
+test "a client's view kept for its rejoin: through an Upgrade's dump, each client back in its own; a join with no room lets one go" {
+ const gpa = testing.allocator;
+ const opts: pardes.Options = .{ .tty_only = true, .cols = 100, .rows = 30 };
+ const p = try Pardes.init(gpa, opts);
+ defer p.deinit();
+ _ = try p.setTestFile("one\ntwo\n");
+ // Two clients, each a pane of its own in its own view.
+ const ks: [2]u8 = .{ p.openView().?, p.openView().? };
+ var made: [2]usize = undefined;
+ for (ks, &made) |k, *m| {
+ p.toView(k);
+ p.update(.{ .command = "New" });
+ m.* = p.active;
+ }
+ // Both let go to upgrade, the live view one of theirs: theirs are kept,
+ // and the session's own is live.
+ for (ks) |k| p.awayView(k);
+ try testing.expectEqual(@as(usize, 1), count(p));
+ try testing.expect(!isAway(p, p.view));
+ // The new build loads the dump; each client is back in its own view.
+ const bytes = try pardes.dump.dumpBytes(p);
+ defer gpa.free(bytes);
+ const q = try pardes.dump.load(gpa, opts, bytes, null);
+ defer q.deinit();
+ for (ks, made, 0..) |k, m, i| {
+ try testing.expect(isAway(q, k));
+ try testing.expect(q.rejoinView(k));
+ q.toView(k);
+ try testing.expectEqual(m, q.active);
+ try testing.expect(layout.findPane(q, m) != null);
+ try testing.expect(layout.findPane(q, made[1 - i]) == null);
+ }
+ try testing.expect(!q.rejoinView(ks[0]));
+ // A client that never comes back: its view goes when a join has no room.
+ p.toView(0);
+ try testing.expectEqual(@as(?u8, 3), p.openView());
+ try testing.expectEqual(ks[0], p.openView());
+ try testing.expect(!isAway(p, ks[0]) and isAway(p, ks[1]));
+}
+
+test "drawing the other views leaves the live one as it was, to the digest" {
+ const gpa = testing.allocator;
+ const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 80, .rows = 24 });
+ defer p.deinit();
+ const text = try numbered(gpa, 100);
+ defer gpa.free(text);
+ const pane = try p.setTestFile(text);
+ const k = p.openView().?;
+ p.toView(k);
+ cursorTo(p, pane, 60);
+ typeKeys(p, "dd");
+ p.toView(0);
+ cursorTo(p, pane, 95);
+ const before = pardes.walk.digest(Pardes, p);
+ try drawOthers(p, .{});
+ try testing.expectEqual(@as(u8, 0), p.view);
+ try testing.expectEqual(before, pardes.walk.digest(Pardes, p));
+ p.toView(k);
+ try testing.expectEqual(@as(i32, 60), pane.body.cur_row);
+}
+
+test "a view drawn while another is live keeps its own cursors" {
+ const gpa = testing.allocator;
+ const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 80, .rows = 24 });
+ defer p.deinit();
+ const pane = try p.setTestFile("ab\ncd\nef\n");
+ const k = p.openView().?;
+ p.toView(k);
+ p.update(.{ .key = .{ .cp = 'C', .text = "C" } });
+ try testing.expectEqual(@as(u16, 1), pane.body.nsel);
+ p.toView(0);
+ const before = pardes.walk.digest(Pardes, p);
+ try drawOthers(p, .{});
+ try testing.expectEqual(before, pardes.walk.digest(Pardes, p));
+ p.toView(k);
+ try testing.expectEqual(@as(u16, 1), pane.body.nsel);
+}
+
+test "a view not live keeps its place in a text another view edits" {
+ const gpa = testing.allocator;
+ const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 80, .rows = 24 });
+ defer p.deinit();
+ const text = try numbered(gpa, 200);
+ defer gpa.free(text);
+ const pane = try p.setTestFile(text);
+ const k = p.openView().?;
+ p.toView(k);
+ cursorTo(p, pane, 100);
+ const scrolled = pane.file.?.scroll;
+ p.toView(0);
+ // Three lines put above it, one taken below it.
+ typeKeys(p, "xyppp");
+ cursorTo(p, pane, 150);
+ typeKeys(p, "xd");
+ p.toView(k);
+ try testing.expectEqual(@as(i32, 103), pane.body.cur_row);
+ try testing.expectEqual(scrolled + 3, pane.file.?.scroll);
+ try testing.expect(std.mem.startsWith(u8, pardes.panes.File.sourceLine(pane, 103), "line 101"));
+}
+
+test "a terminal shown in a view shorter than it keeps its cursor in sight" {
+ const gpa = testing.allocator;
+ const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 80, .rows = 20 });
+ defer p.deinit();
+ const id = p.active;
+ const term = p.panes[id].?;
+ const k = p.openView().?;
+ p.toView(k);
+ p.update(.{ .resize = .{ .cols = 100, .rows = 50 } });
+ p.update(.{ .key = .{ .cp = Key.right } });
+ const rows = term.rows;
+ try testing.expect(rows > 30);
+ var out: std.ArrayList(u8) = .empty;
+ defer out.deinit(gpa);
+ for (1..rows) |i| try out.print(gpa, "row-{d}\r\n", .{i});
+ try out.appendSlice(gpa, "LAST$ ");
+ p.update(.{ .output = .{ .pane = @intCast(id), .bytes = out.items } });
+ // Sized for the tall view, it fits there whole: nothing is passed over.
+ try testing.expectEqual(@as(u16, 0), term.pan);
+ p.toView(0);
+ p.sync();
+ try testing.expectEqual(rows, term.rows);
+ try testing.expect(term.pan > 0);
+ var arena: std.heap.ArenaAllocator = .init(gpa);
+ defer arena.deinit();
+ const s = try p.render(arena.allocator());
+ const r = p.rects[id];
+ // The cursor's row, the last, is on screen in the short view, inside
+ // the pane, and so is the line it is on.
+ const cursor = s.cursor.?;
+ try testing.expect(cursor.y >= r.y and cursor.y < r.y + r.h);
+ var row_text: std.ArrayList(u8) = .empty;
+ defer row_text.deinit(gpa);
+ for (0..s.cols) |x| try row_text.appendSlice(gpa, s.cells[@as(usize, cursor.y) * s.cols + x].grapheme());
+ try testing.expect(std.mem.indexOf(u8, row_text.items, "LAST$") != null);
+ // Back in the tall view, its top is where it was.
+ p.toView(k);
+ try testing.expectEqual(@as(u16, 0), term.pan);
+}
+
+test "a session's dump keeps its views: loaded, each where it was; revived for one client, the live one alone" {
+ const gpa = testing.allocator;
+ const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 80, .rows = 24 });
+ defer p.deinit();
+ const text = try numbered(gpa, 200);
+ defer gpa.free(text);
+ const pane = try p.setTestFile(text);
+ const id = for (p.panes, 0..) |s, i| {
+ if (s == pane) break i;
+ } else unreachable;
+ const k = p.openView().?;
+ cursorTo(p, pane, 119);
+ p.toView(k);
+ p.update(.{ .command = "Newcol" });
+ p.toView(0);
+ p.toView(k);
+ cursorTo(p, pane, 30);
+ const ncol = p.ncol;
+ const bytes = try pardes.dump.dumpBytes(p);
+ defer gpa.free(bytes);
+ const loaded = try pardes.dump.load(gpa, .{ .tty_only = true, .cols = 80, .rows = 24 }, bytes, null);
+ defer loaded.deinit();
+ try testing.expectEqual(pardes.walk.digest(Pardes, p), pardes.walk.digest(Pardes, loaded));
+ const again = try pardes.dump.dumpBytes(loaded);
+ defer gpa.free(again);
+ try testing.expectEqualSlices(u8, bytes, again);
+ const lp = loaded.panes[id].?;
+ loaded.toView(0);
+ try testing.expectEqual(@as(i32, 119), lp.body.cur_row);
+ try testing.expectEqual(ncol - 1, loaded.ncol);
+ loaded.toView(k);
+ try testing.expectEqual(@as(i32, 30), lp.body.cur_row);
+ try testing.expectEqual(ncol, loaded.ncol);
+ // For one client: the view live when dumped, as view 0.
+ const one = try pardes.dump.initFromDump(gpa, .{ .tty_only = true, .cols = 80, .rows = 24 }, bytes);
+ defer one.deinit();
+ try testing.expectEqual(@as(usize, 1), count(one));
+ try testing.expectEqual(@as(u8, 0), one.view);
+ try testing.expectEqual(ncol, one.ncol);
+ try testing.expectEqual(@as(i32, 30), one.panes[id].?.body.cur_row);
+ try testing.expectEqual(@as(?u8, 1), one.openView());
+}