caisin/typst
1
0
Fork 0
mirror of https://github.com/typst/typst synced 2025-05-13 20:46:23 +08:00
Code Issues Packages Projects Releases Wiki Activity

Set rules for everything

Browse Source
This commit is contained in:
Laurenz 2022-02-08 16:39:37 +01:00
parent 68503b9a07
commit e089b6ea40
40 changed files with 1034 additions and 732 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

92
macros/src/lib.rs
View File

@ -5,7 +5,7 @@ use proc_macro2::TokenStream as TokenStream2;
use quote::quote; use quote::quote;
use syn::parse_quote; use syn::parse_quote;
use syn::spanned::Spanned; use syn::spanned::Spanned;
use syn::{Error, Result}; use syn::{Error, Ident, Result};
/// Turn a node into a class. /// Turn a node into a class.
#[proc_macro_attribute] #[proc_macro_attribute]
@ -24,15 +24,17 @@ fn expand(mut impl_block: syn::ItemImpl) -> Result<TokenStream2> {
let module = quote::format_ident!("{}_types", self_name); let module = quote::format_ident!("{}_types", self_name);
let mut key_modules = vec![]; let mut key_modules = vec![];
let mut properties = vec![];
let mut construct = None; let mut construct = None;
let mut set = None; let mut set = None;
for item in std::mem::take(&mut impl_block.items) { for item in std::mem::take(&mut impl_block.items) {
match item { match item {
syn::ImplItem::Const(mut item) => { syn::ImplItem::Const(mut item) => {
key_modules.push(process_const( let (property, module) =
&mut item, params, self_ty, &self_name, &self_args, process_const(&mut item, params, self_ty, &self_name, &self_args)?;
)?); properties.push(property);
key_modules.push(module);
impl_block.items.push(syn::ImplItem::Const(item)); impl_block.items.push(syn::ImplItem::Const(item));
} }
syn::ImplItem::Method(method) => { syn::ImplItem::Method(method) => {
@ -49,17 +51,34 @@ fn expand(mut impl_block: syn::ItemImpl) -> Result<TokenStream2> {
let construct = let construct =
construct.ok_or_else(|| Error::new(impl_block.span(), "missing constructor"))?; construct.ok_or_else(|| Error::new(impl_block.span(), "missing constructor"))?;
let set = if impl_block.items.is_empty() { let set = set.unwrap_or_else(|| {
set.unwrap_or_else(|| { let sets = properties.into_iter().filter(|p| !p.skip).map(|property| {
parse_quote! { let name = property.name;
fn set(_: &mut Args, _: &mut StyleMap) -> TypResult<()> { let string = name.to_string().replace("_", "-").to_lowercase();
Ok(())
let alternative = if property.variadic {
quote! {
.or_else(|| {
let list: Vec<_> = args.all().collect();
(!list.is_empty()).then(|| list)
})
} }
} else if property.shorthand {
quote! { .or_else(|| args.find()) }
} else {
quote! {}
};
quote! { styles.set_opt(Self::#name, args.named(#string)? #alternative); }
});
parse_quote! {
fn set(args: &mut Args, styles: &mut StyleMap) -> TypResult<()> {
#(#sets)*
Ok(())
} }
}) }
} else { });
set.ok_or_else(|| Error::new(impl_block.span(), "missing set method"))?
};
// Put everything into a module with a hopefully unique type to isolate // Put everything into a module with a hopefully unique type to isolate
// it from the outside. // it from the outside.
@ -87,6 +106,14 @@ fn expand(mut impl_block: syn::ItemImpl) -> Result<TokenStream2> {
}) })
} }
/// A style property.
struct Property {
name: Ident,
shorthand: bool,
variadic: bool,
skip: bool,
}
/// Parse the name and generic type arguments of the node type. /// Parse the name and generic type arguments of the node type.
fn parse_self(self_ty: &syn::Type) -> Result<(String, Vec<&syn::Type>)> { fn parse_self(self_ty: &syn::Type) -> Result<(String, Vec<&syn::Type>)> {
// Extract the node type for which we want to generate properties. // Extract the node type for which we want to generate properties.
@ -120,7 +147,7 @@ fn process_const(
self_ty: &syn::Type, self_ty: &syn::Type,
self_name: &str, self_name: &str,
self_args: &[&syn::Type], self_args: &[&syn::Type],
) -> Result<syn::ItemMod> { ) -> Result<(Property, syn::ItemMod)> {
// The module that will contain the `Key` type. // The module that will contain the `Key` type.
let module_name = &item.ident; let module_name = &item.ident;
@ -139,13 +166,16 @@ fn process_const(
let default = &item.expr; let default = &item.expr;
let mut folder = None; let mut folder = None;
let mut nonfolding = Some(quote! { let mut property = Property {
impl<#params> Nonfolding for Key<#key_args> {} name: item.ident.clone(),
}); shorthand: false,
variadic: false,
skip: false,
};
// Look for a folding function like `#[fold(u64::add)]`. for attr in std::mem::take(&mut item.attrs) {
for attr in &item.attrs {
if attr.path.is_ident("fold") { if attr.path.is_ident("fold") {
// Look for a folding function like `#[fold(u64::add)]`.
let func: syn::Expr = attr.parse_args()?; let func: syn::Expr = attr.parse_args()?;
folder = Some(quote! { folder = Some(quote! {
const FOLDING: bool = true; const FOLDING: bool = true;
@ -155,10 +185,30 @@ fn process_const(
f(inner, outer) f(inner, outer)
} }
}); });
nonfolding = None; } else if attr.path.is_ident("shorthand") {
property.shorthand = true;
} else if attr.path.is_ident("variadic") {
property.variadic = true;
} else if attr.path.is_ident("skip") {
property.skip = true;
} else {
item.attrs.push(attr);
} }
} }
if property.shorthand && property.variadic {
return Err(Error::new(
property.name.span(),
"shorthand and variadic are mutually exclusive",
));
}
let nonfolding = folder.is_none().then(|| {
quote! {
impl<#params> Nonfolding for Key<#key_args> {}
}
});
// Generate the module code. // Generate the module code.
let module = parse_quote! { let module = parse_quote! {
#[allow(non_snake_case)] #[allow(non_snake_case)]
@ -204,5 +254,5 @@ fn process_const(
item.ty = parse_quote! { #module_name::Key<#key_args> }; item.ty = parse_quote! { #module_name::Key<#key_args> };
item.expr = parse_quote! { #module_name::Key(PhantomData) }; item.expr = parse_quote! { #module_name::Key(PhantomData) };
Ok(module) Ok((property, module))
} }

26
src/eval/collapse.rs
View File

@ -3,7 +3,7 @@ use super::{StyleChain, StyleVec, StyleVecBuilder};
/// A wrapper around a [`StyleVecBuilder`] that allows to collapse items. /// A wrapper around a [`StyleVecBuilder`] that allows to collapse items.
pub struct CollapsingBuilder<'a, T> { pub struct CollapsingBuilder<'a, T> {
builder: StyleVecBuilder<'a, T>, builder: StyleVecBuilder<'a, T>,
staged: Vec<(T, StyleChain<'a>, bool)>, staged: Vec<(T, StyleChain<'a>, Option<u8>)>,
last: Last, last: Last,
} }
@ -29,9 +29,21 @@ impl<'a, T: Merge> CollapsingBuilder<'a, T> {
/// and to its right, with no destructive items or weak items in between to /// 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 /// its left and no destructive items in between to its right. There may be
/// ignorant items in between in both directions. /// ignorant items in between in both directions.
pub fn weak(&mut self, item: T, styles: StyleChain<'a>) { pub fn weak(&mut self, item: T, strength: u8, styles: StyleChain<'a>) {
if self.last == Last::Supportive { if self.last != Last::Destructive {
self.staged.push((item, styles, true)); 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; self.last = Last::Weak;
} }
} }
@ -52,7 +64,7 @@ impl<'a, T: Merge> CollapsingBuilder<'a, T> {
/// Has no influence on other items. /// Has no influence on other items.
pub fn ignorant(&mut self, item: T, styles: StyleChain<'a>) { pub fn ignorant(&mut self, item: T, styles: StyleChain<'a>) {
self.staged.push((item, styles, false)); self.staged.push((item, styles, None));
} }
/// Return the finish style vec and the common prefix chain. /// Return the finish style vec and the common prefix chain.
@ -63,8 +75,8 @@ impl<'a, T: Merge> CollapsingBuilder<'a, T> {
/// Push the staged items, filtering out weak items if `supportive` is false. /// Push the staged items, filtering out weak items if `supportive` is false.
fn flush(&mut self, supportive: bool) { fn flush(&mut self, supportive: bool) {
for (item, styles, weak) in self.staged.drain(..) { for (item, styles, strength) in self.staged.drain(..) {
if !weak || supportive { if supportive || strength.is_none() {
push_merging(&mut self.builder, item, styles); push_merging(&mut self.builder, item, styles);
} }
} }

150
src/eval/mod.rs
View File

@ -14,6 +14,7 @@ mod collapse;
mod func; mod func;
mod ops; mod ops;
mod scope; mod scope;
mod show;
mod template; mod template;
pub use array::*; pub use array::*;
@ -23,6 +24,7 @@ pub use collapse::*;
pub use dict::*; pub use dict::*;
pub use func::*; pub use func::*;
pub use scope::*; pub use scope::*;
pub use show::*;
pub use styles::*; pub use styles::*;
pub use template::*; pub use template::*;
pub use value::*; pub use value::*;
@ -33,34 +35,23 @@ use std::io;
use std::mem; use std::mem;
use std::path::PathBuf; use std::path::PathBuf;
use once_cell::sync::Lazy;
use syntect::easy::HighlightLines;
use syntect::highlighting::{FontStyle, Highlighter, Style as SynStyle, Theme, ThemeSet};
use syntect::parsing::SyntaxSet;
use unicode_segmentation::UnicodeSegmentation; use unicode_segmentation::UnicodeSegmentation;
use crate::diag::{At, Error, StrResult, Trace, Tracepoint, TypResult}; use crate::diag::{At, Error, StrResult, Trace, Tracepoint, TypResult};
use crate::geom::{Angle, Color, Fractional, Length, Paint, Relative}; use crate::geom::{Angle, Fractional, Length, Relative};
use crate::image::ImageStore; use crate::image::ImageStore;
use crate::layout::Layout; use crate::layout::Layout;
use crate::library::{self, DecoLine, TextNode}; use crate::library::{self};
use crate::loading::Loader; use crate::loading::Loader;
use crate::parse;
use crate::source::{SourceId, SourceStore}; use crate::source::{SourceId, SourceStore};
use crate::syntax;
use crate::syntax::ast::*; use crate::syntax::ast::*;
use crate::syntax::{RedNode, Span, Spanned}; use crate::syntax::{Span, Spanned};
use crate::util::{EcoString, RefMutExt}; use crate::util::{EcoString, RefMutExt};
use crate::Context; use crate::Context;
static THEME: Lazy<Theme> =
Lazy::new(|| ThemeSet::load_defaults().themes.remove("InspiredGitHub").unwrap());
static SYNTAXES: Lazy<SyntaxSet> = Lazy::new(|| SyntaxSet::load_defaults_newlines());
/// An evaluated module, ready for importing or conversion to a root layout /// An evaluated module, ready for importing or conversion to a root layout
/// tree. /// tree.
#[derive(Debug, Default, Clone)] #[derive(Debug, Clone)]
pub struct Module { pub struct Module {
/// The top-level definitions that were bound in this module. /// The top-level definitions that were bound in this module.
pub scope: Scope, pub scope: Scope,
@ -194,17 +185,13 @@ fn eval_markup(
MarkupNode::Expr(Expr::Wrap(wrap)) => { MarkupNode::Expr(Expr::Wrap(wrap)) => {
let tail = eval_markup(ctx, nodes)?; let tail = eval_markup(ctx, nodes)?;
ctx.scopes.def_mut(wrap.binding().take(), tail); ctx.scopes.def_mut(wrap.binding().take(), tail);
wrap.body().eval(ctx)?.show() wrap.body().eval(ctx)?.display()
} }
_ => node.eval(ctx)?, _ => node.eval(ctx)?,
}); });
} }
if seq.len() == 1 { Ok(Template::sequence(seq))
Ok(seq.into_iter().next().unwrap())
} else {
Ok(Template::Sequence(seq))
}
} }
impl Eval for MarkupNode { impl Eval for MarkupNode {
@ -223,7 +210,7 @@ impl Eval for MarkupNode {
Self::Heading(heading) => heading.eval(ctx)?, Self::Heading(heading) => heading.eval(ctx)?,
Self::List(list) => list.eval(ctx)?, Self::List(list) => list.eval(ctx)?,
Self::Enum(enum_) => enum_.eval(ctx)?, Self::Enum(enum_) => enum_.eval(ctx)?,
Self::Expr(expr) => expr.eval(ctx)?.show(), Self::Expr(expr) => expr.eval(ctx)?.display(),
}) })
} }
} }
@ -232,7 +219,7 @@ impl Eval for StrongNode {
type Output = Template; type Output = Template;
fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> { fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
Ok(self.body().eval(ctx)?.styled(TextNode::STRONG, true)) Ok(Template::show(library::StrongNode(self.body().eval(ctx)?)))
} }
} }
@ -240,7 +227,7 @@ impl Eval for EmphNode {
type Output = Template; type Output = Template;
fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> { fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
Ok(self.body().eval(ctx)?.styled(TextNode::EMPH, true)) Ok(Template::show(library::EmphNode(self.body().eval(ctx)?)))
} }
} }
@ -248,104 +235,25 @@ impl Eval for RawNode {
type Output = Template; type Output = Template;
fn eval(&self, _: &mut EvalContext) -> TypResult<Self::Output> { fn eval(&self, _: &mut EvalContext) -> TypResult<Self::Output> {
let code = self.highlighted(); let template = Template::show(library::RawNode {
Ok(if self.block { Template::Block(code.pack()) } else { code }) text: self.text.clone(),
block: self.block,
});
Ok(match self.lang {
Some(_) => template.styled(library::RawNode::LANG, self.lang.clone()),
None => template,
})
} }
} }
impl RawNode {
/// Styled template for a code block, with optional syntax highlighting.
pub fn highlighted(&self) -> Template {
let mut seq: Vec<Template> = vec![];
let syntax = if let Some(syntax) = self
.lang
.as_ref()
.and_then(|token| SYNTAXES.find_syntax_by_token(&token))
{
Some(syntax)
} else if matches!(
self.lang.as_ref().map(|s| s.to_ascii_lowercase()).as_deref(),
Some("typ" | "typst")
) {
None
} else {
return Template::Text(self.text.clone()).monospaced();
};
let foreground = THEME
.settings
.foreground
.map(Color::from)
.unwrap_or(Color::BLACK)
.into();
match syntax {
Some(syntax) => {
let mut highlighter = HighlightLines::new(syntax, &THEME);
for (i, line) in self.text.lines().enumerate() {
if i != 0 {
seq.push(Template::Linebreak);
}
for (style, piece) in highlighter.highlight(line, &SYNTAXES) {
seq.push(style_piece(piece, foreground, style));
}
}
}
None => {
let green = parse::parse(&self.text);
let red = RedNode::from_root(green, SourceId::from_raw(0));
let highlighter = Highlighter::new(&THEME);
syntax::highlight_syntect(
red.as_ref(),
&highlighter,
&mut |range, style| {
seq.push(style_piece(&self.text[range], foreground, style));
},
)
}
}
Template::Sequence(seq).monospaced()
}
}
/// Style a piece of text with a syntect style.
fn style_piece(piece: &str, foreground: Paint, style: SynStyle) -> Template {
let mut styles = StyleMap::new();
let paint = style.foreground.into();
if paint != foreground {
styles.set(TextNode::FILL, paint);
}
if style.font_style.contains(FontStyle::BOLD) {
styles.set(TextNode::STRONG, true);
}
if style.font_style.contains(FontStyle::ITALIC) {
styles.set(TextNode::EMPH, true);
}
if style.font_style.contains(FontStyle::UNDERLINE) {
styles.set(TextNode::LINES, vec![DecoLine::Underline.into()]);
}
Template::Text(piece.into()).styled_with_map(styles)
}
impl Eval for MathNode { impl Eval for MathNode {
type Output = Template; type Output = Template;
fn eval(&self, _: &mut EvalContext) -> TypResult<Self::Output> { fn eval(&self, _: &mut EvalContext) -> TypResult<Self::Output> {
let text = Template::Text(self.formula.trim().into()).monospaced(); Ok(Template::show(library::MathNode {
Ok(if self.display { formula: self.formula.clone(),
Template::Block(text.pack()) display: self.display,
} else { }))
text
})
} }
} }
@ -353,8 +261,8 @@ impl Eval for HeadingNode {
type Output = Template; type Output = Template;
fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> { fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
Ok(Template::block(library::HeadingNode { Ok(Template::show(library::HeadingNode {
child: self.body().eval(ctx)?.pack(), body: self.body().eval(ctx)?,
level: self.level(), level: self.level(),
})) }))
} }
@ -364,9 +272,9 @@ impl Eval for ListNode {
type Output = Template; type Output = Template;
fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> { fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
Ok(Template::block(library::ListNode { Ok(Template::show(library::ListNode {
child: self.body().eval(ctx)?.pack(), child: self.body().eval(ctx)?.pack(),
kind: library::Unordered, label: library::Unordered,
})) }))
} }
} }
@ -375,9 +283,9 @@ impl Eval for EnumNode {
type Output = Template; type Output = Template;
fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> { fn eval(&self, ctx: &mut EvalContext) -> TypResult<Self::Output> {
Ok(Template::block(library::ListNode { Ok(Template::show(library::ListNode {
child: self.body().eval(ctx)?.pack(), child: self.body().eval(ctx)?.pack(),
kind: library::Ordered(self.number()), label: library::Ordered(self.number()),
})) }))
} }
} }

