diff options
Diffstat (limited to 'src/Messages.zig')
| -rw-r--r-- | src/Messages.zig | 251 |
1 files changed, 41 insertions, 210 deletions
diff --git a/src/Messages.zig b/src/Messages.zig index 98e005be..0ab10dab 100644 --- a/src/Messages.zig +++ b/src/Messages.zig @@ -1,5 +1,5 @@ //! The message row: messages and statuses a pane shows between its body and -//! its tagline, how each line falls in, lingers and dissolves, the notices +//! its tagline, how each line lingers once dismissed, the notices //! built from them every frame, and the log of everything said. const pardes = @import("pardes.zig"); const memory = @import("memory.zig"); @@ -189,23 +189,14 @@ fn showMessage(p: *Pardes, id: usize, text: []const u8, stack: bool) void { pane.msg_announcement = false; pane.msg_sent = false; pane.msg_status = !stack; - const arrives = pane.msg_len == 0 or pane.msg_life.phase == .leaving; for (text[0..n], pane.msg[0..n]) |c, *cell| cell.* = if (c < 0x20 or c == 0x7f) ' ' else c; pane.msg_len = @intCast(n); // The clock when it was said (the session clock is the last pump's, // and a 9P write after an idle hour would say it an hour ago). pane.msg_said_ms = pardes.tape.value(.clock, nowMs, .{}); p.needs_frame = true; - if (arrives) { - pane.msg_life = .{ .phase = if (p.settings.message_animation and n > 0) .entering else .shown }; - } else if (pane.msg_life.phase == .lingering or - (pane.msg_life.phase == .entering and !p.settings.message_animation)) - { - // The same line again, or a status update: fresh, so it stays. - pane.msg_life = .{}; - } else { - pane.msg_life.dismissed = false; - } + // New, the same line again or a status update: fresh, so it stays. + pane.msg_life = .{}; } /// With no frontend attached no input dismisses a message, and a detached @@ -239,8 +230,8 @@ pub fn expireUnattended(p: *Pardes) void { } /// The key or click that used to clear the message row now starts each -/// line's exit: it stays `message_linger_ms`, then dissolves. A line -/// already on its way out keeps its own timing. +/// line's exit: it stays `message_linger_ms`, then goes. A line already +/// on its way out keeps its own timing. pub fn dismissMessage(p: *Pardes, pane: *Pane) void { if (pane.msg_len > 0 and dismissLine(p, &pane.msg_life)) { pane.msg_len = 0; @@ -252,30 +243,16 @@ pub fn dismissMessage(p: *Pardes, pane: *Pane) void { } } -/// Start one line's exit; true when it is gone at once (no linger, no -/// animation). +/// Start one line's exit; true when it is gone at once (no linger). fn dismissLine(p: *const Pardes, life: *Pane.MessageLife) bool { - switch (life.phase) { - .lingering, .leaving => return false, - // A falling line lands first, then lingers -- unless falling was - // just turned off, and nothing will land it. - .entering => if (p.settings.message_animation) { - life.dismissed = true; - return false; - }, - .shown => {}, - } - life.frame = 0; - if (p.settings.message_linger_ms > 0) { - life.phase = .lingering; - } else if (p.settings.message_animation) { - life.phase = .leaving; - } else return true; + if (life.phase == .lingering) return false; + if (p.settings.message_linger_ms == 0) return true; + life.* = .{ .phase = .lingering }; return false; } -/// One animation frame of every message line. Each one that moves owes -/// a frame, the one that finishes included: a tick asks for none itself. +/// One frame of every lingering message line. The one that goes owes a +/// frame: a tick asks for none itself. pub fn advanceMessages(p: *Pardes) void { for (p.panes) |slot| { const pane = slot orelse continue; @@ -294,22 +271,11 @@ pub fn advanceMessages(p: *Pardes) void { } } -/// One frame of one line's life; true once it has left. +/// One frame of one line's life; true once it has gone. fn advanceLine(p: *const Pardes, life: *Pane.MessageLife) bool { if (life.phase == .shown) return false; life.frame +|= 1; - switch (life.phase) { - .shown => {}, - .entering => if (life.frame >= messageFrames(p.settings.message_fall_ms)) { - life.* = .{ .phase = if (life.dismissed) .lingering else .shown }; - }, - .lingering => if (life.frame >= messageFrames(p.settings.message_linger_ms)) { - if (!p.settings.message_animation) return true; - life.* = .{ .phase = .leaving }; - }, - .leaving => if (life.frame >= messageFrames(p.settings.message_dissolve_ms)) return true, - } - return false; + return life.frame >= messageFrames(p.settings.message_linger_ms); } /// Move every lingering message line `frames` along its linger at once: @@ -325,68 +291,25 @@ pub fn holdMessages(p: *Pardes, frames: u64) void { } } -/// Frames until this pane's message lines next change: 1 while a line -/// falls in or dissolves, the rest of its linger while one only waits, null -/// when every line just shows. +/// Frames until this pane's message lines next change: the rest of a +/// linger, null when every line just shows. pub fn messageWake(p: *const Pardes, pane: *const Pane) ?u64 { var soonest: ?u64 = null; const linger = messageFrames(p.settings.message_linger_ms); for (0..@as(usize, pane.msg_older_len) + 1) |i| { const life = if (i < pane.msg_older_len) pane.msg_older[i].life else if (pane.msg_len > 0) pane.msg_life else continue; - const frames: u64 = switch (life.phase) { - .shown => continue, - .entering, .leaving => 1, - .lingering => @max(1, linger -| life.frame), - }; + if (life.phase == .shown) continue; + const frames: u64 = @max(1, linger -| life.frame); soonest = if (soonest) |n| @min(n, frames) else frames; } return soonest; } -/// How present a message is (1 = fully) and how far above its row it -/// still is (rows): a fall that decelerates into place with its colour -/// arriving ahead of it, and a dissolve. -pub const MessageMotion = struct { alpha: f32 = 1, slide: f32 = 0 }; - /// Animation frames a message timing lasts; at least one. pub fn messageFrames(ms: u16) u16 { return @intCast(@max(1, (@as(u32, ms) + animation.frame_ms - 1) / animation.frame_ms)); } -pub fn messageMotion(p: *const Pardes, life: Pane.MessageLife) MessageMotion { - const fall_frames = messageFrames(p.settings.message_fall_ms); - const dissolve_frames = messageFrames(p.settings.message_dissolve_ms); - return switch (life.phase) { - .shown, .lingering => .{ .alpha = 1, .slide = 0 }, - .entering => blk: { - const t = @as(f32, @floatFromInt(@min(life.frame, fall_frames))) / @as(f32, @floatFromInt(fall_frames)); - // Out of the gate fast and easing into its row (a cubic - // ease-out), so it is there the moment it is said and the - // last frames only settle it. No overshoot: at a row's height - // and a dozen frames, a follow-through is a pixel or two that - // reads as a jitter, not a bounce. - // The drop follows the Motion flavour (its wind-up, overshoot - // and all) over the fall's length. - const left = 1 - animation.Motion.of(p.settings.motion).ease(t); - // The colour leads the motion: solid by half way, so what - // lands is already legible rather than still fading up. - const faded = 1 - @min(1, 2 * t); - // And never behind it, however fast the flavour leaves. - break :blk .{ .alpha = @max(1 - faded * faded, std.math.clamp(1 - left, 0, 1)), .slide = -left }; - }, - .leaving => blk: { - // Counted to its last frame rather than past it, so that frame - // shows it gone and it never blinks out from part way. - const last = @max(1, dissolve_frames - 1); - const t = @as(f32, @floatFromInt(@min(life.frame, last))) / @as(f32, @floatFromInt(last)); - // An exit eases in: still readable for a beat, then away - // faster and faster. It stays where it is -- the lines - // stacked around it do not move either. - break :blk .{ .alpha = 1 - t * t, .slide = 0 }; - }, - }; -} - /// What notice band `i` says. The grid pass and the band layers both /// read it here, so a terminal and a pixel shell show the same line. pub fn noticeText(p: *const Pardes, pane: *const Pane, i: usize, leader_buf: *[16]u8) []const u8 { @@ -398,15 +321,6 @@ pub fn noticeText(p: *const Pardes, pane: *const Pane, i: usize, leader_buf: *[1 }; } -/// The life of the message line notice `i` shows, if it shows one. -pub fn noticeLife(pane: *const Pane, i: usize) ?Pane.MessageLife { - return switch (pane.notices.kinds[i]) { - .message => pane.msg_life, - .older => pane.msg_older[pane.notices.index[i]].life, - .leader, .prompt => null, - }; -} - fn logMessage(p: *Pardes, id: usize, text: []const u8) void { if (text.len == 0) return; const serial: u32 = if (p.fs.session_write) 0 else if (id < MAX_PANES) if (p.panes[id]) |pane| pane.serial else 0 else 0; @@ -707,13 +621,12 @@ test "Msg writes the transient row by hand, bare or with text, and input ends it try std.testing.expect(p.executeBuiltinLine(2, "Msg")); try std.testing.expectEqualStrings("Msg: no message", row(p, 2)); - // Input starts its exit: it lingers, dissolves, and is gone. + // Input starts its exit: it lingers, and is gone. p.update(.{ .key = .{ .cp = Key.escape } }); try std.testing.expectEqualStrings("Msg: no message", row(p, 2)); for (0..200) |_| p.update(.tick); try std.testing.expectEqualStrings("", row(p, 2)); - // ...and with neither linger nor animation it is as old as your last input. - try std.testing.expect(p.executeBuiltinLine(2, "MessageAnimation off")); + // ...and with no linger it is as old as your last input. try std.testing.expect(p.executeBuiltinLine(2, "MessageLinger 0")); try std.testing.expect(p.executeBuiltinLine(2, "Msg gone")); p.update(.{ .key = .{ .cp = 'h' } }); @@ -754,49 +667,16 @@ test "with no frontend attached a message goes once it has lingered, on the cloc try std.testing.expect(pane.msg_len > 0); } -test "a message falls in, lingers past the input that dismisses it, and dissolves" { +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.settings.message_animation); - // Crisp: the flavour whose drop leaves at full speed and lands without - // passing its row (the others are the Motion tests'). - p.settings.motion = .crisp; try std.testing.expect(p.executeBuiltinLine(p.active, "MessageLinger 160")); try std.testing.expect(p.executeBuiltinLine(p.active, "Msg hello")); - try std.testing.expectEqual(Pane.MessagePhase.entering, pane.msg_life.phase); - try std.testing.expect(p.animationActive()); - // An ease-out fall: starts a whole row up and unseen, covers most of the - // way at once and settles into its row, landing exactly on it without - // passing it. Its colour is whole by half way. - const start = messageMotion(p, pane.msg_life); - try std.testing.expectEqual(@as(f32, -1), start.slide); - try std.testing.expectEqual(@as(f32, 0), start.alpha); - const fall = messageFrames(p.settings.message_fall_ms); - var last = start; - var first_step: f32 = 0; - var last_step: f32 = 0; - for (0..fall) |frame| { - p.needs_frame = false; - p.update(.tick); - // Every tick that moves it owes a frame, the landing one included. - try std.testing.expect(p.needs_frame); - const now = messageMotion(p, pane.msg_life); - try std.testing.expect(now.slide >= last.slide and now.slide <= 0); - try std.testing.expect(now.alpha >= last.alpha); - if (frame == 0) first_step = now.slide - last.slide; - // Never slower to colour up than to arrive, and solid by half way. - try std.testing.expect(now.alpha >= 1 + now.slide); - if (2 * (frame + 1) >= fall) try std.testing.expectEqual(@as(f32, 1), now.alpha); - last_step = now.slide - last.slide; - last = now; - } - try std.testing.expect(first_step > 4 * last_step); + // 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.expectEqual(@as(f32, 0), messageMotion(p, pane.msg_life).slide); try std.testing.expect(!p.animationActive()); - // Shown until input, like always; the same line again does not re-enter. 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")); @@ -809,57 +689,24 @@ test "a message falls in, lingers past the input that dismisses it, and dissolve p.update(.{ .key = .{ .cp = 'h' } }); } try std.testing.expectEqual(Pane.MessagePhase.lingering, pane.msg_life.phase); + // ...then it is gone, and the tick that clears it owes the frame that + // shows it gone. + p.needs_frame = false; p.update(.tick); - // ...then an ease-in dissolve: it lets go slowly and goes faster and - // faster, in place, its last frame showing it gone. - try std.testing.expectEqual(Pane.MessagePhase.leaving, pane.msg_life.phase); - const dissolve = messageFrames(p.settings.message_dissolve_ms); - var alpha: f32 = 1; - var first_drop: f32 = 0; - var last_drop: f32 = 0; - for (0..dissolve) |frame| { - const now = messageMotion(p, pane.msg_life); - try std.testing.expect(now.alpha <= alpha); - try std.testing.expectEqual(@as(f32, 0), now.slide); - if (frame == 1) first_drop = alpha - now.alpha; - last_drop = alpha - now.alpha; - alpha = now.alpha; - p.needs_frame = false; - p.update(.tick); - } - try std.testing.expectEqual(@as(f32, 0), alpha); - try std.testing.expect(first_drop > 0 and first_drop < last_drop); try std.testing.expectEqual(@as(u16, 0), pane.msg_len); - try std.testing.expect(!p.animationActive()); - // The tick that clears it still owes the frame that shows it gone. try std.testing.expect(p.needs_frame); - - // Dismissed mid-fall: it lands, then lingers. + 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.expectEqual(Pane.MessagePhase.entering, pane.msg_life.phase); - p.update(.tick); p.update(.{ .key = .{ .cp = 'h' } }); - try std.testing.expectEqual(Pane.MessagePhase.entering, pane.msg_life.phase); - for (0..messageFrames(p.settings.message_fall_ms)) |_| p.update(.tick); try std.testing.expectEqual(Pane.MessagePhase.lingering, pane.msg_life.phase); - // Shown again while lingering: fresh, so it stays; a status update to a - // line on screen swaps its text in place instead of falling again. try std.testing.expect(p.executeBuiltinLine(p.active, "Msg again")); try std.testing.expectEqual(Pane.MessagePhase.shown, pane.msg_life.phase); setStatus(p, p.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); - // The fall and the dissolve are timings of their own, in milliseconds. - try std.testing.expect(p.executeBuiltinLine(p.active, "MessageFall 48")); - try std.testing.expect(p.executeBuiltinLine(p.active, "MessageDissolve 0")); - try std.testing.expectEqual(@as(u16, 3), messageFrames(p.settings.message_fall_ms)); - try std.testing.expectEqual(@as(u16, 1), messageFrames(p.settings.message_dissolve_ms)); - // The DumpConfig report reads back as configuration. - try std.testing.expect(p.executeBuiltinLine(p.active, "MessageAnimation")); - try std.testing.expect(!p.settings.message_animation); - try std.testing.expect(p.executeBuiltinLine(p.active, "Msg plain")); - try std.testing.expectEqual(Pane.MessagePhase.shown, pane.msg_life.phase); } test "messages stack, oldest on top, each on its own timing" { @@ -869,37 +716,35 @@ test "messages stack, oldest on top, each on its own timing" { 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")); - // A dissolve longer than a fall, so the second is caught mid-way. - try std.testing.expect(p.executeBuiltinLine(p.active, "MessageDissolve 300")); // `Verbose off` announced itself before it took effect. pane.msg_len = 0; pane.msg_life = .{}; - const fall = messageFrames(p.settings.message_fall_ms); setMessage(p, p.active, "first"); - for (0..fall) |_| p.update(.tick); 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"); 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]); - try std.testing.expectEqual(Pane.MessagePhase.entering, pane.msg_life.phase); collectNotices(p, pane, p.rects[p.active], p.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, but each runs its own clock: the first starts - // lingering now, the second only once it has landed. + // One key dismisses both, each on its own clock: a line already + // lingering keeps its timing. p.update(.{ .key = .{ .cp = 'h' } }); try std.testing.expectEqual(Pane.MessagePhase.lingering, pane.msg_older[0].life.phase); - try std.testing.expectEqual(Pane.MessagePhase.entering, pane.msg_life.phase); + try std.testing.expectEqual(Pane.MessagePhase.lingering, pane.msg_life.phase); + p.update(.tick); + setMessage(p, p.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); - const dissolve = messageFrames(p.settings.message_dissolve_ms); - for (0..linger + dissolve) |_| p.update(.tick); - // The first is gone; the second, a fall later, is still dissolving. + for (0..linger - 1) |_| p.update(.tick); + // The first two are gone; the third, a frame later, still lingers. try std.testing.expectEqual(@as(u8, 0), pane.msg_older_len); - try std.testing.expectEqualStrings("second", pane.msg[0..pane.msg_len]); - try std.testing.expectEqual(Pane.MessagePhase.leaving, pane.msg_life.phase); - for (0..fall) |_| p.update(.tick); + try std.testing.expectEqualStrings("third", pane.msg[0..pane.msg_len]); + try std.testing.expectEqual(Pane.MessagePhase.lingering, pane.msg_life.phase); + p.update(.tick); 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. @@ -1033,11 +878,8 @@ test "an idle core wants no wake and a lingering message sleeps to its linger's p.advance(1_000_000); try std.testing.expectEqual(@as(?u64, null), p.nextWake()); const pane = p.panes[p.active].?; + // Shown, a message asks for no wake. try std.testing.expect(p.executeBuiltinLine(p.active, "Msg hello")); - // Falling in: a frame from now. - try std.testing.expectEqual(@as(?u64, p.stepped_ns + frame), p.nextWake()); - const fall = messageFrames(p.settings.message_fall_ms); - p.advance(p.stepped_ns + fall * frame); 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 @@ -1052,9 +894,6 @@ test "an idle core wants no wake and a lingering message sleeps to its linger's try std.testing.expectEqual(@as(?u64, due), p.nextWake()); try std.testing.expectEqual(Pane.MessagePhase.lingering, pane.msg_life.phase); p.advance(due); - try std.testing.expectEqual(Pane.MessagePhase.leaving, pane.msg_life.phase); - try std.testing.expectEqual(@as(?u64, due + frame), p.nextWake()); - p.advance(due + 10 * std.time.ns_per_s); try std.testing.expectEqual(@as(usize, 0), pane.msg_len); try std.testing.expectEqual(@as(?u64, null), p.nextWake()); @@ -1062,17 +901,9 @@ test "an idle core wants no wake and a lingering message sleeps to its linger's // 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")); - p.advance(p.stepped_ns + fall * frame); p.update(.{ .key = .{ .cp = 'x' } }); const long_due = p.stepped_ns + messageFrames(5000) * frame; try std.testing.expectEqual(@as(?u64, long_due), p.nextWake()); p.advance(long_due); - try std.testing.expectEqual(Pane.MessagePhase.leaving, pane.msg_life.phase); -} - -test "a notice leaves quicker than it arrives, each within its ยง8.1 band" { - const settings: config.Runtime = .{}; - try std.testing.expect(settings.message_dissolve_ms < settings.message_fall_ms); - try std.testing.expect(settings.message_fall_ms >= 150 and settings.message_fall_ms <= 220); - try std.testing.expect(settings.message_dissolve_ms >= 100 and settings.message_dissolve_ms <= 160); + try std.testing.expectEqual(@as(usize, 0), pane.msg_len); } |
