Resolve additional merge conflicts

include/SFML/Window/Event.hpp

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

include/SFML/Window/Keyboard.hpp

@@ -29,10 +29,13 @@
 // Headers
 ////////////////////////////////////////////////////////////
 #include <SFML/Window/Export.hpp>
+#include <SFML/System/String.hpp>
 
 
 namespace sf
 {
+class String;
+
 ////////////////////////////////////////////////////////////
 /// \brief Give access to the real-time state of the keyboard
 ///
@@ -44,6 +47,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 +168,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 +328,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
+    /// \warning The virtual keyboard is not supported on all
-    /// systems. It will typically be implemented on mobile OSes
+    ///          systems. It will typically be implemented on mobile OSes
-    /// (Android, iOS) but not on desktop OSes (Windows, Linux, ...).
+    ///          (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
+    /// \copydoc sf::Keyboard::isKeyPressed(Key)
-    ///
-    /// \param key Key to check
-    ///
-    /// \return True if the key is pressed, false otherwise
     ///
     ////////////////////////////////////////////////////////////
     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/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
+    /// By 'localized' we mean keys that depend on the keyboard layout
-    /// and might not be the same as the US keycode in some country
+    /// and might not be the same as the US keycode for some countries
-    /// (e.g. the keys 'Y' and 'Z' are switched on QWERTZ keyboard and
+    /// (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,46 @@ 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
+    /// Close all connections to any devices.
-    /// Set m_isValid to false
+    ///
+    /// \see initializeKeyboard
+    ///
+    /// \see initializeKeyboard
     ///
     ////////////////////////////////////////////////////////////
     void freeUp();
@@ -174,11 +231,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 +253,48 @@ private:
     bool isPressed(IOHIDElements& elements);
 
     ////////////////////////////////////////////////////////////
-    /// \brief Convert a HID key usage to its corresponding virtual code
+    /// \brief Convert a HID key usage to its corresponding scancode
-    ///
-    /// See IOHIDUsageTables.h
     ///
     /// \param usage Any kHIDUsage_Keyboard* usage
-    /// \return the virtual code associate with the given HID key usage
+    /// \return the scancode associate with the given HID key usage
-    ///         or 0xff if it is associate with no virtual code
+    ///         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
+    IOHIDManagerRef    m_manager;                          ///< Underlying HID Manager
-    CFDataRef         m_layoutData;                 ///< CFData containing the layout
+    IOHIDElements      m_keys[Keyboard::ScanCodeCount];    ///< All the keys on any connected keyboard
-    UCKeyboardLayout* m_layout;                     ///< Current Keyboard Layout
+    Keyboard::Scancode m_mapping[Keyboard::KeyCount];      ///< Mapping from Key to Scancode
-    IOHIDManagerRef   m_manager;                    ///< HID Manager
+    Keyboard::Key      m_gnippam[Keyboard::ScanCodeCount]; ///< Mapping from Scancode to Key
-
-    IOHIDElements     m_keys[Keyboard::KeyCount];   ///< All the keys on any connected keyboard
 
     ////////////////////////////////////////////////////////////
-    /// m_keys' index corresponds to sf::Keyboard::Key enum.
+    /// m_keys' index corresponds to sf::Keyboard::Scancode enum.
-    /// if no key is assigned with key XYZ then m_keys[XYZ].size() == 0.
+    /// 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
+    /// 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
+    /// \copydoc sf::Keyboard::isKeyPressed(Key)
-    ///
-    /// \param key Key to check
-    ///
-    /// \return True if the key is pressed, false otherwise
     ///
     ////////////////////////////////////////////////////////////
     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.code     = key;
-    event.alt     = modifiers & NSAlternateKeyMask;
+    event.scancode = code;
-    event.control = modifiers & NSControlKeyMask;
+    event.alt      = modifiers & NSAlternateKeyMask;
-    event.shift   = modifiers & NSShiftKeyMask;
+    event.control  = modifiers & NSControlKeyMask;
-    event.system  = modifiers & NSCommandKeyMask;
+    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, leftMask,  leftWasDown,  leftKey,  leftCode,  requester);
-    processOneModifier(modifiers, rightMask, rightWasDown, rightKey, 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
+    // We look for the key in a list of characters that depend on keyboard localization,
-    sf::Keyboard::Key key = sf::Keyboard::Unknown;
+    // if the key is not "dead".
-
-    // First we look if the key down is from a list of characters
-    // that depend on keyboard localization.
     NSString* string = [event charactersIgnoringModifiers];
-    if ([string length] > 0)
+    sf::Keyboard::Key key = ([string length] > 0)
-        key = sf::priv::HIDInputManager::localizedKeys([string characterAtIndex: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
+    // The scancode always depends on the hardware keyboard, not some OS setting.
-    // through virtual key code.
+    sf::Keyboard::Scancode code = sf::priv::HIDInputManager::nonLocalizedKey([event keyCode]);
-    if (key == sf::Keyboard::Unknown)
-        key = sf::priv::HIDInputManager::nonLocalizedKeys([event keyCode]);
 
-    return keyEventWithModifiers([event modifierFlags], key);
+    return keyEventWithModifiers([event modifierFlags], key, code);
 }
 
 

src/SFML/Window/Unix/InputImpl.hpp

@@ -45,19 +45,37 @@ class InputImpl
 public:
 
     ////////////////////////////////////////////////////////////
-    /// \brief Check if a key is pressed
+    /// \copydoc sf::Keyboard::isKeyPressed(Key)
-    ///
-    /// \param key Key to check
-    ///
-    /// \return True if the key is pressed, false otherwise
     ///
     ////////////////////////////////////////////////////////////
     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/Win32/InputImpl.cpp

@@ -48,113 +48,149 @@ bool InputImpl::isKeyPressed(Keyboard::Key key)
     int vkey = 0;
     switch (key)
     {
-        default:                   vkey = 0;             break;
+    default:                   vkey = 0;             break;
-        case Keyboard::A:          vkey = 'A';           break;
+    case Keyboard::A:          vkey = 'A';           break;
-        case Keyboard::B:          vkey = 'B';           break;
+    case Keyboard::B:          vkey = 'B';           break;
-        case Keyboard::C:          vkey = 'C';           break;
+    case Keyboard::C:          vkey = 'C';           break;
-        case Keyboard::D:          vkey = 'D';           break;
+    case Keyboard::D:          vkey = 'D';           break;
-        case Keyboard::E:          vkey = 'E';           break;
+    case Keyboard::E:          vkey = 'E';           break;
-        case Keyboard::F:          vkey = 'F';           break;
+    case Keyboard::F:          vkey = 'F';           break;
-        case Keyboard::G:          vkey = 'G';           break;
+    case Keyboard::G:          vkey = 'G';           break;
-        case Keyboard::H:          vkey = 'H';           break;
+    case Keyboard::H:          vkey = 'H';           break;
-        case Keyboard::I:          vkey = 'I';           break;
+    case Keyboard::I:          vkey = 'I';           break;
-        case Keyboard::J:          vkey = 'J';           break;
+    case Keyboard::J:          vkey = 'J';           break;
-        case Keyboard::K:          vkey = 'K';           break;
+    case Keyboard::K:          vkey = 'K';           break;
-        case Keyboard::L:          vkey = 'L';           break;
+    case Keyboard::L:          vkey = 'L';           break;
-        case Keyboard::M:          vkey = 'M';           break;
+    case Keyboard::M:          vkey = 'M';           break;
-        case Keyboard::N:          vkey = 'N';           break;
+    case Keyboard::N:          vkey = 'N';           break;
-        case Keyboard::O:          vkey = 'O';           break;
+    case Keyboard::O:          vkey = 'O';           break;
-        case Keyboard::P:          vkey = 'P';           break;
+    case Keyboard::P:          vkey = 'P';           break;
-        case Keyboard::Q:          vkey = 'Q';           break;
+    case Keyboard::Q:          vkey = 'Q';           break;
-        case Keyboard::R:          vkey = 'R';           break;
+    case Keyboard::R:          vkey = 'R';           break;
-        case Keyboard::S:          vkey = 'S';           break;
+    case Keyboard::S:          vkey = 'S';           break;
-        case Keyboard::T:          vkey = 'T';           break;
+    case Keyboard::T:          vkey = 'T';           break;
-        case Keyboard::U:          vkey = 'U';           break;
+    case Keyboard::U:          vkey = 'U';           break;
-        case Keyboard::V:          vkey = 'V';           break;
+    case Keyboard::V:          vkey = 'V';           break;
-        case Keyboard::W:          vkey = 'W';           break;
+    case Keyboard::W:          vkey = 'W';           break;
-        case Keyboard::X:          vkey = 'X';           break;
+    case Keyboard::X:          vkey = 'X';           break;
-        case Keyboard::Y:          vkey = 'Y';           break;
+    case Keyboard::Y:          vkey = 'Y';           break;
-        case Keyboard::Z:          vkey = 'Z';           break;
+    case Keyboard::Z:          vkey = 'Z';           break;
-        case Keyboard::Num0:       vkey = '0';           break;
+    case Keyboard::Num0:       vkey = '0';           break;
-        case Keyboard::Num1:       vkey = '1';           break;
+    case Keyboard::Num1:       vkey = '1';           break;
-        case Keyboard::Num2:       vkey = '2';           break;
+    case Keyboard::Num2:       vkey = '2';           break;
-        case Keyboard::Num3:       vkey = '3';           break;
+    case Keyboard::Num3:       vkey = '3';           break;
-        case Keyboard::Num4:       vkey = '4';           break;
+    case Keyboard::Num4:       vkey = '4';           break;
-        case Keyboard::Num5:       vkey = '5';           break;
+    case Keyboard::Num5:       vkey = '5';           break;
-        case Keyboard::Num6:       vkey = '6';           break;
+    case Keyboard::Num6:       vkey = '6';           break;
-        case Keyboard::Num7:       vkey = '7';           break;
+    case Keyboard::Num7:       vkey = '7';           break;
-        case Keyboard::Num8:       vkey = '8';           break;
+    case Keyboard::Num8:       vkey = '8';           break;
-        case Keyboard::Num9:       vkey = '9';           break;
+    case Keyboard::Num9:       vkey = '9';           break;
-        case Keyboard::Escape:     vkey = VK_ESCAPE;     break;
+    case Keyboard::Escape:     vkey = VK_ESCAPE;     break;
-        case Keyboard::LControl:   vkey = VK_LCONTROL;   break;
+    case Keyboard::LControl:   vkey = VK_LCONTROL;   break;
-        case Keyboard::LShift:     vkey = VK_LSHIFT;     break;
+    case Keyboard::LShift:     vkey = VK_LSHIFT;     break;
-        case Keyboard::LAlt:       vkey = VK_LMENU;      break;
+    case Keyboard::LAlt:       vkey = VK_LMENU;      break;
-        case Keyboard::LSystem:    vkey = VK_LWIN;       break;
+    case Keyboard::LSystem:    vkey = VK_LWIN;       break;
-        case Keyboard::RControl:   vkey = VK_RCONTROL;   break;
+    case Keyboard::RControl:   vkey = VK_RCONTROL;   break;
-        case Keyboard::RShift:     vkey = VK_RSHIFT;     break;
+    case Keyboard::RShift:     vkey = VK_RSHIFT;     break;
-        case Keyboard::RAlt:       vkey = VK_RMENU;      break;
+    case Keyboard::RAlt:       vkey = VK_RMENU;      break;
-        case Keyboard::RSystem:    vkey = VK_RWIN;       break;
+    case Keyboard::RSystem:    vkey = VK_RWIN;       break;
-        case Keyboard::Menu:       vkey = VK_APPS;       break;
+    case Keyboard::Menu:       vkey = VK_APPS;       break;
-        case Keyboard::LBracket:   vkey = VK_OEM_4;      break;
+    case Keyboard::LBracket:   vkey = VK_OEM_4;      break;
-        case Keyboard::RBracket:   vkey = VK_OEM_6;      break;
+    case Keyboard::RBracket:   vkey = VK_OEM_6;      break;
-        case Keyboard::Semicolon:  vkey = VK_OEM_1;      break;
+    case Keyboard::SemiColon:  vkey = VK_OEM_1;      break;
-        case Keyboard::Comma:      vkey = VK_OEM_COMMA;  break;
+    case Keyboard::Comma:      vkey = VK_OEM_COMMA;  break;
-        case Keyboard::Period:     vkey = VK_OEM_PERIOD; break;
+    case Keyboard::Period:     vkey = VK_OEM_PERIOD; break;
-        case Keyboard::Quote:      vkey = VK_OEM_7;      break;
+    case Keyboard::Quote:      vkey = VK_OEM_7;      break;
-        case Keyboard::Slash:      vkey = VK_OEM_2;      break;
+    case Keyboard::Slash:      vkey = VK_OEM_2;      break;
-        case Keyboard::Backslash:  vkey = VK_OEM_5;      break;
+    case Keyboard::BackSlash:  vkey = VK_OEM_5;      break;
-        case Keyboard::Tilde:      vkey = VK_OEM_3;      break;
+    case Keyboard::Tilde:      vkey = VK_OEM_3;      break;
-        case Keyboard::Equal:      vkey = VK_OEM_PLUS;   break;
+    case Keyboard::Equal:      vkey = VK_OEM_PLUS;   break;
-        case Keyboard::Hyphen:     vkey = VK_OEM_MINUS;  break;
+    case Keyboard::Dash:       vkey = VK_OEM_MINUS;  break;
-        case Keyboard::Space:      vkey = VK_SPACE;      break;
+    case Keyboard::Space:      vkey = VK_SPACE;      break;
-        case Keyboard::Enter:      vkey = VK_RETURN;     break;
+    case Keyboard::Return:     vkey = VK_RETURN;     break;
-        case Keyboard::Backspace:  vkey = VK_BACK;       break;
+    case Keyboard::BackSpace:  vkey = VK_BACK;       break;
-        case Keyboard::Tab:        vkey = VK_TAB;        break;
+    case Keyboard::Tab:        vkey = VK_TAB;        break;
-        case Keyboard::PageUp:     vkey = VK_PRIOR;      break;
+    case Keyboard::PageUp:     vkey = VK_PRIOR;      break;
-        case Keyboard::PageDown:   vkey = VK_NEXT;       break;
+    case Keyboard::PageDown:   vkey = VK_NEXT;       break;
-        case Keyboard::End:        vkey = VK_END;        break;
+    case Keyboard::End:        vkey = VK_END;        break;
-        case Keyboard::Home:       vkey = VK_HOME;       break;
+    case Keyboard::Home:       vkey = VK_HOME;       break;
-        case Keyboard::Insert:     vkey = VK_INSERT;     break;
+    case Keyboard::Insert:     vkey = VK_INSERT;     break;
-        case Keyboard::Delete:     vkey = VK_DELETE;     break;
+    case Keyboard::Delete:     vkey = VK_DELETE;     break;
-        case Keyboard::Add:        vkey = VK_ADD;        break;
+    case Keyboard::Add:        vkey = VK_ADD;        break;
-        case Keyboard::Subtract:   vkey = VK_SUBTRACT;   break;
+    case Keyboard::Subtract:   vkey = VK_SUBTRACT;   break;
-        case Keyboard::Multiply:   vkey = VK_MULTIPLY;   break;
+    case Keyboard::Multiply:   vkey = VK_MULTIPLY;   break;
-        case Keyboard::Divide:     vkey = VK_DIVIDE;     break;
+    case Keyboard::Divide:     vkey = VK_DIVIDE;     break;
-        case Keyboard::Left:       vkey = VK_LEFT;       break;
+    case Keyboard::Left:       vkey = VK_LEFT;       break;
-        case Keyboard::Right:      vkey = VK_RIGHT;      break;
+    case Keyboard::Right:      vkey = VK_RIGHT;      break;
-        case Keyboard::Up:         vkey = VK_UP;         break;
+    case Keyboard::Up:         vkey = VK_UP;         break;
-        case Keyboard::Down:       vkey = VK_DOWN;       break;
+    case Keyboard::Down:       vkey = VK_DOWN;       break;
-        case Keyboard::Numpad0:    vkey = VK_NUMPAD0;    break;
+    case Keyboard::Numpad0:    vkey = VK_NUMPAD0;    break;
-        case Keyboard::Numpad1:    vkey = VK_NUMPAD1;    break;
+    case Keyboard::Numpad1:    vkey = VK_NUMPAD1;    break;
-        case Keyboard::Numpad2:    vkey = VK_NUMPAD2;    break;
+    case Keyboard::Numpad2:    vkey = VK_NUMPAD2;    break;
-        case Keyboard::Numpad3:    vkey = VK_NUMPAD3;    break;
+    case Keyboard::Numpad3:    vkey = VK_NUMPAD3;    break;
-        case Keyboard::Numpad4:    vkey = VK_NUMPAD4;    break;
+    case Keyboard::Numpad4:    vkey = VK_NUMPAD4;    break;
-        case Keyboard::Numpad5:    vkey = VK_NUMPAD5;    break;
+    case Keyboard::Numpad5:    vkey = VK_NUMPAD5;    break;
-        case Keyboard::Numpad6:    vkey = VK_NUMPAD6;    break;
+    case Keyboard::Numpad6:    vkey = VK_NUMPAD6;    break;
-        case Keyboard::Numpad7:    vkey = VK_NUMPAD7;    break;
+    case Keyboard::Numpad7:    vkey = VK_NUMPAD7;    break;
-        case Keyboard::Numpad8:    vkey = VK_NUMPAD8;    break;
+    case Keyboard::Numpad8:    vkey = VK_NUMPAD8;    break;
-        case Keyboard::Numpad9:    vkey = VK_NUMPAD9;    break;
+    case Keyboard::Numpad9:    vkey = VK_NUMPAD9;    break;
-        case Keyboard::F1:         vkey = VK_F1;         break;
+    case Keyboard::F1:         vkey = VK_F1;         break;
-        case Keyboard::F2:         vkey = VK_F2;         break;
+    case Keyboard::F2:         vkey = VK_F2;         break;
-        case Keyboard::F3:         vkey = VK_F3;         break;
+    case Keyboard::F3:         vkey = VK_F3;         break;
-        case Keyboard::F4:         vkey = VK_F4;         break;
+    case Keyboard::F4:         vkey = VK_F4;         break;
-        case Keyboard::F5:         vkey = VK_F5;         break;
+    case Keyboard::F5:         vkey = VK_F5;         break;
-        case Keyboard::F6:         vkey = VK_F6;         break;
+    case Keyboard::F6:         vkey = VK_F6;         break;
-        case Keyboard::F7:         vkey = VK_F7;         break;
+    case Keyboard::F7:         vkey = VK_F7;         break;
-        case Keyboard::F8:         vkey = VK_F8;         break;
+    case Keyboard::F8:         vkey = VK_F8;         break;
-        case Keyboard::F9:         vkey = VK_F9;         break;
+    case Keyboard::F9:         vkey = VK_F9;         break;
-        case Keyboard::F10:        vkey = VK_F10;        break;
+    case Keyboard::F10:        vkey = VK_F10;        break;
-        case Keyboard::F11:        vkey = VK_F11;        break;
+    case Keyboard::F11:        vkey = VK_F11;        break;
-        case Keyboard::F12:        vkey = VK_F12;        break;
+    case Keyboard::F12:        vkey = VK_F12;        break;
-        case Keyboard::F13:        vkey = VK_F13;        break;
+    case Keyboard::F13:        vkey = VK_F13;        break;
-        case Keyboard::F14:        vkey = VK_F14;        break;
+    case Keyboard::F14:        vkey = VK_F14;        break;
-        case Keyboard::F15:        vkey = VK_F15;        break;
+    case Keyboard::F15:        vkey = VK_F15;        break;
-        case Keyboard::Pause:      vkey = VK_PAUSE;      break;
+    case Keyboard::Pause:      vkey = VK_PAUSE;      break;
     }
 
     return (GetAsyncKeyState(vkey) & 0x8000) != 0;
 }
 
+////////////////////////////////////////////////////////////
+bool InputImpl::isKeyPressed(Keyboard::Scancode code)
+{
+    auto winCode = sfScanToWin(code);
+    auto vkey = MapVirtualKey(winCode, MAPVK_VSC_TO_VK_EX);
+    auto state = GetAsyncKeyState(vkey);
+    return (state & 0x8000) != 0;
+}
+
+////////////////////////////////////////////////////////////
+Keyboard::Key InputImpl::localize(Keyboard::Scancode code)
+{
+    // TODO
+    return sf::Keyboard::Unknown;
+}
+
+////////////////////////////////////////////////////////////
+Keyboard::Scancode InputImpl::unlocalize(Keyboard::Key code)
+{
+    // TODO
+    return sf::Keyboard::ScanUnknown;
+}
+
+////////////////////////////////////////////////////////////
+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)
@@ -251,6 +287,148 @@ Vector2i InputImpl::getTouchPosition(unsigned int /*finger*/, const WindowBase&
     return Vector2i();
 }
 
