Rename `State` to `Style` and move it into its own module

4 files changed, 77 insertions, 325 deletions

diff --git a/src/eval/mod.rs b/src/eval/mod.rs
index 384ebb2b..2adf785e 100644
--- a/src/eval/mod.rs
+++ b/src/eval/mod.rs
@@ -12,7 +12,6 @@ mod capture;
 mod function;
 mod ops;
 mod scope;
-mod state;
 mod template;
 mod walk;
 
@@ -22,7 +21,6 @@ pub use capture::*;
 pub use dict::*;
 pub use function::*;
 pub use scope::*;
-pub use state::*;
 pub use template::*;
 pub use value::*;
 pub use walk::*;
diff --git a/src/eval/state.rs b/src/eval/state.rs
deleted file mode 100644
index 5d8d3172..00000000
--- a/src/eval/state.rs
+++ /dev/null
@@ -1,247 +0,0 @@
-use std::rc::Rc;
-
-use crate::font::{
-    FontFamily, FontStretch, FontStyle, FontVariant, FontWeight, VerticalFontMetric,
-};
-use crate::geom::*;
-use crate::paper::{PaperClass, ISO_A4};
-
-/// Defines an set of properties a template can be instantiated with.
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct State {
-    /// The direction for text and other inline objects.
-    pub dirs: Gen<Dir>,
-    /// The alignments of layouts in their parents.
-    pub aligns: Gen<Align>,
-    /// The page settings.
-    pub page: Rc<PageState>,
-    /// The paragraph settings.
-    pub par: Rc<ParState>,
-    /// The font settings.
-    pub font: Rc<FontState>,
-}
-
-impl State {
-    /// Access the `page` state mutably.
-    pub fn page_mut(&mut self) -> &mut PageState {
-        Rc::make_mut(&mut self.page)
-    }
-
-    /// Access the `par` state mutably.
-    pub fn par_mut(&mut self) -> &mut ParState {
-        Rc::make_mut(&mut self.par)
-    }
-
-    /// Access the `font` state mutably.
-    pub fn font_mut(&mut self) -> &mut FontState {
-        Rc::make_mut(&mut self.font)
-    }
-
-    /// The resolved line spacing.
-    pub fn line_spacing(&self) -> Length {
-        self.par.line_spacing.resolve(self.font.size)
-    }
-
-    /// The resolved paragraph spacing.
-    pub fn par_spacing(&self) -> Length {
-        self.par.par_spacing.resolve(self.font.size)
-    }
-}
-
-impl Default for State {
-    fn default() -> Self {
-        Self {
-            dirs: Gen::new(Dir::LTR, Dir::TTB),
-            aligns: Gen::splat(Align::Start),
-            page: Rc::new(PageState::default()),
-            par: Rc::new(ParState::default()),
-            font: Rc::new(FontState::default()),
-        }
-    }
-}
-
-/// Defines page properties.
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct PageState {
-    /// The class of this page.
-    pub class: PaperClass,
-    /// The width and height of the page.
-    pub size: Size,
-    /// The amount of white space on each side of the page. If a side is set to
-    /// `None`, the default for the paper class is used.
-    pub margins: Sides<Option<Linear>>,
-}
-
-impl PageState {
-    /// The resolved margins.
-    pub fn margins(&self) -> Sides<Linear> {
-        let default = self.class.default_margins();
-        Sides {
-            left: self.margins.left.unwrap_or(default.left),
-            top: self.margins.top.unwrap_or(default.top),
-            right: self.margins.right.unwrap_or(default.right),
-            bottom: self.margins.bottom.unwrap_or(default.bottom),
-        }
-    }
-}
-
-impl Default for PageState {
-    fn default() -> Self {
-        let paper = ISO_A4;
-        Self {
-            class: paper.class(),
-            size: paper.size(),
-            margins: Sides::splat(None),
-        }
-    }
-}
-
-/// Defines paragraph properties.
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct ParState {
-    /// The spacing between paragraphs (dependent on scaled font size).
-    pub par_spacing: Linear,
-    /// The spacing between lines (dependent on scaled font size).
-    pub line_spacing: Linear,
-}
-
-impl Default for ParState {
-    fn default() -> Self {
-        Self {
-            par_spacing: Relative::new(1.2).into(),
-            line_spacing: Relative::new(0.65).into(),
-        }
-    }
-}
-
-/// Defines font properties.
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct FontState {
-    /// The font size.
-    pub size: Length,
-    /// The selected font variant (the final variant also depends on `strong`
-    /// and `emph`).
-    pub variant: FontVariant,
-    /// The top end of the text bounding box.
-    pub top_edge: VerticalFontMetric,
-    /// The bottom end of the text bounding box.
-    pub bottom_edge: VerticalFontMetric,
-    /// Glyph color.
-    pub fill: Paint,
-    /// A list of font families with generic class definitions (the final
-    /// family list also depends on `monospace`).
-    pub families: Rc<FamilyState>,
-    /// Whether 300 extra font weight should be added to what is defined by the
-    /// `variant`.
-    pub strong: bool,
-    /// Whether the the font style defined by the `variant` should be inverted.
-    pub emph: bool,
-    /// Whether a monospace font should be preferred.
-    pub monospace: bool,
-    /// Whether font fallback to a base list should occur.
-    pub fallback: bool,
-}
-
-impl FontState {
-    /// The resolved variant with `strong` and `emph` factored in.
-    pub fn variant(&self) -> FontVariant {
-        let mut variant = self.variant;
-
-        if self.strong {
-            variant.weight = variant.weight.thicken(300);
-        }
-
-        if self.emph {
-            variant.style = match variant.style {
-                FontStyle::Normal => FontStyle::Italic,
-                FontStyle::Italic => FontStyle::Normal,
-                FontStyle::Oblique => FontStyle::Normal,
-            }
-        }
-
-        variant
-    }
-
-    /// The resolved family iterator.
-    pub fn families(&self) -> impl Iterator<Item = &str> + Clone {
-        let head = if self.monospace {
-            self.families.monospace.as_slice()
-        } else {
-            &[]
-        };
-
-        let core = self.families.list.iter().flat_map(move |family| {
-            match family {
-                FontFamily::Named(name) => std::slice::from_ref(name),
-                FontFamily::Serif => &self.families.serif,
-                FontFamily::SansSerif => &self.families.sans_serif,
-                FontFamily::Monospace => &self.families.monospace,
-            }
-        });
-
-        let tail = if self.fallback {
-            self.families.base.as_slice()
-        } else {
-            &[]
-        };
-
-        head.iter().chain(core).chain(tail).map(String::as_str)
-    }
-
-    /// Access the `families` state mutably.
-    pub fn families_mut(&mut self) -> &mut FamilyState {
-        Rc::make_mut(&mut self.families)
-    }
-}
-
-impl Default for FontState {
-    fn default() -> Self {
-        Self {
-            size: Length::pt(11.0),
-            variant: FontVariant {
-                style: FontStyle::Normal,
-                weight: FontWeight::REGULAR,
-                stretch: FontStretch::NORMAL,
-            },
-            top_edge: VerticalFontMetric::CapHeight,
-            bottom_edge: VerticalFontMetric::Baseline,
-            fill: Paint::Color(Color::Rgba(RgbaColor::BLACK)),
-            families: Rc::new(FamilyState::default()),
-            strong: false,
-            emph: false,
-            monospace: false,
-            fallback: true,
-        }
-    }
-}
-
-/// Font family definitions.
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct FamilyState {
-    /// The user-defined list of font families.
-    pub list: Rc<Vec<FontFamily>>,
-    /// Definition of serif font families.
-    pub serif: Rc<Vec<String>>,
-    /// Definition of sans-serif font families.
-    pub sans_serif: Rc<Vec<String>>,
-    /// Definition of monospace font families used for raw text.
-    pub monospace: Rc<Vec<String>>,
-    /// Base fonts that are tried as last resort.
-    pub base: Rc<Vec<String>>,
-}
-
-impl Default for FamilyState {
-    fn default() -> Self {
-        Self {
-            list: Rc::new(vec![FontFamily::SansSerif]),
-            serif: Rc::new(vec!["ibm plex serif".into()]),
-            sans_serif: Rc::new(vec!["ibm plex sans".into()]),
-            monospace: Rc::new(vec!["ibm plex mono".into()]),
-            base: Rc::new(vec![
-                "ibm plex sans".into(),
-                "latin modern math".into(),
-                "twitter color emoji".into(),
-            ]),
-        }
-    }
-}
diff --git a/src/eval/template.rs b/src/eval/template.rs
index 42b35fc3..0ea312e5 100644
--- a/src/eval/template.rs
+++ b/src/eval/template.rs
@@ -4,13 +4,14 @@ use std::mem;
 use std::ops::{Add, AddAssign};
 use std::rc::Rc;
 
