Struct Live 

pub struct Live<W: Write> { /* private fields */ }

An in-place updating display over a renderable. Mirrors rich.live.Live (manual-refresh subset). Output is written to a generic sink W, so it can target stdout or, in tests, a byte buffer.

Implementations

impl<W: Write> Live<W>

pub fn new(renderable: Box<dyn Renderable>, console: Console, writer: W) -> Self

Create a live display for renderable, rendering with console and writing control/output bytes to writer.

pub fn start(&mut self)

Begin the live display: hide the cursor and draw the first frame.

pub fn update(&mut self, renderable: Box<dyn Renderable>)

Swap in a new renderable and redraw in place.

pub fn refresh(&mut self)

Redraw the current renderable in place (reposition over the last frame, then render).

pub fn stop(&mut self)

Commit the final frame (with a trailing newline) and show the cursor.

pub fn writer(&self) -> &W

The output sink (for inspecting captured bytes in tests).

pub fn into_writer(self) -> W

Consume the display, returning its output sink.

impl<W: Write + Send + 'static> Live<W>

pub fn spawn( renderable: Box<dyn Renderable + Send>, console: Console, writer: W, refresh_per_second: f64, ) -> AutoLive<W>

Start an auto-refreshing live display on a background thread: it draws the first frame, then redraws every 1/refresh_per_second seconds (and immediately on each AutoLive::update). Mirrors upstream’s auto_refresh/refresh_per_second. The renderable, console, and writer are moved into the thread, so all three must be Send.