Fix compiler errors due to branch rebasing

* Moved some functions from sf::priv::anonymous to anonymous namespace.

include/SFML/Window/Event.hpp

@@ -61,11 +61,12 @@ public:
     ////////////////////////////////////////////////////////////
     struct KeyEvent
     {
-        Keyboard::Key code;    //!< Code of the key that has been pressed
-        bool          alt;     //!< Is the Alt key pressed?
-        bool          control; //!< Is the Control key pressed?
-        bool          shift;   //!< Is the Shift key pressed?
-        bool          system;  //!< Is the System key pressed?
+        Keyboard::Key code;          //!< Code of the key that has been pressed
+        Keyboard::Scancode scancode; //!< Physical code of the key that has been pressed
+        bool          alt;           //!< Is the Alt key pressed?
+        bool          control;       //!< Is the Control key pressed?
+        bool          shift;         //!< Is the Shift key pressed?
+        bool          system;        //!< Is the System key pressed?
     };
 
     ////////////////////////////////////////////////////////////

include/SFML/Window/Keyboard.hpp

@@ -33,6 +33,8 @@
 
 namespace sf
 {
+class String;
+
 ////////////////////////////////////////////////////////////
 /// \brief Give access to the real-time state of the keyboard
 ///
@@ -44,6 +46,10 @@ public:
     ////////////////////////////////////////////////////////////
     /// \brief Key codes
     ///
+    /// The enumerators refer to the "localized" key; i.e. depending
+    /// on the layout set by the operating system, a key can be mapped
+    /// to `Y` or `Z`.
+    ///
     ////////////////////////////////////////////////////////////
     enum Key
     {
@@ -161,6 +167,156 @@ public:
         Return    = Enter         //!< \deprecated Use Enter instead
     };
 
+    ////////////////////////////////////////////////////////////
+    /// \brief Scancodes
+    ///
+    /// The enumerators are bound to a physical key and do not depend on
+    /// the keyboard layout used by the operating system. Usually, the AT-101
+    /// keyboard can be used as reference for the physical position of the keys.
+    ///
+    /// The scancodes are based on a subset of Table 12: Keyboard/Keypad Page
+    /// of Universal Serial Bus (USB): HID Usage Tables, v1.12.
+    ///
+    /// \todo When porting this for SFML 3, remove the `Scan` prefix and use
+    ///       enum class.
+    ///
+    ////////////////////////////////////////////////////////////
+    enum Scancode
+    {
+        ScanUnknown = -1,      ///< Represents any scancode not present in this enum
+        ScanA = 0,             ///< Keyboard a and A key
+        ScanB,                 ///< Keyboard b and B key
+        ScanC,                 ///< Keyboard c and C key
+        ScanD,                 ///< Keyboard d and D key
+        ScanE,                 ///< Keyboard e and E key
+        ScanF,                 ///< Keyboard f and F key
+        ScanG,                 ///< Keyboard g and G key
+        ScanH,                 ///< Keyboard h and H key
+        ScanI,                 ///< Keyboard i and I key
+        ScanJ,                 ///< Keyboard j and J key
+        ScanK,                 ///< Keyboard k and K key
+        ScanL,                 ///< Keyboard l and L key
+        ScanM,                 ///< Keyboard m and M key
+        ScanN,                 ///< Keyboard n and N key
+        ScanO,                 ///< Keyboard o and O key
+        ScanP,                 ///< Keyboard p and P key
+        ScanQ,                 ///< Keyboard q and Q key
+        ScanR,                 ///< Keyboard r and R key
+        ScanS,                 ///< Keyboard s and S key
+        ScanT,                 ///< Keyboard t and T key
+        ScanU,                 ///< Keyboard u and U key
+        ScanV,                 ///< Keyboard v and V key
+        ScanW,                 ///< Keyboard w and W key
+        ScanX,                 ///< Keyboard x and X key
+        ScanY,                 ///< Keyboard y and Y key
+        ScanZ,                 ///< Keyboard z and Z key
+        ScanNum1,              ///< Keyboard 1 and ! key
+        ScanNum2,              ///< Keyboard 2 and @ key
+        ScanNum3,              ///< Keyboard 3 and # key
+        ScanNum4,              ///< Keyboard 4 and $ key
+        ScanNum5,              ///< Keyboard 5 and % key
+        ScanNum6,              ///< Keyboard 6 and ^ key
+        ScanNum7,              ///< Keyboard 7 and & key
+        ScanNum8,              ///< Keyboard 8 and * key
+        ScanNum9,              ///< Keyboard 9 and ) key
+        ScanNum0,              ///< Keyboard 0 and ) key
+        ScanEnter,             ///< Keyboard Enter/Return key
+        ScanEscape,            ///< Keyboard Escape key
+        ScanBackspace,         ///< Keyboard Backspace key
+        ScanTab,               ///< Keyboard Tab key
+        ScanSpace,             ///< Keyboard Space key
+        ScanHyphen,            ///< Keyboard - and _ key
+        ScanEquals,            ///< Keyboard = and +
+        ScanLBracket,          ///< Keyboard [ and { key
+        ScanRBracket,          ///< Keyboard ] and } key
+        ScanBackslash,         ///< Keyboard \ and | key
+        ScanDash,              ///< Keyboard Non-US # and ~
+        // TODO hyphen vs minus vs dash
+        ScanSemicolon,         ///< Keyboard ; and : key
+        ScanQuote,             ///< Keyboard ' and " key
+        ScanGraveAccent,       ///< Keyboard ` and ~ key
+        ScanComma,             ///< Keyboard , and < key
+        ScanPeriod,            ///< Keyboard . and > key
+        ScanSlash,             ///< Keyboard / and ? key
+        ScanF1,                ///< Keyboard F1 key
+        ScanF2,                ///< Keyboard F2 key
+        ScanF3,                ///< Keyboard F3 key
+        ScanF4,                ///< Keyboard F4 key
+        ScanF5,                ///< Keyboard F5 key
+        ScanF6,                ///< Keyboard F6 key
+        ScanF7,                ///< Keyboard F7 key
+        ScanF8,                ///< Keyboard F8 key
+        ScanF9,                ///< Keyboard F9 key
+        ScanF10,               ///< Keyboard F10 key
+        ScanF11,               ///< Keyboard F11 key
+        ScanF12,               ///< Keyboard F12 key
+        ScanF13,               ///< Keyboard F13 key
+        ScanF14,               ///< Keyboard F14 key
+        ScanF15,               ///< Keyboard F15 key
+        ScanCapsLock,          ///< Keyboard Caps Lock key
+        ScanPrintScreen,       ///< Keyboard Print Screen key
+        ScanScrollLock,        ///< Keyboard Scroll Lock key
+        ScanPause,             ///< Keyboard Pause key
+        ScanInsert,            ///< Keyboard Insert key
+        ScanHome,              ///< Keyboard Home key
+        ScanPageUp,            ///< Keyboard Page Up key
+        ScanDelete,            ///< Keyboard Delete Forward key
+        ScanEnd,               ///< Keyboard End key
+        ScanPageDown,          ///< Keyboard Page Down key
+        ScanRight,             ///< Keyboard Right Arrow key
+        ScanLeft,              ///< Keyboard Left Arrow key
+        ScanDown,              ///< Keyboard Down Arrow key
+        ScanUp,                ///< Keyboard Up Arrow key
+        ScanNumLock,           ///< Keypad Num Lock and Clear key
+        ScanDivide,            ///< Keypad / key
+        ScanMultiply,          ///< Keypad * key
+        ScanMinus,             ///< Keypad - key
+        ScanPlus,              ///< Keypad + key
+        ScanNumpadEquals,      ///< keypad = key, probably Mac only
+        ScanNumpadEnter,       ///< Keypad Enter/Return key
+        ScanDecimal,           ///< Keypad . and Delete key
+        ScanNumpad1,           ///< Keypad 1 and End key
+        ScanNumpad2,           ///< Keypad 2 and Down Arrow key
+        ScanNumpad3,           ///< Keypad 3 and Page Down key
+        ScanNumpad4,           ///< Keypad 4 and Left Arrow key
+        ScanNumpad5,           ///< Keypad 5 key
+        ScanNumpad6,           ///< Keypad 6 and Right Arrow key
+        ScanNumpad7,           ///< Keypad 7 and Home key
+        ScanNumpad8,           ///< Keypad 8 and Up Arrow key
+        ScanNumpad9,           ///< Keypad 9 and Page Up key
+        ScanNumpad0,           ///< Keypad 0 and Insert key
+        ScanReverseSolidus,    ///< Keyboard Non-US \ and | key
+        // FIXME what is this one? Might need better name. The doc says:
+        // - Typically near the Left-Shift key in AT-102 implementations.
+        // - Typical language mappings: Belg:<\> FrCa:«°» Dan:<\> Dutch:]|[ Fren:<> Ger:<|> Ital:<> LatAm:<> Nor:<> Span:<> Swed:<|> Swiss:<\> UK:\| Brazil: \|.
+        // What is the difference with "regular" \ and | key?
+        ScanApplication,       ///< Keyboard Application key
+        ScanExecute,           ///< Keyboard Execute key
+        ScanHelp,              ///< Keyboard Help key
+        ScanMenu,              ///< Keyboard Menu key
+        ScanSelect,            ///< Keyboard Select key
+        ScanStop,              ///< Keyboard Stop key
+        ScanAgain,             ///< Keyboard Again key
+        ScanUndo,              ///< Keyboard Undo key
+        ScanCut,               ///< Keyboard Cut key
+        ScanCopy,              ///< Keyboard Copy key
+        ScanPaste,             ///< Keyboard Paste key
+        ScanFind,              ///< Keyboard Find key
+        ScanMute,              ///< Keyboard Mute key
+        ScanVolumeUp,          ///< Keyboard Volume Up key
+        ScanVolumeDown,        ///< Keyboard Volume Down key
+        ScanLControl,          ///< Keyboard Left Control key
+        ScanLShift,            ///< Keyboard Left Shift key
+        ScanLAlt,              ///< Keyboard Left Alt key
+        ScanLSystem,           ///< Keyboard Left System key
+        ScanRControl,          ///< Keyboard Right Control key
+        ScanRShift,            ///< Keyboard Right Shift key
+        ScanRAlt,              ///< Keyboard Right Alt key
+        ScanRSystem,           ///< Keyboard Right System key
+
+        ScanCodeCount          ///< Keep last -- the total number of scancodes
+    };
+
     ////////////////////////////////////////////////////////////
     /// \brief Check if a key is pressed
     ///
@@ -171,12 +327,73 @@ public:
     ////////////////////////////////////////////////////////////
     static bool isKeyPressed(Key key);
 
+    ////////////////////////////////////////////////////////////
+    /// \brief Check if a key is pressed
+    ///
+    /// \param code Scancode to check
+    ///
+    /// \return True if the physical key is pressed, false otherwise
+    ///
+    ////////////////////////////////////////////////////////////
+    static bool isKeyPressed(Scancode code);
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Localize a physical key to a logical one
+    ///
+    /// \param code Scancode to localize
+    ///
+    /// \return The key corresponding to the scancode under the current
+    ///         keyboard layout used by the operating system, or
+    ///         sf::Keyboard::Unknown when the scancode cannot be mapped
+    ///         to a Key.
+    ///
+    /// \see unlocalize
+    ///
+    ////////////////////////////////////////////////////////////
+    static Key localize(Scancode code);
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Identify the physical key corresponding to a logical one
+    ///
+    /// \param key Key to "unlocalize"
+    ///
+    /// \return The scancode corresponding to the key under the current
+    ///         keyboard layout used by the operating system, or
+    ///         sf::Keyboard::ScanUnknown when the key cannot be mapped
+    ///         to a Keyboard::Scancode.
+    ///
+    /// \see localize
+    ///
+    ////////////////////////////////////////////////////////////
+    static Scancode unlocalize(Key key);
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Provide a string representation for a given scancode
+    ///
+    /// From a high level point of view, this conversion corresponds
+    /// somewhat to the string available through sf::Event::TextEvent
+    /// when the given physical key is pressed by the user, when no
+    /// modifiers are involved.
+    ///
+    /// \warning The result is OS-dependent: for example, sf::Keyboard::ScanLSystem
+    ///          is "Left Meta" on Linux, "Left Windows" on Windows and
+    ///          "Left Command" on macOS.
+    ///
+    /// The current keyboard layout set by the operating system is used to
+    /// interpret the scancode: for example, sf::Keyboard::Semicolon is
+    /// mapped to ";" for layout and to "é" for others.
+    ///
+    /// \return The localized description of the code
+    ///
+    ////////////////////////////////////////////////////////////
+    static String getDescription(Scancode code);
+
     ////////////////////////////////////////////////////////////
     /// \brief Show or hide the virtual keyboard
     ///
-    /// Warning: the virtual keyboard is not supported on all
-    /// systems. It will typically be implemented on mobile OSes
-    /// (Android, iOS) but not on desktop OSes (Windows, Linux, ...).
+    /// \warning The virtual keyboard is not supported on all
+    ///          systems. It will typically be implemented on mobile OSes
+    ///          (Android, iOS) but not on desktop OSes (Windows, Linux, ...).
     ///
     /// If the virtual keyboard is not available, this function does
     /// nothing.

src/SFML/Window/Android/InputImpl.hpp

@@ -45,19 +45,37 @@ class InputImpl
 public:
 
     ////////////////////////////////////////////////////////////
-    /// \brief Check if a key is pressed
-    ///
-    /// \param key Key to check
-    ///
-    /// \return True if the key is pressed, false otherwise
+    /// \copydoc sf::Keyboard::isKeyPressed(Key)
     ///
     ////////////////////////////////////////////////////////////
     static bool isKeyPressed(Keyboard::Key key);
 
     ////////////////////////////////////////////////////////////
-    /// \brief Show or hide the virtual keyboard
+    /// \copydoc sf::Keyboard::isKeyPressed(Scancode)
     ///
-    /// \param visible True to show, false to hide
+    ////////////////////////////////////////////////////////////
+    static bool isKeyPressed(Keyboard::Scancode code);
+
+    ////////////////////////////////////////////////////////////
+    /// \copydoc sf::Keyboard::localize
+    ///
+    ////////////////////////////////////////////////////////////
+    static Keyboard::Key localize(Keyboard::Scancode code);
+
+    ////////////////////////////////////////////////////////////
+    /// \copydoc sf::Keyboard::unlocalize
+    ///
+    ////////////////////////////////////////////////////////////
+    static Keyboard::Scancode unlocalize(Keyboard::Key key);
+
+    ////////////////////////////////////////////////////////////
+    /// \copydoc sf::Keyboard::localizedRepresentation
+    ///
+    ////////////////////////////////////////////////////////////
+    static String getDescription(Keyboard::Scancode code);
+
+    ////////////////////////////////////////////////////////////
+    /// \copydoc sf::Keyboard::setVirtualKeyboardVisible
     ///
     ////////////////////////////////////////////////////////////
     static void setVirtualKeyboardVisible(bool visible);

src/SFML/Window/CMakeLists.txt

@@ -91,6 +91,12 @@ elseif(SFML_OS_LINUX OR SFML_OS_FREEBSD OR SFML_OS_OPENBSD)
         ${SRCROOT}/Unix/Display.hpp
         ${SRCROOT}/Unix/InputImpl.cpp
         ${SRCROOT}/Unix/InputImpl.hpp
+        ${SRCROOT}/Unix/KeyboardImpl.hpp
+        ${SRCROOT}/Unix/KeyboardImpl.cpp
+        ${SRCROOT}/Unix/KeySymToKeyMapping.hpp
+        ${SRCROOT}/Unix/KeySymToKeyMapping.cpp
+        ${SRCROOT}/Unix/KeySymToUnicodeMapping.hpp
+        ${SRCROOT}/Unix/KeySymToUnicodeMapping.cpp
         ${SRCROOT}/Unix/SensorImpl.cpp
         ${SRCROOT}/Unix/SensorImpl.hpp
         ${SRCROOT}/Unix/VideoModeImpl.cpp

src/SFML/Window/Keyboard.cpp

@@ -27,6 +27,7 @@
 ////////////////////////////////////////////////////////////
 #include <SFML/Window/Keyboard.hpp>
 #include <SFML/Window/InputImpl.hpp>
+#include <SFML/System/String.hpp>
 
 
 namespace sf
@@ -37,6 +38,29 @@ bool Keyboard::isKeyPressed(Key key)
     return priv::InputImpl::isKeyPressed(key);
 }
 
