FileDocCategorySizeDatePackage
KeyboardFocusManager.javaAPI DocJava SE 6 API125893Tue Jun 10 00:25:16 BST 2008java.awt

KeyboardFocusManager

public abstract class KeyboardFocusManager extends Object implements KeyEventPostProcessor, KeyEventDispatcher
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 or a Dialog 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 or Dialog 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.

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

author
David Mendenhall
version
1.74, 03/15/07
see
Window
see
Frame
see
Dialog
see
java.awt.event.FocusEvent
see
java.awt.event.WindowEvent
see
java.awt.event.KeyEvent
since
1.4

Fields Summary
private static final Logger
focusLog
transient KeyboardFocusManagerPeer
peer
private static final sun.awt.DebugHelper
dbg
public static final int
FORWARD_TRAVERSAL_KEYS
The identifier for the Forward focus traversal keys.
public static final int
BACKWARD_TRAVERSAL_KEYS
The identifier for the Backward focus traversal keys.
public static final int
UP_CYCLE_TRAVERSAL_KEYS
The identifier for the Up Cycle focus traversal keys.
public static final int
DOWN_CYCLE_TRAVERSAL_KEYS
The identifier for the Down Cycle focus traversal keys.
static final int
TRAVERSAL_KEY_LENGTH
private static Component
focusOwner
The Component in an application that will typically receive all KeyEvents generated by the user.
private static Component
permanentFocusOwner
The Component in an application that will regain focus when an outstanding temporary focus transfer has completed, or the focus owner, if no outstanding temporary transfer exists.
private static Window
focusedWindow
The Window which is, or contains, the focus owner.
private static Window
activeWindow
Only a Frame or a Dialog can be the active Window. The native windowing system may denote the active Window with a special decoration, such as a highlighted title bar. The active Window is always either the focused Window, or the first Frame or Dialog which is an owner of the focused Window.
private FocusTraversalPolicy
defaultPolicy
The default FocusTraversalPolicy for all Windows that have no policy of their own set. If those Windows have focus-cycle-root children that have no keyboard-traversal policy of their own, then those children will also inherit this policy (as will, recursively, their focus-cycle-root children).
private static final String[]
defaultFocusTraversalKeyPropertyNames
The bound property names of each focus traversal key.
private static final AWTKeyStroke[]
defaultFocusTraversalKeyStrokes
The default strokes for initializing the default focus traversal keys.
private Set[]
defaultFocusTraversalKeys
The default focus traversal keys. Each array of traversal keys will be in effect on all Windows that have no such array of their own explicitly set. Each array will also be inherited, recursively, by any child Component of those Windows that has no such array of its own explicitly set.
private static Container
currentFocusCycleRoot
The current focus cycle root. 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.
private VetoableChangeSupport
vetoableSupport
A description of any VetoableChangeListeners which have been registered.
private PropertyChangeSupport
changeSupport
A description of any PropertyChangeListeners which have been registered.
private LinkedList
keyEventDispatchers
This KeyboardFocusManager's KeyEventDispatcher chain. The List does not include this KeyboardFocusManager unless it was explicitly re-registered via a call to addKeyEventDispatcher. If no other KeyEventDispatchers are registered, this field may be null or refer to a List of length 0.
private LinkedList
keyEventPostProcessors
This KeyboardFocusManager's KeyEventPostProcessor chain. The List does not include this KeyboardFocusManager unless it was explicitly re-registered via a call to addKeyEventPostProcessor. If no other KeyEventPostProcessors are registered, this field may be null or refer to a List of length 0.
private static Map
mostRecentFocusOwners
Maps Windows to those Windows' most recent focus owners.
private static final String
notPrivileged
Error String for initializing SecurityExceptions.
private static AWTPermission
replaceKeyboardFocusManagerPermission
We cache the permission used to verify that the calling thread is permitted to access the global focus state.
transient SequencedEvent
currentSequencedEvent
private static LinkedList
heavyweightRequests
private static LinkedList
currentLightweightRequests
private static boolean
clearingCurrentLightweightRequests
private static boolean
allowSyncFocusRequests
private static Component
newFocusOwner
static volatile boolean
disableRestoreFocus
static final int
SNFH_FAILURE
static final int
SNFH_SUCCESS_HANDLED
static final int
SNFH_SUCCESS_PROCEED
static Field
proxyActive
Constructors Summary
public KeyboardFocusManager()
Initializes a KeyboardFocusManager.

        for (int i = 0; i < TRAVERSAL_KEY_LENGTH; i++) {
            Set work_set = new HashSet();
            for (int j = 0; j < defaultFocusTraversalKeyStrokes[i].length; j++) {
                work_set.add(defaultFocusTraversalKeyStrokes[i][j]);
            }
            defaultFocusTraversalKeys[i] = (work_set.isEmpty())
                ? Collections.EMPTY_SET
                : Collections.unmodifiableSet(work_set);
        }
        initPeer();
    
Methods Summary
private void_clearGlobalFocusOwner()

        Window activeWindow = markClearGlobalFocusOwner();
        peer.clearGlobalFocusOwner(activeWindow);
    
