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