1 /*
   2  * Copyright (c) 1996, 2014, 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 
  26 package java.awt;
  27 
  28 import java.awt.event.*;
  29 
  30 import java.awt.peer.ComponentPeer;
  31 
  32 import java.lang.ref.WeakReference;
  33 import java.lang.reflect.InvocationTargetException;
  34 
  35 import java.security.AccessController;
  36 import java.security.PrivilegedAction;
  37 
  38 import java.util.EmptyStackException;
  39 
  40 import sun.awt.*;
  41 import sun.awt.dnd.SunDropTargetEvent;
  42 import sun.util.logging.PlatformLogger;
  43 
  44 import java.util.concurrent.locks.Condition;
  45 import java.util.concurrent.locks.Lock;
  46 import java.util.concurrent.atomic.AtomicInteger;
  47 
  48 import java.security.AccessControlContext;
  49 
  50 import sun.misc.SharedSecrets;
  51 import sun.misc.JavaSecurityAccess;
  52 
  53 /**
  54  * <code>EventQueue</code> is a platform-independent class
  55  * that queues events, both from the underlying peer classes
  56  * and from trusted application classes.
  57  * <p>
  58  * It encapsulates asynchronous event dispatch machinery which
  59  * extracts events from the queue and dispatches them by calling
  60  * {@link #dispatchEvent(AWTEvent) dispatchEvent(AWTEvent)} method
  61  * on this <code>EventQueue</code> with the event to be dispatched
  62  * as an argument.  The particular behavior of this machinery is
  63  * implementation-dependent.  The only requirements are that events
  64  * which were actually enqueued to this queue (note that events
  65  * being posted to the <code>EventQueue</code> can be coalesced)
  66  * are dispatched:
  67  * <dl>
  68  *   <dt> Sequentially.
  69  *   <dd> That is, it is not permitted that several events from
  70  *        this queue are dispatched simultaneously.
  71  *   <dt> In the same order as they are enqueued.
  72  *   <dd> That is, if <code>AWTEvent</code>&nbsp;A is enqueued
  73  *        to the <code>EventQueue</code> before
  74  *        <code>AWTEvent</code>&nbsp;B then event B will not be
  75  *        dispatched before event A.
  76  * </dl>
  77  * <p>
  78  * Some browsers partition applets in different code bases into
  79  * separate contexts, and establish walls between these contexts.
  80  * In such a scenario, there will be one <code>EventQueue</code>
  81  * per context. Other browsers place all applets into the same
  82  * context, implying that there will be only a single, global
  83  * <code>EventQueue</code> for all applets. This behavior is
  84  * implementation-dependent.  Consult your browser's documentation
  85  * for more information.
  86  * <p>
  87  * For information on the threading issues of the event dispatch
  88  * machinery, see <a href="doc-files/AWTThreadIssues.html#Autoshutdown"
  89  * >AWT Threading Issues</a>.
  90  *
  91  * @author Thomas Ball
  92  * @author Fred Ecks
  93  * @author David Mendenhall
  94  *
  95  * @since       1.1
  96  */
  97 public class EventQueue {
  98     private static final AtomicInteger threadInitNumber = new AtomicInteger(0);
  99 
 100     private static final int LOW_PRIORITY = 0;
 101     private static final int NORM_PRIORITY = 1;
 102     private static final int HIGH_PRIORITY = 2;
 103     private static final int ULTIMATE_PRIORITY = 3;
 104 
 105     private static final int NUM_PRIORITIES = ULTIMATE_PRIORITY + 1;
 106 
 107     /*
 108      * We maintain one Queue for each priority that the EventQueue supports.
 109      * That is, the EventQueue object is actually implemented as
 110      * NUM_PRIORITIES queues and all Events on a particular internal Queue
 111      * have identical priority. Events are pulled off the EventQueue starting
 112      * with the Queue of highest priority. We progress in decreasing order
 113      * across all Queues.
 114      */
 115     private Queue[] queues = new Queue[NUM_PRIORITIES];
 116 
 117     /*
 118      * The next EventQueue on the stack, or null if this EventQueue is
 119      * on the top of the stack.  If nextQueue is non-null, requests to post
 120      * an event are forwarded to nextQueue.
 121      */
 122     private EventQueue nextQueue;
 123 
 124     /*
 125      * The previous EventQueue on the stack, or null if this is the
 126      * "base" EventQueue.
 127      */
 128     private EventQueue previousQueue;
 129 
 130     /*
 131      * A single lock to synchronize the push()/pop() and related operations with
 132      * all the EventQueues from the AppContext. Synchronization on any particular
 133      * event queue(s) is not enough: we should lock the whole stack.
 134      */
 135     private final Lock pushPopLock;
 136     private final Condition pushPopCond;
 137 
 138     /*
 139      * Dummy runnable to wake up EDT from getNextEvent() after
 140      push/pop is performed
 141      */
 142     private final static Runnable dummyRunnable = new Runnable() {
 143         public void run() {
 144         }
 145     };
 146 
 147     private EventDispatchThread dispatchThread;
 148 
 149     private final ThreadGroup threadGroup =
 150         Thread.currentThread().getThreadGroup();
 151     private final ClassLoader classLoader =
 152         Thread.currentThread().getContextClassLoader();
 153 
 154     /*
 155      * The time stamp of the last dispatched InputEvent or ActionEvent.
 156      */
 157     private long mostRecentEventTime = System.currentTimeMillis();
 158 
 159     /*
 160      * The time stamp of the last KeyEvent .
 161      */
 162     private long mostRecentKeyEventTime = System.currentTimeMillis();
 163 
 164     /**
 165      * The modifiers field of the current event, if the current event is an
 166      * InputEvent or ActionEvent.
 167      */
 168     private WeakReference<AWTEvent> currentEvent;
 169 
 170     /*
 171      * Non-zero if a thread is waiting in getNextEvent(int) for an event of
 172      * a particular ID to be posted to the queue.
 173      */
 174     private volatile int waitForID;
 175 
 176     /*
 177      * AppContext corresponding to the queue.
 178      */
 179     private final AppContext appContext;
 180 
 181     private final String name = "AWT-EventQueue-" + threadInitNumber.getAndIncrement();
 182 
 183     private FwDispatcher fwDispatcher;
 184 
 185     private static volatile PlatformLogger eventLog;
 186 
 187     private static final PlatformLogger getEventLog() {
 188         if(eventLog == null) {
 189             eventLog = PlatformLogger.getLogger("java.awt.event.EventQueue");
 190         }
 191         return eventLog;
 192     }
 193 
 194     static {
 195         AWTAccessor.setEventQueueAccessor(
 196             new AWTAccessor.EventQueueAccessor() {
 197                 public Thread getDispatchThread(EventQueue eventQueue) {
 198                     return eventQueue.getDispatchThread();
 199                 }
 200                 public boolean isDispatchThreadImpl(EventQueue eventQueue) {
 201                     return eventQueue.isDispatchThreadImpl();
 202                 }
 203                 public void removeSourceEvents(EventQueue eventQueue,
 204                                                Object source,
 205                                                boolean removeAllEvents)
 206                 {
 207                     eventQueue.removeSourceEvents(source, removeAllEvents);
 208                 }
 209                 public boolean noEvents(EventQueue eventQueue) {
 210                     return eventQueue.noEvents();
 211                 }
 212                 public void wakeup(EventQueue eventQueue, boolean isShutdown) {
 213                     eventQueue.wakeup(isShutdown);
 214                 }
 215                 public void invokeAndWait(Object source, Runnable r)
 216                     throws InterruptedException, InvocationTargetException
 217                 {
 218                     EventQueue.invokeAndWait(source, r);
 219                 }
 220                 public void setFwDispatcher(EventQueue eventQueue,
 221                                             FwDispatcher dispatcher) {
 222                     eventQueue.setFwDispatcher(dispatcher);
 223                 }
 224 
 225                 @Override
 226                 public long getMostRecentEventTime(EventQueue eventQueue) {
 227                     return eventQueue.getMostRecentEventTimeImpl();
 228                 }
 229             });
 230     }
 231 
 232     /**
 233      * Initializes a new instance of {@code EventQueue}.
 234      */
 235     public EventQueue() {
 236         for (int i = 0; i < NUM_PRIORITIES; i++) {
 237             queues[i] = new Queue();
 238         }
 239         /*
 240          * NOTE: if you ever have to start the associated event dispatch
 241          * thread at this point, be aware of the following problem:
 242          * If this EventQueue instance is created in
 243          * SunToolkit.createNewAppContext() the started dispatch thread
 244          * may call AppContext.getAppContext() before createNewAppContext()
 245          * completes thus causing mess in thread group to appcontext mapping.
 246          */
 247 
 248         appContext = AppContext.getAppContext();
 249         pushPopLock = (Lock)appContext.get(AppContext.EVENT_QUEUE_LOCK_KEY);
 250         pushPopCond = (Condition)appContext.get(AppContext.EVENT_QUEUE_COND_KEY);
 251     }
 252 
 253     /**
 254      * Posts a 1.1-style event to the <code>EventQueue</code>.
 255      * If there is an existing event on the queue with the same ID
 256      * and event source, the source <code>Component</code>'s
 257      * <code>coalesceEvents</code> method will be called.
 258      *
 259      * @param theEvent an instance of <code>java.awt.AWTEvent</code>,
 260      *          or a subclass of it
 261      * @throws NullPointerException if <code>theEvent</code> is <code>null</code>
 262      */
 263     public void postEvent(AWTEvent theEvent) {
 264         SunToolkit.flushPendingEvents(appContext);
 265         postEventPrivate(theEvent);
 266     }
 267 
 268     /**
 269      * Posts a 1.1-style event to the <code>EventQueue</code>.
 270      * If there is an existing event on the queue with the same ID
 271      * and event source, the source <code>Component</code>'s
 272      * <code>coalesceEvents</code> method will be called.
 273      *
 274      * @param theEvent an instance of <code>java.awt.AWTEvent</code>,
 275      *          or a subclass of it
 276      */
 277     private final void postEventPrivate(AWTEvent theEvent) {
 278         theEvent.isPosted = true;
 279         pushPopLock.lock();
 280         try {
 281             if (nextQueue != null) {
 282                 // Forward the event to the top of EventQueue stack
 283                 nextQueue.postEventPrivate(theEvent);
 284                 return;
 285             }
 286             if (dispatchThread == null) {
 287                 if (theEvent.getSource() == AWTAutoShutdown.getInstance()) {
 288                     return;
 289                 } else {
 290                     initDispatchThread();
 291                 }
 292             }
 293             postEvent(theEvent, getPriority(theEvent));
 294         } finally {
 295             pushPopLock.unlock();
 296         }
 297     }
 298 
 299     private static int getPriority(AWTEvent theEvent) {
 300         if (theEvent instanceof PeerEvent) {
 301             PeerEvent peerEvent = (PeerEvent)theEvent;
 302             if ((peerEvent.getFlags() & PeerEvent.ULTIMATE_PRIORITY_EVENT) != 0) {
 303                 return ULTIMATE_PRIORITY;
 304             }
 305             if ((peerEvent.getFlags() & PeerEvent.PRIORITY_EVENT) != 0) {
 306                 return HIGH_PRIORITY;
 307             }
 308             if ((peerEvent.getFlags() & PeerEvent.LOW_PRIORITY_EVENT) != 0) {
 309                 return LOW_PRIORITY;
 310             }
 311         }
 312         int id = theEvent.getID();
 313         if ((id >= PaintEvent.PAINT_FIRST) && (id <= PaintEvent.PAINT_LAST)) {
 314             return LOW_PRIORITY;
 315         }
 316         return NORM_PRIORITY;
 317     }
 318 
 319     /**
 320      * Posts the event to the internal Queue of specified priority,
 321      * coalescing as appropriate.
 322      *
 323      * @param theEvent an instance of <code>java.awt.AWTEvent</code>,
 324      *          or a subclass of it
 325      * @param priority  the desired priority of the event
 326      */
 327     private void postEvent(AWTEvent theEvent, int priority) {
 328         if (coalesceEvent(theEvent, priority)) {
 329             return;
 330         }
 331 
 332         EventQueueItem newItem = new EventQueueItem(theEvent);
 333 
 334         cacheEQItem(newItem);
 335 
 336         boolean notifyID = (theEvent.getID() == this.waitForID);
 337 
 338         if (queues[priority].head == null) {
 339             boolean shouldNotify = noEvents();
 340             queues[priority].head = queues[priority].tail = newItem;
 341 
 342             if (shouldNotify) {
 343                 if (theEvent.getSource() != AWTAutoShutdown.getInstance()) {
 344                     AWTAutoShutdown.getInstance().notifyThreadBusy(dispatchThread);
 345                 }
 346                 pushPopCond.signalAll();
 347             } else if (notifyID) {
 348                 pushPopCond.signalAll();
 349             }
 350         } else {
 351             // The event was not coalesced or has non-Component source.
 352             // Insert it at the end of the appropriate Queue.
 353             queues[priority].tail.next = newItem;
 354             queues[priority].tail = newItem;
 355             if (notifyID) {
 356                 pushPopCond.signalAll();
 357             }
 358         }
 359     }
 360 
 361     private boolean coalescePaintEvent(PaintEvent e) {
 362         ComponentPeer sourcePeer = ((Component)e.getSource()).peer;
 363         if (sourcePeer != null) {
 364             sourcePeer.coalescePaintEvent(e);
 365         }
 366         EventQueueItem[] cache = ((Component)e.getSource()).eventCache;
 367         if (cache == null) {
 368             return false;
 369         }
 370         int index = eventToCacheIndex(e);
 371 
 372         if (index != -1 && cache[index] != null) {
 373             PaintEvent merged = mergePaintEvents(e, (PaintEvent)cache[index].event);
 374             if (merged != null) {
 375                 cache[index].event = merged;
 376                 return true;
 377             }
 378         }
 379         return false;
 380     }
 381 
 382     private PaintEvent mergePaintEvents(PaintEvent a, PaintEvent b) {
 383         Rectangle aRect = a.getUpdateRect();
 384         Rectangle bRect = b.getUpdateRect();
 385         if (bRect.contains(aRect)) {
 386             return b;
 387         }
 388         if (aRect.contains(bRect)) {
 389             return a;
 390         }
 391         return null;
 392     }
 393 
 394     private boolean coalesceMouseEvent(MouseEvent e) {
 395         EventQueueItem[] cache = ((Component)e.getSource()).eventCache;
 396         if (cache == null) {
 397             return false;
 398         }
 399         int index = eventToCacheIndex(e);
 400         if (index != -1 && cache[index] != null) {
 401             cache[index].event = e;
 402             return true;
 403         }
 404         return false;
 405     }
 406 
 407     private boolean coalescePeerEvent(PeerEvent e) {
 408         EventQueueItem[] cache = ((Component)e.getSource()).eventCache;
 409         if (cache == null) {
 410             return false;
 411         }
 412         int index = eventToCacheIndex(e);
 413         if (index != -1 && cache[index] != null) {
 414             e = e.coalesceEvents((PeerEvent)cache[index].event);
 415             if (e != null) {
 416                 cache[index].event = e;
 417                 return true;
 418             } else {
 419                 cache[index] = null;
 420             }
 421         }
 422         return false;
 423     }
 424 
 425     /*
 426      * Should avoid of calling this method by any means
 427      * as it's working time is dependant on EQ length.
 428      * In the worst case this method alone can slow down the entire application
 429      * 10 times by stalling the Event processing.
 430      * Only here by backward compatibility reasons.
 431      */
 432     private boolean coalesceOtherEvent(AWTEvent e, int priority) {
 433         int id = e.getID();
 434         Component source = (Component)e.getSource();
 435         for (EventQueueItem entry = queues[priority].head;
 436             entry != null; entry = entry.next)
 437         {
 438             // Give Component.coalesceEvents a chance
 439             if (entry.event.getSource() == source && entry.event.getID() == id) {
 440                 AWTEvent coalescedEvent = source.coalesceEvents(
 441                     entry.event, e);
 442                 if (coalescedEvent != null) {
 443                     entry.event = coalescedEvent;
 444                     return true;
 445                 }
 446             }
 447         }
 448         return false;
 449     }
 450 
 451     private boolean coalesceEvent(AWTEvent e, int priority) {
 452         if (!(e.getSource() instanceof Component)) {
 453             return false;
 454         }
 455         if (e instanceof PeerEvent) {
 456             return coalescePeerEvent((PeerEvent)e);
 457         }
 458         // The worst case
 459         if (((Component)e.getSource()).isCoalescingEnabled()
 460             && coalesceOtherEvent(e, priority))
 461         {
 462             return true;
 463         }
 464         if (e instanceof PaintEvent) {
 465             return coalescePaintEvent((PaintEvent)e);
 466         }
 467         if (e instanceof MouseEvent) {
 468             return coalesceMouseEvent((MouseEvent)e);
 469         }
 470         return false;
 471     }
 472 
 473     private void cacheEQItem(EventQueueItem entry) {
 474         int index = eventToCacheIndex(entry.event);
 475         if (index != -1 && entry.event.getSource() instanceof Component) {
 476             Component source = (Component)entry.event.getSource();
 477             if (source.eventCache == null) {
 478                 source.eventCache = new EventQueueItem[CACHE_LENGTH];
 479             }
 480             source.eventCache[index] = entry;
 481         }
 482     }
 483 
 484     private void uncacheEQItem(EventQueueItem entry) {
 485         int index = eventToCacheIndex(entry.event);
 486         if (index != -1 && entry.event.getSource() instanceof Component) {
 487             Component source = (Component)entry.event.getSource();
 488             if (source.eventCache == null) {
 489                 return;
 490             }
 491             source.eventCache[index] = null;
 492         }
 493     }
 494 
 495     private static final int PAINT = 0;
 496     private static final int UPDATE = 1;
 497     private static final int MOVE = 2;
 498     private static final int DRAG = 3;
 499     private static final int PEER = 4;
 500     private static final int CACHE_LENGTH = 5;
 501 
 502     private static int eventToCacheIndex(AWTEvent e) {
 503         switch(e.getID()) {
 504         case PaintEvent.PAINT:
 505             return PAINT;
 506         case PaintEvent.UPDATE:
 507             return UPDATE;
 508         case MouseEvent.MOUSE_MOVED:
 509             return MOVE;
 510         case MouseEvent.MOUSE_DRAGGED:
 511             // Return -1 for SunDropTargetEvent since they are usually synchronous
 512             // and we don't want to skip them by coalescing with MouseEvent or other drag events
 513             return e instanceof SunDropTargetEvent ? -1 : DRAG;
 514         default:
 515             return e instanceof PeerEvent ? PEER : -1;
 516         }
 517     }
 518 
 519     /**
 520      * Returns whether an event is pending on any of the separate
 521      * Queues.
 522      * @return whether an event is pending on any of the separate Queues
 523      */
 524     private boolean noEvents() {
 525         for (int i = 0; i < NUM_PRIORITIES; i++) {
 526             if (queues[i].head != null) {
 527                 return false;
 528             }
 529         }
 530 
 531         return true;
 532     }
 533 
 534     /**
 535      * Removes an event from the <code>EventQueue</code> and
 536      * returns it.  This method will block until an event has
 537      * been posted by another thread.
 538      * @return the next <code>AWTEvent</code>
 539      * @exception InterruptedException
 540      *            if any thread has interrupted this thread
 541      */
 542     public AWTEvent getNextEvent() throws InterruptedException {
 543         do {
 544             /*
 545              * SunToolkit.flushPendingEvents must be called outside
 546              * of the synchronized block to avoid deadlock when
 547              * event queues are nested with push()/pop().
 548              */
 549             SunToolkit.flushPendingEvents(appContext);
 550             pushPopLock.lock();
 551             try {
 552                 AWTEvent event = getNextEventPrivate();
 553                 if (event != null) {
 554                     return event;
 555                 }
 556                 AWTAutoShutdown.getInstance().notifyThreadFree(dispatchThread);
 557                 pushPopCond.await();
 558             } finally {
 559                 pushPopLock.unlock();
 560             }
 561         } while(true);
 562     }
 563 
 564     /*
 565      * Must be called under the lock. Doesn't call flushPendingEvents()
 566      */
 567     AWTEvent getNextEventPrivate() throws InterruptedException {
 568         for (int i = NUM_PRIORITIES - 1; i >= 0; i--) {
 569             if (queues[i].head != null) {
 570                 EventQueueItem entry = queues[i].head;
 571                 queues[i].head = entry.next;
 572                 if (entry.next == null) {
 573                     queues[i].tail = null;
 574                 }
 575                 uncacheEQItem(entry);
 576                 return entry.event;
 577             }
 578         }
 579         return null;
 580     }
 581 
 582     AWTEvent getNextEvent(int id) throws InterruptedException {
 583         do {
 584             /*
 585              * SunToolkit.flushPendingEvents must be called outside
 586              * of the synchronized block to avoid deadlock when
 587              * event queues are nested with push()/pop().
 588              */
 589             SunToolkit.flushPendingEvents(appContext);
 590             pushPopLock.lock();
 591             try {
 592                 for (int i = 0; i < NUM_PRIORITIES; i++) {
 593                     for (EventQueueItem entry = queues[i].head, prev = null;
 594                          entry != null; prev = entry, entry = entry.next)
 595                     {
 596                         if (entry.event.getID() == id) {
 597                             if (prev == null) {
 598                                 queues[i].head = entry.next;
 599                             } else {
 600                                 prev.next = entry.next;
 601                             }
 602                             if (queues[i].tail == entry) {
 603                                 queues[i].tail = prev;
 604                             }
 605                             uncacheEQItem(entry);
 606                             return entry.event;
 607                         }
 608                     }
 609                 }
 610                 waitForID = id;
 611                 pushPopCond.await();
 612                 waitForID = 0;
 613             } finally {
 614                 pushPopLock.unlock();
 615             }
 616         } while(true);
 617     }
 618 
 619     /**
 620      * Returns the first event on the <code>EventQueue</code>
 621      * without removing it.
 622      * @return the first event
 623      */
 624     public AWTEvent peekEvent() {
 625         pushPopLock.lock();
 626         try {
 627             for (int i = NUM_PRIORITIES - 1; i >= 0; i--) {
 628                 if (queues[i].head != null) {
 629                     return queues[i].head.event;
 630                 }
 631             }
 632         } finally {
 633             pushPopLock.unlock();
 634         }
 635 
 636         return null;
 637     }
 638 
 639     /**
 640      * Returns the first event with the specified id, if any.
 641      * @param id the id of the type of event desired
 642      * @return the first event of the specified id or <code>null</code>
 643      *    if there is no such event
 644      */
 645     public AWTEvent peekEvent(int id) {
 646         pushPopLock.lock();
 647         try {
 648             for (int i = NUM_PRIORITIES - 1; i >= 0; i--) {
 649                 EventQueueItem q = queues[i].head;
 650                 for (; q != null; q = q.next) {
 651                     if (q.event.getID() == id) {
 652                         return q.event;
 653                     }
 654                 }
 655             }
 656         } finally {
 657             pushPopLock.unlock();
 658         }
 659 
 660         return null;
 661     }
 662 
 663     private static final JavaSecurityAccess javaSecurityAccess =
 664         SharedSecrets.getJavaSecurityAccess();
 665 
 666     /**
 667      * Dispatches an event. The manner in which the event is
 668      * dispatched depends upon the type of the event and the
 669      * type of the event's source object:
 670      *
 671      * <table border=1 summary="Event types, source types, and dispatch methods">
 672      * <tr>
 673      *     <th>Event Type</th>
 674      *     <th>Source Type</th>
 675      *     <th>Dispatched To</th>
 676      * </tr>
 677      * <tr>
 678      *     <td>ActiveEvent</td>
 679      *     <td>Any</td>
 680      *     <td>event.dispatch()</td>
 681      * </tr>
 682      * <tr>
 683      *     <td>Other</td>
 684      *     <td>Component</td>
 685      *     <td>source.dispatchEvent(AWTEvent)</td>
 686      * </tr>
 687      * <tr>
 688      *     <td>Other</td>
 689      *     <td>MenuComponent</td>
 690      *     <td>source.dispatchEvent(AWTEvent)</td>
 691      * </tr>
 692      * <tr>
 693      *     <td>Other</td>
 694      *     <td>Other</td>
 695      *     <td>No action (ignored)</td>
 696      * </tr>
 697      * </table>
 698      *
 699      * @param event an instance of <code>java.awt.AWTEvent</code>,
 700      *          or a subclass of it
 701      * @throws NullPointerException if <code>event</code> is <code>null</code>
 702      * @since           1.2
 703      */
 704     protected void dispatchEvent(final AWTEvent event) {
 705         final Object src = event.getSource();
 706         final PrivilegedAction<Void> action = new PrivilegedAction<Void>() {
 707             public Void run() {
 708                 // In case fwDispatcher is installed and we're already on the
 709                 // dispatch thread (e.g. performing DefaultKeyboardFocusManager.sendMessage),
 710                 // dispatch the event straight away.
 711                 if (fwDispatcher == null || isDispatchThreadImpl()) {
 712                     dispatchEventImpl(event, src);
 713                 } else {
 714                     fwDispatcher.scheduleDispatch(new Runnable() {
 715                         @Override
 716                         public void run() {
 717                             dispatchEventImpl(event, src);
 718                         }
 719                     });
 720                 }
 721                 return null;
 722             }
 723         };
 724 
 725         final AccessControlContext stack = AccessController.getContext();
 726         final AccessControlContext srcAcc = getAccessControlContextFrom(src);
 727         final AccessControlContext eventAcc = event.getAccessControlContext();
 728         if (srcAcc == null) {
 729             javaSecurityAccess.doIntersectionPrivilege(action, stack, eventAcc);
 730         } else {
 731             javaSecurityAccess.doIntersectionPrivilege(
 732                 new PrivilegedAction<Void>() {
 733                     public Void run() {
 734                         javaSecurityAccess.doIntersectionPrivilege(action, eventAcc);
 735                         return null;
 736                     }
 737                 }, stack, srcAcc);
 738         }
 739     }
 740 
 741     private static AccessControlContext getAccessControlContextFrom(Object src) {
 742         return src instanceof Component ?
 743             ((Component)src).getAccessControlContext() :
 744             src instanceof MenuComponent ?
 745                 ((MenuComponent)src).getAccessControlContext() :
 746                 src instanceof TrayIcon ?
 747                     ((TrayIcon)src).getAccessControlContext() :
 748                     null;
 749     }
 750 
 751     /**
 752      * Called from dispatchEvent() under a correct AccessControlContext
 753      */
 754     private void dispatchEventImpl(final AWTEvent event, final Object src) {
 755         event.isPosted = true;
 756         if (event instanceof ActiveEvent) {
 757             // This could become the sole method of dispatching in time.
 758             setCurrentEventAndMostRecentTimeImpl(event);
 759             ((ActiveEvent)event).dispatch();
 760         } else if (src instanceof Component) {
 761             ((Component)src).dispatchEvent(event);
 762             event.dispatched();
 763         } else if (src instanceof MenuComponent) {
 764             ((MenuComponent)src).dispatchEvent(event);
 765         } else if (src instanceof TrayIcon) {
 766             ((TrayIcon)src).dispatchEvent(event);
 767         } else if (src instanceof AWTAutoShutdown) {
 768             if (noEvents()) {
 769                 dispatchThread.stopDispatching();
 770             }
 771         } else {
 772             if (getEventLog().isLoggable(PlatformLogger.Level.FINE)) {
 773                 getEventLog().fine("Unable to dispatch event: " + event);
 774             }
 775         }
 776     }
 777 
 778     /**
 779      * Returns the timestamp of the most recent event that had a timestamp, and
 780      * that was dispatched from the <code>EventQueue</code> associated with the
 781      * calling thread. If an event with a timestamp is currently being
 782      * dispatched, its timestamp will be returned. If no events have yet
 783      * been dispatched, the EventQueue's initialization time will be
 784      * returned instead.In the current version of
 785      * the JDK, only <code>InputEvent</code>s,
 786      * <code>ActionEvent</code>s, and <code>InvocationEvent</code>s have
 787      * timestamps; however, future versions of the JDK may add timestamps to
 788      * additional event types. Note that this method should only be invoked
 789      * from an application's {@link #isDispatchThread event dispatching thread}.
 790      * If this method is
 791      * invoked from another thread, the current system time (as reported by
 792      * <code>System.currentTimeMillis()</code>) will be returned instead.
 793      *
 794      * @return the timestamp of the last <code>InputEvent</code>,
 795      *         <code>ActionEvent</code>, or <code>InvocationEvent</code> to be
 796      *         dispatched, or <code>System.currentTimeMillis()</code> if this
 797      *         method is invoked on a thread other than an event dispatching
 798      *         thread
 799      * @see java.awt.event.InputEvent#getWhen
 800      * @see java.awt.event.ActionEvent#getWhen
 801      * @see java.awt.event.InvocationEvent#getWhen
 802      * @see #isDispatchThread
 803      *
 804      * @since 1.4
 805      */
 806     public static long getMostRecentEventTime() {
 807         return Toolkit.getEventQueue().getMostRecentEventTimeImpl();
 808     }
 809     private long getMostRecentEventTimeImpl() {
 810         pushPopLock.lock();
 811         try {
 812             return (Thread.currentThread() == dispatchThread)
 813                 ? mostRecentEventTime
 814                 : System.currentTimeMillis();
 815         } finally {
 816             pushPopLock.unlock();
 817         }
 818     }
 819 
 820     /**
 821      * @return most recent event time on all threads.
 822      */
 823     long getMostRecentEventTimeEx() {
 824         pushPopLock.lock();
 825         try {
 826             return mostRecentEventTime;
 827         } finally {
 828             pushPopLock.unlock();
 829         }
 830     }
 831 
 832     /**
 833      * Returns the event currently being dispatched by the
 834      * <code>EventQueue</code> associated with the calling thread. This is
 835      * useful if a method needs access to the event, but was not designed to
 836      * receive a reference to it as an argument. Note that this method should
 837      * only be invoked from an application's event dispatching thread. If this
 838      * method is invoked from another thread, null will be returned.
 839      *
 840      * @return the event currently being dispatched, or null if this method is
 841      *         invoked on a thread other than an event dispatching thread
 842      * @since 1.4
 843      */
 844     public static AWTEvent getCurrentEvent() {
 845         return Toolkit.getEventQueue().getCurrentEventImpl();
 846     }
 847     private AWTEvent getCurrentEventImpl() {
 848         pushPopLock.lock();
 849         try {
 850                 return (Thread.currentThread() == dispatchThread)
 851                 ? currentEvent.get()
 852                 : null;
 853         } finally {
 854             pushPopLock.unlock();
 855         }
 856     }
 857 
 858     /**
 859      * Replaces the existing <code>EventQueue</code> with the specified one.
 860      * Any pending events are transferred to the new <code>EventQueue</code>
 861      * for processing by it.
 862      *
 863      * @param newEventQueue an <code>EventQueue</code>
 864      *          (or subclass thereof) instance to be use
 865      * @see      java.awt.EventQueue#pop
 866      * @throws NullPointerException if <code>newEventQueue</code> is <code>null</code>
 867      * @since           1.2
 868      */
 869     public void push(EventQueue newEventQueue) {
 870         if (getEventLog().isLoggable(PlatformLogger.Level.FINE)) {
 871             getEventLog().fine("EventQueue.push(" + newEventQueue + ")");
 872         }
 873 
 874         pushPopLock.lock();
 875         try {
 876             EventQueue topQueue = this;
 877             while (topQueue.nextQueue != null) {
 878                 topQueue = topQueue.nextQueue;
 879             }
 880             if (topQueue.fwDispatcher != null) {
 881                 throw new RuntimeException("push() to queue with fwDispatcher");
 882             }
 883             if ((topQueue.dispatchThread != null) &&
 884                 (topQueue.dispatchThread.getEventQueue() == this))
 885             {
 886                 newEventQueue.dispatchThread = topQueue.dispatchThread;
 887                 topQueue.dispatchThread.setEventQueue(newEventQueue);
 888             }
 889 
 890             // Transfer all events forward to new EventQueue.
 891             while (topQueue.peekEvent() != null) {
 892                 try {
 893                     // Use getNextEventPrivate() as it doesn't call flushPendingEvents()
 894                     newEventQueue.postEventPrivate(topQueue.getNextEventPrivate());
 895                 } catch (InterruptedException ie) {
 896                     if (getEventLog().isLoggable(PlatformLogger.Level.FINE)) {
 897                         getEventLog().fine("Interrupted push", ie);
 898                     }
 899                 }
 900             }
 901 

 902             // Wake up EDT waiting in getNextEvent(), so it can
 903             // pick up a new EventQueue. Post the waking event before
 904             // topQueue.nextQueue is assigned, otherwise the event would
 905             // go newEventQueue
 906             topQueue.postEventPrivate(new InvocationEvent(topQueue, dummyRunnable));

 907 
 908             newEventQueue.previousQueue = topQueue;
 909             topQueue.nextQueue = newEventQueue;
 910 
 911             if (appContext.get(AppContext.EVENT_QUEUE_KEY) == topQueue) {
 912                 appContext.put(AppContext.EVENT_QUEUE_KEY, newEventQueue);
 913             }
 914 
 915             pushPopCond.signalAll();
 916         } finally {
 917             pushPopLock.unlock();
 918         }
 919     }
 920 
 921     /**
 922      * Stops dispatching events using this <code>EventQueue</code>.
 923      * Any pending events are transferred to the previous
 924      * <code>EventQueue</code> for processing.
 925      * <p>
 926      * Warning: To avoid deadlock, do not declare this method
 927      * synchronized in a subclass.
 928      *
 929      * @exception EmptyStackException if no previous push was made
 930      *  on this <code>EventQueue</code>
 931      * @see      java.awt.EventQueue#push
 932      * @since           1.2
 933      */
 934     protected void pop() throws EmptyStackException {
 935         if (getEventLog().isLoggable(PlatformLogger.Level.FINE)) {
 936             getEventLog().fine("EventQueue.pop(" + this + ")");
 937         }
 938 
 939         pushPopLock.lock();
 940         try {
 941             EventQueue topQueue = this;
 942             while (topQueue.nextQueue != null) {
 943                 topQueue = topQueue.nextQueue;
 944             }
 945             EventQueue prevQueue = topQueue.previousQueue;
 946             if (prevQueue == null) {
 947                 throw new EmptyStackException();
 948             }
 949 
 950             topQueue.previousQueue = null;
 951             prevQueue.nextQueue = null;
 952 
 953             // Transfer all events back to previous EventQueue.
 954             while (topQueue.peekEvent() != null) {
 955                 try {
 956                     prevQueue.postEventPrivate(topQueue.getNextEventPrivate());
 957                 } catch (InterruptedException ie) {
 958                     if (getEventLog().isLoggable(PlatformLogger.Level.FINE)) {
 959                         getEventLog().fine("Interrupted pop", ie);
 960                     }
 961                 }
 962             }
 963 
 964             if ((topQueue.dispatchThread != null) &&
 965                 (topQueue.dispatchThread.getEventQueue() == this))
 966             {
 967                 prevQueue.dispatchThread = topQueue.dispatchThread;
 968                 topQueue.dispatchThread.setEventQueue(prevQueue);
 969             }
 970 
 971             if (appContext.get(AppContext.EVENT_QUEUE_KEY) == this) {
 972                 appContext.put(AppContext.EVENT_QUEUE_KEY, prevQueue);
 973             }
 974 
 975             // Wake up EDT waiting in getNextEvent(), so it can
 976             // pick up a new EventQueue
 977             topQueue.postEventPrivate(new InvocationEvent(topQueue, dummyRunnable));
 978 
 979             pushPopCond.signalAll();
 980         } finally {
 981             pushPopLock.unlock();
 982         }
 983     }
 984 
 985     /**
 986      * Creates a new {@code secondary loop} associated with this
 987      * event queue. Use the {@link SecondaryLoop#enter} and
 988      * {@link SecondaryLoop#exit} methods to start and stop the
 989      * event loop and dispatch the events from this queue.
 990      *
 991      * @return secondaryLoop A new secondary loop object, which can
 992      *                       be used to launch a new nested event
 993      *                       loop and dispatch events from this queue
 994      *
 995      * @see SecondaryLoop#enter
 996      * @see SecondaryLoop#exit
 997      *
 998      * @since 1.7
 999      */
1000     public SecondaryLoop createSecondaryLoop() {
1001         return createSecondaryLoop(null, null, 0);
1002     }
1003 
1004     SecondaryLoop createSecondaryLoop(Conditional cond, EventFilter filter, long interval) {
1005         pushPopLock.lock();
1006         try {
1007             if (nextQueue != null) {
1008                 // Forward the request to the top of EventQueue stack
1009                 return nextQueue.createSecondaryLoop(cond, filter, interval);
1010             }
1011             if (fwDispatcher != null) {
1012                 return fwDispatcher.createSecondaryLoop();
1013             }
1014             if (dispatchThread == null) {
1015                 initDispatchThread();
1016             }
1017             return new WaitDispatchSupport(dispatchThread, cond, filter, interval);
1018         } finally {
1019             pushPopLock.unlock();
1020         }
1021     }
1022 
1023     /**
1024      * Returns true if the calling thread is
1025      * {@link Toolkit#getSystemEventQueue the current AWT EventQueue}'s
1026      * dispatch thread. Use this method to ensure that a particular
1027      * task is being executed (or not being) there.
1028      * <p>
1029      * Note: use the {@link #invokeLater} or {@link #invokeAndWait}
1030      * methods to execute a task in
1031      * {@link Toolkit#getSystemEventQueue the current AWT EventQueue}'s
1032      * dispatch thread.
1033      *
1034      * @return true if running in
1035      * {@link Toolkit#getSystemEventQueue the current AWT EventQueue}'s
1036      * dispatch thread
1037      * @see             #invokeLater
1038      * @see             #invokeAndWait
1039      * @see             Toolkit#getSystemEventQueue
1040      * @since           1.2
1041      */
1042     public static boolean isDispatchThread() {
1043         EventQueue eq = Toolkit.getEventQueue();
1044         return eq.isDispatchThreadImpl();
1045     }
1046 
1047     final boolean isDispatchThreadImpl() {
1048         EventQueue eq = this;
1049         pushPopLock.lock();
1050         try {
1051             EventQueue next = eq.nextQueue;
1052             while (next != null) {
1053                 eq = next;
1054                 next = eq.nextQueue;
1055             }
1056             if (eq.fwDispatcher != null) {
1057                 return eq.fwDispatcher.isDispatchThread();
1058             }
1059             return (Thread.currentThread() == eq.dispatchThread);
1060         } finally {
1061             pushPopLock.unlock();
1062         }
1063     }
1064 
1065     final void initDispatchThread() {
1066         pushPopLock.lock();
1067         try {
1068             if (dispatchThread == null && !threadGroup.isDestroyed() && !appContext.isDisposed()) {
1069                 dispatchThread = AccessController.doPrivileged(
1070                     new PrivilegedAction<EventDispatchThread>() {
1071                         public EventDispatchThread run() {
1072                             EventDispatchThread t =
1073                                 new EventDispatchThread(threadGroup,
1074                                                         name,
1075                                                         EventQueue.this);
1076                             t.setContextClassLoader(classLoader);
1077                             t.setPriority(Thread.NORM_PRIORITY + 1);
1078                             t.setDaemon(false);
1079                             AWTAutoShutdown.getInstance().notifyThreadBusy(t);
1080                             return t;
1081                         }
1082                     }
1083                 );
1084                 dispatchThread.start();
1085             }
1086         } finally {
1087             pushPopLock.unlock();
1088         }
1089     }
1090 
1091     final void detachDispatchThread(EventDispatchThread edt) {
1092         /*
1093          * Minimize discard possibility for non-posted events
1094          */
1095         SunToolkit.flushPendingEvents(appContext);
1096         /*
1097          * This synchronized block is to secure that the event dispatch
1098          * thread won't die in the middle of posting a new event to the
1099          * associated event queue. It is important because we notify
1100          * that the event dispatch thread is busy after posting a new event
1101          * to its queue, so the EventQueue.dispatchThread reference must
1102          * be valid at that point.
1103          */
1104         pushPopLock.lock();
1105         try {
1106             if (edt == dispatchThread) {
1107                 dispatchThread = null;
1108             }
1109             AWTAutoShutdown.getInstance().notifyThreadFree(edt);
1110             /*
1111              * Event was posted after EDT events pumping had stopped, so start
1112              * another EDT to handle this event
1113              */
1114             if (peekEvent() != null) {
1115                 initDispatchThread();
1116             }
1117         } finally {
1118             pushPopLock.unlock();
1119         }
1120     }
1121 
1122     /*
1123      * Gets the <code>EventDispatchThread</code> for this
1124      * <code>EventQueue</code>.
1125      * @return the event dispatch thread associated with this event queue
1126      *         or <code>null</code> if this event queue doesn't have a
1127      *         working thread associated with it
1128      * @see    java.awt.EventQueue#initDispatchThread
1129      * @see    java.awt.EventQueue#detachDispatchThread
1130      */
1131     final EventDispatchThread getDispatchThread() {
1132         pushPopLock.lock();
1133         try {
1134             return dispatchThread;
1135         } finally {
1136             pushPopLock.unlock();
1137         }
1138     }
1139 
1140     /*
1141      * Removes any pending events for the specified source object.
1142      * If removeAllEvents parameter is <code>true</code> then all
1143      * events for the specified source object are removed, if it
1144      * is <code>false</code> then <code>SequencedEvent</code>, <code>SentEvent</code>,
1145      * <code>FocusEvent</code>, <code>WindowEvent</code>, <code>KeyEvent</code>,
1146      * and <code>InputMethodEvent</code> are kept in the queue, but all other
1147      * events are removed.
1148      *
1149      * This method is normally called by the source's
1150      * <code>removeNotify</code> method.
1151      */
1152     final void removeSourceEvents(Object source, boolean removeAllEvents) {
1153         SunToolkit.flushPendingEvents(appContext);
1154         pushPopLock.lock();
1155         try {
1156             for (int i = 0; i < NUM_PRIORITIES; i++) {
1157                 EventQueueItem entry = queues[i].head;
1158                 EventQueueItem prev = null;
1159                 while (entry != null) {
1160                     if ((entry.event.getSource() == source)
1161                         && (removeAllEvents
1162                             || ! (entry.event instanceof SequencedEvent
1163                                   || entry.event instanceof SentEvent
1164                                   || entry.event instanceof FocusEvent
1165                                   || entry.event instanceof WindowEvent
1166                                   || entry.event instanceof KeyEvent
1167                                   || entry.event instanceof InputMethodEvent)))
1168                     {
1169                         if (entry.event instanceof SequencedEvent) {
1170                             ((SequencedEvent)entry.event).dispose();
1171                         }
1172                         if (entry.event instanceof SentEvent) {
1173                             ((SentEvent)entry.event).dispose();
1174                         }
1175                         if (entry.event instanceof InvocationEvent) {
1176                             AWTAccessor.getInvocationEventAccessor()
1177                                     .dispose((InvocationEvent)entry.event);
1178                         }
1179                         if (prev == null) {
1180                             queues[i].head = entry.next;
1181                         } else {
1182                             prev.next = entry.next;
1183                         }
1184                         uncacheEQItem(entry);
1185                     } else {
1186                         prev = entry;
1187                     }
1188                     entry = entry.next;
1189                 }
1190                 queues[i].tail = prev;
1191             }
1192         } finally {
1193             pushPopLock.unlock();
1194         }
1195     }
1196 
1197     synchronized long getMostRecentKeyEventTime() {
1198         pushPopLock.lock();
1199         try {
1200             return mostRecentKeyEventTime;
1201         } finally {
1202             pushPopLock.unlock();
1203         }
1204     }
1205 
1206     static void setCurrentEventAndMostRecentTime(AWTEvent e) {
1207         Toolkit.getEventQueue().setCurrentEventAndMostRecentTimeImpl(e);
1208     }
1209     private void setCurrentEventAndMostRecentTimeImpl(AWTEvent e) {
1210         pushPopLock.lock();
1211         try {
1212             if (Thread.currentThread() != dispatchThread) {
1213                 return;
1214             }
1215 
1216             currentEvent = new WeakReference<>(e);
1217 
1218             // This series of 'instanceof' checks should be replaced with a
1219             // polymorphic type (for example, an interface which declares a
1220             // getWhen() method). However, this would require us to make such
1221             // a type public, or to place it in sun.awt. Both of these approaches
1222             // have been frowned upon. So for now, we hack.
1223             //
1224             // In tiger, we will probably give timestamps to all events, so this
1225             // will no longer be an issue.
1226             long mostRecentEventTime2 = Long.MIN_VALUE;
1227             if (e instanceof InputEvent) {
1228                 InputEvent ie = (InputEvent)e;
1229                 mostRecentEventTime2 = ie.getWhen();
1230                 if (e instanceof KeyEvent) {
1231                     mostRecentKeyEventTime = ie.getWhen();
1232                 }
1233             } else if (e instanceof InputMethodEvent) {
1234                 InputMethodEvent ime = (InputMethodEvent)e;
1235                 mostRecentEventTime2 = ime.getWhen();
1236             } else if (e instanceof ActionEvent) {
1237                 ActionEvent ae = (ActionEvent)e;
1238                 mostRecentEventTime2 = ae.getWhen();
1239             } else if (e instanceof InvocationEvent) {
1240                 InvocationEvent ie = (InvocationEvent)e;
1241                 mostRecentEventTime2 = ie.getWhen();
1242             }
1243             mostRecentEventTime = Math.max(mostRecentEventTime, mostRecentEventTime2);
1244         } finally {
1245             pushPopLock.unlock();
1246         }
1247     }
1248 
1249     /**
1250      * Causes <code>runnable</code> to have its <code>run</code>
1251      * method called in the {@link #isDispatchThread dispatch thread} of
1252      * {@link Toolkit#getSystemEventQueue the system EventQueue}.
1253      * This will happen after all pending events are processed.
1254      *
1255      * @param runnable  the <code>Runnable</code> whose <code>run</code>
1256      *                  method should be executed
1257      *                  asynchronously in the
1258      *                  {@link #isDispatchThread event dispatch thread}
1259      *                  of {@link Toolkit#getSystemEventQueue the system EventQueue}
1260      * @see             #invokeAndWait
1261      * @see             Toolkit#getSystemEventQueue
1262      * @see             #isDispatchThread
1263      * @since           1.2
1264      */
1265     public static void invokeLater(Runnable runnable) {
1266         Toolkit.getEventQueue().postEvent(
1267             new InvocationEvent(Toolkit.getDefaultToolkit(), runnable));
1268     }
1269 
1270     /**
1271      * Causes <code>runnable</code> to have its <code>run</code>
1272      * method called in the {@link #isDispatchThread dispatch thread} of
1273      * {@link Toolkit#getSystemEventQueue the system EventQueue}.
1274      * This will happen after all pending events are processed.
1275      * The call blocks until this has happened.  This method
1276      * will throw an Error if called from the
1277      * {@link #isDispatchThread event dispatcher thread}.
1278      *
1279      * @param runnable  the <code>Runnable</code> whose <code>run</code>
1280      *                  method should be executed
1281      *                  synchronously in the
1282      *                  {@link #isDispatchThread event dispatch thread}
1283      *                  of {@link Toolkit#getSystemEventQueue the system EventQueue}
1284      * @exception       InterruptedException  if any thread has
1285      *                  interrupted this thread
1286      * @exception       InvocationTargetException  if an throwable is thrown
1287      *                  when running <code>runnable</code>
1288      * @see             #invokeLater
1289      * @see             Toolkit#getSystemEventQueue
1290      * @see             #isDispatchThread
1291      * @since           1.2
1292      */
1293     public static void invokeAndWait(Runnable runnable)
1294         throws InterruptedException, InvocationTargetException
1295     {
1296         invokeAndWait(Toolkit.getDefaultToolkit(), runnable);
1297     }
1298 
1299     static void invokeAndWait(Object source, Runnable runnable)
1300         throws InterruptedException, InvocationTargetException
1301     {
1302         if (EventQueue.isDispatchThread()) {
1303             throw new Error("Cannot call invokeAndWait from the event dispatcher thread");
1304         }
1305 
1306         class AWTInvocationLock {}
1307         Object lock = new AWTInvocationLock();
1308 
1309         InvocationEvent event =
1310             new InvocationEvent(source, runnable, lock, true);
1311 
1312         synchronized (lock) {
1313             Toolkit.getEventQueue().postEvent(event);
1314             while (!event.isDispatched()) {
1315                 lock.wait();
1316             }
1317         }
1318 
1319         Throwable eventThrowable = event.getThrowable();
1320         if (eventThrowable != null) {
1321             throw new InvocationTargetException(eventThrowable);
1322         }
1323     }
1324 
1325     /*
1326      * Called from PostEventQueue.postEvent to notify that a new event
1327      * appeared. First it proceeds to the EventQueue on the top of the
1328      * stack, then notifies the associated dispatch thread if it exists
1329      * or starts a new one otherwise.
1330      */
1331     private void wakeup(boolean isShutdown) {
1332         pushPopLock.lock();
1333         try {
1334             if (nextQueue != null) {
1335                 // Forward call to the top of EventQueue stack.
1336                 nextQueue.wakeup(isShutdown);
1337             } else if (dispatchThread != null) {
1338                 pushPopCond.signalAll();
1339             } else if (!isShutdown) {
1340                 initDispatchThread();
1341             }
1342         } finally {
1343             pushPopLock.unlock();
1344         }
1345     }
1346 
1347     // The method is used by AWTAccessor for javafx/AWT single threaded mode.
1348     private void setFwDispatcher(FwDispatcher dispatcher) {
1349         if (nextQueue != null) {
1350             nextQueue.setFwDispatcher(dispatcher);
1351         } else {
1352             fwDispatcher = dispatcher;
1353         }
1354     }
1355 }
1356 
1357 /**
1358  * The Queue object holds pointers to the beginning and end of one internal
1359  * queue. An EventQueue object is composed of multiple internal Queues, one
1360  * for each priority supported by the EventQueue. All Events on a particular
1361  * internal Queue have identical priority.
1362  */
1363 class Queue {
1364     EventQueueItem head;
1365     EventQueueItem tail;
1366 }
--- EOF ---