diff options
Diffstat (limited to 'src/gui')
| -rw-r--r-- | src/gui/gui.zig | 83 |
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; } |
