Struct MicroscopeState 

pub struct MicroscopeState {

    pub active: bool,
    pub query: String,
    pub cursor_pos: usize,
    pub all_items: Vec<MicroscopeItem>,
    pub items: Vec<MicroscopeItem>,
    pub selected_index: usize,
    pub scroll_offset: usize,
    pub picker_name: String,
    pub title: String,
    pub prompt: String,
    pub preview: Option<PreviewContent>,
    pub layout: MicroscopeLayout,
    pub preview_enabled: bool,
    pub prompt_mode: PromptMode,
    pub loading_state: LoadingState,
    pub bounds: LayoutBounds,
    pub layout_config: LayoutConfig,
    pub total_count: u32,
    pub matched_count: u32,
}

State of the microscope fuzzy finder

Fields

active: bool

Whether microscope is currently active/visible

query: String

Current search query

cursor_pos: usize

Cursor position in the query

all_items: Vec<MicroscopeItem>

All items from the picker (unfiltered)

items: Vec<MicroscopeItem>

Current list of items (filtered/sorted)

selected_index: usize

Currently selected item index

scroll_offset: usize

Scroll offset for long lists

picker_name: String

Name of the current picker

title: String

Title to display

prompt: String

Prompt string

preview: Option<PreviewContent>

Preview content (if available)

layout: MicroscopeLayout

Legacy layout configuration (for compatibility)

preview_enabled: bool

Whether preview is enabled

prompt_mode: PromptMode

Prompt mode (Insert/Normal)

loading_state: LoadingState

Loading state

bounds: LayoutBounds

Helix-style layout bounds

layout_config: LayoutConfig

Layout configuration

total_count: u32

Total item count (from matcher)

matched_count: u32

Matched item count (from matcher)

Implementations

impl MicroscopeState

pub fn new() -> Self

Create a new empty microscope state

pub fn open(&mut self, picker_name: &str, title: &str, prompt: &str)

Open microscope with a picker

Starts in Normal mode for j/k navigation. Press ‘i’ to enter Insert mode.

pub fn close(&mut self)

Close microscope

pub fn enter_insert(&mut self)

Enter insert mode

pub fn enter_normal(&mut self)

Enter normal mode

pub fn toggle_mode(&mut self)

Toggle between insert and normal mode

pub fn set_loading(&mut self, state: LoadingState)

Set loading state

pub fn update_bounds(&mut self, screen_width: u16, screen_height: u16)

Update bounds from screen dimensions

pub fn status_text(&self) -> String

Get status line text

pub fn update_items(&mut self, items: Vec<MicroscopeItem>)

Update items from search results (initial load - stores in both all_items and items)

pub fn update_filtered_items(&mut self, items: Vec<MicroscopeItem>)

Update filtered items only (for filtering - keeps all_items unchanged)

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

Insert a character at cursor position

pub fn delete_char(&mut self)

Delete character before cursor

pub fn cursor_left(&mut self)

Move cursor left

pub fn cursor_right(&mut self)

Move cursor right

pub const fn cursor_home(&mut self)

Move cursor to start

pub fn cursor_end(&mut self)

Move cursor to end

pub fn word_forward(&mut self)

Move cursor forward one word

pub fn word_backward(&mut self)

Move cursor backward one word

pub fn clear_query(&mut self)

Clear the query

pub fn delete_word(&mut self)

Delete word before cursor

pub fn select_next(&mut self)

Select next item

pub fn select_prev(&mut self)

Select previous item

pub fn page_down(&mut self)

Page down

pub fn page_up(&mut self)

Page up

pub fn move_to_first(&mut self)

Move to first item

pub fn move_to_last(&mut self)

Move to last item

pub fn selected_item(&self) -> Option<&MicroscopeItem>

Get currently selected item

pub const fn is_visible(&self) -> bool

Check if microscope is active and visible

pub fn visible_items(&self) -> &[MicroscopeItem]

Get visible items slice

pub fn set_preview(&mut self, content: Option<PreviewContent>)

Update preview content

pub fn calculate_layout(&mut self, screen_width: u16, screen_height: u16)

Calculate layout based on screen dimensions

Trait Implementations

impl Clone for MicroscopeState

fn clone(&self) -> MicroscopeState

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for MicroscopeState

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for MicroscopeState

fn default() -> MicroscopeState

Returns the “default value” for a type.