Struct App 

pub struct App {

    pub view: ViewState,
    pub repo_path: PathBuf,
    pub comparison: ComparisonContext,
    pub base_identifier: String,
    pub files: Vec<FileDiff>,
    pub lines: Vec<DiffLine>,
    pub error: Option<String>,
    pub conflict_warning: Option<String>,
    pub performance_warning: Option<String>,
    pub gitignore_filter: GitignoreFilter,
    pub file_links: HashMap<String, String>,
    pub image_cache: ImageCache,
    pub image_picker: Option<Picker>,
    pub font_size: (u16, u16),
    pub search: Option<SearchState>,
}

Application state

Fields

view: ViewState

View-related state (scrolling, layout, selection, etc.)

repo_path: PathBuf

Path to the repository root

comparison: ComparisonContext

What we’re comparing (branch names/labels)

base_identifier: String

Resolved base reference for diff computation (merge-base SHA, change ID)

files: Vec<FileDiff>

All file diffs

lines: Vec<DiffLine>

Flattened lines for display

error: Option<String>

Error message to display (if any)

conflict_warning: Option<String>

Warning message about merge conflicts (if any)

performance_warning: Option<String>

Performance warning (large repo or diff)

gitignore_filter: GitignoreFilter

Gitignore filter for file change events

file_links: HashMap<String, String>

Bidirectional map: path → related path (app ↔ spec file links)

image_cache: ImageCache

Cache of loaded images for image diff display

image_picker: Option<Picker>

Image protocol picker for terminal image rendering (None if terminal doesn’t support)

font_size: (u16, u16)

Font size in pixels (width, height) from the Picker, used for image height calculations. Defaults to (8, 16) but updated when set_image_picker() is called.

search: Option<SearchState>

Active search state (None when not searching)

Implementations

impl App

pub fn scroll_up(&mut self, n: usize)

pub fn scroll_down(&mut self, n: usize)

pub fn next_file(&mut self)

pub fn next_file_with_frame(&mut self, ctx: &FrameContext)

Navigate to next file using pre-computed FrameContext

pub fn prev_file(&mut self)

pub fn prev_file_with_frame(&mut self, ctx: &FrameContext)

Navigate to previous file using pre-computed FrameContext

pub fn page_up(&mut self)

pub fn page_down(&mut self)

pub fn go_to_top(&mut self)

pub fn go_to_bottom(&mut self)

pub fn go_to_bottom_with_frame(&mut self, ctx: &FrameContext)

Go to bottom using pre-computed FrameContext

pub fn set_viewport_height(&mut self, height: usize)

Set viewport height (called during rendering)

pub fn clamp_scroll_with_frame(&mut self, ctx: &FrameContext)

Clamp scroll offset using pre-computed FrameContext

pub fn scroll_down_with_frame(&mut self, n: usize, ctx: &FrameContext)

Scroll down using pre-computed FrameContext

pub fn scroll_percentage(&self) -> u16

pub fn scroll_percentage_with_frame(&self, ctx: &FrameContext) -> u16

Compute scroll percentage using pre-computed FrameContext

impl App

pub fn set_row_map(&mut self, row_map: Vec<ScreenRowInfo>)

Set the row map (called during rendering)

pub fn start_selection(&mut self, screen_x: u16, screen_y: u16)

Start a selection at the given screen coordinates

pub fn update_selection(&mut self, screen_x: u16, screen_y: u16)

Update selection end point during drag

pub fn end_selection(&mut self)

End selection (mouse released)

pub fn select_word_at(&mut self, screen_x: u16, screen_y: u16)

Select the word at the given screen coordinates (for double-click) If clicking past end of line, selects the entire logical line (including wrapped segments)

pub fn select_line_at(&mut self, screen_x: u16, screen_y: u16)

Select the entire logical line at the given screen position (for triple-click)

pub fn clear_selection(&mut self)

Clear current selection

pub fn has_selection(&self) -> bool

Check if there’s an active selection

pub fn get_selected_text(&self) -> Option<String>

