diff options
Diffstat (limited to 'src/Messages.zig')
| -rw-r--r-- | src/Messages.zig | 88 |
1 files changed, 44 insertions, 44 deletions
diff --git a/src/Messages.zig b/src/Messages.zig index 66beb6bc..ad91cf8d 100644 --- a/src/Messages.zig +++ b/src/Messages.zig @@ -52,7 +52,7 @@ fn leaderText(p: *const Pardes, buf: *[16]u8) []const u8 { buf.* = @splat(' '); @memcpy(buf[0..3], "SPC"); var end: usize = 3; - for (p.leader_keys[0..p.leader_n]) |ch| { + for (p.view().leader_keys[0..p.view().leader_n]) |ch| { if (end + 2 > buf.len) break; buf[end + 1] = ch; end += 2; @@ -522,7 +522,7 @@ fn collectBands(p: *Pardes, pane: *Pane, r: Rect, id: usize) void { // new one lands under them; when rows run out the oldest go first. for (pane.msg_older[0..pane.msg_older_len], 0..) |line, i| pane.notices.pushAt(.older, @intCast(i), line.slot); if (pane.msg_len > 0) pane.notices.pushAt(.message, 0, pane.msg_slot); - if (id == p.active and p.prefix == .leader) pane.notices.push(.leader); + if (id == p.view().active and p.view().prefix == .leader) pane.notices.push(.leader); // Del's question shows once its delay is up: answered before that, it // was never there. const del_waiting = pane.prompt == .del_side and pane.question_due_ns > p.clock.now_ns; @@ -576,7 +576,7 @@ test "the message log keeps what the row forgets, and collapses repeats" { // The same text from a DIFFERENT pane is a different event: one pane's // failure must not be recorded as another's. p.newScratchBelow(0); - const other = p.active; + const other = p.view().active; setMessage(p, other, "save: AccessDenied"); try std.testing.expectEqual(@as(usize, 3), p.messages.len); try std.testing.expectEqual(p.panes[other].?.serial, p.messages.at(2).?.serial); @@ -643,9 +643,9 @@ test "Msg writes the transient row by hand, bare or with text, and input ends it test "with no frontend attached a message goes once it has lingered, on the clock" { const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true }); defer p.deinit(); - const pane = p.panes[p.active].?; - p.setMessage(p.active, "said"); - p.setMessage(p.active, "said again"); + const pane = p.panes[p.view().active].?; + p.setMessage(p.view().active, "said"); + p.setMessage(p.view().active, "said again"); // Attached: it waits for input, however long. pane.msg_said_ms -= 60_000; p.update(.tick); @@ -661,7 +661,7 @@ test "with no frontend attached a message goes once it has lingered, on the cloc try std.testing.expectEqual(@as(u16, 0), pane.msg_len); try std.testing.expectEqual(@as(u8, 0), pane.msg_older_len); // A fresh one stays until its linger is up. - p.setMessage(p.active, "fresh"); + p.setMessage(p.view().active, "fresh"); p.update(.tick); try std.testing.expect(pane.msg_len > 0); } @@ -670,15 +670,15 @@ test "a message lingers past the input that dismisses it, and goes" { const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 24 }); defer p.deinit(); while (p.nextEffect()) |_| {} - const pane = p.panes[p.active].?; - try std.testing.expect(p.executeBuiltinLine(p.active, "MessageLinger 160")); - try std.testing.expect(p.executeBuiltinLine(p.active, "Msg hello")); + const pane = p.panes[p.view().active].?; + try std.testing.expect(p.executeBuiltinLine(p.view().active, "MessageLinger 160")); + try std.testing.expect(p.executeBuiltinLine(p.view().active, "Msg hello")); // Shown at once, until input; the same line again stays shown. try std.testing.expectEqual(Pane.MessagePhase.shown, pane.msg_life.phase); try std.testing.expect(!p.animationActive()); for (0..100) |_| p.update(.tick); try std.testing.expectEqual(Pane.MessagePhase.shown, pane.msg_life.phase); - try std.testing.expect(p.executeBuiltinLine(p.active, "Msg hello")); + try std.testing.expect(p.executeBuiltinLine(p.view().active, "Msg hello")); try std.testing.expectEqual(Pane.MessagePhase.shown, pane.msg_life.phase); // Input (a key that announces nothing): 160 ms of lingering (ten frames), unaffected by more input... p.update(.{ .key = .{ .cp = 'h' } }); @@ -697,12 +697,12 @@ test "a message lingers past the input that dismisses it, and goes" { try std.testing.expect(!p.animationActive()); // Shown again while lingering: fresh, so it stays; a status update to a // line on screen swaps its text in place. - try std.testing.expect(p.executeBuiltinLine(p.active, "Msg again")); + try std.testing.expect(p.executeBuiltinLine(p.view().active, "Msg again")); p.update(.{ .key = .{ .cp = 'h' } }); try std.testing.expectEqual(Pane.MessagePhase.lingering, pane.msg_life.phase); - try std.testing.expect(p.executeBuiltinLine(p.active, "Msg again")); + try std.testing.expect(p.executeBuiltinLine(p.view().active, "Msg again")); try std.testing.expectEqual(Pane.MessagePhase.shown, pane.msg_life.phase); - setStatus(p, p.active, "progress 50%"); + setStatus(p, p.view().active, "progress 50%"); try std.testing.expectEqual(Pane.MessagePhase.shown, pane.msg_life.phase); try std.testing.expectEqualStrings("progress 50%", pane.msg[0..pane.msg_len]); try std.testing.expectEqual(@as(u8, 0), pane.msg_older_len); @@ -712,20 +712,20 @@ test "messages stack, oldest on top, each on its own timing" { const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 24 }); defer p.deinit(); while (p.nextEffect()) |_| {} - const pane = p.panes[p.active].?; - try std.testing.expect(p.executeBuiltinLine(p.active, "Verbose off")); - try std.testing.expect(p.executeBuiltinLine(p.active, "MessageLinger 160")); + const pane = p.panes[p.view().active].?; + try std.testing.expect(p.executeBuiltinLine(p.view().active, "Verbose off")); + try std.testing.expect(p.executeBuiltinLine(p.view().active, "MessageLinger 160")); // `Verbose off` announced itself before it took effect. pane.msg_len = 0; pane.msg_life = .{}; - setMessage(p, p.active, "first"); + setMessage(p, p.view().active, "first"); try std.testing.expectEqual(Pane.MessagePhase.shown, pane.msg_life.phase); // A second message stacks under the first instead of replacing it. - setMessage(p, p.active, "second"); + setMessage(p, p.view().active, "second"); try std.testing.expectEqual(@as(u8, 1), pane.msg_older_len); try std.testing.expectEqualStrings("first", pane.msg_older[0].slice()); try std.testing.expectEqualStrings("second", pane.msg[0..pane.msg_len]); - collectNotices(p, pane, p.rects[p.active], p.active); + collectNotices(p, pane, p.view().rects[p.view().active], p.view().active); try std.testing.expectEqual(Pane.Notices.Kind.older, pane.notices.kinds[0]); try std.testing.expectEqual(Pane.Notices.Kind.message, pane.notices.kinds[1]); // One key dismisses both, each on its own clock: a line already @@ -734,7 +734,7 @@ test "messages stack, oldest on top, each on its own timing" { try std.testing.expectEqual(Pane.MessagePhase.lingering, pane.msg_older[0].life.phase); try std.testing.expectEqual(Pane.MessagePhase.lingering, pane.msg_life.phase); p.update(.tick); - setMessage(p, p.active, "third"); + setMessage(p, p.view().active, "third"); try std.testing.expectEqual(@as(u8, 2), pane.msg_older_len); p.update(.{ .key = .{ .cp = 'h' } }); const linger = messageFrames(p.settings.message_linger_ms); @@ -747,24 +747,24 @@ test "messages stack, oldest on top, each on its own timing" { try std.testing.expectEqual(@as(u16, 0), pane.msg_len); try std.testing.expect(!p.animationActive()); // A status ticking in place does not pile up. - setStatus(p, p.active, "lsp 10%"); - setStatus(p, p.active, "lsp 20%"); + setStatus(p, p.view().active, "lsp 10%"); + setStatus(p, p.view().active, "lsp 20%"); try std.testing.expectEqual(@as(u8, 0), pane.msg_older_len); // Lines keep their rows: when the top one leaves, the one under it does // not move up, and the next message fills the gap instead. - setMessage(p, p.active, "top"); - setMessage(p, p.active, "under"); + setMessage(p, p.view().active, "top"); + setMessage(p, p.view().active, "under"); try std.testing.expectEqual(@as(u8, 0), pane.msg_older[0].slot); try std.testing.expectEqual(@as(u8, 1), pane.msg_slot); pane.removeOlderMessage(0); - collectNotices(p, pane, p.rects[p.active], p.active); + collectNotices(p, pane, p.view().rects[p.view().active], p.view().active); try std.testing.expectEqual(@as(u8, 1), pane.notices.row[0]); try std.testing.expectEqual(@as(u8, 2), pane.notices.span()); - setMessage(p, p.active, "fills"); + setMessage(p, p.view().active, "fills"); try std.testing.expectEqual(@as(u8, 0), pane.msg_slot); try std.testing.expectEqual(@as(u8, 1), pane.msg_older[0].slot); // The stack keeps the newest few. - for ([_][]const u8{ "a", "b", "c", "d", "e" }) |text| setMessage(p, p.active, text); + for ([_][]const u8{ "a", "b", "c", "d", "e" }) |text| setMessage(p, p.view().active, text); try std.testing.expectEqual(@as(u8, Pane.message_stack), pane.msg_older_len); try std.testing.expectEqualStrings("b", pane.msg_older[0].slice()); try std.testing.expectEqualStrings("e", pane.msg[0..pane.msg_len]); @@ -773,23 +773,23 @@ test "messages stack, oldest on top, each on its own timing" { test "a builtin announces itself on the message row, and Verbose silences it" { const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 24 }); defer p.deinit(); - const pane = p.panes[p.active].?; + const pane = p.panes[p.view().active].?; p.sync(); try std.testing.expect(p.settings.verbose); // Wrap, not Collapse: a builtin that folds its own pane away leaves no row // for its announcement, which is correct and not what this is testing. - try std.testing.expect(p.executeBuiltinLine(p.active, "Wrap")); + try std.testing.expect(p.executeBuiltinLine(p.view().active, "Wrap")); try std.testing.expectEqualStrings("Wrap", pane.msg[0..pane.msg_len]); // A value it does not take is said, in place of the announcement. const wrapped = p.settings.wrap; - try std.testing.expect(p.executeBuiltinLine(p.active, "Wrap maybe")); + try std.testing.expect(p.executeBuiltinLine(p.view().active, "Wrap maybe")); try std.testing.expectEqualStrings("Wrap: takes on, off", pane.msg[0..pane.msg_len]); try std.testing.expectEqual(wrapped, p.settings.wrap); // The notice list is what the paint pass reads, so the announcement has to // reach it, not just the buffer. - collectNotices(p, pane, p.rects[p.active], p.active); + collectNotices(p, pane, p.view().rects[p.view().active], p.view().active); try std.testing.expect(pane.notices.len > 0); try std.testing.expectEqual(Pane.Notices.Kind.message, pane.notices.kinds[0]); @@ -798,7 +798,7 @@ test "a builtin announces itself on the message row, and Verbose silences it" { var frame = std.heap.ArenaAllocator.init(std.testing.allocator); defer frame.deinit(); _ = try p.render(frame.allocator()); - const r = p.rects[p.active]; + const r = p.view().rects[p.view().active]; const band = for (p.surface.tagLayers()) |*layer| { if (layer.rows != 0 and layer.kind == .notice) break layer; } else return error.NoNoticeBand; @@ -812,32 +812,32 @@ test "a builtin announces itself on the message row, and Verbose silences it" { try std.testing.expect(line[0].grapheme()[0] == ' '); // Msg owns the row itself, so it does not announce over its own text. - try std.testing.expect(p.executeBuiltinLine(p.active, "Msg hello")); + try std.testing.expect(p.executeBuiltinLine(p.view().active, "Msg hello")); try std.testing.expectEqualStrings("hello", pane.msg[0..pane.msg_len]); pane.msg_len = 0; p.settings.verbose = false; - try std.testing.expect(p.executeBuiltinLine(p.active, "Wrap")); + try std.testing.expect(p.executeBuiltinLine(p.view().active, "Wrap")); try std.testing.expectEqual(@as(u16, 0), pane.msg_len); } test "notices stack over the body's top rows without moving them" { const p = try Pardes.init(std.testing.allocator, .{ .tty_only = true, .cols = 80, .rows = 24 }); defer p.deinit(); - const id = p.active; + const id = p.view().active; const pane = p.panes[id].?; p.sync(); var frame = std.heap.ArenaAllocator.init(std.testing.allocator); defer frame.deinit(); - const r = p.rects[id]; + const r = p.view().rects[id]; const top = p.bodyTop(pane, r); // A message and a leader prefix at once: two chips, in the order // collectNotices chose, each one row tall and each one row further down. try std.testing.expect(p.executeBuiltinLine(id, "Msg first")); - p.prefix = .leader; - p.leader_n = 0; + p.view().prefix = .leader; + p.view().leader_n = 0; _ = frame.reset(.retain_capacity); _ = try p.render(frame.allocator()); try std.testing.expectEqual(@as(u8, 2), pane.notices.len); @@ -861,7 +861,7 @@ test "notices stack over the body's top rows without moving them" { try std.testing.expect(pane.notices.left[0] < pane.notices.left[1]); // Gone with the notices: no stale chip left behind. - p.prefix = .none; + p.view().prefix = .none; pane.msg_len = 0; _ = frame.reset(.retain_capacity); _ = try p.render(frame.allocator()); @@ -876,9 +876,9 @@ test "an idle core wants no wake and a lingering message sleeps to its linger's const frame = pardes.frame_ns; p.advance(1_000_000); try std.testing.expectEqual(@as(?u64, null), p.nextWake()); - const pane = p.panes[p.active].?; + const pane = p.panes[p.view().active].?; // Shown, a message asks for no wake. - try std.testing.expect(p.executeBuiltinLine(p.active, "Msg hello")); + try std.testing.expect(p.executeBuiltinLine(p.view().active, "Msg hello")); try std.testing.expectEqual(Pane.MessagePhase.shown, pane.msg_life.phase); try std.testing.expectEqual(@as(?u64, null), p.nextWake()); // A key starts the 800 ms linger: the core sleeps to its end, not a @@ -898,8 +898,8 @@ test "an idle core wants no wake and a lingering message sleeps to its linger's // A long linger ends when it says, jumped in one step, not stretched by // the cap on catching up with moving frames. - try std.testing.expect(p.executeBuiltinLine(p.active, "MessageLinger 5000")); - try std.testing.expect(p.executeBuiltinLine(p.active, "Msg again")); + try std.testing.expect(p.executeBuiltinLine(p.view().active, "MessageLinger 5000")); + try std.testing.expect(p.executeBuiltinLine(p.view().active, "Msg again")); p.update(.{ .key = .{ .cp = 'x' } }); const long_due = p.clock.stepped_ns + messageFrames(5000) * frame; try std.testing.expectEqual(@as(?u64, long_due), p.nextWake()); |
