138 lines
4.1 KiB
Rust
138 lines
4.1 KiB
Rust
use std::io::{Write, Result as IoResult};
|
|
use {Color, Style};
|
|
|
|
/// Extension to the `Write` trait.
|
|
///
|
|
/// This extension to the `Write` trait is capable of producing the correct ANSI escape sequences
|
|
/// for given commands, effectively controlling the terminal.
|
|
pub trait TermWrite {
|
|
|
|
/// Print the CSI (control sequence introducer) followed by a byte string.
|
|
fn csi(&mut self, b: &[u8]) -> IoResult<usize>;
|
|
/// Print OSC (operating system command) followed by a byte string.
|
|
fn osc(&mut self, b: &[u8]) -> IoResult<usize>;
|
|
/// Print OSC (device control string) followed by a byte string.
|
|
fn dsc(&mut self, b: &[u8]) -> IoResult<usize>;
|
|
|
|
|
|
/// Clear the entire screen.
|
|
fn clear(&mut self) -> IoResult<usize> {
|
|
self.csi(b"2J")
|
|
}
|
|
/// Clear everything _after_ the cursor.
|
|
fn clear_after(&mut self) -> IoResult<usize> {
|
|
self.csi(b"J")
|
|
}
|
|
/// Clear everything _before_ the cursor.
|
|
fn clear_before(&mut self) -> IoResult<usize> {
|
|
self.csi(b"1J")
|
|
}
|
|
/// Clear the current line.
|
|
fn clear_line(&mut self) -> IoResult<usize> {
|
|
self.csi(b"2K")
|
|
}
|
|
/// Clear from the cursor until newline.
|
|
fn clear_until_newline(&mut self) -> IoResult<usize> {
|
|
self.csi(b"K")
|
|
}
|
|
/// Show the cursor.
|
|
fn show_cursor(&mut self) -> IoResult<usize> {
|
|
self.csi(b"?25h")
|
|
}
|
|
/// Hide the cursor.
|
|
fn hide_cursor(&mut self) -> IoResult<usize> {
|
|
self.csi(b"?25l")
|
|
}
|
|
/// Reset the rendition mode.
|
|
///
|
|
/// This will reset both the current style and color.
|
|
fn reset(&mut self) -> IoResult<usize> {
|
|
self.csi(b"m")
|
|
}
|
|
/// Restore the defaults.
|
|
///
|
|
/// This will reset color, position, cursor state, and so on. It is recommended that you use
|
|
/// this before you exit your program, to avoid messing up the user's terminal.
|
|
fn restore(&mut self) -> IoResult<usize> {
|
|
Ok(try!(self.reset()) + try!(self.clear()) + try!(self.goto(0, 0)) + try!(self.show_cursor()))
|
|
}
|
|
|
|
/// Go to a given position.
|
|
///
|
|
/// The position is 0-based.
|
|
fn goto(&mut self, mut x: u16, mut y: u16) -> IoResult<usize> {
|
|
x += 1;
|
|
y += 1;
|
|
|
|
self.csi(&[
|
|
b'0' + (y / 10000) as u8,
|
|
b'0' + (y / 1000) as u8 % 10,
|
|
b'0' + (y / 100) as u8 % 10,
|
|
b'0' + (y / 10) as u8 % 10,
|
|
b'0' + y as u8 % 10,
|
|
b';',
|
|
b'0' + (x / 10000) as u8,
|
|
b'0' + (x / 1000) as u8 % 10,
|
|
b'0' + (x / 100) as u8 % 10,
|
|
b'0' + (x / 10) as u8 % 10,
|
|
b'0' + x as u8 % 10,
|
|
b'H',
|
|
])
|
|
}
|
|
/// Set graphic rendition.
|
|
fn rendition(&mut self, r: u8) -> IoResult<usize> {
|
|
self.csi(&[
|
|
b'0' + r / 100,
|
|
b'0' + r / 10 % 10,
|
|
b'0' + r % 10,
|
|
b'm',
|
|
])
|
|
}
|
|
/// Set foreground color
|
|
fn color(&mut self, color: Color) -> IoResult<usize> {
|
|
let ansi = color.to_ansi_val();
|
|
self.csi(&[
|
|
b'3',
|
|
b'8',
|
|
b';',
|
|
b'5',
|
|
b';',
|
|
b'0' + ansi / 100,
|
|
b'0' + ansi / 10 % 10,
|
|
b'0' + ansi % 10,
|
|
b'm',
|
|
])
|
|
}
|
|
/// Set background color
|
|
fn bg_color(&mut self, color: Color) -> IoResult<usize> {
|
|
let ansi = color.to_ansi_val();
|
|
self.csi(&[
|
|
b'4',
|
|
b'8',
|
|
b';',
|
|
b'5',
|
|
b';',
|
|
b'0' + ansi / 100,
|
|
b'0' + ansi / 10 % 10,
|
|
b'0' + ansi % 10,
|
|
b'm',
|
|
])
|
|
}
|
|
/// Set rendition mode (SGR).
|
|
fn style(&mut self, mode: Style) -> IoResult<usize> {
|
|
self.rendition(mode as u8)
|
|
}
|
|
}
|
|
|
|
impl<W: Write> TermWrite for W {
|
|
fn csi(&mut self, b: &[u8]) -> IoResult<usize> {
|
|
Ok(try!(self.write(b"\x1B[")) + try!(self.write(b)))
|
|
}
|
|
fn osc(&mut self, b: &[u8]) -> IoResult<usize> {
|
|
Ok(try!(self.write(b"\x1B]")) + try!(self.write(b)))
|
|
}
|
|
fn dsc(&mut self, b: &[u8]) -> IoResult<usize> {
|
|
Ok(try!(self.write(b"\x1BP")) + try!(self.write(b)))
|
|
}
|
|
}
|