`a231cc9`

Add directional focus memory for window navigation

When navigating between windows with arrow keys, gar now remembers which
window was last focused in each direction. This fixes the issue where
navigating back and forth between a tall window and stacked windows would
always default to the topmost window instead of returning to the previously
focused one.

The memory is stored only when windows share the same row (for Left/Right)
or column (for Up/Down), preventing interference with natural navigation.

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

SHA: a231cc99e8694fa5deeec1e64aff7593a611f743
Parents: 7056e22
Tree: 0236679

3 changed files

Status	File	+	-
M	`gar/src/core/mod.rs`	9	0
M	`gar/src/core/tree.rs`	11	1
M	`gar/src/x11/events.rs`	43	3

gar/src/core/mod.rsmodified

      pub current_edge_cursor: Option<(XWindow, crate::x11::events::ResizeEdge)>,
      /// garbar child process (managed automatically when gar.bar is configured)
      pub garbar_process: Option<std::process::Child>,
++    /// Directional focus memory: (source_window, direction) -> last_target_window
++    /// Used to remember which window was focused when navigating in a direction
++    pub directional_focus_memory: HashMap<(XWindow, Direction), XWindow>,
  }
  impl WindowManager {
              dock_struts: HashMap::new(),
              current_edge_cursor: None,
              garbar_process: None,
++            directional_focus_memory: HashMap::new(),
          })
      }
              // Remove from focus history
              self.focus_history.retain(|&w| w != window);
++            // Remove directional focus memory entries involving this window
++            self.directional_focus_memory.retain(|(src, _), tgt| {
++                *src != window && *tgt != window
++            });
++
              // Update focus if this was the focused window
              if self.focused_window == Some(window) {
                  // Find next window from focus history that's on this workspace

gar/src/core/tree.rsmodified

      Vertical,
  }
--#[derive(Debug, Clone, Copy, PartialEq, Eq)]
++#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
  pub enum Direction {
      Left,
      Right,
      }
      /// Find adjacent window in a direction, given geometries.
++    /// If `preferred` is Some and is a valid candidate, it will be returned.
++    /// This enables "window memory" - remembering which window was last focused in a direction.
      pub fn find_adjacent(
          geometries: &[(XWindow, Rect)],
          from: XWindow,
          direction: Direction,
++        preferred: Option<XWindow>,
      ) -> Option<XWindow> {
          let from_rect = geometries.iter().find(|(w, _)| *w == from)?.1;
              })
              .collect();
++        // If preferred window is a valid candidate, use it (window memory)
++        if let Some(pref) = preferred {
++            if candidates.iter().any(|(w, _)| *w == pref) {
++                return Some(pref);
++            }
++        }
++
          // Find the closest window in the direction
          // Prioritize alignment perpendicular to movement, then distance in movement direction
          candidates

gar/src/x11/events.rsmodified

          let screen = self.screen_rect();
          let geometries = self.current_workspace().tree.calculate_geometries(screen);
--        if let Some(target) = Node::find_adjacent(&geometries, focused, direction) {
++        // Look up remembered window for this direction (window memory)
++        let preferred = self.directional_focus_memory.get(&(focused, direction)).copied();
++
++        if let Some(target) = Node::find_adjacent(&geometries, focused, direction, preferred) {
++            // Store the directional focus memory for next time
++            self.directional_focus_memory.insert((focused, direction), target);
++
++            // Store reverse direction only if windows are aligned (same row/column)
++            // This enables "back" navigation without breaking natural movement
++            if let (Some((_, from_rect)), Some((_, to_rect))) = (
++                geometries.iter().find(|(w, _)| *w == focused),
++                geometries.iter().find(|(w, _)| *w == target),
++            ) {
++                let dominated = match direction {
++                    // For Left/Right: store reverse if windows share vertical space (same row)
++                    Direction::Left | Direction::Right => {
++                        let overlap_start = from_rect.y.max(to_rect.y);
++                        let overlap_end = (from_rect.y + from_rect.height as i16)
++                            .min(to_rect.y + to_rect.height as i16);
++                        overlap_start < overlap_end
++                    }
++                    // For Up/Down: store reverse if windows share horizontal space (same column)
++                    Direction::Up | Direction::Down => {
++                        let overlap_start = from_rect.x.max(to_rect.x);
++                        let overlap_end = (from_rect.x + from_rect.width as i16)
++                            .min(to_rect.x + to_rect.width as i16);
++                        overlap_start < overlap_end
++                    }
++                };
++
++                if dominated {
++                    let opposite = match direction {
++                        Direction::Left => Direction::Right,
++                        Direction::Right => Direction::Left,
++                        Direction::Up => Direction::Down,
++                        Direction::Down => Direction::Up,
++                    };
++                    self.directional_focus_memory.insert((target, opposite), focused);
++                }
++            }
++
              // Focus new window (keyboard navigation, warp pointer)
              // set_focus handles grab/ungrab for old and new windows
              self.set_focus(target, true)?;
              self.conn.flush()?;
--            tracing::debug!("Focused {:?} to window {}", direction, target);
++            tracing::debug!("Focused {:?} to window {} (preferred: {:?})", direction, target, preferred);
          } else {
              // No adjacent window on this workspace - try adjacent monitor
              self.focus_adjacent_monitor(direction)?;
          let screen = self.screen_rect();
          let geometries = self.current_workspace().tree.calculate_geometries(screen);
--        if let Some(target) = Node::find_adjacent(&geometries, focused, direction) {
++        if let Some(target) = Node::find_adjacent(&geometries, focused, direction, None) {
              // Swap the windows in the tree
              self.current_workspace_mut().tree.swap(focused, target);