`186c6d5`

Fix focus-follows-mouse feedback loop, add monitor warp

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

SHA: 186c6d538f8bfd0e98dd099d4617283d5cc806d6
Parents: db679da
Tree: 58ebc95

2 changed files

Status	File	+	-
M	`gar/src/core/mod.rs`	124	74
M	`gar/src/x11/events.rs`	164	54

gar/src/core/mod.rsmodified

  use std::collections::HashMap;
  use std::sync::{Arc, Mutex};
 -use x11rb::protocol::xproto::Window as XWindow;
 +use x11rb::protocol::xproto::{ConnectionExt, Window as XWindow};
  use crate::config::{Config, LuaConfig, LuaState, RuleActions, WindowMatch};
  use crate::ipc::IpcServer;
      pub running: bool,
      pub drag_state: Option<DragState>,
      pub ipc_server: Option<IpcServer>,
 +    /// Timestamp of last pointer warp - used to suppress EnterNotify feedback loop
 +    pub last_warp: std::time::Instant,
+ }
  impl WindowManager {
              running: true,
              drag_state: None,
              ipc_server,
 +            last_warp: std::time::Instant::now(),
          })
+     }
          self.conn.set_focus(window)?;
          self.conn.set_active_window(Some(window))?;
          self.update_borders()?;
++
 +        // Warp pointer to center of focused window (mouse follows focus)
 +        if let Err(e) = self.conn.warp_pointer_to_window(window) {
 +            tracing::warn!("Failed to warp pointer: {}", e);
 +        }
 +        // Record warp time to suppress EnterNotify feedback loop
 +        self.last_warp = std::time::Instant::now();
++
          Ok(())
+     }
 -    /// Update border colors for all windows based on focus state.
 +    /// Warp pointer to center of a monitor (for focus without windows)
 +    pub fn warp_to_monitor(&mut self, monitor_idx: usize) -> Result<()> {
 +        let geom = self.monitors[monitor_idx].geometry;
 +        let center_x = geom.x + (geom.width / 2) as i16;
 +        let center_y = geom.y + (geom.height / 2) as i16;
++
 +        self.conn.conn.warp_pointer(
 +            x11rb::NONE,
 +            self.conn.root,
 +            0, 0, 0, 0,
 +            center_x,
 +            center_y,
 +        )?;
 +        self.last_warp = std::time::Instant::now();
 +        self.conn.flush()?;
 +        Ok(())
 +    }
