Grid: Rename Flex to Fraction (#350)

* Rename Flex variant of MaxTrackSizingFunction to Fraction. Rename flex() helper to fr() * Add flex(N) helper function which is short for minmax(0, Nfr) * Update changelog * Regenerate tests after rebasing * Add evenly_sized_tracks style helper
DioxusLabs · Feb 7, 2023 · 71027a8 · 71027a8
1 parent f784137
commit 71027a8
Show file tree

Hide file tree

Showing 60 changed files with 112 additions and 89 deletions.
diff --git a/RELEASES.md b/RELEASES.md
@@ -2,13 +2,18 @@
 
 ## 0.3.0-alpha2 (unreleased)
 
+### Added
+
+- A new style helper `evenly_sized_tracks(count: u16)` has been added which creates a grid template containing `count` evenly sized tracks (rows or columns)
+
 ### Changed
 
 - `experimental_grid` feature named to just `grid`
 - `grid` feature enabled by default
 - `GridPlacement::Line` now stores a `GridLine` newtype wrapper around an `i16` rather than a raw `i16`. If you are using the style helpers then this change will not affect you.
 - *BREAKING:* `Position` is now renamed to `Inset` and is now in line with [CSS inset specs](https://developer.mozilla.org/en-US/docs/Web/CSS/inset)
 - *BREAKING:* `PositionType` is now renamed to `Position` and is now in line with [CSS position specs](https://developer.mozilla.org/en-US/docs/Web/CSS/position)
+- `MaxTrackSizingFunction::Flex` is now called `MaxTrackSizingFunction::Fraction`. The `flex()` helper is now called `fr()`. A new `flex()` helper has been added which create a `minmax(0, Nfr)` track.
 
 ### Fixes
 

diff --git a/benches/big_tree_grid.rs b/benches/big_tree_grid.rs
@@ -20,9 +20,9 @@ fn random_grid_track<R: Rng>(rng: &mut R) -> TrackSizingFunction {
     } else if switch < 0.3 {
         max_content()
     } else if switch < 0.5 {
-        flex(1.0)
+        fr(1.0)
     } else if switch < 0.6 {
-        minmax(points(0.0), flex(1.0))
+        minmax(points(0.0), fr(1.0))
     } else if switch < 0.8 {
         points(40.0)
     } else {

diff --git a/benches/generated/grid_auto_takes_precedence_over_fr.rs b/benches/generated/grid_auto_takes_precedence_over_fr.rs
diff --git a/benches/generated/grid_fr_fixed_size_no_content_proportions.rs b/benches/generated/grid_fr_fixed_size_no_content_proportions.rs
diff --git a/benches/generated/grid_fr_fixed_size_no_content_proportions_sub_1_sum.rs b/benches/generated/grid_fr_fixed_size_no_content_proportions_sub_1_sum.rs
diff --git a/benches/generated/grid_fr_fixed_size_single_item.rs b/benches/generated/grid_fr_fixed_size_single_item.rs
diff --git a/benches/generated/grid_fr_no_sized_items_indefinite.rs b/benches/generated/grid_fr_no_sized_items_indefinite.rs
diff --git a/benches/generated/grid_fr_single_item_indefinite.rs b/benches/generated/grid_fr_single_item_indefinite.rs
diff --git a/benches/generated/grid_fr_span_2_proportion.rs b/benches/generated/grid_fr_span_2_proportion.rs
diff --git a/benches/generated/grid_fr_span_2_proportion_sub_1_sum.rs b/benches/generated/grid_fr_span_2_proportion_sub_1_sum.rs
diff --git a/benches/generated/grid_fr_span_2_proportion_with_non_spanned_track.rs b/benches/generated/grid_fr_span_2_proportion_with_non_spanned_track.rs
diff --git a/benches/generated/grid_fr_span_2_proportion_zero_sum.rs b/benches/generated/grid_fr_span_2_proportion_zero_sum.rs
diff --git a/benches/generated/grid_fr_span_2_proportion_zero_sum_with_non_spanned_track.rs b/benches/generated/grid_fr_span_2_proportion_zero_sum_with_non_spanned_track.rs
diff --git a/benches/generated/grid_min_content_flex_single_item.rs b/benches/generated/grid_min_content_flex_single_item.rs
diff --git a/benches/generated/grid_min_content_flex_single_item_margin_auto.rs b/benches/generated/grid_min_content_flex_single_item_margin_auto.rs
diff --git a/benches/generated/grid_min_content_flex_single_item_margin_fixed.rs b/benches/generated/grid_min_content_flex_single_item_margin_fixed.rs
diff --git a/benches/generated/grid_min_content_flex_single_item_margin_percent.rs b/benches/generated/grid_min_content_flex_single_item_margin_percent.rs
diff --git a/benches/generated/grid_minmax_column_with_fr_fixed.rs b/benches/generated/grid_minmax_column_with_fr_fixed.rs
diff --git a/benches/generated/grid_minmax_max_content_1fr.rs b/benches/generated/grid_minmax_max_content_1fr.rs
diff --git a/benches/generated/grid_minmax_min_content_1fr.rs b/benches/generated/grid_minmax_min_content_1fr.rs
diff --git a/benches/generated/grid_percent_items_nested_with_padding_margin.rs b/benches/generated/grid_percent_items_nested_with_padding_margin.rs
diff --git a/benches/generated/grid_span_8_all_track_types_indefinite.rs b/benches/generated/grid_span_8_all_track_types_indefinite.rs
diff --git a/benches/generated/gridflex_column_integration.rs b/benches/generated/gridflex_column_integration.rs
diff --git a/benches/generated/gridflex_kitchen_sink.rs b/benches/generated/gridflex_kitchen_sink.rs
diff --git a/benches/generated/gridflex_kitchen_sink_minimise.rs b/benches/generated/gridflex_kitchen_sink_minimise.rs
diff --git a/benches/generated/gridflex_row_integration.rs b/benches/generated/gridflex_row_integration.rs
diff --git a/examples/grid_holy_grail.rs b/examples/grid_holy_grail.rs
@@ -25,8 +25,8 @@ fn main() -> Result<(), taffy::error::TaffyError> {
     let root_style = Style {
         display: Display::Grid,
         size: Size { width: points(800.0), height: points(600.0) },
-        grid_template_columns: vec![points(250.0), flex(1.0), points(250.0)],
-        grid_template_rows: vec![points(150.0), flex(1.0), points(150.0)],
+        grid_template_columns: vec![points(250.0), fr(1.0), points(250.0)],
+        grid_template_rows: vec![points(150.0), fr(1.0), points(150.0)],
         ..default()
     };
 

diff --git a/scripts/gentest/src/main.rs b/scripts/gentest/src/main.rs
@@ -830,7 +830,7 @@ fn generate_scalar_definition(track_definition: &serde_json::Map<String, Value>)
             match unit() {
                 "points" => quote!(points(#value)),
                 "percent" => quote!(percent(#value)),
-                "fraction" => quote!(flex(#value)),
+                "fraction" => quote!(fr(#value)),
                 _ => unreachable!(),
             }
         }

diff --git a/src/compute/grid/explicit_grid.rs b/src/compute/grid/explicit_grid.rs
@@ -455,7 +455,7 @@ mod test {
         let px100 = LengthPercentage::Points(100.0);
 
         // Setup test
-        let track_template = vec![points(100.0), minmax(points(100.0), flex(2.0)), flex(1.0)];
+        let track_template = vec![points(100.0), minmax(points(100.0), fr(2.0)), fr(1.0)];
         let track_counts =
             TrackCounts { negative_implicit: 3, explicit: track_template.len() as u16, positive_implicit: 3 };
         let auto_tracks = vec![auto(), points(100.0)];
@@ -479,9 +479,9 @@ mod test {
             // Explicit tracks
             (GridTrackKind::Track, MinTrackSizingFunction::Fixed(px100), MaxTrackSizingFunction::Fixed(px100)),
             (GridTrackKind::Gutter, MinTrackSizingFunction::Fixed(px20), MaxTrackSizingFunction::Fixed(px20)),
-            (GridTrackKind::Track, MinTrackSizingFunction::Fixed(px100), MaxTrackSizingFunction::Flex(2.0)), // Note: separate min-max functions
+            (GridTrackKind::Track, MinTrackSizingFunction::Fixed(px100), MaxTrackSizingFunction::Fraction(2.0)), // Note: separate min-max functions
             (GridTrackKind::Gutter, MinTrackSizingFunction::Fixed(px20), MaxTrackSizingFunction::Fixed(px20)),
-            (GridTrackKind::Track, MinTrackSizingFunction::Auto, MaxTrackSizingFunction::Flex(1.0)), // Note: min sizing function of flex sizing functions is auto
+            (GridTrackKind::Track, MinTrackSizingFunction::Auto, MaxTrackSizingFunction::Fraction(1.0)), // Note: min sizing function of flex sizing functions is auto
             (GridTrackKind::Gutter, MinTrackSizingFunction::Fixed(px20), MaxTrackSizingFunction::Fixed(px20)),
             // Positive implict tracks
             (GridTrackKind::Track, MinTrackSizingFunction::Auto, MaxTrackSizingFunction::Auto),

diff --git a/src/compute/grid/track_sizing.rs b/src/compute/grid/track_sizing.rs
@@ -1146,7 +1146,7 @@ fn expand_flexible_tracks(
             let hypothetical_grid_size: f32 = axis_tracks
                 .iter()
                 .map(|track| match track.max_track_sizing_function {
-                    MaxTrackSizingFunction::Flex(track_flex_factor) => {
+                    MaxTrackSizingFunction::Fraction(track_flex_factor) => {
                         f32_max(track.base_size, track_flex_factor * flex_fraction)
                     }
                     _ => track.base_size,
@@ -1167,7 +1167,7 @@ fn expand_flexible_tracks(
     // For each flexible track, if the product of the used flex fraction and the track’s flex factor is greater
     // than the track’s base size, set its base size to that product.
     for track in axis_tracks.iter_mut() {
-        if let MaxTrackSizingFunction::Flex(track_flex_factor) = track.max_track_sizing_function {
+        if let MaxTrackSizingFunction::Fraction(track_flex_factor) = track.max_track_sizing_function {
             track.base_size = f32_max(track.base_size, track_flex_factor * flex_fraction);
         }
     }
@@ -1199,7 +1199,9 @@ fn find_size_of_fr(tracks: &[GridTrack], space_to_fill: f32) -> f32 {
         for track in tracks.iter() {
             match track.max_track_sizing_function {
                 // Tracks for which flex_factor * hypothetical_fr_size < track.base_size are treated as inflexible
-                MaxTrackSizingFunction::Flex(flex_factor) if flex_factor * hypothetical_fr_size >= track.base_size => {
+                MaxTrackSizingFunction::Fraction(flex_factor)
+                    if flex_factor * hypothetical_fr_size >= track.base_size =>
+                {
                     naive_flex_factor_sum += flex_factor;
                 }
                 _ => used_space += track.base_size,
@@ -1216,7 +1218,7 @@ fn find_size_of_fr(tracks: &[GridTrack], space_to_fill: f32) -> f32 {
         // restart this algorithm treating all such tracks as inflexible.
         // We keep track of the hypothetical_fr_size
         let hypotherical_fr_size_is_valid = tracks.iter().all(|track| match track.max_track_sizing_function {
-            MaxTrackSizingFunction::Flex(flex_factor) => {
+            MaxTrackSizingFunction::Fraction(flex_factor) => {
                 flex_factor * hypothetical_fr_size >= track.base_size
                     || flex_factor * previous_iter_hypothetical_fr_size < track.base_size
             }

diff --git a/src/compute/grid/types/grid_item.rs b/src/compute/grid/types/grid_item.rs
@@ -441,7 +441,7 @@ impl GridItem {
                 let only_span_one_track = item_axis_tracks.len() == 1;
                 let spans_a_flexible_track = axis_tracks
                     .iter()
-                    .any(|track| matches!(track.max_track_sizing_function, MaxTrackSizingFunction::Flex(_)));
+                    .any(|track| matches!(track.max_track_sizing_function, MaxTrackSizingFunction::Fraction(_)));
 
                 let use_content_based_minimum =
                     spans_auto_min_track && (only_span_one_track || !spans_a_flexible_track);

diff --git a/src/compute/grid/types/grid_track.rs b/src/compute/grid/types/grid_track.rs
@@ -108,7 +108,7 @@ impl GridTrack {
     #[inline(always)]
     /// Returns true if the track is flexible (has a Flex MaxTrackSizingFunction), else false.
     pub fn is_flexible(&self) -> bool {
-        matches!(self.max_track_sizing_function, MaxTrackSizingFunction::Flex(_))
+        matches!(self.max_track_sizing_function, MaxTrackSizingFunction::Fraction(_))
     }
 
     #[inline(always)]
@@ -148,7 +148,7 @@ impl GridTrack {
     /// Returns the track's flex factor if it is a flex track, else 0.
     pub fn flex_factor(&self) -> f32 {
         match self.max_track_sizing_function {
-            MaxTrackSizingFunction::Flex(flex_factor) => flex_factor,
+            MaxTrackSizingFunction::Fraction(flex_factor) => flex_factor,
             _ => 0.0,
         }
     }

diff --git a/src/compute/grid/util/test_helpers.rs b/src/compute/grid/util/test_helpers.rs
@@ -11,8 +11,8 @@ impl CreateParentTestNode for (f32, f32, i32, i32) {
         Style {
             display: Display::Grid,
             size: Size { width: Dimension::Points(self.0), height: Dimension::Points(self.1) },
-            grid_template_columns: vec![flex(1f32); self.2 as usize],
-            grid_template_rows: vec![flex(1f32); self.3 as usize],
+            grid_template_columns: vec![fr(1f32); self.2 as usize],
+            grid_template_rows: vec![fr(1f32); self.3 as usize],
             ..Default::default()
         }
     }