Struct ratatui::backend::TermionBackend

pub struct TermionBackend<W>
where
    W: Write,
{ /* private fields */ }

Available on crate feature termion only.

A Backend implementation that uses Termion to render to the terminal.

The TermionBackend struct is a wrapper around a writer implementing Write, which is used to send commands to the terminal. It provides methods for drawing content, manipulating the cursor, and clearing the terminal screen.

Most applications should not call the methods on TermionBackend directly, but will instead use the Terminal struct, which provides a more ergonomic interface.

Usually applications will enable raw mode and switch to alternate screen mode when starting. This is done by calling IntoRawMode::into_raw_mode() and IntoAlternateScreen::into_alternate_screen() on the writer before creating the backend. This is not done automatically by the backend because it is possible that the application may want to use the terminal for other purposes (like showing help text) before entering alternate screen mode. This backend automatically disable raw mode and switches back to the primary screen when the writer is dropped.

Example

use std::io::{stderr, stdout};

use ratatui::prelude::*;
use termion::{raw::IntoRawMode, screen::IntoAlternateScreen};

let writer = stdout().into_raw_mode()?.into_alternate_screen()?;
let mut backend = TermionBackend::new(writer);
// or
let writer = stderr().into_raw_mode()?.into_alternate_screen()?;
let backend = TermionBackend::new(stderr());
let mut terminal = Terminal::new(backend)?;

terminal.clear()?;
terminal.draw(|frame| {
    // -- snip --
})?;

Implementations

impl<W> TermionBackend<W>

where W: Write,

pub const fn new(writer: W) -> Self

Creates a new Termion backend with the given writer.

Example

let backend = TermionBackend::new(stdout());

Examples found in repository

examples/demo/termion.rs (line 21)

pub fn run(tick_rate: Duration, enhanced_graphics: bool) -> Result<(), Box<dyn Error>> {
    // setup terminal
    let stdout = io::stdout()
        .into_raw_mode()
        .unwrap()
        .into_alternate_screen()
        .unwrap();
    let stdout = MouseTerminal::from(stdout);
    let backend = TermionBackend::new(stdout);
    let mut terminal = Terminal::new(backend)?;

    // create app and run it
    let app = App::new("Termion demo", enhanced_graphics);
    run_app(&mut terminal, app, tick_rate)?;

    Ok(())
}

Trait Implementations

impl<W> Backend for TermionBackend<W>

where W: Write,

fn clear(&mut self) -> Result<()>

Clears the whole terminal screen

fn clear_region(&mut self, clear_type: ClearType) -> Result<()>

Clears a specific region of the terminal specified by the ClearType parameter

fn append_lines(&mut self, n: u16) -> Result<()>

Insert n line breaks to the terminal screen.

fn hide_cursor(&mut self) -> Result<()>

Hide the cursor on the terminal screen.

fn show_cursor(&mut self) -> Result<()>

Show the cursor on the terminal screen.

fn get_cursor(&mut self) -> Result<(u16, u16)>

Get the current cursor position on the terminal screen.

fn set_cursor(&mut self, x: u16, y: u16) -> Result<()>

Set the cursor position on the terminal screen to the given x and y coordinates.

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

where I: Iterator<Item = (u16, u16, &'a Cell)>,

Draw the given content to the terminal screen.

fn size(&self) -> Result<Rect>

Get the size of the terminal screen in columns/rows as a Rect.

fn window_size(&mut self) -> Result<WindowSize>

Get the size of the terminal screen in columns/rows and pixels as a WindowSize.

fn flush(&mut self) -> Result<()>

Flush any buffered content to the terminal screen.

impl<W> Clone for TermionBackend<W>

where W: Write + Clone,

fn clone(&self) -> TermionBackend<W>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<W> Debug for TermionBackend<W>

where W: Write + Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<W> Default for TermionBackend<W>

where W: Write + Default,

fn default() -> TermionBackend<W>

Returns the “default value” for a type.

impl<W> Hash for TermionBackend<W>

where W: Write + Hash,

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<W> PartialEq for TermionBackend<W>

where W: Write + PartialEq,

fn eq(&self, other: &TermionBackend<W>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<W> Write for TermionBackend<W>

where W: Write,

fn write(&mut self, buf: &[u8]) -> Result<usize>

Write a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> Result<()>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

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

Determines if this Writer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

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

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Write.

impl<W> Eq for TermionBackend<W>

where W: Write + Eq,

impl<W> StructuralPartialEq for TermionBackend<W>

where W: Write,