Struct Size 

pub struct Size(pub i32, pub i32);

A 2D size, also known as an extent

This is both a size and a relative position. One can add or subtract a size from a Coord. One can multiply a size by a scalar.

A Size is expected to be non-negative; some methods such as Size::new and implementations of subtraction will check this, but only in debug mode (similar to overflow checks on integers).

Subtraction is defined to be saturating subtraction.

Size implements PartialOrd such that the comparison must be true of all components: for example a < b == a.0 < b.0 && a.1 < b.1. If c == Size(0, 1) and d == Size(1, 0) then c != d && !(c < d) && !(c > d). Size does not implement Ord.

This may be converted to Offset with from / into.

Tuple Fields

0: i32

1: i32

Implementations

impl Size

pub fn as_physical(self) -> Size

Convert to a “physical” winit::dpi::Size

This implies that the Size was calculated using the correct scale factor. Before the window has been constructed (when the scale factor is supposedly unknown) this should not be used.

impl Size

pub const ZERO: Self

The constant (0, 0)

pub const MIN: Self

The minimum value

pub const MAX: Self

The maximum value

pub fn min(self, other: Self) -> Self

Return the minimum, componentwise

pub fn max(self, other: Self) -> Self

Return the maximum, componentwise

pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to the specified interval, componentwise

pub fn transpose(self) -> Self

Return the transpose (swap x and y values)

pub fn cwise_mul(self, rhs: Self) -> Self

Return the result of component-wise multiplication

pub fn cwise_div(self, rhs: Self) -> Self

Return the result of component-wise division

pub fn distance_l1(self) -> i32

Return the L1 (rectilinear / taxicab) distance

pub fn distance_l_inf(self) -> i32

Return the L-inf (max) distance

pub fn extract<D: Directional>(self, dir: D) -> i32

Extract one component, based on a direction

This merely extracts the horizontal or vertical component. It never negates it, even if the axis is reversed.

pub fn set_component<D: Directional>(&mut self, dir: D, value: i32)

Set one component of self, based on a direction

This does not negate components when the direction is reversed.

impl Size

pub fn new(w: i32, h: i32) -> Self

Construct

In debug mode, this asserts that components are non-negative.

pub fn splat(n: i32) -> Self

Construct, using the same value on all axes

In debug mode, this asserts that components are non-negative.

pub fn aspect_scale_to(self, target: Size) -> Option<Size>

Scale to fit within the target size, keeping aspect ratio

If either dimension of self is 0, this returns None.

Trait Implementations

impl Add<Size> for Coord

type Output = Coord

The resulting type after applying the + operator.

fn add(self, other: Size) -> Self

Performs the + operation.

impl Add for Size

type Output = Size

The resulting type after applying the + operator.

fn add(self, other: Self) -> Self

Performs the + operation.

impl AddAssign<Size> for Coord

fn add_assign(&mut self, rhs: Size)

Performs the += operation.

impl AddAssign for Size

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl Clone for Size

fn clone(&self) -> Size

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Conv<(i32, i32)> for Size

fn conv(v: (i32, i32)) -> Self

Convert from T to Self

fn try_conv(v: (i32, i32)) -> Result<Self>

Try converting from T to Self

impl Conv<(u16, u16)> for Size

fn try_conv(v: (u16, u16)) -> Result<Self>

Try converting from T to Self

fn conv(v: T) -> Self

Convert from T to Self

impl Conv<(u32, u32)> for Size

fn try_conv(v: (u32, u32)) -> Result<Self>

Try converting from T to Self

fn conv(v: T) -> Self

Convert from T to Self

impl Conv<Offset> for Size

Convert an Offset into a Size

In debug mode this asserts that the result is non-negative.

fn try_conv(v: Offset) -> Result<Self>

Try converting from T to Self

fn conv(v: T) -> Self

Convert from T to Self

impl<X: Cast<i32>> Conv<PhysicalSize<X>> for Size

fn try_conv(size: PhysicalSize<X>) -> Result<Self>

Try converting from T to Self

fn conv(v: T) -> Self

Convert from T to Self

impl Conv<Size> for (u16, u16)

fn try_conv(size: Size) -> Result<Self>

Try converting from T to Self

fn conv(v: T) -> Self

Convert from T to Self

impl Conv<Size> for (u32, u32)

fn try_conv(size: Size) -> Result<Self>

Try converting from T to Self

fn conv(v: T) -> Self

Convert from T to Self

impl Conv<Size> for DVec2

fn try_conv(arg: Size) -> Result<Self>

