qsk_types/
layers.rs

1use std::collections::HashMap;
2use std::ops::{Index, IndexMut};
3use std::slice::IterMut;
4
5use crate::control_code::ControlCode;
6use crate::events::{InputEvent, EventCode, KeyCode};
7
8#[derive(Clone)]
9pub struct KeyMap(HashMap<EventCode, Vec<ControlCode>>);
10
11impl Index<EventCode> for KeyMap {
12    type Output = Vec<ControlCode>;
13
14    fn index(&self, index: EventCode) -> &Self::Output {
15        &self.0[&index]
16    }
17}
18
19#[derive(Clone)]
20pub struct Layer {
21    pub name: String,
22    map: KeyMap,
23    pub active: bool,
24}
25
26fn copy_control_codes_for_input_event(e: InputEvent, ccs: &Vec<ControlCode>) -> Vec<ControlCode> {
27    ccs.iter()
28        .map(|cc| {
29            match cc {
30                ControlCode::KeyMap(kc) => {
31                    let mut cloned = e.clone();
32                    cloned.code = EventCode::KeyCode(*kc);
33                    ControlCode::InputEvent(cloned)
34                }
35                _ => cc.clone(),
36            }
37        })
38        .collect()
39}
40
41impl Layer {
42    pub fn from_hashmap(name: String, map: HashMap<KeyCode, Vec<ControlCode>>, active: bool) -> Layer {
43        Layer {
44            name,
45            map: KeyMap(map
46                .iter()
47                .map(|(k, v)| (EventCode::KeyCode(*k), v.clone()) )
48                .collect()),
49            active,
50        }
51    }
52
53    pub(crate) fn transform(&mut self, e: InputEvent) -> Option<Vec<ControlCode>> {
54        match (self.map.0.get(&e.code), self.active) {
55            (Some(ccs), true) => Some(copy_control_codes_for_input_event(e.clone(), ccs)),
56            (Some(_), false) => None,
57            (None, _) => None,
58        }
59    }
60
61    pub fn activate(&mut self) {
62        self.active = true
63    }
64
65    pub fn iter(&self) -> impl Iterator<Item = (&EventCode, &Vec<ControlCode>)> {
66        self.map.0.iter()
67    }
68}
69
70pub struct Layers {
71    vec: Vec<Layer>,
72    map: HashMap<String, usize>,
73}
74
75impl Index<usize> for Layers {
76    type Output = Layer;
77
78    fn index(&self, index: usize) -> &Self::Output {
79        &self.vec[index]
80    }
81}
82
83impl IndexMut<usize> for Layers {
84    fn index_mut(& mut self, index: usize) -> &mut Self::Output {
85        &mut self.vec[index]
86    }
87}
88
89impl From<Vec<Layer>> for Layers {
90    fn from(vec: Vec<Layer>) -> Self {
91        let map: HashMap<String, usize> = vec.iter()
92            .enumerate()
93            .map(|(i, layer)| (layer.name.clone(), i))
94            .collect();
95        Self {
96            vec,
97            map,
98        }
99    }
100}
101
102impl Layers {
103    pub(crate) fn iter_mut(&mut self) -> IterMut<Layer> {
104        self.vec.iter_mut()
105    }
106
107    pub(crate) fn get_mut(&mut self, key: &str) -> Option<&mut Layer> {
108        match self.map.get_mut(key) {
109            Some(idx) => Some(&mut self.vec[*idx]),
110            None => None,
111        }
112    }
113
114    pub fn iter(&self) -> impl Iterator<Item = &Layer> {
115        self.vec.iter()
116    }
117}
qsk_types/layers.rs

qsk_types/
layers.rs
