`af05392`

ui: add breadcrumb truncation for long paths

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

SHA: af0539224f60c4e9c094da4e0f69494fc8c47437
Parents: 3651dd8
Tree: a727aa2

7 changed files

Status	File	+	-
M	`garfield/src/app.rs`	138	5
M	`garfield/src/ui/breadcrumb.rs`	74	7
M	`garfield/src/ui/column_view.rs`	87	15
M	`garfield/src/ui/grid_view.rs`	19	0
M	`garfield/src/ui/list_view.rs`	14	0
M	`garfield/src/ui/sidebar.rs`	40	0
M	`garfield/src/ui/tab.rs`	9	0

garfield/src/app.rsmodified

  use garfield::ui::{AddressBar, Breadcrumb, HelpModal, Pane, Sidebar, StatusBar, TabBar, TabInfo, Toolbar, ToolbarAction, ViewMode, TAB_BAR_HEIGHT, TOOLBAR_HEIGHT};
  use anyhow::Result;
  use gartk_core::{InputEvent, Key, Point, Rect, Theme};
 -use gartk_render::{Renderer, Surface};
 +use gartk_render::{Renderer, Surface, TextStyle};
  use gartk_x11::{Connection, EventLoop, EventLoopConfig, Window, WindowConfig};
  use std::path::PathBuf;
  use std::time::Instant;
      last_click_time: Option<Instant>,
      /// Last click position for double-click detection.
      last_click_pos: Option<Point>,
 +    /// Path being dragged for bookmark drop (directory only).
 +    drag_source_path: Option<PathBuf>,
 +    /// Name of the item being dragged (for visual feedback).
 +    drag_label: Option<String>,
 +    /// Starting position of potential drag.
 +    drag_start_pos: Option<Point>,
 +    /// Current mouse position during drag (for visual feedback).
 +    drag_current_pos: Option<Point>,
 +    /// Whether drag is actively in progress (moved past threshold).
 +    drag_active: bool,
+ }
  impl App {
              pane_resize_path: None,
              last_click_time: None,
              last_click_pos: None,
 +            drag_source_path: None,
 +            drag_label: None,
 +            drag_start_pos: None,
 +            drag_current_pos: None,
 +            drag_active: false,
          };
          app.update_status_bar();
                      self.handle_mouse_press(pos, &mouse_event.modifiers);
                      ev.request_redraw();
+                 }
 -                InputEvent::MouseRelease(_) => {
 -                    self.handle_mouse_release();
 +                InputEvent::MouseRelease(mouse_event) => {
 +                    let pos = Point::new(mouse_event.position.x, mouse_event.position.y);
 +                    self.handle_mouse_release(pos);
                      ev.request_redraw();
+                 }
                  InputEvent::MouseMove(mouse_event) => {
                      tab.on_click(pos, modifiers);
+                 }
+             }
++
 +            // Capture drag source from entry at click position (for bookmark drag)
 +            let entry_at_click = self.focused_pane()
 +                .and_then(|pane| pane.active_tab())
 +                .and_then(|tab| tab.entry_at_point(pos))
 +                .filter(|e| e.is_dir())
 +                .map(|e| (e.path.clone(), e.name.clone()));
++
 +            if let Some((path, name)) = entry_at_click {
 +                self.drag_source_path = Some(path);
 +                self.drag_label = Some(name);
 +                self.drag_start_pos = Some(pos);
 +                self.drag_current_pos = Some(pos);
 +                self.drag_active = false;
 +            }