-use super::{State, Str};
+use super::Str;
 use crate::diag::StrResult;
 use crate::geom::{Align, Dir, Gen, GenAxis, Length, Linear, Sides, Size};
 use crate::layout::{
     Decoration, LayoutNode, LayoutTree, PadNode, PageRun, ParChild, ParNode, StackChild,
     StackNode,
 };
+use crate::style::Style;
 use crate::util::EcoString;
 
 /// A template value: `[*Hi* there]`.
@@ -33,15 +34,15 @@ enum TemplateNode {
     /// Spacing.
     Spacing(GenAxis, Linear),
     /// An inline node builder.
-    Inline(Rc<dyn Fn(&State) -> LayoutNode>, Vec<Decoration>),
+    Inline(Rc<dyn Fn(&Style) -> LayoutNode>, Vec<Decoration>),
     /// An block node builder.
-    Block(Rc<dyn Fn(&State) -> LayoutNode>),
-    /// Save the current state.
+    Block(Rc<dyn Fn(&Style) -> LayoutNode>),
+    /// Save the current style.
     Save,
-    /// Restore the last saved state.
+    /// Restore the last saved style.
     Restore,
-    /// A function that can modify the current state.
-    Modify(Rc<dyn Fn(&mut State)>),
+    /// A function that can modify the current style.
+    Modify(Rc<dyn Fn(&mut Style)>),
 }
 
 impl Template {
@@ -53,7 +54,7 @@ impl Template {
     /// Create a template from a builder for an inline-level node.
     pub fn from_inline<F, T>(f: F) -> Self
     where
-        F: Fn(&State) -> T + 'static,
+        F: Fn(&Style) -> T + 'static,
         T: Into<LayoutNode>,
     {
         let node = TemplateNode::Inline(Rc::new(move |s| f(s).into()), vec![]);
@@ -63,7 +64,7 @@ impl Template {
     /// Create a template from a builder for a block-level node.
     pub fn from_block<F, T>(f: F) -> Self
     where
-        F: Fn(&State) -> T + 'static,
+        F: Fn(&Style) -> T + 'static,
         T: Into<LayoutNode>,
     {
         let node = TemplateNode::Block(Rc::new(move |s| f(s).into()));
@@ -98,7 +99,7 @@ impl Template {
     /// Add text, but in monospace.
     pub fn monospace(&mut self, text: impl Into<EcoString>) {
         self.save();
-        self.modify(|state| state.font_mut().monospace = true);
+        self.modify(|style| style.text_mut().monospace = true);
         self.text(text);
         self.restore();
     }
@@ -126,16 +127,16 @@ impl Template {
         self.make_mut().push(TemplateNode::Save);
     }
 
-    /// Ensure that later nodes are untouched by state modifications made since
+    /// Ensure that later nodes are untouched by style modifications made since
     /// the last snapshot.
     pub fn restore(&mut self) {
         self.make_mut().push(TemplateNode::Restore);
     }
 
-    /// Modify the state.
+    /// Modify the style.
     pub fn modify<F>(&mut self, f: F)
     where
-        F: Fn(&mut State) + 'static,
+        F: Fn(&mut Style) + 'static,
     {
         self.make_mut().push(TemplateNode::Modify(Rc::new(f)));
     }
@@ -143,7 +144,7 @@ impl Template {
     /// Return a new template which is modified from start to end.
     pub fn modified<F>(self, f: F) -> Self
     where
-        F: Fn(&mut State) + 'static,
+        F: Fn(&mut Style) + 'static,
     {
         let mut wrapper = Self::new();
         wrapper.save();
@@ -153,18 +154,18 @@ impl Template {
         wrapper
     }
 
-    /// Build the stack node resulting from instantiating the template in the
-    /// given state.
-    pub fn to_stack(&self, state: &State) -> StackNode {
-        let mut builder = Builder::new(state, false);
+    /// Build the stack node resulting from instantiating the template with the
+    /// given style.
+    pub fn to_stack(&self, style: &Style) -> StackNode {
+        let mut builder = Builder::new(style, false);
         builder.template(self);
         builder.build_stack()
     }
 
-    /// Build the layout tree resulting from instantiating the template in the
-    /// given state.
-    pub fn to_tree(&self, state: &State) -> LayoutTree {
-        let mut builder = Builder::new(state, true);
+    /// Build the layout tree resulting from instantiating the template with the
+    /// given style.
+    pub fn to_tree(&self, style: &Style) -> LayoutTree {
+        let mut builder = Builder::new(style, true);
         builder.template(self);
         builder.build_tree()
     }
@@ -238,10 +239,10 @@ impl Add<Template> for Str {
 
 /// Transforms from template to layout representation.
 struct Builder {
-    /// The active state.
-    state: State,
-    /// Snapshots of the state.
-    snapshots: Vec<State>,
+    /// The current style.
+    style: Style,
+    /// Snapshots of the style.
+    snapshots: Vec<Style>,
     /// The tree of finished page runs.
     tree: LayoutTree,
     /// When we are building the top-level layout trees, this contains metrics
@@ -252,14 +253,14 @@ struct Builder {
 }
 
 impl Builder {
-    /// Create a new builder with a base state.
-    fn new(state: &State, pages: bool) -> Self {
+    /// Create a new builder with a base style.
+    fn new(style: &Style, pages: bool) -> Self {
         Self {
-            state: state.clone(),
+            style: style.clone(),
             snapshots: vec![],
             tree: LayoutTree { runs: vec![] },
-            page: pages.then(|| PageBuilder::new(state, true)),
-            stack: StackBuilder::new(state),
+            page: pages.then(|| PageBuilder::new(style, true)),
+            stack: StackBuilder::new(style),
         }
     }
 
@@ -273,11 +274,11 @@ impl Builder {
     /// Build a template node.
     fn node(&mut self, node: &TemplateNode) {
         match node {
-            TemplateNode::Save => self.snapshots.push(self.state.clone()),
+            TemplateNode::Save => self.snapshots.push(self.style.clone()),
             TemplateNode::Restore => {
-                let state = self.snapshots.pop().unwrap();
-                let newpage = state.page != self.state.page;
-                self.state = state;
+                let style = self.snapshots.pop().unwrap();
+                let newpage = style.page != self.style.page;
+                self.style = style;
                 if newpage {
                     self.pagebreak(true, false);
                 }
@@ -288,9 +289,9 @@ impl Builder {
             TemplateNode::Pagebreak(keep) => self.pagebreak(*keep, true),
             TemplateNode::Text(text, decos) => self.text(text, decos),
             TemplateNode::Spacing(axis, amount) => self.spacing(*axis, *amount),
-            TemplateNode::Inline(f, decos) => self.inline(f(&self.state), decos),
-            TemplateNode::Block(f) => self.block(f(&self.state)),
-            TemplateNode::Modify(f) => f(&mut self.state),
+            TemplateNode::Inline(f, decos) => self.inline(f(&self.style), decos),
+            TemplateNode::Block(f) => self.block(f(&self.style)),
+            TemplateNode::Modify(f) => f(&mut self.style),
         }
     }
 
@@ -306,16 +307,16 @@ impl Builder {
 
     /// Apply a forced paragraph break.
     fn parbreak(&mut self) {
-        let amount = self.state.par_spacing();
-        self.stack.finish_par(&self.state);
+        let amount = self.style.par_spacing();
+        self.stack.finish_par(&self.style);
         self.stack.push_soft(StackChild::Spacing(amount.into()));
     }
 
     /// Apply a forced page break.
     fn pagebreak(&mut self, keep: bool, hard: bool) {
         if let Some(builder) = &mut self.page {
-            let page = mem::replace(builder, PageBuilder::new(&self.state, hard));
-            let stack = mem::replace(&mut self.stack, StackBuilder::new(&self.state));
+            let page = mem::replace(builder, PageBuilder::new(&self.style, hard));
+            let stack = mem::replace(&mut self.stack, StackBuilder::new(&self.style));
             self.tree.runs.extend(page.build(stack.build(), keep));
         }
     }
@@ -327,14 +328,14 @@ impl Builder {
 
     /// Push an inline node into the active paragraph.
     fn inline(&mut self, node: impl Into<LayoutNode>, decos: &[Decoration]) {
-        let align = self.state.aligns.inline;
+        let align = self.style.aligns.inline;
         self.stack.par.push(ParChild::Any(node.into(), align, decos.to_vec()));
     }
 
     /// Push a block node into the active stack, finishing the active paragraph.
     fn block(&mut self, node: impl Into<LayoutNode>) {
         self.parbreak();
-        let aligns = self.state.aligns;
+        let aligns = self.style.aligns;
         self.stack.push(StackChild::Any(node.into(), aligns));
         self.parbreak();
     }
@@ -343,7 +344,7 @@ impl Builder {
     fn spacing(&mut self, axis: GenAxis, amount: Linear) {
         match axis {
             GenAxis::Block => {
-                self.stack.finish_par(&self.state);
+                self.stack.finish_par(&self.style);
                 self.stack.push_hard(StackChild::Spacing(amount));
             }
             GenAxis::Inline => {
@@ -365,8 +366,8 @@ impl Builder {
         self.tree
     }
 
-    /// Construct a text node with the given text and settings from the active
-    /// state.
+    /// Construct a text node with the given text and settings from the current
+    /// style.
     fn make_text_node(
         &self,
         text: impl Into<EcoString>,
@@ -374,8 +375,8 @@ impl Builder {
     ) -> ParChild {
         ParChild::Text(
             text.into(),
-            self.state.aligns.inline,
-            Rc::clone(&self.state.font),
+            self.style.aligns.inline,
+            Rc::clone(&self.style.text),
             decos,
         )
     }
@@ -388,10 +389,10 @@ struct PageBuilder {
 }
 
 impl PageBuilder {
-    fn new(state: &State, hard: bool) -> Self {
+    fn new(style: &Style, hard: bool) -> Self {
         Self {
-            size: state.page.size,
-            padding: state.page.margins(),
+            size: style.page.size,
+            padding: style.page.margins(),
             hard,
         }
     }
@@ -413,12 +414,12 @@ struct StackBuilder {
 }
 
 impl StackBuilder {
-    fn new(state: &State) -> Self {
+    fn new(style: &Style) -> Self {
         Self {
-            dirs: state.dirs,
+            dirs: Gen::new(style.dir, Dir::TTB),
             children: vec![],
             last: Last::None,
-            par: ParBuilder::new(state),
+            par: ParBuilder::new(style),
         }
     }
 
@@ -436,8 +437,8 @@ impl StackBuilder {
         self.children.push(child);
     }
 
-    fn finish_par(&mut self, state: &State) {
-        let par = mem::replace(&mut self.par, ParBuilder::new(state));
+    fn finish_par(&mut self, style: &Style) {
+        let par = mem::replace(&mut self.par, ParBuilder::new(style));
         if let Some(par) = par.build() {
             self.push(par);
         }
@@ -462,11 +463,11 @@ struct ParBuilder {
 }
 
 impl ParBuilder {
-    fn new(state: &State) -> Self {
+    fn new(style: &Style) -> Self {
         Self {
-            aligns: state.aligns,
-            dir: state.dirs.inline,
-            line_spacing: state.line_spacing(),
+            aligns: style.aligns,
+            dir: style.dir,
+            line_spacing: style.line_spacing(),
             children: vec![],
             last: Last::None,
         }
diff --git a/src/eval/walk.rs b/src/eval/walk.rs
index 1755dab9..90361141 100644
--- a/src/eval/walk.rs
+++ b/src/eval/walk.rs
@@ -2,7 +2,7 @@ use std::rc::Rc;
 
 use super::{Eval, EvalContext, Str, Template, Value};
 use crate::diag::TypResult;
-use crate::geom::Gen;
+use crate::geom::{Dir, Gen};
 use crate::layout::{ParChild, ParNode, StackChild, StackNode};
 use crate::syntax::*;
 use crate::util::BoolExt;
@@ -28,8 +28,8 @@ impl Walk for MarkupNode {
             Self::Space => ctx.template.space(),
             Self::Linebreak(_) => ctx.template.linebreak(),
             Self::Parbreak(_) => ctx.template.parbreak(),
-            Self::Strong(_) => ctx.template.modify(|s| s.font_mut().strong.flip()),
-            Self::Emph(_) => ctx.template.modify(|s| s.font_mut().emph.flip()),
+            Self::Strong(_) => ctx.template.modify(|s| s.text_mut().strong.flip()),
+            Self::Emph(_) => ctx.template.modify(|s| s.text_mut().emph.flip()),
             Self::Text(text) => ctx.template.text(text),
             Self::Raw(raw) => raw.walk(ctx)?,
             Self::Heading(heading) => heading.walk(ctx)?,
@@ -73,11 +73,11 @@ impl Walk for HeadingNode {
 
         ctx.template.parbreak();
         ctx.template.save();
-        ctx.template.modify(move |state| {
-            let font = state.font_mut();
+        ctx.template.modify(move |style| {
+            let text = style.text_mut();
             let upscale = 1.6 - 0.1 * level as f64;
-            font.size *= upscale;
-            font.strong = true;
+            text.size *= upscale;
+            text.strong = true;
         });
         ctx.template += body;
         ctx.template.restore();
@@ -105,23 +105,23 @@ impl Walk for EnumNode {
 }
 
 fn walk_item(ctx: &mut EvalContext, label: Str, body: Template) {
-    ctx.template += Template::from_block(move |state| {
+    ctx.template += Template::from_block(move |style| {
         let label = ParNode {
-            dir: state.dirs.inline,
-            line_spacing: state.line_spacing(),
+            dir: style.dir,
+            line_spacing: style.line_spacing(),
             children: vec![ParChild::Text(
                 (&label).into(),
-                state.aligns.inline,
-                Rc::clone(&state.font),
+                style.aligns.inline,
+                Rc::clone(&style.text),
                 vec![],
             )],
         };
         StackNode {
-            dirs: Gen::new(state.dirs.block, state.dirs.inline),
+            dirs: Gen::new(Dir::TTB, style.dir),
             children: vec![
                 StackChild::Any(label.into(), Gen::default()),
-                StackChild::Spacing((state.font.size / 2.0).into()),
-                StackChild::Any(body.to_stack(&state).into(), Gen::default()),
+                StackChild::Spacing((style.text.size / 2.0).into()),
+                StackChild::Any(body.to_stack(&style).into(), Gen::default()),
             ],
         }
     });