Struct App 

pub struct App {

    pub data_table_state: Option<DataTableState>,
    pub home_app: HomeApp,
    pub home: HomeState,
    pub info_modal: InfoModal,
    pub info: InfoState,
    pub prompt: QueryPrompt,
    pub input_mode: InputMode,
    pub overlay: Overlay,
    pub sort_filter_modal: SortFilterModal,
    pub pivot_melt_modal: PivotMeltModal,
    pub view_modal: ViewModal,
    pub analysis_modal: AnalysisModal,
    pub sample: SampleState,
    pub chart: Charts,
    pub export_modal: ExportModal,
    pub copy_modal: CopyModal,
    pub inspector_modal: InspectorModal,
    pub pickers: Pickers,
    pub value_counts: ValueCountsModal,
    pub column_forms: ColumnForms,
    pub hex: HexState,
    pub confirmation_modal: ConfirmationModal,
    /* private fields */
}

Fields

data_table_state: Option<DataTableState>

home_app: HomeApp

The home screen’s work in flight, and what it keeps for the session.

home: HomeState

Home screen state, rebuilt whenever home is entered.

info_modal: InfoModal

info: InfoState

What the Info panel shows of the dataset beyond its schema.

prompt: QueryPrompt

The command line: its inputs per mode, completion, and the query it is running.

input_mode: InputMode

overlay: Overlay

What is open over the table. See Overlay.

sort_filter_modal: SortFilterModal

pivot_melt_modal: PivotMeltModal

view_modal: ViewModal

analysis_modal: AnalysisModal

sample: SampleState

The sample form, and what the draws learned of memory and of the paths they took.

chart: Charts

The chart view, its export form, and the preparations it keeps or waits on.

export_modal: ExportModal

copy_modal: CopyModal

inspector_modal: InspectorModal

pickers: Pickers

The go-to-column, format and table pickers.

value_counts: ValueCountsModal

The Value Counts screen (F).

column_forms: ColumnForms

The retype and combine forms.

hex: HexState

The hex view, and the number its next read is tagged with.

confirmation_modal: ConfirmationModal

Implementations

impl App

pub fn quality_copy_bytes(&self) -> u64

Bytes on disk in the copies kept.

impl App

pub fn set_memory_probe(&mut self, probe: MemoryProbe)

Read available memory from probe instead of the system (for tests).

pub fn sample_drawing(&self) -> bool

Whether the view’s sample is being drawn.

impl App

pub fn python_script(&self, state: &DataTableState) -> String

The view on screen as a Python Polars script: the open’s reader, then every step that made the view. See python_script.

pub fn set_clipboard_destination(&mut self, destination: Box<dyn Destination>)

Replace the clipboard destination, so tests can watch copies without a display or terminal.

impl App

pub fn hex_view(&self) -> Option<&HexView>

The hex view on screen, if it is.

impl App

pub fn sibling_tables(&self) -> Option<Tables>

The tables of the source on screen, from what its open holds; None for a source of one.

pub fn offers_other_tables(&self) -> bool

Whether the source on screen has another table for T to open.

impl App

pub fn request_reshape_preview(&mut self)

Ask for a preview of the staged spec unless already asked. One worker at a time: an edit made meanwhile is previewed when it ends.

pub fn reshape_preview_pending(&self) -> bool

Whether the builder’s preview has an answer still to come.

impl App

pub fn close_overlay(&mut self)

Close the overlay, dropping what it held for this opening, and go back to what it was opened over.

pub fn at_table(&self) -> bool

The plain table or the query line: no overlay, and not home.

impl App

pub fn pointer(&mut self, mouse: &MouseEvent, now: Instant) -> Pointer

What a mouse event means on the screen last drawn.

pub fn cancel_drag(&mut self)

A key was pressed: a header being carried is put back, and its mark goes.

pub fn forget_click(&mut self)

Forget the last click and any drag: it was dropped, so the next is not its second, and nothing was picked up.

pub fn point(&mut self, target: &Target)

Move the cursor to what a click or the wheel landed on. A press on a header picks the column up, for a drag to move.

pub fn point_for_menu(&mut self, hit: &CellHit) -> bool

Put the cursor on the cell a right click landed on, for the menu. Returns whether it is there: rows that moved since they were drawn are not the ones clicked, and the menu would act on another cell.

pub fn focus_field(&mut self, id: &FieldId) -> Option<Clicked>

Focus the field a click landed on, in whichever form drew it.

pub fn point_at_tool(&mut self, tool: usize)

Put the analysis tools list’s cursor on tool, the list focused, as Tab and the arrows would.

pub fn start_resize(&mut self, column: String, x: u16)

