Finalized event, only the "which" stuff is missing.

Author: CodenameLambda

keyboard_event.cc

@@ -4,8 +4,7 @@
 namespace SDL {
     namespace events {
         KeyboardEvent::KeyboardEvent()
-        : KeyboardRelatedEvent(), repeat(this->underlying_event.key.repeat),
-          key_symbol(this->underlying_event.key.keysym) {
+        : KeyboardRelatedEvent(), repeat(this->underlying_event.key.repeat) {
               this->underlying_event.key.type = SDL_KEYDOWN;
               this->underlying_event.key.timestamp = 0;
               this->underlying_event.key.windowID = 0;
@@ -14,26 +13,24 @@ namespace SDL {
         }
 
         KeyboardEvent::KeyboardEvent(const SDL_Event& ev)
-        : KeyboardRelatedEvent(ev), repeat(this->underlying_event.key.repeat),
-          key_symbol(this->underlying_event.key.keysym) {
+        : KeyboardRelatedEvent(ev), repeat(this->underlying_event.key.repeat) {
         }
 
         KeyboardEvent::KeyboardEvent(SDL_Event&& ev)
-        : KeyboardRelatedEvent(ev), repeat(this->underlying_event.key.repeat),
-          key_symbol(this->underlying_event.key.keysym) {
+        : KeyboardRelatedEvent(ev), repeat(this->underlying_event.key.repeat) {
         }
 
         KeyboardEvent::KeyboardEvent(
             const unsigned char repeat,
             const bool pressed,
-            const SDL_Keysym key
+            const KeyCombination key
         ) : KeyboardEvent() {
             this->repeat = repeat;
             this->pressed(pressed);
-            this->key_symbol = key;
+            this->key(key);
         }
 
-        KeyboardEvent::KeyboardEvent(const bool pressed, const SDL_Keysym key)
+        KeyboardEvent::KeyboardEvent(const bool pressed, const KeyCombination key)
         : KeyboardEvent(0, pressed, key) {
         }
 
@@ -45,18 +42,22 @@ namespace SDL {
             this->underlying_event.key.state = value? SDL_PRESSED : SDL_RELEASED;
         }
 
-        KeyPressedEvent::KeyPressedEvent(const unsigned char repeat, const SDL_Keysym key)
+        KeyCombination KeyboardEvent::key() const {
+            return Key(this->underlying_event.key.keysym);
+        }
+
+        KeyPressedEvent::KeyPressedEvent(const unsigned char repeat, const KeyCombination key)
         : KeyboardEvent(repeat, true, key) {
         }
 
-        KeyPressedEvent::KeyPressedEvent(const SDL_Keysym key) : KeyboardEvent(true, key) {
+        KeyPressedEvent::KeyPressedEvent(const KeyCombination key) : KeyboardEvent(true, key) {
         }
 
         KeyReleasedEvent::KeyReleasedEvent() : KeyboardEvent() {
             this->pressed(false);
         }
 
-        KeyReleasedEvent::KeyReleasedEvent(const SDL_Keysym key) : KeyboardEvent(false, key) {
+        KeyReleasedEvent::KeyReleasedEvent(const KeyCombination key) : KeyboardEvent(false, key) {
         }
 
         TextEditingEvent::TextEditingEvent()

keyboard_event.hh

@@ -2,6 +2,8 @@
 #define OBJSDL_KEYBOARD_EVENT_HH
 #include "event.hh"
 
+#include "keys.hh"
+
 namespace SDL {
     namespace events {
         class KeyboardRelatedEvent : public BuiltinEvent {
@@ -11,15 +13,21 @@ namespace SDL {
         class KeyboardEvent : public KeyboardRelatedEvent {
             public:
             Uint8& repeat;
-            SDL_Keysym& key_symbol;
 
             KeyboardEvent();
             KeyboardEvent(const SDL_Event& ev);
             KeyboardEvent(SDL_Event&& ev);
-            KeyboardEvent(const unsigned char repeat, const bool pressed, const SDL_Keysym key);
-            KeyboardEvent(const bool pressed, const SDL_Keysym key);
+            KeyboardEvent(
+                const unsigned char repeat,
+                const bool pressed,
+                const KeyCombination key
+            );
+            KeyboardEvent(const bool pressed, const KeyCombination key);
             bool pressed() const;
             void pressed(const bool);
+
+            KeyCombination key() const;
+            void key(const KeyCombination);
         };
 
         class KeyPressedEvent : public KeyboardEvent {
@@ -28,11 +36,11 @@ namespace SDL {
             KeyPressedEvent(
                 const unsigned char repeat,
                 const bool pressed,
-                const SDL_Keysym key
+                const KeyCombination key
             ) = delete;
-            KeyPressedEvent(const bool pressed, const SDL_Keysym key) = delete;
-            KeyPressedEvent(const unsigned char repeat, const SDL_Keysym key);
-            KeyPressedEvent(const SDL_Keysym key);
+            KeyPressedEvent(const bool pressed, const KeyCombination key) = delete;
+            KeyPressedEvent(const unsigned char repeat, const KeyCombination key);
+            KeyPressedEvent(const KeyCombination key);
         };
 
         class KeyReleasedEvent : public KeyboardEvent {
@@ -42,10 +50,10 @@ namespace SDL {
             KeyReleasedEvent(
                 const unsigned char repeat,
                 const bool pressed,
-                const SDL_Keysym key
+                const KeyCombination key
             ) = delete;
-            KeyReleasedEvent(const bool pressed, const SDL_Keysym key) = delete;
-            KeyReleasedEvent(const SDL_Keysym key);
+            KeyReleasedEvent(const bool pressed, const KeyCombination key) = delete;
+            KeyReleasedEvent(const KeyCombination key);
         };
 
         class TextInputRelatedEvent : public KeyboardRelatedEvent {

keys.cc

@@ -0,0 +1,53 @@
+#include "keys.hh"
+
+
+namespace SDL {
+    namespace events {
+        KeyCombination::KeyCombination(const SDL_Keysym keysym) {
+            this->sdl_keysym = keysym;
+        }
+
+        KeyCombination::KeyCombination(const Uint16 modifiers, const ScanKey key) {
+            this->scan_key(key);
+            this->sdl_keysym.mod = modifiers;
+        }
+
+        KeyCombination::KeyCombination(const Uint16 modifiers, const Key key) {
+            this->key(key);
+            this->sdl_keysym.mod = modifiers;
+        }
+
+        KeyCombination::KeyCombination(const ScanKey key) : KeyCombination(0, key) {
+        }
+
+        KeyCombination::KeyCombination(const Key key) : KeyCombination(0, key) {
+        }
+
+        bool KeyCombination::modifier(const Modifier m) const {
+            return this->sdl_keysym.mod & Uint16(m);
+        }
+
+        void KeyCombination::modifier(const Modifier m, const bool value) {
+            if (this->modifier(m) != value)
+                this->sdl_keysym.mod = this->sdl_keysym.mod ^ Uint16(m);
+        }
+
+        ScanKey KeyCombination::scan_key() const {
+            return ScanKey(this->sdl_keysym.scancode);
+        }
+
+        void KeyCombination::scan_key(const ScanKey key) {
+            this->sdl_keysym.scancode = SDL_Scancode(key);
+            this->sdl_keysym.sym = SDL_GetKeyFromScancode(SDL_Scancode(key));
+        }
+
+        Key KeyCombination::key() const {
+            return Key(this->sdl_keysym.sym);
+        }
+
+        void KeyCombination::key(const Key key) {
+            this->sdl_keysym.sym = SDL_Keycode(key);
+            this->sdl_keysym.scancode = SDL_GetScancodeFromKey(SDL_Keycode(key));
+        }
+    }
+}