mirror of https://github.com/fdehau/tui-rs
You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
184 lines
5.1 KiB
Rust
184 lines
5.1 KiB
Rust
use std::io;
|
|
|
|
use backend::Backend;
|
|
use buffer::Buffer;
|
|
use layout::Rect;
|
|
use widgets::Widget;
|
|
|
|
/// Interface to the terminal backed by Termion
|
|
#[derive(Debug)]
|
|
pub struct Terminal<B>
|
|
where
|
|
B: Backend,
|
|
{
|
|
backend: B,
|
|
/// Holds the results of the current and previous draw calls. The two are compared at the end
|
|
/// of each draw pass to output the necessary updates to the terminal
|
|
buffers: [Buffer; 2],
|
|
/// Index of the current buffer in the previous array
|
|
current: usize,
|
|
/// Whether the cursor is currently hidden
|
|
hidden_cursor: bool,
|
|
/// Terminal size used for rendering.
|
|
known_size: Rect,
|
|
}
|
|
|
|
/// Represents a consistent terminal interface for rendering.
|
|
pub struct Frame<'a, B: 'a>
|
|
where
|
|
B: Backend,
|
|
{
|
|
terminal: &'a mut Terminal<B>,
|
|
}
|
|
|
|
impl<'a, B> Frame<'a, B>
|
|
where
|
|
B: Backend,
|
|
{
|
|
/// Terminal size, guaranteed not to change when rendering.
|
|
pub fn size(&self) -> Rect {
|
|
self.terminal.known_size
|
|
}
|
|
|
|
/// Calls the draw method of a given widget on the current buffer
|
|
pub fn render<W>(&mut self, widget: &mut W, area: Rect)
|
|
where
|
|
W: Widget,
|
|
{
|
|
widget.draw(area, self.terminal.current_buffer_mut());
|
|
}
|
|
}
|
|
|
|
impl<B> Drop for Terminal<B>
|
|
where
|
|
B: Backend,
|
|
{
|
|
fn drop(&mut self) {
|
|
// Attempt to restore the cursor state
|
|
if self.hidden_cursor {
|
|
if let Err(err) = self.show_cursor() {
|
|
error!("Failed to show the cursor: {}", err);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<B> Terminal<B>
|
|
where
|
|
B: Backend,
|
|
{
|
|
/// Wrapper around Termion initialization. Each buffer is initialized with a blank string and
|
|
/// default colors for the foreground and the background
|
|
pub fn new(backend: B) -> io::Result<Terminal<B>> {
|
|
let size = backend.size()?;
|
|
Ok(Terminal {
|
|
backend,
|
|
buffers: [Buffer::empty(size), Buffer::empty(size)],
|
|
current: 0,
|
|
hidden_cursor: false,
|
|
known_size: size,
|
|
})
|
|
}
|
|
|
|
/// Get a Frame object which provides a consistent view into the terminal state for rendering.
|
|
pub fn get_frame(&mut self) -> Frame<B> {
|
|
Frame { terminal: self }
|
|
}
|
|
|
|
pub fn current_buffer_mut(&mut self) -> &mut Buffer {
|
|
&mut self.buffers[self.current]
|
|
}
|
|
|
|
pub fn backend(&self) -> &B {
|
|
&self.backend
|
|
}
|
|
|
|
pub fn backend_mut(&mut self) -> &mut B {
|
|
&mut self.backend
|
|
}
|
|
|
|
/// Builds a string representing the minimal escape sequences and characters set necessary to
|
|
/// update the UI and writes it to stdout.
|
|
pub fn flush(&mut self) -> io::Result<()> {
|
|
let width = self.buffers[self.current].area.width;
|
|
let content = self.buffers[self.current]
|
|
.content
|
|
.iter()
|
|
.zip(self.buffers[1 - self.current].content.iter())
|
|
.enumerate()
|
|
.filter_map(|(i, (c, p))| {
|
|
if c != p {
|
|
let i = i as u16;
|
|
let x = i % width;
|
|
let y = i / width;
|
|
Some((x, y, c))
|
|
} else {
|
|
None
|
|
}
|
|
});
|
|
self.backend.draw(content)
|
|
}
|
|
|
|
/// 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 resize(&mut self, area: Rect) -> io::Result<()> {
|
|
self.buffers[self.current].resize(area);
|
|
self.buffers[1 - self.current].reset();
|
|
self.buffers[1 - self.current].resize(area);
|
|
self.known_size = area;
|
|
self.backend.clear()
|
|
}
|
|
|
|
/// Queries the backend for size and resizes if it doesn't match the previous size.
|
|
pub fn autoresize(&mut self) -> io::Result<()> {
|
|
let size = self.size()?;
|
|
if self.known_size != size {
|
|
self.resize(size)?;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Synchronizes terminal size, calls the rendering closure, flushes the current internal state
|
|
/// and prepares for the next draw call.
|
|
pub fn draw<F>(&mut self, f: F) -> io::Result<()>
|
|
where
|
|
F: FnOnce(Frame<B>),
|
|
{
|
|
// Autoresize - otherwise we get glitches if shrinking or potential desync between widgets
|
|
// and the terminal (if growing), which may OOB.
|
|
self.autoresize()?;
|
|
|
|
f(self.get_frame());
|
|
|
|
// Draw to stdout
|
|
self.flush()?;
|
|
|
|
// Swap buffers
|
|
self.buffers[1 - self.current].reset();
|
|
self.current = 1 - self.current;
|
|
|
|
// Flush
|
|
self.backend.flush()?;
|
|
Ok(())
|
|
}
|
|
|
|
pub fn hide_cursor(&mut self) -> io::Result<()> {
|
|
self.backend.hide_cursor()?;
|
|
self.hidden_cursor = true;
|
|
Ok(())
|
|
}
|
|
pub fn show_cursor(&mut self) -> io::Result<()> {
|
|
self.backend.show_cursor()?;
|
|
self.hidden_cursor = false;
|
|
Ok(())
|
|
}
|
|
pub fn clear(&mut self) -> io::Result<()> {
|
|
self.backend.clear()
|
|
}
|
|
/// Queries the real size of the backend.
|
|
pub fn size(&self) -> io::Result<Rect> {
|
|
self.backend.size()
|
|
}
|
|
}
|