/*

* Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.

* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

*

* This code is free software; you can redistribute it and/or modify it

* under the terms of the GNU General Public License version 2 only, as

* published by the Free Software Foundation. Oracle designates this

* particular file as subject to the "Classpath" exception as provided

* by Oracle in the LICENSE file that accompanied this code.

*

* This code is distributed in the hope that it will be useful, but WITHOUT

* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License

* version 2 for more details (a copy is included in the LICENSE file that

* accompanied this code).

*

* You should have received a copy of the GNU General Public License version

* 2 along with this work; if not, write to the Free Software Foundation,

* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

*

* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

* or visit www.oracle.com if you need additional information or have any

* questions.

*/

package java.awt;

import java.awt.event.FocusEvent;

import java.awt.event.InputEvent;

import java.awt.event.KeyEvent;

import java.awt.event.WindowEvent;

import java.awt.peer.KeyboardFocusManagerPeer;

import java.awt.peer.LightweightPeer;

import java.beans.PropertyChangeListener;

import java.beans.PropertyChangeSupport;

import java.beans.PropertyVetoException;

import java.beans.VetoableChangeListener;

import java.beans.VetoableChangeSupport;

import java.lang.ref.WeakReference;

import java.lang.reflect.Field;

import java.security.AccessController;

import java.security.PrivilegedAction;

import java.util.Collections;

import java.util.HashSet;

import java.util.Iterator;

import java.util.LinkedList;

import java.util.Set;

import java.util.StringTokenizer;

import java.util.WeakHashMap;

import sun.util.logging.PlatformLogger;

import sun.awt.AppContext;

import sun.awt.SunToolkit;

import sun.awt.CausedFocusEvent;

import sun.awt.KeyboardFocusManagerPeerProvider;

import sun.awt.AWTAccessor;

/**

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

* <p>

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

* <p>

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

* <p>

* Please see

* <a href="https://docs.oracle.com/javase/tutorial/uiswing/misc/focus.html">

* How to Use the Focus Subsystem</a>,

* a section in <em>The Java Tutorial</em>, and the

* <a href="../../java/awt/doc-files/FocusSpec.html">Focus Specification</a>

* for more information.

*

* @author David Mendenhall

*

* @see Window

* @see Frame

* @see Dialog

* @see java.awt.event.FocusEvent

* @see java.awt.event.WindowEvent

* @see java.awt.event.KeyEvent

* @since 1.4

*/

public abstract class KeyboardFocusManager

implements KeyEventDispatcher, KeyEventPostProcessor

