The default KeyboardFocusManager for AWT applications. Focus traversal is
done in response to a Component's focus traversal keys, and using a
|Method from java.awt.DefaultKeyboardFocusManager Detail:|
protected synchronized void dequeueKeyEvents(long after,
Releases for normal dispatching to the current focus owner all
KeyEvents which were enqueued because of a call to
enqueueKeyEvents with the same timestamp and Component.
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.
protected synchronized void discardKeyEvents(Component comp)
Discards all KeyEvents which were enqueued because of one or more calls
enqueueKeyEvents with the specified Component, or one of
public boolean dispatchEvent(AWTEvent e)
This method is called by the AWT event dispatcher requesting that the
current KeyboardFocusManager dispatch the specified event on its behalf.
DefaultKeyboardFocusManagers dispatch all FocusEvents, all WindowEvents
related to focus, and all KeyEvents. These events are dispatched based
on the KeyboardFocusManager's notion of the focus owner and the focused
and active Windows, sometimes overriding the source of the specified
AWTEvent. If this method returns
false, then the AWT event
dispatcher will attempt to dispatch the event itself.
public boolean dispatchKeyEvent(KeyEvent e)
dispatchEvent 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.
In all cases, this method returns
DefaultKeyboardFocusManager is designed so that neither
dispatchEvent, nor the AWT event dispatcher, should take
further action on the event in any situation.
public void downFocusCycle(Container aContainer)
Moves the focus down one focus traversal cycle. If aContainer is a focus
cycle root, then the focus owner is set to aContainer's default
Component to focus, and the current focus cycle root is set to
aContainer. If aContainer is not a focus cycle root, then no focus
traversal operation occurs.
Dumps the list of type-ahead queue markers to stderr
protected synchronized void enqueueKeyEvents(long after,
Delays dispatching of KeyEvents until the specified Component becomes
the focus owner. KeyEvents with timestamps later than the specified
timestamp will be enqueued until the specified Component receives a
FOCUS_GAINED event, or the AWT cancels the delay request by invoking
public void focusNextComponent(Component aComponent)
Focuses the Component after aComponent, typically based on a
public void focusPreviousComponent(Component aComponent)
Focuses the Component before aComponent, typically based on a
public boolean postProcessKeyEvent(KeyEvent e)
This method will be called by
dispatchKeyEvent. It will
handle any unconsumed KeyEvents that map to an AWT
MenuShortcut by consuming the event and activating the
public void processKeyEvent(Component focusedComponent,
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.
static boolean sendMessage(Component target,
Sends a synthetic AWTEvent to a Component. If the Component is in
the current AppContext, then the event is immediately dispatched.
If the Component is in a different AppContext, then the event is
posted to the other AppContext's EventQueue, and this method blocks
until the event is handled or target AppContext is disposed.
Returns true if successfuly dispatched event, false if failed
public void upFocusCycle(Component aComponent)
Moves the focus up one focus traversal cycle. Typically, the focus owner
is set to aComponent's focus cycle root, and the current focus cycle
root is set to the new focus owner's focus cycle root. If, however,
aComponent's focus cycle root is a Window, then the focus owner is set
to the focus cycle root's default Component to focus, and the current
focus cycle root is unchanged.