From 0655a20ad119e2e9790afcc45039fd4ac0e7d432 Mon Sep 17 00:00:00 2001
From: Héctor Ramón Jiménez <hector0193@gmail.com>
Date: Thu, 16 Mar 2023 20:23:25 +0100
Subject: Make `Shrink` have priority over `Fill` in layout

---
 widget/src/button.rs              | 13 ++++++---
 widget/src/canvas.rs              |  3 +--
 widget/src/column.rs              |  9 +++----
 widget/src/container.rs           | 33 ++++++++++++-----------
 widget/src/image.rs               |  2 +-
 widget/src/image/viewer.rs        |  9 ++++---
 widget/src/keyed/column.rs        |  2 ++
 widget/src/overlay/menu.rs        | 12 ++++-----
 widget/src/pane_grid.rs           |  9 +++----
 widget/src/pane_grid/content.rs   |  9 ++++---
 widget/src/pane_grid/title_bar.rs | 18 ++++++-------
 widget/src/pick_list.rs           |  7 +++--
 widget/src/progress_bar.rs        | 10 +++----
 widget/src/row.rs                 |  6 ++---
 widget/src/rule.rs                |  4 +--
 widget/src/scrollable.rs          |  2 +-
 widget/src/shader.rs              |  2 +-
 widget/src/slider.rs              |  3 +--
 widget/src/space.rs               |  4 +--
 widget/src/svg.rs                 |  5 +---
 widget/src/text_editor.rs         |  2 +-
 widget/src/text_input.rs          | 57 +++++++++++++++++++--------------------
 widget/src/tooltip.rs             |  2 +-
 widget/src/vertical_slider.rs     |  3 +--
 24 files changed, 111 insertions(+), 115 deletions(-)

(limited to 'widget')

diff --git a/widget/src/button.rs b/widget/src/button.rs
index 384a3156..ba68caa5 100644
--- a/widget/src/button.rs
+++ b/widget/src/button.rs
@@ -433,13 +433,18 @@ pub fn layout(
 ) -> layout::Node {
     let limits = limits.width(width).height(height);
 
-    let mut content = layout_content(&limits.pad(padding));
+    let content = layout_content(&limits.shrink(padding));
     let padding = padding.fit(content.size(), limits.max());
-    let size = limits.pad(padding).resolve(content.size()).pad(padding);
 
-    content.move_to(Point::new(padding.left, padding.top));
+    let size = limits
+        .shrink(padding)
+        .resolve(content.size(), width, height)
+        .expand(padding);
 
-    layout::Node::with_children(size, vec![content])
+    layout::Node::with_children(
+        size,
+        vec![content.move_to(Point::new(padding.left, padding.top))],
+    )
 }
 
 /// Returns the [`mouse::Interaction`] of a [`Button`].
diff --git a/widget/src/canvas.rs b/widget/src/canvas.rs
index 390f4d92..9e33c113 100644
--- a/widget/src/canvas.rs
+++ b/widget/src/canvas.rs
@@ -133,8 +133,7 @@ where
         _renderer: &Renderer,
         limits: &layout::Limits,
     ) -> layout::Node {
-        let limits = limits.width(self.width).height(self.height);
-        let size = limits.resolve(Size::ZERO);
+        let size = limits.resolve(Size::ZERO, self.width, self.height);
 
         layout::Node::new(size)
     }