+////////////////////////////////////////////////////////////
+bool Keyboard::isKeyPressed(Scancode code)
+{
+    return priv::InputImpl::isKeyPressed(code);
+}
+
+////////////////////////////////////////////////////////////
+Keyboard::Key Keyboard::localize(Scancode code)
+{
+    return priv::InputImpl::localize(code);
+}
+
+////////////////////////////////////////////////////////////
+Keyboard::Scancode Keyboard::unlocalize(Key key)
+{
+    return priv::InputImpl::unlocalize(key);
+}
+
+////////////////////////////////////////////////////////////
+String Keyboard::getDescription(Scancode code)
+{
+    return priv::InputImpl::getDescription(code);
+}
 
 ////////////////////////////////////////////////////////////
 void Keyboard::setVirtualKeyboardVisible(bool visible)

src/SFML/Window/OSX/HIDInputManager.hpp

@@ -65,16 +65,6 @@ public:
     ////////////////////////////////////////////////////////////
     static HIDInputManager& getInstance();
 
-    ////////////////////////////////////////////////////////////
-    /// \brief Check if a key is pressed
-    ///
-    /// \param key Key to check
-    ///
-    /// \return True if the key is pressed, false otherwise
-    ///
-    ////////////////////////////////////////////////////////////
-    bool isKeyPressed(Keyboard::Key key);
-
 public:
 
     ////////////////////////////////////////////////////////////
@@ -103,21 +93,64 @@ public:
     ///
     /// Return sf::Keyboard::Unknown if it doesn't match any 'localized' keys.
     ///
-    /// By 'localized' I mean keys that depend on the keyboard layout
-    /// and might not be the same as the US keycode in some country
-    /// (e.g. the keys 'Y' and 'Z' are switched on QWERTZ keyboard and
+    /// By 'localized' we mean keys that depend on the keyboard layout
+    /// and might not be the same as the US keycode for some countries
+    /// (e.g. the keys 'Y' and 'Z' are swapped on QWERTZ keyboard and
     /// US keyboard layouts.)
     ///
     ////////////////////////////////////////////////////////////
-    static Keyboard::Key localizedKeys(UniChar ch);
+    static Keyboard::Key localizedKey(UniChar ch);
 
     ////////////////////////////////////////////////////////////
-    /// Try to convert a virtual keycode into a SFML key code.
+    /// Opposite transformation as localizedKeys
     ///
-    /// Return sf::Keyboard::Unknown if the keycode is unknown.
+    /// Return 0x00 (NULL) for non-convertible keys/numpad numbers.
+    /// For letters, uppercase codes are returned.
+    /// Some returned value are specific to macOS.
     ///
     ////////////////////////////////////////////////////////////
-    static Keyboard::Key nonLocalizedKeys(UniChar virtualKeycode);
+    static UniChar toUnicode(Keyboard::Key key);
+
+    ////////////////////////////////////////////////////////////
+    /// Try to convert a virtual keycode (HID level) into a
+    /// SFML scancode.
+    ///
+    /// Return sf::Keyboard::ScanUnknown if the keycode is unknown.
+    ///
+    ////////////////////////////////////////////////////////////
+    static Keyboard::Scancode nonLocalizedKey(UniChar virtualKeycode);
+
+public:
+
+    ////////////////////////////////////////////////////////////
+    /// \copydoc sf::Keyboard::isKeyPressed(Key)
+    ///
+    ////////////////////////////////////////////////////////////
+    bool isKeyPressed(Keyboard::Key key);
+
+    ////////////////////////////////////////////////////////////
+    /// \copydoc sf::Keyboard::isKeyPressed(Scancode)
+    ///
+    ////////////////////////////////////////////////////////////
+    bool isKeyPressed(Keyboard::Scancode code);
+
+    ////////////////////////////////////////////////////////////
+    /// \copydoc sf::Keyboard::localize
+    ///
+    ////////////////////////////////////////////////////////////
+    Keyboard::Key localize(Keyboard::Scancode code);
+
+    ////////////////////////////////////////////////////////////
+    /// \copydoc sf::Keyboard::unlocalize
+    ///
+    ////////////////////////////////////////////////////////////
+    Keyboard::Scancode unlocalize(Keyboard::Key key);
+
+    ////////////////////////////////////////////////////////////
+    /// \copydoc sf::Keyboard::localizedRepresentation
+    ///
+    ////////////////////////////////////////////////////////////
+    String localizedRepresentation(Keyboard::Scancode code);
 
 private:
 
@@ -136,7 +169,13 @@ private:
     ////////////////////////////////////////////////////////////
     /// \brief Initialize the keyboard part of this class
     ///
-    /// If something went wrong freeUp is called
+    /// If something went wrong freeUp is called.
+    ///
+    /// In a nutshell, this function does this:
+    ///
+    ///     for each connected keyboard kb:
+    ///       for each key k of kb:
+    ///         memorise k -> scancode mapping
     ///
     ////////////////////////////////////////////////////////////
     void initializeKeyboard();
@@ -145,28 +184,44 @@ private:
     /// \brief Load the given keyboard into m_keys
     ///
     /// If the given keyboard has no key this function simply
-    /// returns. freeUp is _not_ called because this is not fatal.
+    /// returns without calling freeUp because this is not fatal.
     ///
     /// \param keyboard Keyboard to load
     ///
+    /// \see initializeKeyboard
+    ///
     ////////////////////////////////////////////////////////////
     void loadKeyboard(IOHIDDeviceRef keyboard);
 
     ////////////////////////////////////////////////////////////
     /// \brief Load the given key into m_keys
     ///
-    /// freeUp is _not_ called by this function.
+    /// On error, freeUp is _not_ called by this function.
     ///
     /// \param key Key to load
     ///
+    /// \see initializeKeyboard
+    ///
     ////////////////////////////////////////////////////////////
     void loadKey(IOHIDElementRef key);
 
+    ////////////////////////////////////////////////////////////
+    /// Regenerate the mappings from/to Key and Scancode.
+    ///
+    /// It is public to allow regular callback to forward the
+    /// information to the manager.
+    ///
+    ////////////////////////////////////////////////////////////
+public:
+    void buildMappings();
+private:
+
     ////////////////////////////////////////////////////////////
     /// \brief Release all resources
     ///
-    /// Close all connections to any devices, if required
-    /// Set m_isValid to false
+    /// Close all connections to any devices.
+    ///
+    /// \see initializeKeyboard
     ///
     ////////////////////////////////////////////////////////////
     void freeUp();
@@ -174,11 +229,11 @@ private:
     ////////////////////////////////////////////////////////////
     /// \brief Filter the devices and return them
     ///
-    /// freeUp is _not_ called by this function.
+    /// On error, freeUp is _not_ called by this function.
     ///
     /// \param page  HID page like kHIDPage_GenericDesktop
     /// \param usage HID usage page like kHIDUsage_GD_Keyboard or kHIDUsage_GD_Mouse
-    /// \return a retained CFSetRef of IOHIDDeviceRef or NULL
+    /// \return a retained, non-emtpy CFSetRef of IOHIDDeviceRef or NULL
     ///
     ////////////////////////////////////////////////////////////
     CFSetRef copyDevices(UInt32 page, UInt32 usage);
@@ -196,36 +251,48 @@ private:
     bool isPressed(IOHIDElements& elements);
 
     ////////////////////////////////////////////////////////////
-    /// \brief Convert a HID key usage to its corresponding virtual code
-    ///
-    /// See IOHIDUsageTables.h
+    /// \brief Convert a HID key usage to its corresponding scancode
     ///
     /// \param usage Any kHIDUsage_Keyboard* usage
-    /// \return the virtual code associate with the given HID key usage
-    ///         or 0xff if it is associate with no virtual code
+    /// \return the scancode associate with the given HID key usage
+    ///         or sUnknown if it is associate with no scancode.
     ///
     ////////////////////////////////////////////////////////////
-    static UInt8 usageToVirtualCode(UInt32 usage);
+    static Keyboard::Scancode usageToScancode(UInt32 usage);
+
+    ////////////////////////////////////////////////////////////
+    /// Convert the scancode to the expected virtual code.
+    ///
+    ////////////////////////////////////////////////////////////
+    static UInt8 scanToVirtualCode(Keyboard::Scancode code);
+
+    ////////////////////////////////////////////////////////////
+    /// Fallback convertion for key that aren't expected to be impacted
+    /// by the layout. Can return Unknown.
+    ///
+    ////////////////////////////////////////////////////////////
+    static Keyboard::Key localizedKeyFallback(Keyboard::Scancode code);
 
 private:
 
     ////////////////////////////////////////////////////////////
     // Member data
     ////////////////////////////////////////////////////////////
-    bool              m_isValid;                    ///< If any error occurs this variable is false
-    CFDataRef         m_layoutData;                 ///< CFData containing the layout
-    UCKeyboardLayout* m_layout;                     ///< Current Keyboard Layout
-    IOHIDManagerRef   m_manager;                    ///< HID Manager
-
-    IOHIDElements     m_keys[Keyboard::KeyCount];   ///< All the keys on any connected keyboard
+    IOHIDManagerRef    m_manager;                                       ///< Underlying HID Manager
+    IOHIDElements      m_keys[Keyboard::ScanCodeCount];                 ///< All the keys on any connected keyboard
+    Keyboard::Scancode m_keyToScancodeMapping[Keyboard::KeyCount];      ///< Mapping from Key to Scancode
+    Keyboard::Key      m_scancodeToKeyMapping[Keyboard::ScanCodeCount]; ///< Mapping from Scancode to Key
 
     ////////////////////////////////////////////////////////////
-    /// m_keys' index corresponds to sf::Keyboard::Key enum.
-    /// if no key is assigned with key XYZ then m_keys[XYZ].size() == 0.
-    /// if there are several keyboards connected and several HID keys associate
+    /// m_keys' index corresponds to sf::Keyboard::Scancode enum.
+    /// If no key is assigned with key XYZ then m_keys[XYZ].size() == 0.
+    /// If there are several keyboards connected and several HID keys associated
     /// with the same sf::Keyboard::Key then m_keys[XYZ] contains all these
     /// HID keys.
     ///
+    /// The mappings (both directions) get invalidated when the
+    /// keyboard layout changes. They both default to (s)Unknown.
+    ///
     ////////////////////////////////////////////////////////////
 };
 

src/SFML/Window/OSX/InputImpl.hpp

@@ -46,19 +46,37 @@ class InputImpl
 public:
 
     ////////////////////////////////////////////////////////////
-    /// \brief Check if a key is pressed
-    ///
-    /// \param key Key to check
-    ///
-    /// \return True if the key is pressed, false otherwise
+    /// \copydoc sf::Keyboard::isKeyPressed(Key)
     ///
     ////////////////////////////////////////////////////////////
     static bool isKeyPressed(Keyboard::Key key);
 
     ////////////////////////////////////////////////////////////
-    /// \brief Show or hide the virtual keyboard
+    /// \copydoc sf::Keyboard::isKeyPressed(Scancode)
     ///
-    /// \param visible True to show, false to hide
+    ////////////////////////////////////////////////////////////
+    static bool isKeyPressed(Keyboard::Scancode code);
+
+    ////////////////////////////////////////////////////////////
+    /// \copydoc sf::Keyboard::localize
+    ///
+    ////////////////////////////////////////////////////////////
+    static Keyboard::Key localize(Keyboard::Scancode code);
+
+    ////////////////////////////////////////////////////////////
+    /// \copydoc sf::Keyboard::unlocalize
+    ///
+    ////////////////////////////////////////////////////////////
+    static Keyboard::Scancode unlocalize(Keyboard::Key key);
+
+    ////////////////////////////////////////////////////////////
+    /// \copydoc sf::Keyboard::localizedRepresentation
+    ///
+    ////////////////////////////////////////////////////////////
+    static String getDescription(Keyboard::Scancode code);
+
+    ////////////////////////////////////////////////////////////
+    /// \copydoc sf::Keyboard::setVirtualKeyboardVisible
     ///
     ////////////////////////////////////////////////////////////
     static void setVirtualKeyboardVisible(bool visible);

src/SFML/Window/OSX/InputImpl.mm

@@ -39,9 +39,6 @@
 /// In order to keep track of the keyboard's state and mouse buttons' state
 /// we use the HID manager. Mouse position is handled differently.
 ///
-/// NB: we probably could use
-/// NSEvent +addGlobalMonitorForEventsMatchingMask:handler: for mouse only.
-///
 ////////////////////////////////////////////////////////////
 
 namespace sf
@@ -122,6 +119,7 @@ SFOpenGLView* getSFOpenGLViewFromSFMLWindow(const WindowBase& window)
     return view;
 }
 
+
 ////////////////////////////////////////////////////////////
 bool InputImpl::isKeyPressed(Keyboard::Key key)
 {
@@ -129,6 +127,34 @@ bool InputImpl::isKeyPressed(Keyboard::Key key)
 }
 
 
+////////////////////////////////////////////////////////////
+bool InputImpl::isKeyPressed(Keyboard::Scancode code)
+{
+    return HIDInputManager::getInstance().isKeyPressed(code);
+}
+
+
+////////////////////////////////////////////////////////////
+Keyboard::Key InputImpl::localize(Keyboard::Scancode code)
+{
+    return HIDInputManager::getInstance().localize(code);
+}
+
+
+////////////////////////////////////////////////////////////
+Keyboard::Scancode InputImpl::unlocalize(Keyboard::Key key)
+{
+    return HIDInputManager::getInstance().unlocalize(key);
+}
+
+
+////////////////////////////////////////////////////////////
+String InputImpl::getDescription(Keyboard::Scancode code)
+{
+    return HIDInputManager::getInstance().localizedRepresentation(code);
+}
+
+
 ////////////////////////////////////////////////////////////
 void InputImpl::setVirtualKeyboardVisible(bool /*visible*/)
 {

src/SFML/Window/OSX/SFKeyboardModifiersHelper.h

@@ -56,7 +56,8 @@ void initialiseKeyboardHelper(void);
 /// \brief Set up a SFML key event based on the given modifiers flags and key code
 ///
 ////////////////////////////////////////////////////////////
-sf::Event::KeyEvent keyEventWithModifiers(NSUInteger modifiers, sf::Keyboard::Key key);
+sf::Event::KeyEvent keyEventWithModifiers(NSUInteger modifiers, sf::Keyboard::Key key,
+                                          sf::Keyboard::Scancode code);
 
 
 ////////////////////////////////////////////////////////////

src/SFML/Window/OSX/SFKeyboardModifiersHelper.mm

@@ -92,6 +92,7 @@ BOOL isKeyMaskActive(NSUInteger modifiers, NSUInteger mask);
 ////////////////////////////////////////////////////////////
 void processOneModifier(NSUInteger modifiers, NSUInteger mask,
                         BOOL& wasDown, sf::Keyboard::Key key,
+                        sf::Keyboard::Scancode code,
                         sf::priv::WindowImplCocoa& requester);
 
 
@@ -105,6 +106,7 @@ void processLeftRightModifiers(NSUInteger modifiers,
                                NSUInteger leftMask, NSUInteger rightMask,
                                BOOL& leftWasDown, BOOL& rightWasDown,
                                sf::Keyboard::Key leftKey, sf::Keyboard::Key rightKey,
+                               sf::Keyboard::Scancode leftCode, sf::Keyboard::Scancode rightCode,
                                sf::priv::WindowImplCocoa& requester);
 
 
@@ -136,14 +138,15 @@ void initialiseKeyboardHelper(void)
 
 
 ////////////////////////////////////////////////////////
-sf::Event::KeyEvent keyEventWithModifiers(NSUInteger modifiers, sf::Keyboard::Key key)
+sf::Event::KeyEvent keyEventWithModifiers(NSUInteger modifiers, sf::Keyboard::Key key, sf::Keyboard::Scancode code)
 {
     sf::Event::KeyEvent event;
-    event.code    = key;
-    event.alt     = modifiers & NSAlternateKeyMask;
-    event.control = modifiers & NSControlKeyMask;
-    event.shift   = modifiers & NSShiftKeyMask;
-    event.system  = modifiers & NSCommandKeyMask;
+    event.code     = key;
+    event.scancode = code;
+    event.alt      = modifiers & NSAlternateKeyMask;
+    event.control  = modifiers & NSControlKeyMask;
+    event.shift    = modifiers & NSShiftKeyMask;
+    event.system   = modifiers & NSCommandKeyMask;
 
     return event;
 }
@@ -158,6 +161,7 @@ void handleModifiersChanged(NSUInteger modifiers, sf::priv::WindowImplCocoa& req
         NSLeftShiftKeyMask, NSRightShiftKeyMask,
         state.leftShiftWasDown, state.rightShiftWasDown,
         sf::Keyboard::LShift, sf::Keyboard::RShift,
+        sf::Keyboard::ScanLShift, sf::Keyboard::ScanRShift,
         requester
     );
 
@@ -167,6 +171,7 @@ void handleModifiersChanged(NSUInteger modifiers, sf::priv::WindowImplCocoa& req
         NSLeftCommandKeyMask, NSRightCommandKeyMask,
         state.leftCommandWasDown, state.rightCommandWasDown,
         sf::Keyboard::LSystem, sf::Keyboard::RSystem,
+        sf::Keyboard::ScanLSystem, sf::Keyboard::ScanRSystem,
         requester
     );
 
@@ -176,6 +181,7 @@ void handleModifiersChanged(NSUInteger modifiers, sf::priv::WindowImplCocoa& req
         NSLeftAlternateKeyMask, NSRightAlternateKeyMask,
         state.leftAlternateWasDown, state.rightAlternateWasDown,
         sf::Keyboard::LAlt, sf::Keyboard::RAlt,
+        sf::Keyboard::ScanLAlt, sf::Keyboard::ScanRAlt,
         requester
     );
 
@@ -185,6 +191,7 @@ void handleModifiersChanged(NSUInteger modifiers, sf::priv::WindowImplCocoa& req
         NSLeftControlKeyMask, NSRightControlKeyMask,
         state.leftControlWasDown, state.rightControlWasDown,
         sf::Keyboard::LControl, sf::Keyboard::RControl,
+        sf::Keyboard::ScanLControl, sf::Keyboard::ScanRControl,
         requester
     );
 }
