KeyboardFocusManager

Overview | Package | Class | Use | Tree | Deprecated | Index | Help

PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## java.awt
Class KeyboardFocusManager

    java.lang.Object
      java.awt.KeyboardFocusManager

All Implemented Interfaces:
  KeyEventDispatcher, KeyEventPostProcessor

    public abstract class KeyboardFocusManager

extends Object
implements KeyEventDispatcher, KeyEventPostProcessor

The KeyboardFocusManager is responsible for managing the active and focused Windows, and the current focus owner. The focus owner is defined as the Component in an application that will typically receive all KeyEvents generated by the user. The focused Window is the Window that is, or contains, the focus owner. Only a Frame can be the active Window. The native windowing system may denote the active Window or its children with special decorations, such as a highlighted title bar. The active Window is always either the focused Window, or the first Frame that is an owner of the focused Window.

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.

Since:
  1.4
Version:
  1.40, 01/23/03
Author:
  David Mendenhall
See Also:
  `Window`, `Frame`, `FocusEvent`, `WindowEvent`, `KeyEvent`

Field Summary
`static int` | `BACKWARD_TRAVERSAL_KEYS` The identifier for the Backward focus traversal keys.
`static int` | `DOWN_CYCLE_TRAVERSAL_KEYS` The identifier for the Down Cycle focus traversal keys.
`static int` | `FORWARD_TRAVERSAL_KEYS` The identifier for the Forward focus traversal keys.
`static int` | `UP_CYCLE_TRAVERSAL_KEYS` The identifier for the Up Cycle focus traversal keys.

Method Summary
`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` | `addVetoableChangeListener(VetoableChangeListener listener)` Adds a VetoableChangeListener to the listener list.
`void` | `clearGlobalFocusOwner()` Clears the global focus owner at both the Java and native levels.
`abstract 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.
`abstract boolean` | `dispatchKeyEvent(KeyEvent e)` 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.
`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(Container aContainer)` Moves the focus down one focus traversal cycle.
`void` | `focusNextComponent()` Focuses the Component after the current focus owner.
`abstract void` | `focusNextComponent(Component aComponent)` Focuses the Component after aComponent, typically based on a FocusTraversalPolicy.
`void` | `focusPreviousComponent()` Focuses the Component before the current focus owner.
`abstract void` | `focusPreviousComponent(Component aComponent)` 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(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.
`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.
`VetoableChangeListener[]` | `getVetoableChangeListeners()` Returns an array of all the vetoable change listeners registered on this keyboard focus manager.
`abstract boolean` | `postProcessKeyEvent(KeyEvent e)` This method will be called by `dispatchKeyEvent`.
`abstract 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` | `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` | `removeVetoableChangeListener(VetoableChangeListener listener)` Removes a VetoableChangeListener from the listener list.
`void` | `setDefaultFocusTraversalKeys(int id, Set keystrokes)` Sets the default focus traversal keys for a given traversal operation.
`void` | `setDefaultFocusTraversalPolicy(FocusTraversalPolicy defaultPolicy)` Sets the default FocusTraversalPolicy.
`void` | `upFocusCycle()` Moves the focus up one focus traversal cycle from the current focus owner.
`abstract void` | `upFocusCycle(Component aComponent)` Moves the focus up one focus traversal cycle.

