Files
radicle-tui/src/terminal.rs
T

147 lines
3.9 KiB
Rust

use std::io::{self, Write};
use std::thread;
use std::time::Instant;
use termion::input::TermRead;
use termion::raw::{IntoRawMode, RawTerminal};
use ratatui::prelude::*;
use ratatui::{TerminalOptions, Viewport};
use tokio::sync::mpsc::{self};
use super::event::Event;
pub type Backend = TermionBackendExt<RawTerminal<io::Stdout>>;
/// FIXME Remove workaround after a new `ratatui` version with
/// https://github.com/ratatui-org/ratatui/pull/981/ included was released.
pub struct TermionBackendExt<W>
where
W: Write,
{
cursor: Option<(u16, u16)>,
inner: TermionBackend<W>,
}
impl<W> TermionBackendExt<W>
where
W: Write,
{
pub fn new(writer: W) -> Self {
Self {
cursor: None,
inner: TermionBackend::new(writer),
}
}
}
impl<W: Write> ratatui::backend::Backend for TermionBackendExt<W> {
fn draw<'a, I>(&mut self, content: I) -> io::Result<()>
where
I: Iterator<Item = (u16, u16, &'a buffer::Cell)>,
{
self.inner.draw(content)
}
fn append_lines(&mut self, n: u16) -> io::Result<()> {
self.inner.append_lines(n)
}
fn hide_cursor(&mut self) -> io::Result<()> {
self.inner.hide_cursor()
}
fn show_cursor(&mut self) -> io::Result<()> {
self.inner.show_cursor()
}
fn get_cursor(&mut self) -> io::Result<(u16, u16)> {
match self.inner.get_cursor() {
Ok((x, y)) => {
let cursor = (x.saturating_sub(0), y.saturating_sub(0));
self.cursor = Some(cursor);
Ok(cursor)
}
Err(_) => Ok(self.cursor.unwrap_or((0, 0))),
}
}
fn set_cursor(&mut self, x: u16, y: u16) -> io::Result<()> {
self.cursor = Some((x, y));
self.inner.set_cursor(x, y)
}
fn clear(&mut self) -> io::Result<()> {
self.inner.clear()
}
fn clear_region(&mut self, clear_type: backend::ClearType) -> io::Result<()> {
self.inner.clear_region(clear_type)
}
fn size(&self) -> io::Result<Rect> {
self.inner.size()
}
fn window_size(&mut self) -> io::Result<backend::WindowSize> {
self.inner.window_size()
}
fn flush(&mut self) -> io::Result<()> {
ratatui::backend::Backend::flush(&mut self.inner)
}
}
/// Setup a `Terminal` with inline viewport using the `termion` backend.
pub fn setup(viewport: Viewport) -> anyhow::Result<Terminal<Backend>> {
let is_fullscreen = viewport == Viewport::Fullscreen;
let stdout = io::stdout().into_raw_mode()?;
let options = TerminalOptions { viewport };
let mut terminal = Terminal::with_options(TermionBackendExt::new(stdout), options)?;
if is_fullscreen {
terminal.clear()?;
}
Ok(terminal)
}
/// Restore the `Terminal` on quit.
pub fn restore(terminal: &mut Terminal<Backend>) -> anyhow::Result<()> {
terminal.clear()?;
Ok(())
}
/// Spawn one thread that polls `stdin` for new user input and another thread
/// that polls UNIX signals, e.g. `SIGWINCH` when the terminal window size is
/// being changed.
pub fn events() -> mpsc::UnboundedReceiver<Event> {
let (tx, rx) = mpsc::unbounded_channel();
let events_tx = tx.clone();
thread::spawn(move || {
let start = Instant::now();
let stdin = io::stdin();
for key in stdin.keys().flatten() {
// TODO(erikli): Remove this hack! Perhaps use `tokio::CancellationToken`?
if start.elapsed().as_millis() > 200 {
if events_tx.send(Event::Key(key)).is_err() {
return;
}
}
}
});
let events_tx = tx.clone();
if let Ok(mut signals) = signal_hook::iterator::Signals::new([libc::SIGWINCH]) {
thread::spawn(move || {
for _ in signals.forever() {
if events_tx.send(Event::Resize).is_err() {
return;
}
}
});
}
rx
}