Struct WindowBackend 

pub struct WindowBackend<P: Presenter> { /* private fields */ }

A Backend built from a Presenter plus an input event queue.

Backend fuses input and output, which does not fit a window: some event loop owns input, while a per-renderer surface owns output. WindowBackend reunites the two so Terminal gets the full Backend it needs, while renderer crates implement only Presenter:

event loop.push_event(e) ──> VecDeque<Event> ──> app.poll_event()
                                                       │
                                                       v
                                            Terminal<WindowBackend<P>>
                                                       │
                             draw / flush / resize     v
                             ◄────────────────────  WindowBackend
                                                       │
                                                       v
                                                P: Presenter (output)

With the winit feature enabled, winit::run_windowed and winit::run_app own the event loop, call push_event as winit events are translated, and call Presenter::present once per frame; callers never touch WindowBackend directly. With winit disabled, retroglyph-window exports no event loop at all: a caller driving its own loop (SDL2, tao, a custom driver) constructs WindowBackend::new(presenter) itself, calls push_event for each translated input event, and calls Terminal::present (which drives Presenter::flush) plus presenter_mut().present() once per frame.

poll_event never blocks: frame timing is owned by the event loop, not by input waits.

Implementations

impl<P: Presenter> WindowBackend<P>

pub const fn new(presenter: P) -> Self

Wrap a presenter, creating an empty event queue.

pub const fn presenter(&self) -> &P

The wrapped presenter.

pub const fn presenter_mut(&mut self) -> &mut P

The wrapped presenter, mutably.

pub fn into_presenter(self) -> P

Unwrap into the presenter, discarding queued events.

Trait Implementations

impl<P: Presenter> Backend for WindowBackend<P>

type Error = <P as Presenter>::Error

Error type returned by fallible operations.

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

where I: Iterator<Item = (Pos, &'a Tile)>,

Draw changed cells to the output surface.

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

where I: Iterator<Item = (u8, Pos, &'a Tile)>,

Draw changed cells across all 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 terminal resize.

fn needs_full_frame(&self) -> bool

Returns true if the backend needs the entire frame (all cells on all layers) on every call to draw_layers, rather than just the changed cells.

fn composites_layers(&self) -> bool

Whether this backend composites layers itself (per pixel or quad), receiving the raw layered stream from draw_layers.

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.

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.