From c1917b949b9580de8bf0977874a210f0266812da Mon Sep 17 00:00:00 2001 From: Gabriel Schneider Date: Fri, 6 Nov 2026 06:24:42 -0300 Subject: kinds #14, the core's PDF code gone: pdf.zig and pdf_view.zig leave and every pdf_enabled branch with them; look, Jump, Recent, dumps (one from before the addon opens as its pane), the watch, mouse, keys, the rail and the tag go through Kind for any kind's pane; test/pdf.zig's behaviours are T1 cases over 9P (addons_pdf.zig) and pane cases (a Shadow over a replica, a file changed under it), the harnesses load pdf.so by path Co-Authored-By: Claude Fable 5.1 Claude-Session: https://claude.ai/code/session_016Y9MNAtZenFv4weoMD3cge --- src/pdf_view.zig | 3721 ------------------------------------------------------ 1 file changed, 3721 deletions(-) delete mode 100644 src/pdf_view.zig (limited to 'src/pdf_view.zig') 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 {}; -- cgit v1.3