Struct Size 

pub struct Size { /* private fields */ }

Holds a 2D floating-point size.

You can think of this as an Offset from the origin.

Implementations

impl Size

pub const ZERO: Size

An empty size, one with a zero width and a zero height.

pub const INFINITE: Size

A size whose width and height are infinite.

See also:

• is_infinite, which checks whether either dimension is infinite.
• is_finite, which checks whether both dimensions are finite.

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

Creates a Size with the given width and height.

pub const fn square(dimension: f64) -> Size

Creates a square Size whose width and height are the given dimension.

See also:

• from_radius, which is more convenient when the available size is the radius of a circle.

pub const fn from_width(width: f64) -> Size

Creates a Size with the given width and an infinite height.

pub const fn from_height(height: f64) -> Size

Creates a Size with the given height and an infinite width.

pub const fn from_radius(radius: f64) -> Size

Creates a square Size whose width and height are twice the given dimension.

This is a square that contains a circle with the given radius.

See also:

• square, which creates a square with the given dimension.

pub const fn width(&self) -> f64

The horizontal extent of this size.

pub const fn height(&self) -> f64

The vertical extent of this size.

pub fn is_infinite(&self) -> bool

Returns true if either component is f64::INFINITY, and false if both are finite (or negative infinity, or NaN).

This is different than comparing for equality with an instance that has both components set to f64::INFINITY.

See also:

• is_finite, which is true if both components are finite (and not NaN).

pub fn is_finite(&self) -> bool

Whether both components are finite (neither infinite nor NaN).

See also:

• is_infinite, which returns true if either component is equal to positive infinity.

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

Less-than operator. Compares an Offset or Size to another Offset or Size, and returns true if both the horizontal and vertical values of the left-hand-side operand are smaller than the horizontal and vertical values of the right-hand-side operand respectively. Returns false otherwise.

This is a partial ordering. It is possible for two values to be neither less, nor greater than, nor equal to, another.

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

Less-than-or-equal-to operator. Compares an Offset or Size to another Offset or Size, and returns true if both the horizontal and vertical values of the left-hand-side operand are smaller than or equal to the horizontal and vertical values of the right-hand-side operand respectively. Returns false otherwise.

This is a partial ordering. It is possible for two values to be neither less, nor greater than, nor equal to, another.

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

Greater-than operator. Compares an Offset or Size to another Offset or Size, and returns true if both the horizontal and vertical values of the left-hand-side operand are bigger than the horizontal and vertical values of the right-hand-side operand respectively. Returns false otherwise.

This is a partial ordering. It is possible for two values to be neither less, nor greater than, nor equal to, another.

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

Greater-than-or-equal-to operator. Compares an Offset or Size to another Offset or Size, and returns true if both the horizontal and vertical values of the left-hand-side operand are bigger than or equal to the horizontal and vertical values of the right-hand-side operand respectively. Returns false otherwise.

This is a partial ordering. It is possible for two values to be neither less, nor greater than, nor equal to, another.

pub fn aspect_ratio(&self) -> f64

The aspect ratio of this size.

This returns the width divided by the height.

If the width is zero, the result will be zero. If the height is zero (and the width is not), the result will be f64::INFINITY or f64::NEG_INFINITY as determined by the sign of width.

See also:

• AspectRatio, a widget for giving a child widget a specific aspect ratio.
• FittedBox, a widget that (in most modes) attempts to maintain a child widget’s aspect ratio while changing its size.

pub fn is_empty(&self) -> bool

Whether this size encloses a zero area.

Negative areas are considered empty.

pub fn truncating_div(&self, operand: f64) -> Size

Integer (truncating) division operator.

Returns a Size whose dimensions are the dimensions of this size divided by the scalar operand, rounded towards zero.

pub fn shortest_side(&self) -> f64

The lesser of the magnitudes of the width and the height.

pub fn longest_side(&self) -> f64

The greater of the magnitudes of the width and the height.

pub fn top_left(&self, origin: Offset) -> Offset

The offset to the intersection of the top and left edges of the rectangle described by the given Offset (which is interpreted as the top-left corner) and this Size.

See also Rect::top_left.

pub fn top_center(&self, origin: Offset) -> Offset

The offset to the center of the top edge of the rectangle described by the given offset (which is interpreted as the top-left corner) and this size.

See also Rect::top_center.

pub fn top_right(&self, origin: Offset) -> Offset

The offset to the intersection of the top and right edges of the rectangle described by the given offset (which is interpreted as the top-left corner) and this size.

See also Rect::top_right.

pub fn center_left(&self, origin: Offset) -> Offset

The offset to the center of the left edge of the rectangle described by the given offset (which is interpreted as the top-left corner) and this size.

See also Rect::center_left.

pub fn center(&self, origin: Offset) -> Offset

The offset to the point halfway between the left and right and the top and bottom edges of the rectangle described by the given offset (which is interpreted as the top-left corner) and this size.

See also Rect::center.

