`d15d3c3`

ui: add paste conflict resolution and help modal scroll

- Add ConflictDialog with Replace/Skip/Keep Both/Cancel options
- Detect file conflicts before paste, show dialog with bell alert
- Handle conflicts: skip, replace existing, or auto-rename (Keep Both)
- Add scrollbar indicator to help modal
- Add scroll limit to prevent over-scrolling
- Add mouse wheel scroll support for help modal
- Add new keybinds to help: Bookmarks section, Shift+Up/Down, q to quit

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

SHA: d15d3c3d6243662339d419d6547cd9213535c8d4
Parents: bfdcd76
Tree: 13adcf0

4 changed files

Status	File	+	-
M	`garfield/src/app.rs`	221	1
M	`garfield/src/ui/dialog.rs`	293	0
M	`garfield/src/ui/help_modal.rs`	70	2
M	`garfield/src/ui/mod.rs`	1	1

garfield/src/app.rsmodified

      trash_files, restore_from_trash,
  };
  use garfield::ui::pane::SplitDirection;
 -use garfield::ui::{AddressBar, Breadcrumb, ConfirmDialog, DialogResult, HelpModal, Pane, ProgressDialog, Sidebar, StatusBar, TabBar, TabInfo, Toolbar, ToolbarAction, ViewMode, TAB_BAR_HEIGHT, TOOLBAR_HEIGHT};
 +use garfield::ui::{AddressBar, Breadcrumb, ConfirmDialog, ConflictAction, ConflictDialog, DialogResult, HelpModal, Pane, ProgressDialog, Sidebar, StatusBar, TabBar, TabInfo, Toolbar, ToolbarAction, ViewMode, TAB_BAR_HEIGHT, TOOLBAR_HEIGHT};
  use anyhow::Result;
  use gartk_core::{InputEvent, Key, MouseButton, Point, Rect, Theme};
  use gartk_render::{Renderer, Surface, TextStyle};
      clipboard: Clipboard,
      /// Confirmation dialog.
      confirm_dialog: ConfirmDialog,
 +    /// Conflict resolution dialog.
 +    conflict_dialog: ConflictDialog,
      /// Progress dialog for long operations.
      progress_dialog: ProgressDialog,
      /// Paths pending delete confirmation.
      pending_delete_paths: Vec<PathBuf>,
      /// Undo/redo stack for file operations.
      undo_stack: UndoStack,
 +    /// Pending paste operation with conflicts.
 +    pending_paste: Option<PendingPaste>,
 +}
++
 +/// State for a paste operation with conflicts.
 +struct PendingPaste {
 +    /// Files to paste.
 +    files: Vec<PathBuf>,
 +    /// Clipboard operation type.
 +    operation: ClipboardOperation,
 +    /// Destination directory.
 +    dest_dir: PathBuf,
 +    /// Files that conflict (exist in destination).
 +    conflicts: Vec<PathBuf>,
 +    /// Current conflict index being resolved.
 +    current_conflict: usize,
+ }
  impl App {
          // Create confirm dialog (full window bounds)
          let confirm_dialog = ConfirmDialog::new(Rect::new(0, 0, width, height));
 +        // Create conflict dialog (full window bounds)
 +        let conflict_dialog = ConflictDialog::new(Rect::new(0, 0, width, height));
++
          // Create progress dialog (full window bounds)
          let progress_dialog = ProgressDialog::new(Rect::new(0, 0, width, height));
              drag_active: false,
              clipboard: Clipboard::new(),
              confirm_dialog,
 +            conflict_dialog,
              progress_dialog,
              pending_delete_paths: Vec::new(),
              undo_stack: UndoStack::new(),
 +            pending_paste: None,
          };
          app.update_status_bar();
              return;
+         }
 +        // Check conflict dialog
 +        if self.conflict_dialog.is_visible() {
 +            if let Some(action) = self.conflict_dialog.on_click(pos) {
 +                self.handle_conflict_action(action);
 +            }
 +            return;
 +        }
