Struct Size 

#[repr(C)]
pub struct Size<T>
where
    T: Clone + Debug + Default + PartialEq,
{
    pub width: T,
    pub height: T,
}

A structure representing a two-dimensional size with width and height in a given unit.

This struct is generic over the type T, which can be any type that implements Clone, Default, and Debug. It is commonly used to specify dimensions for elements in a UI, such as a window or element.

Fields

width: T

The width component of the size.

height: T

The height component of the size.

Implementations

impl<T> Size<T>

where T: Clone + Debug + Default + PartialEq,

pub fn new(width: T, height: T) -> Size<T>

Create a new Size, a synonym for size

impl<T> Size<T>

where T: Clone + Debug + Default + PartialEq,

pub fn map<U>(&self, f: impl Fn(T) -> U) -> Size<U>

where U: Clone + Debug + Default + PartialEq,

Applies a function to the width and height of the size, producing a new Size<U>.

This method allows for converting a Size<T> to a Size<U> by specifying a closure that defines how to convert between the two types. The closure is applied to both the width and height, resulting in a new size of the desired type.

Arguments

• f - A closure that takes a value of type T and returns a value of type U.

Examples

let my_size = Size { width: 10, height: 20 };
let my_new_size = my_size.map(|dimension| dimension as f32 * 1.5);
assert_eq!(my_new_size, Size { width: 15.0, height: 30.0 });

impl<T> Size<T>

where T: Clone + Debug + Default + PartialEq + Half,

pub fn center(&self) -> Point<T>

Compute the center point of the size.g

impl Size<Pixels>

pub fn scale(&self, factor: f32) -> Size<ScaledPixels>

Scales the size by a given factor.

This method multiplies both the width and height by the provided scaling factor, resulting in a new Size<ScaledPixels> that is proportionally larger or smaller depending on the factor.

Arguments

• factor - The scaling factor to apply to the width and height.

Examples

let size = Size { width: Pixels::from(100.0), height: Pixels::from(50.0) };
let scaled_size = size.scale(2.0);
assert_eq!(scaled_size, Size { width: ScaledPixels::from(200.0), height: ScaledPixels::from(100.0) });

impl<T> Size<T>

where T: PartialOrd + Clone + Debug + Default + PartialEq,

pub fn max(&self, other: &Size<T>) -> Size<T>

Returns a new Size with the maximum width and height from self and other.

Arguments

• other - A reference to another Size to compare with self.

Examples

let size1 = Size { width: 30, height: 40 };
let size2 = Size { width: 50, height: 20 };
let max_size = size1.max(&size2);
assert_eq!(max_size, Size { width: 50, height: 40 });

pub fn min(&self, other: &Size<T>) -> Size<T>

Returns a new Size with the minimum width and height from self and other.

Arguments

• other - A reference to another Size to compare with self.

Examples

let size1 = Size { width: 30, height: 40 };
let size2 = Size { width: 50, height: 20 };
let min_size = size1.min(&size2);
assert_eq!(min_size, Size { width: 30, height: 20 });

impl Size<Length>

pub fn full() -> Size<Length>

Returns a Size with both width and height set to fill the available space.

This function creates a Size instance where both the width and height are set to Length::Definite(DefiniteLength::Fraction(1.0)), which represents 100% of the available space in both dimensions.

Returns

A Size<Length> that will fill the available space when used in a layout.

impl Size<Length>

pub fn auto() -> Size<Length>

Returns a Size with both width and height set to auto, which allows the layout engine to determine the size.

This function creates a Size instance where both the width and height are set to Length::Auto, indicating that their size should be computed based on the layout context, such as the content size or available space.

Returns

A Size<Length> with width and height set to Length::Auto.

impl Size<DevicePixels>

pub fn to_pixels(self, scale_factor: f32) -> Size<Pixels>

Converts the size from physical to logical pixels.

impl Size<Pixels>

pub fn to_device_pixels(self, scale_factor: f32) -> Size<DevicePixels>

Converts the size from logical to physical pixels.

Trait Implementations

impl<T> Add for Size<T>

where T: Clone + Debug + Default + PartialEq + Add<Output = T>,

type Output = Size<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T> Along for Size<T>

where T: Clone + Debug + Default + PartialEq,

fn apply_along(&self, axis: Axis, f: impl FnOnce(T) -> T) -> Size<T>

Returns the value of this size along the given axis.

type Unit = T

The unit associated with this type

fn along(&self, axis: Axis) -> T

Returns the unit along the given axis.

impl<T> Clone for Size<T>

where T: Clone + Debug + Default + PartialEq,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Copy for Size<T>

where T: Copy + Clone + Debug + Default + PartialEq,

impl<T> Debug for Size<T>

where T: Clone + Debug + Default + PartialEq,

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

Formats the value using the given formatter.

impl<T> Default for Size<T>

where T: Default + Clone + Debug + PartialEq,

