keyboard win, mid commit

Signed-off-by: fufesou <shuanglongchen@yeah.net>

src/keyboard.rs

@@ -103,8 +103,9 @@ pub mod client {
         if is_long_press(&event) {
             return;
         }
-        let key_event = event_to_key_event(&event);
+        if let Some(key_event) = event_to_key_event(&event) {
-        send_key_event(&key_event);
+            send_key_event(&key_event);
+        }
     }
 
     pub fn get_modifiers_state(
@@ -314,7 +315,7 @@ fn update_modifiers_state(event: &Event) {
     };
 }
 
-pub fn event_to_key_event(event: &Event) -> KeyEvent {
+pub fn event_to_key_event(event: &Event) -> Option<KeyEvent> {
     let mut key_event = KeyEvent::new();
     update_modifiers_state(event);
 
@@ -330,22 +331,22 @@ pub fn event_to_key_event(event: &Event) -> KeyEvent {
 
     let keyboard_mode = get_keyboard_mode_enum();
     key_event.mode = keyboard_mode.into();
-    match keyboard_mode {
+    let mut key_event = match keyboard_mode {
         KeyboardMode::Map => {
-            map_keyboard_mode(event, &mut key_event);
+            map_keyboard_mode(event, key_event)?
         }
         KeyboardMode::Translate => {
-            translate_keyboard_mode(event, &mut key_event);
+            translate_keyboard_mode(event, key_event)?
         }
         _ => {
             #[cfg(not(any(target_os = "android", target_os = "ios")))]
-            legacy_keyboard_mode(event, &mut key_event);
+            legacy_keyboard_mode(event, key_event)?
         }
     };
     #[cfg(not(any(target_os = "android", target_os = "ios")))]
     add_numlock_capslock_status(&mut key_event);
 
-    return key_event;
+    return Some(key_event);
 }
 
 pub fn event_type_to_event(event_type: EventType) -> Event {
@@ -374,15 +375,15 @@ pub fn get_peer_platform() -> String {
 }
 
 #[cfg(not(any(target_os = "android", target_os = "ios")))]
-pub fn legacy_keyboard_mode(event: &Event, key_event: &mut KeyEvent) {
+pub fn legacy_keyboard_mode(event: &Event, mut key_event: KeyEvent) -> Option<KeyEvent> {
     // legacy mode(0): Generate characters locally, look for keycode on other side.
     let (mut key, down_or_up) = match event.event_type {
         EventType::KeyPress(key) => (key, true),
         EventType::KeyRelease(key) => (key, false),
         _ => {
-            return;
+            return None;
         }
-    };
+    }; 
 
     let peer = get_peer_platform();
     let is_win = peer == "Windows";
@@ -422,11 +423,11 @@ pub fn legacy_keyboard_mode(event: &Event, key_event: &mut KeyEvent) {
             // when pressing AltGr, an extra VK_LCONTROL with a special
             // scancode with bit 9 set is sent, let's ignore this.
             #[cfg(windows)]
-            if event.scan_code & 0x200 != 0 {
+            if (event.scan_code >> 8) == 0xE0 {
                 unsafe {
                     IS_ALT_GR = true;
                 }
-                return;
+                return None;
             }
             Some(ControlKey::Control)
         }
@@ -458,7 +459,7 @@ pub fn legacy_keyboard_mode(event: &Event, key_event: &mut KeyEvent) {
         Key::Delete => {
             if is_win && ctrl && alt {
                 client::ctrl_alt_del();
-                return;
+                return None;
             }
             Some(ControlKey::Delete)
         }
@@ -496,7 +497,7 @@ pub fn legacy_keyboard_mode(event: &Event, key_event: &mut KeyEvent) {
         Key::KpMinus => Some(ControlKey::Subtract),
         Key::KpPlus => Some(ControlKey::Add),
         Key::CapsLock | Key::NumLock | Key::ScrollLock => {
-            return;
+            return None;
         }
         Key::Home => Some(ControlKey::Home),
         Key::End => Some(ControlKey::End),
@@ -579,27 +580,28 @@ pub fn legacy_keyboard_mode(event: &Event, key_event: &mut KeyEvent) {
         if chr != '\0' {
             if chr == 'l' && is_win && command {
                 client::lock_screen();
-                return;
+                return None;
             }
             key_event.set_chr(chr as _);
         } else {
             log::error!("Unknown key {:?}", &event);
-            return;
+            return None;
         }
     }
     let (alt, ctrl, shift, command) = client::get_modifiers_state(alt, ctrl, shift, command);
-    client::legacy_modifiers(key_event, alt, ctrl, shift, command);
+    client::legacy_modifiers(&mut key_event, alt, ctrl, shift, command);
 
     if down_or_up == true {
         key_event.down = true;
     }
+    Some(key_event)
 }
 
-pub fn map_keyboard_mode(event: &Event, key_event: &mut KeyEvent) {
+pub fn map_keyboard_mode(event: &Event, mut key_event: KeyEvent) -> Option<KeyEvent> {
     let mut peer = get_peer_platform().to_lowercase();
     peer.retain(|c| !c.is_whitespace());
 
-    let key = match event.event_type {
+    let mut key = match event.event_type {
         EventType::KeyPress(key) => {
             key_event.down = true;
             key
@@ -608,29 +610,32 @@ pub fn map_keyboard_mode(event: &Event, key_event: &mut KeyEvent) {
             key_event.down = false;
             key
         }
-        _ => return,
+        _ => return None,
     };
 
     #[cfg(target_os = "windows")]
     let keycode = match peer.as_str() {
         "windows" => event.scan_code,
-        "macos" => rdev::macos_keycode_from_key(key).unwrap_or_default().into(),
+        "macos" => rdev::win_scancode_to_macos_code(event.scan_code)?,
-        _ => rdev::linux_keycode_from_key(key).unwrap_or_default().into(),
+        _ => rdev::win_scancode_to_linux_code(event.scan_code)?,
     };
     #[cfg(target_os = "macos")]
     let keycode = match peer.as_str() {
-        "windows" => rdev::win_scancode_from_key(key).unwrap_or_default().into(),
+        "windows" => rdev::macos_code_to_win_scancode(event.code as _)?,
-        "macos" => rdev::macos_keycode_from_key(key).unwrap_or_default().into(),
+        "macos" => rdev::macos_code_to_linux_code(event.code as _)?,
         _ => event.code,
     };
     #[cfg(target_os = "linux")]
     let keycode = match peer.as_str() {
-        "windows" => rdev::win_scancode_from_key(key).unwrap_or_default().into(),
+        "windows" => rdev::linux_code_to_win_scancode(event.code as _)?,
         "macos" => event.code,
-        _ => rdev::linux_keycode_from_key(key).unwrap_or_default().into(),
+        _ => rdev::linux_code_to_macos_code(event.code as _)?,
     };
 
     key_event.set_chr(keycode);
+    Some(key_event)
 }
 
-pub fn translate_keyboard_mode(_event: &Event, _key_event: &mut KeyEvent) {}
+pub fn translate_keyboard_mode(_event: &Event, mut _key_event: KeyEvent) -> Option<KeyEvent> {
+    None
+}