@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 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();
}
}
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;
}
@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);
}
}
}
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;
}
}
@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);
}
}
}
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;
}
}
@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);
}
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;
}
}
private static Object getAction(final KeyEvent e, final JComponent comp) {
final KeyStroke stroke = KeyStroke.getKeyStroke(e.getKeyCode(), e.getModifiers());
return comp.getInputMap().get(stroke);
}
