gardesk/garfield / f8dfd93

+        // 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;

+        }

+

+        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()

+            .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 => {}

+    /// Get the focused index.

+    pub fn focused_index(&self) -> usize {

+        self.current_column.selected

+    }

+

+use crate::ui::tab::RenameState;

+    /// Get the focused index.

+    pub fn focused_index(&self) -> usize {

+        self.focused

+    }

+

+    pub fn render(&self, renderer: &Renderer, rename_state: Option<&RenameState>) -> anyhow::Result<()> {

+            let is_renaming = rename_state.map_or(false, |s| s.index == i);

+

+            if is_renaming {

+                // Render rename text field

+                if let Some(state) = rename_state {

+                    self.render_rename_field(renderer, text_rect, state)?;

+                }

+                // File name (truncated)

+                let name_color = if is_selected {

+                    theme.selection_foreground

+                } else if entry.hidden {

+                    theme.item_foreground.with_alpha(0.5)

+                } else {

+                    theme.item_foreground

+                };

+

+                let name_font_size = self.icon_size.font_size();

+                let name_style = TextStyle::new()

+                    .font_family(&theme.font_family)

+                    .font_size(name_font_size)

+                    .color(name_color);

+

+                // Use Pango CENTER alignment for proper text centering (like Dolphin/Nautilus)

+                let name_style = name_style.clone()

+                    .align(TextAlign::Center)

+                    .ellipsize(true)

+                    .max_width((cell.width - 8) as i32);

+

+                // Add "@" suffix for symlinks

+                let display_name = if entry.is_symlink {

+                    format!("{}@", entry.name)

+                } else {

+                    entry.name.clone()

+                };

+                renderer.text_in_rect(&display_name, text_rect, &name_style)?;

+            }

+    /// 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(())

+    }

+

+use crate::ui::tab::RenameState;

+    /// Get the focused index.

+    pub fn focused_index(&self) -> usize {

+        self.focused

+    }

+

+    pub fn render(&self, renderer: &Renderer, rename_state: Option<&RenameState>) -> anyhow::Result<()> {

+            let is_renaming = rename_state.map_or(false, |s| s.index == actual_index);

+

+            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();

+                        // Truncate long targets

+                        let target_display = if target_str.len() > 30 {

+                            format!("...{}", &target_str[target_str.len()-27..])

+                        } else {

+                            target_str.to_string()

+                        };

+                        format!("{}{} -> {}", icon, entry.name, target_display)

+                        format!("{}{}", icon, entry.name)

+                    }

+                };

+                renderer.text_in_rect(&display_name, name_rect, &name_style)?;

+            }

+    /// 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(())

+    }

+

+pub use tab::{RenameState, Tab, ViewMode};

+use crate::core::{read_directory, rename_path, sort_entries, FileEntry, History, SortDirection, SortOrder};

+use gartk_core::{Key, Modifiers, Point, Rect};

+/// 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>,

+}

+

+    /// Active rename operation (if any).

+    renaming: Option<RenameState>,

+            renaming: None,

+    // === 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(),

+        }

+    }

+

+            ViewMode::List => self.list_view.render(renderer, self.renaming.as_ref()),

+            ViewMode::Grid => self.grid_view.render(renderer, self.renaming.as_ref()),

+

+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;

+        }

+    }

+}