1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
|
//! `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.
/// It may open again after a `close`. (Its clock runs on past the
/// open, for the strikes in it: `opening` counts open's lengths.)
pub fn open(l: *const Loupe, s: *anim.Frame) void {
const start = s.cursor;
s.play(.{ l.opening.to(0), l.closing.to(0) }, .{ .seconds = 0 });
s.play(.{l.opening.to(open_lengths)}, .{ .seconds = open_lengths * time.open, .ease = anim.ease.linear });
s.cursor = start + time.open;
}
const open_lengths = 8;
/// `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 });
}
/// What it opens on, by the pointer's name: for the map, where an open loupe is a panel of its own.
pub fn aim(l: *const Loupe, now: cursors.Now) ?struct { name: []const u8, target: u64 } {
const moment = now.moment();
return switch (l.from) {
.register => |name| blk: {
const regs = (moment.regs(l.cursor.rec.tid) catch null) orelse return null;
break :blk .{ .name = name, .target = regs.named(name) orelse return null };
},
.field => |field| .{ .name = "its field", .target = (Recording.word(moment, field.at, 8) catch null) orelse return null },
.row => |row| .{ .name = row.name, .target = row.fields.base },
};
}
/// 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;
// From the band's view it lies over the stack's first rows, its tag on the stack's, never over the registers (what a step changes there is what the captions are about).
const stack = l.stage.box(u.at, .stack);
const h = theme.layout.panelH(k.rows);
return .{ .box = .{ .x = stack.x, .y = stack.y, .w = k.width, .h = h }, .pointer = pointer, .target = target, .first = target, .ink = rows.ink(rows.regionOf(moment, target)) };
},
}
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);
var x = std.math.clamp(@max(pointer.x - k.hang, right), stage.x, stage.x + stage.w - k.width);
var y = @min(pointer.y + pointer.h - 1, stage.y + stage.h - h);
// A deeper one with no room to the right hangs under the one it opens from, both whole.
if (l.from == .field and x < right) {
const parent = l.from.field.loupe.place(u, now).?.box;
x = parent.x;
y = @min(parent.y + parent.h + k.shadow[0][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 or @import("map.zig").looking(f)) 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`.
// Its fields strike once it has opened, 6 f after it and 6 f apart.
var fields = if (l.from == .row) l.from.row.fields else undefined;
if (l.from == .row and now.walking()) fields.struck = opened - time.open - cursors.write_apart;
if (l.from == .row) hexdump.fielded(.{ .u = v, .rows = k.rows, .box = b }, now, top, 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);
}
const drawn = cursors.standard(std.math.clamp(since / time.stem, 0, 1)) * (1 - closed);
// From a row of the band's view: the stem leaves the row's left, goes down the gutter's right lane, into the tag.
if (l.from == .row) {
const view = l.stage.box(placed, .view);
const mid = p.pointer.y + p.pointer.h / 2;
const lane = view.x - k.lane;
u.faded(@min(rise * 2, 1)).route(&.{ .{ view.x, mid }, .{ lane, mid }, .{ lane, b.y + lower + m.tag / 2 }, .{ b.x - 2, b.y + lower + m.tag / 2 } }, p.ink, .{ .width = theme.stroke.line, .head = .{ 10, 10 }, .radius = 4, .progress = drawn });
return;
}
// Hung under the one it opens from: the stem goes down from the pointer to its tag.
if (b.y > p.pointer.y + p.pointer.h + 1) u.faded(@min(rise * 2, 1)).fill(.{ .x = p.pointer.x + 8, .y = p.pointer.y + p.pointer.h - 3, .w = k.stem, .h = (b.y + lower - (p.pointer.y + p.pointer.h - 3)) * drawn }, p.ink);
// The stem: a bracket under the pointer's digits, lying on the tag, drawn head first.
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);
}
|