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);
}
}
}
}
public void processKeyEvent(Component focusedComponent, KeyEvent e) {
if (e.getID() != KeyEvent.KEY_PRESSED) return;
int keyCode = e.getKeyCode();
if (keyCode == KeyEvent.VK_CAPS_LOCK
|| // the keys we want to ignore...
keyCode == KeyEvent.VK_SHIFT
|| keyCode == KeyEvent.VK_CONTROL
|| keyCode == KeyEvent.VK_META
|| keyCode == KeyEvent.VK_ALT
|| keyCode == KeyEvent.VK_ALT_GRAPH
|| keyCode == KeyEvent.VK_COMPOSE
|| keyCode == KeyEvent.VK_NUM_LOCK
|| keyCode == KeyEvent.VK_SCROLL_LOCK
|| keyCode == KeyEvent.VK_UNDEFINED) return;
if (currentAction == null) Debug.message("FunctionDialog: currentAction is null...");
else {
KeyStroke key = KeyStroke.getKeyStrokeForEvent(e);
if (isPrintable(key, e)) helpLabel.setText(getHelpText("cannot-redefine"));
else {
actions.addActionForKeyStroke(key, currentAction);
handleFuncListSelect();
}
}
e.consume();
removeKeyListener();
}
public void keyPressed(KeyEvent keyEvent) {
AppLogger.finest(
"keyModifiers=" + keyEvent.getModifiers() + " keyCode=" + keyEvent.getKeyCode());
int keyCode = keyEvent.getKeyCode();
if (keyCode == KeyEvent.VK_SHIFT
|| keyCode == KeyEvent.VK_CONTROL
|| keyCode == KeyEvent.VK_ALT
|| keyCode == KeyEvent.VK_META) return;
KeyStroke pressedKeyStroke = KeyStroke.getKeyStrokeForEvent(keyEvent);
if (pressedKeyStroke.equals(lastKeyStroke)) {
TableCellEditor activeCellEditor = getCellEditor();
if (activeCellEditor != null) activeCellEditor.stopCellEditing();
} else {
String actionId;
if ((actionId = data.contains(pressedKeyStroke)) != null) {
String errorMessage =
"The shortcut ["
+ KeyStrokeUtils.getKeyStrokeDisplayableRepresentation(pressedKeyStroke)
+ "] is already assigned to '"
+ ActionProperties.getActionDescription(actionId)
+ "'";
tooltipBar.showErrorMessage(errorMessage);
createCancelEditingStateThread(getCellEditor());
} else {
lastKeyStroke = pressedKeyStroke;
setText(KeyStrokeUtils.getKeyStrokeDisplayableRepresentation(lastKeyStroke));
}
}
keyEvent.consume();
}
public void keyPressed(KeyEvent e) {
KeyStroke currentStroke = KeyStroke.getKeyStrokeForEvent(e);
if (e.getKeyCode() == KeyEvent.VK_ENTER) {
TreePath path = ((JTree) e.getSource()).getSelectionPath();
if (path == null) {
return;
}
AWorkspaceTreeNode node = (AWorkspaceTreeNode) path.getLastPathComponent();
if (node instanceof IWorkspaceNodeActionListener) {
((IWorkspaceNodeActionListener) node)
.handleAction(
new WorkspaceActionEvent(
node, WorkspaceActionEvent.WSNODE_OPEN_DOCUMENT, 0, 0, e.getComponent()));
e.consume();
}
} else {
for (HotKeyIdentifier id : actionKeyMap.keySet()) {
if (currentStroke.equals(id.getKeyStroke())) {
if (id.accept(e)) {
AFreeplaneAction action = WorkspaceController.getAction(actionKeyMap.get(id));
if (action != null) {
action.actionPerformed(new ActionEvent(e.getSource(), 0, null));
} else {
LogUtils.info("No action set for: " + id.getKeyStroke());
}
}
e.consume();
break;
}
}
}
}
public void keyPressed(KeyEvent e) {
TreePath selectionPath = mainTree.getSelectionPath();
if (selectionPath == null || mainTree.getSelectionCount() == 0) {
return;
}
if (mainTree.getSelectionCount() == 1) {
SoapUITreeNode lastPathComponent = (SoapUITreeNode) selectionPath.getLastPathComponent();
ActionList actions = lastPathComponent.getActions();
if (actions != null) {
actions.dispatchKeyEvent(e);
}
if (!e.isConsumed()) {
KeyStroke ks = KeyStroke.getKeyStrokeForEvent(e);
if (ks.equals(UISupport.getKeyStroke("alt C"))) {
mainTree.collapsePath(selectionPath);
e.consume();
} else if (ks.equals(UISupport.getKeyStroke("alt E"))) {
mainTree.collapsePath(selectionPath);
int row = mainTree.getSelectionRows()[0];
TreePath nextPath = mainTree.getPathForRow(row + 1);
TreePath path = mainTree.getPathForRow(row);
while (path != null && !path.equals(nextPath)) {
mainTree.expandRow(row);
path = mainTree.getPathForRow(++row);
}
e.consume();
}
}
} else {
TreePath[] selectionPaths = mainTree.getSelectionPaths();
List<ModelItem> targets = new ArrayList<ModelItem>();
for (TreePath treePath : selectionPaths) {
SoapUITreeNode node = (SoapUITreeNode) treePath.getLastPathComponent();
targets.add(node.getModelItem());
}
if (targets.size() > 0) {
ActionList actions =
ActionListBuilder.buildMultiActions(targets.toArray(new ModelItem[targets.size()]));
if (actions.getActionCount() > 0) {
actions.dispatchKeyEvent(e);
}
}
}
}
// {{{ _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);
}
}
private void listKeyReleased(java.awt.event.KeyEvent evt) { // GEN-FIRST:event_listKeyReleased
KeyStroke ks = KeyStroke.getKeyStrokeForEvent(evt);
if (ks.getKeyCode() == KeyEvent.VK_ENTER || ks.getKeyCode() == KeyEvent.VK_SPACE) {
invokeSelected();
}
} // GEN-LAST:event_listKeyReleased