++
          // Check help modal (clicking outside closes it)
          if self.help_modal.on_click(pos) {
              return;
              return;
+         }
 +        // Handle conflict dialog hover
 +        if self.conflict_dialog.is_visible() {
 +            self.conflict_dialog.on_mouse_move(pos);
 +            return;
 +        }
++
          // Handle sidebar resize in progress
          if self.sidebar_resizing {
              let new_width = (pos.x - self.sidebar.bounds().x).max(0) as u32;
              return;
+         }
 +        // Handle conflict dialog when visible
 +        if self.conflict_dialog.is_visible() {
 +            if let Some(action) = self.conflict_dialog.handle_key(key) {
 +                self.handle_conflict_action(action);
 +            }
 +            return;
 +        }
++
          // Handle help modal when visible
          if self.help_modal.is_visible() {
              match key {
          };
          if let Some((files, op)) = self.clipboard.take() {
 +            // Check for conflicts first
 +            let conflicts: Vec<PathBuf> = files.iter()
 +                .filter_map(|f| {
 +                    f.file_name().and_then(|name| {
 +                        let dest = dest_dir.join(name);
 +                        if dest.exists() { Some(f.clone()) } else { None }
 +                    })
 +                })
 +                .collect();
++
 +            if !conflicts.is_empty() {
 +                // Ring bell to alert user
 +                self.bell();
++
 +                // Show conflict dialog for the first conflict
 +                let first_conflict_name = conflicts[0]
 +                    .file_name()
 +                    .map(|n| n.to_string_lossy().to_string())
 +                    .unwrap_or_default();
++
 +                self.conflict_dialog.show(&first_conflict_name);
++
 +                // Store pending paste state
 +                self.pending_paste = Some(PendingPaste {
 +                    files,
 +                    operation: op,
 +                    dest_dir,
 +                    conflicts,
 +                    current_conflict: 0,
 +                });
 +                return;
 +            }
++
 +            // No conflicts - proceed with paste
              let count = files.len();
              let sources = files.clone();
              let result = match op {
+         }
+     }
 +    /// Handle conflict dialog result.
 +    fn handle_conflict_action(&mut self, action: ConflictAction) {
 +        let pending = match self.pending_paste.take() {
 +            Some(p) => p,
 +            None => return,
 +        };
++
 +        let apply_to_all = self.conflict_dialog.apply_to_all();
++
 +        match action {
 +            ConflictAction::Cancel => {
 +                // Cancel the entire operation
 +                self.status_bar.set_status_message("Paste cancelled");
 +            }
 +            ConflictAction::Skip => {
 +                // Skip conflicting files, paste the rest
 +                self.complete_paste_with_skip(pending, apply_to_all);
 +            }
 +            ConflictAction::Replace => {
 +                // Replace conflicting files
 +                self.complete_paste_with_replace(pending, apply_to_all);
 +            }
 +            ConflictAction::KeepBoth => {
 +                // Auto-rename and paste all
 +                self.complete_paste_with_rename(pending, apply_to_all);
 +            }
 +        }
 +    }
++
 +    /// Complete paste, skipping conflicts.
 +    fn complete_paste_with_skip(&mut self, pending: PendingPaste, _apply_to_all: bool) {
 +        let non_conflicting: Vec<_> = pending.files.iter()
 +            .filter(|f| !pending.conflicts.contains(f))
 +            .cloned()
 +            .collect();
++
 +        if non_conflicting.is_empty() {
 +            self.status_bar.set_status_message("All files skipped (conflicts)");
 +            return;
 +        }
++
 +        let result = match pending.operation {
 +            ClipboardOperation::Copy => copy_files(&non_conflicting, &pending.dest_dir),
 +            ClipboardOperation::Cut => move_files(&non_conflicting, &pending.dest_dir),
 +        };
++
 +        let skipped = pending.conflicts.len();
 +        if result.success {
 +            let action = if pending.operation == ClipboardOperation::Copy { "copied" } else { "moved" };
 +            self.status_bar.set_status_message(format!("{} {} (skipped {})", non_conflicting.len(), action, skipped));
 +        }
 +        self.refresh();
 +    }
++
 +    /// Complete paste, replacing conflicts.
 +    fn complete_paste_with_replace(&mut self, pending: PendingPaste, _apply_to_all: bool) {
 +        // Delete conflicting files first
 +        for conflict in &pending.conflicts {
 +            if let Some(name) = conflict.file_name() {
 +                let dest = pending.dest_dir.join(name);
 +                let _ = std::fs::remove_file(&dest).or_else(|_| std::fs::remove_dir_all(&dest));
 +            }
 +        }
++
 +        let result = match pending.operation {
 +            ClipboardOperation::Copy => copy_files(&pending.files, &pending.dest_dir),
 +            ClipboardOperation::Cut => move_files(&pending.files, &pending.dest_dir),
 +        };
++
 +        if result.success {
 +            let action = if pending.operation == ClipboardOperation::Copy { "copied" } else { "moved" };
 +            self.status_bar.set_status_message(format!("{} {} (replaced {})", pending.files.len(), action, pending.conflicts.len()));
 +        }
 +        self.refresh();
 +    }
++
 +    /// Complete paste, auto-renaming conflicts.
 +    fn complete_paste_with_rename(&mut self, pending: PendingPaste, _apply_to_all: bool) {
 +        use garfield::core::make_unique_name;
++
 +        let mut success_count = 0;
 +        let mut sources = Vec::new();
 +        let mut destinations = Vec::new();
++
 +        for file in &pending.files {
 +            if let Some(name) = file.file_name() {
 +                let dest = pending.dest_dir.join(name);
 +                let final_dest = if dest.exists() {
 +                    // Auto-rename
 +                    let unique_name = make_unique_name(&pending.dest_dir, name.to_string_lossy().as_ref());
 +                    pending.dest_dir.join(unique_name)
 +                } else {
 +                    dest
 +                };
++
 +                let result = match pending.operation {
 +                    ClipboardOperation::Copy => {
 +                        if file.is_dir() {
 +                            garfield::core::copy_path(file, &pending.dest_dir)
 +                        } else {
 +                            std::fs::copy(file, &final_dest).map(|_| final_dest.clone())
 +                        }
 +                    }
 +                    ClipboardOperation::Cut => {
 +                        std::fs::rename(file, &final_dest).map(|_| final_dest.clone())
 +                    }
 +                };
++
 +                if let Ok(dest_path) = result {
 +                    success_count += 1;
 +                    sources.push(file.clone());
 +                    destinations.push(dest_path);
 +                }
 +            }
 +        }
++
 +        // Record for undo
 +        if !destinations.is_empty() {
 +            let undo_op = match pending.operation {
 +                ClipboardOperation::Copy => FileOperation::Copy { sources, destinations },
 +                ClipboardOperation::Cut => FileOperation::Move { sources, destinations },
 +            };
 +            self.undo_stack.push(undo_op);
 +        }
++
 +        let action = if pending.operation == ClipboardOperation::Copy { "copied" } else { "moved" };
 +        self.status_bar.set_status_message(format!("{} {} (auto-renamed conflicts)", success_count, action));
 +        self.refresh();
 +    }
++
 +    /// Ring the terminal bell.
 +    fn bell(&self) {
 +        // X11 bell
 +        let _ = self.window.connection().inner().bell(0);
 +        let _ = self.window.connection().flush();
 +    }
++
      /// Create a new folder in the current directory.
      fn create_new_folder(&mut self) {
          let current_dir = self.focused_pane()
          self.help_modal.set_bounds(Rect::new(0, 0, width, height));
          self.confirm_dialog.set_bounds(Rect::new(0, 0, width, height));
 +        self.conflict_dialog.set_bounds(Rect::new(0, 0, width, height));
          self.progress_dialog.set_bounds(Rect::new(0, 0, width, height));
+     }
          // Draw confirm dialog overlay (on top of everything)
          self.confirm_dialog.render(&self.renderer)?;
 +        // Draw conflict dialog overlay (on top of everything)
 +        self.conflict_dialog.render(&self.renderer)?;
++
          // Draw progress dialog overlay (on top of everything)
          self.progress_dialog.render(&self.renderer)?;

garfield/src/ui/dialog.rsmodified

          Ok(())
+     }
+ }
++
 +/// Result of a conflict dialog.
 +#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 +pub enum ConflictAction {
 +    /// Replace the existing file.
 +    Replace,
 +    /// Skip this file.
 +    Skip,
 +    /// Keep both (auto-rename).
 +    KeepBoth,
 +    /// Cancel the entire operation.
 +    Cancel,
 +}
