use std::io::{Read, Write};
use std::path::Path;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex};
use anyhow::Result;
use portable_pty::{Child, CommandBuilder, MasterPty, PtySize, native_pty_system};
const SCROLLBACK_LINES: usize = 10_000;
pub struct TermSession {
pub parser: Arc<Mutex<vt100::Parser>>,
pub exited: Arc<AtomicBool>,
writer: Box<dyn Write + Send>,
master: Box<dyn MasterPty>,
child: Box<dyn Child + Send + Sync>,
rows: u16,
cols: u16,
}
impl TermSession {
pub fn spawn(command: Option<&str>, rows: u16, cols: u16, cwd: &Path) -> Result<Self> {
let pty = native_pty_system();
let pair = pty.openpty(PtySize {
rows,
cols,
pixel_width: 0,
pixel_height: 0,
})?;
let shell = std::env::var("SHELL").unwrap_or_else(|_| "/bin/sh".to_string());
let mut cmd = match command {
Some(script) => {
let mut c = CommandBuilder::new(&shell);
c.arg("-c");
c.arg(script);
c
}
None => CommandBuilder::new(&shell),
};
cmd.cwd(cwd);
cmd.env("TERM", "xterm-256color");
let child = pair.slave.spawn_command(cmd)?;
drop(pair.slave);
let writer = pair.master.take_writer()?;
let mut reader = pair.master.try_clone_reader()?;
let parser = Arc::new(Mutex::new(vt100::Parser::new(rows, cols, SCROLLBACK_LINES)));
let exited = Arc::new(AtomicBool::new(false));
{
let parser = Arc::clone(&parser);
let exited = Arc::clone(&exited);
std::thread::spawn(move || {
let mut buf = [0u8; 8192];
loop {
match reader.read(&mut buf) {
Ok(0) | Err(_) => {
exited.store(true, Ordering::SeqCst);
break;
}
Ok(n) => parser.lock().unwrap().process(&buf[..n]),
}
}
});
}
Ok(TermSession {
parser,
exited,
writer,
master: pair.master,
child,
rows,
cols,
})
}
pub fn exited(&self) -> bool {
self.exited.load(Ordering::SeqCst)
}
pub fn write_input(&mut self, bytes: &[u8]) {
{
let mut p = self.parser.lock().unwrap();
if p.screen().scrollback() > 0 {
p.set_scrollback(0);
}
}
let _ = self.writer.write_all(bytes);
let _ = self.writer.flush();
}
pub fn scroll_lines(&mut self, delta: isize) {
let mut p = self.parser.lock().unwrap();
let cur = p.screen().scrollback() as isize;
let new = (cur + delta).max(0) as usize;
p.set_scrollback(new);
}
pub fn wheel(&mut self, up: bool, col: u16, row: u16) {
let to_child = {
let p = self.parser.lock().unwrap();
wheel_bytes(p.screen(), up, col, row)
};
match to_child {
Some(bytes) => self.write_input(&bytes),
None => self.scroll_lines(if up { 3 } else { -3 }),
}
}
pub fn click(&mut self, col: u16, row: u16) -> bool {
let report = {
let p = self.parser.lock().unwrap();
click_bytes(p.screen(), col, row)
};
match report {
Some(bytes) => {
self.write_input(&bytes);
true
}
None => false,
}
}
pub fn scroll_page(&mut self, up: bool) {
let half = (self.rows / 2).max(1) as isize;
self.scroll_lines(if up { half } else { -half });
}
pub fn scroll_offset(&self) -> usize {
self.parser.lock().unwrap().screen().scrollback()
}
pub fn scroll_info(&self) -> (usize, usize) {
let mut p = self.parser.lock().unwrap();
let cur = p.screen().scrollback();
p.set_scrollback(usize::MAX);
let avail = p.screen().scrollback();
p.set_scrollback(cur);
(cur, avail)
}
pub fn resize(&mut self, rows: u16, cols: u16) {
if rows == self.rows && cols == self.cols {
return;
}
self.rows = rows;
self.cols = cols;
let _ = self.master.resize(PtySize {
rows,
cols,
pixel_width: 0,
pixel_height: 0,
});
self.parser.lock().unwrap().set_size(rows, cols);
}
pub fn kill(&mut self) {
let _ = self.child.kill();
let _ = self.child.wait();
}
}
fn wheel_bytes(screen: &vt100::Screen, up: bool, col: u16, row: u16) -> Option<Vec<u8>> {
if screen.mouse_protocol_mode() != vt100::MouseProtocolMode::None {
return Some(mouse_report(
screen,
if up { 64 } else { 65 },
col,
row,
true,
));
}
if screen.alternate_screen() {
let arrow: &[u8] = match (screen.application_cursor(), up) {
(true, true) => b"\x1bOA",
(true, false) => b"\x1bOB",
(false, true) => b"\x1b[A",
(false, false) => b"\x1b[B",
};
return Some(arrow.repeat(3));
}
None
}
fn click_bytes(screen: &vt100::Screen, col: u16, row: u16) -> Option<Vec<u8>> {
if screen.mouse_protocol_mode() == vt100::MouseProtocolMode::None {
return None;
}
let mut bytes = mouse_report(screen, 0, col, row, true);
bytes.extend(mouse_report(screen, 0, col, row, false));
Some(bytes)
}
fn mouse_report(screen: &vt100::Screen, button: u8, col: u16, row: u16, press: bool) -> Vec<u8> {
let (x, y) = (u32::from(col) + 1, u32::from(row) + 1);
if screen.mouse_protocol_encoding() == vt100::MouseProtocolEncoding::Sgr {
let suffix = if press { 'M' } else { 'm' };
return format!("\x1b[<{button};{x};{y}{suffix}").into_bytes();
}
let b = if press { button } else { 3 };
vec![
0x1b,
b'[',
b'M',
32 + b,
(32 + x.min(223)) as u8,
(32 + y.min(223)) as u8,
]
}
#[cfg(test)]
mod tests {
use super::*;
fn screen_after(setup: &[u8]) -> vt100::Parser {
let mut p = vt100::Parser::new(24, 80, 0);
p.process(setup);
p
}
#[test]
fn wheel_scrolls_history_on_plain_screens() {
let p = screen_after(b"plain output\r\n");
assert_eq!(wheel_bytes(p.screen(), true, 5, 5), None);
}
#[test]
fn wheel_sends_arrows_to_alternate_screen_tuis() {
let p = screen_after(b"\x1b[?1049h");
assert_eq!(
wheel_bytes(p.screen(), true, 0, 0).unwrap(),
b"\x1b[A\x1b[A\x1b[A"
);
let p = screen_after(b"\x1b[?1049h\x1b[?1h");
assert_eq!(
wheel_bytes(p.screen(), false, 0, 0).unwrap(),
b"\x1bOB\x1bOB\x1bOB"
);
}
#[test]
fn wheel_reports_to_mouse_aware_programs() {
let p = screen_after(b"\x1b[?1000h\x1b[?1006h");
assert_eq!(
wheel_bytes(p.screen(), true, 2, 4).unwrap(),
b"\x1b[<64;3;5M"
);
let p = screen_after(b"\x1b[?1000h");
assert_eq!(
wheel_bytes(p.screen(), false, 2, 4).unwrap(),
vec![0x1b, b'[', b'M', 32 + 65, 32 + 3, 32 + 5]
);
}
#[test]
fn clicks_forward_only_when_reported() {
let p = screen_after(b"");
assert_eq!(click_bytes(p.screen(), 1, 1), None);
let p = screen_after(b"\x1b[?1000h\x1b[?1006h");
assert_eq!(
click_bytes(p.screen(), 1, 1).unwrap(),
b"\x1b[<0;2;2M\x1b[<0;2;2m"
);
}
}