808 lines
33 KiB
Rust
808 lines
33 KiB
Rust
// use std::time::{Duration, Instant};
|
|
use std::io;
|
|
use ::std::fmt::{self, Display, Formatter};
|
|
use std::cmp::max;
|
|
use std::io::{Read, Write};
|
|
use std::collections::VecDeque;
|
|
use nix::unistd::{read, write, ForkResult};
|
|
use nix::fcntl::{fcntl, FcntlArg, OFlag};
|
|
use nix::sys::termios::{
|
|
tcgetattr,
|
|
cfmakeraw,
|
|
tcsetattr,
|
|
SetArg,
|
|
tcdrain,
|
|
cfsetispeed,
|
|
cfsetospeed,
|
|
BaudRate,
|
|
};
|
|
use nix::pty::{forkpty, Winsize};
|
|
use std::os::unix::io::RawFd;
|
|
use std::process::Command;
|
|
use ::std::thread;
|
|
use ::std::sync::{Arc, Mutex};
|
|
|
|
use vte;
|
|
|
|
fn read_from_pid (pid: RawFd) -> Option<Vec<u8>> {
|
|
let mut read_buffer = [0; 115200];
|
|
let read_result = read(pid, &mut read_buffer);
|
|
match read_result {
|
|
Ok(res) => {
|
|
let res = Some(read_buffer[..=res].to_vec());
|
|
res
|
|
// (res, read_buffer)
|
|
},
|
|
Err(e) => {
|
|
match e {
|
|
nix::Error::Sys(errno) => {
|
|
if errno == nix::errno::Errno::EAGAIN {
|
|
None
|
|
// (0, read_buffer)
|
|
} else {
|
|
panic!("error {:?}", e);
|
|
}
|
|
},
|
|
_ => panic!("error {:?}", e)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn into_raw_mode(pid: RawFd) {
|
|
let mut tio = tcgetattr(pid).expect("could not get terminal attribute");
|
|
cfmakeraw(&mut tio);
|
|
match tcsetattr(pid, SetArg::TCSANOW, &mut tio) {
|
|
Ok(_) => {},
|
|
Err(e) => panic!("error {:?}", e)
|
|
};
|
|
|
|
}
|
|
|
|
fn set_baud_rate(pid: RawFd) {
|
|
let mut tio = tcgetattr(pid).expect("could not get terminal attribute");
|
|
cfsetospeed(&mut tio, BaudRate::B115200).expect("could not set baud rate");
|
|
cfsetispeed(&mut tio, BaudRate::B115200).expect("could not set baud rate");
|
|
tcsetattr(pid, SetArg::TCSANOW, &mut tio).expect("could not set attributes");
|
|
}
|
|
|
|
pub fn get_terminal_size_using_fd(fd: RawFd) -> Winsize {
|
|
// TODO: do this with the nix ioctl
|
|
use libc::ioctl;
|
|
use libc::TIOCGWINSZ;
|
|
|
|
let mut winsize = Winsize {
|
|
ws_row: 0,
|
|
ws_col: 0,
|
|
ws_xpixel: 0,
|
|
ws_ypixel: 0,
|
|
};
|
|
|
|
unsafe { ioctl(fd, TIOCGWINSZ.into(), &mut winsize) };
|
|
winsize
|
|
}
|
|
|
|
pub fn set_terminal_size_using_fd(fd: RawFd, columns: u16, rows: u16) {
|
|
// TODO: do this with the nix ioctl
|
|
use libc::ioctl;
|
|
use libc::TIOCSWINSZ;
|
|
|
|
let winsize = Winsize {
|
|
ws_col: columns,
|
|
ws_row: rows,
|
|
ws_xpixel: 0,
|
|
ws_ypixel: 0,
|
|
};
|
|
unsafe { ioctl(fd, TIOCSWINSZ.into(), &winsize) };
|
|
}
|
|
|
|
|
|
fn spawn_terminal (ws: &Winsize) -> (RawFd, RawFd) {
|
|
let (pid_primary, pid_secondary): (RawFd, RawFd) = {
|
|
match forkpty(Some(ws), None) {
|
|
Ok(fork_pty_res) => {
|
|
let pid_primary = fork_pty_res.master;
|
|
let pid_secondary = match fork_pty_res.fork_result {
|
|
ForkResult::Parent { child } => {
|
|
fcntl(pid_primary, FcntlArg::F_SETFL(OFlag::O_NONBLOCK)).expect("could not fcntl");
|
|
child
|
|
},
|
|
ForkResult::Child => {
|
|
// TODO: why does $SHELL not work?
|
|
// Command::new("$SHELL").spawn().expect("failed to spawn");
|
|
set_baud_rate(0);
|
|
set_terminal_size_using_fd(0, ws.ws_col, ws.ws_row);
|
|
Command::new("/usr/bin/fish").spawn().expect("failed to spawn");
|
|
::std::thread::sleep(std::time::Duration::from_millis(300000));
|
|
panic!("I am secondary, why?!");
|
|
},
|
|
};
|
|
(pid_primary, pid_secondary.as_raw())
|
|
}
|
|
Err(e) => {
|
|
panic!("failed to fork {:?}", e);
|
|
}
|
|
}
|
|
};
|
|
(pid_primary, pid_secondary)
|
|
}
|
|
|
|
#[derive(Clone, Debug)]
|
|
struct TerminalCharacter {
|
|
pub character: char,
|
|
pub ansi_code: Option<String>,
|
|
}
|
|
|
|
impl PartialEq for TerminalCharacter {
|
|
fn eq(&self, other: &Self) -> bool {
|
|
match (&self.ansi_code, &other.ansi_code) {
|
|
(Some(self_code), Some(other_code)) => {
|
|
self_code == other_code && self.character == other.character
|
|
},
|
|
(None, None) => {
|
|
self.character == other.character
|
|
}
|
|
_ => {
|
|
false
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Eq for TerminalCharacter {}
|
|
|
|
impl TerminalCharacter {
|
|
pub fn new (character: char) -> Self {
|
|
TerminalCharacter {
|
|
character,
|
|
ansi_code: None
|
|
}
|
|
}
|
|
pub fn ansi_code(mut self, ansi_code: String) -> Self {
|
|
self.ansi_code = Some(ansi_code);
|
|
self
|
|
}
|
|
}
|
|
|
|
|
|
impl Display for TerminalCharacter {
|
|
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
|
|
match &self.ansi_code {
|
|
Some(code) => write!(f, "{}{}", code, self.character),
|
|
None => write!(f, "{}", self.character)
|
|
}
|
|
}
|
|
}
|
|
|
|
struct TerminalOutput {
|
|
pub characters: Vec<TerminalCharacter>,
|
|
pub display_rows: u16,
|
|
pub display_cols: u16,
|
|
pub should_render: bool,
|
|
cursor_position: usize,
|
|
newline_indices: Vec<usize>, // canonical line breaks we get from the vt interpreter
|
|
linebreak_indices: Vec<usize>, // linebreaks from line wrapping
|
|
pending_ansi_code: Option<String>, // this is used eg. in a carriage return, where we need to preserve the style
|
|
}
|
|
|
|
const EMPTY_TERMINAL_CHARACTER: TerminalCharacter = TerminalCharacter { character: ' ', ansi_code: None };
|
|
|
|
impl TerminalOutput {
|
|
pub fn new () -> TerminalOutput {
|
|
TerminalOutput {
|
|
characters: vec![],
|
|
cursor_position: 0,
|
|
newline_indices: Vec::new(),
|
|
linebreak_indices: Vec::new(),
|
|
display_rows: 0,
|
|
display_cols: 0,
|
|
should_render: false,
|
|
pending_ansi_code: None,
|
|
}
|
|
}
|
|
pub fn reduce_width(&mut self, count: u16) {
|
|
self.display_cols -= count;
|
|
self.reflow_lines();
|
|
self.should_render = true;
|
|
}
|
|
pub fn increase_width(&mut self, count: u16) {
|
|
self.display_cols += count;
|
|
self.reflow_lines();
|
|
self.should_render = true;
|
|
}
|
|
pub fn set_size(&mut self, ws: &Winsize) {
|
|
let orig_cols = self.display_cols;
|
|
self.display_rows = ws.ws_row;
|
|
self.display_cols = ws.ws_col;
|
|
if orig_cols != self.display_cols && orig_cols != 0 {
|
|
self.reflow_lines();
|
|
}
|
|
}
|
|
fn reflow_lines (&mut self) {
|
|
self.linebreak_indices.clear();
|
|
|
|
let mut newline_indices = self.newline_indices.iter();
|
|
let mut next_newline_index = newline_indices.next();
|
|
|
|
let mut x: u64 = 0;
|
|
for (i, _c) in self.characters.iter().enumerate() {
|
|
if next_newline_index == Some(&i) {
|
|
x = 0;
|
|
next_newline_index = newline_indices.next();
|
|
} else if x == self.display_cols as u64 && i < self.cursor_position {
|
|
self.linebreak_indices.push(i);
|
|
x = 0;
|
|
}
|
|
x += 1;
|
|
}
|
|
}
|
|
pub fn read_buffer_as_lines (&mut self) -> Vec<Vec<&TerminalCharacter>> {
|
|
if DEBUGGING {
|
|
return vec![];
|
|
}
|
|
let mut output: VecDeque<Vec<&TerminalCharacter>> = VecDeque::new();
|
|
let mut i = self.characters.len();
|
|
let mut current_line: VecDeque<&TerminalCharacter> = VecDeque::new();
|
|
|
|
let mut newline_indices = self.newline_indices.iter().rev();
|
|
let mut linebreak_indices = self.linebreak_indices.iter().rev();
|
|
|
|
let mut next_newline_index = newline_indices.next();
|
|
let mut next_linebreak_index = linebreak_indices.next();
|
|
|
|
loop {
|
|
i -= 1;
|
|
let terminal_character = self.characters.get(i).unwrap();
|
|
current_line.push_front(terminal_character);
|
|
if let Some(newline_index) = next_newline_index {
|
|
if newline_index == &i {
|
|
// pad line
|
|
for _ in current_line.len()..self.display_cols as usize {
|
|
current_line.push_back(&EMPTY_TERMINAL_CHARACTER);
|
|
}
|
|
output.push_front(Vec::from(current_line.drain(..).collect::<Vec<&TerminalCharacter>>()));
|
|
next_newline_index = newline_indices.next();
|
|
continue;
|
|
}
|
|
}
|
|
if let Some(linebreak_index) = next_linebreak_index {
|
|
if linebreak_index == &i {
|
|
// pad line
|
|
for _ in current_line.len()..self.display_cols as usize {
|
|
current_line.push_back(&EMPTY_TERMINAL_CHARACTER);
|
|
}
|
|
output.push_front(Vec::from(current_line.drain(..).collect::<Vec<&TerminalCharacter>>()));
|
|
next_linebreak_index = linebreak_indices.next();
|
|
continue;
|
|
}
|
|
}
|
|
if i == 0 || output.len() == self.display_rows as usize {
|
|
break;
|
|
}
|
|
}
|
|
if output.len() < self.display_rows as usize {
|
|
let mut empty_line = vec![];
|
|
for _ in 0..self.display_cols {
|
|
empty_line.push(&EMPTY_TERMINAL_CHARACTER);
|
|
}
|
|
for _ in output.len()..self.display_rows as usize {
|
|
output.push_front(Vec::from(empty_line.clone()));
|
|
}
|
|
}
|
|
self.should_render = false;
|
|
Vec::from(output)
|
|
}
|
|
pub fn cursor_position_in_last_line (&self) -> usize {
|
|
if self.cursor_position < self.characters.len() {
|
|
let start_of_last_line = self.index_of_beginning_of_last_line();
|
|
let difference_from_last_newline = self.cursor_position - start_of_last_line;
|
|
difference_from_last_newline
|
|
} else {
|
|
self.display_cols as usize
|
|
}
|
|
}
|
|
fn index_of_beginning_of_last_line (&self) -> usize {
|
|
let last_newline_index = if self.newline_indices.is_empty() {
|
|
None
|
|
} else {
|
|
// return last
|
|
Some(*self.newline_indices.last().unwrap())
|
|
};
|
|
let last_linebreak_index = if self.linebreak_indices.is_empty() {
|
|
None
|
|
} else {
|
|
// return last
|
|
Some(*self.linebreak_indices.last().unwrap())
|
|
};
|
|
match (last_newline_index, last_linebreak_index) {
|
|
(Some(last_newline_index), Some(last_linebreak_index)) => {
|
|
max(last_newline_index, last_linebreak_index)
|
|
},
|
|
(None, Some(last_linebreak_index)) => last_linebreak_index,
|
|
(Some(last_newline_index), None) => last_newline_index,
|
|
(None, None) => 0
|
|
}
|
|
}
|
|
fn index_of_beginning_of_line (&self, index_in_line: usize) -> usize {
|
|
let last_newline_index = if self.newline_indices.is_empty() {
|
|
None
|
|
} else {
|
|
// return last less than index_in_line
|
|
let last_newline_index = *self.newline_indices.last().unwrap();
|
|
if last_newline_index <= index_in_line {
|
|
Some(last_newline_index)
|
|
} else {
|
|
let mut last_newline_index = 0;
|
|
for n_i in self.newline_indices.iter() {
|
|
if *n_i > last_newline_index && *n_i <= index_in_line {
|
|
last_newline_index = *n_i;
|
|
} else if *n_i > index_in_line {
|
|
break;
|
|
}
|
|
}
|
|
Some(last_newline_index)
|
|
}
|
|
};
|
|
let last_linebreak_index = if self.linebreak_indices.is_empty() {
|
|
None
|
|
} else {
|
|
// return last less than index_in_line
|
|
let last_linebreak_index = *self.linebreak_indices.last().unwrap();
|
|
if last_linebreak_index <= index_in_line {
|
|
Some(last_linebreak_index)
|
|
} else {
|
|
let mut last_linebreak_index = 0;
|
|
for l_i in self.linebreak_indices.iter() {
|
|
if *l_i > last_linebreak_index && *l_i <= index_in_line {
|
|
last_linebreak_index = *l_i;
|
|
} else if *l_i > index_in_line {
|
|
break;
|
|
}
|
|
}
|
|
Some(last_linebreak_index)
|
|
}
|
|
};
|
|
match (last_newline_index, last_linebreak_index) {
|
|
(Some(last_newline_index), Some(last_linebreak_index)) => {
|
|
max(last_newline_index, last_linebreak_index)
|
|
},
|
|
(None, Some(last_linebreak_index)) => last_linebreak_index,
|
|
(Some(last_newline_index), None) => last_newline_index,
|
|
(None, None) => 0
|
|
}
|
|
}
|
|
fn add_newline (&mut self) {
|
|
self.newline_indices.push(self.characters.len()); // -1?
|
|
self.cursor_position = self.characters.len(); // -1?
|
|
self.should_render = true;
|
|
self.pending_ansi_code = None;
|
|
}
|
|
fn move_to_beginning_of_line (&mut self) {
|
|
let last_newline_index = if self.newline_indices.is_empty() {
|
|
0
|
|
} else {
|
|
*self.newline_indices.last().unwrap()
|
|
};
|
|
self.cursor_position = last_newline_index;
|
|
self.should_render = true;
|
|
}
|
|
}
|
|
|
|
const DEBUGGING: bool = false;
|
|
|
|
impl vte::Perform for TerminalOutput {
|
|
fn print(&mut self, c: char) {
|
|
if DEBUGGING {
|
|
println!("\r[print] {:?}", c);
|
|
} else {
|
|
let mut terminal_character = TerminalCharacter::new(c);
|
|
terminal_character.ansi_code = self.pending_ansi_code.clone();
|
|
if self.characters.len() == self.cursor_position {
|
|
self.characters.push(terminal_character);
|
|
} else if self.characters.len() > self.cursor_position {
|
|
self.characters.remove(self.cursor_position);
|
|
self.characters.insert(self.cursor_position, terminal_character);
|
|
} else {
|
|
let mut space_character = TerminalCharacter::new(' ');
|
|
space_character.ansi_code = self.pending_ansi_code.clone();
|
|
for _ in self.characters.len()..self.cursor_position {
|
|
self.characters.push(space_character.clone());
|
|
};
|
|
self.characters.push(terminal_character);
|
|
}
|
|
|
|
let start_of_last_line = self.index_of_beginning_of_line(self.cursor_position);
|
|
let difference_from_last_newline = self.cursor_position - start_of_last_line;
|
|
if difference_from_last_newline == self.display_cols as usize {
|
|
self.linebreak_indices.push(self.cursor_position);
|
|
}
|
|
self.cursor_position += 1;
|
|
}
|
|
}
|
|
|
|
fn execute(&mut self, byte: u8) {
|
|
if DEBUGGING {
|
|
if byte == 13 { // 0d, carriage return
|
|
println!("\rEXECUTE CARRIAGE RETURN");
|
|
} else if byte == 10 { // 0a, newline
|
|
println!("\rEXECUTE NEW LINE");
|
|
} else if byte == 08 { // backspace
|
|
println!("\rEXECUTE BACKSPACE");
|
|
} else {
|
|
println!("\r[execute] {:02x}", byte);
|
|
}
|
|
} else {
|
|
if byte == 13 { // 0d, carriage return
|
|
self.move_to_beginning_of_line();
|
|
} else if byte == 08 { // backspace
|
|
self.cursor_position -= 1;
|
|
} else if byte == 10 { // 0a, newline
|
|
self.add_newline();
|
|
}
|
|
}
|
|
}
|
|
|
|
fn hook(&mut self, params: &[i64], intermediates: &[u8], ignore: bool, c: char) {
|
|
if DEBUGGING {
|
|
println!(
|
|
"\r[hook] params={:?}, intermediates={:?}, ignore={:?}, char={:?}",
|
|
params, intermediates, ignore, c
|
|
);
|
|
}
|
|
}
|
|
|
|
fn put(&mut self, byte: u8) {
|
|
if DEBUGGING {
|
|
println!("\r[put] {:02x}", byte);
|
|
}
|
|
}
|
|
|
|
fn unhook(&mut self) {
|
|
if DEBUGGING {
|
|
println!("\r[unhook]");
|
|
}
|
|
}
|
|
|
|
fn osc_dispatch(&mut self, params: &[&[u8]], bell_terminated: bool) {
|
|
if DEBUGGING {
|
|
println!("\r[osc_dispatch] params={:?} bell_terminated={}", params, bell_terminated);
|
|
}
|
|
}
|
|
|
|
fn csi_dispatch(&mut self, params: &[i64], intermediates: &[u8], ignore: bool, c: char) {
|
|
if DEBUGGING {
|
|
println!(
|
|
"\r[csi_dispatch] params={:?}, intermediates={:?}, ignore={:?}, char={:?}",
|
|
params, intermediates, ignore, c
|
|
);
|
|
} else {
|
|
if c == 'm' {
|
|
// change foreground color (only?)
|
|
if params.len() == 1 && params[0] == 0 {
|
|
// eg. \u{1b}[m
|
|
self.pending_ansi_code = Some(String::from("\u{1b}[m"));
|
|
} else {
|
|
// eg. \u{1b}[38;5;0m
|
|
let param_string = params.iter().map(|p| p.to_string()).collect::<Vec<String>>().join(";");
|
|
self.pending_ansi_code = Some(format!("\u{1b}[{}m", param_string));
|
|
}
|
|
} else if c == 'C' { // move cursor
|
|
self.cursor_position += params[0] as usize; // TODO: negative value?
|
|
} else if c == 'K' { // clear line (0 => right, 1 => left, 2 => all)
|
|
if params[0] == 0 {
|
|
if let Some(position_of_first_newline_index_to_delete) = self.newline_indices.iter().position(|&ni| ni > self.cursor_position) {
|
|
self.newline_indices.truncate(position_of_first_newline_index_to_delete);
|
|
}
|
|
if let Some(position_of_first_linebreak_index_to_delete) = self.linebreak_indices.iter().position(|&li| li > self.cursor_position) {
|
|
self.newline_indices.truncate(position_of_first_linebreak_index_to_delete);
|
|
}
|
|
self.characters.truncate(self.cursor_position + 1);
|
|
}
|
|
// TODO: implement 1 and 2
|
|
} else if c == 'J' { // clear all (0 => below, 1 => above, 2 => all, 3 => saved)
|
|
if params[0] == 0 {
|
|
if let Some(position_of_first_newline_index_to_delete) = self.newline_indices.iter().position(|&ni| ni > self.cursor_position) {
|
|
self.newline_indices.truncate(position_of_first_newline_index_to_delete);
|
|
}
|
|
if let Some(position_of_first_linebreak_index_to_delete) = self.linebreak_indices.iter().position(|&li| li > self.cursor_position) {
|
|
self.newline_indices.truncate(position_of_first_linebreak_index_to_delete);
|
|
}
|
|
self.characters.truncate(self.cursor_position + 1);
|
|
}
|
|
// TODO: implement 1, 2, and 3
|
|
}
|
|
}
|
|
}
|
|
|
|
fn esc_dispatch(&mut self, intermediates: &[u8], ignore: bool, byte: u8) {
|
|
if DEBUGGING {
|
|
println!(
|
|
// "\r[esc_dispatch] intermediates={:?}, ignore={:?}, byte={:02x}",
|
|
"\r[esc_dispatch] intermediates={:?}, ignore={:?}, byte={:?}",
|
|
intermediates, ignore, byte
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
// sigwinch stuff
|
|
use ::signal_hook::iterator::Signals;
|
|
|
|
pub type OnSigWinch = dyn Fn(Box<dyn Fn()>) + Send;
|
|
pub type SigCleanup = dyn Fn() + Send;
|
|
|
|
pub fn sigwinch() -> (Box<OnSigWinch>, Box<SigCleanup>) {
|
|
let signals = Signals::new(&[signal_hook::SIGWINCH]).unwrap();
|
|
let on_winch = {
|
|
let signals = signals.clone();
|
|
move |cb: Box<dyn Fn()>| {
|
|
for signal in signals.forever() {
|
|
match signal {
|
|
signal_hook::SIGWINCH => cb(),
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
}
|
|
};
|
|
let cleanup = move || {
|
|
signals.close();
|
|
};
|
|
(Box::new(on_winch), Box::new(cleanup))
|
|
}
|
|
|
|
fn split_horizontally_with_gap (rect: &Winsize) -> (Winsize, Winsize) {
|
|
let width_of_each_half = (rect.ws_col - 1) / 2;
|
|
let mut first_rect = rect.clone();
|
|
let mut second_rect = rect.clone();
|
|
first_rect.ws_col = width_of_each_half;
|
|
second_rect.ws_col = width_of_each_half;
|
|
(first_rect, second_rect)
|
|
}
|
|
|
|
fn character_is_already_onscreen(
|
|
last_character: &TerminalCharacter,
|
|
current_character: &TerminalCharacter,
|
|
) -> bool {
|
|
let last_character_style = match &last_character.ansi_code {
|
|
Some(ansi_code) => Some(ansi_code.as_str()),
|
|
None => None,
|
|
};
|
|
let current_character_style = match ¤t_character.ansi_code {
|
|
Some(ansi_code) => Some(ansi_code.as_str()),
|
|
None => None,
|
|
};
|
|
last_character_style == current_character_style && last_character.character == current_character.character
|
|
}
|
|
|
|
struct Screen {
|
|
last_frame: Option<Vec<TerminalCharacter>>,
|
|
vertical_separator: TerminalCharacter, // TODO: better
|
|
}
|
|
|
|
impl Screen {
|
|
pub fn new () -> Self {
|
|
Screen {
|
|
last_frame: None,
|
|
vertical_separator: TerminalCharacter::new('|').ansi_code(String::from("\u{1b}[m")), // TODO: better
|
|
}
|
|
}
|
|
pub fn render (&mut self, terminal1_output: &mut TerminalOutput, terminal2_output: &mut TerminalOutput, full_screen_ws: &Winsize, terminal1_is_active: bool) {
|
|
if DEBUGGING {
|
|
return;
|
|
}
|
|
let left_terminal_lines = terminal1_output.read_buffer_as_lines();
|
|
let right_terminal_lines = terminal2_output.read_buffer_as_lines();
|
|
|
|
let mut frame: Vec<&TerminalCharacter> = vec![];
|
|
for i in 0..full_screen_ws.ws_row {
|
|
let left_terminal_row = left_terminal_lines.get(i as usize).unwrap();
|
|
for terminal_character in left_terminal_row.iter() {
|
|
frame.push(terminal_character);
|
|
}
|
|
|
|
frame.push(&self.vertical_separator);
|
|
|
|
let right_terminal_row = right_terminal_lines.get(i as usize).unwrap();
|
|
for terminal_character in right_terminal_row.iter() {
|
|
frame.push(terminal_character);
|
|
}
|
|
}
|
|
|
|
let mut data_lines = String::new();
|
|
match &self.last_frame {
|
|
Some(last_frame) => {
|
|
if last_frame.len() != frame.len() {
|
|
// this is not ideal
|
|
// right now it happens when we resize a pane, until fish resets the last line
|
|
return
|
|
}
|
|
let mut last_character_was_changed = false;
|
|
let mut last_rendered_char_style = None;
|
|
for i in 0..last_frame.len() {
|
|
let last_character = last_frame.get(i).unwrap();
|
|
let current_character = frame.get(i).unwrap();
|
|
let row = i / full_screen_ws.ws_col as usize + 1;
|
|
let col = i % full_screen_ws.ws_col as usize + 1;
|
|
if !character_is_already_onscreen(&last_character, ¤t_character) {
|
|
if !last_character_was_changed {
|
|
data_lines.push_str(&format!("\u{1b}[{};{}H\u{1b}[m", row, &col)); // goto row/col
|
|
}
|
|
// TODO: only render the ansi_code if it is different from the previous
|
|
// rendered ansi code (previous char in this loop)
|
|
if last_rendered_char_style == current_character.ansi_code && last_character_was_changed {
|
|
data_lines.push(current_character.character);
|
|
} else {
|
|
data_lines.push_str(¤t_character.to_string());
|
|
last_rendered_char_style = current_character.ansi_code.clone();
|
|
}
|
|
last_character_was_changed = true;
|
|
} else {
|
|
last_character_was_changed = false;
|
|
last_rendered_char_style = None;
|
|
}
|
|
}
|
|
},
|
|
None => {
|
|
print!("\u{1b}c"); // clear screen
|
|
for terminal_character in frame.iter() {
|
|
data_lines.push_str(&terminal_character.to_string());
|
|
}
|
|
}
|
|
}
|
|
// TODO: consider looping through current frame and only updating the cells that changed
|
|
self.last_frame = Some(frame.into_iter().cloned().collect::<Vec<_>>());
|
|
|
|
let left_terminal_cursor_position = terminal1_output.cursor_position_in_last_line();
|
|
let right_terminal_cursor_position = terminal2_output.cursor_position_in_last_line();
|
|
if terminal1_is_active {
|
|
data_lines.push_str(&format!("\r\u{1b}[{}C", left_terminal_cursor_position));
|
|
} else {
|
|
data_lines.push_str(&format!("\r\u{1b}[{}C", right_terminal_cursor_position + (terminal1_output.display_cols + 1) as usize));
|
|
}
|
|
::std::io::stdout().write_all(&data_lines.as_bytes()).expect("cannot write to stdout");
|
|
::std::io::stdout().flush().expect("could not flush");
|
|
}
|
|
}
|
|
|
|
fn main() {
|
|
let mut active_threads = vec![];
|
|
|
|
let full_screen_ws = get_terminal_size_using_fd(0);
|
|
let (first_terminal_ws, second_terminal_ws) = split_horizontally_with_gap(&full_screen_ws);
|
|
let (first_terminal_pid, _pid_secondary): (RawFd, RawFd) = spawn_terminal(&first_terminal_ws);
|
|
let (second_terminal_pid, _pid_secondary): (RawFd, RawFd) = spawn_terminal(&second_terminal_ws);
|
|
let stdin = io::stdin();
|
|
into_raw_mode(0);
|
|
set_baud_rate(0);
|
|
::std::thread::sleep(std::time::Duration::from_millis(2000));
|
|
let active_terminal = Arc::new(Mutex::new(first_terminal_pid));
|
|
|
|
let first_terminal_ws = Arc::new(Mutex::new(first_terminal_ws));
|
|
let second_terminal_ws = Arc::new(Mutex::new(second_terminal_ws));
|
|
|
|
let terminal1_output = Arc::new(Mutex::new(TerminalOutput::new()));
|
|
let terminal2_output = Arc::new(Mutex::new(TerminalOutput::new()));
|
|
|
|
let screen = Arc::new(Mutex::new(Screen::new()));
|
|
|
|
active_threads.push(
|
|
thread::Builder::new()
|
|
.name("terminal_stdout_handler".to_string())
|
|
.spawn({
|
|
|
|
let mut vte_parser_terminal1 = vte::Parser::new();
|
|
let mut vte_parser_terminal2 = vte::Parser::new();
|
|
|
|
let active_terminal = active_terminal.clone();
|
|
let terminal1_output = terminal1_output.clone();
|
|
let terminal2_output = terminal2_output.clone();
|
|
let first_terminal_ws = first_terminal_ws.clone();
|
|
let second_terminal_ws = second_terminal_ws.clone();
|
|
let screen = screen.clone();
|
|
move || {
|
|
{
|
|
// TODO: better
|
|
let first_terminal_ws = first_terminal_ws.lock().unwrap();
|
|
let second_terminal_ws = second_terminal_ws.lock().unwrap();
|
|
let mut terminal1_output = terminal1_output.lock().unwrap();
|
|
let mut terminal2_output = terminal2_output.lock().unwrap();
|
|
terminal1_output.set_size(&first_terminal_ws);
|
|
terminal2_output.set_size(&second_terminal_ws);
|
|
}
|
|
loop {
|
|
match (read_from_pid(first_terminal_pid), read_from_pid(second_terminal_pid)) {
|
|
(Some(first_terminal_read_bytes), Some(second_terminal_read_bytes)) => {
|
|
let mut terminal1_output = terminal1_output.lock().unwrap();
|
|
let mut terminal2_output = terminal2_output.lock().unwrap();
|
|
for byte in first_terminal_read_bytes.iter() {
|
|
vte_parser_terminal1.advance(&mut *terminal1_output, *byte);
|
|
}
|
|
for byte in second_terminal_read_bytes.iter() {
|
|
vte_parser_terminal2.advance(&mut *terminal2_output, *byte);
|
|
}
|
|
}
|
|
(Some(first_terminal_read_bytes), None) => {
|
|
let mut terminal1_output = terminal1_output.lock().unwrap();
|
|
// let now = Instant::now();
|
|
for byte in first_terminal_read_bytes.iter() {
|
|
vte_parser_terminal1.advance(&mut *terminal1_output, *byte);
|
|
}
|
|
// println!("\rParsed in {:?}", now.elapsed());
|
|
}
|
|
(None, Some(second_terminal_read_bytes)) => {
|
|
// let mut terminal1_output = terminal1_output.lock().unwrap();
|
|
let mut terminal2_output = terminal2_output.lock().unwrap();
|
|
for byte in second_terminal_read_bytes.iter() {
|
|
vte_parser_terminal2.advance(&mut *terminal2_output, *byte);
|
|
}
|
|
}
|
|
(None, None) => {
|
|
::std::thread::sleep(std::time::Duration::from_millis(50)); // TODO: adjust this
|
|
}
|
|
}
|
|
let mut terminal1_output = terminal1_output.lock().unwrap();
|
|
let mut terminal2_output = terminal2_output.lock().unwrap();
|
|
if terminal1_output.should_render || terminal2_output.should_render {
|
|
let active_terminal = active_terminal.lock().unwrap();
|
|
let mut screen = screen.lock().unwrap();
|
|
// let now = Instant::now();
|
|
screen.render(&mut *terminal1_output, &mut *terminal2_output, &full_screen_ws, *active_terminal == first_terminal_pid);
|
|
// println!("\r-------->R rendered in {:?}", now.elapsed());
|
|
}
|
|
}
|
|
}
|
|
})
|
|
.unwrap(),
|
|
);
|
|
loop {
|
|
let mut buffer = [0; 1];
|
|
{
|
|
let mut handle = stdin.lock();
|
|
handle.read(&mut buffer).expect("failed to read stdin");
|
|
if buffer[0] == 10 { // ctrl-j
|
|
let mut terminal1_output = terminal1_output.lock().unwrap();
|
|
let mut terminal2_output = terminal2_output.lock().unwrap();
|
|
let active_terminal = active_terminal.lock().unwrap();
|
|
terminal1_output.reduce_width(10);
|
|
terminal2_output.increase_width(10);
|
|
set_terminal_size_using_fd(first_terminal_pid, terminal1_output.display_cols, terminal1_output.display_rows);
|
|
set_terminal_size_using_fd(second_terminal_pid, terminal2_output.display_cols, terminal2_output.display_rows);
|
|
screen.lock().unwrap().render(&mut *terminal1_output, &mut *terminal2_output, &full_screen_ws, *active_terminal == first_terminal_pid);
|
|
continue;
|
|
} else if buffer[0] == 11 { // ctrl-k
|
|
let mut terminal1_output = terminal1_output.lock().unwrap();
|
|
let mut terminal2_output = terminal2_output.lock().unwrap();
|
|
let active_terminal = active_terminal.lock().unwrap();
|
|
terminal1_output.increase_width(10);
|
|
terminal2_output.reduce_width(10);
|
|
set_terminal_size_using_fd(first_terminal_pid, terminal1_output.display_cols, terminal1_output.display_rows);
|
|
set_terminal_size_using_fd(second_terminal_pid, terminal2_output.display_cols, terminal2_output.display_rows);
|
|
screen.lock().unwrap().render(&mut *terminal1_output, &mut *terminal2_output, &full_screen_ws, *active_terminal == first_terminal_pid);
|
|
continue;
|
|
} else if buffer[0] == 16 { // ctrl-p
|
|
let mut active_terminal = active_terminal.lock().unwrap();
|
|
if *active_terminal == first_terminal_pid {
|
|
*active_terminal = second_terminal_pid;
|
|
let mut terminal1_output = terminal1_output.lock().unwrap();
|
|
let mut terminal2_output = terminal2_output.lock().unwrap();
|
|
screen.lock().unwrap().render(&mut *terminal1_output, &mut *terminal2_output, &full_screen_ws, *active_terminal == first_terminal_pid);
|
|
} else {
|
|
*active_terminal = first_terminal_pid;
|
|
let mut terminal1_output = terminal1_output.lock().unwrap();
|
|
let mut terminal2_output = terminal2_output.lock().unwrap();
|
|
screen.lock().unwrap().render(&mut *terminal1_output, &mut *terminal2_output, &full_screen_ws, *active_terminal == first_terminal_pid);
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
let active_terminal = active_terminal.lock().unwrap();
|
|
write(*active_terminal, &mut buffer).expect("failed to write to terminal");
|
|
tcdrain(*active_terminal).expect("failed to drain terminal");
|
|
};
|
|
// cleanup();
|
|
|
|
// for thread_handler in active_threads {
|
|
// thread_handler.join().unwrap();
|
|
// }
|
|
|
|
}
|