`a66df49`

core: add file operations (copy, cut, paste, trash, new folder)

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

SHA: a66df49aa3ef160830a8b8cee55b880bc43f50fb
Parents: c657243
Tree: ff53cf0

8 changed files

Status	File	+	-
M	`garfield/src/app.rs`	184	1
A	`garfield/src/core/clipboard.rs`	104	0
M	`garfield/src/core/mod.rs`	9	0
A	`garfield/src/core/operations.rs`	236	0
A	`garfield/src/core/trash.rs`	219	0
M	`garfield/src/ui/help_modal.rs`	9	0
M	`garfield/src/ui/tab.rs`	9	0
M	`garfield/src/ui/toolbar.rs`	191	1

garfield/src/app.rsmodified

  //! Application state and event loop.
 +use garfield::core::{
 +    Clipboard, ClipboardOperation,
 +    copy_files, move_files, delete_files, create_directory,
 +    trash_files,
 +};
  use garfield::ui::pane::SplitDirection;
  use garfield::ui::{AddressBar, Breadcrumb, HelpModal, Pane, Sidebar, StatusBar, TabBar, TabInfo, Toolbar, ToolbarAction, ViewMode, TAB_BAR_HEIGHT, TOOLBAR_HEIGHT};
  use anyhow::Result;
      drag_current_pos: Option<Point>,
      /// Whether drag is actively in progress (moved past threshold).
      drag_active: bool,
 +    /// Clipboard for file operations.
 +    clipboard: Clipboard,
+ }
  impl App {
              drag_start_pos: None,
              drag_current_pos: None,
              drag_active: false,
 +            clipboard: Clipboard::new(),
          };
          app.update_status_bar();
+             }
+         }
 -        // Ctrl+Shift keybinds (splits)
 +        // Ctrl+Shift keybinds (splits, new folder)
          if modifiers.ctrl && modifiers.shift {
              match key {
 +                Key::Char('n') | Key::Char('N') => {
 +                    self.create_new_folder();
 +                    return;
 +                }
                  Key::Char('h') | Key::Char('H') => {
                      self.split_horizontal();
                      return;
+                     }
                      return;
+                 }
 +                Key::Char('c') | Key::Char('C') => {
 +                    self.copy_selected();
 +                    return;
 +                }
 +                Key::Char('x') | Key::Char('X') => {
 +                    self.cut_selected();
 +                    return;
 +                }
 +                Key::Char('v') | Key::Char('V') => {
 +                    self.paste();
 +                    return;
 +                }
                  _ => {}
+             }
+         }
 +        // Shift+Delete for permanent delete
 +        if modifiers.shift && *key == Key::Delete {
 +            self.delete_selected_permanently();
 +            return;
 +        }
