`ac0080d`

feat: Ctrl+O fortress file browser, fix multi-cursor same-line edits

Authored by

espadonne 5 months ago

SHA: ac0080dd33b90aaee8a6ff15d3c611822a1c9a0b
Parents: c958e31
Tree: 60121a8

2 changed files

Status	File	+	-
M	`src/editor/state.rs`	379	77
M	`src/render/screen.rs`	177	0

src/editor/state.rsmodified

      Replace,
+ }
 +/// Entry in the fortress file explorer
 +#[derive(Debug, Clone, PartialEq)]
 +struct FortressEntry {
 +    /// File/directory name
 +    name: String,
 +    /// Full path
 +    path: PathBuf,
 +    /// Is this a directory?
 +    is_dir: bool,
 +}
++
  /// Prompt state for quit confirmation
  #[derive(Debug, Clone, PartialEq)]
  enum PromptState {
          /// Regex mode
          regex_mode: bool,
      },
 +    /// Fortress mode - file explorer modal
 +    Fortress {
 +        /// Current directory being browsed
 +        current_path: PathBuf,
 +        /// Directory entries (directories first, then files)
 +        entries: Vec<FortressEntry>,
 +        /// Currently selected index
 +        selected_index: usize,
 +        /// Filter/search query
 +        filter: String,
 +        /// Scroll offset for long lists
 +        scroll_offset: usize,
 +    },
+ }
  /// Action to perform when text input is complete
                  self.screen.render_references_panel(locations, selected_index, query, &self.workspace.root)?;
+             }
 +            // Render fortress modal if active
 +            if let PromptState::Fortress {
 +                ref current_path,
 +                ref entries,
 +                selected_index,
 +                ref filter,
 +                scroll_offset,
 +            } = self.prompt {
 +                // Convert entries to tuple format for render function
 +                let entries_tuples: Vec<(String, PathBuf, bool)> = entries
 +                    .iter()
 +                    .map(|e| (e.name.clone(), e.path.clone(), e.is_dir))
 +                    .collect();
 +                self.screen.render_fortress_modal(
 +                    current_path,
 +                    &entries_tuples,
 +                    selected_index,
 +                    filter,
 +                    scroll_offset,
 +                )?;
 +                return Ok(()); // Modal handles cursor
 +            }
