Enum Flex 

pub enum Flex {
    Legacy,
    Start,
    End,
    Center,
    SpaceBetween,
    SpaceEvenly,
    SpaceAround,
}

Defines the options for layout flex justify content in a container.

This enumeration controls the distribution of space when layout constraints are met and there is excess space available. The Flex option is used with Layout to control how extra space is distributed among layout segments, which is particularly useful for creating responsive layouts that adapt to different terminal sizes.

Available options:

• Legacy: Fills the available space within the container, putting excess space into the last element.
• Start: Aligns items to the start of the container.
• End: Aligns items to the end of the container.
• Center: Centers items within the container.
• SpaceBetween: Adds excess space between each element.
• SpaceAround: Adds excess space around each element.

For comprehensive layout documentation and examples, see the layout module.

Variants

Legacy

Fills the available space within the container, putting excess space into the last constraint of the lowest priority. This matches the default behavior of ratatui and tui applications without Flex

The following examples illustrate the allocation of excess in various combinations of constraints. As a refresher, the priorities of constraints are as follows:

1. Constraint::Min
2. Constraint::Max
3. Constraint::Length
4. Constraint::Percentage
5. Constraint::Ratio
6. Constraint::Fill

When every constraint is Length, the last element gets the excess.

<----------------------------------- 80 px ------------------------------------>
┌──────20 px───────┐┌──────20 px───────┐┌────────────────40 px─────────────────┐
│    Length(20)    ││    Length(20)    ││              Length(20)              │
└──────────────────┘└──────────────────┘└──────────────────────────────────────┘
                                        ^^^^^^^^^^^^^^^^ EXCESS ^^^^^^^^^^^^^^^^

Fill constraints have the lowest priority amongst all the constraints and hence will always take up any excess space available.

<----------------------------------- 80 px ------------------------------------>
┌──────20 px───────┐┌──────20 px───────┐┌──────20 px───────┐┌──────20 px───────┐
│      Fill(0)     ││      Max(20)     ││    Length(20)    ││     Length(20)   │
└──────────────────┘└──────────────────┘└──────────────────┘└──────────────────┘
^^^^^^ EXCESS ^^^^^^

Examples

<------------------------------------80 px------------------------------------->
┌──────────────────────────60 px───────────────────────────┐┌──────20 px───────┐
│                          Min(20)                         ││      Max(20)     │
└──────────────────────────────────────────────────────────┘└──────────────────┘

<------------------------------------80 px------------------------------------->
┌────────────────────────────────────80 px─────────────────────────────────────┐
│                                    Max(20)                                   │
└──────────────────────────────────────────────────────────────────────────────┘

Start

Aligns items to the start of the container.

Examples

<------------------------------------80 px------------------------------------->
┌────16 px─────┐┌──────20 px───────┐┌──────20 px───────┐
│Percentage(20)││    Length(20)    ││     Fixed(20)    │
└──────────────┘└──────────────────┘└──────────────────┘

<------------------------------------80 px------------------------------------->
┌──────20 px───────┐┌──────20 px───────┐
│      Max(20)     ││      Max(20)     │
└──────────────────┘└──────────────────┘

<------------------------------------80 px------------------------------------->
┌──────20 px───────┐
│      Max(20)     │
└──────────────────┘

End

Aligns items to the end of the container.

Examples

<------------------------------------80 px------------------------------------->
                        ┌────16 px─────┐┌──────20 px───────┐┌──────20 px───────┐
                        │Percentage(20)││    Length(20)    ││     Length(20)   │
                        └──────────────┘└──────────────────┘└──────────────────┘

<------------------------------------80 px------------------------------------->
                                        ┌──────20 px───────┐┌──────20 px───────┐
                                        │      Max(20)     ││      Max(20)     │
                                        └──────────────────┘└──────────────────┘

<------------------------------------80 px------------------------------------->
                                                            ┌──────20 px───────┐
                                                            │      Max(20)     │
                                                            └──────────────────┘

Center

Centers items within the container.

Examples

