`9239558`

Add floating window move/resize with mod+drag and edge hover

- Support both Alt and Super mod keys for drag operations
- Add resize cursors for all edges and corners
- Change cursor on hover near floating window edges
- Click and drag edges to resize without mod key
- Keep button grabs on floating windows for edge detection

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

SHA: 923955868720226f505166ce5205a2245b99900b
Parents: 34fe404
Tree: 9558cb8

3 changed files

Status	File	+	-
M	`gar/src/core/mod.rs`	8	1
M	`gar/src/x11/connection.rs`	115	32
M	`gar/src/x11/events.rs`	274	45

gar/src/core/mod.rsmodified

      pub focus_history: Vec<XWindow>,
      /// Struts from dock windows (status bars) - maps window ID to strut
      pub dock_struts: HashMap<XWindow, Strut>,
 +    /// Current edge being displayed (for cursor changes on floating window edges)
 +    pub current_edge_cursor: Option<(XWindow, crate::x11::events::ResizeEdge)>,
+ }
  impl WindowManager {
              frames: FrameManager::new(),
              focus_history: Vec::new(),
              dock_struts: HashMap::new(),
 +            current_edge_cursor: None,
          })
+     }
          self.current_workspace_mut().focused = Some(window);
          // Ungrab buttons on new focused window (allow clicks through)
 -        let _ = self.conn.ungrab_button(window);
 +        // 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);
 +        }
          // Update focus history - move window to front
          self.focus_history.retain(|&w| w != window);

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
 +    pub cursor_normal: u32,
 +    pub cursor_top_left: u32,
 +    pub cursor_top_right: u32,
 +    pub cursor_bottom_left: u32,
 +    pub cursor_bottom_right: u32,
 +    pub cursor_left: u32,
 +    pub cursor_right: u32,
 +    pub cursor_top: u32,
 +    pub cursor_bottom: u32,
+ }
  impl Connection {
          let net_wm_strut = conn.intern_atom(false, b"_NET_WM_STRUT")?.reply()?.atom;
          let net_wm_strut_partial = conn.intern_atom(false, b"_NET_WM_STRUT_PARTIAL")?.reply()?.atom;
 +        // Create cursors for pointer and resize operations
 +        let (
 +            cursor_normal,
 +            cursor_top_left,
 +            cursor_top_right,
 +            cursor_bottom_left,
 +            cursor_bottom_right,
 +            cursor_left,
 +            cursor_right,
 +            cursor_top,
 +            cursor_bottom,
 +        ) = Self::create_cursors(&conn)?;
++
          tracing::info!(
              "Connected to X server, screen {}x{}",
              screen_width,
              net_wm_bypass_compositor,
              net_wm_strut,
              net_wm_strut_partial,
 +            cursor_normal,
 +            cursor_top_left,
 +            cursor_top_right,
 +            cursor_bottom_left,
 +            cursor_bottom_right,
 +            cursor_left,
 +            cursor_right,
 +            cursor_top,
 +            cursor_bottom,
          })
+     }
+     }
      pub fn become_wm(&self) -> Result<(), Error> {
 -        // Create a normal pointer cursor for the root window
 -        // This prevents the ugly X cursor when no windows are focused
 -        let cursor = self.create_cursor()?;
+-
          // Set root window background to black, cursor, and subscribe to events
          // The background ensures old window pixels are cleared when windows close
          let change = ChangeWindowAttributesAux::new()
                      | EventMask::PROPERTY_CHANGE,
+             )
              .background_pixel(self.screen().black_pixel)
 -            .cursor(cursor);
 +            .cursor(self.cursor_normal);
          let result = self
              .conn
