summaryrefslogtreecommitdiff
path: root/src/replica.zig
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-04 20:17:40 -0300
committerGabriel Schneider <[email protected]>2026-11-04 20:17:40 -0300
commita41360e3b9699268d73d598c6eb0155875d3a149 (patch)
treeab4a798f198cce4f421af1bd3d6ce9490767a8b6 /src/replica.zig
parent99d0bf3669a939fb09ac4ae5a0b2ddbace3d3f63 (diff)
downloadpardes-a41360e3b9699268d73d598c6eb0155875d3a149.tar.gz
pardes-a41360e3b9699268d73d598c6eb0155875d3a149.zip
Improve macOS detached client gestures and rendering
Add a thin AppKit input adapter for SDL trackpad momentum, multi-finger and force clicks, deliberate pinch zoom, rotation haptics, and shorter history swipes with early haptic cues. Keep remote cursor motion on the frontend clock, resolve configured fonts locally, follow terminal directories without an authority window, and render live tagline themes without waiting for daemon ticks. Validate with native GUI and TUI release builds, trackpad policy and adapter tests, targeted scroll and replica theme regressions, live remote digest checks, visual theme switching, and user trackpad testing.
Diffstat (limited to 'src/replica.zig')
-rw-r--r--src/replica.zig149
1 files changed, 148 insertions, 1 deletions
diff --git a/src/replica.zig b/src/replica.zig
index 155492c3..95ccb58f 100644
--- a/src/replica.zig
+++ b/src/replica.zig
@@ -600,6 +600,9 @@ pub const Replica = struct {
/// Its predicted echo (src/echo.zig), drawn over its core's terminals:
/// fed by its keys, its units and its deltas here, and by `echoFrame`.
echo: pardes.echo.Echo = .{},
+ /// The frontend's cursor and focus springs, never rewound by a copy.
+ motion: pardes.views.RenderMotion = .{},
+ frame_input_ns: ?u64 = null,
const ScreenOf = struct {
serial: u32,
@@ -659,6 +662,9 @@ pub const Replica = struct {
pardes.dump.terminal_gpa = terminal.emulator_gpa;
defer pardes.dump.terminal_gpa = null;
const c = try pardes.dump.load(epoch, o, bytes, null);
+ // Chrome animation is local drawing state, omitted from a join's
+ // dump. Its initial colours must follow the restored theme too.
+ c.chrome_animation.snap(pardes.colors.ChromeTheme.fromTheme(c.theme()));
// What loading queued (a watch, a theme asked for) is the
// authority's errand, done there already: the session was dumped
// between steps, with nothing queued.
@@ -707,6 +713,7 @@ pub const Replica = struct {
/// The replica's own input: applied at once when it can be, and the
/// message for the authority returned (valid until the next call).
pub fn input(r: *Replica, ev: pardes.Event) ![]const u8 {
+ if (ev == .key or ev == .paste or (ev == .mouse and ev.mouse.kind != .motion)) r.frame_input_ns = nowNs();
r.stats.inputs += 1;
const seq = r.next_seq;
r.next_seq += 1;
@@ -1041,9 +1048,20 @@ pub const Replica = struct {
/// (views.drawOne): nothing the digest covers moves. The epoch's trees
/// held while a copy is (a render can make or drop a syntax tree).
pub fn draw(r: *Replica, present: pardes.views.Present) void {
+ r.drawAt(present, nowNs());
+ }
+
+ /// Only presentation reads this clock. It never advances the session
+ /// or sends ticks, so a quiet daemon cannot hold a cursor mid-glide.
+ pub fn drawAt(r: *Replica, present: pardes.views.Present, now_ns: u64) void {
rollback.Epoch.select(&r.epoch);
defer rollback.Epoch.select(null);
- pardes.views.drawOne(r.core(), r.view, present) catch {};
+ if (r.frame_input_ns == null) r.frame_input_ns = now_ns;
+ pardes.views.drawOneAt(r.core(), r.view, present, &r.motion, now_ns, r.frame_input_ns.?) catch {};
+ }
+
+ pub fn animating(r: *const Replica) bool {
+ return pardes.views.motionActive(&r.motion);
}
/// `f(ctx, core)` with its own view live, outside any step, as `draw`
@@ -3095,6 +3113,102 @@ fn key(r: *Replica, cp: u21, sent: *std.ArrayListUnmanaged([]u8)) !void {
try sent.append(std.testing.allocator, try std.testing.allocator.dupe(u8, msg));
}
+test "a replica cursor lands on its local clock without another daemon event" {
+ if (comptime !pardes.builtins.frontend.lift) return error.SkipZigTest;
+ const gpa = std.testing.allocator;
+ const a = try Authority.init(gpa, .{ .cols = 80, .rows = 24, .file = "build.zig" }, TestHost.host(), false);
+ defer a.deinit();
+ const r = try Replica.init(gpa, 1, try a.unit(0, 0), false);
+ defer r.deinit();
+ const present: pardes.views.Present = .{ .ctx = null, .f = null };
+ const ms = std.time.ns_per_ms;
+ const start = nowNs();
+ r.drawAt(present, start);
+ const before = r.core().surface.cursor.?;
+ const msg = try gpa.dupe(u8, try r.input(.{ .key = .{ .cp = 'j', .text = "j" } }));
+ defer gpa.free(msg);
+ const typed = r.frame_input_ns.?;
+ const digest = r.digest();
+ const clock = r.core().now_ns;
+ r.drawAt(present, typed + 16 * ms);
+ const target = r.core().surface.cursor.?;
+ try std.testing.expect(target.y > before.y);
+ try std.testing.expectEqual(@as(u8, 3), r.core().surface.chrome.cursor_glide);
+ try std.testing.expect(r.animating());
+ r.drawAt(present, typed + 250 * ms);
+ const frame = &r.core().surface;
+ try std.testing.expectEqual(@as(u8, 2), frame.chrome.cursor_glide);
+ try std.testing.expectEqual(@as(f32, @floatFromInt(target.x)), frame.chrome.cursor_quad[0]);
+ try std.testing.expectEqual(@as(f32, @floatFromInt(target.y)), frame.chrome.cursor_quad[1]);
+ try std.testing.expectEqual(@as(u32, 250), frame.chrome.cursor_idle_ms);
+ try std.testing.expectEqual(clock, r.core().now_ns);
+ try std.testing.expectEqual(digest, r.digest());
+ try std.testing.expect(!r.animating());
+ r.confirm(try a.take(msg));
+ r.settle();
+ r.drawAt(present, typed + 500 * ms);
+ try std.testing.expectEqual(@as(u32, 500), r.core().surface.chrome.cursor_idle_ms);
+ try std.testing.expect(r.diverged == null and r.quiet());
+ try std.testing.expectEqual(digestOf(a), r.digest());
+}
+
+test "a replica cursor keeps its drawn position across rollback and another live view" {
+ if (comptime !pardes.builtins.frontend.lift) return error.SkipZigTest;
+ const gpa = std.testing.allocator;
+ const a = try Authority.init(gpa, .{ .cols = 80, .rows = 24, .file = "build.zig" }, TestHost.host(), false);
+ defer a.deinit();
+ const r = try Replica.init(gpa, 1, try a.unit(0, 0), false);
+ defer r.deinit();
+ const other = try a.openView(2);
+ r.confirm(other.unit);
+ r.settle();
+ const present: pardes.views.Present = .{ .ctx = null, .f = null };
+ const ms = std.time.ns_per_ms;
+ const start = 100 * std.time.ns_per_s;
+ r.drawAt(present, start);
+ r.ready();
+ var sent: std.ArrayListUnmanaged([]u8) = .empty;
+ defer {
+ for (sent.items) |msg| gpa.free(msg);
+ sent.deinit(gpa);
+ }
+ for ("5j") |cp| try key(r, cp, &sent);
+ r.drawAt(present, start + 16 * ms);
+ r.drawAt(present, start + 40 * ms);
+ const quad = r.core().surface.chrome.cursor_quad;
+ const target = r.core().surface.cursor.?;
+ try std.testing.expect(r.animating());
+ try std.testing.expect(quad[1] < @as(f32, @floatFromInt(target.y)));
+
+ // The authority changes while both keys are speculative. Replaying
+ // them must continue from the frame already seen, not the saved copy.
+ r.confirm(try a.local(.{ .focus = !a.core.window_focused }));
+ r.settle();
+ try std.testing.expect(r.stats.foreign > 0);
+ r.drawAt(present, start + 40 * ms);
+ try std.testing.expectEqual(quad, r.core().surface.chrome.cursor_quad);
+ for (sent.items) |msg| {
+ r.confirm(try a.take(msg));
+ r.settle();
+ }
+ try std.testing.expect(r.diverged == null and r.quiet());
+
+ // Another client's input leaves its view live. Only our own cursor
+ // is drawn, and the live view and its clock are untouched afterwards.
+ var buf: [256]u8 = undefined;
+ r.confirm(try a.take(try inputOf(&buf, 2, 1, .{ .key = .{ .cp = 'l', .text = "l" } })));
+ r.settle();
+ try std.testing.expectEqual(other.view, r.core().view);
+ const clock = r.core().now_ns;
+ r.drawAt(present, start + 500 * ms);
+ try std.testing.expectEqual(other.view, r.core().view);
+ try std.testing.expectEqual(clock, r.core().now_ns);
+ try std.testing.expectEqual(target, r.core().surface.cursor.?);
+ try std.testing.expectEqual(@as(f32, @floatFromInt(target.y)), r.core().surface.chrome.cursor_quad[1]);
+ try std.testing.expect(!r.animating());
+ try std.testing.expectEqual(digestOf(a), r.digest());
+}
+
test "a replica's own keys apply at once, confirm on the fast path, and end at the authority's digest" {
const gpa = std.testing.allocator;
const a = try Authority.init(gpa, .{ .cols = 80, .rows = 24, .file = "mise.toml" }, TestHost.host(), false);
@@ -3664,6 +3778,39 @@ test "a replica joined from the session's dump replays the units after it" {
try std.testing.expectEqual(digestOf(a), r.digest());
}
+test "a replica joined from a themed dump paints its taglines in the restored theme" {
+ const gpa = std.testing.allocator;
+ const a = try Authority.init(gpa, .{ .cols = 80, .rows = 24, .file = "build.zig" }, TestHost.host(), false);
+ defer a.deinit();
+ _ = try a.local(.{ .command = "Theme rose_pine_moon" });
+ const was = Stepping.begin(&a.t, null);
+ const bytes = try pardes.dump.dumpBytes(a.core);
+ tape.resync(&a.t);
+ was.end();
+ defer a.core.gpa.free(bytes);
+ const r = try Replica.initDump(gpa, 1, 0, bytes, .{ .cols = 80, .rows = 24 });
+ defer r.deinit();
+ const expected = pardes.colors.ChromeTheme.fromTheme(a.core.theme());
+ try std.testing.expectEqualStrings("rose_pine_moon", r.core().theme().name);
+ try std.testing.expectEqual(expected.tag_bg, r.core().chromeTheme().tag_bg);
+ try std.testing.expectEqual(expected.tag_fg, r.core().chromeTheme().tag_fg);
+ r.draw(.{ .ctx = null, .f = null });
+ try std.testing.expectEqual(expected.tag_bg, r.core().surface.chrome.tag_bg);
+ try std.testing.expectEqual(expected.tag_fg, r.core().surface.chrome.tag_fg);
+ try std.testing.expectEqual(digestOf(a), r.digest());
+ // Later theme changes still arrive as ordinary confirmed units.
+ r.confirm(try a.local(.{ .command = "Theme monokai_pro_classic" }));
+ r.settle();
+ // A quiet remote authority sends no transition ticks. Drawing alone
+ // must still update the chrome, without changing replicated state.
+ r.draw(.{ .ctx = null, .f = null });
+ const changed = pardes.colors.ChromeTheme.fromTheme(a.core.theme());
+ try std.testing.expectEqual(changed.tag_bg, r.core().surface.chrome.tag_bg);
+ try std.testing.expectEqual(changed.tag_fg, r.core().surface.chrome.tag_fg);
+ try std.testing.expect(r.diverged == null);
+ try std.testing.expectEqual(digestOf(a), r.digest());
+}
+
test "a host's Adopt and a terminal reader's failure are inputs: a replica makes the same pane" {
const gpa = std.testing.allocator;
// Its terminals as screen state, as a session's for its clients are.