Start a width drag on column, from the width it has now.

pub fn set_dragged_width(&mut self, column: String, width: u16)

Set a column’s width by hand, as < and > do, within their bounds.

impl App

pub fn chart_preparing(&self) -> bool

Whether chart data for the current view is being prepared: running, or waiting behind a superseded preparation still reading (unstoppable, see ChartPrep).

pub fn chart_names(&self) -> Option<Vec<String>>

The series of the line or scatter chart on screen, by name, once prepared: its Y columns or its color groups.

pub fn chart_data_ready(&self) -> bool

True when the chart cache holds the data for the modal’s current selection.

impl App

pub fn live_on_screen(&self) -> Option<usize>

The matches the prompt’s pattern has among the rows on screen, while the prompt is open.

pub fn live_cells(&self) -> Option<Arc<MatchCells>>

The cells to light up: the prompt’s matches while it is open.

pub fn find_hit(&self) -> Option<(usize, String)>

The cell the find in effect landed on, while the view is the one it searched.

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

What the footer says about the find in effect: the pattern, and which match the cursor is on when that is known.

pub fn finding(&self) -> bool

Whether a find is reading.

impl App

pub fn home_schema(&mut self, entry: &Entry) -> Option<SchemaPreview>

Schema for a home entry, from Parquet metadata, memoized for the session. None means not knowable without a scan, and the UI says so.

pub fn home_preview_rows( &mut self, entry: &Entry, screen_height: u16, ) -> Option<Arc<PreviewRows>>

A home file’s first rows for its ROWS preview, read on a worker as its open reads them. None until they land or when not previewed. screen_height sizes the page to the table’s.

pub fn home_preview_pending(&self, path: &Path) -> bool

Whether entry is one the preview reads, before its rows are in.

pub fn home_schema_pending(&self, path: &Path) -> bool

Whether a schema read is currently out for this path.

pub fn enter_home(&mut self)

impl App

pub fn enter_inspects(&self) -> bool

Whether Enter at the table opens the inspector, as Space does: a table whose rows do not drill into groups (a by view, a SQL GROUP BY), and not inside a drill-down.

impl App

pub fn row_count_pending(&self) -> bool

Whether the footer’s row count is on its way, so a spinner stands in. Asked by the bar and by the run loop that turns the spinner, so they agree.

pub fn count_waits_for_a_frame(&self) -> bool

Whether a paint now would start or retire the count waiting on one. A test harness, which paints nothing, asks this to know when to report a paint.

pub fn frame_painted(&mut self)

A frame was painted: read the rows it needed and start the count waiting on it.

pub fn unfit_count_pending(&self) -> bool

Whether the values the read’s column types made null are being counted.

impl App

pub fn set_loading_phase( &mut self, phase: impl Into<String>, progress_percent: u16, )

An open is on its way: the loading screen shows phase and keys wait. Called before the event that carries the open out (by run, or a key before its Open), since a frame drawn between would show the outgoing dataset.

pub fn abandon_load(&mut self)

Enter the home screen, rebuilt, with the cursor on what is open, abandoning any load. loading::Loader::retire supersedes the open’s jobs (their answers are dropped) and raises its stop flag, so downloads and cloud passes stop within a wave. Work not the open’s (an export, an analysis, the screen’s footer pass) is left running, with its progress and completion modal.

pub fn route_named_paths(paths: Vec<PathBuf>, options: OpenOptions) -> AppEvent

What datui <path> does with a directory, by the same rule as Enter on its row (home::look_into_as): a hive root or a one-table directory opens as one table, any other opens home browsed into it. --hive still forces partition columns. Stats the path, so run calls it on a worker (AppEvent::OpenNamed); returns LookThenOpenDirectory or Open.

pub fn route_named_paths_with( paths: Vec<PathBuf>, options: OpenOptions, formats: &Registry, ) -> AppEvent

Self::route_named_paths with the format specs: a directory a spec reads as column files opens rather than being looked at.

pub fn missing_named_path( paths: &[PathBuf], formats: &Registry, ) -> Option<PathBuf>

The first named local path that is not there. URLs and globs are left to the open; stdin is no path.

impl App

pub fn query_prompt_mode(&self) -> Option<QueryMode>

The command line’s language while it is open.

pub fn query_prompt_text(&self) -> Option<&str>

The command line’s text, while it is open.

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

Why the last run failed, for the line under the input: a statement that failed while running, else one that could not be planned.

pub fn inline_failures(&self) -> u64

Bumped each time a running statement’s failure is put in the prompt.

impl App

