From ed0c80401782a6c42173f0bb123731b798a2cfe1 Mon Sep 17 00:00:00 2001
From: Laurenz <laurmaedje@gmail.com>
Date: Mon, 27 Sep 2021 15:11:56 +0200
Subject: Add spacing capabilities to stack function

- Named argument `spacing` controls spacing between any two template arguments
- Arbitrary linears in the list can produce arbitrary spacing
---
 src/library/layout.rs | 98 +++++++++++++++++++++++++++++++++------------------
 1 file changed, 63 insertions(+), 35 deletions(-)

(limited to 'src/library/layout.rs')

diff --git a/src/library/layout.rs b/src/library/layout.rs
index e958f3a3..87cedd99 100644
--- a/src/library/layout.rs
+++ b/src/library/layout.rs
@@ -188,8 +188,22 @@ pub fn pad(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
 
 /// `stack`: Stack children along an axis.
 pub fn stack(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
+    enum Child {
+        Spacing(Linear),
+        Any(Template),
+    }
+
+    castable! {
+        Child: "linear or template",
+        Value::Length(v) => Self::Spacing(v.into()),
+        Value::Relative(v) => Self::Spacing(v.into()),
+        Value::Linear(v) => Self::Spacing(v),
+        Value::Template(v) => Self::Any(v),
+    }
+
     let dir = args.named("dir")?;
-    let children: Vec<Template> = args.all().collect();
+    let spacing = args.named("spacing")?;
+    let list: Vec<Child> = args.all().collect();
 
     Ok(Value::Template(Template::from_block(move |state| {
         let mut dirs = Gen::new(None, dir).unwrap_or(state.dirs);
@@ -208,10 +222,27 @@ pub fn stack(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
             aligns = Gen::new(aligns.block, aligns.inline);
         }
 
-        let children = children
-            .iter()
-            .map(|child| StackChild::Any(child.to_stack(state).into(), aligns))
-            .collect();
+        let mut children = vec![];
+        let mut delayed = None;
+
+        // Build the list of stack children.
+        for child in &list {
+            match child {
+                Child::Spacing(v) => {
+                    children.push(StackChild::Spacing(*v));
+                    delayed = None;
+                }
+                Child::Any(template) => {
+                    if let Some(v) = delayed {
+                        children.push(StackChild::Spacing(v));
+                    }
+
+                    let node = template.to_stack(state).into();
+                    children.push(StackChild::Any(node, aligns));
+                    delayed = spacing;
+                }
+            }
+        }
 
         StackNode { dirs, children }
     })))
@@ -219,27 +250,45 @@ pub fn stack(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
 
 /// `grid`: Arrange children into a grid.
 pub fn grid(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
+    castable! {
+        Vec<TrackSizing>: "array of autos, linears, and fractionals",
+        Value::Int(count) => vec![TrackSizing::Auto; count.max(0) as usize],
+        Value::Array(values) => values
+            .into_iter()
+            .filter_map(|v| v.cast().ok())
+            .collect(),
+    }
+
+    castable! {
+        TrackSizing: "auto, linear, or fractional",
+        Value::Auto => Self::Auto,
+        Value::Length(v) => Self::Linear(v.into()),
+        Value::Relative(v) => Self::Linear(v.into()),
+        Value::Linear(v) => Self::Linear(v),
+        Value::Fractional(v) => Self::Fractional(v),
+    }
+
     let columns = args.named("columns")?.unwrap_or_default();
     let rows = args.named("rows")?.unwrap_or_default();
+    let tracks = Gen::new(columns, rows);
+
+    let column_dir = args.named("column-dir")?;
+    let row_dir = args.named("row-dir")?;
 
     let gutter_columns = args.named("gutter-columns")?;
     let gutter_rows = args.named("gutter-rows")?;
-    let default = args
+    let gutter_default = args
         .named("gutter")?
         .map(|v| vec![TrackSizing::Linear(v)])
         .unwrap_or_default();
 
-    let column_dir = args.named("column-dir")?;
-    let row_dir = args.named("row-dir")?;
-
-    let children: Vec<Template> = args.all().collect();
-
-    let tracks = Gen::new(columns, rows);
     let gutter = Gen::new(
-        gutter_columns.unwrap_or_else(|| default.clone()),
-        gutter_rows.unwrap_or(default),
+        gutter_columns.unwrap_or_else(|| gutter_default.clone()),
+        gutter_rows.unwrap_or(gutter_default),
     );
 
+    let children: Vec<Template> = args.all().collect();
+
     Ok(Value::Template(Template::from_block(move |state| {
         // If the directions become aligned, try to fix up the direction which
         // is not user-defined.
@@ -269,24 +318,3 @@ pub fn grid(_: &mut EvalContext, args: &mut Args) -> TypResult<Value> {
         }
     })))
 }
-
-/// Defines size of rows and columns in a grid.
-type Tracks = Vec<TrackSizing>;
-
-castable! {
-    Tracks: "array of `auto`s, linears, and fractionals",
-    Value::Int(count) => vec![TrackSizing::Auto; count.max(0) as usize],
-    Value::Array(values) => values
-        .into_iter()
-        .filter_map(|v| v.cast().ok())
-        .collect(),
-}
-
-castable! {
-    TrackSizing: "`auto`, linear, or fractional",
-    Value::Auto => TrackSizing::Auto,
-    Value::Length(v) => TrackSizing::Linear(v.into()),
-    Value::Relative(v) => TrackSizing::Linear(v.into()),
-    Value::Linear(v) => TrackSizing::Linear(v),
-    Value::Fractional(v) => TrackSizing::Fractional(v),
-}
-- 
cgit v1.2.3