`8f57948`

ui: add tab reorder via drag in tab bar

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

SHA: 8f5794861e0da378e599fc564219d22fcbde3f7f
Parents: e61c363
Tree: cfe20ae

3 changed files

Status	File	+	-
M	`garfield/src/app.rs`	37	3
M	`garfield/src/ui/pane.rs`	22	0
M	`garfield/src/ui/tab_bar.rs`	148	0

garfield/src/app.rsmodified

              return;
+         }
 -        // Check tab bar clicks
 +        // Check tab bar clicks - try to start tab drag first
 +        if self.tab_bar.start_drag(pos) {
 +            // Started potential tab drag, don't switch yet
 +            return;
 +        }
++
 +        // Handle tab bar close button clicks (non-drag)
          if let Some((tab_index, is_close)) = self.tab_bar.on_click(pos) {
              if is_close {
                  self.close_tab(tab_index);
 -            } else {
 -                self.switch_tab(tab_index);
+             }
 +            // Tab selection happens on mouse release if not dragged
              return;
+         }
      /// Handle mouse release.
      fn handle_mouse_release(&mut self, pos: Point) {
 +        // Handle tab reorder drag completion
 +        if self.tab_bar.is_dragging() {
 +            if let Some((from, to)) = self.tab_bar.complete_drag() {
 +                self.reorder_tab(from, to);
 +            }
 +        } else if self.tab_bar.dragging_tab().is_some() {
 +            // Clicked on tab but didn't drag - select it
 +            if let Some(index) = self.tab_bar.dragging_tab() {
 +                self.switch_tab(index);
 +            }
 +            self.tab_bar.cancel_drag();
 +        }
++
          // Handle bookmark reorder drag completion
          if self.sidebar.is_bookmark_dragging() {
              self.sidebar.complete_bookmark_drag();
+             }
+         }
 +        // Handle tab reorder drag in progress
 +        if self.tab_bar.dragging_tab().is_some() {
 +            self.tab_bar.update_drag(pos);
 +        }
++
          // Handle bookmark reorder drag in progress
          if self.sidebar.bookmark_drag_index().is_some() {
              self.sidebar.update_bookmark_drag(pos);
          self.update_status_bar();
+     }
 +    /// Reorder a tab from one position to another.
 +    fn reorder_tab(&mut self, from: usize, to: usize) {
 +        if let Some(pane) = self.focused_pane_mut() {
 +            pane.reorder_tab(from, to);
 +        }
++
 +        self.sync_tab_bar();
 +        self.sync_breadcrumb();
 +        self.update_status_bar();
 +    }
++
      /// Cycle to next tab.
      fn next_tab(&mut self) {
          if let Some(pane) = self.focused_pane_mut() {

garfield/src/ui/pane.rsmodified

+         }
+     }
 +    /// Reorder a tab from one position to another.
 +    pub fn reorder_tab(&mut self, from: usize, to: usize) {
 +        if let Pane::Leaf { tabs, active_tab, .. } = self {
 +            if from >= tabs.len() || to > tabs.len() {
 +                return;
 +            }
++
 +            let tab = tabs.remove(from);
 +            let new_index = if to > from { to - 1 } else { to };
 +            tabs.insert(new_index, tab);
++
 +            // Update active tab index if affected
 +            if *active_tab == from {
 +                *active_tab = new_index;
 +            } else if from < *active_tab && new_index >= *active_tab {
 +                *active_tab = active_tab.saturating_sub(1);
 +            } else if from > *active_tab && new_index <= *active_tab {
 +                *active_tab = (*active_tab + 1).min(tabs.len() - 1);
 +            }
 +        }
 +    }
++
      /// Get tab count.
      pub fn tab_count(&self) -> usize {
          match self {

garfield/src/ui/tab_bar.rsmodified

      hovered_close: Option<usize>,
      /// Cached tab bounds.
      tab_bounds: Vec<Rect>,
 +    /// Tab being dragged (index).
 +    dragging_tab: Option<usize>,
 +    /// Drag start position.
 +    drag_start: Option<Point>,
 +    /// Whether drag is active (past threshold).
 +    drag_active: bool,
 +    /// Target drop position for reorder.
 +    drop_target: Option<usize>,
+ }
  impl TabBar {
              hovered_tab: None,
              hovered_close: None,
              tab_bounds: Vec::new(),
 +            dragging_tab: None,
 +            drag_start: None,
 +            drag_active: false,
 +            drop_target: None,
+         }
+     }
          self.hovered_close = None;
