//! docs/typ/guide.typ, Modes . const std = @import("std"); const Session = @import("session").Session; const expectEqual = std.testing.expectEqual; fn mode(s: *Session, pane: u32) ![]const u8 { const ctl = try s.read(s.at("/pane/{d}/ctl", .{pane})); const at = std.mem.lastIndexOf(u8, ctl, " mode:").? + " mode:".len; return std.mem.trimEnd(u8, ctl[at..], " "); } test "modes: Esc in normal mode alternates between two panes of the same kind" { var tmp = std.testing.tmpDir(.{}); defer tmp.cleanup(); try tmp.dir.writeFile(std.testing.io, .{ .sub_path = "b.txt", .data = "b\n" }); var dir: [4096]u8 = undefined; const at = dir[0..try tmp.dir.realPath(std.testing.io, &dir)]; var s = try Session.initFile(std.testing.allocator, "a\n"); defer s.deinit(); const a = try s.focused(); try s.write("/look", s.at("{s}/b.txt\n", .{at})); const b = try s.focused(); try std.testing.expect(a != b); for (0..6) |_| { const was = try s.focused(); try s.keys("\x1b"); try expectEqual(if (was == a) b else a, try s.focused()); } } test "modes: Esc in a column or the workspace tag gives the keyboard back to a pane, as Shift-Esc does" { var s = try Session.initFile(std.testing.allocator, "x\n"); defer s.deinit(); _ = try s.newPane(); for ([_][]const u8{ "New Term", "Newcol" }) |tag| { const was = try s.focused(); // A click puts the tag in normal mode, the keyboard there; Esc is // out of it. try s.click(tag, 0, 1); try s.expect("/focus", ""); try s.keys("\x1b"); try std.testing.expect(was != try s.focused()); } } test "modes: Shift-Esc backs out to the previous pane in every mode, never into raw" { var s = try Session.initFile(std.testing.allocator, "x\n"); defer s.deinit(); const doc = try s.focused(); try s.keys("\u{F015}n"); // a shell under the doc const shell = try s.focused(); if (std.mem.eql(u8, try mode(&s, shell), "tty")) try s.keys("\x02"); try std.testing.expectEqualStrings("normal", try mode(&s, shell)); // A terminal in normal mode: out, still normal, never raw. try s.keys("\u{F016}\x1b"); try expectEqual(doc, try s.focused()); try std.testing.expectEqualStrings("normal", try mode(&s, shell)); // A text pane in insert mode: out of insert, and out of the pane. try s.keys("i"); try std.testing.expectEqualStrings("insert", try mode(&s, doc)); try s.keys("\u{F016}\x1b"); try std.testing.expectEqualStrings("normal", try mode(&s, doc)); try std.testing.expect(doc != try s.focused()); } /// The first line number drawn under the tag that starts with `tag`. fn topLine(s: *Session, tag: []const u8) !usize { const row = (try s.where(tag))[1]; var rows = std.mem.splitScalar(u8, try s.screen(), '\n'); for (0..row + 1) |_| _ = rows.next(); var words = std.mem.tokenizeScalar(u8, rows.next().?, ' '); return std.fmt.parseInt(usize, words.next().?, 10); } test "modes: Esc back into a file leaves its view where it was, and a look centres its line" { var s = try Session.initFile(std.testing.allocator, std.mem.asBytes(&@as([100][4]u8, @splat("row\n".*)))); defer s.deinit(); const doc = try s.focused(); const dot = s.at("/pane/{d}/dot", .{doc}); try s.keys("\u{F015}n"); // a shell under the doc const shell = try s.focused(); try s.keys("\x1b"); try expectEqual(doc, try s.focused()); // Ride the cursor down until the view has scrolled. try s.keys(&@as([20]u8, @splat('j'))); const top = try topLine(&s, "/test.txt"); const at = try s.range(dot); try std.testing.expect(top > 1); try s.keys("\x1b"); try expectEqual(shell, try s.focused()); try s.keys("\x1b"); try expectEqual(doc, try s.focused()); // Nothing moved: the old landing recentred the line under the cursor. try expectEqual(top, try topLine(&s, "/test.txt")); try expectEqual(at, try s.range(dot)); // The other arm still centres: a look's `:NN`. const line = 60; try s.write(s.at("/pane/{d}/look", .{doc}), s.at(":{d}\n", .{line})); const rows = (try s.where("Term Save Mode"))[1] - (try s.where("/test.txt"))[1] - 1; // Drawn mid-pane, a row either way. const drawn_at = line - try topLine(&s, "/test.txt"); try std.testing.expect(drawn_at + 1 >= rows / 2 and drawn_at <= rows / 2 + 1); } /// Three panes named /a.txt (left column), /b.txt over /c.txt (right), /// the keyboard on /a.txt; their serials. fn threePanes(s: *Session) ![3]u32 { const a = try s.focused(); try s.write(s.at("/pane/{d}/name", .{a}), "/a.txt\n"); try s.write("/ctl", "Newcol\n"); try s.write(s.at("/col/{d}/exec", .{try s.column(1)}), "New\n"); const b = try s.focused(); try s.write(s.at("/pane/{d}/exec", .{b}), "New\n"); const c = try s.focused(); try s.write(s.at("/pane/{d}/name", .{b}), "/b.txt\n"); try s.write(s.at("/pane/{d}/name", .{c}), "/c.txt\n"); try s.write("/focus", s.at("{d}\n", .{a})); return .{ a, b, c }; } /// The panes whose tag (`name Save`) is drawn in `lit`, the outline's colour. fn outlined(s: *Session, lit: []const u8, names: []const []const u8) ![]const u8 { var found: []const u8 = ""; for (names) |name| { const x, const y = try s.where(s.at("{s} Save", .{name})); if (std.mem.eql(u8, lit, try s.bg(x, y))) found = s.at("{s}{s}", .{ found, name }); } return found; } test "modes: Ctrl-w outlines a pane, h j k l move the outline, and Enter, Esc, : or a pane's letter gives it the keyboard" { var s = try Session.initFile(std.testing.allocator, "left\n"); defer s.deinit(); const a, const b, const c = try threePanes(&s); const names = &[_][]const u8{ "/a.txt", "/b.txt", "/c.txt" }; try s.keys("\x17"); const x, const y = try s.where("/a.txt Save"); const lit = try s.bg(x, y); try std.testing.expectEqualStrings("/a.txt", try outlined(&s, lit, names)); // Each pane's box shows its letter: the left column's is a. try std.testing.expectEqualStrings("a /a.txt", (try s.screen())[y * 81 ..][0.."a /a.txt".len]); try s.keys("l"); try std.testing.expectEqualStrings("/b.txt", try outlined(&s, lit, names)); try s.keys("j"); try std.testing.expectEqualStrings("/c.txt", try outlined(&s, lit, names)); try expectEqual(a, try s.focused()); try s.keys("\n"); try expectEqual(c, try s.focused()); try std.testing.expectEqualStrings("", try outlined(&s, lit, names)); // SPC w enters it too, and Esc leaves it on the outlined pane. try s.keys(" wh\x1b"); try expectEqual(a, try s.focused()); // Other keys change nothing. try s.keys("\x17!"); try std.testing.expectEqualStrings("/a.txt", try outlined(&s, lit, names)); try s.keys("\x1b"); // `:` gives the outlined pane's tag the keyboard. try s.keys("\x17l:"); try expectEqual(b, try s.focused()); try expectEqual((try s.where("/b.txt Save"))[1], (try s.cursor()).?[1]); try s.keys("\x1b"); // A letter goes straight there. try s.keys("\x17a"); try expectEqual(a, try s.focused()); try std.testing.expectEqualStrings("", try outlined(&s, lit, names)); } fn listed(s: *Session, n: u32) !bool { var rows = std.mem.tokenizeScalar(u8, try s.read("/index"), '\n'); while (rows.next()) |row| if (std.mem.startsWith(u8, row, s.at("{d} ", .{n}))) return true; return false; } test "modes: in window mode d deletes the outlined pane, asking k or j between two, c collapses it, and the mode stays on" { var s = try Session.initFile(std.testing.allocator, "top\n"); defer s.deinit(); // The neighbours below are what is under test: each New right under its asker. try s.write("/ctl", "Placement pardes\n"); const top = try s.focused(); try s.write(s.at("/pane/{d}/exec", .{top}), "New\n"); const mid = try s.focused(); try s.write(s.at("/pane/{d}/exec", .{mid}), "New\n"); const low = try s.focused(); try s.write(s.at("/pane/{d}/name", .{mid}), "/mid\n"); try s.write(s.at("/pane/{d}/name", .{low}), "/low\n"); const names = &[_][]const u8{ "/test.txt", "/mid", "/low" }; const row_top = (try s.where("/test.txt Save"))[1]; const row_mid = (try s.where("/mid Save"))[1]; const row_low = (try s.where("/low Save"))[1]; // From the bottom pane, the outline up to the middle one. const mx, const my = try s.where("/mid Save"); const plain = try s.bg(mx, my); try s.keys("\x17k"); const lit = try s.bg(mx, my); try std.testing.expect(!std.mem.eql(u8, plain, lit)); try std.testing.expectEqualStrings("/mid", try outlined(&s, lit, names)); // c folds it to its tag and back, the mode staying. try s.keys("c"); try std.testing.expect(std.mem.indexOf(u8, try s.read(s.at("/pane/{d}/ctl", .{mid})), " collapsed ") != null); try std.testing.expectEqualStrings("/mid", try outlined(&s, lit, names)); try s.keys("c"); try std.testing.expect(std.mem.indexOf(u8, try s.read(s.at("/pane/{d}/ctl", .{mid})), " collapsed ") == null); try expectEqual(row_low, (try s.where("/low Save"))[1]); // d between two panes asks, as SPC d does; Esc takes it back, the // outline where it was. try s.keys("d"); try std.testing.expect(std.mem.indexOf(u8, try s.read("/log"), s.at("ask {d} del k j\n", .{mid})) != null); try s.keys("\x1b"); try std.testing.expect(try listed(&s, mid)); try std.testing.expectEqualStrings("/mid", try outlined(&s, lit, names)); // j: the pane below takes the rows, and the outline goes with them. try s.keys("dj"); try std.testing.expect(!try listed(&s, mid)); try expectEqual(row_top, (try s.where("/test.txt Save"))[1]); try expectEqual(row_mid, (try s.where("/low Save"))[1]); try std.testing.expectEqualStrings("/low", try outlined(&s, lit, &.{ "/test.txt", "/low" })); // With one neighbour nothing is asked: d closes it, the outline on the // pane that grew. try s.keys("d"); try std.testing.expect(!try listed(&s, low)); try std.testing.expect(std.mem.indexOf(u8, try s.read("/log"), s.at("ask {d} ", .{low})) == null); try std.testing.expectEqualStrings("/test.txt", try outlined(&s, lit, &.{"/test.txt"})); // Enter leaves the mode on it. try s.keys("\n"); try expectEqual(top, try s.focused()); try std.testing.expectEqualStrings("", try outlined(&s, lit, &.{"/test.txt"})); } test "modes: window keys walk from a pane up through its column's tag and the workspace's, across, and back down" { var s = try Session.initFile(std.testing.allocator, "body\n"); defer s.deinit(); const a = try s.focused(); try s.write("/ctl", "Newcol\n"); try s.write(s.at("/col/{d}/exec", .{try s.column(1)}), "New\n"); try s.write("/focus", s.at("{d}\n", .{a})); const right = 40; // two columns on 80 cells: the right one's first // Up from the top pane: its column's tag, in normal mode (w moves). try s.keys("\x17k"); try s.expect("/focus", ""); const x0, const y0 = (try s.cursor()).?; try expectEqual(@as(usize, 1), y0); try std.testing.expect(x0 < right); const tag = s.at("/col/{d}/tag", .{try s.column(0)}); const words = try s.read(tag); try s.keys("w"); try s.expect(tag, words); const remembered = (try s.cursor()).?; try std.testing.expect(remembered[0] > x0); // Across to the right column's tag, and back to where the caret was. try s.keys("\x17l"); try std.testing.expect((try s.cursor()).?[0] >= right); try s.keys("\x17h"); try expectEqual(remembered, (try s.cursor()).?); // Up again: the workspace tag; down, the column's, then the pane. try s.keys("\x17k"); try expectEqual(@as(usize, 0), (try s.cursor()).?[1]); try s.keys("\x17j"); try expectEqual(@as(usize, 1), (try s.cursor()).?[1]); try s.keys("\x17j"); try expectEqual(a, try s.focused()); // `:` in a column's tag is the way back to the body. try s.keys("\x17k:"); try expectEqual(a, try s.focused()); try expectEqual((try s.where("body"))[1], (try s.cursor()).?[1]); try s.expect(s.at("/pane/{d}/body", .{a}), "body\n"); } /// The jump tests' session: a pane a letter of `order`, A and B each a file /// of 100 lines, C a Zerox of A, O the +Help output (no file behind it), /// and the jumplist `order`, a letter a place, each letter's n-th place its /// line 1 + 40n ("ABABA" is A1 B1 A41 B41 A81): each made by moving its /// pane's dot there and giving it the keyboard, as a jump does (a new /// pane's first, where it opens). The shell the session started with is /// closed after, its places with it. const Jumps = struct { s: Session, ids: [4]u32 = @splat(0), const letters = "ABCO"; fn init(order: []const u8) !Jumps { var t: Jumps = .{ .s = try Session.initTerm(std.testing.allocator) }; errdefer t.s.deinit(); const s = &t.s; const shell = try s.focused(); var seen: [4]u32 = @splat(0); for (order) |letter| { const which = std.mem.indexOfScalar(u8, letters, letter).?; if (t.ids[which] == 0) t.ids[which] = switch (letter) { 'O' => o: { try s.write(s.at("/pane/{d}/exec", .{shell}), "Help\n"); break :o try s.focused(); }, else => made: { // C is A's twin, and A C's when C came first. const twin = t.ids[if (letter == 'A') 2 else if (letter == 'C') 0 else 1]; if (letter != 'B' and twin != 0) { try s.write(s.at("/pane/{d}/exec", .{twin}), "Zerox\n"); break :made try s.focused(); } const n = try s.newPane(); try s.write(s.at("/pane/{d}/name", .{n}), if (letter == 'B') "/b.txt\n" else "/a.txt\n"); try s.write(s.at("/pane/{d}/body", .{n}), std.mem.asBytes(&@as([100][4]u8, @splat("row\n".*)))); break :made n; }, }; const n = t.ids[which]; try s.write(s.at("/pane/{d}/addr", .{n}), s.at("{d}\n", .{1 + 40 * seen[which]})); try s.write(s.at("/pane/{d}/ctl", .{n}), "dot=addr\n"); try s.write("/focus", s.at("{d}\n", .{n})); seen[which] += 1; } try s.write(s.at("/pane/{d}/ctl", .{shell}), "delete\n"); return t; } /// Where the keyboard is: its pane's letter and the dot's line, `A50`. fn here(t: *Jumps) ![]const u8 { const s = &t.s; const n = try s.focused(); const at, _ = try s.range(s.at("/pane/{d}/dot", .{n})); const body = try s.read(s.at("/pane/{d}/body", .{n})); const which = std.mem.indexOfScalar(u32, &t.ids, n).?; return s.at("{c}{d}", .{ letters[which], std.mem.count(u8, body[0..at], "\n") + 1 }); } const Way = enum { key, leader, builtin }; /// Steps back or on until the list ends that way, as it says; the /// places landed on, "A50 A10 B10". fn walk(t: *Jumps, way: Way, back: bool) ![]const u8 { const s = &t.s; var out: []const u8 = ""; for (0..64) |_| { const before = try t.here(); switch (way) { .key => try s.keys(if (back) "\x0f" else "\u{F017}i"), .leader => try s.keys(if (back) " jo" else " ji"), .builtin => try s.write("/exec", if (back) "Back\n" else "Forward\n"), } const now = try t.here(); if (std.mem.eql(u8, before, now)) break; out = if (out.len == 0) now else s.at("{s} {s}", .{ out, now }); } else return error.NoEnd; try std.testing.expect(std.mem.indexOf(u8, try s.screen(), if (back) "nothing further back" else "nothing further on") != null); return out; } }; test "modes: Ctrl-o keeps to the focused file (JumpScope file), A41 then A1, and leaves it only once it runs out that way; Ctrl-i mirrors it" { var t = try Jumps.init("BABABA"); defer t.s.deinit(); try std.testing.expect(std.mem.indexOf(u8, try t.s.read("/ctl"), "\nJumpScope file\n") != null); // B81, B41 passed over, kept in their places: A has nothing older than // A1, so the step after it is the nearest place of any file, B1. try std.testing.expectEqualStrings("A41 A1 B1", try t.walk(.key, true)); // Forward is the mirror, from B1 in B: B's own places first, then A81, // the newest, where the Backs started. try std.testing.expectEqualStrings("B41 B81 A81", try t.walk(.key, false)); } test "modes: Ctrl-i retraces a run of Ctrl-o inside one file step for step, back to where it began" { var t = try Jumps.init("ABABA"); defer t.s.deinit(); // A1 B1 A41 B41 A81 from A81: nothing older than A1 at all. try std.testing.expectEqualStrings("A41 A1", try t.walk(.key, true)); try std.testing.expectEqualStrings("A41 A81", try t.walk(.key, false)); // One back, one on: the same place, whichever were passed over. try t.s.keys("\x0f"); try std.testing.expectEqualStrings("A41", try t.here()); try t.s.keys("\u{F017}i"); try std.testing.expectEqualStrings("A81", try t.here()); // And the steps made no places of their own. try std.testing.expectEqualStrings("A41 A1", try t.walk(.key, true)); } test "modes: with JumpScope all, Ctrl-o and Ctrl-i take every place in the order it was jumped to, and bare JumpScope is file again" { var t = try Jumps.init("ABABA"); defer t.s.deinit(); try t.s.write("/ctl", "JumpScope all\n"); try std.testing.expectEqualStrings("B41 A41 B1 A1", try t.walk(.key, true)); try std.testing.expectEqualStrings("B1 A41 B41 A81", try t.walk(.key, false)); try t.s.write("/ctl", "JumpScope\n"); try std.testing.expect(std.mem.indexOf(u8, try t.s.read("/ctl"), "\nJumpScope file\n") != null); } test "modes: from a pane with no file, Ctrl-o and Ctrl-i step through every place" { var t = try Jumps.init("OAOBO"); defer t.s.deinit(); // O81 keeps to nothing: B1, the next older of all. From B, nothing of // B is older, so O41; from O, A1; from A, O1. try std.testing.expectEqualStrings("B1 O41 A1 O1", try t.walk(.key, true)); try std.testing.expectEqualStrings("A1 O41 B1 O81", try t.walk(.key, false)); } test "modes: Ctrl-o in a file shown in two panes keeps to its own pane first, then the file in the other" { // C is A's file in a second pane: C1 B1 A1 C41 A41. var t = try Jumps.init("CBACA"); defer t.s.deinit(); // From A41: A1 in this pane, over the nearer C41; then none of A's own // is older, so the file's in C, C1, over B1. try std.testing.expectEqualStrings("A1 C1", try t.walk(.key, true)); // From C1 in C: C41, its own, then the file's newest, A41. try std.testing.expectEqualStrings("C41 A41", try t.walk(.key, false)); } test "modes: Back and Forward take the same steps from Ctrl-o and Ctrl-i, SPC j o and SPC j i, and the builtins" { for ([_]Jumps.Way{ .key, .leader, .builtin }) |way| { var t = try Jumps.init("BABABA"); defer t.s.deinit(); try std.testing.expectEqualStrings("A41 A1 B1", try t.walk(way, true)); try std.testing.expectEqualStrings("B41 B81 A81", try t.walk(way, false)); } } test "modes: Ctrl-o and Ctrl-i drop the selections, select mode and the extra cursors, and land where the place was left" { const rows = std.mem.asBytes(&@as([97][4]u8, @splat("row\n".*))); var s = try Session.initFile(std.testing.allocator, "alpha beta\ngamma delta\nepsilon zeta\n" ++ rows); defer s.deinit(); const n = try s.focused(); const dot = s.at("/pane/{d}/dot", .{n}); // A place on line 3, at its eighth column (byte 30), then line 60. try s.write(s.at("/pane/{d}/addr", .{n}), "#30\n"); try s.write(s.at("/pane/{d}/ctl", .{n}), "dot=addr\n"); try s.keys("60G"); // Each step lands on the cursor the place was left with. var back_to: u32 = 30; for ([_][]const u8{ "\x0f", "\u{F017}i" }) |key| { // A line selected, a second cursor under it, select mode on. try s.keys("xCv"); try std.testing.expectEqualStrings("select", try mode(&s, n)); const leaving = (try s.range(dot))[1] - 1; // the cursor: its last character try s.keys(key); try std.testing.expectEqualStrings("normal", try mode(&s, n)); try std.testing.expectEqual(back_to, (try s.range(dot))[0]); back_to = leaving; try s.expect(s.at("/pane/{d}/sel", .{n}), ""); // One cursor: a Z typed goes in once. try s.keys("iZ\x1b"); try expectEqual(@as(usize, 1), std.mem.count(u8, try s.read(s.at("/pane/{d}/body", .{n})), "Z")); try s.keys("u"); } // No place further on: said, and the selection left as it was. try s.keys("x"); const sel = try s.read(s.at("/pane/{d}/sel", .{n})); try s.keys("\u{F017}i"); try std.testing.expect(std.mem.indexOf(u8, try s.screen(), "nothing further on") != null); try s.expect(s.at("/pane/{d}/sel", .{n}), sel); } test "modes: hopping between two panes by Esc, window mode or a click makes no places, so one Ctrl-o goes back across and the next has nowhere to go" { var s = try Session.initFile(std.testing.allocator, std.mem.asBytes(&@as([100][4]u8, @splat("row\n".*)))); defer s.deinit(); // Two panes of room, not acme's fit to the doc. try s.write("/ctl", "Placement pardes\n"); const doc = try s.focused(); try s.keys("\u{F015}n"); // a shell under the doc const shell = try s.focused(); if (std.mem.indexOf(u8, try s.read(s.at("/pane/{d}/ctl", .{shell})), "mode:tty") != null) try s.keys("\x02"); for (0..8) |_| { const was = try s.focused(); try s.keys("\x1b"); try expectEqual(if (was == doc) shell else doc, try s.focused()); } for (0..8) |_| { const want = if (try s.focused() == doc) shell else doc; try s.keys(if (want == shell) " wj\n" else " wk\n"); try expectEqual(want, try s.focused()); } const doc_row = (try s.where("row"))[1]; const shell_row = (try s.where("Term Save Mode"))[1] + 1; for (0..8) |_| { const other = if (try s.focused() == doc) shell else doc; const row = if (other == doc) doc_row else shell_row; try s.write("/mousein", s.at("m 10 {d} 1\nm 10 {d} 0\n", .{ row, row })); try expectEqual(other, try s.focused()); } const before = try s.focused(); try s.keys("\x0f"); try std.testing.expect(before != try s.focused()); const after = try s.focused(); try s.keys("\x0f"); try expectEqual(after, try s.focused()); try std.testing.expect(std.mem.indexOf(u8, try s.screen(), "nothing further back") != null); }