Audit Linux keyboard

Author: STREGA

Sources/GateEngine/System/HID/Keyboard/Keyboard.swift

@@ -15,43 +15,115 @@ import GameMath
 
     internal var activeStreams: Set<WeakCharacterStream> = []
 
-    public func button(_ keyboardKey: KeyboardKey) -> ButtonState {
+    /**
+     Gets a ``ButtonState`` associcated with the physical key.
+     
+     When requesting a key represents multiple buttons, such as with `.character("1", .anyVariation)`, the `ButtonState` returned will be one of the represented physical keys.
+     If you keep a reference to the ``ButtonState`` you will only be checking that physical button. Request a new ``ButtonState`` each time to ensure any variation of the ``KeyboardKey`` is returned.
+     
+     When requesting with a physical ``KeyboardKey``, like `.shift(.leftSide)`,  it is okay to keep a reference to the ``ButtonState``.
+     
+     - parameter keybordKey: A ``KeyboardKey`` that represents a physical keyboard button.
+     - note: Non-physical keys are keys which have no physical button, like `.control(.anything)` or `.character("0", .anyVariation)`
+     - returns: A ``ButtonState``, or `nil` if the key is not a physical key.
+     */
+    public func button(_ keyboardKey: KeyboardKey) -> ButtonState? {
         if let exactMatch = buttons[keyboardKey] {
             return exactMatch
         }
         if let existing = buttons.first(where: { (key: KeyboardKey, value: ButtonState) in
             if case let .character(character1, origin1) = keyboardKey {
                 if case let .character(character2, origin2) = key {
                     guard character1 == character2 else {return false}
-                    if origin1 == .fromAnywhere || origin2 == .fromAnywhere {
-                        return true
+                    if origin1 == origin2 || origin1 == .anyVariation {
+                        return value.isPressed
                     }
-                    return origin1 == origin2
                 }
                 return false
             }
             if case let .enter(origin1) = keyboardKey {
                 if case let .enter(origin2) = key {
-                    if origin1 == .fromAnywhere || origin2 == .fromAnywhere {
-                        return true
+                    if origin1 == origin2 || origin1 == .anyVariation {
+                        return value.isPressed
+                    }
+                }
+                return false
+            }
+            if case let .shift(alignment1) = keyboardKey {
+                if case let .shift(alignment2) = key {
+                    if alignment1 == .anyVariation || alignment2 == .anyVariation {
+                        return value.isPressed
+                    }
+                }
+                return false
+            }
+            if case let .control(alignment1) = keyboardKey {
+                if case let .control(alignment2) = key {
+                    if alignment1 == .anyVariation || alignment2 == .anyVariation {
+                        return value.isPressed
+                    }
+                }
+                return false
+            }
+            if case let .alt(alignment1) = keyboardKey {
+                if case let .alt(alignment2) = key {
+                    if alignment1 == .anyVariation || alignment2 == .anyVariation {
+                        return value.isPressed
+                    }
+                }
+                return false
+            }
+            if case let .host(alignment1) = keyboardKey {
+                if case let .host(alignment2) = key {
+                    if alignment1 == .anyVariation || alignment2 == .anyVariation {
+                        return value.isPressed
                     }
-                    return origin1 == origin2
                 }
                 return false
             }
             return false
         }) {
             return existing.value
         }
-        let button = ButtonState(keyboard: self, key: keyboardKey)
-        buttons[keyboardKey] = button
-        return button
+        switch keyboardKey {
+        // Non-physical keys can't have a button
+        case .shift(.anyVariation), .alt(.anyVariation), .host(.anyVariation),
+             .control(.anyVariation), .enter(.anyVariation),
+             .character(_, .anyVariation), .unhandledPlatformKeyCode(_, _):
+            return nil
+        default:
+            let button = ButtonState(keyboard: self, key: keyboardKey)
+            buttons[keyboardKey] = button
+            return button
+        }
     }
 
+    /// All currently pressed keyboard keys
     @inlinable @inline(__always)
     public func pressedButtons() -> [KeyboardKey:ButtonState] {
         return buttons.filter({$0.value.isPressed})
     }
+    
+    
+    internal func _button(_ keyboardKey: KeyboardKey) -> ButtonState {
+        #if GATEENGINE_DEBUG_HID
+        switch keyboardKey {
+        // Non-physical keys can't have a button
+        case .shift(.anyVariation), .alt(.anyVariation), .host(.anyVariation),
+             .control(.anyVariation), .enter(.anyVariation),
+             .character(_, .anyVariation), .unhandledPlatformKeyCode(_, _):
+            assertionFailure("pass physical keys only")
+        default:
+           break
+        }
+        #endif
+        if let exactMatch = buttons[keyboardKey] {
+            return exactMatch
+        }
+        let button = ButtonState(keyboard: self, key: keyboardKey)
+        buttons[keyboardKey] = button
+        return button
+    }
 }
 
 
@@ -65,28 +137,56 @@ public extension Keyboard {
         internal var currentRecipt: UInt8 = 0
 
         nonisolated public var description: String {
-            if case .unhandledPlatformKeyCode(let keyCode, let character) = key {
+            switch key {
+            case .unhandledPlatformKeyCode(let keyCode, let character):
                 let keyCodeString: String
                 if let keyCode {
                     keyCodeString = "\(keyCode)"
                 }else{
                     keyCodeString = "nil"
                 }
                 var characterString: String
-                if let character, character.isEmpty == false {
+                if let character{
                     switch character {
                     case "\r":
                         characterString = "\\r"
                     case "\n":
                         characterString = "\\n"
                     default:
-                        characterString = character
+                        characterString = String(character)
                     }
                 }else{
                     characterString = "nil"
                 }
                 return "unhandledPlatformKeyCode(\(keyCodeString), \(characterString))"
+            case .character(let character, _):
+                return "\(character)"
+            case .function(let index):
+                return "F\(index)"
+            case .enter(.standard):
+                return "Enter"
+            case .enter(.numberPad):
+                return "Enter(NumPad)"
+            case .alt(.leftSide):
+                return "Left Alt"
+            case .alt(.rightSide):
+                return "Right Alt"
+            case .host(.leftSide):
+                return "Left Host"
+            case .host(.rightSide):
+                return "Right Host"
+            case .control(.leftSide):
+                return "Left Control"
+            case .control(.rightSide):
+                return "Right Control"
+            case .shift(.leftSide):
+                return "Left Shift"
+            case .shift(.rightSide):
+                return "Right Shift"
+            default:
+                break
             }
+
             return "\(key)"
         }
 
@@ -140,19 +240,20 @@ extension Keyboard {
         switch event {
         case .keyDown:
             if isRepeat == false {
-                self.button(key).isPressed = true
+                self._button(key).isPressed = true
                 self.modifiers = modifiers
             }
             _ = self.updateStreams(with: key, character: character)
         case .keyUp:
-            self.button(key).isPressed = false
+            self._button(key).isPressed = false
             self.modifiers = modifiers
         case .toggle:
             if isRepeat == false {
-                if self.button(key).isPressed == false {
-                    self.button(key).isPressed = true
+                let button = self._button(key)
+                if button.isPressed == false {
+                    button.isPressed = true
                 }else{
-                    self.button(key).isPressed = false
+                    button.isPressed = false
                 }
             }
         }

Sources/GateEngine/System/HID/Keyboard/KeyboardKey.swift

@@ -55,11 +55,11 @@ public enum KeyboardKey: Hashable {
 
     public enum KeyOrigin {
         // Any part of the keyboard
-        case fromAnywhere
+        case anyVariation
         // The main keyboard area
-        case fromMain
+        case standard
         // The numeric key pad area
-        case fromNumberPad
+        case numberPad
     }
     /**
      The primary (not shift) symbol on the face of a physical key.
@@ -68,7 +68,7 @@ public enum KeyboardKey: Hashable {
      - note: `character` is in qwerty layout. If you use another layoit for devlopment you can use the following function to translate:
      ``KeyboardKey.qwerty(_,_)``, ``KeyboardKey.qwertz(_,_)``, ``KeyboardKey.azerty(_,_)``
      */
-    case character(_ character: Character, _ origin: KeyOrigin = .fromAnywhere)
+    case character(_ character: Character, _ origin: KeyOrigin = .anyVariation)
 
     /// The backspace or delete key
     case backspace
@@ -91,15 +91,15 @@ public enum KeyboardKey: Hashable {
      - parameter int: A key code represented as an Int
      - parameter string: A key represented as a String
      */
-    case unhandledPlatformKeyCode(_ int: Int?, _ string: String?)
+    case unhandledPlatformKeyCode(_ int: Int?, _ string: Character?)
 
     public enum Alignment {
         // Any key
-        case anything
+        case anyVariation
         // On the left of the space bar
-        case left
+        case leftSide
         // On the right of the space bar
-        case right
+        case rightSide
     }
     case alt(_ alignment: Alignment)
     case host(_ alignment: Alignment)
@@ -139,8 +139,8 @@ extension KeyboardKey {
      - parameter origin: The location of the key on the keyboard. `nil` means any instance of the key.
      - note: If you are solo and use qwerty, this function can be omitted as the unerlying representation is already \"qwerty\".
      */
-    @_transparent
-    public static func qwerty(_ character: Character, origin: KeyOrigin = .fromAnywhere) -> Self {
+    @inlinable @inline(__always) @_transparent
+    public static func qwerty(_ character: Character, origin: KeyOrigin = .anyVariation) -> Self {
         return .character(character, origin)
     }
 
@@ -153,7 +153,8 @@ extension KeyboardKey {
      - parameter character: The character on your keyboard, assuming your keyboard layout is \"qwertz\".
      - parameter origin: The location of the key on the keyboard. `nil` means any instance of the key.
      */
-    public static func qwertz(_ character: Character, origin: KeyOrigin = .fromAnywhere) -> Self {
+    @inlinable @inline(__always)
+    public static func qwertz(_ character: Character, origin: KeyOrigin = .anyVariation) -> Self {
         switch character {
         case "<":
             return .character("`", origin)
@@ -198,7 +199,8 @@ extension KeyboardKey {
      - parameter character: The character on your keyboard, assuming your keyboard layout is \"azerty\".
      - parameter origin: The location of the key on the keyboard. `nil` means any instance of the key.
      */
-    public static func azerty(_ character: Character, origin: KeyOrigin = .fromAnywhere) -> Self {
+    @inlinable @inline(__always)
+    public static func azerty(_ character: Character, origin: KeyOrigin = .anyVariation) -> Self {
         switch character {
         case "<":
             return .character("`", origin)