summaryrefslogtreecommitdiff
path: root/src/pdf_view.zig
diff options
context:
space:
mode:
Diffstat (limited to 'src/pdf_view.zig')
-rw-r--r--src/pdf_view.zig3721
1 files changed, 0 insertions, 3721 deletions
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 {};