Struct taffy::geometry::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

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

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_points(width: f32, height: f32) -> Self

Generates a Size<Dimension> using Dimension::Points 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::Points(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 both the width and height values are the constant fit_content value of the contained type (e.g. 2.1, Some(2.1), or Dimension::Points(2.1))

impl<T: FromPoints> Size<T>

pub fn points<Input: Into<f32> + Copy>(points_value: Input) -> Self

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

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::Points(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() -> Self

Returns the “default value” for a type.

impl From<Size<f32>> for SizeAndBaselines

fn from(size: Size<f32>) -> Self

Converts to this type from the input type.

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<T: FromPoints> FromPoints for Size<T>

fn from_points<Input: Into<f32> + Copy>(points: Input) -> Self

Converts into an Into<f32> into Self

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

fn eq(&self, other: &Size<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

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

const AUTO: Size<T> = _

The auto value for type implementing TaffyZero

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

fn fit_content(argument: LengthPercentage) -> Self

Converts into 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> StructuralEq for Size<T>

impl<T> StructuralPartialEq for Size<T>