Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(905)

Side by Side Diff: ui/events/keycodes/dom4/keycode_converter.cc

Issue 641753003: DOM Level 3 .code and .key value enumerations. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Created 6 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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
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
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698