use std::io::{self, Stdout, Write};
use std::sync::atomic::{AtomicBool, Ordering};
use crossterm::event::{
DisableBracketedPaste, DisableMouseCapture, EnableBracketedPaste, EnableMouseCapture,
KeyboardEnhancementFlags, PopKeyboardEnhancementFlags, PushKeyboardEnhancementFlags,
};
use crossterm::terminal::{
disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen,
};
use crossterm::{cursor, execute};
use ratatui::backend::CrosstermBackend;
use ratatui::Terminal;
pub type Tui = Terminal<CrosstermBackend<Stdout>>;
struct TerminalState {
raw_mode: AtomicBool,
alternate_screen: AtomicBool,
mouse_capture: AtomicBool,
bracketed_paste: AtomicBool,
keyboard_enhancement: AtomicBool,
}
static STATE: TerminalState = TerminalState {
raw_mode: AtomicBool::new(false),
alternate_screen: AtomicBool::new(false),
mouse_capture: AtomicBool::new(false),
bracketed_paste: AtomicBool::new(false),
keyboard_enhancement: AtomicBool::new(false),
};
pub fn keyboard_enhancement_active() -> bool {
STATE.keyboard_enhancement.load(Ordering::SeqCst)
}
pub fn mouse_capture_active() -> bool {
STATE.mouse_capture.load(Ordering::SeqCst)
}
pub fn setup(mouse: bool) -> io::Result<Tui> {
match try_setup(mouse) {
Ok(terminal) => Ok(terminal),
Err(e) => {
let _ = restore();
Err(e)
}
}
}
fn try_setup(mouse: bool) -> io::Result<Tui> {
let mut stdout = io::stdout();
enable_raw_mode()?;
STATE.raw_mode.store(true, Ordering::SeqCst);
execute!(stdout, EnterAlternateScreen)?;
STATE.alternate_screen.store(true, Ordering::SeqCst);
execute!(stdout, EnableBracketedPaste)?;
STATE.bracketed_paste.store(true, Ordering::SeqCst);
if mouse {
set_mouse_capture(true)?;
}
if crossterm::terminal::supports_keyboard_enhancement().unwrap_or(false) {
execute!(
stdout,
PushKeyboardEnhancementFlags(
KeyboardEnhancementFlags::DISAMBIGUATE_ESCAPE_CODES
| KeyboardEnhancementFlags::REPORT_ALTERNATE_KEYS
)
)?;
STATE.keyboard_enhancement.store(true, Ordering::SeqCst);
}
let mut terminal = Terminal::new(CrosstermBackend::new(io::stdout()))?;
terminal.hide_cursor()?;
Ok(terminal)
}
pub fn set_mouse_capture(enabled: bool) -> io::Result<()> {
let mut stdout = io::stdout();
if enabled {
execute!(stdout, EnableMouseCapture)?;
} else {
execute!(stdout, DisableMouseCapture)?;
}
STATE.mouse_capture.store(enabled, Ordering::SeqCst);
Ok(())
}
pub fn restore() -> io::Result<()> {
let mut stdout = io::stdout();
let mut first_error = None;
let mut attempt = |result: io::Result<()>| {
if let Err(e) = result {
first_error.get_or_insert(e);
}
};
if STATE.keyboard_enhancement.swap(false, Ordering::SeqCst) {
attempt(execute!(stdout, PopKeyboardEnhancementFlags));
}
if STATE.mouse_capture.swap(false, Ordering::SeqCst) {
attempt(execute!(stdout, DisableMouseCapture));
}
if STATE.bracketed_paste.swap(false, Ordering::SeqCst) {
attempt(execute!(stdout, DisableBracketedPaste));
}
if STATE.alternate_screen.swap(false, Ordering::SeqCst) {
attempt(execute!(stdout, LeaveAlternateScreen));
}
if STATE.raw_mode.swap(false, Ordering::SeqCst) {
attempt(disable_raw_mode());
}
attempt(execute!(stdout, cursor::Show));
attempt(stdout.flush());
match first_error {
Some(e) => Err(e),
None => Ok(()),
}
}
pub fn install_panic_hook() {
let previous = std::panic::take_hook();
std::panic::set_hook(Box::new(move |info| {
let _ = restore();
previous(info);
}));
}
pub fn copy_to_clipboard(text: &str) -> std::io::Result<()> {
use base64_encode as encode;
use std::io::Write as _;
let mut out = std::io::stdout().lock();
write!(out, "\x1b]52;c;{}\x07", encode(text.as_bytes()))?;
out.flush()
}
fn base64_encode(bytes: &[u8]) -> String {
const ALPHABET: &[u8; 64] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
let mut out = String::with_capacity(bytes.len().div_ceil(3) * 4);
for chunk in bytes.chunks(3) {
let b = [
chunk[0],
chunk.get(1).copied().unwrap_or(0),
chunk.get(2).copied().unwrap_or(0),
];
let triple = (u32::from(b[0]) << 16) | (u32::from(b[1]) << 8) | u32::from(b[2]);
for i in 0..4 {
if i <= chunk.len() {
let index = (triple >> (18 - 6 * i)) & 0x3f;
out.push(ALPHABET[index as usize] as char);
} else {
out.push('=');
}
}
}
out
}
#[cfg(test)]
mod clipboard_tests {
use super::base64_encode;
#[test]
fn base64_matches_the_standard_vectors() {
assert_eq!(base64_encode(b""), "");
assert_eq!(base64_encode(b"f"), "Zg==");
assert_eq!(base64_encode(b"fo"), "Zm8=");
assert_eq!(base64_encode(b"foo"), "Zm9v");
assert_eq!(base64_encode(b"foob"), "Zm9vYg==");
assert_eq!(base64_encode(b"fooba"), "Zm9vYmE=");
assert_eq!(base64_encode(b"foobar"), "Zm9vYmFy");
}
#[test]
fn base64_handles_non_ascii() {
assert_eq!(base64_encode("ışık".as_bytes()), "xLHFn8Sxaw==");
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn restore_is_idempotent_when_nothing_was_set_up() {
assert!(!STATE.raw_mode.load(Ordering::SeqCst));
assert!(restore().is_ok());
assert!(restore().is_ok());
}
}