++
          match key {
 +            Key::Delete => {
 +                self.trash_selected();
 +            }
 +            Key::F2 => {
 +                self.start_rename();
 +            }
              Key::Escape => {
                  // Cancel drag first if active
                  if self.drag_active || self.drag_source_path.is_some() {
          self.update_status_bar();
+     }
 +    // === File Operations ===
++
 +    /// Copy selected files to clipboard.
 +    fn copy_selected(&mut self) {
 +        let paths = self.get_selected_paths();
 +        if !paths.is_empty() {
 +            self.clipboard.copy(paths);
 +            self.update_status_bar();
 +        }
 +    }
++
 +    /// Cut selected files to clipboard.
 +    fn cut_selected(&mut self) {
 +        let paths = self.get_selected_paths();
 +        if !paths.is_empty() {
 +            self.clipboard.cut(paths);
 +            self.update_status_bar();
 +        }
 +    }
++
 +    /// Paste files from clipboard to current directory.
 +    fn paste(&mut self) {
 +        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,
 +        };
++
 +        if let Some((files, op)) = self.clipboard.take() {
 +            let result = match op {
 +                ClipboardOperation::Copy => copy_files(&files, &dest_dir),
 +                ClipboardOperation::Cut => move_files(&files, &dest_dir),
 +            };
++
 +            // Show result in status bar or log errors
 +            if !result.success {
 +                // TODO: Show error dialog
 +                eprintln!("File operation failed: {:?}", result.error);
 +            }
++
 +            self.refresh();
 +        }
 +    }
++
 +    /// Move selected files to trash.
 +    fn trash_selected(&mut self) {
 +        let paths = self.get_selected_paths();
 +        if paths.is_empty() {
 +            return;
 +        }
++
 +        let results = trash_files(&paths);
 +        let failed: Vec<_> = results.iter()
 +            .filter_map(|r| r.as_ref().err())
 +            .collect();
++
 +        if !failed.is_empty() {
 +            // TODO: Show error dialog
 +            eprintln!("Failed to trash {} files", failed.len());
 +        }
++
 +        self.refresh();
 +    }
++
 +    /// Delete selected files permanently.
 +    fn delete_selected_permanently(&mut self) {
 +        let paths = self.get_selected_paths();
 +        if paths.is_empty() {
 +            return;
 +        }
++
 +        // TODO: Show confirmation dialog
 +        // For now, just perform the delete
 +        let result = delete_files(&paths);
++
 +        if !result.success {
 +            eprintln!("Delete failed: {:?}", result.error);
 +        }
++
 +        self.refresh();
 +    }
++
 +    /// Create a new folder in the current directory.
 +    fn create_new_folder(&mut self) {
 +        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 base_name = "New Folder";
 +        let mut name = base_name.to_string();
 +        let mut counter = 1;
 +        while current_dir.join(&name).exists() {
 +            name = format!("{} ({})", base_name, counter);
 +            counter += 1;
 +        }
++
 +        match create_directory(&current_dir, &name) {
 +            Ok(_) => {
 +                self.refresh();
 +                // TODO: Start rename on the new folder
 +            }
 +            Err(e) => {
 +                // TODO: Show error dialog
 +                eprintln!("Failed to create folder: {}", e);
 +            }
 +        }
 +    }
++
 +    /// Start inline rename for the selected file.
 +    fn start_rename(&mut self) {
 +        // TODO: Implement inline rename UI
 +        // For now, just log that rename was requested
 +        if let Some(entry) = self.focused_pane()
 +            .and_then(|p| p.active_tab())
 +            .and_then(|t| t.selected_entry())
 +        {
 +            eprintln!("Rename requested for: {}", entry.name);
 +        }
 +    }
++
 +    /// Get paths of all selected files.
 +    fn get_selected_paths(&self) -> Vec<PathBuf> {
 +        self.focused_pane()
 +            .and_then(|p| p.active_tab())
 +            .map(|t| t.selected_paths())
 +            .unwrap_or_default()
 +    }
++
      /// Set the view mode for the active tab.
      fn set_view_mode(&mut self, mode: ViewMode) {
          if let Some(pane) = self.focused_pane_mut() {
              ToolbarAction::GoForward => self.go_forward(),
              ToolbarAction::GoUp => self.go_up(),
              ToolbarAction::Help => self.help_modal.toggle(),
 +            ToolbarAction::Copy => self.copy_selected(),
 +            ToolbarAction::Cut => self.cut_selected(),
 +            ToolbarAction::Paste => self.paste(),
 +            ToolbarAction::Trash => self.trash_selected(),
 +            ToolbarAction::NewFolder => self.create_new_folder(),
+         }
+     }
              self.status_bar.update(visible_count, selected_count, selected_size);
              self.status_bar.set_view_mode(view_mode);
              self.status_bar.update_free_space(&path);
++
 +            // Update toolbar file ops state
 +            let has_selection = selected_count > 0;
 +            let has_clipboard = self.clipboard.has_files();
 +            self.toolbar.set_file_ops_state(has_selection, has_clipboard);
+         }
+     }

garfield/src/core/clipboard.rsadded

 +//! Clipboard state for file operations.
++
 +use std::path::PathBuf;
++
 +/// Operation type for clipboard contents.
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +pub enum ClipboardOperation {
 +    /// Files will be copied.
 +    Copy,
 +    /// Files will be moved (cut).
 +    Cut,
 +}
++
 +/// Clipboard holding files for copy/cut operations.
 +#[derive(Debug, Clone, Default)]
 +pub struct Clipboard {
 +    /// Files in the clipboard.
 +    files: Vec<PathBuf>,
 +    /// Operation to perform.
 +    operation: Option<ClipboardOperation>,
 +}
++
 +impl Clipboard {
 +    /// Create a new empty clipboard.
 +    pub fn new() -> Self {
 +        Self::default()
 +    }
++
 +    /// Copy files to clipboard.
 +    pub fn copy(&mut self, files: Vec<PathBuf>) {
 +        self.files = files;
 +        self.operation = Some(ClipboardOperation::Copy);
 +    }
++
 +    /// Cut files to clipboard.
 +    pub fn cut(&mut self, files: Vec<PathBuf>) {
 +        self.files = files;
 +        self.operation = Some(ClipboardOperation::Cut);
 +    }
++
 +    /// Clear the clipboard.
 +    pub fn clear(&mut self) {
 +        self.files.clear();
 +        self.operation = None;
 +    }
++
 +    /// Get files in the clipboard.
 +    pub fn files(&self) -> &[PathBuf] {
 +        &self.files
 +    }
++
 +    /// Get the operation type.
 +    pub fn operation(&self) -> Option<ClipboardOperation> {
 +        self.operation
 +    }
++
 +    /// Check if clipboard has files.
 +    pub fn has_files(&self) -> bool {
 +        !self.files.is_empty() && self.operation.is_some()
 +    }
++
 +    /// Check if this is a cut operation.
 +    pub fn is_cut(&self) -> bool {
 +        self.operation == Some(ClipboardOperation::Cut)
 +    }
++
 +    /// Get status text for display.
 +    pub fn status_text(&self) -> Option<String> {
 +        if !self.has_files() {
 +            return None;
 +        }
++
 +        let count = self.files.len();
 +        let op = match self.operation {
 +            Some(ClipboardOperation::Copy) => "copied",
 +            Some(ClipboardOperation::Cut) => "cut",
 +            None => return None,
 +        };
++
 +        Some(if count == 1 {
 +            format!("1 item {}", op)
 +        } else {
 +            format!("{} items {}", count, op)
 +        })
 +    }
++
 +    /// Take files from clipboard (consumes for cut operations).
 +    pub fn take(&mut self) -> Option<(Vec<PathBuf>, ClipboardOperation)> {
 +        if !self.has_files() {
 +            return None;
 +        }
++
 +        let files = std::mem::take(&mut self.files);
 +        let op = self.operation.take()?;
++
 +        // For copy, restore the files so they can be pasted again
 +        if op == ClipboardOperation::Copy {
 +            self.files = files.clone();
 +            self.operation = Some(op);
 +        }
++
 +        Some((files, op))
 +    }
 +}

