Make all nodes block-level

8 files changed, 100 insertions, 86 deletions

diff --git a/library/src/layout/container.rs b/library/src/layout/container.rs
index b7e7aa18..7bb6a6e9 100644
--- a/library/src/layout/container.rs
+++ b/library/src/layout/container.rs
@@ -38,7 +38,7 @@ use crate::prelude::*;
 /// ## Category
 /// layout
 #[func]
-#[capable(Layout, Inline)]
+#[capable(Layout)]
 #[derive(Debug, Hash)]
 pub struct BoxNode {
     /// How to size the content horizontally and vertically.
@@ -99,8 +99,6 @@ impl Layout for BoxNode {
     }
 }
 
-impl Inline for BoxNode {}
-
 /// # Block
 /// A block-level container that places content into a separate flow.
 ///
diff --git a/library/src/layout/flow.rs b/library/src/layout/flow.rs
index e21dcd2a..7b721c59 100644
--- a/library/src/layout/flow.rs
+++ b/library/src/layout/flow.rs
@@ -2,6 +2,7 @@ use typst::model::Style;
 
 use super::{AlignNode, BlockNode, ColbreakNode, ParNode, PlaceNode, Spacing, VNode};
 use crate::prelude::*;
+use crate::visualize::{CircleNode, EllipseNode, ImageNode, RectNode, SquareNode};
 
 /// Arrange spacing, paragraphs and block-level nodes into a flow.
 ///
