lib-nested/terminal/ansi_parser/src/main.rs

332 lines
11 KiB
Rust
Raw Normal View History

#![feature(iter_advance_by)]
use {
2021-11-19 12:19:52 +01:00
cgmath::Point2,
nested::terminal::{TerminalAtom, TerminalStyle},
std::{
fs::File,
2021-11-19 12:19:52 +01:00
io::{stdin, Read, Write},
os::unix::io::FromRawFd,
},
2021-11-19 12:19:52 +01:00
vte::{Params, Parser, Perform},
};
struct ColorPalett {
black: (u8, u8, u8),
red: (u8, u8, u8),
green: (u8, u8, u8),
yellow: (u8, u8, u8),
blue: (u8, u8, u8),
magenta: (u8, u8, u8),
cyan: (u8, u8, u8),
2021-11-19 12:19:52 +01:00
white: (u8, u8, u8),
}
struct PerfAtom {
colors: ColorPalett,
term_width: i16,
cursor: Point2<i16>,
style: TerminalStyle,
out: File,
}
impl PerfAtom {
fn write_atom(&mut self, pos: Point2<i16>, atom: Option<TerminalAtom>) {
2021-11-19 12:19:52 +01:00
self.out
.write(&bincode::serialize(&(pos, atom)).unwrap())
.expect("");
}
}
impl Perform for PerfAtom {
fn print(&mut self, c: char) {
//eprintln!("[print] {:?}", c);
2021-11-19 12:19:52 +01:00
self.write_atom(self.cursor, Some(TerminalAtom::new(c, self.style)));
self.cursor.x += 1;
if self.cursor.x > self.term_width {
self.cursor.x = 0;
self.cursor.y += 1;
}
}
fn execute(&mut self, byte: u8) {
//eprintln!("[execute] {:02x}", byte);
match byte {
b'\n' => {
self.cursor.x = 0;
self.cursor.y += 1;
2021-11-19 12:19:52 +01:00
}
_ => {}
}
}
fn hook(&mut self, params: &Params, intermediates: &[u8], ignore: bool, c: char) {
eprintln!(
"[hook] params={:?}, intermediates={:?}, ignore={:?}, char={:?}",
params, intermediates, ignore, c
);
}
fn put(&mut self, byte: u8) {
eprintln!("[put] {:02x}", byte);
}
fn unhook(&mut self) {
eprintln!("[unhook]");
}
fn osc_dispatch(&mut self, params: &[&[u8]], bell_terminated: bool) {
2021-11-19 12:19:52 +01:00
eprintln!(
"[osc_dispatch] params={:?} bell_terminated={}",
params, bell_terminated
);
}
fn csi_dispatch(&mut self, params: &Params, intermediates: &[u8], ignore: bool, c: char) {
eprintln!(
"[csi_dispatch] params={:#?}, intermediates={:?}, ignore={:?}, char={:?}",
params, intermediates, ignore, c
);
let mut piter = params.into_iter();
match c {
// Set SGR
2021-11-19 12:19:52 +01:00
'm' => {
while let Some(n) = piter.next() {
match n[0] {
0 => self.style = TerminalStyle::default(),
1 => self.style = self.style.add(TerminalStyle::bold(true)),
3 => self.style = self.style.add(TerminalStyle::italic(true)),
4 => self.style = self.style.add(TerminalStyle::underline(true)),
2021-11-19 12:19:52 +01:00
30 => {
self.style = self.style.add(TerminalStyle::fg_color(self.colors.black))
}
40 => {
self.style = self.style.add(TerminalStyle::bg_color(self.colors.black))
}
31 => self.style = self.style.add(TerminalStyle::fg_color(self.colors.red)),
41 => self.style = self.style.add(TerminalStyle::bg_color(self.colors.red)),
2021-11-19 12:19:52 +01:00
32 => {
self.style = self.style.add(TerminalStyle::fg_color(self.colors.green))
}
42 => {
self.style = self.style.add(TerminalStyle::bg_color(self.colors.green))
}
33 => {
self.style = self.style.add(TerminalStyle::fg_color(self.colors.yellow))
}
43 => {
self.style = self.style.add(TerminalStyle::bg_color(self.colors.yellow))
}
34 => {
self.style = self.style.add(TerminalStyle::fg_color(self.colors.blue))
}
44 => {
self.style = self.style.add(TerminalStyle::bg_color(self.colors.blue))
}
35 => {
self.style =
self.style.add(TerminalStyle::fg_color(self.colors.magenta))
}
45 => {
self.style =
self.style.add(TerminalStyle::bg_color(self.colors.magenta))
}
36 => {
self.style = self.style.add(TerminalStyle::fg_color(self.colors.cyan))
}
46 => {
self.style = self.style.add(TerminalStyle::bg_color(self.colors.cyan))
}
37 => {
self.style = self.style.add(TerminalStyle::fg_color(self.colors.white))
}
47 => {
self.style = self.style.add(TerminalStyle::bg_color(self.colors.white))
}
38 => {
let x = piter.next().unwrap();
match x[0] {
2 => {
let r = piter.next().unwrap();
let g = piter.next().unwrap();
let b = piter.next().unwrap();
2021-11-19 12:19:52 +01:00
self.style = self.style.add(TerminalStyle::fg_color((
r[0] as u8,
g[0] as u8,
b[30] as u8,
)))
}
5 => {
let v = piter.next().unwrap();
2021-11-19 12:19:52 +01:00
self.style = self.style.add(TerminalStyle::fg_color(
ansi_colours::rgb_from_ansi256(v[0] as u8),
))
}
_ => {}
}
2021-11-19 12:19:52 +01:00
}
48 => {
let x = piter.next().unwrap();
match x[0] {
2 => {
let r = piter.next().unwrap();
let g = piter.next().unwrap();
let b = piter.next().unwrap();
2021-11-19 12:19:52 +01:00
self.style = self.style.add(TerminalStyle::bg_color((
r[0] as u8,
g[0] as u8,
b[30] as u8,
)))
}
5 => {
let v = piter.next().unwrap();
2021-11-19 12:19:52 +01:00
self.style = self.style.add(TerminalStyle::bg_color(
ansi_colours::rgb_from_ansi256(v[0] as u8),
))
}
_ => {}
}
2021-11-19 12:19:52 +01:00
}
2021-11-19 12:19:52 +01:00
_ => {}
}
}
2021-11-19 12:19:52 +01:00
}
'H' => {
2021-11-19 12:19:52 +01:00
if let Some(y) = piter.next() {
self.cursor.y = y[0] as i16 - 1
};
if let Some(x) = piter.next() {
self.cursor.x = x[0] as i16 - 1
};
eprintln!("cursor at {:?}", self.cursor);
2021-11-19 12:19:52 +01:00
}
2021-11-19 12:19:52 +01:00
'A' => {
self.cursor.y -= piter.next().unwrap()[0] as i16;
}
'B' => {
self.cursor.y += piter.next().unwrap()[0] as i16;
}
'C' => {
self.cursor.x += piter.next().unwrap()[0] as i16;
}
'D' => {
self.cursor.x -= piter.next().unwrap()[0] as i16;
}
'E' => {
self.cursor.x = 0;
self.cursor.y += piter.next().unwrap()[0] as i16;
}
'J' => {
let x = piter.next().unwrap_or(&[0 as u16; 1]);
match x[0] {
2021-11-19 12:19:52 +01:00
0 => {}
1 => {}
2 => {
2021-11-19 12:19:52 +01:00
for y in 0..100 {
for x in 0..self.term_width {
self.write_atom(Point2::new(x, y), None);
}
}
}
// invalid
_ => {}
}
}
2021-11-19 12:19:52 +01:00
'K' => {
let x = piter.next().unwrap();
match x[0] {
// clear cursor until end
0 => {
2021-11-19 12:19:52 +01:00
for x in self.cursor.x..self.term_width {
self.write_atom(Point2::new(x, self.cursor.y), None);
}
2021-11-19 12:19:52 +01:00
}
// clear start until cursor
1 => {
2021-11-19 12:19:52 +01:00
for x in 0..self.cursor.x {
self.write_atom(Point2::new(x, self.cursor.y), None);
2021-11-19 12:19:52 +01:00
}
}
// clear entire line
2 => {
2021-11-19 12:19:52 +01:00
for x in 0..self.term_width {
self.write_atom(Point2::new(x, self.cursor.y), None);
2021-11-19 12:19:52 +01:00
}
}
// invalid
_ => {}
}
}
2021-11-19 12:19:52 +01:00
_ => {}
}
}
fn esc_dispatch(&mut self, intermediates: &[u8], ignore: bool, byte: u8) {
eprintln!(
"[esc_dispatch] intermediates={:?}, ignore={:?}, byte={:02x}",
intermediates, ignore, byte
);
}
}
fn main() {
let input = stdin();
let mut handle = input.lock();
let mut statemachine = Parser::new();
let mut performer = PerfAtom {
cursor: Point2::new(0, 0),
style: TerminalStyle::default(),
term_width: 200,
out: unsafe { File::from_raw_fd(1) },
colors: ColorPalett {
black: (1, 1, 1),
red: (222, 56, 43),
green: (0, 64, 0),
yellow: (255, 199, 6),
blue: (0, 111, 184),
magenta: (118, 38, 113),
cyan: (44, 181, 233),
2021-11-19 12:19:52 +01:00
white: (204, 204, 204),
},
};
let mut buf = [0; 2048];
loop {
match handle.read(&mut buf) {
Ok(0) => break,
Ok(n) => {
for byte in &buf[..n] {
2021-11-19 12:19:52 +01:00
statemachine.advance(&mut performer, *byte);
performer.out.flush().unwrap();
}
2021-11-19 12:19:52 +01:00
}
Err(err) => {
println!("err: {}", err);
break;
2021-11-19 12:19:52 +01:00
}
}
}
}