public voidaddKeyEventDispatcher(java.awt.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.

In a multithreaded application, {@link KeyEventDispatcher} behaves the same as other AWT listeners. See AWT Threading Issues for more details.

param
dispatcher the KeyEventDispatcher to add to the dispatcher chain
see
#removeKeyEventDispatcher

        if (dispatcher != null) {
	    synchronized (this) {
	        if (keyEventDispatchers == null) {
		    keyEventDispatchers = new java.util.LinkedList();
		}
		keyEventDispatchers.add(dispatcher);
	    }
	}
    
public voidaddKeyEventPostProcessor(java.awt.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.

In a multithreaded application, {@link KeyEventPostProcessor} behaves the same as other AWT listeners. See AWT Threading Issues for more details.

param
processor the KeyEventPostProcessor to add to the post-processor chain
see
#removeKeyEventPostProcessor

        if (processor != null) {
            synchronized (this) {
                if (keyEventPostProcessors == null) {
                    keyEventPostProcessors = new java.util.LinkedList();
                }
                keyEventPostProcessors.add(processor);
            }
        }
    
public voidaddPropertyChangeListener(java.beans.PropertyChangeListener listener)
Adds a PropertyChangeListener to the listener list. The listener is registered for all bound properties of this class, including the following:
  • whether the KeyboardFocusManager is currently managing focus for this application or applet's browser context ("managingFocus")
  • 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.

param
listener the PropertyChangeListener to be added
see
#removePropertyChangeListener
see
#getPropertyChangeListeners
see
#addPropertyChangeListener(java.lang.String,java.beans.PropertyChangeListener)

        if (listener != null) {
	    synchronized (this) {
	        if (changeSupport == null) {
		    changeSupport = new PropertyChangeSupport(this);
		}
		changeSupport.addPropertyChangeListener(listener);
	    }
	}
    
public voidaddPropertyChangeListener(java.lang.String propertyName, java.beans.PropertyChangeListener listener)
Adds a PropertyChangeListener to the listener list for a specific property. The specified property may be user-defined, or one of the following:
  • whether the KeyboardFocusManager is currently managing focus for this application or applet's browser context ("managingFocus")
  • 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.

param
propertyName one of the property names listed above
param
listener the PropertyChangeListener to be added
see
#addPropertyChangeListener(java.beans.PropertyChangeListener)
see
#removePropertyChangeListener(java.lang.String,java.beans.PropertyChangeListener)
see
#getPropertyChangeListeners(java.lang.String)

        if (listener != null) {
	    synchronized (this) {
	        if (changeSupport == null) {
		    changeSupport = new PropertyChangeSupport(this);
		}
		changeSupport.addPropertyChangeListener(propertyName,
							listener);
	    }
	}
    
public voidaddVetoableChangeListener(java.beans.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.

param
listener the VetoableChangeListener to be added
see
#removeVetoableChangeListener
see
#getVetoableChangeListeners
see
#addVetoableChangeListener(java.lang.String,java.beans.VetoableChangeListener)

        if (listener != null) {
	    synchronized (this) {
	        if (vetoableSupport == null) {
		    vetoableSupport =
			new VetoableChangeSupport(this);
		}
		vetoableSupport.addVetoableChangeListener(listener);
	    }
	}
    
public voidaddVetoableChangeListener(java.lang.String propertyName, java.beans.VetoableChangeListener listener)
Adds a VetoableChangeListener to the listener list for a specific property. The specified property may be user-defined, or one of 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.

param
propertyName one of the property names listed above
param
listener the VetoableChangeListener to be added
see
#addVetoableChangeListener(java.beans.VetoableChangeListener)
see
#removeVetoableChangeListener
see
#getVetoableChangeListeners

        if (listener != null) {
	    synchronized (this) {
	        if (vetoableSupport == null) {
		    vetoableSupport =
			new VetoableChangeSupport(this);
		}
		vetoableSupport.addVetoableChangeListener(propertyName,
							  listener);
	    }
	}
    
public voidclearGlobalFocusOwner()
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
Component#requestFocus()
see
java.awt.event.FocusEvent#FOCUS_LOST

        if (!GraphicsEnvironment.isHeadless()) {
            // Toolkit must be fully initialized, otherwise
            // _clearGlobalFocusOwner will crash or throw an exception
            Toolkit.getDefaultToolkit();

            _clearGlobalFocusOwner();
        }
    
voidclearMarkers()
Clears markers queue This method is not intended to be overridden by KFM's. Only DefaultKeyboardFocusManager can implement it.

since
1.5

    
static voidclearMostRecentFocusOwner(java.awt.Component comp)

        Container window;

        if (comp == null) {
            return;
        }

        synchronized (comp.getTreeLock()) {
            window = comp.getParent();
            while (window != null && !(window instanceof Window)) {
                window = window.getParent();
            }
        }

        synchronized (KeyboardFocusManager.class) {
            if ((window != null) 
                && (getMostRecentFocusOwner((Window)window) == comp)) 
            {
                setMostRecentFocusOwner((Window)window, null);
            }
            // Also clear temporary lost component stored in Window
            if (window != null) {
                Window realWindow = (Window)window;
                if (realWindow.getTemporaryLostComponent() == comp) {
                    realWindow.setTemporaryLostComponent(null);
                }
            }
        }
    
protected abstract voiddequeueKeyEvents(long after, java.awt.Component untilFocused)
Called by the AWT to notify the KeyboardFocusManager that it should cancel delayed dispatching of KeyEvents. All KeyEvents which were enqueued because of a call to 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.

param
after the timestamp specified in the call to enqueueKeyEvents, or any value < 0
param
untilFocused the Component specified in the call to enqueueKeyEvents
see
#enqueueKeyEvents
see
#discardKeyEvents

protected abstract voiddiscardKeyEvents(java.awt.Component comp)
Called by the AWT to notify the KeyboardFocusManager that it should cancel delayed dispatching of KeyEvents. All KeyEvents which were enqueued because of one or more calls to enqueueKeyEvents with the same Component should be discarded.

param
comp the Component specified in one or more calls to enqueueKeyEvents
see
#enqueueKeyEvents
see
#dequeueKeyEvents

private static java.lang.ThrowabledispatchAndCatchException(java.lang.Throwable ex, java.awt.Component comp, java.awt.event.FocusEvent event)

        Throwable retEx = null;
        try {
           comp.dispatchEvent(event);
        } catch (RuntimeException re) {
           retEx = re;
        } catch (Error er) {
           retEx = er;
        }
         if (retEx != null) {
            if (ex != null) {
                handleException(ex);
             }
             return retEx;
           }
           return ex;
      
public abstract booleandispatchEvent(java.awt.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.

param
e the AWTEvent to be dispatched
return
true if this method dispatched the event; false otherwise
see
#redispatchEvent
see
#dispatchKeyEvent

public abstract booleandispatchKeyEvent(java.awt.event.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.

param
e the KeyEvent which the current KeyboardFocusManager has requested that this KeyEventDispatcher dispatch
return
true if the KeyEvent was dispatched; false otherwise
see
#dispatchEvent

public abstract voiddownFocusCycle(java.awt.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.

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

public final voiddownFocusCycle()
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.

        Component focusOwner = getFocusOwner();
	if (focusOwner instanceof Container) {
	    downFocusCycle((Container)focusOwner);
	}
    
voiddumpRequests()
Dumps the list of focus requests to stderr

        System.err.println(">>> Requests dump, time: " + System.currentTimeMillis());
        synchronized (heavyweightRequests) {
            Iterator iter = heavyweightRequests.iterator();
            while (iter.hasNext()) {
                HeavyweightFocusRequest req = (HeavyweightFocusRequest)iter.next();
                System.err.println(">>> Req: " + req);
            }
        }
        System.err.println("");
    
protected abstract voidenqueueKeyEvents(long after, java.awt.Component untilFocused)
Called by the AWT to notify the KeyboardFocusManager that it should delay dispatching of KeyEvents until the specified Component becomes the focus owner. If client code requests a focus change, and the AWT determines that this request might be granted by the native windowing system, then the AWT will call this method. It is the responsibility of the KeyboardFocusManager to delay dispatching of KeyEvents with timestamps later than the specified time stamp until the specified Component receives a FOCUS_GAINED event, or the AWT cancels the delay request by invoking dequeueKeyEvents or discardKeyEvents.

param
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
param
untilFocused Component which should receive a FOCUS_GAINED event before any pending KeyEvents
see
#dequeueKeyEvents
see
#discardKeyEvents

protected voidfirePropertyChange(java.lang.String propertyName, java.lang.Object oldValue, java.lang.Object newValue)
Fires a PropertyChangeEvent in response to a change in a bound property. The event will be delivered to all registered PropertyChangeListeners. No event will be delivered if oldValue and newValue are the same.

param
propertyName the name of the property that has changed
param
oldValue the property's previous value
param
newValue the property's new value

        if (oldValue == newValue) {
            return;
        }
        PropertyChangeSupport changeSupport = this.changeSupport;
        if (changeSupport != null) {
	    changeSupport.firePropertyChange(propertyName, oldValue, newValue);
	}
    
protected voidfireVetoableChange(java.lang.String propertyName, java.lang.Object oldValue, java.lang.Object newValue)
Fires a PropertyChangeEvent in response to a change in a vetoable property. The event will be delivered to all registered VetoableChangeListeners. If a VetoableChangeListener throws a PropertyVetoException, a new event is fired reverting all VetoableChangeListeners to the old value and the exception is then rethrown. No event will be delivered if oldValue and newValue are the same.

param
propertyName the name of the property that has changed
param
oldValue the property's previous value
param
newValue the property's new value
throws
java.beans.PropertyVetoException if a VetoableChangeListener threw PropertyVetoException

        if (oldValue == newValue) {
            return;
        }
        VetoableChangeSupport vetoableSupport =
	    this.vetoableSupport;
        if (vetoableSupport != null) {
	    vetoableSupport.fireVetoableChange(propertyName, oldValue,
					       newValue);
	}
    
public abstract voidfocusNextComponent(java.awt.Component aComponent)
Focuses the Component after aComponent, typically based on a FocusTraversalPolicy.

param
aComponent the Component that is the basis for the focus traversal operation
see
FocusTraversalPolicy

public final voidfocusNextComponent()
Focuses the Component after the current focus owner.

        Component focusOwner = getFocusOwner();
        if (focusOwner != null) {
            focusNextComponent(focusOwner);
        }
    
public abstract voidfocusPreviousComponent(java.awt.Component aComponent)
Focuses the Component before aComponent, typically based on a FocusTraversalPolicy.

param
aComponent the Component that is the basis for the focus traversal operation
see
FocusTraversalPolicy

public final voidfocusPreviousComponent()
Focuses the Component before the current focus owner.

        Component focusOwner = getFocusOwner();
        if (focusOwner != null) {
            focusPreviousComponent(focusOwner);
        }
    
private static booleanfocusedWindowChanged(java.awt.Component to, java.awt.Component from)

        Window wto = Component.getContainingWindow(to);
        Window wfrom = Component.getContainingWindow(from);
        if (wto == null && wfrom == null) {
            return true;
        }
        if (wto == null) {
            return true;
        }
        if (wfrom == null) {
            return true;
        }
        return (wto != wfrom);
    
public java.awt.WindowgetActiveWindow()
Returns the active Window, if the active Window is in the same context as the calling thread. Only a Frame or a Dialog 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 or Dialog that is an owner of the focused Window.

return
the active Window, or null if the active Window is not a member of the calling thread's context
see
#getGlobalActiveWindow
see
#setGlobalActiveWindow

        synchronized (KeyboardFocusManager.class) {
	    if (activeWindow == null) {
	        return null;
	    }

	    return (activeWindow.appContext == AppContext.getAppContext())
	        ? activeWindow
	        : null;
	}
    
public java.awt.ContainergetCurrentFocusCycleRoot()
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.

This method is intended to be used only by KeyboardFocusManagers and focus implementations. It is not for general client use.

return
the current focus cycle root, or null if the current focus cycle root is not a member of the calling thread's context
see
#getGlobalCurrentFocusCycleRoot
see
#setGlobalCurrentFocusCycleRoot

        synchronized (KeyboardFocusManager.class) {
	    if (currentFocusCycleRoot == null) {
	        return null;
	    }

	    return (currentFocusCycleRoot.appContext ==
		    AppContext.getAppContext())
	        ? currentFocusCycleRoot
	        : null;
	}
    
public static java.awt.KeyboardFocusManagergetCurrentKeyboardFocusManager()
Returns the current KeyboardFocusManager instance for the calling thread's context.

return
this thread's context's KeyboardFocusManager
see
#setCurrentKeyboardFocusManager


                          
        
	return getCurrentKeyboardFocusManager(AppContext.getAppContext());
    
static synchronized java.awt.KeyboardFocusManagergetCurrentKeyboardFocusManager(sun.awt.AppContext appcontext)

        KeyboardFocusManager manager = (KeyboardFocusManager)
            appcontext.get(KeyboardFocusManager.class);
        if (manager == null) {
            manager = new DefaultKeyboardFocusManager();
            appcontext.put(KeyboardFocusManager.class, manager);
        }
        return manager;
    
final java.awt.SequencedEventgetCurrentSequencedEvent()

        synchronized (SequencedEvent.class) {
            return currentSequencedEvent;
        }
    
java.awt.ComponentgetCurrentWaitingRequest(java.awt.Component parent)

        synchronized (heavyweightRequests) {
            HeavyweightFocusRequest hwFocusRequest = (HeavyweightFocusRequest)
                ((heavyweightRequests.size() > 0)
                 ? heavyweightRequests.getFirst() : null);
            if (hwFocusRequest != null) {
                if (hwFocusRequest.heavyweight == parent) {
                    LightweightFocusRequest lwFocusRequest =
                        (LightweightFocusRequest)hwFocusRequest.
                        lightweightRequests.getFirst();
                    if (lwFocusRequest != null) {
                        return lwFocusRequest.component;
                    }
                }
            }
        }
        return null;
    
public java.util.SetgetDefaultFocusTraversalKeys(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.)

param
id one of KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS, KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS, KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS, or KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYS
return
the Set of AWTKeyStrokes for the specified operation; the Set will be unmodifiable, and may be empty; null will never be returned
see
#setDefaultFocusTraversalKeys
see
Component#setFocusTraversalKeys
see
Component#getFocusTraversalKeys
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

        if (id < 0 || id >= TRAVERSAL_KEY_LENGTH) {
            throw new IllegalArgumentException("invalid focus traversal key identifier");
        }
            
	// Okay to return Set directly because it is an unmodifiable view
	return defaultFocusTraversalKeys[id];
    
public synchronized java.awt.FocusTraversalPolicygetDefaultFocusTraversalPolicy()
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.

return
the default FocusTraversalPolicy. null will never be returned.
see
#setDefaultFocusTraversalPolicy
see
Container#setFocusTraversalPolicy
see
Container#getFocusTraversalPolicy

        return defaultPolicy;
    
public java.awt.ComponentgetFocusOwner()
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.

return
the focus owner, or null if the focus owner is not a member of the calling thread's context
see
#getGlobalFocusOwner
see
#setGlobalFocusOwner

        synchronized (KeyboardFocusManager.class) {
	    if (focusOwner == null) {
	        return null;
	    }

	    return (focusOwner.appContext == AppContext.getAppContext())
	        ? focusOwner
	        : null;
	}
    
public java.awt.WindowgetFocusedWindow()
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.

return
the focused Window, or null if the focused Window is not a member of the calling thread's context
see
#getGlobalFocusedWindow
see
#setGlobalFocusedWindow

        synchronized (KeyboardFocusManager.class) {
	    if (focusedWindow == null) {
	        return null;
	    }

	    return (focusedWindow.appContext == AppContext.getAppContext())
	        ? focusedWindow
	        : null;
	}
    
protected java.awt.WindowgetGlobalActiveWindow()
Returns the active Window, even if the calling thread is in a different context than the active Window. Only a Frame or a Dialog 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 or Dialog that is an owner of the focused Window.

This method will throw a SecurityException if this KeyboardFocusManager is not the current KeyboardFocusManager for the calling thread's context.

return
the active Window
see
#getActiveWindow
see
#setGlobalActiveWindow
throws
SecurityException if this KeyboardFocusManager is not the current KeyboardFocusManager for the calling thread's context

        synchronized (KeyboardFocusManager.class) {
	    if (this == getCurrentKeyboardFocusManager()) {
	       return activeWindow;
	    } else {
                if (focusLog.isLoggable(Level.FINE)) focusLog.fine("This manager is " + this + ", current is " + getCurrentKeyboardFocusManager());
		throw new SecurityException(notPrivileged);
	    }
	}
    
protected java.awt.ContainergetGlobalCurrentFocusCycleRoot()
Returns the current focus cycle root, even if the calling thread is in a different context than the current focus cycle root. 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.

This method will throw a SecurityException if this KeyboardFocusManager is not the current KeyboardFocusManager for the calling thread's context.

return
the current focus cycle root, or null if the current focus cycle root is not a member of the calling thread's context
see
#getCurrentFocusCycleRoot
see
#setGlobalCurrentFocusCycleRoot
throws
SecurityException if this KeyboardFocusManager is not the current KeyboardFocusManager for the calling thread's context

        synchronized (KeyboardFocusManager.class) {
	    if (this == getCurrentKeyboardFocusManager()) {
	        return currentFocusCycleRoot;
	    } else {
                if (focusLog.isLoggable(Level.FINE)) focusLog.fine("This manager is " + this + ", current is " + getCurrentKeyboardFocusManager());
	        throw new SecurityException(notPrivileged);
	    }
	}
    
protected java.awt.ComponentgetGlobalFocusOwner()
Returns the focus owner, even if the calling thread is in a different context than the focus owner. 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.

This method will throw a SecurityException if this KeyboardFocusManager is not the current KeyboardFocusManager for the calling thread's context.

return
the focus owner
see
#getFocusOwner
see
#setGlobalFocusOwner
throws
SecurityException if this KeyboardFocusManager is not the current KeyboardFocusManager for the calling thread's context

        synchronized (KeyboardFocusManager.class) {
	    if (this == getCurrentKeyboardFocusManager()) {
	        return focusOwner;
	    } else {
                if (focusLog.isLoggable(Level.FINE)) focusLog.fine("This manager is " + this + ", current is " + getCurrentKeyboardFocusManager());
	        throw new SecurityException(notPrivileged);
	    }
	}
    
protected java.awt.WindowgetGlobalFocusedWindow()
Returns the focused Window, even if the calling thread is in a different context than the focused Window. The focused Window is the Window that is or contains the focus owner.

This method will throw a SecurityException if this KeyboardFocusManager is not the current KeyboardFocusManager for the calling thread's context.

return
the focused Window
see
#getFocusedWindow
see
#setGlobalFocusedWindow
throws
SecurityException if this KeyboardFocusManager is not the current KeyboardFocusManager for the calling thread's context

        synchronized (KeyboardFocusManager.class) {
	    if (this == getCurrentKeyboardFocusManager()) {
	       return focusedWindow;
	    } else {
                if (focusLog.isLoggable(Level.FINE)) focusLog.fine("This manager is " + this + ", current is " + getCurrentKeyboardFocusManager());
	        throw new SecurityException(notPrivileged);
	    }
	}
    
protected java.awt.ComponentgetGlobalPermanentFocusOwner()
Returns the permanent focus owner, even if the calling thread is in a different context than the permanent focus owner. 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.

This method will throw a SecurityException if this KeyboardFocusManager is not the current KeyboardFocusManager for the calling thread's context.

return
the permanent focus owner
see
#getPermanentFocusOwner
see
#setGlobalPermanentFocusOwner
throws
SecurityException if this KeyboardFocusManager is not the current KeyboardFocusManager for the calling thread's context

	synchronized (KeyboardFocusManager.class) {
	    if (this == getCurrentKeyboardFocusManager()) {
		return permanentFocusOwner;
	    } else {
                if (focusLog.isLoggable(Level.FINE)) focusLog.fine("This manager is " + this + ", current is " + getCurrentKeyboardFocusManager());
		throw new SecurityException(notPrivileged);
	    }
	}
    
static java.awt.ComponentgetHeavyweight(java.awt.Component comp)

        if (comp == null || comp.getPeer() == null) {
            return null;
        } else if (comp.getPeer() instanceof LightweightPeer) {
            return comp.getNativeContainer();
        } else {
            return comp;
        }
    
protected synchronized java.util.ListgetKeyEventDispatchers()
Returns this KeyboardFocusManager's KeyEventDispatcher chain as a List. The List will not include this KeyboardFocusManager unless it was explicitly re-registered via a call to 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.

return
a possibly null or empty List of KeyEventDispatchers
see
#addKeyEventDispatcher
see
#removeKeyEventDispatcher

        return (keyEventDispatchers != null)
	    ? (java.util.List)keyEventDispatchers.clone()
	    : null;
    
protected java.util.ListgetKeyEventPostProcessors()
Returns this KeyboardFocusManager's KeyEventPostProcessor chain as a List. The List will not include this KeyboardFocusManager unless it was explicitly added via a call to 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.

return
a possibly null or empty List of KeyEventPostProcessors
see
#addKeyEventPostProcessor
see
#removeKeyEventPostProcessor

        return (keyEventPostProcessors != null)
            ? (java.util.List)keyEventPostProcessors.clone()
            : null;
    
static synchronized java.awt.ComponentgetMostRecentFocusOwner(java.awt.Window window)

        WeakReference weakValue =
            (WeakReference)mostRecentFocusOwners.get(window);
        return weakValue == null ? null : (Component)weakValue.get();
    
java.awt.ComponentgetNativeFocusOwner()

        return peer.getCurrentFocusOwner();
    
java.awt.WindowgetNativeFocusedWindow()

        return peer.getCurrentFocusedWindow();
    
public java.awt.ComponentgetPermanentFocusOwner()
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.

return
the permanent focus owner, or null if the permanent focus owner is not a member of the calling thread's context
see
#getGlobalPermanentFocusOwner
see
#setGlobalPermanentFocusOwner

	synchronized (KeyboardFocusManager.class) {
	    if (permanentFocusOwner == null) {
		return null;
	    }

	    return (permanentFocusOwner.appContext ==
		    AppContext.getAppContext())
		? permanentFocusOwner
		: null;
	}
    
public synchronized java.beans.PropertyChangeListener[]getPropertyChangeListeners()
Returns an array of all the property change listeners registered on this keyboard focus manager.

return
all of this keyboard focus manager's PropertyChangeListeners or an empty array if no property change listeners are currently registered
see
#addPropertyChangeListener
see
#removePropertyChangeListener
see
#getPropertyChangeListeners(java.lang.String)
since
1.4

        if (changeSupport == null) {
            changeSupport = new PropertyChangeSupport(this);
        }
        return changeSupport.getPropertyChangeListeners();
    
public synchronized java.beans.PropertyChangeListener[]getPropertyChangeListeners(java.lang.String propertyName)
Returns an array of all the PropertyChangeListeners associated with the named property.

return
all of the PropertyChangeListeners associated with the named property or an empty array if no such listeners have been added.
see
#addPropertyChangeListener(java.lang.String,java.beans.PropertyChangeListener)
see
#removePropertyChangeListener(java.lang.String,java.beans.PropertyChangeListener)
since
1.4

        if (changeSupport == null) {
            changeSupport = new PropertyChangeSupport(this);
        }
        return changeSupport.getPropertyChangeListeners(propertyName);
    
public synchronized java.beans.VetoableChangeListener[]getVetoableChangeListeners()
Returns an array of all the vetoable change listeners registered on this keyboard focus manager.

return
all of this keyboard focus manager's VetoableChangeListeners or an empty array if no vetoable change listeners are currently registered
see
#addVetoableChangeListener
see
#removeVetoableChangeListener
see
#getVetoableChangeListeners(java.lang.String)
since
1.4

        if (vetoableSupport == null) {
            vetoableSupport = new VetoableChangeSupport(this);
        }
        return vetoableSupport.getVetoableChangeListeners();
    
public synchronized java.beans.VetoableChangeListener[]getVetoableChangeListeners(java.lang.String propertyName)
Returns an array of all the VetoableChangeListeners associated with the named property.

return
all of the VetoableChangeListeners associated with the named property or an empty array if no such listeners have been added.
see
#addVetoableChangeListener(java.lang.String,java.beans.VetoableChangeListener)
see
#removeVetoableChangeListener(java.lang.String,java.beans.VetoableChangeListener)
see
#getVetoableChangeListeners
since
1.4

        if (vetoableSupport == null) {
            vetoableSupport = new VetoableChangeSupport(this);
        }
        return vetoableSupport.getVetoableChangeListeners(propertyName);
    
private static voidhandleException(java.lang.Throwable ex)

                ex.printStackTrace();
       
static booleanhasFocusRequests()

        synchronized (heavyweightRequests) {
            return heavyweightRequests.size() > 0;
        }
    
static voidheavyweightButtonDown(java.awt.Component heavyweight, long time)

        heavyweightButtonDown(heavyweight, time, false);
    
static voidheavyweightButtonDown(java.awt.Component heavyweight, long time, boolean acceptDuplicates)

        if (dbg.on) {
            dbg.assertion(heavyweight != null);
            dbg.assertion(time != 0);
        }
        KeyboardFocusManager manager = getCurrentKeyboardFocusManager(SunToolkit.targetToAppContext(heavyweight));
        
        synchronized (heavyweightRequests) {
            HeavyweightFocusRequest hwFocusRequest = (HeavyweightFocusRequest)
                ((heavyweightRequests.size() > 0)
                 ? heavyweightRequests.getLast() : null);
            Component currentNativeFocusOwner = (hwFocusRequest == null)
                ? manager.getNativeFocusOwner()
                : hwFocusRequest.heavyweight;
                
            // Behavior for all use cases:
            // 1. Heavyweight leaf Components (e.g., Button, Checkbox, Choice,
            //    List, TextComponent, Canvas) that respond to button down.
            //
            //    Native platform will generate a FOCUS_GAINED if and only if
            //    the Component is not the focus owner (or, will not be the
            //    focus owner when all outstanding focus requests are
            //    processed).
            //
            // 2. Panel with no descendants.
            //
            //    Same as (1).
            //
            // 3. Panel with at least one heavyweight descendant.
            //
            //    This function should NOT be called for this case!
            //
            // 4. Panel with only lightweight descendants.
            //
            //    Native platform will generate a FOCUS_GAINED if and only if
            //    neither the Panel, nor any of its recursive, lightweight
            //    descendants, is the focus owner. However, we want a
            //    requestFocus() for any lightweight descendant to win out over
            //    the focus request for the Panel. To accomplish this, we
            //    differ from the algorithm for shouldNativelyFocusHeavyweight
            //    as follows:
            //      a. If the requestFocus() for a lightweight descendant has
            //         been fully handled by the time this function is invoked,
            //         then 'hwFocusRequest' will be null and 'heavyweight'
            //         will be the native focus owner. Do *not* synthesize a
            //         focus transfer to the Panel.
            //      b. If the requestFocus() for a lightweight descendant has
            //         been recorded, but not handled, then 'hwFocusRequest'
            //         will be non-null and 'hwFocusRequest.heavyweight' will
            //         equal 'heavyweight'. Do *not* append 'heavyweight' to
            //         hwFocusRequest.lightweightRequests.
            //      c. If the requestFocus() for a lightweight descendant is
            //         yet to be made, then post a new HeavyweightFocusRequest.
            //         If no lightweight descendant ever requests focus, then
            //         the Panel will get focus. If some descendant does, then
            //         the descendant will get focus by either a synthetic
            //         focus transfer, or a lightweightRequests focus transfer.

            if (acceptDuplicates || heavyweight != currentNativeFocusOwner) {
                getCurrentKeyboardFocusManager
                    (SunToolkit.targetToAppContext(heavyweight)).
                    enqueueKeyEvents(time, heavyweight);
                heavyweightRequests.add
                    (new HeavyweightFocusRequest(heavyweight, heavyweight,
                                                 false, CausedFocusEvent.Cause.MOUSE_EVENT));
            }
        }
    
static java.util.SetinitFocusTraversalKeysSet(java.lang.String value, java.util.Set targetSet)

	StringTokenizer tokens = new StringTokenizer(value, ",");
	while (tokens.hasMoreTokens()) {
	    targetSet.add(AWTKeyStroke.getAWTKeyStroke(tokens.nextToken()));
	}
	return (targetSet.isEmpty())
	    ? Collections.EMPTY_SET
	    : Collections.unmodifiableSet(targetSet);
    
private static native voidinitIDs()
Initialize JNI field and method IDs

private voidinitPeer()

        if (Toolkit.getDefaultToolkit() instanceof HeadlessToolkit){
            peer = ((HeadlessToolkit)Toolkit.getDefaultToolkit()).createKeyboardFocusManagerPeer(this);
        }
        if (Toolkit.getDefaultToolkit() instanceof SunToolkit){        
            peer = ((SunToolkit)Toolkit.getDefaultToolkit()).createKeyboardFocusManagerPeer(this);                  
        }
    
static booleanisProxyActive(java.awt.event.KeyEvent e)

        if (!GraphicsEnvironment.isHeadless()) {
            return isProxyActiveImpl(e);
        } else {
            return false;
        }
    
private static booleanisProxyActiveImpl(java.awt.event.KeyEvent e)

        if (proxyActive == null) {
            proxyActive = (Field) AccessController.doPrivileged(new PrivilegedAction() {
                    public Object run() {
                        Field field = null;
                        try {
                            field = KeyEvent.class.getDeclaredField("isProxyActive");
                            if (field != null) {
                                field.setAccessible(true);
                            }
                        } catch (NoSuchFieldException nsf) {
                            assert(false);
                        }
                        return field;
                    }
                });
        }

        try {
            return proxyActive.getBoolean(e);
        } catch (IllegalAccessException iae) {
            assert(false);
        }
        return false;
    
private static booleanisTemporary(java.awt.Component to, java.awt.Component from)

        Window wto = Component.getContainingWindow(to);
        Window wfrom = Component.getContainingWindow(from);
        if (wto == null && wfrom == null) {
            return false;
        }
        if (wto == null) {
            return true;
        }
        if (wfrom == null) {
            return false;
        }
        return (wto != wfrom);
    
static java.awt.WindowmarkClearGlobalFocusOwner()
Returns the Window which will be active after processing this request, or null if this is a duplicate request. The active Window is useful because some native platforms do not support setting the native focus owner to null. On these platforms, the obvious choice is to set the focus owner to the focus proxy of the active Window.

        synchronized (heavyweightRequests) {
            HeavyweightFocusRequest hwFocusRequest = (HeavyweightFocusRequest)
                ((heavyweightRequests.size() > 0)
                 ? heavyweightRequests.getLast() : null);
            if (hwFocusRequest ==
                HeavyweightFocusRequest.CLEAR_GLOBAL_FOCUS_OWNER)
            {
                // duplicate request
                return null;
            }
            
            KeyboardFocusManager manager = getCurrentKeyboardFocusManager();
            heavyweightRequests.add
                (HeavyweightFocusRequest.CLEAR_GLOBAL_FOCUS_OWNER);

            Component activeWindow = ((hwFocusRequest != null)
                ? Component.getContainingWindow(hwFocusRequest.heavyweight)
                : manager.getNativeFocusedWindow());
            while (activeWindow != null &&
                   !((activeWindow instanceof Frame) ||
                     (activeWindow instanceof Dialog)))
            {
                activeWindow = activeWindow.getParent();
            }

            return (Window)activeWindow;
        }
    
public abstract booleanpostProcessKeyEvent(java.awt.event.KeyEvent e)
This method will be called by dispatchKeyEvent. By default, this method will handle any unconsumed KeyEvents that map to an AWT MenuShortcut by consuming the event and activating the shortcut.

param
e the KeyEvent to post-process
return
true to indicate that no other KeyEventPostProcessor will be notified of the KeyEvent.
see
#dispatchKeyEvent
see
MenuShortcut

static voidprocessCurrentLightweightRequests()

        KeyboardFocusManager manager = getCurrentKeyboardFocusManager();
        LinkedList localLightweightRequests = null;

        Component globalFocusOwner = manager.getGlobalFocusOwner();
        if ((globalFocusOwner != null) &&
            (globalFocusOwner.appContext != AppContext.getAppContext()))
        {
            // The current app context differs from the app context of a focus
            // owner (and all pending lightweight requests), so we do nothing
            // now and wait for a next event.
            return;
        }

        synchronized(heavyweightRequests) {
            if (currentLightweightRequests != null) {
                clearingCurrentLightweightRequests = true;
                disableRestoreFocus=true;
                localLightweightRequests = currentLightweightRequests;
                allowSyncFocusRequests = (localLightweightRequests.size() < 2);
                currentLightweightRequests = null;
            } else {
                // do nothing
                return;
            }
        }

        Throwable caughtEx=null;
        try {
            if (localLightweightRequests != null) {
               Component lastFocusOwner = null;
               Component currentFocusOwner = null;

               for (Iterator iter = localLightweightRequests.iterator(); iter.hasNext(); )
               {
                    currentFocusOwner = manager.getGlobalFocusOwner();
                    LightweightFocusRequest lwFocusRequest = (LightweightFocusRequest)iter.next();
                    /*
                     * WARNING: This is based on DKFM's logic solely!
                     *
                     * We allow to trigger restoreFocus() in the dispatching process
                     * only if we have the last request to dispatch. If the last request
                     * fails, focus will be restored to either the component of the last
                     * previously succedded request, or to to the focus owner that was
                     * before this clearing proccess.
                     */
                     if (!iter.hasNext()) {
                           disableRestoreFocus = false;
                     }

                    FocusEvent currentFocusOwnerEvent = null;
                    if ( currentFocusOwner != null ){  
                       currentFocusOwnerEvent = new CausedFocusEvent(currentFocusOwner,
                                       FocusEvent.FOCUS_LOST,
                                       lwFocusRequest.temporary,
                                       lwFocusRequest.component, lwFocusRequest.cause);
                    }
                    
                    FocusEvent newFocusOwnerEvent =
                        new CausedFocusEvent(lwFocusRequest.component,
                                       FocusEvent.FOCUS_GAINED,
                                       lwFocusRequest.temporary,
                                       currentFocusOwner == null? lastFocusOwner : currentFocusOwner, lwFocusRequest.cause);

                    if (currentFocusOwner != null){
                         ((AWTEvent) currentFocusOwnerEvent).isPosted = true;
                          caughtEx=dispatchAndCatchException(caughtEx,currentFocusOwner,currentFocusOwnerEvent);
                    }
                    ((AWTEvent) newFocusOwnerEvent).isPosted = true;
                    caughtEx=dispatchAndCatchException(caughtEx, lwFocusRequest.component, newFocusOwnerEvent);
 
                    if (manager.getGlobalFocusOwner() == lwFocusRequest.component){
                        lastFocusOwner = lwFocusRequest.component;
                    }
                }        
            }
        } finally {
            clearingCurrentLightweightRequests = false;
            disableRestoreFocus=false;
            localLightweightRequests = null;
            allowSyncFocusRequests = true;
        }
 
        if (caughtEx instanceof RuntimeException) {
            throw (RuntimeException)caughtEx;
        } else if (caughtEx instanceof Error) {
            throw (Error)caughtEx;
        }

    
public abstract voidprocessKeyEvent(java.awt.Component focusedComponent, java.awt.event.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.

param
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
param
e the event that may represent a focus traversal key

static booleanprocessSynchronousLightweightTransfer(java.awt.Component heavyweight, java.awt.Component descendant, boolean temporary, boolean focusedWindowChangeAllowed, long time)


         
                                                     
                                                   
    
        Window parentWindow = Component.getContainingWindow(heavyweight);
        if (parentWindow == null || !parentWindow.syncLWRequests) {
            return false;
        }
        if (descendant == null) {
            // Focus transfers from a lightweight child back to the
            // heavyweight Container should be treated like lightweight
            // focus transfers.
            descendant = heavyweight;
        }

        KeyboardFocusManager manager = getCurrentKeyboardFocusManager(SunToolkit.targetToAppContext(descendant));

        FocusEvent currentFocusOwnerEvent = null;
        FocusEvent newFocusOwnerEvent = null;
        Component currentFocusOwner = manager.getGlobalFocusOwner();

        synchronized (heavyweightRequests) {
            HeavyweightFocusRequest hwFocusRequest = (HeavyweightFocusRequest)
                ((heavyweightRequests.size() > 0)
                 ? heavyweightRequests.getLast() : null);
            if (hwFocusRequest == null &&
                heavyweight == manager.getNativeFocusOwner() &&
                allowSyncFocusRequests)
            {

                if (descendant == currentFocusOwner) {
                    // Redundant request.
                    return true;
                }

                // 'heavyweight' owns the native focus and there are no pending
                // requests. 'heavyweight' must be a Container and
                // 'descendant' must not be the focus owner. Otherwise,
                // we would never have gotten this far.
                manager.enqueueKeyEvents(time, descendant);

                hwFocusRequest =
                    new HeavyweightFocusRequest(heavyweight, descendant,
                                                temporary, CausedFocusEvent.Cause.UNKNOWN);
                heavyweightRequests.add(hwFocusRequest);

                if (currentFocusOwner != null) {
                    currentFocusOwnerEvent =
                        new FocusEvent(currentFocusOwner,
                                       FocusEvent.FOCUS_LOST,
                                       temporary, descendant);
                }
                newFocusOwnerEvent =
                    new FocusEvent(descendant, FocusEvent.FOCUS_GAINED,
                                   temporary, currentFocusOwner);
            }
        }
        boolean result = false;
        final boolean clearing = clearingCurrentLightweightRequests;
        Throwable caughtEx = null;
        try {
            clearingCurrentLightweightRequests = false;
            synchronized(Component.LOCK) {
                if (currentFocusOwnerEvent != null && currentFocusOwner != null) {
                    ((AWTEvent) currentFocusOwnerEvent).isPosted = true;
                    caughtEx=dispatchAndCatchException(caughtEx, currentFocusOwner, currentFocusOwnerEvent);
                    result = true;
                }
                if (newFocusOwnerEvent != null && descendant != null) {
                    ((AWTEvent) newFocusOwnerEvent).isPosted = true;
                    caughtEx=dispatchAndCatchException(caughtEx, descendant, newFocusOwnerEvent);
                    result = true;
                }
            }
        } finally {
            clearingCurrentLightweightRequests = clearing;
        }
 
        if (caughtEx instanceof RuntimeException){
            throw (RuntimeException) caughtEx;
        } else if (caughtEx instanceof Error) {
            throw (Error) caughtEx;
        }


        return result;
    
public final voidredispatchEvent(java.awt.Component target, java.awt.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.

param
target the Component to which the event should be dispatched
param
e the event to dispatch
see
#dispatchEvent
see
KeyEventDispatcher

        e.focusManagerIsDispatching = true;
	target.dispatchEvent(e);
        e.focusManagerIsDispatching = false;
    
static booleanremoveFirstRequest()

        KeyboardFocusManager manager =
            KeyboardFocusManager.getCurrentKeyboardFocusManager();

        synchronized(heavyweightRequests) {
            HeavyweightFocusRequest hwFocusRequest = (HeavyweightFocusRequest)

                ((heavyweightRequests.size() > 0) 
                 ? heavyweightRequests.getFirst() : null);
            if (hwFocusRequest != null) {
                heavyweightRequests.removeFirst();
                if (hwFocusRequest.lightweightRequests != null) {
                    for (Iterator lwIter = hwFocusRequest.lightweightRequests.
                             iterator();
                         lwIter.hasNext(); )
                    {
                        manager.dequeueKeyEvents
                            (-1, ((LightweightFocusRequest)lwIter.next()).
                             component);
                    }
                }
            }
            // Fix for 4799136 - clear type-ahead markers if requests queue is empty
            // We do it here because this method is called only when problems happen 
            if (heavyweightRequests.size() == 0) {
                manager.clearMarkers();
            }
            return (heavyweightRequests.size() > 0);
        }        
    
public voidremoveKeyEventDispatcher(java.awt.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.

In a multithreaded application, {@link KeyEventDispatcher} behaves the same as other AWT listeners. See AWT Threading Issues for more details.

param
dispatcher the KeyEventDispatcher to remove from the dispatcher chain
see
#addKeyEventDispatcher

        if (dispatcher != null) {
	    synchronized (this) {
	        if (keyEventDispatchers != null) {
		    keyEventDispatchers.remove(dispatcher);
		}
	    }
	}
    
public voidremoveKeyEventPostProcessor(java.awt.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.

In a multithreaded application, {@link KeyEventPostProcessor} behaves the same as other AWT listeners. See AWT Threading Issues for more details.

param
processor the KeyEventPostProcessor to remove from the post- processor chain
see
#addKeyEventPostProcessor

        if (processor != null) {
            synchronized (this) {
                if (keyEventPostProcessors != null) {
                    keyEventPostProcessors.remove(processor);
                }
            }
        }
    
static voidremoveLastFocusRequest(java.awt.Component heavyweight)

        if (dbg.on) {
            dbg.assertion(heavyweight != null);
        }

        KeyboardFocusManager manager =
            KeyboardFocusManager.getCurrentKeyboardFocusManager();
        synchronized(heavyweightRequests) {
            HeavyweightFocusRequest hwFocusRequest = (HeavyweightFocusRequest)
                ((heavyweightRequests.size() > 0) 
                 ? heavyweightRequests.getLast() : null);
            if (hwFocusRequest != null && 
                hwFocusRequest.heavyweight == heavyweight) {
                heavyweightRequests.removeLast();
            }
            // Fix for 4799136 - clear type-ahead markers if requests queue is empty
            // We do it here because this method is called only when problems happen 
            if (heavyweightRequests.size() == 0) {
                manager.clearMarkers();
            }
        }
    
public voidremovePropertyChangeListener(java.beans.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.

param
listener the PropertyChangeListener to be removed
see
#addPropertyChangeListener
see
#getPropertyChangeListeners
see
#removePropertyChangeListener(java.lang.String,java.beans.PropertyChangeListener)

        if (listener != null) {
	    synchronized (this) {
	        if (changeSupport != null) {
		    changeSupport.removePropertyChangeListener(listener);
		}
	    }
	}
    
public voidremovePropertyChangeListener(java.lang.String propertyName, java.beans.PropertyChangeListener listener)
Removes a PropertyChangeListener from the listener list for a specific property. This method should be used to remove PropertyChangeListeners that were registered for a specific bound property.

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

param
propertyName a valid property name
param
listener the PropertyChangeListener to be removed
see
#addPropertyChangeListener(java.lang.String,java.beans.PropertyChangeListener)
see
#getPropertyChangeListeners(java.lang.String)
see
#removePropertyChangeListener(java.beans.PropertyChangeListener)

        if (listener != null) {
	    synchronized (this) {
	        if (changeSupport != null) {
		    changeSupport.removePropertyChangeListener(propertyName,
							       listener);
		}
	    }
	}
    
public voidremoveVetoableChangeListener(java.beans.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.

param
listener the VetoableChangeListener to be removed
see
#addVetoableChangeListener
see
#getVetoableChangeListeners
see
#removeVetoableChangeListener(java.lang.String,java.beans.VetoableChangeListener)

        if (listener != null) {
	    synchronized (this) {
	        if (vetoableSupport != null) {
		    vetoableSupport.removeVetoableChangeListener(listener);
		}
	    }
	}
    
public voidremoveVetoableChangeListener(java.lang.String propertyName, java.beans.VetoableChangeListener listener)
Removes a VetoableChangeListener from the listener list for a specific property. This method should be used to remove VetoableChangeListeners that were registered for a specific bound property.

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

param
propertyName a valid property name
param
listener the VetoableChangeListener to be removed
see
#addVetoableChangeListener
see
#getVetoableChangeListeners
see
#removeVetoableChangeListener(java.beans.VetoableChangeListener)

        if (listener != null) {
	    synchronized (this) {
	        if (vetoableSupport != null) {
		    vetoableSupport.removeVetoableChangeListener(propertyName,
								 listener);
		}
	    }
	}
    
static java.awt.AWTEventretargetFocusEvent(java.awt.AWTEvent event)

        if (clearingCurrentLightweightRequests) {
            return event;
        }        

        KeyboardFocusManager manager = getCurrentKeyboardFocusManager();
        if (focusLog.isLoggable(Level.FINE)) {
            if (event instanceof FocusEvent || event instanceof WindowEvent) {
                focusLog.log(Level.FINE, ">>> {0}", new Object[] {event});
            }
            if (focusLog.isLoggable(Level.FINER) && event instanceof KeyEvent) {
                focusLog.log(Level.FINER, "    focus owner is {0}", new Object[] {manager.getGlobalFocusOwner()});
                focusLog.log(Level.FINER, ">>> {0}", new Object[] {event});
            }
        }

        synchronized(heavyweightRequests) {
            /*
             * This code handles FOCUS_LOST event which is generated by 
             * DefaultKeyboardFocusManager for FOCUS_GAINED.
             *
             * This code based on knowledge of DefaultKeyboardFocusManager's
             * implementation and might be not applicable for another 
             * KeyboardFocusManager.
             * 
             * Fix for 4472032
             */
            if (newFocusOwner != null &&
                event.getID() == FocusEvent.FOCUS_LOST) 
            {
                FocusEvent fe = (FocusEvent)event;

                if (manager.getGlobalFocusOwner() == fe.getComponent() &&
                    fe.getOppositeComponent() == newFocusOwner) 
                {
                    newFocusOwner = null;
                    return event;
                }
            }
        }

        processCurrentLightweightRequests();

        switch (event.getID()) {
            case FocusEvent.FOCUS_GAINED: {
                event = retargetFocusGained((FocusEvent)event);
                break;
            }
            case FocusEvent.FOCUS_LOST: {
                event = retargetFocusLost((FocusEvent)event);
                break;
            }
            default:
                /* do nothing */
        }
        return event;
    
static java.awt.event.FocusEventretargetFocusGained(java.awt.event.FocusEvent fe)

        assert (fe.getID() == FocusEvent.FOCUS_GAINED);

        Component currentFocusOwner = getCurrentKeyboardFocusManager().
            getGlobalFocusOwner();
        Component source = fe.getComponent();
        Component opposite = fe.getOppositeComponent();
        Component nativeSource = getHeavyweight(source);

        synchronized (heavyweightRequests) {
            HeavyweightFocusRequest hwFocusRequest = (HeavyweightFocusRequest)
                ((heavyweightRequests.size() > 0)
                 ? heavyweightRequests.getFirst() : null);

            if (hwFocusRequest == HeavyweightFocusRequest.CLEAR_GLOBAL_FOCUS_OWNER)
            {
                return retargetUnexpectedFocusEvent(fe);
            }

            if (source != null && nativeSource == null && hwFocusRequest != null) {
                // if source w/o peer and 
                // if source is equal to first lightweight
                // then we should correct source and nativeSource
                if (source == hwFocusRequest.getFirstLightweightRequest().component) 
                {
                    source = hwFocusRequest.heavyweight;
                    nativeSource = source; // source is heavuweight itself
                }
            }
            if (hwFocusRequest != null &&
                nativeSource == hwFocusRequest.heavyweight)
            {
                // Focus change as a result of a known call to requestFocus(),
                // or known click on a peer focusable heavyweight Component.

                heavyweightRequests.removeFirst();

                LightweightFocusRequest lwFocusRequest =
                    (LightweightFocusRequest)hwFocusRequest.
                    lightweightRequests.removeFirst();

                Component newSource = lwFocusRequest.component;
                if (currentFocusOwner != null) {
                    /*
                     * Since we receive FOCUS_GAINED when current focus 
                     * owner is not null, correcponding FOCUS_LOST is supposed
                     * to be lost.  And so,  we keep new focus owner 
                     * to determine synthetic FOCUS_LOST event which will be 
                     * generated by KeyboardFocusManager for this FOCUS_GAINED.
                     *
                     * This code based on knowledge of 
                     * DefaultKeyboardFocusManager's implementation and might 
                     * be not applicable for another KeyboardFocusManager.
                     */
                    newFocusOwner = newSource;
                }

                boolean temporary = (opposite == null || 
                                     isTemporary(newSource, opposite))
                        ? false
                        : lwFocusRequest.temporary;

                if (hwFocusRequest.lightweightRequests.size() > 0) {
                    currentLightweightRequests =
                        hwFocusRequest.lightweightRequests;
                    EventQueue.invokeLater(new Runnable() {
                            public void run() {
                                processCurrentLightweightRequests();
                            }
                        });
                }

                // 'opposite' will be fixed by
                // DefaultKeyboardFocusManager.realOppositeComponent
                return new CausedFocusEvent(newSource,
                                      FocusEvent.FOCUS_GAINED, temporary,
                                      opposite, lwFocusRequest.cause);
            }

            if (currentFocusOwner != null
                && currentFocusOwner.getContainingWindow() == source
                && (hwFocusRequest == null || source != hwFocusRequest.heavyweight)) 
            {
                // Special case for FOCUS_GAINED in top-levels
                // If it arrives as the result of activation we should skip it
                // This event will not have appropriate request record and
                // on arrival there will be already some focus owner set.
                return new CausedFocusEvent(currentFocusOwner, FocusEvent.FOCUS_GAINED, false, 
                                            null, CausedFocusEvent.Cause.ACTIVATION);
            }

            return retargetUnexpectedFocusEvent(fe);
        } // end synchronized(heavyweightRequests)
    
static java.awt.event.FocusEventretargetFocusLost(java.awt.event.FocusEvent fe)

        assert (fe.getID() == FocusEvent.FOCUS_LOST);

        Component currentFocusOwner = getCurrentKeyboardFocusManager().
            getGlobalFocusOwner();
        Component opposite = fe.getOppositeComponent();
        Component nativeOpposite = getHeavyweight(opposite);

        synchronized (heavyweightRequests) {
            HeavyweightFocusRequest hwFocusRequest = (HeavyweightFocusRequest)
                ((heavyweightRequests.size() > 0)
                 ? heavyweightRequests.getFirst() : null);

            if (hwFocusRequest == HeavyweightFocusRequest.CLEAR_GLOBAL_FOCUS_OWNER)
            {
                if (currentFocusOwner != null) {
                    // Call to KeyboardFocusManager.clearGlobalFocusOwner()
                    heavyweightRequests.removeFirst();
                    return new CausedFocusEvent(currentFocusOwner,
                                                FocusEvent.FOCUS_LOST, false, null, 
                                                CausedFocusEvent.Cause.CLEAR_GLOBAL_FOCUS_OWNER);
                }

                // Otherwise, fall through to failure case below

            } else if (opposite == null)
            {
                // Focus leaving application
                if (currentFocusOwner != null) {
                    return new CausedFocusEvent(currentFocusOwner, 
                                                FocusEvent.FOCUS_LOST,
                                                true, null, CausedFocusEvent.Cause.ACTIVATION);
                } else {
                    return fe;
                }
            } else if (hwFocusRequest != null &&
                       (nativeOpposite == hwFocusRequest.heavyweight || 
                        nativeOpposite == null && 
                        opposite == hwFocusRequest.getFirstLightweightRequest().component))
            {
                if (currentFocusOwner == null) {
                    return fe;
                }
                // Focus change as a result of a known call to requestFocus(),
                // or click on a peer focusable heavyweight Component.
                
                // If a focus transfer is made across top-levels, then the
                // FOCUS_LOST event is always temporary, and the FOCUS_GAINED
                // event is always permanent. Otherwise, the stored temporary
                // value is honored.

                LightweightFocusRequest lwFocusRequest =
                    (LightweightFocusRequest)hwFocusRequest.
                    lightweightRequests.getFirst();

                boolean temporary = isTemporary(opposite,
                                                         currentFocusOwner)
                    ? true
                    : lwFocusRequest.temporary;

                return new CausedFocusEvent(currentFocusOwner, FocusEvent.FOCUS_LOST,
                                            temporary, lwFocusRequest.component, lwFocusRequest.cause);
            } else if (focusedWindowChanged(opposite, currentFocusOwner)) {
                // If top-level changed there might be no focus request in a list
                // But we know the opposite, we now it is temporary - dispatch the event.
                if (!fe.isTemporary() && currentFocusOwner != null) {
                    // Create copy of the event with only difference in temporary parameter.
                    fe = new CausedFocusEvent(currentFocusOwner, FocusEvent.FOCUS_LOST,
                                              true, opposite, CausedFocusEvent.Cause.ACTIVATION);
                } 
                return fe;
            }

            return retargetUnexpectedFocusEvent(fe);
        }  // end synchronized(heavyweightRequests)
    
static java.awt.event.FocusEventretargetUnexpectedFocusEvent(java.awt.event.FocusEvent fe)

        synchronized (heavyweightRequests) {
            // Any other case represents a failure condition which we did
            // not expect. We need to clearFocusRequestList() and patch up
            // the event as best as possible.

            if (removeFirstRequest()) {
                return (FocusEvent)retargetFocusEvent(fe);
            }

            Component source = fe.getComponent();
            Component opposite = fe.getOppositeComponent();
            boolean temporary = false;
            if (fe.getID() == FocusEvent.FOCUS_LOST &&
                (opposite == null || isTemporary(opposite, source)))
            {
                temporary = true;
            }
            return new CausedFocusEvent(source, fe.getID(), temporary, opposite, 
                                        CausedFocusEvent.Cause.NATIVE_SYSTEM);
        }
    
public static voidsetCurrentKeyboardFocusManager(java.awt.KeyboardFocusManager newManager)
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.

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.

param
newManager the new KeyboardFocusManager for this thread's context
see
#getCurrentKeyboardFocusManager
see
DefaultKeyboardFocusManager
throws
SecurityException if the calling thread does not have permission to replace the current KeyboardFocusManager

        SecurityManager security = System.getSecurityManager();
        if (security != null) {
            if (replaceKeyboardFocusManagerPermission == null) {
                replaceKeyboardFocusManagerPermission =
                    new AWTPermission("replaceKeyboardFocusManager");
            }
            security.
                checkPermission(replaceKeyboardFocusManagerPermission);
        }

        KeyboardFocusManager oldManager = null;

        synchronized (KeyboardFocusManager.class) {
            AppContext appcontext = AppContext.getAppContext();

            if (newManager != null) {
                oldManager = getCurrentKeyboardFocusManager(appcontext);

                appcontext.put(KeyboardFocusManager.class, newManager);
            } else {
                oldManager = getCurrentKeyboardFocusManager(appcontext);
                appcontext.remove(KeyboardFocusManager.class);
            }
        }

        if (oldManager != null) {
            oldManager.firePropertyChange("managingFocus", 
                                          Boolean.TRUE, 
                                          Boolean.FALSE);
        }
        if (newManager != null) {
            newManager.firePropertyChange("managingFocus", 
                                          Boolean.FALSE, 
                                          Boolean.TRUE);
        }
    
final voidsetCurrentSequencedEvent(java.awt.SequencedEvent current)


        
        synchronized (SequencedEvent.class) {
            assert(current == null || currentSequencedEvent == null);
            currentSequencedEvent = current;
        }
    
public voidsetDefaultFocusTraversalKeys(int id, java.util.Set keystrokes)
Sets the 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.

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 KeyEvents, KEY_PRESSED or KEY_RELEASED, the focus traversal operation will occur. Regardless of which KeyEvent is specified, however, all KeyEvents 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.

param
id one of KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS, KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS, KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS, or KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYS
param
keystrokes the Set of AWTKeyStrokes for the specified operation
see
#getDefaultFocusTraversalKeys
see
Component#setFocusTraversalKeys
see
Component#getFocusTraversalKeys
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
beaninfo
bound: true

        if (id < 0 || id >= TRAVERSAL_KEY_LENGTH) {
            throw new IllegalArgumentException("invalid focus traversal key identifier");
        }
        if (keystrokes == null) {
            throw new IllegalArgumentException("cannot set null Set of default focus traversal keys");
        }

	Set oldKeys;

	synchronized (this) {
	    for (Iterator iter = keystrokes.iterator(); iter.hasNext(); ) {
		Object obj = iter.next();

		if (obj == null) {
		    throw new IllegalArgumentException("cannot set null focus traversal key");
		}

                // Fix for 6195831:
                //According to javadoc this method should throw IAE instead of ClassCastException
                if (!(obj instanceof AWTKeyStroke)) {
                    throw new IllegalArgumentException("object is expected to be AWTKeyStroke");
                }
		AWTKeyStroke keystroke = (AWTKeyStroke)obj;

		if (keystroke.getKeyChar() != KeyEvent.CHAR_UNDEFINED) {
		    throw new IllegalArgumentException("focus traversal keys cannot map to KEY_TYPED events");
		}
	    
		// Check to see if key already maps to another traversal
		// operation
		for (int i = 0; i < TRAVERSAL_KEY_LENGTH; i++) {
		    if (i == id) {
			continue;
		    }

		    if (defaultFocusTraversalKeys[i].contains(keystroke)) {
			throw new IllegalArgumentException("focus traversal keys must be unique for a Component");
		    }
		}
	    }

	    oldKeys = defaultFocusTraversalKeys[id];
	    defaultFocusTraversalKeys[id] =
		Collections.unmodifiableSet(new HashSet(keystrokes));
	}

        firePropertyChange(defaultFocusTraversalKeyPropertyNames[id],
                           oldKeys, keystrokes);
    
public voidsetDefaultFocusTraversalPolicy(java.awt.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.

param
defaultPolicy the new, default FocusTraversalPolicy
see
#getDefaultFocusTraversalPolicy
see
Container#setFocusTraversalPolicy
see
Container#getFocusTraversalPolicy
throws
IllegalArgumentException if defaultPolicy is null
beaninfo
bound: true

        if (defaultPolicy == null) {
            throw new IllegalArgumentException("default focus traversal policy cannot be null");
        }

        FocusTraversalPolicy oldPolicy;

	synchronized (this) {
	    oldPolicy = this.defaultPolicy;
	    this.defaultPolicy = defaultPolicy;
	}

        firePropertyChange("defaultFocusTraversalPolicy", oldPolicy,
                           defaultPolicy);
    
protected voidsetGlobalActiveWindow(java.awt.Window activeWindow)
Sets the active Window. Only a Frame or a Dialog 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 or Dialog that is an owner of the focused Window.

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.

param
activeWindow the active Window
see
#getActiveWindow
see
#getGlobalActiveWindow
see
Component#requestFocus()
see
Component#requestFocusInWindow()
beaninfo
bound: true

        Window oldActiveWindow;
	synchronized (KeyboardFocusManager.class) {
	    oldActiveWindow = getActiveWindow();
            if (focusLog.isLoggable(Level.FINER)) {
                focusLog.finer("Setting global active window to " + activeWindow + ", old active " + oldActiveWindow);
            }

	    try {
		fireVetoableChange("activeWindow", oldActiveWindow,
				   activeWindow);
	    } catch (PropertyVetoException e) {
		// rejected
		return;
	    }

	    KeyboardFocusManager.activeWindow = activeWindow;
	}

	firePropertyChange("activeWindow", oldActiveWindow, activeWindow);
    
public voidsetGlobalCurrentFocusCycleRoot(java.awt.Container newFocusCycleRoot)
Sets the current focus cycle root. 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.

This method is intended to be used only by KeyboardFocusManagers and focus implementations. It is not for general client use.

param
newFocusCycleRoot the new focus cycle root
see
#getCurrentFocusCycleRoot
see
#getGlobalCurrentFocusCycleRoot
beaninfo
bound: true

        Container oldFocusCycleRoot;

	synchronized (KeyboardFocusManager.class) {
	    oldFocusCycleRoot  = getCurrentFocusCycleRoot();
	    currentFocusCycleRoot = newFocusCycleRoot;
	}

        firePropertyChange("currentFocusCycleRoot", oldFocusCycleRoot,
                           newFocusCycleRoot);
    
protected voidsetGlobalFocusOwner(java.awt.Component focusOwner)
Sets the focus owner. The operation will be cancelled if the Component is not focusable. 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.

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.

param
focusOwner the focus owner
see
#getFocusOwner
see
#getGlobalFocusOwner
see
Component#requestFocus()
see
Component#requestFocusInWindow()
see
Component#isFocusable
beaninfo
bound: true

        Component oldFocusOwner = null;
	boolean shouldFire = false;

	if (focusOwner == null || focusOwner.isFocusable()) {
	    synchronized (KeyboardFocusManager.class) {
	        oldFocusOwner = getFocusOwner();

		try {
		    fireVetoableChange("focusOwner", oldFocusOwner,
				       focusOwner);
		} catch (PropertyVetoException e) {
		    // rejected
		    return;
		}

		KeyboardFocusManager.focusOwner = focusOwner;

		if (focusOwner != null && 
                    (getCurrentFocusCycleRoot() == null ||
		     !focusOwner.isFocusCycleRoot(getCurrentFocusCycleRoot())))
		{
		    Container rootAncestor =
		        focusOwner.getFocusCycleRootAncestor();
		    if (rootAncestor == null && (focusOwner instanceof Window))
		    {
		        rootAncestor = (Container)focusOwner;
		    }
                    if (rootAncestor != null) {
		        setGlobalCurrentFocusCycleRoot(rootAncestor);
		    }
                }

		shouldFire = true;
	    }
	}

	if (shouldFire) {
	    firePropertyChange("focusOwner", oldFocusOwner, focusOwner);
	}
    
protected voidsetGlobalFocusedWindow(java.awt.Window focusedWindow)
Sets the focused Window. The focused Window is the Window that is or contains the focus owner. The operation will be cancelled if the specified Window to focus is not a focusable Window.

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.

param
focusedWindow the focused Window
see
#getFocusedWindow
see
#getGlobalFocusedWindow
see
Component#requestFocus()
see
Component#requestFocusInWindow()
see
Window#isFocusableWindow
beaninfo
bound: true

        Window oldFocusedWindow = null;
	boolean shouldFire = false;

	if (focusedWindow == null || focusedWindow.isFocusableWindow()) {
	    synchronized (KeyboardFocusManager.class) {
	        oldFocusedWindow = getFocusedWindow();

		try {
		    fireVetoableChange("focusedWindow", oldFocusedWindow,
				       focusedWindow);
		} catch (PropertyVetoException e) {
		    // rejected
		    return;
		}

		KeyboardFocusManager.focusedWindow = focusedWindow;
		shouldFire = true;
	    }
	}

	if (shouldFire) {
	    firePropertyChange("focusedWindow", oldFocusedWindow,
			       focusedWindow);
	}
    
protected voidsetGlobalPermanentFocusOwner(java.awt.Component permanentFocusOwner)
Sets the permanent focus owner. The operation will be cancelled if the Component is not focusable. 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.

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.

param
permanentFocusOwner the permanent focus owner
see
#getPermanentFocusOwner
see
#getGlobalPermanentFocusOwner
see
Component#requestFocus()
see
Component#requestFocusInWindow()
see
Component#isFocusable
beaninfo
bound: true

        Component oldPermanentFocusOwner = null;
	boolean shouldFire = false;

	if (permanentFocusOwner == null || permanentFocusOwner.isFocusable()) {
	    synchronized (KeyboardFocusManager.class) {
	        oldPermanentFocusOwner = getPermanentFocusOwner();

		try {
		    fireVetoableChange("permanentFocusOwner",
				       oldPermanentFocusOwner,
				       permanentFocusOwner);
		} catch (PropertyVetoException e) {
		    // rejected
		    return;
		}

		KeyboardFocusManager.permanentFocusOwner = permanentFocusOwner;

		KeyboardFocusManager.
		    setMostRecentFocusOwner(permanentFocusOwner);

		shouldFire = true;
	    }
	}

	if (shouldFire) {
	    firePropertyChange("permanentFocusOwner", oldPermanentFocusOwner,
			       permanentFocusOwner);
	}
    
static voidsetMostRecentFocusOwner(java.awt.Component component)

        Component window = component;
	while (window != null && !(window instanceof Window)) {
	    window = window.parent;
	}
	if (window != null) {
	    setMostRecentFocusOwner((Window)window, component);
	}
    
static synchronized voidsetMostRecentFocusOwner(java.awt.Window window, java.awt.Component component)

        // ATTN: component has a strong reference to window via chain
        // of Component.parent fields.  Since WeakHasMap refers to its
        // values strongly, we need to break the strong link from the
        // value (component) back to its key (window).
        WeakReference weakValue = null;
        if (component != null) {
            weakValue = new WeakReference(component);
        }
        mostRecentFocusOwners.put(window, weakValue);
    
voidsetNativeFocusOwner(java.awt.Component comp)

        focusLog.log(Level.FINEST, "Calling peer {0} setCurrentFocusOwner for {1}",
                     new Object[] {peer, comp});
        peer.setCurrentFocusOwner(comp);
    
voidsetNativeFocusedWindow(java.awt.Window win)

        peer.setCurrentFocusedWindow(win);
    
static intshouldNativelyFocusHeavyweight(java.awt.Component heavyweight, java.awt.Component descendant, boolean temporary, boolean focusedWindowChangeAllowed, long time, sun.awt.CausedFocusEvent$Cause cause)
Indicates whether the native implementation should proceed with a pending, native focus request. Before changing the focus at the native level, the AWT implementation should always call this function for permission. This function will reject the request if a duplicate request preceded it, or if the specified heavyweight Component already owns the focus and no native focus changes are pending. Otherwise, the request will be approved and the focus request list will be updated so that, if necessary, the proper descendant will be focused when the corresponding FOCUS_GAINED event on the heavyweight is received. An implementation must ensure that calls to this method and native focus changes are atomic. If this is not guaranteed, then the ordering of the focus request list may be incorrect, leading to errors in the type-ahead mechanism. Typically this is accomplished by only calling this function from the native event pumping thread, or by holding a global, native lock during invocation.

        if (dbg.on) {
            dbg.assertion(heavyweight != null);
            dbg.assertion(time != 0);
        }

        if (descendant == null) {
            // Focus transfers from a lightweight child back to the
            // heavyweight Container should be treated like lightweight
            // focus transfers.
            descendant = heavyweight;
        }

        KeyboardFocusManager manager = 
            getCurrentKeyboardFocusManager(SunToolkit.targetToAppContext(descendant));
        KeyboardFocusManager thisManager = getCurrentKeyboardFocusManager();
        Component currentFocusOwner = thisManager.getGlobalFocusOwner();
        Component nativeFocusOwner = thisManager.getNativeFocusOwner();
        Window nativeFocusedWindow = thisManager.getNativeFocusedWindow();
        if (focusLog.isLoggable(Level.FINER)) {
            focusLog.log(Level.FINER, "SNFH for {0} in {1}", 
                         new Object[] {descendant, heavyweight});
        }
        if (focusLog.isLoggable(Level.FINEST)) {
            focusLog.log(Level.FINEST, "0. Current focus owner {0}", 
                         currentFocusOwner);
            focusLog.log(Level.FINEST, "0. Native focus owner {0}", 
                         nativeFocusOwner);
            focusLog.log(Level.FINEST, "0. Native focused window {0}", 
                         nativeFocusedWindow);
        }
        synchronized (heavyweightRequests) {
            HeavyweightFocusRequest hwFocusRequest = (HeavyweightFocusRequest)
                ((heavyweightRequests.size() > 0)
                 ? heavyweightRequests.getLast() : null);
            if (focusLog.isLoggable(Level.FINEST)) {
                focusLog.log(Level.FINEST, "Request {0}", hwFocusRequest);
            }
            if (hwFocusRequest == null &&
                heavyweight == nativeFocusOwner)
            {
                if (descendant == currentFocusOwner) {
                    // Redundant request.
                    if (focusLog.isLoggable(Level.FINEST)) 
                        focusLog.log(Level.FINEST, "1. SNFH_FAILURE for {0}", 
                                     descendant);
                    return SNFH_FAILURE;
                }

                // 'heavyweight' owns the native focus and there are no pending
                // requests. 'heavyweight' must be a Container and
                // 'descendant' must not be the focus owner. Otherwise,
                // we would never have gotten this far.
                manager.enqueueKeyEvents(time, descendant);

                hwFocusRequest =
                    new HeavyweightFocusRequest(heavyweight, descendant,
                                                temporary, cause);
                heavyweightRequests.add(hwFocusRequest);

                if (currentFocusOwner != null) {
                    FocusEvent currentFocusOwnerEvent =
                        new CausedFocusEvent(currentFocusOwner,
                                       FocusEvent.FOCUS_LOST,
                                       temporary, descendant, cause);
                    // Fix 5028014. Rolled out.
                    // SunToolkit.postPriorityEvent(currentFocusOwnerEvent);
                    SunToolkit.postEvent(currentFocusOwner.appContext,
                                         currentFocusOwnerEvent);
                }
                FocusEvent newFocusOwnerEvent =
                    new CausedFocusEvent(descendant, FocusEvent.FOCUS_GAINED,
                                   temporary, currentFocusOwner, cause);
                // Fix 5028014. Rolled out.
                // SunToolkit.postPriorityEvent(newFocusOwnerEvent);
                SunToolkit.postEvent(descendant.appContext, newFocusOwnerEvent);

                if (focusLog.isLoggable(Level.FINEST)) 
                    focusLog.log(Level.FINEST, "2. SNFH_HANDLED for {0}", descendant);
                return SNFH_SUCCESS_HANDLED;
            } else if (hwFocusRequest != null &&
                       hwFocusRequest.heavyweight == heavyweight) {
                // 'heavyweight' doesn't have the native focus right now, but
                // if all pending requests were completed, it would. Add
                // descendant to the heavyweight's list of pending
                // lightweight focus transfers.
                if (hwFocusRequest.addLightweightRequest(descendant,
                                                         temporary, cause)) {
                    manager.enqueueKeyEvents(time, descendant);
                }
                
                if (focusLog.isLoggable(Level.FINEST)) 
                    focusLog.finest("3. SNFH_HANDLED for lightweight" +
                                    descendant + " in " + heavyweight);
                return SNFH_SUCCESS_HANDLED;
            } else {
                if (!focusedWindowChangeAllowed) {
                    // For purposes of computing oldFocusedWindow, we should look at
                    // the second to last HeavyweightFocusRequest on the queue iff the
                    // last HeavyweightFocusRequest is CLEAR_GLOBAL_FOCUS_OWNER. If
                    // there is no second to last HeavyweightFocusRequest, null is an
                    // acceptable value.
                    if (hwFocusRequest ==
                        HeavyweightFocusRequest.CLEAR_GLOBAL_FOCUS_OWNER) 
                    {
                        int size = heavyweightRequests.size();
                        hwFocusRequest = (HeavyweightFocusRequest)((size >= 2)
                            ? heavyweightRequests.get(size - 2)
                            : null);
                    }
                    if (focusedWindowChanged(heavyweight,
                                             (hwFocusRequest != null)
                                             ? hwFocusRequest.heavyweight
                                             : nativeFocusedWindow)) {
                        if (focusLog.isLoggable(Level.FINEST)) 
                            focusLog.finest("4. SNFH_FAILURE for " + descendant);
                        return SNFH_FAILURE;
                    }
                }

                manager.enqueueKeyEvents(time, descendant);
                heavyweightRequests.add
                    (new HeavyweightFocusRequest(heavyweight, descendant,
                                                 temporary, cause));
                if (focusLog.isLoggable(Level.FINEST)) 
                    focusLog.finest("5. SNFH_PROCEED for " + descendant);
                return SNFH_SUCCESS_PROCEED;
            }
        }
    
public abstract voidupFocusCycle(java.awt.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.

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

public final voidupFocusCycle()
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.

        Component focusOwner = getFocusOwner();
        if (focusOwner != null) {
            upFocusCycle(focusOwner);
        }