`e2f36bd`

ui: add right-click context menu with submenus and new file/duplicate actions

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

SHA: e2f36bdbb373dfad83a316c75839227b48c6412b
Parents: 3289b39
Tree: e156b6e

5 changed files

Status	File	+	-
M	`Cargo.lock`	3	3
M	`garfield/src/app.rs`	264	2
A	`garfield/src/ui/context_menu.rs`	912	0
M	`garfield/src/ui/mod.rs`	2	0
M	`garfield/src/ui/tab.rs`	10	0

Cargo.lockmodified

  [[package]]
  name = "gartk-core"
 -version = "0.1.0"
 +version = "0.3.0"
  dependencies = [
   "serde",
   "thiserror",
  [[package]]
  name = "gartk-render"
 -version = "0.1.0"
 +version = "0.3.0"
  dependencies = [
   "cairo-rs",
   "gartk-core",
  [[package]]
  name = "gartk-x11"
 -version = "0.1.0"
 +version = "0.3.0"
  dependencies = [
   "gartk-core",
   "thiserror",

garfield/src/app.rsmodified

      trash_files, restore_from_trash,
  };
  use garfield::ui::pane::SplitDirection;
 -use garfield::ui::{AddressBar, Breadcrumb, ConfirmDialog, ConflictAction, ConflictDialog, DialogResult, HelpModal, Pane, ProgressDialog, Sidebar, StatusBar, TabBar, TabInfo, Toolbar, ToolbarAction, ViewMode, TAB_BAR_HEIGHT, TOOLBAR_HEIGHT};
 +use garfield::ui::{AddressBar, Breadcrumb, ConfirmDialog, ConflictAction, ConflictDialog, ContextMenu, ContextMenuAction, ContextType, DialogResult, HelpModal, Pane, ProgressDialog, Sidebar, StatusBar, TabBar, TabInfo, Toolbar, ToolbarAction, ViewMode, TAB_BAR_HEIGHT, TOOLBAR_HEIGHT};
  use anyhow::Result;
  use gartk_core::{InputEvent, Key, MouseButton, Point, Rect, Theme};
  use gartk_render::{Renderer, Surface, TextStyle};
      conflict_dialog: ConflictDialog,
      /// Progress dialog for long operations.
      progress_dialog: ProgressDialog,
 +    /// Context menu for right-click actions.
 +    context_menu: ContextMenu,
      /// Paths pending delete confirmation.
      pending_delete_paths: Vec<PathBuf>,
      /// Undo/redo stack for file operations.
          // Create progress dialog (full window bounds)
          let progress_dialog = ProgressDialog::new(Rect::new(0, 0, width, height));
 +        // Create context menu (full window bounds for positioning)
 +        let context_menu = ContextMenu::new(Rect::new(0, 0, width, height));
++
          // Content area bounds (for panes)
          let content_bounds = Rect::new(
              sidebar_w as i32,
              confirm_dialog,
              conflict_dialog,
              progress_dialog,
 +            context_menu,
              pending_delete_paths: Vec::new(),
              undo_stack: UndoStack::new(),
              pending_paste: None,
              return;
+         }
 +        // Check context menu
 +        if self.context_menu.is_visible() {
 +            if let Some(action) = self.context_menu.on_click(pos) {
 +                self.handle_context_menu_action(action);
 +            }
 +            return;
 +        }
++
 +        // Right-click shows context menu
 +        if button == Some(MouseButton::Right) {
 +            self.show_context_menu(pos);
 +            return;
 +        }
++
          // Handle middle-click on tab bar to close tab
          if button == Some(MouseButton::Middle) {
              if let Some(index) = self.tab_bar.tab_at_point(pos) {
              return;
+         }
 +        // Handle context menu hover
 +        if self.context_menu.is_visible() {
 +            self.context_menu.on_mouse_move(pos);
 +            return;
 +        }
++
          // Handle sidebar resize in progress
          if self.sidebar_resizing {
              let new_width = (pos.x - self.sidebar.bounds().x).max(0) as u32;
              return;
+         }
 +        // Handle context menu when visible
 +        if self.context_menu.is_visible() {
 +            if let Some(action) = self.context_menu.handle_key(key) {
 +                self.handle_context_menu_action(action);
 +            }
 +            return;
 +        }
++
          // F1 toggles help
          if *key == Key::F1 {
              self.help_modal.show();
+             }
+         }
 -        // Ctrl+Shift keybinds (splits, new folder)
 +        // Ctrl+Shift keybinds (splits, new folder, new file, duplicate)
          if modifiers.ctrl && modifiers.shift {
              match key {
                  Key::Char('n') | Key::Char('N') => {
                      self.create_new_folder();
                      return;
+                 }
 +                Key::Char('f') | Key::Char('F') => {
 +                    self.create_new_file();
 +                    return;
 +                }
 +                Key::Char('d') | Key::Char('D') => {
 +                    self.duplicate_selected();
 +                    return;
 +                }
                  Key::Char('h') | Key::Char('H') => {
                      self.split_horizontal();
                      return;
          let _ = self.window.connection().flush();
+     }
 +    /// Show the context menu at the given position.
 +    fn show_context_menu(&mut self, pos: Point) {
 +        // Determine context type based on what's under the cursor
 +        let (context_type, selected_count) = if let Some(pane) = self.focused_pane() {
 +            if let Some(tab) = pane.active_tab() {
 +                let selected = tab.selected_paths();
++
 +                if let Some(entry) = tab.entry_at_point(pos) {
 +                    // Clicked on an item
 +                    if selected.len() > 1 && selected.contains(&entry.path) {
 +                        (ContextType::MultiSelection, selected.len())
 +                    } else if entry.is_dir() {
 +                        (ContextType::Folder, 1)
 +                    } else {
 +                        (ContextType::File, 1)
 +                    }
 +                } else {
 +                    // Clicked on empty space
 +                    (ContextType::EmptySpace, 0)
 +                }
 +            } else {
 +                (ContextType::EmptySpace, 0)
 +            }
 +        } else {
 +            (ContextType::EmptySpace, 0)
 +        };
++
 +        let has_clipboard = self.clipboard.has_files();
 +        self.context_menu.show(pos, context_type, selected_count, has_clipboard);
 +    }
++
 +    /// Handle a context menu action.
 +    fn handle_context_menu_action(&mut self, action: ContextMenuAction) {
 +        match action {
 +            ContextMenuAction::Open => self.enter_selected(),
 +            ContextMenuAction::OpenWith(app) => self.open_with(&app),
 +            ContextMenuAction::OpenInNewTab => self.open_in_new_tab(),
 +            ContextMenuAction::Copy | ContextMenuAction::CopyAll => self.copy_selected(),
 +            ContextMenuAction::Cut | ContextMenuAction::CutAll => self.cut_selected(),
 +            ContextMenuAction::Duplicate => self.duplicate_selected(),
 +            ContextMenuAction::Rename => self.start_rename(),
 +            ContextMenuAction::Trash | ContextMenuAction::TrashAll => self.trash_selected(),
 +            ContextMenuAction::Delete | ContextMenuAction::DeleteAll => self.delete_selected_permanently(),
 +            ContextMenuAction::Properties => self.show_properties(),
 +            ContextMenuAction::NewFile => self.create_new_file(),
 +            ContextMenuAction::NewFolder => self.create_new_folder(),
 +            ContextMenuAction::Paste => self.paste(),
 +            ContextMenuAction::Refresh => self.refresh(),
 +            ContextMenuAction::ViewList => self.set_view_mode(ViewMode::List),
 +            ContextMenuAction::ViewGrid => self.set_view_mode(ViewMode::Grid),
 +            ContextMenuAction::ViewColumns => self.set_view_mode(ViewMode::Columns),
 +            ContextMenuAction::SortByName => self.set_sort_order(garfield::core::SortOrder::Name),
 +            ContextMenuAction::SortBySize => self.set_sort_order(garfield::core::SortOrder::Size),
 +            ContextMenuAction::SortByDate => self.set_sort_order(garfield::core::SortOrder::Modified),
 +            ContextMenuAction::SortByType => self.set_sort_order(garfield::core::SortOrder::Type),
 +        }
 +    }
++
 +    /// Open selected item with a specific application.
 +    fn open_with(&mut self, app: &str) {
 +        if app.is_empty() {
 +            self.status_bar.set_status_message("Application picker not implemented");
 +            return;
 +        }
++
 +        let paths = self.get_selected_paths();
 +        if let Some(path) = paths.first() {
 +            match std::process::Command::new(app).arg(path).spawn() {
 +                Ok(_) => self.status_bar.set_status_message(format!("Opened with {}", app)),
 +                Err(e) => self.status_bar.set_status_message(format!("Failed: {}", e)),
 +            }
 +        }
 +    }
++
 +    /// Open folder in new tab.
 +    fn open_in_new_tab(&mut self) {
 +        let entry_path = self.focused_pane()
 +            .and_then(|p| p.active_tab())
 +            .and_then(|t| t.selected_entry())
 +            .filter(|e| e.is_dir())
 +            .map(|e| e.path.clone());
++
 +        if let Some(path) = entry_path {
 +            if let Some(pane) = self.focused_pane_mut() {
 +                pane.add_tab(path);
 +            }
 +            self.sync_tab_bar();
 +            self.sync_breadcrumb();
 +            self.update_status_bar();
 +        }
 +    }
++
 +    /// Show properties dialog (placeholder).
 +    fn show_properties(&mut self) {
 +        self.status_bar.set_status_message("Properties dialog not implemented");
 +    }
++
 +    /// Set sort order from context menu.
 +    fn set_sort_order(&mut self, order: garfield::core::SortOrder) {
 +        if let Some(pane) = self.focused_pane_mut() {
 +            if let Some(tab) = pane.active_tab_mut() {
 +                let current_dir = tab.sort_direction();
 +                // Toggle direction if same order
 +                let new_dir = if tab.sort_order() == order {
 +                    match current_dir {
 +                        garfield::core::SortDirection::Ascending => garfield::core::SortDirection::Descending,
 +                        garfield::core::SortDirection::Descending => garfield::core::SortDirection::Ascending,
 +                    }
 +                } else {
 +                    garfield::core::SortDirection::Ascending
 +                };
 +                tab.set_sort(order, new_dir);
 +            }
 +        }
 +    }
++
      /// Create a new folder in the current directory.
      fn create_new_folder(&mut self) {
          let current_dir = self.focused_pane()
+         }
+     }
 +    /// Create a new empty file in the current directory.
 +    fn create_new_file(&mut self) {
 +        use garfield::core::make_unique_name;
++
 +        let current_dir = self.focused_pane()
 +            .and_then(|p| p.active_tab())
 +            .map(|t| t.current_path().clone());
++
 +        let current_dir = match current_dir {
 +            Some(d) => d,
 +            None => return,
 +        };
++
 +        // Generate unique name
 +        let unique_name = make_unique_name(&current_dir, "New File");
 +        let path = current_dir.join(&unique_name);
++
 +        match std::fs::File::create(&path) {
 +            Ok(_) => {
 +                self.status_bar.set_status_message(format!("Created '{}'", unique_name));
 +                self.refresh();
++
 +                // Select the new file and start rename
 +                if let Some(pane) = self.focused_pane_mut() {
 +                    if let Some(tab) = pane.active_tab_mut() {
 +                        if tab.select_by_name(&unique_name) {
 +                            tab.start_rename();
 +                        }
 +                    }
 +                }
 +            }
 +            Err(e) => {
 +                self.status_bar.set_status_message(format!("Failed to create file: {}", e));
 +            }
 +        }
 +    }
++
 +    /// Duplicate the selected files/folders in the current directory.
 +    fn duplicate_selected(&mut self) {
 +        use garfield::core::make_unique_name;
++
 +        let selected = self.get_selected_paths();
 +        if selected.is_empty() {
 +            self.status_bar.set_status_message("No items selected");
 +            return;
 +        }
++
 +        let dest_dir = self.focused_pane()
 +            .and_then(|p| p.active_tab())
 +            .map(|t| t.current_path().clone());
++
 +        let dest_dir = match dest_dir {
 +            Some(d) => d,
 +            None => return,
 +        };
++
 +        let mut success_count = 0;
 +        let mut last_created_name = String::new();
++
 +        for path in &selected {
 +            if let Some(name) = path.file_name() {
 +                let name_str = name.to_string_lossy();
 +                let unique_name = make_unique_name(&dest_dir, &name_str);
 +                let dest = dest_dir.join(&unique_name);
++
 +                let result = if path.is_dir() {
 +                    garfield::core::copy_to_path(path, &dest)
 +                } else {
 +                    std::fs::copy(path, &dest).map(|_| dest.clone())
 +                };
++
 +                if result.is_ok() {
 +                    success_count += 1;
 +                    last_created_name = unique_name;
 +                }
 +            }
 +        }
++
 +        if success_count > 0 {
 +            let msg = if success_count == 1 {
 +                format!("Duplicated as '{}'", last_created_name)
 +            } else {
 +                format!("Duplicated {} items", success_count)
 +            };
 +            self.status_bar.set_status_message(msg);
 +            self.refresh();
++
 +            // Select the last duplicated item
 +            if !last_created_name.is_empty() {
 +                if let Some(pane) = self.focused_pane_mut() {
 +                    if let Some(tab) = pane.active_tab_mut() {
 +                        tab.select_by_name(&last_created_name);
 +                    }
 +                }
 +            }
 +        } else {
 +            self.status_bar.set_status_message("Failed to duplicate items");
 +        }
 +    }
++
      /// Undo the last file operation.
      fn undo(&mut self) {
          let op = match self.undo_stack.pop_undo() {
          self.confirm_dialog.set_bounds(Rect::new(0, 0, width, height));
          self.conflict_dialog.set_bounds(Rect::new(0, 0, width, height));
          self.progress_dialog.set_bounds(Rect::new(0, 0, width, height));
 +        self.context_menu.set_bounds(Rect::new(0, 0, width, height));
+     }
      /// Render the application.
          // Draw conflict dialog overlay (on top of everything)
          self.conflict_dialog.render(&self.renderer)?;
 +        // Draw context menu overlay
 +        self.context_menu.render(&self.renderer)?;
++
          // Draw progress dialog overlay (on top of everything)
          self.progress_dialog.render(&self.renderer)?;

garfield/src/ui/context_menu.rsadded

 +//! Context menu component for right-click actions.
++
 +use anyhow::Result;
 +use gartk_core::{Key, Point, Rect};
 +use gartk_render::{Renderer, TextStyle};
 +use std::time::Instant;
++
 +/// Menu item height.
 +const ITEM_HEIGHT: u32 = 28;
++
 +/// Separator height.
 +const SEPARATOR_HEIGHT: u32 = 9;
++
 +/// Hover delay before opening submenu (milliseconds).
 +const SUBMENU_HOVER_DELAY_MS: u64 = 300;
++
 +/// Minimum menu width.
 +const MIN_MENU_WIDTH: u32 = 200;
++
 +/// Padding inside menu.
 +const MENU_PADDING: u32 = 4;
++
 +/// Context type determining which menu items to show.
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +pub enum ContextType {
 +    /// Right-click on a file.
 +    File,
 +    /// Right-click on a folder.
 +    Folder,
 +    /// Right-click on empty space in file view.
 +    EmptySpace,
 +    /// Multi-selection context.
 +    MultiSelection,
 +}
++
 +/// A context menu action.
 +#[derive(Debug, Clone, PartialEq, Eq)]
 +pub enum ContextMenuAction {
 +    // File/Folder actions
 +    Open,
 +    OpenWith(String),
 +    OpenInNewTab,
 +    Copy,
 +    Cut,
 +    Duplicate,
 +    Rename,
 +    Trash,
 +    Delete,
 +    Properties,
++
 +    // Empty space actions
 +    NewFile,
 +    NewFolder,
 +    Paste,
 +    Refresh,
++
 +    // View submenu actions
 +    ViewList,
 +    ViewGrid,
 +    ViewColumns,
++
 +    // Sort submenu actions
 +    SortByName,
 +    SortBySize,
 +    SortByDate,
 +    SortByType,
++
 +    // Multi-selection actions (same as single but for clarity)
 +    CopyAll,
 +    CutAll,
 +    TrashAll,
 +    DeleteAll,
 +}
++
 +/// A single menu item.
 +#[derive(Debug, Clone)]
 +pub enum MenuItem {
 +    /// Regular action item.
 +    Action {
 +        label: String,
 +        action: ContextMenuAction,
 +        shortcut: Option<String>,
 +        enabled: bool,
 +    },
 +    /// Separator line.
 +    Separator,
 +    /// Submenu with nested items.
 +    Submenu {
 +        label: String,
 +        items: Vec<MenuItem>,
 +    },
 +}
++
 +impl MenuItem {
 +    /// Create a new action item.
 +    pub fn action(label: &str, action: ContextMenuAction) -> Self {
 +        MenuItem::Action {
 +            label: label.to_string(),
 +            action,
 +            shortcut: None,
 +            enabled: true,
 +        }
 +    }
++
 +    /// Add a keyboard shortcut hint.
 +    pub fn with_shortcut(self, shortcut: &str) -> Self {
 +        match self {
 +            MenuItem::Action { label, action, enabled, .. } => MenuItem::Action {
 +                label,
 +                action,
 +                shortcut: Some(shortcut.to_string()),
 +                enabled,
 +            },
 +            other => other,
 +        }
 +    }
++
 +    /// Set enabled state.
 +    pub fn with_enabled(self, enabled: bool) -> Self {
 +        match self {
 +            MenuItem::Action { label, action, shortcut, .. } => MenuItem::Action {
 +                label,
 +                action,
 +                shortcut,
 +                enabled,
 +            },
 +            other => other,
 +        }
 +    }
++
 +    /// Create a submenu.
 +    pub fn submenu(label: &str, items: Vec<MenuItem>) -> Self {
 +        MenuItem::Submenu {
 +            label: label.to_string(),
 +            items,
 +        }
 +    }
++
 +    /// Create a separator.
 +    pub fn separator() -> Self {
 +        MenuItem::Separator
 +    }
++
 +    /// Check if this is a separator.
 +    fn is_separator(&self) -> bool {
 +        matches!(self, MenuItem::Separator)
 +    }
++
 +    /// Get the height of this item.
 +    fn height(&self) -> u32 {
 +        match self {
 +            MenuItem::Separator => SEPARATOR_HEIGHT,
 +            _ => ITEM_HEIGHT,
 +        }
 +    }
 +}
++
 +/// Rendered menu item with computed bounds.
 +struct RenderedItem {
 +    item: MenuItem,
 +    bounds: Rect,
 +}
++
 +/// Context menu state.
 +pub struct ContextMenu {
 +    /// Window bounds (for clipping/positioning).
 +    window_bounds: Rect,
 +    /// Menu bounds (position and size).
 +    menu_bounds: Rect,
 +    /// Whether the menu is visible.
 +    visible: bool,
 +    /// Context type.
 +    context_type: ContextType,
 +    /// Menu items.
 +    items: Vec<MenuItem>,
 +    /// Rendered items with bounds.
 +    rendered_items: Vec<RenderedItem>,
 +    /// Currently focused index (for keyboard nav).
 +    focused_index: Option<usize>,
 +    /// Hovered item index.
 +    hovered_index: Option<usize>,
 +    /// Open submenu index (if any).
 +    open_submenu_index: Option<usize>,
 +    /// Submenu focused index.
 +    submenu_focused_index: Option<usize>,
 +    /// Submenu hovered index.
 +    submenu_hovered_index: Option<usize>,
 +    /// Submenu items bounds.
 +    submenu_bounds: Option<Rect>,
 +    /// Submenu rendered items.
 +    submenu_rendered_items: Vec<RenderedItem>,
 +    /// Time when hover started on a submenu item (for delay).
 +    submenu_hover_start: Option<Instant>,
 +    /// Number of selected items (for multi-select labels).
 +    selected_count: usize,
 +    /// Whether clipboard has content (for paste enable).
 +    has_clipboard: bool,
 +}
++
 +impl ContextMenu {
 +    /// Create a new context menu.
 +    pub fn new(window_bounds: Rect) -> Self {
 +        Self {
 +            window_bounds,
 +            menu_bounds: Rect::new(0, 0, MIN_MENU_WIDTH, 0),
 +            visible: false,
 +            context_type: ContextType::EmptySpace,
 +            items: Vec::new(),
 +            rendered_items: Vec::new(),
 +            focused_index: None,
 +            hovered_index: None,
 +            open_submenu_index: None,
 +            submenu_focused_index: None,
 +            submenu_hovered_index: None,
 +            submenu_bounds: None,
 +            submenu_rendered_items: Vec::new(),
 +            submenu_hover_start: None,
 +            selected_count: 0,
 +            has_clipboard: false,
 +        }
 +    }
++
 +    /// Set window bounds.
 +    pub fn set_bounds(&mut self, bounds: Rect) {
 +        self.window_bounds = bounds;
 +    }
++
 +    /// Check if visible.
 +    pub fn is_visible(&self) -> bool {
 +        self.visible
 +    }
++
 +    /// Hide the menu.
 +    pub fn hide(&mut self) {
 +        self.visible = false;
 +        self.items.clear();
 +        self.rendered_items.clear();
 +        self.focused_index = None;
 +        self.hovered_index = None;
 +        self.open_submenu_index = None;
 +        self.submenu_focused_index = None;
 +        self.submenu_hovered_index = None;
 +        self.submenu_bounds = None;
 +        self.submenu_rendered_items.clear();
 +        self.submenu_hover_start = None;
 +    }
++
 +    /// Show the context menu at position.
 +    pub fn show(
 +        &mut self,
 +        pos: Point,
 +        context_type: ContextType,
 +        selected_count: usize,
 +        has_clipboard: bool,
 +    ) {
 +        self.context_type = context_type;
 +        self.selected_count = selected_count;
 +        self.has_clipboard = has_clipboard;
++
 +        // Build menu items based on context
 +        self.items = self.build_menu_items();
++
 +        // Calculate menu size
 +        let (width, height) = self.calculate_menu_size(&self.items);
++
 +        // Position menu (flip if near edges)
 +        let (x, y) = self.calculate_position(pos, width, height);
++
 +        self.menu_bounds = Rect::new(x, y, width, height);
 +        self.layout_items();
++
 +        self.visible = true;
 +        self.focused_index = Some(0);
 +        self.hovered_index = None;
 +        self.open_submenu_index = None;
 +    }
++
 +    /// Build menu items based on context type.
 +    fn build_menu_items(&self) -> Vec<MenuItem> {
 +        match self.context_type {
 +            ContextType::File => self.build_file_menu(),
 +            ContextType::Folder => self.build_folder_menu(),
 +            ContextType::EmptySpace => self.build_empty_space_menu(),
 +            ContextType::MultiSelection => self.build_multi_selection_menu(),
 +        }
 +    }
++
 +    fn build_file_menu(&self) -> Vec<MenuItem> {
 +        vec![
 +            MenuItem::action("Open", ContextMenuAction::Open),
 +            MenuItem::submenu("Open With", self.build_open_with_submenu()),
 +            MenuItem::separator(),
 +            MenuItem::action("Copy", ContextMenuAction::Copy).with_shortcut("Ctrl+C"),
 +            MenuItem::action("Cut", ContextMenuAction::Cut).with_shortcut("Ctrl+X"),
 +            MenuItem::action("Duplicate", ContextMenuAction::Duplicate).with_shortcut("Ctrl+Shift+D"),
 +            MenuItem::separator(),
 +            MenuItem::action("Rename", ContextMenuAction::Rename).with_shortcut("F2"),
 +            MenuItem::action("Move to Trash", ContextMenuAction::Trash).with_shortcut("Del"),
 +            MenuItem::action("Delete Permanently", ContextMenuAction::Delete).with_shortcut("Shift+Del"),
 +            MenuItem::separator(),
 +            MenuItem::action("Properties", ContextMenuAction::Properties),
 +        ]
 +    }
++
 +    fn build_folder_menu(&self) -> Vec<MenuItem> {
 +        vec![
 +            MenuItem::action("Open", ContextMenuAction::Open),
 +            MenuItem::action("Open in New Tab", ContextMenuAction::OpenInNewTab),
 +            MenuItem::submenu("Open With", self.build_open_with_submenu()),
 +            MenuItem::separator(),
 +            MenuItem::action("Copy", ContextMenuAction::Copy).with_shortcut("Ctrl+C"),
 +            MenuItem::action("Cut", ContextMenuAction::Cut).with_shortcut("Ctrl+X"),
 +            MenuItem::action("Duplicate", ContextMenuAction::Duplicate).with_shortcut("Ctrl+Shift+D"),
 +            MenuItem::separator(),
 +            MenuItem::action("Rename", ContextMenuAction::Rename).with_shortcut("F2"),
 +            MenuItem::action("Move to Trash", ContextMenuAction::Trash).with_shortcut("Del"),
 +            MenuItem::action("Delete Permanently", ContextMenuAction::Delete).with_shortcut("Shift+Del"),
 +            MenuItem::separator(),
 +            MenuItem::action("Properties", ContextMenuAction::Properties),
 +        ]
 +    }
++
 +    fn build_empty_space_menu(&self) -> Vec<MenuItem> {
 +        vec![
 +            MenuItem::action("New File", ContextMenuAction::NewFile).with_shortcut("Ctrl+Shift+F"),
 +            MenuItem::action("New Folder", ContextMenuAction::NewFolder).with_shortcut("Ctrl+Shift+N"),
 +            MenuItem::separator(),
 +            MenuItem::action("Paste", ContextMenuAction::Paste)
 +                .with_shortcut("Ctrl+V")
 +                .with_enabled(self.has_clipboard),
 +            MenuItem::separator(),
 +            MenuItem::action("Refresh", ContextMenuAction::Refresh).with_shortcut("F5"),
 +            MenuItem::separator(),
 +            MenuItem::submenu("View", self.build_view_submenu()),
 +            MenuItem::submenu("Sort By", self.build_sort_submenu()),
 +        ]
 +    }
++
 +    fn build_multi_selection_menu(&self) -> Vec<MenuItem> {
 +        let count = self.selected_count;
 +        vec![
 +            MenuItem::action(&format!("Copy {} items", count), ContextMenuAction::CopyAll)
 +                .with_shortcut("Ctrl+C"),
 +            MenuItem::action(&format!("Cut {} items", count), ContextMenuAction::CutAll)
 +                .with_shortcut("Ctrl+X"),
 +            MenuItem::separator(),
 +            MenuItem::action(&format!("Move {} items to Trash", count), ContextMenuAction::TrashAll)
 +                .with_shortcut("Del"),
 +            MenuItem::action(&format!("Delete {} items", count), ContextMenuAction::DeleteAll)
 +                .with_shortcut("Shift+Del"),
 +        ]
 +    }
++
 +    fn build_open_with_submenu(&self) -> Vec<MenuItem> {
 +        vec![
 +            MenuItem::action("Default Application", ContextMenuAction::OpenWith("xdg-open".to_string())),
 +            MenuItem::action("Text Editor", ContextMenuAction::OpenWith("xdg-open".to_string())),
 +            MenuItem::separator(),
 +            MenuItem::action("Other Application...", ContextMenuAction::OpenWith(String::new())),
 +        ]
 +    }
++
 +    fn build_view_submenu(&self) -> Vec<MenuItem> {
 +        vec![
 +            MenuItem::action("List", ContextMenuAction::ViewList).with_shortcut("Ctrl+1"),
 +            MenuItem::action("Grid", ContextMenuAction::ViewGrid).with_shortcut("Ctrl+2"),
 +            MenuItem::action("Columns", ContextMenuAction::ViewColumns).with_shortcut("Ctrl+3"),
 +        ]
 +    }
++
 +    fn build_sort_submenu(&self) -> Vec<MenuItem> {
 +        vec![
 +            MenuItem::action("Name", ContextMenuAction::SortByName),
 +            MenuItem::action("Size", ContextMenuAction::SortBySize),
 +            MenuItem::action("Date Modified", ContextMenuAction::SortByDate),
 +            MenuItem::action("Type", ContextMenuAction::SortByType),
 +        ]
 +    }
++
 +    /// Calculate menu dimensions.
 +    fn calculate_menu_size(&self, items: &[MenuItem]) -> (u32, u32) {
 +        let height: u32 = items.iter().map(|i| i.height()).sum::<u32>() + (MENU_PADDING * 2);
 +        let width = MIN_MENU_WIDTH + 60; // Extra space for shortcuts
 +        (width, height)
 +    }
++
 +    /// Calculate menu position, flipping if near window edges.
 +    fn calculate_position(&self, pos: Point, width: u32, height: u32) -> (i32, i32) {
 +        let mut x = pos.x;
 +        let mut y = pos.y;
++
 +        // Flip horizontally if menu would extend past right edge
 +        if x + width as i32 > self.window_bounds.x + self.window_bounds.width as i32 {
 +            x = pos.x - width as i32;
 +        }
++
 +        // Flip vertically if menu would extend past bottom edge
 +        if y + height as i32 > self.window_bounds.y + self.window_bounds.height as i32 {
 +            y = pos.y - height as i32;
 +        }
++
 +        // Ensure menu stays within bounds
 +        x = x.max(self.window_bounds.x);
 +        y = y.max(self.window_bounds.y);
++
 +        (x, y)
 +    }
++
 +    /// Layout items and calculate their bounds.
 +    fn layout_items(&mut self) {
 +        self.rendered_items.clear();
 +        let mut y = self.menu_bounds.y + MENU_PADDING as i32;
++
 +        for item in &self.items {
 +            let height = item.height();
++
 +            let bounds = Rect::new(
 +                self.menu_bounds.x + MENU_PADDING as i32,
 +                y,
 +                self.menu_bounds.width - MENU_PADDING * 2,
 +                height,
 +            );
++
 +            self.rendered_items.push(RenderedItem {
 +                item: item.clone(),
 +                bounds,
 +            });
++
 +            y += height as i32;
 +        }
 +    }
++
 +    /// Layout submenu items.
 +    fn layout_submenu(&mut self, parent_bounds: &Rect, items: &[MenuItem]) {
 +        let (width, height) = self.calculate_menu_size(items);
++
 +        // Try to open to the right
 +        let mut x = parent_bounds.x + parent_bounds.width as i32 - 4;
 +        let y = parent_bounds.y;
++
 +        // If would overflow right edge, open to left
 +        if x + width as i32 > self.window_bounds.x + self.window_bounds.width as i32 {
 +            x = self.menu_bounds.x - width as i32 + 4;
 +        }
++
 +        self.submenu_bounds = Some(Rect::new(x, y, width, height));
 +        self.submenu_rendered_items.clear();
++
 +        let mut item_y = y + MENU_PADDING as i32;
 +        for item in items {
 +            let item_height = item.height();
 +            let bounds = Rect::new(
 +                x + MENU_PADDING as i32,
 +                item_y,
 +                width - MENU_PADDING * 2,
 +                item_height,
 +            );
 +            self.submenu_rendered_items.push(RenderedItem {
 +                item: item.clone(),
 +                bounds,
 +            });
 +            item_y += item_height as i32;
 +        }
 +    }
++
 +    /// Handle mouse move.
 +    pub fn on_mouse_move(&mut self, pos: Point) {
 +        if !self.visible {
 +            return;
 +        }
++
 +        // Check submenu first if open
 +        if let Some(ref submenu_bounds) = self.submenu_bounds {
 +            if submenu_bounds.contains_point(pos) {
 +                // Mouse is in submenu
 +                self.submenu_hovered_index = self.submenu_rendered_items
 +                    .iter()
 +                    .position(|r| r.bounds.contains_point(pos) && !r.item.is_separator());
 +                if let Some(idx) = self.submenu_hovered_index {
 +                    self.submenu_focused_index = Some(idx);
 +                }
 +                return;
 +            }
 +        }
++
 +        // Check main menu
 +        self.submenu_hovered_index = None;
++
 +        for (i, rendered) in self.rendered_items.iter().enumerate() {
 +            if rendered.bounds.contains_point(pos) && !rendered.item.is_separator() {
 +                self.hovered_index = Some(i);
 +                self.focused_index = Some(i);
++
 +                // Handle submenu hover
 +                if matches!(&rendered.item, MenuItem::Submenu { .. }) {
 +                    if self.open_submenu_index != Some(i) {
 +                        if self.submenu_hover_start.is_none() {
 +                            self.submenu_hover_start = Some(Instant::now());
 +                        } else if let Some(start) = self.submenu_hover_start {
 +                            if start.elapsed().as_millis() > SUBMENU_HOVER_DELAY_MS as u128 {
 +                                self.open_submenu(i);
 +                            }
 +                        }
 +                    }
 +                } else {
 +                    // Not a submenu, close any open submenu
 +                    self.submenu_hover_start = None;
 +                    if self.open_submenu_index.is_some() {
 +                        self.close_submenu();
 +                    }
 +                }
 +                return;
 +            }
 +        }
++
 +        // Mouse not over any item
 +        self.hovered_index = None;
++
 +        // Check if mouse left menu area entirely
 +        if !self.menu_bounds.contains_point(pos) {
 +            if let Some(ref submenu_bounds) = self.submenu_bounds {
 +                if !submenu_bounds.contains_point(pos) {
 +                    self.submenu_hover_start = None;
 +                }
 +            } else {
 +                self.submenu_hover_start = None;
 +            }
 +        }
 +    }
++
 +    /// Open a submenu by index.
 +    fn open_submenu(&mut self, index: usize) {
 +        // Get the bounds and items from the rendered item
 +        let (bounds, items) = if let Some(rendered) = self.rendered_items.get(index) {
 +            if let MenuItem::Submenu { items, .. } = &rendered.item {
 +                (rendered.bounds, items.clone())
 +            } else {
 +                return;
 +            }
 +        } else {
 +            return;
 +        };
++
 +        self.layout_submenu(&bounds, &items);
 +        self.open_submenu_index = Some(index);
 +        self.submenu_focused_index = Some(0);
 +        self.submenu_hovered_index = None;
 +    }
++
 +    /// Close the open submenu.
 +    fn close_submenu(&mut self) {
 +        self.open_submenu_index = None;
 +        self.submenu_focused_index = None;
 +        self.submenu_hovered_index = None;
 +        self.submenu_bounds = None;
 +        self.submenu_rendered_items.clear();
 +    }
++
 +    /// Handle click. Returns action if item was clicked.
 +    pub fn on_click(&mut self, pos: Point) -> Option<ContextMenuAction> {
 +        if !self.visible {
 +            return None;
 +        }
++
 +        // Check submenu click first
 +        if let Some(ref submenu_bounds) = self.submenu_bounds {
 +            if submenu_bounds.contains_point(pos) {
 +                for rendered in &self.submenu_rendered_items {
 +                    if rendered.bounds.contains_point(pos) {
 +                        if let MenuItem::Action { action, enabled, .. } = &rendered.item {
 +                            if *enabled {
 +                                let action = action.clone();
 +                                self.hide();
 +                                return Some(action);
 +                            }
 +                        }
 +                    }
 +                }
 +                return None;
 +            }
 +        }
++
 +        // Check main menu click
 +        for rendered in &self.rendered_items {
 +            if rendered.bounds.contains_point(pos) {
 +                match &rendered.item {
 +                    MenuItem::Action { action, enabled, .. } => {
 +                        if *enabled {
 +                            let action = action.clone();
 +                            self.hide();
 +                            return Some(action);
 +                        }
 +                    }
 +                    MenuItem::Submenu { .. } => {
 +                        // Clicking on submenu parent opens it
 +                        if let Some(idx) = self.rendered_items.iter().position(|r| std::ptr::eq(r, rendered)) {
 +                            self.open_submenu(idx);
 +                        }
 +                        return None;
 +                    }
 +                    MenuItem::Separator => {}
 +                }
 +            }
 +        }
++
 +        // Click outside menu closes it
 +        if !self.menu_bounds.contains_point(pos) {
 +            if let Some(ref submenu_bounds) = self.submenu_bounds {
 +                if !submenu_bounds.contains_point(pos) {
 +                    self.hide();
 +                }
 +            } else {
 +                self.hide();
 +            }
 +        }
++
 +        None
 +    }
++
 +    /// Handle keyboard input. Returns action if selected.
 +    pub fn handle_key(&mut self, key: &Key) -> Option<ContextMenuAction> {
 +        if !self.visible {
 +            return None;
 +        }
++
 +        match key {
 +            Key::Escape => {
 +                // If submenu is open, close it; otherwise close menu
 +                if self.open_submenu_index.is_some() {
 +                    self.close_submenu();
 +                } else {
 +                    self.hide();
 +                }
 +                None
 +            }
 +            Key::Up => {
 +                if self.open_submenu_index.is_some() {
 +                    self.submenu_move_focus(-1);
 +                } else {
 +                    self.move_focus(-1);
 +                }
 +                None
 +            }
 +            Key::Down => {
 +                if self.open_submenu_index.is_some() {
 +                    self.submenu_move_focus(1);
 +                } else {
 +                    self.move_focus(1);
 +                }
 +                None
 +            }
 +            Key::Right => {
 +                // Open submenu if focused item is a submenu
 +                if let Some(idx) = self.focused_index {
 +                    if let Some(rendered) = self.rendered_items.get(idx) {
 +                        if matches!(&rendered.item, MenuItem::Submenu { .. }) {
 +                            self.open_submenu(idx);
 +                        }
 +                    }
 +                }
 +                None
 +            }
 +            Key::Left => {
 +                // Close submenu
 +                if self.open_submenu_index.is_some() {
 +                    self.close_submenu();
 +                }
 +                None
 +            }
 +            Key::Return => self.activate_focused(),
 +            _ => None,
 +        }
 +    }
++
 +    /// Move focus by delta (skipping separators).
 +    fn move_focus(&mut self, delta: i32) {
 +        let actionable_indices: Vec<usize> = self.rendered_items
 +            .iter()
 +            .enumerate()
 +            .filter(|(_, r)| !r.item.is_separator())
 +            .map(|(i, _)| i)
 +            .collect();
++
 +        if actionable_indices.is_empty() {
 +            return;
 +        }
++
 +        let current_pos = self.focused_index
 +            .and_then(|idx| actionable_indices.iter().position(|&i| i == idx))
 +            .unwrap_or(0);
++
 +        let new_pos = if delta > 0 {
 +            (current_pos + 1) % actionable_indices.len()
 +        } else if current_pos == 0 {
 +            actionable_indices.len() - 1
 +        } else {
 +            current_pos - 1
 +        };
++
 +        self.focused_index = actionable_indices.get(new_pos).copied();
 +        self.hovered_index = self.focused_index;
 +    }
++
 +    /// Move submenu focus by delta.
 +    fn submenu_move_focus(&mut self, delta: i32) {
 +        let actionable_indices: Vec<usize> = self.submenu_rendered_items
 +            .iter()
 +            .enumerate()
 +            .filter(|(_, r)| !r.item.is_separator())
 +            .map(|(i, _)| i)
 +            .collect();
++
 +        if actionable_indices.is_empty() {
 +            return;
 +        }
++
 +        let current_pos = self.submenu_focused_index
 +            .and_then(|idx| actionable_indices.iter().position(|&i| i == idx))
 +            .unwrap_or(0);
++
 +        let new_pos = if delta > 0 {
 +            (current_pos + 1) % actionable_indices.len()
 +        } else if current_pos == 0 {
 +            actionable_indices.len() - 1
 +        } else {
 +            current_pos - 1
 +        };
++
 +        self.submenu_focused_index = actionable_indices.get(new_pos).copied();
 +        self.submenu_hovered_index = self.submenu_focused_index;
 +    }
++
 +    /// Activate the focused item.
 +    fn activate_focused(&mut self) -> Option<ContextMenuAction> {
 +        // Check submenu first
 +        if self.open_submenu_index.is_some() {
 +            if let Some(item_idx) = self.submenu_focused_index {
 +                if let Some(rendered) = self.submenu_rendered_items.get(item_idx) {
 +                    if let MenuItem::Action { action, enabled, .. } = &rendered.item {
 +                        if *enabled {
 +                            let action = action.clone();
 +                            self.hide();
 +                            return Some(action);
 +                        }
 +                    }
 +                }
 +            }
 +            return None;
 +        }
++
 +        // Check main menu
 +        if let Some(idx) = self.focused_index {
 +            if let Some(rendered) = self.rendered_items.get(idx) {
 +                match &rendered.item {
 +                    MenuItem::Action { action, enabled, .. } => {
 +                        if *enabled {
 +                            let action = action.clone();
 +                            self.hide();
 +                            return Some(action);
 +                        }
 +                    }
 +                    MenuItem::Submenu { .. } => {
 +                        // Enter opens submenu
 +                        self.open_submenu(idx);
 +                    }
 +                    MenuItem::Separator => {}
 +                }
 +            }
 +        }
++
 +        None
 +    }
++
 +    /// Render the context menu.
 +    pub fn render(&self, renderer: &Renderer) -> Result<()> {
 +        if !self.visible {
 +            return Ok(());
 +        }
++
 +        let theme = renderer.theme();
++
 +        // Main menu background
 +        renderer.fill_rounded_rect(self.menu_bounds, 6.0, theme.background)?;
 +        renderer.stroke_rounded_rect(self.menu_bounds, 6.0, theme.border, 1.0)?;
++
 +        // Render main menu items
 +        for (i, rendered) in self.rendered_items.iter().enumerate() {
 +            let focused = self.focused_index == Some(i);
 +            let hovered = self.hovered_index == Some(i);
 +            self.render_item(renderer, rendered, focused, hovered)?;
 +        }
++
 +        // Render open submenu if any
 +        if self.open_submenu_index.is_some() {
 +            self.render_submenu(renderer)?;
 +        }
++
 +        Ok(())
 +    }
++
 +    /// Render a single menu item.
 +    fn render_item(&self, renderer: &Renderer, rendered: &RenderedItem, focused: bool, hovered: bool) -> Result<()> {
 +        let theme = renderer.theme();
++
 +        match &rendered.item {
 +            MenuItem::Separator => {
 +                let y = rendered.bounds.y + rendered.bounds.height as i32 / 2;
 +                renderer.line(
 +                    (rendered.bounds.x + 4) as f64,
 +                    y as f64,
 +                    (rendered.bounds.x + rendered.bounds.width as i32 - 4) as f64,
 +                    y as f64,
 +                    theme.border,
 +                    1.0,
 +                )?;
 +            }
 +            MenuItem::Action { label, shortcut, enabled, .. } => {
 +                // Background for hover/focus
 +                if (focused || hovered) && *enabled {
 +                    renderer.fill_rounded_rect(rendered.bounds, 4.0, theme.item_hover_background)?;
 +                }
++
 +                let text_color = if *enabled {
 +                    theme.foreground
 +                } else {
 +                    theme.item_description
 +                };
++
 +                let text_style = TextStyle::new()
 +                    .font_family(&theme.font_family)
 +                    .font_size(theme.font_size)
 +                    .color(text_color);
++
 +                // Label
 +                renderer.text(
 +                    label,
 +                    (rendered.bounds.x + 12) as f64,
 +                    (rendered.bounds.y + 6) as f64,
 +                    &text_style,
 +                )?;
++
 +                // Shortcut (right-aligned)
 +                if let Some(shortcut) = shortcut {
 +                    let shortcut_style = text_style.clone().color(theme.item_description);
 +                    let shortcut_width = renderer.measure_text(shortcut, &shortcut_style)
 +                        .map(|m| m.width as i32)
 +                        .unwrap_or(60);
 +                    let shortcut_x = rendered.bounds.x + rendered.bounds.width as i32 - shortcut_width - 12;
 +                    renderer.text(
 +                        shortcut,
 +                        shortcut_x as f64,
 +                        (rendered.bounds.y + 6) as f64,
 +                        &shortcut_style,
 +                    )?;
 +                }
 +            }
 +            MenuItem::Submenu { label, .. } => {
 +                // Background for hover/focus
 +                if focused || hovered {
 +                    renderer.fill_rounded_rect(rendered.bounds, 4.0, theme.item_hover_background)?;
 +                }
++
 +                let text_style = TextStyle::new()
 +                    .font_family(&theme.font_family)
 +                    .font_size(theme.font_size)
 +                    .color(theme.foreground);
++
 +                // Label
 +                renderer.text(
 +                    label,
 +                    (rendered.bounds.x + 12) as f64,
 +                    (rendered.bounds.y + 6) as f64,
 +                    &text_style,
 +                )?;
++
 +                // Arrow indicator (right-pointing)
 +                let arrow_x = rendered.bounds.x + rendered.bounds.width as i32 - 16;
 +                renderer.text(
 +                    ">",
 +                    arrow_x as f64,
 +                    (rendered.bounds.y + 6) as f64,
 +                    &text_style,
 +                )?;
 +            }
 +        }
++
 +        Ok(())
 +    }
++
 +    /// Render an open submenu.
 +    fn render_submenu(&self, renderer: &Renderer) -> Result<()> {
 +        let theme = renderer.theme();
++
 +        let submenu_bounds = match &self.submenu_bounds {
 +            Some(b) => *b,
 +            None => return Ok(()),
 +        };
++
 +        // Submenu background
 +        renderer.fill_rounded_rect(submenu_bounds, 6.0, theme.background)?;
 +        renderer.stroke_rounded_rect(submenu_bounds, 6.0, theme.border, 1.0)?;
++
 +        // Render submenu items
 +        for (i, rendered) in self.submenu_rendered_items.iter().enumerate() {
 +            let focused = self.submenu_focused_index == Some(i);
 +            let hovered = self.submenu_hovered_index == Some(i);
 +            self.render_item(renderer, rendered, focused, hovered)?;
 +        }
++
 +        Ok(())
 +    }
 +}

garfield/src/ui/mod.rsmodified

  pub mod address_bar;
  pub mod breadcrumb;
  pub mod column_view;
 +pub mod context_menu;
  pub mod dialog;
  pub mod grid_view;
  pub mod help_modal;
  pub mod toolbar;
  pub use address_bar::AddressBar;
 +pub use context_menu::{ContextMenu, ContextMenuAction, ContextType};
  pub use dialog::{ConfirmDialog, ConflictAction, ConflictDialog, DialogResult, ProgressDialog, ProgressInfo};
  pub use breadcrumb::Breadcrumb;
  pub use column_view::{ColumnClickResult, ColumnView};

garfield/src/ui/tab.rsmodified

          self.refresh();
+     }
 +    /// Get current sort order.
 +    pub fn sort_order(&self) -> SortOrder {
 +        self.sort_order
 +    }
++
 +    /// Get current sort direction.
 +    pub fn sort_direction(&self) -> SortDirection {
 +        self.sort_direction
 +    }
++
      // === Navigation (keyboard) ===
      pub fn select_prev(&mut self) {