Skip to content

Instantly share code, notes, and snippets.

@StefanoBelli

StefanoBelli/linux-keys.c

Last active November 25, 2017 11:09
Show Gist options
  • Save StefanoBelli/c12965643c86044719c75fcaaa7d0178 to your computer and use it in GitHub Desktop.
Save StefanoBelli/c12965643c86044719c75fcaaa7d0178 to your computer and use it in GitHub Desktop.
Download ZIP
Linux keypress control utils
Raw
linux-keys.c
/*
* Based on @Andrea993 / github.com/andrea993 's work
* gcc -c -std=c99 -D_GNU_SOURCE
* or
* gcc -c -std=gnu99
*/
#include <linux/limits.h>
#include <linux/input.h>
#include <dirent.h>
#include <string.h>
#include <unistd.h>
#include <stdlib.h>
#include "linux-keys.h"
#define EVENT_BYPATH "/dev/input/by-path/"
#define NEED_MATCH "-event-kbd"
#define NEED_MATCH_COUNT 10
#define COPY_INPUT_EVENT(from_stream,dest) \
for(unsigned i=0;i<sizeof(struct input_event);i++) \
((char*)&dest)[i] = fgetc(from_stream)
int get_keyboard_evpath_s(char* target)
{
DIR* evbp_dir = opendir(EVENT_BYPATH);
if(evbp_dir == NULL)
return CANNOT_OPENDIR;
struct dirent *entry;
while((entry=readdir(evbp_dir))) {
if(entry->d_type == DT_LNK) {
if(!strncmp(entry->d_name + (strlen(entry->d_name) - NEED_MATCH_COUNT),NEED_MATCH,NEED_MATCH_COUNT))
break;
}
}
char local_target[PATH_MAX];
int evbpfd = dirfd(evbp_dir);
if(readlinkat(evbpfd,entry->d_name,local_target,sizeof(entry->d_name)) < 0)
return CANNOT_READLINK;
char current_workdir[PATH_MAX];
if(getcwd(current_workdir,PATH_MAX) == NULL)
return CANNOT_GETCWD;
if(fchdir(evbpfd) < 0)
return CANNOT_FCHDIR;
if(realpath(local_target,target) == NULL)
return CANNOT_GETREALPATH;
if(closedir(evbp_dir) < 0)
return CANNOT_CLOSEDIR;
if(chdir(current_workdir) < 0)
return CANNOT_CHDIR;
return 0;
}
key wait_for_keypress(FILE* stream)
{
struct input_event current;
while(1) {
COPY_INPUT_EVENT(stream,current);
if(current.type == EV_KEY && current.value == 1)
return current.code;
}
return -1;
}
void keycode_to_stream(key code, FILE* _outptr)
{
switch(code)
{
case(KEY_RESERVED): fputs("RESERVED",_outptr); break;
case(KEY_ESC): fputs("ESC",_outptr); break;
case(KEY_1): fputs("1",_outptr); break;
case(KEY_2): fputs("2",_outptr); break;
case(KEY_3): fputs("3",_outptr); break;
case(KEY_4): fputs("4",_outptr); break;
case(KEY_5): fputs("5",_outptr); break;
case(KEY_6): fputs("6",_outptr); break;
case(KEY_7): fputs("7",_outptr); break;
case(KEY_8): fputs("8",_outptr); break;
case(KEY_9): fputs("9",_outptr); break;
case(KEY_0): fputs("0",_outptr); break;
case(KEY_MINUS): fputs("MINUS",_outptr); break;
case(KEY_EQUAL): fputs("EQUAL",_outptr); break;
case(KEY_BACKSPACE): fputs("BACKSPACE",_outptr); break;
case(KEY_TAB): fputs("TAB",_outptr); break;
case(KEY_Q): fputs("Q",_outptr); break;
case(KEY_W): fputs("W",_outptr); break;
case(KEY_E): fputs("E",_outptr); break;
case(KEY_R): fputs("R",_outptr); break;
case(KEY_T): fputs("T",_outptr); break;
case(KEY_Y): fputs("Y",_outptr); break;
case(KEY_U): fputs("U",_outptr); break;
case(KEY_I): fputs("I",_outptr); break;
case(KEY_O): fputs("O",_outptr); break;
case(KEY_P): fputs("P",_outptr); break;
case(KEY_LEFTBRACE): fputs("LEFTBRACE",_outptr); break;
case(KEY_RIGHTBRACE): fputs("RIGHTBRACE",_outptr); break;
case(KEY_ENTER): fputs("ENTER",_outptr); break;
case(KEY_LEFTCTRL): fputs("LEFTCTRL",_outptr); break;
case(KEY_A): fputs("A",_outptr); break;
case(KEY_S): fputs("S",_outptr); break;
case(KEY_D): fputs("D",_outptr); break;
case(KEY_F): fputs("F",_outptr); break;
case(KEY_G): fputs("G",_outptr); break;
case(KEY_H): fputs("H",_outptr); break;
case(KEY_J): fputs("J",_outptr); break;
case(KEY_K): fputs("K",_outptr); break;
case(KEY_L): fputs("L",_outptr); break;
case(KEY_SEMICOLON): fputs("SEMICOLON",_outptr); break;
case(KEY_APOSTROPHE): fputs("APOSTROPHE",_outptr); break;
case(KEY_GRAVE): fputs("GRAVE",_outptr); break;
case(KEY_LEFTSHIFT): fputs("LEFTSHIFT",_outptr); break;
case(KEY_BACKSLASH): fputs("BACKSLASH",_outptr); break;
case(KEY_Z): fputs("Z",_outptr); break;
case(KEY_X): fputs("X",_outptr); break;
case(KEY_C): fputs("C",_outptr); break;
case(KEY_V): fputs("V",_outptr); break;
case(KEY_B): fputs("B",_outptr); break;
case(KEY_N): fputs("N",_outptr); break;
case(KEY_M): fputs("M",_outptr); break;
case(KEY_COMMA): fputs("COMMA",_outptr); break;
case(KEY_DOT): fputs("DOT",_outptr); break;
case(KEY_SLASH): fputs("SLASH",_outptr); break;
case(KEY_RIGHTSHIFT): fputs("RIGHTSHIFT",_outptr); break;
case(KEY_KPASTERISK): fputs("KPASTERISK",_outptr); break;
case(KEY_LEFTALT): fputs("LEFTALT",_outptr); break;
case(KEY_SPACE): fputs("SPACE",_outptr); break;
case(KEY_CAPSLOCK): fputs("CAPSLOCK",_outptr); break;
case(KEY_F1): fputs("F1",_outptr); break;
case(KEY_F2): fputs("F2",_outptr); break;
case(KEY_F3): fputs("F3",_outptr); break;
case(KEY_F4): fputs("F4",_outptr); break;
case(KEY_F5): fputs("F5",_outptr); break;
case(KEY_F6): fputs("F6",_outptr); break;
case(KEY_F7): fputs("F7",_outptr); break;
case(KEY_F8): fputs("F8",_outptr); break;
case(KEY_F9): fputs("F9",_outptr); break;
case(KEY_F10): fputs("F10",_outptr); break;
case(KEY_NUMLOCK): fputs("NUMLOCK",_outptr); break;
case(KEY_SCROLLLOCK): fputs("SCROLLLOCK",_outptr); break;
case(KEY_KP7): fputs("KP7",_outptr); break;
case(KEY_KP8): fputs("KP8",_outptr); break;
case(KEY_KP9): fputs("KP9",_outptr); break;
case(KEY_KPMINUS): fputs("KPMINUS",_outptr); break;
case(KEY_KP4): fputs("KP4",_outptr); break;
case(KEY_KP5): fputs("KP5",_outptr); break;
case(KEY_KP6): fputs("KP6",_outptr); break;
case(KEY_KPPLUS): fputs("KPPLUS",_outptr); break;
case(KEY_KP1): fputs("KP1",_outptr); break;
case(KEY_KP2): fputs("KP2",_outptr); break;
case(KEY_KP3): fputs("KP3",_outptr); break;
case(KEY_KP0): fputs("KP0",_outptr); break;
case(KEY_KPDOT): fputs("KPDOT",_outptr); break;
case(KEY_ZENKAKUHANKAKU): fputs("ZENKAKUHANKAKU",_outptr); break;
case(KEY_102ND): fputs("102ND",_outptr); break;
case(KEY_F11): fputs("F11",_outptr); break;
case(KEY_F12): fputs("F12",_outptr); break;
case(KEY_RO): fputs("RO",_outptr); break;
case(KEY_KATAKANA): fputs("KATAKANA",_outptr); break;
case(KEY_HIRAGANA): fputs("HIRAGANA",_outptr); break;
case(KEY_HENKAN): fputs("HENKAN",_outptr); break;
case(KEY_KATAKANAHIRAGANA): fputs("KATAKANAHIRAGANA",_outptr); break;
case(KEY_MUHENKAN): fputs("MUHENKAN",_outptr); break;
case(KEY_KPJPCOMMA): fputs("KPJPCOMMA",_outptr); break;
case(KEY_KPENTER): fputs("KPENTER",_outptr); break;
case(KEY_RIGHTCTRL): fputs("RIGHTCTRL",_outptr); break;
case(KEY_KPSLASH): fputs("KPSLASH",_outptr); break;
case(KEY_SYSRQ): fputs("SYSRQ",_outptr); break;
case(KEY_RIGHTALT): fputs("RIGHTALT",_outptr); break;
case(KEY_LINEFEED): fputs("LINEFEED",_outptr); break;
case(KEY_HOME): fputs("HOME",_outptr); break;
case(KEY_UP): fputs("UP",_outptr); break;
case(KEY_PAGEUP): fputs("PAGEUP",_outptr); break;
case(KEY_LEFT): fputs("LEFT",_outptr); break;
case(KEY_RIGHT): fputs("RIGHT",_outptr); break;
case(KEY_END): fputs("END",_outptr); break;
case(KEY_DOWN): fputs("DOWN",_outptr); break;
case(KEY_PAGEDOWN): fputs("PAGEDOWN",_outptr); break;
case(KEY_INSERT): fputs("INSERT",_outptr); break;
case(KEY_DELETE): fputs("DELETE",_outptr); break;
case(KEY_MACRO): fputs("MACRO",_outptr); break;
case(KEY_MUTE): fputs("MUTE",_outptr); break;
case(KEY_VOLUMEDOWN): fputs("VOLUMEDOWN",_outptr); break;
case(KEY_VOLUMEUP): fputs("VOLUMEUP",_outptr); break;
case(KEY_POWER): fputs("POWER",_outptr); break;
case(KEY_KPEQUAL): fputs("KPEQUAL",_outptr); break;
case(KEY_KPPLUSMINUS): fputs("KPPLUSMINUS",_outptr); break;
case(KEY_PAUSE): fputs("PAUSE",_outptr); break;
case(KEY_SCALE): fputs("SCALE",_outptr); break;
case(KEY_KPCOMMA): fputs("KPCOMMA",_outptr); break;
case(KEY_HANGEUL): fputs("HANGEUL",_outptr); break;
case(KEY_HANJA): fputs("HANJA",_outptr); break;
case(KEY_YEN): fputs("YEN",_outptr); break;
case(KEY_LEFTMETA): fputs("LEFTMETA",_outptr); break;
case(KEY_RIGHTMETA): fputs("RIGHTMETA",_outptr); break;
case(KEY_COMPOSE): fputs("COMPOSE",_outptr); break;
case(KEY_STOP): fputs("STOP",_outptr); break;
case(KEY_AGAIN): fputs("AGAIN",_outptr); break;
case(KEY_PROPS): fputs("PROPS",_outptr); break;
case(KEY_UNDO): fputs("UNDO",_outptr); break;
case(KEY_FRONT): fputs("FRONT",_outptr); break;
case(KEY_COPY): fputs("COPY",_outptr); break;
case(KEY_OPEN): fputs("OPEN",_outptr); break;
case(KEY_PASTE): fputs("PASTE",_outptr); break;
case(KEY_FIND): fputs("FIND",_outptr); break;
case(KEY_CUT): fputs("CUT",_outptr); break;
case(KEY_HELP): fputs("HELP",_outptr); break;
case(KEY_MENU): fputs("MENU",_outptr); break;
case(KEY_CALC): fputs("CALC",_outptr); break;
case(KEY_SETUP): fputs("SETUP",_outptr); break;
case(KEY_SLEEP): fputs("SLEEP",_outptr); break;
case(KEY_WAKEUP): fputs("WAKEUP",_outptr); break;
case(KEY_FILE): fputs("FILE",_outptr); break;
case(KEY_SENDFILE): fputs("SENDFILE",_outptr); break;
case(KEY_DELETEFILE): fputs("DELETEFILE",_outptr); break;
case(KEY_XFER): fputs("XFER",_outptr); break;
case(KEY_PROG1): fputs("PROG1",_outptr); break;
case(KEY_PROG2): fputs("PROG2",_outptr); break;
case(KEY_WWW): fputs("WWW",_outptr); break;
case(KEY_MSDOS): fputs("MSDOS",_outptr); break;
case(KEY_SCREENLOCK): fputs("SCREENLOCK",_outptr); break;
case(KEY_DIRECTION): fputs("DIRECTION",_outptr); break;
case(KEY_CYCLEWINDOWS): fputs("CYCLEWINDOWS",_outptr); break;
case(KEY_MAIL): fputs("MAIL",_outptr); break;
case(KEY_BOOKMARKS): fputs("BOOKMARKS",_outptr); break;
case(KEY_COMPUTER): fputs("COMPUTER",_outptr); break;
case(KEY_BACK): fputs("BACK",_outptr); break;
case(KEY_FORWARD): fputs("FORWARD",_outptr); break;
case(KEY_CLOSECD): fputs("CLOSECD",_outptr); break;
case(KEY_EJECTCD): fputs("EJECTCD",_outptr); break;
case(KEY_EJECTCLOSECD): fputs("EJECTCLOSECD",_outptr); break;
case(KEY_NEXTSONG): fputs("NEXTSONG",_outptr); break;
case(KEY_PLAYPAUSE): fputs("PLAYPAUSE",_outptr); break;
case(KEY_PREVIOUSSONG): fputs("PREVIOUSSONG",_outptr); break;
case(KEY_STOPCD): fputs("STOPCD",_outptr); break;
case(KEY_RECORD): fputs("RECORD",_outptr); break;
case(KEY_REWIND): fputs("REWIND",_outptr); break;
case(KEY_PHONE): fputs("PHONE",_outptr); break;
case(KEY_ISO): fputs("ISO",_outptr); break;
case(KEY_CONFIG): fputs("CONFIG",_outptr); break;
case(KEY_HOMEPAGE): fputs("HOMEPAGE",_outptr); break;
case(KEY_REFRESH): fputs("REFRESH",_outptr); break;
case(KEY_EXIT): fputs("EXIT",_outptr); break;
case(KEY_MOVE): fputs("MOVE",_outptr); break;
case(KEY_EDIT): fputs("EDIT",_outptr); break;
case(KEY_SCROLLUP): fputs("SCROLLUP",_outptr); break;
case(KEY_SCROLLDOWN): fputs("SCROLLDOWN",_outptr); break;
case(KEY_KPLEFTPAREN): fputs("KPLEFTPAREN",_outptr); break;
case(KEY_KPRIGHTPAREN): fputs("KPRIGHTPAREN",_outptr); break;
case(KEY_NEW): fputs("NEW",_outptr); break;
case(KEY_REDO): fputs("REDO",_outptr); break;
case(KEY_F13): fputs("F13",_outptr); break;
case(KEY_F14): fputs("F14",_outptr); break;
case(KEY_F15): fputs("F15",_outptr); break;
case(KEY_F16): fputs("F16",_outptr); break;
case(KEY_F17): fputs("F17",_outptr); break;
case(KEY_F18): fputs("F18",_outptr); break;
case(KEY_F19): fputs("F19",_outptr); break;
case(KEY_F20): fputs("F20",_outptr); break;
case(KEY_F21): fputs("F21",_outptr); break;
case(KEY_F22): fputs("F22",_outptr); break;
case(KEY_F23): fputs("F23",_outptr); break;
case(KEY_F24): fputs("F24",_outptr); break;
case(KEY_PLAYCD): fputs("PLAYCD",_outptr); break;
case(KEY_PAUSECD): fputs("PAUSECD",_outptr); break;
case(KEY_PROG3): fputs("PROG3",_outptr); break;
case(KEY_PROG4): fputs("PROG4",_outptr); break;
case(KEY_DASHBOARD): fputs("DASHBOARD",_outptr); break;
case(KEY_SUSPEND): fputs("SUSPEND",_outptr); break;
case(KEY_CLOSE): fputs("CLOSE",_outptr); break;
case(KEY_PLAY): fputs("PLAY",_outptr); break;
case(KEY_FASTFORWARD): fputs("FASTFORWARD",_outptr); break;
case(KEY_BASSBOOST): fputs("BASSBOOST",_outptr); break;
case(KEY_PRINT): fputs("PRINT",_outptr); break;
case(KEY_HP): fputs("HP",_outptr); break;
case(KEY_CAMERA): fputs("CAMERA",_outptr); break;
case(KEY_SOUND): fputs("SOUND",_outptr); break;
case(KEY_QUESTION): fputs("QUESTION",_outptr); break;
case(KEY_EMAIL): fputs("EMAIL",_outptr); break;
case(KEY_CHAT): fputs("CHAT",_outptr); break;
case(KEY_SEARCH): fputs("SEARCH",_outptr); break;
case(KEY_CONNECT): fputs("CONNECT",_outptr); break;
case(KEY_FINANCE): fputs("FINANCE",_outptr); break;
case(KEY_SPORT): fputs("SPORT",_outptr); break;
case(KEY_SHOP): fputs("SHOP",_outptr); break;
case(KEY_ALTERASE): fputs("ALTERASE",_outptr); break;
case(KEY_CANCEL): fputs("CANCEL",_outptr); break;
case(KEY_BRIGHTNESSDOWN): fputs("BRIGHTNESSDOWN",_outptr); break;
case(KEY_BRIGHTNESSUP): fputs("BRIGHTNESSUP",_outptr); break;
case(KEY_MEDIA): fputs("MEDIA",_outptr); break;
case(KEY_SWITCHVIDEOMODE): fputs("SWITCHVIDEOMODE",_outptr); break;
case(KEY_KBDILLUMTOGGLE): fputs("KBDILLUMTOGGLE",_outptr); break;
case(KEY_KBDILLUMDOWN): fputs("KBDILLUMDOWN",_outptr); break;
case(KEY_KBDILLUMUP): fputs("KBDILLUMUP",_outptr); break;
case(KEY_SEND): fputs("SEND",_outptr); break;
case(KEY_REPLY): fputs("REPLY",_outptr); break;
case(KEY_FORWARDMAIL): fputs("FORWARDMAIL",_outptr); break;
case(KEY_SAVE): fputs("SAVE",_outptr); break;
case(KEY_DOCUMENTS): fputs("DOCUMENTS",_outptr); break;
case(KEY_BATTERY): fputs("BATTERY",_outptr); break;
case(KEY_BLUETOOTH): fputs("BLUETOOTH",_outptr); break;
case(KEY_WLAN): fputs("WLAN",_outptr); break;
case(KEY_UWB): fputs("UWB",_outptr); break;
case(KEY_UNKNOWN): fputs("UNKNOWN",_outptr); break;
case(KEY_VIDEO_NEXT): fputs("VIDEO_NEXT",_outptr); break;
case(KEY_VIDEO_PREV): fputs("VIDEO_PREV",_outptr); break;
case(KEY_BRIGHTNESS_CYCLE): fputs("BRIGHTNESS_CYCLE",_outptr); break;
case(KEY_BRIGHTNESS_ZERO): fputs("BRIGHTNESS_ZERO",_outptr); break;
case(KEY_DISPLAY_OFF): fputs("DISPLAY_OFF",_outptr); break;
case(KEY_WWAN): fputs("WWAN",_outptr); break;
case(KEY_RFKILL): fputs("RFKILL",_outptr); break;
case(KEY_MICMUTE): fputs("MICMUTE",_outptr); break;
default: fputs(__KEY_UNKNOWN,_outptr); break;
}
fputs(" ",_outptr);
}
char* keycode_to_string(key code)
{
switch(code)
{
case(KEY_RESERVED): return "RESERVED";
case(KEY_ESC): return "ESC";
case(KEY_1): return "1";
case(KEY_2): return "2";
case(KEY_3): return "3";
case(KEY_4): return "4";
case(KEY_5): return "5";
case(KEY_6): return "6";
case(KEY_7): return "7";
case(KEY_8): return "8";
case(KEY_9): return "9";
case(KEY_0): return "0";
case(KEY_MINUS): return "MINUS";
case(KEY_EQUAL): return "EQUAL";
case(KEY_BACKSPACE): return "BACKSPACE";
case(KEY_TAB): return "TAB";
case(KEY_Q): return "Q";
case(KEY_W): return "W";
case(KEY_E): return "E";
case(KEY_R): return "R";
case(KEY_T): return "T";
case(KEY_Y): return "Y";
case(KEY_U): return "U";
case(KEY_I): return "I";
case(KEY_O): return "O";
case(KEY_P): return "P";
case(KEY_LEFTBRACE): return "LEFTBRACE";
case(KEY_RIGHTBRACE): return "RIGHTBRACE";
case(KEY_ENTER): return "ENTER";
case(KEY_LEFTCTRL): return "LEFTCTRL";
case(KEY_A): return "A";
case(KEY_S): return "S";
case(KEY_D): return "D";
case(KEY_F): return "F";
case(KEY_G): return "G";
case(KEY_H): return "H";
case(KEY_J): return "J";
case(KEY_K): return "K";
case(KEY_L): return "L";
case(KEY_SEMICOLON): return "SEMICOLON";
case(KEY_APOSTROPHE): return "APOSTROPHE";
case(KEY_GRAVE): return "GRAVE";
case(KEY_LEFTSHIFT): return "LEFTSHIFT";
case(KEY_BACKSLASH): return "BACKSLASH";
case(KEY_Z): return "Z";
case(KEY_X): return "X";
case(KEY_C): return "C";
case(KEY_V): return "V";
case(KEY_B): return "B";
case(KEY_N): return "N";
case(KEY_M): return "M";
case(KEY_COMMA): return "COMMA";
case(KEY_DOT): return "DOT";
case(KEY_SLASH): return "SLASH";
case(KEY_RIGHTSHIFT): return "RIGHTSHIFT";
case(KEY_KPASTERISK): return "KPASTERISK";
case(KEY_LEFTALT): return "LEFTALT";
case(KEY_SPACE): return "SPACE";
case(KEY_CAPSLOCK): return "CAPSLOCK";
case(KEY_F1): return "F1";
case(KEY_F2): return "F2";
case(KEY_F3): return "F3";
case(KEY_F4): return "F4";
case(KEY_F5): return "F5";
case(KEY_F6): return "F6";
case(KEY_F7): return "F7";
case(KEY_F8): return "F8";
case(KEY_F9): return "F9";
case(KEY_F10): return "F10";
case(KEY_NUMLOCK): return "NUMLOCK";
case(KEY_SCROLLLOCK): return "SCROLLLOCK";
case(KEY_KP7): return "KP7";
case(KEY_KP8): return "KP8";
case(KEY_KP9): return "KP9";
case(KEY_KPMINUS): return "KPMINUS";
case(KEY_KP4): return "KP4";
case(KEY_KP5): return "KP5";
case(KEY_KP6): return "KP6";
case(KEY_KPPLUS): return "KPPLUS";
case(KEY_KP1): return "KP1";
case(KEY_KP2): return "KP2";
case(KEY_KP3): return "KP3";
case(KEY_KP0): return "KP0";
case(KEY_KPDOT): return "KPDOT";
case(KEY_ZENKAKUHANKAKU): return "ZENKAKUHANKAKU";
case(KEY_102ND): return "102ND";
case(KEY_F11): return "F11";
case(KEY_F12): return "F12";
case(KEY_RO): return "RO";
case(KEY_KATAKANA): return "KATAKANA";
case(KEY_HIRAGANA): return "HIRAGANA";
case(KEY_HENKAN): return "HENKAN";
case(KEY_KATAKANAHIRAGANA): return "KATAKANAHIRAGANA";
case(KEY_MUHENKAN): return "MUHENKAN";
case(KEY_KPJPCOMMA): return "KPJPCOMMA";
case(KEY_KPENTER): return "KPENTER";
case(KEY_RIGHTCTRL): return "RIGHTCTRL";
case(KEY_KPSLASH): return "KPSLASH";
case(KEY_SYSRQ): return "SYSRQ";
case(KEY_RIGHTALT): return "RIGHTALT";
case(KEY_LINEFEED): return "LINEFEED";
case(KEY_HOME): return "HOME";
case(KEY_UP): return "UP";
case(KEY_PAGEUP): return "PAGEUP";
case(KEY_LEFT): return "LEFT";
case(KEY_RIGHT): return "RIGHT";
case(KEY_END): return "END";
case(KEY_DOWN): return "DOWN";
case(KEY_PAGEDOWN): return "PAGEDOWN";
case(KEY_INSERT): return "INSERT";
case(KEY_DELETE): return "DELETE";
case(KEY_MACRO): return "MACRO";
case(KEY_MUTE): return "MUTE";
case(KEY_VOLUMEDOWN): return "VOLUMEDOWN";
case(KEY_VOLUMEUP): return "VOLUMEUP";
case(KEY_POWER): return "POWER";
case(KEY_KPEQUAL): return "KPEQUAL";
case(KEY_KPPLUSMINUS): return "KPPLUSMINUS";
case(KEY_PAUSE): return "PAUSE";
case(KEY_SCALE): return "SCALE";
case(KEY_KPCOMMA): return "KPCOMMA";
case(KEY_HANGEUL): return "HANGEUL";
case(KEY_HANJA): return "HANJA";
case(KEY_YEN): return "YEN";
case(KEY_LEFTMETA): return "LEFTMETA";
case(KEY_RIGHTMETA): return "RIGHTMETA";
case(KEY_COMPOSE): return "COMPOSE";
case(KEY_STOP): return "STOP";
case(KEY_AGAIN): return "AGAIN";
case(KEY_PROPS): return "PROPS";
case(KEY_UNDO): return "UNDO";
case(KEY_FRONT): return "FRONT";
case(KEY_COPY): return "COPY";
case(KEY_OPEN): return "OPEN";
case(KEY_PASTE): return "PASTE";
case(KEY_FIND): return "FIND";
case(KEY_CUT): return "CUT";
case(KEY_HELP): return "HELP";
case(KEY_MENU): return "MENU";
case(KEY_CALC): return "CALC";
case(KEY_SETUP): return "SETUP";
case(KEY_SLEEP): return "SLEEP";
case(KEY_WAKEUP): return "WAKEUP";
case(KEY_FILE): return "FILE";
case(KEY_SENDFILE): return "SENDFILE";
case(KEY_DELETEFILE): return "DELETEFILE";
case(KEY_XFER): return "XFER";
case(KEY_PROG1): return "PROG1";
case(KEY_PROG2): return "PROG2";
case(KEY_WWW): return "WWW";
case(KEY_MSDOS): return "MSDOS";
case(KEY_SCREENLOCK): return "SCREENLOCK";
case(KEY_DIRECTION): return "DIRECTION";
case(KEY_CYCLEWINDOWS): return "CYCLEWINDOWS";
case(KEY_MAIL): return "MAIL";
case(KEY_BOOKMARKS): return "BOOKMARKS";
case(KEY_COMPUTER): return "COMPUTER";
case(KEY_BACK): return "BACK";
case(KEY_FORWARD): return "FORWARD";
case(KEY_CLOSECD): return "CLOSECD";
case(KEY_EJECTCD): return "EJECTCD";
case(KEY_EJECTCLOSECD): return "EJECTCLOSECD";
case(KEY_NEXTSONG): return "NEXTSONG";
case(KEY_PLAYPAUSE): return "PLAYPAUSE";
case(KEY_PREVIOUSSONG): return "PREVIOUSSONG";
case(KEY_STOPCD): return "STOPCD";
case(KEY_RECORD): return "RECORD";
case(KEY_REWIND): return "REWIND";
case(KEY_PHONE): return "PHONE";
case(KEY_ISO): return "ISO";
case(KEY_CONFIG): return "CONFIG";
case(KEY_HOMEPAGE): return "HOMEPAGE";
case(KEY_REFRESH): return "REFRESH";
case(KEY_EXIT): return "EXIT";
case(KEY_MOVE): return "MOVE";
case(KEY_EDIT): return "EDIT";
case(KEY_SCROLLUP): return "SCROLLUP";
case(KEY_SCROLLDOWN): return "SCROLLDOWN";
case(KEY_KPLEFTPAREN): return "KPLEFTPAREN";
case(KEY_KPRIGHTPAREN): return "KPRIGHTPAREN";
case(KEY_NEW): return "NEW";
case(KEY_REDO): return "REDO";
case(KEY_F13): return "F13";
case(KEY_F14): return "F14";
case(KEY_F15): return "F15";
case(KEY_F16): return "F16";
case(KEY_F17): return "F17";
case(KEY_F18): return "F18";
case(KEY_F19): return "F19";
case(KEY_F20): return "F20";
case(KEY_F21): return "F21";
case(KEY_F22): return "F22";
case(KEY_F23): return "F23";
case(KEY_F24): return "F24";
case(KEY_PLAYCD): return "PLAYCD";
case(KEY_PAUSECD): return "PAUSECD";
case(KEY_PROG3): return "PROG3";
case(KEY_PROG4): return "PROG4";
case(KEY_DASHBOARD): return "DASHBOARD";
case(KEY_SUSPEND): return "SUSPEND";
case(KEY_CLOSE): return "CLOSE";
case(KEY_PLAY): return "PLAY";
case(KEY_FASTFORWARD): return "FASTFORWARD";
case(KEY_BASSBOOST): return "BASSBOOST";
case(KEY_PRINT): return "PRINT";
case(KEY_HP): return "HP";
case(KEY_CAMERA): return "CAMERA";
case(KEY_SOUND): return "SOUND";
case(KEY_QUESTION): return "QUESTION";
case(KEY_EMAIL): return "EMAIL";
case(KEY_CHAT): return "CHAT";
case(KEY_SEARCH): return "SEARCH";
case(KEY_CONNECT): return "CONNECT";
case(KEY_FINANCE): return "FINANCE";
case(KEY_SPORT): return "SPORT";
case(KEY_SHOP): return "SHOP";
case(KEY_ALTERASE): return "ALTERASE";
case(KEY_CANCEL): return "CANCEL";
case(KEY_BRIGHTNESSDOWN): return "BRIGHTNESSDOWN";
case(KEY_BRIGHTNESSUP): return "BRIGHTNESSUP";
case(KEY_MEDIA): return "MEDIA";
case(KEY_SWITCHVIDEOMODE): return "SWITCHVIDEOMODE";
case(KEY_KBDILLUMTOGGLE): return "KBDILLUMTOGGLE";
case(KEY_KBDILLUMDOWN): return "KBDILLUMDOWN";
case(KEY_KBDILLUMUP): return "KBDILLUMUP";
case(KEY_SEND): return "SEND";
case(KEY_REPLY): return "REPLY";
case(KEY_FORWARDMAIL): return "FORWARDMAIL";
case(KEY_SAVE): return "SAVE";
case(KEY_DOCUMENTS): return "DOCUMENTS";
case(KEY_BATTERY): return "BATTERY";
case(KEY_BLUETOOTH): return "BLUETOOTH";
case(KEY_WLAN): return "WLAN";
case(KEY_UWB): return "UWB";
case(KEY_UNKNOWN): return "UNKNOWN";
case(KEY_VIDEO_NEXT): return "VIDEO_NEXT";
case(KEY_VIDEO_PREV): return "VIDEO_PREV";
case(KEY_BRIGHTNESS_CYCLE): return "BRIGHTNESS_CYCLE";
case(KEY_BRIGHTNESS_ZERO): return "BRIGHTNESS_ZERO";
case(KEY_DISPLAY_OFF): return "DISPLAY_OFF";
case(KEY_WWAN): return "WWAN";
case(KEY_RFKILL): return "RFKILL";
case(KEY_MICMUTE): return "MICMUTE";
}
return __KEY_UNKNOWN;
}
void keycode_to_string_s(key code, char* target, size_t max_size)
{
switch(code)
{
case(KEY_RESERVED): snprintf(target,max_size, "RESERVED");break;
case(KEY_ESC): snprintf(target,max_size, "ESC");break;
case(KEY_1): snprintf(target,max_size, "1");break;
case(KEY_2): snprintf(target,max_size, "2");break;
case(KEY_3): snprintf(target,max_size, "3");break;
case(KEY_4): snprintf(target,max_size, "4");break;
case(KEY_5): snprintf(target,max_size, "5");break;
case(KEY_6): snprintf(target,max_size, "6");break;
case(KEY_7): snprintf(target,max_size, "7");break;
case(KEY_8): snprintf(target,max_size, "8");break;
case(KEY_9): snprintf(target,max_size, "9");break;
case(KEY_0): snprintf(target,max_size, "0");break;
case(KEY_MINUS): snprintf(target,max_size, "MINUS");break;
case(KEY_EQUAL): snprintf(target,max_size, "EQUAL");break;
case(KEY_BACKSPACE): snprintf(target,max_size, "BACKSPACE");break;
case(KEY_TAB): snprintf(target,max_size, "TAB");break;
case(KEY_Q): snprintf(target,max_size, "Q");break;
case(KEY_W): snprintf(target,max_size, "W");break;
case(KEY_E): snprintf(target,max_size, "E");break;
case(KEY_R): snprintf(target,max_size, "R");break;
case(KEY_T): snprintf(target,max_size, "T");break;
case(KEY_Y): snprintf(target,max_size, "Y");break;
case(KEY_U): snprintf(target,max_size, "U");break;
case(KEY_I): snprintf(target,max_size, "I");break;
case(KEY_O): snprintf(target,max_size, "O");break;
case(KEY_P): snprintf(target,max_size, "P");break;
case(KEY_LEFTBRACE): snprintf(target,max_size, "LEFTBRACE");break;
case(KEY_RIGHTBRACE): snprintf(target,max_size, "RIGHTBRACE");break;
case(KEY_ENTER): snprintf(target,max_size, "ENTER");break;
case(KEY_LEFTCTRL): snprintf(target,max_size, "LEFTCTRL");break;
case(KEY_A): snprintf(target,max_size, "A");break;
case(KEY_S): snprintf(target,max_size, "S");break;
case(KEY_D): snprintf(target,max_size, "D");break;
case(KEY_F): snprintf(target,max_size, "F");break;
case(KEY_G): snprintf(target,max_size, "G");break;
case(KEY_H): snprintf(target,max_size, "H");break;
case(KEY_J): snprintf(target,max_size, "J");break;
case(KEY_K): snprintf(target,max_size, "K");break;
case(KEY_L): snprintf(target,max_size, "L");break;
case(KEY_SEMICOLON): snprintf(target,max_size, "SEMICOLON");break;
case(KEY_APOSTROPHE): snprintf(target,max_size, "APOSTROPHE");break;
case(KEY_GRAVE): snprintf(target,max_size, "GRAVE");break;
case(KEY_LEFTSHIFT): snprintf(target,max_size, "LEFTSHIFT");break;
case(KEY_BACKSLASH): snprintf(target,max_size, "BACKSLASH");break;
case(KEY_Z): snprintf(target,max_size, "Z");break;
case(KEY_X): snprintf(target,max_size, "X");break;
case(KEY_C): snprintf(target,max_size, "C");break;
case(KEY_V): snprintf(target,max_size, "V");break;
case(KEY_B): snprintf(target,max_size, "B");break;
case(KEY_N): snprintf(target,max_size, "N");break;
case(KEY_M): snprintf(target,max_size, "M");break;
case(KEY_COMMA): snprintf(target,max_size, "COMMA");break;
case(KEY_DOT): snprintf(target,max_size, "DOT");break;
case(KEY_SLASH): snprintf(target,max_size, "SLASH");break;
case(KEY_RIGHTSHIFT): snprintf(target,max_size, "RIGHTSHIFT");break;
case(KEY_KPASTERISK): snprintf(target,max_size, "KPASTERISK");break;
case(KEY_LEFTALT): snprintf(target,max_size, "LEFTALT");break;
case(KEY_SPACE): snprintf(target,max_size, "SPACE");break;
case(KEY_CAPSLOCK): snprintf(target,max_size, "CAPSLOCK");break;
case(KEY_F1): snprintf(target,max_size, "F1");break;
case(KEY_F2): snprintf(target,max_size, "F2");break;
case(KEY_F3): snprintf(target,max_size, "F3");break;
case(KEY_F4): snprintf(target,max_size, "F4");break;
case(KEY_F5): snprintf(target,max_size, "F5");break;
case(KEY_F6): snprintf(target,max_size, "F6");break;
case(KEY_F7): snprintf(target,max_size, "F7");break;
case(KEY_F8): snprintf(target,max_size, "F8");break;
case(KEY_F9): snprintf(target,max_size, "F9");break;
case(KEY_F10): snprintf(target,max_size, "F10");break;
case(KEY_NUMLOCK): snprintf(target,max_size, "NUMLOCK");break;
case(KEY_SCROLLLOCK): snprintf(target,max_size, "SCROLLLOCK");break;
case(KEY_KP7): snprintf(target,max_size, "KP7");break;
case(KEY_KP8): snprintf(target,max_size, "KP8");break;
case(KEY_KP9): snprintf(target,max_size, "KP9");break;
case(KEY_KPMINUS): snprintf(target,max_size, "KPMINUS");break;
case(KEY_KP4): snprintf(target,max_size, "KP4");break;
case(KEY_KP5): snprintf(target,max_size, "KP5");break;
case(KEY_KP6): snprintf(target,max_size, "KP6");break;
case(KEY_KPPLUS): snprintf(target,max_size, "KPPLUS");break;
case(KEY_KP1): snprintf(target,max_size, "KP1");break;
case(KEY_KP2): snprintf(target,max_size, "KP2");break;
case(KEY_KP3): snprintf(target,max_size, "KP3");break;
case(KEY_KP0): snprintf(target,max_size, "KP0");break;
case(KEY_KPDOT): snprintf(target,max_size, "KPDOT");break;
case(KEY_ZENKAKUHANKAKU): snprintf(target,max_size, "ZENKAKUHANKAKU");break;
case(KEY_102ND): snprintf(target,max_size, "102ND");break;
case(KEY_F11): snprintf(target,max_size, "F11");break;
case(KEY_F12): snprintf(target,max_size, "F12");break;
case(KEY_RO): snprintf(target,max_size, "RO");break;
case(KEY_KATAKANA): snprintf(target,max_size, "KATAKANA");break;
case(KEY_HIRAGANA): snprintf(target,max_size, "HIRAGANA");break;
case(KEY_HENKAN): snprintf(target,max_size, "HENKAN");break;
case(KEY_KATAKANAHIRAGANA): snprintf(target,max_size, "KATAKANAHIRAGANA");break;
case(KEY_MUHENKAN): snprintf(target,max_size, "MUHENKAN");break;
case(KEY_KPJPCOMMA): snprintf(target,max_size, "KPJPCOMMA");break;
case(KEY_KPENTER): snprintf(target,max_size, "KPENTER");break;
case(KEY_RIGHTCTRL): snprintf(target,max_size, "RIGHTCTRL");break;
case(KEY_KPSLASH): snprintf(target,max_size, "KPSLASH");break;
case(KEY_SYSRQ): snprintf(target,max_size, "SYSRQ");break;
case(KEY_RIGHTALT): snprintf(target,max_size, "RIGHTALT");break;
case(KEY_LINEFEED): snprintf(target,max_size, "LINEFEED");break;
case(KEY_HOME): snprintf(target,max_size, "HOME");break;
case(KEY_UP): snprintf(target,max_size, "UP");break;
case(KEY_PAGEUP): snprintf(target,max_size, "PAGEUP");break;
case(KEY_LEFT): snprintf(target,max_size, "LEFT");break;
case(KEY_RIGHT): snprintf(target,max_size, "RIGHT");break;
case(KEY_END): snprintf(target,max_size, "END");break;
case(KEY_DOWN): snprintf(target,max_size, "DOWN");break;
case(KEY_PAGEDOWN): snprintf(target,max_size, "PAGEDOWN");break;
case(KEY_INSERT): snprintf(target,max_size, "INSERT");break;
case(KEY_DELETE): snprintf(target,max_size, "DELETE");break;
case(KEY_MACRO): snprintf(target,max_size, "MACRO");break;
case(KEY_MUTE): snprintf(target,max_size, "MUTE");break;
case(KEY_VOLUMEDOWN): snprintf(target,max_size, "VOLUMEDOWN");break;
case(KEY_VOLUMEUP): snprintf(target,max_size, "VOLUMEUP");break;
case(KEY_POWER): snprintf(target,max_size, "POWER");break;
case(KEY_KPEQUAL): snprintf(target,max_size, "KPEQUAL");break;
case(KEY_KPPLUSMINUS): snprintf(target,max_size, "KPPLUSMINUS");break;
case(KEY_PAUSE): snprintf(target,max_size, "PAUSE");break;
case(KEY_SCALE): snprintf(target,max_size, "SCALE");break;
case(KEY_KPCOMMA): snprintf(target,max_size, "KPCOMMA");break;
case(KEY_HANGEUL): snprintf(target,max_size, "HANGEUL");break;
case(KEY_HANJA): snprintf(target,max_size, "HANJA");break;
case(KEY_YEN): snprintf(target,max_size, "YEN");break;
case(KEY_LEFTMETA): snprintf(target,max_size, "LEFTMETA");break;
case(KEY_RIGHTMETA): snprintf(target,max_size, "RIGHTMETA");break;
case(KEY_COMPOSE): snprintf(target,max_size, "COMPOSE");break;
case(KEY_STOP): snprintf(target,max_size, "STOP");break;
case(KEY_AGAIN): snprintf(target,max_size, "AGAIN");break;
case(KEY_PROPS): snprintf(target,max_size, "PROPS");break;
case(KEY_UNDO): snprintf(target,max_size, "UNDO");break;
case(KEY_FRONT): snprintf(target,max_size, "FRONT");break;
case(KEY_COPY): snprintf(target,max_size, "COPY");break;
case(KEY_OPEN): snprintf(target,max_size, "OPEN");break;
case(KEY_PASTE): snprintf(target,max_size, "PASTE");break;
case(KEY_FIND): snprintf(target,max_size, "FIND");break;
case(KEY_CUT): snprintf(target,max_size, "CUT");break;
case(KEY_HELP): snprintf(target,max_size, "HELP");break;
case(KEY_MENU): snprintf(target,max_size, "MENU");break;
case(KEY_CALC): snprintf(target,max_size, "CALC");break;
case(KEY_SETUP): snprintf(target,max_size, "SETUP");break;
case(KEY_SLEEP): snprintf(target,max_size, "SLEEP");break;
case(KEY_WAKEUP): snprintf(target,max_size, "WAKEUP");break;
case(KEY_FILE): snprintf(target,max_size, "FILE");break;
case(KEY_SENDFILE): snprintf(target,max_size, "SENDFILE");break;
case(KEY_DELETEFILE): snprintf(target,max_size, "DELETEFILE");break;
case(KEY_XFER): snprintf(target,max_size, "XFER");break;
case(KEY_PROG1): snprintf(target,max_size, "PROG1");break;
case(KEY_PROG2): snprintf(target,max_size, "PROG2");break;
case(KEY_WWW): snprintf(target,max_size, "WWW");break;
case(KEY_MSDOS): snprintf(target,max_size, "MSDOS");break;
case(KEY_SCREENLOCK): snprintf(target,max_size, "SCREENLOCK");break;
case(KEY_DIRECTION): snprintf(target,max_size, "DIRECTION");break;
case(KEY_CYCLEWINDOWS): snprintf(target,max_size, "CYCLEWINDOWS");break;
case(KEY_MAIL): snprintf(target,max_size, "MAIL");break;
case(KEY_BOOKMARKS): snprintf(target,max_size, "BOOKMARKS");break;
case(KEY_COMPUTER): snprintf(target,max_size, "COMPUTER");break;
case(KEY_BACK): snprintf(target,max_size, "BACK");break;
case(KEY_FORWARD): snprintf(target,max_size, "FORWARD");break;
case(KEY_CLOSECD): snprintf(target,max_size, "CLOSECD");break;
case(KEY_EJECTCD): snprintf(target,max_size, "EJECTCD");break;
case(KEY_EJECTCLOSECD): snprintf(target,max_size, "EJECTCLOSECD");break;
case(KEY_NEXTSONG): snprintf(target,max_size, "NEXTSONG");break;
case(KEY_PLAYPAUSE): snprintf(target,max_size, "PLAYPAUSE");break;
case(KEY_PREVIOUSSONG): snprintf(target,max_size, "PREVIOUSSONG");break;
case(KEY_STOPCD): snprintf(target,max_size, "STOPCD");break;
case(KEY_RECORD): snprintf(target,max_size, "RECORD");break;
case(KEY_REWIND): snprintf(target,max_size, "REWIND");break;
case(KEY_PHONE): snprintf(target,max_size, "PHONE");break;
case(KEY_ISO): snprintf(target,max_size, "ISO");break;
case(KEY_CONFIG): snprintf(target,max_size, "CONFIG");break;
case(KEY_HOMEPAGE): snprintf(target,max_size, "HOMEPAGE");break;
case(KEY_REFRESH): snprintf(target,max_size, "REFRESH");break;
case(KEY_EXIT): snprintf(target,max_size, "EXIT");break;
case(KEY_MOVE): snprintf(target,max_size, "MOVE");break;
case(KEY_EDIT): snprintf(target,max_size, "EDIT");break;
case(KEY_SCROLLUP): snprintf(target,max_size, "SCROLLUP");break;
case(KEY_SCROLLDOWN): snprintf(target,max_size, "SCROLLDOWN");break;
case(KEY_KPLEFTPAREN): snprintf(target,max_size, "KPLEFTPAREN");break;
case(KEY_KPRIGHTPAREN): snprintf(target,max_size, "KPRIGHTPAREN");break;
case(KEY_NEW): snprintf(target,max_size, "NEW");break;
case(KEY_REDO): snprintf(target,max_size, "REDO");break;
case(KEY_F13): snprintf(target,max_size, "F13");break;
case(KEY_F14): snprintf(target,max_size, "F14");break;
case(KEY_F15): snprintf(target,max_size, "F15");break;
case(KEY_F16): snprintf(target,max_size, "F16");break;
case(KEY_F17): snprintf(target,max_size, "F17");break;
case(KEY_F18): snprintf(target,max_size, "F18");break;
case(KEY_F19): snprintf(target,max_size, "F19");break;
case(KEY_F20): snprintf(target,max_size, "F20");break;
case(KEY_F21): snprintf(target,max_size, "F21");break;
case(KEY_F22): snprintf(target,max_size, "F22");break;
case(KEY_F23): snprintf(target,max_size, "F23");break;
case(KEY_F24): snprintf(target,max_size, "F24");break;
case(KEY_PLAYCD): snprintf(target,max_size, "PLAYCD");break;
case(KEY_PAUSECD): snprintf(target,max_size, "PAUSECD");break;
case(KEY_PROG3): snprintf(target,max_size, "PROG3");break;
case(KEY_PROG4): snprintf(target,max_size, "PROG4");break;
case(KEY_DASHBOARD): snprintf(target,max_size, "DASHBOARD");break;
case(KEY_SUSPEND): snprintf(target,max_size, "SUSPEND");break;
case(KEY_CLOSE): snprintf(target,max_size, "CLOSE");break;
case(KEY_PLAY): snprintf(target,max_size, "PLAY");break;
case(KEY_FASTFORWARD): snprintf(target,max_size, "FASTFORWARD");break;
case(KEY_BASSBOOST): snprintf(target,max_size, "BASSBOOST");break;
case(KEY_PRINT): snprintf(target,max_size, "PRINT");break;
case(KEY_HP): snprintf(target,max_size, "HP");break;
case(KEY_CAMERA): snprintf(target,max_size, "CAMERA");break;
case(KEY_SOUND): snprintf(target,max_size, "SOUND");break;
case(KEY_QUESTION): snprintf(target,max_size, "QUESTION");break;
case(KEY_EMAIL): snprintf(target,max_size, "EMAIL");break;
case(KEY_CHAT): snprintf(target,max_size, "CHAT");break;
case(KEY_SEARCH): snprintf(target,max_size, "SEARCH");break;
case(KEY_CONNECT): snprintf(target,max_size, "CONNECT");break;
case(KEY_FINANCE): snprintf(target,max_size, "FINANCE");break;
case(KEY_SPORT): snprintf(target,max_size, "SPORT");break;
case(KEY_SHOP): snprintf(target,max_size, "SHOP");break;
case(KEY_ALTERASE): snprintf(target,max_size, "ALTERASE");break;
case(KEY_CANCEL): snprintf(target,max_size, "CANCEL");break;
case(KEY_BRIGHTNESSDOWN): snprintf(target,max_size, "BRIGHTNESSDOWN");break;
case(KEY_BRIGHTNESSUP): snprintf(target,max_size, "BRIGHTNESSUP");break;
case(KEY_MEDIA): snprintf(target,max_size, "MEDIA");break;
case(KEY_SWITCHVIDEOMODE): snprintf(target,max_size, "SWITCHVIDEOMODE");break;
case(KEY_KBDILLUMTOGGLE): snprintf(target,max_size, "KBDILLUMTOGGLE");break;
case(KEY_KBDILLUMDOWN): snprintf(target,max_size, "KBDILLUMDOWN");break;
case(KEY_KBDILLUMUP): snprintf(target,max_size, "KBDILLUMUP");break;
case(KEY_SEND): snprintf(target,max_size, "SEND");break;
case(KEY_REPLY): snprintf(target,max_size, "REPLY");break;
case(KEY_FORWARDMAIL): snprintf(target,max_size, "FORWARDMAIL");break;
case(KEY_SAVE): snprintf(target,max_size, "SAVE");break;
case(KEY_DOCUMENTS): snprintf(target,max_size, "DOCUMENTS");break;
case(KEY_BATTERY): snprintf(target,max_size, "BATTERY");break;
case(KEY_BLUETOOTH): snprintf(target,max_size, "BLUETOOTH");break;
case(KEY_WLAN): snprintf(target,max_size, "WLAN");break;
case(KEY_UWB): snprintf(target,max_size, "UWB");break;
case(KEY_UNKNOWN): snprintf(target,max_size, "UNKNOWN");break;
case(KEY_VIDEO_NEXT): snprintf(target,max_size, "VIDEO_NEXT");break;
case(KEY_VIDEO_PREV): snprintf(target,max_size, "VIDEO_PREV");break;
case(KEY_BRIGHTNESS_CYCLE): snprintf(target,max_size, "BRIGHTNESS_CYCLE");break;
case(KEY_BRIGHTNESS_ZERO): snprintf(target,max_size, "BRIGHTNESS_ZERO");break;
case(KEY_DISPLAY_OFF): snprintf(target,max_size, "DISPLAY_OFF");break;
case(KEY_WWAN): snprintf(target,max_size, "WWAN");break;
case(KEY_RFKILL): snprintf(target,max_size, "RFKILL");break;
case(KEY_MICMUTE): snprintf(target,max_size, "MICMUTE");break;
default: snprintf(target,max_size, __KEY_UNKNOWN);
}
}
Raw
linux-keys.h
#ifndef __LINUX_KEYS_H
#define __LINUX_KEYS_H
#include <stdio.h>
#include <linux/input-event-codes.h>
#define PRINT_KEY(keyid) keycode_to_stream(keyid,stdout);
#define EPRINT_KEY(keyid) keycode_to_stream(keyid,stderr);
#define __KEY_UNKNOWN "_UNKNOWN"
#define CANNOT_OPENDIR -1
#define CANNOT_READLINK -2
#define CANNOT_GETREALPATH -3
#define CANNOT_GETCWD -4
#define CANNOT_FCHDIR -5
#define CANNOT_CLOSEDIR -6
#define CANNOT_CHDIR -7
typedef int key;
void keycode_to_stream(key,FILE*);
char* keycode_to_string(key);
void keycode_to_string_s(key,char*,size_t);
int get_keyboard_evpath_s(char*);
key wait_for_keypress(FILE*);
#endif //__LINUX_KEYS_H
@StefanoBelli
Copy link
Author

StefanoBelli commented Nov 25, 2017 •
edited

Example usage

#define die(xstrmsg) \
     fputs(xstrmsg,stderr); \
     exit(1)

void key_to_stdout_oneshot() {
   char path[PATH_MAX];
   if(get_keyboard_evpath_s(path)) {
      die("Couldn't get keyboard event path");
   }
   
   FILE* my_path = fopen(path,"r");
   if(my_path == NULL) {
     die("Unable to open the event path with \"r\" mode, are you **root** ?");
   }

   key my_key = wait_for_keypress(my_path);

   if(my_key != -1)
       PRINT_KEY(my_key);

   fclose(my_path);
}

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment