wez/wezterm
1
1
Fork 0
mirror of https://github.com/wez/wezterm.git synced 2024-12-29 00:21:57 +03:00
Code Issues Projects Releases Wiki Activity
bcd1b03569
wezterm/config/src/color.rs

897 lines
27 KiB
Rust
Raw Normal View History

move config into its own crate
2020-10-02 21:50:50 +03:00
use crate::*;
config: cut over to wezterm-dynamic Avoid using serde for mapping between Lua and Rust for the `Config` struct. This improves the build speed of the config crate by 2x; it goes down from 30 seconds to 9 seconds on my 5950x.
2022-05-14 18:00:03 +03:00
use luahelper::impl_lua_conversion_dynamic;
add wezterm.color.save_scheme for exporting color schemes
2022-07-15 09:22:02 +03:00
use std::convert::{TryFrom, TryInto};
allow setting selection colors with alpha values This commit allows the following configuration: ``` wezterm -n --config 'colors = { selection_fg = "clear", selection_bg = "rgba:50% 50% 50% 50%" }' ``` which sets the selection_bg to fully transparent, and selection_bg to 50% transparent gray. When selection_fg is fully transparent we'll use the normal fg color. When selection_bg is partially (or fully!) transparent, it will be alpha blended over the current cell background color. To support this, the config file will now accept rgba colors specified as 4 whitespace delimited numeric values. If a value ends with `%` it is interpreted as a number in the range 0-100. Otherwise, it is interpreted as a number in the range 0-255. The 4 values are red, green, blue, alpha. At this time, only the selection_fg and selection_bg settings accept alpha values. refs: #1615
2022-02-06 01:13:19 +03:00
use std::str::FromStr;
tidy up config imports a little
2019-11-24 18:55:13 +03:00
use termwiz::cell::CellAttributes;
gui: allow specifying colors for copy mode and quickselect refs: https://github.com/wez/wezterm/issues/2320 ```lua return { colors = { copy_mode_active_highlight_fg={Color="red"}, copy_mode_active_highlight_bg={Color="blue"}, copy_mode_inactive_highlight_fg={AnsiColor="Black"}, copy_mode_inactive_highlight_bg={AnsiColor="White"}, quick_select_label_fg={Color="white"}, quick_select_label_bg={Color="blue"}, quick_select_match_fg={Color="grey"}, quick_select_match_bg={Color="skyblue"}, } } ```
2022-07-29 03:54:07 +03:00
use termwiz::color::ColorSpec as TWColorSpec;
pub use termwiz::color::{AnsiColor, ColorAttribute, RgbColor, SrgbaTuple};
tidy up handling of index colors IndexedMap was a temporary measure while I was hacking through the dynamic crate stuff; we don't need it any more.
2022-05-18 19:31:10 +03:00
use wezterm_dynamic::{FromDynamic, ToDynamic};
add wezterm.color.get_default_colors
2022-07-15 07:41:39 +03:00
use wezterm_term::color::ColorPalette;
split more config into separate modules
2019-11-24 18:44:17 +03:00
config: cut over to wezterm-dynamic Avoid using serde for mapping between Lua and Rust for the `Config` struct. This improves the build speed of the config crate by 2x; it goes down from 30 seconds to 9 seconds on my 5950x.
2022-05-14 18:00:03 +03:00
#[derive(Debug, Copy, Clone, FromDynamic, ToDynamic)]
wezterm: revise opacity configuration This commit revises the opacity configuration to make it more consistently applied. * `window_background_opacity` controls the overall window capacity, whether a background image is present or not. * When a background image is present, or if the window is transparent, then text whose background color is the default background is changed to have a fully transparent background. * `text_background_opacity` controls the alpha channel value for text whose background color is NOT the default background. It defaults to 1.0 (fully opaque), but can be set to be transparent by setting it to a number between 0.0 and 1.0. * The inactive pane hue, saturation, brightness multipliers have been factored out into their own struct which changes that set of options to: ```lua return { inactive_pane_hsb = { hue = 1.0, saturation = 1.0, brightness = 1.0, }, } ``` * `window_background_image_hsb` is a new option that can apply a hue, saturation, brightness transformation to a background image. This is primarily useful to make a background image darker: ```lua return { window_background_image = "/some/pic.png", window_background_image_hsb = { brightness = 0.3, }, } ``` refs: #302 refs: #297
2020-10-24 09:16:00 +03:00
pub struct HsbTransform {
config: cut over to wezterm-dynamic Avoid using serde for mapping between Lua and Rust for the `Config` struct. This improves the build speed of the config crate by 2x; it goes down from 30 seconds to 9 seconds on my 5950x.
2022-05-14 18:00:03 +03:00
#[dynamic(default = "default_one_point_oh")]
wezterm: revise opacity configuration This commit revises the opacity configuration to make it more consistently applied. * `window_background_opacity` controls the overall window capacity, whether a background image is present or not. * When a background image is present, or if the window is transparent, then text whose background color is the default background is changed to have a fully transparent background. * `text_background_opacity` controls the alpha channel value for text whose background color is NOT the default background. It defaults to 1.0 (fully opaque), but can be set to be transparent by setting it to a number between 0.0 and 1.0. * The inactive pane hue, saturation, brightness multipliers have been factored out into their own struct which changes that set of options to: ```lua return { inactive_pane_hsb = { hue = 1.0, saturation = 1.0, brightness = 1.0, }, } ``` * `window_background_image_hsb` is a new option that can apply a hue, saturation, brightness transformation to a background image. This is primarily useful to make a background image darker: ```lua return { window_background_image = "/some/pic.png", window_background_image_hsb = { brightness = 0.3, }, } ``` refs: #302 refs: #297
2020-10-24 09:16:00 +03:00
pub hue: f32,
config: cut over to wezterm-dynamic Avoid using serde for mapping between Lua and Rust for the `Config` struct. This improves the build speed of the config crate by 2x; it goes down from 30 seconds to 9 seconds on my 5950x.
2022-05-14 18:00:03 +03:00
#[dynamic(default = "default_one_point_oh")]
wezterm: revise opacity configuration This commit revises the opacity configuration to make it more consistently applied. * `window_background_opacity` controls the overall window capacity, whether a background image is present or not. * When a background image is present, or if the window is transparent, then text whose background color is the default background is changed to have a fully transparent background. * `text_background_opacity` controls the alpha channel value for text whose background color is NOT the default background. It defaults to 1.0 (fully opaque), but can be set to be transparent by setting it to a number between 0.0 and 1.0. * The inactive pane hue, saturation, brightness multipliers have been factored out into their own struct which changes that set of options to: ```lua return { inactive_pane_hsb = { hue = 1.0, saturation = 1.0, brightness = 1.0, }, } ``` * `window_background_image_hsb` is a new option that can apply a hue, saturation, brightness transformation to a background image. This is primarily useful to make a background image darker: ```lua return { window_background_image = "/some/pic.png", window_background_image_hsb = { brightness = 0.3, }, } ``` refs: #302 refs: #297
2020-10-24 09:16:00 +03:00
pub saturation: f32,
config: cut over to wezterm-dynamic Avoid using serde for mapping between Lua and Rust for the `Config` struct. This improves the build speed of the config crate by 2x; it goes down from 30 seconds to 9 seconds on my 5950x.
2022-05-14 18:00:03 +03:00
#[dynamic(default = "default_one_point_oh")]
wezterm: revise opacity configuration This commit revises the opacity configuration to make it more consistently applied. * `window_background_opacity` controls the overall window capacity, whether a background image is present or not. * When a background image is present, or if the window is transparent, then text whose background color is the default background is changed to have a fully transparent background. * `text_background_opacity` controls the alpha channel value for text whose background color is NOT the default background. It defaults to 1.0 (fully opaque), but can be set to be transparent by setting it to a number between 0.0 and 1.0. * The inactive pane hue, saturation, brightness multipliers have been factored out into their own struct which changes that set of options to: ```lua return { inactive_pane_hsb = { hue = 1.0, saturation = 1.0, brightness = 1.0, }, } ``` * `window_background_image_hsb` is a new option that can apply a hue, saturation, brightness transformation to a background image. This is primarily useful to make a background image darker: ```lua return { window_background_image = "/some/pic.png", window_background_image_hsb = { brightness = 0.3, }, } ``` refs: #302 refs: #297
2020-10-24 09:16:00 +03:00
pub brightness: f32,
}
gui: introduce foreground_text_hsb transform This allows explicitly manipulating the hue, saturation, brightness of the text rendered in the terminal, allowing users to dial in the accidental effect that was introduced by d886de830091366cf79ee9b18ad24e6944cba104 For example, this will punch up the brightness: ``` foreground_text_hsb = { hue = 1.0, saturation = 1.0, brightness = 1.5, }, ``` refs: https://github.com/wez/wezterm/issues/491
2021-02-19 19:28:19 +03:00
impl Default for HsbTransform {
fn default() -> Self {
Self {
hue: 1.,
saturation: 1.,
brightness: 1.,
}
}
}
config: cut over to wezterm-dynamic Avoid using serde for mapping between Lua and Rust for the `Config` struct. This improves the build speed of the config crate by 2x; it goes down from 30 seconds to 9 seconds on my 5950x.
2022-05-14 18:00:03 +03:00
#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash, FromDynamic, ToDynamic)]
#[dynamic(try_from = "String", into = "String")]
allow setting selection colors with alpha values This commit allows the following configuration: ``` wezterm -n --config 'colors = { selection_fg = "clear", selection_bg = "rgba:50% 50% 50% 50%" }' ``` which sets the selection_bg to fully transparent, and selection_bg to 50% transparent gray. When selection_fg is fully transparent we'll use the normal fg color. When selection_bg is partially (or fully!) transparent, it will be alpha blended over the current cell background color. To support this, the config file will now accept rgba colors specified as 4 whitespace delimited numeric values. If a value ends with `%` it is interpreted as a number in the range 0-100. Otherwise, it is interpreted as a number in the range 0-255. The 4 values are red, green, blue, alpha. At this time, only the selection_fg and selection_bg settings accept alpha values. refs: #1615
2022-02-06 01:13:19 +03:00
pub struct RgbaColor {
config: cut over to wezterm-dynamic Avoid using serde for mapping between Lua and Rust for the `Config` struct. This improves the build speed of the config crate by 2x; it goes down from 30 seconds to 9 seconds on my 5950x.
2022-05-14 18:00:03 +03:00
#[dynamic(flatten)]
allow setting selection colors with alpha values This commit allows the following configuration: ``` wezterm -n --config 'colors = { selection_fg = "clear", selection_bg = "rgba:50% 50% 50% 50%" }' ``` which sets the selection_bg to fully transparent, and selection_bg to 50% transparent gray. When selection_fg is fully transparent we'll use the normal fg color. When selection_bg is partially (or fully!) transparent, it will be alpha blended over the current cell background color. To support this, the config file will now accept rgba colors specified as 4 whitespace delimited numeric values. If a value ends with `%` it is interpreted as a number in the range 0-100. Otherwise, it is interpreted as a number in the range 0-255. The 4 values are red, green, blue, alpha. At this time, only the selection_fg and selection_bg settings accept alpha values. refs: #1615
2022-02-06 01:13:19 +03:00
color: SrgbaTuple,
}
palette now stores alpha for all color values We're now capable of remembering an alpha value for everything in the palette and the main window theme, but not the tab bar theme. Whether the alpha is correctly respected at render time is a different story! refs: #1835
2022-04-08 17:08:33 +03:00
impl From<RgbColor> for RgbaColor {
fn from(color: RgbColor) -> Self {
Self {
color: color.into(),
}
}
}
pane select: allow bg to have alpha channel Wraps up the changes from the following diff and allows for the modal layer (and box model) to use alpha for poly quads. Change the default background color for pane select to be slightly transparent.
2022-05-26 09:25:09 +03:00
impl From<SrgbaTuple> for RgbaColor {
fn from(color: SrgbaTuple) -> Self {
Self { color }
}
}
termwiz: ColorSpec now allows for alpha to be tracked This doesn't really change any behavior, but adjusts the types such that CSIs that set colors have the potential to track the alpha channel and that can make it through to the GUI/render layer.
2022-07-27 05:39:53 +03:00
impl From<(u8, u8, u8)> for RgbaColor {
fn from((r, g, b): (u8, u8, u8)) -> Self {
let color: SrgbaTuple = (r, g, b).into();
Self { color }
}
}
palette now stores alpha for all color values We're now capable of remembering an alpha value for everything in the palette and the main window theme, but not the tab bar theme. Whether the alpha is correctly respected at render time is a different story! refs: #1835
2022-04-08 17:08:33 +03:00
impl std::ops::Deref for RgbaColor {
type Target = SrgbaTuple;
fn deref(&self) -> &SrgbaTuple {
&self.color
}
}
config: cut over to wezterm-dynamic Avoid using serde for mapping between Lua and Rust for the `Config` struct. This improves the build speed of the config crate by 2x; it goes down from 30 seconds to 9 seconds on my 5950x.
2022-05-14 18:00:03 +03:00
impl Into<String> for &RgbaColor {
fn into(self) -> String {
color: refactor docs, add a couple more methods Moved the gradient function into the color module, but kept an alias under the old name. Gradients now return color objects. Converting colors to string now uses rgba format when alpha is not 100%.
2022-07-12 17:38:39 +03:00
self.color.to_string()
config: cut over to wezterm-dynamic Avoid using serde for mapping between Lua and Rust for the `Config` struct. This improves the build speed of the config crate by 2x; it goes down from 30 seconds to 9 seconds on my 5950x.
2022-05-14 18:00:03 +03:00
}
}
allow setting selection colors with alpha values This commit allows the following configuration: ``` wezterm -n --config 'colors = { selection_fg = "clear", selection_bg = "rgba:50% 50% 50% 50%" }' ``` which sets the selection_bg to fully transparent, and selection_bg to 50% transparent gray. When selection_fg is fully transparent we'll use the normal fg color. When selection_bg is partially (or fully!) transparent, it will be alpha blended over the current cell background color. To support this, the config file will now accept rgba colors specified as 4 whitespace delimited numeric values. If a value ends with `%` it is interpreted as a number in the range 0-100. Otherwise, it is interpreted as a number in the range 0-255. The 4 values are red, green, blue, alpha. At this time, only the selection_fg and selection_bg settings accept alpha values. refs: #1615
2022-02-06 01:13:19 +03:00
impl Into<String> for RgbaColor {
fn into(self) -> String {
color: refactor docs, add a couple more methods Moved the gradient function into the color module, but kept an alias under the old name. Gradients now return color objects. Converting colors to string now uses rgba format when alpha is not 100%.
2022-07-12 17:38:39 +03:00
self.color.to_string()
allow setting selection colors with alpha values This commit allows the following configuration: ``` wezterm -n --config 'colors = { selection_fg = "clear", selection_bg = "rgba:50% 50% 50% 50%" }' ``` which sets the selection_bg to fully transparent, and selection_bg to 50% transparent gray. When selection_fg is fully transparent we'll use the normal fg color. When selection_bg is partially (or fully!) transparent, it will be alpha blended over the current cell background color. To support this, the config file will now accept rgba colors specified as 4 whitespace delimited numeric values. If a value ends with `%` it is interpreted as a number in the range 0-100. Otherwise, it is interpreted as a number in the range 0-255. The 4 values are red, green, blue, alpha. At this time, only the selection_fg and selection_bg settings accept alpha values. refs: #1615
2022-02-06 01:13:19 +03:00
}
}
impl Into<SrgbaTuple> for RgbaColor {
fn into(self) -> SrgbaTuple {
self.color
}
}
tidy up handling of index colors IndexedMap was a temporary measure while I was hacking through the dynamic crate stuff; we don't need it any more.
2022-05-18 19:31:10 +03:00
impl TryFrom<String> for RgbaColor {
allow setting selection colors with alpha values This commit allows the following configuration: ``` wezterm -n --config 'colors = { selection_fg = "clear", selection_bg = "rgba:50% 50% 50% 50%" }' ``` which sets the selection_bg to fully transparent, and selection_bg to 50% transparent gray. When selection_fg is fully transparent we'll use the normal fg color. When selection_bg is partially (or fully!) transparent, it will be alpha blended over the current cell background color. To support this, the config file will now accept rgba colors specified as 4 whitespace delimited numeric values. If a value ends with `%` it is interpreted as a number in the range 0-100. Otherwise, it is interpreted as a number in the range 0-255. The 4 values are red, green, blue, alpha. At this time, only the selection_fg and selection_bg settings accept alpha values. refs: #1615
2022-02-06 01:13:19 +03:00
type Error = anyhow::Error;
fn try_from(s: String) -> anyhow::Result<RgbaColor> {
Ok(RgbaColor {
color: SrgbaTuple::from_str(&s)
.map_err(|_| anyhow::anyhow!("failed to parse {} as RgbaColor", &s))?,
})
}
}
gui: allow specifying colors for copy mode and quickselect refs: https://github.com/wez/wezterm/issues/2320 ```lua return { colors = { copy_mode_active_highlight_fg={Color="red"}, copy_mode_active_highlight_bg={Color="blue"}, copy_mode_inactive_highlight_fg={AnsiColor="Black"}, copy_mode_inactive_highlight_bg={AnsiColor="White"}, quick_select_label_fg={Color="white"}, quick_select_label_bg={Color="blue"}, quick_select_match_fg={Color="grey"}, quick_select_match_bg={Color="skyblue"}, } } ```
2022-07-29 03:54:07 +03:00
#[derive(Debug, FromDynamic, ToDynamic, Clone, Copy, PartialEq, Eq)]
pub enum ColorSpec {
AnsiColor(AnsiColor),
Color(RgbaColor),
Default,
}
impl From<AnsiColor> for ColorSpec {
fn from(color: AnsiColor) -> ColorSpec {
Self::AnsiColor(color)
}
}
impl Into<ColorAttribute> for ColorSpec {
fn into(self) -> ColorAttribute {
match self {
Self::AnsiColor(c) => ColorAttribute::PaletteIndex(c.into()),
Self::Color(RgbaColor { color }) => ColorAttribute::TrueColorWithDefaultFallback(color),
Self::Default => ColorAttribute::Default,
}
}
}
impl Into<TWColorSpec> for ColorSpec {
fn into(self) -> TWColorSpec {
match self {
Self::AnsiColor(c) => c.into(),
Self::Color(RgbaColor { color }) => TWColorSpec::TrueColor(color),
Self::Default => TWColorSpec::Default,
}
}
}
colorschemes: expand to include Gogh color schemes This commit expands the toml file definition to include metadata for the origin url, author and name. A new sync utility fills out that metadata when it pulls from the iterm2 color schemes repo. The utility also pulls down the scheme data json maintained by the Gogh project: https://gogh-co.github.io/Gogh/ and converts it to wezterm's format. About 50% of Gogh overlaps with iterm2; we take the iterm2 versions of those schemes by default because the iterm2 data has more info about things like cursor and selection colors. The sync utility is responsible for compiling the de-duplicated set of scheme data into a form that is used by wezterm and its docs.
2022-07-10 23:26:33 +03:00
#[derive(Default, Debug, Clone, PartialEq, FromDynamic, ToDynamic)]
split more config into separate modules
2019-11-24 18:44:17 +03:00
pub struct Palette {
/// The text color to use when the attributes are reset to default
palette now stores alpha for all color values We're now capable of remembering an alpha value for everything in the palette and the main window theme, but not the tab bar theme. Whether the alpha is correctly respected at render time is a different story! refs: #1835
2022-04-08 17:08:33 +03:00
pub foreground: Option<RgbaColor>,
split more config into separate modules
2019-11-24 18:44:17 +03:00
/// The background color to use when the attributes are reset to default
palette now stores alpha for all color values We're now capable of remembering an alpha value for everything in the palette and the main window theme, but not the tab bar theme. Whether the alpha is correctly respected at render time is a different story! refs: #1835
2022-04-08 17:08:33 +03:00
pub background: Option<RgbaColor>,
split more config into separate modules
2019-11-24 18:44:17 +03:00
/// The color of the cursor
palette now stores alpha for all color values We're now capable of remembering an alpha value for everything in the palette and the main window theme, but not the tab bar theme. Whether the alpha is correctly respected at render time is a different story! refs: #1835
2022-04-08 17:08:33 +03:00
pub cursor_fg: Option<RgbaColor>,
pub cursor_bg: Option<RgbaColor>,
pub cursor_border: Option<RgbaColor>,
split more config into separate modules
2019-11-24 18:44:17 +03:00
/// The color of selected text
allow setting selection colors with alpha values This commit allows the following configuration: ``` wezterm -n --config 'colors = { selection_fg = "clear", selection_bg = "rgba:50% 50% 50% 50%" }' ``` which sets the selection_bg to fully transparent, and selection_bg to 50% transparent gray. When selection_fg is fully transparent we'll use the normal fg color. When selection_bg is partially (or fully!) transparent, it will be alpha blended over the current cell background color. To support this, the config file will now accept rgba colors specified as 4 whitespace delimited numeric values. If a value ends with `%` it is interpreted as a number in the range 0-100. Otherwise, it is interpreted as a number in the range 0-255. The 4 values are red, green, blue, alpha. At this time, only the selection_fg and selection_bg settings accept alpha values. refs: #1615
2022-02-06 01:13:19 +03:00
pub selection_fg: Option<RgbaColor>,
pub selection_bg: Option<RgbaColor>,
split more config into separate modules
2019-11-24 18:44:17 +03:00
/// A list of 8 colors corresponding to the basic ANSI palette
palette now stores alpha for all color values We're now capable of remembering an alpha value for everything in the palette and the main window theme, but not the tab bar theme. Whether the alpha is correctly respected at render time is a different story! refs: #1835
2022-04-08 17:08:33 +03:00
pub ansi: Option<[RgbaColor; 8]>,
split more config into separate modules
2019-11-24 18:44:17 +03:00
/// A list of 8 colors corresponding to bright versions of the
/// ANSI palette
palette now stores alpha for all color values We're now capable of remembering an alpha value for everything in the palette and the main window theme, but not the tab bar theme. Whether the alpha is correctly respected at render time is a different story! refs: #1835
2022-04-08 17:08:33 +03:00
pub brights: Option<[RgbaColor; 8]>,
Add support for setting arbitrary colors ranging from 16 to 256.
2021-08-21 14:46:52 +03:00
/// A map for setting arbitrary colors ranging from 16 to 256 in the color
/// palette
tidy up handling of index colors IndexedMap was a temporary measure while I was hacking through the dynamic crate stuff; we don't need it any more.
2022-05-18 19:31:10 +03:00
#[dynamic(default)]
palette now stores alpha for all color values We're now capable of remembering an alpha value for everything in the palette and the main window theme, but not the tab bar theme. Whether the alpha is correctly respected at render time is a different story! refs: #1835
2022-04-08 17:08:33 +03:00
pub indexed: HashMap<u8, RgbaColor>,
split more config into separate modules
2019-11-24 18:44:17 +03:00
/// Configure the colors and styling of the tab bar
pub tab_bar: Option<TabBarColors>,
Add optional scroll position UI This commit adds a scrollbar that shows the scroll position but that does not currently allow dragging to scroll. The scrollbar occupies the right hand side window padding. The width of the scrollbar can be set by explicitly configuring `window_padding.right`. If the right padding is set to 0 (which is its default value), and the scroll bar is enabled then the cell width will be used for the right padding value instead. The scrollbar can be enabled/disabled via this config setting: ``` enable_scroll_bar = true ``` Its color by this: ``` [colors] scrollbar_thumb = "#444444" ``` (Note that color palette config will be reloaded when the config file is changed, but you'll need to spawn a new tab/window to see the effects because we cannot assume that a config reload should always replace a potentially dynamically adjusted color scheme in a tab).
2019-12-23 05:57:54 +03:00
/// The color of the "thumb" of the scrollbar; the segment that
/// represents the current viewable area
palette now stores alpha for all color values We're now capable of remembering an alpha value for everything in the palette and the main window theme, but not the tab bar theme. Whether the alpha is correctly respected at render time is a different story! refs: #1835
2022-04-08 17:08:33 +03:00
pub scrollbar_thumb: Option<RgbaColor>,
wezterm: make the split color configurable and darker This makes the color of the split divider darker by default, and configurable via the color scheme configuration file. refs: #297
2020-10-20 08:03:21 +03:00
/// The color of the split line between panes
palette now stores alpha for all color values We're now capable of remembering an alpha value for everything in the palette and the main window theme, but not the tab bar theme. Whether the alpha is correctly respected at render time is a different story! refs: #1835
2022-04-08 17:08:33 +03:00
pub split: Option<RgbaColor>,
add visual bell refs: #3
2021-09-25 22:40:22 +03:00
/// The color of the visual bell. If unspecified, the foreground
/// color is used instead.
palette now stores alpha for all color values We're now capable of remembering an alpha value for everything in the palette and the main window theme, but not the tab bar theme. Whether the alpha is correctly respected at render time is a different story! refs: #1835
2022-04-08 17:08:33 +03:00
pub visual_bell: Option<RgbaColor>,
add colors.dead_key_cursor to signal dead and leader key processing When set, the cursor will change to this color during dead key or leader key processing. ```lua return { colors = { dead_key_cursor = "orange", }, } ``` refs: #686 refs: #688
2022-01-03 03:49:32 +03:00
/// The color to use for the cursor when a dead key or leader state is active
palette now stores alpha for all color values We're now capable of remembering an alpha value for everything in the palette and the main window theme, but not the tab bar theme. Whether the alpha is correctly respected at render time is a different story! refs: #1835
2022-04-08 17:08:33 +03:00
pub compose_cursor: Option<RgbaColor>,
gui: allow specifying colors for copy mode and quickselect refs: https://github.com/wez/wezterm/issues/2320 ```lua return { colors = { copy_mode_active_highlight_fg={Color="red"}, copy_mode_active_highlight_bg={Color="blue"}, copy_mode_inactive_highlight_fg={AnsiColor="Black"}, copy_mode_inactive_highlight_bg={AnsiColor="White"}, quick_select_label_fg={Color="white"}, quick_select_label_bg={Color="blue"}, quick_select_match_fg={Color="grey"}, quick_select_match_bg={Color="skyblue"}, } } ```
2022-07-29 03:54:07 +03:00
pub copy_mode_active_highlight_fg: Option<ColorSpec>,
pub copy_mode_active_highlight_bg: Option<ColorSpec>,
pub copy_mode_inactive_highlight_fg: Option<ColorSpec>,
pub copy_mode_inactive_highlight_bg: Option<ColorSpec>,
pub quick_select_label_fg: Option<ColorSpec>,
pub quick_select_label_bg: Option<ColorSpec>,
pub quick_select_match_fg: Option<ColorSpec>,
pub quick_select_match_bg: Option<ColorSpec>,
split more config into separate modules
2019-11-24 18:44:17 +03:00
}
config: cut over to wezterm-dynamic Avoid using serde for mapping between Lua and Rust for the `Config` struct. This improves the build speed of the config crate by 2x; it goes down from 30 seconds to 9 seconds on my 5950x.
2022-05-14 18:00:03 +03:00
impl_lua_conversion_dynamic!(Palette);
split more config into separate modules
2019-11-24 18:44:17 +03:00
colors now override color_scheme The prior mutually exclusive behavior kept surprising people so let's just flip this around. This is potentially a "breaking" change for folks, but I think it is worth it.
2022-08-20 21:48:22 +03:00
impl Palette {
pub fn overlay_with(&self, other: &Self) -> Self {
macro_rules! overlay {
($name:ident) => {
if let Some(c) = &other.$name {
Some(c.clone())
} else {
self.$name.clone()
}
};
}
Self {
foreground: overlay!(foreground),
background: overlay!(background),
cursor_fg: overlay!(cursor_fg),
cursor_bg: overlay!(cursor_bg),
cursor_border: overlay!(cursor_border),
selection_fg: overlay!(selection_fg),
selection_bg: overlay!(selection_bg),
ansi: overlay!(ansi),
brights: overlay!(brights),
tab_bar: match (&self.tab_bar, &other.tab_bar) {
(Some(a), Some(b)) => Some(a.overlay_with(&b)),
(None, Some(b)) => Some(b.clone()),
(Some(a), None) => Some(a.clone()),
(None, None) => None,
},
indexed: {
let mut map = self.indexed.clone();
for (k, v) in &other.indexed {
fix(clippy): Remove unnecessary clone/to_string calls
2023-03-15 05:37:44 +03:00
map.insert(*k, *v);
colors now override color_scheme The prior mutually exclusive behavior kept surprising people so let's just flip this around. This is potentially a "breaking" change for folks, but I think it is worth it.
2022-08-20 21:48:22 +03:00
}
map
},
scrollbar_thumb: overlay!(scrollbar_thumb),
split: overlay!(split),
visual_bell: overlay!(visual_bell),
compose_cursor: overlay!(compose_cursor),
copy_mode_active_highlight_fg: overlay!(copy_mode_active_highlight_fg),
copy_mode_active_highlight_bg: overlay!(copy_mode_active_highlight_bg),
copy_mode_inactive_highlight_fg: overlay!(copy_mode_inactive_highlight_fg),
copy_mode_inactive_highlight_bg: overlay!(copy_mode_inactive_highlight_bg),
quick_select_label_fg: overlay!(quick_select_label_fg),
quick_select_label_bg: overlay!(quick_select_label_bg),
quick_select_match_fg: overlay!(quick_select_match_fg),
quick_select_match_bg: overlay!(quick_select_match_bg),
}
}
}
add wezterm.color.get_default_colors
2022-07-15 07:41:39 +03:00
impl From<ColorPalette> for Palette {
fn from(cp: ColorPalette) -> Palette {
let mut p = Palette::default();
macro_rules! apply_color {
($name:ident) => {
p.$name = Some(cp.$name.into());
};
}
apply_color!(foreground);
apply_color!(background);
apply_color!(cursor_fg);
apply_color!(cursor_bg);
apply_color!(cursor_border);
apply_color!(selection_fg);
apply_color!(selection_bg);
apply_color!(scrollbar_thumb);
apply_color!(split);
let mut ansi = [RgbaColor::default(); 8];
for (idx, col) in cp.colors.0[0..8].iter().enumerate() {
ansi[idx] = (*col).into();
}
p.ansi = Some(ansi);
let mut brights = [RgbaColor::default(); 8];
for (idx, col) in cp.colors.0[8..16].iter().enumerate() {
brights[idx] = (*col).into();
}
p.brights = Some(brights);
for (idx, col) in cp.colors.0.iter().enumerate().skip(16) {
p.indexed.insert(idx as u8, (*col).into());
}
p
}
}
impl From<Palette> for ColorPalette {
fn from(cfg: Palette) -> ColorPalette {
let mut p = ColorPalette::default();
split more config into separate modules
2019-11-24 18:44:17 +03:00
macro_rules! apply_color {
($name:ident) => {
if let Some($name) = cfg.$name {
allow setting selection colors with alpha values This commit allows the following configuration: ``` wezterm -n --config 'colors = { selection_fg = "clear", selection_bg = "rgba:50% 50% 50% 50%" }' ``` which sets the selection_bg to fully transparent, and selection_bg to 50% transparent gray. When selection_fg is fully transparent we'll use the normal fg color. When selection_bg is partially (or fully!) transparent, it will be alpha blended over the current cell background color. To support this, the config file will now accept rgba colors specified as 4 whitespace delimited numeric values. If a value ends with `%` it is interpreted as a number in the range 0-100. Otherwise, it is interpreted as a number in the range 0-255. The 4 values are red, green, blue, alpha. At this time, only the selection_fg and selection_bg settings accept alpha values. refs: #1615
2022-02-06 01:13:19 +03:00
p.$name = $name.into();
split more config into separate modules
2019-11-24 18:44:17 +03:00
}
};
}
apply_color!(foreground);
apply_color!(background);
apply_color!(cursor_fg);
apply_color!(cursor_bg);
renderer now renders different cursor styles refs: https://github.com/wez/wezterm/issues/7
2019-12-22 23:58:07 +03:00
apply_color!(cursor_border);
split more config into separate modules
2019-11-24 18:44:17 +03:00
apply_color!(selection_fg);
apply_color!(selection_bg);
Add optional scroll position UI This commit adds a scrollbar that shows the scroll position but that does not currently allow dragging to scroll. The scrollbar occupies the right hand side window padding. The width of the scrollbar can be set by explicitly configuring `window_padding.right`. If the right padding is set to 0 (which is its default value), and the scroll bar is enabled then the cell width will be used for the right padding value instead. The scrollbar can be enabled/disabled via this config setting: ``` enable_scroll_bar = true ``` Its color by this: ``` [colors] scrollbar_thumb = "#444444" ``` (Note that color palette config will be reloaded when the config file is changed, but you'll need to spawn a new tab/window to see the effects because we cannot assume that a config reload should always replace a potentially dynamically adjusted color scheme in a tab).
2019-12-23 05:57:54 +03:00
apply_color!(scrollbar_thumb);
wezterm: make the split color configurable and darker This makes the color of the split divider darker by default, and configurable via the color scheme configuration file. refs: #297
2020-10-20 08:03:21 +03:00
apply_color!(split);
split more config into separate modules
2019-11-24 18:44:17 +03:00
if let Some(ansi) = cfg.ansi {
for (idx, col) in ansi.iter().enumerate() {
palette now stores alpha for all color values We're now capable of remembering an alpha value for everything in the palette and the main window theme, but not the tab bar theme. Whether the alpha is correctly respected at render time is a different story! refs: #1835
2022-04-08 17:08:33 +03:00
p.colors.0[idx] = (*col).into();
split more config into separate modules
2019-11-24 18:44:17 +03:00
}
}
if let Some(brights) = cfg.brights {
for (idx, col) in brights.iter().enumerate() {
palette now stores alpha for all color values We're now capable of remembering an alpha value for everything in the palette and the main window theme, but not the tab bar theme. Whether the alpha is correctly respected at render time is a different story! refs: #1835
2022-04-08 17:08:33 +03:00
p.colors.0[idx + 8] = (*col).into();
split more config into separate modules
2019-11-24 18:44:17 +03:00
}
}
Remove explicit deref in 256-colors loop.
2021-08-22 11:10:38 +03:00
for (&idx, &col) in &cfg.indexed {
tidy up handling of index colors IndexedMap was a temporary measure while I was hacking through the dynamic crate stuff; we don't need it any more.
2022-05-18 19:31:10 +03:00
if idx < 16 {
log::warn!(
"Ignoring invalid colors.indexed index {}; \
use `ansi` or `brights` to specify lower indices",
idx
);
continue;
}
palette now stores alpha for all color values We're now capable of remembering an alpha value for everything in the palette and the main window theme, but not the tab bar theme. Whether the alpha is correctly respected at render time is a different story! refs: #1835
2022-04-08 17:08:33 +03:00
p.colors.0[idx as usize] = col.into();
Add support for setting arbitrary colors ranging from 16 to 256.
2021-08-21 14:46:52 +03:00
}
split more config into separate modules
2019-11-24 18:44:17 +03:00
p
}
}
/// Specify the text styling for a tab in the tab bar
colorschemes: expand to include Gogh color schemes This commit expands the toml file definition to include metadata for the origin url, author and name. A new sync utility fills out that metadata when it pulls from the iterm2 color schemes repo. The utility also pulls down the scheme data json maintained by the Gogh project: https://gogh-co.github.io/Gogh/ and converts it to wezterm's format. About 50% of Gogh overlaps with iterm2; we take the iterm2 versions of those schemes by default because the iterm2 data has more info about things like cursor and selection colors. The sync utility is responsible for compiling the de-duplicated set of scheme data into a form that is used by wezterm and its docs.
2022-07-10 23:26:33 +03:00
#[derive(Debug, Clone, Default, PartialEq, FromDynamic, ToDynamic)]
split more config into separate modules
2019-11-24 18:44:17 +03:00
pub struct TabBarColor {
/// Specifies the intensity attribute for the tab title text
config: cut over to wezterm-dynamic Avoid using serde for mapping between Lua and Rust for the `Config` struct. This improves the build speed of the config crate by 2x; it goes down from 30 seconds to 9 seconds on my 5950x.
2022-05-14 18:00:03 +03:00
#[dynamic(default)]
term: rename crate to wezterm-term in advance of publishing Add some more docs and remove a couple of dead bits of code.
2020-06-13 19:04:13 +03:00
pub intensity: wezterm_term::Intensity,
split more config into separate modules
2019-11-24 18:44:17 +03:00
/// Specifies the underline attribute for the tab title text
config: cut over to wezterm-dynamic Avoid using serde for mapping between Lua and Rust for the `Config` struct. This improves the build speed of the config crate by 2x; it goes down from 30 seconds to 9 seconds on my 5950x.
2022-05-14 18:00:03 +03:00
#[dynamic(default)]
term: rename crate to wezterm-term in advance of publishing Add some more docs and remove a couple of dead bits of code.
2020-06-13 19:04:13 +03:00
pub underline: wezterm_term::Underline,
split more config into separate modules
2019-11-24 18:44:17 +03:00
/// Specifies the italic attribute for the tab title text
config: cut over to wezterm-dynamic Avoid using serde for mapping between Lua and Rust for the `Config` struct. This improves the build speed of the config crate by 2x; it goes down from 30 seconds to 9 seconds on my 5950x.
2022-05-14 18:00:03 +03:00
#[dynamic(default)]
split more config into separate modules
2019-11-24 18:44:17 +03:00
pub italic: bool,
/// Specifies the strikethrough attribute for the tab title text
config: cut over to wezterm-dynamic Avoid using serde for mapping between Lua and Rust for the `Config` struct. This improves the build speed of the config crate by 2x; it goes down from 30 seconds to 9 seconds on my 5950x.
2022-05-14 18:00:03 +03:00
#[dynamic(default)]
split more config into separate modules
2019-11-24 18:44:17 +03:00
pub strikethrough: bool,
/// The background color for the tab
termwiz: ColorSpec now allows for alpha to be tracked This doesn't really change any behavior, but adjusts the types such that CSIs that set colors have the potential to track the alpha channel and that can make it through to the GUI/render layer.
2022-07-27 05:39:53 +03:00
pub bg_color: RgbaColor,
split more config into separate modules
2019-11-24 18:44:17 +03:00
/// The forgeground/text color for the tab
termwiz: ColorSpec now allows for alpha to be tracked This doesn't really change any behavior, but adjusts the types such that CSIs that set colors have the potential to track the alpha channel and that can make it through to the GUI/render layer.
2022-07-27 05:39:53 +03:00
pub fg_color: RgbaColor,
split more config into separate modules
2019-11-24 18:44:17 +03:00
}
impl TabBarColor {
pub fn as_cell_attributes(&self) -> CellAttributes {
let mut attr = CellAttributes::default();
attr.set_intensity(self.intensity)
.set_underline(self.underline)
.set_italic(self.italic)
.set_strikethrough(self.strikethrough)
gui: allow specifying colors for copy mode and quickselect refs: https://github.com/wez/wezterm/issues/2320 ```lua return { colors = { copy_mode_active_highlight_fg={Color="red"}, copy_mode_active_highlight_bg={Color="blue"}, copy_mode_inactive_highlight_fg={AnsiColor="Black"}, copy_mode_inactive_highlight_bg={AnsiColor="White"}, quick_select_label_fg={Color="white"}, quick_select_label_bg={Color="blue"}, quick_select_match_fg={Color="grey"}, quick_select_match_bg={Color="skyblue"}, } } ```
2022-07-29 03:54:07 +03:00
.set_background(TWColorSpec::TrueColor(*self.bg_color))
.set_foreground(TWColorSpec::TrueColor(*self.fg_color));
split more config into separate modules
2019-11-24 18:44:17 +03:00
attr
}
}
/// Specifies the colors to use for the tab bar portion of the UI.
/// These are not part of the terminal model and cannot be updated
/// in the same way that the dynamic color schemes are.
colors now override color_scheme The prior mutually exclusive behavior kept surprising people so let's just flip this around. This is potentially a "breaking" change for folks, but I think it is worth it.
2022-08-20 21:48:22 +03:00
#[derive(Default, Debug, Clone, PartialEq, FromDynamic, ToDynamic)]
split more config into separate modules
2019-11-24 18:44:17 +03:00
pub struct TabBarColors {
/// The background color for the tab bar
colors now override color_scheme The prior mutually exclusive behavior kept surprising people so let's just flip this around. This is potentially a "breaking" change for folks, but I think it is worth it.
2022-08-20 21:48:22 +03:00
#[dynamic(default)]
pub background: Option<RgbaColor>,
split more config into separate modules
2019-11-24 18:44:17 +03:00
/// Styling for the active tab
colors now override color_scheme The prior mutually exclusive behavior kept surprising people so let's just flip this around. This is potentially a "breaking" change for folks, but I think it is worth it.
2022-08-20 21:48:22 +03:00
#[dynamic(default)]
pub active_tab: Option<TabBarColor>,
make setting tab bar colors more ergonomic closes: https://github.com/wez/wezterm/issues/148
2020-02-09 20:34:59 +03:00
split more config into separate modules
2019-11-24 18:44:17 +03:00
/// Styling for other inactive tabs
colors now override color_scheme The prior mutually exclusive behavior kept surprising people so let's just flip this around. This is potentially a "breaking" change for folks, but I think it is worth it.
2022-08-20 21:48:22 +03:00
#[dynamic(default)]
pub inactive_tab: Option<TabBarColor>,
make setting tab bar colors more ergonomic closes: https://github.com/wez/wezterm/issues/148
2020-02-09 20:34:59 +03:00
split more config into separate modules
2019-11-24 18:44:17 +03:00
/// Styling for an inactive tab with a mouse hovering
colors now override color_scheme The prior mutually exclusive behavior kept surprising people so let's just flip this around. This is potentially a "breaking" change for folks, but I think it is worth it.
2022-08-20 21:48:22 +03:00
#[dynamic(default)]
pub inactive_tab_hover: Option<TabBarColor>,
Allow styling of the whole new tab button
2021-07-17 18:31:11 +03:00
/// Styling for the new tab button
colors now override color_scheme The prior mutually exclusive behavior kept surprising people so let's just flip this around. This is potentially a "breaking" change for folks, but I think it is worth it.
2022-08-20 21:48:22 +03:00
#[dynamic(default)]
pub new_tab: Option<TabBarColor>,
Allow styling of the whole new tab button
2021-07-17 18:31:11 +03:00
/// Styling for the new tab button with a mouse hovering
colors now override color_scheme The prior mutually exclusive behavior kept surprising people so let's just flip this around. This is potentially a "breaking" change for folks, but I think it is worth it.
2022-08-20 21:48:22 +03:00
#[dynamic(default)]
pub new_tab_hover: Option<TabBarColor>,
gui: fancy tab bars are now the default Adjust the rendering and coloring a bit to make the defaults look pretty reasonable. refs: #1180
2021-12-25 02:23:01 +03:00
colors now override color_scheme The prior mutually exclusive behavior kept surprising people so let's just flip this around. This is potentially a "breaking" change for folks, but I think it is worth it.
2022-08-20 21:48:22 +03:00
#[dynamic(default)]
pub inactive_tab_edge: Option<RgbaColor>,
gui: fancy tab bars are now the default Adjust the rendering and coloring a bit to make the defaults look pretty reasonable. refs: #1180
2021-12-25 02:23:01 +03:00
colors now override color_scheme The prior mutually exclusive behavior kept surprising people so let's just flip this around. This is potentially a "breaking" change for folks, but I think it is worth it.
2022-08-20 21:48:22 +03:00
#[dynamic(default)]
pub inactive_tab_edge_hover: Option<RgbaColor>,
integrated-title-bar: Add color configuration
2022-11-08 19:17:57 +03:00
#[dynamic(default)]
pub window_hide: Option<TabBarColor>,
#[dynamic(default)]
pub window_hide_hover: Option<TabBarColor>,
#[dynamic(default)]
pub window_maximize: Option<TabBarColor>,
#[dynamic(default)]
pub window_maximize_hover: Option<TabBarColor>,
#[dynamic(default)]
pub window_close: Option<TabBarColor>,
#[dynamic(default)]
pub window_close_hover: Option<TabBarColor>,
colors now override color_scheme The prior mutually exclusive behavior kept surprising people so let's just flip this around. This is potentially a "breaking" change for folks, but I think it is worth it.
2022-08-20 21:48:22 +03:00
}
impl TabBarColors {
pub fn background(&self) -> RgbaColor {
self.background.unwrap_or_else(default_background)
}
pub fn active_tab(&self) -> TabBarColor {
self.active_tab.clone().unwrap_or_else(default_active_tab)
}
pub fn inactive_tab(&self) -> TabBarColor {
self.inactive_tab
.clone()
.unwrap_or_else(default_inactive_tab)
}
pub fn inactive_tab_hover(&self) -> TabBarColor {
self.inactive_tab_hover
.clone()
.unwrap_or_else(default_inactive_tab_hover)
}
pub fn new_tab(&self) -> TabBarColor {
self.new_tab.clone().unwrap_or_else(default_inactive_tab)
}
pub fn new_tab_hover(&self) -> TabBarColor {
self.new_tab_hover
.clone()
.unwrap_or_else(default_inactive_tab_hover)
}
pub fn inactive_tab_edge(&self) -> RgbaColor {
self.inactive_tab_edge
.unwrap_or_else(default_inactive_tab_edge)
}
pub fn inactive_tab_edge_hover(&self) -> RgbaColor {
self.inactive_tab_edge_hover
.unwrap_or_else(default_inactive_tab_edge_hover)
}
integrated-title-bar: Add color configuration
2022-11-08 19:17:57 +03:00
pub fn window_hide(&self) -> TabBarColor {
self.window_hide
.clone()
.unwrap_or_else(default_window_hide_color)
}
pub fn window_hide_hover(&self) -> TabBarColor {
self.window_hide_hover
.clone()
.unwrap_or_else(default_window_hide_hover_color)
}
pub fn window_maximize(&self) -> TabBarColor {
self.window_maximize
.clone()
.unwrap_or_else(default_window_maximize_color)
}
pub fn window_maximize_hover(&self) -> TabBarColor {
self.window_maximize_hover
.clone()
.unwrap_or_else(default_window_maximize_hover_color)
}
pub fn window_close(&self) -> TabBarColor {
self.window_close
.clone()
.unwrap_or_else(default_window_close_color)
}
pub fn window_close_hover(&self) -> TabBarColor {
self.window_close_hover
.clone()
.unwrap_or_else(default_window_close_hover_color)
}
colors now override color_scheme The prior mutually exclusive behavior kept surprising people so let's just flip this around. This is potentially a "breaking" change for folks, but I think it is worth it.
2022-08-20 21:48:22 +03:00
pub fn overlay_with(&self, other: &Self) -> Self {
macro_rules! overlay {
($name:ident) => {
if let Some(c) = &other.$name {
Some(c.clone())
} else {
self.$name.clone()
}
};
}
Self {
active_tab: overlay!(active_tab),
background: overlay!(background),
inactive_tab: overlay!(inactive_tab),
inactive_tab_hover: overlay!(inactive_tab_hover),
inactive_tab_edge: overlay!(inactive_tab_edge),
inactive_tab_edge_hover: overlay!(inactive_tab_edge_hover),
new_tab: overlay!(new_tab),
new_tab_hover: overlay!(new_tab_hover),
integrated-title-bar: Add color configuration
2022-11-08 19:17:57 +03:00
window_hide: overlay!(window_hide),
window_hide_hover: overlay!(window_hide_hover),
window_maximize: overlay!(window_maximize),
window_maximize_hover: overlay!(window_maximize_hover),
window_close: overlay!(window_close),
window_close_hover: overlay!(window_close_hover),
colors now override color_scheme The prior mutually exclusive behavior kept surprising people so let's just flip this around. This is potentially a "breaking" change for folks, but I think it is worth it.
2022-08-20 21:48:22 +03:00
}
}
split more config into separate modules
2019-11-24 18:44:17 +03:00
}
termwiz: ColorSpec now allows for alpha to be tracked This doesn't really change any behavior, but adjusts the types such that CSIs that set colors have the potential to track the alpha channel and that can make it through to the GUI/render layer.
2022-07-27 05:39:53 +03:00
fn default_background() -> RgbaColor {
(0x33, 0x33, 0x33).into()
gui: fancy tab bars are now the default Adjust the rendering and coloring a bit to make the defaults look pretty reasonable. refs: #1180
2021-12-25 02:23:01 +03:00
}
palette now stores alpha for all color values We're now capable of remembering an alpha value for everything in the palette and the main window theme, but not the tab bar theme. Whether the alpha is correctly respected at render time is a different story! refs: #1835
2022-04-08 17:08:33 +03:00
fn default_inactive_tab_edge() -> RgbaColor {
RgbColor::new_8bpc(0x57, 0x57, 0x57).into()
gui: fancy tab bars are now the default Adjust the rendering and coloring a bit to make the defaults look pretty reasonable. refs: #1180
2021-12-25 02:23:01 +03:00
}
palette now stores alpha for all color values We're now capable of remembering an alpha value for everything in the palette and the main window theme, but not the tab bar theme. Whether the alpha is correctly respected at render time is a different story! refs: #1835
2022-04-08 17:08:33 +03:00
fn default_inactive_tab_edge_hover() -> RgbaColor {
RgbColor::new_8bpc(0x36, 0x36, 0x36).into()
make setting tab bar colors more ergonomic closes: https://github.com/wez/wezterm/issues/148
2020-02-09 20:34:59 +03:00
}
fn default_inactive_tab() -> TabBarColor {
TabBarColor {
termwiz: ColorSpec now allows for alpha to be tracked This doesn't really change any behavior, but adjusts the types such that CSIs that set colors have the potential to track the alpha channel and that can make it through to the GUI/render layer.
2022-07-27 05:39:53 +03:00
bg_color: (0x33, 0x33, 0x33).into(),
fg_color: (0x80, 0x80, 0x80).into(),
make setting tab bar colors more ergonomic closes: https://github.com/wez/wezterm/issues/148
2020-02-09 20:34:59 +03:00
..TabBarColor::default()
}
}
fn default_inactive_tab_hover() -> TabBarColor {
TabBarColor {
termwiz: ColorSpec now allows for alpha to be tracked This doesn't really change any behavior, but adjusts the types such that CSIs that set colors have the potential to track the alpha channel and that can make it through to the GUI/render layer.
2022-07-27 05:39:53 +03:00
bg_color: (0x1f, 0x1f, 0x1f).into(),
fg_color: (0x90, 0x90, 0x90).into(),
make setting tab bar colors more ergonomic closes: https://github.com/wez/wezterm/issues/148
2020-02-09 20:34:59 +03:00
italic: true,
..TabBarColor::default()
}
}
fn default_active_tab() -> TabBarColor {
TabBarColor {
termwiz: ColorSpec now allows for alpha to be tracked This doesn't really change any behavior, but adjusts the types such that CSIs that set colors have the potential to track the alpha channel and that can make it through to the GUI/render layer.
2022-07-27 05:39:53 +03:00
bg_color: (0x00, 0x00, 0x00).into(),
fg_color: (0xc0, 0xc0, 0xc0).into(),
make setting tab bar colors more ergonomic closes: https://github.com/wez/wezterm/issues/148
2020-02-09 20:34:59 +03:00
..TabBarColor::default()
}
}
integrated-title-bar: Add color configuration
2022-11-08 19:17:57 +03:00
// Colors for window buttons
integrated-title-bar: Add libadwaita styled buttons
2022-11-08 22:45:25 +03:00
#[cfg(not(any(windows, target_os = "linux")))]
integrated-title-bar: Add color configuration
2022-11-08 19:17:57 +03:00
fn default_window_button_color() -> TabBarColor {
default_inactive_tab()
}
integrated-title-bar: Add libadwaita styled buttons
2022-11-08 22:45:25 +03:00
#[cfg(not(any(windows, target_os = "linux")))]
integrated-title-bar: Add color configuration
2022-11-08 19:17:57 +03:00
fn default_window_button_hover_color() -> TabBarColor {
default_inactive_tab_hover()
}
fn default_window_hide_color() -> TabBarColor {
default_window_button_color()
}
fn default_window_hide_hover_color() -> TabBarColor {
default_window_button_hover_color()
}
fn default_window_maximize_color() -> TabBarColor {
default_window_button_color()
}
fn default_window_maximize_hover_color() -> TabBarColor {
default_window_button_hover_color()
}
fn default_window_close_color() -> TabBarColor {
default_window_button_color()
}
#[cfg(not(windows))]
fn default_window_close_hover_color() -> TabBarColor {
default_window_button_hover_color()
}
// Windows dependend colors for window buttons
#[cfg(windows)]
fn default_window_button_color() -> TabBarColor {
TabBarColor {
bg_color: (0x33, 0x33, 0x33).into(),
fg_color: (0xFF, 0xFF, 0xFF).into(),
..TabBarColor::default()
}
}
#[cfg(windows)]
fn default_window_button_hover_color() -> TabBarColor {
TabBarColor {
bg_color: (0x45, 0x45, 0x45).into(),
fg_color: (0xFF, 0xFF, 0xFF).into(),
..TabBarColor::default()
}
}
#[cfg(windows)]
fn default_window_close_hover_color() -> TabBarColor {
TabBarColor {
bg_color: (0xFF, 0x00, 0x00).into(),
fg_color: (0xFF, 0xFF, 0xFF).into(),
..TabBarColor::default()
}
}
integrated-title-bar: Add libadwaita styled buttons
2022-11-08 22:45:25 +03:00
// Linux dependend colors for window buttons
#[cfg(target_os = "linux")]
fn default_window_button_color() -> TabBarColor {
TabBarColor {
bg_color: (0x45, 0x45, 0x45).into(),
fg_color: (0xFF, 0xFF, 0xFF).into(),
..TabBarColor::default()
}
}
#[cfg(target_os = "linux")]
fn default_window_button_hover_color() -> TabBarColor {
TabBarColor {
bg_color: (0x4F, 0x4F, 0x4F).into(),
fg_color: (0xFF, 0xFF, 0xFF).into(),
..TabBarColor::default()
}
}
config: cut over to wezterm-dynamic Avoid using serde for mapping between Lua and Rust for the `Config` struct. This improves the build speed of the config crate by 2x; it goes down from 30 seconds to 9 seconds on my 5950x.
2022-05-14 18:00:03 +03:00
#[derive(Debug, Clone, FromDynamic, ToDynamic)]
add config for customizing the tabs and new tab button ```lua local wezterm = require 'wezterm'; -- The filled in variant of the < symbol local SOLID_LEFT_ARROW = utf8.char(0xe0b2) -- The filled in variant of the > symbol local SOLID_RIGHT_ARROW = utf8.char(0xe0b0) return { tab_bar_style = { active_tab_left = wezterm.format({ {Background={Color="#0b0022"}}, {Foreground={Color="#2b2042"}}, {Text=SOLID_LEFT_ARROW}, }), active_tab_right = wezterm.format({ {Background={Color="#0b0022"}}, {Foreground={Color="#2b2042"}}, {Text=SOLID_RIGHT_ARROW}, }), inactive_tab_left = wezterm.format({ {Background={Color="#0b0022"}}, {Foreground={Color="#1b1032"}}, {Text=SOLID_LEFT_ARROW}, }), inactive_tab_right = wezterm.format({ {Background={Color="#0b0022"}}, {Foreground={Color="#1b1032"}}, {Text=SOLID_RIGHT_ARROW}, }), } } ```
2021-03-12 08:21:31 +03:00
pub struct TabBarStyle {
config: cut over to wezterm-dynamic Avoid using serde for mapping between Lua and Rust for the `Config` struct. This improves the build speed of the config crate by 2x; it goes down from 30 seconds to 9 seconds on my 5950x.
2022-05-14 18:00:03 +03:00
#[dynamic(default = "default_new_tab")]
Allow styling of the whole new tab button
2021-07-17 18:31:11 +03:00
pub new_tab: String,
config: cut over to wezterm-dynamic Avoid using serde for mapping between Lua and Rust for the `Config` struct. This improves the build speed of the config crate by 2x; it goes down from 30 seconds to 9 seconds on my 5950x.
2022-05-14 18:00:03 +03:00
#[dynamic(default = "default_new_tab")]
Allow styling of the whole new tab button
2021-07-17 18:31:11 +03:00
pub new_tab_hover: String,
integrated-title-bar: Add window buttons to the tabbar
2022-11-07 21:39:44 +03:00
#[dynamic(default = "default_window_hide")]
pub window_hide: String,
#[dynamic(default = "default_window_hide")]
pub window_hide_hover: String,
#[dynamic(default = "default_window_maximize")]
pub window_maximize: String,
#[dynamic(default = "default_window_maximize")]
pub window_maximize_hover: String,
#[dynamic(default = "default_window_close")]
pub window_close: String,
#[dynamic(default = "default_window_close")]
pub window_close_hover: String,
add config for customizing the tabs and new tab button ```lua local wezterm = require 'wezterm'; -- The filled in variant of the < symbol local SOLID_LEFT_ARROW = utf8.char(0xe0b2) -- The filled in variant of the > symbol local SOLID_RIGHT_ARROW = utf8.char(0xe0b0) return { tab_bar_style = { active_tab_left = wezterm.format({ {Background={Color="#0b0022"}}, {Foreground={Color="#2b2042"}}, {Text=SOLID_LEFT_ARROW}, }), active_tab_right = wezterm.format({ {Background={Color="#0b0022"}}, {Foreground={Color="#2b2042"}}, {Text=SOLID_RIGHT_ARROW}, }), inactive_tab_left = wezterm.format({ {Background={Color="#0b0022"}}, {Foreground={Color="#1b1032"}}, {Text=SOLID_LEFT_ARROW}, }), inactive_tab_right = wezterm.format({ {Background={Color="#0b0022"}}, {Foreground={Color="#1b1032"}}, {Text=SOLID_RIGHT_ARROW}, }), } } ```
2021-03-12 08:21:31 +03:00
}
impl Default for TabBarStyle {
fn default() -> Self {
Self {
Allow styling of the whole new tab button
2021-07-17 18:31:11 +03:00
new_tab: default_new_tab(),
new_tab_hover: default_new_tab(),
integrated-title-bar: Add window buttons to the tabbar
2022-11-07 21:39:44 +03:00
window_hide: default_window_hide(),
window_hide_hover: default_window_hide(),
window_maximize: default_window_maximize(),
window_maximize_hover: default_window_maximize(),
window_close: default_window_close(),
window_close_hover: default_window_close(),
add config for customizing the tabs and new tab button ```lua local wezterm = require 'wezterm'; -- The filled in variant of the < symbol local SOLID_LEFT_ARROW = utf8.char(0xe0b2) -- The filled in variant of the > symbol local SOLID_RIGHT_ARROW = utf8.char(0xe0b0) return { tab_bar_style = { active_tab_left = wezterm.format({ {Background={Color="#0b0022"}}, {Foreground={Color="#2b2042"}}, {Text=SOLID_LEFT_ARROW}, }), active_tab_right = wezterm.format({ {Background={Color="#0b0022"}}, {Foreground={Color="#2b2042"}}, {Text=SOLID_RIGHT_ARROW}, }), inactive_tab_left = wezterm.format({ {Background={Color="#0b0022"}}, {Foreground={Color="#1b1032"}}, {Text=SOLID_LEFT_ARROW}, }), inactive_tab_right = wezterm.format({ {Background={Color="#0b0022"}}, {Foreground={Color="#1b1032"}}, {Text=SOLID_RIGHT_ARROW}, }), } } ```
2021-03-12 08:21:31 +03:00
}
}
}
Allow styling of the whole new tab button
2021-07-17 18:31:11 +03:00
fn default_new_tab() -> String {
config: split out lua functions into their own crates This shaves off some build time and allows more parallism in the build.
2022-05-19 08:49:53 +03:00
" + ".to_string()
add config for customizing the tabs and new tab button ```lua local wezterm = require 'wezterm'; -- The filled in variant of the < symbol local SOLID_LEFT_ARROW = utf8.char(0xe0b2) -- The filled in variant of the > symbol local SOLID_RIGHT_ARROW = utf8.char(0xe0b0) return { tab_bar_style = { active_tab_left = wezterm.format({ {Background={Color="#0b0022"}}, {Foreground={Color="#2b2042"}}, {Text=SOLID_LEFT_ARROW}, }), active_tab_right = wezterm.format({ {Background={Color="#0b0022"}}, {Foreground={Color="#2b2042"}}, {Text=SOLID_RIGHT_ARROW}, }), inactive_tab_left = wezterm.format({ {Background={Color="#0b0022"}}, {Foreground={Color="#1b1032"}}, {Text=SOLID_LEFT_ARROW}, }), inactive_tab_right = wezterm.format({ {Background={Color="#0b0022"}}, {Foreground={Color="#1b1032"}}, {Text=SOLID_RIGHT_ARROW}, }), } } ```
2021-03-12 08:21:31 +03:00
}
integrated-title-bar: Add window buttons to the tabbar
2022-11-07 21:39:44 +03:00
fn default_window_hide() -> String {
" . ".to_string()
}
fn default_window_maximize() -> String {
" - ".to_string()
}
fn default_window_close() -> String {
" X ".to_string()
}
config: cut over to wezterm-dynamic Avoid using serde for mapping between Lua and Rust for the `Config` struct. This improves the build speed of the config crate by 2x; it goes down from 30 seconds to 9 seconds on my 5950x.
2022-05-14 18:00:03 +03:00
#[derive(Debug, Clone, FromDynamic, ToDynamic)]
wayland: move frame color config to the config file This simplifies it a bit and exposes the config via the config file; the following options are possible, each one specifies a color ```lua return { window_frame = { inactive_titlebar_bg = "", active_titlebar_bg = "", inactive_titlebar_fg = "", active_titlebar_fg = "", inactive_titlebar_border_bottom = "", active_titlebar_border_bottom = "", button_fg = "", button_bg = "", button_hover_fg = "", button_hover_bg = "", } } ``` refs: https://github.com/wez/wezterm/issues/761
2021-06-27 22:19:42 +03:00
pub struct WindowFrameConfig {
config: cut over to wezterm-dynamic Avoid using serde for mapping between Lua and Rust for the `Config` struct. This improves the build speed of the config crate by 2x; it goes down from 30 seconds to 9 seconds on my 5950x.
2022-05-14 18:00:03 +03:00
#[dynamic(default = "default_inactive_titlebar_bg")]
wayland: move frame color config to the config file This simplifies it a bit and exposes the config via the config file; the following options are possible, each one specifies a color ```lua return { window_frame = { inactive_titlebar_bg = "", active_titlebar_bg = "", inactive_titlebar_fg = "", active_titlebar_fg = "", inactive_titlebar_border_bottom = "", active_titlebar_border_bottom = "", button_fg = "", button_bg = "", button_hover_fg = "", button_hover_bg = "", } } ``` refs: https://github.com/wez/wezterm/issues/761
2021-06-27 22:19:42 +03:00
pub inactive_titlebar_bg: RgbColor,
config: cut over to wezterm-dynamic Avoid using serde for mapping between Lua and Rust for the `Config` struct. This improves the build speed of the config crate by 2x; it goes down from 30 seconds to 9 seconds on my 5950x.
2022-05-14 18:00:03 +03:00
#[dynamic(default = "default_active_titlebar_bg")]
wayland: move frame color config to the config file This simplifies it a bit and exposes the config via the config file; the following options are possible, each one specifies a color ```lua return { window_frame = { inactive_titlebar_bg = "", active_titlebar_bg = "", inactive_titlebar_fg = "", active_titlebar_fg = "", inactive_titlebar_border_bottom = "", active_titlebar_border_bottom = "", button_fg = "", button_bg = "", button_hover_fg = "", button_hover_bg = "", } } ``` refs: https://github.com/wez/wezterm/issues/761
2021-06-27 22:19:42 +03:00
pub active_titlebar_bg: RgbColor,
config: cut over to wezterm-dynamic Avoid using serde for mapping between Lua and Rust for the `Config` struct. This improves the build speed of the config crate by 2x; it goes down from 30 seconds to 9 seconds on my 5950x.
2022-05-14 18:00:03 +03:00
#[dynamic(default = "default_inactive_titlebar_fg")]
wayland: move frame color config to the config file This simplifies it a bit and exposes the config via the config file; the following options are possible, each one specifies a color ```lua return { window_frame = { inactive_titlebar_bg = "", active_titlebar_bg = "", inactive_titlebar_fg = "", active_titlebar_fg = "", inactive_titlebar_border_bottom = "", active_titlebar_border_bottom = "", button_fg = "", button_bg = "", button_hover_fg = "", button_hover_bg = "", } } ``` refs: https://github.com/wez/wezterm/issues/761
2021-06-27 22:19:42 +03:00
pub inactive_titlebar_fg: RgbColor,
config: cut over to wezterm-dynamic Avoid using serde for mapping between Lua and Rust for the `Config` struct. This improves the build speed of the config crate by 2x; it goes down from 30 seconds to 9 seconds on my 5950x.
2022-05-14 18:00:03 +03:00
#[dynamic(default = "default_active_titlebar_fg")]
wayland: move frame color config to the config file This simplifies it a bit and exposes the config via the config file; the following options are possible, each one specifies a color ```lua return { window_frame = { inactive_titlebar_bg = "", active_titlebar_bg = "", inactive_titlebar_fg = "", active_titlebar_fg = "", inactive_titlebar_border_bottom = "", active_titlebar_border_bottom = "", button_fg = "", button_bg = "", button_hover_fg = "", button_hover_bg = "", } } ``` refs: https://github.com/wez/wezterm/issues/761
2021-06-27 22:19:42 +03:00
pub active_titlebar_fg: RgbColor,
config: cut over to wezterm-dynamic Avoid using serde for mapping between Lua and Rust for the `Config` struct. This improves the build speed of the config crate by 2x; it goes down from 30 seconds to 9 seconds on my 5950x.
2022-05-14 18:00:03 +03:00
#[dynamic(default = "default_inactive_titlebar_border_bottom")]
wayland: move frame color config to the config file This simplifies it a bit and exposes the config via the config file; the following options are possible, each one specifies a color ```lua return { window_frame = { inactive_titlebar_bg = "", active_titlebar_bg = "", inactive_titlebar_fg = "", active_titlebar_fg = "", inactive_titlebar_border_bottom = "", active_titlebar_border_bottom = "", button_fg = "", button_bg = "", button_hover_fg = "", button_hover_bg = "", } } ``` refs: https://github.com/wez/wezterm/issues/761
2021-06-27 22:19:42 +03:00
pub inactive_titlebar_border_bottom: RgbColor,
config: cut over to wezterm-dynamic Avoid using serde for mapping between Lua and Rust for the `Config` struct. This improves the build speed of the config crate by 2x; it goes down from 30 seconds to 9 seconds on my 5950x.
2022-05-14 18:00:03 +03:00
#[dynamic(default = "default_active_titlebar_border_bottom")]
wayland: move frame color config to the config file This simplifies it a bit and exposes the config via the config file; the following options are possible, each one specifies a color ```lua return { window_frame = { inactive_titlebar_bg = "", active_titlebar_bg = "", inactive_titlebar_fg = "", active_titlebar_fg = "", inactive_titlebar_border_bottom = "", active_titlebar_border_bottom = "", button_fg = "", button_bg = "", button_hover_fg = "", button_hover_bg = "", } } ``` refs: https://github.com/wez/wezterm/issues/761
2021-06-27 22:19:42 +03:00
pub active_titlebar_border_bottom: RgbColor,
config: cut over to wezterm-dynamic Avoid using serde for mapping between Lua and Rust for the `Config` struct. This improves the build speed of the config crate by 2x; it goes down from 30 seconds to 9 seconds on my 5950x.
2022-05-14 18:00:03 +03:00
#[dynamic(default = "default_button_fg")]
wayland: move frame color config to the config file This simplifies it a bit and exposes the config via the config file; the following options are possible, each one specifies a color ```lua return { window_frame = { inactive_titlebar_bg = "", active_titlebar_bg = "", inactive_titlebar_fg = "", active_titlebar_fg = "", inactive_titlebar_border_bottom = "", active_titlebar_border_bottom = "", button_fg = "", button_bg = "", button_hover_fg = "", button_hover_bg = "", } } ``` refs: https://github.com/wez/wezterm/issues/761
2021-06-27 22:19:42 +03:00
pub button_fg: RgbColor,
config: cut over to wezterm-dynamic Avoid using serde for mapping between Lua and Rust for the `Config` struct. This improves the build speed of the config crate by 2x; it goes down from 30 seconds to 9 seconds on my 5950x.
2022-05-14 18:00:03 +03:00
#[dynamic(default = "default_button_bg")]
wayland: move frame color config to the config file This simplifies it a bit and exposes the config via the config file; the following options are possible, each one specifies a color ```lua return { window_frame = { inactive_titlebar_bg = "", active_titlebar_bg = "", inactive_titlebar_fg = "", active_titlebar_fg = "", inactive_titlebar_border_bottom = "", active_titlebar_border_bottom = "", button_fg = "", button_bg = "", button_hover_fg = "", button_hover_bg = "", } } ``` refs: https://github.com/wez/wezterm/issues/761
2021-06-27 22:19:42 +03:00
pub button_bg: RgbColor,
config: cut over to wezterm-dynamic Avoid using serde for mapping between Lua and Rust for the `Config` struct. This improves the build speed of the config crate by 2x; it goes down from 30 seconds to 9 seconds on my 5950x.
2022-05-14 18:00:03 +03:00
#[dynamic(default = "default_button_hover_fg")]
wayland: move frame color config to the config file This simplifies it a bit and exposes the config via the config file; the following options are possible, each one specifies a color ```lua return { window_frame = { inactive_titlebar_bg = "", active_titlebar_bg = "", inactive_titlebar_fg = "", active_titlebar_fg = "", inactive_titlebar_border_bottom = "", active_titlebar_border_bottom = "", button_fg = "", button_bg = "", button_hover_fg = "", button_hover_bg = "", } } ``` refs: https://github.com/wez/wezterm/issues/761
2021-06-27 22:19:42 +03:00
pub button_hover_fg: RgbColor,
config: cut over to wezterm-dynamic Avoid using serde for mapping between Lua and Rust for the `Config` struct. This improves the build speed of the config crate by 2x; it goes down from 30 seconds to 9 seconds on my 5950x.
2022-05-14 18:00:03 +03:00
#[dynamic(default = "default_button_hover_bg")]
wayland: move frame color config to the config file This simplifies it a bit and exposes the config via the config file; the following options are possible, each one specifies a color ```lua return { window_frame = { inactive_titlebar_bg = "", active_titlebar_bg = "", inactive_titlebar_fg = "", active_titlebar_fg = "", inactive_titlebar_border_bottom = "", active_titlebar_border_bottom = "", button_fg = "", button_bg = "", button_hover_fg = "", button_hover_bg = "", } } ``` refs: https://github.com/wez/wezterm/issues/761
2021-06-27 22:19:42 +03:00
pub button_hover_bg: RgbColor,
wayland: use proportional font for title bar allow specifying the font in the config file
2021-06-27 23:04:20 +03:00
config: cut over to wezterm-dynamic Avoid using serde for mapping between Lua and Rust for the `Config` struct. This improves the build speed of the config crate by 2x; it goes down from 30 seconds to 9 seconds on my 5950x.
2022-05-14 18:00:03 +03:00
#[dynamic(default)]
fonts: move computation of title font to wezterm-fonts Rather than hardcode a fixed default value in the config crate, define the default as optional and leave it to the font crate to compute the value. This is a step towards allow introducing system dependent GUI related code to resolve/understand the title font: we can't put that directly in the config crate.
2021-12-25 17:49:46 +03:00
pub font: Option<TextStyle>,
config: cut over to wezterm-dynamic Avoid using serde for mapping between Lua and Rust for the `Config` struct. This improves the build speed of the config crate by 2x; it goes down from 30 seconds to 9 seconds on my 5950x.
2022-05-14 18:00:03 +03:00
#[dynamic(default)]
fonts: move computation of title font to wezterm-fonts Rather than hardcode a fixed default value in the config crate, define the default as optional and leave it to the font crate to compute the value. This is a step towards allow introducing system dependent GUI related code to resolve/understand the title font: we can't put that directly in the config crate.
2021-12-25 17:49:46 +03:00
pub font_size: Option<f64>,
add border size and color config refs: https://github.com/wez/wezterm/issues/2417
2022-08-21 02:39:44 +03:00
#[dynamic(try_from = "crate::units::PixelUnit", default = "default_zero_pixel")]
pub border_left_width: Dimension,
#[dynamic(try_from = "crate::units::PixelUnit", default = "default_zero_pixel")]
pub border_right_width: Dimension,
#[dynamic(try_from = "crate::units::PixelUnit", default = "default_zero_pixel")]
pub border_top_height: Dimension,
#[dynamic(try_from = "crate::units::PixelUnit", default = "default_zero_pixel")]
pub border_bottom_height: Dimension,
pub border_left_color: Option<RgbaColor>,
pub border_right_color: Option<RgbaColor>,
pub border_top_color: Option<RgbaColor>,
pub border_bottom_color: Option<RgbaColor>,
}
const fn default_zero_pixel() -> Dimension {
Dimension::Pixels(0.)
wayland: move frame color config to the config file This simplifies it a bit and exposes the config via the config file; the following options are possible, each one specifies a color ```lua return { window_frame = { inactive_titlebar_bg = "", active_titlebar_bg = "", inactive_titlebar_fg = "", active_titlebar_fg = "", inactive_titlebar_border_bottom = "", active_titlebar_border_bottom = "", button_fg = "", button_bg = "", button_hover_fg = "", button_hover_bg = "", } } ``` refs: https://github.com/wez/wezterm/issues/761
2021-06-27 22:19:42 +03:00
}
impl Default for WindowFrameConfig {
fn default() -> Self {
Self {
inactive_titlebar_bg: default_inactive_titlebar_bg(),
active_titlebar_bg: default_active_titlebar_bg(),
inactive_titlebar_fg: default_inactive_titlebar_fg(),
active_titlebar_fg: default_active_titlebar_fg(),
inactive_titlebar_border_bottom: default_inactive_titlebar_border_bottom(),
active_titlebar_border_bottom: default_active_titlebar_border_bottom(),
button_fg: default_button_fg(),
button_bg: default_button_bg(),
button_hover_fg: default_button_hover_fg(),
button_hover_bg: default_button_hover_bg(),
fonts: move computation of title font to wezterm-fonts Rather than hardcode a fixed default value in the config crate, define the default as optional and leave it to the font crate to compute the value. This is a step towards allow introducing system dependent GUI related code to resolve/understand the title font: we can't put that directly in the config crate.
2021-12-25 17:49:46 +03:00
font: None,
font_size: None,
add border size and color config refs: https://github.com/wez/wezterm/issues/2417
2022-08-21 02:39:44 +03:00
border_left_width: default_zero_pixel(),
border_right_width: default_zero_pixel(),
border_top_height: default_zero_pixel(),
border_bottom_height: default_zero_pixel(),
border_left_color: None,
border_right_color: None,
border_top_color: None,
border_bottom_color: None,
wayland: move frame color config to the config file This simplifies it a bit and exposes the config via the config file; the following options are possible, each one specifies a color ```lua return { window_frame = { inactive_titlebar_bg = "", active_titlebar_bg = "", inactive_titlebar_fg = "", active_titlebar_fg = "", inactive_titlebar_border_bottom = "", active_titlebar_border_bottom = "", button_fg = "", button_bg = "", button_hover_fg = "", button_hover_bg = "", } } ``` refs: https://github.com/wez/wezterm/issues/761
2021-06-27 22:19:42 +03:00
}
}
}
fn default_inactive_titlebar_bg() -> RgbColor {
gui: fancy tab bars are now the default Adjust the rendering and coloring a bit to make the defaults look pretty reasonable. refs: #1180
2021-12-25 02:23:01 +03:00
RgbColor::new_8bpc(0x33, 0x33, 0x33)
wayland: move frame color config to the config file This simplifies it a bit and exposes the config via the config file; the following options are possible, each one specifies a color ```lua return { window_frame = { inactive_titlebar_bg = "", active_titlebar_bg = "", inactive_titlebar_fg = "", active_titlebar_fg = "", inactive_titlebar_border_bottom = "", active_titlebar_border_bottom = "", button_fg = "", button_bg = "", button_hover_fg = "", button_hover_bg = "", } } ``` refs: https://github.com/wez/wezterm/issues/761
2021-06-27 22:19:42 +03:00
}
fn default_active_titlebar_bg() -> RgbColor {
gui: fancy tab bars are now the default Adjust the rendering and coloring a bit to make the defaults look pretty reasonable. refs: #1180
2021-12-25 02:23:01 +03:00
RgbColor::new_8bpc(0x33, 0x33, 0x33)
wayland: move frame color config to the config file This simplifies it a bit and exposes the config via the config file; the following options are possible, each one specifies a color ```lua return { window_frame = { inactive_titlebar_bg = "", active_titlebar_bg = "", inactive_titlebar_fg = "", active_titlebar_fg = "", inactive_titlebar_border_bottom = "", active_titlebar_border_bottom = "", button_fg = "", button_bg = "", button_hover_fg = "", button_hover_bg = "", } } ``` refs: https://github.com/wez/wezterm/issues/761
2021-06-27 22:19:42 +03:00
}
fn default_inactive_titlebar_fg() -> RgbColor {
RgbColor: hide internal red, green, blue fields I'd like to adjust this to support 10bpc color, so the first step is hiding the individual 8bpc fields.
2021-07-11 00:16:57 +03:00
RgbColor::new_8bpc(0xcc, 0xcc, 0xcc)
wayland: move frame color config to the config file This simplifies it a bit and exposes the config via the config file; the following options are possible, each one specifies a color ```lua return { window_frame = { inactive_titlebar_bg = "", active_titlebar_bg = "", inactive_titlebar_fg = "", active_titlebar_fg = "", inactive_titlebar_border_bottom = "", active_titlebar_border_bottom = "", button_fg = "", button_bg = "", button_hover_fg = "", button_hover_bg = "", } } ``` refs: https://github.com/wez/wezterm/issues/761
2021-06-27 22:19:42 +03:00
}
fn default_active_titlebar_fg() -> RgbColor {
RgbColor: hide internal red, green, blue fields I'd like to adjust this to support 10bpc color, so the first step is hiding the individual 8bpc fields.
2021-07-11 00:16:57 +03:00
RgbColor::new_8bpc(0xff, 0xff, 0xff)
wayland: move frame color config to the config file This simplifies it a bit and exposes the config via the config file; the following options are possible, each one specifies a color ```lua return { window_frame = { inactive_titlebar_bg = "", active_titlebar_bg = "", inactive_titlebar_fg = "", active_titlebar_fg = "", inactive_titlebar_border_bottom = "", active_titlebar_border_bottom = "", button_fg = "", button_bg = "", button_hover_fg = "", button_hover_bg = "", } } ``` refs: https://github.com/wez/wezterm/issues/761
2021-06-27 22:19:42 +03:00
}
fn default_inactive_titlebar_border_bottom() -> RgbColor {
RgbColor: hide internal red, green, blue fields I'd like to adjust this to support 10bpc color, so the first step is hiding the individual 8bpc fields.
2021-07-11 00:16:57 +03:00
RgbColor::new_8bpc(0x2b, 0x20, 0x42)
wayland: move frame color config to the config file This simplifies it a bit and exposes the config via the config file; the following options are possible, each one specifies a color ```lua return { window_frame = { inactive_titlebar_bg = "", active_titlebar_bg = "", inactive_titlebar_fg = "", active_titlebar_fg = "", inactive_titlebar_border_bottom = "", active_titlebar_border_bottom = "", button_fg = "", button_bg = "", button_hover_fg = "", button_hover_bg = "", } } ``` refs: https://github.com/wez/wezterm/issues/761
2021-06-27 22:19:42 +03:00
}
fn default_active_titlebar_border_bottom() -> RgbColor {
RgbColor: hide internal red, green, blue fields I'd like to adjust this to support 10bpc color, so the first step is hiding the individual 8bpc fields.
2021-07-11 00:16:57 +03:00
RgbColor::new_8bpc(0x2b, 0x20, 0x42)
wayland: move frame color config to the config file This simplifies it a bit and exposes the config via the config file; the following options are possible, each one specifies a color ```lua return { window_frame = { inactive_titlebar_bg = "", active_titlebar_bg = "", inactive_titlebar_fg = "", active_titlebar_fg = "", inactive_titlebar_border_bottom = "", active_titlebar_border_bottom = "", button_fg = "", button_bg = "", button_hover_fg = "", button_hover_bg = "", } } ``` refs: https://github.com/wez/wezterm/issues/761
2021-06-27 22:19:42 +03:00
}
fn default_button_hover_fg() -> RgbColor {
RgbColor: hide internal red, green, blue fields I'd like to adjust this to support 10bpc color, so the first step is hiding the individual 8bpc fields.
2021-07-11 00:16:57 +03:00
RgbColor::new_8bpc(0xff, 0xff, 0xff)
wayland: move frame color config to the config file This simplifies it a bit and exposes the config via the config file; the following options are possible, each one specifies a color ```lua return { window_frame = { inactive_titlebar_bg = "", active_titlebar_bg = "", inactive_titlebar_fg = "", active_titlebar_fg = "", inactive_titlebar_border_bottom = "", active_titlebar_border_bottom = "", button_fg = "", button_bg = "", button_hover_fg = "", button_hover_bg = "", } } ``` refs: https://github.com/wez/wezterm/issues/761
2021-06-27 22:19:42 +03:00
}
fn default_button_fg() -> RgbColor {
RgbColor: hide internal red, green, blue fields I'd like to adjust this to support 10bpc color, so the first step is hiding the individual 8bpc fields.
2021-07-11 00:16:57 +03:00
RgbColor::new_8bpc(0xcc, 0xcc, 0xcc)
wayland: move frame color config to the config file This simplifies it a bit and exposes the config via the config file; the following options are possible, each one specifies a color ```lua return { window_frame = { inactive_titlebar_bg = "", active_titlebar_bg = "", inactive_titlebar_fg = "", active_titlebar_fg = "", inactive_titlebar_border_bottom = "", active_titlebar_border_bottom = "", button_fg = "", button_bg = "", button_hover_fg = "", button_hover_bg = "", } } ``` refs: https://github.com/wez/wezterm/issues/761
2021-06-27 22:19:42 +03:00
}
fn default_button_hover_bg() -> RgbColor {
gui: fancy tab bars are now the default Adjust the rendering and coloring a bit to make the defaults look pretty reasonable. refs: #1180
2021-12-25 02:23:01 +03:00
RgbColor::new_8bpc(0x1f, 0x1f, 0x1f)
wayland: move frame color config to the config file This simplifies it a bit and exposes the config via the config file; the following options are possible, each one specifies a color ```lua return { window_frame = { inactive_titlebar_bg = "", active_titlebar_bg = "", inactive_titlebar_fg = "", active_titlebar_fg = "", inactive_titlebar_border_bottom = "", active_titlebar_border_bottom = "", button_fg = "", button_bg = "", button_hover_fg = "", button_hover_bg = "", } } ``` refs: https://github.com/wez/wezterm/issues/761
2021-06-27 22:19:42 +03:00
}
fn default_button_bg() -> RgbColor {
gui: fancy tab bars are now the default Adjust the rendering and coloring a bit to make the defaults look pretty reasonable. refs: #1180
2021-12-25 02:23:01 +03:00
RgbColor::new_8bpc(0x33, 0x33, 0x33)
wayland: move frame color config to the config file This simplifies it a bit and exposes the config via the config file; the following options are possible, each one specifies a color ```lua return { window_frame = { inactive_titlebar_bg = "", active_titlebar_bg = "", inactive_titlebar_fg = "", active_titlebar_fg = "", inactive_titlebar_border_bottom = "", active_titlebar_border_bottom = "", button_fg = "", button_bg = "", button_hover_fg = "", button_hover_bg = "", } } ``` refs: https://github.com/wez/wezterm/issues/761
2021-06-27 22:19:42 +03:00
}
colorschemes: expand to include Gogh color schemes This commit expands the toml file definition to include metadata for the origin url, author and name. A new sync utility fills out that metadata when it pulls from the iterm2 color schemes repo. The utility also pulls down the scheme data json maintained by the Gogh project: https://gogh-co.github.io/Gogh/ and converts it to wezterm's format. About 50% of Gogh overlaps with iterm2; we take the iterm2 versions of those schemes by default because the iterm2 data has more info about things like cursor and selection colors. The sync utility is responsible for compiling the de-duplicated set of scheme data into a form that is used by wezterm and its docs.
2022-07-10 23:26:33 +03:00
#[derive(Debug, Default, Clone, Eq, PartialEq, FromDynamic, ToDynamic)]
pub struct ColorSchemeMetaData {
pub name: Option<String>,
pub author: Option<String>,
pub origin_url: Option<String>,
color schemes: add version metadata Record the version in which we first saw a color scheme. For schemes from iterm2-color-schemes, we just assume that we've had them forever as it isn't easy to reverse engineer that metadata. Everything else is tagged as 'nightly builds only' and I'll update that to match the version number in the next release. Newly discovered items will be added with 'nightly builds only' from this point onwards.
2022-07-14 18:45:29 +03:00
pub wezterm_version: Option<String>,
color schemes: add alias concept Various color schemes have been duplicated as they have been added to different scheme collections. They don't always have identical names (eg: some remove spaces) and sometimes they have very different names (eg: _bash vs. nightfox, or Miu vs. Blazer). We already detected duplicates from different collections but previously we would omit those dupes. This commit allows us to track those duplicates by recording their aliases. When we write out our data, we only include "interesting" alias names; those where the name isn't trivially identical. Some scheme collections (eg: iterm2 color schemes) have duplicates (eg: zenbones and zenbones_light are identical) and we have previously shipped with both of those names, so we special case to emit dupes for which we have prior version information in order to avoid breaking backwards compatibility for our users. In the doc generation we can generate links to the aliases if we included them, but also note about the other names and how we don't include them. That is so that someone searching the docs for say "_bash" can discover that it is actually a duplicate of "nightfox" and use nightfox instead.
2022-07-20 17:32:46 +03:00
#[dynamic(default)]
pub aliases: Vec<String>,
colorschemes: expand to include Gogh color schemes This commit expands the toml file definition to include metadata for the origin url, author and name. A new sync utility fills out that metadata when it pulls from the iterm2 color schemes repo. The utility also pulls down the scheme data json maintained by the Gogh project: https://gogh-co.github.io/Gogh/ and converts it to wezterm's format. About 50% of Gogh overlaps with iterm2; we take the iterm2 versions of those schemes by default because the iterm2 data has more info about things like cursor and selection colors. The sync utility is responsible for compiling the de-duplicated set of scheme data into a form that is used by wezterm and its docs.
2022-07-10 23:26:33 +03:00
}
add lua functions for importing color scheme files
2022-07-15 09:03:18 +03:00
impl_lua_conversion_dynamic!(ColorSchemeMetaData);
colorschemes: expand to include Gogh color schemes This commit expands the toml file definition to include metadata for the origin url, author and name. A new sync utility fills out that metadata when it pulls from the iterm2 color schemes repo. The utility also pulls down the scheme data json maintained by the Gogh project: https://gogh-co.github.io/Gogh/ and converts it to wezterm's format. About 50% of Gogh overlaps with iterm2; we take the iterm2 versions of those schemes by default because the iterm2 data has more info about things like cursor and selection colors. The sync utility is responsible for compiling the de-duplicated set of scheme data into a form that is used by wezterm and its docs.
2022-07-10 23:26:33 +03:00
#[derive(Debug, Clone, PartialEq, FromDynamic, ToDynamic)]
load color schemes when we parse the config This eagerly parses all eligible schemes
2020-01-13 08:40:30 +03:00
pub struct ColorSchemeFile {
/// The color palette
pub colors: Palette,
colorschemes: expand to include Gogh color schemes This commit expands the toml file definition to include metadata for the origin url, author and name. A new sync utility fills out that metadata when it pulls from the iterm2 color schemes repo. The utility also pulls down the scheme data json maintained by the Gogh project: https://gogh-co.github.io/Gogh/ and converts it to wezterm's format. About 50% of Gogh overlaps with iterm2; we take the iterm2 versions of those schemes by default because the iterm2 data has more info about things like cursor and selection colors. The sync utility is responsible for compiling the de-duplicated set of scheme data into a form that is used by wezterm and its docs.
2022-07-10 23:26:33 +03:00
/// Info about the scheme
#[dynamic(default)]
pub metadata: ColorSchemeMetaData,
load color schemes when we parse the config This eagerly parses all eligible schemes
2020-01-13 08:40:30 +03:00
}
add lua functions for importing color scheme files
2022-07-15 09:03:18 +03:00
impl_lua_conversion_dynamic!(ColorSchemeFile);
config: cut over to wezterm-dynamic Avoid using serde for mapping between Lua and Rust for the `Config` struct. This improves the build speed of the config crate by 2x; it goes down from 30 seconds to 9 seconds on my 5950x.
2022-05-14 18:00:03 +03:00
add wezterm.color.save_scheme for exporting color schemes
2022-07-15 09:22:02 +03:00
fn dynamic_to_toml(value: Value) -> anyhow::Result<toml::Value> {
Ok(match value {
Value::Null => anyhow::bail!("cannot map Null to toml"),
Value::Bool(b) => toml::Value::Boolean(b),
Value::String(s) => toml::Value::String(s),
Value::Array(a) => {
let mut arr = vec![];
for v in a {
arr.push(dynamic_to_toml(v)?);
}
toml::Value::Array(arr)
}
Value::Object(o) => {
deps: update toml -> 0.7, cargo update
2023-01-30 07:08:25 +03:00
let mut map = toml::map::Map::new();
add wezterm.color.save_scheme for exporting color schemes
2022-07-15 09:22:02 +03:00
for (k, v) in o {
let k = match k {
Value::String(s) => s,
color scheme: allow exporting schemes that set index colors refs: https://github.com/catppuccin/wezterm/issues/6
2022-07-16 01:42:26 +03:00
Value::U64(u) => u.to_string(),
Value::I64(u) => u.to_string(),
Value::F64(u) => u.to_string(),
add wezterm.color.save_scheme for exporting color schemes
2022-07-15 09:22:02 +03:00
_ => anyhow::bail!("toml keys must be strings {k:?}"),
};
let v = match v {
Value::Null => continue,
other => dynamic_to_toml(other)?,
};
map.insert(k, v);
}
toml::Value::Table(map)
}
Value::U64(i) => toml::Value::Integer(i.try_into()?),
Value::I64(i) => toml::Value::Integer(i.try_into()?),
Value::F64(f) => toml::Value::Float(*f),
})
}
config: cut over to wezterm-dynamic Avoid using serde for mapping between Lua and Rust for the `Config` struct. This improves the build speed of the config crate by 2x; it goes down from 30 seconds to 9 seconds on my 5950x.
2022-05-14 18:00:03 +03:00
impl ColorSchemeFile {
pub fn from_toml_value(value: &toml::Value) -> anyhow::Result<Self> {
Self::from_dynamic(&crate::toml_to_dynamic(value), Default::default())
.map_err(|e| anyhow::anyhow!("{}", e))
}
pub fn from_toml_str(s: &str) -> anyhow::Result<Self> {
let scheme: toml::Value = toml::from_str(s)?;
config: revert taking name from the first comment line of toml color scheme files I needed this while swinging through to the new color scheme data stuff, but I don't need it any more, and it causes problems with external toml files.
2022-07-19 22:00:49 +03:00
Self::from_toml_value(&scheme)
config: cut over to wezterm-dynamic Avoid using serde for mapping between Lua and Rust for the `Config` struct. This improves the build speed of the config crate by 2x; it goes down from 30 seconds to 9 seconds on my 5950x.
2022-05-14 18:00:03 +03:00
}
add wezterm.color.save_scheme for exporting color schemes
2022-07-15 09:22:02 +03:00
pub fn to_toml_value(&self) -> anyhow::Result<toml::Value> {
let value = self.to_dynamic();
Ok(dynamic_to_toml(value)?)
}
pub fn save_to_file<P: AsRef<Path>>(&self, path: P) -> anyhow::Result<()> {
let value = self.to_toml_value()?;
let text = toml::to_string_pretty(&value)?;
std::fs::write(&path, text)
.with_context(|| format!("writing toml to {}", path.as_ref().display()))
}
config: cut over to wezterm-dynamic Avoid using serde for mapping between Lua and Rust for the `Config` struct. This improves the build speed of the config crate by 2x; it goes down from 30 seconds to 9 seconds on my 5950x.
2022-05-14 18:00:03 +03:00
}
fix colors.indexed in toml file refs: https://github.com/wez/wezterm/issues/2197
2022-06-28 16:22:31 +03:00
#[cfg(test)]
#[test]
fn test_indexed_colors() {
let scheme = r##"
[colors]
foreground = "#005661"
background = "#fef8ec"
cursor_bg = "#005661"
cursor_border = "#005661"
cursor_fg = "#ffffff"
selection_bg = "#cfe7f0"
selection_fg = "#005661"
ansi = [ "#8ca6a6" ,"#e64100" ,"#00b368" ,"#fa8900" ,"#0095a8" ,"#ff5792" ,"#00bdd6" ,"#005661" ]
brights = [ "#8ca6a6" ,"#e5164a" ,"#00b368" ,"#b3694d" ,"#0094f0" ,"#ff5792" ,"#00bdd6" ,"#004d57" ]
[colors.indexed]
52 = "#fbdada" # minus
88 = "#f6b6b6" # minus emph
22 = "#d6ffd6" # plus
28 = "#adffad" # plus emph
53 = "#feecf7" # purple
17 = "#e5dff6" # blue
23 = "#d8fdf6" # cyan
58 = "#f4ffe0" # yellow
"##;
let scheme = ColorSchemeFile::from_toml_str(scheme).unwrap();
assert_eq!(
scheme.colors.indexed.get(&52),
Some(&RgbColor::new_8bpc(0xfb, 0xda, 0xda).into())
);
}
Reference in New Issue Copy Permalink