+         }
+     }
 -    /// Create a left pointer cursor from the cursor font.
 -    fn create_cursor(&self) -> Result<u32, Error> {
 +    /// Create all cursors used by the window manager.
 +    fn create_cursors(conn: &RustConnection) -> Result<(u32, u32, u32, u32, u32, u32, u32, u32, u32), Error> {
          // Open the cursor font
 -        let font: Font = self.conn.generate_id()?;
 -        self.conn.open_font(font, b"cursor")?;
+-
 -        // Create cursor from font glyphs
 -        // left_ptr is glyph 68, its mask is glyph 69
 -        let cursor = self.conn.generate_id()?;
 -        self.conn.create_glyph_cursor(
 -            cursor,
 -            font,
 -            font,
 -            68,  // left_ptr glyph
 -            69,  // mask glyph
 -            0, 0, 0,           // foreground RGB (black)
 -            0xFFFF, 0xFFFF, 0xFFFF,  // background RGB (white)
 -        )?;
+-
 -        // Close font (cursor keeps its own reference)
 -        self.conn.close_font(font)?;
+-
 -        Ok(cursor)
 +        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
 +        // bottom_left_corner = 12, bottom_right_corner = 14
 +        // left_side = 70, right_side = 96, top_side = 138, bottom_side = 16
++
 +        let create = |glyph: u16| -> Result<u32, Error> {
 +            let cursor = conn.generate_id()?;
 +            conn.create_glyph_cursor(
 +                cursor,
 +                font,
 +                font,
 +                glyph,
 +                glyph + 1,
 +                0, 0, 0,
 +                0xFFFF, 0xFFFF, 0xFFFF,
 +            )?;
 +            Ok(cursor)
 +        };
++
 +        let cursor_normal = create(68)?;       // left_ptr
 +        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
 +        let cursor_bottom_right = create(14)?; // bottom_right_corner
 +        let cursor_left = create(70)?;         // left_side
 +        let cursor_right = create(96)?;        // right_side
 +        let cursor_top = create(138)?;         // top_side
 +        let cursor_bottom = create(16)?;       // bottom_side
++
 +        // Close font (cursors keep their own references)
 +        conn.close_font(font)?;
++
 +        Ok((
 +            cursor_normal,
 +            cursor_top_left,
 +            cursor_top_right,
 +            cursor_bottom_left,
 +            cursor_bottom_right,
 +            cursor_left,
 +            cursor_right,
 +            cursor_top,
 +            cursor_bottom,
 +        ))
+     }
      /// Grab a key combination on the root window.
          Ok(())
+     }
 -    /// Grab Alt+Button1 and Alt+Button3 on root for floating window move/resize.
 +    /// Grab Mod+Button1 and Mod+Button3 on root for floating window move/resize.
 +    /// Grabs both Alt (M1) and Super (M4) to support either mod key configuration.
      pub fn grab_mod_buttons(&self) -> Result<(), Error> {
          let numlock = ModMask::M2;
          let capslock = ModMask::LOCK;
 -        // Grab Alt+Button1 (move) and Alt+Button3 (resize) with NumLock/CapsLock variants
 +        // Grab both Alt (M1) and Super (M4) with Button1 (move) and Button3 (resize)
          for button in [ButtonIndex::M1, ButtonIndex::M3] {
 +            // Alt variants
              for mods in [
                  ModMask::M1,
                  ModMask::M1 | numlock,
                      mods,
                  )?;
+             }
 +            // Super variants
 +            for mods in [
 +                ModMask::M4,
 +                ModMask::M4 | numlock,
 +                ModMask::M4 | capslock,
 +                ModMask::M4 | numlock | capslock,
 +            ] {
 +                self.conn.grab_button(
 +                    false,
 +                    self.root,
 +                    EventMask::BUTTON_PRESS | EventMask::BUTTON_RELEASE | EventMask::BUTTON_MOTION,
 +                    GrabMode::ASYNC,
 +                    GrabMode::ASYNC,
 +                    x11rb::NONE,
 +                    x11rb::NONE,
 +                    button,
 +                    mods,
 +                )?;
 +            }
+         }
 -        tracing::debug!("Grabbed Alt+Button1/Button3 on root for floating move/resize");
 +        tracing::debug!("Grabbed Mod+Button1/Button3 on root for floating move/resize");
 +        Ok(())
 +    }
