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

Last change on this file since 447 was 447, checked in by pharms, 12 years ago

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