Enum Length 

pub enum Length {
    Points(f32),
    Percent(f32),
    ViewportWidth(f32),
    ViewportHeight(f32),
    Add(Box<Length>, Box<Length>),
    Subtract(Box<Length>, Box<Length>),
    Min(Vec<Length>),
    Max(Vec<Length>),
    Clamp {
        min: Box<Length>,
        preferred: Box<Length>,
        max: Box<Length>,
    },
    FitContent(Option<Box<Length>>),
    MinContent,
    MaxContent,
    Auto,
}

A declarative layout length resolved by the constraint engine.

Variants

Points(f32)

Fixed logical points.

Percent(f32)

Percentage of the containing axis. 50.0 means 50%, not 0.5.

ViewportWidth(f32)

Percentage of the active viewport width. 100.0 means full viewport width.

ViewportHeight(f32)

Percentage of the active viewport height. 100.0 means full viewport height.

Add(Box<Length>, Box<Length>)

Sum of two length expressions.

Subtract(Box<Length>, Box<Length>)

Difference between two length expressions.

Min(Vec<Length>)

Smallest value from a list of fully resolvable length expressions.

Max(Vec<Length>)

Largest value from a list of fully resolvable length expressions.

Clamp

Preferred value clamped between lower and upper bounds.

Fields

min: Box<Length>

Lower bound.

preferred: Box<Length>

Preferred value before clamping.

max: Box<Length>

Upper bound.

FitContent(Option<Box<Length>>)

Size to intrinsic content, optionally capped by a limit.

MinContent

Minimum intrinsic size required by the content.

MaxContent

Preferred intrinsic size of the content without wrapping.

Auto

Let the active layout algorithm choose the size.

Implementations

impl Length

pub fn points(value: f32) -> Length

Creates a fixed logical-point length.

pub fn percent(value: f32) -> Length

Creates a percentage of the containing axis.

pub fn vw(value: f32) -> Length

Creates a percentage of the viewport width.

pub fn vh(value: f32) -> Length

Creates a percentage of the viewport height.

pub fn clamp(min: Length, preferred: Length, max: Length) -> Length

Clamps a preferred length between lower and upper bounds.

pub fn min(values: impl Into<Vec<Length>>) -> Length

Selects the smallest fully resolved length.

pub fn max(values: impl Into<Vec<Length>>) -> Length

Selects the largest fully resolved length.

pub fn fit_content(limit: impl Into<Option<Length>>) -> Length

Sizes to content, optionally capped by a resolved limit.

pub fn all(value: Length) -> [Length; 4]

Creates [left, right, top, bottom] edges with one shared value.

pub fn symmetric(horizontal: Length, vertical: Length) -> [Length; 4]

Creates [left, right, top, bottom] edges from axis values.

pub fn resolve( &self, reference: f32, viewport_width: f32, viewport_height: f32, ) -> Option<f32>

Resolves a numeric length against one axis and the active viewport.

Intrinsic and automatic lengths return None because they require a layout measurement rather than arithmetic resolution.

Trait Implementations

impl Add for Length

type Output = Length

The resulting type after applying the + operator.

fn add(self, rhs: Length) -> <Length as Add>::Output

Performs the + operation.

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<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Length

fn deserialize<__D>( __deserializer: __D, ) -> Result<Length, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<f32> for Length

fn from(value: f32) -> Length

Converts to this type from the input type.

impl Hash for Length

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

where H: Hasher,

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 Length

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Length

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Length

impl Sub for Length

type Output = Length

The resulting type after applying the - operator.

fn sub(self, rhs: Length) -> <Length as Sub>::Output

Performs the - operation.