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 "base/logging.h" |
| 8 |
7 namespace ui { | 9 namespace ui { |
8 | 10 |
9 namespace { | 11 namespace { |
10 | 12 |
| 13 template<typename T> |
| 14 struct DomKeyCodeEntry { |
| 15 const char *string; |
| 16 T enumeration; |
| 17 }; |
| 18 |
| 19 #include "ui/events/keycodes/dom4/domcode.h" |
| 20 #include "ui/events/keycodes/dom4/domcode_string.h" |
| 21 #include "ui/events/keycodes/dom4/domcode_table.h" |
| 22 #include "ui/events/keycodes/dom4/domkey.h" |
| 23 #include "ui/events/keycodes/dom4/domkey_string.h" |
| 24 #include "ui/events/keycodes/dom4/domkey_table.h" |
| 25 |
11 #if defined(OS_WIN) | 26 #if defined(OS_WIN) |
12 #define USB_KEYMAP(usb, xkb, win, mac, code) {usb, win, code} | 27 #define USB_KEYMAP(usb, xkb, win, mac, code) {usb, win, code} |
13 #elif defined(OS_LINUX) | 28 #elif defined(OS_LINUX) |
14 #define USB_KEYMAP(usb, xkb, win, mac, code) {usb, xkb, code} | 29 #define USB_KEYMAP(usb, xkb, win, mac, code) {usb, xkb, code} |
15 #elif defined(OS_MACOSX) | 30 #elif defined(OS_MACOSX) |
16 #define USB_KEYMAP(usb, xkb, win, mac, code) {usb, mac, code} | 31 #define USB_KEYMAP(usb, xkb, win, mac, code) {usb, mac, code} |
17 #else | 32 #else |
18 #define USB_KEYMAP(usb, xkb, win, mac, code) {usb, 0, code} | 33 #define USB_KEYMAP(usb, xkb, win, mac, code) {usb, 0, code} |
19 #endif | 34 #endif |
20 #include "ui/events/keycodes/dom4/keycode_converter_data.h" | 35 #include "ui/events/keycodes/dom4/native_code_data.h" |
21 | 36 |
22 const size_t kKeycodeMapEntries = arraysize(usb_keycode_map); | 37 const size_t kKeycodeMapEntries = arraysize(usb_keycode_map); |
| 38 const size_t kDomCodeStringTableEntries = arraysize(dom_code_string); |
| 39 const size_t kDomCodeTableEntries = arraysize(dom_code_table); |
| 40 const size_t kDomKeyStringTableEntries = arraysize(dom_key_string); |
| 41 const size_t kDomKeyTableEntries = arraysize(dom_key_table); |
23 | 42 |
24 } // namespace | 43 } // namespace |
25 | 44 |
26 // static | 45 // static |
27 size_t KeycodeConverter::NumKeycodeMapEntriesForTest() { | 46 size_t KeycodeConverter::NumKeycodeMapEntriesForTest() { |
28 return kKeycodeMapEntries; | 47 return kKeycodeMapEntries; |
29 } | 48 } |
30 | 49 |
31 // static | 50 // static |
32 const KeycodeMapEntry* KeycodeConverter::GetKeycodeMapForTest() { | 51 const KeycodeMapEntry* KeycodeConverter::GetKeycodeMapForTest() { |
33 return &usb_keycode_map[0]; | 52 return &usb_keycode_map[0]; |
34 } | 53 } |
35 | 54 |
36 // static | 55 // static |
| 56 size_t KeycodeConverter::NumDomCodeStringEntriesForTest() { |
| 57 return kDomCodeStringTableEntries; |
| 58 } |
| 59 |
| 60 // static |
| 61 const char* const* KeycodeConverter::DomCodeStringTableForTest() { |
| 62 return dom_code_string; |
| 63 } |
| 64 |
| 65 // static |
| 66 size_t KeycodeConverter::NumDomKeyStringEntriesForTest() { |
| 67 return kDomKeyStringTableEntries; |
| 68 } |
| 69 |
| 70 // static |
| 71 const char* const* KeycodeConverter::DomKeyStringTableForTest() { |
| 72 return dom_key_string; |
| 73 } |
| 74 |
| 75 // static |
37 uint16_t KeycodeConverter::InvalidNativeKeycode() { | 76 uint16_t KeycodeConverter::InvalidNativeKeycode() { |
38 return usb_keycode_map[0].native_keycode; | 77 return usb_keycode_map[0].native_keycode; |
39 } | 78 } |
40 | 79 |
41 // static | 80 // static |
42 const char* KeycodeConverter::InvalidKeyboardEventCode() { | 81 const char* KeycodeConverter::InvalidKeyboardEventCode() { |
43 return "Unidentified"; | 82 return dom_code_string[static_cast<size_t>(ui::DOM_CODE_UNIDENTIFIED)]; |
| 83 } |
| 84 |
| 85 // static |
| 86 const char* KeycodeConverter::DomCodeToCodeString(DomCode dom_code) { |
| 87 size_t code = static_cast<size_t>(dom_code); |
| 88 DCHECK_LT(code, kDomCodeStringTableEntries); |
| 89 DCHECK_NE(dom_code_string[code], static_cast<const char*>(nullptr)); |
| 90 return dom_code_string[code]; |
| 91 } |
| 92 |
| 93 // static |
| 94 DomCode KeycodeConverter::CodeStringToDomCode(const char* code) { |
| 95 if (code) { |
| 96 for (size_t i = 0; i < kDomCodeTableEntries; ++i) { |
| 97 if (strcmp(code, dom_code_table[i].string) == 0) |
| 98 return dom_code_table[i].enumeration; |
| 99 } |
| 100 } |
| 101 return DOM_CODE_NONE; |
| 102 } |
| 103 |
| 104 // static |
| 105 DomCode KeycodeConverter::NativeKeycodeToDomCode(uint16_t native_keycode) { |
| 106 for (size_t i = 0; i < kKeycodeMapEntries; ++i) { |
| 107 if (usb_keycode_map[i].native_keycode == native_keycode) |
| 108 return usb_keycode_map[i].code; |
| 109 } |
| 110 return DOM_CODE_NONE; |
| 111 } |
| 112 |
| 113 // static |
| 114 uint16_t KeycodeConverter::DomCodeToNativeKeycode(DomCode code) { |
| 115 for (size_t i = 0; i < kKeycodeMapEntries; ++i) { |
| 116 if (usb_keycode_map[i].code == code) |
| 117 return usb_keycode_map[i].native_keycode; |
| 118 } |
| 119 return InvalidNativeKeycode(); |
44 } | 120 } |
45 | 121 |
46 // static | 122 // static |
47 const char* KeycodeConverter::NativeKeycodeToCode(uint16_t native_keycode) { | 123 const char* KeycodeConverter::NativeKeycodeToCode(uint16_t native_keycode) { |
48 for (size_t i = 0; i < kKeycodeMapEntries; ++i) { | 124 return DomCodeToCodeString(NativeKeycodeToDomCode(native_keycode)); |
49 if (usb_keycode_map[i].native_keycode == native_keycode) { | |
50 if (usb_keycode_map[i].code != NULL) | |
51 return usb_keycode_map[i].code; | |
52 break; | |
53 } | |
54 } | |
55 return InvalidKeyboardEventCode(); | |
56 } | 125 } |
57 | 126 |
58 // static | 127 // static |
59 uint16_t KeycodeConverter::CodeToNativeKeycode(const char* code) { | 128 uint16_t KeycodeConverter::CodeToNativeKeycode(const char* code_string) { |
60 if (!code || | 129 return DomCodeToNativeKeycode(CodeStringToDomCode(code_string)); |
61 strcmp(code, InvalidKeyboardEventCode()) == 0) { | |
62 return InvalidNativeKeycode(); | |
63 } | |
64 | |
65 for (size_t i = 0; i < kKeycodeMapEntries; ++i) { | |
66 if (usb_keycode_map[i].code && | |
67 strcmp(usb_keycode_map[i].code, code) == 0) { | |
68 return usb_keycode_map[i].native_keycode; | |
69 } | |
70 } | |
71 return InvalidNativeKeycode(); | |
72 } | 130 } |
73 | 131 |
74 // USB keycodes | 132 // USB keycodes |
75 // Note that USB keycodes are not part of any web standard. | 133 // Note that USB keycodes are not part of any web standard. |
76 // Please don't use USB keycodes in new code. | 134 // Please don't use USB keycodes in new code. |
77 | 135 |
78 // static | 136 // static |
79 uint16_t KeycodeConverter::InvalidUsbKeycode() { | 137 uint16_t KeycodeConverter::InvalidUsbKeycode() { |
80 return usb_keycode_map[0].usb_keycode; | 138 return usb_keycode_map[0].usb_keycode; |
81 } | 139 } |
(...skipping 21 matching lines...) Expand all Loading... |
103 if (usb_keycode_map[i].native_keycode == native_keycode) | 161 if (usb_keycode_map[i].native_keycode == native_keycode) |
104 return usb_keycode_map[i].usb_keycode; | 162 return usb_keycode_map[i].usb_keycode; |
105 } | 163 } |
106 return InvalidUsbKeycode(); | 164 return InvalidUsbKeycode(); |
107 } | 165 } |
108 | 166 |
109 // static | 167 // static |
110 const char* KeycodeConverter::UsbKeycodeToCode(uint32_t usb_keycode) { | 168 const char* KeycodeConverter::UsbKeycodeToCode(uint32_t usb_keycode) { |
111 for (size_t i = 0; i < kKeycodeMapEntries; ++i) { | 169 for (size_t i = 0; i < kKeycodeMapEntries; ++i) { |
112 if (usb_keycode_map[i].usb_keycode == usb_keycode) | 170 if (usb_keycode_map[i].usb_keycode == usb_keycode) |
113 return usb_keycode_map[i].code; | 171 return DomCodeToCodeString(usb_keycode_map[i].code); |
114 } | 172 } |
115 return InvalidKeyboardEventCode(); | 173 return InvalidKeyboardEventCode(); |
116 } | 174 } |
117 | 175 |
118 // static | 176 // static |
119 uint32_t KeycodeConverter::CodeToUsbKeycode(const char* code) { | 177 uint32_t KeycodeConverter::CodeToUsbKeycode(const char* code_string) { |
120 if (!code || | 178 DomCode code = CodeStringToDomCode(code_string); |
121 strcmp(code, InvalidKeyboardEventCode()) == 0) { | |
122 return InvalidUsbKeycode(); | |
123 } | |
124 | |
125 for (size_t i = 0; i < kKeycodeMapEntries; ++i) { | 179 for (size_t i = 0; i < kKeycodeMapEntries; ++i) { |
126 if (usb_keycode_map[i].code && | 180 if (usb_keycode_map[i].code == code) { |
127 strcmp(usb_keycode_map[i].code, code) == 0) { | |
128 return usb_keycode_map[i].usb_keycode; | 181 return usb_keycode_map[i].usb_keycode; |
129 } | 182 } |
130 } | 183 } |
131 return InvalidUsbKeycode(); | 184 return InvalidUsbKeycode(); |
132 } | 185 } |
133 | 186 |
| 187 // static |
| 188 const char* KeycodeConverter::DomKeyToKeyString(DomKey dom_key) { |
| 189 size_t key = static_cast<size_t>(dom_key); |
| 190 DCHECK_LT(key, kDomKeyStringTableEntries); |
| 191 DCHECK_NE(dom_key_string[key], static_cast<const char*>(nullptr)); |
| 192 return dom_key_string[key]; |
| 193 } |
| 194 |
| 195 // static |
| 196 DomKey KeycodeConverter::KeyStringToDomKey(const char* key) { |
| 197 if (key) { |
| 198 for (size_t i = 0; i < kDomKeyTableEntries; ++i) { |
| 199 if (strcmp(key, dom_key_table[i].string) == 0) |
| 200 return dom_key_table[i].enumeration; |
| 201 } |
| 202 } |
| 203 return DOM_KEY_NONE; |
| 204 } |
| 205 |
134 } // namespace ui | 206 } // namespace ui |
OLD | NEW |