Class DefaultKeyboardFocusManager

java.lang.Object

java.awt.KeyboardFocusManager

java.awt.DefaultKeyboardFocusManager

All Implemented Interfaces:

KeyEventDispatcher, KeyEventPostProcessor

Direct Known Subclasses:

FocusManager

public class DefaultKeyboardFocusManager
extends KeyboardFocusManager

The default KeyboardFocusManager for AWT applications. Focus traversal is done in response to a Component's focus traversal keys, and using a Container's FocusTraversalPolicy.

Please see How to Use the Focus Subsystem, a section in The Java Tutorial, and the Focus Specification for more information.

Since:

1.4

See Also:

• FocusTraversalPolicy
• Component.setFocusTraversalKeys(int, Set)
• Component.getFocusTraversalKeys(int)

Field Summary

Fields declared in class KeyboardFocusManager

BACKWARD_TRAVERSAL_KEYS, DOWN_CYCLE_TRAVERSAL_KEYS, FORWARD_TRAVERSAL_KEYS, UP_CYCLE_TRAVERSAL_KEYS

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 Summary

Constructors

Constructor	Description
DefaultKeyboardFocusManager()	Constructs a DefaultKeyboardFocusManager.

Method Summary

Modifier and Type	Method	Description
protected void	dequeueKeyEvents(long after, Component untilFocused)	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.
protected void	discardKeyEvents(Component comp)	Discards all KeyEvents which were enqueued because of one or more calls to enqueueKeyEvents with the specified Component, or one of its descendants.
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.
boolean	dispatchKeyEvent(KeyEvent e)	Called by dispatchEvent if no other KeyEventDispatcher in the dispatcher chain dispatched the KeyEvent, or if no other KeyEventDispatchers are registered.
void	downFocusCycle(Container aContainer)	Moves the focus down one focus traversal cycle.
protected void	enqueueKeyEvents(long after, Component untilFocused)	Delays dispatching of KeyEvents until the specified Component becomes the focus owner.
void	focusNextComponent(Component aComponent)	Focuses the Component after aComponent, typically based on a FocusTraversalPolicy.
void	focusPreviousComponent(Component aComponent)	Focuses the Component before aComponent, typically based on a FocusTraversalPolicy.
boolean	postProcessKeyEvent(KeyEvent e)	This method will be called by dispatchKeyEvent.
void	processKeyEvent(Component focusedComponent, KeyEvent e)	This method initiates a focus traversal operation if and only if the KeyEvent represents a focus traversal key for the specified focusedComponent.
void	upFocusCycle(Component aComponent)	Moves the focus up one focus traversal cycle.

Methods declared in class KeyboardFocusManager

addKeyEventDispatcher, addKeyEventPostProcessor, addPropertyChangeListener, addPropertyChangeListener, addVetoableChangeListener, addVetoableChangeListener, clearFocusOwner, clearGlobalFocusOwner, downFocusCycle, firePropertyChange, fireVetoableChange, focusNextComponent, focusPreviousComponent, getActiveWindow, getCurrentFocusCycleRoot, getCurrentKeyboardFocusManager, getDefaultFocusTraversalKeys, getDefaultFocusTraversalPolicy, getFocusedWindow, getFocusOwner, getGlobalActiveWindow, getGlobalCurrentFocusCycleRoot, getGlobalFocusedWindow, getGlobalFocusOwner, getGlobalPermanentFocusOwner, getKeyEventDispatchers, getKeyEventPostProcessors, getPermanentFocusOwner, getPropertyChangeListeners, getPropertyChangeListeners, getVetoableChangeListeners, getVetoableChangeListeners, redispatchEvent, removeKeyEventDispatcher, removeKeyEventPostProcessor, removePropertyChangeListener, removePropertyChangeListener, removeVetoableChangeListener, removeVetoableChangeListener, setCurrentKeyboardFocusManager, setDefaultFocusTraversalKeys, setDefaultFocusTraversalPolicy, setGlobalActiveWindow, setGlobalCurrentFocusCycleRoot, setGlobalFocusedWindow, setGlobalFocusOwner, setGlobalPermanentFocusOwner, upFocusCycle