garfield/src/core/mod.rsmodified

  //! Core file system operations.
 +pub mod clipboard;
  pub mod entry;
  pub mod history;
 +pub mod operations;
 +pub mod trash;
 +pub use clipboard::{Clipboard, ClipboardOperation};
  pub use entry::{
      read_directory, sort_entries, EntryType, FileEntry, SortDirection, SortOrder,
  };
  pub use history::History;
 +pub use operations::{
 +    copy_files, copy_path, create_directory, delete_files, delete_path,
 +    make_unique_name, move_files, move_path, rename_path, OperationResult,
 +};
 +pub use trash::{empty_trash, restore_from_trash, trash_file, trash_files, trash_dir};

garfield/src/core/operations.rsadded

 +//! File operations (copy, move, delete, rename).
++
 +use std::fs;
 +use std::io;
 +use std::path::{Path, PathBuf};
++
 +/// Result of a file operation.
 +#[derive(Debug)]
 +pub struct OperationResult {
 +    /// Whether the operation succeeded.
 +    pub success: bool,
 +    /// Error message if failed.
 +    pub error: Option<String>,
 +    /// Files that were processed.
 +    pub processed: Vec<PathBuf>,
 +    /// Files that failed.
 +    pub failed: Vec<(PathBuf, String)>,
 +}
++
 +impl OperationResult {
 +    /// Create a successful result.
 +    pub fn success(processed: Vec<PathBuf>) -> Self {
 +        Self {
 +            success: true,
 +            error: None,
 +            processed,
 +            failed: Vec::new(),
 +        }
 +    }
++
 +    /// Create a failed result.
 +    pub fn failure(error: String) -> Self {
 +        Self {
 +            success: false,
 +            error: Some(error),
 +            processed: Vec::new(),
 +            failed: Vec::new(),
 +        }
 +    }
++
 +    /// Create a partial result.
 +    pub fn partial(processed: Vec<PathBuf>, failed: Vec<(PathBuf, String)>) -> Self {
 +        Self {
 +            success: failed.is_empty(),
 +            error: if failed.is_empty() {
 +                None
 +            } else {
 +                Some(format!("{} files failed", failed.len()))
 +            },
 +            processed,
 +            failed,
 +        }
 +    }
 +}
++
 +/// Copy a file or directory to a destination.
 +pub fn copy_path(source: &Path, dest_dir: &Path) -> io::Result<PathBuf> {
 +    let file_name = source.file_name().ok_or_else(|| {
 +        io::Error::new(io::ErrorKind::InvalidInput, "Invalid source path")
 +    })?;
 +    let dest = dest_dir.join(file_name);
++
 +    if source.is_dir() {
 +        copy_dir_recursive(source, &dest)?;
 +    } else {
 +        fs::copy(source, &dest)?;
 +    }
++
 +    Ok(dest)
 +}
++
 +/// Copy a directory recursively.
 +fn copy_dir_recursive(source: &Path, dest: &Path) -> io::Result<()> {
 +    fs::create_dir_all(dest)?;
++
 +    for entry in fs::read_dir(source)? {
 +        let entry = entry?;
 +        let entry_path = entry.path();
 +        let dest_path = dest.join(entry.file_name());
++
 +        if entry_path.is_dir() {
 +            copy_dir_recursive(&entry_path, &dest_path)?;
 +        } else {
 +            fs::copy(&entry_path, &dest_path)?;
 +        }
 +    }
++
 +    Ok(())
 +}
++
 +/// Move a file or directory to a destination.
 +pub fn move_path(source: &Path, dest_dir: &Path) -> io::Result<PathBuf> {
 +    let file_name = source.file_name().ok_or_else(|| {
 +        io::Error::new(io::ErrorKind::InvalidInput, "Invalid source path")
 +    })?;
 +    let dest = dest_dir.join(file_name);
++
 +    // Try rename first (fast, same filesystem)
 +    if fs::rename(source, &dest).is_ok() {
 +        return Ok(dest);
 +    }
++
 +    // Fall back to copy + delete (cross-filesystem)
 +    if source.is_dir() {
 +        copy_dir_recursive(source, &dest)?;
 +        fs::remove_dir_all(source)?;
 +    } else {
 +        fs::copy(source, &dest)?;
 +        fs::remove_file(source)?;
 +    }
++
 +    Ok(dest)
 +}