++
 +    /// Set the cursor for a window.
 +    pub fn set_window_cursor(&self, window: Window, cursor: u32) -> Result<(), Error> {
 +        let change = ChangeWindowAttributesAux::new().cursor(cursor);
 +        self.conn.change_window_attributes(window, &change)?;
          Ok(())
+     }
      /// Grab the pointer for drag operations.
      pub fn grab_pointer(&self, _window: Window) -> Result<(), Error> {
 -        self.conn.grab_pointer(
 +        let reply = self.conn.grab_pointer(
              false,
              self.root,
              EventMask::BUTTON_RELEASE | EventMask::POINTER_MOTION,
              x11rb::NONE,
              x11rb::NONE,
              CURRENT_TIME,
 -        )?;
 +        )?.reply()?;
 +        tracing::debug!("grab_pointer result: {:?}", reply.status);
          Ok(())
+     }

gar/src/x11/events.rsmodified

      },
+ }
 -#[derive(Debug, Clone, Copy)]
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
  pub enum ResizeEdge {
      TopLeft,
 +    Top,
      TopRight,
 +    Left,
 +    Right,
      BottomLeft,
 +    Bottom,
      BottomRight,
 +    None,
+ }
  impl WindowManager {
                  continue;
+             }
 +            // Check window rules and EWMH hints
 +            let rule_actions = self.check_rules(window);
 +            let should_float = rule_actions.floating.unwrap_or_else(|| self.conn.should_float(window));
++
              // Subscribe to events on the window
 -            self.conn.select_input(
 -                window,
 -                EventMask::ENTER_WINDOW
 -                    | EventMask::FOCUS_CHANGE
 -                    | EventMask::PROPERTY_CHANGE
 -                    | EventMask::STRUCTURE_NOTIFY,
 -            )?;
 +            // Floating windows get POINTER_MOTION for edge resize cursors
 +            let base_events = EventMask::ENTER_WINDOW
 +                | EventMask::FOCUS_CHANGE
 +                | EventMask::PROPERTY_CHANGE
 +                | EventMask::STRUCTURE_NOTIFY;
 +            let events = if should_float {
 +                base_events | EventMask::POINTER_MOTION
 +            } else {
 +                base_events
 +            };
 +            self.conn.select_input(window, events)?;
              // Grab button for click-to-focus
              self.conn.grab_button(window)?;
 -            // Check window rules and EWMH hints
 -            let rule_actions = self.check_rules(window);
 -            let should_float = rule_actions.floating.unwrap_or_else(|| self.conn.should_float(window));
+-
              // Manage the window
              if should_float {
                  self.manage_window_floating(window);
              // Focus the first window
              if let Some(window) = self.focused_window {
                  self.set_focus(window, true)?;
 -                self.conn.ungrab_button(window)?;
 +                // 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);
+         }
              return Ok(());
+         }
 -        // Subscribe to events on the window
 -        self.conn.select_input(
 -            window,
 -            EventMask::ENTER_WINDOW
 -                | EventMask::FOCUS_CHANGE
 -                | EventMask::PROPERTY_CHANGE
 -                | EventMask::STRUCTURE_NOTIFY,
 -        )?;
+-
 -        // Grab button for click-to-focus
 -        self.conn.grab_button(window)?;
+-
          // Check window rules first
          let rule_actions = self.check_rules(window);
          // Determine if window should float (rule > ICCCM/EWMH hints)
          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
 +        let base_events = EventMask::ENTER_WINDOW
 +            | EventMask::FOCUS_CHANGE
 +            | EventMask::PROPERTY_CHANGE
 +            | EventMask::STRUCTURE_NOTIFY;
 +        let events = if should_float {
 +            base_events | EventMask::POINTER_MOTION
 +        } else {
 +            base_events
 +        };
 +        self.conn.select_input(window, events)?;
++
 +        // Grab button for click-to-focus
 +        self.conn.grab_button(window)?;
