Struct FrameRecorder 

pub struct FrameRecorder<B> { /* private fields */ }

Wraps a backend and records every frame it draws.

Taps Output::draw_layers – the same DrawCell diff stream Terminal::present and every backend already consume – and buffers each call’s changed cells as an owned CapturedFrame, timestamped against when recording started. Works over a Backend, or any subset of Output/Input/Cursor: only Output is tapped, everything else is delegated unchanged, the same shape as InputRecorder.

DrawCell borrows from the source grid, so capture converts to OwnedCell immediately on each draw_layers call rather than deferring to export time, when the borrow would already be gone.

Known limitation

Buffers the whole session in memory (every frame captured, and every cell in it, lives in the shared FrameRecorderHandle until write_cast exports and take_frames drops it) rather than streaming to disk as frames arrive. Fine for docs/demo-length captures – the ones this crate exists for – but not a fit for an unbounded, long-running recording.

Examples

use retroglyph_core::backend::{Headless, Output};
use retroglyph_core::color::Style;
use retroglyph_core::grid::Pos;
use retroglyph_core::tile::Tile;
use retroglyph_recorder::FrameRecorder;

let mut recorder = FrameRecorder::new(Headless::new(10, 3));
let tile = Tile::new('x', Style::default());
let cell = retroglyph_core::backend::DrawCell::new(Pos::new(0, 0), &tile);
recorder.draw_layers(std::iter::once(cell)).unwrap();

assert_eq!(recorder.frames().len(), 1);

Implementations

impl<B: Output> FrameRecorder<B>

pub fn new(inner: B) -> Self

Wraps inner. Recording starts immediately: the clock CapturedFrame::at is measured against begins ticking here, not on the first draw_layers call.

impl<B> FrameRecorder<B>

pub fn handle(&self) -> FrameRecorderHandle

A cloneable FrameRecorderHandle onto this recorder’s shared state, for reading captured frames after a driver (e.g. retroglyph_core::app::run_on) has taken this recorder’s Terminal by value and won’t hand it back.

pub fn frames(&self) -> Vec<CapturedFrame>

FrameRecorderHandle::frames on this recorder’s own handle.

pub fn take_frames(&mut self) -> Vec<CapturedFrame>

FrameRecorderHandle::take_frames on this recorder’s own handle.

pub const fn inner(&self) -> &B

The wrapped backend, for anything not exposed through the decorator itself.

pub const fn inner_mut(&mut self) -> &mut B

The wrapped backend, mutably.

Trait Implementations

impl<B: Cursor> Cursor for FrameRecorder<B>

fn set_cursor_visible(&mut self, visible: bool)

Show or hide the cursor.

fn set_cursor_position(&mut self, position: Pos)

Move the cursor to a position.

fn set_cursor_style(&mut self, style: CursorStyle)

Set the cursor’s shape (and blink behavior).

impl<B: Input> Input for FrameRecorder<B>

fn poll_event(&mut self, timeout: Duration) -> Option<Event>

Poll for an input event, waiting up to timeout.

fn push_event(&mut self, event: Event)

Push an event into the backend’s event buffer.

impl<B: Output> Output for FrameRecorder<B>

type Error = <B as Output>::Error

Error type returned by fallible operations.

fn draw_layers<'a, I>(&mut self, content: I) -> Result<(), Self::Error>

where I: Iterator<Item = DrawCell<'a>>,

Draw changed cells across all layers.

fn compositing(&self) -> Compositing

How this backend wants layers handed to draw_layers.

fn flush(&mut self) -> Result<(), Self::Error>

Flush buffered output to the display.

fn size(&self) -> Size

Return current display dimensions.

fn clear(&mut self) -> Result<(), Self::Error>

Clear the entire display.

fn resize(&mut self, size: Size)

Notify the backend of a resize to size, updating what size reports.

fn draw<'a, I>(&mut self, content: I) -> Result<(), Self::Error>

where I: Iterator<Item = DrawCell<'a>>,

Draw changed cells to the output surface, layer 0 only.