feat: add mouse drag scroll

Author: tsangwailam

.github/workflows/release.yml

@@ -297,4 +297,9 @@ jobs:
             TARGET_REPO="${CLOUDSMITH_REPO}/${TARGET_DISTRIBUTION}/${TARGET_RELEASE}"
           fi
           echo "Publishing to Cloudsmith repository: ${TARGET_REPO}"
-          cloudsmith push deb "${TARGET_REPO}" dist/debian-*/*.deb --republish
+          shopt -s nullglob
+          for pkg in dist/debian-*/*.deb; do
+            if [[ -f "${pkg}" ]]; then
+              cloudsmith push deb --republish "${TARGET_REPO}" "${pkg}"
+            fi
+          done

CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## [0.1.9] - 2026-03-10
+
+### Changed
+
+- Improved preview UX for scrollbar interactions by adding click-and-drag scrolling and visible scroll-position metadata in the preview border.
+- Removed plain-text fallback notice text from rendered previews to keep content display clean.
+- Fixed Cloudsmith apt publish flow to avoid malformed CLI argument ordering and support iterating multiple `.deb` artifacts.
+
 ## [0.1.8] - 2026-03-09
 
 ### Changed

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "fpv"
-version = "0.1.8"
+version = "0.1.9"
 edition = "2021"
 description = "A minimal, keyboard-first TUI file previewer with syntax highlighting"
 authors = ["Digicrafts"]

Cargo.toml

@@ -6,7 +6,7 @@
 
 A minimal, keyboard-first TUI file previewer for browsing directories and viewing code with syntax highlighting in the terminal.
 
-Current release: `v0.1.8`
+Current release: `v0.1.9`
 
 ---
 

README.md