96
src/eval/show.rs Normal file
View File

@ -0,0 +1,96 @@
use std::any::{Any, TypeId};
use std::fmt::{self, Debug, Formatter};
use std::hash::{Hash, Hasher};
use std::sync::Arc;
use super::{StyleChain, Template};
use crate::util::Prehashed;
/// A node that can be realized given some styles.
pub trait Show {
/// Realize the template in the given styles.
fn show(&self, styles: StyleChain) -> Template;
/// 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 show(&self, styles: StyleChain) -> Template {
self.0.show(styles)
}
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 {
// We cast to thin pointers for comparison because we don't want to
// compare vtables (which can be different across codegen units).
std::ptr::eq(
Arc::as_ptr(&self.0) as *const (),
Arc::as_ptr(&other.0) as *const (),
)
}
}
trait Bounds: Show + Debug + Sync + Send + 'static {
fn as_any(&self) -> &dyn Any;
fn hash64(&self) -> u64;
}
impl<T> Bounds for T
where
T: Show + Debug + Hash + Sync + Send + 'static,
{
fn as_any(&self) -> &dyn Any {
self
}
fn hash64(&self) -> u64 {
// Also hash the TypeId since nodes with different types but
// equal data should be different.
let mut state = fxhash::FxHasher64::default();
self.type_id().hash(&mut state);
self.hash(&mut state);
state.finish()
}
}
impl Hash for dyn Bounds {
fn hash<H: Hasher>(&self, state: &mut H) {
state.write_u64(self.hash64());
}
}

30
src/eval/styles.rs
View File

