summaryrefslogtreecommitdiff
path: root/src/gui/gui.zig
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-10-28 17:56:30 -0300
committerGabriel Schneider <[email protected]>2026-10-28 21:05:39 -0300
commitf8fb785c9572855943713181d738b72ea494b7d5 (patch)
tree5a650fb25c0bfde3d14fd11cf49ba204d61ca752 /src/gui/gui.zig
parent96f840a055651b88eb1191772bc4b10fcbbb60ce (diff)
downloadpardes-f8fb785c9572855943713181d738b72ea494b7d5.tar.gz
pardes-f8fb785c9572855943713181d738b72ea494b7d5.zip
caret: a wheel's scroll moves the caret with its line, the text's own glide, no spring of its own chasing it (the dance): its springs land on its cell (CursorGlide.How .rigid gone) and the pixel shell draws it at its cell less the glide's offset while its line rides (caretRide, Glide.caret_rides), clipped as the text is; a page that keeps its row leaves it still as before; tests: the springs land, the caret rides exactly with its line
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Diffstat (limited to 'src/gui/gui.zig')
-rw-r--r--src/gui/gui.zig83
1 files changed, 79 insertions, 4 deletions
diff --git a/src/gui/gui.zig b/src/gui/gui.zig
index 71676194..f0802362 100644
--- a/src/gui/gui.zig
+++ b/src/gui/gui.zig
@@ -5217,6 +5217,62 @@ test "a notch scrolls the core at once and the picture glides after it, a wrappe
try std.testing.expect(!g.glide.pending and !g.glide.moving());
}
+test "a wheel's caret rides with its line, the text's own glide, never a spring of its own" {
+ if (!pardes.builtins.capabilities.lift) return error.SkipZigTest;
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 80, .rows = 24 });
+ defer core.deinit();
+ var text: std.ArrayList(u8) = .empty;
+ defer text.deinit(gpa);
+ for (0..200) |i| try text.print(gpa, "line {d}\n", .{i});
+ _ = try core.setTestFile(text.items);
+ core.settings.motion = .smooth;
+ core.settings.cursor_blink = false;
+ var arena: std.heap.ArenaAllocator = .init(gpa);
+ defer arena.deinit();
+ var now: u64 = std.time.ns_per_s;
+ core.advance(now);
+ for ("10G") |ch| core.update(.{ .key = .{ .cp = ch, .text = &.{ch} } });
+ _ = try core.render(arena.allocator());
+ now += std.time.ns_per_s;
+ core.advance(now);
+ _ = arena.reset(.retain_capacity);
+ var s = try core.render(arena.allocator());
+ var g: Gui = undefined;
+ g.glide = .{};
+ defer g.glide.deinit(gpa);
+ g.scroll_delta = 0;
+ g.scroll_lag = 0;
+ g.scroll_edge_len = 0;
+ const r = core.rects[core.active];
+ g.scroll_pane = core.active;
+ g.scroll_col = r.x + 10;
+ g.scroll_row = r.y + r.h - 2;
+ stepGlide(&g, core, gpa);
+ const before: f32 = @floatFromInt(s.cursor.?.y);
+ g.scroll_notch = 1;
+ stepGlide(&g, core, gpa);
+ var frames: usize = 0;
+ while (true) : (frames += 1) {
+ now += 7 * std.time.ns_per_ms;
+ core.advance(now);
+ _ = arena.reset(.retain_capacity);
+ s = try core.render(arena.allocator());
+ if (g.glide.pending) g.glide.measure(gpa, s);
+ if (frames == 0) {
+ try std.testing.expect(g.glide.caret_rides);
+ // Where its line is drawn: on the row it was on, the cell a row up.
+ try std.testing.expectApproxEqAbs(before, caretRow(&g, s).?, 1e-3);
+ }
+ // Always exactly with its line, the cell less the text's offset.
+ try std.testing.expectApproxEqAbs(@as(f32, @floatFromInt(s.cursor.?.y)) - g.glide.follow.offset, caretRow(&g, s).?, 1e-3);
+ if (!g.glide.moving()) break;
+ stepGlide(&g, core, gpa);
+ if (frames > 200) return error.NeverSettled;
+ }
+ try std.testing.expectEqual(@as(f32, @floatFromInt(s.cursor.?.y)), caretRow(&g, s).?);
+}
+
/// The scripted scroll sequence of the glide tests: a frame a 60 Hz
/// refresh, as the paced loop draws them (waitInput, then stepGlide, the
/// core's render and the frame's measure), an input on the frames `script`
@@ -10435,13 +10491,25 @@ const max_cursors = 1 + pardes.MAX_PANES + pardes.MAX_TAG_LAYERS;
/// Where the frame draws the focused caret, its top in grid rows: from its
/// own springs (the quad's, while it moves or while a glide moves the text)
-/// or its cell; never from the text's glide. The probe records it and the
-/// glide tests hold its invariants.
+/// or its cell; carried by the text's glide when its line rode it. The probe
+/// records it and the glide tests hold its invariants.
fn caretRow(g: *const Gui, surface: *const pardes.Surface) ?f32 {
const chrome = &surface.chrome;
const cursor = surface.cursor orelse return null;
const quad = chrome.cursor_glide & 2 != 0 and (chrome.cursor_glide & 1 != 0 or g.glide.follow.offset != 0);
- return if (quad) chrome.cursor_quad[1] else @floatFromInt(cursor.y);
+ return if (quad) chrome.cursor_quad[1] - caretRide(g, surface) else @floatFromInt(cursor.y);
+}
+
+/// The rows a caret whose line rode the wheel's glide is drawn above its
+/// cell: the text's own offset, so it moves with its line as a glyph does
+/// (its springs landed on the cell, draw.glideCursor).
+fn caretRide(g: *const Gui, surface: *const pardes.Surface) f32 {
+ const glide = &g.glide;
+ if (!glide.caret_rides or glide.follow.offset == 0) return 0;
+ const cu = surface.cursor orelse return 0;
+ const x0 = glide.rect.x + config.GUTTER;
+ if (cu.x < x0 or cu.x >= x0 + glide.bw() or cu.y < glide.body_y or cu.y >= glide.body_y + glide.body_h) return 0;
+ return glide.follow.offset;
}
/// Every cursor on the frame where it is drawn, in window pixels: the grid's
@@ -10529,10 +10597,17 @@ fn appendCursorGlide(g: *Gui, surface: *const pardes.Surface, builder: *OverlayB
const chrome = &surface.chrome;
if (g.cursor_quad_alpha <= 0.001) return;
const layout = fixedCellLayout(g);
+ const ride = caretRide(g, surface);
+ if (ride != 0) {
+ // Carried past the body's edge with its line: clipped as the text is.
+ const mid = chrome.cursor_quad[1] - ride + 0.5;
+ const top: f32 = @floatFromInt(g.glide.body_y);
+ if (mid < top or mid > top + @as(f32, @floatFromInt(g.glide.body_h))) return;
+ }
var px: [4][2]f32 = undefined;
var centre: [2]f32 = .{ 0, 0 };
for (&px, 0..) |*point, i| {
- point.* = .{ chrome.cursor_quad[i * 2] * layout.w, chrome.cursor_quad[i * 2 + 1] * layout.h };
+ point.* = .{ chrome.cursor_quad[i * 2] * layout.w, (chrome.cursor_quad[i * 2 + 1] - ride) * layout.h };
centre[0] += point[0] / 4;
centre[1] += point[1] / 4;
}