++
          // Manage window on target workspace
          if target_idx != self.focused_workspace {
              // Window goes to a different workspace
          let child = event.child;
          tracing::debug!("ButtonPress on window {}, child {}, button {}", window, child, event.detail);
 +        // If we're already in a drag, ignore additional button presses
 +        if self.drag_state.is_some() {
 +            tracing::debug!("Already in drag state, ignoring ButtonPress");
 +            return Ok(());
 +        }
++
          // Check for mod+click on floating windows (move/resize)
 -        let has_mod = event.state.contains(x11rb::protocol::xproto::KeyButMask::MOD1);
 +        // Support both Alt (MOD1) and Super (MOD4) as the modifier
 +        let has_mod = event.state.contains(x11rb::protocol::xproto::KeyButMask::MOD1)
 +            || event.state.contains(x11rb::protocol::xproto::KeyButMask::MOD4);
          // For Alt+click from root grab, use child window (the window under cursor)
          let target = if window == self.conn.root && child != 0 {
                  self.conn.grab_pointer(target)?;
                  return Ok(());
              } else if event.detail == 3 {
 -                // Mod+Button3 = Resize
 -                let edge = determine_resize_edge(&geometry, event.root_x, event.root_y);
 +                // Mod+Button3 = Resize (quadrant-based edge detection)
 +                let edge = determine_resize_edge_quadrant(&geometry, event.root_x, event.root_y);
                  tracing::debug!("Starting resize for floating window {}, edge {:?}", target, edge);
                  self.drag_state = Some(DragState::Resize {
                      window: target,
+             }
+         }
 +        // Check for edge resize on floating windows (click on edge without mod key)
 +        let is_floating_win = self.is_floating(window);
 +        tracing::debug!(
 +            "Edge resize check: window={}, is_floating={}, button={}, pos=({},{})",
 +            window, is_floating_win, event.detail, event.root_x, event.root_y
 +        );
++
 +        if !has_mod && is_floating_win && event.detail == 1 {
 +            let geometry = self.get_floating_geometry(window);
 +            let edge = determine_resize_edge(&geometry, event.root_x, event.root_y);
 +            tracing::debug!(
 +                "Edge detection: geometry=({},{} {}x{}), edge={:?}",
 +                geometry.x, geometry.y, geometry.width, geometry.height, edge
 +            );
 +            if edge != ResizeEdge::None {
 +                tracing::info!("Starting edge resize for floating window {}, edge {:?}", window, edge);
 +                self.drag_state = Some(DragState::Resize {
 +                    window,
 +                    start_x: event.root_x,
 +                    start_y: event.root_y,
 +                    start_geometry: geometry.clone(),
 +                    edge,
 +                });
 +                tracing::debug!("Grabbing pointer for resize, geometry={:?}", geometry);
 +                self.conn.grab_pointer(window)?;
 +                self.conn.flush()?;
 +                return Ok(());
 +            }
 +            // Not on edge - if this is a focused floating window, replay the click
 +            if self.focused_window == Some(window) {
 +                self.conn.conn.allow_events(
 +                    x11rb::protocol::xproto::Allow::REPLAY_POINTER,
 +                    x11rb::CURRENT_TIME,
 +                )?;
 +                self.conn.flush()?;
 +                return Ok(());
 +            }
 +        }
++
          // Only handle if we manage this window
          if !self.windows.contains_key(&window) {
              return Ok(());
          // Focus the clicked window
          if self.focused_window != Some(window) {
 -            // Regrab button on old focused window
 +            // Regrab button on old focused window (unless it's floating - keep grab for edge resize)
              if let Some(old) = self.focused_window {
 -                self.conn.grab_button(old)?;
 +                if !self.is_floating(old) {
 +                    self.conn.grab_button(old)?;
 +                }
+             }
 -            // Set focus and ungrab button on new focused window (no warp - mouse click)
 +            // Set focus
              self.set_focus(window, false)?;
 -            self.conn.ungrab_button(window)?;
++
 +            // For non-floating windows, ungrab button for click-through
 +            // For floating windows, keep grab for edge resize detection
 +            if !self.is_floating(window) {
 +                self.conn.ungrab_button(window)?;
 +            }
              // Raise floating windows on focus
              if self.is_floating(window) {
          Ok(())
+     }
 -    fn handle_button_release(&mut self, _event: ButtonReleaseEvent) -> Result<()> {
 +    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() {
              tracing::debug!("Ending drag operation");
              self.drag_state = None;
+     }
      fn handle_motion_notify(&mut self, event: MotionNotifyEvent) -> Result<()> {
 -        let Some(ref drag) = self.drag_state else {
 +        // If not in a drag, check for edge cursor changes on floating windows
 +        if self.drag_state.is_none() {
 +            let window = event.event;
 +            let is_managed = self.windows.contains_key(&window);
 +            let is_float = is_managed && self.is_floating(window);
++
 +            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(());
 -        };
 +        }
 +        let drag = self.drag_state.as_ref().unwrap();
 +        tracing::debug!("Motion during drag: root({},{}), drag_state={:?}", event.root_x, event.root_y, drag);
          match drag {
              DragState::Move {
                  window,
          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)?;
 +                self.current_edge_cursor = None;
 +            }
 +            return Ok(());
 +        }
++
 +        let geometry = self.get_floating_geometry(window);
 +        let edge = determine_resize_edge(&geometry, root_x, root_y);
++
 +        // Check if we need to update the cursor
 +        let current = self.current_edge_cursor;
 +        if current.map(|(w, e)| (w, e)) == Some((window, edge)) {
 +            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);
 +            self.current_edge_cursor = Some((window, edge));
 +        } else {
 +            self.current_edge_cursor = None;
 +        }
++
 +        Ok(())
 +    }
++
      fn handle_enter_notify(&mut self, event: EnterNotifyEvent) -> Result<()> {
          let window = event.event;
          tracing::debug!("Focus follows mouse: focusing window {}", window);
 -        // Regrab button on old focused window
 +        // Regrab button on old focused window (unless floating - keep for edge resize)
          if let Some(old) = self.focused_window {
 -            self.conn.grab_button(old)?;
 +            if !self.is_floating(old) {
 +                self.conn.grab_button(old)?;
 +            }
+         }
          // Focus the new window (no warp - mouse enter)
          self.set_focus(window, false)?;
 -        self.conn.ungrab_button(window)?;
++
 +        // 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) {
              .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 {
 -                self.conn.grab_button(old)?;
 +                if !self.is_floating(old) {
 +                    self.conn.grab_button(old)?;
 +                }
+             }
              self.set_focus(window, true)?;
 -            self.conn.ungrab_button(window)?;
 +            // 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;
              .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 {
 -                self.conn.grab_button(old)?;
 +                if !self.is_floating(old) {
 +                    self.conn.grab_button(old)?;
 +                }
+             }
              self.set_focus(window, true)?;
 -            self.conn.ungrab_button(window)?;
 +            // 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
 +        // Regrab button on old focused window (unless it's floating)
          if let Some(old) = self.focused_window {
 -            self.conn.grab_button(old)?;
 +            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
          self.set_focus(next_window, true)?;
 -        self.conn.ungrab_button(next_window)?;
          self.raise_window(next_window)?;
          tracing::debug!("Cycled to floating window {} (idx {})", next_window, next_idx);
                  win.floating = false;
+             }
 +            // Remove POINTER_MOTION event mask (no longer need edge detection)
 +            self.conn.select_input(
 +                window,
 +                EventMask::ENTER_WINDOW
 +                    | EventMask::FOCUS_CHANGE
 +                    | EventMask::PROPERTY_CHANGE
 +                    | EventMask::STRUCTURE_NOTIFY,
 +            )?;
++
 +            // 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.current_edge_cursor = None;
 +            }
++
              // Remove from floating list
              self.current_workspace_mut().remove_floating(window);
                  win.floating_geometry = geometry;
+             }
 +            // Add POINTER_MOTION event mask for edge detection
 +            self.conn.select_input(
 +                window,
 +                EventMask::ENTER_WINDOW
 +                    | EventMask::FOCUS_CHANGE
 +                    | EventMask::PROPERTY_CHANGE
 +                    | EventMask::STRUCTURE_NOTIFY
 +                    | EventMask::POINTER_MOTION,
 +            )?;
++
 +            // Re-establish button grabs for edge resize detection
 +            // (buttons may have been ungrabbed when the window was focused as tiled)
 +            self.conn.grab_button(window)?;
++
              // Add to floating list (on top)
              self.current_workspace_mut().add_floating(window);
+     }
+ }
 +/// Threshold in pixels for detecting edge proximity
 +const EDGE_THRESHOLD: i16 = 12;
