Struct Size 

#[repr(C)]
pub struct Size<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: Clone + Debug + Default + PartialEq> Size<T>

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

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: &Self) -> Self

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: &Self) -> Self

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

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

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.

Trait Implementations

impl<T> Add for Size<T>

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

type Output = Size<T>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::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) -> Self

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 + Clone + Debug + Default + PartialEq> Clone for Size<T>

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

where T: Clone + Debug + Default + PartialEq,

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

Formats the value using the given formatter.

impl<T: Default + Clone + Debug + Default + PartialEq> 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> + Clone + Debug + Default + PartialEq,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Clone + Debug + Default + PartialEq + Display> Display for Size<T>

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

Formats the value using the given formatter.

impl<T, __RhsT: Copy> Div<__RhsT> for Size<T>

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

type Output = Size<T>

The resulting type after applying the / operator.

fn div(self, rhs: __RhsT) -> Size<T>

Performs the / operation.

impl<T: Clone + Debug + Default + PartialEq> From<Point<T>> for Size<T>

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

Converts to this type from the input type.

impl From<Size<DevicePixels>> for Size

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

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

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: TaffySize<T>) -> Self

Converts to this type from the input type.

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

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

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

Converts to this type from the input type.

impl From<Size2D<i32, UnknownUnit>> for Size<DevicePixels>

fn from(size: Size) -> Self

Converts to this type from the input type.

impl<T: Clone + Debug + Default + PartialEq> From<SizeRefinement<T>> for Size<T>

where Option<T>: Clone,

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

Converts to this type from the input type.

impl From<Vector2F> for Size<f32>

fn from(vec: Vector2F) -> Self

Converts to this type from the input type.

impl From<Vector2I> for Size<DevicePixels>

fn from(value: Vector2I) -> Self

Converts to this type from the input type.

impl<T: Hash + Clone + Debug + Default + PartialEq> Hash for Size<T>

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<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) -> Self::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: PartialEq + Clone + Debug + Default + 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<T: Clone + Debug + Default + PartialEq> Refineable for Size<T>

where Option<T>: Clone,

type Refinement = SizeRefinement<T>

fn refine(&mut self, refinement: &Self::Refinement)

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

fn refined(self, refinement: Self::Refinement) -> Self

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

fn is_superset_of(&self, refinement: &Self::Refinement) -> bool

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

fn subtract(&self, refinement: &Self::Refinement) -> Self::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: Serialize + Clone + Debug + Default + PartialEq,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Sub for Size<T>

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

type Output = Size<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: Copy + Clone + Debug + Default + PartialEq> Copy for Size<T>

impl<T> Eq for Size<T>

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

impl<T: Clone + Debug + Default + PartialEq> StructuralPartialEq for Size<T>