From 49fd65a4b08a7fe81e7e4df0b3ad08b139ccf903 Mon Sep 17 00:00:00 2001 From: moparisthebest Date: Wed, 15 Nov 2017 01:08:38 -0500 Subject: [PATCH] Panic cleanup part 2 --- src/keymapper.rs | 65 +++++++++++++++++++++--------------------------- src/main.rs | 10 +++++--- 2 files changed, 34 insertions(+), 41 deletions(-) diff --git a/src/keymapper.rs b/src/keymapper.rs index 434bcab..e33684f 100644 --- a/src/keymapper.rs +++ b/src/keymapper.rs @@ -8,6 +8,8 @@ use std::fs::File; use std::io::Read; use std::collections::HashMap; +use {Error, Result}; + // 1 is down, 0 is up const DOWN: i32 = 1; const UP: i32 = 0; @@ -24,7 +26,7 @@ const KEY_RIGHTSHIFT_U16: u16 = KEY_RIGHTSHIFT as u16; const KEY_CAPSLOCK_U16: u16 = KEY_CAPSLOCK as u16; trait KeyMapper { - fn send_event(&self, key_state: &[bool], event: &mut input_event, device: &Device); + fn send_event(&self, key_state: &[bool], event: &mut input_event, device: &Device) -> Result<()>; } pub struct KeyMaps { @@ -153,7 +155,7 @@ impl KeyMaps { //impl KeyMapper for KeyMaps { impl KeyMaps { - pub fn send_event(&mut self, mut event: &mut input_event, device: &Device) { + pub fn send_event(&mut self, mut event: &mut input_event, device: &Device) -> Result<()> { //println!("type: {} code: {} value: {}", event.type_, event.code, event.value); if event.value != 2 { // todo: index check here... @@ -177,7 +179,7 @@ impl KeyMaps { 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 + return Ok(()); // we don't want to also send this keypress, so bail } } if event.code == self.revert_default_key { @@ -189,7 +191,7 @@ impl KeyMaps { } } } - self.keymaps[self.current_keymap_index].send_event(&self.key_state, &mut event, device); + self.keymaps[self.current_keymap_index].send_event(&self.key_state, &mut event, device) } } @@ -239,10 +241,8 @@ impl KeyMap { } impl KeyMapper for KeyMap { - fn send_event(&self, key_state: &[bool], event: &mut input_event, device: &Device) { - self.keymap[event.code as usize].send_event(key_state, event, device); - //event.code = self.keymap[event.code as usize]; - //device.write_event(event).expect("could not write event?"); + fn send_event(&self, key_state: &[bool], event: &mut input_event, device: &Device) -> Result<()> { + self.keymap[event.code as usize].send_event(key_state, event, device) } } @@ -275,16 +275,16 @@ impl CodeKeyMap { } impl KeyMapper for CodeKeyMap { - fn send_event(&self, key_state: &[bool], event: &mut input_event, device: &Device) { - self.keymap[event.code as usize].send_event(key_state, event, device); + fn send_event(&self, key_state: &[bool], event: &mut input_event, device: &Device) -> Result<()> { + self.keymap[event.code as usize].send_event(key_state, event, device) } } -#[allow(unused_variables)] +#[allow(unused_variables, unused_mut)] impl KeyMapper for u16 { - fn send_event(&self, key_state: &[bool], mut event: &mut input_event, device: &Device) { + fn send_event(&self, key_state: &[bool], mut event: &mut input_event, device: &Device) -> Result<()> { event.code = *self; - device.write_event(event).expect("could not write event?"); + device.write_event(event) } } @@ -300,7 +300,7 @@ struct HalfInvertedKey { } impl HalfInvertedKey { - fn send_key(&self, key_state: &[bool], event: &mut input_event, device: &Device, left_shift: bool, right_shift: bool, caps_lock: bool) { + fn send_key(&self, key_state: &[bool], event: &mut input_event, device: &Device, left_shift: bool, right_shift: bool, caps_lock: bool) -> Result<()> { let code = self.code; let value = event.value; let mut invert_shift = self.invert_shift; @@ -320,12 +320,12 @@ impl HalfInvertedKey { event.value = DOWN; } //event.code.send_event(key_state, event, device); - device.write_event(event).expect("could not write event?"); + device.write_event(event)?; event.code = code; // not needed since u16 does it event.value = value; } } - code.send_event(key_state, event, device); + code.send_event(key_state, event, device)?; if value == UP { if caps_lock && self.capslock_nomodify { invert_shift = !invert_shift; @@ -342,21 +342,22 @@ impl HalfInvertedKey { event.value = UP; } //event.code.send_event(key_state, event, device); - device.write_event(event).expect("could not write event?"); + device.write_event(event)?; // neither of these are needed now... event.code = code; // not needed since u16 does it event.value = value; } } + Ok(()) } } impl KeyMapper for HalfInvertedKey { - fn send_event(&self, key_state: &[bool], event: &mut input_event, device: &Device) { + fn send_event(&self, key_state: &[bool], event: &mut input_event, device: &Device) -> Result<()> { let left_shift = key_state[LEFTSHIFT_INDEX]; let right_shift = key_state[RIGHTSHIFT_INDEX]; let caps_lock = key_state[CAPSLOCK_INDEX]; - self.send_key(key_state, event, device, left_shift, right_shift, caps_lock); + self.send_key(key_state, event, device, left_shift, right_shift, caps_lock) } } @@ -369,25 +370,25 @@ enum Key { } impl KeyMapper for Key { - fn send_event(&self, key_state: &[bool], event: &mut input_event, device: &Device) { + fn send_event(&self, key_state: &[bool], event: &mut input_event, device: &Device) -> Result<()> { match *self { Key::Noop => { - device.write_event(event).expect("could not write event?"); + device.write_event(event) }, Key::Direct(code) => { - code.send_event(key_state, event, device); + code.send_event(key_state, event, device) }, Key::HalfKey(ref key_half) => { - key_half.send_event(key_state, event, device); + key_half.send_event(key_state, event, device) }, Key::FullKey(ref noshift_half, ref shift_half) => { let left_shift = key_state[LEFTSHIFT_INDEX]; let right_shift = key_state[RIGHTSHIFT_INDEX]; let caps_lock = key_state[CAPSLOCK_INDEX]; if caps_lock != (left_shift || right_shift) { - shift_half.send_key(key_state, event, device, left_shift, right_shift, caps_lock); + shift_half.send_key(key_state, event, device, left_shift, right_shift, caps_lock) } else { - noshift_half.send_key(key_state, event, device, left_shift, right_shift, caps_lock); + noshift_half.send_key(key_state, event, device, left_shift, right_shift, caps_lock) } }, } @@ -407,24 +408,14 @@ pub struct KeymapConfig { keymaps: Vec } -/* -‎c`p‎: no, ? converts the error with From<> in its expansion -‎c`p‎: so unless io::Error: From it isnt going to work -c`p‎: the idea with your own error type is that MyError: From + From + etc etc -‎c`p‎: ie enum MyError { Io(io::Error), Toml(toml::Error), ... } -c`p‎: error-chain does all this stuff for you -*/ - -use std::io::{Error, ErrorKind}; - -fn parse_cfg>(path: P) -> Result { +fn parse_cfg>(path: P) -> Result { let mut f = File::open(path)?; let mut input = String::new(); f.read_to_string(&mut input)?; //toml::from_str(&input)? match toml::from_str(&input) { Ok(toml) => Ok(toml), - Err(_) => Err(Error::new(ErrorKind::Other, "oh no!")) + Err(_) => Err(Error::NotFound) // todo: something better } } diff --git a/src/main.rs b/src/main.rs index 6071992..a034556 100644 --- a/src/main.rs +++ b/src/main.rs @@ -51,15 +51,17 @@ fn main() { let config_file = config.config_file.clone(); let tx = tx.clone(); thread::spawn(move || { - do_map(&device_file, &config_file).ok(); + let ret = do_map(&device_file, &config_file).err(); + if let Some(e) = ret { + println!("mapping for {} ended due to error: {}", device_file, e); + } tx.send(1).unwrap(); }); } // wait for all threads to finish let mut num_threads = config.device_files.len(); for received in rx { - println!("Got: {}", received); - num_threads = num_threads - received; + num_threads -= received; if num_threads == 0 { break; } @@ -86,7 +88,7 @@ fn do_map(device_file: &str, config_file: &str) -> Result<()> { loop { let mut event = input_device.read_event()?; if event.type_ == EV_KEY_U16 { - key_map.send_event(&mut event, &device); + key_map.send_event(&mut event, &device)? } else { device.write_event(&mut event)? }