Support for align parameter in table to take an array (#1087) (#1149)

1 files changed, 18 insertions, 6 deletions

diff --git a/library/src/layout/table.rs b/library/src/layout/table.rs
index 6e3e6330..29e2edb8 100644
--- a/library/src/layout/table.rs
+++ b/library/src/layout/table.rs
@@ -87,9 +87,10 @@ pub struct TableElem {
 
     /// How to align the cell's content.
     ///
-    /// This can either be a single alignment or a function that returns an
-    /// alignment. The function is passed the cell's column and row index,
-    /// starting at zero. If set to `{auto}`, the outer alignment is used.
+    /// This can either be a single alignment, an array of alignments
+    /// (corresponding to each column) or a function that returns an alignment.
+    /// The function is passed the cell's column and row index, starting at zero.
+    /// If set to `{auto}`, the outer alignment is used.
     ///
     /// ```example
     /// #table(
@@ -236,9 +237,11 @@ pub enum Celled<T> {
     Value(T),
     /// A closure mapping from cell coordinates to a value.
     Func(Func),
+    /// An array of alignment values corresponding to each column.
+    Array(Vec<T>),
 }
 
-impl<T: Cast + Clone> Celled<T> {
+impl<T: Cast + Clone + Default> Celled<T> {
     /// Resolve the value based on the cell position.
     pub fn resolve(&self, vt: &mut Vt, x: usize, y: usize) -> SourceResult<T> {
         Ok(match self {
@@ -247,6 +250,11 @@ impl<T: Cast + Clone> Celled<T> {
                 .call_vt(vt, [Value::Int(x as i64), Value::Int(y as i64)])?
                 .cast()
                 .at(func.span())?,
+            Self::Array(array) => x
+                .checked_rem(array.len())
+                .and_then(|i| array.get(i))
+                .cloned()
+                .unwrap_or_default(),
         })
     }
 }
@@ -259,19 +267,22 @@ impl<T: Default> Default for Celled<T> {
 
 impl<T: Cast> Cast for Celled<T> {
     fn is(value: &Value) -> bool {
-        matches!(value, Value::Func(_)) || T::is(value)
+        matches!(value, Value::Array(_) | Value::Func(_)) || T::is(value)
     }
 
     fn cast(value: Value) -> StrResult<Self> {
         match value {
             Value::Func(v) => Ok(Self::Func(v)),
+            Value::Array(array) => {
+                Ok(Self::Array(array.into_iter().map(T::cast).collect::<StrResult<_>>()?))
+            }
             v if T::is(&v) => Ok(Self::Value(T::cast(v)?)),
             v => <Self as Cast>::error(v),
         }
     }
 
     fn describe() -> CastInfo {
-        T::describe() + CastInfo::Type("function")
+        T::describe() + CastInfo::Type("array") + CastInfo::Type("function")
     }
 }
 
@@ -280,6 +291,7 @@ impl<T: Into<Value>> From<Celled<T>> for Value {
         match celled {
             Celled::Value(value) => value.into(),
             Celled::Func(func) => func.into(),
+            Celled::Array(arr) => arr.into(),
         }
     }
 }