@ -49,6 +49,11 @@ impl StyleMap {
self self
} }
/// Whether this map contains scoped styles.
pub fn has_scoped(&self) -> bool {
self.0.iter().any(|e| e.scoped)
}
/// Make `self` the first link of the style chain `outer`. /// Make `self` the first link of the style chain `outer`.
/// ///
/// The resulting style chain contains styles from `self` as well as /// The resulting style chain contains styles from `self` as well as
@ -136,20 +141,6 @@ impl<'a> StyleChain<'a> {
self.links().count() self.links().count()
} }
/// Convert to an owned style map.
///
/// Panics if the chain contains barrier links.
pub fn to_map(self) -> StyleMap {
let mut suffix = StyleMap::new();
for link in self.links() {
match link {
Link::Map(map) => suffix.apply(map),
Link::Barrier(_) => panic!("chain contains barrier"),
}
}
suffix
}
/// Build a style map from the suffix (all links beyond the `len`) of the /// Build a style map from the suffix (all links beyond the `len`) of the
/// chain. /// chain.
/// ///
@ -170,6 +161,17 @@ impl<'a> StyleChain<'a> {
pub fn pop(&mut self) { pub fn pop(&mut self) {
*self = self.outer.copied().unwrap_or_default(); *self = self.outer.copied().unwrap_or_default();
} }
/// Return the chain, but without the last link if that one contains only
/// scoped styles. This is a hack.
pub(crate) fn unscoped(mut self, node: TypeId) -> Self {
if let Some(Link::Map(map)) = self.link {
if map.0.iter().all(|e| e.scoped && e.is_of_id(node)) {
self.pop();
}
}
self
}
} }
impl<'a> StyleChain<'a> { impl<'a> StyleChain<'a> {

217
src/eval/template.rs
View File

@ -6,12 +6,15 @@ use std::ops::{Add, AddAssign};
use typed_arena::Arena; use typed_arena::Arena;
use super::{CollapsingBuilder, Interruption, Property, StyleMap, StyleVecBuilder}; use super::{
CollapsingBuilder, Interruption, Property, Show, ShowNode, StyleMap, StyleVecBuilder,
};
use crate::diag::StrResult; use crate::diag::StrResult;
use crate::layout::{Layout, PackedNode}; use crate::layout::{Layout, LayoutNode};
use crate::library::prelude::*; use crate::library::prelude::*;
use crate::library::{ use crate::library::{
FlowChild, FlowNode, PageNode, ParChild, ParNode, PlaceNode, SpacingKind, TextNode, DecoNode, FlowChild, FlowNode, PageNode, ParChild, ParNode, PlaceNode, SpacingKind,
TextNode, Underline,
}; };
use crate::util::EcoString; use crate::util::EcoString;
use crate::Context; use crate::Context;
@ -52,7 +55,7 @@ pub enum Template {
/// Plain text. /// Plain text.
Text(EcoString), Text(EcoString),
/// An inline-level node. /// An inline-level node.
Inline(PackedNode), Inline(LayoutNode),
/// A paragraph break. /// A paragraph break.
Parbreak, Parbreak,
/// A column break. /// A column break.
@ -60,21 +63,23 @@ pub enum Template {
/// Vertical spacing. /// Vertical spacing.
Vertical(SpacingKind), Vertical(SpacingKind),
/// A block-level node. /// A block-level node.
Block(PackedNode), Block(LayoutNode),
/// A page break. /// A page break.
Pagebreak, Pagebreak,
/// A page node. /// A page node.
Page(PageNode), Page(PageNode),
/// A node that can be realized with styles.
Show(ShowNode),
/// A template with attached styles. /// A template with attached styles.
Styled(Box<Self>, StyleMap), Styled(Arc<(Self, StyleMap)>),
/// A sequence of multiple subtemplates. /// A sequence of multiple subtemplates.
Sequence(Vec<Self>), Sequence(Arc<Vec<Self>>),
} }
impl Template { impl Template {
/// Create an empty template. /// Create an empty template.
pub fn new() -> Self { pub fn new() -> Self {
Self::Sequence(vec![]) Self::sequence(vec![])
} }
/// Create a template from an inline-level node. /// Create a template from an inline-level node.
@ -93,42 +98,63 @@ impl Template {
Self::Block(node.pack()) Self::Block(node.pack())
} }
/// Layout this template into a collection of pages. /// Create a template from a showable node.
pub fn layout(&self, ctx: &mut Context) -> Vec<Arc<Frame>> { pub fn show<T>(node: T) -> Self
let (mut ctx, styles) = LayoutContext::new(ctx); where
let (pages, shared) = Builder::build_pages(self); T: Show + Debug + Hash + Sync + Send + 'static,
let styles = shared.chain(&styles); {
pages Self::Show(node.pack())
.iter()
.flat_map(|(page, map)| page.layout(&mut ctx, map.chain(&styles)))
.collect()
} }
/// Style this template with a single property. /// Style this template with a single property.
pub fn styled<P: Property>(mut self, key: P, value: P::Value) -> Self { pub fn styled<P: Property>(mut self, key: P, value: P::Value) -> Self {
if let Self::Styled(_, map) = &mut self { if let Self::Styled(styled) = &mut self {
map.set(key, value); if let Some((_, map)) = Arc::get_mut(styled) {
self if !map.has_scoped() {
} else { map.set(key, value);
self.styled_with_map(StyleMap::with(key, value)) }
return self;
}
} }
self.styled_with_map(StyleMap::with(key, value))
} }
/// Style this template with a full style map. /// Style this template with a full style map.
pub fn styled_with_map(mut self, styles: StyleMap) -> Self { pub fn styled_with_map(mut self, styles: StyleMap) -> Self {
if styles.is_empty() { if styles.is_empty() {
self return self;
} else if let Self::Styled(_, map) = &mut self {
map.apply(&styles);
self
} else {
Self::Styled(Box::new(self), styles)
} }
if let Self::Styled(styled) = &mut self {
if let Some((_, map)) = Arc::get_mut(styled) {
if !styles.has_scoped() && !map.has_scoped() {
map.apply(&styles);
return self;
}
}
}
Self::Styled(Arc::new((self, styles)))
} }
/// Style this template in monospace. /// Style this template in monospace.
pub fn monospaced(self) -> Self { pub fn monospaced(self) -> Self {
self.styled(TextNode::MONOSPACE, true) self.styled(TextNode::MONOSPACED, true)
}
/// Underline this template.
pub fn underlined(self) -> Self {
Self::show(DecoNode { kind: Underline, body: self })
}
/// Create a new sequence template.
pub fn sequence(seq: Vec<Self>) -> Self {
if seq.len() == 1 {
seq.into_iter().next().unwrap()
} else {
Self::Sequence(Arc::new(seq))
}
} }
/// Repeat this template `n` times. /// Repeat this template `n` times.
@ -136,7 +162,24 @@ impl Template {
let count = usize::try_from(n) let count = usize::try_from(n)
.map_err(|_| format!("cannot repeat this template {} times", n))?; .map_err(|_| format!("cannot repeat this template {} times", n))?;
Ok(Self::Sequence(vec![self.clone(); count])) Ok(Self::sequence(vec![self.clone(); count]))
}
/// Layout this template into a collection of pages.
pub fn layout(&self, ctx: &mut Context) -> Vec<Arc<Frame>> {
let style_arena = Arena::new();
let template_arena = Arena::new();
let (mut ctx, styles) = LayoutContext::new(ctx);
let mut builder = Builder::new(&style_arena, &template_arena, true);
builder.process(self, styles);
builder.finish_page(true, false, styles);
let (pages, shared) = builder.pages.unwrap().finish();
pages
.iter()
.flat_map(|(page, map)| page.layout(&mut ctx, map.chain(&shared)))
.collect()
} }
} }
@ -168,11 +211,17 @@ impl Debug for Template {
} }
Self::Pagebreak => f.pad("Pagebreak"), Self::Pagebreak => f.pad("Pagebreak"),
Self::Page(page) => page.fmt(f), Self::Page(page) => page.fmt(f),
Self::Styled(sub, map) => { 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)?; map.fmt(f)?;
sub.fmt(f) sub.fmt(f)
} }
Self::Sequence(seq) => f.debug_list().entries(seq).finish(), Self::Sequence(seq) => f.debug_list().entries(seq.iter()).finish(),
} }
} }
} }
@ -183,20 +232,22 @@ impl Add for Template {
fn add(self, rhs: Self) -> Self::Output { fn add(self, rhs: Self) -> Self::Output {
Self::Sequence(match (self, rhs) { Self::Sequence(match (self, rhs) {
(Self::Sequence(mut lhs), Self::Sequence(rhs)) => { (Self::Sequence(mut lhs), Self::Sequence(rhs)) => {
lhs.extend(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 lhs
} }
(Self::Sequence(mut lhs), rhs) => { (Self::Sequence(mut lhs), rhs) => {
lhs.push(rhs); Arc::make_mut(&mut lhs).push(rhs);
lhs lhs
} }
(lhs, Self::Sequence(mut rhs)) => { (lhs, Self::Sequence(mut rhs)) => {
rhs.insert(0, lhs); Arc::make_mut(&mut rhs).insert(0, lhs);
rhs rhs
} }
(lhs, rhs) => { (lhs, rhs) => Arc::new(vec![lhs, rhs]),
vec![lhs, rhs]
}
}) })
} }
} }
@ -209,7 +260,7 @@ impl AddAssign for Template {
impl Sum for Template { impl Sum for Template {
fn sum<I: Iterator<Item = Self>>(iter: I) -> Self { fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
Self::Sequence(iter.collect()) Self::sequence(iter.collect())
} }
} }
@ -220,14 +271,21 @@ impl Layout for Template {
regions: &Regions, regions: &Regions,
styles: StyleChain, styles: StyleChain,
) -> Vec<Constrained<Arc<Frame>>> { ) -> Vec<Constrained<Arc<Frame>>> {
let (flow, shared) = Builder::build_flow(self); let style_arena = Arena::new();
flow.layout(ctx, regions, shared.chain(&styles)) let template_arena = Arena::new();
let mut builder = Builder::new(&style_arena, &template_arena, false);
builder.process(self, styles);
builder.finish_par(styles);
let (flow, shared) = builder.flow.finish();
FlowNode(flow).layout(ctx, regions, shared)
} }
fn pack(self) -> PackedNode { fn pack(self) -> LayoutNode {
match self { match self {
Template::Block(node) => node, Template::Block(node) => node,
other => PackedNode::new(other), other => LayoutNode::new(other),
} }
} }
} }
@ -235,7 +293,9 @@ impl Layout for Template {
/// Builds a flow or page nodes from a template. /// Builds a flow or page nodes from a template.
struct Builder<'a> { struct Builder<'a> {
/// An arena where intermediate style chains are stored. /// An arena where intermediate style chains are stored.
arena: &'a Arena<StyleChain<'a>>, style_arena: &'a Arena<StyleChain<'a>>,
/// An arena where intermediate templates are stored.
template_arena: &'a Arena<Template>,
/// The already built page runs. /// The already built page runs.
pages: Option<StyleVecBuilder<'a, PageNode>>, pages: Option<StyleVecBuilder<'a, PageNode>>,
/// The currently built flow. /// The currently built flow.
@ -247,34 +307,15 @@ struct Builder<'a> {
} }
impl<'a> Builder<'a> { impl<'a> Builder<'a> {
/// Build page runs from a template.
fn build_pages(template: &Template) -> (StyleVec<PageNode>, StyleMap) {
let arena = Arena::new();
let mut builder = Builder::prepare(&arena, true);
builder.process(template, StyleChain::default());
builder.finish_page(true, false, StyleChain::default());
let (pages, shared) = builder.pages.unwrap().finish();
(pages, shared.to_map())
}
/// Build a subflow from a template.
fn build_flow(template: &Template) -> (FlowNode, StyleMap) {
let arena = Arena::new();
let mut builder = Builder::prepare(&arena, false);
builder.process(template, StyleChain::default());
builder.finish_par();
let (flow, shared) = builder.flow.finish();
(FlowNode(flow), shared.to_map())
}
/// Prepare the builder. /// Prepare the builder.
fn prepare(arena: &'a Arena<StyleChain<'a>>, top: bool) -> Self { fn new(
style_arena: &'a Arena<StyleChain<'a>>,
template_arena: &'a Arena<Template>,
top: bool,
) -> Self {
Self { Self {
arena, style_arena,
template_arena,
pages: top.then(|| StyleVecBuilder::new()), pages: top.then(|| StyleVecBuilder::new()),
flow: CollapsingBuilder::new(), flow: CollapsingBuilder::new(),
par: CollapsingBuilder::new(), par: CollapsingBuilder::new(),
@ -286,7 +327,7 @@ impl<'a> Builder<'a> {
fn process(&mut self, template: &'a Template, styles: StyleChain<'a>) { fn process(&mut self, template: &'a Template, styles: StyleChain<'a>) {
match template { match template {
Template::Space => { Template::Space => {
self.par.weak(ParChild::Text(' '.into()), styles); self.par.weak(ParChild::Text(' '.into()), 0, styles);
} }
Template::Linebreak => { Template::Linebreak => {
self.par.destructive(ParChild::Text('\n'.into()), styles); self.par.destructive(ParChild::Text('\n'.into()), styles);
@ -306,15 +347,15 @@ impl<'a> Builder<'a> {
self.par.supportive(ParChild::Node(node.clone()), styles); self.par.supportive(ParChild::Node(node.clone()), styles);
} }
Template::Parbreak => { Template::Parbreak => {
self.finish_par(); self.finish_par(styles);
self.flow.weak(FlowChild::Parbreak, styles); self.flow.weak(FlowChild::Parbreak, 1, styles);
} }
Template::Colbreak => { Template::Colbreak => {
self.finish_par(); self.finish_par(styles);
self.flow.destructive(FlowChild::Colbreak, styles); self.flow.destructive(FlowChild::Colbreak, styles);
} }
Template::Vertical(kind) => { Template::Vertical(kind) => {
self.finish_par(); self.finish_par(styles);
let child = FlowChild::Spacing(*kind); let child = FlowChild::Spacing(*kind);
if kind.is_fractional() { if kind.is_fractional() {
self.flow.destructive(child, styles); self.flow.destructive(child, styles);
@ -323,13 +364,14 @@ impl<'a> Builder<'a> {
} }
} }
Template::Block(node) => { Template::Block(node) => {
self.finish_par(); self.finish_par(styles);
let child = FlowChild::Node(node.clone()); let child = FlowChild::Node(node.clone());
if node.is::<PlaceNode>() { if node.is::<PlaceNode>() {
self.flow.ignorant(child, styles); self.flow.ignorant(child, styles);
} else { } else {
self.flow.supportive(child, styles); self.flow.supportive(child, styles);
} }
self.finish_par(styles);
} }
Template::Pagebreak => { Template::Pagebreak => {
self.finish_page(true, true, styles); self.finish_page(true, true, styles);
@ -340,26 +382,32 @@ impl<'a> Builder<'a> {
pages.push(page.clone(), styles); pages.push(page.clone(), styles);
} }
} }
Template::Styled(sub, map) => { Template::Show(node) => {
let template = self.template_arena.alloc(node.show(styles));
self.process(template, styles.unscoped(node.id()));
}
Template::Styled(styled) => {
let (sub, map) = styled.as_ref();
let stored = self.style_arena.alloc(styles);
let styles = map.chain(stored);
let interruption = map.interruption(); let interruption = map.interruption();
match interruption { match interruption {
Some(Interruption::Page) => self.finish_page(false, true, styles), Some(Interruption::Page) => self.finish_page(false, true, styles),
Some(Interruption::Par) => self.finish_par(), Some(Interruption::Par) => self.finish_par(styles),
None => {} None => {}
} }
let outer = self.arena.alloc(styles);
let styles = map.chain(outer);
self.process(sub, styles); self.process(sub, styles);
match interruption { match interruption {
Some(Interruption::Page) => self.finish_page(true, false, styles), Some(Interruption::Page) => self.finish_page(true, false, styles),
Some(Interruption::Par) => self.finish_par(), Some(Interruption::Par) => self.finish_par(styles),
None => {} None => {}
} }
} }
Template::Sequence(seq) => { Template::Sequence(seq) => {
for sub in seq { for sub in seq.iter() {
self.process(sub, styles); self.process(sub, styles);
} }
} }
@ -367,17 +415,18 @@ impl<'a> Builder<'a> {
} }
/// Finish the currently built paragraph. /// Finish the currently built paragraph.
fn finish_par(&mut self) { fn finish_par(&mut self, styles: StyleChain<'a>) {
let (par, shared) = mem::take(&mut self.par).finish(); let (par, shared) = mem::take(&mut self.par).finish();
if !par.is_empty() { if !par.is_empty() {
let node = ParNode(par).pack(); let node = ParNode(par).pack();
self.flow.supportive(FlowChild::Node(node), shared); self.flow.supportive(FlowChild::Node(node), shared);
} }
self.flow.weak(FlowChild::Leading, 0, styles);
} }
/// Finish the currently built page run. /// Finish the currently built page run.
fn finish_page(&mut self, keep_last: bool, keep_next: bool, styles: StyleChain<'a>) { fn finish_page(&mut self, keep_last: bool, keep_next: bool, styles: StyleChain<'a>) {
self.finish_par(); self.finish_par(styles);
if let Some(pages) = &mut self.pages { if let Some(pages) = &mut self.pages {
let (flow, shared) = mem::take(&mut self.flow).finish(); let (flow, shared) = mem::take(&mut self.flow).finish();
if !flow.is_empty() || (keep_last && self.keep_next) { if !flow.is_empty() || (keep_last && self.keep_next) {

2
src/eval/value.rs
View File

@ -115,7 +115,7 @@ impl Value {
} }
/// Return the display representation of the value. /// Return the display representation of the value.
pub fn show(self) -> Template { pub fn display(self) -> Template {
match self { match self {
Value::None => Template::new(), Value::None => Template::new(),
Value::Int(v) => Template::Text(format_eco!("{}", v)), Value::Int(v) => Template::Text(format_eco!("{}", v)),

78
src/layout/mod.rs
View File

@ -10,7 +10,7 @@ pub use constraints::*;
pub use incremental::*; pub use incremental::*;
pub use regions::*; pub use regions::*;
use std::any::Any; use std::any::{Any, TypeId};
use std::fmt::{self, Debug, Formatter}; use std::fmt::{self, Debug, Formatter};
use std::hash::{Hash, Hasher}; use std::hash::{Hash, Hasher};
use std::sync::Arc; use std::sync::Arc;
@ -21,6 +21,7 @@ use crate::frame::{Element, Frame, Geometry, Shape, Stroke};
use crate::geom::{Align, Linear, Paint, Point, Sides, Size, Spec}; use crate::geom::{Align, Linear, Paint, Point, Sides, Size, Spec};
use crate::image::ImageStore; use crate::image::ImageStore;
use crate::library::{AlignNode, Move, PadNode, TransformNode}; use crate::library::{AlignNode, Move, PadNode, TransformNode};
use crate::util::Prehashed;
use crate::Context; use crate::Context;
/// A node that can be layouted into a sequence of regions. /// A node that can be layouted into a sequence of regions.
@ -37,11 +38,11 @@ pub trait Layout {
) -> Vec<Constrained<Arc<Frame>>>; ) -> Vec<Constrained<Arc<Frame>>>;
/// Convert to a packed node. /// Convert to a packed node.
fn pack(self) -> PackedNode fn pack(self) -> LayoutNode
where where
Self: Debug + Hash + Sized + Sync + Send + 'static, Self: Debug + Hash + Sized + Sync + Send + 'static,
{ {
PackedNode::new(self) LayoutNode::new(self)
} }
} }
@ -75,31 +76,26 @@ impl<'a> LayoutContext<'a> {
} }
/// A type-erased layouting node with a precomputed hash. /// A type-erased layouting node with a precomputed hash.
#[derive(Clone)] #[derive(Clone, Hash)]
pub struct PackedNode { pub struct LayoutNode(Arc<Prehashed<dyn Bounds>>);
/// The type-erased node.
node: Arc<dyn Bounds>,
/// A precomputed hash for the node.
#[cfg(feature = "layout-cache")]
hash: u64,
}
impl PackedNode { impl LayoutNode {
/// Pack any layoutable node. /// Pack any layoutable node.
pub fn new<T>(node: T) -> Self pub fn new<T>(node: T) -> Self
where where
T: Layout + Debug + Hash + Sync + Send + 'static, T: Layout + Debug + Hash + Sync + Send + 'static,
{ {
Self { Self(Arc::new(Prehashed::new(node)))
#[cfg(feature = "layout-cache")]
hash: node.hash64(),
node: Arc::new(node),
}
} }
/// Check whether the contained node is a specific layout node. /// Check whether the contained node is a specific layout node.
pub fn is<T: 'static>(&self) -> bool { pub fn is<T: 'static>(&self) -> bool {
self.node.as_any().is::<T>() self.0.as_any().is::<T>()
}
/// The type id of this node.
pub fn id(&self) -> TypeId {
self.0.as_any().type_id()
} }
/// Try to downcast to a specific layout node. /// Try to downcast to a specific layout node.
@ -107,7 +103,7 @@ impl PackedNode {
where where
T: Layout + Debug + Hash + 'static, T: Layout + Debug + Hash + 'static,
{ {
self.node.as_any().downcast_ref() self.0.as_any().downcast_ref()
} }
/// Force a size for this node. /// Force a size for this node.
@ -165,7 +161,7 @@ impl PackedNode {
} }
} }
impl Layout for PackedNode { impl Layout for LayoutNode {
#[track_caller] #[track_caller]
fn layout( fn layout(
&self, &self,
@ -173,7 +169,7 @@ impl Layout for PackedNode {
regions: &Regions, regions: &Regions,
styles: StyleChain, styles: StyleChain,
) -> Vec<Constrained<Arc<Frame>>> { ) -> Vec<Constrained<Arc<Frame>>> {
let styles = styles.barred(self.node.as_any().type_id()); let styles = styles.barred(self.id());
#[cfg(not(feature = "layout-cache"))] #[cfg(not(feature = "layout-cache"))]
return self.node.layout(ctx, regions, styles); return self.node.layout(ctx, regions, styles);
@ -193,14 +189,14 @@ impl Layout for PackedNode {
frames frames
} else { } else {
ctx.level += 1; ctx.level += 1;
let frames = self.node.layout(ctx, regions, styles); let frames = self.0.layout(ctx, regions, styles);
ctx.level -= 1; ctx.level -= 1;
let entry = FramesEntry::new(frames.clone(), ctx.level); let entry = FramesEntry::new(frames.clone(), ctx.level);
#[cfg(debug_assertions)] #[cfg(debug_assertions)]
if !entry.check(regions) { if !entry.check(regions) {
eprintln!("node: {:#?}", self.node); eprintln!("node: {:#?}", self.0);
eprintln!("regions: {regions:#?}"); eprintln!("regions: {regions:#?}");
eprintln!( eprintln!(
"constraints: {:#?}", "constraints: {:#?}",
@ -214,44 +210,34 @@ impl Layout for PackedNode {
} }
} }
fn pack(self) -> PackedNode { fn pack(self) -> LayoutNode {
self self
} }
} }
impl Default for PackedNode { impl Default for LayoutNode {
fn default() -> Self { fn default() -> Self {
EmptyNode.pack() EmptyNode.pack()
} }
} }
impl Debug for PackedNode { impl Debug for LayoutNode {
fn fmt(&self, f: &mut Formatter) -> fmt::Result { fn fmt(&self, f: &mut Formatter) -> fmt::Result {
self.node.fmt(f) self.0.fmt(f)
} }
} }
impl PartialEq for PackedNode { impl PartialEq for LayoutNode {
fn eq(&self, other: &Self) -> bool { fn eq(&self, other: &Self) -> bool {
// We cast to thin pointers for comparison because we don't want to // We cast to thin pointers for comparison because we don't want to
// compare vtables (which can be different across codegen units). // compare vtables (which can be different across codegen units).
std::ptr::eq( std::ptr::eq(
Arc::as_ptr(&self.node) as *const (), Arc::as_ptr(&self.0) as *const (),
Arc::as_ptr(&other.node) as *const (), Arc::as_ptr(&other.0) as *const (),
) )
} }
} }
impl Hash for PackedNode {
fn hash<H: Hasher>(&self, state: &mut H) {
// Hash the node.
#[cfg(feature = "layout-cache")]
state.write_u64(self.hash);
#[cfg(not(feature = "layout-cache"))]
state.write_u64(self.hash64());
}
}
trait Bounds: Layout + Debug + Sync + Send + 'static { trait Bounds: Layout + Debug + Sync + Send + 'static {
fn as_any(&self) -> &dyn Any; fn as_any(&self) -> &dyn Any;
fn hash64(&self) -> u64; fn hash64(&self) -> u64;
@ -275,6 +261,12 @@ where
} }
} }
impl Hash for dyn Bounds {
fn hash<H: Hasher>(&self, state: &mut H) {
state.write_u64(self.hash64());
}
}
/// A layout node that produces an empty frame. /// A layout node that produces an empty frame.
/// ///
/// The packed version of this is returned by [`PackedNode::default`]. /// The packed version of this is returned by [`PackedNode::default`].
@ -301,7 +293,7 @@ struct SizedNode {
/// How to size the node horizontally and vertically. /// How to size the node horizontally and vertically.
sizing: Spec<Option<Linear>>, sizing: Spec<Option<Linear>>,
/// The node to be sized. /// The node to be sized.
child: PackedNode, child: LayoutNode,
} }
impl Layout for SizedNode { impl Layout for SizedNode {
@ -355,7 +347,7 @@ struct FillNode {
/// How to fill the frames resulting from the `child`. /// How to fill the frames resulting from the `child`.
fill: Paint, fill: Paint,
/// The node to fill. /// The node to fill.
child: PackedNode, child: LayoutNode,
} }
impl Layout for FillNode { impl Layout for FillNode {
@ -380,7 +372,7 @@ struct StrokeNode {
/// How to stroke the frames resulting from the `child`. /// How to stroke the frames resulting from the `child`.
stroke: Stroke, stroke: Stroke,
/// The node to stroke. /// The node to stroke.
child: PackedNode, child: LayoutNode,
} }
impl Layout for StrokeNode { impl Layout for StrokeNode {

4
src/library/align.rs
View File

@ -9,14 +9,14 @@ pub struct AlignNode {
/// How to align the node horizontally and vertically. /// How to align the node horizontally and vertically.
pub aligns: Spec<Option<Align>>, pub aligns: Spec<Option<Align>>,
/// The node to be aligned. /// The node to be aligned.
pub child: PackedNode, pub child: LayoutNode,
} }
#[class] #[class]
impl AlignNode { impl AlignNode {
fn construct(_: &mut EvalContext, args: &mut Args) -> TypResult<Template> { fn construct(_: &mut EvalContext, args: &mut Args) -> TypResult<Template> {
let aligns: Spec<_> = args.find().unwrap_or_default(); let aligns: Spec<_> = args.find().unwrap_or_default();
let body: PackedNode = args.expect("body")?; let body: LayoutNode = args.expect("body")?;
Ok(Template::block(body.aligned(aligns))) Ok(Template::block(body.aligned(aligns)))
} }
} }

7
src/library/columns.rs
View File

@ -10,7 +10,7 @@ pub struct ColumnsNode {
pub columns: NonZeroUsize, pub columns: NonZeroUsize,
/// The child to be layouted into the columns. Most likely, this should be a /// The child to be layouted into the columns. Most likely, this should be a
/// flow or stack node. /// flow or stack node.
pub child: PackedNode, pub child: LayoutNode,
} }
#[class] #[class]
@ -24,11 +24,6 @@ impl ColumnsNode {
child: args.expect("body")?, child: args.expect("body")?,
})) }))
} }
fn set(args: &mut Args, styles: &mut StyleMap) -> TypResult<()> {
styles.set_opt(Self::GUTTER, args.named("gutter")?);
Ok(())
}
} }
impl Layout for ColumnsNode { impl Layout for ColumnsNode {

2
src/library/container.rs
View File

@ -10,7 +10,7 @@ impl BoxNode {
fn construct(_: &mut EvalContext, args: &mut Args) -> TypResult<Template> { fn construct(_: &mut EvalContext, args: &mut Args) -> TypResult<Template> {
let width = args.named("width")?; let width = args.named("width")?;
let height = args.named("height")?; let height = args.named("height")?;
let body: PackedNode = args.find().unwrap_or_default(); let body: LayoutNode = args.find().unwrap_or_default();
Ok(Template::inline(body.sized(Spec::new(width, height)))) Ok(Template::inline(body.sized(Spec::new(width, height))))
} }
} }

76
src/library/deco.rs
View File

@ -4,57 +4,67 @@ use super::prelude::*;
use super::TextNode; use super::TextNode;
/// Typeset underline, striken-through or overlined text. /// Typeset underline, striken-through or overlined text.
pub struct DecoNode<L: LineKind>(pub L); #[derive(Debug, Hash)]
pub struct DecoNode<L: LineKind> {
/// The kind of line.
pub kind: L,
/// The decorated contents.
pub body: Template,
}
#[class] #[class]
impl<L: LineKind> DecoNode<L> { impl<L: LineKind> DecoNode<L> {
/// Stroke color of the line, defaults to the text color if `None`.
#[shorthand]
pub const STROKE: Option<Paint> = None;
/// Thickness of the line's strokes (dependent on scaled font size), read
/// from the font tables if `None`.
#[shorthand]
pub const THICKNESS: Option<Linear> = None;
/// Position of the line relative to the baseline (dependent on scaled font
/// size), read from the font tables if `None`.
pub const OFFSET: Option<Linear> = None;
/// Amount that the line will be longer or shorter than its associated text
/// (dependent on scaled font size).
pub const EXTENT: Linear = Linear::zero();
/// Whether the line skips sections in which it would collide
/// with the glyphs. Does not apply to strikethrough.
pub const EVADE: bool = true;
fn construct(_: &mut EvalContext, args: &mut Args) -> TypResult<Template> { fn construct(_: &mut EvalContext, args: &mut Args) -> TypResult<Template> {
let deco = Decoration { Ok(Template::show(Self {
kind: L::default(),
body: args.expect::<Template>("body")?,
}))
}
}
impl<L: LineKind> Show for DecoNode<L> {
fn show(&self, styles: StyleChain) -> Template {
self.body.clone().styled(TextNode::LINES, vec![Decoration {
line: L::LINE, line: L::LINE,
stroke: args.named("stroke")?.or_else(|| args.find()), stroke: styles.get(Self::STROKE),
thickness: args.named::<Linear>("thickness")?.or_else(|| args.find()), thickness: styles.get(Self::THICKNESS),
offset: args.named("offset")?, offset: styles.get(Self::OFFSET),
extent: args.named("extent")?.unwrap_or_default(), extent: styles.get(Self::EXTENT),
evade: args.named("evade")?.unwrap_or(true), evade: styles.get(Self::EVADE),
}; }])
Ok(args.expect::<Template>("body")?.styled(TextNode::LINES, vec![deco]))
} }
} }
/// Defines a line that is positioned over, under or on top of text. /// Defines a line that is positioned over, under or on top of text.
///
/// For more details, see [`DecoNode`].
#[derive(Debug, Clone, Eq, PartialEq, Hash)] #[derive(Debug, Clone, Eq, PartialEq, Hash)]
pub struct Decoration { pub struct Decoration {
/// Which line to draw.
pub line: DecoLine, pub line: DecoLine,
/// Stroke color of the line, defaults to the text color if `None`.
pub stroke: Option<Paint>, pub stroke: Option<Paint>,
/// Thickness of the line's strokes (dependent on scaled font size), read
/// from the font tables if `None`.
pub thickness: Option<Linear>, pub thickness: Option<Linear>,
/// Position of the line relative to the baseline (dependent on scaled font
/// size), read from the font tables if `None`.
pub offset: Option<Linear>, pub offset: Option<Linear>,
/// Amount that the line will be longer or shorter than its associated text
/// (dependent on scaled font size).
pub extent: Linear, pub extent: Linear,
/// Whether the line skips sections in which it would collide
/// with the glyphs. Does not apply to strikethrough.
pub evade: bool, pub evade: bool,
} }
impl From<DecoLine> for Decoration {
fn from(line: DecoLine) -> Self {
Self {
line,
stroke: None,
thickness: None,
offset: None,
extent: Linear::zero(),
evade: true,
}
}
}
/// The kind of decorative line. /// The kind of decorative line.
#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)] #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
pub enum DecoLine { pub enum DecoLine {
@ -67,7 +77,7 @@ pub enum DecoLine {
} }
/// Different kinds of decorative lines for text. /// Different kinds of decorative lines for text.
pub trait LineKind { pub trait LineKind: Debug + Default + Hash + Sync + Send + 'static {
const LINE: DecoLine; const LINE: DecoLine;
} }

34
src/library/flow.rs
View File

@ -13,6 +13,8 @@ pub struct FlowNode(pub StyleVec<FlowChild>);
/// A child of a flow node. /// A child of a flow node.
#[derive(Hash)] #[derive(Hash)]
pub enum FlowChild { pub enum FlowChild {
/// Leading between other children.
Leading,
/// A paragraph / block break. /// A paragraph / block break.
Parbreak, Parbreak,
/// A column / region break. /// A column / region break.
@ -20,7 +22,7 @@ pub enum FlowChild {
/// Vertical spacing between other children. /// Vertical spacing between other children.
Spacing(SpacingKind), Spacing(SpacingKind),
/// An arbitrary block-level node. /// An arbitrary block-level node.
Node(PackedNode), Node(LayoutNode),
} }
impl Layout for FlowNode { impl Layout for FlowNode {
@ -35,10 +37,17 @@ impl Layout for FlowNode {
for (child, map) in self.0.iter() { for (child, map) in self.0.iter() {
let styles = map.chain(&styles); let styles = map.chain(&styles);
match child { match child {
FlowChild::Leading => {
let em = styles.get(TextNode::SIZE).abs;
let amount = styles.get(ParNode::LEADING).resolve(em);
layouter.layout_spacing(amount.into());
}
FlowChild::Parbreak => { FlowChild::Parbreak => {
let em = styles.get(TextNode::SIZE).abs; let em = styles.get(TextNode::SIZE).abs;
let amount = styles.get(ParNode::SPACING).resolve(em); let leading = styles.get(ParNode::LEADING);
layouter.layout_spacing(SpacingKind::Linear(amount.into())); let spacing = styles.get(ParNode::SPACING);
let amount = (leading + spacing).resolve(em);
layouter.layout_spacing(amount.into());
} }
FlowChild::Colbreak => { FlowChild::Colbreak => {
layouter.finish_region(); layouter.finish_region();
@ -72,6 +81,7 @@ impl Debug for FlowNode {
impl Debug for FlowChild { impl Debug for FlowChild {
fn fmt(&self, f: &mut Formatter) -> fmt::Result { fn fmt(&self, f: &mut Formatter) -> fmt::Result {
match self { match self {
Self::Leading => f.pad("Leading"),
Self::Parbreak => f.pad("Parbreak"), Self::Parbreak => f.pad("Parbreak"),
Self::Colbreak => f.pad("Colbreak"), Self::Colbreak => f.pad("Colbreak"),
Self::Spacing(kind) => write!(f, "{:?}", kind), Self::Spacing(kind) => write!(f, "{:?}", kind),
@ -93,8 +103,6 @@ pub struct FlowLayouter {
used: Size, used: Size,
/// The sum of fractional ratios in the current region. /// The sum of fractional ratios in the current region.
fr: Fractional, fr: Fractional,
/// Whether to add leading before the next node.
leading: bool,
/// Spacing and layouted nodes. /// Spacing and layouted nodes.
items: Vec<FlowItem>, items: Vec<FlowItem>,
/// Finished frames for previous regions. /// Finished frames for previous regions.
@ -129,7 +137,6 @@ impl FlowLayouter {
full, full,
used: Size::zero(), used: Size::zero(),
fr: Fractional::zero(), fr: Fractional::zero(),
leading: false,
items: vec![], items: vec![],
finished: vec![], finished: vec![],
} }
@ -149,7 +156,6 @@ impl FlowLayouter {
SpacingKind::Fractional(v) => { SpacingKind::Fractional(v) => {
self.items.push(FlowItem::Fractional(v)); self.items.push(FlowItem::Fractional(v));
self.fr += v; self.fr += v;
self.leading = false;
} }
} }
} }
@ -158,7 +164,7 @@ impl FlowLayouter {
pub fn layout_node( pub fn layout_node(
&mut self, &mut self,
ctx: &mut LayoutContext, ctx: &mut LayoutContext,
node: &PackedNode, node: &LayoutNode,
styles: StyleChain, styles: StyleChain,
) { ) {
// Don't even try layouting into a full region. // Don't even try layouting into a full region.
@ -168,9 +174,7 @@ impl FlowLayouter {
// Placed nodes that are out of flow produce placed items which aren't // Placed nodes that are out of flow produce placed items which aren't
// aligned later. // aligned later.
let mut is_placed = false;
if let Some(placed) = node.downcast::<PlaceNode>() { if let Some(placed) = node.downcast::<PlaceNode>() {
is_placed = true;
if placed.out_of_flow() { if placed.out_of_flow() {
let frame = node.layout(ctx, &self.regions, styles).remove(0); let frame = node.layout(ctx, &self.regions, styles).remove(0);
self.items.push(FlowItem::Placed(frame.item)); self.items.push(FlowItem::Placed(frame.item));
@ -178,13 +182,6 @@ impl FlowLayouter {
} }
} }
// Add leading.
if self.leading {
let em = styles.get(TextNode::SIZE).abs;
let amount = styles.get(ParNode::LEADING).resolve(em);
self.layout_spacing(SpacingKind::Linear(amount.into()));
}
// How to align the node. // How to align the node.
let aligns = Spec::new( let aligns = Spec::new(
// For non-expanding paragraphs it is crucial that we align the // For non-expanding paragraphs it is crucial that we align the
@ -210,8 +207,6 @@ impl FlowLayouter {
self.finish_region(); self.finish_region();
} }
} }
self.leading = !is_placed;
} }
/// Finish the frame for one region. /// Finish the frame for one region.
@ -264,7 +259,6 @@ impl FlowLayouter {
self.full = self.regions.current; self.full = self.regions.current;
self.used = Size::zero(); self.used = Size::zero();
self.fr = Fractional::zero(); self.fr = Fractional::zero();
self.leading = false;
self.finished.push(output.constrain(cts)); self.finished.push(output.constrain(cts));
} }

8
src/library/grid.rs
View File

@ -10,7 +10,7 @@ pub struct GridNode {
/// Defines sizing of gutter rows and columns between content. /// Defines sizing of gutter rows and columns between content.
pub gutter: Spec<Vec<TrackSizing>>, pub gutter: Spec<Vec<TrackSizing>>,
/// The nodes to be arranged in a grid. /// The nodes to be arranged in a grid.
pub children: Vec<PackedNode>, pub children: Vec<LayoutNode>,
} }
#[class] #[class]
@ -92,7 +92,7 @@ castable! {
/// Performs grid layout. /// Performs grid layout.
pub struct GridLayouter<'a> { pub struct GridLayouter<'a> {
/// The grid cells. /// The grid cells.
cells: &'a [PackedNode], cells: &'a [LayoutNode],
/// The column tracks including gutter tracks. /// The column tracks including gutter tracks.
cols: Vec<TrackSizing>, cols: Vec<TrackSizing>,
/// The row tracks including gutter tracks. /// The row tracks including gutter tracks.
@ -136,7 +136,7 @@ impl<'a> GridLayouter<'a> {
pub fn new( pub fn new(
tracks: Spec<&[TrackSizing]>, tracks: Spec<&[TrackSizing]>,
gutter: Spec<&[TrackSizing]>, gutter: Spec<&[TrackSizing]>,
cells: &'a [PackedNode], cells: &'a [LayoutNode],
regions: &Regions, regions: &Regions,
styles: StyleChain<'a>, styles: StyleChain<'a>,
) -> Self { ) -> Self {
@ -606,7 +606,7 @@ impl<'a> GridLayouter<'a> {
/// ///
/// Returns `None` if it's a gutter cell. /// Returns `None` if it's a gutter cell.
#[track_caller] #[track_caller]
fn cell(&self, x: usize, y: usize) -> Option<&'a PackedNode> { fn cell(&self, x: usize, y: usize) -> Option<&'a LayoutNode> {
assert!(x < self.cols.len()); assert!(x < self.cols.len());
assert!(y < self.rows.len()); assert!(y < self.rows.len());

80
src/library/heading.rs
View File

@ -9,8 +9,8 @@ pub struct HeadingNode {
/// The logical nesting depth of the section, starting from one. In the /// The logical nesting depth of the section, starting from one. In the
/// default style, this controls the text size of the heading. /// default style, this controls the text size of the heading.
pub level: usize, pub level: usize,
/// The node that produces the heading's contents. /// The heading's contents.
pub child: PackedNode, pub body: Template,
} }
#[class] #[class]
@ -23,70 +23,76 @@ impl HeadingNode {
/// The fill color of text in the heading. Just the surrounding text color /// The fill color of text in the heading. Just the surrounding text color
/// if `auto`. /// if `auto`.
pub const FILL: Smart<Paint> = Smart::Auto; pub const FILL: Smart<Paint> = Smart::Auto;
/// Whether text in the heading is strengthend.
pub const STRONG: bool = true;
/// Whether text in the heading is emphasized.
pub const EMPH: bool = false;
/// Whether the heading is underlined.
pub const UNDERLINE: bool = false;
/// The extra padding above the heading. /// The extra padding above the heading.
pub const ABOVE: Length = Length::zero(); pub const ABOVE: Length = Length::zero();
/// The extra padding below the heading. /// The extra padding below the heading.
pub const BELOW: Length = Length::zero(); pub const BELOW: Length = Length::zero();
fn construct(_: &mut EvalContext, args: &mut Args) -> TypResult<Template> { fn construct(_: &mut EvalContext, args: &mut Args) -> TypResult<Template> {
Ok(Template::block(Self { Ok(Template::show(Self {
child: args.expect("body")?, body: args.expect("body")?,
level: args.named("level")?.unwrap_or(1), level: args.named("level")?.unwrap_or(1),
})) }))
} }
fn set(args: &mut Args, styles: &mut StyleMap) -> TypResult<()> {
styles.set_opt(Self::FAMILY, args.named("family")?);
styles.set_opt(Self::SIZE, args.named("size")?);
styles.set_opt(Self::FILL, args.named("fill")?);
styles.set_opt(Self::ABOVE, args.named("above")?);
styles.set_opt(Self::BELOW, args.named("below")?);
Ok(())
}
} }
impl Layout for HeadingNode { impl Show for HeadingNode {
fn layout( fn show(&self, styles: StyleChain) -> Template {
&self, let mut map = StyleMap::new();
ctx: &mut LayoutContext,
regions: &Regions,
styles: StyleChain,
) -> Vec<Constrained<Arc<Frame>>> {
let upscale = (1.6 - 0.1 * self.level as f64).max(0.75);
let mut passed = StyleMap::new(); let upscale = (1.6 - 0.1 * self.level as f64).max(0.75);
passed.set(TextNode::STRONG, true); map.set(
passed.set(
TextNode::SIZE, TextNode::SIZE,
styles.get(Self::SIZE).unwrap_or(Relative::new(upscale).into()), styles.get(Self::SIZE).unwrap_or(Relative::new(upscale).into()),
); );
if let Smart::Custom(family) = styles.get_ref(Self::FAMILY) { if let Smart::Custom(family) = styles.get_ref(Self::FAMILY) {
passed.set( map.set(
TextNode::FAMILY_LIST, TextNode::FAMILY,
std::iter::once(family) std::iter::once(family)
.chain(styles.get_ref(TextNode::FAMILY_LIST)) .chain(styles.get_ref(TextNode::FAMILY))
.cloned() .cloned()
.collect(), .collect(),
); );
} }
if let Smart::Custom(fill) = styles.get(Self::FILL) { if let Smart::Custom(fill) = styles.get(Self::FILL) {
passed.set(TextNode::FILL, fill); map.set(TextNode::FILL, fill);
} }
let mut frames = self.child.layout(ctx, regions, passed.chain(&styles)); if styles.get(Self::STRONG) {
map.set(TextNode::STRONG, true);
}
if styles.get(Self::EMPH) {
map.set(TextNode::EMPH, true);
}
let mut body = self.body.clone();
if styles.get(Self::UNDERLINE) {
body = body.underlined();
}
let mut seq = vec![];
let above = styles.get(Self::ABOVE); let above = styles.get(Self::ABOVE);
let below = styles.get(Self::BELOW); if !above.is_zero() {
seq.push(Template::Vertical(above.into()));
// FIXME: Constraints and region size.
for Constrained { item: frame, .. } in &mut frames {
let frame = Arc::make_mut(frame);
frame.size.y += above + below;
frame.translate(Point::with_y(above));
} }
frames seq.push(body);
let below = styles.get(Self::BELOW);
if !below.is_zero() {
seq.push(Template::Vertical(below.into()));
}
Template::block(Template::sequence(seq).styled_with_map(map))
} }
} }

2
src/library/hide.rs
View File

@ -4,7 +4,7 @@ use super::prelude::*;
/// Hide a node without affecting layout. /// Hide a node without affecting layout.
#[derive(Debug, Hash)] #[derive(Debug, Hash)]
pub struct HideNode(pub PackedNode); pub struct HideNode(pub LayoutNode);
#[class] #[class]
impl HideNode { impl HideNode {

5
src/library/image.rs
View File

@ -31,11 +31,6 @@ impl ImageNode {
ImageNode(id).pack().sized(Spec::new(width, height)), ImageNode(id).pack().sized(Spec::new(width, height)),
)) ))
} }
fn set(args: &mut Args, styles: &mut StyleMap) -> TypResult<()> {
styles.set_opt(Self::FIT, args.named("fit")?);
Ok(())
}
} }
impl Layout for ImageNode { impl Layout for ImageNode {

34
src/library/link.rs
View File

@ -5,10 +5,22 @@ use super::TextNode;
use crate::util::EcoString; use crate::util::EcoString;
/// Link text and other elements to an URL. /// Link text and other elements to an URL.
pub struct LinkNode; #[derive(Debug, Hash)]
pub struct LinkNode {
/// The url the link points to.
pub url: EcoString,
/// How the link is represented.
pub body: Template,
}
#[class] #[class]
impl LinkNode { impl LinkNode {
/// The fill color of text in the link. Just the surrounding text color
/// if `auto`.
pub const FILL: Smart<Paint> = Smart::Auto;
/// Whether to underline link.
pub const UNDERLINE: bool = true;
fn construct(_: &mut EvalContext, args: &mut Args) -> TypResult<Template> { fn construct(_: &mut EvalContext, args: &mut Args) -> TypResult<Template> {
let url = args.expect::<EcoString>("url")?; let url = args.expect::<EcoString>("url")?;
let body = args.find().unwrap_or_else(|| { let body = args.find().unwrap_or_else(|| {
@ -20,6 +32,24 @@ impl LinkNode {
Template::Text(if shorter { text.into() } else { url.clone() }) Template::Text(if shorter { text.into() } else { url.clone() })
}); });
Ok(body.styled(TextNode::LINK, Some(url))) Ok(Template::show(Self { url, body }))
}
}
impl Show for LinkNode {
fn show(&self, styles: StyleChain) -> Template {
let mut map = StyleMap::new();
map.set(TextNode::LINK, Some(self.url.clone()));
if let Smart::Custom(fill) = styles.get(Self::FILL) {
map.set(TextNode::FILL, fill);
}
let mut body = self.body.clone();
if styles.get(Self::UNDERLINE) {
body = body.underlined();
}
body.styled_with_map(map)
} }
} }

57
src/library/list.rs
View File

@ -5,15 +5,15 @@ use super::{GridNode, TextNode, TrackSizing};
/// An unordered or ordered list. /// An unordered or ordered list.
#[derive(Debug, Hash)] #[derive(Debug, Hash)]
pub struct ListNode<L: ListKind> { pub struct ListNode<L: ListLabel> {
/// The list labelling style -- unordered or ordered. /// The list label -- unordered or ordered with index.
pub kind: L, pub label: L,
/// The node that produces the item's body. /// The node that produces the item's body.
pub child: PackedNode, pub child: LayoutNode,
} }
#[class] #[class]
impl<L: ListKind> ListNode<L> { impl<L: ListLabel> ListNode<L> {
/// The indentation of each item's label. /// The indentation of each item's label.
pub const LABEL_INDENT: Linear = Relative::new(0.0).into(); pub const LABEL_INDENT: Linear = Relative::new(0.0).into();
/// The space between the label and the body of each item. /// The space between the label and the body of each item.
@ -22,29 +22,19 @@ impl<L: ListKind> ListNode<L> {
fn construct(_: &mut EvalContext, args: &mut Args) -> TypResult<Template> { fn construct(_: &mut EvalContext, args: &mut Args) -> TypResult<Template> {
Ok(args Ok(args
.all() .all()
.map(|child: PackedNode| Template::block(Self { kind: L::default(), child })) .enumerate()
.map(|(i, child)| Template::show(Self { label: L::new(1 + i), child }))
.sum()) .sum())
} }
fn set(args: &mut Args, styles: &mut StyleMap) -> TypResult<()> {
styles.set_opt(Self::LABEL_INDENT, args.named("label-indent")?);
styles.set_opt(Self::BODY_INDENT, args.named("body-indent")?);
Ok(())
}
} }
impl<L: ListKind> Layout for ListNode<L> { impl<L: ListLabel> Show for ListNode<L> {
fn layout( fn show(&self, styles: StyleChain) -> Template {
&self,
ctx: &mut LayoutContext,
regions: &Regions,
styles: StyleChain,
) -> Vec<Constrained<Arc<Frame>>> {
let em = styles.get(TextNode::SIZE).abs; let em = styles.get(TextNode::SIZE).abs;
let label_indent = styles.get(Self::LABEL_INDENT).resolve(em); let label_indent = styles.get(Self::LABEL_INDENT).resolve(em);
let body_indent = styles.get(Self::BODY_INDENT).resolve(em); let body_indent = styles.get(Self::BODY_INDENT).resolve(em);
let grid = GridNode { Template::block(GridNode {
tracks: Spec::with_x(vec![ tracks: Spec::with_x(vec![
TrackSizing::Linear(label_indent.into()), TrackSizing::Linear(label_indent.into()),
TrackSizing::Auto, TrackSizing::Auto,
@ -53,19 +43,20 @@ impl<L: ListKind> Layout for ListNode<L> {
]), ]),
gutter: Spec::default(), gutter: Spec::default(),
children: vec![ children: vec![
PackedNode::default(), LayoutNode::default(),
Template::Text(self.kind.label()).pack(), Template::Text(self.label.label()).pack(),
PackedNode::default(), LayoutNode::default(),
self.child.clone(), self.child.clone(),
], ],
}; })
grid.layout(ctx, regions, styles)
} }
} }
/// How to label a list. /// How to label a list.
pub trait ListKind: Debug + Default + Hash + Sync + Send + 'static { pub trait ListLabel: Debug + Default + Hash + Sync + Send + 'static {
/// Create a new list label.
fn new(number: usize) -> Self;
/// Return the item's label. /// Return the item's label.
fn label(&self) -> EcoString; fn label(&self) -> EcoString;
} }
@ -74,7 +65,11 @@ pub trait ListKind: Debug + Default + Hash + Sync + Send + 'static {
#[derive(Debug, Default, Hash)] #[derive(Debug, Default, Hash)]
pub struct Unordered; pub struct Unordered;
impl ListKind for Unordered { impl ListLabel for Unordered {
fn new(_: usize) -> Self {
Self
}
fn label(&self) -> EcoString { fn label(&self) -> EcoString {
'•'.into() '•'.into()
} }
@ -84,7 +79,11 @@ impl ListKind for Unordered {
#[derive(Debug, Default, Hash)] #[derive(Debug, Default, Hash)]
pub struct Ordered(pub Option<usize>); pub struct Ordered(pub Option<usize>);
impl ListKind for Ordered { impl ListLabel for Ordered {
fn new(number: usize) -> Self {
Self(Some(number))
}
fn label(&self) -> EcoString { fn label(&self) -> EcoString {
format_eco!("{}.", self.0.unwrap_or(1)) format_eco!("{}.", self.0.unwrap_or(1))
} }

32
src/library/math.rs Normal file
View File

@ -0,0 +1,32 @@
//! Mathematical formulas.
use super::prelude::*;
/// A mathematical formula.
#[derive(Debug, Hash)]
pub struct MathNode {
/// The formula.
pub formula: EcoString,
/// Whether the formula is display-level.
pub display: bool,
}
#[class]
impl MathNode {
fn construct(_: &mut EvalContext, args: &mut Args) -> TypResult<Template> {
Ok(Template::show(Self {
formula: args.expect("formula")?,
display: args.named("display")?.unwrap_or(false),
}))
}
}
impl Show for MathNode {
fn show(&self, _: StyleChain) -> Template {
let mut template = Template::Text(self.formula.trim().into());
if self.display {
template = Template::Block(template.pack());
}
template.monospaced()
}
}

20
src/library/mod.rs
View File

@ -14,18 +14,20 @@ pub mod hide;
pub mod image; pub mod image;
pub mod link; pub mod link;
pub mod list; pub mod list;
pub mod math;
pub mod pad; pub mod pad;
pub mod page; pub mod page;
pub mod par; pub mod par;
pub mod place; pub mod place;
pub mod raw;
pub mod shape; pub mod shape;
pub mod spacing; pub mod spacing;
pub mod stack; pub mod stack;
pub mod table; pub mod table;
pub mod text; pub mod text;
pub mod transform; pub mod transform;
pub mod utility;
pub mod utility;
pub use self::image::*; pub use self::image::*;
pub use align::*; pub use align::*;
pub use columns::*; pub use columns::*;
@ -37,10 +39,12 @@ pub use heading::*;
pub use hide::*; pub use hide::*;
pub use link::*; pub use link::*;
pub use list::*; pub use list::*;
pub use math::*;
pub use pad::*; pub use pad::*;
pub use page::*; pub use page::*;
pub use par::*; pub use par::*;
pub use place::*; pub use place::*;
pub use raw::*;
pub use shape::*; pub use shape::*;
pub use spacing::*; pub use spacing::*;
pub use stack::*; pub use stack::*;
@ -68,13 +72,13 @@ prelude! {
pub use crate::diag::{At, TypResult}; pub use crate::diag::{At, TypResult};
pub use crate::eval::{ pub use crate::eval::{
Args, Construct, EvalContext, Merge, Property, Scope, Set, Smart, StyleChain, Args, Construct, EvalContext, Merge, Property, Scope, Set, Show, ShowNode, Smart,
StyleMap, StyleVec, Template, Value, StyleChain, StyleMap, StyleVec, Template, Value,
}; };
pub use crate::frame::*; pub use crate::frame::*;
pub use crate::geom::*; pub use crate::geom::*;
pub use crate::layout::{ pub use crate::layout::{
Constrain, Constrained, Constraints, Layout, LayoutContext, PackedNode, Regions, Constrain, Constrained, Constraints, Layout, LayoutContext, LayoutNode, Regions,
}; };
pub use crate::syntax::{Span, Spanned}; pub use crate::syntax::{Span, Spanned};
pub use crate::util::{EcoString, OptionExt}; pub use crate::util::{EcoString, OptionExt};
@ -95,6 +99,8 @@ pub fn new() -> Scope {
std.def_class::<TextNode>("text"); std.def_class::<TextNode>("text");
std.def_class::<StrongNode>("strong"); std.def_class::<StrongNode>("strong");
std.def_class::<EmphNode>("emph"); std.def_class::<EmphNode>("emph");
std.def_class::<RawNode>("raw");
std.def_class::<MathNode>("math");
std.def_class::<DecoNode<Underline>>("underline"); std.def_class::<DecoNode<Underline>>("underline");
std.def_class::<DecoNode<Strikethrough>>("strike"); std.def_class::<DecoNode<Strikethrough>>("strike");
std.def_class::<DecoNode<Overline>>("overline"); std.def_class::<DecoNode<Overline>>("overline");
@ -207,9 +213,9 @@ castable! {
castable! { castable! {
NonZeroUsize, NonZeroUsize,
Expected: "positive integer", Expected: "positive integer",
Value::Int(int) => int Value::Int(int) => Value::Int(int)
.cast::<usize>()?
.try_into() .try_into()
.and_then(usize::try_into)
.map_err(|_| "must be positive")?, .map_err(|_| "must be positive")?,
} }
@ -226,7 +232,7 @@ castable! {
} }
castable! { castable! {
PackedNode, LayoutNode,
Expected: "template", Expected: "template",
Value::Template(template) => template.pack(), Value::Template(template) => template.pack(),
} }

4
src/library/pad.rs
View File

@ -8,7 +8,7 @@ pub struct PadNode {
/// The amount of padding. /// The amount of padding.
pub padding: Sides<Linear>, pub padding: Sides<Linear>,
/// The child node whose sides to pad. /// The child node whose sides to pad.
pub child: PackedNode, pub child: LayoutNode,
} }
#[class] #[class]
@ -19,7 +19,7 @@ impl PadNode {
let top = args.named("top")?; let top = args.named("top")?;
let right = args.named("right")?; let right = args.named("right")?;
let bottom = args.named("bottom")?; let bottom = args.named("bottom")?;
let body: PackedNode = args.expect("body")?; let body: LayoutNode = args.expect("body")?;
let padding = Sides::new( let padding = Sides::new(
left.or(all).unwrap_or_default(), left.or(all).unwrap_or_default(),
top.or(all).unwrap_or_default(), top.or(all).unwrap_or_default(),

296
src/library/page.rs
View File

@ -8,16 +8,14 @@ use super::ColumnsNode;
/// Layouts its child onto one or multiple pages. /// Layouts its child onto one or multiple pages.
#[derive(Clone, PartialEq, Hash)] #[derive(Clone, PartialEq, Hash)]
pub struct PageNode(pub PackedNode); pub struct PageNode(pub LayoutNode);
#[class] #[class]
impl PageNode { impl PageNode {
/// The unflipped width of the page. /// The unflipped width of the page.
pub const WIDTH: Smart<Length> = Smart::Custom(Paper::default().width()); pub const WIDTH: Smart<Length> = Smart::Custom(Paper::A4.width());
/// The unflipped height of the page. /// The unflipped height of the page.
pub const HEIGHT: Smart<Length> = Smart::Custom(Paper::default().height()); pub const HEIGHT: Smart<Length> = Smart::Custom(Paper::A4.height());
/// The class of paper. Defines the default margins.
pub const CLASS: PaperClass = Paper::default().class();
/// Whether the page is flipped into landscape orientation. /// Whether the page is flipped into landscape orientation.
pub const FLIPPED: bool = false; pub const FLIPPED: bool = false;
/// The left margin. /// The left margin.
@ -39,20 +37,12 @@ impl PageNode {
fn set(args: &mut Args, styles: &mut StyleMap) -> TypResult<()> { fn set(args: &mut Args, styles: &mut StyleMap) -> TypResult<()> {
if let Some(paper) = args.named::<Paper>("paper")?.or_else(|| args.find()) { if let Some(paper) = args.named::<Paper>("paper")?.or_else(|| args.find()) {
styles.set(Self::CLASS, paper.class());
styles.set(Self::WIDTH, Smart::Custom(paper.width())); styles.set(Self::WIDTH, Smart::Custom(paper.width()));
styles.set(Self::HEIGHT, Smart::Custom(paper.height())); styles.set(Self::HEIGHT, Smart::Custom(paper.height()));
} }
if let Some(width) = args.named("width")? { styles.set_opt(Self::WIDTH, args.named("width")?);
styles.set(Self::CLASS, PaperClass::Custom); styles.set_opt(Self::HEIGHT, args.named("height")?);
styles.set(Self::WIDTH, width);
}
if let Some(height) = args.named("height")? {
styles.set(Self::CLASS, PaperClass::Custom);
styles.set(Self::HEIGHT, height);
}
let margins = args.named("margins")?; let margins = args.named("margins")?;
styles.set_opt(Self::LEFT, args.named("left")?.or(margins)); styles.set_opt(Self::LEFT, args.named("left")?.or(margins));
@ -80,14 +70,18 @@ impl PageNode {
std::mem::swap(&mut size.x, &mut size.y); std::mem::swap(&mut size.x, &mut size.y);
} }
let mut min = width.min(height);
if min.is_infinite() {
min = Paper::A4.width();
}
// Determine the margins. // Determine the margins.
let class = styles.get(Self::CLASS); let default = Linear::from(0.1190 * min);
let default = class.default_margins();
let padding = Sides { let padding = Sides {
left: styles.get(Self::LEFT).unwrap_or(default.left), left: styles.get(Self::LEFT).unwrap_or(default),
right: styles.get(Self::RIGHT).unwrap_or(default.right), right: styles.get(Self::RIGHT).unwrap_or(default),
top: styles.get(Self::TOP).unwrap_or(default.top), top: styles.get(Self::TOP).unwrap_or(default),
bottom: styles.get(Self::BOTTOM).unwrap_or(default.bottom), bottom: styles.get(Self::BOTTOM).unwrap_or(default),
}; };
let mut child = self.0.clone(); let mut child = self.0.clone();
@ -138,8 +132,6 @@ impl PagebreakNode {
/// Specification of a paper. /// Specification of a paper.
#[derive(Debug, Copy, Clone)] #[derive(Debug, Copy, Clone)]
pub struct Paper { pub struct Paper {
/// The broad class this paper belongs to.
class: PaperClass,
/// The width of the paper in millimeters. /// The width of the paper in millimeters.
width: f64, width: f64,
/// The height of the paper in millimeters. /// The height of the paper in millimeters.
@ -147,11 +139,6 @@ pub struct Paper {
} }
impl Paper { impl Paper {
/// The class of the paper.
pub fn class(self) -> PaperClass {
self.class
}
/// The width of the paper. /// The width of the paper.
pub fn width(self) -> Length { pub fn width(self) -> Length {
Length::mm(self.width) Length::mm(self.width)
@ -163,24 +150,14 @@ impl Paper {
} }
} }
impl Default for Paper {
fn default() -> Self {
Paper::A4
}
}
/// Defines paper constants and a paper parsing implementation. /// Defines paper constants and a paper parsing implementation.
macro_rules! papers { macro_rules! papers {
($(($var:ident: $class:ident, $width:expr, $height: expr, $($pats:tt)*))*) => { ($(($var:ident: $width:expr, $height: expr, $($pats:tt)*))*) => {
/// Predefined papers. /// Predefined papers.
/// ///
/// Each paper is parsable from its name in kebab-case. /// Each paper is parsable from its name in kebab-case.
impl Paper { impl Paper {
$(pub const $var: Self = Self { $(pub const $var: Self = Self { width: $width, height: $height };)*
class: PaperClass::$class,
width: $width,
height: $height,
};)*
} }
impl FromStr for Paper { impl FromStr for Paper {
@ -206,149 +183,149 @@ macro_rules! papers {
papers! { papers! {
// ---------------------------------------------------------------------- // // ---------------------------------------------------------------------- //
// ISO 216 A Series // ISO 216 A Series
(A0: Base, 841.0, 1189.0, "a0") (A0: 841.0, 1189.0, "a0")
(A1: Base, 594.0, 841.0, "a1") (A1: 594.0, 841.0, "a1")
(A2: Base, 420.0, 594.0, "a2") (A2: 420.0, 594.0, "a2")
(A3: Base, 297.0, 420.0, "a3") (A3: 297.0, 420.0, "a3")
(A4: Base, 210.0, 297.0, "a4") (A4: 210.0, 297.0, "a4")
(A5: Base, 148.0, 210.0, "a5") (A5: 148.0, 210.0, "a5")
(A6: Book, 105.0, 148.0, "a6") (A6: 105.0, 148.0, "a6")
(A7: Base, 74.0, 105.0, "a7") (A7: 74.0, 105.0, "a7")
(A8: Base, 52.0, 74.0, "a8") (A8: 52.0, 74.0, "a8")
(A9: Base, 37.0, 52.0, "a9") (A9: 37.0, 52.0, "a9")
(A10: Base, 26.0, 37.0, "a10") (A10: 26.0, 37.0, "a10")
(A11: Base, 18.0, 26.0, "a11") (A11: 18.0, 26.0, "a11")
// ISO 216 B Series // ISO 216 B Series
(ISO_B1: Base, 707.0, 1000.0, "iso-b1") (ISO_B1: 707.0, 1000.0, "iso-b1")
(ISO_B2: Base, 500.0, 707.0, "iso-b2") (ISO_B2: 500.0, 707.0, "iso-b2")
(ISO_B3: Base, 353.0, 500.0, "iso-b3") (ISO_B3: 353.0, 500.0, "iso-b3")
(ISO_B4: Base, 250.0, 353.0, "iso-b4") (ISO_B4: 250.0, 353.0, "iso-b4")
(ISO_B5: Book, 176.0, 250.0, "iso-b5") (ISO_B5: 176.0, 250.0, "iso-b5")
(ISO_B6: Book, 125.0, 176.0, "iso-b6") (ISO_B6: 125.0, 176.0, "iso-b6")
(ISO_B7: Base, 88.0, 125.0, "iso-b7") (ISO_B7: 88.0, 125.0, "iso-b7")
(ISO_B8: Base, 62.0, 88.0, "iso-b8") (ISO_B8: 62.0, 88.0, "iso-b8")
// ISO 216 C Series // ISO 216 C Series
(ISO_C3: Base, 324.0, 458.0, "iso-c3") (ISO_C3: 324.0, 458.0, "iso-c3")
(ISO_C4: Base, 229.0, 324.0, "iso-c4") (ISO_C4: 229.0, 324.0, "iso-c4")
(ISO_C5: Base, 162.0, 229.0, "iso-c5") (ISO_C5: 162.0, 229.0, "iso-c5")
(ISO_C6: Base, 114.0, 162.0, "iso-c6") (ISO_C6: 114.0, 162.0, "iso-c6")
(ISO_C7: Base, 81.0, 114.0, "iso-c7") (ISO_C7: 81.0, 114.0, "iso-c7")
(ISO_C8: Base, 57.0, 81.0, "iso-c8") (ISO_C8: 57.0, 81.0, "iso-c8")
// DIN D Series (extension to ISO) // DIN D Series (extension to ISO)
(DIN_D3: Base, 272.0, 385.0, "din-d3") (DIN_D3: 272.0, 385.0, "din-d3")
(DIN_D4: Base, 192.0, 272.0, "din-d4") (DIN_D4: 192.0, 272.0, "din-d4")
(DIN_D5: Base, 136.0, 192.0, "din-d5") (DIN_D5: 136.0, 192.0, "din-d5")
(DIN_D6: Base, 96.0, 136.0, "din-d6") (DIN_D6: 96.0, 136.0, "din-d6")
(DIN_D7: Base, 68.0, 96.0, "din-d7") (DIN_D7: 68.0, 96.0, "din-d7")
(DIN_D8: Base, 48.0, 68.0, "din-d8") (DIN_D8: 48.0, 68.0, "din-d8")
// SIS (used in academia) // SIS (used in academia)
(SIS_G5: Base, 169.0, 239.0, "sis-g5") (SIS_G5: 169.0, 239.0, "sis-g5")
(SIS_E5: Base, 115.0, 220.0, "sis-e5") (SIS_E5: 115.0, 220.0, "sis-e5")
// ANSI Extensions // ANSI Extensions
(ANSI_A: Base, 216.0, 279.0, "ansi-a") (ANSI_A: 216.0, 279.0, "ansi-a")
(ANSI_B: Base, 279.0, 432.0, "ansi-b") (ANSI_B: 279.0, 432.0, "ansi-b")
(ANSI_C: Base, 432.0, 559.0, "ansi-c") (ANSI_C: 432.0, 559.0, "ansi-c")
(ANSI_D: Base, 559.0, 864.0, "ansi-d") (ANSI_D: 559.0, 864.0, "ansi-d")
(ANSI_E: Base, 864.0, 1118.0, "ansi-e") (ANSI_E: 864.0, 1118.0, "ansi-e")
// ANSI Architectural Paper // ANSI Architectural Paper
(ARCH_A: Base, 229.0, 305.0, "arch-a") (ARCH_A: 229.0, 305.0, "arch-a")
(ARCH_B: Base, 305.0, 457.0, "arch-b") (ARCH_B: 305.0, 457.0, "arch-b")
(ARCH_C: Base, 457.0, 610.0, "arch-c") (ARCH_C: 457.0, 610.0, "arch-c")
(ARCH_D: Base, 610.0, 914.0, "arch-d") (ARCH_D: 610.0, 914.0, "arch-d")
(ARCH_E1: Base, 762.0, 1067.0, "arch-e1") (ARCH_E1: 762.0, 1067.0, "arch-e1")
(ARCH_E: Base, 914.0, 1219.0, "arch-e") (ARCH_E: 914.0, 1219.0, "arch-e")
// JIS B Series // JIS B Series
(JIS_B0: Base, 1030.0, 1456.0, "jis-b0") (JIS_B0: 1030.0, 1456.0, "jis-b0")
(JIS_B1: Base, 728.0, 1030.0, "jis-b1") (JIS_B1: 728.0, 1030.0, "jis-b1")
(JIS_B2: Base, 515.0, 728.0, "jis-b2") (JIS_B2: 515.0, 728.0, "jis-b2")
(JIS_B3: Base, 364.0, 515.0, "jis-b3") (JIS_B3: 364.0, 515.0, "jis-b3")
(JIS_B4: Base, 257.0, 364.0, "jis-b4") (JIS_B4: 257.0, 364.0, "jis-b4")
(JIS_B5: Base, 182.0, 257.0, "jis-b5") (JIS_B5: 182.0, 257.0, "jis-b5")
(JIS_B6: Base, 128.0, 182.0, "jis-b6") (JIS_B6: 128.0, 182.0, "jis-b6")
(JIS_B7: Base, 91.0, 128.0, "jis-b7") (JIS_B7: 91.0, 128.0, "jis-b7")
(JIS_B8: Base, 64.0, 91.0, "jis-b8") (JIS_B8: 64.0, 91.0, "jis-b8")
(JIS_B9: Base, 45.0, 64.0, "jis-b9") (JIS_B9: 45.0, 64.0, "jis-b9")
(JIS_B10: Base, 32.0, 45.0, "jis-b10") (JIS_B10: 32.0, 45.0, "jis-b10")
(JIS_B11: Base, 22.0, 32.0, "jis-b11") (JIS_B11: 22.0, 32.0, "jis-b11")
// SAC D Series // SAC D Series
(SAC_D0: Base, 764.0, 1064.0, "sac-d0") (SAC_D0: 764.0, 1064.0, "sac-d0")
(SAC_D1: Base, 532.0, 760.0, "sac-d1") (SAC_D1: 532.0, 760.0, "sac-d1")
(SAC_D2: Base, 380.0, 528.0, "sac-d2") (SAC_D2: 380.0, 528.0, "sac-d2")
(SAC_D3: Base, 264.0, 376.0, "sac-d3") (SAC_D3: 264.0, 376.0, "sac-d3")
(SAC_D4: Base, 188.0, 260.0, "sac-d4") (SAC_D4: 188.0, 260.0, "sac-d4")
(SAC_D5: Base, 130.0, 184.0, "sac-d5") (SAC_D5: 130.0, 184.0, "sac-d5")
(SAC_D6: Base, 92.0, 126.0, "sac-d6") (SAC_D6: 92.0, 126.0, "sac-d6")
// ISO 7810 ID // ISO 7810 ID
(ISO_ID_1: Base, 85.6, 53.98, "iso-id-1") (ISO_ID_1: 85.6, 53.98, "iso-id-1")
(ISO_ID_2: Base, 74.0, 105.0, "iso-id-2") (ISO_ID_2: 74.0, 105.0, "iso-id-2")
(ISO_ID_3: Base, 88.0, 125.0, "iso-id-3") (ISO_ID_3: 88.0, 125.0, "iso-id-3")
// ---------------------------------------------------------------------- // // ---------------------------------------------------------------------- //
// Asia // Asia
(ASIA_F4: Base, 210.0, 330.0, "asia-f4") (ASIA_F4: 210.0, 330.0, "asia-f4")
// Japan // Japan
(JP_SHIROKU_BAN_4: Base, 264.0, 379.0, "jp-shiroku-ban-4") (JP_SHIROKU_BAN_4: 264.0, 379.0, "jp-shiroku-ban-4")
(JP_SHIROKU_BAN_5: Base, 189.0, 262.0, "jp-shiroku-ban-5") (JP_SHIROKU_BAN_5: 189.0, 262.0, "jp-shiroku-ban-5")
(JP_SHIROKU_BAN_6: Base, 127.0, 188.0, "jp-shiroku-ban-6") (JP_SHIROKU_BAN_6: 127.0, 188.0, "jp-shiroku-ban-6")
(JP_KIKU_4: Base, 227.0, 306.0, "jp-kiku-4") (JP_KIKU_4: 227.0, 306.0, "jp-kiku-4")
(JP_KIKU_5: Base, 151.0, 227.0, "jp-kiku-5") (JP_KIKU_5: 151.0, 227.0, "jp-kiku-5")
(JP_BUSINESS_CARD: Base, 91.0, 55.0, "jp-business-card") (JP_BUSINESS_CARD: 91.0, 55.0, "jp-business-card")
// China // China
(CN_BUSINESS_CARD: Base, 90.0, 54.0, "cn-business-card") (CN_BUSINESS_CARD: 90.0, 54.0, "cn-business-card")
// Europe // Europe
(EU_BUSINESS_CARD: Base, 85.0, 55.0, "eu-business-card") (EU_BUSINESS_CARD: 85.0, 55.0, "eu-business-card")
// French Traditional (AFNOR) // French Traditional (AFNOR)
(FR_TELLIERE: Base, 340.0, 440.0, "fr-tellière") (FR_TELLIERE: 340.0, 440.0, "fr-tellière")
(FR_COURONNE_ECRITURE: Base, 360.0, 460.0, "fr-couronne-écriture") (FR_COURONNE_ECRITURE: 360.0, 460.0, "fr-couronne-écriture")
(FR_COURONNE_EDITION: Base, 370.0, 470.0, "fr-couronne-édition") (FR_COURONNE_EDITION: 370.0, 470.0, "fr-couronne-édition")
(FR_RAISIN: Base, 500.0, 650.0, "fr-raisin") (FR_RAISIN: 500.0, 650.0, "fr-raisin")
(FR_CARRE: Base, 450.0, 560.0, "fr-carré") (FR_CARRE: 450.0, 560.0, "fr-carré")
(FR_JESUS: Base, 560.0, 760.0, "fr-jésus") (FR_JESUS: 560.0, 760.0, "fr-jésus")
// United Kingdom Imperial // United Kingdom Imperial
(UK_BRIEF: Base, 406.4, 342.9, "uk-brief") (UK_BRIEF: 406.4, 342.9, "uk-brief")
(UK_DRAFT: Base, 254.0, 406.4, "uk-draft") (UK_DRAFT: 254.0, 406.4, "uk-draft")
(UK_FOOLSCAP: Base, 203.2, 330.2, "uk-foolscap") (UK_FOOLSCAP: 203.2, 330.2, "uk-foolscap")
(UK_QUARTO: Base, 203.2, 254.0, "uk-quarto") (UK_QUARTO: 203.2, 254.0, "uk-quarto")
(UK_CROWN: Base, 508.0, 381.0, "uk-crown") (UK_CROWN: 508.0, 381.0, "uk-crown")
(UK_BOOK_A: Book, 111.0, 178.0, "uk-book-a") (UK_BOOK_A: 111.0, 178.0, "uk-book-a")
(UK_BOOK_B: Book, 129.0, 198.0, "uk-book-b") (UK_BOOK_B: 129.0, 198.0, "uk-book-b")
// Unites States // Unites States
(US_LETTER: US, 215.9, 279.4, "us-letter") (US_LETTER: 215.9, 279.4, "us-letter")
(US_LEGAL: US, 215.9, 355.6, "us-legal") (US_LEGAL: 215.9, 355.6, "us-legal")
(US_TABLOID: US, 279.4, 431.8, "us-tabloid") (US_TABLOID: 279.4, 431.8, "us-tabloid")
(US_EXECUTIVE: US, 184.15, 266.7, "us-executive") (US_EXECUTIVE: 84.15, 266.7, "us-executive")
(US_FOOLSCAP_FOLIO: US, 215.9, 342.9, "us-foolscap-folio") (US_FOOLSCAP_FOLIO: 215.9, 342.9, "us-foolscap-folio")
(US_STATEMENT: US, 139.7, 215.9, "us-statement") (US_STATEMENT: 139.7, 215.9, "us-statement")
(US_LEDGER: US, 431.8, 279.4, "us-ledger") (US_LEDGER: 431.8, 279.4, "us-ledger")
(US_OFICIO: US, 215.9, 340.36, "us-oficio") (US_OFICIO: 215.9, 340.36, "us-oficio")
(US_GOV_LETTER: US, 203.2, 266.7, "us-gov-letter") (US_GOV_LETTER: 203.2, 266.7, "us-gov-letter")
(US_GOV_LEGAL: US, 215.9, 330.2, "us-gov-legal") (US_GOV_LEGAL: 215.9, 330.2, "us-gov-legal")
(US_BUSINESS_CARD: Base, 88.9, 50.8, "us-business-card") (US_BUSINESS_CARD: 88.9, 50.8, "us-business-card")
(US_DIGEST: Book, 139.7, 215.9, "us-digest") (US_DIGEST: 139.7, 215.9, "us-digest")
(US_TRADE: Book, 152.4, 228.6, "us-trade") (US_TRADE: 152.4, 228.6, "us-trade")
// ---------------------------------------------------------------------- // // ---------------------------------------------------------------------- //
// Other // Other
(NEWSPAPER_COMPACT: Newspaper, 280.0, 430.0, "newspaper-compact") (NEWSPAPER_COMPACT: 280.0, 430.0, "newspaper-compact")
(NEWSPAPER_BERLINER: Newspaper, 315.0, 470.0, "newspaper-berliner") (NEWSPAPER_BERLINER: 315.0, 470.0, "newspaper-berliner")
(NEWSPAPER_BROADSHEET: Newspaper, 381.0, 578.0, "newspaper-broadsheet") (NEWSPAPER_BROADSHEET: 381.0, 578.0, "newspaper-broadsheet")
(PRESENTATION_16_9: Base, 297.0, 167.0625, "presentation-16-9") (PRESENTATION_16_9: 297.0, 167.0625, "presentation-16-9")
(PRESENTATION_4_3: Base, 280.0, 210.0, "presentation-4-3") (PRESENTATION_4_3: 280.0, 210.0, "presentation-4-3")
} }
castable! { castable! {
@ -357,31 +334,6 @@ castable! {
Value::Str(string) => Paper::from_str(&string).map_err(|e| e.to_string())?, Value::Str(string) => Paper::from_str(&string).map_err(|e| e.to_string())?,
} }
/// Defines default margins for a class of related papers.
#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
pub enum PaperClass {
Custom,
Base,
US,
Newspaper,
Book,
}
impl PaperClass {
/// The default margins for this page class.
fn default_margins(self) -> Sides<Linear> {
let f = |r| Relative::new(r).into();
let s = |l, t, r, b| Sides::new(f(l), f(t), f(r), f(b));
match self {
Self::Custom => s(0.1190, 0.0842, 0.1190, 0.0842),
Self::Base => s(0.1190, 0.0842, 0.1190, 0.0842),
Self::US => s(0.1760, 0.1092, 0.1760, 0.0910),
Self::Newspaper => s(0.0455, 0.0587, 0.0455, 0.0294),
Self::Book => s(0.1200, 0.0852, 0.1500, 0.0965),
}
}
}
/// The error when parsing a [`Paper`] from a string fails. /// The error when parsing a [`Paper`] from a string fails.
#[derive(Debug, Copy, Clone, Eq, PartialEq)] #[derive(Debug, Copy, Clone, Eq, PartialEq)]
pub struct PaperError; pub struct PaperError;

2
src/library/par.rs
View File

@ -22,7 +22,7 @@ pub enum ParChild {
/// Horizontal spacing between other children. /// Horizontal spacing between other children.
Spacing(SpacingKind), Spacing(SpacingKind),
/// An arbitrary inline-level node. /// An arbitrary inline-level node.
Node(PackedNode), Node(LayoutNode),
} }
#[class] #[class]

4
src/library/place.rs
View File

@ -5,7 +5,7 @@ use super::AlignNode;
/// Place a node at an absolute position. /// Place a node at an absolute position.
#[derive(Debug, Hash)] #[derive(Debug, Hash)]
pub struct PlaceNode(pub PackedNode); pub struct PlaceNode(pub LayoutNode);
#[class] #[class]
impl PlaceNode { impl PlaceNode {
@ -13,7 +13,7 @@ impl PlaceNode {
let aligns = args.find().unwrap_or(Spec::with_x(Some(Align::Left))); let aligns = args.find().unwrap_or(Spec::with_x(Some(Align::Left)));
let tx = args.named("dx")?.unwrap_or_default(); let tx = args.named("dx")?.unwrap_or_default();
let ty = args.named("dy")?.unwrap_or_default(); let ty = args.named("dy")?.unwrap_or_default();
let body: PackedNode = args.expect("body")?; let body: LayoutNode = args.expect("body")?;
Ok(Template::block(Self( Ok(Template::block(Self(
body.moved(Point::new(tx, ty)).aligned(aligns), body.moved(Point::new(tx, ty)).aligned(aligns),
))) )))

117
src/library/raw.rs Normal file
View File

@ -0,0 +1,117 @@
//! Monospaced text and code.
use once_cell::sync::Lazy;
use syntect::easy::HighlightLines;
use syntect::highlighting::{FontStyle, Highlighter, Style, Theme, ThemeSet};
use syntect::parsing::SyntaxSet;
use super::prelude::*;
use crate::library::TextNode;
use crate::source::SourceId;
use crate::syntax::{self, RedNode};
/// The lazily-loaded theme used for syntax highlighting.
static THEME: Lazy<Theme> =
Lazy::new(|| ThemeSet::load_defaults().themes.remove("InspiredGitHub").unwrap());
/// The lazily-loaded syntect syntax definitions.
static SYNTAXES: Lazy<SyntaxSet> = Lazy::new(|| SyntaxSet::load_defaults_newlines());
/// Monospaced text with optional syntax highlighting.
#[derive(Debug, Hash)]
pub struct RawNode {
/// The raw text.
pub text: EcoString,
/// Whether the node is block-level.
pub block: bool,
}
#[class]
impl RawNode {
/// The language to syntax-highlight in.
pub const LANG: Option<EcoString> = None;
fn construct(_: &mut EvalContext, args: &mut Args) -> TypResult<Template> {
Ok(Template::show(Self {
text: args.expect("text")?,
block: args.named("block")?.unwrap_or(false),
}))
}
}
impl Show for RawNode {
fn show(&self, styles: StyleChain) -> Template {
let lang = styles.get_ref(Self::LANG).as_ref();
let foreground = THEME
.settings
.foreground
.map(Color::from)
.unwrap_or(Color::BLACK)
.into();
let mut template = if matches!(
lang.map(|s| s.to_lowercase()).as_deref(),
Some("typ" | "typst")
) {
let mut seq = vec![];
let green = crate::parse::parse(&self.text);
let red = RedNode::from_root(green, SourceId::from_raw(0));
let highlighter = Highlighter::new(&THEME);
syntax::highlight_syntect(red.as_ref(), &highlighter, &mut |range, style| {
seq.push(styled(&self.text[range], foreground, style));
});
Template::sequence(seq)
} else if let Some(syntax) =
lang.and_then(|token| SYNTAXES.find_syntax_by_token(&token))
{
let mut seq = vec![];
let mut highlighter = HighlightLines::new(syntax, &THEME);
for (i, line) in self.text.lines().enumerate() {
if i != 0 {
seq.push(Template::Linebreak);
}
for (style, piece) in highlighter.highlight(line, &SYNTAXES) {
seq.push(styled(piece, foreground, style));
}
}
Template::sequence(seq)
} else {
Template::Text(self.text.clone())
};
if self.block {
template = Template::Block(template.pack());
}
template.monospaced()
}
}
/// Style a piece of text with a syntect style.
fn styled(piece: &str, foreground: Paint, style: Style) -> Template {
let mut styles = StyleMap::new();
let mut body = Template::Text(piece.into());
let paint = style.foreground.into();
if paint != foreground {
styles.set(TextNode::FILL, paint);
}
if style.font_style.contains(FontStyle::BOLD) {
styles.set(TextNode::STRONG, true);
}
if style.font_style.contains(FontStyle::ITALIC) {
styles.set(TextNode::EMPH, true);
}
if style.font_style.contains(FontStyle::UNDERLINE) {
body = body.underlined();
}
body.styled_with_map(styles)
}

10
src/library/shape.rs
View File

@ -11,7 +11,7 @@ pub struct ShapeNode<S: ShapeKind> {
/// Which shape to place the child into. /// Which shape to place the child into.
pub kind: S, pub kind: S,
/// The child node to place into the shape, if any. /// The child node to place into the shape, if any.
pub child: Option<PackedNode>, pub child: Option<LayoutNode>,
} }
#[class] #[class]
@ -50,14 +50,6 @@ impl<S: ShapeKind> ShapeNode<S> {
.sized(Spec::new(width, height)), .sized(Spec::new(width, height)),
)) ))
} }
fn set(args: &mut Args, styles: &mut StyleMap) -> TypResult<()> {
styles.set_opt(Self::FILL, args.named("fill")?);
styles.set_opt(Self::STROKE, args.named("stroke")?);
styles.set_opt(Self::THICKNESS, args.named("thickness")?);
styles.set_opt(Self::PADDING, args.named("padding")?);
Ok(())
}
} }
impl<S: ShapeKind> Layout for ShapeNode<S> { impl<S: ShapeKind> Layout for ShapeNode<S> {

6
src/library/spacing.rs
View File

@ -38,6 +38,12 @@ impl SpacingKind {
} }
} }
impl From<Length> for SpacingKind {
fn from(length: Length) -> Self {
Self::Linear(length.into())
}
}
castable! { castable! {
SpacingKind, SpacingKind,
Expected: "linear or fractional", Expected: "linear or fractional",

4
src/library/stack.rs
View File

@ -64,7 +64,7 @@ pub enum StackChild {
/// Spacing between other nodes. /// Spacing between other nodes.
Spacing(SpacingKind), Spacing(SpacingKind),
/// An arbitrary node. /// An arbitrary node.
Node(PackedNode), Node(LayoutNode),
} }
impl Debug for StackChild { impl Debug for StackChild {
@ -166,7 +166,7 @@ impl StackLayouter {
pub fn layout_node( pub fn layout_node(
&mut self, &mut self,
ctx: &mut LayoutContext, ctx: &mut LayoutContext,
node: &PackedNode, node: &LayoutNode,
styles: StyleChain, styles: StyleChain,
) { ) {
if self.regions.is_full() { if self.regions.is_full() {

19
src/library/table.rs
View File

@ -11,7 +11,7 @@ pub struct TableNode {
/// Defines sizing of gutter rows and columns between content. /// Defines sizing of gutter rows and columns between content.
pub gutter: Spec<Vec<TrackSizing>>, pub gutter: Spec<Vec<TrackSizing>>,
/// The nodes to be arranged in the table. /// The nodes to be arranged in the table.
pub children: Vec<PackedNode>, pub children: Vec<LayoutNode>,
} }
#[class] #[class]
@ -33,7 +33,7 @@ impl TableNode {
let base_gutter: Vec<TrackSizing> = args.named("gutter")?.unwrap_or_default(); let base_gutter: Vec<TrackSizing> = args.named("gutter")?.unwrap_or_default();
let column_gutter = args.named("column-gutter")?; let column_gutter = args.named("column-gutter")?;
let row_gutter = args.named("row-gutter")?; let row_gutter = args.named("row-gutter")?;
Ok(Template::block(Self { Ok(Template::show(Self {
tracks: Spec::new(columns, rows), tracks: Spec::new(columns, rows),
gutter: Spec::new( gutter: Spec::new(
column_gutter.unwrap_or_else(|| base_gutter.clone()), column_gutter.unwrap_or_else(|| base_gutter.clone()),
@ -54,13 +54,8 @@ impl TableNode {
} }
} }
impl Layout for TableNode { impl Show for TableNode {
fn layout( fn show(&self, styles: StyleChain) -> Template {
&self,
ctx: &mut LayoutContext,
regions: &Regions,
styles: StyleChain,
) -> Vec<Constrained<Arc<Frame>>> {
let primary = styles.get(Self::PRIMARY); let primary = styles.get(Self::PRIMARY);
let secondary = styles.get(Self::SECONDARY); let secondary = styles.get(Self::SECONDARY);
let thickness = styles.get(Self::THICKNESS); let thickness = styles.get(Self::THICKNESS);
@ -90,12 +85,10 @@ impl Layout for TableNode {
}) })
.collect(); .collect();
let grid = GridNode { Template::block(GridNode {
tracks: self.tracks.clone(), tracks: self.tracks.clone(),
gutter: self.gutter.clone(), gutter: self.gutter.clone(),
children, children,
}; })
grid.layout(ctx, regions, styles)
} }
} }

125
src/library/text.rs
View File

@ -24,13 +24,14 @@ pub struct TextNode;
#[class] #[class]
impl TextNode { impl TextNode {
/// A prioritized sequence of font families. /// A prioritized sequence of font families.
pub const FAMILY_LIST: Vec<FontFamily> = vec![FontFamily::SansSerif]; #[variadic]
pub const FAMILY: Vec<FontFamily> = vec![FontFamily::SansSerif];
/// The serif font family/families. /// The serif font family/families.
pub const SERIF_LIST: Vec<NamedFamily> = vec![NamedFamily::new("IBM Plex Serif")]; pub const SERIF: Vec<NamedFamily> = vec![NamedFamily::new("IBM Plex Serif")];
/// The sans-serif font family/families. /// The sans-serif font family/families.
pub const SANS_SERIF_LIST: Vec<NamedFamily> = vec![NamedFamily::new("IBM Plex Sans")]; pub const SANS_SERIF: Vec<NamedFamily> = vec![NamedFamily::new("IBM Plex Sans")];
/// The monospace font family/families. /// The monospace font family/families.
pub const MONOSPACE_LIST: Vec<NamedFamily> = vec![NamedFamily::new("IBM Plex Mono")]; pub const MONOSPACE: Vec<NamedFamily> = vec![NamedFamily::new("IBM Plex Mono")];
/// Whether to allow font fallback when the primary font list contains no /// Whether to allow font fallback when the primary font list contains no
/// match. /// match.
pub const FALLBACK: bool = true; pub const FALLBACK: bool = true;
@ -41,23 +42,12 @@ impl TextNode {
pub const WEIGHT: FontWeight = FontWeight::REGULAR; pub const WEIGHT: FontWeight = FontWeight::REGULAR;
/// The width of the glyphs. /// The width of the glyphs.
pub const STRETCH: FontStretch = FontStretch::NORMAL; pub const STRETCH: FontStretch = FontStretch::NORMAL;
/// Whether the font weight should be increased by 300.
#[fold(bool::bitxor)]
pub const STRONG: bool = false;
/// Whether the the font style should be inverted.
#[fold(bool::bitxor)]
pub const EMPH: bool = false;
/// Whether a monospace font should be preferred.
pub const MONOSPACE: bool = false;
/// The glyph fill color. /// The glyph fill color.
#[shorthand]
pub const FILL: Paint = Color::BLACK.into(); pub const FILL: Paint = Color::BLACK.into();
/// Decorative lines.
#[fold(|a, b| a.into_iter().chain(b).collect())]
pub const LINES: Vec<Decoration> = vec![];
/// An URL the text should link to.
pub const LINK: Option<EcoString> = None;
/// The size of the glyphs. /// The size of the glyphs.
#[shorthand]
#[fold(Linear::compose)] #[fold(Linear::compose)]
pub const SIZE: Linear = Length::pt(11.0).into(); pub const SIZE: Linear = Length::pt(11.0).into();
/// The amount of space that should be added between characters. /// The amount of space that should be added between characters.
@ -94,73 +84,64 @@ impl TextNode {
/// Raw OpenType features to apply. /// Raw OpenType features to apply.
pub const FEATURES: Vec<(Tag, u32)> = vec![]; pub const FEATURES: Vec<(Tag, u32)> = vec![];
/// Whether the font weight should be increased by 300.
#[skip]
#[fold(bool::bitxor)]
pub const STRONG: bool = false;
/// Whether the the font style should be inverted.
#[skip]
#[fold(bool::bitxor)]
pub const EMPH: bool = false;
/// Whether a monospace font should be preferred.
#[skip]
pub const MONOSPACED: bool = false;
/// Decorative lines.
#[skip]
#[fold(|a, b| a.into_iter().chain(b).collect())]
pub const LINES: Vec<Decoration> = vec![];
/// An URL the text should link to.
#[skip]
pub const LINK: Option<EcoString> = None;
fn construct(_: &mut EvalContext, args: &mut Args) -> TypResult<Template> { fn construct(_: &mut EvalContext, args: &mut Args) -> TypResult<Template> {
// The text constructor is special: It doesn't create a text node. // The text constructor is special: It doesn't create a text node.
// Instead, it leaves the passed argument structurally unchanged, but // Instead, it leaves the passed argument structurally unchanged, but
// styles all text in it. // styles all text in it.
args.expect("body") args.expect("body")
} }
fn set(args: &mut Args, styles: &mut StyleMap) -> TypResult<()> {
let list = args.named("family")?.or_else(|| {
let families: Vec<_> = args.all().collect();
(!families.is_empty()).then(|| families)
});
styles.set_opt(Self::FAMILY_LIST, list);
styles.set_opt(Self::SERIF_LIST, args.named("serif")?);
styles.set_opt(Self::SANS_SERIF_LIST, args.named("sans-serif")?);
styles.set_opt(Self::MONOSPACE_LIST, args.named("monospace")?);
styles.set_opt(Self::FALLBACK, args.named("fallback")?);
styles.set_opt(Self::STYLE, args.named("style")?);
styles.set_opt(Self::WEIGHT, args.named("weight")?);
styles.set_opt(Self::STRETCH, args.named("stretch")?);
styles.set_opt(Self::FILL, args.named("fill")?.or_else(|| args.find()));
styles.set_opt(Self::SIZE, args.named("size")?.or_else(|| args.find()));
styles.set_opt(Self::TRACKING, args.named("tracking")?.map(Em::new));
styles.set_opt(Self::TOP_EDGE, args.named("top-edge")?);
styles.set_opt(Self::BOTTOM_EDGE, args.named("bottom-edge")?);
styles.set_opt(Self::KERNING, args.named("kerning")?);
styles.set_opt(Self::SMALLCAPS, args.named("smallcaps")?);
styles.set_opt(Self::ALTERNATES, args.named("alternates")?);
styles.set_opt(Self::STYLISTIC_SET, args.named("stylistic-set")?);
styles.set_opt(Self::LIGATURES, args.named("ligatures")?);
styles.set_opt(
Self::DISCRETIONARY_LIGATURES,
args.named("discretionary-ligatures")?,
);
styles.set_opt(
Self::HISTORICAL_LIGATURES,
args.named("historical-ligatures")?,
);
styles.set_opt(Self::NUMBER_TYPE, args.named("number-type")?);
styles.set_opt(Self::NUMBER_WIDTH, args.named("number-width")?);
styles.set_opt(Self::NUMBER_POSITION, args.named("number-position")?);
styles.set_opt(Self::SLASHED_ZERO, args.named("slashed-zero")?);
styles.set_opt(Self::FRACTIONS, args.named("fractions")?);
styles.set_opt(Self::FEATURES, args.named("features")?);
Ok(())
}
} }
/// Strong text, rendered in boldface. /// Strong text, rendered in boldface.
pub struct StrongNode; #[derive(Debug, Hash)]
pub struct StrongNode(pub Template);
#[class] #[class]
impl StrongNode { impl StrongNode {
fn construct(_: &mut EvalContext, args: &mut Args) -> TypResult<Template> { fn construct(_: &mut EvalContext, args: &mut Args) -> TypResult<Template> {
Ok(args.expect::<Template>("body")?.styled(TextNode::STRONG, true)) Ok(Template::show(Self(args.expect("body")?)))
}
}
impl Show for StrongNode {
fn show(&self, _: StyleChain) -> Template {
self.0.clone().styled(TextNode::STRONG, true)
} }
} }
/// Emphasized text, rendered with an italic face. /// Emphasized text, rendered with an italic face.
pub struct EmphNode; #[derive(Debug, Hash)]
pub struct EmphNode(pub Template);
#[class] #[class]
impl EmphNode { impl EmphNode {
fn construct(_: &mut EvalContext, args: &mut Args) -> TypResult<Template> { fn construct(_: &mut EvalContext, args: &mut Args) -> TypResult<Template> {
Ok(args.expect::<Template>("body")?.styled(TextNode::EMPH, true)) Ok(Template::show(Self(args.expect("body")?)))
}
}
impl Show for EmphNode {
fn show(&self, _: StyleChain) -> Template {
self.0.clone().styled(TextNode::EMPH, true)
} }
} }
@ -274,6 +255,12 @@ castable! {
Value::Relative(v) => Self::from_ratio(v.get() as f32), Value::Relative(v) => Self::from_ratio(v.get() as f32),
} }
castable! {
Em,
Expected: "float",
Value::Float(v) => Self::new(v),
}
castable! { castable! {
VerticalFontMetric, VerticalFontMetric,
Expected: "linear or string", Expected: "linear or string",
@ -644,18 +631,18 @@ fn variant(styles: StyleChain) -> FontVariant {
/// Resolve a prioritized iterator over the font families. /// Resolve a prioritized iterator over the font families.
fn families(styles: StyleChain) -> impl Iterator<Item = &str> + Clone { fn families(styles: StyleChain) -> impl Iterator<Item = &str> + Clone {
let head = if styles.get(TextNode::MONOSPACE) { let head = if styles.get(TextNode::MONOSPACED) {
styles.get_ref(TextNode::MONOSPACE_LIST).as_slice() styles.get_ref(TextNode::MONOSPACE).as_slice()
} else { } else {
&[] &[]
}; };
let core = styles.get_ref(TextNode::FAMILY_LIST).iter().flat_map(move |family| { let core = styles.get_ref(TextNode::FAMILY).iter().flat_map(move |family| {
match family { match family {
FontFamily::Named(name) => std::slice::from_ref(name), FontFamily::Named(name) => std::slice::from_ref(name),
FontFamily::Serif => styles.get_ref(TextNode::SERIF_LIST), FontFamily::Serif => styles.get_ref(TextNode::SERIF),
FontFamily::SansSerif => styles.get_ref(TextNode::SANS_SERIF_LIST), FontFamily::SansSerif => styles.get_ref(TextNode::SANS_SERIF),
FontFamily::Monospace => styles.get_ref(TextNode::MONOSPACE_LIST), FontFamily::Monospace => styles.get_ref(TextNode::MONOSPACE),
} }
}); });

7
src/library/transform.rs
View File

@ -9,7 +9,7 @@ pub struct TransformNode<T: TransformKind> {
/// Transformation to apply to the contents. /// Transformation to apply to the contents.
pub kind: T, pub kind: T,
/// The node whose contents should be transformed. /// The node whose contents should be transformed.
pub child: PackedNode, pub child: LayoutNode,
} }
#[class] #[class]
@ -23,11 +23,6 @@ impl<T: TransformKind> TransformNode<T> {
child: args.expect("body")?, child: args.expect("body")?,
})) }))
} }
fn set(args: &mut Args, styles: &mut StyleMap) -> TypResult<()> {
styles.set_opt(Self::ORIGIN, args.named("origin")?);
Ok(())
}
} }
impl<T: TransformKind> Layout for TransformNode<T> { impl<T: TransformKind> Layout for TransformNode<T> {

2
src/util/mod.rs
View File

@ -3,9 +3,11 @@
#[macro_use] #[macro_use]
mod eco_string; mod eco_string;
mod mac_roman; mod mac_roman;
mod prehashed;
pub use eco_string::EcoString; pub use eco_string::EcoString;
pub use mac_roman::decode_mac_roman; pub use mac_roman::decode_mac_roman;
pub use prehashed::Prehashed;
use std::cell::RefMut; use std::cell::RefMut;
use std::cmp::Ordering; use std::cmp::Ordering;

72
src/util/prehashed.rs Normal file
View File

@ -0,0 +1,72 @@
use std::any::Any;
use std::fmt::{self, Debug, Formatter};
use std::hash::{Hash, Hasher};
use std::ops::Deref;
/// A wrapper around a type that precomputes its hash.
#[derive(Copy, Clone)]
pub struct Prehashed<T: ?Sized> {
/// The precomputed hash.
#[cfg(feature = "layout-cache")]
hash: u64,
/// The wrapped item.
item: T,
}
impl<T: Hash + 'static> Prehashed<T> {
/// Compute an item's hash and wrap it.
pub fn new(item: T) -> Self {
Self {
#[cfg(feature = "layout-cache")]
hash: {
// Also hash the TypeId because the type might be converted
// through an unsized coercion.
let mut state = fxhash::FxHasher64::default();
item.type_id().hash(&mut state);
item.hash(&mut state);
state.finish()
},
item,
}
}
/// Return the wrapped value.
pub fn into_iter(self) -> T {
self.item
}
}
impl<T: ?Sized> Deref for Prehashed<T> {
type Target = T;
fn deref(&self) -> &Self::Target {
&self.item
}
}
impl<T: Debug + ?Sized> Debug for Prehashed<T> {
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
self.item.fmt(f)
}
}
impl<T: Hash + ?Sized> Hash for Prehashed<T> {
fn hash<H: Hasher>(&self, state: &mut H) {
// Hash the node.
#[cfg(feature = "layout-cache")]
state.write_u64(self.hash);
#[cfg(not(feature = "layout-cache"))]
self.item.hash(state);
}
}
impl<T: Eq + ?Sized> Eq for Prehashed<T> {}
impl<T: PartialEq + ?Sized> PartialEq for Prehashed<T> {
fn eq(&self, other: &Self) -> bool {
#[cfg(feature = "layout-cache")]
return self.hash == other.hash;
#[cfg(not(feature = "layout-cache"))]
self.item.eq(&other.item)
}
}

BIN
tests/ref/style/construct.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 2.0 KiB

After

Width:  |  Height:  |  Size: 4.5 KiB

BIN
tests/ref/text/links.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 34 KiB

After

Width:  |  Height:  |  Size: 34 KiB

BIN
tests/ref/text/par.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 13 KiB

After

Width:  |  Height:  |  Size: 12 KiB

16
tests/typ/style/construct.typ
View File

@ -2,6 +2,7 @@
--- ---
// Ensure that constructor styles aren't passed down the tree. // Ensure that constructor styles aren't passed down the tree.
// The inner list should have no extra indent.
#set par(leading: 2pt) #set par(leading: 2pt)
#list( #list(
body-indent: 20pt, body-indent: 20pt,
@ -11,7 +12,22 @@
--- ---
// Ensure that constructor styles win, but not over outer styles. // Ensure that constructor styles win, but not over outer styles.
// The outer paragraph should be right-aligned,
// but the B should be center-aligned.
#set par(align: center) #set par(align: center)
#par(align: right)[ #par(align: right)[
A #rect(width: 2cm, fill: conifer, padding: 4pt)[B] A #rect(width: 2cm, fill: conifer, padding: 4pt)[B]
] ]
---
// The inner rectangle should also be yellow here.
// (and therefore invisible)
[#set rect(fill: yellow);#text(100%, rect(padding: 5pt, rect()))]
---
// The inner rectangle should not be yellow here.
A #rect(fill: yellow, padding: 5pt, rect()) B
---
// The inner list should not be indented extra.
[#set text(100%);#list(label-indent: 20pt, list[A])]

18
tests/typ/text/links.typ
View File

@ -1,3 +1,6 @@
// Test hyperlinking.
---
// Link without body. // Link without body.
#link("https://example.com/") #link("https://example.com/")
@ -8,22 +11,25 @@
This link appears #link("https://google.com/")[in the middle of] a paragraph. This link appears #link("https://google.com/")[in the middle of] a paragraph.
// Prefix is trimmed. // Prefix is trimmed.
Contact #link("mailto:hi@typst.app") or call #link("tel:123") for more information. Contact #link("mailto:hi@typst.app") or
call #link("tel:123") for more information.
--- ---
// Styled with underline and color. // Styled with underline and color.
#let link(url, body) = link(url, text(fill: rgb("283663"), underline(body))) #set link(fill: rgb("283663"))
You could also make the #link("https://html5zombo.com/")[link look way more typical.] You could also make the
#link("https://html5zombo.com/")[link look way more typical.]
--- ---
// Transformed link. // Transformed link.
#set page(height: 60pt) #set page(height: 60pt)
#let link = link("https://typst.app/")[LINK] #set link(underline: false)
My cool #move(x: 0.7cm, y: 0.7cm, rotate(10deg, scale(200%, link))) #let mylink = link("https://typst.app/")[LINK]
My cool #move(x: 0.7cm, y: 0.7cm, rotate(10deg, scale(200%, mylink)))
--- ---
// Link containing a block. // Link containing a block.
#link("https://example.com/", block[ #link("https://example.com/", underline: false, block[
My cool rhino My cool rhino
#move(x: 10pt, image("../../res/rhino.png", width: 1cm)) #move(x: 10pt, image("../../res/rhino.png", width: 1cm))
]) ])

12
tests/typ/text/par.typ
View File

@ -29,18 +29,6 @@ You
// Test that paragraphs break due to incompatibility has correct spacing. // Test that paragraphs break due to incompatibility has correct spacing.
A #set par(spacing: 0pt, leading: 0pt); B #parbreak() C A #set par(spacing: 0pt, leading: 0pt); B #parbreak() C
---
// Test that paragraph breaks due to block nodes have the correct spacing.
#set par(spacing: 10pt)
- A
#set par(leading: 0pt)
- B
- C
#set par(leading: 5pt)
- D
- E
--- ---
// Test weird metrics. // Test weird metrics.
#set par(spacing: 100%, leading: 0pt) #set par(spacing: 100%, leading: 0pt)