Enum DimensionValue

pub enum DimensionValue {
    Fixed(Px),
    Wrap {
        min: Option<Px>,
        max: Option<Px>,
    },
    Fill {
        min: Option<Px>,
        max: Option<Px>,
    },
}

Defines how a dimension (width or height) should be calculated.

This enum represents the three fundamental sizing strategies available in Tessera’s layout system. Each variant provides different behavior for how a component determines its size in a given dimension.

Variants

Fixed(Px)

The dimension is a fixed value in logical pixels.

This variant represents a component that has a specific, unchanging size. Fixed dimensions cannot be overridden by parent constraints and will always maintain their specified size regardless of available space.

Example

let button_width = DimensionValue::Fixed(Px(120));

Wrap

The dimension should wrap its content, optionally bounded by min and/or max logical pixels.

This variant represents a component that sizes itself based on its content. The component will be as small as possible while still containing all its content, but can be constrained by optional minimum and maximum bounds.

Parameters

• min: Optional minimum size - the component will never be smaller than this
• max: Optional maximum size - the component will never be larger than this

Examples

// Text that wraps to its content size
let text_width = DimensionValue::Wrap { min: None, max: None };

// Text with minimum width to prevent being too narrow
let min_text_width = DimensionValue::Wrap { min: Some(Px(100)), max: None };

// Text that wraps but never exceeds container width
let bounded_text = DimensionValue::Wrap { min: Some(Px(50)), max: Some(Px(300)) };

Fields

min: Option<Px>

max: Option<Px>

Fill

The dimension should fill the available space, optionally bounded by min and/or max logical pixels.

This variant represents a component that expands to use all available space provided by its parent. The expansion can be constrained by optional minimum and maximum bounds.

Parameters

• min: Optional minimum size - the component will never be smaller than this
• max: Optional maximum size - the component will never be larger than this

Examples

// Fill all available space
let flexible_width = DimensionValue::Fill { min: None, max: None };

// Fill space but ensure minimum usability
let min_fill_width = DimensionValue::Fill { min: Some(Px(200)), max: None };

// Fill space but cap maximum size for readability
let capped_fill = DimensionValue::Fill { min: Some(Px(100)), max: Some(Px(800)) };

Fields

min: Option<Px>

max: Option<Px>

Implementations

impl DimensionValue

pub const ZERO: Self

Zero-sized dimension, equivalent to Fixed(Px(0)).

pub const FILLED: Self

Fill with no constraints.

pub const WRAP: Self

Wrap with no constraints.

impl DimensionValue

pub fn to_max_px(&self, default: Px) -> Px

Converts this dimension value to a maximum pixel value.

This method is useful during layout calculation when you need to determine the maximum space a component might occupy.

Parameters

• default: The value to use when no maximum is specified

Returns

• For Fixed: Returns the fixed value
• For Wrap and Fill: Returns the max value if specified, otherwise the default

Example

let fixed = DimensionValue::Fixed(Px(100));
assert_eq!(fixed.to_max_px(Px(200)), Px(100));

let wrap_unbounded = DimensionValue::Wrap { min: None, max: None };
assert_eq!(wrap_unbounded.to_max_px(Px(200)), Px(200));

let wrap_bounded = DimensionValue::Wrap { min: None, max: Some(Px(150)) };
assert_eq!(wrap_bounded.to_max_px(Px(200)), Px(150));

pub fn get_max(&self) -> Option<Px>

Returns the maximum value of this dimension, if defined.

This method extracts the maximum constraint from a dimension value, which is useful for layout calculations and constraint validation.

Returns

• For Fixed: Returns Some(fixed_value) since fixed dimensions have an implicit maximum
• For Wrap and Fill: Returns the max value if specified, otherwise None

Example

let fixed = DimensionValue::Fixed(Px(100));
assert_eq!(fixed.get_max(), Some(Px(100)));

let wrap_bounded = DimensionValue::Wrap { min: Some(Px(50)), max: Some(Px(200)) };
assert_eq!(wrap_bounded.get_max(), Some(Px(200)));

let wrap_unbounded = DimensionValue::Wrap { min: None, max: None };
assert_eq!(wrap_unbounded.get_max(), None);

pub fn get_min(&self) -> Option<Px>

Returns the minimum value of this dimension, if defined.

This method extracts the minimum constraint from a dimension value, which is useful for layout calculations and ensuring components maintain their minimum required size.

Returns

• For Fixed: Returns Some(fixed_value) since fixed dimensions have an implicit minimum
• For Wrap and Fill: Returns the min value if specified, otherwise None

Example

let fixed = DimensionValue::Fixed(Px(100));
assert_eq!(fixed.get_min(), Some(Px(100)));

let fill_bounded = DimensionValue::Fill { min: Some(Px(50)), max: Some(Px(200)) };
assert_eq!(fill_bounded.get_min(), Some(Px(50)));

let fill_unbounded = DimensionValue::Fill { min: None, max: None };
assert_eq!(fill_unbounded.get_min(), None);

Trait Implementations

impl Add<Px> for DimensionValue

type Output = DimensionValue

The resulting type after applying the + operator.

fn add(self, rhs: Px) -> Self::Output

Performs the + operation.

impl AddAssign<Px> for DimensionValue

fn add_assign(&mut self, rhs: Px)

Performs the += operation.

impl Clone for DimensionValue

fn clone(&self) -> DimensionValue

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DimensionValue

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

Formats the value using the given formatter.

impl Default for DimensionValue

fn default() -> Self

Returns the default dimension value: Wrap { min: None, max: None }.

This default represents a component that sizes itself to its content without any constraints, which is the most flexible and commonly used sizing behavior.

impl From<Dp> for DimensionValue

fn from(value: Dp) -> Self

Converts a Dp value to a DimensionValue::Fixed.

impl From<Px> for DimensionValue

fn from(value: Px) -> Self

Converts a Px value to a DimensionValue::Fixed.

impl Hash for DimensionValue

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 DimensionValue

fn eq(&self, other: &DimensionValue) -> 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 Sub<Px> for DimensionValue

type Output = DimensionValue

The resulting type after applying the - operator.

fn sub(self, rhs: Px) -> Self::Output

Performs the - operation.

impl SubAssign<Px> for DimensionValue

fn sub_assign(&mut self, rhs: Px)

Performs the -= operation.

impl Copy for DimensionValue

impl Eq for DimensionValue

impl StructuralPartialEq for DimensionValue