Add files via upload

Changes To core.c and added keycode.h to translate the from raw keys to raylib scancodes
This commit is contained in:
DarkElvenAngel 2019-02-17 11:51:16 -05:00 committed by GitHub
parent 8a21830b77
commit 26e39b3021
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 723 additions and 2 deletions

View File

@ -215,6 +215,9 @@
#include "EGL/egl.h" // Khronos EGL library - Native platform display device control functions #include "EGL/egl.h" // Khronos EGL library - Native platform display device control functions
#include "EGL/eglext.h" // Khronos EGL library - Extensions #include "EGL/eglext.h" // Khronos EGL library - Extensions
#include "GLES2/gl2.h" // Khronos OpenGL ES 2.0 library #include "GLES2/gl2.h" // Khronos OpenGL ES 2.0 library
#if defined(USERAWKEYBOARD)
#include "keycodes.h" // This is the key codes mapped from ray to match raylib
#endif
#endif #endif
#if defined(PLATFORM_UWP) #if defined(PLATFORM_UWP)
@ -3212,8 +3215,10 @@ static void PollInputEvents(void)
// NOTE: Keyboard reading could be done using input_event(s) reading or just read from stdin, // NOTE: Keyboard reading could be done using input_event(s) reading or just read from stdin,
// we use method 2 (stdin) but maybe in a future we should change to method 1... // we use method 2 (stdin) but maybe in a future we should change to method 1...
#if !defined(USERAWKEYBOARD)
// NOTE: When using the raw keyboard we do not want to run this function.
ProcessKeyboard(); ProcessKeyboard();
#endif
// NOTE: Gamepad (Joystick) input events polling is done asynchonously in another pthread - GamepadThread() // NOTE: Gamepad (Joystick) input events polling is done asynchonously in another pthread - GamepadThread()
#endif #endif
} }
@ -3842,7 +3847,8 @@ static EM_BOOL EmscriptenGamepadCallback(int eventType, const EmscriptenGamepadE
} }
#endif #endif
#if defined(PLATFORM_RPI) #if defined(PLATFORM_RPI
#if !defined(USERAWKEYBOARD)
// Initialize Keyboard system (using standard input) // Initialize Keyboard system (using standard input)
static void InitKeyboard(void) static void InitKeyboard(void)
{ {
@ -4004,7 +4010,274 @@ static void RestoreKeyboard(void)
// Reconfigure keyboard to default mode // Reconfigure keyboard to default mode
ioctl(STDIN_FILENO, KDSKBMODE, defaultKeyboardMode); ioctl(STDIN_FILENO, KDSKBMODE, defaultKeyboardMode);
} }
#endif
#if defined(USERAWKEYBOARD)
// Keyboard input thread
static void *EventKeyBoardThread(void *arg)
{
struct input_event event;
InputEventWorker *worker = (InputEventWorker *)arg;
int code;
for (int i = 0; i <= 512; i++)
{
currentKeyState[i] = 0;
previousKeyState[i] = 0;
}
while (!windowShouldClose)
{
if (read(worker->fd, &event, sizeof(event)) == (int)sizeof(event))
{
if (event.type == 1 && event.value <= 1)
{
TraceLog(LOG_DEBUG, "KEY%s RawCode: %4i ScanCode: %4i KeyName: %s",event.value == 0 ? "UP":"DOWN", event.code, keynames[event.code].scancode, keynames[event.code].name );
// previousKeyState[event.code] = currentKeyState[event.code]; // Looked after each time drawing is finished
currentKeyState[keynames[event.code].scancode] = event.value;
lastKeyPressed = keynames[event.code].scancode;
}
}
usleep(5000);
#if defined(SUPPORT_SCREEN_CAPTURE)
// Check screen capture key (raylib key: KEY_F12)
if (currentKeyState[301] == 1)
{
TakeScreenshot(FormatText("screenshot%03i.png", screenshotCounter));
screenshotCounter++;
}
#endif
if (currentKeyState[exitKey] == 1) windowShouldClose = true;
}
}
// Identifies a input device and spawns a thread to handle it if needed
// Input device events reading thread
static void EventKeyBoardThreadSpawn(char *device)
{
#define BITS_PER_LONG (sizeof(long)*8)
#define NBITS(x) ((((x) - 1)/BITS_PER_LONG) + 1)
#define OFF(x) ((x)%BITS_PER_LONG)
#define BIT(x) (1UL<<OFF(x))
#define LONG(x) ((x)/BITS_PER_LONG)
#define TEST_BIT(array, bit) ((array[LONG(bit)] >> OFF(bit)) & 1)
struct input_absinfo absinfo;
unsigned long evBits[NBITS(EV_MAX)];
unsigned long absBits[NBITS(ABS_MAX)];
unsigned long relBits[NBITS(REL_MAX)];
unsigned long keyBits[NBITS(KEY_MAX)];
bool hasAbs = false;
bool hasRel = false;
bool hasAbsMulti = false;
int freeWorkerId = -1;
int fd = -1;
InputEventWorker *worker;
// Open the device and allocate worker
//-------------------------------------------------------------------------------------------------------
// Find a free spot in the workers array
for (int i = 0; i < sizeof(eventWorkers)/sizeof(InputEventWorker); ++i)
{
if (eventWorkers[i].threadId == 0)
{
freeWorkerId = i;
break;
}
}
// Select the free worker from array
if (freeWorkerId >= 0)
{
worker = &(eventWorkers[freeWorkerId]); // Grab a pointer to the worker
memset(worker, 0, sizeof(InputEventWorker)); // Clear the worker
}
else
{
TraceLog(LOG_WARNING, "Error creating input device thread for [%s]: Out of worker slots", device);
return;
}
// Open the device
fd = open(device, O_RDONLY | O_NONBLOCK);
if (fd < 0)
{
TraceLog(LOG_WARNING, "Error creating input device thread for [%s]: Can't open device (Error: %d)", device, worker->fd);
return;
}
worker->fd = fd;
// Grab number on the end of the devices name "event<N>"
int devNum = 0;
char *ptrDevName = strrchr(device, 't');
worker->eventNum = -1;
if (ptrDevName != NULL)
{
if (sscanf(ptrDevName, "t%d", &devNum) == 1)
worker->eventNum = devNum;
}
// At this point we have a connection to the device, but we don't yet know what the device is.
// It could be many things, even as simple as a power button...
//-------------------------------------------------------------------------------------------------------
// Identify the device
//-------------------------------------------------------------------------------------------------------
ioctl(fd, EVIOCGBIT(0, sizeof(evBits)), evBits); // Read a bitfield of the avalable device properties
// Check for absolute input devices
if (TEST_BIT(evBits, EV_ABS))
{
ioctl(fd, EVIOCGBIT(EV_ABS, sizeof(absBits)), absBits);
// Check for absolute movement support (usualy touchscreens, but also joysticks)
if (TEST_BIT(absBits, ABS_X) && TEST_BIT(absBits, ABS_Y))
{
hasAbs = true;
// Get the scaling values
ioctl(fd, EVIOCGABS(ABS_X), &absinfo);
worker->absRange.x = absinfo.minimum;
worker->absRange.width = absinfo.maximum - absinfo.minimum;
ioctl(fd, EVIOCGABS(ABS_Y), &absinfo);
worker->absRange.y = absinfo.minimum;
worker->absRange.height = absinfo.maximum - absinfo.minimum;
}
// Check for multiple absolute movement support (usualy multitouch touchscreens)
if (TEST_BIT(absBits, ABS_MT_POSITION_X) && TEST_BIT(absBits, ABS_MT_POSITION_Y))
{
hasAbsMulti = true;
// Get the scaling values
ioctl(fd, EVIOCGABS(ABS_X), &absinfo);
worker->absRange.x = absinfo.minimum;
worker->absRange.width = absinfo.maximum - absinfo.minimum;
ioctl(fd, EVIOCGABS(ABS_Y), &absinfo);
worker->absRange.y = absinfo.minimum;
worker->absRange.height = absinfo.maximum - absinfo.minimum;
}
}
// Check for relative movement support (usualy mouse)
if (TEST_BIT(evBits, EV_REL))
{
ioctl(fd, EVIOCGBIT(EV_REL, sizeof(relBits)), relBits);
if (TEST_BIT(relBits, REL_X) && TEST_BIT(relBits, REL_Y)) hasRel = true;
}
// Check for button support to determine the device type(usualy on all input devices)
if (TEST_BIT(evBits, EV_KEY))
{
ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(keyBits)), keyBits);
if (hasAbs || hasAbsMulti)
{
if (TEST_BIT(keyBits, BTN_TOUCH)) worker->isTouch = true; // This is a touchscreen
if (TEST_BIT(keyBits, BTN_TOOL_FINGER)) worker->isTouch = true; // This is a drawing tablet
if (TEST_BIT(keyBits, BTN_TOOL_PEN)) worker->isTouch = true; // This is a drawing tablet
if (TEST_BIT(keyBits, BTN_STYLUS)) worker->isTouch = true; // This is a drawing tablet
if (worker->isTouch || hasAbsMulti) worker->isMultitouch = true; // This is a multitouch capable device
}
if (hasRel)
{
if (TEST_BIT(keyBits, BTN_LEFT)) worker->isMouse = true; // This is a mouse
if (TEST_BIT(keyBits, BTN_RIGHT)) worker->isMouse = true; // This is a mouse
}
if (TEST_BIT(keyBits, BTN_A)) worker->isGamepad = true; // This is a gamepad
if (TEST_BIT(keyBits, BTN_TRIGGER)) worker->isGamepad = true; // This is a gamepad
if (TEST_BIT(keyBits, BTN_START)) worker->isGamepad = true; // This is a gamepad
if (TEST_BIT(keyBits, BTN_TL)) worker->isGamepad = true; // This is a gamepad
if (TEST_BIT(keyBits, BTN_TL)) worker->isGamepad = true; // This is a gamepad
if (TEST_BIT(keyBits, KEY_SPACE)) worker->isKeyboard = true; // This is a keyboard
}
//-------------------------------------------------------------------------------------------------------
// Decide what to do with the device
//-------------------------------------------------------------------------------------------------------
if (worker->isKeyboard)
{
// Looks like a interesting device
TraceLog(LOG_INFO, "Opening input device [%s] (%s%s%s%s%s)", device,
worker->isMouse ? "mouse " : "",
worker->isMultitouch ? "multitouch " : "",
worker->isTouch ? "touchscreen " : "",
worker->isGamepad ? "gamepad " : "",
worker->isKeyboard ? "keyboard " : "");
// Create a thread for this device
int error = pthread_create(&worker->threadId, NULL, &EventKeyBoardThread, (void *)worker);
if (error != 0)
{
TraceLog(LOG_WARNING, "Error creating input device thread for [%s]: Can't create thread (Error: %d)", device, error);
worker->threadId = 0;
close(fd);
}
}
else close(fd); // We are not interested in this device
//-------------------------------------------------------------------------------------------------------
}
// Initialize Keyboard system (using input events)
static void InitKeyboard(void)
{
// Keyboard to be read Directly from /input/eventX
TraceLog(LOG_INFO, "Initialize Keyboard system (using /input/eventX)");
char path[MAX_FILEPATH_LENGTH];
DIR *directory;
struct dirent *entity;
struct termios keyboardNewSettings;
// Setup Terminal to not echo to the screen and block ^C ^Z from sending Signals
if ( tcgetattr(STDIN_FILENO, &defaultKeyboardSettings) == -1 )
{
TraceLog(LOG_ERROR, "Unable to read Terminal Settings");
}
keyboardNewSettings = defaultKeyboardSettings;
keyboardNewSettings.c_lflag &= ~(ECHO | ISIG);
if ( tcsetattr(STDIN_FILENO, TCSAFLUSH, &keyboardNewSettings) == -1 )
{
TraceLog(LOG_ERROR, "Unable to write Terminal Settings");
}
// Open the linux directory of "/dev/input"
directory = opendir(DEFAULT_EVDEV_PATH);
if (directory)
{
while ((entity = readdir(directory)) != NULL)
{
if (strncmp("event", entity->d_name, strlen("event")) == 0) // Search for devices named "event*"
{
sprintf(path, "%s%s", DEFAULT_EVDEV_PATH, entity->d_name);
EventKeyBoardThreadSpawn(path); // Identify the device and spawn a thread for it
}
}
closedir(directory);
}
else TraceLog(LOG_WARNING, "Unable to open linux event directory: %s", DEFAULT_EVDEV_PATH);
// Register keyboard restore when program finishes
atexit(RestoreKeyboard);
}
// Restore default keyboard input
static void RestoreKeyboard(void)
{
TraceLog(LOG_DEBUG,"Restoring Keyboard");
if (tcsetattr(STDIN_FILENO, TCSAFLUSH, &defaultKeyboardSettings) == -1)
{
TraceLog(LOG_INFO,"Failed to restore Keyboard");
} else {
TraceLog(LOG_INFO,"Keyboard successfully restored");
}
}
#endif
// Mouse initialization (including mouse thread) // Mouse initialization (including mouse thread)
static void InitMouse(void) static void InitMouse(void)
{ {

448
src/keycodes.h Normal file
View File

@ -0,0 +1,448 @@
#ifndef KEYCODES_H
#define KEYCODES_H
struct parse_key {
char *name;
unsigned int rawcode;
unsigned int scancode;
} keynames[] = {
{"KEY_RESERVED", 0, 0}, // [x] Converted
{"KEY_ESC", 1, 256}, // [ ] Converted
{"KEY_1", 2, 49}, // [ ] Converted
{"KEY_2", 3, 50}, // [ ] Converted
{"KEY_3", 4, 51}, // [ ] Converted
{"KEY_4", 5, 52}, // [ ] Converted
{"KEY_5", 6, 53}, // [ ] Converted
{"KEY_6", 7, 54}, // [ ] Converted
{"KEY_7", 8, 55}, // [ ] Converted
{"KEY_8", 9, 56}, // [ ] Converted
{"KEY_9", 10, 57}, // [ ] Converted
{"KEY_0", 11, 48}, // [ ] Converted
{"KEY_MINUS", 12, 45}, // [ ] Converted
{"KEY_EQUAL", 13, 61}, // [ ] Converted
{"KEY_BACKSPACE", 14, 259}, // [ ] Converted
{"KEY_TAB", 15, 258}, // [ ] Converted
{"KEY_Q", 16, 81}, // [ ] Converted
{"KEY_W", 17, 87}, // [ ] Converted
{"KEY_E", 18, 69}, // [ ] Converted
{"KEY_R", 19, 82}, // [ ] Converted
{"KEY_T", 20, 84}, // [ ] Converted
{"KEY_Y", 21, 89}, // [ ] Converted
{"KEY_U", 22, 85}, // [ ] Converted
{"KEY_I", 23, 73}, // [ ] Converted
{"KEY_O", 24, 79}, // [ ] Converted
{"KEY_P", 25, 80}, // [ ] Converted
{"KEY_LEFTBRACE", 26, 91}, // [ ] Converted
{"KEY_RIGHTBRACE", 27, 93}, // [ ] Converted
{"KEY_ENTER", 28, 257}, // [ ] Converted
{"KEY_LEFTCTRL", 29, 341}, // [ ] Converted
{"KEY_A", 30, 65}, // [ ] Converted
{"KEY_S", 31, 83}, // [ ] Converted
{"KEY_D", 32, 68}, // [ ] Converted
{"KEY_F", 33, 70}, // [ ] Converted
{"KEY_G", 34, 71}, // [ ] Converted
{"KEY_H", 35, 72}, // [ ] Converted
{"KEY_J", 36, 74}, // [ ] Converted
{"KEY_K", 37, 75}, // [ ] Converted
{"KEY_L", 38, 76}, // [ ] Converted
{"KEY_SEMICOLON", 39, 59}, // [ ] Converted
{"KEY_APOSTROPHE", 40, 39}, // [ ] Converted
{"KEY_GRAVE", 41, 96}, // [ ] Converted
{"KEY_LEFTSHIFT", 42, 340}, // [ ] Converted
{"KEY_BACKSLASH", 43, 92}, // [ ] Converted
{"KEY_Z", 44, 90}, // [ ] Converted
{"KEY_X", 45, 88}, // [ ] Converted
{"KEY_C", 46, 67}, // [ ] Converted
{"KEY_V", 47, 86}, // [ ] Converted
{"KEY_B", 48, 66}, // [ ] Converted
{"KEY_N", 49, 78}, // [ ] Converted
{"KEY_M", 50, 77}, // [ ] Converted
{"KEY_COMMA", 51, 44}, // [ ] Converted
{"KEY_DOT", 52, 46}, // [ ] Converted
{"KEY_SLASH", 53, 47}, // [ ] Converted
{"KEY_RIGHTSHIFT", 54, 344}, // [ ] Converted
{"KEY_KPASTERISK", 55, 332}, // [ ] Converted
{"KEY_LEFTALT", 56, 342}, // [ ] Converted
{"KEY_SPACE", 57, 32}, // [ ] Converted
{"KEY_CAPSLOCK", 58, 280}, // [ ] Converted
{"KEY_F1", 59, 290}, // [ ] Converted
{"KEY_F2", 60, 291}, // [ ] Converted
{"KEY_F3", 61, 292}, // [ ] Converted
{"KEY_F4", 62, 293}, // [ ] Converted
{"KEY_F5", 63, 294}, // [ ] Converted
{"KEY_F6", 64, 295}, // [ ] Converted
{"KEY_F7", 65, 296}, // [ ] Converted
{"KEY_F8", 66, 297}, // [ ] Converted
{"KEY_F9", 67, 298}, // [ ] Converted
{"KEY_F10", 68, 299}, // [ ] Converted
{"KEY_NUMLOCK", 69, 282}, // [ ] Converted
{"KEY_SCROLLLOCK", 70, 281}, // [ ] Converted
{"KEY_KP7", 71, 327}, // [ ] Converted
{"KEY_KP8", 72, 328}, // [ ] Converted
{"KEY_KP9", 73, 329}, // [ ] Converted
{"KEY_KPMINUS", 74, 333}, // [ ] Converted
{"KEY_KP4", 75, 324}, // [ ] Converted
{"KEY_KP5", 76, 325}, // [ ] Converted
{"KEY_KP6", 77, 326}, // [ ] Converted
{"KEY_KPPLUS", 78, 334}, // [ ] Converted
{"KEY_KP1", 79, 321}, // [ ] Converted
{"KEY_KP2", 80, 322}, // [ ] Converted
{"KEY_KP3", 81, 323}, // [ ] Converted
{"KEY_KP0", 82, 320}, // [ ] Converted
{"KEY_KPDOT", 83, 330}, // [ ] Converte
{"KEY_NULL",84, 0}, // KEY NOT ASSIGNRD
{"KEY_ZENKAKUHANKAKU", 85, 85}, // [ ] Converted
{"KEY_102ND", 86, 86}, // [ ] Converted
{"KEY_F11", 87, 300}, // [ ] Converted
{"KEY_F12", 88, 301}, // [ ] Converted
{"KEY_RO", 89, 89}, // [ ] Converted
{"KEY_KATAKANA", 90, 90}, // [ ] Converted
{"KEY_HIRAGANA", 91, 91}, // [ ] Converted
{"KEY_HENKAN", 92, 92}, // [ ] Converted
{"KEY_KATAKANAHIRAGANA", 93, 93}, // [ ] Converted
{"KEY_MUHENKAN", 94, 94}, // [ ] Converted
{"KEY_KPJPCOMMA", 95, 95}, // [ ] Converted
{"KEY_KPENTER", 96, 335}, // [ ] Converted
{"KEY_RIGHTCTRL", 97, 345}, // [ ] Converted
{"KEY_KPSLASH", 98, 331}, // [ ] Converted
{"KEY_SYSRQ", 99, 283}, // [ ] Converted
{"KEY_RIGHTALT", 100, 346}, // [ ] Converted
{"KEY_LINEFEED", 101, 101}, // [ ] Converted
{"KEY_HOME", 102, 268}, // [ ] Converted
{"KEY_UP", 103, 265}, // [ ] Converted
{"KEY_PAGEUP", 104, 266}, // [ ] Converted
{"KEY_LEFT", 105, 263}, // [ ] Converted
{"KEY_RIGHT", 106, 262}, // [ ] Converted
{"KEY_END", 107, 269}, // [ ] Converted
{"KEY_DOWN", 108, 264}, // [ ] Converted
{"KEY_PAGEDOWN", 109, 267}, // [ ] Converted
{"KEY_INSERT", 110, 260}, // [ ] Converted
{"KEY_DELETE", 111, 261}, // [ ] Converted
{"KEY_MACRO", 112, 112}, // [ ] Converted
{"KEY_MUTE", 113, 113}, // [ ] Converted
{"KEY_VOLUMEDOWN", 114, 114}, // [ ] Converted
{"KEY_VOLUMEUP", 115, 115}, // [ ] Converted
{"KEY_POWER", 116, 116}, // [ ] Converted
{"KEY_KPEQUAL", 117, 117}, // [ ] Converted
{"KEY_KPPLUSMINUS", 118, 118}, // [ ] Converted
{"KEY_PAUSE", 119, 119}, // [ ] Converted
{"KEY_SCALE", 120, 120}, // [ ] Converted
{"KEY_KPCOMMA", 121, 121}, // [ ] Converted
{"KEY_HANGEUL", 122, 122}, // [ ] Converted
{"KEY_HANJA", 123, 123}, // [ ] Converted
{"KEY_YEN", 124, 124}, // [ ] Converted
{"KEY_LEFTMETA", 125, 125}, // [ ] Converted
{"KEY_RIGHTMETA", 126, 347}, // [ ] Converted
{"KEY_COMPOSE", 127, 127}, // [ ] Converted
{"KEY_STOP", 128, 128}, // [ ] Converted
{"KEY_AGAIN", 129, 129}, // [ ] Converted
{"KEY_PROPS", 130, 130}, // [ ] Converted
{"KEY_UNDO", 131, 131}, // [ ] Converted
{"KEY_FRONT", 132, 132}, // [ ] Converted
{"KEY_COPY", 133, 133}, // [ ] Converted
{"KEY_OPEN", 134, 134}, // [ ] Converted
{"KEY_PASTE", 135, 135}, // [ ] Converted
{"KEY_FIND", 136, 136}, // [ ] Converted
{"KEY_CUT", 137, 137}, // [ ] Converted
{"KEY_HELP", 138, 138}, // [ ] Converted
{"KEY_MENU", 139, 139}, // [ ] Converted
{"KEY_CALC", 140, 140}, // [ ] Converted
{"KEY_SETUP", 141, 141}, // [ ] Converted
{"KEY_SLEEP", 142, 142}, // [ ] Converted
{"KEY_WAKEUP", 143, 143}, // [ ] Converted
{"KEY_FILE", 144, 144}, // [ ] Converted
{"KEY_SENDFILE", 145, 145}, // [ ] Converted
{"KEY_DELETEFILE", 146, 146}, // [ ] Converted
{"KEY_XFER", 147, 147}, // [ ] Converted
{"KEY_PROG1", 148, 148}, // [ ] Converted
{"KEY_PROG2", 149, 149}, // [ ] Converted
{"KEY_WWW", 150, 150}, // [ ] Converted
{"KEY_MSDOS", 151, 151}, // [ ] Converted
{"KEY_SCREENLOCK", 152, 152}, // [ ] Converted
{"KEY_ROTATE_DISPLAY", 153, 153}, // [ ] Converted
{"KEY_CYCLEWINDOWS", 154, 154}, // [ ] Converted
{"KEY_MAIL", 155, 155}, // [ ] Converted
{"KEY_BOOKMARKS", 156, 156}, // [ ] Converted
{"KEY_COMPUTER", 157, 157}, // [ ] Converted
{"KEY_BACK", 158, 158}, // [ ] Converted
{"KEY_FORWARD", 159, 159}, // [ ] Converted
{"KEY_CLOSECD", 160, 160}, // [ ] Converted
{"KEY_EJECTCD", 161, 161}, // [ ] Converted
{"KEY_EJECTCLOSECD", 162, 162}, // [ ] Converted
{"KEY_NEXTSONG", 163, 163}, // [ ] Converted
{"KEY_PLAYPAUSE", 164, 164}, // [ ] Converted
{"KEY_PREVIOUSSONG", 165, 165}, // [ ] Converted
{"KEY_STOPCD", 166, 166}, // [ ] Converted
{"KEY_RECORD", 167, 167}, // [ ] Converted
{"KEY_REWIND", 168, 168}, // [ ] Converted
{"KEY_PHONE", 169, 169}, // [ ] Converted
{"KEY_ISO", 170, 170}, // [ ] Converted
{"KEY_CONFIG", 171, 171}, // [ ] Converted
{"KEY_HOMEPAGE", 172, 172}, // [ ] Converted
{"KEY_REFRESH", 173, 173}, // [ ] Converted
{"KEY_EXIT", 174, 174}, // [ ] Converted
{"KEY_MOVE", 175, 175}, // [ ] Converted
{"KEY_EDIT", 176, 176}, // [ ] Converted
{"KEY_SCROLLUP", 177, 177}, // [ ] Converted
{"KEY_SCROLLDOWN", 178, 178}, // [ ] Converted
{"KEY_KPLEFTPAREN", 179, 179}, // [ ] Converted
{"KEY_KPRIGHTPAREN", 180, 180}, // [ ] Converted
{"KEY_NEW", 181, 181}, // [ ] Converted
{"KEY_REDO", 182, 182}, // [ ] Converted
{"KEY_F13", 183, 183}, // [ ] Converted
{"KEY_F14", 184, 184}, // [ ] Converted
{"KEY_F15", 185, 185}, // [ ] Converted
{"KEY_F16", 186, 186}, // [ ] Converted
{"KEY_F17", 187, 187}, // [ ] Converted
{"KEY_F18", 188, 188}, // [ ] Converted
{"KEY_F19", 189, 189}, // [ ] Converted
{"KEY_F20", 190, 190}, // [ ] Converted
{"KEY_F21", 191, 191}, // [ ] Converted
{"KEY_F22", 192, 192}, // [ ] Converted
{"KEY_F23", 193, 193}, // [ ] Converted
{"KEY_F24", 194, 194}, // [ ] Converted
{"KEY_PLAYCD", 200, 200}, // [ ] Converted
{"KEY_PAUSECD", 201, 201}, // [ ] Converted
{"KEY_PROG3", 202, 202}, // [ ] Converted
{"KEY_PROG4", 203, 203}, // [ ] Converted
{"KEY_DASHBOARD", 204, 204}, // [ ] Converted
{"KEY_SUSPEND", 205, 205}, // [ ] Converted
{"KEY_CLOSE", 206, 206}, // [ ] Converted
{"KEY_PLAY", 207, 207}, // [ ] Converted
{"KEY_FASTFORWARD", 208, 208}, // [ ] Converted
{"KEY_BASSBOOST", 209, 209}, // [ ] Converted
{"KEY_PRINT", 210, 210}, // [ ] Converted
{"KEY_HP", 211, 211}, // [ ] Converted
{"KEY_CAMERA", 212, 212}, // [ ] Converted
{"KEY_SOUND", 213, 213}, // [ ] Converted
{"KEY_QUESTION", 214, 214}, // [ ] Converted
{"KEY_EMAIL", 215, 215}, // [ ] Converted
{"KEY_CHAT", 216, 216}, // [ ] Converted
{"KEY_SEARCH", 217, 217}, // [ ] Converted
{"KEY_CONNECT", 218, 218}, // [ ] Converted
{"KEY_FINANCE", 219, 219}, // [ ] Converted
{"KEY_SPORT", 220, 220}, // [ ] Converted
{"KEY_SHOP", 221, 221}, // [ ] Converted
{"KEY_ALTERASE", 222, 222}, // [ ] Converted
{"KEY_CANCEL", 223, 223}, // [ ] Converted
{"KEY_BRIGHTNESSDOWN", 224, 224}, // [ ] Converted
{"KEY_BRIGHTNESSUP", 225, 225}, // [ ] Converted
{"KEY_MEDIA", 226, 226}, // [ ] Converted
{"KEY_SWITCHVIDEOMODE", 227, 227}, // [ ] Converted
{"KEY_KBDILLUMTOGGLE", 228, 228}, // [ ] Converted
{"KEY_KBDILLUMDOWN", 229, 229}, // [ ] Converted
{"KEY_KBDILLUMUP", 230, 230}, // [ ] Converted
{"KEY_SEND", 231, 231}, // [ ] Converted
{"KEY_REPLY", 232, 232}, // [ ] Converted
{"KEY_FORWARDMAIL", 233, 233}, // [ ] Converted
{"KEY_SAVE", 234, 234}, // [ ] Converted
{"KEY_DOCUMENTS", 235, 235}, // [ ] Converted
{"KEY_BATTERY", 236, 236}, // [ ] Converted
{"KEY_BLUETOOTH", 237, 237}, // [ ] Converted
{"KEY_WLAN", 238, 238}, // [ ] Converted
{"KEY_UWB", 239, 239}, // [ ] Converted
{"KEY_UNKNOWN", 240, 240}, // [ ] Converted
{"KEY_VIDEO_NEXT", 241, 241}, // [ ] Converted
{"KEY_VIDEO_PREV", 242, 242}, // [ ] Converted
{"KEY_BRIGHTNESS_CYCLE", 243, 243}, // [ ] Converted
{"KEY_BRIGHTNESS_AUTO", 244, 244}, // [ ] Converted
{"KEY_DISPLAY_OFF", 245, 245}, // [ ] Converted
{"KEY_WWAN", 246, 246}, // [ ] Converted
{"KEY_RFKILL", 247, 247}, // [ ] Converted
{"KEY_MICMUTE", 248, 248}, // [ ] Converted
{"KEY_OK", 0x160, 0x160}, // [ ] Converted
{"KEY_SELECT", 0x161, 0x161}, // [ ] Converted
{"KEY_GOTO", 0x162, 0x162}, // [ ] Converted
{"KEY_CLEAR", 0x163, 0x163}, // [ ] Converted
{"KEY_POWER2", 0x164, 0x164}, // [ ] Converted
{"KEY_OPTION", 0x165, 0x165}, // [ ] Converted
{"KEY_INFO", 0x166, 0x166}, // [ ] Converted
{"KEY_TIME", 0x167, 0x167}, // [ ] Converted
{"KEY_VENDOR", 0x168, 0x168}, // [ ] Converted
{"KEY_ARCHIVE", 0x169, 0x169}, // [ ] Converted
{"KEY_PROGRAM", 0x16a, 0x16a}, // [ ] Converted
{"KEY_CHANNEL", 0x16b, 0x16b}, // [ ] Converted
{"KEY_FAVORITES", 0x16c, 0x16c}, // [ ] Converted
{"KEY_EPG", 0x16d, 0x16d}, // [ ] Converted
{"KEY_PVR", 0x16e, 0x16e}, // [ ] Converted
{"KEY_MHP", 0x16f, 0x16f}, // [ ] Converted
{"KEY_LANGUAGE", 0x170, 0x170}, // [ ] Converted
{"KEY_TITLE", 0x171, 0x171}, // [ ] Converted
{"KEY_SUBTITLE", 0x172, 0x172}, // [ ] Converted
{"KEY_ANGLE", 0x173, 0x173}, // [ ] Converted
{"KEY_ZOOM", 0x174, 0x174}, // [ ] Converted
{"KEY_MODE", 0x175, 0x175}, // [ ] Converted
{"KEY_KEYBOARD", 0x176, 0x176}, // [ ] Converted
{"KEY_SCREEN", 0x177, 0x177}, // [ ] Converted
{"KEY_PC", 0x178, 0x178}, // [ ] Converted
{"KEY_TV", 0x179, 0x179}, // [ ] Converted
{"KEY_TV2", 0x17a, 0x17a}, // [ ] Converted
{"KEY_VCR", 0x17b, 0x17b}, // [ ] Converted
{"KEY_VCR2", 0x17c, 0x17c}, // [ ] Converted
{"KEY_SAT", 0x17d, 0x17d}, // [ ] Converted
{"KEY_SAT2", 0x17e, 0x17e}, // [ ] Converted
{"KEY_CD", 0x17f, 0x17f}, // [ ] Converted
{"KEY_TAPE", 0x180, 0x180}, // [ ] Converted
{"KEY_RADIO", 0x181, 0x181}, // [ ] Converted
{"KEY_TUNER", 0x182, 0x182}, // [ ] Converted
{"KEY_PLAYER", 0x183, 0x183}, // [ ] Converted
{"KEY_TEXT", 0x184, 0x184}, // [ ] Converted
{"KEY_DVD", 0x185, 0x185}, // [ ] Converted
{"KEY_AUX", 0x186, 0x186}, // [ ] Converted
{"KEY_MP3", 0x187, 0x187}, // [ ] Converted
{"KEY_AUDIO", 0x188, 0x188}, // [ ] Converted
{"KEY_VIDEO", 0x189, 0x189}, // [ ] Converted
{"KEY_DIRECTORY", 0x18a, 0x18a}, // [ ] Converted
{"KEY_LIST", 0x18b, 0x18b}, // [ ] Converted
{"KEY_MEMO", 0x18c, 0x18c}, // [ ] Converted
{"KEY_CALENDAR", 0x18d, 0x18d}, // [ ] Converted
{"KEY_RED", 0x18e, 0x18e}, // [ ] Converted
{"KEY_GREEN", 0x18f, 0x18f}, // [ ] Converted
{"KEY_YELLOW", 0x190, 0x190}, // [ ] Converted
{"KEY_BLUE", 0x191, 0x191}, // [ ] Converted
{"KEY_CHANNELUP", 0x192, 0x192}, // [ ] Converted
{"KEY_CHANNELDOWN", 0x193, 0x193}, // [ ] Converted
{"KEY_FIRST", 0x194, 0x194}, // [ ] Converted
{"KEY_LAST", 0x195, 0x195}, // [ ] Converted
{"KEY_AB", 0x196, 0x196}, // [ ] Converted
{"KEY_NEXT", 0x197, 0x197}, // [ ] Converted
{"KEY_RESTART", 0x198, 0x198}, // [ ] Converted
{"KEY_SLOW", 0x199, 0x199}, // [ ] Converted
{"KEY_SHUFFLE", 0x19a, 0x19a}, // [ ] Converted
{"KEY_BREAK", 0x19b, 0x19b}, // [ ] Converted
{"KEY_PREVIOUS", 0x19c, 0x19c}, // [ ] Converted
{"KEY_DIGITS", 0x19d, 0x19d}, // [ ] Converted
{"KEY_TEEN", 0x19e, 0x19e}, // [ ] Converted
{"KEY_TWEN", 0x19f, 0x19f}, // [ ] Converted
{"KEY_VIDEOPHONE", 0x1a0, 0x1a0}, // [ ] Converted
{"KEY_GAMES", 0x1a1, 0x1a1}, // [ ] Converted
{"KEY_ZOOMIN", 0x1a2, 0x1a2}, // [ ] Converted
{"KEY_ZOOMOUT", 0x1a3, 0x1a3}, // [ ] Converted
{"KEY_ZOOMRESET", 0x1a4, 0x1a4}, // [ ] Converted
{"KEY_WORDPROCESSOR", 0x1a5, 0x1a5}, // [ ] Converted
{"KEY_EDITOR", 0x1a6, 0x1a6}, // [ ] Converted
{"KEY_SPREADSHEET", 0x1a7, 0x1a7}, // [ ] Converted
{"KEY_GRAPHICSEDITOR", 0x1a8, 0x1a8}, // [ ] Converted
{"KEY_PRESENTATION", 0x1a9, 0x1a9}, // [ ] Converted
{"KEY_DATABASE", 0x1aa, 0x1aa}, // [ ] Converted
{"KEY_NEWS", 0x1ab, 0x1ab}, // [ ] Converted
{"KEY_VOICEMAIL", 0x1ac, 0x1ac}, // [ ] Converted
{"KEY_ADDRESSBOOK", 0x1ad, 0x1ad}, // [ ] Converted
{"KEY_MESSENGER", 0x1ae, 0x1ae}, // [ ] Converted
{"KEY_DISPLAYTOGGLE", 0x1af, 0x1af}, // [ ] Converted
{"KEY_SPELLCHECK", 0x1b0, 0x1b0}, // [ ] Converted
{"KEY_LOGOFF", 0x1b1, 0x1b1}, // [ ] Converted
{"KEY_DOLLAR", 0x1b2, 0x1b2}, // [ ] Converted
{"KEY_EURO", 0x1b3, 0x1b3}, // [ ] Converted
{"KEY_FRAMEBACK", 0x1b4, 0x1b4}, // [ ] Converted
{"KEY_FRAMEFORWARD", 0x1b5, 0x1b5}, // [ ] Converted
{"KEY_CONTEXT_MENU", 0x1b6, 0x1b6}, // [ ] Converted
{"KEY_MEDIA_REPEAT", 0x1b7, 0x1b7}, // [ ] Converted
{"KEY_10CHANNELSUP", 0x1b8, 0x1b8}, // [ ] Converted
{"KEY_10CHANNELSDOWN", 0x1b9, 0x1b9}, // [ ] Converted
{"KEY_IMAGES", 0x1ba, 0x1ba}, // [ ] Converted
{"KEY_DEL_EOL", 0x1c0, 0x1c0}, // [ ] Converted
{"KEY_DEL_EOS", 0x1c1, 0x1c1}, // [ ] Converted
{"KEY_INS_LINE", 0x1c2, 0x1c2}, // [ ] Converted
{"KEY_DEL_LINE", 0x1c3, 0x1c3}, // [ ] Converted
{"KEY_FN", 0x1d0, 0x1d0}, // [ ] Converted
{"KEY_FN_ESC", 0x1d1, 0x1d1}, // [ ] Converted
{"KEY_FN_F1", 0x1d2, 0x1d2}, // [ ] Converted
{"KEY_FN_F2", 0x1d3, 0x1d3}, // [ ] Converted
{"KEY_FN_F3", 0x1d4, 0x1d4}, // [ ] Converted
{"KEY_FN_F4", 0x1d5, 0x1d5}, // [ ] Converted
{"KEY_FN_F5", 0x1d6, 0x1d6}, // [ ] Converted
{"KEY_FN_F6", 0x1d7, 0x1d7}, // [ ] Converted
{"KEY_FN_F7", 0x1d8, 0x1d8}, // [ ] Converted
{"KEY_FN_F8", 0x1d9, 0x1d9}, // [ ] Converted
{"KEY_FN_F9", 0x1da, 0x1da}, // [ ] Converted
{"KEY_FN_F10", 0x1db, 0x1db}, // [ ] Converted
{"KEY_FN_F11", 0x1dc, 0x1dc}, // [ ] Converted
{"KEY_FN_F12", 0x1dd, 0x1dd}, // [ ] Converted
{"KEY_FN_1", 0x1de, 0x1de}, // [ ] Converted
{"KEY_FN_2", 0x1df, 0x1df}, // [ ] Converted
{"KEY_FN_D", 0x1e0, 0x1e0}, // [ ] Converted
{"KEY_FN_E", 0x1e1, 0x1e1}, // [ ] Converted
{"KEY_FN_F", 0x1e2, 0x1e2}, // [ ] Converted
{"KEY_FN_S", 0x1e3, 0x1e3}, // [ ] Converted
{"KEY_FN_B", 0x1e4, 0x1e4}, // [ ] Converted
{"KEY_BRL_DOT1", 0x1f1, 0x1f1}, // [ ] Converted
{"KEY_BRL_DOT2", 0x1f2, 0x1f2}, // [ ] Converted
{"KEY_BRL_DOT3", 0x1f3, 0x1f3}, // [ ] Converted
{"KEY_BRL_DOT4", 0x1f4, 0x1f4}, // [ ] Converted
{"KEY_BRL_DOT5", 0x1f5, 0x1f5}, // [ ] Converted
{"KEY_BRL_DOT6", 0x1f6, 0x1f6}, // [ ] Converted
{"KEY_BRL_DOT7", 0x1f7, 0x1f7}, // [ ] Converted
{"KEY_BRL_DOT8", 0x1f8, 0x1f8}, // [ ] Converted
{"KEY_BRL_DOT9", 0x1f9, 0x1f9}, // [ ] Converted
{"KEY_BRL_DOT10", 0x1fa, 0x1fa}, // [ ] Converted
{"KEY_NUMERIC_0", 0x200, 0x200}, // [ ] Converted
{"KEY_NUMERIC_1", 0x201, 0x201}, // [ ] Converted
{"KEY_NUMERIC_2", 0x202, 0x202}, // [ ] Converted
{"KEY_NUMERIC_3", 0x203, 0x203}, // [ ] Converted
{"KEY_NUMERIC_4", 0x204, 0x204}, // [ ] Converted
{"KEY_NUMERIC_5", 0x205, 0x205}, // [ ] Converted
{"KEY_NUMERIC_6", 0x206, 0x206}, // [ ] Converted
{"KEY_NUMERIC_7", 0x207, 0x207}, // [ ] Converted
{"KEY_NUMERIC_8", 0x208, 0x208}, // [ ] Converted
{"KEY_NUMERIC_9", 0x209, 0x209}, // [ ] Converted
{"KEY_NUMERIC_STAR", 0x20a, 0x20a}, // [ ] Converted
{"KEY_NUMERIC_POUND", 0x20b, 0x20b}, // [ ] Converted
{"KEY_NUMERIC_A", 0x20c, 0x20c}, // [ ] Converted
{"KEY_NUMERIC_B", 0x20d, 0x20d}, // [ ] Converted
{"KEY_NUMERIC_C", 0x20e, 0x20e}, // [ ] Converted
{"KEY_NUMERIC_D", 0x20f, 0x20f}, // [ ] Converted
{"KEY_CAMERA_FOCUS", 0x210, 0x210}, // [ ] Converted
{"KEY_WPS_BUTTON", 0x211, 0x211}, // [ ] Converted
{"KEY_TOUCHPAD_TOGGLE", 0x212, 0x212}, // [ ] Converted
{"KEY_TOUCHPAD_ON", 0x213, 0x213}, // [ ] Converted
{"KEY_TOUCHPAD_OFF", 0x214, 0x214}, // [ ] Converted
{"KEY_CAMERA_ZOOMIN", 0x215, 0x215}, // [ ] Converted
{"KEY_CAMERA_ZOOMOUT", 0x216, 0x216}, // [ ] Converted
{"KEY_CAMERA_UP", 0x217, 0x217}, // [ ] Converted
{"KEY_CAMERA_DOWN", 0x218, 0x218}, // [ ] Converted
{"KEY_CAMERA_LEFT", 0x219, 0x219}, // [ ] Converted
{"KEY_CAMERA_RIGHT", 0x21a, 0x21a}, // [ ] Converted
{"KEY_ATTENDANT_ON", 0x21b, 0x21b}, // [ ] Converted
{"KEY_ATTENDANT_OFF", 0x21c, 0x21c}, // [ ] Converted
{"KEY_ATTENDANT_TOGGLE", 0x21d, 0x21d}, // [ ] Converted
{"KEY_LIGHTS_TOGGLE", 0x21e, 0x21e}, // [ ] Converted
{"KEY_ALS_TOGGLE", 0x230, 0x230}, // [ ] Converted
{"KEY_BUTTONCONFIG", 0x240, 0x240}, // [ ] Converted
{"KEY_TASKMANAGER", 0x241, 0x241}, // [ ] Converted
{"KEY_JOURNAL", 0x242, 0x242}, // [ ] Converted
{"KEY_CONTROLPANEL", 0x243, 0x243}, // [ ] Converted
{"KEY_APPSELECT", 0x244, 0x244}, // [ ] Converted
{"KEY_SCREENSAVER", 0x245, 0x245}, // [ ] Converted
{"KEY_VOICECOMMAND", 0x246, 0x246}, // [ ] Converted
{"KEY_BRIGHTNESS_MIN", 0x250, 0x250}, // [ ] Converted
{"KEY_BRIGHTNESS_MAX", 0x251, 0x251}, // [ ] Converted
{"KEY_KBDINPUTASSIST_PREV", 0x260, 0x260}, // [ ] Converted
{"KEY_KBDINPUTASSIST_NEXT", 0x261, 0x261}, // [ ] Converted
{"KEY_KBDINPUTASSIST_PREVGROUP", 0x262, 0x262}, // [ ] Converted
{"KEY_KBDINPUTASSIST_NEXTGROUP", 0x263, 0x263}, // [ ] Converted
{"KEY_KBDINPUTASSIST_ACCEPT", 0x264, 0x264}, // [ ] Converted
{"KEY_KBDINPUTASSIST_CANCEL", 0x265, 0x265}, // [ ] Converted
{"KEY_RIGHT_UP", 0x266, 0x266}, // [ ] Converted
{"KEY_RIGHT_DOWN", 0x267, 0x267}, // [ ] Converted
{"KEY_LEFT_UP", 0x268, 0x268}, // [ ] Converted
{"KEY_LEFT_DOWN", 0x269, 0x269}, // [ ] Converted
{"KEY_ROOT_MENU", 0x26a, 0x26a}, // [ ] Converted
{"KEY_MEDIA_TOP_MENU", 0x26b, 0x26b}, // [ ] Converted
{"KEY_NUMERIC_11", 0x26c, 0x26c}, // [ ] Converted
{"KEY_NUMERIC_12", 0x26d, 0x26d}, // [ ] Converted
{"KEY_AUDIO_DESC", 0x26e, 0x26e}, // [ ] Converted
{"KEY_3D_MODE", 0x26f, 0x26f}, // [ ] Converted
{"KEY_NEXT_FAVORITE", 0x270, 0x270}, // [ ] Converted
{"KEY_STOP_RECORD", 0x271, 0x271}, // [ ] Converted
{"KEY_PAUSE_RECORD", 0x272, 0x272}, // [ ] Converted
{"KEY_VOD", 0x273, 0x273}, // [ ] Converted
{"KEY_UNMUTE", 0x274, 0x274}, // [ ] Converted
{"KEY_FASTREVERSE", 0x275, 0x275}, // [ ] Converted
{"KEY_SLOWREVERSE", 0x276, 0x276}, // [ ] Converted
{"KEY_DATA", 0x277, 0x277}, // [ ] Converted
{"KEY_MAX", 0x2ff, 0x2ff}, // [ ] Converted
{ NULL, 0}
};
#endif