{

// Shared focus engine logger

private static final PlatformLogger focusLog = PlatformLogger.getLogger("java.awt.focus.KeyboardFocusManager");

static {

/* ensure that the necessary native libraries are loaded */

Toolkit.loadLibraries();

if (!GraphicsEnvironment.isHeadless()) {

initIDs();

}

AWTAccessor.setKeyboardFocusManagerAccessor(

new AWTAccessor.KeyboardFocusManagerAccessor() {

public int shouldNativelyFocusHeavyweight(Component heavyweight,

Component descendant,

boolean temporary,

boolean focusedWindowChangeAllowed,

long time,

CausedFocusEvent.Cause cause)

{

return KeyboardFocusManager.shouldNativelyFocusHeavyweight(

heavyweight, descendant, temporary, focusedWindowChangeAllowed, time, cause);

}

public boolean processSynchronousLightweightTransfer(Component heavyweight,

Component descendant,

boolean temporary,

boolean focusedWindowChangeAllowed,

long time)

{

return KeyboardFocusManager.processSynchronousLightweightTransfer(

heavyweight, descendant, temporary, focusedWindowChangeAllowed, time);

}

public void removeLastFocusRequest(Component heavyweight) {

KeyboardFocusManager.removeLastFocusRequest(heavyweight);

}

public void setMostRecentFocusOwner(Window window, Component component) {

KeyboardFocusManager.setMostRecentFocusOwner(window, component);

}

public KeyboardFocusManager getCurrentKeyboardFocusManager(AppContext ctx) {

return KeyboardFocusManager.getCurrentKeyboardFocusManager(ctx);

}

public Container getCurrentFocusCycleRoot() {

return KeyboardFocusManager.currentFocusCycleRoot;

}

}

);

}

transient KeyboardFocusManagerPeer peer;

/**

* Initialize JNI field and method IDs

*/

private static native void initIDs();

private static final PlatformLogger log = PlatformLogger.getLogger("java.awt.KeyboardFocusManager");

/**

* The identifier for the Forward focus traversal keys.

*

* @see #setDefaultFocusTraversalKeys

* @see #getDefaultFocusTraversalKeys

* @see Component#setFocusTraversalKeys

* @see Component#getFocusTraversalKeys

*/

public static final int FORWARD_TRAVERSAL_KEYS = 0;

/**

* The identifier for the Backward focus traversal keys.

*

* @see #setDefaultFocusTraversalKeys

* @see #getDefaultFocusTraversalKeys

* @see Component#setFocusTraversalKeys

* @see Component#getFocusTraversalKeys

*/

public static final int BACKWARD_TRAVERSAL_KEYS = 1;

/**

* The identifier for the Up Cycle focus traversal keys.

*

* @see #setDefaultFocusTraversalKeys

* @see #getDefaultFocusTraversalKeys

* @see Component#setFocusTraversalKeys

* @see Component#getFocusTraversalKeys

*/

public static final int UP_CYCLE_TRAVERSAL_KEYS = 2;

/**

* The identifier for the Down Cycle focus traversal keys.

*

* @see #setDefaultFocusTraversalKeys

* @see #getDefaultFocusTraversalKeys

* @see Component#setFocusTraversalKeys

* @see Component#getFocusTraversalKeys

*/

public static final int DOWN_CYCLE_TRAVERSAL_KEYS = 3;

static final int TRAVERSAL_KEY_LENGTH = DOWN_CYCLE_TRAVERSAL_KEYS + 1;

/**

* Returns the current KeyboardFocusManager instance for the calling

* thread's context.

*

* @return this thread's context's KeyboardFocusManager

* @see #setCurrentKeyboardFocusManager

*/

public static KeyboardFocusManager getCurrentKeyboardFocusManager() {

return getCurrentKeyboardFocusManager(AppContext.getAppContext());

}

synchronized static KeyboardFocusManager

getCurrentKeyboardFocusManager(AppContext appcontext)

{

KeyboardFocusManager manager = (KeyboardFocusManager)

appcontext.get(KeyboardFocusManager.class);

if (manager == null) {

manager = new DefaultKeyboardFocusManager();

appcontext.put(KeyboardFocusManager.class, manager);

}

return manager;

}

/**

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

* <p>

* 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

*/

public static void setCurrentKeyboardFocusManager(

KeyboardFocusManager newManager) throws SecurityException

{

checkReplaceKFMPermission();

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);

}

}

/**

* The Component in an application that will typically receive all

* KeyEvents generated by the user.

*/

private static Component focusOwner;

/**

* 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 Component permanentFocusOwner;

/**

* The Window which is, or contains, the focus owner.

*/

private static Window focusedWindow;

/**

* 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 static Window activeWindow;

/**

* 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 FocusTraversalPolicy defaultPolicy =

new DefaultFocusTraversalPolicy();

/**

* The bound property names of each focus traversal key.

*/

private static final String[] defaultFocusTraversalKeyPropertyNames = {

"forwardDefaultFocusTraversalKeys",

"backwardDefaultFocusTraversalKeys",

"upCycleDefaultFocusTraversalKeys",

"downCycleDefaultFocusTraversalKeys"

};

/**

* The default strokes for initializing the default focus traversal keys.

*/

private static final AWTKeyStroke[][] defaultFocusTraversalKeyStrokes = {

{

AWTKeyStroke.getAWTKeyStroke(KeyEvent.VK_TAB, 0, false),

AWTKeyStroke.getAWTKeyStroke(KeyEvent.VK_TAB, InputEvent.CTRL_DOWN_MASK | InputEvent.CTRL_MASK, false),

},

{

AWTKeyStroke.getAWTKeyStroke(KeyEvent.VK_TAB, InputEvent.SHIFT_DOWN_MASK | InputEvent.SHIFT_MASK, false),

AWTKeyStroke.getAWTKeyStroke(KeyEvent.VK_TAB,

InputEvent.SHIFT_DOWN_MASK | InputEvent.SHIFT_MASK | InputEvent.CTRL_DOWN_MASK | InputEvent.CTRL_MASK,

false),

},

{},

{},

};

