`bfdcd76`

core: add progress dialog and undo/redo system

- Add ProgressDialog component with progress bar and cancel button
- Add UndoStack for tracking file operations (copy, move, trash, rename, create folder)
- Track operations for undo: paste, trash, rename, create folder
- Implement undo() and redo() methods with reverse operations
- Add Ctrl+Z (undo) and Ctrl+Y (redo) keybindings
- Update help modal with undo/redo shortcuts
- Modify Tab.confirm_rename to return paths for undo tracking

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

SHA: bfdcd76a53a5f63794c20844f93eb55e55f7ec11
Parents: bd6afd9
Tree: dd64552

7 changed files

Status	File	+	-
M	`garfield/src/app.rs`	239	8
M	`garfield/src/core/mod.rs`	2	0
A	`garfield/src/core/undo.rs`	144	0
M	`garfield/src/ui/dialog.rs`	300	1
M	`garfield/src/ui/help_modal.rs`	2	0
M	`garfield/src/ui/mod.rs`	1	1
M	`garfield/src/ui/tab.rs`	11	9

garfield/src/app.rsmodified

  //! Application state and event loop.
  use garfield::core::{
 -    Clipboard, ClipboardOperation,
 +    Clipboard, ClipboardOperation, FileOperation, UndoStack,
      copy_files, move_files, delete_files, create_directory,
 -    trash_files,
 +    trash_files, restore_from_trash,
  };
  use garfield::ui::pane::SplitDirection;
 -use garfield::ui::{AddressBar, Breadcrumb, ConfirmDialog, DialogResult, HelpModal, Pane, Sidebar, StatusBar, TabBar, TabInfo, Toolbar, ToolbarAction, ViewMode, TAB_BAR_HEIGHT, TOOLBAR_HEIGHT};
 +use garfield::ui::{AddressBar, Breadcrumb, ConfirmDialog, 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};
      clipboard: Clipboard,
      /// Confirmation dialog.
      confirm_dialog: ConfirmDialog,
 +    /// Progress dialog for long operations.
 +    progress_dialog: ProgressDialog,
      /// Paths pending delete confirmation.
      pending_delete_paths: Vec<PathBuf>,
 +    /// Undo/redo stack for file operations.
 +    undo_stack: UndoStack,
