`f8dfd93`

ui: add inline rename (F2) with text field overlay

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

SHA: f8dfd93be5ee381de6f180feffa0bfb7968291c0
Parents: c649f9a
Tree: 96ded0c

6 changed files

Status	File	+	-
M	`garfield/src/app.rs`	61	6
M	`garfield/src/ui/column_view.rs`	5	0
M	`garfield/src/ui/grid_view.rs`	84	28
M	`garfield/src/ui/list_view.rs`	116	17
M	`garfield/src/ui/mod.rs`	1	1
M	`garfield/src/ui/tab.rs`	210	4

garfield/src/app.rsmodified

+             }
+         }
 +        // Handle rename input
 +        if self.is_renaming() {
 +            match key {
 +                Key::Escape => {
 +                    self.cancel_rename();
 +                    return;
 +                }
 +                Key::Return => {
 +                    self.confirm_rename();
 +                    return;
 +                }
 +                _ => {
 +                    // Route other keys to rename handler
 +                    if let Some(pane) = self.focused_pane_mut() {
 +                        if let Some(tab) = pane.active_tab_mut() {
 +                            if tab.handle_rename_key(key) {
 +                                return;
 +                            }
 +                        }
 +                    }
 +                }
 +            }
 +            return;
 +        }
++
          // Alt+Arrow for history navigation
          if modifiers.alt {
              match key {
      /// 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()
 +        if let Some(pane) = self.focused_pane_mut() {
 +            if let Some(tab) = pane.active_tab_mut() {
 +                tab.start_rename();
 +            }
 +        }
 +    }
++
 +    /// Check if rename is in progress.
 +    fn is_renaming(&self) -> bool {
 +        self.focused_pane()
              .and_then(|p| p.active_tab())
 -            .and_then(|t| t.selected_entry())
 -        {
 -            eprintln!("Rename requested for: {}", entry.name);
 +            .map_or(false, |t| t.is_renaming())
 +    }
++
 +    /// Cancel rename operation.
 +    fn cancel_rename(&mut self) {
 +        if let Some(pane) = self.focused_pane_mut() {
 +            if let Some(tab) = pane.active_tab_mut() {
 +                tab.cancel_rename();
 +            }
 +        }
 +    }
++
 +    /// Confirm rename operation.
 +    fn confirm_rename(&mut self) {
 +        let result = self.focused_pane_mut()
 +            .and_then(|p| p.active_tab_mut())
 +            .map(|t| t.confirm_rename());
++
 +        match result {
 +            Some(Ok(new_name)) => {
 +                self.status_bar.set_status_message(format!("Renamed to '{}'", new_name));
 +            }
 +            Some(Err(msg)) => {
 +                self.status_bar.set_status_message(format!("Rename failed: {}", msg));
 +            }
 +            None => {}
+         }
+     }

garfield/src/ui/column_view.rsmodified

          visible.get(self.current_column.selected).copied()
+     }
 +    /// Get the focused index.
 +    pub fn focused_index(&self) -> usize {
 +        self.current_column.selected
 +    }
++
      /// Get all selected entries.
      pub fn selected_entries(&self) -> Vec<&FileEntry> {
          let visible = self.visible_entries();

garfield/src/ui/grid_view.rsmodified

  //! Grid/icon view for displaying directory contents.
  use crate::core::{EntryType, FileEntry, SortDirection, SortOrder};
 +use crate::ui::tab::RenameState;
  use gartk_core::{Color, Modifiers, Point, Rect};
  use gartk_render::{Renderer, TextAlign, TextStyle};
  use std::collections::HashSet;
          visible.get(self.focused).copied()
+     }
 +    /// Get the focused index.
 +    pub fn focused_index(&self) -> usize {
 +        self.focused
 +    }
++
      /// Get all selected entries.
      pub fn selected_entries(&self) -> Vec<&FileEntry> {
          let visible = self.visible_entries();
+     }
      /// Render the grid view.
 -    pub fn render(&self, renderer: &Renderer) -> anyhow::Result<()> {
 +    pub fn render(&self, renderer: &Renderer, rename_state: Option<&RenameState>) -> anyhow::Result<()> {
          let theme = renderer.theme();
          let visible = self.visible_entries();
          let visible_rows = self.visible_rows();
              let is_selected = self.selected.contains(&i);
              let is_focused = i == self.focused;
              let is_hovered = self.hovered == Some(i);
 +            let is_renaming = rename_state.map_or(false, |s| s.index == i);
              // Cell background
              if is_selected {
              let icon_center_y = cell.y + 10 + (icon_font_size / 2.0) as i32;
              renderer.text_centered(icon, Point::new(icon_center_x, icon_center_y), &icon_style)?;
 +            // Rectangle for the text area below the icon
 +            let icon_size = self.icon_size.icon_size();
 +            let text_rect = Rect::new(
 +                cell.x + 4,
 +                cell.y + icon_size as i32 + 8,
 +                cell.width - 8,
 +                cell.height - icon_size - 12,
 +            );
++
 +            if is_renaming {
 +                // Render rename text field
 +                if let Some(state) = rename_state {
 +                    self.render_rename_field(renderer, text_rect, state)?;
 +                }
 +            } else {
                  // File name (truncated)
                  let name_color = if is_selected {
                      theme.selection_foreground
                      .ellipsize(true)
                      .max_width((cell.width - 8) as i32);
 -            // Rectangle for the text area below the icon
 -            let icon_size = self.icon_size.icon_size();
 -            let text_rect = Rect::new(
 -                cell.x + 4,
 -                cell.y + icon_size as i32 + 8,
 -                cell.width - 8,
 -                cell.height - icon_size - 12,
 -            );
                  // Add "@" suffix for symlinks
                  let display_name = if entry.is_symlink {
                      format!("{}@", entry.name)
                  };
                  renderer.text_in_rect(&display_name, text_rect, &name_style)?;
+             }
 +        }
          // Draw rubber band selection rectangle
          if let Some(band) = self.rubber_band_rect() {
          Ok(())
+     }
 +    /// Render the inline rename text field.
 +    fn render_rename_field(&self, renderer: &Renderer, rect: Rect, state: &RenameState) -> anyhow::Result<()> {
 +        let theme = renderer.theme();
++
 +        // Background for text field
 +        let field_rect = Rect::new(rect.x, rect.y, rect.width, 20);
 +        renderer.fill_rounded_rect(field_rect, 2.0, theme.background)?;
 +        renderer.stroke_rounded_rect(field_rect, 2.0, theme.selection_background, 1.0)?;
++
 +        // Text style
 +        let text_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(self.icon_size.font_size())
 +            .color(theme.foreground);
++
 +        // Draw the text (centered)
 +        let text_width = renderer.measure_text(&state.text, &text_style)?.width;
 +        let text_x = field_rect.x + (field_rect.width as i32 - text_width as i32) / 2;
 +        let text_y = field_rect.y + 2;
 +        renderer.text(&state.text, text_x as f64, text_y as f64, &text_style)?;
++
 +        // Draw cursor
 +        let cursor_x = if state.cursor == 0 {
 +            text_x as f64
 +        } else {
 +            let prefix = &state.text[..state.cursor];
 +            let prefix_width = renderer.measure_text(prefix, &text_style)?.width;
 +            text_x as f64 + prefix_width as f64
 +        };
 +        renderer.line(
 +            cursor_x,
 +            (field_rect.y + 2) as f64,
 +            cursor_x,
 +            (field_rect.y + field_rect.height as i32 - 2) as f64,
 +            theme.foreground,
 +            1.0,
 +        )?;
++
 +        Ok(())
 +    }
++
      /// Get placeholder icon for file extension.
      fn file_icon_for_extension(ext: Option<&str>) -> &'static str {
          match ext {

garfield/src/ui/list_view.rsmodified

  //! List view component for displaying directory contents.
  use crate::core::{EntryType, FileEntry, SortDirection, SortOrder};
 +use crate::ui::tab::RenameState;
  use gartk_core::{Color, Modifiers, Point, Rect};
  use gartk_render::{Renderer, TextStyle};
  use std::collections::HashSet;
          visible.get(self.focused).copied()
+     }
 +    /// Get the focused index.
 +    pub fn focused_index(&self) -> usize {
 +        self.focused
 +    }
++
      /// Get all selected entries.
      pub fn selected_entries(&self) -> Vec<&FileEntry> {
          let visible = self.visible_entries();
+     }
      /// Render the list view.
 -    pub fn render(&self, renderer: &Renderer) -> anyhow::Result<()> {
 +    pub fn render(&self, renderer: &Renderer, rename_state: Option<&RenameState>) -> anyhow::Result<()> {
          let theme = renderer.theme();
          let visible = self.visible_entries();
          let visible_rows = self.visible_rows();
              let actual_index = self.scroll_offset + i;
              let is_selected = self.selected.contains(&actual_index);
              let is_focused = actual_index == self.focused;
 +            let is_renaming = rename_state.map_or(false, |s| s.index == actual_index);
              // Row background
              if is_selected {
                  EntryType::Symlink => "\u{1F517} ",
                  _ => "\u{1F4C4} ",
              };
++
 +            let name_rect =
 +                Rect::new(row_rect.x + 8, row_rect.y, self.column_widths[0], ROW_HEIGHT);
++
 +            if is_renaming {
 +                // Render rename text field
 +                if let Some(state) = rename_state {
 +                    self.render_rename_field(renderer, name_rect, state, &icon)?;
 +                }
 +            } else {
                  let display_name = if entry.is_symlink {
                      if let Some(target) = &entry.symlink_target {
                          let target_str = target.to_string_lossy();
                      format!("{}{}", icon, entry.name)
                  };
 -            let name_rect =
 -                Rect::new(row_rect.x + 8, row_rect.y, self.column_widths[0], ROW_HEIGHT);
                  renderer.text_in_rect(&display_name, name_rect, &name_style)?;
 +            }
              // Size
              let size_rect = Rect::new(
          Ok(())
+     }
 +    /// Render the inline rename text field.
 +    fn render_rename_field(&self, renderer: &Renderer, rect: Rect, state: &RenameState, icon: &str) -> anyhow::Result<()> {
 +        let theme = renderer.theme();
++
 +        // Background for text field (slightly lighter)
 +        let field_rect = Rect::new(
 +            rect.x + 24, // After icon
 +            rect.y + 2,
 +            rect.width.saturating_sub(28),
 +            rect.height - 4,
 +        );
 +        renderer.fill_rounded_rect(field_rect, 2.0, theme.background)?;
 +        renderer.stroke_rounded_rect(field_rect, 2.0, theme.selection_background, 1.0)?;
++
 +        // Draw icon
 +        let icon_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size)
 +            .color(theme.item_foreground);
 +        renderer.text(icon, (rect.x + 4) as f64, (rect.y + 4) as f64, &icon_style)?;
++
 +        // Text style for the editable text
 +        let text_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size)
 +            .color(theme.foreground);
++
 +        // Draw the text
 +        let text_x = field_rect.x + 4;
 +        let text_y = field_rect.y + 3;
 +        renderer.text(&state.text, text_x as f64, text_y as f64, &text_style)?;
++
 +        // Draw cursor
 +        let cursor_x = if state.cursor == 0 {
 +            text_x as f64
 +        } else {
 +            let prefix = &state.text[..state.cursor];
 +            let prefix_width = renderer.measure_text(prefix, &text_style)?.width;
 +            text_x as f64 + prefix_width as f64
 +        };
 +        renderer.line(
 +            cursor_x,
 +            (field_rect.y + 2) as f64,
 +            cursor_x,
 +            (field_rect.y + field_rect.height as i32 - 2) as f64,
 +            theme.foreground,
 +            1.0,
 +        )?;
++
 +        // Draw selection highlight if any
 +        if let Some(sel_start) = state.selection_start {
 +            let (from, to) = if sel_start < state.cursor {
 +                (sel_start, state.cursor)
 +            } else {
 +                (state.cursor, sel_start)
 +            };
++
 +            let from_x = if from == 0 {
 +                text_x as f64
 +            } else {
 +                let prefix = &state.text[..from];
 +                text_x as f64 + renderer.measure_text(prefix, &text_style)?.width as f64
 +            };
++
 +            let to_x = if to == 0 {
 +                text_x as f64
 +            } else {
 +                let prefix = &state.text[..to];
 +                text_x as f64 + renderer.measure_text(prefix, &text_style)?.width as f64
 +            };
++
 +            let sel_rect = Rect::new(
 +                from_x as i32,
 +                field_rect.y + 2,
 +                (to_x - from_x) as u32,
 +                field_rect.height - 4,
 +            );
 +            renderer.fill_rect(sel_rect, theme.selection_background.with_alpha(0.3))?;
 +        }
++
 +        Ok(())
 +    }
++
      /// Render column headers.
      fn render_header(&self, renderer: &Renderer) -> anyhow::Result<()> {
          let theme = renderer.theme();

garfield/src/ui/mod.rsmodified

  pub use pane::Pane;
  pub use sidebar::Sidebar;
  pub use status_bar::StatusBar;
 -pub use tab::{Tab, ViewMode};
 +pub use tab::{RenameState, Tab, ViewMode};
  pub use tab_bar::{TabBar, TabInfo, TAB_BAR_HEIGHT};
  pub use toolbar::{Toolbar, ToolbarAction, TOOLBAR_HEIGHT};

garfield/src/ui/tab.rsmodified

  //! Tab state for a single directory view.
 -use crate::core::{read_directory, sort_entries, FileEntry, History, SortDirection, SortOrder};
 +use crate::core::{read_directory, rename_path, sort_entries, FileEntry, History, SortDirection, SortOrder};
  use crate::ui::{ColumnClickResult, ColumnView, GridView, ListView};
 -use gartk_core::{Modifiers, Point, Rect};
 +use gartk_core::{Key, Modifiers, Point, Rect};
  use gartk_render::Renderer;
  use std::path::PathBuf;
 +/// State for inline rename operation.
 +#[derive(Debug, Clone)]
 +pub struct RenameState {
 +    /// Index of the entry being renamed.
 +    pub index: usize,
 +    /// Original filename (for cancel).
 +    pub original: String,
 +    /// Current edited text.
 +    pub text: String,
 +    /// Cursor position in the text.
 +    pub cursor: usize,
 +    /// Selection start (for text selection).
 +    pub selection_start: Option<usize>,
 +}
++
  /// View mode for displaying files.
  #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
  pub enum ViewMode {
      entries: Vec<FileEntry>,
      /// Tab bounds (for rendering).
      bounds: Rect,
 +    /// Active rename operation (if any).
 +    renaming: Option<RenameState>,
+ }
  impl Tab {
              sort_direction: SortDirection::Ascending,
              entries,
              bounds,
 +            renaming: None,
+         }
+     }
          self.grid_view.stop_drag();
+     }
 +    // === Rename operations ===
++
 +    /// Check if rename is in progress.
 +    pub fn is_renaming(&self) -> bool {
 +        self.renaming.is_some()
 +    }
++
 +    /// Get the current rename state.
 +    pub fn rename_state(&self) -> Option<&RenameState> {
 +        self.renaming.as_ref()
 +    }
++
 +    /// Start renaming the selected entry.
 +    pub fn start_rename(&mut self) {
 +        let (index, name) = match self.view_mode {
 +            ViewMode::List => {
 +                if let Some(entry) = self.list_view.selected_entry() {
 +                    (self.list_view.focused_index(), entry.name.clone())
 +                } else {
 +                    return;
 +                }
 +            }
 +            ViewMode::Grid => {
 +                if let Some(entry) = self.grid_view.selected_entry() {
 +                    (self.grid_view.focused_index(), entry.name.clone())
 +                } else {
 +                    return;
 +                }
 +            }
 +            ViewMode::Columns => {
 +                if let Some(entry) = self.column_view.selected_entry() {
 +                    (self.column_view.focused_index(), entry.name.clone())
 +                } else {
 +                    return;
 +                }
 +            }
 +        };
++
 +        // Select all text initially (cursor at end, selection from start)
 +        let len = name.len();
 +        self.renaming = Some(RenameState {
 +            index,
 +            original: name.clone(),
 +            text: name,
 +            cursor: len,
 +            selection_start: Some(0),
 +        });
 +    }
++
 +    /// Cancel rename operation.
 +    pub fn cancel_rename(&mut self) {
 +        self.renaming = None;
 +    }
++
 +    /// Confirm rename operation. Returns Ok(new_name) on success, Err(message) on failure.
 +    pub fn confirm_rename(&mut self) -> Result<String, String> {
 +        let state = match self.renaming.take() {
 +            Some(s) => s,
 +            None => return Err("No rename in progress".to_string()),
 +        };
++
 +        let new_name = state.text.trim();
++
 +        // Validate: non-empty and different from original
 +        if new_name.is_empty() {
 +            return Err("Name cannot be empty".to_string());
 +        }
++
 +        if new_name == state.original {
 +            // No change, just cancel silently
 +            return Ok(state.original);
 +        }
++
 +        // Validate: no path separators
 +        if new_name.contains('/') || new_name.contains('\\') {
 +            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(_) => {
 +                self.refresh();
 +                Ok(new_name.to_string())
 +            }
 +            Err(e) => Err(e.to_string()),
 +        }
 +    }
++
 +    /// Handle keyboard input during rename. Returns true if handled.
 +    pub fn handle_rename_key(&mut self, key: &Key) -> bool {
 +        let state = match self.renaming.as_mut() {
 +            Some(s) => s,
 +            None => return false,
 +        };
++
 +        match key {
 +            Key::Escape => {
 +                self.cancel_rename();
 +                true
 +            }
 +            Key::Return => {
 +                // Will be handled by caller to show result
 +                true
 +            }
 +            Key::Backspace => {
 +                if state.selection_start.is_some() {
 +                    // Delete selection
 +                    state.delete_selection();
 +                } else if state.cursor > 0 {
 +                    state.cursor -= 1;
 +                    state.text.remove(state.cursor);
 +                }
 +                true
 +            }
 +            Key::Delete => {
 +                if state.selection_start.is_some() {
 +                    state.delete_selection();
 +                } else if state.cursor < state.text.len() {
 +                    state.text.remove(state.cursor);
 +                }
 +                true
 +            }
 +            Key::Left => {
 +                state.selection_start = None;
 +                if state.cursor > 0 {
 +                    state.cursor -= 1;
 +                }
 +                true
 +            }
 +            Key::Right => {
 +                state.selection_start = None;
 +                if state.cursor < state.text.len() {
 +                    state.cursor += 1;
 +                }
 +                true
 +            }
 +            Key::Home => {
 +                state.selection_start = None;
 +                state.cursor = 0;
 +                true
 +            }
 +            Key::End => {
 +                state.selection_start = None;
 +                state.cursor = state.text.len();
 +                true
 +            }
 +            Key::Char(c) => {
 +                // Clear selection first
 +                if state.selection_start.is_some() {
 +                    state.delete_selection();
 +                }
 +                state.text.insert(state.cursor, *c);
 +                state.cursor += 1;
 +                true
 +            }
 +            _ => false,
 +        }
 +    }
++
 +    /// Get visible entries (helper for rename).
 +    fn visible_entries(&self) -> Vec<&FileEntry> {
 +        match self.view_mode {
 +            ViewMode::List => self.list_view.visible_entries(),
 +            ViewMode::Grid => self.grid_view.visible_entries(),
 +            ViewMode::Columns => self.column_view.visible_entries(),
 +        }
 +    }
++
      // === Rendering ===
      pub fn render(&self, renderer: &Renderer) -> anyhow::Result<()> {
          match self.view_mode {
 -            ViewMode::List => self.list_view.render(renderer),
 -            ViewMode::Grid => self.grid_view.render(renderer),
 +            ViewMode::List => self.list_view.render(renderer, self.renaming.as_ref()),
 +            ViewMode::Grid => self.grid_view.render(renderer, self.renaming.as_ref()),
              ViewMode::Columns => self.column_view.render(renderer),
+         }
+     }
+ }
++
 +impl RenameState {
 +    /// Delete selected text (if any).
 +    fn delete_selection(&mut self) {
 +        if let Some(start) = self.selection_start.take() {
 +            let (from, to) = if start < self.cursor {
 +                (start, self.cursor)
 +            } else {
 +                (self.cursor, start)
 +            };
 +            self.text.drain(from..to);
 +            self.cursor = from;
 +        }
 +    }
 +}