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

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