+////////////////////////////////////////////////////////////
+WORD InputImpl::sfScanToWin(Keyboard::Scancode code)
+{
+    // Windows scan codes
+    // 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?
+    }
+}
+
 } // namespace priv
 
 } // namespace sf

src/SFML/Window/Win32/InputImpl.hpp

@@ -31,6 +31,7 @@
 #include <SFML/Window/Keyboard.hpp>
 #include <SFML/Window/Mouse.hpp>
 
+#include <windows.h>
 
 namespace sf
 {
@@ -45,19 +46,37 @@ class InputImpl
 public:
 
     ////////////////////////////////////////////////////////////
-    /// \brief Check if a key is pressed
+    /// \copydoc sf::Keyboard::isKeyPressed(Key)
-    ///
-    /// \param key Key to check
-    ///
-    /// \return True if the key is pressed, false otherwise
     ///
     ////////////////////////////////////////////////////////////
     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 +177,10 @@ public:
     ///
     ////////////////////////////////////////////////////////////
     static Vector2i getTouchPosition(unsigned int finger, const WindowBase& relativeTo);
+
+    private:
+
+    static WORD sfScanToWin(Keyboard::Scancode code);
 };
 
 } // 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)
@@ -726,12 +827,13 @@ void WindowImplWin32::processEvent(UINT message, WPARAM wParam, LPARAM lParam)
             if (m_keyRepeatEnabled || ((HIWORD(lParam) & KF_REPEAT) == 0))
             {
                 Event event;
-                event.type        = Event::KeyPressed;
+                event.type         = Event::KeyPressed;
-                event.key.alt     = HIWORD(GetKeyState(VK_MENU))    != 0;
+                event.key.alt      = HIWORD(GetKeyState(VK_MENU))    != 0;
-                event.key.control = HIWORD(GetKeyState(VK_CONTROL)) != 0;
+                event.key.control  = HIWORD(GetKeyState(VK_CONTROL)) != 0;
-                event.key.shift   = HIWORD(GetKeyState(VK_SHIFT))   != 0;
+                event.key.shift    = HIWORD(GetKeyState(VK_SHIFT))   != 0;
-                event.key.system  = HIWORD(GetKeyState(VK_LWIN)) || HIWORD(GetKeyState(VK_RWIN));
+                event.key.system   = HIWORD(GetKeyState(VK_LWIN)) || HIWORD(GetKeyState(VK_RWIN));
-                event.key.code    = virtualKeyCodeToSF(wParam, lParam);
+                event.key.scancode = toScancode(lParam);
+                event.key.code     = virtualKeyCodeToSF(wParam, lParam);
                 pushEvent(event);
             }
             break;
