`35a4759`

events: add tiled edge drag resize

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

SHA: 35a4759bfb9c24e82acac749ac8243cc0dc3bd36
Parents: 5584e18
Tree: 5aef70d

1 changed file

Status	File	+	-
M	`gar/src/x11/events.rs`	153	1

gar/src/x11/events.rsmodified

          /// Original workspace index
          workspace: usize,
      },
 +    /// Dragging on the gap between tiled windows to resize
 +    TiledResize {
 +        /// Direction of resize (Right = vertical split, Down = horizontal split)
 +        direction: Direction,
 +        /// Starting cursor position (x for horizontal, y for vertical)
 +        start_pos: i16,
 +        /// Starting ratio of the split
 +        start_ratio: f32,
 +        /// Window whose split we're adjusting
 +        window: u32,
 +        /// Total size of the split container (for pixel-to-ratio conversion)
 +        container_size: u16,
 +        /// Workspace index
 +        workspace: usize,
 +    },
+ }
  #[derive(Debug, Clone, Copy, PartialEq, Eq)]
              let drag_window = match drag {
                  DragState::Move { window, .. } |
                  DragState::Resize { window, .. } |
 -                DragState::TiledSwap { window, .. } => *window,
 +                DragState::TiledSwap { window, .. } |
 +                DragState::TiledResize { window, .. } => *window,
              };
              if drag_window == event.window {
                  self.drag_state = None;
+             }
+         }
 +        // Check for edge resize on TILED windows (click on gap between windows, no mod key)
 +        if !has_mod && event.detail == 1 {
 +            let screen = self.screen_rect();
 +            let geometries = self.current_workspace().tree.calculate_geometries(screen);
++
 +            if let Some((window, direction, container_size)) =
 +                self.find_tiled_edge(event.root_x, event.root_y, &geometries)
 +            {
 +                // Get current ratio from tree
 +                let start_ratio = self
 +                    .current_workspace()
 +                    .tree
 +                    .get_split_ratio(window, direction)
 +                    .unwrap_or(0.5);
++
 +                let start_pos = match direction {
 +                    Direction::Left | Direction::Right => event.root_x,
 +                    Direction::Up | Direction::Down => event.root_y,
 +                };
++
 +                tracing::debug!(
 +                    "Starting tiled edge resize: window={}, direction={:?}, ratio={}, container={}",
 +                    window, direction, start_ratio, container_size
 +                );
++
 +                self.drag_state = Some(DragState::TiledResize {
 +                    direction,
 +                    start_pos,
 +                    start_ratio,
 +                    window,
 +                    container_size,
 +                    workspace: self.focused_workspace,
 +                });
++
 +                let cursor = match direction {
 +                    Direction::Left | Direction::Right => self.conn.cursor_left,
 +                    Direction::Up | Direction::Down => self.conn.cursor_top,
 +                };
 +                self.conn.grab_pointer(Some(cursor))?;
 +                return Ok(());
 +            }
 +        }
++
          // Check for edge resize on floating windows (click on edge without mod key)
          let is_floating_win = self.is_floating(window);
          tracing::debug!(
                          self.update_edge_cursor(window, event.root_x, event.root_y)?;
+                     }
+                 }
 +                DragState::TiledResize { .. } => {
 +                    // Layout already applied during motion, nothing special needed
 +                }
+             }
              self.conn.flush()?;
                      self.conn.flush()?;
+                 }
+             }
 +            DragState::TiledResize {
 +                direction,
 +                start_pos,
 +                start_ratio,
 +                window,
 +                container_size,
 +                workspace,
 +            } => {
 +                if *workspace != self.focused_workspace {
 +                    return Ok(());
 +                }
++
 +                let current_pos = match direction {
 +                    Direction::Left | Direction::Right => event.root_x,
 +                    Direction::Up | Direction::Down => event.root_y,
 +                };
++
 +                // Convert pixel delta to ratio delta
 +                let pixel_delta = current_pos - *start_pos;
 +                let ratio_delta = pixel_delta as f32 / *container_size as f32;
++
 +                let new_ratio = (*start_ratio + ratio_delta).clamp(0.1, 0.9);
++
 +                // Update tree and apply layout
 +                let window = *window;
 +                let direction = *direction;
 +                self.current_workspace_mut()
 +                    .tree
 +                    .set_split_ratio(window, direction, new_ratio);
 +                self.apply_layout()?;
 +                self.conn.flush()?;
 +            }
+         }
          Ok(())
+         }
+     }
 +    /// Find if cursor is in the gap between two adjacent tiled windows.
 +    /// Returns (window, direction, container_size) if on a valid shared edge.
 +    /// Only matches gaps between windows, NOT outer edges.
 +    fn find_tiled_edge(
 +        &self,
 +        x: i16,
 +        y: i16,
 +        geometries: &[(u32, Rect)],
 +    ) -> Option<(u32, Direction, u16)> {
 +        const TILED_EDGE_THRESHOLD: i16 = 8;
 +        let gap_tolerance = self.config.gap_inner as i16 + 4;
++
 +        for (w1, r1) in geometries {
 +            for (w2, r2) in geometries {
 +                if w1 >= w2 {
 +                    continue;
 +                } // Avoid duplicate pairs
++
 +                // Check for vertical shared edge (windows side by side)
 +                // r1's right edge meets r2's left edge
 +                let r1_right = r1.x + r1.width as i16;
++
 +                if (r1_right - r2.x).abs() <= gap_tolerance && r1_right <= r2.x {
 +                    // Verify vertical overlap (they share a horizontal span)
 +                    let y_min = r1.y.max(r2.y);
 +                    let y_max = (r1.y + r1.height as i16).min(r2.y + r2.height as i16);
 +                    if y_min < y_max && y >= y_min && y < y_max {
 +                        // Cursor must be in the gap between them
 +                        let gap_center = (r1_right + r2.x) / 2;
 +                        if (x - gap_center).abs() <= TILED_EDGE_THRESHOLD {
 +                            let container_width = (r1.width + r2.width) as u16;
 +                            return Some((*w1, Direction::Right, container_width));
 +                        }
 +                    }
 +                }
++
 +                // Check for horizontal shared edge (windows stacked vertically)
 +                // r1's bottom edge meets r2's top edge
 +                let r1_bottom = r1.y + r1.height as i16;
++
 +                if (r1_bottom - r2.y).abs() <= gap_tolerance && r1_bottom <= r2.y {
 +                    // Verify horizontal overlap (they share a vertical span)
 +                    let x_min = r1.x.max(r2.x);
 +                    let x_max = (r1.x + r1.width as i16).min(r2.x + r2.width as i16);
 +                    if x_min < x_max && x >= x_min && x < x_max {
 +                        // Cursor must be in the gap between them
 +                        let gap_center = (r1_bottom + r2.y) / 2;
 +                        if (y - gap_center).abs() <= TILED_EDGE_THRESHOLD {
 +                            let container_height = (r1.height + r2.height) as u16;
 +                            return Some((*w1, Direction::Down, container_height));
 +                        }
 +                    }
 +                }
 +            }
 +        }
 +        None
 +    }
++
      fn get_floating_geometry(&self, window: u32) -> Rect {
          self.windows
              .get(&window)