++
 +/// Delete a file or directory permanently.
 +pub fn delete_path(path: &Path) -> io::Result<()> {
 +    if path.is_dir() {
 +        fs::remove_dir_all(path)
 +    } else {
 +        fs::remove_file(path)
 +    }
 +}
++
 +/// Rename a file or directory.
 +pub fn rename_path(path: &Path, new_name: &str) -> io::Result<PathBuf> {
 +    let parent = path.parent().ok_or_else(|| {
 +        io::Error::new(io::ErrorKind::InvalidInput, "Cannot get parent directory")
 +    })?;
 +    let new_path = parent.join(new_name);
++
 +    if new_path.exists() {
 +        return Err(io::Error::new(
 +            io::ErrorKind::AlreadyExists,
 +            format!("'{}' already exists", new_name),
 +        ));
 +    }
++
 +    fs::rename(path, &new_path)?;
 +    Ok(new_path)
 +}
++
 +/// Create a new directory.
 +pub fn create_directory(parent: &Path, name: &str) -> io::Result<PathBuf> {
 +    let new_path = parent.join(name);
++
 +    if new_path.exists() {
 +        return Err(io::Error::new(
 +            io::ErrorKind::AlreadyExists,
 +            format!("'{}' already exists", name),
 +        ));
 +    }
++
 +    fs::create_dir(&new_path)?;
 +    Ok(new_path)
 +}
++
 +/// Generate a unique name if the target already exists.
 +pub fn make_unique_name(dest_dir: &Path, name: &str) -> String {
 +    let path = dest_dir.join(name);
 +    if !path.exists() {
 +        return name.to_string();
 +    }
++
 +    // Split name into base and extension
 +    let (base, ext) = if let Some(dot_pos) = name.rfind('.') {
 +        (&name[..dot_pos], Some(&name[dot_pos..]))
 +    } else {
 +        (name, None)
 +    };
++
 +    // Try adding numbers until we find a unique name
 +    for i in 1..1000 {
 +        let new_name = match ext {
 +            Some(ext) => format!("{} ({}){}", base, i, ext),
 +            None => format!("{} ({})", base, i),
 +        };
 +        if !dest_dir.join(&new_name).exists() {
 +            return new_name;
 +        }
 +    }
++
 +    // Fallback with timestamp
 +    let timestamp = std::time::SystemTime::now()
 +        .duration_since(std::time::UNIX_EPOCH)
 +        .map(|d| d.as_secs())
 +        .unwrap_or(0);
 +    match ext {
 +        Some(ext) => format!("{}_{}{}", base, timestamp, ext),
 +        None => format!("{}_{}", base, timestamp),
 +    }
 +}
++
 +/// Copy multiple files to a destination.
 +pub fn copy_files(sources: &[PathBuf], dest_dir: &Path) -> OperationResult {
 +    let mut processed = Vec::new();
 +    let mut failed = Vec::new();
++
 +    for source in sources {
 +        match copy_path(source, dest_dir) {
 +            Ok(dest) => processed.push(dest),
 +            Err(e) => failed.push((source.clone(), e.to_string())),
 +        }
 +    }
++
 +    OperationResult::partial(processed, failed)
 +}
++
 +/// Move multiple files to a destination.
 +pub fn move_files(sources: &[PathBuf], dest_dir: &Path) -> OperationResult {
 +    let mut processed = Vec::new();
 +    let mut failed = Vec::new();
++
 +    for source in sources {
 +        match move_path(source, dest_dir) {
 +            Ok(dest) => processed.push(dest),
 +            Err(e) => failed.push((source.clone(), e.to_string())),
 +        }
 +    }
++
 +    OperationResult::partial(processed, failed)
 +}
++
 +/// Delete multiple files permanently.
 +pub fn delete_files(paths: &[PathBuf]) -> OperationResult {
 +    let mut processed = Vec::new();
 +    let mut failed = Vec::new();
++
 +    for path in paths {
 +        match delete_path(path) {
 +            Ok(()) => processed.push(path.clone()),
 +            Err(e) => failed.push((path.clone(), e.to_string())),
 +        }
 +    }
++
 +    OperationResult::partial(processed, failed)
 +}

garfield/src/core/trash.rsadded

 +//! Freedesktop trash support.
++
 +use std::fs;
 +use std::io;
 +use std::path::{Path, PathBuf};
 +use std::time::SystemTime;
++
 +/// Get the trash directory path.
 +pub fn trash_dir() -> Option<PathBuf> {
 +    dirs::data_dir().map(|d| d.join("Trash"))
 +}
++
 +/// Get the trash files directory.
 +pub fn trash_files_dir() -> Option<PathBuf> {
 +    trash_dir().map(|d| d.join("files"))
 +}
++
 +/// Get the trash info directory.
 +pub fn trash_info_dir() -> Option<PathBuf> {
 +    trash_dir().map(|d| d.join("info"))
 +}
