1 /*
2 * Copyright (c) 2000, 2020, 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.KeyEvent;
29 import java.awt.event.WindowEvent;
30 import java.awt.peer.ComponentPeer;
31 import java.awt.peer.LightweightPeer;
32 import java.lang.ref.WeakReference;
33 import java.security.AccessController;
34 import java.security.PrivilegedAction;
35 import java.util.Iterator;
36 import java.util.LinkedList;
37 import java.util.ListIterator;
38 import java.util.Set;
39
40 import sun.awt.AWTAccessor;
41 import sun.awt.AppContext;
42 import sun.awt.SunToolkit;
43 import sun.awt.TimedWindowEvent;
44 import sun.util.logging.PlatformLogger;
45
46 /**
47 * The default KeyboardFocusManager for AWT applications. Focus traversal is
48 * done in response to a Component's focus traversal keys, and using a
49 * Container's FocusTraversalPolicy.
50 * <p>
51 * Please see
52 * <a href="https://docs.oracle.com/javase/tutorial/uiswing/misc/focus.html">
53 * How to Use the Focus Subsystem</a>,
54 * a section in <em>The Java Tutorial</em>, and the
55 * <a href="../../java/awt/doc-files/FocusSpec.html">Focus Specification</a>
56 * for more information.
57 *
58 * @author David Mendenhall
59 *
60 * @see FocusTraversalPolicy
61 * @see Component#setFocusTraversalKeys
62 * @see Component#getFocusTraversalKeys
63 * @since 1.4
64 */
65 public class DefaultKeyboardFocusManager extends KeyboardFocusManager {
66 private static final PlatformLogger focusLog = PlatformLogger.getLogger("java.awt.focus.DefaultKeyboardFocusManager");
67
68 // null weak references to not create too many objects
69 private static final WeakReference<Window> NULL_WINDOW_WR =
70 new WeakReference<Window>(null);
71 private static final WeakReference<Component> NULL_COMPONENT_WR =
72 new WeakReference<Component>(null);
73 private WeakReference<Window> realOppositeWindowWR = NULL_WINDOW_WR;
74 private WeakReference<Component> realOppositeComponentWR = NULL_COMPONENT_WR;
75 private int inSendMessage;
76 private LinkedList<KeyEvent> enqueuedKeyEvents = new LinkedList<KeyEvent>();
77 private LinkedList<TypeAheadMarker> typeAheadMarkers = new LinkedList<TypeAheadMarker>();
78 private boolean consumeNextKeyTyped;
79 private Component restoreFocusTo;
80
81 private static boolean fxAppThreadIsDispatchThread;
82
83 static {
84 AWTAccessor.setDefaultKeyboardFocusManagerAccessor(
85 new AWTAccessor.DefaultKeyboardFocusManagerAccessor() {
86 public void consumeNextKeyTyped(DefaultKeyboardFocusManager dkfm, KeyEvent e) {
87 dkfm.consumeNextKeyTyped(e);
88 }
89 });
90 AccessController.doPrivileged(new PrivilegedAction<Object>() {
91 public Object run() {
92 fxAppThreadIsDispatchThread =
93 "true".equals(System.getProperty("javafx.embed.singleThread"));
94 return null;
95 }
96 });
97 }
98
99 /**
100 * Constructs a {@code DefaultKeyboardFocusManager}.
101 */
102 public DefaultKeyboardFocusManager() {}
103
104 private static class TypeAheadMarker {
105 long after;
106 Component untilFocused;
107
108 TypeAheadMarker(long after, Component untilFocused) {
109 this.after = after;
110 this.untilFocused = untilFocused;
111 }
112 /**
113 * Returns string representation of the marker
114 */
115 public String toString() {
116 return ">>> Marker after " + after + " on " + untilFocused;
117 }
118 }
119
120 private Window getOwningFrameDialog(Window window) {
121 while (window != null && !(window instanceof Frame ||
122 window instanceof Dialog)) {
123 window = (Window)window.getParent();
124 }
125 return window;
126 }
127
128 /*
129 * This series of restoreFocus methods is used for recovering from a
130 * rejected focus or activation change. Rejections typically occur when
131 * the user attempts to focus a non-focusable Component or Window.
132 */
133 private void restoreFocus(FocusEvent fe, Window newFocusedWindow) {
134 Component realOppositeComponent = this.realOppositeComponentWR.get();
135 Component vetoedComponent = fe.getComponent();
136
137 if (newFocusedWindow != null && restoreFocus(newFocusedWindow,
138 vetoedComponent, false))
139 {
140 } else if (realOppositeComponent != null &&
141 doRestoreFocus(realOppositeComponent, vetoedComponent, false)) {
142 } else if (fe.getOppositeComponent() != null &&
143 doRestoreFocus(fe.getOppositeComponent(), vetoedComponent, false)) {
144 } else {
145 clearGlobalFocusOwnerPriv();
146 }
147 }
148 private void restoreFocus(WindowEvent we) {
149 Window realOppositeWindow = this.realOppositeWindowWR.get();
150 if (realOppositeWindow != null
151 && restoreFocus(realOppositeWindow, null, false))
152 {
153 // do nothing, everything is done in restoreFocus()
154 } else if (we.getOppositeWindow() != null &&
155 restoreFocus(we.getOppositeWindow(), null, false))
156 {
157 // do nothing, everything is done in restoreFocus()
158 } else {
159 clearGlobalFocusOwnerPriv();
160 }
161 }
162 private boolean restoreFocus(Window aWindow, Component vetoedComponent,
163 boolean clearOnFailure) {
164 restoreFocusTo = null;
165 Component toFocus =
166 KeyboardFocusManager.getMostRecentFocusOwner(aWindow);
167
168 if (toFocus != null && toFocus != vetoedComponent) {
169 if (getHeavyweight(aWindow) != getNativeFocusOwner()) {
170 // cannot restore focus synchronously
171 if (!toFocus.isShowing() || !toFocus.canBeFocusOwner()) {
172 toFocus = toFocus.getNextFocusCandidate();
173 }
174 if (toFocus != null && toFocus != vetoedComponent) {
175 if (!toFocus.requestFocus(false,
176 FocusEvent.Cause.ROLLBACK)) {
177 restoreFocusTo = toFocus;
178 }
179 return true;
180 }
181 } else if (doRestoreFocus(toFocus, vetoedComponent, false)) {
182 return true;
183 }
184 }
185 if (clearOnFailure) {
186 clearGlobalFocusOwnerPriv();
187 return true;
188 } else {
189 return false;
190 }
191 }
192 private boolean restoreFocus(Component toFocus, boolean clearOnFailure) {
193 return doRestoreFocus(toFocus, null, clearOnFailure);
194 }
195 private boolean doRestoreFocus(Component toFocus, Component vetoedComponent,
196 boolean clearOnFailure)
197 {
198 boolean success = true;
199 if (toFocus != vetoedComponent && toFocus.isShowing() && toFocus.canBeFocusOwner() &&
200 (success = toFocus.requestFocus(false, FocusEvent.Cause.ROLLBACK)))
201 {
202 return true;
203 } else {
204 if (!success && getGlobalFocusedWindow() != SunToolkit.getContainingWindow(toFocus)) {
205 restoreFocusTo = toFocus;
206 return true;
207 }
208 Component nextFocus = toFocus.getNextFocusCandidate();
209 if (nextFocus != null && nextFocus != vetoedComponent &&
210 nextFocus.requestFocusInWindow(FocusEvent.Cause.ROLLBACK))
211 {
212 return true;
213 } else if (clearOnFailure) {
214 clearGlobalFocusOwnerPriv();
215 return true;
216 } else {
217 return false;
218 }
219 }
220 }
221
222 /**
223 * A special type of SentEvent which updates a counter in the target
224 * KeyboardFocusManager if it is an instance of
225 * DefaultKeyboardFocusManager.
226 */
227 private static class DefaultKeyboardFocusManagerSentEvent
228 extends SentEvent
229 {
230 /*
231 * serialVersionUID
232 */
233 private static final long serialVersionUID = -2924743257508701758L;
234
235 public DefaultKeyboardFocusManagerSentEvent(AWTEvent nested,
236 AppContext toNotify) {
237 super(nested, toNotify);
238 }
239 public final void dispatch() {
240 KeyboardFocusManager manager =
241 KeyboardFocusManager.getCurrentKeyboardFocusManager();
242 DefaultKeyboardFocusManager defaultManager =
243 (manager instanceof DefaultKeyboardFocusManager)
244 ? (DefaultKeyboardFocusManager)manager
245 : null;
246
247 if (defaultManager != null) {
248 synchronized (defaultManager) {
249 defaultManager.inSendMessage++;
250 }
251 }
252
253 super.dispatch();
254
255 if (defaultManager != null) {
256 synchronized (defaultManager) {
257 defaultManager.inSendMessage--;
258 }
259 }
260 }
261 }
262
263 /**
264 * Sends a synthetic AWTEvent to a Component. If the Component is in
265 * the current AppContext, then the event is immediately dispatched.
266 * If the Component is in a different AppContext, then the event is
267 * posted to the other AppContext's EventQueue, and this method blocks
268 * until the event is handled or target AppContext is disposed.
269 * Returns true if successfully dispatched event, false if failed
270 * to dispatch.
271 */
272 static boolean sendMessage(Component target, AWTEvent e) {
273 e.isPosted = true;
274 AppContext myAppContext = AppContext.getAppContext();
275 final AppContext targetAppContext = target.appContext;
276 final SentEvent se =
277 new DefaultKeyboardFocusManagerSentEvent(e, myAppContext);
278
279 if (myAppContext == targetAppContext) {
280 se.dispatch();
281 } else {
282 if (targetAppContext.isDisposed()) {
283 return false;
284 }
285 SunToolkit.postEvent(targetAppContext, se);
286 if (EventQueue.isDispatchThread()) {
287 if (Thread.currentThread() instanceof EventDispatchThread) {
288 EventDispatchThread edt = (EventDispatchThread)
289 Thread.currentThread();
290 edt.pumpEvents(SentEvent.ID, new Conditional() {
291 public boolean evaluate() {
292 return !se.dispatched && !targetAppContext.isDisposed();
293 }
294 });
295 } else {
296 if (fxAppThreadIsDispatchThread) {
297 Thread fxCheckDispatchThread = new Thread() {
298 @Override
299 public void run() {
300 while (!se.dispatched && !targetAppContext.isDisposed()) {
301 try {
302 Thread.sleep(100);
303 } catch (InterruptedException e) {
304 break;
305 }
306 }
307 }
308 };
309 fxCheckDispatchThread.start();
310 try {
311 // check if event is dispatched or disposed
312 // but since this user app thread is same as
313 // dispatch thread in fx when run with
314 // javafx.embed.singleThread=true
315 // we do not wait infinitely to avoid deadlock
316 // as dispatch will ultimately be done by this thread
317 fxCheckDispatchThread.join(500);
318 } catch (InterruptedException ex) {
319 }
320 }
321 }
322 } else {
323 synchronized (se) {
324 while (!se.dispatched && !targetAppContext.isDisposed()) {
325 try {
326 se.wait(1000);
327 } catch (InterruptedException ie) {
328 break;
329 }
330 }
331 }
332 }
333 }
334 return se.dispatched;
335 }
336
337 /*
338 * Checks if the focus window event follows key events waiting in the type-ahead
339 * queue (if any). This may happen when a user types ahead in the window, the client
340 * listeners hang EDT for a while, and the user switches b/w toplevels. In that
341 * case the focus window events may be dispatched before the type-ahead events
342 * get handled. This may lead to wrong focus behavior and in order to avoid it,
343 * the focus window events are reposted to the end of the event queue. See 6981400.
344 */
345 private boolean repostIfFollowsKeyEvents(WindowEvent e) {
346 if (!(e instanceof TimedWindowEvent)) {
347 return false;
348 }
349 TimedWindowEvent we = (TimedWindowEvent)e;
350 long time = we.getWhen();
351 synchronized (this) {
352 KeyEvent ke = enqueuedKeyEvents.isEmpty() ? null : enqueuedKeyEvents.getFirst();
353 if (ke != null && time >= ke.getWhen()) {
354 TypeAheadMarker marker = typeAheadMarkers.isEmpty() ? null : typeAheadMarkers.getFirst();
355 if (marker != null) {
356 Window toplevel = marker.untilFocused.getContainingWindow();
357 // Check that the component awaiting focus belongs to
358 // the current focused window. See 8015454.
359 if (toplevel != null && toplevel.isFocused()) {
360 SunToolkit.postEvent(AppContext.getAppContext(), new SequencedEvent(e));
361 return true;
362 }
363 }
364 }
365 }
366 return false;
367 }
368
369 /**
370 * This method is called by the AWT event dispatcher requesting that the
371 * current KeyboardFocusManager dispatch the specified event on its behalf.
372 * DefaultKeyboardFocusManagers dispatch all FocusEvents, all WindowEvents
373 * related to focus, and all KeyEvents. These events are dispatched based
374 * on the KeyboardFocusManager's notion of the focus owner and the focused
375 * and active Windows, sometimes overriding the source of the specified
376 * AWTEvent. If this method returns {@code false}, then the AWT event
377 * dispatcher will attempt to dispatch the event itself.
378 *
379 * @param e the AWTEvent to be dispatched
380 * @return {@code true} if this method dispatched the event;
381 * {@code false} otherwise
382 */
383 public boolean dispatchEvent(AWTEvent e) {
384 if (focusLog.isLoggable(PlatformLogger.Level.FINE) && (e instanceof WindowEvent || e instanceof FocusEvent)) {
385 focusLog.fine("" + e);
386 }
387 switch (e.getID()) {
388 case WindowEvent.WINDOW_GAINED_FOCUS: {
389 if (repostIfFollowsKeyEvents((WindowEvent)e)) {
390 break;
391 }
392
393 WindowEvent we = (WindowEvent)e;
394 Window oldFocusedWindow = getGlobalFocusedWindow();
395 Window newFocusedWindow = we.getWindow();
396 if (newFocusedWindow == oldFocusedWindow) {
397 break;
398 }
399
400 if (!(newFocusedWindow.isFocusableWindow()
401 && newFocusedWindow.isVisible()
402 && newFocusedWindow.isDisplayable()))
403 {
404 // we can not accept focus on such window, so reject it.
405 restoreFocus(we);
406 break;
407 }
408 // If there exists a current focused window, then notify it
409 // that it has lost focus.
410 if (oldFocusedWindow != null) {
411 boolean isEventDispatched =
412 sendMessage(oldFocusedWindow,
413 new WindowEvent(oldFocusedWindow,
414 WindowEvent.WINDOW_LOST_FOCUS,
415 newFocusedWindow));
416 // Failed to dispatch, clear by ourselves
417 if (!isEventDispatched) {
418 setGlobalFocusOwner(null);
419 setGlobalFocusedWindow(null);
420 }
421 }
422
423 // Because the native libraries do not post WINDOW_ACTIVATED
424 // events, we need to synthesize one if the active Window
425 // changed.
426 Window newActiveWindow =
427 getOwningFrameDialog(newFocusedWindow);
428 Window currentActiveWindow = getGlobalActiveWindow();
429 if (newActiveWindow != currentActiveWindow) {
430 sendMessage(newActiveWindow,
431 new WindowEvent(newActiveWindow,
432 WindowEvent.WINDOW_ACTIVATED,
433 currentActiveWindow));
434 if (newActiveWindow != getGlobalActiveWindow()) {
435 // Activation change was rejected. Unlikely, but
436 // possible.
437 restoreFocus(we);
438 break;
439 }
440 }
441
442 setGlobalFocusedWindow(newFocusedWindow);
443
444 if (newFocusedWindow != getGlobalFocusedWindow()) {
445 // Focus change was rejected. Will happen if
446 // newFocusedWindow is not a focusable Window.
447 restoreFocus(we);
448 break;
449 }
450
451 // Restore focus to the Component which last held it. We do
452 // this here so that client code can override our choice in
453 // a WINDOW_GAINED_FOCUS handler.
454 //
455 // Make sure that the focus change request doesn't change the
456 // focused Window in case we are no longer the focused Window
457 // when the request is handled.
458 if (inSendMessage == 0) {
459 // Identify which Component should initially gain focus
460 // in the Window.
461 //
462 // * If we're in SendMessage, then this is a synthetic
463 // WINDOW_GAINED_FOCUS message which was generated by a
464 // the FOCUS_GAINED handler. Allow the Component to
465 // which the FOCUS_GAINED message was targeted to
466 // receive the focus.
467 // * Otherwise, look up the correct Component here.
468 // We don't use Window.getMostRecentFocusOwner because
469 // window is focused now and 'null' will be returned
470
471
472 // Calculating of most recent focus owner and focus
473 // request should be synchronized on KeyboardFocusManager.class
474 // to prevent from thread race when user will request
475 // focus between calculation and our request.
476 // But if focus transfer is synchronous, this synchronization
477 // may cause deadlock, thus we don't synchronize this block.
478 Component toFocus = KeyboardFocusManager.
479 getMostRecentFocusOwner(newFocusedWindow);
480 boolean isFocusRestore = restoreFocusTo != null &&
481 toFocus == restoreFocusTo;
482 if ((toFocus == null) &&
483 newFocusedWindow.isFocusableWindow())
484 {
485 toFocus = newFocusedWindow.getFocusTraversalPolicy().
486 getInitialComponent(newFocusedWindow);
487 }
488 Component tempLost = null;
489 synchronized(KeyboardFocusManager.class) {
490 tempLost = newFocusedWindow.setTemporaryLostComponent(null);
491 }
492
493 // The component which last has the focus when this window was focused
494 // should receive focus first
495 if (focusLog.isLoggable(PlatformLogger.Level.FINER)) {
496 focusLog.finer("tempLost {0}, toFocus {1}",
497 tempLost, toFocus);
498 }
499 if (tempLost != null) {
500 tempLost.requestFocusInWindow(
501 isFocusRestore && tempLost == toFocus ?
502 FocusEvent.Cause.ROLLBACK :
503 FocusEvent.Cause.ACTIVATION);
504 }
505
506 if (toFocus != null && toFocus != tempLost) {
507 // If there is a component which requested focus when this window
508 // was inactive it expects to receive focus after activation.
509 toFocus.requestFocusInWindow(FocusEvent.Cause.ACTIVATION);
510 }
511 }
512 restoreFocusTo = null;
513
514 Window realOppositeWindow = this.realOppositeWindowWR.get();
515 if (realOppositeWindow != we.getOppositeWindow()) {
516 we = new WindowEvent(newFocusedWindow,
517 WindowEvent.WINDOW_GAINED_FOCUS,
518 realOppositeWindow);
519 }
520 return typeAheadAssertions(newFocusedWindow, we);
521 }
522
523 case WindowEvent.WINDOW_ACTIVATED: {
524 WindowEvent we = (WindowEvent)e;
525 Window oldActiveWindow = getGlobalActiveWindow();
526 Window newActiveWindow = we.getWindow();
527 if (oldActiveWindow == newActiveWindow) {
528 break;
529 }
530
531 // If there exists a current active window, then notify it that
532 // it has lost activation.
533 if (oldActiveWindow != null) {
534 boolean isEventDispatched =
535 sendMessage(oldActiveWindow,
536 new WindowEvent(oldActiveWindow,
537 WindowEvent.WINDOW_DEACTIVATED,
538 newActiveWindow));
539 // Failed to dispatch, clear by ourselves
540 if (!isEventDispatched) {
541 setGlobalActiveWindow(null);
542 }
543 if (getGlobalActiveWindow() != null) {
544 // Activation change was rejected. Unlikely, but
545 // possible.
546 break;
547 }
548 }
549
550 setGlobalActiveWindow(newActiveWindow);
551
552 if (newActiveWindow != getGlobalActiveWindow()) {
553 // Activation change was rejected. Unlikely, but
554 // possible.
555 break;
556 }
557
558 return typeAheadAssertions(newActiveWindow, we);
559 }
560
561 case FocusEvent.FOCUS_GAINED: {
562 restoreFocusTo = null;
563 FocusEvent fe = (FocusEvent)e;
564 Component oldFocusOwner = getGlobalFocusOwner();
565 Component newFocusOwner = fe.getComponent();
566 if (oldFocusOwner == newFocusOwner) {
567 if (focusLog.isLoggable(PlatformLogger.Level.FINE)) {
568 focusLog.fine("Skipping {0} because focus owner is the same", e);
569 }
570 // We can't just drop the event - there could be
571 // type-ahead markers associated with it.
572 dequeueKeyEvents(-1, newFocusOwner);
573 break;
574 }
575
576 // If there exists a current focus owner, then notify it that
577 // it has lost focus.
578 if (oldFocusOwner != null) {
579 boolean isEventDispatched =
580 sendMessage(oldFocusOwner,
581 new FocusEvent(oldFocusOwner,
582 FocusEvent.FOCUS_LOST,
583 fe.isTemporary(),
584 newFocusOwner, fe.getCause()));
585 // Failed to dispatch, clear by ourselves
586 if (!isEventDispatched) {
587 setGlobalFocusOwner(null);
588 if (!fe.isTemporary()) {
589 setGlobalPermanentFocusOwner(null);
590 }
591 }
592 }
593
594 // Because the native windowing system has a different notion
595 // of the current focus and activation states, it is possible
596 // that a Component outside of the focused Window receives a
597 // FOCUS_GAINED event. We synthesize a WINDOW_GAINED_FOCUS
598 // event in that case.
599 final Window newFocusedWindow = SunToolkit.getContainingWindow(newFocusOwner);
600 final Window currentFocusedWindow = getGlobalFocusedWindow();
601 if (newFocusedWindow != null &&
602 newFocusedWindow != currentFocusedWindow)
603 {
604 sendMessage(newFocusedWindow,
605 new WindowEvent(newFocusedWindow,
606 WindowEvent.WINDOW_GAINED_FOCUS,
607 currentFocusedWindow));
608 if (newFocusedWindow != getGlobalFocusedWindow()) {
609 // Focus change was rejected. Will happen if
610 // newFocusedWindow is not a focusable Window.
611
612 // Need to recover type-ahead, but don't bother
613 // restoring focus. That was done by the
614 // WINDOW_GAINED_FOCUS handler
615 dequeueKeyEvents(-1, newFocusOwner);
616 break;
617 }
618 }
619
620 if (!(newFocusOwner.isFocusable() && newFocusOwner.isShowing() &&
621 // Refuse focus on a disabled component if the focus event
622 // isn't of UNKNOWN reason (i.e. not a result of a direct request
623 // but traversal, activation or system generated).
624 (newFocusOwner.isEnabled() || fe.getCause().equals(FocusEvent.Cause.UNKNOWN))))
625 {
626 // we should not accept focus on such component, so reject it.
627 dequeueKeyEvents(-1, newFocusOwner);
628 if (KeyboardFocusManager.isAutoFocusTransferEnabled()) {
629 // If FOCUS_GAINED is for a disposed component (however
630 // it shouldn't happen) its toplevel parent is null. In this
631 // case we have to try to restore focus in the current focused
632 // window (for the details: 6607170).
633 if (newFocusedWindow == null) {
634 restoreFocus(fe, currentFocusedWindow);
635 } else {
636 restoreFocus(fe, newFocusedWindow);
637 }
638 setMostRecentFocusOwner(newFocusedWindow, null); // see: 8013773
639 }
640 break;
641 }
642
643 setGlobalFocusOwner(newFocusOwner);
644
645 if (newFocusOwner != getGlobalFocusOwner()) {
646 // Focus change was rejected. Will happen if
647 // newFocusOwner is not focus traversable.
648 dequeueKeyEvents(-1, newFocusOwner);
649 if (KeyboardFocusManager.isAutoFocusTransferEnabled()) {
650 restoreFocus(fe, newFocusedWindow);
651 }
652 break;
653 }
654
655 if (!fe.isTemporary()) {
656 setGlobalPermanentFocusOwner(newFocusOwner);
657
658 if (newFocusOwner != getGlobalPermanentFocusOwner()) {
659 // Focus change was rejected. Unlikely, but possible.
660 dequeueKeyEvents(-1, newFocusOwner);
661 if (KeyboardFocusManager.isAutoFocusTransferEnabled()) {
662 restoreFocus(fe, newFocusedWindow);
663 }
664 break;
665 }
666 }
667
668 setNativeFocusOwner(getHeavyweight(newFocusOwner));
669
670 Component realOppositeComponent = this.realOppositeComponentWR.get();
671 if (realOppositeComponent != null &&
672 realOppositeComponent != fe.getOppositeComponent()) {
673 fe = new FocusEvent(newFocusOwner,
674 FocusEvent.FOCUS_GAINED,
675 fe.isTemporary(),
676 realOppositeComponent, fe.getCause());
677 ((AWTEvent) fe).isPosted = true;
678 }
679 return typeAheadAssertions(newFocusOwner, fe);
680 }
681
682 case FocusEvent.FOCUS_LOST: {
683 FocusEvent fe = (FocusEvent)e;
684 Component currentFocusOwner = getGlobalFocusOwner();
685 if (currentFocusOwner == null) {
686 if (focusLog.isLoggable(PlatformLogger.Level.FINE))
687 focusLog.fine("Skipping {0} because focus owner is null", e);
688 break;
689 }
690 // Ignore cases where a Component loses focus to itself.
691 // If we make a mistake because of retargeting, then the
692 // FOCUS_GAINED handler will correct it.
693 if (currentFocusOwner == fe.getOppositeComponent()) {
694 if (focusLog.isLoggable(PlatformLogger.Level.FINE))
695 focusLog.fine("Skipping {0} because current focus owner is equal to opposite", e);
696 break;
697 }
698
699 setGlobalFocusOwner(null);
700
701 if (getGlobalFocusOwner() != null) {
702 // Focus change was rejected. Unlikely, but possible.
703 restoreFocus(currentFocusOwner, true);
704 break;
705 }
706
707 if (!fe.isTemporary()) {
708 setGlobalPermanentFocusOwner(null);
709
710 if (getGlobalPermanentFocusOwner() != null) {
711 // Focus change was rejected. Unlikely, but possible.
712 restoreFocus(currentFocusOwner, true);
713 break;
714 }
715 } else {
716 Window owningWindow = currentFocusOwner.getContainingWindow();
717 if (owningWindow != null) {
718 owningWindow.setTemporaryLostComponent(currentFocusOwner);
719 }
720 }
721
722 setNativeFocusOwner(null);
723
724 fe.setSource(currentFocusOwner);
725
726 realOppositeComponentWR = (fe.getOppositeComponent() != null)
727 ? new WeakReference<Component>(currentFocusOwner)
728 : NULL_COMPONENT_WR;
729
730 return typeAheadAssertions(currentFocusOwner, fe);
731 }
732
733 case WindowEvent.WINDOW_DEACTIVATED: {
734 WindowEvent we = (WindowEvent)e;
735 Window currentActiveWindow = getGlobalActiveWindow();
736 if (currentActiveWindow == null) {
737 break;
738 }
739
740 if (currentActiveWindow != e.getSource()) {
741 // The event is lost in time.
742 // Allow listeners to precess the event but do not
743 // change any global states
744 break;
745 }
746
747 setGlobalActiveWindow(null);
748 if (getGlobalActiveWindow() != null) {
749 // Activation change was rejected. Unlikely, but possible.
750 break;
751 }
752
753 we.setSource(currentActiveWindow);
754 return typeAheadAssertions(currentActiveWindow, we);
755 }
756
757 case WindowEvent.WINDOW_LOST_FOCUS: {
758 if (repostIfFollowsKeyEvents((WindowEvent)e)) {
759 break;
760 }
761
762 WindowEvent we = (WindowEvent)e;
763 Window currentFocusedWindow = getGlobalFocusedWindow();
764 Window losingFocusWindow = we.getWindow();
765 Window activeWindow = getGlobalActiveWindow();
766 Window oppositeWindow = we.getOppositeWindow();
767 if (focusLog.isLoggable(PlatformLogger.Level.FINE))
768 focusLog.fine("Active {0}, Current focused {1}, losing focus {2} opposite {3}",
769 activeWindow, currentFocusedWindow,
770 losingFocusWindow, oppositeWindow);
771 if (currentFocusedWindow == null) {
772 break;
773 }
774
775 // Special case -- if the native windowing system posts an
776 // event claiming that the active Window has lost focus to the
777 // focused Window, then discard the event. This is an artifact
778 // of the native windowing system not knowing which Window is
779 // really focused.
780 if (inSendMessage == 0 && losingFocusWindow == activeWindow &&
781 oppositeWindow == currentFocusedWindow)
782 {
783 break;
784 }
785
786 Component currentFocusOwner = getGlobalFocusOwner();
787 if (currentFocusOwner != null) {
788 // The focus owner should always receive a FOCUS_LOST event
789 // before the Window is defocused.
790 Component oppositeComp = null;
791 if (oppositeWindow != null) {
792 oppositeComp = oppositeWindow.getTemporaryLostComponent();
793 if (oppositeComp == null) {
794 oppositeComp = oppositeWindow.getMostRecentFocusOwner();
795 }
796 }
797 if (oppositeComp == null) {
798 oppositeComp = oppositeWindow;
799 }
800 sendMessage(currentFocusOwner,
801 new FocusEvent(currentFocusOwner,
802 FocusEvent.FOCUS_LOST,
803 true,
804 oppositeComp, FocusEvent.Cause.ACTIVATION));
805 }
806
807 setGlobalFocusedWindow(null);
808 if (getGlobalFocusedWindow() != null) {
809 // Focus change was rejected. Unlikely, but possible.
810 restoreFocus(currentFocusedWindow, null, true);
811 break;
812 }
813
814 we.setSource(currentFocusedWindow);
815 realOppositeWindowWR = (oppositeWindow != null)
816 ? new WeakReference<Window>(currentFocusedWindow)
817 : NULL_WINDOW_WR;
818 typeAheadAssertions(currentFocusedWindow, we);
819
820 if (oppositeWindow == null && activeWindow != null) {
821 // Then we need to deactivate the active Window as well.
822 // No need to synthesize in other cases, because
823 // WINDOW_ACTIVATED will handle it if necessary.
824 sendMessage(activeWindow,
825 new WindowEvent(activeWindow,
826 WindowEvent.WINDOW_DEACTIVATED,
827 null));
828 if (getGlobalActiveWindow() != null) {
829 // Activation change was rejected. Unlikely,
830 // but possible.
831 restoreFocus(currentFocusedWindow, null, true);
832 }
833 }
834 break;
835 }
836
837 case KeyEvent.KEY_TYPED:
838 case KeyEvent.KEY_PRESSED:
839 case KeyEvent.KEY_RELEASED:
840 return typeAheadAssertions(null, e);
841
842 default:
843 return false;
844 }
845
846 return true;
847 }
848
849 /**
850 * Called by {@code dispatchEvent} if no other
851 * KeyEventDispatcher in the dispatcher chain dispatched the KeyEvent, or
852 * if no other KeyEventDispatchers are registered. If the event has not
853 * been consumed, its target is enabled, and the focus owner is not null,
854 * this method dispatches the event to its target. This method will also
855 * subsequently dispatch the event to all registered
856 * KeyEventPostProcessors. After all this operations are finished,
857 * the event is passed to peers for processing.
858 * <p>
859 * In all cases, this method returns {@code true}, since
860 * DefaultKeyboardFocusManager is designed so that neither
861 * {@code dispatchEvent}, nor the AWT event dispatcher, should take
862 * further action on the event in any situation.
863 *
864 * @param e the KeyEvent to be dispatched
865 * @return {@code true}
866 * @see Component#dispatchEvent
867 */
868 public boolean dispatchKeyEvent(KeyEvent e) {
869 Component focusOwner = (((AWTEvent)e).isPosted) ? getFocusOwner() : e.getComponent();
870
871 if (focusOwner != null && focusOwner.isShowing() && focusOwner.canBeFocusOwner()) {
872 if (!e.isConsumed()) {
873 Component comp = e.getComponent();
874 if (comp != null && comp.isEnabled()) {
875 redispatchEvent(comp, e);
876 }
877 }
878 }
879 boolean stopPostProcessing = false;
880 java.util.List<KeyEventPostProcessor> processors = getKeyEventPostProcessors();
881 if (processors != null) {
882 for (java.util.Iterator<KeyEventPostProcessor> iter = processors.iterator();
883 !stopPostProcessing && iter.hasNext(); )
884 {
885 stopPostProcessing = iter.next().
886 postProcessKeyEvent(e);
887 }
888 }
889 if (!stopPostProcessing) {
890 postProcessKeyEvent(e);
891 }
892
893 // Allow the peer to process KeyEvent
894 Component source = e.getComponent();
895 ComponentPeer peer = source.peer;
896
897 if (peer == null || peer instanceof LightweightPeer) {
898 // if focus owner is lightweight then its native container
899 // processes event
900 Container target = source.getNativeContainer();
901 if (target != null) {
902 peer = target.peer;
903 }
904 }
905 if (peer != null) {
906 peer.handleEvent(e);
907 }
908
909 return true;
910 }
911
912 /**
913 * This method will be called by {@code dispatchKeyEvent}. It will
914 * handle any unconsumed KeyEvents that map to an AWT
915 * {@code MenuShortcut} by consuming the event and activating the
916 * shortcut.
917 *
918 * @param e the KeyEvent to post-process
919 * @return {@code true}
920 * @see #dispatchKeyEvent
921 * @see MenuShortcut
922 */
923 public boolean postProcessKeyEvent(KeyEvent e) {
924 if (!e.isConsumed()) {
925 Component target = e.getComponent();
926 Container p = (Container)
927 (target instanceof Container ? target : target.getParent());
928 if (p != null) {
929 p.postProcessKeyEvent(e);
930 }
931 }
932 return true;
933 }
934
935 private void pumpApprovedKeyEvents() {
936 KeyEvent ke;
937 do {
938 ke = null;
939 synchronized (this) {
940 if (enqueuedKeyEvents.size() != 0) {
941 ke = enqueuedKeyEvents.getFirst();
942 if (typeAheadMarkers.size() != 0) {
943 TypeAheadMarker marker = typeAheadMarkers.getFirst();
944 // Fixed 5064013: may appears that the events have the same time
945 // if (ke.getWhen() >= marker.after) {
946 // The fix is rolled out.
947
948 if (ke.getWhen() > marker.after) {
949 ke = null;
950 }
951 }
952 if (ke != null) {
953 if (focusLog.isLoggable(PlatformLogger.Level.FINER)) {
954 focusLog.finer("Pumping approved event {0}", ke);
955 }
956 enqueuedKeyEvents.removeFirst();
957 }
958 }
959 }
960 if (ke != null) {
961 preDispatchKeyEvent(ke);
962 }
963 } while (ke != null);
964 }
965
966 /**
967 * Dumps the list of type-ahead queue markers to stderr
968 */
969 void dumpMarkers() {
970 if (focusLog.isLoggable(PlatformLogger.Level.FINEST)) {
971 focusLog.finest(">>> Markers dump, time: {0}", System.currentTimeMillis());
972 synchronized (this) {
973 if (typeAheadMarkers.size() != 0) {
974 Iterator<TypeAheadMarker> iter = typeAheadMarkers.iterator();
975 while (iter.hasNext()) {
976 TypeAheadMarker marker = iter.next();
977 focusLog.finest(" {0}", marker);
978 }
979 }
980 }
981 }
982 }
983
984 private boolean typeAheadAssertions(Component target, AWTEvent e) {
985
986 // Clear any pending events here as well as in the FOCUS_GAINED
987 // handler. We need this call here in case a marker was removed in
988 // response to a call to dequeueKeyEvents.
989 pumpApprovedKeyEvents();
990
991 switch (e.getID()) {
992 case KeyEvent.KEY_TYPED:
993 case KeyEvent.KEY_PRESSED:
994 case KeyEvent.KEY_RELEASED: {
995 KeyEvent ke = (KeyEvent)e;
996 synchronized (this) {
997 if (e.isPosted && typeAheadMarkers.size() != 0) {
998 TypeAheadMarker marker = typeAheadMarkers.getFirst();
999 // Fixed 5064013: may appears that the events have the same time
1000 // if (ke.getWhen() >= marker.after) {
1001 // The fix is rolled out.
1002
1003 if (ke.getWhen() > marker.after) {
1004 if (focusLog.isLoggable(PlatformLogger.Level.FINER)) {
1005 focusLog.finer("Storing event {0} because of marker {1}", ke, marker);
1006 }
1007 enqueuedKeyEvents.addLast(ke);
1008 return true;
1009 }
1010 }
1011 }
1012
1013 // KeyEvent was posted before focus change request
1014 return preDispatchKeyEvent(ke);
1015 }
1016
1017 case FocusEvent.FOCUS_GAINED:
1018 if (focusLog.isLoggable(PlatformLogger.Level.FINEST)) {
1019 focusLog.finest("Markers before FOCUS_GAINED on {0}", target);
1020 }
1021 dumpMarkers();
1022 // Search the marker list for the first marker tied to
1023 // the Component which just gained focus. Then remove
1024 // that marker, any markers which immediately follow
1025 // and are tied to the same component, and all markers
1026 // that precede it. This handles the case where
1027 // multiple focus requests were made for the same
1028 // Component in a row and when we lost some of the
1029 // earlier requests. Since FOCUS_GAINED events will
1030 // not be generated for these additional requests, we
1031 // need to clear those markers too.
1032 synchronized (this) {
1033 boolean found = false;
1034 if (hasMarker(target)) {
1035 for (Iterator<TypeAheadMarker> iter = typeAheadMarkers.iterator();
1036 iter.hasNext(); )
1037 {
1038 if (iter.next().untilFocused == target) {
1039 found = true;
1040 } else if (found) {
1041 break;
1042 }
1043 iter.remove();
1044 }
1045 } else {
1046 // Exception condition - event without marker
1047 if (focusLog.isLoggable(PlatformLogger.Level.FINER)) {
1048 focusLog.finer("Event without marker {0}", e);
1049 }
1050 }
1051 }
1052 focusLog.finest("Markers after FOCUS_GAINED");
1053 dumpMarkers();
1054
1055 redispatchEvent(target, e);
1056
1057 // Now, dispatch any pending KeyEvents which have been
1058 // released because of the FOCUS_GAINED event so that we don't
1059 // have to wait for another event to be posted to the queue.
1060 pumpApprovedKeyEvents();
1061 return true;
1062
1063 default:
1064 redispatchEvent(target, e);
1065 return true;
1066 }
1067 }
1068
1069 /**
1070 * Returns true if there are some marker associated with component {@code comp}
1071 * in a markers' queue
1072 * @since 1.5
1073 */
1074 private boolean hasMarker(Component comp) {
1075 for (Iterator<TypeAheadMarker> iter = typeAheadMarkers.iterator(); iter.hasNext(); ) {
1076 if (iter.next().untilFocused == comp) {
1077 return true;
1078 }
1079 }
1080 return false;
1081 }
1082
1083 /**
1084 * Clears markers queue
1085 * @since 1.5
1086 */
1087 void clearMarkers() {
1088 synchronized(this) {
1089 typeAheadMarkers.clear();
1090 }
1091 }
1092
1093 @SuppressWarnings("deprecation")
1094 private boolean preDispatchKeyEvent(KeyEvent ke) {
1095 if (((AWTEvent) ke).isPosted) {
1096 Component focusOwner = getFocusOwner();
1097 ke.setSource(((focusOwner != null) ? focusOwner : getFocusedWindow()));
1098 }
1099 if (ke.getSource() == null) {
1100 return true;
1101 }
1102
1103 // Explicitly set the key event timestamp here (not in Component.dispatchEventImpl):
1104 // - A key event is anyway passed to this method which starts its actual dispatching.
1105 // - If a key event is put to the type ahead queue, its time stamp should not be registered
1106 // until its dispatching actually starts (by this method).
1107 EventQueue.setCurrentEventAndMostRecentTime(ke);
1108
1109 /**
1110 * Fix for 4495473.
1111 * This fix allows to correctly dispatch events when native
1112 * event proxying mechanism is active.
1113 * If it is active we should redispatch key events after
1114 * we detected its correct target.
1115 */
1116 if (KeyboardFocusManager.isProxyActive(ke)) {
1117 Component source = (Component)ke.getSource();
1118 Container target = source.getNativeContainer();
1119 if (target != null) {
1120 ComponentPeer peer = target.peer;
1121 if (peer != null) {
1122 peer.handleEvent(ke);
1123 /**
1124 * Fix for 4478780 - consume event after it was dispatched by peer.
1125 */
1126 ke.consume();
1127 }
1128 }
1129 return true;
1130 }
1131
1132 java.util.List<KeyEventDispatcher> dispatchers = getKeyEventDispatchers();
1133 if (dispatchers != null) {
1134 for (java.util.Iterator<KeyEventDispatcher> iter = dispatchers.iterator();
1135 iter.hasNext(); )
1136 {
1137 if (iter.next().
1138 dispatchKeyEvent(ke))
1139 {
1140 return true;
1141 }
1142 }
1143 }
1144 return dispatchKeyEvent(ke);
1145 }
1146
1147 /*
1148 * @param e is a KEY_PRESSED event that can be used
1149 * to track the next KEY_TYPED related.
1150 */
1151 private void consumeNextKeyTyped(KeyEvent e) {
1152 consumeNextKeyTyped = true;
1153 }
1154
1155 private void consumeTraversalKey(KeyEvent e) {
1156 e.consume();
1157 consumeNextKeyTyped = (e.getID() == KeyEvent.KEY_PRESSED) &&
1158 !e.isActionKey();
1159 }
1160
1161 /*
1162 * return true if event was consumed
1163 */
1164 private boolean consumeProcessedKeyEvent(KeyEvent e) {
1165 if ((e.getID() == KeyEvent.KEY_TYPED) && consumeNextKeyTyped) {
1166 e.consume();
1167 consumeNextKeyTyped = false;
1168 return true;
1169 }
1170 return false;
1171 }
1172
1173 /**
1174 * This method initiates a focus traversal operation if and only if the
1175 * KeyEvent represents a focus traversal key for the specified
1176 * focusedComponent. It is expected that focusedComponent is the current
1177 * focus owner, although this need not be the case. If it is not,
1178 * focus traversal will nevertheless proceed as if focusedComponent
1179 * were the focus owner.
1180 *
1181 * @param focusedComponent the Component that is the basis for a focus
1182 * traversal operation if the specified event represents a focus
1183 * traversal key for the Component
1184 * @param e the event that may represent a focus traversal key
1185 */
1186 public void processKeyEvent(Component focusedComponent, KeyEvent e) {
1187 // consume processed event if needed
1188 if (consumeProcessedKeyEvent(e)) {
1189 return;
1190 }
1191
1192 // KEY_TYPED events cannot be focus traversal keys
1193 if (e.getID() == KeyEvent.KEY_TYPED) {
1194 return;
1195 }
1196
1197 if (focusedComponent.getFocusTraversalKeysEnabled() &&
1198 !e.isConsumed())
1199 {
1200 AWTKeyStroke stroke = AWTKeyStroke.getAWTKeyStrokeForEvent(e),
1201 oppStroke = AWTKeyStroke.getAWTKeyStroke(stroke.getKeyCode(),
1202 stroke.getModifiers(),
1203 !stroke.isOnKeyRelease());
1204 Set<AWTKeyStroke> toTest;
1205 boolean contains, containsOpp;
1206
1207 toTest = focusedComponent.getFocusTraversalKeys(
1208 KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS);
1209 contains = toTest.contains(stroke);
1210 containsOpp = toTest.contains(oppStroke);
1211
1212 if (contains || containsOpp) {
1213 consumeTraversalKey(e);
1214 if (contains) {
1215 focusNextComponent(focusedComponent);
1216 }
1217 return;
1218 } else if (e.getID() == KeyEvent.KEY_PRESSED) {
1219 // Fix for 6637607: consumeNextKeyTyped should be reset.
1220 consumeNextKeyTyped = false;
1221 }
1222
1223 toTest = focusedComponent.getFocusTraversalKeys(
1224 KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS);
1225 contains = toTest.contains(stroke);
1226 containsOpp = toTest.contains(oppStroke);
1227
1228 if (contains || containsOpp) {
1229 consumeTraversalKey(e);
1230 if (contains) {
1231 focusPreviousComponent(focusedComponent);
1232 }
1233 return;
1234 }
1235
1236 toTest = focusedComponent.getFocusTraversalKeys(
1237 KeyboardFocusManager.UP_CYCLE_TRAVERSAL_KEYS);
1238 contains = toTest.contains(stroke);
1239 containsOpp = toTest.contains(oppStroke);
1240
1241 if (contains || containsOpp) {
1242 consumeTraversalKey(e);
1243 if (contains) {
1244 upFocusCycle(focusedComponent);
1245 }
1246 return;
1247 }
1248
1249 if (!((focusedComponent instanceof Container) &&
1250 ((Container)focusedComponent).isFocusCycleRoot())) {
1251 return;
1252 }
1253
1254 toTest = focusedComponent.getFocusTraversalKeys(
1255 KeyboardFocusManager.DOWN_CYCLE_TRAVERSAL_KEYS);
1256 contains = toTest.contains(stroke);
1257 containsOpp = toTest.contains(oppStroke);
1258
1259 if (contains || containsOpp) {
1260 consumeTraversalKey(e);
1261 if (contains) {
1262 downFocusCycle((Container)focusedComponent);
1263 }
1264 }
1265 }
1266 }
1267
1268 /**
1269 * Delays dispatching of KeyEvents until the specified Component becomes
1270 * the focus owner. KeyEvents with timestamps later than the specified
1271 * timestamp will be enqueued until the specified Component receives a
1272 * FOCUS_GAINED event, or the AWT cancels the delay request by invoking
1273 * {@code dequeueKeyEvents} or {@code discardKeyEvents}.
1274 *
1275 * @param after timestamp of current event, or the current, system time if
1276 * the current event has no timestamp, or the AWT cannot determine
1277 * which event is currently being handled
1278 * @param untilFocused Component which will receive a FOCUS_GAINED event
1279 * before any pending KeyEvents
1280 * @see #dequeueKeyEvents
1281 * @see #discardKeyEvents
1282 */
1283 protected synchronized void enqueueKeyEvents(long after,
1284 Component untilFocused) {
1285 if (untilFocused == null) {
1286 return;
1287 }
1288
1289 if (focusLog.isLoggable(PlatformLogger.Level.FINER)) {
1290 focusLog.finer("Enqueue at {0} for {1}",
1291 after, untilFocused);
1292 }
1293
1294 int insertionIndex = 0,
1295 i = typeAheadMarkers.size();
1296 ListIterator<TypeAheadMarker> iter = typeAheadMarkers.listIterator(i);
1297
1298 for (; i > 0; i--) {
1299 TypeAheadMarker marker = iter.previous();
1300 if (marker.after <= after) {
1301 insertionIndex = i;
1302 break;
1303 }
1304 }
1305
1306 typeAheadMarkers.add(insertionIndex,
1307 new TypeAheadMarker(after, untilFocused));
1308 }
1309
1310 /**
1311 * Releases for normal dispatching to the current focus owner all
1312 * KeyEvents which were enqueued because of a call to
1313 * {@code enqueueKeyEvents} with the same timestamp and Component.
1314 * If the given timestamp is less than zero, the outstanding enqueue
1315 * request for the given Component with the <b>oldest</b> timestamp (if
1316 * any) should be cancelled.
1317 *
1318 * @param after the timestamp specified in the call to
1319 * {@code enqueueKeyEvents}, or any value < 0
1320 * @param untilFocused the Component specified in the call to
1321 * {@code enqueueKeyEvents}
1322 * @see #enqueueKeyEvents
1323 * @see #discardKeyEvents
1324 */
1325 protected synchronized void dequeueKeyEvents(long after,
1326 Component untilFocused) {
1327 if (untilFocused == null) {
1328 return;
1329 }
1330
1331 if (focusLog.isLoggable(PlatformLogger.Level.FINER)) {
1332 focusLog.finer("Dequeue at {0} for {1}",
1333 after, untilFocused);
1334 }
1335
1336 TypeAheadMarker marker;
1337 ListIterator<TypeAheadMarker> iter = typeAheadMarkers.listIterator
1338 ((after >= 0) ? typeAheadMarkers.size() : 0);
1339
1340 if (after < 0) {
1341 while (iter.hasNext()) {
1342 marker = iter.next();
1343 if (marker.untilFocused == untilFocused)
1344 {
1345 iter.remove();
1346 return;
1347 }
1348 }
1349 } else {
1350 while (iter.hasPrevious()) {
1351 marker = iter.previous();
1352 if (marker.untilFocused == untilFocused &&
1353 marker.after == after)
1354 {
1355 iter.remove();
1356 return;
1357 }
1358 }
1359 }
1360 }
1361
1362 /**
1363 * Discards all KeyEvents which were enqueued because of one or more calls
1364 * to {@code enqueueKeyEvents} with the specified Component, or one of
1365 * its descendants.
1366 *
1367 * @param comp the Component specified in one or more calls to
1368 * {@code enqueueKeyEvents}, or a parent of such a Component
1369 * @see #enqueueKeyEvents
1370 * @see #dequeueKeyEvents
1371 */
1372 protected synchronized void discardKeyEvents(Component comp) {
1373 if (comp == null) {
1374 return;
1375 }
1376
1377 long start = -1;
1378
1379 for (Iterator<TypeAheadMarker> iter = typeAheadMarkers.iterator(); iter.hasNext(); ) {
1380 TypeAheadMarker marker = iter.next();
1381 Component toTest = marker.untilFocused;
1382 boolean match = (toTest == comp);
1383 while (!match && toTest != null && !(toTest instanceof Window)) {
1384 toTest = toTest.getParent();
1385 match = (toTest == comp);
1386 }
1387 if (match) {
1388 if (start < 0) {
1389 start = marker.after;
1390 }
1391 iter.remove();
1392 } else if (start >= 0) {
1393 purgeStampedEvents(start, marker.after);
1394 start = -1;
1395 }
1396 }
1397
1398 purgeStampedEvents(start, -1);
1399 }
1400
1401 // Notes:
1402 // * must be called inside a synchronized block
1403 // * if 'start' is < 0, then this function does nothing
1404 // * if 'end' is < 0, then all KeyEvents from 'start' to the end of the
1405 // queue will be removed
1406 private void purgeStampedEvents(long start, long end) {
1407 if (start < 0) {
1408 return;
1409 }
1410
1411 for (Iterator<KeyEvent> iter = enqueuedKeyEvents.iterator(); iter.hasNext(); ) {
1412 KeyEvent ke = iter.next();
1413 long time = ke.getWhen();
1414
1415 if (start < time && (end < 0 || time <= end)) {
1416 iter.remove();
1417 }
1418
1419 if (end >= 0 && time > end) {
1420 break;
1421 }
1422 }
1423 }
1424
1425 /**
1426 * Focuses the Component before aComponent, typically based on a
1427 * FocusTraversalPolicy.
1428 *
1429 * @param aComponent the Component that is the basis for the focus
1430 * traversal operation
1431 * @see FocusTraversalPolicy
1432 * @see Component#transferFocusBackward
1433 */
1434 public void focusPreviousComponent(Component aComponent) {
1435 if (aComponent != null) {
1436 aComponent.transferFocusBackward();
1437 }
1438 }
1439
1440 /**
1441 * Focuses the Component after aComponent, typically based on a
1442 * FocusTraversalPolicy.
1443 *
1444 * @param aComponent the Component that is the basis for the focus
1445 * traversal operation
1446 * @see FocusTraversalPolicy
1447 * @see Component#transferFocus
1448 */
1449 public void focusNextComponent(Component aComponent) {
1450 if (aComponent != null) {
1451 aComponent.transferFocus();
1452 }
1453 }
1454
1455 /**
1456 * Moves the focus up one focus traversal cycle. Typically, the focus owner
1457 * is set to aComponent's focus cycle root, and the current focus cycle
1458 * root is set to the new focus owner's focus cycle root. If, however,
1459 * aComponent's focus cycle root is a Window, then the focus owner is set
1460 * to the focus cycle root's default Component to focus, and the current
1461 * focus cycle root is unchanged.
1462 *
1463 * @param aComponent the Component that is the basis for the focus
1464 * traversal operation
1465 * @see Component#transferFocusUpCycle
1466 */
1467 public void upFocusCycle(Component aComponent) {
1468 if (aComponent != null) {
1469 aComponent.transferFocusUpCycle();
1470 }
1471 }
1472
1473 /**
1474 * Moves the focus down one focus traversal cycle. If aContainer is a focus
1475 * cycle root, then the focus owner is set to aContainer's default
1476 * Component to focus, and the current focus cycle root is set to
1477 * aContainer. If aContainer is not a focus cycle root, then no focus
1478 * traversal operation occurs.
1479 *
1480 * @param aContainer the Container that is the basis for the focus
1481 * traversal operation
1482 * @see Container#transferFocusDownCycle
1483 */
1484 public void downFocusCycle(Container aContainer) {
1485 if (aContainer != null && aContainer.isFocusCycleRoot()) {
1486 aContainer.transferFocusDownCycle();
1487 }
1488 }
1489 }