+         }
+     }
      /// Handle mouse release.
 -    fn handle_mouse_release(&mut self) {
 +    fn handle_mouse_release(&mut self, pos: Point) {
 +        // Handle bookmark drag drop
 +        if self.drag_active {
 +            if let Some(path) = self.drag_source_path.take() {
 +                if self.sidebar.is_bookmark_drop_zone(pos) {
 +                    self.sidebar.add_bookmark(&path);
 +                }
 +            }
 +        }
++
 +        // Clear drag state
 +        self.drag_source_path = None;
 +        self.drag_label = None;
 +        self.drag_start_pos = None;
 +        self.drag_current_pos = None;
 +        self.drag_active = false;
 +        self.sidebar.set_drop_highlight(false);
++
          // Clear pane resize
          self.pane_resize_path = None;
+             }
+         }
 +        // Handle bookmark drag in progress
 +        if self.drag_source_path.is_some() {
 +            // Update current drag position for visual feedback
 +            self.drag_current_pos = Some(pos);
++
 +            // Check if we've moved past the drag threshold (5px)
 +            if let Some(start_pos) = self.drag_start_pos {
 +                let distance = ((pos.x - start_pos.x).pow(2) + (pos.y - start_pos.y).pow(2)) as f64;
 +                if distance.sqrt() > 5.0 {
 +                    self.drag_active = true;
 +                }
 +            }
++
 +            // Update sidebar drop highlight if drag is active
 +            if self.drag_active {
 +                let is_over_drop_zone = self.sidebar.is_bookmark_drop_zone(pos);
 +                self.sidebar.set_drop_highlight(is_over_drop_zone);
 +            }
 +        }
