private void handleKey(final KeyEvent e) {
int modifiers = e.getModifiers();
if (modifiers == myStoredModifiers) {
return;
}
BrowseMode browseMode = getBrowseMode(modifiers);
if (browseMode != BrowseMode.None) {
TooltipProvider tooltipProvider = myTooltipProvider;
if (tooltipProvider != null) {
if (browseMode != tooltipProvider.getBrowseMode()) {
disposeHighlighter();
}
myStoredModifiers = modifiers;
cancelPreviousTooltip();
myTooltipProvider =
new TooltipProvider(tooltipProvider.myEditor, tooltipProvider.myPosition);
myTooltipProvider.execute(browseMode);
}
} else {
disposeHighlighter();
cancelPreviousTooltip();
}
}
/*
* Post an ActionEvent to the target (on
* keydown) and the item is enabled.
* Returns true if there is an associated shortcut.
*/
boolean handleShortcut(KeyEvent e) {
MenuShortcut s =
new MenuShortcut(e.getKeyCode(), (e.getModifiers() & InputEvent.SHIFT_MASK) > 0);
// Fix For 6185151: Menu shortcuts of all menuitems within a menu
// should be disabled when the menu itself is disabled
if (s.equals(shortcut) && isItemEnabled()) {
// MenuShortcut match -- issue an event on keydown.
if (e.getID() == KeyEvent.KEY_PRESSED) {
doMenuEvent(e.getWhen(), e.getModifiers());
} else {
// silently eat key release.
}
return true;
}
return false;
}
@SuppressWarnings("HardCodedStringLiteral")
private boolean togglePopup(KeyEvent e) {
final KeyStroke stroke = KeyStroke.getKeyStroke(e.getKeyCode(), e.getModifiers());
final Object action = ((InputMap) UIManager.get("ComboBox.ancestorInputMap")).get(stroke);
if ("selectNext".equals(action)) {
if (!isPopupShowing()) {
return true;
} else {
return false;
}
} else if ("togglePopup".equals(action)) {
if (isPopupShowing()) {
closePopup();
} else {
suggestCompletion(true, true);
}
return true;
} else {
final Keymap active = KeymapManager.getInstance().getActiveKeymap();
final String[] ids = active.getActionIds(stroke);
if (ids.length > 0 && IdeActions.ACTION_CODE_COMPLETION.equals(ids[0])) {
suggestCompletion(true, true);
}
}
return false;
}
private void txtHotkeyKeyPressed(KeyEvent e) {
int code = e.getKeyCode();
int mod = e.getModifiers();
Debug.log(7, "" + code + " " + mod);
setTxtHotkey(code, mod);
_txtHotkey.setEditable(false);
}
public void keyReleased(KeyEvent e) {
int keyCode = e.getKeyCode();
IJ.setKeyUp(keyCode);
int flags = e.getModifiers();
boolean control = (flags & KeyEvent.CTRL_MASK) != 0;
boolean meta = (flags & KeyEvent.META_MASK) != 0;
boolean shift = (flags & e.SHIFT_MASK) != 0;
if (keyCode == KeyEvent.VK_G && shift && (control || meta)) new ScreenGrabber().run("");
}
/**
* 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 boolean proceedKeyEvent(KeyEvent event, KeyStroke stroke) {
if (myInputMap.get(stroke) != null) {
final Action action = myActionMap.get(myInputMap.get(stroke));
if (action != null && action.isEnabled()) {
action.actionPerformed(
new ActionEvent(
getContent(), event.getID(), "", event.getWhen(), event.getModifiers()));
return true;
}
}
return false;
}
private void processTerminalKeyPressed(KeyEvent e) {
try {
final int keycode = e.getKeyCode();
final char keychar = e.getKeyChar();
// numLock does not change the code sent by keypad VK_DELETE
// although it send the char '.'
if (keycode == KeyEvent.VK_DELETE && keychar == '.') {
myTerminalStarter.sendBytes(new byte[] {'.'});
return;
}
// CTRL + Space is not handled in KeyEvent; handle it manually
else if (keychar == ' ' && (e.getModifiers() & InputEvent.CTRL_MASK) != 0) {
myTerminalStarter.sendBytes(new byte[] {Ascii.NUL});
return;
}
final byte[] code = myTerminalStarter.getCode(keycode, e.getModifiers());
if (code != null) {
myTerminalStarter.sendBytes(code);
if (mySettingsProvider.scrollToBottomOnTyping() && isCodeThatScrolls(keycode)) {
scrollToBottom();
}
} else if ((keychar & 0xff00) == 0) {
final byte[] obuffer;
if (mySettingsProvider.altSendsEscape() && (e.getModifiers() & InputEvent.ALT_MASK) != 0) {
obuffer = new byte[] {Ascii.ESC, (byte) keychar};
} else {
obuffer = new byte[] {(byte) keychar};
}
myTerminalStarter.sendBytes(obuffer);
if (mySettingsProvider.scrollToBottomOnTyping()) {
scrollToBottom();
}
}
} catch (final Exception ex) {
LOG.error("Error sending key to emulator", ex);
}
}
public final boolean dispatch(KeyEvent event) {
if (event.getID() != KeyEvent.KEY_PRESSED && event.getID() != KeyEvent.KEY_RELEASED) {
return false;
}
if (event.getID() == KeyEvent.KEY_PRESSED) {
final KeyStroke stroke =
KeyStroke.getKeyStroke(event.getKeyCode(), event.getModifiers(), false);
if (proceedKeyEvent(event, stroke)) return false;
}
if (event.getID() == KeyEvent.KEY_RELEASED) {
final KeyStroke stroke =
KeyStroke.getKeyStroke(event.getKeyCode(), event.getModifiers(), true);
return proceedKeyEvent(event, stroke);
}
myMnemonicsSearch.process(event);
mySpeedSearch.process(event);
if (event.isConsumed()) return true;
process(event);
return event.isConsumed();
}
@Override
public boolean dispatchKeyEvent(KeyEvent e) {
int code = e.getKeyCode();
int modifiers = e.getModifiers();
if (code == KeyEvent.VK_ESCAPE) {
if (isShowingSheet()) {
discardTopSheet();
return true;
}
}
if (code == KeyEvent.VK_Q && modifiers == Platform.getPlatform().getCommandModifierMask()) {
shutdown();
return true;
}
return false;
}
/** Handle a key typed event. This inserts the key into the text area. */
public void keyTyped(KeyEvent evt) {
int modifiers = evt.getModifiers();
char c = evt.getKeyChar();
// this is the apple/cmd key on macosx.. so menu commands
// were being passed through as legit keys.. added this line
// in an attempt to prevent.
if ((modifiers & KeyEvent.META_MASK) != 0) return;
if (c != KeyEvent.CHAR_UNDEFINED) // &&
// (modifiers & KeyEvent.ALT_MASK) == 0)
{
if (c >= 0x20 && c != 0x7f) {
KeyStroke keyStroke = KeyStroke.getKeyStroke(Character.toUpperCase(c));
Object o = currentBindings.get(keyStroke);
if (o instanceof Hashtable) {
currentBindings = (Hashtable) o;
return;
} else if (o instanceof ActionListener) {
currentBindings = bindings;
executeAction((ActionListener) o, evt.getSource(), String.valueOf(c));
return;
}
currentBindings = bindings;
if (grabAction != null) {
handleGrabAction(evt);
return;
}
// 0-9 adds another 'digit' to the repeat number
if (repeat && Character.isDigit(c)) {
repeatCount *= 10;
repeatCount += (c - '0');
return;
}
executeAction(INSERT_CHAR, evt.getSource(), String.valueOf(evt.getKeyChar()));
repeatCount = 0;
repeat = false;
}
}
}
/**
* Processes a key event forwarded from the <code>MenuSelectionManager</code> and changes the menu
* selection, if necessary, by using <code>MenuSelectionManager</code>'s API.
*
* <p>Note: you do not have to forward the event to sub-components. This is done automatically by
* the <code>MenuSelectionManager</code>.
*
* @param e a <code>KeyEvent</code>
* @param path the <code>MenuElement</code> path array
* @param manager the <code>MenuSelectionManager</code>
*/
public void processKeyEvent(KeyEvent e, MenuElement path[], MenuSelectionManager manager) {
MenuKeyEvent mke =
new MenuKeyEvent(
e.getComponent(),
e.getID(),
e.getWhen(),
e.getModifiers(),
e.getKeyCode(),
e.getKeyChar(),
path,
manager);
processMenuKeyEvent(mke);
if (mke.isConsumed()) {
e.consume();
}
}
public void keyPressed(KeyEvent e) {
int keyCode = e.getKeyCode();
IJ.setKeyDown(keyCode);
if (keyCode == KeyEvent.VK_ENTER && textArea1 == null && okay != null && okay.isEnabled()) {
wasOKed = true;
if (IJ.isMacOSX()) accessTextFields();
dispose();
} else if (keyCode == KeyEvent.VK_ESCAPE) {
wasCanceled = true;
dispose();
IJ.resetEscape();
} else if (keyCode == KeyEvent.VK_W
&& (e.getModifiers() & Toolkit.getDefaultToolkit().getMenuShortcutKeyMask()) != 0) {
wasCanceled = true;
dispose();
}
}
@Override
public void keyPressed(KeyEvent e) {
// Accept "copy" key strokes
KeyStroke ks = KeyStroke.getKeyStroke(e.getKeyCode(), e.getModifiers());
JComponent comp = (JComponent) e.getSource();
for (int i = 0; i < 3; i++) {
InputMap im = comp.getInputMap(i);
Object key = im.get(ks);
if (defaultEditorKitCopyActionName.equals(key)
|| transferHandlerCopyActionName.equals(key)) {
return;
}
}
// Accept JTable navigation key strokes
if (!tableNavigationKeys.contains(e.getKeyCode())) {
e.consume();
}
}
private void processTerminalKeyTyped(KeyEvent e) {
final char keychar = e.getKeyChar();
if ((keychar & 0xff00) != 0) {
final char[] foo;
if (mySettingsProvider.altSendsEscape() && (e.getModifiers() & InputEvent.ALT_MASK) != 0) {
foo = new char[] {Ascii.ESC, keychar};
} else {
foo = new char[] {keychar};
}
try {
myTerminalStarter.sendString(new String(foo));
if (mySettingsProvider.scrollToBottomOnTyping()) {
scrollToBottom();
}
} catch (final RuntimeException ex) {
LOG.error("Error sending key to emulator", ex);
}
}
}
public void keyTyped(KeyEvent e) {
char keyChar = e.getKeyChar();
int flags = e.getModifiers();
if (IJ.debugMode)
IJ.log(
"keyTyped: char=\""
+ keyChar
+ "\" ("
+ (int) keyChar
+ "), flags= "
+ Integer.toHexString(flags)
+ " ("
+ KeyEvent.getKeyModifiersText(flags)
+ ")");
if (keyChar == '\\' || keyChar == 171 || keyChar == 223) {
if (((flags & Event.ALT_MASK) != 0)) doCommand("Animation Options...");
else doCommand("Start Animation [\\]");
}
}
private void handleKey(final KeyEvent e) {
int modifiers = e.getModifiers();
if (modifiers == myStoredModifiers) {
return;
}
BrowseMode browseMode = getBrowseMode(modifiers);
if (browseMode != BrowseMode.None) {
if (myTooltipProvider != null) {
if (browseMode != myTooltipProvider.getBrowseMode()) {
disposeHighlighter();
}
myStoredModifiers = modifiers;
myTooltipProvider.execute(browseMode);
}
} else {
disposeHighlighter();
myTooltipProvider = null;
}
}
/** Handle a key typed event. This inserts the key into the text area. */
@Override
@SuppressWarnings("unchecked")
public void keyTyped(KeyEvent evt) {
int modifiers = evt.getModifiers();
char c = evt.getKeyChar();
if (c != KeyEvent.CHAR_UNDEFINED && (modifiers & InputEvent.ALT_MASK) == 0) {
if (c >= 0x20 && c != 0x7f) {
KeyStroke keyStroke = KeyStroke.getKeyStroke(Character.toUpperCase(c));
Object o = currentBindings.get(keyStroke);
if (o instanceof Hashtable) {
currentBindings = (Hashtable) o;
return;
} else if (o instanceof ActionListener) {
currentBindings = bindings;
executeAction((ActionListener) o, evt.getSource(), String.valueOf(c));
return;
}
currentBindings = bindings;
if (grabAction != null) {
handleGrabAction(evt);
return;
}
// 0-9 adds another 'digit' to the repeat number
if (repeat && Character.isDigit(c)) {
repeatCount *= 10;
repeatCount += (c - '0');
return;
}
executeAction(INSERT_CHAR, evt.getSource(), String.valueOf(evt.getKeyChar()));
repeatCount = 0;
repeat = false;
}
}
}
@SuppressWarnings("HardCodedStringLiteral")
private void processListSelection(final KeyEvent e) {
if (togglePopup(e)) return;
if (!isPopupShowing()) return;
final InputMap map = myPathTextField.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);
if (map != null) {
final Object object = map.get(KeyStroke.getKeyStrokeForEvent(e));
if (object instanceof Action) {
final Action action = (Action) object;
if (action.isEnabled()) {
action.actionPerformed(new ActionEvent(this, ActionEvent.ACTION_PERFORMED, "action"));
e.consume();
return;
}
}
}
final Object action = getAction(e, myList);
if ("selectNextRow".equals(action)) {
if (ensureSelectionExists()) {
ListScrollingUtil.moveDown(myList, e.getModifiersEx());
}
} else if ("selectPreviousRow".equals(action)) {
ListScrollingUtil.moveUp(myList, e.getModifiersEx());
} else if ("scrollDown".equals(action)) {
ListScrollingUtil.movePageDown(myList);
} else if ("scrollUp".equals(action)) {
ListScrollingUtil.movePageUp(myList);
} else if (getSelectedFileFromCompletionPopup() != null
&& (e.getKeyCode() == KeyEvent.VK_ENTER || e.getKeyCode() == KeyEvent.VK_TAB)
&& e.getModifiers() == 0) {
hideCurrentPopup();
e.consume();
processChosenFromCompletion(e.getKeyCode() == KeyEvent.VK_TAB);
}
}
public void keyTyped(KeyEvent e) {
char code = e.getKeyChar();
if (code == e.VK_ENTER) {
// if (dataField != null)
{
e.setKeyChar(e.CHAR_UNDEFINED);
e.setKeyCode(-1);
// only fire this event, if the data has been changed
if (textField.isDataChanged()) {
fireActionPerformed("enter");
}
// not shift + enter => focus to next
if ((e.getModifiers() & e.SHIFT_MASK) != e.SHIFT_MASK) {
this.changeFocusToNext();
}
}
} else {
if (!TKeyLock.keys.isLocked()) {
textField.setDataChanged(true);
}
}
}
/**
* This method is called when the focused component (and none of its ancestors) want the key
* event. This will look up the keystroke to see if any chidren (or subchildren) of the specified
* container want a crack at the event. If one of them wants it, then it will "DO-THE-RIGHT-THING"
*/
public boolean fireKeyboardAction(KeyEvent e, boolean pressed, Container topAncestor) {
if (e.isConsumed()) {
System.out.println("Acquired pre-used event!");
Thread.dumpStack();
}
// There may be two keystrokes associated with a low-level key event;
// in this case a keystroke made of an extended key code has a priority.
KeyStroke ks;
KeyStroke ksE = null;
if (e.getID() == KeyEvent.KEY_TYPED) {
ks = KeyStroke.getKeyStroke(e.getKeyChar());
} else {
if (e.getKeyCode() != e.getExtendedKeyCode()) {
ksE = KeyStroke.getKeyStroke(e.getExtendedKeyCode(), e.getModifiers(), !pressed);
}
ks = KeyStroke.getKeyStroke(e.getKeyCode(), e.getModifiers(), !pressed);
}
Hashtable keyMap = containerMap.get(topAncestor);
if (keyMap != null) { // this container isn't registered, so bail
Object tmp = null;
// extended code has priority
if (ksE != null) {
tmp = keyMap.get(ksE);
if (tmp != null) {
ks = ksE;
}
}
if (tmp == null) {
tmp = keyMap.get(ks);
}
if (tmp == null) {
// don't do anything
} else if (tmp instanceof JComponent) {
JComponent c = (JComponent) tmp;
if (c.isShowing() && c.isEnabled()) { // only give it out if enabled and visible
fireBinding(c, ks, e, pressed);
}
} else if (tmp instanceof Vector) { // more than one comp registered for this
Vector v = (Vector) tmp;
// There is no well defined order for WHEN_IN_FOCUSED_WINDOW
// bindings, but we give precedence to those bindings just
// added. This is done so that JMenus WHEN_IN_FOCUSED_WINDOW
// bindings are accessed before those of the JRootPane (they
// both have a WHEN_IN_FOCUSED_WINDOW binding for enter).
for (int counter = v.size() - 1; counter >= 0; counter--) {
JComponent c = (JComponent) v.elementAt(counter);
// System.out.println("Trying collision: " + c + " vector = "+ v.size());
if (c.isShowing() && c.isEnabled()) { // don't want to give these out
fireBinding(c, ks, e, pressed);
if (e.isConsumed()) return true;
}
}
} else {
System.out.println("Unexpected condition in fireKeyboardAction " + tmp);
// This means that tmp wasn't null, a JComponent, or a Vector. What is it?
Thread.dumpStack();
}
}
if (e.isConsumed()) {
return true;
}
// if no one else handled it, then give the menus a crack
// The're handled differently. The key is to let any JMenuBars
// process the event
if (keyMap != null) {
Vector v = (Vector) keyMap.get(JMenuBar.class);
if (v != null) {
Enumeration iter = v.elements();
while (iter.hasMoreElements()) {
JMenuBar mb = (JMenuBar) iter.nextElement();
if (mb.isShowing() && mb.isEnabled()) { // don't want to give these out
boolean extended = (ksE != null) && !ksE.equals(ks);
if (extended) {
fireBinding(mb, ksE, e, pressed);
}
if (!extended || !e.isConsumed()) {
fireBinding(mb, ks, e, pressed);
}
if (e.isConsumed()) {
return true;
}
}
}
}
}
return e.isConsumed();
}
/**
* 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;
}
private synchronized void type(KeyEvent e) {
switch (e.getKeyCode()) {
case (KeyEvent.VK_ENTER):
if (e.getID() == KeyEvent.KEY_PRESSED) {
processCommand();
initCommandPos();
text.setCaretPosition(commandPos);
}
e.consume();
text.repaint();
break;
case (KeyEvent.VK_UP):
if (e.getID() == KeyEvent.KEY_PRESSED) prevHistory();
e.consume();
break;
case (KeyEvent.VK_DOWN):
if (e.getID() == KeyEvent.KEY_PRESSED) nextHistory();
e.consume();
break;
case (KeyEvent.VK_LEFT):
case (KeyEvent.VK_BACK_SPACE):
case (KeyEvent.VK_DELETE):
if (text.getCaretPosition() <= commandPos) e.consume();
break;
case (KeyEvent.VK_HOME):
text.setCaretPosition(commandPos);
e.consume();
break;
case (KeyEvent.VK_U):
if ((e.getModifiers() & InputEvent.CTRL_MASK) > 0) {
replaceConsoleText("", commandPos, textLength());
commandHistoryIndex = 0;
e.consume();
}
break;
case (KeyEvent.VK_ALT):
case (KeyEvent.VK_CAPS_LOCK):
case (KeyEvent.VK_CONTROL):
case (KeyEvent.VK_META):
case (KeyEvent.VK_SHIFT):
case (KeyEvent.VK_PRINTSCREEN):
case (KeyEvent.VK_SCROLL_LOCK):
case (KeyEvent.VK_PAUSE):
case (KeyEvent.VK_INSERT):
case (KeyEvent.VK_F1):
case (KeyEvent.VK_F2):
case (KeyEvent.VK_F3):
case (KeyEvent.VK_F4):
case (KeyEvent.VK_F5):
case (KeyEvent.VK_F6):
case (KeyEvent.VK_F7):
case (KeyEvent.VK_F8):
case (KeyEvent.VK_F9):
case (KeyEvent.VK_F10):
case (KeyEvent.VK_F11):
case (KeyEvent.VK_F12):
case (KeyEvent.VK_ESCAPE):
case (KeyEvent.VK_C):
break;
default:
if ((e.getModifiers()
& (InputEvent.CTRL_MASK | InputEvent.ALT_MASK | InputEvent.META_MASK))
== 0) {
moveCaret();
}
if ((e.paramString().contains("Backspace")) && (text.getCaretPosition() <= commandPos)) {
e.consume();
}
break;
}
}
private static Object getAction(final KeyEvent e, final JComponent comp) {
final KeyStroke stroke = KeyStroke.getKeyStroke(e.getKeyCode(), e.getModifiers());
return comp.getInputMap().get(stroke);
}
public void keyPressed(KeyEvent e) {
// if (e.isConsumed()) return;
int keyCode = e.getKeyCode();
IJ.setKeyDown(keyCode);
hotkey = false;
if (keyCode == KeyEvent.VK_CONTROL || keyCode == KeyEvent.VK_SHIFT) return;
char keyChar = e.getKeyChar();
int flags = e.getModifiers();
if (IJ.debugMode)
IJ.log(
"keyPressed: code="
+ keyCode
+ " ("
+ KeyEvent.getKeyText(keyCode)
+ "), char=\""
+ keyChar
+ "\" ("
+ (int) keyChar
+ "), flags="
+ KeyEvent.getKeyModifiersText(flags));
boolean shift = (flags & KeyEvent.SHIFT_MASK) != 0;
boolean control = (flags & KeyEvent.CTRL_MASK) != 0;
boolean alt = (flags & KeyEvent.ALT_MASK) != 0;
boolean meta = (flags & KeyEvent.META_MASK) != 0;
String cmd = null;
ImagePlus imp = WindowManager.getCurrentImage();
boolean isStack = (imp != null) && (imp.getStackSize() > 1);
if (imp != null
&& !control
&& ((keyChar >= 32 && keyChar <= 255) || keyChar == '\b' || keyChar == '\n')) {
Roi roi = imp.getRoi();
if (roi instanceof TextRoi) {
if ((flags & KeyEvent.META_MASK) != 0 && IJ.isMacOSX()) return;
if (alt) {
switch (keyChar) {
case 'u':
case 'm':
keyChar = IJ.micronSymbol;
break;
case 'A':
keyChar = IJ.angstromSymbol;
break;
default:
}
}
((TextRoi) roi).addChar(keyChar);
return;
}
}
// Handle one character macro shortcuts
if (!control && !meta) {
Hashtable macroShortcuts = Menus.getMacroShortcuts();
if (macroShortcuts.size() > 0) {
if (shift) cmd = (String) macroShortcuts.get(new Integer(keyCode + 200));
else cmd = (String) macroShortcuts.get(new Integer(keyCode));
if (cmd != null) {
// MacroInstaller.runMacroCommand(cmd);
commandName = cmd;
MacroInstaller.runMacroShortcut(cmd);
return;
}
}
}
if ((!Prefs.requireControlKey || control || meta) && keyChar != '+') {
Hashtable shortcuts = Menus.getShortcuts();
if (shift) cmd = (String) shortcuts.get(new Integer(keyCode + 200));
else cmd = (String) shortcuts.get(new Integer(keyCode));
}
if (cmd == null) {
switch (keyChar) {
case '<':
case ',':
if (isStack) cmd = "Previous Slice [<]";
break;
case '>':
case '.':
case ';':
if (isStack) cmd = "Next Slice [>]";
break;
case '+':
case '=':
cmd = "In [+]";
break;
case '-':
cmd = "Out [-]";
break;
case '/':
cmd = "Reslice [/]...";
break;
default:
}
}
if (cmd == null) {
switch (keyCode) {
case KeyEvent.VK_TAB:
WindowManager.putBehind();
return;
case KeyEvent.VK_BACK_SPACE: // delete
if (deleteOverlayRoi(imp)) return;
cmd = "Clear";
hotkey = true;
break;
// case KeyEvent.VK_BACK_SLASH: cmd=IJ.altKeyDown()?"Animation Options...":"Start
// Animation"; break;
case KeyEvent.VK_EQUALS:
cmd = "In [+]";
break;
case KeyEvent.VK_MINUS:
cmd = "Out [-]";
break;
case KeyEvent.VK_SLASH:
case 0xbf:
cmd = "Reslice [/]...";
break;
case KeyEvent.VK_COMMA:
case 0xbc:
if (isStack) cmd = "Previous Slice [<]";
break;
case KeyEvent.VK_PERIOD:
case 0xbe:
if (isStack) cmd = "Next Slice [>]";
break;
case KeyEvent.VK_LEFT:
case KeyEvent.VK_RIGHT:
case KeyEvent.VK_UP:
case KeyEvent.VK_DOWN: // arrow keys
if (imp == null) return;
Roi roi = imp.getRoi();
if (IJ.shiftKeyDown() && imp == Orthogonal_Views.getImage()) return;
boolean stackKey = imp.getStackSize() > 1 && (roi == null || IJ.shiftKeyDown());
boolean zoomKey = roi == null || IJ.shiftKeyDown() || IJ.controlKeyDown();
if (stackKey && keyCode == KeyEvent.VK_RIGHT) cmd = "Next Slice [>]";
else if (stackKey && keyCode == KeyEvent.VK_LEFT) cmd = "Previous Slice [<]";
else if (zoomKey
&& keyCode == KeyEvent.VK_DOWN
&& !ignoreArrowKeys(imp)
&& Toolbar.getToolId() < Toolbar.SPARE6) cmd = "Out [-]";
else if (zoomKey
&& keyCode == KeyEvent.VK_UP
&& !ignoreArrowKeys(imp)
&& Toolbar.getToolId() < Toolbar.SPARE6) cmd = "In [+]";
else if (roi != null) {
if ((flags & KeyEvent.ALT_MASK) != 0) roi.nudgeCorner(keyCode);
else roi.nudge(keyCode);
return;
}
break;
case KeyEvent.VK_ESCAPE:
abortPluginOrMacro(imp);
return;
case KeyEvent.VK_ENTER:
WindowManager.toFront(this);
return;
default:
break;
}
}
if (cmd != null && !cmd.equals("")) {
commandName = cmd;
if (cmd.equals("Fill") || cmd.equals("Draw")) hotkey = true;
if (cmd.charAt(0) == MacroInstaller.commandPrefix) MacroInstaller.runMacroShortcut(cmd);
else {
doCommand(cmd);
keyPressedTime = System.currentTimeMillis();
lastKeyCommand = cmd;
}
}
}
@Override
protected void processKeyEvent(KeyEvent evt) {
if (evt.getID() == KeyEvent.KEY_PRESSED) {
ActionContext ac = VFSBrowser.getActionContext();
int row = parentDirectories.getSelectedIndex();
switch (evt.getKeyCode()) {
case KeyEvent.VK_DOWN:
evt.consume();
if (row < parentDirectories.getSize().height - 1)
parentDirectories.setSelectedIndex(++row);
break;
case KeyEvent.VK_LEFT:
if ((evt.getModifiers() & InputEvent.ALT_MASK) > 0) {
evt.consume();
browser.previousDirectory();
} else super.processEvent(evt);
break;
case KeyEvent.VK_RIGHT:
if ((evt.getModifiers() & InputEvent.ALT_MASK) > 0) {
evt.consume();
browser.nextDirectory();
} else super.processEvent(evt);
break;
case KeyEvent.VK_TAB:
evt.consume();
if ((evt.getModifiers() & InputEvent.SHIFT_MASK) > 0) browser.focusOnDefaultComponent();
else table.requestFocus();
break;
case KeyEvent.VK_UP:
evt.consume();
if (row > 0) {
parentDirectories.setSelectedIndex(--row);
}
break;
case KeyEvent.VK_BACK_SPACE:
evt.consume();
EditAction up = ac.getAction("vfs.browser.up");
ac.invokeAction(evt, up);
break;
case KeyEvent.VK_F5:
evt.consume();
EditAction reload = ac.getAction("vfs.browser.reload");
ac.invokeAction(evt, reload);
break;
case KeyEvent.VK_ENTER:
evt.consume();
if (row != -1) {
// basically the same handling as in ParentMouseHandler#mouseReleased
Object obj = parentDirectories.getModel().getElementAt(row);
if (obj instanceof VFSFile) {
VFSFile dirEntry = (VFSFile) obj;
browser.setDirectory(dirEntry.getPath());
if (browser.getMode() == VFSBrowser.BROWSER) focusOnFileView();
}
}
break;
/* These actions don't work because they look at the EntryTable for the current selected
* item. We need actions that look at the parentDirectoryList item instead.
*
case KeyEvent.VK_DELETE:
evt.consume();
ea = ac.getAction("vfs.browser.delete");
ac.invokeAction(evt, ea);
break;
case KeyEvent.CTRL_MASK | KeyEvent.VK_N:
evt.consume();
ea = ac.getAction("vfs.browser.new-file");
ac.invokeAction(evt, ea);
break;
case KeyEvent.VK_INSERT:
evt.consume();
ea = ac.getAction("vfs.browser.new-directory");
ac.invokeAction(evt, ea);
break; */
}
} else if (evt.getID() == KeyEvent.KEY_TYPED) {
if (evt.isControlDown() || evt.isAltDown() || evt.isMetaDown()) {
evt.consume();
return;
}
switch (evt.getKeyChar()) {
case '~':
evt.consume();
if (browser.getMode() == VFSBrowser.BROWSER)
browser.setDirectory(System.getProperty("user.home"));
break;
case '/':
evt.consume();
if (browser.getMode() == VFSBrowser.BROWSER) browser.rootDirectory();
break;
case '-':
evt.consume();
if (browser.getMode() == VFSBrowser.BROWSER) {
browser.setDirectory(browser.getView().getBuffer().getDirectory());
}
break;
}
}
if (!evt.isConsumed()) super.processKeyEvent(evt);
}
/**
* Notification that a key is released.
*
* @param e The event that caused this method to be called
*/
public void keyReleased(KeyEvent e) {
switch (e.getKeyCode()) {
case KeyEvent.VK_A:
console.messageReport("Antialiasing not supported on Java3D yet.");
/*
if((e.getModifiers() & KeyEvent.ALT_MASK) != 0) {
numSamples = numSamples * 2;
int max = getMaximumNumSamples();
// Busy wait till answer comes. Should already be here
while(max < 0) {
try {
Thread.sleep(50);
} catch(Exception e2) {}
max = getMaximumNumSamples();
}
if (numSamples > max)
numSamples = 1;
statusLabel.setText("Antialiasing samples: " + numSamples + " out of max: " + max);
caps.setSampleBuffers(true);
caps.setNumSamples(numSamples);
resetSurface();
}
*/
break;
case KeyEvent.VK_PAGE_DOWN:
vpManager.nextViewpoint();
break;
case KeyEvent.VK_PAGE_UP:
vpManager.previousViewpoint();
break;
case KeyEvent.VK_HOME:
vpManager.firstViewpoint();
break;
case KeyEvent.VK_END:
vpManager.lastViewpoint();
break;
case KeyEvent.VK_F:
if ((e.getModifiers() & KeyEvent.CTRL_MASK) != 0) {
universe.setNavigationMode("FLY");
}
break;
case KeyEvent.VK_W:
if ((e.getModifiers() & KeyEvent.CTRL_MASK) != 0) {
universe.setNavigationMode("WALK");
} else if ((e.getModifiers() & KeyEvent.ALT_MASK) != 0) {
console.messageReport("Wireframe mode not supported on Java3D.");
}
break;
case KeyEvent.VK_E:
if ((e.getModifiers() & KeyEvent.CTRL_MASK) != 0) {
universe.setNavigationMode("EXAMINE");
}
break;
case KeyEvent.VK_Z:
if ((e.getModifiers() & KeyEvent.ALT_MASK) != 0) {
// Enter/Exit Elumens mode
elumensMode = !elumensMode;
// JC: We're not dealing with this right now.
// resetSurface();
}
break;
}
}
/**
* 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 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;
}
}
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);
}
}
