Compare commits
11 commits
master
...
feature/sc
| Author | SHA1 | Date | |
|---|---|---|---|
|
f0066f2aff | ||
|
|
fdeb89a191 | ||
|
|
950d10c49f | ||
|
|
7f9bca43c5 | ||
|
|
188aaae7a1 | ||
|
|
e1380f182a | ||
|
|
6c8544413f | ||
|
|
cf3752ce77 | ||
|
|
7a99260ead | ||
|
|
9dc7f3dc79 | ||
|
|
e122972832 |
|
|
@ -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, or Unknown
|
||||
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?
|
||||
};
|
||||
|
||||
////////////////////////////////////////////////////////////
|
||||
|
|
|
|||
|
|
@ -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
|
||||
/// 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.
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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,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
|
||||
/// Set m_isValid to false
|
||||
/// Close all connections to any devices.
|
||||
///
|
||||
/// \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
|
||||
///
|
||||
/// 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_mapping[Keyboard::KeyCount]; ///< Mapping from Key to Scancode
|
||||
Keyboard::Key m_gnippam[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.
|
||||
///
|
||||
////////////////////////////////////////////////////////////
|
||||
};
|
||||
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -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*/)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
|
|
@ -48,113 +48,149 @@ bool InputImpl::isKeyPressed(Keyboard::Key key)
|
|||
int vkey = 0;
|
||||
switch (key)
|
||||
{
|
||||
default: vkey = 0; break;
|
||||
case Keyboard::A: vkey = 'A'; break;
|
||||
case Keyboard::B: vkey = 'B'; break;
|
||||
case Keyboard::C: vkey = 'C'; break;
|
||||
case Keyboard::D: vkey = 'D'; break;
|
||||
case Keyboard::E: vkey = 'E'; break;
|
||||
case Keyboard::F: vkey = 'F'; break;
|
||||
case Keyboard::G: vkey = 'G'; break;
|
||||
case Keyboard::H: vkey = 'H'; break;
|
||||
case Keyboard::I: vkey = 'I'; break;
|
||||
case Keyboard::J: vkey = 'J'; break;
|
||||
case Keyboard::K: vkey = 'K'; break;
|
||||
case Keyboard::L: vkey = 'L'; break;
|
||||
case Keyboard::M: vkey = 'M'; break;
|
||||
case Keyboard::N: vkey = 'N'; break;
|
||||
case Keyboard::O: vkey = 'O'; break;
|
||||
case Keyboard::P: vkey = 'P'; break;
|
||||
case Keyboard::Q: vkey = 'Q'; break;
|
||||
case Keyboard::R: vkey = 'R'; break;
|
||||
case Keyboard::S: vkey = 'S'; break;
|
||||
case Keyboard::T: vkey = 'T'; break;
|
||||
case Keyboard::U: vkey = 'U'; break;
|
||||
case Keyboard::V: vkey = 'V'; break;
|
||||
case Keyboard::W: vkey = 'W'; break;
|
||||
case Keyboard::X: vkey = 'X'; break;
|
||||
case Keyboard::Y: vkey = 'Y'; break;
|
||||
case Keyboard::Z: vkey = 'Z'; break;
|
||||
case Keyboard::Num0: vkey = '0'; break;
|
||||
case Keyboard::Num1: vkey = '1'; break;
|
||||
case Keyboard::Num2: vkey = '2'; break;
|
||||
case Keyboard::Num3: vkey = '3'; break;
|
||||
case Keyboard::Num4: vkey = '4'; break;
|
||||
case Keyboard::Num5: vkey = '5'; break;
|
||||
case Keyboard::Num6: vkey = '6'; break;
|
||||
case Keyboard::Num7: vkey = '7'; break;
|
||||
case Keyboard::Num8: vkey = '8'; break;
|
||||
case Keyboard::Num9: vkey = '9'; break;
|
||||
case Keyboard::Escape: vkey = VK_ESCAPE; break;
|
||||
case Keyboard::LControl: vkey = VK_LCONTROL; break;
|
||||
case Keyboard::LShift: vkey = VK_LSHIFT; break;
|
||||
case Keyboard::LAlt: vkey = VK_LMENU; break;
|
||||
case Keyboard::LSystem: vkey = VK_LWIN; break;
|
||||
case Keyboard::RControl: vkey = VK_RCONTROL; break;
|
||||
case Keyboard::RShift: vkey = VK_RSHIFT; break;
|
||||
case Keyboard::RAlt: vkey = VK_RMENU; break;
|
||||
case Keyboard::RSystem: vkey = VK_RWIN; break;
|
||||
case Keyboard::Menu: vkey = VK_APPS; break;
|
||||
case Keyboard::LBracket: vkey = VK_OEM_4; break;
|
||||
case Keyboard::RBracket: vkey = VK_OEM_6; break;
|
||||
case Keyboard::Semicolon: vkey = VK_OEM_1; break;
|
||||
case Keyboard::Comma: vkey = VK_OEM_COMMA; break;
|
||||
case Keyboard::Period: vkey = VK_OEM_PERIOD; break;
|
||||
case Keyboard::Quote: vkey = VK_OEM_7; break;
|
||||
case Keyboard::Slash: vkey = VK_OEM_2; break;
|
||||
case Keyboard::Backslash: vkey = VK_OEM_5; break;
|
||||
case Keyboard::Tilde: vkey = VK_OEM_3; break;
|
||||
case Keyboard::Equal: vkey = VK_OEM_PLUS; break;
|
||||
case Keyboard::Hyphen: vkey = VK_OEM_MINUS; break;
|
||||
case Keyboard::Space: vkey = VK_SPACE; break;
|
||||
case Keyboard::Enter: vkey = VK_RETURN; break;
|
||||
case Keyboard::Backspace: vkey = VK_BACK; break;
|
||||
case Keyboard::Tab: vkey = VK_TAB; break;
|
||||
case Keyboard::PageUp: vkey = VK_PRIOR; break;
|
||||
case Keyboard::PageDown: vkey = VK_NEXT; break;
|
||||
case Keyboard::End: vkey = VK_END; break;
|
||||
case Keyboard::Home: vkey = VK_HOME; break;
|
||||
case Keyboard::Insert: vkey = VK_INSERT; break;
|
||||
case Keyboard::Delete: vkey = VK_DELETE; break;
|
||||
case Keyboard::Add: vkey = VK_ADD; break;
|
||||
case Keyboard::Subtract: vkey = VK_SUBTRACT; break;
|
||||
case Keyboard::Multiply: vkey = VK_MULTIPLY; break;
|
||||
case Keyboard::Divide: vkey = VK_DIVIDE; break;
|
||||
case Keyboard::Left: vkey = VK_LEFT; break;
|
||||
case Keyboard::Right: vkey = VK_RIGHT; break;
|
||||
case Keyboard::Up: vkey = VK_UP; break;
|
||||
case Keyboard::Down: vkey = VK_DOWN; break;
|
||||
case Keyboard::Numpad0: vkey = VK_NUMPAD0; break;
|
||||
case Keyboard::Numpad1: vkey = VK_NUMPAD1; break;
|
||||
case Keyboard::Numpad2: vkey = VK_NUMPAD2; break;
|
||||
case Keyboard::Numpad3: vkey = VK_NUMPAD3; break;
|
||||
case Keyboard::Numpad4: vkey = VK_NUMPAD4; break;
|
||||
case Keyboard::Numpad5: vkey = VK_NUMPAD5; break;
|
||||
case Keyboard::Numpad6: vkey = VK_NUMPAD6; break;
|
||||
case Keyboard::Numpad7: vkey = VK_NUMPAD7; break;
|
||||
case Keyboard::Numpad8: vkey = VK_NUMPAD8; break;
|
||||
case Keyboard::Numpad9: vkey = VK_NUMPAD9; break;
|
||||
case Keyboard::F1: vkey = VK_F1; break;
|
||||
case Keyboard::F2: vkey = VK_F2; break;
|
||||
case Keyboard::F3: vkey = VK_F3; break;
|
||||
case Keyboard::F4: vkey = VK_F4; break;
|
||||
case Keyboard::F5: vkey = VK_F5; break;
|
||||
case Keyboard::F6: vkey = VK_F6; break;
|
||||
case Keyboard::F7: vkey = VK_F7; break;
|
||||
case Keyboard::F8: vkey = VK_F8; break;
|
||||
case Keyboard::F9: vkey = VK_F9; break;
|
||||
case Keyboard::F10: vkey = VK_F10; break;
|
||||
case Keyboard::F11: vkey = VK_F11; break;
|
||||
case Keyboard::F12: vkey = VK_F12; break;
|
||||
case Keyboard::F13: vkey = VK_F13; break;
|
||||
case Keyboard::F14: vkey = VK_F14; break;
|
||||
case Keyboard::F15: vkey = VK_F15; break;
|
||||
case Keyboard::Pause: vkey = VK_PAUSE; break;
|
||||
default: vkey = 0; break;
|
||||
case Keyboard::A: vkey = 'A'; break;
|
||||
case Keyboard::B: vkey = 'B'; break;
|
||||
case Keyboard::C: vkey = 'C'; break;
|
||||
case Keyboard::D: vkey = 'D'; break;
|
||||
case Keyboard::E: vkey = 'E'; break;
|
||||
case Keyboard::F: vkey = 'F'; break;
|
||||
case Keyboard::G: vkey = 'G'; break;
|
||||
case Keyboard::H: vkey = 'H'; break;
|
||||
case Keyboard::I: vkey = 'I'; break;
|
||||
case Keyboard::J: vkey = 'J'; break;
|
||||
case Keyboard::K: vkey = 'K'; break;
|
||||
case Keyboard::L: vkey = 'L'; break;
|
||||
case Keyboard::M: vkey = 'M'; break;
|
||||
case Keyboard::N: vkey = 'N'; break;
|
||||
case Keyboard::O: vkey = 'O'; break;
|
||||
case Keyboard::P: vkey = 'P'; break;
|
||||
case Keyboard::Q: vkey = 'Q'; break;
|
||||
case Keyboard::R: vkey = 'R'; break;
|
||||
case Keyboard::S: vkey = 'S'; break;
|
||||
case Keyboard::T: vkey = 'T'; break;
|
||||
case Keyboard::U: vkey = 'U'; break;
|
||||
case Keyboard::V: vkey = 'V'; break;
|
||||
case Keyboard::W: vkey = 'W'; break;
|
||||
case Keyboard::X: vkey = 'X'; break;
|
||||
case Keyboard::Y: vkey = 'Y'; break;
|
||||
case Keyboard::Z: vkey = 'Z'; break;
|
||||
case Keyboard::Num0: vkey = '0'; break;
|
||||
case Keyboard::Num1: vkey = '1'; break;
|
||||
case Keyboard::Num2: vkey = '2'; break;
|
||||
case Keyboard::Num3: vkey = '3'; break;
|
||||
case Keyboard::Num4: vkey = '4'; break;
|
||||
case Keyboard::Num5: vkey = '5'; break;
|
||||
case Keyboard::Num6: vkey = '6'; break;
|
||||
case Keyboard::Num7: vkey = '7'; break;
|
||||
case Keyboard::Num8: vkey = '8'; break;
|
||||
case Keyboard::Num9: vkey = '9'; break;
|
||||
case Keyboard::Escape: vkey = VK_ESCAPE; break;
|
||||
case Keyboard::LControl: vkey = VK_LCONTROL; break;
|
||||
case Keyboard::LShift: vkey = VK_LSHIFT; break;
|
||||
case Keyboard::LAlt: vkey = VK_LMENU; break;
|
||||
case Keyboard::LSystem: vkey = VK_LWIN; break;
|
||||
case Keyboard::RControl: vkey = VK_RCONTROL; break;
|
||||
case Keyboard::RShift: vkey = VK_RSHIFT; break;
|
||||
case Keyboard::RAlt: vkey = VK_RMENU; break;
|
||||
case Keyboard::RSystem: vkey = VK_RWIN; break;
|
||||
case Keyboard::Menu: vkey = VK_APPS; break;
|
||||
case Keyboard::LBracket: vkey = VK_OEM_4; break;
|
||||
case Keyboard::RBracket: vkey = VK_OEM_6; break;
|
||||
case Keyboard::SemiColon: vkey = VK_OEM_1; break;
|
||||
case Keyboard::Comma: vkey = VK_OEM_COMMA; break;
|
||||
case Keyboard::Period: vkey = VK_OEM_PERIOD; break;
|
||||
case Keyboard::Quote: vkey = VK_OEM_7; break;
|
||||
case Keyboard::Slash: vkey = VK_OEM_2; break;
|
||||
case Keyboard::BackSlash: vkey = VK_OEM_5; break;
|
||||
case Keyboard::Tilde: vkey = VK_OEM_3; break;
|
||||
case Keyboard::Equal: vkey = VK_OEM_PLUS; break;
|
||||
case Keyboard::Dash: vkey = VK_OEM_MINUS; break;
|
||||
case Keyboard::Space: vkey = VK_SPACE; break;
|
||||
case Keyboard::Return: vkey = VK_RETURN; break;
|
||||
case Keyboard::BackSpace: vkey = VK_BACK; break;
|
||||
case Keyboard::Tab: vkey = VK_TAB; break;
|
||||
case Keyboard::PageUp: vkey = VK_PRIOR; break;
|
||||
case Keyboard::PageDown: vkey = VK_NEXT; break;
|
||||
case Keyboard::End: vkey = VK_END; break;
|
||||
case Keyboard::Home: vkey = VK_HOME; break;
|
||||
case Keyboard::Insert: vkey = VK_INSERT; break;
|
||||
case Keyboard::Delete: vkey = VK_DELETE; break;
|
||||
case Keyboard::Add: vkey = VK_ADD; break;
|
||||
case Keyboard::Subtract: vkey = VK_SUBTRACT; break;
|
||||
case Keyboard::Multiply: vkey = VK_MULTIPLY; break;
|
||||
case Keyboard::Divide: vkey = VK_DIVIDE; break;
|
||||
case Keyboard::Left: vkey = VK_LEFT; break;
|
||||
case Keyboard::Right: vkey = VK_RIGHT; break;
|
||||
case Keyboard::Up: vkey = VK_UP; break;
|
||||
case Keyboard::Down: vkey = VK_DOWN; break;
|
||||
case Keyboard::Numpad0: vkey = VK_NUMPAD0; break;
|
||||
case Keyboard::Numpad1: vkey = VK_NUMPAD1; break;
|
||||
case Keyboard::Numpad2: vkey = VK_NUMPAD2; break;
|
||||
case Keyboard::Numpad3: vkey = VK_NUMPAD3; break;
|
||||
case Keyboard::Numpad4: vkey = VK_NUMPAD4; break;
|
||||
case Keyboard::Numpad5: vkey = VK_NUMPAD5; break;
|
||||
case Keyboard::Numpad6: vkey = VK_NUMPAD6; break;
|
||||
case Keyboard::Numpad7: vkey = VK_NUMPAD7; break;
|
||||
case Keyboard::Numpad8: vkey = VK_NUMPAD8; break;
|
||||
case Keyboard::Numpad9: vkey = VK_NUMPAD9; break;
|
||||
case Keyboard::F1: vkey = VK_F1; break;
|
||||
case Keyboard::F2: vkey = VK_F2; break;
|
||||
case Keyboard::F3: vkey = VK_F3; break;
|
||||
case Keyboard::F4: vkey = VK_F4; break;
|
||||
case Keyboard::F5: vkey = VK_F5; break;
|
||||
case Keyboard::F6: vkey = VK_F6; break;
|
||||
case Keyboard::F7: vkey = VK_F7; break;
|
||||
case Keyboard::F8: vkey = VK_F8; break;
|
||||
case Keyboard::F9: vkey = VK_F9; break;
|
||||
case Keyboard::F10: vkey = VK_F10; break;
|
||||
case Keyboard::F11: vkey = VK_F11; break;
|
||||
case Keyboard::F12: vkey = VK_F12; break;
|
||||
case Keyboard::F13: vkey = VK_F13; break;
|
||||
case Keyboard::F14: vkey = VK_F14; break;
|
||||
case Keyboard::F15: vkey = VK_F15; 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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
///
|
||||
/// \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 +177,10 @@ public:
|
|||
///
|
||||
////////////////////////////////////////////////////////////
|
||||
static Vector2i getTouchPosition(unsigned int finger, const WindowBase& relativeTo);
|
||||
|
||||
private:
|
||||
|
||||
static WORD sfScanToWin(Keyboard::Scancode code);
|
||||
};
|
||||
|
||||
} // namespace priv
|
||||
|
|
|
|||
127
src/SFML/Window/Win32/WindowImplWin32.cpp
Executable file → Normal file
127
src/SFML/Window/Win32/WindowImplWin32.cpp
Executable file → Normal file
|
|
@ -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.key.alt = HIWORD(GetKeyState(VK_MENU)) != 0;
|
||||
event.key.control = HIWORD(GetKeyState(VK_CONTROL)) != 0;
|
||||
event.key.shift = HIWORD(GetKeyState(VK_SHIFT)) != 0;
|
||||
event.key.system = HIWORD(GetKeyState(VK_LWIN)) || HIWORD(GetKeyState(VK_RWIN));
|
||||
event.key.code = virtualKeyCodeToSF(wParam, lParam);
|
||||
event.type = Event::KeyPressed;
|
||||
event.key.alt = HIWORD(GetKeyState(VK_MENU)) != 0;
|
||||
event.key.control = HIWORD(GetKeyState(VK_CONTROL)) != 0;
|
||||
event.key.shift = HIWORD(GetKeyState(VK_SHIFT)) != 0;
|
||||
event.key.system = HIWORD(GetKeyState(VK_LWIN)) || HIWORD(GetKeyState(VK_RWIN));
|
||||
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.key.alt = HIWORD(GetKeyState(VK_MENU)) != 0;
|
||||
event.key.control = HIWORD(GetKeyState(VK_CONTROL)) != 0;
|
||||
event.key.shift = HIWORD(GetKeyState(VK_SHIFT)) != 0;
|
||||
event.key.system = HIWORD(GetKeyState(VK_LWIN)) || HIWORD(GetKeyState(VK_RWIN));
|
||||
event.key.code = virtualKeyCodeToSF(wParam, lParam);
|
||||
event.type = Event::KeyReleased;
|
||||
event.key.alt = HIWORD(GetKeyState(VK_MENU)) != 0;
|
||||
event.key.control = HIWORD(GetKeyState(VK_CONTROL)) != 0;
|
||||
event.key.shift = HIWORD(GetKeyState(VK_SHIFT)) != 0;
|
||||
event.key.system = HIWORD(GetKeyState(VK_LWIN)) || HIWORD(GetKeyState(VK_RWIN));
|
||||
event.key.scancode = toScancode(lParam);
|
||||
event.key.code = virtualKeyCodeToSF(wParam, lParam);
|
||||
pushEvent(event);
|
||||
break;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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
|
||||
////////////////////////////////////////////////////////////
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
|
|
|
|||
Loading…
Reference in a new issue