1 /*
   2  * Copyright (c) 2000, 2016, 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.util.LinkedList;
  34 import java.util.Iterator;
  35 import java.util.ListIterator;
  36 import java.util.Set;
  37 
  38 import sun.util.logging.PlatformLogger;
  39 
  40 import sun.awt.AppContext;
  41 import sun.awt.SunToolkit;
  42 import sun.awt.AWTAccessor;
  43 import sun.awt.TimedWindowEvent;
  44 
  45 /**
  46  * The default KeyboardFocusManager for AWT applications. Focus traversal is
  47  * done in response to a Component's focus traversal keys, and using a
  48  * Container's FocusTraversalPolicy.
  49  * <p>
  50  * Please see
  51  * <a href="http://docs.oracle.com/javase/tutorial/uiswing/misc/focus.html">
  52  * How to Use the Focus Subsystem</a>,
  53  * a section in <em>The Java Tutorial</em>, and the
  54  * <a href="../../java/awt/doc-files/FocusSpec.html">Focus Specification</a>
  55  * for more information.
  56  *
  57  * @author David Mendenhall
  58  *
  59  * @see FocusTraversalPolicy
  60  * @see Component#setFocusTraversalKeys
  61  * @see Component#getFocusTraversalKeys
  62  * @since 1.4
  63  */
  64 public class DefaultKeyboardFocusManager extends KeyboardFocusManager {
  65     private static final PlatformLogger focusLog = PlatformLogger.getLogger("java.awt.focus.DefaultKeyboardFocusManager");
  66 
  67     // null weak references to not create too many objects
  68     private static final WeakReference<Window> NULL_WINDOW_WR =
  69         new WeakReference<Window>(null);
  70     private static final WeakReference<Component> NULL_COMPONENT_WR =
  71         new WeakReference<Component>(null);
  72     private WeakReference<Window> realOppositeWindowWR = NULL_WINDOW_WR;
  73     private WeakReference<Component> realOppositeComponentWR = NULL_COMPONENT_WR;
  74     private int inSendMessage;
  75     private LinkedList<KeyEvent> enqueuedKeyEvents = new LinkedList<KeyEvent>();
  76     private LinkedList<TypeAheadMarker> typeAheadMarkers = new LinkedList<TypeAheadMarker>();
  77     private boolean consumeNextKeyTyped;
  78     private Component restoreFocusTo;
  79 
  80     static {
  81         AWTAccessor.setDefaultKeyboardFocusManagerAccessor(
  82             new AWTAccessor.DefaultKeyboardFocusManagerAccessor() {
  83                 public void consumeNextKeyTyped(DefaultKeyboardFocusManager dkfm, KeyEvent e) {
  84                     dkfm.consumeNextKeyTyped(e);
  85                 }
  86             });
  87     }
  88 
  89     private static class TypeAheadMarker {
  90         long after;
  91         Component untilFocused;
  92 
  93         TypeAheadMarker(long after, Component untilFocused) {
  94             this.after = after;
  95             this.untilFocused = untilFocused;
  96         }
  97         /**
  98          * Returns string representation of the marker
  99          */
 100         public String toString() {
 101             return ">>> Marker after " + after + " on " + untilFocused;
 102         }
 103     }
 104 
 105     private Window getOwningFrameDialog(Window window) {
 106         while (window != null && !(window instanceof Frame ||
 107                                    window instanceof Dialog)) {
 108             window = (Window)window.getParent();
 109         }
 110         return window;
 111     }
 112 
 113     /*
 114      * This series of restoreFocus methods is used for recovering from a
 115      * rejected focus or activation change. Rejections typically occur when
 116      * the user attempts to focus a non-focusable Component or Window.
 117      */
 118     private void restoreFocus(FocusEvent fe, Window newFocusedWindow) {
 119         Component realOppositeComponent = this.realOppositeComponentWR.get();
 120         Component vetoedComponent = fe.getComponent();
 121 
 122         if (newFocusedWindow != null && restoreFocus(newFocusedWindow,
 123                                                      vetoedComponent, false))
 124         {
 125         } else if (realOppositeComponent != null &&
 126                    doRestoreFocus(realOppositeComponent, vetoedComponent, false)) {
 127         } else if (fe.getOppositeComponent() != null &&
 128                    doRestoreFocus(fe.getOppositeComponent(), vetoedComponent, false)) {
 129         } else {
 130             clearGlobalFocusOwnerPriv();
 131         }
 132     }
 133     private void restoreFocus(WindowEvent we) {
 134         Window realOppositeWindow = this.realOppositeWindowWR.get();
 135         if (realOppositeWindow != null
 136             && restoreFocus(realOppositeWindow, null, false))
 137         {
 138             // do nothing, everything is done in restoreFocus()
 139         } else if (we.getOppositeWindow() != null &&
 140                    restoreFocus(we.getOppositeWindow(), null, false))
 141         {
 142             // do nothing, everything is done in restoreFocus()
 143         } else {
 144             clearGlobalFocusOwnerPriv();
 145         }
 146     }
 147     private boolean restoreFocus(Window aWindow, Component vetoedComponent,
 148                                  boolean clearOnFailure) {
 149         restoreFocusTo = null;
 150         Component toFocus =
 151             KeyboardFocusManager.getMostRecentFocusOwner(aWindow);
 152 
 153         if (toFocus != null && toFocus != vetoedComponent) {
 154             if (getHeavyweight(aWindow) != getNativeFocusOwner()) {
 155                 // cannot restore focus synchronously
 156                 if (!toFocus.isShowing() || !toFocus.canBeFocusOwner()) {
 157                     toFocus = toFocus.getNextFocusCandidate();
 158                 }
 159                 if (toFocus != null && toFocus != vetoedComponent) {
 160                     if (!toFocus.requestFocus(false,
 161                                                    FocusEvent.Cause.ROLLBACK)) {
 162                         restoreFocusTo = toFocus;
 163                     }
 164                     return true;
 165                 }
 166             } else if (doRestoreFocus(toFocus, vetoedComponent, false)) {
 167                 return true;
 168             }
 169         }
 170         if (clearOnFailure) {
 171             clearGlobalFocusOwnerPriv();
 172             return true;
 173         } else {
 174             return false;
 175         }
 176     }
 177     private boolean restoreFocus(Component toFocus, boolean clearOnFailure) {
 178         return doRestoreFocus(toFocus, null, clearOnFailure);
 179     }
 180     private boolean doRestoreFocus(Component toFocus, Component vetoedComponent,
 181                                    boolean clearOnFailure)
 182     {

 183         if (toFocus != vetoedComponent && toFocus.isShowing() && toFocus.canBeFocusOwner() &&
 184             toFocus.requestFocus(false, FocusEvent.Cause.ROLLBACK))
 185         {
 186             return true;
 187         } else {




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