OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "ui/events/keycodes/dom4/keycode_converter.h" | 5 #include "ui/events/keycodes/dom4/keycode_converter.h" |
6 | 6 |
| 7 #include "ui/events/keycodes/dom3/dom_code.h" |
| 8 #include "ui/events/keycodes/dom3/dom_key.h" |
| 9 |
7 namespace ui { | 10 namespace ui { |
8 | 11 |
9 namespace { | 12 namespace { |
10 | 13 |
| 14 // Table of USB codes (equivalent to DomCode values), native scan codes, |
| 15 // and DOM Level 3 |code| strings. |
11 #if defined(OS_WIN) | 16 #if defined(OS_WIN) |
12 #define USB_KEYMAP(usb, xkb, win, mac, code) {usb, win, code} | 17 #define USB_KEYMAP(usb, xkb, win, mac, code, id) {usb, win, code} |
13 #elif defined(OS_LINUX) | 18 #elif defined(OS_LINUX) |
14 #define USB_KEYMAP(usb, xkb, win, mac, code) {usb, xkb, code} | 19 #define USB_KEYMAP(usb, xkb, win, mac, code, id) {usb, xkb, code} |
15 #elif defined(OS_MACOSX) | 20 #elif defined(OS_MACOSX) |
16 #define USB_KEYMAP(usb, xkb, win, mac, code) {usb, mac, code} | 21 #define USB_KEYMAP(usb, xkb, win, mac, code, id) {usb, mac, code} |
17 #else | 22 #else |
18 #define USB_KEYMAP(usb, xkb, win, mac, code) {usb, 0, code} | 23 #define USB_KEYMAP(usb, xkb, win, mac, code, id) {usb, 0, code} |
19 #endif | 24 #endif |
| 25 #define USB_KEYMAP_DECLARATION const KeycodeMapEntry usb_keycode_map[] = |
20 #include "ui/events/keycodes/dom4/keycode_converter_data.h" | 26 #include "ui/events/keycodes/dom4/keycode_converter_data.h" |
| 27 #undef USB_KEYMAP |
| 28 #undef USB_KEYMAP_DECLARATION |
21 | 29 |
22 const size_t kKeycodeMapEntries = arraysize(usb_keycode_map); | 30 const size_t kKeycodeMapEntries = arraysize(usb_keycode_map); |
23 | 31 |
| 32 // Table of DomKey enum values and DOM Level 3 |key| strings. |
| 33 struct DomKeyMapEntry { |
| 34 DomKey dom_key; |
| 35 const char* string; |
| 36 }; |
| 37 |
| 38 #define DOM_KEY_MAP(key, id) {DomKey::id, key} |
| 39 #define DOM_KEY_MAP_DECLARATION const DomKeyMapEntry dom_key_map[] = |
| 40 #include "ui/events/keycodes/dom3/dom_key_data.h" |
| 41 #undef DOM_KEY_MAP |
| 42 #undef DOM_KEY_MAP_DECLARATION |
| 43 |
| 44 const size_t kDomKeyMapEntries = arraysize(dom_key_map); |
| 45 |
24 } // namespace | 46 } // namespace |
25 | 47 |
26 // static | 48 // static |
27 size_t KeycodeConverter::NumKeycodeMapEntriesForTest() { | 49 size_t KeycodeConverter::NumKeycodeMapEntriesForTest() { |
28 return kKeycodeMapEntries; | 50 return kKeycodeMapEntries; |
29 } | 51 } |
30 | 52 |
31 // static | 53 // static |
32 const KeycodeMapEntry* KeycodeConverter::GetKeycodeMapForTest() { | 54 const KeycodeMapEntry* KeycodeConverter::GetKeycodeMapForTest() { |
33 return &usb_keycode_map[0]; | 55 return &usb_keycode_map[0]; |
34 } | 56 } |
35 | 57 |
36 // static | 58 // static |
| 59 const char* KeycodeConverter::DomKeyStringForTest(size_t index) { |
| 60 if (index >= kDomKeyMapEntries) |
| 61 return nullptr; |
| 62 return dom_key_map[index].string; |
| 63 } |
| 64 |
| 65 // static |
37 uint16_t KeycodeConverter::InvalidNativeKeycode() { | 66 uint16_t KeycodeConverter::InvalidNativeKeycode() { |
38 return usb_keycode_map[0].native_keycode; | 67 return usb_keycode_map[0].native_keycode; |
39 } | 68 } |
40 | 69 |
41 // static | 70 // static |
42 const char* KeycodeConverter::InvalidKeyboardEventCode() { | 71 const char* KeycodeConverter::InvalidKeyboardEventCode() { |
43 return "Unidentified"; | 72 return "Unidentified"; |
44 } | 73 } |
45 | 74 |
46 // static | 75 // static |
47 const char* KeycodeConverter::NativeKeycodeToCode(uint16_t native_keycode) { | 76 const char* KeycodeConverter::NativeKeycodeToCode(uint16_t native_keycode) { |
48 for (size_t i = 0; i < kKeycodeMapEntries; ++i) { | 77 for (size_t i = 0; i < kKeycodeMapEntries; ++i) { |
49 if (usb_keycode_map[i].native_keycode == native_keycode) { | 78 if (usb_keycode_map[i].native_keycode == native_keycode) { |
50 if (usb_keycode_map[i].code != NULL) | 79 if (usb_keycode_map[i].code != NULL) |
51 return usb_keycode_map[i].code; | 80 return usb_keycode_map[i].code; |
52 break; | 81 break; |
53 } | 82 } |
54 } | 83 } |
55 return InvalidKeyboardEventCode(); | 84 return InvalidKeyboardEventCode(); |
56 } | 85 } |
57 | 86 |
58 // static | 87 // static |
| 88 DomCode KeycodeConverter::NativeKeycodeToDomCode(uint16_t native_keycode) { |
| 89 for (size_t i = 0; i < kKeycodeMapEntries; ++i) { |
| 90 if (usb_keycode_map[i].native_keycode == native_keycode) { |
| 91 if (usb_keycode_map[i].code != NULL) |
| 92 return static_cast<DomCode>(usb_keycode_map[i].usb_keycode); |
| 93 break; |
| 94 } |
| 95 } |
| 96 return DomCode::NONE; |
| 97 } |
| 98 |
| 99 // static |
59 uint16_t KeycodeConverter::CodeToNativeKeycode(const char* code) { | 100 uint16_t KeycodeConverter::CodeToNativeKeycode(const char* code) { |
60 if (!code || | 101 if (!code || |
61 strcmp(code, InvalidKeyboardEventCode()) == 0) { | 102 strcmp(code, InvalidKeyboardEventCode()) == 0) { |
62 return InvalidNativeKeycode(); | 103 return InvalidNativeKeycode(); |
63 } | 104 } |
64 | 105 |
65 for (size_t i = 0; i < kKeycodeMapEntries; ++i) { | 106 for (size_t i = 0; i < kKeycodeMapEntries; ++i) { |
66 if (usb_keycode_map[i].code && | 107 if (usb_keycode_map[i].code && |
67 strcmp(usb_keycode_map[i].code, code) == 0) { | 108 strcmp(usb_keycode_map[i].code, code) == 0) { |
68 return usb_keycode_map[i].native_keycode; | 109 return usb_keycode_map[i].native_keycode; |
69 } | 110 } |
70 } | 111 } |
71 return InvalidNativeKeycode(); | 112 return InvalidNativeKeycode(); |
72 } | 113 } |
73 | 114 |
| 115 // static |
| 116 uint16_t KeycodeConverter::DomCodeToNativeKeycode(DomCode code) { |
| 117 if (code == DomCode::NONE) |
| 118 return InvalidNativeKeycode(); |
| 119 for (size_t i = 0; i < kKeycodeMapEntries; ++i) { |
| 120 if (usb_keycode_map[i].usb_keycode == static_cast<uint32_t>(code)) |
| 121 return usb_keycode_map[i].native_keycode; |
| 122 } |
| 123 return InvalidNativeKeycode(); |
| 124 } |
| 125 |
| 126 // static |
| 127 DomCode KeycodeConverter::CodeStringToDomCode(const char* code) { |
| 128 if (!code || |
| 129 strcmp(code, InvalidKeyboardEventCode()) == 0) { |
| 130 return DomCode::NONE; |
| 131 } |
| 132 for (size_t i = 0; i < kKeycodeMapEntries; ++i) { |
| 133 if (usb_keycode_map[i].code && |
| 134 strcmp(usb_keycode_map[i].code, code) == 0) { |
| 135 return static_cast<DomCode>(usb_keycode_map[i].usb_keycode); |
| 136 } |
| 137 } |
| 138 return DomCode::NONE; |
| 139 } |
| 140 |
| 141 // static |
| 142 const char* KeycodeConverter::DomCodeToCodeString(DomCode dom_code) { |
| 143 return UsbKeycodeToCode(static_cast<uint32_t>(dom_code)); |
| 144 } |
| 145 |
| 146 // static |
| 147 DomKey KeycodeConverter::KeyStringToDomKey(const char* key) { |
| 148 if (!key || !*key) |
| 149 return DomKey::NONE; |
| 150 for (size_t i = 0; i < kDomKeyMapEntries; ++i) { |
| 151 if (dom_key_map[i].string && |
| 152 strcmp(dom_key_map[i].string, key) == 0) { |
| 153 return dom_key_map[i].dom_key; |
| 154 } |
| 155 } |
| 156 return DomKey::NONE; |
| 157 } |
| 158 |
| 159 // static |
| 160 const char* KeycodeConverter::DomKeyToKeyString(DomKey dom_key) { |
| 161 for (size_t i = 0; i < kDomKeyMapEntries; ++i) { |
| 162 if (dom_key_map[i].dom_key == dom_key) |
| 163 return dom_key_map[i].string; |
| 164 } |
| 165 return nullptr; |
| 166 } |
| 167 |
74 // USB keycodes | 168 // USB keycodes |
75 // Note that USB keycodes are not part of any web standard. | 169 // Note that USB keycodes are not part of any web standard. |
76 // Please don't use USB keycodes in new code. | 170 // Please don't use USB keycodes in new code. |
77 | 171 |
78 // static | 172 // static |
79 uint16_t KeycodeConverter::InvalidUsbKeycode() { | 173 uint16_t KeycodeConverter::InvalidUsbKeycode() { |
80 return static_cast<uint16_t>(usb_keycode_map[0].usb_keycode); | 174 return static_cast<uint16_t>(usb_keycode_map[0].usb_keycode); |
81 } | 175 } |
82 | 176 |
83 // static | 177 // static |
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
125 for (size_t i = 0; i < kKeycodeMapEntries; ++i) { | 219 for (size_t i = 0; i < kKeycodeMapEntries; ++i) { |
126 if (usb_keycode_map[i].code && | 220 if (usb_keycode_map[i].code && |
127 strcmp(usb_keycode_map[i].code, code) == 0) { | 221 strcmp(usb_keycode_map[i].code, code) == 0) { |
128 return usb_keycode_map[i].usb_keycode; | 222 return usb_keycode_map[i].usb_keycode; |
129 } | 223 } |
130 } | 224 } |
131 return InvalidUsbKeycode(); | 225 return InvalidUsbKeycode(); |
132 } | 226 } |
133 | 227 |
134 } // namespace ui | 228 } // namespace ui |
OLD | NEW |