Refactor layouting base 🪁

1 files changed, 25 insertions, 30 deletions

diff --git a/src/layout/pad.rs b/src/layout/pad.rs
index e7584dc8..2574fa16 100644
--- a/src/layout/pad.rs
+++ b/src/layout/pad.rs
@@ -4,45 +4,40 @@ use crate::geom::Linear;
 /// A node that pads its child at the sides.
 #[derive(Debug, Clone, PartialEq)]
 pub struct Pad {
+    /// The amount of padding.
     pub padding: Sides<Linear>,
+    /// The child node whose sides to pad.
     pub child: LayoutNode,
 }
 
 #[async_trait(?Send)]
 impl Layout for Pad {
-    async fn layout(
-        &self,
-        ctx: &mut LayoutContext,
-        constraints: LayoutConstraints,
-    ) -> Vec<Layouted> {
-        self.child
-            .layout(ctx, LayoutConstraints {
-                spaces: constraints
-                    .spaces
-                    .into_iter()
-                    .map(|space| LayoutSpace {
-                        base: space.base - self.padding.eval(space.base).size(),
-                        size: space.size - self.padding.eval(space.size).size(),
-                    })
-                    .collect(),
-                repeat: constraints.repeat,
-            })
-            .await
-            .into_iter()
-            .map(|item| match item {
-                Layouted::Box(boxed, align) => {
-                    let padding = self.padding.eval(boxed.size);
-                    let padded = boxed.size + padding.size();
+    async fn layout(&self, ctx: &mut LayoutContext, areas: &Areas) -> Vec<Layouted> {
+        let shrink = |size| size - self.padding.eval(size).size();
+        let areas = Areas {
+            current: Area {
+                rem: shrink(areas.current.rem),
+                full: shrink(areas.current.full),
+            },
+            backlog: areas.backlog.iter().copied().map(shrink).collect(),
+            last: areas.last.map(shrink),
+        };
 
-                    let mut outer = BoxLayout::new(padded);
-                    let start = Point::new(padding.left, padding.top);
-                    outer.push_layout(start, boxed);
+        let mut layouted = self.child.layout(ctx, &areas).await;
 
-                    Layouted::Box(outer, align)
+        for item in &mut layouted {
+            if let Layouted::Boxed(boxed, _) = item {
+                let padding = self.padding.eval(boxed.size);
+                let origin = Point::new(padding.left, padding.top);
+
+                boxed.size += padding.size();
+                for (point, _) in &mut boxed.elements {
+                    *point += origin;
                 }
-                item => item,
-            })
-            .collect()
+            }
+        }
+
+        layouted
     }
 }