KeyEventDispatcher
, KeyEventPostProcessor
DefaultKeyboardFocusManager
public abstract class KeyboardFocusManager extends Object implements KeyEventDispatcher, KeyEventPostProcessor
The KeyboardFocusManager is both a centralized location for client code to query for the focus owner and initiate focus changes, and an event dispatcher for all FocusEvents, WindowEvents related to focus, and KeyEvents.
Some browsers partition applets in different code bases into separate contexts, and establish walls between these contexts. In such a scenario, there will be one KeyboardFocusManager per context. Other browsers place all applets into the same context, implying that there will be only a single, global KeyboardFocusManager for all applets. This behavior is implementation-dependent. Consult your browser's documentation for more information. No matter how many contexts there may be, however, there can never be more than one focus owner, focused Window, or active Window, per ClassLoader.
Please see How to Use the Focus Subsystem, a section in The Java Tutorial, and the Focus Specification for more information.
Modifier and Type | Field | Description |
---|---|---|
static final int |
BACKWARD_TRAVERSAL_KEYS |
The identifier for the Backward focus traversal keys. |
static final int |
DOWN_CYCLE_TRAVERSAL_KEYS |
The identifier for the Down Cycle focus traversal keys. |
static final int |
FORWARD_TRAVERSAL_KEYS |
The identifier for the Forward focus traversal keys. |
static final int |
UP_CYCLE_TRAVERSAL_KEYS |
The identifier for the Up Cycle focus traversal keys. |
Constructor | Description |
---|---|
KeyboardFocusManager() |
Initializes a KeyboardFocusManager. |
Modifier and Type | Method | Description |
---|---|---|
void |
addKeyEventDispatcher |
Adds a KeyEventDispatcher to this KeyboardFocusManager's dispatcher chain. |
void |
addKeyEventPostProcessor |
Adds a KeyEventPostProcessor to this KeyboardFocusManager's post- processor chain. |
void |
addPropertyChangeListener |
Adds a PropertyChangeListener to the listener list. |
void |
addPropertyChangeListener |
Adds a PropertyChangeListener to the listener list for a specific property. |
void |
addVetoableChangeListener |
Adds a VetoableChangeListener to the listener list. |
void |
addVetoableChangeListener |
Adds a VetoableChangeListener to the listener list for a specific property. |
void |
clearFocusOwner() |
Clears the focus owner at both the Java and native levels if the focus owner exists and resides in the same context as the calling thread, otherwise the method returns silently. |
void |
clearGlobalFocusOwner() |
Clears the global focus owner at both the Java and native levels. |
protected abstract void |
dequeueKeyEvents |
Called by the AWT to notify the KeyboardFocusManager that it should cancel delayed dispatching of KeyEvents. |
protected abstract void |
discardKeyEvents |
Called by the AWT to notify the KeyboardFocusManager that it should cancel delayed dispatching of KeyEvents. |
abstract boolean |
dispatchEvent |
This method is called by the AWT event dispatcher requesting that the current KeyboardFocusManager dispatch the specified event on its behalf. |
abstract boolean |
dispatchKeyEvent |
Typically this method will be called by dispatchEvent if no other KeyEventDispatcher in the dispatcher chain dispatched the KeyEvent, or if no other KeyEventDispatchers are registered. |
final void |
downFocusCycle() |
Moves the focus down one focus traversal cycle from the current focus owner, if and only if the current focus owner is a Container that is a focus cycle root. |
abstract void |
downFocusCycle |
Moves the focus down one focus traversal cycle. |
protected abstract void |
enqueueKeyEvents |
Called by the AWT to notify the KeyboardFocusManager that it should delay dispatching of KeyEvents until the specified Component becomes the focus owner. |
protected void |
firePropertyChange |
Fires a PropertyChangeEvent in response to a change in a bound property. |
protected void |
fireVetoableChange |
Fires a PropertyChangeEvent in response to a change in a vetoable property. |
final void |
focusNextComponent() |
Focuses the Component after the current focus owner. |
abstract void |
focusNextComponent |
Focuses the Component after aComponent, typically based on a FocusTraversalPolicy. |
final void |
focusPreviousComponent() |
Focuses the Component before the current focus owner. |
abstract void |
focusPreviousComponent |
Focuses the Component before aComponent, typically based on a FocusTraversalPolicy. |
Window |
getActiveWindow() |
Returns the active Window, if the active Window is in the same context as the calling thread. |
Container |
getCurrentFocusCycleRoot() |
Returns the current focus cycle root, if the current focus cycle root is in the same context as the calling thread. |
static KeyboardFocusManager |
getCurrentKeyboardFocusManager() |
Returns the current KeyboardFocusManager instance for the calling thread's context. |
Set |
getDefaultFocusTraversalKeys |
Returns a Set of default focus traversal keys for a given traversal operation. |
FocusTraversalPolicy |
getDefaultFocusTraversalPolicy() |
Returns the default FocusTraversalPolicy. |
Window |
getFocusedWindow() |
Returns the focused Window, if the focused Window is in the same context as the calling thread. |
Component |
getFocusOwner() |
Returns the focus owner, if the focus owner is in the same context as the calling thread. |
protected Window |
getGlobalActiveWindow() |
Returns the active Window, even if the calling thread is in a different context than the active Window. |
protected Container |
getGlobalCurrentFocusCycleRoot() |
Returns the current focus cycle root, even if the calling thread is in a different context than the current focus cycle root. |
protected Window |
getGlobalFocusedWindow() |
Returns the focused Window, even if the calling thread is in a different context than the focused Window. |
protected Component |
getGlobalFocusOwner() |
Returns the focus owner, even if the calling thread is in a different context than the focus owner. |
protected Component |
getGlobalPermanentFocusOwner() |
Returns the permanent focus owner, even if the calling thread is in a different context than the permanent focus owner. |
protected List |
getKeyEventDispatchers() |
Returns this KeyboardFocusManager's KeyEventDispatcher chain as a List. |
protected List |
getKeyEventPostProcessors() |
Returns this KeyboardFocusManager's KeyEventPostProcessor chain as a List. |
Component |
getPermanentFocusOwner() |
Returns the permanent focus owner, if the permanent focus owner is in the same context as the calling thread. |
PropertyChangeListener[] |
getPropertyChangeListeners() |
Returns an array of all the property change listeners registered on this keyboard focus manager. |
PropertyChangeListener[] |
getPropertyChangeListeners |
Returns an array of all the PropertyChangeListener s associated with the named property. |
VetoableChangeListener[] |
getVetoableChangeListeners() |
Returns an array of all the vetoable change listeners registered on this keyboard focus manager. |
VetoableChangeListener[] |
getVetoableChangeListeners |
Returns an array of all the VetoableChangeListener s associated with the named property. |
abstract boolean |
postProcessKeyEvent |
This method will be called by dispatchKeyEvent . |
abstract void |
processKeyEvent |
This method initiates a focus traversal operation if and only if the KeyEvent represents a focus traversal key for the specified focusedComponent. |
final void |
redispatchEvent |
Redispatches an AWTEvent in such a way that the AWT event dispatcher will not recursively request that the KeyboardFocusManager, or any installed KeyEventDispatchers, dispatch the event again. |
void |
removeKeyEventDispatcher |
Removes a KeyEventDispatcher which was previously added to this KeyboardFocusManager's dispatcher chain. |
void |
removeKeyEventPostProcessor |
Removes a previously added KeyEventPostProcessor from this KeyboardFocusManager's post-processor chain. |
void |
removePropertyChangeListener |
Removes a PropertyChangeListener from the listener list. |
void |
removePropertyChangeListener |
Removes a PropertyChangeListener from the listener list for a specific property. |
void |
removeVetoableChangeListener |
Removes a VetoableChangeListener from the listener list. |
void |
removeVetoableChangeListener |
Removes a VetoableChangeListener from the listener list for a specific property. |
static void |
setCurrentKeyboardFocusManager |
Sets the current KeyboardFocusManager instance for the calling thread's context. |
void |
setDefaultFocusTraversalKeys |
Sets the default focus traversal keys for a given traversal operation. |
void |
setDefaultFocusTraversalPolicy |
Sets the default FocusTraversalPolicy. |
protected void |
setGlobalActiveWindow |
Sets the active Window. |
void |
setGlobalCurrentFocusCycleRoot |
Sets the current focus cycle root. |
protected void |
setGlobalFocusedWindow |
Sets the focused Window. |
protected void |
setGlobalFocusOwner |
Sets the focus owner. |
protected void |
setGlobalPermanentFocusOwner |
Sets the permanent focus owner. |
final void |
upFocusCycle() |
Moves the focus up one focus traversal cycle from the current focus owner. |
abstract void |
upFocusCycle |
Moves the focus up one focus traversal cycle. |
public static final int FORWARD_TRAVERSAL_KEYS
public static final int BACKWARD_TRAVERSAL_KEYS
public static final int UP_CYCLE_TRAVERSAL_KEYS
public static final int DOWN_CYCLE_TRAVERSAL_KEYS
public KeyboardFocusManager()
public static KeyboardFocusManager getCurrentKeyboardFocusManager()
public static void setCurrentKeyboardFocusManager(KeyboardFocusManager newManager) throws SecurityException
If a SecurityManager is installed, the calling thread must be granted the AWTPermission "replaceKeyboardFocusManager" in order to replace the the current KeyboardFocusManager. If this permission is not granted, this method will throw a SecurityException, and the current KeyboardFocusManager will be unchanged.
newManager
- the new KeyboardFocusManager for this thread's contextSecurityException
- if the calling thread does not have permission to replace the current KeyboardFocusManagerpublic Component getFocusOwner()
protected Component getGlobalFocusOwner() throws SecurityException
This method will throw a SecurityException if this KeyboardFocusManager is not the current KeyboardFocusManager for the calling thread's context.
SecurityException
- if this KeyboardFocusManager is not the current KeyboardFocusManager for the calling thread's context and if the calling thread does not have "replaceKeyboardFocusManager" permissionprotected void setGlobalFocusOwner(Component focusOwner) throws SecurityException
This method does not actually set the focus to the specified Component. It merely stores the value to be subsequently returned by getFocusOwner()
. Use Component.requestFocus()
or Component.requestFocusInWindow()
to change the focus owner, subject to platform limitations.
focusOwner
- the focus ownerSecurityException
- if this KeyboardFocusManager is not the current KeyboardFocusManager for the calling thread's context and if the calling thread does not have "replaceKeyboardFocusManager" permissionpublic void clearFocusOwner()
The focus owner component will receive a permanent FOCUS_LOST event. After this operation completes, the native windowing system will discard all user-generated KeyEvents until the user selects a new Component to receive focus, or a Component is given focus explicitly via a call to requestFocus()
. This operation does not change the focused or active Windows.
public void clearGlobalFocusOwner() throws SecurityException
requestFocus()
. This operation does not change the focused or active Windows. If a SecurityManager is installed, the calling thread must be granted the "replaceKeyboardFocusManager" AWTPermission. If this permission is not granted, this method will throw a SecurityException, and the current focus owner will not be cleared.
This method is intended to be used only by KeyboardFocusManager set as current KeyboardFocusManager for the calling thread's context. It is not for general client use.
SecurityException
- if the calling thread does not have "replaceKeyboardFocusManager" permissionpublic Component getPermanentFocusOwner()
protected Component getGlobalPermanentFocusOwner() throws SecurityException
SecurityException
- if this KeyboardFocusManager is not the current KeyboardFocusManager for the calling thread's context and if the calling thread does not have "replaceKeyboardFocusManager" permissionprotected void setGlobalPermanentFocusOwner(Component permanentFocusOwner) throws SecurityException
This method does not actually set the focus to the specified Component. It merely stores the value to be subsequently returned by getPermanentFocusOwner()
. Use Component.requestFocus()
or Component.requestFocusInWindow()
to change the focus owner, subject to platform limitations.
permanentFocusOwner
- the permanent focus ownerSecurityException
- if this KeyboardFocusManager is not the current KeyboardFocusManager for the calling thread's context and if the calling thread does not have "replaceKeyboardFocusManager" permissionpublic Window getFocusedWindow()
protected Window getGlobalFocusedWindow() throws SecurityException
SecurityException
- if this KeyboardFocusManager is not the current KeyboardFocusManager for the calling thread's context and if the calling thread does not have "replaceKeyboardFocusManager" permissionprotected void setGlobalFocusedWindow(Window focusedWindow) throws SecurityException
This method does not actually change the focused Window as far as the native windowing system is concerned. It merely stores the value to be subsequently returned by getFocusedWindow()
. Use Component.requestFocus()
or Component.requestFocusInWindow()
to change the focused Window, subject to platform limitations.
focusedWindow
- the focused WindowSecurityException
- if this KeyboardFocusManager is not the current KeyboardFocusManager for the calling thread's context and if the calling thread does not have "replaceKeyboardFocusManager" permissionpublic Window getActiveWindow()
protected Window getGlobalActiveWindow() throws SecurityException
SecurityException
- if this KeyboardFocusManager is not the current KeyboardFocusManager for the calling thread's context and if the calling thread does not have "replaceKeyboardFocusManager" permissionprotected void setGlobalActiveWindow(Window activeWindow) throws SecurityException
This method does not actually change the active Window as far as the native windowing system is concerned. It merely stores the value to be subsequently returned by getActiveWindow()
. Use Component.requestFocus()
or Component.requestFocusInWindow()
to change the active Window, subject to platform limitations.
activeWindow
- the active WindowSecurityException
- if this KeyboardFocusManager is not the current KeyboardFocusManager for the calling thread's context and if the calling thread does not have "replaceKeyboardFocusManager" permissionpublic FocusTraversalPolicy getDefaultFocusTraversalPolicy()
public void setDefaultFocusTraversalPolicy(FocusTraversalPolicy defaultPolicy)
defaultPolicy
- the new, default FocusTraversalPolicyIllegalArgumentException
- if defaultPolicy is nullpublic void setDefaultFocusTraversalKeys(int id, Set<? extends AWTKeyStroke> keystrokes)
Set
will be in effect on all Window
s that have no such Set
of their own explicitly defined. This Set
will also be inherited, recursively, by any child Component
of those Windows
that has no such Set
of its own explicitly defined. The default values for the default focus traversal keys are implementation-dependent. Sun recommends that all implementations for a particular native platform use the same default values. The recommendations for Windows and Unix are listed below. These recommendations are used in the Sun AWT implementations.
Identifier | Meaning | Default |
---|---|---|
KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS |
Normal forward keyboard traversal |
TAB on KEY_PRESSED , CTRL-TAB on KEY_PRESSED |
KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS |
Normal reverse keyboard traversal |
SHIFT-TAB on KEY_PRESSED , CTRL-SHIFT-TAB on KEY_PRESSED |
KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS |
Go up one focus traversal cycle | none |
KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYS |
Go down one focus traversal cycle | none |
Set
; Collections.EMPTY_SET
is recommended. Using the AWTKeyStroke
API, client code can specify on which of two specific KeyEvent
s, KEY_PRESSED
or KEY_RELEASED
, the focus traversal operation will occur. Regardless of which KeyEvent
is specified, however, all KeyEvent
s related to the focus traversal key, including the associated KEY_TYPED
event, will be consumed, and will not be dispatched to any Component
. It is a runtime error to specify a KEY_TYPED
event as mapping to a focus traversal operation, or to map the same event to multiple default focus traversal operations.
This method may throw a ClassCastException
if any Object
in keystrokes
is not an AWTKeyStroke
.
id
- one of KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS
, KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS
, KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS
, or KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYS
keystrokes
- the Set of AWTKeyStroke
s for the specified operationIllegalArgumentException
- if id is not one of KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS
, KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS
, KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS
, or KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYS
, or if keystrokes is null
, or if keystrokes contains null
, or if any keystroke represents a KEY_TYPED
event, or if any keystroke already maps to another default focus traversal operationpublic Set<AWTKeyStroke> getDefaultFocusTraversalKeys(int id)
setDefaultFocusTraversalKeys
for a full description of each operation.)id
- one of KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS, KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS, KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS, or KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYSSet
of AWTKeyStroke
s for the specified operation; the Set
will be unmodifiable, and may be empty; null
will never be returnedIllegalArgumentException
- if id is not one of KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS, KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS, KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS, or KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYSpublic Container getCurrentFocusCycleRoot()
This method is intended to be used only by KeyboardFocusManagers and focus implementations. It is not for general client use.
protected Container getGlobalCurrentFocusCycleRoot() throws SecurityException
SecurityException
- if this KeyboardFocusManager is not the current KeyboardFocusManager for the calling thread's context and if the calling thread does not have "replaceKeyboardFocusManager" permissionpublic void setGlobalCurrentFocusCycleRoot(Container newFocusCycleRoot) throws SecurityException
If a SecurityManager is installed, the calling thread must be granted the "replaceKeyboardFocusManager" AWTPermission. If this permission is not granted, this method will throw a SecurityException, and the current focus cycle root will not be changed.
This method is intended to be used only by KeyboardFocusManagers and focus implementations. It is not for general client use.
newFocusCycleRoot
- the new focus cycle rootSecurityException
- if the calling thread does not have "replaceKeyboardFocusManager" permissionpublic void addPropertyChangeListener(PropertyChangeListener listener)
listener
- the PropertyChangeListener to be addedpublic void removePropertyChangeListener(PropertyChangeListener listener)
If listener is null, no exception is thrown and no action is performed.
listener
- the PropertyChangeListener to be removedpublic PropertyChangeListener[] getPropertyChangeListeners()
PropertyChangeListener
s or an empty array if no property change listeners are currently registeredpublic void addPropertyChangeListener(String propertyName, PropertyChangeListener listener)
propertyName
- one of the property names listed abovelistener
- the PropertyChangeListener to be addedpublic void removePropertyChangeListener(String propertyName, PropertyChangeListener listener)
If listener is null, no exception is thrown and no action is performed.
propertyName
- a valid property namelistener
- the PropertyChangeListener to be removedpublic PropertyChangeListener[] getPropertyChangeListeners(String propertyName)
PropertyChangeListener
s associated with the named property.propertyName
- the property namePropertyChangeListener
s associated with the named property or an empty array if no such listeners have been added.protected void firePropertyChange(String propertyName, Object oldValue, Object newValue)
propertyName
- the name of the property that has changedoldValue
- the property's previous valuenewValue
- the property's new valuepublic void addVetoableChangeListener(VetoableChangeListener listener)
listener
- the VetoableChangeListener to be addedpublic void removeVetoableChangeListener(VetoableChangeListener listener)
If listener is null, no exception is thrown and no action is performed.
listener
- the VetoableChangeListener to be removedpublic VetoableChangeListener[] getVetoableChangeListeners()
VetoableChangeListener
s or an empty array if no vetoable change listeners are currently registeredpublic void addVetoableChangeListener(String propertyName, VetoableChangeListener listener)
propertyName
- one of the property names listed abovelistener
- the VetoableChangeListener to be addedpublic void removeVetoableChangeListener(String propertyName, VetoableChangeListener listener)
If listener is null, no exception is thrown and no action is performed.
propertyName
- a valid property namelistener
- the VetoableChangeListener to be removedpublic VetoableChangeListener[] getVetoableChangeListeners(String propertyName)
VetoableChangeListener
s associated with the named property.propertyName
- the property nameVetoableChangeListener
s associated with the named property or an empty array if no such listeners have been added.protected void fireVetoableChange(String propertyName, Object oldValue, Object newValue) throws PropertyVetoException
propertyName
- the name of the property that has changedoldValue
- the property's previous valuenewValue
- the property's new valuePropertyVetoException
- if a VetoableChangeListener
threw PropertyVetoException
public void addKeyEventDispatcher(KeyEventDispatcher dispatcher)
true
from its dispatchKeyEvent
method. There is no limit to the total number of KeyEventDispatchers which can be added, nor to the number of times which a particular KeyEventDispatcher instance can be added. If a null dispatcher is specified, no action is taken and no exception is thrown.
In a multithreaded application, KeyEventDispatcher
behaves the same as other AWT listeners. See AWT Threading Issues for more details.
dispatcher
- the KeyEventDispatcher to add to the dispatcher chainpublic void removeKeyEventDispatcher(KeyEventDispatcher dispatcher)
addKeyEventDispatcher
. If a null dispatcher is specified, if the specified dispatcher is not in the dispatcher chain, or if this KeyboardFocusManager is specified without having been explicitly re-registered, no action is taken and no exception is thrown.
In a multithreaded application, KeyEventDispatcher
behaves the same as other AWT listeners. See AWT Threading Issues for more details.
dispatcher
- the KeyEventDispatcher to remove from the dispatcher chainprotected List<KeyEventDispatcher> getKeyEventDispatchers()
addKeyEventDispatcher
. If no other KeyEventDispatchers are registered, implementations are free to return null or a List of length 0. Client code should not assume one behavior over another, nor should it assume that the behavior, once established, will not change.public void addKeyEventPostProcessor(KeyEventPostProcessor processor)
true
from its postProcessKeyEvent
method. There is no limit to the total number of KeyEventPostProcessors that can be added, nor to the number of times that a particular KeyEventPostProcessor instance can be added. If a null post-processor is specified, no action is taken and no exception is thrown.
In a multithreaded application, KeyEventPostProcessor
behaves the same as other AWT listeners. See AWT Threading Issues for more details.
processor
- the KeyEventPostProcessor to add to the post-processor chainpublic void removeKeyEventPostProcessor(KeyEventPostProcessor processor)
addKeyEventPostProcessor
can be removed. If a null post-processor is specified, if the specified post-processor is not in the post-processor chain, or if this KeyboardFocusManager is specified without having been explicitly added, no action is taken and no exception is thrown.
In a multithreaded application, KeyEventPostProcessor
behaves the same as other AWT listeners. See AWT Threading Issues for more details.
processor
- the KeyEventPostProcessor to remove from the post- processor chainprotected List<KeyEventPostProcessor> getKeyEventPostProcessors()
addKeyEventPostProcessor
. If no KeyEventPostProcessors are registered, implementations are free to return null or a List of length 0. Client code should not assume one behavior over another, nor should it assume that the behavior, once established, will not change.public abstract boolean dispatchEvent(AWTEvent e)
redispatchEvent
to prevent the AWT event dispatcher from recursively requesting that the KeyboardFocusManager dispatch the event again. If this method returns false
, then the AWT event dispatcher will attempt to dispatch the event itself.e
- the AWTEvent to be dispatchedtrue
if this method dispatched the event; false
otherwisepublic final void redispatchEvent(Component target, AWTEvent e)
dispatchEvent
and client-defined KeyEventDispatchers must call redispatchEvent(target, e)
instead of target.dispatchEvent(e)
to dispatch an event. This method is intended to be used only by KeyboardFocusManagers and KeyEventDispatchers. It is not for general client use.
target
- the Component to which the event should be dispatchede
- the event to dispatchpublic abstract boolean dispatchKeyEvent(KeyEvent e)
dispatchEvent
if no other KeyEventDispatcher in the dispatcher chain dispatched the KeyEvent, or if no other KeyEventDispatchers are registered. If an implementation of this method returns false
, dispatchEvent
may try to dispatch the KeyEvent itself, or may simply return false
. If true
is returned, dispatchEvent
should return true
as well.dispatchKeyEvent
in interface KeyEventDispatcher
e
- the KeyEvent which the current KeyboardFocusManager has requested that this KeyEventDispatcher dispatchtrue
if the KeyEvent was dispatched; false
otherwisepublic abstract boolean postProcessKeyEvent(KeyEvent e)
dispatchKeyEvent
. By default, this method will handle any unconsumed KeyEvents that map to an AWT MenuShortcut
by consuming the event and activating the shortcut.postProcessKeyEvent
in interface KeyEventPostProcessor
e
- the KeyEvent to post-processtrue
to indicate that no other KeyEventPostProcessor will be notified of the KeyEvent.public abstract void processKeyEvent(Component focusedComponent, KeyEvent e)
focusedComponent
- the Component that will be the basis for a focus traversal operation if the specified event represents a focus traversal key for the Componente
- the event that may represent a focus traversal keyprotected abstract void enqueueKeyEvents(long after, Component untilFocused)
dequeueKeyEvents
or discardKeyEvents
.after
- timestamp of current event, or the current, system time if the current event has no timestamp, or the AWT cannot determine which event is currently being handleduntilFocused
- Component which should receive a FOCUS_GAINED event before any pending KeyEventsprotected abstract void dequeueKeyEvents(long after, Component untilFocused)
enqueueKeyEvents
with the same timestamp and Component should be released for normal dispatching to the current focus owner. If the given timestamp is less than zero, the outstanding enqueue request for the given Component with the oldest timestamp (if any) should be cancelled.after
- the timestamp specified in the call to enqueueKeyEvents
, or any value < 0untilFocused
- the Component specified in the call to enqueueKeyEvents
protected abstract void discardKeyEvents(Component comp)
enqueueKeyEvents
with the same Component should be discarded.comp
- the Component specified in one or more calls to enqueueKeyEvents
public abstract void focusNextComponent(Component aComponent)
aComponent
- the Component that is the basis for the focus traversal operationpublic abstract void focusPreviousComponent(Component aComponent)
aComponent
- the Component that is the basis for the focus traversal operationpublic abstract void upFocusCycle(Component aComponent)
aComponent
- the Component that is the basis for the focus traversal operationpublic abstract void downFocusCycle(Container aContainer)
aContainer
- the Container that is the basis for the focus traversal operationpublic final void focusNextComponent()
public final void focusPreviousComponent()
public final void upFocusCycle()
public final void downFocusCycle()
© 1993, 2023, Oracle and/or its affiliates. All rights reserved.
Documentation extracted from Debian's OpenJDK Development Kit package.
Licensed under the GNU General Public License, version 2, with the Classpath Exception.
Various third party code in OpenJDK is licensed under different licenses (see Debian package).
Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.
https://docs.oracle.com/en/java/javase/21/docs/api/java.desktop/java/awt/KeyboardFocusManager.html