diff --git a/widget/src/column.rs b/widget/src/column.rs
index abb522be..526509bb 100644
--- a/widget/src/column.rs
+++ b/widget/src/column.rs
@@ -35,7 +35,7 @@ impl<'a, Message, Renderer> Column<'a, Message, Renderer> {
         Column {
             spacing: 0.0,
             padding: Padding::ZERO,
-            width: Length::Shrink,
+            width: Length::Fill,
             height: Length::Shrink,
             max_width: f32::INFINITY,
             align_items: Alignment::Start,
@@ -126,15 +126,14 @@ where
         renderer: &Renderer,
         limits: &layout::Limits,
     ) -> layout::Node {
-        let limits = limits
-            .max_width(self.max_width)
-            .width(self.width)
-            .height(self.height);
+        let limits = limits.max_width(self.max_width);
 
         layout::flex::resolve(
             layout::flex::Axis::Vertical,
             renderer,
             &limits,
+            self.width,
+            self.height,
             self.padding,
             self.spacing,
             self.align_items,
diff --git a/widget/src/container.rs b/widget/src/container.rs
index 5dd7705b..b41a6023 100644
--- a/widget/src/container.rs
+++ b/widget/src/container.rs
@@ -312,24 +312,27 @@ pub fn layout(
     layout_content: impl FnOnce(&layout::Limits) -> layout::Node,
 ) -> layout::Node {
     let limits = limits
-        .loose()
-        .max_width(max_width)
-        .max_height(max_height)
         .width(width)
-        .height(height);
+        .height(height)
+        .max_width(max_width)
+        .max_height(max_height);
 
-    let mut content = layout_content(&limits.pad(padding).loose());
+    let content = layout_content(&limits.shrink(padding).loose());
     let padding = padding.fit(content.size(), limits.max());
-    let size = limits.pad(padding).resolve(content.size());
-
-    content.move_to(Point::new(padding.left, padding.top));
-    content.align(
-        Alignment::from(horizontal_alignment),
-        Alignment::from(vertical_alignment),
-        size,
-    );
-
-    layout::Node::with_children(size.pad(padding), vec![content])
+    let size = limits
+        .shrink(padding)
+        .resolve(content.size(), width, height);
+
+    layout::Node::with_children(
+        size.expand(padding),
+        vec![content
+            .move_to(Point::new(padding.left, padding.top))
+            .align(
+                Alignment::from(horizontal_alignment),
+                Alignment::from(vertical_alignment),
+                size,
+            )],
+    )
 }
 
 /// Draws the background of a [`Container`] given its [`Appearance`] and its `bounds`.
diff --git a/widget/src/image.rs b/widget/src/image.rs
index 67699102..b5f1e907 100644
--- a/widget/src/image.rs
+++ b/widget/src/image.rs
@@ -99,7 +99,7 @@ where
     };
 
     // The size to be available to the widget prior to `Shrink`ing
-    let raw_size = limits.width(width).height(height).resolve(image_size);
+    let raw_size = limits.resolve(image_size, width, height);
 
     // The uncropped size of the image when fit to the bounds above
     let full_size = content_fit.fit(image_size, raw_size);
diff --git a/widget/src/image/viewer.rs b/widget/src/image/viewer.rs
index 68015ba8..23c4fe86 100644
--- a/widget/src/image/viewer.rs
+++ b/widget/src/image/viewer.rs
@@ -113,10 +113,11 @@ where
     ) -> layout::Node {
         let Size { width, height } = renderer.dimensions(&self.handle);
 
-        let mut size = limits
-            .width(self.width)
-            .height(self.height)
-            .resolve(Size::new(width as f32, height as f32));
+        let mut size = limits.resolve(
+            Size::new(width as f32, height as f32),
+            self.width,
+            self.height,
+        );
 
         let expansion_size = if height > width {
             self.width
diff --git a/widget/src/keyed/column.rs b/widget/src/keyed/column.rs
index 0ef82407..1b53b43a 100644
--- a/widget/src/keyed/column.rs
+++ b/widget/src/keyed/column.rs
@@ -196,6 +196,8 @@ where
             layout::flex::Axis::Vertical,
             renderer,
             &limits,
+            self.width,
+            self.height,
             self.padding,
             self.spacing,
             self.align_items,
diff --git a/widget/src/overlay/menu.rs b/widget/src/overlay/menu.rs
index e45b44ae..ef39a952 100644
--- a/widget/src/overlay/menu.rs
+++ b/widget/src/overlay/menu.rs
@@ -254,15 +254,14 @@ where
         )
         .width(self.width);
 
-        let mut node = self.container.layout(self.state, renderer, &limits);
+        let node = self.container.layout(self.state, renderer, &limits);
+        let size = node.size();
 
         node.move_to(if space_below > space_above {
             position + Vector::new(0.0, self.target_height)
         } else {
-            position - Vector::new(0.0, node.size().height)
-        });
-
-        node
+            position - Vector::new(0.0, size.height)
+        })
     }
 
     fn on_event(
@@ -359,7 +358,6 @@ where
     ) -> layout::Node {
         use std::f32;
 
-        let limits = limits.width(Length::Fill).height(Length::Shrink);
         let text_size =
             self.text_size.unwrap_or_else(|| renderer.default_size());
 
@@ -372,7 +370,7 @@ where
                     * self.options.len() as f32,
             );
 
