Struct Size

pub struct Size<T> {
    pub width: T,
    pub height: T,
}

The width and height of a Rect

Fields

width: T

The x extent of the rectangle

height: T

The y extent of the rectangle

Implementations

impl<T> Size<T>

pub fn get_abs(self, axis: AbsoluteAxis) -> T

Get either the width or height depending on the AbsoluteAxis passed in

impl<T> Size<T>

pub fn map<R, F>(self, f: F) -> Size<R>

where F: Fn(T) -> R,

Applies the function f to both the width and height

This is used to transform a Size<T> into a Size<R>.

pub fn map_width<F>(self, f: F) -> Size<T>

where F: Fn(T) -> T,

Applies the function f to the width

pub fn map_height<F>(self, f: F) -> Size<T>

where F: Fn(T) -> T,

Applies the function f to the height

pub fn zip_map<Other, Ret, Func>(self, other: Size<Other>, f: Func) -> Size<Ret>

where Func: Fn(T, Other) -> Ret,

Applies the function f to both the width and height of this value and another passed value

pub(crate) fn get(self, axis: AbstractAxis) -> T

Gets the extent of the specified layout axis Whether this is the width or height depends on the GridAxis provided

pub(crate) fn set(&mut self, axis: AbstractAxis, value: T)

Sets the extent of the specified layout axis Whether this is the width or height depends on the GridAxis provided

impl Size<f32>

pub const ZERO: Size<f32>

A Size with zero width and height

pub fn f32_max(self, rhs: Size<f32>) -> Size<f32>

Applies f32_max to each component separately

pub fn f32_min(self, rhs: Size<f32>) -> Size<f32>

Applies f32_min to each component separately

pub fn has_non_zero_area(self) -> bool

Return true if both width and height are greater than 0 else false

impl Size<Option<f32>>

pub const NONE: Size<Option<f32>>

A Size with None width and height

pub const fn new(width: f32, height: f32) -> Self

A Size<Option<f32>> with Some(width) and Some(height) as parameters

pub fn maybe_apply_aspect_ratio( self, aspect_ratio: Option<f32>, ) -> Size<Option<f32>>

Applies aspect_ratio (if one is supplied) to the Size:

• If width is Some but height is None, then height is computed from width and aspect_ratio
• If height is Some but width is None, then width is computed from height and aspect_ratio

If aspect_ratio is None then this function simply returns self.

impl<T> Size<Option<T>>

pub fn unwrap_or(self, alt: Size<T>) -> Size<T>

Performs Option::unwrap_or on each component separately

pub fn or(self, alt: Size<Option<T>>) -> Size<Option<T>>

Performs Option::or on each component separately

pub fn both_axis_defined(&self) -> bool

Return true if both components are Some, else false.

impl Size<Dimension>

pub const fn from_lengths(width: f32, height: f32) -> Self

Generates a Size<Dimension> using Dimension::Length values

pub const fn from_percent(width: f32, height: f32) -> Self

Generates a Size<Dimension> using Dimension::Percent values

impl Size<AvailableSpace>

pub fn into_options(self) -> Size<Option<f32>>

Convert Size<AvailableSpace> into Size<Option<f32>>

pub fn maybe_set(self, value: Size<Option<f32>>) -> Size<AvailableSpace>

If passed value is Some then return AvailableSpace::Definite containing that value, else return self

impl<T: TaffyZero> Size<T>

pub const fn zero() -> Self

Returns a Size where both the width and height values are the zero value of the contained type (e.g. 0.0, Some(0.0), or Dimension::Length(0.0))

impl<T: TaffyAuto> Size<T>

pub const fn auto() -> Self

Returns a Size where both the width and height values are the auto value of the contained type (e.g. Dimension::Auto or LengthPercentageAuto::Auto)

impl<T: TaffyMinContent> Size<T>

pub const fn min_content() -> Self

Returns a Size where both the width and height values are the min_content value of the contained type (e.g. Dimension::Auto or LengthPercentageAuto::Auto)

impl<T: TaffyMaxContent> Size<T>

pub const fn max_content() -> Self

Returns a Size where both the width and height values are the max_content value of the contained type (e.g. Dimension::Auto or LengthPercentageAuto::Auto)

impl<T: TaffyFitContent> Size<T>

