From 8b4280b297ed74727548702c21d3e257e31f644b Mon Sep 17 00:00:00 2001 From: Sacha Date: Mon, 5 Aug 2013 03:31:40 +1000 Subject: [PATCH] Rename KEYCODE to NKCODE (native key code) to stop name collision. Implement Blackberry keymapping. --- Common/KeyMap.cpp | 491 +++++++++++++++++++------------------ Common/KeyMap.h | 2 +- UI/EmuScreen.cpp | 2 +- UI/MenuScreens.cpp | 6 +- Windows/DinputDevice.cpp | 40 +-- Windows/KeyboardDevice.cpp | 206 ++++++++-------- Windows/WndMainWindow.cpp | 4 +- Windows/XinputDevice.cpp | 34 +-- ios/ViewController.mm | 26 +- native | 2 +- 10 files changed, 407 insertions(+), 406 deletions(-) diff --git a/Common/KeyMap.cpp b/Common/KeyMap.cpp index ef6a7e887e..46e17cf53d 100644 --- a/Common/KeyMap.cpp +++ b/Common/KeyMap.cpp @@ -29,51 +29,51 @@ struct DefaultKeyMap { static KeyMapping defaultKeyboardMap() { KeyMapping m; - m[KeyDef(DEVICE_ID_KEYBOARD, KEYCODE_A)] = CTRL_SQUARE; - m[KeyDef(DEVICE_ID_KEYBOARD, KEYCODE_S)] = CTRL_TRIANGLE; - m[KeyDef(DEVICE_ID_KEYBOARD, KEYCODE_X)] = CTRL_CIRCLE; - m[KeyDef(DEVICE_ID_KEYBOARD, KEYCODE_Z)] = CTRL_CROSS; - m[KeyDef(DEVICE_ID_KEYBOARD, KEYCODE_Q)] = CTRL_LTRIGGER; - m[KeyDef(DEVICE_ID_KEYBOARD, KEYCODE_W)] = CTRL_RTRIGGER; - m[KeyDef(DEVICE_ID_KEYBOARD, KEYCODE_SPACE)] = CTRL_START; + m[KeyDef(DEVICE_ID_KEYBOARD, NKCODE_A)] = CTRL_SQUARE; + m[KeyDef(DEVICE_ID_KEYBOARD, NKCODE_S)] = CTRL_TRIANGLE; + m[KeyDef(DEVICE_ID_KEYBOARD, NKCODE_X)] = CTRL_CIRCLE; + m[KeyDef(DEVICE_ID_KEYBOARD, NKCODE_Z)] = CTRL_CROSS; + m[KeyDef(DEVICE_ID_KEYBOARD, NKCODE_Q)] = CTRL_LTRIGGER; + m[KeyDef(DEVICE_ID_KEYBOARD, NKCODE_W)] = CTRL_RTRIGGER; + m[KeyDef(DEVICE_ID_KEYBOARD, NKCODE_SPACE)] = CTRL_START; #ifdef _WIN32 - m[KeyDef(DEVICE_ID_KEYBOARD, KEYCODE_V)] = CTRL_SELECT; + m[KeyDef(DEVICE_ID_KEYBOARD, NKCODE_V)] = CTRL_SELECT; #else - m[KeyDef(DEVICE_ID_KEYBOARD, KEYCODE_ENTER)] = CTRL_SELECT; + m[KeyDef(DEVICE_ID_KEYBOARD, NKCODE_ENTER)] = CTRL_SELECT; #endif - m[KeyDef(DEVICE_ID_KEYBOARD, KEYCODE_DPAD_UP)] = CTRL_UP; - m[KeyDef(DEVICE_ID_KEYBOARD, KEYCODE_DPAD_DOWN)] = CTRL_DOWN; - m[KeyDef(DEVICE_ID_KEYBOARD, KEYCODE_DPAD_LEFT)] = CTRL_LEFT; - m[KeyDef(DEVICE_ID_KEYBOARD, KEYCODE_DPAD_RIGHT)] = CTRL_RIGHT; - m[KeyDef(DEVICE_ID_KEYBOARD, KEYCODE_I)] = VIRTKEY_AXIS_Y_MAX; - m[KeyDef(DEVICE_ID_KEYBOARD, KEYCODE_K)] = VIRTKEY_AXIS_Y_MIN; - m[KeyDef(DEVICE_ID_KEYBOARD, KEYCODE_J)] = VIRTKEY_AXIS_X_MIN; - m[KeyDef(DEVICE_ID_KEYBOARD, KEYCODE_L)] = VIRTKEY_AXIS_X_MAX; - m[KeyDef(DEVICE_ID_KEYBOARD, KEYCODE_SHIFT_LEFT)] = VIRTKEY_RAPID_FIRE; - m[KeyDef(DEVICE_ID_KEYBOARD, KEYCODE_TAB)] = VIRTKEY_UNTHROTTLE; - m[KeyDef(DEVICE_ID_KEYBOARD, KEYCODE_GRAVE)] = VIRTKEY_SPEED_TOGGLE; - m[KeyDef(DEVICE_ID_KEYBOARD, KEYCODE_ESCAPE)] = VIRTKEY_PAUSE; + m[KeyDef(DEVICE_ID_KEYBOARD, NKCODE_DPAD_UP)] = CTRL_UP; + m[KeyDef(DEVICE_ID_KEYBOARD, NKCODE_DPAD_DOWN)] = CTRL_DOWN; + m[KeyDef(DEVICE_ID_KEYBOARD, NKCODE_DPAD_LEFT)] = CTRL_LEFT; + m[KeyDef(DEVICE_ID_KEYBOARD, NKCODE_DPAD_RIGHT)] = CTRL_RIGHT; + m[KeyDef(DEVICE_ID_KEYBOARD, NKCODE_I)] = VIRTKEY_AXIS_Y_MAX; + m[KeyDef(DEVICE_ID_KEYBOARD, NKCODE_K)] = VIRTKEY_AXIS_Y_MIN; + m[KeyDef(DEVICE_ID_KEYBOARD, NKCODE_J)] = VIRTKEY_AXIS_X_MIN; + m[KeyDef(DEVICE_ID_KEYBOARD, NKCODE_L)] = VIRTKEY_AXIS_X_MAX; + m[KeyDef(DEVICE_ID_KEYBOARD, NKCODE_SHIFT_LEFT)] = VIRTKEY_RAPID_FIRE; + m[KeyDef(DEVICE_ID_KEYBOARD, NKCODE_TAB)] = VIRTKEY_UNTHROTTLE; + m[KeyDef(DEVICE_ID_KEYBOARD, NKCODE_GRAVE)] = VIRTKEY_SPEED_TOGGLE; + m[KeyDef(DEVICE_ID_KEYBOARD, NKCODE_ESCAPE)] = VIRTKEY_PAUSE; return m; } static KeyMapping default360Map() { KeyMapping m; - m[KeyDef(DEVICE_ID_X360_0, KEYCODE_BUTTON_A)] = CTRL_CROSS; - m[KeyDef(DEVICE_ID_X360_0, KEYCODE_BUTTON_B)] = CTRL_CIRCLE; - m[KeyDef(DEVICE_ID_X360_0, KEYCODE_BUTTON_X)] = CTRL_SQUARE; - m[KeyDef(DEVICE_ID_X360_0, KEYCODE_BUTTON_Y)] = CTRL_TRIANGLE; - m[KeyDef(DEVICE_ID_X360_0, KEYCODE_DPAD_UP)] = CTRL_UP; - m[KeyDef(DEVICE_ID_X360_0, KEYCODE_DPAD_RIGHT)] = CTRL_RIGHT; - m[KeyDef(DEVICE_ID_X360_0, KEYCODE_DPAD_DOWN)] = CTRL_DOWN; - m[KeyDef(DEVICE_ID_X360_0, KEYCODE_DPAD_LEFT)] = CTRL_LEFT; - m[KeyDef(DEVICE_ID_X360_0, KEYCODE_BUTTON_START)] = CTRL_START; - m[KeyDef(DEVICE_ID_X360_0, KEYCODE_BUTTON_SELECT)] = CTRL_SELECT; - m[KeyDef(DEVICE_ID_X360_0, KEYCODE_BUTTON_L1)] = CTRL_LTRIGGER; - m[KeyDef(DEVICE_ID_X360_0, KEYCODE_BUTTON_R1)] = CTRL_RTRIGGER; - m[KeyDef(DEVICE_ID_X360_0, KEYCODE_BUTTON_R2)] = VIRTKEY_UNTHROTTLE; - m[KeyDef(DEVICE_ID_X360_0, KEYCODE_BUTTON_THUMBR)] = VIRTKEY_PAUSE; - m[KeyDef(DEVICE_ID_X360_0, KEYCODE_BUTTON_L2)] = VIRTKEY_SPEED_TOGGLE; + m[KeyDef(DEVICE_ID_X360_0, NKCODE_BUTTON_A)] = CTRL_CROSS; + m[KeyDef(DEVICE_ID_X360_0, NKCODE_BUTTON_B)] = CTRL_CIRCLE; + m[KeyDef(DEVICE_ID_X360_0, NKCODE_BUTTON_X)] = CTRL_SQUARE; + m[KeyDef(DEVICE_ID_X360_0, NKCODE_BUTTON_Y)] = CTRL_TRIANGLE; + m[KeyDef(DEVICE_ID_X360_0, NKCODE_DPAD_UP)] = CTRL_UP; + m[KeyDef(DEVICE_ID_X360_0, NKCODE_DPAD_RIGHT)] = CTRL_RIGHT; + m[KeyDef(DEVICE_ID_X360_0, NKCODE_DPAD_DOWN)] = CTRL_DOWN; + m[KeyDef(DEVICE_ID_X360_0, NKCODE_DPAD_LEFT)] = CTRL_LEFT; + m[KeyDef(DEVICE_ID_X360_0, NKCODE_BUTTON_START)] = CTRL_START; + m[KeyDef(DEVICE_ID_X360_0, NKCODE_BUTTON_SELECT)] = CTRL_SELECT; + m[KeyDef(DEVICE_ID_X360_0, NKCODE_BUTTON_L1)] = CTRL_LTRIGGER; + m[KeyDef(DEVICE_ID_X360_0, NKCODE_BUTTON_R1)] = CTRL_RTRIGGER; + m[KeyDef(DEVICE_ID_X360_0, NKCODE_BUTTON_R2)] = VIRTKEY_UNTHROTTLE; + m[KeyDef(DEVICE_ID_X360_0, NKCODE_BUTTON_THUMBR)] = VIRTKEY_PAUSE; + m[KeyDef(DEVICE_ID_X360_0, NKCODE_BUTTON_L2)] = VIRTKEY_SPEED_TOGGLE; m[AxisDef(DEVICE_ID_X360_0, JOYSTICK_AXIS_X, -1)] = VIRTKEY_AXIS_X_MIN; m[AxisDef(DEVICE_ID_X360_0, JOYSTICK_AXIS_X, +1)] = VIRTKEY_AXIS_X_MAX; m[AxisDef(DEVICE_ID_X360_0, JOYSTICK_AXIS_Y, -1)] = VIRTKEY_AXIS_Y_MIN; @@ -85,17 +85,17 @@ struct DefaultKeyMap { static KeyMapping defaultShieldMap() { KeyMapping m; - m[KeyDef(DEVICE_ID_PAD_0, KEYCODE_BUTTON_A)] = CTRL_CROSS; - m[KeyDef(DEVICE_ID_PAD_0, KEYCODE_BUTTON_B)] = CTRL_CIRCLE; - m[KeyDef(DEVICE_ID_PAD_0, KEYCODE_BUTTON_X)] = CTRL_SQUARE; - m[KeyDef(DEVICE_ID_PAD_0, KEYCODE_BUTTON_Y)] = CTRL_TRIANGLE; - m[KeyDef(DEVICE_ID_PAD_0, KEYCODE_BUTTON_START)] = CTRL_START; - m[KeyDef(DEVICE_ID_PAD_0, KEYCODE_BUTTON_SELECT)] = CTRL_SELECT; - m[KeyDef(DEVICE_ID_PAD_0, KEYCODE_BUTTON_L1)] = CTRL_LTRIGGER; - m[KeyDef(DEVICE_ID_PAD_0, KEYCODE_BUTTON_R1)] = CTRL_RTRIGGER; - m[KeyDef(DEVICE_ID_PAD_0, KEYCODE_BUTTON_R2)] = VIRTKEY_UNTHROTTLE; - m[KeyDef(DEVICE_ID_PAD_0, KEYCODE_BUTTON_THUMBR)] = VIRTKEY_PAUSE; - m[KeyDef(DEVICE_ID_PAD_0, KEYCODE_BUTTON_L2)] = VIRTKEY_SPEED_TOGGLE; + m[KeyDef(DEVICE_ID_PAD_0, NKCODE_BUTTON_A)] = CTRL_CROSS; + m[KeyDef(DEVICE_ID_PAD_0, NKCODE_BUTTON_B)] = CTRL_CIRCLE; + m[KeyDef(DEVICE_ID_PAD_0, NKCODE_BUTTON_X)] = CTRL_SQUARE; + m[KeyDef(DEVICE_ID_PAD_0, NKCODE_BUTTON_Y)] = CTRL_TRIANGLE; + m[KeyDef(DEVICE_ID_PAD_0, NKCODE_BUTTON_START)] = CTRL_START; + m[KeyDef(DEVICE_ID_PAD_0, NKCODE_BUTTON_SELECT)] = CTRL_SELECT; + m[KeyDef(DEVICE_ID_PAD_0, NKCODE_BUTTON_L1)] = CTRL_LTRIGGER; + m[KeyDef(DEVICE_ID_PAD_0, NKCODE_BUTTON_R1)] = CTRL_RTRIGGER; + m[KeyDef(DEVICE_ID_PAD_0, NKCODE_BUTTON_R2)] = VIRTKEY_UNTHROTTLE; + m[KeyDef(DEVICE_ID_PAD_0, NKCODE_BUTTON_THUMBR)] = VIRTKEY_PAUSE; + m[KeyDef(DEVICE_ID_PAD_0, NKCODE_BUTTON_L2)] = VIRTKEY_SPEED_TOGGLE; m[AxisDef(DEVICE_ID_PAD_0, JOYSTICK_AXIS_X, -1)] = VIRTKEY_AXIS_X_MIN; m[AxisDef(DEVICE_ID_PAD_0, JOYSTICK_AXIS_X, +1)] = VIRTKEY_AXIS_X_MAX; m[AxisDef(DEVICE_ID_PAD_0, JOYSTICK_AXIS_Y, -1)] = VIRTKEY_AXIS_Y_MIN; @@ -111,38 +111,38 @@ struct DefaultKeyMap { { KeyMapping m; #ifdef ANDROID - m[KeyDef(DEVICE_ID_X360_0, KEYCODE_BUTTON_A)] = CTRL_CROSS; - m[KeyDef(DEVICE_ID_X360_0, KEYCODE_BUTTON_B)] = CTRL_CIRCLE; - m[KeyDef(DEVICE_ID_X360_0, KEYCODE_BUTTON_X)] = CTRL_SQUARE; - m[KeyDef(DEVICE_ID_X360_0, KEYCODE_BUTTON_Y)] = CTRL_TRIANGLE; - m[KeyDef(DEVICE_ID_X360_0, KEYCODE_DPAD_UP)] = CTRL_UP; - m[KeyDef(DEVICE_ID_X360_0, KEYCODE_DPAD_RIGHT)] = CTRL_RIGHT; - m[KeyDef(DEVICE_ID_X360_0, KEYCODE_DPAD_DOWN)] = CTRL_DOWN; - m[KeyDef(DEVICE_ID_X360_0, KEYCODE_DPAD_LEFT)] = CTRL_LEFT; - m[KeyDef(DEVICE_ID_X360_0, KEYCODE_BUTTON_START)] = CTRL_START; - m[KeyDef(DEVICE_ID_X360_0, KEYCODE_BUTTON_SELECT)] = CTRL_SELECT; - m[KeyDef(DEVICE_ID_X360_0, KEYCODE_BUTTON_L1)] = CTRL_LTRIGGER; - m[KeyDef(DEVICE_ID_X360_0, KEYCODE_BUTTON_R1)] = CTRL_RTRIGGER; - m[KeyDef(DEVICE_ID_X360_0, KEYCODE_BUTTON_R2)] = VIRTKEY_UNTHROTTLE; - m[KeyDef(DEVICE_ID_X360_0, KEYCODE_BUTTON_THUMBR)] = VIRTKEY_PAUSE; - m[KeyDef(DEVICE_ID_X360_0, KEYCODE_BUTTON_L2)] = VIRTKEY_SPEED_TOGGLE; + m[KeyDef(DEVICE_ID_X360_0, NKCODE_BUTTON_A)] = CTRL_CROSS; + m[KeyDef(DEVICE_ID_X360_0, NKCODE_BUTTON_B)] = CTRL_CIRCLE; + m[KeyDef(DEVICE_ID_X360_0, NKCODE_BUTTON_X)] = CTRL_SQUARE; + m[KeyDef(DEVICE_ID_X360_0, NKCODE_BUTTON_Y)] = CTRL_TRIANGLE; + m[KeyDef(DEVICE_ID_X360_0, NKCODE_DPAD_UP)] = CTRL_UP; + m[KeyDef(DEVICE_ID_X360_0, NKCODE_DPAD_RIGHT)] = CTRL_RIGHT; + m[KeyDef(DEVICE_ID_X360_0, NKCODE_DPAD_DOWN)] = CTRL_DOWN; + m[KeyDef(DEVICE_ID_X360_0, NKCODE_DPAD_LEFT)] = CTRL_LEFT; + m[KeyDef(DEVICE_ID_X360_0, NKCODE_BUTTON_START)] = CTRL_START; + m[KeyDef(DEVICE_ID_X360_0, NKCODE_BUTTON_SELECT)] = CTRL_SELECT; + m[KeyDef(DEVICE_ID_X360_0, NKCODE_BUTTON_L1)] = CTRL_LTRIGGER; + m[KeyDef(DEVICE_ID_X360_0, NKCODE_BUTTON_R1)] = CTRL_RTRIGGER; + m[KeyDef(DEVICE_ID_X360_0, NKCODE_BUTTON_R2)] = VIRTKEY_UNTHROTTLE; + m[KeyDef(DEVICE_ID_X360_0, NKCODE_BUTTON_THUMBR)] = VIRTKEY_PAUSE; + m[KeyDef(DEVICE_ID_X360_0, NKCODE_BUTTON_L2)] = VIRTKEY_SPEED_TOGGLE; m[AxisDef(DEVICE_ID_X360_0, JOYSTICK_AXIS_X, -1)] = VIRTKEY_AXIS_X_MIN; m[AxisDef(DEVICE_ID_X360_0, JOYSTICK_AXIS_X, +1)] = VIRTKEY_AXIS_X_MAX; m[AxisDef(DEVICE_ID_X360_0, JOYSTICK_AXIS_Y, -1)] = VIRTKEY_AXIS_Y_MIN; m[AxisDef(DEVICE_ID_X360_0, JOYSTICK_AXIS_Y, +1)] = VIRTKEY_AXIS_Y_MAX; #else - m[KeyDef(DEVICE_ID_PAD_0, KEYCODE_BUTTON_2)] = CTRL_CROSS; - m[KeyDef(DEVICE_ID_PAD_0, KEYCODE_BUTTON_3)] = CTRL_CIRCLE; - m[KeyDef(DEVICE_ID_PAD_0, KEYCODE_BUTTON_4)] = CTRL_SQUARE; - m[KeyDef(DEVICE_ID_PAD_0, KEYCODE_BUTTON_1)] = CTRL_TRIANGLE; - m[KeyDef(DEVICE_ID_PAD_0, KEYCODE_DPAD_UP)] = CTRL_UP; - m[KeyDef(DEVICE_ID_PAD_0, KEYCODE_DPAD_RIGHT)] = CTRL_RIGHT; - m[KeyDef(DEVICE_ID_PAD_0, KEYCODE_DPAD_DOWN)] = CTRL_DOWN; - m[KeyDef(DEVICE_ID_PAD_0, KEYCODE_DPAD_LEFT)] = CTRL_LEFT; - m[KeyDef(DEVICE_ID_PAD_0, KEYCODE_BUTTON_10)] = CTRL_START; - m[KeyDef(DEVICE_ID_PAD_0, KEYCODE_BUTTON_9)] = CTRL_SELECT; - m[KeyDef(DEVICE_ID_PAD_0, KEYCODE_BUTTON_7)] = CTRL_LTRIGGER; - m[KeyDef(DEVICE_ID_PAD_0, KEYCODE_BUTTON_8)] = CTRL_RTRIGGER; + m[KeyDef(DEVICE_ID_PAD_0, NKCODE_BUTTON_2)] = CTRL_CROSS; + m[KeyDef(DEVICE_ID_PAD_0, NKCODE_BUTTON_3)] = CTRL_CIRCLE; + m[KeyDef(DEVICE_ID_PAD_0, NKCODE_BUTTON_4)] = CTRL_SQUARE; + m[KeyDef(DEVICE_ID_PAD_0, NKCODE_BUTTON_1)] = CTRL_TRIANGLE; + m[KeyDef(DEVICE_ID_PAD_0, NKCODE_DPAD_UP)] = CTRL_UP; + m[KeyDef(DEVICE_ID_PAD_0, NKCODE_DPAD_RIGHT)] = CTRL_RIGHT; + m[KeyDef(DEVICE_ID_PAD_0, NKCODE_DPAD_DOWN)] = CTRL_DOWN; + m[KeyDef(DEVICE_ID_PAD_0, NKCODE_DPAD_LEFT)] = CTRL_LEFT; + m[KeyDef(DEVICE_ID_PAD_0, NKCODE_BUTTON_10)] = CTRL_START; + m[KeyDef(DEVICE_ID_PAD_0, NKCODE_BUTTON_9)] = CTRL_SELECT; + m[KeyDef(DEVICE_ID_PAD_0, NKCODE_BUTTON_7)] = CTRL_LTRIGGER; + m[KeyDef(DEVICE_ID_PAD_0, NKCODE_BUTTON_8)] = CTRL_RTRIGGER; m[AxisDef(DEVICE_ID_PAD_0, JOYSTICK_AXIS_X, -1)] = VIRTKEY_AXIS_X_MIN; m[AxisDef(DEVICE_ID_PAD_0, JOYSTICK_AXIS_X, +1)] = VIRTKEY_AXIS_X_MAX; m[AxisDef(DEVICE_ID_PAD_0, JOYSTICK_AXIS_Y, +1)] = VIRTKEY_AXIS_Y_MIN; @@ -154,18 +154,18 @@ struct DefaultKeyMap { static KeyMapping defaultXperiaPlay() { KeyMapping m; - m[KeyDef(DEVICE_ID_DEFAULT, KEYCODE_BUTTON_CROSS)] = CTRL_CROSS; - m[KeyDef(DEVICE_ID_DEFAULT, KEYCODE_BUTTON_CIRCLE)] = CTRL_CIRCLE; - m[KeyDef(DEVICE_ID_DEFAULT, KEYCODE_BUTTON_X)] = CTRL_SQUARE; - m[KeyDef(DEVICE_ID_DEFAULT, KEYCODE_BUTTON_Y)] = CTRL_TRIANGLE; - m[KeyDef(DEVICE_ID_DEFAULT, KEYCODE_DPAD_UP)] = CTRL_UP; - m[KeyDef(DEVICE_ID_DEFAULT, KEYCODE_DPAD_RIGHT)] = CTRL_RIGHT; - m[KeyDef(DEVICE_ID_DEFAULT, KEYCODE_DPAD_DOWN)] = CTRL_DOWN; - m[KeyDef(DEVICE_ID_DEFAULT, KEYCODE_DPAD_LEFT)] = CTRL_LEFT; - m[KeyDef(DEVICE_ID_DEFAULT, KEYCODE_BUTTON_START)] = CTRL_START; - m[KeyDef(DEVICE_ID_DEFAULT, KEYCODE_BACK)] = CTRL_SELECT; - m[KeyDef(DEVICE_ID_DEFAULT, KEYCODE_BUTTON_L1)] = CTRL_LTRIGGER; - m[KeyDef(DEVICE_ID_DEFAULT, KEYCODE_BUTTON_R1)] = CTRL_RTRIGGER; + m[KeyDef(DEVICE_ID_DEFAULT, NKCODE_BUTTON_CROSS)] = CTRL_CROSS; + m[KeyDef(DEVICE_ID_DEFAULT, NKCODE_BUTTON_CIRCLE)] = CTRL_CIRCLE; + m[KeyDef(DEVICE_ID_DEFAULT, NKCODE_BUTTON_X)] = CTRL_SQUARE; + m[KeyDef(DEVICE_ID_DEFAULT, NKCODE_BUTTON_Y)] = CTRL_TRIANGLE; + m[KeyDef(DEVICE_ID_DEFAULT, NKCODE_DPAD_UP)] = CTRL_UP; + m[KeyDef(DEVICE_ID_DEFAULT, NKCODE_DPAD_RIGHT)] = CTRL_RIGHT; + m[KeyDef(DEVICE_ID_DEFAULT, NKCODE_DPAD_DOWN)] = CTRL_DOWN; + m[KeyDef(DEVICE_ID_DEFAULT, NKCODE_DPAD_LEFT)] = CTRL_LEFT; + m[KeyDef(DEVICE_ID_DEFAULT, NKCODE_BUTTON_START)] = CTRL_START; + m[KeyDef(DEVICE_ID_DEFAULT, NKCODE_BACK)] = CTRL_SELECT; + m[KeyDef(DEVICE_ID_DEFAULT, NKCODE_BUTTON_L1)] = CTRL_LTRIGGER; + m[KeyDef(DEVICE_ID_DEFAULT, NKCODE_BUTTON_R1)] = CTRL_RTRIGGER; m[AxisDef(DEVICE_ID_DEFAULT, JOYSTICK_AXIS_X, -1)] = VIRTKEY_AXIS_X_MIN; m[AxisDef(DEVICE_ID_DEFAULT, JOYSTICK_AXIS_X, +1)] = VIRTKEY_AXIS_X_MAX; m[AxisDef(DEVICE_ID_DEFAULT, JOYSTICK_AXIS_Y, -1)] = VIRTKEY_AXIS_Y_MIN; @@ -179,6 +179,7 @@ struct DefaultKeyMap { #if defined(USING_GLES2) // Mobile! Only a pad map required, some can use a keyboard map though. + // Currently no way to distinguish between external keyboard and qwerty keyboard ('pad'?) ControllerMap pad; pad.keys = defaultPadMap(); pad.name = "Pad"; @@ -231,170 +232,170 @@ struct KeyMap_IntStrPair { std::string name; }; const KeyMap_IntStrPair key_names[] = { - {KEYCODE_A, "A"}, - {KEYCODE_B, "B"}, - {KEYCODE_C, "C"}, - {KEYCODE_D, "D"}, - {KEYCODE_E, "E"}, - {KEYCODE_F, "F"}, - {KEYCODE_G, "G"}, - {KEYCODE_H, "H"}, - {KEYCODE_I, "I"}, - {KEYCODE_J, "J"}, - {KEYCODE_K, "K"}, - {KEYCODE_L, "L"}, - {KEYCODE_M, "M"}, - {KEYCODE_N, "N"}, - {KEYCODE_O, "O"}, - {KEYCODE_P, "P"}, - {KEYCODE_Q, "Q"}, - {KEYCODE_R, "R"}, - {KEYCODE_S, "S"}, - {KEYCODE_T, "T"}, - {KEYCODE_U, "U"}, - {KEYCODE_V, "V"}, - {KEYCODE_W, "W"}, - {KEYCODE_X, "X"}, - {KEYCODE_Y, "Y"}, - {KEYCODE_Z, "Z"}, + {NKCODE_A, "A"}, + {NKCODE_B, "B"}, + {NKCODE_C, "C"}, + {NKCODE_D, "D"}, + {NKCODE_E, "E"}, + {NKCODE_F, "F"}, + {NKCODE_G, "G"}, + {NKCODE_H, "H"}, + {NKCODE_I, "I"}, + {NKCODE_J, "J"}, + {NKCODE_K, "K"}, + {NKCODE_L, "L"}, + {NKCODE_M, "M"}, + {NKCODE_N, "N"}, + {NKCODE_O, "O"}, + {NKCODE_P, "P"}, + {NKCODE_Q, "Q"}, + {NKCODE_R, "R"}, + {NKCODE_S, "S"}, + {NKCODE_T, "T"}, + {NKCODE_U, "U"}, + {NKCODE_V, "V"}, + {NKCODE_W, "W"}, + {NKCODE_X, "X"}, + {NKCODE_Y, "Y"}, + {NKCODE_Z, "Z"}, - {KEYCODE_0, "0"}, - {KEYCODE_1, "1"}, - {KEYCODE_2, "2"}, - {KEYCODE_3, "3"}, - {KEYCODE_4, "4"}, - {KEYCODE_5, "5"}, - {KEYCODE_6, "6"}, - {KEYCODE_7, "7"}, - {KEYCODE_8, "8"}, - {KEYCODE_9, "9"}, + {NKCODE_0, "0"}, + {NKCODE_1, "1"}, + {NKCODE_2, "2"}, + {NKCODE_3, "3"}, + {NKCODE_4, "4"}, + {NKCODE_5, "5"}, + {NKCODE_6, "6"}, + {NKCODE_7, "7"}, + {NKCODE_8, "8"}, + {NKCODE_9, "9"}, - {KEYCODE_F1, "F1"}, - {KEYCODE_F2, "F2"}, - {KEYCODE_F3, "F3"}, - {KEYCODE_F4, "F4"}, - {KEYCODE_F5, "F5"}, - {KEYCODE_F6, "F6"}, - {KEYCODE_F7, "F7"}, - {KEYCODE_F8, "F8"}, - {KEYCODE_F9, "F9"}, - {KEYCODE_F10, "F10"}, - {KEYCODE_F11, "F11"}, - {KEYCODE_F12, "F12"}, + {NKCODE_F1, "F1"}, + {NKCODE_F2, "F2"}, + {NKCODE_F3, "F3"}, + {NKCODE_F4, "F4"}, + {NKCODE_F5, "F5"}, + {NKCODE_F6, "F6"}, + {NKCODE_F7, "F7"}, + {NKCODE_F8, "F8"}, + {NKCODE_F9, "F9"}, + {NKCODE_F10, "F10"}, + {NKCODE_F11, "F11"}, + {NKCODE_F12, "F12"}, - {KEYCODE_GRAVE, "`"}, - {KEYCODE_SLASH, "/"}, - {KEYCODE_BACKSLASH, "\\"}, - {KEYCODE_SEMICOLON, ";"}, - {KEYCODE_COMMA, ","}, - {KEYCODE_PERIOD, "."}, - {KEYCODE_LEFT_BRACKET, "["}, - {KEYCODE_RIGHT_BRACKET, "]"}, - {KEYCODE_APOSTROPHE, "'"}, - {KEYCODE_MINUS, "-"}, - {KEYCODE_PLUS, "+"}, - {KEYCODE_SYSRQ, "Print"}, - {KEYCODE_SCROLL_LOCK, "ScrLock"}, - {KEYCODE_BREAK, "Pause"}, + {NKCODE_GRAVE, "`"}, + {NKCODE_SLASH, "/"}, + {NKCODE_BACKSLASH, "\\"}, + {NKCODE_SEMICOLON, ";"}, + {NKCODE_COMMA, ","}, + {NKCODE_PERIOD, "."}, + {NKCODE_LEFT_BRACKET, "["}, + {NKCODE_RIGHT_BRACKET, "]"}, + {NKCODE_APOSTROPHE, "'"}, + {NKCODE_MINUS, "-"}, + {NKCODE_PLUS, "+"}, + {NKCODE_SYSRQ, "Print"}, + {NKCODE_SCROLL_LOCK, "ScrLock"}, + {NKCODE_BREAK, "Pause"}, - {KEYCODE_BACK, "Back"}, - {KEYCODE_TAB, "Tab"}, - {KEYCODE_ENTER, "Enter"}, - {KEYCODE_SHIFT_LEFT, "LShift"}, - {KEYCODE_SHIFT_RIGHT, "RShift"}, - {KEYCODE_CTRL_LEFT, "LCtrl"}, - {KEYCODE_CTRL_RIGHT, "RCtrl"}, - {KEYCODE_ALT_LEFT, "LAlt"}, - {KEYCODE_ALT_RIGHT, "RAlt"}, - {KEYCODE_SPACE, "Space"}, - {KEYCODE_WINDOW, "Windows"}, - {KEYCODE_DEL, "Del"}, - {KEYCODE_MOVE_HOME, "Home"}, - {KEYCODE_MOVE_END, "End"}, - {KEYCODE_ESCAPE, "Esc"}, - {KEYCODE_CAPS_LOCK, "CapsLock"}, + {NKCODE_BACK, "Back"}, + {NKCODE_TAB, "Tab"}, + {NKCODE_ENTER, "Enter"}, + {NKCODE_SHIFT_LEFT, "LShift"}, + {NKCODE_SHIFT_RIGHT, "RShift"}, + {NKCODE_CTRL_LEFT, "LCtrl"}, + {NKCODE_CTRL_RIGHT, "RCtrl"}, + {NKCODE_ALT_LEFT, "LAlt"}, + {NKCODE_ALT_RIGHT, "RAlt"}, + {NKCODE_SPACE, "Space"}, + {NKCODE_WINDOW, "Windows"}, + {NKCODE_DEL, "Del"}, + {NKCODE_MOVE_HOME, "Home"}, + {NKCODE_MOVE_END, "End"}, + {NKCODE_ESCAPE, "Esc"}, + {NKCODE_CAPS_LOCK, "CapsLock"}, - {KEYCODE_VOLUME_UP, "Vol +"}, - {KEYCODE_VOLUME_DOWN, "Vol -"}, - {KEYCODE_HOME, "Home"}, - {KEYCODE_INSERT, "Ins"}, - {KEYCODE_PAGE_UP, "PgUp"}, - {KEYCODE_PAGE_DOWN, "PgDn"}, - {KEYCODE_CLEAR, "Clear"}, // 5 when numlock off - {KEYCODE_CALL, "Call"}, - {KEYCODE_ENDCALL, "End Call"}, + {NKCODE_VOLUME_UP, "Vol +"}, + {NKCODE_VOLUME_DOWN, "Vol -"}, + {NKCODE_HOME, "Home"}, + {NKCODE_INSERT, "Ins"}, + {NKCODE_PAGE_UP, "PgUp"}, + {NKCODE_PAGE_DOWN, "PgDn"}, + {NKCODE_CLEAR, "Clear"}, // 5 when numlock off + {NKCODE_CALL, "Call"}, + {NKCODE_ENDCALL, "End Call"}, - {KEYCODE_DPAD_LEFT, "Left"}, - {KEYCODE_DPAD_UP, "Up"}, - {KEYCODE_DPAD_RIGHT, "Right"}, - {KEYCODE_DPAD_DOWN, "Down"}, + {NKCODE_DPAD_LEFT, "Left"}, + {NKCODE_DPAD_UP, "Up"}, + {NKCODE_DPAD_RIGHT, "Right"}, + {NKCODE_DPAD_DOWN, "Down"}, - {KEYCODE_BUTTON_L1, "L1"}, - {KEYCODE_BUTTON_L2, "L2"}, - {KEYCODE_BUTTON_R1, "R1"}, - {KEYCODE_BUTTON_R2, "R2"}, + {NKCODE_BUTTON_L1, "L1"}, + {NKCODE_BUTTON_L2, "L2"}, + {NKCODE_BUTTON_R1, "R1"}, + {NKCODE_BUTTON_R2, "R2"}, - {KEYCODE_BUTTON_A, "[A]"}, - {KEYCODE_BUTTON_B, "[B]"}, - {KEYCODE_BUTTON_C, "[C]"}, - {KEYCODE_BUTTON_X, "[X]"}, - {KEYCODE_BUTTON_Y, "[Y]"}, - {KEYCODE_BUTTON_Z, "[Z]"}, - {KEYCODE_BUTTON_1, "b1"}, - {KEYCODE_BUTTON_2, "b2"}, - {KEYCODE_BUTTON_3, "b3"}, - {KEYCODE_BUTTON_4, "b4"}, - {KEYCODE_BUTTON_5, "b5"}, - {KEYCODE_BUTTON_6, "b6"}, - {KEYCODE_BUTTON_7, "b7"}, - {KEYCODE_BUTTON_8, "b8"}, - {KEYCODE_BUTTON_9, "b9"}, - {KEYCODE_BUTTON_10, "b10"}, - {KEYCODE_BUTTON_11, "b11"}, - {KEYCODE_BUTTON_12, "b12"}, - {KEYCODE_BUTTON_13, "b13"}, - {KEYCODE_BUTTON_14, "b14"}, - {KEYCODE_BUTTON_15, "b15"}, - {KEYCODE_BUTTON_16, "b16"}, - {KEYCODE_BUTTON_START, "Start"}, - {KEYCODE_BUTTON_SELECT, "Select"}, - {KEYCODE_BUTTON_CIRCLE, "Circle"}, - {KEYCODE_BUTTON_CIRCLE_PS3, "Circle3"}, - {KEYCODE_BUTTON_CROSS, "Cross"}, - {KEYCODE_BUTTON_CROSS_PS3, "Cross3"}, - {KEYCODE_BUTTON_TRIANGLE, "Triangle"}, - {KEYCODE_BUTTON_SQUARE, "Square"}, - {KEYCODE_BUTTON_THUMBL, "ThumbL"}, - {KEYCODE_BUTTON_THUMBR, "ThumbR"}, - {KEYCODE_BUTTON_MODE, "Mode"}, + {NKCODE_BUTTON_A, "[A]"}, + {NKCODE_BUTTON_B, "[B]"}, + {NKCODE_BUTTON_C, "[C]"}, + {NKCODE_BUTTON_X, "[X]"}, + {NKCODE_BUTTON_Y, "[Y]"}, + {NKCODE_BUTTON_Z, "[Z]"}, + {NKCODE_BUTTON_1, "b1"}, + {NKCODE_BUTTON_2, "b2"}, + {NKCODE_BUTTON_3, "b3"}, + {NKCODE_BUTTON_4, "b4"}, + {NKCODE_BUTTON_5, "b5"}, + {NKCODE_BUTTON_6, "b6"}, + {NKCODE_BUTTON_7, "b7"}, + {NKCODE_BUTTON_8, "b8"}, + {NKCODE_BUTTON_9, "b9"}, + {NKCODE_BUTTON_10, "b10"}, + {NKCODE_BUTTON_11, "b11"}, + {NKCODE_BUTTON_12, "b12"}, + {NKCODE_BUTTON_13, "b13"}, + {NKCODE_BUTTON_14, "b14"}, + {NKCODE_BUTTON_15, "b15"}, + {NKCODE_BUTTON_16, "b16"}, + {NKCODE_BUTTON_START, "Start"}, + {NKCODE_BUTTON_SELECT, "Select"}, + {NKCODE_BUTTON_CIRCLE, "Circle"}, + {NKCODE_BUTTON_CIRCLE_PS3, "Circle3"}, + {NKCODE_BUTTON_CROSS, "Cross"}, + {NKCODE_BUTTON_CROSS_PS3, "Cross3"}, + {NKCODE_BUTTON_TRIANGLE, "Triangle"}, + {NKCODE_BUTTON_SQUARE, "Square"}, + {NKCODE_BUTTON_THUMBL, "ThumbL"}, + {NKCODE_BUTTON_THUMBR, "ThumbR"}, + {NKCODE_BUTTON_MODE, "Mode"}, - {KEYCODE_EXT_PIPE, "|"}, - {KEYCODE_NUMPAD_DIVIDE, "Num/"}, - {KEYCODE_NUMPAD_MULTIPLY, "Num*"}, - {KEYCODE_NUMPAD_ADD, "Num+"}, - {KEYCODE_NUMPAD_SUBTRACT, "Num-"}, - {KEYCODE_NUMPAD_DOT, "Num."}, - {KEYCODE_NUMPAD_COMMA, "Num,"}, - {KEYCODE_NUMPAD_ENTER, "NumEnter"}, - {KEYCODE_NUMPAD_EQUALS, "Num="}, - {KEYCODE_NUMPAD_LEFT_PAREN, "Num("}, - {KEYCODE_NUMPAD_RIGHT_PAREN, "Num)"}, - {KEYCODE_NUMPAD_0, "Num0"}, - {KEYCODE_NUMPAD_1, "Num1"}, - {KEYCODE_NUMPAD_2, "Num2"}, - {KEYCODE_NUMPAD_3, "Num3"}, - {KEYCODE_NUMPAD_4, "Num4"}, - {KEYCODE_NUMPAD_5, "Num5"}, - {KEYCODE_NUMPAD_6, "Num6"}, - {KEYCODE_NUMPAD_7, "Num7"}, - {KEYCODE_NUMPAD_8, "Num8"}, - {KEYCODE_NUMPAD_9, "Num9"}, + {NKCODE_EXT_PIPE, "|"}, + {NKCODE_NUMPAD_DIVIDE, "Num/"}, + {NKCODE_NUMPAD_MULTIPLY, "Num*"}, + {NKCODE_NUMPAD_ADD, "Num+"}, + {NKCODE_NUMPAD_SUBTRACT, "Num-"}, + {NKCODE_NUMPAD_DOT, "Num."}, + {NKCODE_NUMPAD_COMMA, "Num,"}, + {NKCODE_NUMPAD_ENTER, "NumEnter"}, + {NKCODE_NUMPAD_EQUALS, "Num="}, + {NKCODE_NUMPAD_LEFT_PAREN, "Num("}, + {NKCODE_NUMPAD_RIGHT_PAREN, "Num)"}, + {NKCODE_NUMPAD_0, "Num0"}, + {NKCODE_NUMPAD_1, "Num1"}, + {NKCODE_NUMPAD_2, "Num2"}, + {NKCODE_NUMPAD_3, "Num3"}, + {NKCODE_NUMPAD_4, "Num4"}, + {NKCODE_NUMPAD_5, "Num5"}, + {NKCODE_NUMPAD_6, "Num6"}, + {NKCODE_NUMPAD_7, "Num7"}, + {NKCODE_NUMPAD_8, "Num8"}, + {NKCODE_NUMPAD_9, "Num9"}, - {KEYCODE_EXT_MOUSEBUTTON_1, "MB1"}, - {KEYCODE_EXT_MOUSEBUTTON_2, "MB2"}, - {KEYCODE_EXT_MOUSEBUTTON_3, "MB3"}, - {KEYCODE_EXT_MOUSEWHEEL_UP, "MWheelU"}, - {KEYCODE_EXT_MOUSEWHEEL_DOWN, "MWheelD"}, + {NKCODE_EXT_MOUSEBUTTON_1, "MB1"}, + {NKCODE_EXT_MOUSEBUTTON_2, "MB2"}, + {NKCODE_EXT_MOUSEBUTTON_3, "MB3"}, + {NKCODE_EXT_MOUSEWHEEL_UP, "MWheelU"}, + {NKCODE_EXT_MOUSEWHEEL_DOWN, "MWheelD"}, }; const KeyMap_IntStrPair axis_names[] = { @@ -457,7 +458,7 @@ const KeyMap_IntStrPair psp_button_names[] = { {VIRTKEY_PAUSE, "Pause"}, }; -const int AXIS_BIND_KEYCODE_START = 4000; +const int AXIS_BIND_NKCODE_START = 4000; static std::string FindName(int key, const KeyMap_IntStrPair list[], size_t size) { @@ -480,9 +481,9 @@ std::string GetPspButtonName(int btn) int TranslateKeyCodeToAxis(int keyCode, int &direction) { - if (keyCode < AXIS_BIND_KEYCODE_START) + if (keyCode < AXIS_BIND_NKCODE_START) return 0; - int v = keyCode - AXIS_BIND_KEYCODE_START; + int v = keyCode - AXIS_BIND_NKCODE_START; // Even/odd for direction. direction = v & 1 ? -1 : 1; @@ -492,7 +493,7 @@ int TranslateKeyCodeToAxis(int keyCode, int &direction) int TranslateKeyCodeFromAxis(int axisId, int direction) { direction = direction < 0 ? 1 : 0; - return AXIS_BIND_KEYCODE_START + axisId * 2 + direction; + return AXIS_BIND_NKCODE_START + axisId * 2 + direction; } KeyDef AxisDef(int deviceId, int axisId, int direction) { @@ -551,7 +552,7 @@ bool AxisFromPspButton(int controllerMap, int btn, int *deviceId, int *axisId, i int search_start_layer = 0; for (auto iter = controllerMaps[controllerMap].keys.begin(); iter != controllerMaps[controllerMap].keys.end(); ++iter) { - if (iter->second == btn && iter->first.keyCode >= AXIS_BIND_KEYCODE_START) { + if (iter->second == btn && iter->first.keyCode >= AXIS_BIND_NKCODE_START) { *deviceId = iter->first.deviceId; *axisId = TranslateKeyCodeToAxis(iter->first.keyCode, *direction); return true; diff --git a/Common/KeyMap.h b/Common/KeyMap.h index ae6a47e796..6cbc28ff61 100644 --- a/Common/KeyMap.h +++ b/Common/KeyMap.h @@ -88,7 +88,7 @@ extern std::vector controllerMaps; // // Does not handle input state managment. // -// Platform ports should map their platform's keys to KeyMap's keys (KEYCODE_*). +// Platform ports should map their platform's keys to KeyMap's keys (NKCODE_*). // // Then have KeyMap transform those into psp buttons. diff --git a/UI/EmuScreen.cpp b/UI/EmuScreen.cpp index bf838506c4..a664712128 100644 --- a/UI/EmuScreen.cpp +++ b/UI/EmuScreen.cpp @@ -301,7 +301,7 @@ inline void EmuScreen::setVKeyAnalogY(int stick, int virtualKeyMin, int virtualK } void EmuScreen::key(const KeyInput &key) { - if (key.keyCode == KEYCODE_BACK) + if (key.keyCode == NKCODE_BACK) pauseTrigger_ = true; int result = KeyMap::KeyToPspButton(key.deviceId, key.keyCode); diff --git a/UI/MenuScreens.cpp b/UI/MenuScreens.cpp index dfaa6b0fe3..ef7c08342b 100644 --- a/UI/MenuScreens.cpp +++ b/UI/MenuScreens.cpp @@ -702,7 +702,7 @@ void ControlsScreen::update(InputState &input) { void KeyMappingNewKeyDialog::key(const KeyInput &key) { if (key.flags & KEY_DOWN) { - if (key.keyCode != KEYCODE_EXT_MOUSEBUTTON_1) { + if (key.keyCode != NKCODE_EXT_MOUSEBUTTON_1) { last_kb_deviceid = key.deviceId; last_kb_key = key.keyCode; last_axis_id = -1; @@ -1938,10 +1938,10 @@ FileSelectScreen::FileSelectScreen(const FileSelectScreenOptions &options) : opt void FileSelectScreen::key(const KeyInput &key) { if (key.flags & KEY_DOWN) { switch (key.keyCode) { - case KEYCODE_EXT_MOUSEWHEEL_UP: + case NKCODE_EXT_MOUSEWHEEL_UP: list_.scrollRelative(-50); break; - case KEYCODE_EXT_MOUSEWHEEL_DOWN: + case NKCODE_EXT_MOUSEWHEEL_DOWN: list_.scrollRelative(50); break; } diff --git a/Windows/DinputDevice.cpp b/Windows/DinputDevice.cpp index 1b24b1ef72..e4033c67da 100644 --- a/Windows/DinputDevice.cpp +++ b/Windows/DinputDevice.cpp @@ -36,22 +36,22 @@ // In order from 0. There can be 128, but most controllers do not have that many. static const int dinput_buttons[] = { - KEYCODE_BUTTON_1, - KEYCODE_BUTTON_2, - KEYCODE_BUTTON_3, - KEYCODE_BUTTON_4, - KEYCODE_BUTTON_5, - KEYCODE_BUTTON_6, - KEYCODE_BUTTON_7, - KEYCODE_BUTTON_8, - KEYCODE_BUTTON_9, - KEYCODE_BUTTON_10, - KEYCODE_BUTTON_11, - KEYCODE_BUTTON_12, - KEYCODE_BUTTON_13, - KEYCODE_BUTTON_14, - KEYCODE_BUTTON_15, - KEYCODE_BUTTON_16, + NKCODE_BUTTON_1, + NKCODE_BUTTON_2, + NKCODE_BUTTON_3, + NKCODE_BUTTON_4, + NKCODE_BUTTON_5, + NKCODE_BUTTON_6, + NKCODE_BUTTON_7, + NKCODE_BUTTON_8, + NKCODE_BUTTON_9, + NKCODE_BUTTON_10, + NKCODE_BUTTON_11, + NKCODE_BUTTON_12, + NKCODE_BUTTON_13, + NKCODE_BUTTON_14, + NKCODE_BUTTON_15, + NKCODE_BUTTON_16, }; static float NormalizedDeadzoneFilter(short value); @@ -230,10 +230,10 @@ void DinputDevice::ApplyButtons(DIJOYSTATE2 &state, InputState &input_state) { dpad[i].deviceId = DEVICE_ID_PAD_0; dpad[i].flags = KEY_UP; } - dpad[0].keyCode = KEYCODE_DPAD_UP; - dpad[1].keyCode = KEYCODE_DPAD_LEFT; - dpad[2].keyCode = KEYCODE_DPAD_DOWN; - dpad[3].keyCode = KEYCODE_DPAD_RIGHT; + dpad[0].keyCode = NKCODE_DPAD_UP; + dpad[1].keyCode = NKCODE_DPAD_LEFT; + dpad[2].keyCode = NKCODE_DPAD_DOWN; + dpad[3].keyCode = NKCODE_DPAD_RIGHT; if (LOWORD(state.rgdwPOV[0]) != JOY_POVCENTERED) { // These are the edges, so we use or. diff --git a/Windows/KeyboardDevice.cpp b/Windows/KeyboardDevice.cpp index fd24d166a0..eaaf831f65 100644 --- a/Windows/KeyboardDevice.cpp +++ b/Windows/KeyboardDevice.cpp @@ -14,109 +14,109 @@ // TODO: More keys need to be added, but this is more than // a fair start. std::map windowsTransTable = InitConstMap - ('A', KEYCODE_A) - ('B', KEYCODE_B) - ('C', KEYCODE_C) - ('D', KEYCODE_D) - ('E', KEYCODE_E) - ('F', KEYCODE_F) - ('G', KEYCODE_G) - ('H', KEYCODE_H) - ('I', KEYCODE_I) - ('J', KEYCODE_J) - ('K', KEYCODE_K) - ('L', KEYCODE_L) - ('M', KEYCODE_M) - ('N', KEYCODE_N) - ('O', KEYCODE_O) - ('P', KEYCODE_P) - ('Q', KEYCODE_Q) - ('R', KEYCODE_R) - ('S', KEYCODE_S) - ('T', KEYCODE_T) - ('U', KEYCODE_U) - ('V', KEYCODE_V) - ('W', KEYCODE_W) - ('X', KEYCODE_X) - ('Y', KEYCODE_Y) - ('Z', KEYCODE_Z) - ('0', KEYCODE_0) - ('1', KEYCODE_1) - ('2', KEYCODE_2) - ('3', KEYCODE_3) - ('4', KEYCODE_4) - ('5', KEYCODE_5) - ('6', KEYCODE_6) - ('7', KEYCODE_7) - ('8', KEYCODE_8) - ('9', KEYCODE_9) - (VK_OEM_PERIOD, KEYCODE_PERIOD) - (VK_OEM_COMMA, KEYCODE_COMMA) - (VK_NUMPAD0, KEYCODE_NUMPAD_0) - (VK_NUMPAD1, KEYCODE_NUMPAD_1) - (VK_NUMPAD2, KEYCODE_NUMPAD_2) - (VK_NUMPAD3, KEYCODE_NUMPAD_3) - (VK_NUMPAD4, KEYCODE_NUMPAD_4) - (VK_NUMPAD5, KEYCODE_NUMPAD_5) - (VK_NUMPAD6, KEYCODE_NUMPAD_6) - (VK_NUMPAD7, KEYCODE_NUMPAD_7) - (VK_NUMPAD8, KEYCODE_NUMPAD_8) - (VK_NUMPAD9, KEYCODE_NUMPAD_9) - (VK_DECIMAL, KEYCODE_NUMPAD_DOT) - (VK_DIVIDE, KEYCODE_NUMPAD_DIVIDE) - (VK_MULTIPLY, KEYCODE_NUMPAD_MULTIPLY) - (VK_SUBTRACT, KEYCODE_NUMPAD_SUBTRACT) - (VK_ADD, KEYCODE_NUMPAD_ADD) - (VK_SEPARATOR, KEYCODE_NUMPAD_COMMA) - (VK_OEM_MINUS, KEYCODE_MINUS) - (VK_OEM_PLUS, KEYCODE_PLUS) - (VK_LCONTROL, KEYCODE_CTRL_LEFT) - (VK_RCONTROL, KEYCODE_CTRL_RIGHT) - (VK_LSHIFT, KEYCODE_SHIFT_LEFT) - (VK_RSHIFT, KEYCODE_SHIFT_RIGHT) - (VK_LMENU, KEYCODE_ALT_LEFT) - (VK_RMENU, KEYCODE_ALT_RIGHT) - (VK_BACK, KEYCODE_BACK) - (VK_SPACE, KEYCODE_SPACE) - (VK_ESCAPE, KEYCODE_ESCAPE) - (VK_UP, KEYCODE_DPAD_UP) - (VK_INSERT, KEYCODE_INSERT) - (VK_HOME, KEYCODE_HOME) - (VK_PRIOR, KEYCODE_PAGE_UP) - (VK_NEXT, KEYCODE_PAGE_DOWN) - (VK_DELETE, KEYCODE_DEL) - (VK_END, KEYCODE_MOVE_END) - (VK_TAB, KEYCODE_TAB) - (VK_DOWN, KEYCODE_DPAD_DOWN) - (VK_LEFT, KEYCODE_DPAD_LEFT) - (VK_RIGHT, KEYCODE_DPAD_RIGHT) - (VK_CAPITAL, KEYCODE_CAPS_LOCK) - (VK_CLEAR, KEYCODE_CLEAR) - (VK_SNAPSHOT, KEYCODE_SYSRQ) - (VK_SCROLL, KEYCODE_SCROLL_LOCK) - (VK_OEM_1, KEYCODE_SEMICOLON) - (VK_OEM_2, KEYCODE_SLASH) - (VK_OEM_3, KEYCODE_GRAVE) - (VK_OEM_4, KEYCODE_LEFT_BRACKET) - (VK_OEM_5, KEYCODE_BACKSLASH) - (VK_OEM_6, KEYCODE_RIGHT_BRACKET) - (VK_OEM_7, KEYCODE_APOSTROPHE) - (VK_RETURN, KEYCODE_ENTER) - (VK_APPS, KEYCODE_MENU) // Context menu key, let's call this "menu". - (VK_PAUSE, KEYCODE_BREAK) - (VK_F1, KEYCODE_F1) - (VK_F2, KEYCODE_F2) - (VK_F3, KEYCODE_F3) - (VK_F4, KEYCODE_F4) - (VK_F5, KEYCODE_F5) - (VK_F6, KEYCODE_F6) - (VK_F7, KEYCODE_F7) - (VK_F8, KEYCODE_F8) - (VK_F9, KEYCODE_F9) - (VK_F10, KEYCODE_F10) - (VK_F11, KEYCODE_F11) - (VK_F12, KEYCODE_F12) - (VK_OEM_102, KEYCODE_EXT_PIPE); + ('A', NKCODE_A) + ('B', NKCODE_B) + ('C', NKCODE_C) + ('D', NKCODE_D) + ('E', NKCODE_E) + ('F', NKCODE_F) + ('G', NKCODE_G) + ('H', NKCODE_H) + ('I', NKCODE_I) + ('J', NKCODE_J) + ('K', NKCODE_K) + ('L', NKCODE_L) + ('M', NKCODE_M) + ('N', NKCODE_N) + ('O', NKCODE_O) + ('P', NKCODE_P) + ('Q', NKCODE_Q) + ('R', NKCODE_R) + ('S', NKCODE_S) + ('T', NKCODE_T) + ('U', NKCODE_U) + ('V', NKCODE_V) + ('W', NKCODE_W) + ('X', NKCODE_X) + ('Y', NKCODE_Y) + ('Z', NKCODE_Z) + ('0', NKCODE_0) + ('1', NKCODE_1) + ('2', NKCODE_2) + ('3', NKCODE_3) + ('4', NKCODE_4) + ('5', NKCODE_5) + ('6', NKCODE_6) + ('7', NKCODE_7) + ('8', NKCODE_8) + ('9', NKCODE_9) + (VK_OEM_PERIOD, NKCODE_PERIOD) + (VK_OEM_COMMA, NKCODE_COMMA) + (VK_NUMPAD0, NKCODE_NUMPAD_0) + (VK_NUMPAD1, NKCODE_NUMPAD_1) + (VK_NUMPAD2, NKCODE_NUMPAD_2) + (VK_NUMPAD3, NKCODE_NUMPAD_3) + (VK_NUMPAD4, NKCODE_NUMPAD_4) + (VK_NUMPAD5, NKCODE_NUMPAD_5) + (VK_NUMPAD6, NKCODE_NUMPAD_6) + (VK_NUMPAD7, NKCODE_NUMPAD_7) + (VK_NUMPAD8, NKCODE_NUMPAD_8) + (VK_NUMPAD9, NKCODE_NUMPAD_9) + (VK_DECIMAL, NKCODE_NUMPAD_DOT) + (VK_DIVIDE, NKCODE_NUMPAD_DIVIDE) + (VK_MULTIPLY, NKCODE_NUMPAD_MULTIPLY) + (VK_SUBTRACT, NKCODE_NUMPAD_SUBTRACT) + (VK_ADD, NKCODE_NUMPAD_ADD) + (VK_SEPARATOR, NKCODE_NUMPAD_COMMA) + (VK_OEM_MINUS, NKCODE_MINUS) + (VK_OEM_PLUS, NKCODE_PLUS) + (VK_LCONTROL, NKCODE_CTRL_LEFT) + (VK_RCONTROL, NKCODE_CTRL_RIGHT) + (VK_LSHIFT, NKCODE_SHIFT_LEFT) + (VK_RSHIFT, NKCODE_SHIFT_RIGHT) + (VK_LMENU, NKCODE_ALT_LEFT) + (VK_RMENU, NKCODE_ALT_RIGHT) + (VK_BACK, NKCODE_BACK) + (VK_SPACE, NKCODE_SPACE) + (VK_ESCAPE, NKCODE_ESCAPE) + (VK_UP, NKCODE_DPAD_UP) + (VK_INSERT, NKCODE_INSERT) + (VK_HOME, NKCODE_HOME) + (VK_PRIOR, NKCODE_PAGE_UP) + (VK_NEXT, NKCODE_PAGE_DOWN) + (VK_DELETE, NKCODE_DEL) + (VK_END, NKCODE_MOVE_END) + (VK_TAB, NKCODE_TAB) + (VK_DOWN, NKCODE_DPAD_DOWN) + (VK_LEFT, NKCODE_DPAD_LEFT) + (VK_RIGHT, NKCODE_DPAD_RIGHT) + (VK_CAPITAL, NKCODE_CAPS_LOCK) + (VK_CLEAR, NKCODE_CLEAR) + (VK_SNAPSHOT, NKCODE_SYSRQ) + (VK_SCROLL, NKCODE_SCROLL_LOCK) + (VK_OEM_1, NKCODE_SEMICOLON) + (VK_OEM_2, NKCODE_SLASH) + (VK_OEM_3, NKCODE_GRAVE) + (VK_OEM_4, NKCODE_LEFT_BRACKET) + (VK_OEM_5, NKCODE_BACKSLASH) + (VK_OEM_6, NKCODE_RIGHT_BRACKET) + (VK_OEM_7, NKCODE_APOSTROPHE) + (VK_RETURN, NKCODE_ENTER) + (VK_APPS, NKCODE_MENU) // Context menu key, let's call this "menu". + (VK_PAUSE, NKCODE_BREAK) + (VK_F1, NKCODE_F1) + (VK_F2, NKCODE_F2) + (VK_F3, NKCODE_F3) + (VK_F4, NKCODE_F4) + (VK_F5, NKCODE_F5) + (VK_F6, NKCODE_F6) + (VK_F7, NKCODE_F7) + (VK_F8, NKCODE_F8) + (VK_F9, NKCODE_F9) + (VK_F10, NKCODE_F10) + (VK_F11, NKCODE_F11) + (VK_F12, NKCODE_F12) + (VK_OEM_102, NKCODE_EXT_PIPE); int KeyboardDevice::UpdateState(InputState &input_state) { // Nothing to do, all done in WM_INPUT diff --git a/Windows/WndMainWindow.cpp b/Windows/WndMainWindow.cpp index 71434774ff..67001f2fa4 100644 --- a/Windows/WndMainWindow.cpp +++ b/Windows/WndMainWindow.cpp @@ -613,10 +613,10 @@ namespace MainWindow key.deviceId = DEVICE_ID_MOUSE; if (wheelDelta < 0) { - key.keyCode = KEYCODE_EXT_MOUSEWHEEL_DOWN; + key.keyCode = NKCODE_EXT_MOUSEWHEEL_DOWN; wheelDelta = -wheelDelta; } else { - key.keyCode = KEYCODE_EXT_MOUSEWHEEL_UP; + key.keyCode = NKCODE_EXT_MOUSEWHEEL_UP; } // There's no separate keyup event for mousewheel events, let's pass them both together. // This also means it really won't work great for key mapping :( Need to build a 1 frame delay or something. diff --git a/Windows/XinputDevice.cpp b/Windows/XinputDevice.cpp index 2bf772da31..5ab1781eff 100644 --- a/Windows/XinputDevice.cpp +++ b/Windows/XinputDevice.cpp @@ -74,23 +74,23 @@ static void UnloadXInputDLL() { // Permanent map. Actual mapping happens elsewhere. static const struct {int from, to;} xinput_ctrl_map[] = { - {XBOX_CODE_LEFTTRIGGER, KEYCODE_BUTTON_L2}, - {XBOX_CODE_RIGHTTRIGGER, KEYCODE_BUTTON_R2}, - {XINPUT_GAMEPAD_A, KEYCODE_BUTTON_A}, - {XINPUT_GAMEPAD_B, KEYCODE_BUTTON_B}, - {XINPUT_GAMEPAD_X, KEYCODE_BUTTON_X}, - {XINPUT_GAMEPAD_Y, KEYCODE_BUTTON_Y}, - {XINPUT_GAMEPAD_BACK, KEYCODE_BUTTON_SELECT}, - {XINPUT_GAMEPAD_START, KEYCODE_BUTTON_START}, - {XINPUT_GAMEPAD_LEFT_SHOULDER, KEYCODE_BUTTON_L1}, - {XINPUT_GAMEPAD_RIGHT_SHOULDER, KEYCODE_BUTTON_R1}, - {XINPUT_GAMEPAD_LEFT_THUMB, KEYCODE_BUTTON_THUMBL}, - {XINPUT_GAMEPAD_RIGHT_THUMB, KEYCODE_BUTTON_THUMBR}, - {XINPUT_GAMEPAD_DPAD_UP, KEYCODE_DPAD_UP}, - {XINPUT_GAMEPAD_DPAD_DOWN, KEYCODE_DPAD_DOWN}, - {XINPUT_GAMEPAD_DPAD_LEFT, KEYCODE_DPAD_LEFT}, - {XINPUT_GAMEPAD_DPAD_RIGHT, KEYCODE_DPAD_RIGHT}, - {XINPUT_GUIDE_BUTTON, KEYCODE_HOME}, + {XBOX_CODE_LEFTTRIGGER, NKCODE_BUTTON_L2}, + {XBOX_CODE_RIGHTTRIGGER, NKCODE_BUTTON_R2}, + {XINPUT_GAMEPAD_A, NKCODE_BUTTON_A}, + {XINPUT_GAMEPAD_B, NKCODE_BUTTON_B}, + {XINPUT_GAMEPAD_X, NKCODE_BUTTON_X}, + {XINPUT_GAMEPAD_Y, NKCODE_BUTTON_Y}, + {XINPUT_GAMEPAD_BACK, NKCODE_BUTTON_SELECT}, + {XINPUT_GAMEPAD_START, NKCODE_BUTTON_START}, + {XINPUT_GAMEPAD_LEFT_SHOULDER, NKCODE_BUTTON_L1}, + {XINPUT_GAMEPAD_RIGHT_SHOULDER, NKCODE_BUTTON_R1}, + {XINPUT_GAMEPAD_LEFT_THUMB, NKCODE_BUTTON_THUMBL}, + {XINPUT_GAMEPAD_RIGHT_THUMB, NKCODE_BUTTON_THUMBR}, + {XINPUT_GAMEPAD_DPAD_UP, NKCODE_DPAD_UP}, + {XINPUT_GAMEPAD_DPAD_DOWN, NKCODE_DPAD_DOWN}, + {XINPUT_GAMEPAD_DPAD_LEFT, NKCODE_DPAD_LEFT}, + {XINPUT_GAMEPAD_DPAD_RIGHT, NKCODE_DPAD_RIGHT}, + {XINPUT_GUIDE_BUTTON, NKCODE_HOME}, }; static const unsigned int xinput_ctrl_map_size = sizeof(xinput_ctrl_map) / sizeof(xinput_ctrl_map[0]); diff --git a/ios/ViewController.mm b/ios/ViewController.mm index 1f00ab3cb1..6201970f32 100644 --- a/ios/ViewController.mm +++ b/ios/ViewController.mm @@ -86,18 +86,18 @@ ViewController* sharedViewController; isJailed = false; } - iCadeToKeyMap[iCadeJoystickUp] = KEYCODE_DPAD_UP; - iCadeToKeyMap[iCadeJoystickRight] = KEYCODE_DPAD_RIGHT; - iCadeToKeyMap[iCadeJoystickDown] = KEYCODE_DPAD_DOWN; - iCadeToKeyMap[iCadeJoystickLeft] = KEYCODE_DPAD_LEFT; - iCadeToKeyMap[iCadeButtonA] = KEYCODE_BUTTON_9; // Select - iCadeToKeyMap[iCadeButtonB] = KEYCODE_BUTTON_7; // LTrigger - iCadeToKeyMap[iCadeButtonC] = KEYCODE_BUTTON_10; // Start - iCadeToKeyMap[iCadeButtonD] = KEYCODE_BUTTON_8; // RTrigger - iCadeToKeyMap[iCadeButtonE] = KEYCODE_BUTTON_4; // Square - iCadeToKeyMap[iCadeButtonF] = KEYCODE_BUTTON_2; // Cross - iCadeToKeyMap[iCadeButtonG] = KEYCODE_BUTTON_1; // Triangle - iCadeToKeyMap[iCadeButtonH] = KEYCODE_BUTTON_3; // Circle + iCadeToKeyMap[iCadeJoystickUp] = NKCODE_DPAD_UP; + iCadeToKeyMap[iCadeJoystickRight] = NKCODE_DPAD_RIGHT; + iCadeToKeyMap[iCadeJoystickDown] = NKCODE_DPAD_DOWN; + iCadeToKeyMap[iCadeJoystickLeft] = NKCODE_DPAD_LEFT; + iCadeToKeyMap[iCadeButtonA] = NKCODE_BUTTON_9; // Select + iCadeToKeyMap[iCadeButtonB] = NKCODE_BUTTON_7; // LTrigger + iCadeToKeyMap[iCadeButtonC] = NKCODE_BUTTON_10; // Start + iCadeToKeyMap[iCadeButtonD] = NKCODE_BUTTON_8; // RTrigger + iCadeToKeyMap[iCadeButtonE] = NKCODE_BUTTON_4; // Square + iCadeToKeyMap[iCadeButtonF] = NKCODE_BUTTON_2; // Cross + iCadeToKeyMap[iCadeButtonG] = NKCODE_BUTTON_1; // Triangle + iCadeToKeyMap[iCadeButtonH] = NKCODE_BUTTON_3; // Circle } return self; } @@ -373,7 +373,7 @@ void DisableFZ(){}; if ((lastStartPress + 1.0f) > time_now_d()) { KeyInput key; key.flags = KEY_DOWN; - key.keyCode = KEYCODE_ESCAPE; + key.keyCode = NKCODE_ESCAPE; key.deviceId = DEVICE_ID_KEYBOARD; NativeKey(key); return; diff --git a/native b/native index 55897ffde0..48498d1833 160000 --- a/native +++ b/native @@ -1 +1 @@ -Subproject commit 55897ffde04c26ee78696d79d44986271d0a4bec +Subproject commit 48498d183324901176b77807e71c7f1448562f82