Evaluation and node-based layouting 🚀

1 files changed, 66 insertions, 168 deletions

diff --git a/src/layout/mod.rs b/src/layout/mod.rs
index 912ca010..f709da1a 100644
--- a/src/layout/mod.rs
+++ b/src/layout/mod.rs
@@ -1,88 +1,24 @@
-//! Layouting of syntax trees.
+//! Layouting of documents.
 
+pub mod nodes;
 pub mod primitive;
 
-mod line;
-mod stack;
-mod tree;
-
-pub use line::*;
 pub use primitive::*;
-pub use stack::*;
-pub use tree::*;
 
-use crate::diag::Diag;
+use async_trait::async_trait;
+
 use crate::eval::{PageState, State, TextState};
 use crate::font::SharedFontLoader;
 use crate::geom::{Insets, Point, Rect, Size, SizeExt};
 use crate::shaping::Shaped;
-use crate::syntax::{Deco, Spanned, SynTree};
-use crate::{Feedback, Pass};
-
-/// Layout a syntax tree and return the produced layout.
-pub async fn layout(
-    tree: &SynTree,
-    state: State,
-    loader: SharedFontLoader,
-) -> Pass<Vec<BoxLayout>> {
-    let space = LayoutSpace {
-        size: state.page.size,
-        insets: state.page.insets(),
-        expansion: Spec2::new(true, true),
-    };
-
-    let constraints = LayoutConstraints {
-        root: true,
-        base: space.usable(),
-        spaces: vec![space],
-        repeat: true,
-    };
-
-    let mut ctx = LayoutContext {
-        loader,
-        state,
-        constraints,
-        f: Feedback::new(),
-    };
-
-    let layouts = layout_tree(&tree, &mut ctx).await;
-    Pass::new(layouts, ctx.f)
-}
-
-/// A finished box with content at fixed positions.
-#[derive(Debug, Clone, PartialEq)]
-pub struct BoxLayout {
-    /// The size of the box.
-    pub size: Size,
-    /// The elements composing this layout.
-    pub elements: Vec<(Point, LayoutElement)>,
-}
+use crate::syntax::SynTree;
 
