kickoff 0.7.1

Fast and minimal program launcher
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use crate::gui::Action;
use serde::de::{self, Visitor};
use serde::{Deserialize, Deserializer};
use smithay_client_toolkit::seat::keyboard::{Keysym, Modifiers as ModifiersState};
use std::collections::HashMap;
use std::fmt;
use std::hash::{Hash, Hasher};
use x11_keysymdef::lookup_by_name;

use crate::config::KeybindingsConfig;

pub struct Keybindings {
    inner: HashMap<KeyCombo, Action>,
}

impl From<KeybindingsConfig> for Keybindings {
    fn from(config: KeybindingsConfig) -> Self {
        let mut res = Self {
            inner: HashMap::new(),
        };

        res.add_key_combos(&Action::Complete, &config.complete);
        res.add_key_combos(&Action::Execute, &config.execute);
        res.add_key_combos(&Action::Exit, &config.exit);
        res.add_key_combos(&Action::Delete, &config.delete);
        res.add_key_combos(&Action::DeleteWord, &config.delete_word);
        res.add_key_combos(&Action::NavUp, &config.nav_up);
        res.add_key_combos(&Action::NavDown, &config.nav_down);
        res.add_key_combos(&Action::Paste, &config.paste);

        res
    }
}

#[derive(Clone, Default, Debug)]
pub struct Modifiers(ModifiersState);

impl From<ModifiersState> for Modifiers {
    fn from(modifiers: ModifiersState) -> Self {
        Self(modifiers)
    }
}

impl Hash for Modifiers {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.0.alt.hash(state);
        self.0.shift.hash(state);
        self.0.ctrl.hash(state);
        self.0.logo.hash(state);
    }
}

impl PartialEq for Modifiers {
    fn eq(&self, other: &Self) -> bool {
        self.0.ctrl == other.0.ctrl
            && self.0.alt == other.0.alt
            && self.0.shift == other.0.shift
            && self.0.logo == other.0.logo
    }
}
impl Eq for Modifiers {}

#[derive(Eq, PartialEq, Hash, Clone, fmt::Debug)]
pub struct KeyCombo {
    modifiers: Modifiers,
    key: Keysym,
}

impl Keybindings {
    pub fn get(&self, modifiers: ModifiersState, keysym: Keysym) -> Option<&Action> {
        self.inner.get(&KeyCombo {
            modifiers: Modifiers(modifiers),
            key: keysym,
        })
    }

    fn add_key_combos(&mut self, action: &Action, key_combos: &[KeyCombo]) {
        for entry in key_combos.iter() {
            self.inner.insert(entry.clone(), action.clone());
        }
    }
}

impl KeyCombo {
    pub const fn new(modifiers: Modifiers, key: Keysym) -> Self {
        Self { modifiers, key }
    }
}

impl<'de> Deserialize<'de> for KeyCombo {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        deserializer.deserialize_str(KeyComboVisitor)
    }
}

struct KeyComboVisitor;
impl<'de> Visitor<'de> for KeyComboVisitor {
    type Value = KeyCombo;
    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("assignments of key combinations")
    }

    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        let mut modifiers = ModifiersState::default();
        let mut key: Option<Keysym> = None;
        value.split('+').for_each(|s| match s {
            "ctrl" => modifiers.ctrl = true,
            "shift" => modifiers.shift = true,
            "alt" => modifiers.alt = true,
            "logo" => modifiers.logo = true,
            s => {
                if let Some(value) = lookup_by_name(s) {
                    key = Some(Keysym::from(value.keysym));
                }
            }
        });
        key.map_or_else(
            || Err(de::Error::custom("No key given or unable to parse")),
            |key| {
                Ok(KeyCombo {
                    modifiers: Modifiers(modifiers),
                    key,
                })
            },
        )
    }
}