Modifier and Type	Method	Description
void	addKeyEventDispatcher(KeyEventDispatcher dispatcher)	Adds a KeyEventDispatcher to this KeyboardFocusManager's dispatcher chain.
void	addKeyEventPostProcessor(KeyEventPostProcessor processor)	Adds a KeyEventPostProcessor to this KeyboardFocusManager's post- processor chain.
void	addPropertyChangeListener(PropertyChangeListener listener)	Adds a PropertyChangeListener to the listener list.
void	addPropertyChangeListener(String propertyName, PropertyChangeListener listener)	Adds a PropertyChangeListener to the listener list for a specific property.
void	addVetoableChangeListener(VetoableChangeListener listener)	Adds a VetoableChangeListener to the listener list.
void	addVetoableChangeListener(String propertyName, VetoableChangeListener listener)	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.
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.
protected void	firePropertyChange(String propertyName, Object oldValue, Object newValue)	Fires a PropertyChangeEvent in response to a change in a bound property.
protected void	fireVetoableChange(String propertyName, Object oldValue, Object newValue)	Fires a PropertyChangeEvent in response to a change in a vetoable property.
final void	focusNextComponent()	Focuses the Component after the current focus owner.
final void	focusPreviousComponent()	Focuses the Component before the current focus owner.
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<AWTKeyStroke>	getDefaultFocusTraversalKeys(int id)	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<KeyEventDispatcher>	getKeyEventDispatchers()	Returns this KeyboardFocusManager's KeyEventDispatcher chain as a List.
protected List<KeyEventPostProcessor>	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(String propertyName)	Returns an array of all the PropertyChangeListeners associated with the named property.
VetoableChangeListener[]	getVetoableChangeListeners()	Returns an array of all the vetoable change listeners registered on this keyboard focus manager.
VetoableChangeListener[]	getVetoableChangeListeners(String propertyName)	Returns an array of all the VetoableChangeListeners associated with the named property.
final void	redispatchEvent(Component target, AWTEvent e)	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(KeyEventDispatcher dispatcher)	Removes a KeyEventDispatcher which was previously added to this KeyboardFocusManager's dispatcher chain.
void	removeKeyEventPostProcessor(KeyEventPostProcessor processor)	Removes a previously added KeyEventPostProcessor from this KeyboardFocusManager's post-processor chain.
void	removePropertyChangeListener(PropertyChangeListener listener)	Removes a PropertyChangeListener from the listener list.
void	removePropertyChangeListener(String propertyName, PropertyChangeListener listener)	Removes a PropertyChangeListener from the listener list for a specific property.
void	removeVetoableChangeListener(VetoableChangeListener listener)	Removes a VetoableChangeListener from the listener list.
void	removeVetoableChangeListener(String propertyName, VetoableChangeListener listener)	Removes a VetoableChangeListener from the listener list for a specific property.
static void	setCurrentKeyboardFocusManager(KeyboardFocusManager newManager)	Sets the current KeyboardFocusManager instance for the calling thread's context.
void	setDefaultFocusTraversalKeys(int id, Set<? extends AWTKeyStroke> keystrokes)	Sets the default focus traversal keys for a given traversal operation.
void	setDefaultFocusTraversalPolicy(FocusTraversalPolicy defaultPolicy)	Sets the default FocusTraversalPolicy.
protected void	setGlobalActiveWindow(Window activeWindow)	Sets the active Window.
void	setGlobalCurrentFocusCycleRoot(Container newFocusCycleRoot)	Sets the current focus cycle root.
protected void	setGlobalFocusedWindow(Window focusedWindow)	Sets the focused Window.
protected void	setGlobalFocusOwner(Component focusOwner)	Sets the focus owner.
protected void	setGlobalPermanentFocusOwner(Component permanentFocusOwner)	Sets the permanent focus owner.
final void	upFocusCycle()	Moves the focus up one focus traversal cycle from the current focus owner.

Methods declared in class Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Modifier and Type	Method	Description
protected Object	clone()	Creates and returns a copy of this object.
boolean	equals(Object obj)	Indicates whether some other object is "equal to" this one.
protected void	finalize()	Deprecated, for removal: This API element is subject to removal in a future version. Finalization is deprecated and subject to removal in a future release.
final Class<?>	getClass()	Returns the runtime class of this Object.
int	hashCode()	Returns a hash code value for this object.
final void	notify()	Wakes up a single thread that is waiting on this object's monitor.
final void	notifyAll()	Wakes up all threads that are waiting on this object's monitor.
String	toString()	Returns a string representation of the object.
final void	wait()	Causes the current thread to wait until it is awakened, typically by being notified or interrupted.
final void	wait(long timeoutMillis)	Causes the current thread to wait until it is awakened, typically by being notified or interrupted, or until a certain amount of real time has elapsed.
final void	wait(long timeoutMillis, int nanos)	Causes the current thread to wait until it is awakened, typically by being notified or interrupted, or until a certain amount of real time has elapsed.