Methods inherited from class java.lang.Object
`equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### FORWARD_TRAVERSAL_KEYS

    public static final int FORWARD_TRAVERSAL_KEYS

  The identifier for the Forward focus traversal keys.

  See Also:
    `setDefaultFocusTraversalKeys(int, java.util.Set)`, `getDefaultFocusTraversalKeys(int)`, `Component.setFocusTraversalKeys(int, java.util.Set)`, `Component.getFocusTraversalKeys(int)`, Constant Field Values

### BACKWARD_TRAVERSAL_KEYS

    public static final int BACKWARD_TRAVERSAL_KEYS

  The identifier for the Backward focus traversal keys.

  See Also:
    `setDefaultFocusTraversalKeys(int, java.util.Set)`, `getDefaultFocusTraversalKeys(int)`, `Component.setFocusTraversalKeys(int, java.util.Set)`, `Component.getFocusTraversalKeys(int)`, Constant Field Values

### UP_CYCLE_TRAVERSAL_KEYS

    public static final int UP_CYCLE_TRAVERSAL_KEYS

  The identifier for the Up Cycle focus traversal keys.

  See Also:
    `setDefaultFocusTraversalKeys(int, java.util.Set)`, `getDefaultFocusTraversalKeys(int)`, `Component.setFocusTraversalKeys(int, java.util.Set)`, `Component.getFocusTraversalKeys(int)`, Constant Field Values

### DOWN_CYCLE_TRAVERSAL_KEYS

    public static final int DOWN_CYCLE_TRAVERSAL_KEYS

  The identifier for the Down Cycle focus traversal keys.

  See Also:
    `setDefaultFocusTraversalKeys(int, java.util.Set)`, `getDefaultFocusTraversalKeys(int)`, `Component.setFocusTraversalKeys(int, java.util.Set)`, `Component.getFocusTraversalKeys(int)`, Constant Field Values

Method Detail

### getCurrentKeyboardFocusManager

    public static KeyboardFocusManager getCurrentKeyboardFocusManager()

  Returns the current KeyboardFocusManager instance for the calling thread's context.

  Returns:
    this thread's context's KeyboardFocusManager

### getFocusOwner

    public Component getFocusOwner()

  Returns the focus owner, if the focus owner is in the same context as the calling thread. The focus owner is defined as the Component in an application that will typically receive all KeyEvents generated by the user. KeyEvents which map to the focus owner's focus traversal keys will not be delivered if focus traversal keys are enabled for the focus owner. In addition, KeyEventDispatchers may retarget or consume KeyEvents before they reach the focus owner.

  Returns:
    the focus owner, or null if the focus owner is not a member of the calling thread's context

### clearGlobalFocusOwner

    public void clearGlobalFocusOwner()

  Clears the global focus owner at both the Java and native levels. If there exists a focus owner, that 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.

  See Also:
    `Component.requestFocus()`, `FocusEvent.FOCUS_LOST`

### getPermanentFocusOwner

    public Component getPermanentFocusOwner()

  Returns the permanent focus owner, if the permanent focus owner is in the same context as the calling thread. The permanent focus owner is defined as the last Component in an application to receive a permanent FOCUS_GAINED event. The focus owner and permanent focus owner are equivalent unless a temporary focus change is currently in effect. In such a situation, the permanent focus owner will again be the focus owner when the temporary focus change ends.

  Returns:
    the permanent focus owner, or null if the permanent focus owner is not a member of the calling thread's context

### getFocusedWindow

    public Window getFocusedWindow()

  Returns the focused Window, if the focused Window is in the same context as the calling thread. The focused Window is the Window that is or contains the focus owner.

  Returns:
    the focused Window, or null if the focused Window is not a member of the calling thread's context

### getActiveWindow

    public Window getActiveWindow()

  Returns the active Window, if the active Window is in the same context as the calling thread. Only a Frame can be the active Window. The native windowing system may denote the active Window or its children with special decorations, such as a highlighted title bar. The active Window is always either the focused Window, or the first Frame that is an owner of the focused Window.

  Returns:
    the active Window, or null if the active Window is not a member of the calling thread's context

### getDefaultFocusTraversalPolicy

    public FocusTraversalPolicy getDefaultFocusTraversalPolicy()

  Returns the default FocusTraversalPolicy. Top-level components use this value on their creation to initialize their own focus traversal policy by explicit call to Container.setFocusTraversalPolicy.

  Returns:
    the default FocusTraversalPolicy. null will never be returned.
  See Also:
    `setDefaultFocusTraversalPolicy(java.awt.FocusTraversalPolicy)`, `Container.setFocusTraversalPolicy(java.awt.FocusTraversalPolicy)`, `Container.getFocusTraversalPolicy()`

### setDefaultFocusTraversalPolicy

    public void setDefaultFocusTraversalPolicy(FocusTraversalPolicy defaultPolicy)

  Sets the default FocusTraversalPolicy. Top-level components use this value on their creation to initialize their own focus traversal policy by explicit call to Container.setFocusTraversalPolicy. Note: this call doesn't affect already created components as they have their policy initialized. Only new components will use this policy as their default policy.

  Parameters:
    `defaultPolicy` - the new, default FocusTraversalPolicy
  Throws:
    `IllegalArgumentException` - if defaultPolicy is null
  See Also:
    `getDefaultFocusTraversalPolicy()`, `Container.setFocusTraversalPolicy(java.awt.FocusTraversalPolicy)`, `Container.getFocusTraversalPolicy()`

### setDefaultFocusTraversalKeys

    public void setDefaultFocusTraversalKeys(int id,
                                             Set keystrokes)

  Sets the default focus traversal keys for a given traversal operation. This traversal key `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

  To disable a traversal key, use an empty `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.

  Parameters:
    `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 operation
  Throws:
    `IllegalArgumentException` - 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 `Object` in keystrokes is not an `AWTKeyStroke`, or if any keystroke represents a `KEY_TYPED` event, or if any keystroke already maps to another default focus traversal operation
  See Also:
    `getDefaultFocusTraversalKeys(int)`, `Component.setFocusTraversalKeys(int, java.util.Set)`, `Component.getFocusTraversalKeys(int)`

