| // Copyright 2016 Samsung Electronics. All Rights Reserved. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| #ifndef STARBOARD_SHARED_WAYLAND_DEV_INPUT_H_ |
| #define STARBOARD_SHARED_WAYLAND_DEV_INPUT_H_ |
| |
| #include <EGL/egl.h> |
| #include <linux/input.h> |
| |
| #include "starboard/input.h" |
| #include "starboard/key.h" |
| #include "starboard/log.h" |
| #include "starboard/shared/wayland/application_wayland.h" |
| #include "starboard/shared/wayland/window_internal.h" |
| |
| namespace starboard { |
| namespace shared { |
| namespace wayland { |
| |
| #define KEY_INFO_BUTTON 0xbc |
| |
| // Converts an input_event code into an SbKey. |
| static SbKey KeyCodeToSbKey(uint16_t code) { |
| switch (code) { |
| case KEY_BACKSPACE: |
| return kSbKeyBack; |
| case KEY_DELETE: |
| return kSbKeyDelete; |
| case KEY_TAB: |
| return kSbKeyTab; |
| case KEY_LINEFEED: |
| case KEY_ENTER: |
| case KEY_KPENTER: |
| return kSbKeyReturn; |
| case KEY_CLEAR: |
| return kSbKeyClear; |
| case KEY_SPACE: |
| return kSbKeySpace; |
| case KEY_HOME: |
| return kSbKeyHome; |
| case KEY_END: |
| return kSbKeyEnd; |
| case KEY_PAGEUP: |
| return kSbKeyPrior; |
| case KEY_PAGEDOWN: |
| return kSbKeyNext; |
| case KEY_LEFT: |
| return kSbKeyLeft; |
| case KEY_RIGHT: |
| return kSbKeyRight; |
| case KEY_DOWN: |
| return kSbKeyDown; |
| case KEY_UP: |
| return kSbKeyUp; |
| case KEY_ESC: |
| return kSbKeyEscape; |
| case KEY_KATAKANA: |
| case KEY_HIRAGANA: |
| case KEY_KATAKANAHIRAGANA: |
| return kSbKeyKana; |
| case KEY_HANGEUL: |
| return kSbKeyHangul; |
| case KEY_HANJA: |
| return kSbKeyHanja; |
| case KEY_HENKAN: |
| return kSbKeyConvert; |
| case KEY_MUHENKAN: |
| return kSbKeyNonconvert; |
| case KEY_ZENKAKUHANKAKU: |
| return kSbKeyDbeDbcschar; |
| case KEY_A: |
| return kSbKeyA; |
| case KEY_B: |
| return kSbKeyB; |
| case KEY_C: |
| return kSbKeyC; |
| case KEY_D: |
| return kSbKeyD; |
| case KEY_E: |
| return kSbKeyE; |
| case KEY_F: |
| return kSbKeyF; |
| case KEY_G: |
| return kSbKeyG; |
| case KEY_H: |
| return kSbKeyH; |
| case KEY_I: |
| return kSbKeyI; |
| case KEY_J: |
| return kSbKeyJ; |
| case KEY_K: |
| return kSbKeyK; |
| case KEY_L: |
| return kSbKeyL; |
| case KEY_M: |
| return kSbKeyM; |
| case KEY_N: |
| return kSbKeyN; |
| case KEY_O: |
| return kSbKeyO; |
| case KEY_P: |
| return kSbKeyP; |
| case KEY_Q: |
| return kSbKeyQ; |
| case KEY_R: |
| return kSbKeyR; |
| case KEY_S: |
| return kSbKeyS; |
| case KEY_T: |
| return kSbKeyT; |
| case KEY_U: |
| return kSbKeyU; |
| case KEY_V: |
| return kSbKeyV; |
| case KEY_W: |
| return kSbKeyW; |
| case KEY_X: |
| return kSbKeyX; |
| case KEY_Y: |
| return kSbKeyY; |
| case KEY_Z: |
| return kSbKeyZ; |
| |
| case KEY_0: |
| return kSbKey0; |
| case KEY_1: |
| return kSbKey1; |
| case KEY_2: |
| return kSbKey2; |
| case KEY_3: |
| return kSbKey3; |
| case KEY_4: |
| return kSbKey4; |
| case KEY_5: |
| return kSbKey5; |
| case KEY_6: |
| return kSbKey6; |
| case KEY_7: |
| return kSbKey7; |
| case KEY_8: |
| return kSbKey8; |
| case KEY_9: |
| return kSbKey9; |
| |
| case KEY_NUMERIC_0: |
| case KEY_NUMERIC_1: |
| case KEY_NUMERIC_2: |
| case KEY_NUMERIC_3: |
| case KEY_NUMERIC_4: |
| case KEY_NUMERIC_5: |
| case KEY_NUMERIC_6: |
| case KEY_NUMERIC_7: |
| case KEY_NUMERIC_8: |
| case KEY_NUMERIC_9: |
| return static_cast<SbKey>(kSbKey0 + (code - KEY_NUMERIC_0)); |
| |
| case KEY_KP0: |
| return kSbKeyNumpad0; |
| case KEY_KP1: |
| return kSbKeyNumpad1; |
| case KEY_KP2: |
| return kSbKeyNumpad2; |
| case KEY_KP3: |
| return kSbKeyNumpad3; |
| case KEY_KP4: |
| return kSbKeyNumpad4; |
| case KEY_KP5: |
| return kSbKeyNumpad5; |
| case KEY_KP6: |
| return kSbKeyNumpad6; |
| case KEY_KP7: |
| return kSbKeyNumpad7; |
| case KEY_KP8: |
| return kSbKeyNumpad8; |
| case KEY_KP9: |
| return kSbKeyNumpad9; |
| |
| case KEY_KPASTERISK: |
| return kSbKeyMultiply; |
| case KEY_KPDOT: |
| return kSbKeyDecimal; |
| case KEY_KPSLASH: |
| return kSbKeyDivide; |
| case KEY_KPPLUS: |
| case KEY_EQUAL: |
| return kSbKeyOemPlus; |
| case KEY_COMMA: |
| return kSbKeyOemComma; |
| case KEY_KPMINUS: |
| case KEY_MINUS: |
| return kSbKeyOemMinus; |
| case KEY_DOT: |
| return kSbKeyOemPeriod; |
| case KEY_SEMICOLON: |
| return kSbKeyOem1; |
| case KEY_SLASH: |
| return kSbKeyOem2; |
| case KEY_GRAVE: |
| return kSbKeyOem3; |
| case KEY_LEFTBRACE: |
| return kSbKeyOem4; |
| case KEY_BACKSLASH: |
| return kSbKeyOem5; |
| case KEY_RIGHTBRACE: |
| return kSbKeyOem6; |
| case KEY_APOSTROPHE: |
| return kSbKeyOem7; |
| case KEY_LEFTSHIFT: |
| case KEY_RIGHTSHIFT: |
| return kSbKeyShift; |
| case KEY_LEFTCTRL: |
| case KEY_RIGHTCTRL: |
| return kSbKeyControl; |
| case KEY_LEFTMETA: |
| case KEY_RIGHTMETA: |
| case KEY_LEFTALT: |
| case KEY_RIGHTALT: |
| return kSbKeyMenu; |
| case KEY_PAUSE: |
| return kSbKeyPause; |
| case KEY_CAPSLOCK: |
| return kSbKeyCapital; |
| case KEY_NUMLOCK: |
| return kSbKeyNumlock; |
| case KEY_SCROLLLOCK: |
| return kSbKeyScroll; |
| case KEY_SELECT: |
| return kSbKeySelect; |
| case KEY_PRINT: |
| return kSbKeyPrint; |
| case KEY_INSERT: |
| return kSbKeyInsert; |
| case KEY_HELP: |
| return kSbKeyHelp; |
| case KEY_MENU: |
| return kSbKeyApps; |
| case KEY_FN_F1: |
| case KEY_FN_F2: |
| case KEY_FN_F3: |
| case KEY_FN_F4: |
| case KEY_FN_F5: |
| case KEY_FN_F6: |
| case KEY_FN_F7: |
| case KEY_FN_F8: |
| case KEY_FN_F9: |
| case KEY_FN_F10: |
| case KEY_FN_F11: |
| case KEY_FN_F12: |
| return static_cast<SbKey>(kSbKeyF1 + (code - KEY_FN_F1)); |
| |
| // For supporting multimedia buttons on a USB keyboard. |
| case KEY_BACK: |
| return kSbKeyBrowserBack; |
| case KEY_FORWARD: |
| return kSbKeyBrowserForward; |
| case KEY_REFRESH: |
| return kSbKeyBrowserRefresh; |
| case KEY_STOP: |
| return kSbKeyBrowserStop; |
| case KEY_SEARCH: |
| return kSbKeyBrowserSearch; |
| case KEY_FAVORITES: |
| return kSbKeyBrowserFavorites; |
| case KEY_HOMEPAGE: |
| return kSbKeyBrowserHome; |
| case KEY_MUTE: |
| return kSbKeyVolumeMute; |
| case KEY_VOLUMEDOWN: |
| return kSbKeyVolumeDown; |
| case KEY_VOLUMEUP: |
| return kSbKeyVolumeUp; |
| case KEY_NEXTSONG: |
| return kSbKeyMediaNextTrack; |
| case KEY_PREVIOUSSONG: |
| return kSbKeyMediaPrevTrack; |
| case KEY_STOPCD: |
| return kSbKeyMediaStop; |
| case KEY_PLAYPAUSE: |
| return kSbKeyMediaPlayPause; |
| case KEY_MAIL: |
| return kSbKeyMediaLaunchMail; |
| case KEY_CALC: |
| return kSbKeyMediaLaunchApp2; |
| case KEY_WLAN: |
| return kSbKeyWlan; |
| case KEY_POWER: |
| return kSbKeyPower; |
| case KEY_BRIGHTNESSDOWN: |
| return kSbKeyBrightnessDown; |
| case KEY_BRIGHTNESSUP: |
| return kSbKeyBrightnessUp; |
| |
| case KEY_INFO_BUTTON: |
| return kSbKeyF1; |
| } |
| SB_DLOG(WARNING) << "Unknown code: 0x" << std::hex << code; |
| return kSbKeyUnknown; |
| } // NOLINT(readability/fn_size) |
| |
| // Get a SbKeyLocation from an input_event.code. |
| static SbKeyLocation KeyCodeToSbKeyLocation(uint16_t code) { |
| switch (code) { |
| case KEY_LEFTALT: |
| case KEY_LEFTCTRL: |
| case KEY_LEFTMETA: |
| case KEY_LEFTSHIFT: |
| return kSbKeyLocationLeft; |
| case KEY_RIGHTALT: |
| case KEY_RIGHTCTRL: |
| case KEY_RIGHTMETA: |
| case KEY_RIGHTSHIFT: |
| return kSbKeyLocationRight; |
| } |
| |
| return kSbKeyLocationUnspecified; |
| } |
| |
| // keyboard_listener |
| static void KeyboardHandleKeyMap(void* data, |
| struct wl_keyboard* keyboard, |
| uint32_t format, |
| int fd, |
| uint32_t size) { |
| SB_DLOG(INFO) << "[Key] Keyboard keymap"; |
| } |
| |
| static void KeyboardHandleEnter(void* data, |
| struct wl_keyboard* keyboard, |
| uint32_t serial, |
| struct wl_surface* surface, |
| struct wl_array* keys) { |
| SB_DLOG(INFO) << "[Key] Keyboard gained focus"; |
| } |
| |
| static void KeyboardHandleLeave(void* data, |
| struct wl_keyboard* keyboard, |
| uint32_t serial, |
| struct wl_surface* surface) { |
| SB_DLOG(INFO) << "[Key] Keyboard lost focus"; |
| ApplicationWayland* wayland_window_ = |
| reinterpret_cast<ApplicationWayland*>(data); |
| wayland_window_->DeleteRepeatKey(); |
| } |
| |
| static void KeyboardHandleKey(void* data, |
| struct wl_keyboard* keyboard, |
| uint32_t serial, |
| uint32_t time, |
| uint32_t key, |
| uint32_t state) { |
| SB_DLOG(INFO) << "[Key] Key :" << key << ", state:" << state; |
| ApplicationWayland* wayland_window_ = |
| reinterpret_cast<ApplicationWayland*>(data); |
| if (key == KEY_LEFT || key == KEY_RIGHT || key == KEY_UP || key == KEY_DOWN) { |
| wayland_window_->CreateKey(key, state, true); |
| } else { |
| wayland_window_->CreateKey(key, state, false); |
| } |
| } |
| |
| static void KeyboardHandleModifiers(void* data, |
| struct wl_keyboard* keyboard, |
| uint32_t serial, |
| uint32_t mods_depressed, |
| uint32_t mods_latched, |
| uint32_t mods_locked, |
| uint32_t group) { |
| ApplicationWayland* wayland_window_ = |
| reinterpret_cast<ApplicationWayland*>(data); |
| // Convert to SbKeyModifiers. |
| unsigned int modifiers = kSbKeyModifiersNone; |
| |
| if (mods_depressed & 1) |
| modifiers |= kSbKeyModifiersShift; |
| if (mods_depressed & 4) |
| modifiers |= kSbKeyModifiersCtrl; |
| if (mods_depressed & 8) |
| modifiers |= kSbKeyModifiersAlt; |
| |
| SB_DLOG(INFO) << "[Key] Modifiers depressed " << mods_depressed |
| << ", latched " << mods_latched << ", locked " << mods_locked |
| << ", group " << group << ", key modifiers " << modifiers; |
| |
| wayland_window_->UpdateKeyModifiers(modifiers); |
| } |
| |
| static const struct wl_keyboard_listener keyboard_listener_ = { |
| &KeyboardHandleKeyMap, &KeyboardHandleEnter, &KeyboardHandleLeave, |
| &KeyboardHandleKey, &KeyboardHandleModifiers, |
| }; |
| |
| // seat_listener |
| static void SeatHandleCapabilities(void* data, |
| struct wl_seat* seat, |
| unsigned int caps) { |
| ApplicationWayland* wayland_window_ = |
| reinterpret_cast<ApplicationWayland*>(data); |
| if (!wayland_window_->GetKeyboard()) { |
| SB_DLOG(INFO) << "[Key] seat_handle_capabilities caps: " << caps; |
| if (caps & WL_SEAT_CAPABILITY_KEYBOARD) { |
| SB_DLOG(INFO) << "[Key] wl_seat_get_keyboard"; |
| wayland_window_->SetKeyboard(wl_seat_get_keyboard(seat)); |
| wl_keyboard_add_listener(wayland_window_->GetKeyboard(), |
| &keyboard_listener_, data); |
| } else if (!(caps & WL_SEAT_CAPABILITY_KEYBOARD)) { |
| SB_DLOG(INFO) << "[Key] wl_keyboard_destroy"; |
| wl_keyboard_destroy(wayland_window_->GetKeyboard()); |
| wayland_window_->SetKeyboard(NULL); |
| } |
| } |
| } |
| |
| static const struct wl_seat_listener seat_listener = { |
| &SeatHandleCapabilities, |
| }; |
| |
| // registry_listener |
| static void RegistryAddObject(void* data, |
| struct wl_registry* registry, |
| uint32_t name, |
| const char* interface, |
| uint32_t version) { |
| ApplicationWayland* wayland_window_ = |
| reinterpret_cast<ApplicationWayland*>(data); |
| if (strcmp(interface, "wl_compositor") == 0) { |
| wayland_window_->SetCompositor(static_cast<wl_compositor*>( |
| wl_registry_bind(registry, name, &wl_compositor_interface, 1))); |
| } else if (strcmp(interface, "wl_shell") == 0) { |
| wayland_window_->SetShell(static_cast<wl_shell*>( |
| wl_registry_bind(registry, name, &wl_shell_interface, 1))); |
| } else if (strcmp(interface, "wl_seat") == 0) { |
| wayland_window_->SetSeat(static_cast<wl_seat*>( |
| wl_registry_bind(registry, name, &wl_seat_interface, 1))); |
| wl_seat_add_listener(wayland_window_->GetSeat(), &seat_listener, data); |
| } else if (!strcmp(interface, "tizen_policy")) { |
| wayland_window_->SetPolicy(static_cast<tizen_policy*>( |
| wl_registry_bind(registry, name, &tizen_policy_interface, 1))); |
| } |
| } |
| |
| static void RegistryRemoveObject(void*, struct wl_registry*, uint32_t) {} |
| |
| static struct wl_registry_listener registry_listener = {&RegistryAddObject, |
| &RegistryRemoveObject}; |
| |
| // shell_surface_listener |
| static void ShellSurfacePing(void*, |
| struct wl_shell_surface* shell_surface, |
| uint32_t serial) { |
| wl_shell_surface_pong(shell_surface, serial); |
| } |
| static void ShellSurfaceConfigure(void* data, |
| struct wl_shell_surface*, |
| uint32_t, |
| int32_t width, |
| int32_t height) { |
| SB_DLOG(INFO) << "shell_surface_configure width(" << width << "), height(" |
| << height << ")"; |
| if (width && height) { |
| SbWindowPrivate* window = reinterpret_cast<SbWindowPrivate*>(data); |
| wl_egl_window_resize(window->egl_window, width, height, 0, 0); |
| } else { |
| SB_DLOG(INFO) << "width and height is 0. we don't resize that"; |
| } |
| } |
| |
| static void ShellSurfacePopupDone(void*, struct wl_shell_surface*) {} |
| |
| static struct wl_shell_surface_listener shell_surface_listener = { |
| &ShellSurfacePing, &ShellSurfaceConfigure, &ShellSurfacePopupDone}; |
| |
| static void WindowCbVisibilityChange(void* data, |
| struct tizen_visibility* tizen_visibility |
| EINA_UNUSED, |
| uint32_t visibility) { |
| #if SB_HAS(LAZY_SUSPEND) |
| if (visibility == TIZEN_VISIBILITY_VISIBILITY_FULLY_OBSCURED) |
| ApplicationWayland::Get()->Pause(NULL, NULL); |
| else |
| ApplicationWayland::Get()->Unpause(NULL, NULL); |
| #else |
| if (visibility == TIZEN_VISIBILITY_VISIBILITY_FULLY_OBSCURED) |
| shared::starboard::Application::Get()->Suspend(NULL, NULL); |
| else |
| shared::starboard::Application::Get()->Unpause(NULL, NULL); |
| #endif |
| } |
| |
| static const struct tizen_visibility_listener tizen_visibility_listener = { |
| WindowCbVisibilityChange}; |
| |
| } // namespace wayland |
| } // namespace shared |
| } // namespace starboard |
| |
| #endif // STARBOARD_SHARED_WAYLAND_DEV_INPUT_H_ |
