Struct node_launchpad::tui::Tui

pub struct Tui {
    pub terminal: Terminal<CrosstermBackend<IO>>,
    pub task: JoinHandle<()>,
    pub cancellation_token: CancellationToken,
    pub event_rx: UnboundedReceiver<Event>,
    pub event_tx: UnboundedSender<Event>,
    pub frame_rate: f64,
    pub tick_rate: f64,
    pub mouse: bool,
    pub paste: bool,
}

Fields

terminal: Terminal<CrosstermBackend<IO>>

task: JoinHandle<()>

cancellation_token: CancellationToken

event_rx: UnboundedReceiver<Event>

event_tx: UnboundedSender<Event>

frame_rate: f64

tick_rate: f64

mouse: bool

paste: bool

Implementations

impl Tui

pub fn new() -> Result<Self>

pub fn tick_rate(self, tick_rate: f64) -> Self

pub fn frame_rate(self, frame_rate: f64) -> Self

pub fn mouse(self, mouse: bool) -> Self

pub fn paste(self, paste: bool) -> Self

pub fn start(&mut self)

pub fn stop(&self) -> Result<()>

pub fn enter(&mut self) -> Result<()>

pub fn exit(&mut self) -> Result<()>

pub fn cancel(&self)

pub fn suspend(&mut self) -> Result<()>

pub fn resume(&mut self) -> Result<()>

pub async fn next(&mut self) -> Option<Event>

Methods from Deref<Target = Terminal<Backend<IO>>>

pub fn get_frame(&mut self) -> Frame<'_>

Get a Frame object which provides a consistent view into the terminal state for rendering.

pub fn current_buffer_mut(&mut self) -> &mut Buffer

Gets the current buffer as a mutable reference.

pub fn backend(&self) -> &B

Gets the backend

pub fn backend_mut(&mut self) -> &mut B

Gets the backend as a mutable reference

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

Obtains a difference between the previous and the current buffer and passes it to the current backend for drawing.

pub fn resize(&mut self, size: Rect) -> Result<(), Error>

Updates the Terminal so that internal buffers match the requested size.

Requested size will be saved so the size can remain consistent when rendering. This leads to a full clear of the screen.

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

Queries the backend for size and resizes if it doesn’t match the previous size.

pub fn draw<F>(&mut self, f: F) -> Result<CompletedFrame<'_>, Error>

where F: FnOnce(&mut Frame<'_>),

Synchronizes terminal size, calls the rendering closure, flushes the current internal state and prepares for the next draw call.

This is the main entry point for drawing to the terminal.

The changes drawn to the frame are applied only to the current Buffer. After the closure returns, the current buffer is compared to the previous buffer and only the changes are applied to the terminal.

Examples

let backend = CrosstermBackend::new(stdout());
let mut terminal = Terminal::new(backend)?;
terminal.draw(|frame| {
    let area = frame.size();
    frame.render_widget(Paragraph::new("Hello World!"), area);
    frame.set_cursor(0, 0);
})?;

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

Hides the cursor.

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

Shows the cursor.

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

Gets the current cursor position.

This is the position of the cursor after the last draw call and is returned as a tuple of (x, y) coordinates.

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

Sets the cursor position.

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

Clear the terminal and force a full redraw on the next draw call.

pub fn swap_buffers(&mut self)

Clears the inactive buffer and swaps it with the current buffer

pub fn size(&self) -> Result<Rect, Error>

Queries the real size of the backend.

pub fn insert_before<F>(&mut self, height: u16, draw_fn: F) -> Result<(), Error>

where F: FnOnce(&mut Buffer),

Insert some content before the current inline viewport. This has no effect when the viewport is fullscreen.

This function scrolls down the current viewport by the given height. The newly freed space is then made available to the draw_fn closure through a writable Buffer.

Before:

+-------------------+
|                   |
|      viewport     |
|                   |
+-------------------+

After:

+-------------------+
|      buffer       |
+-------------------+
+-------------------+
|                   |
|      viewport     |
|                   |
+-------------------+

Examples

Insert a single line before the current viewport

terminal.insert_before(1, |buf| {
    Paragraph::new(Line::from(vec![
        Span::raw("This line will be added "),
        Span::styled("before", Style::default().fg(Color::Blue)),
        Span::raw(" the current viewport"),
    ]))
    .render(buf.area, buf);
});

Trait Implementations

impl Deref for Tui

type Target = Terminal<CrosstermBackend<Stdout>>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for Tui

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl Drop for Tui

fn drop(&mut self)

Executes the destructor for this type.