//! `source` (design/README.md, "3. Panels"): a window on the whole file, //! scrolled by whole lines to keep the current line in its middle third: //! fourteen lines, eight beside a lens, ten when the lens is the subject. //! Its rows are `line`s, pardes's colours; the current mark is a gold //! plaque on the number and its ember across, the three lines before it //! the trail. The mark fires on the line about to run and moves on last: //! a slide to a line near by, a jump (out, then in) into a call or out //! of one. Reads `Moment.line` (through the recording's index of it). const std = @import("std"); const sk = @import("sketch"); const anim = @import("anim"); const pardes = @import("pardes-syntax"); const ui = @import("ui.zig"); const rows = @import("rows.zig"); const context = @import("context.zig"); const ties = @import("ties.zig"); const map = @import("map.zig"); const cursors = @import("cursor.zig"); const Stage = @import("stage.zig").Stage; const Cursor = cursors.Cursor; const theme = ui.theme; const Rect = ui.Rect; const m = theme.metric.context; const gpa = std.heap.smp_allocator; pub const Source = struct { cursor: Cursor, stage: *const Stage, focus: bool = false, pub fn draw(p: *const Source, f: *sk.Frame, placed: anim.Placed) void { const box = p.stage.box(placed, .source); const u = context.at(f, placed, box); const rec = p.cursor.rec; const now = p.cursor.now(placed); const text = prepared(rec.source, rec.file) orelse return; const fit: u32 = @intCast(theme.layout.rowsIn(box.h)); // The mark: leaving the line of one moment for that of the next. const was = rec.own[now.marks[0]]; const here = rec.own[now.marks[1]]; // The window: where the line it is on has it, and (as the mark // moves on) gliding to where the next one does. It never cuts. const going = now.advancing(); const windows = [2]f32{ @floatFromInt(rec.viewFirst(fit, was)), @floatFromInt(rec.viewFirst(fit, here)) }; // Farther than its own height (another function far off): what // leaves has left before what replaces it arrives; a scroll of more // lines than the window shows would be a blur, and say nothing. const far = @abs(windows[1] - windows[0]) > @as(f32, @floatFromInt(fit)); const first = if (far) windows[if (going >= 0.5) 1 else 0] else std.math.lerp(windows[0], windows[1], cursors.glide(going)); const lit = if (far and going < 1) u.faded(@abs(2 * going - 1)) else u; const from: u32 = @intFromFloat(@floor(first)); const last: u32 = @min(from + @as(u32, @intCast(context.rowsOf(box))), rec.line_count); const shown_first: u32 = @intFromFloat(windows[if (going >= 0.5) 1 else 0]); const body = u.panel(box.w, box.h, rec.file, .{ .focus = p.focus, .note = if (rec.line_count > fit) u.print("lines {d} to {d} of {d}", .{ shown_first, @min(shown_first + fit - 1, rec.line_count), rec.line_count }) else u.print("{d} lines", .{rec.line_count}) }); const top = body.y + m.pad; // Where the mark is, and how much of it. const travel = now.plan.travel; const moved = going * travel; var mark_line = here; var mark_at: f32 = @floatFromInt(here); var shows: f32 = 1; if (going < 1) { if (!now.plan.wave and !cursors.jumps(rec, now.marks[0], now.marks[1])) { // A line near by: it slides, off promptly and settling on // the next. The step's follow-through. mark_at = std.math.lerp(@as(f32, @floatFromInt(was)), mark_at, cursors.standard(going)); if (@abs(mark_at - @as(f32, @floatFromInt(was))) < 0.5) mark_line = was; } else { // A call, a return, a line far off, a continue: a jump. Out // there, then in here; it does not cross the lines between. const half = @min(theme.time.current_jump, travel / 2); if (moved < travel - half) { mark_line = was; mark_at = @floatFromInt(was); shows = 1 - std.math.clamp(moved / half, 0, 1); } else shows = std.math.clamp((moved - (travel - half)) / half, 0, 1); } } const mark_y = top + (mark_at - first) * m.row; // The numbers as wide as the program's largest: a scroll does not shift the text. const widen = rows.numberRoom(rec.line_count); context.clipBody(u, box); defer u.unclip(); // The plaque over the number. Fire: on the line about to run its // edges go out and come back, once, and nothing else moves. if (shows > 0) u.faded(shows).current(.{ .x = theme.stroke.rule, .y = mark_y, .w = box.w - 2 * theme.stroke.rule, .h = m.row }, theme.metric.plaque.line + widen, now.fires(.source)); if (shows >= 1 and mark_y >= body.y and mark_y + m.row <= box.h) ties.anchor(u, .source, .{ .x = 0, .y = mark_y, .w = box.w, .h = m.row }); // The trail: the last three other lines it was on. It shifts without animation. const on_line = rec.own[now.marked()]; var trail: [3]u32 = @splat(0); var found: usize = 0; var back = now.marked(); while (back > 0 and found < trail.len) { back -= 1; const l = rec.own[back]; if (l == 0 or l == on_line or std.mem.indexOfScalar(u32, trail[0..found], l) != null) continue; trail[found] = l; found += 1; } map.window(.source, shown_first, @min(shown_first + fit - 1, rec.line_count)); var line = @max(from, 1); while (line <= last) : (line += 1) { const y = top + (@as(f32, @floatFromInt(line)) - first) * m.row; map.row(.source, line, u, .{ .x = 0, .y = y, .w = box.w, .h = m.row }); const span = text.lines[line - 1]; const k = std.mem.indexOfScalar(u32, trail[0..found], line); const on = shows >= 0.5 and line == mark_line; rows.line(lit, y, box.w, line, widen, text.bytes[span[0]..span[1]], text.styles[span[0]..span[1]], if (on) .marked else if (k) |n| .{ .trail = n } else .plain); } // The source is read at a run; at a sprint it is veiled too. context.veiled(u, box, now.sprint_veil); } }; /// A source ready to draw: a class for each byte, and where each line is. const Text = struct { bytes: []const u8, styles: []const u8, lines: []const [2]usize, }; /// Made once for each source and kept: a scene draws the same few. var texts: std.ArrayList(Text) = .empty; fn prepared(source: []const u8, file: []const u8) ?*const Text { for (texts.items) |*t| if (t.bytes.ptr == source.ptr) return t; texts.append(gpa, prepare(source, file) catch return null) catch return null; return &texts.items[texts.items.len - 1]; } fn prepare(source: []const u8, file: []const u8) !Text { var analysis = try pardes.analyzeSource(gpa, file, source, false, true); var lines: std.ArrayList([2]usize) = .empty; var start: usize = 0; while (start < source.len) { const end = std.mem.indexOfScalarPos(u8, source, start, '\n') orelse source.len; try lines.append(gpa, .{ start, end }); start = end + 1; } // A language pardes has no grammar for is drawn plain. if (analysis.colors.len != source.len) { analysis.deinit(gpa); const plain = try gpa.alloc(u8, source.len); @memset(plain, 0); analysis.colors = plain; } return .{ .bytes = source, .styles = analysis.colors, .lines = try lines.toOwnedSlice(gpa) }; } test "a source is cut into lines and classed byte by byte" { const source = "int main(void) {\n return 0; // done\n}\n"; const text = try prepare(source, "main.c"); defer gpa.free(text.lines); defer gpa.free(text.styles); try std.testing.expectEqual(@as(usize, 3), text.lines.len); try std.testing.expectEqualStrings(" return 0; // done", source[text.lines[1][0]..text.lines[1][1]]); const at = std.mem.indexOf(u8, source, "return").?; try std.testing.expectEqual(pardes.Syn.keyword, @as(pardes.Syn, @enumFromInt(text.styles[at]))); try std.testing.expectEqual(pardes.Syn.number, @as(pardes.Syn, @enumFromInt(text.styles[at + 7]))); try std.testing.expectEqual(pardes.Syn.comment, @as(pardes.Syn, @enumFromInt(text.styles[at + 10]))); // rows.line reads these classes by number. try std.testing.expectEqual(@as(u8, 1), @intFromEnum(pardes.Syn.keyword)); try std.testing.expectEqual(@as(u8, 4), @intFromEnum(pardes.Syn.comment)); }