992 lines
36 KiB
Rust
992 lines
36 KiB
Rust
use std::{
|
|
borrow::BorrowMut,
|
|
collections::HashMap,
|
|
env,
|
|
fmt::{Debug, Display},
|
|
fs::{self},
|
|
io,
|
|
ops::Deref,
|
|
path::Path,
|
|
str::FromStr,
|
|
string::FromUtf8Error,
|
|
};
|
|
|
|
use log::info;
|
|
use serde::{Deserialize, Serialize};
|
|
use strum::IntoEnumIterator;
|
|
use thiserror::Error;
|
|
|
|
use crate::{
|
|
environ::{self, ActiveKeybinds},
|
|
hlwm::{
|
|
self,
|
|
attribute::{Attribute, AttributeType},
|
|
color::Color,
|
|
command::{CommandError, HlwmCommand},
|
|
hook::Hook,
|
|
key::{Key, KeyUnbind, Keybind, MouseButton, Mousebind, MousebindAction},
|
|
parser::{ArgParser, FromCommandArgs, FromStrings, ParseError},
|
|
rule::{Condition, Consequence, FloatPlacement, Rule, Unrule},
|
|
setting::{FrameLayout, Setting, ShowFrameDecoration, SmartFrameSurroundings},
|
|
theme::ThemeAttr,
|
|
window::Window,
|
|
Align, Client, Direction, Index, Operator, Separator, ToggleBool,
|
|
},
|
|
logerr::UnwrapLog,
|
|
rule, split, window_types,
|
|
};
|
|
|
|
#[derive(Debug, Error)]
|
|
pub enum ConfigError {
|
|
#[error("IO error")]
|
|
IoError(#[from] io::Error),
|
|
#[error("toml deserialization error: {0}")]
|
|
TomlDeserializeError(#[from] toml::de::Error),
|
|
#[error("toml serialization error: {0}")]
|
|
TomlSerializeError(#[from] toml::ser::Error),
|
|
#[error("json error: {0}")]
|
|
JsonError(#[from] serde_json::Error),
|
|
#[error("$HOME must be set")]
|
|
HomeNotSet,
|
|
#[error("herbstluft client command error: {0}")]
|
|
CommandError(#[from] CommandError),
|
|
#[error("non-utf8 string error: {0}")]
|
|
Utf8StringError(#[from] FromUtf8Error),
|
|
#[error("failed parsing value: {0}")]
|
|
ParseError(#[from] ParseError),
|
|
}
|
|
|
|
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
|
|
pub struct Config {
|
|
pub use_panel: bool,
|
|
pub font: String,
|
|
pub font_bold: String,
|
|
/// Pango font for use where pango fonts are
|
|
/// used (i.e. panel)
|
|
pub font_pango: String,
|
|
/// Bold version of `font_pango`
|
|
pub font_pango_bold: String,
|
|
pub mod_key: Key,
|
|
pub keybinds: Vec<Keybind>,
|
|
pub mousebinds: Vec<Mousebind>,
|
|
// services won't be spawned through HlwmCommand::Spawn
|
|
// so that the running instance can hold the handles
|
|
// and a reset would kill them
|
|
pub services: Vec<Service>,
|
|
pub tags: Vec<Tag>,
|
|
pub theme: Theme,
|
|
pub rules: Vec<Rule>,
|
|
pub attributes: Vec<SetAttribute>,
|
|
pub settings: Vec<Setting>,
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub struct SetAttribute {
|
|
pub path: String,
|
|
pub value: Attribute,
|
|
}
|
|
|
|
impl Display for SetAttribute {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
write!(
|
|
f,
|
|
"({}){}={}",
|
|
self.value.type_string(),
|
|
&self.path,
|
|
self.value.to_string()
|
|
)
|
|
}
|
|
}
|
|
|
|
impl FromStrings for SetAttribute {
|
|
fn from_strings<I: Iterator<Item = String>>(s: I) -> Result<Self, ParseError> {
|
|
let s = s.collect::<Vec<_>>();
|
|
let original_str = s.join(" ");
|
|
let mut parser = ArgParser::from_strings(s.into_iter());
|
|
let x = parser.must_string("set_attribute(type/name)")?;
|
|
let (attr_ty, remainder) = split::parens(&x).ok_or(ParseError::InvalidValue {
|
|
value: original_str,
|
|
expected: "does not have a valid type string (type)",
|
|
})?;
|
|
if remainder.contains('=') {
|
|
let mut parser = ArgParser::from_strings(remainder.split('=').map(|c| c.to_string()));
|
|
return Ok(Self {
|
|
path: parser.must_string("set_attribute(path)")?,
|
|
value: Attribute::new(
|
|
AttributeType::from_str(&attr_ty)?,
|
|
&parser.must_string("set_attribute(value)")?,
|
|
)?,
|
|
});
|
|
}
|
|
if parser.must_string("set_attribute(equals)")? != "=" {
|
|
return Err(ParseError::ValueMissing);
|
|
}
|
|
Ok(Self {
|
|
path: remainder,
|
|
value: Attribute::new(
|
|
AttributeType::from_str(&attr_ty)?,
|
|
&parser.must_string("set_attribute(value)")?,
|
|
)?,
|
|
})
|
|
}
|
|
}
|
|
|
|
impl Serialize for SetAttribute {
|
|
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
|
|
where
|
|
S: serde::Serializer,
|
|
{
|
|
serializer.serialize_str(&self.to_string())
|
|
}
|
|
}
|
|
|
|
impl<'de> Deserialize<'de> for SetAttribute {
|
|
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
|
|
where
|
|
D: serde::Deserializer<'de>,
|
|
{
|
|
struct ExpectedKey;
|
|
impl serde::de::Expected for ExpectedKey {
|
|
fn fmt(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
|
|
formatter.write_str("Expected a supported key")
|
|
}
|
|
}
|
|
let str_val: String = Deserialize::deserialize(deserializer)?;
|
|
Ok(
|
|
Self::from_strings(split::tab_or_space(&str_val).into_iter()).map_err(|_| {
|
|
serde::de::Error::invalid_value(serde::de::Unexpected::Str(&str_val), &ExpectedKey)
|
|
})?,
|
|
)
|
|
}
|
|
}
|
|
|
|
impl Config {
|
|
const USE_PANEL: &'static str = "settings.my_hlctl_panel_enabled";
|
|
const FONT: &'static str = "theme.my_font";
|
|
const FONT_BOLD: &'static str = "theme.my_font_bold";
|
|
const FONT_PANGO: &'static str = "theme.my_font_pango";
|
|
const FONT_PANGO_BOLD: &'static str = "theme.my_font_pango_bold";
|
|
const SERVICES: &'static str = "settings.my_services";
|
|
const MOD_KEY: &'static str = "settings.my_mod_key";
|
|
|
|
pub fn from_file(path: &Path) -> Result<Self, ConfigError> {
|
|
info!(
|
|
"reading config from: {}",
|
|
path.to_str().unwrap_or_log("<not a valid utf8 string>")
|
|
);
|
|
Self::deserialize(&fs::read_to_string(path)?)
|
|
}
|
|
|
|
pub fn write_to_file(&self, path: &Path) -> Result<(), ConfigError> {
|
|
info!(
|
|
"saving config to: {}",
|
|
path.to_str().unwrap_or_log("<not a valid utf8 string>")
|
|
);
|
|
Ok(fs::write(path, self.serialize()?)?)
|
|
}
|
|
|
|
pub fn serialize(&self) -> Result<String, ConfigError> {
|
|
Ok(toml::ser::to_string_pretty(self)?)
|
|
}
|
|
|
|
pub fn deserialize(str: &str) -> Result<Self, ConfigError> {
|
|
Ok(toml::from_str(&str)?)
|
|
}
|
|
|
|
pub fn default_path() -> Result<String, ConfigError> {
|
|
Ok(format!(
|
|
"{home}/.config/herbstluftwm/hlctl.toml",
|
|
home = env::var("XDG_CONFIG_HOME")
|
|
.unwrap_or(env::var("HOME").map_err(|_| ConfigError::HomeNotSet)?)
|
|
))
|
|
}
|
|
|
|
fn new_or_set_attr(path: String, attr: Attribute) -> HlwmCommand {
|
|
HlwmCommand::Or {
|
|
separator: Separator::Comma,
|
|
commands: vec![
|
|
HlwmCommand::NewAttr {
|
|
path: path.clone(),
|
|
attr: attr.clone().into(),
|
|
},
|
|
HlwmCommand::SetAttr {
|
|
path,
|
|
new_value: attr,
|
|
},
|
|
],
|
|
}
|
|
}
|
|
|
|
fn attrs_set(&self) -> Result<Vec<HlwmCommand>, ConfigError> {
|
|
info!("loading attr settings command set");
|
|
Ok([
|
|
(Self::USE_PANEL, Some(self.use_panel.to_string())),
|
|
(Self::FONT, Some(self.font.clone())),
|
|
(Self::FONT_BOLD, Some(self.font_bold.clone())),
|
|
(Self::FONT_PANGO, Some(self.font_pango.clone())),
|
|
(Self::FONT_PANGO_BOLD, Some(self.font_pango_bold.clone())),
|
|
(
|
|
Self::SERVICES,
|
|
if self.services.len() == 0 {
|
|
None
|
|
} else {
|
|
Some(serde_json::ser::to_string(&self.services)?)
|
|
},
|
|
),
|
|
(Self::MOD_KEY, Some(self.mod_key.to_string())),
|
|
]
|
|
.into_iter()
|
|
.filter(|(_, attr)| attr.is_some())
|
|
.map(|(name, attr)| {
|
|
Self::new_or_set_attr(name.to_string(), Attribute::String(attr.unwrap()))
|
|
})
|
|
.collect())
|
|
}
|
|
|
|
fn theme_command_set(&self) -> Vec<HlwmCommand> {
|
|
info!("loading theme attr command set");
|
|
[
|
|
HlwmCommand::SetAttr {
|
|
path: "theme.reset".into(),
|
|
new_value: Attribute::String("1".into()),
|
|
},
|
|
HlwmCommand::SetAttr {
|
|
path: "theme.tiling.reset".into(),
|
|
new_value: Attribute::String("1".into()),
|
|
},
|
|
HlwmCommand::SetAttr {
|
|
path: "theme.floating.reset".into(),
|
|
new_value: Attribute::String("1".into()),
|
|
},
|
|
]
|
|
.into_iter()
|
|
.chain(
|
|
(&self.theme.attributes)
|
|
.into_iter()
|
|
.map(|attr| HlwmCommand::SetAttr {
|
|
path: attr.attr_path(),
|
|
new_value: Attribute::from(attr.clone()).into(),
|
|
}),
|
|
)
|
|
.collect()
|
|
}
|
|
|
|
fn settings_command_set(&self) -> Vec<HlwmCommand> {
|
|
info!("loading settings command set");
|
|
self.settings
|
|
.clone()
|
|
.into_iter()
|
|
.map(|s| HlwmCommand::Set(s))
|
|
.collect()
|
|
}
|
|
|
|
fn service_command_set(&self) -> Vec<HlwmCommand> {
|
|
info!("loading service command set");
|
|
self.services
|
|
.clone()
|
|
.into_iter()
|
|
.map(|s| {
|
|
[
|
|
HlwmCommand::Spawn {
|
|
executable: "pkill".into(),
|
|
args: vec!["-9".into(), s.name.clone()],
|
|
}
|
|
.to_try()
|
|
.silent(),
|
|
HlwmCommand::Spawn {
|
|
executable: s.name,
|
|
args: s.arguments,
|
|
},
|
|
]
|
|
})
|
|
.flatten()
|
|
.collect()
|
|
}
|
|
|
|
fn rule_command_set(&self) -> Vec<HlwmCommand> {
|
|
[HlwmCommand::Unrule(Unrule::All)]
|
|
.into_iter()
|
|
.chain(self.rules.clone().into_iter().map(|r| HlwmCommand::Rule(r)))
|
|
.collect()
|
|
}
|
|
|
|
pub fn to_command_set(&self) -> Result<Vec<HlwmCommand>, ConfigError> {
|
|
Ok([
|
|
HlwmCommand::EmitHook(Hook::Reload),
|
|
HlwmCommand::Keyunbind(KeyUnbind::All),
|
|
HlwmCommand::Mouseunbind,
|
|
]
|
|
.into_iter()
|
|
.chain(
|
|
self.keybinds
|
|
.clone()
|
|
.into_iter()
|
|
.map(|key| HlwmCommand::Keybind(key)),
|
|
)
|
|
.chain(
|
|
self.mousebinds
|
|
.clone()
|
|
.into_iter()
|
|
.map(|mb| HlwmCommand::Mousebind(mb)),
|
|
)
|
|
.chain(self.theme_command_set())
|
|
.chain(self.attrs_set()?)
|
|
.chain(self.tag_command_set())
|
|
.chain(self.settings_command_set())
|
|
.chain(self.rule_command_set())
|
|
.chain(self.service_command_set())
|
|
.chain([HlwmCommand::Unlock])
|
|
.collect())
|
|
}
|
|
|
|
fn tag_command_set(&self) -> Vec<HlwmCommand> {
|
|
info!("loading tag command set");
|
|
(&self.tags)
|
|
.into_iter()
|
|
.map(|tag| tag.to_command_set(self.mod_key))
|
|
.flatten()
|
|
.chain([HlwmCommand::And {
|
|
separator: Separator::Comma,
|
|
commands: vec![
|
|
HlwmCommand::Substitute {
|
|
identifier: "CURRENT_INDEX".into(),
|
|
attribute_path: "tags.focus.index".into(),
|
|
command: Box::new(HlwmCommand::Compare {
|
|
attribute: "tags.by-name.default.index".into(),
|
|
operator: Operator::Equal,
|
|
value: "CURRENT_INDEX".into(),
|
|
}),
|
|
},
|
|
HlwmCommand::UseIndex {
|
|
index: Index::Relative(1),
|
|
skip_visible: false,
|
|
},
|
|
HlwmCommand::MergeTag {
|
|
tag: "default".to_string(),
|
|
target: Some(hlwm::TagSelect::Name(
|
|
self.tags.first().cloned().unwrap().name().to_string(),
|
|
)),
|
|
},
|
|
],
|
|
}
|
|
.to_try()])
|
|
.collect()
|
|
}
|
|
|
|
/// Create a config gathered from the herbstluftwm configs,
|
|
/// using default mouse binds/attributes set
|
|
pub fn from_herbstluft() -> Self {
|
|
fn setting<T, E: std::error::Error, F: FnOnce(&str) -> Result<T, E>>(
|
|
name: &str,
|
|
f: F,
|
|
default: T,
|
|
) -> T
|
|
where
|
|
T: Debug,
|
|
{
|
|
match Client::new().get_attr(name.to_string()) {
|
|
Ok(setting) => f(&setting.to_string()).unwrap_or_log(default),
|
|
Err(_) => default,
|
|
}
|
|
}
|
|
let client = Client::new();
|
|
let default = Config::default();
|
|
let mod_key = setting(Self::MOD_KEY, Key::from_str, default.mod_key);
|
|
Config {
|
|
use_panel: client
|
|
.get_from_str_attr(Self::USE_PANEL.to_string())
|
|
.unwrap_or_log(default.use_panel),
|
|
font: client
|
|
.get_str_attr(Self::FONT.to_string())
|
|
.unwrap_or_log(default.font),
|
|
font_bold: client
|
|
.get_str_attr(Self::FONT_BOLD.to_string())
|
|
.unwrap_or_log(default.font_bold),
|
|
font_pango: client
|
|
.get_str_attr(Self::FONT_PANGO.to_string())
|
|
.unwrap_or_log(default.font_pango),
|
|
font_pango_bold: client
|
|
.get_str_attr(Self::FONT_PANGO_BOLD.to_string())
|
|
.unwrap_or_log(default.font_pango_bold),
|
|
mod_key,
|
|
services: setting(
|
|
Self::SERVICES,
|
|
|v| serde_json::de::from_str(v),
|
|
default.services,
|
|
),
|
|
theme: Theme {
|
|
attributes: (|| -> Vec<_> {
|
|
ThemeAttr::iter()
|
|
.map(|attr| {
|
|
let attr_path = attr.attr_path();
|
|
let default = (&default.theme.attributes)
|
|
.into_iter()
|
|
.find(|f| (*f).eq(&attr))
|
|
.unwrap();
|
|
ThemeAttr::from_command_args(
|
|
&attr_path,
|
|
[client
|
|
.get_attr(attr_path.clone())
|
|
.map(|t| t.to_string())
|
|
.unwrap_or_log(default.to_string())]
|
|
.into_iter(),
|
|
)
|
|
.unwrap_or_log(default.clone())
|
|
})
|
|
.collect()
|
|
})(),
|
|
},
|
|
keybinds: environ::active_keybinds(ActiveKeybinds::OmitNamedTagBinds)
|
|
.unwrap_or_log(default.keybinds),
|
|
tags: Self::active_tags(mod_key).unwrap_or_log(default.tags),
|
|
rules: (|| -> Result<Vec<Rule>, ConfigError> {
|
|
Ok(HlwmCommand::ListRules
|
|
.execute_str()?
|
|
.split('\n')
|
|
.map(|l| l.trim())
|
|
.filter(|l| !l.is_empty())
|
|
.map(|line| Rule::from_strings(split::tab_or_space(line).into_iter()))
|
|
.collect::<Result<_, _>>()?)
|
|
})()
|
|
.unwrap_or_log(default.rules),
|
|
settings: (|| -> Result<Vec<_>, CommandError> {
|
|
default
|
|
.settings
|
|
.clone()
|
|
.into_iter()
|
|
.map(|s| Ok(client.get_setting(s.into())?))
|
|
.collect::<Result<Vec<_>, CommandError>>()
|
|
})()
|
|
.unwrap_or_log(default.settings),
|
|
..default
|
|
}
|
|
}
|
|
|
|
fn active_tags(mod_key: Key) -> Result<Vec<Tag>, ConfigError> {
|
|
let mut by_tag: HashMap<String, Vec<Keybind>> = HashMap::new();
|
|
environ::active_keybinds(ActiveKeybinds::OnlyNamedTagBinds)?
|
|
.into_iter()
|
|
.filter(|bind| match bind.command.deref() {
|
|
HlwmCommand::UseTag(_) | HlwmCommand::MoveTag(_) => true,
|
|
_ => false,
|
|
})
|
|
.for_each(|bind| match bind.command.deref() {
|
|
HlwmCommand::UseTag(tag) | HlwmCommand::MoveTag(tag) => match by_tag.get_mut(tag) {
|
|
Some(coll) => coll.push(bind.clone()),
|
|
None => {
|
|
by_tag.insert(tag.to_string(), vec![bind]);
|
|
}
|
|
},
|
|
_ => unreachable!(),
|
|
});
|
|
Ok(by_tag
|
|
.into_iter()
|
|
.map(|(name, binds)| {
|
|
let standard = binds.len() != 0
|
|
&& (&binds).into_iter().all(|bind| match bind.command.deref() {
|
|
HlwmCommand::UseTag(_) => {
|
|
bind.keys.len() == 2
|
|
&& bind.keys[0] == mod_key
|
|
&& bind.keys[1].is_standard()
|
|
}
|
|
HlwmCommand::MoveTag(_) => {
|
|
bind.keys.len() == 3
|
|
&& bind.keys[0] == mod_key
|
|
&& bind.keys[1] == Key::Shift
|
|
&& bind.keys[2].is_standard()
|
|
}
|
|
// Filtered out above
|
|
_ => unreachable!(),
|
|
});
|
|
|
|
if standard {
|
|
let key = *binds.first().unwrap().keys.last().unwrap();
|
|
let key_same = (&binds)
|
|
.into_iter()
|
|
.all(|bind| bind.keys.last().unwrap().eq(&key));
|
|
if key_same {
|
|
// Actually standard
|
|
return Tag::standard(name, key);
|
|
}
|
|
}
|
|
|
|
let mut use_keys = None;
|
|
let mut move_keys = None;
|
|
for bind in binds {
|
|
match bind.command.deref() {
|
|
HlwmCommand::UseTag(_) => {
|
|
if use_keys.is_none() {
|
|
use_keys = Some(bind.keys);
|
|
}
|
|
}
|
|
HlwmCommand::MoveTag(_) => {
|
|
if move_keys.is_none() {
|
|
move_keys = Some(bind.keys);
|
|
}
|
|
}
|
|
// Filtered out above
|
|
_ => unreachable!(),
|
|
}
|
|
}
|
|
Tag::other(name, use_keys, move_keys)
|
|
})
|
|
.collect())
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
|
|
pub struct Theme {
|
|
pub attributes: Vec<ThemeAttr>,
|
|
}
|
|
|
|
#[allow(unused)]
|
|
impl Theme {
|
|
pub fn active_color(&self) -> Option<Color> {
|
|
for attr in &self.attributes {
|
|
if let ThemeAttr::ActiveColor(col) = attr {
|
|
return Some(col.clone());
|
|
}
|
|
}
|
|
None
|
|
}
|
|
|
|
pub fn normal_color(&self) -> Option<Color> {
|
|
for attr in &self.attributes {
|
|
if let ThemeAttr::NormalColor(col) = attr {
|
|
return Some(col.clone());
|
|
}
|
|
}
|
|
None
|
|
}
|
|
|
|
pub fn urgent_color(&self) -> Option<Color> {
|
|
for attr in &self.attributes {
|
|
if let ThemeAttr::UrgentColor(col) = attr {
|
|
return Some(col.clone());
|
|
}
|
|
}
|
|
None
|
|
}
|
|
|
|
pub fn text_color(&self) -> Option<Color> {
|
|
for attr in &self.attributes {
|
|
if let ThemeAttr::TitleColor(col) = attr {
|
|
return Some(col.clone());
|
|
}
|
|
}
|
|
None
|
|
}
|
|
}
|
|
|
|
impl Default for Config {
|
|
fn default() -> Self {
|
|
let resize_step = 0.1;
|
|
let mod_key = Key::Mod4Super;
|
|
let font_bold = String::from("-*-fixed-*-*-*-*-13-*-*-*-*-*-*-*");
|
|
let active_color = Color::from_hex("#800080").expect("default active color");
|
|
let normal_color = Color::from_hex("#330033").expect("default normal color");
|
|
let urgent_color = Color::from_hex("#7811A1").expect("default urgent color");
|
|
let text_color = Color::from_hex("#898989").expect("default text color");
|
|
|
|
Self {
|
|
use_panel: true,
|
|
mod_key,
|
|
font: String::from("-*-fixed-medium-*-*-*-12-*-*-*-*-*-*-*"),
|
|
font_bold: font_bold.clone(),
|
|
keybinds: vec![
|
|
Keybind::new(
|
|
[mod_key, Key::Shift, Key::Char('r')].into_iter(),
|
|
HlwmCommand::Reload,
|
|
),
|
|
Keybind::new(
|
|
[mod_key, Key::Shift, Key::Char('c')].into_iter(),
|
|
HlwmCommand::Close { window: None },
|
|
),
|
|
Keybind::new(
|
|
[mod_key, Key::Char('s')].into_iter(),
|
|
HlwmCommand::Spawn {
|
|
executable: String::from("flameshot"),
|
|
args: vec![String::from("gui")],
|
|
},
|
|
),
|
|
Keybind::new(
|
|
[mod_key, Key::Return].into_iter(),
|
|
HlwmCommand::Spawn {
|
|
executable: String::from("dmenu_run"),
|
|
args: vec![],
|
|
},
|
|
),
|
|
Keybind::new(
|
|
[mod_key, Key::Left].into_iter(),
|
|
HlwmCommand::Focus(Direction::Left),
|
|
),
|
|
Keybind::new(
|
|
[mod_key, Key::Right].into_iter(),
|
|
HlwmCommand::Focus(Direction::Right),
|
|
),
|
|
Keybind::new(
|
|
[mod_key, Key::Up].into_iter(),
|
|
HlwmCommand::Focus(Direction::Up),
|
|
),
|
|
Keybind::new(
|
|
[mod_key, Key::Down].into_iter(),
|
|
HlwmCommand::Focus(Direction::Down),
|
|
),
|
|
Keybind::new(
|
|
[mod_key, Key::Shift, Key::Left].into_iter(),
|
|
HlwmCommand::Shift(Direction::Left),
|
|
),
|
|
Keybind::new(
|
|
[mod_key, Key::Shift, Key::Right].into_iter(),
|
|
HlwmCommand::Shift(Direction::Right),
|
|
),
|
|
Keybind::new(
|
|
[mod_key, Key::Shift, Key::Up].into_iter(),
|
|
HlwmCommand::Shift(Direction::Up),
|
|
),
|
|
Keybind::new(
|
|
[mod_key, Key::Shift, Key::Down].into_iter(),
|
|
HlwmCommand::Shift(Direction::Down),
|
|
),
|
|
Keybind::new(
|
|
[mod_key, Key::Char('u')].into_iter(),
|
|
HlwmCommand::Split(Align::Bottom(Some(0.5))),
|
|
),
|
|
Keybind::new(
|
|
[mod_key, Key::Char('o')].into_iter(),
|
|
HlwmCommand::Split(Align::Right(Some(0.5))),
|
|
),
|
|
Keybind::new([mod_key, Key::Char('r')].into_iter(), HlwmCommand::Remove),
|
|
Keybind::new(
|
|
[mod_key, Key::Char('f')].into_iter(),
|
|
HlwmCommand::Fullscreen(ToggleBool::Toggle),
|
|
),
|
|
Keybind::new(
|
|
[mod_key, Key::Space].into_iter(),
|
|
HlwmCommand::Or {
|
|
separator: Separator::Comma,
|
|
commands: vec![
|
|
HlwmCommand::And {
|
|
separator: Separator::Period,
|
|
commands: vec![
|
|
HlwmCommand::Compare {
|
|
attribute: String::from("tags.focus.curframe_wcount"),
|
|
operator: Operator::Equal,
|
|
value: String::from("2"),
|
|
},
|
|
HlwmCommand::CycleLayout {
|
|
delta: Some(Index::Relative(1)),
|
|
layouts: vec![
|
|
FrameLayout::Vertical,
|
|
FrameLayout::Horizontal,
|
|
FrameLayout::Max,
|
|
FrameLayout::Vertical,
|
|
FrameLayout::Grid,
|
|
],
|
|
},
|
|
],
|
|
},
|
|
HlwmCommand::CycleLayout {
|
|
delta: Some(Index::Relative(1)),
|
|
layouts: vec![],
|
|
},
|
|
],
|
|
},
|
|
),
|
|
Keybind::new(
|
|
[mod_key, Key::Control, Key::Left].into_iter(),
|
|
HlwmCommand::Resize {
|
|
direction: Direction::Left,
|
|
fraction_delta: Some(Index::Relative(resize_step)),
|
|
},
|
|
),
|
|
Keybind::new(
|
|
[mod_key, Key::Control, Key::Down].into_iter(),
|
|
HlwmCommand::Resize {
|
|
direction: Direction::Down,
|
|
fraction_delta: Some(Index::Relative(resize_step)),
|
|
},
|
|
),
|
|
Keybind::new(
|
|
[mod_key, Key::Control, Key::Up].into_iter(),
|
|
HlwmCommand::Resize {
|
|
direction: Direction::Up,
|
|
fraction_delta: Some(Index::Relative(resize_step)),
|
|
},
|
|
),
|
|
Keybind::new(
|
|
[mod_key, Key::Control, Key::Right].into_iter(),
|
|
HlwmCommand::Resize {
|
|
direction: Direction::Right,
|
|
fraction_delta: Some(Index::Relative(resize_step)),
|
|
},
|
|
),
|
|
Keybind::new([mod_key, Key::Tab].into_iter(), HlwmCommand::Cycle),
|
|
Keybind::new(
|
|
[mod_key, Key::Char('i')].into_iter(),
|
|
HlwmCommand::JumpTo(Window::Urgent),
|
|
),
|
|
],
|
|
services: vec![Service {
|
|
name: String::from("fcitx5"),
|
|
arguments: vec![],
|
|
}],
|
|
tags: [
|
|
Tag::standard(".1", Key::Char('1')),
|
|
Tag::standard(".2", Key::Char('2')),
|
|
Tag::standard(".3", Key::Char('3')),
|
|
Tag::standard(".4", Key::Char('4')),
|
|
Tag::standard(".5", Key::Char('5')),
|
|
Tag::standard("F1", Key::F1),
|
|
Tag::standard("F2", Key::F2),
|
|
Tag::standard("F3", Key::F3),
|
|
Tag::standard("F4", Key::F4),
|
|
Tag::standard("F5", Key::F5),
|
|
]
|
|
.into(),
|
|
mousebinds: vec![
|
|
Mousebind::new(
|
|
mod_key,
|
|
[Key::Mouse(MouseButton::Button1)].into_iter(),
|
|
MousebindAction::Move,
|
|
),
|
|
Mousebind::new(
|
|
mod_key,
|
|
[Key::Mouse(MouseButton::Button2)].into_iter(),
|
|
MousebindAction::Zoom,
|
|
),
|
|
Mousebind::new(
|
|
mod_key,
|
|
[Key::Mouse(MouseButton::Button3)].into_iter(),
|
|
MousebindAction::Resize,
|
|
),
|
|
],
|
|
theme: Theme {
|
|
attributes: (|| -> Vec<ThemeAttr> {
|
|
ThemeAttr::iter()
|
|
.map(|attr| {
|
|
let mut attr = attr;
|
|
match attr.borrow_mut() {
|
|
ThemeAttr::TitleWhen(when) => *when = "multiple_tabs".into(),
|
|
ThemeAttr::TitleFont(font) => *font = font_bold.clone(),
|
|
ThemeAttr::TitleDepth(depth) => *depth = 3,
|
|
ThemeAttr::InnerWidth(inw) => *inw = 0,
|
|
ThemeAttr::TitleHeight(h) => *h = 15,
|
|
ThemeAttr::BorderWidth(w) => *w = 1,
|
|
ThemeAttr::TilingOuterWidth(w) => *w = 1,
|
|
ThemeAttr::FloatingOuterWidth(w) => *w = 1,
|
|
ThemeAttr::FloatingBorderWidth(w) => *w = 4,
|
|
ThemeAttr::InnerColor(col) => *col = Color::BLACK,
|
|
ThemeAttr::TitleColor(col) => *col = text_color.clone(),
|
|
ThemeAttr::ActiveColor(col) => *col = active_color.clone(),
|
|
ThemeAttr::NormalColor(col) => *col = normal_color.clone(),
|
|
ThemeAttr::UrgentColor(col) => *col = urgent_color.clone(),
|
|
ThemeAttr::BackgroundColor(col) => *col = Color::BLACK,
|
|
ThemeAttr::ActiveInnerColor(col) => *col = active_color.clone(),
|
|
ThemeAttr::ActiveOuterColor(col) => *col = active_color.clone(),
|
|
ThemeAttr::NormalInnerColor(col) => *col = normal_color.clone(),
|
|
ThemeAttr::NormalOuterColor(col) => *col = normal_color.clone(),
|
|
ThemeAttr::NormalTitleColor(col) => *col = normal_color.clone(),
|
|
ThemeAttr::UrgentInnerColor(col) => *col = urgent_color.clone(),
|
|
ThemeAttr::UrgentOuterColor(col) => *col = urgent_color.clone(),
|
|
}
|
|
attr
|
|
})
|
|
.collect()
|
|
})(),
|
|
},
|
|
rules: vec![
|
|
rule!(
|
|
window_types!(Dialog, Utility, Splash),
|
|
Consequence::Floating(true)
|
|
),
|
|
rule!(Consequence::Focus(true)),
|
|
rule!(Consequence::FloatPlacement(FloatPlacement::Smart)),
|
|
rule!(window_types!(Dialog), Consequence::Floating(true)),
|
|
rule!(
|
|
window_types!(Notification, Dock, Desktop),
|
|
Consequence::Manage(false)
|
|
),
|
|
rule!(Condition::FixedSize, Consequence::Floating(true)),
|
|
],
|
|
attributes: vec![],
|
|
settings: vec![
|
|
Setting::FrameBorderWidth(2),
|
|
Setting::ShowFrameDecorations(ShowFrameDecoration::FocusedIfMultiple),
|
|
Setting::TreeStyle(String::from("╾│ ├└╼─┐")),
|
|
Setting::FrameBgTransparent(true.into()),
|
|
Setting::SmartWindowSurroundings(false.into()),
|
|
Setting::SmartFrameSurroundings(SmartFrameSurroundings::HideAll),
|
|
Setting::FrameTransparentWidth(5),
|
|
Setting::FrameGap(3),
|
|
Setting::WindowGap(0),
|
|
Setting::FramePadding(0),
|
|
Setting::MouseRecenterGap(0),
|
|
Setting::FrameBorderActiveColor(active_color.clone()),
|
|
Setting::FrameBgActiveColor(active_color.clone()),
|
|
],
|
|
font_pango: String::from("Monospace 9"),
|
|
font_pango_bold: String::from("Monospace Bold 9"),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
|
|
pub struct Service {
|
|
pub name: String,
|
|
pub arguments: Vec<String>,
|
|
}
|
|
|
|
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
|
|
pub enum Tag {
|
|
Standard {
|
|
name: String,
|
|
key: Key,
|
|
},
|
|
Other {
|
|
name: String,
|
|
use_keys: Option<Vec<Key>>,
|
|
move_keys: Option<Vec<Key>>,
|
|
},
|
|
}
|
|
|
|
impl Tag {
|
|
pub fn standard<S: Into<String>>(name: S, key: Key) -> Self {
|
|
Self::Standard {
|
|
key,
|
|
name: name.into(),
|
|
}
|
|
}
|
|
|
|
pub fn other<S: Into<String>, K: IntoIterator<Item = Key>>(
|
|
name: S,
|
|
use_keys: Option<K>,
|
|
move_keys: Option<K>,
|
|
) -> Self {
|
|
Self::Other {
|
|
name: name.into(),
|
|
use_keys: use_keys.map(|k| k.into_iter().collect()),
|
|
move_keys: move_keys.map(|k| k.into_iter().collect()),
|
|
}
|
|
}
|
|
|
|
pub fn name(&self) -> &str {
|
|
match self {
|
|
Tag::Standard { name, key: _ } => name.as_str(),
|
|
Tag::Other {
|
|
name,
|
|
use_keys: _,
|
|
move_keys: _,
|
|
} => name.as_str(),
|
|
}
|
|
}
|
|
|
|
fn use_keybind(&self, mod_key: Key) -> Option<Keybind> {
|
|
match self {
|
|
Tag::Standard { name, key } => Some(Keybind {
|
|
keys: vec![mod_key, *key],
|
|
command: Box::new(HlwmCommand::UseTag(name.clone())),
|
|
}),
|
|
Tag::Other {
|
|
name,
|
|
use_keys,
|
|
move_keys: _,
|
|
} => use_keys.clone().map(|use_keys| Keybind {
|
|
keys: use_keys,
|
|
command: Box::new(HlwmCommand::UseTag(name.clone())),
|
|
}),
|
|
}
|
|
}
|
|
|
|
fn move_keybind(&self, mod_key: Key) -> Option<Keybind> {
|
|
match self {
|
|
Tag::Standard { name, key } => Some(Keybind {
|
|
keys: vec![mod_key, Key::Shift, *key],
|
|
command: Box::new(HlwmCommand::MoveTag(name.clone())),
|
|
}),
|
|
Tag::Other {
|
|
name,
|
|
use_keys: _,
|
|
move_keys,
|
|
} => move_keys.clone().map(|move_keys| Keybind {
|
|
keys: move_keys,
|
|
command: Box::new(HlwmCommand::MoveTag(name.clone())),
|
|
}),
|
|
}
|
|
}
|
|
|
|
pub fn to_command_set(&self, mod_key: Key) -> Vec<HlwmCommand> {
|
|
let mut commands = Vec::with_capacity(3);
|
|
commands.push(HlwmCommand::AddTag(self.name().to_string()));
|
|
if let Some(keybind) = self.use_keybind(mod_key) {
|
|
commands.push(HlwmCommand::Keybind(keybind));
|
|
}
|
|
if let Some(keybind) = self.move_keybind(mod_key) {
|
|
commands.push(HlwmCommand::Keybind(keybind));
|
|
}
|
|
|
|
commands
|
|
}
|
|
}
|
|
|
|
impl<S> From<(S, Key)> for Tag
|
|
where
|
|
S: Into<String>,
|
|
{
|
|
fn from((name, key): (S, Key)) -> Self {
|
|
Self::Standard {
|
|
name: name.into(),
|
|
key,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use pretty_assertions::assert_eq;
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
use crate::hlwm::{
|
|
attribute::Attribute,
|
|
color::{Color, X11Color},
|
|
};
|
|
|
|
use super::{Config, SetAttribute};
|
|
|
|
#[test]
|
|
fn config_serialize_deserialize() {
|
|
let mut cfg = Config::default();
|
|
// Add extra attrs for testing
|
|
cfg.attributes.push(SetAttribute {
|
|
path: "my.attr.path".into(),
|
|
value: Attribute::Color(Color::X11(X11Color::NavajoWhite3)),
|
|
});
|
|
let cfg_serialized = cfg.serialize().unwrap();
|
|
println!("--> Config <--");
|
|
println!("{cfg_serialized}");
|
|
println!("--> Config <--");
|
|
let parsed_cfg = Config::deserialize(&cfg_serialized).unwrap();
|
|
|
|
assert_eq!(cfg, parsed_cfg,)
|
|
}
|
|
|
|
#[derive(Debug, Serialize, Deserialize)]
|
|
pub struct AttrWrapper {
|
|
attr: SetAttribute,
|
|
}
|
|
|
|
#[test]
|
|
fn set_attribute_serialize_deserialize() {
|
|
let attr = AttrWrapper {
|
|
attr: SetAttribute {
|
|
path: "MyCool.Path".into(),
|
|
value: Attribute::Color(Color::X11(X11Color::LemonChiffon2)),
|
|
},
|
|
};
|
|
let serialized = toml::to_string_pretty(&attr).expect("serialize");
|
|
let parsed: AttrWrapper = toml::from_str(&serialized).expect("unserailize");
|
|
|
|
assert_eq!(attr.attr, parsed.attr,)
|
|
}
|
|
}
|