Try converting from T to Self

fn conv(v: T) -> Self

Convert from T to Self

impl Conv<Size> for LogicalSize

fn try_conv(size: Size) -> Result<Self>

Try converting from T to Self

fn conv(v: T) -> Self

Convert from T to Self

impl Conv<Size> for Offset

fn try_conv(v: Size) -> Result<Self>

Try converting from T to Self

fn conv(v: T) -> Self

Convert from T to Self

impl Conv<Size> for Vec2

fn try_conv(arg: Size) -> Result<Self>

Try converting from T to Self

fn conv(v: T) -> Self

Convert from T to Self

impl Conv<Size> for Vec2

fn try_conv(size: Size) -> Result<Self>

Try converting from T to Self

fn conv(v: T) -> Self

Convert from T to Self

impl ConvApprox<DVec2> for Size

fn try_conv_approx(arg: DVec2) -> Result<Self>

Try converting from T to Self, allowing approximation of value

fn conv_approx(x: T) -> Self

Converting from T to Self, allowing approximation of value

impl ConvApprox<Vec2> for Size

fn try_conv_approx(arg: Vec2) -> Result<Self>

Try converting from T to Self, allowing approximation of value

fn conv_approx(x: T) -> Self

Converting from T to Self, allowing approximation of value

impl ConvFloat<DVec2> for Size

fn try_conv_trunc(x: DVec2) -> Result<Self>

Try converting to integer with truncation

fn try_conv_nearest(x: DVec2) -> Result<Self>

Try converting to the nearest integer

fn try_conv_floor(x: DVec2) -> Result<Self>

Try converting the floor to an integer

fn try_conv_ceil(x: DVec2) -> Result<Self>

Try convert the ceiling to an integer

fn conv_trunc(x: T) -> Self

Convert to integer with truncatation

fn conv_nearest(x: T) -> Self

Convert to the nearest integer

fn conv_floor(x: T) -> Self

Convert the floor to an integer

fn conv_ceil(x: T) -> Self

Convert the ceiling to an integer

impl ConvFloat<Vec2> for Size

fn try_conv_trunc(x: Vec2) -> Result<Self>

Try converting to integer with truncation

fn try_conv_nearest(x: Vec2) -> Result<Self>

Try converting to the nearest integer

fn try_conv_floor(x: Vec2) -> Result<Self>

Try converting the floor to an integer

fn try_conv_ceil(x: Vec2) -> Result<Self>

Try convert the ceiling to an integer

fn conv_trunc(x: T) -> Self

Convert to integer with truncatation

fn conv_nearest(x: T) -> Self

Convert to the nearest integer

fn conv_floor(x: T) -> Self

Convert the floor to an integer

fn conv_ceil(x: T) -> Self

Convert the ceiling to an integer

impl Debug for Size

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

Formats the value using the given formatter.

impl Default for Size

fn default() -> Size

Returns the “default value” for a type.

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

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Div<i32> for Size

Divide a Size by an integer

In debug mode this asserts that the result is non-negative.

type Output = Size

The resulting type after applying the / operator.

fn div(self, x: i32) -> Self

Performs the / operation.

impl From<(i32, i32)> for Size

fn from(v: (i32, i32)) -> Self

Converts to this type from the input type.

impl From<Size> for Margins

fn from(size: Size) -> Self

Converts to this type from the input type.

impl Hash for Size

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 Mul<i32> for Size

Multiply a Size by an integer

In debug mode this asserts that the result is non-negative.

type Output = Size

The resulting type after applying the * operator.

fn mul(self, x: i32) -> Self

Performs the * operation.

impl PartialEq for Size

fn eq(&self, other: &Size) -> 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 PartialOrd for Size

fn partial_cmp(&self, rhs: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, rhs: &Self) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, rhs: &Self) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn ge(&self, rhs: &Self) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

fn gt(&self, rhs: &Self) -> bool

Tests greater than (for self and other) and is used by the > operator.

impl Serialize for Size

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Sub<Size> for Coord

type Output = Coord

The resulting type after applying the - operator.

fn sub(self, other: Size) -> Self

Performs the - operation.

impl Sub for Size

Subtract a Size from a Size

This is saturating subtraction: Size::ZERO - Size::splat(6) == Size::ZERO.

type Output = Size

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign<Size> for Coord

fn sub_assign(&mut self, rhs: Size)

Performs the -= operation.

impl SubAssign for Size

Subtract a Size from a Size

This is saturating subtraction.

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl Copy for Size

impl Eq for Size

impl StructuralPartialEq for Size