`ee6e68b`

detect monitor edge before BSP adjacency for cross-monitor nav

both focus_direction and swap_direction now check if the focused
window's edge touches the monitor boundary before consulting
find_adjacent. prevents the BSP spiral from trapping navigation
at the edge — if a window is flush with the right edge of the
monitor, pressing right crosses to the next monitor instead of
spiraling deeper into the BSP tree.

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 1 month ago

SHA: ee6e68bce1dfee77d562d0f542c7a7d49cd4edf8
Parents: 23927cb
Tree: c9cd343

1 changed file

Status	File	+	-
M	`tarmac/src/core/state.rs`	65	19

tarmac/src/core/state.rsmodified

              let geoms =
                  ws.tree
                      .calculate_geometries_with_gaps(sr, self.gap_inner, self.gap_outer, true);
--            if let Some(target) = Node::find_adjacent(&geoms, from, direction) {
++
--                self.focus_window(target);
++            // Check if focused window is at the monitor edge in the requested
--                if self.mouse_follows_focus
++            // direction. If so, cross monitors instead of spiraling into the BSP tree.
--                    && let Some((_, rect)) = geoms.iter().find(|(id, _)| *id == target)
++            let at_edge = if let Some((_, rect)) = geoms.iter().find(|(w, _)| *w == from) {
--                {
++                let tolerance = self.gap_outer + 2.0;
--                    warp_mouse_to_center(rect);
++                match direction {
--                    self.ffm_cooldown_until =
++                    Direction::Right => {
--                        Some(std::time::Instant::now() + std::time::Duration::from_millis(200));
++                        (rect.x + rect.width) >= (sr.x + sr.width - tolerance)
--                    self.ffm_last_window = Some(target);
++                    }
++                    Direction::Left => rect.x <= (sr.x + tolerance),
++                    Direction::Down => {
++                        (rect.y + rect.height) >= (sr.y + sr.height - tolerance)
++                    }
++                    Direction::Up => rect.y <= (sr.y + tolerance),
++                }
++            } else {
++                false
++            };
++
++            if !at_edge {
++                if let Some(target) = Node::find_adjacent(&geoms, from, direction) {
++                    self.focus_window(target);
++                    if self.mouse_follows_focus
++                        && let Some((_, rect)) = geoms.iter().find(|(id, _)| *id == target)
++                    {
++                        warp_mouse_to_center(rect);
++                        self.ffm_cooldown_until = Some(
++                            std::time::Instant::now() + std::time::Duration::from_millis(200),
++                        );
++                        self.ffm_last_window = Some(target);
++                    }
++                    return;
+                 }
--                return;
+             }
+         }
--        // No adjacent window (or empty workspace) — try crossing monitors
++        // At monitor edge or no adjacent window — try crossing monitors
          if self.monitors.len() <= 1 {
              return;
+         }
              None => return,
          };
          let sr = self.focused_rect();
--        let geoms = ws.tree.calculate_geometries(sr);
++        let geoms = ws.tree.calculate_geometries_with_gaps(
--        if let Some(target) = Node::find_adjacent(&geoms, focused, direction) {
++            sr,
--            tracing::debug!(focused, target, ?direction, "swap_direction");
++            self.gap_inner,
--            if self.active_workspace_mut().tree.swap(focused, target) {
++            self.gap_outer,
--                self.apply_layout();
++            true,
--                self.fix_oversized_windows();
++        );
++
++        // Check if the focused window touches the monitor edge in the
++        // requested direction. If so, skip intra-workspace swap and move
++        // to the adjacent monitor. This prevents the BSP spiral from
++        // trapping windows at the edge.
++        let at_edge = if let Some((_, rect)) = geoms.iter().find(|(w, _)| *w == focused) {
++            let tolerance = self.gap_outer + 2.0;
++            match direction {
++                Direction::Right => (rect.x + rect.width) >= (sr.x + sr.width - tolerance),
++                Direction::Left => rect.x <= (sr.x + tolerance),
++                Direction::Down => (rect.y + rect.height) >= (sr.y + sr.height - tolerance),
++                Direction::Up => rect.y <= (sr.y + tolerance),
++            }
++        } else {
++            false
++        };
++
++        if !at_edge {
++            if let Some(target) = Node::find_adjacent(&geoms, focused, direction) {
++                tracing::debug!(focused, target, ?direction, "swap_direction");
++                if self.active_workspace_mut().tree.swap(focused, target) {
++                    self.apply_layout();
++                    self.fix_oversized_windows();
++                }
++                return;
+             }
--            return;
+         }
--        // No adjacent window — move window to adjacent monitor
++        // At monitor edge or no adjacent window — move to adjacent monitor
          if self.monitors.len() <= 1 {
              return;
+         }