Mirrored_Repos/LookingGlass
1
0
Fork 0
mirror of https://github.com/gnif/LookingGlass.git synced 2026-11-12 14:57:20 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[client] input: add platform-neutral keycodes

Browse Source
This commit is contained in:
Geoffrey McRae
2026-09-12 10:12:18 +10:00
parent 382f35e503
commit 7ea69f3d1c
26 changed files with 1412 additions and 1000 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
client/include/app.h
View File

@@ -23,7 +23,8 @@
#include <stdbool.h>
#include <stdint.h>
#include <linux/input.h>
#include "input/keycodes.h"
#include "common/ringbuffer.h"
#include "common/types.h"

199
client/include/input/keycodes.h Normal file
View File

@@ -0,0 +1,199 @@
/**
* Looking Glass
* Copyright © 2017-2026 The Looking Glass Authors
* https://looking-glass.io
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the Free
* Software Foundation; either version 2 of the License, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc., 59
* Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef _H_LG_INPUT_KEYCODES_
#define _H_LG_INPUT_KEYCODES_
/*
* Looking Glass uses the Linux input-event keycode values as its internal
* keyboard namespace. Keep these values stable: they are also consumed by
* input transports and platform backends that do not provide Linux headers.
*/
typedef enum LG_KeyCode
{
LG_KEY_RESERVED = 0,
LG_KEY_ESC = 1,
LG_KEY_1 = 2,
LG_KEY_2 = 3,
LG_KEY_3 = 4,
LG_KEY_4 = 5,
LG_KEY_5 = 6,
LG_KEY_6 = 7,
LG_KEY_7 = 8,
LG_KEY_8 = 9,
LG_KEY_9 = 10,
LG_KEY_0 = 11,
LG_KEY_MINUS = 12,
LG_KEY_EQUAL = 13,
LG_KEY_BACKSPACE = 14,
LG_KEY_TAB = 15,
LG_KEY_Q = 16,
LG_KEY_W = 17,
LG_KEY_E = 18,
LG_KEY_R = 19,
LG_KEY_T = 20,
LG_KEY_Y = 21,
LG_KEY_U = 22,
LG_KEY_I = 23,
LG_KEY_O = 24,
LG_KEY_P = 25,
LG_KEY_LEFTBRACE = 26,
LG_KEY_RIGHTBRACE = 27,
LG_KEY_ENTER = 28,
LG_KEY_LEFTCTRL = 29,
LG_KEY_A = 30,
LG_KEY_S = 31,
LG_KEY_D = 32,
LG_KEY_F = 33,
LG_KEY_G = 34,
LG_KEY_H = 35,
LG_KEY_J = 36,
LG_KEY_K = 37,
LG_KEY_L = 38,
LG_KEY_SEMICOLON = 39,
LG_KEY_APOSTROPHE = 40,
LG_KEY_GRAVE = 41,
LG_KEY_LEFTSHIFT = 42,
LG_KEY_BACKSLASH = 43,
LG_KEY_Z = 44,
LG_KEY_X = 45,
LG_KEY_C = 46,
LG_KEY_V = 47,
LG_KEY_B = 48,
LG_KEY_N = 49,
LG_KEY_M = 50,
LG_KEY_COMMA = 51,
LG_KEY_DOT = 52,
LG_KEY_SLASH = 53,
LG_KEY_RIGHTSHIFT = 54,
LG_KEY_KPASTERISK = 55,
LG_KEY_LEFTALT = 56,
LG_KEY_SPACE = 57,
LG_KEY_CAPSLOCK = 58,
LG_KEY_F1 = 59,
LG_KEY_F2 = 60,
LG_KEY_F3 = 61,
LG_KEY_F4 = 62,
LG_KEY_F5 = 63,
LG_KEY_F6 = 64,
LG_KEY_F7 = 65,
LG_KEY_F8 = 66,
LG_KEY_F9 = 67,
LG_KEY_F10 = 68,
LG_KEY_NUMLOCK = 69,
LG_KEY_SCROLLLOCK = 70,
LG_KEY_KP7 = 71,
LG_KEY_KP8 = 72,
LG_KEY_KP9 = 73,
LG_KEY_KPMINUS = 74,
LG_KEY_KP4 = 75,
LG_KEY_KP5 = 76,
LG_KEY_KP6 = 77,
LG_KEY_KPPLUS = 78,
LG_KEY_KP1 = 79,
LG_KEY_KP2 = 80,
LG_KEY_KP3 = 81,
LG_KEY_KP0 = 82,
LG_KEY_KPDOT = 83,
LG_KEY_ZENKAKUHANKAKU = 85,
LG_KEY_102ND = 86,
LG_KEY_F11 = 87,
LG_KEY_F12 = 88,
LG_KEY_RO = 89,
LG_KEY_KATAKANA = 90,
LG_KEY_HIRAGANA = 91,
LG_KEY_HENKAN = 92,
LG_KEY_KATAKANAHIRAGANA = 93,
LG_KEY_MUHENKAN = 94,
LG_KEY_KPJPCOMMA = 95,
LG_KEY_KPENTER = 96,
LG_KEY_RIGHTCTRL = 97,
LG_KEY_KPSLASH = 98,
LG_KEY_SYSRQ = 99,
LG_KEY_RIGHTALT = 100,
LG_KEY_HOME = 102,
LG_KEY_UP = 103,
LG_KEY_PAGEUP = 104,
LG_KEY_LEFT = 105,
LG_KEY_RIGHT = 106,
LG_KEY_END = 107,
LG_KEY_DOWN = 108,
LG_KEY_PAGEDOWN = 109,
LG_KEY_INSERT = 110,
LG_KEY_DELETE = 111,
LG_KEY_MUTE = 113,
LG_KEY_VOLUMEDOWN = 114,
LG_KEY_VOLUMEUP = 115,
LG_KEY_POWER = 116,
LG_KEY_KPEQUAL = 117,
LG_KEY_PAUSE = 119,
LG_KEY_KPCOMMA = 121,
LG_KEY_HANGEUL = 122,
LG_KEY_HANJA = 123,
LG_KEY_YEN = 124,
LG_KEY_LEFTMETA = 125,
LG_KEY_RIGHTMETA = 126,
LG_KEY_COMPOSE = 127,
LG_KEY_STOP = 128,
LG_KEY_AGAIN = 129,
LG_KEY_UNDO = 131,
LG_KEY_FRONT = 132,
LG_KEY_COPY = 133,
LG_KEY_OPEN = 134,
LG_KEY_PASTE = 135,
LG_KEY_FIND = 136,
LG_KEY_CUT = 137,
LG_KEY_HELP = 138,
LG_KEY_MENU = 139,
LG_KEY_CALC = 140,
LG_KEY_SLEEP = 142,
LG_KEY_WWW = 150,
LG_KEY_SCREENLOCK = 152,
LG_KEY_BACK = 158,
LG_KEY_FORWARD = 159,
LG_KEY_EJECTCD = 161,
LG_KEY_NEXTSONG = 163,
LG_KEY_PLAYPAUSE = 164,
LG_KEY_PREVIOUSSONG = 165,
LG_KEY_STOPCD = 166,
LG_KEY_REFRESH = 173,
LG_KEY_EDIT = 176,
LG_KEY_SCROLLUP = 177,
LG_KEY_SCROLLDOWN = 178,
LG_KEY_KPLEFTPAREN = 179,
LG_KEY_KPRIGHTPAREN = 180,
LG_KEY_F13 = 183,
LG_KEY_F14 = 184,
LG_KEY_F15 = 185,
LG_KEY_F16 = 186,
LG_KEY_F17 = 187,
LG_KEY_F18 = 188,
LG_KEY_F19 = 189,
LG_KEY_F20 = 190,
LG_KEY_F21 = 191,
LG_KEY_F22 = 192,
LG_KEY_F23 = 193,
LG_KEY_F24 = 194,
LG_KEY_PRINT = 210,
LG_KEY_MAX = 0x2ff,
}
LG_KeyCode;
#endif

2
client/renderers/EGL/desktop.c
View File

