`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, ConflictAction, ConflictDialog, DialogResult, ProgressDialog, ProgressInfo};
 pub use breadcrumb::Breadcrumb;
 pub use column_view::{ColumnClickResult, ColumnView};
 pub use grid_view::GridView;

`@@ -15,7 +15,7 @@` pub mod tab_bar;
15	pub mod toolbar;	15	pub mod toolbar;
16		16
17	pub use address_bar::AddressBar;	17	pub use address_bar::AddressBar;
18	-pub use dialog::{ConfirmDialog, DialogResult, ProgressDialog, ProgressInfo};	18	+pub use dialog::{ConfirmDialog, ConflictAction, ConflictDialog, DialogResult, ProgressDialog, ProgressInfo};
19	pub use breadcrumb::Breadcrumb;	19	pub use breadcrumb::Breadcrumb;
20	pub use column_view::{ColumnClickResult, ColumnView};	20	pub use column_view::{ColumnClickResult, ColumnView};
21	pub use grid_view::GridView;	21	pub use grid_view::GridView;