@@ -235,6 +235,7 @@ pub struct SessionState {
     pub preview_scroll_col: usize,
     pub preview_selection: Option<PreviewSelection>,
     pub preview_selecting: bool,
+    pub preview_scrollbar_dragging: bool,
     pub preview_inner_rect: (u16, u16, u16, u16),
     pub preview_line_number_cols: usize,
     pub preview_render_epoch: u64,
@@ -282,6 +283,7 @@ impl SessionState {
             preview_scroll_col: 0,
             preview_selection: None,
             preview_selecting: false,
+            preview_scrollbar_dragging: false,
             preview_inner_rect: (0, 0, 0, 0),
             preview_line_number_cols: 0,
             preview_render_epoch: 0,
@@ -316,6 +318,7 @@ impl SessionState {
         self.preview_scroll_col = 0;
         self.preview_selection = None;
         self.preview_selecting = false;
+        self.preview_scrollbar_dragging = false;
     }
 
     pub fn clamp_preview_scroll(&mut self, total_lines: usize, viewport_rows: usize) {

src/app/state.rs

@@ -168,6 +168,21 @@ fn preview_scrollbar_target_row(
     Some(target_row.min(max_scroll))
 }
 
+fn handle_preview_scrollbar_drag(
+    state: &mut SessionState,
+    mouse: MouseEvent,
+    total_lines: usize,
+) -> bool {
+    let Some(target_row) = preview_scrollbar_target_row(state, mouse, total_lines) else {
+        return false;
+    };
+    if target_row == state.preview_scroll_row {
+        return false;
+    }
+    state.preview_scroll_row = target_row;
+    true
+}
+
 fn preview_viewport_cols(state: &SessionState) -> usize {
     let (_, _, inner_w, _) = state.preview_inner_rect;
     (inner_w as usize).saturating_sub(state.preview_line_number_cols)
@@ -775,7 +790,7 @@ pub fn process_once(
                 }
             }
         }
-        Event::Mouse(mouse) => {
+    Event::Mouse(mouse) => {
             if state.help_overlay_visible {
                 return Ok((false, false, false));
             }
@@ -785,12 +800,14 @@ pub fn process_once(
 
             if !state.divider_drag_active {
                 state.preview_copy_indicator = false;
+                let rendered_total_lines = rendered_preview_total_lines(state, preview_total_lines);
                 match mouse.kind {
                     MouseEventKind::Down(MouseButton::Left) => {
                         // If we were selecting, finalize the previous selection
                         if state.preview_selecting {
                             finalize_selection(state, preview_doc);
                         }
+                        state.preview_scrollbar_dragging = false;
 
                         let mut tree_clicked = false;
                         if let Some(index) = tree_index_for_click(state, mouse, nodes.len()) {
@@ -814,8 +831,6 @@ pub fn process_once(
                             }
                         }
 
-                        let rendered_total_lines =
-                            rendered_preview_total_lines(state, preview_total_lines);
                         if !tree_clicked {
                             if let Some(target_row) =
                                 preview_scrollbar_target_row(state, mouse, rendered_total_lines)
@@ -824,6 +839,7 @@ pub fn process_once(
                                 state.preview_selection = None;
                                 state.preview_selecting = false;
                                 state.preview_copying_indicator = false;
+                                state.preview_scrollbar_dragging = true;
                             } else if in_preview_panel(state, mouse) {
                                 let pos = mouse_to_content_position(state, mouse);
                                 state.preview_selection = Some(PreviewSelection {
@@ -838,13 +854,23 @@ pub fn process_once(
                             }
                         }
                     }
+                    MouseEventKind::Drag(MouseButton::Left) if state.preview_scrollbar_dragging => {
+                        let _ = handle_preview_scrollbar_drag(
+                            state,
+                            mouse,
+                            rendered_total_lines,
+                        );
+                    }
                     MouseEventKind::Drag(MouseButton::Left) if state.preview_selecting => {
                         let pos = mouse_to_content_position(state, mouse);
                         if let Some(sel) = &mut state.preview_selection {
                             sel.cursor = pos;
                         }
                     }
                     // Some terminals send Moved instead of Drag during button hold
+                    MouseEventKind::Moved if state.preview_scrollbar_dragging => {
+                        let _ = handle_preview_scrollbar_drag(state, mouse, rendered_total_lines);
+                    }
                     MouseEventKind::Moved if state.preview_selecting => {
                         let pos = mouse_to_content_position(state, mouse);
                         if let Some(sel) = &mut state.preview_selection {
@@ -854,6 +880,9 @@ pub fn process_once(
                     MouseEventKind::Up(MouseButton::Left) if state.preview_selecting => {
                         finalize_selection(state, preview_doc);
                     }
+                    MouseEventKind::Up(MouseButton::Left) if state.preview_scrollbar_dragging => {
+                        state.preview_scrollbar_dragging = false;
+                    }
                     _ => {}
                 }
 
@@ -930,7 +959,8 @@ pub fn process_once(
 #[cfg(test)]
 mod tests {
     use super::{
-        apply_mouse_resize, preview_scrollbar_target_row, tree_index_for_click, tree_panel_area,
+        apply_mouse_resize, handle_preview_scrollbar_drag, preview_scrollbar_target_row,
+        tree_index_for_click, tree_panel_area,
     };
     use crate::app::state::{PreviewRenderCache, PreviewRenderCacheKey, SessionState};
     use crossterm::event::{KeyModifiers, MouseButton, MouseEvent, MouseEventKind};
@@ -988,6 +1018,24 @@ mod tests {
         assert_eq!(preview_scrollbar_target_row(&state, click, 8), None);
     }
 
+    #[test]
+    fn preview_scrollbar_drag_moves_scroll_row() {
+        let mut state = SessionState::new(PathBuf::from("."));
+        state.preview_inner_rect = (40, 2, 30, 10);
+        state.preview_scroll_row = 0;
+        state.preview_scrollbar_dragging = true;
+
+        let drag = MouseEvent {
+            kind: MouseEventKind::Drag(MouseButton::Left),
+            column: 69,
+            row: 8,
+            modifiers: KeyModifiers::NONE,
+        };
+
+        assert_eq!(handle_preview_scrollbar_drag(&mut state, drag, 100), true);
+        assert_eq!(state.preview_scroll_row, 60);
+    }
+
     #[test]
     fn rendered_preview_total_lines_prefers_render_cache() {
         let mut state = SessionState::new(PathBuf::from("."));

src/tui/event_loop.rs

@@ -1,5 +1,5 @@
 use crate::app::state::{
-    ContentType, LoadState, PreviewDocument, PreviewFallbackReason, PreviewLineChange,
+    ContentType, LoadState, PreviewDocument, PreviewLineChange,
     PreviewRenderCache, PreviewRenderCacheKey, PreviewSelection, SessionState,
 };
 use crate::config::load::ThemeProfile;
@@ -32,26 +32,57 @@ fn line_count(text: &str) -> usize {
     text.split('\n').count().max(1)
 }
 
+fn preview_scroll_position_text(
+    state: &SessionState,
+    total_lines: usize,
+) -> String {
+    let total = total_lines.max(1);
+    let current = state.preview_scroll_row.saturating_add(1).min(total);
+    format!("[{current}:{total}]")
+}
+
+fn preview_border_bottom_line(
+    state: &SessionState,
+    total_lines: usize,
+    width: usize,
+) -> String {
+    let left = preview_scroll_position_text(state, total_lines);
+    if width <= left.len() {
+        return left.chars().take(width).collect();
+    }
+
+    let right = preview_border_metadata_for_state(state, width.saturating_sub(left.len() + 1));
+    let mut line = left;
+    line.push(' ');
+    let right_width = width.saturating_sub(line.len());
+
+    if right_width == 0 {
+        return line.chars().take(width).collect();
+    }
+
+    let right_with_pad = if right.is_empty() {
+        String::new()
+    } else {
+        let gap = right_width.saturating_sub(right.len());
+        format!("{}{}", " ".repeat(gap), right)
+    };
+    line.push_str(&right_with_pad);
+
+    if line.len() > width {
+        line.chars().take(width).collect()
+    } else {
+        line
+    }
+}
+
 fn plain_text_for_doc(doc: &PreviewDocument) -> String {
     match doc.load_state {
         LoadState::Error | LoadState::Binary => doc
             .error_message
             .clone()
             .unwrap_or_else(|| "Unable to render preview".to_string()),
         _ => {
-            let mut content = doc.content_excerpt.clone();
-            if matches!(doc.content_type, ContentType::PlainText) {
-                if let Some(reason) = &doc.fallback_reason {
-                    let reason_text = match reason {
-                        PreviewFallbackReason::UnsupportedExtension => "unsupported-extension",
-                        PreviewFallbackReason::EngineFailure => "highlight-failed",
-                        PreviewFallbackReason::TooLarge => "large-file-guard",
-                        PreviewFallbackReason::DecodeUncertain => "decode-uncertain",
-                    };
-                    content = format!("[plain-text fallback: {reason_text}]\n{content}");
-                }
-            }
-            content
+            doc.content_excerpt.clone()
         }
     }
 }
@@ -764,14 +795,18 @@ pub fn draw_preview(
 ) {
     frame.render_widget(Clear, area);
     let title = preview_title_for_state(state);
-    let metadata_line =
-        preview_border_metadata_for_state(state, area.width.saturating_sub(2) as usize);
+    let total_lines = preview_total_lines(doc);
+    let metadata_line = preview_border_bottom_line(
+        state,
+        total_lines,
+        area.width.saturating_sub(2) as usize,
+    );
     let block = Block::default()
         .title(
             Line::from(vec![Span::raw(" "), Span::raw(title), Span::raw(" ")])
                 .alignment(Alignment::Right),
         )
-        .title_bottom(Line::from(metadata_line).alignment(Alignment::Right))
+        .title_bottom(Line::from(metadata_line).alignment(Alignment::Left))
         .borders(Borders::ALL);
     let inner = block.inner(area);
     frame.render_widget(block, area);

src/tui/preview_pane.rs

@@ -557,7 +557,7 @@ fn preview_total_lines_counts_fallback_header_and_content() {
         fallback_reason: Some(PreviewFallbackReason::UnsupportedExtension),
         ..fpv::app::state::PreviewDocument::default()
     };
-    assert_eq!(preview_total_lines(&doc), 3);
+    assert_eq!(preview_total_lines(&doc), 2);
 
     doc.fallback_reason = None;
     assert_eq!(preview_total_lines(&doc), 2);