mirror of
https://seed.radicle.dev/rad:z39mP9rQAaGmERfUMPULfPUi473tY.git
synced 2026-11-21 02:20:48 +08:00
147 lines
3.9 KiB
Rust
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
|
|
}
|