Struct euclid::rect::TypedRect

pub struct TypedRect<T, U = UnknownUnit> {
    pub origin: TypedPoint2D<T, U>,
    pub size: TypedSize2D<T, U>,
}

A 2d Rectangle optionally tagged with a unit.

Fields

origin: TypedPoint2D<T, U>

size: TypedSize2D<T, U>

Methods

impl<T, U> TypedRect<T, U>

fn new(origin: TypedPoint2D<T, U>, size: TypedSize2D<T, U>) -> TypedRect<T, U>

Constructor.

impl<T, U> TypedRect<T, U> where T: Copy + Clone + Zero + PartialOrd + PartialEq + Add<T, Output=T> + Sub<T, Output=T>

fn intersects(&self, other: &TypedRect<T, U>) -> bool

fn max_x(&self) -> T

fn min_x(&self) -> T

fn max_y(&self) -> T

fn min_y(&self) -> T

fn max_x_typed(&self) -> Length<T, U>

fn min_x_typed(&self) -> Length<T, U>

fn max_y_typed(&self) -> Length<T, U>

fn min_y_typed(&self) -> Length<T, U>

fn intersection(&self, other: &TypedRect<T, U>) -> Option<TypedRect<T, U>>

fn translate(&self, other: &TypedPoint2D<T, U>) -> TypedRect<T, U>

Translates the rect by a vector.

fn contains(&self, other: &TypedPoint2D<T, U>) -> bool

Returns true if this rectangle contains the point. Points are considered in the rectangle if they are on the left or top edge, but outside if they are on the right or bottom edge.

fn contains_rect(&self, rect: &TypedRect<T, U>) -> bool

Returns true if this rectangle contains the interior of rect. Always returns true if rect is empty, and always returns false if rect is nonempty but this rectangle is empty.

fn inflate(&self, width: T, height: T) -> TypedRect<T, U>

fn inflate_typed(&self,
                 width: Length<T, U>,
                 height: Length<T, U>)
                 -> TypedRect<T, U>

fn top_right(&self) -> TypedPoint2D<T, U>

fn bottom_left(&self) -> TypedPoint2D<T, U>

fn bottom_right(&self) -> TypedPoint2D<T, U>

fn translate_by_size(&self, size: &TypedSize2D<T, U>) -> TypedRect<T, U>

fn from_points(points: &[TypedPoint2D<T, U>]) -> Self

Returns the smallest rectangle containing the four points.

impl<T, U> TypedRect<T, U> where T: Copy + Clone + PartialOrd + Add<T, Output=T> + Sub<T, Output=T> + Zero

fn union(&self, other: &TypedRect<T, U>) -> TypedRect<T, U>

impl<T, U> TypedRect<T, U>

fn scale<Scale: Copy>(&self, x: Scale, y: Scale) -> TypedRect<T, U> where T: Copy + Clone + Mul<Scale, Output=T>

impl<T: Copy + PartialEq + Zero, U> TypedRect<T, U>

fn zero() -> TypedRect<T, U>

Constructor, setting all sides to zero.

fn is_empty(&self) -> bool

Returns true if the size is zero, regardless of the origin's value.

impl<T: Copy, Unit> TypedRect<T, Unit>

fn to_untyped(&self) -> Rect<T>

Drop the units, preserving only the numeric value.

fn from_untyped(r: &Rect<T>) -> TypedRect<T, Unit>

Tag a unitless value with units.

impl<T0: NumCast + Copy, Unit> TypedRect<T0, Unit>

fn cast<T1: NumCast + Copy>(&self) -> Option<TypedRect<T1, Unit>>

Cast from one numeric representation to another, preserving the units.

When casting from floating point to integer coordinates, the decimals are truncated as one would expect from a simple cast, but this behavior does not always make sense geometrically. Consider using round(), round_in or round_out() before casting.

impl<T: Floor + Ceil + Round + Add<T, Output=T> + Sub<T, Output=T>, U> TypedRect<T, U>

fn round(&self) -> Self

Return a rectangle with edges rounded to integer coordinates, such that the returned rectangle has the same set of pixel centers as the original one. Edges at offset 0.5 round up. Suitable for most places where integral device coordinates are needed, but note that any translation should be applied first to avoid pixel rounding errors. Note that this is not rounding to nearest integer if the values are negative. They are always rounding as floor(n + 0.5).