++
 +    /// Update border colors for all visible windows based on focus state.
      pub fn update_borders(&mut self) -> Result<()> {
          let focused = self.focused_window;
          let focused_color = self.config.border_color_focused;
          let unfocused_color = self.config.border_color_unfocused;
          let border_width = self.config.border_width;
 -        // Update borders for all windows (tiled + floating)
 -        for window in self.current_workspace().all_windows() {
 -            let color = if Some(window) == focused {
 -                focused_color
 -            } else {
 -                unfocused_color
 -            };
 -            self.conn.set_border(window, border_width, color)?;
 +        // Get all visible workspace indices
 +        let visible_ws: Vec<usize> = self.monitors.iter().map(|m| m.active_workspace).collect();
++
 +        // Update borders for all windows on visible workspaces
 +        for ws_idx in visible_ws {
 +            for window in self.workspaces[ws_idx].all_windows() {
 +                let color = if Some(window) == focused {
 +                    focused_color
 +                } else {
 +                    unfocused_color
 +                };
 +                self.conn.set_border(window, border_width, color)?;
 +            }
+         }
          Ok(())
+     }
 -    /// Apply the current layout to all windows.
 +    /// Apply the current layout to all visible windows across all monitors.
 +    /// Each monitor displays its active_workspace.
      /// Stacking order: tiled windows at bottom, floating windows on top (in list order).
      pub fn apply_layout(&mut self) -> Result<()> {
          use x11rb::protocol::xproto::{ConfigureWindowAux, ConnectionExt, StackMode};
          let gap_inner = self.config.gap_inner as i16;
          let half_gap = gap_inner / 2;
 -        // Apply outer gap to screen rect
 -        let screen = self.screen_rect();
 -        let work_area = Rect::new(
 -            screen.x + gap_outer,
 -            screen.y + gap_outer,
 -            screen.width.saturating_sub(2 * gap_outer as u16),
 -            screen.height.saturating_sub(2 * gap_outer as u16),
 -        );
+-
 -        tracing::debug!(
 -            "apply_layout: screen={:?}, work_area={:?}, tiled_count={}, floating_count={}",
 -            screen,
 -            work_area,
 -            self.current_workspace().tree.window_count(),
 -            self.current_workspace().floating.len()
 -        );
+-
 -        // 1. Configure tiled windows from the BSP tree
 -        let geometries = self.current_workspace().tree.calculate_geometries(work_area);
 -        for (window, rect) in &geometries {
 -            // Apply inner gap: shrink each window by half_gap on each side
 -            let gapped_x = rect.x + half_gap;
 -            let gapped_y = rect.y + half_gap;
 -            let gapped_width = rect.width.saturating_sub(gap_inner as u16);
 -            let gapped_height = rect.height.saturating_sub(gap_inner as u16);
+-
 -            // Account for border width
 -            let final_width = gapped_width.saturating_sub(2 * border_width as u16);
 -            let final_height = gapped_height.saturating_sub(2 * border_width as u16);
 +        // Collect visible workspaces (one per monitor)
 +        let visible_workspaces: Vec<(usize, Rect)> = self.monitors
 +            .iter()
 +            .map(|m| (m.active_workspace, m.geometry))
 +            .collect();
 -            tracing::debug!(
 -                "apply_layout: TILED window={} at ({}, {}) size {}x{}",
 -                window, gapped_x, gapped_y, final_width.max(1), final_height.max(1)
 +        // Layout each monitor's active workspace
 +        for (ws_idx, screen) in &visible_workspaces {
 +            let work_area = Rect::new(
 +                screen.x + gap_outer,
 +                screen.y + gap_outer,
 +                screen.width.saturating_sub(2 * gap_outer as u16),
 +                screen.height.saturating_sub(2 * gap_outer as u16),
              );
 -            self.conn.configure_window(
 -                *window,
 -                gapped_x,
 -                gapped_y,
 -                final_width.max(1),
 -                final_height.max(1),
 -                border_width,
 -            )?;
 -        }
 +            let ws = &self.workspaces[*ws_idx];
 +            tracing::debug!(
 +                "apply_layout: ws={} screen={:?}, work_area={:?}, tiled={}, floating={}",
 +                ws_idx + 1, screen, work_area,
 +                ws.tree.window_count(), ws.floating.len()
 +            );
 -        // 2. Configure floating windows and stack them above tiled
 -        // Get floating window IDs (in stacking order: first = bottom, last = top)
 -        let floating_ids: Vec<XWindow> = self.current_workspace().floating.clone();
 +            // 1. Configure tiled windows from the BSP tree
 +            let geometries = ws.tree.calculate_geometries(work_area);
 +            for (window, rect) in &geometries {
 +                // Apply inner gap: shrink each window by half_gap on each side
 +                let gapped_x = rect.x + half_gap;
 +                let gapped_y = rect.y + half_gap;
 +                let gapped_width = rect.width.saturating_sub(gap_inner as u16);
 +                let gapped_height = rect.height.saturating_sub(gap_inner as u16);
 -        for window_id in floating_ids {
 -            // Get the window's floating geometry from our state
 -            if let Some(win) = self.windows.get(&window_id) {
 -                let geom = win.floating_geometry;
 -                let adjusted_width = geom.width.saturating_sub(2 * border_width as u16);
 -                let adjusted_height = geom.height.saturating_sub(2 * border_width as u16);
 +                // Account for border width
 +                let final_width = gapped_width.saturating_sub(2 * border_width as u16);
 +                let final_height = gapped_height.saturating_sub(2 * border_width as u16);
                  tracing::debug!(
 -                    "apply_layout: FLOATING window={} at ({}, {}) size {}x{} (raising)",
 -                    window_id, geom.x, geom.y, adjusted_width.max(1), adjusted_height.max(1)
 +                    "apply_layout: TILED window={} at ({}, {}) size {}x{}",
 +                    window, gapped_x, gapped_y, final_width.max(1), final_height.max(1)
                  );
 -                // Configure geometry
                  self.conn.configure_window(
 -                    window_id,
 -                    geom.x,
 -                    geom.y,
 -                    adjusted_width.max(1),
 -                    adjusted_height.max(1),
 +                    *window,
 +                    gapped_x,
 +                    gapped_y,
 +                    final_width.max(1),
 +                    final_height.max(1),
                      border_width,
                  )?;
 +            }
 -                // Raise to top of stack (each subsequent window goes above the previous)
 -                let aux = ConfigureWindowAux::new().stack_mode(StackMode::ABOVE);
 -                self.conn.conn.configure_window(window_id, &aux)?;
 -            } else {
 -                tracing::warn!("apply_layout: floating window {} not in windows map!", window_id);
 +            // 2. Configure floating windows and stack them above tiled
 +            let floating_ids: Vec<XWindow> = ws.floating.clone();
++
 +            for window_id in floating_ids {
 +                // Get the window's floating geometry from our state
 +                if let Some(win) = self.windows.get(&window_id) {
 +                    let geom = win.floating_geometry;
 +                    let adjusted_width = geom.width.saturating_sub(2 * border_width as u16);
 +                    let adjusted_height = geom.height.saturating_sub(2 * border_width as u16);
++
 +                    tracing::debug!(
 +                        "apply_layout: FLOATING window={} at ({}, {}) size {}x{} (raising)",
 +                        window_id, geom.x, geom.y, adjusted_width.max(1), adjusted_height.max(1)
 +                    );
++
 +                    // Configure geometry
 +                    self.conn.configure_window(
 +                        window_id,
 +                        geom.x,
 +                        geom.y,
 +                        adjusted_width.max(1),
 +                        adjusted_height.max(1),
 +                        border_width,
 +                    )?;
++
 +                    // Raise to top of stack (each subsequent window goes above the previous)
 +                    let aux = ConfigureWindowAux::new().stack_mode(StackMode::ABOVE);
 +                    self.conn.conn.configure_window(window_id, &aux)?;
 +                } else {
 +                    tracing::warn!("apply_layout: floating window {} not in windows map!", window_id);
 +                }
+             }
+         }
          self.conn.flush()?;
          Ok(())
+     }
++
 +    /// Check if a workspace is currently visible (active on any monitor).
 +    pub fn is_workspace_visible(&self, ws_idx: usize) -> bool {
 +        self.monitors.iter().any(|m| m.active_workspace == ws_idx)
 +    }
++
 +    /// Get all currently visible workspace indices.
 +    pub fn visible_workspaces(&self) -> Vec<usize> {
 +        self.monitors.iter().map(|m| m.active_workspace).collect()
 +    }
+ }
  /// Check if window properties match rule criteria (case-insensitive substring match).

gar/src/x11/events.rsmodified

  use x11rb::connection::Connection as X11Connection;
  use x11rb::protocol::xproto::{
      ButtonPressEvent, ButtonReleaseEvent, ConfigureRequestEvent, ConfigureWindowAux, ConnectionExt,
 -    DestroyNotifyEvent, EventMask, KeyPressEvent, MapRequestEvent, ModMask, MotionNotifyEvent,
 -    StackMode, UnmapNotifyEvent,
 +    DestroyNotifyEvent, EnterNotifyEvent, EventMask, KeyPressEvent, MapRequestEvent, ModMask,
 +    MotionNotifyEvent, NotifyMode, StackMode, UnmapNotifyEvent,
  };
  use x11rb::protocol::Event;
              Event::MotionNotify(e) => self.handle_motion_notify(e)?,
              Event::KeyPress(e) => self.handle_key_press(e)?,
              Event::EnterNotify(e) => {
 -                tracing::trace!("EnterNotify for window {}", e.event);
 +                self.handle_enter_notify(e)?;
+             }
              Event::RandrScreenChangeNotify(_) => {
                  tracing::info!("RandR screen change detected, refreshing monitors");
          Ok(())
+     }
 +    fn handle_enter_notify(&mut self, event: EnterNotifyEvent) -> Result<()> {
 +        let window = event.event;
++
 +        // Ignore if we're in a drag operation
 +        if self.drag_state.is_some() {
 +            return Ok(());
 +        }
++
 +        // Suppress EnterNotify events that happen shortly after a pointer warp
 +        // This prevents feedback loops from mouse-follows-focus
 +        if self.last_warp.elapsed() < std::time::Duration::from_millis(50) {
 +            return Ok(());
 +        }
++
 +        // Ignore inferior (entering from a child window) and non-normal modes
 +        // Only handle "Normal" mode enters (actual mouse movement)
 +        if event.mode != NotifyMode::NORMAL {
 +            return Ok(());
 +        }
++
 +        // Only focus windows we manage
 +        if !self.windows.contains_key(&window) {
 +            return Ok(());
 +        }
++
 +        // Don't focus if already focused
 +        if self.focused_window == Some(window) {
 +            return Ok(());
 +        }
++
 +        tracing::debug!("Focus follows mouse: focusing window {}", window);
++
 +        // Regrab button on old focused window
 +        if let Some(old) = self.focused_window {
 +            self.conn.grab_button(old)?;
 +        }
++
 +        // Focus the new window (this will warp pointer back, but we'll suppress the resulting EnterNotify)
 +        self.set_focus(window)?;
 +        self.conn.ungrab_button(window)?;
++
 +        // Raise floating windows on focus
 +        if self.is_floating(window) {
 +            self.raise_window(window)?;
 +        }
++
 +        self.conn.flush()?;
 +        Ok(())
 +    }
++
      fn handle_key_press(&mut self, event: KeyPressEvent) -> Result<()> {
          let keycode = event.detail;
          let state = event.state;
                      self.close_window(window)?;
+                 }
+             }
 +            Action::ForceCloseWindow => {
 +                if let Some(window) = self.focused_window {
 +                    self.force_close_window(window)?;
 +                }
 +            }
              Action::Focus(direction) => {
                  if let Some(dir) = parse_direction(&direction) {
                      self.focus_direction(dir)?;
+     }
      fn close_window(&mut self, window: u32) -> Result<()> {
 +        // Verify we actually have a window to close
 +        if !self.windows.contains_key(&window) {
 +            tracing::warn!("close_window called on unmanaged window {}", window);
 +            return Ok(());
 +        }
++
          tracing::info!("Closing window {}", window);
          // Try graceful ICCCM close first
          if self.conn.supports_delete_window(window) {
 -            tracing::debug!("Window {} supports WM_DELETE_WINDOW, sending graceful close", window);
 +            tracing::info!("Window {} supports WM_DELETE_WINDOW, sending graceful close", window);
              self.conn.send_delete_window(window)?;
          } else {
 -            tracing::debug!("Window {} doesn't support WM_DELETE_WINDOW, using kill_client", window);
 +            tracing::info!("Window {} doesn't support WM_DELETE_WINDOW, using kill_client", window);
              self.conn.conn.kill_client(window)?;
+         }
          Ok(())
+     }
 +    fn force_close_window(&mut self, window: u32) -> Result<()> {
 +        tracing::info!("Force closing window {}", window);
 +        self.conn.conn.kill_client(window)?;
 +        self.conn.flush()?;
 +        Ok(())
 +    }
++
      fn focus_direction(&mut self, direction: Direction) -> Result<()> {
          let Some(focused) = self.focused_window else {
 -            return Ok(());
 +            // No focused window - try to focus adjacent monitor
 +            return self.focus_adjacent_monitor(direction);
          };
          let screen = self.screen_rect();
              self.conn.flush()?;
              tracing::debug!("Focused {:?} to window {}", direction, target);
 +        } else {
 +            // No adjacent window on this workspace - try adjacent monitor
 +            self.focus_adjacent_monitor(direction)?;
 +        }
++
 +        Ok(())
 +    }
++
 +    /// Focus the adjacent monitor in the given direction (does NOT wrap at edges)
 +    fn focus_adjacent_monitor(&mut self, direction: Direction) -> Result<()> {
 +        if self.monitors.len() <= 1 {
 +            return Ok(());
 +        }
++
 +        // Calculate target index WITHOUT wrapping
 +        let target_idx = match direction {
 +            Direction::Left => {
 +                if self.focused_monitor == 0 {
 +                    // At leftmost monitor - do nothing
 +                    return Ok(());
 +                }
 +                self.focused_monitor - 1
 +            }
 +            Direction::Right => {
 +                if self.focused_monitor >= self.monitors.len() - 1 {
 +                    // At rightmost monitor - do nothing
 +                    return Ok(());
 +                }
 +                self.focused_monitor + 1
 +            }
 +            // Up/Down could navigate if monitors are stacked vertically
 +            Direction::Up | Direction::Down => return Ok(()),
 +        };
++
 +        tracing::info!("Moving focus from monitor {} to {}", self.focused_monitor, target_idx);
 +        self.focused_monitor = target_idx;
++
 +        // Focus the active workspace on that monitor
 +        let workspace_idx = self.monitors[target_idx].active_workspace;
 +        self.focused_workspace = workspace_idx;
++
 +        // Focus a window on that workspace if any, or just warp to monitor center
 +        if let Some(window) = self.workspaces[workspace_idx].focused
 +            .or_else(|| self.workspaces[workspace_idx].floating.last().copied())
 +            .or_else(|| self.workspaces[workspace_idx].tree.first_window())
 +        {
 +            if let Some(old) = self.focused_window {
 +                self.conn.grab_button(old)?;
 +            }
 +            self.set_focus(window)?;
 +            self.conn.ungrab_button(window)?;
 +        } else {
 +            // No windows on target monitor - clear focus and warp to monitor center
 +            self.focused_window = None;
 +            self.warp_to_monitor(target_idx)?;
 +            tracing::debug!("No windows on monitor {}, warped to center", target_idx);
+         }
 +        self.conn.flush()?;
          Ok(())
+     }
+         }
          // Find which monitor owns this workspace
 -        let target_monitor = self.monitor_idx_for_workspace(idx);
+-
 -        // If the workspace is on a different monitor, just focus that monitor
 -        if let Some(mon_idx) = target_monitor {
 -            if mon_idx != self.focused_monitor {
 -                tracing::info!("Workspace {} is on monitor {}, switching focus", idx + 1, mon_idx);
 -                self.focused_monitor = mon_idx;
 -                self.focused_workspace = idx;
 -                self.monitors[mon_idx].active_workspace = idx;
 -                self.conn.set_current_desktop(idx as u32)?;
+-
 -                // Focus a window on the target workspace
 -                let ws = &self.workspaces[idx];
 -                if let Some(window) = ws.focused
 -                    .or_else(|| ws.floating.last().copied())
 -                    .or_else(|| ws.tree.first_window())
 -                {
 -                    self.set_focus(window)?;
 -                } else {
 -                    self.focused_window = None;
 -                }
 -                self.conn.flush()?;
 -                return Ok(());
 -            }
 -        }
 +        let target_monitor_idx = self.monitor_idx_for_workspace(idx).unwrap_or(0);
 +        let old_ws_on_target = self.monitors[target_monitor_idx].active_workspace;
 -        // Same monitor - switch its active workspace
 -        if idx == self.focused_workspace {
 +        // Already on this workspace?
 +        if idx == old_ws_on_target && target_monitor_idx == self.focused_monitor {
              return Ok(());
+         }
 -        tracing::info!("Switching to workspace {}", idx + 1);
 +        tracing::info!(
 +            "Switching to workspace {} on monitor {} (was ws {})",
 +            idx + 1, target_monitor_idx, old_ws_on_target + 1
 +        );
++
 +        // If switching to a different workspace on the target monitor, hide old/show new
 +        if idx != old_ws_on_target {
 +            // Hide windows on old workspace
 +            for window in self.workspaces[old_ws_on_target].all_windows() {
 +                self.conn.unmap_window(window)?;
 +            }
 -        // Hide all windows on current workspace (tiled + floating)
 -        for window in self.current_workspace().all_windows() {
 -            self.conn.unmap_window(window)?;
 +            // Update monitor's active workspace
 +            self.monitors[target_monitor_idx].active_workspace = idx;
++
 +            // Show windows on new workspace
 +            for window in self.workspaces[idx].all_windows() {
 +                self.conn.map_window(window)?;
 +            }
+         }
 -        // Update monitor's active workspace
 -        let old_ws = self.focused_workspace;
 +        // Update focused state
 +        self.focused_monitor = target_monitor_idx;
          self.focused_workspace = idx;
 -        self.monitors[self.focused_monitor].active_workspace = idx;
          // Update EWMH _NET_CURRENT_DESKTOP
          self.conn.set_current_desktop(idx as u32)?;
 -        // Show all windows on new workspace (tiled + floating)
 -        for window in self.current_workspace().all_windows() {
 -            self.conn.map_window(window)?;
 -        }
+-
 -        // Apply layout and update focus
 +        // Apply layout
          self.apply_layout()?;
 -        // Focus the workspace's focused window, preferring floating on top
 -        if let Some(window) = self
 -            .current_workspace()
 -            .focused
 -            .or_else(|| self.current_workspace().floating.last().copied())
 -            .or_else(|| self.current_workspace().tree.first_window())
 +        // Focus a window on the target workspace
 +        if let Some(window) = self.workspaces[idx].focused
 +            .or_else(|| self.workspaces[idx].floating.last().copied())
 +            .or_else(|| self.workspaces[idx].tree.first_window())
+         {
              self.set_focus(window)?;
              self.conn.ungrab_button(window)?;
              self.focused_window = None;
+         }
 -        tracing::debug!("Switched from workspace {} to {}", old_ws + 1, idx + 1);
          self.conn.flush()?;
          Ok(())
+     }
          let workspace_idx = self.monitors[target_idx].active_workspace;
          self.focused_workspace = workspace_idx;
 -        // Focus a window on that workspace if any
 +        // Focus a window on that workspace if any, or warp to monitor center
          if let Some(window) = self.workspaces[workspace_idx].focused
              .or_else(|| self.workspaces[workspace_idx].floating.last().copied())
              .or_else(|| self.workspaces[workspace_idx].tree.first_window())
              self.set_focus(window)?;
              self.conn.ungrab_button(window)?;
          } else {
 +            // No windows - warp to monitor center
              self.focused_window = None;
 +            self.warp_to_monitor(target_idx)?;
+         }
          self.conn.flush()?;