@@ -31,8 +32,17 @@ impl Layout for FlowNode {
                 let barrier = Style::Barrier(child.id());
                 let styles = styles.chain_one(&barrier);
                 layouter.layout_par(vt, node, styles)?;
+            } else if child.is::<RectNode>()
+                || child.is::<SquareNode>()
+                || child.is::<EllipseNode>()
+                || child.is::<CircleNode>()
+                || child.is::<ImageNode>()
+            {
+                let barrier = Style::Barrier(child.id());
+                let styles = styles.chain_one(&barrier);
+                layouter.layout_single(vt, child, styles)?;
             } else if child.has::<dyn Layout>() {
-                layouter.layout_block(vt, child, styles)?;
+                layouter.layout_multiple(vt, child, styles)?;
             } else if child.is::<ColbreakNode>() {
                 layouter.finish_region();
             } else {
@@ -157,8 +167,25 @@ impl<'a> FlowLayouter<'a> {
         Ok(())
     }
 
-    /// Layout a block.
-    fn layout_block(
+    /// Layout into a single region.
+    fn layout_single(
+        &mut self,
+        vt: &mut Vt,
+        content: &Content,
+        styles: StyleChain,
+    ) -> SourceResult<()> {
+        let aligns = styles.get(AlignNode::ALIGNS).resolve(styles);
+        let sticky = styles.get(BlockNode::STICKY);
+        let pod = Regions::one(self.regions.base(), Axes::splat(false));
+        let layoutable = content.with::<dyn Layout>().unwrap();
+        let frame = layoutable.layout(vt, styles, pod)?.into_frame();
+        self.layout_item(FlowItem::Frame(frame, aligns, sticky));
+        self.last_was_par = false;
+        Ok(())
+    }
+
+    /// Layout into multiple regions.
+    fn layout_multiple(
         &mut self,
         vt: &mut Vt,
         block: &Content,
diff --git a/library/src/layout/hide.rs b/library/src/layout/hide.rs
index cedc2489..4f46324f 100644
--- a/library/src/layout/hide.rs
+++ b/library/src/layout/hide.rs
@@ -21,7 +21,7 @@ use crate::prelude::*;
 /// ## Category
 /// layout
 #[func]
-#[capable(Layout, Inline)]
+#[capable(Show)]
 #[derive(Debug, Hash)]
 pub struct HideNode(pub Content);
 
@@ -39,19 +39,8 @@ impl HideNode {
     }
 }
 
-impl Layout for HideNode {
-    fn layout(
-        &self,
-        vt: &mut Vt,
-        styles: StyleChain,
-        regions: Regions,
-    ) -> SourceResult<Fragment> {
-        let mut fragment = self.0.layout(vt, styles, regions)?;
-        for frame in &mut fragment {
-            frame.clear();
-        }
-        Ok(fragment)
+impl Show for HideNode {
+    fn show(&self, _: &mut Vt, _: &Content, _: StyleChain) -> SourceResult<Content> {
+        Ok(self.0.clone().styled(Meta::DATA, vec![Meta::Hidden]))
     }
 }
-
-impl Inline for HideNode {}
diff --git a/library/src/layout/mod.rs b/library/src/layout/mod.rs
index f603ef6c..3294a96c 100644
--- a/library/src/layout/mod.rs
+++ b/library/src/layout/mod.rs
@@ -57,6 +57,7 @@ use crate::meta::DocumentNode;
 use crate::prelude::*;
 use crate::shared::BehavedBuilder;
 use crate::text::{LinebreakNode, SmartQuoteNode, SpaceNode, TextNode};
+use crate::visualize::{CircleNode, EllipseNode, ImageNode, RectNode, SquareNode};
 
 /// Root-level layout.
 #[capability]
@@ -144,10 +145,6 @@ impl Layout for Content {
     }
 }
 
-/// Inline-level layout.
-#[capability]
-pub trait Inline: Layout {}
-
 /// Realize into a node that is capable of root-level layout.
 fn realize_root<'a>(
     vt: &mut Vt,
@@ -173,7 +170,14 @@ fn realize_block<'a>(
     content: &'a Content,
     styles: StyleChain<'a>,
 ) -> SourceResult<(Content, StyleChain<'a>)> {
-    if content.has::<dyn Layout>() && !applicable(content, styles) {
+    if content.has::<dyn Layout>()
+        && !content.is::<RectNode>()
+        && !content.is::<SquareNode>()
+        && !content.is::<EllipseNode>()
+        && !content.is::<CircleNode>()
+        && !content.is::<ImageNode>()
+        && !applicable(content, styles)
+    {
         return Ok((content.clone(), styles));
     }
 
@@ -464,18 +468,19 @@ struct ParBuilder<'a>(BehavedBuilder<'a>);
 impl<'a> ParBuilder<'a> {
     fn accept(&mut self, content: &'a Content, styles: StyleChain<'a>) -> bool {
         if content.is::<SpaceNode>()
-            || content.is::<LinebreakNode>()
+            || content.is::<TextNode>()
             || content.is::<HNode>()
             || content.is::<SmartQuoteNode>()
-            || content.is::<TextNode>()
-            || content.is::<FormulaNode>()
-            || content.has::<dyn Inline>()
+            || content.is::<LinebreakNode>()
+            || content.is::<BoxNode>()
+            || content.is::<RepeatNode>()
+            || content.to::<FormulaNode>().map_or(false, |node| !node.block)
         {
             self.0.push(content.clone(), styles);
             return true;
         }
 
-        if content.has::<dyn LayoutMath>() {
+        if !content.is::<FormulaNode>() && content.has::<dyn LayoutMath>() {
             let formula = FormulaNode { body: content.clone(), block: false }.pack();
             self.0.push(formula, styles);
             return true;
diff --git a/library/src/layout/par.rs b/library/src/layout/par.rs
index 21551268..b712d8b1 100644
--- a/library/src/layout/par.rs
+++ b/library/src/layout/par.rs
@@ -500,12 +500,14 @@ fn collect<'a>(
                 .0
                 .items()
                 .find_map(|child| {
-                    if child.is::<TextNode>() || child.is::<SmartQuoteNode>() {
+                    if child.with::<dyn Behave>().map_or(false, |behaved| {
+                        behaved.behaviour() == Behaviour::Ignorant
+                    }) {
+                        None
+                    } else if child.is::<TextNode>() || child.is::<SmartQuoteNode>() {
                         Some(true)
-                    } else if child.has::<dyn Inline>() {
-                        Some(false)
                     } else {
-                        None
+                        Some(false)
                     }
                 })
                 .unwrap_or_default()
@@ -558,11 +560,9 @@ fn collect<'a>(
         } else if let Some(&node) = child.to::<HNode>() {
             full.push(SPACING_REPLACE);
             Segment::Spacing(node.amount)
-        } else if child.has::<dyn Inline>() {
+        } else {
             full.push(NODE_REPLACE);
             Segment::Inline(child)
-        } else {
-            panic!("unexpected par child: {child:?}");
         };
 
         if let Some(last) = full.chars().last() {
diff --git a/library/src/layout/repeat.rs b/library/src/layout/repeat.rs
index 06806fb0..10cd1d25 100644
--- a/library/src/layout/repeat.rs
+++ b/library/src/layout/repeat.rs
@@ -26,7 +26,7 @@ use crate::prelude::*;
 /// ## Category
 /// layout
 #[func]
-#[capable(Layout, Inline)]
+#[capable(Layout)]
 #[derive(Debug, Hash)]
 pub struct RepeatNode(pub Content);
 
@@ -54,5 +54,3 @@ impl Layout for RepeatNode {
         self.0.layout(vt, styles, regions)
     }
 }
-
-impl Inline for RepeatNode {}
diff --git a/library/src/layout/stack.rs b/library/src/layout/stack.rs
index 5c1a471c..35a0ff6f 100644
--- a/library/src/layout/stack.rs
+++ b/library/src/layout/stack.rs
@@ -169,7 +169,7 @@ enum StackItem {
     /// Fractional spacing between other items.
     Fractional(Fr),
     /// A frame for a layouted block.
-    Frame(Frame, Align),
+    Frame(Frame, Axes<Align>),
 }
 
 impl<'a> StackLayouter<'a> {
@@ -239,7 +239,7 @@ impl<'a> StackLayouter<'a> {
             styles.get(AlignNode::ALIGNS)
         };
 
-        let align = aligns.get(self.axis).resolve(styles);
+        let aligns = aligns.resolve(styles);
         let fragment = block.layout(vt, styles, self.regions)?;
         let len = fragment.len();
         for (i, frame) in fragment.into_iter().enumerate() {
@@ -257,7 +257,7 @@ impl<'a> StackLayouter<'a> {
             self.used.main += gen.main;
             self.used.cross.set_max(gen.cross);
 
-            self.items.push(StackItem::Frame(frame, align));
+            self.items.push(StackItem::Frame(frame, aligns));
 
             if i + 1 < len {
                 self.finish_region();
@@ -291,24 +291,30 @@ impl<'a> StackLayouter<'a> {
             match item {
                 StackItem::Absolute(v) => cursor += v,
                 StackItem::Fractional(v) => cursor += v.share(self.fr, remaining),
-                StackItem::Frame(frame, align) => {
+                StackItem::Frame(frame, aligns) => {
                     if self.dir.is_positive() {
-                        ruler = ruler.max(align);
+                        ruler = ruler.max(aligns.get(self.axis));
                     } else {
-                        ruler = ruler.min(align);
+                        ruler = ruler.min(aligns.get(self.axis));
                     }
 
-                    // Align along the block axis.
+                    // Align along the main axis.
                     let parent = size.get(self.axis);
                     let child = frame.size().get(self.axis);
-                    let block = ruler.position(parent - self.used.main)
+                    let main = ruler.position(parent - self.used.main)
                         + if self.dir.is_positive() {
                             cursor
                         } else {
                             self.used.main - child - cursor
                         };
 
-                    let pos = Gen::new(Abs::zero(), block).to_point(self.axis);
+                    // Align along the cross axis.
+                    let other = self.axis.other();
+                    let cross = aligns
+                        .get(other)
+                        .position(size.get(other) - frame.size().get(other));
+
+                    let pos = Gen::new(cross, main).to_point(self.axis);
                     cursor += child;
                     output.push_frame(pos, frame);
                 }
diff --git a/library/src/layout/transform.rs b/library/src/layout/transform.rs
index 1c9dfce5..5977e90b 100644
--- a/library/src/layout/transform.rs
+++ b/library/src/layout/transform.rs
@@ -39,7 +39,7 @@ use crate::prelude::*;
 /// ## Category
 /// layout
 #[func]
-#[capable(Layout, Inline)]
+#[capable(Layout)]
 #[derive(Debug, Hash)]
 pub struct MoveNode {
     /// The offset by which to move the content.
@@ -75,18 +75,15 @@ impl Layout for MoveNode {
         styles: StyleChain,
         regions: Regions,
     ) -> SourceResult<Fragment> {
-        let mut fragment = self.body.layout(vt, styles, regions)?;
-        for frame in &mut fragment {
-            let delta = self.delta.resolve(styles);
-            let delta = delta.zip(regions.base()).map(|(d, s)| d.relative_to(s));
-            frame.translate(delta.to_point());
-        }
-        Ok(fragment)
+        let pod = Regions::one(regions.base(), Axes::splat(false));
+        let mut frame = self.body.layout(vt, styles, pod)?.into_frame();
+        let delta = self.delta.resolve(styles);
+        let delta = delta.zip(regions.base()).map(|(d, s)| d.relative_to(s));
+        frame.translate(delta.to_point());
+        Ok(Fragment::frame(frame))
     }
 }
 
-impl Inline for MoveNode {}
-
 /// # Rotate
 /// Rotate content with affecting layout.
 ///
@@ -116,7 +113,7 @@ impl Inline for MoveNode {}
 /// ## Category
 /// layout
 #[func]
-#[capable(Layout, Inline)]
+#[capable(Layout)]
 #[derive(Debug, Hash)]
 pub struct RotateNode {
     /// The angle by which to rotate the node.
@@ -169,21 +166,18 @@ impl Layout for RotateNode {
         styles: StyleChain,
         regions: Regions,
     ) -> SourceResult<Fragment> {
-        let mut fragment = self.body.layout(vt, styles, regions)?;
-        for frame in &mut fragment {
-            let origin = styles.get(Self::ORIGIN).unwrap_or(Align::CENTER_HORIZON);
-            let Axes { x, y } = origin.zip(frame.size()).map(|(o, s)| o.position(s));
-            let transform = Transform::translate(x, y)
-                .pre_concat(Transform::rotate(self.angle))
-                .pre_concat(Transform::translate(-x, -y));
-            frame.transform(transform);
-        }
-        Ok(fragment)
+        let pod = Regions::one(regions.base(), Axes::splat(false));
+        let mut frame = self.body.layout(vt, styles, pod)?.into_frame();
+        let origin = styles.get(Self::ORIGIN).unwrap_or(Align::CENTER_HORIZON);
+        let Axes { x, y } = origin.zip(frame.size()).map(|(o, s)| o.position(s));
+        let ts = Transform::translate(x, y)
+            .pre_concat(Transform::rotate(self.angle))
+            .pre_concat(Transform::translate(-x, -y));
+        frame.transform(ts);
+        Ok(Fragment::frame(frame))
     }
 }
 
-impl Inline for RotateNode {}
-
 /// # Scale
 /// Scale content without affecting layout.
 ///
@@ -214,7 +208,7 @@ impl Inline for RotateNode {}
 /// ## Category
 /// layout
 #[func]
-#[capable(Layout, Inline)]
+#[capable(Layout)]
 #[derive(Debug, Hash)]
 pub struct ScaleNode {
     /// Scaling factor.
@@ -262,17 +256,14 @@ impl Layout for ScaleNode {
         styles: StyleChain,
         regions: Regions,
     ) -> SourceResult<Fragment> {
-        let mut fragment = self.body.layout(vt, styles, regions)?;
-        for frame in &mut fragment {
-            let origin = styles.get(Self::ORIGIN).unwrap_or(Align::CENTER_HORIZON);
-            let Axes { x, y } = origin.zip(frame.size()).map(|(o, s)| o.position(s));
-            let transform = Transform::translate(x, y)
-                .pre_concat(Transform::scale(self.factor.x, self.factor.y))
-                .pre_concat(Transform::translate(-x, -y));
-            frame.transform(transform);
-        }
-        Ok(fragment)
+        let pod = Regions::one(regions.base(), Axes::splat(false));
+        let mut frame = self.body.layout(vt, styles, pod)?.into_frame();
+        let origin = styles.get(Self::ORIGIN).unwrap_or(Align::CENTER_HORIZON);
+        let Axes { x, y } = origin.zip(frame.size()).map(|(o, s)| o.position(s));
+        let transform = Transform::translate(x, y)
+            .pre_concat(Transform::scale(self.factor.x, self.factor.y))
+            .pre_concat(Transform::translate(-x, -y));
+        frame.transform(transform);
+        Ok(Fragment::frame(frame))
     }
 }
-
-impl Inline for ScaleNode {}