Decode Pause and Print Scr correctly.

Tapping "Pause" generates E1,14,77,E1,F0,14,F0,77

We now decode this as:

* PauseBreak/Down
* NumLock/Down
* PauseBreak/Up
* NumLock/Up

Tapping "Print Scr" generates E0,12,E0,7C. This becomes:

We now decode this as:

* PrintScreen/SingleShot
* PrintScreen2/SingleShot

Note the addition of the "SingleShot" KeyState, for keys that don't
have a Make/Break pair. This avoids users waiting a "Break" that never
happens.

Author: thejpster

src/lib.rs

@@ -189,12 +189,17 @@ pub enum KeyCode {
     // Sent when the keyboard boots
     PowerOnTestOk,
     Oem102,
+    /// PrintScreen comes in two parts - this is the second
+    PrintScreen2,
+    /// Sent by the keyboard when too many keys are pressed
+    TooManyKeys,
 }
 
 #[derive(Debug, PartialEq, Eq, Copy, Clone)]
 pub enum KeyState {
     Up,
     Down,
+    SingleShot,
 }
 
 /// Options for how we can handle what happens when the Ctrl key is held down
@@ -237,6 +242,10 @@ pub trait ScancodeSet {
     /// Convert a Scan Code Set X extended byte (prefixed E0) to our `KeyCode`
     /// enum.
     fn map_extended_scancode(code: u8) -> Result<KeyCode, Error>;
+
+    /// Convert a Scan Code Set X extended byte (prefixed E1) to our `KeyCode`
+    /// enum.
+    fn map_extended2_scancode(code: u8) -> Result<KeyCode, Error>;
 }
 
 #[derive(Debug)]
@@ -276,6 +285,8 @@ pub enum DecodeState {
     Extended,
     Release,
     ExtendedRelease,
+    Extended2,
+    Extended2Release,
 }
 
 // ****************************************************************************
@@ -286,6 +297,7 @@ pub enum DecodeState {
 
 const KEYCODE_BITS: u8 = 11;
 const EXTENDED_KEY_CODE: u8 = 0xE0;
+const EXTENDED2_KEY_CODE: u8 = 0xE1;
 const KEY_RELEASE_CODE: u8 = 0xF0;
 
 // ****************************************************************************
@@ -912,8 +924,8 @@ mod test {
         }
         codes.sort();
         println!("{:?}", codes);
-        assert_eq!(codes.len(), 85);
-        assert_eq!(errs.len(), 43);
+        assert_eq!(codes.len(), 86);
+        assert_eq!(errs.len(), 42);
 
         let mut codes = Vec::new();
         let mut errs = Vec::new();
@@ -926,8 +938,8 @@ mod test {
         }
         codes.sort();
         println!("{:?}", codes);
-        assert_eq!(codes.len(), 87);
-        assert_eq!(errs.len(), 169);
+        assert_eq!(codes.len(), 89);
+        assert_eq!(errs.len(), 167);
     }
 
     #[test]
@@ -970,6 +982,38 @@ mod test {
         );
     }
 
+    #[test]
+    fn test_set_2_poweron() {
+        let mut k = Keyboard::new(
+            layouts::Us104Key,
+            ScancodeSet2,
+            HandleControl::MapLettersToUnicode,
+        );
+        assert_eq!(
+            k.add_byte(0xAA),
+            Ok(Some(KeyEvent::new(
+                KeyCode::PowerOnTestOk,
+                KeyState::SingleShot
+            )))
+        );
+    }
+
+    #[test]
+    fn test_set_2_toomanykeys() {
+        let mut k = Keyboard::new(
+            layouts::Us104Key,
+            ScancodeSet2,
+            HandleControl::MapLettersToUnicode,
+        );
+        assert_eq!(
+            k.add_byte(0x00),
+            Ok(Some(KeyEvent::new(
+                KeyCode::TooManyKeys,
+                KeyState::SingleShot
+            )))
+        );
+    }
+
     #[test]
     fn test_set_2_down_up() {
         let mut k = Keyboard::new(

src/scancodes.rs

@@ -1,6 +1,6 @@
 use super::{
-    DecodeState, Error, KeyCode, KeyEvent, KeyState, ScancodeSet, EXTENDED_KEY_CODE,
-    KEY_RELEASE_CODE,
+    DecodeState, Error, KeyCode, KeyEvent, KeyState, ScancodeSet, EXTENDED2_KEY_CODE,
+    EXTENDED_KEY_CODE, KEY_RELEASE_CODE,
 };
 
 /// Contains the implementation of Scancode Set 1.
@@ -239,6 +239,11 @@ impl ScancodeSet for ScancodeSet1 {
             _ => Err(Error::UnknownKeyCode),
         }
     }
+
+    /// There are no extended2 scancodes here
+    fn map_extended2_scancode(_code: u8) -> Result<KeyCode, Error> {
+        Err(Error::UnknownKeyCode)
+    }
 }
 
 /// Contains the implementation of Scancode Set 2.
