/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @author Dmitry A. Durnev
* @version $Revision$
*/
package java.awt;
import java.awt.event.InputEvent;
import java.awt.event.KeyEvent;
import java.io.ObjectStreamException;
import java.io.Serializable;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.StringTokenizer;
import org.apache.harmony.awt.internal.nls.Messages;
/**
* The AWTKeyStroke holds all of the information for the complete act of
* typing a character. This includes the events that are generated when
* the key is pressed, released, or typed (pressed and released generating
* a Unicode character result) which are associated with the event
* objects KeyEvent.KEY_PRESSED, KeyEvent.KEY_RELEASED, or KeyEvent.KEY_TYPED.
* It also holds information about which modifiers (such as control or
* shift) were used in conjunction with the keystroke. The following masks
* are available to identify the modifiers:
* <ul>
* <li>java.awt.event.InputEvent.ALT_GRAPH_DOWN_MASK</li>
* <li>java.awt.event.InputEvent.ALT_DOWN_MASK</li>
* <li>java.awt.event.InputEvent.CTRL_DOWN_MASK</li>
* <li>java.awt.event.InputEvent.META_DOWN_MASK</li>
* <li>java.awt.event.InputEvent.SHIFT_DOWN_MASK</li>
* <li>java.awt.event.InputEvent.ALT_GRAPH_MASK</li>
* <li>java.awt.event.InputEvent.ALT_MASK</li>
* <li>java.awt.event.InputEvent.CTRL_MASK</li>
* <li>java.awt.event.InputEvent.META_MASK</li>
* <li>java.awt.event.InputEvent.SHIFT_MASK</li>
* </ul>
* <br>
* The AWTKeyStroke is unique, and applications should not create their own
* instances of AWTKeyStroke. All applications should use getAWTKeyStroke
* methods for obtaining instances of AWTKeyStroke.
*
* @since Android 1.0
*/
public class AWTKeyStroke implements Serializable {
/**
* The Constant serialVersionUID.
*/
private static final long serialVersionUID = -6430539691155161871L;
/**
* The Constant cache.
*/
private static final Map<AWTKeyStroke, AWTKeyStroke> cache = new HashMap<AWTKeyStroke, AWTKeyStroke>(); // Map
// <
// AWTKeyStroke
// ,
// ?
// extends
// AWTKeyStroke
// >
/**
* The Constant keyEventTypesMap.
*/
private static final Map<Integer, String> keyEventTypesMap = new HashMap<Integer, String>(); // Map
// <
// int
// ,
// String
// >
private static Constructor<?> subConstructor;
static {
keyEventTypesMap.put(new Integer(KeyEvent.KEY_PRESSED), "pressed"); //$NON-NLS-1$
keyEventTypesMap.put(new Integer(KeyEvent.KEY_RELEASED), "released"); //$NON-NLS-1$
keyEventTypesMap.put(new Integer(KeyEvent.KEY_TYPED), "typed"); //$NON-NLS-1$
}
/**
* The key char.
*/
private char keyChar;
/**
* The key code.
*/
private int keyCode;
/**
* The modifiers.
*/
private int modifiers;
/**
* The on key release.
*/
private boolean onKeyRelease;
/**
* Instantiates a new AWTKeyStroke. getAWTKeyStroke method should be used by
* applications code.
*
* @param keyChar
* the key char.
* @param keyCode
* the key code.
* @param modifiers
* the modifiers.
* @param onKeyRelease
* true if AWTKeyStroke is for a key release, false otherwise.
*/
protected AWTKeyStroke(char keyChar, int keyCode, int modifiers, boolean onKeyRelease) {
setAWTKeyStroke(keyChar, keyCode, modifiers, onKeyRelease);
}
/**
* Sets the AWT key stroke.
*
* @param keyChar
* the key char.
* @param keyCode
* the key code.
* @param modifiers
* the modifiers.
* @param onKeyRelease
* the on key release.
*/
private void setAWTKeyStroke(char keyChar, int keyCode, int modifiers, boolean onKeyRelease) {
this.keyChar = keyChar;
this.keyCode = keyCode;
this.modifiers = modifiers;
this.onKeyRelease = onKeyRelease;
}
/**
* Instantiates a new AWTKeyStroke with default parameters:
* KeyEvent.CHAR_UNDEFINED key char, KeyEvent.VK_UNDEFINED key code, without
* modifiers and false key realized value.
*/
protected AWTKeyStroke() {
this(KeyEvent.CHAR_UNDEFINED, KeyEvent.VK_UNDEFINED, 0, false);
}
/**
* Returns the unique number value for AWTKeyStroke object.
*
* @return the integer unique value of the AWTKeyStroke object.
*/
@Override
public int hashCode() {
return modifiers + (keyCode != KeyEvent.VK_UNDEFINED ? keyCode : keyChar)
+ (onKeyRelease ? -1 : 0);
}
/**
* Gets the set of modifiers for the AWTKeyStroke object.
*
* @return the integer value which contains modifiers.
*/
public final int getModifiers() {
return modifiers;
}
/**
* Compares this AWTKeyStroke object to the specified object.
*
* @param anObject
* the specified AWTKeyStroke object to compare with this
* instance.
* @return true if objects are identical, false otherwise.
*/
@Override
public final boolean equals(Object anObject) {
if (anObject instanceof AWTKeyStroke) {
AWTKeyStroke key = (AWTKeyStroke)anObject;
return ((key.keyCode == keyCode) && (key.keyChar == keyChar)
&& (key.modifiers == modifiers) && (key.onKeyRelease == onKeyRelease));
}
return false;
}
/**
* Returns the string representation of the AWTKeyStroke. This string should
* contain key stroke properties.
*
* @return the string representation of the AWTKeyStroke.
*/
@Override
public String toString() {
int type = getKeyEventType();
return InputEvent.getModifiersExText(getModifiers()) + " " + //$NON-NLS-1$
keyEventTypesMap.get(new Integer(type)) + " " + //$NON-NLS-1$
(type == KeyEvent.KEY_TYPED ? new String(new char[] {
keyChar
}) : KeyEvent.getKeyText(keyCode));
}
/**
* Gets the key code for the AWTKeyStroke object.
*
* @return the key code for the AWTKeyStroke object.
*/
public final int getKeyCode() {
return keyCode;
}
/**
* Gets the key character for the AWTKeyStroke object.
*
* @return the key character for the AWTKeyStroke object.
*/
public final char getKeyChar() {
return keyChar;
}
/**
* Gets the AWT key stroke.
*
* @param keyChar
* the key char.
* @param keyCode
* the key code.
* @param modifiers
* the modifiers.
* @param onKeyRelease
* the on key release.
* @return the AWT key stroke.
*/
private static AWTKeyStroke getAWTKeyStroke(char keyChar, int keyCode, int modifiers,
boolean onKeyRelease) {
AWTKeyStroke key = newInstance(keyChar, keyCode, modifiers, onKeyRelease);
AWTKeyStroke value = cache.get(key);
if (value == null) {
value = key;
cache.put(key, value);
}
return value;
}
/**
* New instance.
*
* @param keyChar
* the key char.
* @param keyCode
* the key code.
* @param modifiers
* the modifiers.
* @param onKeyRelease
* the on key release.
* @return the AWT key stroke.
*/
private static AWTKeyStroke newInstance(char keyChar, int keyCode, int modifiers,
boolean onKeyRelease) {
AWTKeyStroke key;
// ???AWT
// if (subConstructor == null) {
key = new AWTKeyStroke();
// ???AWT
// } else {
// try {
// key = (AWTKeyStroke) subConstructor.newInstance();
// } catch (Exception e) {
// throw new RuntimeException(e);
// }
// }
int allModifiers = getAllModifiers(modifiers);
key.setAWTKeyStroke(keyChar, keyCode, allModifiers, onKeyRelease);
return key;
}
/**
* Adds the mask.
*
* @param mod
* the mod.
* @param mask
* the mask.
* @return the int.
*/
private static int addMask(int mod, int mask) {
return ((mod & mask) != 0) ? (mod | mask) : mod;
}
/**
* Return all (old & new) modifiers corresponding to.
*
* @param mod
* old or new modifiers.
* @return old and new modifiers together.
*/
static int getAllModifiers(int mod) {
int allMod = mod;
int shift = (InputEvent.SHIFT_MASK | InputEvent.SHIFT_DOWN_MASK);
int ctrl = (InputEvent.CTRL_MASK | InputEvent.CTRL_DOWN_MASK);
int meta = (InputEvent.META_MASK | InputEvent.META_DOWN_MASK);
int alt = (InputEvent.ALT_MASK | InputEvent.ALT_DOWN_MASK);
int altGr = (InputEvent.ALT_GRAPH_MASK | InputEvent.ALT_GRAPH_DOWN_MASK);
// button modifiers are not converted between old & new
allMod = addMask(allMod, shift);
allMod = addMask(allMod, ctrl);
allMod = addMask(allMod, meta);
allMod = addMask(allMod, alt);
allMod = addMask(allMod, altGr);
return allMod;
}
/**
* Returns an instance of AWTKeyStroke for parsed string. The string must
* have the following syntax:
*<p>
* <modifiers>* (<typedID> | <pressedReleasedID>)
*<p>
* modifiers := shift | control | ctrl | meta | alt | altGraph <br>
* typedID := typed <typedKey> <br>
* typedKey := string of length 1 giving the Unicode character. <br>
* pressedReleasedID := (pressed | released) <key> <br>
* key := KeyEvent key code name, i.e. the name following "VK_".
* <p>
*
* @param s
* the String which contains key stroke parameters.
* @return the AWTKeyStroke for string.
* @throws IllegalArgumentException
* if string has incorrect format or null.
*/
public static AWTKeyStroke getAWTKeyStroke(String s) {
if (s == null) {
// awt.65=null argument
throw new IllegalArgumentException(Messages.getString("awt.65")); //$NON-NLS-1$
}
StringTokenizer tokenizer = new StringTokenizer(s);
Boolean release = null;
int modifiers = 0;
int keyCode = KeyEvent.VK_UNDEFINED;
char keyChar = KeyEvent.CHAR_UNDEFINED;
boolean typed = false;
long modifier = 0;
String token = null;
do {
token = getNextToken(tokenizer);
modifier = parseModifier(token);
modifiers |= modifier;
} while (modifier > 0);
typed = parseTypedID(token);
if (typed) {
token = getNextToken(tokenizer);
keyChar = parseTypedKey(token);
}
if (keyChar == KeyEvent.CHAR_UNDEFINED) {
release = parsePressedReleasedID(token);
if (release != null) {
token = getNextToken(tokenizer);
}
keyCode = parseKey(token);
}
if (tokenizer.hasMoreTokens()) {
// awt.66=Invalid format
throw new IllegalArgumentException(Messages.getString("awt.66")); //$NON-NLS-1$
}
return getAWTKeyStroke(keyChar, keyCode, modifiers, release == Boolean.TRUE);
}
/**
* Gets the next token.
*
* @param tokenizer
* the tokenizer.
* @return the next token.
*/
private static String getNextToken(StringTokenizer tokenizer) {
try {
return tokenizer.nextToken();
} catch (NoSuchElementException exception) {
// awt.66=Invalid format
throw new IllegalArgumentException(Messages.getString("awt.66")); //$NON-NLS-1$
}
}
/**
* Gets the key code.
*
* @param s
* the s.
* @return the key code.
*/
static int getKeyCode(String s) {
try {
Field vk = KeyEvent.class.getField("VK_" + s); //$NON-NLS-1$
return vk.getInt(null);
} catch (Exception e) {
if (s.length() != 1) {
// awt.66=Invalid format
throw new IllegalArgumentException(Messages.getString("awt.66")); //$NON-NLS-1$
}
return KeyEvent.VK_UNDEFINED;
}
}
/**
* Gets an instance of the AWTKeyStroke for specified character.
*
* @param keyChar
* the keyboard character value.
* @return a AWTKeyStroke for specified character.
*/
public static AWTKeyStroke getAWTKeyStroke(char keyChar) {
return getAWTKeyStroke(keyChar, KeyEvent.VK_UNDEFINED, 0, false);
}
/**
* Returns an instance of AWTKeyStroke for a given key code, set of
* modifiers, and specified key released flag value. The key codes are
* defined in java.awt.event.KeyEvent class. The set of modifiers is given
* as a bitwise combination of masks taken from the following list:
* <ul>
* <li>java.awt.event.InputEvent.ALT_GRAPH_DOWN_MASK</li> <li>
* java.awt.event.InputEvent.ALT_DOWN_MASK</li> <li>
* java.awt.event.InputEvent.CTRL_DOWN_MASK</li> <li>
* java.awt.event.InputEvent.META_DOWN_MASK</li> <li>
* java.awt.event.InputEvent.SHIFT_DOWN_MASK</li> <li>
* java.awt.event.InputEvent.ALT_GRAPH_MASK</li> <li>
* java.awt.event.InputEvent.ALT_MASK</li> <li>
* java.awt.event.InputEvent.CTRL_MASK</li> <li>
* java.awt.event.InputEvent.META_MASK</li> <li>
* java.awt.event.InputEvent.SHIFT_MASK</li>
* </ul>
* <br>
*
* @param keyCode
* the specified key code of keyboard.
* @param modifiers
* the bit set of modifiers.
* @param onKeyRelease
* the value which represents whether this AWTKeyStroke shall
* represents a key release.
* @return the AWTKeyStroke.
*/
public static AWTKeyStroke getAWTKeyStroke(int keyCode, int modifiers, boolean onKeyRelease) {
return getAWTKeyStroke(KeyEvent.CHAR_UNDEFINED, keyCode, modifiers, onKeyRelease);
}
/**
* Returns AWTKeyStroke for a specified character and set of modifiers. The
* set of modifiers is given as a bitwise combination of masks taken from
* the following list:
* <ul>
* <li>java.awt.event.InputEvent.ALT_GRAPH_DOWN_MASK</li> <li>
* java.awt.event.InputEvent.ALT_DOWN_MASK</li> <li>
* java.awt.event.InputEvent.CTRL_DOWN_MASK</li> <li>
* java.awt.event.InputEvent.META_DOWN_MASK</li> <li>
* java.awt.event.InputEvent.SHIFT_DOWN_MASK</li> <li>
* java.awt.event.InputEvent.ALT_GRAPH_MASK</li> <li>
* java.awt.event.InputEvent.ALT_MASK</li> <li>
* java.awt.event.InputEvent.CTRL_MASK</li> <li>
* java.awt.event.InputEvent.META_MASK</li> <li>
* java.awt.event.InputEvent.SHIFT_MASK</li>
* </ul>
*
* @param keyChar
* the Character object which represents keyboard character
* value.
* @param modifiers
* the bit set of modifiers.
* @return the AWTKeyStroke object.
* @throws IllegalArgumentException
* if keyChar value is null.
*/
public static AWTKeyStroke getAWTKeyStroke(Character keyChar, int modifiers) {
if (keyChar == null) {
// awt.01='{0}' parameter is null
throw new IllegalArgumentException(Messages.getString("awt.01", "keyChar")); //$NON-NLS-1$ //$NON-NLS-2$
}
return getAWTKeyStroke(keyChar.charValue(), KeyEvent.VK_UNDEFINED, modifiers, false);
}
/**
* Returns an instance of AWTKeyStroke for a specified key code and set of
* modifiers. The key codes are defined in java.awt.event.KeyEvent class.
* The set of modifiers is given as a bitwise combination of masks taken
* from the following list:
* <ul>
* <li>java.awt.event.InputEvent.ALT_GRAPH_DOWN_MASK</li> <li>
* java.awt.event.InputEvent.ALT_DOWN_MASK</li> <li>
* java.awt.event.InputEvent.CTRL_DOWN_MASK</li> <li>
* java.awt.event.InputEvent.META_DOWN_MASK</li> <li>
* java.awt.event.InputEvent.SHIFT_DOWN_MASK</li> <li>
* java.awt.event.InputEvent.ALT_GRAPH_MASK</li> <li>
* java.awt.event.InputEvent.ALT_MASK</li> <li>
* java.awt.event.InputEvent.CTRL_MASK</li> <li>
* java.awt.event.InputEvent.META_MASK</li> <li>
* java.awt.event.InputEvent.SHIFT_MASK</li>
* </ul>
*
* @param keyCode
* the specified key code of keyboard.
* @param modifiers
* the bit set of modifiers.
* @return the AWTKeyStroke.
*/
public static AWTKeyStroke getAWTKeyStroke(int keyCode, int modifiers) {
return getAWTKeyStroke(keyCode, modifiers, false);
}
/**
* Gets the AWTKeyStroke for a key event. This method obtains the key char
* and key code from the specified key event.
*
* @param anEvent
* the key event which identifies the desired AWTKeyStroke.
* @return the AWTKeyStroke for the key event.
*/
public static AWTKeyStroke getAWTKeyStrokeForEvent(KeyEvent anEvent) {
int id = anEvent.getID();
char undef = KeyEvent.CHAR_UNDEFINED;
char keyChar = (id == KeyEvent.KEY_TYPED ? anEvent.getKeyChar() : undef);
int keyCode = (keyChar == undef ? anEvent.getKeyCode() : KeyEvent.VK_UNDEFINED);
return getAWTKeyStroke(keyChar, keyCode, anEvent.getModifiersEx(),
id == KeyEvent.KEY_RELEASED);
}
/**
* Gets the key event type for the AWTKeyStroke object.
*
* @return the key event type: KeyEvent.KEY_PRESSED, KeyEvent.KEY_TYPED, or
* KeyEvent.KEY_RELEASED.
*/
public final int getKeyEventType() {
if (keyCode == KeyEvent.VK_UNDEFINED) {
return KeyEvent.KEY_TYPED;
}
return (onKeyRelease ? KeyEvent.KEY_RELEASED : KeyEvent.KEY_PRESSED);
}
/**
* Returns true if the key event is associated with the AWTKeyStroke is
* KEY_RELEASED, false otherwise.
*
* @return true, if if the key event associated with the AWTKeyStroke is
* KEY_RELEASED, false otherwise.
*/
public final boolean isOnKeyRelease() {
return onKeyRelease;
}
/**
* Read resolve.
*
* @return the object.
* @throws ObjectStreamException
* the object stream exception.
*/
protected Object readResolve() throws ObjectStreamException {
return getAWTKeyStroke(this.keyChar, this.keyCode, this.modifiers, this.onKeyRelease);
}
/**
* Register subclass.
*
* @param subclass
* the subclass.
*/
protected static void registerSubclass(Class<?> subclass) {
// ???AWT
/*
* if (subclass == null) { // awt.01='{0}' parameter is null throw new
* IllegalArgumentException(Messages.getString("awt.01", "subclass"));
* //$NON-NLS-1$ //$NON-NLS-2$ } if (!
* AWTKeyStroke.class.isAssignableFrom(subclass)) { // awt.67=subclass
* is not derived from AWTKeyStroke throw new
* ClassCastException(Messages.getString("awt.67")); //$NON-NLS-1$ } try
* { subConstructor = subclass.getDeclaredConstructor();
* subConstructor.setAccessible(true); } catch (SecurityException e) {
* throw new RuntimeException(e); } catch (NoSuchMethodException e) { //
* awt.68=subclass could not be instantiated throw new
* IllegalArgumentException(Messages.getString("awt.68")); //$NON-NLS-1$
* } cache.clear(); //flush the cache
*/
}
/**
* Parses the modifier.
*
* @param strMod
* the str mod.
* @return the long.
*/
private static long parseModifier(String strMod) {
long modifiers = 0l;
if (strMod.equals("shift")) { //$NON-NLS-1$
modifiers |= InputEvent.SHIFT_DOWN_MASK;
} else if (strMod.equals("control") || strMod.equals("ctrl")) { //$NON-NLS-1$ //$NON-NLS-2$
modifiers |= InputEvent.CTRL_DOWN_MASK;
} else if (strMod.equals("meta")) { //$NON-NLS-1$
modifiers |= InputEvent.META_DOWN_MASK;
} else if (strMod.equals("alt")) { //$NON-NLS-1$
modifiers |= InputEvent.ALT_DOWN_MASK;
} else if (strMod.equals("altGraph")) { //$NON-NLS-1$
modifiers |= InputEvent.ALT_GRAPH_DOWN_MASK;
} else if (strMod.equals("button1")) { //$NON-NLS-1$
modifiers |= InputEvent.BUTTON1_DOWN_MASK;
} else if (strMod.equals("button2")) { //$NON-NLS-1$
modifiers |= InputEvent.BUTTON2_DOWN_MASK;
} else if (strMod.equals("button3")) { //$NON-NLS-1$
modifiers |= InputEvent.BUTTON3_DOWN_MASK;
}
return modifiers;
}
/**
* Parses the typed id.
*
* @param strTyped
* the str typed.
* @return true, if successful.
*/
private static boolean parseTypedID(String strTyped) {
if (strTyped.equals("typed")) { //$NON-NLS-1$
return true;
}
return false;
}
/**
* Parses the typed key.
*
* @param strChar
* the str char.
* @return the char.
*/
private static char parseTypedKey(String strChar) {
char keyChar = KeyEvent.CHAR_UNDEFINED;
if (strChar.length() != 1) {
// awt.66=Invalid format
throw new IllegalArgumentException(Messages.getString("awt.66")); //$NON-NLS-1$
}
keyChar = strChar.charAt(0);
return keyChar;
}
/**
* Parses the pressed released id.
*
* @param str
* the str.
* @return the boolean.
*/
private static Boolean parsePressedReleasedID(String str) {
if (str.equals("pressed")) { //$NON-NLS-1$
return Boolean.FALSE;
} else if (str.equals("released")) { //$NON-NLS-1$
return Boolean.TRUE;
}
return null;
}
/**
* Parses the key.
*
* @param strCode
* the str code.
* @return the int.
*/
private static int parseKey(String strCode) {
int keyCode = KeyEvent.VK_UNDEFINED;
keyCode = getKeyCode(strCode);
if (keyCode == KeyEvent.VK_UNDEFINED) {
// awt.66=Invalid format
throw new IllegalArgumentException(Messages.getString("awt.66")); //$NON-NLS-1$
}
return keyCode;
}
}
|
