`c7ea6ce`

multimonitor: fix focus tracking and spawn on mouse position

Authored by

espadonne 3 months ago

SHA: c7ea6ce4dc83b60001cb128e07a2d45dfeb26e83
Parents: 066e8f2
Tree: 5b6b8a0

3 changed files

Status	File	+	-
M	`gar/src/core/mod.rs`	34	0
M	`gar/src/x11/connection.rs`	6	0
M	`gar/src/x11/events.rs`	9	3

gar/src/core/mod.rsmodified

          self.monitors.iter().position(|m| m.active_workspace == workspace_idx)
+     }
 +    /// Find the monitor index containing a point (x, y in root window coordinates).
 +    pub fn monitor_idx_at_point(&self, x: i16, y: i16) -> usize {
 +        self.monitors
 +            .iter()
 +            .position(|m| {
 +                let g = &m.geometry;
 +                x >= g.x && x < g.x + g.width as i16 &&
 +                y >= g.y && y < g.y + g.height as i16
 +            })
 +            .unwrap_or(self.focused_monitor) // Fallback to focused monitor
 +    }
++
 +    /// Get the workspace that should receive new windows (based on mouse position).
 +    /// This supports spawning windows on the monitor where the mouse is.
 +    pub fn workspace_for_new_window(&self) -> usize {
 +        if let Ok((x, y)) = self.conn.get_pointer_position() {
 +            let monitor_idx = self.monitor_idx_at_point(x, y);
 +            self.monitors[monitor_idx].active_workspace
 +        } else {
 +            self.focused_workspace
 +        }
 +    }
++
      /// Calculate struts (reserved space for panels/docks) for a monitor.
      fn calculate_struts(&self, _monitor_idx: usize) -> (u32, u32, u32, u32) {
          if self.config.bar_height > 0 {
+             }
+         }
 +        // Update focused workspace and monitor based on the window's workspace
 +        // This is critical for focus-follows-mouse to work correctly with multimonitor
 +        if let Some(win) = self.windows.get(&window) {
 +            let ws_idx = win.workspace;
 +            self.focused_workspace = ws_idx;
 +            // Update focused_monitor to the monitor displaying this workspace (if visible)
 +            if let Some(monitor_idx) = self.monitor_idx_for_workspace(ws_idx) {
 +                self.focused_monitor = monitor_idx;
 +            }
 +        }
++
          self.focused_window = Some(window);
          self.current_workspace_mut().focused = Some(window);

gar/src/x11/connection.rsmodified

          Ok(())
+     }
 +    /// Get the current mouse pointer position (root window coordinates).
 +    pub fn get_pointer_position(&self) -> Result<(i16, i16), Error> {
 +        let reply = self.conn.query_pointer(self.root)?.reply()?;
 +        Ok((reply.root_x, reply.root_y))
 +    }
++
      /// Set window border width and color.
      pub fn set_border(&self, window: Window, width: u32, color: u32) -> Result<(), Error> {
          let aux = ChangeWindowAttributesAux::new().border_pixel(color);

gar/src/x11/events.rsmodified

          // Check window rules first
          let rule_actions = self.check_rules(window);
 -        // Determine target workspace (rule or current)
 -        let target_workspace = rule_actions.workspace.unwrap_or(self.focused_workspace + 1);
 -        let target_idx = target_workspace.saturating_sub(1).min(self.workspaces.len() - 1);
 +        // Determine target workspace: rule > mouse position > focused
 +        // This makes windows spawn on the monitor where the mouse is
 +        let target_idx = if let Some(ws) = rule_actions.workspace {
 +            // Rule specifies workspace (1-indexed)
 +            ws.saturating_sub(1).min(self.workspaces.len() - 1)
 +        } else {
 +            // Use workspace of monitor under mouse pointer
 +            self.workspace_for_new_window()
 +        };
          // Determine if window should float (rule > ICCCM/EWMH hints)
          let should_float = rule_actions.floating.unwrap_or_else(|| self.conn.should_float(window));