# Class FocusManager

java.lang.Object
java.awt.KeyboardFocusManager
java.awt.DefaultKeyboardFocusManager
javax.swing.FocusManager

All Implemented Interfaces:
  `KeyEventDispatcher, KeyEventPostProcessor`

Direct Known Subclasses:
  `DefaultFocusManager`

public abstract class FocusManager extends DefaultKeyboardFocusManager
This class has been obsoleted by the 1.4 focus APIs. While client code may still use this class, developers are strongly encouraged to use `java.awt.KeyboardFocusManager` and `java.awt.DefaultKeyboardFocusManager` instead.

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

Since:
  1.2
See Also:
  - Focus Specification

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `static final String`
  `FOCUS_MANAGER_CLASS_PROPERTY`
  This field is obsolete, and its use is discouraged since its specification is incompatible with the 1.4 focus APIs.

  ### 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
  Modifier
  Constructor
  Description
  `protected`
  `FocusManager()`
  Constructor for subclasses to call.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `static void`
  `disableSwingFocusManager()`
  Deprecated.
  as of 1.4, replaced by `KeyboardFocusManager.setDefaultFocusTraversalPolicy(FocusTraversalPolicy)`
  `static FocusManager`
  `getCurrentManager()`
  Returns the current `KeyboardFocusManager` instance for the calling thread's context.
  `static boolean`
  `isFocusManagerEnabled()`
  Deprecated.
  As of 1.4, replaced by `KeyboardFocusManager.getDefaultFocusTraversalPolicy()`
  `static void`
  `setCurrentManager(FocusManager aFocusManager)`
  Sets the current `KeyboardFocusManager` instance for the calling thread's context.

  ### Methods declared in class DefaultKeyboardFocusManager

  `dequeueKeyEvents, discardKeyEvents, dispatchEvent, dispatchKeyEvent, downFocusCycle, enqueueKeyEvents, focusNextComponent, focusPreviousComponent, postProcessKeyEvent, processKeyEvent, upFocusCycle`
  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 `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(String propertyName)`
  Returns an array of all the `VetoableChangeListener`s 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.

- ## Field Details

  - ### FOCUS_MANAGER_CLASS_PROPERTY

    public static final String FOCUS_MANAGER_CLASS_PROPERTY
    This field is obsolete, and its use is discouraged since its specification is incompatible with the 1.4 focus APIs. The current FocusManager is no longer a property of the UI. Client code must query for the current FocusManager using `KeyboardFocusManager.getCurrentKeyboardFocusManager()`. See the Focus Specification for more information.
    See Also:
      - `KeyboardFocusManager.getCurrentKeyboardFocusManager()`
      - Focus Specification
      - Constant Field Values

- ## Constructor Details

  - ### FocusManager

    protected FocusManager()
    Constructor for subclasses to call.

- ## Method Details

  - ### getCurrentManager

    public static FocusManager getCurrentManager()
    Returns the current `KeyboardFocusManager` instance for the calling thread's context.
    Returns:
      this thread's context's `KeyboardFocusManager`
    See Also:
      - `setCurrentManager(FocusManager)`

  - ### setCurrentManager

    public static void setCurrentManager(FocusManager aFocusManager)
    Sets the current `KeyboardFocusManager` instance for the calling thread's context. If `null` is specified, then the current `KeyboardFocusManager` is replaced with a new instance of `DefaultKeyboardFocusManager`.
    Parameters:
      `aFocusManager` - the new `KeyboardFocusManager` for this thread's context
    See Also:
      - `getCurrentManager()`
      - `DefaultKeyboardFocusManager`

  - ### disableSwingFocusManager

    @Deprecated public static void disableSwingFocusManager()
    Deprecated.
    as of 1.4, replaced by `KeyboardFocusManager.setDefaultFocusTraversalPolicy(FocusTraversalPolicy)`
    Changes the current `KeyboardFocusManager`'s default `FocusTraversalPolicy` to `DefaultFocusTraversalPolicy`.
    See Also:
      - `DefaultFocusTraversalPolicy`
      - `KeyboardFocusManager.setDefaultFocusTraversalPolicy(FocusTraversalPolicy)`

  - ### isFocusManagerEnabled

    @Deprecated public static boolean isFocusManagerEnabled()
    Deprecated.
    As of 1.4, replaced by `KeyboardFocusManager.getDefaultFocusTraversalPolicy()`
    Returns whether the application has invoked `disableSwingFocusManager()`.
    Returns:
      `true` if focus manager is enabled.
    See Also:
      - `disableSwingFocusManager()`