Get selected text (content only, without line numbers or prefixes) Now uses row_map to correctly handle wrapped lines and split inline diffs

pub fn copy_selection(&mut self) -> Result<bool>

Copy selected text to clipboard

pub fn copy_current_path(&mut self) -> Result<bool>

Copy current file path to clipboard

pub fn copy_diff(&mut self) -> Result<bool>

Copy entire diff to clipboard (respects view mode and collapsed files)

pub fn copy_patch(&mut self) -> Result<bool>

Copy git patch format to clipboard (for use with git apply)

pub fn should_show_copied_flash(&self) -> bool

Check if the “copied” flash should be shown (within 800ms of copy)

pub fn get_file_header_at(&self, screen_x: u16, screen_y: u16) -> Option<String>

Check if a screen position is on a file header, and return the file path if so

impl App

pub fn changed_line_count(&self) -> usize

pub fn additions_count(&self) -> usize

pub fn deletions_count(&self) -> usize

pub fn build_context_lines_with_mapping( &self, ) -> (Vec<DiffLine>, Vec<Option<usize>>)

Build filtered lines with elided markers for context mode

pub fn compute_displayable_items(&self) -> Vec<DisplayableItem>

Compute displayable items as indices (more efficient than cloning lines)

pub fn cycle_view_mode(&mut self)

pub fn find_position_for_original_index(&self, original_idx: usize) -> usize

impl App

pub fn new_for_bench(lines: Vec<DiffLine>) -> Self

Create an App instance for benchmarking with pre-built lines

pub fn new( repo_path: PathBuf, comparison: ComparisonContext, initial: RefreshResult, ) -> Self

Create a new App instance with pre-computed comparison context and initial refresh.

The caller is responsible for detecting the VCS, building the context, and computing the initial refresh via vcs.refresh().

pub fn set_image_picker(&mut self, picker: Picker)

Set the image picker for terminal image rendering. Also stores the font size from the picker for height calculations.

pub fn toggle_file_collapsed(&mut self, path: &str)

Toggle the collapse state of a file

pub fn is_file_collapsed(&self, path: &str) -> bool

Check if a file is collapsed

pub fn apply_refresh_result(&mut self, result: RefreshResult)

pub fn load_images_for_markers(&mut self, vcs: &dyn Vcs)

Load images for any image marker lines into the cache.

pub fn ensure_inline_spans_for_visible( &mut self, visible_height: usize, ) -> Vec<DisplayableItem>

Compute inline spans for visible lines and return the displayable items. Returns the items so they can be reused by FrameContext (avoiding double computation).

pub fn update_single_file( &mut self, file_path: &str, new_diff: Option<FileDiff>, )

pub fn toggle_help(&mut self)

pub fn should_quit(&mut self) -> bool

pub fn is_search_input_active(&self) -> bool

pub fn open_search(&mut self)

pub fn close_search(&mut self)

pub fn search_insert_char(&mut self, c: char)

pub fn search_delete_char(&mut self)

pub fn search_next(&mut self)

pub fn search_prev(&mut self)

pub fn current_file(&self) -> Option<String>

Get the file path of the first visible line

pub fn set_content_layout( &mut self, offset_x: u16, offset_y: u16, line_num_width: usize, content_width: usize, panel_width: u16, )

Set content area layout info (called during rendering)

pub fn needs_inline_spans(&self) -> bool

Check if inline spans need recomputation

pub fn clear_needs_inline_spans(&mut self)

Clear the needs_inline_spans flag after computation

pub fn related_file(&self, path: &str) -> Option<&str>

Get the related file (app ↔ spec) for a given path.

pub fn has_related_file(&self, path: &str) -> bool

Check if a file has a related file in the diff.

pub fn estimate_content_width(&mut self, terminal_width: u16)

Estimate content_width from terminal dimensions.

This should be called BEFORE creating a FrameContext to ensure visible_range calculations use an accurate content_width for line wrapping estimates. The actual content_width is refined during rendering, but this estimate prevents the initial render from showing too few lines.