Struct embedded_graphics::geometry::Size

pub struct Size {
    pub width: u32,
    pub height: u32,
}

2D size.

Size is used to define the width and height of an object.

Nalgebra support can be enabled with the nalgebra_support feature. This implements From<Vector2<N>> and From<&Vector2<N>> where N is Scalar + Into<u32>. This allows use of Nalgebra’s Vector2 with embedded-graphics where u32, u16 or u8 is used for value storage.

Examples

Create a Size from two integers

use embedded_graphics::geometry::Size;

// Create a size using the `new` constructor method
let s = Size::new(10, 20);

Create a Size from a Nalgebra Vector2

Be sure to enable the nalgebra_support feature to get Nalgebra integration.

Any Vector2<N> can be used where N: Into<u32> + nalgebra::Scalar. This includes the primitive types u32, u16 and u8.

use embedded_graphics::geometry::Size;
use nalgebra::Vector2;

assert_eq!(Size::from(Vector2::new(10u32, 20)), Size::new(10u32, 20));
assert_eq!(Size::from(Vector2::new(10u16, 20)), Size::new(10u32, 20));
assert_eq!(Size::from(Vector2::new(10u8, 20)), Size::new(10u32, 20));

.into() can also be used, but may require more type annotations:

use embedded_graphics::geometry::Size;
use nalgebra::Vector2;

let c: Size = Vector2::new(10u32, 20).into();

assert_eq!(c, Size::new(10u32, 20));

Fields

width: u32

The width.

height: u32

The height.

Implementations

impl Size

pub const fn new(width: u32, height: u32) -> Size

Creates a size from a width and a height.

pub const fn new_equal(value: u32) -> Size

Creates a size with width and height set to an equal value.

use embedded_graphics::geometry::Size;

let size = Size::new_equal(11);

assert_eq!(
    size,
    Size {
        width: 11,
        height: 11
    }
);

pub const fn zero() -> Size

Creates a size with width and height equal to zero.

pub const fn x_axis(self) -> Size

Returns a size with equal width value and height set to 0.

Examples

Move a Point along the X axis.

use embedded_graphics::geometry::{Point, Size};

let size = Size::new(20, 30);

let point = Point::new(10, 15);

let moved_x = point + size.x_axis();

assert_eq!(moved_x, Point::new(30, 15));

pub const fn y_axis(self) -> Size

Returns a size with equal height value and width set to 0.

Examples

Move a Point along the Y axis.

use embedded_graphics::geometry::{Point, Size};

let size = Size::new(20, 30);

let point = Point::new(10, 15);

let moved_y = point + size.y_axis();

assert_eq!(moved_y, Point::new(10, 45));

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

Saturating addition.

Returns u32::max_value() for width and/or height instead of overflowing.

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

Saturating subtraction.

Returns 0 for width and/or height instead of overflowing, if the value in other is larger then in self.

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

Returns the componentwise minimum of two Sizes.

use embedded_graphics::geometry::Size;

let min = Size::new(20, 30).component_min(Size::new(15, 50));

assert_eq!(min, Size::new(15, 30));

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

Returns the componentwise maximum of two Sizes.

use embedded_graphics::geometry::Size;

let min = Size::new(20, 30).component_max(Size::new(15, 50));

assert_eq!(min, Size::new(20, 50));

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

Returns the componentwise multiplication of two Sizes.

use embedded_graphics::geometry::Size;

let result = Size::new(20, 30).component_mul(Size::new(2, 3));

assert_eq!(result, Size::new(40, 90));

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

Returns the componentwise division of two Sizes.

Panics

Panics if one of the components of other equals zero.

use embedded_graphics::geometry::Size;

let result = Size::new(20, 30).component_div(Size::new(5, 10));

assert_eq!(result, Size::new(4, 3));

Trait Implementations

impl Add<Size> for Size

type Output = Size

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Size> for Point

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

Offsets a point by adding a size.

Panics

This function will panic if width or height are too large to be represented as an i32 and debug assertions are enabled.

type Output = Point

The resulting type after applying the + operator.

impl AddAssign<Size> for Point

pub fn add_assign(&mut self, other: Size)

Offsets a point by adding a size.

Panics

This function will panic if width or height are too large to be represented as an i32 and debug assertions are enabled.

impl AddAssign<Size> for Size

pub fn add_assign(&mut self, other: Size)

Performs the += operation.

impl Clone for Size

pub fn clone(&self) -> Size

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Size

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

Formats the value using the given formatter.

impl Default for Size

pub fn default() -> Size

Returns the “default value” for a type.

impl Div<u32> for Size

type Output = Size

The resulting type after applying the / operator.

pub fn div(self, rhs: u32) -> Size

Performs the / operation.

impl DivAssign<u32> for Size

pub fn div_assign(&mut self, rhs: u32)

Performs the /= operation.

impl<'_> From<&'_ [u32; 2]> for Size

pub fn from(other: &[u32; 2]) -> Size

Performs the conversion.

impl<'_, N> From<&'_ Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>> for Size where
    N: Into<u32> + Scalar + Copy, 

pub fn from(
    other: &Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
) -> Size

Performs the conversion.

impl From<[u32; 2]> for Size

pub fn from(other: [u32; 2]) -> Size

Performs the conversion.

impl From<(u32, u32)> for Size

pub fn from(other: (u32, u32)) -> Size

Performs the conversion.

impl<N> From<Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>> for Size where
    N: Into<u32> + Scalar + Copy, 

pub fn from(
    other: Matrix<N, U2, U1, <DefaultAllocator as Allocator<N, U2, U1>>::Buffer>
) -> Size

Performs the conversion.

impl Hash for Size

pub 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, 

Feeds a slice of this type into the given Hasher.

impl Index<usize> for Size

type Output = u32

The returned type after indexing.

pub fn index(&self, idx: usize) -> &u32

Performs the indexing (container[index]) operation.

impl Mul<u32> for Size

type Output = Size

The resulting type after applying the * operator.

pub fn mul(self, rhs: u32) -> Size

Performs the * operation.

impl MulAssign<u32> for Size

pub fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl Ord for Size

pub fn cmp(&self, other: &Size) -> Ordering

This method returns an Ordering between self and other.

#[must_use]

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

Compares and returns the maximum of two values.

#[must_use]

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

Compares and returns the minimum of two values.

#[must_use]

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

Restrict a value to a certain interval.

impl PartialEq<Size> for Size

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

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

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

This method tests for !=.

impl PartialOrd<Size> for Size

pub fn partial_cmp(&self, other: &Size) -> Option<Ordering>

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

#[must_use]

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

This method tests less than (for self and other) and is used by the < operator.

#[must_use]

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

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

#[must_use]

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

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]

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

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

impl Sub<Size> for Size

type Output = Size

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Size> for Point

pub fn sub(self, other: Size) -> Point

Offsets a point by subtracting a size.

Panics

This function will panic if width or height are too large to be represented as an i32 and debug assertions are enabled.

type Output = Point

The resulting type after applying the - operator.

impl SubAssign<Size> for Size

pub fn sub_assign(&mut self, other: Size)

Performs the -= operation.

impl SubAssign<Size> for Point

pub fn sub_assign(&mut self, other: Size)

Offsets a point by subtracting a size.

Panics

This function will panic if width or height are too large to be represented as an i32 and debug assertions are enabled.

impl Copy for Size

impl Eq for Size

impl StructuralEq for Size

impl StructuralPartialEq for Size