summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/Layer.zig8
-rw-r--r--src/Messages.zig251
-rw-r--r--src/builtins.zig2
-rw-r--r--src/config.zig48
-rw-r--r--src/draw.zig16
-rw-r--r--src/gui/gui.zig34
-rw-r--r--src/panes.zig9
7 files changed, 64 insertions, 304 deletions
diff --git a/src/Layer.zig b/src/Layer.zig
index c5125a81..3522fce8 100644
--- a/src/Layer.zig
+++ b/src/Layer.zig
@@ -70,14 +70,6 @@ cells: []pardes.Cell = &.{},
cursor: ?struct { x: u16, y: u16, bar: bool = false } = null,
/// A band's fill, where its cells run out.
bg: [3]u8 = .{ 0, 0, 0 },
-/// Vertical offset in rows (negative: above its viewport), for a band
-/// that is moving into place. A pixel shell draws it offset and clipped
-/// to the rows below the viewport's top; the grid has no such thing.
-slide: f32 = 0,
-/// How present a notice band is (1 = fully) while it fades up or
-/// dissolves. `bg` and the cells are already blended by it; a pixel
-/// shell uses it for what it draws around the band, like its rule.
-fade: f32 = 1,
/// Tag columns a viewport this wide holds at the tagline's pitch.
pub fn capacity(layer: *const Layer, metrics: Metrics) u16 {
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);
}
diff --git a/src/builtins.zig b/src/builtins.zig
index bb3a167b..cbde62da 100644
--- a/src/builtins.zig
+++ b/src/builtins.zig
@@ -244,7 +244,7 @@ pub const registry = struct {
// a switch flips bare, a choice steps, and DumpDir and Shell bare
// are the default
.toggle, .dump_dir, .choice, .motion, .shell => false,
- .theme, .font, .tagline_size, .window_opacity, .window_blur, .message_ms, .inactive_dim, .grip_width => true,
+ .theme, .font, .tagline_size, .window_opacity, .window_blur, .message_linger, .inactive_dim, .grip_width => true,
// bare, it says the current value (exec.applySettingBuiltin)
.tab, .callstack_depth, .search_rows => false,
};
diff --git a/src/config.zig b/src/config.zig
index dbe4e9b7..9a7e6848 100644
--- a/src/config.zig
+++ b/src/config.zig
@@ -158,10 +158,7 @@ pub const leader_path = paths: {
table.set(.Font, null);
table.set(.TaglineSize, null);
}
- table.set(.MessageAnimation, null);
table.set(.MessageLinger, null);
- table.set(.MessageFall, null);
- table.set(.MessageDissolve, null);
table.set(.DumpDir, null);
if (builtins.capabilities.window_opacity) table.set(.WindowOpacity, null);
if (builtins.capabilities.window_blur) table.set(.WindowBlur, null);
@@ -365,8 +362,7 @@ pub const wheel_cols: i32 = 4;
pub const look_preview_delay_frames: u16 = 2;
-/// The longest any message timing (MessageLinger, MessageFall,
-/// MessageDissolve) may be set to, in milliseconds.
+/// The longest MessageLinger may be set to, in milliseconds.
pub const message_ms_max: u16 = 60_000;
// Tag fonts keep body-cell geometry; valid sizes are 1...100 percent.
@@ -725,8 +721,6 @@ pub const Runtime = struct {
/// Builtins announce themselves on the message row.
verbose: bool = true,
- /// A message falls into its row and dissolves out of it.
- message_animation: bool = true,
/// The cursor blinks, a pixel shell's (docs/render-pipeline.md §5.4):
/// solid while typing and for half a second after, eased at each edge,
/// solid again after ten idle seconds.
@@ -739,12 +733,6 @@ pub const Runtime = struct {
program_esc: bool = false,
/// How long a message stays after the key or click that dismisses it.
message_linger_ms: u16 = 800,
- /// How long its fall into the row takes, easing out (§8.1: arriving,
- /// 150 to 220 ms).
- message_fall_ms: u16 = 180,
- /// How long its dissolve takes, easing in: leaving is quicker than
- /// arriving (§8.1: 100 to 160 ms).
- message_dissolve_ms: u16 = 150,
/// Where Dump writes and a relative Restore looks; empty is the default
/// ($XDG_DATA_HOME/pardes, else ~/.local/share/pardes).
dump_dir: Text(limits.host_path_cap) = .{},
@@ -879,10 +867,7 @@ pub const Runtime = struct {
pub const Capability = std.meta.FieldEnum(Capabilities);
- /// The message timings a setting word sets, each in milliseconds.
- pub const MessageTime = enum { linger, fall, dissolve };
-
- pub const Toggle = enum { colors, wrap, tree_context_tag_style, tag_bottom, debug, focus_tint, syntax_bold, pager_color, verbose, message_animation, ligatures, cursor_blink, jump_trail, program_esc };
+ pub const Toggle = enum { colors, wrap, tree_context_tag_style, tag_bottom, debug, focus_tint, syntax_bold, pager_color, verbose, ligatures, cursor_blink, jump_trail, program_esc };
pub const Action = union(enum) {
toggle: Toggle,
@@ -892,7 +877,7 @@ pub const Runtime = struct {
tagline_size,
window_opacity,
window_blur,
- message_ms: MessageTime,
+ message_linger,
dump_dir,
/// A motion flavour.
motion,
@@ -948,7 +933,6 @@ pub const Runtime = struct {
.{ .word = "FocusTint", .action = .{ .toggle = .focus_tint }, .doc = "The focused pane's and column's tags are tinted, on or off." },
.{ .word = "SyntaxBold", .action = .{ .toggle = .syntax_bold }, .doc = "Keywords and the like are drawn bold, on or off." },
.{ .word = "Verbose", .action = .{ .toggle = .verbose }, .doc = "A builtin says its own name on the message row as it runs, on or off." },
- .{ .word = "MessageAnimation", .action = .{ .toggle = .message_animation }, .doc = "A message falls into its row and dissolves out of it, on or off." },
.{ .word = "Ligatures", .action = .{ .toggle = .ligatures }, .doc = "A font's programming ligatures draw across their cells, on or off." },
.{ .word = "CursorBlink", .action = .{ .toggle = .cursor_blink }, .doc = "The cursor blinks, solid while typing, on or off." },
.{ .word = "JumpTrail", .action = .{ .toggle = .jump_trail }, .doc = "A jump of the cursor leaves a short trail that fades, on or off." },
@@ -957,9 +941,7 @@ pub const Runtime = struct {
.{ .word = "GripWidth", .action = .grip_width, .doc = "The grip and scrollbar width, as a percent of the theme's rail." },
.{ .word = "InactiveDim", .action = .inactive_dim, .doc = "Fade the unfocused panes' text by a percentage, 0 through 100, 0 off." },
.{ .word = "Pet", .action = .{ .choice = .pet }, .doc = "The window's companion in the workspace tag's blank space: off, cat or frog." },
- .{ .word = "MessageLinger", .action = .{ .message_ms = .linger }, .doc = "How long, in milliseconds, a message stays after what dismisses it." },
- .{ .word = "MessageFall", .action = .{ .message_ms = .fall }, .doc = "How long, in milliseconds, a message takes to fall into its row." },
- .{ .word = "MessageDissolve", .action = .{ .message_ms = .dissolve }, .doc = "How long, in milliseconds, a message takes to dissolve." },
+ .{ .word = "MessageLinger", .action = .message_linger, .doc = "How long, in milliseconds, a message stays after what dismisses it." },
.{ .word = "DumpDir", .action = .dump_dir, .doc = "The directory Dump writes to and a relative Restore reads from; bare, the default." },
.{ .word = "Theme", .action = .theme, .doc = "Switch to the named theme." },
.{ .word = "Shell", .action = .shell, .doc = "The shell new terminals run; bare, $SHELL if it is executable, else /bin/sh." },
@@ -1045,12 +1027,7 @@ pub const Runtime = struct {
}
if (!state.dump_dir.set(text)) return false;
},
- .message_ms => |which| {
- const ms = number(u16, argument, " \t\r\n", 0, message_ms_max) orelse return false;
- switch (which) {
- inline else => |w| @field(state, "message_" ++ @tagName(w) ++ "_ms") = ms,
- }
- },
+ .message_linger => state.message_linger_ms = number(u16, argument, " \t\r\n", 0, message_ms_max) orelse return false,
// Bare, it steps to the next word, as a tag word should.
.choice => |which| switch (which) {
inline else => |field| {
@@ -1100,7 +1077,7 @@ pub const Runtime = struct {
.callstack_depth => "1-64 (levels)",
.search_rows => "1-100 (rows)",
.tagline_size => std.fmt.comptimePrint("{d}-{d} (a percentage)", .{ tagline_percent_min, tagline_percent_max }),
- .message_ms => std.fmt.comptimePrint("0-{d} (milliseconds)", .{message_ms_max}),
+ .message_linger => std.fmt.comptimePrint("0-{d} (milliseconds)", .{message_ms_max}),
.shell => "a path of at most 255 bytes; bare, $SHELL, else /bin/sh",
.dump_dir => std.fmt.comptimePrint("an absolute or ~ path of at most {d} bytes, to a directory that may be written; bare, the default", .{limits.host_path_cap}),
.font => "a name or path, :8 to :72 after it (Mono:14)",
@@ -1193,9 +1170,7 @@ pub const Runtime = struct {
const dir = if (state.dump_dir.len > 0) state.dump_dir.get() else context.default_dump_dir;
if (dir.len > 0) try out.print("{s} {s}\n", .{ setting.word, dir }) else try out.print("# {s} (none)\n", .{setting.word});
},
- .message_ms => |which| try out.print("{s} {d}\n", .{ setting.word, switch (which) {
- inline else => |w| @field(state, "message_" ++ @tagName(w) ++ "_ms"),
- } }),
+ .message_linger => try out.print("{s} {d}\n", .{ setting.word, state.message_linger_ms }),
.shell => {
const chosen = state.shell.requested.get();
try out.print("{s} {s}\n", .{ setting.word, if (chosen.len == 0) context.compiled_default_shell else chosen });
@@ -1393,11 +1368,10 @@ pub const Runtime = struct {
};
const values = [_][2][]const u8{
.{ "TaglineSize", "73" }, .{ "WindowOpacity", "85" }, .{ "WindowBlur", "40" },
- .{ "MessageLinger", "1500" }, .{ "MessageFall", "1500" }, .{ "MessageDissolve", "1500" },
- .{ "DumpDir", "~/dumps" }, .{ "TermImages", "petscii" }, .{ "JumpScope", "all" },
- .{ "SearchPlace", "column" }, .{ "SearchPane", "new" }, .{ "Motion", "playful" },
- .{ "GripWidth", "200" }, .{ "InactiveDim", "35" }, .{ "CallstackDepth", "16" },
- .{ "Tab", "8" }, .{ "SearchRows", "12" },
+ .{ "MessageLinger", "1500" }, .{ "DumpDir", "~/dumps" }, .{ "TermImages", "petscii" },
+ .{ "JumpScope", "all" }, .{ "SearchPlace", "column" }, .{ "SearchPane", "new" },
+ .{ "Motion", "playful" }, .{ "GripWidth", "200" }, .{ "InactiveDim", "35" },
+ .{ "CallstackDepth", "16" }, .{ "Tab", "8" }, .{ "SearchRows", "12" },
};
for (values) |v| try std.testing.expect(apply(&state, find(v[0]).?, v[1]));
try std.testing.expect(state.font.requested_name.set("Wanted Mono"));
diff --git a/src/draw.zig b/src/draw.zig
index d299b03f..55fab141 100644
--- a/src/draw.zig
+++ b/src/draw.zig
@@ -752,8 +752,6 @@ fn renderHeaderLayer(p: *Pardes, layer: *pardes.Layer, kind: TagKind, id: u16, v
layer.context_rows = 0;
layer.bg = bg;
layer.cursor = null;
- layer.slide = 0;
- layer.fade = 1;
// A notice band carries a PANE id, not a column index, so it must not
// answer to the column being edited -- that would scroll and select
// its text with the column tag's offsets and give it a second caret.
@@ -870,8 +868,6 @@ fn joinPaneTag(p: *Pardes, s: *Surface, arena: std.mem.Allocator, pane: *Pane, r
layer.rows = rows;
layer.context_rows = 0;
layer.bg = if (p.window_pick == id) p.theme().sel_bg else if (active and p.settings.focus_tint) chrome.tag_active_bg else chrome.tag_bg;
- layer.slide = 0;
- layer.fade = 1;
layer.cursor = if (p.header_focus) null else if (temporary.cursor) |cursor|
.{ .x = cursor.x - TAG_TEXT_INSET, .y = cursor.y, .bar = cursor.bar }
else
@@ -892,7 +888,6 @@ fn joinPaneTag(p: *Pardes, s: *Surface, arena: std.mem.Allocator, pane: *Pane, r
/// grid's chip a copy of its right end, where its text is.
fn joinNotice(p: *Pardes, s: *Surface, arena: std.mem.Allocator, region: Region) !void {
const chrome = p.chromeTheme();
- const th = p.theme();
const id: usize = region.owner;
const pane = p.panes[id].?;
const i: usize = region.notice;
@@ -901,15 +896,10 @@ fn joinNotice(p: *Pardes, s: *Surface, arena: std.mem.Allocator, region: Region)
const chip = region.rect.w;
var leader_buf: [16]u8 = undefined;
const text = Messages.noticeText(p, pane, i, &leader_buf);
- // A message coming or going blends toward the page it sits on; a grid
- // cannot move it by less than a row, a pixel shell slides it too.
- const motion: Messages.MessageMotion = if (Messages.noticeLife(pane, i)) |life| Messages.messageMotion(p, life) else .{};
- const page = th.bg orelse chrome.tag_bg;
- const bg = colors.lerp(page, chrome.tag_bg, motion.alpha);
+ const bg = chrome.tag_bg;
// Where an exec was sent to a REPL reads in the tag's name tint, set
// apart from what the editor says.
- const ink = if (kind == .message and pane.msg_sent) chrome.tag_name_fg else chrome.tag_fg;
- const fg = colors.lerp(page, ink, motion.alpha);
+ const fg = if (kind == .message and pane.msg_sent) chrome.tag_name_fg else chrome.tag_fg;
// Nothing to say, or too narrow for a layer: a blank chip on the grid.
if (text.len == 0 or r.w <= TAG_TEXT_INSET) {
s.fill(region.rect.x, region.rect.y, chip, 1, .{ .bg = .{ .rgb = bg }, .font_role = .tagline });
@@ -941,8 +931,6 @@ fn joinNotice(p: *Pardes, s: *Surface, arena: std.mem.Allocator, region: Region)
@memcpy(line[pad..], kept);
const layer = &s.tag_layers[NOTICE_LAYER_BASE + id * Pane.Notices.max + i];
try renderHeaderLayer(p, layer, .notice, @intCast(id), region.rect, line, 0, bg, fg);
- layer.slide = motion.slide;
- layer.fade = motion.alpha;
// The caret rides the band, where the prompt's glyphs are.
if (kind == .prompt and id == p.active and pane.prompt != .del_side and pane.prompt != .repl_choice) caret: {
const typed = panes.File.displayWidth(text[0..@min(@as(usize, @intCast(@max(0, pane.input.cur_col))), text.len)]);
diff --git a/src/gui/gui.zig b/src/gui/gui.zig
index 01a58eae..a81f029f 100644
--- a/src/gui/gui.zig
+++ b/src/gui/gui.zig
@@ -5548,13 +5548,7 @@ fn renderFrame(
if (layer.rows == 0) continue;
// A notice floats over the panes.
const group_index = if (layer.kind == .notice) groups.notices else 0;
- const start = cell_next[group_index];
emitTagLayer(g, instances, &cell_next[group_index], layer, win_w, win_h, page, cursors_shown);
- // A notice dropping past its row (a flavour's overshoot) stays
- // inside its pane's body.
- if (layer.kind == .notice and layer.slide > 0) if (bodyBottom(surface, layer.id, layout)) |bottom| {
- for (instances[start..cell_next[group_index]]) |*instance| clipInstance(instance, .{ -1e9, -1e9, 1e9, bottom }, win_w, win_h);
- };
}
for (groups.items[0..groups.len], 0..) |group, index|
std.debug.assert(cell_next[index] == group.cell_start + group.cell_count);
@@ -5809,14 +5803,6 @@ test "the layer cover is the per-cell layer scan, over a core's layouts and rand
}
}
-/// The bottom of pane `owner`'s body, in window pixels.
-fn bodyBottom(surface: *const pardes.Surface, owner: u16, layout: CellLayout) ?f32 {
- for (surface.regionList()) |region| {
- if (region.kind == .body and region.owner == owner) return @as(f32, @floatFromInt(region.rect.y + region.rect.h)) * layout.h;
- }
- return null;
-}
-
fn tagLayerCellCount(g: *const Gui, layer: *const pardes.Layer) u32 {
const pixels = @as(u32, layer.viewport.w) * g.cell_w;
return @min(layer.cols, (pixels + g.tagline_width - 1) / g.tagline_width);
@@ -5829,9 +5815,6 @@ fn emitTagLayer(g: *Gui, instances: [*]CellInstance, next: *u32, layer: *const p
const left = @as(f32, @floatFromInt(layer.viewport.x)) * bw;
const right = left + @as(f32, @floatFromInt(layer.viewport.w)) * bw;
const background: pardes.Cell = .{ .default = false, .style = .{ .bg = .{ .rgb = layer.bg } } };
- // A band sliding into place is drawn offset and cut at its row's top, so
- // it comes out from under whatever is above it.
- const slide = layer.slide * bh;
// A window is rarely a whole number of cells wide: a band that ends at
// the last column runs on through the leftover pixels to the edge.
const band_right = if (win_w - right < bw) @max(right, win_w) else right;
@@ -5839,16 +5822,14 @@ fn emitTagLayer(g: *Gui, instances: [*]CellInstance, next: *u32, layer: *const p
// A row to each line, each a grid row with the tagline's glyphs.
for (0..layer.rows) |index| {
const y = layer.viewport.y + @as(u16, @intCast(index));
- const top = @as(f32, @floatFromInt(y)) * bh;
- emitInstance(g, instances, next.*, 0, y, .{ .w = band_right - left, .h = bh, .x_off = left, .y_off = slide }, win_w, win_h, .body, (&background)[0..1], 0, null, false, page);
- if (slide != 0) clipInstance(&instances[next.*], .{ -1e9, top, 1e9, 1e9 }, win_w, win_h);
+ emitInstance(g, instances, next.*, 0, y, .{ .w = band_right - left, .h = bh, .x_off = left, .y_off = 0 }, win_w, win_h, .body, (&background)[0..1], 0, null, false, page);
next.* += 1;
const cells = layer.cells[index * layer.cols ..][0..layer.cols];
const line_cursor: ?usize = if (layer.cursor) |cu| (if (cu.y == index) cu.x else null) else null;
for (0..tagLayerCellCount(g, layer)) |col| {
const cursor = if (layer.cursor) |cu| show_cursor and !cu.bar and cu.x == col and cu.y == index else false;
- emitInstance(g, instances, next.*, @intCast(col), y, .{ .w = tw, .h = bh, .x_off = left, .y_off = slide }, win_w, win_h, .tagline, cells, col, line_cursor, cursor, page);
- clipInstance(&instances[next.*], .{ -1e9, if (slide != 0) top else -1e9, right, 1e9 }, win_w, win_h);
+ emitInstance(g, instances, next.*, @intCast(col), y, .{ .w = tw, .h = bh, .x_off = left, .y_off = 0 }, win_w, win_h, .tagline, cells, col, line_cursor, cursor, page);
+ clipInstance(&instances[next.*], .{ -1e9, -1e9, right, 1e9 }, win_w, win_h);
if (faded and !cursor) dim.fade(&instances[next.*]);
next.* += 1;
}
@@ -7521,18 +7502,15 @@ fn buildDecor(g: *Gui, gpa: std.mem.Allocator, surface: *const pardes.Surface, g
// A notice chip is tagline hung over the body's top rows, so it is
// ruled off from the text beneath it the way a tag is: the same
// colour and thickness along its bottom, running to the window's
- // edge when it does, fading up and dissolving with its band.
+ // edge when it does.
if (index == groups.notices) for (surface.tagLayers()) |*layer| {
if (layer.rows == 0 or layer.kind != .notice) continue;
const x0 = @as(f32, @floatFromInt(layer.viewport.x)) * layout.w;
const x1 = x0 + @as(f32, @floatFromInt(layer.viewport.w)) * layout.w;
const rule_x1 = if (win_w - x1 < layout.w) @max(x1, win_w) else x1;
const top = @as(f32, @floatFromInt(layer.viewport.y)) * layout.h;
- // A band still falling into place is cut at its row's top; its
- // rule comes with it, and shows only once it is below that cut.
- const rule_y = top + (1 + layer.slide) * layout.h;
- if (rule_y - dp(1) < top) continue;
- try addDecor(g, gpa, x0, rule_y - dp(1), rule_x1, rule_y, chrome.border, layer.fade, win_w, win_h);
+ const rule_y = top + layout.h;
+ try addDecor(g, gpa, x0, rule_y - dp(1), rule_x1, rule_y, chrome.border, 1, win_w, win_h);
};
if (index == groups.ink and cursors_shown) try cursorDecor(g, gpa, surface, layout, win_w, win_h);
}
diff --git a/src/panes.zig b/src/panes.zig
index 95917b42..73a0fc9e 100644
--- a/src/panes.zig
+++ b/src/panes.zig
@@ -309,15 +309,12 @@ pub const Pane = struct {
/// that view's focus leaving the pane drops it.
prompt_view: u8 = 0,
- pub const MessagePhase = enum { entering, shown, lingering, leaving };
- /// One message line's animation: falling in, shown, lingering after the
- /// key or click that dismissed it, dissolving. `frame` counts animation
- /// frames within the phase.
+ pub const MessagePhase = enum { shown, lingering };
+ /// One message line's life: shown, or lingering after the key or click
+ /// that dismissed it, `frame` frames of its linger gone.
pub const MessageLife = struct {
phase: MessagePhase = .shown,
frame: u16 = 0,
- /// Dismissed while still falling: it lingers once it has landed.
- dismissed: bool = false,
};
/// Older message lines kept on screen under a new one.
pub const message_stack = 3;