feat(Rect): Rect manipulation methods

src/layout/rect.rs

@@ -6,6 +6,10 @@ use std::{
 
 use crate::prelude::*;
 
+mod offset;
+
+pub use offset::*;
+
 /// A simple rectangle used in the computation of the layout and to give widgets a hint about the
 /// area they are supposed to render to.
 #[derive(Debug, Default, Clone, Copy, Eq, PartialEq, Hash)]
@@ -106,6 +110,62 @@ impl Rect {
         }
     }
 
+    /// Adjusts the size of the `Rect`.
+    ///
+    /// - Positive `width` grows the width, negative shrinks.
+    /// - Positive `height` grows the height, negative shrinks.
+    ///
+    /// # See also
+    ///
+    /// See also [`Rect::relocate`] to move the `Rect`.
+    pub fn resize<I, J>(self, width: I, height: J) -> Rect
+    where
+        I: Into<i32>,
+        J: Into<i32>,
+    {
+        Rect {
+            width: i32::from(self.width)
+                .saturating_add(width.into())
+                .clamp(0, u16::MAX as i32) as u16,
+            height: i32::from(self.height)
+                .saturating_add(height.into())
+                .clamp(0, u16::MAX as i32) as u16,
+            ..self
+        }
+    }
+
+    /// Moves the `Rect` without modifying its size.
+    ///
+    /// Moves the `Rect` according to `x` or `y` without modifying its [`Rect::width`] or
+    /// [`Rect::height`].
+    /// - Positive `x` moves the whole `Rect` to the right, negative to the left.
+    /// - Positive `y` moves the whole `Rect` to the bottom, negative to the top.
+    ///
+    /// # See also
+    ///
+    /// See also [`Rect::resize`] to resize.
+    pub fn relocate<I, J>(self, x: I, y: J) -> Rect
+    where
+        I: Into<i32>,
+        J: Into<i32>,
+    {
+        Rect {
+            x: i32::from(self.x)
+                .saturating_add(x.into())
+                .clamp(0, u16::MAX as i32) as u16,
+            y: i32::from(self.y)
+                .saturating_add(y.into())
+                .clamp(0, u16::MAX as i32) as u16,
+            ..self
+        }
+    }
+
+    /// Apply the given [`Offset`] to this Rect.
+    pub fn offset(self, offset: Offset) -> Rect {
+        self.relocate(offset.top, offset.left)
+            .resize(offset.right, offset.bottom)
+    }
+
     /// Returns a new rect that contains both the current one and the given one.
     pub fn union(self, other: Rect) -> Rect {
         let x1 = min(self.x, other.x);
@@ -288,4 +348,10 @@ mod tests {
         const _BOTTOM: u16 = RECT.bottom();
         assert!(RECT.intersects(RECT));
     }
+
+    #[test]
+    fn saturate_add_neg() {
+        let t: i32 = -1;
+        assert_eq!(t.clamp(0, i32::from(u16::MAX)) as u16, 0u16);
+    }
 }

src/layout/rect/offset.rs

@@ -0,0 +1,16 @@
+/// Amounts by which to move a [`Rect`](super::Rect)'s borders.
+///
+/// Positive numbers move to the right/bottom and negative to the left/top.
+///
+/// See [`Rect::offset`](super::Rect::offset)
+#[derive(Debug, Default, Clone, Copy)]
+pub struct Offset {
+    /// How much to move the left border
+    pub left: i32,
+    /// How much to move the top border
+    pub top: i32,
+    /// How much to move the right border
+    pub right: i32,
+    /// How much to move the bottom border
+    pub bottom: i32,
+}