summaryrefslogtreecommitdiff
path: root/src/draw.zig
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-11-05 13:55:00 -0300
committerGabriel Schneider <[email protected]>2026-11-05 15:25:19 -0300
commitc2885d899c95b9c4a72786940289afd0b3ddbde8 (patch)
tree3a4d9086eba674c2198abc526611258b098328b2 /src/draw.zig
parent23c9932afe9bbf01aa84d780e9030dfb6e333475 (diff)
downloadpardes-c2885d899c95b9c4a72786940289afd0b3ddbde8.tar.gz
pardes-c2885d899c95b9c4a72786940289afd0b3ddbde8.zip
the cursor's ease leaves the core for the window: the core no longer runs the caret's springs (Pardes.cursor_glide, cursor_view, cursor_crossing, cursor_held, input_ns, draw.zig's glideCursor, focusedCursorBox and PaneFrame) nor hands a quad on (Chrome.cursor_glide, cursor_alpha, cursor_quad, cursor_idle_ms); the window's Caret eases its own quad on critically damped springs, on its own clock, from the cursor and the focused body the Surface shows (a jump glides, its leading corners first and bowing a little on a long one, a step eases, typing keeps up, a scroll or a pane's move carries it with its text), with the default flavour's pace and drawn as a quad only while it moves; the blink stays the window's as it was, now timed from the window's own last key or click; the core's caret tests go (with no motion a focus switch asks for no frames; the caret is its own body; the focused cursor glides a jump; a terminal's cursor lands with scrolling output; focus moved to another column glides; a click that takes focus glides once; focus moving to a pane with no cursor lets the session go idle) and the window's caret has one of its own, the glide tests feeding it as the frame does; a click that takes focus no longer holds the caret for its release; while the caret glides the window asks for frames on the continuous path its glide uses (a step of the loop that cleared it left a frame mid-glide on screen, five GUI goldens caught it); GUI goldens unchanged
Co-Authored-By: Claude Opus 5.5 <[email protected]> Claude-Session: https://claude.ai/code/session_016Y9MNAtZenFv4weoMD3cge
Diffstat (limited to 'src/draw.zig')
-rw-r--r--src/draw.zig444
1 files changed, 0 insertions, 444 deletions
diff --git a/src/draw.zig b/src/draw.zig
index 9db5d0ff..fe4921ff 100644
--- a/src/draw.zig
+++ b/src/draw.zig
@@ -160,166 +160,6 @@ fn inkOn(bg: [3]u8) [3]u8 {
return if (lum > 140) .{ 0x00, 0x00, 0x00 } else .{ 0xff, 0xff, 0xff };
}
-/// The focused cursor's box in grid cells, at the pitch it is drawn at: a
-/// tag's at the tagline's (Layer.Metrics), else a grid cell.
-fn focusedCursorBox(p: *const Pardes, s: *const Surface) ?animation.Box {
- const cursor = s.cursor orelse return null;
- const m = p.row_metrics;
- const bw: f32 = @floatFromInt(@max(1, m.body_w));
- const bh: f32 = @floatFromInt(@max(1, m.body_h));
- const tw: f32 = @floatFromInt(@max(1, m.tagline_w));
- const th: f32 = @floatFromInt(@max(1, @min(m.tagline_h, m.body_h)));
- for (s.tagLayers()) |*layer| {
- const caret = layer.cursor orelse continue;
- if (layer.rows == 0 or layer.viewport.y + caret.y != cursor.y) continue;
- if (cursor.x < layer.viewport.x or cursor.x >= layer.viewport.x + layer.viewport.w) continue;
- const w = if (caret.bar) tw / bw / 8 else tw / bw;
- const x = layer.caretSpan(caret.x, 1, tw / bw, w)[0];
- return .{ .x = x, .y = @as(f32, @floatFromInt(cursor.y)) + (bh - th) / 2 / bh, .w = w, .h = th / bh };
- }
- return .{ .x = @floatFromInt(cursor.x), .y = @floatFromInt(cursor.y), .w = if (cursor.bar) 1.0 / 8.0 else 1, .h = 1 };
-}
-
-/// G3 (docs/render-pipeline.md ยง5.4): the focused cursor on its springs,
-/// at the Motion flavour's pace, a jump gliding and a step easing over a
-/// few frames (CursorGlide.aim), the thin insert-mode caret as the block;
-/// blinking unless typing. A pixel shell's: a grid's cursor is the
-/// terminal's own.
-///
-/// The springs hold the cursor where the pane's final layout puts it, and
-/// the quad is drawn through the pane's frame (paneFrame): while the pane
-/// slides, zooms or is dragged, the cursor rides with its text. A pane that
-/// moved in the layout carries the springs with it (they keep their place
-/// in the pane), so with no transition the cursor lands with the text. A
-/// focus change glides from where the cursor is drawn to the new pane's
-/// cursor, wherever that pane is drawn now.
-fn glideCursor(p: *Pardes, s: *Surface) void {
- s.chrome.cursor_glide = 0;
- s.chrome.cursor_alpha = 1;
- s.chrome.cursor_idle_ms = std.math.maxInt(u32);
- if (!builtins.frontend.lift) return;
- const box = focusedCursorBox(p, s) orelse {
- // No cursor drawn (a PDF or picture took focus, a program hid its
- // own): a glide under way has nowhere to land, and its springs,
- // never stepped again, held continuous() and the frames on for
- // ever. It stops; the next cursor lands where it is.
- p.cursor_glide = .{};
- p.cursor_crossing = false;
- return;
- };
- const motion = animation.Motion.of(p.settings.motion);
- // The thin insert-mode caret glides as the block does (a jump smears
- // and bows, a step eases); a scroll lands it, below.
- var how: animation.CursorGlide.How = .ease;
- var frame: PaneFrame = .{};
- // In a column's or the workspace's tag the cursor is not the pane's,
- // and does not move with it.
- var inside = false;
- if (p.panes[p.active]) |pane| {
- const rect = p.rects[p.active];
- const cx = box.x + box.w / 2;
- const cy = box.y + box.h / 2;
- inside = cx >= @as(f32, @floatFromInt(rect.x)) and cx <= @as(f32, @floatFromInt(rect.x + rect.w)) and
- cy >= @as(f32, @floatFromInt(rect.y)) and cy <= @as(f32, @floatFromInt(rect.y + rect.h));
- if (inside) frame = paneFrame(s, pane.serial, rect);
- const origin: [2]f32 = .{ @floatFromInt(rect.x), @floatFromInt(rect.y) };
- const view = p.cursor_view;
- const line: i64 = if (pane.file) |f| @intCast(f.scroll) else if (pane.isTerminal()) panes.terminal.gridOffset(pane) else 0;
- if (view.serial == pane.serial and view.inside == inside) {
- // The pane moved in the layout: the springs move with it (its
- // own cursor's; one in a column's tag stays).
- if (inside) p.cursor_glide.shift(origin[0] - view.origin[0], origin[1] - view.origin[1]);
- // Scrolled (a file's view, a terminal's output): the caret did not
- // move, the text did. Its springs land on its cell (the core's
- // view is the settled one), so a page that keeps its row leaves
- // it still, and a scroll that carries its line has the shell draw
- // it with the text's own glide (Glide.caret_rides), one picture,
- // never a second spring chasing the first.
- if (inside and line != view.line) how = .land;
- } else if (view.serial != 0 and p.cursor_glide.placed) {
- // Focus moved (to another pane, or between a pane and a
- // column's or the workspace's tag): the glide starts where the
- // cursor is drawn, in the old place's frame, and heads for the
- // new cursor through the new one's.
- const old: PaneFrame = if (!view.inside) .{} else for (p.panes, 0..) |slot, id| {
- const other = slot orelse continue;
- if (other.serial != view.serial) continue;
- const r = p.rects[id];
- p.cursor_glide.shift(@as(f32, @floatFromInt(r.x)) - view.origin[0], @as(f32, @floatFromInt(r.y)) - view.origin[1]);
- break paneFrame(s, view.serial, r);
- } else .{};
- const at = p.cursor_glide.centreAt(p.now_ns);
- const seen = frame.unplace(old.place(at));
- p.cursor_glide.shift(seen[0] - at[0], seen[1] - at[1]);
- p.cursor_crossing = true;
- p.cursor_held = p.drag == .select;
- }
- p.cursor_view = .{ .serial = pane.serial, .line = line, .origin = origin, .inside = inside };
- }
- // A click that took focus places the cursor on its release; aimed at
- // the pane's old cursor meanwhile, it would glide there first.
- if (p.drag != .select) p.cursor_held = false;
- if (!p.cursor_held) p.cursor_glide.aim(box, p.now_ns, motion, how);
- _ = p.cursor_glide.step(p.now_ns);
- const moving = p.cursor_glide.moving();
- if (!moving and !p.cursor_held) p.cursor_crossing = false;
- // Drawn as the quad while it glides, while its pane moves and while it
- // waits for a click's release.
- s.chrome.cursor_glide = 2 | @as(u8, @intFromBool(moving or frame.moving() or p.cursor_held));
- // The shell blinks it, from how long ago the last key or click was.
- if (p.settings.cursor_blink)
- s.chrome.cursor_idle_ms = @intCast(@min(std.math.maxInt(u32) - 1, (p.now_ns -| p.input_ns) / std.time.ns_per_ms));
- // A little less than solid while it glides, so the glyphs it passes
- // stay legible (less on the long flavours), solid again as it lands.
- const remaining = p.cursor_glide.remaining(p.now_ns);
- const see_through: f32 = if (motion.zeta < 1) 0.7 else 0.85;
- s.chrome.cursor_alpha = if (moving) see_through + (1 - see_through) * std.math.clamp(1 - remaining / 0.5, 0, 1) else 1;
- const quad = p.cursor_glide.sample(p.now_ns, motion);
- // Never outside the focused pane as drawn, however far a flavour
- // overshoots or a scroll carried it: it squashes against the pane's
- // edges. Crossing to another pane, it may pass over any of the grid.
- const bounds: animation.Box = if (p.cursor_crossing or !inside)
- .{ .w = @floatFromInt(s.cols), .h = @floatFromInt(s.rows) }
- else
- frame.at;
- for (quad, 0..) |corner, i| {
- const point = frame.place(corner);
- s.chrome.cursor_quad[i * 2] = std.math.clamp(point[0], bounds.x, bounds.x + bounds.w);
- s.chrome.cursor_quad[i * 2 + 1] = std.math.clamp(point[1], bounds.y, bounds.y + bounds.h);
- }
-}
-
-/// Where a pane is drawn against where the layout puts it: its transition
-/// track's presented box against the track's target, or the layout's box
-/// both ways when it is still. Maps grid points between the two.
-const PaneFrame = struct {
- to: animation.Box = .{ .w = 1, .h = 1 },
- at: animation.Box = .{ .w = 1, .h = 1 },
-
- fn moving(f: PaneFrame) bool {
- return !std.meta.eql(f.to, f.at);
- }
-
- fn place(f: PaneFrame, point: [2]f32) [2]f32 {
- return .{ f.at.x + (point[0] - f.to.x) * scale(f.at.w, f.to.w), f.at.y + (point[1] - f.to.y) * scale(f.at.h, f.to.h) };
- }
-
- fn unplace(f: PaneFrame, point: [2]f32) [2]f32 {
- return .{ f.to.x + (point[0] - f.at.x) * scale(f.to.w, f.at.w), f.to.y + (point[1] - f.at.y) * scale(f.to.h, f.at.h) };
- }
-
- fn scale(num: f32, den: f32) f32 {
- return if (den > 0.001) num / den else 1;
- }
-};
-
-fn paneFrame(s: *const Surface, serial: u32, rect: Rect) PaneFrame {
- _ = s;
- _ = serial;
- const still = layout.panelBox(rect);
- return .{ .to = still, .at = still };
-}
-
pub fn render(p: *Pardes, arena: std.mem.Allocator) !*Surface {
const taped = pardes.tape.enter(p, .render);
defer pardes.tape.leave(p, taped);
@@ -526,7 +366,6 @@ pub fn render(p: *Pardes, arena: std.mem.Allocator) !*Surface {
}
}
};
- glideCursor(p, s);
return s;
}
@@ -1357,174 +1196,6 @@ test "a notice wider than its band, as a shader's compile error is, draws its en
}
}
-test "with no motion a focus switch asks for no frames" {
- const p = try Pardes.init(std.testing.allocator, .{ .cols = 80, .rows = 24 });
- defer p.deinit();
- _ = try p.setTestFile("text\n");
- p.newScratchBelow(0);
- // With motion the cursor glides to the other pane (glideCursor).
- p.settings.motion = .off;
- var arena: std.heap.ArenaAllocator = .init(std.testing.allocator);
- defer arena.deinit();
- p.advance(std.time.ns_per_s);
- _ = try p.render(arena.allocator());
- p.active = 0;
- _ = arena.reset(.retain_capacity);
- _ = try p.render(arena.allocator());
- try std.testing.expect(!p.continuous());
-}
-
-test "the caret is its own body: a page leaves it still under the moving text, a wheel scroll lands its springs on its line's new row" {
- if (!builtins.frontend.lift) return error.SkipZigTest;
- const p = try Pardes.init(std.testing.allocator, .{ .cols = 80, .rows = 30 });
- defer p.deinit();
- var text: std.ArrayList(u8) = .empty;
- defer text.deinit(std.testing.allocator);
- for (0..400) |i| try text.print(std.testing.allocator, "line {d}\n", .{i});
- const pane = try p.setTestFile(text.items);
- p.settings.cursor_blink = false;
- var arena: std.heap.ArenaAllocator = .init(std.testing.allocator);
- defer arena.deinit();
- var now: u64 = std.time.ns_per_s;
- p.advance(now);
- // Mid-file, where a half page keeps the caret's row.
- for ("200G") |ch| p.update(.{ .key = .{ .cp = ch, .text = &.{ch} } });
- _ = try p.render(arena.allocator());
- now += std.time.ns_per_s;
- p.advance(now);
- _ = arena.reset(.retain_capacity);
- _ = try p.render(arena.allocator());
- // Ctrl-d: the caret moves with the view and keeps its screen row: it
- // does not ride the glide, and it does not move.
- const row_before = (try p.render(arena.allocator())).cursor.?.y;
- p.update(.{ .key = .{ .cp = 'd', .ctrl = true } });
- now += 16 * std.time.ns_per_ms;
- p.advance(now);
- _ = arena.reset(.retain_capacity);
- var s = try p.render(arena.allocator());
- try std.testing.expect(pane.file.?.scroll > 0);
- try std.testing.expectEqual(row_before, s.cursor.?.y);
- try std.testing.expectEqual(@as(u8, 0), s.chrome.cursor_glide & 1);
- try std.testing.expectEqual(@as(f32, @floatFromInt(row_before)), s.chrome.cursor_quad[1]);
- // The view scrolled with the caret on its line: its springs land on
- // the line's new row at once, no second glide; the shell carries it
- // there with the text's own (Glide.caret_rides).
- pane.scrollBy(-3);
- now += 16 * std.time.ns_per_ms;
- p.advance(now);
- _ = arena.reset(.retain_capacity);
- s = try p.render(arena.allocator());
- try std.testing.expectEqual(@as(u8, 0), s.chrome.cursor_glide & 1);
- try std.testing.expectEqual(@as(f32, @floatFromInt(s.cursor.?.y)), s.chrome.cursor_quad[1]);
-}
-
-test "the focused cursor glides a jump, eases a step, the thin caret too, and is exact at rest" {
- if (!builtins.frontend.lift) return error.SkipZigTest;
- const p = try Pardes.init(std.testing.allocator, .{ .cols = 80, .rows = 30 });
- defer p.deinit();
- _ = try p.setTestFile(std.mem.asBytes(&@as([20][20]u8, @splat("some text on a line\n".*))));
- p.settings.cursor_blink = false;
- var arena: std.heap.ArenaAllocator = .init(std.testing.allocator);
- defer arena.deinit();
- const ms = std.time.ns_per_ms;
- var now: u64 = std.time.ns_per_s;
- p.advance(now);
- _ = try p.render(arena.allocator());
- // A step down: eases there in a few frames.
- p.update(.{ .key = .{ .cp = 'j' } });
- now += 16 * ms;
- p.advance(now);
- _ = arena.reset(.retain_capacity);
- var s = try p.render(arena.allocator());
- try std.testing.expectEqual(@as(u8, 3), s.chrome.cursor_glide);
- now += 100 * ms;
- p.advance(now);
- _ = arena.reset(.retain_capacity);
- s = try p.render(arena.allocator());
- try std.testing.expectEqual(@as(u8, 2), s.chrome.cursor_glide);
- const before = s.cursor.?;
- // To the last line: it glides, a quad partway, and asks for frames.
- p.update(.{ .key = .{ .cp = 'g' } });
- p.update(.{ .key = .{ .cp = 'e' } });
- now += 16 * ms;
- p.advance(now);
- _ = arena.reset(.retain_capacity);
- s = try p.render(arena.allocator());
- const target = s.cursor.?;
- try std.testing.expect(target.y > before.y + 5);
- try std.testing.expectEqual(@as(u8, 3), s.chrome.cursor_glide);
- try std.testing.expect(s.chrome.cursor_quad[1] < @as(f32, @floatFromInt(target.y)) - 1);
- try std.testing.expect(p.continuous());
- // Frame by frame to rest: gliding exactly while it moves (the shell then
- // draws the quad, never the cells' cursor too), at under full alpha
- // until it lands, solid as it does.
- var frames: usize = 0;
- while (p.continuous()) : (frames += 1) {
- now += 7 * ms;
- p.advance(now);
- _ = arena.reset(.retain_capacity);
- s = try p.render(arena.allocator());
- try std.testing.expect(s.chrome.cursor_glide & 2 != 0);
- try std.testing.expectEqual(p.cursor_glide.moving(), s.chrome.cursor_glide & 1 != 0);
- if (s.chrome.cursor_glide & 1 != 0) try std.testing.expect(s.chrome.cursor_alpha <= 1 and s.chrome.cursor_alpha >= 0.7);
- for (s.chrome.cursor_quad) |value| try std.testing.expect(std.math.isFinite(value));
- }
- try std.testing.expect(frames > 3);
- try std.testing.expectEqual(@as(u8, 2), s.chrome.cursor_glide);
- try std.testing.expectEqual(@as(f32, 1), s.chrome.cursor_alpha);
- // At rest the quad is the cursor's own cell.
- try std.testing.expectEqual(@as(f32, @floatFromInt(target.x)), s.chrome.cursor_quad[0]);
- try std.testing.expectEqual(@as(f32, @floatFromInt(target.y)), s.chrome.cursor_quad[1]);
- // A mode change mid-glide: the thin caret glides on to the mark.
- p.update(.{ .key = .{ .cp = 'g' } });
- p.update(.{ .key = .{ .cp = 'g' } });
- now += 7 * ms;
- p.advance(now);
- _ = arena.reset(.retain_capacity);
- s = try p.render(arena.allocator());
- try std.testing.expectEqual(@as(u8, 3), s.chrome.cursor_glide);
- p.update(.{ .key = .{ .cp = 'i' } });
- now += 7 * ms;
- p.advance(now);
- _ = arena.reset(.retain_capacity);
- s = try p.render(arena.allocator());
- try std.testing.expectEqual(@as(u8, 3), s.chrome.cursor_glide);
- try std.testing.expect(s.cursor.?.bar);
- while (p.continuous()) {
- now += 7 * ms;
- p.advance(now);
- _ = arena.reset(.retain_capacity);
- s = try p.render(arena.allocator());
- }
- // At rest, a bar's width at the caret's cell.
- try std.testing.expectEqual(@as(f32, @floatFromInt(s.cursor.?.x)), s.chrome.cursor_quad[0]);
- try std.testing.expectApproxEqAbs(@as(f32, 1.0 / 8.0), s.chrome.cursor_quad[2] - s.chrome.cursor_quad[0], 1e-4);
-}
-
-test "a terminal's cursor lands with scrolling output, never gliding against it" {
- if (!builtins.frontend.lift) return error.SkipZigTest;
- const p = try Pardes.init(std.testing.allocator, .{ .cols = 80, .rows = 12 });
- defer p.deinit();
- while (p.nextEffect()) |_| {}
- const term = p.active;
- try std.testing.expect(p.panes[term].?.isTerminal());
- p.settings.cursor_blink = false;
- var arena: std.heap.ArenaAllocator = .init(std.testing.allocator);
- defer arena.deinit();
- const ms = std.time.ns_per_ms;
- var now: u64 = std.time.ns_per_s;
- p.update(.{ .output = .{ .pane = @intCast(term), .bytes = std.mem.asBytes(&@as([20][6]u8, @splat("line\r\n".*))) ++ "$ some command typed" } });
- p.advance(now);
- _ = try p.render(arena.allocator());
- // Enter: three lines of output scroll up, the cursor to a new prompt.
- p.update(.{ .output = .{ .pane = @intCast(term), .bytes = "\r\nout\r\nout\r\nout\r\n$ " } });
- now += 16 * ms;
- p.advance(now);
- _ = arena.reset(.retain_capacity);
- const s = try p.render(arena.allocator());
- try std.testing.expectEqual(@as(u8, 2), s.chrome.cursor_glide);
-}
-
test "a monkey over notices, prompts, tags and tiny panes at a gui's metrics never panics" {
// The snapshot harness runs the tty, whose tagline pitch is the body's,
// so it never reaches what a narrower tagline does to a notice's band:
@@ -1679,118 +1350,3 @@ test "a body with context rows is painted once, and the grid's rows are what a p
}
}
-/// Two columns, the file in the left one and a shell in the right, the
-/// right one focused with its cursor settled.
-fn twoColumns(p: *Pardes, arena: *std.heap.ArenaAllocator) !void {
- _ = try p.setTestFile(std.mem.asBytes(&@as([6][20]u8, @splat("some text on a line\n".*))));
- _ = try p.newShell(1, "");
- try std.testing.expect(layout.splitColumn(p, 0, 1, false));
- p.sync();
- p.advance(std.time.ns_per_s);
- _ = try p.render(arena.allocator());
- p.presented();
- p.advance(2 * std.time.ns_per_s);
- _ = arena.reset(.retain_capacity);
- _ = try p.render(arena.allocator());
- p.presented();
- try std.testing.expect(!p.cursor_glide.moving());
-}
-
-test "focus moved to another column glides from where the cursor was drawn" {
- if (!builtins.frontend.lift) return error.SkipZigTest;
- const p = try Pardes.init(std.testing.allocator, .{ .cols = 120, .rows = 20 });
- defer p.deinit();
- var arena: std.heap.ArenaAllocator = .init(std.testing.allocator);
- defer arena.deinit();
- p.settings.motion = .smooth;
- try twoColumns(p, &arena);
- p.active = 0;
- p.advance(3 * std.time.ns_per_s);
- _ = arena.reset(.retain_capacity);
- const before = try p.render(arena.allocator());
- try std.testing.expect(!p.cursor_glide.moving());
- const was: [2]f32 = .{ before.chrome.cursor_quad[0], before.chrome.cursor_quad[1] };
-
- p.active = 1;
- _ = arena.reset(.retain_capacity);
- const start = try p.render(arena.allocator());
- // It sets off from where it was drawn, in the left column...
- try std.testing.expectApproxEqAbs(was[0], start.chrome.cursor_quad[0], 0.01);
- try std.testing.expectApproxEqAbs(was[1], start.chrome.cursor_quad[1], 0.01);
- try std.testing.expect(p.cursor_glide.moving() and start.chrome.cursor_glide & 1 != 0);
- // ...crosses the grid, not squashed against the right one's edge...
- p.advance(3 * std.time.ns_per_s + 40 * std.time.ns_per_ms);
- _ = arena.reset(.retain_capacity);
- const mid = try p.render(arena.allocator());
- try std.testing.expect(mid.chrome.cursor_quad[0] > was[0] and mid.chrome.cursor_quad[0] < @as(f32, @floatFromInt(p.rects[1].x)) + 1);
- // ...and lands on the right one's cursor.
- p.advance(5 * std.time.ns_per_s);
- _ = arena.reset(.retain_capacity);
- const landed = try p.render(arena.allocator());
- const box = focusedCursorBox(p, landed).?;
- try std.testing.expectApproxEqAbs(box.x, landed.chrome.cursor_quad[0], 0.01);
- try std.testing.expect(!p.cursor_glide.moving() and !p.cursor_crossing);
-}
-
-test "a click that takes focus glides the cursor once, to where it lands on release" {
- if (!builtins.frontend.lift) return error.SkipZigTest;
- const p = try Pardes.init(std.testing.allocator, .{ .cols = 120, .rows = 20 });
- defer p.deinit();
- var arena: std.heap.ArenaAllocator = .init(std.testing.allocator);
- defer arena.deinit();
- p.settings.motion = .smooth;
- try twoColumns(p, &arena);
- p.active = 0;
- p.advance(3 * std.time.ns_per_s);
- _ = arena.reset(.retain_capacity);
- const before = try p.render(arena.allocator());
- const was: [2]f32 = .{ before.chrome.cursor_quad[0], before.chrome.cursor_quad[1] };
- // Pressed in the other column: focus moves, the cursor waits.
- p.active = 1;
- p.drag = .{ .select = .{ .id = 1, .button = config.select_button } };
- for (0..3) |_| {
- p.advance(p.now_ns + 100 * std.time.ns_per_ms);
- _ = arena.reset(.retain_capacity);
- const held = try p.render(arena.allocator());
- try std.testing.expectApproxEqAbs(was[0], held.chrome.cursor_quad[0], 0.01);
- try std.testing.expectApproxEqAbs(was[1], held.chrome.cursor_quad[1], 0.01);
- }
- // Released: one glide, from there to the placed cursor.
- p.drag = .none;
- _ = arena.reset(.retain_capacity);
- _ = try p.render(arena.allocator());
- try std.testing.expect(p.cursor_glide.moving());
- p.advance(p.now_ns + 5 * std.time.ns_per_s);
- _ = arena.reset(.retain_capacity);
- const landed = try p.render(arena.allocator());
- try std.testing.expectApproxEqAbs(focusedCursorBox(p, landed).?.x, landed.chrome.cursor_quad[0], 0.01);
-}
-
-test "focus moving to a pane with no cursor while the cursor glides lets the session go idle" {
- if (!builtins.frontend.lift) return error.SkipZigTest;
- const p = try Pardes.init(std.testing.allocator, .{ .cols = 120, .rows = 20 });
- defer p.deinit();
- var arena: std.heap.ArenaAllocator = .init(std.testing.allocator);
- defer arena.deinit();
- p.settings.motion = .smooth;
- try twoColumns(p, &arena);
- p.active = 0;
- p.advance(3 * std.time.ns_per_s);
- _ = arena.reset(.retain_capacity);
- _ = try p.render(arena.allocator());
- p.active = 1;
- _ = arena.reset(.retain_capacity);
- _ = try p.render(arena.allocator());
- try std.testing.expect(p.cursor_glide.moving());
- // Mid-glide, the pane focused draws no cursor (as a PDF pane does).
- p.panes[1].?.body.mode = .tty;
- p.update(.{ .output = .{ .pane = 1, .bytes = "\x1b[?25l" } });
- p.advance(3 * std.time.ns_per_s + 20 * std.time.ns_per_ms);
- _ = arena.reset(.retain_capacity);
- const hidden = try p.render(arena.allocator());
- try std.testing.expect(hidden.cursor == null);
- p.advance(5 * std.time.ns_per_s);
- _ = arena.reset(.retain_capacity);
- _ = try p.render(arena.allocator());
- try std.testing.expect(!p.cursor_glide.moving() and !p.continuous());
-}