pub fn center_right(&self, origin: Offset) -> Offset

The offset to the center of the right edge of the rectangle described by the given offset (which is interpreted as the top-left corner) and this size.

See also Rect::center_right.

pub fn bottom_left(&self, origin: Offset) -> Offset

The offset to the intersection of the bottom and left edges of the rectangle described by the given offset (which is interpreted as the top-left corner) and this size.

See also Rect::bottom_left.

pub fn bottom_center(&self, origin: Offset) -> Offset

The offset to the center of the bottom edge of the rectangle described by the given offset (which is interpreted as the top-left corner) and this size.

See also Rect::bottom_center.

pub fn bottom_right(&self, origin: Offset) -> Offset

The offset to the intersection of the bottom and right edges of the rectangle described by the given offset (which is interpreted as the top-left corner) and this size.

See also Rect::bottom_right.

pub fn contains(&self, offset: Offset) -> bool

Whether the point specified by the given offset (which is assumed to be relative to the top left of the size) lies between the left and right and the top and bottom edges of a rectangle of this size.

Rectangles include their top and left edges but exclude their bottom and right edges.

pub fn flipped(&self) -> Size

A Size with the width and height swapped.

pub fn lerp(a: Option<Size>, b: Option<Size>, t: f64) -> Option<Size>

Linearly interpolate between two sizes.

If either size is null, this function interpolates from Size::ZERO.

The t argument represents position on the timeline, with 0.0 meaning that the interpolation has not started, returning a (or something equivalent to a), 1.0 meaning that the interpolation has finished, returning b (or something equivalent to b), and values in between meaning that the interpolation is at the relevant point on the timeline between a and b. The interpolation can be extrapolated beyond 0.0 and 1.0, so negative values and values greater than 1.0 are valid (and can easily be generated by curves such as Curves.elasticInOut).

Values for t are usually obtained from an Animation<double>, such as an AnimationController.

Trait Implementations

impl Add<Offset> for Size

Binary addition operator for adding an Offset to a Size.

Returns a Size whose width is the sum of the width of the left-hand-side operand, a Size, and the Offset::dx dimension of the right-hand-side operand, an Offset, and whose height is the sum of the height of the left-hand-side operand and the Offset::dy dimension of the right-hand-side operand.

type Output = Size

The resulting type after applying the + operator.

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

Performs the + operation.

impl BitAnd<Size> for Offset

Rectangle constructor operator.

Combines an Offset and a Size to form a Rect whose top-left coordinate is the point given by adding this offset, the left-hand-side operand, to the origin, and whose size is the right-hand-side operand.

let my_rect = Offset::ZERO & Size::new(100.0, 100.0);
// same as: Rect::from_ltwh(0.0, 0.0, 100.0, 100.0)

type Output = Rect

The resulting type after applying the & operator.

fn bitand(self, other: Size) -> Rect

Performs the & operation.

impl Clone for Size

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Size

impl Debug for Size

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

Formats the value using the given formatter.

impl Div<f64> for Size

Division operator.

Returns a Size whose dimensions are the dimensions of the left-hand-side operand (a Size) divided by the scalar right-hand-side operand (an f64).

type Output = Size

The resulting type after applying the / operator.

fn div(self, operand: f64) -> Size

Performs the / operation.

impl From<Size> for Size

fn from(size: Size) -> Size

Converts to this type from the input type.

impl Mul<f64> for Size

Multiplication operator.

Returns a Size whose dimensions are the dimensions of the left-hand-side operand (a Size) multiplied by the scalar right-hand-side operand (an f64).

type Output = Size

The resulting type after applying the * operator.

fn mul(self, operand: f64) -> Size

Performs the * operation.

impl PartialEq for Size

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

Equality operator ==.

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

Inequality operator !=.

impl Rem<f64> for Size

Modulo (remainder) operator.

Returns a Size whose dimensions are the remainder of dividing the left-hand-side operand (a Size) by the scalar right-hand-side operand (an f64).

type Output = Size

The resulting type after applying the % operator.

fn rem(self, operand: f64) -> Size

Performs the % operation.

impl StructuralPartialEq for Size

impl Sub for Size

Binary subtraction operator for Size.

Subtracting a Size from a Size returns the Offset that describes how much bigger the left-hand-side operand is than the right-hand-side operand. Adding that resulting Offset to the Size that was the right-hand-side operand would return a Size equal to the Size that was the left-hand-side operand. (i.e. if size_a - size_b -> offset_a, then offset_a + size_b -> size_a)

type Output = Offset

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Offset> for Size

Subtracting an Offset from a Size returns the Size that is smaller than the Size operand by the difference given by the Offset operand. In other words, the returned Size has a width consisting of the width of the left-hand-side operand minus the Offset::dx dimension of the right-hand-side operand, and a height consisting of the height of the left-hand-side operand minus the Offset::dy dimension of the right-hand-side operand.

type Output = Size

The resulting type after applying the - operator.

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

Performs the - operation.