### getDefaultFocusTraversalKeys

    public Set getDefaultFocusTraversalKeys(int id)

  Returns a Set of default focus traversal keys for a given traversal operation. This traversal key Set will be in effect on all Windows 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. (See `setDefaultFocusTraversalKeys` for a full description of each operation.)

  Parameters:
    `id` - one of KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS, KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS, KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS, or KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYS
  Returns:
    the `Set` of `AWTKeyStroke`s for the specified operation; the `Set` will be unmodifiable, and may be empty; `null` will never be returned
  Throws:
    `IllegalArgumentException` - 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
  See Also:
    `setDefaultFocusTraversalKeys(int, java.util.Set)`, `Component.setFocusTraversalKeys(int, java.util.Set)`, `Component.getFocusTraversalKeys(int)`

### getCurrentFocusCycleRoot

    public Container getCurrentFocusCycleRoot()

  Returns the current focus cycle root, if the current focus cycle root is in the same context as the calling thread. If the focus owner is itself a focus cycle root, then it may be ambiguous as to which Components represent the next and previous Components to focus during normal focus traversal. In that case, the current focus cycle root is used to differentiate among the possibilities.

  Returns:
    the current focus cycle root, or null if the current focus cycle root is not a member of the calling thread's context

### addPropertyChangeListener

    public void addPropertyChangeListener(PropertyChangeListener listener)

  Adds a PropertyChangeListener to the listener list. The listener is registered for all bound properties of this class, including the following:
  - the focus owner ("focusOwner")
  - the permanent focus owner ("permanentFocusOwner")
  - the focused Window ("focusedWindow")
  - the active Window ("activeWindow")
  - the default focus traversal policy ("defaultFocusTraversalPolicy")
  - the Set of default FORWARD_TRAVERSAL_KEYS ("forwardDefaultFocusTraversalKeys")
  - the Set of default BACKWARD_TRAVERSAL_KEYS ("backwardDefaultFocusTraversalKeys")
  - the Set of default UP_CYCLE_TRAVERSAL_KEYS ("upCycleDefaultFocusTraversalKeys")
  - the Set of default DOWN_CYCLE_TRAVERSAL_KEYS ("downCycleDefaultFocusTraversalKeys")
  - the current focus cycle root ("currentFocusCycleRoot")
  If listener is null, no exception is thrown and no action is performed.

  Parameters:
    `listener` - the PropertyChangeListener to be added
  See Also:
    `removePropertyChangeListener(java.beans.PropertyChangeListener)`, `getPropertyChangeListeners()`

### removePropertyChangeListener

    public void removePropertyChangeListener(PropertyChangeListener listener)

  Removes a PropertyChangeListener from the listener list. This method should be used to remove the PropertyChangeListeners that were registered for all bound properties of this class.

  If listener is null, no exception is thrown and no action is performed.

  Parameters:
    `listener` - the PropertyChangeListener to be removed
  See Also:
    `addPropertyChangeListener(java.beans.PropertyChangeListener)`, `getPropertyChangeListeners()`