@@ -252,6 +257,7 @@ impl ScancodeSet for ScancodeSet2 {
     /// Start:
     /// F0 => Release
     /// E0 => Extended
+    /// E1 => Extended2 (only used for Pause Key)
     /// xx => Key Down
     ///
     /// Release:
@@ -263,21 +269,39 @@ impl ScancodeSet for ScancodeSet2 {
     ///
     /// Release Extended:
     /// xxx => Extended Key Up
+    ///
+    /// Extended2:
+    /// F0 => Release Extended2
+    /// xx => Extended2 Key Down
+    ///
+    /// Release Extended2:
+    /// xxx => Extended2 Key Up
     fn advance_state(state: &mut DecodeState, code: u8) -> Result<Option<KeyEvent>, Error> {
         match *state {
             DecodeState::Start => match code {
                 EXTENDED_KEY_CODE => {
                     *state = DecodeState::Extended;
                     Ok(None)
                 }
+                EXTENDED2_KEY_CODE => {
+                    *state = DecodeState::Extended2;
+                    Ok(None)
+                }
                 KEY_RELEASE_CODE => {
                     *state = DecodeState::Release;
                     Ok(None)
                 }
-                _ => Ok(Some(KeyEvent::new(
-                    Self::map_scancode(code)?,
-                    KeyState::Down,
-                ))),
+                _ => {
+                    let keycode = Self::map_scancode(code)?;
+                    if keycode == KeyCode::TooManyKeys || keycode == KeyCode::PowerOnTestOk {
+                        Ok(Some(KeyEvent::new(keycode, KeyState::SingleShot)))
+                    } else {
+                        Ok(Some(KeyEvent::new(
+                            Self::map_scancode(code)?,
+                            KeyState::Down,
+                        )))
+                    }
+                }
             },
             DecodeState::Release => {
                 *state = DecodeState::Start;
@@ -288,18 +312,41 @@ impl ScancodeSet for ScancodeSet2 {
                     *state = DecodeState::ExtendedRelease;
                     Ok(None)
                 }
+                _ => {
+                    *state = DecodeState::Start;
+
+                    let keycode = Self::map_extended_scancode(code)?;
+                    if keycode == KeyCode::PrintScreen || keycode == KeyCode::PrintScreen2 {
+                        Ok(Some(KeyEvent::new(keycode, KeyState::SingleShot)))
+                    } else {
+                        Ok(Some(KeyEvent::new(keycode, KeyState::Down)))
+                    }
+                }
+            },
+            DecodeState::ExtendedRelease => {
+                *state = DecodeState::Start;
+                Ok(Some(KeyEvent::new(
+                    Self::map_extended_scancode(code)?,
+                    KeyState::Up,
+                )))
+            }
+            DecodeState::Extended2 => match code {
+                KEY_RELEASE_CODE => {
+                    *state = DecodeState::Extended2Release;
+                    Ok(None)
+                }
                 _ => {
                     *state = DecodeState::Start;
                     Ok(Some(KeyEvent::new(
-                        Self::map_extended_scancode(code)?,
+                        Self::map_extended2_scancode(code)?,
                         KeyState::Down,
                     )))
                 }
             },
-            DecodeState::ExtendedRelease => {
+            DecodeState::Extended2Release => {
                 *state = DecodeState::Start;
                 Ok(Some(KeyEvent::new(
-                    Self::map_extended_scancode(code)?,
+                    Self::map_extended2_scancode(code)?,
                     KeyState::Up,
                 )))
             }
@@ -309,6 +356,7 @@ impl ScancodeSet for ScancodeSet2 {
     /// Implements the single byte codes for Set 2.
     fn map_scancode(code: u8) -> Result<KeyCode, Error> {
         match code {
+            0x00 => Ok(KeyCode::TooManyKeys),        // 00
             0x01 => Ok(KeyCode::F9),                 // 01
             0x03 => Ok(KeyCode::F5),                 // 03
             0x04 => Ok(KeyCode::F3),                 // 04
@@ -405,6 +453,7 @@ impl ScancodeSet for ScancodeSet2 {
     fn map_extended_scancode(code: u8) -> Result<KeyCode, Error> {
         match code {
             0x11 => Ok(KeyCode::AltRight),     // E011
+            0x12 => Ok(KeyCode::PrintScreen),  // E012 (first half)
             0x14 => Ok(KeyCode::ControlRight), // E014
             0x1F => Ok(KeyCode::WindowsLeft),  // E01F
             0x27 => Ok(KeyCode::WindowsRight), // E027
@@ -420,9 +469,17 @@ impl ScancodeSet for ScancodeSet2 {
             0x74 => Ok(KeyCode::ArrowRight),   // E074
             0x75 => Ok(KeyCode::ArrowUp),      // E075
             0x7A => Ok(KeyCode::PageDown),     // E07A
-            0x7C => Ok(KeyCode::PrintScreen),  // E07C
+            0x7C => Ok(KeyCode::PrintScreen2), // E07C (second half)
             0x7D => Ok(KeyCode::PageUp),       // E07D
-            0x7E => Ok(KeyCode::Break),        // E07E
+            0x7E => Ok(KeyCode::ScrollLock),   // E07E
+            _ => Err(Error::UnknownKeyCode),
+        }
+    }
+
+    /// Implements the extended byte codes for set 2 (prefixed with E1)
+    fn map_extended2_scancode(code: u8) -> Result<KeyCode, Error> {
+        match code {
+            0x14 => Ok(KeyCode::PauseBreak), // E114
             _ => Err(Error::UnknownKeyCode),
         }
     }