source: trunk/quest-misc/src/main/java/de/ugoe/cs/tasktree/keyboardmaps/KeyboardMap.java @ 725

Last change on this file since 725 was 725, checked in by pharms, 12 years ago
  • use console for logging instead of logger
File size: 73.4 KB
Line 
1package de.ugoe.cs.tasktree.keyboardmaps;
2
3import java.io.BufferedReader;
4import java.io.IOException;
5import java.io.InputStream;
6import java.io.InputStreamReader;
7import java.io.UnsupportedEncodingException;
8import java.util.ArrayList;
9import java.util.HashMap;
10import java.util.List;
11import java.util.Locale;
12import java.util.Map;
13import java.util.logging.Level;
14
15import de.ugoe.cs.util.console.Console;
16
17/**
18 * TODO comment
19 *
20 * @version $Revision: $ $Date: 11.07.2012$
21 * @author 2012, last modified by $Author: patrick$
22 */
23public class KeyboardMap {
24
25    /** */
26    private Locale locale;
27
28    /** */
29    private String fileName;
30
31    /** */
32    private Map<VirtualKey, List<KeyStroke>> keyStrokes =
33        new HashMap<VirtualKey, List<KeyStroke>>();
34
35    /** TODO: remove this stuff */
36    private List<Object[]> mKeyIds = new ArrayList<Object[]>();
37
38    /**
39     * TODO: comment
40     *
41     * @param locale
42     */
43    KeyboardMap(Locale locale) {
44        this.locale = locale;
45
46        if ((this.locale == Locale.ENGLISH) || (this.locale == Locale.US) ||
47            (this.locale == Locale.CANADA))
48        {
49            fileName = "en-us";
50        }
51        else if (locale == Locale.UK) {
52            fileName = "en-gb";
53        }
54        else {
55            fileName = locale.getLanguage();
56        }
57    }
58
59    /**
60     * TODO: comment
61     *
62     * @param digit1
63     * @param b
64     * @param c
65     * @param d
66     * @param e
67     * @param f
68     * @return
69     */
70    public char getCharacterFor(VirtualKey key,
71                                boolean    numlock,
72                                boolean    shift,
73                                boolean    altgr,
74                                boolean    inhibit)
75        throws IllegalArgumentException
76    {
77        List<KeyStroke> candidates = keyStrokes.get(key);
78
79        if (candidates == null) {
80            return Character.UNASSIGNED;
81        }
82
83        // try to find the key stroke
84        for (KeyStroke keyStroke : candidates) {
85            if ((numlock == keyStroke.getNumlock()) && (!keyStroke.getLocalstate()) &&
86                (shift == keyStroke.getShift()) && (altgr == keyStroke.getAltgr()) &&
87                (inhibit == keyStroke.getInhibit()))
88            {
89                return keyStroke.getCharacter();
90            }
91        }
92
93        // try to find the key stroke with a local state ignoring the other keys
94        for (KeyStroke keyStroke : candidates) {
95            if ((numlock == keyStroke.getNumlock()) && (keyStroke.getLocalstate()) &&
96                (inhibit == keyStroke.getInhibit()))
97            {
98                return keyStroke.getCharacter();
99            }
100        }
101
102        return Character.UNASSIGNED;
103    }
104
105    /**
106     * TODO: comment
107     *
108     */
109    void init() throws IllegalArgumentException {
110        Console.traceln(Level.FINE, "initializing keymap for locale " + locale);
111
112        List<String[]> deadKeySequences = new ArrayList<String[]>();
113        List<String[]> keyStrokes = new ArrayList<String[]>();
114        readStream(getStream(fileName), deadKeySequences, keyStrokes);
115
116        Console.traceln(Level.FINER, "read " + keyStrokes.size() + " key strokes and " +
117                        deadKeySequences.size() + " dead key sequences");
118
119        VirtualKeySynonyms virtualKeySynonyms = determineVirtualKeySynonyms(keyStrokes);
120        processKeyStrokes(keyStrokes, virtualKeySynonyms);
121        processDeadKeySequences(deadKeySequences);
122
123        for (Object[] keyId : mKeyIds) {
124            System.out.println(Integer.toHexString((Integer) keyId[0]) + "  " + keyId[1]);
125        }
126    }
127
128    /**
129     * TODO: comment
130     *
131     * @param fileName
132     * @return
133     */
134    private InputStream getStream(String name) {
135        Console.traceln
136          (Level.FINER, "reading keymap for locale " + locale + " from resource keymaps/" + name);
137
138        InputStream stream =
139            this.getClass().getClassLoader().getResourceAsStream("keymaps/" + name);
140
141        if (stream == null) {
142            throw new IllegalArgumentException("no keyboard map available for locale " + locale);
143        }
144
145        return stream;
146    }
147
148    /**
149     * TODO: comment
150     *
151     * @param stream
152     * @param virtualKeySynonyms
153     * @param deadKeySequences
154     */
155    private void readStream(InputStream    stream,
156                            List<String[]> deadKeySequences,
157                            List<String[]> keyStrokes)
158        throws IllegalArgumentException
159    {
160        BufferedReader in = null;
161        try {
162            in = new BufferedReader(new InputStreamReader(stream, "UTF-8"));
163        }
164        catch (UnsupportedEncodingException e) {
165            Console.traceln(Level.WARNING, "no keyboard map available for locale " + locale);
166            throw new IllegalArgumentException
167                ("provided stream can not be read due to invalid encoding", e);
168        }
169
170        try {
171            String line;
172            while ((line = in.readLine()) != null) {
173                if (!"".equals(line)) {
174                    processLine(line, deadKeySequences, keyStrokes);
175                }
176            }
177        }
178        catch (IOException e) {
179            Console.traceln(Level.WARNING, "no keyboard map available for locale " + locale);
180            throw new IllegalArgumentException("no keyboard map available for locale " + locale, e);
181        }
182        finally {
183            try {
184                in.close();
185            }
186            catch (IOException e) {
187                Console.traceln
188                    (Level.WARNING, "could not close input stream for reading keyboard map");
189            }
190        }
191    }
192
193    /**
194     * TODO: comment
195     *
196     * @param line
197     * @param deadKeySequences
198     */
199    private void processLine(String         line,
200                             List<String[]> deadKeySequences,
201                             List<String[]> keyStrokes)
202    {
203        String[] values = line.split(" ");
204
205        if (values.length <= 0) {
206            return;
207        }
208
209        // ignore comments
210        if (values[0].startsWith("#")) {
211            return;
212        }
213
214        if ("map".equals(values[0])) {
215            // this is the map id. Ignore it.
216        }
217        else if ("include".equals(values[0])) {
218            // process all includes
219            for (int i = 1; i < values.length; i++) {
220                if (!values[i].startsWith("#")) {
221                    readStream(getStream(values[i]), deadKeySequences, keyStrokes);
222                }
223                else {
224                    break;
225                }
226            }
227        }
228        else if ("sequence".equals(values[0])) {
229            deadKeySequences.add(values);
230        }
231        else {
232            boolean alreadyAdded = false;
233
234            // check, if there is a replacement
235            for (int i = 0; i < keyStrokes.size(); i++) {
236                if (keyStrokes.get(i)[0].equals(values[0])) {
237                    Console.traceln(Level.FINEST, "replacing key stroke " + values[0] +
238                                    " with former keyid " + keyStrokes.get(i)[1] +
239                                    " with new key id " + values[1]);
240                    keyStrokes.set(i, values);
241                    alreadyAdded = true;
242                    break;
243                }
244            }
245
246            if (!alreadyAdded) {
247                keyStrokes.add(values);
248            }
249        }
250    }
251
252    /**
253     * TODO: comment
254     *
255     * @param keyStrokes
256     * @return
257     */
258    private VirtualKeySynonyms determineVirtualKeySynonyms(List<String[]> keyStrokes) {
259        Console.traceln(Level.FINER, "determining virtual keys and synonyms for the keymap");
260
261        VirtualKeySynonyms virtualKeySynonyms = new VirtualKeySynonyms();
262
263        // for debugging purposes, determine which key strokes are not matched to virtual keys.
264        List<String[]> unmatchedKeyStrokes = new ArrayList<String[]>();
265
266        for (String[] keyStroke : keyStrokes) {
267            String keyStrokeName = keyStroke[0];
268            int keyId = getKeyId(keyStroke[1]);
269            // System.err.println(keyStrokeName + "  0x" + Integer.toHexString(keyId));
270
271            VirtualKey virtualKey = determineVirtualKey(keyStrokeName);
272
273            if (virtualKey != null) {
274                virtualKeySynonyms.add(keyId, virtualKey);
275            }
276            else {
277                unmatchedKeyStrokes.add(keyStroke);
278            }
279        }
280
281        for (String[] unmatchedKeyStroke : unmatchedKeyStrokes) {
282            if (!virtualKeySynonyms.containsKey(getKeyId(unmatchedKeyStroke[1]))) {
283                Console.traceln(Level.FINEST, "no virtual key mapped to key stroke " +
284                                unmatchedKeyStroke[0] + "(" + unmatchedKeyStroke[1] +
285                                ") of keyboard map for locale " + locale);
286            }
287        }
288
289        return virtualKeySynonyms;
290    }
291
292    /**
293     * TODO: comment
294     *
295     * @param string
296     * @return
297     */
298    private int getKeyId(String keyIdString) {
299        if (keyIdString.startsWith("0x")) {
300            keyIdString = keyIdString.substring(2);
301        }
302
303        return Integer.parseInt(keyIdString, 16);
304    }
305
306    /**
307     * TODO: comment
308     *
309     * @param keyStrokes
310     * @param virtualKeySynonyms
311     */
312    private void processKeyStrokes(List<String[]> keyStrokes, VirtualKeySynonyms virtualKeySynonyms)
313    {
314        for (String[] keyStroke : keyStrokes) {
315            handleKeyStroke(keyStroke, virtualKeySynonyms);
316        }
317
318        addKeyStrokesIndependentOfNumLock();
319    }
320
321    /**
322     * TODO: comment
323     *
324     * @param values
325     */
326    private void handleKeyStroke(String[] values, VirtualKeySynonyms virtualKeySynonyms) {
327        String keyStrokeName = values[0];
328        String keyIdString = values[1];
329        if (keyIdString.startsWith("0x")) {
330            keyIdString = keyIdString.substring(2);
331        }
332
333        int keyId = Integer.parseInt(keyIdString, 16);
334
335        // parse the conditions
336        boolean numlock = false;
337        boolean localstate = false;
338        boolean shift = false;
339        boolean altgr = false;
340        boolean addupper = false;
341        boolean inhibit = false;
342
343        for (int i = 2; i < values.length; i++) {
344            if (!values[i].startsWith("#")) {
345                if ("numlock".equals(values[i])) {
346                    numlock = true;
347                }
348                else if ("localstate".equals(values[i])) {
349                    localstate = true;
350                }
351                else if ("shift".equals(values[i])) {
352                    shift = true;
353                }
354                else if ("altgr".equals(values[i])) {
355                    altgr = true;
356                }
357                else if ("addupper".equals(values[i])) {
358                    addupper = true;
359                }
360                else if ("inhibit".equals(values[i])) {
361                    inhibit = true;
362                }
363                else {
364                    Console.traceln(Level.SEVERE, "unknown condition " + values[i] +
365                                    " specified for key stroke " + keyStrokeName +
366                                    " through keyboard map for locale " + locale);
367                    throw new IllegalArgumentException
368                        ("no keyboard map available for locale " + locale);
369                }
370            }
371            else {
372                break;
373            }
374        }
375
376        addAllRepresentedKeyStrokes(keyStrokeName, keyId, numlock, localstate, shift, altgr,
377                                    addupper, inhibit, virtualKeySynonyms);
378    }
379
380    /**
381     * TODO: comment
382     *
383     * @param keyStrokeName
384     * @param keyId
385     * @param numlock
386     * @param localstate
387     * @param shift
388     * @param altgr
389     * @param addupper
390     * @param inhibit
391     */
392    private void addAllRepresentedKeyStrokes(String             keyStrokeName,
393                                             int                keyId,
394                                             boolean            numlock,
395                                             boolean            localstate,
396                                             boolean            shift,
397                                             boolean            altgr,
398                                             boolean            addupper,
399                                             boolean            inhibit,
400                                             VirtualKeySynonyms virtualKeySynonyms)
401    {
402        VirtualKey[] virtualKeys = virtualKeySynonyms.getVirtualKeySynonyms(keyId);
403
404        if (virtualKeys == null) {
405            Console.traceln(Level.SEVERE, "no virtual key mapped to key stroke " + keyStrokeName +
406                            " of keyboard map for locale " + locale);
407            // throw new IllegalArgumentException("no keyboard map available for locale " +
408            // mLocale);
409            return;
410        }
411
412        for (VirtualKey virtualKey : virtualKeys) {
413            if (addupper) {
414                char c = determineCharacter(keyStrokeName, true);
415                addKeyStroke
416                  (keyStrokeName, virtualKey, numlock, localstate, true, altgr, inhibit, c);
417
418                c = determineCharacter(keyStrokeName, false);
419                addKeyStroke
420                  (keyStrokeName, virtualKey, numlock, localstate, false, altgr, inhibit, c);
421            }
422            else {
423                char c = determineCharacter(keyStrokeName, false);
424                addKeyStroke
425                  (keyStrokeName, virtualKey, numlock, localstate, shift, altgr, inhibit, c);
426            }
427        }
428    }
429
430    /**
431     * TODO: comment
432     *
433     * @param keyStroke
434     */
435    private void addKeyStroke(String     keyStrokeName,
436                              VirtualKey virtualKey,
437                              boolean    numlock,
438                              boolean    localstate,
439                              boolean    shift,
440                              boolean    altgr,
441                              boolean    inhibit,
442                              char       character)
443    {
444        KeyStroke keyStroke = new KeyStroke
445            (keyStrokeName, virtualKey, numlock, localstate, shift, altgr, inhibit, character);
446
447        List<KeyStroke> keyStrokeList = keyStrokes.get(keyStroke.getVirtualKey());
448
449        if (keyStrokeList == null) {
450            keyStrokeList = new ArrayList<KeyStroke>();
451            keyStrokes.put(keyStroke.getVirtualKey(), keyStrokeList);
452        }
453
454        keyStrokeList.add(keyStroke);
455    }
456
457    /**
458     * TODO: comment
459     *
460     */
461    private void addKeyStrokesIndependentOfNumLock() {
462        for (Map.Entry<VirtualKey, List<KeyStroke>> entry : keyStrokes.entrySet()) {
463            List<KeyStroke> keyStrokesToAdd = new ArrayList<KeyStroke>();
464            for (KeyStroke keyStroke : entry.getValue()) {
465                if (!keyStroke.getNumlock()) {
466                    boolean foundPositiveNumlockVariant = false;
467                    for (KeyStroke candidate : entry.getValue()) {
468                        if ((candidate.getShift() == keyStroke.getShift()) &&
469                            (candidate.getAltgr() == keyStroke.getAltgr()) &&
470                            (candidate.getLocalstate() == keyStroke.getLocalstate()) &&
471                            (candidate.getInhibit() == keyStroke.getInhibit()) &&
472                            (candidate.getNumlock()))
473                        {
474                            foundPositiveNumlockVariant = true;
475                            break;
476                        }
477                    }
478
479                    if (!foundPositiveNumlockVariant) {
480                        keyStrokesToAdd.add(keyStroke);
481                    }
482                }
483            }
484
485            for (KeyStroke keyStroke : keyStrokesToAdd) {
486                addKeyStroke(keyStroke.getKeyStrokeName(), keyStroke.getVirtualKey(), true,
487                             keyStroke.getLocalstate(), keyStroke.getShift(), keyStroke.getAltgr(),
488                             keyStroke.getInhibit(), keyStroke.getCharacter());
489            }
490        }
491    }
492
493    /**
494     * TODO: comment
495     *
496     * @param deadKeySequences
497     */
498    private void processDeadKeySequences(List<String[]> deadKeySequences) {
499        // TODO Auto-generated method stub
500        // System.out.println("PATRICK: KeyboardMap.processDeadKeySequences ");
501    }
502
503    /**
504     * TODO: comment
505     *
506     * @param keyStrokeName
507     * @param shift
508     * @return
509     */
510    private VirtualKey determineVirtualKey(String keyStrokeName) {
511        if ("Shift_R".equals(keyStrokeName)) {
512            return VirtualKey.SHIFT;
513        }
514        else if ("Shift_L".equals(keyStrokeName)) {
515            return VirtualKey.SHIFT;
516        }
517        else if ("Alt_R".equals(keyStrokeName)) {
518            return VirtualKey.ALT_GRAPH;
519        }
520        else if ("Mode_switch".equals(keyStrokeName)) {
521            return VirtualKey.MODECHANGE;
522        }
523        else if ("ISO_Level3_Shift".equals(keyStrokeName)) {
524            return VirtualKey.SHIFT;
525        }
526        else if ("Alt_L".equals(keyStrokeName)) {
527            return VirtualKey.ALT;
528        }
529        else if ("Control_R".equals(keyStrokeName)) {
530            return VirtualKey.CONTROL;
531        }
532        else if ("Control_L".equals(keyStrokeName)) {
533            return VirtualKey.CONTROL;
534        }
535        else if ("Menu".equals(keyStrokeName)) {
536            return VirtualKey.WINDOWS;
537        }
538        else if ("1".equals(keyStrokeName)) {
539            return VirtualKey.DIGIT_1;
540        }
541        else if ("2".equals(keyStrokeName)) {
542            return VirtualKey.DIGIT_2;
543        }
544        else if ("3".equals(keyStrokeName)) {
545            return VirtualKey.DIGIT_3;
546        }
547        else if ("4".equals(keyStrokeName)) {
548            return VirtualKey.DIGIT_4;
549        }
550        else if ("5".equals(keyStrokeName)) {
551            return VirtualKey.DIGIT_5;
552        }
553        else if ("6".equals(keyStrokeName)) {
554            return VirtualKey.DIGIT_6;
555        }
556        else if ("7".equals(keyStrokeName)) {
557            return VirtualKey.DIGIT_7;
558        }
559        else if ("8".equals(keyStrokeName)) {
560            return VirtualKey.DIGIT_8;
561        }
562        else if ("9".equals(keyStrokeName)) {
563            return VirtualKey.DIGIT_9;
564        }
565        else if ("0".equals(keyStrokeName)) {
566            return VirtualKey.DIGIT_0;
567        }
568        else if ("BackSpace".equals(keyStrokeName)) {
569            return VirtualKey.BACK_SPACE;
570        }
571        else if ("Tab".equals(keyStrokeName)) {
572            return VirtualKey.TAB;
573        }
574        else if ("q".equals(keyStrokeName)) {
575            return VirtualKey.LETTER_Q;
576        }
577        else if ("w".equals(keyStrokeName)) {
578            return VirtualKey.LETTER_W;
579        }
580        else if ("e".equals(keyStrokeName)) {
581            return VirtualKey.LETTER_E;
582        }
583        else if ("r".equals(keyStrokeName)) {
584            return VirtualKey.LETTER_R;
585        }
586        else if ("t".equals(keyStrokeName)) {
587            return VirtualKey.LETTER_T;
588        }
589        else if ("y".equals(keyStrokeName)) {
590            return VirtualKey.LETTER_Y;
591        }
592        else if ("u".equals(keyStrokeName)) {
593            return VirtualKey.LETTER_U;
594        }
595        else if ("i".equals(keyStrokeName)) {
596            return VirtualKey.LETTER_I;
597        }
598        else if ("o".equals(keyStrokeName)) {
599            return VirtualKey.LETTER_O;
600        }
601        else if ("p".equals(keyStrokeName)) {
602            return VirtualKey.LETTER_P;
603        }
604        else if ("a".equals(keyStrokeName)) {
605            return VirtualKey.LETTER_A;
606        }
607        else if ("s".equals(keyStrokeName)) {
608            return VirtualKey.LETTER_S;
609        }
610        else if ("d".equals(keyStrokeName)) {
611            return VirtualKey.LETTER_D;
612        }
613        else if ("f".equals(keyStrokeName)) {
614            return VirtualKey.LETTER_F;
615        }
616        else if ("g".equals(keyStrokeName)) {
617            return VirtualKey.LETTER_G;
618        }
619        else if ("h".equals(keyStrokeName)) {
620            return VirtualKey.LETTER_H;
621        }
622        else if ("j".equals(keyStrokeName)) {
623            return VirtualKey.LETTER_J;
624        }
625        else if ("k".equals(keyStrokeName)) {
626            return VirtualKey.LETTER_K;
627        }
628        else if ("l".equals(keyStrokeName)) {
629            return VirtualKey.LETTER_L;
630        }
631        else if ("Return".equals(keyStrokeName)) {
632            return VirtualKey.ENTER;
633        }
634        else if ("z".equals(keyStrokeName)) {
635            return VirtualKey.LETTER_Z;
636        }
637        else if ("x".equals(keyStrokeName)) {
638            return VirtualKey.LETTER_X;
639        }
640        else if ("c".equals(keyStrokeName)) {
641            return VirtualKey.LETTER_C;
642        }
643        else if ("v".equals(keyStrokeName)) {
644            return VirtualKey.LETTER_V;
645        }
646        else if ("b".equals(keyStrokeName)) {
647            return VirtualKey.LETTER_B;
648        }
649        else if ("n".equals(keyStrokeName)) {
650            return VirtualKey.LETTER_N;
651        }
652        else if ("m".equals(keyStrokeName)) {
653            return VirtualKey.LETTER_M;
654        }
655        else if ("space".equals(keyStrokeName)) {
656            return VirtualKey.SPACE;
657        }
658        else if ("less".equals(keyStrokeName)) {
659            return VirtualKey.LESS;
660        }
661        else if ("greater".equals(keyStrokeName)) {
662            return VirtualKey.GREATER;
663        }
664        else if ("Escape".equals(keyStrokeName)) {
665            return VirtualKey.ESCAPE;
666        }
667        else if ("F1".equals(keyStrokeName)) {
668            return VirtualKey.F1;
669        }
670        else if ("F2".equals(keyStrokeName)) {
671            return VirtualKey.F2;
672        }
673        else if ("F3".equals(keyStrokeName)) {
674            return VirtualKey.F3;
675        }
676        else if ("F4".equals(keyStrokeName)) {
677            return VirtualKey.F4;
678        }
679        else if ("F5".equals(keyStrokeName)) {
680            return VirtualKey.F5;
681        }
682        else if ("F6".equals(keyStrokeName)) {
683            return VirtualKey.F6;
684        }
685        else if ("F7".equals(keyStrokeName)) {
686            return VirtualKey.F7;
687        }
688        else if ("F8".equals(keyStrokeName)) {
689            return VirtualKey.F8;
690        }
691        else if ("F9".equals(keyStrokeName)) {
692            return VirtualKey.F9;
693        }
694        else if ("F10".equals(keyStrokeName)) {
695            return VirtualKey.F10;
696        }
697        else if ("F11".equals(keyStrokeName)) {
698            return VirtualKey.F11;
699        }
700        else if ("F12".equals(keyStrokeName)) {
701            return VirtualKey.F12;
702        }
703        else if ("F13".equals(keyStrokeName)) {
704            return VirtualKey.F13;
705        }
706        else if ("F14".equals(keyStrokeName)) {
707            return VirtualKey.F14;
708        }
709        else if ("F15".equals(keyStrokeName)) {
710            return VirtualKey.F15;
711        }
712        else if ("F16".equals(keyStrokeName)) {
713            return VirtualKey.F16;
714        }
715        else if ("F17".equals(keyStrokeName)) {
716            return VirtualKey.F17;
717        }
718        else if ("F18".equals(keyStrokeName)) {
719            return VirtualKey.F18;
720        }
721        else if ("F19".equals(keyStrokeName)) {
722            return VirtualKey.F19;
723        }
724        else if ("F20".equals(keyStrokeName)) {
725            return VirtualKey.F20;
726        }
727        else if ("F21".equals(keyStrokeName)) {
728            return VirtualKey.F21;
729        }
730        else if ("F22".equals(keyStrokeName)) {
731            return VirtualKey.F22;
732        }
733        else if ("F23".equals(keyStrokeName)) {
734            return VirtualKey.F23;
735        }
736        else if ("F24".equals(keyStrokeName)) {
737            return VirtualKey.F24;
738        }
739        else if ("Print".equals(keyStrokeName)) {
740            return VirtualKey.PRINTSCREEN;
741        }
742        else if ("Scroll_Lock".equals(keyStrokeName)) {
743            return VirtualKey.SCROLL_LOCK;
744        }
745        else if ("Insert".equals(keyStrokeName)) {
746            return VirtualKey.INSERT;
747        }
748        else if ("Delete".equals(keyStrokeName)) {
749            return VirtualKey.DELETE;
750        }
751        else if ("Home".equals(keyStrokeName)) {
752            return VirtualKey.HOME;
753        }
754        else if ("End".equals(keyStrokeName)) {
755            return VirtualKey.END;
756        }
757        else if ("Page_Up".equals(keyStrokeName)) {
758            return VirtualKey.PAGE_UP;
759        }
760        else if ("Page_Down".equals(keyStrokeName)) {
761            return VirtualKey.PAGE_DOWN;
762        }
763        else if ("Left".equals(keyStrokeName)) {
764            return VirtualKey.LEFT;
765        }
766        else if ("Up".equals(keyStrokeName)) {
767            return VirtualKey.UP;
768        }
769        else if ("Down".equals(keyStrokeName)) {
770            return VirtualKey.DOWN;
771        }
772        else if ("Right".equals(keyStrokeName)) {
773            return VirtualKey.RIGHT;
774        }
775        else if ("Num_Lock".equals(keyStrokeName)) {
776            return VirtualKey.NUM_LOCK;
777        }
778        else if ("KP_Divide".equals(keyStrokeName)) {
779            return VirtualKey.SLASH;
780        }
781        else if ("KP_Multiply".equals(keyStrokeName)) {
782            return VirtualKey.ASTERISK;
783        }
784        else if ("KP_Subtract".equals(keyStrokeName)) {
785            return VirtualKey.MINUS;
786        }
787        else if ("KP_Add".equals(keyStrokeName)) {
788            return VirtualKey.PLUS;
789        }
790        else if ("KP_Enter".equals(keyStrokeName)) {
791            return VirtualKey.ENTER;
792        }
793        else if ("KP_Decimal".equals(keyStrokeName)) {
794            return VirtualKey.DECIMAL;
795        }
796        else if ("KP_Separator".equals(keyStrokeName)) {
797            return VirtualKey.SEPARATOR;
798        }
799        else if ("KP_Delete".equals(keyStrokeName)) {
800            return VirtualKey.DELETE;
801        }
802        else if ("KP_0".equals(keyStrokeName)) {
803            return VirtualKey.NUMPAD_0;
804        }
805        else if ("KP_Insert".equals(keyStrokeName)) {
806            return VirtualKey.INSERT;
807        }
808        else if ("KP_1".equals(keyStrokeName)) {
809            return VirtualKey.NUMPAD_1;
810        }
811        else if ("KP_End".equals(keyStrokeName)) {
812            return VirtualKey.END;
813        }
814        else if ("KP_2".equals(keyStrokeName)) {
815            return VirtualKey.NUMPAD_2;
816        }
817        else if ("KP_Down".equals(keyStrokeName)) {
818            return VirtualKey.KP_DOWN;
819        }
820        else if ("KP_3".equals(keyStrokeName)) {
821            return VirtualKey.NUMPAD_3;
822        }
823        else if ("KP_Next".equals(keyStrokeName)) {
824            return VirtualKey.PAGE_DOWN;
825        }
826        else if ("KP_4".equals(keyStrokeName)) {
827            return VirtualKey.NUMPAD_4;
828        }
829        else if ("KP_Left".equals(keyStrokeName)) {
830            return VirtualKey.KP_LEFT;
831        }
832        else if ("KP_5".equals(keyStrokeName)) {
833            return VirtualKey.NUMPAD_5;
834        }
835        else if ("KP_Begin".equals(keyStrokeName)) {
836            return VirtualKey.BEGIN;
837        }
838        else if ("KP_6".equals(keyStrokeName)) {
839            return VirtualKey.NUMPAD_6;
840        }
841        else if ("KP_Right".equals(keyStrokeName)) {
842            return VirtualKey.KP_RIGHT;
843        }
844        else if ("KP_7".equals(keyStrokeName)) {
845            return VirtualKey.NUMPAD_7;
846        }
847        else if ("KP_Home".equals(keyStrokeName)) {
848            return VirtualKey.HOME;
849        }
850        else if ("KP_8".equals(keyStrokeName)) {
851            return VirtualKey.NUMPAD_8;
852        }
853        else if ("KP_Up".equals(keyStrokeName)) {
854            return VirtualKey.KP_UP;
855        }
856        else if ("KP_9".equals(keyStrokeName)) {
857            return VirtualKey.NUMPAD_9;
858        }
859        else if ("KP_Prior".equals(keyStrokeName)) {
860            return VirtualKey.PAGE_UP;
861        }
862        else if ("Caps_Lock".equals(keyStrokeName)) {
863            return VirtualKey.CAPS_LOCK;
864        }
865        else if ("exclam".equals(keyStrokeName)) {
866            return VirtualKey.EXCLAMATION_MARK;
867        }
868        else if ("exclamdown".equals(keyStrokeName)) {
869            return VirtualKey.INVERTED_EXCLAMATION_MARK;
870        }
871        else if ("quotedbl".equals(keyStrokeName)) {
872            return VirtualKey.QUOTEDBL;
873        }
874        else if ("slash".equals(keyStrokeName)) {
875            return VirtualKey.SLASH;
876        }
877        else if ("backslash".equals(keyStrokeName)) {
878            return VirtualKey.BACK_SLASH;
879        }
880        else if ("dead_acute".equals(keyStrokeName)) {
881            return VirtualKey.DEAD_ACUTE;
882        }
883        else if ("dead_diaresis".equals(keyStrokeName)) {
884            return VirtualKey.DEAD_DIAERESIS;
885        }
886        else if ("dead_abovering".equals(keyStrokeName)) {
887            return VirtualKey.DEAD_ABOVERING;
888        }
889        else if ("plus".equals(keyStrokeName)) {
890            return VirtualKey.PLUS;
891        }
892        else if ("asterisk".equals(keyStrokeName)) {
893            return VirtualKey.ASTERISK;
894        }
895        else if ("dead_tilde".equals(keyStrokeName)) {
896            return VirtualKey.DEAD_TILDE;
897        }
898        else if ("dead_doubleacute".equals(keyStrokeName)) {
899            return VirtualKey.DEAD_DOUBLEACUTE;
900        }
901        else if ("dead_caron".equals(keyStrokeName)) {
902            return VirtualKey.DEAD_CARON;
903        }
904        else if ("dead_circumflex".equals(keyStrokeName)) {
905            return VirtualKey.DEAD_CIRCUMFLEX;
906        }
907        else if ("comma".equals(keyStrokeName)) {
908            return VirtualKey.COMMA;
909        }
910        else if ("semicolon".equals(keyStrokeName)) {
911            return VirtualKey.SEMICOLON;
912        }
913        else if ("multiply".equals(keyStrokeName)) {
914            return VirtualKey.MULTIPLY;
915        }
916        else if ("period".equals(keyStrokeName)) {
917            return VirtualKey.PERIOD;
918        }
919        else if ("colon".equals(keyStrokeName)) {
920            return VirtualKey.COLON;
921        }
922        else if ("dead_breve".equals(keyStrokeName)) {
923            return VirtualKey.DEAD_BREVE;
924        }
925        else if ("division".equals(keyStrokeName)) {
926            return VirtualKey.DIVIDE;
927        }
928        else if ("minus".equals(keyStrokeName)) {
929            return VirtualKey.MINUS;
930        }
931        else if ("underscore".equals(keyStrokeName)) {
932            return VirtualKey.UNDERSCORE;
933        }
934        else if ("dead_abovedot".equals(keyStrokeName)) {
935            return VirtualKey.DEAD_ABOVEDOT;
936        }
937        else if ("bracketleft".equals(keyStrokeName)) {
938            return VirtualKey.OPEN_BRACKET;
939        }
940        else if ("bracketright".equals(keyStrokeName)) {
941            return VirtualKey.CLOSE_BRACKET;
942        }
943        else if ("grave".equals(keyStrokeName)) {
944            return VirtualKey.DEAD_GRAVE;
945        }
946        else if ("equal".equals(keyStrokeName)) {
947            return VirtualKey.EQUALS;
948        }
949        else if ("dead_macron".equals(keyStrokeName)) {
950            return VirtualKey.DEAD_MACRON;
951        }
952        else if ("dead_ogonek".equals(keyStrokeName)) {
953            return VirtualKey.DEAD_OGONEK;
954        }
955        else if ("dead_cedilla".equals(keyStrokeName)) {
956            return VirtualKey.DEAD_CEDILLA;
957        }
958        else if ("ampersand".equals(keyStrokeName)) {
959            return VirtualKey.AMPERSAND;
960        }
961        else if ("parenleft".equals(keyStrokeName)) {
962            return VirtualKey.LEFT_PARENTHESIS;
963        }
964        else if ("parenright".equals(keyStrokeName)) {
965            return VirtualKey.RIGHT_PARENTHESIS;
966        }
967        else if ("braceleft".equals(keyStrokeName)) {
968            return VirtualKey.BRACELEFT;
969        }
970        else if ("braceright".equals(keyStrokeName)) {
971            return VirtualKey.BRACERIGHT;
972        }
973        else if ("at".equals(keyStrokeName)) {
974            return VirtualKey.AT;
975        }
976        else if ("dollar".equals(keyStrokeName)) {
977            return VirtualKey.DOLLAR;
978        }
979        else if ("EuroSign".equals(keyStrokeName)) {
980            return VirtualKey.EURO_SIGN;
981        }
982        else if ("Begin".equals(keyStrokeName)) {
983            return VirtualKey.BEGIN;
984        }
985        else if ("numbersign".equals(keyStrokeName)) {
986            return VirtualKey.NUMBER_SIGN;
987        }
988        else if ("asciicircum".equals(keyStrokeName)) {
989            return VirtualKey.CIRCUMFLEX;
990        }
991        else if ("Kanji".equals(keyStrokeName)) {
992            return VirtualKey.KANJI;
993        }
994        else if ("Katakana".equals(keyStrokeName)) {
995            return VirtualKey.KATAKANA;
996        }
997        else if ("Hiragana_Katakana".equals(keyStrokeName)) {
998            return VirtualKey.HIRAGANA;
999        }
1000        else if ("Muhenkan".equals(keyStrokeName)) {
1001            // I found this in the KeyEvent description
1002            return VirtualKey.NONCONVERT;
1003        }
1004        else if ("kan".equals(keyStrokeName)) {
1005            // I found this in the KeyEvent description
1006            return VirtualKey.NONCONVERT;
1007        }
1008        else if ("Henkan_Mode".equals(keyStrokeName)) {
1009            // I found this in the key event description
1010            return VirtualKey.CONVERT;
1011        }
1012        else if ("voicedsound".equals(keyStrokeName)) {
1013            return VirtualKey.DEAD_VOICED_SOUND;
1014        }
1015        else if ("semivoicedsound".equals(keyStrokeName)) {
1016            return VirtualKey.DEAD_SEMIVOICED_SOUND;
1017        }
1018        else if ("Menu".equals(keyStrokeName)) {
1019            return VirtualKey.CONTEXT_MENU;
1020        }
1021        else {
1022            Console.traceln(Level.FINEST, "unknown virtual key for key stroke " + keyStrokeName +
1023                            " specified through " + "keyboard map for locale " + locale);
1024
1025            return null;
1026        }
1027
1028        // for the following virtual keys no key stroke names are provided in the key maps
1029        /*
1030         * CANCEL(KeyEvent.VK_CANCEL), CLEAR(KeyEvent.VK_CLEAR), PAUSE(KeyEvent.VK_PAUSE),
1031         * HELP(KeyEvent.VK_HELP), META(KeyEvent.VK_META),
1032         *
1033         * BACK_QUOTE(KeyEvent.VK_BACK_QUOTE), QUOTE(KeyEvent.VK_QUOTE),
1034         *
1035         * DEAD_IOTA(KeyEvent.VK_DEAD_IOTA),
1036         *
1037         * FINAL(KeyEvent.VK_FINAL), CONVERT(KeyEvent.VK_CONVERT),
1038         * NONCONVERT(KeyEvent.VK_NONCONVERT), ACCEPT(KeyEvent.VK_ACCEPT), KANA(KeyEvent.VK_KANA),
1039         * ALPHANUMERIC(KeyEvent.VK_ALPHANUMERIC), FULL_WIDTH(KeyEvent.VK_FULL_WIDTH),
1040         * HALF_WIDTH(KeyEvent.VK_HALF_WIDTH), ROMAN_CHARACTERS(KeyEvent.VK_ROMAN_CHARACTERS),
1041         * ALL_CANDIDATES(KeyEvent.VK_ALL_CANDIDATES),
1042         * PREVIOUS_CANDIDATE(KeyEvent.VK_PREVIOUS_CANDIDATE), CODE_INPUT(KeyEvent.VK_CODE_INPUT),
1043         * JAPANESE_KATAKANA(KeyEvent.VK_JAPANESE_KATAKANA),
1044         * JAPANESE_HIRAGANA(KeyEvent.VK_JAPANESE_HIRAGANA),
1045         * JAPANESE_ROMAN(KeyEvent.VK_JAPANESE_ROMAN), KANA_LOCK(KeyEvent.VK_KANA_LOCK),
1046         * INPUT_METHOD_ON_OFF(KeyEvent.VK_INPUT_METHOD_ON_OFF),
1047         *
1048         * CUT(KeyEvent.VK_CUT), COPY(KeyEvent.VK_COPY), PASTE(KeyEvent.VK_PASTE),
1049         * UNDO(KeyEvent.VK_UNDO), AGAIN(KeyEvent.VK_AGAIN), FIND(KeyEvent.VK_FIND),
1050         * PROPS(KeyEvent.VK_PROPS), STOP(KeyEvent.VK_STOP), COMPOSE(KeyEvent.VK_COMPOSE),
1051         */
1052    }
1053
1054    /**
1055     * TODO: comment
1056     *
1057     * @param keyStrokeName
1058     * @param shift
1059     * @return
1060     */
1061    private char determineCharacter(String keyStrokeName, boolean getUpper) {
1062        if ("Shift_R".equals(keyStrokeName)) {
1063            return Character.UNASSIGNED;
1064        }
1065        else if ("Shift_L".equals(keyStrokeName)) {
1066            return Character.UNASSIGNED;
1067        }
1068        else if ("Alt_R".equals(keyStrokeName)) {
1069            return Character.UNASSIGNED;
1070        }
1071        else if ("Mode_switch".equals(keyStrokeName)) {
1072            return Character.UNASSIGNED;
1073        }
1074        else if ("ISO_Level3_Shift".equals(keyStrokeName)) {
1075            return Character.UNASSIGNED;
1076        }
1077        else if ("Alt_L".equals(keyStrokeName)) {
1078            return Character.UNASSIGNED;
1079        }
1080        else if ("Control_R".equals(keyStrokeName)) {
1081            return Character.UNASSIGNED;
1082        }
1083        else if ("Control_L".equals(keyStrokeName)) {
1084            return Character.UNASSIGNED;
1085        }
1086        else if ("Menu".equals(keyStrokeName)) {
1087            return Character.UNASSIGNED;
1088        }
1089        else if ("1".equals(keyStrokeName)) {
1090            return '1';
1091        }
1092        else if ("2".equals(keyStrokeName)) {
1093            return '2';
1094        }
1095        else if ("3".equals(keyStrokeName)) {
1096            return '3';
1097        }
1098        else if ("4".equals(keyStrokeName)) {
1099            return '4';
1100        }
1101        else if ("5".equals(keyStrokeName)) {
1102            return '5';
1103        }
1104        else if ("6".equals(keyStrokeName)) {
1105            return '6';
1106        }
1107        else if ("7".equals(keyStrokeName)) {
1108            return '7';
1109        }
1110        else if ("8".equals(keyStrokeName)) {
1111            return '8';
1112        }
1113        else if ("9".equals(keyStrokeName)) {
1114            return '9';
1115        }
1116        else if ("0".equals(keyStrokeName)) {
1117            return '0';
1118        }
1119        else if ("BackSpace".equals(keyStrokeName)) {
1120            return '\b';
1121        }
1122        else if ("Tab".equals(keyStrokeName)) {
1123            return '\t';
1124        }
1125        else if ("ISO_Left_Tab".equals(keyStrokeName)) {
1126            return Character.UNASSIGNED;
1127        }
1128        else if ("q".equals(keyStrokeName)) {
1129            return getUpper ? 'Q' : 'q';
1130        }
1131        else if ("w".equals(keyStrokeName)) {
1132            return getUpper ? 'W' : 'w';
1133        }
1134        else if ("e".equals(keyStrokeName)) {
1135            return getUpper ? 'E' : 'e';
1136        }
1137        else if ("r".equals(keyStrokeName)) {
1138            return getUpper ? 'R' : 'r';
1139        }
1140        else if ("t".equals(keyStrokeName)) {
1141            return getUpper ? 'T' : 't';
1142        }
1143        else if ("y".equals(keyStrokeName)) {
1144            return getUpper ? 'Y' : 'y';
1145        }
1146        else if ("u".equals(keyStrokeName)) {
1147            return getUpper ? 'U' : 'u';
1148        }
1149        else if ("i".equals(keyStrokeName)) {
1150            return getUpper ? 'I' : 'i';
1151        }
1152        else if ("o".equals(keyStrokeName)) {
1153            return getUpper ? 'O' : 'o';
1154        }
1155        else if ("p".equals(keyStrokeName)) {
1156            return getUpper ? 'P' : 'p';
1157        }
1158        else if ("a".equals(keyStrokeName)) {
1159            return getUpper ? 'A' : 'a';
1160        }
1161        else if ("s".equals(keyStrokeName)) {
1162            return getUpper ? 'S' : 's';
1163        }
1164        else if ("d".equals(keyStrokeName)) {
1165            return getUpper ? 'D' : 'd';
1166        }
1167        else if ("f".equals(keyStrokeName)) {
1168            return getUpper ? 'F' : 'f';
1169        }
1170        else if ("g".equals(keyStrokeName)) {
1171            return getUpper ? 'G' : 'g';
1172        }
1173        else if ("h".equals(keyStrokeName)) {
1174            return getUpper ? 'H' : 'h';
1175        }
1176        else if ("j".equals(keyStrokeName)) {
1177            return getUpper ? 'J' : 'j';
1178        }
1179        else if ("k".equals(keyStrokeName)) {
1180            return getUpper ? 'K' : 'k';
1181        }
1182        else if ("l".equals(keyStrokeName)) {
1183            return getUpper ? 'L' : 'l';
1184        }
1185        else if ("Return".equals(keyStrokeName)) {
1186            return '\n';
1187        }
1188        else if ("z".equals(keyStrokeName)) {
1189            return getUpper ? 'Z' : 'z';
1190        }
1191        else if ("x".equals(keyStrokeName)) {
1192            return getUpper ? 'X' : 'x';
1193        }
1194        else if ("c".equals(keyStrokeName)) {
1195            return getUpper ? 'C' : 'c';
1196        }
1197        else if ("v".equals(keyStrokeName)) {
1198            return getUpper ? 'V' : 'v';
1199        }
1200        else if ("b".equals(keyStrokeName)) {
1201            return getUpper ? 'B' : 'b';
1202        }
1203        else if ("n".equals(keyStrokeName)) {
1204            return getUpper ? 'N' : 'n';
1205        }
1206        else if ("m".equals(keyStrokeName)) {
1207            return getUpper ? 'M' : 'm';
1208        }
1209        else if ("space".equals(keyStrokeName)) {
1210            return ' ';
1211        }
1212        else if ("less".equals(keyStrokeName)) {
1213            return '<';
1214        }
1215        else if ("greater".equals(keyStrokeName)) {
1216            return '>';
1217        }
1218        else if ("bar".equals(keyStrokeName)) {
1219            return '|';
1220        }
1221        else if ("brokenbar".equals(keyStrokeName)) {
1222            return '¦';
1223        }
1224        else if ("Escape".equals(keyStrokeName)) {
1225            return Character.UNASSIGNED;
1226        }
1227        else if ("F1".equals(keyStrokeName)) {
1228            return Character.UNASSIGNED;
1229        }
1230        else if ("F2".equals(keyStrokeName)) {
1231            return Character.UNASSIGNED;
1232        }
1233        else if ("F3".equals(keyStrokeName)) {
1234            return Character.UNASSIGNED;
1235        }
1236        else if ("F4".equals(keyStrokeName)) {
1237            return Character.UNASSIGNED;
1238        }
1239        else if ("F5".equals(keyStrokeName)) {
1240            return Character.UNASSIGNED;
1241        }
1242        else if ("F6".equals(keyStrokeName)) {
1243            return Character.UNASSIGNED;
1244        }
1245        else if ("F7".equals(keyStrokeName)) {
1246            return Character.UNASSIGNED;
1247        }
1248        else if ("F8".equals(keyStrokeName)) {
1249            return Character.UNASSIGNED;
1250        }
1251        else if ("F9".equals(keyStrokeName)) {
1252            return Character.UNASSIGNED;
1253        }
1254        else if ("F10".equals(keyStrokeName)) {
1255            return Character.UNASSIGNED;
1256        }
1257        else if ("F11".equals(keyStrokeName)) {
1258            return Character.UNASSIGNED;
1259        }
1260        else if ("SunF36".equals(keyStrokeName)) {
1261            return Character.UNASSIGNED;
1262        }
1263        else if ("F12".equals(keyStrokeName)) {
1264            return Character.UNASSIGNED;
1265        }
1266        else if ("SunF37".equals(keyStrokeName)) {
1267            return Character.UNASSIGNED;
1268        }
1269        else if ("Print".equals(keyStrokeName)) {
1270            return Character.UNASSIGNED;
1271        }
1272        else if ("Sys_Req".equals(keyStrokeName)) {
1273            return Character.UNASSIGNED;
1274        }
1275        else if ("Execute".equals(keyStrokeName)) {
1276            return Character.UNASSIGNED;
1277        }
1278        else if ("F22".equals(keyStrokeName)) {
1279            return Character.UNASSIGNED;
1280        }
1281        else if ("Scroll_Lock".equals(keyStrokeName)) {
1282            return Character.UNASSIGNED;
1283        }
1284        else if ("F23".equals(keyStrokeName)) {
1285            return Character.UNASSIGNED;
1286        }
1287        else if ("Insert".equals(keyStrokeName)) {
1288            return Character.UNASSIGNED;
1289        }
1290        else if ("Delete".equals(keyStrokeName)) {
1291            return Character.UNASSIGNED;
1292        }
1293        else if ("Home".equals(keyStrokeName)) {
1294            return Character.UNASSIGNED;
1295        }
1296        else if ("End".equals(keyStrokeName)) {
1297            return Character.UNASSIGNED;
1298        }
1299        else if ("Page_Up".equals(keyStrokeName)) {
1300            return Character.UNASSIGNED;
1301        }
1302        else if ("Page_Down".equals(keyStrokeName)) {
1303            return Character.UNASSIGNED;
1304        }
1305        else if ("Left".equals(keyStrokeName)) {
1306            return Character.UNASSIGNED;
1307        }
1308        else if ("Up".equals(keyStrokeName)) {
1309            return Character.UNASSIGNED;
1310        }
1311        else if ("Down".equals(keyStrokeName)) {
1312            return Character.UNASSIGNED;
1313        }
1314        else if ("Right".equals(keyStrokeName)) {
1315            return Character.UNASSIGNED;
1316        }
1317        else if ("Num_Lock".equals(keyStrokeName)) {
1318            return Character.UNASSIGNED;
1319        }
1320        else if ("KP_Divide".equals(keyStrokeName)) {
1321            return '/';
1322        }
1323        else if ("KP_Multiply".equals(keyStrokeName)) {
1324            return '*';
1325        }
1326        else if ("KP_Subtract".equals(keyStrokeName)) {
1327            return '-';
1328        }
1329        else if ("KP_Add".equals(keyStrokeName)) {
1330            return '+';
1331        }
1332        else if ("KP_Enter".equals(keyStrokeName)) {
1333            return '\n';
1334        }
1335        else if ("KP_Decimal".equals(keyStrokeName)) {
1336            return ',';
1337        }
1338        else if ("KP_Separator".equals(keyStrokeName)) {
1339            return ',';
1340        }
1341        else if ("KP_Delete".equals(keyStrokeName)) {
1342            return Character.UNASSIGNED;
1343        }
1344        else if ("KP_0".equals(keyStrokeName)) {
1345            return '0';
1346        }
1347        else if ("KP_Insert".equals(keyStrokeName)) {
1348            return Character.UNASSIGNED;
1349        }
1350        else if ("KP_1".equals(keyStrokeName)) {
1351            return '1';
1352        }
1353        else if ("KP_End".equals(keyStrokeName)) {
1354            return Character.UNASSIGNED;
1355        }
1356        else if ("KP_2".equals(keyStrokeName)) {
1357            return '2';
1358        }
1359        else if ("KP_Down".equals(keyStrokeName)) {
1360            return Character.UNASSIGNED;
1361        }
1362        else if ("KP_3".equals(keyStrokeName)) {
1363            return '3';
1364        }
1365        else if ("KP_Next".equals(keyStrokeName)) {
1366            return Character.UNASSIGNED;
1367        }
1368        else if ("KP_4".equals(keyStrokeName)) {
1369            return '4';
1370        }
1371        else if ("KP_Left".equals(keyStrokeName)) {
1372            return Character.UNASSIGNED;
1373        }
1374        else if ("KP_5".equals(keyStrokeName)) {
1375            return '5';
1376        }
1377        else if ("KP_Begin".equals(keyStrokeName)) {
1378            return Character.UNASSIGNED;
1379        }
1380        else if ("KP_6".equals(keyStrokeName)) {
1381            return '6';
1382        }
1383        else if ("KP_Right".equals(keyStrokeName)) {
1384            return Character.UNASSIGNED;
1385        }
1386        else if ("KP_7".equals(keyStrokeName)) {
1387            return '7';
1388        }
1389        else if ("KP_Home".equals(keyStrokeName)) {
1390            return Character.UNASSIGNED;
1391        }
1392        else if ("KP_8".equals(keyStrokeName)) {
1393            return '8';
1394        }
1395        else if ("KP_Up".equals(keyStrokeName)) {
1396            return Character.UNASSIGNED;
1397        }
1398        else if ("KP_9".equals(keyStrokeName)) {
1399            return '9';
1400        }
1401        else if ("KP_Prior".equals(keyStrokeName)) {
1402            return Character.UNASSIGNED;
1403        }
1404        else if ("Caps_Lock".equals(keyStrokeName)) {
1405            return Character.UNASSIGNED;
1406        }
1407        else if ("Multi_key".equals(keyStrokeName)) {
1408            return Character.UNASSIGNED;
1409        }
1410        else if ("exclam".equals(keyStrokeName)) {
1411            return '!';
1412        }
1413        else if ("onesuperior".equals(keyStrokeName)) {
1414            return '¹';
1415        }
1416        else if ("exclamdown".equals(keyStrokeName)) {
1417            return '¡';
1418        }
1419        else if ("quotedbl".equals(keyStrokeName)) {
1420            return '"';
1421        }
1422        else if ("twosuperior".equals(keyStrokeName)) {
1423            return '²';
1424        }
1425        else if ("oneeighth".equals(keyStrokeName)) {
1426            return '⅛';
1427        }
1428        else if ("section".equals(keyStrokeName)) {
1429            return '§';
1430        }
1431        else if ("threesuperior".equals(keyStrokeName)) {
1432            return '³';
1433        }
1434        else if ("sterling".equals(keyStrokeName)) {
1435            return '£';
1436        }
1437        else if ("dollar".equals(keyStrokeName)) {
1438            return '$';
1439        }
1440        else if ("onequarter".equals(keyStrokeName)) {
1441            return '¼';
1442        }
1443        else if ("currency".equals(keyStrokeName)) {
1444            return '¤';
1445        }
1446        else if ("percent".equals(keyStrokeName)) {
1447            return '%';
1448        }
1449        else if ("onehalf".equals(keyStrokeName)) {
1450            return '½';
1451        }
1452        else if ("threeeighths".equals(keyStrokeName)) {
1453            return '⅜';
1454        }
1455        else if ("ampersand".equals(keyStrokeName)) {
1456            return '&';
1457        }
1458        else if ("threequarters".equals(keyStrokeName)) {
1459            return '¾';
1460        }
1461        else if ("fiveeighths".equals(keyStrokeName)) {
1462            return '⅝';
1463        }
1464        else if ("slash".equals(keyStrokeName)) {
1465            return '/';
1466        }
1467        else if ("braceleft".equals(keyStrokeName)) {
1468            return '{';
1469        }
1470        else if ("seveneighths".equals(keyStrokeName)) {
1471            return '⅞';
1472        }
1473        else if ("parenleft".equals(keyStrokeName)) {
1474            return '(';
1475        }
1476        else if ("bracketleft".equals(keyStrokeName)) {
1477            return '[';
1478        }
1479        else if ("trademark".equals(keyStrokeName)) {
1480            return '™';
1481        }
1482        else if ("parenright".equals(keyStrokeName)) {
1483            return ')';
1484        }
1485        else if ("bracketright".equals(keyStrokeName)) {
1486            return ']';
1487        }
1488        else if ("plusminus".equals(keyStrokeName)) {
1489            return '±';
1490        }
1491        else if ("equal".equals(keyStrokeName)) {
1492            return '=';
1493        }
1494        else if ("braceright".equals(keyStrokeName)) {
1495            return '}';
1496        }
1497        else if ("ssharp".equals(keyStrokeName)) {
1498            return 'ß';
1499        }
1500        else if ("question".equals(keyStrokeName)) {
1501            return '?';
1502        }
1503        else if ("backslash".equals(keyStrokeName)) {
1504            return '\\';
1505        }
1506        else if ("questiondown".equals(keyStrokeName)) {
1507            return '¿';
1508        }
1509        else if ("acute".equals(keyStrokeName)) {
1510            return '´';
1511        }
1512        else if ("dead_acute".equals(keyStrokeName)) {
1513            return 0x0301;
1514        }
1515        else if ("grave".equals(keyStrokeName)) {
1516            return '`';
1517        }
1518        else if ("dead_grave".equals(keyStrokeName)) {
1519            return 0x0300;
1520        }
1521        else if ("dead_cedilla".equals(keyStrokeName)) {
1522            return 0x0327;
1523        }
1524        else if ("dead_ogonek".equals(keyStrokeName)) {
1525            return 0x0328;
1526        }
1527        else if ("at".equals(keyStrokeName)) {
1528            return '@';
1529        }
1530        else if ("Greek_OMEGA".equals(keyStrokeName)) {
1531            return 'Ω';
1532        }
1533        else if ("EuroSign".equals(keyStrokeName)) {
1534            return '€';
1535        }
1536        else if ("paragraph".equals(keyStrokeName)) {
1537            return 0x2029;
1538        }
1539        else if ("registered".equals(keyStrokeName)) {
1540            return '®';
1541        }
1542        else if ("tslash".equals(keyStrokeName)) {
1543            return 'ŧ';
1544        }
1545        else if ("Tslash".equals(keyStrokeName)) {
1546            return 'Ŧ';
1547        }
1548        else if ("z".equals(keyStrokeName)) {
1549            return getUpper ? 'Z' : 'z';
1550        }
1551        else if ("leftarrow".equals(keyStrokeName)) {
1552            return '←';
1553        }
1554        else if ("yen".equals(keyStrokeName)) {
1555            return '¥';
1556        }
1557        else if ("downarrow".equals(keyStrokeName)) {
1558            return '↓';
1559        }
1560        else if ("uparrow".equals(keyStrokeName)) {
1561            return '↑';
1562        }
1563        else if ("rightarrow".equals(keyStrokeName)) {
1564            return '→';
1565        }
1566        else if ("idotless".equals(keyStrokeName)) {
1567            return 'ı';
1568        }
1569        else if ("oslash".equals(keyStrokeName)) {
1570            return 'ø';
1571        }
1572        else if ("Ooblique".equals(keyStrokeName)) {
1573            return 'Ø';
1574        }
1575        else if ("thorn".equals(keyStrokeName)) {
1576            return 'þ';
1577        }
1578        else if ("THORN".equals(keyStrokeName)) {
1579            return 'Þ';
1580        }
1581        else if ("udiaeresis".equals(keyStrokeName)) {
1582            return getUpper ? 'Ü' : 'ü';
1583        }
1584        else if ("Udiaeresis".equals(keyStrokeName)) {
1585            return getUpper ? 'Ü' : 'ü';
1586        }
1587        else if ("dead_diaeresis".equals(keyStrokeName)) {
1588            return 0x0308;
1589        }
1590        else if ("dead_abovering".equals(keyStrokeName)) {
1591            return 0x030A;
1592        }
1593        else if ("plus".equals(keyStrokeName)) {
1594            return '+';
1595        }
1596        else if ("asterisk".equals(keyStrokeName)) {
1597            return '*';
1598        }
1599        else if ("asciitilde".equals(keyStrokeName)) {
1600            return '~';
1601        }
1602        else if ("dead_tilde".equals(keyStrokeName)) {
1603            return 0x0303;
1604        }
1605        else if ("dead_macron".equals(keyStrokeName)) {
1606            return 0x0304;
1607        }
1608        else if ("ae".equals(keyStrokeName)) {
1609            return 'æ';
1610        }
1611        else if ("AE".equals(keyStrokeName)) {
1612            return 'Æ';
1613        }
1614        else if ("eth".equals(keyStrokeName)) {
1615            return 'ð';
1616        }
1617        else if ("ETH".equals(keyStrokeName)) {
1618            return 'Ð';
1619        }
1620        else if ("dstroke".equals(keyStrokeName)) {
1621            return getUpper ? 'Đ' : 'đ';
1622        }
1623        else if ("ordfeminine".equals(keyStrokeName)) {
1624            return 'ª';
1625        }
1626        else if ("eng".equals(keyStrokeName)) {
1627            return 'ŋ';
1628        }
1629        else if ("ENG".equals(keyStrokeName)) {
1630            return 'Ŋ';
1631        }
1632        else if ("hstroke".equals(keyStrokeName)) {
1633            return 'ħ';
1634        }
1635        else if ("Hstroke".equals(keyStrokeName)) {
1636            return 'Ħ';
1637        }
1638        else if ("kra".equals(keyStrokeName)) {
1639            return 'ĸ';
1640        }
1641        else if ("odiaeresis".equals(keyStrokeName)) {
1642            return 'ö';
1643        }
1644        else if ("Odiaeresis".equals(keyStrokeName)) {
1645            return 'Ö';
1646        }
1647        else if ("dead_doubleacute".equals(keyStrokeName)) {
1648            return 0x030B;
1649        }
1650        else if ("adiaeresis".equals(keyStrokeName)) {
1651            return 'ä';
1652        }
1653        else if ("Adiaeresis".equals(keyStrokeName)) {
1654            return 'Ä';
1655        }
1656        else if ("dead_caron".equals(keyStrokeName)) {
1657            return 0x030C;
1658        }
1659        else if ("asciicircum".equals(keyStrokeName)) {
1660            return '^';
1661        }
1662        else if ("dead_circumflex".equals(keyStrokeName)) {
1663            return 0x0302;
1664        }
1665        else if ("degree".equals(keyStrokeName)) {
1666            return '°';
1667        }
1668        else if ("notsign".equals(keyStrokeName)) {
1669            return '¬';
1670        }
1671        else if ("numbersign".equals(keyStrokeName)) {
1672            return '#';
1673        }
1674        else if ("apostrophe".equals(keyStrokeName)) {
1675            return '\'';
1676        }
1677        else if ("dead_breve".equals(keyStrokeName)) {
1678            return 0x0306;
1679        }
1680        else if ("y".equals(keyStrokeName)) {
1681            return getUpper ? 'Y' : 'y';
1682        }
1683        else if ("guillemotleft".equals(keyStrokeName)) {
1684            return '»';
1685        }
1686        else if ("guillemotright".equals(keyStrokeName)) {
1687            return '«';
1688        }
1689        else if ("cent".equals(keyStrokeName)) {
1690            return '¢';
1691        }
1692        else if ("copyright".equals(keyStrokeName)) {
1693            return '©';
1694        }
1695        else if ("leftdoublequotemark".equals(keyStrokeName)) {
1696            return '„';
1697        }
1698        else if ("rightdoublequotemark".equals(keyStrokeName)) {
1699            return '“';
1700        }
1701        else if ("mu".equals(keyStrokeName)) {
1702            return 'µ';
1703        }
1704        else if ("masculine".equals(keyStrokeName)) {
1705            return 'º';
1706        }
1707        else if ("comma".equals(keyStrokeName)) {
1708            return ',';
1709        }
1710        else if ("semicolon".equals(keyStrokeName)) {
1711            return ';';
1712        }
1713        else if ("horizconnector".equals(keyStrokeName)) {
1714            return '·';
1715        }
1716        else if ("multiply".equals(keyStrokeName)) {
1717            return '×';
1718        }
1719        else if ("period".equals(keyStrokeName)) {
1720            return '.';
1721        }
1722        else if ("colon".equals(keyStrokeName)) {
1723            return ':';
1724        }
1725        else if ("periodcentered".equals(keyStrokeName)) {
1726            return '…';
1727        }
1728        else if ("division".equals(keyStrokeName)) {
1729            return '÷';
1730        }
1731        else if ("minus".equals(keyStrokeName)) {
1732            return '-';
1733        }
1734        else if ("underscore".equals(keyStrokeName)) {
1735            return '_';
1736        }
1737        else if ("dead_belowdot".equals(keyStrokeName)) {
1738            return 0x0323;
1739        }
1740        else if ("dead_abovedot".equals(keyStrokeName)) {
1741            return 0x0307;
1742        }
1743        else if ("eacute".equals(keyStrokeName)) {
1744            return getUpper ? 'É' : 'é';
1745        }
1746        else if ("Eacute".equals(keyStrokeName)) {
1747            return getUpper ? 'É' : 'é';
1748        }
1749        else if ("egrave".equals(keyStrokeName)) {
1750            return getUpper ? 'È' : 'è';
1751        }
1752        else if ("Egrave".equals(keyStrokeName)) {
1753            return getUpper ? 'È' : 'è';
1754        }
1755        else if ("ccedilla".equals(keyStrokeName)) {
1756            return getUpper ? 'Ç' : 'ç';
1757        }
1758        else if ("Ccedilla".equals(keyStrokeName)) {
1759            return getUpper ? 'Ç' : 'ç';
1760        }
1761        else if ("agrave".equals(keyStrokeName)) {
1762            return getUpper ? 'À' : 'à';
1763        }
1764        else if ("Agrave".equals(keyStrokeName)) {
1765            return getUpper ? 'À' : 'à';
1766        }
1767        else if ("lstroke".equals(keyStrokeName)) {
1768            return getUpper ? 'Ł' : 'ł';
1769        }
1770        else if ("Lstroke".equals(keyStrokeName)) {
1771            return getUpper ? 'Ł' : 'ł';
1772        }
1773        else if ("ugrave".equals(keyStrokeName)) {
1774            return getUpper ? 'Ù' : 'ù';
1775        }
1776        else if ("Ugrave".equals(keyStrokeName)) {
1777            return getUpper ? 'Ù' : 'ù';
1778        }
1779        else if ("igrave".equals(keyStrokeName)) {
1780            return getUpper ? 'Ì' : 'ì';
1781        }
1782        else if ("Igrave".equals(keyStrokeName)) {
1783            return getUpper ? 'Ì' : 'ì';
1784        }
1785        else if ("ograve".equals(keyStrokeName)) {
1786            return getUpper ? 'Ò' : 'ò';
1787        }
1788        else if ("ograve".equals(keyStrokeName)) {
1789            return getUpper ? 'Ò' : 'ò';
1790        }
1791        else if ("keyboard_type".equals(keyStrokeName)) {
1792            return Character.UNASSIGNED;
1793        }
1794        else if ("keyboard_subtype".equals(keyStrokeName)) {
1795            return Character.UNASSIGNED;
1796        }
1797        else if ("keyboard_functionkeys".equals(keyStrokeName)) {
1798            return Character.UNASSIGNED;
1799        }
1800        else if ("kana_NU".equals(keyStrokeName)) {
1801            return 'ヌ';
1802        }
1803        else if ("kana_FU".equals(keyStrokeName)) {
1804            return 'フ';
1805        }
1806        else if ("kana_A".equals(keyStrokeName)) {
1807            return 'ア';
1808        }
1809        else if ("kana_a".equals(keyStrokeName)) {
1810            return 'ァ';
1811        }
1812        else if ("kana_U".equals(keyStrokeName)) {
1813            return 'ウ';
1814        }
1815        else if ("kana_u".equals(keyStrokeName)) {
1816            return 'ゥ';
1817        }
1818        else if ("kana_E".equals(keyStrokeName)) {
1819            return 'エ';
1820        }
1821        else if ("kana_e".equals(keyStrokeName)) {
1822            return 'ェ';
1823        }
1824        else if ("kana_O".equals(keyStrokeName)) {
1825            return 'オ';
1826        }
1827        else if ("kana_o".equals(keyStrokeName)) {
1828            return 'ォ';
1829        }
1830        else if ("kana_YA".equals(keyStrokeName)) {
1831            return 'ヤ';
1832        }
1833        else if ("kana_ya".equals(keyStrokeName)) {
1834            return 'ャ';
1835        }
1836        else if ("kana_YU".equals(keyStrokeName)) {
1837            return 'ユ';
1838        }
1839        else if ("kana_yu".equals(keyStrokeName)) {
1840            return 'ュ';
1841        }
1842        else if ("kana_YO".equals(keyStrokeName)) {
1843            return 'ヨ';
1844        }
1845        else if ("kana_yo".equals(keyStrokeName)) {
1846            return 'ョ';
1847        }
1848        else if ("kana_WA".equals(keyStrokeName)) {
1849            return 'ワ';
1850        }
1851        else if ("kana_WO".equals(keyStrokeName)) {
1852            return 'ヲ';
1853        }
1854        else if ("kana_HO".equals(keyStrokeName)) {
1855            return 'ホ';
1856        }
1857        else if ("kana_HE".equals(keyStrokeName)) {
1858            return 'ヘ';
1859        }
1860        else if ("kana_TA".equals(keyStrokeName)) {
1861            return 'タ';
1862        }
1863        else if ("kana_TE".equals(keyStrokeName)) {
1864            return 'テ';
1865        }
1866        else if ("kana_I".equals(keyStrokeName)) {
1867            return 'イ';
1868        }
1869        else if ("kana_i".equals(keyStrokeName)) {
1870            return 'ィ';
1871        }
1872        else if ("kana_SU".equals(keyStrokeName)) {
1873            return 'ス';
1874        }
1875        else if ("kana_KA".equals(keyStrokeName)) {
1876            return 'カ';
1877        }
1878        else if ("kana_N".equals(keyStrokeName)) {
1879            return 'ン';
1880        }
1881        else if ("kana_NA".equals(keyStrokeName)) {
1882            return 'ナ';
1883        }
1884        else if ("kana_NI".equals(keyStrokeName)) {
1885            return 'ニ';
1886        }
1887        else if ("kana_RA".equals(keyStrokeName)) {
1888            return 'ラ';
1889        }
1890        else if ("kana_SE".equals(keyStrokeName)) {
1891            return 'セ';
1892        }
1893        else if ("voicedsound".equals(keyStrokeName)) {
1894            return 0x3099;
1895        }
1896        else if ("semivoicedsound".equals(keyStrokeName)) {
1897            return 0x309A;
1898        }
1899        else if ("kana_openingbracket".equals(keyStrokeName)) {
1900            return 0x04A2;
1901        }
1902        else if ("kana_closingbracket".equals(keyStrokeName)) {
1903            return 0x04A3;
1904        }
1905        else if ("kana_CHI".equals(keyStrokeName)) {
1906            return 'チ';
1907        }
1908        else if ("kana_TO".equals(keyStrokeName)) {
1909            return 'ト';
1910        }
1911        else if ("kana_SHI".equals(keyStrokeName)) {
1912            return 'シ';
1913        }
1914        else if ("kana_HA".equals(keyStrokeName)) {
1915            return 'ハ';
1916        }
1917        else if ("kana_KI".equals(keyStrokeName)) {
1918            return 'キ';
1919        }
1920        else if ("kana_KU".equals(keyStrokeName)) {
1921            return 'ク';
1922        }
1923        else if ("kana_MA".equals(keyStrokeName)) {
1924            return 'マ';
1925        }
1926        else if ("kana_NO".equals(keyStrokeName)) {
1927            return 'ノ';
1928        }
1929        else if ("kana_RI".equals(keyStrokeName)) {
1930            return 'リ';
1931        }
1932        else if ("kana_RE".equals(keyStrokeName)) {
1933            return 'レ';
1934        }
1935        else if ("kana_KE".equals(keyStrokeName)) {
1936            return 'ケ';
1937        }
1938        else if ("Zenkaku_Hankaku".equals(keyStrokeName)) {
1939            return Character.UNASSIGNED;
1940        }
1941        else if ("Kanji".equals(keyStrokeName)) {
1942            return Character.UNASSIGNED;
1943        }
1944        else if ("kana_MU".equals(keyStrokeName)) {
1945            return 'ム';
1946        }
1947        else if ("kana_TSU".equals(keyStrokeName)) {
1948            return 'ツ';
1949        }
1950        else if ("kana_tsu".equals(keyStrokeName)) {
1951            return 'ッ';
1952        }
1953        else if ("kana_SA".equals(keyStrokeName)) {
1954            return 'サ';
1955        }
1956        else if ("kana_SO".equals(keyStrokeName)) {
1957            return 'ソ';
1958        }
1959        else if ("kana_HI".equals(keyStrokeName)) {
1960            return 'ヒ';
1961        }
1962        else if ("kana_KO".equals(keyStrokeName)) {
1963            return 'コ';
1964        }
1965        else if ("kana_MI".equals(keyStrokeName)) {
1966            return 'ミ';
1967        }
1968        else if ("kana_MO".equals(keyStrokeName)) {
1969            return 'モ';
1970        }
1971        else if ("kana_NE".equals(keyStrokeName)) {
1972            return 'ネ';
1973        }
1974        else if ("kana_comma".equals(keyStrokeName)) {
1975            return '､';
1976        }
1977        else if ("kana_RU".equals(keyStrokeName)) {
1978            return 'ル';
1979        }
1980        else if ("kana_fullstop".equals(keyStrokeName)) {
1981            return '｡';
1982        }
1983        else if ("kana_ME".equals(keyStrokeName)) {
1984            return 'メ';
1985        }
1986        else if ("kana_conjunctive".equals(keyStrokeName)) {
1987            return Character.UNASSIGNED;
1988        }
1989        else if ("Henkan_Mode".equals(keyStrokeName)) {
1990            return Character.UNASSIGNED;
1991        }
1992        else if ("Hiragana_Katakana".equals(keyStrokeName)) {
1993            return Character.UNASSIGNED;
1994        }
1995        else if ("Katakana".equals(keyStrokeName)) {
1996            return Character.UNASSIGNED;
1997        }
1998        else if ("Romaji".equals(keyStrokeName)) {
1999            return Character.UNASSIGNED;
2000        }
2001        else if ("Muhenkan".equals(keyStrokeName)) {
2002            return Character.UNASSIGNED;
2003        }
2004        else if ("Eisu_toggle".equals(keyStrokeName)) {
2005            return Character.UNASSIGNED;
2006        }
2007        else if ("Eisu_toggle".equals(keyStrokeName)) {
2008            return Character.UNASSIGNED;
2009        }
2010        else if ("F13".equals(keyStrokeName)) {
2011            return Character.UNASSIGNED;
2012        }
2013        else if ("Hangul".equals(keyStrokeName)) {
2014            return Character.UNASSIGNED;
2015        }
2016        else if ("Hangul_Hanja".equals(keyStrokeName)) {
2017            return Character.UNASSIGNED;
2018        }
2019        else {
2020            Console.traceln(Level.SEVERE, "unknown key stroke name " + keyStrokeName +
2021                            " specified through keyboard map " + "for locale " + locale);
2022
2023            // if (shift)
2024            // {
2025            // System.err.println("    else if (\"" + keyStrokeName + "\".equals(keyStrokeName))");
2026            // System.err.println("    {");
2027            // System.err.println("      return shift ? '" +
2028            // Character.toUpperCase(keyStrokeName.charAt(0)) +
2029            // "' : '" + Character.toLowerCase(keyStrokeName.charAt(0)) + "';");
2030            // System.err.println("    }");
2031            // }
2032            // else
2033            // {
2034            // System.err.println("    else if (\"" + keyStrokeName + "\".equals(keyStrokeName))");
2035            // System.err.println("    {");
2036            // System.err.println("      return '" + keyStrokeName + "';");
2037            // System.err.println("    }");
2038            // }
2039            //
2040            // return 0x0;
2041            throw new IllegalArgumentException("no keyboard map available for locale " + locale);
2042        }
2043    }
2044
2045    /**
2046     * this is a former implementation
2047     *
2048     * @param keyId
2049     * @return
2050     */
2051    /*
2052     * private VirtualKey[] mapKeyIdToVirtualKeys(int keyId, String keyStrokeName) {
2053     *
2054     * Set<String> names = null;
2055     *
2056     * for (int i = 0; i < mKeyIds.size(); i++) { if (((Integer) mKeyIds.get(i)[0]) == keyId) {
2057     * names = (Set<String>) mKeyIds.get(i)[1]; break; } }
2058     *
2059     * if (names == null) { names = new HashSet<String>(); boolean added = false;
2060     *
2061     * for (int i = 0; i < mKeyIds.size(); i++) { if (((Integer) mKeyIds.get(i)[0]) > keyId) {
2062     * mKeyIds.add(i, new Object[] { keyId, names }); added = true; break; } }
2063     *
2064     * if (!added) { mKeyIds.add(new Object[] { keyId, names }); } }
2065     *
2066     * names.add(keyStrokeName);
2067     *
2068     *
2069     * switch(keyId) { case 0x36: case 0x2a: return new VirtualKey[] { VirtualKey.SHIFT }; case
2070     * 0xb8: return new VirtualKey[] { VirtualKey.ALT_GRAPH }; case 0x38: return new VirtualKey[] {
2071     * VirtualKey.ALT }; case 0x9d: case 0x1d: return new VirtualKey[] { VirtualKey.CONTROL }; case
2072     * 0xdd: return new VirtualKey[] { VirtualKey.WINDOWS }; case 0x2: return new VirtualKey[] {
2073     * VirtualKey.DIGIT_1 }; case 0x3: return new VirtualKey[] { VirtualKey.DIGIT_2 }; case 0x4:
2074     * return new VirtualKey[] { VirtualKey.DIGIT_3 }; case 0x5: return new VirtualKey[] {
2075     * VirtualKey.DIGIT_4 }; case 0x6: return new VirtualKey[] { VirtualKey.DIGIT_5 }; case 0x7:
2076     * return new VirtualKey[] { VirtualKey.DIGIT_6 }; case 0x8: return new VirtualKey[] {
2077     * VirtualKey.DIGIT_7 }; case 0x9: return new VirtualKey[] { VirtualKey.DIGIT_8 }; case 0xa:
2078     * return new VirtualKey[] { VirtualKey.DIGIT_9 }; case 0xb: return new VirtualKey[] {
2079     * VirtualKey.DIGIT_0 }; case 0xe: return new VirtualKey[] { VirtualKey.BACK_SPACE }; case 0xf:
2080     * return new VirtualKey[] { VirtualKey.TAB }; case 0x10: return new VirtualKey[] {
2081     * VirtualKey.LETTER_Q }; case 0x11: return new VirtualKey[] { VirtualKey.LETTER_W }; case 0x12:
2082     * return new VirtualKey[] { VirtualKey.LETTER_E }; case 0x13: return new VirtualKey[] {
2083     * VirtualKey.LETTER_R }; case 0x14: return new VirtualKey[] { VirtualKey.LETTER_T }; case 0x15:
2084     * return new VirtualKey[] { VirtualKey.LETTER_Y }; case 0x16: return new VirtualKey[] {
2085     * VirtualKey.LETTER_U }; case 0x17: return new VirtualKey[] { VirtualKey.LETTER_I }; case 0x18:
2086     * return new VirtualKey[] { VirtualKey.LETTER_O }; case 0x19: return new VirtualKey[] {
2087     * VirtualKey.LETTER_P }; case 0x1e: return new VirtualKey[] { VirtualKey.LETTER_A }; case 0x1f:
2088     * return new VirtualKey[] { VirtualKey.LETTER_S }; case 0x20: return new VirtualKey[] {
2089     * VirtualKey.LETTER_D }; case 0x21: return new VirtualKey[] { VirtualKey.LETTER_F }; case 0x22:
2090     * return new VirtualKey[] { VirtualKey.LETTER_G }; case 0x23: return new VirtualKey[] {
2091     * VirtualKey.LETTER_H }; case 0x24: return new VirtualKey[] { VirtualKey.LETTER_J }; case 0x25:
2092     * return new VirtualKey[] { VirtualKey.LETTER_K }; case 0x26: return new VirtualKey[] {
2093     * VirtualKey.LETTER_L }; case 0x1c: return new VirtualKey[] { VirtualKey.ENTER }; case 0x2c:
2094     * return new VirtualKey[] { VirtualKey.LETTER_Z }; case 0x2d: return new VirtualKey[] {
2095     * VirtualKey.LETTER_X }; case 0x2e: return new VirtualKey[] { VirtualKey.LETTER_C }; case 0x2f:
2096     * return new VirtualKey[] { VirtualKey.LETTER_V }; case 0x30: return new VirtualKey[] {
2097     * VirtualKey.LETTER_B }; case 0x31: return new VirtualKey[] { VirtualKey.LETTER_N }; case 0x32:
2098     * return new VirtualKey[] { VirtualKey.LETTER_M }; case 0x39: return new VirtualKey[] {
2099     * VirtualKey.SPACE }; case 0x56: return new VirtualKey[] { VirtualKey.LESS }; case 0x1: return
2100     * new VirtualKey[] { VirtualKey.ESCAPE }; case 0x3b: return new VirtualKey[] { VirtualKey.F1 };
2101     * case 0x3c: return new VirtualKey[] { VirtualKey.F2 }; case 0x3d: return new VirtualKey[] {
2102     * VirtualKey.F3 }; case 0x3e: return new VirtualKey[] { VirtualKey.F4 }; case 0x3f: return new
2103     * VirtualKey[] { VirtualKey.F5 }; case 0x40: return new VirtualKey[] { VirtualKey.F6 }; case
2104     * 0x41: return new VirtualKey[] { VirtualKey.F7 }; case 0x42: return new VirtualKey[] {
2105     * VirtualKey.F8 }; case 0x43: return new VirtualKey[] { VirtualKey.F9 }; case 0x44: return new
2106     * VirtualKey[] { VirtualKey.F10 }; case 0x57: return new VirtualKey[] { VirtualKey.F11 }; case
2107     * 0x58: return new VirtualKey[] { VirtualKey.F12 }; case 0xb7: return new VirtualKey[] {
2108     * VirtualKey.PRINTSCREEN }; case 0x46: return new VirtualKey[] { VirtualKey.SCROLL_LOCK }; case
2109     * 0xd2: return new VirtualKey[] { VirtualKey.INSERT }; case 0xd3: return new VirtualKey[] {
2110     * VirtualKey.DELETE }; case 0xc7: return new VirtualKey[] { VirtualKey.HOME }; case 0xcf:
2111     * return new VirtualKey[] { VirtualKey.END }; case 0xc9: return new VirtualKey[] {
2112     * VirtualKey.PAGE_UP }; case 0xd1: return new VirtualKey[] { VirtualKey.PAGE_DOWN }; case 0xcb:
2113     * return new VirtualKey[] { VirtualKey.LEFT }; case 0xc8: return new VirtualKey[] {
2114     * VirtualKey.UP }; case 0xd0: return new VirtualKey[] { VirtualKey.DOWN }; case 0xcd: return
2115     * new VirtualKey[] { VirtualKey.RIGHT }; case 0x45: return new VirtualKey[] {
2116     * VirtualKey.NUM_LOCK }; case 0xb5: return new VirtualKey[] { VirtualKey.DIVIDE }; case 0x37:
2117     * return new VirtualKey[] { VirtualKey.MULTIPLY }; case 0x4a: return new VirtualKey[] {
2118     * VirtualKey.SUBTRACT }; case 0x4e: return new VirtualKey[] { VirtualKey.ADD }; case 0x9c:
2119     * return new VirtualKey[] { VirtualKey.ENTER }; case 0x53: return new VirtualKey[] {
2120     * VirtualKey.DECIMAL, VirtualKey.DELETE }; case 0x52: return new VirtualKey[] {
2121     * VirtualKey.NUMPAD_0, VirtualKey.INSERT }; case 0x4f: return new VirtualKey[] {
2122     * VirtualKey.NUMPAD_1, VirtualKey.END }; case 0x50: return new VirtualKey[] {
2123     * VirtualKey.NUMPAD_2, VirtualKey.KP_DOWN }; case 0x51: return new VirtualKey[] {
2124     * VirtualKey.NUMPAD_3, VirtualKey.PAGE_UP }; case 0x4b: return new VirtualKey[] {
2125     * VirtualKey.NUMPAD_4, VirtualKey.KP_LEFT }; case 0x4c: return new VirtualKey[] {
2126     * VirtualKey.NUMPAD_5, VirtualKey.BEGIN }; case 0x4d: return new VirtualKey[] {
2127     * VirtualKey.NUMPAD_6, VirtualKey.KP_RIGHT }; case 0x47: return new VirtualKey[] {
2128     * VirtualKey.NUMPAD_7, VirtualKey.HOME }; case 0x48: return new VirtualKey[] {
2129     * VirtualKey.NUMPAD_8, VirtualKey.KP_UP }; case 0x49: return new VirtualKey[] {
2130     * VirtualKey.NUMPAD_9, VirtualKey.PAGE_DOWN }; case 0x0: return new VirtualKey[] {
2131     * VirtualKey.CAPS_LOCK }; case 0xc: return new VirtualKey[] { VirtualKey.MINUS,
2132     * VirtualKey.UNDERSCORE }; case 0xd: return new VirtualKey[] { VirtualKey.EQUALS,
2133     * VirtualKey.PLUS }; case 0x1a: return new VirtualKey[] { VirtualKey.OPEN_BRACKET,
2134     * VirtualKey.BRACELEFT }; case 0x1b: return new VirtualKey[] { VirtualKey.CLOSE_BRACKET,
2135     * VirtualKey.BRACERIGHT }; case 0x27: return new VirtualKey[] { VirtualKey.SEMICOLON,
2136     * VirtualKey.COLON }; /* case 0x28: return new VirtualKey[] { VirtualKey.APOSTROPHE,
2137     * VirtualKey.QUOTEDBL }; case 0x29: return new VirtualKey[] { VirtualKey.DEAD_GRAVE,
2138     * VirtualKey.DEAD_TILDE }; case 0x2b: return new VirtualKey[] { VirtualKey.BACK_SLASH,
2139     * VirtualKey.BAR }; case 0x33: return new VirtualKey[] { VirtualKey.COMMA, VirtualKey.LESS };
2140     * case 0x34: return new VirtualKey[] { VirtualKey.PERIOD, VirtualKey.GREATER }; case 0x35:
2141     * return new VirtualKey[] { VirtualKey.SLASH, VirtualKey.QUESTIONMARK }; case 0x73: return new
2142     * VirtualKey[] { VirtualKey.BACK_SLASH, VirtualKey.DEGREE, VirtualKey.QUESTIONMARK,
2143     * VirtualKey.UNDERSCORE }; case 0x7d: return new VirtualKey[] { VirtualKey.BAR }; case 0x79:
2144     * return new VirtualKey[] { VirtualKey.HENKAN_MODE }; case 0x70: return new VirtualKey[] {
2145     * VirtualKey.KATAKANA }; case 0x7b: return new VirtualKey[] { VirtualKey.MUHENKAN }; case 0x3a:
2146     * return new VirtualKey[] { VirtualKey.EISU_TOGGLE, VirtualKey.CAPS_LOCK }; case 0xdc: return
2147     * new VirtualKey[] { VirtualKey.F13 }; case 0xf2: return new VirtualKey[] { VirtualKey.HANGUL
2148     * }; case 0xf1: return new VirtualKey[] { VirtualKey.HANGUL_HANJA }; case 0x54: return new
2149     * VirtualKey[] { VirtualKey.EXECUTE }; default: LOG.severe("unknown key id 0x" +
2150     * Integer.toHexString(keyId) + " specified for key stroke " + keyStrokeName +
2151     * " through keyboard map for locale " + mLocale); throw new
2152     * IllegalArgumentException("no keyboard map available for locale " + mLocale); } }
2153     */
2154
2155}
Note: See TracBrowser for help on using the repository browser.