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

2 files changed, 485 insertions, 0 deletions

diff --git a/src/style/mod.rs b/src/style/mod.rs
new file mode 100644
index 00000000..f59ea32e
--- /dev/null
+++ b/src/style/mod.rs
@@ -0,0 +1,252 @@
+//! Style properties.
+
+mod paper;
+
+pub use paper::*;
+
+use std::rc::Rc;
+
+use crate::font::{
+    FontFamily, FontStretch, FontStyle, FontVariant, FontWeight, VerticalFontMetric,
+};
+use crate::geom::*;
+
+/// Defines a set of properties a template can be instantiated with.
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
+pub struct Style {
+    /// The direction for text and other inline objects.
+    pub dir: Dir,
+    /// The alignments of layouts in their parents.
+    pub aligns: Gen<Align>,
+    /// The page settings.
+    pub page: Rc<PageStyle>,
+    /// The paragraph settings.
+    pub par: Rc<ParStyle>,
+    /// The current text settings.
+    pub text: Rc<TextStyle>,
+}
+
+impl Style {
+    /// Access the `page` style mutably.
+    pub fn page_mut(&mut self) -> &mut PageStyle {
+        Rc::make_mut(&mut self.page)
+    }
+
+    /// Access the `par` style mutably.
+    pub fn par_mut(&mut self) -> &mut ParStyle {
+        Rc::make_mut(&mut self.par)
+    }
+
+    /// Access the `text` style mutably.
+    pub fn text_mut(&mut self) -> &mut TextStyle {
+        Rc::make_mut(&mut self.text)
+    }
+
+    /// The resolved line spacing.
+    pub fn line_spacing(&self) -> Length {
+        self.par.line_spacing.resolve(self.text.size)
+    }
+
+    /// The resolved paragraph spacing.
+    pub fn par_spacing(&self) -> Length {
+        self.par.par_spacing.resolve(self.text.size)
+    }
+}
+
+impl Default for Style {
+    fn default() -> Self {
+        Self {
+            dir: Dir::LTR,
+            aligns: Gen::splat(Align::Start),
+            page: Rc::new(PageStyle::default()),
+            par: Rc::new(ParStyle::default()),
+            text: Rc::new(TextStyle::default()),
+        }
+    }
+}
+
+/// Defines style properties of pages.
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
+pub struct PageStyle {
+    /// 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 PageStyle {
+    /// 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 PageStyle {
+    fn default() -> Self {
+        let paper = Paper::ISO_A4;
+        Self {
+            class: paper.class(),
+            size: paper.size(),
+            margins: Sides::splat(None),
+        }
+    }
+}
+
+/// Defines style properties of paragraphs.
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
+pub struct ParStyle {
+    /// 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 ParStyle {
+    fn default() -> Self {
+        Self {
+            par_spacing: Relative::new(1.2).into(),
+            line_spacing: Relative::new(0.65).into(),
+        }
+    }
+}
+
+/// Defines style properties of text.
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
+pub struct TextStyle {
+    /// 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<FamilyStyle>,
+    /// 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 TextStyle {
+    /// 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` style mutably.
+    pub fn families_mut(&mut self) -> &mut FamilyStyle {
+        Rc::make_mut(&mut self.families)
+    }
+}
+
+impl Default for TextStyle {
+    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(FamilyStyle::default()),
+            strong: false,
+            emph: false,
+            monospace: false,
+            fallback: true,
+        }
+    }
+}
+
+/// Font list with family definitions.
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
+pub struct FamilyStyle {
+    /// 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 FamilyStyle {
+    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/style/paper.rs b/src/style/paper.rs
new file mode 100644
index 00000000..bc317308
--- /dev/null
+++ b/src/style/paper.rs
@@ -0,0 +1,233 @@
+use crate::geom::{Length, Linear, Relative, Sides, Size};
+
+/// Specification of a paper.
+#[derive(Debug, Copy, Clone)]
+pub struct Paper {
+    /// The broad class this paper belongs to.
+    class: PaperClass,
+    /// The width of the paper in millimeters.
+    width: f64,
+    /// The height of the paper in millimeters.
+    height: f64,
+}
+
+/// 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.
+    pub 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),
+        }
+    }
+}
+
+macro_rules! papers {
+    ($(($var:ident: $class:ident, $width:expr, $height: expr, $($pats:tt)*))*) => {
+        impl Paper {
+            /// Parse a paper from its name.
+            ///
+            /// Both lower and upper case are fine.
+            pub fn from_name(name: &str) -> Option<Self> {
+                match name.to_lowercase().as_str() {
+                    $($($pats)* => Some(Self::$var),)*
+                    _ => None,
+                }
+            }
+
+            /// The class of the paper.
+            pub fn class(self) -> PaperClass {
+                self.class
+            }
+
+            /// The size of the paper.
+            pub fn size(self) -> Size {
+                Size::new(Length::mm(self.width), Length::mm(self.height))
+            }
+        }
+
+        /// Predefined papers.
+        ///
+        /// Each paper is parsable from its name in kebab-case.
+        impl Paper {
+            $(papers!(@$var, stringify!($($pats)*), $class, $width, $height);)*
+        }
+    };
+
+    (@$var:ident, $names:expr, $class:ident, $width:expr, $height:expr) => {
+        pub const $var: Self = Self {
+            class: PaperClass::$class,
+            width: $width,
+            height: $height,
+        };
+    };
+}
+
+// All paper sizes in mm.
+//
+// Resources:
+// - https://papersizes.io/
+// - https://en.wikipedia.org/wiki/Paper_size
+// - https://www.theedkins.co.uk/jo/units/oldunits/print.htm
+// - https://vintagepaper.co/blogs/news/traditional-paper-sizes
+papers! {
+    // ---------------------------------------------------------------------- //
+    // ISO 216 A Series
+    (ISO_A0:  Base, 841.0, 1189.0, "iso-a0")
+    (ISO_A1:  Base, 594.0,  841.0, "iso-a1")
+    (ISO_A2:  Base, 420.0,  594.0, "iso-a2")
+    (ISO_A3:  Base, 297.0,  420.0, "iso-a3")
+    (ISO_A4:  Base, 210.0,  297.0, "iso-a4")
+    (ISO_A5:  Base, 148.0,  210.0, "iso-a5")
+    (ISO_A6:  Book, 105.0,  148.0, "iso-a6")
+    (ISO_A7:  Base,  74.0,  105.0, "iso-a7")
+    (ISO_A8:  Base,  52.0,   74.0, "iso-a8")
+    (ISO_A9:  Base,  37.0,   52.0, "iso-a9")
+    (ISO_A10: Base,  26.0,   37.0, "iso-a10")
+    (ISO_A11: Base,  18.0,   26.0, "iso-a11")
+
+    // ISO 216 B Series
+    (ISO_B1: Base, 707.0, 1000.0, "iso-b1")
+    (ISO_B2: Base, 500.0, 707.0,  "iso-b2")
+    (ISO_B3: Base, 353.0, 500.0,  "iso-b3")
+    (ISO_B4: Base, 250.0, 353.0,  "iso-b4")
+    (ISO_B5: Book, 176.0, 250.0,  "iso-b5")
+    (ISO_B6: Book, 125.0, 176.0,  "iso-b6")
+    (ISO_B7: Base,  88.0, 125.0,  "iso-b7")
+    (ISO_B8: Base,  62.0,  88.0,  "iso-b8")
+
+    // ISO 216 C Series
+    (ISO_C3: Base, 324.0, 458.0, "iso-c3")
+    (ISO_C4: Base, 229.0, 324.0, "iso-c4")
+    (ISO_C5: Base, 162.0, 229.0, "iso-c5")
+    (ISO_C6: Base, 114.0, 162.0, "iso-c6")
+    (ISO_C7: Base,  81.0, 114.0, "iso-c7")
+    (ISO_C8: Base,  57.0,  81.0, "iso-c8")
+
+    // DIN D Series (extension to ISO)
+    (DIN_D3: Base, 272.0, 385.0, "din-d3")
+    (DIN_D4: Base, 192.0, 272.0, "din-d4")
+    (DIN_D5: Base, 136.0, 192.0, "din-d5")
+    (DIN_D6: Base,  96.0, 136.0, "din-d6")
+    (DIN_D7: Base,  68.0,  96.0, "din-d7")
+    (DIN_D8: Base,  48.0,  68.0, "din-d8")
+
+    // SIS (used in academia)
+    (SIS_G5: Base, 169.0, 239.0, "sis-g5")
+    (SIS_E5: Base, 115.0, 220.0, "sis-e5")
+
+    // ANSI Extensions
+    (ANSI_A: Base, 216.0,  279.0, "ansi-a")
+    (ANSI_B: Base, 279.0,  432.0, "ansi-b")
+    (ANSI_C: Base, 432.0,  559.0, "ansi-c")
+    (ANSI_D: Base, 559.0,  864.0, "ansi-d")
+    (ANSI_E: Base, 864.0, 1118.0, "ansi-e")
+
+    // ANSI Architectural Paper
+    (ARCH_A:  Base, 229.0,  305.0, "arch-a")
+    (ARCH_B:  Base, 305.0,  457.0, "arch-b")
+    (ARCH_C:  Base, 457.0,  610.0, "arch-c")
+    (ARCH_D:  Base, 610.0,  914.0, "arch-d")
+    (ARCH_E1: Base, 762.0, 1067.0, "arch-e1")
+    (ARCH_E:  Base, 914.0, 1219.0, "arch-e")
+
+    // JIS B Series
+    (JIS_B0:  Base, 1030.0, 1456.0, "jis-b0")
+    (JIS_B1:  Base,  728.0, 1030.0, "jis-b1")
+    (JIS_B2:  Base,  515.0,  728.0, "jis-b2")
+    (JIS_B3:  Base,  364.0,  515.0, "jis-b3")
+    (JIS_B4:  Base,  257.0,  364.0, "jis-b4")
+    (JIS_B5:  Base,  182.0,  257.0, "jis-b5")
+    (JIS_B6:  Base,  128.0,  182.0, "jis-b6")
+    (JIS_B7:  Base,   91.0,  128.0, "jis-b7")
+    (JIS_B8:  Base,   64.0,   91.0, "jis-b8")
+    (JIS_B9:  Base,   45.0,   64.0, "jis-b9")
+    (JIS_B10: Base,   32.0,   45.0, "jis-b10")
+    (JIS_B11: Base,   22.0,   32.0, "jis-b11")
+
+    // SAC D Series
+    (SAC_D0: Base, 764.0, 1064.0, "sac-d0")
+    (SAC_D1: Base, 532.0,  760.0, "sac-d1")
+    (SAC_D2: Base, 380.0,  528.0, "sac-d2")
+    (SAC_D3: Base, 264.0,  376.0, "sac-d3")
+    (SAC_D4: Base, 188.0,  260.0, "sac-d4")
+    (SAC_D5: Base, 130.0,  184.0, "sac-d5")
+    (SAC_D6: Base,  92.0,  126.0, "sac-d6")
+
+    // ISO 7810 ID
+    (ISO_ID_1: Base, 85.6, 53.98, "iso-id-1")
+    (ISO_ID_2: Base, 74.0, 105.0, "iso-id-2")
+    (ISO_ID_3: Base, 88.0, 125.0, "iso-id-3")
+
+    // ---------------------------------------------------------------------- //
+    // Asia
+    (ASIA_F4: Base, 210.0, 330.0, "asia-f4")
+
+    // Japan
+    (JP_SHIROKU_BAN_4: Base, 264.0, 379.0, "jp-shiroku-ban-4")
+    (JP_SHIROKU_BAN_5: Base, 189.0, 262.0, "jp-shiroku-ban-5")
+    (JP_SHIROKU_BAN_6: Base, 127.0, 188.0, "jp-shiroku-ban-6")
+    (JP_KIKU_4:        Base, 227.0, 306.0, "jp-kiku-4")
+    (JP_KIKU_5:        Base, 151.0, 227.0, "jp-kiku-5")
+    (JP_BUSINESS_CARD: Base,  91.0,  55.0, "jp-business-card")
+
+    // China
+    (CN_BUSINESS_CARD: Base, 90.0, 54.0, "cn-business-card")
+
+    // Europe
+    (EU_BUSINESS_CARD: Base, 85.0, 55.0, "eu-business-card")
+
+    // French Traditional (AFNOR)
+    (FR_TELLIERE:          Base, 340.0, 440.0, "fr-tellière")
+    (FR_COURONNE_ECRITURE: Base, 360.0, 460.0, "fr-couronne-écriture")
+    (FR_COURONNE_EDITION:  Base, 370.0, 470.0, "fr-couronne-édition")
+    (FR_RAISIN:            Base, 500.0, 650.0, "fr-raisin")
+    (FR_CARRE:             Base, 450.0, 560.0, "fr-carré")
+    (FR_JESUS:             Base, 560.0, 760.0, "fr-jésus")
+
+    // United Kingdom Imperial
+    (UK_BRIEF:    Base, 406.4, 342.9, "uk-brief")
+    (UK_DRAFT:    Base, 254.0, 406.4, "uk-draft")
+    (UK_FOOLSCAP: Base, 203.2, 330.2, "uk-foolscap")
+    (UK_QUARTO:   Base, 203.2, 254.0, "uk-quarto")
+    (UK_CROWN:    Base, 508.0, 381.0, "uk-crown")
+    (UK_BOOK_A:   Book, 111.0, 178.0, "uk-book-a")
+    (UK_BOOK_B:   Book, 129.0, 198.0, "uk-book-b")
+
+    // Unites States
+    (US_LETTER:         US,   215.9,  279.4, "us-letter")
+    (US_LEGAL:          US,   215.9,  355.6, "us-legal")
+    (US_TABLOID:        US,   279.4,  431.8, "us-tabloid")
+    (US_EXECUTIVE:      US,  184.15,  266.7, "us-executive")
+    (US_FOOLSCAP_FOLIO: US,   215.9,  342.9, "us-foolscap-folio")
+    (US_STATEMENT:      US,   139.7,  215.9, "us-statement")
+    (US_LEDGER:         US,   431.8,  279.4, "us-ledger")
+    (US_OFICIO:         US,   215.9, 340.36, "us-oficio")
+    (US_GOV_LETTER:     US,   203.2,  266.7, "us-gov-letter")
+    (US_GOV_LEGAL:      US,   215.9,  330.2, "us-gov-legal")
+    (US_BUSINESS_CARD:  Base,  88.9,   50.8, "us-business-card")
+    (US_DIGEST:         Book, 139.7,  215.9, "us-digest")
+    (US_TRADE:          Book, 152.4,  228.6, "us-trade")
+
+    // ---------------------------------------------------------------------- //
+    // Other
+    (NEWSPAPER_COMPACT:    Newspaper, 280.0, 430.0,    "newspaper-compact")
+    (NEWSPAPER_BERLINER:   Newspaper, 315.0, 470.0,    "newspaper-berliner")
+    (NEWSPAPER_BROADSHEET: Newspaper, 381.0, 578.0,    "newspaper-broadsheet")
+    (PRESENTATION_16_9:    Base,      297.0, 167.0625, "presentation-16-9")
+    (PRESENTATION_4_3:     Base,      280.0, 210.0,    "presentation-4-3")
+}