Diffstat (limited to 'noncore/apps/opie-console/keytrans.cpp') (more/less context) (show whitespace changes)
-rw-r--r-- | noncore/apps/opie-console/keytrans.cpp | 706 |
1 files changed, 706 insertions, 0 deletions
diff --git a/noncore/apps/opie-console/keytrans.cpp b/noncore/apps/opie-console/keytrans.cpp new file mode 100644 index 0000000..d569ae0 --- a/dev/null +++ b/noncore/apps/opie-console/keytrans.cpp | |||
@@ -0,0 +1,706 @@ | |||
1 | /* -------------------------------------------------------------------------- */ | ||
2 | /* */ | ||
3 | /* [keytrans.C] Keyboard Translation */ | ||
4 | /* */ | ||
5 | /* -------------------------------------------------------------------------- */ | ||
6 | /* */ | ||
7 | /* Copyright (c) 1997,1998 by Lars Doelle <lars.doelle@on-line.de> */ | ||
8 | /* */ | ||
9 | /* This file is part of Konsole - an X terminal for KDE */ | ||
10 | /* */ | ||
11 | /* -------------------------------------------------------------------------- */ | ||
12 | /* */ | ||
13 | /* Ported Konsole to Qt/Embedded */ | ||
14 | /* */ | ||
15 | /* Copyright (C) 2000 by John Ryland <jryland@trolltech.com> */ | ||
16 | /* */ | ||
17 | /* -------------------------------------------------------------------------- */ | ||
18 | |||
19 | /* | ||
20 | The keyboard translation table allows to configure konsoles behavior | ||
21 | on key strokes. | ||
22 | |||
23 | FIXME: some bug crept in, disallowing '\0' to be emitted. | ||
24 | */ | ||
25 | |||
26 | #include "keytrans.h" | ||
27 | |||
28 | #include <qpe/qpeapplication.h> | ||
29 | |||
30 | #include <qnamespace.h> | ||
31 | #include <qbuffer.h> | ||
32 | #include <qobject.h> | ||
33 | #include <qdict.h> | ||
34 | #include <qintdict.h> | ||
35 | #include <qfile.h> | ||
36 | #include <qglobal.h> | ||
37 | #include <qdir.h> | ||
38 | |||
39 | //#include <kstddirs.h> | ||
40 | //nclude <klocale.h> | ||
41 | |||
42 | #include <stdio.h> | ||
43 | |||
44 | |||
45 | #undef USE_APPDATA_DIR | ||
46 | |||
47 | |||
48 | #define HERE printf("%s(%d): here\n",__FILE__,__LINE__) | ||
49 | |||
50 | /* KeyEntry | ||
51 | |||
52 | instances represent the individual assignments | ||
53 | */ | ||
54 | |||
55 | KeyTrans::KeyEntry::KeyEntry(int _ref, int _key, int _bits, int _mask, int _cmd, QString _txt) | ||
56 | : ref(_ref), key(_key), bits(_bits), mask(_mask), cmd(_cmd), txt(_txt) | ||
57 | { | ||
58 | } | ||
59 | |||
60 | KeyTrans::KeyEntry::~KeyEntry() | ||
61 | { | ||
62 | } | ||
63 | |||
64 | bool KeyTrans::KeyEntry::matches(int _key, int _bits, int _mask) | ||
65 | { int m = mask & _mask; | ||
66 | return _key == key && (bits & m) == (_bits & m); | ||
67 | } | ||
68 | |||
69 | QString KeyTrans::KeyEntry::text() | ||
70 | { | ||
71 | return txt; | ||
72 | } | ||
73 | |||
74 | /* KeyTrans | ||
75 | |||
76 | combines the individual assignments to a proper map | ||
77 | Takes part in a collection themself. | ||
78 | */ | ||
79 | |||
80 | KeyTrans::KeyTrans() | ||
81 | { | ||
82 | path = ""; | ||
83 | numb = 0; | ||
84 | } | ||
85 | |||
86 | KeyTrans::~KeyTrans() | ||
87 | { | ||
88 | } | ||
89 | |||
90 | KeyTrans::KeyEntry* KeyTrans::addEntry(int ref, int key, int bits, int mask, int cmd, QString txt) | ||
91 | // returns conflicting entry | ||
92 | { | ||
93 | for (QListIterator<KeyEntry> it(table); it.current(); ++it) | ||
94 | { | ||
95 | if (it.current()->matches(key,bits,mask)) | ||
96 | { | ||
97 | return it.current(); | ||
98 | } | ||
99 | } | ||
100 | table.append(new KeyEntry(ref,key,bits,mask,cmd,txt)); | ||
101 | return (KeyEntry*)NULL; | ||
102 | } | ||
103 | |||
104 | bool KeyTrans::findEntry(int key, int bits, int* cmd, const char** txt, int* len) | ||
105 | { | ||
106 | for (QListIterator<KeyEntry> it(table); it.current(); ++it) | ||
107 | if (it.current()->matches(key,bits,0xffff)) | ||
108 | { | ||
109 | *cmd = it.current()->cmd; | ||
110 | *txt = it.current()->txt.ascii(); | ||
111 | *len = it.current()->txt.length(); | ||
112 | return TRUE; | ||
113 | } | ||
114 | return FALSE; | ||
115 | } | ||
116 | |||
117 | /* ------------------------------------------------------------------------- */ | ||
118 | /* */ | ||
119 | /* Scanner for keyboard configuration */ | ||
120 | /* */ | ||
121 | /* ------------------------------------------------------------------------- */ | ||
122 | |||
123 | // regular tokenizer | ||
124 | /* Tokens | ||
125 | - Spaces | ||
126 | - Name (A-Za-z0-9)+ | ||
127 | - String | ||
128 | - Opr on of +-: | ||
129 | */ | ||
130 | |||
131 | #define SYMName 0 | ||
132 | #define SYMString 1 | ||
133 | #define SYMEol 2 | ||
134 | #define SYMEof 3 | ||
135 | #define SYMOpr 4 | ||
136 | #define SYMError 5 | ||
137 | |||
138 | #define inRange(L,X,H) ((L <= X) && (X <= H)) | ||
139 | #define isNibble(X) (inRange('A',X,'F')||inRange('a',X,'f')||inRange('0',X,'9')) | ||
140 | #define convNibble(X) (inRange('0',X,'9')?X-'0':X+10-(inRange('A',X,'F')?'A':'a')) | ||
141 | |||
142 | class KeytabReader | ||
143 | { | ||
144 | public: | ||
145 | KeytabReader(QString p, QIODevice &d); | ||
146 | public: | ||
147 | void getCc(); | ||
148 | void getSymbol(); | ||
149 | void parseTo(KeyTrans* kt); | ||
150 | void ReportError(const char* msg); | ||
151 | void ReportToken(); // diagnostic | ||
152 | private: | ||
153 | int sym; | ||
154 | QString res; | ||
155 | int len; | ||
156 | int slinno; | ||
157 | int scolno; | ||
158 | private: | ||
159 | int cc; | ||
160 | int linno; | ||
161 | int colno; | ||
162 | QIODevice* buf; | ||
163 | QString path; | ||
164 | }; | ||
165 | |||
166 | |||
167 | KeytabReader::KeytabReader(QString p, QIODevice &d) | ||
168 | { | ||
169 | path = p; | ||
170 | buf = &d; | ||
171 | cc = 0; | ||
172 | } | ||
173 | |||
174 | void KeytabReader::getCc() | ||
175 | { | ||
176 | if (cc == '\n') { linno += 1; colno = 0; } | ||
177 | if (cc < 0) return; | ||
178 | cc = buf->getch(); | ||
179 | colno += 1; | ||
180 | } | ||
181 | |||
182 | void KeytabReader::getSymbol() | ||
183 | { | ||
184 | res = ""; len = 0; sym = SYMError; | ||
185 | while (cc == ' ') getCc(); // skip spaces | ||
186 | if (cc == '#') // skip comment | ||
187 | { | ||
188 | while (cc != '\n' && cc > 0) getCc(); | ||
189 | } | ||
190 | slinno = linno; | ||
191 | scolno = colno; | ||
192 | if (cc <= 0) | ||
193 | { | ||
194 | sym = SYMEof; return; // eos | ||
195 | } | ||
196 | if (cc == '\n') | ||
197 | { | ||
198 | getCc(); | ||
199 | sym = SYMEol; return; // eol | ||
200 | } | ||
201 | if (inRange('A',cc,'Z')||inRange('a',cc,'z')||inRange('0',cc,'9')) | ||
202 | { | ||
203 | while (inRange('A',cc,'Z') || inRange('a',cc,'z') || inRange('0',cc,'9')) | ||
204 | { | ||
205 | res = res + (char)cc; | ||
206 | getCc(); | ||
207 | } | ||
208 | sym = SYMName; | ||
209 | return; | ||
210 | } | ||
211 | if (strchr("+-:",cc)) | ||
212 | { | ||
213 | res = ""; | ||
214 | res = res + (char)cc; | ||
215 | getCc(); | ||
216 | sym = SYMOpr; return; | ||
217 | } | ||
218 | if (cc == '"') | ||
219 | { | ||
220 | getCc(); | ||
221 | while (cc >= ' ' && cc != '"') | ||
222 | { int sc; | ||
223 | if (cc == '\\') // handle quotation | ||
224 | { | ||
225 | getCc(); | ||
226 | switch (cc) | ||
227 | { | ||
228 | case 'E' : sc = 27; getCc(); break; | ||
229 | case 'b' : sc = 8; getCc(); break; | ||
230 | case 'f' : sc = 12; getCc(); break; | ||
231 | case 't' : sc = 9; getCc(); break; | ||
232 | case 'r' : sc = 13; getCc(); break; | ||
233 | case 'n' : sc = 10; getCc(); break; | ||
234 | case '\\' : // fall thru | ||
235 | case '"' : sc = cc; getCc(); break; | ||
236 | case 'x' : getCc(); | ||
237 | sc = 0; | ||
238 | if (!isNibble(cc)) return; sc = 16*sc + convNibble(cc); getCc(); | ||
239 | if (!isNibble(cc)) return; sc = 16*sc + convNibble(cc); getCc(); | ||
240 | break; | ||
241 | default : return; | ||
242 | } | ||
243 | } | ||
244 | else | ||
245 | { | ||
246 | // regular char | ||
247 | sc = cc; getCc(); | ||
248 | } | ||
249 | res = res + (char)sc; | ||
250 | len = len + 1; | ||
251 | } | ||
252 | if (cc != '"') return; | ||
253 | getCc(); | ||
254 | sym = SYMString; return; | ||
255 | } | ||
256 | } | ||
257 | |||
258 | void KeytabReader::ReportToken() // diagnostic | ||
259 | { | ||
260 | printf("sym(%d): ",slinno); | ||
261 | switch(sym) | ||
262 | { | ||
263 | case SYMEol : printf("End of line"); break; | ||
264 | case SYMEof : printf("End of file"); break; | ||
265 | case SYMName : printf("Name: %s",res.latin1()); break; | ||
266 | case SYMOpr : printf("Opr : %s",res.latin1()); break; | ||
267 | case SYMString : printf("String len %d,%d ",res.length(),len); | ||
268 | for (unsigned i = 0; i < res.length(); i++) | ||
269 | printf(" %02x(%c)",res.latin1()[i],res.latin1()[i]>=' '?res.latin1()[i]:'?'); | ||
270 | break; | ||
271 | } | ||
272 | printf("\n"); | ||
273 | } | ||
274 | |||
275 | void KeytabReader::ReportError(const char* msg) // diagnostic | ||
276 | { | ||
277 | fprintf(stderr,"%s(%d,%d):error: %s.\n",path.ascii(),slinno,scolno,msg); | ||
278 | } | ||
279 | |||
280 | // local symbol tables --------------------------------------------------------------------- | ||
281 | |||
282 | class KeyTransSymbols | ||
283 | { | ||
284 | public: | ||
285 | KeyTransSymbols(); | ||
286 | protected: | ||
287 | void defOprSyms(); | ||
288 | void defModSyms(); | ||
289 | void defKeySyms(); | ||
290 | void defKeySym(const char* key, int val); | ||
291 | void defOprSym(const char* key, int val); | ||
292 | void defModSym(const char* key, int val); | ||
293 | public: | ||
294 | QDict<QObject> keysyms; | ||
295 | QDict<QObject> modsyms; | ||
296 | QDict<QObject> oprsyms; | ||
297 | }; | ||
298 | |||
299 | static KeyTransSymbols * syms = 0L; | ||
300 | |||
301 | // parser ---------------------------------------------------------------------------------- | ||
302 | /* Syntax | ||
303 | - Line :: [KeyName { ("+" | "-") ModeName } ":" (String|CommandName)] "\n" | ||
304 | - Comment :: '#' (any but \n)* | ||
305 | */ | ||
306 | |||
307 | KeyTrans* KeyTrans::fromDevice(QString path, QIODevice &buf) | ||
308 | { | ||
309 | KeyTrans* kt = new KeyTrans; | ||
310 | kt->path = path; | ||
311 | KeytabReader ktr(path,buf); ktr.parseTo(kt); | ||
312 | return kt; | ||
313 | } | ||
314 | |||
315 | |||
316 | #define assertSyntax(Cond,Message) if (!(Cond)) { ReportError(Message); goto ERROR; } | ||
317 | |||
318 | void KeytabReader::parseTo(KeyTrans* kt) | ||
319 | { | ||
320 | // Opening sequence | ||
321 | |||
322 | buf->open(IO_ReadOnly); | ||
323 | getCc(); | ||
324 | linno = 1; | ||
325 | colno = 1; | ||
326 | getSymbol(); | ||
327 | |||
328 | Loop: | ||
329 | // syntax: ["key" KeyName { ("+" | "-") ModeName } ":" String/CommandName] ["#" Comment] | ||
330 | if (sym == SYMName && !strcmp(res.latin1(),"keyboard")) | ||
331 | { | ||
332 | getSymbol(); assertSyntax(sym == SYMString, "Header expected") | ||
333 | kt->hdr = res.latin1(); | ||
334 | getSymbol(); assertSyntax(sym == SYMEol, "Text unexpected") | ||
335 | getSymbol(); // eoln | ||
336 | goto Loop; | ||
337 | } | ||
338 | if (sym == SYMName && !strcmp(res.latin1(),"key")) | ||
339 | { | ||
340 | //printf("line %3d: ",startofsym); | ||
341 | getSymbol(); assertSyntax(sym == SYMName, "Name expected") | ||
342 | assertSyntax(syms->keysyms[res], "Unknown key name") | ||
343 | int key = (int)syms->keysyms[res]-1; | ||
344 | //printf(" key %s (%04x)",res.latin1(),(int)syms->keysyms[res]-1); | ||
345 | getSymbol(); // + - : | ||
346 | int mode = 0; | ||
347 | int mask = 0; | ||
348 | while (sym == SYMOpr && (!strcmp(res.latin1(),"+") || !strcmp(res.latin1(),"-"))) | ||
349 | { | ||
350 | bool on = !strcmp(res.latin1(),"+"); | ||
351 | getSymbol(); | ||
352 | // mode name | ||
353 | assertSyntax(sym == SYMName, "Name expected") | ||
354 | assertSyntax(syms->modsyms[res], "Unknown mode name") | ||
355 | int bits = (int)syms->modsyms[res]-1; | ||
356 | if (mask & (1 << bits)) | ||
357 | { | ||
358 | fprintf(stderr,"%s(%d,%d): mode name used multible times.\n",path.ascii(),slinno,scolno); | ||
359 | } | ||
360 | else | ||
361 | { | ||
362 | mode |= (on << bits); | ||
363 | mask |= (1 << bits); | ||
364 | } | ||
365 | //printf(", mode %s(%d) %s",res.latin1(),(int)syms->modsyms[res]-1,on?"on":"off"); | ||
366 | getSymbol(); | ||
367 | } | ||
368 | assertSyntax(sym == SYMOpr && !strcmp(res.latin1(),":"), "':' expected") | ||
369 | getSymbol(); | ||
370 | // string or command | ||
371 | assertSyntax(sym == SYMName || sym == SYMString,"Command or string expected") | ||
372 | int cmd = 0; | ||
373 | if (sym == SYMName) | ||
374 | { | ||
375 | assertSyntax(syms->oprsyms[res], "Unknown operator name") | ||
376 | cmd = (int)syms->oprsyms[res]-1; | ||
377 | //printf(": do %s(%d)",res.latin1(),(int)syms->oprsyms[res]-1); | ||
378 | } | ||
379 | if (sym == SYMString) | ||
380 | { | ||
381 | cmd = CMD_send; | ||
382 | //printf(": send"); | ||
383 | //for (unsigned i = 0; i < res.length(); i++) | ||
384 | //printf(" %02x(%c)",res.latin1()[i],res.latin1()[i]>=' '?res.latin1()[i]:'?'); | ||
385 | } | ||
386 | //printf(". summary %04x,%02x,%02x,%d\n",key,mode,mask,cmd); | ||
387 | KeyTrans::KeyEntry* ke = kt->addEntry(slinno,key,mode,mask,cmd,res); | ||
388 | if (ke) | ||
389 | { | ||
390 | fprintf(stderr,"%s(%d): keystroke already assigned in line %d.\n",path.ascii(),slinno,ke->ref); | ||
391 | } | ||
392 | getSymbol(); | ||
393 | assertSyntax(sym == SYMEol, "Unexpected text") | ||
394 | goto Loop; | ||
395 | } | ||
396 | if (sym == SYMEol) | ||
397 | { | ||
398 | getSymbol(); | ||
399 | goto Loop; | ||
400 | } | ||
401 | |||
402 | assertSyntax(sym == SYMEof, "Undecodable Line") | ||
403 | |||
404 | buf->close(); | ||
405 | return; | ||
406 | |||
407 | ERROR: | ||
408 | while (sym != SYMEol && sym != SYMEof) getSymbol(); // eoln | ||
409 | goto Loop; | ||
410 | } | ||
411 | |||
412 | |||
413 | KeyTrans* KeyTrans::defaultKeyTrans() | ||
414 | { | ||
415 | QCString txt = | ||
416 | #include "default.keytab.h" | ||
417 | ; | ||
418 | QBuffer buf(txt); | ||
419 | return fromDevice("[buildin]",buf); | ||
420 | } | ||
421 | |||
422 | KeyTrans* KeyTrans::fromFile(const char* path) | ||
423 | { | ||
424 | QFile file(path); | ||
425 | return fromDevice(path,file); | ||
426 | } | ||
427 | |||
428 | // local symbol tables --------------------------------------------------------------------- | ||
429 | // material needed for parsing the config file. | ||
430 | // This is incomplete work. | ||
431 | |||
432 | void KeyTransSymbols::defKeySym(const char* key, int val) | ||
433 | { | ||
434 | keysyms.insert(key,(QObject*)(val+1)); | ||
435 | } | ||
436 | |||
437 | void KeyTransSymbols::defOprSym(const char* key, int val) | ||
438 | { | ||
439 | oprsyms.insert(key,(QObject*)(val+1)); | ||
440 | } | ||
441 | |||
442 | void KeyTransSymbols::defModSym(const char* key, int val) | ||
443 | { | ||
444 | modsyms.insert(key,(QObject*)(val+1)); | ||
445 | } | ||
446 | |||
447 | void KeyTransSymbols::defOprSyms() | ||
448 | { | ||
449 | // Modifier | ||
450 | defOprSym("scrollLineUp", CMD_scrollLineUp ); | ||
451 | defOprSym("scrollLineDown",CMD_scrollLineDown); | ||
452 | defOprSym("scrollPageUp", CMD_scrollPageUp ); | ||
453 | defOprSym("scrollPageDown",CMD_scrollPageDown); | ||
454 | defOprSym("emitSelection", CMD_emitSelection ); | ||
455 | defOprSym("prevSession", CMD_prevSession ); | ||
456 | defOprSym("nextSession", CMD_nextSession ); | ||
457 | } | ||
458 | |||
459 | void KeyTransSymbols::defModSyms() | ||
460 | { | ||
461 | // Modifier | ||
462 | defModSym("Shift", BITS_Shift ); | ||
463 | defModSym("Control", BITS_Control ); | ||
464 | defModSym("Alt", BITS_Alt ); | ||
465 | // Modes | ||
466 | defModSym("BsHack", BITS_BsHack ); // deprecated | ||
467 | defModSym("Ansi", BITS_Ansi ); | ||
468 | defModSym("NewLine", BITS_NewLine ); | ||
469 | defModSym("AppCuKeys", BITS_AppCuKeys ); | ||
470 | } | ||
471 | |||
472 | void KeyTransSymbols::defKeySyms() | ||
473 | { | ||
474 | // Grey keys | ||
475 | defKeySym("Escape", Qt::Key_Escape ); | ||
476 | defKeySym("Tab", Qt::Key_Tab ); | ||
477 | defKeySym("Backtab", Qt::Key_Backtab ); | ||
478 | defKeySym("Backspace", Qt::Key_Backspace ); | ||
479 | defKeySym("Return", Qt::Key_Return ); | ||
480 | defKeySym("Enter", Qt::Key_Enter ); | ||
481 | defKeySym("Insert", Qt::Key_Insert ); | ||
482 | defKeySym("Delete", Qt::Key_Delete ); | ||
483 | defKeySym("Pause", Qt::Key_Pause ); | ||
484 | defKeySym("Print", Qt::Key_Print ); | ||
485 | defKeySym("SysReq", Qt::Key_SysReq ); | ||
486 | defKeySym("Home", Qt::Key_Home ); | ||
487 | defKeySym("End", Qt::Key_End ); | ||
488 | defKeySym("Left", Qt::Key_Left ); | ||
489 | defKeySym("Up", Qt::Key_Up ); | ||
490 | defKeySym("Right", Qt::Key_Right ); | ||
491 | defKeySym("Down", Qt::Key_Down ); | ||
492 | defKeySym("Prior", Qt::Key_Prior ); | ||
493 | defKeySym("Next", Qt::Key_Next ); | ||
494 | defKeySym("Shift", Qt::Key_Shift ); | ||
495 | defKeySym("Control", Qt::Key_Control ); | ||
496 | defKeySym("Meta", Qt::Key_Meta ); | ||
497 | defKeySym("Alt", Qt::Key_Alt ); | ||
498 | defKeySym("CapsLock", Qt::Key_CapsLock ); | ||
499 | defKeySym("NumLock", Qt::Key_NumLock ); | ||
500 | defKeySym("ScrollLock", Qt::Key_ScrollLock ); | ||
501 | defKeySym("F1", Qt::Key_F1 ); | ||
502 | defKeySym("F2", Qt::Key_F2 ); | ||
503 | defKeySym("F3", Qt::Key_F3 ); | ||
504 | defKeySym("F4", Qt::Key_F4 ); | ||
505 | defKeySym("F5", Qt::Key_F5 ); | ||
506 | defKeySym("F6", Qt::Key_F6 ); | ||
507 | defKeySym("F7", Qt::Key_F7 ); | ||
508 | defKeySym("F8", Qt::Key_F8 ); | ||
509 | defKeySym("F9", Qt::Key_F9 ); | ||
510 | defKeySym("F10", Qt::Key_F10 ); | ||
511 | defKeySym("F11", Qt::Key_F11 ); | ||
512 | defKeySym("F12", Qt::Key_F12 ); | ||
513 | defKeySym("F13", Qt::Key_F13 ); | ||
514 | defKeySym("F14", Qt::Key_F14 ); | ||
515 | defKeySym("F15", Qt::Key_F15 ); | ||
516 | defKeySym("F16", Qt::Key_F16 ); | ||
517 | defKeySym("F17", Qt::Key_F17 ); | ||
518 | defKeySym("F18", Qt::Key_F18 ); | ||
519 | defKeySym("F19", Qt::Key_F19 ); | ||
520 | defKeySym("F20", Qt::Key_F20 ); | ||
521 | defKeySym("F21", Qt::Key_F21 ); | ||
522 | defKeySym("F22", Qt::Key_F22 ); | ||
523 | defKeySym("F23", Qt::Key_F23 ); | ||
524 | defKeySym("F24", Qt::Key_F24 ); | ||
525 | defKeySym("F25", Qt::Key_F25 ); | ||
526 | defKeySym("F26", Qt::Key_F26 ); | ||
527 | defKeySym("F27", Qt::Key_F27 ); | ||
528 | defKeySym("F28", Qt::Key_F28 ); | ||
529 | defKeySym("F29", Qt::Key_F29 ); | ||
530 | defKeySym("F30", Qt::Key_F30 ); | ||
531 | defKeySym("F31", Qt::Key_F31 ); | ||
532 | defKeySym("F32", Qt::Key_F32 ); | ||
533 | defKeySym("F33", Qt::Key_F33 ); | ||
534 | defKeySym("F34", Qt::Key_F34 ); | ||
535 | defKeySym("F35", Qt::Key_F35 ); | ||
536 | defKeySym("Super_L", Qt::Key_Super_L ); | ||
537 | defKeySym("Super_R", Qt::Key_Super_R ); | ||
538 | defKeySym("Menu", Qt::Key_Menu ); | ||
539 | defKeySym("Hyper_L", Qt::Key_Hyper_L ); | ||
540 | defKeySym("Hyper_R", Qt::Key_Hyper_R ); | ||
541 | |||
542 | // Regular keys | ||
543 | defKeySym("Space", Qt::Key_Space ); | ||
544 | defKeySym("Exclam", Qt::Key_Exclam ); | ||
545 | defKeySym("QuoteDbl", Qt::Key_QuoteDbl ); | ||
546 | defKeySym("NumberSign", Qt::Key_NumberSign ); | ||
547 | defKeySym("Dollar", Qt::Key_Dollar ); | ||
548 | defKeySym("Percent", Qt::Key_Percent ); | ||
549 | defKeySym("Ampersand", Qt::Key_Ampersand ); | ||
550 | defKeySym("Apostrophe", Qt::Key_Apostrophe ); | ||
551 | defKeySym("ParenLeft", Qt::Key_ParenLeft ); | ||
552 | defKeySym("ParenRight", Qt::Key_ParenRight ); | ||
553 | defKeySym("Asterisk", Qt::Key_Asterisk ); | ||
554 | defKeySym("Plus", Qt::Key_Plus ); | ||
555 | defKeySym("Comma", Qt::Key_Comma ); | ||
556 | defKeySym("Minus", Qt::Key_Minus ); | ||
557 | defKeySym("Period", Qt::Key_Period ); | ||
558 | defKeySym("Slash", Qt::Key_Slash ); | ||
559 | defKeySym("0", Qt::Key_0 ); | ||
560 | defKeySym("1", Qt::Key_1 ); | ||
561 | defKeySym("2", Qt::Key_2 ); | ||
562 | defKeySym("3", Qt::Key_3 ); | ||
563 | defKeySym("4", Qt::Key_4 ); | ||
564 | defKeySym("5", Qt::Key_5 ); | ||
565 | defKeySym("6", Qt::Key_6 ); | ||
566 | defKeySym("7", Qt::Key_7 ); | ||
567 | defKeySym("8", Qt::Key_8 ); | ||
568 | defKeySym("9", Qt::Key_9 ); | ||
569 | defKeySym("Colon", Qt::Key_Colon ); | ||
570 | defKeySym("Semicolon", Qt::Key_Semicolon ); | ||
571 | defKeySym("Less", Qt::Key_Less ); | ||
572 | defKeySym("Equal", Qt::Key_Equal ); | ||
573 | defKeySym("Greater", Qt::Key_Greater ); | ||
574 | defKeySym("Question", Qt::Key_Question ); | ||
575 | defKeySym("At", Qt::Key_At ); | ||
576 | defKeySym("A", Qt::Key_A ); | ||
577 | defKeySym("B", Qt::Key_B ); | ||
578 | defKeySym("C", Qt::Key_C ); | ||
579 | defKeySym("D", Qt::Key_D ); | ||
580 | defKeySym("E", Qt::Key_E ); | ||
581 | defKeySym("F", Qt::Key_F ); | ||
582 | defKeySym("G", Qt::Key_G ); | ||
583 | defKeySym("H", Qt::Key_H ); | ||
584 | defKeySym("I", Qt::Key_I ); | ||
585 | defKeySym("J", Qt::Key_J ); | ||
586 | defKeySym("K", Qt::Key_K ); | ||
587 | defKeySym("L", Qt::Key_L ); | ||
588 | defKeySym("M", Qt::Key_M ); | ||
589 | defKeySym("N", Qt::Key_N ); | ||
590 | defKeySym("O", Qt::Key_O ); | ||
591 | defKeySym("P", Qt::Key_P ); | ||
592 | defKeySym("Q", Qt::Key_Q ); | ||
593 | defKeySym("R", Qt::Key_R ); | ||
594 | defKeySym("S", Qt::Key_S ); | ||
595 | defKeySym("T", Qt::Key_T ); | ||
596 | defKeySym("U", Qt::Key_U ); | ||
597 | defKeySym("V", Qt::Key_V ); | ||
598 | defKeySym("W", Qt::Key_W ); | ||
599 | defKeySym("X", Qt::Key_X ); | ||
600 | defKeySym("Y", Qt::Key_Y ); | ||
601 | defKeySym("Z", Qt::Key_Z ); | ||
602 | defKeySym("BracketLeft", Qt::Key_BracketLeft ); | ||
603 | defKeySym("Backslash", Qt::Key_Backslash ); | ||
604 | defKeySym("BracketRight", Qt::Key_BracketRight); | ||
605 | defKeySym("AsciiCircum", Qt::Key_AsciiCircum ); | ||
606 | defKeySym("Underscore", Qt::Key_Underscore ); | ||
607 | defKeySym("QuoteLeft", Qt::Key_QuoteLeft ); | ||
608 | defKeySym("BraceLeft", Qt::Key_BraceLeft ); | ||
609 | defKeySym("Bar", Qt::Key_Bar ); | ||
610 | defKeySym("BraceRight", Qt::Key_BraceRight ); | ||
611 | defKeySym("AsciiTilde", Qt::Key_AsciiTilde ); | ||
612 | } | ||
613 | |||
614 | KeyTransSymbols::KeyTransSymbols() | ||
615 | { | ||
616 | defModSyms(); | ||
617 | defOprSyms(); | ||
618 | defKeySyms(); | ||
619 | } | ||
620 | |||
621 | // Global material ----------------------------------------------------------- | ||
622 | |||
623 | static int keytab_serial = 0; //FIXME: remove,localize | ||
624 | |||
625 | static QIntDict<KeyTrans> * numb2keymap = 0L; | ||
626 | static QDict<KeyTrans> * path2keymap = 0L; | ||
627 | |||
628 | KeyTrans* KeyTrans::find(int numb) | ||
629 | { | ||
630 | KeyTrans* res = numb2keymap->find(numb); | ||
631 | return res ? res : numb2keymap->find(0); | ||
632 | } | ||
633 | |||
634 | KeyTrans* KeyTrans::find(const char* path) | ||
635 | { | ||
636 | KeyTrans* res = path2keymap->find(path); | ||
637 | return res ? res : numb2keymap->find(0); | ||
638 | } | ||
639 | |||
640 | int KeyTrans::count() | ||
641 | { | ||
642 | return numb2keymap->count(); | ||
643 | } | ||
644 | |||
645 | void KeyTrans::addKeyTrans() | ||
646 | { | ||
647 | this->numb = keytab_serial ++; | ||
648 | numb2keymap->insert(numb,this); | ||
649 | path2keymap->insert(path,this); | ||
650 | } | ||
651 | |||
652 | void KeyTrans::loadAll() | ||
653 | { | ||
654 | if (!numb2keymap) | ||
655 | numb2keymap = new QIntDict<KeyTrans>; | ||
656 | if (!path2keymap) | ||
657 | path2keymap = new QDict<KeyTrans>; | ||
658 | if (!syms) | ||
659 | syms = new KeyTransSymbols; | ||
660 | |||
661 | defaultKeyTrans()->addKeyTrans(); | ||
662 | |||
663 | |||
664 | QString path = QPEApplication::qpeDir() + "etc/keytabs"; | ||
665 | QDir dir(path); | ||
666 | QStringList lst = dir.entryList("*.keytab"); | ||
667 | |||
668 | for(QStringList::Iterator it = lst.begin(); it != lst.end(); ++it ) { | ||
669 | QFile file(path + "/" + *it); | ||
670 | KeyTrans* sc = KeyTrans::fromDevice(*it, file); | ||
671 | if (sc) { | ||
672 | sc->addKeyTrans(); | ||
673 | } | ||
674 | } | ||
675 | |||
676 | } | ||
677 | |||
678 | // Debugging material ----------------------------------------------------------- | ||
679 | /* | ||
680 | void TestTokenizer(QBuffer &buf) | ||
681 | { | ||
682 | // opening sequence | ||
683 | |||
684 | buf.open(IO_ReadOnly); | ||
685 | cc = buf.getch(); | ||
686 | lineno = 1; | ||
687 | |||
688 | // Test tokenizer | ||
689 | |||
690 | while (getSymbol(buf)) ReportToken(); | ||
691 | |||
692 | buf.close(); | ||
693 | } | ||
694 | |||
695 | void test() | ||
696 | { | ||
697 | // Opening sequence | ||
698 | |||
699 | QCString txt = | ||
700 | #include "default.keytab.h" | ||
701 | ; | ||
702 | QBuffer buf(txt); | ||
703 | if (0) TestTokenizer(buf); | ||
704 | if (1) { KeyTrans kt; kt.scanTable(buf); } | ||
705 | } | ||
706 | */ | ||