Simpler alignment resolving

7 files changed, 31 insertions, 19 deletions

diff --git a/src/geom/align.rs b/src/geom/align.rs
index 4be696e6..f068b821 100644
--- a/src/geom/align.rs
+++ b/src/geom/align.rs
@@ -38,12 +38,12 @@ impl Align {
         }
     }
 
-    /// Returns the position of this alignment in the given range.
-    pub fn resolve(self, range: Range<Length>) -> Length {
+    /// Returns the position of this alignment in the given length.
+    pub fn resolve(self, length: Length) -> Length {
         match self {
-            Self::Left | Self::Top => range.start,
-            Self::Center | Self::Horizon => (range.start + range.end) / 2.0,
-            Self::Right | Self::Bottom => range.end,
+            Self::Left | Self::Top => Length::zero(),
+            Self::Center | Self::Horizon => length / 2.0,
+            Self::Right | Self::Bottom => length,
         }
     }
 }
diff --git a/src/library/align.rs b/src/library/align.rs
index 7ce749d1..fa4d17c5 100644
--- a/src/library/align.rs
+++ b/src/library/align.rs
@@ -45,8 +45,8 @@ impl Layout for AlignNode {
 
             let aligns = self.aligns.unwrap_or(Spec::new(Align::Left, Align::Top));
             let offset = Point::new(
-                aligns.x.resolve(Length::zero() .. canvas.w - frame.size.w),
-                aligns.y.resolve(Length::zero() .. canvas.h - frame.size.h),
+                aligns.x.resolve(canvas.w - frame.size.w),
+                aligns.y.resolve(canvas.h - frame.size.h),
             );
 
             let frame = Rc::make_mut(frame);
diff --git a/src/library/flow.rs b/src/library/flow.rs
index 5271eca9..93dcbea6 100644
--- a/src/library/flow.rs
+++ b/src/library/flow.rs
@@ -236,8 +236,8 @@ impl<'a> FlowLayouter<'a> {
                     ruler = ruler.max(aligns.y);
 
                     // Align horizontally and vertically.
-                    let x = aligns.x.resolve(Length::zero() .. size.w - frame.size.w);
-                    let y = ruler.resolve(before .. before + size.h - self.used.h);
+                    let x = aligns.x.resolve(size.w - frame.size.w);
+                    let y = before + ruler.resolve(size.h - self.used.h);
                     let pos = Point::new(x, y);
                     before += frame.size.h;
 
diff --git a/src/library/par.rs b/src/library/par.rs
index 5edffeaa..46dc304a 100644
--- a/src/library/par.rs
+++ b/src/library/par.rs
@@ -499,7 +499,7 @@ impl<'a> LineLayout<'a> {
                     }
                 }
 
-                let x = self.par.align.resolve(offset .. remaining + offset);
+                let x = offset + self.par.align.resolve(remaining);
                 let y = self.baseline - frame.baseline;
                 offset += frame.size.w;
 
diff --git a/src/library/stack.rs b/src/library/stack.rs
index 3d91bec7..a2e80ba5 100644
--- a/src/library/stack.rs
+++ b/src/library/stack.rs
@@ -230,19 +230,21 @@ impl<'a> StackLayouter<'a> {
                     before += v.resolve(self.fr, remaining);
                 }
                 StackItem::Frame(frame, align) => {
-                    ruler = ruler.max(align);
+                    if self.stack.dir.is_positive() {
+                        ruler = ruler.max(align);
+                    } else {
+                        ruler = ruler.min(align);
+                    }
 
                     // Align along the block axis.
                     let parent = size.get(self.axis);
                     let child = frame.size.get(self.axis);
-                    let block = ruler.resolve(if self.stack.dir.is_positive() {
-                        let after = self.used.block - before;
-                        before .. parent - after
-                    } else {
-                        let before_with_self = before + child;
-                        let after = self.used.block - before_with_self;
-                        after .. parent - before_with_self
-                    });
+                    let block = ruler.resolve(parent - self.used.block)
+                        + if self.stack.dir.is_positive() {
+                            before
+                        } else {
+                            self.used.block - child - before
+                        };
 
                     let pos = Gen::new(Length::zero(), block).to_point(self.axis);
                     before += child;
diff --git a/tests/ref/layout/stack-1.png b/tests/ref/layout/stack-1.png
index 535632c4..46c8d9d6 100644
--- a/tests/ref/layout/stack-1.png
+++ b/tests/ref/layout/stack-1.png
diff --git a/tests/typ/layout/stack-1.typ b/tests/typ/layout/stack-1.typ
index 2fbe22e3..02083d2b 100644
--- a/tests/typ/layout/stack-1.typ
+++ b/tests/typ/layout/stack-1.typ
@@ -19,6 +19,16 @@
 #stack(dir: btt, ..items)
 
 ---
+// Test RTL alignment.
+#page(width: 50pt, margins: 5pt)
+#font(8pt)
+#stack(dir: rtl,
+  align(center, [A]),
+  align(left, [B]),
+  [C],
+)
+
+---
 // Test spacing.
 #page(width: 50pt, margins: 0pt)
 #par(spacing: 5pt)