Debian Codegraph @

unikey/inputproc.cpp

raw
1 /*
2 * SPDX-FileCopyrightText: 2000-2005 Pham Kim Long <[email protected]>
3 *
4 * SPDX-License-Identifier: LGPL-2.0-or-later
5 */
6 #include "inputproc.h"
7 #include <array>
8 #include <iostream>
9 #include <unordered_set>
10
11 using namespace std;
12
13 /*
14 unsigned char WordBreakSyms[] = {
15 ',', ';', ':', '.', '\"', '\'', '!', '?', ' ',
16 '<', '>', '=', '+', '-', '*', '/', '\\',
17 '_', '~', '`', '@', '#', '$', '%', '^', '&', '(', ')', '{', '}', '[', ']'};
18 */
19
20 const std::unordered_set<unsigned char> WordBreakSyms = {
21 ',', ';', ':', '.', '\"', '\'', '!', '?', ' ', '<',
22 '>', '=', '+', '-', '*', '/', '\\', '_', '@', '#',
23 '$', '%', '&', '(', ')', '{', '}', '[', ']', '|'}; // we excluded ~, `, ^
24
25 VnLexiName AZLexiUpper[] = {vnl_A, vnl_B, vnl_C, vnl_D, vnl_E, vnl_F, vnl_G,
26 vnl_H, vnl_I, vnl_J, vnl_K, vnl_L, vnl_M, vnl_N,
27 vnl_O, vnl_P, vnl_Q, vnl_R, vnl_S, vnl_T, vnl_U,
28 vnl_V, vnl_W, vnl_X, vnl_Y, vnl_Z};
29
30 VnLexiName AZLexiLower[] = {vnl_a, vnl_b, vnl_c, vnl_d, vnl_e, vnl_f, vnl_g,
31 vnl_h, vnl_i, vnl_j, vnl_k, vnl_l, vnl_m, vnl_n,
32 vnl_o, vnl_p, vnl_q, vnl_r, vnl_s, vnl_t, vnl_u,
33 vnl_v, vnl_w, vnl_x, vnl_y, vnl_z};
34
35 UkCharType UkcMap[256];
36
37 struct _ascVnLexi {
38 int asc;
39 VnLexiName lexi;
40 };
41
42 // List of western characters outside range A-Z that are
43 // also Vietnamese characters
44 _ascVnLexi AscVnLexiList[] = {
45 {0xC0, vnl_A2}, {0xC1, vnl_A1}, {0xC2, vnl_Ar}, {0xC2, vnl_A4},
46 {0xC8, vnl_E2}, {0xC9, vnl_E1}, {0xCA, vnl_Er}, {0xCC, vnl_I2},
47 {0xCD, vnl_I1}, {0xD2, vnl_O2}, {0xD3, vnl_O1}, {0xD4, vnl_Or},
48 {0xD5, vnl_O4}, {0xD9, vnl_U2}, {0xDA, vnl_U1}, {0xDD, vnl_Y1},
49 {0xE0, vnl_a2}, {0xE1, vnl_a1}, {0xE2, vnl_ar}, {0xE3, vnl_a4},
50 {0xE8, vnl_e2}, {0xE9, vnl_e1}, {0xEA, vnl_er}, {0xEC, vnl_i2},
51 {0xED, vnl_i1}, {0xF2, vnl_o2}, {0xF3, vnl_o1}, {0xF4, vnl_or},
52 {0xF5, vnl_o4}, {0xF9, vnl_u2}, {0xFA, vnl_u1}, {0xFD, vnl_y1},
53 {0x00, vnl_nonVnChar}};
54
55 VnLexiName IsoVnLexiMap[256];
56
57 bool ClassifierTableInitialized = false;
58
59 DllExport UkKeyMapping TelexMethodMapping[] = {{'Z', vneTone0},
60 {'S', vneTone1},
61 {'F', vneTone2},
62 {'R', vneTone3},
63 {'X', vneTone4},
64 {'J', vneTone5},
65 {'W', vne_telex_w},
66 {'A', vneRoof_a},
67 {'E', vneRoof_e},
68 {'O', vneRoof_o},
69 {'D', vneDd},
70 {'[', vneCount + vnl_oh},
71 {']', vneCount + vnl_uh},
72 {'{', vneCount + vnl_Oh},
73 {'}', vneCount + vnl_Uh},
74 {0, vneNormal}};
75
76 DllExport UkKeyMapping SimpleTelexMethodMapping[] = {
77 {'Z', vneTone0}, {'S', vneTone1}, {'F', vneTone2}, {'R', vneTone3},
78 {'X', vneTone4}, {'J', vneTone5}, {'W', vneHookAll}, {'A', vneRoof_a},
79 {'E', vneRoof_e}, {'O', vneRoof_o}, {'D', vneDd}, {0, vneNormal}};
80
81 DllExport UkKeyMapping SimpleTelex2MethodMapping[] = {
82 {'Z', vneTone0}, {'S', vneTone1}, {'F', vneTone2}, {'R', vneTone3},
83 {'X', vneTone4}, {'J', vneTone5}, {'W', vne_telex_w}, {'A', vneRoof_a},
84 {'E', vneRoof_e}, {'O', vneRoof_o}, {'D', vneDd}, {0, vneNormal}};
85
86 DllExport UkKeyMapping VniMethodMapping[] = {
87 {'0', vneTone0}, {'1', vneTone1}, {'2', vneTone2}, {'3', vneTone3},
88 {'4', vneTone4}, {'5', vneTone5}, {'6', vneRoofAll}, {'7', vneHook_uo},
89 {'8', vneBowl}, {'9', vneDd}, {0, vneNormal}};
90
91 DllExport UkKeyMapping VIQRMethodMapping[] = {
92 {'0', vneTone0}, {'\'', vneTone1}, {'`', vneTone2}, {'?', vneTone3},
93 {'~', vneTone4}, {'.', vneTone5}, {'^', vneRoofAll}, {'+', vneHook_uo},
94 {'*', vneHook_uo}, {'(', vneBowl}, {'D', vneDd}, {'\\', vneEscChar},
95 {0, vneNormal}};
96
97 DllExport UkKeyMapping MsViMethodMapping[] = {{'5', vneTone2},
98 {'%', vneTone2},
99 {'6', vneTone3},
100 {'^', vneTone3},
101 {'7', vneTone4},
102 {'&', vneTone4},
103 {'8', vneTone1},
104 {'*', vneTone1},
105 {'9', vneTone5},
106 {'(', vneTone5},
107 {'1', vneCount + vnl_ab},
108 {'!', vneCount + vnl_Ab},
109 {'2', vneCount + vnl_ar},
110 {'@', vneCount + vnl_Ar},
111 {'3', vneCount + vnl_er},
112 {'#', vneCount + vnl_Er},
113 {'4', vneCount + vnl_or},
114 {'$', vneCount + vnl_Or},
115 {'0', vneCount + vnl_dd},
116 {')', vneCount + vnl_DD},
117 {'[', vneCount + vnl_uh},
118 {']', vneCount + vnl_oh},
119 {'{', vneCount + vnl_Uh},
120 {'}', vneCount + vnl_Oh},
121 {0, vneNormal}};
122
123 //-------------------------------------------
124 void SetupInputClassifierTable() {
125 if (!ClassifierTableInitialized) {
126 ClassifierTableInitialized = true;
127 }
128 unsigned int c;
129 int i;
130
131 for (c = 0; c <= 32; c++) {
132 UkcMap[c] = ukcReset;
133 }
134
135 for (c = 33; c < 256; c++) {
136 UkcMap[c] = ukcNonVn;
137 }
138
139 /*
140 for (c = '0'; c <= '9'; c++)
141 UkcMap[c] = ukcNonVn;
142 */
143
144 for (c = 'a'; c <= 'z'; c++)
145 UkcMap[c] = ukcVn;
146 for (c = 'A'; c <= 'Z'; c++)
147 UkcMap[c] = ukcVn;
148
149 for (i = 0; AscVnLexiList[i].asc; i++) {
150 UkcMap[AscVnLexiList[i].asc] = ukcVn;
151 }
152
153 UkcMap[(unsigned char)'j'] = ukcNonVn;
154 UkcMap[(unsigned char)'J'] = ukcNonVn;
155 UkcMap[(unsigned char)'f'] = ukcNonVn;
156 UkcMap[(unsigned char)'F'] = ukcNonVn;
157 UkcMap[(unsigned char)'w'] = ukcNonVn;
158 UkcMap[(unsigned char)'W'] = ukcNonVn;
159
160 for (auto wordBreakSym : WordBreakSyms)
161 UkcMap[wordBreakSym] = ukcWordBreak;
162
163 // Calculate IsoVnLexiMap
164 for (i = 0; i < 256; i++) {
165 IsoVnLexiMap[i] = vnl_nonVnChar;
166 }
167
168 for (i = 0; AscVnLexiList[i].asc; i++) {
169 IsoVnLexiMap[AscVnLexiList[i].asc] = AscVnLexiList[i].lexi;
170 }
171
172 for (c = 'a'; c <= 'z'; c++) {
173 IsoVnLexiMap[c] = AZLexiLower[c - 'a'];
174 }
175
176 for (c = 'A'; c <= 'Z'; c++) {
177 IsoVnLexiMap[c] = AZLexiUpper[c - 'A'];
178 }
179 }
180
181 //-------------------------------------------
182 void UkInputProcessor::init() {
183 SetupInputClassifierTable();
184 setIM(UkTelex);
185 }
186
187 //-------------------------------------------
188 int UkInputProcessor::setIM(UkInputMethod im) {
189 m_im = im;
190 switch (im) {
191 case UkTelex:
192 useBuiltIn(TelexMethodMapping);
193 break;
194 case UkSimpleTelex:
195 useBuiltIn(SimpleTelexMethodMapping);
196 break;
197 case UkSimpleTelex2:
198 useBuiltIn(SimpleTelex2MethodMapping);
199 break;
200 case UkVni:
201 useBuiltIn(VniMethodMapping);
202 break;
203 case UkViqr:
204 useBuiltIn(VIQRMethodMapping);
205 break;
206 case UkMsVi:
207 useBuiltIn(MsViMethodMapping);
208 break;
209 default:
210 m_im = UkTelex;
211 useBuiltIn(TelexMethodMapping);
212 }
213 return 1;
214 }
215
216 //-------------------------------------------
217 int UkInputProcessor::setIM(int map[256]) {
218 int i;
219 m_im = UkUsrIM;
220 for (i = 0; i < 256; i++)
221 m_keyMap[i] = map[i];
222 return 1;
223 }
224
225 //-------------------------------------------
226 void UkResetKeyMap(int keyMap[256]) {
227 unsigned int c;
228 for (c = 0; c < 256; c++)
229 keyMap[c] = vneNormal;
230 }
231
232 //-------------------------------------------
233 void UkInputProcessor::useBuiltIn(UkKeyMapping *map) {
234 UkResetKeyMap(m_keyMap);
235 for (int i = 0; map[i].key; i++) {
236 m_keyMap[map[i].key] = map[i].action;
237 if (map[i].action < vneCount) {
238 if (islower(map[i].key)) {
239 m_keyMap[toupper(map[i].key)] = map[i].action;
240 } else if (isupper(map[i].key)) {
241 m_keyMap[tolower(map[i].key)] = map[i].action;
242 }
243 }
244 }
245 }
246
247 //-------------------------------------------
248 void UkInputProcessor::keyCodeToEvent(unsigned int keyCode, UkKeyEvent &ev) {
249 ev.keyCode = keyCode;
250 if (keyCode == 0) {
251 ev.evType = vneNormal;
252 ev.vnSym = vnl_nonVnChar;
253 ev.chType = ukcWordBreak;
254 } else if (keyCode > 255) {
255 ev.evType = vneNormal;
256 ev.vnSym = IsoToVnLexi(keyCode);
257 ev.chType = (ev.vnSym == vnl_nonVnChar) ? ukcNonVn : ukcVn;
258 } else {
259 ev.chType = UkcMap[keyCode];
260 ev.evType = m_keyMap[keyCode];
261
262 if (ev.evType >= vneTone0 && ev.evType <= vneTone5) {
263 ev.tone = ev.evType - vneTone0;
264 }
265
266 if (ev.evType >= vneCount) {
267 ev.chType = ukcVn;
268 ev.vnSym = (VnLexiName)(ev.evType - vneCount);
269 ev.evType = vneMapChar;
270 } else {
271 ev.vnSym = IsoToVnLexi(keyCode);
272 }
273 }
274 }
275
276 //----------------------------------------------------------------
277 // This method translates a key stroke to a symbol.
278 // Key strokes are simply considered character input, not action keys as in
279 // keyCodeToEvent method
280 //----------------------------------------------------------------
281 void UkInputProcessor::keyCodeToSymbol(unsigned int keyCode, UkKeyEvent &ev) {
282 ev.keyCode = keyCode;
283 ev.evType = vneNormal;
284 ev.vnSym = IsoToVnLexi(keyCode);
285 if (keyCode > 255) {
286 ev.chType = (ev.vnSym == vnl_nonVnChar) ? ukcNonVn : ukcVn;
287 } else {
288 ev.chType = UkcMap[keyCode];
289 }
290 }
291
292 //-------------------------------------------
293 UkCharType UkInputProcessor::getCharType(unsigned int keyCode) const {
294 if (keyCode > 255)
295 return (IsoToVnLexi(keyCode) == vnl_nonVnChar) ? ukcNonVn : ukcVn;
296 return UkcMap[keyCode];
297 }
298
299 //-------------------------------------------
300 void UkInputProcessor::getKeyMap(int map[256]) const {
301 int i;
302 for (i = 0; i < 256; i++)
303 map[i] = m_keyMap[i];
304 }