diff options
Diffstat (limited to 'src/eval')
| -rw-r--r-- | src/eval/collapse.rs | 100 | ||||
| -rw-r--r-- | src/eval/content.rs | 604 | ||||
| -rw-r--r-- | src/eval/func.rs | 3 | ||||
| -rw-r--r-- | src/eval/layout.rs | 382 | ||||
| -rw-r--r-- | src/eval/mod.rs | 13 | ||||
| -rw-r--r-- | src/eval/module.rs | 3 | ||||
| -rw-r--r-- | src/eval/ops.rs | 9 | ||||
| -rw-r--r-- | src/eval/raw.rs | 3 | ||||
| -rw-r--r-- | src/eval/show.rs | 111 | ||||
| -rw-r--r-- | src/eval/styles.rs | 829 | ||||
| -rw-r--r-- | src/eval/value.rs | 3 |
11 files changed, 15 insertions, 2045 deletions
diff --git a/src/eval/collapse.rs b/src/eval/collapse.rs deleted file mode 100644 index 5e7a25f8..00000000 --- a/src/eval/collapse.rs +++ /dev/null @@ -1,100 +0,0 @@ -use super::{StyleChain, StyleVec, StyleVecBuilder}; - -/// A wrapper around a [`StyleVecBuilder`] that allows to collapse items. -pub struct CollapsingBuilder<'a, T> { - builder: StyleVecBuilder<'a, T>, - staged: Vec<(T, StyleChain<'a>, Option<u8>)>, - last: Last, -} - -/// What the last non-ignorant item was. -#[derive(Debug, Copy, Clone, Eq, PartialEq)] -enum Last { - Weak, - Destructive, - Supportive, -} - -impl<'a, T> CollapsingBuilder<'a, T> { - /// Create a new style-vec builder. - pub fn new() -> Self { - Self { - builder: StyleVecBuilder::new(), - staged: vec![], - last: Last::Destructive, - } - } - - /// Can only exist when there is at least one supportive item to its left - /// and to its right, with no destructive items or weak items in between to - /// its left and no destructive items in between to its right. There may be - /// ignorant items in between in both directions. - pub fn weak(&mut self, item: T, strength: u8, styles: StyleChain<'a>) { - if self.last != Last::Destructive { - if self.last == Last::Weak { - if let Some(i) = self - .staged - .iter() - .position(|(.., prev)| prev.map_or(false, |p| p < strength)) - { - self.staged.remove(i); - } else { - return; - } - } - - self.staged.push((item, styles, Some(strength))); - self.last = Last::Weak; - } - } - - /// Forces nearby weak items to collapse. - pub fn destructive(&mut self, item: T, styles: StyleChain<'a>) { - self.flush(false); - self.push(item, styles); - self.last = Last::Destructive; - } - - /// Allows nearby weak items to exist. - pub fn supportive(&mut self, item: T, styles: StyleChain<'a>) { - self.flush(true); - self.push(item, styles); - self.last = Last::Supportive; - } - - /// Has no influence on other items. - pub fn ignorant(&mut self, item: T, styles: StyleChain<'a>) { - self.staged.push((item, styles, None)); - } - - /// Iterate over the contained items. - pub fn items(&self) -> impl DoubleEndedIterator<Item = &T> { - self.builder.items().chain(self.staged.iter().map(|(item, ..)| item)) - } - - /// Return the finish style vec and the common prefix chain. - pub fn finish(mut self) -> (StyleVec<T>, StyleChain<'a>) { - self.flush(false); - self.builder.finish() - } - - /// Push the staged items, filtering out weak items if `supportive` is false. - fn flush(&mut self, supportive: bool) { - for (item, styles, strength) in self.staged.drain(..) { - if supportive || strength.is_none() { - self.builder.push(item, styles); - } - } - } - - /// Push a new item into the style vector. - fn push(&mut self, item: T, styles: StyleChain<'a>) { - self.builder.push(item, styles); - } -} - -impl<'a, T> Default for CollapsingBuilder<'a, T> { - fn default() -> Self { - Self::new() - } -} diff --git a/src/eval/content.rs b/src/eval/content.rs deleted file mode 100644 index 2465f0e3..00000000 --- a/src/eval/content.rs +++ /dev/null @@ -1,604 +0,0 @@ -use std::fmt::Debug; -use std::hash::Hash; -use std::iter::Sum; -use std::ops::{Add, AddAssign}; - -use typed_arena::Arena; - -use super::{ - CollapsingBuilder, Interruption, Key, Layout, LayoutNode, Show, ShowNode, StyleMap, - StyleVecBuilder, -}; -use crate::diag::StrResult; -use crate::library::layout::{FlowChild, FlowNode, PageNode, PlaceNode, Spacing}; -use crate::library::prelude::*; -use crate::library::structure::{ListItem, ListKind, ListNode, ORDERED, UNORDERED}; -use crate::library::text::{DecoNode, ParChild, ParNode, UNDERLINE}; -use crate::util::EcoString; - -/// Composable representation of styled content. -/// -/// This results from: -/// - anything written between square brackets in Typst -/// - any node constructor -/// -/// Content is represented as a tree of nodes. There are two nodes of special -/// interest: -/// -/// 1. A `Styled` node attaches a style map to other content. For example, a -/// single bold word could be represented as a `Styled(Text("Hello"), -/// [TextNode::STRONG: true])` node. -/// -/// 2. A `Sequence` node content combines other arbitrary content and is the -/// representation of a "flow" of other nodes. So, when you write `[Hi] + -/// [you]` in Typst, this type's [`Add`] implementation is invoked and the -/// two [`Text`](Self::Text) nodes are combined into a single -/// [`Sequence`](Self::Sequence) node. A sequence may contain nested -/// sequences. -#[derive(PartialEq, Clone, Hash)] -pub enum Content { - /// A word space. - Space, - /// A forced line break. If soft (`true`), the preceding line can still be - /// justified, if hard (`false`) not. - Linebreak(bool), - /// Horizontal spacing. - Horizontal(Spacing), - /// Plain text. - Text(EcoString), - /// A smart quote, may be single (`false`) or double (`true`). - Quote(bool), - /// An inline-level node. - Inline(LayoutNode), - /// A paragraph break. - Parbreak, - /// A column break. - Colbreak, - /// Vertical spacing. - Vertical(Spacing), - /// A block-level node. - Block(LayoutNode), - /// An item in an unordered list. - List(ListItem), - /// An item in an ordered list. - Enum(ListItem), - /// A page break. - Pagebreak, - /// A page node. - Page(PageNode), - /// A node that can be realized with styles. - Show(ShowNode), - /// Content with attached styles. - Styled(Arc<(Self, StyleMap)>), - /// A sequence of multiple nodes. - Sequence(Arc<Vec<Self>>), -} - -impl Content { - /// Create empty content. - pub fn new() -> Self { - Self::sequence(vec![]) - } - - /// Create content from an inline-level node. - pub fn inline<T>(node: T) -> Self - where - T: Layout + Debug + Hash + Sync + Send + 'static, - { - Self::Inline(node.pack()) - } - - /// Create content from a block-level node. - pub fn block<T>(node: T) -> Self - where - T: Layout + Debug + Hash + Sync + Send + 'static, - { - Self::Block(node.pack()) - } - - /// Create content from a showable node. - pub fn show<T>(node: T) -> Self - where - T: Show + Debug + Hash + Sync + Send + 'static, - { - Self::Show(node.pack()) - } - - /// Create a new sequence nodes from multiples nodes. - pub fn sequence(seq: Vec<Self>) -> Self { - if seq.len() == 1 { - seq.into_iter().next().unwrap() - } else { - Self::Sequence(Arc::new(seq)) - } - } - - /// Repeat this content `n` times. - pub fn repeat(&self, n: i64) -> StrResult<Self> { - let count = usize::try_from(n) - .map_err(|_| format!("cannot repeat this content {} times", n))?; - - Ok(Self::sequence(vec![self.clone(); count])) - } - - /// Style this content with a single style property. - pub fn styled<'k, K: Key<'k>>(mut self, key: K, value: K::Value) -> Self { - if let Self::Styled(styled) = &mut self { - if let Some((_, map)) = Arc::get_mut(styled) { - map.apply(key, value); - return self; - } - } - - Self::Styled(Arc::new((self, StyleMap::with(key, value)))) - } - - /// Style this content with a full style map. - pub fn styled_with_map(mut self, styles: StyleMap) -> Self { - if styles.is_empty() { - return self; - } - - if let Self::Styled(styled) = &mut self { - if let Some((_, map)) = Arc::get_mut(styled) { - map.apply_map(&styles); - return self; - } - } - - Self::Styled(Arc::new((self, styles))) - } - - /// Underline this content. - pub fn underlined(self) -> Self { - Self::show(DecoNode::<UNDERLINE>(self)) - } - - /// Return a node that is spaced apart at top and bottom. - pub fn spaced(self, above: Length, below: Length) -> Self { - if above.is_zero() && below.is_zero() { - return self; - } - - let mut seq = vec![]; - if !above.is_zero() { - seq.push(Content::Vertical(above.into())); - } - - seq.push(self); - - if !below.is_zero() { - seq.push(Content::Vertical(below.into())); - } - - Self::sequence(seq) - } - - /// Layout this content into a collection of pages. - pub fn layout(&self, ctx: &mut Context) -> TypResult<Vec<Arc<Frame>>> { - let sya = Arena::new(); - let tpa = Arena::new(); - - let styles = ctx.styles.clone(); - let styles = StyleChain::with_root(&styles); - - let mut builder = Builder::new(&sya, &tpa, true); - builder.process(ctx, self, styles)?; - builder.finish(ctx, styles)?; - - let mut frames = vec![]; - let (pages, shared) = builder.pages.unwrap().finish(); - - for (page, map) in pages.iter() { - let number = 1 + frames.len(); - frames.extend(page.layout(ctx, number, map.chain(&shared))?); - } - - Ok(frames) - } -} - -impl Layout for Content { - fn layout( - &self, - ctx: &mut Context, - regions: &Regions, - styles: StyleChain, - ) -> TypResult<Vec<Arc<Frame>>> { - let sya = Arena::new(); - let tpa = Arena::new(); - - let mut builder = Builder::new(&sya, &tpa, false); - builder.process(ctx, self, styles)?; - builder.finish(ctx, styles)?; - - let (flow, shared) = builder.flow.finish(); - FlowNode(flow).layout(ctx, regions, shared) - } - - fn pack(self) -> LayoutNode { - match self { - Content::Block(node) => node, - other => LayoutNode::new(other), - } - } -} - -impl Default for Content { - fn default() -> Self { - Self::new() - } -} - -impl Debug for Content { - fn fmt(&self, f: &mut Formatter) -> fmt::Result { - match self { - Self::Space => f.pad("Space"), - Self::Linebreak(soft) => write!(f, "Linebreak({soft})"), - Self::Horizontal(kind) => write!(f, "Horizontal({kind:?})"), - Self::Text(text) => write!(f, "Text({text:?})"), - Self::Quote(double) => write!(f, "Quote({double})"), - Self::Inline(node) => { - f.write_str("Inline(")?; - node.fmt(f)?; - f.write_str(")") - } - Self::Parbreak => f.pad("Parbreak"), - Self::Colbreak => f.pad("Colbreak"), - Self::Vertical(kind) => write!(f, "Vertical({kind:?})"), - Self::Block(node) => { - f.write_str("Block(")?; - node.fmt(f)?; - f.write_str(")") - } - Self::List(item) => { - f.write_str("- ")?; - item.body.fmt(f) - } - Self::Enum(item) => { - if let Some(number) = item.number { - write!(f, "{}", number)?; - } - f.write_str(". ")?; - item.body.fmt(f) - } - Self::Pagebreak => f.pad("Pagebreak"), - Self::Page(page) => page.fmt(f), - Self::Show(node) => { - f.write_str("Show(")?; - node.fmt(f)?; - f.write_str(")") - } - Self::Styled(styled) => { - let (sub, map) = styled.as_ref(); - map.fmt(f)?; - sub.fmt(f) - } - Self::Sequence(seq) => f.debug_list().entries(seq.iter()).finish(), - } - } -} - -impl Add for Content { - type Output = Self; - - fn add(self, rhs: Self) -> Self::Output { - Self::Sequence(match (self, rhs) { - (Self::Sequence(mut lhs), Self::Sequence(rhs)) => { - let mutable = Arc::make_mut(&mut lhs); - match Arc::try_unwrap(rhs) { - Ok(vec) => mutable.extend(vec), - Err(rc) => mutable.extend(rc.iter().cloned()), - } - lhs - } - (Self::Sequence(mut lhs), rhs) => { - Arc::make_mut(&mut lhs).push(rhs); - lhs - } - (lhs, Self::Sequence(mut rhs)) => { - Arc::make_mut(&mut rhs).insert(0, lhs); - rhs - } - (lhs, rhs) => Arc::new(vec![lhs, rhs]), - }) - } -} - -impl AddAssign for Content { - fn add_assign(&mut self, rhs: Self) { - *self = std::mem::take(self) + rhs; - } -} - -impl Sum for Content { - fn sum<I: Iterator<Item = Self>>(iter: I) -> Self { - Self::sequence(iter.collect()) - } -} - -/// Builds a flow or page nodes from content. -struct Builder<'a> { - /// An arena where intermediate style chains are stored. - sya: &'a Arena<StyleChain<'a>>, - /// An arena where intermediate content resulting from show rules is stored. - tpa: &'a Arena<Content>, - /// The already built page runs. - pages: Option<StyleVecBuilder<'a, PageNode>>, - /// The currently built list. - list: Option<ListBuilder<'a>>, - /// The currently built flow. - flow: CollapsingBuilder<'a, FlowChild>, - /// The currently built paragraph. - par: CollapsingBuilder<'a, ParChild>, - /// Whether to keep the next page even if it is empty. - keep_next: bool, -} - -/// Builds an unordered or ordered list from items. -struct ListBuilder<'a> { - styles: StyleChain<'a>, - kind: ListKind, - items: Vec<ListItem>, - tight: bool, - staged: Vec<(&'a Content, StyleChain<'a>)>, -} - -impl<'a> Builder<'a> { - /// Prepare the builder. - fn new(sya: &'a Arena<StyleChain<'a>>, tpa: &'a Arena<Content>, top: bool) -> Self { - Self { - sya, - tpa, - pages: top.then(|| StyleVecBuilder::new()), - flow: CollapsingBuilder::new(), - list: None, - par: CollapsingBuilder::new(), - keep_next: true, - } - } - - /// Process content. - fn process( - &mut self, - ctx: &mut Context, - content: &'a Content, - styles: StyleChain<'a>, - ) -> TypResult<()> { - if let Some(builder) = &mut self.list { - match content { - Content::Space => { - builder.staged.push((content, styles)); - return Ok(()); - } - Content::Parbreak => { - builder.staged.push((content, styles)); - return Ok(()); - } - Content::List(item) if builder.kind == UNORDERED => { - builder.tight &= - builder.staged.iter().all(|&(t, _)| *t != Content::Parbreak); - builder.staged.clear(); - builder.items.push(item.clone()); - return Ok(()); - } - Content::Enum(item) if builder.kind == ORDERED => { - builder.tight &= - builder.staged.iter().all(|&(t, _)| *t != Content::Parbreak); - builder.staged.clear(); - builder.items.push(item.clone()); - return Ok(()); - } - _ => self.finish_list(ctx)?, - } - } - - match content { - Content::Space => { - self.par.weak(ParChild::Text(' '.into()), 0, styles); - } - Content::Linebreak(soft) => { - let c = if *soft { '\u{2028}' } else { '\n' }; - self.par.destructive(ParChild::Text(c.into()), styles); - } - Content::Horizontal(kind) => { - let child = ParChild::Spacing(*kind); - if kind.is_fractional() { - self.par.destructive(child, styles); - } else { - self.par.ignorant(child, styles); - } - } - Content::Quote(double) => { - self.par.supportive(ParChild::Quote(*double), styles); - } - Content::Text(text) => { - self.par.supportive(ParChild::Text(text.clone()), styles); - } - Content::Inline(node) => { - self.par.supportive(ParChild::Node(node.clone()), styles); - } - Content::Parbreak => { - self.finish_par(styles); - self.flow.weak(FlowChild::Parbreak, 1, styles); - } - Content::Colbreak => { - self.finish_par(styles); - self.flow.destructive(FlowChild::Colbreak, styles); - } - Content::Vertical(kind) => { - self.finish_par(styles); - let child = FlowChild::Spacing(*kind); - if kind.is_fractional() { - self.flow.destructive(child, styles); - } else { - self.flow.ignorant(child, styles); - } - } - Content::Block(node) => { - self.finish_par(styles); - let child = FlowChild::Node(node.clone()); - if node.is::<PlaceNode>() { - self.flow.ignorant(child, styles); - } else { - self.flow.supportive(child, styles); - } - self.finish_par(styles); - } - Content::List(item) => { - self.list = Some(ListBuilder { - styles, - kind: UNORDERED, - items: vec![item.clone()], - tight: true, - staged: vec![], - }); - } - Content::Enum(item) => { - self.list = Some(ListBuilder { - styles, - kind: ORDERED, - items: vec![item.clone()], - tight: true, - staged: vec![], - }); - } - Content::Pagebreak => { - self.finish_page(ctx, true, true, styles)?; - } - Content::Page(page) => { - self.finish_page(ctx, false, false, styles)?; - if let Some(pages) = &mut self.pages { - pages.push(page.clone(), styles); - } - } - Content::Show(node) => { - let id = node.id(); - let realized = match styles.realize(ctx, node)? { - Some(content) => content, - None => node.realize(ctx, styles)?, - }; - let content = node.finalize(ctx, styles, realized)?; - let stored = self.tpa.alloc(content); - self.process(ctx, stored, styles.unscoped(id))?; - } - Content::Styled(styled) => { - let (sub, map) = styled.as_ref(); - let stored = self.sya.alloc(styles); - let styles = map.chain(stored); - - let interruption = map.interruption(); - match interruption { - Some(Interruption::Page) => { - self.finish_page(ctx, false, true, styles)? - } - Some(Interruption::Par) => self.finish_par(styles), - None => {} - } - - self.process(ctx, sub, styles)?; - - match interruption { - Some(Interruption::Page) => { - self.finish_page(ctx, true, false, styles)? - } - Some(Interruption::Par) => self.finish_par(styles), - None => {} - } - } - Content::Sequence(seq) => { - for sub in seq.iter() { - self.process(ctx, sub, styles)?; - } - } - } - - Ok(()) - } - - /// Finish the currently built paragraph. - fn finish_par(&mut self, styles: StyleChain<'a>) { - let (mut par, shared) = std::mem::take(&mut self.par).finish(); - if !par.is_empty() { - // Paragraph indent should only apply if the paragraph starts with - // text and follows directly after another paragraph. - let indent = shared.get(ParNode::INDENT); - if !indent.is_zero() - && par - .items() - .find_map(|child| match child { - ParChild::Spacing(_) => None, - ParChild::Text(_) | ParChild::Quote(_) => Some(true), - ParChild::Node(_) => Some(false), - }) - .unwrap_or_default() - && self - .flow - .items() - .rev() - .find_map(|child| match child { - FlowChild::Leading => None, - FlowChild::Parbreak => None, - FlowChild::Node(node) => Some(node.is::<ParNode>()), - FlowChild::Spacing(_) => Some(false), - FlowChild::Colbreak => Some(false), - }) - .unwrap_or_default() - { - par.push_front(ParChild::Spacing(indent.into())); - } - - let node = ParNode(par).pack(); - self.flow.supportive(FlowChild::Node(node), shared); - } - self.flow.weak(FlowChild::Leading, 0, styles); - } - - /// Finish the currently built list. - fn finish_list(&mut self, ctx: &mut Context) -> TypResult<()> { - let ListBuilder { styles, kind, items, tight, staged } = match self.list.take() { - Some(list) => list, - None => return Ok(()), - }; - - let content = match kind { - UNORDERED => Content::show(ListNode::<UNORDERED> { start: 1, tight, items }), - ORDERED | _ => Content::show(ListNode::<ORDERED> { start: 1, tight, items }), - }; - - let stored = self.tpa.alloc(content); - self.process(ctx, stored, styles)?; - for (content, styles) in staged { - self.process(ctx, content, styles)?; - } - - Ok(()) - } - - /// Finish the currently built page run. - fn finish_page( - &mut self, - ctx: &mut Context, - keep_last: bool, - keep_next: bool, - styles: StyleChain<'a>, - ) -> TypResult<()> { - self.finish_list(ctx)?; - self.finish_par(styles); - if let Some(pages) = &mut self.pages { - let (flow, shared) = std::mem::take(&mut self.flow).finish(); - if !flow.is_empty() || (keep_last && self.keep_next) { - let styles = if flow.is_empty() { styles } else { shared }; - let node = PageNode(FlowNode(flow).pack()); - pages.push(node, styles); - } - } - self.keep_next = keep_next; - Ok(()) - } - - /// Finish everything. - fn finish(&mut self, ctx: &mut Context, styles: StyleChain<'a>) -> TypResult<()> { - self.finish_page(ctx, true, false, styles) - } -} diff --git a/src/eval/func.rs b/src/eval/func.rs index fcd19326..b2ecfe93 100644 --- a/src/eval/func.rs +++ b/src/eval/func.rs @@ -2,8 +2,9 @@ use std::fmt::{self, Debug, Formatter, Write}; use std::hash::{Hash, Hasher}; use std::sync::Arc; -use super::{Args, Content, Control, Eval, Scope, Scopes, StyleMap, Value}; +use super::{Args, Control, Eval, Scope, Scopes, Value}; use crate::diag::{StrResult, TypResult}; +use crate::model::{Content, StyleMap}; use crate::syntax::ast::Expr; use crate::syntax::Span; use crate::util::EcoString; diff --git a/src/eval/layout.rs b/src/eval/layout.rs deleted file mode 100644 index 117c269a..00000000 --- a/src/eval/layout.rs +++ /dev/null @@ -1,382 +0,0 @@ -//! Layouting infrastructure. - -use std::any::Any; -use std::fmt::{self, Debug, Formatter}; -use std::hash::Hash; -use std::sync::Arc; - -use super::{Barrier, RawAlign, RawLength, Resolve, StyleChain}; -use crate::diag::TypResult; -use crate::frame::{Element, Frame, Geometry}; -use crate::geom::{Align, Length, Paint, Point, Relative, Sides, Size, Spec, Stroke}; -use crate::library::graphics::MoveNode; -use crate::library::layout::{AlignNode, PadNode}; -use crate::util::Prehashed; -use crate::Context; - -/// A node that can be layouted into a sequence of regions. -/// -/// Layout return one frame per used region alongside constraints that define -/// whether the result is reusable in other regions. -pub trait Layout: 'static { - /// Layout this node into the given regions, producing constrained frames. - fn layout( - &self, - ctx: &mut Context, - regions: &Regions, - styles: StyleChain, - ) -> TypResult<Vec<Arc<Frame>>>; - - /// Convert to a packed node. - fn pack(self) -> LayoutNode - where - Self: Debug + Hash + Sized + Sync + Send + 'static, - { - LayoutNode::new(self) - } -} - -/// A sequence of regions to layout into. -#[derive(Debug, Clone, Hash)] -pub struct Regions { - /// The (remaining) size of the first region. - pub first: Size, - /// The base size for relative sizing. - pub base: Size, - /// The height of followup regions. The width is the same for all regions. - pub backlog: Vec<Length>, - /// The height of the final region that is repeated once the backlog is - /// drained. The width is the same for all regions. - pub last: Option<Length>, - /// Whether nodes should expand to fill the regions instead of shrinking to - /// fit the content. - pub expand: Spec<bool>, -} - -impl Regions { - /// Create a new region sequence with exactly one region. - pub fn one(size: Size, base: Size, expand: Spec<bool>) -> Self { - Self { - first: size, - base, - backlog: vec![], - last: None, - expand, - } - } - - /// Create a new sequence of same-size regions that repeats indefinitely. - pub fn repeat(size: Size, base: Size, expand: Spec<bool>) -> Self { - Self { - first: size, - base, - backlog: vec![], - last: Some(size.y), - expand, - } - } - - /// Create new regions where all sizes are mapped with `f`. - /// - /// Note that since all regions must have the same width, the width returned - /// by `f` is ignored for the backlog and the final region. - pub fn map<F>(&self, mut f: F) -> Self - where - F: FnMut(Size) -> Size, - { - let x = self.first.x; - Self { - first: f(self.first), - base: f(self.base), - backlog: self.backlog.iter().map(|&y| f(Size::new(x, y)).y).collect(), - last: self.last.map(|y| f(Size::new(x, y)).y), - expand: self.expand, - } - } - - /// Whether the first region is full and a region break is called for. - pub fn is_full(&self) -> bool { - Length::zero().fits(self.first.y) && !self.in_last() - } - - /// Whether the first region is the last usable region. - /// - /// If this is true, calling `next()` will have no effect. - pub fn in_last(&self) -> bool { - self.backlog.len() == 0 && self.last.map_or(true, |height| self.first.y == height) - } - - /// Advance to the next region if there is any. - pub fn next(&mut self) { - if let Some(height) = (!self.backlog.is_empty()) - .then(|| self.backlog.remove(0)) - .or(self.last) - { - self.first.y = height; - self.base.y = height; - } - } - - /// An iterator that returns the sizes of the first and all following - /// regions, equivalently to what would be produced by calling - /// [`next()`](Self::next) repeatedly until all regions are exhausted. - /// This iterater may be infinite. - pub fn iter(&self) -> impl Iterator<Item = Size> + '_ { - let first = std::iter::once(self.first); - let backlog = self.backlog.iter(); - let last = self.last.iter().cycle(); - first.chain(backlog.chain(last).map(|&h| Size::new(self.first.x, h))) - } -} - -/// A type-erased layouting node with a precomputed hash. -#[derive(Clone, Hash)] -pub struct LayoutNode(Arc<Prehashed<dyn Bounds>>); - -impl LayoutNode { - /// Pack any layoutable node. - pub fn new<T>(node: T) -> Self - where - T: Layout + Debug + Hash + Sync + Send + 'static, - { - Self(Arc::new(Prehashed::new(node))) - } - - /// Check whether the contained node is a specific layout node. - pub fn is<T: 'static>(&self) -> bool { - (**self.0).as_any().is::<T>() - } - - /// A barrier for the node. - pub fn barrier(&self) -> Barrier { - (**self.0).barrier() - } - - /// Try to downcast to a specific layout node. - pub fn downcast<T>(&self) -> Option<&T> - where - T: Layout + Debug + Hash + 'static, - { - (**self.0).as_any().downcast_ref() - } - - /// Force a size for this node. - pub fn sized(self, sizing: Spec<Option<Relative<RawLength>>>) -> Self { - if sizing.any(Option::is_some) { - SizedNode { sizing, child: self }.pack() - } else { - self - } - } - - /// Fill the frames resulting from a node. - pub fn filled(self, fill: Paint) -> Self { - FillNode { fill, child: self }.pack() - } - - /// Stroke the frames resulting from a node. - pub fn stroked(self, stroke: Stroke) -> Self { - StrokeNode { stroke, child: self }.pack() - } - - /// Set alignments for this node. - pub fn aligned(self, aligns: Spec<Option<RawAlign>>) -> Self { - if aligns.any(Option::is_some) { - AlignNode { aligns, child: self }.pack() - } else { - self - } - } - - /// Pad this node at the sides. - pub fn padded(self, padding: Sides<Relative<RawLength>>) -> Self { - if !padding.left.is_zero() - || !padding.top.is_zero() - || !padding.right.is_zero() - || !padding.bottom.is_zero() - { - PadNode { padding, child: self }.pack() - } else { - self - } - } - - /// Transform this node's contents without affecting layout. - pub fn moved(self, delta: Spec<Relative<RawLength>>) -> Self { - if delta.any(|r| !r.is_zero()) { - MoveNode { delta, child: self }.pack() - } else { - self - } - } -} - -impl Layout for LayoutNode { - fn layout( - &self, - ctx: &mut Context, - regions: &Regions, - styles: StyleChain, - ) -> TypResult<Vec<Arc<Frame>>> { - ctx.query((self, regions, styles), |ctx, (node, regions, styles)| { - node.0.layout(ctx, regions, node.barrier().chain(&styles)) - }) - .clone() - } - - fn pack(self) -> LayoutNode { - self - } -} - -impl Default for LayoutNode { - fn default() -> Self { - EmptyNode.pack() - } -} - -impl Debug for LayoutNode { - fn fmt(&self, f: &mut Formatter) -> fmt::Result { - self.0.fmt(f) - } -} - -impl PartialEq for LayoutNode { - fn eq(&self, other: &Self) -> bool { - self.0.eq(&other.0) - } -} - -trait Bounds: Layout + Debug + Sync + Send + 'static { - fn as_any(&self) -> &dyn Any; - fn barrier(&self) -> Barrier; -} - -impl<T> Bounds for T -where - T: Layout + Debug + Hash + Sync + Send + 'static, -{ - fn as_any(&self) -> &dyn Any { - self - } - - fn barrier(&self) -> Barrier { - Barrier::new::<T>() - } -} - -/// A layout node that produces an empty frame. -/// -/// The packed version of this is returned by [`PackedNode::default`]. -#[derive(Debug, Hash)] -struct EmptyNode; - -impl Layout for EmptyNode { - fn layout( - &self, - _: &mut Context, - regions: &Regions, - _: StyleChain, - ) -> TypResult<Vec<Arc<Frame>>> { - Ok(vec![Arc::new(Frame::new( - regions.expand.select(regions.first, Size::zero()), - ))]) - } -} - -/// Fix the size of a node. -#[derive(Debug, Hash)] -struct SizedNode { - /// How to size the node horizontally and vertically. - sizing: Spec<Option<Relative<RawLength>>>, - /// The node to be sized. - child: LayoutNode, -} - -impl Layout for SizedNode { - fn layout( - &self, - ctx: &mut Context, - regions: &Regions, - styles: StyleChain, - ) -> TypResult<Vec<Arc<Frame>>> { - // The "pod" is the region into which the child will be layouted. - let pod = { - // Resolve the sizing to a concrete size. - let size = self - .sizing - .resolve(styles) - .zip(regions.base) - .map(|(s, b)| s.map(|v| v.relative_to(b))) - .unwrap_or(regions.first); - - // Select the appropriate base and expansion for the child depending - // on whether it is automatically or relatively sized. - let is_auto = self.sizing.map_is_none(); - let base = is_auto.select(regions.base, size); - let expand = regions.expand | !is_auto; - - Regions::one(size, base, expand) - }; - - // Layout the child. - let mut frames = self.child.layout(ctx, &pod, styles)?; - - // Ensure frame size matches regions size if expansion is on. - let frame = &mut frames[0]; - let target = regions.expand.select(regions.first, frame.size); - Arc::make_mut(frame).resize(target, Align::LEFT_TOP); - - Ok(frames) - } -} - -/// Fill the frames resulting from a node. -#[derive(Debug, Hash)] -struct FillNode { - /// How to fill the frames resulting from the `child`. - fill: Paint, - /// The node to fill. - child: LayoutNode, -} - -impl Layout for FillNode { - fn layout( - &self, - ctx: &mut Context, - regions: &Regions, - styles: StyleChain, - ) -> TypResult<Vec<Arc<Frame>>> { - let mut frames = self.child.layout(ctx, regions, styles)?; - for frame in &mut frames { - let shape = Geometry::Rect(frame.size).filled(self.fill); - Arc::make_mut(frame).prepend(Point::zero(), Element::Shape(shape)); - } - Ok(frames) - } -} - -/// Stroke the frames resulting from a node. -#[derive(Debug, Hash)] -struct StrokeNode { - /// How to stroke the frames resulting from the `child`. - stroke: Stroke, - /// The node to stroke. - child: LayoutNode, -} - -impl Layout for StrokeNode { - fn layout( - &self, - ctx: &mut Context, - regions: &Regions, - styles: StyleChain, - ) -> TypResult<Vec<Arc<Frame>>> { - let mut frames = self.child.layout(ctx, regions, styles)?; - for frame in &mut frames { - let shape = Geometry::Rect(frame.size).stroked(self.stroke); - Arc::make_mut(frame).prepend(Point::zero(), Element::Shape(shape)); - } - Ok(frames) - } -} diff --git a/src/eval/mod.rs b/src/eval/mod.rs index f77efe47..2839baff 100644 --- a/src/eval/mod.rs +++ b/src/eval/mod.rs @@ -6,38 +6,28 @@ mod array; mod dict; #[macro_use] mod value; -#[macro_use] -mod styles; + mod args; mod capture; -mod collapse; -mod content; mod control; mod func; -mod layout; pub mod methods; mod module; pub mod ops; mod raw; mod scope; -mod show; mod str; pub use self::str::*; pub use args::*; pub use array::*; pub use capture::*; -pub use collapse::*; -pub use content::*; pub use control::*; pub use dict::*; pub use func::*; -pub use layout::*; pub use module::*; pub use raw::*; pub use scope::*; -pub use show::*; -pub use styles::*; pub use value::*; use std::collections::BTreeMap; @@ -48,6 +38,7 @@ use unicode_segmentation::UnicodeSegmentation; use crate::diag::{At, StrResult, Trace, Tracepoint, TypResult}; use crate::geom::{Angle, Em, Fraction, Length, Ratio}; use crate::library; +use crate::model::{Content, StyleMap}; use crate::syntax::ast::*; use crate::syntax::{Span, Spanned}; use crate::util::EcoString; diff --git a/src/eval/module.rs b/src/eval/module.rs index 4460caec..d2b4c520 100644 --- a/src/eval/module.rs +++ b/src/eval/module.rs @@ -1,4 +1,5 @@ -use super::{Content, Scope}; +use super::Scope; +use crate::model::Content; use crate::source::{SourceId, SourceStore}; /// An evaluated module, ready for importing or layouting. diff --git a/src/eval/ops.rs b/src/eval/ops.rs index 70352039..832bd354 100644 --- a/src/eval/ops.rs +++ b/src/eval/ops.rs @@ -5,6 +5,7 @@ use std::cmp::Ordering; use super::{Dynamic, RawAlign, RawStroke, Smart, StrExt, Value}; use crate::diag::StrResult; use crate::geom::{Numeric, Spec, SpecAxis}; +use crate::model; use Value::*; /// Bail with a type mismatch error. @@ -20,8 +21,8 @@ pub fn join(lhs: Value, rhs: Value) -> StrResult<Value> { (a, None) => a, (None, b) => b, (Str(a), Str(b)) => Str(a + b), - (Str(a), Content(b)) => Content(super::Content::Text(a) + b), - (Content(a), Str(b)) => Content(a + super::Content::Text(b)), + (Str(a), Content(b)) => Content(model::Content::Text(a) + b), + (Content(a), Str(b)) => Content(a + model::Content::Text(b)), (Content(a), Content(b)) => Content(a + b), (Array(a), Array(b)) => Array(a + b), (Dict(a), Dict(b)) => Dict(a + b), @@ -86,8 +87,8 @@ pub fn add(lhs: Value, rhs: Value) -> StrResult<Value> { (Content(a), None) => Content(a), (None, Content(b)) => Content(b), (Content(a), Content(b)) => Content(a + b), - (Content(a), Str(b)) => Content(a + super::Content::Text(b)), - (Str(a), Content(b)) => Content(super::Content::Text(a) + b), + (Content(a), Str(b)) => Content(a + model::Content::Text(b)), + (Str(a), Content(b)) => Content(model::Content::Text(a) + b), (Array(a), Array(b)) => Array(a + b), (Dict(a), Dict(b)) => Dict(a + b), diff --git a/src/eval/raw.rs b/src/eval/raw.rs index 6792c491..2d82fca8 100644 --- a/src/eval/raw.rs +++ b/src/eval/raw.rs @@ -2,11 +2,12 @@ use std::cmp::Ordering; use std::fmt::{self, Debug, Formatter}; use std::ops::{Add, Div, Mul, Neg}; -use super::{Fold, Resolve, Smart, StyleChain, Value}; +use super::{Smart, Value}; use crate::geom::{ Align, Em, Get, Length, Numeric, Paint, Relative, Spec, SpecAxis, Stroke, }; use crate::library::text::TextNode; +use crate::model::{Fold, Resolve, StyleChain}; /// The unresolved alignment representation. #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)] diff --git a/src/eval/show.rs b/src/eval/show.rs deleted file mode 100644 index c374c2df..00000000 --- a/src/eval/show.rs +++ /dev/null @@ -1,111 +0,0 @@ -use std::any::{Any, TypeId}; -use std::fmt::{self, Debug, Formatter}; -use std::hash::Hash; -use std::sync::Arc; - -use super::{Content, Dict, StyleChain}; -use crate::diag::TypResult; -use crate::util::Prehashed; -use crate::Context; - -/// A node that can be realized given some styles. -pub trait Show: 'static { - /// Encode this node into a dictionary. - fn encode(&self) -> Dict; - - /// The base recipe for this node that is executed if there is no - /// user-defined show rule. - fn realize(&self, ctx: &mut Context, styles: StyleChain) -> TypResult<Content>; - - /// Finalize this node given the realization of a base or user recipe. Use - /// this for effects that should work even in the face of a user-defined - /// show rule, for example: - /// - Application of general settable properties - /// - Attaching things like semantics to a heading - /// - /// Defaults to just the realized content. - #[allow(unused_variables)] - fn finalize( - &self, - ctx: &mut Context, - styles: StyleChain, - realized: Content, - ) -> TypResult<Content> { - Ok(realized) - } - - /// Convert to a packed show node. - fn pack(self) -> ShowNode - where - Self: Debug + Hash + Sized + Sync + Send + 'static, - { - ShowNode::new(self) - } -} - -/// A type-erased showable node with a precomputed hash. -#[derive(Clone, Hash)] -pub struct ShowNode(Arc<Prehashed<dyn Bounds>>); - -impl ShowNode { - /// Pack any showable node. - pub fn new<T>(node: T) -> Self - where - T: Show + Debug + Hash + Sync + Send + 'static, - { - Self(Arc::new(Prehashed::new(node))) - } - - /// The type id of this node. - pub fn id(&self) -> TypeId { - self.0.as_any().type_id() - } -} - -impl Show for ShowNode { - fn encode(&self) -> Dict { - self.0.encode() - } - - fn realize(&self, ctx: &mut Context, styles: StyleChain) -> TypResult<Content> { - self.0.realize(ctx, styles) - } - - fn finalize( - &self, - ctx: &mut Context, - styles: StyleChain, - realized: Content, - ) -> TypResult<Content> { - self.0.finalize(ctx, styles, realized) - } - - fn pack(self) -> ShowNode { - self - } -} - -impl Debug for ShowNode { - fn fmt(&self, f: &mut Formatter) -> fmt::Result { - self.0.fmt(f) - } -} - -impl PartialEq for ShowNode { - fn eq(&self, other: &Self) -> bool { - self.0.eq(&other.0) - } -} - -trait Bounds: Show + Debug + Sync + Send + 'static { - fn as_any(&self) -> &dyn Any; -} - -impl<T> Bounds for T -where - T: Show + Debug + Hash + Sync + Send + 'static, -{ - fn as_any(&self) -> &dyn Any { - self - } -} diff --git a/src/eval/styles.rs b/src/eval/styles.rs deleted file mode 100644 index b666c85d..00000000 --- a/src/eval/styles.rs +++ /dev/null @@ -1,829 +0,0 @@ -use std::any::{Any, TypeId}; -use std::fmt::{self, Debug, Formatter}; -use std::hash::Hash; -use std::marker::PhantomData; -use std::sync::Arc; - -use super::{Args, Content, Func, Layout, Node, Show, ShowNode, Smart, Span, Value}; -use crate::diag::{At, TypResult}; -use crate::geom::{Numeric, Relative, Sides, Spec}; -use crate::library::layout::PageNode; -use crate::library::text::{FontFamily, ParNode, TextNode}; -use crate::util::Prehashed; -use crate::Context; - -/// A map of style properties. -#[derive(Default, Clone, PartialEq, Hash)] -pub struct StyleMap(Vec<Entry>); - -impl StyleMap { - /// Create a new, empty style map. - pub fn new() -> Self { - Self::default() - } - - /// Whether this map contains no styles. - pub fn is_empty(&self) -> bool { - self.0.is_empty() - } - - /// Create a style map from a single property-value pair. - pub fn with<'a, K: Key<'a>>(key: K, value: K::Value) -> Self { - let mut styles = Self::new(); - styles.set(key, value); - styles - } - - /// Set an inner value for a style property. - /// - /// If the property needs folding and the value is already contained in the - /// style map, `self` contributes the outer values and `value` is the inner - /// one. - pub fn set<'a, K: Key<'a>>(&mut self, key: K, value: K::Value) { - self.0.push(Entry::Property(Property::new(key, value))); - } - - /// Set an inner value for a style property if it is `Some(_)`. - pub fn set_opt<'a, K: Key<'a>>(&mut self, key: K, value: Option<K::Value>) { - if let Some(value) = value { - self.set(key, value); - } - } - - /// Set a font family composed of a preferred family and existing families - /// from a style chain. - pub fn set_family(&mut self, preferred: FontFamily, existing: StyleChain) { - self.set( - TextNode::FAMILY, - std::iter::once(preferred) - .chain(existing.get(TextNode::FAMILY).iter().cloned()) - .collect(), - ); - } - - /// Set a show rule recipe for a node. - pub fn set_recipe<T: Node>(&mut self, func: Func, span: Span) { - self.0.push(Entry::Recipe(Recipe::new::<T>(func, span))); - } - - /// Whether the map contains a style property for the given key. - pub fn contains<'a, K: Key<'a>>(&self, _: K) -> bool { - self.0 - .iter() - .filter_map(|entry| entry.property()) - .any(|property| property.key == TypeId::of::<K>()) - } - - /// Make `self` the first link of the `tail` chain. - /// - /// The resulting style chain contains styles from `self` as well as - /// `tail`. The ones from `self` take precedence over the ones from - /// `tail`. For folded properties `self` contributes the inner value. - pub fn chain<'a>(&'a self, tail: &'a StyleChain<'a>) -> StyleChain<'a> { - if self.is_empty() { - *tail - } else { - StyleChain { head: &self.0, tail: Some(tail) } - } - } - - /// Set an outer value for a style property. - /// - /// If the property needs folding and the value is already contained in the - /// style map, `self` contributes the inner values and `value` is the outer - /// one. - /// - /// Like [`chain`](Self::chain) or [`apply_map`](Self::apply_map), but with - /// only a single property. - pub fn apply<'a, K: Key<'a>>(&mut self, key: K, value: K::Value) { - self.0.insert(0, Entry::Property(Property::new(key, value))); - } - - /// Apply styles from `tail` in-place. The resulting style map is equivalent - /// to the style chain created by `self.chain(StyleChain::new(tail))`. - /// - /// This is useful over `chain` when you want to combine two maps, but you - /// still need an owned map without a lifetime. - pub fn apply_map(&mut self, tail: &Self) { - self.0.splice(0 .. 0, tail.0.iter().cloned()); - } - - /// Mark all contained properties as _scoped_. This means that they only - /// apply to the first descendant node (of their type) in the hierarchy and - /// not its children, too. This is used by [constructors](Node::construct). - pub fn scoped(mut self) -> Self { - for entry in &mut self.0 { - if let Entry::Property(property) = entry { - property.scoped = true; - } - } - self - } - - /// The highest-level kind of of structure the map interrupts. - pub fn interruption(&self) -> Option<Interruption> { - self.0 - .iter() - .filter_map(|entry| entry.property()) - .filter_map(|property| property.interruption()) - .max() - } -} - -impl Debug for StyleMap { - fn fmt(&self, f: &mut Formatter) -> fmt::Result { - for entry in self.0.iter().rev() { - writeln!(f, "{:?}", entry)?; - } - Ok(()) - } -} - -/// An entry for a single style property, recipe or barrier. -#[derive(Clone, PartialEq, Hash)] -enum Entry { - /// A style property originating from a set rule or constructor. - Property(Property), - /// A barrier for scoped styles. - Barrier(TypeId, &'static str), - /// A show rule recipe. - Recipe(Recipe), -} - -impl Entry { - /// If this is a property, return it. - fn property(&self) -> Option<&Property> { - match self { - Self::Property(property) => Some(property), - _ => None, - } - } - - /// If this is a recipe, return it. - fn recipe(&self) -> Option<&Recipe> { - match self { - Self::Recipe(recipe) => Some(recipe), - _ => None, - } - } -} - -impl Debug for Entry { - fn fmt(&self, f: &mut Formatter) -> fmt::Result { - f.write_str("#[")?; - match self { - Self::Property(property) => property.fmt(f)?, - Self::Recipe(recipe) => recipe.fmt(f)?, - Self::Barrier(_, name) => write!(f, "Barrier for {name}")?, - } - f.write_str("]") - } -} - -/// A style property originating from a set rule or constructor. -#[derive(Clone, Hash)] -struct Property { - /// The type id of the property's [key](Key). - key: TypeId, - /// The type id of the node the property belongs to. - node: TypeId, - /// The name of the property. - name: &'static str, - /// The property's value. - value: Arc<Prehashed<dyn Bounds>>, - /// Whether the property should only affects the first node down the - /// hierarchy. Used by constructors. - scoped: bool, -} - -impl Property { - /// Create a new property from a key-value pair. - fn new<'a, K: Key<'a>>(_: K, value: K::Value) -> Self { - Self { - key: TypeId::of::<K>(), - node: K::node(), - name: K::NAME, - value: Arc::new(Prehashed::new(value)), - scoped: false, - } - } - - /// What kind of structure the property interrupts. - fn interruption(&self) -> Option<Interruption> { - if self.is_of::<PageNode>() { - Some(Interruption::Page) - } else if self.is_of::<ParNode>() { - Some(Interruption::Par) - } else { - None - } - } - - /// Access the property's value if it is of the given key. - fn downcast<'a, K: Key<'a>>(&'a self) -> Option<&'a K::Value> { - if self.key == TypeId::of::<K>() { - (**self.value).as_any().downcast_ref() - } else { - None - } - } - - /// Whether this property belongs to the node `T`. - fn is_of<T: Node>(&self) -> bool { - self.node == TypeId::of::<T>() - } -} - -impl Debug for Property { - fn fmt(&self, f: &mut Formatter) -> fmt::Result { - write!(f, "{} = {:?}", self.name, self.value)?; - if self.scoped { - write!(f, " [scoped]")?; - } - Ok(()) - } -} - -impl PartialEq for Property { - fn eq(&self, other: &Self) -> bool { - self.key == other.key - && self.value.eq(&other.value) - && self.scoped == other.scoped - } -} - -trait Bounds: Debug + Sync + Send + 'static { - fn as_any(&self) -> &dyn Any; -} - -impl<T> Bounds for T -where - T: Debug + Sync + Send + 'static, -{ - fn as_any(&self) -> &dyn Any { - self - } -} - -/// Style property keys. -/// -/// This trait is not intended to be implemented manually, but rather through -/// the `#[node]` proc-macro. -pub trait Key<'a>: Copy + 'static { - /// The unfolded type which this property is stored as in a style map. For - /// example, this is [`Toggle`](crate::geom::Length) for the - /// [`STRONG`](TextNode::STRONG) property. - type Value: Debug + Clone + Hash + Sync + Send + 'static; - - /// The folded type of value that is returned when reading this property - /// from a style chain. For example, this is [`bool`] for the - /// [`STRONG`](TextNode::STRONG) property. For non-copy, non-folding - /// properties this is a reference type. - type Output; - - /// The name of the property, used for debug printing. - const NAME: &'static str; - - /// The type id of the node this property belongs to. - fn node() -> TypeId; - - /// Compute an output value from a sequence of values belong to this key, - /// folding if necessary. - fn get( - chain: StyleChain<'a>, - values: impl Iterator<Item = &'a Self::Value>, - ) -> Self::Output; -} - -/// A property that is resolved with other properties from the style chain. -pub trait Resolve { - /// The type of the resolved output. - type Output; - - /// Resolve the value using the style chain. - fn resolve(self, styles: StyleChain) -> Self::Output; -} - -impl<T: Resolve> Resolve for Option<T> { - type Output = Option<T::Output>; - - fn resolve(self, styles: StyleChain) -> Self::Output { - self.map(|v| v.resolve(styles)) - } -} - -impl<T: Resolve> Resolve for Smart<T> { - type Output = Smart<T::Output>; - - fn resolve(self, styles: StyleChain) -> Self::Output { - self.map(|v| v.resolve(styles)) - } -} - -impl<T: Resolve> Resolve for Spec<T> { - type Output = Spec<T::Output>; - - fn resolve(self, styles: StyleChain) -> Self::Output { - self.map(|v| v.resolve(styles)) - } -} - -impl<T: Resolve> Resolve for Sides<T> { - type Output = Sides<T::Output>; - - fn resolve(self, styles: StyleChain) -> Self::Output { - Sides { - left: self.left.resolve(styles), - right: self.right.resolve(styles), - top: self.top.resolve(styles), - bottom: self.bottom.resolve(styles), - } - } -} - -impl<T> Resolve for Relative<T> -where - T: Resolve + Numeric, - <T as Resolve>::Output: Numeric, -{ - type Output = Relative<<T as Resolve>::Output>; - - fn resolve(self, styles: StyleChain) -> Self::Output { - self.map(|abs| abs.resolve(styles)) - } -} - -/// A property that is folded to determine its final value. -pub trait Fold { - /// The type of the folded output. - type Output; - - /// Fold this inner value with an outer folded value. - fn fold(self, outer: Self::Output) -> Self::Output; -} - -impl<T> Fold for Option<T> -where - T: Fold, - T::Output: Default, -{ - type Output = Option<T::Output>; - - fn fold(self, outer: Self::Output) -> Self::Output { - self.map(|inner| inner.fold(outer.unwrap_or_default())) - } -} - -impl<T> Fold for Smart<T> -where - T: Fold, - T::Output: Default, -{ - type Output = Smart<T::Output>; - - fn fold(self, outer: Self::Output) -> Self::Output { - self.map(|inner| inner.fold(outer.unwrap_or_default())) - } -} - -/// A show rule recipe. -#[derive(Clone, PartialEq, Hash)] -struct Recipe { - /// The affected node. - node: TypeId, - /// The name of the affected node. - name: &'static str, - /// The function that defines the recipe. - func: Func, - /// The span to report all erros with. - span: Span, -} - -impl Recipe { - /// Create a new recipe for the node `T`. - fn new<T: Node>(func: Func, span: Span) -> Self { - Self { - node: TypeId::of::<T>(), - name: std::any::type_name::<T>(), - func, - span, - } - } -} - -impl Debug for Recipe { - fn fmt(&self, f: &mut Formatter) -> fmt::Result { - write!(f, "Recipe for {} from {:?}", self.name, self.span) - } -} - -/// A style chain barrier. -/// -/// Barriers interact with [scoped](StyleMap::scoped) styles: A scoped style -/// can still be read through a single barrier (the one of the node it -/// _should_ apply to), but a second barrier will make it invisible. -#[derive(Clone, PartialEq, Hash)] -pub struct Barrier(Entry); - -impl Barrier { - /// Create a new barrier for the layout node `T`. - pub fn new<T: Layout>() -> Self { - Self(Entry::Barrier( - TypeId::of::<T>(), - std::any::type_name::<T>(), - )) - } - - /// Make this barrier the first link of the `tail` chain. - pub fn chain<'a>(&'a self, tail: &'a StyleChain) -> StyleChain<'a> { - // We have to store a full `Entry` enum inside the barrier because - // otherwise the `slice::from_ref` trick below won't work. - // Unfortunately, that also means we have to somehow extract the id - // here. - let id = match self.0 { - Entry::Barrier(id, _) => id, - _ => unreachable!(), - }; - - if tail - .entries() - .filter_map(Entry::property) - .any(|p| p.scoped && p.node == id) - { - StyleChain { - head: std::slice::from_ref(&self.0), - tail: Some(tail), - } - } else { - *tail - } - } -} - -impl Debug for Barrier { - fn fmt(&self, f: &mut Formatter) -> fmt::Result { - self.0.fmt(f) - } -} - -/// Determines whether a style could interrupt some composable structure. -#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)] -pub enum Interruption { - /// The style forces a paragraph break. - Par, - /// The style forces a page break. - Page, -} - -/// A chain of style maps, similar to a linked list. -/// -/// A style chain allows to combine properties from multiple style maps in a -/// node hierarchy in a non-allocating way. Rather than eagerly merging the -/// maps, each access walks the hierarchy from the innermost to the outermost -/// map, trying to find a match and then folding it with matches further up the -/// chain. -#[derive(Default, Clone, Copy, Hash)] -pub struct StyleChain<'a> { - /// The first link of this chain. - head: &'a [Entry], - /// The remaining links in the chain. - tail: Option<&'a Self>, -} - -impl<'a> StyleChain<'a> { - /// Create a new, empty style chain. - pub fn new() -> Self { - Self::default() - } - - /// Start a new style chain with a root map. - pub fn with_root(root: &'a StyleMap) -> Self { - Self { head: &root.0, tail: None } - } - - /// Get the output value of a style property. - /// - /// Returns the property's default value if no map in the chain contains an - /// entry for it. Also takes care of resolving and folding and returns - /// references where applicable. - pub fn get<K: Key<'a>>(self, key: K) -> K::Output { - K::get(self, self.values(key)) - } - - /// Realize a node with a user recipe. - pub fn realize( - self, - ctx: &mut Context, - node: &ShowNode, - ) -> TypResult<Option<Content>> { - let id = node.id(); - if let Some(recipe) = self - .entries() - .filter_map(Entry::recipe) - .find(|recipe| recipe.node == id) - { - let dict = node.encode(); - let args = Args::from_values(recipe.span, [Value::Dict(dict)]); - Ok(Some(recipe.func.call(ctx, args)?.cast().at(recipe.span)?)) - } else { - Ok(None) - } - } -} - -impl<'a> StyleChain<'a> { - /// Return the chain, but without the trailing scoped property for the given - /// `node`. This is a 90% hack fix for show node constructor scoping. - pub(super) fn unscoped(mut self, node: TypeId) -> Self { - while self - .head - .last() - .and_then(Entry::property) - .map_or(false, |p| p.scoped && p.node == node) - { - let len = self.head.len(); - self.head = &self.head[.. len - 1] - } - self - } - - /// Remove the last link from the chain. - fn pop(&mut self) { - *self = self.tail.copied().unwrap_or_default(); - } - - /// Build a style map from the suffix (all links beyond the `len`) of the - /// chain. - fn suffix(self, len: usize) -> StyleMap { - let mut suffix = StyleMap::new(); - let take = self.links().count().saturating_sub(len); - for link in self.links().take(take) { - suffix.0.splice(0 .. 0, link.iter().cloned()); - } - suffix - } - - /// Iterate over all values for the given property in the chain. - fn values<K: Key<'a>>(self, _: K) -> Values<'a, K> { - Values { - entries: self.entries(), - depth: 0, - key: PhantomData, - } - } - - /// Iterate over the entries of the chain. - fn entries(self) -> Entries<'a> { - Entries { - inner: [].as_slice().iter(), - links: self.links(), - } - } - - /// Iterate over the links of the chain. - fn links(self) -> Links<'a> { - Links(Some(self)) - } -} - -impl Debug for StyleChain<'_> { - fn fmt(&self, f: &mut Formatter) -> fmt::Result { - for entry in self.entries() { - writeln!(f, "{:?}", entry)?; - } - Ok(()) - } -} - -impl PartialEq for StyleChain<'_> { - fn eq(&self, other: &Self) -> bool { - let as_ptr = |s| s as *const _; - self.head.as_ptr() == other.head.as_ptr() - && self.head.len() == other.head.len() - && self.tail.map(as_ptr) == other.tail.map(as_ptr) - } -} - -/// An iterator over the values in a style chain. -struct Values<'a, K> { - entries: Entries<'a>, - depth: usize, - key: PhantomData<K>, -} - -impl<'a, K: Key<'a>> Iterator for Values<'a, K> { - type Item = &'a K::Value; - - fn next(&mut self) -> Option<Self::Item> { - while let Some(entry) = self.entries.next() { - match entry { - Entry::Property(property) => { - if let Some(value) = property.downcast::<K>() { - if !property.scoped || self.depth <= 1 { - return Some(value); - } - } - } - Entry::Barrier(id, _) => { - self.depth += (*id == K::node()) as usize; - } - Entry::Recipe(_) => {} - } - } - - None - } -} - -/// An iterator over the entries in a style chain. -struct Entries<'a> { - inner: std::slice::Iter<'a, Entry>, - links: Links<'a>, -} - -impl<'a> Iterator for Entries<'a> { - type Item = &'a Entry; - - fn next(&mut self) -> Option<Self::Item> { - loop { - if let Some(entry) = self.inner.next_back() { - return Some(entry); - } - - match self.links.next() { - Some(next) => self.inner = next.iter(), - None => return None, - } - } - } -} - -/// An iterator over the links of a style chain. -struct Links<'a>(Option<StyleChain<'a>>); - -impl<'a> Iterator for Links<'a> { - type Item = &'a [Entry]; - - fn next(&mut self) -> Option<Self::Item> { - let StyleChain { head, tail } = self.0?; - self.0 = tail.copied(); - Some(head) - } -} - -/// A sequence of items with associated styles. -#[derive(Hash)] -pub struct StyleVec<T> { - items: Vec<T>, - maps: Vec<(StyleMap, usize)>, -} - -impl<T> StyleVec<T> { - /// Whether there are any items in the sequence. - pub fn is_empty(&self) -> bool { - self.items.is_empty() - } - - /// Number of items in the sequence. - pub fn len(&self) -> usize { - self.items.len() - } - - /// Iterate over the contained maps. Note that zipping this with `items()` - /// does not yield the same result as calling `iter()` because this method - /// only returns maps once that are shared by consecutive items. This method - /// is designed for use cases where you want to check, for example, whether - /// any of the maps fulfills a specific property. - pub fn maps(&self) -> impl Iterator<Item = &StyleMap> { - self.maps.iter().map(|(map, _)| map) - } - - /// Iterate over the contained items. - pub fn items(&self) -> std::slice::Iter<'_, T> { - self.items.iter() - } - - /// Iterate over the contained items and associated style maps. - pub fn iter(&self) -> impl Iterator<Item = (&T, &StyleMap)> + '_ { - let styles = self - .maps - .iter() - .flat_map(|(map, count)| std::iter::repeat(map).take(*count)); - self.items().zip(styles) - } - - /// Insert an element in the front. The element will share the style of the - /// current first element. - /// - /// This method has no effect if the vector is empty. - pub fn push_front(&mut self, item: T) { - if !self.maps.is_empty() { - self.items.insert(0, item); - self.maps[0].1 += 1; - } - } -} - -impl<T> Default for StyleVec<T> { - fn default() -> Self { - Self { items: vec![], maps: vec![] } - } -} - -impl<T: Debug> Debug for StyleVec<T> { - fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result { - f.debug_list() - .entries(self.iter().map(|(item, map)| { - crate::util::debug(|f| { - map.fmt(f)?; - item.fmt(f) - }) - })) - .finish() - } -} - -/// Assists in the construction of a [`StyleVec`]. -pub struct StyleVecBuilder<'a, T> { - items: Vec<T>, - chains: Vec<(StyleChain<'a>, usize)>, -} - -impl<'a, T> StyleVecBuilder<'a, T> { - /// Create a new style-vec builder. - pub fn new() -> Self { - Self { items: vec![], chains: vec![] } - } - - /// Push a new item into the style vector. - pub fn push(&mut self, item: T, styles: StyleChain<'a>) { - self.items.push(item); - - if let Some((prev, count)) = self.chains.last_mut() { - if *prev == styles { - *count += 1; - return; - } - } - - self.chains.push((styles, 1)); - } - - /// Access the last item mutably and its chain by value. - pub fn last_mut(&mut self) -> Option<(&mut T, StyleChain<'a>)> { - let item = self.items.last_mut()?; - let chain = self.chains.last()?.0; - Some((item, chain)) - } - - /// Iterate over the contained items. - pub fn items(&self) -> std::slice::Iter<'_, T> { - self.items.iter() - } - - /// Finish building, returning a pair of two things: - /// - a style vector of items with the non-shared styles - /// - a shared prefix chain of styles that apply to all items - pub fn finish(self) -> (StyleVec<T>, StyleChain<'a>) { - let mut iter = self.chains.iter(); - let mut trunk = match iter.next() { - Some(&(chain, _)) => chain, - None => return Default::default(), - }; - - let mut shared = trunk.links().count(); - for &(mut chain, _) in iter { - let len = chain.links().count(); - if len < shared { - for _ in 0 .. shared - len { - trunk.pop(); - } - shared = len; - } else if len > shared { - for _ in 0 .. len - shared { - chain.pop(); - } - } - - while shared > 0 && chain != trunk { - trunk.pop(); - chain.pop(); - shared -= 1; - } - } - - let maps = self - .chains - .into_iter() - .map(|(chain, count)| (chain.suffix(shared), count)) - .collect(); - - (StyleVec { items: self.items, maps }, trunk) - } -} - -impl<'a, T> Default for StyleVecBuilder<'a, T> { - fn default() -> Self { - Self::new() - } -} diff --git a/src/eval/value.rs b/src/eval/value.rs index 2ef26059..31287fa8 100644 --- a/src/eval/value.rs +++ b/src/eval/value.rs @@ -5,12 +5,13 @@ use std::hash::{Hash, Hasher}; use std::num::NonZeroUsize; use std::sync::Arc; -use super::{ops, Args, Array, Content, Dict, Func, Layout, LayoutNode, RawLength}; +use super::{ops, Args, Array, Dict, Func, RawLength}; use crate::diag::{with_alternative, StrResult}; use crate::geom::{ Angle, Color, Dir, Em, Fraction, Length, Paint, Ratio, Relative, RgbaColor, }; use crate::library::text::RawNode; +use crate::model::{Content, Layout, LayoutNode}; use crate::syntax::Spanned; use crate::util::EcoString; |