Constructor Details

DefaultKeyboardFocusManager

public DefaultKeyboardFocusManager()

Constructs a DefaultKeyboardFocusManager.

Method Details

dispatchEvent

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.

Specified by:

dispatchEvent in class KeyboardFocusManager

Parameters:

e - the AWTEvent to be dispatched

Returns:

true if this method dispatched the event; false otherwise

See Also:

• KeyboardFocusManager.redispatchEvent(Component, AWTEvent)
• KeyboardFocusManager.dispatchKeyEvent(KeyEvent)

dispatchKeyEvent

public boolean dispatchKeyEvent(KeyEvent e)

Called by 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 true, since DefaultKeyboardFocusManager is designed so that neither dispatchEvent, nor the AWT event dispatcher, should take further action on the event in any situation.

Specified by:

dispatchKeyEvent in interface KeyEventDispatcher

Specified by:

dispatchKeyEvent in class KeyboardFocusManager

Parameters:

e - the KeyEvent to be dispatched

Returns:

true

See Also:

• Component.dispatchEvent(AWTEvent)

postProcessKeyEvent

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 shortcut.

Specified by:

postProcessKeyEvent in interface KeyEventPostProcessor

Specified by:

postProcessKeyEvent in class KeyboardFocusManager

Parameters:

e - the KeyEvent to post-process

Returns:

true

See Also:

• dispatchKeyEvent(KeyEvent)
• MenuShortcut

processKeyEvent

public void processKeyEvent(Component focusedComponent,
 KeyEvent e)

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.

Specified by:

processKeyEvent in class KeyboardFocusManager

Parameters:

focusedComponent - the Component that is the basis for a focus traversal operation if the specified event represents a focus traversal key for the Component

e - the event that may represent a focus traversal key

enqueueKeyEvents

protected void enqueueKeyEvents(long after,
 Component untilFocused)

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 dequeueKeyEvents or discardKeyEvents.

Specified by:

enqueueKeyEvents in class KeyboardFocusManager

Parameters:

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 handled

untilFocused - Component which will receive a FOCUS_GAINED event before any pending KeyEvents

See Also:

• dequeueKeyEvents(long, Component)
• discardKeyEvents(Component)

dequeueKeyEvents

protected void dequeueKeyEvents(long after,
 Component untilFocused)

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.

Specified by:

dequeueKeyEvents in class KeyboardFocusManager

Parameters:

after - the timestamp specified in the call to enqueueKeyEvents, or any value < 0

untilFocused - the Component specified in the call to enqueueKeyEvents

See Also:

• enqueueKeyEvents(long, Component)
• discardKeyEvents(Component)

discardKeyEvents

protected void discardKeyEvents(Component comp)

Discards all KeyEvents which were enqueued because of one or more calls to enqueueKeyEvents with the specified Component, or one of its descendants.

Specified by:

discardKeyEvents in class KeyboardFocusManager

Parameters:

comp - the Component specified in one or more calls to enqueueKeyEvents, or a parent of such a Component

See Also:

• enqueueKeyEvents(long, Component)
• dequeueKeyEvents(long, Component)

focusPreviousComponent

public void focusPreviousComponent(Component aComponent)

Focuses the Component before aComponent, typically based on a FocusTraversalPolicy.

Specified by:

focusPreviousComponent in class KeyboardFocusManager

Parameters:

aComponent - the Component that is the basis for the focus traversal operation

See Also:

• FocusTraversalPolicy
• Component.transferFocusBackward()

focusNextComponent

public void focusNextComponent(Component aComponent)

Focuses the Component after aComponent, typically based on a FocusTraversalPolicy.

Specified by:

focusNextComponent in class KeyboardFocusManager

Parameters:

aComponent - the Component that is the basis for the focus traversal operation

See Also:

• FocusTraversalPolicy
• Component.transferFocus()

upFocusCycle

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.

Specified by:

upFocusCycle in class KeyboardFocusManager

Parameters:

aComponent - the Component that is the basis for the focus traversal operation

See Also:

• Component.transferFocusUpCycle()

downFocusCycle

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.

Specified by:

downFocusCycle in class KeyboardFocusManager

Parameters:

aContainer - the Container that is the basis for the focus traversal operation

See Also:

• Container.transferFocusDownCycle()