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

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) -> Size<Option<f32>>

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) -> Size<Dimension>

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

pub const fn from_percent(width: f32, height: f32) -> Size<Dimension>

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> Size<T>

where T: TaffyZero,

pub const fn zero() -> Size<T>

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> Size<T>

where T: TaffyAuto,

pub const fn auto() -> Size<T>

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> Size<T>

where T: TaffyMinContent,

pub const fn min_content() -> Size<T>

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> Size<T>

where T: TaffyMaxContent,

pub const fn max_content() -> Size<T>

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> Size<T>

where T: TaffyFitContent,

pub fn fit_content(argument: LengthPercentage) -> Size<T>

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> Size<T>

where T: FromPoints,

pub fn points<Input>(points_value: Input) -> Size<T>

where Input: Into<f32> + Copy,

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> Size<T>

where T: FromPercent,

pub fn percent<Input>(percent_value: Input) -> Size<T>

where Input: Into<f32> + Copy,

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<Size<U>> for Size<T>

where T: Add<U>,

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

The resulting type after applying the + operator.

fn add(self, rhs: Size<U>) -> <Size<T> as Add<Size<U>>>::Output

Performs the + operation.

impl<T> Clone for Size<T>

where T: Clone,

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

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for Size<T>

where T: Default,

fn default() -> Size<T>

Returns the “default value” for a type.

impl<T> FromPercent for Size<T>

where T: FromPercent,

fn from_percent<Input>(percent: Input) -> Size<T>

where Input: Into<f32> + Copy,

Converts into an Into<f32> into Self

impl<T> FromPoints for Size<T>

where T: FromPoints,

fn from_points<Input>(points: Input) -> Size<T>

where Input: Into<f32> + Copy,

Converts into an Into<f32> into Self

impl<T> PartialEq for Size<T>

where T: PartialEq,

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<T> TaffyAuto for Size<T>

where T: TaffyAuto,

const AUTO: Size<T>

The auto value for type implementing TaffyZero

impl<T> TaffyFitContent for Size<T>

where T: TaffyFitContent,

fn fit_content(argument: LengthPercentage) -> Size<T>

Converts into a LengthPercentage into Self

impl<T> TaffyMaxContent for Size<T>

where T: TaffyMaxContent,

const MAX_CONTENT: Size<T>

The max_content value for type implementing TaffyZero

impl<T> TaffyMinContent for Size<T>

where T: TaffyMinContent,

const MIN_CONTENT: Size<T>

The min_content value for type implementing TaffyZero

impl<T> TaffyZero for Size<T>

where T: TaffyZero,

const ZERO: Size<T>

The zero value for type implementing TaffyZero

impl<T> Copy for Size<T>

where T: Copy,

impl<T> Eq for Size<T>

where T: Eq,

impl<T> StructuralPartialEq for Size<T>