public static boolean isDigraphStart(@NotNull KeyStroke key) { if ((key.getModifiers() & KeyEvent.CTRL_MASK) != 0) { if (key.getKeyCode() == KeyEvent.VK_K || key.getKeyCode() == KeyEvent.VK_V || key.getKeyCode() == KeyEvent.VK_Q) { return true; } } return false; }
public static boolean isCloseKeyStroke(@NotNull KeyStroke key) { return key.getKeyCode() == VK_ESCAPE || key.getKeyChar() == VK_ESCAPE || key.getKeyCode() == VK_C && (key.getModifiers() & CTRL_MASK) != 0 || key.getKeyCode() == '[' && (key.getModifiers() & CTRL_MASK) != 0; }
@Override public int compareTo(@NotNull Row row) { final KeyStroke otherKeyStroke = row.getKeyStroke(); final int keyCodeDiff = myKeyStroke.getKeyCode() - otherKeyStroke.getKeyCode(); return keyCodeDiff != 0 ? keyCodeDiff : myKeyStroke.getModifiers() - otherKeyStroke.getModifiers(); }
private boolean isDeleteCommandCount(@NotNull KeyStroke key, @NotNull CommandState editorState) { return (editorState.getMode() == CommandState.Mode.COMMAND || editorState.getMode() == CommandState.Mode.VISUAL) && state == State.NEW_COMMAND && currentArg != Argument.Type.CHARACTER && currentArg != Argument.Type.DIGRAPH && key.getKeyCode() == KeyEvent.VK_DELETE && count != 0; }
@Nullable private static String toEscapeNotation(@NotNull KeyStroke key) { final char c = key.getKeyChar(); if (isControlCharacter(c)) { return "^" + String.valueOf((char)(c + 'A' - 1)); } else if (isControlKeyCode(key)) { return "^" + String.valueOf((char)(key.getKeyCode() + 'A' - 1)); } return null; }
private static void appendRest(StringBuilder sb, KeyStroke stroke) { String c = initNameAndValues().keyToString.get(Integer.valueOf(stroke.getKeyCode())); if (c == null) { sb.append(stroke.getKeyChar()); } else { sb.append(c); } }
private static boolean isControlKeyCode(@NotNull KeyStroke key) { return key.getKeyChar() == CHAR_UNDEFINED && key.getKeyCode() < 0x20 && key.getModifiers() == 0; }
@NotNull private KeyEvent createKeyEvent(@NotNull KeyStroke stroke, Component component) { return new KeyEvent(component, stroke.getKeyChar() == KeyEvent.CHAR_UNDEFINED ? KeyEvent.KEY_PRESSED : KeyEvent.KEY_TYPED, System.currentTimeMillis(), stroke.getModifiers(), stroke.getKeyCode(), stroke.getKeyChar()); }
private int compareKeys(@NotNull KeyStroke key1, @NotNull KeyStroke key2) { final char c1 = key1.getKeyChar(); final char c2 = key2.getKeyChar(); if (c1 == KeyEvent.CHAR_UNDEFINED && c2 == KeyEvent.CHAR_UNDEFINED) { final int keyCodeDiff = key1.getKeyCode() - key2.getKeyCode(); if (keyCodeDiff != 0) { return keyCodeDiff; } return key1.getModifiers() - key2.getModifiers(); } else if (c1 == KeyEvent.CHAR_UNDEFINED) { return -1; } else if (c2 == KeyEvent.CHAR_UNDEFINED) { return 1; } else { return c1 - c2; } } }
private void handleCharArgument(@NotNull KeyStroke key, char chKey) { // We are expecting a character argument - is this a regular character the user typed? // Some special keys can be handled as character arguments - let's check for them here. if (chKey == 0) { switch (key.getKeyCode()) { case KeyEvent.VK_TAB: chKey = '\t'; break; case KeyEvent.VK_ENTER: chKey = '\n'; break; } } if (chKey != 0) { // Create the character argument, add it to the current command, and signal we are ready to process // the command Argument arg = new Argument(chKey); Command cmd = currentCmd.peek(); cmd.setArgument(arg); state = State.READY; } else { // Oops - this isn't a valid character argument state = State.BAD_COMMAND; } }
public void handleKey(@NotNull KeyStroke stroke) { if (logger.isDebugEnabled()) logger.debug("stroke=" + stroke); final char keyChar = stroke.getKeyChar(); char c = keyChar; final int modifiers = stroke.getModifiers(); final int keyCode = stroke.getKeyCode(); if ((modifiers & KeyEvent.CTRL_MASK) != 0) { final int codePoint = keyCode - KeyEvent.VK_A + 1; if (codePoint > 0) { c = Character.toChars(codePoint)[0]; } } KeyEvent event = new KeyEvent(this, keyChar != KeyEvent.CHAR_UNDEFINED ? KeyEvent.KEY_TYPED : (stroke.isOnKeyRelease() ? KeyEvent.KEY_RELEASED : KeyEvent.KEY_PRESSED), (new Date()).getTime(), modifiers, keyCode, c); super.processKeyEvent(event); }
@NotNull public static String toKeyNotation(@NotNull KeyStroke key) { final char c = key.getKeyChar(); final int keyCode = key.getKeyCode(); final int modifiers = key.getModifiers();
public void saveData(@NotNull final Element element) { logger.debug("saveData"); final Element registersElement = new Element("registers"); for (Character key : registers.keySet()) { final Register register = registers.get(key); final Element registerElement = new Element("register"); registerElement.setAttribute("name", String.valueOf(key)); registerElement.setAttribute("type", Integer.toString(register.getType().getValue())); final String text = register.getText(); if (text != null) { final Element textElement = new Element("text"); StringHelper.setSafeXmlText(textElement, text); registerElement.addContent(textElement); } else { final Element keys = new Element("keys"); final List<KeyStroke> list = register.getKeys(); for (KeyStroke stroke : list) { final Element k = new Element("key"); k.setAttribute("char", Integer.toString(stroke.getKeyChar())); k.setAttribute("code", Integer.toString(stroke.getKeyCode())); k.setAttribute("mods", Integer.toString(stroke.getModifiers())); keys.addContent(k); } registerElement.addContent(keys); } registersElement.addContent(registerElement); } element.addContent(registersElement); }
private void handleEditorReset(@NotNull Editor editor, @NotNull KeyStroke key, @NotNull final DataContext context) { if (state != State.COMMAND && count == 0 && currentArg == Argument.Type.NONE && currentCmd.size() == 0) { RegisterGroup register = VimPlugin.getRegister(); if (register.getCurrentRegister() == register.getDefaultRegister()) { if (key.getKeyCode() == KeyEvent.VK_ESCAPE) { CommandProcessor.getInstance().executeCommand(editor.getProject(), new Runnable() { @Override public void run() { KeyHandler.executeAction("EditorEscape", context); } }, "", null); } VimPlugin.indicateError(); } } reset(editor); }
final TestInputModel inputModel = TestInputModel.getInstance(editor); for (KeyStroke key = inputModel.nextKeyStroke(); key != null && !StringHelper.isCloseKeyStroke(key) && key.getKeyCode() != KeyEvent.VK_ENTER; key = inputModel.nextKeyStroke()) { final char c = key.getKeyChar();
@Override public boolean process(KeyStroke key) { if (StringHelper.isCloseKeyStroke(key)) { exEntryPanel.deactivate(true); return false; } else if (key.getKeyCode() == KeyEvent.VK_ENTER) { text.set(exEntryPanel.getText()); exEntryPanel.deactivate(true); return false; } else { exEntryPanel.handleKey(key); return true; } } });
final KeyStroke keyStroke = getKeyStroke(e); if (editor != null && keyStroke != null) { final int keyCode = keyStroke.getKeyCode(); if (LookupManager.getActiveLookup(editor) != null) { return isExitInsertMode(keyStroke);
@Override public boolean dispatchKeyEvent(KeyEvent e) { final KeyStroke stroke; if (e.getID() == KeyEvent.KEY_RELEASED) { stroke = KeyStroke.getKeyStrokeForEvent(e); if (!StringHelper.isCloseKeyStroke(stroke) && stroke.getKeyCode() != KeyEvent.VK_ENTER) { return true; } } else if (e.getID() == KeyEvent.KEY_TYPED) { stroke = KeyStroke.getKeyStrokeForEvent(e); } else { return true; } if (!processor.process(stroke)) { KeyboardFocusManager.getCurrentKeyboardFocusManager().removeKeyEventDispatcher(this); loop.exit(); } return true; } });
case DIG_STATE_START: logger.debug("DIG_STATE_START"); if (key.getKeyCode() == KeyEvent.VK_K && (key.getModifiers() & KeyEvent.CTRL_MASK) != 0) { logger.debug("found Ctrl-K"); digraphState = DIG_STATE_DIG_ONE; return DigraphResult.OK; else if ((key.getKeyCode() == KeyEvent.VK_V || key.getKeyCode() == KeyEvent.VK_Q) && (key.getModifiers() & KeyEvent.CTRL_MASK) != 0) { logger.debug("found Ctrl-V"); return DigraphResult.OK; default: switch (key.getKeyCode()) { case KeyEvent.VK_TAB: KeyStroke code = KeyStroke.getKeyStroke('\t');
private static void appendRest(StringBuilder sb, KeyStroke stroke) { String c = initNameAndValues().keyToString.get(Integer.valueOf(stroke.getKeyCode())); if (c == null) { sb.append(stroke.getKeyChar()); } else { sb.append(c); } }