++
 +/// A modal dialog for file conflict resolution.
 +pub struct ConflictDialog {
 +    /// Window bounds (for centering).
 +    bounds: Rect,
 +    /// Conflicting file name.
 +    filename: String,
 +    /// Whether the dialog is visible.
 +    visible: bool,
 +    /// Currently focused button (0-3).
 +    focused_button: usize,
 +    /// Hovered button.
 +    hovered_button: Option<usize>,
 +    /// Apply to all remaining conflicts.
 +    apply_to_all: bool,
 +}
++
 +impl ConflictDialog {
 +    /// Create a new conflict dialog.
 +    pub fn new(bounds: Rect) -> Self {
 +        Self {
 +            bounds,
 +            filename: String::new(),
 +            visible: false,
 +            focused_button: 2, // Default to Keep Both (safest)
 +            hovered_button: None,
 +            apply_to_all: false,
 +        }
 +    }
++
 +    /// Set bounds.
 +    pub fn set_bounds(&mut self, bounds: Rect) {
 +        self.bounds = bounds;
 +    }
++
 +    /// Show the dialog for a conflicting file.
 +    pub fn show(&mut self, filename: &str) {
 +        self.filename = filename.to_string();
 +        self.visible = true;
 +        self.focused_button = 2; // Default to Keep Both
 +        self.hovered_button = None;
 +        self.apply_to_all = false;
 +    }
++
 +    /// Check if visible.
 +    pub fn is_visible(&self) -> bool {
 +        self.visible
 +    }
++
 +    /// Check if apply to all is set.
 +    pub fn apply_to_all(&self) -> bool {
 +        self.apply_to_all
 +    }
++
 +    /// Hide the dialog.
 +    pub fn hide(&mut self) {
 +        self.visible = false;
 +    }
++
 +    /// Handle key press. Returns Some(action) if dialog should close.
 +    pub fn handle_key(&mut self, key: &Key) -> Option<ConflictAction> {
 +        if !self.visible {
 +            return None;
 +        }
++
 +        match key {
 +            Key::Escape => {
 +                self.hide();
 +                Some(ConflictAction::Cancel)
 +            }
 +            Key::Return => {
 +                self.hide();
 +                Some(match self.focused_button {
 +                    0 => ConflictAction::Replace,
 +                    1 => ConflictAction::Skip,
 +                    2 => ConflictAction::KeepBoth,
 +                    _ => ConflictAction::Cancel,
 +                })
 +            }
 +            Key::Tab | Key::Right => {
 +                self.focused_button = (self.focused_button + 1) % 4;
 +                None
 +            }
 +            Key::Left => {
 +                self.focused_button = if self.focused_button == 0 { 3 } else { self.focused_button - 1 };
 +                None
 +            }
 +            Key::Char('a') | Key::Char('A') => {
 +                // Toggle apply to all
 +                self.apply_to_all = !self.apply_to_all;
 +                None
 +            }
 +            _ => None,
 +        }
 +    }
++
 +    /// Handle mouse move.
 +    pub fn on_mouse_move(&mut self, pos: Point) {
 +        if !self.visible {
 +            return;
 +        }
++
 +        let buttons = self.button_rects();
 +        self.hovered_button = buttons.iter().position(|r| r.contains_point(pos));
 +    }
++
 +    /// Handle click. Returns Some(action) if a button was clicked.
 +    pub fn on_click(&mut self, pos: Point) -> Option<ConflictAction> {
 +        if !self.visible {
 +            return None;
 +        }
++
 +        let dialog_rect = self.dialog_rect();
 +        if !dialog_rect.contains_point(pos) {
 +            self.hide();
 +            return Some(ConflictAction::Cancel);
 +        }
++
 +        // Check checkbox
 +        let checkbox_rect = self.checkbox_rect();
 +        if checkbox_rect.contains_point(pos) {
 +            self.apply_to_all = !self.apply_to_all;
 +            return None;
 +        }
++
 +        let buttons = self.button_rects();
 +        for (i, rect) in buttons.iter().enumerate() {
 +            if rect.contains_point(pos) {
 +                self.hide();
 +                return Some(match i {
 +                    0 => ConflictAction::Replace,
 +                    1 => ConflictAction::Skip,
 +                    2 => ConflictAction::KeepBoth,
 +                    _ => ConflictAction::Cancel,
 +                });
 +            }
 +        }
++
 +        None
 +    }
++
 +    /// Get the dialog rectangle.
 +    fn dialog_rect(&self) -> Rect {
 +        let dialog_width = 420.min(self.bounds.width.saturating_sub(40));
 +        let dialog_height = 180.min(self.bounds.height.saturating_sub(40));
 +        let x = self.bounds.x + (self.bounds.width as i32 - dialog_width as i32) / 2;
 +        let y = self.bounds.y + (self.bounds.height as i32 - dialog_height as i32) / 2;
 +        Rect::new(x, y, dialog_width, dialog_height)
 +    }
++
 +    /// Get button rectangles [Replace, Skip, Keep Both, Cancel].
 +    fn button_rects(&self) -> [Rect; 4] {
 +        let dialog = self.dialog_rect();
 +        let button_width = 85;
 +        let button_height = 28;
 +        let button_y = dialog.y + dialog.height as i32 - button_height as i32 - 16;
 +        let button_gap = 8;
 +        let total_width = button_width * 4 + button_gap * 3;
 +        let start_x = dialog.x + (dialog.width as i32 - total_width as i32) / 2;
++
 +        [
 +            Rect::new(start_x, button_y, button_width as u32, button_height),
 +            Rect::new(start_x + button_width + button_gap, button_y, button_width as u32, button_height),
 +            Rect::new(start_x + (button_width + button_gap) * 2, button_y, button_width as u32, button_height),
 +            Rect::new(start_x + (button_width + button_gap) * 3, button_y, button_width as u32, button_height),
 +        ]
 +    }
++
 +    /// Get checkbox rectangle.
 +    fn checkbox_rect(&self) -> Rect {
 +        let dialog = self.dialog_rect();
 +        Rect::new(dialog.x + 20, dialog.y + 95, 16, 16)
 +    }
++
 +    /// Render the dialog.
 +    pub fn render(&self, renderer: &Renderer) -> Result<()> {
 +        if !self.visible {
 +            return Ok(());
 +        }
++
 +        let theme = renderer.theme();
++
 +        // Dim background overlay
 +        renderer.fill_rect(self.bounds, gartk_core::Color::from_u8(0, 0, 0, 180))?;
++
 +        let dialog_rect = self.dialog_rect();
++
 +        // Dialog background
 +        renderer.fill_rounded_rect(dialog_rect, 8.0, theme.background)?;
 +        renderer.stroke_rounded_rect(dialog_rect, 8.0, theme.border, 1.0)?;
++
 +        // Title
 +        let title_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size + 2.0)
 +            .color(theme.foreground);
++
 +        renderer.text(
 +            "File Already Exists",
 +            (dialog_rect.x + 20) as f64,
 +            (dialog_rect.y + 20) as f64,
 +            &title_style,
 +        )?;
++
 +        // Message
 +        let msg_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size)
 +            .color(theme.item_foreground);
