From 548e7c67944a983c7051733817d4905245c1318c Mon Sep 17 00:00:00 2001 From: Laurenz Stampfl <47084093+LaurenzV@users.noreply.github.com> Date: Mon, 16 Dec 2024 23:33:44 +0100 Subject: [PATCH] First attempt at outline --- crates/typst-pdf/src/krilla.rs | 6 +- crates/typst-pdf/src/lib.rs | 1 + crates/typst-pdf/src/outline.rs | 149 ++++++++++++++++++++++++++++++++ 3 files changed, 154 insertions(+), 2 deletions(-) create mode 100644 crates/typst-pdf/src/outline.rs diff --git a/crates/typst-pdf/src/krilla.rs b/crates/typst-pdf/src/krilla.rs index 985626e10..13216f413 100644 --- a/crates/typst-pdf/src/krilla.rs +++ b/crates/typst-pdf/src/krilla.rs @@ -29,6 +29,7 @@ use typst_library::visualize::{ FillRule, Geometry, Image, ImageKind, Paint, Path, PathItem, Shape, }; use typst_syntax::Span; +use crate::outline::build_outline; #[derive(Debug, Clone)] pub(crate) struct State { @@ -161,8 +162,8 @@ pub struct GlobalContext<'a> { // if it appears in the document multiple times. We just store the // first appearance, though. image_spans: HashMap, - document: &'a PagedDocument, - options: &'a PdfOptions<'a>, + pub(crate) document: &'a PagedDocument, + pub(crate) options: &'a PdfOptions<'a>, loc_to_named: HashMap, languages: BTreeMap, } @@ -376,6 +377,7 @@ pub fn pdf( metadata }; + document.set_outline(build_outline(&gc)); document.set_metadata(metadata); match document.finish() { diff --git a/crates/typst-pdf/src/lib.rs b/crates/typst-pdf/src/lib.rs index 5baaf5e1a..6facbd150 100644 --- a/crates/typst-pdf/src/lib.rs +++ b/crates/typst-pdf/src/lib.rs @@ -4,6 +4,7 @@ mod image; mod krilla; mod paint; mod util; +mod outline; use typst_library::diag::SourceResult; use typst_library::foundations::{Datetime, Smart}; diff --git a/crates/typst-pdf/src/outline.rs b/crates/typst-pdf/src/outline.rs new file mode 100644 index 000000000..34d25ddd9 --- /dev/null +++ b/crates/typst-pdf/src/outline.rs @@ -0,0 +1,149 @@ +use std::num::NonZeroUsize; +use krilla::destination::XyzDestination; +use krilla::outline::{Outline, OutlineNode}; +use typst_library::foundations::{NativeElement, Packed, StyleChain}; +use typst_library::layout::Abs; +use typst_library::model::HeadingElem; +use crate::krilla::GlobalContext; +use crate::util::AbsExt; + +/// A heading in the outline panel. +#[derive(Debug)] +struct HeadingNode<'a> { + element: &'a Packed, + level: NonZeroUsize, + bookmarked: bool, + children: Vec>, +} + +impl<'a> HeadingNode<'a> { + fn leaf(element: &'a Packed) -> Self { + HeadingNode { + level: element.resolve_level(StyleChain::default()), + // 'bookmarked' set to 'auto' falls back to the value of 'outlined'. + bookmarked: element + .bookmarked(StyleChain::default()) + .unwrap_or_else(|| element.outlined(StyleChain::default())), + element, + children: Vec::new(), + } + } +} + +pub(crate) fn build_outline(gc: &GlobalContext) -> Outline { + let mut tree: Vec = vec![]; + + // Stores the level of the topmost skipped ancestor of the next bookmarked + // heading. A skipped heading is a heading with 'bookmarked: false', that + // is, it is not added to the PDF outline, and so is not in the tree. + // Therefore, its next descendant must be added at its level, which is + // enforced in the manner shown below. + let mut last_skipped_level = None; + let elements = &gc.document.introspector.query(&HeadingElem::elem().select()); + + for elem in elements.iter() { + if let Some(page_ranges) = &gc.options.page_ranges { + if !page_ranges + .includes_page(gc.document.introspector.page(elem.location().unwrap())) + { + // Don't bookmark headings in non-exported pages + continue; + } + } + + let heading = elem.to_packed::().unwrap(); + let leaf = HeadingNode::leaf(heading); + + if leaf.bookmarked { + let mut children = &mut tree; + + // Descend the tree through the latest bookmarked heading of each + // level until either: + // - you reach a node whose children would be brothers of this + // heading (=> add the current heading as a child of this node); + // - you reach a node with no children (=> this heading probably + // skipped a few nesting levels in Typst, or one or more ancestors + // of this heading weren't bookmarked, so add it as a child of this + // node, which is its deepest bookmarked ancestor); + // - or, if the latest heading(s) was(/were) skipped + // ('bookmarked: false'), then stop if you reach a node whose + // children would be brothers of the latest skipped heading + // of lowest level (=> those skipped headings would be ancestors + // of the current heading, so add it as a 'brother' of the least + // deep skipped ancestor among them, as those ancestors weren't + // added to the bookmark tree, and the current heading should not + // be mistakenly added as a descendant of a brother of that + // ancestor.) + // + // That is, if you had a bookmarked heading of level N, a skipped + // heading of level N, a skipped heading of level N + 1, and then + // a bookmarked heading of level N + 2, that last one is bookmarked + // as a level N heading (taking the place of its topmost skipped + // ancestor), so that it is not mistakenly added as a descendant of + // the previous level N heading. + // + // In other words, a heading can be added to the bookmark tree + // at most as deep as its topmost skipped direct ancestor (if it + // exists), or at most as deep as its actual nesting level in Typst + // (not exceeding whichever is the most restrictive depth limit + // of those two). + while children.last().is_some_and(|last| { + last_skipped_level.map_or(true, |l| last.level < l) + && last.level < leaf.level + }) { + children = &mut children.last_mut().unwrap().children; + } + + // Since this heading was bookmarked, the next heading, if it is a + // child of this one, won't have a skipped direct ancestor (indeed, + // this heading would be its most direct ancestor, and wasn't + // skipped). Therefore, it can be added as a child of this one, if + // needed, following the usual rules listed above. + last_skipped_level = None; + children.push(leaf); + } else if last_skipped_level.map_or(true, |l| leaf.level < l) { + // Only the topmost / lowest-level skipped heading matters when you + // have consecutive skipped headings (since none of them are being + // added to the bookmark tree), hence the condition above. + // This ensures the next bookmarked heading will be placed + // at most as deep as its topmost skipped ancestors. Deeper + // ancestors do not matter as the nesting structure they create + // won't be visible in the PDF outline. + last_skipped_level = Some(leaf.level); + } + } + + let mut outline = Outline::new(); + + for child in convert_heading_nodes(&tree, gc) { + outline.push_child(child); + } + + outline +} + +fn convert_heading_nodes(nodes: &[HeadingNode], gc: &GlobalContext) -> Vec { + nodes.iter().flat_map(|node| { + let loc = node.element.location().unwrap(); + let title = node.element.body().plain_text().to_string(); + let pos = gc.document.introspector.position(loc); + let page_index = pos.page.get() - 1; + + if !gc.page_excluded(page_index) { + let y = (pos.point.y - Abs::pt(10.0)).max(Abs::zero()); + let dest = XyzDestination::new( + page_index, + krilla::geom::Point::from_xy(pos.point.x.to_f32(), y.to_f32()), + ); + + let mut outline_node = OutlineNode::new(title, dest); + for child in convert_heading_nodes(&node.children, gc) { + outline_node.push_child(child); + } + + return Some(outline_node); + } + + None + }).collect() +}