@@ -203,10 +210,11 @@ BOOL isKeyMaskActive(NSUInteger modifiers, NSUInteger mask)
 ////////////////////////////////////////////////////////
 void processOneModifier(NSUInteger modifiers, NSUInteger mask,
                         BOOL& wasDown, sf::Keyboard::Key key,
+                        sf::Keyboard::Scancode code,
                         sf::priv::WindowImplCocoa& requester)
 {
     // Setup a potential event key.
-    sf::Event::KeyEvent event = keyEventWithModifiers(modifiers, key);
+    sf::Event::KeyEvent event = keyEventWithModifiers(modifiers, key, code);
 
     // State
     BOOL isDown = isKeyMaskActive(modifiers, mask);
@@ -231,10 +239,11 @@ void processLeftRightModifiers(NSUInteger modifiers,
                                NSUInteger leftMask, NSUInteger rightMask,
                                BOOL& leftWasDown, BOOL& rightWasDown,
                                sf::Keyboard::Key leftKey, sf::Keyboard::Key rightKey,
+                               sf::Keyboard::Scancode leftCode, sf::Keyboard::Scancode rightCode,
                                sf::priv::WindowImplCocoa& requester)
 {
-    processOneModifier(modifiers, leftMask,  leftWasDown,  leftKey,  requester);
-    processOneModifier(modifiers, rightMask, rightWasDown, rightKey, requester);
+    processOneModifier(modifiers, leftMask,  leftWasDown,  leftKey,  leftCode,  requester);
+    processOneModifier(modifiers, rightMask, rightWasDown, rightKey, rightCode, requester);
 }
 
 

src/SFML/Window/OSX/SFOpenGLView+keyboard.mm

@@ -86,7 +86,7 @@
     {
         sf::Event::KeyEvent key = [SFOpenGLView convertNSKeyEventToSFMLEvent:theEvent];
 
-        if (key.code != sf::Keyboard::Unknown) // The key is recognized.
+        if ((key.code != sf::Keyboard::Unknown) || (key.scancode != sf::Keyboard::ScanUnknown))
             m_requester->keyDown(key);
     }
 
@@ -180,21 +180,17 @@
 ////////////////////////////////////////////////////////
 +(sf::Event::KeyEvent)convertNSKeyEventToSFMLEvent:(NSEvent*)event
 {
-    // Key code
-    sf::Keyboard::Key key = sf::Keyboard::Unknown;
-
-    // First we look if the key down is from a list of characters
-    // that depend on keyboard localization.
+    // We look for the key in a list of characters that depend on keyboard localization,
+    // if the key is not "dead".
     NSString* string = [event charactersIgnoringModifiers];
-    if ([string length] > 0)
-        key = sf::priv::HIDInputManager::localizedKeys([string characterAtIndex:0]);
+    sf::Keyboard::Key key = ([string length] > 0)
+        ? sf::priv::HIDInputManager::localizedKey([string characterAtIndex:0])
+        : sf::Keyboard::Unknown;
 
-    // If the key is not a localized one, we try to find a corresponding code
-    // through virtual key code.
-    if (key == sf::Keyboard::Unknown)
-        key = sf::priv::HIDInputManager::nonLocalizedKeys([event keyCode]);
+    // The scancode always depends on the hardware keyboard, not some OS setting.
+    sf::Keyboard::Scancode code = sf::priv::HIDInputManager::nonLocalizedKey([event keyCode]);
 
-    return keyEventWithModifiers([event modifierFlags], key);
+    return keyEventWithModifiers([event modifierFlags], key, code);
 }
 
 

src/SFML/Window/Unix/InputImpl.cpp

@@ -28,11 +28,11 @@
 #include <SFML/Window/Window.hpp> // important to be included first (conflict with None)
 #include <SFML/Window/Unix/InputImpl.hpp>
 #include <SFML/Window/Unix/Display.hpp>
+#include <SFML/Window/Unix/KeyboardImpl.hpp>
 #include <SFML/System/Err.hpp>
 #include <X11/Xlib.h>
 #include <X11/keysym.h>
 
-
 namespace sf
 {
 namespace priv
@@ -40,142 +40,35 @@ namespace priv
 ////////////////////////////////////////////////////////////
 bool InputImpl::isKeyPressed(Keyboard::Key key)
 {
-    // Get the corresponding X11 keysym
-    KeySym keysym = 0;
-    switch (key)
-    {
-        case Keyboard::LShift:     keysym = XK_Shift_L;      break;
-        case Keyboard::RShift:     keysym = XK_Shift_R;      break;
-        case Keyboard::LControl:   keysym = XK_Control_L;    break;
-        case Keyboard::RControl:   keysym = XK_Control_R;    break;
-        case Keyboard::LAlt:       keysym = XK_Alt_L;        break;
-        case Keyboard::RAlt:       keysym = XK_Alt_R;        break;
-        case Keyboard::LSystem:    keysym = XK_Super_L;      break;
-        case Keyboard::RSystem:    keysym = XK_Super_R;      break;
-        case Keyboard::Menu:       keysym = XK_Menu;         break;
-        case Keyboard::Escape:     keysym = XK_Escape;       break;
-        case Keyboard::Semicolon:  keysym = XK_semicolon;    break;
-        case Keyboard::Slash:      keysym = XK_slash;        break;
-        case Keyboard::Equal:      keysym = XK_equal;        break;
-        case Keyboard::Hyphen:     keysym = XK_minus;        break;
-        case Keyboard::LBracket:   keysym = XK_bracketleft;  break;
-        case Keyboard::RBracket:   keysym = XK_bracketright; break;
-        case Keyboard::Comma:      keysym = XK_comma;        break;
-        case Keyboard::Period:     keysym = XK_period;       break;
-        case Keyboard::Quote:      keysym = XK_apostrophe;   break;
-        case Keyboard::Backslash:  keysym = XK_backslash;    break;
-        case Keyboard::Tilde:      keysym = XK_grave;        break;
-        case Keyboard::Space:      keysym = XK_space;        break;
-        case Keyboard::Enter:      keysym = XK_Return;       break;
-        case Keyboard::Backspace:  keysym = XK_BackSpace;    break;
-        case Keyboard::Tab:        keysym = XK_Tab;          break;
-        case Keyboard::PageUp:     keysym = XK_Prior;        break;
-        case Keyboard::PageDown:   keysym = XK_Next;         break;
-        case Keyboard::End:        keysym = XK_End;          break;
-        case Keyboard::Home:       keysym = XK_Home;         break;
-        case Keyboard::Insert:     keysym = XK_Insert;       break;
-        case Keyboard::Delete:     keysym = XK_Delete;       break;
-        case Keyboard::Add:        keysym = XK_KP_Add;       break;
-        case Keyboard::Subtract:   keysym = XK_KP_Subtract;  break;
-        case Keyboard::Multiply:   keysym = XK_KP_Multiply;  break;
-        case Keyboard::Divide:     keysym = XK_KP_Divide;    break;
-        case Keyboard::Pause:      keysym = XK_Pause;        break;
-        case Keyboard::F1:         keysym = XK_F1;           break;
-        case Keyboard::F2:         keysym = XK_F2;           break;
-        case Keyboard::F3:         keysym = XK_F3;           break;
-        case Keyboard::F4:         keysym = XK_F4;           break;
-        case Keyboard::F5:         keysym = XK_F5;           break;
-        case Keyboard::F6:         keysym = XK_F6;           break;
-        case Keyboard::F7:         keysym = XK_F7;           break;
-        case Keyboard::F8:         keysym = XK_F8;           break;
-        case Keyboard::F9:         keysym = XK_F9;           break;
-        case Keyboard::F10:        keysym = XK_F10;          break;
-        case Keyboard::F11:        keysym = XK_F11;          break;
-        case Keyboard::F12:        keysym = XK_F12;          break;
-        case Keyboard::F13:        keysym = XK_F13;          break;
-        case Keyboard::F14:        keysym = XK_F14;          break;
-        case Keyboard::F15:        keysym = XK_F15;          break;
-        case Keyboard::Left:       keysym = XK_Left;         break;
-        case Keyboard::Right:      keysym = XK_Right;        break;
-        case Keyboard::Up:         keysym = XK_Up;           break;
-        case Keyboard::Down:       keysym = XK_Down;         break;
-        case Keyboard::Numpad0:    keysym = XK_KP_Insert;    break;
-        case Keyboard::Numpad1:    keysym = XK_KP_End;       break;
-        case Keyboard::Numpad2:    keysym = XK_KP_Down;      break;
-        case Keyboard::Numpad3:    keysym = XK_KP_Page_Down; break;
-        case Keyboard::Numpad4:    keysym = XK_KP_Left;      break;
-        case Keyboard::Numpad5:    keysym = XK_KP_Begin;     break;
-        case Keyboard::Numpad6:    keysym = XK_KP_Right;     break;
-        case Keyboard::Numpad7:    keysym = XK_KP_Home;      break;
-        case Keyboard::Numpad8:    keysym = XK_KP_Up;        break;
-        case Keyboard::Numpad9:    keysym = XK_KP_Page_Up;   break;
-        case Keyboard::A:          keysym = XK_a;            break;
-        case Keyboard::B:          keysym = XK_b;            break;
-        case Keyboard::C:          keysym = XK_c;            break;
-        case Keyboard::D:          keysym = XK_d;            break;
-        case Keyboard::E:          keysym = XK_e;            break;
-        case Keyboard::F:          keysym = XK_f;            break;
-        case Keyboard::G:          keysym = XK_g;            break;
-        case Keyboard::H:          keysym = XK_h;            break;
-        case Keyboard::I:          keysym = XK_i;            break;
-        case Keyboard::J:          keysym = XK_j;            break;
-        case Keyboard::K:          keysym = XK_k;            break;
-        case Keyboard::L:          keysym = XK_l;            break;
-        case Keyboard::M:          keysym = XK_m;            break;
-        case Keyboard::N:          keysym = XK_n;            break;
-        case Keyboard::O:          keysym = XK_o;            break;
-        case Keyboard::P:          keysym = XK_p;            break;
-        case Keyboard::Q:          keysym = XK_q;            break;
-        case Keyboard::R:          keysym = XK_r;            break;
-        case Keyboard::S:          keysym = XK_s;            break;
-        case Keyboard::T:          keysym = XK_t;            break;
-        case Keyboard::U:          keysym = XK_u;            break;
-        case Keyboard::V:          keysym = XK_v;            break;
-        case Keyboard::W:          keysym = XK_w;            break;
-        case Keyboard::X:          keysym = XK_x;            break;
-        case Keyboard::Y:          keysym = XK_y;            break;
-        case Keyboard::Z:          keysym = XK_z;            break;
-        case Keyboard::Num0:       keysym = XK_0;            break;
-        case Keyboard::Num1:       keysym = XK_1;            break;
-        case Keyboard::Num2:       keysym = XK_2;            break;
-        case Keyboard::Num3:       keysym = XK_3;            break;
-        case Keyboard::Num4:       keysym = XK_4;            break;
-        case Keyboard::Num5:       keysym = XK_5;            break;
-        case Keyboard::Num6:       keysym = XK_6;            break;
-        case Keyboard::Num7:       keysym = XK_7;            break;
-        case Keyboard::Num8:       keysym = XK_8;            break;
-        case Keyboard::Num9:       keysym = XK_9;            break;
-        default:                   keysym = 0;               break;
-    }
+    return KeyboardImpl::isKeyPressed(key);
+}
 
-    // Sanity checks
-    if (key < 0 || key >= sf::Keyboard::KeyCount)
-        return false;
 
-    // Open a connection with the X server
-    Display* display = OpenDisplay();
+////////////////////////////////////////////////////////////
+bool InputImpl::isKeyPressed(Keyboard::Scancode code)
+{
+    return KeyboardImpl::isKeyPressed(code);
+}
 
-    // Convert to keycode
-    KeyCode keycode = XKeysymToKeycode(display, keysym);
-    if (keycode != 0)
-    {
-        // Get the whole keyboard state
-        char keys[32];
-        XQueryKeymap(display, keys);
 
-        // Close the connection with the X server
-        CloseDisplay(display);
+////////////////////////////////////////////////////////////
+Keyboard::Key InputImpl::localize(Keyboard::Scancode code)
+{
+    return KeyboardImpl::localize(code);
+}
 
-        // Check our keycode
-        return (keys[keycode / 8] & (1 << (keycode % 8))) != 0;
-    }
-    else
-    {
-        // Close the connection with the X server
-        CloseDisplay(display);
 
-        return false;
-    }
+////////////////////////////////////////////////////////////
+Keyboard::Scancode InputImpl::unlocalize(Keyboard::Key key)
+{
+    return KeyboardImpl::unlocalize(key);
+}
+
+
+////////////////////////////////////////////////////////////
+String InputImpl::getDescription(Keyboard::Scancode code)
+{
+    return KeyboardImpl::getDescription(code);
 }
 
 

src/SFML/Window/Unix/InputImpl.hpp

@@ -45,19 +45,37 @@ class InputImpl
 public:
 
     ////////////////////////////////////////////////////////////
-    /// \brief Check if a key is pressed
-    ///
-    /// \param key Key to check
-    ///
-    /// \return True if the key is pressed, false otherwise
+    /// \copydoc sf::Keyboard::isKeyPressed(Key)
     ///
     ////////////////////////////////////////////////////////////
     static bool isKeyPressed(Keyboard::Key key);
 
     ////////////////////////////////////////////////////////////
-    /// \brief Show or hide the virtual keyboard
+    /// \copydoc sf::Keyboard::isKeyPressed(Scancode)
     ///
-    /// \param visible True to show, false to hide
+    ////////////////////////////////////////////////////////////
+    static bool isKeyPressed(Keyboard::Scancode code);
+
+    ////////////////////////////////////////////////////////////
+    /// \copydoc sf::Keyboard::localize
+    ///
+    ////////////////////////////////////////////////////////////
+    static Keyboard::Key localize(Keyboard::Scancode code);
+
+    ////////////////////////////////////////////////////////////
+    /// \copydoc sf::Keyboard::unlocalize
+    ///
+    ////////////////////////////////////////////////////////////
+    static Keyboard::Scancode unlocalize(Keyboard::Key key);
+
+    ////////////////////////////////////////////////////////////
+    /// \copydoc sf::Keyboard::localizedRepresentation
+    ///
+    ////////////////////////////////////////////////////////////
+    static String getDescription(Keyboard::Scancode code);
+
+    ////////////////////////////////////////////////////////////
+    /// \copydoc sf::Keyboard::setVirtualKeyboardVisible
     ///
     ////////////////////////////////////////////////////////////
     static void setVirtualKeyboardVisible(bool visible);

src/SFML/Window/Unix/KeySymToKeyMapping.cpp

@@ -0,0 +1,261 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
+//
+// This software is provided 'as-is', without any express or implied warranty.
+// In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it freely,
+// subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented;
+//    you must not claim that you wrote the original software.
+//    If you use this software in a product, an acknowledgment
+//    in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such,
+//    and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+//
+////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <SFML/Window/Unix/KeySymToKeyMapping.hpp>
+#include <X11/keysym.h>
+
+namespace sf
+{
+namespace priv
+{
+
+////////////////////////////////////////////////////////////
+Keyboard::Key keySymToKey(KeySym symbol)
+{
+    switch (symbol)
+    {
+        case XK_Shift_L:      return Keyboard::LShift;
+        case XK_Shift_R:      return Keyboard::RShift;
+        case XK_Control_L:    return Keyboard::LControl;
+        case XK_Control_R:    return Keyboard::RControl;
+        case XK_Alt_L:        return Keyboard::LAlt;
+        case XK_Alt_R:        return Keyboard::RAlt;
+        case XK_Super_L:      return Keyboard::LSystem;
+        case XK_Super_R:      return Keyboard::RSystem;
+        case XK_Menu:         return Keyboard::Menu;
+        case XK_Escape:       return Keyboard::Escape;
+        case XK_semicolon:    return Keyboard::SemiColon;
+        case XK_slash:        return Keyboard::Slash;
+        case XK_equal:        return Keyboard::Equal;
+        case XK_minus:        return Keyboard::Dash;
+        case XK_bracketleft:  return Keyboard::LBracket;
+        case XK_bracketright: return Keyboard::RBracket;
+        case XK_comma:        return Keyboard::Comma;
+        case XK_period:       return Keyboard::Period;
+        case XK_apostrophe:   return Keyboard::Quote;
+        case XK_backslash:    return Keyboard::BackSlash;
+        case XK_grave:        return Keyboard::Tilde;
+        case XK_space:        return Keyboard::Space;
+        case XK_Return:       return Keyboard::Return;
+        case XK_KP_Enter:     return Keyboard::Return;
+        case XK_BackSpace:    return Keyboard::BackSpace;
+        case XK_Tab:          return Keyboard::Tab;
+        case XK_Prior:        return Keyboard::PageUp;
+        case XK_Next:         return Keyboard::PageDown;
+        case XK_End:          return Keyboard::End;
+        case XK_Home:         return Keyboard::Home;
+        case XK_Insert:       return Keyboard::Insert;
+        case XK_Delete:       return Keyboard::Delete;
+        case XK_KP_Add:       return Keyboard::Add;
+        case XK_KP_Subtract:  return Keyboard::Subtract;
+        case XK_KP_Multiply:  return Keyboard::Multiply;
+        case XK_KP_Divide:    return Keyboard::Divide;
+        case XK_Pause:        return Keyboard::Pause;
+        case XK_F1:           return Keyboard::F1;
+        case XK_F2:           return Keyboard::F2;
+        case XK_F3:           return Keyboard::F3;
+        case XK_F4:           return Keyboard::F4;
+        case XK_F5:           return Keyboard::F5;
+        case XK_F6:           return Keyboard::F6;
+        case XK_F7:           return Keyboard::F7;
+        case XK_F8:           return Keyboard::F8;
+        case XK_F9:           return Keyboard::F9;
+        case XK_F10:          return Keyboard::F10;
+        case XK_F11:          return Keyboard::F11;
+        case XK_F12:          return Keyboard::F12;
+        case XK_F13:          return Keyboard::F13;
+        case XK_F14:          return Keyboard::F14;
+        case XK_F15:          return Keyboard::F15;
+        case XK_Left:         return Keyboard::Left;
+        case XK_Right:        return Keyboard::Right;
+        case XK_Up:           return Keyboard::Up;
+        case XK_Down:         return Keyboard::Down;
+        case XK_KP_Insert:    return Keyboard::Numpad0;
+        case XK_KP_End:       return Keyboard::Numpad1;
+        case XK_KP_Down:      return Keyboard::Numpad2;
+        case XK_KP_Page_Down: return Keyboard::Numpad3;
+        case XK_KP_Left:      return Keyboard::Numpad4;
+        case XK_KP_Begin:     return Keyboard::Numpad5;
+        case XK_KP_Right:     return Keyboard::Numpad6;
+        case XK_KP_Home:      return Keyboard::Numpad7;
+        case XK_KP_Up:        return Keyboard::Numpad8;
+        case XK_KP_Page_Up:   return Keyboard::Numpad9;
+        case XK_a:            return Keyboard::A;
+        case XK_b:            return Keyboard::B;
+        case XK_c:            return Keyboard::C;
+        case XK_d:            return Keyboard::D;
+        case XK_e:            return Keyboard::E;
+        case XK_f:            return Keyboard::F;
+        case XK_g:            return Keyboard::G;
+        case XK_h:            return Keyboard::H;
+        case XK_i:            return Keyboard::I;
+        case XK_j:            return Keyboard::J;
+        case XK_k:            return Keyboard::K;
+        case XK_l:            return Keyboard::L;
+        case XK_m:            return Keyboard::M;
+        case XK_n:            return Keyboard::N;
+        case XK_o:            return Keyboard::O;
+        case XK_p:            return Keyboard::P;
+        case XK_q:            return Keyboard::Q;
+        case XK_r:            return Keyboard::R;
+        case XK_s:            return Keyboard::S;
+        case XK_t:            return Keyboard::T;
+        case XK_u:            return Keyboard::U;
+        case XK_v:            return Keyboard::V;
+        case XK_w:            return Keyboard::W;
+        case XK_x:            return Keyboard::X;
+        case XK_y:            return Keyboard::Y;
+        case XK_z:            return Keyboard::Z;
+        case XK_0:            return Keyboard::Num0;
+        case XK_1:            return Keyboard::Num1;
+        case XK_2:            return Keyboard::Num2;
+        case XK_3:            return Keyboard::Num3;
+        case XK_4:            return Keyboard::Num4;
+        case XK_5:            return Keyboard::Num5;
+        case XK_6:            return Keyboard::Num6;
+        case XK_7:            return Keyboard::Num7;
+        case XK_8:            return Keyboard::Num8;
+        case XK_9:            return Keyboard::Num9;
+        default:              return Keyboard::Unknown;
+    }
+}
+
+
+////////////////////////////////////////////////////////////
+KeySym keyToKeySym(Keyboard::Key key)
+{
+    switch (key)
+    {
+        case Keyboard::LShift:     return XK_Shift_L;
+        case Keyboard::RShift:     return XK_Shift_R;
+        case Keyboard::LControl:   return XK_Control_L;
+        case Keyboard::RControl:   return XK_Control_R;
+        case Keyboard::LAlt:       return XK_Alt_L;
+        case Keyboard::RAlt:       return XK_Alt_R;
+        case Keyboard::LSystem:    return XK_Super_L;
+        case Keyboard::RSystem:    return XK_Super_R;
+        case Keyboard::Menu:       return XK_Menu;
+        case Keyboard::Escape:     return XK_Escape;
+        case Keyboard::SemiColon:  return XK_semicolon;
+        case Keyboard::Slash:      return XK_slash;
+        case Keyboard::Equal:      return XK_equal;
+        case Keyboard::Dash:       return XK_minus;
+        case Keyboard::LBracket:   return XK_bracketleft;
+        case Keyboard::RBracket:   return XK_bracketright;
+        case Keyboard::Comma:      return XK_comma;
+        case Keyboard::Period:     return XK_period;
+        case Keyboard::Quote:      return XK_apostrophe;
+        case Keyboard::BackSlash:  return XK_backslash;
+        case Keyboard::Tilde:      return XK_grave;
+        case Keyboard::Space:      return XK_space;
+        case Keyboard::Return:     return XK_Return;
+        case Keyboard::BackSpace:  return XK_BackSpace;
+        case Keyboard::Tab:        return XK_Tab;
+        case Keyboard::PageUp:     return XK_Prior;
+        case Keyboard::PageDown:   return XK_Next;
+        case Keyboard::End:        return XK_End;
+        case Keyboard::Home:       return XK_Home;
+        case Keyboard::Insert:     return XK_Insert;
+        case Keyboard::Delete:     return XK_Delete;
+        case Keyboard::Add:        return XK_KP_Add;
+        case Keyboard::Subtract:   return XK_KP_Subtract;
+        case Keyboard::Multiply:   return XK_KP_Multiply;
+        case Keyboard::Divide:     return XK_KP_Divide;
+        case Keyboard::Pause:      return XK_Pause;
+        case Keyboard::F1:         return XK_F1;
+        case Keyboard::F2:         return XK_F2;
+        case Keyboard::F3:         return XK_F3;
+        case Keyboard::F4:         return XK_F4;
+        case Keyboard::F5:         return XK_F5;
+        case Keyboard::F6:         return XK_F6;
+        case Keyboard::F7:         return XK_F7;
+        case Keyboard::F8:         return XK_F8;
+        case Keyboard::F9:         return XK_F9;
+        case Keyboard::F10:        return XK_F10;
+        case Keyboard::F11:        return XK_F11;
+        case Keyboard::F12:        return XK_F12;
+        case Keyboard::F13:        return XK_F13;
+        case Keyboard::F14:        return XK_F14;
+        case Keyboard::F15:        return XK_F15;
+        case Keyboard::Left:       return XK_Left;
+        case Keyboard::Right:      return XK_Right;
+        case Keyboard::Up:         return XK_Up;
+        case Keyboard::Down:       return XK_Down;
+        case Keyboard::Numpad0:    return XK_KP_Insert;
+        case Keyboard::Numpad1:    return XK_KP_End;
+        case Keyboard::Numpad2:    return XK_KP_Down;
+        case Keyboard::Numpad3:    return XK_KP_Page_Down;
+        case Keyboard::Numpad4:    return XK_KP_Left;
+        case Keyboard::Numpad5:    return XK_KP_Begin;
+        case Keyboard::Numpad6:    return XK_KP_Right;
+        case Keyboard::Numpad7:    return XK_KP_Home;
+        case Keyboard::Numpad8:    return XK_KP_Up;
+        case Keyboard::Numpad9:    return XK_KP_Page_Up;
+        case Keyboard::A:          return XK_a;
+        case Keyboard::B:          return XK_b;
+        case Keyboard::C:          return XK_c;
+        case Keyboard::D:          return XK_d;
+        case Keyboard::E:          return XK_e;
+        case Keyboard::F:          return XK_f;
+        case Keyboard::G:          return XK_g;
+        case Keyboard::H:          return XK_h;
+        case Keyboard::I:          return XK_i;
+        case Keyboard::J:          return XK_j;
+        case Keyboard::K:          return XK_k;
+        case Keyboard::L:          return XK_l;
+        case Keyboard::M:          return XK_m;
+        case Keyboard::N:          return XK_n;
+        case Keyboard::O:          return XK_o;
+        case Keyboard::P:          return XK_p;
+        case Keyboard::Q:          return XK_q;
+        case Keyboard::R:          return XK_r;
+        case Keyboard::S:          return XK_s;
+        case Keyboard::T:          return XK_t;
+        case Keyboard::U:          return XK_u;
+        case Keyboard::V:          return XK_v;
+        case Keyboard::W:          return XK_w;
+        case Keyboard::X:          return XK_x;
+        case Keyboard::Y:          return XK_y;
+        case Keyboard::Z:          return XK_z;
+        case Keyboard::Num0:       return XK_0;
+        case Keyboard::Num1:       return XK_1;
+        case Keyboard::Num2:       return XK_2;
+        case Keyboard::Num3:       return XK_3;
+        case Keyboard::Num4:       return XK_4;
+        case Keyboard::Num5:       return XK_5;
+        case Keyboard::Num6:       return XK_6;
+        case Keyboard::Num7:       return XK_7;
+        case Keyboard::Num8:       return XK_8;
+        case Keyboard::Num9:       return XK_9;
+        default:                   return NoSymbol;
+    }
+}
+
+} // namespace priv
+
+} // namespace sf
+

src/SFML/Window/Unix/KeySymToKeyMapping.hpp

@@ -0,0 +1,63 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
+//
+// This software is provided 'as-is', without any express or implied warranty.
+// In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it freely,
+// subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented;
+//    you must not claim that you wrote the original software.
+//    If you use this software in a product, an acknowledgment
+//    in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such,
+//    and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+//
+////////////////////////////////////////////////////////////
+
+#ifndef SFML_KEYSYMTOKEYMAPPING_HPP
+#define SFML_KEYSYMTOKEYMAPPING_HPP
+
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <SFML/Window/Keyboard.hpp> // sf::Keyboard::Key
+#include <X11/X.h> // KeySym
+
+namespace sf
+{
+namespace priv
+{
+////////////////////////////////////////////////////////////
+/// \brief Convert X11 KeySym to sf::Keyboard::Key
+///
+/// \param symbol X11 KeySym
+///
+/// \return The corresponding sf::Keyboard::Key
+///
+////////////////////////////////////////////////////////////
+Keyboard::Key keySymToKey(KeySym symbol);
+
+
+////////////////////////////////////////////////////////////
+/// \brief Convert sf::Keyboard::Key to X11 KeySym
+///
+/// \param key X11 sf::Keyboard::Key
+///
+/// \return The corresponding X11 KeySym
+///
+////////////////////////////////////////////////////////////
+KeySym keyToKeySym(Keyboard::Key key);
+
+} // namespace priv
+
+} // namespace sf
+
+#endif // SFML_KEYSYMTOKEYMAPPING_HPP

src/SFML/Window/Unix/KeySymToUnicodeMapping.hpp

@@ -0,0 +1,56 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
+//
+// This software is provided 'as-is', without any express or implied warranty.
+// In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it freely,
+// subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented;
+//    you must not claim that you wrote the original software.
+//    If you use this software in a product, an acknowledgment
+//    in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such,
+//    and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+//
+////////////////////////////////////////////////////////////
+
+#ifndef SFML_KEYSYMTOUNICODEMAPPING_HPP
+#define SFML_KEYSYMTOUNICODEMAPPING_HPP
+
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <SFML/Config.hpp> // sf::Uint32
+#include <X11/X.h> // KeySym
+
+namespace sf
+{
+namespace priv
+{
+
+////////////////////////////////////////////////////////////
+/// \brief Converts a KeySym to UTF-32
+///
+/// This code was autogenerated from the following table:
+/// https://www.cl.cam.ac.uk/~mgk25/ucs/keysyms.txt
+///
+/// \param keysym keysym to be converted
+///
+/// \return corresponding UTF-32
+///
+////////////////////////////////////////////////////////////
+Uint32 keysymToUnicode(KeySym keysym);
+
+} // namespace priv
+
+} // namespace sf
+
+#endif // SFML_KEYSYMTOUNICODEMAPPING_HPP

src/SFML/Window/Unix/KeyboardImpl.cpp

@@ -0,0 +1,586 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
+//
+// This software is provided 'as-is', without any express or implied warranty.
+// In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it freely,
+// subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented;
+//    you must not claim that you wrote the original software.
+//    If you use this software in a product, an acknowledgment
+//    in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such,
+//    and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+//
+////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <SFML/Window/Unix/KeyboardImpl.hpp>
+#include <SFML/Window/Unix/Display.hpp>
+#include <SFML/Window/Unix/KeySymToKeyMapping.hpp>
+#include <SFML/Window/Unix/KeySymToUnicodeMapping.hpp>
+#include <SFML/System/String.hpp>
+#include <SFML/System/Utf.hpp>
+#include <X11/keysym.h>
+#include <X11/Xlib.h>
+#include <X11/XKBlib.h>
+#include <cstring> // strcmp
+
+namespace
+{
+
+const KeyCode NullKeyCode = 0;
+KeyCode scancodeToKeycode[sf::Keyboard::ScanCodeCount]; ///< Mapping of SFML scancode to X11 KeyCode
+sf::Keyboard::Scancode keycodeToScancode[256];          ///< Mapping of X11 KeyCode to SFML scancode
+bool isMappingInitialized = false;
+
+////////////////////////////////////////////////////////////
+bool isValidKeycode(KeyCode keycode)
+{
+    // Valid key code range is [8,255], according to the Xlib manual
+    return (keycode >= 8) || (keycode <= 255);
+}
+
+
+////////////////////////////////////////////////////////////
+sf::Keyboard::Scancode translateKeyCode(Display* display, KeyCode keycode)
+{
+    if (!isValidKeycode(keycode))
+        return sf::Keyboard::ScanUnknown;
+
+    // Try secondary keysym, for numeric keypad keys
+    // Note: This way we always force "NumLock = ON", which is intentional
+    // since the returned key code should correspond to a physical
+    // location.
+    KeySym keySym = XkbKeycodeToKeysym(display, keycode, 0, 1);
+
+    switch (keySym)
+    {
+        case XK_KP_0:             return sf::Keyboard::ScanNumpad0;
+        case XK_KP_1:             return sf::Keyboard::ScanNumpad1;
+        case XK_KP_2:             return sf::Keyboard::ScanNumpad2;
+        case XK_KP_3:             return sf::Keyboard::ScanNumpad3;
+        case XK_KP_4:             return sf::Keyboard::ScanNumpad4;
+        case XK_KP_5:             return sf::Keyboard::ScanNumpad5;
+        case XK_KP_6:             return sf::Keyboard::ScanNumpad6;
+        case XK_KP_7:             return sf::Keyboard::ScanNumpad7;
+        case XK_KP_8:             return sf::Keyboard::ScanNumpad8;
+        case XK_KP_9:             return sf::Keyboard::ScanNumpad9;
+        case XK_KP_Separator:     return sf::Keyboard::ScanDecimal;
+        case XK_KP_Decimal:       return sf::Keyboard::ScanDecimal;
+        case XK_KP_Equal:         return sf::Keyboard::ScanNumpadEquals;
+        case XK_KP_Enter:         return sf::Keyboard::ScanNumpadEnter;
+        default:                  break;
+    }
+
+    // Now try primary keysym for function keys (non-printable keys)
+    // These should not depend on the current keyboard layout
+    keySym = XkbKeycodeToKeysym(display, keycode, 0, 0);
+
+    switch (keySym)
+    {
+        case XK_Escape:           return sf::Keyboard::ScanEscape;
+        case XK_Tab:              return sf::Keyboard::ScanTab;
+        case XK_Shift_L:          return sf::Keyboard::ScanLShift;
+        case XK_Shift_R:          return sf::Keyboard::ScanRShift;
+        case XK_Control_L:        return sf::Keyboard::ScanLControl;
+        case XK_Control_R:        return sf::Keyboard::ScanRControl;
+        case XK_Meta_L:           return sf::Keyboard::ScanLAlt;
+        case XK_Alt_L:            return sf::Keyboard::ScanLAlt;
+        case XK_Mode_switch:      return sf::Keyboard::ScanRAlt; // Mapped to Alt_R on many keyboards
+        case XK_ISO_Level3_Shift: return sf::Keyboard::ScanRAlt; // AltGr on at least some machines
+        case XK_Meta_R:           return sf::Keyboard::ScanRAlt;
+        case XK_Alt_R:            return sf::Keyboard::ScanRAlt;
+        case XK_Super_L:          return sf::Keyboard::ScanLSystem;
+        case XK_Super_R:          return sf::Keyboard::ScanRSystem;
+        case XK_Menu:             return sf::Keyboard::ScanMenu;
+        case XK_Num_Lock:         return sf::Keyboard::ScanNumLock;
+        case XK_Caps_Lock:        return sf::Keyboard::ScanCapsLock;
+        case XK_Print:            return sf::Keyboard::ScanPrintScreen;
+        case XK_Scroll_Lock:      return sf::Keyboard::ScanScrollLock;
+        case XK_Pause:            return sf::Keyboard::ScanPause;
+        case XK_Delete:           return sf::Keyboard::ScanDelete;
+        case XK_BackSpace:        return sf::Keyboard::ScanBackspace;
+        case XK_Return:           return sf::Keyboard::ScanEnter;
+        case XK_Home:             return sf::Keyboard::ScanHome;
+        case XK_End:              return sf::Keyboard::ScanEnd;
+        case XK_Page_Up:          return sf::Keyboard::ScanPageUp;
+        case XK_Page_Down:        return sf::Keyboard::ScanPageDown;
+        case XK_Insert:           return sf::Keyboard::ScanInsert;
+        case XK_Left:             return sf::Keyboard::ScanLeft;
+        case XK_Right:            return sf::Keyboard::ScanRight;
+        case XK_Down:             return sf::Keyboard::ScanDown;
+        case XK_Up:               return sf::Keyboard::ScanUp;
+        case XK_F1:               return sf::Keyboard::ScanF1;
+        case XK_F2:               return sf::Keyboard::ScanF2;
+        case XK_F3:               return sf::Keyboard::ScanF3;
+        case XK_F4:               return sf::Keyboard::ScanF4;
+        case XK_F5:               return sf::Keyboard::ScanF5;
+        case XK_F6:               return sf::Keyboard::ScanF6;
+        case XK_F7:               return sf::Keyboard::ScanF7;
+        case XK_F8:               return sf::Keyboard::ScanF8;
+        case XK_F9:               return sf::Keyboard::ScanF9;
+        case XK_F10:              return sf::Keyboard::ScanF10;
+        case XK_F11:              return sf::Keyboard::ScanF11;
+        case XK_F12:              return sf::Keyboard::ScanF12;
+        case XK_F13:              return sf::Keyboard::ScanF13;
+        case XK_F14:              return sf::Keyboard::ScanF14;
+        case XK_F15:              return sf::Keyboard::ScanF15;
+        // TODO: add scancodes for F16-F25 when they're added in Scancode enum
+
+        // Numeric keypad
+        case XK_KP_Divide:        return sf::Keyboard::ScanDivide;
+        case XK_KP_Multiply:      return sf::Keyboard::ScanMultiply;
+        case XK_KP_Subtract:      return sf::Keyboard::ScanMinus;
+        case XK_KP_Add:           return sf::Keyboard::ScanPlus;
+
+        // These should have been detected in secondary keysym test above!
+        case XK_KP_Insert:        return sf::Keyboard::ScanNumpad0;
+        case XK_KP_End:           return sf::Keyboard::ScanNumpad1;
+        case XK_KP_Down:          return sf::Keyboard::ScanNumpad2;
+        case XK_KP_Page_Down:     return sf::Keyboard::ScanNumpad3;
+        case XK_KP_Left:          return sf::Keyboard::ScanNumpad4;
+        case XK_KP_Right:         return sf::Keyboard::ScanNumpad6;
+        case XK_KP_Home:          return sf::Keyboard::ScanNumpad7;
+        case XK_KP_Up:            return sf::Keyboard::ScanNumpad8;
+        case XK_KP_Page_Up:       return sf::Keyboard::ScanNumpad9;
+        case XK_KP_Delete:        return sf::Keyboard::ScanDecimal;
+        case XK_KP_Equal:         return sf::Keyboard::ScanNumpadEquals;
+        case XK_KP_Enter:         return sf::Keyboard::ScanNumpadEnter;
+
+        // Last resort: Check for printable keys (should not happen if the XKB
+        // extension is available). This will give a layout dependent mapping
+        // (which is wrong, and we may miss some keys, especially on non-US
+        // keyboards), but it's better than nothing...
+        case XK_a:                return sf::Keyboard::ScanA;
+        case XK_b:                return sf::Keyboard::ScanB;
+        case XK_c:                return sf::Keyboard::ScanC;
+        case XK_d:                return sf::Keyboard::ScanD;
+        case XK_e:                return sf::Keyboard::ScanE;
+        case XK_f:                return sf::Keyboard::ScanF;
+        case XK_g:                return sf::Keyboard::ScanG;
+        case XK_h:                return sf::Keyboard::ScanH;
+        case XK_i:                return sf::Keyboard::ScanI;
+        case XK_j:                return sf::Keyboard::ScanJ;
+        case XK_k:                return sf::Keyboard::ScanK;
+        case XK_l:                return sf::Keyboard::ScanL;
+        case XK_m:                return sf::Keyboard::ScanM;
+        case XK_n:                return sf::Keyboard::ScanN;
+        case XK_o:                return sf::Keyboard::ScanO;
+        case XK_p:                return sf::Keyboard::ScanP;
+        case XK_q:                return sf::Keyboard::ScanQ;
+        case XK_r:                return sf::Keyboard::ScanR;
+        case XK_s:                return sf::Keyboard::ScanS;
+        case XK_t:                return sf::Keyboard::ScanT;
+        case XK_u:                return sf::Keyboard::ScanU;
+        case XK_v:                return sf::Keyboard::ScanV;
+        case XK_w:                return sf::Keyboard::ScanW;
+        case XK_x:                return sf::Keyboard::ScanX;
+        case XK_y:                return sf::Keyboard::ScanY;
+        case XK_z:                return sf::Keyboard::ScanZ;
+        case XK_1:                return sf::Keyboard::ScanNum1;
+        case XK_2:                return sf::Keyboard::ScanNum2;
+        case XK_3:                return sf::Keyboard::ScanNum3;
+        case XK_4:                return sf::Keyboard::ScanNum4;
+        case XK_5:                return sf::Keyboard::ScanNum5;
+        case XK_6:                return sf::Keyboard::ScanNum6;
+        case XK_7:                return sf::Keyboard::ScanNum7;
+        case XK_8:                return sf::Keyboard::ScanNum8;
+        case XK_9:                return sf::Keyboard::ScanNum9;
+        case XK_0:                return sf::Keyboard::ScanNum0;
+        case XK_space:            return sf::Keyboard::ScanSpace;
+        case XK_minus:            return sf::Keyboard::ScanHyphen;
+        case XK_equal:            return sf::Keyboard::ScanEquals;
+        case XK_bracketleft:      return sf::Keyboard::ScanLBracket;
+        case XK_bracketright:     return sf::Keyboard::ScanRBracket;
+        case XK_backslash:        return sf::Keyboard::ScanBackslash;
+        case XK_semicolon:        return sf::Keyboard::ScanSemicolon;
+        case XK_apostrophe:       return sf::Keyboard::ScanQuote;
+        case XK_grave:            return sf::Keyboard::ScanGraveAccent;
+        case XK_comma:            return sf::Keyboard::ScanComma;
+        case XK_period:           return sf::Keyboard::ScanPeriod;
+        case XK_slash:            return sf::Keyboard::ScanSlash;
+        case XK_less:             return sf::Keyboard::ScanReverseSolidus;
+        default:                  return sf::Keyboard::ScanUnknown;
+    }
+}
+
+
+////////////////////////////////////////////////////////////
+void initMapping()
+{
+    for (int i = 0; i < 256; ++i)
+        scancodeToKeycode[i] = NullKeyCode;
+
+    for (int i = 0; i < sf::Keyboard::ScanCodeCount; ++i)
+        keycodeToScancode[i] = sf::Keyboard::ScanUnknown;
+
+    Display* display = sf::priv::OpenDisplay();
+
+    // Find the X11 key code -> SFML key code mapping
+    // This code was inspired by GLFW implementation
+
+    char name[XkbKeyNameLength + 1];
+    XkbDescPtr desc = XkbGetMap(display, 0, XkbUseCoreKbd);
+    XkbGetNames(display, XkbKeyNamesMask, desc);
+
+    sf::Keyboard::Scancode sc;
+
+    for (int keycode = desc->min_key_code; keycode <= desc->max_key_code; ++keycode)
+    {
+        std::memcpy(name, desc->names->keys[keycode].name, XkbKeyNameLength);
+        name[XkbKeyNameLength] = '\0';
+
+        if      (strcmp(name, "TLDE") == 0) sc = sf::Keyboard::ScanGraveAccent;
+        else if (strcmp(name, "AE01") == 0) sc = sf::Keyboard::ScanNum1;
+        else if (strcmp(name, "AE02") == 0) sc = sf::Keyboard::ScanNum2;
+        else if (strcmp(name, "AE03") == 0) sc = sf::Keyboard::ScanNum3;
+        else if (strcmp(name, "AE04") == 0) sc = sf::Keyboard::ScanNum4;
+        else if (strcmp(name, "AE05") == 0) sc = sf::Keyboard::ScanNum5;
+        else if (strcmp(name, "AE06") == 0) sc = sf::Keyboard::ScanNum6;
+        else if (strcmp(name, "AE07") == 0) sc = sf::Keyboard::ScanNum7;
+        else if (strcmp(name, "AE08") == 0) sc = sf::Keyboard::ScanNum8;
+        else if (strcmp(name, "AE09") == 0) sc = sf::Keyboard::ScanNum9;
+        else if (strcmp(name, "AE10") == 0) sc = sf::Keyboard::ScanNum0;
+        else if (strcmp(name, "AE11") == 0) sc = sf::Keyboard::ScanDash;
+        else if (strcmp(name, "AE12") == 0) sc = sf::Keyboard::ScanEquals;
+        else if (strcmp(name, "TAB" ) == 0) sc = sf::Keyboard::ScanTab;
+        else if (strcmp(name, "AD01") == 0) sc = sf::Keyboard::ScanQ;
+        else if (strcmp(name, "AD02") == 0) sc = sf::Keyboard::ScanW;
+        else if (strcmp(name, "AD03") == 0) sc = sf::Keyboard::ScanE;
+        else if (strcmp(name, "AD04") == 0) sc = sf::Keyboard::ScanR;
+        else if (strcmp(name, "AD05") == 0) sc = sf::Keyboard::ScanT;
+        else if (strcmp(name, "AD06") == 0) sc = sf::Keyboard::ScanY;
+        else if (strcmp(name, "AD07") == 0) sc = sf::Keyboard::ScanU;
+        else if (strcmp(name, "AD08") == 0) sc = sf::Keyboard::ScanI;
+        else if (strcmp(name, "AD09") == 0) sc = sf::Keyboard::ScanO;
+        else if (strcmp(name, "AD10") == 0) sc = sf::Keyboard::ScanP;
+        else if (strcmp(name, "AD11") == 0) sc = sf::Keyboard::ScanLBracket;
+        else if (strcmp(name, "AD12") == 0) sc = sf::Keyboard::ScanRBracket;
+        else if (strcmp(name, "BKSL") == 0) sc = sf::Keyboard::ScanBackslash;
+        else if (strcmp(name, "AC01") == 0) sc = sf::Keyboard::ScanA;
+        else if (strcmp(name, "AC02") == 0) sc = sf::Keyboard::ScanS;
+        else if (strcmp(name, "AC03") == 0) sc = sf::Keyboard::ScanD;
+        else if (strcmp(name, "AC04") == 0) sc = sf::Keyboard::ScanF;
+        else if (strcmp(name, "AC05") == 0) sc = sf::Keyboard::ScanG;
+        else if (strcmp(name, "AC06") == 0) sc = sf::Keyboard::ScanH;
+        else if (strcmp(name, "AC07") == 0) sc = sf::Keyboard::ScanJ;
+        else if (strcmp(name, "AC08") == 0) sc = sf::Keyboard::ScanK;
+        else if (strcmp(name, "AC09") == 0) sc = sf::Keyboard::ScanL;
+        else if (strcmp(name, "AC10") == 0) sc = sf::Keyboard::ScanSemicolon;
+        else if (strcmp(name, "AC11") == 0) sc = sf::Keyboard::ScanQuote;
+        else if (strcmp(name, "AB01") == 0) sc = sf::Keyboard::ScanZ;
+        else if (strcmp(name, "AB02") == 0) sc = sf::Keyboard::ScanX;
+        else if (strcmp(name, "AB03") == 0) sc = sf::Keyboard::ScanC;
+        else if (strcmp(name, "AB04") == 0) sc = sf::Keyboard::ScanV;
+        else if (strcmp(name, "AB05") == 0) sc = sf::Keyboard::ScanB;
+        else if (strcmp(name, "AB06") == 0) sc = sf::Keyboard::ScanN;
+        else if (strcmp(name, "AB07") == 0) sc = sf::Keyboard::ScanM;
+        else if (strcmp(name, "AB08") == 0) sc = sf::Keyboard::ScanComma;
+        else if (strcmp(name, "AB09") == 0) sc = sf::Keyboard::ScanPeriod;
+        else if (strcmp(name, "AB10") == 0) sc = sf::Keyboard::ScanSlash;
+        else if (strcmp(name, "LSGT") == 0) sc = sf::Keyboard::ScanReverseSolidus;
+        else                                sc = sf::Keyboard::ScanUnknown;
+
+        if (isValidKeycode(keycode))
+        {
+            scancodeToKeycode[sc] = keycode;
+            keycodeToScancode[keycode] = sc;
+        }
+    }
+
+    XkbFreeNames(desc, XkbKeyNamesMask, True);
+    XkbFreeKeyboard(desc, 0, True);
+
+    // Translate un-translated keycodes using traditional X11 KeySym lookups
+    // Valid keycodes are [8;255], so we only initialize them
+    for (int keycode = 8; keycode < 256; ++keycode)
+    {
+        if (keycodeToScancode[keycode] == sf::Keyboard::ScanUnknown)
+        {
+            sf::Keyboard::Scancode sc = translateKeyCode(display, keycode);
+            scancodeToKeycode[sc] = keycode;
+            keycodeToScancode[keycode] = sc;
+        }
+    }
+
+    sf::priv::CloseDisplay(display);
+
+    isMappingInitialized = true;
+}
+
+
+////////////////////////////////////////////////////////////
+KeyCode scancodeToKeyCode(sf::Keyboard::Scancode code)
+{
+    if (!isMappingInitialized)
+        initMapping();
+
+    return scancodeToKeycode[code];
+}
+
+
+////////////////////////////////////////////////////////////
+sf::Keyboard::Scancode keyCodeToScancode(KeyCode code)
+{
+    if (!isMappingInitialized)
+        initMapping();
+
+    if (isValidKeycode(code))
+        return keycodeToScancode[code];
+
+    return sf::Keyboard::ScanUnknown;
+}
+
+
+////////////////////////////////////////////////////////////
+KeyCode keyToKeyCode(sf::Keyboard::Key key)
+{
+    KeySym keysym = sf::priv::keyToKeySym(key);
+
+    if (keysym != NoSymbol)
+    {
+        Display* display = sf::priv::OpenDisplay();
+        KeyCode keycode = XKeysymToKeycode(display, keysym);
+        sf::priv::CloseDisplay(display);
+        return keycode;
+    }
+
+    return NullKeyCode;
+}
+
+
+////////////////////////////////////////////////////////////
+KeySym scancodeToKeySym(sf::Keyboard::Scancode code)
+{
+    Display* display = sf::priv::OpenDisplay();
+
+    KeySym keysym = NoSymbol;
+    KeyCode keycode = scancodeToKeyCode(code);
+
+    if (keycode != NullKeyCode) // ensure that this Scancode is mapped to keycode
+        keysym = XkbKeycodeToKeysym(display, keycode, 0, 0);
+
+    sf::priv::CloseDisplay(display);
+
+    return keysym;
+}
+
+
+////////////////////////////////////////////////////////////
+bool isKeyPressedImpl(KeyCode keycode)
+{
+    if (keycode != NullKeyCode)
+    {
+        Display* display = sf::priv::OpenDisplay();
+
+        // Get the whole keyboard state
+        char keys[32];
+        XQueryKeymap(display, keys);
+
+        sf::priv::CloseDisplay(display);
+
+        // Check our keycode
+        return (keys[keycode / 8] & (1 << (keycode % 8))) != 0;
+    }
+
+    return false;
+}
+
+} // anonymous namespace
+
+namespace sf
+{
+namespace priv
+{
+
+////////////////////////////////////////////////////////////
+bool KeyboardImpl::isKeyPressed(Keyboard::Key key)
+{
+    KeyCode keycode = keyToKeyCode(key);
+    return isKeyPressedImpl(keycode);
+}
+
+
+////////////////////////////////////////////////////////////
+bool KeyboardImpl::isKeyPressed(Keyboard::Scancode code)
+{
+    KeyCode keycode = scancodeToKeyCode(code);
+    return isKeyPressedImpl(keycode);
+}
+
+
+////////////////////////////////////////////////////////////
+Keyboard::Scancode KeyboardImpl::unlocalize(Keyboard::Key key)
+{
+    KeyCode keycode = keyToKeyCode(key);
+    return keyCodeToScancode(keycode);
+}
+
+
+////////////////////////////////////////////////////////////
+Keyboard::Key KeyboardImpl::localize(Keyboard::Scancode code)
+{
+    KeySym keysym = scancodeToKeySym(code);
+    return keySymToKey(keysym);
+}
+
+
+////////////////////////////////////////////////////////////
+String KeyboardImpl::getDescription(Keyboard::Scancode code)
+{
+    bool checkInput = true;
+
+    // these scancodes actually correspond to keys with input
+    // but we want to return their description, not their behaviour
+    if (code == Keyboard::ScanEscape      ||
+        code == Keyboard::ScanEnter       ||
+        code == Keyboard::ScanNumpadEnter ||
+        code == Keyboard::ScanTab         ||
+        code == Keyboard::ScanDelete      ||
+        code == Keyboard::ScanBackspace   ||
+        code == Keyboard::ScanSpace)
+    {
+        checkInput = false;
+    }
+
+    if (checkInput)
+    {
+        KeySym keysym = scancodeToKeySym(code);
+        Uint32 unicode = keysymToUnicode(keysym);
+
+        if (unicode != 0)
+            return String(unicode);
+    }
+
+    // Fallback to our best guess for the keys that are known to be independent of the layout.
+    switch (code)
+    {
+        case Keyboard::ScanEnter:        return "Enter";
+        case Keyboard::ScanEscape:       return "Escape";
+        case Keyboard::ScanBackspace:    return "Backspace";
+        case Keyboard::ScanTab:          return "Tab";
+        case Keyboard::ScanSpace:        return "Space";
+
+        case Keyboard::ScanF1:           return "F1";
+        case Keyboard::ScanF2:           return "F2";
+        case Keyboard::ScanF3:           return "F3";
+        case Keyboard::ScanF4:           return "F4";
+        case Keyboard::ScanF5:           return "F5";
+        case Keyboard::ScanF6:           return "F6";
+        case Keyboard::ScanF7:           return "F7";
+        case Keyboard::ScanF8:           return "F8";
+        case Keyboard::ScanF9:           return "F9";
+        case Keyboard::ScanF10:          return "F10";
+        case Keyboard::ScanF11:          return "F11";
+        case Keyboard::ScanF12:          return "F12";
+        case Keyboard::ScanF13:          return "F13";
+        case Keyboard::ScanF14:          return "F14";
+        case Keyboard::ScanF15:          return "F15";
+        // TODO: add F16-F25 once they're added in Scancode enum
+
+        case Keyboard::ScanCapsLock:     return "CapsLock";
+        case Keyboard::ScanPrintScreen:  return "PrintScreen";
+        case Keyboard::ScanScrollLock:   return "ScrollLock";
+
+        case Keyboard::ScanPause:        return "Pause";
+        case Keyboard::ScanInsert:       return "Insert";
+        case Keyboard::ScanHome:         return "Home";
+        case Keyboard::ScanPageUp:       return "PageUp";
+        case Keyboard::ScanDelete:       return "Delete";
+        case Keyboard::ScanEnd:          return "End";
+        case Keyboard::ScanPageDown:     return "PageDown";
+
+        case Keyboard::ScanLeft:         return "Left Arrow";
+        case Keyboard::ScanRight:        return "Right Arrow";
+        case Keyboard::ScanDown:         return "Down Arrow";
+        case Keyboard::ScanUp:           return "Up Arrow";
+
+        case Keyboard::ScanNumLock:      return "NumLock";
+        case Keyboard::ScanDivide:       return "Divide (Numpad)";
+        case Keyboard::ScanMultiply:     return "Multiply (Numpad)";
+        case Keyboard::ScanMinus:        return "Minux (Numpad)";
+        case Keyboard::ScanPlus:         return "Plus (Numpad)";
+        case Keyboard::ScanNumpadEquals: return "Equals (Numpad)";
+        case Keyboard::ScanNumpadEnter:  return "Enter (Numpad)";
+        case Keyboard::ScanDecimal:      return "Decimal (Numpad)";
+
+        case Keyboard::ScanNumpad0:      return "0 (Numpad)";
+        case Keyboard::ScanNumpad1:      return "1 (Numpad)";
+        case Keyboard::ScanNumpad2:      return "2 (Numpad)";
+        case Keyboard::ScanNumpad3:      return "3 (Numpad)";
+        case Keyboard::ScanNumpad4:      return "4 (Numpad)";
+        case Keyboard::ScanNumpad5:      return "5 (Numpad)";
+        case Keyboard::ScanNumpad6:      return "6 (Numpad)";
+        case Keyboard::ScanNumpad7:      return "7 (Numpad)";
+        case Keyboard::ScanNumpad8:      return "8 (Numpad)";
+        case Keyboard::ScanNumpad9:      return "9 (Numpad)";
+
+        case Keyboard::ScanApplication:  return "Application";
+        case Keyboard::ScanExecute:      return "Execute";
+        case Keyboard::ScanHelp:         return "Help";
+        case Keyboard::ScanMenu:         return "Menu";
+        case Keyboard::ScanSelect:       return "Select";
+        case Keyboard::ScanStop:         return "Stop";
+        case Keyboard::ScanAgain:        return "Again";
+        case Keyboard::ScanUndo:         return "Undo";
+        case Keyboard::ScanCut:          return "Cut";
+        case Keyboard::ScanCopy:         return "Copy";
+        case Keyboard::ScanPaste:        return "Paste";
+        case Keyboard::ScanFind:         return "Find";
+        case Keyboard::ScanMute:         return "Mute";
+        case Keyboard::ScanVolumeUp:     return "Volume Up";
+        case Keyboard::ScanVolumeDown:   return "Volume Down";
+
+        case Keyboard::ScanLControl:     return "Left Control";
+        case Keyboard::ScanLShift:       return "Left Shift";
+        case Keyboard::ScanLAlt:         return "Left Meta";
+        case Keyboard::ScanLSystem:      return "Left Super";
+        case Keyboard::ScanRControl:     return "Right Control";
+        case Keyboard::ScanRShift:       return "Right Shift";
+        case Keyboard::ScanRAlt:         return "Right Meta";
+        case Keyboard::ScanRSystem:      return "Right Super";
+        default:                         return "Unknown Scancode"; // no guess good enough possible.
+    }
+}
+
+
+////////////////////////////////////////////////////////////
+Keyboard::Key KeyboardImpl::getKeyFromEvent(XKeyEvent& event)
+{
+    Keyboard::Key key = Keyboard::Unknown;
+
+    // Try each KeySym index (modifier group) until we get a match
+    for (int i = 0; i < 4; ++i)
+    {
+        // Get the SFML keyboard code from the keysym of the key that has been pressed
+        KeySym keysym = XLookupKeysym(&event, i);
+        key = keySymToKey(keysym);
+
+        if (key != Keyboard::Unknown)
+            break;
+    }
+
+    return key;
+}
+
+
+////////////////////////////////////////////////////////////
+Keyboard::Scancode KeyboardImpl::getScancodeFromEvent(XKeyEvent& event)
+{
+    return keyCodeToScancode(event.keycode);
+}
+
+} // namespace priv
+
+} // namespace sf

src/SFML/Window/Unix/KeyboardImpl.hpp

@@ -0,0 +1,104 @@
+////////////////////////////////////////////////////////////
+//
+// SFML - Simple and Fast Multimedia Library
+// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org)
+//
+// This software is provided 'as-is', without any express or implied warranty.
+// In no event will the authors be held liable for any damages arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it freely,
+// subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented;
+//    you must not claim that you wrote the original software.
+//    If you use this software in a product, an acknowledgment
+//    in the product documentation would be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such,
+//    and must not be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source distribution.
+//
+////////////////////////////////////////////////////////////
+
+#ifndef SFML_KEYBOARD_IMPL_HPP
+#define SFML_KEYBOARD_IMPL_HPP
+
+////////////////////////////////////////////////////////////
+// Headers
+////////////////////////////////////////////////////////////
+#include <SFML/Window/Keyboard.hpp>
+#include <X11/Xlib.h> // XKeyEvent
+
+
+namespace sf
+{
+namespace priv
+{
+////////////////////////////////////////////////////////////
+/// \brief sf::priv::KeyboardImpl helper
+///
+/// This class implements keyboard handling functions
+/// to help sf::priv::InputImpl class.
+////////////////////////////////////////////////////////////
+class KeyboardImpl
+{
+public:
+
+    ////////////////////////////////////////////////////////////
+    /// \copydoc sf::Keyboard::isKeyPressed(Key)
+    ///
+    ////////////////////////////////////////////////////////////
+    static bool isKeyPressed(Keyboard::Key key);
+
+    ////////////////////////////////////////////////////////////
+    /// \copydoc sf::Keyboard::isKeyPressed(Scancode)
+    ///
+    ////////////////////////////////////////////////////////////
+    static bool isKeyPressed(Keyboard::Scancode code);
+
+    ////////////////////////////////////////////////////////////
+    /// \copydoc sf::Keyboard::localize
+    ///
+    ////////////////////////////////////////////////////////////
+    static Keyboard::Scancode unlocalize(Keyboard::Key key);
+
+    ////////////////////////////////////////////////////////////
+    /// \copydoc sf::Keyboard::unlocalize
+    ///
+    ////////////////////////////////////////////////////////////
+    static Keyboard::Key localize(Keyboard::Scancode code);
+
+    ////////////////////////////////////////////////////////////
+    /// \copydoc sf::Keyboard::getDescription
+    ///
+    ////////////////////////////////////////////////////////////
+    static String getDescription(Keyboard::Scancode code);
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Get the sf::Keyboard::Key from XKeyEvent
+    ///
+    /// \param event Event from which key is gotten
+    ///
+    /// \return A key being pressed or released
+    ///
+    ////////////////////////////////////////////////////////////
+    static Keyboard::Key getKeyFromEvent(XKeyEvent& event);
+
+    ////////////////////////////////////////////////////////////
+    /// \brief Get the sf::Keyboard::Scancode from XKeyEvent
+    ///
+    /// \param event Event from which scancode is gotten
+    ///
+    /// \return A scancode of a key being pressed or released
+    ///
+    ////////////////////////////////////////////////////////////
+    static Keyboard::Scancode getScancodeFromEvent(XKeyEvent& event);
+};
+
+} // namespace priv
+
+} // namespace sf
+
+#endif // SFML_KEYBOARD_IMPL_HPP

src/SFML/Window/Unix/WindowImplX11.cpp

@@ -29,6 +29,7 @@
 #include <SFML/Window/Unix/ClipboardImpl.hpp>
 #include <SFML/Window/Unix/Display.hpp>
 #include <SFML/Window/Unix/InputImpl.hpp>
+#include <SFML/Window/Unix/KeyboardImpl.hpp>
 #include <SFML/System/Utf.hpp>
 #include <SFML/System/Err.hpp>
 #include <SFML/System/Mutex.hpp>
@@ -1826,27 +1827,16 @@ bool WindowImplX11::processEvent(XEvent& windowEvent)
         // Key down event
         case KeyPress:
         {
-            Keyboard::Key key = Keyboard::Unknown;
-
-            // Try each KeySym index (modifier group) until we get a match
-            for (int i = 0; i < 4; ++i)
-            {
-                // Get the SFML keyboard code from the keysym of the key that has been pressed
-                key = keysymToSF(XLookupKeysym(&windowEvent.xkey, i));
-
-                if (key != Keyboard::Unknown)
-                    break;
-            }
-
             // Fill the event parameters
             // TODO: if modifiers are wrong, use XGetModifierMapping to retrieve the actual modifiers mapping
             Event event;
-            event.type        = Event::KeyPressed;
-            event.key.code    = key;
-            event.key.alt     = windowEvent.xkey.state & Mod1Mask;
-            event.key.control = windowEvent.xkey.state & ControlMask;
-            event.key.shift   = windowEvent.xkey.state & ShiftMask;
-            event.key.system  = windowEvent.xkey.state & Mod4Mask;
+            event.type         = Event::KeyPressed;
+            event.key.code     = KeyboardImpl::getKeyFromEvent(windowEvent.xkey);
+            event.key.scancode = KeyboardImpl::getScancodeFromEvent(windowEvent.xkey);
+            event.key.alt      = windowEvent.xkey.state & Mod1Mask;
+            event.key.control  = windowEvent.xkey.state & ControlMask;
+            event.key.shift    = windowEvent.xkey.state & ShiftMask;
+            event.key.system   = windowEvent.xkey.state & Mod4Mask;
             pushEvent(event);
 
             // Generate a TextEntered event
@@ -1903,26 +1893,15 @@ bool WindowImplX11::processEvent(XEvent& windowEvent)
         // Key up event
         case KeyRelease:
         {
-            Keyboard::Key key = Keyboard::Unknown;
-
-            // Try each KeySym index (modifier group) until we get a match
-            for (int i = 0; i < 4; ++i)
-            {
-                // Get the SFML keyboard code from the keysym of the key that has been released
-                key = keysymToSF(XLookupKeysym(&windowEvent.xkey, i));
-
-                if (key != Keyboard::Unknown)
-                    break;
-            }
-
             // Fill the event parameters
             Event event;
-            event.type        = Event::KeyReleased;
-            event.key.code    = key;
-            event.key.alt     = windowEvent.xkey.state & Mod1Mask;
-            event.key.control = windowEvent.xkey.state & ControlMask;
-            event.key.shift   = windowEvent.xkey.state & ShiftMask;
-            event.key.system  = windowEvent.xkey.state & Mod4Mask;
+            event.type         = Event::KeyReleased;
+            event.key.code     = KeyboardImpl::getKeyFromEvent(windowEvent.xkey);
+            event.key.scancode = KeyboardImpl::getScancodeFromEvent(windowEvent.xkey);
+            event.key.alt      = windowEvent.xkey.state & Mod1Mask;
+            event.key.control  = windowEvent.xkey.state & ControlMask;
+            event.key.shift    = windowEvent.xkey.state & ShiftMask;
+            event.key.system   = windowEvent.xkey.state & Mod4Mask;
             pushEvent(event);
 
             break;
@@ -2193,5 +2172,4 @@ Vector2i WindowImplX11::getPrimaryMonitorPosition()
 }
 
 } // namespace priv
-
 } // namespace sf

src/SFML/Window/Win32/InputImpl.cpp

@@ -43,7 +43,122 @@ namespace sf
 namespace priv
 {
 ////////////////////////////////////////////////////////////
-bool InputImpl::isKeyPressed(Keyboard::Key key)
+Keyboard::Scancode InputImpl::m_keyToScancodeMapping[Keyboard::KeyCount];      ///< Mapping from Key to Scancode
+Keyboard::Key      InputImpl::m_scancodeToKeyMapping[Keyboard::ScanCodeCount]; ///< Mapping from Scancode to Key
+
+////////////////////////////////////////////////////////////
+Keyboard::Key winKeyToSfKey(int vkey)
+{
+    Keyboard::Key key;
+    switch (vkey)
+    {
+        default:                key = Keyboard::Unknown; break;
+        case 'A':               key = Keyboard::A; break;
+        case 'B':               key = Keyboard::B; break;
+        case 'C':               key = Keyboard::C; break;
+        case 'D':               key = Keyboard::D; break;
+        case 'E':               key = Keyboard::E; break;
+        case 'F':               key = Keyboard::F; break;
+        case 'G':               key = Keyboard::G; break;
+        case 'H':               key = Keyboard::H; break;
+        case 'I':               key = Keyboard::I; break;
+        case 'J':               key = Keyboard::J; break;
+        case 'K':               key = Keyboard::K; break;
+        case 'L':               key = Keyboard::L; break;
+        case 'M':               key = Keyboard::M; break;
+        case 'N':               key = Keyboard::N; break;
+        case 'O':               key = Keyboard::O; break;
+        case 'P':               key = Keyboard::P; break;
+        case 'Q':               key = Keyboard::Q; break;
+        case 'R':               key = Keyboard::R; break;
+        case 'S':               key = Keyboard::S; break;
+        case 'T':               key = Keyboard::T; break;
+        case 'U':               key = Keyboard::U; break;
+        case 'V':               key = Keyboard::V; break;
+        case 'W':               key = Keyboard::W; break;
+        case 'X':               key = Keyboard::X; break;
+        case 'Y':               key = Keyboard::Y; break;
+        case 'Z':               key = Keyboard::Z; break;
+        case '0':               key = Keyboard::Num0; break;
+        case '1':               key = Keyboard::Num1; break;
+        case '2':               key = Keyboard::Num2; break;
+        case '3':               key = Keyboard::Num3; break;
+        case '4':               key = Keyboard::Num4; break;
+        case '5':               key = Keyboard::Num5; break;
+        case '6':               key = Keyboard::Num6; break;
+        case '7':               key = Keyboard::Num7; break;
+        case '8':               key = Keyboard::Num8; break;
+        case '9':               key = Keyboard::Num9; break;
+        case VK_ESCAPE:         key = Keyboard::Escape; break;
+        case VK_LCONTROL:       key = Keyboard::LControl; break;
+        case VK_LSHIFT:         key = Keyboard::LShift; break;
+        case VK_LMENU:          key = Keyboard::LAlt; break;
+        case VK_LWIN:           key = Keyboard::LSystem; break;
+        case VK_RCONTROL:       key = Keyboard::RControl; break;
+        case VK_RSHIFT:         key = Keyboard::RShift; break;
+        case VK_RMENU:          key = Keyboard::RAlt; break;
+        case VK_RWIN:           key = Keyboard::RSystem; break;
+        case VK_APPS:           key = Keyboard::Menu; break;
+        case VK_OEM_4:          key = Keyboard::LBracket; break;
+        case VK_OEM_6:          key = Keyboard::RBracket; break;
+        case VK_OEM_1:          key = Keyboard::Semicolon; break;
+        case VK_OEM_COMMA:      key = Keyboard::Comma; break;
+        case VK_OEM_PERIOD:     key = Keyboard::Period; ;
+        case VK_OEM_7:          key = Keyboard::Quote; break;
+        case VK_OEM_2:          key = Keyboard::Slash; break;
+        case VK_OEM_5:          key = Keyboard::Backslash; break;
+        case VK_OEM_3:          key = Keyboard::Tilde; break;
+        case VK_OEM_PLUS:       key = Keyboard::Equal; break;
+        case VK_OEM_MINUS:      key = Keyboard::Hyphen; break;
+        case VK_SPACE:          key = Keyboard::Space; break;
+        case VK_RETURN:         key = Keyboard::Enter; break;
+        case VK_BACK:           key = Keyboard::Backspace; break;
+        case VK_TAB:            key = Keyboard::Tab; break;
+        case VK_PRIOR:          key = Keyboard::PageUp; break;
+        case VK_NEXT:           key = Keyboard::PageDown; break;
+        case VK_END:            key = Keyboard::End; break;
+        case VK_HOME:           key = Keyboard::Home; break;
+        case VK_INSERT:         key = Keyboard::Insert; break;
+        case VK_DELETE:         key = Keyboard::Delete; break;
+        case VK_ADD:            key = Keyboard::Add; break;
+        case VK_SUBTRACT:       key = Keyboard::Subtract; break;
+        case VK_MULTIPLY:       key = Keyboard::Multiply; break;
+        case VK_DIVIDE:         key = Keyboard::Divide; break;
+        case VK_LEFT:           key = Keyboard::Left; break;
+        case VK_RIGHT:          key = Keyboard::Right; break;
+        case VK_UP:             key = Keyboard::Up; break;
+        case VK_DOWN:           key = Keyboard::Down; break;
+        case VK_NUMPAD0:        key = Keyboard::Numpad0; break;
+        case VK_NUMPAD1:        key = Keyboard::Numpad1; break;
+        case VK_NUMPAD2:        key = Keyboard::Numpad2; break;
+        case VK_NUMPAD3:        key = Keyboard::Numpad3; break;
+        case VK_NUMPAD4:        key = Keyboard::Numpad4; break;
+        case VK_NUMPAD5:        key = Keyboard::Numpad5; break;
+        case VK_NUMPAD6:        key = Keyboard::Numpad6; break;
+        case VK_NUMPAD7:        key = Keyboard::Numpad7; break;
+        case VK_NUMPAD8:        key = Keyboard::Numpad8; break;
+        case VK_NUMPAD9:        key = Keyboard::Numpad9; break;
+        case VK_F1:             key = Keyboard::F1; break;
+        case VK_F2:             key = Keyboard::F2; break;
+        case VK_F3:             key = Keyboard::F3; break;
+        case VK_F4:             key = Keyboard::F4; break;
+        case VK_F5:             key = Keyboard::F5; break;
+        case VK_F6:             key = Keyboard::F6; break;
+        case VK_F7:             key = Keyboard::F7; break;
+        case VK_F8:             key = Keyboard::F8; break;
+        case VK_F9:             key = Keyboard::F9; break;
+        case VK_F10:            key = Keyboard::F10; break;
+        case VK_F11:            key = Keyboard::F11; break;
+        case VK_F12:            key = Keyboard::F12; break;
+        case VK_F13:            key = Keyboard::F13; break;
+        case VK_F14:            key = Keyboard::F14; break;
+        case VK_F15:            key = Keyboard::F15; break;
+        case VK_PAUSE:          key = Keyboard::Pause; break;
+    }
+    return key;
+}
+////////////////////////////////////////////////////////////
+int sfKeyToWin(Keyboard::Key key)
 {
     int vkey = 0;
     switch (key)
@@ -151,10 +266,217 @@ bool InputImpl::isKeyPressed(Keyboard::Key key)
         case Keyboard::F15:        vkey = VK_F15;        break;
         case Keyboard::Pause:      vkey = VK_PAUSE;      break;
     }
+    return vkey;
+}
 
+////////////////////////////////////////////////////////////
+WORD sfScanToWin(Keyboard::Scancode code)
+{
+    // Convert an SFML scancode to a windows scancode
+    // Reference: https://msdn.microsoft.com/en-us/library/aa299374(v=vs.60).aspx
+    switch (code)
+    {
+        case Keyboard::ScanA: return 30;
+        case Keyboard::ScanB: return 48;
+        case Keyboard::ScanC: return 46;
+        case Keyboard::ScanD: return 32;
+        case Keyboard::ScanE: return 18;
+        case Keyboard::ScanF: return 33;
+        case Keyboard::ScanG: return 34;
+        case Keyboard::ScanH: return 35;
+        case Keyboard::ScanI: return 23;
+        case Keyboard::ScanJ: return 36;
+        case Keyboard::ScanK: return 37;
+        case Keyboard::ScanL: return 38;
+        case Keyboard::ScanM: return 50;
+        case Keyboard::ScanN: return 49;
+        case Keyboard::ScanO: return 24;
+        case Keyboard::ScanP: return 25;
+        case Keyboard::ScanQ: return 16;
+        case Keyboard::ScanR: return 19;
+        case Keyboard::ScanS: return 31;
+        case Keyboard::ScanT: return 20;
+        case Keyboard::ScanU: return 22;
+        case Keyboard::ScanV: return 47;
+        case Keyboard::ScanW: return 17;
+        case Keyboard::ScanX: return 45;
+        case Keyboard::ScanY: return 21;
+        case Keyboard::ScanZ: return 44;
+    
+        case Keyboard::ScanNum1: return 2;
+        case Keyboard::ScanNum2: return 3;
+        case Keyboard::ScanNum3: return 4;
+        case Keyboard::ScanNum4: return 5;
+        case Keyboard::ScanNum5: return 6;
+        case Keyboard::ScanNum6: return 7;
+        case Keyboard::ScanNum7: return 8;
+        case Keyboard::ScanNum8: return 9;
+        case Keyboard::ScanNum9: return 10;
+        case Keyboard::ScanNum0: return 11;
+    
+        case Keyboard::ScanEnter:           return 28;
+        case Keyboard::ScanEscape:          return 1;
+        case Keyboard::ScanBackspace:       return 14;
+        case Keyboard::ScanTab:             return 15;
+        case Keyboard::ScanSpace:           return 57;
+        case Keyboard::ScanHyphen:          return 12;
+        case Keyboard::ScanEquals:          return 13;
+        case Keyboard::ScanLBracket:        return 26;
+        case Keyboard::ScanRBracket:        return 27;
+        case Keyboard::ScanBackslash:       return 43;
+        case Keyboard::ScanDash:            return 41;
+        case Keyboard::ScanSemicolon:       return 39;
+        case Keyboard::ScanQuote:           return 40;
+        //case Keyboard::ScanGraveAccent:   return ? ? ? 
+        case Keyboard::ScanComma:           return 51;
+        case Keyboard::ScanPeriod:          return 52;
+        case Keyboard::ScanSlash:           return 53;
+    
+        case Keyboard::ScanF1:      return 59;
+        case Keyboard::ScanF2:      return 60;
+        case Keyboard::ScanF3:      return 61;
+        case Keyboard::ScanF4:      return 62;
+        case Keyboard::ScanF5:      return 63;
+        case Keyboard::ScanF6:      return 64;
+        case Keyboard::ScanF7:      return 65;
+        case Keyboard::ScanF8:      return 66;
+        case Keyboard::ScanF9:      return 67;
+        case Keyboard::ScanF10:     return 68;
+        case Keyboard::ScanF11:     return KF_EXTENDED | 87;
+        case Keyboard::ScanF12:     return KF_EXTENDED | 88;
+        //case Keyboard::ScanF13:   return ???
+        //case Keyboard::ScanF14:   return ???
+        //case Keyboard::ScanF15:   return ???
+    
+        case Keyboard::ScanCapsLock:    return 58;
+        case Keyboard::ScanPrintScreen: return 55 | KF_EXTENDED;
+        case Keyboard::ScanScrollLock:  return 70;
+        case Keyboard::ScanPause:       return 69;
+        case Keyboard::ScanInsert:      return 82 | KF_EXTENDED;
+        case Keyboard::ScanHome:        return 71 | KF_EXTENDED;
+        case Keyboard::ScanPageUp:      return 73 | KF_EXTENDED;
+        case Keyboard::ScanDelete:      return 83 | KF_EXTENDED;
+        case Keyboard::ScanEnd:         return 79 | KF_EXTENDED;
+        case Keyboard::ScanPageDown:    return 81 | KF_EXTENDED;
+        case Keyboard::ScanRight:       return 77 | KF_EXTENDED;
+        case Keyboard::ScanLeft:        return 75 | KF_EXTENDED;
+        case Keyboard::ScanDown:        return 80 | KF_EXTENDED;
+        case Keyboard::ScanUp:          return 72 | KF_EXTENDED;
+        case Keyboard::ScanNumLock:     return 69 | KF_EXTENDED;
+        case Keyboard::ScanDivide:      return 53;
+        case Keyboard::ScanMultiply:    return 55;
+        case Keyboard::ScanMinus:       return 74;
+        case Keyboard::ScanPlus:        return 78;
+        //case Keyboard::ScanPadEquals: return ???;
+        case Keyboard::ScanNumpadEnter: return  KF_EXTENDED | 28;
+        case Keyboard::ScanDecimal:     return 83;
+    
+        case Keyboard::ScanNumpad1: return 79;
+        case Keyboard::ScanNumpad2: return 80;
+        case Keyboard::ScanNumpad3: return 81 ;
+        case Keyboard::ScanNumpad4: return 75 ;
+        case Keyboard::ScanNumpad5: return 76;
+        case Keyboard::ScanNumpad6: return 77 ;
+        case Keyboard::ScanNumpad7: return 71 ;
+        case Keyboard::ScanNumpad8: return 72 ;
+        case Keyboard::ScanNumpad9: return 73 ;
+        case Keyboard::ScanNumpad0: return 82 ;
+    
+        //case Keyboard::ScanReverseSolidus:    return ? ? ? ;
+        //case Keyboard::ScanApplication:       return ? ? ? ;
+        //case Keyboard::ScanExecute:           return ? ? ? ;
+        //case Keyboard::ScanHelp:              return ? ? ? ;
+        case Keyboard::ScanMenu:                return 93 | KF_EXTENDED;
+        //case Keyboard::ScanSelect:            return ? ? ? ;
+        //case Keyboard::ScanStop:              return ? ? ? ;
+        //case Keyboard::ScanAgain:             return ? ? ? ;
+        //case Keyboard::ScanUndo:              return ? ? ? ;
+        //case Keyboard::ScanCut:               return ? ? ? ;
+        //case Keyboard::ScanCopy:              return ? ? ? ;
+        //case Keyboard::ScanPaste:             return ? ? ? ;
+        //case Keyboard::ScanFind:              return ? ? ? ;
+        //case Keyboard::ScanMute:              return ? ? ? ;
+        //case Keyboard::ScanVolumeUp:          return ? ? ? ;
+        //case Keyboard::ScanVolumeDown:        return ? ? ? ;
+        case Keyboard::ScanLControl:            return 29;
+        case Keyboard::ScanLShift:              return 42;
+        case Keyboard::ScanLAlt:                return 56;
+        case Keyboard::ScanLSystem:             return 91 | KF_EXTENDED ;
+        case Keyboard::ScanRControl:            return KF_EXTENDED | 29;
+        case Keyboard::ScanRShift:              return 54;
+        case Keyboard::ScanRAlt:                return 56;
+        //case Keyboard::ScanRSystem:           return ? ? ? ;
+    
+        default: return 0; // Not sure what to return here?
+    }
+}
+
+////////////////////////////////////////////////////////////
+InputImpl::InputImpl()
+{
+    buildMappings();
+}
+
+////////////////////////////////////////////////////////////
+void InputImpl::buildMappings()
+{
+    // Reset the mappings
+    for (int i = 0; i < Keyboard::KeyCount; ++i)
+        m_keyToScancodeMapping[i] = Keyboard::ScanUnknown;
+    for (int i = 0; i < Keyboard::ScanCodeCount; ++i)
+        m_scancodeToKeyMapping[i] = Keyboard::Unknown;
+
+    for (int i = 0; i < Keyboard::ScanCodeCount; ++i)
+    {
+        Keyboard::Scancode scan = static_cast<Keyboard::Scancode>(i);
+        WORD winScanCode = sfScanToWin(scan);
+        UINT vkey = MapVirtualKey(winScanCode, MAPVK_VSC_TO_VK_EX);
+        Keyboard::Key key = winKeyToSfKey(vkey);
+        m_keyToScancodeMapping[key] = scan;
+        m_scancodeToKeyMapping[scan] = key;
+    }
+}
+
+////////////////////////////////////////////////////////////
+bool InputImpl::isKeyPressed(Keyboard::Key key)
+{
+    int vkey = sfKeyToWin(key);
     return (GetAsyncKeyState(vkey) & 0x8000) != 0;
 }
 
+////////////////////////////////////////////////////////////
+bool InputImpl::isKeyPressed(Keyboard::Scancode code)
+{
+    WORD winScanCode = sfScanToWin(code);
+    UINT vkey = MapVirtualKey(winScanCode, MAPVK_VSC_TO_VK_EX);
+    return (GetAsyncKeyState(vkey) & 0x8000) != 0;
+}
+
+////////////////////////////////////////////////////////////
+Keyboard::Key InputImpl::localize(Keyboard::Scancode code)
+{
+    return m_scancodeToKeyMapping[code];
+}
+
+////////////////////////////////////////////////////////////
+Keyboard::Scancode InputImpl::unlocalize(Keyboard::Key key)
+{
+    return m_keyToScancodeMapping[key];
+}
+
+////////////////////////////////////////////////////////////
+String InputImpl::getDescription(Keyboard::Scancode code)
+{
+    WORD winCode = sfScanToWin(code);
+    const int bufSize(1024);
+    WCHAR name[bufSize];
+    int result = GetKeyNameText(winCode << 16, name, bufSize);
+    if (result > 0)
+    {
+        return name;
+    }
+    return "Unknown";
+}
 
 ////////////////////////////////////////////////////////////
 void InputImpl::setVirtualKeyboardVisible(bool visible)

src/SFML/Window/Win32/InputImpl.hpp

@@ -31,7 +31,6 @@
 #include <SFML/Window/Keyboard.hpp>
 #include <SFML/Window/Mouse.hpp>
 
-
 namespace sf
 {
 namespace priv
@@ -43,21 +42,44 @@ namespace priv
 class InputImpl
 {
 public:
+    ////////////////////////////////////////////////////////////
+    /// \brief Default constructor
+    ///
+    ////////////////////////////////////////////////////////////
+    InputImpl();
 
     ////////////////////////////////////////////////////////////
-    /// \brief Check if a key is pressed
-    ///
-    /// \param key Key to check
-    ///
-    /// \return True if the key is pressed, false otherwise
+    /// \copydoc sf::Keyboard::isKeyPressed(Key)
     ///
     ////////////////////////////////////////////////////////////
     static bool isKeyPressed(Keyboard::Key key);
 
     ////////////////////////////////////////////////////////////
-    /// \brief Show or hide the virtual keyboard
+    /// \copydoc sf::Keyboard::isKeyPressed(Scancode)
     ///
-    /// \param visible True to show, false to hide
+    ////////////////////////////////////////////////////////////
+    static bool isKeyPressed(Keyboard::Scancode code);
+
+    ////////////////////////////////////////////////////////////
+    /// \copydoc sf::Keyboard::localize
+    ///
+    ////////////////////////////////////////////////////////////
+    static Keyboard::Key localize(Keyboard::Scancode code);
+
+    ////////////////////////////////////////////////////////////
+    /// \copydoc sf::Keyboard::unlocalize
+    ///
+    ////////////////////////////////////////////////////////////
+    static Keyboard::Scancode unlocalize(Keyboard::Key key);
+
+    ////////////////////////////////////////////////////////////
+    /// \copydoc sf::Keyboard::getDescription
+    ///
+    ////////////////////////////////////////////////////////////
+    static String getDescription(Keyboard::Scancode code);
+
+    ////////////////////////////////////////////////////////////
+    /// \copydoc sf::Keyboard::setVirtualKeyboardVisible
     ///
     ////////////////////////////////////////////////////////////
     static void setVirtualKeyboardVisible(bool visible);
@@ -158,6 +180,20 @@ public:
     ///
     ////////////////////////////////////////////////////////////
     static Vector2i getTouchPosition(unsigned int finger, const WindowBase& relativeTo);
+
+private:
+
+    ////////////////////////////////////////////////////////////
+    /// Regenerate the mappings from/to Key and Scancode.
+    ///
+    ////////////////////////////////////////////////////////////
+    void buildMappings();
+
+    ////////////////////////////////////////////////////////////
+    // Member data
+    ////////////////////////////////////////////////////////////
+    static Keyboard::Scancode m_keyToScancodeMapping[Keyboard::KeyCount];      ///< Mapping from Key to Scancode
+    static Keyboard::Key      m_scancodeToKeyMapping[Keyboard::ScanCodeCount]; ///< Mapping from Scancode to Key
 };
 
 } // namespace priv

src/SFML/Window/Win32/WindowImplWin32.cpp

@@ -557,6 +557,107 @@ void WindowImplWin32::grabCursor(bool grabbed)
     }
 }
 
