| // Copyright 2015 Google Inc. 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. |
| |
| #include "cobalt/dom/keyboard_event.h" |
| |
| #include <string> |
| |
| #include "base/logging.h" |
| #include "cobalt/base/token.h" |
| #include "cobalt/base/tokens.h" |
| #include "cobalt/dom/keycode.h" |
| |
| namespace cobalt { |
| namespace dom { |
| |
| KeyboardEvent::KeyboardEvent(const std::string& type) |
| : UIEventWithKeyState(base::Token(type), kBubbles, kCancelable, NULL), |
| key_location_(kDomKeyLocationStandard), |
| key_code_(0), |
| char_code_(0), |
| repeat_(false) {} |
| |
| // TODO: Initialize from init_dict.key() or init_dict.code() when not empty. |
| KeyboardEvent::KeyboardEvent(const std::string& type, |
| const KeyboardEventInit& init_dict) |
| : UIEventWithKeyState(base::Token(type), kBubbles, kCancelable, |
| init_dict.view(), init_dict), |
| key_location_(static_cast<KeyLocationCode>(init_dict.location())), |
| key_code_(init_dict.key_code()), |
| char_code_(init_dict.char_code()), |
| repeat_(init_dict.repeat()) {} |
| |
| KeyboardEvent::KeyboardEvent(base::Token type, |
| const scoped_refptr<Window>& view, |
| const KeyboardEventInit& init_dict) |
| : UIEventWithKeyState(type, kBubbles, kCancelable, view, init_dict), |
| key_location_(static_cast<KeyLocationCode>(init_dict.location())), |
| key_code_(init_dict.key_code()), |
| char_code_(init_dict.char_code()), |
| repeat_(init_dict.repeat()) {} |
| |
| KeyboardEvent::KeyboardEvent(UninitializedFlag uninitialized_flag) |
| : UIEventWithKeyState(uninitialized_flag), |
| key_code_(0), |
| char_code_(0), |
| repeat_(false) {} |
| |
| void KeyboardEvent::InitKeyboardEvent(const std::string& type, bool bubbles, |
| bool cancelable, |
| const scoped_refptr<Window>& view, |
| const std::string& key, uint32 location, |
| const std::string& modifierslist, |
| bool repeat) { |
| InitUIEventWithKeyState(type, bubbles, cancelable, view, 0, modifierslist); |
| key_location_ = static_cast<KeyLocationCode>(location); |
| repeat_ = repeat; |
| |
| // TODO: Implement full keyCode determination according to 'Legacy key models' |
| // from: https://www.w3.org/TR/2016/WD-uievents-20160804/#legacy-key-models |
| |
| // Parse keys from the "Fixed virtual key codes" table from: |
| // https://www.w3.org/TR/2016/WD-uievents-20160804/#fixed-virtual-key-codes |
| if (key == "Backspace") { |
| key_code_ = keycode::kBack; |
| } else if (key == "Tab") { |
| key_code_ = keycode::kTab; |
| } else if (key == "Enter") { |
| key_code_ = keycode::kReturn; |
| } else if (key == "Shift") { |
| key_code_ = keycode::kShift; |
| } else if (key == "Control") { |
| key_code_ = keycode::kControl; |
| } else if (key == "Alt") { |
| key_code_ = keycode::kMenu; |
| } else if (key == "CapsLock") { |
| key_code_ = keycode::kCapital; |
| } else if (key == "Escape") { |
| key_code_ = keycode::kEscape; |
| } else if (key == "Space") { |
| key_code_ = keycode::kSpace; |
| } else if (key == "PageUp") { |
| key_code_ = keycode::kPrior; |
| } else if (key == "PageDown") { |
| key_code_ = keycode::kNext; |
| } else if (key == "End") { |
| key_code_ = keycode::kEnd; |
| } else if (key == "Home") { |
| key_code_ = keycode::kHome; |
| } else if (key == "ArrowLeft") { |
| key_code_ = keycode::kLeft; |
| } else if (key == "ArrowUp") { |
| key_code_ = keycode::kUp; |
| } else if (key == "ArrowRight") { |
| key_code_ = keycode::kRight; |
| } else if (key == "ArrowDown") { |
| key_code_ = keycode::kDown; |
| } else if (key == "Delete") { |
| key_code_ = keycode::kDelete; |
| } |
| } |
| |
| // How to determine keycode: |
| // https://www.w3.org/TR/2016/WD-uievents-20160804/#determine-keydown-keyup-keyCode |
| // Virtual key code for keyup/keydown, 0 for keypress (split model) |
| uint32 KeyboardEvent::key_code() const { |
| if (type() == base::Tokens::keydown() || type() == base::Tokens::keyup()) { |
| return key_code_; |
| } |
| |
| return 0; |
| } |
| |
| uint32 KeyboardEvent::char_code() const { |
| return type() == base::Tokens::keypress() ? char_code_ : 0; |
| } |
| |
| uint32 KeyboardEvent::which() const { return key_code(); } |
| |
| std::string KeyboardEvent::NonPrintableKey(int32_t key_code) const { |
| // Otherwise, we have one of the non-printable characters. |
| // Definitions taken from: |
| // https://www.w3.org/TR/DOM-Level-3-Events-key/ |
| // https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent/key. |
| switch (key_code) { |
| case keycode::kBack: |
| return "Backspace"; |
| case keycode::kTab: |
| return "Tab"; |
| case keycode::kBacktab: |
| return "Tab"; |
| case keycode::kClear: |
| return "Clear"; |
| case keycode::kReturn: |
| return "Enter"; |
| case keycode::kShift: |
| return "Shift"; |
| case keycode::kControl: |
| return "Control"; |
| case keycode::kMenu: |
| return "Alt"; |
| case keycode::kPause: |
| return "Pause"; |
| case keycode::kCapital: |
| return "CapsLock"; |
| case keycode::kKana: |
| return "KanaMode"; |
| case keycode::kJunja: |
| return "JunjaMode"; |
| case keycode::kFinal: |
| return "HanjaMode"; |
| case keycode::kKanji: |
| return "KanjiMode"; |
| case keycode::kEscape: |
| return "Esc"; |
| case keycode::kConvert: |
| return "Convert"; |
| case keycode::kNonconvert: |
| return "Nonconvert"; |
| case keycode::kAccept: |
| return "Accept"; |
| case keycode::kModechange: |
| return "ModeChange"; |
| case keycode::kSpace: |
| return " "; |
| case keycode::kPrior: |
| return "PageUp"; |
| case keycode::kNext: |
| return "PageDown"; |
| case keycode::kEnd: |
| return "End"; |
| case keycode::kHome: |
| return "Home"; |
| case keycode::kLeft: |
| return "ArrowLeft"; |
| case keycode::kUp: |
| return "ArrowUp"; |
| case keycode::kRight: |
| return "ArrowRight"; |
| case keycode::kDown: |
| return "ArrowDown"; |
| case keycode::kSelect: |
| return "Select"; |
| case keycode::kPrint: |
| return "Print"; |
| case keycode::kExecute: |
| return "Execute"; |
| case keycode::kSnapshot: |
| return "PrintScreen"; |
| case keycode::kInsert: |
| return "Insert"; |
| case keycode::kDelete: |
| return "Delete"; |
| case keycode::kHelp: |
| return "Help"; |
| case keycode::kLwin: |
| return "Win"; |
| case keycode::kRwin: |
| return "Win"; |
| case keycode::kApps: |
| return "Apps"; |
| case keycode::kSleep: |
| return "Standby"; |
| case keycode::kNumpad0: |
| return "0"; |
| case keycode::kNumpad1: |
| return "1"; |
| case keycode::kNumpad2: |
| return "2"; |
| case keycode::kNumpad3: |
| return "3"; |
| case keycode::kNumpad4: |
| return "4"; |
| case keycode::kNumpad5: |
| return "5"; |
| case keycode::kNumpad6: |
| return "6"; |
| case keycode::kNumpad7: |
| return "7"; |
| case keycode::kNumpad8: |
| return "8"; |
| case keycode::kNumpad9: |
| return "9"; |
| case keycode::kMultiply: |
| return "Multiply"; |
| case keycode::kAdd: |
| return "Add"; |
| case keycode::kSeparator: |
| return "Separator"; |
| case keycode::kSubtract: |
| return "Subtract"; |
| case keycode::kDecimal: |
| return "Decimal"; |
| case keycode::kDivide: |
| return "Divide"; |
| case keycode::kF1: |
| return "F1"; |
| case keycode::kF2: |
| return "F2"; |
| case keycode::kF3: |
| return "F3"; |
| case keycode::kF4: |
| return "F4"; |
| case keycode::kF5: |
| return "F5"; |
| case keycode::kF6: |
| return "F6"; |
| case keycode::kF7: |
| return "F7"; |
| case keycode::kF8: |
| return "F8"; |
| case keycode::kF9: |
| return "F9"; |
| case keycode::kF10: |
| return "F10"; |
| case keycode::kF11: |
| return "F11"; |
| case keycode::kF12: |
| return "F12"; |
| case keycode::kF13: |
| return "F13"; |
| case keycode::kF14: |
| return "F14"; |
| case keycode::kF15: |
| return "F15"; |
| case keycode::kF16: |
| return "F16"; |
| case keycode::kF17: |
| return "F17"; |
| case keycode::kF18: |
| return "F18"; |
| case keycode::kF19: |
| return "F19"; |
| case keycode::kF20: |
| return "F20"; |
| case keycode::kF21: |
| return "F21"; |
| case keycode::kF22: |
| return "F22"; |
| case keycode::kF23: |
| return "F23"; |
| case keycode::kF24: |
| return "F24"; |
| case keycode::kNumlock: |
| return "NumLock"; |
| case keycode::kScroll: |
| return "Scroll"; |
| case keycode::kWlan: |
| return "Unidentified"; |
| case keycode::kPower: |
| return "Unidentified"; |
| case keycode::kLshift: |
| case keycode::kRshift: |
| return "Shift"; |
| case keycode::kLcontrol: |
| case keycode::kRcontrol: |
| return "Control"; |
| case keycode::kLmenu: |
| case keycode::kRmenu: |
| return "Alt"; |
| case keycode::kBrowserBack: |
| return "BrowserBack"; |
| case keycode::kBrowserForward: |
| return "BrowserForward"; |
| case keycode::kBrowserRefresh: |
| return "BrowserRefresh"; |
| case keycode::kBrowserStop: |
| return "BrowserStop"; |
| case keycode::kBrowserSearch: |
| return "BrowserSearch"; |
| case keycode::kBrowserFavorites: |
| return "BrowserFavorites"; |
| case keycode::kBrowserHome: |
| return "BrowserHome"; |
| case keycode::kVolumeMute: |
| return "VolumeMute"; |
| case keycode::kVolumeDown: |
| return "VolumeMute"; |
| case keycode::kVolumeUp: |
| return "VolumeMute"; |
| case keycode::kMediaNextTrack: |
| return "MediaNextTrack"; |
| case keycode::kMediaPrevTrack: |
| return "MediaPrevTrack"; |
| case keycode::kMediaStop: |
| return "MediaStop"; |
| case keycode::kMediaPlayPause: |
| return "MediaPlayPause"; |
| case keycode::kMediaLaunchMail: |
| return "LaunchMail"; |
| case keycode::kMediaLaunchMediaSelect: |
| return "SelectMedia"; |
| case keycode::kMediaLaunchApp1: |
| return "LaunchApplication1"; |
| case keycode::kMediaLaunchApp2: |
| return "LaunchApplication1"; |
| case keycode::kBrightnessDown: |
| return "BrightnessDown"; |
| case keycode::kBrightnessUp: |
| return "BrightnessUp"; |
| case keycode::kPlay: |
| return "Play"; |
| default: |
| return "Unidentified"; |
| } |
| } |
| |
| std::string KeyboardEvent::key() const { |
| // First check if the event corresponds to a printable character. |
| // If so, just return a string containing that single character. |
| int char_code = ComputeCharCode(key_code_, shift_key()); |
| if (char_code > 0 && char_code <= 127) { |
| return std::string(1, static_cast<char>(char_code)); |
| } |
| |
| return NonPrintableKey(key_code_); |
| } |
| |
| std::string KeyboardEvent::code() const { |
| // First check if the event corresponds to a named key in the tables here: |
| // https://www.w3.org/TR/uievents-code/#code-value-tables |
| |
| // First check if the event corresponds to a alphanumeric key. |
| if (key_code_ >= keycode::kA && key_code_ <= keycode::kZ) { |
| std::string key_code = "Key"; |
| key_code.append(1, static_cast<char>(key_code_)); |
| return key_code; |
| } |
| |
| // Check if the event corresponds to a digit key. |
| if (key_code_ >= keycode::k0 && key_code_ <= keycode::k9) { |
| std::string key_code = "Digit"; |
| key_code.append(1, static_cast<char>(key_code_)); |
| return key_code; |
| } |
| |
| // Check if the event corresponds to a numpad digit key. |
| // https://www.w3.org/TR/uievents-code/#key-numpad-section |
| if (key_code_ >= keycode::kNumpad0 && key_code_ <= keycode::kDivide) { |
| std::string key_code = "Numpad"; |
| char numpad_digit = '0' + static_cast<char>(key_code_ - keycode::kNumpad0); |
| key_code.append(1, numpad_digit); |
| return key_code; |
| } |
| |
| // Check if the event corresponds to a remaining named key |
| switch (key_code_) { |
| case keycode::kSpace: |
| return "Space"; |
| case keycode::kMultiply: |
| return "NumpadMultiply"; |
| case keycode::kAdd: |
| return "NumpadAdd"; |
| case keycode::kSeparator: |
| return "NumpadComma"; |
| case keycode::kSubtract: |
| return "NumpadSubtract"; |
| case keycode::kDecimal: |
| return "NumpadDecimal"; |
| case keycode::kDivide: |
| return "NumpadDivide"; |
| case keycode::kOem1: |
| return "Semicolon"; |
| case keycode::kOemPlus: |
| return "Equal"; |
| case keycode::kOemComma: |
| return "Comma"; |
| case keycode::kOemMinus: |
| return "Minus"; |
| case keycode::kOemPeriod: |
| return "Period"; |
| case keycode::kOem2: |
| return "Slash"; |
| case keycode::kOem3: |
| return "Backquote"; |
| case keycode::kOem4: |
| return "BracketLeft"; |
| case keycode::kOem5: |
| return "Backslash"; |
| case keycode::kOem6: |
| return "BracketRight"; |
| case keycode::kOem7: |
| return "Quote"; |
| case keycode::kLwin: |
| return "MetaLeft"; |
| case keycode::kRwin: |
| return "MetaRight"; |
| case keycode::kLshift: |
| return "ShiftLeft"; |
| case keycode::kRshift: |
| return "ShiftRight"; |
| case keycode::kLcontrol: |
| return "ControlLeft"; |
| case keycode::kRcontrol: |
| return "ControlRight"; |
| case keycode::kLmenu: |
| return "AltLeft"; |
| case keycode::kRmenu: |
| return "AltRight"; |
| default: |
| // Nothing. |
| break; |
| } |
| |
| // The event corresponds to a nonprintable key with a name that matches the |
| // named value for the key. |
| return NonPrintableKey(key_code_); |
| } |
| |
| // Static. |
| int32 KeyboardEvent::ComputeCharCode(int32 key_code, bool shift_key) { |
| if (shift_key) { |
| return KeyCodeToCharCodeWithShift(key_code); |
| } else { |
| return KeyCodeToCharCodeNoShift(key_code); |
| } |
| } |
| |
| // Static. |
| int KeyboardEvent::KeyCodeToCharCodeWithShift(int key_code) { |
| // Space is unaffected (keycode is same as Unicode). |
| // Characters are unaffected (keycode is uppercase by default). |
| // Numbers map to the corresponding symbol. |
| // Special symbols take on their shifted value. |
| if (key_code == keycode::kSpace) { |
| return key_code; |
| } |
| if (key_code >= keycode::kA && key_code <= keycode::kZ) { |
| return key_code; |
| } |
| |
| switch (key_code) { |
| case keycode::k0: |
| return ')'; |
| case keycode::k1: |
| return '!'; |
| case keycode::k2: |
| return '@'; |
| case keycode::k3: |
| return '#'; |
| case keycode::k4: |
| return '$'; |
| case keycode::k5: |
| return '%'; |
| case keycode::k6: |
| return '^'; |
| case keycode::k7: |
| return '&'; |
| case keycode::k8: |
| return '*'; |
| case keycode::k9: |
| return '('; |
| case keycode::kOem1: |
| return ':'; |
| case keycode::kOemPlus: |
| return '+'; |
| case keycode::kOemComma: |
| return '<'; |
| case keycode::kOemMinus: |
| return '_'; |
| case keycode::kOemPeriod: |
| return '>'; |
| case keycode::kOem2: |
| return '?'; |
| case keycode::kOem3: |
| return '~'; |
| case keycode::kOem4: |
| return '{'; |
| case keycode::kOem5: |
| return '|'; |
| case keycode::kOem6: |
| return '}'; |
| case keycode::kOem7: |
| return '"'; |
| default: |
| return 0; |
| } |
| } |
| |
| // Static. |
| int KeyboardEvent::KeyCodeToCharCodeNoShift(int key_code) { |
| // Space keycode corresponds to Unicode value. |
| // Numbers are unaffected (keycode corresponds to correct Unicode value). |
| // Characters are mapped from uppercase to lowercase. |
| // Special symbols use their unshifted value. |
| if (key_code == keycode::kSpace) { |
| return key_code; |
| } |
| if (key_code >= keycode::k0 && key_code <= keycode::k9) { |
| return key_code; |
| } |
| if (key_code >= keycode::kA && key_code <= keycode::kZ) { |
| return key_code + 32; |
| } |
| |
| switch (key_code) { |
| case keycode::kOem1: |
| return ';'; |
| case keycode::kOemPlus: |
| return '='; |
| case keycode::kOemComma: |
| return ','; |
| case keycode::kOemMinus: |
| return '-'; |
| case keycode::kOemPeriod: |
| return '.'; |
| case keycode::kOem2: |
| return '/'; |
| case keycode::kOem3: |
| return '`'; |
| case keycode::kOem4: |
| return '['; |
| case keycode::kOem5: |
| return '\\'; |
| case keycode::kOem6: |
| return ']'; |
| case keycode::kOem7: |
| return '\''; |
| default: |
| return 0; |
| } |
| } |
| |
| // Static. |
| KeyboardEvent::KeyLocationCode KeyboardEvent::KeyCodeToKeyLocation( |
| int key_code) { |
| switch (key_code) { |
| case keycode::kLshift: |
| case keycode::kLcontrol: |
| case keycode::kLmenu: |
| case keycode::kLwin: |
| return kDomKeyLocationLeft; |
| case keycode::kRshift: |
| case keycode::kRcontrol: |
| case keycode::kRmenu: |
| case keycode::kRwin: |
| return kDomKeyLocationRight; |
| default: |
| return kDomKeyLocationStandard; |
| } |
| } |
| |
| } // namespace dom |
| } // namespace cobalt |