`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
++            // Show result in status bar and record for undo
--            if result.success {
++            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, 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" },

`@@ -15,7 +15,7 @@` pub mod tab_bar;
15	pub mod toolbar;	15	pub mod toolbar;
16		16
17	pub use address_bar::AddressBar;	17	pub use address_bar::AddressBar;
18	-pub use dialog::{ConfirmDialog, DialogResult};	18	+pub use dialog::{ConfirmDialog, DialogResult, ProgressDialog, ProgressInfo};
19	pub use breadcrumb::Breadcrumb;	19	pub use breadcrumb::Breadcrumb;
20	pub use column_view::{ColumnClickResult, ColumnView};	20	pub use column_view::{ColumnClickResult, ColumnView};
21	pub use grid_view::GridView;	21	pub use grid_view::GridView;