### getPropertyChangeListeners

    public PropertyChangeListener[] getPropertyChangeListeners()

  Returns an array of all the property change listeners registered on this keyboard focus manager.

  Returns:
    all of this keyboard focus manager's `PropertyChangeListener`s or an empty array if no property change listeners are currently registered
  Since:
    1.4
  See Also:
    `addPropertyChangeListener(java.beans.PropertyChangeListener)`, `removePropertyChangeListener(java.beans.PropertyChangeListener)`

### addVetoableChangeListener

    public void addVetoableChangeListener(VetoableChangeListener listener)

  Adds a VetoableChangeListener to the listener list. The listener is registered for all vetoable properties of this class, including the following:
  - the focus owner ("focusOwner")
  - the permanent focus owner ("permanentFocusOwner")
  - the focused Window ("focusedWindow")
  - the active Window ("activeWindow")
  If listener is null, no exception is thrown and no action is performed.

  Parameters:
    `listener` - the VetoableChangeListener to be added
  See Also:
    `removeVetoableChangeListener(java.beans.VetoableChangeListener)`, `getVetoableChangeListeners()`

### removeVetoableChangeListener

    public void removeVetoableChangeListener(VetoableChangeListener listener)

  Removes a VetoableChangeListener from the listener list. This method should be used to remove the VetoableChangeListeners that were registered for all vetoable properties of this class.

  If listener is null, no exception is thrown and no action is performed.

  Parameters:
    `listener` - the VetoableChangeListener to be removed
  See Also:
    `addVetoableChangeListener(java.beans.VetoableChangeListener)`, `getVetoableChangeListeners()`

### getVetoableChangeListeners

    public VetoableChangeListener[] getVetoableChangeListeners()

  Returns an array of all the vetoable change listeners registered on this keyboard focus manager.

  Returns:
    all of this keyboard focus manager's `VetoableChangeListener`s or an empty array if no vetoable change listeners are currently registered
  Since:
    1.4
  See Also:
    `addVetoableChangeListener(java.beans.VetoableChangeListener)`, `removeVetoableChangeListener(java.beans.VetoableChangeListener)`

### addKeyEventDispatcher

    public void addKeyEventDispatcher(KeyEventDispatcher dispatcher)

  Adds a KeyEventDispatcher to this KeyboardFocusManager's dispatcher chain. This KeyboardFocusManager will request that each KeyEventDispatcher dispatch KeyEvents generated by the user before finally dispatching the KeyEvent itself. KeyEventDispatchers will be notified in the order in which they were added. Notifications will halt as soon as one KeyEventDispatcher returns `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.

  Parameters:
    `dispatcher` - the KeyEventDispatcher to add to the dispatcher chain
  See Also:
    `removeKeyEventDispatcher(java.awt.KeyEventDispatcher)`

### removeKeyEventDispatcher

    public void removeKeyEventDispatcher(KeyEventDispatcher dispatcher)

  Removes a KeyEventDispatcher which was previously added to this KeyboardFocusManager's dispatcher chain. This KeyboardFocusManager cannot itself be removed, unless it was explicitly re-registered via a call to `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.

  Parameters:
    `dispatcher` - the KeyEventDispatcher to remove from the dispatcher chain
  See Also:
    `addKeyEventDispatcher(java.awt.KeyEventDispatcher)`

### addKeyEventPostProcessor

    public void addKeyEventPostProcessor(KeyEventPostProcessor processor)

  Adds a KeyEventPostProcessor to this KeyboardFocusManager's post- processor chain. After a KeyEvent has been dispatched to and handled by its target, KeyboardFocusManager will request that each KeyEventPostProcessor perform any necessary post-processing as part of the KeyEvent's final resolution. KeyEventPostProcessors will be notified in the order in which they were added; the current KeyboardFocusManager will be notified last. Notifications will halt as soon as one KeyEventPostProcessor returns `true` from its `postProcessKeyEvent` method. There is no limit to the 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.

  Parameters:
    `processor` - the KeyEventPostProcessor to add to the post-processor chain
  See Also:
    `removeKeyEventPostProcessor(java.awt.KeyEventPostProcessor)`