fn round_in(&self) -> Self

Return a rectangle with edges rounded to integer coordinates, such that the original rectangle contains the resulting rectangle.

fn round_out(&self) -> Self

Return a rectangle with edges rounded to integer coordinates, such that the original rectangle is contained in the resulting rectangle.

impl<T: NumCast + Copy, Unit> TypedRect<T, Unit>

fn to_f32(&self) -> TypedRect<f32, Unit>

Cast into an f32 vector.

fn to_uint(&self) -> TypedRect<usize, Unit>

Cast into an usize vector, truncating decimals if any.

When casting from floating point vectors, it is worth considering whether to round(), round_in() or round_out() before the cast in order to obtain the desired conversion behavior.

fn to_i32(&self) -> TypedRect<i32, Unit>

Cast into an i32 vector, truncating decimals if any.

When casting from floating point vectors, it is worth considering whether to round(), round_in() or round_out() before the cast in order to obtain the desired conversion behavior.

fn to_i64(&self) -> TypedRect<i64, Unit>

Cast into an i64 vector, truncating decimals if any.

When casting from floating point vectors, it is worth considering whether to round(), round_in() or round_out() before the cast in order to obtain the desired conversion behavior.

Trait Implementations

impl<T: Decodable, U: Decodable> Decodable for TypedRect<T, U>

fn decode<__DTU: Decoder>(__arg_0: &mut __DTU)
                          -> Result<TypedRect<T, U>, __DTU::Error>

Deserialize a value using a Decoder.

impl<T: Encodable, U: Encodable> Encodable for TypedRect<T, U>

fn encode<__STU: Encoder>(&self,
                          __arg_0: &mut __STU)
                          -> Result<(), __STU::Error>

Serialize a value using an Encoder.

impl<T: HeapSizeOf, U> HeapSizeOf for TypedRect<T, U>

fn heap_size_of_children(&self) -> usize

Measure the size of any heap-allocated structures that hang off this value, but not the space taken up by the value itself (i.e. what size_of:: measures, more or less); that space is handled by the implementation of HeapSizeOf for Box below.

impl<T: Copy + Deserialize, U> Deserialize for TypedRect<T, U>

fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error> where D: Deserializer

Deserialize this value given this Deserializer.

impl<T: Serialize, U> Serialize for TypedRect<T, U>

fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer

Serializes this value into this serializer.

impl<T: Copy, U> Copy for TypedRect<T, U>

impl<T: Copy, U> Clone for TypedRect<T, U>

fn clone(&self) -> TypedRect<T, U>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: PartialEq, U> PartialEq<TypedRect<T, U>> for TypedRect<T, U>

fn eq(&self, other: &TypedRect<T, U>) -> 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 !=.

impl<T: Eq, U> Eq for TypedRect<T, U>

impl<T: Debug, U> Debug for TypedRect<T, U>

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

Formats the value using the given formatter.

impl<T: Display, U> Display for TypedRect<T, U>

fn fmt(&self, formatter: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<T: Copy + Mul<T, Output=T>, U> Mul<T> for TypedRect<T, U>

type Output = TypedRect<T, U>

The resulting type after applying the * operator

fn mul(self, scale: T) -> TypedRect<T, U>

The method for the * operator

impl<T: Copy + Div<T, Output=T>, U> Div<T> for TypedRect<T, U>

type Output = TypedRect<T, U>

The resulting type after applying the / operator

fn div(self, scale: T) -> TypedRect<T, U>

The method for the / operator

impl<T: Copy + Mul<T, Output=T>, U1, U2> Mul<ScaleFactor<T, U1, U2>> for TypedRect<T, U1>

type Output = TypedRect<T, U2>

The resulting type after applying the * operator

fn mul(self, scale: ScaleFactor<T, U1, U2>) -> TypedRect<T, U2>

The method for the * operator

impl<T: Copy + Div<T, Output=T>, U1, U2> Div<ScaleFactor<T, U1, U2>> for TypedRect<T, U2>

type Output = TypedRect<T, U1>

The resulting type after applying the / operator

fn div(self, scale: ScaleFactor<T, U1, U2>) -> TypedRect<T, U1>

The method for the / operator