++
          self.toolbar.on_mouse_move(pos);
          self.breadcrumb.on_mouse_move(pos);
          self.sidebar.on_mouse_move(pos);
          match key {
              Key::Escape => {
 -                if self.address_bar.is_active() {
 +                // Cancel drag first if active
 +                if self.drag_active || self.drag_source_path.is_some() {
 +                    self.drag_source_path = None;
 +                    self.drag_label = None;
 +                    self.drag_start_pos = None;
 +                    self.drag_current_pos = None;
 +                    self.drag_active = false;
 +                    self.sidebar.set_drop_highlight(false);
 +                } else if self.address_bar.is_active() {
                      self.address_bar.cancel();
                  } else {
                      self.should_quit = true;
          // Draw toolbar tooltip overlay (on top of other UI)
          self.toolbar.render_tooltip_overlay(&self.renderer)?;
 +        // Draw drag label overlay (on top of other UI)
 +        self.render_drag_label()?;
++
          // Draw help modal overlay (on top of everything)
          self.help_modal.render(&self.renderer)?;
          Ok(())
+     }
 +    /// Render the drag label overlay when dragging a folder.
 +    fn render_drag_label(&self) -> Result<()> {
 +        // Only render if drag is active and we have a label
 +        if !self.drag_active {
 +            return Ok(());
 +        }
++
 +        let (label, pos) = match (&self.drag_label, self.drag_current_pos) {
 +            (Some(label), Some(pos)) => (label, pos),
 +            _ => return Ok(()),
 +        };
++
 +        let theme = self.renderer.theme();
++
 +        // Create text style for the drag label
 +        let text_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size)
 +            .color(theme.item_foreground);
++
 +        // Measure the text to size the background
 +        let text_size = self.renderer.measure_text(label, &text_style)?;
++
 +        // Position the label slightly offset from the cursor
 +        let label_x = pos.x + 16;
 +        let label_y = pos.y + 8;
 +        let padding = 8;
++
 +        // Draw background with rounded appearance
 +        let bg_rect = Rect::new(
 +            label_x - padding,
 +            label_y - padding / 2,
 +            text_size.width + (padding * 2) as u32,
 +            text_size.height + padding as u32,
 +        );
++
 +        // Semi-transparent dark background
 +        let bg_color = gartk_core::Color::from_u8(40, 40, 45, 230);
 +        self.renderer.fill_rect(bg_rect, bg_color)?;
++
 +        // Border
 +        let border_color = theme.selection_background.with_alpha(0.8);
 +        self.renderer.stroke_rect(bg_rect, border_color, 1.0)?;
++
 +        // Folder icon prefix
 +        let icon_style = text_style.clone().color(theme.selection_background);
 +        self.renderer.text("*", label_x as f64, label_y as f64, &icon_style)?;
++
 +        // Draw the text
 +        self.renderer.text(label, (label_x + 14) as f64, label_y as f64, &text_style)?;
++
 +        Ok(())
 +    }
++
      /// Blit the rendered surface to the window.
      fn blit_surface(&mut self) -> Result<()> {
          let size = self.renderer.size();

garfield/src/ui/breadcrumb.rsmodified

          renderer.text(">", (self.bounds.x + 8 + button_width) as f64, button_y as f64, &forward_style)?;
          // Start position for path segments (after buttons)
 -        let mut x = self.bounds.x + 8 + button_width * 2 + 8;
 +        let start_x = self.bounds.x + 8 + button_width * 2 + 8;
          let text_y = self.bounds.y + (self.bounds.height as i32 - theme.font_size as i32) / 2;
 +        let available_width = (self.bounds.x + self.bounds.width as i32 - start_x - 16) as u32;
          // Check if first segment is root "/" for separator logic
          let first_is_root = self.segments.first().map(|s| s.text == "/").unwrap_or(false);
 -        // Measure and render segments
 -        for (i, segment) in self.segments.iter_mut().enumerate() {
 -            // Add separator before non-root segments (but not after root "/")
 +        // Measure total width and individual segment widths
 +        let ellipsis = "...";
 +        let ellipsis_size = renderer.measure_text(ellipsis, &separator_style)?;
 +        let sep_size = renderer.measure_text(&self.separator, &separator_style)?;
++
 +        let mut segment_widths: Vec<u32> = Vec::new();
 +        let mut total_width: u32 = 0;
++
 +        for (i, segment) in self.segments.iter().enumerate() {
 +            let seg_width = renderer.measure_text(&segment.text, &style)?.width + 4;
 +            segment_widths.push(seg_width);
++
 +            // Add separator width
              if i > 0 {
 -                // If previous segment was root "/", just add space, not " / "
 +                let sep_w = if i == 1 && first_is_root { 8 } else { sep_size.width };
 +                total_width += sep_w;
 +            }
 +            total_width += seg_width;
 +        }
++
 +        // Determine which segments to skip (truncate from left)
 +        let mut skip_count = 0;
 +        let mut show_ellipsis = false;
++
 +        if total_width > available_width && self.segments.len() > 2 {
 +            // Need to truncate - always show at least root and last segment
 +            let mut running_width = ellipsis_size.width + sep_size.width; // "... / "
++
 +            // Start from the end and work backwards to find how many we can show
 +            let mut can_show_from = self.segments.len();
 +            for i in (1..self.segments.len()).rev() {
 +                let seg_width = segment_widths[i] + sep_size.width;
 +                if running_width + seg_width <= available_width {
 +                    running_width += seg_width;
 +                    can_show_from = i;
 +                } else {
 +                    break;
 +                }
 +            }
++
 +            if can_show_from > 1 {
 +                skip_count = can_show_from - 1; // Skip segments 1 to can_show_from-1 (keep root)
 +                show_ellipsis = true;
 +            }
 +        }
++
 +        // Render segments
 +        let mut x = start_x;
++
 +        for (i, segment) in self.segments.iter_mut().enumerate() {
 +            // Skip truncated segments (but always show root at index 0)
 +            if i > 0 && i <= skip_count {
 +                // Clear bounds for skipped segments
 +                segment.bounds = Rect::new(0, 0, 0, 0);
 +                continue;
 +            }
++
 +            // Add ellipsis after root if truncating
 +            if show_ellipsis && i == skip_count + 1 {
 +                let sep = if first_is_root { " " } else { &self.separator };
 +                let sep_w = renderer.measure_text(sep, &separator_style)?;
 +                renderer.text(sep, x as f64, text_y as f64, &separator_style)?;
 +                x += sep_w.width as i32;
++
 +                renderer.text(ellipsis, x as f64, text_y as f64, &separator_style)?;
 +                x += ellipsis_size.width as i32;
++
 +                renderer.text(&self.separator, x as f64, text_y as f64, &separator_style)?;
 +                x += sep_size.width as i32;
 +            } else if i > 0 && !(show_ellipsis && i == skip_count + 1) {
 +                // Normal separator
                  let sep = if i == 1 && first_is_root {
                      " "
                  } else {
                      &self.separator
                  };
 -                let sep_size = renderer.measure_text(sep, &separator_style)?;
 +                let sep_w = renderer.measure_text(sep, &separator_style)?;
                  renderer.text(sep, x as f64, text_y as f64, &separator_style)?;
 -                x += sep_size.width as i32;
 +                x += sep_w.width as i32;
+             }
              // Measure segment

garfield/src/ui/column_view.rsmodified

      None,
+ }
 +/// Role of a column for rendering purposes.
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +enum ColumnRole {
 +    /// Parent column - dimmed position indicator.
 +    Parent,
 +    /// Current column - active selection highlight.
 +    Current,
 +    /// Preview column - no selection highlight.
 +    Preview,
 +}
++
  /// A single column in the Miller columns view.
  struct Column {
      /// Entries in this column.
+         }
+     }
 +    /// Get the entry at the given position (for drag detection).
 +    pub fn entry_at_point(&self, pos: Point) -> Option<&FileEntry> {
 +        // Check current column (main selection column)
 +        if self.current_column.bounds.contains_point(pos) {
 +            let visible = self.visible_entries();
 +            let visible_rows = self.current_column.visible_rows();
++
 +            for i in self.current_column.scroll_offset..(self.current_column.scroll_offset + visible_rows).min(visible.len()) {
 +                let y = self.current_column.bounds.y + ((i - self.current_column.scroll_offset) as i32 * ROW_HEIGHT as i32);
 +                let row = Rect::new(self.current_column.bounds.x, y, self.current_column.bounds.width, ROW_HEIGHT);
++
 +                if row.contains_point(pos) {
 +                    return visible.get(i).copied();
 +                }
 +            }
 +        }
++
 +        // Check parent column
 +        if let Some(ref parent) = self.parent_column {
 +            if parent.bounds.contains_point(pos) {
 +                let visible = parent.visible_entries(self.show_hidden);
 +                let visible_rows = parent.visible_rows();
++
 +                for i in parent.scroll_offset..(parent.scroll_offset + visible_rows).min(visible.len()) {
 +                    let y = parent.bounds.y + ((i - parent.scroll_offset) as i32 * ROW_HEIGHT as i32);
 +                    let row = Rect::new(parent.bounds.x, y, parent.bounds.width, ROW_HEIGHT);
++
 +                    if row.contains_point(pos) {
 +                        return visible.get(i).copied();
 +                    }
 +                }
 +            }
 +        }
++
 +        // Check preview column
 +        if let Some(ref preview) = self.preview_column {
 +            if preview.bounds.contains_point(pos) {
 +                let visible = preview.visible_entries(self.show_hidden);
 +                let visible_rows = preview.visible_rows();
++
 +                for i in preview.scroll_offset..(preview.scroll_offset + visible_rows).min(visible.len()) {
 +                    let y = preview.bounds.y + ((i - preview.scroll_offset) as i32 * ROW_HEIGHT as i32);
 +                    let row = Rect::new(preview.bounds.x, y, preview.bounds.width, ROW_HEIGHT);
++
 +                    if row.contains_point(pos) {
 +                        return visible.get(i).copied();
 +                    }
 +                }
 +            }
 +        }
++
 +        None
 +    }
++
      /// Handle click in any column. Returns click result.
      pub fn on_click(&mut self, pos: Point, modifiers: &Modifiers) -> ColumnClickResult {
          // Check parent column click - navigate to clicked directory
      pub fn render(&self, renderer: &Renderer) -> anyhow::Result<()> {
          let theme = renderer.theme();
 -        // Draw parent column
 +        // Draw parent column (with dimmed position indicator)
          if let Some(ref parent) = self.parent_column {
 -            self.render_column(renderer, parent, false)?;
 +            self.render_column(renderer, parent, ColumnRole::Parent)?;
              // Draw divider
              let divider_x = parent.bounds.x + parent.bounds.width as i32;
              renderer.line(
              )?;
+         }
 -        // Draw current column
 -        self.render_column(renderer, &self.current_column, true)?;
 +        // Draw current column (with active selection highlight)
 +        self.render_column(renderer, &self.current_column, ColumnRole::Current)?;
 -        // Draw preview column
 +        // Draw preview column (no selection highlight)
          if let Some(ref preview) = self.preview_column {
              let divider_x = self.current_column.bounds.x + self.current_column.bounds.width as i32;
              renderer.line(
                  theme.border,
 .0,
              )?;
 -            self.render_column(renderer, preview, false)?;
 +            self.render_column(renderer, preview, ColumnRole::Preview)?;
          } else if let Some(entry) = self.selected_entry() {
              // Show file info for non-directories
              if !entry.is_dir() {
+     }
      /// Render a single column.
 -    fn render_column(&self, renderer: &Renderer, column: &Column, is_current: bool) -> anyhow::Result<()> {
 +    fn render_column(&self, renderer: &Renderer, column: &Column, role: ColumnRole) -> anyhow::Result<()> {
          let theme = renderer.theme();
          let visible = column.visible_entries(self.show_hidden);
          let visible_rows = column.visible_rows();
              let y = column.bounds.y + (i as i32 * ROW_HEIGHT as i32);
              let row = Rect::new(column.bounds.x, y, column.bounds.width, ROW_HEIGHT);
 -            let is_selected = if is_current {
 -                self.selected.contains(&actual_index)
 -            } else {
 -                actual_index == column.selected
 +            // Determine selection state based on column role
 +            let (is_selected, show_highlight) = match role {
 +                ColumnRole::Current => (self.selected.contains(&actual_index), true),
 +                ColumnRole::Parent => (actual_index == column.selected, true),
 +                ColumnRole::Preview => (false, false), // No highlight in preview
              };
              let is_hovered = column.hovered == Some(actual_index);
              // Row background
 -            if is_selected {
 -                renderer.fill_rect(row, theme.item_selected_background)?;
 +            if is_selected && show_highlight {
 +                if role == ColumnRole::Parent {
 +                    // Dimmer highlight for parent column position indicator
 +                    renderer.fill_rect(row, theme.item_selected_background.with_alpha(0.4))?;
 +                } else {
 +                    // Full highlight for current column
 +                    renderer.fill_rect(row, theme.item_selected_background)?;
 +                }
              } else if is_hovered {
                  renderer.fill_rect(row, theme.item_background)?;
+             }
 -            // Entry color
 -            let text_color = if is_selected {
 +            // Entry color - don't use selection foreground for parent column
 +            let text_color = if is_selected && show_highlight && role == ColumnRole::Current {
                  theme.selection_foreground
              } else if entry.hidden {
                  theme.item_foreground.with_alpha(0.5)

garfield/src/ui/grid_view.rsmodified

+         }
+     }
 +    /// Get the entry at the given position (for drag detection).
 +    pub fn entry_at_point(&self, pos: Point) -> Option<&FileEntry> {
 +        if !self.bounds.contains_point(pos) {
 +            return None;
 +        }
++
 +        let visible = self.visible_entries();
 +        let start_index = self.scroll_offset * self.columns;
 +        let end_index = (start_index + self.visible_rows() * self.columns).min(visible.len());
++
 +        for i in start_index..end_index {
 +            if self.cell_bounds(i).contains_point(pos) {
 +                return visible.get(i).copied();
 +            }
 +        }
++
 +        None
 +    }
++
      /// Handle cell click. Returns index of clicked cell if valid.
      pub fn on_click(&mut self, pos: Point, modifiers: &Modifiers) -> Option<usize> {
          if !self.bounds.contains_point(pos) {

garfield/src/ui/list_view.rsmodified

          None
+     }
 +    /// Get the entry at the given position (for drag detection).
 +    pub fn entry_at_point(&self, pos: Point) -> Option<&FileEntry> {
 +        let content = self.content_bounds();
 +        if !content.contains_point(pos) {
 +            return None;
 +        }
++
 +        let relative_y = pos.y - content.y;
 +        let row_index = self.scroll_offset + (relative_y / ROW_HEIGHT as i32) as usize;
++
 +        let visible = self.visible_entries();
 +        visible.get(row_index).copied()
 +    }
++
      /// Handle row click. Returns index of clicked row if valid.
      pub fn on_row_click(&mut self, pos: Point, modifiers: &Modifiers) -> Option<usize> {
          let content = self.content_bounds();

garfield/src/ui/sidebar.rsmodified

      padding: u32,
      /// Path to bookmarks file.
      bookmarks_path: PathBuf,
 +    /// Y coordinate where bookmarks section starts (for drop zone detection).
 +    bookmarks_section_y: i32,
 +    /// Whether to show drop highlight on bookmarks section.
 +    drop_highlight: bool,
+ }
  impl Sidebar {
              item_height: 28,
              padding: 8,
              bookmarks_path,
 +            bookmarks_section_y: 0,
 +            drop_highlight: false,
          };
          sidebar.populate_default_places();
          sidebar.load_bookmarks();
          self.hovered = None;
+     }
 +    /// Check if the given position is within the bookmarks drop zone.
 +    pub fn is_bookmark_drop_zone(&self, pos: Point) -> bool {
 +        if !self.visible {
 +            return false;
 +        }
++
 +        // Check if within sidebar bounds
 +        if !self.bounds.contains_point(pos) {
 +            return false;
 +        }
++
 +        // Check if below the bookmarks section start
 +        pos.y >= self.bookmarks_section_y
 +    }
++
 +    /// Set whether to show the drop highlight on the bookmarks section.
 +    pub fn set_drop_highlight(&mut self, highlight: bool) {
 +        self.drop_highlight = highlight;
 +    }
++
      /// Render the sidebar.
      pub fn render(&mut self, renderer: &Renderer) -> anyhow::Result<()> {
          if !self.visible {
          )?;
          y += 8;
 +        // Store the bookmarks section start for drop zone detection
 +        self.bookmarks_section_y = y;
++
 +        // Draw drop highlight if active
 +        if self.drop_highlight {
 +            let highlight_rect = Rect::new(
 +                self.bounds.x,
 +                y,
 +                self.bounds.width,
 +                (self.bounds.y + self.bounds.height as i32 - y) as u32,
 +            );
 +            renderer.fill_rect(highlight_rect, theme.selection_background.with_alpha(0.2))?;
 +        }
++
          // Header
          let header_x = self.bounds.x + self.padding as i32;
          renderer.text("Bookmarks", header_x as f64, y as f64, &header_style)?;

garfield/src/ui/tab.rsmodified

+         }
+     }
 +    /// Get the entry at the given position (for drag detection).
 +    pub fn entry_at_point(&self, pos: Point) -> Option<&FileEntry> {
 +        match self.view_mode {
 +            ViewMode::List => self.list_view.entry_at_point(pos),
 +            ViewMode::Grid => self.grid_view.entry_at_point(pos),
 +            ViewMode::Columns => self.column_view.entry_at_point(pos),
 +        }
 +    }
++
      /// Enter the selected entry (open directory).
      pub fn enter_selected(&mut self) {
          if let Some(entry) = self.selected_entry().cloned() {