++
 +/// Ensure trash directories exist.
 +fn ensure_trash_dirs() -> io::Result<(PathBuf, PathBuf)> {
 +    let files_dir = trash_files_dir().ok_or_else(|| {
 +        io::Error::new(io::ErrorKind::NotFound, "Cannot determine trash directory")
 +    })?;
 +    let info_dir = trash_info_dir().ok_or_else(|| {
 +        io::Error::new(io::ErrorKind::NotFound, "Cannot determine trash info directory")
 +    })?;
++
 +    fs::create_dir_all(&files_dir)?;
 +    fs::create_dir_all(&info_dir)?;
++
 +    Ok((files_dir, info_dir))
 +}
++
 +/// Generate a unique trash name.
 +fn unique_trash_name(files_dir: &Path, name: &str) -> String {
 +    if !files_dir.join(name).exists() {
 +        return name.to_string();
 +    }
++
 +    let (base, ext) = if let Some(dot_pos) = name.rfind('.') {
 +        (&name[..dot_pos], Some(&name[dot_pos..]))
 +    } else {
 +        (name, None)
 +    };
++
 +    for i in 1..10000 {
 +        let new_name = match ext {
 +            Some(ext) => format!("{}.{}{}", base, i, ext),
 +            None => format!("{}.{}", base, i),
 +        };
 +        if !files_dir.join(&new_name).exists() {
 +            return new_name;
 +        }
 +    }
++
 +    // Fallback with timestamp
 +    let timestamp = SystemTime::now()
 +        .duration_since(std::time::UNIX_EPOCH)
 +        .map(|d| d.as_millis())
 +        .unwrap_or(0);
 +    format!("{}.{}", name, timestamp)
 +}
++
 +/// Create a .trashinfo file content.
 +fn create_trash_info(original_path: &Path) -> String {
 +    let path_encoded = original_path
 +        .to_string_lossy()
 +        .replace('%', "%25")
 +        .replace('\n', "%0A")
 +        .replace('\r', "%0D");
++
 +    let deletion_date = chrono::Local::now().format("%Y-%m-%dT%H:%M:%S");
++
 +    format!(
 +        "[Trash Info]\nPath={}\nDeletionDate={}\n",
 +        path_encoded, deletion_date
 +    )
 +}
++
 +/// Move a file to trash.
 +pub fn trash_file(path: &Path) -> io::Result<PathBuf> {
 +    let (files_dir, info_dir) = ensure_trash_dirs()?;
++
 +    let original_name = path
 +        .file_name()
 +        .ok_or_else(|| io::Error::new(io::ErrorKind::InvalidInput, "Invalid path"))?
 +        .to_string_lossy()
 +        .to_string();
++
 +    let trash_name = unique_trash_name(&files_dir, &original_name);
 +    let trash_path = files_dir.join(&trash_name);
 +    let info_path = info_dir.join(format!("{}.trashinfo", trash_name));
++
 +    // Write .trashinfo file first
 +    let info_content = create_trash_info(path);
 +    fs::write(&info_path, info_content)?;
++
 +    // Move file to trash
 +    if let Err(_) = fs::rename(path, &trash_path) {
 +        // If rename fails, try copy + delete (cross-filesystem)
 +        if path.is_dir() {
 +            copy_dir_recursive(path, &trash_path)?;
 +            fs::remove_dir_all(path)?;
 +        } else {
 +            fs::copy(path, &trash_path)?;
 +            fs::remove_file(path)?;
 +        }
 +    }
++
 +    Ok(trash_path)
 +}
++
 +/// Copy a directory recursively.
 +fn copy_dir_recursive(source: &Path, dest: &Path) -> io::Result<()> {
 +    fs::create_dir_all(dest)?;
++
 +    for entry in fs::read_dir(source)? {
 +        let entry = entry?;
 +        let entry_path = entry.path();
 +        let dest_path = dest.join(entry.file_name());
++
 +        if entry_path.is_dir() {
 +            copy_dir_recursive(&entry_path, &dest_path)?;
 +        } else {
 +            fs::copy(&entry_path, &dest_path)?;
 +        }
 +    }
++
 +    Ok(())
 +}
++
 +/// Move multiple files to trash.
 +pub fn trash_files(paths: &[PathBuf]) -> Vec<Result<PathBuf, (PathBuf, String)>> {
 +    paths
 +        .iter()
 +        .map(|path| {
 +            trash_file(path)
 +                .map_err(|e| (path.clone(), e.to_string()))
 +        })
 +        .collect()
 +}
++
 +/// Restore a file from trash to its original location.
 +pub fn restore_from_trash(trash_name: &str) -> io::Result<PathBuf> {
 +    let (files_dir, info_dir) = ensure_trash_dirs()?;
++
 +    let trash_path = files_dir.join(trash_name);
 +    let info_path = info_dir.join(format!("{}.trashinfo", trash_name));
++
 +    if !trash_path.exists() {
 +        return Err(io::Error::new(
 +            io::ErrorKind::NotFound,
 +            "File not found in trash",
 +        ));
 +    }
++
 +    // Read original path from .trashinfo
 +    let info_content = fs::read_to_string(&info_path)?;
 +    let original_path = parse_trash_info_path(&info_content).ok_or_else(|| {
 +        io::Error::new(io::ErrorKind::InvalidData, "Invalid .trashinfo file")
 +    })?;
++
 +    // Restore the file
 +    if let Some(parent) = original_path.parent() {
 +        fs::create_dir_all(parent)?;
 +    }
++
 +    fs::rename(&trash_path, &original_path)?;
 +    fs::remove_file(&info_path)?;
++
 +    Ok(original_path)
 +}