+ }
  impl App {
          // Create confirm dialog (full window bounds)
          let confirm_dialog = ConfirmDialog::new(Rect::new(0, 0, width, height));
 +        // Create progress dialog (full window bounds)
 +        let progress_dialog = ProgressDialog::new(Rect::new(0, 0, width, height));
++
          // Content area bounds (for panes)
          let content_bounds = Rect::new(
              sidebar_w as i32,
              drag_active: false,
              clipboard: Clipboard::new(),
              confirm_dialog,
 +            progress_dialog,
              pending_delete_paths: Vec::new(),
 +            undo_stack: UndoStack::new(),
          };
          app.update_status_bar();
      /// Handle mouse press.
      fn handle_mouse_press(&mut self, pos: Point, modifiers: &gartk_core::Modifiers, button: Option<MouseButton>) {
 +        // Check progress dialog first (blocks all other input)
 +        if self.progress_dialog.is_visible() {
 +            self.progress_dialog.on_click(pos);
 +            return;
 +        }
++
          // Check confirm dialog first
          if self.confirm_dialog.is_visible() {
              if let Some(result) = self.confirm_dialog.on_click(pos) {
      /// Handle mouse move.
      fn handle_mouse_move(&mut self, pos: Point) {
 +        // Handle progress dialog hover
 +        if self.progress_dialog.is_visible() {
 +            self.progress_dialog.on_mouse_move(pos);
 +            return;
 +        }
++
          // Handle confirm dialog hover
          if self.confirm_dialog.is_visible() {
              self.confirm_dialog.on_mouse_move(pos);
      /// Handle a key press.
      fn handle_key(&mut self, key: &Key, modifiers: &gartk_core::Modifiers) {
 +        // Handle progress dialog when visible (blocks all other input)
 +        if self.progress_dialog.is_visible() {
 +            self.progress_dialog.handle_key(key);
 +            return;
 +        }
++
          // Handle confirm dialog when visible
          if self.confirm_dialog.is_visible() {
              if let Some(result) = self.confirm_dialog.handle_key(key) {
                      self.paste();
                      return;
+                 }
 +                Key::Char('z') | Key::Char('Z') => {
 +                    self.undo();
 +                    return;
 +                }
 +                Key::Char('y') | Key::Char('Y') => {
 +                    self.redo();
 +                    return;
 +                }
                  _ => {}
+             }
+         }
          if let Some((files, op)) = self.clipboard.take() {
              let count = files.len();
 +            let sources = files.clone();
              let result = match op {
                  ClipboardOperation::Copy => copy_files(&files, &dest_dir),
                  ClipboardOperation::Cut => move_files(&files, &dest_dir),
              };
 -            // Show result in status bar
 -            if result.success {
 +            // Show result in status bar and record for undo
 +            if result.success && !result.processed.is_empty() {
                  let action = if op == ClipboardOperation::Copy { "copied" } else { "moved" };
                  let msg = if count == 1 { format!("1 item {}", action) } else { format!("{} items {}", count, action) };
                  self.status_bar.set_status_message(msg);
 -            } else {
++
 +                // Record for undo
 +                let undo_op = match op {
 +                    ClipboardOperation::Copy => FileOperation::Copy {
 +                        sources,
 +                        destinations: result.processed.clone(),
 +                    },
 +                    ClipboardOperation::Cut => FileOperation::Move {
 +                        sources,
 +                        destinations: result.processed.clone(),
 +                    },
 +                };
 +                self.undo_stack.push(undo_op);
 +            } else if !result.success {
                  let msg = format!("Operation failed: {}", result.error.as_deref().unwrap_or("unknown error"));
                  self.status_bar.set_status_message(msg);
+             }
          let success_count = results.iter().filter(|r| r.is_ok()).count();
          let failed_count = results.iter().filter(|r| r.is_err()).count();
 +        // Collect successful trash operations for undo
 +        let mut trashed_originals = Vec::new();
 +        let mut trash_names = Vec::new();
 +        for (i, result) in results.iter().enumerate() {
 +            if let Ok(trash_path) = result {
 +                trashed_originals.push(paths[i].clone());
 +                // Extract the trash entry name (filename in trash/files/)
 +                if let Some(name) = trash_path.file_name() {
 +                    trash_names.push(name.to_string_lossy().to_string());
 +                }
 +            }
 +        }
++
          if failed_count > 0 {
              let msg = format!("Moved {} to trash, {} failed", success_count, failed_count);
              self.status_bar.set_status_message(msg);
              self.status_bar.set_status_message(msg);
+         }
 +        // Record for undo if any succeeded
 +        if !trashed_originals.is_empty() {
 +            self.undo_stack.push(FileOperation::Trash {
 +                originals: trashed_originals,
 +                trash_names,
 +            });
 +        }
++
          self.refresh();
+     }
+         }
          match create_directory(&current_dir, &name) {
 -            Ok(_) => {
 +            Ok(path) => {
                  self.status_bar.set_status_message(format!("Created '{}'", name));
 +                self.undo_stack.push(FileOperation::CreateDir { path });
                  self.refresh();
                  // TODO: Start rename on the new folder
+             }
+         }
+     }
 +    /// Undo the last file operation.
 +    fn undo(&mut self) {
 +        let op = match self.undo_stack.pop_undo() {
 +            Some(op) => op,
 +            None => {
 +                self.status_bar.set_status_message("Nothing to undo");
 +                return;
 +            }
 +        };
++
 +        let result = self.perform_undo(&op);
 +        match result {
 +            Ok(msg) => {
 +                self.status_bar.set_status_message(format!("Undo: {}", msg));
 +                self.undo_stack.push_redo(op);
 +            }
 +            Err(msg) => {
 +                self.status_bar.set_status_message(format!("Undo failed: {}", msg));
 +            }
 +        }
 +        self.refresh();
 +    }
++
 +    /// Perform the undo operation.
 +    fn perform_undo(&mut self, op: &FileOperation) -> Result<String, String> {
 +        use garfield::core::{delete_path, move_path, rename_path};
++
 +        match op {
 +            FileOperation::Copy { destinations, .. } => {
 +                // Undo copy: delete the copied files
 +                for dest in destinations {
 +                    if dest.exists() {
 +                        delete_path(dest).map_err(|e| e.to_string())?;
 +                    }
 +                }
 +                Ok(format!("Deleted {} copied item(s)", destinations.len()))
 +            }
 +            FileOperation::Move { sources, destinations } => {
 +                // Undo move: move files back to original locations
 +                for (src, dest) in sources.iter().zip(destinations.iter()) {
 +                    if dest.exists() {
 +                        if let Some(parent) = src.parent() {
 +                            move_path(dest, parent).map_err(|e| e.to_string())?;
 +                        }
 +                    }
 +                }
 +                Ok(format!("Moved {} item(s) back", sources.len()))
 +            }
 +            FileOperation::Trash { trash_names, .. } => {
 +                // Undo trash: restore from trash
 +                for name in trash_names {
 +                    restore_from_trash(name).map_err(|e| e.to_string())?;
 +                }
 +                Ok(format!("Restored {} item(s) from trash", trash_names.len()))
 +            }
 +            FileOperation::Rename { original, renamed } => {
 +                // Undo rename: rename back to original
 +                if renamed.exists() {
 +                    if let Some(orig_name) = original.file_name() {
 +                        rename_path(renamed, orig_name.to_string_lossy().as_ref())
 +                            .map_err(|e| e.to_string())?;
 +                    }
 +                }
 +                Ok("Renamed back".to_string())
 +            }
 +            FileOperation::CreateDir { path } => {
 +                // Undo create dir: delete the directory (only if empty)
 +                if path.exists() && path.is_dir() {
 +                    std::fs::remove_dir(path).map_err(|e| e.to_string())?;
 +                }
 +                Ok("Deleted folder".to_string())
 +            }
 +        }
 +    }
++
 +    /// Redo the last undone operation.
 +    fn redo(&mut self) {
 +        let op = match self.undo_stack.pop_redo() {
 +            Some(op) => op,
 +            None => {
 +                self.status_bar.set_status_message("Nothing to redo");
 +                return;
 +            }
 +        };
++
 +        let result = self.perform_redo(&op);
 +        match result {
 +            Ok(msg) => {
 +                self.status_bar.set_status_message(format!("Redo: {}", msg));
 +                self.undo_stack.push(op);
 +            }
 +            Err(msg) => {
 +                self.status_bar.set_status_message(format!("Redo failed: {}", msg));
 +            }
 +        }
 +        self.refresh();
 +    }
++
 +    /// Perform the redo operation.
 +    fn perform_redo(&mut self, op: &FileOperation) -> Result<String, String> {
 +        use garfield::core::{copy_path, move_path, rename_path};
++
 +        match op {
 +            FileOperation::Copy { sources, destinations } => {
 +                // Redo copy: copy files again
 +                for (src, dest) in sources.iter().zip(destinations.iter()) {
 +                    if src.exists() {
 +                        if let Some(parent) = dest.parent() {
 +                            copy_path(src, parent).map_err(|e| e.to_string())?;
 +                        }
 +                    }
 +                }
 +                Ok(format!("Copied {} item(s)", sources.len()))
 +            }
 +            FileOperation::Move { sources, destinations } => {
 +                // Redo move: move files again
 +                for (src, dest) in sources.iter().zip(destinations.iter()) {
 +                    if src.exists() {
 +                        if let Some(parent) = dest.parent() {
 +                            move_path(src, parent).map_err(|e| e.to_string())?;
 +                        }
 +                    }
 +                }
 +                Ok(format!("Moved {} item(s)", sources.len()))
 +            }
 +            FileOperation::Trash { originals, .. } => {
 +                // Redo trash: trash the files again
 +                let results = trash_files(originals);
 +                let success = results.iter().filter(|r| r.is_ok()).count();
 +                Ok(format!("Trashed {} item(s)", success))
 +            }
 +            FileOperation::Rename { original, renamed } => {
 +                // Redo rename: rename again
 +                if original.exists() {
 +                    if let Some(new_name) = renamed.file_name() {
 +                        rename_path(original, new_name.to_string_lossy().as_ref())
 +                            .map_err(|e| e.to_string())?;
 +                    }
 +                }
 +                Ok("Renamed".to_string())
 +            }
 +            FileOperation::CreateDir { path } => {
 +                // Redo create dir: create the directory again
 +                std::fs::create_dir(path).map_err(|e| e.to_string())?;
 +                Ok("Created folder".to_string())
 +            }
 +        }
 +    }
++
      /// Start inline rename for the selected file.
      fn start_rename(&mut self) {
          if let Some(pane) = self.focused_pane_mut() {
              .map(|t| t.confirm_rename());
          match result {
 -            Some(Ok(new_name)) => {
 +            Some(Ok((original, renamed, new_name))) => {
 +                // Only record undo if the name actually changed
 +                if original != renamed {
 +                    self.undo_stack.push(FileOperation::Rename {
 +                        original,
 +                        renamed,
 +                    });
 +                }
                  self.status_bar.set_status_message(format!("Renamed to '{}'", new_name));
+             }
              Some(Err(msg)) => {
          self.help_modal.set_bounds(Rect::new(0, 0, width, height));
          self.confirm_dialog.set_bounds(Rect::new(0, 0, width, height));
 +        self.progress_dialog.set_bounds(Rect::new(0, 0, width, height));
+     }
      /// Render the application.
          // Draw confirm dialog overlay (on top of everything)
          self.confirm_dialog.render(&self.renderer)?;
 +        // Draw progress dialog overlay (on top of everything)
 +        self.progress_dialog.render(&self.renderer)?;
++
          // Flush and copy to window
          self.renderer.flush();
          self.blit_surface()?;

garfield/src/core/mod.rsmodified

  pub mod history;
  pub mod operations;
  pub mod trash;
 +pub mod undo;
  pub use clipboard::{Clipboard, ClipboardOperation};
  pub use entry::{
      make_unique_name, move_files, move_path, rename_path, OperationResult,
  };
  pub use trash::{empty_trash, restore_from_trash, trash_file, trash_files, trash_dir};
 +pub use undo::{FileOperation, UndoStack};

garfield/src/core/undo.rsadded

 +//! Undo/redo system for file operations.
++
 +use std::path::PathBuf;
++
 +/// Maximum number of operations to keep in history.
 +const MAX_HISTORY: usize = 100;
++
 +/// A file operation that can be undone.
 +#[derive(Debug, Clone)]
 +pub enum FileOperation {
 +    /// Copy files (sources, created destinations).
 +    Copy {
 +        sources: Vec<PathBuf>,
 +        destinations: Vec<PathBuf>,
 +    },
 +    /// Move files (sources, destinations).
 +    Move {
 +        sources: Vec<PathBuf>,
 +        destinations: Vec<PathBuf>,
 +    },
 +    /// Trash files (original paths, trash entry names).
 +    Trash {
 +        originals: Vec<PathBuf>,
 +        trash_names: Vec<String>,
 +    },
 +    /// Rename file (original path, new path).
 +    Rename {
 +        original: PathBuf,
 +        renamed: PathBuf,
 +    },
 +    /// Create directory (path).
 +    CreateDir {
 +        path: PathBuf,
 +    },
 +}
++
 +impl FileOperation {
 +    /// Get a human-readable description of this operation.
 +    pub fn description(&self) -> String {
 +        match self {
 +            FileOperation::Copy { sources, .. } => {
 +                if sources.len() == 1 {
 +                    format!("Copy '{}'", sources[0].file_name().unwrap_or_default().to_string_lossy())
 +                } else {
 +                    format!("Copy {} items", sources.len())
 +                }
 +            }
 +            FileOperation::Move { sources, .. } => {
 +                if sources.len() == 1 {
 +                    format!("Move '{}'", sources[0].file_name().unwrap_or_default().to_string_lossy())
 +                } else {
 +                    format!("Move {} items", sources.len())
 +                }
 +            }
 +            FileOperation::Trash { originals, .. } => {
 +                if originals.len() == 1 {
 +                    format!("Trash '{}'", originals[0].file_name().unwrap_or_default().to_string_lossy())
 +                } else {
 +                    format!("Trash {} items", originals.len())
 +                }
 +            }
 +            FileOperation::Rename { original, renamed } => {
 +                format!(
 +                    "Rename '{}' to '{}'",
 +                    original.file_name().unwrap_or_default().to_string_lossy(),
 +                    renamed.file_name().unwrap_or_default().to_string_lossy()
 +                )
 +            }
 +            FileOperation::CreateDir { path } => {
 +                format!("Create folder '{}'", path.file_name().unwrap_or_default().to_string_lossy())
 +            }
 +        }
 +    }
 +}
++
 +/// Manages undo/redo stacks for file operations.
 +#[derive(Debug, Default)]
 +pub struct UndoStack {
 +    /// Operations that can be undone (most recent last).
 +    undo_stack: Vec<FileOperation>,
 +    /// Operations that can be redone (most recent last).
 +    redo_stack: Vec<FileOperation>,
 +}
++
 +impl UndoStack {
 +    /// Create a new undo stack.
 +    pub fn new() -> Self {
 +        Self::default()
 +    }
++
 +    /// Push an operation onto the undo stack.
 +    /// Clears the redo stack since the history has diverged.
 +    pub fn push(&mut self, op: FileOperation) {
 +        self.undo_stack.push(op);
 +        self.redo_stack.clear();
++
 +        // Limit history size
 +        if self.undo_stack.len() > MAX_HISTORY {
 +            self.undo_stack.remove(0);
 +        }
 +    }
++
 +    /// Check if undo is available.
 +    pub fn can_undo(&self) -> bool {
 +        !self.undo_stack.is_empty()
 +    }
++
 +    /// Check if redo is available.
 +    pub fn can_redo(&self) -> bool {
 +        !self.redo_stack.is_empty()
 +    }
++
 +    /// Pop an operation from the undo stack for undoing.
 +    /// The operation should be performed, then moved to redo.
 +    pub fn pop_undo(&mut self) -> Option<FileOperation> {
 +        self.undo_stack.pop()
 +    }
++
 +    /// Push an operation onto the redo stack (after undoing).
 +    pub fn push_redo(&mut self, op: FileOperation) {
 +        self.redo_stack.push(op);
 +    }
++
 +    /// Pop an operation from the redo stack for redoing.
 +    pub fn pop_redo(&mut self) -> Option<FileOperation> {
 +        self.redo_stack.pop()
 +    }
++
 +    /// Get description of the next undo operation.
 +    pub fn undo_description(&self) -> Option<String> {
 +        self.undo_stack.last().map(|op| op.description())
 +    }
++
 +    /// Get description of the next redo operation.
 +    pub fn redo_description(&self) -> Option<String> {
 +        self.redo_stack.last().map(|op| op.description())
 +    }
++
 +    /// Clear all history.
 +    pub fn clear(&mut self) {
 +        self.undo_stack.clear();
 +        self.redo_stack.clear();
 +    }
 +}

garfield/src/ui/dialog.rsmodified

 -//! Modal dialog component for confirmations.
 +//! Modal dialog components for confirmations and progress.
  use anyhow::Result;
  use gartk_core::{Key, Point, Rect};
  use gartk_render::{Renderer, TextStyle};
 +use std::time::Instant;
  /// Dialog button type.
  #[derive(Debug, Clone, Copy, PartialEq, Eq)]
          Ok(())
+     }
+ }
++
 +/// Progress information for an operation.
 +#[derive(Debug, Clone)]
 +pub struct ProgressInfo {
 +    /// Current item being processed.
 +    pub current_item: String,
 +    /// Current item index (1-based).
 +    pub current: usize,
 +    /// Total items.
 +    pub total: usize,
 +    /// Bytes processed (for copy/move).
 +    pub bytes_done: u64,
 +    /// Total bytes (for copy/move).
 +    pub bytes_total: u64,
 +}
++
 +impl ProgressInfo {
 +    /// Create new progress info.
 +    pub fn new(total: usize) -> Self {
 +        Self {
 +            current_item: String::new(),
 +            current: 0,
 +            total,
 +            bytes_done: 0,
 +            bytes_total: 0,
 +        }
 +    }
++
 +    /// Get progress as a fraction (0.0 to 1.0).
 +    pub fn fraction(&self) -> f64 {
 +        if self.total == 0 {
 +            0.0
 +        } else {
 +            self.current as f64 / self.total as f64
 +        }
 +    }
 +}
++
 +/// A modal progress dialog for long operations.
 +pub struct ProgressDialog {
 +    /// Window bounds (for centering).
 +    bounds: Rect,
 +    /// Dialog title (operation name).
 +    title: String,
 +    /// Whether the dialog is visible.
 +    visible: bool,
 +    /// Progress information.
 +    progress: ProgressInfo,
 +    /// Whether the operation can be cancelled.
 +    cancellable: bool,
 +    /// Whether cancel was requested.
 +    cancel_requested: bool,
 +    /// Whether the cancel button is hovered.
 +    cancel_hovered: bool,
 +    /// Time when dialog was shown.
 +    start_time: Option<Instant>,
 +}
++
 +impl ProgressDialog {
 +    /// Create a new progress dialog.
 +    pub fn new(bounds: Rect) -> Self {
 +        Self {
 +            bounds,
 +            title: String::new(),
 +            visible: false,
 +            progress: ProgressInfo::new(0),
 +            cancellable: true,
 +            cancel_requested: false,
 +            cancel_hovered: false,
 +            start_time: None,
 +        }
 +    }
++
 +    /// Set bounds.
 +    pub fn set_bounds(&mut self, bounds: Rect) {
 +        self.bounds = bounds;
 +    }
++
 +    /// Show the progress dialog.
 +    pub fn show(&mut self, title: &str, total: usize, cancellable: bool) {
 +        self.title = title.to_string();
 +        self.progress = ProgressInfo::new(total);
 +        self.cancellable = cancellable;
 +        self.cancel_requested = false;
 +        self.cancel_hovered = false;
 +        self.visible = true;
 +        self.start_time = Some(Instant::now());
 +    }
++
 +    /// Update progress.
 +    pub fn update(&mut self, current: usize, current_item: &str) {
 +        self.progress.current = current;
 +        self.progress.current_item = current_item.to_string();
 +    }
++
 +    /// Update byte progress.
 +    pub fn update_bytes(&mut self, bytes_done: u64, bytes_total: u64) {
 +        self.progress.bytes_done = bytes_done;
 +        self.progress.bytes_total = bytes_total;
 +    }
++
 +    /// Check if visible.
 +    pub fn is_visible(&self) -> bool {
 +        self.visible
 +    }
++
 +    /// Check if cancel was requested.
 +    pub fn is_cancel_requested(&self) -> bool {
 +        self.cancel_requested
 +    }
++
 +    /// Hide the dialog.
 +    pub fn hide(&mut self) {
 +        self.visible = false;
 +        self.start_time = None;
 +    }
++
 +    /// Handle key press.
 +    pub fn handle_key(&mut self, key: &Key) -> bool {
 +        if !self.visible {
 +            return false;
 +        }
++
 +        match key {
 +            Key::Escape if self.cancellable => {
 +                self.cancel_requested = true;
 +                true
 +            }
 +            _ => true, // Consume all keys while dialog is visible
 +        }
 +    }
++
 +    /// Handle mouse move.
 +    pub fn on_mouse_move(&mut self, pos: Point) {
 +        if !self.visible || !self.cancellable {
 +            return;
 +        }
++
 +        let cancel_rect = self.cancel_button_rect();
 +        self.cancel_hovered = cancel_rect.contains_point(pos);
 +    }
++
 +    /// Handle click.
 +    pub fn on_click(&mut self, pos: Point) -> bool {
 +        if !self.visible {
 +            return false;
 +        }
++
 +        if self.cancellable {
 +            let cancel_rect = self.cancel_button_rect();
 +            if cancel_rect.contains_point(pos) {
 +                self.cancel_requested = true;
 +                return true;
 +            }
 +        }
++
 +        // Consume click but don't do anything else
 +        true
 +    }
++
 +    /// Get the dialog rectangle (centered in bounds).
 +    fn dialog_rect(&self) -> Rect {
 +        let dialog_width = 450.min(self.bounds.width.saturating_sub(40));
 +        let dialog_height = 160.min(self.bounds.height.saturating_sub(40));
 +        let x = self.bounds.x + (self.bounds.width as i32 - dialog_width as i32) / 2;
 +        let y = self.bounds.y + (self.bounds.height as i32 - dialog_height as i32) / 2;
 +        Rect::new(x, y, dialog_width, dialog_height)
 +    }
++
 +    /// Get progress bar rectangle.
 +    fn progress_bar_rect(&self) -> Rect {
 +        let dialog = self.dialog_rect();
 +        let bar_width = dialog.width.saturating_sub(40);
 +        let bar_height = 8;
 +        let x = dialog.x + 20;
 +        let y = dialog.y + 80;
 +        Rect::new(x, y, bar_width, bar_height)
 +    }
++
 +    /// Get cancel button rectangle.
 +    fn cancel_button_rect(&self) -> Rect {
 +        let dialog = self.dialog_rect();
 +        let button_width = 80;
 +        let button_height = 28;
 +        let x = dialog.x + (dialog.width as i32 - button_width as i32) / 2;
 +        let y = dialog.y + dialog.height as i32 - button_height as i32 - 16;
 +        Rect::new(x, y, button_width, button_height)
 +    }
++
 +    /// Render the dialog.
 +    pub fn render(&self, renderer: &Renderer) -> Result<()> {
 +        if !self.visible {
 +            return Ok(());
 +        }
++
 +        let theme = renderer.theme();
++
 +        // Dim background overlay
 +        renderer.fill_rect(self.bounds, gartk_core::Color::from_u8(0, 0, 0, 180))?;
++
 +        let dialog_rect = self.dialog_rect();
++
 +        // Dialog background
 +        renderer.fill_rounded_rect(dialog_rect, 8.0, theme.background)?;
 +        renderer.stroke_rounded_rect(dialog_rect, 8.0, theme.border, 1.0)?;
++
 +        // Title
 +        let title_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size + 2.0)
 +            .color(theme.foreground);
++
 +        renderer.text(
 +            &self.title,
 +            (dialog_rect.x + 20) as f64,
 +            (dialog_rect.y + 20) as f64,
 +            &title_style,
 +        )?;
++
 +        // Current item
 +        let item_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size - 1.0)
 +            .color(theme.item_foreground);
++
 +        let item_text = if self.progress.current_item.is_empty() {
 +            "Preparing...".to_string()
 +        } else {
 +            // Truncate long paths
 +            let max_len = 50;
 +            if self.progress.current_item.len() > max_len {
 +                format!("...{}", &self.progress.current_item[self.progress.current_item.len() - max_len..])
 +            } else {
 +                self.progress.current_item.clone()
 +            }
 +        };
++
 +        renderer.text(
 +            &item_text,
 +            (dialog_rect.x + 20) as f64,
 +            (dialog_rect.y + 50) as f64,
 +            &item_style,
 +        )?;
++
 +        // Progress bar background
 +        let bar_rect = self.progress_bar_rect();
 +        renderer.fill_rounded_rect(bar_rect, 4.0, theme.item_background)?;
++
 +        // Progress bar fill
 +        let progress_fraction = self.progress.fraction();
 +        if progress_fraction > 0.0 {
 +            let fill_width = ((bar_rect.width as f64 * progress_fraction) as u32).max(1);
 +            let fill_rect = Rect::new(bar_rect.x, bar_rect.y, fill_width, bar_rect.height);
 +            let progress_color = gartk_core::Color::from_hex("#4a9eff").unwrap_or(theme.selection_background);
 +            renderer.fill_rounded_rect(fill_rect, 4.0, progress_color)?;
 +        }
++
 +        // Progress text (e.g., "3 of 10")
 +        let progress_text = format!("{} of {}", self.progress.current, self.progress.total);
 +        let progress_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size - 1.0)
 +            .color(theme.item_foreground);
++
 +        let text_width = renderer.measure_text(&progress_text, &progress_style)?.width;
 +        let text_x = bar_rect.x + (bar_rect.width as i32 - text_width as i32) / 2;
 +        renderer.text(
 +            &progress_text,
 +            text_x as f64,
 +            (bar_rect.y + bar_rect.height as i32 + 8) as f64,
 +            &progress_style,
 +        )?;
++
 +        // Cancel button (if cancellable)
 +        if self.cancellable {
 +            let cancel_rect = self.cancel_button_rect();
 +            let cancel_bg = if self.cancel_hovered {
 +                theme.item_hover_background
 +            } else {
 +                theme.item_background
 +            };
 +            renderer.fill_rounded_rect(cancel_rect, 4.0, cancel_bg)?;
++
 +            let button_style = TextStyle::new()
 +                .font_family(&theme.font_family)
 +                .font_size(theme.font_size)
 +                .color(theme.foreground);
++
 +            let cancel_text = "Cancel";
 +            let cancel_width = renderer.measure_text(cancel_text, &button_style)?.width;
 +            let cancel_x = cancel_rect.x + (cancel_rect.width as i32 - cancel_width as i32) / 2;
 +            let cancel_y = cancel_rect.y + (cancel_rect.height as i32 - theme.font_size as i32) / 2;
 +            renderer.text(cancel_text, cancel_x as f64, cancel_y as f64, &button_style)?;
 +        }
++
 +        Ok(())
 +    }
 +}

garfield/src/ui/mod.rsmodified

  pub mod toolbar;
  pub use address_bar::AddressBar;
 -pub use dialog::{ConfirmDialog, DialogResult};
 +pub use dialog::{ConfirmDialog, DialogResult, ProgressDialog, ProgressInfo};
  pub use breadcrumb::Breadcrumb;
  pub use column_view::{ColumnClickResult, ColumnView};
  pub use grid_view::GridView;

garfield/src/ui/tab.rsmodified

+     }
      /// Confirm rename operation. Returns Ok(new_name) on success, Err(message) on failure.
 -    pub fn confirm_rename(&mut self) -> Result<String, String> {
 +    /// Confirm and perform the rename.
 +    /// Returns (original_path, new_path, new_name) on success.
 +    pub fn confirm_rename(&mut self) -> Result<(PathBuf, PathBuf, String), String> {
          let state = match self.renaming.take() {
              Some(s) => s,
              None => return Err("No rename in progress".to_string()),
              return Err("Name cannot be empty".to_string());
+         }
 +        // Get the entry path
 +        let visible = self.visible_entries();
 +        let entry = visible.get(state.index).ok_or("Entry not found")?;
 +        let entry_path = entry.path.clone();
++
          if new_name == state.original {
              // No change, just cancel silently
 -            return Ok(state.original);
 +            return Ok((entry_path.clone(), entry_path, state.original));
+         }
          // Validate: no path separators
              return Err("Name cannot contain path separators".to_string());
+         }
 -        // Get the entry path
 -        let visible = self.visible_entries();
 -        let entry = visible.get(state.index).ok_or("Entry not found")?;
 -        let entry_path = entry.path.clone();
+-
          // Perform the rename
          match rename_path(&entry_path, new_name) {
 -            Ok(_) => {
 +            Ok(new_path) => {
                  self.refresh();
 -                Ok(new_name.to_string())
 +                Ok((entry_path, new_path, new_name.to_string()))
+             }
              Err(e) => Err(e.to_string()),
+         }

          KeybindEntry { key: "Ctrl+C", description: "Copy" },
          KeybindEntry { key: "Ctrl+X", description: "Cut" },
          KeybindEntry { key: "Ctrl+V", description: "Paste" },
 +        KeybindEntry { key: "Ctrl+Z", description: "Undo" },
 +        KeybindEntry { key: "Ctrl+Y", description: "Redo" },
          KeybindEntry { key: "Delete", description: "Move to trash" },
          KeybindEntry { key: "Shift+Delete", description: "Delete permanently" },
          KeybindEntry { key: "F2", description: "Rename" },