gardesk/gardisplay / f63d047

-        let mut snap_x: Option<i32> = None;

-        let mut snap_y: Option<i32> = None;

-

-        let dragged = self.monitors[dragged_idx].scaled_rect;

-

-        // First pass: threshold-based snapping for fine alignment

-        for (i, other) in self.monitors.iter().enumerate() {

-            if i == dragged_idx {

-                continue;

-            }

-

-            let other_rect = other.scaled_rect;

-

-            // Vertical snapping (x-axis)

-            // Snap left edge to right edge of other

-            let dist = (dragged.x - (other_rect.x + other_rect.width as i32)).abs();

-            if dist < SNAP_THRESHOLD && snap_x.map_or(true, |sx| dist < (dragged.x - sx).abs()) {

-                snap_x = Some(other_rect.x + other_rect.width as i32);

-            }

-

-            // Snap right edge to left edge of other

-            let dist = ((dragged.x + dragged.width as i32) - other_rect.x).abs();

-            if dist < SNAP_THRESHOLD && snap_x.map_or(true, |sx| dist < (dragged.x - sx).abs()) {

-                snap_x = Some(other_rect.x - dragged.width as i32);

-            }

-

-            // Snap left to left (align)

-            let dist = (dragged.x - other_rect.x).abs();

-            if dist < SNAP_THRESHOLD && snap_x.map_or(true, |sx| dist < (dragged.x - sx).abs()) {

-                snap_x = Some(other_rect.x);

-            }

-

-            // Horizontal snapping (y-axis)

-            // Snap top edge to bottom edge of other

-            let dist = (dragged.y - (other_rect.y + other_rect.height as i32)).abs();

-            if dist < SNAP_THRESHOLD && snap_y.map_or(true, |sy| dist < (dragged.y - sy).abs()) {

-                snap_y = Some(other_rect.y + other_rect.height as i32);

-            }

-

-            // Snap bottom edge to top edge of other

-            let dist = ((dragged.y + dragged.height as i32) - other_rect.y).abs();

-            if dist < SNAP_THRESHOLD && snap_y.map_or(true, |sy| dist < (dragged.y - sy).abs()) {

-                snap_y = Some(other_rect.y - dragged.height as i32);

-            }

-

-            // Snap top to top (align)

-            let dist = (dragged.y - other_rect.y).abs();

-            if dist < SNAP_THRESHOLD && snap_y.map_or(true, |sy| dist < (dragged.y - sy).abs()) {

-                snap_y = Some(other_rect.y);

-            }

-        }

-

-        // Apply threshold snaps

-        if let Some(x) = snap_x {

-            self.monitors[dragged_idx].scaled_rect.x = x;

-        }

-        if let Some(y) = snap_y {

-            self.monitors[dragged_idx].scaled_rect.y = y;

-        }

-

-        // Second pass: close gaps - ensure monitor is adjacent to at least one other

-        if !self.is_adjacent_to_any(dragged_idx) {

-            self.snap_to_nearest(dragged_idx, dragged);

-        }

-    }

-

-    /// Check if a monitor is adjacent (touching) any other monitor.

-    fn is_adjacent_to_any(&self, monitor_idx: usize) -> bool {

-        let rect = self.monitors[monitor_idx].scaled_rect;

-

-        for (i, other) in self.monitors.iter().enumerate() {

-            if i == monitor_idx {

-                continue;

-            }

-

-            if self.rects_adjacent(rect, other.scaled_rect) {

-                return true;

-            }

-        }

-        false

-    }

-

-    /// Check if two rects are adjacent (touching edges, with possible overlap on perpendicular axis).

-    fn rects_adjacent(&self, a: Rect, b: Rect) -> bool {

-        // Check if they overlap on one axis and touch on the other

-        let a_right = a.x + a.width as i32;

-        let a_bottom = a.y + a.height as i32;

-        let b_right = b.x + b.width as i32;

-        let b_bottom = b.y + b.height as i32;

-

-        // Horizontal adjacency: a's right touches b's left OR a's left touches b's right

-        // AND they overlap vertically

-        let horiz_touch = a_right == b.x || a.x == b_right;

-        let vert_overlap = a.y < b_bottom && a_bottom > b.y;

-

-        // Vertical adjacency: a's bottom touches b's top OR a's top touches b's bottom

-        // AND they overlap horizontally

-        let vert_touch = a_bottom == b.y || a.y == b_bottom;

-        let horiz_overlap = a.x < b_right && a_right > b.x;

-

-        (horiz_touch && vert_overlap) || (vert_touch && horiz_overlap)