summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-07 01:02:25 -0300
committerGabriel Schneider <[email protected]>2026-11-07 01:42:27 -0300
commit6decf23fe8ac1ce6b48dac42a3502900f6e251b7 (patch)
tree5bdad28b45ca43f6494f34057e3211443ec26f50
parentf316b46caea6ecf947989114c37af8288b37dbf5 (diff)
downloadpardes-6decf23fe8ac1ce6b48dac42a3502900f6e251b7.tar.gz
pardes-6decf23fe8ac1ce6b48dac42a3502900f6e251b7.zip
follow: `Follow` (SPC c f) is Emacs's follow-mode, one text across a chain of Zerox twins shown in column order as consecutive pages (File.followChain, which syncTwins runs only for a twin group holding a chain): a scroll of any page reflows the others from it, the keyboard's page leaves its inner edges to the cursor, which goes on into the next page rather than scrolling it, the chain's ends scroll it as one pane, `Unfollow` on a follower's tag (or Del) takes a pane out, and the chain is a twin's `follow` flag with each view's `follow_scroll`, so a dump, Restore and replicas carry it; test/behaviour/follow.zig and follow.snap pin it, the reference, guide, changelog and builtins-json say it, and the builtins, leader and ttyhelp goldens list SPC c f
Co-Authored-By: Claude Fable 5.1 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNAtZenFv4weoMD3cge
-rw-r--r--docs/typ/builtins-gui.json2
-rw-r--r--docs/typ/builtins-tui.json2
-rw-r--r--docs/typ/guide.typ6
-rw-r--r--docs/typ/reference.typ24
-rw-r--r--src/CHANGELOG.md6
-rw-r--r--src/File.zig142
-rw-r--r--src/builtins.zig51
-rw-r--r--src/config.zig2
-rw-r--r--src/panes.zig12
-rw-r--r--src/views.zig3
-rw-r--r--test/behaviour.zig1
-rw-r--r--test/behaviour/follow.zig204
-rw-r--r--test/snapshots/builtins.golden8
-rw-r--r--test/snapshots/follow.golden61
-rw-r--r--test/snapshots/follow.snap20
-rw-r--r--test/snapshots/leader.golden7
-rw-r--r--test/snapshots/ttyhelp.golden12
17 files changed, 546 insertions, 17 deletions
diff --git a/docs/typ/builtins-gui.json b/docs/typ/builtins-gui.json
index 37b8e1ba..09517de3 100644
--- a/docs/typ/builtins-gui.json
+++ b/docs/typ/builtins-gui.json
@@ -37,6 +37,7 @@
{"name": "Exit", "leader": "SPC q", "also": ["topbar"], "arg": false, "scope": "root", "setting": false, "choices": null, "doc": "Quit the editor, refusing once while a pane holds unsaved text: an Exit with nothing edited since discards it."},
{"name": "Filter", "leader": null, "also": [], "arg": false, "scope": "pane", "setting": false, "choices": null, "doc": "Recolour a terminal's or a +Pager's program colours to the theme, or show them as sent, flipping between them."},
{"name": "Find", "leader": "SPC f f", "also": ["topbar"], "arg": true, "scope": "pane", "setting": false, "choices": null, "doc": "List the files below this pane's directory whose names hold its argument, in a +Search."},
+ {"name": "Follow", "leader": "SPC c f", "also": [], "arg": false, "scope": "pane", "setting": false, "choices": null, "doc": "Emacs's follow-mode: one text across a chain of panes as consecutive pages, each going on where the one before ends, scrolled as one."},
{"name": "Font", "leader": null, "also": [], "arg": true, "scope": "root", "setting": true, "choices": null, "doc": "The body font, by name or path, and its size."},
{"name": "Fonts", "leader": "SPC t f", "also": [], "arg": false, "scope": "root", "setting": false, "choices": null, "doc": "List the fonts in a pane, each a word to click."},
{"name": "Forward", "leader": "SPC j i", "also": ["C-i"], "arg": false, "scope": "root", "setting": false, "choices": null, "doc": "Ctrl-i: one step forward again, up to wherever Back started."},
@@ -101,6 +102,7 @@
{"name": "Tutor", "leader": "SPC h t", "also": ["topbar"], "arg": false, "scope": "root", "setting": false, "choices": null, "doc": "Open the tutor, a document to work through."},
{"name": "Unattach", "leader": null, "also": [], "arg": false, "scope": "pane", "setting": false, "choices": null, "doc": "Unattach a pane from the pane it answers for: it stays where it is, a pane of its own, and the next search from that pane opens another under it."},
{"name": "Undo", "leader": null, "also": [], "arg": false, "scope": "pane", "setting": false, "choices": null, "doc": "acme's Undo and Redo: step the pane's body back or forward through its edits, from a tag, a pane ctl or exec."},
+ {"name": "Unfollow", "leader": null, "also": [], "arg": false, "scope": "pane", "setting": false, "choices": null, "doc": "Take this pane out of its Follow chain: it stays, a Zerox twin with the scroll it has, and the chain closes up behind it."},
{"name": "Unmount", "leader": null, "also": [], "arg": true, "scope": "root", "setting": false, "choices": null, "doc": "Unmount the 9P tree mounted under /n/<name>."},
{"name": "Up", "leader": null, "also": [], "arg": false, "scope": "pane", "setting": false, "choices": null, "doc": "Move the keyboard to the pane above, and from a column's top pane to its tag."},
{"name": "Upgrade", "leader": "SPC s U", "also": [], "arg": false, "scope": "root", "setting": false, "choices": null, "doc": "Move this session onto the pardes installed since it started, in place: its text, undo, views, terminals with their running shells, and its terminals and windows come along."},
diff --git a/docs/typ/builtins-tui.json b/docs/typ/builtins-tui.json
index e307b3f8..edc401f6 100644
--- a/docs/typ/builtins-tui.json
+++ b/docs/typ/builtins-tui.json
@@ -36,6 +36,7 @@
{"name": "Exit", "leader": "SPC q", "also": ["topbar"], "arg": false, "scope": "root", "setting": false, "choices": null, "doc": "Quit the editor, refusing once while a pane holds unsaved text: an Exit with nothing edited since discards it."},
{"name": "Filter", "leader": null, "also": [], "arg": false, "scope": "pane", "setting": false, "choices": null, "doc": "Recolour a terminal's or a +Pager's program colours to the theme, or show them as sent, flipping between them."},
{"name": "Find", "leader": "SPC f f", "also": ["topbar"], "arg": true, "scope": "pane", "setting": false, "choices": null, "doc": "List the files below this pane's directory whose names hold its argument, in a +Search."},
+ {"name": "Follow", "leader": "SPC c f", "also": [], "arg": false, "scope": "pane", "setting": false, "choices": null, "doc": "Emacs's follow-mode: one text across a chain of panes as consecutive pages, each going on where the one before ends, scrolled as one."},
{"name": "Forward", "leader": "SPC j i", "also": ["C-i"], "arg": false, "scope": "root", "setting": false, "choices": null, "doc": "Ctrl-i: one step forward again, up to wherever Back started."},
{"name": "Get", "leader": null, "also": [], "arg": true, "scope": "pane", "setting": false, "choices": null, "doc": "acme's Get: the pane's file read again, its unsaved edits refused once as Del refuses them."},
{"name": "Grep", "leader": "SPC f g", "also": ["topbar"], "arg": true, "scope": "pane", "setting": false, "choices": null, "doc": "Find's sibling: Find matches file NAMES under this pane's directory, Grep matches the LINES of those files, on the disk engine's worker."},
@@ -95,6 +96,7 @@
{"name": "Tutor", "leader": "SPC h t", "also": ["topbar"], "arg": false, "scope": "root", "setting": false, "choices": null, "doc": "Open the tutor, a document to work through."},
{"name": "Unattach", "leader": null, "also": [], "arg": false, "scope": "pane", "setting": false, "choices": null, "doc": "Unattach a pane from the pane it answers for: it stays where it is, a pane of its own, and the next search from that pane opens another under it."},
{"name": "Undo", "leader": null, "also": [], "arg": false, "scope": "pane", "setting": false, "choices": null, "doc": "acme's Undo and Redo: step the pane's body back or forward through its edits, from a tag, a pane ctl or exec."},
+ {"name": "Unfollow", "leader": null, "also": [], "arg": false, "scope": "pane", "setting": false, "choices": null, "doc": "Take this pane out of its Follow chain: it stays, a Zerox twin with the scroll it has, and the chain closes up behind it."},
{"name": "Unmount", "leader": null, "also": [], "arg": true, "scope": "root", "setting": false, "choices": null, "doc": "Unmount the 9P tree mounted under /n/<name>."},
{"name": "Up", "leader": null, "also": [], "arg": false, "scope": "pane", "setting": false, "choices": null, "doc": "Move the keyboard to the pane above, and from a column's top pane to its tag."},
{"name": "Upgrade", "leader": "SPC s U", "also": [], "arg": false, "scope": "root", "setting": false, "choices": null, "doc": "Move this session onto the pardes installed since it started, in place: its text, undo, views, terminals with their running shells, and its terminals and windows come along."},
diff --git a/docs/typ/guide.typ b/docs/typ/guide.typ
index 2128f0cc..51f29fb8 100644
--- a/docs/typ/guide.typ
+++ b/docs/typ/guide.typ
@@ -146,6 +146,12 @@ To open beside: #word("Newcol"), then #word("Look") a file name typed in
its tag opens it there; #key("Alt-c") moves a pane into a new column.
#clip("columns", wide: true)
+A file longer than its pane can go on in the next column, as Emacs's
+follow-mode shows it: #word("Follow") (#key("SPC c f")) adds a page right of
+it, and each page starts where the one before ends; scrolling any of them, or
+moving the cursor past a page's edge, moves through all of them as one.
+#word("Unfollow") on a page's tag takes it out of the chain.
+
Closing a column's last pane leaves it empty; #word("Delcol") and
#word("Joincol") take columns away. Closing the session's last pane quits
pardes.
diff --git a/docs/typ/reference.typ b/docs/typ/reference.typ
index db090d24..7ffbd3ea 100644
--- a/docs/typ/reference.typ
+++ b/docs/typ/reference.typ
@@ -612,7 +612,8 @@ takes:
its tag; #word("Window") (#key("Ctrl-w"), #key("SPC w")) picks the pane
first: #keys("h", "j", "k", "l") move an outline, #key("Enter") or
#key("Esc") or a pane's letter focuses, #key("d") is #word("Del") and
- #key("c") #word("Collapse") on the outlined pane.
+ #key("c") #word("Collapse") on the outlined pane. #word("Follow")
+ (#key("SPC c f")) and #word("Unfollow"), below.
- `get`: reload from the file (refused once over unsaved edits, `<name>: Modified (get again to discard)`). It is an undo step, so #word("Undo") brings back what was there: the sure way back to the file on disk.
- `lock`/`unlock` (acme's). The lock binds only clients that take it and
belongs to the open that wrote it: `exec 3>$pane/ctl; echo lock >&3; ...; exec 3>&-`. A `lock` another open holds fails at once, `file in use`
@@ -629,6 +630,27 @@ A file changed on disk reloads by itself only when the buffer has no
unsaved edits; otherwise it stays dirty, says `<name> changed on disk (get reloads it, Save overwrites it)`, logs `changed <serial>`, and its next
#word("Save") warns once. A file whose disk text is what the pane was read or saved as is no change: an #word("Undo") back across #word("Get") `file` or `e` to unsaved edits says nothing changed, and #word("Save") writes it.
+== Follow <follow>
+
+#word("Follow") (#key("SPC c f")) is Emacs's follow-mode: one text across a
+chain of panes as consecutive pages. On a file pane it adds a page, a
+#word("Zerox") twin, at the end of the column right of the chain's last
+page, or alone in a new column there when there is none; the keyboard stays
+where it was. #word("Follow") on any page adds one after the last; on a twin
+outside the chain it is refused (`Follow: this text has a chain: Follow on
+one of its panes`). The pages, in column order, each start on the line after
+the one before ends (a line wrapped on past a page's bottom starts the next
+again), and scroll as one: the wheel, a page key, a jump or a #word("Look")
+in any page moves the others with it. Each page keeps its own cursor; one
+moved past its page's last row (or above its first) takes the keyboard to
+the page showing its line, scrolling nothing, and past the chain's ends the
+chain scrolls as one pane would. A page the chain made has #word("Unfollow")
+on its tag: it takes the pane out, a plain twin with the scroll it has, and
+the chain closes up. #word("Del") of a page leaves the chain too; the first
+page left is the head, whose tag has no #word("Unfollow"), and a chain of
+one is none. The chain is kept across #word("Dump") and #word("Restore");
+each window or terminal on the session scrolls its own.
+
== Addresses and data <addresses>
#file("addr"), #file("dot") and #file("limit") read the pair of byte
diff --git a/src/CHANGELOG.md b/src/CHANGELOG.md
index 8bb5216c..2dca1ac0 100644
--- a/src/CHANGELOG.md
+++ b/src/CHANGELOG.md
@@ -2,6 +2,12 @@
## Unreleased
+- `Follow` (`SPC c f`), Emacs's follow-mode: one text across a chain of
+ panes as consecutive pages, each a Zerox twin in the column to the right
+ (a new column when there is none). The pages scroll as one, and the
+ cursor moved past a page's edge goes on in the next. `Unfollow` on a
+ follower's tag takes it out; the chain is kept in a Dump.
+
- A theme may give the tagline (the workspace row) colours of its own,
`tagline_bg` and `tagline_fg`, an editor's status bar; dark_plus has VS
Code's blue. Without them the row keeps the tag's colours, as before.
diff --git a/src/File.zig b/src/File.zig
index 1e553bc9..e387abab 100644
--- a/src/File.zig
+++ b/src/File.zig
@@ -200,6 +200,9 @@ pub const State = struct {
/// and (while it is the one index) `line_starts`, each with its own
/// scroll, cursor and syntax; 0, none. See `zerox`.
twin: u32 = 0,
+ /// In its twin group's Follow chain (builtins.Follow), whose panes
+ /// show the text as consecutive pages (followChain).
+ follow: bool = false,
};
pub const NodeStep = struct { ranges: []modal.Selection, primary: usize };
@@ -1020,7 +1023,10 @@ fn edit(p: *Pardes, f: *State, off: usize, len: usize, bytes_in: []const u8, who
const cursor = positionIn(p.gpa, tf, moved[i].cursor);
t.body.cur_row = @intCast(cursor.row);
t.body.cur_col = @intCast(cursor.col);
+ const was = tf.scroll;
tf.scroll = positionIn(p.gpa, tf, moved[i].scroll).row;
+ // Moved by the edit, not scrolled: a Follow chain reflows from its head.
+ t.follow_scroll +%= tf.scroll -% was;
}
return true;
}
@@ -1094,7 +1100,9 @@ const ParkedPlaces = struct {
v.body.cur_col = @intCast(cursor.col);
v.body.vsel.active = false;
v.body.nsel = 0;
+ const was = v.scroll;
v.scroll = positionIn(p.gpa, tf, @min(a.scroll, tf.content.len)).row;
+ v.follow_scroll +%= v.scroll -% was;
}
}
};
@@ -1232,6 +1240,7 @@ pub fn leaveTwins(p: *Pardes, f: *State) void {
f.history = History.create(p.gpa) catch f.history;
// The one left is no twin now (syncTwins drops the group).
if (n == 1) p.panes[twins[0]].?.file.?.twin = 0;
+ if (n == 1) unchain(p.panes[twins[0]].?);
}
pub const TwinGroup = struct {
@@ -1265,6 +1274,7 @@ pub fn syncTwins(p: *Pardes) void {
}
if (n < 2) {
if (n == 1) members[0].twin = 0;
+ if (n == 1) unchain(member_panes[0]);
p.gpa.free(group.path);
_ = p.twin_groups.swapRemove(g);
continue;
@@ -1305,10 +1315,142 @@ pub fn syncTwins(p: *Pardes) void {
std.debug.assert(other.content.ptr == members[0].content.ptr and other.content.len == members[0].content.len);
std.debug.assert(other.revision == members[0].revision);
};
+ // Only a group with a chain pays for one.
+ for (members[0..n]) |f| if (f.follow) {
+ followChain(p, group.id);
+ break;
+ };
g += 1;
}
}
+/// Follow's chain in twin group `twin`, as the live view lays it out: its
+/// panes in column order show the text as consecutive pages, each starting
+/// on the line after the one before ends. A pane scrolled (by anything:
+/// the wheel, a page key, a jump, the cursor past a chain's end) moves the
+/// others with it; the cursor going past a page's edge takes the keyboard
+/// to the page that shows its line (ensureCursorVisible leaves the
+/// keyboard's page's inner edges alone, `follow_edges`). A chain of one is
+/// no chain.
+fn followChain(p: *Pardes, twin: u32) void {
+ const v = p.view();
+ var chain: [pardes.MAX_PANES]*Pane = undefined;
+ var ids: [pardes.MAX_PANES]usize = undefined;
+ var n: usize = 0;
+ for (v.cols[0..v.ncol]) |col| for (col.panes[0..col.n]) |id| {
+ const pane = p.panes[id] orelse continue;
+ const f = if (pane.file) |*file| file else continue;
+ if (f.twin != twin or !f.follow) continue;
+ chain[n] = pane;
+ ids[n] = id;
+ n += 1;
+ };
+ if (n < 2) {
+ for (chain[0..n]) |pane| unchain(pane);
+ return;
+ }
+ // The head is the text's first page, never a follower of another.
+ dropUnfollow(chain[0]);
+ // The cursor moved past its page's edge: the keyboard goes to the page
+ // showing its line, else to the chain's end, which scrolls to it.
+ const active = for (ids[0..n], 0..) |id, k| {
+ if (id == v.active) break k;
+ } else null;
+ if (active) |k| if (v.header == null and chain[k].focus == .body) hop: {
+ const m = chain[k];
+ const row: usize = @intCast(@max(0, m.body.cur_row));
+ if (m.follow_crossed and (row < m.file.?.scroll or row >= pageEnd(m))) {
+ const j = for (chain[0..n], 0..) |o, i| {
+ if (row >= o.file.?.scroll and row < pageEnd(o)) break i;
+ } else if (row < m.file.?.scroll) 0 else n - 1;
+ if (j == k) break :hop;
+ const to = chain[j];
+ to.body.cur_row = m.body.cur_row;
+ to.body.cur_col = m.body.cur_col;
+ to.body.cur_pinned = true;
+ to.body.vsel.active = false;
+ to.body.nsel = 0;
+ to.body.mode = m.body.mode;
+ m.body.mode = .normal;
+ v.active = ids[j];
+ to.follow_edges = @as(u2, @intFromBool(j > 0)) | @as(u2, @intFromBool(j + 1 < n)) << 1;
+ to.ensureCursorVisible();
+ }
+ };
+ // The page that moved (the keyboard's first), else the head, sets the
+ // others: back to the head, then on from it.
+ var anchor: usize = 0;
+ for (chain[0..n], 0..) |o, k| if (o.file.?.scroll != o.follow_scroll) {
+ anchor = k;
+ if (ids[k] == v.active) break;
+ };
+ var k = anchor;
+ while (k > 0) : (k -= 1) {
+ const prev = chain[k - 1];
+ const want = chain[k].file.?.scroll;
+ // The furthest scroll whose page ends at `want` or before.
+ var s = want -| prev.rows;
+ setPageScroll(prev, s);
+ while (s < want) : (s += 1) {
+ setPageScroll(prev, s + 1);
+ if (pageEnd(prev) <= want) continue;
+ setPageScroll(prev, s);
+ break;
+ }
+ }
+ for (chain[1..n], 0..) |o, i| setPageScroll(o, pageEnd(chain[i]));
+ // Only the keyboard's page crosses its edges: a dot written to another
+ // scrolls it there, and the chain with it.
+ for (chain[0..n], ids[0..n], 0..) |o, id, i| {
+ o.follow_scroll = o.file.?.scroll;
+ o.follow_crossed = false;
+ o.follow_edges = if (id != v.active) 0 else @as(u2, @intFromBool(i > 0)) | @as(u2, @intFromBool(i + 1 < n)) << 1;
+ }
+}
+
+/// The line a page after `pane`'s starts on: the one after its last row's,
+/// or that line again when the pane wraps it on past its bottom.
+fn pageEnd(pane: *Pane) usize {
+ const f = &pane.file.?;
+ if (pane.collapsed) return f.scroll;
+ geometry(pane);
+ if (pane.wrap_n == 0) return f.scroll + pane.rows;
+ const last = (if (pane.body_visible_rows > 0) @min(pane.wrap_n, pane.body_visible_rows) else pane.wrap_n) - 1;
+ const line: usize = @intCast(pane.wrap_line[last]);
+ if (!pane.body_wrapped or line >= nlines(pane.gpa, f)) return line + 1;
+ const text = sourceLine(pane, @intCast(line));
+ const width = wrapWidth(pane, pane.view.wrap) -| pane.wrap_pad[last];
+ return if (fitEnd(text, @intCast(pane.wrap_col[last]), width) < text.len) @max(line, f.scroll + 1) else line + 1;
+}
+
+fn setPageScroll(pane: *Pane, line: usize) void {
+ const f = &pane.file.?;
+ const to = @min(line, nlines(pane.gpa, f) -| 1);
+ if (to == f.scroll) return;
+ f.scroll = to;
+ f.syntax_dirty = true;
+}
+
+/// `pane` out of its Follow chain (Unfollow, or a chain down to it): a
+/// plain twin with the scroll it has.
+pub fn unchain(pane: *Pane) void {
+ pane.file.?.follow = false;
+ pane.follow_edges = 0;
+ pane.follow_crossed = false;
+ dropUnfollow(pane);
+}
+
+/// The Unfollow word Follow gave a pane's tag (builtins.Follow), gone.
+fn dropUnfollow(pane: *Pane) void {
+ const own = pane.tag.own orelse return;
+ const at = std.mem.indexOf(u8, own, " Unfollow") orelse return;
+ const end = at + " Unfollow".len;
+ if (end < own.len and std.mem.indexOfScalar(u8, " \t\n", own[end]) == null) return;
+ const cut = std.mem.concat(pane.gpa, u8, &.{ own[0..at], own[end..] }) catch return;
+ pane.gpa.free(own);
+ pane.tag.own = cut;
+}
+
/// Whether `head`, a text's first bytes, holds a diff, as a command pane's
/// rows are told one (diff.looksLikeDiff, its first 200 lines).
pub fn looksLikeDiff(head: []const u8) bool {
diff --git a/src/builtins.zig b/src/builtins.zig
index 15319d6e..c41b3e1b 100644
--- a/src/builtins.zig
+++ b/src/builtins.zig
@@ -1785,6 +1785,57 @@ pub const Right = struct {
}
};
+/// Emacs's follow-mode: one text across a chain of panes as consecutive
+/// pages, each going on where the one before ends, scrolled as one. Adds a
+/// page, a Zerox twin, at the end of the column right of the chain's last,
+/// or in a new column there; its tag has Unfollow.
+pub const Follow = struct {
+ pub fn run(c: Ctx) void {
+ if (@import("edit_cmd.zig").busyOn(c.p, c.id)) return c.p.reportFailure(c.id, "Follow: " ++ @import("edit_cmd.zig").e_busy);
+ const f = if (c.pane.file) |*file| file else return c.p.reportFailure(c.id, "Follow: only a file pane takes it");
+ if (f.output != null or f.listing != null or f.mini != null) return c.p.reportFailure(c.id, "Follow: only a file pane takes it");
+ // One chain a text: the new page goes after its last, in column order.
+ const v = c.p.view();
+ var last = c.id;
+ for (v.cols[0..v.ncol]) |col| for (col.panes[0..col.n]) |id| {
+ const other = if (c.p.panes[id].?.file) |*file| file else continue;
+ if (f.twin != 0 and other.twin == f.twin and other.follow) last = id;
+ };
+ if (!f.follow and last != c.id) return c.p.reportFailure(c.id, "Follow: this text has a chain: Follow on one of its panes");
+ const col = (layout.findPane(c.p, last) orelse return c.p.reportFailure(c.id, "Follow: the pane is not laid out")).col;
+ const free = c.p.freeSlot() orelse return c.p.reportError(c.id, "Follow", error.NoPaneSlots);
+ const made = panes.File.zerox(c.p, c.id, free) catch |err| return c.p.reportError(c.id, "Follow", err);
+ const keep = v.active;
+ if (col + 1 < v.ncol) {
+ c.p.exec_column = col + 1;
+ defer c.p.exec_column = null;
+ exec.placeNew(c.p, c.id, null, free, .scratch);
+ if (c.p.unplaced.isSet(free)) return;
+ } else if (!layout.splitColumn(c.p, last, free, false)) {
+ c.p.unplaced.set(free);
+ return c.p.reportFailure(c.id, "Follow: no space for a column: this one is too narrow to split");
+ }
+ // The keyboard stays on the page it was on.
+ v.active = keep;
+ if (layout.findPane(c.p, keep)) |at| c.p.setActiveColumn(at.col);
+ f.follow = true;
+ made.file.?.follow = true;
+ c.pane.follow_scroll = f.scroll;
+ made.follow_scroll = made.file.?.scroll;
+ made.appendTag(" Unfollow") catch |err| c.p.reportError(c.id, "Follow", err);
+ }
+};
+
+/// Take this pane out of its Follow chain: it stays, a Zerox twin with the
+/// scroll it has, and the chain closes up behind it.
+pub const Unfollow = struct {
+ pub fn run(c: Ctx) void {
+ const f = if (c.pane.file) |*file| file else return c.p.reportFailure(c.id, "Unfollow: this pane is in no Follow chain");
+ if (!f.follow) return c.p.reportFailure(c.id, "Unfollow: this pane is in no Follow chain");
+ panes.File.unchain(c.pane);
+ }
+};
+
/// Window mode: h/j/k/l move an outline between the panes; Enter or Esc
/// focuses the outlined pane, `:` its tag, the letter shown on a pane that one; d is Del on it (then k or j between two), c Collapse.
pub const Window = struct {
diff --git a/src/config.zig b/src/config.zig
index ee7d76f7..3f9403a8 100644
--- a/src/config.zig
+++ b/src/config.zig
@@ -135,6 +135,8 @@ pub const leader_path = paths: {
.Up = null,
.Right = null,
.Window = "w",
+ .Follow = "cf",
+ .Unfollow = null,
.Back = "jo",
.Forward = "ji",
.Last = "jj",
diff --git a/src/panes.zig b/src/panes.zig
index a90613d0..6b6f621a 100644
--- a/src/panes.zig
+++ b/src/panes.zig
@@ -260,6 +260,13 @@ pub const Pane = struct {
tag_lead: usize = 0,
cwd: Cwd = .none,
hscroll: i32 = 0,
+ /// A Follow chain's page (File.followChain): the scroll the chain last
+ /// gave it, each view's; on the keyboard's page, whether a page comes
+ /// before (1) and after (2), whose edge the cursor crosses rather than
+ /// scrolling, and whether it crossed one this step.
+ follow_scroll: usize = 0,
+ follow_edges: u2 = 0,
+ follow_crossed: bool = false,
// Visible rows map to source lines and raw/display column origins.
wrap_line: [limits.wrap_rows]i32 = undefined,
wrap_col: [limits.wrap_rows]i32 = undefined,
@@ -624,9 +631,10 @@ pub const Pane = struct {
margin = @min(margin, @divTrunc(@max(0, lines_shown), 2));
}
if (!in_context) {
+ if (pane.follow_edges != 0 and (pane.body.cur_row < off or pane.body.cur_row > last)) pane.follow_crossed = true;
if (pane.body.cur_row < off + margin) {
- pane.scrollBy(pane.body.cur_row - margin - off);
- } else if (pane.body.cur_row > last - margin) {
+ if (pane.follow_edges & 1 == 0) pane.scrollBy(pane.body.cur_row - margin - off);
+ } else if (pane.body.cur_row > last - margin and pane.follow_edges & 2 == 0) {
var to = pane.body.cur_row + margin;
if (pane.file) |*f| {
// The margin only reveals text: a pane its whole text
diff --git a/src/views.zig b/src/views.zig
index 354ae0d0..953b39a4 100644
--- a/src/views.zig
+++ b/src/views.zig
@@ -33,7 +33,7 @@ pub const max = 4;
/// 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" };
+const pane_fields = [_][:0]const u8{ "focus", "vweight", "collapsed", "attached_to", "hscroll", "tag_scroll", "tag_top", "tag_rows", "view", "notices", "pan", "follow_scroll" };
/// 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" };
@@ -51,6 +51,7 @@ pub const PaneView = struct {
view: Pane.SessionView = .{},
notices: Pane.Notices = .{},
pan: u16 = 0,
+ follow_scroll: usize = 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`).
diff --git a/test/behaviour.zig b/test/behaviour.zig
index de0cb83c..5b31b6d9 100644
--- a/test/behaviour.zig
+++ b/test/behaviour.zig
@@ -12,6 +12,7 @@ test {
_ = @import("behaviour/edit.zig");
_ = @import("behaviour/event.zig");
_ = @import("behaviour/flags.zig");
+ _ = @import("behaviour/follow.zig");
_ = @import("behaviour/from_acme.zig");
_ = @import("behaviour/keys.zig");
_ = @import("behaviour/language_servers.zig");
diff --git a/test/behaviour/follow.zig b/test/behaviour/follow.zig
new file mode 100644
index 00000000..5f2acb02
--- /dev/null
+++ b/test/behaviour/follow.zig
@@ -0,0 +1,204 @@
+//! docs/typ/reference.typ, Follow <follow>.
+const std = @import("std");
+const Session = @import("session").Session;
+
+fn has(hay: []const u8, needle: []const u8) bool {
+ return std.mem.indexOf(u8, hay, needle) != null;
+}
+
+/// A session on a 300-line file, `L001` to `L300`, in a window wide enough
+/// for three columns' tags on one row each.
+fn init() !Session {
+ var text: [300 * 5]u8 = undefined;
+ for (0..300) |i| _ = try std.fmt.bufPrint(text[i * 5 ..][0..5], "L{d:0>3}\n", .{i + 1});
+ var s = try Session.initFile(std.testing.allocator, &text);
+ s.detach();
+ try s.write("/ctl", "size 200 30\n");
+ return s;
+}
+
+const Page = struct { x: usize, first: usize, last: usize, rows: usize };
+
+/// Each pane's lines as /screen draws them, left to right: the labels
+/// drawn at one column of cells are one pane's.
+fn pages(s: *Session) ![]Page {
+ var out: std.ArrayList(Page) = .empty;
+ var rows = std.mem.splitScalar(u8, try s.screen(), '\n');
+ while (rows.next()) |row| {
+ var i: usize = 0;
+ while (std.mem.indexOfScalarPos(u8, row, i, 'L')) |at| : (i = at + 1) {
+ if (at + 4 > row.len) break;
+ const n = std.fmt.parseInt(usize, row[at + 1 .. at + 4], 10) catch continue;
+ const x = try std.unicode.utf8CountCodepoints(row[0..at]);
+ for (out.items) |*p| {
+ if (p.x != x) continue;
+ p.first = @min(p.first, n);
+ p.last = @max(p.last, n);
+ p.rows += 1;
+ break;
+ } else try out.append(s.arena.allocator(), .{ .x = x, .first = n, .last = n, .rows = 1 });
+ }
+ }
+ std.mem.sort(Page, out.items, {}, struct {
+ fn lt(_: void, a: Page, b: Page) bool {
+ return a.x < b.x;
+ }
+ }.lt);
+ return out.items;
+}
+
+/// The pages go on one from another: each starts the line after the one
+/// before it ends, every line drawn once.
+fn expectConsecutive(ps: []const Page) !void {
+ for (ps) |p| try std.testing.expectEqual(p.last - p.first + 1, p.rows);
+ for (ps[1..], ps[0 .. ps.len - 1]) |p, before| try std.testing.expectEqual(before.last + 1, p.first);
+}
+
+/// The pane the last Follow made: the newest serial in the index.
+fn newest(s: *Session) !u32 {
+ var max: u32 = 0;
+ var lines = std.mem.tokenizeScalar(u8, try s.read("/index"), '\n');
+ while (lines.next()) |l| max = @max(max, try std.fmt.parseInt(u32, std.mem.sliceTo(l, ' '), 10));
+ return max;
+}
+
+/// The first line of the cursor's selection, 0-based (a label is 5 bytes).
+fn line(s: *Session, pane: u32) !usize {
+ return (try s.range(s.at("/pane/{d}/dot", .{pane})))[0] / 5;
+}
+
+test "follow: Follow puts the next page right of the chain, in a new column or at the end of the one there, Unfollow on its tag alone" {
+ var s = try init();
+ defer s.deinit();
+ const head = try s.focused();
+ try s.write(s.at("/pane/{d}/exec", .{head}), "Follow\n");
+ const second = try newest(&s);
+ // No column to the right: a new one; the keyboard stays on the head.
+ try std.testing.expectEqualStrings(s.at("{d}:{d} {d}:{d}", .{ try s.column(0), head, try s.column(1), second }), try s.columns());
+ try std.testing.expectEqual(head, try s.focused());
+ try std.testing.expect(has(try s.read(s.at("/pane/{d}/tag", .{second})), " Unfollow"));
+ try std.testing.expect(!has(try s.read(s.at("/pane/{d}/tag", .{head})), "Unfollow"));
+ try expectConsecutive(try pages(&s));
+ // A column right of the last page: the next goes at its end, from
+ // any page of the chain.
+ try s.write(s.at("/pane/{d}/exec", .{second}), "Newcol\n");
+ const other = try s.newPane();
+ try s.write(s.at("/pane/{d}/exec", .{head}), "Follow\n");
+ const third = try newest(&s);
+ try std.testing.expect(has(try s.columns(), s.at(":{d},{d}", .{ other, third })));
+ // A twin out of the chain is refused one of its own.
+ try s.write(s.at("/pane/{d}/exec", .{head}), "Zerox\n");
+ try std.testing.expect(try s.refused(s.at("/pane/{d}/exec", .{try newest(&s)}), "Follow\n") != 0);
+ try std.testing.expect(has(s.said, "Follow: this text has a chain"));
+}
+
+test "follow: two and three pages show consecutive lines; the wheel in any page moves them all" {
+ var s = try init();
+ defer s.deinit();
+ const head = try s.focused();
+ try s.write(s.at("/pane/{d}/exec", .{head}), "Follow\n");
+ var ps = try pages(&s);
+ try std.testing.expectEqual(@as(usize, 2), ps.len);
+ try std.testing.expectEqual(@as(usize, 1), ps[0].first);
+ try expectConsecutive(ps);
+ try s.write(s.at("/pane/{d}/exec", .{head}), "Follow\n");
+ ps = try pages(&s);
+ try std.testing.expectEqual(@as(usize, 3), ps.len);
+ try expectConsecutive(ps);
+ // Three notches down in the second page: the first follows.
+ for (0..3) |_| try s.write("/mousein", s.at("m {d} 10 16\nm {d} 10 0\n", .{ ps[1].x + 2, ps[1].x + 2 }));
+ const scrolled = try pages(&s);
+ try std.testing.expectEqual(@as(usize, 4), scrolled[0].first);
+ try expectConsecutive(scrolled);
+ // And up again in the last.
+ for (0..3) |_| try s.write("/mousein", s.at("m {d} 10 8\nm {d} 10 0\n", .{ ps[2].x + 2, ps[2].x + 2 }));
+ try std.testing.expectEqual(@as(usize, 1), (try pages(&s))[0].first);
+ try expectConsecutive(try pages(&s));
+}
+
+test "follow: the cursor past a page's last row takes the keyboard to the next page, and back above its first" {
+ var s = try init();
+ defer s.deinit();
+ const head = try s.focused();
+ try s.write(s.at("/pane/{d}/exec", .{head}), "Follow\n");
+ const second = try newest(&s);
+ const ps = try pages(&s);
+ const rows = ps[0].rows;
+ try s.keys(s.at("{d}j", .{rows - 1}));
+ try std.testing.expectEqual(head, try s.focused());
+ try std.testing.expectEqual(rows - 1, try line(&s, head));
+ try s.keys("j");
+ try std.testing.expectEqual(second, try s.focused());
+ try std.testing.expectEqual(rows, try line(&s, second));
+ // Nothing scrolled: the pages are where they were.
+ try std.testing.expectEqualSlices(Page, ps, try pages(&s));
+ try s.keys("k");
+ try std.testing.expectEqual(head, try s.focused());
+ try std.testing.expectEqual(rows - 1, try line(&s, head));
+ // Past the chain's end the chain scrolls as one pane.
+ try s.keys(s.at("{d}j", .{2 * rows + 2}));
+ try std.testing.expectEqual(second, try s.focused());
+ const moved = try pages(&s);
+ try std.testing.expect(moved[0].first > 1);
+ try expectConsecutive(moved);
+ // A dot written to the other page scrolls it there, the chain with it.
+ try s.write(s.at("/pane/{d}/dot", .{head}), "745 745");
+ const shown = try pages(&s);
+ try std.testing.expect(shown[0].first <= 150 and 150 <= shown[0].last);
+ try expectConsecutive(shown);
+}
+
+test "follow: Unfollow leaves a twin with its own scroll and closes the chain up; Del of the head makes the next one head" {
+ var s = try init();
+ defer s.deinit();
+ const head = try s.focused();
+ try s.write(s.at("/pane/{d}/exec", .{head}), "Follow\n");
+ const second = try newest(&s);
+ try s.write(s.at("/pane/{d}/exec", .{head}), "Follow\n");
+ const third = try newest(&s);
+ const was = try pages(&s);
+ try s.write(s.at("/pane/{d}/exec", .{second}), "Unfollow\n");
+ try std.testing.expect(!has(try s.read(s.at("/pane/{d}/tag", .{second})), "Unfollow"));
+ var ps = try pages(&s);
+ // The twin keeps its lines; the third follows the head now.
+ try std.testing.expectEqual(was[1], ps[1]);
+ try std.testing.expectEqual(was[0].last + 1, ps[2].first);
+ // A wheel in the twin moves it alone, as Zerox's does.
+ try s.write("/mousein", s.at("m {d} 10 16\nm {d} 10 0\n", .{ ps[1].x + 2, ps[1].x + 2 }));
+ const after = try pages(&s);
+ try std.testing.expectEqual(ps[0], after[0]);
+ try std.testing.expectEqual(ps[2], after[2]);
+ try std.testing.expectEqual(ps[1].first + 1, after[1].first);
+ try std.testing.expect(try s.refused(s.at("/pane/{d}/exec", .{second}), "Unfollow\n") != 0);
+ // Del of the head: the third is a chain of one, which is no chain.
+ try s.write(s.at("/pane/{d}/ctl", .{second}), "Del\n");
+ try s.write(s.at("/pane/{d}/exec", .{third}), "Follow\n");
+ const fourth = try newest(&s);
+ try s.write(s.at("/pane/{d}/ctl", .{head}), "Del\n");
+ try std.testing.expect(!has(try s.read(s.at("/pane/{d}/tag", .{third})), "Unfollow"));
+ try std.testing.expect(has(try s.read(s.at("/pane/{d}/tag", .{fourth})), "Unfollow"));
+ ps = try pages(&s);
+ try std.testing.expectEqual(@as(usize, 2), ps.len);
+ try expectConsecutive(ps);
+ try s.write(s.at("/pane/{d}/ctl", .{third}), "Del\n");
+ try std.testing.expect(!has(try s.read(s.at("/pane/{d}/tag", .{fourth})), "Unfollow"));
+}
+
+test "follow: a Dump and Restore keep the chain, still one" {
+ var s = try init();
+ defer s.deinit();
+ const head = try s.focused();
+ try s.write(s.at("/pane/{d}/exec", .{head}), "Follow\n");
+ try s.write(s.at("/pane/{d}/exec", .{head}), "Follow\n");
+ try s.write("/ctl", "Dump\n");
+ const label = try s.arena.allocator().dupe(u8, std.mem.sliceTo(try s.read("/dumps"), ' '));
+ try s.write(s.at("/pane/{d}/exec", .{head}), "Unfollow\n");
+ try s.write("/ctl", s.at("Restore {s}\n", .{label}));
+ var ps = try pages(&s);
+ try std.testing.expectEqual(@as(usize, 3), ps.len);
+ try expectConsecutive(ps);
+ for (0..2) |_| try s.write("/mousein", s.at("m {d} 10 16\nm {d} 10 0\n", .{ ps[2].x + 2, ps[2].x + 2 }));
+ ps = try pages(&s);
+ try std.testing.expectEqual(@as(usize, 3), ps[0].first);
+ try expectConsecutive(ps);
+}
diff --git a/test/snapshots/builtins.golden b/test/snapshots/builtins.golden
index fd60bc74..7230f9b8 100644
--- a/test/snapshots/builtins.golden
+++ b/test/snapshots/builtins.golden
@@ -14,16 +14,16 @@
|10: 1 pardes builtins under SPC c
|11: 2
|12: 3 SPC c d Delcol
-|13: 4 SPC c j Joincol topbar
-|14: 5 SPC c n Newcol topbar
-|15: 6
+|13: 4 SPC c f Follow
+|14: 5 SPC c j Joincol topbar
+|15: 6 SPC c n Newcol topbar
+|16: 7
== snap docs-group grid=120x67 cursor=7,10
|10: 1 pardes builtins under SPC h
|12: 3 SPC h b Build
|13: 4 SPC h c Changelog topbar
|14: 5 SPC h m Messages
|15: 6 SPC h t Tutor topbar
-|16: 7
== snap tutor-from-index grid=120x67 cursor=7,17
|10: 1 pardes builtins under SPC h Tutor
|16: /tmp/pardes-snap/builtins/cwd/+Tutor Save Term Collapse Del
diff --git a/test/snapshots/follow.golden b/test/snapshots/follow.golden
new file mode 100644
index 00000000..99ef20b9
--- /dev/null
+++ b/test/snapshots/follow.golden
@@ -0,0 +1,61 @@
+== snap three-pages grid=150x30 cursor=7,3
+| Newcol Joincol Find Grep Help Changelog Tutor Dump Themes Config Debug Exit
+| New Term Find Grep Joincol Delcol New Term Find Grep Joincol Delcol New Term Find Grep Joincol Delcol
+| /tmp/pardes-snap/follow/cwd/big.txt Save Term Collapse Del /tmp/pardes-snap/follow/cwd/big.txt /tmp/pardes-snap/follow/cwd/big.txt
+| 1 line 1 Follow Save Term Collapse Del Unfollow Save Term Collapse Del Unfollow
+| 2 line 2 28 line 28 54 line 54
+| 3 line 3 29 line 29 55 line 55
+| 4 line 4 30 line 30 56 line 56
+| 5 line 5 31 line 31 57 line 57
+| 6 line 6 32 line 32 58 line 58
+| 7 line 7 33 line 33 59 line 59
+| 8 line 8 34 line 34 60 line 60
+| 9 line 9 35 line 35 61 line 61
+| 10 line 10 36 line 36 62 line 62
+| 11 line 11 37 line 37 63 line 63
+| 12 line 12 38 line 38 64 line 64
+| 13 line 13 39 line 39 65 line 65
+| 14 line 14 40 line 40 66 line 66
+| 15 line 15 41 line 41 67 line 67
+| 16 line 16 42 line 42 68 line 68
+| 17 line 17 43 line 43 69 line 69
+| 18 line 18 44 line 44 70 line 70
+| 19 line 19 45 line 45 71 line 71
+| 20 line 20 46 line 46 72 line 72
+| 21 line 21 47 line 47 73 line 73
+| 22 line 22 48 line 48 74 line 74
+| 23 line 23 49 line 49 75 line 75
+| 24 line 24 50 line 50 76 line 76
+| 25 line 25 51 line 51 77 line 77
+| 26 line 26 52 line 52 78 line 78
+| 27 line 27 53 line 53 79 line 79
+== snap hop grid=150x30 cursor=82,4
+|3: 1 line 1 Save Term Collapse Del Unfollow Save Term Collapse Del Unfollow
+== snap wheel grid=150x30 cursor=82,4
+|3: 2 line 2 Save Term Collapse Del Unfollow Save Term Collapse Del Unfollow
+|4: 3 line 3 29 line 29 55 line 55
+|5: 4 line 4 30 line 30 56 line 56
+|6: 5 line 5 31 line 31 57 line 57
+|7: 6 line 6 32 line 32 58 line 58
+|8: 7 line 7 33 line 33 59 line 59
+|9: 8 line 8 34 line 34 60 line 60
+|10: 9 line 9 35 line 35 61 line 61
+|11: 10 line 10 36 line 36 62 line 62
+|12: 11 line 11 37 line 37 63 line 63
+|13: 12 line 12 38 line 38 64 line 64
+|14: 13 line 13 39 line 39 65 line 65
+|15: 14 line 14 40 line 40 66 line 66
+|16: 15 line 15 41 line 41 67 line 67
+|17: 16 line 16 42 line 42 68 line 68
+|18: 17 line 17 43 line 43 69 line 69
+|19: 18 line 18 44 line 44 70 line 70
+|20: 19 line 19 45 line 45 71 line 71
+|21: 20 line 20 46 line 46 72 line 72
+|22: 21 line 21 47 line 47 73 line 73
+|23: 22 line 22 48 line 48 74 line 74
+|24: 23 line 23 49 line 49 75 line 75
+|25: 24 line 24 50 line 50 76 line 76
+|26: 25 line 25 51 line 51 77 line 77
+|27: 26 line 26 52 line 52 78 line 78
+|28: 27 line 27 53 line 53 79 line 79
+|29: 28 line 28 54 line 54 80 line 80
diff --git a/test/snapshots/follow.snap b/test/snapshots/follow.snap
new file mode 100644
index 00000000..0e5d23a2
--- /dev/null
+++ b/test/snapshots/follow.snap
@@ -0,0 +1,20 @@
+# Follow (SPC c f) twice on a 300-line file: three pages in three columns,
+# each going on the line after the one before ends; Unfollow on the two
+# followers' tags only. Then j past the first page's last row takes the
+# keyboard to the second page without scrolling, and a wheel notch in the
+# last page moves all three.
+lines big.txt 300
+start 30 150 big.txt
+wait 8000 big.txt
+stable 500 15000
+key space c f
+stable 500 8000
+key space c f
+stable 500 8000
+snap three-pages
+text 27j
+stable 500 8000
+snap hop
+wheel down 120 12
+stable 500 8000
+snap wheel
diff --git a/test/snapshots/leader.golden b/test/snapshots/leader.golden
index 932e8a95..1895a833 100644
--- a/test/snapshots/leader.golden
+++ b/test/snapshots/leader.golden
@@ -90,9 +90,10 @@
|6: 1 pardes builtins under SPC c
|7: 2
|8: 3 SPC c d Delcol
-|9: 4 SPC c j Joincol topbar
-|10: 5 SPC c n Newcol topbar
-|11: 6
+|9: 4 SPC c f Follow
+|10: 5 SPC c j Joincol topbar
+|11: 6 SPC c n Newcol topbar
+|12: 7
|34:
|35:
|36:
diff --git a/test/snapshots/ttyhelp.golden b/test/snapshots/ttyhelp.golden
index d0b90887..c3b4d57e 100644
--- a/test/snapshots/ttyhelp.golden
+++ b/test/snapshots/ttyhelp.golden
@@ -34,11 +34,11 @@
|12: 7 SPC R ClipReplace
|13: 8 SPC Y ClipYankMain
|14: 9 SPC c d Delcol
-|15: 10 SPC c j Joincol topbar
-|16: 11 SPC c n Newcol topbar
-|17: 12 SPC d Del
-|18: 13 SPC f c Config topbar
-|19: 14 SPC f f Find topbar
-|20: 15 SPC f g Grep topbar
+|15: 10 SPC c f Follow
+|16: 11 SPC c j Joincol topbar
+|17: 12 SPC c n Newcol topbar
+|18: 13 SPC d Del
+|19: 14 SPC f c Config topbar
+|20: 15 SPC f f Find topbar
== snap leaderworks grid=100x31 cursor=7,6
|3: $