Struct kas::geom::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.

This may be converted to Offset with from / into.

Tuple Fields

0: i32

1: i32

Implementations

impl Size

pub const ZERO: Size = _

The constant (0, 0)

pub const MIN: Size = _

The minimum value

pub const MAX: Size = _

The maximum value

pub fn lt(self, rhs: Size) -> bool

True when for all components, lhs < rhs

pub fn le(self, rhs: Size) -> bool

True when for all components, lhs ≤ rhs

pub fn ge(self, rhs: Size) -> bool

True when for all components, lhs ≥ rhs

pub fn gt(self, rhs: Size) -> bool

True when for all components, lhs > rhs

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

Return the minimum, componentwise

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

Return the maximum, componentwise

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

Restrict a value to the specified interval, componentwise

pub fn transpose(self) -> Size

Return the transpose (swap x and y values)

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

Return the result of component-wise multiplication

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

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>(self, dir: D) -> i32

where D: Directional,

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>(&mut self, dir: D, value: i32)

where D: Directional,

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

Construct

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

pub fn splat(n: i32) -> Size

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.

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.

pub fn as_logical(self) -> Size

Convert to a “logical” [winit::dpi::Size]

This implies that the Size was calculated using scale_factor = 1.

Trait Implementations

impl Add<Size> for Coord

type Output = Coord

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for Size

type Output = Size

The resulting type after applying the + operator.

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

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

Performs the += operation.

impl Clone for Size

fn clone(&self) -> Size

Returns a copy 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)) -> Size

Convert from T to Self

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

Try converting from T to Self

impl Conv<(u16, u16)> for Size

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

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<Size, Error>

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<Size, Error>

Try converting from T to Self

fn conv(v: T) -> Self

Convert from T to Self

impl<X> Conv<PhysicalSize<X>> for Size

where X: Cast<i32>,

fn try_conv(size: PhysicalSize<X>) -> Result<Size, Error>

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<(u16, u16), Error>

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<(u32, u32), Error>

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<DVec2, Error>

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<LogicalSize, Error>

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<Offset, Error>

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<Vec2, Error>

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<Vec2, Error>

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<Size, Error>

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<Size, Error>

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<Size, Error>

Try converting to integer with truncation

fn try_conv_nearest(x: DVec2) -> Result<Size, Error>

Try converting to the nearest integer

fn try_conv_floor(x: DVec2) -> Result<Size, Error>

Try converting the floor to an integer

fn try_conv_ceil(x: DVec2) -> Result<Size, Error>

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<Size, Error>

Try converting to integer with truncation

fn try_conv_nearest(x: Vec2) -> Result<Size, Error>

Try converting to the nearest integer

fn try_conv_floor(x: Vec2) -> Result<Size, Error>

Try converting the floor to an integer

fn try_conv_ceil(x: Vec2) -> Result<Size, Error>

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<(), Error>

Formats the value using the given formatter.

impl Default for Size

fn default() -> Size

Returns the “default value” for a type.

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

Performs the / operation.

impl From<(i32, i32)> for Size

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

Converts to this type from the input type.

impl From<Size> for Margins

fn from(size: Size) -> Margins

Converts to this type from the input type.

impl Hash for Size

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

Performs the * operation.

impl PartialEq for Size

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Sub<Size> for Coord

type Output = Coord

The resulting type after applying the - operator.

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

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

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

Performs the -= operation.

impl Copy for Size

impl Eq for Size

impl StructuralEq for Size

impl StructuralPartialEq for Size