/**

* 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 Set<AWTKeyStroke>[] defaultFocusTraversalKeys = new Set[4];

/**

* 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 static Container currentFocusCycleRoot;

/**

* A description of any VetoableChangeListeners which have been registered.

*/

private VetoableChangeSupport vetoableSupport;

/**

* A description of any PropertyChangeListeners which have been registered.

*/

private PropertyChangeSupport changeSupport;

/**

* This KeyboardFocusManager's KeyEventDispatcher chain. The List does not

* include this KeyboardFocusManager unless it was explicitly re-registered

* via a call to <code>addKeyEventDispatcher</code>. If no other

* KeyEventDispatchers are registered, this field may be null or refer to

* a List of length 0.

*/

private java.util.LinkedList<KeyEventDispatcher> keyEventDispatchers;

/**

* This KeyboardFocusManager's KeyEventPostProcessor chain. The List does

* not include this KeyboardFocusManager unless it was explicitly

* re-registered via a call to <code>addKeyEventPostProcessor</code>.

* If no other KeyEventPostProcessors are registered, this field may be

* null or refer to a List of length 0.

*/

private java.util.LinkedList<KeyEventPostProcessor> keyEventPostProcessors;

/**

* Maps Windows to those Windows' most recent focus owners.

*/

private static java.util.Map<Window, WeakReference<Component>> mostRecentFocusOwners = new WeakHashMap<>();

/**

* We cache the permission used to verify that the calling thread is

* permitted to access the global focus state.

*/

private static AWTPermission replaceKeyboardFocusManagerPermission;

/*

* SequencedEvent which is currently dispatched in AppContext.

*/

transient SequencedEvent currentSequencedEvent = null;

final void setCurrentSequencedEvent(SequencedEvent current) {

synchronized (SequencedEvent.class) {

assert(current == null || currentSequencedEvent == null);

currentSequencedEvent = current;

}

}

final SequencedEvent getCurrentSequencedEvent() {

synchronized (SequencedEvent.class) {

return currentSequencedEvent;

}

}

static Set<AWTKeyStroke> initFocusTraversalKeysSet(String value, Set<AWTKeyStroke> targetSet) {

StringTokenizer tokens = new StringTokenizer(value, ",");

while (tokens.hasMoreTokens()) {

targetSet.add(AWTKeyStroke.getAWTKeyStroke(tokens.nextToken()));

}

return (targetSet.isEmpty())

? Collections.EMPTY_SET

: Collections.unmodifiableSet(targetSet);

}

/**

* Initializes a KeyboardFocusManager.

*/