++
 +        let message = format!("\"{}\" already exists in the destination.", self.filename);
 +        renderer.text(
 +            &message,
 +            (dialog_rect.x + 20) as f64,
 +            (dialog_rect.y + 52) as f64,
 +            &msg_style,
 +        )?;
++
 +        renderer.text(
 +            "What would you like to do?",
 +            (dialog_rect.x + 20) as f64,
 +            (dialog_rect.y + 72) as f64,
 +            &msg_style,
 +        )?;
++
 +        // Checkbox for "Apply to all"
 +        let checkbox_rect = self.checkbox_rect();
 +        renderer.stroke_rounded_rect(checkbox_rect, 2.0, theme.border, 1.0)?;
 +        if self.apply_to_all {
 +            // Draw checkmark
 +            let cx = checkbox_rect.x as f64 + 3.0;
 +            let cy = checkbox_rect.y as f64 + 8.0;
 +            renderer.line(cx, cy, cx + 4.0, cy + 4.0, theme.foreground, 2.0)?;
 +            renderer.line(cx + 4.0, cy + 4.0, cx + 10.0, cy - 4.0, theme.foreground, 2.0)?;
 +        }
++
 +        let checkbox_label_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size - 1.0)
 +            .color(theme.item_foreground);
++
 +        renderer.text(
 +            "Apply to all (A)",
 +            (checkbox_rect.x + 22) as f64,
 +            (checkbox_rect.y) as f64,
 +            &checkbox_label_style,
 +        )?;
