Struct Size

#[repr(C)]
pub struct Size<N, Kind> {
    pub w: N,
    pub h: N,
    /* private fields */
}

A size as defined by its width and height

Constructors of this type ensure that the values are always positive via debug_assert!(), however manually changing the values of the fields can break this invariant.

Operations on sizes are saturating.

Fields

w: N

horizontal coordinate

h: N

vertical coordinate

Implementations

impl<N: Coordinate, Kind> Size<N, Kind>

pub fn new(w: N, h: N) -> Size<N, Kind>

Create a new Size

impl<N: Coordinate, Kind> Size<N, Kind>

pub fn to_point(self) -> Point<N, Kind>

Convert this Size to a Point with the same coordinates

impl<N: Coordinate, Kind> Size<N, Kind>

pub fn clamp( self, min: impl Into<Size<N, Kind>>, max: impl Into<Size<N, Kind>>, ) -> Size<N, Kind>

Restrict this Size to min and max Size with the same coordinates

impl<N: Coordinate, Kind> Size<N, Kind>

pub fn to_f64(self) -> Size<f64, Kind>

Convert the underlying numerical type to f64 for floating point manipulations

impl<N: Coordinate, Kind> Size<N, Kind>

pub fn upscale(self, scale: impl Into<Scale<N>>) -> Size<N, Kind>

Upscale this Size by a specified Scale

pub fn downscale(self, scale: impl Into<Scale<N>>) -> Size<N, Kind>

Downscale this Size by a specified Scale

pub fn is_empty(&self) -> bool

Check if this Size is empty

Returns true if either the width or the height is zero

impl<Kind> Size<f64, Kind>

pub fn to_i32_round<N: Coordinate>(self) -> Size<N, Kind>

Convert to i32 for integer-space manipulations by rounding float values

pub fn to_i32_floor<N: Coordinate>(self) -> Size<N, Kind>

Convert to i32 for integer-space manipulations by flooring float values

pub fn to_i32_ceil<N: Coordinate>(self) -> Size<N, Kind>

Convert to i32 for integer-space manipulations by ceiling float values

impl<N: Coordinate> Size<N, Logical>

pub fn to_physical(self, scale: impl Into<Scale<N>>) -> Size<N, Physical>

Convert this logical size to physical coordinate space according to given scale factor

pub fn to_physical_precise_round<S: Coordinate, R: Coordinate>( self, scale: impl Into<Scale<S>>, ) -> Size<R, Physical>

Convert this logical size to physical coordinate space according to given scale factor and round the result

pub fn to_physical_precise_ceil<S: Coordinate, R: Coordinate>( &self, scale: impl Into<Scale<S>>, ) -> Size<R, Physical>

Convert this logical size to physical coordinate space according to given scale factor and ceil the result

pub fn to_physical_precise_floor<S: Coordinate, R: Coordinate>( &self, scale: impl Into<Scale<S>>, ) -> Size<R, Physical>

Convert this logical size to physical coordinate space according to given scale factor and floor the result

pub fn to_buffer( self, scale: impl Into<Scale<N>>, transformation: Transform, ) -> Size<N, Buffer>

Convert this logical size to buffer coordinate space according to given scale factor

impl<N: Coordinate> Size<N, Physical>

pub fn to_logical(self, scale: impl Into<Scale<N>>) -> Size<N, Logical>

Convert this physical point to logical coordinate space according to given scale factor

impl<N: Coordinate> Size<N, Buffer>

pub fn to_logical( self, scale: impl Into<Scale<N>>, transformation: Transform, ) -> Size<N, Logical>

Convert this physical point to logical coordinate space according to given scale factor

Trait Implementations

impl<N: Coordinate, Kind> Add<Size<N, Kind>> for Point<N, Kind>

type Output = Point<N, Kind>

The resulting type after applying the + operator.

fn add(self, other: Size<N, Kind>) -> Point<N, Kind>

Performs the + operation.

impl<N: Coordinate, Kind> Add for Size<N, Kind>

type Output = Size<N, Kind>

The resulting type after applying the + operator.

fn add(self, other: Size<N, Kind>) -> Size<N, Kind>

Performs the + operation.

impl<N: Coordinate, Kind> AddAssign for Size<N, Kind>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<N: Clone, Kind> Clone for Size<N, Kind>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<N: Debug, S> Debug for Size<N, S>

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

Formats the value using the given formatter.

impl<N: Default, Kind> Default for Size<N, Kind>

fn default() -> Self

Returns the “default value” for a type.

impl<N: Coordinate + Div, Kind> Div<N> for Size<N, Kind>

type Output = Size<<N as Div>::Output, Kind>

The resulting type after applying the / operator.

fn div(self, rhs: N) -> Self::Output

Performs the / operation.

impl<N: Coordinate + Div<Output = N>, KindLhs, KindRhs> Div<Size<N, KindRhs>> for Size<N, KindLhs>

type Output = Scale<N>

The resulting type after applying the / operator.

fn div(self, rhs: Size<N, KindRhs>) -> Self::Output

Performs the / operation.

impl<N: Coordinate, Kind> From<(N, N)> for Size<N, Kind>

fn from((w, h): (N, N)) -> Size<N, Kind>

Converts to this type from the input type.

impl<N, Kind> From<Size<N, Kind>> for (N, N)

fn from(point: Size<N, Kind>) -> (N, N)

Converts to this type from the input type.

impl<N: Coordinate + Mul, Kind> Mul<N> for Size<N, Kind>

type Output = Size<<N as Mul>::Output, Kind>

The resulting type after applying the * operator.

fn mul(self, rhs: N) -> Self::Output

Performs the * operation.

impl<N: PartialEq, Kind> PartialEq for Size<N, Kind>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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<N: Coordinate, Kind> Sub<Size<N, Kind>> for Point<N, Kind>

type Output = Point<N, Kind>

The resulting type after applying the - operator.

fn sub(self, other: Size<N, Kind>) -> Point<N, Kind>

Performs the - operation.

impl<N: Coordinate, Kind> Sub for Size<N, Kind>

type Output = Size<N, Kind>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<N: Coordinate, Kind> SubAssign for Size<N, Kind>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<N: Copy, Kind> Copy for Size<N, Kind>

impl<N: Eq, Kind> Eq for Size<N, Kind>