| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2013 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "ui/events/keycodes/dom4/keycode_converter.h" | |
| 6 | |
| 7 #include "base/logging.h" | |
| 8 #include "ui/events/keycodes/dom3/dom_code.h" | |
| 9 #include "ui/events/keycodes/dom3/dom_key.h" | |
| 10 | |
| 11 namespace ui { | |
| 12 | |
| 13 namespace { | |
| 14 | |
| 15 // Table of USB codes (equivalent to DomCode values), native scan codes, | |
| 16 // and DOM Level 3 |code| strings. | |
| 17 #if defined(OS_WIN) | |
| 18 #define USB_KEYMAP(usb, xkb, win, mac, code, id) {usb, win, code} | |
| 19 #elif defined(OS_LINUX) | |
| 20 #define USB_KEYMAP(usb, xkb, win, mac, code, id) {usb, xkb, code} | |
| 21 #elif defined(OS_MACOSX) | |
| 22 #define USB_KEYMAP(usb, xkb, win, mac, code, id) {usb, mac, code} | |
| 23 #else | |
| 24 #define USB_KEYMAP(usb, xkb, win, mac, code, id) {usb, 0, code} | |
| 25 #endif | |
| 26 #define USB_KEYMAP_DECLARATION const KeycodeMapEntry usb_keycode_map[] = | |
| 27 #include "ui/events/keycodes/dom4/keycode_converter_data.h" | |
| 28 #undef USB_KEYMAP | |
| 29 #undef USB_KEYMAP_DECLARATION | |
| 30 | |
| 31 const size_t kKeycodeMapEntries = arraysize(usb_keycode_map); | |
| 32 | |
| 33 // Table of DomKey enum values and DOM Level 3 |key| strings. | |
| 34 struct DomKeyMapEntry { | |
| 35 DomKey dom_key; | |
| 36 const char* string; | |
| 37 }; | |
| 38 | |
| 39 #define DOM_KEY_MAP(key, id) {DomKey::id, key} | |
| 40 #define DOM_KEY_MAP_DECLARATION const DomKeyMapEntry dom_key_map[] = | |
| 41 #include "ui/events/keycodes/dom3/dom_key_data.h" | |
| 42 #undef DOM_KEY_MAP | |
| 43 #undef DOM_KEY_MAP_DECLARATION | |
| 44 | |
| 45 const size_t kDomKeyMapEntries = arraysize(dom_key_map); | |
| 46 | |
| 47 } // namespace | |
| 48 | |
| 49 // static | |
| 50 size_t KeycodeConverter::NumKeycodeMapEntriesForTest() { | |
| 51 return kKeycodeMapEntries; | |
| 52 } | |
| 53 | |
| 54 // static | |
| 55 const KeycodeMapEntry* KeycodeConverter::GetKeycodeMapForTest() { | |
| 56 return &usb_keycode_map[0]; | |
| 57 } | |
| 58 | |
| 59 // static | |
| 60 const char* KeycodeConverter::DomKeyStringForTest(size_t index) { | |
| 61 if (index >= kDomKeyMapEntries) | |
| 62 return nullptr; | |
| 63 return dom_key_map[index].string; | |
| 64 } | |
| 65 | |
| 66 // static | |
| 67 int KeycodeConverter::InvalidNativeKeycode() { | |
| 68 return usb_keycode_map[0].native_keycode; | |
| 69 } | |
| 70 | |
| 71 // static | |
| 72 const char* KeycodeConverter::NativeKeycodeToCode(int native_keycode) { | |
| 73 for (size_t i = 0; i < kKeycodeMapEntries; ++i) { | |
| 74 if (usb_keycode_map[i].native_keycode == native_keycode) { | |
| 75 if (usb_keycode_map[i].code != NULL) | |
| 76 return usb_keycode_map[i].code; | |
| 77 break; | |
| 78 } | |
| 79 } | |
| 80 return ""; | |
| 81 } | |
| 82 | |
| 83 // static | |
| 84 DomCode KeycodeConverter::NativeKeycodeToDomCode(int native_keycode) { | |
| 85 for (size_t i = 0; i < kKeycodeMapEntries; ++i) { | |
| 86 if (usb_keycode_map[i].native_keycode == native_keycode) { | |
| 87 if (usb_keycode_map[i].code != NULL) | |
| 88 return static_cast<DomCode>(usb_keycode_map[i].usb_keycode); | |
| 89 break; | |
| 90 } | |
| 91 } | |
| 92 return DomCode::NONE; | |
| 93 } | |
| 94 | |
| 95 // static | |
| 96 int KeycodeConverter::CodeToNativeKeycode(const char* code) { | |
| 97 if (!code || !*code) | |
| 98 return InvalidNativeKeycode(); | |
| 99 | |
| 100 for (size_t i = 0; i < kKeycodeMapEntries; ++i) { | |
| 101 if (usb_keycode_map[i].code && | |
| 102 strcmp(usb_keycode_map[i].code, code) == 0) { | |
| 103 return usb_keycode_map[i].native_keycode; | |
| 104 } | |
| 105 } | |
| 106 return InvalidNativeKeycode(); | |
| 107 } | |
| 108 | |
| 109 // static | |
| 110 int KeycodeConverter::DomCodeToNativeKeycode(DomCode code) { | |
| 111 if (code == DomCode::NONE) | |
| 112 return InvalidNativeKeycode(); | |
| 113 for (size_t i = 0; i < kKeycodeMapEntries; ++i) { | |
| 114 if (usb_keycode_map[i].usb_keycode == static_cast<uint32_t>(code)) | |
| 115 return usb_keycode_map[i].native_keycode; | |
| 116 } | |
| 117 return InvalidNativeKeycode(); | |
| 118 } | |
| 119 | |
| 120 // static | |
| 121 DomCode KeycodeConverter::CodeStringToDomCode(const char* code) { | |
| 122 if (!code || !*code) { | |
| 123 LOG(WARNING) << "empty code string"; | |
| 124 return DomCode::NONE; | |
| 125 } | |
| 126 for (size_t i = 0; i < kKeycodeMapEntries; ++i) { | |
| 127 if (usb_keycode_map[i].code && | |
| 128 strcmp(usb_keycode_map[i].code, code) == 0) { | |
| 129 return static_cast<DomCode>(usb_keycode_map[i].usb_keycode); | |
| 130 } | |
| 131 } | |
| 132 LOG(WARNING) << "unrecognized code string '" << code << "'"; | |
| 133 return DomCode::NONE; | |
| 134 } | |
| 135 | |
| 136 // static | |
| 137 const char* KeycodeConverter::DomCodeToCodeString(DomCode dom_code) { | |
| 138 return UsbKeycodeToCode(static_cast<uint32_t>(dom_code)); | |
| 139 } | |
| 140 | |
| 141 // static | |
| 142 DomKeyLocation KeycodeConverter::DomCodeToLocation(DomCode dom_code) { | |
| 143 static const struct { | |
| 144 DomCode code; | |
| 145 DomKeyLocation location; | |
| 146 } kLocations[] = {{DomCode::CONTROL_LEFT, DomKeyLocation::LEFT}, | |
| 147 {DomCode::SHIFT_LEFT, DomKeyLocation::LEFT}, | |
| 148 {DomCode::ALT_LEFT, DomKeyLocation::LEFT}, | |
| 149 {DomCode::OS_LEFT, DomKeyLocation::LEFT}, | |
| 150 {DomCode::CONTROL_RIGHT, DomKeyLocation::RIGHT}, | |
| 151 {DomCode::SHIFT_RIGHT, DomKeyLocation::RIGHT}, | |
| 152 {DomCode::ALT_RIGHT, DomKeyLocation::RIGHT}, | |
| 153 {DomCode::OS_RIGHT, DomKeyLocation::RIGHT}, | |
| 154 {DomCode::NUMPAD_DIVIDE, DomKeyLocation::NUMPAD}, | |
| 155 {DomCode::NUMPAD_MULTIPLY, DomKeyLocation::NUMPAD}, | |
| 156 {DomCode::NUMPAD_SUBTRACT, DomKeyLocation::NUMPAD}, | |
| 157 {DomCode::NUMPAD_ADD, DomKeyLocation::NUMPAD}, | |
| 158 {DomCode::NUMPAD_ENTER, DomKeyLocation::NUMPAD}, | |
| 159 {DomCode::NUMPAD1, DomKeyLocation::NUMPAD}, | |
| 160 {DomCode::NUMPAD2, DomKeyLocation::NUMPAD}, | |
| 161 {DomCode::NUMPAD3, DomKeyLocation::NUMPAD}, | |
| 162 {DomCode::NUMPAD4, DomKeyLocation::NUMPAD}, | |
| 163 {DomCode::NUMPAD5, DomKeyLocation::NUMPAD}, | |
| 164 {DomCode::NUMPAD6, DomKeyLocation::NUMPAD}, | |
| 165 {DomCode::NUMPAD7, DomKeyLocation::NUMPAD}, | |
| 166 {DomCode::NUMPAD8, DomKeyLocation::NUMPAD}, | |
| 167 {DomCode::NUMPAD9, DomKeyLocation::NUMPAD}, | |
| 168 {DomCode::NUMPAD0, DomKeyLocation::NUMPAD}, | |
| 169 {DomCode::NUMPAD_DECIMAL, DomKeyLocation::NUMPAD}, | |
| 170 {DomCode::NUMPAD_EQUAL, DomKeyLocation::NUMPAD}, | |
| 171 {DomCode::NUMPAD_COMMA, DomKeyLocation::NUMPAD}, | |
| 172 {DomCode::NUMPAD_PAREN_LEFT, DomKeyLocation::NUMPAD}, | |
| 173 {DomCode::NUMPAD_PAREN_RIGHT, DomKeyLocation::NUMPAD}, | |
| 174 {DomCode::NUMPAD_BACKSPACE, DomKeyLocation::NUMPAD}, | |
| 175 {DomCode::NUMPAD_MEMORY_STORE, DomKeyLocation::NUMPAD}, | |
| 176 {DomCode::NUMPAD_MEMORY_RECALL, DomKeyLocation::NUMPAD}, | |
| 177 {DomCode::NUMPAD_MEMORY_CLEAR, DomKeyLocation::NUMPAD}, | |
| 178 {DomCode::NUMPAD_MEMORY_ADD, DomKeyLocation::NUMPAD}, | |
| 179 {DomCode::NUMPAD_MEMORY_SUBTRACT, DomKeyLocation::NUMPAD}, | |
| 180 {DomCode::NUMPAD_SIGN_CHANGE, DomKeyLocation::NUMPAD}, | |
| 181 {DomCode::NUMPAD_CLEAR, DomKeyLocation::NUMPAD}, | |
| 182 {DomCode::NUMPAD_CLEAR_ENTRY, DomKeyLocation::NUMPAD}}; | |
| 183 for (const auto& key : kLocations) { | |
| 184 if (key.code == dom_code) | |
| 185 return key.location; | |
| 186 } | |
| 187 return DomKeyLocation::STANDARD; | |
| 188 } | |
| 189 | |
| 190 // static | |
| 191 DomKey KeycodeConverter::KeyStringToDomKey(const char* key) { | |
| 192 if (!key || !*key) | |
| 193 return DomKey::NONE; | |
| 194 for (size_t i = 0; i < kDomKeyMapEntries; ++i) { | |
| 195 if (dom_key_map[i].string && | |
| 196 strcmp(dom_key_map[i].string, key) == 0) { | |
| 197 return dom_key_map[i].dom_key; | |
| 198 } | |
| 199 } | |
| 200 return DomKey::NONE; | |
| 201 } | |
| 202 | |
| 203 // static | |
| 204 const char* KeycodeConverter::DomKeyToKeyString(DomKey dom_key) { | |
| 205 for (size_t i = 0; i < kDomKeyMapEntries; ++i) { | |
| 206 if (dom_key_map[i].dom_key == dom_key) | |
| 207 return dom_key_map[i].string; | |
| 208 } | |
| 209 return ""; | |
| 210 } | |
| 211 | |
| 212 // USB keycodes | |
| 213 // Note that USB keycodes are not part of any web standard. | |
| 214 // Please don't use USB keycodes in new code. | |
| 215 | |
| 216 // static | |
| 217 uint32_t KeycodeConverter::InvalidUsbKeycode() { | |
| 218 return usb_keycode_map[0].usb_keycode; | |
| 219 } | |
| 220 | |
| 221 // static | |
| 222 int KeycodeConverter::UsbKeycodeToNativeKeycode(uint32_t usb_keycode) { | |
| 223 // Deal with some special-cases that don't fit the 1:1 mapping. | |
| 224 if (usb_keycode == 0x070032) // non-US hash. | |
| 225 usb_keycode = 0x070031; // US backslash. | |
| 226 #if defined(OS_MACOSX) | |
| 227 if (usb_keycode == 0x070046) // PrintScreen. | |
| 228 usb_keycode = 0x070068; // F13. | |
| 229 #endif | |
| 230 | |
| 231 for (size_t i = 0; i < kKeycodeMapEntries; ++i) { | |
| 232 if (usb_keycode_map[i].usb_keycode == usb_keycode) | |
| 233 return usb_keycode_map[i].native_keycode; | |
| 234 } | |
| 235 return InvalidNativeKeycode(); | |
| 236 } | |
| 237 | |
| 238 // static | |
| 239 uint32_t KeycodeConverter::NativeKeycodeToUsbKeycode(int native_keycode) { | |
| 240 for (size_t i = 0; i < kKeycodeMapEntries; ++i) { | |
| 241 if (usb_keycode_map[i].native_keycode == native_keycode) | |
| 242 return usb_keycode_map[i].usb_keycode; | |
| 243 } | |
| 244 return InvalidUsbKeycode(); | |
| 245 } | |
| 246 | |
| 247 // static | |
| 248 const char* KeycodeConverter::UsbKeycodeToCode(uint32_t usb_keycode) { | |
| 249 for (size_t i = 0; i < kKeycodeMapEntries; ++i) { | |
| 250 if (usb_keycode_map[i].usb_keycode == usb_keycode) { | |
| 251 if (usb_keycode_map[i].code) | |
| 252 return usb_keycode_map[i].code; | |
| 253 break; | |
| 254 } | |
| 255 } | |
| 256 return ""; | |
| 257 } | |
| 258 | |
| 259 // static | |
| 260 DomCode KeycodeConverter::UsbKeycodeToDomCode(uint32_t usb_keycode) { | |
| 261 for (size_t i = 0; i < kKeycodeMapEntries; ++i) { | |
| 262 if (usb_keycode_map[i].usb_keycode == usb_keycode) | |
| 263 return static_cast<DomCode>(usb_keycode); | |
| 264 } | |
| 265 return DomCode::NONE; | |
| 266 } | |
| 267 | |
| 268 // static | |
| 269 uint32_t KeycodeConverter::CodeToUsbKeycode(const char* code) { | |
| 270 if (!code || !*code) | |
| 271 return InvalidUsbKeycode(); | |
| 272 | |
| 273 for (size_t i = 0; i < kKeycodeMapEntries; ++i) { | |
| 274 if (usb_keycode_map[i].code && | |
| 275 strcmp(usb_keycode_map[i].code, code) == 0) { | |
| 276 return usb_keycode_map[i].usb_keycode; | |
| 277 } | |
| 278 } | |
| 279 return InvalidUsbKeycode(); | |
| 280 } | |
| 281 | |
| 282 } // namespace ui | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1136503003:
Consolidate ui/events/keycodes/dom[34]/ into .../dom/ (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master