/**
* @brief Check call to SDL_GetKeyFromScancode
*
* @sa http://wiki.libsdl.org/moin.cgi/SDL_GetKeyFromScancode
*/
int
keyboard_getKeyFromScancode(void *arg)
{
SDL_Keycode result;
/* Case where input is valid */
result = SDL_GetKeyFromScancode(SDL_SCANCODE_A);
SDLTest_AssertPass("Call to SDL_GetKeyFromScancode(valid)");
SDLTest_AssertCheck(result == SDLK_a, "Verify result from call, expected: %i, got: %i", SDLK_a, result);
/* Case where input is zero */
result = SDL_GetKeyFromScancode(0);
SDLTest_AssertPass("Call to SDL_GetKeyFromScancode(0)");
SDLTest_AssertCheck(result == SDLK_UNKNOWN, "Verify result from call is UNKNOWN, expected: %i, got: %i", SDLK_UNKNOWN, result);
/* Clear error message */
SDL_ClearError();
SDLTest_AssertPass("Call to SDL_ClearError()");
/* Case where input is invalid (too small) */
result = SDL_GetKeyFromScancode(-999);
SDLTest_AssertPass("Call to SDL_GetKeyFromScancode(-999)");
SDLTest_AssertCheck(result == SDLK_UNKNOWN, "Verify result from call is UNKNOWN, expected: %i, got: %i", SDLK_UNKNOWN, result);
_checkInvalidScancodeError();
/* Case where input is invalid (too big) */
result = SDL_GetKeyFromScancode(999);
SDLTest_AssertPass("Call to SDL_GetKeyFromScancode(999)");
SDLTest_AssertCheck(result == SDLK_UNKNOWN, "Verify result from call is UNKNOWN, expected: %i, got: %i", SDLK_UNKNOWN, result);
_checkInvalidScancodeError();
return TEST_COMPLETED;
}
void SetDefaultKeyMap(DefaultMaps dmap, bool replace) {
switch (dmap) {
case DEFAULT_MAPPING_KEYBOARD:
{
bool azerty = false;
bool qwertz = false;
#if defined(SDL)
char q, w, y;
q = SDL_GetKeyFromScancode(SDL_SCANCODE_Q);
w = SDL_GetKeyFromScancode(SDL_SCANCODE_W);
y = SDL_GetKeyFromScancode(SDL_SCANCODE_Y);
if (q == 'a' && w == 'z' && y == 'y')
azerty = true;
else if (q == 'q' && w == 'w' && y == 'z')
qwertz = true;
#elif defined(USING_WIN_UI)
HKL localeId = GetKeyboardLayout(0);
// TODO: Is this list complete enough?
switch ((int)(intptr_t)localeId & 0xFFFF) {
case 0x407:
qwertz = true;
break;
case 0x040c:
case 0x080c:
case 0x1009:
azerty = true;
break;
default:
break;
}
#endif
if (azerty) {
SetDefaultKeyMap(DEVICE_ID_KEYBOARD, defaultAzertyKeyboardKeyMap, ARRAY_SIZE(defaultAzertyKeyboardKeyMap), replace);
} else if (qwertz) {
SetDefaultKeyMap(DEVICE_ID_KEYBOARD, defaultQwertzKeyboardKeyMap, ARRAY_SIZE(defaultQwertzKeyboardKeyMap), replace);
} else {
SetDefaultKeyMap(DEVICE_ID_KEYBOARD, defaultQwertyKeyboardKeyMap, ARRAY_SIZE(defaultQwertyKeyboardKeyMap), replace);
}
}
break;
case DEFAULT_MAPPING_X360:
SetDefaultKeyMap(DEVICE_ID_X360_0, default360KeyMap, ARRAY_SIZE(default360KeyMap), replace);
break;
case DEFAULT_MAPPING_SHIELD:
SetDefaultKeyMap(DEVICE_ID_PAD_0, defaultShieldKeyMap, ARRAY_SIZE(defaultShieldKeyMap), replace);
break;
case DEFAULT_MAPPING_PAD:
SetDefaultKeyMap(DEVICE_ID_PAD_0, defaultPadMap, ARRAY_SIZE(defaultPadMap), replace);
break;
case DEFAULT_MAPPING_OUYA:
SetDefaultKeyMap(DEVICE_ID_PAD_0, defaultOuyaMap, ARRAY_SIZE(defaultOuyaMap), replace);
break;
case DEFAULT_MAPPING_XPERIA_PLAY:
SetDefaultKeyMap(DEVICE_ID_DEFAULT, defaultXperiaPlay, ARRAY_SIZE(defaultXperiaPlay), replace);
break;
}
UpdateNativeMenuKeys();
}
void mw2_Input::CheckDevices()
{
SDL_Event ev;
while (SDL_PollEvent(&ev) == 1)
{
switch (ev.type)
{
case SDL_QUIT:
mw2_Application::Exit();
break;
case SDL_KEYDOWN:
mKeysValue[ SDL_GetKeyFromScancode(ev.key.keysym.scancode) ] = 3;
break;
case SDL_KEYUP:
mKeysValue[ SDL_GetKeyFromScancode(ev.key.keysym.scancode) ] = 0;
break;
case SDL_MOUSEBUTTONDOWN:
mButtonsValue[ ev.button.button ] = 3;
break;
case SDL_MOUSEBUTTONUP:
mButtonsValue[ ev.button.button ] = 0;
break;
case SDL_MOUSEMOTION:
mMousePosition->x = ev.motion.x;
mMousePosition->y = ev.motion.y;
break;
}
}
// update keys
for (int i = 0; i < sizeof(KEYS) / sizeof(*KEYS); i++)
{
if (mKeysValue[KEYS[i]] == 3)
{
mKeysValue[KEYS[i]] = 2;
}
else if (mKeysValue[KEYS[i]] == 2)
{
mKeysValue[KEYS[i]] = 1;
}
}
// update buttons
for (int i = 0; i < sizeof(BUTTONS) / sizeof(*BUTTONS); i++)
{
if (mButtonsValue[BUTTONS[i]] == 3)
{
mButtonsValue[BUTTONS[i]] = 2;
}
else if (mButtonsValue[BUTTONS[i]] == 2)
{
mButtonsValue[BUTTONS[i]] = 1;
}
}
}
static mrb_value
mrb_sdl2_keyboard_key_from_scancode(mrb_state *mrb, mrb_value mod)
{
mrb_int code;
mrb_get_args(mrb, "i", &code);
return mrb_fixnum_value(SDL_GetKeyFromScancode((SDL_Scancode)code));
}
wchar_t Gosu::Input::idToChar(Button btn)
{
if (btn.id() > kbRangeEnd)
return 0;
// SDL_GetKeyName would return "Space" for this value.
if (btn.id() == kbSpace)
return L' ';
SDL_Keycode keycode = SDL_GetKeyFromScancode(static_cast<SDL_Scancode>(btn.id()));
if (keycode == SDLK_UNKNOWN)
return 0;
const char* name = SDL_GetKeyName(keycode);
if (name == NULL)
return 0;
std::wstring wname = utf8ToWstring(name);
if (wname.length() != 1)
return 0;
// Convert to lower case to be consistent with previous versions of Gosu.
// Also, German umlauts are already reported in lower-case by the SDL, so
// this makes everything a little more consistent.
//
// This should handle Turkish i/I just fine because it uses the current
// locale, but if we ever receive bug reports from Turkish users, they are
// likely caused by a combination of this line and an invalid locale :)
return std::towlower(wname[0]);
}
static void shortcutInput(int& shortcut)
{
Lumix::StaticString<50> popup_name("");
popup_name << (Lumix::i64)&shortcut;
Lumix::StaticString<50> button_label(SDL_GetKeyName(SDL_GetKeyFromScancode((SDL_Scancode)shortcut)));
button_label << "###" << (Lumix::i64)&shortcut;
if (ImGui::Button(button_label, ImVec2(65, 0))) shortcut = -1;
auto& io = ImGui::GetIO();
int key_count;
auto* state = SDL_GetKeyboardState(&key_count);
if (ImGui::IsItemHovered())
{
for (int i = 0; i < key_count; ++i)
{
if (state[i])
{
shortcut = i;
break;
}
}
}
}
const std::string hotkey_keyboard::get_name_helper() const
{
std::string ret = std::string(SDL_GetKeyName(SDL_GetKeyFromScancode(scancode_)));
if (ret.size() == 1) {
boost::algorithm::to_lower(ret);
}
return ret;
}
int osinterface_scancode_to_rct_keycode(int sdl_key){
char keycode = (char)SDL_GetKeyFromScancode((SDL_Scancode)sdl_key);
// Until we reshufle the text files to use the new positions
// this will suffice to move the majority to the correct positions.
// Note any special buttons PgUp PgDwn are mapped wrong.
if (keycode >= 'a' && keycode <= 'z')keycode = toupper(keycode);
return keycode;
}
bool ConfirmScreen(const char *info, const char *msg)
{
int w = gGraphicsDevice.cachedConfig.Res.x;
int h = gGraphicsDevice.cachedConfig.Res.y;
ClearScreen(&gGraphicsDevice);
FontStr(info, Vec2iNew((w - FontStrW(info)) / 2, (h - FontH()) / 2));
FontStr(msg, Vec2iNew((w - FontStrW(msg)) / 2, (h + FontH()) / 2));
BlitFlip(&gGraphicsDevice);
SDL_Keycode k = SDL_GetKeyFromScancode(GetKey(&gEventHandlers));
return k == SDLK_y;
}
bool ConfirmScreen(const char *info, const char *msg)
{
int w = gGraphicsDevice.cachedConfig.Res.x;
int h = gGraphicsDevice.cachedConfig.Res.y;
ClearScreen(&gGraphicsDevice);
FontStr(info, svec2i((w - FontStrW(info)) / 2, (h - FontH()) / 2));
FontStr(msg, svec2i((w - FontStrW(msg)) / 2, (h + FontH()) / 2));
WindowContextPreRender(&gGraphicsDevice.gameWindow);
BlitUpdateFromBuf(&gGraphicsDevice, gGraphicsDevice.screen);
WindowContextPostRender(&gGraphicsDevice.gameWindow);
SDL_Keycode k = SDL_GetKeyFromScancode(GetKey(&gEventHandlers));
return k == SDLK_y;
}
Keyboard::Key Keyboard::getKeyFromScancode(Scancode scancode) const
{
SDL_Scancode sdlscancode = SDL_SCANCODE_UNKNOWN;
scancodes.find(scancode, sdlscancode);
SDL_Keycode sdlkey = SDL_GetKeyFromScancode(sdlscancode);
for (int i = 0; i < KEY_MAX_ENUM; i++)
{
if (keymap[i] == sdlkey)
return (Key) i;
}
return KEY_UNKNOWN;
}
std::string KeyboardConfig::getKeyName(const int key)
{
if (key == -1)
return "";
if (key > -1)
{
#ifdef USE_SDL2
return SDL_GetKeyName(SDL_GetKeyFromScancode(
static_cast<SDL_Scancode>(key)));
#else
return SDL_GetKeyName(static_cast<SDLKey>(key));
#endif
}
// TRANSLATORS: long key name, should be short
return strprintf(_("key_%d"), static_cast<int>(key));
}
/**
* \brief Refresh the state of the keys.
*/
void bear::input::keyboard::refresh_keys()
{
int num_codes;
const Uint8* scan_codes( SDL_GetKeyboardState( &num_codes ) );
m_pressed_keys.clear();
for (unsigned int i=0; i!=(unsigned int)num_codes; ++i)
if ( scan_codes[i] == 1 )
{
const SDL_Keymod mod( SDL_GetModState() );
const key_code k
( sdl_key_to_local
( SDL_GetKeyFromScancode( static_cast<SDL_Scancode>(i) ),
mod & KMOD_SHIFT, mod & KMOD_ALT) );
if ( (k != kc_not_a_key) &&
(k != kc_num_lock) &&
(k != kc_caps_lock) &&
(k != kc_scroll_lock) )
m_pressed_keys.push_back( k );
}
} // keyboard::refresh_keys()
void FHTML5InputInterface::Tick(float DeltaTime, const SDL_Event& Event,TSharedRef < FGenericWindow>& ApplicationWindow )
{
switch (Event.type)
{
case SDL_KEYDOWN:
{
SDL_KeyboardEvent KeyEvent = Event.key;
const SDL_Keycode KeyCode = KeyEvent.keysym.scancode;
const bool bIsRepeated = KeyEvent.repeat != 0;
// First KeyDown, then KeyChar. This is important, as in-game console ignores first character otherwise
MessageHandler->OnKeyDown(KeyCode, KeyEvent.keysym.sym, bIsRepeated);
// Backspace/Return input caught here.
// Note that TextInput still seems to get characters messages too but slate seems to not process them.
if (KeyCode == SDL_SCANCODE_BACKSPACE || KeyCode == SDL_SCANCODE_RETURN)
{
const TCHAR Character = SDL_GetKeyFromScancode(Event.key.keysym.scancode);
UE_LOG(LogHTML5Input, Verbose, TEXT("TextInput: Text:%c bIsRepeated:%s"), Character, bIsRepeated ? TEXT("TRUE") : TEXT("FALSE"));
MessageHandler->OnKeyChar(Character, bIsRepeated);
}
UE_LOG(LogHTML5Input, Verbose, TEXT("KeyDown: Code:%d bIsRepeated:%s"), KeyCode, bIsRepeated ? TEXT("TRUE") : TEXT("FALSE"));
}
break;
case SDL_KEYUP:
{
SDL_KeyboardEvent keyEvent = Event.key;
const SDL_Keycode KeyCode = keyEvent.keysym.scancode;
const bool IsRepeat = keyEvent.repeat != 0;
MessageHandler->OnKeyUp( KeyCode, keyEvent.keysym.sym, IsRepeat );
UE_LOG(LogHTML5Input, Verbose, TEXT("KeyUp Code:%d"), KeyCode);
}
break;
case SDL_TEXTINPUT:
{
const bool bIsRepeated = Event.key.repeat != 0;
const TCHAR Character = *ANSI_TO_TCHAR(Event.text.text);
MessageHandler->OnKeyChar(Character, bIsRepeated);
UE_LOG(LogHTML5Input, Verbose, TEXT("TextInput: Text:%c bIsRepeated:%s"), Character, bIsRepeated ? TEXT("TRUE") : TEXT("FALSE"));
}
break;
case SDL_MOUSEBUTTONDOWN:
{
EMouseButtons::Type MouseButton = Event.button.button == 1 ? EMouseButtons::Left : Event.button.button == 2 ? EMouseButtons::Middle : EMouseButtons::Right;
MessageHandler->OnMouseDown(ApplicationWindow, MouseButton );
UE_LOG(LogHTML5Input, Verbose, TEXT("MouseButtonDown ID:%d"), Event.button.button);
}
break;
case SDL_MOUSEBUTTONUP:
{
EMouseButtons::Type MouseButton = Event.button.button == 1 ? EMouseButtons::Left : Event.button.button == 2 ? EMouseButtons::Middle : EMouseButtons::Right;
MessageHandler->OnMouseUp(MouseButton );
UE_LOG(LogHTML5Input, Verbose, TEXT("MouseButtonUp ID:%d"), Event.button.button);
}
break;
case SDL_MOUSEMOTION:
{
//Cursor->SetPosition(Event.motion.x, Event.motion.y);
MessageHandler->OnRawMouseMove(Event.motion.xrel, Event.motion.yrel);
MessageHandler->OnMouseMove();
UE_LOG(LogHTML5Input, Verbose, TEXT("MouseMotion Pos(%d, %d) XRel:%d YRel:%d"), Event.motion.x, Event.motion.y, Event.motion.xrel, Event.motion.yrel);
}
break;
case SDL_MOUSEWHEEL:
{
SDL_MouseWheelEvent* w = (SDL_MouseWheelEvent*)&Event;
const float SpinFactor = 1 / 120.0f;
MessageHandler->OnMouseWheel(w->y * SpinFactor);
UE_LOG(LogHTML5Input, Verbose, TEXT("MouseWheel %f"), SpinFactor);
}
break;
default:
// unhandled.
break;
}
}
variant playable_custom_object::get_player_value_by_slot(int slot) const
{
switch(slot) {
case CUSTOM_OBJECT_PLAYER_DIFFICULTY: {
if(preferences::force_difficulty() != INT_MIN) {
return variant(preferences::force_difficulty());
}
return variant(difficulty_);
}
case CUSTOM_OBJECT_PLAYER_CAN_INTERACT: {
return variant(can_interact_);
}
case CUSTOM_OBJECT_PLAYER_UNDERWATER_CONTROLS: {
return variant(underwater_controls_);
}
case CUSTOM_OBJECT_PLAYER_CTRL_MOD_KEY: {
return variant(SDL_GetModState());
}
case CUSTOM_OBJECT_PLAYER_CTRL_KEYS: {
std::vector<variant> result;
if(level_runner::get_current() && level_runner::get_current()->get_debug_console() && level_runner::get_current()->get_debug_console()->has_keyboard_focus()) {
//the debug console is stealing all keystrokes.
return variant(&result);
}
#if !TARGET_OS_IPHONE && !TARGET_IPHONE_SIMULATOR
int ary_length;
const Uint8* key_state = SDL_GetKeyboardState(&ary_length);
#ifndef NO_EDITOR
if(level_runner::get_current()) {
const editor* e = level_runner::get_current()->get_editor();
if(e && e->has_keyboard_focus()) {
//the editor has the focus, so we tell the game there
//are no keys pressed.
ary_length = 0;
}
}
#endif
for(int count = 0; count < ary_length; ++count) {
if(key_state[count]) { //Returns only keys that are down so the list that ffl has to deal with is small.
SDL_Keycode k = SDL_GetKeyFromScancode(SDL_Scancode(count));
if(k < 128 && util::c_isprint(k)) {
std::string str(1,k);
result.push_back(variant(str));
} else {
result.push_back(variant(k));
}
}
}
#endif
return variant(&result);
}
case CUSTOM_OBJECT_PLAYER_CTRL_MICE: {
std::vector<variant> result;
#if TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR
const int nmice = SDL_GetNumMice();
#else
const int nmice = 1;
#endif
for(int n = 0; n != nmice; ++n) {
#if TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR
SDL_SelectMouse(n);
#endif
std::vector<variant> info;
int x, y;
Uint8 button_state = input::sdl_get_mouse_state(&x, &y);
translate_mouse_coords(&x, &y);
info.push_back(variant(x));
info.push_back(variant(y));
if(button_state & SDL_BUTTON(SDL_BUTTON_LEFT)) {
info.push_back(variant("left"));
}
if(button_state & SDL_BUTTON(SDL_BUTTON_RIGHT)) {
info.push_back(variant("right"));
}
if(button_state & SDL_BUTTON(SDL_BUTTON_MIDDLE)) {
info.push_back(variant("middle"));
}
if(button_state & SDL_BUTTON(SDL_BUTTON_X1)) { //these aren't tested
info.push_back(variant("x1"));
}
if(button_state & SDL_BUTTON(SDL_BUTTON_X2)) {
info.push_back(variant("x2"));
}
result.push_back(variant(&info));
}
return variant(&result);
}
case CUSTOM_OBJECT_PLAYER_CTRL_TILT: {
return variant(-joystick::iphone_tilt());
}
case CUSTOM_OBJECT_PLAYER_CTRL_X: {
return variant(underwater_ctrl_x_);
}
case CUSTOM_OBJECT_PLAYER_CTRL_Y: {
return variant(underwater_ctrl_y_);
}
case CUSTOM_OBJECT_PLAYER_CTRL_REVERSE_AB: {
return variant::from_bool(reverse_ab_);
}
case CUSTOM_OBJECT_PLAYER_CONTROL_SCHEME: {
return variant(preferences::control_scheme());
}
case CUSTOM_OBJECT_PLAYER_VERTICAL_LOOK: {
return variant(vertical_look_);
}
case CUSTOM_OBJECT_PLAYER_CONTROL_LOCK: {
std::vector<variant> result;
const unsigned char* locked_control_frame = controls::get_local_control_lock();
if (locked_control_frame == nullptr) {
return variant();
}
for(int i = 0; i < 8; ++i){
if((*locked_control_frame & (0x01 << i)) ){
result.push_back( variant(ctrl[i]) );
} else {
//this key isn't pressed
}
}
return variant(&result);
}
}
ASSERT_LOG(false, "unknown slot in get_player_value_by_slot: " << slot);
}
/* Human readable string representation */
std::string sourceDescString(const SourceDesc &src)
{
char buf[128];
char pos;
switch (src.type)
{
case Invalid:
return std::string();
case Key:
{
if (src.d.scan == SDL_SCANCODE_LSHIFT)
return "Shift";
SDL_Keycode key = SDL_GetKeyFromScancode(src.d.scan);
const char *str = SDL_GetKeyName(key);
if (*str == '\0')
return "Unknown key";
else
return str;
}
case JButton:
snprintf(buf, sizeof(buf), "JS %d", src.d.jb);
return buf;
case JHat:
switch(src.d.jh.pos)
{
case SDL_HAT_UP:
pos = 'U';
break;
case SDL_HAT_DOWN:
pos = 'D';
break;
case SDL_HAT_LEFT:
pos = 'L';
break;
case SDL_HAT_RIGHT:
pos = 'R';
break;
default:
pos = '-';
}
snprintf(buf, sizeof(buf), "Hat %d:%c",
src.d.jh.hat, pos);
return buf;
case JAxis:
snprintf(buf, sizeof(buf), "Axis %d%c",
src.d.ja.axis, src.d.ja.dir == Negative ? '-' : '+');
return buf;
}
assert(!"unreachable");
return "";
}
/*
===============
IN_TranslateSDLToJKKey
===============
*/
static fakeAscii_t IN_TranslateSDLToJKKey( SDL_Keysym *keysym, qboolean down ) {
fakeAscii_t key = A_NULL;
if ( keysym->sym >= A_LOW_A && keysym->sym <= A_LOW_Z )
key = (fakeAscii_t)(A_CAP_A + (keysym->sym - A_LOW_A));
else if ( keysym->sym >= A_LOW_AGRAVE && keysym->sym <= A_LOW_THORN && keysym->sym != A_DIVIDE )
key = (fakeAscii_t)(A_CAP_AGRAVE + (keysym->sym - A_LOW_AGRAVE));
else if ( keysym->sym >= SDLK_SPACE && keysym->sym < SDLK_DELETE )
key = (fakeAscii_t)keysym->sym;
else
{
IN_TranslateNumpad( keysym, &key );
switch( keysym->sym )
{
case SDLK_PAGEUP: key = A_PAGE_UP; break;
case SDLK_KP_9: key = A_KP_9; break;
case SDLK_PAGEDOWN: key = A_PAGE_DOWN; break;
case SDLK_KP_3: key = A_KP_3; break;
case SDLK_KP_7: key = A_KP_7; break;
case SDLK_HOME: key = A_HOME; break;
case SDLK_KP_1: key = A_KP_1; break;
case SDLK_END: key = A_END; break;
case SDLK_KP_4: key = A_KP_4; break;
case SDLK_LEFT: key = A_CURSOR_LEFT; break;
case SDLK_KP_6: key = A_KP_6; break;
case SDLK_RIGHT: key = A_CURSOR_RIGHT; break;
case SDLK_KP_2: key = A_KP_2; break;
case SDLK_DOWN: key = A_CURSOR_DOWN; break;
case SDLK_KP_8: key = A_KP_8; break;
case SDLK_UP: key = A_CURSOR_UP; break;
case SDLK_ESCAPE: key = A_ESCAPE; break;
case SDLK_KP_ENTER: key = A_KP_ENTER; break;
case SDLK_RETURN: key = A_ENTER; break;
case SDLK_TAB: key = A_TAB; break;
case SDLK_F1: key = A_F1; break;
case SDLK_F2: key = A_F2; break;
case SDLK_F3: key = A_F3; break;
case SDLK_F4: key = A_F4; break;
case SDLK_F5: key = A_F5; break;
case SDLK_F6: key = A_F6; break;
case SDLK_F7: key = A_F7; break;
case SDLK_F8: key = A_F8; break;
case SDLK_F9: key = A_F9; break;
case SDLK_F10: key = A_F10; break;
case SDLK_F11: key = A_F11; break;
case SDLK_F12: key = A_F12; break;
case SDLK_BACKSPACE: key = A_BACKSPACE; break;
case SDLK_KP_PERIOD: key = A_KP_PERIOD; break;
case SDLK_DELETE: key = A_DELETE; break;
case SDLK_PAUSE: key = A_PAUSE; break;
case SDLK_LSHIFT:
case SDLK_RSHIFT: key = A_SHIFT; break;
case SDLK_LCTRL:
case SDLK_RCTRL: key = A_CTRL; break;
case SDLK_RALT:
case SDLK_LALT: key = A_ALT; break;
case SDLK_KP_5: key = A_KP_5; break;
case SDLK_INSERT: key = A_INSERT; break;
case SDLK_KP_0: key = A_KP_0; break;
case SDLK_KP_MULTIPLY: key = A_STAR; break;
case SDLK_KP_PLUS: key = A_KP_PLUS; break;
case SDLK_KP_MINUS: key = A_KP_MINUS; break;
case SDLK_KP_DIVIDE: key = A_FORWARD_SLASH; break;
case SDLK_SCROLLLOCK: key = A_SCROLLLOCK; break;
case SDLK_NUMLOCKCLEAR: key = A_NUMLOCK; break;
case SDLK_CAPSLOCK: key = A_CAPSLOCK; break;
case L'\u00D7': key = A_MULTIPLY; break;
case L'\u00E0': key = A_LOW_AGRAVE; break;
case L'\u00E1': key = A_LOW_AACUTE; break;
case L'\u00E2': key = A_LOW_ACIRCUMFLEX; break;
case L'\u00E3': key = A_LOW_ATILDE; break;
case L'\u00E4': key = A_LOW_ADIERESIS; break;
case L'\u00E5': key = A_LOW_ARING; break;
case L'\u00E6': key = A_LOW_AE; break;
case L'\u00E7': key = A_LOW_CCEDILLA; break;
case L'\u00E8': key = A_LOW_EGRAVE; break;
case L'\u00E9': key = A_LOW_EACUTE; break;
case L'\u00EA': key = A_LOW_ECIRCUMFLEX; break;
case L'\u00EB': key = A_LOW_EDIERESIS; break;
case L'\u00EC': key = A_LOW_IGRAVE; break;
case L'\u00ED': key = A_LOW_IACUTE; break;
case L'\u00EE': key = A_LOW_ICIRCUMFLEX; break;
case L'\u00EF': key = A_LOW_IDIERESIS; break;
case L'\u00F0': key = A_LOW_ETH; break;
case L'\u00F1': key = A_LOW_NTILDE; break;
case L'\u00F2': key = A_LOW_OGRAVE; break;
case L'\u00F3': key = A_LOW_OACUTE; break;
case L'\u00F4': key = A_LOW_OCIRCUMFLEX; break;
case L'\u00F5': key = A_LOW_OTILDE; break;
case L'\u00F6': key = A_LOW_ODIERESIS; break;
case L'\u00F7': key = A_DIVIDE; break;
case L'\u00F8': key = A_LOW_OSLASH; break;
case L'\u00F9': key = A_LOW_UGRAVE; break;
case L'\u00FA': key = A_LOW_UACUTE; break;
case L'\u00FB': key = A_LOW_UCIRCUMFLEX; break;
case L'\u00FC': key = A_LOW_UDIERESIS; break;
case L'\u00FD': key = A_LOW_YACUTE; break;
case L'\u00FE': key = A_LOW_THORN; break;
case L'\u00FF': key = A_LOW_YDIERESIS; break;
default:
break;
}
}
if( in_keyboardDebug->integer )
IN_PrintKey( keysym, key, down );
if ( cl_consoleUseScanCode->integer )
{
if ( keysym->scancode == SDL_SCANCODE_GRAVE )
{
SDL_Keycode translated = SDL_GetKeyFromScancode( SDL_SCANCODE_GRAVE );
if ( (translated != SDLK_CARET) || (translated == SDLK_CARET && (keysym->mod & KMOD_SHIFT)) )
{
// Console keys can't be bound or generate characters
key = A_CONSOLE;
}
}
}
else
{
if ( IN_IsConsoleKey( key, 0 ) )
{
// Console keys can't be bound or generate characters
key = A_CONSOLE;
}
}
return key;
}
}
}
/*
if (scancode == SDL_SCANCODE_UNKNOWN) {
SDL_Log("WinRT TranslateKeycode, unknown keycode=%d\n", (int)keycode);
}
*/
return scancode;
}
void
WINRT_ProcessKeyDownEvent(Windows::UI::Core::KeyEventArgs ^args)
{
SDL_Scancode sdlScancode = WINRT_TranslateKeycode((int)args->VirtualKey, args->KeyStatus.ScanCode);
#if 0
SDL_Keycode keycode = SDL_GetKeyFromScancode(sdlScancode);
SDL_Log("key down, handled=%s, ext?=%s, released?=%s, menu key down?=%s, "
"repeat count=%d, native scan code=0x%x, was down?=%s, vkey=%d, "
"sdl scan code=%d (%s), sdl key code=%d (%s)\n",
(args->Handled ? "1" : "0"),
(args->KeyStatus.IsExtendedKey ? "1" : "0"),
(args->KeyStatus.IsKeyReleased ? "1" : "0"),
(args->KeyStatus.IsMenuKeyDown ? "1" : "0"),
args->KeyStatus.RepeatCount,
args->KeyStatus.ScanCode,
(args->KeyStatus.WasKeyDown ? "1" : "0"),
args->VirtualKey,
sdlScancode,
SDL_GetScancodeName(sdlScancode),
keycode,
SDL_GetKeyName(keycode));
const char *getInputName(Uint32 scancode) {
if( scancode>=0 && scancode<283 ) {
return SDL_GetKeyName(SDL_GetKeyFromScancode(static_cast<SDL_Scancode>(scancode)));
} else if( scancode<299 ) {
switch( scancode ) {
case 283:
return "Mouse 0";
case 284:
return "Mouse 1";
case 285:
return "Mouse 2";
case 286:
return "Mouse 3";
case 287:
return "Wheel up";
case 288:
return "Wheel down";
case 289:
return "Mouse 6";
case 290:
return "Mouse 7";
case 291:
return "Mouse 8";
case 292:
return "Mouse 9";
case 293:
return "Mouse 10";
case 294:
return "Mouse 11";
case 295:
return "Mouse 12";
case 296:
return "Mouse 13";
case 297:
return "Mouse 14";
case 298:
return "Mouse 15";
default:
return "Unknown key";
}
} else if( scancode<315 ) {
switch( scancode ) {
case 299:
return "Button 0";
case 300:
return "Button 1";
case 301:
return "Button 2";
case 302:
return "Button 3";
case 303:
return "Button 4";
case 304:
return "Button 5";
case 305:
return "Button 6";
case 306:
return "Button 7";
case 307:
return "Button 8";
case 308:
return "Button 9";
case 309:
return "Button 10";
case 310:
return "Button 11";
case 311:
return "Button 12";
case 312:
return "Button 13";
case 313:
return "Button 14";
case 314:
return "Button 15";
default:
return "Unknown key";
}
} else {
return "Unknown key";
}
}
int to_keycode(VirtualKey vkey)
{
return SDL_GetKeyFromScancode(
static_cast<SDL_Scancode>(to_scancode(vkey)));
}
inline int32_t from_scan(int32_t scan_code) noexcept {
return SDL_GetKeyFromScancode(static_cast<SDL_Scancode>(scan_code));
}