+////////////////////////////////////////////////////////////
+Keyboard::Scancode WindowImplWin32::toScancode(LPARAM flags)
+{
+    int code = ((flags & (0xFF << 16)) >> 16);
+
+    // Windows scan codes
+    // Reference: https://msdn.microsoft.com/en-us/library/aa299374(v=vs.60).aspx
+    switch (code)
+    {
+        case 1: return Keyboard::ScanEscape;
+        case 2: return Keyboard::ScanNum1;
+        case 3: return Keyboard::ScanNum2;
+        case 4: return Keyboard::ScanNum3;
+        case 5: return Keyboard::ScanNum4;
+        case 6: return Keyboard::ScanNum5;
+        case 7: return Keyboard::ScanNum6;
+        case 8: return Keyboard::ScanNum7;
+        case 9: return Keyboard::ScanNum8;
+        case 10: return Keyboard::ScanNum9;
+        case 11: return Keyboard::ScanNum0;
+        case 12: return Keyboard::ScanHyphen;
+        case 13: return Keyboard::ScanEquals;
+        case 14: return Keyboard::ScanBackspace;
+        case 15: return Keyboard::ScanTab;
+        case 16: return Keyboard::ScanQ;
+        case 17: return Keyboard::ScanW;
+        case 18: return Keyboard::ScanE;
+        case 19: return Keyboard::ScanR;
+        case 20: return Keyboard::ScanT;
+        case 21: return Keyboard::ScanY;
+        case 22: return Keyboard::ScanU;
+        case 23: return Keyboard::ScanI;
+        case 24: return Keyboard::ScanO;
+        case 25: return Keyboard::ScanP;
+        case 26: return Keyboard::ScanLBracket;
+        case 27: return Keyboard::ScanRBracket;
+        case 28: return (HIWORD(flags) & KF_EXTENDED) ? Keyboard::ScanEnter : Keyboard::ScanNumpadEnter;
+        case 29: return (HIWORD(flags) & KF_EXTENDED) ? Keyboard::ScanRControl : Keyboard::ScanLControl;
+        case 30: return Keyboard::ScanA;
+        case 31: return Keyboard::ScanS;
+        case 32: return Keyboard::ScanD;
+        case 33: return Keyboard::ScanF;
+        case 34: return Keyboard::ScanG;
+        case 35: return Keyboard::ScanH;
+        case 36: return Keyboard::ScanJ;
+        case 37: return Keyboard::ScanK;
+        case 38: return Keyboard::ScanL;
+        case 39: return Keyboard::ScanSemicolon;
+        case 40: return Keyboard::ScanQuote;
+        case 41: return Keyboard::ScanBackslash;
+        case 42: return Keyboard::ScanLShift;
+        case 43: return Keyboard::ScanDash;
+        case 44: return Keyboard::ScanZ;
+        case 45: return Keyboard::ScanX;
+        case 46: return Keyboard::ScanC;
+        case 47: return Keyboard::ScanV;
+        case 48: return Keyboard::ScanB;
+        case 49: return Keyboard::ScanN;
+        case 50: return Keyboard::ScanM;
+        case 51: return Keyboard::ScanComma;
+        case 52: return Keyboard::ScanPeriod;
+        case 53: return (HIWORD(flags) & KF_EXTENDED) ? Keyboard::ScanDivide : Keyboard::ScanSlash;
+        case 54: return Keyboard::ScanRShift;
+        case 55: return (HIWORD(flags) & KF_EXTENDED) ? Keyboard::ScanPrintScreen : Keyboard::ScanMultiply;
+        case 56: return (HIWORD(flags) & KF_EXTENDED) ? Keyboard::ScanRAlt : Keyboard::ScanLAlt;
+        case 57: return Keyboard::ScanSpace;
+        case 58: return Keyboard::ScanCapsLock;
+        case 59: return Keyboard::ScanF1;
+        case 60: return Keyboard::ScanF2;
+        case 61: return Keyboard::ScanF3;
+        case 62: return Keyboard::ScanF4;
+        case 63: return Keyboard::ScanF5;
+        case 64: return Keyboard::ScanF6;
+        case 65: return Keyboard::ScanF7;
+        case 66: return Keyboard::ScanF8;
+        case 67: return Keyboard::ScanF9;
+        case 68: return Keyboard::ScanF10;
+        case 87: return (HIWORD(flags) & KF_EXTENDED) ? Keyboard::ScanUnknown : Keyboard::ScanF11;
+        case 88: return (HIWORD(flags) & KF_EXTENDED) ? Keyboard::ScanUnknown : Keyboard::ScanF12;
+        case 69: return (HIWORD(flags) & KF_EXTENDED) ? Keyboard::ScanNumLock : Keyboard::ScanPause;
+        case 70: return Keyboard::ScanScrollLock;
+        case 71: return (HIWORD(flags) & KF_EXTENDED) ? Keyboard::ScanHome : Keyboard::ScanNumpad7;
+        case 72: return (HIWORD(flags) & KF_EXTENDED) ? Keyboard::ScanUp : Keyboard::ScanNumpad8;
+        case 73: return (HIWORD(flags) & KF_EXTENDED) ? Keyboard::ScanPageUp : Keyboard::ScanNumpad9;
+        case 74: return Keyboard::ScanMinus;
+        case 75: return (HIWORD(flags) & KF_EXTENDED) ? Keyboard::ScanLeft : Keyboard::ScanNumpad4;
+        case 76: return Keyboard::ScanNumpad5;
+        case 77: return (HIWORD(flags) & KF_EXTENDED) ? Keyboard::ScanRight : Keyboard::ScanNumpad6;
+        case 78: return Keyboard::ScanPlus;
+        case 79: return (HIWORD(flags) & KF_EXTENDED) ? Keyboard::ScanEnd : Keyboard::ScanNumpad1;
+        case 80: return (HIWORD(flags) & KF_EXTENDED) ? Keyboard::ScanDown : Keyboard::ScanNumpad2;
+        case 81: return (HIWORD(flags) & KF_EXTENDED) ? Keyboard::ScanPageDown : Keyboard::ScanNumpad3;
+        case 82: return (HIWORD(flags) & KF_EXTENDED) ? Keyboard::ScanInsert : Keyboard::ScanNumpad0;
+        case 83: return (HIWORD(flags) & KF_EXTENDED) ? Keyboard::ScanDelete : Keyboard::ScanDecimal;
+    
+        case 91: return (HIWORD(flags) & KF_EXTENDED) ? Keyboard::ScanLSystem : Keyboard::ScanUnknown;
+        case 93: return (HIWORD(flags) & KF_EXTENDED) ? Keyboard::ScanMenu : Keyboard::ScanUnknown;
+    
+        default: return Keyboard::ScanUnknown;
+    }
+}
 
 ////////////////////////////////////////////////////////////
 void WindowImplWin32::processEvent(UINT message, WPARAM wParam, LPARAM lParam)

