1 /*
   2  * Copyright (c) 1996, 2011, 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 import sun.util.logging.PlatformLogger;
  40 
  41 import sun.awt.AppContext;
  42 import sun.awt.AWTAutoShutdown;
  43 import sun.awt.PeerEvent;
  44 import sun.awt.SunToolkit;
  45 import sun.awt.EventQueueItem;
  46 import sun.awt.AWTAccessor;
  47 
  48 import java.util.concurrent.locks.Condition;
  49 import java.util.concurrent.locks.ReentrantLock;
  50 import java.util.concurrent.atomic.AtomicInteger;
  51 
  52 import java.security.AccessControlContext;
  53 import java.security.ProtectionDomain;
  54 
  55 import sun.misc.SharedSecrets;
  56 import sun.misc.JavaSecurityAccess;
  57 
  58 /**
  59  * <code>EventQueue</code> is a platform-independent class
  60  * that queues events, both from the underlying peer classes
  61  * and from trusted application classes.
  62  * <p>
  63  * It encapsulates asynchronous event dispatch machinery which
  64  * extracts events from the queue and dispatches them by calling
  65  * {@link #dispatchEvent(AWTEvent) dispatchEvent(AWTEvent)} method
  66  * on this <code>EventQueue</code> with the event to be dispatched
  67  * as an argument.  The particular behavior of this machinery is
  68  * implementation-dependent.  The only requirements are that events
  69  * which were actually enqueued to this queue (note that events
  70  * being posted to the <code>EventQueue</code> can be coalesced)
  71  * are dispatched:
  72  * <dl>
  73  *   <dt> Sequentially.
  74  *   <dd> That is, it is not permitted that several events from
  75  *        this queue are dispatched simultaneously.
  76  *   <dt> In the same order as they are enqueued.
  77  *   <dd> That is, if <code>AWTEvent</code>&nbsp;A is enqueued
  78  *        to the <code>EventQueue</code> before
  79  *        <code>AWTEvent</code>&nbsp;B then event B will not be
  80  *        dispatched before event A.
  81  * </dl>
  82  * <p>
  83  * Some browsers partition applets in different code bases into
  84  * separate contexts, and establish walls between these contexts.
  85  * In such a scenario, there will be one <code>EventQueue</code>
  86  * per context. Other browsers place all applets into the same
  87  * context, implying that there will be only a single, global
  88  * <code>EventQueue</code> for all applets. This behavior is
  89  * implementation-dependent.  Consult your browser's documentation
  90  * for more information.
  91  * <p>
  92  * For information on the threading issues of the event dispatch
  93  * machinery, see <a href="doc-files/AWTThreadIssues.html#Autoshutdown"
  94  * >AWT Threading Issues</a>.
  95  *
  96  * @author Thomas Ball
  97  * @author Fred Ecks
  98  * @author David Mendenhall
  99  *
 100  * @since       1.1
 101  */
 102 public class EventQueue {
 103     private static final AtomicInteger threadInitNumber = new AtomicInteger(0);





 104 
 105     private static final int LOW_PRIORITY = 0;
 106     private static final int NORM_PRIORITY = 1;
 107     private static final int HIGH_PRIORITY = 2;
 108     private static final int ULTIMATE_PRIORITY = 3;
 109 
 110     private static final int NUM_PRIORITIES = ULTIMATE_PRIORITY + 1;
 111 
 112     /*
 113      * We maintain one Queue for each priority that the EventQueue supports.
 114      * That is, the EventQueue object is actually implemented as
 115      * NUM_PRIORITIES queues and all Events on a particular internal Queue
 116      * have identical priority. Events are pulled off the EventQueue starting
 117      * with the Queue of highest priority. We progress in decreasing order
 118      * across all Queues.
 119      */
 120     private Queue[] queues = new Queue[NUM_PRIORITIES];
 121 
 122     /*
 123      * The next EventQueue on the stack, or null if this EventQueue is
 124      * on the top of the stack.  If nextQueue is non-null, requests to post
 125      * an event are forwarded to nextQueue.
 126      */
 127     private EventQueue nextQueue;
 128 
 129     /*
 130      * The previous EventQueue on the stack, or null if this is the
 131      * "base" EventQueue.
 132      */
 133     private EventQueue previousQueue;
 134 
 135     /*
 136      * A single lock to synchronize the push()/pop() and related operations with
 137      * all the EventQueues from the AppContext. Synchronization on any particular
 138      * event queue(s) is not enough: we should lock the whole stack.
 139      */
 140     private final ReentrantLock pushPopLock;
 141     private final Condition pushPopCond;
 142 
 143     /*
 144      * Dummy runnable to wake up EDT from getNextEvent() after
 145      push/pop is performed
 146      */
 147     private final static Runnable dummyRunnable = new Runnable() {
 148         public void run() {
 149         }
 150     };
 151 
 152     private EventDispatchThread dispatchThread;
 153 
 154     private final ThreadGroup threadGroup =
 155         Thread.currentThread().getThreadGroup();
 156     private final ClassLoader classLoader =
 157         Thread.currentThread().getContextClassLoader();
 158 
 159     /*
 160      * The time stamp of the last dispatched InputEvent or ActionEvent.
 161      */
 162     private long mostRecentEventTime = 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 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     private final String name = "AWT-EventQueue-" + threadInitNumber.getAndIncrement();
 177 
 178     private static final PlatformLogger eventLog = PlatformLogger.getLogger("java.awt.event.EventQueue");
 179 
 180     static {
 181         AWTAccessor.setEventQueueAccessor(
 182             new AWTAccessor.EventQueueAccessor() {
 183                 public Thread getDispatchThread(EventQueue eventQueue) {
 184                     return eventQueue.getDispatchThread();
 185                 }
 186                 public boolean isDispatchThreadImpl(EventQueue eventQueue) {
 187                     return eventQueue.isDispatchThreadImpl();
 188                 }
 189             });
 190     }
 191 
 192     public EventQueue() {
 193         for (int i = 0; i < NUM_PRIORITIES; i++) {
 194             queues[i] = new Queue();
 195         }
 196         /*
 197          * NOTE: if you ever have to start the associated event dispatch
 198          * thread at this point, be aware of the following problem:
 199          * If this EventQueue instance is created in
 200          * SunToolkit.createNewAppContext() the started dispatch thread
 201          * may call AppContext.getAppContext() before createNewAppContext()
 202          * completes thus causing mess in thread group to appcontext mapping.
 203          */
 204 
 205         pushPopLock = (ReentrantLock)AppContext.getAppContext().get(AppContext.EVENT_QUEUE_LOCK_KEY);
 206         pushPopCond = (Condition)AppContext.getAppContext().get(AppContext.EVENT_QUEUE_COND_KEY);
 207     }
 208 
 209     /**
 210      * Posts a 1.1-style event to the <code>EventQueue</code>.
 211      * If there is an existing event on the queue with the same ID
 212      * and event source, the source <code>Component</code>'s
 213      * <code>coalesceEvents</code> method will be called.
 214      *
 215      * @param theEvent an instance of <code>java.awt.AWTEvent</code>,
 216      *          or a subclass of it
 217      * @throws NullPointerException if <code>theEvent</code> is <code>null</code>
 218      */
 219     public void postEvent(AWTEvent theEvent) {
 220         SunToolkit.flushPendingEvents();
 221         postEventPrivate(theEvent);
 222     }
 223 
 224     /**
 225      * Posts a 1.1-style event to the <code>EventQueue</code>.
 226      * If there is an existing event on the queue with the same ID
 227      * and event source, the source <code>Component</code>'s
 228      * <code>coalesceEvents</code> method will be called.
 229      *
 230      * @param theEvent an instance of <code>java.awt.AWTEvent</code>,
 231      *          or a subclass of it
 232      */
 233     private final void postEventPrivate(AWTEvent theEvent) {
 234         theEvent.isPosted = true;
 235         pushPopLock.lock();
 236         try {
 237             if (nextQueue != null) {
 238                 // Forward the event to the top of EventQueue stack
 239                 nextQueue.postEventPrivate(theEvent);
 240                 return;
 241             }
 242             if (dispatchThread == null) {
 243                 if (theEvent.getSource() == AWTAutoShutdown.getInstance()) {
 244                     return;
 245                 } else {
 246                     initDispatchThread();
 247                 }
 248             }
 249             postEvent(theEvent, getPriority(theEvent));
 250         } finally {
 251             pushPopLock.unlock();
 252         }
 253     }
 254 
 255     private static int getPriority(AWTEvent theEvent) {
 256         if (theEvent instanceof PeerEvent) {
 257             PeerEvent peerEvent = (PeerEvent)theEvent;
 258             if ((peerEvent.getFlags() & PeerEvent.ULTIMATE_PRIORITY_EVENT) != 0) {
 259                 return ULTIMATE_PRIORITY;
 260             }
 261             if ((peerEvent.getFlags() & PeerEvent.PRIORITY_EVENT) != 0) {
 262                 return HIGH_PRIORITY;
 263             }
 264             if ((peerEvent.getFlags() & PeerEvent.LOW_PRIORITY_EVENT) != 0) {
 265                 return LOW_PRIORITY;
 266             }
 267         }
 268         int id = theEvent.getID();
 269         if ((id >= PaintEvent.PAINT_FIRST) && (id <= PaintEvent.PAINT_LAST)) {
 270             return LOW_PRIORITY;
 271         }
 272         return NORM_PRIORITY;
 273     }
 274 
 275     /**
 276      * Posts the event to the internal Queue of specified priority,
 277      * coalescing as appropriate.
 278      *
 279      * @param theEvent an instance of <code>java.awt.AWTEvent</code>,
 280      *          or a subclass of it
 281      * @param priority  the desired priority of the event
 282      */
 283     private void postEvent(AWTEvent theEvent, int priority) {
 284         if (coalesceEvent(theEvent, priority)) {
 285             return;
 286         }
 287 
 288         EventQueueItem newItem = new EventQueueItem(theEvent);
 289 
 290         cacheEQItem(newItem);
 291 
 292         boolean notifyID = (theEvent.getID() == this.waitForID);
 293 
 294         if (queues[priority].head == null) {
 295             boolean shouldNotify = noEvents();
 296             queues[priority].head = queues[priority].tail = newItem;
 297 
 298             if (shouldNotify) {
 299                 if (theEvent.getSource() != AWTAutoShutdown.getInstance()) {
 300                     AWTAutoShutdown.getInstance().notifyThreadBusy(dispatchThread);
 301                 }
 302                 pushPopCond.signalAll();
 303             } else if (notifyID) {
 304                 pushPopCond.signalAll();
 305             }
 306         } else {
 307             // The event was not coalesced or has non-Component source.
 308             // Insert it at the end of the appropriate Queue.
 309             queues[priority].tail.next = newItem;
 310             queues[priority].tail = newItem;
 311             if (notifyID) {
 312                 pushPopCond.signalAll();
 313             }
 314         }
 315     }
 316 
 317     private boolean coalescePaintEvent(PaintEvent e) {
 318         ComponentPeer sourcePeer = ((Component)e.getSource()).peer;
 319         if (sourcePeer != null) {
 320             sourcePeer.coalescePaintEvent(e);
 321         }
 322         EventQueueItem[] cache = ((Component)e.getSource()).eventCache;
 323         if (cache == null) {
 324             return false;
 325         }
 326         int index = eventToCacheIndex(e);
 327 
 328         if (index != -1 && cache[index] != null) {
 329             PaintEvent merged = mergePaintEvents(e, (PaintEvent)cache[index].event);
 330             if (merged != null) {
 331                 cache[index].event = merged;
 332                 return true;
 333             }
 334         }
 335         return false;
 336     }
 337 
 338     private PaintEvent mergePaintEvents(PaintEvent a, PaintEvent b) {
 339         Rectangle aRect = a.getUpdateRect();
 340         Rectangle bRect = b.getUpdateRect();
 341         if (bRect.contains(aRect)) {
 342             return b;
 343         }
 344         if (aRect.contains(bRect)) {
 345             return a;
 346         }
 347         return null;
 348     }
 349 
 350     private boolean coalesceMouseEvent(MouseEvent e) {
 351         EventQueueItem[] cache = ((Component)e.getSource()).eventCache;
 352         if (cache == null) {
 353             return false;
 354         }
 355         int index = eventToCacheIndex(e);
 356         if (index != -1 && cache[index] != null) {
 357             cache[index].event = e;
 358             return true;
 359         }
 360         return false;
 361     }
 362 
 363     private boolean coalescePeerEvent(PeerEvent e) {
 364         EventQueueItem[] cache = ((Component)e.getSource()).eventCache;
 365         if (cache == null) {
 366             return false;
 367         }
 368         int index = eventToCacheIndex(e);
 369         if (index != -1 && cache[index] != null) {
 370             e = e.coalesceEvents((PeerEvent)cache[index].event);
 371             if (e != null) {
 372                 cache[index].event = e;
 373                 return true;
 374             } else {
 375                 cache[index] = null;
 376             }
 377         }
 378         return false;
 379     }
 380 
 381     /*
 382      * Should avoid of calling this method by any means
 383      * as it's working time is dependant on EQ length.
 384      * In the wors case this method alone can slow down the entire application
 385      * 10 times by stalling the Event processing.
 386      * Only here by backward compatibility reasons.
 387      */
 388     private boolean coalesceOtherEvent(AWTEvent e, int priority) {
 389         int id = e.getID();
 390         Component source = (Component)e.getSource();
 391         for (EventQueueItem entry = queues[priority].head;
 392             entry != null; entry = entry.next)
 393         {
 394             // Give Component.coalesceEvents a chance
 395             if (entry.event.getSource() == source && entry.event.getID() == id) {
 396                 AWTEvent coalescedEvent = source.coalesceEvents(
 397                     entry.event, e);
 398                 if (coalescedEvent != null) {
 399                     entry.event = coalescedEvent;
 400                     return true;
 401                 }
 402             }
 403         }
 404         return false;
 405     }
 406 
 407     private boolean coalesceEvent(AWTEvent e, int priority) {
 408         if (!(e.getSource() instanceof Component)) {
 409             return false;
 410         }
 411         if (e instanceof PeerEvent) {
 412             return coalescePeerEvent((PeerEvent)e);
 413         }
 414         // The worst case
 415         if (((Component)e.getSource()).isCoalescingEnabled()
 416             && coalesceOtherEvent(e, priority))
 417         {
 418             return true;
 419         }
 420         if (e instanceof PaintEvent) {
 421             return coalescePaintEvent((PaintEvent)e);
 422         }
 423         if (e instanceof MouseEvent) {
 424             return coalesceMouseEvent((MouseEvent)e);
 425         }
 426         return false;
 427     }
 428 
 429     private void cacheEQItem(EventQueueItem entry) {
 430         int index = eventToCacheIndex(entry.event);
 431         if (index != -1 && entry.event.getSource() instanceof Component) {
 432             Component source = (Component)entry.event.getSource();
 433             if (source.eventCache == null) {
 434                 source.eventCache = new EventQueueItem[CACHE_LENGTH];
 435             }
 436             source.eventCache[index] = entry;
 437         }
 438     }
 439 
 440     private void uncacheEQItem(EventQueueItem entry) {
 441         int index = eventToCacheIndex(entry.event);
 442         if (index != -1 && entry.event.getSource() instanceof Component) {
 443             Component source = (Component)entry.event.getSource();
 444             if (source.eventCache == null) {
 445                 return;
 446             }
 447             source.eventCache[index] = null;
 448         }
 449     }
 450 
 451     private static final int PAINT = 0;
 452     private static final int UPDATE = 1;
 453     private static final int MOVE = 2;
 454     private static final int DRAG = 3;
 455     private static final int PEER = 4;
 456     private static final int CACHE_LENGTH = 5;
 457 
 458     private static int eventToCacheIndex(AWTEvent e) {
 459         switch(e.getID()) {
 460         case PaintEvent.PAINT:
 461             return PAINT;
 462         case PaintEvent.UPDATE:
 463             return UPDATE;
 464         case MouseEvent.MOUSE_MOVED:
 465             return MOVE;
 466         case MouseEvent.MOUSE_DRAGGED:
 467             return DRAG;
 468         default:
 469             return e instanceof PeerEvent ? PEER : -1;
 470         }
 471     }
 472 
 473     /**
 474      * Returns whether an event is pending on any of the separate
 475      * Queues.
 476      * @return whether an event is pending on any of the separate Queues
 477      */
 478     private boolean noEvents() {
 479         for (int i = 0; i < NUM_PRIORITIES; i++) {
 480             if (queues[i].head != null) {
 481                 return false;
 482             }
 483         }
 484 
 485         return true;
 486     }
 487 
 488     /**
 489      * Removes an event from the <code>EventQueue</code> and
 490      * returns it.  This method will block until an event has
 491      * been posted by another thread.
 492      * @return the next <code>AWTEvent</code>
 493      * @exception InterruptedException
 494      *            if any thread has interrupted this thread
 495      */
 496     public AWTEvent getNextEvent() throws InterruptedException {
 497         do {
 498             /*
 499              * SunToolkit.flushPendingEvents must be called outside
 500              * of the synchronized block to avoid deadlock when
 501              * event queues are nested with push()/pop().
 502              */
 503             SunToolkit.flushPendingEvents();
 504             pushPopLock.lock();
 505             try {
 506                 AWTEvent event = getNextEventPrivate();
 507                 if (event != null) {
 508                     return event;
 509                 }
 510                 AWTAutoShutdown.getInstance().notifyThreadFree(dispatchThread);
 511                 pushPopCond.await();
 512             } finally {
 513                 if(pushPopLock.isHeldByCurrentThread()) {
 514                    pushPopLock.unlock();
 515                 }
 516             }
 517         } while(true);
 518     }
 519 
 520     /*
 521      * Must be called under the lock. Doesn't call flushPendingEvents()
 522      */
 523     AWTEvent getNextEventPrivate() throws InterruptedException {
 524         for (int i = NUM_PRIORITIES - 1; i >= 0; i--) {
 525             if (queues[i].head != null) {
 526                 EventQueueItem entry = queues[i].head;
 527                 queues[i].head = entry.next;
 528                 if (entry.next == null) {
 529                     queues[i].tail = null;
 530                 }
 531                 uncacheEQItem(entry);
 532                 return entry.event;
 533             }
 534         }
 535         return null;
 536     }
 537 
 538     AWTEvent getNextEvent(int id) throws InterruptedException {
 539         do {
 540             /*
 541              * SunToolkit.flushPendingEvents must be called outside
 542              * of the synchronized block to avoid deadlock when
 543              * event queues are nested with push()/pop().
 544              */
 545             SunToolkit.flushPendingEvents();
 546             pushPopLock.lock();
 547             try {
 548                 for (int i = 0; i < NUM_PRIORITIES; i++) {
 549                     for (EventQueueItem entry = queues[i].head, prev = null;
 550                          entry != null; prev = entry, entry = entry.next)
 551                     {
 552                         if (entry.event.getID() == id) {
 553                             if (prev == null) {
 554                                 queues[i].head = entry.next;
 555                             } else {
 556                                 prev.next = entry.next;
 557                             }
 558                             if (queues[i].tail == entry) {
 559                                 queues[i].tail = prev;
 560                             }
 561                             uncacheEQItem(entry);
 562                             return entry.event;
 563                         }
 564                     }
 565                 }
 566                 waitForID = id;
 567                 pushPopCond.await();
 568                 waitForID = 0;
 569             } finally {
 570                 if(pushPopLock.isHeldByCurrentThread()) {
 571                    pushPopLock.unlock();
 572                 }
 573             }
 574         } while(true);
 575     }
 576 
 577     /**
 578      * Returns the first event on the <code>EventQueue</code>
 579      * without removing it.
 580      * @return the first event
 581      */
 582     public AWTEvent peekEvent() {
 583         pushPopLock.lock();
 584         try {
 585             for (int i = NUM_PRIORITIES - 1; i >= 0; i--) {
 586                 if (queues[i].head != null) {
 587                     return queues[i].head.event;
 588                 }
 589             }
 590         } finally {
 591             pushPopLock.unlock();
 592         }
 593 
 594         return null;
 595     }
 596 
 597     /**
 598      * Returns the first event with the specified id, if any.
 599      * @param id the id of the type of event desired
 600      * @return the first event of the specified id or <code>null</code>
 601      *    if there is no such event
 602      */
 603     public AWTEvent peekEvent(int id) {
 604         pushPopLock.lock();
 605         try {
 606             for (int i = NUM_PRIORITIES - 1; i >= 0; i--) {
 607                 EventQueueItem q = queues[i].head;
 608                 for (; q != null; q = q.next) {
 609                     if (q.event.getID() == id) {
 610                         return q.event;
 611                     }
 612                 }
 613             }
 614         } finally {
 615             pushPopLock.unlock();
 616         }
 617 
 618         return null;
 619     }
 620 
 621     private static final JavaSecurityAccess javaSecurityAccess =
 622         SharedSecrets.getJavaSecurityAccess();
 623 
 624     /**
 625      * Dispatches an event. The manner in which the event is
 626      * dispatched depends upon the type of the event and the
 627      * type of the event's source object:
 628      * <p> </p>
 629      * <table border=1 summary="Event types, source types, and dispatch methods">
 630      * <tr>
 631      *     <th>Event Type</th>
 632      *     <th>Source Type</th>
 633      *     <th>Dispatched To</th>
 634      * </tr>
 635      * <tr>
 636      *     <td>ActiveEvent</td>
 637      *     <td>Any</td>
 638      *     <td>event.dispatch()</td>
 639      * </tr>
 640      * <tr>
 641      *     <td>Other</td>
 642      *     <td>Component</td>
 643      *     <td>source.dispatchEvent(AWTEvent)</td>
 644      * </tr>
 645      * <tr>
 646      *     <td>Other</td>
 647      *     <td>MenuComponent</td>
 648      *     <td>source.dispatchEvent(AWTEvent)</td>
 649      * </tr>
 650      * <tr>
 651      *     <td>Other</td>
 652      *     <td>Other</td>
 653      *     <td>No action (ignored)</td>
 654      * </tr>
 655      * </table>
 656      * <p> </p>
 657      * @param event an instance of <code>java.awt.AWTEvent</code>,
 658      *          or a subclass of it
 659      * @throws NullPointerException if <code>event</code> is <code>null</code>
 660      * @since           1.2
 661      */
 662     protected void dispatchEvent(final AWTEvent event) {
 663         final Object src = event.getSource();
 664         final PrivilegedAction<Void> action = new PrivilegedAction<Void>() {
 665             public Void run() {
 666                 dispatchEventImpl(event, src);
 667                 return null;
 668             }
 669         };
 670 
 671         final AccessControlContext stack = AccessController.getContext();
 672         final AccessControlContext srcAcc = getAccessControlContextFrom(src);
 673         final AccessControlContext eventAcc = event.getAccessControlContext();
 674         if (srcAcc == null) {
 675             javaSecurityAccess.doIntersectionPrivilege(action, stack, eventAcc);
 676         } else {
 677             javaSecurityAccess.doIntersectionPrivilege(
 678                 new PrivilegedAction<Void>() {
 679                     public Void run() {
 680                         javaSecurityAccess.doIntersectionPrivilege(action, eventAcc);
 681                         return null;
 682                     }
 683                 }, stack, srcAcc);
 684         }
 685     }
 686 
 687     private static AccessControlContext getAccessControlContextFrom(Object src) {
 688         return src instanceof Component ?
 689             ((Component)src).getAccessControlContext() :
 690             src instanceof MenuComponent ?
 691                 ((MenuComponent)src).getAccessControlContext() :
 692                 src instanceof TrayIcon ?
 693                     ((TrayIcon)src).getAccessControlContext() :
 694                     null;
 695     }
 696 
 697     /**
 698      * Called from dispatchEvent() under a correct AccessControlContext
 699      */
 700     private void dispatchEventImpl(final AWTEvent event, final Object src) {
 701         event.isPosted = true;
 702         if (event instanceof ActiveEvent) {
 703             // This could become the sole method of dispatching in time.
 704             setCurrentEventAndMostRecentTimeImpl(event);
 705             ((ActiveEvent)event).dispatch();
 706         } else if (src instanceof Component) {
 707             ((Component)src).dispatchEvent(event);
 708             event.dispatched();
 709         } else if (src instanceof MenuComponent) {
 710             ((MenuComponent)src).dispatchEvent(event);
 711         } else if (src instanceof TrayIcon) {
 712             ((TrayIcon)src).dispatchEvent(event);
 713         } else if (src instanceof AWTAutoShutdown) {
 714             if (noEvents()) {
 715                 dispatchThread.stopDispatching();
 716             }
 717         } else {
 718             if (eventLog.isLoggable(PlatformLogger.FINE)) {
 719                 eventLog.fine("Unable to dispatch event: " + event);
 720             }
 721         }
 722     }
 723 
 724     /**
 725      * Returns the timestamp of the most recent event that had a timestamp, and
 726      * that was dispatched from the <code>EventQueue</code> associated with the
 727      * calling thread. If an event with a timestamp is currently being
 728      * dispatched, its timestamp will be returned. If no events have yet
 729      * been dispatched, the EventQueue's initialization time will be
 730      * returned instead.In the current version of
 731      * the JDK, only <code>InputEvent</code>s,
 732      * <code>ActionEvent</code>s, and <code>InvocationEvent</code>s have
 733      * timestamps; however, future versions of the JDK may add timestamps to
 734      * additional event types. Note that this method should only be invoked
 735      * from an application's {@link #isDispatchThread event dispatching thread}.
 736      * If this method is
 737      * invoked from another thread, the current system time (as reported by
 738      * <code>System.currentTimeMillis()</code>) will be returned instead.
 739      *
 740      * @return the timestamp of the last <code>InputEvent</code>,
 741      *         <code>ActionEvent</code>, or <code>InvocationEvent</code> to be
 742      *         dispatched, or <code>System.currentTimeMillis()</code> if this
 743      *         method is invoked on a thread other than an event dispatching
 744      *         thread
 745      * @see java.awt.event.InputEvent#getWhen
 746      * @see java.awt.event.ActionEvent#getWhen
 747      * @see java.awt.event.InvocationEvent#getWhen
 748      * @see #isDispatchThread
 749      *
 750      * @since 1.4
 751      */
 752     public static long getMostRecentEventTime() {
 753         return Toolkit.getEventQueue().getMostRecentEventTimeImpl();
 754     }
 755     private long getMostRecentEventTimeImpl() {
 756         pushPopLock.lock();
 757         try {
 758             return (Thread.currentThread() == dispatchThread)
 759                 ? mostRecentEventTime
 760                 : System.currentTimeMillis();
 761         } finally {
 762             pushPopLock.unlock();
 763         }
 764     }
 765 
 766     /**
 767      * @return most recent event time on all threads.
 768      */
 769     long getMostRecentEventTimeEx() {
 770         pushPopLock.lock();
 771         try {
 772             return mostRecentEventTime;
 773         } finally {
 774             pushPopLock.unlock();
 775         }
 776     }
 777 
 778     /**
 779      * Returns the the event currently being dispatched by the
 780      * <code>EventQueue</code> associated with the calling thread. This is
 781      * useful if a method needs access to the event, but was not designed to
 782      * receive a reference to it as an argument. Note that this method should
 783      * only be invoked from an application's event dispatching thread. If this
 784      * method is invoked from another thread, null will be returned.
 785      *
 786      * @return the event currently being dispatched, or null if this method is
 787      *         invoked on a thread other than an event dispatching thread
 788      * @since 1.4
 789      */
 790     public static AWTEvent getCurrentEvent() {
 791         return Toolkit.getEventQueue().getCurrentEventImpl();
 792     }
 793     private AWTEvent getCurrentEventImpl() {
 794         pushPopLock.lock();
 795         try {
 796                 return (Thread.currentThread() == dispatchThread)
 797                 ? ((AWTEvent)currentEvent.get())
 798                 : null;
 799         } finally {
 800             pushPopLock.unlock();
 801         }
 802     }
 803 
 804     /**
 805      * Replaces the existing <code>EventQueue</code> with the specified one.
 806      * Any pending events are transferred to the new <code>EventQueue</code>
 807      * for processing by it.
 808      *
 809      * @param newEventQueue an <code>EventQueue</code>
 810      *          (or subclass thereof) instance to be use
 811      * @see      java.awt.EventQueue#pop
 812      * @throws NullPointerException if <code>newEventQueue</code> is <code>null</code>
 813      * @since           1.2
 814      */
 815     public void push(EventQueue newEventQueue) {
 816         if (eventLog.isLoggable(PlatformLogger.FINE)) {
 817             eventLog.fine("EventQueue.push(" + newEventQueue + ")");
 818         }
 819 
 820         pushPopLock.lock();
 821         try {
 822             EventQueue topQueue = this;
 823             while (topQueue.nextQueue != null) {
 824                 topQueue = topQueue.nextQueue;
 825             }
 826 
 827             if ((topQueue.dispatchThread != null) &&
 828                 (topQueue.dispatchThread.getEventQueue() == this))
 829             {
 830                 newEventQueue.dispatchThread = topQueue.dispatchThread;
 831                 topQueue.dispatchThread.setEventQueue(newEventQueue);
 832             }
 833 
 834             // Transfer all events forward to new EventQueue.
 835             while (topQueue.peekEvent() != null) {
 836                 try {
 837                     // Use getNextEventPrivate() as it doesn't call flushPendingEvents()
 838                     newEventQueue.postEventPrivate(topQueue.getNextEventPrivate());
 839                 } catch (InterruptedException ie) {
 840                     if (eventLog.isLoggable(PlatformLogger.FINE)) {
 841                         eventLog.fine("Interrupted push", ie);
 842                     }
 843                 }
 844             }
 845 
 846             // Wake up EDT waiting in getNextEvent(), so it can
 847             // pick up a new EventQueue. Post the waking event before
 848             // topQueue.nextQueue is assigned, otherwise the event would
 849             // go newEventQueue
 850             topQueue.postEventPrivate(new InvocationEvent(topQueue, dummyRunnable));
 851 
 852             newEventQueue.previousQueue = topQueue;
 853             topQueue.nextQueue = newEventQueue;
 854 
 855             AppContext appContext = AppContext.getAppContext();
 856             if (appContext.get(AppContext.EVENT_QUEUE_KEY) == topQueue) {
 857                 appContext.put(AppContext.EVENT_QUEUE_KEY, newEventQueue);
 858             }
 859 
 860             pushPopCond.signalAll();
 861         } finally {
 862             pushPopLock.unlock();
 863         }
 864     }
 865 
 866     /**
 867      * Stops dispatching events using this <code>EventQueue</code>.
 868      * Any pending events are transferred to the previous
 869      * <code>EventQueue</code> for processing.
 870      * <p>
 871      * Warning: To avoid deadlock, do not declare this method
 872      * synchronized in a subclass.
 873      *
 874      * @exception EmptyStackException if no previous push was made
 875      *  on this <code>EventQueue</code>
 876      * @see      java.awt.EventQueue#push
 877      * @since           1.2
 878      */
 879     protected void pop() throws EmptyStackException {
 880         if (eventLog.isLoggable(PlatformLogger.FINE)) {
 881             eventLog.fine("EventQueue.pop(" + this + ")");
 882         }
 883 
 884         pushPopLock.lock();
 885         try {
 886             EventQueue topQueue = this;
 887             while (topQueue.nextQueue != null) {
 888                 topQueue = topQueue.nextQueue;
 889             }
 890             EventQueue prevQueue = topQueue.previousQueue;
 891             if (prevQueue == null) {
 892                 throw new EmptyStackException();
 893             }
 894 
 895             topQueue.previousQueue = null;
 896             prevQueue.nextQueue = null;
 897 
 898             // Transfer all events back to previous EventQueue.
 899             while (topQueue.peekEvent() != null) {
 900                 try {
 901                     prevQueue.postEventPrivate(topQueue.getNextEventPrivate());
 902                 } catch (InterruptedException ie) {
 903                     if (eventLog.isLoggable(PlatformLogger.FINE)) {
 904                         eventLog.fine("Interrupted pop", ie);
 905                     }
 906                 }
 907             }
 908 
 909             if ((topQueue.dispatchThread != null) &&
 910                 (topQueue.dispatchThread.getEventQueue() == this))
 911             {
 912                 prevQueue.dispatchThread = topQueue.dispatchThread;
 913                 topQueue.dispatchThread.setEventQueue(prevQueue);
 914             }
 915 
 916             AppContext appContext = AppContext.getAppContext();
 917             if (appContext.get(AppContext.EVENT_QUEUE_KEY) == this) {
 918                 appContext.put(AppContext.EVENT_QUEUE_KEY, prevQueue);
 919             }
 920 
 921             // Wake up EDT waiting in getNextEvent(), so it can
 922             // pick up a new EventQueue
 923             topQueue.postEventPrivate(new InvocationEvent(topQueue, dummyRunnable));
 924 
 925             pushPopCond.signalAll();
 926         } finally {
 927             pushPopLock.unlock();
 928         }
 929     }
 930 
 931     /**
 932      * Creates a new {@code secondary loop} associated with this
 933      * event queue. Use the {@link SecondaryLoop#enter} and
 934      * {@link SecondaryLoop#exit} methods to start and stop the
 935      * event loop and dispatch the events from this queue.
 936      *
 937      * @return secondaryLoop A new secondary loop object, which can
 938      *                       be used to launch a new nested event
 939      *                       loop and dispatch events from this queue
 940      *
 941      * @see SecondaryLoop#enter
 942      * @see SecondaryLoop#exit
 943      *
 944      * @since 1.7
 945      */
 946     public SecondaryLoop createSecondaryLoop() {
 947         return createSecondaryLoop(null, null, 0);
 948     }
 949 
 950     SecondaryLoop createSecondaryLoop(Conditional cond, EventFilter filter, long interval) {
 951         pushPopLock.lock();
 952         try {
 953             if (nextQueue != null) {
 954                 // Forward the request to the top of EventQueue stack
 955                 return nextQueue.createSecondaryLoop(cond, filter, interval);
 956             }
 957             if (dispatchThread == null) {
 958                 initDispatchThread();
 959             }
 960             return new WaitDispatchSupport(dispatchThread, cond, filter, interval);
 961         } finally {
 962             pushPopLock.unlock();
 963         }
 964     }
 965 
 966     /**
 967      * Returns true if the calling thread is
 968      * {@link Toolkit#getSystemEventQueue the current AWT EventQueue}'s
 969      * dispatch thread. Use this method to ensure that a particular
 970      * task is being executed (or not being) there.
 971      * <p>
 972      * Note: use the {@link #invokeLater} or {@link #invokeAndWait}
 973      * methods to execute a task in
 974      * {@link Toolkit#getSystemEventQueue the current AWT EventQueue}'s
 975      * dispatch thread.
 976      * <p>
 977      *
 978      * @return true if running in
 979      * {@link Toolkit#getSystemEventQueue the current AWT EventQueue}'s
 980      * dispatch thread
 981      * @see             #invokeLater
 982      * @see             #invokeAndWait
 983      * @see             Toolkit#getSystemEventQueue
 984      * @since           1.2
 985      */
 986     public static boolean isDispatchThread() {
 987         EventQueue eq = Toolkit.getEventQueue();
 988         return eq.isDispatchThreadImpl();
 989     }
 990 
 991     final boolean isDispatchThreadImpl() {
 992         EventQueue eq = this;
 993         pushPopLock.lock();
 994         try {
 995             EventQueue next = eq.nextQueue;
 996             while (next != null) {
 997                 eq = next;
 998                 next = eq.nextQueue;
 999             }
1000             return (Thread.currentThread() == eq.dispatchThread);
1001         } finally {
1002             pushPopLock.unlock();
1003         }
1004     }
1005 
1006     final void initDispatchThread() {
1007         pushPopLock.lock();
1008         try {
1009             AppContext appContext = AppContext.getAppContext();
1010             if (dispatchThread == null && !threadGroup.isDestroyed() && !appContext.isDisposed()) {
1011                 dispatchThread = AccessController.doPrivileged(
1012                     new PrivilegedAction<EventDispatchThread>() {
1013                         public EventDispatchThread run() {
1014                             EventDispatchThread t =
1015                                 new EventDispatchThread(threadGroup,
1016                                                         name,
1017                                                         EventQueue.this);
1018                             t.setContextClassLoader(classLoader);
1019                             t.setPriority(Thread.NORM_PRIORITY + 1);
1020                             t.setDaemon(false);
1021                             return t;
1022                         }
1023                     }
1024                 );
1025                 AWTAutoShutdown.getInstance().notifyThreadBusy(dispatchThread);
1026                 dispatchThread.start();
1027             }
1028         } finally {
1029             pushPopLock.unlock();
1030         }
1031     }
1032 
1033     final boolean detachDispatchThread(EventDispatchThread edt, boolean forceDetach) {
1034         /*
1035          * This synchronized block is to secure that the event dispatch
1036          * thread won't die in the middle of posting a new event to the
1037          * associated event queue. It is important because we notify
1038          * that the event dispatch thread is busy after posting a new event
1039          * to its queue, so the EventQueue.dispatchThread reference must
1040          * be valid at that point.
1041          */
1042         pushPopLock.lock();
1043         try {
1044             if (edt == dispatchThread) {
1045                 /*
1046                  * Don't detach the thread if any events are pending. Not
1047                  * sure if it's a possible scenario, though.
1048                  *
1049                  * Fix for 4648733. Check both the associated java event
1050                  * queue and the PostEventQueue.
1051                  */
1052                 if (!forceDetach && (peekEvent() != null) || !SunToolkit.isPostEventQueueEmpty()) {
1053                     return false;
1054                 }
1055                 dispatchThread = null;
1056             }
1057             AWTAutoShutdown.getInstance().notifyThreadFree(edt);
1058             return true;
1059         } finally {
1060             pushPopLock.unlock();
1061         }
1062     }
1063 
1064     /*
1065      * Gets the <code>EventDispatchThread</code> for this
1066      * <code>EventQueue</code>.
1067      * @return the event dispatch thread associated with this event queue
1068      *         or <code>null</code> if this event queue doesn't have a
1069      *         working thread associated with it
1070      * @see    java.awt.EventQueue#initDispatchThread
1071      * @see    java.awt.EventQueue#detachDispatchThread
1072      */
1073     final EventDispatchThread getDispatchThread() {
1074         pushPopLock.lock();
1075         try {
1076             return dispatchThread;
1077         } finally {
1078             pushPopLock.unlock();
1079         }
1080     }
1081 
1082     /*
1083      * Removes any pending events for the specified source object.
1084      * If removeAllEvents parameter is <code>true</code> then all
1085      * events for the specified source object are removed, if it
1086      * is <code>false</code> then <code>SequencedEvent</code>, <code>SentEvent</code>,
1087      * <code>FocusEvent</code>, <code>WindowEvent</code>, <code>KeyEvent</code>,
1088      * and <code>InputMethodEvent</code> are kept in the queue, but all other
1089      * events are removed.
1090      *
1091      * This method is normally called by the source's
1092      * <code>removeNotify</code> method.
1093      */
1094     final void removeSourceEvents(Object source, boolean removeAllEvents) {
1095         SunToolkit.flushPendingEvents();
1096         pushPopLock.lock();
1097         try {
1098             for (int i = 0; i < NUM_PRIORITIES; i++) {
1099                 EventQueueItem entry = queues[i].head;
1100                 EventQueueItem prev = null;
1101                 while (entry != null) {
1102                     if ((entry.event.getSource() == source)
1103                         && (removeAllEvents
1104                             || ! (entry.event instanceof SequencedEvent
1105                                   || entry.event instanceof SentEvent
1106                                   || entry.event instanceof FocusEvent
1107                                   || entry.event instanceof WindowEvent
1108                                   || entry.event instanceof KeyEvent
1109                                   || entry.event instanceof InputMethodEvent)))
1110                     {
1111                         if (entry.event instanceof SequencedEvent) {
1112                             ((SequencedEvent)entry.event).dispose();
1113                         }
1114                         if (entry.event instanceof SentEvent) {
1115                             ((SentEvent)entry.event).dispose();
1116                         }
1117                         if (prev == null) {
1118                             queues[i].head = entry.next;
1119                         } else {
1120                             prev.next = entry.next;
1121                         }
1122                         uncacheEQItem(entry);
1123                     } else {
1124                         prev = entry;
1125                     }
1126                     entry = entry.next;
1127                 }
1128                 queues[i].tail = prev;
1129             }
1130         } finally {
1131             pushPopLock.unlock();
1132         }
1133     }
1134 
1135     static void setCurrentEventAndMostRecentTime(AWTEvent e) {
1136         Toolkit.getEventQueue().setCurrentEventAndMostRecentTimeImpl(e);
1137     }
1138     private void setCurrentEventAndMostRecentTimeImpl(AWTEvent e) {
1139         pushPopLock.lock();
1140         try {
1141             if (Thread.currentThread() != dispatchThread) {
1142                 return;
1143             }
1144 
1145             currentEvent = new WeakReference(e);
1146 
1147             // This series of 'instanceof' checks should be replaced with a
1148             // polymorphic type (for example, an interface which declares a
1149             // getWhen() method). However, this would require us to make such
1150             // a type public, or to place it in sun.awt. Both of these approaches
1151             // have been frowned upon. So for now, we hack.
1152             //
1153             // In tiger, we will probably give timestamps to all events, so this
1154             // will no longer be an issue.
1155             long mostRecentEventTime2 = Long.MIN_VALUE;
1156             if (e instanceof InputEvent) {
1157                 InputEvent ie = (InputEvent)e;
1158                 mostRecentEventTime2 = ie.getWhen();
1159             } else if (e instanceof InputMethodEvent) {
1160                 InputMethodEvent ime = (InputMethodEvent)e;
1161                 mostRecentEventTime2 = ime.getWhen();
1162             } else if (e instanceof ActionEvent) {
1163                 ActionEvent ae = (ActionEvent)e;
1164                 mostRecentEventTime2 = ae.getWhen();
1165             } else if (e instanceof InvocationEvent) {
1166                 InvocationEvent ie = (InvocationEvent)e;
1167                 mostRecentEventTime2 = ie.getWhen();
1168             }
1169             mostRecentEventTime = Math.max(mostRecentEventTime, mostRecentEventTime2);
1170         } finally {
1171             pushPopLock.unlock();
1172         }
1173     }
1174 
1175     /**
1176      * Causes <code>runnable</code> to have its <code>run</code>
1177      * method called in the {@link #isDispatchThread dispatch thread} of
1178      * {@link Toolkit#getSystemEventQueue the system EventQueue}.
1179      * This will happen after all pending events are processed.
1180      *
1181      * @param runnable  the <code>Runnable</code> whose <code>run</code>
1182      *                  method should be executed
1183      *                  asynchronously in the
1184      *                  {@link #isDispatchThread event dispatch thread}
1185      *                  of {@link Toolkit#getSystemEventQueue the system EventQueue}
1186      * @see             #invokeAndWait
1187      * @see             Toolkit#getSystemEventQueue
1188      * @see             #isDispatchThread
1189      * @since           1.2
1190      */
1191     public static void invokeLater(Runnable runnable) {
1192         Toolkit.getEventQueue().postEvent(
1193             new InvocationEvent(Toolkit.getDefaultToolkit(), runnable));
1194     }
1195 
1196     /**
1197      * Causes <code>runnable</code> to have its <code>run</code>
1198      * method called in the {@link #isDispatchThread dispatch thread} of
1199      * {@link Toolkit#getSystemEventQueue the system EventQueue}.
1200      * This will happen after all pending events are processed.
1201      * The call blocks until this has happened.  This method
1202      * will throw an Error if called from the
1203      * {@link #isDispatchThread event dispatcher thread}.
1204      *
1205      * @param runnable  the <code>Runnable</code> whose <code>run</code>
1206      *                  method should be executed
1207      *                  synchronously in the
1208      *                  {@link #isDispatchThread event dispatch thread}
1209      *                  of {@link Toolkit#getSystemEventQueue the system EventQueue}
1210      * @exception       InterruptedException  if any thread has
1211      *                  interrupted this thread
1212      * @exception       InvocationTargetException  if an throwable is thrown
1213      *                  when running <code>runnable</code>
1214      * @see             #invokeLater
1215      * @see             Toolkit#getSystemEventQueue
1216      * @see             #isDispatchThread
1217      * @since           1.2
1218      */
1219     public static void invokeAndWait(Runnable runnable)
1220              throws InterruptedException, InvocationTargetException {
1221 
1222         if (EventQueue.isDispatchThread()) {
1223             throw new Error("Cannot call invokeAndWait from the event dispatcher thread");
1224         }
1225 
1226         class AWTInvocationLock {}
1227         Object lock = new AWTInvocationLock();
1228 
1229         InvocationEvent event =
1230             new InvocationEvent(Toolkit.getDefaultToolkit(), runnable, lock,
1231                                 true);
1232 
1233         synchronized (lock) {
1234             Toolkit.getEventQueue().postEvent(event);
1235             while (!event.isDispatched()) {
1236                 lock.wait();
1237             }
1238         }
1239 
1240         Throwable eventThrowable = event.getThrowable();
1241         if (eventThrowable != null) {
1242             throw new InvocationTargetException(eventThrowable);
1243         }
1244     }
1245 
1246     /*
1247      * Called from PostEventQueue.postEvent to notify that a new event
1248      * appeared. First it proceeds to the EventQueue on the top of the
1249      * stack, then notifies the associated dispatch thread if it exists
1250      * or starts a new one otherwise.
1251      */
1252     private void wakeup(boolean isShutdown) {
1253         pushPopLock.lock();
1254         try {
1255             if (nextQueue != null) {
1256                 // Forward call to the top of EventQueue stack.
1257                 nextQueue.wakeup(isShutdown);
1258             } else if (dispatchThread != null) {
1259                 pushPopCond.signalAll();
1260             } else if (!isShutdown) {
1261                 initDispatchThread();
1262             }
1263         } finally {
1264             pushPopLock.unlock();
1265         }
1266     }
1267 }
1268 
1269 /**
1270  * The Queue object holds pointers to the beginning and end of one internal
1271  * queue. An EventQueue object is composed of multiple internal Queues, one
1272  * for each priority supported by the EventQueue. All Events on a particular
1273  * internal Queue have identical priority.
1274  */
1275 class Queue {
1276     EventQueueItem head;
1277     EventQueueItem tail;
1278 }
--- EOF ---