1 /*
2 * Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25 package java.awt;
26
27 import java.awt.event.FocusEvent;
28 import java.awt.event.InputEvent;
29 import java.awt.event.KeyEvent;
30 import java.awt.event.WindowEvent;
31
32 import java.awt.peer.KeyboardFocusManagerPeer;
33 import java.awt.peer.LightweightPeer;
34
35 import java.beans.PropertyChangeListener;
36 import java.beans.PropertyChangeSupport;
37 import java.beans.PropertyVetoException;
38 import java.beans.VetoableChangeListener;
39 import java.beans.VetoableChangeSupport;
40
41 import java.lang.ref.WeakReference;
42
43 import java.lang.reflect.Field;
44
45 import java.security.AccessController;
46 import java.security.PrivilegedAction;
47
48 import java.util.Collections;
49 import java.util.HashSet;
50 import java.util.Iterator;
51 import java.util.LinkedList;
52 import java.util.Set;
53 import java.util.StringTokenizer;
54 import java.util.WeakHashMap;
55
56 import sun.util.logging.PlatformLogger;
57
58 import sun.awt.AppContext;
59 import sun.awt.SunToolkit;
60 import sun.awt.CausedFocusEvent;
61 import sun.awt.KeyboardFocusManagerPeerProvider;
62 import sun.awt.AWTAccessor;
63
64 /**
65 * The KeyboardFocusManager is responsible for managing the active and focused
66 * Windows, and the current focus owner. The focus owner is defined as the
67 * Component in an application that will typically receive all KeyEvents
68 * generated by the user. The focused Window is the Window that is, or
69 * contains, the focus owner. Only a Frame or a Dialog can be the active
70 * Window. The native windowing system may denote the active Window or its
71 * children with special decorations, such as a highlighted title bar. The
72 * active Window is always either the focused Window, or the first Frame or
73 * Dialog that is an owner of the focused Window.
74 * <p>
75 * The KeyboardFocusManager is both a centralized location for client code to
76 * query for the focus owner and initiate focus changes, and an event
77 * dispatcher for all FocusEvents, WindowEvents related to focus, and
78 * KeyEvents.
79 * <p>
80 * Some browsers partition applets in different code bases into separate
81 * contexts, and establish walls between these contexts. In such a scenario,
82 * there will be one KeyboardFocusManager per context. Other browsers place all
83 * applets into the same context, implying that there will be only a single,
84 * global KeyboardFocusManager for all applets. This behavior is
85 * implementation-dependent. Consult your browser's documentation for more
86 * information. No matter how many contexts there may be, however, there can
87 * never be more than one focus owner, focused Window, or active Window, per
88 * ClassLoader.
89 * <p>
90 * Please see
91 * <a href="http://docs.oracle.com/javase/tutorial/uiswing/misc/focus.html">
92 * How to Use the Focus Subsystem</a>,
93 * a section in <em>The Java Tutorial</em>, and the
94 * <a href="../../java/awt/doc-files/FocusSpec.html">Focus Specification</a>
95 * for more information.
96 *
97 * @author David Mendenhall
98 *
99 * @see Window
100 * @see Frame
101 * @see Dialog
102 * @see java.awt.event.FocusEvent
103 * @see java.awt.event.WindowEvent
104 * @see java.awt.event.KeyEvent
105 * @since 1.4
106 */
107 public abstract class KeyboardFocusManager
108 implements KeyEventDispatcher, KeyEventPostProcessor
109 {
110
111 // Shared focus engine logger
112 private static final PlatformLogger focusLog = PlatformLogger.getLogger("java.awt.focus.KeyboardFocusManager");
113
114 static {
115 /* ensure that the necessary native libraries are loaded */
116 Toolkit.loadLibraries();
117 if (!GraphicsEnvironment.isHeadless()) {
118 initIDs();
119 }
120 AWTAccessor.setKeyboardFocusManagerAccessor(
121 new AWTAccessor.KeyboardFocusManagerAccessor() {
122 public int shouldNativelyFocusHeavyweight(Component heavyweight,
123 Component descendant,
124 boolean temporary,
125 boolean focusedWindowChangeAllowed,
126 long time,
127 CausedFocusEvent.Cause cause)
128 {
129 return KeyboardFocusManager.shouldNativelyFocusHeavyweight(
130 heavyweight, descendant, temporary, focusedWindowChangeAllowed, time, cause);
131 }
132 public boolean processSynchronousLightweightTransfer(Component heavyweight,
133 Component descendant,
134 boolean temporary,
135 boolean focusedWindowChangeAllowed,
136 long time)
137 {
138 return KeyboardFocusManager.processSynchronousLightweightTransfer(
139 heavyweight, descendant, temporary, focusedWindowChangeAllowed, time);
140 }
141 public void removeLastFocusRequest(Component heavyweight) {
142 KeyboardFocusManager.removeLastFocusRequest(heavyweight);
143 }
144 public void setMostRecentFocusOwner(Window window, Component component) {
145 KeyboardFocusManager.setMostRecentFocusOwner(window, component);
146 }
147 public KeyboardFocusManager getCurrentKeyboardFocusManager(AppContext ctx) {
148 return KeyboardFocusManager.getCurrentKeyboardFocusManager(ctx);
149 }
150 public Container getCurrentFocusCycleRoot() {
151 return KeyboardFocusManager.currentFocusCycleRoot;
152 }
153 }
154 );
155 }
156
157 transient KeyboardFocusManagerPeer peer;
158
159 /**
160 * Initialize JNI field and method IDs
161 */
162 private static native void initIDs();
163
164 private static final PlatformLogger log = PlatformLogger.getLogger("java.awt.KeyboardFocusManager");
165
166 /**
167 * The identifier for the Forward focus traversal keys.
168 *
169 * @see #setDefaultFocusTraversalKeys
170 * @see #getDefaultFocusTraversalKeys
171 * @see Component#setFocusTraversalKeys
172 * @see Component#getFocusTraversalKeys
173 */
174 public static final int FORWARD_TRAVERSAL_KEYS = 0;
175
176 /**
177 * The identifier for the Backward focus traversal keys.
178 *
179 * @see #setDefaultFocusTraversalKeys
180 * @see #getDefaultFocusTraversalKeys
181 * @see Component#setFocusTraversalKeys
182 * @see Component#getFocusTraversalKeys
183 */
184 public static final int BACKWARD_TRAVERSAL_KEYS = 1;
185
186 /**
187 * The identifier for the Up Cycle focus traversal keys.
188 *
189 * @see #setDefaultFocusTraversalKeys
190 * @see #getDefaultFocusTraversalKeys
191 * @see Component#setFocusTraversalKeys
192 * @see Component#getFocusTraversalKeys
193 */
194 public static final int UP_CYCLE_TRAVERSAL_KEYS = 2;
195
196 /**
197 * The identifier for the Down Cycle focus traversal keys.
198 *
199 * @see #setDefaultFocusTraversalKeys
200 * @see #getDefaultFocusTraversalKeys
201 * @see Component#setFocusTraversalKeys
202 * @see Component#getFocusTraversalKeys
203 */
204 public static final int DOWN_CYCLE_TRAVERSAL_KEYS = 3;
205
206 static final int TRAVERSAL_KEY_LENGTH = DOWN_CYCLE_TRAVERSAL_KEYS + 1;
207
208 /**
209 * Returns the current KeyboardFocusManager instance for the calling
210 * thread's context.
211 *
212 * @return this thread's context's KeyboardFocusManager
213 * @see #setCurrentKeyboardFocusManager
214 */
215 public static KeyboardFocusManager getCurrentKeyboardFocusManager() {
216 return getCurrentKeyboardFocusManager(AppContext.getAppContext());
217 }
218
219 synchronized static KeyboardFocusManager
220 getCurrentKeyboardFocusManager(AppContext appcontext)
221 {
222 KeyboardFocusManager manager = (KeyboardFocusManager)
223 appcontext.get(KeyboardFocusManager.class);
224 if (manager == null) {
225 manager = new DefaultKeyboardFocusManager();
226 appcontext.put(KeyboardFocusManager.class, manager);
227 }
228 return manager;
229 }
230
231 /**
232 * Sets the current KeyboardFocusManager instance for the calling thread's
233 * context. If null is specified, then the current KeyboardFocusManager
234 * is replaced with a new instance of DefaultKeyboardFocusManager.
235 * <p>
236 * If a SecurityManager is installed, the calling thread must be granted
237 * the AWTPermission "replaceKeyboardFocusManager" in order to replace the
238 * the current KeyboardFocusManager. If this permission is not granted,
239 * this method will throw a SecurityException, and the current
240 * KeyboardFocusManager will be unchanged.
241 *
242 * @param newManager the new KeyboardFocusManager for this thread's context
243 * @see #getCurrentKeyboardFocusManager
244 * @see DefaultKeyboardFocusManager
245 * @throws SecurityException if the calling thread does not have permission
246 * to replace the current KeyboardFocusManager
247 */
248 public static void setCurrentKeyboardFocusManager(
249 KeyboardFocusManager newManager) throws SecurityException
250 {
251 checkReplaceKFMPermission();
252
253 KeyboardFocusManager oldManager = null;
254
255 synchronized (KeyboardFocusManager.class) {
256 AppContext appcontext = AppContext.getAppContext();
257
258 if (newManager != null) {
259 oldManager = getCurrentKeyboardFocusManager(appcontext);
260
261 appcontext.put(KeyboardFocusManager.class, newManager);
262 } else {
263 oldManager = getCurrentKeyboardFocusManager(appcontext);
264 appcontext.remove(KeyboardFocusManager.class);
265 }
266 }
267
268 if (oldManager != null) {
269 oldManager.firePropertyChange("managingFocus",
270 Boolean.TRUE,
271 Boolean.FALSE);
272 }
273 if (newManager != null) {
274 newManager.firePropertyChange("managingFocus",
275 Boolean.FALSE,
276 Boolean.TRUE);
277 }
278 }
279
280 /**
281 * The Component in an application that will typically receive all
282 * KeyEvents generated by the user.
283 */
284 private static Component focusOwner;
285
286 /**
287 * The Component in an application that will regain focus when an
288 * outstanding temporary focus transfer has completed, or the focus owner,
289 * if no outstanding temporary transfer exists.
290 */
291 private static Component permanentFocusOwner;
292
293 /**
294 * The Window which is, or contains, the focus owner.
295 */
296 private static Window focusedWindow;
297
298 /**
299 * Only a Frame or a Dialog can be the active Window. The native windowing
300 * system may denote the active Window with a special decoration, such as a
301 * highlighted title bar. The active Window is always either the focused
302 * Window, or the first Frame or Dialog which is an owner of the focused
303 * Window.
304 */
305 private static Window activeWindow;
306
307 /**
308 * The default FocusTraversalPolicy for all Windows that have no policy of
309 * their own set. If those Windows have focus-cycle-root children that have
310 * no keyboard-traversal policy of their own, then those children will also
311 * inherit this policy (as will, recursively, their focus-cycle-root
312 * children).
313 */
314 private FocusTraversalPolicy defaultPolicy =
315 new DefaultFocusTraversalPolicy();
316
317 /**
318 * The bound property names of each focus traversal key.
319 */
320 private static final String[] defaultFocusTraversalKeyPropertyNames = {
321 "forwardDefaultFocusTraversalKeys",
322 "backwardDefaultFocusTraversalKeys",
323 "upCycleDefaultFocusTraversalKeys",
324 "downCycleDefaultFocusTraversalKeys"
325 };
326
327 /**
328 * The default strokes for initializing the default focus traversal keys.
329 */
330 private static final AWTKeyStroke[][] defaultFocusTraversalKeyStrokes = {
331 {
332 AWTKeyStroke.getAWTKeyStroke(KeyEvent.VK_TAB, 0, false),
333 AWTKeyStroke.getAWTKeyStroke(KeyEvent.VK_TAB, InputEvent.CTRL_DOWN_MASK | InputEvent.CTRL_MASK, false),
334 },
335 {
336 AWTKeyStroke.getAWTKeyStroke(KeyEvent.VK_TAB, InputEvent.SHIFT_DOWN_MASK | InputEvent.SHIFT_MASK, false),
337 AWTKeyStroke.getAWTKeyStroke(KeyEvent.VK_TAB,
338 InputEvent.SHIFT_DOWN_MASK | InputEvent.SHIFT_MASK | InputEvent.CTRL_DOWN_MASK | InputEvent.CTRL_MASK,
339 false),
340 },
341 {},
342 {},
343 };
344 /**
345 * The default focus traversal keys. Each array of traversal keys will be
346 * in effect on all Windows that have no such array of their own explicitly
347 * set. Each array will also be inherited, recursively, by any child
348 * Component of those Windows that has no such array of its own explicitly
349 * set.
350 */
351 private Set<AWTKeyStroke>[] defaultFocusTraversalKeys = new Set[4];
352
353 /**
354 * The current focus cycle root. If the focus owner is itself a focus cycle
355 * root, then it may be ambiguous as to which Components represent the next
356 * and previous Components to focus during normal focus traversal. In that
357 * case, the current focus cycle root is used to differentiate among the
358 * possibilities.
359 */
360 private static Container currentFocusCycleRoot;
361
362 /**
363 * A description of any VetoableChangeListeners which have been registered.
364 */
365 private VetoableChangeSupport vetoableSupport;
366
367 /**
368 * A description of any PropertyChangeListeners which have been registered.
369 */
370 private PropertyChangeSupport changeSupport;
371
372 /**
373 * This KeyboardFocusManager's KeyEventDispatcher chain. The List does not
374 * include this KeyboardFocusManager unless it was explicitly re-registered
375 * via a call to <code>addKeyEventDispatcher</code>. If no other
376 * KeyEventDispatchers are registered, this field may be null or refer to
377 * a List of length 0.
378 */
379 private java.util.LinkedList<KeyEventDispatcher> keyEventDispatchers;
380
381 /**
382 * This KeyboardFocusManager's KeyEventPostProcessor chain. The List does
383 * not include this KeyboardFocusManager unless it was explicitly
384 * re-registered via a call to <code>addKeyEventPostProcessor</code>.
385 * If no other KeyEventPostProcessors are registered, this field may be
386 * null or refer to a List of length 0.
387 */
388 private java.util.LinkedList<KeyEventPostProcessor> keyEventPostProcessors;
389
390 /**
391 * Maps Windows to those Windows' most recent focus owners.
392 */
393 private static java.util.Map<Window, WeakReference<Component>> mostRecentFocusOwners = new WeakHashMap<>();
394
395 /**
396 * We cache the permission used to verify that the calling thread is
397 * permitted to access the global focus state.
398 */
399 private static AWTPermission replaceKeyboardFocusManagerPermission;
400
401 /*
402 * SequencedEvent which is currently dispatched in AppContext.
403 */
404 transient SequencedEvent currentSequencedEvent = null;
405
406 final void setCurrentSequencedEvent(SequencedEvent current) {
407 synchronized (SequencedEvent.class) {
408 assert(current == null || currentSequencedEvent == null);
409 currentSequencedEvent = current;
410 }
411 }
412
413 final SequencedEvent getCurrentSequencedEvent() {
414 synchronized (SequencedEvent.class) {
415 return currentSequencedEvent;
416 }
417 }
418
419 static Set<AWTKeyStroke> initFocusTraversalKeysSet(String value, Set<AWTKeyStroke> targetSet) {
420 StringTokenizer tokens = new StringTokenizer(value, ",");
421 while (tokens.hasMoreTokens()) {
422 targetSet.add(AWTKeyStroke.getAWTKeyStroke(tokens.nextToken()));
423 }
424 return (targetSet.isEmpty())
425 ? Collections.EMPTY_SET
426 : Collections.unmodifiableSet(targetSet);
427 }
428
429 /**
430 * Initializes a KeyboardFocusManager.
431 */
432 public KeyboardFocusManager() {
433 for (int i = 0; i < TRAVERSAL_KEY_LENGTH; i++) {
434 Set<AWTKeyStroke> work_set = new HashSet<>();
435 for (int j = 0; j < defaultFocusTraversalKeyStrokes[i].length; j++) {
436 work_set.add(defaultFocusTraversalKeyStrokes[i][j]);
437 }
438 defaultFocusTraversalKeys[i] = (work_set.isEmpty())
439 ? Collections.EMPTY_SET
440 : Collections.unmodifiableSet(work_set);
441 }
442 initPeer();
443 }
444
445 private void initPeer() {
446 Toolkit tk = Toolkit.getDefaultToolkit();
447 KeyboardFocusManagerPeerProvider peerProvider = (KeyboardFocusManagerPeerProvider)tk;
448 peer = peerProvider.getKeyboardFocusManagerPeer();
449 }
450
451 /**
452 * Returns the focus owner, if the focus owner is in the same context as
453 * the calling thread. The focus owner is defined as the Component in an
454 * application that will typically receive all KeyEvents generated by the
455 * user. KeyEvents which map to the focus owner's focus traversal keys will
456 * not be delivered if focus traversal keys are enabled for the focus
457 * owner. In addition, KeyEventDispatchers may retarget or consume
458 * KeyEvents before they reach the focus owner.
459 *
460 * @return the focus owner, or null if the focus owner is not a member of
461 * the calling thread's context
462 * @see #getGlobalFocusOwner
463 * @see #setGlobalFocusOwner
464 */
465 public Component getFocusOwner() {
466 synchronized (KeyboardFocusManager.class) {
467 if (focusOwner == null) {
468 return null;
469 }
470
471 return (focusOwner.appContext == AppContext.getAppContext())
472 ? focusOwner
473 : null;
474 }
475 }
476
477 /**
478 * Returns the focus owner, even if the calling thread is in a different
479 * context than the focus owner. The focus owner is defined as the
480 * Component in an application that will typically receive all KeyEvents
481 * generated by the user. KeyEvents which map to the focus owner's focus
482 * traversal keys will not be delivered if focus traversal keys are enabled
483 * for the focus owner. In addition, KeyEventDispatchers may retarget or
484 * consume KeyEvents before they reach the focus owner.
485 * <p>
486 * This method will throw a SecurityException if this KeyboardFocusManager
487 * is not the current KeyboardFocusManager for the calling thread's
488 * context.
489 *
490 * @return the focus owner
491 * @see #getFocusOwner
492 * @see #setGlobalFocusOwner
493 * @throws SecurityException if this KeyboardFocusManager is not the
494 * current KeyboardFocusManager for the calling thread's context
495 * and if the calling thread does not have "replaceKeyboardFocusManager"
496 * permission
497 */
498 protected Component getGlobalFocusOwner() throws SecurityException {
499 synchronized (KeyboardFocusManager.class) {
500 checkKFMSecurity();
501 return focusOwner;
502 }
503 }
504
505 /**
506 * Sets the focus owner. The operation will be cancelled if the Component
507 * is not focusable. The focus owner is defined as the Component in an
508 * application that will typically receive all KeyEvents generated by the
509 * user. KeyEvents which map to the focus owner's focus traversal keys will
510 * not be delivered if focus traversal keys are enabled for the focus
511 * owner. In addition, KeyEventDispatchers may retarget or consume
512 * KeyEvents before they reach the focus owner.
513 * <p>
514 * This method does not actually set the focus to the specified Component.
515 * It merely stores the value to be subsequently returned by
516 * <code>getFocusOwner()</code>. Use <code>Component.requestFocus()</code>
517 * or <code>Component.requestFocusInWindow()</code> to change the focus
518 * owner, subject to platform limitations.
519 *
520 * @param focusOwner the focus owner
521 * @see #getFocusOwner
522 * @see #getGlobalFocusOwner
523 * @see Component#requestFocus()
524 * @see Component#requestFocusInWindow()
525 * @see Component#isFocusable
526 * @throws SecurityException if this KeyboardFocusManager is not the
527 * current KeyboardFocusManager for the calling thread's context
528 * and if the calling thread does not have "replaceKeyboardFocusManager"
529 * permission
530 * @beaninfo
531 * bound: true
532 */
533 protected void setGlobalFocusOwner(Component focusOwner)
534 throws SecurityException
535 {
536 Component oldFocusOwner = null;
537 boolean shouldFire = false;
538
539 if (focusOwner == null || focusOwner.isFocusable()) {
540 synchronized (KeyboardFocusManager.class) {
541 checkKFMSecurity();
542
543 oldFocusOwner = getFocusOwner();
544
545 try {
546 fireVetoableChange("focusOwner", oldFocusOwner,
547 focusOwner);
548 } catch (PropertyVetoException e) {
549 // rejected
550 return;
551 }
552
553 KeyboardFocusManager.focusOwner = focusOwner;
554
555 if (focusOwner != null &&
556 (getCurrentFocusCycleRoot() == null ||
557 !focusOwner.isFocusCycleRoot(getCurrentFocusCycleRoot())))
558 {
559 Container rootAncestor =
560 focusOwner.getFocusCycleRootAncestor();
561 if (rootAncestor == null && (focusOwner instanceof Window))
562 {
563 rootAncestor = (Container)focusOwner;
564 }
565 if (rootAncestor != null) {
566 setGlobalCurrentFocusCycleRootPriv(rootAncestor);
567 }
568 }
569
570 shouldFire = true;
571 }
572 }
573
574 if (shouldFire) {
575 firePropertyChange("focusOwner", oldFocusOwner, focusOwner);
576 }
577 }
578
579 /**
580 * Clears the focus owner at both the Java and native levels if the
581 * focus owner exists and resides in the same context as the calling thread,
582 * otherwise the method returns silently.
583 * <p>
584 * The focus owner component will receive a permanent FOCUS_LOST event.
585 * After this operation completes, the native windowing system will discard
586 * all user-generated KeyEvents until the user selects a new Component to
587 * receive focus, or a Component is given focus explicitly via a call to
588 * {@code requestFocus()}. This operation does not change the focused or
589 * active Windows.
590 *
591 * @see Component#requestFocus()
592 * @see java.awt.event.FocusEvent#FOCUS_LOST
593 * @since 1.8
594 */
595 public void clearFocusOwner() {
596 if (getFocusOwner() != null) {
597 clearGlobalFocusOwner();
598 }
599 }
600
601 /**
602 * Clears the global focus owner at both the Java and native levels. If
603 * there exists a focus owner, that Component will receive a permanent
604 * FOCUS_LOST event. After this operation completes, the native windowing
605 * system will discard all user-generated KeyEvents until the user selects
606 * a new Component to receive focus, or a Component is given focus
607 * explicitly via a call to <code>requestFocus()</code>. This operation
608 * does not change the focused or active Windows.
609 * <p>
610 * If a SecurityManager is installed, the calling thread must be granted
611 * the "replaceKeyboardFocusManager" AWTPermission. If this permission is
612 * not granted, this method will throw a SecurityException, and the current
613 * focus owner will not be cleared.
614 * <p>
615 * This method is intended to be used only by KeyboardFocusManager set as
616 * current KeyboardFocusManager for the calling thread's context. It is not
617 * for general client use.
618 *
619 * @see KeyboardFocusManager#clearFocusOwner
620 * @see Component#requestFocus()
621 * @see java.awt.event.FocusEvent#FOCUS_LOST
622 * @throws SecurityException if the calling thread does not have
623 * "replaceKeyboardFocusManager" permission
624 */
625 public void clearGlobalFocusOwner()
626 throws SecurityException
627 {
628 checkReplaceKFMPermission();
629 if (!GraphicsEnvironment.isHeadless()) {
630 // Toolkit must be fully initialized, otherwise
631 // _clearGlobalFocusOwner will crash or throw an exception
632 Toolkit.getDefaultToolkit();
633
634 _clearGlobalFocusOwner();
635 }
636 }
637 private void _clearGlobalFocusOwner() {
638 Window activeWindow = markClearGlobalFocusOwner();
639 peer.clearGlobalFocusOwner(activeWindow);
640 }
641
642 void clearGlobalFocusOwnerPriv() {
643 AccessController.doPrivileged(new PrivilegedAction<Void>() {
644 public Void run() {
645 clearGlobalFocusOwner();
646 return null;
647 }
648 });
649 }
650
651 Component getNativeFocusOwner() {
652 return peer.getCurrentFocusOwner();
653 }
654
655 void setNativeFocusOwner(Component comp) {
656 if (focusLog.isLoggable(PlatformLogger.Level.FINEST)) {
657 focusLog.finest("Calling peer {0} setCurrentFocusOwner for {1}",
658 String.valueOf(peer), String.valueOf(comp));
659 }
660 peer.setCurrentFocusOwner(comp);
661 }
662
663 Window getNativeFocusedWindow() {
664 return peer.getCurrentFocusedWindow();
665 }
666
667 /**
668 * Returns the permanent focus owner, if the permanent focus owner is in
669 * the same context as the calling thread. The permanent focus owner is
670 * defined as the last Component in an application to receive a permanent
671 * FOCUS_GAINED event. The focus owner and permanent focus owner are
672 * equivalent unless a temporary focus change is currently in effect. In
673 * such a situation, the permanent focus owner will again be the focus
674 * owner when the temporary focus change ends.
675 *
676 * @return the permanent focus owner, or null if the permanent focus owner
677 * is not a member of the calling thread's context
678 * @see #getGlobalPermanentFocusOwner
679 * @see #setGlobalPermanentFocusOwner
680 */
681 public Component getPermanentFocusOwner() {
682 synchronized (KeyboardFocusManager.class) {
683 if (permanentFocusOwner == null) {
684 return null;
685 }
686
687 return (permanentFocusOwner.appContext ==
688 AppContext.getAppContext())
689 ? permanentFocusOwner
690 : null;
691 }
692 }
693
694 /**
695 * Returns the permanent focus owner, even if the calling thread is in a
696 * different context than the permanent focus owner. The permanent focus
697 * owner is defined as the last Component in an application to receive a
698 * permanent FOCUS_GAINED event. The focus owner and permanent focus owner
699 * are equivalent unless a temporary focus change is currently in effect.
700 * In such a situation, the permanent focus owner will again be the focus
701 * owner when the temporary focus change ends.
702 *
703 * @return the permanent focus owner
704 * @see #getPermanentFocusOwner
705 * @see #setGlobalPermanentFocusOwner
706 * @throws SecurityException if this KeyboardFocusManager is not the
707 * current KeyboardFocusManager for the calling thread's context
708 * and if the calling thread does not have "replaceKeyboardFocusManager"
709 * permission
710 */
711 protected Component getGlobalPermanentFocusOwner()
712 throws SecurityException
713 {
714 synchronized (KeyboardFocusManager.class) {
715 checkKFMSecurity();
716 return permanentFocusOwner;
717 }
718 }
719
720 /**
721 * Sets the permanent focus owner. The operation will be cancelled if the
722 * Component is not focusable. The permanent focus owner is defined as the
723 * last Component in an application to receive a permanent FOCUS_GAINED
724 * event. The focus owner and permanent focus owner are equivalent unless
725 * a temporary focus change is currently in effect. In such a situation,
726 * the permanent focus owner will again be the focus owner when the
727 * temporary focus change ends.
728 * <p>
729 * This method does not actually set the focus to the specified Component.
730 * It merely stores the value to be subsequently returned by
731 * <code>getPermanentFocusOwner()</code>. Use
732 * <code>Component.requestFocus()</code> or
733 * <code>Component.requestFocusInWindow()</code> to change the focus owner,
734 * subject to platform limitations.
735 *
736 * @param permanentFocusOwner the permanent focus owner
737 * @see #getPermanentFocusOwner
738 * @see #getGlobalPermanentFocusOwner
739 * @see Component#requestFocus()
740 * @see Component#requestFocusInWindow()
741 * @see Component#isFocusable
742 * @throws SecurityException if this KeyboardFocusManager is not the
743 * current KeyboardFocusManager for the calling thread's context
744 * and if the calling thread does not have "replaceKeyboardFocusManager"
745 * permission
746 * @beaninfo
747 * bound: true
748 */
749 protected void setGlobalPermanentFocusOwner(Component permanentFocusOwner)
750 throws SecurityException
751 {
752 Component oldPermanentFocusOwner = null;
753 boolean shouldFire = false;
754
755 if (permanentFocusOwner == null || permanentFocusOwner.isFocusable()) {
756 synchronized (KeyboardFocusManager.class) {
757 checkKFMSecurity();
758
759 oldPermanentFocusOwner = getPermanentFocusOwner();
760
761 try {
762 fireVetoableChange("permanentFocusOwner",
763 oldPermanentFocusOwner,
764 permanentFocusOwner);
765 } catch (PropertyVetoException e) {
766 // rejected
767 return;
768 }
769
770 KeyboardFocusManager.permanentFocusOwner = permanentFocusOwner;
771
772 KeyboardFocusManager.
773 setMostRecentFocusOwner(permanentFocusOwner);
774
775 shouldFire = true;
776 }
777 }
778
779 if (shouldFire) {
780 firePropertyChange("permanentFocusOwner", oldPermanentFocusOwner,
781 permanentFocusOwner);
782 }
783 }
784
785 /**
786 * Returns the focused Window, if the focused Window is in the same context
787 * as the calling thread. The focused Window is the Window that is or
788 * contains the focus owner.
789 *
790 * @return the focused Window, or null if the focused Window is not a
791 * member of the calling thread's context
792 * @see #getGlobalFocusedWindow
793 * @see #setGlobalFocusedWindow
794 */
795 public Window getFocusedWindow() {
796 synchronized (KeyboardFocusManager.class) {
797 if (focusedWindow == null) {
798 return null;
799 }
800
801 return (focusedWindow.appContext == AppContext.getAppContext())
802 ? focusedWindow
803 : null;
804 }
805 }
806
807 /**
808 * Returns the focused Window, even if the calling thread is in a different
809 * context than the focused Window. The focused Window is the Window that
810 * is or contains the focus owner.
811 *
812 * @return the focused Window
813 * @see #getFocusedWindow
814 * @see #setGlobalFocusedWindow
815 * @throws SecurityException if this KeyboardFocusManager is not the
816 * current KeyboardFocusManager for the calling thread's context
817 * and if the calling thread does not have "replaceKeyboardFocusManager"
818 * permission
819 */
820 protected Window getGlobalFocusedWindow() throws SecurityException {
821 synchronized (KeyboardFocusManager.class) {
822 checkKFMSecurity();
823 return focusedWindow;
824 }
825 }
826
827 /**
828 * Sets the focused Window. The focused Window is the Window that is or
829 * contains the focus owner. The operation will be cancelled if the
830 * specified Window to focus is not a focusable Window.
831 * <p>
832 * This method does not actually change the focused Window as far as the
833 * native windowing system is concerned. It merely stores the value to be
834 * subsequently returned by <code>getFocusedWindow()</code>. Use
835 * <code>Component.requestFocus()</code> or
836 * <code>Component.requestFocusInWindow()</code> to change the focused
837 * Window, subject to platform limitations.
838 *
839 * @param focusedWindow the focused Window
840 * @see #getFocusedWindow
841 * @see #getGlobalFocusedWindow
842 * @see Component#requestFocus()
843 * @see Component#requestFocusInWindow()
844 * @see Window#isFocusableWindow
845 * @throws SecurityException if this KeyboardFocusManager is not the
846 * current KeyboardFocusManager for the calling thread's context
847 * and if the calling thread does not have "replaceKeyboardFocusManager"
848 * permission
849 * @beaninfo
850 * bound: true
851 */
852 protected void setGlobalFocusedWindow(Window focusedWindow)
853 throws SecurityException
854 {
855 Window oldFocusedWindow = null;
856 boolean shouldFire = false;
857
858 if (focusedWindow == null || focusedWindow.isFocusableWindow()) {
859 synchronized (KeyboardFocusManager.class) {
860 checkKFMSecurity();
861
862 oldFocusedWindow = getFocusedWindow();
863
864 try {
865 fireVetoableChange("focusedWindow", oldFocusedWindow,
866 focusedWindow);
867 } catch (PropertyVetoException e) {
868 // rejected
869 return;
870 }
871
872 KeyboardFocusManager.focusedWindow = focusedWindow;
873 shouldFire = true;
874 }
875 }
876
877 if (shouldFire) {
878 firePropertyChange("focusedWindow", oldFocusedWindow,
879 focusedWindow);
880 }
881 }
882
883 /**
884 * Returns the active Window, if the active Window is in the same context
885 * as the calling thread. Only a Frame or a Dialog can be the active
886 * Window. The native windowing system may denote the active Window or its
887 * children with special decorations, such as a highlighted title bar.
888 * The active Window is always either the focused Window, or the first
889 * Frame or Dialog that is an owner of the focused Window.
890 *
891 * @return the active Window, or null if the active Window is not a member
892 * of the calling thread's context
893 * @see #getGlobalActiveWindow
894 * @see #setGlobalActiveWindow
895 */
896 public Window getActiveWindow() {
897 synchronized (KeyboardFocusManager.class) {
898 if (activeWindow == null) {
899 return null;
900 }
901
902 return (activeWindow.appContext == AppContext.getAppContext())
903 ? activeWindow
904 : null;
905 }
906 }
907
908 /**
909 * Returns the active Window, even if the calling thread is in a different
910 * context than the active Window. Only a Frame or a Dialog can be the
911 * active Window. The native windowing system may denote the active Window
912 * or its children with special decorations, such as a highlighted title
913 * bar. The active Window is always either the focused Window, or the first
914 * Frame or Dialog that is an owner of the focused Window.
915 *
916 * @return the active Window
917 * @see #getActiveWindow
918 * @see #setGlobalActiveWindow
919 * @throws SecurityException if this KeyboardFocusManager is not the
920 * current KeyboardFocusManager for the calling thread's context
921 * and if the calling thread does not have "replaceKeyboardFocusManager"
922 * permission
923 */
924 protected Window getGlobalActiveWindow() throws SecurityException {
925 synchronized (KeyboardFocusManager.class) {
926 checkKFMSecurity();
927 return activeWindow;
928 }
929 }
930
931 /**
932 * Sets the active Window. Only a Frame or a Dialog can be the active
933 * Window. The native windowing system may denote the active Window or its
934 * children with special decorations, such as a highlighted title bar. The
935 * active Window is always either the focused Window, or the first Frame or
936 * Dialog that is an owner of the focused Window.
937 * <p>
938 * This method does not actually change the active Window as far as the
939 * native windowing system is concerned. It merely stores the value to be
940 * subsequently returned by <code>getActiveWindow()</code>. Use
941 * <code>Component.requestFocus()</code> or
942 * <code>Component.requestFocusInWindow()</code>to change the active
943 * Window, subject to platform limitations.
944 *
945 * @param activeWindow the active Window
946 * @see #getActiveWindow
947 * @see #getGlobalActiveWindow
948 * @see Component#requestFocus()
949 * @see Component#requestFocusInWindow()
950 * @throws SecurityException if this KeyboardFocusManager is not the
951 * current KeyboardFocusManager for the calling thread's context
952 * and if the calling thread does not have "replaceKeyboardFocusManager"
953 * permission
954 * @beaninfo
955 * bound: true
956 */
957 protected void setGlobalActiveWindow(Window activeWindow)
958 throws SecurityException
959 {
960 Window oldActiveWindow;
961 synchronized (KeyboardFocusManager.class) {
962 checkKFMSecurity();
963
964 oldActiveWindow = getActiveWindow();
965 if (focusLog.isLoggable(PlatformLogger.Level.FINER)) {
966 focusLog.finer("Setting global active window to " + activeWindow + ", old active " + oldActiveWindow);
967 }
968
969 try {
970 fireVetoableChange("activeWindow", oldActiveWindow,
971 activeWindow);
972 } catch (PropertyVetoException e) {
973 // rejected
974 return;
975 }
976
977 KeyboardFocusManager.activeWindow = activeWindow;
978 }
979
980 firePropertyChange("activeWindow", oldActiveWindow, activeWindow);
981 }
982
983 /**
984 * Returns the default FocusTraversalPolicy. Top-level components
985 * use this value on their creation to initialize their own focus traversal
986 * policy by explicit call to Container.setFocusTraversalPolicy.
987 *
988 * @return the default FocusTraversalPolicy. null will never be returned.
989 * @see #setDefaultFocusTraversalPolicy
990 * @see Container#setFocusTraversalPolicy
991 * @see Container#getFocusTraversalPolicy
992 */
993 public synchronized FocusTraversalPolicy getDefaultFocusTraversalPolicy() {
994 return defaultPolicy;
995 }
996
997 /**
998 * Sets the default FocusTraversalPolicy. Top-level components
999 * use this value on their creation to initialize their own focus traversal
1000 * policy by explicit call to Container.setFocusTraversalPolicy.
1001 * Note: this call doesn't affect already created components as they have
1002 * their policy initialized. Only new components will use this policy as
1003 * their default policy.
1004 *
1005 * @param defaultPolicy the new, default FocusTraversalPolicy
1006 * @see #getDefaultFocusTraversalPolicy
1007 * @see Container#setFocusTraversalPolicy
1008 * @see Container#getFocusTraversalPolicy
1009 * @throws IllegalArgumentException if defaultPolicy is null
1010 * @beaninfo
1011 * bound: true
1012 */
1013 public void setDefaultFocusTraversalPolicy(FocusTraversalPolicy
1014 defaultPolicy) {
1015 if (defaultPolicy == null) {
1016 throw new IllegalArgumentException("default focus traversal policy cannot be null");
1017 }
1018
1019 FocusTraversalPolicy oldPolicy;
1020
1021 synchronized (this) {
1022 oldPolicy = this.defaultPolicy;
1023 this.defaultPolicy = defaultPolicy;
1024 }
1025
1026 firePropertyChange("defaultFocusTraversalPolicy", oldPolicy,
1027 defaultPolicy);
1028 }
1029
1030 /**
1031 * Sets the default focus traversal keys for a given traversal operation.
1032 * This traversal key {@code Set} will be in effect on all
1033 * {@code Window}s that have no such {@code Set} of
1034 * their own explicitly defined. This {@code Set} will also be
1035 * inherited, recursively, by any child {@code Component} of
1036 * those {@code Windows} that has
1037 * no such {@code Set} of its own explicitly defined.
1038 * <p>
1039 * The default values for the default focus traversal keys are
1040 * implementation-dependent. Sun recommends that all implementations for a
1041 * particular native platform use the same default values. The
1042 * recommendations for Windows and Unix are listed below. These
1043 * recommendations are used in the Sun AWT implementations.
1044 *
1045 * <table border=1 summary="Recommended default values for focus traversal keys">
1046 * <tr>
1047 * <th>Identifier</th>
1048 * <th>Meaning</th>
1049 * <th>Default</th>
1050 * </tr>
1051 * <tr>
1052 * <td>{@code KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS}</td>
1053 * <td>Normal forward keyboard traversal</td>
1054 * <td>{@code TAB} on {@code KEY_PRESSED},
1055 * {@code CTRL-TAB} on {@code KEY_PRESSED}</td>
1056 * </tr>
1057 * <tr>
1058 * <td>{@code KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS}</td>
1059 * <td>Normal reverse keyboard traversal</td>
1060 * <td>{@code SHIFT-TAB} on {@code KEY_PRESSED},
1061 * {@code CTRL-SHIFT-TAB} on {@code KEY_PRESSED}</td>
1062 * </tr>
1063 * <tr>
1064 * <td>{@code KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS}</td>
1065 * <td>Go up one focus traversal cycle</td>
1066 * <td>none</td>
1067 * </tr>
1068 * <tr>
1069 * <td>{@code KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYS}</td>
1070 * <td>Go down one focus traversal cycle</td>
1071 * <td>none</td>
1072 * </tr>
1073 * </table>
1074 *
1075 * To disable a traversal key, use an empty {@code Set};
1076 * {@code Collections.EMPTY_SET} is recommended.
1077 * <p>
1078 * Using the {@code AWTKeyStroke} API, client code can
1079 * specify on which of two
1080 * specific {@code KeyEvent}s, {@code KEY_PRESSED} or
1081 * {@code KEY_RELEASED}, the focus traversal operation will
1082 * occur. Regardless of which {@code KeyEvent} is specified,
1083 * however, all {@code KeyEvent}s related to the focus
1084 * traversal key, including the associated {@code KEY_TYPED}
1085 * event, will be consumed, and will not be dispatched
1086 * to any {@code Component}. It is a runtime error to
1087 * specify a {@code KEY_TYPED} event as
1088 * mapping to a focus traversal operation, or to map the same event to
1089 * multiple default focus traversal operations.
1090 * <p>
1091 * This method may throw a {@code ClassCastException} if any {@code Object}
1092 * in {@code keystrokes} is not an {@code AWTKeyStroke}.
1093 *
1094 * @param id one of
1095 * {@code KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS},
1096 * {@code KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS},
1097 * {@code KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS}, or
1098 * {@code KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYS}
1099 * @param keystrokes the Set of {@code AWTKeyStroke}s for the
1100 * specified operation
1101 * @see #getDefaultFocusTraversalKeys
1102 * @see Component#setFocusTraversalKeys
1103 * @see Component#getFocusTraversalKeys
1104 * @throws IllegalArgumentException if id is not one of
1105 * {@code KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS},
1106 * {@code KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS},
1107 * {@code KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS}, or
1108 * {@code KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYS},
1109 * or if keystrokes is {@code null},
1110 * or if keystrokes contains {@code null},
1111 * or if any keystroke
1112 * represents a {@code KEY_TYPED} event,
1113 * or if any keystroke already maps
1114 * to another default focus traversal operation
1115 * @beaninfo
1116 * bound: true
1117 */
1118 public void
1119 setDefaultFocusTraversalKeys(int id,
1120 Set<? extends AWTKeyStroke> keystrokes)
1121 {
1122 if (id < 0 || id >= TRAVERSAL_KEY_LENGTH) {
1123 throw new IllegalArgumentException("invalid focus traversal key identifier");
1124 }
1125 if (keystrokes == null) {
1126 throw new IllegalArgumentException("cannot set null Set of default focus traversal keys");
1127 }
1128
1129 Set<AWTKeyStroke> oldKeys;
1130
1131 synchronized (this) {
1132 for (AWTKeyStroke keystroke : keystrokes) {
1133
1134 if (keystroke == null) {
1135 throw new IllegalArgumentException("cannot set null focus traversal key");
1136 }
1137
1138 if (keystroke.getKeyChar() != KeyEvent.CHAR_UNDEFINED) {
1139 throw new IllegalArgumentException("focus traversal keys cannot map to KEY_TYPED events");
1140 }
1141
1142 // Check to see if key already maps to another traversal
1143 // operation
1144 for (int i = 0; i < TRAVERSAL_KEY_LENGTH; i++) {
1145 if (i == id) {
1146 continue;
1147 }
1148
1149 if (defaultFocusTraversalKeys[i].contains(keystroke)) {
1150 throw new IllegalArgumentException("focus traversal keys must be unique for a Component");
1151 }
1152 }
1153 }
1154
1155 oldKeys = defaultFocusTraversalKeys[id];
1156 defaultFocusTraversalKeys[id] =
1157 Collections.unmodifiableSet(new HashSet<>(keystrokes));
1158 }
1159
1160 firePropertyChange(defaultFocusTraversalKeyPropertyNames[id],
1161 oldKeys, keystrokes);
1162 }
1163
1164 /**
1165 * Returns a Set of default focus traversal keys for a given traversal
1166 * operation. This traversal key Set will be in effect on all Windows that
1167 * have no such Set of their own explicitly defined. This Set will also be
1168 * inherited, recursively, by any child Component of those Windows that has
1169 * no such Set of its own explicitly defined. (See
1170 * <code>setDefaultFocusTraversalKeys</code> for a full description of each
1171 * operation.)
1172 *
1173 * @param id one of KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS,
1174 * KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS,
1175 * KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS, or
1176 * KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYS
1177 * @return the <code>Set</code> of <code>AWTKeyStroke</code>s
1178 * for the specified operation; the <code>Set</code>
1179 * will be unmodifiable, and may be empty; <code>null</code>
1180 * will never be returned
1181 * @see #setDefaultFocusTraversalKeys
1182 * @see Component#setFocusTraversalKeys
1183 * @see Component#getFocusTraversalKeys
1184 * @throws IllegalArgumentException if id is not one of
1185 * KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS,
1186 * KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS,
1187 * KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS, or
1188 * KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYS
1189 */
1190 public Set<AWTKeyStroke> getDefaultFocusTraversalKeys(int id) {
1191 if (id < 0 || id >= TRAVERSAL_KEY_LENGTH) {
1192 throw new IllegalArgumentException("invalid focus traversal key identifier");
1193 }
1194
1195 // Okay to return Set directly because it is an unmodifiable view
1196 return defaultFocusTraversalKeys[id];
1197 }
1198
1199 /**
1200 * Returns the current focus cycle root, if the current focus cycle root is
1201 * in the same context as the calling thread. If the focus owner is itself
1202 * a focus cycle root, then it may be ambiguous as to which Components
1203 * represent the next and previous Components to focus during normal focus
1204 * traversal. In that case, the current focus cycle root is used to
1205 * differentiate among the possibilities.
1206 * <p>
1207 * This method is intended to be used only by KeyboardFocusManagers and
1208 * focus implementations. It is not for general client use.
1209 *
1210 * @return the current focus cycle root, or null if the current focus cycle
1211 * root is not a member of the calling thread's context
1212 * @see #getGlobalCurrentFocusCycleRoot
1213 * @see #setGlobalCurrentFocusCycleRoot
1214 */
1215 public Container getCurrentFocusCycleRoot() {
1216 synchronized (KeyboardFocusManager.class) {
1217 if (currentFocusCycleRoot == null) {
1218 return null;
1219 }
1220
1221 return (currentFocusCycleRoot.appContext ==
1222 AppContext.getAppContext())
1223 ? currentFocusCycleRoot
1224 : null;
1225 }
1226 }
1227
1228 /**
1229 * Returns the current focus cycle root, even if the calling thread is in a
1230 * different context than the current focus cycle root. If the focus owner
1231 * is itself a focus cycle root, then it may be ambiguous as to which
1232 * Components represent the next and previous Components to focus during
1233 * normal focus traversal. In that case, the current focus cycle root is
1234 * used to differentiate among the possibilities.
1235 *
1236 * @return the current focus cycle root, or null if the current focus cycle
1237 * root is not a member of the calling thread's context
1238 * @see #getCurrentFocusCycleRoot
1239 * @see #setGlobalCurrentFocusCycleRoot
1240 * @throws SecurityException if this KeyboardFocusManager is not the
1241 * current KeyboardFocusManager for the calling thread's context
1242 * and if the calling thread does not have "replaceKeyboardFocusManager"
1243 * permission
1244 */
1245 protected Container getGlobalCurrentFocusCycleRoot()
1246 throws SecurityException
1247 {
1248 synchronized (KeyboardFocusManager.class) {
1249 checkKFMSecurity();
1250 return currentFocusCycleRoot;
1251 }
1252 }
1253
1254 /**
1255 * Sets the current focus cycle root. If the focus owner is itself a focus
1256 * cycle root, then it may be ambiguous as to which Components represent
1257 * the next and previous Components to focus during normal focus traversal.
1258 * In that case, the current focus cycle root is used to differentiate
1259 * among the possibilities.
1260 * <p>
1261 * If a SecurityManager is installed, the calling thread must be granted
1262 * the "replaceKeyboardFocusManager" AWTPermission. If this permission is
1263 * not granted, this method will throw a SecurityException, and the current
1264 * focus cycle root will not be changed.
1265 * <p>
1266 * This method is intended to be used only by KeyboardFocusManagers and
1267 * focus implementations. It is not for general client use.
1268 *
1269 * @param newFocusCycleRoot the new focus cycle root
1270 * @see #getCurrentFocusCycleRoot
1271 * @see #getGlobalCurrentFocusCycleRoot
1272 * @throws SecurityException if the calling thread does not have
1273 * "replaceKeyboardFocusManager" permission
1274 * @beaninfo
1275 * bound: true
1276 */
1277 public void setGlobalCurrentFocusCycleRoot(Container newFocusCycleRoot)
1278 throws SecurityException
1279 {
1280 checkReplaceKFMPermission();
1281
1282 Container oldFocusCycleRoot;
1283
1284 synchronized (KeyboardFocusManager.class) {
1285 oldFocusCycleRoot = getCurrentFocusCycleRoot();
1286 currentFocusCycleRoot = newFocusCycleRoot;
1287 }
1288
1289 firePropertyChange("currentFocusCycleRoot", oldFocusCycleRoot,
1290 newFocusCycleRoot);
1291 }
1292
1293 void setGlobalCurrentFocusCycleRootPriv(final Container newFocusCycleRoot) {
1294 AccessController.doPrivileged(new PrivilegedAction<Void>() {
1295 public Void run() {
1296 setGlobalCurrentFocusCycleRoot(newFocusCycleRoot);
1297 return null;
1298 }
1299 });
1300 }
1301
1302 /**
1303 * Adds a PropertyChangeListener to the listener list. The listener is
1304 * registered for all bound properties of this class, including the
1305 * following:
1306 * <ul>
1307 * <li>whether the KeyboardFocusManager is currently managing focus
1308 * for this application or applet's browser context
1309 * ("managingFocus")</li>
1310 * <li>the focus owner ("focusOwner")</li>
1311 * <li>the permanent focus owner ("permanentFocusOwner")</li>
1312 * <li>the focused Window ("focusedWindow")</li>
1313 * <li>the active Window ("activeWindow")</li>
1314 * <li>the default focus traversal policy
1315 * ("defaultFocusTraversalPolicy")</li>
1316 * <li>the Set of default FORWARD_TRAVERSAL_KEYS
1317 * ("forwardDefaultFocusTraversalKeys")</li>
1318 * <li>the Set of default BACKWARD_TRAVERSAL_KEYS
1319 * ("backwardDefaultFocusTraversalKeys")</li>
1320 * <li>the Set of default UP_CYCLE_TRAVERSAL_KEYS
1321 * ("upCycleDefaultFocusTraversalKeys")</li>
1322 * <li>the Set of default DOWN_CYCLE_TRAVERSAL_KEYS
1323 * ("downCycleDefaultFocusTraversalKeys")</li>
1324 * <li>the current focus cycle root ("currentFocusCycleRoot")</li>
1325 * </ul>
1326 * If listener is null, no exception is thrown and no action is performed.
1327 *
1328 * @param listener the PropertyChangeListener to be added
1329 * @see #removePropertyChangeListener
1330 * @see #getPropertyChangeListeners
1331 * @see #addPropertyChangeListener(java.lang.String,java.beans.PropertyChangeListener)
1332 */
1333 public void addPropertyChangeListener(PropertyChangeListener listener) {
1334 if (listener != null) {
1335 synchronized (this) {
1336 if (changeSupport == null) {
1337 changeSupport = new PropertyChangeSupport(this);
1338 }
1339 changeSupport.addPropertyChangeListener(listener);
1340 }
1341 }
1342 }
1343
1344 /**
1345 * Removes a PropertyChangeListener from the listener list. This method
1346 * should be used to remove the PropertyChangeListeners that were
1347 * registered for all bound properties of this class.
1348 * <p>
1349 * If listener is null, no exception is thrown and no action is performed.
1350 *
1351 * @param listener the PropertyChangeListener to be removed
1352 * @see #addPropertyChangeListener
1353 * @see #getPropertyChangeListeners
1354 * @see #removePropertyChangeListener(java.lang.String,java.beans.PropertyChangeListener)
1355 */
1356 public void removePropertyChangeListener(PropertyChangeListener listener) {
1357 if (listener != null) {
1358 synchronized (this) {
1359 if (changeSupport != null) {
1360 changeSupport.removePropertyChangeListener(listener);
1361 }
1362 }
1363 }
1364 }
1365
1366 /**
1367 * Returns an array of all the property change listeners
1368 * registered on this keyboard focus manager.
1369 *
1370 * @return all of this keyboard focus manager's
1371 * <code>PropertyChangeListener</code>s
1372 * or an empty array if no property change
1373 * listeners are currently registered
1374 *
1375 * @see #addPropertyChangeListener
1376 * @see #removePropertyChangeListener
1377 * @see #getPropertyChangeListeners(java.lang.String)
1378 * @since 1.4
1379 */
1380 public synchronized PropertyChangeListener[] getPropertyChangeListeners() {
1381 if (changeSupport == null) {
1382 changeSupport = new PropertyChangeSupport(this);
1383 }
1384 return changeSupport.getPropertyChangeListeners();
1385 }
1386
1387 /**
1388 * Adds a PropertyChangeListener to the listener list for a specific
1389 * property. The specified property may be user-defined, or one of the
1390 * following:
1391 * <ul>
1392 * <li>whether the KeyboardFocusManager is currently managing focus
1393 * for this application or applet's browser context
1394 * ("managingFocus")</li>
1395 * <li>the focus owner ("focusOwner")</li>
1396 * <li>the permanent focus owner ("permanentFocusOwner")</li>
1397 * <li>the focused Window ("focusedWindow")</li>
1398 * <li>the active Window ("activeWindow")</li>
1399 * <li>the default focus traversal policy
1400 * ("defaultFocusTraversalPolicy")</li>
1401 * <li>the Set of default FORWARD_TRAVERSAL_KEYS
1402 * ("forwardDefaultFocusTraversalKeys")</li>
1403 * <li>the Set of default BACKWARD_TRAVERSAL_KEYS
1404 * ("backwardDefaultFocusTraversalKeys")</li>
1405 * <li>the Set of default UP_CYCLE_TRAVERSAL_KEYS
1406 * ("upCycleDefaultFocusTraversalKeys")</li>
1407 * <li>the Set of default DOWN_CYCLE_TRAVERSAL_KEYS
1408 * ("downCycleDefaultFocusTraversalKeys")</li>
1409 * <li>the current focus cycle root ("currentFocusCycleRoot")</li>
1410 * </ul>
1411 * If listener is null, no exception is thrown and no action is performed.
1412 *
1413 * @param propertyName one of the property names listed above
1414 * @param listener the PropertyChangeListener to be added
1415 * @see #addPropertyChangeListener(java.beans.PropertyChangeListener)
1416 * @see #removePropertyChangeListener(java.lang.String,java.beans.PropertyChangeListener)
1417 * @see #getPropertyChangeListeners(java.lang.String)
1418 */
1419 public void addPropertyChangeListener(String propertyName,
1420 PropertyChangeListener listener) {
1421 if (listener != null) {
1422 synchronized (this) {
1423 if (changeSupport == null) {
1424 changeSupport = new PropertyChangeSupport(this);
1425 }
1426 changeSupport.addPropertyChangeListener(propertyName,
1427 listener);
1428 }
1429 }
1430 }
1431
1432 /**
1433 * Removes a PropertyChangeListener from the listener list for a specific
1434 * property. This method should be used to remove PropertyChangeListeners
1435 * that were registered for a specific bound property.
1436 * <p>
1437 * If listener is null, no exception is thrown and no action is performed.
1438 *
1439 * @param propertyName a valid property name
1440 * @param listener the PropertyChangeListener to be removed
1441 * @see #addPropertyChangeListener(java.lang.String,java.beans.PropertyChangeListener)
1442 * @see #getPropertyChangeListeners(java.lang.String)
1443 * @see #removePropertyChangeListener(java.beans.PropertyChangeListener)
1444 */
1445 public void removePropertyChangeListener(String propertyName,
1446 PropertyChangeListener listener) {
1447 if (listener != null) {
1448 synchronized (this) {
1449 if (changeSupport != null) {
1450 changeSupport.removePropertyChangeListener(propertyName,
1451 listener);
1452 }
1453 }
1454 }
1455 }
1456
1457 /**
1458 * Returns an array of all the <code>PropertyChangeListener</code>s
1459 * associated with the named property.
1460 *
1461 * @return all of the <code>PropertyChangeListener</code>s associated with
1462 * the named property or an empty array if no such listeners have
1463 * been added.
1464 *
1465 * @see #addPropertyChangeListener(java.lang.String,java.beans.PropertyChangeListener)
1466 * @see #removePropertyChangeListener(java.lang.String,java.beans.PropertyChangeListener)
1467 * @since 1.4
1468 */
1469 public synchronized PropertyChangeListener[] getPropertyChangeListeners(String propertyName) {
1470 if (changeSupport == null) {
1471 changeSupport = new PropertyChangeSupport(this);
1472 }
1473 return changeSupport.getPropertyChangeListeners(propertyName);
1474 }
1475
1476 /**
1477 * Fires a PropertyChangeEvent in response to a change in a bound property.
1478 * The event will be delivered to all registered PropertyChangeListeners.
1479 * No event will be delivered if oldValue and newValue are the same.
1480 *
1481 * @param propertyName the name of the property that has changed
1482 * @param oldValue the property's previous value
1483 * @param newValue the property's new value
1484 */
1485 protected void firePropertyChange(String propertyName, Object oldValue,
1486 Object newValue)
1487 {
1488 if (oldValue == newValue) {
1489 return;
1490 }
1491 PropertyChangeSupport changeSupport = this.changeSupport;
1492 if (changeSupport != null) {
1493 changeSupport.firePropertyChange(propertyName, oldValue, newValue);
1494 }
1495 }
1496
1497 /**
1498 * Adds a VetoableChangeListener to the listener list. The listener is
1499 * registered for all vetoable properties of this class, including the
1500 * following:
1501 * <ul>
1502 * <li>the focus owner ("focusOwner")</li>
1503 * <li>the permanent focus owner ("permanentFocusOwner")</li>
1504 * <li>the focused Window ("focusedWindow")</li>
1505 * <li>the active Window ("activeWindow")</li>
1506 * </ul>
1507 * If listener is null, no exception is thrown and no action is performed.
1508 *
1509 * @param listener the VetoableChangeListener to be added
1510 * @see #removeVetoableChangeListener
1511 * @see #getVetoableChangeListeners
1512 * @see #addVetoableChangeListener(java.lang.String,java.beans.VetoableChangeListener)
1513 */
1514 public void addVetoableChangeListener(VetoableChangeListener listener) {
1515 if (listener != null) {
1516 synchronized (this) {
1517 if (vetoableSupport == null) {
1518 vetoableSupport =
1519 new VetoableChangeSupport(this);
1520 }
1521 vetoableSupport.addVetoableChangeListener(listener);
1522 }
1523 }
1524 }
1525
1526 /**
1527 * Removes a VetoableChangeListener from the listener list. This method
1528 * should be used to remove the VetoableChangeListeners that were
1529 * registered for all vetoable properties of this class.
1530 * <p>
1531 * If listener is null, no exception is thrown and no action is performed.
1532 *
1533 * @param listener the VetoableChangeListener to be removed
1534 * @see #addVetoableChangeListener
1535 * @see #getVetoableChangeListeners
1536 * @see #removeVetoableChangeListener(java.lang.String,java.beans.VetoableChangeListener)
1537 */
1538 public void removeVetoableChangeListener(VetoableChangeListener listener) {
1539 if (listener != null) {
1540 synchronized (this) {
1541 if (vetoableSupport != null) {
1542 vetoableSupport.removeVetoableChangeListener(listener);
1543 }
1544 }
1545 }
1546 }
1547
1548 /**
1549 * Returns an array of all the vetoable change listeners
1550 * registered on this keyboard focus manager.
1551 *
1552 * @return all of this keyboard focus manager's
1553 * <code>VetoableChangeListener</code>s
1554 * or an empty array if no vetoable change
1555 * listeners are currently registered
1556 *
1557 * @see #addVetoableChangeListener
1558 * @see #removeVetoableChangeListener
1559 * @see #getVetoableChangeListeners(java.lang.String)
1560 * @since 1.4
1561 */
1562 public synchronized VetoableChangeListener[] getVetoableChangeListeners() {
1563 if (vetoableSupport == null) {
1564 vetoableSupport = new VetoableChangeSupport(this);
1565 }
1566 return vetoableSupport.getVetoableChangeListeners();
1567 }
1568
1569 /**
1570 * Adds a VetoableChangeListener to the listener list for a specific
1571 * property. The specified property may be user-defined, or one of the
1572 * following:
1573 * <ul>
1574 * <li>the focus owner ("focusOwner")</li>
1575 * <li>the permanent focus owner ("permanentFocusOwner")</li>
1576 * <li>the focused Window ("focusedWindow")</li>
1577 * <li>the active Window ("activeWindow")</li>
1578 * </ul>
1579 * If listener is null, no exception is thrown and no action is performed.
1580 *
1581 * @param propertyName one of the property names listed above
1582 * @param listener the VetoableChangeListener to be added
1583 * @see #addVetoableChangeListener(java.beans.VetoableChangeListener)
1584 * @see #removeVetoableChangeListener
1585 * @see #getVetoableChangeListeners
1586 */
1587 public void addVetoableChangeListener(String propertyName,
1588 VetoableChangeListener listener) {
1589 if (listener != null) {
1590 synchronized (this) {
1591 if (vetoableSupport == null) {
1592 vetoableSupport =
1593 new VetoableChangeSupport(this);
1594 }
1595 vetoableSupport.addVetoableChangeListener(propertyName,
1596 listener);
1597 }
1598 }
1599 }
1600
1601 /**
1602 * Removes a VetoableChangeListener from the listener list for a specific
1603 * property. This method should be used to remove VetoableChangeListeners
1604 * that were registered for a specific bound property.
1605 * <p>
1606 * If listener is null, no exception is thrown and no action is performed.
1607 *
1608 * @param propertyName a valid property name
1609 * @param listener the VetoableChangeListener to be removed
1610 * @see #addVetoableChangeListener
1611 * @see #getVetoableChangeListeners
1612 * @see #removeVetoableChangeListener(java.beans.VetoableChangeListener)
1613 */
1614 public void removeVetoableChangeListener(String propertyName,
1615 VetoableChangeListener listener) {
1616 if (listener != null) {
1617 synchronized (this) {
1618 if (vetoableSupport != null) {
1619 vetoableSupport.removeVetoableChangeListener(propertyName,
1620 listener);
1621 }
1622 }
1623 }
1624 }
1625
1626 /**
1627 * Returns an array of all the <code>VetoableChangeListener</code>s
1628 * associated with the named property.
1629 *
1630 * @return all of the <code>VetoableChangeListener</code>s associated with
1631 * the named property or an empty array if no such listeners have
1632 * been added.
1633 *
1634 * @see #addVetoableChangeListener(java.lang.String,java.beans.VetoableChangeListener)
1635 * @see #removeVetoableChangeListener(java.lang.String,java.beans.VetoableChangeListener)
1636 * @see #getVetoableChangeListeners
1637 * @since 1.4
1638 */
1639 public synchronized VetoableChangeListener[] getVetoableChangeListeners(String propertyName) {
1640 if (vetoableSupport == null) {
1641 vetoableSupport = new VetoableChangeSupport(this);
1642 }
1643 return vetoableSupport.getVetoableChangeListeners(propertyName);
1644 }
1645
1646 /**
1647 * Fires a PropertyChangeEvent in response to a change in a vetoable
1648 * property. The event will be delivered to all registered
1649 * VetoableChangeListeners. If a VetoableChangeListener throws a
1650 * PropertyVetoException, a new event is fired reverting all
1651 * VetoableChangeListeners to the old value and the exception is then
1652 * rethrown. No event will be delivered if oldValue and newValue are the
1653 * same.
1654 *
1655 * @param propertyName the name of the property that has changed
1656 * @param oldValue the property's previous value
1657 * @param newValue the property's new value
1658 * @throws java.beans.PropertyVetoException if a
1659 * <code>VetoableChangeListener</code> threw
1660 * <code>PropertyVetoException</code>
1661 */
1662 protected void fireVetoableChange(String propertyName, Object oldValue,
1663 Object newValue)
1664 throws PropertyVetoException
1665 {
1666 if (oldValue == newValue) {
1667 return;
1668 }
1669 VetoableChangeSupport vetoableSupport =
1670 this.vetoableSupport;
1671 if (vetoableSupport != null) {
1672 vetoableSupport.fireVetoableChange(propertyName, oldValue,
1673 newValue);
1674 }
1675 }
1676
1677 /**
1678 * Adds a KeyEventDispatcher to this KeyboardFocusManager's dispatcher
1679 * chain. This KeyboardFocusManager will request that each
1680 * KeyEventDispatcher dispatch KeyEvents generated by the user before
1681 * finally dispatching the KeyEvent itself. KeyEventDispatchers will be
1682 * notified in the order in which they were added. Notifications will halt
1683 * as soon as one KeyEventDispatcher returns <code>true</code> from its
1684 * <code>dispatchKeyEvent</code> method. There is no limit to the total
1685 * number of KeyEventDispatchers which can be added, nor to the number of
1686 * times which a particular KeyEventDispatcher instance can be added.
1687 * <p>
1688 * If a null dispatcher is specified, no action is taken and no exception
1689 * is thrown.
1690 * <p>
1691 * In a multithreaded application, {@link KeyEventDispatcher} behaves
1692 * the same as other AWT listeners. See
1693 * <a href="doc-files/AWTThreadIssues.html#ListenersThreads"
1694 * >AWT Threading Issues</a> for more details.
1695 *
1696 * @param dispatcher the KeyEventDispatcher to add to the dispatcher chain
1697 * @see #removeKeyEventDispatcher
1698 */
1699 public void addKeyEventDispatcher(KeyEventDispatcher dispatcher) {
1700 if (dispatcher != null) {
1701 synchronized (this) {
1702 if (keyEventDispatchers == null) {
1703 keyEventDispatchers = new java.util.LinkedList<>();
1704 }
1705 keyEventDispatchers.add(dispatcher);
1706 }
1707 }
1708 }
1709
1710 /**
1711 * Removes a KeyEventDispatcher which was previously added to this
1712 * KeyboardFocusManager's dispatcher chain. This KeyboardFocusManager
1713 * cannot itself be removed, unless it was explicitly re-registered via a
1714 * call to <code>addKeyEventDispatcher</code>.
1715 * <p>
1716 * If a null dispatcher is specified, if the specified dispatcher is not
1717 * in the dispatcher chain, or if this KeyboardFocusManager is specified
1718 * without having been explicitly re-registered, no action is taken and no
1719 * exception is thrown.
1720 * <p>
1721 * In a multithreaded application, {@link KeyEventDispatcher} behaves
1722 * the same as other AWT listeners. See
1723 * <a href="doc-files/AWTThreadIssues.html#ListenersThreads"
1724 * >AWT Threading Issues</a> for more details.
1725 *
1726 * @param dispatcher the KeyEventDispatcher to remove from the dispatcher
1727 * chain
1728 * @see #addKeyEventDispatcher
1729 */
1730 public void removeKeyEventDispatcher(KeyEventDispatcher dispatcher) {
1731 if (dispatcher != null) {
1732 synchronized (this) {
1733 if (keyEventDispatchers != null) {
1734 keyEventDispatchers.remove(dispatcher);
1735 }
1736 }
1737 }
1738 }
1739
1740 /**
1741 * Returns this KeyboardFocusManager's KeyEventDispatcher chain as a List.
1742 * The List will not include this KeyboardFocusManager unless it was
1743 * explicitly re-registered via a call to
1744 * <code>addKeyEventDispatcher</code>. If no other KeyEventDispatchers are
1745 * registered, implementations are free to return null or a List of length
1746 * 0. Client code should not assume one behavior over another, nor should
1747 * it assume that the behavior, once established, will not change.
1748 *
1749 * @return a possibly null or empty List of KeyEventDispatchers
1750 * @see #addKeyEventDispatcher
1751 * @see #removeKeyEventDispatcher
1752 */
1753 protected synchronized java.util.List<KeyEventDispatcher>
1754 getKeyEventDispatchers()
1755 {
1756 return (keyEventDispatchers != null)
1757 ? (java.util.List)keyEventDispatchers.clone()
1758 : null;
1759 }
1760
1761 /**
1762 * Adds a KeyEventPostProcessor to this KeyboardFocusManager's post-
1763 * processor chain. After a KeyEvent has been dispatched to and handled by
1764 * its target, KeyboardFocusManager will request that each
1765 * KeyEventPostProcessor perform any necessary post-processing as part
1766 * of the KeyEvent's final resolution. KeyEventPostProcessors
1767 * will be notified in the order in which they were added; the current
1768 * KeyboardFocusManager will be notified last. Notifications will halt
1769 * as soon as one KeyEventPostProcessor returns <code>true</code> from its
1770 * <code>postProcessKeyEvent</code> method. There is no limit to the the
1771 * total number of KeyEventPostProcessors that can be added, nor to the
1772 * number of times that a particular KeyEventPostProcessor instance can be
1773 * added.
1774 * <p>
1775 * If a null post-processor is specified, no action is taken and no
1776 * exception is thrown.
1777 * <p>
1778 * In a multithreaded application, {@link KeyEventPostProcessor} behaves
1779 * the same as other AWT listeners. See
1780 * <a href="doc-files/AWTThreadIssues.html#ListenersThreads"
1781 * >AWT Threading Issues</a> for more details.
1782 *
1783 * @param processor the KeyEventPostProcessor to add to the post-processor
1784 * chain
1785 * @see #removeKeyEventPostProcessor
1786 */
1787 public void addKeyEventPostProcessor(KeyEventPostProcessor processor) {
1788 if (processor != null) {
1789 synchronized (this) {
1790 if (keyEventPostProcessors == null) {
1791 keyEventPostProcessors = new java.util.LinkedList<>();
1792 }
1793 keyEventPostProcessors.add(processor);
1794 }
1795 }
1796 }
1797
1798
1799 /**
1800 * Removes a previously added KeyEventPostProcessor from this
1801 * KeyboardFocusManager's post-processor chain. This KeyboardFocusManager
1802 * cannot itself be entirely removed from the chain. Only additional
1803 * references added via <code>addKeyEventPostProcessor</code> can be
1804 * removed.
1805 * <p>
1806 * If a null post-processor is specified, if the specified post-processor
1807 * is not in the post-processor chain, or if this KeyboardFocusManager is
1808 * specified without having been explicitly added, no action is taken and
1809 * no exception is thrown.
1810 * <p>
1811 * In a multithreaded application, {@link KeyEventPostProcessor} behaves
1812 * the same as other AWT listeners. See
1813 * <a href="doc-files/AWTThreadIssues.html#ListenersThreads"
1814 * >AWT Threading Issues</a> for more details.
1815 *
1816 * @param processor the KeyEventPostProcessor to remove from the post-
1817 * processor chain
1818 * @see #addKeyEventPostProcessor
1819 */
1820 public void removeKeyEventPostProcessor(KeyEventPostProcessor processor) {
1821 if (processor != null) {
1822 synchronized (this) {
1823 if (keyEventPostProcessors != null) {
1824 keyEventPostProcessors.remove(processor);
1825 }
1826 }
1827 }
1828 }
1829
1830
1831 /**
1832 * Returns this KeyboardFocusManager's KeyEventPostProcessor chain as a
1833 * List. The List will not include this KeyboardFocusManager unless it was
1834 * explicitly added via a call to <code>addKeyEventPostProcessor</code>. If
1835 * no KeyEventPostProcessors are registered, implementations are free to
1836 * return null or a List of length 0. Client code should not assume one
1837 * behavior over another, nor should it assume that the behavior, once
1838 * established, will not change.
1839 *
1840 * @return a possibly null or empty List of KeyEventPostProcessors
1841 * @see #addKeyEventPostProcessor
1842 * @see #removeKeyEventPostProcessor
1843 */
1844 protected java.util.List<KeyEventPostProcessor>
1845 getKeyEventPostProcessors()
1846 {
1847 return (keyEventPostProcessors != null)
1848 ? (java.util.List)keyEventPostProcessors.clone()
1849 : null;
1850 }
1851
1852
1853
1854 static void setMostRecentFocusOwner(Component component) {
1855 Component window = component;
1856 while (window != null && !(window instanceof Window)) {
1857 window = window.parent;
1858 }
1859 if (window != null) {
1860 setMostRecentFocusOwner((Window)window, component);
1861 }
1862 }
1863 static synchronized void setMostRecentFocusOwner(Window window,
1864 Component component) {
1865 // ATTN: component has a strong reference to window via chain
1866 // of Component.parent fields. Since WeakHasMap refers to its
1867 // values strongly, we need to break the strong link from the
1868 // value (component) back to its key (window).
1869 WeakReference<Component> weakValue = null;
1870 if (component != null) {
1871 weakValue = new WeakReference<>(component);
1872 }
1873 mostRecentFocusOwners.put(window, weakValue);
1874 }
1875 static void clearMostRecentFocusOwner(Component comp) {
1876 Container window;
1877
1878 if (comp == null) {
1879 return;
1880 }
1881
1882 synchronized (comp.getTreeLock()) {
1883 window = comp.getParent();
1884 while (window != null && !(window instanceof Window)) {
1885 window = window.getParent();
1886 }
1887 }
1888
1889 synchronized (KeyboardFocusManager.class) {
1890 if ((window != null)
1891 && (getMostRecentFocusOwner((Window)window) == comp))
1892 {
1893 setMostRecentFocusOwner((Window)window, null);
1894 }
1895 // Also clear temporary lost component stored in Window
1896 if (window != null) {
1897 Window realWindow = (Window)window;
1898 if (realWindow.getTemporaryLostComponent() == comp) {
1899 realWindow.setTemporaryLostComponent(null);
1900 }
1901 }
1902 }
1903 }
1904
1905 /*
1906 * Please be careful changing this method! It is called from
1907 * javax.swing.JComponent.runInputVerifier() using reflection.
1908 */
1909 static synchronized Component getMostRecentFocusOwner(Window window) {
1910 WeakReference<Component> weakValue =
1911 (WeakReference)mostRecentFocusOwners.get(window);
1912 return weakValue == null ? null : (Component)weakValue.get();
1913 }
1914
1915 /**
1916 * This method is called by the AWT event dispatcher requesting that the
1917 * current KeyboardFocusManager dispatch the specified event on its behalf.
1918 * It is expected that all KeyboardFocusManagers will dispatch all
1919 * FocusEvents, all WindowEvents related to focus, and all KeyEvents.
1920 * These events should be dispatched based on the KeyboardFocusManager's
1921 * notion of the focus owner and the focused and active Windows, sometimes
1922 * overriding the source of the specified AWTEvent. Dispatching must be
1923 * done using <code>redispatchEvent</code> to prevent the AWT event
1924 * dispatcher from recursively requesting that the KeyboardFocusManager
1925 * dispatch the event again. If this method returns <code>false</code>,
1926 * then the AWT event dispatcher will attempt to dispatch the event itself.
1927 *
1928 * @param e the AWTEvent to be dispatched
1929 * @return <code>true</code> if this method dispatched the event;
1930 * <code>false</code> otherwise
1931 * @see #redispatchEvent
1932 * @see #dispatchKeyEvent
1933 */
1934 public abstract boolean dispatchEvent(AWTEvent e);
1935
1936 /**
1937 * Redispatches an AWTEvent in such a way that the AWT event dispatcher
1938 * will not recursively request that the KeyboardFocusManager, or any
1939 * installed KeyEventDispatchers, dispatch the event again. Client
1940 * implementations of <code>dispatchEvent</code> and client-defined
1941 * KeyEventDispatchers must call <code>redispatchEvent(target, e)</code>
1942 * instead of <code>target.dispatchEvent(e)</code> to dispatch an event.
1943 * <p>
1944 * This method is intended to be used only by KeyboardFocusManagers and
1945 * KeyEventDispatchers. It is not for general client use.
1946 *
1947 * @param target the Component to which the event should be dispatched
1948 * @param e the event to dispatch
1949 * @see #dispatchEvent
1950 * @see KeyEventDispatcher
1951 */
1952 public final void redispatchEvent(Component target, AWTEvent e) {
1953 e.focusManagerIsDispatching = true;
1954 target.dispatchEvent(e);
1955 e.focusManagerIsDispatching = false;
1956 }
1957
1958 /**
1959 * Typically this method will be called by <code>dispatchEvent</code> if no
1960 * other KeyEventDispatcher in the dispatcher chain dispatched the
1961 * KeyEvent, or if no other KeyEventDispatchers are registered. If an
1962 * implementation of this method returns <code>false</code>,
1963 * <code>dispatchEvent</code> may try to dispatch the KeyEvent itself, or
1964 * may simply return <code>false</code>. If <code>true</code> is returned,
1965 * <code>dispatchEvent</code> should return <code>true</code> as well.
1966 *
1967 * @param e the KeyEvent which the current KeyboardFocusManager has
1968 * requested that this KeyEventDispatcher dispatch
1969 * @return <code>true</code> if the KeyEvent was dispatched;
1970 * <code>false</code> otherwise
1971 * @see #dispatchEvent
1972 */
1973 public abstract boolean dispatchKeyEvent(KeyEvent e);
1974
1975 /**
1976 * This method will be called by <code>dispatchKeyEvent</code>.
1977 * By default, this method will handle any unconsumed KeyEvents that
1978 * map to an AWT <code>MenuShortcut</code> by consuming the event
1979 * and activating the shortcut.
1980 *
1981 * @param e the KeyEvent to post-process
1982 * @return <code>true</code> to indicate that no other
1983 * KeyEventPostProcessor will be notified of the KeyEvent.
1984 * @see #dispatchKeyEvent
1985 * @see MenuShortcut
1986 */
1987 public abstract boolean postProcessKeyEvent(KeyEvent e);
1988
1989 /**
1990 * This method initiates a focus traversal operation if and only if the
1991 * KeyEvent represents a focus traversal key for the specified
1992 * focusedComponent. It is expected that focusedComponent is the current
1993 * focus owner, although this need not be the case. If it is not,
1994 * focus traversal will nevertheless proceed as if focusedComponent
1995 * were the current focus owner.
1996 *
1997 * @param focusedComponent the Component that will be the basis for a focus
1998 * traversal operation if the specified event represents a focus
1999 * traversal key for the Component
2000 * @param e the event that may represent a focus traversal key
2001 */
2002 public abstract void processKeyEvent(Component focusedComponent,
2003 KeyEvent e);
2004
2005 /**
2006 * Called by the AWT to notify the KeyboardFocusManager that it should
2007 * delay dispatching of KeyEvents until the specified Component becomes
2008 * the focus owner. If client code requests a focus change, and the AWT
2009 * determines that this request might be granted by the native windowing
2010 * system, then the AWT will call this method. It is the responsibility of
2011 * the KeyboardFocusManager to delay dispatching of KeyEvents with
2012 * timestamps later than the specified time stamp until the specified
2013 * Component receives a FOCUS_GAINED event, or the AWT cancels the delay
2014 * request by invoking <code>dequeueKeyEvents</code> or
2015 * <code>discardKeyEvents</code>.
2016 *
2017 * @param after timestamp of current event, or the current, system time if
2018 * the current event has no timestamp, or the AWT cannot determine
2019 * which event is currently being handled
2020 * @param untilFocused Component which should receive a FOCUS_GAINED event
2021 * before any pending KeyEvents
2022 * @see #dequeueKeyEvents
2023 * @see #discardKeyEvents
2024 */
2025 protected abstract void enqueueKeyEvents(long after,
2026 Component untilFocused);
2027
2028 /**
2029 * Called by the AWT to notify the KeyboardFocusManager that it should
2030 * cancel delayed dispatching of KeyEvents. All KeyEvents which were
2031 * enqueued because of a call to <code>enqueueKeyEvents</code> with the
2032 * same timestamp and Component should be released for normal dispatching
2033 * to the current focus owner. If the given timestamp is less than zero,
2034 * the outstanding enqueue request for the given Component with the <b>
2035 * oldest</b> timestamp (if any) should be cancelled.
2036 *
2037 * @param after the timestamp specified in the call to
2038 * <code>enqueueKeyEvents</code>, or any value < 0
2039 * @param untilFocused the Component specified in the call to
2040 * <code>enqueueKeyEvents</code>
2041 * @see #enqueueKeyEvents
2042 * @see #discardKeyEvents
2043 */
2044 protected abstract void dequeueKeyEvents(long after,
2045 Component untilFocused);
2046
2047 /**
2048 * Called by the AWT to notify the KeyboardFocusManager that it should
2049 * cancel delayed dispatching of KeyEvents. All KeyEvents which were
2050 * enqueued because of one or more calls to <code>enqueueKeyEvents</code>
2051 * with the same Component should be discarded.
2052 *
2053 * @param comp the Component specified in one or more calls to
2054 * <code>enqueueKeyEvents</code>
2055 * @see #enqueueKeyEvents
2056 * @see #dequeueKeyEvents
2057 */
2058 protected abstract void discardKeyEvents(Component comp);
2059
2060 /**
2061 * Focuses the Component after aComponent, typically based on a
2062 * FocusTraversalPolicy.
2063 *
2064 * @param aComponent the Component that is the basis for the focus
2065 * traversal operation
2066 * @see FocusTraversalPolicy
2067 */
2068 public abstract void focusNextComponent(Component aComponent);
2069
2070 /**
2071 * Focuses the Component before aComponent, typically based on a
2072 * FocusTraversalPolicy.
2073 *
2074 * @param aComponent the Component that is the basis for the focus
2075 * traversal operation
2076 * @see FocusTraversalPolicy
2077 */
2078 public abstract void focusPreviousComponent(Component aComponent);
2079
2080 /**
2081 * Moves the focus up one focus traversal cycle. Typically, the focus owner
2082 * is set to aComponent's focus cycle root, and the current focus cycle
2083 * root is set to the new focus owner's focus cycle root. If, however,
2084 * aComponent's focus cycle root is a Window, then typically the focus
2085 * owner is set to the Window's default Component to focus, and the current
2086 * focus cycle root is unchanged.
2087 *
2088 * @param aComponent the Component that is the basis for the focus
2089 * traversal operation
2090 */
2091 public abstract void upFocusCycle(Component aComponent);
2092
2093 /**
2094 * Moves the focus down one focus traversal cycle. Typically, if
2095 * aContainer is a focus cycle root, then the focus owner is set to
2096 * aContainer's default Component to focus, and the current focus cycle
2097 * root is set to aContainer. If aContainer is not a focus cycle root, then
2098 * no focus traversal operation occurs.
2099 *
2100 * @param aContainer the Container that is the basis for the focus
2101 * traversal operation
2102 */
2103 public abstract void downFocusCycle(Container aContainer);
2104
2105 /**
2106 * Focuses the Component after the current focus owner.
2107 */
2108 public final void focusNextComponent() {
2109 Component focusOwner = getFocusOwner();
2110 if (focusOwner != null) {
2111 focusNextComponent(focusOwner);
2112 }
2113 }
2114
2115 /**
2116 * Focuses the Component before the current focus owner.
2117 */
2118 public final void focusPreviousComponent() {
2119 Component focusOwner = getFocusOwner();
2120 if (focusOwner != null) {
2121 focusPreviousComponent(focusOwner);
2122 }
2123 }
2124
2125 /**
2126 * Moves the focus up one focus traversal cycle from the current focus
2127 * owner. Typically, the new focus owner is set to the current focus
2128 * owner's focus cycle root, and the current focus cycle root is set to the
2129 * new focus owner's focus cycle root. If, however, the current focus
2130 * owner's focus cycle root is a Window, then typically the focus owner is
2131 * set to the focus cycle root's default Component to focus, and the
2132 * current focus cycle root is unchanged.
2133 */
2134 public final void upFocusCycle() {
2135 Component focusOwner = getFocusOwner();
2136 if (focusOwner != null) {
2137 upFocusCycle(focusOwner);
2138 }
2139 }
2140
2141 /**
2142 * Moves the focus down one focus traversal cycle from the current focus
2143 * owner, if and only if the current focus owner is a Container that is a
2144 * focus cycle root. Typically, the focus owner is set to the current focus
2145 * owner's default Component to focus, and the current focus cycle root is
2146 * set to the current focus owner. If the current focus owner is not a
2147 * Container that is a focus cycle root, then no focus traversal operation
2148 * occurs.
2149 */
2150 public final void downFocusCycle() {
2151 Component focusOwner = getFocusOwner();
2152 if (focusOwner instanceof Container) {
2153 downFocusCycle((Container)focusOwner);
2154 }
2155 }
2156
2157 /**
2158 * Dumps the list of focus requests to stderr
2159 */
2160 void dumpRequests() {
2161 System.err.println(">>> Requests dump, time: " + System.currentTimeMillis());
2162 synchronized (heavyweightRequests) {
2163 for (HeavyweightFocusRequest req : heavyweightRequests) {
2164 System.err.println(">>> Req: " + req);
2165 }
2166 }
2167 System.err.println("");
2168 }
2169
2170 private static final class LightweightFocusRequest {
2171 final Component component;
2172 final boolean temporary;
2173 final CausedFocusEvent.Cause cause;
2174
2175 LightweightFocusRequest(Component component, boolean temporary, CausedFocusEvent.Cause cause) {
2176 this.component = component;
2177 this.temporary = temporary;
2178 this.cause = cause;
2179 }
2180 public String toString() {
2181 return "LightweightFocusRequest[component=" + component +
2182 ",temporary=" + temporary + ", cause=" + cause + "]";
2183 }
2184 }
2185
2186 private static final class HeavyweightFocusRequest {
2187 final Component heavyweight;
2188 final LinkedList<LightweightFocusRequest> lightweightRequests;
2189
2190 static final HeavyweightFocusRequest CLEAR_GLOBAL_FOCUS_OWNER =
2191 new HeavyweightFocusRequest();
2192
2193 private HeavyweightFocusRequest() {
2194 heavyweight = null;
2195 lightweightRequests = null;
2196 }
2197
2198 HeavyweightFocusRequest(Component heavyweight, Component descendant,
2199 boolean temporary, CausedFocusEvent.Cause cause) {
2200 if (log.isLoggable(PlatformLogger.Level.FINE)) {
2201 if (heavyweight == null) {
2202 log.fine("Assertion (heavyweight != null) failed");
2203 }
2204 }
2205
2206 this.heavyweight = heavyweight;
2207 this.lightweightRequests = new LinkedList<LightweightFocusRequest>();
2208 addLightweightRequest(descendant, temporary, cause);
2209 }
2210 boolean addLightweightRequest(Component descendant,
2211 boolean temporary, CausedFocusEvent.Cause cause) {
2212 if (log.isLoggable(PlatformLogger.Level.FINE)) {
2213 if (this == HeavyweightFocusRequest.CLEAR_GLOBAL_FOCUS_OWNER) {
2214 log.fine("Assertion (this != HeavyweightFocusRequest.CLEAR_GLOBAL_FOCUS_OWNER) failed");
2215 }
2216 if (descendant == null) {
2217 log.fine("Assertion (descendant != null) failed");
2218 }
2219 }
2220
2221 Component lastDescendant = ((lightweightRequests.size() > 0)
2222 ? lightweightRequests.getLast().component
2223 : null);
2224
2225 if (descendant != lastDescendant) {
2226 // Not a duplicate request
2227 lightweightRequests.add
2228 (new LightweightFocusRequest(descendant, temporary, cause));
2229 return true;
2230 } else {
2231 return false;
2232 }
2233 }
2234
2235 LightweightFocusRequest getFirstLightweightRequest() {
2236 if (this == CLEAR_GLOBAL_FOCUS_OWNER) {
2237 return null;
2238 }
2239 return lightweightRequests.getFirst();
2240 }
2241 public String toString() {
2242 boolean first = true;
2243 String str = "HeavyweightFocusRequest[heavweight=" + heavyweight +
2244 ",lightweightRequests=";
2245 if (lightweightRequests == null) {
2246 str += null;
2247 } else {
2248 str += "[";
2249
2250 for (LightweightFocusRequest lwRequest : lightweightRequests) {
2251 if (first) {
2252 first = false;
2253 } else {
2254 str += ",";
2255 }
2256 str += lwRequest;
2257 }
2258 str += "]";
2259 }
2260 str += "]";
2261 return str;
2262 }
2263 }
2264
2265 /*
2266 * heavyweightRequests is used as a monitor for synchronized changes of
2267 * currentLightweightRequests, clearingCurrentLightweightRequests and
2268 * newFocusOwner.
2269 */
2270 private static LinkedList<HeavyweightFocusRequest> heavyweightRequests =
2271 new LinkedList<HeavyweightFocusRequest>();
2272 private static LinkedList<LightweightFocusRequest> currentLightweightRequests;
2273 private static boolean clearingCurrentLightweightRequests;
2274 private static boolean allowSyncFocusRequests = true;
2275 private static Component newFocusOwner = null;
2276 private static volatile boolean disableRestoreFocus;
2277
2278 static final int SNFH_FAILURE = 0;
2279 static final int SNFH_SUCCESS_HANDLED = 1;
2280 static final int SNFH_SUCCESS_PROCEED = 2;
2281
2282 static boolean processSynchronousLightweightTransfer(Component heavyweight, Component descendant,
2283 boolean temporary, boolean focusedWindowChangeAllowed,
2284 long time)
2285 {
2286 Window parentWindow = SunToolkit.getContainingWindow(heavyweight);
2287 if (parentWindow == null || !parentWindow.syncLWRequests) {
2288 return false;
2289 }
2290 if (descendant == null) {
2291 // Focus transfers from a lightweight child back to the
2292 // heavyweight Container should be treated like lightweight
2293 // focus transfers.
2294 descendant = heavyweight;
2295 }
2296
2297 KeyboardFocusManager manager = getCurrentKeyboardFocusManager(SunToolkit.targetToAppContext(descendant));
2298
2299 FocusEvent currentFocusOwnerEvent = null;
2300 FocusEvent newFocusOwnerEvent = null;
2301 Component currentFocusOwner = manager.getGlobalFocusOwner();
2302
2303 synchronized (heavyweightRequests) {
2304 HeavyweightFocusRequest hwFocusRequest = getLastHWRequest();
2305 if (hwFocusRequest == null &&
2306 heavyweight == manager.getNativeFocusOwner() &&
2307 allowSyncFocusRequests)
2308 {
2309
2310 if (descendant == currentFocusOwner) {
2311 // Redundant request.
2312 return true;
2313 }
2314
2315 // 'heavyweight' owns the native focus and there are no pending
2316 // requests. 'heavyweight' must be a Container and
2317 // 'descendant' must not be the focus owner. Otherwise,
2318 // we would never have gotten this far.
2319 manager.enqueueKeyEvents(time, descendant);
2320
2321 hwFocusRequest =
2322 new HeavyweightFocusRequest(heavyweight, descendant,
2323 temporary, CausedFocusEvent.Cause.UNKNOWN);
2324 heavyweightRequests.add(hwFocusRequest);
2325
2326 if (currentFocusOwner != null) {
2327 currentFocusOwnerEvent =
2328 new FocusEvent(currentFocusOwner,
2329 FocusEvent.FOCUS_LOST,
2330 temporary, descendant);
2331 }
2332 newFocusOwnerEvent =
2333 new FocusEvent(descendant, FocusEvent.FOCUS_GAINED,
2334 temporary, currentFocusOwner);
2335 }
2336 }
2337 boolean result = false;
2338 final boolean clearing = clearingCurrentLightweightRequests;
2339
2340 Throwable caughtEx = null;
2341 try {
2342 clearingCurrentLightweightRequests = false;
2343 synchronized(Component.LOCK) {
2344
2345 if (currentFocusOwnerEvent != null && currentFocusOwner != null) {
2346 ((AWTEvent) currentFocusOwnerEvent).isPosted = true;
2347 caughtEx = dispatchAndCatchException(caughtEx, currentFocusOwner, currentFocusOwnerEvent);
2348 result = true;
2349 }
2350
2351 if (newFocusOwnerEvent != null && descendant != null) {
2352 ((AWTEvent) newFocusOwnerEvent).isPosted = true;
2353 caughtEx = dispatchAndCatchException(caughtEx, descendant, newFocusOwnerEvent);
2354 result = true;
2355 }
2356 }
2357 } finally {
2358 clearingCurrentLightweightRequests = clearing;
2359 }
2360 if (caughtEx instanceof RuntimeException) {
2361 throw (RuntimeException)caughtEx;
2362 } else if (caughtEx instanceof Error) {
2363 throw (Error)caughtEx;
2364 }
2365 return result;
2366 }
2367
2368 /**
2369 * Indicates whether the native implementation should proceed with a
2370 * pending, native focus request. Before changing the focus at the native
2371 * level, the AWT implementation should always call this function for
2372 * permission. This function will reject the request if a duplicate request
2373 * preceded it, or if the specified heavyweight Component already owns the
2374 * focus and no native focus changes are pending. Otherwise, the request
2375 * will be approved and the focus request list will be updated so that,
2376 * if necessary, the proper descendant will be focused when the
2377 * corresponding FOCUS_GAINED event on the heavyweight is received.
2378 *
2379 * An implementation must ensure that calls to this method and native
2380 * focus changes are atomic. If this is not guaranteed, then the ordering
2381 * of the focus request list may be incorrect, leading to errors in the
2382 * type-ahead mechanism. Typically this is accomplished by only calling
2383 * this function from the native event pumping thread, or by holding a
2384 * global, native lock during invocation.
2385 */
2386 static int shouldNativelyFocusHeavyweight
2387 (Component heavyweight, Component descendant, boolean temporary,
2388 boolean focusedWindowChangeAllowed, long time, CausedFocusEvent.Cause cause)
2389 {
2390 if (log.isLoggable(PlatformLogger.Level.FINE)) {
2391 if (heavyweight == null) {
2392 log.fine("Assertion (heavyweight != null) failed");
2393 }
2394 if (time == 0) {
2395 log.fine("Assertion (time != 0) failed");
2396 }
2397 }
2398
2399 if (descendant == null) {
2400 // Focus transfers from a lightweight child back to the
2401 // heavyweight Container should be treated like lightweight
2402 // focus transfers.
2403 descendant = heavyweight;
2404 }
2405
2406 KeyboardFocusManager manager =
2407 getCurrentKeyboardFocusManager(SunToolkit.targetToAppContext(descendant));
2408 KeyboardFocusManager thisManager = getCurrentKeyboardFocusManager();
2409 Component currentFocusOwner = thisManager.getGlobalFocusOwner();
2410 Component nativeFocusOwner = thisManager.getNativeFocusOwner();
2411 Window nativeFocusedWindow = thisManager.getNativeFocusedWindow();
2412 if (focusLog.isLoggable(PlatformLogger.Level.FINER)) {
2413 focusLog.finer("SNFH for {0} in {1}",
2414 String.valueOf(descendant), String.valueOf(heavyweight));
2415 }
2416 if (focusLog.isLoggable(PlatformLogger.Level.FINEST)) {
2417 focusLog.finest("0. Current focus owner {0}",
2418 String.valueOf(currentFocusOwner));
2419 focusLog.finest("0. Native focus owner {0}",
2420 String.valueOf(nativeFocusOwner));
2421 focusLog.finest("0. Native focused window {0}",
2422 String.valueOf(nativeFocusedWindow));
2423 }
2424 synchronized (heavyweightRequests) {
2425 HeavyweightFocusRequest hwFocusRequest = getLastHWRequest();
2426 if (focusLog.isLoggable(PlatformLogger.Level.FINEST)) {
2427 focusLog.finest("Request {0}", String.valueOf(hwFocusRequest));
2428 }
2429 if (hwFocusRequest == null &&
2430 heavyweight == nativeFocusOwner &&
2431 heavyweight.getContainingWindow() == nativeFocusedWindow)
2432 {
2433 if (descendant == currentFocusOwner) {
2434 // Redundant request.
2435 if (focusLog.isLoggable(PlatformLogger.Level.FINEST))
2436 focusLog.finest("1. SNFH_FAILURE for {0}",
2437 String.valueOf(descendant));
2438 return SNFH_FAILURE;
2439 }
2440
2441 // 'heavyweight' owns the native focus and there are no pending
2442 // requests. 'heavyweight' must be a Container and
2443 // 'descendant' must not be the focus owner. Otherwise,
2444 // we would never have gotten this far.
2445 manager.enqueueKeyEvents(time, descendant);
2446
2447 hwFocusRequest =
2448 new HeavyweightFocusRequest(heavyweight, descendant,
2449 temporary, cause);
2450 heavyweightRequests.add(hwFocusRequest);
2451
2452 if (currentFocusOwner != null) {
2453 FocusEvent currentFocusOwnerEvent =
2454 new CausedFocusEvent(currentFocusOwner,
2455 FocusEvent.FOCUS_LOST,
2456 temporary, descendant, cause);
2457 // Fix 5028014. Rolled out.
2458 // SunToolkit.postPriorityEvent(currentFocusOwnerEvent);
2459 SunToolkit.postEvent(currentFocusOwner.appContext,
2460 currentFocusOwnerEvent);
2461 }
2462 FocusEvent newFocusOwnerEvent =
2463 new CausedFocusEvent(descendant, FocusEvent.FOCUS_GAINED,
2464 temporary, currentFocusOwner, cause);
2465 // Fix 5028014. Rolled out.
2466 // SunToolkit.postPriorityEvent(newFocusOwnerEvent);
2467 SunToolkit.postEvent(descendant.appContext, newFocusOwnerEvent);
2468
2469 if (focusLog.isLoggable(PlatformLogger.Level.FINEST))
2470 focusLog.finest("2. SNFH_HANDLED for {0}", String.valueOf(descendant));
2471 return SNFH_SUCCESS_HANDLED;
2472 } else if (hwFocusRequest != null &&
2473 hwFocusRequest.heavyweight == heavyweight) {
2474 // 'heavyweight' doesn't have the native focus right now, but
2475 // if all pending requests were completed, it would. Add
2476 // descendant to the heavyweight's list of pending
2477 // lightweight focus transfers.
2478 if (hwFocusRequest.addLightweightRequest(descendant,
2479 temporary, cause)) {
2480 manager.enqueueKeyEvents(time, descendant);
2481 }
2482
2483 if (focusLog.isLoggable(PlatformLogger.Level.FINEST)) {
2484 focusLog.finest("3. SNFH_HANDLED for lightweight" +
2485 descendant + " in " + heavyweight);
2486 }
2487 return SNFH_SUCCESS_HANDLED;
2488 } else {
2489 if (!focusedWindowChangeAllowed) {
2490 // For purposes of computing oldFocusedWindow, we should look at
2491 // the second to last HeavyweightFocusRequest on the queue iff the
2492 // last HeavyweightFocusRequest is CLEAR_GLOBAL_FOCUS_OWNER. If
2493 // there is no second to last HeavyweightFocusRequest, null is an
2494 // acceptable value.
2495 if (hwFocusRequest ==
2496 HeavyweightFocusRequest.CLEAR_GLOBAL_FOCUS_OWNER)
2497 {
2498 int size = heavyweightRequests.size();
2499 hwFocusRequest = (HeavyweightFocusRequest)((size >= 2)
2500 ? heavyweightRequests.get(size - 2)
2501 : null);
2502 }
2503 if (focusedWindowChanged(heavyweight,
2504 (hwFocusRequest != null)
2505 ? hwFocusRequest.heavyweight
2506 : nativeFocusedWindow)) {
2507 if (focusLog.isLoggable(PlatformLogger.Level.FINEST)) {
2508 focusLog.finest("4. SNFH_FAILURE for " + descendant);
2509 }
2510 return SNFH_FAILURE;
2511 }
2512 }
2513
2514 manager.enqueueKeyEvents(time, descendant);
2515 heavyweightRequests.add
2516 (new HeavyweightFocusRequest(heavyweight, descendant,
2517 temporary, cause));
2518 if (focusLog.isLoggable(PlatformLogger.Level.FINEST)) {
2519 focusLog.finest("5. SNFH_PROCEED for " + descendant);
2520 }
2521 return SNFH_SUCCESS_PROCEED;
2522 }
2523 }
2524 }
2525
2526 /**
2527 * Returns the Window which will be active after processing this request,
2528 * or null if this is a duplicate request. The active Window is useful
2529 * because some native platforms do not support setting the native focus
2530 * owner to null. On these platforms, the obvious choice is to set the
2531 * focus owner to the focus proxy of the active Window.
2532 */
2533 static Window markClearGlobalFocusOwner() {
2534 // need to call this out of synchronized block to avoid possible deadlock
2535 // see 6454631.
2536 final Component nativeFocusedWindow =
2537 getCurrentKeyboardFocusManager().getNativeFocusedWindow();
2538
2539 synchronized (heavyweightRequests) {
2540 HeavyweightFocusRequest hwFocusRequest = getLastHWRequest();
2541 if (hwFocusRequest ==
2542 HeavyweightFocusRequest.CLEAR_GLOBAL_FOCUS_OWNER)
2543 {
2544 // duplicate request
2545 return null;
2546 }
2547
2548 heavyweightRequests.add
2549 (HeavyweightFocusRequest.CLEAR_GLOBAL_FOCUS_OWNER);
2550
2551 Component activeWindow = ((hwFocusRequest != null)
2552 ? SunToolkit.getContainingWindow(hwFocusRequest.heavyweight)
2553 : nativeFocusedWindow);
2554 while (activeWindow != null &&
2555 !((activeWindow instanceof Frame) ||
2556 (activeWindow instanceof Dialog)))
2557 {
2558 activeWindow = activeWindow.getParent_NoClientCode();
2559 }
2560
2561 return (Window) activeWindow;
2562 }
2563 }
2564 Component getCurrentWaitingRequest(Component parent) {
2565 synchronized (heavyweightRequests) {
2566 HeavyweightFocusRequest hwFocusRequest = getFirstHWRequest();
2567 if (hwFocusRequest != null) {
2568 if (hwFocusRequest.heavyweight == parent) {
2569 LightweightFocusRequest lwFocusRequest =
2570 hwFocusRequest.lightweightRequests.getFirst();
2571 if (lwFocusRequest != null) {
2572 return lwFocusRequest.component;
2573 }
2574 }
2575 }
2576 }
2577 return null;
2578 }
2579
2580 static boolean isAutoFocusTransferEnabled() {
2581 synchronized (heavyweightRequests) {
2582 return (heavyweightRequests.size() == 0)
2583 && !disableRestoreFocus
2584 && (null == currentLightweightRequests);
2585 }
2586 }
2587
2588 static boolean isAutoFocusTransferEnabledFor(Component comp) {
2589 return isAutoFocusTransferEnabled() && comp.isAutoFocusTransferOnDisposal();
2590 }
2591
2592 /*
2593 * Used to process exceptions in dispatching focus event (in focusLost/focusGained callbacks).
2594 * @param ex previously caught exception that may be processed right here, or null
2595 * @param comp the component to dispatch the event to
2596 * @param event the event to dispatch to the component
2597 */
2598 static private Throwable dispatchAndCatchException(Throwable ex, Component comp, FocusEvent event) {
2599 Throwable retEx = null;
2600 try {
2601 comp.dispatchEvent(event);
2602 } catch (RuntimeException re) {
2603 retEx = re;
2604 } catch (Error er) {
2605 retEx = er;
2606 }
2607 if (retEx != null) {
2608 if (ex != null) {
2609 handleException(ex);
2610 }
2611 return retEx;
2612 }
2613 return ex;
2614 }
2615
2616 static private void handleException(Throwable ex) {
2617 ex.printStackTrace();
2618 }
2619
2620 static void processCurrentLightweightRequests() {
2621 KeyboardFocusManager manager = getCurrentKeyboardFocusManager();
2622 LinkedList<LightweightFocusRequest> localLightweightRequests = null;
2623
2624 Component globalFocusOwner = manager.getGlobalFocusOwner();
2625 if ((globalFocusOwner != null) &&
2626 (globalFocusOwner.appContext != AppContext.getAppContext()))
2627 {
2628 // The current app context differs from the app context of a focus
2629 // owner (and all pending lightweight requests), so we do nothing
2630 // now and wait for a next event.
2631 return;
2632 }
2633
2634 synchronized(heavyweightRequests) {
2635 if (currentLightweightRequests != null) {
2636 clearingCurrentLightweightRequests = true;
2637 disableRestoreFocus = true;
2638 localLightweightRequests = currentLightweightRequests;
2639 allowSyncFocusRequests = (localLightweightRequests.size() < 2);
2640 currentLightweightRequests = null;
2641 } else {
2642 // do nothing
2643 return;
2644 }
2645 }
2646
2647 Throwable caughtEx = null;
2648 try {
2649 if (localLightweightRequests != null) {
2650 Component lastFocusOwner = null;
2651 Component currentFocusOwner = null;
2652
2653 for (Iterator<KeyboardFocusManager.LightweightFocusRequest> iter = localLightweightRequests.iterator(); iter.hasNext(); ) {
2654
2655 currentFocusOwner = manager.getGlobalFocusOwner();
2656 LightweightFocusRequest lwFocusRequest =
2657 iter.next();
2658
2659 /*
2660 * WARNING: This is based on DKFM's logic solely!
2661 *
2662 * We allow to trigger restoreFocus() in the dispatching process
2663 * only if we have the last request to dispatch. If the last request
2664 * fails, focus will be restored to either the component of the last
2665 * previously succedded request, or to to the focus owner that was
2666 * before this clearing process.
2667 */
2668 if (!iter.hasNext()) {
2669 disableRestoreFocus = false;
2670 }
2671
2672 FocusEvent currentFocusOwnerEvent = null;
2673 /*
2674 * We're not dispatching FOCUS_LOST while the current focus owner is null.
2675 * But regardless of whether it's null or not, we're clearing ALL the local
2676 * lw requests.
2677 */
2678 if (currentFocusOwner != null) {
2679 currentFocusOwnerEvent = new CausedFocusEvent(currentFocusOwner,
2680 FocusEvent.FOCUS_LOST,
2681 lwFocusRequest.temporary,
2682 lwFocusRequest.component, lwFocusRequest.cause);
2683 }
2684 FocusEvent newFocusOwnerEvent =
2685 new CausedFocusEvent(lwFocusRequest.component,
2686 FocusEvent.FOCUS_GAINED,
2687 lwFocusRequest.temporary,
2688 currentFocusOwner == null ? lastFocusOwner : currentFocusOwner,
2689 lwFocusRequest.cause);
2690
2691 if (currentFocusOwner != null) {
2692 ((AWTEvent) currentFocusOwnerEvent).isPosted = true;
2693 caughtEx = dispatchAndCatchException(caughtEx, currentFocusOwner, currentFocusOwnerEvent);
2694 }
2695
2696 ((AWTEvent) newFocusOwnerEvent).isPosted = true;
2697 caughtEx = dispatchAndCatchException(caughtEx, lwFocusRequest.component, newFocusOwnerEvent);
2698
2699 if (manager.getGlobalFocusOwner() == lwFocusRequest.component) {
2700 lastFocusOwner = lwFocusRequest.component;
2701 }
2702 }
2703 }
2704 } finally {
2705 clearingCurrentLightweightRequests = false;
2706 disableRestoreFocus = false;
2707 localLightweightRequests = null;
2708 allowSyncFocusRequests = true;
2709 }
2710 if (caughtEx instanceof RuntimeException) {
2711 throw (RuntimeException)caughtEx;
2712 } else if (caughtEx instanceof Error) {
2713 throw (Error)caughtEx;
2714 }
2715 }
2716
2717 static FocusEvent retargetUnexpectedFocusEvent(FocusEvent fe) {
2718 synchronized (heavyweightRequests) {
2719 // Any other case represents a failure condition which we did
2720 // not expect. We need to clearFocusRequestList() and patch up
2721 // the event as best as possible.
2722
2723 if (removeFirstRequest()) {
2724 return (FocusEvent)retargetFocusEvent(fe);
2725 }
2726
2727 Component source = fe.getComponent();
2728 Component opposite = fe.getOppositeComponent();
2729 boolean temporary = false;
2730 if (fe.getID() == FocusEvent.FOCUS_LOST &&
2731 (opposite == null || isTemporary(opposite, source)))
2732 {
2733 temporary = true;
2734 }
2735 return new CausedFocusEvent(source, fe.getID(), temporary, opposite,
2736 CausedFocusEvent.Cause.NATIVE_SYSTEM);
2737 }
2738 }
2739
2740 static FocusEvent retargetFocusGained(FocusEvent fe) {
2741 assert (fe.getID() == FocusEvent.FOCUS_GAINED);
2742
2743 Component currentFocusOwner = getCurrentKeyboardFocusManager().
2744 getGlobalFocusOwner();
2745 Component source = fe.getComponent();
2746 Component opposite = fe.getOppositeComponent();
2747 Component nativeSource = getHeavyweight(source);
2748
2749 synchronized (heavyweightRequests) {
2750 HeavyweightFocusRequest hwFocusRequest = getFirstHWRequest();
2751
2752 if (hwFocusRequest == HeavyweightFocusRequest.CLEAR_GLOBAL_FOCUS_OWNER)
2753 {
2754 return retargetUnexpectedFocusEvent(fe);
2755 }
2756
2757 if (source != null && nativeSource == null && hwFocusRequest != null) {
2758 // if source w/o peer and
2759 // if source is equal to first lightweight
2760 // then we should correct source and nativeSource
2761 if (source == hwFocusRequest.getFirstLightweightRequest().component)
2762 {
2763 source = hwFocusRequest.heavyweight;
2764 nativeSource = source; // source is heavuweight itself
2765 }
2766 }
2767 if (hwFocusRequest != null &&
2768 nativeSource == hwFocusRequest.heavyweight)
2769 {
2770 // Focus change as a result of a known call to requestFocus(),
2771 // or known click on a peer focusable heavyweight Component.
2772
2773 heavyweightRequests.removeFirst();
2774
2775 LightweightFocusRequest lwFocusRequest =
2776 hwFocusRequest.lightweightRequests.removeFirst();
2777
2778 Component newSource = lwFocusRequest.component;
2779 if (currentFocusOwner != null) {
2780 /*
2781 * Since we receive FOCUS_GAINED when current focus
2782 * owner is not null, correcponding FOCUS_LOST is supposed
2783 * to be lost. And so, we keep new focus owner
2784 * to determine synthetic FOCUS_LOST event which will be
2785 * generated by KeyboardFocusManager for this FOCUS_GAINED.
2786 *
2787 * This code based on knowledge of
2788 * DefaultKeyboardFocusManager's implementation and might
2789 * be not applicable for another KeyboardFocusManager.
2790 */
2791 newFocusOwner = newSource;
2792 }
2793
2794 boolean temporary = (opposite == null ||
2795 isTemporary(newSource, opposite))
2796 ? false
2797 : lwFocusRequest.temporary;
2798
2799 if (hwFocusRequest.lightweightRequests.size() > 0) {
2800 currentLightweightRequests =
2801 hwFocusRequest.lightweightRequests;
2802 EventQueue.invokeLater(new Runnable() {
2803 public void run() {
2804 processCurrentLightweightRequests();
2805 }
2806 });
2807 }
2808
2809 // 'opposite' will be fixed by
2810 // DefaultKeyboardFocusManager.realOppositeComponent
2811 return new CausedFocusEvent(newSource,
2812 FocusEvent.FOCUS_GAINED, temporary,
2813 opposite, lwFocusRequest.cause);
2814 }
2815
2816 if (currentFocusOwner != null
2817 && currentFocusOwner.getContainingWindow() == source
2818 && (hwFocusRequest == null || source != hwFocusRequest.heavyweight))
2819 {
2820 // Special case for FOCUS_GAINED in top-levels
2821 // If it arrives as the result of activation we should skip it
2822 // This event will not have appropriate request record and
2823 // on arrival there will be already some focus owner set.
2824 return new CausedFocusEvent(currentFocusOwner, FocusEvent.FOCUS_GAINED, false,
2825 null, CausedFocusEvent.Cause.ACTIVATION);
2826 }
2827
2828 return retargetUnexpectedFocusEvent(fe);
2829 } // end synchronized(heavyweightRequests)
2830 }
2831
2832 static FocusEvent retargetFocusLost(FocusEvent fe) {
2833 assert (fe.getID() == FocusEvent.FOCUS_LOST);
2834
2835 Component currentFocusOwner = getCurrentKeyboardFocusManager().
2836 getGlobalFocusOwner();
2837 Component opposite = fe.getOppositeComponent();
2838 Component nativeOpposite = getHeavyweight(opposite);
2839
2840 synchronized (heavyweightRequests) {
2841 HeavyweightFocusRequest hwFocusRequest = getFirstHWRequest();
2842
2843 if (hwFocusRequest == HeavyweightFocusRequest.CLEAR_GLOBAL_FOCUS_OWNER)
2844 {
2845 if (currentFocusOwner != null) {
2846 // Call to KeyboardFocusManager.clearGlobalFocusOwner()
2847 heavyweightRequests.removeFirst();
2848 return new CausedFocusEvent(currentFocusOwner,
2849 FocusEvent.FOCUS_LOST, false, null,
2850 CausedFocusEvent.Cause.CLEAR_GLOBAL_FOCUS_OWNER);
2851 }
2852
2853 // Otherwise, fall through to failure case below
2854
2855 } else if (opposite == null)
2856 {
2857 // Focus leaving application
2858 if (currentFocusOwner != null) {
2859 return new CausedFocusEvent(currentFocusOwner,
2860 FocusEvent.FOCUS_LOST,
2861 true, null, CausedFocusEvent.Cause.ACTIVATION);
2862 } else {
2863 return fe;
2864 }
2865 } else if (hwFocusRequest != null &&
2866 (nativeOpposite == hwFocusRequest.heavyweight ||
2867 nativeOpposite == null &&
2868 opposite == hwFocusRequest.getFirstLightweightRequest().component))
2869 {
2870 if (currentFocusOwner == null) {
2871 return fe;
2872 }
2873 // Focus change as a result of a known call to requestFocus(),
2874 // or click on a peer focusable heavyweight Component.
2875 // If a focus transfer is made across top-levels, then the
2876 // FOCUS_LOST event is always temporary, and the FOCUS_GAINED
2877 // event is always permanent. Otherwise, the stored temporary
2878 // value is honored.
2879
2880 LightweightFocusRequest lwFocusRequest =
2881 hwFocusRequest.lightweightRequests.getFirst();
2882
2883 boolean temporary = isTemporary(opposite, currentFocusOwner)
2884 ? true
2885 : lwFocusRequest.temporary;
2886
2887 return new CausedFocusEvent(currentFocusOwner, FocusEvent.FOCUS_LOST,
2888 temporary, lwFocusRequest.component, lwFocusRequest.cause);
2889 } else if (focusedWindowChanged(opposite, currentFocusOwner)) {
2890 // If top-level changed there might be no focus request in a list
2891 // But we know the opposite, we now it is temporary - dispatch the event.
2892 if (!fe.isTemporary() && currentFocusOwner != null) {
2893 // Create copy of the event with only difference in temporary parameter.
2894 fe = new CausedFocusEvent(currentFocusOwner, FocusEvent.FOCUS_LOST,
2895 true, opposite, CausedFocusEvent.Cause.ACTIVATION);
2896 }
2897 return fe;
2898 }
2899
2900 return retargetUnexpectedFocusEvent(fe);
2901 } // end synchronized(heavyweightRequests)
2902 }
2903
2904 static AWTEvent retargetFocusEvent(AWTEvent event) {
2905 if (clearingCurrentLightweightRequests) {
2906 return event;
2907 }
2908
2909 KeyboardFocusManager manager = getCurrentKeyboardFocusManager();
2910 if (focusLog.isLoggable(PlatformLogger.Level.FINER)) {
2911 if (event instanceof FocusEvent || event instanceof WindowEvent) {
2912 focusLog.finer(">>> {0}", String.valueOf(event));
2913 }
2914 if (focusLog.isLoggable(PlatformLogger.Level.FINER) && event instanceof KeyEvent) {
2915 focusLog.finer(" focus owner is {0}",
2916 String.valueOf(manager.getGlobalFocusOwner()));
2917 focusLog.finer(">>> {0}", String.valueOf(event));
2918 }
2919 }
2920
2921 synchronized(heavyweightRequests) {
2922 /*
2923 * This code handles FOCUS_LOST event which is generated by
2924 * DefaultKeyboardFocusManager for FOCUS_GAINED.
2925 *
2926 * This code based on knowledge of DefaultKeyboardFocusManager's
2927 * implementation and might be not applicable for another
2928 * KeyboardFocusManager.
2929 *
2930 * Fix for 4472032
2931 */
2932 if (newFocusOwner != null &&
2933 event.getID() == FocusEvent.FOCUS_LOST)
2934 {
2935 FocusEvent fe = (FocusEvent)event;
2936
2937 if (manager.getGlobalFocusOwner() == fe.getComponent() &&
2938 fe.getOppositeComponent() == newFocusOwner)
2939 {
2940 newFocusOwner = null;
2941 return event;
2942 }
2943 }
2944 }
2945
2946 processCurrentLightweightRequests();
2947
2948 switch (event.getID()) {
2949 case FocusEvent.FOCUS_GAINED: {
2950 event = retargetFocusGained((FocusEvent)event);
2951 break;
2952 }
2953 case FocusEvent.FOCUS_LOST: {
2954 event = retargetFocusLost((FocusEvent)event);
2955 break;
2956 }
2957 default:
2958 /* do nothing */
2959 }
2960 return event;
2961 }
2962
2963 /**
2964 * Clears markers queue
2965 * This method is not intended to be overridden by KFM's.
2966 * Only DefaultKeyboardFocusManager can implement it.
2967 * @since 1.5
2968 */
2969 void clearMarkers() {
2970 }
2971
2972 static boolean removeFirstRequest() {
2973 KeyboardFocusManager manager =
2974 KeyboardFocusManager.getCurrentKeyboardFocusManager();
2975
2976 synchronized(heavyweightRequests) {
2977 HeavyweightFocusRequest hwFocusRequest = getFirstHWRequest();
2978
2979 if (hwFocusRequest != null) {
2980 heavyweightRequests.removeFirst();
2981 if (hwFocusRequest.lightweightRequests != null) {
2982 for (Iterator<KeyboardFocusManager.LightweightFocusRequest> lwIter = hwFocusRequest.lightweightRequests.
2983 iterator();
2984 lwIter.hasNext(); )
2985 {
2986 manager.dequeueKeyEvents
2987 (-1, lwIter.next().
2988 component);
2989 }
2990 }
2991 }
2992 // Fix for 4799136 - clear type-ahead markers if requests queue is empty
2993 // We do it here because this method is called only when problems happen
2994 if (heavyweightRequests.size() == 0) {
2995 manager.clearMarkers();
2996 }
2997 return (heavyweightRequests.size() > 0);
2998 }
2999 }
3000 static void removeLastFocusRequest(Component heavyweight) {
3001 if (log.isLoggable(PlatformLogger.Level.FINE)) {
3002 if (heavyweight == null) {
3003 log.fine("Assertion (heavyweight != null) failed");
3004 }
3005 }
3006
3007 KeyboardFocusManager manager =
3008 KeyboardFocusManager.getCurrentKeyboardFocusManager();
3009 synchronized(heavyweightRequests) {
3010 HeavyweightFocusRequest hwFocusRequest = getLastHWRequest();
3011 if (hwFocusRequest != null &&
3012 hwFocusRequest.heavyweight == heavyweight) {
3013 heavyweightRequests.removeLast();
3014 }
3015 // Fix for 4799136 - clear type-ahead markers if requests queue is empty
3016 // We do it here because this method is called only when problems happen
3017 if (heavyweightRequests.size() == 0) {
3018 manager.clearMarkers();
3019 }
3020 }
3021 }
3022
3023 private static boolean focusedWindowChanged(Component to, Component from) {
3024 Window wto = SunToolkit.getContainingWindow(to);
3025 Window wfrom = SunToolkit.getContainingWindow(from);
3026 if (wto == null && wfrom == null) {
3027 return true;
3028 }
3029 if (wto == null) {
3030 return true;
3031 }
3032 if (wfrom == null) {
3033 return true;
3034 }
3035 return (wto != wfrom);
3036 }
3037
3038 private static boolean isTemporary(Component to, Component from) {
3039 Window wto = SunToolkit.getContainingWindow(to);
3040 Window wfrom = SunToolkit.getContainingWindow(from);
3041 if (wto == null && wfrom == null) {
3042 return false;
3043 }
3044 if (wto == null) {
3045 return true;
3046 }
3047 if (wfrom == null) {
3048 return false;
3049 }
3050 return (wto != wfrom);
3051 }
3052
3053 static Component getHeavyweight(Component comp) {
3054 if (comp == null || comp.getPeer() == null) {
3055 return null;
3056 } else if (comp.getPeer() instanceof LightweightPeer) {
3057 return comp.getNativeContainer();
3058 } else {
3059 return comp;
3060 }
3061 }
3062
3063 static Field proxyActive;
3064 // Accessor to private field isProxyActive of KeyEvent
3065 private static boolean isProxyActiveImpl(KeyEvent e) {
3066 if (proxyActive == null) {
3067 proxyActive = AccessController.doPrivileged(new PrivilegedAction<Field>() {
3068 public Field run() {
3069 Field field = null;
3070 try {
3071 field = KeyEvent.class.getDeclaredField("isProxyActive");
3072 if (field != null) {
3073 field.setAccessible(true);
3074 }
3075 } catch (NoSuchFieldException nsf) {
3076 assert(false);
3077 }
3078 return field;
3079 }
3080 });
3081 }
3082
3083 try {
3084 return proxyActive.getBoolean(e);
3085 } catch (IllegalAccessException iae) {
3086 assert(false);
3087 }
3088 return false;
3089 }
3090
3091 // Returns the value of this KeyEvent's field isProxyActive
3092 static boolean isProxyActive(KeyEvent e) {
3093 if (!GraphicsEnvironment.isHeadless()) {
3094 return isProxyActiveImpl(e);
3095 } else {
3096 return false;
3097 }
3098 }
3099
3100 private static HeavyweightFocusRequest getLastHWRequest() {
3101 synchronized(heavyweightRequests) {
3102 return (heavyweightRequests.size() > 0)
3103 ? heavyweightRequests.getLast()
3104 : null;
3105 }
3106 }
3107
3108 private static HeavyweightFocusRequest getFirstHWRequest() {
3109 synchronized(heavyweightRequests) {
3110 return (heavyweightRequests.size() > 0)
3111 ? heavyweightRequests.getFirst()
3112 : null;
3113 }
3114 }
3115
3116 private static void checkReplaceKFMPermission()
3117 throws SecurityException
3118 {
3119 SecurityManager security = System.getSecurityManager();
3120 if (security != null) {
3121 if (replaceKeyboardFocusManagerPermission == null) {
3122 replaceKeyboardFocusManagerPermission =
3123 new AWTPermission("replaceKeyboardFocusManager");
3124 }
3125 security.
3126 checkPermission(replaceKeyboardFocusManagerPermission);
3127 }
3128 }
3129
3130 // Checks if this KeyboardFocusManager instance is the current KFM,
3131 // or otherwise checks if the calling thread has "replaceKeyboardFocusManager"
3132 // permission. Here's the reasoning to do so:
3133 //
3134 // A system KFM instance (which is the current KFM by default) may have no
3135 // "replaceKFM" permission when a client code is on the call stack beneath,
3136 // but still it should be able to execute the methods protected by this check
3137 // due to the system KFM is trusted (and so it does like "privileged").
3138 //
3139 // If this KFM instance is not the current KFM but the client code has all
3140 // permissions we can't throw SecurityException because it would contradict
3141 // the security concepts. In this case the trusted client code is responsible
3142 // for calling the secured methods from KFM instance which is not current.
3143 private void checkKFMSecurity()
3144 throws SecurityException
3145 {
3146 if (this != getCurrentKeyboardFocusManager()) {
3147 checkReplaceKFMPermission();
3148 }
3149 }
3150 }