src/SFML/Window/Win32/WindowImplWin32.hpp

@@ -269,6 +269,16 @@ private:
     ////////////////////////////////////////////////////////////
     static LRESULT CALLBACK globalOnEvent(HWND handle, UINT message, WPARAM wParam, LPARAM lParam);
 
+    ////////////////////////////////////////////////////////////
+    /// \brief Convert a Win32 scancode to an sfml scancode
+    ///
+    /// \param flags input flags
+    ///
+    /// \return SFML scancode corresponding to the key
+    ///
+    ////////////////////////////////////////////////////////////
+    static Keyboard::Scancode toScancode(LPARAM flags);
+
     ////////////////////////////////////////////////////////////
     // Member data
     ////////////////////////////////////////////////////////////

src/SFML/Window/iOS/InputImpl.hpp

@@ -45,19 +45,37 @@ class InputImpl
 public:
 
     ////////////////////////////////////////////////////////////
-    /// \brief Check if a key is pressed
-    ///
-    /// \param key Key to check
-    ///
-    /// \return True if the key is pressed, false otherwise
+    /// \copydoc sf::Keyboard::isKeyPressed(Key)
     ///
     ////////////////////////////////////////////////////////////
     static bool isKeyPressed(Keyboard::Key key);
 
     ////////////////////////////////////////////////////////////
-    /// \brief Show or hide the virtual keyboard
+    /// \copydoc sf::Keyboard::isKeyPressed(Scancode)
     ///
-    /// \param visible True to show, false to hide
+    ////////////////////////////////////////////////////////////
+    static bool isKeyPressed(Keyboard::Scancode code);
+
+    ////////////////////////////////////////////////////////////
+    /// \copydoc sf::Keyboard::localize
+    ///
+    ////////////////////////////////////////////////////////////
+    static Keyboard::Key localize(Keyboard::Scancode code);
+
+    ////////////////////////////////////////////////////////////
+    /// \copydoc sf::Keyboard::unlocalize
+    ///
+    ////////////////////////////////////////////////////////////
+    static Keyboard::Scancode unlocalize(Keyboard::Key key);
+
+    ////////////////////////////////////////////////////////////
+    /// \copydoc sf::Keyboard::localizedRepresentation
+    ///
+    ////////////////////////////////////////////////////////////
+    static String getDescription(Keyboard::Scancode code);
+
+    ////////////////////////////////////////////////////////////
+    /// \copydoc sf::Keyboard::setVirtualKeyboardVisible
     ///
     ////////////////////////////////////////////////////////////
     static void setVirtualKeyboardVisible(bool visible);