Merge pull request #2 from ModProg/rect-corners

Accessors for Rect corners

Author: ecton

CHANGELOG.md

@@ -5,6 +5,12 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## Unreleased
+
+### Added
+
+- Functions to get the four corners of a `Rect`.
+
 ## v0.5.0 (2024-11-19)
 
 ### Breaking Changes

src/rect.rs

@@ -95,7 +95,7 @@ impl<Unit> Rect<Unit> {
     /// # Errors
     ///
     /// Returns `<NewUnit as TryFrom>::Error` when the inner type cannot be
-    /// converted. For this crate's types, this genenerally will be
+    /// converted. For this crate's types, this generally will be
     pub fn try_cast<NewUnit>(self) -> Result<Rect<NewUnit>, NewUnit::Error>
     where
         NewUnit: TryFrom<Unit>,
@@ -191,24 +191,53 @@ impl<Unit> Rect<Unit> {
     /// Returns the non-origin point.
     pub fn extent(&self) -> Point<Unit>
     where
-        Unit: crate::Unit,
+        Unit: Add<Output = Unit> + Copy,
     {
         self.origin + self.size
     }
 }
 
 impl<Unit> Rect<Unit>
 where
+    // alternatively we could reduce the traits for `extent()`
     Unit: Add<Output = Unit> + Ord + Copy,
 {
     /// Returns the top-left and bottom-right points of this rectangle.
     ///
-    /// The first point returned will always be the top-right point, even if the size of the rectangle is negative.
+    /// The first point returned will always be the top-left point, even if the size of the rectangle is negative.
     pub fn extents(&self) -> (Point<Unit>, Point<Unit>) {
-        let extent = self.origin + self.size;
-        (
-            Point::new(self.origin.x.min(extent.x), self.origin.y.min(extent.y)),
-            Point::new(self.origin.x.max(extent.x), self.origin.y.max(extent.y)),
+        (self.top_left(), self.bottom_right())
+    }
+
+    /// Returns the top-left corner of this rectangle.
+    pub fn top_left(&self) -> Point<Unit> {
+        Point::new(
+            self.origin.x.min(self.extent().x),
+            self.origin.y.min(self.extent().y),
+        )
+    }
+
+    /// Returns the top-right corner of this rectangle.
+    pub fn top_right(&self) -> Point<Unit> {
+        Point::new(
+            self.origin.x.max(self.extent().x),
+            self.origin.y.min(self.extent().y),
+        )
+    }
+
+    /// Returns the bottom-left corner of this rectangle.
+    pub fn bottom_left(&self) -> Point<Unit> {
+        Point::new(
+            self.origin.x.min(self.extent().x),
+            self.origin.y.max(self.extent().y),
+        )
+    }
+
+    /// Returns the bottom-right corner of this rectangle.
+    pub fn bottom_right(&self) -> Point<Unit> {
+        Point::new(
+            self.origin.x.max(self.extent().x),
+            self.origin.y.max(self.extent().y),
         )
     }
 }

src/traits.rs

@@ -8,7 +8,7 @@ use crate::Fraction;
 
 /// Converts a type to its floating point representation.
 ///
-/// This trait exists because there is no trait in Rust to peform `x as f32`.
+/// This trait exists because there is no trait in Rust to perform `x as f32`.
 pub trait FloatConversion {
     /// The type that represents this type in floating point form.
     type Float;
@@ -332,7 +332,7 @@ pub trait ScreenScale {
     /// Converts this value from its current unit into device independent pixels
     /// ([`Lp`](crate::units::Lp)) using the provided `scale` factor.
     fn into_lp(self, scale: Fraction) -> Self::Lp;
-    /// Converts from Lp into this type, using the provided `scale` factor.
+    /// Converts from [`Lp`](crate::units::Lp) into this type, using the provided `scale` factor.
     fn from_lp(lp: Self::Lp, scale: Fraction) -> Self;
 }
 
@@ -427,12 +427,16 @@ pub trait Unit:
 /// available as traits.
 pub trait StdNumOps {
     /// Adds `self` and `other`, saturating instead of overflowing.
+    #[must_use]
     fn saturating_add(self, other: Self) -> Self;
     /// Multiplies `self` and `other`, saturating instead of overflowing.
+    #[must_use]
     fn saturating_mul(self, other: Self) -> Self;
     /// Divides `self` by `other`, saturating instead of overflowing.
+    #[must_use]
     fn saturating_div(self, other: Self) -> Self;
     /// Subtracts `other` from `self`, saturating instead of overflowing.
+    #[must_use]
     fn saturating_sub(self, other: Self) -> Self;
 }
 
@@ -556,7 +560,7 @@ impl PixelScaling for Lp {
 
 /// Information about scaling for a numerical unit type.
 pub trait UnscaledUnit {
-    /// The internal reprsentation used by this type.
+    /// The internal representation used by this type.
     type Representation: CastInto<i32>;
 
     /// Returns a new instance using the unscaled representation.