-            limits.resolve(intrinsic)
+            limits.resolve(intrinsic, Length::Fill, Length::Shrink)
         };
 
         layout::Node::new(size)
diff --git a/widget/src/pane_grid.rs b/widget/src/pane_grid.rs
index 7057fe59..3d799fd3 100644
--- a/widget/src/pane_grid.rs
+++ b/widget/src/pane_grid.rs
@@ -490,8 +490,7 @@ pub fn layout<Renderer, T>(
         &layout::Limits,
     ) -> layout::Node,
 ) -> layout::Node {
-    let limits = limits.width(width).height(height);
-    let size = limits.resolve(Size::ZERO);
+    let size = limits.resolve(Size::ZERO, width, height);
 
     let regions = node.pane_regions(spacing, size);
     let children = contents
@@ -500,16 +499,14 @@ pub fn layout<Renderer, T>(
             let region = regions.get(&pane)?;
             let size = Size::new(region.width, region.height);
 
-            let mut node = layout_content(
+            let node = layout_content(
                 content,
                 tree,
                 renderer,
                 &layout::Limits::new(size, size),
             );
 
-            node.move_to(Point::new(region.x, region.y));
-
-            Some(node)
+            Some(node.move_to(Point::new(region.x, region.y)))
         })
         .collect();
 
diff --git a/widget/src/pane_grid/content.rs b/widget/src/pane_grid/content.rs
index 826ea663..ee00f186 100644
--- a/widget/src/pane_grid/content.rs
+++ b/widget/src/pane_grid/content.rs
@@ -165,7 +165,7 @@ where
 
             let title_bar_size = title_bar_layout.size();
 
-            let mut body_layout = self.body.as_widget().layout(
+            let body_layout = self.body.as_widget().layout(
                 &mut tree.children[0],
                 renderer,
                 &layout::Limits::new(
@@ -177,11 +177,12 @@ where
                 ),
             );
 
-            body_layout.move_to(Point::new(0.0, title_bar_size.height));
-
             layout::Node::with_children(
                 max_size,
-                vec![title_bar_layout, body_layout],
+                vec![
+                    title_bar_layout,
+                    body_layout.move_to(Point::new(0.0, title_bar_size.height)),
+                ],
             )
         } else {
             self.body.as_widget().layout(
diff --git a/widget/src/pane_grid/title_bar.rs b/widget/src/pane_grid/title_bar.rs
index f4dbb6b1..eb21b743 100644
--- a/widget/src/pane_grid/title_bar.rs
+++ b/widget/src/pane_grid/title_bar.rs
@@ -217,7 +217,7 @@ where
         renderer: &Renderer,
         limits: &layout::Limits,
     ) -> layout::Node {
-        let limits = limits.pad(self.padding);
+        let limits = limits.shrink(self.padding);
         let max_size = limits.max();
 
         let title_layout = self.content.as_widget().layout(
@@ -228,8 +228,8 @@ where
 
         let title_size = title_layout.size();
 
-        let mut node = if let Some(controls) = &self.controls {
-            let mut controls_layout = controls.as_widget().layout(
+        let node = if let Some(controls) = &self.controls {
+            let controls_layout = controls.as_widget().layout(
                 &mut tree.children[1],
                 renderer,
                 &layout::Limits::new(Size::ZERO, max_size),
@@ -240,11 +240,13 @@ where
 
             let height = title_size.height.max(controls_size.height);
 
-            controls_layout.move_to(Point::new(space_before_controls, 0.0));
-
             layout::Node::with_children(
                 Size::new(max_size.width, height),
-                vec![title_layout, controls_layout],
+                vec![
+                    title_layout,
+                    controls_layout
+                        .move_to(Point::new(space_before_controls, 0.0)),
+                ],
             )
         } else {
             layout::Node::with_children(
@@ -253,9 +255,7 @@ where
             )
         };
 
-        node.move_to(Point::new(self.padding.left, self.padding.top));
-
-        layout::Node::with_children(node.size().pad(self.padding), vec![node])
+        layout::Node::container(node, self.padding)
     }
 
     pub(crate) fn operate(
diff --git a/widget/src/pick_list.rs b/widget/src/pick_list.rs
index 022ca8d9..13110725 100644
--- a/widget/src/pick_list.rs
+++ b/widget/src/pick_list.rs
@@ -393,7 +393,7 @@ where
 {
     use std::f32;
 
-    let limits = limits.width(width).height(Length::Shrink).pad(padding);
+    let limits = limits.width(width).height(Length::Shrink);
     let font = font.unwrap_or_else(|| renderer.default_font());
     let text_size = text_size.unwrap_or_else(|| renderer.default_size());
 
@@ -451,7 +451,10 @@ where
             f32::from(text_line_height.to_absolute(text_size)),
         );
 
-        limits.resolve(intrinsic).pad(padding)
+        limits
+            .shrink(padding)
+            .resolve(intrinsic, width, Length::Shrink)
+            .expand(padding)
     };
 
     layout::Node::new(size)
diff --git a/widget/src/progress_bar.rs b/widget/src/progress_bar.rs
index 07de72d5..b84ab2dd 100644
--- a/widget/src/progress_bar.rs
+++ b/widget/src/progress_bar.rs
@@ -99,11 +99,11 @@ where
         _renderer: &Renderer,
         limits: &layout::Limits,
     ) -> layout::Node {
-        let limits = limits
-            .width(self.width)
-            .height(self.height.unwrap_or(Length::Fixed(Self::DEFAULT_HEIGHT)));
-
-        let size = limits.resolve(Size::ZERO);
+        let size = limits.resolve(
+            Size::ZERO,
+            self.width,
+            self.height.unwrap_or(Length::Fixed(Self::DEFAULT_HEIGHT)),
+        );
 
         layout::Node::new(size)
     }
diff --git a/widget/src/row.rs b/widget/src/row.rs
index d52b8c43..650c2c7d 100644
--- a/widget/src/row.rs
+++ b/widget/src/row.rs
@@ -34,7 +34,7 @@ impl<'a, Message, Renderer> Row<'a, Message, Renderer> {
         Row {
             spacing: 0.0,
             padding: Padding::ZERO,
-            width: Length::Shrink,
+            width: Length::Fill,
             height: Length::Shrink,
             align_items: Alignment::Start,
             children,
@@ -118,12 +118,12 @@ where
         renderer: &Renderer,
         limits: &layout::Limits,
     ) -> layout::Node {
-        let limits = limits.width(self.width).height(self.height);
-
         layout::flex::resolve(
             layout::flex::Axis::Horizontal,
             renderer,
             &limits,
+            self.width,
+            self.height,
             self.padding,
             self.spacing,
             self.align_items,
diff --git a/widget/src/rule.rs b/widget/src/rule.rs
index b5c5fa55..ecaedf60 100644
--- a/widget/src/rule.rs
+++ b/widget/src/rule.rs
@@ -76,9 +76,7 @@ where
         _renderer: &Renderer,
         limits: &layout::Limits,
     ) -> layout::Node {
-        let limits = limits.width(self.width).height(self.height);
-
-        layout::Node::new(limits.resolve(Size::ZERO))
+        layout::Node::new(limits.resolve(Size::ZERO, self.width, self.height))
     }
 
     fn draw(
diff --git a/widget/src/scrollable.rs b/widget/src/scrollable.rs
index 49aed2f0..525463c4 100644
--- a/widget/src/scrollable.rs
+++ b/widget/src/scrollable.rs
@@ -489,7 +489,7 @@ pub fn layout<Renderer>(
     );
 
     let content = layout_content(renderer, &child_limits);
-    let size = limits.resolve(content.size());
+    let size = limits.resolve(content.size(), width, height);
 
     layout::Node::with_children(size, vec![content])
 }
diff --git a/widget/src/shader.rs b/widget/src/shader.rs
index 8e334693..5b18ec7d 100644
--- a/widget/src/shader.rs
+++ b/widget/src/shader.rs
@@ -85,7 +85,7 @@ where
         limits: &layout::Limits,
     ) -> layout::Node {
         let limits = limits.width(self.width).height(self.height);
-        let size = limits.resolve(Size::ZERO);
+        let size = limits.resolve(Size::ZERO, self.width, self.height);
 
         layout::Node::new(size)
     }
diff --git a/widget/src/slider.rs b/widget/src/slider.rs
index ac0982c8..2b600d9d 100644
--- a/widget/src/slider.rs
+++ b/widget/src/slider.rs
@@ -173,8 +173,7 @@ where
         _renderer: &Renderer,
         limits: &layout::Limits,
     ) -> layout::Node {
-        let limits = limits.width(self.width).height(self.height);
-        let size = limits.resolve(Size::ZERO);
+        let size = limits.resolve(Size::ZERO, self.width, self.height);
 
         layout::Node::new(size)
     }
diff --git a/widget/src/space.rs b/widget/src/space.rs
index e5a8f169..afa9a7c8 100644
--- a/widget/src/space.rs
+++ b/widget/src/space.rs
@@ -59,9 +59,7 @@ where
         _renderer: &Renderer,
         limits: &layout::Limits,
     ) -> layout::Node {
-        let limits = limits.width(self.width).height(self.height);
-
-        layout::Node::new(limits.resolve(Size::ZERO))
+        layout::Node::new(limits.resolve(Size::ZERO, self.width, self.height))
     }
 
     fn draw(
diff --git a/widget/src/svg.rs b/widget/src/svg.rs
index 2d01d1ab..8367ad18 100644
--- a/widget/src/svg.rs
+++ b/widget/src/svg.rs
@@ -115,10 +115,7 @@ where
         let image_size = Size::new(width as f32, height as f32);
 
         // The size to be available to the widget prior to `Shrink`ing
-        let raw_size = limits
-            .width(self.width)
-            .height(self.height)
-            .resolve(image_size);
+        let raw_size = limits.resolve(image_size, self.width, self.height);
 
         // The uncropped size of the image when fit to the bounds above
         let full_size = self.content_fit.fit(image_size, raw_size);
diff --git a/widget/src/text_editor.rs b/widget/src/text_editor.rs
index a2a186f0..214bce17 100644
--- a/widget/src/text_editor.rs
+++ b/widget/src/text_editor.rs
@@ -350,7 +350,7 @@ where
         }
 
         internal.editor.update(
-            limits.pad(self.padding).max(),
+            limits.shrink(self.padding).max(),
             self.font.unwrap_or_else(|| renderer.default_font()),
             self.text_size.unwrap_or_else(|| renderer.default_size()),
             self.line_height,
diff --git a/widget/src/text_input.rs b/widget/src/text_input.rs
index 65d3e1eb..03eb2fd0 100644
--- a/widget/src/text_input.rs
+++ b/widget/src/text_input.rs
@@ -506,14 +506,11 @@ where
 {
     let font = font.unwrap_or_else(|| renderer.default_font());
     let text_size = size.unwrap_or_else(|| renderer.default_size());
-
     let padding = padding.fit(Size::ZERO, limits.max());
-    let limits = limits
-        .width(width)
-        .pad(padding)
-        .height(line_height.to_absolute(text_size));
+    let height = line_height.to_absolute(text_size);
 
-    let text_bounds = limits.resolve(Size::ZERO);
+    let limits = limits.width(width).shrink(padding).height(height);
+    let text_bounds = limits.resolve(Size::ZERO, width, height);
 
     let placeholder_text = Text {
         font,
@@ -552,41 +549,41 @@ where
 
         let icon_width = state.icon.min_width();
 
-        let mut text_node = layout::Node::new(
-            text_bounds - Size::new(icon_width + icon.spacing, 0.0),
-        );
-
-        let mut icon_node =
-            layout::Node::new(Size::new(icon_width, text_bounds.height));
-
-        match icon.side {
-            Side::Left => {
-                text_node.move_to(Point::new(
+        let (text_position, icon_position) = match icon.side {
+            Side::Left => (
+                Point::new(
                     padding.left + icon_width + icon.spacing,
                     padding.top,
-                ));
-
-                icon_node.move_to(Point::new(padding.left, padding.top));
-            }
-            Side::Right => {
-                text_node.move_to(Point::new(padding.left, padding.top));
-
-                icon_node.move_to(Point::new(
+                ),
+                Point::new(padding.left, padding.top),
+            ),
+            Side::Right => (
+                Point::new(padding.left, padding.top),
+                Point::new(
                     padding.left + text_bounds.width - icon_width,
                     padding.top,
-                ));
-            }
+                ),
+            ),
         };
 
+        let text_node = layout::Node::new(
+            text_bounds - Size::new(icon_width + icon.spacing, 0.0),
+        )
+        .move_to(text_position);
+
+        let icon_node =
+            layout::Node::new(Size::new(icon_width, text_bounds.height))
+                .move_to(icon_position);
+
         layout::Node::with_children(
-            text_bounds.pad(padding),
+            text_bounds.expand(padding),
             vec![text_node, icon_node],
         )
     } else {
-        let mut text = layout::Node::new(text_bounds);
-        text.move_to(Point::new(padding.left, padding.top));
+        let text = layout::Node::new(text_bounds)
+            .move_to(Point::new(padding.left, padding.top));
 
-        layout::Node::with_children(text_bounds.pad(padding), vec![text])
+        layout::Node::with_children(text_bounds.expand(padding), vec![text])
     }
 }
 
diff --git a/widget/src/tooltip.rs b/widget/src/tooltip.rs
index b888980a..adef13e4 100644
--- a/widget/src/tooltip.rs
+++ b/widget/src/tooltip.rs
@@ -353,7 +353,7 @@ where
                     .then(|| viewport.size())
                     .unwrap_or(Size::INFINITY),
             )
-            .pad(Padding::new(self.padding)),
+            .shrink(Padding::new(self.padding)),
         );
 
         let text_bounds = text_layout.bounds();
diff --git a/widget/src/vertical_slider.rs b/widget/src/vertical_slider.rs
index 01d3359c..e489104c 100644
--- a/widget/src/vertical_slider.rs
+++ b/widget/src/vertical_slider.rs
@@ -170,8 +170,7 @@ where
         _renderer: &Renderer,
         limits: &layout::Limits,
     ) -> layout::Node {
-        let limits = limits.width(self.width).height(self.height);
-        let size = limits.resolve(Size::ZERO);
+        let size = limits.resolve(Size::ZERO, self.width, self.height);
 
         layout::Node::new(size)
     }
-- 
cgit