++
 +/// Determine which edge/corner of a window a point is near.
 +/// Returns ResizeEdge::None if not near any edge.
  fn determine_resize_edge(geometry: &Rect, click_x: i16, click_y: i16) -> ResizeEdge {
 +    let left = geometry.x;
 +    let right = geometry.x + geometry.width as i16;
 +    let top = geometry.y;
 +    let bottom = geometry.y + geometry.height as i16;
++
 +    let near_left = click_x >= left && click_x < left + EDGE_THRESHOLD;
 +    let near_right = click_x > right - EDGE_THRESHOLD && click_x <= right;
 +    let near_top = click_y >= top && click_y < top + EDGE_THRESHOLD;
 +    let near_bottom = click_y > bottom - EDGE_THRESHOLD && click_y <= bottom;
++
 +    match (near_left, near_right, near_top, near_bottom) {
 +        (true, _, true, _) => ResizeEdge::TopLeft,
 +        (_, true, true, _) => ResizeEdge::TopRight,
 +        (true, _, _, true) => ResizeEdge::BottomLeft,
 +        (_, true, _, true) => ResizeEdge::BottomRight,
 +        (true, _, _, _) => ResizeEdge::Left,
 +        (_, true, _, _) => ResizeEdge::Right,
 +        (_, _, true, _) => ResizeEdge::Top,
 +        (_, _, _, true) => ResizeEdge::Bottom,
 +        _ => ResizeEdge::None,
 +    }
 +}
