下面列出了java.awt.event.KeyEvent#isConsumed() 实例代码,或者点击链接到github查看源代码,也可以在右侧发表评论。
public void processKeyTyped(KeyEvent keyEvent)
{
if (keyEvent.isConsumed())
{
return;
}
for (KeyListener keyListener : keyListeners)
{
if (!shouldProcess(keyListener))
{
continue;
}
keyListener.keyTyped(keyEvent);
if (keyEvent.isConsumed())
{
break;
}
}
}
@Override
public void keyTyped(KeyEvent event) {
if (!event.isConsumed() && (event.getModifiersEx() & getToolkit().getMenuShortcutKeyMaskEx()) == 0) {
char ch = event.getKeyChar();
switch (ch) {
case '-':
zoomOut();
break;
case '=':
zoomIn();
break;
case '1':
actualSize();
break;
default:
return;
}
event.consume();
}
}
@Override
public void keyTyped(KeyEvent event) {
if (!event.isConsumed() && (event.getModifiersEx() & getToolkit().getMenuShortcutKeyMaskEx()) == 0) {
char ch = event.getKeyChar();
if (ch == '\n' || ch == '\r') {
if (mModel.hasSelection()) {
notifyActionListeners();
}
event.consume();
} else if (ch == '\b' || ch == KeyEvent.VK_DELETE) {
if (canDeleteSelection()) {
deleteSelection();
}
event.consume();
}
}
}
/**
* @param event the specified key event to process
* @param extended {@code true} if extended key code should be used
* @return a key stroke or {@code null} if it is not applicable
* @see JComponent#processKeyBindings(KeyEvent, boolean)
*/
public static KeyStroke getKeyStroke(KeyEvent event, boolean extended) {
if (event != null && !event.isConsumed()) {
int id = event.getID();
if (id == KeyEvent.KEY_TYPED) {
return extended ? null : getKeyStroke(event.getKeyChar(), 0);
}
boolean released = id == KeyEvent.KEY_RELEASED;
if (released || id == KeyEvent.KEY_PRESSED) {
int code = event.getKeyCode();
if (extended) {
if (Registry.is("actionSystem.extendedKeyCode.disabled")) {
return null;
}
code = getExtendedKeyCode(event);
if (code == event.getKeyCode()) {
return null;
}
}
return getKeyStroke(code, event.getModifiers(), released);
}
}
return null;
}
public boolean postProcessKeyEvent(KeyEvent ev) {
if(ev.isConsumed()) {
// do not manage consumed event
return false;
}
if (ev.getKeyCode() == KeyEvent.VK_ALT) {
root = SwingUtilities.getRootPane(ev.getComponent());
winAncestor = (root == null ? null :
SwingUtilities.getWindowAncestor(root));
if (ev.getID() == KeyEvent.KEY_PRESSED) {
if (!altKeyPressed) {
altPressed(ev);
}
altKeyPressed = true;
return true;
} else if (ev.getID() == KeyEvent.KEY_RELEASED) {
if (altKeyPressed) {
altReleased(ev);
} else {
MenuSelectionManager msm =
MenuSelectionManager.defaultManager();
MenuElement[] path = msm.getSelectedPath();
if (path.length <= 0) {
WindowsLookAndFeel.setMnemonicHidden(true);
WindowsGraphicsUtils.repaintMnemonicsInWindow(winAncestor);
}
}
altKeyPressed = false;
}
root = null;
winAncestor = null;
} else {
altKeyPressed = false;
}
return false;
}
public boolean postProcessKeyEvent(KeyEvent ev) {
if(ev.isConsumed()) {
// do not manage consumed event
return false;
}
if (ev.getKeyCode() == KeyEvent.VK_ALT) {
root = SwingUtilities.getRootPane(ev.getComponent());
winAncestor = (root == null ? null :
SwingUtilities.getWindowAncestor(root));
if (ev.getID() == KeyEvent.KEY_PRESSED) {
if (!altKeyPressed) {
altPressed(ev);
}
altKeyPressed = true;
return true;
} else if (ev.getID() == KeyEvent.KEY_RELEASED) {
if (altKeyPressed) {
altReleased(ev);
} else {
MenuSelectionManager msm =
MenuSelectionManager.defaultManager();
MenuElement[] path = msm.getSelectedPath();
if (path.length <= 0) {
WindowsLookAndFeel.setMnemonicHidden(true);
WindowsGraphicsUtils.repaintMnemonicsInWindow(winAncestor);
}
}
altKeyPressed = false;
}
root = null;
winAncestor = null;
} else {
altKeyPressed = false;
}
return false;
}
public void processKeyEvent(KeyEvent evt) {
for (CompletionLayoutPopup popup : visiblePopups) {
popup.processKeyEvent(evt);
if (evt.isConsumed())
return;
}
}
public boolean postProcessKeyEvent(KeyEvent ev) {
if(ev.isConsumed()) {
// do not manage consumed event
return false;
}
if (ev.getKeyCode() == KeyEvent.VK_ALT) {
root = SwingUtilities.getRootPane(ev.getComponent());
winAncestor = (root == null ? null :
SwingUtilities.getWindowAncestor(root));
if (ev.getID() == KeyEvent.KEY_PRESSED) {
if (!altKeyPressed) {
altPressed(ev);
}
altKeyPressed = true;
return true;
} else if (ev.getID() == KeyEvent.KEY_RELEASED) {
if (altKeyPressed) {
altReleased(ev);
} else {
MenuSelectionManager msm =
MenuSelectionManager.defaultManager();
MenuElement[] path = msm.getSelectedPath();
if (path.length <= 0) {
WindowsLookAndFeel.setMnemonicHidden(true);
WindowsGraphicsUtils.repaintMnemonicsInWindow(winAncestor);
}
}
altKeyPressed = false;
}
root = null;
winAncestor = null;
} else {
altKeyPressed = false;
}
return false;
}
private boolean redirectKeyEventToFloater(KeyEvent event) {
if (mFloater != null && !event.isConsumed() && (event.getModifiersEx() & getToolkit().getMenuShortcutKeyMaskEx()) == 0) {
int keyCode = event.getKeyCode();
if (keyCode == KeyEvent.VK_UP || keyCode == KeyEvent.VK_DOWN) {
mFloater.handleKeyPressed(event);
return true;
}
}
return false;
}
public void processKeyEvent(@Nonnull KeyEvent e) {
if (e.isConsumed()) return;
if (e.getID() != KeyEvent.KEY_TYPED) return;
if (!StringUtil.isEmptyOrSpaces(myPopup.getSpeedSearch().getFilter())) return;
if (Character.isLetterOrDigit(e.getKeyChar())) {
final String s = Character.toString(e.getKeyChar());
final T toSelect = myChar2ValueMap.get(s);
if (toSelect != null) {
select(toSelect);
e.consume();
}
}
}
/**
* This method will be called by <code>dispatchKeyEvent</code>. It will
* handle any unconsumed KeyEvents that map to an AWT
* <code>MenuShortcut</code> by consuming the event and activating the
* shortcut.
*
* @param e the KeyEvent to post-process
* @return <code>true</code>
* @see #dispatchKeyEvent
* @see MenuShortcut
*/
public boolean postProcessKeyEvent(KeyEvent e) {
if (!e.isConsumed()) {
Component target = e.getComponent();
Container p = (Container)
(target instanceof Container ? target : target.getParent());
if (p != null) {
p.postProcessKeyEvent(e);
}
}
return true;
}
protected void fireNotificationNonConsumedKeyEvent(@Nonnull final KeyEvent keyEvent, @Nonnull final KeyEventType type) {
for (final MindMapListener l : MindMapPanel.this.mindMapListeners) {
if (keyEvent.isConsumed()) {
break;
}
l.onNonConsumedKeyEvent(MindMapPanel.this, keyEvent, type);
}
}
@Override
public void keyReleased(final KeyEvent e) {
for (final KeyListener kl : listeners) {
if (e.isConsumed())
break;
kl.keyReleased(e);
}
}
@Override
protected final boolean processKeyBinding(KeyStroke ks, KeyEvent e, int condition, boolean pressed) {
if (condition == WHEN_FOCUSED && myCurrentEvent != e) {
try {
myCurrentEvent = e;
myComponent.dispatchEvent(e);
}
finally {
myCurrentEvent = null;
}
}
if (e.isConsumed()) return true;
return super.processKeyBinding(ks, e, condition, pressed);
}
@Override
public void keyPressed(final KeyEvent ke) {
if (isTagging()) {
super.keyPressed(ke);
return;
}
final int tool = ProjectToolbar.getToolId();
try {
if (ProjectToolbar.PEN == tool) {
final Object origin = ke.getSource();
if (! (origin instanceof DisplayCanvas)) {
ke.consume();
return;
}
final DisplayCanvas dc = (DisplayCanvas)origin;
final Layer layer = dc.getDisplay().getLayer();
final Point p = dc.getCursorLoc(); // as offscreen coords
switch (ke.getKeyCode()) {
case KeyEvent.VK_O:
if (askAdjustRadius(p.x, p.y, layer, dc.getMagnification())) {
ke.consume();
}
break;
}
}
} finally {
if (!ke.isConsumed()) {
super.keyPressed(ke);
}
}
}
/**
* This method initiates a focus traversal operation if and only if the
* KeyEvent represents a focus traversal key for the specified
* focusedComponent. It is expected that focusedComponent is the current
* focus owner, although this need not be the case. If it is not,
* focus traversal will nevertheless proceed as if focusedComponent
* were the focus owner.
*
* @param focusedComponent the Component that is the basis for a focus
* traversal operation if the specified event represents a focus
* traversal key for the Component
* @param e the event that may represent a focus traversal key
*/
public void processKeyEvent(Component focusedComponent, KeyEvent e) {
// consume processed event if needed
if (consumeProcessedKeyEvent(e)) {
return;
}
// KEY_TYPED events cannot be focus traversal keys
if (e.getID() == KeyEvent.KEY_TYPED) {
return;
}
if (focusedComponent.getFocusTraversalKeysEnabled() &&
!e.isConsumed())
{
AWTKeyStroke stroke = AWTKeyStroke.getAWTKeyStrokeForEvent(e),
oppStroke = AWTKeyStroke.getAWTKeyStroke(stroke.getKeyCode(),
stroke.getModifiers(),
!stroke.isOnKeyRelease());
Set<AWTKeyStroke> toTest;
boolean contains, containsOpp;
toTest = focusedComponent.getFocusTraversalKeys(
KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS);
contains = toTest.contains(stroke);
containsOpp = toTest.contains(oppStroke);
if (contains || containsOpp) {
consumeTraversalKey(e);
if (contains) {
focusNextComponent(focusedComponent);
}
return;
} else if (e.getID() == KeyEvent.KEY_PRESSED) {
// Fix for 6637607: consumeNextKeyTyped should be reset.
consumeNextKeyTyped = false;
}
toTest = focusedComponent.getFocusTraversalKeys(
KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS);
contains = toTest.contains(stroke);
containsOpp = toTest.contains(oppStroke);
if (contains || containsOpp) {
consumeTraversalKey(e);
if (contains) {
focusPreviousComponent(focusedComponent);
}
return;
}
toTest = focusedComponent.getFocusTraversalKeys(
KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS);
contains = toTest.contains(stroke);
containsOpp = toTest.contains(oppStroke);
if (contains || containsOpp) {
consumeTraversalKey(e);
if (contains) {
upFocusCycle(focusedComponent);
}
return;
}
if (!((focusedComponent instanceof Container) &&
((Container)focusedComponent).isFocusCycleRoot())) {
return;
}
toTest = focusedComponent.getFocusTraversalKeys(
KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYS);
contains = toTest.contains(stroke);
containsOpp = toTest.contains(oppStroke);
if (contains || containsOpp) {
consumeTraversalKey(e);
if (contains) {
downFocusCycle((Container)focusedComponent);
}
}
}
}
/**
* Called by <code>dispatchEvent</code> if no other
* KeyEventDispatcher in the dispatcher chain dispatched the KeyEvent, or
* if no other KeyEventDispatchers are registered. If the event has not
* been consumed, its target is enabled, and the focus owner is not null,
* this method dispatches the event to its target. This method will also
* subsequently dispatch the event to all registered
* KeyEventPostProcessors. After all this operations are finished,
* the event is passed to peers for processing.
* <p>
* In all cases, this method returns <code>true</code>, since
* DefaultKeyboardFocusManager is designed so that neither
* <code>dispatchEvent</code>, nor the AWT event dispatcher, should take
* further action on the event in any situation.
*
* @param e the KeyEvent to be dispatched
* @return <code>true</code>
* @see Component#dispatchEvent
*/
public boolean dispatchKeyEvent(KeyEvent e) {
Component focusOwner = (((AWTEvent)e).isPosted) ? getFocusOwner() : e.getComponent();
if (focusOwner != null && focusOwner.isShowing() && focusOwner.canBeFocusOwner()) {
if (!e.isConsumed()) {
Component comp = e.getComponent();
if (comp != null && comp.isEnabled()) {
redispatchEvent(comp, e);
}
}
}
boolean stopPostProcessing = false;
java.util.List<KeyEventPostProcessor> processors = getKeyEventPostProcessors();
if (processors != null) {
for (java.util.Iterator<KeyEventPostProcessor> iter = processors.iterator();
!stopPostProcessing && iter.hasNext(); )
{
stopPostProcessing = iter.next().
postProcessKeyEvent(e);
}
}
if (!stopPostProcessing) {
postProcessKeyEvent(e);
}
// Allow the peer to process KeyEvent
Component source = e.getComponent();
ComponentPeer peer = source.getPeer();
if (peer == null || peer instanceof LightweightPeer) {
// if focus owner is lightweight then its native container
// processes event
Container target = source.getNativeContainer();
if (target != null) {
peer = target.getPeer();
}
}
if (peer != null) {
peer.handleEvent(e);
}
return true;
}
@Override
public void keyPressed(final KeyEvent ke) {
super.keyPressed(ke);
if (ke.isConsumed()) return;
if (!ke.getSource().equals(ProjectTree.this) || !project.isInputEnabled()) {
return;
}
// get the first selected node only
TreePath path = getSelectionPath();
if (null == path) return;
DefaultMutableTreeNode node = (DefaultMutableTreeNode)path.getLastPathComponent();
if (null == node) return;
final ProjectThing pt = (ProjectThing)node.getUserObject();
if (null == pt) return;
//
final int flags = ke.getModifiers();
switch (ke.getKeyCode()) {
case KeyEvent.VK_PAGE_UP:
move(node, -1);
ke.consume(); // in any case
break;
case KeyEvent.VK_PAGE_DOWN:
move(node, 1);
ke.consume(); // in any case
break;
case KeyEvent.VK_F2:
rename(pt);
ke.consume();
break;
case KeyEvent.VK_H:
if (0 == (flags ^ Event.ALT_MASK)) {
pt.setVisible(true);
ke.consume();
} else if (0 == flags) {
pt.setVisible(false);
ke.consume();
}
break;
case KeyEvent.VK_A:
if (0 == flags || (0 == (flags ^ Event.SHIFT_MASK))) {
selectInDisplay(pt, 0 == (flags ^ Event.SHIFT_MASK));
ke.consume();
}
break;
case KeyEvent.VK_3:
if (0 == flags) {
ini.trakem2.display.Display3D.showAndResetView(pt);
ke.consume();
break;
}
// else, flow:
case KeyEvent.VK_1:
case KeyEvent.VK_2:
case KeyEvent.VK_4:
case KeyEvent.VK_5:
case KeyEvent.VK_6:
case KeyEvent.VK_7:
case KeyEvent.VK_8:
case KeyEvent.VK_9:
// run a plugin, if any
if (pt.getObject() instanceof Displayable && null != Utils.launchTPlugIn(ke, "Project Tree", project, (Displayable)pt.getObject())) {
ke.consume();
}
break;
}
ke.consume();
}
protected @Override boolean processKeyBinding(KeyStroke ks,
KeyEvent e,
int condition,
boolean pressed) {
if (Utilities.isMac()) {
int mods = e.getModifiers();
boolean isCtrl = (mods & KeyEvent.CTRL_MASK) != 0;
boolean isAlt = (mods & KeyEvent.ALT_MASK) != 0;
if (isAlt && (e instanceof MarkedKeyEvent)) {
mods = mods & ~ KeyEvent.CTRL_MASK;
mods = mods & ~ KeyEvent.CTRL_DOWN_MASK;
mods |= KeyEvent.ALT_MASK;
mods |= KeyEvent.ALT_DOWN_MASK;
KeyEvent newEvent = new MarkedKeyEvent (
(Component) e.getSource(), e.getID(),
e.getWhen(), mods, e.getKeyCode(), e.getKeyChar(),
e.getKeyLocation());
KeyStroke newStroke = null;
if( null != ks ) {
newStroke = e.getID() == KeyEvent.KEY_TYPED ?
KeyStroke.getKeyStroke (ks.getKeyChar(), mods) :
KeyStroke.getKeyStroke (ks.getKeyCode(), mods,
!ks.isOnKeyRelease());
}
boolean result = super.processKeyBinding (newStroke,
newEvent, condition, pressed);
if (newEvent.isConsumed()) {
e.consume();
}
return result;
} else if (!isAlt) {
return super.processKeyBinding (ks, e, condition, pressed);
} else {
return false;
}
} else {
return super.processKeyBinding (ks, e, condition, pressed);
}
}
/** Overridden to allow standard keybinding processing of VK_TAB and
* abort any pending drag operation on the vertical grid. */
public void processKeyEvent(KeyEvent e) {
if (dragListener.isArmed()) {
dragListener.setArmed(false);
}
boolean suppressDefaultHandling = ((searchField != null) && searchField.isShowing()) &&
((e.getKeyCode() == KeyEvent.VK_UP) || (e.getKeyCode() == KeyEvent.VK_DOWN));
//Manually hook in the bindings for tab - does not seem to get called
//automatically
if (e.getKeyCode() != KeyEvent.VK_TAB) {
if (!suppressDefaultHandling) {
//Either the search field or the table should handle up/down, not both
super.processKeyEvent(e);
}
if (!e.isConsumed()) {
if ((e.getID() == KeyEvent.KEY_PRESSED) && !isEditing()) {
int modifiers = e.getModifiers();
int keyCode = e.getKeyCode();
if (((modifiers > 0) && (modifiers != KeyEvent.SHIFT_MASK)) || e.isActionKey()) {
return;
}
char c = e.getKeyChar();
if (!Character.isISOControl(c) && (keyCode != KeyEvent.VK_SHIFT) &&
(keyCode != KeyEvent.VK_ESCAPE)) {
searchArmed = true;
e.consume();
}
} else if (searchArmed && (e.getID() == KeyEvent.KEY_TYPED)) {
passToSearchField(e);
e.consume();
searchArmed = false;
} else {
searchArmed = false;
}
}
} else {
processKeyBinding(
KeyStroke.getKeyStroke(e.VK_TAB, e.getModifiersEx(), e.getID() == e.KEY_RELEASED), e,
JComponent.WHEN_FOCUSED, e.getID() == e.KEY_PRESSED
);
}
}