587 lines
16 KiB
Rust
587 lines
16 KiB
Rust
use std::{borrow::BorrowMut, fmt::Display, str::FromStr};
|
|
|
|
use serde::{Deserialize, Serialize};
|
|
use strum::IntoEnumIterator;
|
|
|
|
use crate::{logerr::UnwrapLog, split};
|
|
|
|
use super::{
|
|
command::HlwmCommand,
|
|
parser::{ArgParser, FromCommandArgs, FromStrings, ParseError},
|
|
ToCommandString,
|
|
};
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, strum::EnumIter)]
|
|
pub enum Key {
|
|
Mod1Alt,
|
|
Mod4Super,
|
|
Return,
|
|
Shift,
|
|
Tab,
|
|
Left,
|
|
Right,
|
|
Up,
|
|
Down,
|
|
Space,
|
|
Control,
|
|
Backtick,
|
|
F1,
|
|
F2,
|
|
F3,
|
|
F4,
|
|
F5,
|
|
F6,
|
|
F7,
|
|
F8,
|
|
F9,
|
|
F10,
|
|
F11,
|
|
F12,
|
|
Home,
|
|
Delete,
|
|
Char(char),
|
|
Mouse(MouseButton),
|
|
}
|
|
|
|
fn title_case(s: &str) -> String {
|
|
let mut chars = s.chars();
|
|
let mut out_chars = Vec::with_capacity(s.len());
|
|
|
|
if let Some(first) = chars.next() {
|
|
out_chars.push(first.to_ascii_uppercase());
|
|
}
|
|
|
|
while let Some(c) = chars.next() {
|
|
out_chars.push(c.to_ascii_lowercase());
|
|
}
|
|
|
|
out_chars.into_iter().collect()
|
|
}
|
|
|
|
impl Key {
|
|
pub fn is_standard(&self) -> bool {
|
|
match self {
|
|
Key::Char(_)
|
|
| Key::F1
|
|
| Key::F2
|
|
| Key::F3
|
|
| Key::F4
|
|
| Key::F5
|
|
| Key::F6
|
|
| Key::F7
|
|
| Key::F8
|
|
| Key::F9
|
|
| Key::F10
|
|
| Key::F11
|
|
| Key::F12 => true,
|
|
_ => false,
|
|
}
|
|
}
|
|
|
|
pub fn parse_keybind_keys(s: &str) -> Result<Vec<Key>, ParseError> {
|
|
s.split(['-', '+'])
|
|
.map(Key::from_str)
|
|
.collect::<Result<Vec<_>, _>>()
|
|
}
|
|
pub fn from_str_case_insensitive(s: &str) -> Result<Self, ParseError> {
|
|
Key::from_str(&title_case(s))
|
|
}
|
|
|
|
/// Returns the name for this key as it should appear in the config
|
|
pub fn config_name(&self) -> String {
|
|
self.aliases()
|
|
.first()
|
|
.expect_log("all keys should have at least one alias")
|
|
.to_string()
|
|
}
|
|
|
|
/// Returns a list of aliases for the key
|
|
pub fn aliases(&self) -> Vec<String> {
|
|
match self {
|
|
Key::Mod1Alt => vec!["Alt".into(), "Mod1".into()],
|
|
Key::Mod4Super => vec!["Super".into(), "Mod4".into()],
|
|
Key::Return => vec!["Return".into(), "Enter".into()],
|
|
Key::Shift => vec!["Shift".into()],
|
|
Key::Tab => vec!["Tab".into()],
|
|
Key::Left => vec!["Left".into()],
|
|
Key::Right => vec!["Right".into()],
|
|
Key::Up => vec!["Up".into()],
|
|
Key::Down => vec!["Down".into()],
|
|
Key::Space => vec!["Space".into()],
|
|
Key::Control => vec!["Ctrl".into(), "Ctl".into(), "Control".into()],
|
|
Key::Backtick => vec!["Backtick".into(), "Grave".into()],
|
|
Key::F1 => vec!["F1".into()],
|
|
Key::F2 => vec!["F2".into()],
|
|
Key::F3 => vec!["F3".into()],
|
|
Key::F4 => vec!["F4".into()],
|
|
Key::F5 => vec!["F5".into()],
|
|
Key::F6 => vec!["F6".into()],
|
|
Key::F7 => vec!["F7".into()],
|
|
Key::F8 => vec!["F8".into()],
|
|
Key::F9 => vec!["F9".into()],
|
|
Key::F10 => vec!["F10".into()],
|
|
Key::F11 => vec!["F11".into()],
|
|
Key::F12 => vec!["F12".into()],
|
|
Key::Home => vec!["Home".into()],
|
|
Key::Delete => vec!["Delete".into(), "Del".into()],
|
|
Key::Char(c) => vec![c.to_ascii_lowercase().to_string()],
|
|
Key::Mouse(m) => vec![m.to_string()],
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Display for Key {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
f.write_str(&self.aliases().first().unwrap())
|
|
}
|
|
}
|
|
|
|
impl From<MouseButton> for Key {
|
|
fn from(value: MouseButton) -> Self {
|
|
Key::Mouse(value)
|
|
}
|
|
}
|
|
|
|
impl From<char> for Key {
|
|
fn from(value: char) -> Self {
|
|
Key::Char(value)
|
|
}
|
|
}
|
|
|
|
impl Serialize for Key {
|
|
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
|
|
where
|
|
S: serde::Serializer,
|
|
{
|
|
serializer.serialize_str(&self.config_name())
|
|
}
|
|
}
|
|
|
|
impl<'de> Deserialize<'de> for Key {
|
|
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_str_case_insensitive(&str_val).map_err(|_| {
|
|
serde::de::Error::invalid_value(serde::de::Unexpected::Str(&str_val), &ExpectedKey)
|
|
})?)
|
|
}
|
|
}
|
|
|
|
impl FromStr for Key {
|
|
type Err = ParseError;
|
|
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"Button1" | "Button2" | "Button3" | "Button4" | "Button5" => {
|
|
Ok(Self::Mouse(MouseButton::from_str(s)?))
|
|
}
|
|
_ => {
|
|
if let Some(key) = Self::iter().into_iter().find(|key| match key {
|
|
Key::Char(_) | Key::Mouse(_) => false,
|
|
_ => key.aliases().contains(&s.to_string()),
|
|
}) {
|
|
return Ok(key);
|
|
}
|
|
if s.len() == 1 {
|
|
Ok(Self::Char(
|
|
s.chars().next().unwrap_log().to_ascii_lowercase(),
|
|
))
|
|
} else {
|
|
Err(ParseError::InvalidValue {
|
|
value: s.to_string(),
|
|
expected: "a valid key",
|
|
})
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq)]
|
|
pub enum MouseButton {
|
|
Button1,
|
|
Button2,
|
|
Button3,
|
|
Button4,
|
|
Button5,
|
|
}
|
|
|
|
impl Default for MouseButton {
|
|
fn default() -> Self {
|
|
Self::Button1
|
|
}
|
|
}
|
|
|
|
impl FromStr for MouseButton {
|
|
type Err = ParseError;
|
|
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"Button1" => Ok(Self::Button1),
|
|
"Button2" => Ok(Self::Button2),
|
|
"Button3" => Ok(Self::Button3),
|
|
"Button4" => Ok(Self::Button4),
|
|
"Button5" => Ok(Self::Button5),
|
|
_ => Err(ParseError::InvalidCommand(s.to_string())),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Display for MouseButton {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
match self {
|
|
MouseButton::Button1 => write!(f, "Button1"),
|
|
MouseButton::Button2 => write!(f, "Button2"),
|
|
MouseButton::Button3 => write!(f, "Button3"),
|
|
MouseButton::Button4 => write!(f, "Button4"),
|
|
MouseButton::Button5 => write!(f, "Button5"),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, strum::Display, strum::EnumIter, PartialEq)]
|
|
#[strum(serialize_all = "snake_case")]
|
|
pub enum MousebindAction {
|
|
Move,
|
|
Resize,
|
|
Zoom,
|
|
Call(Box<HlwmCommand>),
|
|
}
|
|
|
|
impl Serialize for MousebindAction {
|
|
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
|
|
where
|
|
S: serde::Serializer,
|
|
{
|
|
serializer.serialize_str(&self.to_command_string())
|
|
}
|
|
}
|
|
|
|
impl<'de> Deserialize<'de> for MousebindAction {
|
|
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_str(&str_val).map_err(|_| {
|
|
serde::de::Error::invalid_value(serde::de::Unexpected::Str(&str_val), &ExpectedKey)
|
|
})?)
|
|
}
|
|
}
|
|
|
|
impl FromCommandArgs for MousebindAction {
|
|
fn from_command_args<S: Into<String>, I: Iterator<Item = S>>(
|
|
command: &str,
|
|
args: I,
|
|
) -> Result<Self, ParseError> {
|
|
let mut action = Self::iter()
|
|
.find(|i| i.to_string() == command)
|
|
.ok_or(ParseError::InvalidCommand(command.to_string()))?;
|
|
|
|
match action.borrow_mut() {
|
|
MousebindAction::Move | MousebindAction::Resize | MousebindAction::Zoom => (),
|
|
MousebindAction::Call(arg) => {
|
|
*arg = Box::new(
|
|
ArgParser::from_strings(args.map(|a| a.into()))
|
|
.collect_command("mousebind_args(command)")?,
|
|
)
|
|
}
|
|
}
|
|
|
|
Ok(action)
|
|
}
|
|
}
|
|
|
|
impl FromStr for MousebindAction {
|
|
type Err = ParseError;
|
|
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
let mut parser = ArgParser::from_strings(split::tab_or_space(s).into_iter());
|
|
let action_str = parser.must_string("mousebind_action(action)")?;
|
|
|
|
let mut action = Self::iter()
|
|
.find(|i| i.to_string() == action_str)
|
|
.ok_or(ParseError::InvalidCommand(s.to_string()))?;
|
|
|
|
match action.borrow_mut() {
|
|
MousebindAction::Move | MousebindAction::Resize | MousebindAction::Zoom => (),
|
|
MousebindAction::Call(command) => {
|
|
*command = Box::new(parser.collect_command("mousebind_action(command)")?);
|
|
}
|
|
}
|
|
|
|
Ok(action)
|
|
}
|
|
}
|
|
|
|
impl Default for MousebindAction {
|
|
fn default() -> Self {
|
|
Self::Move
|
|
}
|
|
}
|
|
|
|
impl ToCommandString for MousebindAction {
|
|
fn to_command_string(&self) -> String {
|
|
match self {
|
|
MousebindAction::Move | MousebindAction::Resize | MousebindAction::Zoom => {
|
|
self.to_string()
|
|
}
|
|
MousebindAction::Call(cmd) => format!("{self}\t{}", cmd.to_string()),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
|
pub struct Keybind {
|
|
pub keys: Vec<Key>,
|
|
pub command: Box<HlwmCommand>,
|
|
}
|
|
|
|
impl Default for Keybind {
|
|
fn default() -> Self {
|
|
Self {
|
|
keys: Default::default(),
|
|
command: Default::default(),
|
|
}
|
|
}
|
|
}
|
|
impl FromStrings for Keybind {
|
|
fn from_strings<I: Iterator<Item = String>>(s: I) -> Result<Self, ParseError> {
|
|
let mut parser = ArgParser::from_strings(s);
|
|
|
|
Ok(Self {
|
|
keys: Key::parse_keybind_keys(&parser.must_string("keybind(keys)")?)?,
|
|
command: Box::new(parser.collect_command("keybind(command)")?),
|
|
})
|
|
}
|
|
}
|
|
|
|
impl ToCommandString for Keybind {
|
|
fn to_command_string(&self) -> String {
|
|
format!("{self}\t{}", self.command.to_command_string())
|
|
}
|
|
}
|
|
|
|
impl Keybind {
|
|
pub fn new<I: IntoIterator<Item = Key>>(keys: I, command: HlwmCommand) -> Self {
|
|
Self {
|
|
keys: keys.into_iter().collect(),
|
|
command: Box::new(command),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Display for Keybind {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
f.write_str(
|
|
&(&self.keys)
|
|
.into_iter()
|
|
.map(|key| key.to_string())
|
|
.collect::<Vec<String>>()
|
|
.join("+"),
|
|
)
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
|
|
pub struct Mousebind {
|
|
pub keys: Vec<Key>,
|
|
pub action: MousebindAction,
|
|
}
|
|
|
|
impl FromStrings for Mousebind {
|
|
fn from_strings<I: Iterator<Item = String>>(s: I) -> Result<Self, ParseError> {
|
|
let mut parser = ArgParser::from_strings(s);
|
|
let keys = Key::parse_keybind_keys(&parser.must_string("mousebind(keys)")?)?;
|
|
|
|
let action: MousebindAction = parser.collect_command("mousebind(action)")?;
|
|
|
|
Ok(Self { keys, action })
|
|
}
|
|
}
|
|
|
|
impl Mousebind {
|
|
pub fn new<I: Iterator<Item = Key>>(mod_key: Key, keys: I, action: MousebindAction) -> Self {
|
|
let keys = [mod_key].into_iter().chain(keys).collect();
|
|
Self { keys, action }
|
|
}
|
|
}
|
|
|
|
impl Default for Mousebind {
|
|
fn default() -> Self {
|
|
Self {
|
|
keys: Default::default(),
|
|
action: Default::default(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Display for Mousebind {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
write!(
|
|
f,
|
|
"{keys}\t{action}",
|
|
keys = (&self.keys)
|
|
.into_iter()
|
|
.map(|key| key.to_string())
|
|
.collect::<Vec<String>>()
|
|
.join("-"),
|
|
action = self.action.to_command_string(),
|
|
)
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
|
|
pub enum KeyUnbind {
|
|
Keybind(Vec<Key>),
|
|
All,
|
|
}
|
|
|
|
impl FromStr for KeyUnbind {
|
|
type Err = ParseError;
|
|
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
"--all" | "-F" => Ok(Self::All),
|
|
_ => Ok(Self::Keybind(Key::parse_keybind_keys(s)?)),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Default for KeyUnbind {
|
|
fn default() -> Self {
|
|
Self::All
|
|
}
|
|
}
|
|
|
|
impl Display for KeyUnbind {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
match self {
|
|
KeyUnbind::Keybind(keys) => f.write_str(
|
|
&keys
|
|
.into_iter()
|
|
.map(|k| k.to_string())
|
|
.collect::<Vec<String>>()
|
|
.join("-"),
|
|
),
|
|
KeyUnbind::All => f.write_str("--all"),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use serde::{Deserialize, Serialize};
|
|
use strum::IntoEnumIterator;
|
|
|
|
use crate::{hlwm::command::HlwmCommand, logerr::UnwrapLog};
|
|
|
|
use super::{Key, MousebindAction};
|
|
use pretty_assertions::assert_eq;
|
|
|
|
#[derive(Debug, Serialize, Deserialize)]
|
|
pub struct KeyWrapper {
|
|
key: Key,
|
|
}
|
|
|
|
#[test]
|
|
fn key_serialize_deserialize() {
|
|
for (original_key, wrapper) in Key::iter().map(|key| (key, KeyWrapper { key })) {
|
|
let wrapper_str = toml::to_string_pretty(&wrapper).expect_log("serialize");
|
|
let parsed: KeyWrapper = toml::from_str(&wrapper_str).expect_log("deserialize");
|
|
assert_eq!(original_key, parsed.key);
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Serialize, Deserialize)]
|
|
pub struct MousebindActionWrapper {
|
|
action: MousebindAction,
|
|
}
|
|
|
|
#[test]
|
|
fn mousebindaction_serialize_deserialize() {
|
|
for (original_key, wrapper) in [
|
|
MousebindAction::Call(Box::new(HlwmCommand::Cycle)),
|
|
MousebindAction::Move,
|
|
MousebindAction::Resize,
|
|
MousebindAction::Zoom,
|
|
]
|
|
.map(|action| (action.clone(), MousebindActionWrapper { action }))
|
|
{
|
|
let wrapper_str = toml::to_string_pretty(&wrapper).unwrap();
|
|
let parsed: MousebindActionWrapper = toml::from_str(&wrapper_str).unwrap();
|
|
assert_eq!(original_key, parsed.action);
|
|
}
|
|
}
|
|
|
|
fn case_random<S: Into<String>>(s: S) -> Vec<String> {
|
|
let s = s.into();
|
|
let counts: usize = s.chars().map(|c| c.is_ascii_alphabetic() as usize).sum();
|
|
if counts < 2 {
|
|
return vec![s.to_string()];
|
|
}
|
|
let mut variants: Vec<String> = Vec::with_capacity(counts + 2);
|
|
let mut working = Vec::new();
|
|
|
|
for idx in 0..counts {
|
|
let mut c_idx = 0;
|
|
for c in s.chars() {
|
|
if !c.is_ascii_alphabetic() {
|
|
working.push(c);
|
|
continue;
|
|
}
|
|
if c_idx == idx {
|
|
working.push(c.to_ascii_uppercase());
|
|
} else {
|
|
working.push(c.to_ascii_lowercase());
|
|
}
|
|
c_idx += 1;
|
|
}
|
|
|
|
variants.push(working.into_iter().collect());
|
|
working = Vec::new();
|
|
}
|
|
variants.push(s.to_ascii_lowercase());
|
|
variants.push(s.to_ascii_uppercase());
|
|
|
|
variants
|
|
}
|
|
|
|
#[test]
|
|
fn key_from_case_insensitive() {
|
|
let test_cases = Key::iter().map(|key| {
|
|
let strings = key
|
|
.aliases()
|
|
.into_iter()
|
|
.map(|a| case_random(a))
|
|
.flatten()
|
|
.collect::<Vec<_>>();
|
|
(strings, key)
|
|
});
|
|
|
|
for (strings, key) in test_cases {
|
|
for case in strings {
|
|
println!("comparing str: [{case}] with key: [{key}]");
|
|
let parsed = Key::from_str_case_insensitive(&case).expect(&format!(
|
|
"key [{key}] parse from insensitive string [{case}] failed"
|
|
));
|
|
assert_eq!(key, parsed);
|
|
}
|
|
}
|
|
}
|
|
}
|