Refactor a bit

1 files changed, 26 insertions, 28 deletions

diff --git a/src/layout/fixed.rs b/src/layout/fixed.rs
index b7c58523..f0528643 100644
--- a/src/layout/fixed.rs
+++ b/src/layout/fixed.rs
@@ -22,63 +22,61 @@ impl Layout for FixedNode {
     fn layout(
         &self,
         ctx: &mut LayoutContext,
-        &Regions { current, base, expand, .. }: &Regions,
+        regions: &Regions,
     ) -> Vec<Constrained<Rc<Frame>>> {
         // Fill in width or height if aspect ratio and the other is given.
         let aspect = self.aspect.map(N64::into_inner);
         let width = self.width.or(self.height.zip(aspect).map(|(h, a)| a * h));
         let height = self.height.or(self.width.zip(aspect).map(|(w, a)| w / a));
 
+        // Resolve the linears based on the current width and height.
+        let mut child_size = Size::new(
+            width.map_or(regions.current.w, |w| w.resolve(regions.base.w)),
+            height.map_or(regions.current.h, |h| h.resolve(regions.base.h)),
+        );
+
+        // If width or height aren't set for an axis, the base should be
+        // inherited from the parent for that axis.
+        let child_base = Size::new(
+            if width.is_some() { child_size.w } else { regions.base.w },
+            if height.is_some() { child_size.h } else { regions.base.h },
+        );
+
         // Prepare constraints.
-        let mut constraints = Constraints::new(expand);
-        constraints.set_base_if_linear(base, Spec::new(width, height));
+        let mut constraints = Constraints::new(regions.expand);
+        constraints.set_base_if_linear(regions.base, Spec::new(width, height));
 
         // If the size for one axis isn't specified, the `current` size along
         // that axis needs to remain the same for the result to be reusable.
         if width.is_none() {
-            constraints.exact.x = Some(current.w);
+            constraints.exact.x = Some(regions.current.w);
         }
-
         if height.is_none() {
-            constraints.exact.y = Some(current.h);
+            constraints.exact.y = Some(regions.current.h);
         }
 
-        // Resolve the linears based on the current width and height.
-        let mut size = Size::new(
-            width.map_or(current.w, |w| w.resolve(base.w)),
-            height.map_or(current.h, |h| h.resolve(base.h)),
-        );
-
-        // If width or height aren't set for an axis, the base should be
-        // inherited from the parent for that axis.
-        let base = Size::new(
-            width.map_or(base.w, |_| size.w),
-            height.map_or(base.h, |_| size.h),
-        );
-
-        // Handle the aspect ratio.
+        // Apply the aspect ratio.
         if let Some(aspect) = aspect {
-            constraints.exact = current.to_spec().map(Some);
+            let width = child_size.w.min(aspect * child_size.h);
+            child_size = Size::new(width, width / aspect);
+            constraints.exact = regions.current.to_spec().map(Some);
             constraints.min = Spec::splat(None);
             constraints.max = Spec::splat(None);
-
-            let width = size.w.min(aspect * size.h);
-            size = Size::new(width, width / aspect);
         }
 
         // If width or height are fixed, the child should fill the available
         // space along that axis.
-        let expand = Spec::new(width.is_some(), height.is_some());
+        let child_expand = Spec::new(width.is_some(), height.is_some());
 
         // Layout the child.
-        let mut regions = Regions::one(size, base, expand);
+        let mut regions = Regions::one(child_size, child_base, child_expand);
         let mut frames = self.child.layout(ctx, &regions);
 
         // If we have an aspect ratio and the child is content-sized, we need to
         // relayout with expansion.
         if let Some(aspect) = aspect {
             if width.is_none() && height.is_none() {
-                let needed = frames[0].item.size.cap(size);
+                let needed = frames[0].item.size.cap(child_size);
                 let width = needed.w.max(aspect * needed.h);
                 regions.current = Size::new(width, width / aspect);
                 regions.expand = Spec::splat(true);
@@ -87,8 +85,8 @@ impl Layout for FixedNode {
         }
 
         // Overwrite the child's constraints with ours.
-        frames[0].constraints = constraints;
         assert_eq!(frames.len(), 1);
+        frames[0].constraints = constraints;
 
         frames
     }