`eb8314e`

prevent monitor overlaps during snap

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 3 months ago

SHA: eb8314e0011cfdf9beb24d16f38014df3548eada
Parents: 896a89e
Tree: faa4058

1 changed file

Status	File	+	-
M	`gardisplay/src/ui/monitor_view.rs`	67	34

gardisplay/src/ui/monitor_view.rsmodified

          self.snap_to_nearest(dragged_idx, dragged);
+     }
++    /// Check if a rect overlaps with any monitor except the specified one.
++    fn would_overlap(&self, rect: Rect, exclude_idx: usize) -> bool {
++        for (i, other) in self.monitors.iter().enumerate() {
++            if i == exclude_idx {
++                continue;
++            }
++            if Self::rects_overlap(rect, other.scaled_rect) {
++                return true;
++            }
++        }
++        false
++    }
++
++    /// Check if two rects overlap (share any interior area).
++    fn rects_overlap(a: Rect, b: Rect) -> bool {
++        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;
++
++        a.x < b_right && a_right > b.x && a.y < b_bottom && a_bottom > b.y
++    }
++
      /// Snap a monitor to be adjacent to the nearest other monitor.
      /// Uses directional awareness - snaps to the side the monitor was dropped on.
++    /// Ensures no overlaps with other monitors.
      fn snap_to_nearest(&mut self, dragged_idx: usize, dragged: Rect) {
          let dragged_center_x = dragged.x + dragged.width as i32 / 2;
          let dragged_center_y = dragged.y + dragged.height as i32 / 2;
              let dx = dragged_center_x - other_center_x;
              let dy = dragged_center_y - other_center_y;
--            // Determine snap position based on which side we're dropping on
++            // Try all 4 sides and pick the best non-overlapping position
--            // Also align on the perpendicular axis to ensure actual adjacency
++            let candidates = [
--            let (new_x, new_y) = if dx.abs() > dy.abs() {
++                // Right of other
--                // More horizontal - snap left or right
++                (other_rect.x + other_rect.width as i32, other_rect.y),
--                // Clamp y to ensure vertical overlap with the target
++                // Left of other
--                let clamped_y = dragged.y
++                (other_rect.x - dragged.width as i32, other_rect.y),
--                    .max(other_rect.y - dragged.height as i32 + 1)
++                // Below other
--                    .min(other_rect.y + other_rect.height as i32 - 1);
++                (other_rect.x, other_rect.y + other_rect.height as i32),
--                if dx > 0 {
++                // Above other
--                    // Dropping to the right of other - snap to right side
++                (other_rect.x, other_rect.y - dragged.height as i32),
--                    (other_rect.x + other_rect.width as i32, clamped_y)
++            ];
--                } else {
++
--                    // Dropping to the left of other - snap to left side
++            // Score each candidate based on direction preference
--                    (other_rect.x - dragged.width as i32, clamped_y)
++            for (new_x, new_y) in candidates {
++                let candidate_rect = Rect::new(new_x, new_y, dragged.width, dragged.height);
++
++                // Skip if this position would overlap with another monitor
++                if self.would_overlap(candidate_rect, dragged_idx) {
++                    continue;
+                 }
--            } else {
++
--                // More vertical - snap above or below
++                // Calculate distance with direction weighting
--                // Clamp x to ensure horizontal overlap with the target
++                let new_center_x = new_x + dragged.width as i32 / 2;
--                let clamped_x = dragged.x
++                let new_center_y = new_y + dragged.height as i32 / 2;
--                    .max(other_rect.x - dragged.width as i32 + 1)
++
--                    .min(other_rect.x + other_rect.width as i32 - 1);
++                // Base distance
--                if dy > 0 {
++                let mut dist = (dragged_center_x - new_center_x).abs()
--                    // Dropping below other - snap to bottom
++                    + (dragged_center_y - new_center_y).abs();
--                    (clamped_x, other_rect.y + other_rect.height as i32)
++
++                // Penalize positions that don't match the drag direction
++                let snap_dx = new_center_x - other_center_x;
++                let snap_dy = new_center_y - other_center_y;
++
++                // If we're dragging more horizontally, prefer horizontal snaps
++                if dx.abs() > dy.abs() {
++                    if (dx > 0) != (snap_dx > 0) {
++                        dist += 1000; // Penalize wrong horizontal direction
++                    }
                  } else {
--                    // Dropping above other - snap to top
++                    if (dy > 0) != (snap_dy > 0) {
--                    (clamped_x, other_rect.y - dragged.height as i32)
++                        dist += 1000; // Penalize wrong vertical direction
++                    }
+                 }
--            };
--            // Distance from current position to this snap position
++                if best_snap.map_or(true, |(_, _, best_dist)| dist < best_dist) {
--            let new_center_x = new_x + dragged.width as i32 / 2;
++                    best_snap = Some((new_x, new_y, dist));
--            let new_center_y = new_y + dragged.height as i32 / 2;
++                }
--            let dist = (dragged_center_x - new_center_x).abs()
--                + (dragged_center_y - new_center_y).abs();
--
--            if best_snap.map_or(true, |(_, _, best_dist)| dist < best_dist) {
--                best_snap = Some((new_x, new_y, dist));
+             }
+         }