//! 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 (its frame and its timings). 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", "active", "jumps", "njumps", "jcur", "jump_force", "active_column", "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", "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", "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 frame and its /// timings). 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.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) 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); 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); } p.gpa.destroy(slot); } } /// 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 /// nothing of its drawing: 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); } 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()); }