alacritty/src/main.rs

436 lines
13 KiB
Rust
Raw Normal View History

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.
//
//! Alacritty - The GPU Enhanced Terminal
#![feature(question_mark)]
#![feature(inclusive_range_syntax)]
#![feature(drop_types_in_const)]
#![allow(stable_features)] // lying about question_mark because 1.14.0 isn't released!
#![feature(proc_macro)]
#[macro_use]
extern crate serde_derive;
#[macro_use]
extern crate alacritty;
extern crate cgmath;
extern crate copypasta;
extern crate errno;
Add support for macOS Alacritty now runs on macOS using CoreText for font rendering. The font rendering subsystems were moved into a separate crate called `font`. The font crate provides a unified (albeit limited) API which wraps CoreText on macOS and FreeType/FontConfig on other platforms. The unified API differed slightly from what the original Rasterizer for freetype implemented, and it was updated accordingly. The cell separation properties (sep_x and sep_y) are now premultiplied into the cell width and height. They were previously passed through as uniforms to the shaders; removing them prevents a lot of redundant work. `libc` has some differences between Linux and macOS. `__errno_location` is not available on macOS, and the `errno` crate was brought in to provide a cross-platform API for dealing with errno. Differences in `openpty` were handled by implementing a macOS specific version. It would be worth investigating a way to unify the implementations at some point. A type mismatch with TIOCSCTTY was resolved with a cast. Differences in libc::passwd struct fields were resolved by using std::mem::uninitialized instead of zeroing the struct ourselves. This has the benefit of being much cleaner. The thread setup had to be changed to support both macOS and Linux. macOS requires that events from the window be handled on the main thread. Failure to do so will prevent the glutin window from even showing up! For this reason, the renderer and parser were moved to their own thread, and the input is received on the main thread. This is essentially reverse the setup prior to this commit. Renderer initialization (and thus font cache initialization) had to be moved to the rendering thread as well since there's no way to make_context(null) with glx on Linux. Trying to just call make_context a second time on the rendering thread had resulted in a panic!.
2016-06-10 03:39:40 +00:00
extern crate font;
extern crate glutin;
extern crate libc;
extern crate mio;
extern crate notify;
extern crate parking_lot;
extern crate serde;
extern crate serde_json;
extern crate serde_yaml;
extern crate vte;
#[macro_use]
extern crate bitflags;
use std::sync::{mpsc, Arc};
use std::sync::atomic::Ordering;
use parking_lot::{MutexGuard};
use alacritty::Flag;
use alacritty::Rgb;
use alacritty::config::{self, Config};
use alacritty::event;
use alacritty::event_loop::EventLoop;
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::window::{self, Window, SetInnerSize, Pixels, Size};
mod cli;
Add support for macOS Alacritty now runs on macOS using CoreText for font rendering. The font rendering subsystems were moved into a separate crate called `font`. The font crate provides a unified (albeit limited) API which wraps CoreText on macOS and FreeType/FontConfig on other platforms. The unified API differed slightly from what the original Rasterizer for freetype implemented, and it was updated accordingly. The cell separation properties (sep_x and sep_y) are now premultiplied into the cell width and height. They were previously passed through as uniforms to the shaders; removing them prevents a lot of redundant work. `libc` has some differences between Linux and macOS. `__errno_location` is not available on macOS, and the `errno` crate was brought in to provide a cross-platform API for dealing with errno. Differences in `openpty` were handled by implementing a macOS specific version. It would be worth investigating a way to unify the implementations at some point. A type mismatch with TIOCSCTTY was resolved with a cast. Differences in libc::passwd struct fields were resolved by using std::mem::uninitialized instead of zeroing the struct ourselves. This has the benefit of being much cleaner. The thread setup had to be changed to support both macOS and Linux. macOS requires that events from the window be handled on the main thread. Failure to do so will prevent the glutin window from even showing up! For this reason, the renderer and parser were moved to their own thread, and the input is received on the main thread. This is essentially reverse the setup prior to this commit. Renderer initialization (and thus font cache initialization) had to be moved to the rendering thread as well since there's no way to make_context(null) with glx on Linux. Trying to just call make_context a second time on the rendering thread had resulted in a panic!.
2016-06-10 03:39:40 +00:00
fn main() {
// Load configuration
let config = match Config::load() {
// Error loading config
Err(err) => match err {
// Use default config when not found
config::Error::NotFound => {
err_println!("Config file not found; using defaults");
Config::default()
},
// If there's a problem with the config file, print an error
// and exit.
_ => die!("{}", err),
},
// Successfully loaded config from file
Ok(config) => config
};
// Load command line options
let options = cli::Options::load();
// Run alacritty
run(config, options);
}
/// Run Alacritty
///
/// Currently, these operations take place in this order.
/// 1. create a window
/// 2. create font rasterizer
/// 3. create quad renderer
/// 4. create glyph cache
/// 5. resize window/renderer using info from glyph cache / rasterizer
/// 6. create a pty
/// 7. create the terminal
/// 8. set resize callback on the window
/// 9. create event loop
/// 10. create display
/// 11. create input processor
/// 12. create config reloader
/// 13. enter main loop
///
/// Observations:
/// * The window + quad renderer + glyph cache and display are closely
/// related Actually, probably include the input processor as well.
/// The resize callback can be lumped in there and that resize step.
/// Rasterizer as well. Maybe we can lump *all* of this into the
/// `Display`.
/// * the pty and event loop closely related
/// * The term bridges the display and pty
/// * Main loop currently manages input, config reload events, drawing, and
/// exiting
///
/// It would be *really* great if this could read more like
///
/// ```ignore
/// let display = Display::new(args..);
/// let pty = Pty::new(display.size());
/// let term = Arc::new(Term::new(display.size());
/// let io_loop = Loop::new(Pty::new(display.size()), term.clone());
/// let config_reloader = config::Monitor::new(&config);
///
/// loop {
/// force_draw = false;
/// // Wait for something to happen
/// processor.process_events(&display);
///
/// // Handle config reloads
/// if let Ok(config) = config_rx.try_recv() {
/// force_draw = true;
/// display.update_config(&config);
/// processor.update_config(&config);
/// }
///
/// // Maybe draw the terminal
/// let terminal = terminal.lock();
/// signal_flag.set(false);
/// if force_draw || terminal.dirty {
/// display.draw(terminal, &config);
/// drop(terminal);
/// display.swap_buffers();
/// }
///
/// // Begin shutdown if the flag was raised.
/// if process_should_exit() {
/// break;
/// }
/// }
/// ```
///
/// instead of the 200 line monster it currently is.
///
fn run(config: Config, options: cli::Options) {
// Extract some properties from config
let font = config.font();
let dpi = config.dpi();
let render_timer = config.render_timer();
Add support for macOS Alacritty now runs on macOS using CoreText for font rendering. The font rendering subsystems were moved into a separate crate called `font`. The font crate provides a unified (albeit limited) API which wraps CoreText on macOS and FreeType/FontConfig on other platforms. The unified API differed slightly from what the original Rasterizer for freetype implemented, and it was updated accordingly. The cell separation properties (sep_x and sep_y) are now premultiplied into the cell width and height. They were previously passed through as uniforms to the shaders; removing them prevents a lot of redundant work. `libc` has some differences between Linux and macOS. `__errno_location` is not available on macOS, and the `errno` crate was brought in to provide a cross-platform API for dealing with errno. Differences in `openpty` were handled by implementing a macOS specific version. It would be worth investigating a way to unify the implementations at some point. A type mismatch with TIOCSCTTY was resolved with a cast. Differences in libc::passwd struct fields were resolved by using std::mem::uninitialized instead of zeroing the struct ourselves. This has the benefit of being much cleaner. The thread setup had to be changed to support both macOS and Linux. macOS requires that events from the window be handled on the main thread. Failure to do so will prevent the glutin window from even showing up! For this reason, the renderer and parser were moved to their own thread, and the input is received on the main thread. This is essentially reverse the setup prior to this commit. Renderer initialization (and thus font cache initialization) had to be moved to the rendering thread as well since there's no way to make_context(null) with glx on Linux. Trying to just call make_context a second time on the rendering thread had resulted in a panic!.
2016-06-10 03:39:40 +00:00
// Create the window where Alacritty will be displayed
let mut window = match Window::new() {
Ok(window) => window,
Err(err) => die!("{}", err)
};
Add support for macOS Alacritty now runs on macOS using CoreText for font rendering. The font rendering subsystems were moved into a separate crate called `font`. The font crate provides a unified (albeit limited) API which wraps CoreText on macOS and FreeType/FontConfig on other platforms. The unified API differed slightly from what the original Rasterizer for freetype implemented, and it was updated accordingly. The cell separation properties (sep_x and sep_y) are now premultiplied into the cell width and height. They were previously passed through as uniforms to the shaders; removing them prevents a lot of redundant work. `libc` has some differences between Linux and macOS. `__errno_location` is not available on macOS, and the `errno` crate was brought in to provide a cross-platform API for dealing with errno. Differences in `openpty` were handled by implementing a macOS specific version. It would be worth investigating a way to unify the implementations at some point. A type mismatch with TIOCSCTTY was resolved with a cast. Differences in libc::passwd struct fields were resolved by using std::mem::uninitialized instead of zeroing the struct ourselves. This has the benefit of being much cleaner. The thread setup had to be changed to support both macOS and Linux. macOS requires that events from the window be handled on the main thread. Failure to do so will prevent the glutin window from even showing up! For this reason, the renderer and parser were moved to their own thread, and the input is received on the main thread. This is essentially reverse the setup prior to this commit. Renderer initialization (and thus font cache initialization) had to be moved to the rendering thread as well since there's no way to make_context(null) with glx on Linux. Trying to just call make_context a second time on the rendering thread had resulted in a panic!.
2016-06-10 03:39:40 +00:00
// get window properties for initializing the other subsytems
let size = window.inner_size_pixels().unwrap();
2016-02-28 04:26:31 +00:00
let dpr = window.hidpi_factor();
Add support for macOS Alacritty now runs on macOS using CoreText for font rendering. The font rendering subsystems were moved into a separate crate called `font`. The font crate provides a unified (albeit limited) API which wraps CoreText on macOS and FreeType/FontConfig on other platforms. The unified API differed slightly from what the original Rasterizer for freetype implemented, and it was updated accordingly. The cell separation properties (sep_x and sep_y) are now premultiplied into the cell width and height. They were previously passed through as uniforms to the shaders; removing them prevents a lot of redundant work. `libc` has some differences between Linux and macOS. `__errno_location` is not available on macOS, and the `errno` crate was brought in to provide a cross-platform API for dealing with errno. Differences in `openpty` were handled by implementing a macOS specific version. It would be worth investigating a way to unify the implementations at some point. A type mismatch with TIOCSCTTY was resolved with a cast. Differences in libc::passwd struct fields were resolved by using std::mem::uninitialized instead of zeroing the struct ourselves. This has the benefit of being much cleaner. The thread setup had to be changed to support both macOS and Linux. macOS requires that events from the window be handled on the main thread. Failure to do so will prevent the glutin window from even showing up! For this reason, the renderer and parser were moved to their own thread, and the input is received on the main thread. This is essentially reverse the setup prior to this commit. Renderer initialization (and thus font cache initialization) had to be moved to the rendering thread as well since there's no way to make_context(null) with glx on Linux. Trying to just call make_context a second time on the rendering thread had resulted in a panic!.
2016-06-10 03:39:40 +00:00
println!("device_pixel_ratio: {}", dpr);
let rasterizer = font::Rasterizer::new(dpi.x(), dpi.y(), dpr);
// Create renderer
let mut renderer = QuadRenderer::new(&config, size);
// Initialize glyph cache
let glyph_cache = {
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
};
// Need font metrics to resize the window properly. This suggests to me the
// font metrics should be computed before creating the window in the first
// place so that a resize is not needed.
let metrics = glyph_cache.font_metrics();
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;
// Resize window to specified dimensions
let width = cell_width * options.columns_u32() + 4;
let height = cell_height * options.lines_u32() + 4;
let size = Size { width: Pixels(width), height: Pixels(height) };
println!("set_inner_size: {}", size);
window.set_inner_size(size);
renderer.resize(*size.width as _, *size.height as _);
Add support for macOS Alacritty now runs on macOS using CoreText for font rendering. The font rendering subsystems were moved into a separate crate called `font`. The font crate provides a unified (albeit limited) API which wraps CoreText on macOS and FreeType/FontConfig on other platforms. The unified API differed slightly from what the original Rasterizer for freetype implemented, and it was updated accordingly. The cell separation properties (sep_x and sep_y) are now premultiplied into the cell width and height. They were previously passed through as uniforms to the shaders; removing them prevents a lot of redundant work. `libc` has some differences between Linux and macOS. `__errno_location` is not available on macOS, and the `errno` crate was brought in to provide a cross-platform API for dealing with errno. Differences in `openpty` were handled by implementing a macOS specific version. It would be worth investigating a way to unify the implementations at some point. A type mismatch with TIOCSCTTY was resolved with a cast. Differences in libc::passwd struct fields were resolved by using std::mem::uninitialized instead of zeroing the struct ourselves. This has the benefit of being much cleaner. The thread setup had to be changed to support both macOS and Linux. macOS requires that events from the window be handled on the main thread. Failure to do so will prevent the glutin window from even showing up! For this reason, the renderer and parser were moved to their own thread, and the input is received on the main thread. This is essentially reverse the setup prior to this commit. Renderer initialization (and thus font cache initialization) had to be moved to the rendering thread as well since there's no way to make_context(null) with glx on Linux. Trying to just call make_context a second time on the rendering thread had resulted in a panic!.
2016-06-10 03:39:40 +00:00
println!("Cell Size: ({} x {})", cell_width, cell_height);
let size = term::SizeInfo {
width: *size.width as f32,
height: *size.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();
let (tx, rx) = mpsc::channel();
let signal_flag = Flag::new(false);
let terminal = Arc::new(FairMutex::new(terminal));
// 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();
window.set_resize_callback(move |width, height| {
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();
}
});
let event_loop = EventLoop::new(
terminal.clone(),
window.create_window_proxy(),
signal_flag.clone(),
pty_io,
options.ref_test,
);
let loop_tx = event_loop.channel();
let event_loop_handle = event_loop.spawn(None);
// Wraps a renderer and gives simple draw() api.
let mut display = Display::new(
&window,
renderer,
glyph_cache,
render_timer,
rx,
pty
);
// Event processor
let mut processor = event::Processor::new(
input::LoopNotifier(loop_tx),
terminal.clone(),
tx,
&config,
options.ref_test,
);
let (config_tx, config_rx) = mpsc::channel();
// create a config watcher when config is loaded from disk
let _config_reloader = config.path().map(|path| {
config::Watcher::new(path, ConfigHandler {
tx: config_tx,
window: window.create_window_proxy(),
})
});
// Main loop
2016-12-05 00:02:38 +00:00
let mut force_draw;
loop {
2016-12-05 00:02:38 +00:00
force_draw = false;
// Wait for something to happen
processor.process_events(&window);
2016-12-04 23:48:12 +00:00
// Handle config reloads
if let Ok(config) = config_rx.try_recv() {
2016-12-05 00:02:38 +00:00
force_draw = true;
display.update_config(&config);
processor.update_config(&config);
}
// Maybe draw the terminal
let terminal = terminal.lock();
signal_flag.set(false);
2016-12-05 00:02:38 +00:00
if force_draw || terminal.dirty {
display.draw(terminal, &config);
}
2016-12-04 23:48:12 +00:00
// Begin shutdown if the flag was raised.
if process_should_exit() {
break;
}
}
// FIXME need file watcher to work with custom delegates before
// joining config reloader is possible
// config_reloader.join().ok();
// shutdown
event_loop_handle.join().ok();
println!("Goodbye");
}
struct ConfigHandler {
tx: mpsc::Sender<config::Config>,
window: window::Proxy,
}
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();
}
}
struct Display<'a> {
window: &'a Window,
renderer: QuadRenderer,
glyph_cache: GlyphCache,
render_timer: bool,
rx: mpsc::Receiver<(u32, u32)>,
meter: Meter,
pty: Pty,
}
impl<'a> Display<'a> {
pub fn update_config(&mut self, config: &Config) {
self.renderer.update_config(config);
self.render_timer = config.render_timer();
}
pub fn new(
window: &Window,
renderer: QuadRenderer,
glyph_cache: GlyphCache,
render_timer: bool,
rx: mpsc::Receiver<(u32, u32)>,
pty: Pty
) -> Display {
Display {
window: window,
renderer: renderer,
glyph_cache: glyph_cache,
render_timer: render_timer,
rx: rx,
meter: Meter::new(),
pty: pty,
}
}
/// Draw the screen
///
/// A reference to Term whose state is being drawn must be provided.
///
/// This call may block if vsync is enabled
pub fn draw(&mut self, mut terminal: MutexGuard<Term>, config: &Config) {
terminal.dirty = false;
// 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;
// Check for any out-of-band resize events (mac only)
while let Ok(sz) = self.rx.try_recv() {
new_size = Some(sz);
}
// 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);
let size = terminal.size_info();
self.pty.resize(size.lines(), size.cols(), w as _, h as _);
self.renderer.resize(w as i32, h as i32);
}
{
let glyph_cache = &mut self.glyph_cache;
// Draw grid
{
let _sampler = self.meter.sampler();
let size_info = terminal.size_info().clone();
self.renderer.with_api(config, &size_info, |mut api| {
api.clear();
// Draw the grid
api.render_cells(terminal.renderable_cells(), glyph_cache);
});
}
// Draw render timer
if self.render_timer {
let timing = format!("{:.3} usec", self.meter.average());
let color = alacritty::ansi::Color::Spec(Rgb { r: 0xd5, g: 0x4e, b: 0x53 });
self.renderer.with_api(config, terminal.size_info(), |mut api| {
api.render_string(&timing[..], glyph_cache, &color);
});
}
}
// Unlock the terminal mutex
drop(terminal);
self.window.swap_buffers().unwrap();
}
}