`77eff09`

Fix picom v12+ startup and improve cursor handling

- Add --backend glx to picom commands (required for v12+, no default)
- Add cursor_move (fleur) for floating window drag operations
- Add clear_window_cursor() to prevent grab/window cursor conflicts
- Pass appropriate cursor to grab_pointer() during drag/resize
- Restore edge cursor after drag release
- Add cursor_for_edge() helper for resize cursor selection

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

SHA: 77eff09dfa9e861cb10ce3120d1c4cd01193596b
Parents: 9239558
Tree: dacf2c7

4 changed files

Status	File	+	-
M	`gar-session.sh`	2	1
M	`gar/src/x11/connection.rs`	21	6
M	`gar/src/x11/events.rs`	86	37
M	`start-gar.sh`	2	1

gar-session.shmodified

  #   --output HDMI-1 --mode 2560x1440 --pos 1920x0
  # Launch compositor before WM (for proper screen repainting)
 +# --backend glx is required for picom v12+ (no longer has a default)
  if command -v picom &> /dev/null; then
 -    picom -b --use-ewmh-active-win &
 +    picom -b --backend glx --use-ewmh-active-win &
      sleep 0.1
  fi

gar/src/x11/connection.rsmodified

      // Struts (reserved screen areas for docks/panels)
      pub net_wm_strut: Atom,
      pub net_wm_strut_partial: Atom,
 -    // Cursors for resize operations
 +    // Cursors for resize/move operations
      pub cursor_normal: u32,
 +    pub cursor_move: u32,
      pub cursor_top_left: u32,
      pub cursor_top_right: u32,
      pub cursor_bottom_left: u32,
          // Create cursors for pointer and resize operations
          let (
              cursor_normal,
 +            cursor_move,
              cursor_top_left,
              cursor_top_right,
              cursor_bottom_left,
              net_wm_strut,
              net_wm_strut_partial,
              cursor_normal,
 +            cursor_move,
              cursor_top_left,
              cursor_top_right,
              cursor_bottom_left,
+     }
      /// Create all cursors used by the window manager.
 -    fn create_cursors(conn: &RustConnection) -> Result<(u32, u32, u32, u32, u32, u32, u32, u32, u32), Error> {
 +    fn create_cursors(conn: &RustConnection) -> Result<(u32, u32, u32, u32, u32, u32, u32, u32, u32, u32), Error> {
          // Open the cursor font
          let font: Font = conn.generate_id()?;
          conn.open_font(font, b"cursor")?;
          // Cursor glyph numbers from the cursor font:
 -        // left_ptr = 68, top_left_corner = 134, top_right_corner = 136
 +        // left_ptr = 68, fleur = 52, top_left_corner = 134, top_right_corner = 136
          // bottom_left_corner = 12, bottom_right_corner = 14
          // left_side = 70, right_side = 96, top_side = 138, bottom_side = 16
          };
          let cursor_normal = create(68)?;       // left_ptr
 +        let cursor_move = create(52)?;         // fleur (move cursor)
          let cursor_top_left = create(134)?;    // top_left_corner
          let cursor_top_right = create(136)?;   // top_right_corner
          let cursor_bottom_left = create(12)?;  // bottom_left_corner
          Ok((
              cursor_normal,
 +            cursor_move,
              cursor_top_left,
              cursor_top_right,
              cursor_bottom_left,
      /// Set the cursor for a window.
      pub fn set_window_cursor(&self, window: Window, cursor: u32) -> Result<(), Error> {
 +        tracing::debug!("set_window_cursor: window={} cursor={}", window, cursor);
          let change = ChangeWindowAttributesAux::new().cursor(cursor);
          self.conn.change_window_attributes(window, &change)?;
          Ok(())
+     }
 +    /// Clear the cursor attribute from a window, letting the application's cursor show.
 +    pub fn clear_window_cursor(&self, window: Window) -> Result<(), Error> {
 +        tracing::debug!("clear_window_cursor: window={}", window);
 +        let change = ChangeWindowAttributesAux::new().cursor(x11rb::NONE);
 +        self.conn.change_window_attributes(window, &change)?;
 +        Ok(())
 +    }
++
      /// Set input focus to a window.
      pub fn set_focus(&self, window: Window) -> Result<(), Error> {
          self.conn
          Ok(())
+     }
 -    /// Grab the pointer for drag operations.
 -    pub fn grab_pointer(&self, _window: Window) -> Result<(), Error> {
 +    /// Grab the pointer for drag operations with optional cursor override.
 +    pub fn grab_pointer(&self, cursor: Option<u32>) -> Result<(), Error> {
 +        let cursor_id = cursor.unwrap_or(x11rb::NONE);
          let reply = self.conn.grab_pointer(
              false,
              self.root,
              GrabMode::ASYNC,
              GrabMode::ASYNC,
              x11rb::NONE,
 -            x11rb::NONE,
 +            cursor_id,
              CURRENT_TIME,
          )?.reply()?;
          tracing::debug!("grab_pointer result: {:?}", reply.status);

gar/src/x11/events.rsmodified

              let should_float = rule_actions.floating.unwrap_or_else(|| self.conn.should_float(window));
              // Subscribe to events on the window
 -            // Floating windows get POINTER_MOTION for edge resize cursors
 +            // Floating windows get POINTER_MOTION for edge resize cursor feedback
              let base_events = EventMask::ENTER_WINDOW
                  | EventMask::FOCUS_CHANGE
                  | EventMask::PROPERTY_CHANGE
+     }
      pub fn handle_event(&mut self, event: Event) -> Result<()> {
 +        // Log events to debug cursor flicker
 +        match &event {
 +            Event::MotionNotify(e) => {
 +                tracing::info!("MOTION: window={} pos=({},{})", e.event, e.root_x, e.root_y);
 +            }
 +            Event::EnterNotify(e) => {
 +                tracing::info!("ENTER: window={}", e.event);
 +            }
 +            Event::ButtonPress(e) => {
 +                tracing::info!("BUTTON: window={} btn={}", e.event, e.detail);
 +            }
 +            _ => {}
 +        }
          match event {
              Event::MapRequest(e) => self.handle_map_request(e)?,
              Event::ConfigureRequest(e) => self.handle_configure_request(e)?,
          let should_float = rule_actions.floating.unwrap_or_else(|| self.conn.should_float(window));
          // Subscribe to events on the window
 -        // Floating windows get POINTER_MOTION for edge resize cursors
 +        // Floating windows get POINTER_MOTION for edge resize cursor feedback
          let base_events = EventMask::ENTER_WINDOW
              | EventMask::FOCUS_CHANGE
              | EventMask::PROPERTY_CHANGE
                      start_y: event.root_y,
                      start_geometry: geometry,
                  });
 -                // Grab pointer for motion events
 -                self.conn.grab_pointer(target)?;
 +                // Clear window cursor to prevent conflict with grab cursor
 +                self.conn.clear_window_cursor(target)?;
 +                // Grab pointer for motion events (use fleur/move cursor)
 +                self.conn.grab_pointer(Some(self.conn.cursor_move))?;
                  return Ok(());
              } else if event.detail == 3 {
                  // Mod+Button3 = Resize (quadrant-based edge detection)
                      start_geometry: geometry,
                      edge,
                  });
 -                self.conn.grab_pointer(target)?;
 +                // Clear window cursor to prevent conflict with grab cursor
 +                self.conn.clear_window_cursor(target)?;
 +                let cursor = self.cursor_for_edge(edge);
 +                self.conn.grab_pointer(Some(cursor))?;
                  return Ok(());
+             }
+         }
                      edge,
                  });
                  tracing::debug!("Grabbing pointer for resize, geometry={:?}", geometry);
 -                self.conn.grab_pointer(window)?;
 +                // Clear window cursor to prevent conflict with grab cursor
 +                self.conn.clear_window_cursor(window)?;
 +                let cursor = self.cursor_for_edge(edge);
 +                self.conn.grab_pointer(Some(cursor))?;
                  self.conn.flush()?;
                  return Ok(());