pub fn create_view_from_current_state( &mut self, name: String, description: Option<String>, match_criteria: MatchCriteria, ) -> Result<SavedView>

impl App

pub fn what_enter_does(&self) -> WhatEnter

See WhatEnter.

impl App

pub const LOOKING_AT_A_DIRECTORY: &'static str = "Looking at the directory"

The wait while a directory named on the command line is looked at (seconds for large Parquet).

pub const LOADING_BUFFER: &'static str = "Loading buffer..."

The wait while the rows for the view are fetched.

pub fn is_busy(&self) -> bool

Whether keys wait: a job the user waits on runs or is owed, an errand is between phases, or an open is on its way.

pub fn task_generation(&self) -> u64

The generation background answers are judged by.

pub fn job_is_current(&self, ticket: Ticket) -> bool

Whether the job ticket names is still running and its answer still wanted.

pub fn use_cache(&mut self, cache: CacheManager)

Use cache from now on. For tests that read their store back: a shared one loses entries to other tests’ opens.

pub fn use_catalog_dir(&mut self, dir: &Path) -> Result<()>

Read and write catalog.toml in dir, so a test’s Ctrl+D stays out of the shared config directory.

pub fn open_path(&self) -> Option<&Path>

Path of the installed dataset, if any.

pub fn background_work_in_flight(&self) -> bool

Whether any leased background work, current or abandoned, has yet to report.

pub fn screen_generation(&self) -> u64

See the screen_generation field.

pub fn modal_showing(&self) -> bool

True while a message is in front of the user that has to be dismissed.

pub fn follow(&self) -> Option<&Follow>

The follow of the dataset on screen, while it is followed.

pub fn recording(&self) -> Option<&Arc<Spool>>

Standard input being recorded to the --tee file, for the dataset on screen.

pub fn recording_after_exit(&mut self) -> Option<(Tee, Arc<SpoolHandle>)>

The recording to wait for after the terminal is handed back.

pub fn flash_message(&self) -> Option<&str>

The completion flash on the footer, if one is showing.

pub fn error_message(&self) -> Option<&str>

The error dialog’s message, if one is showing.

pub fn next_deadline(&self) -> Option<Instant>

When the screen next changes with no event (a flash expiring): the loop sleeps until then at most.

pub fn tick_follow_clock(&mut self) -> bool

Whether the follow chip’s clock reads differently now: the frame must redraw.

pub fn tick_flash(&mut self) -> bool

Drop an expired flash. Returns true when the frame must redraw.

pub fn flash_polars_warning(&mut self) -> bool

Flash the next Polars user warning once per session when the bar is free. True when the frame must redraw.

pub fn flash_background_panic(&mut self) -> bool

Flash a background thread panic nothing else reported (a job’s panic ends the job). True when the frame must redraw.

pub fn set_input_dropped(&mut self, dropped: bool)

See the input_dropped field.

pub fn hard_escape_while_busy(&self, key: &KeyEvent) -> bool

Escapes that act at once while busy and jump the queue: Ctrl-Q and Ctrl-C quit, Ctrl-O goes home, confirmation modals keep their keys, and the home screen (never busy on its own account) keeps every key.

pub fn key_acts_while_busy(&self, key: &KeyEvent) -> bool

Whether a key may act while busy; the main loop adds “nothing queued” for the second group. The hard escapes always qualify. At the plain table view, keys that read nothing act too: quit, help, and the column cursor (which re-slices the held buffer, never collects; a count here would read cloud metadata on this thread, see a_key_that_acts_while_busy_reads_nothing). Everything else is type-ahead and waits. Never by keycode alone: the h in /hello never scrolls.

pub fn in_normal_table_view(&self) -> bool

The plain table view: Normal mode with nothing drawn over it.

pub fn open_context_menu(&mut self, at: Position)

Open the context menu at at, over the cell the cursor was just put on.

pub fn close_context_menu(&mut self)

Close the context menu, if it is open.

pub fn choose_from_menu(&mut self, i: usize) -> Option<AppEvent>

Choose line i of the open menu: it closes and its key is offered as typed.

pub fn drop_column(&mut self, column: &str, onto: &str) -> Option<AppEvent>

A header dropped on another column: column moves to onto, as repeated H / L would. Frozen columns move among the frozen, scrolling among the scrolling.

pub fn text_field_focused(&self) -> bool

Whether a text field owns typed characters, so the wheel and ? leave it alone. The home filter is excluded on purpose.

pub fn something_is_spinning(&self) -> bool

Whether a spinner is on screen, so the run loop turns it and redraws.

pub fn frame_work(&mut self)