++
 +/// Determine resize edge for mod+click (quadrant-based, always picks a corner)
 +fn determine_resize_edge_quadrant(geometry: &Rect, click_x: i16, click_y: i16) -> ResizeEdge {
      let center_x = geometry.x + geometry.width as i16 / 2;
      let center_y = geometry.y + geometry.height as i16 / 2;
              w = (w as i16 - dx).max(MIN_SIZE as i16) as u16;
              h = (h as i16 - dy).max(MIN_SIZE as i16) as u16;
+         }
 +        ResizeEdge::Top => {
 +            y += dy;
 +            h = (h as i16 - dy).max(MIN_SIZE as i16) as u16;
 +        }
          ResizeEdge::TopRight => {
              y += dy;
              w = (w as i16 + dx).max(MIN_SIZE as i16) as u16;
              h = (h as i16 - dy).max(MIN_SIZE as i16) as u16;
+         }
 +        ResizeEdge::Left => {
 +            x += dx;
 +            w = (w as i16 - dx).max(MIN_SIZE as i16) as u16;
 +        }
 +        ResizeEdge::Right => {
 +            w = (w as i16 + dx).max(MIN_SIZE as i16) as u16;
 +        }
          ResizeEdge::BottomLeft => {
              x += dx;
              w = (w as i16 - dx).max(MIN_SIZE as i16) as u16;
              h = (h as i16 + dy).max(MIN_SIZE as i16) as u16;
+         }
 +        ResizeEdge::Bottom => {
 +            h = (h as i16 + dy).max(MIN_SIZE as i16) as u16;
 +        }
          ResizeEdge::BottomRight => {
              w = (w as i16 + dx).max(MIN_SIZE as i16) as u16;
              h = (h as i16 + dy).max(MIN_SIZE as i16) as u16;
+         }
 +        ResizeEdge::None => {
 +            // No resize
 +        }
+     }
      (x, y, w, h)