/** * Get the text in the register. */ @Nullable public String getText() { final StringBuilder builder = new StringBuilder(); for (KeyStroke key : keys) { final char c = key.getKeyChar(); if (c == KeyEvent.CHAR_UNDEFINED) { return null; } builder.append(c); } return builder.toString(); }
private static char getChar(@NotNull Editor editor) { final KeyStroke key = inputKeyStroke(editor); final char keyChar = key.getKeyChar(); if (keyChar == KeyEvent.CHAR_UNDEFINED || keyChar == KeyEvent.VK_ESCAPE) { return 0; } return keyChar; }
@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()); }
/** * @deprecated Inherit your action from {@link com.maddyhome.idea.vim.action.VimCommandAction} instead. */ @Deprecated public void registerAction(@NotNull Set<MappingMode> mappingModes, @NotNull String actName, @NotNull Command.Type cmdType, int cmdFlags, @NotNull Shortcut[] shortcuts, @NotNull Argument.Type argType) { for (Shortcut shortcut : shortcuts) { final KeyStroke[] keys = shortcut.getKeys(); for (KeyStroke key : keys) { if (key.getKeyChar() == KeyEvent.CHAR_UNDEFINED) { requiredShortcutKeys.add(key); } } //noinspection deprecation registerAction(mappingModes, actName, cmdType, cmdFlags, keys, argType); } }
@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; }
/** * Drafts an {@link ActionPlan} for preemptive rendering before "regular" keystroke processing in insert/replace mode. * <p> * Like {@link #processKey(Editor, DataContext, KeyStroke)}, delegates the task to the original handler. * * @param editor The editor the character was typed into * @param context The data context * @param key The user entered keystroke * @param plan the current action plan draft */ public void beforeProcessKey(@NotNull final Editor editor, @NotNull final DataContext context, @NotNull final KeyStroke key, @NotNull ActionPlan plan) { final TypedActionHandler originalHandler = KeyHandler.getInstance().getOriginalHandler(); if (originalHandler instanceof TypedActionHandlerEx) { ((TypedActionHandlerEx)originalHandler).beforeExecute(editor, key.getKeyChar(), context, plan); } }
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; } } }
public void putKeyMapping(@NotNull Set<MappingMode> modes, @NotNull List<KeyStroke> fromKeys, @Nullable List<KeyStroke> toKeys, @Nullable VimExtensionHandler extensionHandler, boolean recursive) { for (MappingMode mode : modes) { final KeyMapping mapping = getKeyMapping(mode); mapping.put(EnumSet.of(mode), fromKeys, toKeys, extensionHandler, recursive); } final int oldSize = requiredShortcutKeys.size(); for (KeyStroke key : fromKeys) { if (key.getKeyChar() == KeyEvent.CHAR_UNDEFINED) { requiredShortcutKeys.add(key); } } if (requiredShortcutKeys.size() != oldSize) { for (Editor editor : EditorFactory.getInstance().getAllEditors()) { unregisterShortcutKeys(editor); registerRequiredShortcutKeys(editor); } } }
@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 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); }
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); }
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; }
/** * This processes all "regular" keystrokes entered while in insert/replace mode * * @param editor The editor the character was typed into * @param context The data context * @param key The user entered keystroke * @return true if this was a regular character, false if not */ public boolean processKey(@NotNull final Editor editor, @NotNull final DataContext context, @NotNull final KeyStroke key) { if (logger.isDebugEnabled()) { logger.debug("processKey(" + key + ")"); } if (key.getKeyChar() != KeyEvent.CHAR_UNDEFINED) { final Document doc = editor.getDocument(); CommandProcessor.getInstance().executeCommand(editor.getProject(), () -> ApplicationManager.getApplication().runWriteAction( () -> KeyHandler.getInstance().getOriginalHandler().execute( editor, key.getKeyChar(), context)), "", doc, UndoConfirmationPolicy.DEFAULT, doc); return true; } return false; }
public void actionPerformed(@NotNull ActionEvent e) { ExTextField target = (ExTextField)getTextComponent(e); final Action currentAction = target.getCurrentAction(); if (currentAction != null) { currentAction.actionPerformed(e); } else { KeyStroke key = convert(e); if (key != null) { final char c = key.getKeyChar(); if (c > 0) { ActionEvent event = new ActionEvent(e.getSource(), e.getID(), "" + c, e.getWhen(), e.getModifiers()); super.actionPerformed(event); target.saveLastEntry(); } } else { super.actionPerformed(e); target.saveLastEntry(); } } } }
key != null && !StringHelper.isCloseKeyStroke(key) && key.getKeyCode() != KeyEvent.VK_ENTER; key = inputModel.nextKeyStroke()) { final char c = key.getKeyChar(); if (c != KeyEvent.CHAR_UNDEFINED) { builder.append(c);
ModalEntry.activate(key -> { final ReplaceConfirmationChoice choice; final char c = key.getKeyChar(); if (StringHelper.isCloseKeyStroke(key) || c == 'q') { choice = ReplaceConfirmationChoice.QUIT;
public void actionPerformed(@NotNull ActionEvent e) { final ExTextField target = (ExTextField)getTextComponent(e); final KeyStroke key = convert(e); if (key != null) { switch (state) { case SKIP_CTRL_R: state = State.WAIT_REGISTER; target.setCurrentAction(this); break; case WAIT_REGISTER: state = State.SKIP_CTRL_R; target.setCurrentAction(null); final char c = key.getKeyChar(); if (c != KeyEvent.CHAR_UNDEFINED) { final Register register = VimPlugin.getRegister().getRegister(c); if (register != null) { final String oldText = target.getText(); final String text = register.getText(); if (oldText != null && text != null) { target.setText(oldText + text); } } } else { target.handleKey(key); } } } } }
char chKey = key.getKeyChar() == KeyEvent.CHAR_UNDEFINED ? 0 : key.getKeyChar(); char dig = VimPlugin.getDigraph().getDigraph(lastChar, key.getKeyChar()); key = KeyStroke.getKeyStroke(dig); lastChar = key.getKeyChar(); partialReset(editor);