`83272c3`

Fix mouse clicks not working on floating windows

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

SHA: 83272c3ad7cdbbf2a7cad5b95d5e363e7c6f7686
Parents: 6051a9e
Tree: ae0b835

3 changed files

Status	File	+	-
M	`gar/src/core/mod.rs`	2	5
M	`gar/src/ipc/i3_server.rs`	29	7
M	`gar/src/x11/events.rs`	100	65

gar/src/core/mod.rsmodified

          self.current_workspace_mut().focused = Some(window);
          // Ungrab buttons on new focused window (allow clicks through)
 -        // But keep grabs on floating windows so we can detect edge resize clicks
 -        let is_floating = self.windows.get(&window).map_or(false, |w| w.floating);
 -        if !is_floating {
 -            let _ = self.conn.ungrab_button(window);
 -        }
 +        // Edge resize detection uses POINTER_MOTION events, not button grabs
 +        let _ = self.conn.ungrab_button(window);
          // Update focus history - move window to front
          self.focus_history.retain(|&w| w != window);

gar/src/ipc/i3_server.rsmodified

      /// Process incoming requests from all clients.
      /// Returns a list of (client_index, message) pairs.
 -    /// Also cleans up stale/disconnected clients.
 +    /// Note: Stale/disconnected clients are cleaned up AFTER requests are processed
 +    /// to avoid index invalidation issues.
      pub fn poll_requests(&mut self) -> Vec<(usize, I3Message)> {
          let mut requests = Vec::new();
 -        let mut to_remove = Vec::new();
          for (i, client) in self.clients.iter_mut().enumerate() {
              match client.read_message() {
                  ReadResult::Message(msg) => requests.push((i, msg)),
 +                ReadResult::Disconnected | ReadResult::WouldBlock => {}
 +            }
 +        }
++
 +        requests
 +    }
++
 +    /// Clean up disconnected and stale clients.
 +    /// Call this AFTER processing requests to avoid index invalidation.
 +    pub fn cleanup_clients(&mut self) {
 +        let mut to_remove = Vec::new();
++
 +        for (i, client) in self.clients.iter_mut().enumerate() {
 +            // Try a non-destructive check - peek for disconnection
 +            match client.read_message() {
                  ReadResult::Disconnected => to_remove.push(i),
                  ReadResult::WouldBlock => {
 -                    // Check if this client is stale (never sent anything, no subscriptions)
                      if client.is_stale() {
                          tracing::debug!("Cleaning up stale i3 IPC client (no activity for {:?})", IDLE_CLIENT_TIMEOUT);
                          to_remove.push(i);
+                     }
+                 }
 +                ReadResult::Message(_) => {
 +                    // Message will be processed next poll cycle
 +                }
+             }
+         }
          for i in to_remove.into_iter().rev() {
              self.clients.remove(i);
+         }
+-
 -        requests
+     }
      /// Send a response to a specific client.
      /// Broadcast a workspace event to all subscribed clients.
      pub fn broadcast_workspace_event(&mut self, json: &str) {
          let mut disconnected = Vec::new();
 +        let subscribed_count = self.clients.iter().filter(|c| c.is_subscribed("workspace")).count();
 +        tracing::debug!("Broadcasting workspace event to {} subscribed clients (of {} total)", subscribed_count, self.clients.len());
          for (i, client) in self.clients.iter_mut().enumerate() {
              if client.is_subscribed("workspace") {
 -                if client.send_event(EventType::Workspace, json).is_err() {
 -                    disconnected.push(i);
 +                match client.send_event(EventType::Workspace, json) {
 +                    Ok(_) => tracing::debug!("Sent workspace event to client {}", i),
 +                    Err(e) => {
 +                        tracing::warn!("Failed to send workspace event to client {}: {}", i, e);
 +                        disconnected.push(i);
 +                    }
+                 }
+             }
+         }
          // Remove failed clients
          for i in disconnected.into_iter().rev() {
 +            tracing::debug!("Removing disconnected client {}", i);
              self.clients.remove(i);
+         }
+     }

gar/src/x11/events.rsmodified

              // Focus the first window
              if let Some(window) = self.focused_window {
                  self.set_focus(window, true)?;
 -                // Ungrab button for click-through (unless floating - keep for edge resize)
 -                if !self.is_floating(window) {
 -                    self.conn.ungrab_button(window)?;
 -                }
+             }
              tracing::info!("Adopted {} existing windows", adopted);
+         }
          tracing::debug!("Focus follows mouse: focusing window {}", window);
 -        // Regrab button on old focused window (unless floating - keep for edge resize)
 -        if let Some(old) = self.focused_window {
 -            if !self.is_floating(old) {
 -                self.conn.grab_button(old)?;
 -            }
 -        }