@@ -742,12 +844,13 @@ void WindowImplWin32::processEvent(UINT message, WPARAM wParam, LPARAM lParam)
         case WM_SYSKEYUP:
         {
             Event event;
-            event.type        = Event::KeyReleased;
+            event.type         = Event::KeyReleased;
-            event.key.alt     = HIWORD(GetKeyState(VK_MENU))    != 0;
+            event.key.alt      = HIWORD(GetKeyState(VK_MENU))    != 0;
-            event.key.control = HIWORD(GetKeyState(VK_CONTROL)) != 0;
+            event.key.control  = HIWORD(GetKeyState(VK_CONTROL)) != 0;
-            event.key.shift   = HIWORD(GetKeyState(VK_SHIFT))   != 0;
+            event.key.shift    = HIWORD(GetKeyState(VK_SHIFT))   != 0;
-            event.key.system  = HIWORD(GetKeyState(VK_LWIN)) || HIWORD(GetKeyState(VK_RWIN));
+            event.key.system   = HIWORD(GetKeyState(VK_LWIN)) || HIWORD(GetKeyState(VK_RWIN));
-            event.key.code    = virtualKeyCodeToSF(wParam, lParam);
+            event.key.scancode = toScancode(lParam);
+            event.key.code     = virtualKeyCodeToSF(wParam, lParam);
             pushEvent(event);
             break;
         }

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
+    /// \copydoc sf::Keyboard::isKeyPressed(Key)
-    ///
-    /// \param key Key to check
-    ///
-    /// \return True if the key is pressed, false otherwise
     ///
     ////////////////////////////////////////////////////////////
     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);