++
 +/// Parse the original path from .trashinfo content.
 +fn parse_trash_info_path(content: &str) -> Option<PathBuf> {
 +    for line in content.lines() {
 +        if let Some(path) = line.strip_prefix("Path=") {
 +            // URL decode the path
 +            let decoded = path
 +                .replace("%0A", "\n")
 +                .replace("%0D", "\r")
 +                .replace("%25", "%");
 +            return Some(PathBuf::from(decoded));
 +        }
 +    }
 +    None
 +}
++
 +/// Empty the trash.
 +pub fn empty_trash() -> io::Result<()> {
 +    let (files_dir, info_dir) = ensure_trash_dirs()?;
++
 +    // Remove all files
 +    if files_dir.exists() {
 +        for entry in fs::read_dir(&files_dir)? {
 +            let entry = entry?;
 +            let path = entry.path();
 +            if path.is_dir() {
 +                fs::remove_dir_all(&path)?;
 +            } else {
 +                fs::remove_file(&path)?;
 +            }
 +        }
 +    }
++
 +    // Remove all .trashinfo files
 +    if info_dir.exists() {
 +        for entry in fs::read_dir(&info_dir)? {
 +            let entry = entry?;
 +            fs::remove_file(entry.path())?;
 +        }
 +    }
++
 +    Ok(())
 +}

garfield/src/ui/tab.rsmodified

+         }
+     }
 +    /// Get paths of all selected entries.
 +    pub fn selected_paths(&self) -> Vec<std::path::PathBuf> {
 +        match self.view_mode {
 +            ViewMode::List => self.list_view.selected_entries().iter().map(|e| e.path.clone()).collect(),
 +            ViewMode::Grid => self.grid_view.selected_entries().iter().map(|e| e.path.clone()).collect(),
 +            ViewMode::Columns => self.column_view.selected_entries().iter().map(|e| e.path.clone()).collect(),
 +        }
 +    }
++
      /// Get the entry at the given position (for drag detection).
      pub fn entry_at_point(&self, pos: Point) -> Option<&FileEntry> {
          match self.view_mode {

garfield/src/ui/toolbar.rsmodified

      GoUp,
      /// Show help modal.
      Help,
 +    /// Copy selected files.
 +    Copy,
 +    /// Cut selected files.
 +    Cut,
 +    /// Paste files from clipboard.
 +    Paste,
 +    /// Delete selected files to trash.
 +    Trash,
 +    /// Create new folder.
 +    NewFolder,
+ }
  /// A toolbar button.
      active_view: ToolbarAction,
      can_go_back: bool,
      can_go_forward: bool,
 +    has_selection: bool,
 +    has_clipboard: bool,
+ }
  impl Toolbar {
              active_view: ToolbarAction::ViewList,
              can_go_back: false,
              can_go_forward: false,
 +            has_selection: false,
 +            has_clipboard: false,
          };
          toolbar.layout_buttons();
          toolbar
          self.can_go_forward = can_forward;
+     }
 +    /// Set file operation state.
 +    pub fn set_file_ops_state(&mut self, has_selection: bool, has_clipboard: bool) {
 +        self.has_selection = has_selection;
 +        self.has_clipboard = has_clipboard;
 +    }
++
      /// Layout buttons.
      fn layout_buttons(&mut self) {
          self.buttons.clear();
              x += BUTTON_SIZE as i32 + BUTTON_PADDING as i32;
+         }
 +        x += GROUP_SEPARATOR as i32;
++
 +        // File operation buttons
 +        let file_buttons = [
 +            (ToolbarAction::Copy, "Copy (Ctrl+C)"),
 +            (ToolbarAction::Cut, "Cut (Ctrl+X)"),
 +            (ToolbarAction::Paste, "Paste (Ctrl+V)"),
 +            (ToolbarAction::Trash, "Delete (Del)"),
 +            (ToolbarAction::NewFolder, "New Folder (Ctrl+Shift+N)"),
 +        ];
++
 +        for (action, tooltip) in file_buttons {
 +            self.buttons.push(ToolbarButton {
 +                action,
 +                bounds: Rect::new(x, y, BUTTON_SIZE, BUTTON_SIZE),
 +                tooltip,
 +            });
 +            x += BUTTON_SIZE as i32 + BUTTON_PADDING as i32;
 +        }