+     }
 +    /// Start potential tab drag.
 +    pub fn start_drag(&mut self, pos: Point) -> bool {
 +        if !self.bounds.contains_point(pos) {
 +            return false;
 +        }
++
 +        for (i, tab_bounds) in self.tab_bounds.iter().enumerate() {
 +            if tab_bounds.contains_point(pos) {
 +                // Don't drag if clicking close button
 +                if let Some(close_bounds) = self.close_button_bounds(i) {
 +                    if close_bounds.contains_point(pos) {
 +                        return false;
 +                    }
 +                }
 +                self.dragging_tab = Some(i);
 +                self.drag_start = Some(pos);
 +                self.drag_active = false;
 +                self.drop_target = None;
 +                return true;
 +            }
 +        }
 +        false
 +    }
++
 +    /// Update tab drag with current mouse position.
 +    /// Returns true if drag is active.
 +    pub fn update_drag(&mut self, pos: Point) -> bool {
 +        if self.dragging_tab.is_none() {
 +            return false;
 +        }
++
 +        // Check if past drag threshold
 +        if !self.drag_active {
 +            if let Some(start) = self.drag_start {
 +                let dx = (pos.x - start.x).abs();
 +                if dx > 5 {
 +                    self.drag_active = true;
 +                }
 +            }
 +        }
++
 +        if !self.drag_active {
 +            return false;
 +        }
++
 +        // Calculate drop target based on position
 +        if !self.bounds.contains_point(pos) {
 +            self.drop_target = None;
 +        } else {
 +            // Find which slot we're closest to
 +            let mut target = 0;
 +            for (i, tab_bounds) in self.tab_bounds.iter().enumerate() {
 +                let mid_x = tab_bounds.x + tab_bounds.width as i32 / 2;
 +                if pos.x > mid_x {
 +                    target = i + 1;
 +                }
 +            }
 +            self.drop_target = Some(target);
 +        }
++
 +        true
 +    }
++
 +    /// Complete tab drag and return reorder info if any (from, to).
 +    pub fn complete_drag(&mut self) -> Option<(usize, usize)> {
 +        let result = if self.drag_active {
 +            if let (Some(from), Some(to)) = (self.dragging_tab, self.drop_target) {
 +                if from != to && to != from + 1 {
 +                    Some((from, to))
 +                } else {
 +                    None
 +                }
 +            } else {
 +                None
 +            }
 +        } else {
 +            None
 +        };
++
 +        self.cancel_drag();
 +        result
 +    }
++
 +    /// Cancel tab drag.
 +    pub fn cancel_drag(&mut self) {
 +        self.dragging_tab = None;
 +        self.drag_start = None;
 +        self.drag_active = false;
 +        self.drop_target = None;
 +    }
++
 +    /// Check if currently dragging.
 +    pub fn is_dragging(&self) -> bool {
 +        self.drag_active
 +    }
++
 +    /// Get dragging tab index.
 +    pub fn dragging_tab(&self) -> Option<usize> {
 +        self.dragging_tab
 +    }
++
      /// Render the tab bar.
      pub fn render(&self, renderer: &Renderer) -> anyhow::Result<()> {
          let theme = renderer.theme();
          for (i, (tab, bounds)) in self.tabs.iter().zip(self.tab_bounds.iter()).enumerate() {
              let is_active = i == self.active_index;
              let is_hovered = self.hovered_tab == Some(i);
 +            let is_being_dragged = self.drag_active && self.dragging_tab == Some(i);
++
 +            // Dim the tab being dragged
 +            if is_being_dragged {
 +                renderer.fill_rect(*bounds, theme.item_background.with_alpha(0.3))?;
 +                continue; // Skip rest of rendering for dragged tab
 +            }
++
 +            // Draw drop indicator before this tab if needed
 +            if self.drag_active && self.drop_target == Some(i) {
 +                let indicator_x = bounds.x - 2;
 +                renderer.line(
 +                    indicator_x as f64,
 +                    (bounds.y + 4) as f64,
 +                    indicator_x as f64,
 +                    (bounds.y + bounds.height as i32 - 4) as f64,
 +                    theme.selection_background,
 +                    3.0,
 +                )?;
 +            }
              // Tab background
              if is_active {
+             }
+         }
 +        // Draw drop indicator at end if dropping after last tab
 +        if self.drag_active && self.drop_target == Some(self.tabs.len()) {
 +            if let Some(last_bounds) = self.tab_bounds.last() {
 +                let indicator_x = last_bounds.x + last_bounds.width as i32 + 2;
 +                renderer.line(
 +                    indicator_x as f64,
 +                    (last_bounds.y + 4) as f64,
 +                    indicator_x as f64,
 +                    (last_bounds.y + last_bounds.height as i32 - 4) as f64,
 +                    theme.selection_background,
 +                    3.0,
 +                )?;
 +            }
 +        }
++
          Ok(())
+     }
+ }