refactor(layouts): extract independent komorebi-layouts crate

This commit moves layout-related code into a new workspace crate
komorebi-layouts, with the intention of re-using it all in komorebi for
Mac instead of maintaining two separate implementations.

komorebi-layouts/src/rect.rs

@@ -0,0 +1,113 @@
+use serde::Deserialize;
+use serde::Serialize;
+
+#[cfg(feature = "win32")]
+use windows::Win32::Foundation::RECT;
+
+#[derive(Debug, Default, Clone, Copy, Serialize, Deserialize, Eq, PartialEq)]
+#[cfg_attr(feature = "schemars", derive(schemars::JsonSchema))]
+/// Rectangle dimensions
+pub struct Rect {
+    /// Left point of the rectangle
+    pub left: i32,
+    /// Top point of the rectangle
+    pub top: i32,
+    /// Width of the recentangle (from the left point)
+    pub right: i32,
+    /// Height of the rectangle (from the top point)
+    pub bottom: i32,
+}
+
+#[cfg(feature = "win32")]
+impl From<RECT> for Rect {
+    fn from(rect: RECT) -> Self {
+        Self {
+            left: rect.left,
+            top: rect.top,
+            right: rect.right - rect.left,
+            bottom: rect.bottom - rect.top,
+        }
+    }
+}
+
+#[cfg(feature = "win32")]
+impl From<Rect> for RECT {
+    fn from(rect: Rect) -> Self {
+        Self {
+            left: rect.left,
+            top: rect.top,
+            right: rect.right,
+            bottom: rect.bottom,
+        }
+    }
+}
+
+impl Rect {
+    pub fn is_same_size_as(&self, rhs: &Self) -> bool {
+        self.right == rhs.right && self.bottom == rhs.bottom
+    }
+
+    pub fn has_same_position_as(&self, rhs: &Self) -> bool {
+        self.left == rhs.left && self.top == rhs.top
+    }
+}
+
+impl Rect {
+    /// decrease the size of self by the padding amount.
+    pub fn add_padding<T>(&mut self, padding: T)
+    where
+        T: Into<Option<i32>>,
+    {
+        if let Some(padding) = padding.into() {
+            self.left += padding;
+            self.top += padding;
+            self.right -= padding * 2;
+            self.bottom -= padding * 2;
+        }
+    }
+
+    /// increase the size of self by the margin amount.
+    pub fn add_margin(&mut self, margin: i32) {
+        self.left -= margin;
+        self.top -= margin;
+        self.right += margin * 2;
+        self.bottom += margin * 2;
+    }
+
+    pub fn left_padding(&mut self, padding: i32) {
+        self.left += padding;
+    }
+
+    pub fn right_padding(&mut self, padding: i32) {
+        self.right -= padding;
+    }
+
+    #[must_use]
+    pub const fn contains_point(&self, point: (i32, i32)) -> bool {
+        point.0 >= self.left
+            && point.0 <= self.left + self.right
+            && point.1 >= self.top
+            && point.1 <= self.top + self.bottom
+    }
+
+    #[must_use]
+    pub const fn scale(&self, system_dpi: i32, rect_dpi: i32) -> Rect {
+        Rect {
+            left: (self.left * rect_dpi) / system_dpi,
+            top: (self.top * rect_dpi) / system_dpi,
+            right: (self.right * rect_dpi) / system_dpi,
+            bottom: (self.bottom * rect_dpi) / system_dpi,
+        }
+    }
+
+    #[cfg(feature = "win32")]
+    #[must_use]
+    pub const fn rect(&self) -> RECT {
+        RECT {
+            left: self.left,
+            top: self.top,
+            right: self.left + self.right,
+            bottom: self.top + self.bottom,
+        }
+    }
+}