diff options
Diffstat (limited to 'addons/pdf/pdf.zig')
| -rw-r--r-- | addons/pdf/pdf.zig | 1505 |
1 files changed, 1505 insertions, 0 deletions
diff --git a/addons/pdf/pdf.zig b/addons/pdf/pdf.zig new file mode 100644 index 00000000..d10407e0 --- /dev/null +++ b/addons/pdf/pdf.zig @@ -0,0 +1,1505 @@ +//! pdf.zig: PDFs as a pardes addon, in Zig over MuPDF through pdf_bridge.c +//! (C, so MuPDF's throws stay in C; build.zig translates its header for +//! this file as `pdf_bridge`). +//! +//! A pane is one place, a page and how far down it (what `where` says and +//! `address` takes), shown by each of its views its own way. A view with +//! pictures lays out a strip of the pages at its pixels, each fitted to its +//! width or height (PdfFit), a gap between two, tinted to the theme or not +//! (PdfTint), and asks for the rasters it shows; a view of glyphs (a +//! terminal without graphics) shows the page's text layer. Pages render off the loop on jobs, two at once: a +//! pane's document has two lanes (a context and a document of their own +//! each, MuPDF's threading rule), found by the jobs in a table of the open +//! documents under its own lock, and a cookie stops a job nobody waits +//! for. The pages' sizes, the page's text and its search hits, and the +//! search over every page are jobs on the lanes too; a selection and the +//! pointer's word are MuPDF's on the loop. A highlight (the pointer's word +//! or link, the search's hits, the selection) is MuPDF's highlight pass +//! over the page's clean rows, repainted on the loop and said as rows +//! (`from`, `dirty_*`). The body is the text of the page shown; `/` lists +//! hits as `file.pdf:P:H`; PdfSections lists the outline; a click on a +//! link follows it. A fling (a window's travel or more between frames) +//! renders only the rows each page shows until it rests. The record in a dump is its fit, tint +//! and place. +const std = @import("std"); +const addon = @import("addon"); +const m = @import("pdf_bridge"); +const c = addon.c; + +pub const pardes_addon = addon.ops(Pdf); +// A library's one export; a static pardes reads the declaration (Addon.zig). +comptime { + if (@import("builtin").output_mode == .Lib) @export(&pardes_addon, .{ .name = "pardes_addon" }); +} + +const gap_px = 8; // between two pages of the strip +const slots_n = 16; // pages' pixels a pane holds at once, all its views' +const lanes = 2; // jobs a document runs at once +const jobs_n = 8; +const views_n = 4; // views a pane is told of, by id +const max_hits = 512; // rows a search lists +const band_rows = 8192; +const chunk = 512; // a tall page's bands start on these +const overlap = 32; // rows rendered past a band's edges +const hover_ns = 32 * std.time.ns_per_ms; // the pointer's rest before its word shows +const fling_ns = 100 * std.time.ns_per_ms; // a fling's end: this long with no turn +const grain = 64; // a fling's band starts and ends on these rows +const marks_n = 1024; // highlights on a page +const record_version = 1; + +const heap = addon.heap; +const ok = m.PARDES_PDF_OK; +const Quad = m.pardes_pdf_quad; +const Mark = m.pardes_pdf_highlight; +const Point = m.pardes_pdf_point; +const Request = m.pardes_pdf_request; +const Button = @FieldType(addon.Mouse, "button"); + +fn f64Of(x: anytype) f64 { + return @floatFromInt(x); +} + +// ---- the tint: a page's ink and paper to the theme's ---- + +const Tint = enum(u32) { disabled, filtered, full }; + +/// Rec. 601 luminance (77/150/29). `full` maps black to the theme's text +/// and white to its paper; `filtered` starts there and adds back 3/4 of each +/// channel's distance from the luminance, so grey is the same in both and +/// colour keeps its hue. Alpha is never touched. A page is runs of one +/// value, so the last pixel's answer is kept. +fn tint(px: []u8, mode: Tint, ink: u32, paper: u32) void { + if (mode == .disabled) return; + var target: [256][3]u8 = undefined; + for (&target, 0..) |*t, l| for (t, 0..) |*v, ch| { + const f = (ink >> @intCast(16 - 8 * ch)) & 0xff; + const b = (paper >> @intCast(16 - 8 * ch)) & 0xff; + v.* = @intCast((f * (255 - @as(u32, @intCast(l))) + b * @as(u32, @intCast(l)) + 127) / 255); + }; + var last: ?[2][4]u8 = null; + var i: usize = 0; + while (i + 4 <= px.len) : (i += 4) { + const p = px[i..][0..4]; + if (last) |was| if (std.mem.eql(u8, p, &was[0])) { + p.* = was[1]; + continue; + }; + const in = p.*; + const lum = (@as(i32, p[0]) * 77 + @as(i32, p[1]) * 150 + @as(i32, p[2]) * 29 + 128) >> 8; + for (p[0..3], target[@intCast(lum)]) |*v, t| { + const d = if (mode == .filtered) @divTrunc((@as(i32, v.*) - lum) * 3, 4) else 0; + v.* = @intCast(std.math.clamp(@as(i32, t) + d, 0, 255)); + } + last = .{ in, p.* }; + } +} + +// ---- the documents the jobs see ---- + +/// A pane's document and its lanes, shared with the jobs: found by id in +/// `docs` under `docs_lock`, alive while its pane is open or a job runs on +/// it. A job's pixels are its until the pane takes them (`unclaimed`): an +/// answer nobody takes is freed with the document. +const Doc = struct { id: u64 = 0, refs: u32 = 1, closed: bool = false, base: ?*m.pardes_pdf_document = null, lane: [lanes]?*m.pardes_pdf_document = @splat(null), busy: [lanes]bool = @splat(false), cookie: [jobs_n]m.pardes_pdf_cookie = std.mem.zeroes([jobs_n]m.pardes_pdf_cookie), unclaimed: [24][]u8 = @splat(&.{}) }; + +var docs_lock: std.atomic.Mutex = .unlocked; +var docs: [64]?*Doc = @splat(null); +var doc_ids: u64 = 0; + +fn lock() void { + while (!docs_lock.tryLock()) std.atomic.spinLoopHint(); +} + +fn docFree(d: *Doc) void { + for (d.unclaimed) |p| heap.free(p); + for (d.lane) |l| m.pardes_pdf_close(l); + m.pardes_pdf_close(d.base); + heap.destroy(d); +} + +/// One more reference to the open document `id`, or null. +fn docTake(id: u64) ?*Doc { + lock(); + defer docs_lock.unlock(); + for (docs) |slot| if (slot) |d| if (d.id == id and !d.closed) { + d.refs += 1; + return d; + }; + return null; +} + +fn docDrop(d: *Doc, closing: bool) void { + lock(); + d.closed = d.closed or closing; + d.refs -= 1; + const last = d.refs == 0; + if (last) if (std.mem.indexOfScalar(?*Doc, &docs, d)) |i| { + docs[i] = null; + }; + docs_lock.unlock(); + if (last) docFree(d); +} + +/// A job's pixels the pane's now. +fn claim(d: *Doc, p: []const u8) void { + if (p.len == 0) return; + lock(); + for (&d.unclaimed) |*u| if (u.ptr == p.ptr) { + u.* = &.{}; + }; + docs_lock.unlock(); +} + +// ---- a pane ---- + +/// Page `page`'s pixels for view `view` (0: none): `band_h` rows from +/// `band_y` of its `w` x `h` raster, as `req`, the tint and `shown` made +/// them (`clean` before highlights and tint, kept once highlighted), its +/// key `rev`, and `from` the key it is of but rows `dirty_*`; and the job +/// it waits for (`token`), asked as `want` and `asked`. +const Slot = struct { + view: u8 = 0, + page: u32 = 0, + rgba: []u8 = &.{}, + clean: []u8 = &.{}, + shown: []Mark = &.{}, + asked: []Mark = &.{}, + is: struct { w: u32 = 0, h: u32 = 0, band_y: u32 = 0, band_h: u32 = 0, rev: u32 = 0, from: u32 = 0, dirty_y: u32 = 0, dirty_h: u32 = 0, req: Request = std.mem.zeroes(Request), tint: Tint = .disabled, ink: u32 = 0, paper: u32 = 0 } = .{}, + job: struct { token: u32 = 0, want: Request = std.mem.zeroes(Request), y: u32 = 0, h: u32 = 0, failed: bool = false } = .{}, + + fn clear(s: *Slot) void { + for ([_][]const u8{ s.rgba, s.clean, std.mem.sliceAsBytes(s.shown), std.mem.sliceAsBytes(s.asked) }) |p| heap.free(p); + s.* = .{}; + } +}; + +/// A view as told (`v`) and, with pictures, the strip laid out at its +/// `vw` x `vh` pixels (`fit`, height): each page's top (`y`) and height +/// (`ph`) on it, and the strip's pixel at its window's top, laid at the +/// place's `rev`. +const Layout = struct { v: addon.View = std.mem.zeroes(addon.View), y: []u64 = &.{}, ph: []u32 = &.{}, height: u64 = 0, vw: u32 = 0, vh: u32 = 0, fit: bool = false, laid: bool = false, top: f64 = 0, rev: u32 = 0 }; + +/// A page's text, and its lines. +const Text = struct { bytes: []u8 = &.{}, page: ?u32 = null, lines: u32 = 0 }; +const Op = enum(u32) { render, sizes, page, search }; +const Job = struct { token: u32 = 0, op: Op = .render, page: u32 = 0 }; + +pub const Pdf = struct { + d: ?*Doc = null, + name: []const u8 = "", // the file's, in the rows a pane lists + pages: u32 = 0, + size: []m.pardes_pdf_page_size = &.{}, + sizes_assumed: bool = false, + /// The place: the page at the window's top and how far down it, one + /// for the pane whatever views show it; `rev` moves at each change. + page: u32 = 0, + frac: f64 = 0, + rev: u32 = 1, + pan: u16 = 0, // fit height: how far across, 0..65535 + fit_height: bool = false, + tint: Tint = .filtered, + views: [views_n]Layout = @splat(.{}), + /// The view of the last input (an id), else the first told: whose + /// window's top the place follows. + active: u8 = 0, + s: [slots_n]Slot = @splat(.{}), + revs: u32 = 0, + jobs: [jobs_n]Job = @splat(.{}), + warm: bool = false, + blank: [4]u8 = .{ 255, 255, 255, 255 }, // the paper a page shows until its pixels land + /// The text of the page shown, a job's; a body read's own, which no + /// frame shows. + text: Text = .{}, + read: Text = .{}, + /// The search: its pattern, each page's hits (its job's, `counts`), + /// and the page shown's quads (`hits`, `hits_page`'s). + find: struct { query: [256]u8 = undefined, len: u32 = 0, due: bool = false, counts: []u32 = &.{}, hits: []m.pardes_pdf_search_quad = &.{}, hits_page: ?u32 = null, hit: u32 = 0, reveal: bool = false } = .{}, + /// The selection: its quads and text on its page, from `anchor` to `tip`. + sel: struct { quads: []Quad = &.{}, text: []u8 = &.{}, page: ?u32 = null, anchor: Point = .{ .x = 0, .y = 0 }, tip: Point = .{ .x = 0, .y = 0 } } = .{}, + /// A button held (a right one's Look waits for a drag off its cell), + /// and whether another came while it was (a chord). + press: struct { button: ?Button = null, chorded: bool = false, look: bool = false, col: u16 = 0, row: u16 = 0, page: ?u32 = null } = .{}, + /// The pointer's word or link where it rests: `wait` 1 moved, 2 resting + /// until `at`. + hover: struct { quad: Quad = std.mem.zeroes(Quad), page: ?u32 = null, link: bool = false, wait: u2 = 0, col: u16 = 0, row: u16 = 0, view: u8 = 0, at: u64 = 0 } = .{}, + /// A fling: the strip's travel since the last tick and since the last + /// frame drawn, a window or more of it a frame renders only the rows + /// each page shows, the whole page once it rests. + go: struct { since_tick: f64 = 0, travel: f64 = 0, framed: bool = false, landed: bool = false, fling: bool = false } = .{}, + count: u32 = 0, // a key's count, typed before it + g: bool = false, + + pub const head: addon.Head = .{ .name = "pdf", .version = 1, .exts = ".pdf", .pictures = true, .words = &.{ + .{ .name = "PdfSections", .leader = "ts", .doc = "list the PDF's sections in a pane, each a place to go" }, + .{ .name = "PdfTint", .leader = "ti", .arg = .optional, .doc = "tint the PDF to the theme or show it as printed (disabled|filtered|full)" }, + .{ .name = "PdfFit", .leader = "tz", .arg = .optional, .doc = "fit the PDF's pages to the pane's width or height (width|height)" }, + } }; + + /// MuPDF's memory is pardes's heap. + pub fn init() bool { + const H = struct { + fn alloc(_: ?*anyopaque, n: usize) callconv(.c) ?*anyopaque { + return addon.api.heap.?(null, @max(n, 1)); + } + fn realloc(_: ?*anyopaque, p: ?*anyopaque, n: usize) callconv(.c) ?*anyopaque { + return addon.api.heap.?(p, @max(n, 1)); + } + fn free(_: ?*anyopaque, p: ?*anyopaque) callconv(.c) void { + if (p != null) _ = addon.api.heap.?(p, 0); + } + const hooks: m.pardes_pdf_allocator = .{ .user = null, .alloc = alloc, .realloc = realloc, .free = free }; + }; + return m.pardes_pdf_set_allocator(&H.hooks) == ok; + } + + pub fn open(st: *Pdf, path: ?[]const u8, bytes: ?[]const u8) void { + if (path) |p| st.name = addon.arena.dupe(u8, std.fs.path.basename(p)) catch ""; + const b = bytes orelse return; + var pages: c_int = 0; + const d = heap.create(Doc) catch return; + d.* = .{ .base = m.pardes_pdf_open_memory(b.ptr, b.len, &pages) }; + if (d.base) |base| for (&d.lane) |*l| { + l.* = m.pardes_pdf_lane_clone(base); + }; + lock(); + if (d.base != null) if (std.mem.indexOfScalar(?*Doc, &docs, null)) |at| { + doc_ids += 1; + d.id = doc_ids; + docs[at] = d; + }; + docs_lock.unlock(); + st.pages = @intCast(pages); + st.size = if (d.id != 0) addon.arena.alloc(m.pardes_pdf_page_size, st.pages) catch &.{} else &.{}; + if (st.size.len == 0 or m.pardes_pdf_get_page_size(d.base, 0, &st.size[0]) != ok) { + if (d.id != 0) docDrop(d, true) else docFree(d); + return addon.say("not a PDF pardes can read", .err); + } + st.d = d; + // every page the first's size until a lane measures them + @memset(st.size[1..], st.size[0]); + st.sizes_assumed = st.pages > 1; + } + + pub fn close(st: *Pdf) void { + for (&st.s) |*s| s.clear(); + for (st.jobs) |j| abortJob(st, j.token); + for ([_][]const u8{ st.text.bytes, st.read.bytes, std.mem.sliceAsBytes(st.find.hits) }) |p| heap.free(p); + dropSel(st); + if (st.d) |d| docDrop(d, true); + st.d = null; + } + + pub fn tick(st: *Pdf, now: u64, flags: addon.Flags) u64 { + if (st.d == null) return 0; + const go = &st.go; + // A fling is a window's travel or more between frames; a tick a + // page's landing made (no turn since) neither starts nor ends one. + go.framed = go.framed or flags.framed; + if (!(go.landed and go.since_tick == 0)) { + if (go.framed) go.travel = 0; + go.framed = false; + go.travel += go.since_tick; + go.fling = if (pixels(st, st.active)) |l| go.travel >= f64Of(l.vh) else false; + } + go.landed, go.since_tick = .{ false, 0 }; + settle(st); + for (&st.views) |*l| layout(st, l); + // white tinted is the theme's paper + const paper: u32 = if (st.tint == .disabled) 0xffffff else if (pixels(st, st.active)) |l| @backingInt(l.v.bg) else 0xffffff; + st.blank = .{ @truncate(paper >> 16), @truncate(paper >> 8), @truncate(paper), 255 }; + const hv = &st.hover; + if (hv.wait == 1) hv.wait, hv.at = .{ 2, now + hover_ns }; + if (hv.wait == 2 and now >= hv.at) { + hv.wait = 0; + if (probeAt(st, hv.view, hv.col, hv.row)) |pr| { + hv.quad, hv.page, hv.link = .{ pr.quad, pr.page, pr.link != null }; + heap.free(pr.text); + } + } + const f = &st.find; + if (f.reveal and f.hits_page == st.page) revealHit(st); + // What the place asks of the lanes: the pages' sizes, the page's + // text and hits, the search, then each view's pages. + const query = f.query[0..f.len]; + if (st.sizes_assumed and jobsOut(st, .sizes) == 0) _ = ask(st, .{ .op = .sizes, .page = st.pages }, "", ""); + const glyphs = for (st.views) |l| { + if (l.v.cols != 0 and l.v.glyphs) break true; + } else false; + if (((glyphs and st.text.page != st.page) or (query.len > 0 and f.hits_page != st.page)) and jobsOut(st, .page) == 0) _ = ask(st, .{ .op = .page, .page = st.page, .n = f.len }, query, ""); + if (f.due and ask(st, .{ .op = .search, .page = st.pages, .n = f.len }, query, st.name) != 0) f.due = false; + for (&st.views, 1..) |*l, id| if (l.laid and !l.v.glyphs) reconcile(st, l, @intCast(id)); + var next: u64 = if (hv.wait == 2) hv.at else 0; + // flinging: a tick when it rests, for the whole pages + if (go.fling and (next == 0 or now + fling_ns < next)) next = now + fling_ns; + return next; + } + + pub fn prefix(st: *const Pdf, w: *std.Io.Writer) !void { + if (st.d != null) try w.print("[{d}/{d}]", .{ st.page + 1, st.pages }); + } + + /// A view told: kept by its id; a glyph view's pictures and a stopped + /// one's are dropped. + pub fn view(st: *Pdf, v: addon.View) void { + if (v.id < 1 or v.id > views_n) return; + st.views[v.id - 1].v = v; + if (v.cols == 0 or v.glyphs) { + for (&st.s) |*s| if (s.view == v.id) { + abortJob(st, s.job.token); + s.clear(); + }; + st.views[v.id - 1].laid = false; + } + if (st.active != 0 and st.views[st.active - 1].v.cols != 0) return; + st.active = for (st.views, 1..) |o, id| { + if (o.v.cols != 0) break @intCast(id); + } else 0; + } + + pub fn paint(st: *const Pdf, win: addon.Window, into: addon.Paint) void { + if (st.d == null or win.view < 1 or win.view > views_n) return; + const out = into.out; + out.pointer = if (st.hover.page != null and st.hover.link) c.PA_POINTER_LINK else c.PA_POINTER_DEFAULT; + if (win.glyphs) { // the page's text layer, from its top (read on a tick) + out.at = @floatCast((f64Of(st.page) + std.math.clamp(st.frac, 0, 1)) / f64Of(st.pages)); + out.span = @floatCast(1 / f64Of(st.pages)); + if (st.text.page != st.page) return; + const t = st.text.bytes; + var at: usize = 0; + for (0..win.rows) |row| { + var col: usize = 0; + while (at < t.len and t[at] != '\n') { + var n: usize = 1; + while (n < 7 and at + n < t.len and t[at + n] & 0xc0 == 0x80) n += 1; + if (t[at] >= 0x20 and col < win.cols) { + const cell = &win.cells[row * win.stride + col]; + cell.* = .{ .text = @splat(0), .fg = c.PA_DEFAULT, .bg = c.PA_DEFAULT, .attrs = 0, .len = @intCast(n), .flags = c.PA_PAINTED }; + @memcpy(cell.text[0..n], t[at..][0..n]); + } + col += @intFromBool(t[at] >= 0x20); + at += n; + } + at += 1; + } + return; + } + const l = &st.views[win.view - 1]; + if (!l.laid) return; + const vh = @min(@as(u32, win.rows) * win.cell_h, l.vh); + const first, const count = visible(st, l); + for (first..first + count) |p| { + const k = @as(u64, p) << 32; + const s = if (landed(st, win.view, p)) |at| at[0] else null; + // not landed yet: its paper, where it will be + const wh: [2]u32 = if (s) |sl| .{ sl.is.w, sl.is.h } else .{ @intFromFloat(@max(1, @round(st.size[p].width * 8))), @intFromFloat(@max(1, @round(st.size[p].height * 8))) }; + const r = pageRows(st, l, @intCast(p), wh[0], wh[1], vh) orelse continue; + const paper = std.mem.zeroInit(c.pa_placement, .{ .rgba = &st.blank, .w = 1, .h = 1, .src = .{ .x = 0, .y = 0, .w = 1, .h = 1 }, .dst = .{ .x = 0, .y = 0, .w = win.cols, .h = win.rows }, .at = .{ .x = r.g.dx, .y = r.at_y, .w = r.g.dw, .h = r.at_h }, .key = k }); + const sl = s orelse { + into.place(paper); + continue; + }; + var pl = paper; + pl.rgba, pl.w, pl.h, pl.key = .{ sl.rgba.ptr, sl.is.w, sl.is.band_h, k | sl.is.rev }; + if (r.y0 >= sl.is.band_y and r.y1 <= sl.is.band_y + sl.is.band_h) { + pl.src = .{ .x = r.g.sx, .y = r.y0 - sl.is.band_y, .w = r.g.sw, .h = r.y1 - r.y0 }; + pl.from, pl.dirty_y, pl.dirty_h = .{ if (sl.is.from != 0) k | sl.is.from else 0, sl.is.dirty_y, sl.is.dirty_h }; + into.place(pl); + continue; + } + // Its rows not all landed (a fling's band moved on): its + // paper, and over it what the band has of them. + into.place(paper); + const c0 = @max(r.y0, sl.is.band_y); + const c1 = @min(r.y1, sl.is.band_y + sl.is.band_h); + if (c1 <= c0) continue; + pl.src = .{ .x = r.g.sx, .y = c0 - sl.is.band_y, .w = r.g.sw, .h = c1 - c0 }; + pl.at.y = r.at_y + @as(u32, @intCast(@as(u64, c0 - r.y0) * r.at_h / (r.y1 - r.y0))); + pl.at.h = @intCast(@as(u64, c1 - c0) * r.at_h / (r.y1 - r.y0)); + if (pl.at.h > 0) into.place(pl); + } + if (l.height != 0) { // the rail's thumb + out.at = @floatCast(l.top / f64Of(l.height)); + out.span = @floatCast(f64Of(l.vh) / f64Of(l.height)); + } + } + + pub fn key(st: *Pdf, k: addon.Key) bool { + if (st.d == null) return false; + const l = &st.views[take(st, k.view) -| 1]; + const cell: f64 = if (l.v.cell_h != 0) f64Of(l.v.cell_h) else 16; + const vh = f64Of(l.vh); + var cp: u32 = @backingInt(k.code); + if (cp == 0x1b) return !k.shift and cancel(st); // Shift-Esc: the editor's, leaving at once + const ctrl = k.ctrl or (cp > 0 and cp < 0x20 and cp != '\r' and cp != '\t'); // ^D as Ctrl-d + if (ctrl and cp < 0x20) cp += 0x60; + if (ctrl) { + const n = counted(st); + switch (cp) { + 'd', 'u' => move(st, l, if (cp == 'd') 1 else -1, @max(1, @floor(vh / 2)), n), + 'f', 'b' => move(st, l, if (cp == 'f') 1 else -1, vh, n), + 'e', 'y' => move(st, l, if (cp == 'e') 1 else -1, cell, 1), + else => return false, // the editor's: windows, jumps + } + return true; + } + if (k.alt) return false; + if (st.g) { + const n = st.count; + st.g, st.count = .{ false, 0 }; + switch (cp) { + 'g' => goPage(st, n -| 1), + 'e' => goPage(st, st.pages - 1), + 'j', 'k' => move(st, l, if (cp == 'j') 1 else -1, cell, @max(n, 1)), + 'h', 's', 'l' => edge(st, cp == 'l'), + else => {}, + } + return true; + } + if (cp >= '0' and cp <= '9' and (cp != '0' or st.count > 0)) { + st.count = @min(st.count * 10 + (cp - '0'), 1000000); + return true; + } + const across = f64Of(if (l.v.cell_w != 0) l.v.cell_w else 8); + const K = addon.Code; + switch (cp) { + ':', ' ', '/', 'n', 'N', '\t' => { + st.count = 0; + return false; // the editor's + }, + 'g' => st.g = true, + 'G' => goPage(st, if (st.count > 0) st.count - 1 else st.pages - 1), + 'f' => addon.exec("PdfSections"), + 'j', @backingInt(K.down) => move(st, l, 1, cell, counted(st)), + 'k', @backingInt(K.up) => move(st, l, -1, cell, counted(st)), + @backingInt(K.page_down) => move(st, l, 1, vh, counted(st)), + @backingInt(K.page_up) => move(st, l, -1, vh, counted(st)), + 'h', @backingInt(K.left) => panBy(st, -1, across * f64Of(counted(st))), + 'l', @backingInt(K.right) => panBy(st, 1, across * f64Of(counted(st))), + '0', '^', @backingInt(K.home) => edge(st, false), + '$', @backingInt(K.end) => edge(st, true), + else => {}, // the editing keys: nothing here + } + if (cp != 'g') st.count = 0; + return true; + } + + pub fn mouse(st: *Pdf, ev: addon.Mouse) bool { + if (st.d == null) return false; + const id = take(st, ev.view); + const l = &st.views[id -| 1]; + const dir: f64 = if (ev.button == .wheel_up or ev.button == .wheel_left) -1 else 1; + switch (ev.button) { + .wheel_up, .wheel_down => { + // a notch a row, a touchpad's fraction of one its fraction; + // as text a page a turn + const notches: f64 = if (ev.amount > 0) ev.amount else 1; + const cell: f64 = if (l.v.cell_h != 0) f64Of(l.v.cell_h) else 16; + move(st, l, dir, notches * cell, 1); + return true; + }, + .wheel_left, .wheel_right => { + if (st.fit_height) panBy(st, @intFromFloat(dir), f64Of(l.v.cell_w) * 4); + return true; + }, + else => {}, + } + const pr = &st.press; + if (ev.action == .motion) { + const here = ev.col == st.hover.col and ev.row == st.hover.row and (st.hover.wait != 0 or st.hover.page != null); + if (ev.col == 0xffff) st.hover = .{} else if (pr.button == null and !here) st.hover = .{ .col = ev.col, .row = ev.row, .wait = 1, .view = id }; + return true; + } + if (ev.action == .press) { + st.hover = .{}; + if (pr.button != null) { // a chord: B1 and B2 copies, a PDF being nothing to cut + pr.chorded = true; + if (ev.button == .middle and st.sel.quads.len > 0) addon.exec("ClipYank"); + return true; + } + pr.* = .{ .button = ev.button, .look = ev.button == .right, .col = ev.col, .row = ev.row }; + if (pr.look) return true; + const at = pointAt(st, id, ev.col, ev.row, null) orelse { + pr.button = null; + return true; + }; + pr.page = at.page; + st.sel.anchor, st.sel.tip = .{ at.pt, at.pt }; + if (ev.button == .middle and !selContains(st, at.page, at.pt)) _ = selectTo(st, at.page, at.pt); + return true; + } + if (ev.action == .drag) { + if (pr.button == null or pr.chorded) return true; + if (pr.look) { + if (ev.col == pr.col and ev.row == pr.row) return true; + pr.look = false; + const at = pointAt(st, id, pr.col, pr.row, null) orelse return true; + pr.page = at.page; + st.sel.anchor, st.sel.tip = .{ at.pt, at.pt }; + } + const at = pointAt(st, id, ev.col, ev.row, pr.page orelse return true) orelse return true; + if (at.pt.x != st.sel.tip.x or at.pt.y != st.sel.tip.y) _ = selectTo(st, at.page, at.pt); + return true; + } + const was = pr.button orelse return true; + if (ev.action != .release) return true; + const held = pr.*; + pr.* = .{}; + if (held.chorded) return true; + if (was == .right and held.look) { + const word = probeAt(st, id, held.col, held.row) orelse return true; + defer heap.free(word.text); + if (word.link) |link| follow(st, link, word.text) else addon.look(word.text); + } else if (was == .left) { + if (std.meta.eql(st.sel.anchor, st.sel.tip)) dropSel(st); + } else if (st.sel.text.len > 0) { + // the selection, looked at (B3) or run (B2) + if (was == .right) addon.look(st.sel.text) else addon.exec(st.sel.text); + } + return true; + } + + /// The page's text: a job's, else MuPDF's read here and kept for reads + /// alone (a read changes nothing a frame shows). + pub fn body(st: *Pdf) []const u8 { + const d = st.d orelse return ""; + if (st.text.page == st.page) return st.text.bytes; + if (st.read.page == st.page) return st.read.bytes; + heap.free(st.read.bytes); + st.read = .{ .page = st.page }; + var t: m.pardes_pdf_text = undefined; + if (m.pardes_pdf_page_text(d.base, @intCast(st.page), &t) != ok) return ""; + defer m.pardes_pdf_drop_text(d.base, t.handle); + st.read.bytes = heap.dupe(u8, t.data[0..t.len]) catch &.{}; + return st.read.bytes; + } + + /// `P` (a page), `P:H` (hit H of the search there), `P:F` (F of the way + /// down page P, a fraction: a jump, Recent, a Restore), or a + /// +PdfSections row's `P:S`; after a space, where's window. + pub fn address(st: *Pdf, text: []const u8) bool { + if (st.d == null) return false; + var t = text; + const sections_row = std.mem.startsWith(u8, t, "+PdfSections "); + if (std.mem.startsWith(u8, t, "+")) t = t[(std.mem.indexOfScalar(u8, t, ' ') orelse t.len - 1) + 1 ..]; + if (std.mem.startsWith(u8, t, ":")) t = t[1..]; + t = t[0 .. std.mem.indexOfScalar(u8, t, ' ') orelse t.len]; + const colon = std.mem.indexOfScalar(u8, t, ':') orelse t.len; + const page = std.fmt.parseInt(u32, t[0..colon], 10) catch return none(); + const rest = t[@min(colon + 1, t.len)..]; + if (std.mem.indexOfScalar(u8, rest, '.') != null) { + const f = std.fmt.parseFloat(f64, rest) catch return none(); + dropSel(st); + goTo(st, @min(page -| 1, st.pages - 1), f); + return true; + } + const second = if (colon < t.len) std.fmt.parseInt(u32, rest, 10) catch return none() else 0; + if (sections_row) return section(st, page, second); + var said: [160]u8 = undefined; + if (page == 0 or page > st.pages) return miss(std.fmt.bufPrint(&said, "has no page {d}", .{page})); + const f = &st.find; + if (second > 0 and (f.len == 0 or f.counts.len != st.pages or f.counts[page - 1] < second)) return miss(std.fmt.bufPrint(&said, "has no search hit {d} on page {d}", .{ second, page })); + dropSel(st); + goPage(st, page - 1); + if (second > 0) f.hit, f.reveal = .{ second - 1, true }; + return true; + } + + /// `P:F S`: its page, how far down it, and the window's height in pages + /// (two places within it are one visit of the jumps, as a text's lines + /// within a body). + pub fn where(st: *const Pdf, w: *std.Io.Writer) !void { + if (st.d == null) return; + const f6: u64 = @intFromFloat(@round(std.math.clamp(st.frac, 0, 1) * 1e6)); + const shown: f64 = if (pixels(st, st.active)) |l| f64Of(l.vh) / f64Of(@max(l.ph[st.page], 1)) else if (st.text.page == st.page) f64Of(st.views[st.active -| 1].v.rows) / f64Of(st.text.lines) else 1; + const w3: u64 = @intFromFloat(@round(@min(shown, 1e6) * 1e3)); + try w.print("{d}:{d}.{d:0>6} {d}.{d:0>3}", .{ st.page + 1, f6 / 1000000, f6 % 1000000, w3 / 1000, w3 % 1000 }); + } + + pub fn ctl(st: *Pdf, line: []const u8, reply: *std.Io.Writer) bool { + if (st.d == null) return false; + const word = line[0 .. std.mem.indexOfAny(u8, line, " \t\n") orelse line.len]; + const arg = std.mem.trim(u8, line[word.len..], " \t\n"); + if (std.mem.eql(u8, word, "PdfSections")) { + sections(st); + } else if (std.mem.eql(u8, word, "PdfFit")) { + const fit = if (arg.len == 0) !st.fit_height else if (std.mem.eql(u8, arg, "height")) true else if (std.mem.eql(u8, arg, "width")) false else { + reply.print("invalid argument: PdfFit takes width or height, not \"{s}\"", .{arg[0..@min(arg.len, 32)]}) catch {}; + return false; + }; + if (fit == st.fit_height) return true; + st.fit_height, st.pan = .{ fit, 0 }; + goPage(st, st.page); + st.find.reveal = st.find.len > 0; + } else if (std.mem.eql(u8, word, "PdfTint")) { + st.tint = if (arg.len == 0) @fromBackingInt((@backingInt(st.tint) + 1) % 3) else std.meta.stringToEnum(Tint, arg) orelse { + reply.print("invalid argument: PdfTint takes disabled, filtered or full, not \"{s}\"", .{arg[0..@min(arg.len, 32)]}) catch {}; + return false; + }; + } else return false; + return true; + } + + pub fn ctlRead(st: *const Pdf, w: *std.Io.Writer) !void { + try w.print("fit:{s} tint:{t}", .{ if (st.fit_height) "height" else "width", st.tint }); + } + + /// `/`: every hit, `file.pdf:P:H pattern` a row, at most max_hits, + /// found on a job (a stale one's dropped), and the first gone to. + pub fn search(st: *Pdf, pat: []const u8) void { + const f = &st.find; + if (st.d == null or pat.len == 0 or pat.len > 255) return; + if (!std.mem.eql(u8, f.query[0..f.len], pat)) { + @memcpy(f.query[0..pat.len], pat); + f.len = @intCast(pat.len); + dropHits(st); + @memset(f.counts, 0); + f.hit, f.reveal = .{ 0, true }; + } + // (a page's job asked its hits of the pattern before) + for (&st.jobs) |*j| if (j.token != 0 and (j.op == .search or j.op == .page)) { + abortJob(st, j.token); + addon.cancel(j.token); + j.* = .{}; + }; + f.due = true; + } + + // ---- the record: its fit, tint and place ---- + + const Record = extern struct { version: u32, fit: u32, tint: u32, page: u32, frac: f64 }; + + pub fn dump(st: *const Pdf, buf: []u8) usize { + if (st.d == null or buf.len < @sizeOf(Record)) return 0; + const r: Record = .{ .version = record_version, .fit = @intFromBool(st.fit_height), .tint = @backingInt(st.tint), .page = st.page, .frac = st.frac }; + @memcpy(buf[0..@sizeOf(Record)], std.mem.asBytes(&r)); + return @sizeOf(Record); + } + + /// On a state open made from its file as it is (a Restore's, a change + /// on disk): its fit, tint and place. + pub fn load(st: *Pdf, bytes: []const u8, _: u32) bool { + if (st.d == null or bytes.len < @sizeOf(Record)) return false; + const r = std.mem.bytesToValue(Record, bytes[0..@sizeOf(Record)]); + if (r.version != record_version or r.fit > 1 or r.tint > 2) return false; + st.fit_height, st.tint = .{ r.fit == 1, @fromBackingInt(r.tint) }; + goTo(st, @min(r.page, st.pages - 1), r.frac); + return true; + } + + // ---- jobs ---- + + /// A job's input: `n` highlights after it (render), or the pattern's + /// `n` bytes (hits, search) and the file's name (search). + const In = extern struct { op: Op, cookie: u32 = 0, doc: u64 = 0, page: u32 = 0, tint: Tint = .disabled, req: Request = std.mem.zeroes(Request), band_y: u32 = 0, band_h: u32 = 0, ink: u32 = 0, paper: u32 = 0, keep_clean: u32 = 0, n: u32 = 0 }; + /// A job's answer, and after it the sizes (sizes), the text (text), the + /// quads (hits), or each page's count of hits and the rows (search). + const Out = extern struct { ok: u32 = 0, busy: u32 = 0, w: u32 = 0, h: u32 = 0, band_y: u32 = 0, band_h: u32 = 0, n: u32 = 0, hits: u32 = 0, rgba: ?[*]u8 = null, clean: ?[*]u8 = null }; + + /// On a worker: the job on a free lane of its document. + pub fn jobRun(bytes: []const u8, gpa: std.mem.Allocator) ?[]u8 { + if (bytes.len < @sizeOf(In)) return null; + const in = std.mem.bytesToValue(In, bytes[0..@sizeOf(In)]); + const extra = bytes[@sizeOf(In)..]; + var res: Out = .{}; + var tail: []const u8 = ""; + const d = docTake(in.doc) orelse return answer(gpa, res, tail); + defer docDrop(d, false); + const lane = for (&d.busy, d.lane, 0..) |*b, ld, i| { + if (ld != null and @cmpxchgStrong(bool, b, false, true, .acquire, .monotonic) == null) break i; + } else null; + res.busy = @intFromBool(lane == null); + const ld = d.lane[lane orelse return answer(gpa, res, tail)]; + defer @atomicStore(bool, &d.busy[lane.?], false, .release); + const cookie = &d.cookie[in.cookie % jobs_n]; + if (m.pardes_pdf_lane_open(ld) != ok) return answer(gpa, res, tail); + switch (in.op) { + .render => { + const marks = gpa.alloc(Mark, in.n) catch return null; + @memcpy(std.mem.sliceAsBytes(marks), extra[0 .. in.n * @sizeOf(Mark)]); + m.pardes_pdf_set_cookie(ld, cookie); + render(d, ld, &in, marks, &res); + m.pardes_pdf_set_cookie(ld, null); + }, + .sizes => { + const sizes = gpa.alloc(m.pardes_pdf_page_size, in.page) catch return null; + for (sizes, 0..) |*s, p| if ((p % 64 == 0 and @atomicLoad(c_int, &cookie.abort, .monotonic) != 0) or m.pardes_pdf_get_page_size(ld, @intCast(p), s) != ok) return answer(gpa, res, tail); + res.ok, res.n, tail = .{ 1, in.page, std.mem.sliceAsBytes(sizes) }; + }, + .page, .search => { + var q: [257]u8 = @splat(0); + @memcpy(q[0..in.n], extra[0..in.n]); + var t: m.pardes_pdf_text = undefined; + var r: m.pardes_pdf_search_result = undefined; + if (in.op == .page) { // its text, and the pattern's hits' quads on it + if (m.pardes_pdf_page_text(ld, @intCast(in.page), &t) != ok) return answer(gpa, res, tail); + defer m.pardes_pdf_drop_text(ld, t.handle); + const found = in.n > 0 and m.pardes_pdf_search_page(ld, @intCast(in.page), &q, &r) == ok; + defer if (found) m.pardes_pdf_drop_search_result(ld, r.handle); + res.ok, res.n, res.hits = .{ 1, @intCast(t.len), if (found) @intCast(r.hit_count) else 0 }; + return answer(gpa, res, std.mem.concat(gpa, u8, &.{ t.data[0..t.len], if (found) std.mem.sliceAsBytes(r.quads[0..r.quad_count]) else "" }) catch return null); + } + // each page's count of hits, then the rows + var shown = @min(in.n, 200); + while (shown > 0 and shown < in.n and q[shown] & 0xc0 == 0x80) shown -= 1; + const counts = gpa.alloc(u32, in.page) catch return null; + var rows: std.ArrayList(u8) = .empty; + for (counts, 0..) |*count, p| { + if (@atomicLoad(c_int, &cookie.abort, .monotonic) != 0) return answer(gpa, .{}, ""); + count.* = 0; + if (m.pardes_pdf_search_page(ld, @intCast(p), &q, &r) != ok) continue; + defer m.pardes_pdf_drop_search_result(ld, r.handle); + count.* = @intCast(r.hit_count); + for (0..@min(r.hit_count, max_hits - res.hits)) |h| rows.print(gpa, "{s}:{d}:{d} {s}\n", .{ extra[in.n..], p + 1, h + 1, q[0..shown] }) catch return null; + res.hits += @intCast(@min(r.hit_count, max_hits - res.hits)); + } + res.ok, res.n = .{ 1, in.page }; + tail = std.mem.concat(gpa, u8, &.{ std.mem.sliceAsBytes(counts), rows.items }) catch return null; + }, + } + return answer(gpa, res, tail); + } + + pub fn jobDone(st: *Pdf, token: u32, bytes: []const u8) void { + const d = st.d orelse return; + const res = if (bytes.len >= @sizeOf(Out)) std.mem.bytesToValue(Out, bytes[0..@sizeOf(Out)]) else Out{}; + const extra = bytes[@min(bytes.len, @sizeOf(Out))..]; + const len = @as(usize, res.w) * 4 * res.band_h; + const px: [2][]u8 = .{ if (res.rgba) |p| p[0..len] else &.{}, if (res.clean) |p| p[0..len] else &.{} }; + for (px) |p| claim(d, p); + var kept = false; // (the pixels, a page's slot's) + defer if (!kept) for (px) |p| heap.free(p); + const at = for (st.jobs, 0..) |j, i| { + if (j.token == token) break i; + } else return; + const j = st.jobs[at]; + st.jobs[at] = .{}; + st.warm, st.go.landed = .{ true, true }; + const f = &st.find; + // (a busy lane's refusal is asked again) + if (res.ok == 0 and j.op != .render) { + if (res.busy != 0 and j.op == .search) f.due = true; + if (res.busy == 0 and j.op == .sizes) st.sizes_assumed = false; + return; + } + switch (j.op) { + .render => {}, + .sizes => { + st.sizes_assumed = false; + const sizes = std.mem.bytesAsSlice(m.pardes_pdf_page_size, extra[0..@min(extra.len, st.pages * @sizeOf(m.pardes_pdf_page_size))]); + if (res.n != st.pages or sizes.len != st.pages or std.mem.eql(u8, std.mem.sliceAsBytes(sizes), std.mem.sliceAsBytes(st.size))) return; + for (st.size, sizes) |*to, from| to.* = from; + for (&st.views) |*l| l.laid = false; + return; + }, + .page => { + if (extra.len < res.n) return; + heap.free(st.text.bytes); + st.text = .{ .bytes = heap.dupe(u8, extra[0..res.n]) catch &.{}, .page = j.page }; + st.text.lines = @intCast(std.mem.count(u8, st.text.bytes, "\n") + 1); + if (j.page != st.page or f.len == 0) return; + dropHits(st); + f.hits = heap.alloc(m.pardes_pdf_search_quad, (extra.len - res.n) / @sizeOf(m.pardes_pdf_search_quad)) catch return; + @memcpy(std.mem.sliceAsBytes(f.hits), extra[res.n..][0 .. f.hits.len * @sizeOf(m.pardes_pdf_search_quad)]); + f.hits_page, f.hit = .{ j.page, @min(f.hit, res.hits -| 1) }; + return; + }, + .search => { + if (res.n != st.pages or extra.len < st.pages * 4) return; + if (f.counts.len != st.pages) f.counts = addon.arena.alloc(u32, st.pages) catch return; + @memcpy(std.mem.sliceAsBytes(f.counts), extra[0 .. st.pages * 4]); + if (extra.len == st.pages * 4) return; + addon.found(extra[st.pages * 4 ..]); + // at its first hit, as a Look of its first row goes + goPage(st, @intCast(std.mem.indexOfNone(u32, f.counts, &.{0}) orelse 0)); + f.hit, f.reveal = .{ 0, true }; + return; + }, + } + const s = for (&st.s) |*s| { + if (s.job.token == token and s.view != 0) break s; + } else return; + s.job.token, s.job.failed = .{ 0, res.ok == 0 and res.busy == 0 }; + if (res.ok == 0) return; + for ([_][]const u8{ s.rgba, s.clean, std.mem.sliceAsBytes(s.shown) }) |p| heap.free(p); + const v = st.views[s.view - 1].v; + st.revs += 1; + s.rgba, s.clean, s.shown, s.asked, kept = .{ px[0], px[1], s.asked, &.{}, true }; + s.is = .{ .w = res.w, .h = res.h, .band_y = res.band_y, .band_h = res.band_h, .req = s.job.want, .tint = st.tint, .ink = @backingInt(v.fg), .paper = @backingInt(v.bg), .rev = st.revs }; + } +}; + +/// A job's answer: `res`, then `tail`, the last it allocates. +fn answer(gpa: std.mem.Allocator, res: Pdf.Out, tail: []const u8) ?[]u8 { + const a = gpa.alloc(u8, @sizeOf(Pdf.Out) + tail.len) catch return null; + @memcpy(a[0..@sizeOf(Pdf.Out)], std.mem.asBytes(&res)); + @memcpy(a[@sizeOf(Pdf.Out)..], tail); + return a; +} + +/// A page's band rendered on lane `ld`: its pixels the document's until its +/// pane takes them (`unclaimed`), or freed when its pane is gone. +fn render(d: *Doc, ld: ?*m.pardes_pdf_document, in: *const Pdf.In, marks: []const Mark, res: *Pdf.Out) void { + var L: m.pardes_pdf_raster_layout = undefined; + if (m.pardes_pdf_measure_render(ld, @intCast(in.page), &in.req, &L) != ok) return; + const full: u32 = @intCast(L.height); + const by = if (in.band_y < full) in.band_y else 0; + const bh = if (in.band_h != 0 and by + in.band_h <= full) in.band_h else full - by; + // a tall page's chunk renders past its edges, thrown away: a row is the + // same row however its band was cut + const cut = bh < full; + const ry = if (cut) by -| overlap else by; + const rb = if (cut and by + bh + overlap < full) by + bh + overlap else by + bh; + const stride: usize = @intCast(L.stride); + const len = stride * bh; + const px = heap.alloc(u8, @max(stride * (rb - ry), 1)) catch return; + var clean: []u8 = &.{}; + var good = m.pardes_pdf_render_into(ld, @intCast(in.page), &in.req, null, 0, px.ptr, px.len, L.width, L.height, L.stride, @intCast(ry), @intCast(rb - ry), 0) == ok; + if (good and ry != by) std.mem.copyForwards(u8, px[0..len], px[(by - ry) * stride ..][0..len]); + if (good and in.keep_clean != 0) { + clean = heap.dupe(u8, px[0..len]) catch &.{}; + good = clean.len == len; + } + if (good and marks.len > 0) good = m.pardes_pdf_paint_highlights(ld, @intCast(in.page), &in.req, marks.ptr, marks.len, px.ptr, len, L.width, L.height, L.stride, @intCast(by), @intCast(bh)) == ok; + if (good) tint(px[0..len], in.tint, in.ink, in.paper); + // kept for the pane, unless its document closed meanwhile + lock(); + var kept = good and !d.closed; + for ([_][]u8{ px, clean }) |p| if (kept and p.len > 0) { + const at = for (d.unclaimed, 0..) |u, i| { + if (u.len == 0) break i; + } else null; + if (at) |i| d.unclaimed[i] = p else kept = false; + }; + docs_lock.unlock(); + if (kept) { + res.* = .{ .ok = 1, .w = @intCast(L.width), .h = full, .band_y = by, .band_h = bh, .rgba = px.ptr, .clean = if (clean.len > 0) clean.ptr else null }; + return; + } + for ([_][]u8{ px, clean }) |p| { + claim(d, p); + heap.free(p); + } +} + +// ---- the strip ---- + +fn pageHeight(st: *const Pdf, l: *const Layout, p: usize) u32 { + if (st.fit_height) return l.vh; + const h = @round(f64Of(l.vw) * st.size[p].height / st.size[p].width); + return if (h < 1) 1 else if (h > 4e9) 4000000000 else @intFromFloat(h); +} + +fn pageAt(st: *const Pdf, l: *const Layout, y: f64) u32 { + if (st.pages == 0 or !l.laid) return st.page; + const at: u64 = @intFromFloat(std.math.clamp(@floor(y), 0, f64Of(l.height -| 1))); + var lo: usize = 0; + var hi: usize = st.pages; + while (lo + 1 < hi) { + const mid = lo + (hi - lo) / 2; + if (l.y[mid] <= at) lo = mid else hi = mid; + } + if (at >= l.y[lo] + l.ph[lo] and lo + 1 < st.pages) lo += 1; + return @intCast(lo); +} + +/// View `id`'s layout when it shows pictures and is laid out. +fn pixels(st: anytype, id: u8) ?@TypeOf(&st.views[0]) { + if (id < 1 or id > views_n) return null; + const l = &st.views[id - 1]; + return if (l.v.cols != 0 and !l.v.glyphs and l.laid) l else null; +} + +/// An input from view `id`: the view the place follows from now on; its +/// id, or the active one's when it was never told. +fn take(st: *Pdf, id: u8) u8 { + if (id >= 1 and id <= views_n and st.views[id - 1].v.cols != 0) st.active = id; + return st.active; +} + +/// The strip laid out for view `l`'s pixels, its top at the place (but in +/// the view the place was last moved in, whose top the place is). +fn layout(st: *Pdf, l: *Layout) void { + const vw = @as(u32, l.v.cols) * l.v.cell_w; + const vh = @as(u32, l.v.rows) * l.v.cell_h; + if (vw == 0 or vh == 0 or st.pages == 0 or l.v.glyphs) return; + if (l.y.len == 0) { + l.y = addon.arena.alloc(u64, st.pages) catch return; + l.ph = addon.arena.alloc(u32, st.pages) catch return; + } + if (!l.laid or vw != l.vw or vh != l.vh or st.fit_height != l.fit) { + l.vw, l.vh, l.fit, l.laid, l.rev = .{ vw, vh, st.fit_height, true, 0 }; + var at: u64 = 0; + for (l.y, l.ph, 0..) |*y, *ph, p| { + y.*, ph.* = .{ at, pageHeight(st, l, p) }; + at += ph.* + @as(u64, if (p + 1 < st.pages) gap_px else 0); + } + l.height = at; + } + if (l.rev != st.rev) { // a pixel's: P:F rounds + l.top = @round(f64Of(l.y[st.page]) + std.math.clamp(st.frac, 0, 1) * f64Of(l.ph[st.page])); + l.rev = st.rev; + } + l.top = std.math.clamp(l.top, 0, f64Of(l.height -| l.vh)); +} + +/// The place where view `l`'s window's top is (a move in it, or the strip's +/// end it stopped at). +fn placeFrom(st: *Pdf, l: *Layout) void { + if (!l.laid) return; + const p = pageAt(st, l, l.top); + const frac = (l.top - f64Of(l.y[p])) / f64Of(@max(l.ph[p], 1)); + if (p == st.page and frac == st.frac and l.rev == st.rev) return; + toPage(st, p); + st.frac = frac; + st.rev += 1; + l.rev = st.rev; +} + +/// The active view laid out at the place, and the place where its top is. +fn settle(st: *Pdf) void { + if (st.active < 1) return; + layout(st, &st.views[st.active - 1]); + if (pixels(st, st.active)) |l| placeFrom(st, l); +} + +fn setTop(st: *Pdf, l: *Layout, top: f64) void { + l.top = std.math.clamp(top, 0, f64Of(l.height -| l.vh)); + placeFrom(st, l); +} + +fn scrollBy(st: *Pdf, l: *Layout, px: f64) void { + if (!l.laid) return; + const was = l.top; + setTop(st, l, l.top + px); + st.go.since_tick += @abs(l.top - was); +} + +/// The page at the window's top is `p` now: what was the old one's goes. +fn toPage(st: *Pdf, p: u32) void { + if (p == st.page) return; + st.page = p; + dropHits(st); + st.find.hit, st.find.reveal = .{ 0, st.find.len > 0 }; +} + +fn goTo(st: *Pdf, p: u32, frac: f64) void { + toPage(st, p); + st.frac = frac; + st.rev += 1; + settle(st); +} + +/// Turn to page `p`, its top at the window's. +fn goPage(st: *Pdf, p: u32) void { + goTo(st, @min(p, st.pages - 1), 0); +} + +/// Down (dir 1) or up `n` steps of `px` pixels in view `l`; as text, a +/// page a step. +fn move(st: *Pdf, l: *Layout, dir: f64, px: f64, n: u32) void { + if (!l.v.glyphs) return scrollBy(st, l, dir * px * f64Of(n)); + goPage(st, @intCast(std.math.clamp(@as(i64, st.page) + @as(i64, @intFromFloat(dir)) * n, 0, st.pages - 1))); +} + +fn visible(st: *const Pdf, l: *const Layout) struct { usize, usize } { + if (!l.laid) return .{ 0, 0 }; + var p: usize = pageAt(st, l, l.top); + if (p > 0 and f64Of(l.y[p - 1] + l.ph[p - 1]) > l.top) p -= 1; + var n: usize = 0; + while (p + n < st.pages and f64Of(l.y[p + n]) < l.top + f64Of(l.vh)) n += 1; + return .{ p, n }; +} + +/// Where a raster of `iw` x `ih` lies in a page's `bw` x `bh` box: the part +/// of it shown (`s*`) and where (`d*`, the box's pixels), its axis fitted, +/// the other letterboxed or, past the box, cropped (at `pan`, fit height). +const Geo = struct { sx: u32, sy: u32, sw: u32, sh: u32, dx: u32, dy: u32, dw: u32, dh: u32 }; + +fn fitGeo(iw: u32, ih: u32, bw: u32, bh: u32, by_height: bool, pan: u16) ?Geo { + if (iw == 0 or ih == 0 or bw == 0 or bh == 0) return null; + // in the fitted axis's terms: its sides, then the other's + const a: [4]u64 = if (by_height) .{ ih, iw, bh, bw } else .{ iw, ih, bw, bh }; + if (a[1] * a[2] <= a[3] * a[0]) { + const full: u32 = @intCast(@max(a[1] * a[2] / a[0], 1)); + const off: u32 = @intCast((a[3] - full) / 2); + return if (by_height) .{ .sx = 0, .sy = 0, .sw = iw, .sh = ih, .dx = off, .dy = 0, .dw = full, .dh = bh } else .{ .sx = 0, .sy = 0, .sw = iw, .sh = ih, .dx = 0, .dy = off, .dw = bw, .dh = full }; + } + const crop = a[3] * a[0] / a[2]; + if (crop == 0) return null; + const cr: u32 = @intCast(@min(crop, a[1])); + const dd: u32 = @intCast(std.math.clamp(@as(u64, cr) * a[2] / a[0], 1, a[3])); + const off: u32 = @intCast((a[3] - dd) / 2); + if (!by_height) return .{ .sx = 0, .sy = 0, .sw = iw, .sh = cr, .dx = 0, .dy = off, .dw = bw, .dh = dd }; + const over = iw - cr; + const x: u32 = if (over == 0 or pan == 0) 0 else if (pan == 65535) over else @intCast((@as(u64, over) * pan + 32767) / 65535); + return .{ .sx = x, .sy = 0, .sw = cr, .sh = ih, .dx = off, .dy = 0, .dw = dd, .dh = bh }; +} + +/// Rows y0..y1 of page `p`'s raster over a window `vh` pixels tall, and +/// where (`at_y`, `at_h`); null when none of it is there. +const Rows = struct { g: Geo, y0: u32, y1: u32, at_y: u32, at_h: u32 }; + +fn pageRows(st: *const Pdf, l: *const Layout, p: u32, iw: u32, ih: u32, vh: u32) ?Rows { + const g = fitGeo(iw, ih, l.vw, l.ph[p], st.fit_height, st.pan) orelse return null; + if (g.dh == 0 or g.sh == 0) return null; + const full_y = @as(i64, @intCast(l.y[p])) - @as(i64, @intFromFloat(@floor(l.top))) + g.dy; + const vy = @max(full_y, 0); + const vb = @min(full_y + g.dh, vh); + if (vb <= vy) return null; + const ry0: u64 = @intCast(vy - full_y); + const ry1: u64 = @intCast(vb - full_y); + const y0 = g.sy + @as(u32, @intCast(ry0 * g.sh / g.dh)); + const y1 = g.sy + @as(u32, @intCast(@min((ry1 * g.sh + g.dh - 1) / g.dh, g.sh))); + return if (y1 > y0) .{ .g = g, .y0 = y0, .y1 = y1, .at_y = @intCast(vy), .at_h = @intCast(vb - vy) } else null; +} + +/// The raster page `p` renders to under `q`, as the bridge's geometry +/// computes it, give or take the rounding of its corners. +fn rasterOf(st: *const Pdf, p: usize, q: Request) [2]u32 { + const pw = st.size[p].width; + const ph = st.size[p].height; + const dpi: f32, const mw: f32, const mh: f32, const most: f32, const dw: f32, const dh: f32 = .{ @floatFromInt(q.dpi), @floatFromInt(q.minimum_width), @floatFromInt(q.minimum_height), @floatFromInt(q.max_dimension), @floatFromInt(q.display_width), @floatFromInt(q.display_height) }; + var scale = @max(dpi / 72, mw / pw, mh / ph); // (none is 0) + if (pw * scale > most) scale = most / pw; + if (ph * scale > most) scale = @min(scale, @max(most / ph, dw / pw, dh / ph)); + if (ph * scale > m.PARDES_PDF_MAX_RASTER_ROWS) scale = m.PARDES_PDF_MAX_RASTER_ROWS / ph; + return .{ @intFromFloat(@max(1, @round(pw * scale))), @intFromFloat(@max(1, @round(ph * scale))) }; +} + +// ---- highlights ---- + +/// Page `p`'s highlights in view `l`, as painted: the pointer's, the +/// search's, the selection's. +fn marksOf(st: *const Pdf, l: *const Layout, p: u32, out: []Mark) []Mark { + const f = struct { + fn mark(q: Quad, rgb: u32, a: u8, kind: c_int) Mark { + return .{ .quad = q, .rgba = .{ @truncate(rgb >> 16), @truncate(rgb >> 8), @truncate(rgb), a }, .kind = kind }; + } + }; + var n: usize = 0; + if (st.hover.page == p) { + out[0] = f.mark(st.hover.quad, @backingInt(if (st.hover.link) l.v.link else l.v.sel), 0x2c, m.PARDES_PDF_HIGHLIGHT_CUSTOM); + n = 1; + } + if (st.find.hits_page == p) for (st.find.hits[0..@min(st.find.hits.len, out.len - n)]) |h| { + out[n] = f.mark(h.quad, 0xffd54f, 0x70, m.PARDES_PDF_HIGHLIGHT_SEARCH); + n += 1; + }; + if (st.sel.page == p) for (st.sel.quads[0..@min(st.sel.quads.len, out.len - n)]) |q| { + out[n] = f.mark(q, @backingInt(l.v.sel), 0x78, m.PARDES_PDF_HIGHLIGHT_SELECTION); + n += 1; + }; + return out[0..n]; +} + +fn keepMarks(to: *[]Mark, now: []const Mark) bool { + const copy = heap.dupe(Mark, now) catch return false; + heap.free(to.*); + to.* = copy; + return true; +} + +// ---- jobs ---- + +/// Jobs out, or of `op` alone. +fn jobsOut(st: *const Pdf, op: ?Op) usize { + var n: usize = 0; + for (st.jobs) |j| n += @intFromBool(j.token != 0 and (op == null or j.op == op.?)); + return n; +} + +var ask_buf: [@sizeOf(Pdf.In) + marks_n * @sizeOf(Mark) + 512]u8 align(8) = undefined; // the loop's alone + +/// A job of `in` (`extra` and `more` after it) asked, when a lane is free: +/// its token, 0 when none could be. +fn ask(st: *Pdf, in_: Pdf.In, extra: []const u8, more: []const u8) u32 { + if (jobsOut(st, null) >= lanes) return 0; + const at = for (st.jobs, 0..) |j, i| { + if (j.token == 0) break i; + } else return 0; + var in = in_; + in.doc, in.cookie = .{ st.d.?.id, @intCast(at) }; + @atomicStore(c_int, &st.d.?.cookie[at].abort, 0, .monotonic); + var w: std.Io.Writer = .fixed(&ask_buf); + w.writeAll(std.mem.asBytes(&in)) catch {}; + w.writeAll(extra) catch {}; + w.writeAll(more) catch {}; + const token = addon.job(w.buffered()); + if (token != 0) st.jobs[at] = .{ .token = token, .op = in.op, .page = in.page }; + return token; +} + +fn abortJob(st: *Pdf, token: u32) void { + const d = st.d orelse return; + for (st.jobs, 0..) |j, i| if (token != 0 and j.token == token) @atomicStore(c_int, &d.cookie[i].abort, 1, .monotonic); +} + +/// The band of page `p` (a `w` x `h` raster) asked for: the whole, or for +/// a page too tall for one raster, the chunks round what the window shows +/// and a screenful either side. +fn bandOf(st: *const Pdf, l: *const Layout, p: u32, w: u32, h: u32) [2]u32 { + const cap = @min(c.PA_RASTER_MAX / (w * 4), band_rows) / chunk * chunk; + const r = pageRows(st, l, p, w, h, l.vh); + if (h <= cap) { + // flinging: the rows shown alone, on the grain + const rs = (if (st.go.fling) r else null) orelse return .{ 0, h }; + const y0 = rs.y0 / grain * grain; + return .{ y0, @min((rs.y1 + grain - 1) / grain * grain, h) - y0 }; + } + const seen = if (r) |rs| rs.y1 - rs.y0 else 0; + var y0 = (if (r) |rs| rs.y0 -| seen else 0) / chunk * chunk; + var y1 = ((if (r) |rs| rs.y1 + seen else chunk) + chunk - 1) / chunk * chunk; + if (y1 - y0 > cap) { + y0 = (if (r) |rs| rs.y0 else 0) / chunk * chunk; + y1 = y0 + cap; + } + return .{ y0, @min(y1, h) - y0 }; +} + +/// Only the highlights moved: their rows painted again from the clean copy +/// on the loop, never the page, and said as those rows. +fn repaint(st: *Pdf, s: *Slot, now: []const Mark) bool { + if (s.clean.len == 0 or s.rgba.len == 0) return false; + const both = struct { + var at: [2 * marks_n]Mark = undefined; // the loop's alone + }; + @memcpy(both.at[0..s.shown.len], s.shown); + @memcpy(both.at[s.shown.len..][0..now.len], now); + var y0: c_int = 0; + var y1: c_int = 0; + const base = st.d.?.base; + if (m.pardes_pdf_highlight_rows(base, @intCast(s.page), &s.is.req, &both.at, s.shown.len + now.len, &y0, &y1) != ok) return false; + const a: u32 = @max(@as(u32, @intCast(y0)), s.is.band_y); + const b: u32 = @min(@as(u32, @intCast(y1)), s.is.band_y + s.is.band_h); + if (b > a) { + const stride = @as(usize, s.is.w) * 4; + const px = s.rgba[(a - s.is.band_y) * stride ..][0 .. (b - a) * stride]; + @memcpy(px, s.clean[(a - s.is.band_y) * stride ..][0..px.len]); + if (m.pardes_pdf_paint_highlights(base, @intCast(s.page), &s.is.req, now.ptr, now.len, px.ptr, px.len, @intCast(s.is.w), @intCast(s.is.h), @intCast(stride), @intCast(a), @intCast(b - a)) != ok) { + heap.free(s.rgba); // half made: rendered again + s.rgba = &.{}; + return false; + } + tint(px, s.is.tint, s.is.ink, s.is.paper); + st.revs += 1; + s.is.from, s.is.rev, s.is.dirty_y, s.is.dirty_h = .{ s.is.rev, st.revs, a - s.is.band_y, b - a }; + } + return keepMarks(&s.shown, now); +} + +/// What view `id`'s window shows (and the page past it) made so: pages gone +/// dropped, highlights moved repainted, the rest asked of the lanes. +fn reconcile(st: *Pdf, l: *const Layout, id: u8) void { + const first, var n = visible(st, l); + if (n > 0 and first + n < st.pages and !st.go.fling) n += 1; // the page ahead, at rest + for (&st.s) |*s| if (s.view == id and (s.page < first or s.page >= first + n)) { + abortJob(st, s.job.token); + s.clear(); + }; + const q: Request = .{ + .dpi = if (l.v.dpi != 0) l.v.dpi else 96, + .minimum_width = if (l.v.fill) @intCast(l.vw) else 0, + .minimum_height = if (l.v.fill) @intCast(l.vh) else 0, + .max_dimension = if (l.v.max_px != 0) l.v.max_px else 1200, + .display_width = if (st.fit_height) 0 else @intCast(l.vw), + .display_height = if (st.fit_height) @intCast(l.vh) else 0, + }; + const now = struct { + var at: [marks_n]Mark = undefined; // the loop's alone + fn eq(a: []const Mark, b: []const Mark) bool { + return std.mem.eql(u8, std.mem.sliceAsBytes(a), std.mem.sliceAsBytes(b)); + } + }; + for (first..first + n) |pi| { + const p: u32 = @intCast(pi); + const s = for (&st.s) |*s| { + if (s.view == id and s.page == p) break s; + } else for (&st.s) |*s| { + if (s.view == 0) break s; + } else break; + s.view, s.page = .{ id, p }; + const same = s.rgba.len > 0 and std.meta.eql(s.is.req, q); + const wh = if (same) [2]u32{ s.is.w, s.is.h } else rasterOf(st, p, q); + const y, const bh = bandOf(st, l, p, wh[0], wh[1]); + const marks = marksOf(st, l, p, &now.at); + if (same and s.is.tint == st.tint and s.is.ink == @backingInt(l.v.fg) and s.is.paper == @backingInt(l.v.bg) and s.is.band_y <= y and s.is.band_y + s.is.band_h >= y + bh) { + if (now.eq(s.shown, marks) or repaint(st, s, marks)) continue; + } + if (s.job.token != 0) { + if (std.meta.eql(s.job.want, q) and s.job.y == y and s.job.h == bh and now.eq(s.asked, marks)) continue; + abortJob(st, s.job.token); + s.job.token = 0; + } + if (s.job.failed and std.meta.eql(s.job.want, q)) continue; + // a lane's first job parses the document and loads its fonts: the + // second starts once the first is warm + if (jobsOut(st, .render) >= @as(usize, if (st.warm) lanes else 1) or !keepMarks(&s.asked, marks)) continue; + const token = ask(st, .{ .op = .render, .page = p, .tint = st.tint, .req = q, .band_y = y, .band_h = bh, .ink = @backingInt(l.v.fg), .paper = @backingInt(l.v.bg), .keep_clean = @intFromBool(marks.len > 0 or s.clean.len > 0), .n = @intCast(marks.len) }, std.mem.sliceAsBytes(marks), ""); + if (token != 0) s.job.token, s.job.want, s.job.y, s.job.h, s.job.failed = .{ token, q, y, bh, false }; + } +} + +// ---- the search, the selection, the pointer ---- + +fn dropHits(st: *Pdf) void { + heap.free(st.find.hits); + st.find.hits, st.find.hits_page = .{ &.{}, null }; +} + +/// The search's hit `hit` in the window: centred (fit width), or panned to +/// (fit height). +fn revealHit(st: *Pdf) void { + st.find.reveal = false; + const l = pixels(st, st.active) orelse return; + const q = for (st.find.hits) |h| { + if (h.hit == st.find.hit) break h.quad; + } else return; + const cx = (q.ul.x + q.ur.x + q.ll.x + q.lr.x) / 4; + const cy = (q.ul.y + q.ur.y + q.ll.y + q.lr.y) / 4; + if (!st.fit_height) return setTop(st, l, f64Of(l.y[st.page]) + cy * f64Of(l.ph[st.page]) - f64Of(l.vh) / 2); + const s, const g = landed(st, st.active, st.page) orelse return; + const at: u32 = @intFromFloat(cx * f64Of(s.is.w)); + const over = s.is.w - g.sw; + if ((at >= g.sx and at < g.sx + g.sw) or over == 0) return; + st.pan = @intCast((@as(u64, @min(at -| g.sw / 2, over)) * 65535 + over / 2) / over); +} + +/// Page `p`'s pixels in view `id`, landed, and where they lie in it. +fn landed(st: *const Pdf, id: u8, p: usize) ?struct { *const Slot, Geo } { + const l = pixels(st, id) orelse return null; + for (&st.s) |*s| if (s.view == id and s.page == p and s.rgba.len > 0) + return .{ s, fitGeo(s.is.w, s.is.h, l.vw, l.ph[p], st.fit_height, st.pan) orelse return null }; + return null; +} + +fn counted(st: *Pdf) u32 { + defer st.count = 0; + return @max(st.count, 1); +} + +fn panBy(st: *Pdf, dir: i32, px: f64) void { + const s, const g = landed(st, st.active, st.page) orelse return; + const over = s.is.w - g.sw; + if (over == 0 or (dir < 0 and g.sx == 0) or (dir > 0 and g.sx >= over)) return; + const step = (@as(u64, @intFromFloat(px)) * g.sw + g.dw - 1) / @max(g.dw, 1); + const norm: i32 = @intCast(std.math.clamp((step * 65535 + over - 1) / over, 1, 65535)); + st.pan = @intCast(std.math.clamp(@as(i32, st.pan) + dir * norm, 0, 65535)); +} + +fn edge(st: *Pdf, end: bool) void { + const s, const g = landed(st, st.active, st.page) orelse return; + if (s.is.w > g.sw) st.pan = if (end) 65535 else 0; +} + +/// Esc: the selection and the search go first; with neither, it leaves. +fn cancel(st: *Pdf) bool { + const had = st.sel.quads.len > 0 or st.find.len > 0; + dropSel(st); + st.find.len, st.find.reveal, st.find.due = .{ 0, false, false }; + dropHits(st); + return had; +} + +fn dropSel(st: *Pdf) void { + const had = st.sel.quads.len > 0; + heap.free(st.sel.quads); + heap.free(st.sel.text); + st.sel = .{}; + if (had) addon.select(""); +} + +/// The page and its point under the middle of cell (col, row) of view `id`, +/// from where its pixels are shown; clamped to page `on` when given. +fn pointAt(st: *Pdf, id: u8, col: u16, row: u16, on: ?u32) ?struct { page: u32, pt: Point } { + const l = pixels(st, id) orelse return null; + const px = f64Of(@as(u32, col) * l.v.cell_w + l.v.cell_w / 2); + const py = f64Of(@as(u32, row) * l.v.cell_h + l.v.cell_h / 2); + const p = on orelse pageAt(st, l, l.top + py); + const s, const g = landed(st, id, p) orelse return null; + const left = f64Of(g.dx); + const top = f64Of(l.y[p]) - @floor(l.top) + f64Of(g.dy); + if (on == null and (px < left or px >= left + f64Of(g.dw) or py < top or py >= top + f64Of(g.dh))) return null; + const x = if (on == null) px else std.math.clamp(px, left, left + f64Of(g.dw) - 1.0 / 1024.0); + const y = if (on == null) py else std.math.clamp(py, top, top + f64Of(g.dh) - 1.0 / 1024.0); + const ix: u32 = @min(@as(u32, @intFromFloat(f64Of(g.sx) + (x - left) * f64Of(g.sw) / f64Of(g.dw))), s.is.w - 1); + const iy: u32 = @min(@as(u32, @intFromFloat(f64Of(g.sy) + (y - top) * f64Of(g.sh) / f64Of(g.dh))), s.is.h - 1); + return .{ .page = p, .pt = .{ .x = @floatCast((f64Of(ix) + 0.5) / f64Of(s.is.w)), .y = @floatCast((f64Of(iy) + 0.5) / f64Of(s.is.h)) } }; +} + +/// The selection from the anchor to `to` on `page`, word-snapped by MuPDF; +/// what it holds handed to pardes. +fn selectTo(st: *Pdf, page: u32, to: Point) bool { + const base = st.d.?.base; + var sel: m.pardes_pdf_selection = undefined; + if (m.pardes_pdf_select(base, @intCast(page), st.sel.anchor, to, &sel) != ok) return false; + defer m.pardes_pdf_drop_selection(base, sel.handle); + var t: m.pardes_pdf_owned_text = undefined; + if (m.pardes_pdf_copy_selection(base, @intCast(page), sel.start, sel.end, &t) != ok) return false; + defer m.pardes_pdf_drop_owned_text(base, t.handle); + heap.free(st.sel.quads); + heap.free(st.sel.text); + st.sel.quads = heap.dupe(Quad, sel.quads[0..sel.quad_count]) catch &.{}; + st.sel.text = heap.dupe(u8, t.data[0..t.len]) catch &.{}; + st.sel.page, st.sel.tip = .{ page, to }; + addon.select(t.data[0..t.len]); + return true; +} + +fn selContains(st: *const Pdf, page: u32, pt: Point) bool { + if (st.sel.page != page) return false; + for (st.sel.quads) |q| if (m.pardes_pdf_point_inside_quad(pt, q) != 0) return true; + return false; +} + +/// The word or link under a cell of view `id`: its quad and its text +/// (heap), and the link when it is one. +fn probeAt(st: *Pdf, id: u8, col: u16, row: u16) ?struct { page: u32, quad: Quad, text: []u8, link: ?m.pardes_pdf_link } { + const at = pointAt(st, id, col, row, null) orelse return null; + const base = st.d.?.base; + var link: m.pardes_pdf_link = undefined; + var t: m.pardes_pdf_owned_text = undefined; + if (m.pardes_pdf_link_at(base, @intCast(at.page), at.pt, &link) == ok and link.uri != null and link.uri_len < 1024 and link.destination_kind != m.PARDES_PDF_OUTLINE_DESTINATION_NONE) { + // (its URI borrowed from the page's links, kept until the next probe) + const uri = struct { + var buf: [1024]u8 = undefined; + }; + @memcpy(uri.buf[0..link.uri_len], link.uri[0..link.uri_len]); + link.uri = &uri.buf; + var text: []u8 = &.{}; + if (m.pardes_pdf_copy_rectangle(base, @intCast(at.page), link.quad, &t) == ok) { + text = heap.dupe(u8, t.data[0..t.len]) catch &.{}; + m.pardes_pdf_drop_owned_text(base, t.handle); + } + return .{ .page = at.page, .quad = link.quad, .text = text, .link = link }; + } + var sel: m.pardes_pdf_selection = undefined; + if (m.pardes_pdf_select(base, @intCast(at.page), at.pt, at.pt, &sel) != ok) return null; + defer m.pardes_pdf_drop_selection(base, sel.handle); + if (sel.quad_count == 0 or m.pardes_pdf_copy_selection(base, @intCast(at.page), sel.start, sel.end, &t) != ok) return null; + defer m.pardes_pdf_drop_owned_text(base, t.handle); + if (t.len == 0) return null; + return .{ .page = at.page, .quad = sel.quads[0], .text = heap.dupe(u8, t.data[0..t.len]) catch return null, .link = null }; +} + +/// A link followed: a place in the document scrolled to, else looked at +/// (its URI); one whose text names another place than it goes to offers +/// both, a +Links. +fn follow(st: *Pdf, link: m.pardes_pdf_link, text: []const u8) void { + if (link.destination_kind == m.PARDES_PDF_OUTLINE_DESTINATION_INTERNAL) return goToXY(st, @intCast(link.page), link.has_x != 0, link.x, link.has_y != 0, link.y); + const uri = link.uri[0..link.uri_len]; + var shown: [512]u8 = undefined; + var k: usize = 0; + for (text) |ch| if (ch > ' ' and k < shown.len) { + shown[k] = ch; + k += 1; + }; + var both: [1600]u8 = undefined; + if (k > 0 and std.mem.indexOf(u8, shown[0..k], "://") != null and !std.mem.eql(u8, shown[0..k], uri)) if (std.fmt.bufPrint(&both, "{s}\n{s}\n", .{ shown[0..k], uri })) |rows| { + _ = addon.text("+Links", rows); + return; + } else |_| {}; + addon.look(uri); +} + +/// Page `p` at an outline's or a link's point of it: its height (the +/// window's top there) and, fit height, how far across. +fn goToXY(st: *Pdf, page: u32, has_x: bool, x: f32, has_y: bool, y: f32) void { + const p = @min(page, st.pages - 1); + const size = st.size[p]; + if (has_x and st.fit_height and std.math.isFinite(x)) if (pixels(st, st.active)) |l| { + const shown = f64Of(l.vh) * size.width / size.height; + const over = shown - f64Of(l.vw); + const want = std.math.clamp(x, 0, size.width) / size.width * shown - f64Of(l.vw) / 2; + if (over > 0) st.pan = @intFromFloat(@round(std.math.clamp(want, 0, over) / over * 65535)); + }; + goTo(st, p, if (has_y and std.math.isFinite(y)) std.math.clamp(y, 0, size.height) / size.height else 0); +} + +// ---- the outline ---- + +/// The outline as rows `file.pdf:PAGE:N title` (N its place in the outline, +/// from 1), indented by depth; an entry with nowhere to go takes its first +/// child's that has, and an http(s) one is its URI. +fn usable(o: *const m.pardes_pdf_outline_result, i: usize) bool { + const it = o.items[i]; + if (it.destination_kind == m.PARDES_PDF_OUTLINE_DESTINATION_INTERNAL) return true; + if (it.destination_kind != m.PARDES_PDF_OUTLINE_DESTINATION_EXTERNAL or it.uri_len == 0 or it.uri_len > 256) return false; + const u = o.bytes[it.uri_offset..][0..it.uri_len]; + return (std.mem.startsWith(u8, u, "http://") or std.mem.startsWith(u8, u, "https://")) and for (u) |ch| { + if (ch <= 0x20 or ch == 0x7f) break false; + } else true; +} + +/// Entry `i`'s place: its own, else the first usable one below it. +fn resolve(o: *const m.pardes_pdf_outline_result, i: usize) ?usize { + if (o.items[i].destination_kind != m.PARDES_PDF_OUTLINE_DESTINATION_NONE) return if (usable(o, i)) i else null; + var k = i + 1; + while (k < o.item_count and o.items[k].depth > o.items[i].depth) : (k += 1) if (usable(o, k)) return k; + return null; +} + +fn sections(st: *Pdf) void { + const base = st.d.?.base; + var o: m.pardes_pdf_outline_result = undefined; + if (m.pardes_pdf_load_outline(base, &o) != ok) return addon.say("PdfSections: this PDF has no outline", .err); + defer m.pardes_pdf_drop_outline_result(base, o.handle); + const rows = heap.alloc(u8, o.item_count * 300 + 1) catch return; + defer heap.free(rows); + var w: std.Io.Writer = .fixed(rows); + for (o.items[0..o.item_count], 0..) |it, i| { + const to = o.items[resolve(&o, i) orelse continue]; + if (to.destination_kind == m.PARDES_PDF_OUTLINE_DESTINATION_INTERNAL) w.print("{s}:{d}:{d} ", .{ st.name, to.page + 1, i + 1 }) catch {} else w.print("{s} ", .{o.bytes[to.uri_offset..][0..to.uri_len]}) catch {}; + w.splatByteAll(' ', 2 * it.depth) catch {}; + // the title on one line: control and invalid characters a space + // between words, none at either end + const t = o.bytes[it.title_offset..][0..it.title_len]; + const start = w.end; + var gap = false; + var i_: usize = 0; + while (it.title_present != 0 and i_ < t.len) { + const k = std.unicode.utf8ByteSequenceLength(t[i_]) catch 0; + if (k > 0 and i_ + k > t.len) break; + defer i_ += @max(k, 1); + const ch = (if (k > 0) std.unicode.utf8Decode(t[i_..][0..k]) catch null else null) orelse 0; + if (ch <= 0x20 or ch == 0x7f or (ch >= 0x80 and ch <= 0x9f) or ch == 0x2028 or ch == 0x2029) { + gap = w.end > start; + } else if (w.end + k + 1 - start <= 255) { + if (gap) w.writeByte(' ') catch {}; + w.writeAll(t[i_..][0..k]) catch {}; + gap = false; + } + } + if (w.end == start) w.writeAll(if (it.title_present != 0) "[empty title]" else "[untitled]") catch {}; + w.writeByte('\n') catch {}; + } + if (w.end == 0) return addon.say("PdfSections: this PDF has no outline", .err); + _ = addon.text("+PdfSections", w.buffered()); +} + +/// A +PdfSections row's place: page P, section S, which must be on it. +fn section(st: *Pdf, page: u32, ord: u32) bool { + const base = st.d.?.base; + var o: m.pardes_pdf_outline_result = std.mem.zeroes(m.pardes_pdf_outline_result); + defer if (o.handle != null) m.pardes_pdf_drop_outline_result(base, o.handle); + var said: [200]u8 = undefined; + const r = if (m.pardes_pdf_load_outline(base, &o) == ok and ord > 0 and ord <= o.item_count) resolve(&o, ord - 1) else null; + const to = o.items[r orelse return miss(std.fmt.bufPrint(&said, "PdfSections: {s} has no section {d}", .{ st.name, ord }))]; + if (to.destination_kind == m.PARDES_PDF_OUTLINE_DESTINATION_EXTERNAL) { + addon.look(o.bytes[to.uri_offset..][0..@min(to.uri_len, 256)]); + return true; + } + if (to.page + 1 != page) return miss(std.fmt.bufPrint(&said, "PdfSections: section {d} of {s} is on page {d}, not {d}", .{ ord, st.name, to.page + 1, page })); + dropSel(st); + goToXY(st, @intCast(to.page), to.has_x != 0, to.x, to.has_y != 0, to.y); + return true; +} + +/// A miss said (an error): no place here. +fn miss(said: anyerror![]const u8) bool { + addon.say(said catch "", .err); + return false; +} + +fn none() bool { + return miss("has no text to address; its address is a page, :N"); +} |