++
 +        // Buttons
 +        let buttons = self.button_rects();
 +        let labels = ["Replace", "Skip", "Keep Both", "Cancel"];
++
 +        let button_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size - 1.0)
 +            .color(theme.foreground);
++
 +        for (i, (rect, label)) in buttons.iter().zip(labels.iter()).enumerate() {
 +            let focused = self.focused_button == i;
 +            let hovered = self.hovered_button == Some(i);
++
 +            let bg = if focused || hovered {
 +                theme.item_hover_background
 +            } else {
 +                theme.item_background
 +            };
 +            renderer.fill_rounded_rect(*rect, 4.0, bg)?;
 +            if focused {
 +                renderer.stroke_rounded_rect(*rect, 4.0, theme.foreground, 2.0)?;
 +            }
++
 +            let text_width = renderer.measure_text(label, &button_style)?.width;
 +            let text_x = rect.x + (rect.width as i32 - text_width as i32) / 2;
 +            let text_y = rect.y + (rect.height as i32 - (theme.font_size - 1.0) as i32) / 2;
 +            renderer.text(label, text_x as f64, text_y as f64, &button_style)?;
 +        }
++
 +        Ok(())
 +    }
 +}

garfield/src/ui/help_modal.rsmodified

      bounds: Rect,
      visible: bool,
      scroll_offset: i32,
 +    content_height: i32,
