/** * Returns the KeyStroke for this binding, as defined by the defaults, or in the Preferences, but * adapted for Mac users, with the Command key preferred instead of Control. */ private KeyStroke getKeyForMac(KeyStroke ks) { if (ks == null) return null; int keyCode = ks.getKeyCode(); if ((ks.getModifiers() & KeyEvent.CTRL_MASK) == 0) { return ks; } else { if ((ks.getModifiers() & KeyEvent.SHIFT_MASK) != 0) { return KeyStroke.getKeyStroke(keyCode, Globals.getShortcutMask() + KeyEvent.SHIFT_MASK); } return KeyStroke.getKeyStroke(keyCode, Globals.getShortcutMask()); } }
public static void registerHotKey(KeyStroke stroke, final ActionBase ab) { // under windows, use hotkey that can be used even when window // has not the focus. Note that all keys are nor hotkeys (given // by bHotkey flag) int index = hmIndexAction.size() - 1; jintellitype.registerSwingHotKey(index + 1, stroke.getModifiers(), stroke.getKeyCode()); // register the action with its index hmIndexAction.put(index + 1, ab); // add the listener jintellitype.addHotKeyListener( new HotkeyListener() { public void onHotKey(int key) { // Leave if user disabled hotkeys if (!ConfigurationManager.getBoolean(CONF_OPTIONS_HOTKEYS)) { return; } // Check it is the right listener that caught the event if (ab.equals(hmIndexAction.get(key))) { try { // Call action itself ab.perform(null); } catch (Throwable e2) { Log.error(e2); } finally { ObservationManager.notify(new Event(EventSubject.EVENT_PLAYLIST_REFRESH)); } } } }); }
/** * Converts a KeyStroke into a string representation for preference storage. * * @param prefsStroke the KeyStroke to convert * @return a string representation of the form "modifiers keyCode" or <code>null</code> * if the prefsStroke is invalid or <code>null</code> */ public static final String strokeToPrefs(KeyStroke prefsStroke) { if (prefsStroke == null) return null; else return String.valueOf(prefsStroke.getModifiers()) + ' ' + String.valueOf(prefsStroke.getKeyCode()); }
/** * Returns a human readable text for the shortcut. * * @return a human readable text for the shortcut */ public String getKeyText() { KeyStroke keyStroke = getKeyStroke(); if (keyStroke == null) return ""; String modifText = KeyEvent.getKeyModifiersText(keyStroke.getModifiers()); if ("".equals(modifText)) return KeyEvent.getKeyText(keyStroke.getKeyCode()); return modifText + '+' + KeyEvent.getKeyText(keyStroke.getKeyCode()); }
public static String keyStroke2String(KeyStroke key) { StringBuffer s = new StringBuffer(50); int m = key.getModifiers(); if ((m & 0x41) != 0) s.append("shift "); if ((m & 0x82) != 0) s.append("ctrl "); if ((m & 0x104) != 0) s.append("meta "); if ((m & 0x208) != 0) s.append("alt "); if ((m & 0x410) != 0) s.append("button1 "); if ((m & 0x808) != 0) s.append("button2 "); if ((m & 0x1004) != 0) s.append("button3 "); switch (key.getKeyEventType()) { case 400: s.append("typed "); s.append(key.getKeyChar() + " "); break; case 401: s.append("pressed "); s.append(getKeyText(key.getKeyCode()) + " "); break; case 402: s.append("released "); s.append(getKeyText(key.getKeyCode()) + " "); break; default: s.append("unknown-event-type"); break; } return s.toString(); }
public void setActionItem(GUIAction aAction) { mAction = aAction; this.setText(mAction.getTitle()); if (mAction.getMnemonic() != 0) this.setMnemonic(mAction.getMnemonic()); setImage(mAction.getIcon()); if (mAction.getIcon() != null) this.setIcon((ImageIcon) mAction.getIcon().resizeIcon(24, true).getData()); else this.setIcon(null); KeyStroke key = KeyStroke.getKeyStroke(mAction.getKeyStroke()); if (key != null) { int key_code = key.getKeyCode(); int modifier = key.getModifiers(); int new_modifier = 0; if ((modifier & java.awt.event.InputEvent.ALT_MASK) == java.awt.event.InputEvent.ALT_MASK) new_modifier += java.awt.event.InputEvent.ALT_MASK; if ((modifier & java.awt.event.InputEvent.SHIFT_MASK) == java.awt.event.InputEvent.SHIFT_MASK) new_modifier += java.awt.event.InputEvent.SHIFT_MASK; if ((modifier & java.awt.event.InputEvent.CTRL_MASK) == java.awt.event.InputEvent.CTRL_MASK) new_modifier += getControlKey(); this.setAccelerator(KeyStroke.getKeyStroke(key_code, new_modifier)); } this.addActionListener( new ActionListener() { public void actionPerformed(ActionEvent e) { mAction.actionPerformed(); } }); }
public static InputEvent getInputEvent(String actionName) { final Shortcut[] shortcuts = KeymapManager.getInstance().getActiveKeymap().getShortcuts(actionName); KeyStroke keyStroke = null; for (Shortcut each : shortcuts) { if (each instanceof KeyboardShortcut) { keyStroke = ((KeyboardShortcut) each).getFirstKeyStroke(); if (keyStroke != null) break; } } if (keyStroke != null) { return new KeyEvent( JOptionPane.getRootFrame(), KeyEvent.KEY_PRESSED, System.currentTimeMillis(), keyStroke.getModifiers(), keyStroke.getKeyCode(), keyStroke.getKeyChar(), KeyEvent.KEY_LOCATION_STANDARD); } else { return new MouseEvent( JOptionPane.getRootFrame(), MouseEvent.MOUSE_PRESSED, 0, 0, 0, 0, 1, false, MouseEvent.BUTTON1); } }
/** * This is hack. AWT doesn't allow to create KeyStroke with specified key code and key char * simultaneously. Therefore we are using reflection. */ private static KeyStroke getKeyStrokeWithoutMouseModifiers(KeyStroke originalKeyStroke) { int modifier = originalKeyStroke.getModifiers() & ~InputEvent.BUTTON1_DOWN_MASK & ~InputEvent.BUTTON1_MASK & ~InputEvent.BUTTON2_DOWN_MASK & ~InputEvent.BUTTON2_MASK & ~InputEvent.BUTTON3_DOWN_MASK & ~InputEvent.BUTTON3_MASK; try { Method[] methods = AWTKeyStroke.class.getDeclaredMethods(); Method getCachedStrokeMethod = null; for (Method method : methods) { if (GET_CACHED_STROKE_METHOD_NAME.equals(method.getName())) { getCachedStrokeMethod = method; getCachedStrokeMethod.setAccessible(true); break; } } if (getCachedStrokeMethod == null) { throw new IllegalStateException("not found method with name getCachedStrokeMethod"); } Object[] getCachedStrokeMethodArgs = new Object[] { originalKeyStroke.getKeyChar(), originalKeyStroke.getKeyCode(), modifier, originalKeyStroke.isOnKeyRelease() }; return (KeyStroke) getCachedStrokeMethod.invoke(originalKeyStroke, getCachedStrokeMethodArgs); } catch (Exception exc) { throw new IllegalStateException(exc.getMessage()); } }
/** * Get the mnemonic for a keystroke. * * @param key a keystroke * @return mnemonic of tghe keystroke. */ private static String getKeyMnemonic(KeyStroke key) { String sk = org.openide.util.Utilities.keyToString(key); StringBuffer sb = new StringBuffer(); int mods = key.getModifiers(); if ((mods & KeyEvent.CTRL_MASK) != 0) { sb.append("Ctrl+"); // NOI18N } if ((mods & KeyEvent.ALT_MASK) != 0) { sb.append("Alt+"); // NOI18N } if ((mods & KeyEvent.SHIFT_MASK) != 0) { sb.append("Shift+"); // NOI18N } if ((mods & KeyEvent.META_MASK) != 0) { sb.append("Meta+"); // NOI18N } int i = sk.indexOf('-'); // NOI18N if (i != -1) { sk = sk.substring(i + 1); } sb.append(sk); return sb.toString(); }
public boolean isValid(final KeyStroke keystroke, final Character keyChar) { if (keystroke == null) { return true; } final Node menuBarNode = menuBuilder.getMenuBar(menuBuilder.get(key)); if (menuBarNode == null) { return true; } if (keyChar != KeyEvent.CHAR_UNDEFINED && (keystroke.getModifiers() & (Event.ALT_MASK | Event.CTRL_MASK | Event.META_MASK)) == 0) { final String keyTypeActionString = ResourceController.getResourceController() .getProperty("key_type_action", FirstAction.EDIT_CURRENT.toString()); FirstAction keyTypeAction = FirstAction.valueOf(keyTypeActionString); return FirstAction.IGNORE.equals(keyTypeAction); } if ((keystroke.getModifiers() & (Event.ALT_MASK | Event.CTRL_MASK | Event.META_MASK)) == Event.ALT_MASK) { final JMenuBar menuBar = (JMenuBar) menuBarNode.getUserObject(); final int menuCount = menuBar.getMenuCount(); for (int i = 0; i < menuCount; i++) { final JMenu menu = menuBar.getMenu(i); final char c = (char) menu.getMnemonic(); if (Character.toLowerCase(keystroke.getKeyCode()) == Character.toLowerCase(c)) { JOptionPane.showMessageDialog( parentComponent, menu.getText(), TextUtils.getText("used_in_menu"), JOptionPane.WARNING_MESSAGE); return false; } } } if (!checkForOverwriteShortcut(menuBarNode, keystroke)) { return false; } final KeyStroke derivedKS = FreeplaneMenuBar.derive(keystroke, keyChar); if (derivedKS == keystroke) { return true; } return checkForOverwriteShortcut(menuBarNode, derivedKS); }
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 List<KeyStroke> getAdditionalShortcuts(KeyStroke keystroke) { if (keystroke == null) { return null; } ArrayList<KeyStroke> ret = new ArrayList<KeyStroke>(); Modifier mod1 = byPassDialog.getByPassDialogToggleModifier(); if (mod1 != null) { ret.add(KeyStroke.getKeyStroke(keystroke.getKeyCode(), keystroke.getModifiers() | mod1.getModifier())); } Modifier mod2 = getDeleteFilesToggleModifier(); if (mod2 != null) { ret.add(KeyStroke.getKeyStroke(keystroke.getKeyCode(), keystroke.getModifiers() | mod2.getModifier())); } if (mod2 != null && mod1 != null) { ret.add(KeyStroke.getKeyStroke(keystroke.getKeyCode(), keystroke.getModifiers() | mod2.getModifier() | mod1.getModifier())); } return ret; }
private void pressKeyStrokeAndVerify(final int expectedKey) { assertThat(keyStroke.getModifiers()).as("no modifiers should be specified").isEqualTo(0); final KeyRecorder recorder = KeyRecorder.attachTo(textArea); pressInTextArea(); pause( new Condition(concat("key with code ", expectedKey, " is pressed")) { @Override public boolean test() { return recorder.keysWerePressed(expectedKey); } }, 2000); }
@NotNull public static String toKeyNotation(@NotNull KeyStroke key) { final char c = key.getKeyChar(); final int keyCode = key.getKeyCode(); final int modifiers = key.getModifiers(); if (c != CHAR_UNDEFINED && !isControlCharacter(c)) { return String.valueOf(c); } String prefix = ""; if ((modifiers & META_MASK) != 0) { prefix += "M-"; } if ((modifiers & ALT_MASK) != 0) { prefix += "A-"; } if ((modifiers & CTRL_MASK) != 0) { prefix += "C-"; } if ((modifiers & SHIFT_MASK) != 0) { prefix += "S-"; } String name = VIM_KEY_VALUES.get(keyCode); if (name != null) { if (UPPERCASE_DISPLAY_KEY_NAMES.contains(name)) { name = name.toUpperCase(); } else { name = StringUtil.capitalize(name); } } if (name == null) { final String escape = toEscapeNotation(key); if (escape != null) { return escape; } try { name = String.valueOf(Character.toChars(keyCode)); } catch (IllegalArgumentException ignored) { } } return name != null ? "<" + prefix + name + ">" : "<<" + key.toString() + ">>"; }
private boolean isPrintable(KeyStroke key, KeyEvent e) { // all control and alt keys are non-printable int modifiers = key.getModifiers(); if (modifiers != 0 && modifiers != Event.SHIFT_MASK) return false; // action keys are non-printable if (e.isActionKey()) return false; // some action keys that the above function not recognises int keyCode = e.getKeyCode(); if (keyCode == KeyEvent.VK_BACK_SPACE || keyCode == KeyEvent.VK_DELETE || keyCode == KeyEvent.VK_ENTER || keyCode == KeyEvent.VK_TAB || keyCode == KeyEvent.VK_ESCAPE) return false; // otherwise it's printable return true; }
public static String getKeystrokeText(KeyStroke accelerator) { if (accelerator == null) return ""; if (SystemInfo.isMac) { return MacKeymapUtil.getKeyStrokeText(accelerator); } String acceleratorText = ""; int modifiers = accelerator.getModifiers(); if (modifiers > 0) { acceleratorText = getModifiersText(modifiers); } final int code = accelerator.getKeyCode(); String keyText = SystemInfo.isMac ? MacKeymapUtil.getKeyText(code) : KeyEvent.getKeyText(code); // [vova] this is dirty fix for bug #35092 if (CANCEL_KEY_TEXT.equals(keyText)) { keyText = BREAK_KEY_TEXT; } acceleratorText += keyText; return acceleratorText.trim(); }
private int getMnemonicCharIndex(String text) { final int mnemonicIndex = myPresentation.getDisplayedMnemonicIndex(); if (mnemonicIndex != -1) { return mnemonicIndex; } final ShortcutSet shortcutSet = myAction.getShortcutSet(); final Shortcut[] shortcuts = shortcutSet.getShortcuts(); for (Shortcut shortcut : shortcuts) { if (!(shortcut instanceof KeyboardShortcut)) continue; KeyboardShortcut keyboardShortcut = (KeyboardShortcut) shortcut; if (keyboardShortcut.getSecondKeyStroke() == null) { // we are interested only in "mnemonic-like" shortcuts final KeyStroke keyStroke = keyboardShortcut.getFirstKeyStroke(); final int modifiers = keyStroke.getModifiers(); if (BitUtil.isSet(modifiers, InputEvent.ALT_MASK)) { return (keyStroke.getKeyChar() != KeyEvent.CHAR_UNDEFINED) ? text.indexOf(keyStroke.getKeyChar()) : text.indexOf(KeyEvent.getKeyText(keyStroke.getKeyCode())); } } } return -1; }
/** Replaces ctrl- shortcuts with command- shortcuts for OSX */ protected void replaceCtrlShortcutsWithMacShortcuts() { for (Object keyObj : UIManager.getLookAndFeelDefaults().keySet()) { String key = keyObj.toString(); if (key.contains("InputMap")) { // System.out.println("MAP: " + key); Object val = UIManager.getLookAndFeelDefaults().get(key); if (val instanceof InputMapUIResource) { InputMapUIResource map = (InputMapUIResource) val; for (KeyStroke keyStroke : map.allKeys()) { int modifiers = keyStroke.getModifiers(); if ((modifiers & KeyEvent.CTRL_MASK) > 0) { modifiers -= KeyEvent.CTRL_DOWN_MASK; modifiers -= KeyEvent.CTRL_MASK; modifiers += KeyEvent.META_DOWN_MASK + KeyEvent.META_MASK; KeyStroke k = KeyStroke.getKeyStroke(keyStroke.getKeyCode(), modifiers); Object mapVal = map.get(keyStroke); map.remove(keyStroke); map.put(k, mapVal); // System.out.println("Old: " + keyStroke); // System.out.println("New: " + k); } } } } } }
/** * Return a good string representation of the given keystroke, since the toString method returns * more garbage than we want to see in a user interface. */ public static String keyStrokeToString(KeyStroke key) { int modifiers = key.getModifiers(); StringBuffer buffer = new StringBuffer(); if ((modifiers & Event.SHIFT_MASK) == Event.SHIFT_MASK) { buffer.append("(Shift-"); buffer.append(KeyEvent.getKeyText(key.getKeyCode())); buffer.append(")"); } if ((modifiers & Event.CTRL_MASK) == Event.CTRL_MASK) { buffer.append("(Ctrl-"); buffer.append(KeyEvent.getKeyText(key.getKeyCode())); buffer.append(")"); } if ((modifiers & Event.META_MASK) == Event.META_MASK) { buffer.append("(Meta-"); buffer.append(KeyEvent.getKeyText(key.getKeyCode())); buffer.append(")"); } if ((modifiers & Event.ALT_MASK) == Event.ALT_MASK) { buffer.append("(Alt-"); buffer.append(KeyEvent.getKeyText(key.getKeyCode())); buffer.append(")"); } if (modifiers == 0) { buffer.append("("); buffer.append(KeyEvent.getKeyText(key.getKeyCode())); buffer.append(")"); } return buffer.toString(); }
/** * This method is not being used to paint menu item since 6.0 This code left for compatibility * only. Do not use or override it, this will not cause any visible effect. */ public static void paintMenuItem( Graphics g, JComponent c, Icon checkIcon, Icon arrowIcon, Color background, Color foreground, int defaultTextIconGap) { JMenuItem b = (JMenuItem) c; ButtonModel model = b.getModel(); Dimension size = b.getSize(); Insets i = c.getInsets(); Rectangle viewRect = new Rectangle(size); viewRect.x += i.left; viewRect.y += i.top; viewRect.width -= (i.right + viewRect.x); viewRect.height -= (i.bottom + viewRect.y); Rectangle iconRect = new Rectangle(); Rectangle textRect = new Rectangle(); Rectangle acceleratorRect = new Rectangle(); Rectangle checkRect = new Rectangle(); Rectangle arrowRect = new Rectangle(); Font holdf = g.getFont(); Font f = c.getFont(); g.setFont(f); FontMetrics fm = SwingUtilities2.getFontMetrics(c, g, f); FontMetrics fmAccel = SwingUtilities2.getFontMetrics(c, g, UIManager.getFont("MenuItem.acceleratorFont")); if (c.isOpaque()) { if (model.isArmed() || (c instanceof JMenu && model.isSelected())) { g.setColor(background); } else { g.setColor(c.getBackground()); } g.fillRect(0, 0, size.width, size.height); } // get Accelerator text KeyStroke accelerator = b.getAccelerator(); String acceleratorText = ""; if (accelerator != null) { int modifiers = accelerator.getModifiers(); if (modifiers > 0) { acceleratorText = KeyEvent.getKeyModifiersText(modifiers); acceleratorText += "+"; } acceleratorText += KeyEvent.getKeyText(accelerator.getKeyCode()); } // layout the text and icon String text = layoutMenuItem( c, fm, b.getText(), fmAccel, acceleratorText, b.getIcon(), checkIcon, arrowIcon, b.getVerticalAlignment(), b.getHorizontalAlignment(), b.getVerticalTextPosition(), b.getHorizontalTextPosition(), viewRect, iconRect, textRect, acceleratorRect, checkRect, arrowRect, b.getText() == null ? 0 : defaultTextIconGap, defaultTextIconGap); // Paint the Check Color holdc = g.getColor(); if (checkIcon != null) { if (model.isArmed() || (c instanceof JMenu && model.isSelected())) g.setColor(foreground); checkIcon.paintIcon(c, g, checkRect.x, checkRect.y); g.setColor(holdc); } // Paint the Icon if (b.getIcon() != null) { Icon icon; if (!model.isEnabled()) { icon = (Icon) b.getDisabledIcon(); } else if (model.isPressed() && model.isArmed()) { icon = (Icon) b.getPressedIcon(); if (icon == null) { // Use default icon icon = (Icon) b.getIcon(); } } else { icon = (Icon) b.getIcon(); } if (icon != null) { icon.paintIcon(c, g, iconRect.x, iconRect.y); } } // Draw the Text if (text != null && !text.equals("")) { // Once BasicHTML becomes public, use BasicHTML.propertyKey // instead of the hardcoded string below! View v = (View) c.getClientProperty("html"); if (v != null) { v.paint(g, textRect); } else { int mnemIndex = b.getDisplayedMnemonicIndex(); if (!model.isEnabled()) { // *** paint the text disabled g.setColor(b.getBackground().brighter()); SwingUtilities2.drawStringUnderlineCharAt( b, g, text, mnemIndex, textRect.x, textRect.y + fmAccel.getAscent()); g.setColor(b.getBackground().darker()); SwingUtilities2.drawStringUnderlineCharAt( b, g, text, mnemIndex, textRect.x - 1, textRect.y + fmAccel.getAscent() - 1); } else { // *** paint the text normally if (model.isArmed() || (c instanceof JMenu && model.isSelected())) { g.setColor(foreground); } else { g.setColor(b.getForeground()); } SwingUtilities2.drawStringUnderlineCharAt( b, g, text, mnemIndex, textRect.x, textRect.y + fm.getAscent()); } } } // Draw the Accelerator Text if (acceleratorText != null && !acceleratorText.equals("")) { // Get the maxAccWidth from the parent to calculate the offset. int accOffset = 0; Container parent = b.getParent(); if (parent != null && parent instanceof JComponent) { JComponent p = (JComponent) parent; Integer maxValueInt = (Integer) p.getClientProperty(MotifGraphicsUtils.MAX_ACC_WIDTH); int maxValue = maxValueInt != null ? maxValueInt.intValue() : acceleratorRect.width; // Calculate the offset, with which the accelerator texts will be drawn with. accOffset = maxValue - acceleratorRect.width; } g.setFont(UIManager.getFont("MenuItem.acceleratorFont")); if (!model.isEnabled()) { // *** paint the acceleratorText disabled g.setColor(b.getBackground().brighter()); SwingUtilities2.drawString( c, g, acceleratorText, acceleratorRect.x - accOffset, acceleratorRect.y + fm.getAscent()); g.setColor(b.getBackground().darker()); SwingUtilities2.drawString( c, g, acceleratorText, acceleratorRect.x - accOffset - 1, acceleratorRect.y + fm.getAscent() - 1); } else { // *** paint the acceleratorText normally if (model.isArmed() || (c instanceof JMenu && model.isSelected())) { g.setColor(foreground); } else { g.setColor(b.getForeground()); } SwingUtilities2.drawString( c, g, acceleratorText, acceleratorRect.x - accOffset, acceleratorRect.y + fmAccel.getAscent()); } } // Paint the Arrow if (arrowIcon != null) { if (model.isArmed() || (c instanceof JMenu && model.isSelected())) g.setColor(foreground); if (!(b.getParent() instanceof JMenuBar)) arrowIcon.paintIcon(c, g, arrowRect.x, arrowRect.y); } g.setColor(holdc); g.setFont(holdf); }
private static boolean isEnterKeyStroke(KeyStroke keyStroke) { return keyStroke.getKeyCode() == KeyEvent.VK_ENTER && keyStroke.getModifiers() == 0; }
protected ActionCallback _execute(final PlaybackContext context) { final String actionName = getText().substring(PREFIX.length()).trim(); final ActionManager am = ActionManager.getInstance(); final AnAction targetAction = am.getAction(actionName); if (targetAction == null) { dumpError(context, "Unknown action: " + actionName); return new ActionCallback.Rejected(); } if (!context.isUseDirectActionCall()) { final Shortcut[] sc = KeymapManager.getInstance().getActiveKeymap().getShortcuts(actionName); KeyStroke stroke = null; for (Shortcut each : sc) { if (each instanceof KeyboardShortcut) { final KeyboardShortcut ks = (KeyboardShortcut) each; final KeyStroke first = ks.getFirstKeyStroke(); final KeyStroke second = ks.getSecondKeyStroke(); if (first != null && second == null) { stroke = KeyStroke.getKeyStroke(first.getKeyCode(), first.getModifiers(), false); break; } } } if (stroke != null) { final ActionCallback result = new TimedOutCallback( Registry.intValue("actionSystem.commandProcessingTimeout"), "Timed out calling action id=" + actionName, new Throwable(), true) { @Override protected void dumpError() { context.error(getMessage(), getLine()); } }; context.message("Invoking action via shortcut: " + stroke.toString(), getLine()); final KeyStroke finalStroke = stroke; IdeFocusManager.getGlobalInstance() .doWhenFocusSettlesDown( new Runnable() { @Override public void run() { final Ref<AnActionListener> listener = new Ref<AnActionListener>(); listener.set( new AnActionListener.Adapter() { @Override public void beforeActionPerformed( final AnAction action, DataContext dataContext, AnActionEvent event) { SwingUtilities.invokeLater( new Runnable() { @Override public void run() { if (context.isDisposed()) { am.removeAnActionListener(listener.get()); return; } if (targetAction.equals(action)) { context.message( "Performed action: " + actionName, context.getCurrentLine()); am.removeAnActionListener(listener.get()); result.setDone(); } } }); } }); am.addAnActionListener(listener.get()); context.runPooledThread( new Runnable() { @Override public void run() { type(context.getRobot(), finalStroke); } }); } }); return result; } } final InputEvent input = getInputEvent(actionName); final ActionCallback result = new ActionCallback(); context.getRobot().delay(Registry.intValue("actionSystem.playback.delay")); SwingUtilities.invokeLater( new Runnable() { public void run() { am.tryToExecute(targetAction, input, null, null, false) .doWhenProcessed(result.createSetDoneRunnable()); } }); return result; }
/** * This method fills <code>myActions</code> list. * * @return true if there is a shortcut with second stroke found. */ public KeyProcessorContext updateCurrentContext( Component component, Shortcut sc, boolean isModalContext) { myContext.setFoundComponent(null); myContext.getActions().clear(); if (isControlEnterOnDialog(component, sc)) return myContext; boolean hasSecondStroke = false; // here we try to find "local" shortcuts for (; component != null; component = component.getParent()) { if (!(component instanceof JComponent)) { continue; } ArrayList listOfActions = (ArrayList) ((JComponent) component).getClientProperty(AnAction.ourClientProperty); if (listOfActions == null) { continue; } for (Object listOfAction : listOfActions) { if (!(listOfAction instanceof AnAction)) { continue; } AnAction action = (AnAction) listOfAction; hasSecondStroke |= addAction(action, sc); } // once we've found a proper local shortcut(s), we continue with non-local shortcuts if (!myContext.getActions().isEmpty()) { myContext.setFoundComponent((JComponent) component); break; } } // search in main keymap Keymap keymap = KeymapManager.getInstance().getActiveKeymap(); String[] actionIds = keymap.getActionIds(sc); ActionManager actionManager = ActionManager.getInstance(); for (String actionId : actionIds) { AnAction action = actionManager.getAction(actionId); if (action != null) { if (isModalContext && !action.isEnabledInModalContext()) { continue; } hasSecondStroke |= addAction(action, sc); } } if (!hasSecondStroke && sc instanceof KeyboardShortcut) { // little trick to invoke action which second stroke is a key w/o modifiers, but user still // holds the modifier key(s) of the first stroke final KeyboardShortcut keyboardShortcut = (KeyboardShortcut) sc; final KeyStroke firstKeyStroke = keyboardShortcut.getFirstKeyStroke(); final KeyStroke secondKeyStroke = keyboardShortcut.getSecondKeyStroke(); if (secondKeyStroke != null && secondKeyStroke.getModifiers() != 0 && firstKeyStroke.getModifiers() != 0) { final KeyboardShortcut altShortCut = new KeyboardShortcut( firstKeyStroke, KeyStroke.getKeyStroke(secondKeyStroke.getKeyCode(), 0)); final String[] additionalActions = keymap.getActionIds(altShortCut); for (final String actionId : additionalActions) { AnAction action = actionManager.getAction(actionId); if (action != null) { if (isModalContext && !action.isEnabledInModalContext()) { continue; } hasSecondStroke |= addAction(action, altShortCut); } } } } myContext.setHasSecondStroke(hasSecondStroke); Comparator<? super AnAction> comparator = PlatformDataKeys.ACTIONS_SORTER.getData(myContext.getDataContext()); if (comparator != null) { Collections.sort(myContext.getActions(), comparator); } return myContext; }
private void pressInTextArea() { driver.pressAndReleaseKey( textArea, keyStroke.getKeyCode(), new int[] {keyStroke.getModifiers()}); }
public static String formatKeyStroke(final KeyStroke keyStroke) { final String keyModifiersText = KeyEvent.getKeyModifiersText(keyStroke.getModifiers()); final String keyText = KeyEvent.getKeyText(keyStroke.getKeyCode()); return keyModifiersText.length() == 0 ? keyText : keyModifiersText + "+" + keyText; }
public void registerKeyStroke(KeyStroke keyStroke, String description) { String modifiersText = KeyEvent.getKeyModifiersText(keyStroke.getModifiers()); String keyText = KeyEvent.getKeyText(keyStroke.getKeyCode()); keyboardEntries.add( (modifiersText.length() != 0 ? modifiersText + " " : "") + keyText + ": " + description); }
@NotNull public DigraphResult processKey(@NotNull KeyStroke key, @NotNull Editor editor) { switch (digraphState) { 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"); digraphState = DIG_STATE_CODE_START; codeChars = new char[8]; codeCnt = 0; return DigraphResult.OK; } else { return new DigraphResult(key); } case DIG_STATE_DIG_ONE: logger.debug("DIG_STATE_DIG_ONE"); if (key.getKeyChar() != KeyEvent.CHAR_UNDEFINED) { digraphChar = key.getKeyChar(); digraphState = DIG_STATE_DIG_TWO; return DigraphResult.OK; } else { digraphState = DIG_STATE_START; return DigraphResult.BAD; } case DIG_STATE_DIG_TWO: logger.debug("DIG_STATE_DIG_TWO"); digraphState = DIG_STATE_START; if (key.getKeyChar() != KeyEvent.CHAR_UNDEFINED) { char ch = VimPlugin.getDigraph().getDigraph(digraphChar, key.getKeyChar()); return new DigraphResult(KeyStroke.getKeyStroke(ch)); } return DigraphResult.BAD; case DIG_STATE_CODE_START: logger.debug("DIG_STATE_CODE_START"); switch (key.getKeyChar()) { case 'o': case 'O': codeMax = 3; digraphState = DIG_STATE_CODE_CHAR; codeType = 8; logger.debug("Octal"); return DigraphResult.OK; case 'x': case 'X': codeMax = 2; digraphState = DIG_STATE_CODE_CHAR; codeType = 16; logger.debug("hex2"); return DigraphResult.OK; case 'u': codeMax = 4; digraphState = DIG_STATE_CODE_CHAR; codeType = 16; logger.debug("hex4"); return DigraphResult.OK; case 'U': codeMax = 8; digraphState = DIG_STATE_CODE_CHAR; codeType = 16; logger.debug("hex8"); return DigraphResult.OK; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': codeMax = 3; digraphState = DIG_STATE_CODE_CHAR; codeType = 10; codeChars[codeCnt++] = key.getKeyChar(); logger.debug("decimal"); return DigraphResult.OK; default: switch (key.getKeyCode()) { case KeyEvent.VK_TAB: KeyStroke code = KeyStroke.getKeyStroke('\t'); digraphState = DIG_STATE_START; return new DigraphResult(code); default: logger.debug("unknown"); digraphState = DIG_STATE_START; return new DigraphResult(key); } } case DIG_STATE_CODE_CHAR: logger.debug("DIG_STATE_CODE_CHAR"); boolean valid = false; switch (codeType) { case 10: if (key.getKeyChar() >= '0' && key.getKeyChar() <= '9') { valid = true; } break; case 8: if (key.getKeyChar() >= '0' && key.getKeyChar() <= '7') { valid = true; } break; case 16: if (key.getKeyChar() >= '0' && key.getKeyChar() <= '9' || key.getKeyChar() >= 'a' && key.getKeyChar() <= 'f' || key.getKeyChar() >= 'A' && key.getKeyChar() <= 'F') { valid = true; } break; } if (valid) { logger.debug("valid"); codeChars[codeCnt++] = key.getKeyChar(); if (codeCnt == codeMax) { String digits = new String(codeChars, 0, codeCnt); int val = Integer.parseInt(digits, codeType); KeyStroke code = KeyStroke.getKeyStroke((char) val); digraphState = DIG_STATE_START; return new DigraphResult(code); } else { return DigraphResult.OK; } } else if (codeCnt > 0) { logger.debug("invalid"); String digits = new String(codeChars, 0, codeCnt); int val = Integer.parseInt(digits, codeType); digraphState = DIG_STATE_START; KeyStroke code = KeyStroke.getKeyStroke((char) val); VimPlugin.getMacro().postKey(key, editor); return new DigraphResult(code); } else { return DigraphResult.BAD; } default: return DigraphResult.BAD; } }
private static boolean isControlKeyCode(@NotNull KeyStroke key) { return key.getKeyChar() == CHAR_UNDEFINED && key.getKeyCode() < 0x20 && key.getModifiers() == 0; }