use std::io::{Stdout, Write};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::mpsc::{Receiver, Sender, channel};
use std::sync::{Arc, Mutex};
use std::thread;
use std::time::Duration;
use crate::SessionControl;
use crossterm::event::{Event, KeyCode, KeyEvent as CrosstermKeyEvent, KeyEventKind, KeyModifiers};
use engine::io::{InputMode, Key, KeyEvent, Size, Terminal};
use terminal::{Color, Style, TerminalModel};
pub struct HostTerminal {
model: Arc<Mutex<TerminalModel>>,
control: SessionControl,
}
impl HostTerminal {
pub fn new(size: Size, control: SessionControl) -> Self {
Self {
model: Arc::new(Mutex::new(TerminalModel::new(size))),
control,
}
}
pub fn model(&self) -> &Arc<Mutex<TerminalModel>> {
&self.model
}
}
impl Terminal for HostTerminal {
fn size(&self) -> Size {
self.model.lock().expect("model lock poisoned").size()
}
fn next_key(&mut self) -> Option<KeyEvent> {
loop {
if self.control.interruption().is_some() {
return Some(KeyEvent::ctrl('c'));
}
if let Some(key) = self.model.lock().expect("model lock poisoned").next_key() {
return Some(key);
}
thread::sleep(KEY_POLL);
}
}
fn push_keys(&mut self, keys: &[KeyEvent]) {
self.model
.lock()
.expect("model lock poisoned")
.push_keys(keys);
}
fn write(&mut self, bytes: &[u8]) {
self.model.lock().expect("model lock poisoned").write(bytes);
}
fn enter_alternate_screen(&mut self) {
self.model
.lock()
.expect("model lock poisoned")
.enter_alternate_screen();
}
fn leave_alternate_screen(&mut self) {
self.model
.lock()
.expect("model lock poisoned")
.leave_alternate_screen();
}
fn input_mode(&self) -> InputMode {
self.model.lock().expect("model lock poisoned").input_mode()
}
fn set_input_mode(&mut self, mode: InputMode) {
self.model
.lock()
.expect("model lock poisoned")
.set_input_mode(mode);
}
fn flush(&mut self) {}
}
#[derive(Clone)]
pub struct TerminalOutput {
model: Arc<Mutex<TerminalModel>>,
}
impl TerminalOutput {
pub fn new(terminal: &HostTerminal) -> Self {
Self {
model: Arc::clone(terminal.model()),
}
}
}
impl engine::Output for TerminalOutput {
fn write(&mut self, bytes: &[u8]) -> Result<(), engine::OutputError> {
self.model.lock().expect("model lock poisoned").write(bytes);
Ok(())
}
}
pub struct TerminalInput {
model: Arc<Mutex<TerminalModel>>,
pending: Vec<u8>,
control: SessionControl,
}
impl TerminalInput {
pub fn new(terminal: &HostTerminal) -> Self {
Self {
model: Arc::clone(terminal.model()),
pending: Vec::new(),
control: terminal.control.clone(),
}
}
}
impl engine::Input for TerminalInput {
fn read(&mut self, buffer: &mut [u8]) -> Result<usize, engine::InputError> {
if buffer.is_empty() {
return Ok(0);
}
if self.control.interruption().is_some() {
return Ok(0);
}
if !self.pending.is_empty() {
let count = buffer.len().min(self.pending.len());
buffer[..count].copy_from_slice(&self.pending[..count]);
self.pending.drain(..count);
return Ok(count);
}
let mut bytes: Vec<u8> = Vec::new();
while bytes.is_empty() {
let key = {
let mut model = self.model.lock().expect("model lock poisoned");
model.next_key()
};
let Some(key) = key else {
thread::sleep(KEY_POLL);
continue;
};
match key.key {
Key::Character if !key.ctrl && !key.alt => {
if let Some(character) = key.character {
let mut encoded = [0u8; 4];
bytes.extend_from_slice(character.encode_utf8(&mut encoded).as_bytes());
}
}
Key::Enter => bytes.push(b'\n'),
Key::Backspace => bytes.push(0x7f),
Key::Tab => bytes.push(b'\t'),
Key::Escape => bytes.push(0x1b),
Key::Character if key.ctrl && key.character == Some('d') => return Ok(0),
Key::Character if key.ctrl && key.character == Some('c') => {
bytes.push(0x03);
}
_ => {}
}
}
let count = bytes.len().min(buffer.len());
buffer[..count].copy_from_slice(&bytes[..count]);
self.pending.extend_from_slice(&bytes[count..]);
Ok(count)
}
}
pub fn render(
host: &mut Stdout,
model: &TerminalModel,
last_version: &mut u64,
) -> std::io::Result<()> {
if model.version() == *last_version {
return Ok(());
}
*last_version = model.version();
let size = model.size();
let screen = model.visible_screen();
let first_frame = *last_version == 0;
let mut frame = String::new();
frame.push_str("\x1b[0m\x1b[H");
if first_frame {
frame.push_str("\x1b[2J");
}
for (index, row) in screen.rows().enumerate() {
frame.push_str(&format!("\x1b[{};1H", index + 1));
frame.push_str("\x1b[K");
let width = usize::from(size.cols);
let mut styled = String::new();
let mut current = Style::plain();
for cell in row {
if cell.style != current {
push_style_reset(&mut styled, ¤t);
current = cell.style;
push_style(&mut styled, ¤t);
}
styled.push(cell.ch);
}
push_style_reset(&mut styled, ¤t);
let cell_count = styled.chars().count();
if cell_count < width {
styled.push_str(&" ".repeat(width - cell_count));
}
frame.push_str(&styled);
}
let (row, col) = screen.cursor();
frame.push_str(&format!("\x1b[{};{}H", row + 1, col + 1));
if model.cursor_visible() {
frame.push_str("\x1b[?25h");
} else {
frame.push_str("\x1b[?25l");
}
host.write_all(frame.as_bytes())?;
host.flush()
}
fn push_style_reset(out: &mut String, style: &Style) {
if *style != Style::plain() {
out.push_str("\x1b[0m");
}
}
fn push_style(out: &mut String, style: &Style) {
let mut params: Vec<String> = Vec::new();
if style.bold {
params.push("1".to_owned());
}
if style.underline {
params.push("4".to_owned());
}
if style.reverse {
params.push("7".to_owned());
}
match style.fg {
Color::Default => {}
Color::Standard(n) if n < 8 => params.push(format!("{}", 30 + n)),
Color::Standard(n) => params.push(format!("{}", 90 + n - 8)),
Color::Rgb(r, g, b) => params.push(format!("38;2;{r};{g};{b}")),
}
match style.bg {
Color::Default => {}
Color::Standard(n) if n < 8 => params.push(format!("{}", 40 + n)),
Color::Standard(n) => params.push(format!("{}", 100 + n - 8)),
Color::Rgb(r, g, b) => params.push(format!("48;2;{r};{g};{b}")),
}
if params.is_empty() {
return;
}
out.push_str("\x1b[");
out.push_str(¶ms.join(";"));
out.push('m');
}
const RENDER_POLL: Duration = Duration::from_millis(16);
const SIZE_CHECK_POLL: Duration = Duration::from_millis(250);
const KEY_POLL: Duration = Duration::from_millis(4);
pub fn spawn_render_watcher(
model: Arc<Mutex<TerminalModel>>,
in_command: Arc<AtomicBool>,
host_lock: Arc<Mutex<Stdout>>,
last_version: Arc<Mutex<u64>>,
stop: Arc<AtomicBool>,
) {
thread::spawn(move || {
let mut last_known_size = model.lock().expect("model lock poisoned").size();
let mut size_elapsed = Duration::ZERO;
loop {
if stop.load(Ordering::Relaxed) {
break;
}
thread::sleep(RENDER_POLL);
size_elapsed += RENDER_POLL;
if size_elapsed >= SIZE_CHECK_POLL {
size_elapsed = Duration::ZERO;
if let Ok((cols, rows)) = crossterm::terminal::size()
&& rows > 0
&& cols > 0
{
let size = Size::new(rows, cols);
if size != last_known_size {
last_known_size = size;
model.lock().expect("model lock poisoned").resize(size);
let model = model.lock().expect("model lock poisoned");
let mut version = last_version.lock().expect("version lock poisoned");
if model.version() != *version
&& let Ok(mut host) = host_lock.try_lock()
{
let _ = render(&mut host, &model, &mut version);
}
continue;
}
}
}
if in_command.load(Ordering::Relaxed) {
let model = model.lock().expect("model lock poisoned");
let mut version = last_version.lock().expect("version lock poisoned");
if model.version() != *version
&& let Ok(mut host) = host_lock.try_lock()
{
let _ = render(&mut host, &model, &mut version);
}
}
}
});
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
enum KeyDestination {
Prompt,
Command,
}
pub fn spawn_key_reader(
model: Arc<Mutex<TerminalModel>>,
) -> (Sender<KeyEvent>, Receiver<KeyEvent>, Arc<AtomicBool>) {
let (sender, receiver) = channel();
let key_sender = sender.clone();
let in_command = Arc::new(AtomicBool::new(false));
let in_command_flag = Arc::clone(&in_command);
thread::spawn(move || {
loop {
let Ok(event) = crossterm::event::read() else {
continue;
};
match event {
Event::Key(crossterm_key) => {
let destination = if in_command_flag.load(Ordering::Relaxed) {
KeyDestination::Command
} else {
KeyDestination::Prompt
};
forward_key(crossterm_key, destination, &model, &key_sender);
}
Event::Mouse(mouse) => {
let destination = if in_command_flag.load(Ordering::Relaxed) {
KeyDestination::Command
} else {
continue;
};
use crossterm::event::MouseEventKind;
let scroll_key = match mouse.kind {
MouseEventKind::ScrollUp => Some(Key::ArrowUp),
MouseEventKind::ScrollDown => Some(Key::ArrowDown),
_ => None,
};
if let Some(key) = scroll_key {
route_event(KeyEvent::special(key), destination, &model, &key_sender);
}
}
Event::Resize(cols, rows) => {
model
.lock()
.expect("model lock poisoned")
.resize(Size::new(rows, cols));
}
_ => {}
}
}
});
(sender, receiver, in_command)
}
fn forward_key(
key: CrosstermKeyEvent,
destination: KeyDestination,
model: &Arc<Mutex<TerminalModel>>,
sender: &Sender<KeyEvent>,
) {
if let Some(event) = translate_key(&key) {
route_event(event, destination, model, sender);
}
}
fn route_event(
event: KeyEvent,
destination: KeyDestination,
model: &Arc<Mutex<TerminalModel>>,
sender: &Sender<KeyEvent>,
) {
match destination {
KeyDestination::Command => {
model
.lock()
.expect("model lock poisoned")
.push_keys(&[event]);
}
KeyDestination::Prompt => {
let _ = sender.send(event);
}
}
}
pub(crate) fn translate_key(key: &CrosstermKeyEvent) -> Option<KeyEvent> {
if key.kind == KeyEventKind::Release {
return None;
}
let ctrl = key.modifiers.contains(KeyModifiers::CONTROL);
let alt = key.modifiers.contains(KeyModifiers::ALT);
let shift = key.modifiers.contains(KeyModifiers::SHIFT);
let mut event = match key.code {
KeyCode::Char('\n' | '\r' | 'j' | 'm')
if ctrl || matches!(key.code, KeyCode::Char('\n' | '\r')) =>
{
KeyEvent::special(Key::Enter)
}
KeyCode::Char('\t' | 'i') if ctrl || key.code == KeyCode::Char('\t') => {
KeyEvent::special(Key::Tab)
}
KeyCode::Char('\u{8}' | '\u{7f}' | 'h')
if ctrl || matches!(key.code, KeyCode::Char('\u{8}' | '\u{7f}')) =>
{
KeyEvent::special(Key::Backspace)
}
KeyCode::Char(ch) => {
if ctrl && (ch == 'c' || ch == 'd' || ch == 'o' || ch == 'x' || ch == 'z') {
KeyEvent {
key: Key::Character,
character: Some(ch.to_ascii_lowercase()),
ctrl: true,
alt,
shift,
}
} else {
KeyEvent {
key: Key::Character,
character: Some(ch),
ctrl,
alt,
shift,
}
}
}
KeyCode::Esc => KeyEvent::special(Key::Escape),
KeyCode::Enter => KeyEvent::special(Key::Enter),
KeyCode::Backspace => KeyEvent::special(Key::Backspace),
KeyCode::Tab | KeyCode::BackTab => KeyEvent::special(Key::Tab),
KeyCode::Up => KeyEvent::special(Key::ArrowUp),
KeyCode::Down => KeyEvent::special(Key::ArrowDown),
KeyCode::Left => KeyEvent::special(Key::ArrowLeft),
KeyCode::Right => KeyEvent::special(Key::ArrowRight),
KeyCode::Home => KeyEvent::special(Key::Home),
KeyCode::End => KeyEvent::special(Key::End),
KeyCode::PageUp => KeyEvent::special(Key::PageUp),
KeyCode::PageDown => KeyEvent::special(Key::PageDown),
KeyCode::Delete => KeyEvent::special(Key::Delete),
KeyCode::Insert => KeyEvent::special(Key::Insert),
KeyCode::F(n) => KeyEvent::special(Key::Function(n)),
_ => return None,
};
event.ctrl = ctrl;
event.alt = alt;
event.shift = shift || key.code == KeyCode::BackTab;
Some(event)
}
#[cfg(test)]
mod tests {
use super::*;
fn key(code: KeyCode, modifiers: KeyModifiers) -> CrosstermKeyEvent {
CrosstermKeyEvent::new_with_kind(code, modifiers, KeyEventKind::Press)
}
#[test]
fn host_characters_preserve_unicode() {
assert_eq!(
translate_key(&key(KeyCode::Char('a'), KeyModifiers::NONE)),
Some(KeyEvent::character('a'))
);
assert_eq!(
translate_key(&key(KeyCode::Char('é'), KeyModifiers::NONE)),
Some(KeyEvent::character('é'))
);
assert_eq!(
translate_key(&key(KeyCode::Char('🔐'), KeyModifiers::NONE)),
Some(KeyEvent::character('🔐'))
);
}
#[test]
fn host_key_modifiers_are_not_lost() {
let control = translate_key(&key(KeyCode::Char('c'), KeyModifiers::CONTROL)).unwrap();
assert_eq!(control, KeyEvent::ctrl('c'));
let shifted = translate_key(&key(KeyCode::Left, KeyModifiers::SHIFT)).unwrap();
assert_eq!(shifted.key, Key::ArrowLeft);
assert!(shifted.shift);
let back_tab = translate_key(&key(KeyCode::BackTab, KeyModifiers::SHIFT)).unwrap();
assert_eq!(back_tab.key, Key::Tab);
assert!(back_tab.shift);
}
#[test]
fn pasted_control_characters_keep_key_semantics() {
for character in ['\n', '\r'] {
assert_eq!(
translate_key(&key(KeyCode::Char(character), KeyModifiers::NONE)),
Some(KeyEvent::special(Key::Enter))
);
}
assert_eq!(
translate_key(&key(KeyCode::Char('\t'), KeyModifiers::NONE)),
Some(KeyEvent::special(Key::Tab))
);
assert_eq!(
translate_key(&key(KeyCode::Char('j'), KeyModifiers::CONTROL)),
Some(KeyEvent {
ctrl: true,
..KeyEvent::special(Key::Enter)
})
);
}
#[test]
fn key_release_events_do_not_duplicate_input() {
let released = CrosstermKeyEvent::new_with_kind(
KeyCode::Char('a'),
KeyModifiers::NONE,
KeyEventKind::Release,
);
assert_eq!(translate_key(&released), None);
}
}