+             }
      fn handle_button_release(&mut self, event: ButtonReleaseEvent) -> Result<()> {
          tracing::debug!("ButtonRelease: button={}, window={}, in_drag={}",
              event.detail, event.event, self.drag_state.is_some());
 -        if self.drag_state.is_some() {
 +        if let Some(drag) = self.drag_state.take() {
              tracing::debug!("Ending drag operation");
 -            self.drag_state = None;
              self.conn.ungrab_pointer()?;
              self.conn.flush()?;
++
 +            // Restore edge cursor if pointer is still over the dragged floating window
 +            let window = match drag {
 +                DragState::Move { window, .. } | DragState::Resize { window, .. } => window,
 +            };
 +            if self.is_floating(window) {
 +                // Use the release event position to update cursor
 +                self.update_edge_cursor(window, event.root_x, event.root_y)?;
 +            }
+         }
          Ok(())
+     }
              let is_managed = self.windows.contains_key(&window);
              let is_float = is_managed && self.is_floating(window);
 +            // Debug: log all motion events to track down cursor flicker
 +            tracing::debug!(
 +                "MotionNotify: window={} managed={} floating={} root_xy=({},{}) event_xy=({},{})",
 +                window, is_managed, is_float, event.root_x, event.root_y, event.event_x, event.event_y
 +            );
++
              if is_float {
 -                tracing::trace!(
 -                    "Motion on floating window {}: root({},{}) event({},{})",
 -                    window, event.root_x, event.root_y, event.event_x, event.event_y
 -                );
                  self.update_edge_cursor(window, event.root_x, event.root_y)?;
+             }
              return Ok(());
      /// Handle pointer motion for edge cursor changes on floating windows.
      fn update_edge_cursor(&mut self, window: u32, root_x: i16, root_y: i16) -> Result<()> {
          if !self.is_floating(window) {
 -            // Not a floating window, ensure cursor is normal
 -            if self.current_edge_cursor.is_some() {
 -                self.conn.set_window_cursor(window, self.conn.cursor_normal)?;
 +            // Not a floating window, clear any edge cursor state
 +            if let Some((old_window, old_edge)) = self.current_edge_cursor {
 +                if old_edge != ResizeEdge::None {
 +                    self.conn.clear_window_cursor(old_window)?;
 +                }
                  self.current_edge_cursor = None;
+             }
              return Ok(());
              return Ok(()); // No change needed
+         }
 -        // Get the appropriate cursor for this edge
 -        let cursor = match edge {
 -            ResizeEdge::TopLeft => self.conn.cursor_top_left,
 -            ResizeEdge::Top => self.conn.cursor_top,
 -            ResizeEdge::TopRight => self.conn.cursor_top_right,
 -            ResizeEdge::Left => self.conn.cursor_left,
 -            ResizeEdge::Right => self.conn.cursor_right,
 -            ResizeEdge::BottomLeft => self.conn.cursor_bottom_left,
 -            ResizeEdge::Bottom => self.conn.cursor_bottom,
 -            ResizeEdge::BottomRight => self.conn.cursor_bottom_right,
 -            ResizeEdge::None => self.conn.cursor_normal,
 -        };
+-
 -        // Set cursor on the window
 -        self.conn.set_window_cursor(window, cursor)?;
 -        self.conn.flush()?;
+-
          if edge != ResizeEdge::None {
 -            tracing::debug!("Set resize cursor {:?} for floating window {} edge", edge, window);
 +            let cursor = match edge {
 +                ResizeEdge::TopLeft => self.conn.cursor_top_left,
 +                ResizeEdge::Top => self.conn.cursor_top,
 +                ResizeEdge::TopRight => self.conn.cursor_top_right,
 +                ResizeEdge::Left => self.conn.cursor_left,
 +                ResizeEdge::Right => self.conn.cursor_right,
 +                ResizeEdge::BottomLeft => self.conn.cursor_bottom_left,
 +                ResizeEdge::Bottom => self.conn.cursor_bottom,
 +                ResizeEdge::BottomRight => self.conn.cursor_bottom_right,
 +                ResizeEdge::None => unreachable!(),
 +            };
 +            self.conn.set_window_cursor(window, cursor)?;
 +            self.conn.flush()?;
              self.current_edge_cursor = Some((window, edge));
 +        } else if let Some((old_window, old_edge)) = current {
 +            if old_edge != ResizeEdge::None {
 +                self.conn.clear_window_cursor(old_window)?;
 +                self.conn.flush()?;
 +            }
 +            self.current_edge_cursor = Some((window, ResizeEdge::None));
          } else {
 -            self.current_edge_cursor = None;
 +            self.current_edge_cursor = Some((window, ResizeEdge::None));
+         }
          Ok(())
              .unwrap_or(false)
+     }
 +    /// Get the appropriate cursor for a resize edge.
 +    fn cursor_for_edge(&self, edge: ResizeEdge) -> u32 {
 +        match edge {
 +            ResizeEdge::TopLeft => self.conn.cursor_top_left,
 +            ResizeEdge::Top => self.conn.cursor_top,
 +            ResizeEdge::TopRight => self.conn.cursor_top_right,
 +            ResizeEdge::Left => self.conn.cursor_left,
 +            ResizeEdge::Right => self.conn.cursor_right,
 +            ResizeEdge::BottomLeft => self.conn.cursor_bottom_left,
 +            ResizeEdge::Bottom => self.conn.cursor_bottom,
 +            ResizeEdge::BottomRight => self.conn.cursor_bottom_right,
 +            ResizeEdge::None => self.conn.cursor_normal,
 +        }
 +    }
++
      fn get_floating_geometry(&self, window: u32) -> Rect {
          self.windows
              .get(&window)
                  win.floating = false;
+             }
 -            // Remove POINTER_MOTION event mask (no longer need edge detection)
 +            // Standard event mask for tiled window
              self.conn.select_input(
                  window,
                  EventMask::ENTER_WINDOW
              // Clear edge cursor state if this window had one
              if self.current_edge_cursor.map(|(w, _)| w) == Some(window) {
 -                self.conn.set_window_cursor(window, self.conn.cursor_normal)?;
 +                self.conn.clear_window_cursor(window)?;
                  self.current_edge_cursor = None;
+             }
                  win.floating_geometry = geometry;
+             }
 -            // Add POINTER_MOTION event mask for edge detection
 +            // Event mask for floating window (includes POINTER_MOTION for edge cursor)
              self.conn.select_input(
                  window,
                  EventMask::ENTER_WINDOW

start-gar.shmodified

  # Launch compositor before WM (for proper screen repainting)
  # --use-ewmh-active-win uses _NET_ACTIVE_WINDOW for focus detection
 +# --backend glx is required for picom v12+ (no longer has a default)
  if command -v picom > /dev/null 2>&1; then
 -    picom -b --use-ewmh-active-win &
 +    picom -b --backend glx --use-ewmh-active-win &
      sleep 0.1
  fi