A frame’s work without painting it, in the order EventPump::run does it around a frame: ask for what the frame needs, take in what arrived (as drawing does), and ask again for what that changed. For a harness with no terminal, at the point the run loop would draw: once the events on hand are handled.

pub fn footer_progress(&self) -> &Arc<FooterProgress>

The footer counter: the open’s while one is on its way, else the dataset’s. Each open counts on its own, so a replaced one cannot count under another’s name.

pub fn exit_sweep(&self) -> ExitSweep

Held past the app: when dropped it removes temp files the app’s opens were still writing, giving workers up to a second to stop.

pub fn spawn_async_collect(&mut self, status: &str) -> bool

Spawn a buffer collect if needed; true if a job was spawned. Advances the generation, invalidating any prior collect. An unknown row count is computed in the background (BackgroundLenReady) and never gates the paint: the plan is then a top-of-data window.

pub fn new(events: Sender<AppEvent>, runtime: Handle) -> App

pub fn new_with_theme( events: Sender<AppEvent>, runtime: Handle, theme: Theme, ) -> App

pub fn new_with_config( events: Sender<AppEvent>, runtime: Handle, theme: Theme, app_config: AppConfig, ) -> App

An app with its saved views read here, before it is returned.

pub fn new_with_views( events: Sender<AppEvent>, runtime: Handle, theme: Theme, app_config: AppConfig, view_manager: Views, ) -> App

An app whose saved views may still be on their way (Views).

pub fn set_formats(&mut self, registry: Registry)

Use registry as the format specs on the search path.

pub fn enable_debug(&mut self)

pub fn request_what_the_frame_needs(&mut self)

After a frame, ask for what it lacked: counts for the rows on screen with none, and kinds for rows nothing has looked into. Workers read; this thread decides.

impl App

pub fn help_visible(&self) -> bool

Whether the help overlay is on screen.

pub fn help_context(&self) -> Option<Context>

The screen the help overlay shows the keys of, while it is up.

pub fn keys_context(&self) -> Context

The screen the keys typed now go to, as the key registry names it.

pub fn awaiting_open_confirmation(&self) -> bool

True while the confirmation modal asks whether to download a remote file or read a large one whole. These can be walked away from (to home, not exit): the size probe behind them can take seconds.

pub fn handle(&mut self, event: AppEvent) -> EventOutcome

Handle one event. A key arriving while busy is neither acted on nor dropped: it returns as Err(key) for the caller to hold until idle, as app::event_pump::EventPump does. App::event is for callers with nowhere to hold a key.

pub fn event(&mut self, event: AppEvent) -> Option<AppEvent>

pub fn header_toggle_offered(&self) -> bool

Whether the dataset is delimited text, whose header H on Info’s Schema tab toggles.

impl App

pub fn file_facts(&self) -> Option<&FileFacts>

What the Info panel knows about the open file: None until asked, and for a source with no local file. Cleared on install.

pub fn follow_terminal_background(&mut self, mode: ThemeMode)

Under theme.mode = "auto", switch to theme.dark or theme.light for the terminal’s background, with theme.colors over it. An explicit mode ignores the terminal.

pub fn settle_first_palette(&mut self, answered: Option<ThemeMode>)

Settle the first frame’s palette under auto without waiting: answered if given, else this terminal’s last answer. A later answer switches if it differs.

pub fn take_background_query(&mut self) -> bool

Whether the run loop should ask the terminal’s background, once (set by AppEvent::TerminalFocused under auto).

pub fn take_repaint(&mut self) -> bool

Whether the next frame repaints every cell (after a resize, or when the terminal regains focus), for the run loop.

pub fn theme(&self) -> &Theme

The colors the next frame is drawn with.

pub fn follows_terminal(&self) -> bool

Whether the palette follows the terminal (theme.mode = "auto").

pub fn take_external_open(&mut self) -> Option<ExternalOpen>

The value the inspector wrote for another program, for the run loop.

pub fn mouse_enabled(&self) -> bool

Whether the session reports the mouse, to retake it after a program had the terminal.

pub fn external_opened(&mut self, open: &ExternalOpen, failed: Option<String>)

The run loop opened open: a waiting program is done with its file; a failure goes on the bar.

impl App

pub fn capture_view(&self) -> Result<Option<LazyFrame>>

The view returned on exit to a caller that asked (datui.view(..., capture=True)): the committed frame without internal columns; None with no dataset. Refused when the frame scans a temp file (download, decompressed or converted copy), which is removed on exit; export (e) is the way out.

Trait Implementations

impl Drop for App

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl Widget for &mut App

fn render(self, area: Rect, buf: &mut Buffer)

Draws the current state of the widget in the given buffer. That is the only method required to implement a custom widget.