1
1
mirror of https://github.com/wez/wezterm.git synced 2024-12-19 11:21:39 +03:00
wezterm/src/config.rs
2018-03-01 08:18:19 -08:00

280 lines
8.8 KiB
Rust

//! Configuration for the gui portion of the terminal
use failure::Error;
use std;
use std::fs;
use std::io::prelude::*;
use term::hyperlink;
use toml;
use term;
use term::color::RgbColor;
#[derive(Debug, Deserialize, Clone)]
pub struct Config {
/// The font size, measured in points
#[serde(default = "default_font_size")]
pub font_size: f64,
/// The DPI to assume
#[serde(default = "default_dpi")]
pub dpi: f64,
/// The baseline font to use
#[serde(default)]
pub font: TextStyle,
/// An optional set of style rules to select the font based
/// on the cell attributes
#[serde(default)]
pub font_rules: Vec<StyleRule>,
/// The color palette
pub colors: Option<Palette>,
/// How many lines of scrollback you want to retain
pub scrollback_lines: Option<usize>,
#[serde(default = "default_hyperlink_rules")]
pub hyperlink_rules: Vec<hyperlink::Rule>,
}
fn default_hyperlink_rules() -> Vec<hyperlink::Rule> {
vec![
// URL with a protocol
hyperlink::Rule::new(r"\b\w+://(?:[\w.-]+)\.[a-z]{2,15}\S*\b", "$0").unwrap(),
// implicit mailto link
hyperlink::Rule::new(r"\b\w+@[\w-]+(\.[\w-]+)+\b", "mailto:$0").unwrap(),
]
}
fn default_font_size() -> f64 {
10.0
}
fn default_dpi() -> f64 {
96.0
}
impl Default for Config {
fn default() -> Self {
Self {
font_size: default_font_size(),
dpi: default_dpi(),
font: TextStyle::default(),
font_rules: Vec::new(),
colors: None,
scrollback_lines: None,
hyperlink_rules: default_hyperlink_rules(),
}
}
}
/// Represents textual styling.
#[derive(Debug, Deserialize, Clone, PartialEq, Eq, Hash)]
pub struct TextStyle {
/// A font config pattern to parse to locate the font.
/// Note that the dpi and current font_size for the terminal
/// will be set on the parsed result.
pub fontconfig_pattern: String,
/// If set, when rendering text that is set to the default
/// foreground color, use this color instead. This is most
/// useful in a `[[font_rules]]` section to implement changing
/// the text color for eg: bold text.
pub foreground: Option<RgbColor>,
}
impl Default for TextStyle {
fn default() -> Self {
Self {
fontconfig_pattern: "monospace".into(),
foreground: None,
}
}
}
impl TextStyle {
/// Make a version of this style with bold enabled.
/// Semi-lame: we just append fontconfig style settings
/// to the string blindly. We could get more involved
/// but it would mean adding in the fontsystem stuff here
/// and this is probably good enough.
fn make_bold(&self) -> Self {
Self {
fontconfig_pattern: format!("{}:weight=bold", self.fontconfig_pattern),
foreground: self.foreground,
}
}
/// Make a version of this style with italic enabled.
/// Semi-lame: we just append fontconfig style settings
/// to the string blindly. We could get more involved
/// but it would mean adding in the fontsystem stuff here
/// and this is probably good enough.
fn make_italic(&self) -> Self {
Self {
fontconfig_pattern: format!("{}:style=Italic", self.fontconfig_pattern),
foreground: self.foreground,
}
}
}
/// Defines a rule that can be used to select a TextStyle given
/// an input CellAttributes value. The logic that applies the
/// matching can be found in src/font/mod.rs. The concept is that
/// the user can specify something like this:
///
/// ```
/// [[font_rules]]
/// italic = true
/// font = { fontconfig_pattern = "Operator Mono SSm Lig:style=Italic" }
/// ```
///
/// The above is translated as: "if the CellAttributes have the italic bit
/// set, then use the italic style of font rather than the default", and
/// stop processing further font rules.
#[derive(Debug, Default, Deserialize, Clone)]
pub struct StyleRule {
/// If present, this rule matches when CellAttributes::intensity holds
/// a value that matches this rule. Valid values are "Bold", "Normal",
/// "Half".
pub intensity: Option<term::Intensity>,
/// If present, this rule matches when CellAttributes::underline holds
/// a value that matches this rule. Valid values are "None", "Single",
/// "Double".
pub underline: Option<term::Underline>,
/// If present, this rule matches when CellAttributes::italic holds
/// a value that matches this rule.
pub italic: Option<bool>,
/// If present, this rule matches when CellAttributes::blink holds
/// a value that matches this rule.
pub blink: Option<bool>,
/// If present, this rule matches when CellAttributes::reverse holds
/// a value that matches this rule.
pub reverse: Option<bool>,
/// If present, this rule matches when CellAttributes::strikethrough holds
/// a value that matches this rule.
pub strikethrough: Option<bool>,
/// If present, this rule matches when CellAttributes::invisible holds
/// a value that matches this rule.
pub invisible: Option<bool>,
/// When this rule matches, `font` specifies the styling to be used.
pub font: TextStyle,
}
impl Config {
pub fn load() -> Result<Self, Error> {
let home = std::env::home_dir().ok_or_else(|| format_err!("can't find home dir"))?;
let paths = [
home.join(".config").join("wezterm").join("wezterm.toml"),
home.join(".wezterm.toml"),
];
for p in paths.iter() {
let mut file = match fs::File::open(p) {
Ok(file) => file,
Err(err) => match err.kind() {
std::io::ErrorKind::NotFound => continue,
_ => bail!("Error opening {}: {:?}", p.display(), err),
},
};
let mut s = String::new();
file.read_to_string(&mut s)?;
let cfg: Self = toml::from_str(&s)
.map_err(|e| format_err!("Error parsing TOML from {}: {:?}", p.display(), e))?;
return Ok(cfg.compute_extra_defaults());
}
Ok(Self::default().compute_extra_defaults())
}
/// In some cases we need to compute expanded values based
/// on those provided by the user. This is where we do that.
fn compute_extra_defaults(&self) -> Self {
let mut cfg = self.clone();
if cfg.font_rules.len() == 0 {
// Expand out some reasonable default font rules
let bold = self.font.make_bold();
let italic = self.font.make_italic();
let bold_italic = bold.make_italic();
cfg.font_rules.push(StyleRule {
italic: Some(true),
font: italic,
..Default::default()
});
cfg.font_rules.push(StyleRule {
intensity: Some(term::Intensity::Bold),
font: bold,
..Default::default()
});
cfg.font_rules.push(StyleRule {
italic: Some(true),
intensity: Some(term::Intensity::Bold),
font: bold_italic,
..Default::default()
});
}
cfg
}
}
#[derive(Debug, Deserialize, Clone)]
pub struct Palette {
/// The text color to use when the attributes are reset to default
pub foreground: Option<RgbColor>,
/// The background color to use when the attributes are reset to default
pub background: Option<RgbColor>,
/// The color of the cursor
pub cursor_fg: Option<RgbColor>,
pub cursor_bg: Option<RgbColor>,
/// The color of selected text
pub selection_fg: Option<RgbColor>,
pub selection_bg: Option<RgbColor>,
/// A list of 8 colors corresponding to the basic ANSI palette
pub ansi: Option<[RgbColor; 8]>,
/// A list of 8 colors corresponding to bright versions of the
/// ANSI palette
pub brights: Option<[RgbColor; 8]>,
}
impl From<Palette> for term::color::ColorPalette {
fn from(cfg: Palette) -> term::color::ColorPalette {
let mut p = term::color::ColorPalette::default();
macro_rules! apply_color {
($name:ident) => {
if let Some($name) = cfg.$name {
p.$name = $name;
}
};
}
apply_color!(foreground);
apply_color!(background);
apply_color!(cursor_fg);
apply_color!(cursor_bg);
apply_color!(selection_fg);
apply_color!(selection_bg);
if let Some(ansi) = cfg.ansi {
for (idx, col) in ansi.iter().enumerate() {
p.colors.0[idx] = *col;
}
}
if let Some(brights) = cfg.brights {
for (idx, col) in brights.iter().enumerate() {
p.colors.0[idx + 8] = *col;
}
}
p
}
}