+-
          // Focus the new window (no warp - mouse enter)
 +        // set_focus handles grab/ungrab for old and new windows
          self.set_focus(window, false)?;
 -        // Ungrab button for click-through (unless floating - keep for edge resize)
 -        if !self.is_floating(window) {
 -            self.conn.ungrab_button(window)?;
 -        }
+-
          // Raise floating windows on focus
          if self.is_floating(window) {
              self.raise_window(window)?;
          let geometries = self.current_workspace().tree.calculate_geometries(screen);
          if let Some(target) = Node::find_adjacent(&geometries, focused, direction) {
 -            // Regrab button on old window
 -            self.conn.grab_button(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.ungrab_button(target)?;
              self.conn.flush()?;
              tracing::debug!("Focused {:?} to window {}", direction, target);
              .or_else(|| self.workspaces[workspace_idx].floating.last().copied())
              .or_else(|| self.workspaces[workspace_idx].tree.first_window())
+         {
 -            // Regrab on old window (unless floating)
 -            if let Some(old) = self.focused_window {
 -                if !self.is_floating(old) {
 -                    self.conn.grab_button(old)?;
 -                }
 -            }
 +            // set_focus handles grab/ungrab for old and new windows
              self.set_focus(window, true)?;
 -            // Ungrab on new window (unless floating - keep for edge resize)
 -            if !self.is_floating(window) {
 -                self.conn.ungrab_button(window)?;
 -            }
          } else {
              // No windows on target monitor - clear focus and warp to monitor center
              self.focused_window = None;
          Ok(())
+     }
 +    /// Execute an i3-compatible command (from IPC RUN_COMMAND).
 +    /// Returns true if the command was executed successfully.
 +    fn execute_i3_command(&mut self, cmd: &str) -> bool {
 +        let cmd = cmd.trim();
 +        tracing::debug!("Executing i3 command: {}", cmd);
++
 +        // Parse "workspace <name|number>" command
 +        // Use switch_workspace_impl with warp_pointer=false since IPC commands
 +        // (like clicks from the bar) shouldn't move the mouse cursor
 +        if let Some(rest) = cmd.strip_prefix("workspace ") {
 +            let rest = rest.trim();
 +            // Try to parse as number first
 +            if let Ok(num) = rest.parse::<usize>() {
 +                // Workspace numbers are 1-indexed in i3
 +                let idx = num.saturating_sub(1);
 +                if idx < self.workspaces.len() {
 +                    if let Err(e) = self.switch_workspace_impl(idx, false) {
 +                        tracing::warn!("Failed to switch workspace: {}", e);
 +                        return false;
 +                    }
 +                    return true;
 +                }
 +            }
 +            // Try to match by name
 +            if let Some(idx) = self.workspaces.iter().position(|ws| ws.name == rest) {
 +                if let Err(e) = self.switch_workspace_impl(idx, false) {
 +                    tracing::warn!("Failed to switch workspace: {}", e);
 +                    return false;
 +                }
 +                return true;
 +            }
 +            tracing::warn!("Workspace not found: {}", rest);
 +            return false;
 +        }
++
 +        // Parse "workspace number <n>" command
 +        if let Some(rest) = cmd.strip_prefix("workspace number ") {
 +            if let Ok(num) = rest.trim().parse::<usize>() {
 +                let idx = num.saturating_sub(1);
 +                if idx < self.workspaces.len() {
 +                    if let Err(e) = self.switch_workspace_impl(idx, false) {
 +                        tracing::warn!("Failed to switch workspace: {}", e);
 +                        return false;
 +                    }
 +                    return true;
 +                }
 +            }
 +            return false;
 +        }
++
 +        tracing::debug!("Unknown i3 command: {}", cmd);
 +        false
 +    }
++
      /// Switch to workspace using i3-style behavior:
      /// - If workspace is visible on another monitor, focus moves to that monitor
      /// - If workspace is not visible, it appears on the current monitor
 -    fn switch_workspace(&mut self, idx: usize) -> Result<()> {
 +    /// If warp_pointer is false, the mouse cursor is not moved (for IPC commands).
 +    fn switch_workspace_impl(&mut self, idx: usize, warp_pointer: bool) -> Result<()> {
          if idx >= self.workspaces.len() {
              return Ok(());
+         }
              // Update EWMH
              self.conn.set_current_desktop(idx as u32)?;
 -            // Warp pointer to that monitor
 -            let monitor_geom = self.monitors[monitor_idx].geometry;
 -            let center_x = monitor_geom.x + (monitor_geom.width as i16 / 2);
 -            let center_y = monitor_geom.y + (monitor_geom.height as i16 / 2);
 -            self.conn.warp_pointer(center_x, center_y)?;
 -            self.last_warp = std::time::Instant::now();
 +            // Warp pointer to that monitor (only if requested)
 +            if warp_pointer {
 +                let monitor_geom = self.monitors[monitor_idx].geometry;
 +                let center_x = monitor_geom.x + (monitor_geom.width as i16 / 2);
 +                let center_y = monitor_geom.y + (monitor_geom.height as i16 / 2);
 +                self.conn.warp_pointer(center_x, center_y)?;
 +                self.last_warp = std::time::Instant::now();
 +            }
              // Focus a window on that 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, true)?;
 +                self.set_focus(window, warp_pointer)?;
              } else {
                  self.focused_window = None;
                  self.conn.set_active_window(None)?;
                  .or_else(|| self.workspaces[idx].floating.last().copied())
                  .or_else(|| self.workspaces[idx].tree.first_window())
+             {
 -                self.set_focus(window, true)?;
 +                self.set_focus(window, warp_pointer)?;
              } else {
 -                // No windows - warp to center of monitor
 +                // No windows - warp to center of monitor (only if requested)
                  self.focused_window = None;
                  self.conn.set_active_window(None)?;
 -                let monitor_geom = self.monitors[current_monitor].geometry;
 -                let center_x = monitor_geom.x + (monitor_geom.width as i16 / 2);
 -                let center_y = monitor_geom.y + (monitor_geom.height as i16 / 2);
 -                self.conn.warp_pointer(center_x, center_y)?;
 -                self.last_warp = std::time::Instant::now();
 +                if warp_pointer {
 +                    let monitor_geom = self.monitors[current_monitor].geometry;
 +                    let center_x = monitor_geom.x + (monitor_geom.width as i16 / 2);
 +                    let center_y = monitor_geom.y + (monitor_geom.height as i16 / 2);
 +                    self.conn.warp_pointer(center_x, center_y)?;
 +                    self.last_warp = std::time::Instant::now();
 +                }
+             }
+         }
          Ok(())
+     }
 +    /// Switch to workspace with pointer warping (default behavior for keybinds).
 +    fn switch_workspace(&mut self, idx: usize) -> Result<()> {
 +        self.switch_workspace_impl(idx, true)
 +    }
++
      fn move_to_workspace(&mut self, idx: usize) -> Result<()> {
          if idx >= self.workspaces.len() {
              return Ok(());
              .or_else(|| self.workspaces[workspace_idx].floating.last().copied())
              .or_else(|| self.workspaces[workspace_idx].tree.first_window())
+         {
 -            // Regrab on old window (unless floating)
 -            if let Some(old) = self.focused_window {
 -                if !self.is_floating(old) {
 -                    self.conn.grab_button(old)?;
 -                }
 -            }
 +            // set_focus handles grab/ungrab for old and new windows
              self.set_focus(window, true)?;
 -            // Ungrab on new window (unless floating - keep for edge resize)
 -            if !self.is_floating(window) {
 -                self.conn.ungrab_button(window)?;
 -            }
          } else {
              // No windows - warp to monitor center
              self.focused_window = None;
          let next_window = floating[next_idx];
 -        // Regrab button on old focused window (unless it's floating)
 -        if let Some(old) = self.focused_window {
 -            if !self.is_floating(old) {
 -                self.conn.grab_button(old)?;
 -            }
 -        }
+-
          // Focus and raise the next floating window (keyboard action, warp pointer)
 -        // Keep button grabbed on floating windows for edge resize
 +        // set_focus handles grab/ungrab for old and new windows
          self.set_focus(next_window, true)?;
          self.raise_window(next_window)?;
              match MessageType::from_u32(msg_type) {
                  Some(MessageType::GetWorkspaces) => {
                      let workspaces = self.build_i3_workspaces();
 +                    let focused_ws: Vec<_> = workspaces.iter().filter(|w| w.focused).map(|w| &w.name).collect();
 +                    tracing::debug!("GET_WORKSPACES: returning {} workspaces, focused: {:?}", workspaces.len(), focused_ws);
                      let json = build_workspaces_json(&workspaces);
                      if let Some(ref mut i3_ipc) = self.i3_ipc_server {
                          i3_ipc.send_response(client_idx, msg_type, &json);
+                     }
+                 }
                  Some(MessageType::RunCommand) => {
 -                    // Return success for now - we could parse and execute i3 commands later
 -                    let json = r#"[{"success":true}]"#;
 +                    // Parse and execute i3-compatible commands
 +                    let cmd_str = msg.payload_str().unwrap_or("");
 +                    let success = self.execute_i3_command(cmd_str);
 +                    let json = if success {
 +                        r#"[{"success":true}]"#
 +                    } else {
 +                        r#"[{"success":false,"error":"command failed"}]"#
 +                    };
                      if let Some(ref mut i3_ipc) = self.i3_ipc_server {
                          i3_ipc.send_response(client_idx, msg_type, json);
+                     }
+             }
+         }
 +        // Clean up disconnected/stale clients AFTER processing requests
 +        // to avoid index invalidation during send_response
 +        if let Some(ref mut i3_ipc) = self.i3_ipc_server {
 +            i3_ipc.cleanup_clients();
 +        }
++
          Ok(())
+     }