<------------------------------------80 px------------------------------------->
            ┌────16 px─────┐┌──────20 px───────┐┌──────20 px───────┐
            │Percentage(20)││    Length(20)    ││     Length(20)   │
            └──────────────┘└──────────────────┘└──────────────────┘

<------------------------------------80 px------------------------------------->
                    ┌──────20 px───────┐┌──────20 px───────┐
                    │      Max(20)     ││      Max(20)     │
                    └──────────────────┘└──────────────────┘

<------------------------------------80 px------------------------------------->
                              ┌──────20 px───────┐
                              │      Max(20)     │
                              └──────────────────┘

SpaceBetween

Adds excess space between each element.

Examples

<------------------------------------80 px------------------------------------->
┌────16 px─────┐            ┌──────20 px───────┐            ┌──────20 px───────┐
│Percentage(20)│            │    Length(20)    │            │     Length(20)   │
└──────────────┘            └──────────────────┘            └──────────────────┘

<------------------------------------80 px------------------------------------->
┌──────20 px───────┐                                        ┌──────20 px───────┐
│      Max(20)     │                                        │      Max(20)     │
└──────────────────┘                                        └──────────────────┘

<------------------------------------80 px------------------------------------->
┌────────────────────────────────────80 px─────────────────────────────────────┐
│                                    Max(20)                                   │
└──────────────────────────────────────────────────────────────────────────────┘

SpaceEvenly

Evenly distributes excess space between all elements, including before the first and after the last.

Examples

<------------------------------------80 px------------------------------------->
      ┌────16 px─────┐      ┌──────20 px───────┐      ┌──────20 px───────┐
      │Percentage(20)│      │    Length(20)    │      │     Length(20)   │
      └──────────────┘      └──────────────────┘      └──────────────────┘

<------------------------------------80 px------------------------------------->
             ┌──────20 px───────┐              ┌──────20 px───────┐
             │      Max(20)     │              │      Max(20)     │
             └──────────────────┘              └──────────────────┘

<------------------------------------80 px------------------------------------->
                              ┌──────20 px───────┐
                              │      Max(20)     │
                              └──────────────────┘

SpaceAround

Adds excess space around each element.

Examples

<------------------------------------80 px------------------------------------->
    ┌────16 px─────┐       ┌──────20 px───────┐       ┌──────20 px───────┐
    │Percentage(20)│       │    Length(20)    │       │     Length(20)   │
    └──────────────┘       └──────────────────┘       └──────────────────┘

<------------------------------------80 px------------------------------------->
     ┌──────20 px───────┐                      ┌──────20 px───────┐
     │      Max(20)     │                      │      Max(20)     │
     └──────────────────┘                      └──────────────────┘

<------------------------------------80 px------------------------------------->
                              ┌──────20 px───────┐
                              │      Max(20)     │
                              └──────────────────┘

Implementations

impl Flex

pub const fn is_legacy(&self) -> bool

Returns true if the enum is Flex::Legacy otherwise false

pub const fn is_start(&self) -> bool

Returns true if the enum is Flex::Start otherwise false

pub const fn is_end(&self) -> bool

Returns true if the enum is Flex::End otherwise false

pub const fn is_center(&self) -> bool

Returns true if the enum is Flex::Center otherwise false

pub const fn is_space_between(&self) -> bool

Returns true if the enum is Flex::SpaceBetween otherwise false

pub const fn is_space_evenly(&self) -> bool

Returns true if the enum is Flex::SpaceEvenly otherwise false

pub const fn is_space_around(&self) -> bool

Returns true if the enum is Flex::SpaceAround otherwise false

Trait Implementations

impl Clone for Flex

fn clone(&self) -> Flex

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Flex

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Flex

fn default() -> Flex

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Flex

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Flex

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl FromStr for Flex

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Flex, <Self as FromStr>::Err>

Parses a string s to return a value of this type.

impl Hash for Flex

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Flex

fn eq(&self, other: &Flex) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Flex

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<&str> for Flex

type Error = ParseError

The type returned in the event of a conversion error.

fn try_from(s: &str) -> Result<Flex, <Self as TryFrom<&str>>::Error>

Performs the conversion.

impl Copy for Flex

impl Eq for Flex

impl StructuralPartialEq for Flex