//! `loupe` (design/README.md, "3. Panels"): the telescope's other form. A //! chain says, flat, `rax → 407030 ◂ 12`; a loupe opens the place it points //! to: a panel held over the context, lifted (its own surface, the one //! shadow there is), with five `bytes` rows round the target, the target //! framed bright, its pointers to its own rows as `arc`s at full ink. In //! the working frame it hangs from its pointer: its tag's top on the foot //! of the pointer's row, its left edge 92 left of the pointer's digits (the //! tag's address under them), a bracket under the digits its stem. One //! opened from a pointer field of a loupe hangs the same way from that //! field, 120 to the right where the stage has room, deeper (its shadow //! 20 and 26). Its verbs are `open` and `close`. const std = @import("std"); const sk = @import("sketch"); const anim = @import("anim"); const zt = @import("ztrace"); const ui = @import("ui.zig"); const rows = @import("rows.zig"); const cursors = @import("cursor.zig"); const Recording = @import("Recording.zig"); const objects = @import("objects.zig"); const hexdump = @import("hexdump.zig"); const ties = @import("ties.zig"); const context = @import("context.zig"); const Stage = @import("stage.zig").Stage; const theme = ui.theme; const Rect = ui.Rect; const t = theme.color.text; const m = theme.metric.context; const k = theme.metric.loupe; const time = theme.time.loupe; /// The rows each open loupe shows, and how much it shows: a dump showing /// the same rows withholds their arcs while it is open (the loupe carries /// them). Set as each draws, read the next frame by the dumps drawn before it. /// shortcut: process-wide, a frame behind; two players at once want it on the frame. pub var holding: [2]?struct { lo: u64, hi: u64, shows: f32 } = @splat(null); pub const Loupe = struct { cursor: cursors.Cursor, stage: *const Stage, /// What it opens from: a register, by name; or a pointer field (its /// address) of the loupe it hangs under. /// Or the bytes of a dump's row (`at`, a field the view publishes as a /// `dump_run`), opening on `fields` (the region it reads them as): a /// struct the debug info does not type (malloc's tcache), named `name`. from: union(enum) { register: []const u8, field: struct { loupe: *const Loupe, at: u64 }, row: struct { at: u64, name: []const u8, note: []const u8, fields: hexdump.Fields }, }, /// 0 to 1 as it opens (`time.loupe.open`) and as it closes (`close`). opening: anim.Value = undefined, closing: anim.Value = undefined, /// `open`: its pointer framed as read; the stem draws and the loupe /// rises with it, its shadow growing; its target's frame lands last. pub fn open(l: *const Loupe, s: *anim.Frame) void { s.play(.{l.opening.to(1)}, .{ .seconds = time.open, .ease = anim.ease.linear }); } /// `close`: the stem draws back and the loupe sinks, fading as it falls. pub fn close(l: *const Loupe, s: *anim.Frame) void { s.play(.{l.closing.to(1)}, .{ .seconds = time.close, .ease = anim.ease.linear }); } /// Where it is now (in the working frame's units) and what it shows: /// null while it is shut, or where its pointer is not on screen. const Placed = struct { box: Rect, pointer: Rect, target: u64, first: u64, ink: u24 }; fn place(l: *const Loupe, u: ui.Ui, now: cursors.Now) ?Placed { const moment = now.moment(); var pointer: Rect = undefined; var target: u64 = undefined; var right: f32 = 0; switch (l.from) { .register => |name| { const i = context.index(name) orelse return null; const px = ties.find(.{ .register = i }) orelse return null; const back = u.at.xf.invert(); const a = back.apply(.{ px[0], px[1] }); const b = back.apply(.{ px[2], px[3] }); pointer = .{ .x = a[0], .y = a[1], .w = b[0] - a[0], .h = b[1] - a[1] }; const regs = (moment.regs(l.cursor.rec.tid) catch null) orelse return null; target = regs.named(name) orelse return null; }, .field => |field| { const parent = field.loupe.place(u, now) orelse return null; const row = @as(f32, @floatFromInt((field.at -| parent.first) / 16)); const shift = rows.addressRoom(parent.first + 16 * (k.rows - 1)); const at: u8 = @intCast(field.at % 16); pointer = .{ .x = parent.box.x + shift + rows.byteX(at), .y = parent.box.y + m.tag + m.pad + row * m.row, .w = rows.byteX(at + 7) + 24 - rows.byteX(at), .h = m.row }; target = (Recording.word(moment, field.at, 8) catch null) orelse return null; right = parent.box.x + 120; }, .row => |row| { const px = ties.find(.{ .dump_run = row.at }) orelse return null; const back = u.at.xf.invert(); const a = back.apply(.{ px[0], px[1] }); const b = back.apply(.{ px[2], px[3] }); pointer = .{ .x = a[0], .y = a[1], .w = b[0] - a[0], .h = b[1] - a[1] }; target = row.fields.base; }, } if (target == 0) return null; // shortcut: it keeps to the stage and does not yet move past the current marks or a changed row; the scene picks a pointer whose loupe covers neither. const stage = theme.canvas.stage; const h = theme.layout.panelH(k.rows); const x = std.math.clamp(@max(pointer.x - k.hang, right), stage.x, stage.x + stage.w - k.width); const y = @min(pointer.y + pointer.h - 1, stage.y + stage.h - h); return .{ .box = .{ .x = x, .y = y, .w = k.width, .h = h }, .pointer = pointer, .target = target, .first = (target & ~@as(u64, 15)) - 16 * (k.rows / 2), .ink = rows.ink(rows.regionOf(moment, target)) }; } pub fn draw(l: *const Loupe, f: *sk.Frame, placed: anim.Placed) void { const deep = l.from == .field; holding[@intFromBool(deep)] = null; const opened = placed.value(l.opening) * time.open; const closed = placed.value(l.closing); if (opened <= 0 or closed >= 1 or ui.mapping) return; const u: ui.Ui = .{ .f = f, .at = placed }; const now = l.cursor.now(placed); const p = l.place(u, now) orelse return; holding[@intFromBool(deep)] = .{ .lo = p.first, .hi = p.first + 16 * k.rows, .shows = std.math.clamp((opened - time.read) / time.rise, 0, 1) * (1 - closed) }; // Its pointer framed as read, first. u.read(p.pointer, std.math.clamp(opened / time.read, 0, 1) * (1 - closed)); // It rises with the stem: in over 12 f from 8 lower, its shadow growing; it sinks as it closes. const since = opened - time.read; if (since <= 0) return; const rise = std.math.clamp(since / time.rise, 0, 1) * (1 - closed); const lower = (1 - theme.ease(.enter, std.math.clamp(since / time.rise, 0, 1))) * theme.time.caption_rise + closed * theme.time.caption_rise; const grow = cursors.standard(std.math.clamp(since / time.shadow, 0, 1)) * (1 - closed); const off = k.shadow[@intFromBool(deep)]; const b = p.box; const v = u.faded(rise).moved(b.x, b.y + lower); v.fill(.{ .x = off[0] * grow, .y = off[1] * grow, .w = b.w, .h = b.h }, theme.color.shade); v.fill(.{ .x = 0, .y = 0, .w = b.w, .h = b.h }, theme.color.lift); v.fill(.{ .x = 0, .y = 0, .w = b.w, .h = m.tag }, theme.color.lift_tag); v.frame(.{ .x = 0, .y = 0, .w = b.w, .h = b.h }, t.dim, theme.stroke.rule); // The tag: the pointer it opens from, and the target in its region's ink; the region and the type. const size = theme.size.mono.context; const base = m.tag - 6; const moment = now.moment(); const things = objects.reach(f.scratch, l.cursor.rec, moment, null); const object: ?objects.Object = for (things) |o| { if (o.holds(p.target)) break o; } else null; var x: f32 = m.side; switch (l.from) { .register => |name| { v.text(.mono, size, x, base, name, t.dim); x += v.width(.mono, size, name) + 6; }, .field => |field| x = v.address(x, base, field.at, .{ .ink = ui.rgb(rows.ink(rows.regionOf(moment, field.at))) }) + 6, .row => |row| { v.text(.mono, size, x, base, row.name, t.dim); x += v.width(.mono, size, row.name) + 6; }, } x = v.arrow(x, m.tag / 2, .points) + 8; _ = v.address(x, base, p.target, .{ .ink = ui.rgb(p.ink) }); const region = switch (rows.regionOf(moment, p.target)) { .stack => "stack", .heap => "heap", .code => "code", .data, .rwx => "data", .rodata => "read-only", .none => "", }; const note = if (l.from == .row) l.from.row.note else if (object) |o| v.print("{s} \u{00b7} {s}, {d} bytes", .{ region, if (o.name.len > 0) o.name else "a struct", o.type.record.size }) else region; v.text(.sans, theme.size.sans.micro, b.w - 10 - v.width(.sans, theme.size.sans.micro, note), base, note, t.dim); // Its rows, typed where the recording types them, its own pointers as arcs at full ink. const top = m.tag + m.pad; v.clip(.{ .x = 0, .y = m.tag, .w = b.w, .h = b.h - m.tag }); // By the scene's fields: the rows that hold them, the rest `more`. if (l.from == .row) hexdump.fielded(.{ .u = v, .rows = k.rows, .box = b }, now, top, l.from.row.fields) else hexdump.drawArcs(v, now, 0, top, p.first, k.rows, .{ .things = things }, true, .{ m.tag, b.h - m.pad }); v.unclip(); // Its target, framed bright: each field of the struct, or the word. const framed = std.math.clamp((since - time.stem - time.frame) / time.frame, 0, 1); if (framed > 0 and l.from != .row) { const row_y = top + @as(f32, @floatFromInt((p.target - p.first) / 16)) * m.row; const shift = rows.addressRoom(p.first + 16 * (k.rows - 1)); const w = v.faded(framed); if (object) |o| { for (o.type.record.fields) |field| frameRun(w, row_y, shift, o.addr + field.offset - (p.target & ~@as(u64, 15)), field.type.size() orelse 8); } else frameRun(w, row_y, shift, p.target % 16, 8); } // The stem: a bracket under the pointer's digits, lying on the tag, drawn head first. const drawn = cursors.standard(std.math.clamp(since / time.stem, 0, 1)) * (1 - closed); u.faded(@min(rise * 2, 1)).fill(.{ .x = p.pointer.x - 2, .y = p.pointer.y + p.pointer.h - 3, .w = (p.pointer.w + 4) * drawn, .h = k.stem }, p.ink); } }; /// `attention` on the bytes `at .. at + len` of a row (from its first /// byte, up to its end): a 2-unit bright frame round them. fn frameRun(u: ui.Ui, y: f32, shift: f32, at: u64, len: u64) void { if (at >= 16 or len == 0) return; const first: u8 = @intCast(at); const last: u8 = @intCast(@min(at + len, 16) - 1); const x0 = shift + rows.byteX(first) - 4; const x1 = shift + rows.byteX(last) + 28; u.frame(.{ .x = x0 - 3, .y = y - 1, .w = x1 - x0 + 6, .h = m.row + 2 }, theme.mark(.attention).solid, theme.stroke.rule); }