libjava/classpath/java/awt/AWTKeyStroke.java

   1 /* AWTKeyStroke.java -- an immutable key stroke
   2    Copyright (C) 2002, 2004, 2005, 2006 Free Software Foundation
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 02110-1301 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package java.awt;
  40
  41 import java.awt.event.InputEvent;
  42 import java.awt.event.KeyEvent;
  43 import java.io.ObjectStreamException;
  44 import java.io.Serializable;
  45 import java.lang.reflect.Constructor;
  46 import java.lang.reflect.Field;
  47 import java.lang.reflect.InvocationTargetException;
  48 import java.security.AccessController;
  49 import java.security.PrivilegedAction;
  50 import java.security.PrivilegedActionException;
  51 import java.security.PrivilegedExceptionAction;
  52 import java.util.HashMap;
  53 import java.util.LinkedHashMap;
  54 import java.util.Map;
  55 import java.util.StringTokenizer;
  56
  57 /**
  58  * This class mirrors KeyEvents, representing both low-level key presses and
  59  * key releases, and high level key typed inputs. However, this class forms
  60  * immutable strokes, and can be efficiently reused via the factory methods
  61  * for creating them.
  62  *
  63  * <p>For backwards compatibility with Swing, this supports a way to build
  64  * instances of a subclass, using reflection, provided the subclass has a
  65  * no-arg constructor (of any accessibility).
  66  *
  67  * @author Eric Blake (ebb9@email.byu.edu)
  68  * @author Andrew John Hughes (gnu_andrew@member.fsf.org)
  69  * @see #getAWTKeyStroke(char)
  70  * @since 1.4
  71  * @status updated to 1.4
  72  */
  73 public class AWTKeyStroke implements Serializable
  74 {
  75   /**
  76    * Compatible with JDK 1.4+.
  77    */
  78   private static final long serialVersionUID = -6430539691155161871L;
  79
  80   /** The mask for modifiers. */
  81   private static final int MODIFIERS_MASK = 0x3fef;
  82
  83   /**
  84    * The cache of recently created keystrokes. This maps KeyStrokes to
  85    * KeyStrokes in a cache which removes the least recently accessed entry,
  86    * under the assumption that garbage collection of a new keystroke is
  87    * easy when we find the old one that it matches in the cache.
  88    */
  89   private static final LinkedHashMap<AWTKeyStroke,AWTKeyStroke> cache =
  90     new LinkedHashMap<AWTKeyStroke,AWTKeyStroke>(11, 0.75f, true)
  91   {
  92     /** The largest the keystroke cache can grow. */
  93     private static final int MAX_CACHE_SIZE = 2048;
  94
  95     /** Prune stale entries. */
  96     protected boolean removeEldestEntry(Map.Entry<AWTKeyStroke,AWTKeyStroke>
  97                                         eldest)
  98     {
  99       return size() > MAX_CACHE_SIZE;
 100     }
 101   };
 102
 103   /** The most recently generated keystroke, or null. */
 104   private static AWTKeyStroke recent;
 105
 106   /**
 107    * The no-arg constructor of a subclass, or null to use AWTKeyStroke. Note
 108    * that this will be left accessible, to get around private access; but
 109    * it should not be a security risk as it is highly unlikely that creating
 110    * protected instances of the subclass via reflection will do much damage.
 111    */
 112   private static Constructor ctor;
 113
 114   /**
 115    * A table of keyCode names to values.  This is package-private to
 116    * avoid an accessor method.
 117    *
 118    * @see #getAWTKeyStroke(String)
 119    */
 120   static final HashMap<String,Object> vktable = new HashMap<String,Object>();
 121   static
 122   {
 123     // Using reflection saves the hassle of keeping this in sync with KeyEvent,
 124     // at the price of an expensive initialization.
 125     AccessController.doPrivileged(new PrivilegedAction()
 126       {
 127         public Object run()
 128         {
 129           Field[] fields = KeyEvent.class.getFields();
 130           int i = fields.length;
 131           try
 132             {
 133               while (--i >= 0)
 134                 {
 135                   Field f = fields[i];
 136                   String name = f.getName();
 137                   if (name.startsWith("VK_"))
 138                     vktable.put(name.substring(3), f.get(null));
 139                 }
 140             }
 141           catch (Exception e)
 142             {
 143               throw (Error) new InternalError().initCause(e);
 144             }
 145           return null;
 146         }
 147       });
 148   }
 149
 150   /**
 151    * The typed character, or CHAR_UNDEFINED for key presses and releases.
 152    *
 153    * @serial the keyChar
 154    */
 155   private char keyChar;
 156
 157   /**
 158    * The virtual key code, or VK_UNDEFINED for key typed. Package visible for
 159    * use by Component.
 160    *
 161    * @serial the keyCode
 162    */
 163   int keyCode;
 164
 165   /**
 166    * The modifiers in effect. To match Sun, this stores the old style masks
 167    * for shift, control, alt, meta, and alt-graph (but not button1); as well
 168    * as the new style of extended modifiers for all modifiers.
 169    *
 170    * @serial bitwise or of the *_DOWN_MASK modifiers
 171    */
 172   private int modifiers;
 173
 174   /**
 175    * True if this is a key release; should only be true if keyChar is
 176    * CHAR_UNDEFINED.
 177    *
 178    * @serial true to distinguish key pressed from key released
 179    */
 180   private boolean onKeyRelease;
 181
 182   /**
 183    * Construct a keystroke with default values: it will be interpreted as a
 184    * key typed event with an invalid character and no modifiers. Client code
 185    * should use the factory methods instead.
 186    *
 187    * @see #getAWTKeyStroke(char)
 188    * @see #getAWTKeyStroke(Character, int)
 189    * @see #getAWTKeyStroke(int, int, boolean)
 190    * @see #getAWTKeyStroke(int, int)
 191    * @see #getAWTKeyStrokeForEvent(KeyEvent)
 192    * @see #getAWTKeyStroke(String)
 193    */
 194   protected AWTKeyStroke()
 195   {
 196     keyChar = KeyEvent.CHAR_UNDEFINED;
 197   }
 198
 199   /**
 200    * Construct a keystroke with the given values. Client code should use the
 201    * factory methods instead.
 202    *
 203    * @param keyChar the character entered, if this is a key typed
 204    * @param keyCode the key pressed or released, or VK_UNDEFINED for key typed
 205    * @param modifiers the modifier keys for the keystroke, in old or new style
 206    * @param onKeyRelease true if this is a key release instead of a press
 207    * @see #getAWTKeyStroke(char)
 208    * @see #getAWTKeyStroke(Character, int)
 209    * @see #getAWTKeyStroke(int, int, boolean)
 210    * @see #getAWTKeyStroke(int, int)
 211    * @see #getAWTKeyStrokeForEvent(KeyEvent)
 212    * @see #getAWTKeyStroke(String)
 213    */
 214   protected AWTKeyStroke(char keyChar, int keyCode, int modifiers,
 215                          boolean onKeyRelease)
 216   {
 217     this.keyChar = keyChar;
 218     this.keyCode = keyCode;
 219     // No need to call extend(), as only trusted code calls this constructor.
 220     this.modifiers = modifiers;
 221     this.onKeyRelease = onKeyRelease;
 222   }
 223
 224   /**
 225    * Registers a new subclass as being the type of keystrokes to generate in
 226    * the factory methods. This operation flushes the cache of stored keystrokes
 227    * if the class differs from the current one. The new class must be
 228    * AWTKeyStroke or a subclass, and must have a no-arg constructor (which may
 229    * be private).
 230    *
 231    * @param subclass the new runtime type of generated keystrokes
 232    * @throws IllegalArgumentException subclass doesn't have no-arg constructor
 233    * @throws ClassCastException subclass doesn't extend AWTKeyStroke
 234    */
 235   protected static void registerSubclass(final Class<?> subclass)
 236   {
 237     if (subclass == null)
 238       throw new IllegalArgumentException();
 239     if (subclass.equals(ctor == null ? AWTKeyStroke.class
 240                         : ctor.getDeclaringClass()))
 241       return;
 242     if (subclass.equals(AWTKeyStroke.class))
 243        {
 244          cache.clear();
 245          recent = null;
 246          ctor = null;
 247          return;
 248        }
 249     try
 250       {
 251         ctor = (Constructor) AccessController.doPrivileged
 252           (new PrivilegedExceptionAction()
 253             {
 254               public Object run()
 255                 throws NoSuchMethodException, InstantiationException,
 256                        IllegalAccessException, InvocationTargetException
 257               {
 258                 Constructor<?> c =
 259                   subclass.getDeclaredConstructor((Class<?>[])null);
 260                 c.setAccessible(true);
 261                 // Create a new instance, to make sure that we can, and
 262                 // to cause any ClassCastException.
 263                 AWTKeyStroke dummy = (AWTKeyStroke) c.newInstance(null);
 264                 return c;
 265               }
 266             });
 267       }
 268     catch (PrivilegedActionException e)
 269       {
 270         // e.getCause() will not ever be ClassCastException; that should
 271         // escape on its own.
 272         throw (RuntimeException)
 273           new IllegalArgumentException().initCause(e.getCause());
 274       }
 275     cache.clear();
 276     recent = null;
 277   }
 278
 279   /**
 280    * Returns a keystroke representing a typed character.
 281    *
 282    * @param keyChar the typed character
 283    * @return the specified keystroke
 284    */
 285   public static AWTKeyStroke getAWTKeyStroke(char keyChar)
 286   {
 287     return getAWTKeyStroke(keyChar, KeyEvent.VK_UNDEFINED, 0, false);
 288   }
 289
 290   /**
 291    * Returns a keystroke representing a typed character with the given
 292    * modifiers. Note that keyChar is a <code>Character</code> instead of a
 293    * <code>char</code> to avoid accidental ambiguity with
 294    * <code>getAWTKeyStroke(int, int)</code>. The modifiers are the bitwise
 295    * or of the masks found in {@link InputEvent}; the new style (*_DOWN_MASK)
 296    * is preferred, but the old style will work.
 297    *
 298    * @param keyChar the typed character
 299    * @param modifiers the modifiers, or 0
 300    * @return the specified keystroke
 301    * @throws IllegalArgumentException if keyChar is null
 302    */
 303   public static AWTKeyStroke getAWTKeyStroke(Character keyChar, int modifiers)
 304   {
 305     if (keyChar == null)
 306       throw new IllegalArgumentException();
 307     return getAWTKeyStroke(keyChar.charValue(), KeyEvent.VK_UNDEFINED,
 308                            extend(modifiers), false);
 309   }
 310
 311   /**
 312    * Returns a keystroke representing a pressed or released key event, with
 313    * the given modifiers. The "virtual key" should be one of the VK_*
 314    * constants in {@link KeyEvent}. The modifiers are the bitwise or of the
 315    * masks found in {@link InputEvent}; the new style (*_DOWN_MASK) is
 316    * preferred, but the old style will work.
 317    *
 318    * @param keyCode the virtual key
 319    * @param modifiers the modifiers, or 0
 320    * @param release true if this is a key release instead of a key press
 321    * @return the specified keystroke
 322    */
 323   public static AWTKeyStroke getAWTKeyStroke(int keyCode, int modifiers,
 324                                              boolean release)
 325   {
 326     return getAWTKeyStroke(KeyEvent.CHAR_UNDEFINED, keyCode,
 327                            extend(modifiers), release);
 328   }
 329
 330   /**
 331    * Returns a keystroke representing a pressed key event, with the given
 332    * modifiers. The "virtual key" should be one of the VK_* constants in
 333    * {@link KeyEvent}. The modifiers are the bitwise or of the masks found
 334    * in {@link InputEvent}; the new style (*_DOWN_MASK) is preferred, but the
 335    * old style will work.
 336    *
 337    * @param keyCode the virtual key
 338    * @param modifiers the modifiers, or 0
 339    * @return the specified keystroke
 340    */
 341   public static AWTKeyStroke getAWTKeyStroke(int keyCode, int modifiers)
 342   {
 343     return getAWTKeyStroke(KeyEvent.CHAR_UNDEFINED, keyCode,
 344                            extend(modifiers), false);
 345   }
 346
 347   /**
 348    * Returns a keystroke representing what caused the key event.
 349    *
 350    * @param event the key event to convert
 351    * @return the specified keystroke, or null if the event is invalid
 352    * @throws NullPointerException if event is null
 353    */
 354   public static AWTKeyStroke getAWTKeyStrokeForEvent(KeyEvent event)
 355   {
 356     switch (event.id)
 357       {
 358       case KeyEvent.KEY_TYPED:
 359         return getAWTKeyStroke(event.getKeyChar(), KeyEvent.VK_UNDEFINED,
 360                                extend(event.getModifiersEx()), false);
 361       case KeyEvent.KEY_PRESSED:
 362         return getAWTKeyStroke(KeyEvent.CHAR_UNDEFINED, event.getKeyCode(),
 363                                extend(event.getModifiersEx()), false);
 364       case KeyEvent.KEY_RELEASED:
 365         return getAWTKeyStroke(KeyEvent.CHAR_UNDEFINED, event.getKeyCode(),
 366                                extend(event.getModifiersEx()), true);
 367       default:
 368         return null;
 369       }
 370   }
 371
 372   /**
 373    * Parses a string and returns the keystroke that it represents. The syntax
 374    * for keystrokes is listed below, with tokens separated by an arbitrary
 375    * number of spaces:
 376    * <pre>
 377    * keyStroke := &lt;modifiers&gt;* ( &lt;typedID&gt; | &lt;codeID&gt; )
 378    * modifiers := ( shift | control | ctrl | meta | alt
 379    *                | button1 | button2 | button3 )
 380    * typedID := typed &lt;single Unicode character&gt;
 381    * codeID := ( pressed | released )? &lt;name&gt;
 382    * name := &lt;the KeyEvent field name less the leading "VK_"&gt;
 383    * </pre>
 384    *
 385    * <p>Note that the grammar is rather weak, and not all valid keystrokes
 386    * can be generated in this manner (for example, a typed space, or anything
 387    * with the alt-graph modifier!). The output of AWTKeyStroke.toString()
 388    * will not meet the grammar. If pressed or released is not specified,
 389    * pressed is assumed. Examples:<br>
 390    * <code>
 391    * "INSERT" =&gt; getAWTKeyStroke(KeyEvent.VK_INSERT, 0);<br>
 392    * "control DELETE" =&gt;
 393    *    getAWTKeyStroke(KeyEvent.VK_DELETE, InputEvent.CTRL_MASK);<br>
 394    * "alt shift X" =&gt; getAWTKeyStroke(KeyEvent.VK_X,
 395    *    InputEvent.ALT_MASK | InputEvent.SHIFT_MASK);<br>
 396    * "alt shift released X" =&gt; getAWTKeyStroke(KeyEvent.VK_X,
 397    *    InputEvent.ALT_MASK | InputEvent.SHIFT_MASK, true);<br>
 398    * "typed a" =&gt; getAWTKeyStroke('a');
 399    * </code>
 400    *
 401    * @param s the string to parse
 402    * @throws IllegalArgumentException if s is null or cannot be parsed
 403    * @return the specified keystroke
 404    */
 405   public static AWTKeyStroke getAWTKeyStroke(String s)
 406   {
 407     if (s == null)
 408       throw new IllegalArgumentException("null argument");
 409     StringTokenizer t = new StringTokenizer(s, " ");
 410     if (! t.hasMoreTokens())
 411       throw new IllegalArgumentException("no tokens '" + s + "'");
 412     int modifiers = 0;
 413     boolean released = false;
 414     String token = null;
 415     do
 416       {
 417         token = t.nextToken();
 418         if ("shift".equals(token))
 419           {
 420             modifiers |= KeyEvent.SHIFT_MASK;
 421             modifiers |= KeyEvent.SHIFT_DOWN_MASK;
 422           }
 423         else if ("ctrl".equals(token) || "control".equals(token))
 424           {
 425             modifiers |= KeyEvent.CTRL_MASK;
 426             modifiers |= KeyEvent.CTRL_DOWN_MASK;
 427           }
 428         else if ("meta".equals(token))
 429           {
 430             modifiers |= KeyEvent.META_MASK;
 431             modifiers |= KeyEvent.META_DOWN_MASK;
 432           }
 433         else if ("alt".equals(token))
 434           {
 435             modifiers |= KeyEvent.ALT_MASK;
 436             modifiers |= KeyEvent.ALT_DOWN_MASK;
 437           }
 438         else if ("button1".equals(token))
 439           modifiers |= KeyEvent.BUTTON1_DOWN_MASK;
 440         else if ("button2".equals(token))
 441           modifiers |= KeyEvent.BUTTON2_DOWN_MASK;
 442         else if ("button3".equals(token))
 443           modifiers |= KeyEvent.BUTTON3_DOWN_MASK;
 444         else if ("typed".equals(token))
 445           {
 446             if (t.hasMoreTokens())
 447               {
 448                 token = t.nextToken();
 449                 if (! t.hasMoreTokens() && token.length() == 1)
 450                   return getAWTKeyStroke(token.charAt(0),
 451                                          KeyEvent.VK_UNDEFINED, modifiers,
 452                                          false);
 453               }
 454             throw new IllegalArgumentException("Invalid 'typed' argument '"
 455                                                + s + "'");
 456           }
 457         else if ("pressed".equals(token))
 458           {
 459             if (t.hasMoreTokens())
 460               token = t.nextToken();
 461             break;
 462           }
 463         else if ("released".equals(token))
 464           {
 465             released = true;
 466             if (t.hasMoreTokens())
 467               token = t.nextToken();
 468             break;
 469           }
 470         else
 471           break;
 472       }
 473     while (t.hasMoreTokens());
 474     // Now token contains the VK name we must parse.
 475     Integer code = (Integer) vktable.get(token);
 476     if (code == null)
 477       throw new IllegalArgumentException("Unknown token '" + token
 478                                          + "' in '" + s + "'");
 479     if (t.hasMoreTokens())
 480       throw new IllegalArgumentException("Too many tokens: " + s);
 481     return getAWTKeyStroke(KeyEvent.CHAR_UNDEFINED, code.intValue(),
 482                            modifiers, released);
 483   }
 484
 485   /**
 486    * Returns the character of this keystroke, if it was typed.
 487    *
 488    * @return the character value, or CHAR_UNDEFINED
 489    * @see #getAWTKeyStroke(char)
 490    */
 491   public final char getKeyChar()
 492   {
 493     return keyChar;
 494   }
 495
 496   /**
 497    * Returns the virtual key code of this keystroke, if it was pressed or
 498    * released. This will be a VK_* constant from KeyEvent.
 499    *
 500    * @return the virtual key code value, or VK_UNDEFINED
 501    * @see #getAWTKeyStroke(int, int)
 502    */
 503   public final int getKeyCode()
 504   {
 505     return keyCode;
 506   }
 507
 508   /**
 509    * Returns the modifiers for this keystroke. This will be a bitwise or of
 510    * constants from InputEvent; it includes the old style masks for shift,
 511    * control, alt, meta, and alt-graph (but not button1); as well as the new
 512    * style of extended modifiers for all modifiers.
 513    *
 514    * @return the modifiers
 515    * @see #getAWTKeyStroke(Character, int)
 516    * @see #getAWTKeyStroke(int, int)
 517    */
 518   public final int getModifiers()
 519   {
 520     return modifiers;
 521   }
 522
 523   /**
 524    * Tests if this keystroke is a key release.
 525    *
 526    * @return true if this is a key release
 527    * @see #getAWTKeyStroke(int, int, boolean)
 528    */
 529   public final boolean isOnKeyRelease()
 530   {
 531     return onKeyRelease;
 532   }
 533
 534   /**
 535    * Returns the AWT event type of this keystroke. This is one of
 536    * {@link KeyEvent#KEY_TYPED}, {@link KeyEvent#KEY_PRESSED}, or
 537    * {@link KeyEvent#KEY_RELEASED}.
 538    *
 539    * @return the key event type
 540    */
 541   public final int getKeyEventType()
 542   {
 543     return keyCode == KeyEvent.VK_UNDEFINED ? KeyEvent.KEY_TYPED
 544       : onKeyRelease ? KeyEvent.KEY_RELEASED : KeyEvent.KEY_PRESSED;
 545   }
 546
 547   /**
 548    * Returns a hashcode for this key event. It is not documented, but appears
 549    * to be: <code>(getKeyChar() + 1) * (getKeyCode() + 1)
 550    * * (getModifiers() + 1) * 2 + (isOnKeyRelease() ? 1 : 2)</code>.
 551    *
 552    * @return the hashcode
 553    */
 554   public int hashCode()
 555   {
 556     return (keyChar + 1) * (keyCode + 1) * (modifiers + 1) * 2
 557       + (onKeyRelease ? 1 : 2);
 558   }
 559
 560   /**
 561    * Tests two keystrokes for equality.
 562    *
 563    * @param o the object to test
 564    * @return true if it is equal
 565    */
 566   public final boolean equals(Object o)
 567   {
 568     if (! (o instanceof AWTKeyStroke))
 569       return false;
 570     AWTKeyStroke s = (AWTKeyStroke) o;
 571     return this == o || (keyChar == s.keyChar && keyCode == s.keyCode
 572                          && modifiers == s.modifiers
 573                          && onKeyRelease == s.onKeyRelease);
 574   }
 575
 576   /**
 577    * Returns a string representation of this keystroke. For typed keystrokes,
 578    * this is <code>"keyChar " + KeyEvent.getKeyModifiersText(getModifiers())
 579    + getKeyChar()</code>; for pressed and released keystrokes, this is
 580    * <code>"keyCode " + KeyEvent.getKeyModifiersText(getModifiers())
 581    * + KeyEvent.getKeyText(getKeyCode())
 582    * + (isOnKeyRelease() ? "-R" : "-P")</code>.
 583    *
 584    * @return a string representation
 585    */
 586   public String toString()
 587   {
 588     if (keyCode == KeyEvent.VK_UNDEFINED)
 589       return "keyChar " + KeyEvent.getKeyModifiersText(modifiers) + keyChar;
 590     return "keyCode " + KeyEvent.getKeyModifiersText(modifiers)
 591       + KeyEvent.getKeyText(keyCode) + (onKeyRelease ? "-R" : "-P");
 592   }
 593
 594   /**
 595    * Returns a cached version of the deserialized keystroke, if available.
 596    *
 597    * @return a cached replacement
 598    * @throws ObjectStreamException if something goes wrong
 599    */
 600   protected Object readResolve() throws ObjectStreamException
 601   {
 602     AWTKeyStroke s = cache.get(this);
 603     if (s != null)
 604       return s;
 605     cache.put(this, this);
 606     return this;
 607   }
 608
 609   /**
 610    * Gets the appropriate keystroke, creating one if necessary.
 611    *
 612    * @param keyChar the keyChar
 613    * @param keyCode the keyCode
 614    * @param modifiers the modifiers
 615    * @param release true for key release
 616    * @return the specified keystroke
 617    */
 618   private static AWTKeyStroke getAWTKeyStroke(char keyChar, int keyCode,
 619                                               int modifiers, boolean release)
 620   {
 621     // Check level 0 cache.
 622     AWTKeyStroke stroke = recent; // Avoid thread races.
 623     if (stroke != null && stroke.keyChar == keyChar
 624         && stroke.keyCode == keyCode && stroke.modifiers == modifiers
 625         && stroke.onKeyRelease == release)
 626       return stroke;
 627     // Create a new object, on the assumption that if it has a match in the
 628     // cache, the VM can easily garbage collect it as it is temporary.
 629     Constructor c = ctor; // Avoid thread races.
 630     if (c == null)
 631       stroke = new AWTKeyStroke(keyChar, keyCode, modifiers, release);
 632     else
 633       try
 634         {
 635           stroke = (AWTKeyStroke) c.newInstance(null);
 636           stroke.keyChar = keyChar;
 637           stroke.keyCode = keyCode;
 638           stroke.modifiers = modifiers;
 639           stroke.onKeyRelease = release;
 640         }
 641       catch (Exception e)
 642         {
 643           throw (Error) new InternalError().initCause(e);
 644         }
 645     // Check level 1 cache.
 646     AWTKeyStroke cached = (AWTKeyStroke) cache.get(stroke);
 647     if (cached == null)
 648       cache.put(stroke, stroke);
 649     else
 650       stroke = cached;
 651     return recent = stroke;
 652   }
 653
 654   /**
 655    * Converts the modifiers to the appropriate format.
 656    *
 657    * @param mod the modifiers to convert
 658    * @return the adjusted modifiers
 659    */
 660   private static int extend(int mod)
 661   {
 662     if ((mod & (KeyEvent.SHIFT_MASK | KeyEvent.SHIFT_DOWN_MASK)) != 0)
 663       mod |= KeyEvent.SHIFT_MASK | KeyEvent.SHIFT_DOWN_MASK;
 664     if ((mod & (KeyEvent.CTRL_MASK | KeyEvent.CTRL_DOWN_MASK)) != 0)
 665       mod |= KeyEvent.CTRL_MASK | KeyEvent.CTRL_DOWN_MASK;
 666     if ((mod & (KeyEvent.META_MASK | KeyEvent.META_DOWN_MASK)) != 0)
 667       mod |= KeyEvent.META_MASK | KeyEvent.META_DOWN_MASK;
 668     if ((mod & (KeyEvent.ALT_MASK | KeyEvent.ALT_DOWN_MASK)) != 0)
 669       mod |= KeyEvent.ALT_MASK | KeyEvent.ALT_DOWN_MASK;
 670     if ((mod & (KeyEvent.ALT_GRAPH_MASK | KeyEvent.ALT_GRAPH_DOWN_MASK)) != 0)
 671       mod |= KeyEvent.ALT_GRAPH_MASK | KeyEvent.ALT_GRAPH_DOWN_MASK;
 672     if ((mod & KeyEvent.BUTTON1_MASK) != 0)
 673       mod |= KeyEvent.BUTTON1_DOWN_MASK;
 674     return mod & MODIFIERS_MASK;
 675   }
 676 } // class AWTKeyStroke