public KeyboardFocusManager() {

for (int i = 0; i < TRAVERSAL_KEY_LENGTH; i++) {

Set<AWTKeyStroke> 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();

}

private void initPeer() {

Toolkit tk = Toolkit.getDefaultToolkit();

KeyboardFocusManagerPeerProvider peerProvider = (KeyboardFocusManagerPeerProvider)tk;

peer = peerProvider.getKeyboardFocusManagerPeer();

}

/**

* 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

*/

public Component getFocusOwner() {

synchronized (KeyboardFocusManager.class) {

if (focusOwner == null) {

return null;

}

return (focusOwner.appContext == AppContext.getAppContext())

? focusOwner

: null;

}

}

/**

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

* <p>

* 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

* and if the calling thread does not have "replaceKeyboardFocusManager"

* permission

*/

protected Component getGlobalFocusOwner() throws SecurityException {

synchronized (KeyboardFocusManager.class) {

checkKFMSecurity();

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

* <p>

* This method does not actually set the focus to the specified Component.

* It merely stores the value to be subsequently returned by

* <code>getFocusOwner()</code>. Use <code>Component.requestFocus()</code>

* or <code>Component.requestFocusInWindow()</code> 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

* @throws SecurityException if this KeyboardFocusManager is not the

* current KeyboardFocusManager for the calling thread's context

* and if the calling thread does not have "replaceKeyboardFocusManager"

* permission

* @beaninfo

* bound: true

*/

protected void setGlobalFocusOwner(Component focusOwner)

throws SecurityException

{

Component oldFocusOwner = null;

boolean shouldFire = false;

if (focusOwner == null || focusOwner.isFocusable()) {

synchronized (KeyboardFocusManager.class) {

checkKFMSecurity();

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) {

setGlobalCurrentFocusCycleRootPriv(rootAncestor);

}

}

shouldFire = true;

}

}

if (shouldFire) {

firePropertyChange("focusOwner", oldFocusOwner, focusOwner);

}

}

/**

* Clears the focus owner at both the Java and native levels if the

* focus owner exists and resides in the same context as the calling thread,

* otherwise the method returns silently.

* <p>

* The focus owner 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

* {@code requestFocus()}. This operation does not change the focused or

* active Windows.

*

* @see Component#requestFocus()

* @see java.awt.event.FocusEvent#FOCUS_LOST

* @since 1.8

*/

public void clearFocusOwner() {

if (getFocusOwner() != null) {

clearGlobalFocusOwner();

}

}

/**

* Clears the global focus owner at both the Java and native levels. If

* there exists a focus owner, that Component will receive a permanent

* FOCUS_LOST event. After this operation completes, the native windowing

* system will discard all user-generated KeyEvents until the user selects

* a new Component to receive focus, or a Component is given focus

* explicitly via a call to <code>requestFocus()</code>. This operation

* does not change the focused or active Windows.

* <p>

* If a SecurityManager is installed, the calling thread must be granted

* the "replaceKeyboardFocusManager" AWTPermission. If this permission is

* not granted, this method will throw a SecurityException, and the current

* focus owner will not be cleared.

* <p>

* This method is intended to be used only by KeyboardFocusManager set as

* current KeyboardFocusManager for the calling thread's context. It is not

* for general client use.

*

* @see KeyboardFocusManager#clearFocusOwner

* @see Component#requestFocus()

* @see java.awt.event.FocusEvent#FOCUS_LOST

* @throws SecurityException if the calling thread does not have

* "replaceKeyboardFocusManager" permission

*/

public void clearGlobalFocusOwner()

throws SecurityException

{

checkReplaceKFMPermission();

if (!GraphicsEnvironment.isHeadless()) {

// Toolkit must be fully initialized, otherwise

// _clearGlobalFocusOwner will crash or throw an exception

Toolkit.getDefaultToolkit();

_clearGlobalFocusOwner();

}

}

private void _clearGlobalFocusOwner() {

Window activeWindow = markClearGlobalFocusOwner();

peer.clearGlobalFocusOwner(activeWindow);

}

void clearGlobalFocusOwnerPriv() {

AccessController.doPrivileged(new PrivilegedAction<Void>() {

public Void run() {

clearGlobalFocusOwner();

return null;

}

});

}

Component getNativeFocusOwner() {

return peer.getCurrentFocusOwner();

}

void setNativeFocusOwner(Component comp) {

if (focusLog.isLoggable(PlatformLogger.Level.FINEST)) {

focusLog.finest("Calling peer {0} setCurrentFocusOwner for {1}",

String.valueOf(peer), String.valueOf(comp));

}

peer.setCurrentFocusOwner(comp);

}

Window getNativeFocusedWindow() {

return peer.getCurrentFocusedWindow();

}

/**

* 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

*/

public Component getPermanentFocusOwner() {

synchronized (KeyboardFocusManager.class) {

if (permanentFocusOwner == null) {

return null;

}

return (permanentFocusOwner.appContext ==

AppContext.getAppContext())

? permanentFocusOwner

: null;

}

}

/**

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

*

* @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

* and if the calling thread does not have "replaceKeyboardFocusManager"

* permission

*/

protected Component getGlobalPermanentFocusOwner()

throws SecurityException

{

synchronized (KeyboardFocusManager.class) {

checkKFMSecurity();

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

* <p>

* This method does not actually set the focus to the specified Component.

* It merely stores the value to be subsequently returned by

* <code>getPermanentFocusOwner()</code>. Use

* <code>Component.requestFocus()</code> or

* <code>Component.requestFocusInWindow()</code> 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

* @throws SecurityException if this KeyboardFocusManager is not the

* current KeyboardFocusManager for the calling thread's context

* and if the calling thread does not have "replaceKeyboardFocusManager"

* permission

* @beaninfo

* bound: true

*/

protected void setGlobalPermanentFocusOwner(Component permanentFocusOwner)

throws SecurityException

{

Component oldPermanentFocusOwner = null;

boolean shouldFire = false;

if (permanentFocusOwner == null || permanentFocusOwner.isFocusable()) {

synchronized (KeyboardFocusManager.class) {

checkKFMSecurity();

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);

}

}

/**

* 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

*/

public Window getFocusedWindow() {

synchronized (KeyboardFocusManager.class) {

if (focusedWindow == null) {

return null;

}

return (focusedWindow.appContext == AppContext.getAppContext())

? focusedWindow

: null;

}

}

/**

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

*

* @return the focused Window

* @see #getFocusedWindow

* @see #setGlobalFocusedWindow

* @throws SecurityException if this KeyboardFocusManager is not the

* current KeyboardFocusManager for the calling thread's context

* and if the calling thread does not have "replaceKeyboardFocusManager"

* permission

*/

protected Window getGlobalFocusedWindow() throws SecurityException {

synchronized (KeyboardFocusManager.class) {

checkKFMSecurity();

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

* <p>

* 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 <code>getFocusedWindow()</code>. Use

* <code>Component.requestFocus()</code> or

* <code>Component.requestFocusInWindow()</code> 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

* @throws SecurityException if this KeyboardFocusManager is not the

* current KeyboardFocusManager for the calling thread's context

* and if the calling thread does not have "replaceKeyboardFocusManager"

* permission

* @beaninfo

* bound: true

*/

protected void setGlobalFocusedWindow(Window focusedWindow)

throws SecurityException

{

Window oldFocusedWindow = null;

boolean shouldFire = false;

if (focusedWindow == null || focusedWindow.isFocusableWindow()) {

synchronized (KeyboardFocusManager.class) {

checkKFMSecurity();

oldFocusedWindow = getFocusedWindow();

try {

fireVetoableChange("focusedWindow", oldFocusedWindow,

focusedWindow);

} catch (PropertyVetoException e) {

// rejected

return;

}

KeyboardFocusManager.focusedWindow = focusedWindow;

shouldFire = true;

}

}

if (shouldFire) {

firePropertyChange("focusedWindow", oldFocusedWindow,

focusedWindow);

}

}

/**

* 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

*/

public Window getActiveWindow() {

synchronized (KeyboardFocusManager.class) {

if (activeWindow == null) {

return null;

}

return (activeWindow.appContext == AppContext.getAppContext())

? activeWindow

: null;

}

}

/**

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

*

* @return the active Window

* @see #getActiveWindow

* @see #setGlobalActiveWindow

* @throws SecurityException if this KeyboardFocusManager is not the

* current KeyboardFocusManager for the calling thread's context

* and if the calling thread does not have "replaceKeyboardFocusManager"

* permission

*/

protected Window getGlobalActiveWindow() throws SecurityException {

synchronized (KeyboardFocusManager.class) {

checkKFMSecurity();

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

* <p>

* 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 <code>getActiveWindow()</code>. Use

* <code>Component.requestFocus()</code> or

* <code>Component.requestFocusInWindow()</code>to change the active

* Window, subject to platform limitations.

*

* @param activeWindow the active Window

* @see #getActiveWindow

* @see #getGlobalActiveWindow

* @see Component#requestFocus()

* @see Component#requestFocusInWindow()

* @throws SecurityException if this KeyboardFocusManager is not the

* current KeyboardFocusManager for the calling thread's context

* and if the calling thread does not have "replaceKeyboardFocusManager"

* permission

* @beaninfo

* bound: true

*/

protected void setGlobalActiveWindow(Window activeWindow)

throws SecurityException

{

Window oldActiveWindow;

synchronized (KeyboardFocusManager.class) {

checkKFMSecurity();

oldActiveWindow = getActiveWindow();

if (focusLog.isLoggable(PlatformLogger.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);

}

/**

* 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

*/

public synchronized FocusTraversalPolicy getDefaultFocusTraversalPolicy() {

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