pub fn fit_content(argument: LengthPercentage) -> Self

Returns a Size where with width and height set to the same fit-content(…) value with the given argument.

impl<T: FromLength> Size<T>

pub fn length<Input: Into<f32> + Copy>(value: Input) -> Self

Returns a Size where both the width and height values the same given absolute length

impl<T: FromPercent> Size<T>

pub fn percent<Input: Into<f32> + Copy>(percent_value: Input) -> Self

Returns a Size where both the width and height values are the constant percent value of the contained type (e.g. 2.1, Some(2.1), or Dimension::Length(2.1))

Trait Implementations

impl<U, T: Add<U>> Add<Size<U>> for Size<T>

type Output = Size<<T as Add<U>>::Output>

The resulting type after applying the + operator.

fn add(self, rhs: Size<U>) -> Self::Output

Performs the + operation.

impl<T: Clone> Clone for Size<T>

fn clone(&self) -> Size<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Size<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Size<T>

fn default() -> Size<T>

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for Size<T>

where T: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> From<Point<T>> for Size<T>

fn from(value: Point<T>) -> Self

Converts to this type from the input type.

impl<T: FromLength> FromLength for Size<T>

fn from_length<Input: Into<f32> + Copy>(value: Input) -> Self

Converts into an Into<f32> into Self

impl<T: FromPercent> FromPercent for Size<T>

fn from_percent<Input: Into<f32> + Copy>(percent: Input) -> Self

Converts into an Into<f32> into Self

impl<In, Out, T: MaybeMath<In, Out>> MaybeMath<Size<In>, Size<Out>> for Size<T>

fn maybe_min(self, rhs: Size<In>) -> Size<Out>

Returns the minimum of self and rhs

fn maybe_max(self, rhs: Size<In>) -> Size<Out>

Returns the maximum of self and rhs

fn maybe_clamp(self, min: Size<In>, max: Size<In>) -> Size<Out>

Returns self clamped between min and max

fn maybe_add(self, rhs: Size<In>) -> Size<Out>

Adds self and rhs.

fn maybe_sub(self, rhs: Size<In>) -> Size<Out>

Subtracts rhs from self, treating None values as default

impl<In, Out, T: MaybeResolve<In, Out>> MaybeResolve<Size<In>, Size<Out>> for Size<T>

fn maybe_resolve(self, context: Size<In>) -> Size<Out>

Converts any parent-relative values for size into an absolute size

impl<T: PartialEq> PartialEq for Size<T>

fn eq(&self, other: &Size<T>) -> 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<In: Copy, Out: TaffyZero, T: ResolveOrZero<In, Out>> ResolveOrZero<Size<In>, Rect<Out>> for Rect<T>

fn resolve_or_zero(self, context: Size<In>) -> Rect<Out>

Converts any parent-relative values for Rect into an absolute Rect

impl<In, Out: TaffyZero, T: ResolveOrZero<In, Out>> ResolveOrZero<Size<In>, Size<Out>> for Size<T>

fn resolve_or_zero(self, context: Size<In>) -> Size<Out>

Converts any parent-relative values for size into an absolute size

impl<T> Serialize for Size<T>

where T: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<U, T: Sub<U>> Sub<Size<U>> for Size<T>

type Output = Size<<T as Sub<U>>::Output>

The resulting type after applying the - operator.

fn sub(self, rhs: Size<U>) -> Self::Output

Performs the - operation.

impl<T: TaffyAuto> TaffyAuto for Size<T>

const AUTO: Size<T>

The auto value for type implementing TaffyAuto

impl<T: TaffyFitContent> TaffyFitContent for Size<T>

fn fit_content(argument: LengthPercentage) -> Self

Converts a LengthPercentage into Self

impl<T: TaffyMaxContent> TaffyMaxContent for Size<T>

const MAX_CONTENT: Size<T>

The max_content value for type implementing TaffyZero

impl<T: TaffyMinContent> TaffyMinContent for Size<T>

const MIN_CONTENT: Size<T>

The min_content value for type implementing TaffyZero

impl<T: TaffyZero> TaffyZero for Size<T>

const ZERO: Size<T>

The zero value for type implementing TaffyZero

impl<T: Copy> Copy for Size<T>

impl<T: Eq> Eq for Size<T>

impl<T> StructuralPartialEq for Size<T>