Struct Program 

pub struct Program<M, E, W = Stdout>
where
    M: Model,
    E: BackendEventSource<Error = Error>,
    W: Write + Send,
{ /* private fields */ }

The program runtime that manages the update/view loop.

Implementations

impl<M> Program<M, CrosstermEventSource>

where M: Model,

pub fn new(model: M) -> Result<Program<M, CrosstermEventSource>, Error>

where <M as Model>::Message: Send + 'static,

Create a new program with default configuration.

pub fn with_config( model: M, config: ProgramConfig, ) -> Result<Program<M, CrosstermEventSource>, Error>

where <M as Model>::Message: Send + 'static,

Create a new program with the specified configuration.

impl<M, E, W> Program<M, E, W>

where M: Model, E: BackendEventSource<Error = Error>, W: Write + Send,

pub fn with_event_source( model: M, events: E, backend_features: BackendFeatures, writer: TerminalWriter<W>, config: ProgramConfig, ) -> Result<Program<M, E, W>, Error>

where <M as Model>::Message: Send + 'static,

Create a program with an externally-constructed event source and writer.

This is the generic entry point for alternative backends (native tty, WASM, headless testing). The caller is responsible for terminal lifecycle (raw mode, cleanup) — the event source should handle that via its Drop impl or an external RAII guard.

impl<M> Program<M, TtyBackend>

where M: Model,

pub fn with_native_backend( model: M, config: ProgramConfig, ) -> Result<Program<M, TtyBackend>, Error>

where <M as Model>::Message: Send + 'static,

Create a program backed by the native TTY backend (no Crossterm).

This opens a live terminal session via ftui-tty, entering raw mode and enabling the requested features. When the program exits (or panics), TtyBackend::drop() restores the terminal to its original state.

impl<M, E, W> Program<M, E, W>

where M: Model, E: BackendEventSource<Error = Error>, W: Write + Send,

pub fn run(&mut self) -> Result<(), Error>

Run the main event loop.

This is the main entry point. It handles:

1. Initialization (terminal setup, raw mode)
2. Event polling and message dispatch
3. Frame rendering
4. Shutdown (terminal cleanup)

pub fn last_widget_signals(&self) -> &[WidgetSignal]

Access widget scheduling signals captured on the last render.

pub fn immediate_drain_stats(&self) -> ImmediateDrainStats

Snapshot immediate-drain runtime counters.

pub fn model(&self) -> &M

Get a reference to the model.

pub fn model_mut(&mut self) -> &mut M

Get a mutable reference to the model.

pub fn is_running(&self) -> bool

Check if the program is running.

pub const fn tick_rate(&self) -> Option<Duration>

Get the current tick rate, if one has been installed.

pub const fn executed_cmd_count(&self) -> usize

Get the number of commands actually executed by the runtime.

pub fn quit(&mut self)

Request a quit.

pub fn state_registry(&self) -> Option<&Arc<StateRegistry>>

Get a reference to the state registry, if configured.

pub fn has_persistence(&self) -> bool

Check if state persistence is enabled.

pub fn tick_strategy_stats(&self) -> Vec<(String, String)>

Query the current tick strategy’s debug statistics.

Returns key-value pairs describing the strategy’s internal state (e.g. strategy name, divisors, confidence, transition counts). Returns an empty vec if no tick strategy is configured.

pub fn trigger_save(&mut self) -> Result<bool, StorageError>

Trigger a manual save of widget state.

Returns the result of the flush operation, or Ok(false) if persistence is not configured.

pub fn trigger_load(&mut self) -> Result<usize, StorageError>

Trigger a manual load of widget state.

Returns the number of entries loaded, or Ok(0) if persistence is not configured.

pub fn request_redraw(&mut self)

Mark the UI as needing redraw.

pub fn request_ui_height_remeasure(&mut self)

Request a re-measure of inline auto UI height on next render.

pub fn start_recording(&mut self, name: impl Into<String>)

Start recording events into a macro.

If already recording, the current recording is discarded and a new one starts. The current terminal size is captured as metadata.

pub fn stop_recording(&mut self) -> Option<InputMacro>

Stop recording and return the recorded macro, if any.

Returns None if not currently recording.

pub fn is_recording(&self) -> bool

Check if event recording is active.