public void processKeyEvent(KeyEvent evt) {
evt = KeyEventWorkaround.processKeyEvent(evt);
if (evt == null) return;
switch (evt.getID()) {
case KeyEvent.KEY_TYPED:
char ch = evt.getKeyChar();
if (!nonDigit && Character.isDigit(ch)) {
super.processKeyEvent(evt);
repeat = true;
repeatCount = Integer.parseInt(action.getText());
} else {
nonDigit = true;
if (repeat) {
passToView(evt);
} else super.processKeyEvent(evt);
}
break;
case KeyEvent.KEY_PRESSED:
int keyCode = evt.getKeyCode();
if (evt.isActionKey()
|| evt.isControlDown()
|| evt.isAltDown()
|| evt.isMetaDown()
|| keyCode == KeyEvent.VK_BACK_SPACE
|| keyCode == KeyEvent.VK_DELETE
|| keyCode == KeyEvent.VK_ENTER
|| keyCode == KeyEvent.VK_TAB
|| keyCode == KeyEvent.VK_ESCAPE) {
nonDigit = true;
if (repeat) {
passToView(evt);
break;
} else if (keyCode == KeyEvent.VK_TAB) {
complete(true);
evt.consume();
} else if (keyCode == KeyEvent.VK_ESCAPE) {
evt.consume();
if (popup != null) {
popup.dispose();
popup = null;
action.requestFocus();
} else {
if (temp) view.removeToolBar(ActionBar.this);
view.getEditPane().focusOnTextArea();
}
break;
} else if ((keyCode == KeyEvent.VK_UP || keyCode == KeyEvent.VK_DOWN)
&& popup != null) {
popup.list.processKeyEvent(evt);
break;
}
}
super.processKeyEvent(evt);
break;
}
}
/**
* Handle a key pressed event. This will look up the binding for the key stroke and execute it.
*/
@Override
@SuppressWarnings("unchecked")
public void keyPressed(KeyEvent evt) {
int keyCode = evt.getKeyCode();
int modifiers = evt.getModifiers();
if (keyCode == KeyEvent.VK_CONTROL
|| keyCode == KeyEvent.VK_SHIFT
|| keyCode == KeyEvent.VK_ALT
|| keyCode == KeyEvent.VK_META) return;
if ((modifiers & InputEvent.SHIFT_MASK) != 0
|| (modifiers & InputEvent.CTRL_MASK) != 0
|| evt.isActionKey()
|| keyCode == KeyEvent.VK_BACK_SPACE
|| keyCode == KeyEvent.VK_DELETE
|| keyCode == KeyEvent.VK_ENTER
|| keyCode == KeyEvent.VK_TAB
|| keyCode == KeyEvent.VK_ESCAPE) {
if (grabAction != null) {
handleGrabAction(evt);
return;
}
KeyStroke keyStroke = KeyStroke.getKeyStroke(keyCode, modifiers);
Object o = currentBindings.get(keyStroke);
if (o == null) {
// Don't beep if the user presses some
// key we don't know about unless a
// prefix is active. Otherwise it will
// beep when caps lock is pressed, etc.
if (currentBindings != bindings) {
Toolkit.getDefaultToolkit().beep();
// F10 should be passed on, but C+e F10
// shouldn't
repeatCount = 0;
repeat = false;
evt.consume();
}
currentBindings = bindings;
return;
} else if (o instanceof ActionListener) {
currentBindings = bindings;
executeAction(((ActionListener) o), evt.getSource(), null);
evt.consume();
return;
} else if (o instanceof Hashtable) {
currentBindings = (Hashtable) o;
evt.consume();
return;
}
}
}
private void displayInfo(KeyEvent e, String keyStatus) {
// Method copied from http://java.sun.com/docs/books/tutorial/uiswing/events/keylistener.html
// You should only rely on the key char if the event
// is a key typed event.
int id = e.getID();
String keyString;
if (id == KeyEvent.KEY_TYPED) {
char c = e.getKeyChar();
keyString = "key character = '" + c + "'";
} else {
int keyCode = e.getKeyCode();
keyString = "key code = " + keyCode + " (" + KeyEvent.getKeyText(keyCode) + ")";
}
int modifiersEx = e.getModifiersEx();
String modString = "extended modifiers = " + modifiersEx;
String tmpString = KeyEvent.getModifiersExText(modifiersEx);
if (tmpString.length() > 0) {
modString += " (" + tmpString + ")";
} else {
modString += " (no extended modifiers)";
}
String actionString = "action key? ";
if (e.isActionKey()) {
actionString += "YES";
} else {
actionString += "NO";
}
String locationString = "key location: ";
int location = e.getKeyLocation();
if (location == KeyEvent.KEY_LOCATION_STANDARD) {
locationString += "standard";
} else if (location == KeyEvent.KEY_LOCATION_LEFT) {
locationString += "left";
} else if (location == KeyEvent.KEY_LOCATION_RIGHT) {
locationString += "right";
} else if (location == KeyEvent.KEY_LOCATION_NUMPAD) {
locationString += "numpad";
} else { // (location == KeyEvent.KEY_LOCATION_UNKNOWN)
locationString += "unknown";
}
// Added:
System.out.println("Keypress: " + keyString);
}
/**
* Handle a key pressed event. This will look up the binding for the key stroke and execute it.
*/
public void keyPressed(KeyEvent evt) {
int keyCode = evt.getKeyCode();
int modifiers = evt.getModifiers();
// moved this earlier so it doesn't get random meta clicks
if (keyCode == KeyEvent.VK_CONTROL
|| keyCode == KeyEvent.VK_SHIFT
|| keyCode == KeyEvent.VK_ALT
|| keyCode == KeyEvent.VK_META) {
return;
}
// don't get command-s or other menu key equivs on mac
// unless it's something that's specifically bound (cmd-left or right)
// if ((modifiers & KeyEvent.META_MASK) != 0) return;
if ((modifiers & KeyEvent.META_MASK) != 0) {
KeyStroke keyStroke = KeyStroke.getKeyStroke(keyCode, modifiers);
if (currentBindings.get(keyStroke) == null) {
return;
}
}
/*
char keyChar = evt.getKeyChar();
System.out.println("code=" + keyCode + " char=" + keyChar +
" charint=" + ((int)keyChar));
System.out.println("other codes " + KeyEvent.VK_ALT + " " +
KeyEvent.VK_META);
*/
if ((modifiers & ~KeyEvent.SHIFT_MASK) != 0
|| evt.isActionKey()
|| keyCode == KeyEvent.VK_BACK_SPACE
|| keyCode == KeyEvent.VK_DELETE
|| keyCode == KeyEvent.VK_ENTER
|| keyCode == KeyEvent.VK_TAB
|| keyCode == KeyEvent.VK_ESCAPE) {
if (grabAction != null) {
handleGrabAction(evt);
return;
}
KeyStroke keyStroke = KeyStroke.getKeyStroke(keyCode, modifiers);
Object o = currentBindings.get(keyStroke);
if (o == null) {
// Don't beep if the user presses some
// key we don't know about unless a
// prefix is active. Otherwise it will
// beep when caps lock is pressed, etc.
if (currentBindings != bindings) {
Toolkit.getDefaultToolkit().beep();
// F10 should be passed on, but C+e F10
// shouldn't
repeatCount = 0;
repeat = false;
evt.consume();
}
currentBindings = bindings;
return;
} else if (o instanceof ActionListener) {
currentBindings = bindings;
executeAction(((ActionListener) o), evt.getSource(), null);
evt.consume();
return;
} else if (o instanceof Hashtable) {
currentBindings = (Hashtable) o;
evt.consume();
return;
}
}
}
public void keyTyped(KeyEvent e) {
if (debug) {
System.out.println(
"--- RecordingModule: key typed = "
+ e
+ "\n > Key char->int = "
+ (int) e.getKeyChar());
System.out.println(" -- isActionKey() = " + e.isActionKey());
System.out.println(" -- isISOControl() = " + Character.isISOControl(e.getKeyChar()));
System.out.println(" -- isWhitespace() = " + Character.isWhitespace(e.getKeyChar()));
}
if (isKeyReserved(e)) {
return;
}
if (enabled && !readOnly && lastKeyPressEvent != null) {
if (enableKeyboard) {
boolean replace = false;
String text = "";
if (isControl(e)) {
if (lastKeyPressEvent.getKeyCode() == KeyEvent.VK_ENTER) {
// Change the Type cmd prior to Typeline if the delay from the last type key is less
// than 1 sec
if (useTypeline && e.getModifiers() == 0 && lastElement != null) {
String s = DocumentUtils.getElementText(lastElement);
if (s.startsWith("Type ")
&& (System.currentTimeMillis() - lastInsertTime) < typelineDelay) {
replace = true;
text = s.replaceFirst("Type", "Typeline");
}
}
}
if ("".equals(text)) {
int count = 1;
KeyEvent e2;
long lastEventTime = e.getWhen();
// We go through the vector of events and check whether there are events corresponding
// to a typed text.
for (int i = 0; i < events.size() && events.get(i) instanceof KeyEvent; i++) {
e2 = (KeyEvent) events.get(i);
if (e.getID() == e2.getID()
&& e.getKeyChar() == e2.getKeyChar()
&& e.getKeyCode() == e2.getKeyCode()
&& e.getModifiers() == e2.getModifiers()
&& (lastEventTime - e2.getWhen() < keyMutiDelay)) {
count++;
replace = true;
lastEventTime = e2.getWhen();
} else {
break;
}
}
text = "Press ";
// String modifiers = KeyEvent.getKeyModifiersText(e.getModifiers());
String modifiers = parser.modifiersToString(e.getModifiers());
if (!"".equals(modifiers)) {
text += modifiers + "+";
}
String charText = KeyEvent.getKeyText(lastKeyPressEvent.getKeyCode());
if (charText == null) {
charText = "<unknown>";
}
text += charText;
if (count > 1) {
text += " " + PressCommand.PARAM_COUNT + "=" + count;
}
if (debug) {
System.out.println("--- RecordingModule: Inserting '" + text + "'");
}
}
} else {
text = "" + e.getKeyChar();
KeyEvent e2;
// We go through the vector of events and check whether there are events corresponding to
// a typed text.
for (int i = 0; i < events.size() && events.get(i) instanceof KeyEvent; i++) {
e2 = (KeyEvent) events.get(i);
if (!isControl(e2) && !e2.isActionKey()) {
text = e2.getKeyChar() + text;
replace = true;
} else {
break;
}
}
text = "Type \"" + Utils.escapeUnescapedDoubleQuotes(text) + "\"";
}
// Insert the command to the current editor
insertLine(text, replace, true, false);
}
insertEvent(e);
}
}
public void keyPressed(KeyEvent e) {
if (debug) {
System.out.println(
"--- RecordingModule: key pressed = "
+ e
+ "\n > Key char->int = "
+ (int) e.getKeyChar());
}
// Here we process just action keys because they do not generate KEY_TYPED events.
// Other key events are handled by the keyTyped method.
lastInteractionTime = System.currentTimeMillis();
if (isKeyReserved(e)) {
return;
}
if (enabled && !readOnly) {
// System.out.println("keyPressed (e.isActionKey()=)"+e.isActionKey()+":
// "+e.toString());
// TODO: implement text corrections in type like Delete, Backspace
if (e.isActionKey()) {
if (enableKeyboard) {
int count = 1;
KeyEvent e2;
long lastEventTime = e.getWhen();
// We go through the vector of events and check whether there are events corresponding to
// a typed text.
for (int i = 0; i < events.size() && events.get(i) instanceof KeyEvent; i++) {
e2 = (KeyEvent) events.get(i);
if (e.getID() == e2.getID()
&& e.getKeyChar() == e2.getKeyChar()
&& e.getKeyCode() == e2.getKeyCode()
&& e.getModifiers() == e2.getModifiers()
&& (lastEventTime - e2.getWhen() < keyMutiDelay)) {
count++;
lastEventTime = e2.getWhen();
} else {
break;
}
}
String text = "Press ";
// String modifiers = KeyEvent.getKeyModifiersText(e.getModifiers());
String modifiers = parser.modifiersToString(e.getModifiers());
if (!"".equals(modifiers)) {
text += modifiers + "+";
}
String charText = (String) keyCodes.get(new Integer(e.getKeyCode()));
if (charText == null) {
charText = "<unknown>";
}
text += charText;
if (count > 1) {
text += " " + PressCommand.PARAM_COUNT + "=" + count;
}
// text += '\n';
if (debug) {
System.out.println("--- RecordingModule: Inserting '" + text + "'");
}
// Insert the command to the current editor
insertLine(text, count > 1, true, false);
}
insertEvent(e);
}
lastKeyPressEvent = e;
}
}
/**
* Converts a new event to an old one (used for compatibility). If the new event cannot be
* converted (because no old equivalent exists) then this returns null.
*
* <p>Note: this method is here instead of in each individual new event class in java.awt.event
* because we don't want to make it public and it needs to be called from java.awt.
*/
Event convertToOld() {
Object src = getSource();
int newid = id;
switch (id) {
case KeyEvent.KEY_PRESSED:
case KeyEvent.KEY_RELEASED:
KeyEvent ke = (KeyEvent) this;
if (ke.isActionKey()) {
newid = (id == KeyEvent.KEY_PRESSED ? Event.KEY_ACTION : Event.KEY_ACTION_RELEASE);
}
int keyCode = ke.getKeyCode();
if (keyCode == KeyEvent.VK_SHIFT
|| keyCode == KeyEvent.VK_CONTROL
|| keyCode == KeyEvent.VK_ALT) {
return null; // suppress modifier keys in old event model.
}
// no mask for button1 existed in old Event - strip it out
return new Event(
src,
ke.getWhen(),
newid,
0,
0,
Event.getOldEventKey(ke),
(ke.getModifiers() & ~InputEvent.BUTTON1_MASK));
case MouseEvent.MOUSE_PRESSED:
case MouseEvent.MOUSE_RELEASED:
case MouseEvent.MOUSE_MOVED:
case MouseEvent.MOUSE_DRAGGED:
case MouseEvent.MOUSE_ENTERED:
case MouseEvent.MOUSE_EXITED:
MouseEvent me = (MouseEvent) this;
// no mask for button1 existed in old Event - strip it out
Event olde =
new Event(
src,
me.getWhen(),
newid,
me.getX(),
me.getY(),
0,
(me.getModifiers() & ~InputEvent.BUTTON1_MASK));
olde.clickCount = me.getClickCount();
return olde;
case FocusEvent.FOCUS_GAINED:
return new Event(src, Event.GOT_FOCUS, null);
case FocusEvent.FOCUS_LOST:
return new Event(src, Event.LOST_FOCUS, null);
case WindowEvent.WINDOW_CLOSING:
case WindowEvent.WINDOW_ICONIFIED:
case WindowEvent.WINDOW_DEICONIFIED:
return new Event(src, newid, null);
case ComponentEvent.COMPONENT_MOVED:
if (src instanceof Frame || src instanceof Dialog) {
Point p = ((Component) src).getLocation();
return new Event(src, 0, Event.WINDOW_MOVED, p.x, p.y, 0, 0);
}
break;
case ActionEvent.ACTION_PERFORMED:
ActionEvent ae = (ActionEvent) this;
String cmd;
if (src instanceof Button) {
cmd = ((Button) src).getLabel();
} else if (src instanceof MenuItem) {
cmd = ((MenuItem) src).getLabel();
} else {
cmd = ae.getActionCommand();
}
return new Event(src, 0, newid, 0, 0, 0, ae.getModifiers(), cmd);
case ItemEvent.ITEM_STATE_CHANGED:
ItemEvent ie = (ItemEvent) this;
Object arg;
if (src instanceof List) {
newid =
(ie.getStateChange() == ItemEvent.SELECTED ? Event.LIST_SELECT : Event.LIST_DESELECT);
arg = ie.getItem();
} else {
newid = Event.ACTION_EVENT;
if (src instanceof Choice) {
arg = ie.getItem();
} else { // Checkbox
arg = new Boolean(ie.getStateChange() == ItemEvent.SELECTED);
}
}
return new Event(src, newid, arg);
case AdjustmentEvent.ADJUSTMENT_VALUE_CHANGED:
AdjustmentEvent aje = (AdjustmentEvent) this;
switch (aje.getAdjustmentType()) {
case AdjustmentEvent.UNIT_INCREMENT:
newid = Event.SCROLL_LINE_DOWN;
break;
case AdjustmentEvent.UNIT_DECREMENT:
newid = Event.SCROLL_LINE_UP;
break;
case AdjustmentEvent.BLOCK_INCREMENT:
newid = Event.SCROLL_PAGE_DOWN;
break;
case AdjustmentEvent.BLOCK_DECREMENT:
newid = Event.SCROLL_PAGE_UP;
break;
case AdjustmentEvent.TRACK:
if (aje.getValueIsAdjusting()) {
newid = Event.SCROLL_ABSOLUTE;
} else {
newid = Event.SCROLL_END;
}
break;
default:
return null;
}
return new Event(src, newid, new Integer(aje.getValue()));
default:
}
return null;
}