+ }
  /// A keybind entry for display.
          KeybindEntry { key: "Ctrl+A", description: "Select all" },
          KeybindEntry { key: "Ctrl+Click", description: "Toggle selection" },
          KeybindEntry { key: "Shift+Click", description: "Range select" },
 +        KeybindEntry { key: "Shift+Up/Down", description: "Extend selection" },
      ]),
      ("File Operations", &[
          KeybindEntry { key: "Ctrl+C", description: "Copy" },
          KeybindEntry { key: "F2", description: "Rename" },
          KeybindEntry { key: "Ctrl+Shift+N", description: "New folder" },
      ]),
 +    ("Bookmarks", &[
 +        KeybindEntry { key: "Ctrl+D", description: "Add bookmark" },
 +        KeybindEntry { key: "Drag folder", description: "Drop on sidebar" },
 +    ]),
      ("Other", &[
          KeybindEntry { key: "Ctrl+L", description: "Edit address" },
          KeybindEntry { key: "F5", description: "Refresh" },
          KeybindEntry { key: "F1", description: "Toggle help" },
 -        KeybindEntry { key: "Escape", description: "Close modal" },
 +        KeybindEntry { key: "Escape", description: "Close modal/quit" },
 +        KeybindEntry { key: "q", description: "Quit" },
      ]),
  ];
              bounds,
              visible: false,
              scroll_offset: 0,
 +            content_height: Self::calculate_content_height(),
