`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.
++    /// Create all cursors used by the window manager.
--    fn create_cursor(&self) -> Result<u32, Error> {
++    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()?;
++        let font: Font = conn.generate_id()?;
--        self.conn.open_font(font, b"cursor")?;
++        conn.open_font(font, b"cursor")?;
--
++
--        // Create cursor from font glyphs
++        // Cursor glyph numbers from the cursor font:
--        // left_ptr is glyph 68, its mask is glyph 69
++        // left_ptr = 68, top_left_corner = 134, top_right_corner = 136
--        let cursor = self.conn.generate_id()?;
++        // bottom_left_corner = 12, bottom_right_corner = 14
--        self.conn.create_glyph_cursor(
++        // left_side = 70, right_side = 96, top_side = 138, bottom_side = 16
--            cursor,
++
--            font,
++        let create = |glyph: u16| -> Result<u32, Error> {
--            font,
++            let cursor = conn.generate_id()?;
--            68,  // left_ptr glyph
++            conn.create_glyph_cursor(
--            69,  // mask glyph
++                cursor,
--            0, 0, 0,           // foreground RGB (black)
++                font,
--            0xFFFF, 0xFFFF, 0xFFFF,  // background RGB (white)
++                font,
--        )?;
++                glyph,
--
++                glyph + 1,
--        // Close font (cursor keeps its own reference)
++                0, 0, 0,
--        self.conn.close_font(font)?;
++                0xFFFF, 0xFFFF, 0xFFFF,
--
++            )?;
--        Ok(cursor)
++            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(
++            // Floating windows get POINTER_MOTION for edge resize cursors
--                window,
++            let base_events = EventMask::ENTER_WINDOW
--                EventMask::ENTER_WINDOW
++                | EventMask::FOCUS_CHANGE
--                    | EventMask::FOCUS_CHANGE
++                | EventMask::PROPERTY_CHANGE
--                    | EventMask::PROPERTY_CHANGE
++                | EventMask::STRUCTURE_NOTIFY;
--                    | 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
++                // Mod+Button3 = Resize (quadrant-based edge detection)
--                let edge = determine_resize_edge(&geometry, event.root_x, event.root_y);
++                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)