301 lines
6.9 KiB
Rust
301 lines
6.9 KiB
Rust
|
//! Configuration definitions and file loading
|
||
|
//!
|
||
|
//! Alacritty reads from a config file at startup to determine various runtime
|
||
|
//! parameters including font family and style, font size, etc. In the future,
|
||
|
//! the config file will also hold user and platform specific keybindings.
|
||
|
use std::env;
|
||
|
use std::fs;
|
||
|
use std::io::{self, Read};
|
||
|
use std::path::{Path, PathBuf};
|
||
|
|
||
|
use serde_yaml;
|
||
|
|
||
|
/// Top-level config type
|
||
|
#[derive(Debug, Deserialize, Default)]
|
||
|
pub struct Config {
|
||
|
/// Pixels per inch
|
||
|
#[serde(default)]
|
||
|
dpi: Dpi,
|
||
|
|
||
|
/// Font configuration
|
||
|
#[serde(default)]
|
||
|
font: Font,
|
||
|
|
||
|
/// Should show render timer
|
||
|
#[serde(default)]
|
||
|
render_timer: bool,
|
||
|
}
|
||
|
|
||
|
/// Errors occurring during config loading
|
||
|
#[derive(Debug)]
|
||
|
pub enum Error {
|
||
|
/// Config file not found
|
||
|
NotFound,
|
||
|
|
||
|
/// Couldn't read $HOME environment variable
|
||
|
ReadingEnvHome(env::VarError),
|
||
|
|
||
|
/// io error reading file
|
||
|
Io(io::Error),
|
||
|
|
||
|
/// Not valid yaml or missing parameters
|
||
|
Yaml(serde_yaml::Error),
|
||
|
}
|
||
|
|
||
|
impl ::std::error::Error for Error {
|
||
|
fn cause(&self) -> Option<&::std::error::Error> {
|
||
|
match *self {
|
||
|
Error::NotFound => None,
|
||
|
Error::ReadingEnvHome(ref err) => Some(err),
|
||
|
Error::Io(ref err) => Some(err),
|
||
|
Error::Yaml(ref err) => Some(err),
|
||
|
}
|
||
|
}
|
||
|
|
||
|
fn description(&self) -> &str {
|
||
|
match *self {
|
||
|
Error::NotFound => "could not locate config file",
|
||
|
Error::ReadingEnvHome(ref err) => err.description(),
|
||
|
Error::Io(ref err) => err.description(),
|
||
|
Error::Yaml(ref err) => err.description(),
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
impl ::std::fmt::Display for Error {
|
||
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
||
|
match *self {
|
||
|
Error::NotFound => write!(f, "{}", ::std::error::Error::description(self)),
|
||
|
Error::ReadingEnvHome(ref err) => {
|
||
|
write!(f, "could not read $HOME environment variable: {}", err)
|
||
|
},
|
||
|
Error::Io(ref err) => write!(f, "error reading config file: {}", err),
|
||
|
Error::Yaml(ref err) => write!(f, "problem with config: {}", err),
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
impl From<env::VarError> for Error {
|
||
|
fn from(val: env::VarError) -> Error {
|
||
|
Error::ReadingEnvHome(val)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
impl From<io::Error> for Error {
|
||
|
fn from(val: io::Error) -> Error {
|
||
|
if val.kind() == io::ErrorKind::NotFound {
|
||
|
Error::NotFound
|
||
|
} else {
|
||
|
Error::Io(val)
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
impl From<serde_yaml::Error> for Error {
|
||
|
fn from(val: serde_yaml::Error) -> Error {
|
||
|
Error::Yaml(val)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/// Result from config loading
|
||
|
pub type Result<T> = ::std::result::Result<T, Error>;
|
||
|
|
||
|
impl Config {
|
||
|
/// Attempt to load the config file
|
||
|
///
|
||
|
/// The config file is loaded from the first file it finds in this list of paths
|
||
|
///
|
||
|
/// 1. `$HOME/.config/alacritty.yml`
|
||
|
/// 2. `$HOME/.alacritty.yml`
|
||
|
pub fn load() -> Result<Config> {
|
||
|
let home = env::var("HOME")?;
|
||
|
|
||
|
// First path
|
||
|
let mut path = PathBuf::from(&home);
|
||
|
path.push(".config");
|
||
|
path.push("alacritty.yml");
|
||
|
|
||
|
// Fallback path
|
||
|
let mut alt_path = PathBuf::from(&home);
|
||
|
alt_path.push(".alacritty.yml");
|
||
|
|
||
|
match Config::load_from(&path) {
|
||
|
Ok(c) => Ok(c),
|
||
|
Err(e) => {
|
||
|
match e {
|
||
|
Error::NotFound => Config::load_from(&alt_path),
|
||
|
_ => Err(e),
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/// Get font config
|
||
|
#[inline]
|
||
|
pub fn font(&self) -> &Font {
|
||
|
&self.font
|
||
|
}
|
||
|
|
||
|
/// Get dpi config
|
||
|
#[inline]
|
||
|
pub fn dpi(&self) -> &Dpi {
|
||
|
&self.dpi
|
||
|
}
|
||
|
|
||
|
/// Should show render timer
|
||
|
#[inline]
|
||
|
pub fn render_timer(&self) -> bool {
|
||
|
self.render_timer
|
||
|
}
|
||
|
|
||
|
fn load_from<P: AsRef<Path>>(path: P) -> Result<Config> {
|
||
|
let raw = Config::read_file(path)?;
|
||
|
Ok(serde_yaml::from_str(&raw[..])?)
|
||
|
}
|
||
|
|
||
|
fn read_file<P: AsRef<Path>>(path: P) -> Result<String> {
|
||
|
let mut f = fs::File::open(path)?;
|
||
|
let mut contents = String::new();
|
||
|
f.read_to_string(&mut contents)?;
|
||
|
|
||
|
Ok(contents)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/// Pixels per inch
|
||
|
///
|
||
|
/// This is only used on FreeType systems
|
||
|
#[derive(Debug, Deserialize)]
|
||
|
pub struct Dpi {
|
||
|
/// Horizontal dpi
|
||
|
x: f32,
|
||
|
|
||
|
/// Vertical dpi
|
||
|
y: f32,
|
||
|
}
|
||
|
|
||
|
impl Default for Dpi {
|
||
|
fn default() -> Dpi {
|
||
|
Dpi { x: 96.0, y: 96.0 }
|
||
|
}
|
||
|
}
|
||
|
|
||
|
impl Dpi {
|
||
|
/// Get horizontal dpi
|
||
|
#[inline]
|
||
|
pub fn x(&self) -> f32 {
|
||
|
self.x
|
||
|
}
|
||
|
|
||
|
/// Get vertical dpi
|
||
|
#[inline]
|
||
|
pub fn y(&self) -> f32 {
|
||
|
self.y
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/// Modifications to font spacing
|
||
|
///
|
||
|
/// The way Alacritty calculates vertical and horizontal cell sizes may not be
|
||
|
/// ideal for all fonts. This gives the user a way to tweak those values.
|
||
|
#[derive(Debug, Deserialize)]
|
||
|
pub struct FontOffset {
|
||
|
/// Extra horizontal spacing between letters
|
||
|
x: f32,
|
||
|
/// Extra vertical spacing between lines
|
||
|
y: f32,
|
||
|
}
|
||
|
|
||
|
impl FontOffset {
|
||
|
/// Get letter spacing
|
||
|
#[inline]
|
||
|
pub fn x(&self) -> f32 {
|
||
|
self.x
|
||
|
}
|
||
|
|
||
|
/// Get line spacing
|
||
|
#[inline]
|
||
|
pub fn y(&self) -> f32 {
|
||
|
self.y
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/// Font config
|
||
|
///
|
||
|
/// Defaults are provided at the level of this struct per platform, but not per
|
||
|
/// field in this struct. It might be nice in the future to have defaults for
|
||
|
/// each value independently. Alternatively, maybe erroring when the user
|
||
|
/// doesn't provide complete config is Ok.
|
||
|
#[derive(Debug, Deserialize)]
|
||
|
pub struct Font {
|
||
|
/// Font family
|
||
|
family: String,
|
||
|
|
||
|
/// Font style
|
||
|
style: String,
|
||
|
|
||
|
/// Font size in points
|
||
|
size: f32,
|
||
|
|
||
|
/// Extra spacing per character
|
||
|
offset: FontOffset,
|
||
|
}
|
||
|
|
||
|
impl Font {
|
||
|
/// Get the font family
|
||
|
#[inline]
|
||
|
pub fn family(&self) -> &str {
|
||
|
&self.family[..]
|
||
|
}
|
||
|
|
||
|
/// Get the font style
|
||
|
#[inline]
|
||
|
pub fn style(&self) -> &str {
|
||
|
&self.style[..]
|
||
|
}
|
||
|
|
||
|
/// Get the font size in points
|
||
|
#[inline]
|
||
|
pub fn size(&self) -> f32 {
|
||
|
self.size
|
||
|
}
|
||
|
|
||
|
/// Get offsets to font metrics
|
||
|
#[inline]
|
||
|
pub fn offset(&self) -> &FontOffset {
|
||
|
&self.offset
|
||
|
}
|
||
|
}
|
||
|
|
||
|
#[cfg(target_os = "macos")]
|
||
|
impl Default for Font {
|
||
|
fn default() -> Font {
|
||
|
Font {
|
||
|
family: String::from("Menlo"),
|
||
|
style: String::from("Regular"),
|
||
|
size: 11.0,
|
||
|
offset: FontOffset {
|
||
|
x: 0.0,
|
||
|
y: 0.0
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
#[cfg(target_os = "linux")]
|
||
|
impl Default for Font {
|
||
|
fn default() -> Font {
|
||
|
Font {
|
||
|
family: String::from("DejaVu Sans Mono"),
|
||
|
style: String::from("Book"),
|
||
|
size: 11.0,
|
||
|
offset: FontOffset {
|
||
|
// TODO should improve freetype metrics... shouldn't need such
|
||
|
// drastic offsets for the default!
|
||
|
x: 2.0,
|
||
|
y: -7.0
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|