@@ -195,7 +195,7 @@ bool egl_desktopInit(EGL * egl, EGL_Desktop ** desktop_, EGLDisplay * display,
return false;
}
app_registerKeybind(KEY_N, toggleNV, desktop,
app_registerKeybind(LG_KEY_N, toggleNV, desktop,
"Toggle night vision mode");
desktop->nvMax = option_get_int("egl", "nvGainMax");

34
client/src/app.c
View File

@@ -448,10 +448,10 @@ void app_handleWheelMotion(double motion)
void app_handleKeyPressInternal(int sc)
{
if (sc == KEY_LEFTSHIFT)
if (sc == LG_KEY_LEFTSHIFT)
atomic_fetch_or_explicit(&g_state.keyModifiers,
KEY_MODIFIER_LEFT_SHIFT, memory_order_acq_rel);
else if (sc == KEY_RIGHTSHIFT)
else if (sc == LG_KEY_RIGHTSHIFT)
atomic_fetch_or_explicit(&g_state.keyModifiers,
KEY_MODIFIER_RIGHT_SHIFT, memory_order_acq_rel);
@@ -481,9 +481,9 @@ void app_handleKeyPressInternal(int sc)
{
unsigned modifiers = atomic_load_explicit(
&g_state.keyModifiers, memory_order_acquire);
if (g_params.escapeKey == KEY_LEFTSHIFT)
if (g_params.escapeKey == LG_KEY_LEFTSHIFT)
modifiers &= ~(unsigned)KEY_MODIFIER_LEFT_SHIFT;
else if (g_params.escapeKey == KEY_RIGHTSHIFT)
else if (g_params.escapeKey == LG_KEY_RIGHTSHIFT)
modifiers &= ~(unsigned)KEY_MODIFIER_RIGHT_SHIFT;
const bool shift = modifiers != 0;
if (!repeat)
@@ -508,12 +508,12 @@ void app_handleKeyPressInternal(int sc)
if (app_isOverlayMode())
{
if (sc == KEY_ESC)
if (sc == LG_KEY_ESC)
app_setOverlay(false);
else
{
if (linux_to_imgui[sc])
ImGuiIO_AddKeyEvent(g_state.io, linux_to_imgui[sc], true);
if (lg_keycode_to_imgui[sc])
ImGuiIO_AddKeyEvent(g_state.io, lg_keycode_to_imgui[sc], true);
}
return;
}
@@ -521,7 +521,7 @@ void app_handleKeyPressInternal(int sc)
if (!core_inputEnabled())
return;
if (g_params.ignoreWindowsKeys && (sc == KEY_LEFTMETA || sc == KEY_RIGHTMETA))
if (g_params.ignoreWindowsKeys && (sc == LG_KEY_LEFTMETA || sc == LG_KEY_RIGHTMETA))
return;
if (!lgInput_keyDown(sc))
@@ -530,10 +530,10 @@ void app_handleKeyPressInternal(int sc)
void app_handleKeyReleaseInternal(int sc)
{
if (sc == KEY_LEFTSHIFT)
if (sc == LG_KEY_LEFTSHIFT)
atomic_fetch_and_explicit(&g_state.keyModifiers,
~(unsigned)KEY_MODIFIER_LEFT_SHIFT, memory_order_acq_rel);
else if (sc == KEY_RIGHTSHIFT)
else if (sc == LG_KEY_RIGHTSHIFT)
atomic_fetch_and_explicit(&g_state.keyModifiers,
~(unsigned)KEY_MODIFIER_RIGHT_SHIFT, memory_order_acq_rel);
@@ -559,15 +559,15 @@ void app_handleKeyReleaseInternal(int sc)
if (app_isOverlayMode())
{
if (linux_to_imgui[sc])
ImGuiIO_AddKeyEvent(g_state.io, linux_to_imgui[sc], false);
if (lg_keycode_to_imgui[sc])
ImGuiIO_AddKeyEvent(g_state.io, lg_keycode_to_imgui[sc], false);
return;
}
if (!core_inputEnabled())
return;
if (g_params.ignoreWindowsKeys && (sc == KEY_LEFTMETA || sc == KEY_RIGHTMETA))
if (g_params.ignoreWindowsKeys && (sc == LG_KEY_LEFTMETA || sc == LG_KEY_RIGHTMETA))
return;
if (!lgInput_keyUp(sc))
@@ -623,9 +623,9 @@ void app_handleInputResetInternal(bool keyboard, bool pointer)
if (keyboard)
{
for(int key = 0; key < KEY_MAX; ++key)
if (linux_to_imgui[key])
ImGuiIO_AddKeyEvent(g_state.io, linux_to_imgui[key], false);
for(int key = 0; key < LG_KEY_MAX; ++key)
if (lg_keycode_to_imgui[key])
ImGuiIO_AddKeyEvent(g_state.io, lg_keycode_to_imgui[key], false);
g_state.modCtrl = false;
g_state.modShift = false;
@@ -909,7 +909,7 @@ KeybindHandle app_registerKeybind(int sc, KeybindFn callback, void * opaque,
return NULL;
}
if (sc <= KEY_RESERVED || sc >= KEY_MAX || !linux_to_display[sc])
if (sc <= LG_KEY_RESERVED || sc >= LG_KEY_MAX || !lg_keycode_to_display[sc])
{
DEBUG_ERROR("invalid keybind keycode: %d", sc);
return NULL;

18
client/src/config.c
View File

@@ -353,7 +353,7 @@ static struct Option options[] =
.description = "Specify the escape/menu key to use (use \"help\" to see valid values)",
.shortopt = 'm',
.type = OPTION_TYPE_INT,
.value.x_int = KEY_SCROLLLOCK,
.value.x_int = LG_KEY_SCROLLLOCK,
.parser = optScancodeParse,
.getValues = optScancodeValues,
.validator = optScancodeValidate,
@@ -896,16 +896,16 @@ static StringList optScancodeValues(struct Option * opt)
return NULL;
// this typecast is safe as the stringlist doesn't own the values
for(unsigned int i = 0; i < KEY_MAX; ++i)
if (linux_to_str[i])
stringlist_push(sl, (char *)linux_to_str[i]);
for(unsigned int i = 0; i < LG_KEY_MAX; ++i)
if (lg_keycode_to_name[i])
stringlist_push(sl, (char *)lg_keycode_to_name[i]);
return sl;
}
static bool optScancodeValidate(struct Option * opt, const char ** error)
{
if (opt->value.x_int >= 0 && opt->value.x_int < KEY_MAX)
if (opt->value.x_int >= 0 && opt->value.x_int < LG_KEY_MAX)
return true;
*error = "Out of range";
@@ -914,12 +914,12 @@ static bool optScancodeValidate(struct Option * opt, const char ** error)
static bool optScancodeParse(struct Option * opt, const char * str)
{
for(unsigned int i = 0; i < KEY_MAX; ++i)
for(unsigned int i = 0; i < LG_KEY_MAX; ++i)
{
if (!linux_to_str[i])
if (!lg_keycode_to_name[i])
continue;
if (strcasecmp(linux_to_str[i], str) == 0)
if (strcasecmp(lg_keycode_to_name[i], str) == 0)
{
opt->value.x_int = i;
return true;
@@ -939,7 +939,7 @@ static char * optScancodeToString(struct Option * opt)
{
char * str;
alloc_sprintf(&str, "%d = %s", opt->value.x_int,
linux_to_str[opt->value.x_int]);
lg_keycode_to_name[opt->value.x_int]);
return str;
}

6
client/src/core.c
View File

@@ -1149,9 +1149,9 @@ void core_resetOverlayInputState(void)
g_state.io->MouseDown[ImGuiMouseButton_Left ] = false;
g_state.io->MouseDown[ImGuiMouseButton_Right ] = false;
g_state.io->MouseDown[ImGuiMouseButton_Middle] = false;
for(int key = 0; key < KEY_MAX; key++)
if (linux_to_imgui[key])
ImGuiIO_AddKeyEvent(g_state.io, linux_to_imgui[key], false);
for(int key = 0; key < LG_KEY_MAX; key++)
if (lg_keycode_to_imgui[key])
ImGuiIO_AddKeyEvent(g_state.io, lg_keycode_to_imgui[key], false);
}
void core_updateOverlayState(void)

5
client/src/evdev.c
View File

@@ -55,6 +55,11 @@
#define EVDEV_WHEEL_LIMIT 64
#define EVDEV_GUEST_LEDS_VALID UINT8_C(0x80)
_Static_assert((int)LG_KEY_RESERVED == KEY_RESERVED,
"Looking Glass and evdev reserved keycodes differ");
_Static_assert((int)LG_KEY_MAX == KEY_MAX,
"Looking Glass and evdev maximum keycodes differ");
enum EvdevGrabReason
{
EVDEV_GRAB_KEYBOARD = 1 << 0,

14
client/src/input.c
View File

@@ -22,8 +22,8 @@
#include "common/debug.h"
#include "common/locking.h"
#include "input/keycodes.h"
#include <linux/input.h>
#include <stdatomic.h>
struct InputBinding
@@ -60,7 +60,7 @@ static struct
bool desiredKeyboardLEDsValid;
uint8_t desiredKeyboardLEDs;
_Atomic(bool) keys[KEY_MAX];
_Atomic(bool) keys[LG_KEY_MAX];
_Atomic(uint32_t) buttons;
}
l_input;
@@ -160,7 +160,7 @@ static void dispatchAvailability(void)
static void releaseKeysNL(void)
{
for (int key = 0; key < KEY_MAX; ++key)
for (int key = 0; key < LG_KEY_MAX; ++key)
if (atomic_exchange_explicit(&l_input.keys[key], false,
memory_order_relaxed) && l_input.active.ops)
l_input.active.ops->keyUp(l_input.active.opaque, key);
@@ -189,7 +189,7 @@ static void resetActiveNL(void)
static void clearStateNL(void)
{
for (int key = 0; key < KEY_MAX; ++key)
for (int key = 0; key < LG_KEY_MAX; ++key)
atomic_store_explicit(&l_input.keys[key], false, memory_order_relaxed);
atomic_store_explicit(&l_input.buttons, 0, memory_order_relaxed);
@@ -337,7 +337,7 @@ void lgInput_init(void)
l_input.desiredKeyboardLEDsValid = false;
l_input.desiredKeyboardLEDs = 0;
for (int key = 0; key < KEY_MAX; ++key)
for (int key = 0; key < LG_KEY_MAX; ++key)
atomic_init(&l_input.keys[key], false);
atomic_init(&l_input.buttons, 0);
@@ -531,7 +531,7 @@ void lgInput_setAvailabilityListener(
bool lgInput_keyDown(int key)
{
if (key < 0 || key >= KEY_MAX)
if (key < 0 || key >= LG_KEY_MAX)
return false;
LG_LOCK_SHARED(l_input.activeLock);
@@ -552,7 +552,7 @@ bool lgInput_keyDown(int key)
bool lgInput_keyUp(int key)
{
if (key < 0 || key >= KEY_MAX)
if (key < 0 || key >= LG_KEY_MAX)
return false;
LG_LOCK_SHARED(l_input.activeLock);

1230
client/src/kb.c
View File

File diff suppressed because it is too large Load Diff

13
client/src/kb.h
View File

@@ -21,17 +21,18 @@
#ifndef _H_LG_KB_
#define _H_LG_KB_
#include <linux/input.h>
#include <stdint.h>
#include "input/keycodes.h"
#define PS2_MUTE 0xE020
#define PS2_VOLUME_UP 0xE030
#define PS2_VOLUME_DOWN 0xE02E
extern const uint32_t linux_to_ps2[KEY_MAX];
extern const uint8_t linux_to_hid[KEY_MAX];
extern const char * linux_to_str[KEY_MAX];
extern const char * linux_to_display[KEY_MAX];
extern const int linux_to_imgui[KEY_MAX];
extern const uint32_t lg_keycode_to_ps2 [LG_KEY_MAX];
extern const uint8_t lg_keycode_to_hid [LG_KEY_MAX];
extern const char * lg_keycode_to_name [LG_KEY_MAX];
extern const char * lg_keycode_to_display[LG_KEY_MAX];
extern const int lg_keycode_to_imgui [LG_KEY_MAX];
#endif

294
client/src/kb_hid.c
View File

@@ -20,152 +20,152 @@
#include "kb.h"
const uint8_t linux_to_hid[KEY_MAX] =
const uint8_t lg_keycode_to_hid[LG_KEY_MAX] =
{
[KEY_ESC] = 41,
[KEY_1] = 30,
[KEY_2] = 31,
[KEY_3] = 32,
[KEY_4] = 33,
[KEY_5] = 34,
[KEY_6] = 35,
[KEY_7] = 36,
[KEY_8] = 37,
[KEY_9] = 38,
[KEY_0] = 39,
[KEY_MINUS] = 45,
[KEY_EQUAL] = 46,
[KEY_BACKSPACE] = 42,
[KEY_TAB] = 43,
[KEY_Q] = 20,
[KEY_W] = 26,
[KEY_E] = 8,
[KEY_R] = 21,
[KEY_T] = 23,
[KEY_Y] = 28,
[KEY_U] = 24,
[KEY_I] = 12,
[KEY_O] = 18,
[KEY_P] = 19,
[KEY_LEFTBRACE] = 47,
[KEY_RIGHTBRACE] = 48,
[KEY_ENTER] = 40,
[KEY_LEFTCTRL] = 224,
[KEY_A] = 4,
[KEY_S] = 22,
[KEY_D] = 7,
[KEY_F] = 9,
[KEY_G] = 10,
[KEY_H] = 11,
[KEY_J] = 13,
[KEY_K] = 14,
[KEY_L] = 15,
[KEY_SEMICOLON] = 51,
[KEY_APOSTROPHE] = 52,
[KEY_GRAVE] = 53,
[KEY_LEFTSHIFT] = 225,
[KEY_BACKSLASH] = 49,
[KEY_Z] = 29,
[KEY_X] = 27,
[KEY_C] = 6,
[KEY_V] = 25,
[KEY_B] = 5,
[KEY_N] = 17,
[KEY_M] = 16,
[KEY_COMMA] = 54,
[KEY_DOT] = 55,
[KEY_SLASH] = 56,
[KEY_RIGHTSHIFT] = 229,
[KEY_KPASTERISK] = 85,
[KEY_LEFTALT] = 226,
[KEY_SPACE] = 44,
[KEY_CAPSLOCK] = 57,
[KEY_F1] = 58,
[KEY_F2] = 59,
[KEY_F3] = 60,
[KEY_F4] = 61,
[KEY_F5] = 62,
[KEY_F6] = 63,
[KEY_F7] = 64,
[KEY_F8] = 65,
[KEY_F9] = 66,
[KEY_F10] = 67,
[KEY_NUMLOCK] = 83,
[KEY_SCROLLLOCK] = 71,
[KEY_KP7] = 95,
[KEY_KP8] = 96,
[KEY_KP9] = 97,
[KEY_KPMINUS] = 86,
[KEY_KP4] = 92,
[KEY_KP5] = 93,
[KEY_KP6] = 94,
[KEY_KPPLUS] = 87,
[KEY_KP1] = 89,
[KEY_KP2] = 90,
[KEY_KP3] = 91,
[KEY_KP0] = 98,
[KEY_KPDOT] = 99,
[KEY_102ND] = 100,
[KEY_F11] = 68,
[KEY_F12] = 69,
[KEY_RO] = 135,
[KEY_HENKAN] = 138,
[KEY_KATAKANAHIRAGANA] = 136,
[KEY_MUHENKAN] = 139,
[KEY_KPENTER] = 88,
[KEY_RIGHTCTRL] = 228,
[KEY_KPSLASH] = 84,
[KEY_SYSRQ] = 70,
[KEY_RIGHTALT] = 230,
[KEY_HOME] = 74,
[KEY_UP] = 82,
[KEY_PAGEUP] = 75,
[KEY_LEFT] = 80,
[KEY_RIGHT] = 79,
[KEY_END] = 77,
[KEY_DOWN] = 81,
[KEY_PAGEDOWN] = 78,
[KEY_INSERT] = 73,
[KEY_DELETE] = 76,
[KEY_KPEQUAL] = 103,
[KEY_PAUSE] = 72,
[KEY_KPCOMMA] = 133,
[KEY_HANGEUL] = 144,
[KEY_HANJA] = 145,
[KEY_YEN] = 137,
[KEY_LEFTMETA] = 227,
[KEY_RIGHTMETA] = 231,
[KEY_COMPOSE] = 101,
[KEY_POWER] = 102,
[KEY_F13] = 104,
[KEY_F14] = 105,
[KEY_F15] = 106,
[KEY_F16] = 107,
[KEY_F17] = 108,
[KEY_F18] = 109,
[KEY_F19] = 110,
[KEY_F20] = 111,
[KEY_F21] = 112,
[KEY_F22] = 113,
[KEY_F23] = 114,
[KEY_F24] = 115,
[KEY_OPEN] = 116,
[KEY_HELP] = 117,
[KEY_MENU] = 118,
[KEY_FRONT] = 119,
[KEY_AGAIN] = 121,
[KEY_UNDO] = 122,
[KEY_CUT] = 123,
[KEY_COPY] = 124,
[KEY_PASTE] = 125,
[KEY_KPJPCOMMA] = 140,
[KEY_KATAKANA] = 146,
[KEY_HIRAGANA] = 147,
[KEY_ZENKAKUHANKAKU] = 148,
[KEY_KPLEFTPAREN] = 182,
[KEY_KPRIGHTPAREN] = 183,
[KEY_PRINT] = 70,
[KEY_MUTE] = 127,
[KEY_VOLUMEUP] = 128,
[KEY_VOLUMEDOWN] = 129,
[LG_KEY_ESC] = 41,
[LG_KEY_1] = 30,
[LG_KEY_2] = 31,
[LG_KEY_3] = 32,
[LG_KEY_4] = 33,
[LG_KEY_5] = 34,
[LG_KEY_6] = 35,
[LG_KEY_7] = 36,
[LG_KEY_8] = 37,
[LG_KEY_9] = 38,
[LG_KEY_0] = 39,
[LG_KEY_MINUS] = 45,
[LG_KEY_EQUAL] = 46,
[LG_KEY_BACKSPACE] = 42,
[LG_KEY_TAB] = 43,
[LG_KEY_Q] = 20,
[LG_KEY_W] = 26,
[LG_KEY_E] = 8,
[LG_KEY_R] = 21,
[LG_KEY_T] = 23,
[LG_KEY_Y] = 28,
[LG_KEY_U] = 24,
[LG_KEY_I] = 12,
[LG_KEY_O] = 18,
[LG_KEY_P] = 19,
[LG_KEY_LEFTBRACE] = 47,
[LG_KEY_RIGHTBRACE] = 48,
[LG_KEY_ENTER] = 40,
[LG_KEY_LEFTCTRL] = 224,
[LG_KEY_A] = 4,
[LG_KEY_S] = 22,
[LG_KEY_D] = 7,
[LG_KEY_F] = 9,
[LG_KEY_G] = 10,
[LG_KEY_H] = 11,
[LG_KEY_J] = 13,
[LG_KEY_K] = 14,
[LG_KEY_L] = 15,
[LG_KEY_SEMICOLON] = 51,
[LG_KEY_APOSTROPHE] = 52,
[LG_KEY_GRAVE] = 53,
[LG_KEY_LEFTSHIFT] = 225,
[LG_KEY_BACKSLASH] = 49,
[LG_KEY_Z] = 29,
[LG_KEY_X] = 27,
[LG_KEY_C] = 6,
[LG_KEY_V] = 25,
[LG_KEY_B] = 5,
[LG_KEY_N] = 17,
[LG_KEY_M] = 16,
[LG_KEY_COMMA] = 54,
[LG_KEY_DOT] = 55,
[LG_KEY_SLASH] = 56,
[LG_KEY_RIGHTSHIFT] = 229,
[LG_KEY_KPASTERISK] = 85,
[LG_KEY_LEFTALT] = 226,
[LG_KEY_SPACE] = 44,
[LG_KEY_CAPSLOCK] = 57,
[LG_KEY_F1] = 58,
[LG_KEY_F2] = 59,
[LG_KEY_F3] = 60,
[LG_KEY_F4] = 61,
[LG_KEY_F5] = 62,
[LG_KEY_F6] = 63,
[LG_KEY_F7] = 64,
[LG_KEY_F8] = 65,
[LG_KEY_F9] = 66,
[LG_KEY_F10] = 67,
[LG_KEY_NUMLOCK] = 83,
[LG_KEY_SCROLLLOCK] = 71,
[LG_KEY_KP7] = 95,
[LG_KEY_KP8] = 96,
[LG_KEY_KP9] = 97,
[LG_KEY_KPMINUS] = 86,
[LG_KEY_KP4] = 92,
[LG_KEY_KP5] = 93,
[LG_KEY_KP6] = 94,
[LG_KEY_KPPLUS] = 87,
[LG_KEY_KP1] = 89,
[LG_KEY_KP2] = 90,
[LG_KEY_KP3] = 91,
[LG_KEY_KP0] = 98,
[LG_KEY_KPDOT] = 99,
[LG_KEY_102ND] = 100,
[LG_KEY_F11] = 68,
[LG_KEY_F12] = 69,
[LG_KEY_RO] = 135,
[LG_KEY_HENKAN] = 138,
[LG_KEY_KATAKANAHIRAGANA] = 136,
[LG_KEY_MUHENKAN] = 139,
[LG_KEY_KPENTER] = 88,
[LG_KEY_RIGHTCTRL] = 228,
[LG_KEY_KPSLASH] = 84,
[LG_KEY_SYSRQ] = 70,
[LG_KEY_RIGHTALT] = 230,
[LG_KEY_HOME] = 74,
[LG_KEY_UP] = 82,
[LG_KEY_PAGEUP] = 75,
[LG_KEY_LEFT] = 80,
[LG_KEY_RIGHT] = 79,
[LG_KEY_END] = 77,
[LG_KEY_DOWN] = 81,
[LG_KEY_PAGEDOWN] = 78,
[LG_KEY_INSERT] = 73,
[LG_KEY_DELETE] = 76,
[LG_KEY_KPEQUAL] = 103,
[LG_KEY_PAUSE] = 72,
[LG_KEY_KPCOMMA] = 133,
[LG_KEY_HANGEUL] = 144,
[LG_KEY_HANJA] = 145,
[LG_KEY_YEN] = 137,
[LG_KEY_LEFTMETA] = 227,
[LG_KEY_RIGHTMETA] = 231,
[LG_KEY_COMPOSE] = 101,
[LG_KEY_POWER] = 102,
[LG_KEY_F13] = 104,
[LG_KEY_F14] = 105,
[LG_KEY_F15] = 106,
[LG_KEY_F16] = 107,
[LG_KEY_F17] = 108,
[LG_KEY_F18] = 109,
[LG_KEY_F19] = 110,
[LG_KEY_F20] = 111,
[LG_KEY_F21] = 112,
[LG_KEY_F22] = 113,
[LG_KEY_F23] = 114,
[LG_KEY_F24] = 115,
[LG_KEY_OPEN] = 116,
[LG_KEY_HELP] = 117,
[LG_KEY_MENU] = 118,
[LG_KEY_FRONT] = 119,
[LG_KEY_AGAIN] = 121,
[LG_KEY_UNDO] = 122,
[LG_KEY_CUT] = 123,
[LG_KEY_COPY] = 124,
[LG_KEY_PASTE] = 125,
[LG_KEY_KPJPCOMMA] = 140,
[LG_KEY_KATAKANA] = 146,
[LG_KEY_HIRAGANA] = 147,
[LG_KEY_ZENKAKUHANKAKU] = 148,
[LG_KEY_KPLEFTPAREN] = 182,
[LG_KEY_KPRIGHTPAREN] = 183,
[LG_KEY_PRINT] = 70,
[LG_KEY_MUTE] = 127,
[LG_KEY_VOLUMEUP] = 128,
[LG_KEY_VOLUMEDOWN] = 129,
};

64
client/src/keybind.c
View File

@@ -103,13 +103,13 @@ static void bind_mouseSens(int sc, void * opaque)
static void bind_ctrlAltFn(int sc, void * opaque)
{
lgInput_keyDown(KEY_LEFTCTRL);
lgInput_keyDown(KEY_LEFTALT);
lgInput_keyDown(LG_KEY_LEFTCTRL);
lgInput_keyDown(LG_KEY_LEFTALT);
lgInput_keyDown(sc);
lgInput_keyUp(sc);
lgInput_keyUp(KEY_LEFTALT);
lgInput_keyUp(KEY_LEFTCTRL);
lgInput_keyUp(LG_KEY_LEFTALT);
lgInput_keyUp(LG_KEY_LEFTCTRL);
}
static void bind_passthrough(int sc, void * opaque)
@@ -152,22 +152,22 @@ static void bind_setGuestRes(int sc, void * opaque)
void keybind_commonRegister(void)
{
app_registerKeybind(KEY_F, bind_fullscreen , NULL,
app_registerKeybind(LG_KEY_F, bind_fullscreen , NULL,
"Full screen toggle");
app_registerKeybind(KEY_V, bind_video , NULL,
app_registerKeybind(LG_KEY_V, bind_video , NULL,
"Video stream toggle");
KeybindHandle rotate = app_registerKeybind(KEY_R, bind_rotate, NULL,
KeybindHandle rotate = app_registerKeybind(LG_KEY_R, bind_rotate, NULL,
"Rotate the output clockwise by 90° increments");
if (rotate)
{
rotate->shiftCallback = bind_forceRecovery;
rotate->shiftDescription = "Force guest display recovery";
}
app_registerKeybind(KEY_Q, bind_quit , NULL,
app_registerKeybind(LG_KEY_Q, bind_quit , NULL,
"Quit");
app_registerKeybind(KEY_O, bind_toggleOverlay, NULL,
app_registerKeybind(LG_KEY_O, bind_toggleOverlay, NULL,
"Toggle overlay");
app_registerKeybind(KEY_EQUAL, bind_setGuestRes, NULL,
app_registerKeybind(LG_KEY_EQUAL, bind_setGuestRes, NULL,
"Set guest resolution to match window size");
}
@@ -198,32 +198,32 @@ void keybind_inputRegister(void)
static bool firstTime = true;
if (firstTime)
{
app_registerKeybind(KEY_I, bind_input, NULL,
app_registerKeybind(LG_KEY_I, bind_input, NULL,
"Keyboard & mouse toggle");
app_registerKeybind(KEY_INSERT, bind_mouseSens, (void *) true,
app_registerKeybind(LG_KEY_INSERT, bind_mouseSens, (void *) true,
"Increase mouse sensitivity in capture mode");
app_registerKeybind(KEY_DELETE, bind_mouseSens, (void *) false,
app_registerKeybind(LG_KEY_DELETE, bind_mouseSens, (void *) false,
"Decrease mouse sensitivity in capture mode");
app_registerKeybind(KEY_UP, bind_toggleKey, (void *) KEY_VOLUMEUP,
app_registerKeybind(LG_KEY_UP, bind_toggleKey, (void *) LG_KEY_VOLUMEUP,
"Send volume up to the guest");
app_registerKeybind(KEY_DOWN, bind_toggleKey, (void *) KEY_VOLUMEDOWN,
app_registerKeybind(LG_KEY_DOWN, bind_toggleKey, (void *) LG_KEY_VOLUMEDOWN,
"Send volume down to the guest");
app_registerKeybind(KEY_M, bind_toggleKey, (void *) KEY_MUTE,
app_registerKeybind(LG_KEY_M, bind_toggleKey, (void *) LG_KEY_MUTE,
"Send mute to the guest");
app_registerKeybind(KEY_LEFTMETA, bind_passthrough, NULL,
app_registerKeybind(LG_KEY_LEFTMETA, bind_passthrough, NULL,
"Send LWin to the guest");
app_registerKeybind(KEY_RIGHTMETA, bind_passthrough, NULL,
app_registerKeybind(LG_KEY_RIGHTMETA, bind_passthrough, NULL,
"Send RWin to the guest");
#if ENABLE_AUDIO
if (lgAudio_supportsRecord())
{
app_registerKeybind(KEY_E, lgAudio_recordToggleKeybind, NULL,
app_registerKeybind(LG_KEY_E, lgAudio_recordToggleKeybind, NULL,
"Toggle audio recording");
app_registerKeybind(KEY_C, bind_toggleMicDefault, NULL,
app_registerKeybind(LG_KEY_C, bind_toggleMicDefault, NULL,
"Cycle audio recording default");
}
#endif
@@ -241,29 +241,29 @@ void keybind_inputRegister(void)
/* register OS based keybinds */
if (app_guestIsLinux())
{
handles[handleCount++] = app_registerKeybind(KEY_F1, bind_ctrlAltFn, NULL,
handles[handleCount++] = app_registerKeybind(LG_KEY_F1, bind_ctrlAltFn, NULL,
"Send Ctrl+Alt+F1 to the guest");
handles[handleCount++] = app_registerKeybind(KEY_F2, bind_ctrlAltFn, NULL,
handles[handleCount++] = app_registerKeybind(LG_KEY_F2, bind_ctrlAltFn, NULL,
"Send Ctrl+Alt+F2 to the guest");
handles[handleCount++] = app_registerKeybind(KEY_F3, bind_ctrlAltFn, NULL,
handles[handleCount++] = app_registerKeybind(LG_KEY_F3, bind_ctrlAltFn, NULL,
"Send Ctrl+Alt+F3 to the guest");
handles[handleCount++] = app_registerKeybind(KEY_F4, bind_ctrlAltFn, NULL,
handles[handleCount++] = app_registerKeybind(LG_KEY_F4, bind_ctrlAltFn, NULL,
"Send Ctrl+Alt+F4 to the guest");
handles[handleCount++] = app_registerKeybind(KEY_F5, bind_ctrlAltFn, NULL,
handles[handleCount++] = app_registerKeybind(LG_KEY_F5, bind_ctrlAltFn, NULL,
"Send Ctrl+Alt+F5 to the guest");
handles[handleCount++] = app_registerKeybind(KEY_F6, bind_ctrlAltFn, NULL,
handles[handleCount++] = app_registerKeybind(LG_KEY_F6, bind_ctrlAltFn, NULL,
"Send Ctrl+Alt+F6 to the guest");
handles[handleCount++] = app_registerKeybind(KEY_F7, bind_ctrlAltFn, NULL,
handles[handleCount++] = app_registerKeybind(LG_KEY_F7, bind_ctrlAltFn, NULL,
"Send Ctrl+Alt+F7 to the guest");
handles[handleCount++] = app_registerKeybind(KEY_F8, bind_ctrlAltFn, NULL,
handles[handleCount++] = app_registerKeybind(LG_KEY_F8, bind_ctrlAltFn, NULL,
"Send Ctrl+Alt+F8 to the guest");
handles[handleCount++] = app_registerKeybind(KEY_F9, bind_ctrlAltFn, NULL,
handles[handleCount++] = app_registerKeybind(LG_KEY_F9, bind_ctrlAltFn, NULL,
"Send Ctrl+Alt+F9 to the guest");
handles[handleCount++] = app_registerKeybind(KEY_F10, bind_ctrlAltFn, NULL,
handles[handleCount++] = app_registerKeybind(LG_KEY_F10, bind_ctrlAltFn, NULL,
"Send Ctrl+Alt+F10 to the guest");
handles[handleCount++] = app_registerKeybind(KEY_F11, bind_ctrlAltFn, NULL,
handles[handleCount++] = app_registerKeybind(LG_KEY_F11, bind_ctrlAltFn, NULL,
"Send Ctrl+Alt+F11 to the guest");
handles[handleCount++] = app_registerKeybind(KEY_F12, bind_ctrlAltFn, NULL,
handles[handleCount++] = app_registerKeybind(LG_KEY_F12, bind_ctrlAltFn, NULL,
"Send Ctrl+Alt+F12 to the guest");
}
}

1
client/src/main.c
View File

@@ -37,7 +37,6 @@
#include <math.h>
#include <stdlib.h>
#include <stdatomic.h>
#include <linux/input.h>
#include "common/array.h"
#include "common/debug.h"

7
client/src/main.h
View File

@@ -20,7 +20,8 @@
#include <stdbool.h>
#include <stdatomic.h>
#include <linux/input.h>
#include "input/keycodes.h"
#include "dynamic/displayservers.h"
#include "dynamic/renderers.h"
@@ -130,8 +131,8 @@ struct AppState
bool escapeActive;
uint64_t escapeTime;
int escapeAction;
bool escapeKeys[KEY_MAX];
bool escapeShiftKeys[KEY_MAX];
bool escapeKeys[LG_KEY_MAX];
bool escapeShiftKeys[LG_KEY_MAX];
atomic_uint keyModifiers;
bool escapeHelp;
struct ll * bindings;

2
client/src/overlay/fps.c
View File

@@ -53,7 +53,7 @@ static void fps_earlyInit(void)
static bool fps_init(void ** udata, const void * params)
{
app_registerKeybind(KEY_D, showFPSKeybind, NULL, "FPS display toggle");
app_registerKeybind(LG_KEY_D, showFPSKeybind, NULL, "FPS display toggle");
showFPS = option_get_bool("win", "showFPS");
return true;
}

2
client/src/overlay/graphs.c
View File

@@ -162,7 +162,7 @@ static bool graphs_init(void ** udata, const void * params)
}
app_overlayConfigRegister("Performance Metrics", configCallback, NULL);
app_registerKeybind(KEY_T, showTimingKeybind, NULL,
app_registerKeybind(LG_KEY_T, showTimingKeybind, NULL,
"Show frame timing information");
return true;
}

4
client/src/overlay/help.c
View File

@@ -57,7 +57,7 @@ static int help_render(void * udata, bool interactive, struct Rect * windowRects
if (igBeginTable("Help", 2, 0, (ImVec2) { 0.0f, 0.0f }, 0.0f))
{
char escapeLabel[8];
const char * escapeName = linux_to_display[g_params.escapeKey];
const char * escapeName = lg_keycode_to_display[g_params.escapeKey];
if (g_state.ds->getKeyLabel(
g_params.escapeKey, escapeLabel, sizeof(escapeLabel)))
escapeName = escapeLabel;
@@ -74,7 +74,7 @@ static int help_render(void * udata, bool interactive, struct Rect * windowRects
continue;
char keyLabel[8];
const char * keyName = linux_to_display[handle->sc];
const char * keyName = lg_keycode_to_display[handle->sc];
if (g_state.ds->getKeyLabel(handle->sc, keyLabel, sizeof(keyLabel)))
keyName = keyLabel;

10
client/tests/CMakeLists.txt
View File

@@ -49,6 +49,16 @@ if(LG_CLIENT_PLATFORM_LINUX)
set_tests_properties(lgmp-platform-tests PROPERTIES
TIMEOUT 10
)
add_executable(keycode-tests
keycode_test.c
)
add_test(NAME keycode-tests
COMMAND keycode-tests
)
set_tests_properties(keycode-tests PROPERTIES
TIMEOUT 10
)
endif()
if(LG_CLIENT_PLATFORM_WINDOWS)

82
client/tests/app_keybind_test.c
View File

@@ -81,15 +81,15 @@ struct CursorState g_cursor;
struct AppParams g_params;
_Atomic(enum RunState) p_appState;
const char * linux_to_display[KEY_MAX] =
const char * lg_keycode_to_display[LG_KEY_MAX] =
{
[KEY_ESC] = "Esc",
[KEY_A] = "A",
[KEY_B] = "B",
[KEY_C] = "C",
[LG_KEY_ESC] = "Esc",
[LG_KEY_A] = "A",
[LG_KEY_B] = "B",
[LG_KEY_C] = "C",
};
const int linux_to_imgui[KEY_MAX] = { 0 };
const int lg_keycode_to_imgui[LG_KEY_MAX] = { 0 };
static bool getFullscreen(void)
{
@@ -136,7 +136,7 @@ static void init(void)
g_state.ds = &ds;
g_state.focused = true;
g_params.escapeKey = KEY_ESC;
g_params.escapeKey = LG_KEY_ESC;
atomic_store(&p_appState, APP_STATE_RUNNING);
CHECK(g_state.bindings);
@@ -256,12 +256,12 @@ static void checkKey(unsigned int index, bool down, int key)
static void testInvalid(void)
{
init();
CHECK(!app_registerKeybind(KEY_RESERVED, count, &t, "reserved"));
CHECK(!app_registerKeybind(KEY_MAX, count, &t, "past-end"));
CHECK(!app_registerKeybind(KEY_MAX - 1, count, &t, "unmapped"));
CHECK(!app_registerKeybind(LG_KEY_RESERVED, count, &t, "reserved"));
CHECK(!app_registerKeybind(LG_KEY_MAX, count, &t, "past-end"));
CHECK(!app_registerKeybind(LG_KEY_MAX - 1, count, &t, "unmapped"));
CHECK(ll_count(g_state.bindings) == 0);
KeybindHandle handle = app_registerKeybind(KEY_A, count, &t, "valid");
KeybindHandle handle = app_registerKeybind(LG_KEY_A, count, &t, "valid");
CHECK(handle);
CHECK(ll_count(g_state.bindings) == 1);
fini();
@@ -270,7 +270,7 @@ static void testInvalid(void)
static void testNullCallback(void)
{
init();
CHECK(!app_registerKeybind(KEY_A, NULL, NULL, "null callback"));
CHECK(!app_registerKeybind(LG_KEY_A, NULL, NULL, "null callback"));
CHECK(ll_count(g_state.bindings) == 0);
fini();
}
@@ -278,9 +278,9 @@ static void testNullCallback(void)
static void testDuplicate(void)
{
init();
KeybindHandle first = app_registerKeybind(KEY_A, count, &t, "first");
KeybindHandle first = app_registerKeybind(LG_KEY_A, count, &t, "first");
CHECK(first);
CHECK(!app_registerKeybind(KEY_A, count, &t, "duplicate"));
CHECK(!app_registerKeybind(LG_KEY_A, count, &t, "duplicate"));
CHECK(ll_count(g_state.bindings) == 1);
app_releaseKeybind(&first);
@@ -289,7 +289,7 @@ static void testDuplicate(void)
app_releaseKeybind(&first);
CHECK(!first);
first = app_registerKeybind(KEY_A, count, &t, "replacement");
first = app_registerKeybind(LG_KEY_A, count, &t, "replacement");
CHECK(first);
CHECK(ll_count(g_state.bindings) == 1);
fini();
@@ -298,23 +298,23 @@ static void testDuplicate(void)
static void testNormal(void)
{
init();
app_handleKeyPress(KEY_A);
app_handleKeyPress(KEY_A);
app_handleKeyRelease(KEY_A);
app_handleKeyPress(LG_KEY_A);
app_handleKeyPress(LG_KEY_A);
app_handleKeyRelease(LG_KEY_A);
CHECK(t.keyN == 3);
checkKey(0, true , KEY_A);
checkKey(1, true , KEY_A);
checkKey(2, false, KEY_A);
checkKey(0, true , LG_KEY_A);
checkKey(1, true , LG_KEY_A);
checkKey(2, false, LG_KEY_A);
t.exclusive = true;
app_handleKeyPress(KEY_B);
app_handleKeyRelease(KEY_B);
app_handleKeyPress(LG_KEY_B);
app_handleKeyRelease(LG_KEY_B);
CHECK(t.keyN == 3);
t.exclusive = false;
g_params.ignoreWindowsKeys = true;
app_handleKeyPress(KEY_LEFTMETA);
app_handleKeyRelease(KEY_LEFTMETA);
app_handleKeyPress(LG_KEY_LEFTMETA);
app_handleKeyRelease(LG_KEY_LEFTMETA);
CHECK(t.keyN == 3);
fini();
}
@@ -322,21 +322,21 @@ static void testNormal(void)
static void testDispatch(void)
{
init();
CHECK(app_registerKeybind(KEY_A, count, &t, "action"));
app_handleKeyPress(KEY_ESC);
CHECK(app_registerKeybind(LG_KEY_A, count, &t, "action"));
app_handleKeyPress(LG_KEY_ESC);
CHECK(g_state.escapeActive);
CHECK(g_state.escapeAction == -1);
CHECK(t.keyN == 0);
app_handleKeyPress(KEY_A);
app_handleKeyPress(KEY_A);
app_handleKeyPress(LG_KEY_A);
app_handleKeyPress(LG_KEY_A);
CHECK(t.cbN == 2);
CHECK(t.cbKey == KEY_A);
CHECK(g_state.escapeAction == KEY_A);
CHECK(t.cbKey == LG_KEY_A);
CHECK(g_state.escapeAction == LG_KEY_A);
CHECK(t.keyN == 0);
app_handleKeyRelease(KEY_A);
app_handleKeyRelease(KEY_ESC);
app_handleKeyRelease(LG_KEY_A);
app_handleKeyRelease(LG_KEY_ESC);
CHECK(!g_state.escapeActive);
CHECK(t.cbN == 2);
CHECK(t.keyN == 0);
@@ -346,16 +346,16 @@ static void testDispatch(void)
static void testReleaseAll(void)
{
init();
CHECK(app_registerKeybind(KEY_A, count, &t, "a"));
CHECK(app_registerKeybind(KEY_B, count, &t, "b"));
CHECK(app_registerKeybind(KEY_C, count, &t, "c"));
CHECK(app_registerKeybind(LG_KEY_A, count, &t, "a"));
CHECK(app_registerKeybind(LG_KEY_B, count, &t, "b"));
CHECK(app_registerKeybind(LG_KEY_C, count, &t, "c"));
CHECK(ll_count(g_state.bindings) == 3);
app_releaseAllKeybinds();
CHECK(ll_count(g_state.bindings) == 0);
app_releaseAllKeybinds();
CHECK(ll_count(g_state.bindings) == 0);
CHECK(app_registerKeybind(KEY_A, count, &t, "again"));
CHECK(app_registerKeybind(LG_KEY_A, count, &t, "again"));
CHECK(ll_count(g_state.bindings) == 1);
fini();
}
@@ -405,16 +405,16 @@ static void testFocus(void)
static void testReentrant(void)
{
init();
re.handle = app_registerKeybind(KEY_A, replace, &re, "old");
re.handle = app_registerKeybind(LG_KEY_A, replace, &re, "old");
CHECK(re.handle);
app_handleKeyPress(KEY_ESC);
app_handleKeyPress(KEY_A);
app_handleKeyPress(LG_KEY_ESC);
app_handleKeyPress(LG_KEY_A);
CHECK(re.oldN == 1);
CHECK(re.newN == 0);
CHECK(re.handle);
CHECK(ll_count(g_state.bindings) == 1);
app_handleKeyPress(KEY_A);
app_handleKeyPress(LG_KEY_A);
CHECK(re.oldN == 1);
CHECK(re.newN == 1);
CHECK(ll_count(g_state.bindings) == 1);

8
client/tests/config_message_test.c
View File

@@ -59,10 +59,10 @@ struct AppState g_state;
struct CursorState g_cursor;
struct AppParams g_params;
const char * linux_to_str[KEY_MAX] =
const char * lg_keycode_to_name[LG_KEY_MAX] =
{
[KEY_A] = "KEY_A",
[KEY_RIGHTCTRL] = "KEY_RIGHTCTRL",
[LG_KEY_A] = "KEY_A",
[LG_KEY_RIGHTCTRL] = "KEY_RIGHTCTRL",
};
static const char * renAName(void)
@@ -352,7 +352,7 @@ static void testCfgValues(void)
struct Option * key = opt("input", "escapeKey");
CHECK(key->parser(key, "KEY_A"));
CHECK(key->value.x_int == KEY_A);
CHECK(key->value.x_int == LG_KEY_A);
char * keyName = key->toString(key);
CHECK(keyName);
CHECK(strstr(keyName, "KEY_A"));

74
client/tests/input_test.c
View File

@@ -22,7 +22,7 @@
#include "common/debug.h"
#include <linux/input.h>
#include "input/keycodes.h"
#include <stdint.h>
#include <stdio.h>
#include <string.h>
@@ -70,7 +70,7 @@ typedef struct FakeInput
RetiredListener retired[TEST_RETIRED_LISTENERS];
unsigned retiredCount;
FakeCalls calls;
bool remoteKeys[KEY_MAX];
bool remoteKeys[LG_KEY_MAX];
uint32_t remoteButtons;
int lastKeyDown;
int lastKeyUp;
@@ -167,7 +167,7 @@ static bool fakeKeyDown(void * opaque, int key)
FakeInput * input = opaque;
if (!fakeAlive(input))
return false;
if (key < 0 || key >= KEY_MAX)
if (key < 0 || key >= LG_KEY_MAX)
{
++input->calls.fault;
return false;
@@ -186,7 +186,7 @@ static bool fakeKeyUp(void * opaque, int key)
FakeInput * input = opaque;
if (!fakeAlive(input))
return false;
if (key < 0 || key >= KEY_MAX)
if (key < 0 || key >= LG_KEY_MAX)
{
++input->calls.fault;
return false;
@@ -410,9 +410,9 @@ static bool testHandoff(TestState * state)
{
CHECK(bindBoth(state));
CHECK(lgInput_keyDown(KEY_A));
CHECK(lgInput_keyDown(LG_KEY_A));
CHECK(lgInput_mousePress(1));
CHECK(state->transport.remoteKeys[KEY_A]);
CHECK(state->transport.remoteKeys[LG_KEY_A]);
CHECK(state->transport.remoteButtons & (UINT32_C(1) << 1));
const unsigned transportKeyUp = state->transport.calls.keyUp;
@@ -421,42 +421,42 @@ static bool testHandoff(TestState * state)
const unsigned fallbackReset = state->fallback.calls.reset;
CHECK(setAvailable(&state->transport, false));
CHECK(state->transport.calls.keyUp == transportKeyUp + 1);
CHECK(state->transport.lastKeyUp == KEY_A);
CHECK(state->transport.lastKeyUp == LG_KEY_A);
CHECK(state->transport.calls.release == transportRelease + 1);
CHECK(state->transport.lastRelease == 1);
CHECK(state->transport.calls.reset == transportReset + 1);
CHECK(state->fallback.calls.reset == fallbackReset + 1);
CHECK(!state->transport.remoteKeys[KEY_A]);
CHECK(!state->transport.remoteKeys[LG_KEY_A]);
CHECK(state->transport.remoteButtons == 0);
const unsigned fallbackKeyUp = state->fallback.calls.keyUp;
const unsigned fallbackRelease = state->fallback.calls.release;
CHECK(lgInput_keyUp(KEY_A));
CHECK(lgInput_keyUp(LG_KEY_A));
CHECK(lgInput_mouseRelease(1));
CHECK(state->fallback.calls.keyUp == fallbackKeyUp);
CHECK(state->fallback.calls.release == fallbackRelease);
CHECK(lgInput_keyDown(KEY_B));
CHECK(lgInput_keyDown(LG_KEY_B));
CHECK(lgInput_mousePress(2));
CHECK(state->fallback.remoteKeys[KEY_B]);
CHECK(state->fallback.remoteKeys[LG_KEY_B]);
CHECK(setAvailable(&state->transport, true));
CHECK(state->fallback.calls.keyUp == fallbackKeyUp + 1);
CHECK(state->fallback.lastKeyUp == KEY_B);
CHECK(state->fallback.lastKeyUp == LG_KEY_B);
CHECK(state->fallback.calls.release == fallbackRelease + 1);
CHECK(state->fallback.lastRelease == 2);
CHECK(!state->fallback.remoteKeys[KEY_B]);
CHECK(!state->fallback.remoteKeys[LG_KEY_B]);
CHECK(state->fallback.remoteButtons == 0);
CHECK(lgInput_keyDown(KEY_C));
CHECK(lgInput_keyDown(LG_KEY_C));
CHECK(lgInput_mousePress(3));
const unsigned secondTransportKeyUp = state->transport.calls.keyUp;
const unsigned secondTransportRelease = state->transport.calls.release;
lgInput_useTransport(false);
CHECK(state->transport.calls.keyUp == secondTransportKeyUp + 1);
CHECK(state->transport.lastKeyUp == KEY_C);
CHECK(state->transport.lastKeyUp == LG_KEY_C);
CHECK(state->transport.calls.release == secondTransportRelease + 1);
CHECK(state->transport.lastRelease == 3);
CHECK(!state->transport.remoteKeys[KEY_C]);
CHECK(!state->transport.remoteKeys[LG_KEY_C]);
CHECK(state->transport.remoteButtons == 0);
return true;
}
@@ -492,7 +492,7 @@ static bool testStale(TestState * state)
static bool testDeadDrop(TestState * state)
{
CHECK(bindBoth(state));
CHECK(lgInput_keyDown(KEY_A));
CHECK(lgInput_keyDown(LG_KEY_A));
CHECK(lgInput_mousePress(1));
LG_InputStatusFn stale = state->transport.listener;
@@ -509,13 +509,13 @@ static bool testDeadDrop(TestState * state)
CHECK(state->transport.calls.reset == reset);
CHECK(state->transport.calls.listenerClear == listenerClear);
CHECK(state->transport.calls.dead == 0);
CHECK(state->transport.remoteKeys[KEY_A]);
CHECK(state->transport.remoteKeys[LG_KEY_A]);
CHECK(state->transport.remoteButtons & (UINT32_C(1) << 1));
CHECK(lgInput_available());
const unsigned fallbackKeyUp = state->fallback.calls.keyUp;
const unsigned fallbackRelease = state->fallback.calls.release;
CHECK(lgInput_keyUp(KEY_A));
CHECK(lgInput_keyUp(LG_KEY_A));
CHECK(lgInput_mouseRelease(1));
CHECK(state->fallback.calls.keyUp == fallbackKeyUp);
CHECK(state->fallback.calls.release == fallbackRelease);
@@ -541,23 +541,23 @@ static bool testRollback(TestState * state)
CHECK(lgInput_available());
state->transport.keyDownResult = false;
CHECK(!lgInput_keyDown(KEY_A));
CHECK(!lgInput_keyDown(LG_KEY_A));
CHECK(state->transport.calls.keyDown == 1);
state->transport.keyDownResult = true;
CHECK(lgInput_keyDown(KEY_A));
CHECK(lgInput_keyDown(LG_KEY_A));
CHECK(state->transport.calls.keyDown == 2);
CHECK(lgInput_keyDown(KEY_A));
CHECK(lgInput_keyDown(LG_KEY_A));
CHECK(state->transport.calls.keyDown == 2);
state->transport.keyUpResult = false;
CHECK(!lgInput_keyUp(KEY_A));
CHECK(!lgInput_keyUp(LG_KEY_A));
CHECK(state->transport.calls.keyUp == 1);
CHECK(state->transport.remoteKeys[KEY_A]);
CHECK(state->transport.remoteKeys[LG_KEY_A]);
state->transport.keyUpResult = true;
CHECK(lgInput_keyUp(KEY_A));
CHECK(lgInput_keyUp(LG_KEY_A));
CHECK(state->transport.calls.keyUp == 2);
CHECK(!state->transport.remoteKeys[KEY_A]);
CHECK(lgInput_keyUp(KEY_A));
CHECK(!state->transport.remoteKeys[LG_KEY_A]);
CHECK(lgInput_keyUp(LG_KEY_A));
CHECK(state->transport.calls.keyUp == 2);
state->transport.pressResult = false;
@@ -588,9 +588,9 @@ static bool testDuplicate(TestState * state)
CHECK(lgInput_available());
CHECK(!lgInput_keyDown(-1));
CHECK(!lgInput_keyDown(KEY_MAX));
CHECK(!lgInput_keyDown(LG_KEY_MAX));
CHECK(!lgInput_keyUp(-1));
CHECK(!lgInput_keyUp(KEY_MAX));
CHECK(!lgInput_keyUp(LG_KEY_MAX));
CHECK(!lgInput_mousePress(0));
CHECK(!lgInput_mousePress(32));
CHECK(!lgInput_mouseRelease(0));
@@ -600,11 +600,11 @@ static bool testDuplicate(TestState * state)
CHECK(state->transport.calls.press == 0);
CHECK(state->transport.calls.release == 0);
CHECK(lgInput_keyDown(KEY_A));
CHECK(lgInput_keyDown(KEY_A));
CHECK(lgInput_keyDown(LG_KEY_A));
CHECK(lgInput_keyDown(LG_KEY_A));
CHECK(state->transport.calls.keyDown == 1);
CHECK(lgInput_keyUp(KEY_A));
CHECK(lgInput_keyUp(KEY_A));
CHECK(lgInput_keyUp(LG_KEY_A));
CHECK(lgInput_keyUp(LG_KEY_A));
CHECK(state->transport.calls.keyUp == 1);
CHECK(lgInput_mousePress(1));
@@ -614,13 +614,13 @@ static bool testDuplicate(TestState * state)
CHECK(lgInput_mouseRelease(1));
CHECK(state->transport.calls.release == 1);
CHECK(lgInput_keyDown(KEY_B));
CHECK(lgInput_keyDown(KEY_C));
CHECK(lgInput_keyDown(LG_KEY_B));
CHECK(lgInput_keyDown(LG_KEY_C));
const unsigned keyUp = state->transport.calls.keyUp;
lgInput_releaseKeys();
CHECK(state->transport.calls.keyUp == keyUp + 2);
CHECK(!state->transport.remoteKeys[KEY_B]);
CHECK(!state->transport.remoteKeys[KEY_C]);
CHECK(!state->transport.remoteKeys[LG_KEY_B]);
CHECK(!state->transport.remoteKeys[LG_KEY_C]);
lgInput_releaseKeys();
CHECK(state->transport.calls.keyUp == keyUp + 2);
return true;

112
client/tests/keybind_test.c
View File

@@ -93,9 +93,9 @@ void app_setState(enum RunState state)
static const int fKeys[] =
{
KEY_F1 , KEY_F2 , KEY_F3 , KEY_F4,
KEY_F5 , KEY_F6 , KEY_F7 , KEY_F8,
KEY_F9 , KEY_F10, KEY_F11, KEY_F12,
LG_KEY_F1 , LG_KEY_F2 , LG_KEY_F3 , LG_KEY_F4,
LG_KEY_F5 , LG_KEY_F6 , LG_KEY_F7 , LG_KEY_F8,
LG_KEY_F9 , LG_KEY_F10, LG_KEY_F11, LG_KEY_F12,
};
static void realign(void)
@@ -134,7 +134,7 @@ static void call(int sc)
KeybindHandle app_registerKeybind(int sc, KeybindFn callback, void * opaque,
const char * description)
{
CHECK(sc > KEY_RESERVED && sc < KEY_MAX);
CHECK(sc > LG_KEY_RESERVED && sc < LG_KEY_MAX);
CHECK(callback);
CHECK(description);
++t.tryN;
@@ -286,12 +286,12 @@ static void testCommon(void)
CHECK(t.tryN == 6);
CHECK(t.activeN == 6);
CHECK(t.collisionN == 0);
checkBind(0, KEY_F, "Full screen toggle");
checkBind(1, KEY_V, "Video stream toggle");
checkBind(2, KEY_R, "Rotate the output clockwise by 90° increments");
checkBind(3, KEY_Q, "Quit");
checkBind(4, KEY_O, "Toggle overlay");
checkBind(5, KEY_EQUAL,
checkBind(0, LG_KEY_F, "Full screen toggle");
checkBind(1, LG_KEY_V, "Video stream toggle");
checkBind(2, LG_KEY_R, "Rotate the output clockwise by 90° increments");
checkBind(3, LG_KEY_Q, "Quit");
checkBind(4, LG_KEY_O, "Toggle overlay");
checkBind(5, LG_KEY_EQUAL,
"Set guest resolution to match window size");
keybind_commonRegister();
@@ -303,28 +303,28 @@ static void testCommon(void)
static void testOS(void)
{
reset();
CHECK(app_registerKeybind(KEY_F1, nop, NULL, "external"));
CHECK(app_registerKeybind(LG_KEY_F1, nop, NULL, "external"));
t.isLinux = true;
keybind_inputRegister();
CHECK(t.tryN == 21);
CHECK(t.activeN == 20);
CHECK(t.collisionN == 1);
CHECK(find(KEY_I));
CHECK(find(KEY_LEFTMETA));
CHECK(find(KEY_RIGHTMETA));
CHECK(find(LG_KEY_I));
CHECK(find(LG_KEY_LEFTMETA));
CHECK(find(LG_KEY_RIGHTMETA));
for (unsigned int i = 0; i < ARRAY_LENGTH(fKeys); ++i)
CHECK(find(fKeys[i]));
struct Bind * fixed = find(KEY_I);
struct Bind * oldF2 = find(KEY_F2);
struct Bind * fixed = find(LG_KEY_I);
struct Bind * oldF2 = find(LG_KEY_F2);
const unsigned int op = t.opN;
keybind_inputRegister();
CHECK(t.activeN == 20);
CHECK(t.releaseN == 11);
CHECK(t.collisionN == 2);
CHECK(find(KEY_I) == fixed);
CHECK(find(KEY_F2) != oldF2);
CHECK(find(LG_KEY_I) == fixed);
CHECK(find(LG_KEY_F2) != oldF2);
CHECK(!oldF2->active);
CHECK(t.opN == op + 22);
for (unsigned int i = 0; i < 11; ++i)
@@ -337,8 +337,8 @@ static void testOS(void)
keybind_inputRegister();
CHECK(t.activeN == 9);
CHECK(t.releaseN == 22);
CHECK(find(KEY_I) == fixed);
CHECK(strcmp(find(KEY_F1)->handle.description, "external") == 0);
CHECK(find(LG_KEY_I) == fixed);
CHECK(strcmp(find(LG_KEY_F1)->handle.description, "external") == 0);
for (unsigned int i = 1; i < ARRAY_LENGTH(fKeys); ++i)
CHECK(!find(fKeys[i]));
@@ -353,35 +353,35 @@ static void testOrder(void)
reset();
t.isLinux = true;
keybind_inputRegister();
call(KEY_F5);
call(LG_KEY_F5);
CHECK(t.keyN == 6);
checkKey(0, true , KEY_LEFTCTRL);
checkKey(1, true , KEY_LEFTALT );
checkKey(2, true , KEY_F5 );
checkKey(3, false, KEY_F5 );
checkKey(4, false, KEY_LEFTALT );
checkKey(5, false, KEY_LEFTCTRL);
checkKey(0, true , LG_KEY_LEFTCTRL);
checkKey(1, true , LG_KEY_LEFTALT );
checkKey(2, true , LG_KEY_F5 );
checkKey(3, false, LG_KEY_F5 );
checkKey(4, false, LG_KEY_LEFTALT );
checkKey(5, false, LG_KEY_LEFTCTRL);
}
static void testRepeat(void)
{
reset();
keybind_inputRegister();
call(KEY_LEFTMETA);
call(KEY_LEFTMETA);
call(KEY_UP);
call(KEY_UP);
call(LG_KEY_LEFTMETA);
call(LG_KEY_LEFTMETA);
call(LG_KEY_UP);
call(LG_KEY_UP);
CHECK(t.keyN == 8);
checkKey(0, true , KEY_LEFTMETA);
checkKey(1, false, KEY_LEFTMETA);
checkKey(2, true , KEY_LEFTMETA);
checkKey(3, false, KEY_LEFTMETA);
checkKey(4, true , KEY_VOLUMEUP);
checkKey(5, false, KEY_VOLUMEUP);
checkKey(6, true , KEY_VOLUMEUP);
checkKey(7, false, KEY_VOLUMEUP);
checkKey(0, true , LG_KEY_LEFTMETA);
checkKey(1, false, LG_KEY_LEFTMETA);
checkKey(2, true , LG_KEY_LEFTMETA);
checkKey(3, false, LG_KEY_LEFTMETA);
checkKey(4, true , LG_KEY_VOLUMEUP);
checkKey(5, false, LG_KEY_VOLUMEUP);
checkKey(6, true , LG_KEY_VOLUMEUP);
checkKey(7, false, LG_KEY_VOLUMEUP);
}
static void testActions(void)
@@ -390,66 +390,66 @@ static void testActions(void)
keybind_commonRegister();
keybind_inputRegister();
call(KEY_F);
call(LG_KEY_F);
CHECK(t.fullscreen);
call(KEY_F);
call(LG_KEY_F);
CHECK(!t.fullscreen);
call(KEY_V);
call(LG_KEY_V);
CHECK(g_state.stopVideo);
call(KEY_V);
call(LG_KEY_V);
CHECK(!g_state.stopVideo);
CHECK(t.videoN == 2);
g_params.winRotate = LG_ROTATE_MAX - 1;
call(KEY_R);
call(LG_KEY_R);
CHECK(g_params.winRotate == 0);
call(KEY_R);
call(LG_KEY_R);
CHECK(g_params.winRotate == 1);
CHECK(t.posN == 2);
call(KEY_O);
call(LG_KEY_O);
CHECK(g_state.overlayInput);
call(KEY_O);
call(LG_KEY_O);
CHECK(!g_state.overlayInput);
CHECK(t.overlayN == 2);
g_state.ignoreInput = false;
call(KEY_I);
call(LG_KEY_I);
CHECK(g_state.ignoreInput);
CHECK(t.cursorN == 1);
CHECK(!t.cursorInView);
CHECK(strcmp(t.alert, "Input Disabled") == 0);
call(KEY_I);
call(LG_KEY_I);
CHECK(!g_state.ignoreInput);
CHECK(t.realignN == 1);
CHECK(strcmp(t.alert, "Input Enabled") == 0);
g_cursor.sens = 8;
call(KEY_INSERT);
call(KEY_INSERT);
call(LG_KEY_INSERT);
call(LG_KEY_INSERT);
CHECK(g_cursor.sens == 9);
CHECK(strcmp(t.alert, "Sensitivity: +9") == 0);
g_cursor.sens = -8;
call(KEY_DELETE);
call(KEY_DELETE);
call(LG_KEY_DELETE);
call(LG_KEY_DELETE);
CHECK(g_cursor.sens == -9);
CHECK(strcmp(t.alert, "Sensitivity: -9") == 0);
g_state.windowW = 1920;
g_state.windowH = 1080;
call(KEY_EQUAL);
call(LG_KEY_EQUAL);
CHECK(t.msgN == 0);
CHECK(strcmp(t.alert,
"The guest doesn't support this feature") == 0);
g_state.transportFeatures = LG_TRANSPORT_FEATURE_WINDOW_SIZE;
call(KEY_EQUAL);
call(LG_KEY_EQUAL);
CHECK(t.msgN == 1);
CHECK(t.msg.type == LG_MSG_WINDOWSIZE);
CHECK(t.msg.windowSize.width == 1920);
CHECK(t.msg.windowSize.height == 1080);
call(KEY_Q);
call(LG_KEY_Q);
CHECK(app_getState() == APP_STATE_SHUTDOWN);
}

196
client/tests/keycode_test.c Normal file
View File

@@ -0,0 +1,196 @@
/**
* Looking Glass
* Copyright © 2017-2026 The Looking Glass Authors
* https://looking-glass.io
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the Free
* Software Foundation; either version 2 of the License, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc., 59
* Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include "input/keycodes.h"
#include "test.h"
#include <linux/input-event-codes.h>
#define CHECK_KEY(name) CHECK((int)LG_KEY_##name == KEY_##name)
int main(void)
{
CHECK_KEY(RESERVED);
CHECK_KEY(ESC);
CHECK_KEY(1);
CHECK_KEY(2);
CHECK_KEY(3);
CHECK_KEY(4);
CHECK_KEY(5);
CHECK_KEY(6);
CHECK_KEY(7);
CHECK_KEY(8);
CHECK_KEY(9);
CHECK_KEY(0);
CHECK_KEY(MINUS);
CHECK_KEY(EQUAL);
CHECK_KEY(BACKSPACE);
CHECK_KEY(TAB);
CHECK_KEY(Q);
CHECK_KEY(W);
CHECK_KEY(E);
CHECK_KEY(R);
CHECK_KEY(T);
CHECK_KEY(Y);
CHECK_KEY(U);
CHECK_KEY(I);
CHECK_KEY(O);
CHECK_KEY(P);
CHECK_KEY(LEFTBRACE);
CHECK_KEY(RIGHTBRACE);
CHECK_KEY(ENTER);
CHECK_KEY(LEFTCTRL);
CHECK_KEY(A);
CHECK_KEY(S);
CHECK_KEY(D);
CHECK_KEY(F);
CHECK_KEY(G);
CHECK_KEY(H);
CHECK_KEY(J);
CHECK_KEY(K);
CHECK_KEY(L);
CHECK_KEY(SEMICOLON);
CHECK_KEY(APOSTROPHE);
CHECK_KEY(GRAVE);
CHECK_KEY(LEFTSHIFT);
CHECK_KEY(BACKSLASH);
CHECK_KEY(Z);
CHECK_KEY(X);
CHECK_KEY(C);
CHECK_KEY(V);
CHECK_KEY(B);
CHECK_KEY(N);
CHECK_KEY(M);
CHECK_KEY(COMMA);
CHECK_KEY(DOT);
CHECK_KEY(SLASH);
CHECK_KEY(RIGHTSHIFT);
CHECK_KEY(KPASTERISK);
CHECK_KEY(LEFTALT);
CHECK_KEY(SPACE);
CHECK_KEY(CAPSLOCK);
CHECK_KEY(F1);
CHECK_KEY(F2);
CHECK_KEY(F3);
CHECK_KEY(F4);
CHECK_KEY(F5);
CHECK_KEY(F6);
CHECK_KEY(F7);
CHECK_KEY(F8);
CHECK_KEY(F9);
CHECK_KEY(F10);
CHECK_KEY(NUMLOCK);
CHECK_KEY(SCROLLLOCK);
CHECK_KEY(KP7);
CHECK_KEY(KP8);
CHECK_KEY(KP9);
CHECK_KEY(KPMINUS);
CHECK_KEY(KP4);
CHECK_KEY(KP5);
CHECK_KEY(KP6);
CHECK_KEY(KPPLUS);
CHECK_KEY(KP1);
CHECK_KEY(KP2);
CHECK_KEY(KP3);
CHECK_KEY(KP0);
CHECK_KEY(KPDOT);
CHECK_KEY(ZENKAKUHANKAKU);
CHECK_KEY(102ND);
CHECK_KEY(F11);
CHECK_KEY(F12);
CHECK_KEY(RO);
CHECK_KEY(KATAKANA);
CHECK_KEY(HIRAGANA);
CHECK_KEY(HENKAN);
CHECK_KEY(KATAKANAHIRAGANA);
CHECK_KEY(MUHENKAN);
CHECK_KEY(KPJPCOMMA);
CHECK_KEY(KPENTER);
CHECK_KEY(RIGHTCTRL);
CHECK_KEY(KPSLASH);
CHECK_KEY(SYSRQ);
CHECK_KEY(RIGHTALT);
CHECK_KEY(HOME);
CHECK_KEY(UP);
CHECK_KEY(PAGEUP);
CHECK_KEY(LEFT);
CHECK_KEY(RIGHT);
CHECK_KEY(END);
CHECK_KEY(DOWN);
CHECK_KEY(PAGEDOWN);
CHECK_KEY(INSERT);
CHECK_KEY(DELETE);
CHECK_KEY(MUTE);
CHECK_KEY(VOLUMEDOWN);
CHECK_KEY(VOLUMEUP);
CHECK_KEY(POWER);
CHECK_KEY(KPEQUAL);
CHECK_KEY(PAUSE);
CHECK_KEY(KPCOMMA);
CHECK_KEY(HANGEUL);
CHECK_KEY(HANJA);
CHECK_KEY(YEN);
CHECK_KEY(LEFTMETA);
CHECK_KEY(RIGHTMETA);
CHECK_KEY(COMPOSE);
CHECK_KEY(STOP);
CHECK_KEY(AGAIN);
CHECK_KEY(UNDO);
CHECK_KEY(FRONT);
CHECK_KEY(COPY);
CHECK_KEY(OPEN);
CHECK_KEY(PASTE);
CHECK_KEY(FIND);
CHECK_KEY(CUT);
CHECK_KEY(HELP);
CHECK_KEY(MENU);
CHECK_KEY(CALC);
CHECK_KEY(SLEEP);
CHECK_KEY(WWW);
CHECK_KEY(SCREENLOCK);
CHECK_KEY(BACK);
CHECK_KEY(FORWARD);
CHECK_KEY(EJECTCD);
CHECK_KEY(NEXTSONG);
CHECK_KEY(PLAYPAUSE);
CHECK_KEY(PREVIOUSSONG);
CHECK_KEY(STOPCD);
CHECK_KEY(REFRESH);
CHECK_KEY(EDIT);
CHECK_KEY(SCROLLUP);
CHECK_KEY(SCROLLDOWN);
CHECK_KEY(KPLEFTPAREN);
CHECK_KEY(KPRIGHTPAREN);
CHECK_KEY(F13);
CHECK_KEY(F14);
CHECK_KEY(F15);
CHECK_KEY(F16);
CHECK_KEY(F17);
CHECK_KEY(F18);
CHECK_KEY(F19);
CHECK_KEY(F20);
CHECK_KEY(F21);
CHECK_KEY(F22);
CHECK_KEY(F23);
CHECK_KEY(F24);
CHECK_KEY(PRINT);
CHECK_KEY(MAX);
return 0;
}

14
client/tests/lgmp_input_test.c
View File

@@ -28,7 +28,7 @@
#include <lgmp/host.h>
#include <lgmp/stream.h>
#include <linux/input.h>
#include "input/keycodes.h"
#include <pthread.h>
#include <stdatomic.h>
#include <stdint.h>
@@ -359,7 +359,7 @@ static bool testClaim(TestState * state)
CHECK(postAvailable(state, 10));
CHECK(state->ops->supports(state->input,
LG_INPUT_SUPPORT_MOUSE_ABSOLUTE));
CHECK(state->ops->keyDown(state->input, KEY_A));
CHECK(state->ops->keyDown(state->input, LG_KEY_A));
KVMFRInputMessage claim;
KVMFRInputMessage keyboard;
@@ -371,7 +371,7 @@ static bool testClaim(TestState * state)
CHECK(keyboardHas(&keyboard, 4));
CHECK(postOwner(state, 10, state->clientID, claim.generation));
CHECK(state->ops->keyUp(state->input, KEY_A));
CHECK(state->ops->keyUp(state->input, LG_KEY_A));
CHECK(expectType(state, KVMFR_INPUT_MESSAGE_KEYBOARD, &keyboard));
CHECK(keyboard.generation == claim.generation);
CHECK(keyboard.sequence == 3);
@@ -389,7 +389,7 @@ static bool testBlocked(TestState * state)
CHECK(postStatus(state, 20, otherClient, 77));
CHECK(waitStatus(state, 2, true, 20));
CHECK(state->ops->keyDown(state->input, KEY_A));
CHECK(state->ops->keyDown(state->input, LG_KEY_A));
CHECK(state->ops->mousePress(state->input, 1));
CHECK(expectNoInput(state));
@@ -413,7 +413,7 @@ static bool testBlocked(TestState * state)
static bool testRestart(TestState * state)
{
CHECK(postAvailable(state, 30));
CHECK(state->ops->keyDown(state->input, KEY_A));
CHECK(state->ops->keyDown(state->input, LG_KEY_A));
CHECK(state->ops->mousePress(state->input, 1));
KVMFRInputMessage oldClaim;
@@ -504,7 +504,7 @@ static bool testPressure(TestState * state)
static bool testIdle(TestState * state)
{
CHECK(postAvailable(state, 50));
CHECK(state->ops->keyDown(state->input, KEY_A));
CHECK(state->ops->keyDown(state->input, LG_KEY_A));
KVMFRInputMessage claim;
KVMFRInputMessage message;
@@ -517,7 +517,7 @@ static bool testIdle(TestState * state)
CHECK(message.generation == claim.generation);
CHECK(message.sequence > 2);
CHECK(state->ops->keyUp(state->input, KEY_A));
CHECK(state->ops->keyUp(state->input, LG_KEY_A));
CHECK(readUntilType(state, KVMFR_INPUT_MESSAGE_KEYBOARD, 8,
&message, &skipped));
CHECK(keyboardEmpty(&message));

14
client/transports/LGMP/input.c
View File

@@ -83,9 +83,9 @@ struct LGMPInputLockKey
static const struct LGMPInputLockKey LOCK_KEYS[] =
{
{ KEY_NUMLOCK, LG_KEYBOARD_LED_NUM_LOCK },
{ KEY_CAPSLOCK, LG_KEYBOARD_LED_CAPS_LOCK },
{ KEY_SCROLLLOCK, LG_KEYBOARD_LED_SCROLL_LOCK },
{ LG_KEY_NUMLOCK, LG_KEYBOARD_LED_NUM_LOCK },
{ LG_KEY_CAPSLOCK, LG_KEYBOARD_LED_CAPS_LOCK },
{ LG_KEY_SCROLLLOCK, LG_KEYBOARD_LED_SCROLL_LOCK },
};
static const uint8_t LOCK_LED_MASK =
@@ -715,7 +715,7 @@ static void recordKeyboardToggle(LGMPInput * input, int key)
static bool queueKeyboardTap(LGMPInput * input,
const struct LGMPInputLockKey * lockKey, bool * wake)
{
const uint8_t usage = linux_to_hid[lockKey->key];
const uint8_t usage = lg_keycode_to_hid[lockKey->key];
if (!usage || input->keyState[usage] || !claim(input, wake))
return false;
@@ -858,7 +858,7 @@ static bool restoreInputState(LGMPInput * input, bool * wake)
if (keyboardHeld)
for (size_t i = 0; i < sizeof(LOCK_KEYS) / sizeof(*LOCK_KEYS); ++i)
{
const uint8_t usage = linux_to_hid[LOCK_KEYS[i].key];
const uint8_t usage = lg_keycode_to_hid[LOCK_KEYS[i].key];
if (usage && input->keyState[usage])
recordKeyboardToggle(input, LOCK_KEYS[i].key);
}
@@ -1723,10 +1723,10 @@ static bool buildKeyboardPayload(const LGMPInput * input,
static bool updateKey(void * opaque, int key, bool pressed)
{
if (key < 0 || key >= KEY_MAX)
if (key < 0 || key >= LG_KEY_MAX)
return false;
const uint8_t usage = linux_to_hid[key];
const uint8_t usage = lg_keycode_to_hid[key];
if (!usage)
return true;

4
client/transports/SPICE/input.c
View File

@@ -81,7 +81,7 @@ static void spiceSetStatusListener(void * opaque,
static bool spiceKeyDown(void * opaque, int key)
{
SpiceInput * input = opaque;
const uint32_t ps2 = linux_to_ps2[key];
const uint32_t ps2 = lg_keycode_to_ps2[key];
LG_LOCK(input->stateLock);
const bool result = input->available &&
@@ -93,7 +93,7 @@ static bool spiceKeyDown(void * opaque, int key)
static bool spiceKeyUp(void * opaque, int key)
{
SpiceInput * input = opaque;
const uint32_t ps2 = linux_to_ps2[key];
const uint32_t ps2 = lg_keycode_to_ps2[key];
LG_LOCK(input->stateLock);
const bool result = !ps2 || purespice_keyUp(ps2);