summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/Core.zig96
-rw-r--r--src/Effect.zig4
-rw-r--r--src/Event.zig14
-rw-r--r--src/Jump.zig77
-rw-r--r--src/Output.zig26
-rw-r--r--src/Store.zig2
-rw-r--r--src/body_layer.zig16
-rw-r--r--src/builtins.zig59
-rw-r--r--src/colors.zig10
-rw-r--r--src/config.zig49
-rw-r--r--src/draw.zig43
-rw-r--r--src/dump.zig67
-rw-r--r--src/edit.zig33
-rw-r--r--src/exec.zig8
-rw-r--r--src/file_watch.zig89
-rw-r--r--src/fs.zig3
-rw-r--r--src/gui/gui.zig61
-rw-r--r--src/host_io.zig26
-rw-r--r--src/keys.zig8
-rw-r--r--src/look.zig301
-rw-r--r--src/macos.zig44
-rw-r--r--src/memory.zig18
-rw-r--r--src/modal.zig2
-rw-r--r--src/mouse.zig102
-rw-r--r--src/ninep/ctl.zig54
-rw-r--r--src/ninep/pane.zig21
-rw-r--r--src/normal.zig23
-rw-r--r--src/panes.zig76
-rw-r--r--src/pardes.zig30
-rw-r--r--src/pdf.zig1904
-rw-r--r--src/pdf_view.zig3721
-rw-r--r--src/replica.zig2
-rw-r--r--src/rollback.zig12
-rw-r--r--src/surface.zig6
-rw-r--r--src/tagline.zig14
-rw-r--r--src/tape.zig12
-rw-r--r--src/terminal.zig5
-rw-r--r--src/tui/tui.zig112
-rw-r--r--src/walk.zig9
-rw-r--r--src/wire.zig55
40 files changed, 562 insertions, 6652 deletions
diff --git a/src/Core.zig b/src/Core.zig
index b1195ac2..cd7b4ec5 100644
--- a/src/Core.zig
+++ b/src/Core.zig
@@ -74,7 +74,6 @@ const modal = pardes.modal;
const mouse = pardes.mouse;
const newer_build_words = pardes.newer_build_words;
const pager = pardes.pager;
-const pdf_enabled = pardes.pdf_enabled;
const platform = pardes.platform;
const recent_files = @import("recent.zig");
const sel_slot = pardes.sel_slot;
@@ -164,6 +163,11 @@ pub const View = struct {
header_drag: bool = false,
/// A middle or right sweep held over a column's or the workspace's tag.
header_sweep: ?mouse.HeaderSweep = null,
+ /// The kind's pane a press went to, which has its drag and release
+ /// wherever the pointer goes; and the one the pointer is over, told
+ /// when it leaves (mouse.kindMouse).
+ kind_grab: ?u8 = null,
+ kind_hover: ?u8 = null,
header_scroll: usize = 0,
/// The focused header's first line on screen, which follows its caret
/// when it has more lines than rows.
@@ -180,7 +184,6 @@ image_gpa: std.mem.Allocator,
/// Its kinds of pane (Kind.zig): the compiled-in ones, then what addons
/// brought; the data both cores hold, the code only the authority.
kinds: pardes.Kind.Registry = .{},
-pdf_gpa: std.mem.Allocator,
tree_sitter_gpa: std.mem.Allocator,
opts: Options,
resize_count: usize = 0,
@@ -271,7 +274,6 @@ look_hover_wait: ?look.LookHoverWait = null,
/// resting there does not ask again every frame (look.noteLookHover).
look_hover_refused: ?look.LookHoverWait = null,
look_hover_preview: ?look.LookHoverPreview = null,
-pdf_hover_preview: if (pdf_enabled) ?look.PdfWordPreview else void = if (pdf_enabled) null else {},
/// While a key is replayed across the ranges (normal.replaySels): which
/// range this pass is, in document order, how many there are, and
/// whether this is the first pass; outside a replay, the one range and
@@ -472,7 +474,6 @@ pub fn create(gpa: std.mem.Allocator, opts: Options) !*Pardes {
.gpa = gpa,
.image_gpa = opts.image_allocator orelse gpa,
.kinds = .started(opts.addons),
- .pdf_gpa = opts.pdf_allocator orelse gpa,
.tree_sitter_gpa = opts.tree_sitter_allocator orelse gpa,
.opts = opts,
.tty_toggle = opts.tty_toggle,
@@ -520,10 +521,18 @@ fn initSession(gpa: std.mem.Allocator, opts: Options) !*Pardes {
.document => {
const path = opts.file.?;
const opened = initial_doc: {
- if (comptime pdf_enabled) if (look.isPdfPath(path))
- break :initial_doc pardes.panes.Pdf.openPane(p, 0, path, opts.file_line, .last);
- if (p.kinds.forPath(path)) |kind|
- break :initial_doc pardes.Kind.openFile(p, 0, kind, path);
+ if (p.kinds.forPath(path)) |kind| {
+ const made = pardes.Kind.openFile(p, 0, kind, path);
+ // `pardes book.pdf:12`'s place, the kind's to take.
+ if (made) |_| {
+ if (opts.file_line > 0) {
+ var said: pardes.Kind.Buf(160) = .{};
+ var place: [16]u8 = undefined;
+ _ = pardes.Kind.address(p, 0, std.fmt.bufPrint(&place, "{d}", .{opts.file_line}) catch "", &said);
+ }
+ } else |_| {}
+ break :initial_doc made;
+ }
break :initial_doc pardes.panes.File.open(p, 0, path, opts.file_line);
};
if (opened) |_| {} else |err| {
@@ -661,7 +670,7 @@ pub fn recentKeeps(path: []const u8) bool {
return exec.kindOf(local) == .file;
}
-/// A file, PDF or image pane closing: its place noted in Recent, when
+/// A file pane or a kind's (a PDF, a picture) closing: its place noted in Recent, when
/// Recent keeps it.
pub fn noteClosed(p: *Pardes, pane: *const Pane) void {
const d = recentPlace(pane) orelse return;
@@ -674,12 +683,16 @@ pub fn noteClosed(p: *Pardes, pane: *const Pane) void {
pub const RecentPlace = struct { path: []const u8, line: u32, col: u32, aline: u32 = 0, acol: u32 = 0 };
-/// Where a pane is, as Recent keeps it: a file's dot, a PDF's page
-/// (`:page:1`), a kind's pane's path alone (line 0). Null for any other.
+/// Where a pane is, as Recent keeps it: a file's dot, a kind's pane's
+/// path and the first number of its `where` (a PDF's page), 0 for none.
+/// Null for any other.
pub fn recentPlace(pane: *const Pane) ?RecentPlace {
if (recentDot(pane)) |d| return .{ .path = d.path, .line = d.line, .col = d.col, .aline = d.aline, .acol = d.acol };
- if (pane.pdfPath()) |path| return .{ .path = path, .line = @intCast(pane.pdfPage().? + 1), .col = 1 };
- if (pane.addon) |k| if (k.path.len > 0) return .{ .path = k.path, .line = 0, .col = 0 };
+ if (pane.addon) |k| if (k.path.len > 0) {
+ var buf: [32]u8 = undefined;
+ const line = Jump.firstNumber(pardes.Kind.placeOf(@constCast(k), &buf));
+ return .{ .path = k.path, .line = line, .col = @intFromBool(line > 0) };
+ };
return null;
}
@@ -1038,13 +1051,7 @@ pub fn rejectFont(p: *Pardes) void {
fn applyWatchedFileChanged(p: *Pardes, id: u8, bytes: []const u8) bool {
if (id >= MAX_PANES) return false;
const pane = p.panes[id] orelse return false;
- if (comptime pdf_enabled) if (pane.pdf != null) {
- pardes.panes.Pdf.reloadWatched(p, pane) catch |err| {
- p.reportError(id, "PDF reload", err);
- return false;
- };
- return true;
- };
+ if (pane.addon != null) return pardes.Kind.fileChanged(p, id, bytes);
if (pane.file == null) return false;
pardes.panes.File.changed(p, id, bytes);
return if (p.panes[id]) |current|
@@ -1536,7 +1543,6 @@ pub fn update(p: *Pardes, ev: Event) void {
.mouse => |m| m.button == .none and m.kind == .motion,
.output => |o| look.lookHoverPane(p) != o.pane,
.file_changed => |changed| look.lookHoverPane(p) != changed.pane,
- .pdf_scroll => |scroll| look.lookHoverPane(p) != scroll.pane,
else => false,
};
if (!hover_stays) {
@@ -1566,31 +1572,11 @@ pub fn update(p: *Pardes, ev: Event) void {
switch (ev) {
.resize => |sz| {
if (sz.row_metrics) |metrics| v.row_metrics = metrics;
- if (comptime pdf_enabled) {
- var before: [MAX_PANES]?pardes.panes.Pdf.Viewport = @splat(null);
- for (p.panes, 0..) |slot, id| {
- const pane = slot orelse continue;
- if (pane.pdf != null) before[id] = pardes.panes.Pdf.paneViewport(p, pane);
- }
- v.screen_w = sz.cols;
- v.screen_h = sz.rows;
- v.cell_pixels.w = @max(1, sz.cell_pixels.w);
- v.cell_pixels.h = @max(1, sz.cell_pixels.h);
- layout.compute(p);
- for (p.panes, 0..) |slot, id| {
- const pane = slot orelse continue;
- if (pane.pdf) |pv| {
- if (!std.meta.eql(before[id], pardes.panes.Pdf.paneViewport(p, pane))) {
- pardes.panes.Pdf.captureLayoutAnchor(pv);
- pv.layout_valid = false;
- pv.search_reveal_pending = pv.search_query.len > 0;
- }
- }
- }
- } else {
- v.screen_w = sz.cols;
- v.screen_h = sz.rows;
- }
+ v.screen_w = sz.cols;
+ v.screen_h = sz.rows;
+ v.cell_pixels.w = @max(1, sz.cell_pixels.w);
+ v.cell_pixels.h = @max(1, sz.cell_pixels.h);
+ layout.compute(p);
p.resize_count += 1;
},
.output => |o| {
@@ -1625,16 +1611,6 @@ pub fn update(p: *Pardes, ev: Event) void {
@import("keys.zig").handleKey(p, key);
},
.mouse => |m| mouse.handleMouse(p, m),
- .pdf_scroll => |scroll| {
- if (comptime pdf_enabled) {
- if (scroll.pane < MAX_PANES) {
- if (p.panes[scroll.pane]) |pane| {
- if (pane.hasPdf() and v.frontend.native_images)
- _ = pardes.panes.Pdf.scrollPane(p, pane, @floatCast(scroll.delta_pixels), scroll.glide);
- }
- }
- }
- },
.paste => |bytes| {
p.typedInto();
edit.applyPaste(p, bytes);
@@ -1651,6 +1627,7 @@ pub fn update(p: *Pardes, ev: Event) void {
v.frontend = f;
},
.pointer_leave => {
+ mouse.kindLeave(p);
v.pointer_inside = false;
v.pointer_body_hit = null;
v.pointer_tag_hit = null;
@@ -1955,8 +1932,6 @@ pub fn nextWake(p: *const Pardes) ?u64 {
for (p.panes) |slot| if (slot) |pane| if (pane.places.busy(pane)) return next;
const kinds = pardes.Kind.wake(p);
if (kinds) |due| if (due <= next) return next;
- // A PDF page being rendered on a lane lands on the frame after it is done.
- if (comptime pdf_enabled) for (p.panes) |slot| if (slot) |pane| if (pane.pdf) |st| if (pardes.panes.Pdf.rendering(st)) return next;
// A markdown text's tables still being read from the top (Tables.zig).
for (p.panes) |slot| if (slot) |pane| if (pane.file) |f| if (f.tables.busy()) return next;
if (pardes.panes.Query.busy(p)) return next;
@@ -2193,7 +2168,6 @@ pub const Options = struct {
image_allocator: ?std.mem.Allocator = null,
/// What the host's scan of the addon directories found (Addon.scan).
addons: []const pardes.Kind.Loaded = &.{},
- pdf_allocator: ?std.mem.Allocator = null,
tree_sitter_allocator: ?std.mem.Allocator = null,
/// Where each frame's Surface text is built. Hosts pass a purpose-built
/// stack-fallback arena; null means the general allocator.
@@ -2204,7 +2178,7 @@ pub const Options = struct {
pub const Haptic = enum { none, exec, look };
-/// Zero-sized off macOS, the way PdfSlot is off -Dmupdf: no other shell reads
+/// Zero-sized off macOS: no other shell reads
/// the field, so no other shell carries it.
const HapticSlot = if (platform == .macos) Haptic else void;
@@ -2241,7 +2215,7 @@ const FakeTtyQuery = struct {
};
fn bootAndTearDown(gpa: std.mem.Allocator) !void {
- const p = try Pardes.init(gpa, .{ .cols = 56, .rows = 14, .tty_only = true, .frame_allocator = gpa, .image_allocator = gpa, .pdf_allocator = gpa, .tree_sitter_allocator = gpa });
+ const p = try Pardes.init(gpa, .{ .cols = 56, .rows = 14, .tty_only = true, .frame_allocator = gpa, .image_allocator = gpa, .tree_sitter_allocator = gpa });
p.deinit();
}
diff --git a/src/Effect.zig b/src/Effect.zig
index f5ee7ff9..2bcf82f5 100644
--- a/src/Effect.zig
+++ b/src/Effect.zig
@@ -226,8 +226,8 @@ pub fn perform(p: *Pardes, e: Effect) void {
}
},
.watch => |w| if (v.watch_file) |f| {
- // What a watch is about: a real file, or a PDF.
- const path: []const u8 = if (p.panes[w.pane]) |pane| (if (pane.file) |file| (if (file.output == null) file.path else "") else pane.pdfPath() orelse "") else "";
+ // What a watch is about: a real file, or a kind's (a PDF's).
+ const path: []const u8 = if (p.panes[w.pane]) |pane| (if (pane.file) |file| (if (file.output == null) file.path else "") else if (pane.addon) |k| k.path else "") else "";
f(p.host.ctx, w.pane, path, w.on, w.mode);
} else {
p.fallback.watched[w.pane] = w.on;
diff --git a/src/Event.zig b/src/Event.zig
index bf27ff69..63dcb5f2 100644
--- a/src/Event.zig
+++ b/src/Event.zig
@@ -4,7 +4,6 @@ const config = @import("config.zig");
const selection_pipe = @import("selection_pipe.zig");
const Stream = @import("Stream.zig");
const Layer = @import("Layer.zig");
-const pdf_enabled = @import("panes.zig").Pdf.enabled;
const RowMetrics = Layer.Metrics;
const TagHit = Layer.TagHit;
@@ -89,12 +88,12 @@ pub fn hit(key: Key, binding: []const config.Chord) bool {
pub const sel_slot = @backingInt(config.select_button);
-/// Pixel dimensions are meaningful only to the native PDF placement path.
-/// Keep resize events layout-only when that path is not part of the build.
-pub const CellPixels = if (pdf_enabled) struct {
+/// A cell's pixels, as the frontend draws it: what a kind's pictures and a
+/// terminal's kitty images are laid out at.
+pub const CellPixels = struct {
w: u16 = 8,
h: u16 = 16,
-} else struct {};
+};
pub const Event = union(enum) {
key: Key,
@@ -125,11 +124,6 @@ pub const Event = union(enum) {
search: Stream.Batch,
paste: []const u8,
command: []const u8,
- /// Native shells may preserve sub-cell wheel distance in physical pixels.
- /// TTY button events still enter through the ordinary mouse path.
- /// `glide`: a wheel's notch, which the strip glides; a touchpad's
- /// fraction is followed as it comes.
- pdf_scroll: struct { pane: u8, delta_pixels: f32, glide: bool = true },
/// The host pointer left the drawable area. Unlike an out-of-range motion,
/// this must not clamp onto and preview the final grid cell.
pointer_leave,
diff --git a/src/Jump.zig b/src/Jump.zig
index 0d82d104..10014e9e 100644
--- a/src/Jump.zig
+++ b/src/Jump.zig
@@ -41,10 +41,43 @@ pub const Loc = struct {
col: u32,
/// The file it is in (Wyhash of the path), 0 for a pane with none.
path_hash: u64 = 0,
- /// A PDF's place: `line` its page (one-based), `col` how far down it
- /// (pdf_view.Place.at, a fraction of the page in 2^-32).
- pdf: bool = false,
+ /// A kind's pane's place, its `where` (a PDF's `12:0.330000`), with
+ /// `line` its first number.
+ place: Kind.Buf(32) = .{},
};
+const Kind = @import("Kind.zig");
+
+/// A kind's pane's place now, its `where`.
+fn kindPlace(pane: *Pane) ?Kind.Buf(32) {
+ const slot = pane.addon orelse return null;
+ if (!slot.live) return null;
+ var buf: [32]u8 = undefined;
+ const w = Kind.placeOf(slot, &buf);
+ if (w.len == 0) return null;
+ var out: Kind.Buf(32) = .{};
+ out.set(w);
+ return out;
+}
+
+/// A place's first number: a kind's line (a PDF's page).
+/// A kind's place `L:F S` as where it is (L + F, in lines) and its
+/// window's height (S lines); null for one without both.
+fn spanOf(text: []const u8) ?[2]f64 {
+ const sp = std.mem.lastIndexOfScalar(u8, text, ' ') orelse return null;
+ const colon = std.mem.indexOfScalar(u8, text[0..sp], ':') orelse return null;
+ const line = std.fmt.parseFloat(f64, text[0..colon]) catch return null;
+ const frac = std.fmt.parseFloat(f64, text[colon + 1 .. sp]) catch return null;
+ return .{ line + frac, std.fmt.parseFloat(f64, text[sp + 1 ..]) catch return null };
+}
+
+pub fn firstNumber(text: []const u8) u32 {
+ var n: u32 = 0;
+ for (text) |ch| {
+ if (ch < '0' or ch > '9') break;
+ n = n *| 10 +| (ch - '0');
+ }
+ return n;
+}
/// A session for the side-button jump test: four panes of 100 lines in one
/// column, A (pane 0) and B each on a file of its own, C on A's file, and O
@@ -128,22 +161,22 @@ const JumpsTest = struct {
}
};
-/// The file a jump in `pane` is in: a text's, a PDF's.
+/// The file a jump in `pane` is in: a text's, a kind's (a PDF's).
fn jumpPath(pane: *const Pane) ?[]const u8 {
if (Pardes.recentDot(pane)) |d| return d.path;
- return pane.pdfPath();
+ if (pane.addon) |k| if (k.path.len > 0) return k.path;
+ return null;
}
fn samePlace(p: *const Pardes, a: Loc, b: Loc) bool {
if (a.pane != b.pane or a.serial != b.serial) return false;
- // A PDF's places by where they stand on its strip, as a text's by
- // lines: within a body of each other, one visit.
- if (a.pdf and b.pdf) if (p.panes[b.pane]) |pane| {
- const view = panes.Pdf.paneViewport(p, pane) orelse return a.line == b.line;
- const ya = panes.Pdf.placeY(pane, .{ .page = a.line - 1, .at = a.col }) orelse return a.line == b.line;
- const yb = panes.Pdf.placeY(pane, .{ .page = b.line - 1, .at = b.col }) orelse return a.line == b.line;
- return @abs(ya - yb) <= @as(f64, @floatFromInt(view.pixel_h));
- };
+ // A kind's places within a window of each other (`where`'s `L:F S`:
+ // the window S lines), else by their first numbers (a page or the
+ // next), one visit.
+ if (a.place.len > 0 and b.place.len > 0) {
+ if (spanOf(a.place.slice())) |x| if (spanOf(b.place.slice())) |y| return @abs(x[0] - y[0]) <= @max(x[1], y[1]);
+ return @max(a.line, b.line) - @min(a.line, b.line) <= 1;
+ }
if (a.line == 0 or b.line == 0) return true;
const body = @max(1, p.view().rects[b.pane].h -| BOX_H);
return @max(a.line, b.line) - @min(a.line, b.line) <= body;
@@ -191,14 +224,14 @@ pub fn trackJump(p: *Pardes) void {
if (pane.query) |q| if (!q.frozen) return;
const force = v.jumps.force;
v.jumps.force = false;
- const pdf_place = panes.Pdf.place(pane);
+ const place = kindPlace(pane);
const now: Loc = .{
.pane = @intCast(v.active),
.serial = pane.serial,
- .line = if (pdf_place) |at| @intCast(at.page + 1) else if (pane.body.cur_pinned) @intCast(@max(0, pane.body.cur_row) + 1) else 0,
- .col = if (pdf_place) |at| at.at else if (pane.body.cur_pinned) @intCast(@max(0, pane.body.cur_col) + 1) else 0,
+ .line = if (place) |at| firstNumber(at.slice()) else if (pane.body.cur_pinned) @intCast(@max(0, pane.body.cur_row) + 1) else 0,
+ .col = if (place != null) 0 else if (pane.body.cur_pinned) @intCast(@max(0, pane.body.cur_col) + 1) else 0,
.path_hash = if (jumpPath(pane)) |path| std.hash.Wyhash.hash(0, path) else 0,
- .pdf = pdf_place != null,
+ .place = place orelse .{},
};
if (!force and v.jumps.n > 0 and samePlace(p, v.jumps.list[v.jumps.cur], now)) {
v.jumps.list[v.jumps.cur] = now; // same visit; the entry IS where you are
@@ -289,11 +322,12 @@ pub fn jumpBy(p: *Pardes, delta: i32) void {
}
const e = found.?;
const from = v.active;
- look.reopenAt(p, from, e.path, .{ .line = @max(1, j.line), .col = if (j.pdf) 0 else @max(1, j.col) });
+ look.reopenAt(p, from, e.path, .{ .line = @max(1, j.line), .col = if (j.place.len > 0) 0 else @max(1, j.col) });
const opened = p.panes[v.active] orelse return;
const opened_path = jumpPath(opened) orelse return;
if (!std.mem.eql(u8, opened_path, e.path)) return; // it did not open
- if (j.pdf) panes.Pdf.landAt(p, opened, .{ .page = j.line -| 1, .at = j.col });
+ var said: Kind.Buf(160) = .{};
+ if (j.place.len > 0) _ = Kind.address(p, v.active, j.place.slice(), &said);
// Every entry of that file is the reopened pane from here on, so
// a step onto another of them moves in it rather than reopening.
for (v.jumps.list[0..p.view().jumps.n]) |*k| if (k.serial == 0 and k.path_hash == j.path_hash) {
@@ -308,9 +342,10 @@ pub fn jumpBy(p: *Pardes, delta: i32) void {
if (p.panes[v.active]) |source| look.clearNavigationSelection(p, source);
if (v.active != j.pane) look.clearNavigationSelection(p, pane);
v.jumps.cur = next;
- if (pane.pdfPath() != null) {
+ if (pane.addon != null) {
look.focusPaneLine(p, j.pane, .{ .line = 0, .col = 0 }, .keep);
- panes.Pdf.landAt(p, pane, .{ .page = j.line -| 1, .at = if (j.pdf) j.col else 0 });
+ var said: Kind.Buf(160) = .{};
+ if (j.place.len > 0) _ = Kind.address(p, j.pane, j.place.slice(), &said);
return;
}
look.focusPaneLine(p, j.pane, .{ .line = j.line, .col = j.col }, .center);
diff --git a/src/Output.zig b/src/Output.zig
index 006ab7bd..20d672d2 100644
--- a/src/Output.zig
+++ b/src/Output.zig
@@ -27,7 +27,9 @@ pub const Origin = union(enum) {
query: lsp.Kind,
search,
errors,
- pdf_links,
+ /// A kind's list (`pa_api.text`: a +PdfSections, a +Links), named its
+ /// argument: rows of places n/N walk, a Look of one its kind's.
+ kind,
/// The panes a refusal (Exit, Restore, Del, Delcol, get) is over, kept
/// in +Unsaved rather than a notice that goes.
unsaved,
@@ -254,7 +256,7 @@ pub fn traits(o: Origin) Traits {
// rows are `location text`, so n/N walk them
.search => .{ .name = config.search_buffer, .steps = true, .locations = true },
.errors => .{ .name = config.errors_buffer, .doc = true },
- .pdf_links => .{ .name = config.pdf_links_buffer, .steps = true, .locations = true },
+ .kind => .{ .name = "", .steps = true, .locations = true },
.unsaved => .{ .name = config.unsaved_buffer, .doc = true },
.preview => .{ .name = config.preview_buffer, .doc = true },
// Named for its directory, not a `+` name in it.
@@ -291,7 +293,7 @@ pub fn traits(o: Origin) Traits {
pub fn usesLocationsConfig(from: Origin) bool {
const tr = traits(from);
- return tr.steps and !tr.commands and from != .pdf_links and
+ return tr.steps and !tr.commands and from != .kind and
!std.meta.eql(from, Origin{ .query = .completion }) and
!std.meta.eql(from, Origin{ .query = .callstack });
}
@@ -358,7 +360,7 @@ fn sortResults(arena: std.mem.Allocator, from: Origin, content: []u8, anchor: ?u
=> {},
else => return anchor,
},
- .errors, .pdf_links, .unsaved, .dir, .preview => return anchor,
+ .errors, .kind, .unsaved, .dir, .preview => return anchor,
}
if (content.len == 0) return anchor;
const trailing_newline = content[content.len - 1] == '\n';
@@ -437,7 +439,7 @@ pub fn nextResult(content: []const u8, rows: []const locations.Row, path: []cons
pub fn open(p: *Pardes, id: usize, dir: []const u8, from: Origin, arg: []const u8, content: []u8) !*Pane {
const path = try std.fmt.allocPrint(p.gpa, "{s}/{s}", .{
- std.mem.trimEnd(u8, dir, "/"), traits(from).name,
+ std.mem.trimEnd(u8, dir, "/"), if (from == .kind) arg else traits(from).name,
});
errdefer p.gpa.free(path);
var out: State = .{ .from = from };
@@ -630,8 +632,8 @@ pub fn openJumps(p: *Pardes, id: usize) !void {
// A closed file's entry: marked, and a look at it opens it again.
if (j.serial == 0) {
const e = p.recentByHash(j.path_hash) orelse continue;
- // A PDF's `col` is how far down its page, no Look's column.
- if (j.pdf) {
+ // A kind's place has no Look's column.
+ if (j.place.len > 0) {
try out.writer.print("{s}:{d} (closed)\n", .{ e.path, @max(1, j.line) });
continue;
}
@@ -640,25 +642,23 @@ pub fn openJumps(p: *Pardes, id: usize) !void {
}
const jp = p.panes[j.pane] orelse continue;
var idbuf: [16]u8 = undefined;
- const pdf_path: ?[]const u8 = if (comptime pardes.pdf_enabled) jp.pdfPath() else null;
- const has_path = if (jp.file) |f| f.output == null else pdf_path != null;
+ const kind_path: ?[]const u8 = if (jp.addon) |k| (if (k.path.len > 0) k.path else null) else null;
+ const has_path = if (jp.file) |f| f.output == null else kind_path != null;
const loc: []const u8 = if (has_path)
- (if (jp.file) |f| f.path else pdf_path.?)
+ (if (jp.file) |f| f.path else kind_path.?)
else
std.fmt.bufPrint(&idbuf, config.pane_addr ++ "{d}", .{jp.serial}) catch unreachable;
const what: []const u8 = if (jp.file) |f|
std.mem.trim(u8, modal.lineSlice(f.content, j.line -| 1), " \t\r")
else if (jp.addon) |k|
k.path
- else if (pdf_path) |path|
- path
else
jp.cwdSlice();
var cut = @min(what.len, 120);
while (cut > 0 and cut < what.len and what[cut] & 0xc0 == 0x80) cut -= 1;
if (j.line == 0)
try out.writer.print("{s} {s}\n", .{ loc, what[0..cut] })
- else if (j.pdf)
+ else if (j.place.len > 0)
try out.writer.print("{s}:{d} {s}\n", .{ loc, j.line, what[0..cut] })
else
try out.writer.print("{s}:{d}:{d} {s}\n", .{ loc, j.line, j.col, what[0..cut] });
diff --git a/src/Store.zig b/src/Store.zig
index 64a8a7be..afe07742 100644
--- a/src/Store.zig
+++ b/src/Store.zig
@@ -106,7 +106,7 @@ pub fn keep(s: *Store, p: *Pardes, id: usize) ?Kept {
gpa.free(owned);
return null;
}
- const what: []const u8 = if (pane.file) |f| f.path else if (pane.pdfPath()) |pdf| pdf else if (pane.addon) |k| k.path else if (pane.command) |c| c else pane.cwdSlice();
+ const what: []const u8 = if (pane.file) |f| f.path else if (pane.addon) |k| k.path else if (pane.command) |c| c else pane.cwdSlice();
var name = gpa.alloc(u8, @min(what.len, 4096)) catch {
gpa.free(owned);
return null;
diff --git a/src/body_layer.zig b/src/body_layer.zig
index dc5e51bf..56c4bc79 100644
--- a/src/body_layer.zig
+++ b/src/body_layer.zig
@@ -15,7 +15,6 @@ const Color = @import("surface.zig").Color;
const CellStyle = @import("surface.zig").CellStyle;
const Cell = @import("surface.zig").Cell;
const Surface = @import("surface.zig").Surface;
-const pdf_enabled = panes.Pdf.enabled;
const Pane = panes.Pane;
const BOX_H = pardes.BOX_H;
const TAG_TEXT_INSET = pardes.TAG_TEXT_INSET;
@@ -29,7 +28,7 @@ const Layer = @import("Layer.zig");
// ---- drawing a pane body into the surface ----
fn paintTerminalSelection(p: *Pardes, s: *Surface, pane: *Pane, r: Rect, rows: []const Pane.PointerRow, bg: [3]u8, fg: ?[3]u8) void {
- const body = bodyText(p, p.scratch.allocator(), pane) catch return;
+ const body = bodyText(p.scratch.allocator(), pane) catch return;
const raw = pane.body.mode == .tty;
const tx = r.x + config.GUTTER;
const width = r.w -| config.GUTTER;
@@ -248,7 +247,7 @@ pub fn renderBody(p: *Pardes, s: *Surface, arena: std.mem.Allocator, pane: *Pane
};
const tz_body = tracy.zone(@src(), "bodyText");
const probe_text = pardes.FrameStats.nowNs();
- const body = try bodyText(p, arena, pane);
+ const body = try bodyText(arena, pane);
p.frames.zone(.body_text, probe_text);
tz_body.end();
// A select sweep begun on the tag and dragged into the body marks the
@@ -475,21 +474,12 @@ pub fn renderBody(p: *Pardes, s: *Surface, arena: std.mem.Allocator, pane: *Pane
};
}
-pub fn bodyText(p: *Pardes, arena: std.mem.Allocator, pane: *Pane) ![]const u8 {
+pub fn bodyText(arena: std.mem.Allocator, pane: *Pane) ![]const u8 {
if (pane.addon != null) {
const buf = try arena.alloc(u8, pane.rows -| 1);
@memset(buf, '\n');
return buf;
}
- if (pane.hasPdf()) {
- if (comptime pdf_enabled) return panes.Pdf.visibleText(
- pane.pdf.?,
- p.pdf_gpa,
- arena,
- pane.rows -| BOX_H,
- );
- unreachable;
- }
if (pane.file) |*f| return panes.File.bodyText(arena, pane, f);
return panes.terminal.bodyText(arena, pane);
}
diff --git a/src/builtins.zig b/src/builtins.zig
index 68730166..e5c7753d 100644
--- a/src/builtins.zig
+++ b/src/builtins.zig
@@ -59,7 +59,6 @@ pub fn viewPlatform(p: *const Pardes) []const u8 {
/// The kinds of pane a builtin may be for alone (registry.needs).
pub const PaneKind = enum {
terminal,
- pdf,
image,
/// An image pane, or a terminal, whose program's kitty graphics are
/// pictures too.
@@ -72,7 +71,6 @@ pub const PaneKind = enum {
pub fn has(kind: PaneKind, pane: *const panes.Pane) bool {
return switch (kind) {
.terminal => pane.isTerminal(),
- .pdf => pane.hasPdf(),
.image => pane.addon != null,
.picture => pane.addon != null or pane.isTerminal(),
.program_colors => pane.isTerminal() or (pane.file != null and pane.file.?.pager),
@@ -84,7 +82,6 @@ pub const PaneKind = enum {
pub fn noun(kind: PaneKind) []const u8 {
return switch (kind) {
.terminal => "a terminal",
- .pdf => "a PDF",
.image => "an image",
.picture => "an image or a terminal",
.program_colors => "a terminal or a +Pager",
@@ -946,49 +943,6 @@ fn stateArg(c: Ctx, comptime T: type, comptime builtin_word: []const u8, comptim
const OnOff = enum { on, off };
-/// Fit the PDF page to the pane by width or by height, flipping between them
-/// (or to the one named, `width|height`).
-pub const PdfFit = struct {
- pub const needs: PaneKind = .pdf;
- pub const enabled = pardes.pdf_enabled;
- pub const takes_arg = true;
- pub fn run(c: Ctx) void {
- const state = c.pane.pdf orelse return;
- if (c.arg != null) {
- const want = stateArg(c, panes.Pdf.FitMode, "PdfFit", "width or height") orelse return;
- if (want == state.fit) return;
- }
- panes.Pdf.toggleFit(c.pane);
- }
-};
-
-/// Tint the PDF page to the theme, or show it as printed, stepping through
-/// them (or to the one named, `disabled|filtered|full`).
-pub const PdfTint = struct {
- pub const needs: PaneKind = .pdf;
- pub const enabled = pardes.pdf_enabled;
- pub const takes_arg = true;
- pub fn run(c: Ctx) void {
- const state = c.pane.pdf orelse return;
- if (c.arg != null) {
- const want = stateArg(c, panes.Pdf.TintMode, "PdfTint", "disabled, filtered or full") orelse return;
- while (state.tint != want) panes.Pdf.toggleTint(c.pane);
- return;
- }
- panes.Pdf.toggleTint(c.pane);
- }
-};
-
-/// List the PDF's sections in a pane, each a place to go.
-pub const PdfSections = struct {
- pub const needs: PaneKind = .pdf;
- pub const output: OutputTraits = .{ .name = config.pdf_sections_buffer, .steps = true, .locations = true };
- pub const enabled = pardes.pdf_enabled;
- pub fn run(c: Ctx) void {
- panes.Pdf.openSections(c.p, c.id);
- }
-};
-
/// Addons, the libraries that bring kinds of pane: `Addon load <path>`,
/// `Addon unload <name>`, `Addon reload <name>`; bare, the kinds here.
pub const Addon = struct {
@@ -1211,11 +1165,14 @@ pub const Zerox = struct {
pub const Save = struct {
pub const takes_arg = true;
pub fn run(c: Ctx) void {
- // A PDF or an image shows a file it does not hold as text: there
- // is nothing of its own to write, bare or to a path. Said, never a
- // silent success.
- if (c.pane.file == null and !c.pane.isTerminal())
- return c.p.reportFailure(c.id, if (c.pane.hasPdf()) "Save: a PDF pane has no text to save" else "Save: an image pane has no text to save");
+ // A kind's pane (an image, a PDF) shows a file it does not hold as
+ // text: there is nothing of its own to write, bare or to a path.
+ // Said, never a silent success.
+ if (c.pane.file == null and !c.pane.isTerminal()) {
+ const kind = if (c.pane.addon) |k| k.nameOf() else "";
+ var said: [64]u8 = undefined;
+ return c.p.reportFailure(c.id, std.fmt.bufPrint(&said, "Save: a{s} {s} pane has no text to save", .{ if (kind.len > 0 and std.mem.indexOfScalar(u8, "aeiou", kind[0]) != null) "n" else "", kind }) catch "Save: no text to save");
+ }
// A directory's listing is no file to write, bare or to a path, as
// acme's Put does nothing in a directory window.
if (c.pane.file) |file| if (file.listing != null) {
diff --git a/src/colors.zig b/src/colors.zig
index de20cf9b..7bac64ea 100644
--- a/src/colors.zig
+++ b/src/colors.zig
@@ -7,7 +7,6 @@ const std = @import("std");
const Color = @import("surface.zig").Color;
const FontRole = @import("surface.zig").FontRole;
const config = @import("config.zig");
-const pdf_enabled = panes.Pdf.enabled;
const platform = pardes.platform;
const MAX_PANES = pardes.MAX_PANES;
const BOX_H = pardes.BOX_H;
@@ -731,7 +730,6 @@ pub fn loadThemeFile(p: *Pardes, generation: u32, bytes: []const u8) bool {
p.custom_theme = parsed;
if (old) |theme_value| p.gpa.free(theme_value.name);
_ = p.theme_file_loaded.set(request.path);
- invalidateThemeDependentRasters(p);
_ = p.scratch.reset(.{ .retain_with_limit = pardes.memory.limits.scratch_kept });
p.sync();
return true;
@@ -741,13 +739,6 @@ pub fn finishThemeInitialization(p: *Pardes) void {
p.chrome = ChromeTheme.fromTheme(p.theme());
}
-fn invalidateThemeDependentRasters(p: *Pardes) void {
- if (comptime pdf_enabled) for (p.panes) |slot| {
- const pane = slot orelse continue;
- const pv = pane.pdf orelse continue;
- if (pv.tint != .disabled) pv.invalidateAllRasters();
- };
-}
/// Themes near `name`, a line of them, for a Theme given a name there is
/// none of (all of them, Themes, are too many for a refused write): every
@@ -841,7 +832,6 @@ pub fn setThemeIndex(p: *Pardes, index: usize) void {
p.emit(.{ .theme_file = .{ .generation = generation, .on = false } });
}
p.settings.theme = @intCast(index);
- invalidateThemeDependentRasters(p);
}
test "a theme file that cannot be read is named in the failure" {
diff --git a/src/config.zig b/src/config.zig
index f9fd336f..17a7305a 100644
--- a/src/config.zig
+++ b/src/config.zig
@@ -17,7 +17,7 @@ pub const Chord = struct {
};
// Leader paths apply wherever normal mode reads keys: a body's, a tag's
-// (column and workspace tags too) and a PDF's, never a raw terminal's
+// (column and workspace tags too) and a kind's pane's, never a raw terminal's
// (normal.zig takes `.leader` for every target).
pub const leader: []const Chord = &.{.{ .cp = ' ' }};
@@ -164,11 +164,6 @@ pub const leader_path = paths: {
table.set(.Adopt, null);
table.set(.Upgrade, "sU");
}
- if (pardes.pdf_enabled) {
- table.set(.PdfTint, "ti");
- table.set(.PdfSections, "ts");
- table.set(.PdfFit, "tz");
- }
for (std.enums.values(Builtin)) |b| if (table.get(b)) |p| {
if (std.mem.eql(u8, p, undecided)) @compileError("builtin has no leader path decided: " ++ @tagName(b));
};
@@ -280,7 +275,6 @@ pub const child_term_program = "pardes";
pub const topbar_str = "Newcol Joincol Find Grep Help Changelog Tutor Dump Themes Config Debug Exit";
pub const pane_builtins_str = "Term Collapse Del";
-pub const pdf_pane_builtins_str = "Term PdfSections PdfTint PdfFit Collapse Del";
pub const file_pane_builtins_str = "Save Term Collapse Del";
/// After a file's, on one a language server speaks for.
pub const lsp_pane_builtins_str = "Def Refs";
@@ -497,9 +491,7 @@ pub const preview_buffer = "+Preview";
pub const unsaved_buffer = "+Unsaved";
pub const themes_buffer = "+Themes";
pub const fonts_buffer = "+Fonts";
-pub const pdf_sections_buffer = "+PdfSections";
pub const diff_buffer = "+Diff";
-pub const pdf_links_buffer = "+Links";
pub const hover_buffer = "+Hover";
pub const lsp_buffer = "+Lsp";
pub const changelog_buffer = "+Changelog";
@@ -1496,13 +1488,33 @@ const doc_typ = struct {
/// The other build's builtins (docs/typ/builtins-*.json), so the docs
/// may name a window-only word in a terminal build's test, and back.
var other_build: []const u8 = "";
+ /// The shipped addons' sources (addons/*/*.c): their words are named
+ /// in the docs too, `PA_WORD("PdfFit", ...`.
+ var addon_sources: []const u8 = "";
+
+ fn loadAddons(gpa: std.mem.Allocator) !void {
+ const io = std.testing.io;
+ var root = try std.Io.Dir.cwd().openDir(io, @import("doc_typ").addons, .{ .iterate = true });
+ defer root.close(io);
+ var kinds = root.iterate();
+ while (try kinds.next(io)) |k| if (k.kind == .directory) {
+ var sub = try root.openDir(io, k.name, .{ .iterate = true });
+ defer sub.close(io);
+ var files = sub.iterate();
+ while (try files.next(io)) |f| if (std.mem.endsWith(u8, f.name, ".c")) {
+ addon_sources = try std.mem.concat(gpa, u8, &.{ addon_sources, try sub.readFileAlloc(io, f.name, gpa, .limited(1 << 20)) });
+ };
+ };
+ }
fn word(w: []const u8) bool {
const name = w[0 .. std.mem.indexOfScalar(u8, w, '+') orelse w.len];
if (std.meta.stringToEnum(Builtin, name) != null) return true;
var buf: [96]u8 = undefined;
const needle = std.fmt.bufPrint(&buf, "{{\"name\": \"{s}\",", .{name}) catch return false;
- return std.mem.indexOf(u8, other_build, needle) != null;
+ if (std.mem.indexOf(u8, other_build, needle) != null) return true;
+ const addon = std.fmt.bufPrint(&buf, "PA_WORD(\"{s}\",", .{name}) catch return false;
+ return std.mem.indexOf(u8, addon_sources, addon) != null;
}
fn chord(tok: []const u8) ?Chord {
@@ -1585,9 +1597,18 @@ const doc_typ = struct {
if (w.end > 0) w.writeByte(' ') catch return false;
w.writeAll(x[0 .. std.mem.indexOfScalar(u8, x, '+') orelse x.len]) catch return false;
}
- const tags = [_][]const u8{ topbar_str, @import("tagline.zig").column_tag_default, pane_builtins_str, pdf_pane_builtins_str, file_pane_builtins_str, diff_pane_builtins_str, pager_pane_builtins_str, pager_diff_pane_builtins_str, diff_view_builtins_str, terminal_pane_builtins_str, command_pane_builtins_str, dir_pane_builtins_str };
+ const tags = [_][]const u8{ topbar_str, @import("tagline.zig").column_tag_default, pane_builtins_str, file_pane_builtins_str, diff_pane_builtins_str, pager_pane_builtins_str, pager_diff_pane_builtins_str, diff_view_builtins_str, terminal_pane_builtins_str, command_pane_builtins_str, dir_pane_builtins_str };
for (tags) |d| if (std.mem.eql(u8, d, w.buffered())) return true;
- return false;
+ // A kind's pane's: Term, its addon's words, Collapse Del (Kind.zig).
+ const shown = w.buffered();
+ if (!std.mem.startsWith(u8, shown, "Term ") or !std.mem.endsWith(u8, shown, " Collapse Del")) return false;
+ var mid = std.mem.tokenizeScalar(u8, shown["Term ".len .. shown.len - " Collapse Del".len], ' ');
+ while (mid.next()) |x| {
+ var buf: [96]u8 = undefined;
+ const addon = std.fmt.bufPrint(&buf, "PA_WORD(\"{s}\",", .{x}) catch return false;
+ if (std.mem.indexOf(u8, addon_sources, addon) == null) return false;
+ }
+ return true;
}
};
@@ -1601,6 +1622,8 @@ test "docs/typ names only words, keys and default tags that exist" {
var found: [3]std.ArrayList([]const u8) = @splat(.empty);
// The arena's: gone with this test, so no later test reads it.
defer doc_typ.other_build = "";
+ defer doc_typ.addon_sources = "";
+ try doc_typ.loadAddons(gpa);
for ([_][]const u8{ "builtins-tui.json", "builtins-gui.json" }) |f| {
const text = dir.readFileAlloc(io, f, gpa, .limited(1 << 20)) catch continue;
doc_typ.other_build = try std.mem.concat(gpa, u8, &.{ doc_typ.other_build, text });
@@ -1701,6 +1724,8 @@ test "the tutor names only words, keys, paths and default tags that exist" {
defer arena.deinit();
const gpa = arena.allocator();
const tutor = @embedFile("tutor.txt");
+ defer doc_typ.addon_sources = "";
+ try doc_typ.loadAddons(gpa);
var found: std.ArrayList([]const u8) = .empty;
try doc_tutor.words(gpa, tutor, &found);
diff --git a/src/draw.zig b/src/draw.zig
index c97e2a6c..8538c6a6 100644
--- a/src/draw.zig
+++ b/src/draw.zig
@@ -28,7 +28,6 @@ const Text = panes.Text;
const Rect = layout.Rect;
const Region = @import("surface.zig").Region;
const TagKind = @import("Layer.zig").Kind;
-const pdf_enabled = panes.Pdf.enabled;
const wordBoundsAtCol = tagline.wordBoundsAtCol;
const BOX_H = pardes.BOX_H;
const TAG_TEXT_INSET = pardes.TAG_TEXT_INSET;
@@ -67,17 +66,13 @@ pub fn place(p: *Pardes, s: *Surface) void {
const doc: u64 = if (pane.file) |f| std.hash.Wyhash.hash(if (f.output != null) f.revision else 0, f.path) else 0;
s.addRegion(.{ .kind = .body, .owner = owner, .serial = pane.serial, .active = active, .line = line, .doc = doc, .rect = .{ .x = r.x + config.GUTTER, .y = body_y, .w = r.w - config.GUTTER, .h = body_h } });
var rail: Region = .{ .kind = .rail, .owner = owner, .serial = pane.serial, .active = active, .rect = .{ .x = r.x, .y = body_y, .w = config.GUTTER, .h = body_h } };
- // An image's rail has no thumb; a native PDF's is measured as its
- // pages are placed (Pdf.draw); every other pane's is here.
+ // A kind's rail is its paint's (drawPane); every other pane's is
+ // here.
if (pane.addon == null and body_h > 0) {
const sb: struct { total: usize, offset: usize, len: usize } = if (pane.file) |*f| .{
.total = panes.File.nlines(p.gpa, f),
.offset = f.scroll,
.len = pane.rows,
- } else if (pane.pdfPage()) |page| .{
- .total = if (comptime pdf_enabled) pane.pdf.?.page_count else 1,
- .offset = page,
- .len = 1,
} else blk: {
const gsb = panes.terminal.scrollbar(pane);
break :blk .{ .total = gsb.total, .offset = gsb.offset, .len = gsb.len };
@@ -182,14 +177,6 @@ pub fn render(p: *Pardes, arena: std.mem.Allocator) !*Surface {
s.rows = v.screen_h;
s.cursor = null;
s.pointer_shape = .arrow;
- if (comptime pdf_enabled) if (p.pdf_hover_preview) |preview| {
- if (preview.probe.link != null and preview.pane < p.panes.len) {
- if (p.panes[preview.pane]) |pane| {
- if (pane.serial == preview.serial and panes.Pdf.paneNativeReady(p, pane))
- s.pointer_shape = .link;
- }
- }
- };
// A look-hover preview means the pointed word is a real Look or Exec
// operand: the same plumbing a click would act on. Hosts that model
// the pointer per-text (the macOS I-beam) read this as "target" and
@@ -319,9 +306,9 @@ pub fn render(p: *Pardes, arena: std.mem.Allocator) !*Surface {
if (at.file) |*f| {
sb_off = f.scroll;
sb_total = panes.File.nlines(p.gpa, f);
- } else if (at.pdfPage()) |page| {
- sb_off = page;
- sb_total = if (comptime pdf_enabled) at.pdf.?.page_count else 0;
+ } else if (at.addon != null) {
+ sb_off = 0;
+ sb_total = 0;
} else {
const sb = panes.terminal.scrollbar(at);
sb_off = sb.offset;
@@ -435,8 +422,6 @@ fn renderPane(p: *Pardes, s: *Surface, arena: std.mem.Allocator, pane: *Pane, r:
if (pane.collapsed) return;
const rail = s.region(.rail, id).?;
- if (comptime pdf_enabled)
- if (pane.hasPdf() and panes.Pdf.draw(p, s, pane, r, id, tx, tw, rail)) return;
if (pane.addon != null) {
// Below the notice chips: a picture is drawn after the cells (the
@@ -445,11 +430,21 @@ fn renderPane(p: *Pardes, s: *Surface, arena: std.mem.Allocator, pane: *Pane, r:
const shown = pane.notices.span();
const body_h = (r.h -| pane.tag_rows) -| shown;
pardes.Kind.draw(p, s, arena, pane, id, tx, body_y + shown, tw, body_h);
- // thumbless, but the same one column as the real scrollbar below —
- // that is the whole point of drawing it, and like that one it runs
- // past the notice bands so the gutter has no notch in it
+ // The same one column as the real scrollbar below, running past
+ // the notice bands so the gutter has no notch in it; its thumb
+ // where this frame's paint said its window is in its whole (a
+ // PDF's strip), none for a kind that said nothing (an image).
s.fill(rail.rect.x, rail.rect.y, 1, rail.rect.h, .{ .bg = .{ .rgb = chrome.scroll_track } });
s.fill(rail.rect.x + 1, rail.rect.y, 1, rail.rect.h, .{ .bg = pane_bg });
+ const k = pane.addon.?;
+ if (k.thumb_span > 0) {
+ const track: f32 = @floatFromInt(rail.rect.h);
+ rail.thumb_y = @intFromFloat(@min(track - 1, @floor(k.thumb_at * track)));
+ rail.thumb_h = @intFromFloat(@min(track - @as(f32, @floatFromInt(rail.thumb_y)), @max(1, k.thumb_span * track)));
+ rail.thumb_at = k.thumb_at;
+ rail.thumb_span = k.thumb_span;
+ s.fill(rail.rect.x, rail.rect.y + rail.thumb_y, 1, rail.thumb_h, .{ .bg = .{ .rgb = chrome.scroll_thumb } });
+ }
return;
}
@@ -566,8 +561,6 @@ fn tagTintRange(pane: *const Pane, tag: []const u8, prefix_len: usize) ?struct {
if (k.path.len == 0) return null;
start = std.mem.lastIndexOf(u8, tag[0..@min(prefix_len, tag.len)], k.path) orelse return null;
break :blk k.path;
- } else if (comptime pdf_enabled) blk: {
- break :blk if (pane.pdf) |state| state.path else return null;
} else return null;
const basename = if (std.mem.lastIndexOfScalar(u8, name, '/')) |slash| slash + 1 else 0;
if (basename == name.len) return null;
diff --git a/src/dump.zig b/src/dump.zig
index 38fdbb7d..1d4ee2c2 100644
--- a/src/dump.zig
+++ b/src/dump.zig
@@ -10,7 +10,6 @@ const ctlfs = @import("ninep/tree.zig");
const exec = @import("exec.zig");
const colors = @import("colors.zig");
const config = @import("config.zig");
-const pdf_enabled = pardes.pdf_enabled;
const platform = pardes.platform;
const isolated = pardes.isolated;
const MAX_PANES = pardes.MAX_PANES;
@@ -93,7 +92,7 @@ pub var terminal_gpa: ?std.mem.Allocator = null;
//
// Loading is two halves. `load` makes the core the dump was and nothing
// else (a replica joining a session takes that, phase 5); `revivePane` and
-// `reviveSession` give it to this host: new shells, watches, PDFs opened.
+// `reviveSession` give it to this host: new shells, watches, kinds' panes opened.
/// A session's dump: its core, everything it is but what is the host's,
/// the frame's or worked out again (`replica` in each type, src/walk.zig),
@@ -298,7 +297,7 @@ fn loadKnowing(gpa: std.mem.Allocator, opts: Options, bytes: []const u8, notes:
p.fs.deinit(gpa);
gpa.destroy(p);
}
- l.allocs = .{ .image = p.image_gpa, .pdf = p.pdf_gpa, .terminal = terminal_gpa };
+ l.allocs = .{ .image = p.image_gpa, .terminal = terminal_gpa };
try l.into(Pardes, p);
const read = l.shared.items.len;
const mounts = try l.get([]const filesystem.Mount);
@@ -372,7 +371,7 @@ fn loadImage(gpa: std.mem.Allocator, opts: Options, bytes: []const u8, notes: ?*
p.fs.deinit(gpa);
gpa.destroy(p);
}
- l.allocs = .{ .image = p.image_gpa, .pdf = p.pdf_gpa, .terminal = terminal_gpa };
+ l.allocs = .{ .image = p.image_gpa, .terminal = terminal_gpa };
try l.into(Pardes, core_at, p);
if (try walk.Get.member(core_at, "views") == null) {
// From before `Pardes.views`: the live view's share is the core's
@@ -441,7 +440,7 @@ fn loadImage(gpa: std.mem.Allocator, opts: Options, bytes: []const u8, notes: ?*
/// A pane that is none of its kinds (a terminal kept slim, or one another
/// build's dump could not give): a terminal, a new emulator for its shell.
fn ensureKind(p: *Pardes, pane: *pardes.panes.Pane) !void {
- if (pane.terminal != null or pane.file != null or pane.addon != null or pane.hasPdf()) return;
+ if (pane.terminal != null or pane.file != null or pane.addon != null or pane.pdf != null) return;
const fresh = try pardes.panes.terminal.create(p.gpa, @max(1, pane.cols), @max(1, pane.rows));
pane.terminal = fresh.terminal;
fresh.terminal = null;
@@ -588,7 +587,8 @@ fn reviveSession(p: *Pardes, previous: ?*Pardes, resumed: bool) !void {
/// A loaded pane given to this host: a terminal a new shell in its old
/// one's directory under its history, a file watched again (one changed on
/// disk since comes back as it is now, one unsaved is marked changed), a
-/// PDF opened again.
+/// kind's pane opened again (a PDF a build before the pdf addon dumped, as
+/// the addon's).
fn revivePane(p: *Pardes, id: usize, pane: *pardes.panes.Pane, was_on_disk: bool) void {
if (pane.addon) |slot| return reviveSlot(p, id, slot);
if (pane.terminal != null) {
@@ -606,13 +606,7 @@ fn revivePane(p: *Pardes, id: usize, pane: *pardes.panes.Pane, was_on_disk: bool
p.emitSpawn(id, pane.serial, pane.cwdSlice());
return;
}
- if (comptime pdf_enabled) if (pane.pdf != null) {
- pardes.panes.Pdf.reopen(p, pane) catch |err| {
- p.reportError(id, "Restore", err);
- p.removePane(id, null) catch {};
- };
- return;
- };
+ if (pane.pdf) |old| return revivePdf(p, id, pane, old);
const f = if (pane.file) |*file| file else return;
if (f.output != null or filesystem.localPath(f.path) == null) return;
p.emit(.{ .watch = .{ .pane = @intCast(id), .on = true } });
@@ -667,7 +661,7 @@ pub fn savePane(gpa: std.mem.Allocator, pane: *pardes.panes.Pane, slim: bool) ![
pub fn loadPane(p: *Pardes, id: usize, bytes: []const u8) !*pardes.panes.Pane {
var l = try walk.Load(&.{pardes.panes.Pane}).init(p.gpa, bytes);
defer l.deinit();
- l.allocs = .{ .image = p.image_gpa, .pdf = p.pdf_gpa, .terminal = pardes.panes.terminal.emulatorGpa(p.gpa) };
+ l.allocs = .{ .image = p.image_gpa, .terminal = pardes.panes.terminal.emulatorGpa(p.gpa) };
const pane = try p.gpa.create(pardes.panes.Pane);
errdefer {
l.rollback();
@@ -925,11 +919,17 @@ const SlotRecord = struct {
record: ?[]const u8 = null,
values: []const u8 = "",
live: bool = false,
+ /// What decides its next calls (Kind.step): a replica joining keeps
+ /// them, its Shadow calling where the authority's kind does.
+ next_tick: u64 = 0,
+ view: u64 = 0,
+ focused: bool = false,
+ told: []const u8 = "",
};
pub fn slotWrite(s: *const Kind.Slot, gpa: std.mem.Allocator, w: *std.Io.Writer) !void {
var place: [32]u8 = undefined;
- var r: SlotRecord = .{ .name = s.nameOf(), .version = s.version, .path = s.path, .art = s.art, .record = s.record, .where = s.where_text.slice(), .values = s.values.slice(), .live = s.live };
+ var r: SlotRecord = .{ .name = s.nameOf(), .version = s.version, .path = s.path, .art = s.art, .record = s.record, .where = s.where_text.slice(), .values = s.values.slice(), .live = s.live, .next_tick = s.next_tick, .view = s.view, .focused = s.focused, .told = s.told.slice() };
var owned: ?[]u8 = null;
defer if (owned) |o| s.gpa.free(o);
if (s.ops != null) {
@@ -966,11 +966,12 @@ pub fn slotRead(out: *Kind.Slot, gpa: std.mem.Allocator, bytes: []const u8) !voi
var arena: std.heap.ArenaAllocator = .init(gpa);
defer arena.deinit();
const r = try walk.load(SlotRecord, arena.allocator(), bytes, null);
- out.* = .{ .gpa = gpa, .arena = .init(gpa), .version = r.version, .art = r.art, .live = r.live };
+ out.* = .{ .gpa = gpa, .arena = .init(gpa), .version = r.version, .art = r.art, .live = r.live, .next_tick = r.next_tick, .view = r.view, .focused = r.focused };
errdefer out.free();
@memcpy(out.name[0..@min(15, r.name.len)], r.name[0..@min(15, r.name.len)]);
out.path = try gpa.dupe(u8, r.path);
out.where_text.set(r.where);
+ out.told.set(r.told);
out.values.set(r.values);
if (r.record) |rec| out.record = try gpa.dupe(u8, rec);
}
@@ -981,7 +982,8 @@ pub fn slotFree(s: *Kind.Slot, gpa: std.mem.Allocator) void {
}
/// A loaded pane of a kind opened by its kind, if this core has it, else
-/// a placeholder saying what it waits for.
+/// a placeholder saying what it waits for. One with no record reopens from
+/// its file, its place and its words.
pub fn reviveSlot(p: *Pardes, id: usize, s: *Kind.Slot) void {
const k = p.kinds.byName(s.nameOf()) orelse {
s.live = false;
@@ -989,5 +991,34 @@ pub fn reviveSlot(p: *Pardes, id: usize, s: *Kind.Slot) void {
};
s.ops = p.kinds.ops[k];
s.gen = p.kinds.kinds[k].gen;
- _ = Kind.reopen(p, id, s, null);
+ const bytes: ?[]u8 = if (s.record == null and s.path.len > 0) filesystem.read(p, s.path) catch null else null;
+ defer if (bytes) |b| p.gpa.free(b);
+ const kept = .{ s.next_tick, s.view, s.focused };
+ _ = Kind.reopen(p, id, s, bytes);
+ // A replica's Shadow is the authority's pane as it is: it ticks when
+ // that one does, not because it was loaded (a kind opened here ticks
+ // to lay itself out).
+ if (s.ops == null) s.next_tick, s.view, s.focused = kept;
+}
+
+/// A PDF pane of a dump from before the pdf addon: a pane of the addon's
+/// kind `pdf` on its file, at its page, its fit and tint given again as
+/// its words; a placeholder until the addon is loaded.
+fn revivePdf(p: *Pardes, id: usize, pane: *pardes.panes.Pane, old: *pardes.panes.Pane.LegacyPdf) void {
+ defer {
+ p.image_gpa.free(old.path);
+ p.image_gpa.destroy(old);
+ pane.pdf = null;
+ }
+ const s = p.image_gpa.create(Kind.Slot) catch return;
+ s.* = .{ .gpa = p.image_gpa, .arena = .init(p.image_gpa), .version = 1, .live = true };
+ @memcpy(s.name[0..3], "pdf");
+ s.path = p.image_gpa.dupe(u8, old.path) catch {
+ s.free();
+ return p.image_gpa.destroy(s);
+ };
+ _ = s.where_text.print("{d}", .{old.page + 1});
+ _ = s.values.print("PdfFit {t}\nPdfTint {t}\n", .{ old.fit, old.tint });
+ pane.addon = s;
+ reviveSlot(p, id, s);
}
diff --git a/src/edit.zig b/src/edit.zig
index c6c59604..5fa18c2c 100644
--- a/src/edit.zig
+++ b/src/edit.zig
@@ -12,7 +12,6 @@ const sam = @import("sam_edit.zig");
const panes = @import("panes.zig");
const body_layer = @import("body_layer.zig");
const config = @import("config.zig");
-const pdf_enabled = panes.Pdf.enabled;
const lsp = @import("lsp/lsp.zig");
const syntax = @import("syntax.zig");
const platform = pardes.platform;
@@ -178,10 +177,11 @@ pub fn clipYank(p: *Pardes, pane: *Pane, main_only: bool) void {
const named = v.register;
v.register = '+';
defer v.register = named;
- if (comptime pdf_enabled) if (pane.pdf) |pv| {
- if (pv.selection_text.len > 0) setYank(p, pv.selection_text);
+ // A kind's pane: what it has selected (Kind.Slot.selection).
+ if (pane.addon) |k| {
+ if (k.selection.len > 0) setYank(p, k.selection);
return;
- };
+ }
if (pane.body.nsel > 0 and !main_only) {
normal.replaySels(p, &pane.body, .{ .normal = .{ .role = .yank } });
} else {
@@ -200,7 +200,7 @@ pub fn paneText(p: *Pardes, pane: *Pane) ![]u8 {
const from = modal.lineStartOffset(tag, pane.tag_top);
const cut = modal.lineStartOffset(tag, pane.tag_top + pane.tag_rows);
const shown = if (cut < tag.len) tag[from .. cut - 1] else tag[from..];
- return std.fmt.allocPrint(arena, "{s}\n{s}", .{ shown, try body_layer.bodyText(p, arena, pane) });
+ return std.fmt.allocPrint(arena, "{s}\n{s}", .{ shown, try body_layer.bodyText(arena, pane) });
}
pub fn pointerSourceLine(pane: *Pane, terminal_lines: []const []const u8, row: i32) []const u8 {
@@ -212,13 +212,13 @@ pub fn pointerSourceLine(pane: *Pane, terminal_lines: []const []const u8, row: i
pub fn capturePointerSelection(p: *Pardes, pane: *Pane, slot: usize) !void {
var gesture = pane.sel[slot];
- if (pane.hasPdf()) return;
+ if (pane.addon != null) return;
if (gesture.state != .done or @min(gesture.r0, gesture.r1) < pane.tag_rows) return;
if (pane.pointerSelection(gesture) != null) return;
pane.clearPointerSelection(slot);
// Refresh the source map before translating the rendered rectangle.
const raw = pane.isTerminal() and pane.body.mode == .tty;
- const body = try body_layer.bodyText(p, p.scratch.allocator(), pane);
+ const body = try body_layer.bodyText(p.scratch.allocator(), pane);
const terminal_lines = if (pane.file == null and !raw) try panes.terminal.cursorLines(p, pane) else &.{};
const first = @max(0, @min(gesture.r0, gesture.r1) - pane.tag_rows);
const logical_rows = if (pane.body_rows > 0) pane.body_rows else pane.rows;
@@ -352,8 +352,7 @@ pub fn spanHas(r: i32, c: i32, ar: i32, ac: i32, br: i32, bc: i32) bool {
/// the active modal selection as text, if any
pub fn currentSelText(p: *Pardes, pane: *Pane) ?[]const u8 {
- if (comptime pdf_enabled) if (p.view().frontend.native_images) if (pane.pdf) |pv|
- if (pv.selection != null and pv.selection_text.len > 0) return pv.selection_text;
+ if (pane.addon) |k| if (k.selection.len > 0) return k.selection;
if (!pane.body.vsel.active) return null;
return vselText(p, &pane.body);
}
@@ -390,10 +389,7 @@ pub fn paneCursorLines(p: *Pardes, t: *Text) ![]const []const u8 {
}
const pane = t.pane() orelse return &.{};
if (pane.file) |*f| return panes.File.cursorLines(arena, pane, f);
- if (pane.hasPdf()) {
- if (comptime pdf_enabled) return panes.Pdf.textLines(pane.pdf.?, p.pdf_gpa, arena);
- unreachable;
- }
+ if (pane.addon != null) return &.{};
return panes.terminal.cursorLines(p, pane);
}
@@ -422,7 +418,7 @@ pub fn pinPaneCursor(p: *Pardes, t: *Text) void {
}
const pane = t.pane() orelse return;
pane.pinCursor();
- if (pane.file == null and !pane.hasPdf())
+ if (pane.file == null and pane.addon == null)
t.cur_col = paneByteAtDisplay(p, t, t.cur_row, 0, t.cur_col);
}
@@ -436,10 +432,7 @@ pub fn flatSurface(p: *Pardes, t: *Text) ![]const u8 {
}
const pane = t.pane() orelse return "";
if (pane.file) |f| return f.content;
- if (pane.hasPdf()) {
- if (comptime pdf_enabled) return pane.pdf.?.ensureText(p.pdf_gpa);
- unreachable;
- }
+ if (pane.addon != null) return "";
const lines = try panes.terminal.cursorLines(p, pane);
return panes.terminal.flatSurface(p, pane, lines);
}
@@ -465,7 +458,7 @@ fn editText(p: *Pardes, t: *Text, lo: i32, hi: i32, col: i32) ?panes.EditText {
if (t.what != .body) return .{ .text = t.own orelse &.{}, .row0 = 0 };
const pane = t.pane() orelse return null;
if (pane.file) |f| return .{ .text = f.content, .row0 = 0 };
- if (pane.addon != null or pane.hasPdf()) return null;
+ if (pane.addon != null) return null;
return panes.terminal.editText(p, pane, lo, hi, col);
}
@@ -583,7 +576,7 @@ pub fn clampFileCursor(t: *Text) bool {
}
pub fn enterInsert(p: *Pardes, t: *Text, where: InsertAt, cnt: usize) void {
- if (t.what == .body) if (t.pane()) |pane| if (pane.hasPdf()) return;
+ if (t.what == .body) if (t.pane()) |pane| if (pane.addon != null) return;
pinPaneCursor(p, t);
_ = clampFileCursor(t);
// snapshot once per insert session (WITH the pre-insert selection) so
diff --git a/src/exec.zig b/src/exec.zig
index c927cb49..eb42424f 100644
--- a/src/exec.zig
+++ b/src/exec.zig
@@ -20,7 +20,6 @@ const python_lang = blk: {
@setEvalBranchQuota(20_000);
break :blk @import("grammar_manifest.zig").byName("python").?;
};
-const pdf_enabled = panes.Pdf.enabled;
const font_picker = pardes.font_picker;
const fonts = pardes.fonts;
const Pane = panes.Pane;
@@ -120,7 +119,7 @@ pub fn operandAt(p: *Pardes, pane: *Pane, clicked: Pane.Sel, borrow: bool, for_l
const wrapped = pane.wrapAt(visible);
const raw = pane.isTerminal() and pane.body.mode == .tty and clicked.r0 >= pane.tag_rows;
const row = if (raw) panes.terminal.gridOffset(pane) + visible else wrapped.line;
- const raw_line = if (raw) modal.lineSlice(body_layer.bodyText(p, p.scratch.allocator(), pane) catch "", @intCast(@max(0, visible))) else "";
+ const raw_line = if (raw) modal.lineSlice(body_layer.bodyText(p.scratch.allocator(), pane) catch "", @intCast(@max(0, visible))) else "";
const col = if (raw)
@as(i32, @intCast(panes.File.rawAtDisplay(raw_line, @intCast(@max(0, clicked.c0)))))
else if (clicked.r0 >= pane.tag_rows)
@@ -270,10 +269,7 @@ fn heldPane(p: *Pardes, first: usize, k: usize) ?*Pane {
pub fn heldSelection(p: *Pardes, first: usize) ?[]const u8 {
for (0..p.panes.len + 2) |k| {
const t = heldPane(p, first, k) orelse continue;
- if (comptime pdf_enabled) if (p.view().frontend.native_images) if (t.pdf) |pv| {
- if (pv.selection != null and pv.selection_text.len > 0)
- return pv.selection_text;
- };
+ if (t.addon) |kind| if (kind.selection.len > 0) return kind.selection;
if (t.sel[sel_slot].state == .done) {
if (edit.selectionText(p, t, t.sel[sel_slot]) catch null) |tx| return tx;
} else if (t.body.vsel.active and t.body.vsel.explicit) {
diff --git a/src/file_watch.zig b/src/file_watch.zig
index 7b8ccbef..812c1791 100644
--- a/src/file_watch.zig
+++ b/src/file_watch.zig
@@ -2,8 +2,8 @@
//! TTY and SDL hosts. Their event loops still own blocking waits, wake
//! coalescing, and retry scheduling; this file owns the identical synchronous
//! operation each wake performs. Text buffers already own the bytes whose hash
-//! is their generation. Large PDFs use metadata which changes for in-place and
-//! rename-over saves, avoiding a second whole-document allocation.
+//! is their generation. A kind's pane (a PDF) uses metadata which changes for
+//! in-place and rename-over saves, reading its file only when it changed.
//!
//! Two kernels, one transaction: inotify on linux (and FreeBSD 15's, the
//! same events), kqueue on macos. `init`, `wait`, `stop`, `drain`, `markDir`
@@ -30,14 +30,27 @@ pub const Identity = struct {
};
/// The last disk generation accepted by a native shell. Text panes already
-/// need their bytes, so their exact content hash is cheapest. PDF panes reopen
-/// the pathname directly and use metadata, avoiding a second whole-document
-/// allocation merely to discover whether MuPDF should reopen it.
+/// need their bytes, so their exact content hash is cheapest. A kind's pane
+/// uses metadata, its file read only once that moved (a PDF can be large).
pub const Generation = union(enum) {
text: u64,
- pdf: ?Identity,
+ kind: ?Identity,
};
+/// Whether a kind's file is still the bytes its pane opened from.
+fn sameBytes(core: *pardes.Pardes, pane: *const pardes.Pane, path: []const u8) bool {
+ const k = pane.addon orelse return false;
+ if (k.opened == 0) return false;
+ const bytes = filesystem.read(core, path) catch return false;
+ defer core.gpa.free(bytes);
+ return std.hash.Wyhash.hash(0, bytes) == k.opened;
+}
+
+fn kindPath(pane: *const pardes.Pane) ?[]const u8 {
+ const k = pane.addon orelse return null;
+ return if (k.path.len > 0) k.path else null;
+}
+
/// One native directory mark, plus what macos needs beside it.
///
/// `wd` is an inotify wd on linux and an open EVTONLY directory descriptor on
@@ -421,8 +434,8 @@ pub fn unwatchAll(fd: c_int, watches: *Table) void {
}
/// Reconcile one marked pane. A true result requests an immediate second pass:
-/// the PDF pathname changed between the stat before MuPDF reopened it and the
-/// stat after, so committing either identity would lose a generation.
+/// a kind's pathname changed between the stat before its pane reopened and
+/// the stat after, so committing either identity would lose a generation.
pub fn reloadPane(
core: *pardes.Pardes,
io: std.Io,
@@ -439,7 +452,7 @@ pub fn reloadPane(
// the next in-place save would otherwise wake nobody. A no-op elsewhere,
// and a no-op here too when the inode has not moved.
if (comptime builtin.os.tag == .macos) {
- if (watches[id]) |*live| remarkFile(live, if (pane.file) |f| f.path else pane.pdfPath());
+ if (watches[id]) |*live| remarkFile(live, if (pane.file) |f| f.path else kindPath(pane));
}
if (pane.file) |file| {
@@ -453,7 +466,7 @@ pub fn reloadPane(
const hash = std.hash.Wyhash.hash(0, bytes);
switch (watched.generation) {
.text => |accepted| if (accepted == hash) return false,
- .pdf => {},
+ .kind => {},
}
// The pane holds the disk's text already (a Zerox twin saved, its
// other twin watching the same file): nothing reloaded, nothing said.
@@ -479,31 +492,32 @@ pub fn reloadPane(
return false;
}
- const path = pane.pdfPath() orelse return false;
+ const path = kindPath(pane) orelse return false;
const before = identify(io, path) catch return false;
switch (watched.generation) {
- .pdf => |accepted| if (accepted) |identity| {
+ .kind => |accepted| if (accepted) |identity| {
if (identity.eql(before)) return false;
- } else if (pardes.panes.Pdf.sameBytes(core, pane)) {
- // Armed over the bytes the pane opened (a text's baseline is its
- // content, a PDF's is what it read): nothing to reload. Parsing
- // the document again doubled every PDF's open.
+ } else if (sameBytes(core, pane, path)) {
+ // Armed over the bytes the pane opened: nothing to reload
+ // (opening it again doubled every PDF's open). Changed between
+ // the open and the arm, it reloads.
if (watches[id]) |*live| if (live.serial == watched.serial) {
- live.generation = .{ .pdf = before };
+ live.generation = .{ .kind = before };
};
return false;
},
.text => {},
}
+ // Its kind reads the file again (Kind.fileChanged): on the tape, no bytes.
if (!core.reloadWatchedFile(@intCast(id), &.{})) return false;
const current = core.panes[id] orelse return false;
if (current.serial != watched.serial) return false;
- const current_path = current.pdfPath() orelse return false;
+ const current_path = kindPath(current) orelse return false;
const after = identify(io, current_path) catch return true;
if (!before.eql(after)) return true;
if (watches[id]) |*live| {
if (live.serial == watched.serial)
- live.generation = .{ .pdf = after };
+ live.generation = .{ .kind = after };
}
if (announce) {
var msg_buf: [256]u8 = undefined;
@@ -531,9 +545,9 @@ pub fn applyEffect(
if (pane.file) |file| {
path = file.path;
generation = .{ .text = std.hash.Wyhash.hash(0, file.content) };
- } else if (pane.pdfPath()) |pdf_path| {
- path = pdf_path;
- generation = .{ .pdf = null };
+ } else if (kindPath(pane)) |kind_path| {
+ path = kind_path;
+ generation = .{ .kind = null };
}
};
watchPane(fd, watches, id, path, serial, generation);
@@ -623,7 +637,7 @@ pub fn reloadTheme(
const hash = std.hash.Wyhash.hash(0, bytes);
switch (watched.generation) {
.text => |accepted| if (accepted == hash) return false,
- .pdf => unreachable,
+ .kind => unreachable,
}
if (!colors.loadThemeFile(core, watched.serial, bytes)) return false;
core.invalidate();
@@ -760,6 +774,35 @@ test "ordinary file watches still reconcile changes between open and watch" {
try std.testing.expectEqualStrings("opened\n", pane.file.?.content);
}
+test "a kind's pane whose file changed between its open and its watch opens again from it" {
+ if (comptime !supported or !filesystem.platform_has_fs) return;
+ const io = std.testing.io;
+ const gpa = std.testing.allocator;
+ var tmp = std.testing.tmpDir(.{});
+ defer tmp.cleanup();
+ try tmp.dir.writeFile(io, .{ .sub_path = "pic.ppm", .data = "opened\n" });
+ var path_buf: [256]u8 = undefined;
+ const path = try std.fmt.bufPrint(&path_buf, ".zig-cache/tmp/{s}/pic.ppm", .{tmp.sub_path});
+ const core = try pardes.Pardes.init(gpa, .{ .tty_only = true });
+ defer core.deinit();
+ const id: u8 = @intCast(core.freeSlot().?);
+ _ = try pardes.Kind.open(core, id, pardes.Kind.test_kind.of(core), path, "opened\n");
+ while (core.nextEffect()) |_| {}
+ const fd = init(true);
+ if (fd < 0) return error.NoWatcher;
+ defer _ = libc.close(fd);
+ var watches: Table = @splat(null);
+ defer unwatchAll(fd, &watches);
+ // The file as it opened: armed, nothing opened again.
+ try std.testing.expect(!applyEffect(core, io, fd, &watches, id, true, .reconcile));
+ try std.testing.expectEqual(std.hash.Wyhash.hash(0, "opened\n"), core.panes[id].?.addon.?.opened);
+ // Changed before the watch arms: opened again from it.
+ try std.testing.expect(!applyEffect(core, io, fd, &watches, id, false, .reconcile));
+ try tmp.dir.writeFile(io, .{ .sub_path = "pic.ppm", .data = "changed before watch\n" });
+ try std.testing.expect(!applyEffect(core, io, fd, &watches, id, true, .reconcile));
+ try std.testing.expectEqual(std.hash.Wyhash.hash(0, "changed before watch\n"), core.panes[id].?.addon.?.opened);
+}
+
test "explicit OS directory watches refresh prefix-preserving listings" {
if (comptime !supported or !filesystem.platform_has_fs) return;
const gpa = std.testing.allocator;
diff --git a/src/fs.zig b/src/fs.zig
index 835b191a..b5ee2d9e 100644
--- a/src/fs.zig
+++ b/src/fs.zig
@@ -53,9 +53,7 @@ const source_files = [_]Source{
.{ .path = "src/File.zig", .contents = @embedFile("File.zig") },
.{ .path = "src/Output.zig", .contents = @embedFile("Output.zig") },
.{ .path = "src/mini.zig", .contents = @embedFile("mini.zig") },
- .{ .path = "src/image.zig", .contents = @embedFile("image.zig") },
.{ .path = "src/terminal.zig", .contents = @embedFile("terminal.zig") },
- .{ .path = "src/pdf_view.zig", .contents = @embedFile("pdf_view.zig") },
.{ .path = "src/layout.zig", .contents = @embedFile("layout.zig") },
.{ .path = "src/fs.zig", .contents = @embedFile("fs.zig") },
.{ .path = "src/look.zig", .contents = @embedFile("look.zig") },
@@ -1464,7 +1462,6 @@ pub fn unmount(p: *Pardes, name: []const u8) !void {
const pane = slot orelse continue;
const paths = [_][]const u8{
if (pane.file) |file| file.path else "",
- if (comptime pardes.pdf_enabled) (if (pane.pdf) |pdf| pdf.path else "") else "",
if (pane.addon) |k| k.path else "",
Pardes.paneDir(pane),
};
diff --git a/src/gui/gui.zig b/src/gui/gui.zig
index 1125ff03..e7cd539a 100644
--- a/src/gui/gui.zig
+++ b/src/gui/gui.zig
@@ -482,20 +482,16 @@ fn updateCoreResize(core: *pardes.Pardes, cols: u16, rows: u16, cell_w: u32, cel
fn resizeOf(v: *const pardes.Pardes.View, cols: u16, rows: u16, cell_w: u32, cell_h: u32, tag_w: u32, tag_h: u32) ?pardes.Event {
const metrics: pardes.RowMetrics = .{ .body_w = @intCast(cell_w), .body_h = @intCast(cell_h), .tagline_w = @intCast(tag_w), .tagline_h = @intCast(tag_h) };
const same_metrics = std.meta.eql(metrics, v.row_metrics);
- if (comptime pardes.pdf_enabled) {
- const cell_px_w: u16 = @intCast(@min(@max(1, cell_w), std.math.maxInt(u16)));
- const cell_px_h: u16 = @intCast(@min(@max(1, cell_h), std.math.maxInt(u16)));
- if (cols == v.screen_w and rows == v.screen_h and
- cell_px_w == v.cell_pixels.w and cell_px_h == v.cell_pixels.h and same_metrics) return null;
- return .{ .resize = .{
- .cols = cols,
- .rows = rows,
- .cell_pixels = .{ .w = cell_px_w, .h = cell_px_h },
- .row_metrics = metrics,
- } };
- }
- if (cols == v.screen_w and rows == v.screen_h and same_metrics) return null;
- return .{ .resize = .{ .cols = cols, .rows = rows, .row_metrics = metrics } };
+ const cell_px_w: u16 = @intCast(@min(@max(1, cell_w), std.math.maxInt(u16)));
+ const cell_px_h: u16 = @intCast(@min(@max(1, cell_h), std.math.maxInt(u16)));
+ if (cols == v.screen_w and rows == v.screen_h and
+ cell_px_w == v.cell_pixels.w and cell_px_h == v.cell_pixels.h and same_metrics) return null;
+ return .{ .resize = .{
+ .cols = cols,
+ .rows = rows,
+ .cell_pixels = .{ .w = cell_px_w, .h = cell_px_h },
+ .row_metrics = metrics,
+ } };
}
const TouchPoint = struct {
@@ -1697,7 +1693,6 @@ fn localSession(
var opts = opts_in;
opts.addons = pardes.Addon.scan();
opts.image_allocator = allocs.image;
- opts.pdf_allocator = allocs.pdf;
opts.tree_sitter_allocator = allocs.tree_sitter;
opts.frame_allocator = allocs.frame;
var pw: c_int = 0;
@@ -2030,21 +2025,15 @@ fn remoteSession(init: std.process.Init, g: *Gui, opts_in: pardes.Options, test_
const have: ?*replica.Have = if (far) &have_store else null;
const allocs = pardes.memory.init(gpa);
defer pardes.memory.deinit();
- if (comptime pardes.pdf_enabled) {
- pardes.TerminalImages.start(io, allocs.image);
- pardes.pdf.start(allocs.pdf);
- }
+ pardes.TerminalImages.start(io, allocs.image);
+ pardes.Kind.heap = allocs.addon;
pardes.syntax.start(allocs.tree_sitter);
defer {
- if (comptime pardes.pdf_enabled) {
- pardes.TerminalImages.stop();
- pardes.pdf.stop();
- }
+ pardes.TerminalImages.stop();
pardes.syntax.stop();
}
var o = opts_in;
o.image_allocator = allocs.image;
- o.pdf_allocator = allocs.pdf;
var joined: replica.Joined = undefined;
var r = replica.join(gpa, &joined, to.path, to.session, o, have, &why, null) orelse Said.no(io, "{s}", .{std.mem.sliceTo(&why, 0)});
@@ -2910,22 +2899,12 @@ fn wheelAt(g: *Gui, in: *Input, w: WheelTurn, mc: MouseCell) void {
resetScroll(g);
};
if (hit) |id| {
- const pdf_target = if (comptime pardes.pdf_enabled)
- core.view().frontend.native_images and core.panes[id].?.pdfPage() != null
- else
- false;
const pane = core.panes[id].?;
- if (pdf_target) {
- resetScroll(g);
- in.post(.{ .pdf_scroll = .{
- .pane = @intCast(id),
- .delta_pixels = -w.y * @as(f32, @floatFromInt(g.cell_h)),
- .glide = notchOf(w.y, w.integer_y) != null,
- } });
- } else if (!w.mods.shift and pane.isTerminal() and pardes.panes.terminal.ownsWheel(pane)) {
- // The program's (codex, htop, less): every whole
- // turn goes to it, no glide, for nothing of ours
- // moves. Shift keeps the wheel pardes's.
+ if (pane.addon != null or (!w.mods.shift and pane.isTerminal() and pardes.panes.terminal.ownsWheel(pane))) {
+ // The program's (codex, htop, less), or a kind's (a
+ // PDF's strip): every whole turn goes to it, no glide,
+ // for nothing of ours moves. Shift keeps a terminal's
+ // wheel pardes's.
resetScroll(g);
g.program_wheel = accumulateWheelDelta(g.program_wheel, w.y);
while (g.program_wheel >= 1) : (g.program_wheel -= 1)
@@ -5314,9 +5293,7 @@ fn renderFrame(
const caret_alpha: f32 = if (gliding) 0.85 + 0.15 * std.math.clamp(1 - g.caret.remaining(now) / 0.5, 0, 1) else 1;
g.cursor_quad_alpha = if (quad_mode) caret_alpha * blink_alpha else 0;
// The probe's view of this frame's motion (FrameStats.Frame).
- // A focused PDF's strip is the core's (pdf_view.draw).
- const pdf_focus = if (core.panes[core.view().active]) |pane| pane.hasPdf() else false;
- if (!pdf_focus) core.frames.scroll = g.glide.follow.offset;
+ core.frames.scroll = g.glide.follow.offset;
core.frames.caret = caretRow(g, surface, now) orelse 0;
const cursors_shown = !quad_mode;
var overlay_count = buildOverlay(g, core.settings.pet, core.settings.jump_trail, surface, now, sw, sh);
diff --git a/src/host_io.zig b/src/host_io.zig
index 9cc34465..44061c4d 100644
--- a/src/host_io.zig
+++ b/src/host_io.zig
@@ -167,24 +167,18 @@ pub fn testClock() ?u64 {
return if (libc.getenv("PARDES_TEST_CLOCK")) |v| (if (std.mem.span(v).len != 0) 0 else null) else null;
}
-/// The image, PDF and syntax subsystems a frontend's session draws with,
-/// on `allocs` (pardes.memory.init); PDF pages render on lanes off the
-/// loop (pdf_view.workers). `stopWorkers` is its defer.
+/// The kitty images and syntax subsystems a frontend's session draws with,
+/// on `allocs` (pardes.memory.init), and what kinds keep past a call (their
+/// heap, `pa_api.heap`: the pdf addon's documents and pages). `stopWorkers`
+/// is its defer.
pub fn startWorkers(io: std.Io, allocs: pardes.memory.Allocators) void {
- if (comptime pardes.pdf_enabled) {
- pardes.TerminalImages.start(io, allocs.image);
- pardes.pdf.start(allocs.pdf);
- pardes.panes.Pdf.workers = io;
- }
+ pardes.TerminalImages.start(io, allocs.image);
+ pardes.Kind.heap = allocs.addon;
pardes.syntax.start(allocs.tree_sitter);
}
pub fn stopWorkers() void {
- if (comptime pardes.pdf_enabled) {
- pardes.TerminalImages.stop();
- pardes.panes.Pdf.dropKept();
- pardes.pdf.stop();
- }
+ pardes.TerminalImages.stop();
pardes.syntax.stop();
}
@@ -2152,10 +2146,10 @@ pub const exec_command_max = pardes.exec.command_max;
/// graphics by the pixels (yazi's previews; pardes nested in a pane).
pub fn ptyWinsize(core: ?*const pardes.Pardes, cols: u16, rows: u16) posix.winsize {
var ws: posix.winsize = .{ .row = rows, .col = cols, .xpixel = 0, .ypixel = 0 };
- if (comptime pardes.pdf_enabled) if (core) |c| {
+ if (core) |c| {
ws.xpixel = std.math.cast(u16, @as(u32, cols) * c.view().cell_pixels.w) orelse 0;
ws.ypixel = std.math.cast(u16, @as(u32, rows) * c.view().cell_pixels.h) orelse 0;
- };
+ }
return ws;
}
@@ -3597,7 +3591,7 @@ pub fn writeFile(core: *pardes.Pardes, watches: *file_watch.Table, pane: u8, pat
if (core.panes[pane]) |pn| if (pn.file) |f| if (std.mem.eql(u8, f.path, path)) {
if (watches[pane]) |*w| if (w.serial == pn.serial) switch (w.generation) {
.text => w.generation = .{ .text = std.hash.Wyhash.hash(0, bytes) },
- .pdf => {},
+ .kind => {},
};
};
var mbuf: [256]u8 = undefined;
diff --git a/src/keys.zig b/src/keys.zig
index ee14a48a..e6b417a9 100644
--- a/src/keys.zig
+++ b/src/keys.zig
@@ -228,11 +228,12 @@ pub fn handleKey(p: *Pardes, key: Key) void {
return panes.terminal.forwardKey(p, p.view().active, key);
}
// A kind's pane that takes keys takes them all, as a raw terminal
- // does, but Esc, which leaves (and Shift-Esc, above).
+ // does; Esc too, first, when its kind is of 2.1 (a PDF's drops its
+ // search), and not taken it leaves (and Shift-Esc, above, at once).
if (header == null and pane.focus == .body and pane.prompt == .none) if (pane.addon) |slot| if (pardes.Kind.takesKeys(p, slot)) {
p.view().prefix = .none;
- if (key.cp == Key.escape and !key.ctrl and !key.alt) return exec.runBuiltin(p, .Last, p.view().active, "", null);
if (pardes.Kind.key(p, p.view().active, key)) return;
+ if (key.cp == Key.escape and !key.ctrl and !key.alt) return exec.runBuiltin(p, .Last, p.view().active, "", null);
};
if (p.view().prefix == .leader) return leaderKey(p, key);
if (p.view().prefix == .window) {
@@ -367,7 +368,7 @@ pub fn handleKey(p: *Pardes, key: Key) void {
return;
}
edit.pinPaneCursor(p, &pane.body);
- const explicit = (p.view().frontend.native_images and pane.hasPdfSelection()) or
+ const explicit = (if (pane.addon) |k| k.selection.len > 0 else false) or
(pane.body.vsel.active and pane.body.vsel.explicit);
if (explicit) {
if (exec.chordEachSel(p, pane, cmd)) return;
@@ -386,7 +387,6 @@ pub fn handleKey(p: *Pardes, key: Key) void {
mouse.dispatchPointerBuiltin(p, p.view().active, cmd, operand.text, .{ .on_tag = false, .operand = operand });
return;
}
- if (t.mode == .normal and t.what == .body and pane.hasPdf()) return normal.handlePdfNormal(p, pane, key);
if (t.what == .tag and t.mode == .insert and tagline.typedIntoName(p, pane, key)) return;
// A tag's prefix is read-only: a key whose edit reached into it
// changes nothing, not even where the cursor is.
diff --git a/src/look.zig b/src/look.zig
index 42ed0fb1..7ac8798b 100644
--- a/src/look.zig
+++ b/src/look.zig
@@ -5,7 +5,6 @@ const libc = std.c;
const pardes = @import("pardes.zig");
const exec = @import("exec.zig");
const config = @import("config.zig");
-const pdf_enabled = @import("pardes_config").mupdf;
const diff = @import("diff.zig");
const platform_has_fs = filesystem.platform_has_fs;
const layout = @import("layout.zig");
@@ -18,7 +17,6 @@ const normal = @import("normal.zig");
const edit = @import("edit.zig");
const colors = @import("colors.zig");
const Color = @import("surface.zig").Color;
-const pdf = panes.Pdf.pdf;
const Pane = panes.Pane;
const MAX_PANES = pardes.MAX_PANES;
const Layer = @import("Layer.zig");
@@ -174,54 +172,22 @@ test "parsePathLine: `end` separates a whole-token target from a lenient read" {
try std.testing.expectEqualStrings(whole, parsePathLine(whole).path);
}
-pub const FileKind = if (pdf_enabled) enum { text, pdf } else enum { text };
-
pub const FileTarget = struct {
path: []const u8,
at: Spot,
- kind: FileKind = .text,
};
pub const Target = union(enum) {
none,
dir: []const u8, // resolved absolute path, in caller's buf
file: FileTarget,
- /// A file a kind opens (Kind.forPath): a picture.
- kind: struct { path: []const u8, kind: u8 },
+ /// A file a kind opens (Kind.forPath): a picture, a PDF; `at` the place
+ /// written after it (`book.pdf:12:3`), the kind's to take.
+ kind: struct { path: []const u8, kind: u8, at: Spot = .{} },
url: []const u8,
pane: struct { id: usize, at: Spot },
};
-pub fn isPdfPath(path: []const u8) bool {
- if (comptime !pdf_enabled) return false;
- return std.ascii.endsWithIgnoreCase(path, ".pdf");
-}
-
-test "PDF file kinds exist only in MuPDF-enabled builds" {
- try std.testing.expectEqual(pdf_enabled, isPdfPath("manual.PDF"));
- try std.testing.expect(!isPdfPath("manual.pdf.txt"));
- try std.testing.expectEqual(
- pdf_enabled,
- std.meta.stringToEnum(FileKind, "pdf") != null,
- );
- try std.testing.expect(std.meta.stringToEnum(std.meta.Tag(Target), "pdf") == null);
-}
-
-test ".pdf Look paths are ordinary files when MuPDF is disabled" {
- if (!platform_has_fs) return;
- var realbuf: [4096]u8 = undefined;
- const target = resolve(null, "docs/design.pdf", ".", &realbuf);
- switch (target) {
- .file => |file| {
- if (comptime pdf_enabled)
- try std.testing.expectEqual(FileKind.pdf, file.kind)
- else
- try std.testing.expectEqual(FileKind.text, file.kind);
- },
- else => return error.PdfDidNotResolveAsFile,
- }
-}
-
pub const Span = struct { start: usize, end: usize };
const lead_trim = "([{<\"'`*";
@@ -366,12 +332,7 @@ pub fn resolve(p: ?*pardes.Pardes, word_raw: []const u8, cwd: []const u8, realbu
const found = filesystem.resolve(p, word, cwd, realbuf) orelse return .none;
if (found.dir) return .{ .dir = found.path };
- if (comptime pdf_enabled) if (isPdfPath(found.path)) return .{ .file = .{
- .path = found.path,
- .at = pl.at,
- .kind = .pdf,
- } };
- if (p) |pp| if (pp.kinds.forPath(found.path)) |k| return .{ .kind = .{ .path = found.path, .kind = k } };
+ if (p) |pp| if (pp.kinds.forPath(found.path)) |k| return .{ .kind = .{ .path = found.path, .kind = k, .at = pl.at } };
return .{ .file = .{ .path = found.path, .at = pl.at } };
}
@@ -406,19 +367,6 @@ pub const FileWordSpan = struct {
hi: i32, // exclusive
};
-pub const PdfWordPreview = if (pdf_enabled) struct {
- col: u16,
- row: u16,
- pane: usize,
- serial: u32,
- probe: panes.Pdf.WordProbe,
-
- fn deinit(preview: *@This(), gpa: std.mem.Allocator) void {
- preview.probe.deinit(gpa);
- preview.* = undefined;
- }
-} else void;
-
fn noteLookSource(p: *Pardes, id: usize) void {
const pane = p.panes[id] orelse return;
var w: usize = 0;
@@ -586,19 +534,11 @@ pub fn runSearch(p: *Pardes, id: usize, pat_raw: []const u8, start: SearchStart,
var out_len: usize = 0;
var nrows: usize = 0;
var anchor: ?usize = null;
- if (pane.hasPdf()) {
- if (comptime pdf_enabled) {
- const found = try panes.Pdf.searchRows(
- pane.pdf.?,
- p.pdf_gpa,
- pat,
- start == .cursor,
- out,
- );
- out_len = found.bytes;
- nrows = found.rows;
- anchor = found.anchor;
- }
+ if (pane.addon != null) {
+ // A kind's own rows, if it has a search.
+ const rows = Kind.search(p, id, pat, out) orelse "";
+ out_len = rows.len;
+ nrows = std.mem.count(u8, rows, "\n");
} else {
const lines = try edit.paneCursorLines(p, &pane.body);
// a real file names itself; a terminal or an output buffer has no path
@@ -889,20 +829,11 @@ fn landLookSpot(p: *Pardes, id: usize, pane: *Pane, spot: Pane.LookSpot) void {
}
pub fn cancelLookHover(p: *Pardes) void {
- if (comptime pdf_enabled) if (p.pdf_hover_preview) |*preview| {
- if (preview.pane < p.panes.len) if (p.panes[preview.pane]) |pane| {
- if (pane.serial == preview.serial) if (pane.pdf) |pv|
- pv.invalidateRaster(preview.probe.page);
- };
- preview.deinit(p.pdf_gpa);
- p.pdf_hover_preview = null;
- };
p.look_hover_wait = null;
p.look_hover_preview = null;
}
pub fn lookHoverPane(p: *const Pardes) ?usize {
- if (comptime pdf_enabled) if (p.pdf_hover_preview) |preview| return preview.pane;
if (p.look_hover_preview) |preview| return preview.pane;
if (p.look_hover_wait) |waiting| return waiting.pane;
return null;
@@ -913,8 +844,6 @@ fn noteLookHover(p: *Pardes, col: u16, row: u16, body_hit: ?Mouse.BodyHit, tag_h
const pane = p.panes[id] orelse return cancelLookHover(p);
_ = edit.pointerTextSelection(p, id, col, row, body_hit, tag_hit) orelse return cancelLookHover(p);
- if (comptime pdf_enabled) if (p.pdf_hover_preview) |shown|
- if (shown.col == col and shown.row == row and shown.pane == id and shown.serial == pane.serial) return;
if (p.look_hover_preview) |shown|
if (shown.col == col and shown.row == row and shown.pane == id and shown.serial == pane.serial and mouse.sameBodyCell(shown.body_hit, body_hit) and Layer.sameCell(shown.tag_hit, tag_hit)) return;
if (p.look_hover_wait) |waiting|
@@ -954,21 +883,6 @@ pub fn advanceLookHover(p: *Pardes) void {
p.look_hover_refused = waiting.*;
return cancelLookHover(p);
};
- if (comptime pdf_enabled) if (!pointed.on_tag and panes.Pdf.paneNativeReady(p, pane)) {
- const probe = panes.Pdf.probeAt(p, pane, waiting.col, waiting.row) orelse
- return cancelLookHover(p);
- const ready = waiting.*;
- p.look_hover_wait = null;
- p.pdf_hover_preview = .{
- .col = ready.col,
- .row = ready.row,
- .pane = ready.pane,
- .serial = ready.serial,
- .probe = probe,
- };
- pane.pdf.?.invalidateRaster(probe.page);
- return;
- };
const operand = exec.operandAt(p, pane, pointed.sel, true, true);
if (operand.text == null or operand.text.?.len == 0) {
p.look_hover_refused = waiting.*;
@@ -995,14 +909,8 @@ pub fn focusPaneLine(p: *Pardes, id: usize, at: Spot, landing: enum { center, ke
p.view().active = id;
if (pane.collapsed) layout.toggleCollapse(p, id);
pane.body.normal.clear();
- if (pane.hasPdf()) {
- if (landing == .keep) return;
- if (comptime pdf_enabled) {
- const pv = pane.pdf.?;
- if (pv.focusLocation(p.pdf_gpa, at.line, at.col)) panes.Pdf.resetPageChrome(pane);
- }
- return;
- }
+ // A kind's place is its `address`'s (lookKind).
+ if (pane.addon != null) return;
if (at.line == 0) return;
if (pane.file) |*f| {
if (at.line > panes.File.nlines(p.gpa, f)) return;
@@ -1036,9 +944,6 @@ fn openPaneTarget(p: *const Pardes, path: []const u8, at: Spot) ?Target {
for (p.panes, 0..) |slot, i| {
const tt = slot orelse continue;
if (tt.addon) |k| if (std.mem.eql(u8, k.path, path)) {
- return .{ .pane = .{ .id = i, .at = .{} } };
- };
- if (comptime pdf_enabled) if (tt.pdf) |pv| if (std.mem.eql(u8, pv.path, path)) {
return .{ .pane = .{ .id = i, .at = at } };
};
const ff = if (tt.file) |*f| f else continue;
@@ -1066,10 +971,6 @@ pub fn clearNavigationSelection(p: *Pardes, pane: *Pane) void {
pane.body.sticky_col = -1;
for (0..pane.sel.len) |slot| pane.clearPointerSelection(slot);
pane.sel = @splat(.{});
- if (comptime pdf_enabled) if (pane.pdf) |state| {
- state.clearDrag();
- state.clearSelection(p.pdf_gpa);
- };
if (v.drag == .select and p.panes[v.drag.select.id] == pane) v.drag = .none;
}
@@ -1142,7 +1043,6 @@ fn canonicalLookLocation(p: *Pardes, id: usize, text: []const u8) ?[]const u8 {
if (target.id >= p.panes.len) return null;
const pane = p.panes[target.id] orelse return null;
if (pane.file) |file| return locationText(p, file.path, target.at);
- if (comptime pdf_enabled) if (pane.pdf) |doc| return locationText(p, doc.path, target.at);
if (pane.addon) |k| if (k.path.len > 0) return locationText(p, k.path, target.at);
var path: [32]u8 = undefined;
return locationText(p, std.fmt.bufPrint(&path, config.pane_addr ++ "{d}", .{pane.serial}) catch return null, target.at);
@@ -1150,47 +1050,6 @@ fn canonicalLookLocation(p: *Pardes, id: usize, text: []const u8) ?[]const u8 {
}
}
-pub fn pdfLinkLocation(p: *Pardes, pane: *const Pane, link: if (pdf_enabled) pdf.Link else void) ?[]const u8 {
- if (comptime !pdf_enabled) return null;
- const state = pane.pdf orelse return null;
- const id = panes.paneIdOf(p, pane) orelse return null;
- return switch (link.destination) {
- .none => null,
- .internal => |dest| if (dest.page < state.document.pages)
- locationText(p, state.path, .{ .line = dest.page + 1 })
- else
- null,
- .external => |uri| canonicalLookLocation(p, id, uri),
- };
-}
-
-pub fn followPdfLink(p: *Pardes, id: usize, probe: *const panes.Pdf.WordProbe) void {
- if (comptime !pdf_enabled) return;
- const pane = p.panes[id] orelse return;
- const link = probe.link orelse return;
- const target = pdfLinkLocation(p, pane, link) orelse return;
- clearNavigationSelection(p, pane);
- if (canonicalLookLocation(p, id, probe.text)) |visible| {
- if (!std.mem.eql(u8, visible, target)) {
- const content = std.fmt.allocPrint(p.gpa, "{s}\n{s}\n", .{ visible, target }) catch |err|
- return p.reportError(id, "PDF link choices", err);
- panes.Output.fillResults(p, id, std.fs.path.dirname(pane.pdf.?.path) orelse ".", .pdf_links, "", content, null) catch |err|
- return p.reportError(id, "PDF link choices", err);
- return;
- }
- }
- switch (link.destination) {
- .internal => |dest| {
- p.noteHaptic(.look);
- noteLookSource(p, id);
- p.view().active = id;
- panes.Pdf.revealOutlineDestination(p, pane, dest);
- },
- .external => lookAt(p, id, target),
- .none => {},
- }
-}
-
/// A look that found nothing: said on the message row, logged as an `err`
/// record, and marked so that /look reads back nothing (ninep/ctl.zig run).
/// The most of a looked-at path or text a miss repeats; past it, its
@@ -1227,25 +1086,6 @@ fn lookOpenFailed(p: *Pardes, id: usize, path: []const u8, err: anyerror) void {
p.reportError(id, std.fmt.bufPrint(&said, "look: {s}", .{missText(path, &cut)}) catch "look", err);
}
-fn missedPage(p: *Pardes, id: usize, path: []const u8, page: usize) void {
- var cut: [miss_path_cap + "…".len]u8 = undefined;
- missed(p, id, "{s} has no page {d}", .{ missText(path, &cut), page });
-}
-
-/// `file.pdf:P:H` names hit H of the pane's search on page P: none there,
-/// or no search, is a miss as a page past the last is.
-fn missedHit(p: *Pardes, id: usize, path: []const u8, page: usize, hit: usize) void {
- var cut: [miss_path_cap + "…".len]u8 = undefined;
- missed(p, id, "{s} has no search hit {d} on page {d}", .{ missText(path, &cut), hit, page });
-}
-
-/// The open PDF pane showing `path`, if one does.
-fn pdfPaneOf(p: *Pardes, path: []const u8) ?*panes.Pdf.State {
- if (comptime !pdf_enabled) return null;
- for (p.panes) |slot| if (slot) |pane| if (pane.pdf) |pv| if (std.mem.eql(u8, pv.path, path)) return pv;
- return null;
-}
-
fn missedLine(p: *Pardes, id: usize, path: []const u8, line: usize) void {
var cut: [miss_path_cap + "…".len]u8 = undefined;
missed(p, id, "{s} has no line {d}", .{ missText(path, &cut), line });
@@ -1481,7 +1321,7 @@ fn lookAddress(p: *Pardes, id: usize, path: []const u8, expr: []const u8) void {
}
const pane = p.panes[target] orelse return;
const f = pane.file orelse {
- if (comptime pdf_enabled) if (pane.pdf) |pv| return lookPdfPage(p, id, target, pv, expr);
+ if (pane.addon != null) return lookKind(p, id, target, expr, open == null and target != id);
if ((by_serial or path.len == 0) and pane.isTerminal()) return lookTerminalAddress(p, id, target, expr);
// Named as the pane is, the bare `:addr` (path empty) included.
var serial_name: [32]u8 = undefined;
@@ -1521,26 +1361,40 @@ fn lookAddress(p: *Pardes, id: usize, path: []const u8, expr: []const u8) void {
v.active = target;
}
-/// A PDF's address is its page: `:N` turns to page N, one past its last a
-/// miss, and `:N:H` to page N's search hit H, as `book.pdf:N:H` (a PDF
-/// search's row) does. It has no text to hold a byte offset (`#N`) or a
-/// pattern: any other address is refused with what it takes.
-fn lookPdfPage(p: *Pardes, id: usize, target: usize, pv: *panes.Pdf.State, expr: []const u8) void {
+/// A place in a kind's pane, its `address`'s: one looked at in a list the
+/// kind made (`text`, a +PdfSections) handed with the list's name first.
+/// A miss is said as the kind said it (`<path> has no page 99`), and a
+/// pane opened for it goes again, as for a file's line past its end.
+fn lookKind(p: *Pardes, id: usize, target: usize, expr_raw: []const u8, opened: bool) void {
+ const slot = p.panes[target].?.addon.?;
+ const expr = std.mem.trim(u8, expr_raw, " \t");
+ var buf: [512]u8 = undefined;
+ const from: []const u8 = if (p.panes[id]) |src| if (src.file) |f| if (f.output) |o| if (o.from == .kind) o.arg() else "" else "" else "" else "";
+ const text = if (from.len > 0) std.fmt.bufPrint(&buf, "{s} {s}", .{ from, expr }) catch expr else expr;
+ var said: Kind.Buf(160) = .{};
+ if (Kind.address(p, target, text, &said)) {
+ if (p.panes[target]) |pane| clearNavigationSelection(p, pane);
+ p.view().active = target;
+ return;
+ }
+ var serial_name: [32]u8 = undefined;
+ const subject = if (slot.path.len > 0) slot.path else std.fmt.bufPrint(&serial_name, config.pane_addr ++ "{d}", .{p.panes[target].?.serial}) catch "the pane";
var cut: [miss_path_cap + "…".len]u8 = undefined;
- const trimmed = std.mem.trim(u8, expr, " \t");
- const colon = std.mem.indexOfScalar(u8, trimmed, ':') orelse trimmed.len;
- const no_text = "{s}: a PDF has no text to address; its address is a page, :N";
- const page = std.fmt.parseInt(usize, trimmed[0..colon], 10) catch
- return missed(p, id, no_text, .{missText(pv.path, &cut)});
- const hit = if (colon < trimmed.len) std.fmt.parseInt(usize, trimmed[colon + 1 ..], 10) catch
- return missed(p, id, no_text, .{missText(pv.path, &cut)}) else 0;
- if (page == 0) return missedPage(p, id, pv.path, 0);
- if (page > pv.page_count) return missedPage(p, id, pv.path, page);
- if (!pv.hitExists(p.pdf_gpa, page, hit)) return missedHit(p, id, pv.path, page, hit);
- const pane = p.panes[target].?;
- clearNavigationSelection(p, pane);
- if (pv.focusLocation(p.pdf_gpa, page, hit)) panes.Pdf.resetPageChrome(pane);
- p.view().active = target;
+ const name = missText(subject, &cut);
+ if (opened) {
+ var kept: [miss_path_cap + "…".len]u8 = undefined;
+ @memcpy(kept[0..name.len], name);
+ p.removePane(target, null) catch {};
+ if (p.panes[id] != null) p.view().active = id;
+ return missed(p, id, "{s} {s}", .{ kept[0..name.len], if (said.len > 0) said.slice() else "is no text to address" });
+ }
+ missed(p, id, "{s} {s}", .{ name, if (said.len > 0) said.slice() else "is no text to address" });
+}
+
+/// A place as `address` takes it: `12`, `12:3`.
+fn spotText(at: Spot, buf: *[32]u8) []const u8 {
+ if (at.col == 0) return std.fmt.bufPrint(buf, "{d}", .{at.line}) catch "";
+ return std.fmt.bufPrint(buf, "{d}:{d}", .{ at.line, at.col }) catch "";
}
fn closeAndMiss(p: *Pardes, id: usize, opened: usize, name: []const u8, why: []const u8) void {
@@ -1599,9 +1453,11 @@ pub fn reopenAt(p: *Pardes, from: usize, path: []const u8, at: Spot) void {
lookAt(p, from, path);
const id = p.view().active;
const pane = p.panes[id] orelse return;
- // A PDF's place is its page, the last if it has fewer now.
- if (comptime pdf_enabled) if (pane.pdf) |pv| if (std.mem.eql(u8, pv.path, path)) {
- if (at.line > 0 and pv.focusLocation(p.pdf_gpa, @min(at.line, pv.page_count), 0)) panes.Pdf.resetPageChrome(pane);
+ // A kind's place is its `address`'s (a PDF's page), quietly.
+ if (pane.addon) |k| if (std.mem.eql(u8, k.path, path)) {
+ var said: Kind.Buf(160) = .{};
+ var place: [32]u8 = undefined;
+ if (at.line > 0) _ = Kind.address(p, id, spotText(.{ .line = at.line }, &place), &said);
return;
};
const f = if (pane.file) |*file| file else return;
@@ -1757,12 +1613,11 @@ pub fn lookAt(p: *Pardes, id: usize, operand_raw: []const u8) void {
// (or, after line 0, as an address).
if (zeroColumnTail(trimmed)) return p.reportFailure(id, @import("ninep/addr.zig").e_col_zero);
if (addressed(trimmed)) |ad| return lookAddress(p, id, ad.path, ad.expr);
- // `:N` on a PDF is its page N, never a search for the text.
- if (comptime pdf_enabled) if (pane.hasPdf() and trimmed.len > 1 and trimmed[0] == ':')
+ // `:N` on a kind's pane is its place N (a PDF's page), never a search
+ // for the text.
+ if (pane.addon != null and trimmed.len > 1 and trimmed[0] == ':')
return lookAddress(p, id, "", trimmed[1..]);
const pl = parsePathLine(trimmed);
- if (comptime pdf_enabled) if (pane.hasPdf()) clearNavigationSelection(p, pane);
- if (comptime pdf_enabled) if (panes.Pdf.lookSection(p, id, pl.path, pl.at)) return;
var realbuf: [4096]u8 = undefined;
// What is looked for is the place without its trailing `:`, `@p33:`
// and `a.txt:` as much as `a.txt:2:`.
@@ -1797,13 +1652,11 @@ pub fn lookAt(p: *Pardes, id: usize, operand_raw: []const u8) void {
return missed(p, id, "no pane {s}", .{pl.path[0..@min(pl.path.len, 32)]});
}
const target = p.panes[t.id].?;
- // A PDF's page past its last is a miss, as a line past a file's
- // end is: never the last page in its place (opening one, the
- // same: Pdf.openPane's .refuse).
- if (comptime pdf_enabled) if (target.pdf) |pv| {
- if (t.at.line > pv.page_count) return missedPage(p, id, pv.path, t.at.line);
- if (!pv.hitExists(p.pdf_gpa, @max(1, t.at.line), t.at.col)) return missedHit(p, id, pv.path, @max(1, t.at.line), t.at.col);
- };
+ // A place in a kind's pane is its `address`'s, a miss its to say.
+ if (target.addon != null and t.at.line > 0) {
+ var place: [32]u8 = undefined;
+ return lookKind(p, id, t.id, spotText(t.at, &place), false);
+ }
// A directory's pane, looked at again: read again.
if (target.file) |f| if (f.listing != null) return panes.Dir.show(p, id, t.id);
const before = v.active;
@@ -1823,25 +1676,6 @@ pub fn lookAt(p: *Pardes, id: usize, operand_raw: []const u8) void {
panes.Dir.look(p, id, dir);
},
.file => |target| {
- if (comptime pdf_enabled) if (target.kind == .pdf) {
- // A hit of a search: one of the open pane's, checked by
- // focusPaneByPath's pane; a PDF not open has none.
- if (target.at.col > 0) if (pdfPaneOf(p, target.path)) |pv| {
- if (!pv.hitExists(p.pdf_gpa, @max(1, target.at.line), target.at.col)) return missedHit(p, id, target.path, @max(1, target.at.line), target.at.col);
- } else return missedHit(p, id, target.path, @max(1, target.at.line), target.at.col);
- if (focusPaneByPath(p, target.path, target.at)) return;
- const free = p.freeSlot() orelse return p.reportError(id, "look", error.NoPaneSlots);
- // Said with its path and why, as an image that cannot be read
- // is; a page past its last is a miss, as for an open one.
- _ = panes.Pdf.openPane(p, free, target.path, target.at.line, .refuse) catch |err| {
- if (err == error.NoSuchPage) return missedPage(p, id, target.path, target.at.line);
- var said: [miss_path_cap + 64]u8 = undefined;
- var cut: [miss_path_cap + "…".len]u8 = undefined;
- return p.reportError(id, std.fmt.bufPrint(&said, "look: {s}: not a PDF pardes can read", .{missText(target.path, &cut)}) catch "look: not a PDF pardes can read", err);
- };
- exec.placeNew(p, id, id, free, .doc);
- return;
- };
// An open pane on this path too short for the line: a miss that
// touches nothing.
if (openPaneTarget(p, target.path, target.at)) |open| if (p.panes[open.pane.id].?.file) |*f|
@@ -1884,7 +1718,23 @@ pub fn lookAt(p: *Pardes, id: usize, operand_raw: []const u8) void {
settleLine(p, id, target.path, target.at, before, opened);
},
.kind => |target| {
- if (focusPaneByPath(p, target.path, .{})) return;
+ var place: [32]u8 = undefined;
+ // A row of a list a kind's pane made (a +PdfSections) is that
+ // pane's place, never another's of the same file: none once it
+ // is gone.
+ const from_list = if (p.panes[id]) |src| if (src.file) |f| if (f.output) |o| o.from == .kind else false else false else false;
+ if (from_list) {
+ for (p.panes, 0..) |slot, owner| if (slot) |op| if (op.search_pane == id) if (op.addon) |k| if (std.mem.eql(u8, k.path, target.path)) {
+ if (target.at.line > 0) return lookKind(p, id, owner, spotText(target.at, &place), false);
+ p.view().active = owner;
+ return;
+ };
+ return missed(p, id, "{s}: the pane its list is of is gone", .{target.path});
+ }
+ if (focusPaneByPath(p, target.path, .{})) {
+ if (target.at.line > 0) lookKind(p, id, v.active, spotText(target.at, &place), false);
+ return;
+ }
const free = p.freeSlot() orelse return p.reportError(id, "look", error.NoPaneSlots);
const made = Kind.openFile(p, free, target.kind, target.path) catch |err|
return lookOpenFailed(p, id, target.path, err);
@@ -1898,6 +1748,7 @@ pub fn lookAt(p: *Pardes, id: usize, operand_raw: []const u8) void {
return p.reportFailure(id, std.fmt.bufPrint(&said, "look: {s}: {s}", .{ missText(target.path, &cut), made.addon.?.refused.slice() }) catch "look: refused");
}
exec.placeNew(p, id, id, free, .doc);
+ if (target.at.line > 0) lookKind(p, id, free, spotText(target.at, &place), true);
},
}
}
diff --git a/src/macos.zig b/src/macos.zig
index 685e9d2f..3fa018c0 100644
--- a/src/macos.zig
+++ b/src/macos.zig
@@ -228,7 +228,7 @@ const FileWatches = struct {
if (!std.mem.eql(u8, watched.path, path)) return;
switch (watched.generation_on_disk) {
.text => watched.generation_on_disk = .{ .text = hash },
- .pdf => {},
+ .kind => {},
}
}
@@ -289,9 +289,9 @@ test "mac file watch generations own paths, coalesce, and reject stale callbacks
try std.testing.expect(!watches.retry(3, second));
try std.testing.expect(watches.entries[3] == null);
- _ = try watches.replace(std.testing.allocator, 4, "/tmp/book.pdf", 77, .{ .pdf = null });
+ _ = try watches.replace(std.testing.allocator, 4, "/tmp/book.pdf", 77, .{ .kind = null });
watches.restampText(4, "/tmp/book.pdf", 123);
- try std.testing.expect(watches.entries[4].?.generation_on_disk.pdf == null);
+ try std.testing.expect(watches.entries[4].?.generation_on_disk.kind == null);
}
const file_watcher_swift = @embedFile("macos/Sources/FileWatcher.swift");
@@ -499,7 +499,7 @@ fn initCore(runtime: ?*const Runtime, cols_arg: u16, rows_arg: u16) !void {
.boot = .tty,
.frame_allocator = allocs.frame,
.image_allocator = allocs.image,
- .pdf_allocator = allocs.pdf,
+
.tree_sitter_allocator = allocs.tree_sitter,
};
if (captureEnv(config_arena.allocator())) |*env| {
@@ -510,14 +510,9 @@ fn initCore(runtime: ?*const Runtime, cols_arg: u16, rows_arg: u16) !void {
if (found.dir) |d| crash.setDir(d);
}
- if (comptime pardes.pdf_enabled) {
- pardes.TerminalImages.start(io, allocs.image);
- pardes.pdf.start(allocs.pdf);
- }
- errdefer if (comptime pardes.pdf_enabled) {
- pardes.TerminalImages.stop();
- pardes.pdf.stop();
- };
+ pardes.TerminalImages.start(io, allocs.image);
+ pardes.Kind.heap = allocs.addon;
+ errdefer pardes.TerminalImages.stop();
pardes.syntax.start(allocs.tree_sitter);
errdefer pardes.syntax.stop();
@@ -607,10 +602,7 @@ export fn pardes_deinit() void {
if (st.changed_cells.len > 0) st.gpa.free(st.changed_cells);
if (st.images.len > 0) st.gpa.free(st.images);
st.core.deinit();
- if (comptime pardes.pdf_enabled) {
- pardes.TerminalImages.stop();
- pardes.pdf.stop();
- }
+ pardes.TerminalImages.stop();
pardes.syntax.stop();
st.config_arena.deinit();
st.prompt_rcs.deinit();
@@ -870,7 +862,7 @@ fn refreshCwds(ctx: ?*anyopaque) void {
fn paneWatchPath(core: *const pardes.Pardes, pane: u8) ?[]const u8 {
const value = core.panes[pane] orelse return null;
if (value.file) |file| return file.path;
- if (comptime pardes.pdf_enabled) if (value.pdfPath()) |path| return path;
+ if (value.addon) |k| if (k.path.len > 0) return k.path;
return null;
}
@@ -878,8 +870,8 @@ fn watchInitialGeneration(st: *State, pane: u8, path: []const u8) ?file_watch.Ge
const value = st.core.panes[pane] orelse return null;
if (value.file) |file| if (std.mem.eql(u8, file.path, path))
return .{ .text = std.hash.Wyhash.hash(0, file.content) };
- if (comptime pardes.pdf_enabled) if (value.pdf) |pdf| if (std.mem.eql(u8, pdf.path, path))
- return .{ .pdf = null };
+ if (value.addon) |k| if (std.mem.eql(u8, k.path, path))
+ return .{ .kind = null };
return null;
}
@@ -943,7 +935,7 @@ fn reloadWatchedTheme(st: *State, announce: bool) bool {
const hash = std.hash.Wyhash.hash(0, bytes);
switch (watched.generation_on_disk) {
.text => |accepted| if (accepted == hash) return false,
- .pdf => unreachable,
+ .kind => unreachable,
}
if (!colors.loadThemeFile(st.core, watched.serial, bytes, true)) return false;
const live = if (st.file_watches.entries[theme_watch_pane]) |*entry| entry else return false;
@@ -994,9 +986,8 @@ fn reloadWatchedFile(st: *State, pane: u8, announce: bool) bool {
active.retries_left = 0;
break :text .committed;
},
- .pdf => |old_identity| pdf: {
- if (comptime !pardes.pdf_enabled) break :pdf .no_change;
- const state_before = if (current.pdf) |pdf_before| pdf_before else break :pdf .no_change;
+ .kind => |old_identity| pdf: {
+ const state_before = if (current.addon) |k| k else break :pdf .no_change;
if (!std.mem.eql(u8, state_before.path, watched.path)) break :pdf .no_change;
const before = file_watch.identify(st.io, watched.path) catch {
retryWatchedFile(st, pane, generation);
@@ -1010,7 +1001,7 @@ fn reloadWatchedFile(st: *State, pane: u8, announce: bool) bool {
const after = st.core.panes[pane] orelse break :pdf .changed_uncommitted;
if (after.serial != watched.serial) break :pdf .changed_uncommitted;
- const pdf_state = if (after.pdf) |pdf_after| pdf_after else break :pdf .changed_uncommitted;
+ const pdf_state = if (after.addon) |k| k else break :pdf .changed_uncommitted;
if (!std.mem.eql(u8, pdf_state.path, watched.path)) break :pdf .changed_uncommitted;
const after_identity = file_watch.identify(st.io, watched.path) catch {
retryWatchedFile(st, pane, generation);
@@ -1023,7 +1014,7 @@ fn reloadWatchedFile(st: *State, pane: u8, announce: bool) bool {
const active = if (st.file_watches.entries[pane]) |*entry| entry else break :pdf .changed_uncommitted;
if (active.generation != generation or active.serial != after.serial)
break :pdf .changed_uncommitted;
- active.generation_on_disk = .{ .pdf = after_identity };
+ active.generation_on_disk = .{ .kind = after_identity };
active.retries_left = 0;
break :pdf .committed;
},
@@ -2099,7 +2090,6 @@ export fn pardes_active_dirty() bool {
fn activeFilePath(st: *State) ?[]const u8 {
const pane = st.core.panes[st.core.view().active] orelse return null;
if (pane.file) |*f| return if (f.output == null) f.path else null;
- if (comptime pardes.pdf_enabled) if (pane.pdfPath()) |path| return path;
if (pane.addon) |k| return k.path;
return null;
}
@@ -2820,7 +2810,7 @@ test "mac row metrics ABI preserves PDF cell dimensions and the unrendered grid"
state.?.config_arena.deinit();
state = null;
}
- if (comptime pardes.pdf_enabled) core.view().cell_pixels = .{ .w = 22, .h = 39 };
+ core.view().cell_pixels = .{ .w = 22, .h = 39 };
const pixels = core.view().cell_pixels;
try std.testing.expectEqual(@as(u16, 0), core.surface.cols);
pardes_row_metrics(22, 39, 17, 30);
diff --git a/src/memory.zig b/src/memory.zig
index e3fa4ac9..31b04b99 100644
--- a/src/memory.zig
+++ b/src/memory.zig
@@ -53,7 +53,9 @@ pub const limits = struct {
pub const host = 512 * MiB;
pub const tree_sitter = 256 * MiB;
pub const image = 256 * MiB;
- pub const pdf = if (!config.mupdf) 64 * KiB else 512 * MiB;
+ /// What kinds keep past a call (`pa_api.heap`): the pdf addon's
+ /// documents, MuPDF's own memory and the pages' pixels.
+ pub const addon = 512 * MiB;
/// One language query's working memory (its parsed answers, the rows
/// it writes): a hard bound, nothing spills. Callstack walks until it
/// would leave less than its rendering reserve.
@@ -70,7 +72,7 @@ pub const Allocators = struct {
lsp: Allocator,
tree_sitter: Allocator,
image: Allocator,
- pdf: Allocator,
+ addon: Allocator,
};
/// One arena's fixed region on a native target, handed out in runs of 4 KiB
@@ -286,8 +288,8 @@ var tree_sitter_bits: [bitsFor(limits.arena.tree_sitter)]u64 = @splat(0);
var tree_sitter_region: Region = .{ .size = limits.arena.tree_sitter, .bits = &tree_sitter_bits };
var image_bits: [bitsFor(limits.arena.image)]u64 = @splat(0);
var image_region: Region = .{ .size = limits.arena.image, .bits = &image_bits };
-var pdf_bits: [bitsFor(limits.arena.pdf)]u64 = @splat(0);
-var pdf_region: Region = .{ .size = limits.arena.pdf, .bits = &pdf_bits };
+var addon_bits: [bitsFor(limits.arena.addon)]u64 = @splat(0);
+var addon_region: Region = .{ .size = limits.arena.addon, .bits = &addon_bits };
var host_bits: [bitsFor(limits.arena.host)]u64 = @splat(0);
var host_region: Region = .{ .size = limits.arena.host, .bits = &host_bits };
@@ -429,7 +431,7 @@ fn pinned(allocator: Allocator, bytes: []const u8, alignment: std.mem.Alignment)
/// was freed (a V8 Callstack page left 21 MiB free in its heap; this returned
/// 20). Walks every arena and the heap, so for rare, large events only.
pub fn trim() void {
- inline for (.{ &pardes_region, &frame_region, &lsp_region, &tree_sitter_region, &image_region, &pdf_region, &host_region }) |r| r.trim();
+ inline for (.{ &pardes_region, &frame_region, &lsp_region, &tree_sitter_region, &image_region, &addon_region, &host_region }) |r| r.trim();
if (comptime builtin.os.tag != .linux or builtin.abi.isMusl() or !builtin.link_libc) return;
const glibc = struct {
extern "c" fn malloc_trim(pad: usize) c_int;
@@ -472,7 +474,7 @@ pub fn init(fallback: Allocator) Allocators {
.lsp = lsp_region.init(spill),
.tree_sitter = tree_sitter_region.init(spill),
.image = image_region.init(spill),
- .pdf = pdf_region.init(spill),
+ .addon = addon_region.init(spill),
};
}
@@ -481,7 +483,7 @@ pub fn deinit() void {
if (!debug_enabled) return;
var leaked = false;
// The host's arena lives as long as the process (`host`).
- inline for (.{ &pardes_region, &frame_region, &lsp_region, &tree_sitter_region, &image_region, &pdf_region }) |r| leaked = r.deinit() or leaked;
+ inline for (.{ &pardes_region, &frame_region, &lsp_region, &tree_sitter_region, &image_region, &addon_region }) |r| leaked = r.deinit() or leaked;
if (leaked) @panic("allocator leaks detected");
}
@@ -547,7 +549,7 @@ test "memory limits preserve desktop capacities" {
try std.testing.expectEqual(512 * MiB, limits.arena.lsp);
try std.testing.expectEqual(256 * MiB, limits.arena.tree_sitter);
try std.testing.expectEqual(256 * MiB, limits.arena.image);
- try std.testing.expectEqual(if (config.mupdf) 512 * MiB else 64 * KiB, limits.arena.pdf);
+ try std.testing.expectEqual(512 * MiB, limits.arena.addon);
}
test "a pinned blob's free is put off until its last pin goes" {
diff --git a/src/modal.zig b/src/modal.zig
index 894fbaf8..c510adc1 100644
--- a/src/modal.zig
+++ b/src/modal.zig
@@ -244,7 +244,7 @@ pub const Normal = struct {
pub const Find = enum { forward, backward, till_forward, till_backward };
/// What a key sequence asks for: the command and what it was given. The
- /// text's executor (normal.zig) and a PDF's (pdf_view.zig) both take it.
+ /// text's executor (normal.zig) takes it.
pub const Action = struct {
role: Role,
count: u32 = 1,
diff --git a/src/mouse.zig b/src/mouse.zig
index 7eab8322..6e8c1719 100644
--- a/src/mouse.zig
+++ b/src/mouse.zig
@@ -14,8 +14,6 @@ const edit = @import("edit.zig");
const body_layer = @import("body_layer.zig");
const builtins = @import("builtins.zig");
const config = @import("config.zig");
-const pdf_enabled = panes.Pdf.enabled;
-const pdf = panes.Pdf.pdf;
const platform = pardes.platform;
const Pane = panes.Pane;
const MAX_PANES = pardes.MAX_PANES;
@@ -52,9 +50,6 @@ pub const Drag = union(enum) {
/// Where the sweep began in the text, once it has scrolled: its
/// press row may be off the screen.
anchor: ?modal.Cursor = null,
- /// This gesture began over a usable native PDF raster. The payload is
- /// zero-bit when PDF support is absent.
- pdf: panes.Pdf.PointerDrag = .{},
/// Where its body was in the frontend's frame at its last hit there:
/// a sweep that leaves it is clamped back onto it (`bodyHitForPane`).
body: ?Layer.Place = null,
@@ -385,7 +380,9 @@ fn tracksMouse(pane: *const Pane) bool {
/// program's, reported without the Shift that chose it. True when the
/// event was the program's.
/// The pointer over the body of a pane whose kind takes the mouse: the
-/// kind's, a press focusing the pane first.
+/// kind's, a press focusing the pane first, its drag and release the
+/// kind's wherever they go (clamped to its body); a pointer leaving the
+/// body is told as a motion at 0xffff.
fn kindMouse(p: *Pardes, m: Mouse) bool {
const v = p.view();
if (v.drag != .none or v.header_drag or v.header_sweep != null) return false;
@@ -396,13 +393,30 @@ fn kindMouse(p: *Pardes, m: Mouse) bool {
const r = v.rects[id];
const top = p.bodyTop(pane, r) + pane.notices.span();
const x0 = r.x + config.GUTTER;
- if (m.col < x0 or m.col >= r.x + r.w or m.row < top or m.row >= r.y + r.h) continue;
+ const inside = m.col >= x0 and m.col < r.x + r.w and m.row >= top and m.row < r.y + r.h;
+ const grabbed = v.kind_grab != null and v.kind_grab.? == id and (m.kind == .drag or m.kind == .release);
+ if (!inside and !grabbed) continue;
+ if (v.kind_hover != null and v.kind_hover.? != id) kindLeave(p);
+ v.kind_hover = @intCast(id);
if (m.kind == .press) v.active = id;
- return pardes.Kind.mouse(p, id, m, m.col - x0, m.row - top);
+ if (m.kind == .press and m.button != .wheel_up and m.button != .wheel_down and m.button != .wheel_left and m.button != .wheel_right) v.kind_grab = @intCast(id);
+ if (m.kind == .release) v.kind_grab = null;
+ const col = std.math.clamp(m.col, x0, r.x + r.w -| 1) - x0;
+ const row = std.math.clamp(m.row, top, r.y + r.h -| 1) - top;
+ return pardes.Kind.mouse(p, id, m, col, row);
}
+ kindLeave(p);
return false;
}
+/// The pointer has left the kind's pane it was over: told so, once.
+pub fn kindLeave(p: *Pardes) void {
+ const v = p.view();
+ const id = v.kind_hover orelse return;
+ v.kind_hover = null;
+ _ = pardes.Kind.mouse(p, id, .{ .button = .none, .kind = .motion, .col = 0, .row = 0 }, 0xffff, 0xffff);
+}
+
fn programMouse(p: *Pardes, m: Mouse) bool {
const v = p.view();
const button: ?panes.terminal.MouseButton = switch (m.button) {
@@ -699,9 +713,7 @@ pub fn handleMouse(p: *Pardes, event: Mouse) void {
_ = config.wheelTick(&v.wheel_guard, true);
const id = hovered orelse return;
const pane = p.panes[id].?;
- if (pane.hasPdf())
- panes.Pdf.verticalWheel(p, pane, if (m.button == .wheel_up) -1 else 1)
- else if (!programWheel(p, id, m, mcol, mrow))
+ if (!programWheel(p, id, m, mcol, mrow))
pane.scrollBy(if (m.button == .wheel_up) -config.wheel_rows else config.wheel_rows);
},
.wheel_left, .wheel_right => {
@@ -711,10 +723,6 @@ pub fn handleMouse(p: *Pardes, event: Mouse) void {
const pane = p.panes[id].?;
if (programWheel(p, id, m, mcol, mrow)) {
// the program's
- } else if (pane.hasPdf()) {
- panes.Pdf.horizontalWheel(p, pane, if (m.button == .wheel_right) 1 else -1);
- // ponytail: no right clamp — overscroll shows blank and the
- // next cursor move or left wheel pulls it back
} else if (pane.file != null and !p.settings.wrap) {
// wrapped there is nothing off to the right to reach
const line = panes.File.sourceLine(pane, pane.body.cur_row);
@@ -740,8 +748,6 @@ pub fn handleMouse(p: *Pardes, event: Mouse) void {
if (v.drag == .select and v.drag.select.button == config.look_button) {
if (p.panes[v.drag.select.id]) |t| {
t.sel[@backingInt(config.look_button)].state = .none;
- if (comptime pdf_enabled)
- panes.Pdf.pointerCancel(t, v.drag.select.pdf);
}
v.drag = .none;
return;
@@ -827,14 +833,6 @@ pub fn handleMouse(p: *Pardes, event: Mouse) void {
.button = config.select_button,
.ctrl = m.ctrl,
.body = bodyPlace(m.body_hit, pane),
- .pdf = panes.Pdf.pointerStart(
- p,
- pane,
- config.select_button,
- mcol,
- mrow,
- pointed.on_tag,
- ),
} };
}
},
@@ -858,8 +856,6 @@ pub fn handleMouse(p: *Pardes, event: Mouse) void {
if (v.drag == .select) {
if (p.panes[v.drag.select.id]) |t| {
t.sel[@backingInt(v.drag.select.button)].state = .none;
- if (comptime pdf_enabled)
- panes.Pdf.pointerCancel(t, v.drag.select.pdf);
}
v.drag = .none;
return;
@@ -885,16 +881,6 @@ pub fn handleMouse(p: *Pardes, event: Mouse) void {
.id = id,
.button = m.button,
.body = bodyPlace(m.body_hit, pane),
- // A native body gesture stays native even when its
- // point later misses a letterbox or selection.
- .pdf = panes.Pdf.pointerStart(
- p,
- pane,
- m.button,
- mcol,
- mrow,
- pointed.on_tag,
- ),
},
};
}
@@ -979,7 +965,7 @@ pub fn dragUpdate(p: *Pardes, mcol: u16, mrow: u16, body_hit: ?Mouse.BodyHit) vo
// from the pointer.
const body_y = p.bodyTop(pane, r);
const body_h = r.h -| pane.tag_rows;
- s.edge = if (s.button != config.select_button or pane.sel[b].r0 < tag_rows or pane.file == null or pane.hasPdf() or body_h == 0)
+ s.edge = if (s.button != config.select_button or pane.sel[b].r0 < tag_rows or pane.file == null or body_h == 0)
0
else if (mrow < body_y)
-1
@@ -997,8 +983,6 @@ pub fn dragUpdate(p: *Pardes, mcol: u16, mrow: u16, body_hit: ?Mouse.BodyHit) vo
else
@as(i32, @min(@max(mrow, body_y), body_y + body_h - 1)) - @as(i32, body_y) + tag_rows;
if (pane.sel[b].r1 < tag_rows) pane.sel[b].c1 += @as(i32, pane.tag_scroll);
- if (comptime pdf_enabled)
- panes.Pdf.pointerUpdate(&s.pdf, p, pane, mcol, mrow);
}
},
.none => {},
@@ -1140,7 +1124,7 @@ fn mirrorTtySelection(p: *Pardes, pane: *Pane) void {
if (rows.len == 0) return;
const forward = gesture.r1 > gesture.r0 or (gesture.r1 == gesture.r0 and gesture.c1 >= gesture.c0);
const endpoint = rows[if (forward) rows.len - 1 else 0];
- const body = body_layer.bodyText(p, p.scratch.allocator(), pane) catch return;
+ const body = body_layer.bodyText(p.scratch.allocator(), pane) catch return;
const line = modal.lineSlice(body, @intCast(@max(0, endpoint.row - panes.terminal.gridOffset(pane))));
const byte = if (forward) modal.prevGrapheme(line, @min(endpoint.hi, line.len)) else endpoint.lo;
pane.body.cur_row = pane.surfRow(endpoint.row);
@@ -1251,32 +1235,6 @@ fn dragRelease(p: *Pardes, button: Mouse.Button) void {
},
.select => |s| {
const pane = p.panes[s.id] orelse return;
- if (comptime pdf_enabled) {
- if (s.pdf.native) {
- var release = panes.Pdf.pointerRelease(
- p,
- pane,
- s.pdf,
- s.button,
- s.chorded,
- );
- defer release.deinit(p.pdf_gpa);
- if (release.probe) |*probe| if (probe.link != null) {
- look.followPdfLink(p, s.id, probe);
- return;
- };
- // A native PDF page has no byte offsets of its own to
- // report, so a scripted pane cannot intercept this one.
- if (release.action) |action| dispatchPointerBuiltin(
- p,
- s.id,
- if (action == .look) config.look_cmd else config.exec_cmd,
- release.text,
- null,
- );
- return;
- }
- }
if (s.chorded) {
// a cut/paste chord consumed this drag; the release is inert
pane.sel[@backingInt(s.button)].state = .none;
@@ -1402,16 +1360,6 @@ fn dragRelease(p: *Pardes, button: Mouse.Button) void {
fn chordCutPaste(p: *Pardes, cut: bool) void {
const s = &p.view().drag.select;
const pane = p.panes[s.id] orelse return;
- if (comptime pdf_enabled) if (pane.pdf) |pv| {
- if (!s.chorded) {
- s.chorded = true;
- pane.sel[sel_slot].state = .none;
- }
- // A PDF is immutable: its Cut-side chord is Snarf (copy), while
- // Paste has no document mutation to perform.
- if (cut and pv.selection_text.len > 0) edit.setYank(p, pv.selection_text);
- return;
- };
if (@min(pane.sel[sel_slot].r0, pane.sel[sel_slot].r1) < pane.tag_rows) {
// A sweep over the tag cuts from and pastes into the tag's own text;
// the part of it over the prefix is not the tag's to cut, so the
diff --git a/src/ninep/ctl.zig b/src/ninep/ctl.zig
index 42d9f3bd..53128c5e 100644
--- a/src/ninep/ctl.zig
+++ b/src/ninep/ctl.zig
@@ -442,10 +442,9 @@ pub fn paneText(p: *Pardes, pane: *Pane, buf: []u8) []const u8 {
var idbuf: [48]u8 = undefined;
const id = exec_line.replId(&idbuf, pane);
if (id.len > 0) w.print("{s} ", .{id}) catch {};
- // Then what its tag does not say: Collapse, and a PDF's PdfFit and
- // PdfTint, in the words they take.
+ // Then what its tag does not say: Collapse, and a kind's own fields (a
+ // PDF's PdfFit and PdfTint, in the words they take).
if (pane.collapsed) w.writeAll("collapsed ") catch {};
- if (comptime pardes.pdf_enabled) if (pane.pdf) |pv| w.print("fit:{s} tint:{s} ", .{ @tagName(pv.fit), @tagName(pv.tint) }) catch {};
if (pane.addon != null) {
var fields: [128]u8 = undefined;
const kind_fields = pardes.Kind.ctlRead(pane, &fields);
@@ -1544,7 +1543,7 @@ test "an address looked at in an image pane names the image, never an empty subj
try testing.expect(th.logHas(p, "look: /tmp/pardes-pic.ppm is no text to address"));
}
-test "Save and Save path on an image pane are refused with why, never a silent success" {
+test "Save and Save path on a kind's pane (a picture) are refused with why, never a silent success" {
const p = try withFile(testing.allocator, "x\n");
defer p.deinit();
const id = p.freeSlot().?;
@@ -1552,7 +1551,7 @@ test "Save and Save path on an image pane are refused with why, never a silent s
for ([_][]const u8{ "Save\n", "Save /tmp/pardes-copy.ppm\n" }) |line| {
const r = wr(p, Node.of(doc.serial, .ctl), line);
try testing.expectEqual(Status.err, r.reply.status);
- try testing.expectEqualStrings("Save: an image pane has no text to save", r.reply.ename);
+ try testing.expectEqualStrings("Save: a test pane has no text to save", r.reply.ename);
}
}
@@ -1574,9 +1573,6 @@ test "a builtin for one kind of pane is refused on another, and still acts on it
try testing.expectEqual(Status.err, r.reply.status);
try testing.expectEqualStrings(case[1], r.reply.ename);
}
- if (pardes.pdf_enabled) for ([_][]const u8{ "PdfFit\n", "PdfTint\n", "PdfSections\n" }) |line| {
- try testing.expectEqual(Status.err, wr(p, Node.of(serial, .ctl), line).reply.status);
- };
const id = p.freeSlot().?;
// A picture shown: the core's art words follow the kind's prefix.
const doc = try pardes.Kind.open(p, id, pardes.Kind.test_kind.of(p), "/tmp/pardes-pic.ppm", "P6\n1 1\n255\n\x01\x02\x03");
@@ -2160,48 +2156,6 @@ test "a language server question that finds nothing, cannot be answered, or is a
try testing.expectEqual(E.INVAL, wr(p, Node.of(img.serial, .body), "text\n").errno());
}
-test "a truncated PDF fails its look with its path and why" {
- if (comptime !pardes.pdf_enabled) return;
- const p = try withFile(testing.allocator, "x\n");
- defer p.deinit();
- var tmp = testing.tmpDir(.{});
- defer tmp.cleanup();
- const bytes = try @import("mupdf").testFixture(testing.allocator, "links.pdf");
- defer testing.allocator.free(bytes);
- try tmp.dir.writeFile(testing.io, .{ .sub_path = "cut.pdf", .data = bytes[0..40] });
- var dir_buf: [4096]u8 = undefined;
- const dir = dir_buf[0..try tmp.dir.realPath(testing.io, &dir_buf)];
- var line: [4200]u8 = undefined;
- const r = wr(p, root_look, try std.fmt.bufPrint(&line, "{s}/cut.pdf\n", .{dir}));
- try testing.expectEqual(Status.err, r.reply.status);
- try testing.expect(std.mem.indexOf(u8, r.reply.ename, "cut.pdf: not a PDF pardes can read: ") != null);
-}
-
-test "a PDF's body reads its page's text layer, and takes no write" {
- if (comptime !pardes.pdf_enabled) return;
- const p = try withFile(testing.allocator, "x\n");
- defer p.deinit();
- var tmp = testing.tmpDir(.{});
- defer tmp.cleanup();
- const bytes = try @import("mupdf").testFixture(testing.allocator, "links.pdf");
- defer testing.allocator.free(bytes);
- try tmp.dir.writeFile(testing.io, .{ .sub_path = "doc.pdf", .data = bytes });
- var dir_buf: [4096]u8 = undefined;
- const dir = dir_buf[0..try tmp.dir.realPath(testing.io, &dir_buf)];
- var line: [4200]u8 = undefined;
- _ = wr(p, root_look, try std.fmt.bufPrint(&line, "{s}/doc.pdf\n", .{dir}));
- p.sync();
- const doc = p.panes[p.view().active].?;
- try testing.expect(doc.hasPdf());
- const body = Node.of(doc.serial, .body);
- try testing.expect(std.mem.indexOf(u8, rd(p, body, 0, 4096).bytes, "target.txt") != null);
- // Read from an offset, as a mount's chunked reads ask: the text from there.
- const whole = try testing.allocator.dupe(u8, rd(p, body, 0, 4096).bytes);
- defer testing.allocator.free(whole);
- try testing.expectEqualStrings(whole[3..], rd(p, body, 3, 4096).bytes);
- try testing.expectEqual(E.INVAL, wr(p, body, "more\n").errno());
-}
-
test "workspace symbols, Symbols and Diagnostics share their directory's one +Search" {
const p = try withFile(testing.allocator, "x\n");
defer p.deinit();
diff --git a/src/ninep/pane.zig b/src/ninep/pane.zig
index 92d28b99..704f1ac8 100644
--- a/src/ninep/pane.zig
+++ b/src/ninep/pane.zig
@@ -145,7 +145,6 @@ pub fn dirtyOf(pane: *const Pane) bool {
/// The pane's name: its file, its document, or a terminal's directory.
pub fn nameOf(p: *Pardes, pane: *const Pane) []const u8 {
if (pane.file) |*f| return f.path;
- if (pane.pdfPath()) |path| return path;
if (pane.addon) |k| if (k.path.len > 0) return k.path;
const cwd = pane.cwdSlice();
// A shell given no directory was started in the session's, and is
@@ -155,7 +154,6 @@ pub fn nameOf(p: *Pardes, pane: *const Pane) []const u8 {
pub fn kindOf(pane: *const Pane) []const u8 {
if (pane.file != null) return "text";
- if (pane.pdfPath() != null) return "pdf";
if (pane.addon) |k| return k.nameOf();
// A command's pane is no shell to type into: a script choosing a
// terminal by kind must not pick one.
@@ -350,7 +348,7 @@ pub fn fileSize(p: *Pardes, id: usize, f: PaneFile) u64 {
const pf = &pane.fs;
return switch (f) {
// A terminal's body reads its screen and history, as text.
- .body => if (pane.file == null and pane.isTerminal()) panes.terminal.screenTextLen(pane) else if (pdfText(p, pane)) |t| t.len else bodyOf(pane).len,
+ .body => if (pane.file == null and pane.isTerminal()) panes.terminal.screenTextLen(pane) else if (kindText(p, pane)) |t| t.len else bodyOf(pane).len,
// What addr selects, generated by each read: no length, as acme's
// data and xdata have none.
.data, .xdata => 0,
@@ -452,14 +450,11 @@ fn readFlag(p: *Pardes, req: Req, on: bool) Reply {
return tree.stagedReply(p, req);
}
-/// The text layer of the page a PDF pane shows (MuPDF's extraction, kept
-/// with the page), null for any other pane.
-/// A document's text, read-only: a PDF's text layer, a kind's `body`.
-fn pdfText(p: *Pardes, pane: *Pane) ?[]const u8 {
- if (pane.addon != null) return pardes.Kind.body(pane, p.scratch.allocator()) catch null;
- if (comptime !pardes.pdf_enabled) return null;
- const pv = pane.pdf orelse return null;
- return pv.ensureText(p.pdf_gpa);
+/// A kind's pane's text, read-only: its `body` (a PDF's: the text layer
+/// of the page shown); null for any other pane.
+fn kindText(p: *Pardes, pane: *Pane) ?[]const u8 {
+ if (pane.addon == null) return null;
+ return pardes.Kind.body(pane, p.scratch.allocator()) catch null;
}
fn readBody(p: *Pardes, req: Req, id: usize, pane: *Pane) Reply {
@@ -474,8 +469,8 @@ fn readBody(p: *Pardes, req: Req, id: usize, pane: *Pane) Reply {
.len = clip(n),
} } };
}
- // A PDF's body is its text layer, the page shown's: read-only.
- if (pdfText(p, pane)) |text| return tree.window(p, req, text);
+ // A kind's body is its text (a PDF's, the page shown's): read-only.
+ if (kindText(p, pane)) |text| return tree.window(p, req, text);
if (req.handle != 0 and pane.isTerminal()) return screen.readSnapshot(p, req, pane);
const text = panes.terminal.screenTextAlloc(pane, p.gpa) catch
return Reply.fail(req.tag, E.NOMEM);
diff --git a/src/normal.zig b/src/normal.zig
index d5ce5f4a..1fa5bf11 100644
--- a/src/normal.zig
+++ b/src/normal.zig
@@ -1,6 +1,6 @@
//! Helix normal mode: a key read against the configured bindings becomes
//! modal actions, replayed across every selection, and each action is done
-//! to the pane; PDF panes get their own normal keys.
+//! to the pane (a kind's pane takes its own keys first, Kind.key).
const pardes = @import("pardes.zig");
const tagline = @import("tagline.zig");
const exec = @import("exec.zig");
@@ -13,7 +13,6 @@ const panes = @import("panes.zig");
const edit = @import("edit.zig");
const config = @import("config.zig");
const keyboard = @import("keys.zig");
-const pdf_enabled = panes.Pdf.enabled;
const Pane = panes.Pane;
const Text = panes.Text;
const Key = pardes.Key;
@@ -852,7 +851,10 @@ fn executeNormalAction(p: *Pardes, t: *Text, a: modal.Normal.Action) void {
return panes.startPrompt(p, pane, &pane.body, .{ .search = config.search_marker }),
// In a file's text, n and N step its places while they answer for
// the register (Places.answersN); else helix's search of the register.
- .search_next, .search_prev => if (t.what == .body and pane.file != null and pane.places.answersN(p, pane))
+ // A kind's pane walks its `/`'s +Search (look.zig runSearch).
+ .search_next, .search_prev => if (t.what == .body and pane.addon != null)
+ return look.lookWalk(p, if (a.role == .search_next) 1 else -1)
+ else if (t.what == .body and pane.file != null and pane.places.answersN(p, pane))
return pane.places.step(p, pane, a.role == .search_next, a.count, t.select)
else
return searchStep(p, t, text, a.role == .search_next, a.count),
@@ -860,7 +862,7 @@ fn executeNormalAction(p: *Pardes, t: *Text, a: modal.Normal.Action) void {
searchSelection(p, t, text, a.role == .search_selection_word);
// The pattern is line 1 of this text's query pane, made or
// reused, the keyboard staying here: n and N step its places.
- if (t.what == .body and pane.file != null and !pane.hasPdf() and pane.query == null) {
+ if (t.what == .body and pane.file != null and pane.query == null) {
const name = if (v.register != 0) v.register else '/';
const pat = p.registers.value(name, 0) orelse return;
panes.Query.open(p, v.active, .text, pat, false);
@@ -910,19 +912,6 @@ fn executeNormalAction(p: *Pardes, t: *Text, a: modal.Normal.Action) void {
}
}
-pub fn handlePdfNormal(p: *Pardes, pane: *Pane, key: Key) void {
- if (comptime !pdf_enabled) return;
- if (pane.pdf == null) return;
- if (pane.body.normal.prefix == null and isPrefix(key, 'f')) {
- pane.body.normal.clear();
- return exec.runBuiltin(p, .PdfSections, p.view().active, "", null);
- }
- switch (modal.Normal.parse(&pane.body.normal, normalInput(key))) {
- .pending, .ignored, .unbound => {},
- .action => |action| panes.Pdf.applyNormal(p, pane, action),
- }
-}
-
test "gj/gk step the wrapped rows a body draws while j/k keep the file's lines" {
const gpa = std.testing.allocator;
const p = try Pardes.init(gpa, .{ .tty_only = true });
diff --git a/src/panes.zig b/src/panes.zig
index cfe09f33..1ec78bbc 100644
--- a/src/panes.zig
+++ b/src/panes.zig
@@ -20,7 +20,6 @@ const Cell = pardes.Cell;
const BOX_H = pardes.BOX_H;
const MAX_PANES = pardes.MAX_PANES;
const effect_path_cap = pardes.effect_path_cap;
-const pdf_enabled = Pdf.enabled;
/// An owned editable buffer and the absolute surface row of its first line.
/// Files use row zero; terminal overlays may begin anywhere in scrollback.
@@ -35,9 +34,9 @@ pub const Pane = struct {
.derived = .{ "wrap_line", "wrap_col", "wrap_pad", "wrap_n", "body_wrapped", "context_rows", "body_rows", "body_visible_rows", "context_row_limit", "geometry_key", "geometry_len", "notices", "pan" },
.authority = .{"fs"},
.len = .{ .{ "msg", "msg_len" }, .{ "msg_older", "msg_older_len" }, .{ "question", "question_len" }, .{ "shell_tail", "shell_tail_len" }, .{ "sel_snap", "nsel_snap" } },
- // A picture's and a PDF's memory is their own allocators' (a dump
- // loaded makes it there).
- .alloc = .{ .{ "addon", "image" }, .{ "pdf", "pdf" }, .{ "terminal", "terminal" } },
+ // A picture's memory is its own allocator's (a dump loaded makes
+ // it there).
+ .alloc = .{ .{ "addon", "image" }, .{ "pdf", "image" }, .{ "terminal", "terminal" } },
};
/// The words that throw unsaved text away (builtins.zig warnModified).
pub const Discarding = enum { Exit, Restore, get, Del, Delcol };
@@ -78,10 +77,14 @@ pub const Pane = struct {
col1: i32,
};
- /// A PDF's state is its own allocation in the pdf region, as a
- /// terminal's is its own: inline, its raster slots would be every
- /// pane's, and every rollback copy's.
- const PdfSlot = if (Pdf.enabled) ?*Pdf.State else void;
+ /// A PDF pane as a dump of a build before the pdf addon kept it, read
+ /// to open it as the addon's (dump.zig revivePane); never written.
+ pub const LegacyPdf = struct {
+ path: []u8 = &.{},
+ page: usize = 0,
+ fit: enum { width, height } = .width,
+ tint: enum { disabled, filtered, full } = .filtered,
+ };
/// What an open prompt is asking. The answer is typed into `input`.
pub const Prompt = union(enum) {
@@ -203,7 +206,7 @@ pub const Pane = struct {
file: ?File.State = null,
/// A pane of a kind (Kind.zig): a picture, or one a library brought.
addon: ?*@import("Kind.zig").Slot = null,
- pdf: PdfSlot = if (Pdf.enabled) null else {},
+ pdf: ?*LegacyPdf = null,
prompt: Prompt = .none,
/// The text an open prompt answers for: `s`/`S` select in it and `|`
/// pipes it. A header's is whichever has the keyboard; `/` and Save's
@@ -502,8 +505,7 @@ pub const Pane = struct {
}
pub fn isTerminal(pane: *const Pane) bool {
- const no_pdf = if (comptime Pdf.enabled) pane.pdf == null else true;
- return pane.file == null and pane.addon == null and no_pdf;
+ return pane.file == null and pane.addon == null and pane.pdf == null;
}
/// The one coloring choice keyed on what a pane IS, so the highlight
@@ -526,16 +528,6 @@ pub const Pane = struct {
return .none;
}
- pub fn pdfPath(pane: *const Pane) ?[]const u8 {
- if (comptime Pdf.enabled) if (pane.pdf) |pv| return pv.path;
- return null;
- }
-
- pub fn pdfPage(pane: *const Pane) ?usize {
- if (comptime Pdf.enabled) if (pane.pdf) |pv| return pv.page;
- return null;
- }
-
pub fn surfRow(pane: *const Pane, g: i32) i32 {
const o = pane.ovl orelse return g;
if (g <= o.row) return g;
@@ -556,7 +548,6 @@ pub const Pane = struct {
/// current scroll offset: file top line, or the scrollback offset
pub fn scroll(pane: *Pane) i32 {
if (pane.file) |f| return @intCast(f.scroll);
- if (comptime Pdf.enabled) if (pane.pdf) |pv| return @intCast(pv.text_scroll);
return pane.surfRow(terminal.gridOffset(pane) + pane.pan);
}
@@ -592,17 +583,7 @@ pub const Pane = struct {
f.scroll = next;
f.syntax_dirty = true;
}
- } else if (hasPdf(pane)) {
- if (comptime Pdf.enabled) {
- const pv = pane.pdf.?;
- const max: i64 = @intCast(modal.lineCount(pv.text) -| 1);
- pv.text_scroll = @intCast(std.math.clamp(
- @as(i64, @intCast(pv.text_scroll)) + delta,
- 0,
- max,
- ));
- }
- } else {
+ } else if (pane.addon == null) {
// the vt scrolls in SHELL rows; convert through the edit buffer
const off = terminal.gridOffset(pane);
terminal.scrollGrid(pane, pane.gridRow(pane.surfRow(off) + delta) - off);
@@ -654,10 +635,6 @@ pub const Pane = struct {
const lines: i32 = @intCast(File.nlines(pane.gpa, f));
to = @min(to, if (off == 0 and pane.textFits()) @max(pane.body.cur_row, lines - 1 - @intFromBool(std.mem.endsWith(u8, f.content, "\n"))) else lines - 1);
}
- if (comptime Pdf.enabled) {
- if (pane.pdf) |pv|
- to = @min(to, @as(i32, @intCast(modal.lineCount(pv.text) -| 1)));
- }
pane.scrollBy(@max(0, to - last));
}
}
@@ -685,7 +662,7 @@ pub const Pane = struct {
pub fn pinCursor(pane: *Pane) void {
if (pane.body.cur_pinned) return;
- if (pane.file != null or hasPdf(pane)) {
+ if (pane.file != null or pane.addon != null) {
pane.body.cur_row = pane.scroll();
pane.body.cur_col = 0;
} else {
@@ -695,17 +672,6 @@ pub const Pane = struct {
}
pane.body.cur_pinned = true;
}
-
- pub fn hasPdf(pane: *const Pane) bool {
- return if (comptime Pdf.enabled) pane.pdf != null else false;
- }
-
- pub fn hasPdfSelection(pane: *const Pane) bool {
- return if (comptime Pdf.enabled)
- if (pane.pdf) |pv| pv.selection != null and pv.selection_text.len > 0 else false
- else
- false;
- }
};
pub const Text = @import("Text.zig");
@@ -723,8 +689,6 @@ pub const Dir = @import("Dir.zig");
pub const mini = @import("mini.zig");
-pub const Pdf = @import("pdf_view.zig");
-
pub const terminal = @import("terminal.zig");
test {
@@ -735,7 +699,6 @@ test {
_ = Dir;
_ = mini;
_ = @import("Kind.zig");
- _ = Pdf;
_ = terminal;
}
@@ -776,7 +739,7 @@ pub fn retirePane(p: *Pardes, pane: *Pane) void {
// A query pane's places, in whatever panes it fed, go with it.
if (pane.query != null) panes.Query.release(p, pane);
if (pane.file) |*file| panes.File.leaveTwins(p, file);
- const watched = (if (pane.file) |f| f.output == null else false) or pane.hasPdf();
+ const watched = (if (pane.file) |f| f.output == null else false) or (if (pane.addon) |k| k.path.len > 0 else false);
for (p.panes, 0..) |slot, id| if (slot == pane) {
if (watched) p.emit(.{ .watch = .{ .pane = @intCast(id), .on = false } });
if (pane.isTerminal()) p.emit(.{ .close_pty = .{ .pane = @intCast(id) } });
@@ -803,7 +766,10 @@ pub fn teardownPane(p: *Pardes, pane: *Pane) void {
if (pane.command) |line| p.gpa.free(line);
if (pane.shell) |bin| p.gpa.free(bin);
@import("Kind.zig").close(p, pane);
- if (comptime pdf_enabled) if (pane.pdf) |pv| panes.Pdf.deinitPane(p, pane, pv);
+ if (pane.pdf) |old| {
+ p.image_gpa.free(old.path);
+ p.image_gpa.destroy(old);
+ }
if (pane.file) |*file| panes.File.deinit(p, pane, file);
if (pane.ovl) |o| p.gpa.free(o.text);
views.tornDown(p, pane);
@@ -996,8 +962,6 @@ pub fn paneDir(pane: *const Pane) []const u8 {
.none => {},
}
if (pane.file) |f| return panes.Dir.ofName(f.path);
- if (comptime pdf_enabled) if (pane.pdf) |pv|
- return std.fs.path.dirname(pv.path) orelse "/";
if (pane.addon) |k| if (k.path.len > 0) return std.fs.path.dirname(k.path) orelse "/";
return pane.cwdSlice();
}
diff --git a/src/pardes.zig b/src/pardes.zig
index 58f8fa17..ecbc0633 100644
--- a/src/pardes.zig
+++ b/src/pardes.zig
@@ -69,8 +69,6 @@ pub const builtins_json = @import("builtins_json.zig");
const limits = memory.limits;
const selection_pipe = @import("selection_pipe.zig");
pub const config = @import("config.zig");
-pub const pdf_enabled = panes.Pdf.enabled;
-pub const pdf = panes.Pdf.pdf;
pub const memory = @import("memory.zig");
pub const tape = @import("tape.zig");
pub const walk = @import("walk.zig");
@@ -111,24 +109,15 @@ pub const can_attach = platform == .tui or platform == .gui;
pub const fonts = if (font_picker) @import("fonts.zig") else struct {};
-pub const PdfRasterPolicy = panes.Pdf.RasterPolicy;
-
-pub const kitty_pdf_raster_policy: PdfRasterPolicy = .{
- .dpi = 96,
- .max_dimension = 1200,
- .match_viewport = false,
-};
-pub const sdl_pdf_raster_policy: PdfRasterPolicy = .{
- .dpi = 192,
- .max_dimension = 4096,
- .match_viewport = true,
-};
-pub const pdf_raster_policy: PdfRasterPolicy = switch (platform) {
- .tui => kitty_pdf_raster_policy,
- // Both pixel shells rasterize for a real display and can afford it; the
- // wire-bandwidth argument that shapes the Kitty policy does not apply.
- .gui, .macos => sdl_pdf_raster_policy,
-};
+/// The raster a frontend wants a kind's picture at (Kind.viewOf, a
+/// `pa_view`): a terminal's kitty images go down a wire, so smaller; a
+/// window rasterizes for its display.
+pub const RasterPolicy = struct { dpi: u16, max_dimension: u16, match_viewport: bool };
+/// A view's: a window's denser than a terminal's. By the view's frontend,
+/// never the build's, so every core of a session asks a kind alike.
+pub fn rasterPolicy(windowed: bool) RasterPolicy {
+ return if (windowed) .{ .dpi = 192, .max_dimension = 4096, .match_viewport = true } else .{ .dpi = 96, .max_dimension = 1200, .match_viewport = false };
+}
pub const Pane = panes.Pane;
const Text = panes.Text;
@@ -149,7 +138,6 @@ pub const MAX_TAG_ROWS = 8;
/// bands: a band to a tag, however many lines it has.
pub const MAX_TAG_LAYERS = MAX_PANES + MAX_COLS + 1 + MAX_PANES * Pane.Notices.max;
pub const NOTICE_LAYER_BASE = MAX_PANES + MAX_COLS + 1;
-pub const PDF_PAGE_GAP_PX = panes.Pdf.page_gap_px;
/// Columns a session holds (each costs about 8 KB of state, a column tag
/// being most of it).
pub const MAX_COLS = 16;
diff --git a/src/pdf.zig b/src/pdf.zig
deleted file mode 100644
index 7cfb86d5..00000000
--- a/src/pdf.zig
+++ /dev/null
@@ -1,1904 +0,0 @@
-//! Exception-safe MuPDF runtime wrapper. MuPDF's public API throws with
-//! setjmp/longjmp; pdf_bridge.c catches every such throw before control returns
-//! to Zig. This module is present in native builds unless `-Dmupdf=false`.
-const std = @import("std");
-const c_heap = @import("c_heap");
-
-const c = @import("pdf_c"); // src/pdf_bridge.h, translated by build.zig
-
-/// What MuPDF allocates from, itself and the libraries it bundles (they all
-/// allocate through its context): `start`'s allocator, through the shared C
-/// heap. MuPDF's allocator functions carry a user pointer the heap does not
-/// need.
-var bridge_allocator: std.mem.Allocator = undefined;
-const bridge_heap = c_heap.Heap(&bridge_allocator);
-var bridge_started = false;
-
-fn bridgeAlloc(_: ?*anyopaque, size: usize) callconv(.c) ?*anyopaque {
- return bridge_heap.malloc(size);
-}
-
-fn bridgeRealloc(_: ?*anyopaque, block: ?*anyopaque, size: usize) callconv(.c) ?*anyopaque {
- return bridge_heap.realloc(block, size);
-}
-
-fn bridgeFree(_: ?*anyopaque, block: ?*anyopaque) callconv(.c) void {
- bridge_heap.free(block);
-}
-
-/// Installs the allocator used by all subsequently opened PDF documents and
-/// by MuPDF itself. Call once before opening any documents.
-pub fn start(allocator: std.mem.Allocator) void {
- if (bridge_started) @panic("PDF allocator is already started");
- bridge_allocator = allocator;
- const descriptor = c.pardes_pdf_allocator{
- .user = null,
- .alloc = bridgeAlloc,
- .realloc = bridgeRealloc,
- .free = bridgeFree,
- };
- if (c.pardes_pdf_set_allocator(&descriptor) != c.PARDES_PDF_OK)
- @panic("cannot start PDF allocator while documents are live");
- bridge_started = true;
-}
-
-/// Restores libc and MuPDF's default allocator. Every Document must have been
-/// destroyed first so no allocation can outlive its allocator domain.
-pub fn stop() void {
- if (!bridge_started) @panic("PDF allocator is not started");
- if (c.pardes_pdf_set_allocator(null) != c.PARDES_PDF_OK)
- @panic("cannot stop PDF allocator while documents are live");
- bridge_started = false;
- bridge_allocator = undefined;
-}
-
-test "custom allocator owns a complete PDF document lifecycle" {
- start(std.testing.allocator);
- defer stop();
-
- var document = try openTestFile("docs/design.pdf");
- defer document.deinit();
- const raster = try document.render(std.testing.allocator, 0, .{}, &.{});
- defer std.testing.allocator.free(raster.rgba);
- try std.testing.expect(raster.rgba.len > 0);
-}
-
-test "two lanes render two pages of one document at once, each as the base renders it, and a cookie aborts" {
- const gpa = std.testing.allocator;
- var base = try openTestFile("docs/design.pdf");
- defer base.deinit();
- try std.testing.expect(base.pages >= 2);
- const Lane = struct {
- doc: Document,
- page: usize,
- out: ?Render = null,
- fn run(lane: *@This()) void {
- lane.doc.laneOpen() catch return;
- lane.out = lane.doc.render(std.testing.allocator, lane.page, .{}, &.{}) catch null;
- }
- };
- // Cloned on the base's thread; each lane's document opened on its own.
- var lanes = [2]Lane{ .{ .doc = try base.laneClone(), .page = 0 }, .{ .doc = try base.laneClone(), .page = 1 } };
- defer for (&lanes) |*lane| {
- if (lane.out) |r| gpa.free(r.rgba);
- lane.doc.deinit();
- };
- var threads: [2]std.Thread = undefined;
- for (&threads, &lanes) |*t, *lane| t.* = try std.Thread.spawn(.{}, Lane.run, .{lane});
- for (threads) |t| t.join();
- for (lanes) |lane| {
- const want = try base.render(gpa, lane.page, .{}, &.{});
- defer gpa.free(want.rgba);
- try std.testing.expect(std.mem.eql(u8, want.rgba, lane.out.?.rgba));
- }
- // An abort set before the run stops it at its first operator.
- var cookie = std.mem.zeroes(Cookie);
- cookie.abort = 1;
- lanes[0].doc.setCookie(&cookie);
- try std.testing.expectError(error.Aborted, lanes[0].doc.render(gpa, 1, .{}, &.{}));
- lanes[0].doc.setCookie(null);
-}
-
-/// One raster-quality request. `minimum_*` asks MuPDF for enough source pixels
-/// to avoid backend upscaling; `max_dimension` caps a raster row always, and
-/// the page's height unless that would draw it below `display_*`, the size
-/// the page is shown at (0: no floor). A page taller than that is never one
-/// allocation: its owner renders bands of it (`Raster.band`).
-pub const RenderRequest = struct {
- dpi: u16 = 144,
- minimum_width: u32 = 0,
- minimum_height: u32 = 0,
- max_dimension: u16 = 1600,
- display_width: u32 = 0,
- display_height: u32 = 0,
-
- pub fn eql(a: RenderRequest, b: RenderRequest) bool {
- return std.meta.eql(a, b);
- }
-};
-
-pub const absolute_max_render_dimension: u16 = 4096;
-/// The most one render buffer holds: a whole page, or one band of a page
-/// taller than this.
-pub const max_owned_raster_bytes: usize = @as(usize, absolute_max_render_dimension) *
- absolute_max_render_dimension * 4;
-/// Maximum native outline rows accepted atomically from one document.
-pub const max_outline_items: usize = c.PARDES_PDF_MAX_OUTLINE_ITEMS;
-
-/// Page-space geometry is normalized to the page bounds, not a render. It
-/// therefore survives DPI changes and can be shared by Kitty and SDL.
-pub const Cookie = c.pardes_pdf_cookie;
-pub const Point = c.pardes_pdf_point;
-pub const Quad = c.pardes_pdf_quad;
-
-pub const HighlightKind = enum(c_int) {
- custom = c.PARDES_PDF_HIGHLIGHT_CUSTOM,
- search = c.PARDES_PDF_HIGHLIGHT_SEARCH,
- selection = c.PARDES_PDF_HIGHLIGHT_SELECTION,
-};
-
-/// RGBA is straight (not premultiplied). `kind` remains available to the UI as
-/// semantic metadata; the caller-supplied RGBA is authoritative for rendering.
-pub const Highlight = extern struct {
- quad: Quad,
- rgba: [4]u8,
- kind: HighlightKind,
-
- pub fn init(quad: Quad, rgba: [4]u8, kind: HighlightKind) Highlight {
- return .{ .quad = quad, .rgba = rgba, .kind = kind };
- }
-};
-
-comptime {
- if (@sizeOf(Highlight) != @sizeOf(c.pardes_pdf_highlight) or
- @alignOf(Highlight) != @alignOf(c.pardes_pdf_highlight) or
- @offsetOf(Highlight, "quad") != @offsetOf(c.pardes_pdf_highlight, "quad") or
- @offsetOf(Highlight, "rgba") != @offsetOf(c.pardes_pdf_highlight, "rgba") or
- @offsetOf(Highlight, "kind") != @offsetOf(c.pardes_pdf_highlight, "kind"))
- @compileError("Highlight must match pardes_pdf_highlight's C ABI");
-}
-
-pub const Render = struct {
- rgba: []u8,
- width: usize,
- height: usize,
-};
-
-/// Pane-local PDF color treatment. The core owns when this changes; keeping
-/// the pixel transform here lets the renderer benchmark and any future PDF
-/// consumer exercise exactly the same fixed-point rule.
-pub const TintMode = enum {
- disabled,
- filtered,
- full,
-
- pub fn next(mode: TintMode) TintMode {
- return switch (mode) {
- .disabled => .filtered,
- .filtered => .full,
- .full => .disabled,
- };
- }
-};
-
-pub const TintColors = struct {
- background: [3]u8,
- foreground: [3]u8,
-};
-
-fn tintTargets(colors: TintColors) [256][3]u8 {
- var targets: [256][3]u8 = undefined;
- for (&targets, 0..) |*target, luminance| {
- inline for (0..3) |channel| {
- target[channel] = @intCast(
- (@as(u32, colors.foreground[channel]) * @as(u32, @intCast(255 - luminance)) +
- @as(u32, colors.background[channel]) * @as(u32, @intCast(luminance)) + 127) / 255,
- );
- }
- }
- return targets;
-}
-
-const tint_chroma_residuals: [511]i16 = table: {
- var values: [511]i16 = undefined;
- for (&values, 0..) |*value, index| {
- const residual: i16 = @as(i16, @intCast(index)) - 255;
- value.* = @divTrunc(residual * 3, 4);
- }
- break :table values;
-};
-
-const tint_clamped_sums: [638]u8 = table: {
- @setEvalBranchQuota(2000);
- var values: [638]u8 = undefined;
- for (&values, 0..) |*value, index| {
- const sum: i16 = @as(i16, @intCast(index)) - 191;
- value.* = @intCast(std.math.clamp(sum, 0, 255));
- }
- break :table values;
-};
-
-inline fn filteredTintChannel(target: u8, source: u8, residual_base: i16) u8 {
- const chroma = tint_chroma_residuals[@intCast(residual_base + source)];
- return tint_clamped_sums[@intCast(@as(i16, target) + chroma + 191)];
-}
-
-/// Rewrite packed straight-alpha RGBA in place without allocating.
-///
-/// Source luminance is Rec. 601's 77/150/29 integer approximation. `full`
-/// linearly maps source black to theme foreground and source white to theme
-/// background. `filtered` starts with that same themed target, then adds 3/4
-/// of each source channel's signed distance from source luminance, clamped to
-/// a byte. Thus grayscale is identical in both modes while filtered color
-/// retains the source hue/chroma. Alpha is never touched.
-pub fn tintRgba(rgba: []u8, mode: TintMode, colors: TintColors) !void {
- if (rgba.len % 4 != 0) return error.InvalidRgbaLength;
- if (mode == .disabled) return;
-
- const targets = tintTargets(colors);
- const pixels = std.mem.bytesAsSlice([4]u8, rgba);
- switch (mode) {
- .disabled => unreachable,
- .full => tintPixels(pixels, .full, &targets),
- .filtered => tintPixels(pixels, .filtered, &targets),
- }
-}
-
-/// The whole rule for ONE pixel, and the reason the memo below is exact: the
-/// transform reads nothing but this packed word, and alpha rides through
-/// untouched, so the word is a complete cache key.
-inline fn tintPixel(word: u32, comptime mode: TintMode, targets: *const [256][3]u8) u32 {
- var pixel: [4]u8 = @bitCast(word);
- const red = pixel[0];
- const green = pixel[1];
- const blue = pixel[2];
- const luminance: u8 = @intCast((@as(u32, red) * 77 +
- @as(u32, green) * 150 +
- @as(u32, blue) * 29 + 128) >> 8);
- const target = targets[luminance];
- switch (mode) {
- .disabled => comptime unreachable,
- .full => {
- pixel[0] = target[0];
- pixel[1] = target[1];
- pixel[2] = target[2];
- },
- .filtered => {
- const residual_base: i16 = 255 - @as(i16, luminance);
- pixel[0] = filteredTintChannel(target[0], red, residual_base);
- pixel[1] = filteredTintChannel(target[1], green, residual_base);
- pixel[2] = filteredTintChannel(target[2], blue, residual_base);
- },
- }
- return @bitCast(pixel);
-}
-
-/// Alpha-less packed tint for every grayscale level. See tintWord: this one
-/// table serves BOTH modes, which is why it takes no mode.
-fn grayTintTable(targets: *const [256][3]u8) [256]u32 {
- var table: [256]u32 = undefined;
- for (&table, targets) |*word, target|
- word.* = @bitCast([4]u8{ target[0], target[1], target[2], 0 });
- return table;
-}
-
-const tint_alpha_mask: u32 = @bitCast([4]u8{ 0, 0, 0, 0xff });
-
-/// One pixel, with the two shortcuts that make a full-page tint affordable.
-///
-/// Rec. 601's integer weights sum to exactly 256, so for r == g == b the
-/// luminance dot product is the channel value itself, and `filtered`'s chroma
-/// residual is then exactly zero — both modes collapse to the themed target
-/// for that level. A text page's raster is overwhelmingly grayscale, so this
-/// arm carries almost every pixel at one table load. Colour falls through to
-/// the general rule, unchanged.
-inline fn tintWord(
- word: u32,
- comptime mode: TintMode,
- targets: *const [256][3]u8,
- gray: *const [256]u32,
-) u32 {
- const pixel: [4]u8 = @bitCast(word);
- if (pixel[0] == pixel[1] and pixel[1] == pixel[2])
- return gray[pixel[0]] | (word & tint_alpha_mask);
- return tintPixel(word, mode, targets);
-}
-
-/// Pixels per run test. Sixteen is four SSE2 registers: one branch says
-/// "this whole span repeats the previous pixel", which is the shape of the
-/// paper margins and of any flat fill.
-const tint_run_pixels = 16;
-
-/// A rasterized page is mostly flat — paper, then runs of one ink value — and
-/// the transform reads nothing but the packed word, so a one-entry memo tested
-/// a span at a time turns those runs into one comparison and one store. That,
-/// plus the grayscale collapse above, is what lets a fling afford to tint a
-/// whole freshly rasterized page inside a single frame. Colour-photographic
-/// content pays the span comparison and nothing else; the arithmetic is
-/// byte-for-byte the scalar rule in every arm.
-fn tintPixels(pixels: [][4]u8, comptime mode: TintMode, targets: *const [256][3]u8) void {
- const gray = grayTintTable(targets);
- const Run = @Vector(tint_run_pixels, u32);
- var memo_key: u32 = undefined;
- var memo_value: u32 = undefined;
- var memo_valid = false;
- var at: usize = 0;
- while (at + tint_run_pixels <= pixels.len) : (at += tint_run_pixels) {
- const span = pixels[at..][0..tint_run_pixels];
- if (memo_valid) {
- const words: Run = @bitCast(span.*);
- if (@reduce(.And, words == @as(Run, @splat(memo_key)))) {
- span.* = @bitCast(@as(Run, @splat(memo_value)));
- continue;
- }
- }
- for (span) |*pixel| {
- memo_key = @bitCast(pixel.*);
- memo_value = tintWord(memo_key, mode, targets, &gray);
- pixel.* = @bitCast(memo_value);
- }
- memo_valid = true;
- }
- while (at < pixels.len) : (at += 1) {
- const pixel = &pixels[at];
- const word: u32 = @bitCast(pixel.*);
- pixel.* = @bitCast(tintWord(word, mode, targets, &gray));
- }
-}
-
-fn tintRgbaReference(rgba: []u8, mode: TintMode, colors: TintColors) !void {
- if (rgba.len % 4 != 0) return error.InvalidRgbaLength;
- if (mode == .disabled) return;
- var at: usize = 0;
- while (at < rgba.len) : (at += 4) {
- const source = rgba[at..][0..3];
- const luminance: u8 = @intCast((@as(u32, source[0]) * 77 +
- @as(u32, source[1]) * 150 +
- @as(u32, source[2]) * 29 + 128) >> 8);
- for (0..3) |channel| {
- const target: i32 = @intCast((@as(u32, colors.foreground[channel]) * (255 - @as(u32, luminance)) +
- @as(u32, colors.background[channel]) * @as(u32, luminance) + 127) / 255);
- const chroma = if (mode == .filtered)
- @divTrunc(
- (@as(i32, source[channel]) - @as(i32, luminance)) * 3,
- 4,
- )
- else
- 0;
- rgba[at + channel] = @intCast(std.math.clamp(target + chroma, 0, 255));
- }
- }
-}
-
-fn tintTestByte(state: *u64) u8 {
- state.* = state.* *% 6364136223846793005 +% 1442695040888963407;
- return @truncate(state.* >> 32);
-}
-
-test "PDF tint lookup tables are exact over every signed chroma residual" {
- for (tint_chroma_residuals, 0..) |actual, index| {
- const residual: i16 = @as(i16, @intCast(index)) - 255;
- try std.testing.expectEqual(@divTrunc(residual * 3, 4), actual);
- }
- for (tint_clamped_sums, 0..) |actual, index| {
- const sum: i16 = @as(i16, @intCast(index)) - 191;
- try std.testing.expectEqual(
- @as(u8, @intCast(std.math.clamp(sum, 0, 255))),
- actual,
- );
- }
-}
-
-test "optimized PDF tint matches scalar rule for every endpoint combination" {
- const modes = [_]TintMode{ .full, .filtered };
- for (0..8) |background_mask| {
- for (0..8) |foreground_mask| {
- const colors: TintColors = .{
- .background = .{
- if (background_mask & 1 == 0) 0 else 255,
- if (background_mask & 2 == 0) 0 else 255,
- if (background_mask & 4 == 0) 0 else 255,
- },
- .foreground = .{
- if (foreground_mask & 1 == 0) 0 else 255,
- if (foreground_mask & 2 == 0) 0 else 255,
- if (foreground_mask & 4 == 0) 0 else 255,
- },
- };
- var source: [8 * 2 * 4]u8 = undefined;
- var at: usize = 0;
- for (0..8) |source_mask| {
- for ([_]u8{ 0, 255 }) |alpha| {
- source[at..][0..4].* = .{
- if (source_mask & 1 == 0) 0 else 255,
- if (source_mask & 2 == 0) 0 else 255,
- if (source_mask & 4 == 0) 0 else 255,
- alpha,
- };
- at += 4;
- }
- }
- for (modes) |mode| {
- var expected = source;
- var actual = source;
- try tintRgbaReference(&expected, mode, colors);
- try tintRgba(&actual, mode, colors);
- try std.testing.expectEqualSlices(u8, &expected, &actual);
- }
- }
- }
-}
-
-test "optimized PDF tint matches scalar rule across deterministic broad samples" {
- const modes = [_]TintMode{ .full, .filtered };
- var state: u64 = 0x7061_7264_6573_5449;
- for (0..64) |_| {
- const colors: TintColors = .{
- .background = .{ tintTestByte(&state), tintTestByte(&state), tintTestByte(&state) },
- .foreground = .{ tintTestByte(&state), tintTestByte(&state), tintTestByte(&state) },
- };
- var source: [512 * 4]u8 = undefined;
- for (&source) |*byte| byte.* = tintTestByte(&state);
- for (modes) |mode| {
- var expected = source;
- var actual = source;
- try tintRgbaReference(&expected, mode, colors);
- try tintRgba(&actual, mode, colors);
- try std.testing.expectEqualSlices(u8, &expected, &actual);
- }
- }
-}
-
-// The memo, its tint_run_pixels span test, and the grayscale collapse only
-// engage on repeated or achromatic pixels, and the span loop leaves a tail on
-// any pixel count that is not a multiple of tint_run_pixels. None of that is
-// visible to the random corpus above, so drive flat runs, run boundaries, and
-// every remainder against the reference rule directly.
-test "optimized PDF tint matches scalar rule across runs, boundaries, and every tail" {
- const modes = [_]TintMode{ .full, .filtered };
- const colors: TintColors = .{
- .background = .{ 0x08, 0x12, 0x2a },
- .foreground = .{ 0xbd, 0xa4, 0x71 },
- };
- // Paper, ink, antialiased edge, saturated colour, and a transparent pixel
- // that shares its RGB with an opaque one — the memo key must include alpha
- // or that pair would tint from one cached word.
- const palette = [_][4]u8{
- .{ 0xff, 0xff, 0xff, 0xff },
- .{ 0x00, 0x00, 0x00, 0xff },
- .{ 0x7f, 0x80, 0x81, 0xff },
- .{ 0xff, 0x00, 0x00, 0xff },
- .{ 0xff, 0xff, 0xff, 0x00 },
- };
- var state: u64 = 0x7061_7264_6573_5254;
- var pixels: [37][4]u8 = undefined;
- for (0..96) |round| {
- // Alternate long flat runs against pixel-by-pixel churn so the block
- // fast path, the per-pixel memo, and the miss path all run.
- var run_left: usize = 0;
- var current: [4]u8 = palette[round % palette.len];
- for (&pixels) |*pixel| {
- if (run_left == 0) {
- run_left = 1 + (tintTestByte(&state) % 9);
- current = if (tintTestByte(&state) & 3 == 0)
- .{ tintTestByte(&state), tintTestByte(&state), tintTestByte(&state), tintTestByte(&state) }
- else
- palette[tintTestByte(&state) % palette.len];
- }
- run_left -= 1;
- pixel.* = current;
- }
- for (0..pixels.len + 1) |count| {
- const source = std.mem.sliceAsBytes(pixels[0..count]);
- for (modes) |mode| {
- var expected: [pixels.len * 4]u8 = undefined;
- var actual: [pixels.len * 4]u8 = undefined;
- @memcpy(expected[0..source.len], source);
- @memcpy(actual[0..source.len], source);
- try tintRgbaReference(expected[0..source.len], mode, colors);
- try tintRgba(actual[0..source.len], mode, colors);
- try std.testing.expectEqualSlices(u8, expected[0..source.len], actual[0..source.len]);
- }
- }
- }
-}
-
-test "PDF tint mode cycle is exact" {
- try std.testing.expectEqual(TintMode.filtered, TintMode.disabled.next());
- try std.testing.expectEqual(TintMode.full, TintMode.filtered.next());
- try std.testing.expectEqual(TintMode.disabled, TintMode.full.next());
-}
-
-test "full PDF tint maps black and white to dark and light theme endpoints" {
- const dark: TintColors = .{
- .background = .{ 0x12, 0x12, 0x12 },
- .foreground = .{ 0x94, 0x94, 0x94 },
- };
- var dark_pixels = [_]u8{ 0, 0, 0, 17, 255, 255, 255, 231 };
- try tintRgba(&dark_pixels, .full, dark);
- try std.testing.expectEqualSlices(u8, &.{ 0x94, 0x94, 0x94, 17 }, dark_pixels[0..4]);
- try std.testing.expectEqualSlices(u8, &.{ 0x12, 0x12, 0x12, 231 }, dark_pixels[4..8]);
-
- const light: TintColors = .{
- .background = .{ 0xea, 0xff, 0xff },
- .foreground = .{ 0x00, 0x00, 0x00 },
- };
- var light_pixels = [_]u8{ 0, 0, 0, 0, 255, 255, 255, 255 };
- try tintRgba(&light_pixels, .full, light);
- try std.testing.expectEqualSlices(u8, &.{ 0x00, 0x00, 0x00, 0 }, light_pixels[0..4]);
- try std.testing.expectEqualSlices(u8, &.{ 0xea, 0xff, 0xff, 255 }, light_pixels[4..8]);
-}
-
-test "filtered PDF tint preserves fixed-point source chroma and alpha" {
- const colors: TintColors = .{
- .background = .{ 20, 40, 60 },
- .foreground = .{ 220, 200, 180 },
- };
- var full = [_]u8{ 255, 0, 0, 37 };
- var filtered = full;
- try tintRgba(&full, .full, colors);
- try tintRgba(&filtered, .filtered, colors);
- // Red has integer luma 77. The themed target is {160,152,144}; adding
- // 3/4 of its {178,-77,-77} chroma residual yields this clamped result.
- try std.testing.expectEqualSlices(u8, &.{ 160, 152, 144, 37 }, &full);
- try std.testing.expectEqualSlices(u8, &.{ 255, 95, 87, 37 }, &filtered);
-
- var gray_full = [_]u8{ 128, 128, 128, 91 };
- var gray_filtered = gray_full;
- try tintRgba(&gray_full, .full, colors);
- try tintRgba(&gray_filtered, .filtered, colors);
- try std.testing.expectEqualSlices(u8, &gray_full, &gray_filtered);
- try std.testing.expectEqual(@as(u8, 91), gray_filtered[3]);
-}
-
-test "disabled PDF tint is byte-identical and malformed RGBA is rejected unchanged" {
- const colors: TintColors = .{
- .background = .{ 1, 2, 3 },
- .foreground = .{ 4, 5, 6 },
- };
- var pixels = [_]u8{ 9, 80, 170, 0, 250, 33, 71, 199 };
- const before = pixels;
- try tintRgba(&pixels, .disabled, colors);
- try std.testing.expectEqualSlices(u8, &before, &pixels);
-
- var malformed = [_]u8{ 11, 22, 33 };
- const malformed_before = malformed;
- try std.testing.expectError(error.InvalidRgbaLength, tintRgba(&malformed, .full, colors));
- try std.testing.expectEqualSlices(u8, &malformed_before, &malformed);
-}
-
-pub const PageSize = struct {
- width: f32,
- height: f32,
-};
-
-pub const SearchQuad = struct {
- quad: Quad,
- /// Zero-based logical hit. One hit may have several oriented quads.
- hit: usize,
-};
-
-pub const SearchResults = struct {
- quads: []SearchQuad,
- hit_count: usize,
-
- pub fn deinit(results: *SearchResults, gpa: std.mem.Allocator) void {
- gpa.free(results.quads);
- results.* = undefined;
- }
-};
-
-pub const Selection = struct {
- quads: []Quad,
- /// Word-snapped endpoints; pass these to `Document.copySelection`.
- start: Point,
- end: Point,
-
- /// Hit-test without flattening oriented text quads to axis-aligned boxes.
- /// The bridge delegates to MuPDF's geometry predicate and cannot throw.
- pub fn contains(selection: *const Selection, point: Point) bool {
- if (!validPoint(point)) return false;
- for (selection.quads) |quad| {
- if (c.pardes_pdf_point_inside_quad(point, quad) != 0) return true;
- }
- return false;
- }
-
- pub fn deinit(selection: *Selection, gpa: std.mem.Allocator) void {
- gpa.free(selection.quads);
- selection.* = undefined;
- }
-};
-
-pub const OutlineInternalDestination = struct {
- /// Zero-based document page number.
- page: usize,
- /// MuPDF page-space viewing coordinates; null when the PDF destination
- /// omits that axis (for example, a Fit destination omits both).
- x: ?f32,
- y: ?f32,
-};
-
-pub const OutlineDestination = union(enum) {
- none,
- internal: OutlineInternalDestination,
- external: []const u8,
-};
-
-pub const Link = struct {
- page: usize,
- quad: Quad,
- /// Owned independently of the document's current-page cache. External
- /// destination slices point into this same allocation.
- uri: []u8,
- destination: OutlineDestination,
-
- pub fn deinit(link: *Link, gpa: std.mem.Allocator) void {
- gpa.free(link.uri);
- link.* = undefined;
- }
-};
-
-pub const OutlineEntry = struct {
- /// Zero for a root row; rows are in stable pre-order depth-first order.
- depth: u8,
- /// Null preserves a missing /Title; a present empty title is "".
- title: ?[]const u8,
- destination: OutlineDestination,
-};
-
-/// All title and external-URI slices point into `bytes`. This fixed two-allocation
-/// representation avoids one allocation per row while keeping deinit deterministic.
-pub const Outline = struct {
- entries: []OutlineEntry,
- bytes: []u8,
-
- pub fn deinit(outline: *Outline, gpa: std.mem.Allocator) void {
- gpa.free(outline.entries);
- gpa.free(outline.bytes);
- outline.* = undefined;
- }
-};
-
-test "oriented selection containment delegates to MuPDF quad geometry" {
- const quads = [_]Quad{.{
- .ul = .{ .x = 0.10, .y = 0.10 },
- .ur = .{ .x = 0.70, .y = 0.20 },
- .ll = .{ .x = 0.20, .y = 0.80 },
- .lr = .{ .x = 0.80, .y = 0.90 },
- }};
- const selection = Selection{
- .quads = @constCast(quads[0..]),
- .start = quads[0].ul,
- .end = quads[0].lr,
- };
- try std.testing.expect(selection.contains(.{ .x = 0.45, .y = 0.50 }));
- try std.testing.expect(!selection.contains(.{ .x = 0.05, .y = 0.85 }));
- try std.testing.expect(!selection.contains(.{ .x = -0.1, .y = 0.5 }));
-}
-
-pub const Document = struct {
- /// None in a document loaded from a dump until its PDF is opened again
- /// (pdf_view.reopen).
- handle: ?*c.pardes_pdf_document = null,
- pages: usize,
-
- /// The open document is MuPDF's, made from the file's bytes (src/walk.zig).
- pub const replica = .{ .derived = .{"handle"} };
-
- pub fn deinit(document: *Document) void {
- c.pardes_pdf_close(document.handle);
- document.* = undefined;
- }
-
- pub fn openBytes(bytes: []const u8) !Document {
- var page_count: c_int = 0;
- const handle = c.pardes_pdf_open_memory(bytes.ptr, bytes.len, &page_count) orelse
- return error.OpenFailed;
- return .{ .handle = handle, .pages = @intCast(page_count) };
- }
-
- /// A render lane of this document (`pardes_pdf_lane_clone`): its own
- /// cloned context, its own document opened (`laneOpen`) on the thread
- /// that renders with it. Deinit every lane before `base`.
- pub fn laneClone(base: *Document) !Document {
- const handle = c.pardes_pdf_lane_clone(base.handle) orelse return error.OpenFailed;
- return .{ .handle = handle, .pages = base.pages };
- }
-
- pub fn laneOpen(lane: *Document) !void {
- if (c.pardes_pdf_lane_open(lane.handle) != c.PARDES_PDF_OK) return error.OpenFailed;
- }
-
- /// The cookie this document's renders run under until set again: set
- /// its `abort` from any thread and a render stops at its next operator
- /// (`error.Aborted`).
- pub fn setCookie(document: *Document, cookie: ?*Cookie) void {
- c.pardes_pdf_set_cookie(document.handle, cookie);
- }
-
- /// Link annotations are loaded only for the pointed page, separately from
- /// text/raster work. Returned URIs survive cache eviction and page changes.
- pub fn linkAt(document: *Document, gpa: std.mem.Allocator, page: usize, point: Point) !?Link {
- const page_number = try document.checkedPage(page);
- if (!validPoint(point)) return null;
- var raw: c.pardes_pdf_link = std.mem.zeroes(c.pardes_pdf_link);
- if (c.pardes_pdf_link_at(document.handle, page_number, point, &raw) != c.PARDES_PDF_OK)
- return error.LinkFailed;
- if (raw.uri == null or raw.uri_len == 0) return null;
- if (raw.uri_len > c.PARDES_PDF_MAX_LINK_URI_BYTES or !validQuad(raw.quad)) return error.BadLink;
- const borrowed: [*]const u8 = @ptrCast(raw.uri);
- const text = borrowed[0..raw.uri_len];
- if (!std.unicode.utf8ValidateSlice(text) or std.mem.trim(u8, text, " ").len == 0 or
- std.ascii.eqlIgnoreCase(text, "file://")) return null;
- for (text) |byte| if (byte < ' ') return null;
- const uri = try gpa.dupe(u8, text);
- errdefer gpa.free(uri);
- const destination: OutlineDestination = switch (raw.destination_kind) {
- c.PARDES_PDF_OUTLINE_DESTINATION_INTERNAL => blk: {
- if (raw.page < 0 or @as(usize, @intCast(raw.page)) >= document.pages or
- raw.has_x > 1 or raw.has_y > 1 or
- (raw.has_x != 0 and !std.math.isFinite(raw.x)) or
- (raw.has_y != 0 and !std.math.isFinite(raw.y))) return error.BadLink;
- break :blk .{ .internal = .{
- .page = @intCast(raw.page),
- .x = if (raw.has_x != 0) raw.x else null,
- .y = if (raw.has_y != 0) raw.y else null,
- } };
- },
- c.PARDES_PDF_OUTLINE_DESTINATION_EXTERNAL => .{ .external = uri },
- else => return error.BadLink,
- };
- return .{ .page = page, .quad = raw.quad, .uri = uri, .destination = destination };
- }
-
- pub fn copyRectangle(document: *Document, gpa: std.mem.Allocator, page: usize, quad: Quad) ![]u8 {
- const page_number = try document.checkedPage(page);
- if (!validQuad(quad)) return error.InvalidPoint;
- var text: c.pardes_pdf_owned_text = std.mem.zeroes(c.pardes_pdf_owned_text);
- if (c.pardes_pdf_copy_rectangle(document.handle, page_number, quad, &text) != c.PARDES_PDF_OK)
- return error.SelectionFailed;
- defer c.pardes_pdf_drop_owned_text(document.handle, text.handle);
- if (text.len == 0) return &.{};
- if (text.data == null) return error.BadText;
- const source: [*]const u8 = @ptrCast(text.data);
- return gpa.dupe(u8, source[0..text.len]);
- }
-
- /// Load and flatten the PDF-native outline/bookmarks. MuPDF's temporary
- /// tree and the bridge's flat view are both dropped before this returns.
- pub fn outline(
- document: *Document,
- gpa: std.mem.Allocator,
- ) !Outline {
- var raw: c.pardes_pdf_outline_result =
- std.mem.zeroes(c.pardes_pdf_outline_result);
- const status = c.pardes_pdf_load_outline(document.handle, &raw);
- if (status == c.PARDES_PDF_LIMIT_EXCEEDED)
- return error.OutlineLimitExceeded;
- if (status != c.PARDES_PDF_OK)
- return error.OutlineFailed;
- defer c.pardes_pdf_drop_outline_result(document.handle, raw.handle);
-
- if (raw.item_count > c.PARDES_PDF_MAX_OUTLINE_ITEMS or
- raw.bytes_len > c.PARDES_PDF_MAX_OUTLINE_BYTES or
- (raw.item_count != 0 and raw.items == null) or
- (raw.bytes_len != 0 and raw.bytes == null))
- return error.BadOutline;
-
- const bytes = try gpa.alloc(u8, raw.bytes_len);
- errdefer gpa.free(bytes);
- if (raw.bytes_len != 0) {
- const source: [*]const u8 = @ptrCast(raw.bytes);
- @memcpy(bytes, source[0..raw.bytes_len]);
- }
-
- const entries = try gpa.alloc(OutlineEntry, raw.item_count);
- errdefer gpa.free(entries);
- if (raw.item_count != 0) {
- const source: [*]const c.pardes_pdf_outline_item =
- @ptrCast(raw.items);
- var previous_depth: u8 = 0;
- for (entries, source[0..raw.item_count], 0..) |*entry, item, index| {
- if (item.depth >= c.PARDES_PDF_MAX_OUTLINE_DEPTH or
- item.depth > std.math.maxInt(u8) or
- item.title_present > 1 or item.has_x > 1 or
- item.has_y > 1)
- return error.BadOutline;
- const depth: u8 = @intCast(item.depth);
- if ((index == 0 and depth != 0) or
- (index != 0 and depth > previous_depth + 1))
- return error.BadOutline;
- previous_depth = depth;
-
- const title = if (item.title_present != 0) title: {
- const value = try outlineBytes(bytes, item.title_offset, item.title_len);
- if (!std.unicode.utf8ValidateSlice(value))
- return error.BadOutline;
- break :title value;
- } else title: {
- if (item.title_offset != 0 or item.title_len != 0)
- return error.BadOutline;
- break :title null;
- };
-
- const destination: OutlineDestination = switch (item.destination_kind) {
- c.PARDES_PDF_OUTLINE_DESTINATION_NONE => .none,
- c.PARDES_PDF_OUTLINE_DESTINATION_INTERNAL => internal: {
- if (item.page < 0 or
- @as(usize, @intCast(item.page)) >= document.pages or
- (item.has_x != 0 and !std.math.isFinite(item.x)) or
- (item.has_y != 0 and !std.math.isFinite(item.y)))
- return error.BadOutline;
- break :internal .{ .internal = .{
- .page = @intCast(item.page),
- .x = if (item.has_x != 0) item.x else null,
- .y = if (item.has_y != 0) item.y else null,
- } };
- },
- c.PARDES_PDF_OUTLINE_DESTINATION_EXTERNAL => external: {
- const uri = try outlineBytes(bytes, item.uri_offset, item.uri_len);
- if (!std.unicode.utf8ValidateSlice(uri))
- return error.BadOutline;
- break :external .{ .external = uri };
- },
- else => return error.BadOutline,
- };
- entry.* = .{ .depth = depth, .title = title, .destination = destination };
- }
- }
- return .{ .entries = entries, .bytes = bytes };
- }
-
- /// Return crop/rotation-aware page dimensions without allocating pixels.
- pub fn pageSize(document: *Document, page: usize) !PageSize {
- const page_number = try document.checkedPage(page);
- var size: c.pardes_pdf_page_size = std.mem.zeroes(c.pardes_pdf_page_size);
- if (c.pardes_pdf_get_page_size(document.handle, page_number, &size) != c.PARDES_PDF_OK or
- !std.math.isFinite(size.width) or !std.math.isFinite(size.height) or
- size.width <= 0 or size.height <= 0)
- return error.BadPageSize;
- return .{ .width = size.width, .height = size.height };
- }
-
- /// Render one zero-based page whole into allocator-owned packed RGBA,
- /// baking `highlights` in: the tests' and benches' render. The view
- /// renders bands into buffers it owns (`renderIntoAtWithPaper`).
- pub fn render(
- document: *Document,
- gpa: std.mem.Allocator,
- page: usize,
- request: RenderRequest,
- highlights: []const Highlight,
- ) !Render {
- const raster = try document.measureRenderAt(page, request);
- if (raster.len > max_owned_raster_bytes) return error.PixmapTooLarge;
- const rgba = try gpa.alloc(u8, raster.len);
- errdefer gpa.free(rgba);
- try document.renderIntoAtWithPaper(page, request, raster, raster.wholePage(), highlights, rgba, false);
- return .{ .rgba = rgba, .width = raster.width, .height = raster.height };
- }
-
- /// Exactly the raster this request will produce, without producing it.
- /// Split out of the render so a caller holding a retired buffer of the
- /// same length can hand it straight back instead of making the allocator
- /// fetch (and later return) fresh pages for every page it flies past.
- pub fn measureRenderAt(
- document: *Document,
- page: usize,
- request: RenderRequest,
- ) !Raster {
- const bounded = try boundedRequest(document, page, request);
- var raw_layout: c.pardes_pdf_raster_layout = std.mem.zeroes(c.pardes_pdf_raster_layout);
- if (c.pardes_pdf_measure_render(
- document.handle,
- @intCast(page),
- &bounded,
- &raw_layout,
- ) != c.PARDES_PDF_OK) return error.RenderFailed;
- // The page's shape, not an allocation: a page taller than
- // `max_owned_raster_bytes` allows is rendered a band at a time.
- return checkedRasterLayout(raw_layout);
- }
-
- /// Rasterize `band` of a page into `rgba`, which MUST be exactly
- /// `band.len` bytes for a `band` taken from the same `measureRenderAt`
- /// shape and request. On any failure the buffer's contents are unspecified
- /// and it still belongs to the caller. `transparent_paper` preserves the
- /// PDF's content coverage when the host paints paper separately.
- pub fn renderIntoAtWithPaper(
- document: *Document,
- page: usize,
- request: RenderRequest,
- raster: Raster,
- band: Raster.Band,
- highlights: []const Highlight,
- rgba: []u8,
- transparent_paper: bool,
- ) !void {
- if (rgba.len != band.len) return error.BadPixmap;
- if (band.height == 0 or band.y + band.height > raster.height)
- return error.BadPixmap;
- if (band.len > max_owned_raster_bytes) return error.PixmapTooLarge;
- const bounded = try boundedRequest(document, page, request);
- if (highlights.len > c.PARDES_PDF_MAX_RESULT_QUADS) return error.RenderFailed;
- const highlight_ptr: ?[*]const c.pardes_pdf_highlight =
- if (highlights.len == 0) null else @ptrCast(highlights.ptr);
- const status = c.pardes_pdf_render_into(
- document.handle,
- @intCast(page),
- &bounded,
- highlight_ptr,
- highlights.len,
- rgba.ptr,
- rgba.len,
- @intCast(raster.width),
- @intCast(raster.height),
- @intCast(raster.stride),
- @intCast(band.y),
- @intCast(band.height),
- @intFromBool(transparent_paper),
- );
- if (status == c.PARDES_PDF_ABORTED) return error.Aborted;
- if (status != c.PARDES_PDF_OK) return error.RenderFailed;
- }
-
- /// Only the highlight pass of `renderIntoAtWithPaper`, over `rgba`, which
- /// holds `band` of this page as that render left it before highlighting
- /// (opaque paper). Rendering with highlights equals rendering without and
- /// then this, row for row: the render draws highlights over the finished
- /// page, and so does this.
- pub fn paintHighlightsAt(
- document: *Document,
- page: usize,
- request: RenderRequest,
- raster: Raster,
- band: Raster.Band,
- highlights: []const Highlight,
- rgba: []u8,
- ) !void {
- if (rgba.len != band.len) return error.BadPixmap;
- if (band.height == 0 or band.y + band.height > raster.height)
- return error.BadPixmap;
- const bounded = try boundedRequest(document, page, request);
- if (highlights.len > c.PARDES_PDF_MAX_RESULT_QUADS) return error.RenderFailed;
- if (c.pardes_pdf_paint_highlights(
- document.handle,
- @intCast(page),
- &bounded,
- if (highlights.len == 0) null else @ptrCast(highlights.ptr),
- highlights.len,
- rgba.ptr,
- rgba.len,
- @intCast(raster.width),
- @intCast(raster.height),
- @intCast(raster.stride),
- @intCast(band.y),
- @intCast(band.height),
- ) != c.PARDES_PDF_OK) return error.RenderFailed;
- }
-
- pub const Rows = struct { start: usize, end: usize };
-
- /// The rows of `request`'s raster that painting `highlights` can touch,
- /// by the transform the render itself uses (rotation included). Empty
- /// when nothing would paint.
- pub fn highlightRows(
- document: *Document,
- page: usize,
- request: RenderRequest,
- highlights: []const Highlight,
- ) !Rows {
- const bounded = try boundedRequest(document, page, request);
- var row_start: c_int = 0;
- var row_end: c_int = 0;
- if (c.pardes_pdf_highlight_rows(
- document.handle,
- @intCast(page),
- &bounded,
- if (highlights.len == 0) null else @ptrCast(highlights.ptr),
- highlights.len,
- &row_start,
- &row_end,
- ) != c.PARDES_PDF_OK) return error.RenderFailed;
- return .{ .start = @intCast(row_start), .end = @intCast(row_end) };
- }
-
- /// `request` as the bridge takes it, refused when the page or a size is
- /// out of range.
- fn boundedRequest(
- document: *Document,
- page: usize,
- request: RenderRequest,
- ) !c.pardes_pdf_request {
- _ = try document.checkedPage(page);
- if (request.dpi == 0 or request.max_dimension == 0 or
- request.max_dimension > absolute_max_render_dimension)
- return error.InvalidRenderRequest;
- return .{
- .dpi = request.dpi,
- .minimum_width = clampInt(request.minimum_width),
- .minimum_height = clampInt(request.minimum_height),
- .max_dimension = request.max_dimension,
- .display_width = clampInt(request.display_width),
- .display_height = clampInt(request.display_height),
- };
- }
-
- fn clampInt(value: u32) c_int {
- return @intCast(@min(value, @as(u32, @intCast(std.math.maxInt(c_int)))));
- }
-
- /// Plain UTF-8-ish text projection for one zero-based page. MuPDF owns the
- /// temporary buffer; callers receive an allocator-owned copy.
- pub fn pageText(document: *Document, gpa: std.mem.Allocator, page: usize) ![]u8 {
- const page_number = try document.checkedPage(page);
- var text: c.pardes_pdf_text = std.mem.zeroes(c.pardes_pdf_text);
- if (c.pardes_pdf_page_text(document.handle, page_number, &text) != 0)
- return error.TextFailed;
- defer c.pardes_pdf_drop_text(document.handle, text.handle);
- if (text.len == 0) return gpa.dupe(u8, "");
- if (text.data == null) return error.BadText;
- const bytes: [*]const u8 = @ptrCast(text.data);
- return gpa.dupe(u8, bytes[0..text.len]);
- }
-
- /// Case-insensitive single-page search. MuPDF's iterative search owns a
- /// retained reference to the cached structured-text page while running;
- /// this wrapper copies every borrowed oriented quad before dropping it.
- /// The C bridge doubles capacity up to 65,536 aggregate quads and returns
- /// TooManyResults atomically rather than silently truncating beyond it.
- pub fn search(
- document: *Document,
- gpa: std.mem.Allocator,
- page: usize,
- needle: []const u8,
- ) !SearchResults {
- const page_number = try document.checkedPage(page);
- if (std.mem.indexOfScalar(u8, needle, 0) != null)
- return error.InvalidNeedle;
- const needle_z = try gpa.dupeSentinel(u8, needle, 0);
- defer gpa.free(needle_z);
-
- var found: c.pardes_pdf_search_result =
- std.mem.zeroes(c.pardes_pdf_search_result);
- const status = c.pardes_pdf_search_page(document.handle, page_number, needle_z.ptr, &found);
- if (status == c.PARDES_PDF_LIMIT_EXCEEDED)
- return error.TooManyResults;
- if (status != c.PARDES_PDF_OK)
- return error.SearchFailed;
- defer c.pardes_pdf_drop_search_result(document.handle, found.handle);
-
- if (found.quad_count != 0 and found.quads == null)
- return error.BadGeometry;
- const quads = try gpa.alloc(SearchQuad, found.quad_count);
- errdefer gpa.free(quads);
- if (found.quad_count != 0) {
- const source: [*]const c.pardes_pdf_search_quad = @ptrCast(found.quads);
- for (quads, source[0..found.quad_count]) |*dest, item| {
- if (item.hit >= found.hit_count or !validQuad(item.quad))
- return error.BadGeometry;
- dest.* = .{ .quad = item.quad, .hit = item.hit };
- }
- }
- return .{ .quads = quads, .hit_count = found.hit_count };
- }
-
- /// Word-snap two normalized page points and return allocator-owned,
- /// orientation-preserving highlight geometry.
- pub fn select(
- document: *Document,
- gpa: std.mem.Allocator,
- page: usize,
- selection_start: Point,
- selection_end: Point,
- ) !Selection {
- const page_number = try document.checkedPage(page);
- if (!validPoint(selection_start) or !validPoint(selection_end))
- return error.InvalidPoint;
-
- var selected: c.pardes_pdf_selection =
- std.mem.zeroes(c.pardes_pdf_selection);
- const status = c.pardes_pdf_select(
- document.handle,
- page_number,
- selection_start,
- selection_end,
- &selected,
- );
- if (status == c.PARDES_PDF_LIMIT_EXCEEDED)
- return error.TooManyResults;
- if (status != c.PARDES_PDF_OK)
- return error.SelectionFailed;
- defer c.pardes_pdf_drop_selection(document.handle, selected.handle);
-
- if (selected.quad_count != 0 and selected.quads == null)
- return error.BadGeometry;
- if (!validPoint(selected.start) or !validPoint(selected.end))
- return error.BadGeometry;
- const quads = try gpa.alloc(Quad, selected.quad_count);
- errdefer gpa.free(quads);
- if (selected.quad_count != 0) {
- const source: [*]const Quad = @ptrCast(selected.quads);
- for (quads, source[0..selected.quad_count]) |*dest, item| {
- if (!validQuad(item)) return error.BadGeometry;
- dest.* = item;
- }
- }
- return .{
- .quads = quads,
- .start = selected.start,
- .end = selected.end,
- };
- }
-
- /// Copy UTF-8 text between normalized page points. For word selection,
- /// pass the snapped endpoints returned by `select`. MuPDF's temporary
- /// fz_malloc string is always freed after making the allocator-owned copy.
- pub fn copySelection(
- document: *Document,
- gpa: std.mem.Allocator,
- page: usize,
- selection_start: Point,
- selection_end: Point,
- ) ![]u8 {
- const page_number = try document.checkedPage(page);
- if (!validPoint(selection_start) or !validPoint(selection_end))
- return error.InvalidPoint;
-
- var text: c.pardes_pdf_owned_text =
- std.mem.zeroes(c.pardes_pdf_owned_text);
- if (c.pardes_pdf_copy_selection(
- document.handle,
- page_number,
- selection_start,
- selection_end,
- &text,
- ) != c.PARDES_PDF_OK) return error.TextFailed;
- defer c.pardes_pdf_drop_owned_text(document.handle, text.handle);
- if (text.len == 0) return gpa.dupe(u8, "");
- if (text.data == null) return error.BadText;
- const bytes: [*]const u8 = @ptrCast(text.data);
- return gpa.dupe(u8, bytes[0..text.len]);
- }
-
- fn checkedPage(document: *const Document, page: usize) !c_int {
- if (page >= document.pages or page > std.math.maxInt(c_int))
- return error.PageOutOfRange;
- return @intCast(page);
- }
-};
-
-fn outlineBytes(bytes: []const u8, offset: usize, len: usize) ![]const u8 {
- if (offset > bytes.len or len > bytes.len - offset)
- return error.BadOutline;
- return bytes[offset .. offset + len];
-}
-
-fn validPoint(point: Point) bool {
- return std.math.isFinite(point.x) and std.math.isFinite(point.y) and
- point.x >= 0 and point.x <= 1 and point.y >= 0 and point.y <= 1;
-}
-
-fn validQuad(quad: Quad) bool {
- return validPoint(quad.ul) and validPoint(quad.ur) and
- validPoint(quad.ll) and validPoint(quad.lr);
-}
-
-/// The exact shape of the raster a render request produces. `len` is the
-/// packed RGBA byte count a FULL-page `renderIntoAtWithPaper` demands, so a caller can
-/// match a retired buffer against it before deciding to allocate.
-pub const Raster = struct {
- width: usize,
- height: usize,
- stride: usize,
- len: usize,
-
- /// The rows a reader can actually see are usually a fraction of a page:
- /// flinging through a manual, a page is on screen for one frame showing a
- /// couple of hundred of its twelve hundred rows. `Band` is that fraction,
- /// and rendering one is the same rendering clipped — see the bridge's
- /// comment and the test that proves the rows are identical.
- pub const Band = struct {
- y: usize,
- height: usize,
- /// bytes of a `y`/`height` band at this raster's stride
- len: usize,
- };
-
- /// The whole page as a band, which is what a reader at rest gets.
- pub fn wholePage(raster: Raster) Band {
- return .{ .y = 0, .height = raster.height, .len = raster.len };
- }
-
- /// Clamp a wanted row range to the page and return it as a band. A range
- /// that misses the page entirely comes back as its nearest single row
- /// rather than as an error: the caller is describing a viewport, and a
- /// viewport that has just left a page is not a malformed request.
- pub fn band(raster: Raster, first_row: usize, rows: usize) Band {
- const y = @min(first_row, raster.height - 1);
- const height = @min(@max(rows, 1), raster.height - y);
- return .{ .y = y, .height = height, .len = raster.stride * height };
- }
-};
-
-fn checkedRasterLayout(raw: c.pardes_pdf_raster_layout) !Raster {
- if (raw.width < 1 or raw.height < 1 or raw.stride < 1)
- return error.BadPixmap;
- const width: usize = @intCast(raw.width);
- const height: usize = @intCast(raw.height);
- const stride: usize = @intCast(raw.stride);
- const expected_stride = std.math.mul(usize, width, 4) catch
- return error.BadPixmap;
- if (stride != expected_stride) return error.BadPixmap;
- const len = std.math.mul(usize, stride, height) catch
- return error.BadPixmap;
- if (raw.samples_len != len) return error.BadPixmap;
- return .{ .width = width, .height = height, .stride = stride, .len = len };
-}
-
-fn expectOpaque(rgba: []const u8) !void {
- if (rgba.len % 4 != 0) return error.BadPixmap;
- var alpha: usize = 3;
- while (alpha < rgba.len) : (alpha += 4)
- try std.testing.expectEqual(@as(u8, 0xff), rgba[alpha]);
-}
-
-/// TEST-ONLY: a PDF file read whole and opened from memory, as the view
-/// opens one.
-fn openTestFile(path: []const u8) !Document {
- const bytes = try std.Io.Dir.cwd().readFileAlloc(std.testing.io, path, std.testing.allocator, .unlimited);
- defer std.testing.allocator.free(bytes);
- return Document.openBytes(bytes);
-}
-
-/// TEST-ONLY (here and in the core's tests, which run in the repository's
-/// root): one of test/pdf-fixtures' PDFs, whole. `outline.pdf`, an outline
-/// of every kind (a branch with neither title nor destination over a UTF-16
-/// child, an empty title, an external link); `offset-rotated.pdf`, one page
-/// with an offset CropBox and /Rotate 90 and no outline; `links.pdf`,
-/// external, internal, same-URI and link-only annotations; `tall.pdf`, one
-/// `tall_test_page` labelled every 100 pt; `rotated-link*.pdf`, a link on
-/// the rotated page by URI, empty URI, JavaScript, a missing destination.
-pub fn testFixture(gpa: std.mem.Allocator, comptime name: []const u8) ![]u8 {
- return std.Io.Dir.cwd().readFileAlloc(std.testing.io, "test/pdf-fixtures/" ++ name, gpa, .unlimited);
-}
-
-fn allocateGeneratedPdf(
- gpa: std.mem.Allocator,
- offsets: []usize,
- context: anytype,
- comptime emit: anytype,
-) ![]u8 {
- @memset(offsets, 0);
- var bytes: std.Io.Writer.Allocating = .init(gpa);
- defer bytes.deinit();
- try emit(&bytes.writer, offsets, context);
- return bytes.toOwnedSlice();
-}
-
-fn beginPdfObject(bytes: *std.Io.Writer, offsets: []usize, number: usize) !void {
- offsets[number] = bytes.end;
- try bytes.print("{d} 0 obj\n", .{number});
-}
-
-fn finishGeneratedPdf(bytes: *std.Io.Writer, offsets: []const usize) !void {
- const xref = bytes.end;
- try bytes.print("xref\n0 {d}\n0000000000 65535 f \n", .{offsets.len});
- for (offsets[1..]) |offset|
- try bytes.print("{d:0>10} 00000 n \n", .{offset});
- try bytes.print(
- "trailer\n<< /Size {d} /Root 1 0 R >>\nstartxref\n{d}\n%%EOF\n",
- .{ offsets.len, xref },
- );
-}
-
-/// The tall test page: 600 x 9000 pt, fifteen A4 pages' height on one.
-pub const tall_test_page: PageSize = .{ .width = 600, .height = 9000 };
-
-test "a tall page rasterizes at the size it is shown, however many max_dimensions tall" {
- var document = try openTestFile("test/pdf-fixtures/tall.pdf");
- defer document.deinit();
- const size = try document.pageSize(0);
- try std.testing.expectEqual(tall_test_page.width, size.width);
- try std.testing.expectEqual(tall_test_page.height, size.height);
-
- // Shown 960 px wide (fit width): 960 px a row, 14400 rows, though that is
- // far past max_dimension. The old clamp of the longest side made this
- // 273 x 4096, drawn 3.5 times too large.
- const shown: RenderRequest = .{ .dpi = 192, .minimum_width = 960, .minimum_height = 600, .max_dimension = 4096, .display_width = 960 };
- const tall = try document.measureRenderAt(0, shown);
- try std.testing.expectEqual(@as(usize, 960), tall.width);
- try std.testing.expectEqual(@as(usize, 14400), tall.height);
- // Kitty's 96 dpi, as any page has it, not 1200 rows' worth.
- const kitty = try document.measureRenderAt(0, .{ .dpi = 96, .max_dimension = 1200, .display_width = 944 });
- try std.testing.expectEqual(@as(usize, 800), kitty.width);
- try std.testing.expectEqual(@as(usize, 12000), kitty.height);
- // The dpi never takes it past what is shown: that would be bands of
- // pixels nobody sees.
- const small = try document.measureRenderAt(0, .{ .dpi = 192, .max_dimension = 4096, .display_width = 300 });
- try std.testing.expectEqual(@as(usize, 300), small.width);
- // Shown whole (fit height), the height cap holds: the page is 600 px
- // tall on screen and 4096 rows is already more.
- const whole = try document.measureRenderAt(0, .{ .dpi = 192, .minimum_width = 960, .minimum_height = 600, .max_dimension = 4096, .display_height = 600 });
- try std.testing.expectEqual(@as(usize, 4096), whole.height);
- // Without a display size, the old budget.
- const blind = try document.measureRenderAt(0, .{ .dpi = 192, .minimum_width = 960, .max_dimension = 4096 });
- try std.testing.expectEqual(@as(usize, 4096), blind.height);
- // A row is never longer than max_dimension, whatever is shown.
- const wide = try document.measureRenderAt(0, .{ .dpi = 192, .minimum_width = 10_000, .max_dimension = 4096, .display_width = 10_000 });
- try std.testing.expectEqual(@as(usize, 4096), wide.width);
- // One buffer is bounded even when the page is not: a whole render of a
- // page past it is refused, a band of it is not.
- const poster: RenderRequest = .{ .dpi = 72, .minimum_width = 4096, .max_dimension = 4096, .display_width = 4096 };
- const huge = try document.measureRenderAt(0, poster);
- try std.testing.expect(huge.len > max_owned_raster_bytes);
- try std.testing.expectError(error.PixmapTooLarge, document.render(std.testing.allocator, 0, poster, &.{}));
- const band = huge.band(huge.height - 100, 100);
- const rows = try std.testing.allocator.alloc(u8, band.len);
- defer std.testing.allocator.free(rows);
- try document.renderIntoAtWithPaper(0, poster, huge, band, &.{}, rows, false);
- try expectOpaque(rows);
-}
-
-test "PDF links own URIs across page eviction and preserve internal coordinates" {
- const gpa = std.testing.allocator;
- start(gpa);
- defer stop();
- var document = try openTestFile("test/pdf-fixtures/links.pdf");
- defer document.deinit();
- var external = (try document.linkAt(gpa, 0, .{ .x = 0.3, .y = 0.18 })) orelse return error.NoLink;
- defer external.deinit(gpa);
- try std.testing.expectEqualStrings("https://example.com/embedded", external.uri);
- try std.testing.expectEqualStrings(external.uri, external.destination.external);
- try std.testing.expectApproxEqAbs(@as(f32, 0.1), external.quad.ul.x, 0.0001);
- try std.testing.expectApproxEqAbs(@as(f32, 40.0 / 300.0), external.quad.ul.y, 0.0001);
- try std.testing.expectApproxEqAbs(@as(f32, 0.6), external.quad.lr.x, 0.0001);
- const label = try document.copyRectangle(gpa, 0, external.quad);
- defer gpa.free(label);
- try std.testing.expectEqualStrings("target.txt", std.mem.trim(u8, label, "\r\n "));
- var internal = (try document.linkAt(gpa, 0, .{ .x = 0.3, .y = 0.38 })) orelse return error.NoLink;
- defer internal.deinit(gpa);
- try std.testing.expectEqual(@as(usize, 1), internal.destination.internal.page);
- try std.testing.expectApproxEqAbs(@as(f32, 12), internal.destination.internal.x.?, 0.001);
- try std.testing.expectApproxEqAbs(@as(f32, 266), internal.destination.internal.y.?, 0.001);
- const blank = try document.copyRectangle(gpa, 0, internal.quad);
- defer gpa.free(blank);
- try std.testing.expectEqualStrings("", blank);
- try std.testing.expect(try document.linkAt(gpa, 1, .{ .x = 0.3, .y = 0.18 }) == null);
- try std.testing.expectEqualStrings("https://example.com/embedded", external.uri);
- var again = (try document.linkAt(gpa, 0, .{ .x = 0.3, .y = 0.18 })) orelse return error.NoLink;
- defer again.deinit(gpa);
- try std.testing.expectEqualStrings(external.uri, again.uri);
- var failing = std.testing.FailingAllocator.init(gpa, .{ .fail_index = 0 });
- try std.testing.expectError(error.OutOfMemory, document.linkAt(failing.allocator(), 0, .{ .x = 0.3, .y = 0.18 }));
- try std.testing.expectError(error.PageOutOfRange, document.linkAt(gpa, 2, .{ .x = 0.3, .y = 0.18 }));
- for ([_]Point{ .{ .x = -0.1, .y = 0.18 }, .{ .x = 0.3, .y = 1.1 }, .{ .x = std.math.nan(f32), .y = 0.18 } }) |point|
- try std.testing.expect(try document.linkAt(gpa, 0, point) == null);
- try std.testing.expect(try document.linkAt(gpa, 0, .{ .x = 0.99, .y = 0.99 }) == null);
-}
-
-test "PDF links normalize cropped rotated annotations and ignore unsupported actions" {
- const gpa = std.testing.allocator;
- start(gpa);
- defer stop();
- // The page's link's action: a URI, an empty URI, JavaScript, a
- // destination that is not there.
- const fixtures = [_][]const u8{ "rotated-link.pdf", "rotated-link-empty-uri.pdf", "rotated-link-javascript.pdf", "rotated-link-missing-dest.pdf" };
- for (fixtures, 0..) |name, index| {
- var path: [64]u8 = undefined;
- var document = try openTestFile(try std.fmt.bufPrint(&path, "test/pdf-fixtures/{s}", .{name}));
- defer document.deinit();
- var found = try document.linkAt(gpa, 0, .{ .x = 0.1, .y = 0.1 });
- defer if (found) |*item| item.deinit(gpa);
- if (index != 0) {
- try std.testing.expect(found == null);
- continue;
- }
- const link = found orelse return error.NoRotatedLink;
- try std.testing.expectApproxEqAbs(@as(f32, 0), link.quad.ul.x, 0.0001);
- try std.testing.expectApproxEqAbs(@as(f32, 0), link.quad.ul.y, 0.0001);
- try std.testing.expectApproxEqAbs(@as(f32, 50.0 / 150.0), link.quad.lr.x, 0.0001);
- try std.testing.expectApproxEqAbs(@as(f32, 40.0 / 160.0), link.quad.lr.y, 0.0001);
- try std.testing.expect(try document.linkAt(gpa, 0, .{ .x = 0.7, .y = 0.7 }) == null);
- }
-}
-
-fn emitTooDeepOutlinePdf(bytes: *std.Io.Writer, offsets: []usize, levels: usize) !void {
- const first_outline_item = 5;
- try bytes.writeAll("%PDF-1.7\n%\xE2\xE3\xCF\xD3\n");
- try beginPdfObject(bytes, offsets, 1);
- try bytes.writeAll("<< /Type /Catalog /Pages 2 0 R /Outlines 4 0 R >>\nendobj\n");
- try beginPdfObject(bytes, offsets, 2);
- try bytes.writeAll("<< /Type /Pages /Count 1 /Kids [3 0 R] >>\nendobj\n");
- try beginPdfObject(bytes, offsets, 3);
- try bytes.writeAll("<< /Type /Page /Parent 2 0 R /MediaBox [0 0 100 100] /Resources << >> >>\nendobj\n");
- try beginPdfObject(bytes, offsets, 4);
- try bytes.print("<< /Type /Outlines /First 5 0 R /Last 5 0 R /Count {d} >>\nendobj\n", .{levels});
-
- for (0..levels) |level| {
- const number = first_outline_item + level;
- try beginPdfObject(bytes, offsets, number);
- try bytes.print("<< /Title (Level {d}) /Parent {d} 0 R", .{
- level,
- if (level == 0) 4 else number - 1,
- });
- if (level + 1 < levels) {
- try bytes.print(" /First {d} 0 R /Last {d} 0 R /Count {d}", .{
- number + 1,
- number + 1,
- levels - level - 1,
- });
- }
- try bytes.writeAll(" >>\nendobj\n");
- }
- try finishGeneratedPdf(bytes, offsets);
-}
-
-fn makeTooDeepOutlinePdf(gpa: std.mem.Allocator) ![]u8 {
- const levels: usize = c.PARDES_PDF_MAX_OUTLINE_DEPTH + 1;
- const object_count = 5 + levels;
- const offsets = try gpa.alloc(usize, object_count);
- defer gpa.free(offsets);
- return allocateGeneratedPdf(gpa, offsets, levels, emitTooDeepOutlinePdf);
-}
-
-fn emitWideOutlinePdf(bytes: *std.Io.Writer, offsets: []usize, items: usize) !void {
- const first_outline_item = 5;
- try bytes.writeAll("%PDF-1.7\n%\xE2\xE3\xCF\xD3\n");
- try beginPdfObject(bytes, offsets, 1);
- try bytes.writeAll("<< /Type /Catalog /Pages 2 0 R /Outlines 4 0 R >>\nendobj\n");
- try beginPdfObject(bytes, offsets, 2);
- try bytes.writeAll("<< /Type /Pages /Count 1 /Kids [3 0 R] >>\nendobj\n");
- try beginPdfObject(bytes, offsets, 3);
- try bytes.writeAll("<< /Type /Page /Parent 2 0 R /MediaBox [0 0 100 100] /Resources << >> >>\nendobj\n");
- try beginPdfObject(bytes, offsets, 4);
- try bytes.print("<< /Type /Outlines /First 5 0 R /Last {d} 0 R /Count {d} >>\nendobj\n", .{
- first_outline_item + items - 1,
- items,
- });
-
- for (0..items) |ordinal| {
- const number = first_outline_item + ordinal;
- try beginPdfObject(bytes, offsets, number);
- try bytes.print("<< /Title (Section {d}) /Parent 4 0 R /Dest [3 0 R /Fit]", .{ordinal});
- if (ordinal != 0)
- try bytes.print(" /Prev {d} 0 R", .{number - 1});
- if (ordinal + 1 < items)
- try bytes.print(" /Next {d} 0 R", .{number + 1});
- try bytes.writeAll(" >>\nendobj\n");
- }
- try finishGeneratedPdf(bytes, offsets);
-}
-
-fn makeWideOutlinePdf(gpa: std.mem.Allocator, items: usize) ![]u8 {
- if (items == 0) return error.EmptyOutlineFixture;
- const object_count = try std.math.add(usize, 5, items);
- const offsets = try gpa.alloc(usize, object_count);
- defer gpa.free(offsets);
- return allocateGeneratedPdf(gpa, offsets, items, emitWideOutlinePdf);
-}
-
-test "PDF outline is a stable owned DFS view with native destinations" {
- var document = try openTestFile("test/pdf-fixtures/outline.pdf");
- defer document.deinit();
- try std.testing.expectEqual(@as(usize, 3), document.pages);
- for (0..2) |fail_index| {
- var failing = std.testing.FailingAllocator.init(std.testing.allocator, .{
- .fail_index = fail_index,
- });
- try std.testing.expectError(
- error.OutOfMemory,
- document.outline(failing.allocator()),
- );
- }
- for (0..2) |_| {
- var outline = try document.outline(std.testing.allocator);
- defer outline.deinit(std.testing.allocator);
- try std.testing.expectEqual(@as(usize, 4), outline.entries.len);
- try std.testing.expectEqualSlices(u8, &.{ 0, 1, 0, 0 }, &.{
- outline.entries[0].depth,
- outline.entries[1].depth,
- outline.entries[2].depth,
- outline.entries[3].depth,
- });
-
- try std.testing.expect(outline.entries[0].title == null);
- try std.testing.expect(outline.entries[0].destination == .none);
- try std.testing.expectEqualStrings("Café 子", outline.entries[1].title.?);
- const child = outline.entries[1].destination.internal;
- try std.testing.expectEqual(@as(usize, 1), child.page);
- try std.testing.expect(child.x != null and child.y != null);
- try std.testing.expectApproxEqAbs(@as(f32, 12), child.x.?, 0.01);
-
- try std.testing.expectEqualStrings("", outline.entries[2].title.?);
- const fitted = outline.entries[2].destination.internal;
- try std.testing.expectEqual(@as(usize, 2), fitted.page);
- try std.testing.expect(fitted.x == null);
- try std.testing.expect(fitted.y != null);
-
- try std.testing.expectEqualStrings("External", outline.entries[3].title.?);
- try std.testing.expectEqualStrings(
- "https://example.com/manual",
- outline.entries[3].destination.external,
- );
- }
-}
-
-test "PDF outline accepts manual-sized trees and rejects item overflow atomically" {
- const manual_items = 4105;
- try std.testing.expect(max_outline_items >= manual_items);
-
- const manual_fixture = try makeWideOutlinePdf(std.testing.allocator, manual_items);
- defer std.testing.allocator.free(manual_fixture);
- var manual_document = try Document.openBytes(manual_fixture);
- defer manual_document.deinit();
- var outline = try manual_document.outline(std.testing.allocator);
- defer outline.deinit(std.testing.allocator);
- try std.testing.expectEqual(@as(usize, manual_items), outline.entries.len);
- try std.testing.expectEqualStrings("Section 0", outline.entries[0].title.?);
- try std.testing.expectEqualStrings("Section 4104", outline.entries[manual_items - 1].title.?);
- try std.testing.expectEqual(@as(usize, 0), outline.entries[manual_items - 1].destination.internal.page);
-
- const overflow_fixture = try makeWideOutlinePdf(std.testing.allocator, max_outline_items + 1);
- defer std.testing.allocator.free(overflow_fixture);
- var overflow_document = try Document.openBytes(overflow_fixture);
- defer overflow_document.deinit();
- var raw: c.pardes_pdf_outline_result = undefined;
- @memset(std.mem.asBytes(&raw), 0xa5);
- try std.testing.expectEqual(
- c.PARDES_PDF_LIMIT_EXCEEDED,
- c.pardes_pdf_load_outline(overflow_document.handle, &raw),
- );
- try std.testing.expect(raw.handle == null);
- try std.testing.expect(raw.items == null);
- try std.testing.expectEqual(@as(usize, 0), raw.item_count);
- try std.testing.expect(raw.bytes == null);
- try std.testing.expectEqual(@as(usize, 0), raw.bytes_len);
-}
-
-test "PDF outline absence and hostile depth are atomic and repeatable" {
- var plain_document = try openTestFile("test/pdf-fixtures/offset-rotated.pdf");
- defer plain_document.deinit();
- var absent = try plain_document.outline(std.testing.allocator);
- defer absent.deinit(std.testing.allocator);
- try std.testing.expectEqual(@as(usize, 0), absent.entries.len);
- try std.testing.expectEqual(@as(usize, 0), absent.bytes.len);
-
- const deep_fixture = try makeTooDeepOutlinePdf(std.testing.allocator);
- defer std.testing.allocator.free(deep_fixture);
- var deep_document = try Document.openBytes(deep_fixture);
- defer deep_document.deinit();
- var raw: c.pardes_pdf_outline_result = undefined;
- @memset(std.mem.asBytes(&raw), 0xa5);
- try std.testing.expectEqual(
- c.PARDES_PDF_LIMIT_EXCEEDED,
- c.pardes_pdf_load_outline(deep_document.handle, &raw),
- );
- try std.testing.expect(raw.handle == null);
- try std.testing.expect(raw.items == null);
- try std.testing.expectEqual(@as(usize, 0), raw.item_count);
- try std.testing.expect(raw.bytes == null);
- try std.testing.expectEqual(@as(usize, 0), raw.bytes_len);
- for (0..2) |_|
- try std.testing.expectError(
- error.OutlineLimitExceeded,
- deep_document.outline(std.testing.allocator),
- );
- const size = try deep_document.pageSize(0);
- try std.testing.expectEqual(@as(f32, 100), size.width);
- try std.testing.expectEqual(@as(f32, 100), size.height);
-}
-
-test "caller-owned RGBA layout is packed and overflow checked" {
- const layout = try checkedRasterLayout(.{
- .width = 2,
- .height = 3,
- .stride = 8,
- .samples_len = 24,
- });
- try std.testing.expectEqual(@as(usize, 2), layout.width);
- try std.testing.expectEqual(@as(usize, 3), layout.height);
- try std.testing.expectEqual(@as(usize, 8), layout.stride);
- try std.testing.expectEqual(@as(usize, 24), layout.len);
- try std.testing.expectError(error.BadPixmap, checkedRasterLayout(.{
- .width = 2,
- .height = 3,
- .stride = 7,
- .samples_len = 21,
- }));
-}
-
-test "RGBA allocation and buffer-validation failures leave the document renderable" {
- var document = try openTestFile("docs/design.pdf");
- defer document.deinit();
-
- var failing = std.testing.FailingAllocator.init(std.testing.allocator, .{
- .fail_index = 0,
- });
- try std.testing.expectError(
- error.OutOfMemory,
- document.render(failing.allocator(), 0, .{}, &.{}),
- );
-
- const request = try document.boundedRequest(0, .{});
- var raw_layout: c.pardes_pdf_raster_layout = std.mem.zeroes(c.pardes_pdf_raster_layout);
- try std.testing.expectEqual(c.PARDES_PDF_OK, c.pardes_pdf_measure_render(document.handle, 0, &request, &raw_layout));
- const layout = try checkedRasterLayout(raw_layout);
- {
- const scratch = try std.testing.allocator.alloc(u8, layout.len);
- defer std.testing.allocator.free(scratch);
- @memset(scratch, 0xa5);
- try std.testing.expectEqual(c.PARDES_PDF_ERROR, c.pardes_pdf_render_into(
- document.handle,
- 0,
- &request,
- null,
- 0,
- scratch.ptr,
- scratch.len - 1,
- raw_layout.width,
- raw_layout.height,
- raw_layout.stride,
- 0,
- raw_layout.height,
- 0,
- ));
- for (scratch) |byte|
- try std.testing.expectEqual(@as(u8, 0xa5), byte);
- }
-
- const after = try document.render(std.testing.allocator, 0, .{}, &.{});
- defer std.testing.allocator.free(after.rgba);
- const repeated = try document.render(std.testing.allocator, 0, .{}, &.{});
- defer std.testing.allocator.free(repeated.rgba);
- try std.testing.expectEqualSlices(u8, after.rgba, repeated.rgba);
- try expectOpaque(after.rgba);
- try expectOpaque(repeated.rgba);
-}
-
-test "a band's rows are the full page's rows, and highlights land in them" {
- // THE claim the fast-scroll path rests on: rendering rows [y, y+h) of a
- // page is the same rendering, clipped — not a different one. If MuPDF ever
- // let the pixmap's bbox change antialiasing, hinting or subpixel placement,
- // a fling would show pixels a reader could tell apart from a rested view,
- // and this test is what refuses to let that happen quietly.
- var document = try openTestFile("docs/design.pdf");
- defer document.deinit();
-
- const request: RenderRequest = .{ .dpi = 96, .max_dimension = 1200 };
- const raster = try document.measureRenderAt(0, request);
- const whole = try std.testing.allocator.alloc(u8, raster.len);
- defer std.testing.allocator.free(whole);
- try document.renderIntoAtWithPaper(0, request, raster, raster.wholePage(), &.{}, whole, false);
-
- // Odd offsets and an odd height on purpose: a band that starts on a row
- // MuPDF would never choose itself is exactly where an off-by-one in the
- // bbox arithmetic would show up.
- const cases = [_]struct { y: usize, h: usize }{
- .{ .y = 0, .h = 1 },
- .{ .y = 1, .h = 37 },
- .{ .y = raster.height / 3, .h = 101 },
- .{ .y = raster.height / 2, .h = raster.height / 2 },
- .{ .y = raster.height - 1, .h = 1 },
- };
- for (cases) |case| {
- const band = raster.band(case.y, case.h);
- const rows = try std.testing.allocator.alloc(u8, band.len);
- defer std.testing.allocator.free(rows);
- try document.renderIntoAtWithPaper(0, request, raster, band, &.{}, rows, false);
- const from = band.y * raster.stride;
- try std.testing.expectEqualSlices(u8, whole[from..][0..band.len], rows);
- try expectOpaque(rows);
- }
-
- // A baked highlight is drawn under the same CTM, so it has to land on the
- // same rows through a band as it does through a whole page.
- const highlights = [_]Highlight{.{
- .quad = .{
- .ul = .{ .x = 0.1, .y = 0.4 },
- .ur = .{ .x = 0.9, .y = 0.4 },
- .ll = .{ .x = 0.1, .y = 0.6 },
- .lr = .{ .x = 0.9, .y = 0.6 },
- },
- .kind = .search,
- .rgba = .{ 0x30, 0x80, 0xf0, 0x80 },
- }};
- const marked_whole = try std.testing.allocator.alloc(u8, raster.len);
- defer std.testing.allocator.free(marked_whole);
- try document.renderIntoAtWithPaper(0, request, raster, raster.wholePage(), &highlights, marked_whole, false);
- const marked_band = raster.band(raster.height / 3, raster.height / 3);
- const marked_rows = try std.testing.allocator.alloc(u8, marked_band.len);
- defer std.testing.allocator.free(marked_rows);
- try document.renderIntoAtWithPaper(0, request, raster, marked_band, &highlights, marked_rows, false);
- const marked_from = marked_band.y * raster.stride;
- try std.testing.expectEqualSlices(
- u8,
- marked_whole[marked_from..][0..marked_band.len],
- marked_rows,
- );
- // ...and the highlight really is in the band that was compared, or the
- // comparison above would be two identical plain renders agreeing.
- try std.testing.expect(!std.mem.eql(
- u8,
- whole[marked_from..][0..marked_band.len],
- marked_rows,
- ));
-
- // A band request that misses the page is a viewport that has left it, not
- // a malformed call: it clamps instead of failing.
- const past_end = raster.band(raster.height + 500, 64);
- try std.testing.expect(past_end.y < raster.height);
- try std.testing.expectEqual(@as(usize, 1), past_end.height);
-}
-
-test "MuPDF search returns normalized oriented quads and word selection text" {
- var document = try openTestFile("docs/design.pdf");
- defer document.deinit();
-
- const projected = try document.pageText(std.testing.allocator, 0);
- defer std.testing.allocator.free(projected);
- try std.testing.expect(std.ascii.findIgnoreCase(projected, "Pardes") != null);
- // Exercise transactional cache replacement before searching page zero
- // again; a failed ownership handoff here tends to surface as a double drop.
- if (document.pages > 1) {
- const other_page = try document.pageText(std.testing.allocator, 1);
- std.testing.allocator.free(other_page);
- }
-
- var found = try document.search(std.testing.allocator, 0, "Pardes");
- defer found.deinit(std.testing.allocator);
- try std.testing.expect(found.hit_count > 0);
- try std.testing.expect(found.quads.len > 0);
- for (found.quads) |item| {
- try std.testing.expect(item.hit < found.hit_count);
- try std.testing.expect(validQuad(item.quad));
- }
-
- const first = found.quads[0].quad;
- var selected = try document.select(std.testing.allocator, 0, first.ul, first.lr);
- defer selected.deinit(std.testing.allocator);
- try std.testing.expect(selected.quads.len > 0);
- try std.testing.expect(validPoint(selected.start));
- try std.testing.expect(validPoint(selected.end));
-
- const text = try document.copySelection(std.testing.allocator, 0, selected.start, selected.end);
- defer std.testing.allocator.free(text);
- try std.testing.expect(std.ascii.findIgnoreCase(text, "Pardes") != null);
-}
-
-test "highlighted render changes pixels while plain render stays stable" {
- var document = try openTestFile("docs/design.pdf");
- defer document.deinit();
-
- const plain_before = try document.render(std.testing.allocator, 0, .{}, &.{});
- defer std.testing.allocator.free(plain_before.rgba);
- const whole_page = Quad{
- .ul = .{ .x = 0, .y = 0 },
- .ur = .{ .x = 1, .y = 0 },
- .ll = .{ .x = 0, .y = 1 },
- .lr = .{ .x = 1, .y = 1 },
- };
- const highlights = [_]Highlight{
- Highlight.init(whole_page, .{ 255, 0, 0, 128 }, .custom),
- };
- const marked = try document.render(std.testing.allocator, 0, .{}, &highlights);
- defer std.testing.allocator.free(marked.rgba);
- const plain_after = try document.render(std.testing.allocator, 0, .{}, &.{});
- defer std.testing.allocator.free(plain_after.rgba);
-
- try expectOpaque(plain_before.rgba);
- try expectOpaque(marked.rgba);
- try expectOpaque(plain_after.rgba);
- try std.testing.expectEqual(plain_before.width, marked.width);
- try std.testing.expectEqual(plain_before.height, marked.height);
- try std.testing.expect(!std.mem.eql(u8, plain_before.rgba, marked.rgba));
- try std.testing.expectEqualSlices(u8, plain_before.rgba, plain_after.rgba);
-}
-
-test "offset crop and rotation keep normalized highlights pixel-aligned" {
- var document = try openTestFile("test/pdf-fixtures/offset-rotated.pdf");
- defer document.deinit();
- const plain = try document.render(std.testing.allocator, 0, .{}, &.{});
- defer std.testing.allocator.free(plain.rgba);
- // CropBox is 160x150 points and /Rotate 90 swaps its displayed axes.
- try std.testing.expectEqual(@as(usize, 300), plain.width);
- try std.testing.expectEqual(@as(usize, 320), plain.height);
-
- // The SIZE comes off the page object rather than a loaded page (see
- // pardes_pdf_get_page_size), and this is the fixture that would catch it
- // being a different answer: an offset CropBox plus /Rotate 90, where a
- // MediaBox reading, an untransformed cropbox or a missed rotation all give
- // plausible-looking wrong numbers. The rendered raster above is what
- // fz_bound_page produces, so the strip's layout has to agree with it.
- const size = try document.pageSize(0);
- try std.testing.expectEqual(@as(f32, 150), size.width);
- try std.testing.expectEqual(@as(f32, 160), size.height);
- try std.testing.expectApproxEqAbs(
- @as(f32, @floatFromInt(plain.width)) / @as(f32, @floatFromInt(plain.height)),
- size.width / size.height,
- 0.001,
- );
-
- const kitty = try document.render(std.testing.allocator, 0, .{
- .dpi = 96,
- .max_dimension = 1200,
- }, &.{});
- defer std.testing.allocator.free(kitty.rgba);
- try std.testing.expect(kitty.width < plain.width);
- try std.testing.expect(kitty.height < plain.height);
-
- const sdl = try document.render(std.testing.allocator, 0, .{
- .dpi = 192,
- .minimum_width = 640,
- .minimum_height = 480,
- .max_dimension = 4096,
- }, &.{});
- defer std.testing.allocator.free(sdl.rgba);
- try std.testing.expect(sdl.width >= 640);
- try std.testing.expect(sdl.height >= 480);
- try std.testing.expect(sdl.width * sdl.height >= kitty.width * kitty.height * 4);
-
- const capped = try document.render(std.testing.allocator, 0, .{
- .dpi = 192,
- .minimum_width = 4096,
- .minimum_height = 4096,
- .max_dimension = 512,
- }, &.{});
- defer std.testing.allocator.free(capped.rgba);
- try std.testing.expectEqual(@as(usize, 512), @max(capped.width, capped.height));
-
- const left_half = Quad{
- .ul = .{ .x = 0, .y = 0 },
- .ur = .{ .x = 0.5, .y = 0 },
- .ll = .{ .x = 0, .y = 1 },
- .lr = .{ .x = 0.5, .y = 1 },
- };
- const highlights = [_]Highlight{
- Highlight.init(left_half, .{ 0, 0, 255, 255 }, .custom),
- };
- const marked = try document.render(std.testing.allocator, 0, .{}, &highlights);
- defer std.testing.allocator.free(marked.rgba);
- try std.testing.expectEqual(plain.width, marked.width);
- try std.testing.expectEqual(plain.height, marked.height);
-
- const left = (plain.height / 2 * plain.width + plain.width / 4) * 4;
- const right = (plain.height / 2 * plain.width + plain.width * 3 / 4) * 4;
- try std.testing.expect(plain.rgba[left] > 240 and
- plain.rgba[left + 1] < 10 and plain.rgba[left + 2] < 10);
- try std.testing.expect(marked.rgba[left] < 10 and
- marked.rgba[left + 1] < 10 and marked.rgba[left + 2] > 240);
- try std.testing.expectEqualSlices(u8, plain.rgba[right .. right + 4], marked.rgba[right .. right + 4]);
-}
-
-test "transparent PDF paper preserves ink and band coverage" {
- var document = try openTestFile("docs/9p.pdf");
- defer document.deinit();
- const request: RenderRequest = .{ .dpi = 96, .max_dimension = 1200 };
- const raster = try document.measureRenderAt(0, request);
- const flattened = try std.testing.allocator.alloc(u8, raster.len);
- defer std.testing.allocator.free(flattened);
- const content = try std.testing.allocator.alloc(u8, raster.len);
- defer std.testing.allocator.free(content);
- try document.renderIntoAtWithPaper(0, request, raster, raster.wholePage(), &.{}, flattened, false);
- try document.renderIntoAtWithPaper(0, request, raster, raster.wholePage(), &.{}, content, true);
- var paper: usize = 0;
- var ink: usize = 0;
- var edges: usize = 0;
- for (std.mem.bytesAsSlice([4]u8, content), std.mem.bytesAsSlice([4]u8, flattened)) |pixel, reference| {
- const a: u32 = pixel[3];
- paper += @intFromBool(a == 0);
- ink += @intFromBool(a == 255);
- edges += @intFromBool(a > 0 and a < 255);
- for (0..3) |channel| {
- const over_white = (a * pixel[channel] + (255 - a) * 255 + 127) / 255;
- try std.testing.expect(@abs(@as(i32, @intCast(over_white)) - @as(i32, reference[channel])) <= 2);
- }
- }
- try std.testing.expect(paper > 100 and ink > 100 and edges > 100);
- const band = raster.band(raster.height / 3, raster.height / 4);
- const rows = try std.testing.allocator.alloc(u8, band.len);
- defer std.testing.allocator.free(rows);
- try document.renderIntoAtWithPaper(0, request, raster, band, &.{}, rows, true);
- try std.testing.expectEqualSlices(u8, content[band.y * raster.stride ..][0..band.len], rows);
-}
diff --git a/src/pdf_view.zig b/src/pdf_view.zig
deleted file mode 100644
index 93390b57..00000000
--- a/src/pdf_view.zig
+++ /dev/null
@@ -1,3721 +0,0 @@
-//! A PDF pane: the MuPDF document it views, page rasters and their placement,
-//! scrolling, search, pointer selection, and the sections outline.
-const panes = @import("panes.zig");
-const std = @import("std");
-const pardes = @import("pardes.zig");
-const exec = @import("exec.zig");
-const layout = @import("layout.zig");
-const config = @import("config.zig");
-const modal = @import("modal.zig");
-const filesystem = @import("fs.zig");
-const tracy = @import("tracy.zig");
-const surface = @import("surface.zig");
-const look = @import("look.zig");
-const tagline = @import("tagline.zig");
-const File = panes.File;
-const Output = panes.Output;
-
-pub const enabled = @import("pardes_config").mupdf;
-pub const pdf = if (enabled) @import("mupdf") else struct {
- pub const PageSize = struct { width: f32, height: f32 };
- pub const Raster = struct {
- width: usize = 0,
- height: usize = 0,
- stride: usize = 0,
- len: usize = 0,
- pub const Band = struct { y: usize = 0, height: usize = 0, len: usize = 0 };
- pub fn wholePage(_: @This()) Band {
- return .{};
- }
- pub fn band(_: @This(), _: usize, _: usize) Band {
- return .{};
- }
- };
-};
-pub const Point = if (enabled) pdf.Point else void;
-pub const Quad = if (enabled) pdf.Quad else void;
-pub const Document = if (enabled) pdf.Document else opaque {};
-pub const OutlineInternalDestination = if (enabled) pdf.OutlineInternalDestination else void;
-const raster_max = 256;
-const raster_spare = 4;
-pub const page_gap_px: u32 = 8;
-const band_grain: usize = 64;
-/// The tallest raster one buffer carries: within every GPU's texture size
-/// and Kitty's 10000-pixel image limit (kitty and ghostty both). A page
-/// taller than this, or than `pdf.max_owned_raster_bytes` allows, is BANDED:
-/// it is held as the rows around what is on screen and rendered in chunks.
-const max_band_rows: usize = 8192;
-/// A banded page is rendered in chunks of this many rows, each from its own
-/// render of the chunk and `chunk_overlap` rows of the page beyond both of
-/// its edges, which are thrown away. A row of the page therefore always comes
-/// from the same render, however the reader scrolled to it, and never from
-/// the edge of one: MuPDF's rows at the edge of a clip can differ from the
-/// same rows rendered whole (see `pardes_pdf_render_into`), which, butted
-/// against the next chunk, would be a seam.
-const chunk_rows: usize = 512;
-const chunk_overlap: usize = 32;
-
-pub const FitMode = if (enabled) enum { width, height } else void;
-pub const TintMode = if (enabled) pdf.TintMode else void;
-pub const TintColors = if (enabled) pdf.TintColors else void;
-pub const RenderRequest = if (enabled) pdf.RenderRequest else void;
-
-pub const RasterPolicy = struct {
- dpi: u16,
- max_dimension: u16,
- match_viewport: bool,
-};
-
-pub const TintKey = if (enabled) struct {
- mode: TintMode,
- colors: pdf.TintColors,
-
- pub fn eql(a: @This(), b: @This()) bool {
- return a.mode == b.mode and
- (a.mode == .disabled or std.meta.eql(a.colors, b.colors));
- }
-} else void;
-
-pub const Highlight = if (enabled) pdf.Highlight else void;
-pub const Highlights = if (enabled) struct {
- const Page = struct { page: usize, items: []const Highlight };
- pub const replica = .{ .len = .{.{ "pages", "len" }} };
- pages: [3]Page = undefined,
- len: usize = 0,
- /// Repaint whenever the set changes, not only when a page's raster was
- /// invalidated (`HighlightInput.live`).
- live: bool = false,
-
- pub fn forPage(highlights: @This(), page: usize) []const Highlight {
- for (highlights.pages[0..highlights.len]) |group|
- if (group.page == page) return group.items;
- return &.{};
- }
-} else void;
-
-pub const HighlightInput = if (enabled) struct {
- hover_quads: []const Quad = &.{},
- hover_page: ?usize = null,
- hover_color: [3]u8,
- selection_color: [3]u8,
- live: bool = false,
-} else void;
-
-pub fn buildHighlights(
- state: *const State,
- arena: std.mem.Allocator,
- input: HighlightInput,
-) !Highlights {
- if (comptime !enabled) return;
- const search_len = if (state.search_results) |results| results.quads.len else 0;
- const selection_len = if (state.selection) |selection| selection.quads.len else 0;
- const items = try arena.alloc(Highlight, input.hover_quads.len + search_len + selection_len);
- var result: Highlights = .{ .live = input.live };
- var n: usize = 0;
- // Hover, search and selection can belong to three different pages.
- // Group them once so raster rendering can borrow a contiguous slice.
- for ([_]?usize{ input.hover_page, state.page, state.selection_page }) |candidate| {
- const page = candidate orelse continue;
- var seen = false;
- for (result.pages[0..result.len]) |group| {
- if (group.page == page) seen = true;
- }
- if (seen) continue;
- const start = n;
- if (input.hover_page == page) for (input.hover_quads) |quad| {
- items[n] = pdf.Highlight.init(quad, .{
- input.hover_color[0], input.hover_color[1], input.hover_color[2], 0x2c,
- }, .custom);
- n += 1;
- };
- if (state.page == page) if (state.search_results) |results| {
- for (results.quads) |item| {
- items[n] = pdf.Highlight.init(item.quad, .{ 0xff, 0xd5, 0x4f, 0x70 }, .search);
- n += 1;
- }
- };
- if (state.selection_page == page) if (state.selection) |selection| {
- for (selection.quads) |quad| {
- items[n] = pdf.Highlight.init(quad, .{
- input.selection_color[0], input.selection_color[1], input.selection_color[2], 0x78,
- }, .selection);
- n += 1;
- }
- };
- result.pages[result.len] = .{ .page = page, .items = items[start..n] };
- result.len += 1;
- }
- return result;
-}
-
-test "PDF selections retain their owning page across page focus" {
- if (comptime !enabled) return;
- const gpa = std.testing.allocator;
- var state = try State.open(gpa, "docs/design.pdf", 1);
- defer state.deinit(gpa);
- try std.testing.expect(state.page_count > 1);
- var found = try state.document.search(gpa, 0, "Pardes");
- defer found.deinit(gpa);
- const quad = found.quads[0].quad;
- const point: Point = .{
- .x = (quad.ul.x + quad.ur.x + quad.ll.x + quad.lr.x) / 4,
- .y = (quad.ul.y + quad.ur.y + quad.ll.y + quad.lr.y) / 4,
- };
- try std.testing.expectEqual(.changed, state.setSelection(gpa, point, point, true));
- const selected = try gpa.dupe(u8, state.selection_text);
- defer gpa.free(selected);
- try std.testing.expect(selected.len > 0);
- try std.testing.expect(state.focusLocation(gpa, 2, 0));
- try std.testing.expectEqual(@as(?usize, 0), state.selection_page);
- try std.testing.expectEqualStrings(selected, state.selection_text);
- var arena = std.heap.ArenaAllocator.init(gpa);
- defer arena.deinit();
- const highlights = try buildHighlights(&state, arena.allocator(), .{
- .hover_quads = &.{quad},
- .hover_page = 1,
- .hover_color = .{ 1, 2, 3 },
- .selection_color = .{ 4, 5, 6 },
- });
- try std.testing.expectEqual(state.selection.?.quads.len, highlights.forPage(0).len);
- try std.testing.expectEqual(@as(usize, 1), highlights.forPage(1).len);
- try std.testing.expectEqual(@as(usize, 0), highlights.forPage(2).len);
- try std.testing.expect(state.focusLocation(gpa, 1, 0));
- try std.testing.expectEqualStrings(selected, state.selection_text);
- try std.testing.expectEqual(.unchanged, state.setSelection(gpa, point, point, true));
- try std.testing.expect(state.focusLocation(gpa, 2, 0));
- state.rasters[0] = .{ .valid = true, .page = 0, .tried = true, .decorated = true };
- state.rasters_len = 1;
- try std.testing.expectEqual(.changed, state.setSelection(gpa, point, point, false));
- try std.testing.expectEqual(@as(?usize, 1), state.selection_page);
- try std.testing.expect(!state.rasters[0].tried);
- state.clearSelection(gpa);
- try std.testing.expect(state.selection_page == null);
- try std.testing.expectEqual(@as(usize, 0), state.selection_text.len);
-}
-
-test "off the loop: pages land from lanes, a stale request's raster never lands, and a job nobody waits for is aborted" {
- if (comptime !enabled) return;
- const gpa = std.testing.allocator;
- workers = std.testing.io;
- defer workers = null;
- defer dropKept();
- var state = try State.open(gpa, "docs/design.pdf", 1);
- defer state.deinit(gpa);
- var arena: std.heap.ArenaAllocator = .init(gpa);
- defer arena.deinit();
- const key: TintKey = .{ .mode = .disabled, .colors = undefined };
- const none: HighlightInput = .{ .hover_color = .{ 0, 0, 0 }, .selection_color = .{ 0, 0, 0 } };
- const policy = pardes.pdf_raster_policy;
- const Run = struct {
- /// Frames until every lane is idle; no slot ever holds a raster of
- /// the `stale` request.
- fn settle(st: *State, a: *std.heap.ArenaAllocator, v: Viewport, k: TintKey, h: HighlightInput, stale: ?RenderRequest) !void {
- var frames: usize = 0;
- while (true) : (frames += 1) {
- _ = renderFrame(st, std.testing.allocator, a.allocator(), v, pardes.pdf_raster_policy, k, h, 0, false);
- if (stale) |old| for (st.rasters[0..st.rasters_len]) |r| if (r.rgba.len > 0 and r.request_valid)
- try std.testing.expect(!r.request.eql(old));
- if (!rendering(st)) break;
- try std.testing.expect(frames < 100_000);
- std.Thread.yield() catch {};
- }
- }
- };
- const small: Viewport = .{ .pixel_w = 400, .pixel_h = 300 };
- ensureLayout(&state, small);
- // The first frame asks; nothing has landed, so the loop drew nothing.
- _ = renderFrame(&state, gpa, arena.allocator(), small, policy, key, none, 0, false);
- try std.testing.expect(rendering(&state));
- try std.testing.expect(!pageReady(&state, small, 0));
- try Run.settle(&state, &arena, small, key, none, null);
- try std.testing.expect(pageReady(&state, small, 0));
- // The page past the view was rendered ahead.
- const shown = visiblePages(&state, small);
- try std.testing.expect(rasterForPage(&state, shown.first + shown.len) != null);
- // A new request while the old one's jobs are out, many times over:
- // only the newest request's rasters are ever in a slot.
- var round: u32 = 0;
- while (round < 8) : (round += 1) {
- const v: Viewport = .{ .pixel_w = 300 + 37 * round, .pixel_h = 300 };
- ensureLayout(&state, v);
- _ = renderFrame(&state, gpa, arena.allocator(), v, policy, key, none, 0, false);
- const next: Viewport = .{ .pixel_w = 301 + 37 * round, .pixel_h = 300 };
- ensureLayout(&state, next);
- try Run.settle(&state, &arena, next, key, none, renderRequest(v, policy, state.fit));
- try std.testing.expect(pageReady(&state, next, state.page));
- try std.testing.expect(rasterForPage(&state, state.page).?.request.eql(renderRequest(next, policy, state.fit)));
- }
- // A job whose page left the strip is aborted through its cookie, and an
- // aborted job is not a failure: the page is asked again when it returns.
- state.invalidateAllRasters();
- const last: Viewport = .{ .pixel_w = 301 + 37 * 7, .pixel_h = 300 };
- _ = renderFrame(&state, gpa, arena.allocator(), last, policy, key, none, 0, false);
- state.document_scroll_y = @floatFromInt(state.page_starts[state.page_count - 1]);
- _ = renderFrame(&state, gpa, arena.allocator(), last, policy, key, none, 0, false);
- for (state.lanes) |lane| if (lane.job) |job| if (job.page < state.page_count - 2)
- try std.testing.expectEqual(@as(c_int, 1), @atomicLoad(c_int, &job.cookie.abort, .acquire));
- try Run.settle(&state, &arena, last, key, none, null);
- for (state.rasters[0..state.rasters_len]) |r| try std.testing.expect(!r.failed);
-}
-
-test "page sizes off the loop: the strip opens on the first page's size, and when a lane's sizes land it keeps its page and offset" {
- if (comptime !enabled) return;
- const gpa = std.testing.allocator;
- var exact = try State.open(gpa, "docs/design.pdf", 1);
- defer exact.deinit(gpa);
- workers = std.testing.io;
- defer workers = null;
- defer dropKept();
- var state = try State.open(gpa, "docs/design.pdf", 1);
- defer state.deinit(gpa);
- try std.testing.expect(state.sizes_pending);
- for (state.page_sizes) |size| try std.testing.expectEqual(exact.page_sizes[0], size);
- var arena: std.heap.ArenaAllocator = .init(gpa);
- defer arena.deinit();
- const view: Viewport = .{ .pixel_w = 400, .pixel_h = 300 };
- // Assumed wrong (half as tall) so that the landing lays out again.
- for (state.page_sizes) |*size| size.height /= 2;
- ensureLayout(&state, view);
- state.document_scroll_y = @as(f64, @floatFromInt(state.page_starts[2])) + 0.25 * @as(f64, @floatFromInt(state.page_heights[2]));
- state.drawn_y = state.document_scroll_y;
- const none: HighlightInput = .{ .hover_color = .{ 0, 0, 0 }, .selection_color = .{ 0, 0, 0 } };
- const key: TintKey = .{ .mode = .disabled, .colors = undefined };
- var frames: usize = 0;
- while (state.sizes_pending) : (frames += 1) {
- _ = renderFrame(&state, gpa, arena.allocator(), view, pardes.pdf_raster_policy, key, none, 0, false);
- try std.testing.expect(frames < 100_000);
- std.Thread.yield() catch {};
- }
- applySizes(&state, gpa);
- ensureLayout(&state, view);
- try std.testing.expect(std.mem.eql(u8, std.mem.sliceAsBytes(exact.page_sizes), std.mem.sliceAsBytes(state.page_sizes)));
- try std.testing.expectEqual(@as(usize, 2), pageAtOffset(&state, state.document_scroll_y));
- const offset = (state.document_scroll_y - @as(f64, @floatFromInt(state.page_starts[2]))) / @as(f64, @floatFromInt(state.page_heights[2]));
- try std.testing.expectApproxEqAbs(@as(f64, 0.25), offset, 1e-9);
- // The strip moved with its place: no kick, the motion carries on.
- try std.testing.expectEqual(state.document_scroll_y, state.drawn_y);
- try Wait.idle(&state, &arena, view);
-}
-
-test "kept pages: a second open shows the page it left, bounded in bytes, the oldest going first" {
- if (comptime !enabled) return;
- const gpa = std.testing.allocator;
- workers = std.testing.io;
- defer workers = null;
- defer dropKept();
- const key: TintKey = .{ .mode = .disabled, .colors = undefined };
- const request: RenderRequest = .{};
- // Five pages of 20 MiB kept: only what fits in the bound stays, newest.
- {
- var state = try State.open(gpa, "docs/design.pdf", 1);
- defer state.deinit(gpa);
- for (0..5) |page| {
- state.rasters[page] = .{ .valid = true, .page = page, .rgba = try gpa.alloc(u8, 20 << 20), .iw = 1, .ih = 1, .band_h = 1, .request = request, .request_valid = true, .tint_key = key };
- state.rasters_len += 1;
- }
- }
- var total: usize = 0;
- var pages: [5]bool = @splat(false);
- for (kept) |k| if (k) |e| {
- total += e.rgba.len;
- pages[e.page] = true;
- };
- try std.testing.expect(total <= kept_limit);
- try std.testing.expect(pages[4] and !pages[0]);
- // Opened again: page 4 is there before any render.
- var again = try State.open(gpa, "docs/design.pdf", 1);
- defer again.deinit(gpa);
- again.rasters[0] = .{ .valid = true, .page = 4 };
- again.rasters_len = 1;
- try std.testing.expect(unkeep(&again, &again.rasters[0], request, key));
- try std.testing.expectEqual(@as(usize, 20 << 20), again.rasters[0].rgba.len);
- for (kept) |k| if (k) |e| try std.testing.expect(e.page != 4);
-}
-
-/// TEST-ONLY: frames until every lane is idle.
-const Wait = struct {
- fn idle(st: *State, a: *std.heap.ArenaAllocator, v: Viewport) !void {
- const none: HighlightInput = .{ .hover_color = .{ 0, 0, 0 }, .selection_color = .{ 0, 0, 0 } };
- const key: TintKey = .{ .mode = .disabled, .colors = undefined };
- var frames: usize = 0;
- while (rendering(st)) : (frames += 1) {
- _ = renderFrame(st, std.testing.allocator, a.allocator(), v, pardes.pdf_raster_policy, key, none, 0, false);
- try std.testing.expect(frames < 100_000);
- std.Thread.yield() catch {};
- }
- }
-};
-
-pub const Raster = if (enabled) struct {
- valid: bool = false,
- page: usize = 0,
- rgba: []u8 = &.{},
- /// Full page shape; rgba contains only the band below.
- iw: usize = 0,
- ih: usize = 0,
- band_y: usize = 0,
- band_h: usize = 0,
- request: pdf.RenderRequest = .{},
- request_valid: bool = false,
- tried: bool = false,
- decorated: bool = false,
- tint_key: ?TintKey = null,
- revision: u32 = 0,
- /// `rgba` before its highlights and tint, kept once the page has been
- /// highlighted: a highlight change repaints rows from it instead of
- /// rendering the page again.
- clean: []u8 = &.{},
- /// The highlights baked into `rgba` (gpa-owned), so a change repaints
- /// only the rows of the quads that differ.
- baked: []Highlight = &.{},
- /// `baked` is a true record (false after a render could not copy it).
- baked_valid: bool = false,
- /// Page rows changed since revision `patch_from`, the one last handed
- /// to a shell; 0 when the pixels were replaced wholesale since.
- patch_from: u32 = 0,
- patch_rows: pdf.Document.Rows = .{ .start = 0, .end = 0 },
- /// The render job this slot waits for (its generation; 0: none). Only
- /// that job's raster lands here: an older one, or one for a slot since
- /// retired, is dropped when it comes (`land`).
- pending: u32 = 0,
- /// The last job for `request` failed (not aborted): not asked again
- /// until the raster is invalidated or the request changes.
- failed: bool = false,
- /// A lane found the page too tall for one buffer: it is rendered on the
- /// loop, in chunks, as before.
- banded: bool = false,
-} else void;
-
-/// Where page renders run off the loop: set by a shell that has threads
-/// (gui, tty) to its Io. Null (tests, benches, hosts without threads): the
-/// loop renders as it always did.
-pub var workers: ?std.Io = null;
-
-/// Two lanes: the page in view and the next one, or the two a strip shows
-/// at once; a page asked for while both are out waits a frame.
-/// ponytail: two lanes, fixed; more only if a profile shows pages queuing
-/// behind a slow one (a third costs another parse of the document).
-const lane_count = 2;
-
-/// One page render, run on a lane's thread: what the loop asked for, and
-/// what the lane leaves for `land` (rgba and clean are gpa-owned, handed
-/// over). The lane's thread touches only this and the lane's document.
-const Job = if (enabled) struct {
- /// A page's raster, or every page's size (`submitSizes`).
- kind: enum { render, sizes } = .render,
- /// The sizes pass's answer, gpa-owned.
- sizes: []pdf.PageSize = &.{},
- gen: u32,
- page: usize,
- request: RenderRequest,
- /// Measured by the lane.
- shape: pdf.Raster = .{ .width = 0, .height = 0, .stride = 0, .len = 0 },
- /// Too tall for one buffer: the loop renders it in bands (`slot.banded`).
- banded: bool = false,
- tint_key: TintKey,
- /// The highlights baked in (gpa-owned): the slot's `baked` once it lands.
- highlights: []Highlight,
- keep_clean: bool,
- /// A spare of the page's size, or empty: the lane allocates it.
- rgba: []u8,
- clean: []u8 = &.{},
- ok: bool = false,
- /// Set from the loop when nothing waits for this page any more.
- cookie: pdf.Cookie = std.mem.zeroes(pdf.Cookie),
- done: std.atomic.Value(bool) = .init(false),
-} else void;
-
-/// Pages kept past their pane: a second open of the same file, a Restore
-/// (the old core's panes close, the new one's open), shows them on its
-/// first frame instead of waiting for a lane. Only with workers (a test's
-/// State leaves nothing behind). Bound: `kept_limit` bytes and
-/// `kept.len` pages, the least recently kept evicted first.
-/// ponytail: the file is known by its path, length and a hash of its first
-/// and last 64 KiB (a PDF's trailer and xref are at its end); a change
-/// that keeps all three shows the old page until it is next rendered.
-const Kept = if (enabled) struct {
- file: u64,
- page: usize,
- request: RenderRequest,
- tint_key: TintKey,
- rgba: []u8,
- iw: usize,
- ih: usize,
- gpa: std.mem.Allocator,
- age: u64,
-} else void;
-const kept_limit: usize = 64 << 20;
-var kept: [16]?Kept = @splat(null);
-var kept_age: u64 = 0;
-
-fn fileKey(path: []const u8, bytes: []const u8) u64 {
- var h: std.hash.Wyhash = .init(bytes.len);
- h.update(path);
- h.update(bytes[0..@min(bytes.len, 64 << 10)]);
- h.update(bytes[bytes.len -| (64 << 10)..]);
- return h.final();
-}
-
-/// A slot's page as it stands (whole, unhighlighted) into the kept pages,
-/// its buffer handed over; the oldest go until it fits.
-fn keepPage(state: *State, gpa: std.mem.Allocator, slot: *Raster) void {
- if (workers == null or slot.rgba.len == 0 or slot.baked.len != 0 or !slot.request_valid or
- slot.tint_key == null or slot.band_y != 0 or slot.band_h != slot.ih or slot.rgba.len > kept_limit) return;
- kept_age += 1;
- for (&kept) |*k| if (k.*) |e| if (e.file == state.file and e.page == slot.page) {
- e.gpa.free(e.rgba);
- k.* = null;
- };
- while (true) {
- var total: usize = slot.rgba.len;
- var oldest: ?*?Kept = null;
- var free: ?*?Kept = null;
- for (&kept) |*k| if (k.*) |e| {
- total += e.rgba.len;
- if (oldest == null or e.age < oldest.?.*.?.age) oldest = k;
- } else if (free == null) {
- free = k;
- };
- if (total <= kept_limit) if (free) |f| {
- f.* = .{ .file = state.file, .page = slot.page, .request = slot.request, .tint_key = slot.tint_key.?, .rgba = slot.rgba, .iw = slot.iw, .ih = slot.ih, .gpa = gpa, .age = kept_age };
- slot.rgba = &.{};
- return;
- };
- const o = oldest.?;
- o.*.?.gpa.free(o.*.?.rgba);
- o.* = null;
- }
-}
-
-/// The kept page for this file, page, request and tint, into `slot`.
-fn unkeep(state: *State, slot: *Raster, request: RenderRequest, tint_key: TintKey) bool {
- for (&kept) |*k| if (k.*) |e| if (e.file == state.file and e.page == slot.page and e.request.eql(request) and e.tint_key.eql(tint_key)) {
- k.* = null;
- slot.rgba = e.rgba;
- slot.iw = e.iw;
- slot.ih = e.ih;
- slot.band_y = 0;
- slot.band_h = e.ih;
- slot.request = request;
- slot.request_valid = true;
- slot.tint_key = tint_key;
- slot.tried = true;
- slot.baked_valid = true;
- state.next_raster_revision +%= 1;
- if (state.next_raster_revision == 0) state.next_raster_revision = 1;
- slot.revision = state.next_raster_revision;
- state.landed +|= 1;
- return true;
- };
- return false;
-}
-
-/// Every kept page freed: a shell's end, before its allocators' leak check.
-pub fn dropKept() void {
- if (comptime !enabled) return;
- for (&kept) |*k| if (k.*) |e| {
- e.gpa.free(e.rgba);
- k.* = null;
- };
-}
-
-const Lane = if (enabled) struct {
- /// The lane's cloned context and its own document (`Document.laneClone`):
- /// made on the loop at its first job, opened by its first job, used by
- /// one job at a time, closed with the State.
- doc: ?Document = null,
- job: ?*Job = null,
- future: ?std.Io.Future(void) = null,
- io: std.Io = undefined,
- /// Its document is open and its fonts loaded by a job (`collect`).
- warm: bool = false,
-} else void;
-
-pub const SectionsOutput = if (enabled) struct {
- pane: usize,
- serial: u32,
- revision: u32,
-} else void;
-
-pub const SelectionUpdate = enum { failed, stationary, unchanged, changed };
-
-pub const State = if (enabled) struct {
- /// What the replay digest leaves out (src/walk.zig): the pages' pixels,
- /// rendered from the document, and the lanes rendering them.
- pub const replica = .{ .derived = .{ "rasters", "rasters_len" }, .local = .{"lanes"} };
- path: []u8,
- document: Document,
- page: usize = 0,
- page_count: usize,
- page_sizes: []pdf.PageSize,
- page_starts: []u64,
- page_heights: []u32,
- document_height: u64 = 0,
- layout_viewport_w: u32 = 0,
- layout_viewport_h: u32 = 0,
- layout_fit: FitMode = .width,
- layout_valid: bool = false,
- document_scroll_y: f64 = 0,
- /// Where the core stood at the last frame (`drawn_y`), and what moved
- /// it since by the pixel (`direct_y`: a touchpad, a relayout).
- drawn_y: f64 = 0,
- direct_y: f64 = 0,
- /// The last kick was a jump past a body (renderFrame's `far`).
- far: bool = false,
- scroll_to_page_pending: bool = true,
- rasters: [raster_max]Raster = undefined,
- rasters_len: usize = 0,
- /// Rasters installed since the last draw (the probe's `landed`).
- landed: u16 = 0,
- lanes: [lane_count]Lane = @splat(.{}),
- render_gen: u32 = 0,
- /// The paper a page shows until its raster lands, tinted (`draw`).
- blank: [4]u8 = .{ 255, 255, 255, 255 },
- /// Which way the strip last went: the page past it is rendered ahead.
- ahead: i2 = 1,
- /// `page_sizes` past the first are assumed (the first's) until a
- /// lane's pass lands, generation `sizes_gen` (0: not asked yet).
- sizes_pending: bool = false,
- sizes_gen: u32 = 0,
- /// The pass's sizes, landed, for the next draw (gpa-owned).
- sizes_ready: []pdf.PageSize = &.{},
- /// The next relayout keeps the strip's motion (a retarget, not a
- /// reset): the sizes landed under it, nothing the user did.
- relayout_keeps_motion: bool = false,
- /// Which file this is, for the kept pages (`fileKey`).
- file: u64 = 0,
- spare: [raster_spare][]u8 = @splat(&.{}),
- spare_len: usize = 0,
- layout_anchor_pending: bool = false,
- layout_anchor_page: usize = 0,
- layout_anchor_fraction: f64 = 0,
- next_raster_revision: u32 = 0,
- scroll_travel: f64 = 0,
- fit: FitMode = .width,
- tint: TintMode = .filtered,
- pan_x: u16 = 0,
- pan_y: u16 = 0,
- highlights_dirty: bool = false,
- search_reveal_pending: bool = false,
- search_results: ?pdf.SearchResults = null,
- selection: ?pdf.Selection = null,
- selection_page: ?usize = null,
- selection_text: []u8 = &.{},
- selection_anchor: ?Point = null,
- selection_head: ?Point = null,
- drag_anchor: ?Point = null,
- drag_head: ?Point = null,
- text: []u8 = &.{},
- text_tried: bool = false,
- text_scroll: usize = 0,
- text_scroll_clamp_pending: bool = false,
- search_query: []u8 = &.{},
- search_hit: usize = 0,
- reveal_viewport_w: u32 = 0,
- reveal_viewport_h: u32 = 0,
- reveal_fit: FitMode = .width,
- reveal_viewport_valid: bool = false,
- outline: ?pdf.Outline = null,
- outline_tried: bool = false,
- sections_output: ?SectionsOutput = null,
- outline_reveal_pending: ?pdf.OutlineInternalDestination = null,
-
- /// Read whole and opened from memory (the bridge copies), never from
- /// the file itself: MuPDF reads a file lazily at every page, and the
- /// path may be a mount this editor serves, which only a read that
- /// gives the turn up can come back from (`filesystem.readFile`).
- pub fn open(gpa: std.mem.Allocator, path: []const u8, page_one_based: usize) !@This() {
- const local = filesystem.localPath(path) orelse return error.NonLocalPath;
- const bytes = try filesystem.readFile(gpa, local);
- defer gpa.free(bytes);
- return openBytes(gpa, path, bytes, page_one_based);
- }
-
- pub fn openBytes(gpa: std.mem.Allocator, path: []const u8, bytes: []const u8, page_one_based: usize) !@This() {
- var state = try initDocument(gpa, path, try Document.openBytes(bytes), page_one_based);
- state.file = fileKey(path, bytes);
- return state;
- }
-
- fn initDocument(gpa: std.mem.Allocator, path: []const u8, opened: Document, page_one_based: usize) !@This() {
- var document = opened;
- errdefer document.deinit();
- const page_sizes = try gpa.alloc(pdf.PageSize, document.pages);
- errdefer gpa.free(page_sizes);
- // With lanes, only the first page is measured here and the strip
- // is laid out as if every page had its size, until a lane's pass
- // over the rest lands (`submitSizes`): 5363 pages of the SDM took
- // the open 700 ms in Debug, 26 in ReleaseSafe, on the loop.
- const assumed = workers != null and document.pages > 1;
- if (assumed) {
- @memset(page_sizes, try document.pageSize(0));
- } else for (page_sizes, 0..) |*size, page| size.* = try document.pageSize(page);
- const page_starts = try gpa.alloc(u64, document.pages);
- errdefer gpa.free(page_starts);
- const page_heights = try gpa.alloc(u32, document.pages);
- errdefer gpa.free(page_heights);
- const owned_path = try gpa.dupe(u8, path);
- errdefer gpa.free(owned_path);
- return .{
- .path = owned_path,
- .document = document,
- .sizes_pending = assumed,
- .page = if (page_one_based > 0)
- @min(page_one_based - 1, document.pages - 1)
- else
- 0,
- .page_count = document.pages,
- .page_sizes = page_sizes,
- .page_starts = page_starts,
- .page_heights = page_heights,
- };
- }
-
- pub fn reload(state: *@This(), gpa: std.mem.Allocator) !void {
- const preserve_anchor = !state.scroll_to_page_pending and
- (state.layout_anchor_pending or
- (state.layout_valid and state.page_count > 0 and state.document_height > 0));
- var anchor_page: usize = state.layout_anchor_page;
- var anchor_fraction: f64 = state.layout_anchor_fraction;
- if (preserve_anchor and !state.layout_anchor_pending) {
- anchor_page = pageAtOffset(state, state.document_scroll_y);
- const start: f64 = @floatFromInt(state.page_starts[anchor_page]);
- const height: f64 = @floatFromInt(@max(@as(u32, 1), state.page_heights[anchor_page]));
- anchor_fraction = std.math.clamp(
- (state.document_scroll_y - start) / height,
- 0,
- 1,
- );
- }
-
- var fresh = try @This().open(gpa, state.path, state.page + 1);
- errdefer fresh.deinit(gpa);
- if (state.search_query.len > 0)
- fresh.search_query = try gpa.dupe(u8, state.search_query);
-
- fresh.fit = state.fit;
- fresh.tint = state.tint;
- fresh.pan_x = state.pan_x;
- fresh.pan_y = state.pan_y;
- fresh.text_scroll = state.text_scroll;
- fresh.text_scroll_clamp_pending = true;
- fresh.search_hit = state.search_hit;
- fresh.highlights_dirty = fresh.search_query.len > 0;
- fresh.search_reveal_pending = state.search_reveal_pending;
- fresh.reveal_viewport_w = state.reveal_viewport_w;
- fresh.reveal_viewport_h = state.reveal_viewport_h;
- fresh.reveal_fit = state.reveal_fit;
- fresh.reveal_viewport_valid = state.reveal_viewport_valid;
- // Revisions are part of the backend texture key. Resetting this counter
- // while the pane serial stays live can alias a cached pre-reload page.
- fresh.next_raster_revision = state.next_raster_revision;
- fresh.sections_output = state.sections_output;
- if (preserve_anchor) {
- fresh.scroll_to_page_pending = false;
- fresh.layout_anchor_pending = true;
- fresh.layout_anchor_page = anchor_page;
- fresh.layout_anchor_fraction = anchor_fraction;
- }
-
- var old = state.*;
- state.* = fresh;
- old.deinit(gpa);
- }
-
- pub fn invalidateRaster(state: *@This(), page: usize) void {
- if (rasterForPage(state, page)) |raster| raster.tried = false;
- }
-
- pub fn invalidateAllRasters(state: *@This()) void {
- for (state.rasters[0..state.rasters_len]) |*raster| {
- if (raster.valid) raster.tried = false;
- }
- }
-
- fn retireRgba(state: *@This(), gpa: std.mem.Allocator, rgba: []u8) void {
- if (rgba.len == 0) return;
- if (state.spare_len == state.spare.len) return gpa.free(rgba);
- state.spare[state.spare_len] = rgba;
- state.spare_len += 1;
- }
-
- fn retireRaster(state: *@This(), gpa: std.mem.Allocator, raster: *Raster) void {
- if (raster.clean.len > 0) gpa.free(raster.clean);
- gpa.free(raster.baked);
- state.retireRgba(gpa, raster.rgba);
- raster.* = .{};
- }
-
- fn claimRgba(state: *@This(), gpa: std.mem.Allocator, bytes: usize) ?[]u8 {
- for (state.spare[0..state.spare_len], 0..) |candidate, index| {
- if (candidate.len != bytes) continue;
- state.spare_len -= 1;
- state.spare[index] = state.spare[state.spare_len];
- return candidate;
- }
- return gpa.alloc(u8, bytes) catch null;
- }
-
- fn trimSpares(state: *@This(), gpa: std.mem.Allocator) void {
- while (state.spare_len > 1) {
- state.spare_len -= 1;
- gpa.free(state.spare[state.spare_len]);
- }
- }
-
- fn dropSearchResults(state: *@This(), gpa: std.mem.Allocator) void {
- if (state.search_results) |*results| results.deinit(gpa);
- state.search_results = null;
- }
-
- fn dropSelection(state: *@This(), gpa: std.mem.Allocator) void {
- if (state.selection) |*selection| selection.deinit(gpa);
- state.selection = null;
- state.selection_page = null;
- if (state.selection_text.len > 0) gpa.free(state.selection_text);
- state.selection_text = &.{};
- state.selection_anchor = null;
- state.selection_head = null;
- }
-
- pub fn setSelection(
- state: *@This(),
- gpa: std.mem.Allocator,
- start: Point,
- end: Point,
- invalidate_raster: bool,
- ) SelectionUpdate {
- if (state.selection != null and state.selection_page == state.page and
- state.selection_anchor != null and state.selection_head != null and
- state.selection_anchor.?.x == start.x and state.selection_anchor.?.y == start.y and
- state.selection_head.?.x == end.x and state.selection_head.?.y == end.y) return .unchanged;
- var selection = state.document.select(gpa, state.page, start, end) catch return .failed;
- const text = state.document.copySelection(
- gpa,
- state.page,
- selection.start,
- selection.end,
- ) catch {
- selection.deinit(gpa);
- return .failed;
- };
-
- const old_page = state.selection_page;
- state.dropSelection(gpa);
- state.selection = selection;
- state.selection_page = state.page;
- state.selection_text = text;
- state.selection_anchor = start;
- state.selection_head = end;
- if (old_page) |page| if (page != state.page) state.invalidateRaster(page);
- if (invalidate_raster) state.invalidateRaster(state.page);
- return .changed;
- }
-
- pub fn clearDrag(state: *@This()) void {
- state.drag_anchor = null;
- state.drag_head = null;
- }
-
- pub fn clearSelection(state: *@This(), gpa: std.mem.Allocator) void {
- const page = state.selection_page;
- state.dropSelection(gpa);
- if (page) |selected_page| state.invalidateRaster(selected_page);
- }
-
- /// Drops the selection and the search; true when there was one.
- pub fn cancelChrome(state: *@This(), gpa: std.mem.Allocator) bool {
- const had = state.selection != null or state.search_query.len > 0;
- state.clearDrag();
- state.clearSelection(gpa);
- if (state.search_query.len == 0) return had;
- state.dropSearchQuery(gpa);
- state.invalidateRaster(state.page);
- return had;
- }
-
- fn invalidatePage(state: *@This(), gpa: std.mem.Allocator) void {
- state.dropSearchResults(gpa);
- state.clearDrag();
- if (state.text.len > 0) gpa.free(state.text);
- state.text = &.{};
- state.text_tried = false;
- state.text_scroll = 0;
- state.text_scroll_clamp_pending = false;
- state.highlights_dirty = state.search_query.len > 0;
- state.search_reveal_pending = state.search_query.len > 0;
- state.search_hit = 0;
- }
-
- fn dropSearchQuery(state: *@This(), gpa: std.mem.Allocator) void {
- if (state.search_query.len > 0) gpa.free(state.search_query);
- state.search_query = &.{};
- state.search_hit = 0;
- state.dropSearchResults(gpa);
- state.highlights_dirty = false;
- state.search_reveal_pending = false;
- }
-
- pub fn setSearchQuery(state: *@This(), gpa: std.mem.Allocator, query: []const u8) !void {
- if (std.mem.eql(u8, state.search_query, query)) return;
- const owned = try gpa.dupe(u8, query);
- state.dropSearchQuery(gpa);
- state.search_query = owned;
- state.highlights_dirty = query.len > 0;
- state.search_reveal_pending = query.len > 0;
- state.invalidateRaster(state.page);
- }
-
- pub fn ensureText(state: *@This(), gpa: std.mem.Allocator) []const u8 {
- if (!state.text_tried) {
- state.text_tried = true;
- state.text = state.document.pageText(gpa, state.page) catch &.{};
- }
- if (state.text_scroll_clamp_pending) {
- const lines = std.mem.count(u8, state.text, "\n") + 1;
- state.text_scroll = @min(state.text_scroll, lines - 1);
- state.text_scroll_clamp_pending = false;
- }
- return state.text;
- }
-
- pub fn resolveSearch(state: *@This(), gpa: std.mem.Allocator) void {
- if (!state.highlights_dirty) return;
- state.highlights_dirty = false;
- state.dropSearchResults(gpa);
- if (state.search_query.len == 0) return;
- const results = state.document.search(gpa, state.page, state.search_query) catch return;
- state.search_hit = if (results.hit_count == 0)
- 0
- else
- @min(state.search_hit, results.hit_count - 1);
- state.search_results = results;
- }
-
- /// Whether page `page` (one-based) holds search hit `hit` (one-based) of
- /// the pane's search: none asked, no hit is there.
- pub fn hitExists(state: *@This(), gpa: std.mem.Allocator, page: usize, hit: usize) bool {
- if (hit == 0) return true;
- if (state.search_query.len == 0 or page == 0 or page > state.page_count) return false;
- var results = state.document.search(gpa, page - 1, state.search_query) catch return false;
- defer results.deinit(gpa);
- return hit <= results.hit_count;
- }
-
- pub fn ensureOutline(state: *@This(), gpa: std.mem.Allocator) ?*const pdf.Outline {
- if (!state.outline_tried) {
- state.outline_tried = true;
- state.outline = state.document.outline(gpa) catch null;
- }
- return if (state.outline) |*outline| outline else null;
- }
-
- pub fn renderSections(
- state: *@This(),
- pdf_gpa: std.mem.Allocator,
- output_gpa: std.mem.Allocator,
- ) ![]u8 {
- const entries: []const pdf.OutlineEntry = if (state.ensureOutline(pdf_gpa)) |outline|
- outline.entries
- else
- &.{};
- return SectionRows.render(output_gpa, state.path, entries);
- }
-
- pub fn sectionDestination(
- state: *@This(),
- gpa: std.mem.Allocator,
- ordinal: usize,
- ) ?pdf.OutlineDestination {
- const outline = state.ensureOutline(gpa) orelse return null;
- return SectionRows.resolve(outline.entries, ordinal);
- }
-
- /// Apply the one-based page/hit location encoded in a PDF search row.
- /// Returns whether host pane cursor chrome must be reset.
- pub fn focusLocation(
- state: *@This(),
- gpa: std.mem.Allocator,
- line: usize,
- column: usize,
- ) bool {
- const changed = line > 0 and state.activatePage(gpa, line - 1, true);
- if (column > 0 and state.search_query.len > 0) {
- state.search_hit = column - 1;
- state.search_reveal_pending = true;
- }
- return changed;
- }
-
- /// Change the document page while leaving pane cursor/selection chrome to
- /// the UI adapter. Returns whether that pane-local chrome must be reset.
- pub fn activatePage(
- state: *@This(),
- gpa: std.mem.Allocator,
- page: usize,
- reveal: bool,
- ) bool {
- state.outline_reveal_pending = null;
- const next = @min(page, state.page_count -| 1);
- const changed = next != state.page;
- if (changed) {
- state.invalidatePage(gpa);
- state.page = next;
- }
- if (reveal) {
- state.scroll_to_page_pending = true;
- if (state.layout_valid) {
- state.document_scroll_y = @floatFromInt(state.page_starts[next]);
- state.scroll_to_page_pending = false;
- }
- } else {
- state.search_reveal_pending = false;
- }
- return changed;
- }
-
- pub fn toggleFit(state: *@This()) void {
- state.fit = if (state.fit == .width) .height else .width;
- state.pan_x = 0;
- state.pan_y = 0;
- state.layout_valid = false;
- state.scroll_to_page_pending = true;
- state.search_reveal_pending = state.search_query.len > 0;
- }
-
- pub fn toggleTint(state: *@This()) void {
- state.tint = state.tint.next();
- state.invalidateAllRasters();
- }
-
- pub fn queueOutlineReveal(
- state: *@This(),
- destination: pdf.OutlineInternalDestination,
- ) void {
- state.scroll_to_page_pending = false;
- state.layout_anchor_pending = false;
- state.outline_reveal_pending = destination;
- }
-
- pub fn deinit(state: *@This(), gpa: std.mem.Allocator) void {
- // Every lane stopped and joined, its job dropped, its document
- // closed, before the document its context was cloned from.
- for (&state.lanes) |*lane| {
- if (lane.job) |job| {
- @atomicStore(c_int, &job.cookie.abort, 1, .release);
- pardes.turn.yield();
- lane.future.?.await(lane.io);
- pardes.turn.back();
- job.gen = 0;
- land(state, gpa, job);
- }
- if (lane.doc) |*doc| doc.deinit();
- lane.* = .{};
- }
- gpa.free(state.path);
- for (state.rasters[0..state.rasters_len]) |*raster| keepPage(state, gpa, raster);
- for (state.rasters[0..state.rasters_len]) |raster| {
- if (raster.rgba.len > 0) gpa.free(raster.rgba);
- if (raster.clean.len > 0) gpa.free(raster.clean);
- gpa.free(raster.baked);
- }
- for (state.spare[0..state.spare_len]) |rgba| gpa.free(rgba);
- if (state.sizes_ready.len > 0) gpa.free(state.sizes_ready);
- gpa.free(state.page_sizes);
- gpa.free(state.page_starts);
- gpa.free(state.page_heights);
- if (state.text.len > 0) gpa.free(state.text);
- if (state.search_query.len > 0) gpa.free(state.search_query);
- if (state.search_results) |*results| results.deinit(gpa);
- if (state.selection) |*selection| selection.deinit(gpa);
- if (state.selection_text.len > 0) gpa.free(state.selection_text);
- if (state.outline) |*outline| outline.deinit(gpa);
- state.document.deinit();
- state.* = undefined;
- }
-} else void;
-
-pub const SearchOutput = struct {
- bytes: usize = 0,
- rows: usize = 0,
- anchor: ?usize = null,
-};
-
-pub fn textLines(
- state: *State,
- gpa: std.mem.Allocator,
- arena: std.mem.Allocator,
-) ![]const []const u8 {
- if (comptime !enabled) return &.{};
- const page_text = state.ensureText(gpa);
- const lines = try arena.alloc([]const u8, std.mem.count(u8, page_text, "\n") + 1);
- var it = std.mem.splitScalar(u8, page_text, '\n');
- var n: usize = 0;
- while (it.next()) |line| : (n += 1) lines[n] = line;
- return lines;
-}
-
-pub fn visibleText(
- state: *State,
- gpa: std.mem.Allocator,
- arena: std.mem.Allocator,
- max_rows: usize,
-) ![]const u8 {
- if (comptime !enabled) return "";
- const page_text = state.ensureText(gpa);
- var start: usize = 0;
- for (0..state.text_scroll) |_| {
- const newline = std.mem.indexOfScalarPos(u8, page_text, start, '\n') orelse
- return arena.dupe(u8, "");
- start = newline + 1;
- }
- if (max_rows == 0) return arena.dupe(u8, "");
-
- var end = start;
- var row: usize = 0;
- while (row < max_rows) : (row += 1) {
- const newline = std.mem.indexOfScalarPos(u8, page_text, end, '\n') orelse {
- end = page_text.len;
- break;
- };
- if (row + 1 == max_rows) {
- end = newline;
- break;
- }
- end = newline + 1;
- }
- return arena.dupe(u8, page_text[start..end]);
-}
-
-/// Materialize exact MuPDF logical hits as `path:PAGE:HIT query` rows. The
-/// same hit numbering drives persistent highlights and later reveal actions.
-pub fn searchRows(
- state: *State,
- gpa: std.mem.Allocator,
- pattern: []const u8,
- from_cursor: bool,
- out: []u8,
-) !SearchOutput {
- if (comptime !enabled) return .{};
- try state.setSearchQuery(gpa, pattern);
- const shown = std.fs.path.basename(state.path);
- var result: SearchOutput = .{};
- const max_hits = 512;
- var snippet_len = @min(pattern.len, 200);
- while (snippet_len > 0 and snippet_len < pattern.len and pattern[snippet_len] & 0xc0 == 0x80)
- snippet_len -= 1;
- const snippet = pattern[0..snippet_len];
- for (0..state.page_count) |page| {
- if (result.rows >= max_hits) break;
- var found = try state.document.search(gpa, page, pattern);
- defer found.deinit(gpa);
-
- const cursor_hit: ?usize = if (from_cursor and page == state.page and state.selection_page == page) cursor: {
- const selection = state.selection orelse break :cursor null;
- for (found.quads) |item| {
- const q = item.quad;
- const center: Point = .{
- .x = (q.ul.x + q.ur.x + q.ll.x + q.lr.x) / 4,
- .y = (q.ul.y + q.ur.y + q.ll.y + q.lr.y) / 4,
- };
- if (selection.contains(center)) break :cursor item.hit;
- }
- break :cursor null;
- } else null;
-
- for (0..found.hit_count) |hit_index| {
- if (result.rows >= max_hits) break;
- // A row that does not fit ends the list.
- const line = std.fmt.bufPrint(out[result.bytes..], "{s}:{d}:{d} {s}\n", .{
- shown, page + 1, hit_index + 1, snippet,
- }) catch return result;
- if (from_cursor and
- (page < state.page or
- (page == state.page and cursor_hit != null and hit_index <= cursor_hit.?)))
- result.anchor = result.rows;
- result.bytes += line.len;
- result.rows += 1;
- }
- }
- return result;
-}
-
-pub const Viewport = struct { pixel_w: u32, pixel_h: u32 };
-pub const VisiblePages = struct { first: usize = 0, len: usize = 0 };
-pub const PanAxis = enum { horizontal, vertical };
-pub const PanResult = enum { moved, edge, unavailable };
-pub const ScrollResult = struct { active_page: usize };
-pub const CellPixels = struct { w: u16, h: u16 };
-
-/// How a native pixel attachment is placed in its pane body. `contain` is the
-/// historical image-pane policy: shrink only when necessary and keep the
-/// image at the top left. The axis-specific modes may enlarge, letterbox the
-/// unconstrained axis, or crop it when it overflows.
-pub const NativeFit = if (enabled) enum { contain, width, height } else enum { contain };
-
-fn panOffset(overflow: u32, pan: u16) u32 {
- if (overflow == 0 or pan == 0) return 0;
- if (pan == std.math.maxInt(u16)) return overflow;
- // Round, rather than truncate, so the midpoint is the visual midpoint.
- return @intCast((@as(u64, overflow) * pan + std.math.maxInt(u16) / 2) / std.math.maxInt(u16));
-}
-
-fn fitWidth(src_w: u32, src_h: u32, body_w: u32, body_h: u32, pan_y: u16) ?surface.NativeGeometry {
- const scaled_h = @as(u64, src_h) * body_w;
- if (scaled_h <= @as(u64, body_h) * src_w) {
- const full_h: u32 = @intCast(@max(1, scaled_h / src_w));
- return .{
- .src = .{ .w = src_w, .h = src_h },
- .dst = .{ .y = (body_h - full_h) / 2, .w = body_w, .h = full_h },
- };
- }
-
- // Retain the largest whole source-pixel crop which cannot extend beyond
- // the body at this scale. The sub-pixel remainder becomes at most a small
- // centered letterbox instead of leaking into an adjacent cell in Kitty.
- const crop_h_wide = @as(u64, body_h) * src_w / body_w;
- if (crop_h_wide == 0) return null;
- const crop_h: u32 = @min(src_h, @as(u32, @intCast(crop_h_wide)));
- const dst_h: u32 = @min(body_h, @max(1, @as(u32, @intCast(@as(u64, crop_h) * body_w / src_w))));
- return .{
- .src = .{
- .y = panOffset(src_h - crop_h, pan_y),
- .w = src_w,
- .h = crop_h,
- },
- .dst = .{ .y = (body_h - dst_h) / 2, .w = body_w, .h = dst_h },
- };
-}
-
-fn fitHeight(src_w: u32, src_h: u32, body_w: u32, body_h: u32, pan_x: u16) ?surface.NativeGeometry {
- const scaled_w = @as(u64, src_w) * body_h;
- if (scaled_w <= @as(u64, body_w) * src_h) {
- const full_w: u32 = @intCast(@max(1, scaled_w / src_h));
- return .{
- .src = .{ .w = src_w, .h = src_h },
- .dst = .{ .x = (body_w - full_w) / 2, .w = full_w, .h = body_h },
- };
- }
-
- const crop_w_wide = @as(u64, body_w) * src_h / body_h;
- if (crop_w_wide == 0) return null;
- const crop_w: u32 = @min(src_w, @as(u32, @intCast(crop_w_wide)));
- const dst_w: u32 = @min(body_w, @max(1, @as(u32, @intCast(@as(u64, crop_w) * body_h / src_h))));
- return .{
- .src = .{
- .x = panOffset(src_w - crop_w, pan_x),
- .w = crop_w,
- .h = src_h,
- },
- .dst = .{ .x = (body_w - dst_w) / 2, .w = dst_w, .h = body_h },
- };
-}
-
-/// Compute native image placement without floating point. Source dimensions
-/// are limited to u32 because SDL's texture API and Kitty's crop parameters
-/// cannot describe anything larger. Kitty applies the stricter u16 check at
-/// its protocol boundary.
-pub fn nativeGeometry(
- iw: usize,
- ih: usize,
- body_pixel_w: u32,
- body_pixel_h: u32,
- fit: NativeFit,
- pan_x: u16,
- pan_y: u16,
-) ?surface.NativeGeometry {
- if (comptime !enabled) {
- return surface.containGeometry(iw, ih, body_pixel_w, body_pixel_h);
- }
- if (iw == 0 or ih == 0 or body_pixel_w == 0 or body_pixel_h == 0 or
- iw > std.math.maxInt(u32) or ih > std.math.maxInt(u32)) return null;
-
- const src_w: u32 = @intCast(iw);
- const src_h: u32 = @intCast(ih);
- return switch (fit) {
- .width => fitWidth(src_w, src_h, body_pixel_w, body_pixel_h, pan_y),
- .height => fitHeight(src_w, src_h, body_pixel_w, body_pixel_h, pan_x),
- // Pan is not contain's: it keeps the top-left placement.
- .contain => surface.containGeometry(iw, ih, body_pixel_w, body_pixel_h),
- };
-}
-
-test "native fit width handles portrait crop, pan extrema, and landscape letterbox" {
- if (comptime !enabled) return;
- const top = nativeGeometry(600, 1000, 800, 600, .width, 0, 0).?;
- try std.testing.expectEqual(surface.RectPx{ .w = 600, .h = 450 }, top.src);
- try std.testing.expectEqual(surface.RectPx{ .w = 800, .h = 600 }, top.dst);
-
- const middle = nativeGeometry(600, 1000, 800, 600, .width, 0, 32768).?;
- try std.testing.expectEqual(@as(u32, 275), middle.src.y);
- const bottom = nativeGeometry(600, 1000, 800, 600, .width, 65535, 65535).?;
- try std.testing.expectEqual(@as(u32, 550), bottom.src.y);
-
- const landscape = nativeGeometry(1000, 600, 800, 600, .width, 0, 65535).?;
- try std.testing.expectEqual(surface.RectPx{ .w = 1000, .h = 600 }, landscape.src);
- try std.testing.expectEqual(surface.RectPx{ .y = 60, .w = 800, .h = 480 }, landscape.dst);
-}
-
-test "native fit height handles portrait letterbox and landscape crop" {
- if (comptime !enabled) return;
- const portrait = nativeGeometry(600, 1000, 800, 600, .height, 65535, 0).?;
- try std.testing.expectEqual(surface.RectPx{ .w = 600, .h = 1000 }, portrait.src);
- try std.testing.expectEqual(surface.RectPx{ .x = 220, .w = 360, .h = 600 }, portrait.dst);
-
- const left = nativeGeometry(1000, 600, 800, 600, .height, 0, 0).?;
- try std.testing.expectEqual(surface.RectPx{ .w = 800, .h = 600 }, left.src);
- try std.testing.expectEqual(surface.RectPx{ .w = 800, .h = 600 }, left.dst);
- const right = nativeGeometry(1000, 600, 800, 600, .height, 65535, 0).?;
- try std.testing.expectEqual(@as(u32, 200), right.src.x);
-}
-
-test "native fit odd ratios round inward and map points through letterboxes and crops" {
- if (comptime !enabled) return;
- const width = nativeGeometry(403, 211, 101, 47, .width, 0, 32768).?;
- try std.testing.expectEqual(surface.RectPx{ .y = 12, .w = 403, .h = 187 }, width.src);
- try std.testing.expectEqual(surface.RectPx{ .w = 101, .h = 46 }, width.dst);
- const mapped = width.sourcePoint(100, 45).?;
- try std.testing.expect(mapped.x < width.src.x + width.src.w);
- try std.testing.expect(mapped.y < width.src.y + width.src.h);
- try std.testing.expect(width.sourcePoint(101, 46) == null);
-
- const height = nativeGeometry(403, 211, 101, 47, .height, 32768, 0).?;
- try std.testing.expectEqual(surface.RectPx{ .w = 403, .h = 211 }, height.src);
- try std.testing.expectEqual(surface.RectPx{ .x = 6, .w = 89, .h = 47 }, height.dst);
- try std.testing.expect(height.sourcePoint(5, 20) == null);
- try std.testing.expect(height.sourcePoint(6, 20) != null);
-}
-
-test "native fit modes reject what the backend contract cannot represent and are total at extreme aspect ratios" {
- if (comptime !enabled) return;
- try std.testing.expect(nativeGeometry(10, 10, 0, 20, .width, 0, 0) == null);
- if (@bitSizeOf(usize) > 32)
- try std.testing.expect(nativeGeometry(@as(usize, std.math.maxInt(u32)) + 1, 10, 20, 20, .height, 0, 0) == null);
-
- const largest = std.math.maxInt(u32);
- try std.testing.expect(nativeGeometry(1, largest, largest, 1, .width, 0, 65535) == null);
- try std.testing.expect(nativeGeometry(largest, 1, 1, largest, .height, 65535, 0) == null);
-
- const wide = nativeGeometry(largest, 1, largest, 1, .width, 0, 0).?;
- try std.testing.expectEqual(surface.RectPx{ .w = largest, .h = 1 }, wide.dst);
- const tall = nativeGeometry(1, largest, 1, largest, .height, 0, 0).?;
- try std.testing.expectEqual(surface.RectPx{ .w = 1, .h = largest }, tall.dst);
-}
-
-const PlacedGeometry = struct {
- geometry: surface.NativeGeometry,
- pixel_offset_y: f32,
-};
-
-pub const PlacedRaster = if (enabled) struct {
- page: usize,
- revision: u32,
- fit: FitMode,
- pan_x: u16,
- geometry: surface.NativeGeometry,
- pixel_offset_y: f32,
- rgba: []const u8,
- width: usize,
- band_height: usize,
-} else void;
-
-const VisibleRows = struct {
- base: surface.NativeGeometry,
- y0: u32,
- y1: u32,
- dst_y: u32,
- dst_h: u32,
- pixel_offset_y: f32,
-};
-
-/// The raster a pane asks for. The page is shown `viewport.pixel_w` wide
-/// (fit width) or `pixel_h` tall (fit height), and the raster is never
-/// smaller than that, however tall the page: see `pdf.RenderRequest`.
-pub fn renderRequest(viewport: Viewport, policy: RasterPolicy, fit: FitMode) RenderRequest {
- if (comptime !enabled) return;
- return .{
- .dpi = policy.dpi,
- .minimum_width = if (policy.match_viewport) viewport.pixel_w else 0,
- .minimum_height = if (policy.match_viewport) viewport.pixel_h else 0,
- .max_dimension = policy.max_dimension,
- .display_width = if (fit == .width) viewport.pixel_w else 0,
- .display_height = if (fit == .height) viewport.pixel_h else 0,
- };
-}
-
-fn pageHeight(size: pdf.PageSize, viewport: Viewport, fit: FitMode) u32 {
- if (comptime !enabled) return 0;
- if (fit == .height) return viewport.pixel_h;
- const scaled = @as(f64, @floatFromInt(viewport.pixel_w)) *
- @as(f64, size.height) / @as(f64, size.width);
- return @max(1, @as(u32, @intFromFloat(@min(
- @as(f64, @floatFromInt(std.math.maxInt(u32))),
- @round(scaled),
- ))));
-}
-
-fn pageAtOffset(state: *const State, offset: f64) usize {
- if (comptime !enabled) return 0;
- const y: u64 = @intFromFloat(std.math.clamp(
- @floor(offset),
- 0,
- @as(f64, @floatFromInt(state.document_height -| 1)),
- ));
- var lo: usize = 0;
- var hi: usize = state.page_count;
- while (lo + 1 < hi) {
- const mid = lo + (hi - lo) / 2;
- if (state.page_starts[mid] <= y) lo = mid else hi = mid;
- }
- const end = state.page_starts[lo] + state.page_heights[lo];
- return if (y >= end and lo + 1 < state.page_count) lo + 1 else lo;
-}
-
-fn pageVisible(state: *const State, page: usize, y: f64, h: f64) bool {
- if (comptime !enabled) return false;
- const top = @as(f64, @floatFromInt(state.page_starts[page])) - y;
- const bottom = top + @as(f64, @floatFromInt(state.page_heights[page]));
- return bottom > 0 and top < h;
-}
-
-pub fn visiblePages(state: *const State, viewport: Viewport) VisiblePages {
- return pagesOver(state, state.document_scroll_y, @floatFromInt(viewport.pixel_h));
-}
-
-/// The pages over the strip from `y`, `h` pixels down.
-fn pagesOver(state: *const State, y: f64, h: f64) VisiblePages {
- if (comptime !enabled) return .{};
- var out: VisiblePages = .{};
- var page = pageAtOffset(state, y);
- if (page > 0 and pageVisible(state, page - 1, y, h)) page -= 1;
- out.first = page;
- while (page < state.page_count) : (page += 1) {
- const top = @as(f64, @floatFromInt(state.page_starts[page])) - y;
- if (top >= h) break;
- if (pageVisible(state, page, y, h)) out.len += 1;
- }
- return out;
-}
-
-fn visibleContains(visible: VisiblePages, page: usize) bool {
- return page >= visible.first and page - visible.first < visible.len;
-}
-
-pub fn rasterForPage(state: *State, page: usize) ?*Raster {
- if (comptime !enabled) return null;
- for (state.rasters[0..state.rasters_len]) |*raster|
- if (raster.valid and raster.page == page) return raster;
- return null;
-}
-
-fn rasterForPageConst(state: *const State, page: usize) ?*const Raster {
- if (comptime !enabled) return null;
- for (state.rasters[0..state.rasters_len]) |*raster|
- if (raster.valid and raster.page == page) return raster;
- return null;
-}
-
-fn visibleRows(
- state: *const State,
- viewport: Viewport,
- page: usize,
- iw: usize,
- ih: usize,
-) ?VisibleRows {
- if (comptime !enabled) return null;
- const page_h = state.page_heights[page];
- const base = nativeGeometry(
- iw,
- ih,
- viewport.pixel_w,
- page_h,
- switch (state.fit) {
- .width => .width,
- .height => .height,
- },
- state.pan_x,
- 0,
- ) orelse return null;
- if (base.dst.h == 0 or base.src.h == 0) return null;
-
- const scroll_floor = @floor(state.document_scroll_y);
- const fractional: f32 = @floatCast(state.document_scroll_y - scroll_floor);
- const scroll_i: i64 = @intFromFloat(@min(
- scroll_floor,
- @as(f64, @floatFromInt(std.math.maxInt(i64))),
- ));
- const start_i: i64 = @intCast(@min(
- state.page_starts[page],
- @as(u64, std.math.maxInt(i64)),
- ));
- const full_y = start_i - scroll_i + @as(i64, base.dst.y);
- const full_bottom = full_y + @as(i64, base.dst.h);
- const visible_y = @max(@as(i64, 0), full_y);
- const visible_bottom = @min(@as(i64, viewport.pixel_h), full_bottom);
- if (visible_bottom <= visible_y) return null;
-
- const rel_y0: u64 = @intCast(visible_y - full_y);
- const rel_y1: u64 = @intCast(visible_bottom - full_y);
- const src_y0: u32 = base.src.y + @as(u32, @intCast(
- rel_y0 * base.src.h / base.dst.h,
- ));
- const src_y1: u32 = base.src.y + @as(u32, @intCast(@min(
- @as(u64, base.src.h),
- (rel_y1 * base.src.h + base.dst.h - 1) / base.dst.h,
- )));
- if (src_y1 <= src_y0) return null;
- return .{
- .base = base,
- .y0 = src_y0,
- .y1 = src_y1,
- .dst_y = @intCast(visible_y),
- .dst_h = @intCast(visible_bottom - visible_y),
- .pixel_offset_y = -fractional,
- };
-}
-
-fn placedGeometry(
- state: *const State,
- raster: *const Raster,
- viewport: Viewport,
- page: usize,
-) ?PlacedGeometry {
- if (comptime !enabled) return null;
- const rows = visibleRows(state, viewport, page, raster.iw, raster.ih) orelse return null;
- const band_y: u32 = @intCast(raster.band_y);
- const band_end: u32 = @intCast(raster.band_y + raster.band_h);
- if (rows.y0 < band_y or rows.y1 > band_end) return null;
- return .{
- .geometry = .{
- .src = .{
- .x = rows.base.src.x,
- .y = rows.y0 - band_y,
- .w = rows.base.src.w,
- .h = rows.y1 - rows.y0,
- },
- .dst = .{
- .x = rows.base.dst.x,
- .y = rows.dst_y,
- .w = rows.base.dst.w,
- .h = rows.dst_h,
- },
- },
- .pixel_offset_y = rows.pixel_offset_y,
- };
-}
-
-pub fn placedRaster(state: *const State, viewport: Viewport, page: usize) ?PlacedRaster {
- if (comptime !enabled) return null;
- const raster = rasterForPageConst(state, page) orelse return null;
- if (raster.rgba.len == 0) return null;
- const placed = placedGeometry(state, raster, viewport, page) orelse return null;
- return .{
- .page = page,
- .revision = raster.revision,
- .fit = state.fit,
- .pan_x = state.pan_x,
- .geometry = placed.geometry,
- .pixel_offset_y = placed.pixel_offset_y,
- .rgba = raster.rgba,
- .width = raster.iw,
- .band_height = raster.band_h,
- };
-}
-
-pub fn activeGeometry(state: *const State, viewport: Viewport) ?surface.NativeGeometry {
- if (comptime !enabled) return null;
- const raster = rasterForPageConst(state, state.page) orelse return null;
- const placed = placedGeometry(state, raster, viewport, state.page) orelse return null;
- return placed.geometry;
-}
-
-pub fn pageReady(state: *const State, viewport: Viewport, page: usize) bool {
- if (comptime !enabled) return false;
- return placedRaster(state, viewport, page) != null;
-}
-
-fn slotShape(slot: *const Raster) pdf.Raster {
- const stride = slot.iw * 4;
- return .{ .width = slot.iw, .height = slot.ih, .stride = stride, .len = stride * slot.ih };
-}
-
-fn flinging(state: *const State, viewport: Viewport) bool {
- if (comptime !enabled) return false;
- return state.scroll_travel >= @as(f64, @floatFromInt(viewport.pixel_h));
-}
-
-/// The most rows one buffer of this page holds.
-fn bandCap(shape: pdf.Raster) usize {
- return @min(max_band_rows, pdf.max_owned_raster_bytes / @max(shape.stride, 1));
-}
-
-/// A page too tall for one buffer: see `max_band_rows`.
-pub fn isBanded(shape: pdf.Raster) bool {
- if (comptime !enabled) return false;
- return shape.height > bandCap(shape);
-}
-
-/// What a banded page's buffer is asked to hold. `target` is what a render
-/// covers: the rows on screen and a screenful either side, so scrolling finds
-/// the next rows ready (none while flinging, which only wants this frame's).
-/// `keep` is what the buffer must still cover to be kept: half a screenful
-/// either side, so a render happens once per half screenful scrolled, not on
-/// every frame.
-const Reach = enum { target, keep };
-
-fn wantedBand(
- state: *const State,
- viewport: Viewport,
- page: usize,
- shape: pdf.Raster,
- is_flinging: bool,
- reach: Reach,
-) pdf.Raster.Band {
- if (isBanded(shape)) return chunkBand(state, viewport, page, shape, is_flinging, reach);
- if (!is_flinging) return shape.wholePage();
- const rows = visibleRows(state, viewport, page, shape.width, shape.height) orelse
- return shape.wholePage();
- const first = (@as(usize, rows.y0) / band_grain) * band_grain;
- const last = std.math.divCeil(usize, @as(usize, rows.y1), band_grain) catch
- return shape.wholePage();
- return shape.band(first, last * band_grain - first);
-}
-
-fn chunkBand(
- state: *const State,
- viewport: Viewport,
- page: usize,
- shape: pdf.Raster,
- is_flinging: bool,
- reach: Reach,
-) pdf.Raster.Band {
- const rows = visibleRows(state, viewport, page, shape.width, shape.height) orelse
- return shape.band(0, chunk_rows);
- const seen: usize = rows.y1 - rows.y0;
- const margin: usize = if (is_flinging) 0 else switch (reach) {
- .target => seen,
- .keep => seen / 2,
- };
- const top = @as(usize, rows.y0) -| margin;
- const bottom = @min(shape.height, @as(usize, rows.y1) + margin);
- if (reach == .keep) return shape.band(top, bottom - top);
- var first = top / chunk_rows * chunk_rows;
- var last = @min(shape.height, (bottom + chunk_rows - 1) / chunk_rows * chunk_rows);
- const cap = bandCap(shape) / chunk_rows * chunk_rows;
- if (last - first > cap) {
- // The margins give way: what is on screen always fits.
- first = @as(usize, rows.y0) / chunk_rows * chunk_rows;
- last = @min(shape.height, first + cap);
- }
- return shape.band(first, last - first);
-}
-
-/// Fill `fresh` with the rows `want` of a banded page. Chunks the slot
-/// already holds, under this request and tint and with these highlights
-/// (`reuse`), are copied; the rest are rendered (`renderChunk`), then
-/// highlighted and tinted as `reconcile` does a whole page. `slot.clean`
-/// becomes the new rows' clean copy when `keep_clean`.
-fn fillBanded(
- state: *State,
- gpa: std.mem.Allocator,
- slot: *const Raster,
- request: RenderRequest,
- shape: pdf.Raster,
- want: pdf.Raster.Band,
- highlights: []const Highlight,
- tint_key: TintKey,
- fresh: []u8,
- keep_clean: bool,
- reuse: bool,
- clean_out: *[]u8,
-) bool {
- const tz = tracy.zone(@src(), "pdf.fill_banded");
- defer tz.end();
- const stride = shape.stride;
- const clean: []u8 = if (keep_clean) gpa.alloc(u8, fresh.len) catch return false else &.{};
- var filled = false;
- defer if (!filled and clean.len > 0) gpa.free(clean);
- const held = reuse and slot.rgba.len == slot.band_h * stride and
- (!keep_clean or slot.clean.len == slot.rgba.len);
- var scratch: []u8 = &.{};
- defer if (scratch.len > 0) gpa.free(scratch);
- const end = want.y + want.height;
- var y = want.y;
- while (y < end) {
- const rows = @min(chunk_rows - y % chunk_rows, end - y);
- const at = (y - want.y) * stride;
- const out = fresh[at..][0 .. rows * stride];
- if (held and slot.band_y <= y and y + rows <= slot.band_y + slot.band_h) {
- const from = (y - slot.band_y) * stride;
- @memcpy(out, slot.rgba[from..][0..out.len]);
- if (keep_clean) @memcpy(clean[at..][0..out.len], slot.clean[from..][0..out.len]);
- } else {
- if (scratch.len == 0)
- scratch = gpa.alloc(u8, (chunk_rows + 2 * chunk_overlap) * stride) catch return false;
- const target = if (keep_clean) clean[at..][0..out.len] else out;
- renderChunk(state, request, shape, slot.page, y, if (keep_clean) &.{} else highlights, target, scratch) catch
- return false;
- if (keep_clean) {
- @memcpy(out, target);
- state.document.paintHighlightsAt(slot.page, request, shape, shape.band(y, rows), highlights, out) catch
- return false;
- }
- pdf.tintRgba(out, tint_key.mode, tint_key.colors) catch return false;
- }
- y += rows;
- }
- filled = true;
- clean_out.* = clean;
- return true;
-}
-
-/// The `out.len / stride` rows of a banded page from row `y` (a chunk or
-/// its end), cut from a render reaching `chunk_overlap` rows past both.
-fn renderChunk(
- state: *State,
- request: RenderRequest,
- shape: pdf.Raster,
- page: usize,
- y: usize,
- highlights: []const Highlight,
- out: []u8,
- scratch: []u8,
-) !void {
- const tz = tracy.zone(@src(), "pdf.render_chunk");
- defer tz.end();
- const rows = out.len / shape.stride;
- const top = y -| chunk_overlap;
- const bottom = @min(shape.height, y + rows + chunk_overlap);
- const band = shape.band(top, bottom - top);
- const buf = scratch[0..band.len];
- try state.document.renderIntoAtWithPaper(page, request, shape, band, highlights, buf, pardes.platform == .macos);
- @memcpy(out, buf[(y - top) * shape.stride ..][0..out.len]);
-}
-
-fn reconcile(
- state: *State,
- gpa: std.mem.Allocator,
- request: RenderRequest,
- tint_key: TintKey,
- highlights: Highlights,
- visible: VisiblePages,
- viewport: Viewport,
-) void {
- if (comptime !enabled) return;
- const tz = tracy.zone(@src(), "pdf.reconcile");
- defer tz.end();
- collect(state, gpa);
- defer if (workers != null) sweep(state);
- if (state.sizes_pending and state.sizes_gen == 0) if (workers) |io| submitSizes(state, gpa, io);
-
- // Remove first so arriving pages can claim departing page buffers. Only
- // the final visible set can be seen, so a fling skips crossed-over pages.
- var index: usize = 0;
- while (index < state.rasters_len) {
- if (visibleContains(visible, state.rasters[index].page)) {
- index += 1;
- continue;
- }
- state.retireRaster(gpa, &state.rasters[index]);
- state.rasters_len -= 1;
- if (index != state.rasters_len)
- state.rasters[index] = state.rasters[state.rasters_len];
- }
-
- const is_flinging = flinging(state, viewport);
- var page = visible.first;
- const end = visible.first + visible.len;
- while (page < end) : (page += 1) {
- var raster = rasterForPage(state, page);
- if (raster == null) {
- if (state.rasters_len == state.rasters.len) continue;
- state.rasters[state.rasters_len] = .{ .valid = true, .page = page };
- state.rasters_len += 1;
- raster = &state.rasters[state.rasters_len - 1];
- if (workers != null) _ = unkeep(state, raster.?, request, tint_key);
- }
- const slot = raster.?;
- const page_highlights = highlights.forPage(page);
- const decorated = page_highlights.len > 0;
- const base_stale = !slot.request_valid or !slot.request.eql(request) or
- slot.tint_key == null or !slot.tint_key.?.eql(tint_key) or
- slot.rgba.len == 0 or slot.band_h == 0;
- const uncovered = !base_stale and uncovered: {
- const want = wantedBand(state, viewport, page, slotShape(slot), is_flinging, .keep);
- break :uncovered slot.band_y > want.y or
- slot.band_y + slot.band_h < want.y + want.height;
- };
- // A banded page moving on keeps the rows it has, if they are exactly
- // what a render would make now.
- const reuse = !base_stale and slot.baked_valid and sameHighlights(slot.baked, page_highlights);
- if (!base_stale and !uncovered) {
- if (slot.tried and slot.decorated == decorated and
- !(highlights.live and !sameHighlights(slot.baked, page_highlights))) continue;
- // Invalidated, but it already shows exactly these highlights
- // (a preview withdrawn that was never drawn, on every pointer
- // move over a page): nothing to render.
- if (slot.baked_valid and sameHighlights(slot.baked, page_highlights)) {
- slot.tried = true;
- continue;
- }
- // Only the highlights moved: repaint their rows in place.
- if (repaintHighlights(state, gpa, slot, request, tint_key, page_highlights)) continue;
- }
-
- // Off the loop: a lane renders the page whole and it lands on a
- // later frame (`collect`); until then the slot shows what it has.
- // A page too tall for one buffer is banded and stays on the loop.
- if (workers) |io| {
- if (pendingJob(state, slot)) |job| {
- if (job.request.eql(request) and job.tint_key.eql(tint_key)) continue;
- @atomicStore(c_int, &job.cookie.abort, 1, .release);
- slot.pending = 0;
- }
- if (slot.failed and slot.tried and slot.request_valid and slot.request.eql(request)) continue;
- const keep = pardes.platform != .macos and (decorated or slot.clean.len > 0);
- switch (submit(state, gpa, io, slot, request, tint_key, page_highlights, keep)) {
- .sent, .busy => continue,
- .loop => {},
- }
- }
-
- slot.tried = true;
- slot.request = request;
- slot.request_valid = true;
- const shape_or_null = shape: {
- const tz_measure = tracy.zone(@src(), "pdf.measure");
- defer tz_measure.end();
- break :shape state.document.measureRenderAt(page, request) catch null;
- };
- const shape = shape_or_null orelse continue;
- const want = wantedBand(state, viewport, page, shape, is_flinging, .target);
- const fresh = state.claimRgba(gpa, want.len) orelse continue;
- // A highlighted page keeps its clean rows for repaints.
- const keep_clean = pardes.platform != .macos and (decorated or slot.clean.len > 0);
- const filled = if (isBanded(shape)) banded: {
- var clean: []u8 = &.{};
- if (!fillBanded(state, gpa, slot, request, shape, want, page_highlights, tint_key, fresh, keep_clean, reuse, &clean))
- break :banded false;
- if (slot.clean.len > 0) gpa.free(slot.clean);
- slot.clean = clean;
- break :banded true;
- } else filled: {
- {
- const tz_render = tracy.zone(@src(), "pdf.render_into");
- defer tz_render.end();
- state.document.renderIntoAtWithPaper(
- page,
- request,
- shape,
- want,
- if (keep_clean) &.{} else page_highlights,
- fresh,
- pardes.platform == .macos,
- ) catch break :filled false;
- if (slot.clean.len != 0 and (!keep_clean or slot.clean.len != fresh.len)) {
- gpa.free(slot.clean);
- slot.clean = &.{};
- }
- if (keep_clean) {
- if (slot.clean.len == 0) slot.clean = gpa.alloc(u8, fresh.len) catch &.{};
- if (slot.clean.len == fresh.len) @memcpy(slot.clean, fresh);
- state.document.paintHighlightsAt(page, request, shape, want, page_highlights, fresh) catch
- break :filled false;
- }
- }
- const tz_tint = tracy.zone(@src(), "pdf.tint");
- defer tz_tint.end();
- pdf.tintRgba(fresh, tint_key.mode, tint_key.colors) catch
- break :filled false;
- break :filled true;
- };
- if (!filled) {
- state.retireRgba(gpa, fresh);
- // `clean` may already hold the band that failed.
- if (slot.clean.len > 0) gpa.free(slot.clean);
- slot.clean = &.{};
- continue;
- }
-
- state.retireRgba(gpa, slot.rgba);
- slot.rgba = fresh;
- slot.iw = shape.width;
- slot.ih = shape.height;
- slot.band_y = want.y;
- slot.band_h = want.height;
- slot.decorated = decorated;
- slot.tint_key = tint_key;
- if (gpa.dupe(Highlight, page_highlights)) |copy| {
- gpa.free(slot.baked);
- slot.baked = copy;
- slot.baked_valid = true;
- } else |_| {
- // Unrecorded highlights cannot be compared or diffed.
- slot.baked_valid = false;
- if (slot.clean.len > 0) gpa.free(slot.clean);
- slot.clean = &.{};
- }
- slot.patch_from = 0;
- slot.patch_rows = .{ .start = 0, .end = 0 };
- state.next_raster_revision +%= 1;
- if (state.next_raster_revision == 0) state.next_raster_revision = 1;
- slot.revision = state.next_raster_revision;
- state.landed +|= 1;
- }
- state.trimSpares(gpa);
-}
-
-fn pendingJob(state: *State, slot: *const Raster) ?*Job {
- if (slot.pending == 0) return null;
- for (state.lanes) |lane| if (lane.job) |job| if (job.gen == slot.pending) return job;
- return null;
-}
-
-/// Hands `slot`'s page to a free lane: `busy` when both are out (asked
-/// again next frame), `loop` when the page is banded or no lane can be had
-/// (the loop renders it as before).
-fn submit(
- state: *State,
- gpa: std.mem.Allocator,
- io: std.Io,
- slot: *Raster,
- request: RenderRequest,
- tint_key: TintKey,
- page_highlights: []const Highlight,
- keep_clean: bool,
-) enum { sent, busy, loop } {
- if (slot.banded) return .loop;
- // A lane's first job parses the document again and loads its fonts:
- // a second cold lane beside the first only slowed both (the SDM's
- // first page 1.7 -> 2.5 s in Debug), so a lane starts once the one
- // before it is warm.
- const lane = for (&state.lanes, 0..) |*l, i| {
- if (l.job == null and (l.doc != null or i == 0 or state.lanes[i - 1].warm)) break l;
- } else return .busy;
- if (lane.doc == null) lane.doc = state.document.laneClone() catch return .loop;
- const highlights = gpa.dupe(Highlight, page_highlights) catch return .loop;
- const job = gpa.create(Job) catch {
- gpa.free(highlights);
- return .loop;
- };
- state.render_gen +%= 1;
- if (state.render_gen == 0) state.render_gen = 1;
- // A spare is handed over: the lane keeps it if it is the page's size
- // (most pages of a document are), else frees it and allocates.
- const spare: []u8 = if (state.spare_len > 0) spare: {
- state.spare_len -= 1;
- break :spare state.spare[state.spare_len];
- } else &.{};
- job.* = .{
- .gen = state.render_gen,
- .page = slot.page,
- .request = request,
- .tint_key = tint_key,
- .highlights = highlights,
- .keep_clean = keep_clean,
- .rgba = spare,
- };
- lane.future = io.concurrent(renderJob, .{ lane.doc.?, job, gpa }) catch {
- state.retireRgba(gpa, spare);
- gpa.free(highlights);
- gpa.destroy(job);
- return .loop;
- };
- lane.job = job;
- lane.io = io;
- slot.pending = job.gen;
- return .sent;
-}
-
-/// The sizes landed: laid out again where the view is, by page and offset
-/// in it (a Look made meanwhile landed on the assumed layout and stays on
-/// its page), and the strip's glide carries on through it (`ensureLayout`).
-/// A document whose pages are all one size never gets here.
-pub fn applySizes(state: *State, gpa: std.mem.Allocator) void {
- if (comptime !enabled) return;
- if (state.sizes_ready.len == 0) return;
- if (state.layout_valid and !state.scroll_to_page_pending and !state.layout_anchor_pending) captureLayoutAnchor(state);
- @memcpy(state.page_sizes, state.sizes_ready);
- gpa.free(state.sizes_ready);
- state.sizes_ready = &.{};
- state.layout_valid = false;
- state.relayout_keeps_motion = true;
-}
-
-/// The sizes of every page, measured on the last lane (its first job, so
-/// its document's page tree is loaded when it starts rendering).
-fn submitSizes(state: *State, gpa: std.mem.Allocator, io: std.Io) void {
- const lane = &state.lanes[lane_count - 1];
- if (lane.job != null) return;
- if (lane.doc == null) lane.doc = state.document.laneClone() catch return;
- const job = gpa.create(Job) catch return;
- state.render_gen +%= 1;
- if (state.render_gen == 0) state.render_gen = 1;
- job.* = .{ .kind = .sizes, .gen = state.render_gen, .page = 0, .request = .{}, .tint_key = .{ .mode = .disabled, .colors = undefined }, .highlights = &.{}, .keep_clean = false, .rgba = &.{} };
- lane.future = io.concurrent(renderJob, .{ lane.doc.?, job, gpa }) catch {
- gpa.destroy(job);
- // No lane: measured here after all.
- for (state.page_sizes, 0..) |*size, page| size.* = state.document.pageSize(page) catch size.*;
- state.sizes_pending = false;
- state.layout_valid = false;
- return;
- };
- lane.job = job;
- lane.io = io;
- state.sizes_gen = job.gen;
-}
-
-/// A lane's thread: the page rendered whole into the job's buffer, its
-/// clean copy kept, highlighted and tinted, all as `reconcile` does on the
-/// loop, under the job's cookie. It touches the job and the lane's own
-/// document (`doc` is a copy of its handle), nothing of the State.
-fn renderJob(lane_doc: Document, job: *Job, gpa: std.mem.Allocator) void {
- const tz = tracy.zone(@src(), "pdf.lane_render");
- defer tz.end();
- var doc = lane_doc;
- defer job.done.store(true, .release);
- doc.laneOpen() catch return;
- if (job.kind == .sizes) {
- job.sizes = gpa.alloc(pdf.PageSize, doc.pages) catch return;
- for (job.sizes, 0..) |*size, page| {
- if (page % 64 == 0 and @atomicLoad(c_int, &job.cookie.abort, .acquire) != 0) return;
- size.* = doc.pageSize(page) catch return;
- }
- job.ok = true;
- return;
- }
- doc.setCookie(&job.cookie);
- defer doc.setCookie(null);
- // Measured here, on the lane's own document: loading a page (its links
- // and annotations) cost the loop 6-7 ms a page of the SDM in Debug.
- job.shape = doc.measureRenderAt(job.page, job.request) catch return;
- if (isBanded(job.shape)) {
- job.banded = true;
- return;
- }
- if (job.rgba.len != job.shape.len) {
- if (job.rgba.len > 0) gpa.free(job.rgba);
- job.rgba = &.{};
- job.rgba = pardes.memory.unfilled(gpa, job.shape.len) catch return;
- }
- const band = job.shape.wholePage();
- doc.renderIntoAtWithPaper(job.page, job.request, job.shape, band, if (job.keep_clean) &.{} else job.highlights, job.rgba, pardes.platform == .macos) catch return;
- if (job.keep_clean) {
- job.clean = pardes.memory.dupeUnfilled(gpa, job.rgba) catch return;
- doc.paintHighlightsAt(job.page, job.request, job.shape, band, job.highlights, job.rgba) catch return;
- }
- pdf.tintRgba(job.rgba, job.tint_key.mode, job.tint_key.colors) catch return;
- job.ok = true;
-}
-
-/// The jobs that are done, joined (a return away) and landed.
-fn collect(state: *State, gpa: std.mem.Allocator) void {
- for (&state.lanes) |*lane| {
- const job = lane.job orelse continue;
- if (!job.done.load(.acquire)) continue;
- lane.future.?.await(lane.io);
- lane.future = null;
- lane.job = null;
- lane.warm = true;
- land(state, gpa, job);
- }
-}
-
-/// A job's raster into the slot waiting for its generation, swapped in
-/// whole (no pixel is copied on the loop); a stale, failed or aborted one
-/// is dropped. Frees the job.
-fn land(state: *State, gpa: std.mem.Allocator, job: *Job) void {
- const tz = tracy.zone(@src(), "pdf.land");
- defer tz.end();
- defer gpa.destroy(job);
- if (job.kind == .sizes) {
- defer if (job.sizes.len > 0) gpa.free(job.sizes);
- if (job.gen == 0 or job.gen != state.sizes_gen) return;
- state.sizes_pending = false;
- if (!job.ok or job.sizes.len != state.page_count) return; // ponytail: the assumed sizes stay
- if (std.mem.eql(u8, std.mem.sliceAsBytes(job.sizes), std.mem.sliceAsBytes(state.page_sizes))) return;
- // Applied by the next draw, before it lays out (`applySizes`): here
- // the strip may stand where it is drawn, not where the core is.
- if (state.sizes_ready.len > 0) gpa.free(state.sizes_ready);
- state.sizes_ready = job.sizes;
- job.sizes = &.{};
- return;
- }
- const slot: ?*Raster = if (job.gen == 0) null else for (state.rasters[0..state.rasters_len]) |*r| {
- if (r.valid and r.pending == job.gen) break r;
- } else null;
- if (slot == null or !job.ok) {
- if (slot) |s| {
- s.pending = 0;
- s.banded = job.banded;
- if (@atomicLoad(c_int, &job.cookie.abort, .acquire) == 0 and !job.banded) {
- s.failed = true;
- s.tried = true;
- s.request = job.request;
- s.request_valid = true;
- }
- }
- state.retireRgba(gpa, job.rgba);
- if (job.clean.len > 0) gpa.free(job.clean);
- gpa.free(job.highlights);
- return;
- }
- const s = slot.?;
- s.pending = 0;
- s.failed = false;
- s.tried = true;
- state.retireRgba(gpa, s.rgba);
- s.rgba = job.rgba;
- if (s.clean.len > 0) gpa.free(s.clean);
- s.clean = job.clean;
- s.iw = job.shape.width;
- s.ih = job.shape.height;
- s.band_y = 0;
- s.band_h = job.shape.height;
- s.request = job.request;
- s.request_valid = true;
- s.tint_key = job.tint_key;
- s.decorated = job.highlights.len > 0;
- gpa.free(s.baked);
- s.baked = job.highlights;
- s.baked_valid = true;
- s.patch_from = 0;
- s.patch_rows = .{ .start = 0, .end = 0 };
- state.next_raster_revision +%= 1;
- if (state.next_raster_revision == 0) state.next_raster_revision = 1;
- s.revision = state.next_raster_revision;
- state.landed +|= 1;
-}
-
-/// A job no slot waits for any more (its page left the strip, its request
-/// changed) is told to stop: MuPDF sees the cookie at its next operator.
-fn sweep(state: *State) void {
- for (state.lanes) |lane| if (lane.job) |job| if (job.kind == .render) {
- const wanted = for (state.rasters[0..state.rasters_len]) |r| {
- if (r.valid and r.pending == job.gen) break true;
- } else false;
- if (!wanted) @atomicStore(c_int, &job.cookie.abort, 1, .release);
- };
-}
-
-/// Some page of this State is being rendered on a lane (the frames after
-/// look for it, as a picture's decode is looked for).
-pub fn rendering(state: *const State) bool {
- if (comptime !enabled) return false;
- for (state.lanes) |lane| if (lane.job != null) return true;
- return false;
-}
-
-/// Repaint only the rows where the old and new highlights differ: the
-/// clean rows kept from the page's last render, MuPDF's highlight pass
-/// (the whole new set) over them, the per-pixel tint — the operations a
-/// full render performs, in its order, on fewer rows and without running
-/// the page again. False leaves the slot for the full path.
-fn repaintHighlights(
- state: *State,
- gpa: std.mem.Allocator,
- slot: *Raster,
- request: RenderRequest,
- tint_key: TintKey,
- page_highlights: []const Highlight,
-) bool {
- const tz = tracy.zone(@src(), "pdf.repaint_highlights");
- defer tz.end();
- if (slot.clean.len != slot.rgba.len or !slot.baked_valid) return false;
- if (sameHighlights(slot.baked, page_highlights)) {
- slot.tried = true;
- return true;
- }
- const baked = gpa.dupe(Highlight, page_highlights) catch return false;
- const changed = changedHighlights(gpa, slot.baked, page_highlights) catch {
- gpa.free(baked);
- return false;
- };
- defer gpa.free(changed);
- var dirty = state.document.highlightRows(slot.page, request, changed) catch {
- gpa.free(baked);
- return false;
- };
- slot.tried = true;
- dirty.start = @max(dirty.start, slot.band_y);
- dirty.end = @min(dirty.end, slot.band_y + slot.band_h);
- if (dirty.start < dirty.end) {
- const shape = slotShape(slot);
- const band = shape.band(dirty.start, dirty.end - dirty.start);
- const offset = (dirty.start - slot.band_y) * shape.stride;
- const out = slot.rgba[offset..][0..band.len];
- @memcpy(out, slot.clean[offset..][0..band.len]);
- // On failure the rows are half-made: let the full path redo them.
- state.document.paintHighlightsAt(slot.page, request, shape, band, page_highlights, out) catch {
- gpa.free(baked);
- slot.tried = false;
- return false;
- };
- pdf.tintRgba(out, tint_key.mode, tint_key.colors) catch {
- gpa.free(baked);
- slot.tried = false;
- return false;
- };
- slot.patch_rows = unionRows(slot.patch_rows, dirty);
- state.next_raster_revision +%= 1;
- if (state.next_raster_revision == 0) state.next_raster_revision = 1;
- slot.revision = state.next_raster_revision;
- }
- gpa.free(slot.baked);
- slot.baked = baked;
- slot.decorated = page_highlights.len > 0;
- return true;
-}
-
-fn sameHighlights(a: []const Highlight, b: []const Highlight) bool {
- return std.mem.eql(u8, std.mem.sliceAsBytes(a), std.mem.sliceAsBytes(b));
-}
-
-/// The highlights in one set and not the other, as multisets (a quad
-/// painted twice blends twice). When only the order changed, blending
-/// order did, so everything counts.
-// ponytail: quadratic match; past 64k comparisons every quad counts.
-fn changedHighlights(gpa: std.mem.Allocator, old: []const Highlight, new: []const Highlight) ![]Highlight {
- const out = try gpa.alloc(Highlight, old.len + new.len);
- errdefer gpa.free(out);
- var n: usize = 0;
- if (old.len * new.len <= 1 << 16) {
- const matched = try gpa.alloc(bool, new.len);
- defer gpa.free(matched);
- @memset(matched, false);
- for (old) |h| {
- for (new, matched) |candidate, *used| {
- if (!used.* and std.mem.eql(u8, std.mem.asBytes(&h), std.mem.asBytes(&candidate))) {
- used.* = true;
- break;
- }
- } else {
- out[n] = h;
- n += 1;
- }
- }
- for (new, matched) |h, used| if (!used) {
- out[n] = h;
- n += 1;
- };
- }
- if (n == 0) {
- @memcpy(out[0..old.len], old);
- @memcpy(out[old.len..], new);
- return out;
- }
- // Freed by length: hand back exactly what the caller will free.
- return gpa.realloc(out, n);
-}
-
-fn unionRows(a: pdf.Document.Rows, b: pdf.Document.Rows) pdf.Document.Rows {
- if (a.start >= a.end) return b;
- if (b.start >= b.end) return a;
- return .{ .start = @min(a.start, b.start), .end = @max(a.end, b.end) };
-}
-
-pub fn renderFrame(
- state: *State,
- gpa: std.mem.Allocator,
- arena: std.mem.Allocator,
- viewport: Viewport,
- policy: RasterPolicy,
- tint_key: TintKey,
- highlight_input: HighlightInput,
- path: f64,
- far: bool,
-) VisiblePages {
- if (comptime !enabled) return .{};
- ensureLayout(state, viewport);
- state.resolveSearch(gpa);
- const highlights = buildHighlights(state, arena, highlight_input) catch Highlights{};
- const request = renderRequest(viewport, policy, state.fit);
- // ponytail: every page the glide crosses to its mark (`path` pixels
- // on) renders now, in the input's frame, so no frame of the glide
- // waits on MuPDF (it renders on the loop). A far jump's slide (`far`)
- // comes in over what is there, none of the page above its mark, which
- // would cost the input's frame a page; a render thread would draw it.
- const span = struct {
- fn f(st: *const State, view: Viewport, along: f64, from_rest: bool) VisiblePages {
- const h: f64 = @floatFromInt(view.pixel_h);
- return if (from_rest) pagesOver(st, st.document_scroll_y + along, h) else pagesOver(st, st.document_scroll_y + @min(0, along), h + @abs(along));
- }
- }.f;
- // Off the loop, the page past the strip the way it last went is asked
- // for too, after the ones in view: rendered ahead, as paint-ahead does.
- const ahead = struct {
- fn f(st: *const State, v: VisiblePages) VisiblePages {
- if (workers == null or v.len == 0) return v;
- if (st.ahead > 0 and v.first + v.len < st.page_count) return .{ .first = v.first, .len = v.len + 1 };
- if (st.ahead < 0 and v.first > 0) return .{ .first = v.first - 1, .len = v.len + 1 };
- return v;
- }
- }.f;
- var visible = span(state, viewport, path, far);
- reconcile(state, gpa, request, tint_key, highlights, ahead(state, visible), viewport);
-
- rearmSearchReveal(state, viewport);
- revealSearch(state, viewport, activeGeometry(state, viewport));
- visible = span(state, viewport, path, far);
- reconcile(state, gpa, request, tint_key, highlights, ahead(state, visible), viewport);
- return visible;
-}
-
-pub fn normalizedPixel(value: f32, dimension: usize) u32 {
- const scaled = std.math.clamp(value, 0, 1) * @as(f32, @floatFromInt(dimension));
- return @intCast(@min(dimension - 1, @as(usize, @intFromFloat(scaled))));
-}
-
-pub fn scaledStep(base: u32, count: u32) u32 {
- return @intCast(@min(
- @as(u64, std.math.maxInt(u32)),
- @as(u64, base) * @max(@as(u64, 1), count),
- ));
-}
-
-pub fn scrollDocument(state: *State, viewport: Viewport, delta_pixels: f64) ?ScrollResult {
- if (comptime !enabled) return null;
- if (!std.math.isFinite(delta_pixels) or delta_pixels == 0) return null;
- const max_scroll = @as(f64, @floatFromInt(state.document_height -| viewport.pixel_h));
- const next = std.math.clamp(state.document_scroll_y + delta_pixels, 0, max_scroll);
- if (next == state.document_scroll_y) return null;
- state.scroll_travel += @abs(next - state.document_scroll_y);
- state.document_scroll_y = next;
- return .{ .active_page = pageAtOffset(state, next) };
-}
-
-pub fn panPixels(
- state: *State,
- geometry: surface.NativeGeometry,
- axis: PanAxis,
- direction: i8,
- display_pixels: u32,
-) PanResult {
- if (comptime !enabled) return .unavailable;
- const raster = rasterForPage(state, state.page) orelse return .unavailable;
- const source_full: u32 = @intCast(switch (axis) {
- .horizontal => raster.iw,
- .vertical => raster.ih,
- });
- const crop = switch (axis) {
- .horizontal => geometry.src.w,
- .vertical => geometry.src.h,
- };
- const source_at = switch (axis) {
- .horizontal => geometry.src.x,
- .vertical => geometry.src.y,
- };
- const displayed = @max(@as(u32, 1), switch (axis) {
- .horizontal => geometry.dst.w,
- .vertical => geometry.dst.h,
- });
- const overflow = source_full -| crop;
- if (overflow == 0 or
- (direction < 0 and source_at == 0) or
- (direction > 0 and source_at >= overflow)) return .edge;
-
- const source_step = @max(
- @as(u64, 1),
- (@as(u64, display_pixels) * @as(u64, crop) + displayed - 1) / displayed,
- );
- const normalized_step: u32 = @intCast(@min(
- @as(u64, std.math.maxInt(u16)),
- @max(
- @as(u64, 1),
- (source_step * std.math.maxInt(u16) + overflow - 1) / overflow,
- ),
- ));
- const position = switch (axis) {
- .horizontal => &state.pan_x,
- .vertical => &state.pan_y,
- };
- if (direction > 0) {
- position.* = @intCast(@min(
- @as(u32, std.math.maxInt(u16)),
- @as(u32, position.*) + normalized_step,
- ));
- } else {
- position.* -|= @intCast(normalized_step);
- }
- return .moved;
-}
-
-fn setHorizontalEdge(state: *State, geometry: surface.NativeGeometry, end: bool) void {
- if (comptime !enabled) return;
- const raster = rasterForPage(state, state.page) orelse return;
- if (raster.iw <= geometry.src.w) return;
- state.pan_x = if (end) std.math.maxInt(u16) else 0;
-}
-
-fn rearmSearchReveal(state: *State, viewport: Viewport) void {
- if (comptime !enabled) return;
- if (state.search_query.len == 0) return;
- if (!state.reveal_viewport_valid or
- state.reveal_viewport_w != viewport.pixel_w or
- state.reveal_viewport_h != viewport.pixel_h or
- state.reveal_fit != state.fit)
- state.search_reveal_pending = true;
-}
-
-pub fn revealSearch(
- state: *State,
- viewport: Viewport,
- geometry: ?surface.NativeGeometry,
-) void {
- if (comptime !enabled) return;
- if (!state.search_reveal_pending) return;
- state.reveal_viewport_w = viewport.pixel_w;
- state.reveal_viewport_h = viewport.pixel_h;
- state.reveal_fit = state.fit;
- state.reveal_viewport_valid = true;
- const results = state.search_results orelse {
- state.search_reveal_pending = false;
- return;
- };
- if (results.hit_count == 0 or results.quads.len == 0) {
- state.search_reveal_pending = false;
- return;
- }
- state.search_hit = @min(state.search_hit, results.hit_count - 1);
- const q = for (results.quads) |item| {
- if (item.hit == state.search_hit) break item.quad;
- } else {
- state.search_reveal_pending = false;
- return;
- };
- state.search_reveal_pending = false;
- const center_x = (q.ul.x + q.ur.x + q.ll.x + q.lr.x) / 4;
- const center_y = (q.ul.y + q.ur.y + q.ll.y + q.lr.y) / 4;
- if (state.fit == .width) {
- ensureLayout(state, viewport);
- const page_y = @as(f64, @floatFromInt(state.page_starts[state.page])) +
- @as(f64, center_y) * @as(f64, @floatFromInt(state.page_heights[state.page]));
- const wanted = page_y - @as(f64, @floatFromInt(viewport.pixel_h)) / 2;
- const max_scroll = @as(f64, @floatFromInt(state.document_height -| viewport.pixel_h));
- state.document_scroll_y = std.math.clamp(wanted, 0, max_scroll);
- return;
- }
- const placed = geometry orelse return;
- const raster = rasterForPage(state, state.page) orelse return;
- const full: u32 = @intCast(raster.iw);
- const at = normalizedPixel(center_x, raster.iw);
- if (at >= placed.src.x and at < placed.src.x + placed.src.w) return;
- const overflow = full -| placed.src.w;
- if (overflow == 0) return;
- const wanted = @min(overflow, at -| placed.src.w / 2);
- state.pan_x = @intCast(
- (@as(u64, wanted) * std.math.maxInt(u16) + overflow / 2) / overflow,
- );
-}
-
-pub fn stepPage(state: *State, gpa: std.mem.Allocator, delta: i64) bool {
- const current: i64 = @intCast(state.page);
- const last: i64 = @intCast(state.page_count -| 1);
- return state.activatePage(
- gpa,
- @intCast(std.math.clamp(current + delta, 0, last)),
- true,
- );
-}
-
-fn scrollNormal(
- state: *State,
- gpa: std.mem.Allocator,
- viewport: ?Viewport,
- delta_pixels: f64,
-) bool {
- const view = viewport orelse return false;
- ensureLayout(state, view);
- const result = scrollDocument(state, view, delta_pixels) orelse return false;
- return result.active_page != state.page and
- state.activatePage(gpa, result.active_page, false);
-}
-
-fn moveRows(
- state: *State,
- gpa: std.mem.Allocator,
- native_images: bool,
- viewport: ?Viewport,
- cell_pixels: CellPixels,
- direction: i8,
- count: u32,
-) bool {
- if (!native_images) {
- const pages: i64 = @intCast(@max(@as(u32, 1), count));
- return stepPage(state, gpa, if (direction > 0) pages else -pages);
- }
- return scrollNormal(
- state,
- gpa,
- viewport,
- @as(f64, @floatFromInt(scaledStep(cell_pixels.h, count))) * direction,
- );
-}
-
-fn movePage(
- state: *State,
- gpa: std.mem.Allocator,
- native_images: bool,
- viewport: ?Viewport,
- cell_pixels: CellPixels,
- direction: i8,
- half: bool,
- count: u32,
-) bool {
- if (!native_images) {
- const pages: i64 = @intCast(@max(@as(u32, 1), count));
- return stepPage(state, gpa, if (direction > 0) pages else -pages);
- }
- const base: u32 = if (viewport) |view|
- (if (half) @max(@as(u32, 1), view.pixel_h / 2) else view.pixel_h)
- else
- cell_pixels.h;
- return scrollNormal(
- state,
- gpa,
- viewport,
- @as(f64, @floatFromInt(scaledStep(base, count))) * direction,
- );
-}
-
-/// A normal-mode command in a PDF pane: the page moves, or the session is
-/// asked for what a page cannot do (Last, the leader, the tag, a search).
-pub fn applyNormal(core: *pardes.Pardes, pane: *pardes.Pane, a: modal.Normal.Action) void {
- const v = core.view();
- if (comptime !enabled) return;
- const state = pane.pdf orelse return;
- const gpa = core.pdf_gpa;
- const native = v.frontend.native_images;
- const cells: CellPixels = .{ .w = v.cell_pixels.w, .h = v.cell_pixels.h };
- const viewport = paneViewport(core, pane);
- const placed = if (native) paneGeometry(core, pane) else null;
- const page_changed = switch (a.role) {
- // Esc drops a selection or a search the page shows, else goes back
- // a pane (text-only, the page shows neither); typed again by a
- // macro, Esc is only the page's.
- .escape => {
- if ((!state.cancelChrome(gpa) or !native) and core.macro.replaying == 0) exec.runBuiltin(core, .Last, v.active, "", null);
- return;
- },
- .move_down, .goto_line_down => moveRows(state, gpa, native, viewport, cells, 1, a.count),
- .move_up, .goto_line_up => moveRows(state, gpa, native, viewport, cells, -1, a.count),
- .view_scroll_down => moveRows(state, gpa, native, viewport, cells, 1, 1),
- .view_scroll_up => moveRows(state, gpa, native, viewport, cells, -1, 1),
- .move_left, .move_right => {
- if (placed) |g| _ = panPixels(state, g, .horizontal, if (a.role == .move_left) -1 else 1, scaledStep(cells.w, a.count));
- return;
- },
- .goto_line_start, .goto_first_nonws, .line_start, .line_first_nonws, .goto_line_end, .line_end => {
- if (placed) |g| setHorizontalEdge(state, g, a.role == .goto_line_end or a.role == .line_end);
- return;
- },
- .goto_file_start => state.activatePage(gpa, if (a.explicit) a.count -| 1 else 0, true),
- .goto_line => a.explicit and state.activatePage(gpa, a.count -| 1, true),
- .goto_last_line => state.activatePage(gpa, state.page_count -| 1, true),
- .half_page_down, .page_down => movePage(state, gpa, native, viewport, cells, 1, a.role == .half_page_down, a.count),
- .half_page_up, .page_up => movePage(state, gpa, native, viewport, cells, -1, a.role == .half_page_up, a.count),
- .leader => {
- v.prefix = .leader;
- v.leader_n = 0;
- return;
- },
- .command_line => return tagline.enterTag(core, pane),
- .search => return panes.startPrompt(core, pane, &pane.body, .{ .search = config.search_marker }),
- .search_next, .search_prev => return look.lookWalk(core, if (a.role == .search_next) 1 else -1),
- else => false,
- };
- if (page_changed) resetPageChrome(pane);
-}
-
-pub fn captureLayoutAnchor(state: *State) void {
- if (comptime !enabled) return;
- if (!state.layout_valid or state.page_count == 0 or state.document_height == 0) return;
- const page = pageAtOffset(state, state.document_scroll_y);
- const start: f64 = @floatFromInt(state.page_starts[page]);
- const height: f64 = @floatFromInt(@max(@as(u32, 1), state.page_heights[page]));
- state.layout_anchor_page = page;
- state.layout_anchor_fraction = std.math.clamp((state.document_scroll_y - start) / height, 0, 1);
- state.layout_anchor_pending = true;
-}
-
-fn consumeOutlineReveal(state: *State, viewport: Viewport) void {
- const destination = state.outline_reveal_pending orelse return;
- state.outline_reveal_pending = null;
- const page = @min(destination.page, state.page_count -| 1);
- const size = state.page_sizes[page];
- const raw_y = destination.y orelse 0;
- const y = if (std.math.isFinite(raw_y)) std.math.clamp(raw_y, 0, size.height) else 0;
- state.document_scroll_y = @as(f64, @floatFromInt(state.page_starts[page])) +
- @as(f64, y) / @as(f64, size.height) * @as(f64, @floatFromInt(state.page_heights[page]));
-
- if (destination.x) |raw_x| if (state.fit == .height and std.math.isFinite(raw_x)) {
- const display_width = @as(f64, @floatFromInt(viewport.pixel_h)) *
- @as(f64, size.width) / @as(f64, size.height);
- const viewport_width: f64 = @floatFromInt(viewport.pixel_w);
- if (display_width > viewport_width) {
- const x = std.math.clamp(raw_x, 0, size.width);
- const target = @as(f64, x) / @as(f64, size.width) * display_width;
- const overflow = display_width - viewport_width;
- const wanted = std.math.clamp(target - viewport_width / 2, 0, overflow);
- state.pan_x = @intFromFloat(@round(
- wanted / overflow * @as(f64, std.math.maxInt(u16)),
- ));
- }
- };
- state.search_reveal_pending = false;
- state.reveal_viewport_w = viewport.pixel_w;
- state.reveal_viewport_h = viewport.pixel_h;
- state.reveal_fit = state.fit;
- state.reveal_viewport_valid = true;
-}
-
-pub fn ensureLayout(state: *State, viewport: Viewport) void {
- if (comptime !enabled) return;
- const tz = tracy.zone(@src(), "pdf.ensure_layout");
- defer tz.end();
- var relaid = false;
- const before = state.document_scroll_y;
- if (state.layout_valid and !state.scroll_to_page_pending and
- !state.layout_anchor_pending and
- (state.layout_viewport_w != viewport.pixel_w or
- state.layout_viewport_h != viewport.pixel_h)) captureLayoutAnchor(state);
- if (!state.layout_valid or state.layout_viewport_w != viewport.pixel_w or
- state.layout_viewport_h != viewport.pixel_h or state.layout_fit != state.fit)
- {
- var at: u64 = 0;
- for (state.page_sizes, 0..) |size, page| {
- state.page_starts[page] = at;
- const height = pageHeight(size, viewport, state.fit);
- state.page_heights[page] = height;
- at = std.math.add(u64, at, height) catch std.math.maxInt(u64);
- if (page + 1 < state.page_count)
- at = std.math.add(u64, at, page_gap_px) catch std.math.maxInt(u64);
- }
- state.document_height = at;
- state.layout_viewport_w = viewport.pixel_w;
- state.layout_viewport_h = viewport.pixel_h;
- state.layout_fit = state.fit;
- state.layout_valid = true;
- relaid = true;
- if (state.scroll_to_page_pending) {
- state.document_scroll_y = @floatFromInt(state.page_starts[state.page]);
- state.scroll_to_page_pending = false;
- state.layout_anchor_pending = false;
- } else if (state.layout_anchor_pending) {
- const page = @min(state.layout_anchor_page, state.page_count -| 1);
- state.document_scroll_y = @as(f64, @floatFromInt(state.page_starts[page])) +
- state.layout_anchor_fraction * @as(f64, @floatFromInt(state.page_heights[page]));
- state.layout_anchor_pending = false;
- }
- }
- consumeOutlineReveal(state, viewport);
- const max_scroll = @as(f64, @floatFromInt(state.document_height -| viewport.pixel_h));
- state.document_scroll_y = std.math.clamp(state.document_scroll_y, 0, max_scroll);
- // A new layout is not a scroll: the picture is drawn there at once.
- // Unless the sizes landed under it: then the strip, wherever it is in
- // its glide, moves with the place it is heading for.
- if (relaid and state.relayout_keeps_motion) {
- state.drawn_y += state.document_scroll_y - before;
- state.relayout_keeps_motion = false;
- } else if (relaid) {
- state.drawn_y = state.document_scroll_y;
- state.direct_y = 0;
- }
-}
-
-pub const WordProbe = if (enabled) struct {
- page: usize,
- quads: []pdf.Quad,
- text: []u8,
- link: ?pdf.Link = null,
-
- pub fn deinit(probe: *@This(), gpa: std.mem.Allocator) void {
- if (probe.link) |*link| link.deinit(gpa);
- gpa.free(probe.quads);
- gpa.free(probe.text);
- probe.* = undefined;
- }
-} else void;
-
-pub const PointerDrag = if (enabled) struct {
- native: bool = false,
- /// Right-button Look probes this cell on release without borrowing or
- /// replacing the pane's persistent MuPDF selection.
- word_at: ?struct { col: u16, row: u16 } = null,
- /// Drag updates keep selection geometry/text live, but their expensive
- /// baked raster highlight is committed once on release.
- selection_changed: bool = false,
-} else struct {};
-
-pub const PointerAction = enum { look, exec };
-
-pub const PointerRelease = if (enabled) struct {
- action: ?PointerAction = null,
- text: []const u8 = &.{},
- probe: ?WordProbe = null,
-
- pub fn deinit(release: *@This(), gpa: std.mem.Allocator) void {
- if (release.probe) |*probe| probe.deinit(gpa);
- release.* = undefined;
- }
-} else struct {
- pub fn deinit(_: *@This(), _: std.mem.Allocator) void {}
-};
-
-pub fn probeWord(
- document: *Document,
- gpa: std.mem.Allocator,
- page: usize,
- point: if (enabled) pdf.Point else void,
-) !?WordProbe {
- if (comptime !enabled) return null;
- var selection = try document.select(gpa, page, point, point);
- errdefer selection.deinit(gpa);
- const text = try document.copySelection(gpa, page, selection.start, selection.end);
- errdefer gpa.free(text);
- if (selection.quads.len == 0 or text.len == 0) {
- selection.deinit(gpa);
- gpa.free(text);
- return null;
- }
- // Transfer the quad allocation out of Selection. There is intentionally
- // no Selection.deinit on this success path: WordProbe is now its owner.
- return .{ .page = page, .quads = selection.quads, .text = text };
-}
-
-pub fn pointAtGeometry(
- geometry: surface.NativeGeometry,
- pixel_offset_y: f32,
- full_width: usize,
- full_height: usize,
- band_y: usize,
- pixel_x: i64,
- pixel_y: i64,
- clamp_to_page: bool,
-) ?Point {
- if (comptime !enabled) return null;
- if (full_width == 0 or full_height == 0 or
- geometry.src.w == 0 or geometry.src.h == 0 or
- geometry.dst.w == 0 or geometry.dst.h == 0) return null;
-
- const left: f64 = @floatFromInt(geometry.dst.x);
- const top: f64 = @floatFromInt(geometry.dst.y);
- const right = left + @as(f64, @floatFromInt(geometry.dst.w));
- const bottom = top + @as(f64, @floatFromInt(geometry.dst.h));
- var x: f64 = @floatFromInt(pixel_x);
- var y: f64 = @as(f64, @floatFromInt(pixel_y)) - @as(f64, pixel_offset_y);
- if (clamp_to_page) {
- // Half-open rectangles: keep a clamped point infinitesimally inside
- // the last presented pixel instead of letting it become `right`.
- const epsilon = 1.0 / 1024.0;
- x = std.math.clamp(x, left, @max(left, right - epsilon));
- y = std.math.clamp(y, top, @max(top, bottom - epsilon));
- } else if (x < left or x >= right or y < top or y >= bottom) {
- return null;
- }
-
- const source_x_f = @as(f64, @floatFromInt(geometry.src.x)) +
- (x - left) * @as(f64, @floatFromInt(geometry.src.w)) /
- @as(f64, @floatFromInt(geometry.dst.w));
- const source_y_f = @as(f64, @floatFromInt(geometry.src.y)) +
- (y - top) * @as(f64, @floatFromInt(geometry.src.h)) /
- @as(f64, @floatFromInt(geometry.dst.h));
- const source_x: usize = @min(full_width - 1, @as(usize, @intFromFloat(@floor(source_x_f))));
- const band_source_y: usize = @intFromFloat(@floor(source_y_f));
- const source_y = @min(full_height - 1, band_y + band_source_y);
- return .{
- .x = (@as(f32, @floatFromInt(source_x)) + 0.5) /
- @as(f32, @floatFromInt(full_width)),
- .y = (@as(f32, @floatFromInt(source_y)) + 0.5) /
- @as(f32, @floatFromInt(full_height)),
- };
-}
-
-pub fn openPane(
- core: *pardes.Pardes,
- id: usize,
- path: []const u8,
- page_one_based: usize,
- /// A page past the last: the last page (a restore, a start-up), or
- /// refused with error.NoSuchPage (a look, which names a place).
- past_end: enum { last, refuse },
-) !*pardes.Pane {
- if (comptime !enabled) return error.PdfDisabled;
- // The slot stays ours across the read: another request may make a
- // pane meanwhile.
- core.reserved_slots[id] = true;
- defer core.reserved_slots[id] = false;
- const state = try core.pdf_gpa.create(State);
- errdefer core.pdf_gpa.destroy(state);
- state.* = if (filesystem.localPath(path) != null)
- try State.open(core.pdf_gpa, path, page_one_based)
- else virtual: {
- const bytes = try filesystem.read(core, path);
- defer core.gpa.free(bytes);
- break :virtual try State.openBytes(core.pdf_gpa, path, bytes, page_one_based);
- };
- errdefer state.deinit(core.pdf_gpa);
- if (past_end == .refuse and page_one_based > state.page_count) return error.NoSuchPage;
- const pane = try core.newDocPane(id);
- pane.pdf = state;
- pane.body.cur_pinned = true;
- if (filesystem.localPath(path) != null) core.emit(.{ .watch = .{ .pane = @intCast(id), .on = true } });
- return pane;
-}
-
-/// The file on disk is still the one the pane read (`fileKey`): a watch
-/// armed over it has nothing to reload.
-pub fn sameBytes(core: *pardes.Pardes, pane: *const pardes.Pane) bool {
- if (comptime !enabled) return false;
- const state = if (pane.pdf) |pv| pv else return false;
- if (state.file == 0) return false;
- const bytes = filesystem.read(core, state.path) catch return false;
- defer core.gpa.free(bytes);
- return fileKey(state.path, bytes) == state.file;
-}
-
-/// Release a PDF payload while its pane slot is still installed, so the host
-/// can retire the corresponding directory watch before that id is reused.
-pub fn deinitPane(core: *pardes.Pardes, pane: *pardes.Pane, state: *State) void {
- if (comptime !enabled) return;
- if (panes.paneIdOf(core, pane)) |id| core.emit(.{ .watch = .{ .pane = @intCast(id), .on = false } });
- state.deinit(core.pdf_gpa);
- core.pdf_gpa.destroy(state);
- pane.pdf = null;
-}
-
-/// A PDF pane loaded from a dump given its document again (MuPDF's, so
-/// never in the dump) from its file; one changed since is laid out anew.
-pub fn reopen(core: *pardes.Pardes, pane: *pardes.Pane) !void {
- if (comptime !enabled) return;
- const state = pane.pdf orelse return;
- const local = filesystem.localPath(state.path) orelse return error.NonLocalPath;
- const bytes = try filesystem.readFile(core.pdf_gpa, local);
- defer core.pdf_gpa.free(bytes);
- state.document = try Document.openBytes(bytes);
- if (state.document.pages != state.page_count or fileKey(state.path, bytes) != state.file) {
- try state.reload(core.pdf_gpa);
- }
-}
-
-pub fn isSectionsOutput(pane: *const pardes.Pane) bool {
- if (comptime !enabled) return false;
- const file = pane.file orelse return false;
- const output = file.output orelse return false;
- return switch (output.from) {
- .cmd => |builtin| builtin == .PdfSections,
- else => false,
- };
-}
-
-fn refreshCleanSections(core: *pardes.Pardes, state: *State) void {
- if (comptime !enabled) return;
- const remembered = state.sections_output orelse return;
- if (remembered.pane >= core.panes.len) return;
- const result = core.panes[remembered.pane] orelse return;
- if (result.serial != remembered.serial or !isSectionsOutput(result)) return;
- const file = &result.file.?;
- if (file.revision != remembered.revision) return;
-
- const content = state.renderSections(core.pdf_gpa, core.gpa) catch {
- state.sections_output = null;
- return;
- };
- if (std.mem.eql(u8, file.content, content)) {
- core.gpa.free(content);
- return;
- }
- look.invalidateLookHover(core, remembered.pane);
- File.setContent(core, file, content);
- const rows = File.lineCount(file.content);
- file.scroll = @min(file.scroll, rows - 1);
- const row = @min(@as(usize, @intCast(@max(0, result.body.cur_row))), rows - 1);
- result.body.cur_row = @intCast(row);
- result.body.cur_col = @intCast(@min(
- @as(usize, @intCast(@max(0, result.body.cur_col))),
- modal.lineSlice(file.content, row).len,
- ));
- result.body.vsel.active = false;
- result.body.nsel = 0;
- state.sections_output.?.revision = file.revision;
-}
-
-/// One successful watched-path transaction, including every piece of derived
-/// PDF output. The caller owns generic update bookkeeping and status text.
-pub fn reloadWatched(
- core: *pardes.Pardes,
- pane: *pardes.Pane,
-) !void {
- if (comptime !enabled) return error.PdfDisabled;
- const state = pane.pdf orelse return error.MissingPdfState;
- try state.reload(core.pdf_gpa);
- resetPageChrome(pane);
- refreshCleanSections(core, state);
-}
-
-fn rearmCleanSections(
- core: *pardes.Pardes,
- id: usize,
- pane: *pardes.Pane,
- state: *State,
-) bool {
- const remembered = state.sections_output orelse return false;
- if (remembered.pane >= core.panes.len) return false;
- const result = core.panes[remembered.pane] orelse return false;
- if (result.serial != remembered.serial or !isSectionsOutput(result)) return false;
- const file = &result.file.?;
- if (file.revision != remembered.revision) return false;
-
- file.scroll = 0;
- result.body.cur_row = 0;
- result.body.cur_col = 0;
- result.body.vsel.active = false;
- result.body.nsel = 0;
- pane.search_pane = remembered.pane;
- pane.search_row = null;
- look.armLookWalk(core, remembered.pane);
- core.view().active = id;
- return true;
-}
-
-/// Lazily materialise this pane's cached outline as a location list. All
-/// PDF-specific ownership stays here; Pardes contributes only placement.
-pub fn openSections(core: *pardes.Pardes, id: usize) void {
- if (comptime !enabled) return;
- const pane = core.panes[id] orelse return;
- const state = pane.pdf orelse return;
- if (rearmCleanSections(core, id, pane, state)) return;
- const content = state.renderSections(core.pdf_gpa, core.gpa) catch |err| return core.reportError(id, "PdfSections", err);
- // No outline: said, not an empty pane to puzzle over.
- if (content.len == 0) {
- core.gpa.free(content);
- return core.reportFailure(id, "PdfSections: this PDF has no outline");
- }
-
- const free = core.freeSlot() orelse {
- core.gpa.free(content);
- return core.reportError(id, "PdfSections", error.NoPaneSlots);
- };
- const dir = std.fs.path.dirname(state.path) orelse "/";
- const result = Output.open(
- core,
- free,
- dir,
- .{ .cmd = .PdfSections },
- "",
- content,
- ) catch {
- core.gpa.free(content);
- return;
- };
- state.sections_output = .{
- .pane = free,
- .serial = result.serial,
- .revision = result.file.?.revision,
- };
- exec.placeNew(core, id, id, free, .doc);
- layout.compute(core);
- core.view().active = id;
- pane.search_pane = free;
- pane.search_row = null;
- look.armLookWalk(core, free);
-}
-
-const SectionsOwner = struct {
- id: usize,
- pane: *pardes.Pane,
- state: *State,
-};
-
-fn sectionsOwner(core: *pardes.Pardes, output_id: usize) ?SectionsOwner {
- const output = core.panes[output_id] orelse return null;
- if (!isSectionsOutput(output)) return null;
- const file = output.file.?;
- for (core.panes, 0..) |slot, id| {
- const pane = slot orelse continue;
- const state = if (pane.pdf) |pdf_state| pdf_state else continue;
- const token = state.sections_output orelse continue;
- if (token.pane == output_id and token.serial == output.serial and
- token.revision == file.revision)
- return .{ .id = id, .pane = pane, .state = state };
- }
- return null;
-}
-
-pub fn lookSection(
- core: *pardes.Pardes,
- output_id: usize,
- path: []const u8,
- at: look.Spot,
-) bool {
- if (comptime !enabled) return false;
- const output = core.panes[output_id] orelse return false;
- if (!isSectionsOutput(output)) return false;
- if (at.line == 0 or at.col == 0 or at.end_line != 0 or
- !look.isPdfPath(path)) return false;
- const owner = sectionsOwner(core, output_id) orelse return true;
-
- var joined_path: [4096]u8 = undefined;
- const output_dir = std.fs.path.dirname(output.file.?.path) orelse "/";
- const separator = if (std.mem.endsWith(u8, output_dir, "/")) "" else "/";
- const target_path = if (std.fs.path.isAbsolute(path))
- path
- else
- std.fmt.bufPrint(&joined_path, "{s}{s}{s}", .{ output_dir, separator, path }) catch return true;
- if (!std.mem.eql(u8, owner.state.path, target_path)) return true;
-
- // A row is `file:PAGE:SECTION`, its first number the page as in every
- // other location: a section there is none, or one on another page, is
- // a miss said, never a silent jump.
- var said: [160]u8 = undefined;
- const destination = owner.state.sectionDestination(core.pdf_gpa, at.col - 1) orelse
- return failSection(core, output_id, std.fmt.bufPrint(&said, "PdfSections: {s} has no section {d}", .{ std.fs.path.basename(owner.state.path), at.col }) catch "PdfSections: no such section");
- if (destination == .internal and destination.internal.page + 1 != at.line)
- return failSection(core, output_id, std.fmt.bufPrint(&said, "PdfSections: section {d} of {s} is on page {d}, not {d}", .{ at.col, std.fs.path.basename(owner.state.path), destination.internal.page + 1, at.line }) catch "PdfSections: that section is on another page");
- switch (destination) {
- .internal => |internal| {
- look.clearNavigationSelection(core, owner.pane);
- revealOutlineDestination(core, owner.pane, internal);
- },
- .external => |uri| if (uri.len <= 256) core.emit(.{ .open_link = .from(uri) }),
- .none => unreachable,
- }
- core.view().active = owner.id;
- return true;
-}
-
-fn failSection(core: *pardes.Pardes, id: usize, text: []const u8) bool {
- core.look_missed = true;
- core.reportFailure(id, text);
- return true;
-}
-
-pub fn resetPageChrome(pane: *pardes.Pane) void {
- pane.body.cur_row = 0;
- pane.body.cur_col = 0;
- pane.body.vsel.active = false;
- pane.body.nsel = 0;
-}
-
-pub fn activatePage(
- core: *pardes.Pardes,
- pane: *pardes.Pane,
- page: usize,
- reveal: bool,
-) void {
- if (comptime !enabled) return;
- const state = pane.pdf orelse return;
- if (state.activatePage(core.pdf_gpa, page, reveal)) resetPageChrome(pane);
-}
-
-pub fn revealOutlineDestination(
- core: *pardes.Pardes,
- pane: *pardes.Pane,
- destination: OutlineInternalDestination,
-) void {
- if (comptime !enabled) return;
- activatePage(core, pane, destination.page, false);
- const state = pane.pdf.?;
- state.queueOutlineReveal(destination);
- // Consume immediately when geometry already exists; otherwise the PDF
- // draw pass consumes the same value after the next layout transaction.
- _ = ensurePaneLayout(core, pane);
-}
-
-/// A PDF's place, as the jumplist keeps it: the page at the strip's top and
-/// how far down that page it stands, a fraction in 2^-32 of the page. A
-/// fraction, not pixels: a zoom, a fit change or a resize scales every page,
-/// and a fraction of one lands on the same line of print after it.
-pub const Place = struct { page: usize, at: u32 };
-const place_scale: f64 = std.math.maxInt(u32);
-
-pub fn place(pane: *const pardes.Pane) ?Place {
- if (comptime !enabled) return null;
- const state = if (pane.pdf) |pv| pv else return null;
- if (!state.layout_valid or state.document_height == 0) return .{ .page = state.page, .at = 0 };
- const page = pageAtOffset(state, state.document_scroll_y);
- const start: f64 = @floatFromInt(state.page_starts[page]);
- const height: f64 = @floatFromInt(@max(1, state.page_heights[page]));
- const fraction = std.math.clamp((state.document_scroll_y - start) / height, 0, 1);
- return .{ .page = page, .at = @intFromFloat(@round(fraction * place_scale)) };
-}
-
-/// Where `at` stands on the strip as laid out now, in document pixels.
-pub fn placeY(pane: *const pardes.Pane, at: Place) ?f64 {
- if (comptime !enabled) return null;
- const state = if (pane.pdf) |pv| pv else return null;
- if (!state.layout_valid) return null;
- const page = @min(at.page, state.page_count -| 1);
- return @as(f64, @floatFromInt(state.page_starts[page])) +
- @as(f64, @floatFromInt(at.at)) / place_scale * @as(f64, @floatFromInt(state.page_heights[page]));
-}
-
-/// A jump to `at` (Back, Forward): the strip is there at once. Not laid
-/// out yet (a pane just reopened), it is anchored there for the first
-/// layout.
-pub fn landAt(core: *pardes.Pardes, pane: *pardes.Pane, at: Place) void {
- if (comptime !enabled) return;
- const state = pane.pdf orelse return;
- const page = @min(at.page, state.page_count -| 1);
- activatePage(core, pane, page, false);
- state.scroll_to_page_pending = false;
- if (placeY(pane, .{ .page = page, .at = at.at })) |y| {
- state.layout_anchor_pending = false;
- // Where it stands already (half a pixel is the place's rounding):
- // not moved, not kicked.
- if (@abs(y - state.document_scroll_y) >= 0.5) state.document_scroll_y = y;
- } else {
- state.layout_anchor_pending = true;
- state.layout_anchor_page = page;
- state.layout_anchor_fraction = @as(f64, @floatFromInt(at.at)) / place_scale;
- }
-}
-
-pub fn toggleFit(pane: *pardes.Pane) void {
- if (comptime !enabled) return;
- const state = pane.pdf orelse return;
- state.toggleFit();
-}
-
-pub fn toggleTint(pane: *pardes.Pane) void {
- if (comptime !enabled) return;
- const state = pane.pdf orelse return;
- state.toggleTint();
-}
-
-pub fn paneViewport(core: *const pardes.Pardes, pane: *const pardes.Pane) ?Viewport {
- const v = core.view();
- if (comptime !enabled) return null;
- const rect = v.rects[panes.paneIdOf(core, pane) orelse return null];
- const cols = rect.w -| config.GUTTER;
- const rows = rect.h -| pane.tag_rows;
- if (cols == 0 or rows == 0) return null;
- return .{
- .pixel_w = @as(u32, cols) * @as(u32, v.cell_pixels.w),
- .pixel_h = @as(u32, rows) * @as(u32, v.cell_pixels.h),
- };
-}
-
-pub fn ensurePaneLayout(core: *pardes.Pardes, pane: *pardes.Pane) ?Viewport {
- if (comptime !enabled) return null;
- const state = pane.pdf orelse return null;
- const view = paneViewport(core, pane) orelse return null;
- ensureLayout(state, view);
- return view;
-}
-
-pub fn tintColors(core: *const pardes.Pardes) TintColors {
- if (comptime !enabled) return;
- const theme = core.theme();
- return .{
- .background = theme.bg orelse theme.tag_bg,
- .foreground = theme.fg orelse theme.tag_fg,
- };
-}
-
-pub fn paneGeometry(core: *const pardes.Pardes, pane: *const pardes.Pane) ?surface.NativeGeometry {
- if (comptime !enabled) return null;
- const state = if (pane.pdf) |view| view else return null;
- const view = paneViewport(core, pane) orelse return null;
- return activeGeometry(state, view);
-}
-
-/// The page under grid row `row`, from the middle of its cell.
-pub fn pageAtGridRow(core: *const pardes.Pardes, pane: *const pardes.Pane, row: u16) ?usize {
- const v = core.view();
- if (comptime !enabled) return null;
- const state = pane.pdf orelse return null;
- const rect = v.rects[panes.paneIdOf(core, pane) orelse return null];
- const body_y = core.bodyTop(pane, rect);
- if (!state.layout_valid or row < body_y or row >= body_y + (rect.h -| pane.tag_rows)) return null;
- const document_y = state.document_scroll_y + @as(f64, @floatFromInt(
- @as(u32, row - body_y) * v.cell_pixels.h + v.cell_pixels.h / 2,
- ));
- const page = pageAtOffset(state, document_y);
- const start: f64 = @floatFromInt(state.page_starts[page]);
- if (document_y < start or
- document_y >= start + @as(f64, @floatFromInt(state.page_heights[page]))) return null;
- return page;
-}
-
-/// Some page of the pane is placed where it is drawn.
-pub fn paneNativeReady(core: *const pardes.Pardes, pane: *const pardes.Pane) bool {
- if (comptime !enabled) return false;
- if (!core.view().frontend.native_images) return false;
- const state = if (pane.pdf) |view| view else return false;
- const view = paneViewport(core, pane) orelse return false;
- for (state.rasters[0..state.rasters_len]) |*raster| {
- if (raster.valid and raster.rgba.len > 0 and
- placedGeometry(state, raster, view, raster.page) != null) return true;
- }
- return false;
-}
-
-pub fn nativePageAtGridRow(
- core: *const pardes.Pardes,
- pane: *const pardes.Pane,
- row: u16,
-) ?usize {
- if (comptime !enabled) return null;
- if (!core.view().frontend.native_images) return null;
- const state = if (pane.pdf) |view| view else return null;
- const page = pageAtGridRow(core, pane, row) orelse return null;
- const view = paneViewport(core, pane) orelse return null;
- if (!pageReady(state, view, page)) return null;
- return page;
-}
-
-/// The point of `page` under the middle of grid cell `col`,`row`, where
-/// that page is placed; `clamp_to_page` holds a point past it on its edge.
-pub fn panePointAtPage(
- core: *const pardes.Pardes,
- pane: *const pardes.Pane,
- page: usize,
- col: u16,
- row: u16,
- clamp_to_page: bool,
-) ?Point {
- if (comptime !enabled) return null;
- const state = if (pane.pdf) |view| view else return null;
- const view = paneViewport(core, pane) orelse return null;
- const raster = rasterForPageConst(state, page) orelse return null;
- if (raster.rgba.len == 0) return null;
- const placed = placedGeometry(state, raster, view, page) orelse return null;
- const rect = core.view().rects[panes.paneIdOf(core, pane) orelse return null];
- const body_x = @as(i64, rect.x + config.GUTTER);
- const body_y = @as(i64, core.bodyTop(pane, rect));
- const px = (@as(i64, col) - body_x) * core.view().cell_pixels.w + core.view().cell_pixels.w / 2;
- const py = (@as(i64, row) - body_y) * core.view().cell_pixels.h + core.view().cell_pixels.h / 2;
- return pointAtGeometry(placed.geometry, placed.pixel_offset_y, raster.iw, raster.ih, raster.band_y, px, py, clamp_to_page);
-}
-
-pub fn probeAt(
- core: *pardes.Pardes,
- pane: *pardes.Pane,
- col: u16,
- row: u16,
-) ?WordProbe {
- if (comptime !enabled) return null;
- const page = nativePageAtGridRow(core, pane, row) orelse return null;
- const point = panePointAtPage(core, pane, page, col, row, false) orelse return null;
- const state = pane.pdf orelse return null;
- if (state.document.linkAt(core.pdf_gpa, page, point) catch null) |found| {
- var link = found;
- if (look.pdfLinkLocation(core, pane, link) != null) {
- const quads = core.pdf_gpa.alloc(pdf.Quad, 1) catch {
- link.deinit(core.pdf_gpa);
- return null;
- };
- const text = state.document.copyRectangle(core.pdf_gpa, page, link.quad) catch {
- core.pdf_gpa.free(quads);
- link.deinit(core.pdf_gpa);
- return null;
- };
- quads[0] = link.quad;
- return .{ .page = page, .quads = quads, .text = text, .link = link };
- }
- link.deinit(core.pdf_gpa);
- }
- return probeWord(&state.document, core.pdf_gpa, page, point) catch null;
-}
-
-pub fn beginDrag(
- core: *pardes.Pardes,
- pane: *pardes.Pane,
- col: u16,
- row: u16,
- snap_word: bool,
-) bool {
- if (comptime !enabled) return false;
- const hit_page = pageAtGridRow(core, pane, row) orelse return false;
- if (hit_page != pane.pdf.?.page) activatePage(core, pane, hit_page, false);
- const state = pane.pdf.?;
- state.clearDrag();
- const point = panePointAtPage(core, pane, state.page, col, row, false) orelse return false;
- state.drag_anchor = point;
- state.drag_head = point;
- if (!snap_word) return true;
- if (state.selection_page == state.page) if (state.selection) |selection| if (selection.contains(point)) return true;
- if (state.setSelection(core.pdf_gpa, point, point, true) == .failed) {
- // Preserve the old selection transactionally, but never let an
- // outside click execute its stale text.
- state.clearDrag();
- return false;
- }
- return true;
-}
-
-pub fn updateSelection(
- core: *pardes.Pardes,
- pane: *pardes.Pane,
- col: u16,
- row: u16,
- invalidate_raster: bool,
-) SelectionUpdate {
- if (comptime !enabled) return .failed;
- const state = pane.pdf orelse return .failed;
- const anchor = state.drag_anchor orelse return .failed;
- const point = panePointAtPage(core, pane, state.page, col, row, true) orelse return .failed;
- if (state.drag_head) |head| if (head.x == point.x and head.y == point.y) return .stationary;
- const result = state.setSelection(core.pdf_gpa, anchor, point, invalidate_raster);
- if (result != .failed) state.drag_head = point;
- return result;
-}
-
-pub fn pointerStart(
- core: *pardes.Pardes,
- pane: *pardes.Pane,
- button: pardes.Mouse.Button,
- col: u16,
- row: u16,
- on_tag: bool,
-) PointerDrag {
- if (comptime !enabled) return .{};
- if (on_tag or !paneNativeReady(core, pane)) return .{};
- var drag: PointerDrag = .{ .native = true };
- if (button == config.look_button) {
- drag.word_at = .{ .col = col, .row = row };
- } else if (button == config.select_button) {
- _ = beginDrag(core, pane, col, row, false);
- } else if (button == config.exec_button) {
- _ = beginDrag(core, pane, col, row, true);
- }
- return drag;
-}
-
-pub fn pointerUpdate(
- drag: *PointerDrag,
- core: *pardes.Pardes,
- pane: *pardes.Pane,
- col: u16,
- row: u16,
-) void {
- if (comptime !enabled) return;
- if (!drag.native) return;
- if (drag.word_at) |at| {
- if (col == at.col and row == at.row) return;
- if (!beginDrag(core, pane, at.col, at.row, false)) {
- drag.word_at = null;
- return;
- }
- switch (updateSelection(core, pane, col, row, false)) {
- .failed => {
- drag.word_at = null;
- pane.pdf.?.clearDrag();
- },
- // Adjacent grid cells can still address one raster pixel. Keep
- // click mode and retry farther out.
- .stationary => {},
- .unchanged => drag.word_at = null,
- .changed => {
- drag.word_at = null;
- drag.selection_changed = true;
- },
- }
- return;
- }
- switch (updateSelection(core, pane, col, row, false)) {
- .failed => pane.pdf.?.clearDrag(),
- .stationary, .unchanged => {},
- .changed => drag.selection_changed = true,
- }
-}
-
-pub fn pointerCancel(pane: *pardes.Pane, drag: PointerDrag) void {
- if (comptime !enabled) return;
- if (drag.native) if (pane.pdf) |state| {
- if (drag.selection_changed) state.invalidateRaster(state.page);
- state.clearDrag();
- };
-}
-
-pub fn pointerRelease(
- core: *pardes.Pardes,
- pane: *pardes.Pane,
- drag: PointerDrag,
- button: pardes.Mouse.Button,
- chorded: bool,
-) PointerRelease {
- if (comptime !enabled) return .{};
- const state = pane.pdf orelse return .{};
- const slot = @backingInt(button);
- const grid_selection = pane.sel[slot];
- pane.sel[slot].state = .none; // native quads, not projected text cells
-
- // Drag updates changed live geometry/text while leaving baked pixels
- // stable. Commit exactly once before any chord/Exec/Look can clear state.
- if (drag.selection_changed) state.invalidateRaster(state.page);
- if (chorded) {
- state.clearDrag();
- return .{};
- }
- if (drag.word_at) |at| {
- const maybe_probe = probeAt(core, pane, at.col, at.row);
- state.clearDrag();
- const probe = maybe_probe orelse return .{};
- // A neighboring visible page becomes current before Look dispatch.
- // WordProbe owns its text/quads independently of that state change.
- if (probe.page != state.page) activatePage(core, pane, probe.page, false);
- const text = probe.text;
- return .{ .action = .look, .text = text, .probe = probe };
- }
- if (button == config.select_button) {
- const dragged = grid_selection.c0 != grid_selection.c1 or
- grid_selection.r0 != grid_selection.r1;
- if (!dragged) state.clearSelection(core.pdf_gpa);
- pane.body.cur_pinned = true;
- pane.body.mode = .normal;
- pane.body.vsel.active = false;
- pane.body.normal.clear();
- pane.body.nsel = 0;
- state.clearDrag();
- return .{};
- }
- if (state.drag_anchor == null or state.selection_text.len == 0) {
- state.clearDrag();
- return .{};
- }
- const text = state.selection_text;
- state.clearDrag();
- return .{
- .action = if (button == config.look_button) .look else .exec,
- .text = text,
- };
-}
-
-pub fn highlightInput(
- core: *pardes.Pardes,
- pane_id: usize,
- pane: *const pardes.Pane,
-) HighlightInput {
- if (comptime !enabled) return;
- const hover_quads: []const Quad = if (core.pdf_hover_preview) |preview|
- if (preview.pane == pane_id and preview.serial == pane.serial)
- preview.probe.quads
- else
- &.{}
- else
- &.{};
- const hover_page = if (hover_quads.len > 0) core.pdf_hover_preview.?.probe.page else null;
- const link_hover = hover_quads.len > 0 and core.pdf_hover_preview.?.probe.link != null;
- const selection_color = core.theme().sel_bg;
- return .{
- .hover_quads = hover_quads,
- .hover_page = hover_page,
- .hover_color = if (link_hover) core.theme().box else selection_color,
- .selection_color = selection_color,
- .live = core.view().frontend.native_image_patches,
- };
-}
-
-/// `glide`: a notch; else a touchpad's fraction, counted as moved by the
-/// pixel (`direct_y`).
-pub fn scrollPane(core: *pardes.Pardes, pane: *pardes.Pane, delta_pixels: f64, glide: bool) bool {
- if (comptime !enabled) return false;
- const tz = tracy.zone(@src(), "pdf.scroll_notch");
- defer tz.end();
- const state = pane.pdf orelse return false;
- const view = ensurePaneLayout(core, pane) orelse return false;
- const from = state.document_scroll_y;
- const result = scrollDocument(state, view, delta_pixels) orelse return false;
- if (!glide) state.direct_y += state.document_scroll_y - from;
- if (result.active_page != state.page) activatePage(core, pane, result.active_page, false);
- return true;
-}
-
-/// Where the strip is drawn this frame: where the core stands, a scroll
-/// landing at once; which way it went, for the page rendered ahead.
-fn stripAt(state: *State, view: Viewport) f64 {
- const moved = state.document_scroll_y - state.drawn_y;
- if (moved != 0) state.ahead = if (moved > 0) 1 else -1;
- state.drawn_y = state.document_scroll_y;
- state.direct_y = 0;
- state.far = false;
- const max_scroll = @as(f64, @floatFromInt(state.document_height -| view.pixel_h));
- return std.math.clamp(state.drawn_y, 0, max_scroll);
-}
-
-pub fn verticalWheel(core: *pardes.Pardes, pane: *pardes.Pane, direction: i8) void {
- if (comptime !enabled) return;
- if (!core.view().frontend.native_images) {
- // The text layer: a page a notch.
- const state = pane.pdf orelse return;
- if (stepPage(state, core.pdf_gpa, direction)) resetPageChrome(pane);
- return;
- }
- const rows: u32 = @intCast(@max(1, config.wheel_rows));
- const pixels = scaledStep(core.view().cell_pixels.h, rows);
- _ = scrollPane(core, pane, @as(f64, @floatFromInt(pixels)) * direction, true);
-}
-
-pub fn horizontalWheel(core: *pardes.Pardes, pane: *pardes.Pane, direction: i8) void {
- if (comptime !enabled) return;
- const state = pane.pdf orelse return;
- if (!core.view().frontend.native_images or state.fit != .height) return;
- const placed = paneGeometry(core, pane) orelse return;
- const cols: u32 = @intCast(@max(1, config.wheel_cols));
- _ = panPixels(state, placed, .horizontal, direction, scaledStep(core.view().cell_pixels.w, cols));
-}
-
-pub fn draw(
- core: *pardes.Pardes,
- s: *pardes.Surface,
- pane: *pardes.Pane,
- rect: pardes.Rect,
- pane_id: usize,
- text_x: u16,
- text_width: u16,
- rail: *pardes.Region,
-) bool {
- if (comptime !enabled) return false;
- if (!core.view().frontend.native_images or rect.h <= pane.tag_rows) return false;
- const state = pane.pdf orelse return false;
- const view = paneViewport(core, pane) orelse return false;
- const key = TintKey{ .mode = state.tint, .colors = tintColors(core) };
- applySizes(state, core.pdf_gpa);
- ensureLayout(state, view);
- // Drawn where the core stands (`drawn_y`), unless a search's reveal
- // moved it as it drew, which is then drawn there.
- const shown = stripAt(state, view);
- state.document_scroll_y = shown;
- defer state.document_scroll_y = state.drawn_y;
- if (pane_id == core.view().active) core.frames.scroll = @floatCast(shown);
- defer {
- core.frames.landed +|= state.landed;
- state.landed = 0;
- }
- const visible = renderFrame(
- state,
- core.pdf_gpa,
- core.scratch.allocator(),
- view,
- pardes.pdf_raster_policy,
- key,
- highlightInput(core, pane_id, pane),
- state.drawn_y - shown,
- state.far,
- );
- if (state.document_scroll_y != shown) state.drawn_y = state.document_scroll_y;
- // Below the notice chips, like an image: a placed page is drawn after
- // the cells and would paint a chip out.
- const body: pardes.RectCell = .{
- .x = text_x,
- .y = core.bodyTop(pane, rect) + pane.notices.span(),
- .w = text_width,
- .h = (rect.h -| pane.tag_rows) -| pane.notices.span(),
- };
- if (s.region(.body, pane_id)) |region| region.scroll_px = state.document_scroll_y;
- var placed_any = false;
- var page = visible.first;
- const visible_end = visible.first + visible.len;
- state.blank = .{ 255, 255, 255, 255 };
- pdf.tintRgba(&state.blank, key.mode, key.colors) catch {};
- while (page < visible_end) : (page += 1) {
- const placed = placedRaster(state, view, page) orelse {
- // Not landed yet (a lane renders it): its paper, where it will
- // be, one pixel drawn the page's size. Never a stall.
- // ponytail: the blank's texture is keyed revision 0, so a tint
- // change shows the old paper until the page lands.
- if (workers == null or pardes.platform == .macos) continue;
- const size = state.page_sizes[page];
- const rows = visibleRows(state, view, page, @intFromFloat(@max(1, @round(size.width * 8))), @intFromFloat(@max(1, @round(size.height * 8)))) orelse continue;
- if (!core.appendPlacement(.{
- .pane = @intCast(pane_id),
- .raster = .of(&state.blank, 1, 1),
- .src = .{ .w = 1, .h = 1 },
- .dst = body,
- .at = .{ .x = rows.base.dst.x, .y = rows.dst_y, .w = rows.base.dst.w, .h = rows.dst_h },
- .key = pardes.Placement.keyOf(pane.serial, @intCast(page), 0),
- })) break;
- placed_any = true;
- continue;
- };
- const slot = rasterForPage(state, page).?;
- const dirty: ?pardes.Placement.Dirty = if (slot.patch_from != 0 and
- slot.patch_rows.start < slot.patch_rows.end)
- .{
- .from = pardes.Placement.keyOf(pane.serial, @intCast(placed.page), slot.patch_from),
- .y = @intCast(slot.patch_rows.start - slot.band_y),
- .h = @intCast(slot.patch_rows.end - slot.patch_rows.start),
- }
- else
- null;
- if (!core.appendPlacement(.{
- .pane = @intCast(pane_id),
- // The texture is the retained band, not the full page.
- .raster = .of(placed.rgba, placed.width, placed.band_height),
- .src = placed.geometry.src,
- .dst = body,
- .at = placed.geometry.dst,
- .key = pardes.Placement.keyOf(pane.serial, @intCast(placed.page), placed.revision),
- .dirty = dirty,
- })) break;
- // A shell now holds (or will fetch whole) this revision.
- slot.patch_from = slot.revision;
- slot.patch_rows = .{ .start = 0, .end = 0 };
- placed_any = true;
- }
- // Nothing placed while pages are there (a far jump's first frame: its
- // slide starts a body short of the pages it renders) is still the PDF's
- // frame: falling back to the page's text extracted it on the loop
- // (9 ms RS, 110 ms Debug on the SDM) to show it for one frame.
- if (!placed_any and visible.len == 0) return false;
-
- // This frame has spent the motion used to choose its raster band.
- state.scroll_travel = 0;
- const chrome = core.chromeTheme();
- const theme = core.theme();
- const pane_bg: pardes.Color = if (theme.bg) |color| .{ .rgb = color } else .default;
- // The rail runs past the notice bands; only the thumb tracks the text,
- // and it is measured here, in document pixels, for `place`'s region.
- const track_h: usize = rail.rect.h;
- const total = @max(@as(u64, 1), state.document_height);
- const len = @max(
- @as(usize, 1),
- @as(usize, @intCast(@min(
- @as(u64, track_h),
- @as(u64, track_h) * view.pixel_h / total,
- ))),
- );
- const offset: u64 = @intFromFloat(@floor(state.document_scroll_y));
- const pos: usize = @intCast(@min(
- @as(u64, track_h -| 1),
- @as(u64, track_h) * offset / total,
- ));
- rail.thumb_y = @intCast(pos);
- rail.thumb_h = @intCast(@min(len, track_h -| pos));
- rail.thumb_at = @floatCast(state.document_scroll_y / @as(f64, @floatFromInt(total)));
- rail.thumb_span = @as(f32, @floatFromInt(view.pixel_h)) / @as(f32, @floatFromInt(total));
- s.fill(rail.rect.x, rail.rect.y, 1, rail.rect.h, .{ .bg = .{ .rgb = chrome.scroll_track } });
- s.fill(rail.rect.x + 1, rail.rect.y, 1, rail.rect.h, .{ .bg = pane_bg });
- s.fill(rail.rect.x, rail.rect.y + rail.thumb_y, 1, rail.thumb_h, .{ .bg = .{ .rgb = chrome.scroll_thumb } });
- return true;
-}
-
-pub const SectionRows = if (enabled) struct {
- pub fn usableDestination(destination: pdf.OutlineDestination) ?pdf.OutlineDestination {
- return switch (destination) {
- .internal => destination,
- .external => |uri| if (safeHttpUri(uri)) destination else null,
- .none => null,
- };
- }
-
- fn safeHttpUri(uri: []const u8) bool {
- // Effect.open_link is inline and cannot carry a larger URL. Omitting
- // it here is preferable to rendering a row which can never act.
- if (uri.len > 256) return false;
- var has_scheme = false;
- for (config.url_schemes) |scheme| {
- if (std.mem.startsWith(u8, uri, scheme)) {
- has_scheme = true;
- break;
- }
- }
- if (!has_scheme) return false;
- for (uri) |byte| if (byte <= 0x20 or byte == 0x7f) return false;
- return true;
- }
-
- pub fn resolve(entries: []const pdf.OutlineEntry, ordinal: usize) ?pdf.OutlineDestination {
- if (ordinal >= entries.len) return null;
- const entry = entries[ordinal];
- if (entry.destination != .none) return usableDestination(entry.destination);
- var i = ordinal + 1;
- while (i < entries.len and entries[i].depth > entry.depth) : (i += 1)
- if (usableDestination(entries[i].destination)) |destination| return destination;
- return null;
- }
-
- pub fn resolveOrdinals(
- gpa: std.mem.Allocator,
- entries: []const pdf.OutlineEntry,
- ) ![]usize {
- const unresolved = std.math.maxInt(usize);
- const ordinals = try gpa.alloc(usize, entries.len);
- @memset(ordinals, unresolved);
-
- const Pending = struct { depth: u8, ordinal: usize };
- var pending: [256]Pending = undefined;
- var pending_len: usize = 0;
- for (entries, 0..) |entry, ordinal| {
- while (pending_len > 0 and pending[pending_len - 1].depth >= entry.depth)
- pending_len -= 1;
-
- if (usableDestination(entry.destination) != null) {
- ordinals[ordinal] = ordinal;
- for (pending[0..pending_len]) |ancestor|
- ordinals[ancestor.ordinal] = ordinal;
- pending_len = 0;
- } else if (entry.destination == .none) {
- pending[pending_len] = .{ .depth = entry.depth, .ordinal = ordinal };
- pending_len += 1;
- }
- }
- return ordinals;
- }
-
- /// A title on one row: blanks, controls and broken bytes as one space
- /// between words and none at its ends; `[untitled]` for none, `[empty
- /// title]` for one with nothing to print.
- fn cleanTitle(w: *std.Io.Writer, title: ?[]const u8) std.Io.Writer.Error!void {
- const raw = title orelse return w.writeAll("[untitled]");
- var i: usize = 0;
- var wrote = false;
- var pending_space = false;
- while (i < raw.len) {
- const n: usize = std.unicode.utf8ByteSequenceLength(raw[i]) catch {
- pending_space = wrote;
- i += 1;
- continue;
- };
- if (i + n > raw.len) {
- pending_space = wrote;
- break;
- }
- const cp = std.unicode.utf8Decode(raw[i .. i + n]) catch {
- pending_space = wrote;
- i += n;
- continue;
- };
- const whitespace_or_control = cp <= 0x20 or cp == 0x7f or
- (cp >= 0x80 and cp <= 0x9f) or cp == 0x2028 or cp == 0x2029;
- if (whitespace_or_control) {
- pending_space = wrote;
- } else {
- if (pending_space) try w.writeByte(' ');
- try w.writeAll(raw[i .. i + n]);
- wrote = true;
- pending_space = false;
- }
- i += n;
- }
- if (!wrote) try w.writeAll("[empty title]");
- }
-
- pub fn render(gpa: std.mem.Allocator, path: []const u8, entries: []const pdf.OutlineEntry) ![]u8 {
- const ordinals = try resolveOrdinals(gpa, entries);
- defer gpa.free(ordinals);
- var out: std.Io.Writer.Allocating = .init(gpa);
- errdefer out.deinit();
- writeRows(&out.writer, std.fs.path.basename(path), entries, ordinals) catch return error.OutOfMemory;
- return out.toOwnedSlice();
- }
-
- /// A row an entry with somewhere to go: where (`file:PAGE:ORDINAL`, or
- /// its URI), indented by depth, its title.
- fn writeRows(w: *std.Io.Writer, target: []const u8, entries: []const pdf.OutlineEntry, ordinals: []const usize) std.Io.Writer.Error!void {
- for (entries, ordinals, 0..) |entry, resolved, ordinal| {
- if (resolved == std.math.maxInt(usize)) continue;
- // unreachable: resolveOrdinals resolves only to usable destinations
- switch (usableDestination(entries[resolved].destination) orelse unreachable) {
- .internal => |internal| try w.print("{s}:{d}:{d} ", .{ target, internal.page + 1, ordinal + 1 }),
- .external => |uri| try w.print("{s} ", .{uri}),
- .none => unreachable,
- }
- try w.splatByteAll(' ', @as(usize, entry.depth) * 2);
- try cleanTitle(w, entry.title);
- try w.writeByte('\n');
- }
- }
-} else struct {};
diff --git a/src/replica.zig b/src/replica.zig
index 622537d7..25507ec5 100644
--- a/src/replica.zig
+++ b/src/replica.zig
@@ -175,7 +175,6 @@ pub const Authority = struct {
// tells an allocator from none.
var opts = options;
opts.image_allocator = opts.image_allocator orelse gpa;
- opts.pdf_allocator = opts.pdf_allocator orelse gpa;
opts.tree_sitter_allocator = opts.tree_sitter_allocator orelse gpa;
opts.frame_allocator = opts.frame_allocator orelse gpa;
const a = try gpa.create(Authority);
@@ -712,7 +711,6 @@ pub const Replica = struct {
o.frame_allocator = epoch;
o.tree_sitter_allocator = epoch;
o.image_allocator = o.image_allocator orelse std.heap.c_allocator;
- o.pdf_allocator = o.pdf_allocator orelse std.heap.c_allocator;
// The session's closed panes and Recent are the authority's.
o.state = .off;
// Its emulators off the epoch, as `terminal.create` makes a screen
diff --git a/src/rollback.zig b/src/rollback.zig
index ce4016d8..e08e6242 100644
--- a/src/rollback.zig
+++ b/src/rollback.zig
@@ -576,7 +576,7 @@ test "a copy put back is the core as it was; one let go keeps what was done" {
var e: Epoch = .{ .child = std.testing.allocator };
defer e.deinit();
const gpa = e.allocator();
- const p = try Pardes.init(gpa, .{ .cols = 80, .rows = 24, .file = "mise.toml", .image_allocator = gpa, .pdf_allocator = gpa, .tree_sitter_allocator = gpa, .frame_allocator = gpa });
+ const p = try Pardes.init(gpa, .{ .cols = 80, .rows = 24, .file = "mise.toml", .image_allocator = gpa, .tree_sitter_allocator = gpa, .frame_allocator = gpa });
p.pump(.{}) catch {};
const before = walk.digest(Pardes, p);
var c: Copy = .{};
@@ -606,7 +606,7 @@ test "a text written in place under a copy comes back byte for byte: typed into
var e: Epoch = .{ .child = std.testing.allocator };
defer e.deinit();
const gpa = e.allocator();
- const p = try Pardes.init(gpa, .{ .cols = 80, .rows = 24, .file = "build.zig", .image_allocator = gpa, .pdf_allocator = gpa, .tree_sitter_allocator = gpa, .frame_allocator = gpa });
+ const p = try Pardes.init(gpa, .{ .cols = 80, .rows = 24, .file = "build.zig", .image_allocator = gpa, .tree_sitter_allocator = gpa, .frame_allocator = gpa });
p.pump(.{}) catch {};
const f = for (p.panes) |slot| {
if (slot) |pane| if (pane.file) |*file| break file;
@@ -671,7 +671,7 @@ test "a view's slot, live or drawn outside a step (a replica's own, another live
var e: Epoch = .{};
defer e.deinit();
const gpa = e.allocator();
- const p = try Pardes.init(gpa, .{ .cols = 80, .rows = 24, .file = "mise.toml", .image_allocator = gpa, .pdf_allocator = gpa, .tree_sitter_allocator = gpa, .frame_allocator = gpa });
+ const p = try Pardes.init(gpa, .{ .cols = 80, .rows = 24, .file = "mise.toml", .image_allocator = gpa, .tree_sitter_allocator = gpa, .frame_allocator = gpa });
defer p.deinit();
p.pump(.{}) catch {};
_ = p.openView() orelse return error.NoView;
@@ -711,7 +711,7 @@ test "a register's texts are pinned, not copied, and come back whole" {
var e: Epoch = .{ .child = std.testing.allocator };
defer e.deinit();
const gpa = e.allocator();
- const p = try Pardes.init(gpa, .{ .cols = 80, .rows = 24, .file = "mise.toml", .image_allocator = gpa, .pdf_allocator = gpa, .tree_sitter_allocator = gpa, .frame_allocator = gpa });
+ const p = try Pardes.init(gpa, .{ .cols = 80, .rows = 24, .file = "mise.toml", .image_allocator = gpa, .tree_sitter_allocator = gpa, .frame_allocator = gpa });
p.pump(.{}) catch {};
// A terminal's whole grid yanked: megabytes, and joined once read.
const grid = try std.testing.allocator.alloc(u8, 2 << 20);
@@ -740,7 +740,7 @@ test "a file's location rows are pinned whole, with what they own, and come back
var e: Epoch = .{ .child = std.testing.allocator };
defer e.deinit();
const gpa = e.allocator();
- const p = try Pardes.init(gpa, .{ .cols = 80, .rows = 24, .file = "mise.toml", .image_allocator = gpa, .pdf_allocator = gpa, .tree_sitter_allocator = gpa, .frame_allocator = gpa });
+ const p = try Pardes.init(gpa, .{ .cols = 80, .rows = 24, .file = "mise.toml", .image_allocator = gpa, .tree_sitter_allocator = gpa, .frame_allocator = gpa });
p.pump(.{}) catch {};
const f = for (p.panes) |slot| {
if (slot) |pane| if (pane.file) |*file| break file;
@@ -774,7 +774,7 @@ test "a rollback leaves the store and Recent as a speculation left them: they li
var e: Epoch = .{ .child = std.testing.allocator };
defer e.deinit();
const gpa = e.allocator();
- const p = try Pardes.init(gpa, .{ .cols = 80, .rows = 24, .file = "mise.toml", .image_allocator = gpa, .pdf_allocator = gpa, .tree_sitter_allocator = gpa, .frame_allocator = gpa });
+ const p = try Pardes.init(gpa, .{ .cols = 80, .rows = 24, .file = "mise.toml", .image_allocator = gpa, .tree_sitter_allocator = gpa, .frame_allocator = gpa });
p.pump(.{}) catch {};
var line: [std.fs.max_path_bytes + 16]u8 = undefined;
p.update(.{ .command = try lookAt(&line, "build.zig.zon") });
diff --git a/src/surface.zig b/src/surface.zig
index c058e101..15147146 100644
--- a/src/surface.zig
+++ b/src/surface.zig
@@ -260,9 +260,9 @@ pub const Region = struct {
/// A grip's pane has changes it has not saved.
dirty: bool = false,
/// A rail's thumb: rows from the rail's top, and how many. Zero rows is
- /// a rail with no thumb (an image). A native PDF's thumb is measured in
- /// document pixels and filled in by Pdf.draw while it paints, so read
- /// regions once render has returned.
+ /// a rail with no thumb (an image). A kind's thumb is where its paint
+ /// said its window is (`pa_paint.at`, `span`: a PDF's strip), filled in
+ /// as it paints, so read regions once render has returned.
thumb_y: u16 = 0,
thumb_h: u16 = 0,
/// The same thumb unrounded, for a pixel shell: its top and its length
diff --git a/src/tagline.zig b/src/tagline.zig
index 469d97d1..28cd2a9b 100644
--- a/src/tagline.zig
+++ b/src/tagline.zig
@@ -9,7 +9,6 @@ const panes = @import("panes.zig");
const edit = @import("edit.zig");
const exec = @import("exec.zig");
const config = @import("config.zig");
-const pdf_enabled = panes.Pdf.enabled;
const Layer = @import("Layer.zig");
const layout = @import("layout.zig");
const Pane = panes.Pane;
@@ -18,7 +17,6 @@ const TAG_TEXT_INSET = pardes.TAG_TEXT_INSET;
const Pardes = pardes.Pardes;
pub const pane_tail = " " ++ config.pane_builtins_str;
-pub const pdf_pane_tail = " " ++ config.pdf_pane_builtins_str;
pub const file_pane_tail = " " ++ config.file_pane_builtins_str;
fn withFileCommands(comptime tail: []const u8, comptime words: []const u8) []const u8 {
std.debug.assert(std.mem.endsWith(u8, tail, " Del"));
@@ -116,8 +114,6 @@ fn shownDir(arena: std.mem.Allocator, pane: *Pane) ![]const u8 {
/// PDF's page, a terminal's directory -- without the space that parts it
/// from the tag's own text. It is never stored, and never edited.
pub fn pathPrefix(p: *const Pardes, arena: std.mem.Allocator, pane: *Pane) ![]const u8 {
- if (comptime pdf_enabled) if (pane.pdf) |pv|
- return std.fmt.allocPrint(arena, "{s} [{d}/{d}]", .{ pv.path, pv.page + 1, pv.page_count });
// What is drawn: with no graphics, glyph art whatever `Petscii` says.
if (pane.addon != null) return pardes.Kind.prefix(p, arena, pane);
// A command pane: its directory, the line it runs, and how that went.
@@ -185,7 +181,8 @@ pub fn curTail(pane: *Pane) []const u8 {
}
pub fn defaultTail(pane: *const Pane) []const u8 {
- if (comptime pdf_enabled) if (pane.pdf != null) return pdf_pane_tail;
+ // A kind's: Term, its words for its panes, Collapse Del (Kind.open).
+ if (pane.addon) |k| if (k.tail.len > 0) return k.tail.slice();
if (pane.query) |q| return if (q.frozen) query_frozen_tail else if (q.capped) query_capped_tail else query_live_tail;
if (pane.file) |file| if (file.output) |out| if (out.from == .preview) return query_live_tail;
if (pane.file) |file| if (file.listing != null) return dir_pane_tail;
@@ -293,8 +290,11 @@ pub fn wrapTag(arena: std.mem.Allocator, whole: []const u8, width: usize) !Shown
if (!first) try out.append(arena, '\n');
first = false;
var rest = line;
- while (panes.File.displayWidth(rest) > w) {
- var cut = modal.graphemeStart(rest, panes.File.rawAtDisplay(rest, w));
+ // The grapheme at column w, if the row runs past it: a row's
+ // measure, never the whole rest's (this runs on every step).
+ while (true) {
+ var cut = panes.File.byteAtDisplay(rest, w);
+ if (cut >= rest.len) break;
if (cut == 0) cut = modal.nextGrapheme(rest, 0);
try out.appendSlice(arena, rest[0..cut]);
try soft.append(arena, out.items.len);
diff --git a/src/tape.zig b/src/tape.zig
index cd777f96..2354fb06 100644
--- a/src/tape.zig
+++ b/src/tape.zig
@@ -573,7 +573,6 @@ pub const Tape = struct {
};
const gpa = t.core_gpa orelse t.gpa;
opts.image_allocator = gpa;
- opts.pdf_allocator = gpa;
opts.tree_sitter_allocator = gpa;
opts.frame_allocator = gpa;
t.core = switch (input) {
@@ -1033,6 +1032,12 @@ pub fn speculating() bool {
return if (on) |t| t.speculating else false;
}
+/// Inside a step: one being recorded, a replica's replay of one, or its
+/// speculation. A read made between steps (a frame drawn) is none.
+pub fn stepping() bool {
+ return if (on) |t| t.depth > 0 or t.replay or t.speculating else false;
+}
+
/// Screen-state terminals, on either side (`Tape.screen_state`).
pub fn screenState() bool {
return if (on) |t| t.screen_state else false;
@@ -1242,10 +1247,7 @@ pub fn startFromEnv() void {
pub fn replayMain(io: std.Io, path: []const u8) u8 {
const gpa = std.heap.c_allocator;
// What a shell starts before its core (tui.zig's localSession).
- if (comptime pardes.pdf_enabled) {
- pardes.TerminalImages.start(io, gpa);
- pardes.pdf.start(gpa);
- }
+ pardes.TerminalImages.start(io, gpa);
pardes.syntax.start(gpa);
const bytes = std.Io.Dir.cwd().readFileAlloc(std.Io.Threaded.global_single_threaded.io(), path, gpa, .unlimited) catch |err| {
std.debug.print("replay: cannot read {s}: {t}\n", .{ path, err });
diff --git a/src/terminal.zig b/src/terminal.zig
index 8204b0af..3d2e4943 100644
--- a/src/terminal.zig
+++ b/src/terminal.zig
@@ -21,9 +21,8 @@ pub const history_max = 64;
pub const VtSlot = ghostty_vt.Terminal;
/// A cell of an emulator's pages, as `getCell` reads it (src/echo.zig).
pub const PageCell = ghostty_vt.PageList.Cell;
-/// Kitty graphics are drawn where pixel geometry is (pdf_enabled, as for
-/// image panes' native placements).
-pub const images_enabled = pardes.pdf_enabled;
+/// Kitty graphics: a program's images are placements, as a kind's are.
+pub const images_enabled = true;
pub const TerminalImages = if (images_enabled) @import("TerminalImages.zig") else void;
pub const StreamSlot = ghostty_vt.Stream(MarkedHandler);
diff --git a/src/tui/tui.zig b/src/tui/tui.zig
index fd47cb67..78789f69 100644
--- a/src/tui/tui.zig
+++ b/src/tui/tui.zig
@@ -984,7 +984,6 @@ test "Kitty PDF fragments never declare pixels beyond their clipped bottom" {
}
test "on a terminal with no kitty graphics a program's 64x64 image over 8x4 cells is glyph art in every cell, and pixels stay put where it has them" {
- if (comptime !pardes.pdf_enabled) return;
const gpa = std.testing.allocator;
const core = try pardes.Pardes.init(gpa, .{ .cols = 120, .rows = 40, .shells = 1 });
defer core.deinit();
@@ -1023,66 +1022,6 @@ test "on a terminal with no kitty graphics a program's 64x64 image over 8x4 cell
try std.testing.expectEqual(@as(usize, 32), painted);
}
-test "host watch closes initial race and reloads rename-over PDF while idle" {
- if (comptime !file_watch.supported or !pardes.pdf_enabled) return;
- const io = std.testing.io;
- const gpa = std.testing.allocator;
- var tmp = std.testing.tmpDir(.{});
- defer tmp.cleanup();
- const original = try pardes.pdf.testFixture(gpa, "outline.pdf");
- defer gpa.free(original);
- const replacement = try pardes.pdf.testFixture(gpa, "offset-rotated.pdf");
- defer gpa.free(replacement);
- try tmp.dir.writeFile(io, .{ .sub_path = "live.pdf", .data = original });
- try tmp.dir.writeFile(io, .{ .sub_path = "initial.pdf", .data = replacement });
- try tmp.dir.writeFile(io, .{ .sub_path = "live-replacement.pdf", .data = original });
- var path_buf: [256]u8 = undefined;
- const path = try std.fmt.bufPrint(&path_buf, ".zig-cache/tmp/{s}/live.pdf", .{tmp.sub_path});
-
- const fd = file_watch.init(true);
- if (fd < 0) return error.WatchInitFailed;
- defer _ = libc.close(fd);
- var watches: file_watch.Table = @splat(null);
- defer file_watch.unwatchAll(fd, &watches);
-
- const core = try pardes.Pardes.init(gpa, .{ .file = path, .cols = 80, .rows = 28 });
- defer core.deinit();
- try std.testing.expectEqual(@as(usize, 3), core.panes[0].?.pdf.?.page_count);
-
- try tmp.dir.rename("initial.pdf", tmp.dir, "live.pdf", io);
- var armed = false;
- while (core.nextEffect()) |effect| switch (effect) {
- .watch => |watch| if (watch.pane == 0 and watch.on) {
- armed = true;
- try std.testing.expect(!file_watch.applyEffect(core, io, fd, &watches, 0, true, watch.mode));
- },
- else => {},
- };
- try std.testing.expect(armed and watches[0] != null);
- try std.testing.expectEqual(@as(usize, 1), core.panes[0].?.pdf.?.page_count);
-
- try tmp.dir.rename("live-replacement.pdf", tmp.dir, "live.pdf", io);
- try std.testing.expect(file_watch.drain(fd));
-
- try std.testing.expect(!file_watch.reloadChanged(core, io, gpa, &watches));
- const pane = core.panes[0].?;
- try std.testing.expectEqual(@as(usize, 3), pane.pdf.?.page_count);
- const disk_identity = try file_watch.identify(io, path);
- switch (watches[0].?.generation) {
- .pdf => |accepted| try std.testing.expect(accepted != null and accepted.?.eql(disk_identity)),
- .text => return error.PdfWatchStoredTextGeneration,
- }
- try std.testing.expect(std.mem.indexOf(u8, pane.msg[0..pane.msg_len], "reloaded") != null);
-
- core.view().frontend.native_images = true;
- var frame = std.heap.ArenaAllocator.init(gpa);
- defer frame.deinit();
- const surface = try core.render(frame.allocator());
- try std.testing.expect(surface.placements.items.len > 0);
- const shown = surface.placements.items[0];
- try std.testing.expectEqual(pardes.Placement.keyOf(pane.serial, 0, pardes.panes.Pdf.rasterForPage(pane.pdf.?, 0).?.revision), shown.key);
-}
-
fn kittyImageRepresentable(place: pardes.Placement) bool {
return place.raster.w > 0 and place.raster.h > 0 and
place.raster.w <= std.math.maxInt(u16) and place.raster.h <= std.math.maxInt(u16);
@@ -1096,26 +1035,6 @@ fn surfaceHasKittyKey(surface: *const pardes.Surface, key: u64) bool {
return false;
}
-const PdfWheelTarget = struct { pane: usize, page: usize };
-
-fn nativePdfWheelTarget(core: *const pardes.Pardes, mouse: vaxis.Mouse) ?PdfWheelTarget {
- if (comptime !pardes.pdf_enabled) return null;
- if (!core.view().frontend.native_images or mouse.type != .press or
- (mouse.button != .wheel_up and mouse.button != .wheel_down) or
- mouse.col < 0 or mouse.row < 0) return null;
- const col: u16 = @intCast(mouse.col);
- const row: u16 = @intCast(mouse.row);
- for (core.panes, 0..) |slot, id| {
- const pane = slot orelse continue;
- const rect = core.view().rects[id];
- if (col < rect.x or col >= rect.x + rect.w or
- row < rect.y or row >= rect.y + rect.h) continue;
- const page = pane.pdfPage() orelse return null;
- return .{ .pane = id, .page = page };
- }
- return null;
-}
-
/// Where a session's terminal comes from: /dev/tty, as a plain `pardes`
/// opens it; one open already (a session forked off its stub,
/// daemon.forkSession); or none, until one is attached (`--detach`).
@@ -1221,21 +1140,15 @@ pub fn remote(init: std.process.Init, opts: pardes.Options, path: []const u8, se
const have: ?*replica.Have = if (far) &have_store else null;
const allocs = pardes.memory.init(gpa);
defer pardes.memory.deinit();
- if (comptime pardes.pdf_enabled) {
- pardes.TerminalImages.start(io, allocs.image);
- pardes.pdf.start(allocs.pdf);
- }
+ pardes.TerminalImages.start(io, allocs.image);
+ pardes.Kind.heap = allocs.addon;
pardes.syntax.start(allocs.tree_sitter);
defer {
- if (comptime pardes.pdf_enabled) {
- pardes.TerminalImages.stop();
- pardes.pdf.stop();
- }
+ pardes.TerminalImages.stop();
pardes.syntax.stop();
}
var o = opts;
o.image_allocator = allocs.image;
- o.pdf_allocator = allocs.pdf;
var joined: replica.Joined = undefined;
var r = replica.join(gpa, &joined, path, session, o, have, &why, null) orelse Said.no(io, "{s}", .{std.mem.sliceTo(&why, 0)});
@@ -1507,7 +1420,6 @@ fn localSession(
defer pardes.memory.deinit();
var options = opts;
options.image_allocator = allocs.image;
- options.pdf_allocator = allocs.pdf;
options.tree_sitter_allocator = allocs.tree_sitter;
options.frame_allocator = allocs.frame;
@@ -1668,9 +1580,7 @@ fn localSession(
core.deinit();
core = nc;
sh.core = nc;
- if (comptime pardes.pdf_enabled) if (live.on) {
- core.update(.{ .resize = terminalSize(live.vx.screen.width, live.vx.screen.height, live.vx.screen.width_pix, live.vx.screen.height_pix) });
- };
+ if (live.on) core.update(.{ .resize = terminalSize(live.vx.screen.width, live.vx.screen.height, live.vx.screen.width_pix, live.vx.screen.height_pix) });
}
}
if (fs) |f| {
@@ -2316,17 +2226,7 @@ const Shell = struct {
const room = max_paste_bytes -| s.paste_buf.written().len;
s.paste_buf.writer.writeAll(bytes[0..@min(bytes.len, room)]) catch {};
} else s.feed(vaxis_input.keyEvent(key)),
- .mouse => |m| {
- const pdf_before = nativePdfWheelTarget(core, m);
- if (mouseEvent(m)) |ev| s.feed(ev);
- if (pdf_before) |before| {
- if (core.panes[before.pane]) |pane| {
- if (pane.pdfPage()) |page| {
- if (page != before.page) return true;
- }
- }
- }
- },
+ .mouse => |m| if (mouseEvent(m)) |ev| s.feed(ev),
.paste => |bytes| {
s.feed(.{ .paste = bytes });
s.gpa.free(@constCast(bytes));
@@ -2385,7 +2285,7 @@ const Shell = struct {
sc.size = ws;
sc.vx.resize(s.gpa, sc.tty.writer(), ws) catch {};
}
- s.feed(.{ .resize = if (comptime pardes.pdf_enabled) terminalSize(ws.cols, ws.rows, ws.x_pixel, ws.y_pixel) else .{ .cols = ws.cols, .rows = ws.rows } });
+ s.feed(.{ .resize = terminalSize(ws.cols, ws.rows, ws.x_pixel, ws.y_pixel) });
}
/// A SIGWINCH: the terminal, if it changed size, resized in its view
diff --git a/src/walk.zig b/src/walk.zig
index dc743a4d..d7ee63b3 100644
--- a/src/walk.zig
+++ b/src/walk.zig
@@ -1051,7 +1051,6 @@ const DecodeError = error{ EndOfDump, BadDump, Incompatible, OutOfMemory };
/// `image` holds with `allocs.image`.
const Allocators = struct {
image: ?std.mem.Allocator = null,
- pdf: ?std.mem.Allocator = null,
terminal: ?std.mem.Allocator = null,
};
@@ -1281,8 +1280,8 @@ pub fn Load(comptime roots: []const type) type {
out.* = .{ .raw = raw };
return;
}
- // A field this build compiles out (a PDF slot where there is no
- // MuPDF): passed over, said only when it held something.
+ // A field this build compiles out (a void field): passed over,
+ // said only when it held something.
if (comptime kindOf(Canon(T)) == .void) if (!l.same and l.src[ty].kind != .void) {
const held = l.src[ty].kind != .optional or (l.at < l.bytes.len and l.bytes[l.at] != 0);
try l.skip(ty);
@@ -2378,8 +2377,8 @@ pub const Get = struct {
if (comptime allocOf(T, field)) |which| if (@field(l.allocs, which)) |a| {
l.gpa = a;
};
- // A field this build compiles out (a PDF slot where there is no
- // MuPDF): passed over, said when it held something.
+ // A field this build compiles out (a void field): passed over,
+ // said when it held something.
if (comptime kindOf(Canon(F)) == .void) {
if ((try slotOf(c)).tag != .none) l.note("{s}: not in this build", .{l.field});
return;
diff --git a/src/wire.zig b/src/wire.zig
index 91e805e7..d083ea82 100644
--- a/src/wire.zig
+++ b/src/wire.zig
@@ -9,6 +9,8 @@ const builtin = @import("builtin");
const pardes = @import("pardes.zig");
const config = @import("pardes_config");
+/// 22: a PDF's pixel scroll (0x1a) is gone with the core's PDF, the pdf
+/// addon's panes scrolled by the wheel as any kind's are;
/// 21: a session's views are `Pardes.views` in its dump and its digest
/// (src/views.zig), the panes' shares of the others under `shares`;
/// 20: a digest takes a blob of 4 KiB and up (a file's text, a register's,
@@ -29,7 +31,7 @@ const config = @import("pardes_config");
/// part B); 14: the hello names a session and
/// carries the semantics hash, and a ping is answered (phase 5's
/// groundwork); 13: the frames went (phase 3).
-pub const version: u16 = 21;
+pub const version: u16 = 22;
/// The terminal's build and the window's step alike (`semantics`).
const family = switch (config.platform) {
@@ -56,13 +58,13 @@ const family = switch (config.platform) {
pub const semantics: u64 = blk: {
@setEvalBranchQuota(1_000_000);
break :blk std.hash.Wyhash.hash(0, std.fmt.comptimePrint(
- "wire {d}\npardes {s} {s}\n{s} grammars {} {} {} {} mupdf {} workspace_tag {} sources {}\nusize {d} {t}\n{s}\n{s}",
+ "wire {d}\npardes {s} {s}\n{s} grammars {} {} {} {} workspace_tag {} sources {}\nusize {d} {t}\n{s}\n{s}",
.{
version, config.version, config.commit orelse "unstamped",
family, config.syntax_highlighting, config.syntax_zig_grammar,
- config.syntax_minimal_grammars, config.syntax_full_grammars, config.mupdf,
- config.workspace_tag, config.embed_sources, @sizeOf(usize),
- builtin.cpu.arch.endian(), config.deps, pardes.tape.shape,
+ config.syntax_minimal_grammars, config.syntax_full_grammars, config.workspace_tag,
+ config.embed_sources, @sizeOf(usize), builtin.cpu.arch.endian(),
+ config.deps, pardes.tape.shape,
},
));
};
@@ -103,8 +105,8 @@ pub const ClientTag = enum(u8) {
resize = 0x12,
paste = 0x18,
command = 0x19,
- pdf_scroll = 0x1a,
- // 0x1b and 0x1c were a pinch and a touch scroll, gone since.
+ // 0x1a was a PDF's pixel scroll, 0x1b and 0x1c a pinch and a touch
+ // scroll, gone since.
pointer_leave = 0x1d,
focus = 0x1e,
/// Which frontend the client is: a window, or a terminal.
@@ -323,14 +325,6 @@ fn getSlice32(r: *std.Io.Reader) Error![]const u8 {
return r.take(n);
}
-/// A pane id the core can actually index. `Event.output{ .pane = 200 }`
-/// would reach `p.panes[200]`.
-fn getPane(r: *std.Io.Reader) Error!u8 {
- const pane = try r.takeByte();
- if (pane >= pardes.MAX_PANES) return error.BadValue;
- return pane;
-}
-
/// A grid the core can render into. Zero is refused rather than clamped: a
/// frontend that has not been sized yet must not be allowed to collapse a
/// shared session to nothing.
@@ -539,11 +533,6 @@ pub fn encodeClient(out: []u8, msg: ClientMsg) Error![]const u8 {
},
.paste => |b| try putSlice32(&w, b),
.command => |line| try putSlice16(&w, line),
- .pdf_scroll => |s| {
- try w.writeByte(s.pane);
- try w.writeInt(u32, @bitCast(s.delta_pixels), .little);
- try w.writeByte(@intFromBool(s.glide));
- },
.pointer_leave => {},
.focus => |focused| try w.writeByte(@intFromBool(focused)),
.frontend => |f| {
@@ -623,7 +612,6 @@ pub fn decodeClient(tag: u8, payload: []const u8) Error!ClientMsg {
},
.paste => .{ .event = .{ .paste = try getSlice32(&r) } },
.command => .{ .event = .{ .command = try r.take(try r.takeInt(u16, .little)) } },
- .pdf_scroll => .{ .event = .{ .pdf_scroll = .{ .pane = try getPane(&r), .delta_pixels = try getF32(&r), .glide = try getBool(&r) } } },
.pointer_leave => .{ .event = .pointer_leave },
.focus => .{ .event = .{ .focus = try getBool(&r) } },
.frontend => .{ .event = .{ .frontend = .{ .windowed = try getBool(&r), .native_images = try getBool(&r), .native_image_patches = try getBool(&r) } } },
@@ -646,7 +634,7 @@ pub fn clientBound(msg: ClientMsg) usize {
.event => |ev| switch (ev) {
// Its hits' places (14 bytes each) past the slack.
.mouse => 28,
- .resize, .pdf_scroll, .pointer_leave, .focus, .frontend => 0,
+ .resize, .pointer_leave, .focus, .frontend => 0,
.key => |k| k.text.len,
.paste => |b| b.len,
.command => |line| line.len,
@@ -746,12 +734,6 @@ test "detached wire: every Event variant round-trips" {
}
try testing.expectEqualStrings("clip", (try roundClient(&buf, .{ .event = .{ .paste = "clip" } })).event.paste);
try testing.expectEqualStrings("Look /x", (try roundClient(&buf, .{ .event = .{ .command = "Look /x" } })).event.command);
- {
- const got = (try roundClient(&buf, .{ .event = .{ .pdf_scroll = .{ .pane = 2, .delta_pixels = -12.5, .glide = false } } })).event.pdf_scroll;
- try testing.expectEqual(@as(u8, 2), got.pane);
- try testing.expectEqual(@as(f32, -12.5), got.delta_pixels);
- try testing.expect(!got.glide);
- }
try testing.expectEqual(
std.meta.Tag(pardes.Event).pointer_leave,
(try roundClient(&buf, .{ .event = .pointer_leave })).event,
@@ -780,7 +762,7 @@ test "detached wire: a session is never told to do a frontend's remembering" {
"stamp",
// ...and everything a person can do to a window.
"key", "mouse", "resize",
- "paste", "command", "pdf_scroll", "pointer_leave", "focus",
+ "paste", "command", "pointer_leave", "focus",
// ...and which of its frontends the person sits at: a window, or a
// terminal (what the view draws, and the words it takes).
"frontend",
@@ -893,13 +875,6 @@ test "detached wire: values a field cannot mean are refused" {
@backingInt(ClientTag.key),
&.{ 0x00, 0x00, 0x11, 0x00, 0, 0, 0, 0, 0 },
));
- // A pane the core cannot index. `pdf_scroll` reads its pane byte before the
- // f32 that follows, so a one-byte payload reaches the check this is about
- // rather than tripping `EndOfStream` first.
- try testing.expectError(error.BadValue, decodeClient(
- @backingInt(ClientTag.pdf_scroll),
- &.{pardes.MAX_PANES},
- ));
// A session name longer than the daemon keeps one: refused, never cut
// to another session's name.
{
@@ -912,14 +887,6 @@ test "detached wire: values a field cannot mean are refused" {
try testing.expectEqual(@as(usize, max_name), (try decodeClient(@backingInt(ClientTag.hello), &hello)).hello.session.len);
try testing.expect(header_len + hello.len == hello_max);
}
- // A NaN or an infinite scroll distance.
- {
- var scroll: [6]u8 = .{ 0, 0, 0, 0, 0, 1 };
- std.mem.writeInt(u32, scroll[1..5], @bitCast(std.math.nan(f32)), .little);
- try testing.expectError(error.BadValue, decodeClient(@backingInt(ClientTag.pdf_scroll), &scroll));
- std.mem.writeInt(u32, scroll[1..5], @bitCast(std.math.inf(f32)), .little);
- try testing.expectError(error.BadValue, decodeClient(@backingInt(ClientTag.pdf_scroll), &scroll));
- }
}
test "detached wire: max_payload bounds every message this protocol can build" {