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

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