Struct systemctl_tui::terminal::Tui

source ·

pub struct Tui {
    pub terminal: Terminal<CrosstermBackend<Stderr>>,
}

Fields§

§terminal: Terminal<CrosstermBackend<Stderr>>

Implementations§

source §

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

Methods from Deref<Target = Terminal<Backend<Stderr>>>§

source

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

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

source

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

Gets the current buffer as a mutable reference.

source

pub fn backend(&self) -> &B

Gets the backend

source

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

Gets the backend as a mutable reference

source

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.

source

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.

source

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

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

source

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);
})?;

source

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

Hides the cursor.

source

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

Shows the cursor.

source

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.

source

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

Sets the cursor position.

source

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

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

source

pub fn swap_buffers(&mut self)

Clears the inactive buffer and swaps it with the current buffer

source

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

Queries the real size of the backend.

source

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);
});