Merge some modules

1 files changed, 0 insertions, 294 deletions

diff --git a/src/eval/raw.rs b/src/eval/raw.rs
deleted file mode 100644
index 9cf346b1..00000000
--- a/src/eval/raw.rs
+++ /dev/null
@@ -1,294 +0,0 @@
-use std::cmp::Ordering;
-use std::fmt::{self, Debug, Formatter};
-use std::ops::{Add, Div, Mul, Neg};
-
-use super::{Smart, Value};
-use crate::geom::{
-    Align, Em, Get, Length, Numeric, Paint, Relative, Spec, SpecAxis, Stroke,
-};
-use crate::library::text::TextNode;
-use crate::model::{Fold, Resolve, StyleChain};
-
-/// The unresolved alignment representation.
-#[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
-pub enum RawAlign {
-    /// Align at the start side of the text direction.
-    Start,
-    /// Align at the end side of the text direction.
-    End,
-    /// Align at a specific alignment.
-    Specific(Align),
-}
-
-impl Resolve for RawAlign {
-    type Output = Align;
-
-    fn resolve(self, styles: StyleChain) -> Self::Output {
-        let dir = styles.get(TextNode::DIR);
-        match self {
-            Self::Start => dir.start().into(),
-            Self::End => dir.end().into(),
-            Self::Specific(align) => align,
-        }
-    }
-}
-
-impl RawAlign {
-    /// The axis this alignment belongs to.
-    pub const fn axis(self) -> SpecAxis {
-        match self {
-            Self::Start | Self::End => SpecAxis::Horizontal,
-            Self::Specific(align) => align.axis(),
-        }
-    }
-}
-
-impl From<Align> for RawAlign {
-    fn from(align: Align) -> Self {
-        Self::Specific(align)
-    }
-}
-
-impl Debug for RawAlign {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        match self {
-            Self::Start => f.pad("left"),
-            Self::End => f.pad("center"),
-            Self::Specific(align) => align.fmt(f),
-        }
-    }
-}
-
-dynamic! {
-    RawAlign: "alignment",
-}
-
-dynamic! {
-    Spec<RawAlign>: "2d alignment",
-}
-
-castable! {
-    Spec<Option<RawAlign>>,
-    Expected: "1d or 2d alignment",
-    @align: RawAlign => {
-        let mut aligns = Spec::default();
-        aligns.set(align.axis(), Some(*align));
-        aligns
-    },
-    @aligns: Spec<RawAlign> => aligns.map(Some),
-}
-
-/// The unresolved stroke representation.
-///
-/// In this representation, both fields are optional so that you can pass either
-/// just a paint (`red`), just a thickness (`0.1em`) or both (`2pt + red`) where
-/// this is expected.
-#[derive(Default, Copy, Clone, Eq, PartialEq, Hash)]
-pub struct RawStroke<T = RawLength> {
-    /// The stroke's paint.
-    pub paint: Smart<Paint>,
-    /// The stroke's thickness.
-    pub thickness: Smart<T>,
-}
-
-impl RawStroke<Length> {
-    /// Unpack the stroke, filling missing fields from the `default`.
-    pub fn unwrap_or(self, default: Stroke) -> Stroke {
-        Stroke {
-            paint: self.paint.unwrap_or(default.paint),
-            thickness: self.thickness.unwrap_or(default.thickness),
-        }
-    }
-
-    /// Unpack the stroke, filling missing fields with the default values.
-    pub fn unwrap_or_default(self) -> Stroke {
-        self.unwrap_or(Stroke::default())
-    }
-}
-
-impl Resolve for RawStroke {
-    type Output = RawStroke<Length>;
-
-    fn resolve(self, styles: StyleChain) -> Self::Output {
-        RawStroke {
-            paint: self.paint,
-            thickness: self.thickness.resolve(styles),
-        }
-    }
-}
-
-impl Fold for RawStroke<Length> {
-    type Output = Self;
-
-    fn fold(self, outer: Self::Output) -> Self::Output {
-        Self {
-            paint: self.paint.or(outer.paint),
-            thickness: self.thickness.or(outer.thickness),
-        }
-    }
-}
-
-impl<T: Debug> Debug for RawStroke<T> {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        match (self.paint, &self.thickness) {
-            (Smart::Custom(paint), Smart::Custom(thickness)) => {
-                write!(f, "{thickness:?} + {paint:?}")
-            }
-            (Smart::Custom(paint), Smart::Auto) => paint.fmt(f),
-            (Smart::Auto, Smart::Custom(thickness)) => thickness.fmt(f),
-            (Smart::Auto, Smart::Auto) => f.pad("<stroke>"),
-        }
-    }
-}
-
-dynamic! {
-    RawStroke: "stroke",
-    Value::Length(thickness) => Self {
-        paint: Smart::Auto,
-        thickness: Smart::Custom(thickness),
-    },
-    Value::Color(color) => Self {
-        paint: Smart::Custom(color.into()),
-        thickness: Smart::Auto,
-    },
-}
-
-/// The unresolved length representation.
-///
-/// Currently supports absolute and em units, but support could quite easily be
-/// extended to other units that can be resolved through a style chain.
-/// Probably, it would be a good idea to then move to an enum representation
-/// that has a small footprint and allocates for the rare case that units are
-/// mixed.
-#[derive(Default, Copy, Clone, Eq, PartialEq, Hash)]
-pub struct RawLength {
-    /// The absolute part.
-    pub length: Length,
-    /// The font-relative part.
-    pub em: Em,
-}
-
-impl RawLength {
-    /// The zero length.
-    pub const fn zero() -> Self {
-        Self { length: Length::zero(), em: Em::zero() }
-    }
-}
-
-impl Debug for RawLength {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        match (self.length.is_zero(), self.em.is_zero()) {
-            (false, false) => write!(f, "{:?} + {:?}", self.length, self.em),
-            (true, false) => self.em.fmt(f),
-            (_, true) => self.length.fmt(f),
-        }
-    }
-}
-
-impl Resolve for Em {
-    type Output = Length;
-
-    fn resolve(self, styles: StyleChain) -> Self::Output {
-        if self.is_zero() {
-            Length::zero()
-        } else {
-            self.at(styles.get(TextNode::SIZE))
-        }
-    }
-}
-
-impl Resolve for RawLength {
-    type Output = Length;
-
-    fn resolve(self, styles: StyleChain) -> Self::Output {
-        self.length + self.em.resolve(styles)
-    }
-}
-
-impl Numeric for RawLength {
-    fn zero() -> Self {
-        Self::zero()
-    }
-
-    fn is_finite(self) -> bool {
-        self.length.is_finite() && self.em.is_finite()
-    }
-}
-
-impl PartialOrd for RawLength {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        if self.em.is_zero() && other.em.is_zero() {
-            self.length.partial_cmp(&other.length)
-        } else if self.length.is_zero() && other.length.is_zero() {
-            self.em.partial_cmp(&other.em)
-        } else {
-            None
-        }
-    }
-}
-
-impl From<Length> for RawLength {
-    fn from(length: Length) -> Self {
-        Self { length, em: Em::zero() }
-    }
-}
-
-impl From<Em> for RawLength {
-    fn from(em: Em) -> Self {
-        Self { length: Length::zero(), em }
-    }
-}
-
-impl From<Length> for Relative<RawLength> {
-    fn from(length: Length) -> Self {
-        Relative::from(RawLength::from(length))
-    }
-}
-
-impl Neg for RawLength {
-    type Output = Self;
-
-    fn neg(self) -> Self::Output {
-        Self { length: -self.length, em: -self.em }
-    }
-}
-
-impl Add for RawLength {
-    type Output = Self;
-
-    fn add(self, rhs: Self) -> Self::Output {
-        Self {
-            length: self.length + rhs.length,
-            em: self.em + rhs.em,
-        }
-    }
-}
-
-sub_impl!(RawLength - RawLength -> RawLength);
-
-impl Mul<f64> for RawLength {
-    type Output = Self;
-
-    fn mul(self, rhs: f64) -> Self::Output {
-        Self {
-            length: self.length * rhs,
-            em: self.em * rhs,
-        }
-    }
-}
-
-impl Div<f64> for RawLength {
-    type Output = Self;
-
-    fn div(self, rhs: f64) -> Self::Output {
-        Self {
-            length: self.length / rhs,
-            em: self.em / rhs,
-        }
-    }
-}
-
-assign_impl!(RawLength += RawLength);
-assign_impl!(RawLength -= RawLength);
-assign_impl!(RawLength *= f64);
-assign_impl!(RawLength /= f64);