diff --git a/app/src/hid_keyboard.c b/app/src/hid_keyboard.c index cf8eab61..be5f8a19 100644 --- a/app/src/hid_keyboard.c +++ b/app/src/hid_keyboard.c @@ -1,8 +1,8 @@ #include "hid_keyboard.h" #include -#include +#include "input_events.h" #include "util/log.h" /** Downcast key processor to hid_keyboard */ @@ -201,30 +201,30 @@ static const unsigned char keyboard_report_desc[] = { */ static unsigned char -sdl_keymod_to_hid_modifiers(SDL_Keymod mod) { +sdl_keymod_to_hid_modifiers(uint16_t mod) { unsigned char modifiers = HID_MODIFIER_NONE; - if (mod & KMOD_LCTRL) { + if (mod & SC_MOD_LCTRL) { modifiers |= HID_MODIFIER_LEFT_CONTROL; } - if (mod & KMOD_LSHIFT) { + if (mod & SC_MOD_LSHIFT) { modifiers |= HID_MODIFIER_LEFT_SHIFT; } - if (mod & KMOD_LALT) { + if (mod & SC_MOD_LALT) { modifiers |= HID_MODIFIER_LEFT_ALT; } - if (mod & KMOD_LGUI) { + if (mod & SC_MOD_LGUI) { modifiers |= HID_MODIFIER_LEFT_GUI; } - if (mod & KMOD_RCTRL) { + if (mod & SC_MOD_RCTRL) { modifiers |= HID_MODIFIER_RIGHT_CONTROL; } - if (mod & KMOD_RSHIFT) { + if (mod & SC_MOD_RSHIFT) { modifiers |= HID_MODIFIER_RIGHT_SHIFT; } - if (mod & KMOD_RALT) { + if (mod & SC_MOD_RALT) { modifiers |= HID_MODIFIER_RIGHT_ALT; } - if (mod & KMOD_RGUI) { + if (mod & SC_MOD_RGUI) { modifiers |= HID_MODIFIER_RIGHT_GUI; } return modifiers; @@ -248,15 +248,15 @@ sc_hid_keyboard_event_init(struct sc_hid_event *hid_event) { } static inline bool -scancode_is_modifier(SDL_Scancode scancode) { - return scancode >= SDL_SCANCODE_LCTRL && scancode <= SDL_SCANCODE_RGUI; +scancode_is_modifier(enum sc_scancode scancode) { + return scancode >= SC_SCANCODE_LCTRL && scancode <= SC_SCANCODE_RGUI; } static bool convert_hid_keyboard_event(struct sc_hid_keyboard *kb, struct sc_hid_event *hid_event, - const SDL_KeyboardEvent *event) { - SDL_Scancode scancode = event->keysym.scancode; + const struct sc_key_event *event) { + enum sc_scancode scancode = event->scancode; assert(scancode >= 0); // SDL also generates events when only modifiers are pressed, we cannot @@ -272,11 +272,11 @@ convert_hid_keyboard_event(struct sc_hid_keyboard *kb, return false; } - unsigned char modifiers = sdl_keymod_to_hid_modifiers(event->keysym.mod); + unsigned char modifiers = sdl_keymod_to_hid_modifiers(event->mods_state); if (scancode < SC_HID_KEYBOARD_KEYS) { // Pressed is true and released is false - kb->keys[scancode] = (event->type == SDL_KEYDOWN); + kb->keys[scancode] = (event->action == SC_ACTION_DOWN); LOGV("keys[%02x] = %s", scancode, kb->keys[scancode] ? "true" : "false"); } @@ -306,17 +306,17 @@ convert_hid_keyboard_event(struct sc_hid_keyboard *kb, end: LOGV("hid keyboard: key %-4s scancode=%02x (%u) mod=%02x", - event->type == SDL_KEYDOWN ? "down" : "up", event->keysym.scancode, - event->keysym.scancode, modifiers); + event->action == SC_ACTION_DOWN ? "down" : "up", event->scancode, + event->scancode, modifiers); return true; } static bool -push_mod_lock_state(struct sc_hid_keyboard *kb, uint16_t sdl_mod) { - bool capslock = sdl_mod & KMOD_CAPS; - bool numlock = sdl_mod & KMOD_NUM; +push_mod_lock_state(struct sc_hid_keyboard *kb, uint16_t mods_state) { + bool capslock = mods_state & SC_MOD_CAPS; + bool numlock = mods_state & SC_MOD_NUM; if (!capslock && !numlock) { // Nothing to do return true; @@ -328,8 +328,6 @@ push_mod_lock_state(struct sc_hid_keyboard *kb, uint16_t sdl_mod) { return false; } -#define SC_SCANCODE_CAPSLOCK SDL_SCANCODE_CAPSLOCK -#define SC_SCANCODE_NUMLOCK SDL_SCANCODE_NUMLOCKCLEAR unsigned i = 0; if (capslock) { hid_event.buffer[HID_KEYBOARD_INDEX_KEYS + i] = SC_SCANCODE_CAPSLOCK; @@ -353,7 +351,7 @@ push_mod_lock_state(struct sc_hid_keyboard *kb, uint16_t sdl_mod) { static void sc_key_processor_process_key(struct sc_key_processor *kp, - const SDL_KeyboardEvent *event, + const struct sc_key_event *event, uint64_t ack_to_wait) { if (event->repeat) { // In USB HID protocol, key repeat is handled by the host (Android), so @@ -369,7 +367,7 @@ sc_key_processor_process_key(struct sc_key_processor *kp, if (!kb->mod_lock_synchronized) { // Inject CAPSLOCK and/or NUMLOCK if necessary to synchronize // keyboard state - if (push_mod_lock_state(kb, event->keysym.mod)) { + if (push_mod_lock_state(kb, event->mods_state)) { kb->mod_lock_synchronized = true; } } @@ -391,7 +389,7 @@ sc_key_processor_process_key(struct sc_key_processor *kp, static void sc_key_processor_process_text(struct sc_key_processor *kp, - const SDL_TextInputEvent *event) { + const struct sc_text_event *event) { (void) kp; (void) event; diff --git a/app/src/input_manager.c b/app/src/input_manager.c index 0ed364b1..03d19b0e 100644 --- a/app/src/input_manager.c +++ b/app/src/input_manager.c @@ -6,6 +6,30 @@ #include "input_events.h" #include "util/log.h" +static inline uint16_t +sc_mods_state_from_sdl(uint16_t mods_state) { + return mods_state; +} + +static inline enum sc_keycode +sc_keycode_from_sdl(SDL_Keycode keycode) { + return (enum sc_keycode) keycode; +} + +static inline enum sc_scancode +sc_scancode_from_sdl(SDL_Scancode scancode) { + return (enum sc_scancode) scancode; +} + +static inline enum sc_action +sc_action_from_sdl_keyboard_type(uint32_t type) { + assert(type == SDL_KEYDOWN || type == SDL_KEYUP); + if (type == SDL_KEYDOWN) { + return SC_ACTION_DOWN; + } + return SC_ACTION_UP; +} + #define SC_SDL_SHORTCUT_MODS_MASK (KMOD_CTRL | KMOD_ALT | KMOD_GUI) static inline uint16_t @@ -317,7 +341,11 @@ input_manager_process_text_input(struct input_manager *im, return; } - im->kp->ops->process_text(im->kp, event); + struct sc_text_event evt = { + .text = event->text, + }; + + im->kp->ops->process_text(im->kp, &evt); } static bool @@ -536,7 +564,15 @@ input_manager_process_key(struct input_manager *im, } } - im->kp->ops->process_key(im->kp, event, ack_to_wait); + struct sc_key_event evt = { + .action = sc_action_from_sdl_keyboard_type(event->type), + .keycode = sc_keycode_from_sdl(event->keysym.sym), + .scancode = sc_scancode_from_sdl(event->keysym.scancode), + .repeat = event->repeat, + .mods_state = sc_mods_state_from_sdl(event->keysym.mod), + }; + + im->kp->ops->process_key(im->kp, &evt, ack_to_wait); } static void diff --git a/app/src/keyboard_inject.c b/app/src/keyboard_inject.c index 5143eafc..968a3c4f 100644 --- a/app/src/keyboard_inject.c +++ b/app/src/keyboard_inject.c @@ -1,11 +1,11 @@ #include "keyboard_inject.h" #include -#include #include "android/input.h" #include "control_msg.h" #include "controller.h" +#include "input_events.h" #include "util/intmap.h" #include "util/log.h" @@ -13,10 +13,10 @@ #define DOWNCAST(KP) container_of(KP, struct sc_keyboard_inject, key_processor) static bool -convert_keycode_action(SDL_EventType from, enum android_keyevent_action *to) { +convert_keycode_action(enum sc_action from, enum android_keyevent_action *to) { static const struct sc_intmap_entry actions[] = { - {SDL_KEYDOWN, AKEY_EVENT_ACTION_DOWN}, - {SDL_KEYUP, AKEY_EVENT_ACTION_UP}, + {SC_ACTION_DOWN, AKEY_EVENT_ACTION_DOWN}, + {SC_ACTION_UP, AKEY_EVENT_ACTION_UP}, }; const struct sc_intmap_entry *entry = SC_INTMAP_FIND_ENTRY(actions, from); @@ -29,125 +29,125 @@ convert_keycode_action(SDL_EventType from, enum android_keyevent_action *to) { } static bool -convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod, +convert_keycode(enum sc_keycode from, enum android_keycode *to, uint16_t mod, enum sc_key_inject_mode key_inject_mode) { // Navigation keys and ENTER. // Used in all modes. static const struct sc_intmap_entry special_keys[] = { - {SDLK_RETURN, AKEYCODE_ENTER}, - {SDLK_KP_ENTER, AKEYCODE_NUMPAD_ENTER}, - {SDLK_ESCAPE, AKEYCODE_ESCAPE}, - {SDLK_BACKSPACE, AKEYCODE_DEL}, - {SDLK_TAB, AKEYCODE_TAB}, - {SDLK_PAGEUP, AKEYCODE_PAGE_UP}, - {SDLK_DELETE, AKEYCODE_FORWARD_DEL}, - {SDLK_HOME, AKEYCODE_MOVE_HOME}, - {SDLK_END, AKEYCODE_MOVE_END}, - {SDLK_PAGEDOWN, AKEYCODE_PAGE_DOWN}, - {SDLK_RIGHT, AKEYCODE_DPAD_RIGHT}, - {SDLK_LEFT, AKEYCODE_DPAD_LEFT}, - {SDLK_DOWN, AKEYCODE_DPAD_DOWN}, - {SDLK_UP, AKEYCODE_DPAD_UP}, - {SDLK_LCTRL, AKEYCODE_CTRL_LEFT}, - {SDLK_RCTRL, AKEYCODE_CTRL_RIGHT}, - {SDLK_LSHIFT, AKEYCODE_SHIFT_LEFT}, - {SDLK_RSHIFT, AKEYCODE_SHIFT_RIGHT}, + {SC_KEYCODE_RETURN, AKEYCODE_ENTER}, + {SC_KEYCODE_KP_ENTER, AKEYCODE_NUMPAD_ENTER}, + {SC_KEYCODE_ESCAPE, AKEYCODE_ESCAPE}, + {SC_KEYCODE_BACKSPACE, AKEYCODE_DEL}, + {SC_KEYCODE_TAB, AKEYCODE_TAB}, + {SC_KEYCODE_PAGEUP, AKEYCODE_PAGE_UP}, + {SC_KEYCODE_DELETE, AKEYCODE_FORWARD_DEL}, + {SC_KEYCODE_HOME, AKEYCODE_MOVE_HOME}, + {SC_KEYCODE_END, AKEYCODE_MOVE_END}, + {SC_KEYCODE_PAGEDOWN, AKEYCODE_PAGE_DOWN}, + {SC_KEYCODE_RIGHT, AKEYCODE_DPAD_RIGHT}, + {SC_KEYCODE_LEFT, AKEYCODE_DPAD_LEFT}, + {SC_KEYCODE_DOWN, AKEYCODE_DPAD_DOWN}, + {SC_KEYCODE_UP, AKEYCODE_DPAD_UP}, + {SC_KEYCODE_LCTRL, AKEYCODE_CTRL_LEFT}, + {SC_KEYCODE_RCTRL, AKEYCODE_CTRL_RIGHT}, + {SC_KEYCODE_LSHIFT, AKEYCODE_SHIFT_LEFT}, + {SC_KEYCODE_RSHIFT, AKEYCODE_SHIFT_RIGHT}, }; // Numpad navigation keys. // Used in all modes, when NumLock and Shift are disabled. static const struct sc_intmap_entry kp_nav_keys[] = { - {SDLK_KP_0, AKEYCODE_INSERT}, - {SDLK_KP_1, AKEYCODE_MOVE_END}, - {SDLK_KP_2, AKEYCODE_DPAD_DOWN}, - {SDLK_KP_3, AKEYCODE_PAGE_DOWN}, - {SDLK_KP_4, AKEYCODE_DPAD_LEFT}, - {SDLK_KP_6, AKEYCODE_DPAD_RIGHT}, - {SDLK_KP_7, AKEYCODE_MOVE_HOME}, - {SDLK_KP_8, AKEYCODE_DPAD_UP}, - {SDLK_KP_9, AKEYCODE_PAGE_UP}, - {SDLK_KP_PERIOD, AKEYCODE_FORWARD_DEL}, + {SC_KEYCODE_KP_0, AKEYCODE_INSERT}, + {SC_KEYCODE_KP_1, AKEYCODE_MOVE_END}, + {SC_KEYCODE_KP_2, AKEYCODE_DPAD_DOWN}, + {SC_KEYCODE_KP_3, AKEYCODE_PAGE_DOWN}, + {SC_KEYCODE_KP_4, AKEYCODE_DPAD_LEFT}, + {SC_KEYCODE_KP_6, AKEYCODE_DPAD_RIGHT}, + {SC_KEYCODE_KP_7, AKEYCODE_MOVE_HOME}, + {SC_KEYCODE_KP_8, AKEYCODE_DPAD_UP}, + {SC_KEYCODE_KP_9, AKEYCODE_PAGE_UP}, + {SC_KEYCODE_KP_PERIOD, AKEYCODE_FORWARD_DEL}, }; // Letters and space. // Used in non-text mode. static const struct sc_intmap_entry alphaspace_keys[] = { - {SDLK_a, AKEYCODE_A}, - {SDLK_b, AKEYCODE_B}, - {SDLK_c, AKEYCODE_C}, - {SDLK_d, AKEYCODE_D}, - {SDLK_e, AKEYCODE_E}, - {SDLK_f, AKEYCODE_F}, - {SDLK_g, AKEYCODE_G}, - {SDLK_h, AKEYCODE_H}, - {SDLK_i, AKEYCODE_I}, - {SDLK_j, AKEYCODE_J}, - {SDLK_k, AKEYCODE_K}, - {SDLK_l, AKEYCODE_L}, - {SDLK_m, AKEYCODE_M}, - {SDLK_n, AKEYCODE_N}, - {SDLK_o, AKEYCODE_O}, - {SDLK_p, AKEYCODE_P}, - {SDLK_q, AKEYCODE_Q}, - {SDLK_r, AKEYCODE_R}, - {SDLK_s, AKEYCODE_S}, - {SDLK_t, AKEYCODE_T}, - {SDLK_u, AKEYCODE_U}, - {SDLK_v, AKEYCODE_V}, - {SDLK_w, AKEYCODE_W}, - {SDLK_x, AKEYCODE_X}, - {SDLK_y, AKEYCODE_Y}, - {SDLK_z, AKEYCODE_Z}, - {SDLK_SPACE, AKEYCODE_SPACE}, + {SC_KEYCODE_a, AKEYCODE_A}, + {SC_KEYCODE_b, AKEYCODE_B}, + {SC_KEYCODE_c, AKEYCODE_C}, + {SC_KEYCODE_d, AKEYCODE_D}, + {SC_KEYCODE_e, AKEYCODE_E}, + {SC_KEYCODE_f, AKEYCODE_F}, + {SC_KEYCODE_g, AKEYCODE_G}, + {SC_KEYCODE_h, AKEYCODE_H}, + {SC_KEYCODE_i, AKEYCODE_I}, + {SC_KEYCODE_j, AKEYCODE_J}, + {SC_KEYCODE_k, AKEYCODE_K}, + {SC_KEYCODE_l, AKEYCODE_L}, + {SC_KEYCODE_m, AKEYCODE_M}, + {SC_KEYCODE_n, AKEYCODE_N}, + {SC_KEYCODE_o, AKEYCODE_O}, + {SC_KEYCODE_p, AKEYCODE_P}, + {SC_KEYCODE_q, AKEYCODE_Q}, + {SC_KEYCODE_r, AKEYCODE_R}, + {SC_KEYCODE_s, AKEYCODE_S}, + {SC_KEYCODE_t, AKEYCODE_T}, + {SC_KEYCODE_u, AKEYCODE_U}, + {SC_KEYCODE_v, AKEYCODE_V}, + {SC_KEYCODE_w, AKEYCODE_W}, + {SC_KEYCODE_x, AKEYCODE_X}, + {SC_KEYCODE_y, AKEYCODE_Y}, + {SC_KEYCODE_z, AKEYCODE_Z}, + {SC_KEYCODE_SPACE, AKEYCODE_SPACE}, }; // Numbers and punctuation keys. // Used in raw mode only. static const struct sc_intmap_entry numbers_punct_keys[] = { - {SDLK_HASH, AKEYCODE_POUND}, - {SDLK_PERCENT, AKEYCODE_PERIOD}, - {SDLK_QUOTE, AKEYCODE_APOSTROPHE}, - {SDLK_ASTERISK, AKEYCODE_STAR}, - {SDLK_PLUS, AKEYCODE_PLUS}, - {SDLK_COMMA, AKEYCODE_COMMA}, - {SDLK_MINUS, AKEYCODE_MINUS}, - {SDLK_PERIOD, AKEYCODE_PERIOD}, - {SDLK_SLASH, AKEYCODE_SLASH}, - {SDLK_0, AKEYCODE_0}, - {SDLK_1, AKEYCODE_1}, - {SDLK_2, AKEYCODE_2}, - {SDLK_3, AKEYCODE_3}, - {SDLK_4, AKEYCODE_4}, - {SDLK_5, AKEYCODE_5}, - {SDLK_6, AKEYCODE_6}, - {SDLK_7, AKEYCODE_7}, - {SDLK_8, AKEYCODE_8}, - {SDLK_9, AKEYCODE_9}, - {SDLK_SEMICOLON, AKEYCODE_SEMICOLON}, - {SDLK_EQUALS, AKEYCODE_EQUALS}, - {SDLK_AT, AKEYCODE_AT}, - {SDLK_LEFTBRACKET, AKEYCODE_LEFT_BRACKET}, - {SDLK_BACKSLASH, AKEYCODE_BACKSLASH}, - {SDLK_RIGHTBRACKET, AKEYCODE_RIGHT_BRACKET}, - {SDLK_BACKQUOTE, AKEYCODE_GRAVE}, - {SDLK_KP_1, AKEYCODE_NUMPAD_1}, - {SDLK_KP_2, AKEYCODE_NUMPAD_2}, - {SDLK_KP_3, AKEYCODE_NUMPAD_3}, - {SDLK_KP_4, AKEYCODE_NUMPAD_4}, - {SDLK_KP_5, AKEYCODE_NUMPAD_5}, - {SDLK_KP_6, AKEYCODE_NUMPAD_6}, - {SDLK_KP_7, AKEYCODE_NUMPAD_7}, - {SDLK_KP_8, AKEYCODE_NUMPAD_8}, - {SDLK_KP_9, AKEYCODE_NUMPAD_9}, - {SDLK_KP_0, AKEYCODE_NUMPAD_0}, - {SDLK_KP_DIVIDE, AKEYCODE_NUMPAD_DIVIDE}, - {SDLK_KP_MULTIPLY, AKEYCODE_NUMPAD_MULTIPLY}, - {SDLK_KP_MINUS, AKEYCODE_NUMPAD_SUBTRACT}, - {SDLK_KP_PLUS, AKEYCODE_NUMPAD_ADD}, - {SDLK_KP_PERIOD, AKEYCODE_NUMPAD_DOT}, - {SDLK_KP_EQUALS, AKEYCODE_NUMPAD_EQUALS}, - {SDLK_KP_LEFTPAREN, AKEYCODE_NUMPAD_LEFT_PAREN}, - {SDLK_KP_RIGHTPAREN, AKEYCODE_NUMPAD_RIGHT_PAREN}, + {SC_KEYCODE_HASH, AKEYCODE_POUND}, + {SC_KEYCODE_PERCENT, AKEYCODE_PERIOD}, + {SC_KEYCODE_QUOTE, AKEYCODE_APOSTROPHE}, + {SC_KEYCODE_ASTERISK, AKEYCODE_STAR}, + {SC_KEYCODE_PLUS, AKEYCODE_PLUS}, + {SC_KEYCODE_COMMA, AKEYCODE_COMMA}, + {SC_KEYCODE_MINUS, AKEYCODE_MINUS}, + {SC_KEYCODE_PERIOD, AKEYCODE_PERIOD}, + {SC_KEYCODE_SLASH, AKEYCODE_SLASH}, + {SC_KEYCODE_0, AKEYCODE_0}, + {SC_KEYCODE_1, AKEYCODE_1}, + {SC_KEYCODE_2, AKEYCODE_2}, + {SC_KEYCODE_3, AKEYCODE_3}, + {SC_KEYCODE_4, AKEYCODE_4}, + {SC_KEYCODE_5, AKEYCODE_5}, + {SC_KEYCODE_6, AKEYCODE_6}, + {SC_KEYCODE_7, AKEYCODE_7}, + {SC_KEYCODE_8, AKEYCODE_8}, + {SC_KEYCODE_9, AKEYCODE_9}, + {SC_KEYCODE_SEMICOLON, AKEYCODE_SEMICOLON}, + {SC_KEYCODE_EQUALS, AKEYCODE_EQUALS}, + {SC_KEYCODE_AT, AKEYCODE_AT}, + {SC_KEYCODE_LEFTBRACKET, AKEYCODE_LEFT_BRACKET}, + {SC_KEYCODE_BACKSLASH, AKEYCODE_BACKSLASH}, + {SC_KEYCODE_RIGHTBRACKET, AKEYCODE_RIGHT_BRACKET}, + {SC_KEYCODE_BACKQUOTE, AKEYCODE_GRAVE}, + {SC_KEYCODE_KP_1, AKEYCODE_NUMPAD_1}, + {SC_KEYCODE_KP_2, AKEYCODE_NUMPAD_2}, + {SC_KEYCODE_KP_3, AKEYCODE_NUMPAD_3}, + {SC_KEYCODE_KP_4, AKEYCODE_NUMPAD_4}, + {SC_KEYCODE_KP_5, AKEYCODE_NUMPAD_5}, + {SC_KEYCODE_KP_6, AKEYCODE_NUMPAD_6}, + {SC_KEYCODE_KP_7, AKEYCODE_NUMPAD_7}, + {SC_KEYCODE_KP_8, AKEYCODE_NUMPAD_8}, + {SC_KEYCODE_KP_9, AKEYCODE_NUMPAD_9}, + {SC_KEYCODE_KP_0, AKEYCODE_NUMPAD_0}, + {SC_KEYCODE_KP_DIVIDE, AKEYCODE_NUMPAD_DIVIDE}, + {SC_KEYCODE_KP_MULTIPLY, AKEYCODE_NUMPAD_MULTIPLY}, + {SC_KEYCODE_KP_MINUS, AKEYCODE_NUMPAD_SUBTRACT}, + {SC_KEYCODE_KP_PLUS, AKEYCODE_NUMPAD_ADD}, + {SC_KEYCODE_KP_PERIOD, AKEYCODE_NUMPAD_DOT}, + {SC_KEYCODE_KP_EQUALS, AKEYCODE_NUMPAD_EQUALS}, + {SC_KEYCODE_KP_LEFTPAREN, AKEYCODE_NUMPAD_LEFT_PAREN}, + {SC_KEYCODE_KP_RIGHTPAREN, AKEYCODE_NUMPAD_RIGHT_PAREN}, }; const struct sc_intmap_entry *entry = @@ -157,7 +157,7 @@ convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod, return true; } - if (!(mod & (KMOD_NUM | KMOD_SHIFT))) { + if (!(mod & (SC_MOD_NUM | SC_MOD_LSHIFT | SC_MOD_RSHIFT))) { // Handle Numpad events when Num Lock is disabled // If SHIFT is pressed, a text event will be sent instead entry = SC_INTMAP_FIND_ENTRY(kp_nav_keys, from); @@ -167,12 +167,13 @@ convert_keycode(SDL_Keycode from, enum android_keycode *to, uint16_t mod, } } - if (key_inject_mode == SC_KEY_INJECT_MODE_TEXT && !(mod & KMOD_CTRL)) { + if (key_inject_mode == SC_KEY_INJECT_MODE_TEXT && + !(mod & (SC_MOD_LCTRL | SC_MOD_RCTRL))) { // do not forward alpha and space key events (unless Ctrl is pressed) return false; } - if (mod & (KMOD_LALT | KMOD_RALT | KMOD_LGUI | KMOD_RGUI)) { + if (mod & (SC_MOD_LALT | SC_MOD_RALT | SC_MOD_LGUI | SC_MOD_RGUI)) { return false; } @@ -214,70 +215,66 @@ autocomplete_metastate(enum android_metastate metastate) { } static enum android_metastate -convert_meta_state(SDL_Keymod mod) { +convert_meta_state(uint16_t mod) { enum android_metastate metastate = 0; - if (mod & KMOD_LSHIFT) { + if (mod & SC_MOD_LSHIFT) { metastate |= AMETA_SHIFT_LEFT_ON; } - if (mod & KMOD_RSHIFT) { + if (mod & SC_MOD_RSHIFT) { metastate |= AMETA_SHIFT_RIGHT_ON; } - if (mod & KMOD_LCTRL) { + if (mod & SC_MOD_LCTRL) { metastate |= AMETA_CTRL_LEFT_ON; } - if (mod & KMOD_RCTRL) { + if (mod & SC_MOD_RCTRL) { metastate |= AMETA_CTRL_RIGHT_ON; } - if (mod & KMOD_LALT) { + if (mod & SC_MOD_LALT) { metastate |= AMETA_ALT_LEFT_ON; } - if (mod & KMOD_RALT) { + if (mod & SC_MOD_RALT) { metastate |= AMETA_ALT_RIGHT_ON; } - if (mod & KMOD_LGUI) { // Windows key + if (mod & SC_MOD_LGUI) { // Windows key metastate |= AMETA_META_LEFT_ON; } - if (mod & KMOD_RGUI) { // Windows key + if (mod & SC_MOD_RGUI) { // Windows key metastate |= AMETA_META_RIGHT_ON; } - if (mod & KMOD_NUM) { + if (mod & SC_MOD_NUM) { metastate |= AMETA_NUM_LOCK_ON; } - if (mod & KMOD_CAPS) { + if (mod & SC_MOD_CAPS) { metastate |= AMETA_CAPS_LOCK_ON; } - if (mod & KMOD_MODE) { // Alt Gr - // no mapping? - } // fill the dependent fields return autocomplete_metastate(metastate); } static bool -convert_input_key(const SDL_KeyboardEvent *from, struct control_msg *to, +convert_input_key(const struct sc_key_event *event, struct control_msg *msg, enum sc_key_inject_mode key_inject_mode, uint32_t repeat) { - to->type = CONTROL_MSG_TYPE_INJECT_KEYCODE; + msg->type = CONTROL_MSG_TYPE_INJECT_KEYCODE; - if (!convert_keycode_action(from->type, &to->inject_keycode.action)) { + if (!convert_keycode_action(event->action, &msg->inject_keycode.action)) { return false; } - uint16_t mod = from->keysym.mod; - if (!convert_keycode(from->keysym.sym, &to->inject_keycode.keycode, mod, - key_inject_mode)) { + if (!convert_keycode(event->keycode, &msg->inject_keycode.keycode, + event->mods_state, key_inject_mode)) { return false; } - to->inject_keycode.repeat = repeat; - to->inject_keycode.metastate = convert_meta_state(mod); + msg->inject_keycode.repeat = repeat; + msg->inject_keycode.metastate = convert_meta_state(event->mods_state); return true; } static void sc_key_processor_process_key(struct sc_key_processor *kp, - const SDL_KeyboardEvent *event, + const struct sc_key_event *event, uint64_t ack_to_wait) { // The device clipboard synchronization and the key event messages are // serialized, there is nothing special to do to ensure that the clipboard @@ -305,7 +302,7 @@ sc_key_processor_process_key(struct sc_key_processor *kp, static void sc_key_processor_process_text(struct sc_key_processor *kp, - const SDL_TextInputEvent *event) { + const struct sc_text_event *event) { struct sc_keyboard_inject *ki = DOWNCAST(kp); if (ki->key_inject_mode == SC_KEY_INJECT_MODE_RAW) { diff --git a/app/src/trait/key_processor.h b/app/src/trait/key_processor.h index f4afe27b..045e5e7b 100644 --- a/app/src/trait/key_processor.h +++ b/app/src/trait/key_processor.h @@ -6,7 +6,7 @@ #include #include -#include +#include "input_events.h" /** * Key processor trait. @@ -37,12 +37,12 @@ struct sc_key_processor_ops { * Ctrl+v on the device. */ void - (*process_key)(struct sc_key_processor *kp, const SDL_KeyboardEvent *event, - uint64_t ack_to_wait); + (*process_key)(struct sc_key_processor *kp, + const struct sc_key_event *event, uint64_t ack_to_wait); void (*process_text)(struct sc_key_processor *kp, - const SDL_TextInputEvent *event); + const struct sc_text_event *event); }; #endif