fn default() -> Size<T>

Returns the “default value” for a type.

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

where T: Clone + Debug + Default + PartialEq + Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Display for Size<T>

where T: Clone + Debug + Default + PartialEq + Display,

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

Formats the value using the given formatter.

impl<T, __derive_more_Rhs> Div<__derive_more_Rhs> for Size<T>

where T: Clone + Debug + Default + PartialEq + Div<__derive_more_Rhs, Output = T>, __derive_more_Rhs: Copy,

type Output = Size<T>

The resulting type after applying the / operator.

fn div( self, __rhs: __derive_more_Rhs, ) -> <Size<T> as Div<__derive_more_Rhs>>::Output

Performs the / operation.

impl<T> Eq for Size<T>

where T: Eq + Clone + Debug + Default + PartialEq,

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

where T: Clone + Debug + Default + PartialEq,

fn from(point: Point<T>) -> Size<T>

Converts to this type from the input type.

impl From<Size<Pixels>> for Size<DefiniteLength>

fn from(size: Size<Pixels>) -> Size<DefiniteLength>

Converts to this type from the input type.

impl From<Size<Pixels>> for Size<AbsoluteLength>

fn from(size: Size<Pixels>) -> Size<AbsoluteLength>

Converts to this type from the input type.

impl From<Size<Pixels>> for Size<AvailableSpace>

fn from(size: Size<Pixels>) -> Size<AvailableSpace>

Converts to this type from the input type.

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

where T: Clone + Debug + Default + PartialEq,

fn from(size: Size<T>) -> Point<T>

Converts to this type from the input type.

impl<T, U> From<Size<T>> for Size<U>

where T: Into<U>, U: Clone + Debug + Default + PartialEq,

fn from(taffy_size: Size<T>) -> Size<U>

Converts to this type from the input type.

impl<T> From<SizeRefinement<T>> for Size<T>

where T: Clone + Debug + Default + PartialEq, Option<T>: Clone,

fn from(value: SizeRefinement<T>) -> Size<T>

Converts to this type from the input type.

impl<T> Hash for Size<T>

where T: Hash + Clone + Debug + Default + PartialEq,

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 Interpolate for Size<Pixels>

fn interpolate(&self, target: &Size<Pixels>, progress: f32) -> Size<Pixels>

impl<T> IsZero for Size<T>

where T: IsZero + Clone + Debug + Default + PartialEq,

fn is_zero(&self) -> bool

Determines if the value is zero.

impl<T, Rhs> Mul<Rhs> for Size<T>

where T: Mul<Rhs, Output = Rhs> + Clone + Debug + Default + PartialEq, Rhs: Clone + Debug + Default + PartialEq,

type Output = Size<Rhs>

The resulting type after applying the * operator.

fn mul(self, rhs: Rhs) -> <Size<T> as Mul<Rhs>>::Output

Performs the * operation.

impl<T, S> MulAssign<S> for Size<T>

where T: Mul<S, Output = T> + Clone + Debug + Default + PartialEq, S: Clone,

fn mul_assign(&mut self, rhs: S)

Performs the *= operation.

impl<T> Neg for Size<T>

where T: Clone + Debug + Default + PartialEq + Neg<Output = T>,

type Output = Size<T>

The resulting type after applying the - operator.

fn neg(self) -> Size<T>

Performs the unary - operation.

impl<T> PartialEq for Size<T>

where T: PartialEq + Clone + Debug + Default,

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

Equality operator ==.

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

Inequality operator !=.

impl<T> Refineable for Size<T>

where T: Clone + Debug + Default + PartialEq, Option<T>: Clone,

type Refinement = SizeRefinement<T>

fn refine(&mut self, refinement: &<Size<T> as Refineable>::Refinement)

Applies the given refinement to this instance, modifying it in place.

fn refined(self, refinement: <Size<T> as Refineable>::Refinement) -> Size<T>

Returns a new instance with the refinement applied, equivalent to cloning self and calling refine on it.

fn is_superset_of( &self, refinement: &<Size<T> as Refineable>::Refinement, ) -> bool

Returns true if this instance would contain all values from the refinement.

fn subtract( &self, refinement: &<Size<T> as Refineable>::Refinement, ) -> <Size<T> as Refineable>::Refinement

Returns a refinement that represents the difference between this instance and the given refinement.

fn from_cascade(cascade: &Cascade<Self>) -> Self

where Self: Sized + Default,

Creates an instance from a cascade by merging all refinements atop the default value.

impl<T> Serialize for Size<T>

where T: Clone + Debug + Default + PartialEq + Serialize,

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

where T: PartialEq + Clone + Debug + Default,

impl<T> Sub for Size<T>

where T: Clone + Debug + Default + PartialEq + Sub<Output = T>,

type Output = Size<T>

The resulting type after applying the - operator.

fn sub(self, __rhs: Size<T>) -> <Size<T> as Sub>::Output

Performs the - operation.