-impl BoxLayout {
-    /// Create a new empty collection.
-    pub fn new(size: Size) -> Self {
-        Self { size, elements: vec![] }
-    }
+use nodes::Document;
 
-    /// Add an element at a position.
-    pub fn push(&mut self, pos: Point, element: LayoutElement) {
-        self.elements.push((pos, element));
-    }
-
-    /// Add all elements of another collection, placing them relative to the
-    /// given position.
-    pub fn push_layout(&mut self, pos: Point, more: Self) {
-        for (subpos, element) in more.elements {
-            self.push(pos + subpos.to_vec2(), element);
-        }
-    }
-}
-
-/// A layout element, the basic building block layouts are composed of.
-#[derive(Debug, Clone, PartialEq)]
-pub enum LayoutElement {
-    /// Shaped text.
-    Text(Shaped),
+/// Layout a document and return the produced layouts.
+pub async fn layout(document: &Document, loader: SharedFontLoader) -> Vec<BoxLayout> {
+    let mut ctx = LayoutContext { loader };
+    document.layout(&mut ctx).await
 }
 
 /// The context for layouting.
@@ -90,33 +26,43 @@ pub enum LayoutElement {
 pub struct LayoutContext {
     /// The font loader to query fonts from when typesetting text.
     pub loader: SharedFontLoader,
-    /// The active state.
-    pub state: State,
-    /// The active constraints.
-    pub constraints: LayoutConstraints,
-    /// The accumulated feedback.
-    pub f: Feedback,
 }
 
-impl LayoutContext {
-    /// Add a diagnostic to the feedback.
-    pub fn diag(&mut self, diag: Spanned<Diag>) {
-        self.f.diags.push(diag);
-    }
+/// Layout a node.
+#[async_trait(?Send)]
+pub trait Layout {
+    /// Layout the node in the given layout context.
+    ///
+    /// This signature looks pretty horrible due to async in trait methods, but
+    /// it's actually just the following:
+    /// ```rust,ignore
+    /// async fn layout(
+    ///     &self,
+    ///     ctx: &mut LayoutContext,
+    ///     constraints: LayoutConstraints,
+    /// ) -> Vec<LayoutItem>;
+    /// ```
+    async fn layout(
+        &self,
+        ctx: &mut LayoutContext,
+        constraints: LayoutConstraints,
+    ) -> Vec<LayoutItem>;
+}
 
-    /// Add a decoration to the feedback.
-    pub fn deco(&mut self, deco: Spanned<Deco>) {
-        self.f.decos.push(deco);
-    }
+/// An item that is produced by [layouting] a node.
+///
+/// [layouting]: trait.Layout.html#method.layout
+#[derive(Debug, Clone, PartialEq)]
+pub enum LayoutItem {
+    /// Spacing that should be added to the parent.
+    Spacing(f64),
+    /// A box that should be aligned in the parent.
+    Box(BoxLayout, Gen2<GenAlign>),
 }
 
 /// The constraints for layouting a single node.
 #[derive(Debug, Clone)]
 pub struct LayoutConstraints {
-    /// Whether this layouting process is the root page-building process.
-    pub root: bool,
-    /// The unpadded size of this container (the base 100% for relative sizes).
-    pub base: Size,
     /// The spaces to layout into.
     pub spaces: Vec<LayoutSpace>,
     /// Whether to spill over into copies of the last space or finish layouting
@@ -127,92 +73,44 @@ pub struct LayoutConstraints {
 /// The space into which content is laid out.
 #[derive(Debug, Copy, Clone, PartialEq)]
 pub struct LayoutSpace {
+    /// The full size of this container (the base for relative sizes).
+    pub base: Size,
     /// The maximum size of the rectangle to layout into.
     pub size: Size,
-    /// Padding that should be respected on each side.
-    pub insets: Insets,
-    /// Whether to expand the size of the resulting layout to the full size of
-    /// this space or to shrink it to fit the content.
-    pub expansion: Spec2<bool>,
 }
 
-impl LayoutSpace {
-    /// The position of the padded start in the space.
-    pub fn start(&self) -> Point {
-        Point::new(-self.insets.x0, -self.insets.y0)
+/// A finished box with content at fixed positions.
+#[derive(Debug, Clone, PartialEq)]
+pub struct BoxLayout {
+    /// The size of the box.
+    pub size: Size,
+    /// The elements composing this layout.
+    pub elements: Vec<(Point, LayoutElement)>,
+}
+
+impl BoxLayout {
+    /// Create a new empty collection.
+    pub fn new(size: Size) -> Self {
+        Self { size, elements: vec![] }
     }
 
-    /// The actually usable area (size minus padding).
-    pub fn usable(&self) -> Size {
-        self.size + self.insets.size()
+    /// Add an element at a position.
+    pub fn push(&mut self, pos: Point, element: LayoutElement) {
+        self.elements.push((pos, element));
     }
 
-    /// The inner layout space with size reduced by the padding, zero padding of
-    /// its own and no layout expansion.
-    pub fn inner(&self) -> Self {
-        Self {
-            size: self.usable(),
-            insets: Insets::ZERO,
-            expansion: Spec2::new(false, false),
+    /// Add all elements of another collection, placing them relative to the
+    /// given position.
+    pub fn push_layout(&mut self, pos: Point, more: Self) {
+        for (subpos, element) in more.elements {
+            self.push(pos + subpos.to_vec2(), element);
         }
     }
 }
 
-/// Commands executable by the layouting engine.
+/// A layout element, the basic building block layouts are composed of.
 #[derive(Debug, Clone, PartialEq)]
-pub enum Command {
-    /// Layout the given tree in the current context (i.e. not nested). The
-    /// content of the tree is not laid out into a separate box and then added,
-    /// but simply laid out flatly in the active layouting process.
-    ///
-    /// This has the effect that the content fits nicely into the active line
-    /// layouting, enabling functions to e.g. change the style of some piece of
-    /// text while keeping it part of the current paragraph.
-    LayoutSyntaxTree(SynTree),
-
-    /// Add a finished layout.
-    Add(BoxLayout, Gen2<GenAlign>),
-    /// Add spacing of the given kind along the given axis. The
-    /// kind defines how the spacing interacts with surrounding spacing.
-    AddSpacing(f64, SpacingKind, GenAxis),
-
-    /// Start a new line.
-    BreakLine,
-    /// Start a new page, which will be part of the finished layout even if it
-    /// stays empty (since the page break is a _hard_ space break).
-    BreakPage,
-
-    /// Update the text style.
-    SetTextState(TextState),
-    /// Update the page style.
-    SetPageState(PageState),
-    /// Update the alignment for future boxes added to this layouting process.
-    SetAlignment(Gen2<GenAlign>),
-}
-
-/// Defines how spacing interacts with surrounding spacing.
-///
-/// There are two options for interaction: Hard and soft spacing. Typically,
-/// hard spacing is used when a fixed amount of space needs to be inserted no
-/// matter what. In contrast, soft spacing can be used to insert a default
-/// spacing between e.g. two words or paragraphs that can still be overridden by
-/// a hard space.
-#[derive(Debug, Copy, Clone, Eq, PartialEq)]
-pub enum SpacingKind {
-    /// Hard spaces are always laid out and consume surrounding soft space.
-    Hard,
-    /// Soft spaces are not laid out if they are touching a hard space and
-    /// consume neighbouring soft spaces with higher levels.
-    Soft(u32),
-}
-
-impl SpacingKind {
-    /// The standard spacing kind used for paragraph spacing.
-    pub const PARAGRAPH: Self = Self::Soft(1);
-
-    /// The standard spacing kind used for line spacing.
-    pub const LINE: Self = Self::Soft(2);
-
-    /// The standard spacing kind used for word spacing.
-    pub const WORD: Self = Self::Soft(1);
+pub enum LayoutElement {
+    /// Shaped text.
+    Text(Shaped),
 }