### removeKeyEventPostProcessor

    public void removeKeyEventPostProcessor(KeyEventPostProcessor processor)

  Removes a previously added KeyEventPostProcessor from this KeyboardFocusManager's post-processor chain. This KeyboardFocusManager cannot itself be entirely removed from the chain. Only additional references added via `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.

  Parameters:
    `processor` - the KeyEventPostProcessor to remove from the post- processor chain
  See Also:
    `addKeyEventPostProcessor(java.awt.KeyEventPostProcessor)`

### dispatchEvent

    public abstract 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. It is expected that all KeyboardFocusManagers will dispatch all FocusEvents, all WindowEvents related to focus, and all KeyEvents. These events should be 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. Dispatching must be done using `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.

  Parameters:
    `e` - the AWTEvent to be dispatched
  Returns:
    `true` if this method dispatched the event; `false` otherwise
  See Also:
    `redispatchEvent(java.awt.Component, java.awt.AWTEvent)`, `dispatchKeyEvent(java.awt.event.KeyEvent)`

### redispatchEvent

    public 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. Client implementations of `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.

  Parameters:
    `target` - the Component to which the event should be dispatched
    `e` - the event to dispatch
  See Also:
    `dispatchEvent(java.awt.AWTEvent)`, `KeyEventDispatcher`

### dispatchKeyEvent

    public abstract boolean dispatchKeyEvent(KeyEvent e)

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

  Specified by:
    `dispatchKeyEvent` in interface `KeyEventDispatcher`
  Parameters:
    `e` - the KeyEvent which the current KeyboardFocusManager has requested that this KeyEventDispatcher dispatch
  Returns:
    `true` if the KeyEvent was dispatched; `false` otherwise
  See Also:
    `dispatchEvent(java.awt.AWTEvent)`

### postProcessKeyEvent

    public abstract boolean postProcessKeyEvent(KeyEvent e)

  This method will be called by `dispatchKeyEvent`. By default, this method will handle any unconsumed KeyEvents by consuming the event .

  Specified by:
    `postProcessKeyEvent` in interface `KeyEventPostProcessor`
  Parameters:
    `e` - the KeyEvent to post-process
  Returns:
    `true` to indicate that no other KeyEventPostProcessor will be notified of the KeyEvent.
  See Also:
    `dispatchKeyEvent(java.awt.event.KeyEvent)`

### processKeyEvent

    public abstract 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 current focus owner.

  Parameters:
    `focusedComponent` - the Component that will be 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

### focusNextComponent

    public abstract void focusNextComponent(Component aComponent)

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

  Parameters:
    `aComponent` - the Component that is the basis for the focus traversal operation
  See Also:
    `FocusTraversalPolicy`

### focusPreviousComponent

    public abstract void focusPreviousComponent(Component aComponent)

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

  Parameters:
    `aComponent` - the Component that is the basis for the focus traversal operation
  See Also:
    `FocusTraversalPolicy`

### upFocusCycle

    public abstract 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 typically the focus owner is set to the Window's default Component to focus, and the current focus cycle root is unchanged.

  Parameters:
    `aComponent` - the Component that is the basis for the focus traversal operation

### downFocusCycle

    public abstract void downFocusCycle(Container aContainer)

  Moves the focus down one focus traversal cycle. Typically, 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.

  Parameters:
    `aContainer` - the Container that is the basis for the focus traversal operation

### focusNextComponent

    public final void focusNextComponent()

  Focuses the Component after the current focus owner.

### focusPreviousComponent

    public final void focusPreviousComponent()

  Focuses the Component before the current focus owner.

### upFocusCycle

    public final void upFocusCycle()

  Moves the focus up one focus traversal cycle from the current focus owner. Typically, the new focus owner is set to the current focus owner's focus cycle root, and the current focus cycle root is set to the new focus owner's focus cycle root. If, however, the current focus owner's focus cycle root is a Window, then typically the focus owner is set to the focus cycle root's default Component to focus, and the current focus cycle root is unchanged.

### downFocusCycle

    public 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. Typically, the focus owner is set to the current focus owner's default Component to focus, and the current focus cycle root is set to the current focus owner. If the current focus owner is not a Container that is a focus cycle root, then no focus traversal operation occurs.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help

PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD