Make percentages for h and v relative to area instead of font size

5 files changed, 19 insertions, 17 deletions

diff --git a/src/exec/context.rs b/src/exec/context.rs
index 9b235c29..2b0ef9fa 100644
--- a/src/exec/context.rs
+++ b/src/exec/context.rs
@@ -93,7 +93,7 @@ impl ExecContext {
     }
 
     /// Push spacing into the active paragraph or stack depending on the `axis`.
-    pub fn push_spacing(&mut self, axis: GenAxis, amount: Length) {
+    pub fn push_spacing(&mut self, axis: GenAxis, amount: Linear) {
         match axis {
             GenAxis::Main => {
                 self.stack.finish_par(&self.state);
@@ -114,7 +114,7 @@ impl ExecContext {
     pub fn parbreak(&mut self) {
         let amount = self.state.par_spacing();
         self.stack.finish_par(&self.state);
-        self.stack.push_soft(StackChild::Spacing(amount));
+        self.stack.push_soft(StackChild::Spacing(amount.into()));
     }
 
     /// Apply a forced page break.
diff --git a/src/exec/mod.rs b/src/exec/mod.rs
index dc3054d2..63e47995 100644
--- a/src/exec/mod.rs
+++ b/src/exec/mod.rs
@@ -119,7 +119,7 @@ fn exec_item(ctx: &mut ExecContext, label: EcoString, body: &SyntaxTree, map: &E
         aspect: None,
         children: vec![
             StackChild::Any(label.into(), Gen::default()),
-            StackChild::Spacing(ctx.state.font.size / 2.0),
+            StackChild::Spacing((ctx.state.font.size / 2.0).into()),
             StackChild::Any(body.into(), Gen::default()),
         ],
     });
diff --git a/src/layout/par.rs b/src/layout/par.rs
index a88a0f0b..c8512243 100644
--- a/src/layout/par.rs
+++ b/src/layout/par.rs
@@ -27,7 +27,7 @@ pub struct ParNode {
 #[cfg_attr(feature = "layout-cache", derive(Hash))]
 pub enum ParChild {
     /// Spacing between other nodes.
-    Spacing(Length),
+    Spacing(Linear),
     /// A run of text and how to align it in its line.
     Text(EcoString, Align, Rc<FontState>),
     /// Any child node and how to align it in its line.
@@ -137,7 +137,8 @@ impl<'a> ParLayouter<'a> {
         for (range, child) in par.ranges().zip(&par.children) {
             match *child {
                 ParChild::Spacing(amount) => {
-                    items.push(ParItem::Spacing(amount));
+                    let resolved = amount.resolve(regions.current.width);
+                    items.push(ParItem::Spacing(resolved));
                     ranges.push(range);
                 }
                 ParChild::Text(_, align, ref state) => {
diff --git a/src/layout/stack.rs b/src/layout/stack.rs
index 7f0f2b9d..504c64aa 100644
--- a/src/layout/stack.rs
+++ b/src/layout/stack.rs
@@ -24,7 +24,7 @@ pub struct StackNode {
 #[cfg_attr(feature = "layout-cache", derive(Hash))]
 pub enum StackChild {
     /// Spacing between other nodes.
-    Spacing(Length),
+    Spacing(Linear),
     /// Any child node and how to align it in the stack.
     Any(LayoutNode, Gen<Align>),
 }
@@ -125,11 +125,15 @@ impl<'a> StackLayouter<'a> {
     }
 
     /// Add main-axis spacing into the current region.
-    fn space(&mut self, amount: Length) {
+    fn space(&mut self, amount: Linear) {
+        // Resolve the linear.
+        let full = self.full.get(self.main);
+        let resolved = amount.resolve(full);
+
         // Cap the spacing to the remaining available space. This action does
         // not directly affect the constraints because of the cap.
         let remaining = self.regions.current.get_mut(self.main);
-        let capped = amount.min(*remaining);
+        let capped = resolved.min(*remaining);
 
         // Grow our size and shrink the available space in the region.
         self.used.main += capped;
diff --git a/src/library/layout.rs b/src/library/layout.rs
index 977b3153..67e58606 100644
--- a/src/library/layout.rs
+++ b/src/library/layout.rs
@@ -80,20 +80,17 @@ pub fn pagebreak(_: &mut EvalContext, _: &mut Arguments) -> TypResult<Value> {
 
 /// `h`: Horizontal spacing.
 pub fn h(_: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
-    spacing_impl(args, GenAxis::Cross)
+    let spacing = args.expect("spacing")?;
+    Ok(Value::template(move |ctx| {
+        ctx.push_spacing(GenAxis::Cross, spacing);
+    }))
 }
 
 /// `v`: Vertical spacing.
 pub fn v(_: &mut EvalContext, args: &mut Arguments) -> TypResult<Value> {
-    spacing_impl(args, GenAxis::Main)
-}
-
-fn spacing_impl(args: &mut Arguments, axis: GenAxis) -> TypResult<Value> {
-    let spacing = args.expect::<Linear>("spacing")?;
+    let spacing = args.expect("spacing")?;
     Ok(Value::template(move |ctx| {
-        // TODO: Should this really always be font-size relative?
-        let amount = spacing.resolve(ctx.state.font.size);
-        ctx.push_spacing(axis, amount);
+        ctx.push_spacing(GenAxis::Main, spacing);
     }))
 }