Pretty good stack layouter ✈

1 files changed, 112 insertions, 65 deletions

diff --git a/src/layout/stack.rs b/src/layout/stack.rs
index 369b1c81..27ca433b 100644
--- a/src/layout/stack.rs
+++ b/src/layout/stack.rs
@@ -1,14 +1,15 @@
 use smallvec::smallvec;
-use crate::size::{min, max};
+use crate::size::max;
 use super::*;
 
-/// The stack layouter arranges boxes stacked onto each other.
+/// The stack layouter stack boxes onto each other along the secondary layouting
+/// axis.
 ///
-/// The boxes are laid out in the direction of the secondary layouting axis and
-/// are aligned along both axes.
+/// The boxes are aligned along both axes according to their requested
+/// alignment.
 #[derive(Debug, Clone)]
 pub struct StackLayouter {
-    /// The context for layouter.
+    /// The context for layouting.
     ctx: StackContext,
     /// The output layouts.
     layouts: MultiLayout,
@@ -17,13 +18,19 @@ pub struct StackLayouter {
 }
 
 /// The context for stack layouting.
-///
-/// See [`LayoutContext`] for details about the fields.
 #[derive(Debug, Clone)]
 pub struct StackContext {
+    /// The spaces to layout in.
     pub spaces: LayoutSpaces,
+    /// The initial layouting axes, which can be updated by the
+    /// [`StackLayouter::set_axes`] method.
     pub axes: LayoutAxes,
+    /// Which alignment to set on the resulting layout. This affects how it will
+    /// be positioned in a parent box.
     pub alignment: LayoutAlignment,
+    /// Whether to output a command which renders a debugging box showing the
+    /// extent of the layout.
+    pub debug: bool,
 }
 
 /// A layout space composed of subspaces which can have different axes and
@@ -42,19 +49,26 @@ struct Space {
     usable: Size2D,
     /// The specialized extra-needed dimensions to affect the size at all.
     extra: Size2D,
-    /// The maximal secondary alignment for both specialized axes (horizontal,
-    /// vertical).
-    alignment: (Alignment, Alignment),
+    /// Dictates the valid alignments for new boxes in this space.
+    rulers: Rulers,
     /// The last added spacing if the last added thing was spacing.
     last_spacing: LastSpacing,
 }
 
+/// The rulers of a space dictate which alignments for new boxes are still
+/// allowed and which require a new space to be started.
+#[derive(Debug, Clone)]
+struct Rulers {
+    top: Alignment,
+    bottom: Alignment,
+    left: Alignment,
+    right: Alignment,
+}
+
 impl StackLayouter {
     /// Create a new stack layouter.
     pub fn new(ctx: StackContext) -> StackLayouter {
-        let axes = ctx.axes;
         let space = ctx.spaces[0];
-
         StackLayouter {
             ctx,
             layouts: MultiLayout::new(),
@@ -64,23 +78,15 @@ impl StackLayouter {
 
     /// Add a layout to the stack.
     pub fn add(&mut self, layout: Layout) -> LayoutResult<()> {
-        // If the layout's secondary alignment is less than what we have already
-        // seen, it needs to go into the next space.
-        if layout.alignment.secondary < *self.secondary_alignment() {
+        if !self.update_rulers(layout.alignment) {
             self.finish_space(true);
         }
 
-        if layout.alignment.secondary == *self.secondary_alignment() {
-            // Add a cached soft space if there is one and the alignment stayed
-            // the same. Soft spaces are discarded if the alignment changes.
-            if let LastSpacing::Soft(spacing, _) = self.space.last_spacing {
-                self.add_spacing(spacing, SpacingKind::Hard);
-            }
-        } else {
-            // We want the new maximal alignment and since the layout's
-            // secondary alignment is at least the previous maximum, we just
-            // take it.
-            *self.secondary_alignment() = layout.alignment.secondary;
+        // Now, we add a possibly cached soft space. If the secondary alignment
+        // changed before, a possibly cached space would have already been
+        // discarded.
+        if let LastSpacing::Soft(spacing, _) = self.space.last_spacing {
+            self.add_spacing(spacing, SpacingKind::Hard);
         }
 
         // Find the first space that fits the layout.
@@ -93,8 +99,11 @@ impl StackLayouter {
             self.finish_space(true);
         }
 
+        // Change the usable space and size of the space.
         self.update_metrics(layout.dimensions.generalized(self.ctx.axes));
 
+        // Add the box to the vector and remember that spacings are allowed
+        // again.
         self.space.layouts.push((self.ctx.axes, layout));
         self.space.last_spacing = LastSpacing::None;
 
@@ -103,7 +112,7 @@ impl StackLayouter {
 
     /// Add multiple layouts to the stack.
     ///
-    /// This function simply calls `add` for each layout.
+    /// This function simply calls `add` repeatedly for each layout.
     pub fn add_multiple(&mut self, layouts: MultiLayout) -> LayoutResult<()> {
         for layout in layouts {
             self.add(layout)?;
@@ -121,7 +130,6 @@ impl StackLayouter {
                 let dimensions = Size2D::with_y(spacing);
 
                 self.update_metrics(dimensions);
-
                 self.space.layouts.push((self.ctx.axes, Layout {
                     dimensions: dimensions.specialized(self.ctx.axes),
                     alignment: LayoutAlignment::default(),
@@ -147,6 +155,26 @@ impl StackLayouter {
         }
     }
 
+    /// Update the rulers to account for the new layout. Returns true if a
+    /// space break is necessary.
+    fn update_rulers(&mut self, alignment: LayoutAlignment) -> bool {
+        let axes = self.ctx.axes;
+        let allowed = self.alignment_allowed(axes.primary, alignment.primary)
+            && self.alignment_allowed(axes.secondary, alignment.secondary);
+
+        if allowed {
+            *self.space.rulers.get(axes.secondary) = alignment.secondary;
+        }
+
+        allowed
+    }
+
+    /// Whether the given alignment is still allowed according to the rulers.
+    fn alignment_allowed(&mut self, axis: Axis, alignment: Alignment) -> bool {
+        alignment >= *self.space.rulers.get(axis)
+        && alignment <= self.space.rulers.get(axis.inv()).inv()
+    }
+
     /// Update the size metrics to reflect that a layout or spacing with the
     /// given generalized dimensions has been added.
     fn update_metrics(&mut self, dimensions: Size2D) {
@@ -196,8 +224,12 @@ impl StackLayouter {
     /// The remaining unpadded, unexpanding spaces. If a multi-layout is laid
     /// out into these spaces, it will fit into this stack.
     pub fn remaining(&self) -> LayoutSpaces {
+        let dimensions = self.space.usable
+            - Size2D::with_y(self.space.last_spacing.soft_or_zero())
+                .specialized(self.ctx.axes);
+
         let mut spaces = smallvec![LayoutSpace {
-            dimensions: self.space.usable,
+            dimensions,
             padding: SizeBox::ZERO,
             expand: LayoutExpansion::new(false, false),
         }];
@@ -280,18 +312,34 @@ impl StackLayouter {
         // Step 3: Backward pass. Reduce the bounding boxes from the previous
         // layouts by what is taken by the following ones.
 
-        let mut extent = Size::ZERO;
+        // The `x` field stores the maximal primary extent in one axis-aligned
+        // run, while the `y` fields stores the accumulated secondary extent.
+        let mut extent = Size2D::ZERO;
+        let mut rotated = false;
 
         for (bound, entry) in bounds.iter_mut().zip(&self.space.layouts).rev() {
             let (axes, layout) = entry;
 
+            // When the axes get rotated, the the maximal primary size
+            // (`extent.x`) dictates how much secondary extent the whole run
+            // had. This value is thus stored in `extent.y`. The primary extent
+            // is reset for this new axis-aligned run.
+            let is_horizontal = axes.secondary.is_horizontal();
+            if is_horizontal != rotated {
+                extent.y = extent.x;
+                extent.x = Size::ZERO;
+                rotated = is_horizontal;
+            }
+
             // We reduce the bounding box of this layout at it's end by the
             // accumulated secondary extent of all layouts we have seen so far,
             // which are the layouts after this one since we iterate reversed.
-            *bound.secondary_end_mut(*axes) -= axes.secondary.factor() * extent;
+            *bound.secondary_end_mut(*axes) -= axes.secondary.factor() * extent.y;
 
             // Then, we add this layout's secondary extent to the accumulator.
-            extent += layout.dimensions.secondary(*axes);
+            let size = layout.dimensions.generalized(*axes);
+            extent.x.max_eq(size.x);
+            extent.y += size.y;
         }
 
         // ------------------------------------------------------------------ //
@@ -299,38 +347,26 @@ impl StackLayouter {
         // into a single finished layout.
 
         let mut actions = LayoutActions::new();
-        actions.add(LayoutAction::DebugBox(dimensions));
 
-        let layouts = std::mem::replace(&mut self.space.layouts, vec![]);
+        if self.ctx.debug {
+            actions.add(LayoutAction::DebugBox(dimensions));
+        }
 
+        let layouts = std::mem::replace(&mut self.space.layouts, vec![]);
         for ((axes, layout), bound) in layouts.into_iter().zip(bounds) {
-            let LayoutAxes { primary, secondary } = axes;
-
             let size = layout.dimensions.specialized(axes);
             let alignment = layout.alignment;
 
-            // The space in which this layout is aligned is given by it's
-            // corresponding bound box.
-            let usable = Size2D::new(
-                bound.right - bound.left,
-                bound.bottom - bound.top
-            ).generalized(axes);
-
-            let offsets = Size2D {
-                x: usable.x.anchor(alignment.primary, primary.is_positive())
-                    - size.x.anchor(alignment.primary, primary.is_positive()),
-                y: usable.y.anchor(alignment.secondary, secondary.is_positive())
-                    - size.y.anchor(alignment.secondary, secondary.is_positive()),
-            };
+            // The space in which this layout is aligned is given by the
+            // distances between the borders of it's bounding box.
+            let usable =
+                Size2D::new(bound.right - bound.left, bound.bottom - bound.top)
+                    .generalized(axes);
 
-            let position = Size2D::new(bound.left, bound.top)
-                + offsets.specialized(axes);
+            let local = usable.anchor(alignment, axes) - size.anchor(alignment, axes);
+            let pos = Size2D::new(bound.left, bound.top) + local.specialized(axes);
 
-            println!("pos: {}", position);
-            println!("usable: {}", usable);
-            println!("size: {}", size);
-
-            actions.add_layout(position, layout);
+            actions.add_layout(pos, layout);
         }
 
         self.layouts.push(Layout {
@@ -339,6 +375,9 @@ impl StackLayouter {
             actions: actions.to_vec(),
         });
 
+        // ------------------------------------------------------------------ //
+        // Step 5: Start the next space.
+
         self.start_space(self.next_space(), hard);
     }
 
@@ -352,14 +391,6 @@ impl StackLayouter {
     fn next_space(&self) -> usize {
         (self.space.index + 1).min(self.ctx.spaces.len() - 1)
     }
-
-    // Access the secondary alignment in the current system of axes.
-    fn secondary_alignment(&mut self) -> &mut Alignment {
-        match self.ctx.axes.primary.is_horizontal() {
-            true => &mut self.space.alignment.1,
-            false => &mut self.space.alignment.0,
-        }
-    }
 }
 
 impl Space {
@@ -371,8 +402,24 @@ impl Space {
             size: Size2D::ZERO,
             usable,
             extra: Size2D::ZERO,
-            alignment: (Alignment::Origin, Alignment::Origin),
+            rulers: Rulers {
+                top: Alignment::Origin,
+                bottom: Alignment::Origin,
+                left: Alignment::Origin,
+                right: Alignment::Origin,
+            },
             last_spacing: LastSpacing::Hard,
         }
     }
 }
+
+impl Rulers {
+    fn get(&mut self, axis: Axis) -> &mut Alignment {
+        match axis {
+            Axis::TopToBottom => &mut self.top,
+            Axis::BottomToTop => &mut self.bottom,
+            Axis::LeftToRight => &mut self.left,
+            Axis::RightToLeft => &mut self.right,
+        }
+    }
+}