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(inclusive_range_syntax)]
|
2016-06-30 03:14:37 +00:00
|
|
|
#![feature(drop_types_in_const)]
|
2016-10-14 23:38:15 +00:00
|
|
|
#![allow(stable_features)] // lying about question_mark because 1.14.0 isn't released!
|
|
|
|
|
|
|
|
#![feature(proc_macro)]
|
|
|
|
|
|
|
|
#[macro_use]
|
|
|
|
extern crate serde_derive;
|
2016-05-25 03:55:51 +00:00
|
|
|
|
2016-11-20 00:16:20 +00:00
|
|
|
#[macro_use]
|
|
|
|
extern crate alacritty;
|
2016-06-30 16:04:06 +00:00
|
|
|
extern crate cgmath;
|
2016-10-09 01:42:33 +00:00
|
|
|
extern crate copypasta;
|
2016-06-30 16:04:06 +00:00
|
|
|
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-09-24 23:11:50 +00:00
|
|
|
extern crate mio;
|
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;
|
2016-11-20 00:16:20 +00:00
|
|
|
extern crate serde_json;
|
2016-06-30 16:04:06 +00:00
|
|
|
extern crate serde_yaml;
|
2016-09-18 18:17:44 +00:00
|
|
|
extern crate vte;
|
2016-02-21 23:20:03 +00:00
|
|
|
|
2016-06-06 23:54:15 +00:00
|
|
|
#[macro_use]
|
|
|
|
extern crate bitflags;
|
|
|
|
|
2016-06-28 02:46:24 +00:00
|
|
|
use std::sync::{mpsc, Arc};
|
2016-11-20 00:16:20 +00:00
|
|
|
use std::sync::atomic::Ordering;
|
2016-06-28 02:46:24 +00:00
|
|
|
|
2016-09-23 17:12:11 +00:00
|
|
|
use parking_lot::{MutexGuard};
|
2016-05-31 03:44:37 +00:00
|
|
|
|
2016-11-20 00:16:20 +00:00
|
|
|
use alacritty::Flag;
|
|
|
|
use alacritty::Rgb;
|
|
|
|
use alacritty::config::{self, Config};
|
|
|
|
use alacritty::event;
|
|
|
|
use alacritty::gl;
|
|
|
|
use alacritty::input;
|
|
|
|
use alacritty::meter::Meter;
|
|
|
|
use alacritty::renderer::{QuadRenderer, GlyphCache};
|
|
|
|
use alacritty::sync::FairMutex;
|
|
|
|
use alacritty::term::{self, Term};
|
|
|
|
use alacritty::tty::{self, Pty, process_should_exit};
|
|
|
|
use alacritty::event_loop::EventLoop;
|
2016-05-31 03:44:37 +00:00
|
|
|
|
2016-06-30 03:14:37 +00:00
|
|
|
/// Channel used by resize handling on mac
|
2016-11-12 01:40:12 +00:00
|
|
|
static mut RESIZE_CALLBACK: Option<Box<Fn(u32, u32)>> = None;
|
2016-06-30 03:14:37 +00:00
|
|
|
|
|
|
|
/// Resize handling for Mac
|
|
|
|
fn window_resize_handler(width: u32, height: u32) {
|
|
|
|
unsafe {
|
2016-11-12 01:40:12 +00:00
|
|
|
RESIZE_CALLBACK.as_ref().map(|func| func(width, height));
|
2016-06-30 03:14:37 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-06-10 03:39:40 +00:00
|
|
|
fn main() {
|
2016-06-30 16:04:06 +00:00
|
|
|
// Load configuration
|
2016-10-27 17:05:04 +00:00
|
|
|
let (config, config_path) = match Config::load() {
|
2016-06-30 16:04:06 +00:00
|
|
|
Err(err) => match err {
|
|
|
|
// Use default config when not found
|
2016-10-27 17:05:04 +00:00
|
|
|
config::Error::NotFound => (Config::default(), None),
|
2016-06-30 16:04:06 +00:00
|
|
|
// Exit when there's a problem with it
|
|
|
|
_ => die!("{}", err),
|
|
|
|
},
|
2016-10-27 17:05:04 +00:00
|
|
|
Ok((config, path)) => (config, Some(path)),
|
2016-06-30 16:04:06 +00:00
|
|
|
};
|
|
|
|
|
2016-11-20 00:16:20 +00:00
|
|
|
let mut ref_test = false;
|
|
|
|
let mut columns = 80;
|
|
|
|
let mut lines = 24;
|
|
|
|
|
|
|
|
let mut args_iter = ::std::env::args();
|
|
|
|
while let Some(arg) = args_iter.next() {
|
|
|
|
match &arg[..] {
|
|
|
|
// Generate ref test
|
|
|
|
"--ref-test" => ref_test = true,
|
|
|
|
// Set dimensions
|
|
|
|
"-d" | "--dimensions" => {
|
|
|
|
args_iter.next()
|
|
|
|
.map(|w| w.parse().map(|w| columns = w));
|
|
|
|
args_iter.next()
|
|
|
|
.map(|h| h.parse().map(|h| lines = h));
|
|
|
|
},
|
|
|
|
// ignore unexpected
|
|
|
|
_ => (),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-06-30 16:04:06 +00:00
|
|
|
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();
|
2016-07-04 21:46:25 +00:00
|
|
|
|
2016-06-30 03:14:37 +00:00
|
|
|
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-07-04 15:32:55 +00:00
|
|
|
let _ = unsafe { window.make_current() };
|
|
|
|
unsafe {
|
2016-11-20 00:16:20 +00:00
|
|
|
// gl::Viewport(0, 0, width as i32, height as i32);
|
2016-07-04 15:32:55 +00:00
|
|
|
gl::Enable(gl::BLEND);
|
|
|
|
gl::BlendFunc(gl::SRC1_COLOR, gl::ONE_MINUS_SRC1_COLOR);
|
|
|
|
gl::Enable(gl::MULTISAMPLE);
|
|
|
|
}
|
|
|
|
|
2016-08-12 18:38:41 +00:00
|
|
|
let rasterizer = font::Rasterizer::new(dpi.x(), dpi.y(), dpr);
|
2016-04-10 23:19:39 +00:00
|
|
|
|
2016-08-12 18:38:41 +00:00
|
|
|
// Create renderer
|
2016-10-23 22:37:06 +00:00
|
|
|
let mut renderer = QuadRenderer::new(&config, width, height);
|
2016-08-12 18:38:41 +00:00
|
|
|
|
|
|
|
// Initialize glyph cache
|
2016-08-30 02:23:04 +00:00
|
|
|
let glyph_cache = {
|
2016-08-12 18:38:41 +00:00
|
|
|
println!("Initializing glyph cache");
|
|
|
|
let init_start = ::std::time::Instant::now();
|
|
|
|
|
|
|
|
let cache = renderer.with_loader(|mut api| {
|
|
|
|
GlyphCache::new(rasterizer, &config, &mut api)
|
|
|
|
});
|
|
|
|
|
|
|
|
let stop = init_start.elapsed();
|
|
|
|
let stop_f = stop.as_secs() as f64 + stop.subsec_nanos() as f64 / 1_000_000_000f64;
|
|
|
|
println!("Finished initializing glyph cache in {}", stop_f);
|
|
|
|
|
|
|
|
cache
|
|
|
|
};
|
|
|
|
|
|
|
|
let metrics = glyph_cache.font_metrics();
|
2016-06-30 16:04:06 +00:00
|
|
|
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-11-20 00:16:20 +00:00
|
|
|
// Resize window to be 80 col x 24 lines
|
|
|
|
let width = cell_width * columns + 4;
|
|
|
|
let height = cell_height * lines + 4;
|
|
|
|
println!("set_inner_size: {} x {}", width, height);
|
|
|
|
// Is this in points?
|
|
|
|
let width_pts = (width as f32 / dpr) as u32;
|
|
|
|
let height_pts = (height as f32 / dpr) as u32;
|
|
|
|
println!("set_inner_size: {} x {}; pts: {} x {}", width, height, width_pts, height_pts);
|
|
|
|
window.set_inner_size(width_pts, height_pts);
|
|
|
|
renderer.resize(width as _, height as _);
|
|
|
|
|
2016-06-10 03:39:40 +00:00
|
|
|
println!("Cell Size: ({} x {})", cell_width, cell_height);
|
|
|
|
|
2016-11-20 00:16:20 +00:00
|
|
|
let size = term::SizeInfo {
|
|
|
|
width: width as f32,
|
|
|
|
height: height as f32,
|
|
|
|
cell_width: cell_width as f32,
|
|
|
|
cell_height: cell_height as f32
|
|
|
|
};
|
|
|
|
|
|
|
|
let terminal = Term::new(size);
|
|
|
|
let pty = tty::new(size.lines(), size.cols());
|
|
|
|
pty.resize(size.lines(), size.cols(), size.width as usize, size.height as usize);
|
|
|
|
let pty_io = pty.reader();
|
2016-02-24 04:42:58 +00:00
|
|
|
|
2016-06-09 15:06:47 +00:00
|
|
|
let (tx, rx) = mpsc::channel();
|
2016-07-01 17:34:08 +00:00
|
|
|
|
2016-09-18 18:17:44 +00:00
|
|
|
let signal_flag = Flag::new(false);
|
|
|
|
|
2016-09-23 17:12:11 +00:00
|
|
|
let terminal = Arc::new(FairMutex::new(terminal));
|
2016-08-30 02:23:04 +00:00
|
|
|
|
2016-11-12 01:40:12 +00:00
|
|
|
// Setup the rsize callback for osx
|
|
|
|
let terminal_ref = terminal.clone();
|
|
|
|
let signal_flag_ref = signal_flag.clone();
|
|
|
|
let proxy = window.create_window_proxy();
|
|
|
|
let tx2 = tx.clone();
|
|
|
|
unsafe {
|
|
|
|
RESIZE_CALLBACK = Some(Box::new(move |width: u32, height: u32| {
|
|
|
|
let _ = tx2.send((width, height));
|
|
|
|
if !signal_flag_ref.0.swap(true, Ordering::AcqRel) {
|
|
|
|
// We raised the signal flag
|
|
|
|
let mut terminal = terminal_ref.lock();
|
|
|
|
terminal.dirty = true;
|
|
|
|
proxy.wakeup_event_loop();
|
|
|
|
}
|
|
|
|
}));
|
|
|
|
}
|
|
|
|
|
2016-09-24 23:11:50 +00:00
|
|
|
let event_loop = EventLoop::new(
|
2016-09-18 18:17:44 +00:00
|
|
|
terminal.clone(),
|
|
|
|
window.create_window_proxy(),
|
2016-09-24 23:11:50 +00:00
|
|
|
signal_flag.clone(),
|
|
|
|
pty_io,
|
2016-11-20 00:16:20 +00:00
|
|
|
ref_test,
|
2016-09-18 18:17:44 +00:00
|
|
|
);
|
2016-09-01 17:24:20 +00:00
|
|
|
|
2016-09-24 23:11:50 +00:00
|
|
|
let loop_tx = event_loop.channel();
|
2016-09-26 15:28:38 +00:00
|
|
|
let event_loop_handle = event_loop.spawn(None);
|
2016-09-24 23:11:50 +00:00
|
|
|
|
2016-09-01 17:24:20 +00:00
|
|
|
// Wraps a renderer and gives simple draw() api.
|
2016-09-18 18:17:44 +00:00
|
|
|
let mut display = Display::new(
|
2016-12-04 21:29:08 +00:00
|
|
|
&window,
|
2016-09-18 18:17:44 +00:00
|
|
|
renderer,
|
|
|
|
glyph_cache,
|
|
|
|
render_timer,
|
2016-11-20 00:16:20 +00:00
|
|
|
rx,
|
|
|
|
pty
|
2016-09-18 18:17:44 +00:00
|
|
|
);
|
2016-09-01 17:24:20 +00:00
|
|
|
|
|
|
|
// Event processor
|
2016-09-24 23:11:50 +00:00
|
|
|
let mut processor = event::Processor::new(
|
|
|
|
input::LoopNotifier(loop_tx),
|
|
|
|
terminal.clone(),
|
2016-11-15 17:38:50 +00:00
|
|
|
tx,
|
2016-11-20 00:16:20 +00:00
|
|
|
&config,
|
|
|
|
ref_test,
|
2016-09-24 23:11:50 +00:00
|
|
|
);
|
2016-09-01 17:24:20 +00:00
|
|
|
|
2016-10-27 17:05:04 +00:00
|
|
|
let (config_tx, config_rx) = mpsc::channel();
|
|
|
|
|
|
|
|
// create a config watcher when config is loaded from disk
|
|
|
|
let _config_reloader = config_path.map(|config_path| {
|
|
|
|
config::Watcher::new(config_path, ConfigHandler {
|
|
|
|
tx: config_tx,
|
|
|
|
window: window.create_window_proxy(),
|
|
|
|
})
|
|
|
|
});
|
|
|
|
|
2016-09-01 17:24:20 +00:00
|
|
|
// Main loop
|
2016-12-05 00:02:38 +00:00
|
|
|
let mut force_draw;
|
2016-09-01 17:24:20 +00:00
|
|
|
loop {
|
2016-12-05 00:02:38 +00:00
|
|
|
force_draw = false;
|
2016-09-01 17:24:20 +00:00
|
|
|
// Wait for something to happen
|
|
|
|
processor.process_events(&window);
|
|
|
|
|
2016-12-04 23:48:12 +00:00
|
|
|
// Handle config reloads
|
2016-10-27 17:05:04 +00:00
|
|
|
if let Ok(config) = config_rx.try_recv() {
|
2016-12-05 00:02:38 +00:00
|
|
|
force_draw = true;
|
2016-10-27 17:05:04 +00:00
|
|
|
display.update_config(&config);
|
2016-11-15 17:38:50 +00:00
|
|
|
processor.update_config(&config);
|
2016-10-27 17:05:04 +00:00
|
|
|
}
|
|
|
|
|
2016-09-01 17:24:20 +00:00
|
|
|
// Maybe draw the terminal
|
2016-09-23 17:12:11 +00:00
|
|
|
let terminal = terminal.lock();
|
2016-09-22 04:05:27 +00:00
|
|
|
signal_flag.set(false);
|
2016-12-05 00:02:38 +00:00
|
|
|
if force_draw || terminal.dirty {
|
2016-12-04 21:13:44 +00:00
|
|
|
display.draw(terminal, &config);
|
2016-09-01 17:24:20 +00:00
|
|
|
}
|
2016-08-30 02:23:04 +00:00
|
|
|
|
2016-12-04 23:48:12 +00:00
|
|
|
// Begin shutdown if the flag was raised.
|
2016-09-01 17:24:20 +00:00
|
|
|
if process_should_exit() {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2016-09-01 04:16:17 +00:00
|
|
|
|
2016-10-27 17:05:04 +00:00
|
|
|
// FIXME need file watcher to work with custom delegates before
|
|
|
|
// joining config reloader is possible
|
|
|
|
// config_reloader.join().ok();
|
|
|
|
|
2016-09-01 17:24:20 +00:00
|
|
|
// shutdown
|
2016-09-24 23:11:50 +00:00
|
|
|
event_loop_handle.join().ok();
|
2016-08-30 02:23:04 +00:00
|
|
|
println!("Goodbye");
|
|
|
|
}
|
|
|
|
|
2016-10-27 17:05:04 +00:00
|
|
|
struct ConfigHandler {
|
|
|
|
tx: mpsc::Sender<config::Config>,
|
|
|
|
window: ::glutin::WindowProxy,
|
|
|
|
}
|
|
|
|
|
2016-10-28 16:19:48 +00:00
|
|
|
// TODO FIXME
|
2016-10-27 17:05:04 +00:00
|
|
|
impl config::OnConfigReload for ConfigHandler {
|
|
|
|
fn on_config_reload(&mut self, config: Config) {
|
|
|
|
if let Err(..) = self.tx.send(config) {
|
|
|
|
err_println!("Failed to notify of new config");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
self.window.wakeup_event_loop();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-12-04 21:29:08 +00:00
|
|
|
struct Display<'a> {
|
|
|
|
window: &'a glutin::Window,
|
2016-09-01 17:24:20 +00:00
|
|
|
renderer: QuadRenderer,
|
|
|
|
glyph_cache: GlyphCache,
|
|
|
|
render_timer: bool,
|
|
|
|
rx: mpsc::Receiver<(u32, u32)>,
|
|
|
|
meter: Meter,
|
2016-11-20 00:16:20 +00:00
|
|
|
pty: Pty,
|
2016-08-30 02:23:04 +00:00
|
|
|
}
|
2016-07-01 17:34:08 +00:00
|
|
|
|
2016-12-04 21:29:08 +00:00
|
|
|
impl<'a> Display<'a> {
|
2016-10-27 17:05:04 +00:00
|
|
|
pub fn update_config(&mut self, config: &Config) {
|
|
|
|
self.renderer.update_config(config);
|
2016-10-28 15:11:45 +00:00
|
|
|
self.render_timer = config.render_timer();
|
2016-10-27 17:05:04 +00:00
|
|
|
}
|
|
|
|
|
2016-12-04 21:29:08 +00:00
|
|
|
pub fn new(
|
|
|
|
window: &glutin::Window,
|
|
|
|
renderer: QuadRenderer,
|
|
|
|
glyph_cache: GlyphCache,
|
|
|
|
render_timer: bool,
|
|
|
|
rx: mpsc::Receiver<(u32, u32)>,
|
|
|
|
pty: Pty
|
|
|
|
) -> Display {
|
2016-09-01 17:24:20 +00:00
|
|
|
Display {
|
|
|
|
window: window,
|
|
|
|
renderer: renderer,
|
|
|
|
glyph_cache: glyph_cache,
|
|
|
|
render_timer: render_timer,
|
|
|
|
rx: rx,
|
|
|
|
meter: Meter::new(),
|
2016-11-20 00:16:20 +00:00
|
|
|
pty: pty,
|
2016-08-30 02:23:04 +00:00
|
|
|
}
|
2016-09-01 17:24:20 +00:00
|
|
|
}
|
2016-06-09 15:06:47 +00:00
|
|
|
|
2016-09-01 17:24:20 +00:00
|
|
|
/// Draw the screen
|
|
|
|
///
|
|
|
|
/// A reference to Term whose state is being drawn must be provided.
|
|
|
|
///
|
|
|
|
/// This call may block if vsync is enabled
|
2016-12-04 21:13:44 +00:00
|
|
|
pub fn draw(&mut self, mut terminal: MutexGuard<Term>, config: &Config) {
|
2016-09-01 17:24:20 +00:00
|
|
|
terminal.dirty = false;
|
2016-06-28 02:46:24 +00:00
|
|
|
|
2016-09-01 17:24:20 +00:00
|
|
|
// Resize events new_size and are handled outside the poll_events
|
|
|
|
// iterator. This has the effect of coalescing multiple resize
|
|
|
|
// events into one.
|
|
|
|
let mut new_size = None;
|
2016-02-24 04:42:58 +00:00
|
|
|
|
2016-07-04 15:32:55 +00:00
|
|
|
|
2016-09-01 17:24:20 +00:00
|
|
|
// Check for any out-of-band resize events (mac only)
|
|
|
|
while let Ok(sz) = self.rx.try_recv() {
|
|
|
|
new_size = Some(sz);
|
|
|
|
}
|
2016-06-29 17:21:02 +00:00
|
|
|
|
2016-09-01 17:24:20 +00:00
|
|
|
// Receive any resize events; only call gl::Viewport on last
|
|
|
|
// available
|
|
|
|
if let Some((w, h)) = new_size.take() {
|
|
|
|
terminal.resize(w as f32, h as f32);
|
2016-11-20 00:16:20 +00:00
|
|
|
let size = terminal.size_info();
|
|
|
|
self.pty.resize(size.lines(), size.cols(), w as _, h as _);
|
2016-09-01 17:24:20 +00:00
|
|
|
self.renderer.resize(w as i32, h as i32);
|
|
|
|
}
|
2016-08-30 02:23:04 +00:00
|
|
|
|
2016-09-01 17:24:20 +00:00
|
|
|
{
|
|
|
|
let glyph_cache = &mut self.glyph_cache;
|
|
|
|
// Draw grid
|
|
|
|
{
|
|
|
|
let _sampler = self.meter.sampler();
|
2016-06-28 16:18:54 +00:00
|
|
|
|
2016-09-01 17:24:20 +00:00
|
|
|
let size_info = terminal.size_info().clone();
|
2016-12-04 21:13:44 +00:00
|
|
|
self.renderer.with_api(config, &size_info, |mut api| {
|
2016-11-28 22:13:11 +00:00
|
|
|
api.clear();
|
|
|
|
|
2016-09-01 17:24:20 +00:00
|
|
|
// Draw the grid
|
2016-12-04 19:13:24 +00:00
|
|
|
api.render_cells(terminal.renderable_cells(), glyph_cache);
|
2016-09-01 17:24:20 +00:00
|
|
|
});
|
2016-06-28 16:18:54 +00:00
|
|
|
}
|
2016-06-09 15:06:47 +00:00
|
|
|
|
2016-09-01 17:24:20 +00:00
|
|
|
// Draw render timer
|
|
|
|
if self.render_timer {
|
|
|
|
let timing = format!("{:.3} usec", self.meter.average());
|
2016-12-04 19:14:27 +00:00
|
|
|
let color = alacritty::ansi::Color::Spec(Rgb { r: 0xd5, g: 0x4e, b: 0x53 });
|
2016-12-04 21:13:44 +00:00
|
|
|
self.renderer.with_api(config, terminal.size_info(), |mut api| {
|
2016-10-23 22:37:06 +00:00
|
|
|
api.render_string(&timing[..], glyph_cache, &color);
|
2016-09-01 17:24:20 +00:00
|
|
|
});
|
2016-08-30 02:23:04 +00:00
|
|
|
}
|
2016-06-09 04:24:31 +00:00
|
|
|
}
|
2016-09-01 17:24:20 +00:00
|
|
|
|
|
|
|
// Unlock the terminal mutex
|
|
|
|
drop(terminal);
|
|
|
|
self.window.swap_buffers().unwrap();
|
|
|
|
}
|
2016-02-24 04:42:58 +00:00
|
|
|
}
|