`c037b91`

fix edge snapping to respect alignment, clear dirty on save

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

SHA: c037b9125e334c2d9fb042073f8c5e93acf1f5ed
Parents: cc3d7ca
Tree: b5b22d0

2 changed files

Status	File	+	-
M	`gardisplay/src/app.rs`	4	1
M	`gardisplay/src/ui/monitor_view.rs`	79	83

gardisplay/src/app.rsmodified

              .insert("default".to_string(), profile);
          match self.config.save() {
 -            Ok(()) => self.set_status("Saved profile"),
 +            Ok(()) => {
 +                self.monitor_view.clear_dirty();
 +                self.set_status("Saved profile");
 +            }
              Err(e) => {
                  tracing::error!("failed to save profile: {}", e);
                  self.set_status("Failed to save profile");

gardisplay/src/ui/monitor_view.rsmodified

+     }
      /// Apply snapping to a monitor after drag ends.
 -    /// Ensures no gaps - monitors must always be adjacent to at least one other.
 +    /// Snaps edges to nearby edges while preserving the user's intended position.
      fn apply_snap(&mut self, dragged_idx: usize) {
          if self.monitors.len() < 2 {
              return;
+         }
 -        // Always snap to nearest to ensure adjacency, using directional awareness
 -        let dragged = self.monitors[dragged_idx].scaled_rect;
 -        self.snap_to_nearest(dragged_idx, dragged);
 +        let mut dragged = self.monitors[dragged_idx].scaled_rect;
 +        let dragged_right = dragged.x + dragged.width as i32;
 +        let dragged_bottom = dragged.y + dragged.height as i32;
++
 +        // Find best edge snaps independently for each axis
 +        let mut best_x_snap: Option<(i32, i32)> = None; // (new_x, distance)
 +        let mut best_y_snap: Option<(i32, i32)> = None; // (new_y, distance)
++
 +        for (i, other) in self.monitors.iter().enumerate() {
 +            if i == dragged_idx {
 +                continue;
 +            }
++
 +            let other_rect = other.scaled_rect;
 +            let other_right = other_rect.x + other_rect.width as i32;
 +            let other_bottom = other_rect.y + other_rect.height as i32;
++
 +            // X-axis edge snaps (for adjacency - touching edges)
 +            let x_snaps = [
 +                // Dragged left edge to other right edge (place right of other)
 +                (other_right, (dragged.x - other_right).abs()),
 +                // Dragged right edge to other left edge (place left of other)
 +                (other_rect.x - dragged.width as i32, (dragged_right - other_rect.x).abs()),
 +                // Dragged left edge to other left edge (align left edges)
 +                (other_rect.x, (dragged.x - other_rect.x).abs()),
 +                // Dragged right edge to other right edge (align right edges)
 +                (other_right - dragged.width as i32, (dragged_right - other_right).abs()),
 +            ];
++
 +            for (new_x, dist) in x_snaps {
 +                if dist < SNAP_THRESHOLD {
 +                    if best_x_snap.map_or(true, |(_, best_dist)| dist < best_dist) {
 +                        best_x_snap = Some((new_x, dist));
 +                    }
 +                }
 +            }
++
 +            // Y-axis edge snaps
 +            let y_snaps = [
 +                // Dragged top edge to other bottom edge (place below other)
 +                (other_bottom, (dragged.y - other_bottom).abs()),
 +                // Dragged bottom edge to other top edge (place above other)
 +                (other_rect.y - dragged.height as i32, (dragged_bottom - other_rect.y).abs()),
 +                // Dragged top edge to other top edge (align top edges)
 +                (other_rect.y, (dragged.y - other_rect.y).abs()),
 +                // Dragged bottom edge to other bottom edge (align bottom edges)
 +                (other_bottom - dragged.height as i32, (dragged_bottom - other_bottom).abs()),
 +            ];
++
 +            for (new_y, dist) in y_snaps {
 +                if dist < SNAP_THRESHOLD {
 +                    if best_y_snap.map_or(true, |(_, best_dist)| dist < best_dist) {
 +                        best_y_snap = Some((new_y, dist));
 +                    }
 +                }
 +            }
 +        }
++
 +        // Apply snaps
 +        if let Some((new_x, _)) = best_x_snap {
 +            dragged.x = new_x;
 +        }
 +        if let Some((new_y, _)) = best_y_snap {
 +            dragged.y = new_y;
 +        }
++
 +        // Check for overlap and resolve if needed
 +        if self.would_overlap(dragged, dragged_idx) {
 +            // Revert to original position if we'd overlap
 +            return;
 +        }
++
 +        self.monitors[dragged_idx].scaled_rect = dragged;
+     }
      /// Check if a rect overlaps with any monitor except the specified one.
          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 mut best_snap: Option<(i32, i32, i32)> = None; // (new_x, new_y, distance)
+-
 -        for (i, other) in self.monitors.iter().enumerate() {
 -            if i == dragged_idx {
 -                continue;
 -            }
+-
 -            let other_rect = other.scaled_rect;
 -            let other_center_x = other_rect.x + other_rect.width as i32 / 2;
 -            let other_center_y = other_rect.y + other_rect.height as i32 / 2;
+-
 -            // Determine which side of the other monitor we're on
 -            let dx = dragged_center_x - other_center_x;
 -            let dy = dragged_center_y - other_center_y;
+-
 -            // Try all 4 sides and pick the best non-overlapping position
 -            let candidates = [
 -                // Right of other
 -                (other_rect.x + other_rect.width as i32, other_rect.y),
 -                // Left of other
 -                (other_rect.x - dragged.width as i32, other_rect.y),
 -                // Below other
 -                (other_rect.x, other_rect.y + other_rect.height as i32),
 -                // Above other
 -                (other_rect.x, other_rect.y - dragged.height as i32),
 -            ];
+-
 -            // Score each candidate based on direction preference
 -            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;
 -                }
+-
 -                // Calculate distance with direction weighting
 -                let new_center_x = new_x + dragged.width as i32 / 2;
 -                let new_center_y = new_y + dragged.height as i32 / 2;
+-
 -                // Base distance
 -                let mut dist = (dragged_center_x - new_center_x).abs()
 -                    + (dragged_center_y - new_center_y).abs();
+-
 -                // 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 {
 -                    if (dy > 0) != (snap_dy > 0) {
 -                        dist += 1000; // Penalize wrong vertical direction
 -                    }
 -                }
+-
 -                if best_snap.map_or(true, |(_, _, best_dist)| dist < best_dist) {
 -                    best_snap = Some((new_x, new_y, dist));
 -                }
 -            }
 -        }
+-
 -        if let Some((new_x, new_y, _)) = best_snap {
 -            self.monitors[dragged_idx].scaled_rect.x = new_x;
 -            self.monitors[dragged_idx].scaled_rect.y = new_y;
 -        }
 -    }
+-
      /// Render the monitor view.
      pub fn render(&self, renderer: &mut Renderer, theme: &Theme) -> anyhow::Result<()> {
          // Background
+     }
      /// Check if layout has been modified.
 -    #[allow(dead_code)] // Used in Sprint 3 for RandR application
      pub fn is_dirty(&self) -> bool {
          self.dirty
+     }
 +    /// Clear the dirty flag (after save).
 +    pub fn clear_dirty(&mut self) {
 +        self.dirty = false;
 +    }
++
      /// Get primary monitor name.
      #[allow(dead_code)] // Used in Sprint 3 for RandR application
      pub fn primary_name(&self) -> Option<&str> {