From 1cbe1f52abb7ab1cd5bd05030e7857ee1762f44a Mon Sep 17 00:00:00 2001 From: Dheepak Krishnamurthy Date: Sun, 28 Jan 2024 05:41:01 -0500 Subject: [PATCH] feat(constraints): Rename `Constraint::Proportional` to `Constraint::Fill` (#880) `Constraint::Fill` is a more intuitive name for the behavior, and it is shorter. Resolves #859 --- examples/constraints.rs | 40 +++---- examples/flex.rs | 34 +++--- examples/layout.rs | 2 +- src/layout/constraint.rs | 54 +++++----- src/layout/flex.rs | 13 ++- src/layout/layout.rs | 214 ++++++++++++++++++------------------- src/widgets/calendar.rs | 2 +- src/widgets/table/table.rs | 2 +- 8 files changed, 177 insertions(+), 184 deletions(-) diff --git a/examples/constraints.rs b/examples/constraints.rs index faf7c15b..8256fdfd 100644 --- a/examples/constraints.rs +++ b/examples/constraints.rs @@ -38,7 +38,7 @@ const LENGTH_COLOR: Color = tailwind::SLATE.c700; const PERCENTAGE_COLOR: Color = tailwind::SLATE.c800; const RATIO_COLOR: Color = tailwind::SLATE.c900; // priority 4 -const PROPORTIONAL_COLOR: Color = tailwind::SLATE.c950; +const FILL_COLOR: Color = tailwind::SLATE.c950; #[derive(Default, Clone, Copy)] struct App { @@ -60,7 +60,7 @@ enum SelectedTab { Length, Percentage, Ratio, - Proportional, + Fill, } #[derive(Debug, Default, Clone, Copy, PartialEq, Eq)] @@ -165,7 +165,7 @@ impl Widget for App { let [tabs, axis, demo] = area.split(&Layout::vertical([ Constraint::Fixed(3), Constraint::Fixed(3), - Proportional(0), + Fill(0), ])); self.render_tabs(tabs, buf); @@ -272,7 +272,7 @@ impl SelectedTab { Length => 4, Percentage => 5, Ratio => 4, - Proportional => 2, + Fill => 2, Min => 5, Max => 5, } @@ -286,7 +286,7 @@ impl SelectedTab { Length => LENGTH_COLOR, Percentage => PERCENTAGE_COLOR, Ratio => RATIO_COLOR, - Proportional => PROPORTIONAL_COLOR, + Fill => FILL_COLOR, Min => MIN_COLOR, Max => MAX_COLOR, }; @@ -301,7 +301,7 @@ impl Widget for SelectedTab { SelectedTab::Length => self.render_length_example(area, buf), SelectedTab::Percentage => self.render_percentage_example(area, buf), SelectedTab::Ratio => self.render_ratio_example(area, buf), - SelectedTab::Proportional => self.render_proportional_example(area, buf), + SelectedTab::Fill => self.render_fill_example(area, buf), SelectedTab::Min => self.render_min_example(area, buf), SelectedTab::Max => self.render_max_example(area, buf), } @@ -313,17 +313,11 @@ impl SelectedTab { let [example1, example2, example3, example4, _] = area.split(&Layout::vertical([Fixed(EXAMPLE_HEIGHT); 5])); - Example::new(&[Fixed(40), Proportional(0)]).render(example1, buf); - Example::new(&[Fixed(20), Fixed(20), Proportional(0)]).render(example2, buf); + Example::new(&[Fixed(40), Fill(0)]).render(example1, buf); + Example::new(&[Fixed(20), Fixed(20), Fill(0)]).render(example2, buf); Example::new(&[Fixed(20), Min(20), Max(20)]).render(example3, buf); - Example::new(&[ - Length(20), - Percentage(20), - Ratio(1, 5), - Proportional(1), - Fixed(15), - ]) - .render(example4, buf); + Example::new(&[Length(20), Percentage(20), Ratio(1, 5), Fill(1), Fixed(15)]) + .render(example4, buf); } fn render_length_example(&self, area: Rect, buf: &mut Buffer) { @@ -340,11 +334,11 @@ impl SelectedTab { let [example1, example2, example3, example4, example5, _] = area.split(&Layout::vertical([Fixed(EXAMPLE_HEIGHT); 6])); - Example::new(&[Percentage(75), Proportional(0)]).render(example1, buf); - Example::new(&[Percentage(25), Proportional(0)]).render(example2, buf); + Example::new(&[Percentage(75), Fill(0)]).render(example1, buf); + Example::new(&[Percentage(25), Fill(0)]).render(example2, buf); Example::new(&[Percentage(50), Min(20)]).render(example3, buf); Example::new(&[Percentage(0), Max(0)]).render(example4, buf); - Example::new(&[Percentage(0), Proportional(0)]).render(example5, buf); + Example::new(&[Percentage(0), Fill(0)]).render(example5, buf); } fn render_ratio_example(&self, area: Rect, buf: &mut Buffer) { @@ -357,11 +351,11 @@ impl SelectedTab { Example::new(&[Ratio(1, 2), Percentage(25), Length(10)]).render(example4, buf); } - fn render_proportional_example(&self, area: Rect, buf: &mut Buffer) { + fn render_fill_example(&self, area: Rect, buf: &mut Buffer) { let [example1, example2, _] = area.split(&Layout::vertical([Fixed(EXAMPLE_HEIGHT); 3])); - Example::new(&[Proportional(1), Proportional(2), Proportional(3)]).render(example1, buf); - Example::new(&[Proportional(1), Percentage(50), Proportional(1)]).render(example2, buf); + Example::new(&[Fill(1), Fill(2), Fill(3)]).render(example1, buf); + Example::new(&[Fill(1), Percentage(50), Fill(1)]).render(example2, buf); } fn render_min_example(&self, area: Rect, buf: &mut Buffer) { @@ -421,7 +415,7 @@ impl Example { Constraint::Length(_) => LENGTH_COLOR, Constraint::Percentage(_) => PERCENTAGE_COLOR, Constraint::Ratio(_, _) => RATIO_COLOR, - Constraint::Proportional(_) => PROPORTIONAL_COLOR, + Constraint::Fill(_) => FILL_COLOR, Constraint::Min(_) => MIN_COLOR, Constraint::Max(_) => MAX_COLOR, }; diff --git a/examples/flex.rs b/examples/flex.rs index 4b59f7d0..32bab9db 100644 --- a/examples/flex.rs +++ b/examples/flex.rs @@ -36,12 +36,12 @@ const EXAMPLE_DATA: &[(&str, &[Constraint])] = &[ &[Fixed(10), Min(10), Max(10), Percentage(10), Ratio(1,10)], ), ( - "Proportional(u16) takes any excess space always", - &[Length(20), Percentage(20), Ratio(1, 5), Proportional(1)], + "Fill(u16) takes any excess space always", + &[Length(20), Percentage(20), Ratio(1, 5), Fill(1)], ), ( "Here's all constraints in one line", - &[Fixed(10), Min(10), Max(10), Percentage(10), Ratio(1,10), Proportional(1)], + &[Fixed(10), Min(10), Max(10), Percentage(10), Ratio(1,10), Fill(1)], ), ( "", @@ -58,12 +58,12 @@ const EXAMPLE_DATA: &[(&str, &[Constraint])] = &[ ("", &[Length(100), Min(20)]), ("`Fixed` is higher priority than `Min/Max`", &[Max(20), Fixed(10)]), ("", &[Min(20), Fixed(90)]), - ("Proportional is the lowest priority and will fill any excess space", &[Proportional(1), Ratio(1, 4)]), - ("Proportional can be used to scale proportionally with other Proportional blocks", &[Proportional(1), Percentage(20), Proportional(2)]), + ("Fill is the lowest priority and will fill any excess space", &[Fill(1), Ratio(1, 4)]), + ("Fill can be used to scale proportionally with other Fill blocks", &[Fill(1), Percentage(20), Fill(2)]), ("", &[Ratio(1, 3), Percentage(20), Ratio(2, 3)]), ("StretchLast will stretch the last lowest priority constraint\nStretch will only stretch equal weighted constraints", &[Length(20), Length(15)]), ("", &[Percentage(20), Length(15)]), - ("`Proportional(u16)` fills up excess space, but is lower priority to spacers.\ni.e. Proportional will only have widths in Flex::Stretch and Flex::StretchLast", &[Proportional(1), Proportional(1)]), + ("`Fill(u16)` fills up excess space, but is lower priority to spacers.\ni.e. Fill will only have widths in Flex::Stretch and Flex::StretchLast", &[Fill(1), Fill(1)]), ("", &[Length(20), Fixed(20)]), ( "When not using `Flex::Stretch` or `Flex::StretchLast`,\n`Min(u16)` and `Max(u16)` collapse to their lowest values", @@ -74,21 +74,21 @@ const EXAMPLE_DATA: &[(&str, &[Constraint])] = &[ &[Max(20)], ), ("", &[Min(20), Max(20), Length(20), Fixed(20)]), - ("", &[Proportional(0), Proportional(0)]), + ("", &[Fill(0), Fill(0)]), ( - "`Proportional(1)` can be to scale with respect to other `Proportional(2)`", - &[Proportional(1), Proportional(2)], + "`Fill(1)` can be to scale with respect to other `Fill(2)`", + &[Fill(1), Fill(2)], ), ( "", - &[Proportional(1), Min(10), Max(10), Proportional(2)], + &[Fill(1), Min(10), Max(10), Fill(2)], ), ( - "`Proportional(0)` collapses if there are other non-zero `Proportional(_)`\nconstraints. e.g. `[Proportional(0), Proportional(0), Proportional(1)]`:", + "`Fill(0)` collapses if there are other non-zero `Fill(_)`\nconstraints. e.g. `[Fill(0), Fill(0), Fill(1)]`:", &[ - Proportional(0), - Proportional(0), - Proportional(1), + Fill(0), + Fill(0), + Fill(1), ], ), ]; @@ -244,7 +244,7 @@ fn example_height() -> u16 { impl Widget for App { fn render(self, area: Rect, buf: &mut Buffer) { - let layout = Layout::vertical([Fixed(3), Fixed(1), Proportional(0)]); + let layout = Layout::vertical([Fixed(3), Fixed(1), Fill(0)]); let [tabs, axis, demo] = area.split(&layout); self.tabs().render(tabs, buf); let scroll_needed = self.render_demo(demo, buf); @@ -419,7 +419,7 @@ impl Example { impl Widget for Example { fn render(self, area: Rect, buf: &mut Buffer) { let title_height = get_description_height(&self.description); - let layout = Layout::vertical([Fixed(title_height), Proportional(0)]); + let layout = Layout::vertical([Fixed(title_height), Fill(0)]); let [title, illustrations] = area.split(&layout); let (blocks, spacers) = Layout::horizontal(&self.constraints) @@ -518,7 +518,7 @@ fn color_for_constraint(constraint: Constraint) -> Color { Constraint::Length(_) => SLATE.c700, Constraint::Percentage(_) => SLATE.c800, Constraint::Ratio(_, _) => SLATE.c900, - Constraint::Proportional(_) => SLATE.c950, + Constraint::Fill(_) => SLATE.c950, } } diff --git a/examples/layout.rs b/examples/layout.rs index 1c7d7fbd..bfff020d 100644 --- a/examples/layout.rs +++ b/examples/layout.rs @@ -217,7 +217,7 @@ fn constraint_label(constraint: Constraint) -> String { Min(n) => format!("{n}"), Max(n) => format!("{n}"), Percentage(n) => format!("{n}"), - Proportional(n) => format!("{n}"), + Fill(n) => format!("{n}"), Fixed(n) => format!("{n}"), Ratio(a, b) => format!("{a}:{b}"), } diff --git a/src/layout/constraint.rs b/src/layout/constraint.rs index f6a77f50..496e940a 100644 --- a/src/layout/constraint.rs +++ b/src/layout/constraint.rs @@ -6,7 +6,8 @@ use strum::EnumIs; /// A constraint that defines the size of a layout element. /// /// Constraints can be used to specify a fixed size, a percentage of the available space, a ratio of -/// the available space, a minimum or maximum size or a proportional value for a layout element. +/// the available space, a minimum or maximum size or a fill proportional value for a layout +/// element. /// /// Relative constraints (percentage, ratio) are calculated relative to the entire space being /// divided, rather than the space available after applying more fixed constraints (min, max, @@ -20,7 +21,7 @@ use strum::EnumIs; /// 4. [`Constraint::Length`] /// 5. [`Constraint::Percentage`] /// 6. [`Constraint::Ratio`] -/// 7. [`Constraint::Proportional`] +/// 7. [`Constraint::Fill`] /// /// # Examples /// @@ -44,8 +45,8 @@ use strum::EnumIs; /// // Create a sidebar layout specifying maximum sizes for the columns /// let constraints = Constraint::from_maxes([30, 170]); /// -/// // Create a layout with proportional sizes for each element -/// let constraints = Constraint::from_proportional_lengths([1, 2, 1]); +/// // Create a layout with fill proportional sizes for each element +/// let constraints = Constraint::from_fills([1, 2, 1]); /// ``` #[derive(Debug, Clone, Copy, Eq, PartialEq, Hash, EnumIs)] pub enum Constraint { @@ -56,7 +57,7 @@ pub enum Constraint { /// /// # Examples /// - /// `[Fixed(40), Proportional(1)]` + /// `[Fixed(40), Fill(1)]` /// /// ```plain /// ┌──────────────────────────────────────┐┌────────┐ @@ -64,7 +65,7 @@ pub enum Constraint { /// └──────────────────────────────────────┘└────────┘ /// ``` /// - /// `[Fixed(20), Fixed(20), Proportional(1)]` + /// `[Fixed(20), Fixed(20), Fill(1)]` /// /// ```plain /// ┌──────────────────┐┌──────────────────┐┌────────┐ @@ -145,7 +146,7 @@ pub enum Constraint { /// /// # Examples /// - /// `[Percentage(75), Proportional(1)]` + /// `[Percentage(75), Fill(1)]` /// /// ```plain /// ┌────────────────────────────────────┐┌──────────┐ @@ -153,7 +154,7 @@ pub enum Constraint { /// └────────────────────────────────────┘└──────────┘ /// ``` /// - /// `[Percentage(50), Proportional(1)]` + /// `[Percentage(50), Fill(1)]` /// /// ```plain /// ┌───────────────────────┐┌───────────────────────┐ @@ -184,16 +185,16 @@ pub enum Constraint { /// └───────────┘└──────────┘└───────────┘└──────────┘ /// ``` Ratio(u32, u32), - /// Applies the scaling factor proportional to all other [`Constraint::Proportional`] elements + /// Applies the scaling factor proportional to all other [`Constraint::Fill`] elements /// to fill excess space /// - /// The element will only expand into excess available space, proportionally matching other - /// [`Constraint::Proportional`] elements while satisfying all other constraints. + /// The element will only expand or fill into excess available space, proportionally matching + /// other [`Constraint::Fill`] elements while satisfying all other constraints. /// /// # Examples /// /// - /// `[Proportional(1), Proportional(2), Proportional(3)]` + /// `[Fill(1), Fill(2), Fill(3)]` /// /// ```plain /// ┌──────┐┌───────────────┐┌───────────────────────┐ @@ -201,14 +202,14 @@ pub enum Constraint { /// └──────┘└───────────────┘└───────────────────────┘ /// ``` /// - /// `[Proportional(1), Percentage(50), Proportional(1)]` + /// `[Fill(1), Percentage(50), Fill(1)]` /// /// ```plain /// ┌───────────┐┌───────────────────────┐┌──────────┐ /// │ 13 px ││ 25 px ││ 12 px │ /// └───────────┘└───────────────────────┘└──────────┘ /// ``` - Proportional(u16), + Fill(u16), } impl Constraint { @@ -232,7 +233,7 @@ impl Constraint { } Constraint::Length(l) => length.min(l), Constraint::Fixed(l) => length.min(l), - Constraint::Proportional(l) => length.min(l), + Constraint::Fill(l) => length.min(l), Constraint::Max(m) => length.min(m), Constraint::Min(m) => length.max(m), } @@ -359,13 +360,13 @@ impl Constraint { /// let constraints = Constraint::from_mins([1, 2, 3]); /// let layout = Layout::default().constraints(constraints).split(area); /// ``` - pub fn from_proportional_lengths(proportional_lengths: T) -> Vec + pub fn from_fills(proportional_factors: T) -> Vec where T: IntoIterator, { - proportional_lengths + proportional_factors .into_iter() - .map(Constraint::Proportional) + .map(Constraint::Fill) .collect_vec() } } @@ -415,7 +416,7 @@ impl Display for Constraint { Constraint::Ratio(n, d) => write!(f, "Ratio({}, {})", n, d), Constraint::Length(l) => write!(f, "Length({})", l), Constraint::Fixed(l) => write!(f, "Fixed({})", l), - Constraint::Proportional(l) => write!(f, "Proportional({})", l), + Constraint::Fill(l) => write!(f, "Fill({})", l), Constraint::Max(m) => write!(f, "Max({})", m), Constraint::Min(m) => write!(f, "Min({})", m), } @@ -502,17 +503,14 @@ mod tests { } #[test] - fn from_proportional_lengths() { + fn from_fills() { let expected = [ - Constraint::Proportional(1), - Constraint::Proportional(2), - Constraint::Proportional(3), + Constraint::Fill(1), + Constraint::Fill(2), + Constraint::Fill(3), ]; - assert_eq!(Constraint::from_proportional_lengths([1, 2, 3]), expected); - assert_eq!( - Constraint::from_proportional_lengths(vec![1, 2, 3]), - expected - ); + assert_eq!(Constraint::from_fills([1, 2, 3]), expected); + assert_eq!(Constraint::from_fills(vec![1, 2, 3]), expected); } #[test] diff --git a/src/layout/flex.rs b/src/layout/flex.rs index fca4e6cf..b6717578 100644 --- a/src/layout/flex.rs +++ b/src/layout/flex.rs @@ -25,9 +25,12 @@ pub enum Flex { /// constraints. As a refresher, the priorities of constraints are as follows: /// /// 1. [`Constraint::Fixed`] - /// 2. [`Constraint::Min`] / [`Constraint::Max`] - /// 3. [`Constraint::Length`] / [`Constraint::Percentage`] / [`Constraint::Ratio`] - /// 4. [`Constraint::Proportional`] + /// 2. [`Constraint::Min`] + /// 3. [`Constraint::Max`] + /// 4. [`Constraint::Length`] + /// 5. [`Constraint::Percentage`] + /// 6. [`Constraint::Ratio`] + /// 7. [`Constraint::Fill`] /// /// When every constraint is `Length`, the last element gets the excess. /// @@ -81,13 +84,13 @@ pub enum Flex { /// ^^^^^^^^^^^^^^^^ EXCESS ^^^^^^^^^^^^^^^^ /// ``` /// - /// Proportional constraints have the lowest priority amongst all the constraints and hence + /// Fill constraints have the lowest priority amongst all the constraints and hence /// will always take up any excess space available. /// /// ```plain /// <----------------------------------- 80 px ------------------------------------> /// ┌──────20 px───────┐┌──────20 px───────┐┌──────20 px───────┐┌──────20 px───────┐ - /// │ Proportional(0) ││ Min(20) ││ Length(20) ││ Fixed(20) │ + /// │ Fill(0) ││ Min(20) ││ Length(20) ││ Fixed(20) │ /// └──────────────────┘└──────────────────┘└──────────────────┘└──────────────────┘ /// ^^^^^^ EXCESS ^^^^^^ /// ``` diff --git a/src/layout/layout.rs b/src/layout/layout.rs index 4115cdcf..18bcd37e 100644 --- a/src/layout/layout.rs +++ b/src/layout/layout.rs @@ -9,8 +9,8 @@ use itertools::Itertools; use lru::LruCache; use self::strengths::{ - FIXED_SIZE_EQ, LENGTH_SIZE_EQ, MAX_SIZE_EQ, MAX_SIZE_LE, MIN_SIZE_EQ, MIN_SIZE_GE, - PERCENTAGE_SIZE_EQ, PROPORTIONAL_GROW, RATIO_SIZE_EQ, *, + FILL_GROW, FIXED_SIZE_EQ, LENGTH_SIZE_EQ, MAX_SIZE_EQ, MAX_SIZE_LE, MIN_SIZE_EQ, MIN_SIZE_GE, + PERCENTAGE_SIZE_EQ, RATIO_SIZE_EQ, *, }; use super::{Flex, SegmentSize}; use crate::prelude::*; @@ -620,7 +620,7 @@ impl Layout { configure_variable_constraints(&mut solver, &variables, area_size)?; configure_flex_constraints(&mut solver, area_size, &spacers, &segments, flex, spacing)?; configure_constraints(&mut solver, area_size, &segments, constraints)?; - configure_proportional_constraints(&mut solver, &segments, constraints)?; + configure_fill_constraints(&mut solver, &segments, constraints)?; // `solver.fetch_changes()` can only be called once per solve let changes: HashMap = solver.fetch_changes().iter().copied().collect(); @@ -694,9 +694,9 @@ fn configure_constraints( let size = area.size() * f64::from(num) / f64::from(den.max(1)); solver.add_constraint(element.has_size(size, RATIO_SIZE_EQ))?; } - Constraint::Proportional(_) => { + Constraint::Fill(_) => { // given no other constraints, this segment will grow as much as possible. - solver.add_constraint(element.has_size(area, PROPORTIONAL_GROW))?; + solver.add_constraint(element.has_size(area, FILL_GROW))?; } } } @@ -792,21 +792,21 @@ fn configure_flex_constraints( Ok(()) } -/// Make every `Proportional` constraint proportionally equal to each other +/// Make every `Fill` constraint proportionally equal to each other /// This will make it fill up empty spaces equally /// -/// [Proportional(1), Proportional(1)] +/// [Fill(1), Fill(1)] /// ┌──────┐┌──────┐ /// │abcdef││abcdef│ /// └──────┘└──────┘ /// -/// [Proportional(1), Proportional(2)] +/// [Fill(1), Fill(2)] /// ┌──────┐┌────────────┐ /// │abcdef││abcdefabcdef│ /// └──────┘└────────────┘ /// /// size == base_element * scaling_factor -fn configure_proportional_constraints( +fn configure_fill_constraints( solver: &mut Solver, segments: &[Element], constraints: &[Constraint], @@ -814,17 +814,15 @@ fn configure_proportional_constraints( for ((&l_constraint, &l_element), (&r_constraint, &r_element)) in constraints .iter() .zip(segments.iter()) - .filter(|(c, _)| c.is_proportional()) + .filter(|(c, _)| c.is_fill()) .tuple_combinations() { - // `Proportional` will only expand into _excess_ available space. You can think of - // `Proportional` element sizes as starting from `0` and incrementally - // increasing while proportionally matching other `Proportional` spaces AND + // `Fill` will only expand into _excess_ available space. You can think of + // `Fill` element sizes as starting from `0` and incrementally + // increasing while proportionally matching other `Fill` spaces AND // also meeting all other constraints. - if let ( - Constraint::Proportional(l_scaling_factor), - Constraint::Proportional(r_scaling_factor), - ) = (l_constraint, r_constraint) + if let (Constraint::Fill(l_scaling_factor), Constraint::Fill(r_scaling_factor)) = + (l_constraint, r_constraint) { // because of the way cassowary works, we need to use `*` instead of `/` // l_size / l_scaling_factor == l_size / l_scaling_factor @@ -846,7 +844,7 @@ fn configure_proportional_constraints( ); solver.add_constraint( (r_scaling_factor * l_element.size()) - | EQ(PROPORTIONAL_SCALING_EQ) + | EQ(FILL_SCALING_EQ) | (l_scaling_factor * r_element.size()), )?; } @@ -969,12 +967,12 @@ mod strengths { /// └ ┘└───┘└ ┘└───┘└ ┘ pub const SPACER_SIZE_EQ: f64 = REQUIRED - 1.0; - /// The strength to apply to Proportional constraints so that their sizes are proportional. + /// The strength to apply to Fill constraints so that their sizes are proportional. /// /// ┌───────────────┐┌───────────────┐ - /// │Proportional(x)││Proportional(x)│ + /// │ Fill(x) ││ Fill(x) │ /// └───────────────┘└───────────────┘ - pub const PROPORTIONAL_SCALING_EQ: f64 = REQUIRED - 1.0; + pub const FILL_SCALING_EQ: f64 = REQUIRED - 1.0; /// The strength to apply to Fixed constraints. /// @@ -1032,12 +1030,12 @@ mod strengths { /// └────────┘ pub const MAX_SIZE_EQ: f64 = MEDIUM / 10.0; - /// The strength to apply to Proportional growing constraints. + /// The strength to apply to Fill growing constraints. /// /// ┌─────────────────────┐ - /// │<= Proportional(x) =>│ + /// │<= Fill(x) =>│ /// └─────────────────────┘ - pub const PROPORTIONAL_GROW: f64 = WEAK * 10.0; + pub const FILL_GROW: f64 = WEAK * 10.0; /// The strength to apply to growing constraints. /// @@ -1056,7 +1054,7 @@ mod strengths { #[allow(dead_code)] pub fn is_valid() -> bool { SPACER_SIZE_EQ > FIXED_SIZE_EQ - && PROPORTIONAL_SCALING_EQ > FIXED_SIZE_EQ + && FILL_SCALING_EQ > FIXED_SIZE_EQ && FIXED_SIZE_EQ > MIN_SIZE_GE && MIN_SIZE_GE > MIN_SIZE_EQ && MAX_SIZE_LE > MAX_SIZE_EQ @@ -1066,8 +1064,8 @@ mod strengths { && LENGTH_SIZE_EQ > PERCENTAGE_SIZE_EQ && PERCENTAGE_SIZE_EQ > RATIO_SIZE_EQ && RATIO_SIZE_EQ > MAX_SIZE_EQ - && MIN_SIZE_GE > PROPORTIONAL_GROW - && PROPORTIONAL_GROW > GROW + && MIN_SIZE_GE > FILL_GROW + && FILL_GROW > GROW && GROW > SPACE_GROW } } @@ -1084,14 +1082,14 @@ mod tests { fn strength() { assert!(strengths::is_valid()); assert_eq!(strengths::SPACER_SIZE_EQ, REQUIRED - 1.0); - assert_eq!(strengths::PROPORTIONAL_SCALING_EQ, REQUIRED - 1.0); + assert_eq!(strengths::FILL_SCALING_EQ, REQUIRED - 1.0); assert_eq!(strengths::FIXED_SIZE_EQ, REQUIRED / 10.0); assert_eq!(strengths::MIN_SIZE_GE, STRONG * 10.0); assert_eq!(strengths::LENGTH_SIZE_EQ, STRONG / 10.0); assert_eq!(strengths::PERCENTAGE_SIZE_EQ, MEDIUM * 10.0); assert_eq!(strengths::RATIO_SIZE_EQ, MEDIUM); assert_eq!(strengths::MIN_SIZE_EQ, MEDIUM / 10.0); - assert_eq!(strengths::PROPORTIONAL_GROW, WEAK * 10.0); + assert_eq!(strengths::FILL_GROW, WEAK * 10.0); assert_eq!(strengths::GROW, WEAK); assert_eq!(strengths::SPACE_GROW, WEAK / 10.0); } @@ -1858,10 +1856,10 @@ mod tests { #[case::fixed_higher_priority(vec![50, 25, 25], vec![Ratio(1, 4), Percentage(25), Fixed(25)])] #[case::fixed_higher_priority(vec![79, 1, 20], vec![Length(100), Fixed(1), Min(20)])] #[case::fixed_higher_priority(vec![20, 1, 79], vec![Min(20), Fixed(1), Length(100)])] - #[case::fixed_higher_priority(vec![45, 10, 45], vec![Proportional(1), Fixed(10), Proportional(1)])] - #[case::fixed_higher_priority(vec![30, 10, 60], vec![Proportional(1), Fixed(10), Proportional(2)])] - #[case::fixed_higher_priority(vec![18, 10, 72], vec![Proportional(1), Fixed(10), Proportional(4)])] - #[case::fixed_higher_priority(vec![15, 10, 75], vec![Proportional(1), Fixed(10), Proportional(5)])] + #[case::fixed_higher_priority(vec![45, 10, 45], vec![Fill(1), Fixed(10), Fill(1)])] + #[case::fixed_higher_priority(vec![30, 10, 60], vec![Fill(1), Fixed(10), Fill(2)])] + #[case::fixed_higher_priority(vec![18, 10, 72], vec![Fill(1), Fixed(10), Fill(4)])] + #[case::fixed_higher_priority(vec![15, 10, 75], vec![Fill(1), Fixed(10), Fill(5)])] #[case::three_lengths_reference(vec![25, 25, 50], vec![Length(25), Length(25), Length(25)])] // #[case::previously_unstable_test(vec![25, 50, 25], vec![Length(25), Length(25), // Fixed(25)])] @@ -1877,8 +1875,8 @@ mod tests { } #[rstest] - #[case::excess_in_last_variable(vec![13, 10, 27], vec![Proportional(1), Fixed(10), Proportional(2)])] - #[case::excess_in_last_variable(vec![10, 27, 13], vec![Fixed(10), Proportional(2), Proportional(1)])] // might be unstable? + #[case::excess_in_last_variable(vec![13, 10, 27], vec![Fill(1), Fixed(10), Fill(2)])] + #[case::excess_in_last_variable(vec![10, 27, 13], vec![Fixed(10), Fill(2), Fill(1)])] // might be unstable? fn fixed_with_50_width(#[case] expected: Vec, #[case] constraints: Vec) { let rect = Rect::new(0, 0, 50, 1); let r = Layout::horizontal(constraints) @@ -1891,42 +1889,42 @@ mod tests { } #[rstest] - #[case::multiple_same_proportionals_are_same(vec![20, 40, 20, 20], vec![Proportional(1), Proportional(2), Proportional(1), Proportional(1)])] - #[case::incremental(vec![10, 20, 30, 40], vec![Proportional(1), Proportional(2), Proportional(3), Proportional(4)])] - #[case::decremental(vec![40, 30, 20, 10], vec![Proportional(4), Proportional(3), Proportional(2), Proportional(1)])] - #[case::randomly_ordered(vec![10, 30, 20, 40], vec![Proportional(1), Proportional(3), Proportional(2), Proportional(4)])] - #[case::randomly_ordered(vec![5, 15, 50, 10, 20], vec![Proportional(1), Proportional(3), Fixed(50), Proportional(2), Proportional(4)])] - #[case::randomly_ordered(vec![5, 15, 50, 10, 20], vec![Proportional(1), Proportional(3), Length(50), Proportional(2), Proportional(4)])] - #[case::randomly_ordered(vec![5, 15, 50, 10, 20], vec![Proportional(1), Proportional(3), Percentage(50), Proportional(2), Proportional(4)])] - #[case::randomly_ordered(vec![5, 15, 50, 10, 20], vec![Proportional(1), Proportional(3), Min(50), Proportional(2), Proportional(4)])] - #[case::randomly_ordered(vec![5, 15, 50, 10, 20], vec![Proportional(1), Proportional(3), Max(50), Proportional(2), Proportional(4)])] - #[case::zero_width(vec![0, 100, 0], vec![Proportional(0), Proportional(1), Proportional(0)])] - #[case::zero_width(vec![50, 1, 49], vec![Proportional(0), Fixed(1), Proportional(0)])] - #[case::zero_width(vec![50, 1, 49], vec![Proportional(0), Length(1), Proportional(0)])] - #[case::zero_width(vec![50, 1, 49], vec![Proportional(0), Percentage(1), Proportional(0)])] - #[case::zero_width(vec![50, 1, 49], vec![Proportional(0), Min(1), Proportional(0)])] - #[case::zero_width(vec![50, 1, 49], vec![Proportional(0), Max(1), Proportional(0)])] - #[case::zero_width(vec![0, 67, 0, 33], vec![Proportional(0), Proportional(2), Proportional(0), Proportional(1)])] - #[case::space_filler(vec![0, 80, 20], vec![Proportional(0), Proportional(2), Percentage(20)])] - #[case::space_filler(vec![40, 40, 20], vec![Proportional(0), Proportional(0), Percentage(20)])] - #[case::space_filler(vec![80, 20], vec![Proportional(0), Ratio(1, 5)])] - #[case::space_filler(vec![0, 100], vec![Proportional(0), Proportional(u16::MAX)])] - #[case::space_filler(vec![100, 0], vec![Proportional(u16::MAX), Proportional(0)])] - #[case::space_filler(vec![80, 20], vec![Proportional(0), Percentage(20)])] - #[case::space_filler(vec![80, 20], vec![Proportional(1), Percentage(20)])] - #[case::space_filler(vec![80, 20], vec![Proportional(u16::MAX), Percentage(20)])] - #[case::space_filler(vec![80, 0, 20], vec![Proportional(u16::MAX), Proportional(0), Percentage(20)])] - #[case::space_filler(vec![80, 20], vec![Proportional(0), Fixed(20)])] - #[case::space_filler(vec![80, 20], vec![Proportional(0), Length(20)])] - #[case::space_filler(vec![80, 20], vec![Proportional(0), Min(20)])] - #[case::space_filler(vec![80, 20], vec![Proportional(0), Max(20)])] - #[case::proportional_collapses_first(vec![7, 6, 7, 30, 50], vec![Proportional(1), Proportional(1), Proportional(1), Min(30), Length(50)])] - #[case::proportional_collapses_first(vec![0, 0, 0, 50, 50], vec![Proportional(1), Proportional(1), Proportional(1), Length(50), Length(50)])] - #[case::proportional_collapses_first(vec![0, 0, 0, 75, 25], vec![Proportional(1), Proportional(1), Proportional(1), Length(75), Length(50)])] - #[case::proportional_collapses_first(vec![0, 0, 0, 50, 50], vec![Proportional(1), Proportional(1), Proportional(1), Min(50), Max(50)])] - #[case::proportional_collapses_first(vec![0, 0, 0, 100], vec![Proportional(1), Proportional(1), Proportional(1), Ratio(1, 1)])] - #[case::proportional_collapses_first(vec![0, 0, 0, 100], vec![Proportional(1), Proportional(1), Proportional(1), Percentage(100)])] - fn proportional(#[case] expected: Vec, #[case] constraints: Vec) { + #[case::multiple_same_fill_are_same(vec![20, 40, 20, 20], vec![Fill(1), Fill(2), Fill(1), Fill(1)])] + #[case::incremental(vec![10, 20, 30, 40], vec![Fill(1), Fill(2), Fill(3), Fill(4)])] + #[case::decremental(vec![40, 30, 20, 10], vec![Fill(4), Fill(3), Fill(2), Fill(1)])] + #[case::randomly_ordered(vec![10, 30, 20, 40], vec![Fill(1), Fill(3), Fill(2), Fill(4)])] + #[case::randomly_ordered(vec![5, 15, 50, 10, 20], vec![Fill(1), Fill(3), Fixed(50), Fill(2), Fill(4)])] + #[case::randomly_ordered(vec![5, 15, 50, 10, 20], vec![Fill(1), Fill(3), Length(50), Fill(2), Fill(4)])] + #[case::randomly_ordered(vec![5, 15, 50, 10, 20], vec![Fill(1), Fill(3), Percentage(50), Fill(2), Fill(4)])] + #[case::randomly_ordered(vec![5, 15, 50, 10, 20], vec![Fill(1), Fill(3), Min(50), Fill(2), Fill(4)])] + #[case::randomly_ordered(vec![5, 15, 50, 10, 20], vec![Fill(1), Fill(3), Max(50), Fill(2), Fill(4)])] + #[case::zero_width(vec![0, 100, 0], vec![Fill(0), Fill(1), Fill(0)])] + #[case::zero_width(vec![50, 1, 49], vec![Fill(0), Fixed(1), Fill(0)])] + #[case::zero_width(vec![50, 1, 49], vec![Fill(0), Length(1), Fill(0)])] + #[case::zero_width(vec![50, 1, 49], vec![Fill(0), Percentage(1), Fill(0)])] + #[case::zero_width(vec![50, 1, 49], vec![Fill(0), Min(1), Fill(0)])] + #[case::zero_width(vec![50, 1, 49], vec![Fill(0), Max(1), Fill(0)])] + #[case::zero_width(vec![0, 67, 0, 33], vec![Fill(0), Fill(2), Fill(0), Fill(1)])] + #[case::space_filler(vec![0, 80, 20], vec![Fill(0), Fill(2), Percentage(20)])] + #[case::space_filler(vec![40, 40, 20], vec![Fill(0), Fill(0), Percentage(20)])] + #[case::space_filler(vec![80, 20], vec![Fill(0), Ratio(1, 5)])] + #[case::space_filler(vec![0, 100], vec![Fill(0), Fill(u16::MAX)])] + #[case::space_filler(vec![100, 0], vec![Fill(u16::MAX), Fill(0)])] + #[case::space_filler(vec![80, 20], vec![Fill(0), Percentage(20)])] + #[case::space_filler(vec![80, 20], vec![Fill(1), Percentage(20)])] + #[case::space_filler(vec![80, 20], vec![Fill(u16::MAX), Percentage(20)])] + #[case::space_filler(vec![80, 0, 20], vec![Fill(u16::MAX), Fill(0), Percentage(20)])] + #[case::space_filler(vec![80, 20], vec![Fill(0), Fixed(20)])] + #[case::space_filler(vec![80, 20], vec![Fill(0), Length(20)])] + #[case::space_filler(vec![80, 20], vec![Fill(0), Min(20)])] + #[case::space_filler(vec![80, 20], vec![Fill(0), Max(20)])] + #[case::fill_collapses_first(vec![7, 6, 7, 30, 50], vec![Fill(1), Fill(1), Fill(1), Min(30), Length(50)])] + #[case::fill_collapses_first(vec![0, 0, 0, 50, 50], vec![Fill(1), Fill(1), Fill(1), Length(50), Length(50)])] + #[case::fill_collapses_first(vec![0, 0, 0, 75, 25], vec![Fill(1), Fill(1), Fill(1), Length(75), Length(50)])] + #[case::fill_collapses_first(vec![0, 0, 0, 50, 50], vec![Fill(1), Fill(1), Fill(1), Min(50), Max(50)])] + #[case::fill_collapses_first(vec![0, 0, 0, 100], vec![Fill(1), Fill(1), Fill(1), Ratio(1, 1)])] + #[case::fill_collapses_first(vec![0, 0, 0, 100], vec![Fill(1), Fill(1), Fill(1), Percentage(100)])] + fn fill(#[case] expected: Vec, #[case] constraints: Vec) { let rect = Rect::new(0, 0, 100, 1); let r = Layout::horizontal(constraints) .split(rect) @@ -2103,8 +2101,8 @@ mod tests { #[case::n(vec![(0, 75), (75, 25)], vec![Ratio(1, 4), Length(25)])] #[case::o(vec![(0, 25), (25, 75)], vec![Percentage(25), Ratio(1, 4)])] #[case::p(vec![(0, 75), (75, 25)], vec![Ratio(1, 4), Percentage(25)])] - #[case::q(vec![(0, 25), (25, 75)], vec![Ratio(1, 4), Proportional(25)])] - #[case::r(vec![(0, 75), (75, 25)], vec![Proportional(25), Ratio(1, 4)])] + #[case::q(vec![(0, 25), (25, 75)], vec![Ratio(1, 4), Fill(25)])] + #[case::r(vec![(0, 75), (75, 25)], vec![Fill(25), Ratio(1, 4)])] fn constraint_specification_tests_for_priority( #[case] expected: Vec<(u16, u16)>, #[case] constraints: Vec, @@ -2147,17 +2145,17 @@ mod tests { } #[rstest] - #[case::prop(vec![(0 , 10), (10, 80), (90 , 10)] , vec![Fixed(10), Proportional(1), Fixed(10)], Flex::Stretch)] + #[case::prop(vec![(0 , 10), (10, 80), (90 , 10)] , vec![Fixed(10), Fill(1), Fixed(10)], Flex::Stretch)] #[case::flex(vec![(0 , 10), (90 , 10)] , vec![Fixed(10), Fixed(10)], Flex::SpaceBetween)] - #[case::prop(vec![(0 , 27), (27, 10), (37, 26), (63, 10), (73, 27)] , vec![Proportional(1), Fixed(10), Proportional(1), Fixed(10), Proportional(1)], Flex::Stretch)] + #[case::prop(vec![(0 , 27), (27, 10), (37, 26), (63, 10), (73, 27)] , vec![Fill(1), Fixed(10), Fill(1), Fixed(10), Fill(1)], Flex::Stretch)] #[case::flex(vec![(27 , 10), (63, 10)] , vec![Fixed(10), Fixed(10)], Flex::SpaceAround)] - #[case::prop(vec![(0 , 10), (10, 10), (20 , 80)] , vec![Fixed(10), Fixed(10), Proportional(1)], Flex::Stretch)] + #[case::prop(vec![(0 , 10), (10, 10), (20 , 80)] , vec![Fixed(10), Fixed(10), Fill(1)], Flex::Stretch)] #[case::flex(vec![(0 , 10), (10, 10)] , vec![Fixed(10), Fixed(10)], Flex::Start)] - #[case::prop(vec![(0 , 80), (80 , 10), (90, 10)] , vec![Proportional(1), Fixed(10), Fixed(10)], Flex::Stretch)] + #[case::prop(vec![(0 , 80), (80 , 10), (90, 10)] , vec![Fill(1), Fixed(10), Fixed(10)], Flex::Stretch)] #[case::flex(vec![(80 , 10), (90, 10)] , vec![Fixed(10), Fixed(10)], Flex::End)] - #[case::prop(vec![(0 , 40), (40, 10), (50, 10), (60, 40)] , vec![Proportional(1), Fixed(10), Fixed(10), Proportional(1)], Flex::Stretch)] + #[case::prop(vec![(0 , 40), (40, 10), (50, 10), (60, 40)] , vec![Fill(1), Fixed(10), Fixed(10), Fill(1)], Flex::Stretch)] #[case::flex(vec![(40 , 10), (50, 10)] , vec![Fixed(10), Fixed(10)], Flex::Center)] - fn proportional_vs_flex( + fn fill_vs_flex( #[case] expected: Vec<(u16, u16)>, #[case] constraints: Vec, #[case] flex: Flex, @@ -2172,37 +2170,37 @@ mod tests { } #[rstest] - #[case::flex0(vec![(0 , 50), (50 , 50)] , vec![Proportional(1), Proportional(1)], Flex::Stretch , 0)] - #[case::flex0(vec![(0 , 50), (50 , 50)] , vec![Proportional(1), Proportional(1)], Flex::StretchLast , 0)] - #[case::flex0(vec![(0 , 50), (50 , 50)] , vec![Proportional(1), Proportional(1)], Flex::SpaceAround , 0)] - #[case::flex0(vec![(0 , 50), (50 , 50)] , vec![Proportional(1), Proportional(1)], Flex::SpaceBetween , 0)] - #[case::flex0(vec![(0 , 50), (50 , 50)] , vec![Proportional(1), Proportional(1)], Flex::Start , 0)] - #[case::flex0(vec![(0 , 50), (50 , 50)] , vec![Proportional(1), Proportional(1)], Flex::Center , 0)] - #[case::flex0(vec![(0 , 50), (50 , 50)] , vec![Proportional(1), Proportional(1)], Flex::End , 0)] - #[case::flex10(vec![(0 , 45), (55 , 45)] , vec![Proportional(1), Proportional(1)], Flex::Stretch , 10)] - #[case::flex10(vec![(0 , 45), (55 , 45)] , vec![Proportional(1), Proportional(1)], Flex::StretchLast , 10)] - #[case::flex10(vec![(0 , 45), (55 , 45)] , vec![Proportional(1), Proportional(1)], Flex::Start , 10)] - #[case::flex10(vec![(0 , 45), (55 , 45)] , vec![Proportional(1), Proportional(1)], Flex::Center , 10)] - #[case::flex10(vec![(0 , 45), (55 , 45)] , vec![Proportional(1), Proportional(1)], Flex::End , 10)] + #[case::flex0(vec![(0 , 50), (50 , 50)] , vec![Fill(1), Fill(1)], Flex::Stretch , 0)] + #[case::flex0(vec![(0 , 50), (50 , 50)] , vec![Fill(1), Fill(1)], Flex::StretchLast , 0)] + #[case::flex0(vec![(0 , 50), (50 , 50)] , vec![Fill(1), Fill(1)], Flex::SpaceAround , 0)] + #[case::flex0(vec![(0 , 50), (50 , 50)] , vec![Fill(1), Fill(1)], Flex::SpaceBetween , 0)] + #[case::flex0(vec![(0 , 50), (50 , 50)] , vec![Fill(1), Fill(1)], Flex::Start , 0)] + #[case::flex0(vec![(0 , 50), (50 , 50)] , vec![Fill(1), Fill(1)], Flex::Center , 0)] + #[case::flex0(vec![(0 , 50), (50 , 50)] , vec![Fill(1), Fill(1)], Flex::End , 0)] + #[case::flex10(vec![(0 , 45), (55 , 45)] , vec![Fill(1), Fill(1)], Flex::Stretch , 10)] + #[case::flex10(vec![(0 , 45), (55 , 45)] , vec![Fill(1), Fill(1)], Flex::StretchLast , 10)] + #[case::flex10(vec![(0 , 45), (55 , 45)] , vec![Fill(1), Fill(1)], Flex::Start , 10)] + #[case::flex10(vec![(0 , 45), (55 , 45)] , vec![Fill(1), Fill(1)], Flex::Center , 10)] + #[case::flex10(vec![(0 , 45), (55 , 45)] , vec![Fill(1), Fill(1)], Flex::End , 10)] // SpaceAround and SpaceBetween spacers behave differently from other flexes - #[case::flex10(vec![(0 , 50), (50 , 50)] , vec![Proportional(1), Proportional(1)], Flex::SpaceAround , 10)] - #[case::flex10(vec![(0 , 50), (50 , 50)] , vec![Proportional(1), Proportional(1)], Flex::SpaceBetween , 10)] - #[case::flex_fixed0(vec![(0 , 45), (45, 10), (55 , 45)] , vec![Proportional(1), Fixed(10), Proportional(1)], Flex::Stretch , 0)] - #[case::flex_fixed0(vec![(0 , 45), (45, 10), (55 , 45)] , vec![Proportional(1), Fixed(10), Proportional(1)], Flex::StretchLast , 0)] - #[case::flex_fixed0(vec![(0 , 45), (45, 10), (55 , 45)] , vec![Proportional(1), Fixed(10), Proportional(1)], Flex::SpaceAround , 0)] - #[case::flex_fixed0(vec![(0 , 45), (45, 10), (55 , 45)] , vec![Proportional(1), Fixed(10), Proportional(1)], Flex::SpaceBetween , 0)] - #[case::flex_fixed0(vec![(0 , 45), (45, 10), (55 , 45)] , vec![Proportional(1), Fixed(10), Proportional(1)], Flex::Start , 0)] - #[case::flex_fixed0(vec![(0 , 45), (45, 10), (55 , 45)] , vec![Proportional(1), Fixed(10), Proportional(1)], Flex::Center , 0)] - #[case::flex_fixed0(vec![(0 , 45), (45, 10), (55 , 45)] , vec![Proportional(1), Fixed(10), Proportional(1)], Flex::End , 0)] - #[case::flex_fixed10(vec![(0 , 35), (45, 10), (65 , 35)] , vec![Proportional(1), Fixed(10), Proportional(1)], Flex::Stretch , 10)] - #[case::flex_fixed10(vec![(0 , 35), (45, 10), (65 , 35)] , vec![Proportional(1), Fixed(10), Proportional(1)], Flex::StretchLast , 10)] - #[case::flex_fixed10(vec![(0 , 35), (45, 10), (65 , 35)] , vec![Proportional(1), Fixed(10), Proportional(1)], Flex::Start , 10)] - #[case::flex_fixed10(vec![(0 , 35), (45, 10), (65 , 35)] , vec![Proportional(1), Fixed(10), Proportional(1)], Flex::Center , 10)] - #[case::flex_fixed10(vec![(0 , 35), (45, 10), (65 , 35)] , vec![Proportional(1), Fixed(10), Proportional(1)], Flex::End , 10)] + #[case::flex10(vec![(0 , 50), (50 , 50)] , vec![Fill(1), Fill(1)], Flex::SpaceAround , 10)] + #[case::flex10(vec![(0 , 50), (50 , 50)] , vec![Fill(1), Fill(1)], Flex::SpaceBetween , 10)] + #[case::flex_fixed0(vec![(0 , 45), (45, 10), (55 , 45)] , vec![Fill(1), Fixed(10), Fill(1)], Flex::Stretch , 0)] + #[case::flex_fixed0(vec![(0 , 45), (45, 10), (55 , 45)] , vec![Fill(1), Fixed(10), Fill(1)], Flex::StretchLast , 0)] + #[case::flex_fixed0(vec![(0 , 45), (45, 10), (55 , 45)] , vec![Fill(1), Fixed(10), Fill(1)], Flex::SpaceAround , 0)] + #[case::flex_fixed0(vec![(0 , 45), (45, 10), (55 , 45)] , vec![Fill(1), Fixed(10), Fill(1)], Flex::SpaceBetween , 0)] + #[case::flex_fixed0(vec![(0 , 45), (45, 10), (55 , 45)] , vec![Fill(1), Fixed(10), Fill(1)], Flex::Start , 0)] + #[case::flex_fixed0(vec![(0 , 45), (45, 10), (55 , 45)] , vec![Fill(1), Fixed(10), Fill(1)], Flex::Center , 0)] + #[case::flex_fixed0(vec![(0 , 45), (45, 10), (55 , 45)] , vec![Fill(1), Fixed(10), Fill(1)], Flex::End , 0)] + #[case::flex_fixed10(vec![(0 , 35), (45, 10), (65 , 35)] , vec![Fill(1), Fixed(10), Fill(1)], Flex::Stretch , 10)] + #[case::flex_fixed10(vec![(0 , 35), (45, 10), (65 , 35)] , vec![Fill(1), Fixed(10), Fill(1)], Flex::StretchLast , 10)] + #[case::flex_fixed10(vec![(0 , 35), (45, 10), (65 , 35)] , vec![Fill(1), Fixed(10), Fill(1)], Flex::Start , 10)] + #[case::flex_fixed10(vec![(0 , 35), (45, 10), (65 , 35)] , vec![Fill(1), Fixed(10), Fill(1)], Flex::Center , 10)] + #[case::flex_fixed10(vec![(0 , 35), (45, 10), (65 , 35)] , vec![Fill(1), Fixed(10), Fill(1)], Flex::End , 10)] // SpaceAround and SpaceBetween spacers behave differently from other flexes - #[case::flex_fixed10(vec![(0 , 45), (45, 10), (55 , 45)] , vec![Proportional(1), Fixed(10), Proportional(1)], Flex::SpaceAround , 10)] - #[case::flex_fixed10(vec![(0 , 45), (45, 10), (55 , 45)] , vec![Proportional(1), Fixed(10), Proportional(1)], Flex::SpaceBetween , 10)] - fn proportional_spacing( + #[case::flex_fixed10(vec![(0 , 45), (45, 10), (55 , 45)] , vec![Fill(1), Fixed(10), Fill(1)], Flex::SpaceAround , 10)] + #[case::flex_fixed10(vec![(0 , 45), (45, 10), (55 , 45)] , vec![Fill(1), Fixed(10), Fill(1)], Flex::SpaceBetween , 10)] + fn fill_spacing( #[case] expected: Vec<(u16, u16)>, #[case] constraints: Vec, #[case] flex: Flex, diff --git a/src/widgets/calendar.rs b/src/widgets/calendar.rs index fc99b787..972a7c82 100644 --- a/src/widgets/calendar.rs +++ b/src/widgets/calendar.rs @@ -133,7 +133,7 @@ impl Monthly<'_, DS> { let layout = Layout::vertical([ Constraint::Length(self.show_month.is_some().into()), Constraint::Length(self.show_weekday.is_some().into()), - Constraint::Proportional(1), + Constraint::Fill(1), ]); let [month_header, days_header, days_area] = area.split(&layout); diff --git a/src/widgets/table/table.rs b/src/widgets/table/table.rs index c2d1c8b8..95f91d73 100644 --- a/src/widgets/table/table.rs +++ b/src/widgets/table/table.rs @@ -775,7 +775,7 @@ impl Table<'_> { let [_selection_area, columns_area] = Rect::new(0, 0, max_width, 1).split(&Layout::horizontal([ Constraint::Fixed(selection_width), - Constraint::Proportional(0), + Constraint::Fill(0), ])); let rects = Layout::horizontal(widths) .flex(self.flex)