Improve naming of new types in length module

hecrj · hecrj · commit d5aa4d4552e2 · 2026-06-17T20:44:00.000+08:00
diff --git a/core/src/layout/flex.rs b/core/src/layout/flex.rs
@@ -154,15 +154,15 @@ where
 
         match meta.main {
             Length::Bounded {
-                with: length::Fluidity::Fill(_),
+                sizing: length::Sizing::Fill(_),
                 bounds: length::Bounds::Min(min),
             }
             | Length::Fluid(length::Constraint::Min(min)) => {
                 min_total += min;
                 min_factors += fill_main_factor;
             }
             Length::Bounded {
-                with: length::Fluidity::Fill(_),
+                sizing: length::Sizing::Fill(_),
                 bounds: length::Bounds::Max(_) | length::Bounds::Both { .. },
             }
             | Length::Fluid(length::Constraint::Max) => {
diff --git a/core/src/layout/limits.rs b/core/src/layout/limits.rs
@@ -64,7 +64,7 @@ impl Limits {
                 self.max.width = new_width;
                 self.compression.width = false;
             }
-            Length::Bounded { bounds, with } => {
+            Length::Bounded { bounds, sizing } => {
                 match bounds {
                     length::Bounds::Min(min) => {
                         self.min.width = min.min(self.max.width).max(self.min.width);
@@ -78,14 +78,14 @@ impl Limits {
                     }
                 }
 
-                match with {
-                    length::Fluidity::Shrink => {
+                match sizing {
+                    length::Sizing::Shrink => {
                         self.compression.width = true;
                     }
-                    length::Fluidity::Fit => {
+                    length::Sizing::Fit => {
                         self.compression.width = false;
                     }
-                    length::Fluidity::Fill(_) => {}
+                    length::Sizing::Fill(_) => {}
                 }
             }
             Length::Fill | Length::FillPortion(_) => {}
@@ -110,7 +110,7 @@ impl Limits {
                 self.max.height = new_height;
                 self.compression.height = false;
             }
-            Length::Bounded { bounds, with } => {
+            Length::Bounded { bounds, sizing } => {
                 match bounds {
                     length::Bounds::Min(min) => {
                         self.min.height = min.min(self.max.height).max(self.min.height);
@@ -124,14 +124,14 @@ impl Limits {
                     }
                 }
 
-                match with {
-                    length::Fluidity::Shrink => {
+                match sizing {
+                    length::Sizing::Shrink => {
                         self.compression.height = true;
                     }
-                    length::Fluidity::Fit => {
+                    length::Sizing::Fit => {
                         self.compression.height = false;
                     }
-                    length::Fluidity::Fill(_) => {}
+                    length::Sizing::Fill(_) => {}
                 }
             }
             Length::Fill | Length::FillPortion(_) => {}
@@ -191,7 +191,7 @@ impl Limits {
             Length::Fill
             | Length::FillPortion(_)
             | Length::Bounded {
-                with: length::Fluidity::Fill(_),
+                sizing: length::Sizing::Fill(_),
                 ..
             } if !self.compression.width => self.max.width,
             Length::Fixed(amount) => amount.min(self.max.width).max(self.min.width),
@@ -205,7 +205,7 @@ impl Limits {
             Length::Fill
             | Length::FillPortion(_)
             | Length::Bounded {
-                with: length::Fluidity::Fill(_),
+                sizing: length::Sizing::Fill(_),
                 ..
             } if !self.compression.height => self.max.height,
             Length::Fixed(amount) => amount.min(self.max.height).max(self.min.height),
diff --git a/core/src/length.rs b/core/src/length.rs
@@ -27,15 +27,16 @@ pub enum Length {
     /// Fill a fixed amount of space in pixels.
     Fixed(f32),
 
-    /// Fill a certain amount of space inside the given [`Bounds`] with some [`Fluidity`].
+    /// Fill a certain amount of space inside the given [`Bounds`] with some [`Sizing`] strategy.
     Bounded {
-        /// The amount of space that can be filled.
+        /// The [`Bounds`] of space that can be filled.
         bounds: Bounds,
-        /// The strategy in which the space should be filled.
-        with: Fluidity,
+        /// The [`Sizing`] strategy with which the [`Bounds`] should be filled.
+        sizing: Sizing,
     },
 
-    /// TODO
+    /// Fill the remaining space like [`Fill`](Self::Fill), but subject to a single
+    /// open-ended [`Constraint`].
     Fluid(Constraint),
 }
 
@@ -98,7 +99,7 @@ impl Bounds {
 }
 
 #[derive(Debug, Clone, Copy, PartialEq)]
-pub enum Fluidity {
+pub enum Sizing {
     Fit,
     Fill(u16),
     Shrink,
@@ -110,22 +111,25 @@ impl Length {
         let min = min.into().0;
 
         let with = match self {
-            Self::Fit | Self::Fluid(_) => Fluidity::Fit,
-            Self::Fill => Fluidity::Fill(1),
-            Self::FillPortion(factor) => Fluidity::Fill(factor),
-            Self::Shrink => Fluidity::Shrink,
+            Self::Fit | Self::Fluid(_) => Sizing::Fit,
+            Self::Fill => Sizing::Fill(1),
+            Self::FillPortion(factor) => Sizing::Fill(factor),
+            Self::Shrink => Sizing::Shrink,
             Self::Fixed(_) => return self,
-            Self::Bounded { bounds, with } => {
+            Self::Bounded {
+                bounds,
+                sizing: with,
+            } => {
                 return Self::Bounded {
                     bounds: bounds.min(min),
-                    with,
+                    sizing: with,
                 };
             }
         };
 
         Self::Bounded {
             bounds: Bounds::Min(min),
-            with,
+            sizing: with,
         }
     }
 
@@ -134,22 +138,25 @@ impl Length {
         let max = max.into().0;
 
         let with = match self {
-            Self::Fit | Self::Fluid(_) => Fluidity::Fit,
-            Self::Fill => Fluidity::Fill(1),
-            Self::FillPortion(factor) => Fluidity::Fill(factor),
-            Self::Shrink => Fluidity::Shrink,
+            Self::Fit | Self::Fluid(_) => Sizing::Fit,
+            Self::Fill => Sizing::Fill(1),
+            Self::FillPortion(factor) => Sizing::Fill(factor),
+            Self::Shrink => Sizing::Shrink,
             Self::Fixed(_) => return self,
-            Self::Bounded { bounds, with } => {
+            Self::Bounded {
+                bounds,
+                sizing: with,
+            } => {
                 return Self::Bounded {
                     bounds: bounds.max(max),
-                    with,
+                    sizing: with,
                 };
             }
         };
 
         Self::Bounded {
             bounds: Bounds::Max(max),
-            with,
+            sizing: with,
         }
     }
 
@@ -163,7 +170,7 @@ impl Length {
             Length::Fill => 1,
             Length::FillPortion(factor)
             | Length::Bounded {
-                with: Fluidity::Fill(factor),
+                sizing: Sizing::Fill(factor),
                 ..
             } => *factor,
             Length::Fluid(_) => 1,
@@ -182,19 +189,6 @@ impl Length {
         matches!(self, Self::Fit)
     }
 
-    /// Returns the "fluid" variant of the [`Length`].
-    ///
-    /// Specifically:
-    /// - [`Length::Shrink`] if [`Length::Shrink`] or [`Length::Fixed`].
-    /// - [`Length::Fill`] otherwise.
-    pub fn fluid(&self) -> Self {
-        if self.fill_factor() == 0 {
-            Self::Shrink
-        } else {
-            Self::Fill
-        }
-    }
-
     /// TODO
     pub fn stack(self, other: Length) -> Self {
         self.merge_with(other, Constraint::stack)
@@ -216,34 +210,43 @@ impl Length {
                 Length::Fluid(a),
                 Length::Bounded {
                     bounds,
-                    with: Fluidity::Fill(_),
+                    sizing: Sizing::Fill(_),
                 },
             ) => Length::Fluid(merge(a, bounds.constraint())),
             (Length::Fluid(constraint), _) => Length::Fluid(constraint),
 
             (
                 Length::Bounded {
                     bounds,
-                    with: Fluidity::Fit,
+                    sizing: Sizing::Fit,
                 },
                 Length::Fill
                 | Length::FillPortion(_)
                 | Length::Bounded {
-                    with: Fluidity::Fill(_),
+                    sizing: Sizing::Fill(_),
                     ..
                 },
             ) => Length::Bounded {
                 bounds,
-                with: Fluidity::Fill(1),
+                sizing: Sizing::Fill(1),
+            },
+            (
+                Length::Bounded {
+                    bounds,
+                    sizing: with,
+                },
+                _,
+            ) => Length::Bounded {
+                bounds,
+                sizing: with,
             },
-            (Length::Bounded { bounds, with }, _) => Length::Bounded { bounds, with },
 
             // Fluid and bounded constraints must be propagated
             (
                 _,
                 Length::Bounded {
                     bounds,
-                    with: Fluidity::Fill(_),
+                    sizing: Sizing::Fill(_),
                 },
             ) => Length::Fluid(bounds.constraint()),
             (_, Length::Fluid(constraint)) => Length::Fluid(constraint),
diff --git a/widget/src/table.rs b/widget/src/table.rs
@@ -230,7 +230,11 @@ where
 
         let limits = limits.width(self.width).height(self.height);
         let available = limits.max();
-        let table_fluid = self.width.fluid();
+        let table_fluid = if self.width.fill_factor() == 0 {
+            Length::Shrink
+        } else {
+            Length::Fill
+        };
 
         let mut cells = Vec::with_capacity(self.cells.len());
         cells.resize(self.cells.len(), layout::Node::default());

Original file line number	Diff line number	Diff line change
`@@ -154,15 +154,15 @@ where`
`154`	`154`
`155`	`155`	`match meta.main {`
`156`	`156`	`Length::Bounded {`
`157`		`- with: length::Fluidity::Fill(_),`
	`157`	`+ sizing: length::Sizing::Fill(_),`
`158`	`158`	`bounds: length::Bounds::Min(min),`
`159`	`159`	`}`
`160`	`160`	`\| Length::Fluid(length::Constraint::Min(min)) => {`
`161`	`161`	`min_total += min;`
`162`	`162`	`min_factors += fill_main_factor;`
`163`	`163`	`}`
`164`	`164`	`Length::Bounded {`
`165`		`- with: length::Fluidity::Fill(_),`
	`165`	`+ sizing: length::Sizing::Fill(_),`
`166`	`166`	`bounds: length::Bounds::Max(_) \| length::Bounds::Both { .. },`
`167`	`167`	`}`
`168`	`168`	`\| Length::Fluid(length::Constraint::Max) => {`
Original file line number	Diff line number	Diff line change
`@@ -64,7 +64,7 @@ impl Limits {`
`64`	`64`	`self.max.width = new_width;`
`65`	`65`	`self.compression.width = false;`
`66`	`66`	`}`
`67`		`- Length::Bounded { bounds, with } => {`
	`67`	`+ Length::Bounded { bounds, sizing } => {`
`68`	`68`	`match bounds {`
`69`	`69`	`length::Bounds::Min(min) => {`
`70`	`70`	`self.min.width = min.min(self.max.width).max(self.min.width);`
`@@ -78,14 +78,14 @@ impl Limits {`
`78`	`78`	`}`
`79`	`79`	`}`
`80`	`80`
`81`		`- match with {`
`82`		`- length::Fluidity::Shrink => {`
	`81`	`+ match sizing {`
	`82`	`+ length::Sizing::Shrink => {`
`83`	`83`	`self.compression.width = true;`
`84`	`84`	`}`
`85`		`- length::Fluidity::Fit => {`
	`85`	`+ length::Sizing::Fit => {`
`86`	`86`	`self.compression.width = false;`
`87`	`87`	`}`
`88`		`- length::Fluidity::Fill(_) => {}`
	`88`	`+ length::Sizing::Fill(_) => {}`
`89`	`89`	`}`
`90`	`90`	`}`
`91`	`91`	`Length::Fill \| Length::FillPortion(_) => {}`
`@@ -110,7 +110,7 @@ impl Limits {`
`110`	`110`	`self.max.height = new_height;`
`111`	`111`	`self.compression.height = false;`
`112`	`112`	`}`
`113`		`- Length::Bounded { bounds, with } => {`
	`113`	`+ Length::Bounded { bounds, sizing } => {`
`114`	`114`	`match bounds {`
`115`	`115`	`length::Bounds::Min(min) => {`
`116`	`116`	`self.min.height = min.min(self.max.height).max(self.min.height);`
`@@ -124,14 +124,14 @@ impl Limits {`
`124`	`124`	`}`
`125`	`125`	`}`
`126`	`126`
`127`		`- match with {`
`128`		`- length::Fluidity::Shrink => {`
	`127`	`+ match sizing {`
	`128`	`+ length::Sizing::Shrink => {`
`129`	`129`	`self.compression.height = true;`
`130`	`130`	`}`
`131`		`- length::Fluidity::Fit => {`
	`131`	`+ length::Sizing::Fit => {`
`132`	`132`	`self.compression.height = false;`
`133`	`133`	`}`
`134`		`- length::Fluidity::Fill(_) => {}`
	`134`	`+ length::Sizing::Fill(_) => {}`
`135`	`135`	`}`
`136`	`136`	`}`
`137`	`137`	`Length::Fill \| Length::FillPortion(_) => {}`
`@@ -191,7 +191,7 @@ impl Limits {`
`191`	`191`	`Length::Fill`
`192`	`192`	`\| Length::FillPortion(_)`
`193`	`193`	`\| Length::Bounded {`
`194`		`- with: length::Fluidity::Fill(_),`
	`194`	`+ sizing: length::Sizing::Fill(_),`
`195`	`195`	`..`
`196`	`196`	`} if !self.compression.width => self.max.width,`
`197`	`197`	`Length::Fixed(amount) => amount.min(self.max.width).max(self.min.width),`
`@@ -205,7 +205,7 @@ impl Limits {`
`205`	`205`	`Length::Fill`
`206`	`206`	`\| Length::FillPortion(_)`
`207`	`207`	`\| Length::Bounded {`
`208`		`- with: length::Fluidity::Fill(_),`
	`208`	`+ sizing: length::Sizing::Fill(_),`
`209`	`209`	`..`
`210`	`210`	`} if !self.compression.height => self.max.height,`
`211`	`211`	`Length::Fixed(amount) => amount.min(self.max.height).max(self.min.height),`