++
          // Help button (right-aligned)
          let help_x = self.bounds.x + self.bounds.width as i32 - BUTTON_SIZE as i32 - BUTTON_PADDING as i32;
          self.buttons.push(ToolbarButton {
      pub fn on_click(&self, pos: Point) -> Option<ToolbarAction> {
          for button in &self.buttons {
              if button.bounds.contains_point(pos) {
 -                // Don't trigger disabled nav buttons
 +                // Don't trigger disabled buttons
                  match button.action {
                      ToolbarAction::GoBack if !self.can_go_back => return None,
                      ToolbarAction::GoForward if !self.can_go_forward => return None,
 +                    ToolbarAction::Copy | ToolbarAction::Cut | ToolbarAction::Trash
 +                        if !self.has_selection => return None,
 +                    ToolbarAction::Paste if !self.has_clipboard => return None,
                      _ => return Some(button.action),
+                 }
+             }
          let is_disabled = match button.action {
              ToolbarAction::GoBack => !self.can_go_back,
              ToolbarAction::GoForward => !self.can_go_forward,
 +            ToolbarAction::Copy | ToolbarAction::Cut | ToolbarAction::Trash => !self.has_selection,
 +            ToolbarAction::Paste => !self.has_clipboard,
              _ => false,
          };
              ToolbarAction::SplitHorizontal => self.draw_split_h_icon(renderer, cx, cy, icon_color)?,
              ToolbarAction::SplitVertical => self.draw_split_v_icon(renderer, cx, cy, icon_color)?,
              ToolbarAction::Help => self.draw_help_icon(renderer, cx, cy, icon_color)?,
 +            ToolbarAction::Copy => self.draw_copy_icon(renderer, cx, cy, icon_color)?,
 +            ToolbarAction::Cut => self.draw_cut_icon(renderer, cx, cy, icon_color)?,
 +            ToolbarAction::Paste => self.draw_paste_icon(renderer, cx, cy, icon_color)?,
 +            ToolbarAction::Trash => self.draw_trash_icon(renderer, cx, cy, icon_color)?,
 +            ToolbarAction::NewFolder => self.draw_new_folder_icon(renderer, cx, cy, icon_color)?,
+         }
          Ok(())
          renderer.fill_rect(Rect::new((cx - 1.0) as i32, (cy + 3.0) as i32, 3, 3), color)?;
          Ok(())
+     }
++
 +    fn draw_copy_icon(&self, renderer: &Renderer, cx: f64, cy: f64, color: gartk_core::Color) -> Result<()> {
 +        // Two overlapping rectangles (copy symbol)
 +        let w = 7.0;
 +        let h = 9.0;
 +        let offset = 3.0;
++
 +        // Back rectangle (slightly offset)
 +        let bx = cx - w/2.0 - offset/2.0;
 +        let by = cy - h/2.0 - offset/2.0;
 +        renderer.stroke_rect(Rect::new(bx as i32, by as i32, w as u32, h as u32), color, 1.5)?;
++
 +        // Front rectangle
 +        let fx = cx - w/2.0 + offset/2.0;
 +        let fy = cy - h/2.0 + offset/2.0;
 +        renderer.fill_rect(Rect::new(fx as i32, fy as i32, w as u32, h as u32), color.with_alpha(0.3))?;
 +        renderer.stroke_rect(Rect::new(fx as i32, fy as i32, w as u32, h as u32), color, 1.5)?;
 +        Ok(())
 +    }
++
 +    fn draw_cut_icon(&self, renderer: &Renderer, cx: f64, cy: f64, color: gartk_core::Color) -> Result<()> {
 +        // Scissors shape - two circles with crossed lines
 +        let r = 3.0;
 +        let segments = 12;
++
 +        // Left circle (handle)
 +        let lcx = cx - 4.0;
 +        let lcy = cy + 3.0;
 +        for i in 0..segments {
 +            let a1 = (i as f64 / segments as f64) * std::f64::consts::TAU;
 +            let a2 = ((i + 1) as f64 / segments as f64) * std::f64::consts::TAU;
 +            renderer.line(
 +                lcx + r * a1.cos(), lcy + r * a1.sin(),
 +                lcx + r * a2.cos(), lcy + r * a2.sin(),
 +                color, 1.5
 +            )?;
 +        }
++
 +        // Right circle (handle)
 +        let rcx = cx + 4.0;
 +        let rcy = cy + 3.0;
 +        for i in 0..segments {
 +            let a1 = (i as f64 / segments as f64) * std::f64::consts::TAU;
 +            let a2 = ((i + 1) as f64 / segments as f64) * std::f64::consts::TAU;
 +            renderer.line(
 +                rcx + r * a1.cos(), rcy + r * a1.sin(),
 +                rcx + r * a2.cos(), rcy + r * a2.sin(),
 +                color, 1.5
 +            )?;
 +        }
++
 +        // Blades (crossed lines going up)
 +        renderer.line(lcx, lcy - r, cx + 2.0, cy - 6.0, color, 1.5)?;
 +        renderer.line(rcx, rcy - r, cx - 2.0, cy - 6.0, color, 1.5)?;
 +        Ok(())
 +    }
++
 +    fn draw_paste_icon(&self, renderer: &Renderer, cx: f64, cy: f64, color: gartk_core::Color) -> Result<()> {
 +        // Clipboard with paper
 +        let w = 10.0;
 +        let h = 12.0;
++
 +        // Clipboard outline
 +        let bx = cx - w/2.0;
 +        let by = cy - h/2.0 + 1.0;
 +        renderer.stroke_rect(Rect::new(bx as i32, by as i32, w as u32, h as u32), color, 1.5)?;
++
 +        // Clip at top (small rectangle)
 +        let clip_w = 5.0;
 +        let clip_h = 3.0;
 +        let clip_x = cx - clip_w/2.0;
 +        let clip_y = by - clip_h/2.0;
 +        renderer.fill_rect(Rect::new(clip_x as i32, clip_y as i32, clip_w as u32, clip_h as u32), color)?;
++
 +        // Lines on clipboard (document content)
 +        let line_y1 = by + 4.0;
 +        let line_y2 = by + 7.0;
 +        renderer.line(bx + 2.0, line_y1, bx + w - 2.0, line_y1, color, 1.5)?;
 +        renderer.line(bx + 2.0, line_y2, bx + w - 2.0, line_y2, color, 1.5)?;
 +        Ok(())
 +    }
++
 +    fn draw_trash_icon(&self, renderer: &Renderer, cx: f64, cy: f64, color: gartk_core::Color) -> Result<()> {
 +        // Trash can shape
 +        let w = 10.0;
 +        let h = 10.0;
++
 +        // Body (trapezoid-ish)
 +        let bx = cx - w/2.0;
 +        let by = cy - h/2.0 + 2.0;
 +        let bw = w;
 +        let bh = h - 2.0;
 +        renderer.line(bx, by, bx + 1.0, by + bh, color, 1.5)?;
 +        renderer.line(bx + 1.0, by + bh, bx + bw - 1.0, by + bh, color, 1.5)?;
 +        renderer.line(bx + bw - 1.0, by + bh, bx + bw, by, color, 1.5)?;
++
 +        // Lid
 +        let lid_y = cy - h/2.0;
 +        renderer.line(cx - w/2.0 - 1.0, lid_y, cx + w/2.0 + 1.0, lid_y, color, 2.0)?;
++
 +        // Handle on lid
 +        renderer.line(cx - 2.0, lid_y, cx - 2.0, lid_y - 2.0, color, 1.5)?;
 +        renderer.line(cx - 2.0, lid_y - 2.0, cx + 2.0, lid_y - 2.0, color, 1.5)?;
 +        renderer.line(cx + 2.0, lid_y - 2.0, cx + 2.0, lid_y, color, 1.5)?;
++
 +        // Vertical lines inside
 +        renderer.line(cx - 2.0, by + 2.0, cx - 2.0, by + bh - 2.0, color, 1.0)?;
 +        renderer.line(cx, by + 2.0, cx, by + bh - 2.0, color, 1.0)?;
 +        renderer.line(cx + 2.0, by + 2.0, cx + 2.0, by + bh - 2.0, color, 1.0)?;
 +        Ok(())
 +    }
++
 +    fn draw_new_folder_icon(&self, renderer: &Renderer, cx: f64, cy: f64, color: gartk_core::Color) -> Result<()> {
 +        // Folder shape with plus sign
 +        let w = 12.0;
 +        let h = 9.0;
 +        let tab_w = 5.0;
 +        let tab_h = 2.0;
++
 +        let fx = cx - w/2.0;
 +        let fy = cy - h/2.0;
++
 +        // Folder tab
 +        renderer.line(fx, fy + tab_h, fx, fy, color, 1.5)?;
 +        renderer.line(fx, fy, fx + tab_w, fy, color, 1.5)?;
 +        renderer.line(fx + tab_w, fy, fx + tab_w + 2.0, fy + tab_h, color, 1.5)?;
++
 +        // Folder body
 +        renderer.line(fx + tab_w + 2.0, fy + tab_h, fx + w, fy + tab_h, color, 1.5)?;
 +        renderer.line(fx + w, fy + tab_h, fx + w, fy + h, color, 1.5)?;
 +        renderer.line(fx + w, fy + h, fx, fy + h, color, 1.5)?;
 +        renderer.line(fx, fy + h, fx, fy + tab_h, color, 1.5)?;
++
 +        // Plus sign in center
 +        let plus_size = 4.0;
 +        let pcy = cy + 1.0;
 +        renderer.line(cx - plus_size/2.0, pcy, cx + plus_size/2.0, pcy, color, 1.5)?;
 +        renderer.line(cx, pcy - plus_size/2.0, cx, pcy + plus_size/2.0, color, 1.5)?;
 +        Ok(())
 +    }
+ }

          KeybindEntry { key: "Ctrl+Click", description: "Toggle selection" },
          KeybindEntry { key: "Shift+Click", description: "Range select" },
      ]),
 +    ("File Operations", &[
 +        KeybindEntry { key: "Ctrl+C", description: "Copy" },
 +        KeybindEntry { key: "Ctrl+X", description: "Cut" },
 +        KeybindEntry { key: "Ctrl+V", description: "Paste" },
 +        KeybindEntry { key: "Delete", description: "Move to trash" },
 +        KeybindEntry { key: "Shift+Delete", description: "Delete permanently" },
 +        KeybindEntry { key: "F2", description: "Rename" },
 +        KeybindEntry { key: "Ctrl+Shift+N", description: "New folder" },
 +    ]),
      ("Other", &[
          KeybindEntry { key: "Ctrl+L", description: "Edit address" },
          KeybindEntry { key: "F5", description: "Refresh" },