From 0236df691440bb2b2ac329fb4775cd954e14e2ed Mon Sep 17 00:00:00 2001 From: moparisthebest Date: Thu, 14 Sep 2017 22:57:20 -0400 Subject: [PATCH] finish permanent and temporary keymap switching, basic non-shift-modifying mapping complete --- keymap.toml | 2 +- src/main.rs | 93 +++++++++++++++++++++++++++++++++++++++++++++-------- 2 files changed, 80 insertions(+), 15 deletions(-) diff --git a/keymap.toml b/keymap.toml index 7103f96..59074e2 100644 --- a/keymap.toml +++ b/keymap.toml @@ -10,7 +10,7 @@ revert_keymap_index = 0 # this is the default index to use when the program first starts # in this case, 2 means modified Progammer Dvorak -default_keymap_index = 2 +default_keymap_index = 1 # these are keys that caps_lock doesn't modify by default, but that you would like it to, affects all keymaps caps_lock_modify = """ diff --git a/src/main.rs b/src/main.rs index 15a57b9..c72e962 100644 --- a/src/main.rs +++ b/src/main.rs @@ -56,7 +56,7 @@ fn main() { //.event(uinput::event::Keyboard::All).unwrap() .create().expect("4"); - let key_map = KeyMaps::new(&key_map, key_map_config); + let mut key_map = KeyMaps::new(&key_map, key_map_config); //println!("keymaps: {:?}", keymaps); //let mut key_map = KeyMap::new(); @@ -205,22 +205,46 @@ impl Drop for InputDevice { } // keymapper stuff +// 1 is down, 0 is up +const DOWN : i32 = 1; +const UP : i32 = 0; trait KeyMapper { - fn send_event(&self, event: input_event, device: &Device); + fn send_event(&mut self, event: input_event, device: &Device); +} + +struct LayoutSwitchKey { + key: u16, + down: bool, +} + +impl LayoutSwitchKey { + fn set_down(&mut self, event: input_event) { + self.down = event.value == DOWN; + } } struct KeyMaps { - keymaps: Vec, + keymaps: Vec, + keymap_index_keys: HashMap, + switch_layout_keys: Vec, + revert_default_key: u16, + revert_keymap_index: usize, + // above do not change, below does + chosen_keymap_index: usize, + current_keymap_index: usize, + switch_layout_keys_pressed: bool, +} + +fn parse_key(key_map: &HashMap<&'static str, *const c_int>, key: &str) -> u16 { + match key_map.get(key.trim()) { + Some(key_code) => *key_code as u16, + None => panic!("unknown key: {}", key.trim()) + } } fn parse_keymap(key_map: &HashMap<&'static str, *const c_int>, keymap: &str) -> Vec { - keymap.split(",").map(|k| - match key_map.get(k.trim()) { - Some(key_code) => *key_code as u16, - None => panic!("unknown key: {}", k.trim()) - } - ).collect() + keymap.split(",").map(|k|parse_key(key_map, k)).collect() } impl KeyMaps { @@ -228,10 +252,15 @@ impl KeyMaps { if config.keymaps.len() < 2 { panic!("must have at least 2 keymaps (original and mapped) but only have {},", config.keymaps.len()); } + if config.default_keymap_index >= config.keymaps.len() || config.revert_keymap_index >= config.keymaps.len() { + panic!("default_keymap_index ({}) and revert_keymap_index ({}) must be less than keymaps length ({}),", config.default_keymap_index, config.revert_keymap_index, config.keymaps.len()); + } let base_keymap = parse_keymap(key_map, &config.keymaps[0]); println!("base_keymap : {:?}", base_keymap); let mut keymaps = vec!(KeyMap::new()); + let mut keymap_index_keys: HashMap = HashMap::new(); for (x, v) in config.keymaps.iter().enumerate() { + keymap_index_keys.insert(*key_map.get(&*x.to_string()).unwrap() as u16, x); if x == 0 { continue; } @@ -248,16 +277,52 @@ impl KeyMaps { keymaps.push(keymap); } //println!("keymaps: {:?}", keymaps); + //println!("keymap_index_keys: {:?}", keymap_index_keys); + KeyMaps { - keymaps: keymaps + keymaps: keymaps, + keymap_index_keys: keymap_index_keys, + switch_layout_keys: config.switch_layout_keys.iter().map(|k|LayoutSwitchKey { key: parse_key(key_map, k), down: false }).collect(), + revert_default_key: parse_key(key_map, &config.revert_default_key), + revert_keymap_index: config.revert_keymap_index, + chosen_keymap_index: config.default_keymap_index, + current_keymap_index: config.default_keymap_index, + switch_layout_keys_pressed: false, } } } impl KeyMapper for KeyMaps { - fn send_event(&self, event: input_event, device: &Device) { - //println!("type: {} code: {}", event.type_, event.code); - self.keymaps[1].send_event(event, device); + fn send_event(&mut self, event: input_event, device: &Device) { + //println!("type: {} code: {} value: {}", event.type_, event.code, event.value); + if event.value != 2 { + let mut switch_layout_keys_pressed = true; + for mut layout_switch_key in self.switch_layout_keys.iter_mut() { + if event.code == layout_switch_key.key { + layout_switch_key.set_down(event); + } + switch_layout_keys_pressed &= layout_switch_key.down; + } + self.switch_layout_keys_pressed = switch_layout_keys_pressed; + //println!("switch_layout_keys_pressed: {}", self.switch_layout_keys_pressed); + if self.switch_layout_keys_pressed { + let new_index = self.keymap_index_keys.get(&event.code); + if new_index.is_some() { + self.chosen_keymap_index = *new_index.unwrap(); + self.current_keymap_index = self.chosen_keymap_index; // todo: what if revert_default_key is held? for now ignore + return; // we don't want to also send this keypress, so bail + } + } + if event.code == self.revert_default_key { + match event.value { + // todo: ctrl+c will get c stuck because code c value 1 will be sent, but then we'll let go of ctrl, and code j value 0 is sent, so c is never released... fix that... + 1 => self.current_keymap_index = self.revert_keymap_index, + 0 => self.current_keymap_index = self.chosen_keymap_index, + _ => () // do nothing for 2 + } + } + } + self.keymaps[self.current_keymap_index].send_event(event, device); } } @@ -610,7 +675,7 @@ impl KeyMap { } impl KeyMapper for KeyMap { - fn send_event(&self, mut event: input_event, device: &Device) { + fn send_event(&mut self, mut event: input_event, device: &Device) { event.code = self.keymap[event.code as usize]; device.write_event(event).expect("could not write event?"); }