`3abf9ab`

ui: add bookmark reorder via drag in sidebar

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

SHA: 3abf9ab0ae87b7621d6bf2761403c4e300fccc00
Parents: c7ca947
Tree: 81e2dd2

2 changed files

Status	File	+	-
M	`garfield/src/app.rs`	25	3
M	`garfield/src/ui/sidebar.rs`	224	1

garfield/src/app.rsmodified

              return;
+         }
 -        // Check sidebar clicks
 +        // Check sidebar clicks - try to start bookmark drag first
 +        if self.sidebar.start_bookmark_drag(pos) {
 +            // Started potential bookmark drag, don't navigate yet
 +            return;
 +        }
++
 +        // Check sidebar clicks (for non-bookmark items)
          if let Some(path) = self.sidebar.on_click(pos) {
              self.navigate_to(path);
              return;
      /// Handle mouse release.
      fn handle_mouse_release(&mut self, pos: Point) {
 -        // Handle bookmark drag drop
 +        // Handle bookmark reorder drag completion
 +        if self.sidebar.is_bookmark_dragging() {
 +            self.sidebar.complete_bookmark_drag();
 +        } else if self.sidebar.bookmark_drag_index().is_some() {
 +            // Clicked on bookmark but didn't drag - navigate to it
 +            if let Some(path) = self.sidebar.bookmark_path_at_index() {
 +                self.navigate_to(path);
 +            }
 +            self.sidebar.cancel_bookmark_drag();
 +        }
++
 +        // Handle bookmark drag drop (dragging from file view to sidebar)
          if self.drag_active {
              if let Some(path) = self.drag_source_path.take() {
                  if self.sidebar.is_bookmark_drop_zone(pos) {
+             }
+         }
 -        // Handle bookmark drag in progress
 +        // Handle bookmark reorder drag in progress
 +        if self.sidebar.bookmark_drag_index().is_some() {
 +            self.sidebar.update_bookmark_drag(pos);
 +        }
++
 +        // Handle bookmark drag in progress (dragging from file view)
          if self.drag_source_path.is_some() {
              // Update current drag position for visual feedback
              self.drag_current_pos = Some(pos);

garfield/src/ui/sidebar.rsmodified

      bookmarks_section_y: i32,
      /// Whether to show drop highlight on bookmarks section.
      drop_highlight: bool,
 +    /// Index of bookmark being dragged for reorder.
 +    bookmark_drag_index: Option<usize>,
 +    /// Target insert position for bookmark reorder.
 +    bookmark_drop_index: Option<usize>,
 +    /// Starting position of bookmark drag.
 +    bookmark_drag_start: Option<Point>,
 +    /// Whether bookmark drag is active (past threshold).
 +    bookmark_drag_active: bool,
+ }
  impl Sidebar {
              bookmarks_path,
              bookmarks_section_y: 0,
              drop_highlight: false,
 +            bookmark_drag_index: None,
 +            bookmark_drop_index: None,
 +            bookmark_drag_start: None,
 +            bookmark_drag_active: false,
          };
          sidebar.populate_default_places();
          sidebar.load_bookmarks();
+         }
+     }
 +    /// Get the bookmark index at a given point (if any).
 +    fn bookmark_index_at_point(&self, pos: Point) -> Option<usize> {
 +        for (i, bookmark) in self.bookmarks.iter().enumerate() {
 +            if bookmark.bounds.contains_point(pos) {
 +                return Some(i);
 +            }
 +        }
 +        None
 +    }
++
 +    /// Start dragging a bookmark if the position is over one.
 +    /// Returns true if drag was started.
 +    pub fn start_bookmark_drag(&mut self, pos: Point) -> bool {
 +        if !self.visible || !self.bounds.contains_point(pos) {
 +            return false;
 +        }
++
 +        if let Some(index) = self.bookmark_index_at_point(pos) {
 +            self.bookmark_drag_index = Some(index);
 +            self.bookmark_drag_start = Some(pos);
 +            self.bookmark_drag_active = false;
 +            self.bookmark_drop_index = None;
 +            true
 +        } else {
 +            false
 +        }
 +    }
++
 +    /// Update bookmark drag state with current mouse position.
 +    /// Returns true if drag is active.
 +    pub fn update_bookmark_drag(&mut self, pos: Point) -> bool {
 +        if self.bookmark_drag_index.is_none() {
 +            return false;
 +        }
++
 +        // Check if past drag threshold
 +        if !self.bookmark_drag_active {
 +            if let Some(start) = self.bookmark_drag_start {
 +                let dx = (pos.x - start.x).abs();
 +                let dy = (pos.y - start.y).abs();
 +                if dx > 5 || dy > 5 {
 +                    self.bookmark_drag_active = true;
 +                }
 +            }
 +        }
++
 +        if !self.bookmark_drag_active {
 +            return false;
 +        }
++
 +        // Calculate drop index based on mouse position
 +        if pos.y < self.bookmarks_section_y || !self.bounds.contains_point(pos) {
 +            self.bookmark_drop_index = None;
 +        } else {
 +            // Find which slot we're closest to
 +            let mut drop_index = 0;
 +            for (i, bookmark) in self.bookmarks.iter().enumerate() {
 +                let mid_y = bookmark.bounds.y + bookmark.bounds.height as i32 / 2;
 +                if pos.y > mid_y {
 +                    drop_index = i + 1;
 +                }
 +            }
 +            self.bookmark_drop_index = Some(drop_index);
 +        }
++
 +        true
 +    }
++
 +    /// Complete bookmark drag and reorder.
 +    /// Returns true if reorder occurred.
 +    pub fn complete_bookmark_drag(&mut self) -> bool {
 +        let result = if self.bookmark_drag_active {
 +            if let (Some(from), Some(to)) = (self.bookmark_drag_index, self.bookmark_drop_index) {
 +                if from != to && to != from + 1 && !self.bookmarks.is_empty() {
 +                    // Perform the reorder
 +                    let bookmark = self.bookmarks.remove(from);
 +                    let new_index = if to > from { to - 1 } else { to };
 +                    self.bookmarks.insert(new_index, bookmark);
 +                    self.save_bookmarks();
 +                    true
 +                } else {
 +                    false
 +                }
 +            } else {
 +                false
 +            }
 +        } else {
 +            false
 +        };
++
 +        self.cancel_bookmark_drag();
 +        result
 +    }
++
 +    /// Cancel bookmark drag.
 +    pub fn cancel_bookmark_drag(&mut self) {
 +        self.bookmark_drag_index = None;
 +        self.bookmark_drop_index = None;
 +        self.bookmark_drag_start = None;
 +        self.bookmark_drag_active = false;
 +    }
++
 +    /// Check if bookmark drag is in progress.
 +    pub fn is_bookmark_dragging(&self) -> bool {
 +        self.bookmark_drag_active
 +    }
++
 +    /// Get the index of the bookmark being dragged (for checking if a click was on a bookmark).
 +    pub fn bookmark_drag_index(&self) -> Option<usize> {
 +        self.bookmark_drag_index
 +    }
++
 +    /// Get the path of the bookmark at the current drag index.
 +    pub fn bookmark_path_at_index(&self) -> Option<PathBuf> {
 +        self.bookmark_drag_index
 +            .and_then(|i| self.bookmarks.get(i))
 +            .map(|b| b.path.clone())
 +    }
++
      /// Update bounds.
      pub fn set_bounds(&mut self, bounds: Rect) {
          self.bounds = bounds;
                  .font_size(theme.font_size - 2.0)
                  .color(theme.item_foreground.with_alpha(0.4));
              renderer.text("Ctrl+D to add", (header_x + 4) as f64, y as f64, &hint_style)?;
++
 +            // Draw drop indicator at start if dragging (shouldn't happen but be safe)
 +            if self.bookmark_drag_active && self.bookmark_drop_index == Some(0) {
 +                self.render_drop_indicator(renderer, y)?;
 +            }
          } else {
              for i in 0..self.bookmarks.len() {
 +                // Draw drop indicator before this item if needed
 +                if self.bookmark_drag_active && self.bookmark_drop_index == Some(i) {
 +                    self.render_drop_indicator(renderer, y)?;
 +                }
++
                  let combined_index = self.places.len() + i;
                  let is_hovered = self.hovered == Some(combined_index);
 -                y = self.render_item(renderer, combined_index, y, is_hovered, &icon_style, &name_style, &hover_style)?;
 +                let is_dragging = self.bookmark_drag_index == Some(i);
 +                y = self.render_bookmark_item(renderer, combined_index, y, is_hovered, is_dragging, &icon_style, &name_style, &hover_style)?;
 +            }
++
 +            // Draw drop indicator at end if needed
 +            if self.bookmark_drag_active && self.bookmark_drop_index == Some(self.bookmarks.len()) {
 +                self.render_drop_indicator(renderer, y)?;
+             }
+         }
          Ok(y + self.item_height as i32)
+     }
++
 +    /// Render a bookmark item (supports dimming when being dragged).
 +    fn render_bookmark_item(
 +        &mut self,
 +        renderer: &Renderer,
 +        index: usize,
 +        y: i32,
 +        is_hovered: bool,
 +        is_dragging: bool,
 +        icon_style: &TextStyle,
 +        name_style: &TextStyle,
 +        hover_style: &TextStyle,
 +    ) -> anyhow::Result<i32> {
 +        let theme = renderer.theme();
++
 +        // Get item (need to reborrow to avoid issues)
 +        let (icon, name) = {
 +            let item = self.get_item(index).unwrap();
 +            (item.icon.clone(), item.name.clone())
 +        };
++
 +        // Update bounds for hit testing
 +        let item_bounds = Rect::new(
 +            self.bounds.x,
 +            y,
 +            self.bounds.width,
 +            self.item_height,
 +        );
++
 +        // Store bounds
 +        if let Some(item) = self.get_item_mut(index) {
 +            item.bounds = item_bounds;
 +        }
++
 +        // Draw hover background (unless being dragged)
 +        if is_hovered && !is_dragging {
 +            renderer.fill_rect(item_bounds, theme.item_background)?;
 +        }
++
 +        // Dim if being dragged
 +        let alpha = if is_dragging { 0.4 } else { 1.0 };
++
 +        let text_style = if is_hovered && !is_dragging {
 +            hover_style.clone()
 +        } else {
 +            name_style.clone().color(theme.item_foreground.with_alpha(alpha))
 +        };
++
 +        let icon_style = icon_style.clone().color(theme.item_foreground.with_alpha(0.7 * alpha));
++
 +        // Draw icon
 +        let icon_x = self.bounds.x + self.padding as i32;
 +        let text_y = y + (self.item_height as i32 - theme.font_size as i32) / 2;
 +        renderer.text(&icon, icon_x as f64, text_y as f64, &icon_style)?;
++
 +        // Draw name
 +        let name_x = icon_x + 20;
 +        renderer.text(&name, name_x as f64, text_y as f64, &text_style)?;
++
 +        Ok(y + self.item_height as i32)
 +    }
++
 +    /// Render a drop indicator line.
 +    fn render_drop_indicator(&self, renderer: &Renderer, y: i32) -> anyhow::Result<()> {
 +        let theme = renderer.theme();
 +        let line_y = y - 2;
 +        renderer.line(
 +            (self.bounds.x + self.padding as i32) as f64,
 +            line_y as f64,
 +            (self.bounds.x + self.bounds.width as i32 - self.padding as i32) as f64,
 +            line_y as f64,
 +            theme.selection_background,
 +            2.0,
 +        )?;
 +        Ok(())
 +    }
+ }