public void actionPerformed(@NotNull AnActionEvent event) {
if (logger.isDebugEnabled()) {
logger.debug("actionPerformed=" + event);
}
if (!VimPlugin.isEnabled()) {
return;
}
if (event.getInputEvent() instanceof KeyEvent) {
KeyEvent ke = (KeyEvent) event.getInputEvent();
Editor editor = event.getData(PlatformDataKeys.EDITOR);
if (editor != null) {
KeyStroke key = KeyStroke.getKeyStrokeForEvent(ke);
KeyHandler.getInstance().handleKey(editor, key, event.getDataContext());
} else {
if (ExEntryPanel.getInstance().isActive()) {
KeyEvent e =
new KeyEvent(
ke.getComponent(),
ke.getID(),
ke.getWhen(),
ke.getModifiers(),
ke.getKeyCode(),
ke.getKeyChar(),
ke.getKeyLocation());
ExEntryPanel.getInstance().processKey(e);
}
}
}
}
static boolean processKeyEventOnComponent(final Component target, final KeyEvent event) {
if (target instanceof JComponent) {
final boolean pressed = (event.getID() == KeyEvent.KEY_PRESSED);
final KeyStroke keyStroke = KeyStroke.getKeyStrokeForEvent(event);
if (((JComponent) target)
.processKeyBinding(keyStroke, event, JComponent.WHEN_IN_FOCUSED_WINDOW, pressed)) {
return true;
}
}
return false;
}
// {{{ _preprocessKeyEvent() method
private KeyEvent _preprocessKeyEvent(KeyEvent evt) {
if (view.isClosed()) return null;
Component focusOwner = view.getFocusOwner();
if (focusOwner instanceof JComponent) {
JComponent comp = (JComponent) focusOwner;
InputMap map = comp.getInputMap();
ActionMap am = comp.getActionMap();
if (map != null && am != null && comp.isEnabled()) {
KeyStroke keyStroke = KeyStroke.getKeyStrokeForEvent(evt);
Object binding = map.get(keyStroke);
if (binding != null && am.get(binding) != null) {
return null;
}
}
}
if (focusOwner instanceof JTextComponent) {
// fix for the bug where key events in JTextComponents
// inside views are also handled by the input handler
if (evt.getID() == KeyEvent.KEY_PRESSED) {
switch (evt.getKeyCode()) {
case KeyEvent.VK_ENTER:
case KeyEvent.VK_TAB:
case KeyEvent.VK_BACK_SPACE:
case KeyEvent.VK_SPACE:
return null;
}
}
}
if (evt.isConsumed()) return null;
if (Debug.DUMP_KEY_EVENTS) {
Log.log(Log.DEBUG, this, "Key event (preprocessing) : " + AbstractInputHandler.toString(evt));
}
return KeyEventWorkaround.processKeyEvent(evt);
} // }}}
@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);
}
}
private boolean inSecondStrokeInProgressState() {
KeyEvent e = myContext.getInputEvent();
// when any key is released, we stop waiting for the second stroke
if (KeyEvent.KEY_RELEASED == e.getID()) {
myFirstKeyStroke = null;
setState(KeyState.STATE_INIT);
Project project = PlatformDataKeys.PROJECT.getData(myContext.getDataContext());
StatusBar.Info.set(null, project);
return false;
}
KeyStroke originalKeyStroke = KeyStroke.getKeyStrokeForEvent(e);
KeyStroke keyStroke = getKeyStrokeWithoutMouseModifiers(originalKeyStroke);
updateCurrentContext(
myContext.getFoundComponent(),
new KeyboardShortcut(myFirstKeyStroke, keyStroke),
myContext.isModalContext());
// consume the wrong second stroke and keep on waiting
if (myContext.getActions().isEmpty()) {
return true;
}
// finally user had managed to enter the second keystroke, so let it be processed
Project project = PlatformDataKeys.PROJECT.getData(myContext.getDataContext());
StatusBarEx statusBar = (StatusBarEx) WindowManager.getInstance().getStatusBar(project);
if (processAction(e, myActionProcessor)) {
if (statusBar != null) {
statusBar.setInfo(null);
}
return true;
} else {
return false;
}
}
private boolean isKeyReserved(KeyEvent e) {
return fb.getActionForKeyStroke(KeyStroke.getKeyStrokeForEvent(e)) != null;
}
private boolean inInitState() {
Component focusOwner = myContext.getFocusOwner();
boolean isModalContext = myContext.isModalContext();
DataContext dataContext = myContext.getDataContext();
KeyEvent e = myContext.getInputEvent();
// http://www.jetbrains.net/jira/browse/IDEADEV-12372
if (myLeftCtrlPressed
&& myRightAltPressed
&& focusOwner != null
&& e.getModifiers() == (InputEvent.CTRL_MASK | InputEvent.ALT_MASK)) {
if (Registry.is("actionSystem.force.alt.gr")) {
return false;
}
final InputContext inputContext = focusOwner.getInputContext();
if (inputContext != null) {
Locale locale = inputContext.getLocale();
if (locale != null) {
@NonNls final String language = locale.getLanguage();
if (ALT_GR_LAYOUTS.contains(language)) {
// don't search for shortcuts
return false;
}
}
}
}
KeyStroke originalKeyStroke = KeyStroke.getKeyStrokeForEvent(e);
KeyStroke keyStroke = getKeyStrokeWithoutMouseModifiers(originalKeyStroke);
if (myKeyGestureProcessor.processInitState()) {
return true;
}
if (SystemInfo.isMac) {
boolean keyTyped = e.getID() == KeyEvent.KEY_TYPED;
boolean hasMnemonicsInWindow =
e.getID() == KeyEvent.KEY_PRESSED && hasMnemonicInWindow(focusOwner, e.getKeyCode())
|| keyTyped && hasMnemonicInWindow(focusOwner, e.getKeyChar());
boolean imEnabled = IdeEventQueue.getInstance().isInputMethodEnabled();
if (e.getModifiersEx() == InputEvent.ALT_DOWN_MASK
&& (hasMnemonicsInWindow || (!imEnabled && keyTyped))) {
setPressedWasProcessed(true);
setState(KeyState.STATE_PROCESSED);
return false;
}
}
updateCurrentContext(focusOwner, new KeyboardShortcut(keyStroke, null), isModalContext);
if (myContext.getActions().isEmpty()) {
// there's nothing mapped for this stroke
return false;
}
if (myContext.isHasSecondStroke()) {
myFirstKeyStroke = keyStroke;
final ArrayList<Pair<AnAction, KeyStroke>> secondKeyStrokes = getSecondKeystrokeActions();
final Project project = PlatformDataKeys.PROJECT.getData(dataContext);
StringBuilder message = new StringBuilder();
message.append(KeyMapBundle.message("prefix.key.pressed.message"));
message.append(' ');
for (int i = 0; i < secondKeyStrokes.size(); i++) {
Pair<AnAction, KeyStroke> pair = secondKeyStrokes.get(i);
if (i > 0) message.append(", ");
message.append(pair.getFirst().getTemplatePresentation().getText());
message.append(" (");
message.append(KeymapUtil.getKeystrokeText(pair.getSecond()));
message.append(")");
}
StatusBar.Info.set(message.toString(), project);
mySecondStrokeTimeout.cancelAllRequests();
mySecondStrokeTimeout.addRequest(
mySecondStrokeTimeoutRunnable, Registry.intValue("actionSystem.secondKeystrokeTimeout"));
if (Registry.is("actionSystem.secondKeystrokeAutoPopupEnabled")) {
mySecondKeystrokePopupTimeout.cancelAllRequests();
if (secondKeyStrokes.size() > 1) {
final DataContext oldContext = myContext.getDataContext();
mySecondKeystrokePopupTimeout.addRequest(
new Runnable() {
@Override
public void run() {
if (myState == KeyState.STATE_WAIT_FOR_SECOND_KEYSTROKE) {
StatusBar.Info.set(null, PlatformDataKeys.PROJECT.getData(oldContext));
new SecondaryKeystrokePopup(myFirstKeyStroke, secondKeyStrokes, oldContext)
.showInBestPositionFor(oldContext);
}
}
},
Registry.intValue("actionSystem.secondKeystrokePopupTimeout"));
}
}
setState(KeyState.STATE_WAIT_FOR_SECOND_KEYSTROKE);
return true;
} else {
return processAction(e, myActionProcessor);
}
}