++
              // Render find/replace bar if active (replaces status bar)
              if let PromptState::FindReplace {
                  ref find_query,
              // Find previous: Shift+F3
              (Key::F(3), Modifiers { shift: true, .. }) => self.find_prev(),
 +            // === File operations ===
 +            // Open file browser (Fortress mode): Ctrl+O
 +            (Key::Char('o'), Modifiers { ctrl: true, .. }) => self.open_fortress(),
++
              // === Editing ===
              (Key::Char(c), Modifiers { ctrl: false, alt: false, .. }) => {
                  self.insert_char(*c);
              return;
+         }
 -        // Multi-cursor: process from bottom-right to top-left to maintain correct positions.
 -        // This ordering ensures that when we insert text, we don't affect the character indices
 -        // of cursors we haven't processed yet (they're all earlier in the document).
 -        //
 -        // Collect original cursor positions with indices
 -        let mut positions: Vec<(usize, usize, usize)> = self.cursors().all()
 +        // Multi-cursor: compute absolute character indices FIRST from a frozen view of the buffer.
 +        // Then sort by ASCENDING char index, apply edits from start to end,
 +        // and track cumulative offset to adjust subsequent positions.
++
 +        // Step 1: Compute char indices for all cursors from current buffer state
 +        let mut cursor_char_indices: Vec<(usize, usize)> = self.cursors().all()
              .iter()
              .enumerate()
 -            .map(|(i, c)| (i, c.line, c.col))
 +            .map(|(i, c)| {
 +                let char_idx = self.buffer().line_col_to_char(c.line, c.col);
 +                (i, char_idx)
 +            })
              .collect();
 -        // Sort by position, bottom-right first (highest line, then highest col)
 -        positions.sort_by(|a, b| {
 -            match b.1.cmp(&a.1) {
 -                std::cmp::Ordering::Equal => b.2.cmp(&a.2),
 -                ord => ord,
 -            }
 -        });
 +        // Step 2: Sort by ASCENDING char index (process from start of document)
 +        cursor_char_indices.sort_by(|a, b| a.1.cmp(&b.1));
          // Record all cursor positions before the operation
          let cursors_before = self.all_cursor_positions();
          self.history_mut().begin_group();
          self.history_mut().set_cursors_before(cursors_before);
 -        // Count newlines and chars for position updates
 -        let newlines = text.chars().filter(|&c| c == '\n').count();
          let text_char_count = text.chars().count();
 -        let chars_after_last_newline = if let Some(pos) = text.rfind('\n') {
 -            text[pos + 1..].chars().count()
 -        } else {
 -            text_char_count
 -        };
+-
          let cursor_before = self.cursor_pos();
 -        // Process each cursor using the ORIGINAL positions we captured.
 -        // Since we go bottom-right to top-left, insertions don't affect positions we'll use later.
 -        for (cursor_idx, orig_line, orig_col) in positions.iter().copied() {
 -            let idx = self.buffer().line_col_to_char(orig_line, orig_col);
 -            self.buffer_mut().insert(idx, text);
 -            self.history_mut().record_insert(idx, text.to_string(), cursor_before, cursor_before);
 +        // Step 3: Apply inserts from start to end, tracking cumulative offset
 +        let mut cumulative_offset: usize = 0;
 +        let mut new_positions: Vec<(usize, usize, usize)> = Vec::new(); // (cursor_idx, line, col)
 -            // Update this cursor's final position
 +        for (cursor_idx, original_char_idx) in cursor_char_indices {
 +            // Adjust position by cumulative offset from previous inserts
 +            let adjusted_char_idx = original_char_idx + cumulative_offset;
++
 +            self.buffer_mut().insert(adjusted_char_idx, text);
 +            self.history_mut().record_insert(adjusted_char_idx, text.to_string(), cursor_before, cursor_before);
++
 +            // New cursor position is right after the inserted text
 +            let new_char_idx = adjusted_char_idx + text_char_count;
 +            let (new_line, new_col) = self.buffer().char_to_line_col(new_char_idx);
 +            new_positions.push((cursor_idx, new_line, new_col));
++
 +            // Update cumulative offset for next cursor
 +            cumulative_offset += text_char_count;
 +        }
++
 +        // Step 4: Update all cursor positions at once
 +        for (cursor_idx, new_line, new_col) in new_positions {
              let cursor = &mut self.cursors_mut().all_mut()[cursor_idx];
 -            if newlines > 0 {
 -                cursor.line = orig_line + newlines;
 -                cursor.col = chars_after_last_newline;
 -            } else {
 -                cursor.line = orig_line;
 -                cursor.col = orig_col + text_char_count;
 -            }
 -            cursor.desired_col = cursor.col;
 +            cursor.line = new_line;
 +            cursor.col = new_col;
 +            cursor.desired_col = new_col;
+         }
          // Record all cursor positions after the operation
      /// Delete backward at all cursor positions (multi-cursor)
      fn delete_backward_multi(&mut self) {
 -        // Collect cursor positions, process from bottom to top
 -        let mut positions: Vec<(usize, usize, usize)> = self.cursors().all()
 +        // Multi-cursor: compute absolute character indices FIRST from a frozen view of the buffer.
 +        // Sort by ASCENDING, process start to end, track cumulative offset.
++
 +        // Step 1: Compute char indices for all cursors from current buffer state
 +        let mut cursor_char_indices: Vec<(usize, usize)> = self.cursors().all()
              .iter()
              .enumerate()
 -            .map(|(i, c)| (i, c.line, c.col))
 +            .map(|(i, c)| {
 +                let char_idx = self.buffer().line_col_to_char(c.line, c.col);
 +                (i, char_idx)
 +            })
              .collect();
 -        // Sort by position, bottom-right first
 -        positions.sort_by(|a, b| {
 -            match b.1.cmp(&a.1) {
 -                std::cmp::Ordering::Equal => b.2.cmp(&a.2),
 -                ord => ord,
 -            }
 -        });
 +        // Step 2: Sort by ASCENDING char index (process from start of document)
 +        cursor_char_indices.sort_by(|a, b| a.1.cmp(&b.1));
          // Record all cursor positions before the operation
          let cursors_before = self.all_cursor_positions();
          self.history_mut().set_cursors_before(cursors_before);
          let cursor_before = self.cursor_pos();
 -        for (cursor_idx, line, col) in positions {
 -            if col > 0 {
 -                let idx = self.buffer().line_col_to_char(line, col);
 -                let deleted = self.buffer().char_at(idx - 1).map(|c| c.to_string()).unwrap_or_default();
 -                self.buffer_mut().delete(idx - 1, idx);
 -                self.history_mut().record_delete(idx - 1, deleted, cursor_before, cursor_before);
 -                // Update cursor position
 -                let cursor = &mut self.cursors_mut().all_mut()[cursor_idx];
 -                cursor.col -= 1;
 -                cursor.desired_col = cursor.col;
 +        // Step 3: Apply deletes from start to end, tracking cumulative offset
 +        let mut cumulative_offset: isize = 0;
 +        let mut new_positions: Vec<(usize, usize, usize)> = Vec::new();
++
 +        for (cursor_idx, original_char_idx) in cursor_char_indices {
 +            if original_char_idx == 0 {
 +                // Can't delete backward from position 0, keep cursor where it is
 +                let cursor = &self.cursors().all()[cursor_idx];
 +                new_positions.push((cursor_idx, cursor.line, cursor.col));
 +                continue;
 +            }
++
 +            // Adjust position by cumulative offset from previous deletes
 +            let adjusted_char_idx = (original_char_idx as isize + cumulative_offset) as usize;
++
 +            if adjusted_char_idx > 0 {
 +                let deleted = self.buffer().char_at(adjusted_char_idx - 1).map(|c| c.to_string()).unwrap_or_default();
 +                self.buffer_mut().delete(adjusted_char_idx - 1, adjusted_char_idx);
 +                self.history_mut().record_delete(adjusted_char_idx - 1, deleted, cursor_before, cursor_before);
++
 +                // New cursor position is at the delete point
 +                let new_char_idx = adjusted_char_idx - 1;
 +                let (new_line, new_col) = self.buffer().char_to_line_col(new_char_idx);
 +                new_positions.push((cursor_idx, new_line, new_col));
++
 +                // Update cumulative offset (we deleted 1 char, so offset decreases by 1)
 +                cumulative_offset -= 1;
+             }
 -            // Note: For simplicity, we don't handle joining lines in multi-cursor mode
 +        }
++
 +        // Step 4: Update all cursor positions at once
 +        for (cursor_idx, new_line, new_col) in new_positions {
 +            let cursor = &mut self.cursors_mut().all_mut()[cursor_idx];
 +            cursor.line = new_line;
 +            cursor.col = new_col;
 +            cursor.desired_col = new_col;
+         }
          // Record all cursor positions after the operation
      /// Delete forward at all cursor positions (multi-cursor)
      fn delete_forward_multi(&mut self) {
 -        // Collect cursor positions, process from bottom to top
 -        let mut positions: Vec<(usize, usize, usize)> = self.cursors().all()
 +        // Multi-cursor: compute absolute character indices FIRST from a frozen view of the buffer.
 +        // Sort by ASCENDING, process start to end, track cumulative offset.
++
 +        let total_chars = self.buffer().char_count();
++
 +        // Step 1: Compute char indices for all cursors from current buffer state
 +        let mut cursor_char_indices: Vec<(usize, usize)> = self.cursors().all()
              .iter()
              .enumerate()
 -            .map(|(i, c)| (i, c.line, c.col))
 +            .map(|(i, c)| {
 +                let char_idx = self.buffer().line_col_to_char(c.line, c.col);
 +                (i, char_idx)
 +            })
              .collect();
 -        // Sort by position, bottom-right first
 -        positions.sort_by(|a, b| {
 -            match b.1.cmp(&a.1) {
 -                std::cmp::Ordering::Equal => b.2.cmp(&a.2),
 -                ord => ord,
 -            }
 -        });
 +        // Step 2: Sort by ASCENDING char index (process from start of document)
 +        cursor_char_indices.sort_by(|a, b| a.1.cmp(&b.1));
          // Record all cursor positions before the operation
          let cursors_before = self.all_cursor_positions();
          self.history_mut().set_cursors_before(cursors_before);
          let cursor_before = self.cursor_pos();
 -        for (_cursor_idx, line, col) in positions {
 -            let line_len = self.buffer().line_len(line);
 -            if col < line_len {
 -                let idx = self.buffer().line_col_to_char(line, col);
 -                let deleted = self.buffer().char_at(idx).map(|c| c.to_string()).unwrap_or_default();
 -                self.buffer_mut().delete(idx, idx + 1);
 -                self.history_mut().record_delete(idx, deleted, cursor_before, cursor_before);
 -                // Cursor position doesn't change for delete forward
++
 +        // Step 3: Apply deletes from start to end, tracking cumulative offset
 +        let mut cumulative_offset: isize = 0;
 +        let mut new_positions: Vec<(usize, usize, usize)> = Vec::new();
++
 +        for (cursor_idx, original_char_idx) in cursor_char_indices {
 +            // Adjust position by cumulative offset from previous deletes
 +            let adjusted_char_idx = (original_char_idx as isize + cumulative_offset) as usize;
 +            let current_total = (total_chars as isize + cumulative_offset) as usize;
++
 +            if adjusted_char_idx < current_total {
 +                let deleted = self.buffer().char_at(adjusted_char_idx).map(|c| c.to_string()).unwrap_or_default();
 +                // Don't delete newlines in multi-cursor mode for simplicity
 +                if deleted != "\n" {
 +                    self.buffer_mut().delete(adjusted_char_idx, adjusted_char_idx + 1);
 +                    self.history_mut().record_delete(adjusted_char_idx, deleted, cursor_before, cursor_before);
 +                    cumulative_offset -= 1;
 +                }
+             }
 -            // Note: For simplicity, we don't handle joining lines in multi-cursor mode
++
 +            // Cursor position: convert from adjusted char index (cursor doesn't move for delete forward)
 +            let (new_line, new_col) = self.buffer().char_to_line_col(adjusted_char_idx.min(self.buffer().char_count()));
 +            new_positions.push((cursor_idx, new_line, new_col));
 +        }
++
 +        // Step 4: Update all cursor positions at once
 +        for (cursor_idx, new_line, new_col) in new_positions {
 +            let cursor = &mut self.cursors_mut().all_mut()[cursor_idx];
 +            cursor.line = new_line;
 +            cursor.col = new_col;
 +            cursor.desired_col = new_col;
+         }
          // Record all cursor positions after the operation
                      _ => {}
+                 }
+             }
 +            PromptState::Fortress {
 +                ref current_path,
 +                ref entries,
 +                ref mut selected_index,
 +                ref mut filter,
 +                ref mut scroll_offset,
 +            } => {
 +                // Filter entries based on query
 +                let filtered: Vec<(usize, &FortressEntry)> = if filter.is_empty() {
 +                    entries.iter().enumerate().collect()
 +                } else {
 +                    let f = filter.to_lowercase();
 +                    entries.iter().enumerate()
 +                        .filter(|(_, e)| e.name.to_lowercase().contains(&f))
 +                        .collect()
 +                };
++
 +                match key {
 +                    Key::Enter => {
 +                        // Open selected entry
 +                        if let Some((orig_idx, _entry)) = filtered.get(*selected_index) {
 +                            let entry = entries[*orig_idx].clone();
 +                            if entry.is_dir {
 +                                // Navigate into directory
 +                                self.fortress_navigate_to(&entry.path);
 +                            } else {
 +                                // Open the file
 +                                self.prompt = PromptState::None;
 +                                self.fortress_open_file(&entry.path);
 +                            }
 +                        }
 +                    }
 +                    Key::Escape => {
 +                        self.prompt = PromptState::None;
 +                        self.message = None;
 +                    }
 +                    Key::Backspace if filter.is_empty() => {
 +                        // Go up one directory when filter is empty
 +                        if let Some(parent) = current_path.parent() {
 +                            let parent = parent.to_path_buf();
 +                            self.fortress_navigate_to(&parent);
 +                        }
 +                    }
 +                    Key::Backspace => {
 +                        filter.pop();
 +                        *selected_index = 0;
 +                        *scroll_offset = 0;
 +                    }
 +                    Key::Up => {
 +                        if *selected_index > 0 {
 +                            *selected_index -= 1;
 +                            // Adjust scroll
 +                            if *selected_index < *scroll_offset {
 +                                *scroll_offset = *selected_index;
 +                            }
 +                        }
 +                    }
 +                    Key::Down => {
 +                        if *selected_index + 1 < filtered.len() {
 +                            *selected_index += 1;
 +                        }
 +                    }
 +                    Key::Left => {
 +                        // Go up one directory
 +                        if let Some(parent) = current_path.parent() {
 +                            let parent = parent.to_path_buf();
 +                            self.fortress_navigate_to(&parent);
 +                        }
 +                    }
 +                    Key::Right => {
 +                        // Enter selected directory (same as Enter for dirs)
 +                        if let Some((orig_idx, _)) = filtered.get(*selected_index) {
 +                            let entry = entries[*orig_idx].clone();
 +                            if entry.is_dir {
 +                                self.fortress_navigate_to(&entry.path);
 +                            }
 +                        }
 +                    }
 +                    Key::PageUp => {
 +                        *selected_index = selected_index.saturating_sub(10);
 +                        *scroll_offset = scroll_offset.saturating_sub(10);
 +                    }
 +                    Key::PageDown => {
 +                        let max = filtered.len().saturating_sub(1);
 +                        *selected_index = (*selected_index + 10).min(max);
 +                    }
 +                    Key::Home => {
 +                        *selected_index = 0;
 +                        *scroll_offset = 0;
 +                    }
 +                    Key::End => {
 +                        if !filtered.is_empty() {
 +                            *selected_index = filtered.len() - 1;
 +                        }
 +                    }
 +                    Key::Char(c) => {
 +                        filter.push(c);
 +                        *selected_index = 0;
 +                        *scroll_offset = 0;
 +                    }
 +                    _ => {}
 +                }
 +            }
              PromptState::None => {}
+         }
          Ok(())
              self.update_search_matches();
+         }
+     }
++
 +    // === Fortress mode (file browser) ===
++
 +    /// Open fortress mode file browser
 +    fn open_fortress(&mut self) {
 +        // Start at current file's directory, or workspace root
 +        let start_path = if let Some(path) = self.current_file_path() {
 +            if let Some(parent) = path.parent() {
 +                parent.to_path_buf()
 +            } else {
 +                self.workspace.root.clone()
 +            }
 +        } else {
 +            self.workspace.root.clone()
 +        };
++
 +        let entries = self.read_directory(&start_path);
 +        self.prompt = PromptState::Fortress {
 +            current_path: start_path,
 +            entries,
 +            selected_index: 0,
 +            filter: String::new(),
 +            scroll_offset: 0,
 +        };
 +    }
++
 +    /// Read directory contents and return sorted entries (dirs first, then files)
 +    fn read_directory(&self, path: &Path) -> Vec<FortressEntry> {
 +        let mut entries = Vec::new();
++
 +        // Add parent directory entry if not at root
 +        if path.parent().is_some() {
 +            entries.push(FortressEntry {
 +                name: "..".to_string(),
 +                path: path.parent().unwrap().to_path_buf(),
 +                is_dir: true,
 +            });
 +        }
++
 +        if let Ok(read_dir) = std::fs::read_dir(path) {
 +            let mut dirs = Vec::new();
 +            let mut files = Vec::new();
++
 +            for entry in read_dir.flatten() {
 +                let entry_path = entry.path();
 +                let name = entry.file_name().to_string_lossy().to_string();
++
 +                // Skip hidden files (starting with .)
 +                if name.starts_with('.') {
 +                    continue;
 +                }
++
 +                let is_dir = entry_path.is_dir();
 +                let fortress_entry = FortressEntry {
 +                    name,
 +                    path: entry_path,
 +                    is_dir,
 +                };
++
 +                if is_dir {
 +                    dirs.push(fortress_entry);
 +                } else {
 +                    files.push(fortress_entry);
 +                }
 +            }
++
 +            // Sort alphabetically (case-insensitive)
 +            dirs.sort_by(|a, b| a.name.to_lowercase().cmp(&b.name.to_lowercase()));
 +            files.sort_by(|a, b| a.name.to_lowercase().cmp(&b.name.to_lowercase()));
++
 +            // Directories first, then files
 +            entries.extend(dirs);
 +            entries.extend(files);
 +        }
++
 +        entries
 +    }
++
 +    /// Navigate to a new directory in fortress mode
 +    fn fortress_navigate_to(&mut self, path: &Path) {
 +        let entries = self.read_directory(path);
 +        self.prompt = PromptState::Fortress {
 +            current_path: path.to_path_buf(),
 +            entries,
 +            selected_index: 0,
 +            filter: String::new(),
 +            scroll_offset: 0,
 +        };
 +    }
++
 +    /// Open a file from fortress mode
 +    fn fortress_open_file(&mut self, path: &Path) {
 +        // Open file in current pane by reusing workspace method
 +        if let Err(e) = self.workspace.open_file(path) {
 +            self.message = Some(format!("Failed to open file: {}", e));
 +        } else {
 +            // Sync with LSP
 +            self.sync_document_to_lsp();
 +        }
 +    }
+ }
  impl Drop for Editor {

src/render/screen.rsmodified

          Ok(())
+     }
 +    /// Render the Fortress file browser modal
 +    pub fn render_fortress_modal(
 +        &mut self,
 +        current_path: &std::path::Path,
 +        entries: &[(String, std::path::PathBuf, bool)], // (name, path, is_dir)
 +        selected_index: usize,
 +        filter: &str,
 +        scroll_offset: usize,
 +    ) -> Result<()> {
 +        let (width, height) = (self.cols as usize, self.rows as usize);
++
 +        // Modal dimensions - centered
 +        let modal_width = 60.min(width - 4);
 +        let modal_height = 20.min(height - 4);
 +        let start_col = (width.saturating_sub(modal_width)) / 2;
 +        let start_row = (height.saturating_sub(modal_height)) / 2;
++
 +        // Filter entries based on query
 +        let filtered: Vec<(usize, &(String, std::path::PathBuf, bool))> = if filter.is_empty() {
 +            entries.iter().enumerate().collect()
 +        } else {
 +            let f = filter.to_lowercase();
 +            entries.iter().enumerate()
 +                .filter(|(_, (name, _, _))| name.to_lowercase().contains(&f))
 +                .collect()
 +        };
++
 +        // Colors
 +        let bg = Color::AnsiValue(235);
 +        let border_color = Color::AnsiValue(244);
 +        let header_color = Color::Cyan;
 +        let dir_color = Color::Blue;
 +        let file_color = Color::AnsiValue(252);
 +        let selected_bg = Color::AnsiValue(240);
 +        let input_bg = Color::AnsiValue(238);
++
 +        // Draw top border with title
 +        let path_str = current_path.to_string_lossy();
 +        let max_path_len = modal_width - 6;
 +        let display_path = if path_str.len() > max_path_len {
 +            format!("...{}", &path_str[path_str.len().saturating_sub(max_path_len - 3)..])
 +        } else {
 +            path_str.to_string()
 +        };
 +        let title = format!(" {} ", display_path);
 +        execute!(
 +            self.stdout,
 +            MoveTo(start_col as u16, start_row as u16),
 +            SetBackgroundColor(bg),
 +            SetForegroundColor(border_color),
 +            Print("┌"),
 +            SetForegroundColor(header_color),
 +            Print(&title),
 +            SetForegroundColor(border_color),
 +            Print(format!("{:─<width$}┐", "", width = modal_width.saturating_sub(title.len() + 2))),
 +            ResetColor,
 +        )?;
++
 +        // Draw filter input row
 +        execute!(
 +            self.stdout,
 +            MoveTo(start_col as u16, (start_row + 1) as u16),
 +            SetBackgroundColor(bg),
 +            SetForegroundColor(border_color),
 +            Print("│ "),
 +            SetForegroundColor(Color::AnsiValue(248)),
 +            Print("Filter: "),
 +            SetBackgroundColor(input_bg),
 +            SetForegroundColor(Color::White),
 +            Print(format!("{:<width$}", filter, width = modal_width.saturating_sub(12))),
 +            SetBackgroundColor(bg),
 +            SetForegroundColor(border_color),
 +            Print("│"),
 +            ResetColor,
 +        )?;
++
 +        // Draw separator
 +        execute!(
 +            self.stdout,
 +            MoveTo(start_col as u16, (start_row + 2) as u16),
 +            SetBackgroundColor(bg),
 +            SetForegroundColor(border_color),
 +            Print(format!("├{:─<width$}┤", "", width = modal_width.saturating_sub(2))),
 +            ResetColor,
 +        )?;
++
 +        // Calculate visible range
 +        let visible_rows = modal_height.saturating_sub(5); // Account for borders, title, filter, help
++
 +        // Adjust scroll offset so selected item is visible
 +        let scroll = if selected_index < scroll_offset {
 +            selected_index
 +        } else if selected_index >= scroll_offset + visible_rows {
 +            selected_index - visible_rows + 1
 +        } else {
 +            scroll_offset
 +        };
++
 +        // Draw file/directory entries
 +        for (display_idx, (_orig_idx, (name, _, is_dir))) in filtered.iter().enumerate().skip(scroll).take(visible_rows) {
 +            let row = (start_row + 3 + display_idx - scroll) as u16;
 +            let is_selected = display_idx == selected_index;
++
 +            let item_bg = if is_selected { selected_bg } else { bg };
 +            let name_color = if *is_dir { dir_color } else { file_color };
 +            let icon = if *is_dir { "[d] " } else { "    " };
++
 +            // Truncate name if needed
 +            let max_name_len = modal_width.saturating_sub(6);
 +            let display_name = if name.len() > max_name_len {
 +                format!("{}...", &name[..max_name_len - 3])
 +            } else {
 +                name.clone()
 +            };
++
 +            execute!(
 +                self.stdout,
 +                MoveTo(start_col as u16, row),
 +                SetBackgroundColor(item_bg),
 +                SetForegroundColor(border_color),
 +                Print("│ "),
 +                Print(icon),
 +                SetForegroundColor(name_color),
 +                Print(format!("{:<width$}", display_name, width = modal_width.saturating_sub(6))),
 +                SetForegroundColor(border_color),
 +                Print("│"),
 +                ResetColor,
 +            )?;
 +        }
++
 +        // Fill remaining rows with empty space
 +        let items_drawn = filtered.len().saturating_sub(scroll).min(visible_rows);
 +        for i in items_drawn..visible_rows {
 +            let row = (start_row + 3 + i) as u16;
 +            execute!(
 +                self.stdout,
 +                MoveTo(start_col as u16, row),
 +                SetBackgroundColor(bg),
 +                SetForegroundColor(border_color),
 +                Print(format!("│{:width$}│", "", width = modal_width.saturating_sub(2))),
 +                ResetColor,
 +            )?;
 +        }
++
 +        // Draw help text row
 +        let help_row = (start_row + 3 + visible_rows) as u16;
 +        let help_text = "←:up  →/Enter:open  ↑↓:nav  Esc:close";
 +        execute!(
 +            self.stdout,
 +            MoveTo(start_col as u16, help_row),
 +            SetBackgroundColor(bg),
 +            SetForegroundColor(border_color),
 +            Print("├"),
 +            SetForegroundColor(Color::AnsiValue(243)),
 +            Print(format!(" {:<width$}", help_text, width = modal_width.saturating_sub(3))),
 +            SetForegroundColor(border_color),
 +            Print("┤"),
 +            ResetColor,
 +        )?;
++
 +        // Draw bottom border
 +        execute!(
 +            self.stdout,
 +            MoveTo(start_col as u16, help_row + 1),
 +            SetBackgroundColor(bg),
 +            SetForegroundColor(border_color),
 +            Print(format!("└{:─<width$}┘", "", width = modal_width.saturating_sub(2))),
 +            ResetColor,
 +        )?;
++
 +        // Hide cursor when in fortress modal
 +        execute!(self.stdout, Hide)?;
++
 +        self.stdout.flush()?;
 +        Ok(())
 +    }
++
      /// Render the LSP references panel (sidebar style)
      pub fn render_references_panel(
          &mut self,