//! 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 from the line //! the place names. 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 wheel's whole notches glide there over four ticks; 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); comptime { addon.exportLib(&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 frame_ns = 16 * std.time.ns_per_ms; // a glide's next step 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. A glide: a wheel's /// pixels still to go in a view, half each frame, all by its 4th tick. go: struct { since_tick: f64 = 0, travel: f64 = 0, framed: bool = false, landed: bool = false, fling: bool = false, glide: f64 = 0, glide_n: u8 = 0, glide_view: u8 = 0 } = .{}, 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; if (go.glide != 0) if (pixels(st, go.glide_view)) |l| { go.glide_n += 1; const step = if (go.glide_n >= 4) go.glide else if (flags.framed) go.glide / 2 else 0; go.glide -= step; scrollBy(st, l, step); } else { go.glide = 0; }; // 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; if (go.glide != 0) next = now + frame_ns; // 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 the place's line (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..lineOf(st)) |_| at = if (std.mem.indexOfScalarPos(u8, t, at, '\n')) |nl| nl + 1 else t.len; 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, false), 'f', 'b' => move(st, l, if (cp == 'f') 1 else -1, vh, n, false), 'e', 'y' => move(st, l, if (cp == 'e') 1 else -1, cell, 1, true), 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), true), '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), false), 'k', @backingInt(K.up) => move(st, l, -1, cell, counted(st), false), @backingInt(K.page_down) => move(st, l, 1, vh, counted(st), false), @backingInt(K.page_up) => move(st, l, -1, vh, counted(st), false), '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, gliding there; a touchpad's fraction its // fraction at once; as text a line, a page at the edge 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; if (l.v.glyphs) move(st, l, dir, 0, @intFromFloat(@max(1, @round(notches))), true) else if (notches != @floor(notches)) scrollBy(st, l, dir * notches * cell) else { st.go.glide += dir * notches * cell; st.go.glide_n, st.go.glide_view = .{ 0, id }; } 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); } /// The line of the page's text the place names. fn lineOf(st: *const Pdf) usize { return @min(@as(usize, @intFromFloat(@round(std.math.clamp(st.frac, 0, 1) * f64Of(st.text.lines)))), st.text.lines -| 1); } /// Down (dir 1) or up `n` steps of `px` pixels in view `l`; as text, a /// page a step, or with `line` a line, and a page at the window's edge. fn move(st: *Pdf, l: *Layout, dir: f64, px: f64, n: u32, line: bool) void { if (!l.v.glyphs) return scrollBy(st, l, dir * px * f64Of(n)); const page = @as(i64, st.page) + @as(i64, @intFromFloat(dir)) * @as(i64, if (line) 1 else n); const at: i64 = @intCast(lineOf(st)); const last = @as(i64, st.text.lines) - l.v.rows; if (!line or st.text.page != st.page or (dir > 0 and at >= last) or (dir < 0 and at == 0)) { if (page >= 0 and page < st.pages or !line) goPage(st, @intCast(std.math.clamp(page, 0, st.pages - 1))); return; } goTo(st, st.page, f64Of(std.math.clamp(at + @as(i64, @intFromFloat(dir)) * n, 0, @max(last, 0))) / f64Of(st.text.lines)); } 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"); }