2016-06-30 03:56:12 +00:00
|
|
|
// Copyright 2016 Joe Wilm, The Alacritty Project Contributors
|
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
// you may not use this file except in compliance with the License.
|
|
|
|
// You may obtain a copy of the License at
|
|
|
|
//
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
//
|
|
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
// See the License for the specific language governing permissions and
|
|
|
|
// limitations under the License.
|
|
|
|
//
|
2016-05-25 03:55:51 +00:00
|
|
|
//! Alacritty - The GPU Enhanced Terminal
|
|
|
|
#![feature(question_mark)]
|
Initial ANSI parser implementation
This is the initial terminal stream parsing implementation for
Alacritty. There are currently several TODOs, FIXMEs, and unimplemented!
things scattered about still, but what's here is good enough to
correctly parse my zsh startup.
The `Parser` implementation is largely based on the suck-less _simple
terminal_ parser. Because this is Rust and Rust has a fantastic type
system, some improvements are possible. First, `Parser` is a struct, and
its data is stored internally instead of statically. Second, there's no
terminal updates hard-coded into the parser. Instead, `Parser` is
generic over a `Handler` type which has methods for all of the actions
supported by the parser. Because Parser is generic, it should be
possible (with proper inlining) to have equivalent performance to the
hard-coded version.
In addition to using _simple terminal_ as a reference, there's a doc in
Alacritty's repository `docs/ansicode.txt`, a summary of the ANSI
terminal protocol, which has been referenced extensively.
There's probably a large number escapes we don't handle, and that's ok.
There's a lot that aren't necessary for everyday terminal usage. If you
feel like something that's not supported should be, feel free to add it.
Please try not to become overzealous and adding support for sequences
only used by folks trapped in 1988.
2016-05-29 05:09:25 +00:00
|
|
|
#![feature(range_contains)]
|
|
|
|
#![feature(inclusive_range_syntax)]
|
2016-06-30 03:14:37 +00:00
|
|
|
#![feature(drop_types_in_const)]
|
2016-05-31 03:44:37 +00:00
|
|
|
#![feature(unicode)]
|
2016-06-30 16:04:06 +00:00
|
|
|
#![feature(custom_derive, plugin)]
|
|
|
|
#![plugin(serde_macros)]
|
2016-05-25 03:55:51 +00:00
|
|
|
|
2016-06-30 16:04:06 +00:00
|
|
|
extern crate cgmath;
|
|
|
|
extern crate errno;
|
2016-06-10 03:39:40 +00:00
|
|
|
extern crate font;
|
2016-02-24 04:42:58 +00:00
|
|
|
extern crate glutin;
|
2016-06-30 16:04:06 +00:00
|
|
|
extern crate libc;
|
2016-06-04 17:54:33 +00:00
|
|
|
extern crate notify;
|
2016-06-28 02:46:24 +00:00
|
|
|
extern crate parking_lot;
|
2016-06-30 16:04:06 +00:00
|
|
|
extern crate serde;
|
|
|
|
extern crate serde_yaml;
|
2016-02-21 23:20:03 +00:00
|
|
|
|
2016-06-06 23:54:15 +00:00
|
|
|
#[macro_use]
|
|
|
|
extern crate bitflags;
|
|
|
|
|
Initial ANSI parser implementation
This is the initial terminal stream parsing implementation for
Alacritty. There are currently several TODOs, FIXMEs, and unimplemented!
things scattered about still, but what's here is good enough to
correctly parse my zsh startup.
The `Parser` implementation is largely based on the suck-less _simple
terminal_ parser. Because this is Rust and Rust has a fantastic type
system, some improvements are possible. First, `Parser` is a struct, and
its data is stored internally instead of statically. Second, there's no
terminal updates hard-coded into the parser. Instead, `Parser` is
generic over a `Handler` type which has methods for all of the actions
supported by the parser. Because Parser is generic, it should be
possible (with proper inlining) to have equivalent performance to the
hard-coded version.
In addition to using _simple terminal_ as a reference, there's a doc in
Alacritty's repository `docs/ansicode.txt`, a summary of the ANSI
terminal protocol, which has been referenced extensively.
There's probably a large number escapes we don't handle, and that's ok.
There's a lot that aren't necessary for everyday terminal usage. If you
feel like something that's not supported should be, feel free to add it.
Please try not to become overzealous and adding support for sequences
only used by folks trapped in 1988.
2016-05-29 05:09:25 +00:00
|
|
|
#[macro_use]
|
|
|
|
mod macros;
|
|
|
|
|
2016-02-26 04:59:21 +00:00
|
|
|
mod renderer;
|
2016-06-09 15:30:55 +00:00
|
|
|
pub mod grid;
|
2016-05-21 18:08:50 +00:00
|
|
|
mod meter;
|
2016-06-30 16:04:06 +00:00
|
|
|
pub mod config;
|
2016-06-23 16:48:31 +00:00
|
|
|
mod input;
|
2016-05-25 03:55:51 +00:00
|
|
|
mod tty;
|
2016-06-09 15:30:55 +00:00
|
|
|
pub mod ansi;
|
2016-05-31 03:44:37 +00:00
|
|
|
mod term;
|
2016-06-08 04:11:23 +00:00
|
|
|
mod util;
|
2016-07-01 04:26:26 +00:00
|
|
|
mod io;
|
2016-07-01 17:34:08 +00:00
|
|
|
mod sync;
|
2016-05-31 03:44:37 +00:00
|
|
|
|
2016-07-01 17:34:08 +00:00
|
|
|
use std::io::{Write, BufWriter, Read};
|
2016-06-28 02:46:24 +00:00
|
|
|
use std::sync::{mpsc, Arc};
|
|
|
|
|
2016-07-01 17:34:08 +00:00
|
|
|
use sync::PriorityMutex;
|
2016-05-31 03:44:37 +00:00
|
|
|
|
2016-06-30 16:04:06 +00:00
|
|
|
use config::Config;
|
2016-06-23 16:48:31 +00:00
|
|
|
use font::FontDesc;
|
2016-05-31 03:44:37 +00:00
|
|
|
use meter::Meter;
|
2016-06-09 15:30:55 +00:00
|
|
|
use renderer::{QuadRenderer, GlyphCache};
|
2016-06-09 15:16:44 +00:00
|
|
|
use term::Term;
|
2016-06-09 04:24:31 +00:00
|
|
|
use tty::process_should_exit;
|
2016-06-09 15:16:44 +00:00
|
|
|
use util::thread;
|
2016-05-31 03:44:37 +00:00
|
|
|
|
2016-07-01 17:34:08 +00:00
|
|
|
use io::{Utf8Chars, Utf8CharsError};
|
2016-06-09 15:06:47 +00:00
|
|
|
|
|
|
|
#[derive(Debug, Copy, Clone, Eq, PartialEq)]
|
|
|
|
enum ShouldExit {
|
|
|
|
Yes,
|
|
|
|
No
|
|
|
|
}
|
2016-06-30 03:14:37 +00:00
|
|
|
/// Channel used by resize handling on mac
|
2016-07-01 17:34:08 +00:00
|
|
|
static mut resize_sender: Option<mpsc::Sender<glutin::Event>> = None;
|
2016-06-30 03:14:37 +00:00
|
|
|
|
|
|
|
/// Resize handling for Mac
|
|
|
|
fn window_resize_handler(width: u32, height: u32) {
|
|
|
|
unsafe {
|
|
|
|
if let Some(ref tx) = resize_sender {
|
2016-07-01 17:34:08 +00:00
|
|
|
let _ = tx.send(glutin::Event::Resized(width, height));
|
2016-06-30 03:14:37 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-07-01 17:34:08 +00:00
|
|
|
fn handle_event<W>(event: glutin::Event,
|
2016-06-09 15:06:47 +00:00
|
|
|
writer: &mut W,
|
|
|
|
terminal: &mut Term,
|
2016-06-29 17:21:02 +00:00
|
|
|
render_tx: &mpsc::Sender<(u32, u32)>,
|
2016-06-23 16:48:31 +00:00
|
|
|
input_processor: &mut input::Processor) -> ShouldExit
|
2016-06-09 15:06:47 +00:00
|
|
|
where W: Write
|
|
|
|
{
|
2016-07-01 17:34:08 +00:00
|
|
|
// Handle keyboard/mouse input and other window events
|
2016-06-09 15:06:47 +00:00
|
|
|
match event {
|
2016-07-01 17:34:08 +00:00
|
|
|
glutin::Event::Closed => return ShouldExit::Yes,
|
|
|
|
glutin::Event::ReceivedCharacter(c) => {
|
|
|
|
let encoded = c.encode_utf8();
|
|
|
|
writer.write(encoded.as_slice()).unwrap();
|
|
|
|
},
|
|
|
|
glutin::Event::Resized(w, h) => {
|
|
|
|
terminal.resize(w as f32, h as f32);
|
|
|
|
render_tx.send((w, h)).expect("render thread active");
|
|
|
|
},
|
|
|
|
glutin::Event::KeyboardInput(state, _code, key) => {
|
2016-07-02 15:32:28 +00:00
|
|
|
input_processor.process(state, key, &mut input::WriteNotifier(writer), *terminal.mode())
|
2016-07-01 17:34:08 +00:00
|
|
|
},
|
|
|
|
_ => ()
|
2016-06-09 15:06:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ShouldExit::No
|
|
|
|
}
|
|
|
|
|
2016-05-31 03:44:37 +00:00
|
|
|
#[derive(Debug, Eq, PartialEq, Copy, Clone, Default)]
|
|
|
|
pub struct Rgb {
|
|
|
|
r: u8,
|
|
|
|
g: u8,
|
|
|
|
b: u8,
|
|
|
|
}
|
2016-02-24 04:42:58 +00:00
|
|
|
|
2016-05-21 04:36:28 +00:00
|
|
|
mod gl {
|
|
|
|
include!(concat!(env!("OUT_DIR"), "/gl_bindings.rs"));
|
|
|
|
}
|
|
|
|
|
2016-06-10 03:39:40 +00:00
|
|
|
fn main() {
|
2016-06-30 16:04:06 +00:00
|
|
|
// Load configuration
|
|
|
|
let config = match Config::load() {
|
|
|
|
Err(err) => match err {
|
|
|
|
// Use default config when not found
|
|
|
|
config::Error::NotFound => Config::default(),
|
|
|
|
// Exit when there's a problem with it
|
|
|
|
_ => die!("{}", err),
|
|
|
|
},
|
|
|
|
Ok(config) => config,
|
|
|
|
};
|
|
|
|
|
|
|
|
let font = config.font();
|
|
|
|
let dpi = config.dpi();
|
|
|
|
let render_timer = config.render_timer();
|
2016-06-10 03:39:40 +00:00
|
|
|
|
2016-06-30 03:14:37 +00:00
|
|
|
let mut window = glutin::WindowBuilder::new()
|
|
|
|
.with_vsync()
|
|
|
|
.with_title("Alacritty")
|
|
|
|
.build().unwrap();
|
|
|
|
window.set_window_resize_callback(Some(window_resize_handler as fn(u32, u32)));
|
2016-06-10 03:39:40 +00:00
|
|
|
|
|
|
|
gl::load_with(|symbol| window.get_proc_address(symbol) as *const _);
|
|
|
|
let (width, height) = window.get_inner_size_pixels().unwrap();
|
2016-02-28 04:26:31 +00:00
|
|
|
let dpr = window.hidpi_factor();
|
|
|
|
|
2016-06-10 03:39:40 +00:00
|
|
|
println!("device_pixel_ratio: {}", dpr);
|
|
|
|
|
2016-06-30 16:04:06 +00:00
|
|
|
let desc = FontDesc::new(font.family(), font.style());
|
|
|
|
let mut rasterizer = font::Rasterizer::new(dpi.x(), dpi.y(), dpr);
|
2016-04-10 23:19:39 +00:00
|
|
|
|
2016-06-30 16:04:06 +00:00
|
|
|
let metrics = rasterizer.metrics(&desc, font.size());
|
|
|
|
let cell_width = (metrics.average_advance + font.offset().x() as f64) as u32;
|
|
|
|
let cell_height = (metrics.line_height + font.offset().y() as f64) as u32;
|
2016-04-10 23:19:39 +00:00
|
|
|
|
2016-06-10 03:39:40 +00:00
|
|
|
println!("Cell Size: ({} x {})", cell_width, cell_height);
|
|
|
|
|
2016-06-28 16:18:54 +00:00
|
|
|
let terminal = Term::new(width as f32, height as f32, cell_width as f32, cell_height as f32);
|
2016-05-25 03:55:51 +00:00
|
|
|
|
2016-07-01 17:34:08 +00:00
|
|
|
let mut reader = terminal.tty().reader();
|
2016-06-28 16:18:54 +00:00
|
|
|
let writer = terminal.tty().writer();
|
2016-06-06 21:31:12 +00:00
|
|
|
|
2016-06-30 16:04:06 +00:00
|
|
|
let mut glyph_cache = GlyphCache::new(rasterizer, desc, font.size());
|
2016-02-24 04:42:58 +00:00
|
|
|
|
2016-06-09 15:06:47 +00:00
|
|
|
let (tx, rx) = mpsc::channel();
|
2016-06-30 03:14:37 +00:00
|
|
|
unsafe {
|
|
|
|
resize_sender = Some(tx.clone());
|
|
|
|
}
|
2016-07-01 17:34:08 +00:00
|
|
|
|
|
|
|
let terminal = Arc::new(PriorityMutex::new(terminal));
|
|
|
|
let term_ref = terminal.clone();
|
|
|
|
let term_updater = terminal.clone();
|
|
|
|
|
|
|
|
// Rendering thread
|
|
|
|
//
|
|
|
|
// Holds lock only when updating terminal
|
2016-06-09 04:24:31 +00:00
|
|
|
let reader_thread = thread::spawn_named("TTY Reader", move || {
|
2016-07-01 17:34:08 +00:00
|
|
|
let mut buf = [0u8; 4096];
|
|
|
|
let mut start = 0;
|
|
|
|
let mut pty_parser = ansi::Parser::new();
|
|
|
|
|
|
|
|
'reader: loop {
|
|
|
|
let got = reader.read(&mut buf[start..]).expect("pty fd active");
|
|
|
|
let mut remain = 0;
|
|
|
|
|
|
|
|
// if `start` is nonzero, then actual bytes in buffer is > `got` by `start` bytes.
|
|
|
|
let end = start + got;
|
|
|
|
let mut terminal = term_updater.lock_low();
|
|
|
|
for c in Utf8Chars::new(&buf[..end]) {
|
|
|
|
match c {
|
|
|
|
Ok(c) => pty_parser.advance(&mut *terminal, c),
|
|
|
|
Err(err) => match err {
|
|
|
|
Utf8CharsError::IncompleteUtf8(unused) => {
|
|
|
|
remain = unused;
|
|
|
|
break;
|
|
|
|
},
|
|
|
|
_ => panic!("{}", err),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Move any leftover bytes to front of buffer
|
|
|
|
for i in 0..remain {
|
|
|
|
buf[i] = buf[end - (remain - i)];
|
|
|
|
}
|
|
|
|
start = remain;
|
2016-05-31 03:44:37 +00:00
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
let mut meter = Meter::new();
|
|
|
|
|
2016-06-09 15:06:47 +00:00
|
|
|
let window = Arc::new(window);
|
|
|
|
let window_ref = window.clone();
|
|
|
|
|
2016-06-29 17:21:02 +00:00
|
|
|
let (render_tx, render_rx) = mpsc::channel::<(u32, u32)>();
|
|
|
|
|
2016-06-28 02:46:24 +00:00
|
|
|
let update_thread = thread::spawn_named("Update", move || {
|
2016-07-01 17:34:08 +00:00
|
|
|
let mut input_processor = input::Processor::new();
|
|
|
|
|
2016-06-28 02:46:24 +00:00
|
|
|
'main_loop: loop {
|
|
|
|
let mut writer = BufWriter::new(&writer);
|
2016-06-23 16:48:31 +00:00
|
|
|
|
2016-06-28 02:46:24 +00:00
|
|
|
if process_should_exit() {
|
|
|
|
break;
|
|
|
|
}
|
2016-06-09 15:06:47 +00:00
|
|
|
|
2016-06-28 02:46:24 +00:00
|
|
|
// Block waiting for next event and handle it
|
|
|
|
let event = match rx.recv() {
|
|
|
|
Ok(e) => e,
|
|
|
|
Err(mpsc::RecvError) => break,
|
|
|
|
};
|
|
|
|
|
|
|
|
// Need mutable terminal for updates; lock it.
|
2016-07-01 17:34:08 +00:00
|
|
|
let mut terminal = terminal.lock_low();
|
2016-06-28 02:46:24 +00:00
|
|
|
let res = handle_event(event,
|
|
|
|
&mut writer,
|
|
|
|
&mut *terminal,
|
2016-06-29 17:21:02 +00:00
|
|
|
&render_tx,
|
2016-06-28 02:46:24 +00:00
|
|
|
&mut input_processor);
|
|
|
|
if res == ShouldExit::Yes {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Handle Any events that are in the queue
|
|
|
|
loop {
|
|
|
|
match rx.try_recv() {
|
2016-06-09 15:30:55 +00:00
|
|
|
Ok(e) => {
|
2016-06-23 16:48:31 +00:00
|
|
|
let res = handle_event(e,
|
|
|
|
&mut writer,
|
2016-06-28 02:46:24 +00:00
|
|
|
&mut *terminal,
|
2016-06-29 17:21:02 +00:00
|
|
|
&render_tx,
|
2016-06-23 16:48:31 +00:00
|
|
|
&mut input_processor);
|
2016-06-28 02:46:24 +00:00
|
|
|
|
2016-06-09 15:30:55 +00:00
|
|
|
if res == ShouldExit::Yes {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
},
|
2016-06-28 02:46:24 +00:00
|
|
|
Err(mpsc::TryRecvError::Disconnected) => break 'main_loop,
|
|
|
|
Err(mpsc::TryRecvError::Empty) => break,
|
2016-06-09 15:30:55 +00:00
|
|
|
}
|
|
|
|
}
|
2016-06-28 02:46:24 +00:00
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
let render_thread = thread::spawn_named("Render", move || {
|
|
|
|
let _ = unsafe { window.make_current() };
|
|
|
|
unsafe {
|
|
|
|
gl::Viewport(0, 0, width as i32, height as i32);
|
|
|
|
gl::Enable(gl::BLEND);
|
|
|
|
gl::BlendFunc(gl::SRC1_COLOR, gl::ONE_MINUS_SRC1_COLOR);
|
|
|
|
gl::Enable(gl::MULTISAMPLE);
|
|
|
|
}
|
|
|
|
|
2016-06-28 16:18:54 +00:00
|
|
|
// Create renderer
|
2016-06-28 02:46:24 +00:00
|
|
|
let mut renderer = QuadRenderer::new(width, height);
|
2016-06-28 16:18:54 +00:00
|
|
|
|
|
|
|
// Initialize glyph cache
|
|
|
|
{
|
2016-07-01 17:34:08 +00:00
|
|
|
let terminal = term_ref.lock_high();
|
2016-06-28 16:18:54 +00:00
|
|
|
renderer.with_api(terminal.size_info(), |mut api| {
|
|
|
|
glyph_cache.init(&mut api);
|
|
|
|
});
|
|
|
|
}
|
2016-05-31 03:44:37 +00:00
|
|
|
|
2016-06-28 02:46:24 +00:00
|
|
|
loop {
|
2016-06-10 03:39:40 +00:00
|
|
|
unsafe {
|
|
|
|
gl::ClearColor(0.0, 0.0, 0.00, 1.0);
|
|
|
|
gl::Clear(gl::COLOR_BUFFER_BIT);
|
|
|
|
}
|
2016-02-24 04:42:58 +00:00
|
|
|
|
2016-06-29 17:21:02 +00:00
|
|
|
// Receive any resize events; only call gl::Viewport on last available
|
|
|
|
let mut new_size = None;
|
|
|
|
while let Ok(val) = render_rx.try_recv() {
|
|
|
|
new_size = Some(val);
|
|
|
|
}
|
|
|
|
if let Some((w, h)) = new_size.take() {
|
|
|
|
renderer.resize(w as i32, h as i32);
|
|
|
|
}
|
|
|
|
|
2016-06-28 16:18:54 +00:00
|
|
|
// Need scope so lock is released when swap_buffers is called
|
2016-06-10 03:39:40 +00:00
|
|
|
{
|
2016-06-28 02:46:24 +00:00
|
|
|
// Acquire term lock
|
2016-07-01 17:34:08 +00:00
|
|
|
let terminal = term_ref.lock_high();
|
2016-02-24 04:42:58 +00:00
|
|
|
|
2016-06-28 16:18:54 +00:00
|
|
|
// Draw grid + cursor
|
|
|
|
{
|
|
|
|
let _sampler = meter.sampler();
|
2016-05-21 18:08:50 +00:00
|
|
|
|
2016-06-28 16:18:54 +00:00
|
|
|
renderer.with_api(terminal.size_info(), |mut api| {
|
|
|
|
// Draw the grid
|
|
|
|
api.render_grid(terminal.grid(), &mut glyph_cache);
|
2016-06-09 04:24:31 +00:00
|
|
|
|
2016-06-28 16:18:54 +00:00
|
|
|
// Also draw the cursor
|
|
|
|
if terminal.mode().contains(term::mode::SHOW_CURSOR) {
|
|
|
|
api.render_cursor(terminal.cursor(), &mut glyph_cache);
|
|
|
|
}
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
// Draw render timer
|
2016-06-30 16:04:06 +00:00
|
|
|
if render_timer {
|
|
|
|
let timing = format!("{:.3} usec", meter.average());
|
|
|
|
let color = Rgb { r: 0xd5, g: 0x4e, b: 0x53 };
|
|
|
|
renderer.with_api(terminal.size_info(), |mut api| {
|
|
|
|
api.render_string(&timing[..], &mut glyph_cache, &color);
|
|
|
|
});
|
|
|
|
}
|
2016-06-28 16:18:54 +00:00
|
|
|
}
|
2016-06-09 15:06:47 +00:00
|
|
|
|
2016-06-10 03:39:40 +00:00
|
|
|
window.swap_buffers().unwrap();
|
|
|
|
|
|
|
|
if process_should_exit() {
|
2016-06-28 02:46:24 +00:00
|
|
|
break;
|
2016-06-10 03:39:40 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
});
|
2016-06-09 15:06:47 +00:00
|
|
|
|
2016-06-10 03:39:40 +00:00
|
|
|
'event_processing: loop {
|
|
|
|
for event in window_ref.wait_events() {
|
2016-07-01 17:34:08 +00:00
|
|
|
tx.send(event).unwrap();
|
2016-06-10 03:39:40 +00:00
|
|
|
if process_should_exit() {
|
|
|
|
break 'event_processing;
|
|
|
|
}
|
2016-06-09 04:24:31 +00:00
|
|
|
}
|
2016-02-24 04:42:58 +00:00
|
|
|
}
|
2016-06-08 04:12:21 +00:00
|
|
|
|
2016-06-09 15:06:47 +00:00
|
|
|
reader_thread.join().ok();
|
2016-06-10 03:39:40 +00:00
|
|
|
render_thread.join().ok();
|
2016-06-28 02:46:24 +00:00
|
|
|
update_thread.join().ok();
|
2016-06-09 04:24:31 +00:00
|
|
|
println!("Goodbye");
|
2016-02-24 04:42:58 +00:00
|
|
|
}
|
|
|
|
|