Enum Length 

pub enum Length {
    Fit,
    Fill,
    FillPortion(u16),
    Shrink,
    Fixed(f32),
    Bounded {
        bounds: Bounds,
        sizing: Sizing,
    },
    Fluid(Constraint),
}

The strategy used to fill space in a specific dimension.

Variants

Fit

Fill the minimum amount of space based on the intrinsic size of the element; normally defined by its contents.

This is the default sizing strategy of most widgets.

Fill

Fill all the remaining space.

FillPortion(u16)

Fill a portion of the remaining space relative to other elements.

Let’s say we have two elements: one with FillPortion(2) and one with FillPortion(3). The first will get 2 portions of the available space, while the second one would get 3.

Length::Fill is equivalent to Length::FillPortion(1).

Shrink

Fill the least amount of space; compressing contents if possible.

Fixed(f32)

Fill a fixed amount of space in pixels.

Bounded

Fill a certain amount of space inside the given Bounds with some Sizing strategy.

Fields

bounds: Bounds

The Bounds of space that can be filled.

sizing: Sizing

The Sizing strategy with which the Bounds should be filled.

Fluid(Constraint)

Fill the remaining space like Fill, but subject to a single open-ended Constraint.

Implementations

impl Length

pub fn min(self, min: impl Into<Pixels>) -> Self

Returns a new Bounded length with the given minimum bounds.

pub fn max(self, max: impl Into<Pixels>) -> Self

Returns a new Bounded length with the given maximum bounds.

pub fn fill_factor(&self) -> u16

Returns the fill factor of the Length.

The fill factor is a relative unit describing how much of the remaining space should be filled when compared to other elements. It is only meant to be used by layout engines.

pub fn is_fill(&self) -> bool

Returns true if the Length is either Length::Fill or Length::FillPortion.

pub fn is_fit(&self) -> bool

Returns true if the Length is Fit.

pub fn stack(self, other: Length) -> Self

Stacks the constraints of the current Length with the given one, if applicable.

Specifically, minimum constraints will be added together and accumulated.

You should use this when a container lays out multiple elements along a given axis and need to inherit their constraints in the main axis.

pub fn cross(self, other: Length) -> Self

Crosses the constraints of the current Length with the given one, if applicable.

Specifically, minimum constraints will be compared and the maximum will be returned.

You should use this when a container lays out multiple elements along a given axis and need to inherit their constraints in the cross axis.

Trait Implementations

impl Clone for Length

fn clone(&self) -> Length

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Length

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

Formats the value using the given formatter.

impl From<Pixels> for Length

fn from(amount: Pixels) -> Self

Converts to this type from the input type.

impl From<f32> for Length

fn from(amount: f32) -> Self

Converts to this type from the input type.

impl From<u32> for Length

fn from(units: u32) -> Self

Converts to this type from the input type.

impl PartialEq for Length

fn eq(&self, other: &Length) -> 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 Copy for Length

impl StructuralPartialEq for Length