+         }
+     }
 +    /// Calculate total content height based on keybind entries.
 +    fn calculate_content_height() -> i32 {
 +        let line_height = 21; // Approximate: font_size * 1.5
 +        let section_gap = 8;
 +        let section_header_extra = 4;
++
 +        let mut height = 0;
 +        for (_, entries) in KEYBINDS {
 +            height += line_height + section_header_extra; // Section header
 +            height += entries.len() as i32 * line_height; // Entries
 +            height += section_gap;
 +        }
 +        height
 +    }
++
      /// Set bounds.
      pub fn set_bounds(&mut self, bounds: Rect) {
          self.bounds = bounds;
          true
+     }
 +    /// Handle mouse wheel scroll.
 +    pub fn on_scroll(&mut self, delta: i32) {
 +        if !self.visible {
 +            return;
 +        }
 +        if delta > 0 {
 +            self.scroll_up();
 +        } else if delta < 0 {
 +            self.scroll_down();
 +        }
 +    }
++
      /// Scroll up.
      pub fn scroll_up(&mut self) {
          self.scroll_offset = (self.scroll_offset - 20).max(0);
      /// Scroll down.
      pub fn scroll_down(&mut self) {
 -        self.scroll_offset += 20;
 +        let modal_rect = self.modal_rect();
 +        let visible_height = modal_rect.height as i32 - 60; // Account for title
 +        let max_scroll = (self.content_height - visible_height).max(0);
 +        self.scroll_offset = (self.scroll_offset + 20).min(max_scroll);
+     }
      /// Get the modal rectangle (centered in bounds).
          self.render_keybinds(renderer, content_rect, theme)?;
 +        // Render scroll indicator if content overflows
 +        let visible_height = content_rect.height as i32;
 +        if self.content_height > visible_height {
 +            self.render_scrollbar(renderer, modal_rect, visible_height, theme)?;
 +        }
++
 +        Ok(())
 +    }
++
 +    /// Render a scrollbar indicator.
 +    fn render_scrollbar(&self, renderer: &Renderer, modal_rect: Rect, visible_height: i32, theme: &Theme) -> Result<()> {
 +        let scrollbar_width = 4;
 +        let scrollbar_x = modal_rect.x + modal_rect.width as i32 - scrollbar_width - 8;
 +        let scrollbar_y = modal_rect.y + 50;
 +        let scrollbar_height = visible_height as u32;
++
 +        // Track background
 +        let track_rect = Rect::new(scrollbar_x, scrollbar_y, scrollbar_width as u32, scrollbar_height);
 +        renderer.fill_rounded_rect(track_rect, 2.0, theme.item_background)?;
++
 +        // Thumb
 +        let thumb_ratio = visible_height as f64 / self.content_height as f64;
 +        let thumb_height = ((scrollbar_height as f64 * thumb_ratio) as u32).max(20);
 +        let max_scroll = (self.content_height - visible_height).max(1);
 +        let scroll_ratio = self.scroll_offset as f64 / max_scroll as f64;
 +        let thumb_y = scrollbar_y + ((scrollbar_height - thumb_height) as f64 * scroll_ratio) as i32;
++
 +        let thumb_rect = Rect::new(scrollbar_x, thumb_y, scrollbar_width as u32, thumb_height);
 +        renderer.fill_rounded_rect(thumb_rect, 2.0, theme.item_foreground)?;
++
          Ok(())
+     }

garfield/src/ui/mod.rsmodified

  pub mod toolbar;
  pub use address_bar::AddressBar;
 -pub use dialog::{ConfirmDialog, DialogResult, ProgressDialog, ProgressInfo};
 +pub use dialog::{ConfirmDialog, ConflictAction, ConflictDialog, DialogResult, ProgressDialog, ProgressInfo};
  pub use breadcrumb::Breadcrumb;
  pub use column_view::{ColumnClickResult, ColumnView};
  pub use grid_view::GridView;