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.Lock;
50
51 import java.security.AccessControlContext;
52 import java.security.ProtectionDomain;
53
54 import sun.misc.SharedSecrets;
55 import sun.misc.JavaSecurityAccess;
56
57 /**
58 * <code>EventQueue</code> is a platform-independent class
59 * that queues events, both from the underlying peer classes
60 * and from trusted application classes.
61 * <p>
62 * It encapsulates asynchronous event dispatch machinery which
63 * extracts events from the queue and dispatches them by calling
64 * {@link #dispatchEvent(AWTEvent) dispatchEvent(AWTEvent)} method
65 * on this <code>EventQueue</code> with the event to be dispatched
66 * as an argument. The particular behavior of this machinery is
67 * implementation-dependent. The only requirements are that events
68 * which were actually enqueued to this queue (note that events
69 * being posted to the <code>EventQueue</code> can be coalesced)
70 * are dispatched:
71 * <dl>
72 * <dt> Sequentially.
73 * <dd> That is, it is not permitted that several events from
74 * this queue are dispatched simultaneously.
75 * <dt> In the same order as they are enqueued.
76 * <dd> That is, if <code>AWTEvent</code> A is enqueued
77 * to the <code>EventQueue</code> before
78 * <code>AWTEvent</code> B then event B will not be
79 * dispatched before event A.
80 * </dl>
81 * <p>
82 * Some browsers partition applets in different code bases into
83 * separate contexts, and establish walls between these contexts.
84 * In such a scenario, there will be one <code>EventQueue</code>
85 * per context. Other browsers place all applets into the same
86 * context, implying that there will be only a single, global
87 * <code>EventQueue</code> for all applets. This behavior is
88 * implementation-dependent. Consult your browser's documentation
89 * for more information.
90 * <p>
91 * For information on the threading issues of the event dispatch
92 * machinery, see <a href="doc-files/AWTThreadIssues.html#Autoshutdown"
93 * >AWT Threading Issues</a>.
94 *
95 * @author Thomas Ball
96 * @author Fred Ecks
97 * @author David Mendenhall
98 *
99 * @since 1.1
100 */
101 public class EventQueue {
102
103 // From Thread.java
104 private static int threadInitNumber;
105 private static synchronized int nextThreadNum() {
106 return threadInitNumber++;
107 }
108
109 private static final int LOW_PRIORITY = 0;
110 private static final int NORM_PRIORITY = 1;
111 private static final int HIGH_PRIORITY = 2;
112 private static final int ULTIMATE_PRIORITY = 3;
113
114 private static final int NUM_PRIORITIES = ULTIMATE_PRIORITY + 1;
115
116 /*
117 * We maintain one Queue for each priority that the EventQueue supports.
118 * That is, the EventQueue object is actually implemented as
119 * NUM_PRIORITIES queues and all Events on a particular internal Queue
120 * have identical priority. Events are pulled off the EventQueue starting
121 * with the Queue of highest priority. We progress in decreasing order
122 * across all Queues.
123 */
124 private Queue[] queues = new Queue[NUM_PRIORITIES];
125
126 /*
127 * The next EventQueue on the stack, or null if this EventQueue is
128 * on the top of the stack. If nextQueue is non-null, requests to post
129 * an event are forwarded to nextQueue.
130 */
131 private EventQueue nextQueue;
132
133 /*
134 * The previous EventQueue on the stack, or null if this is the
135 * "base" EventQueue.
136 */
137 private EventQueue previousQueue;
138
139 /*
140 * A single lock to synchronize the push()/pop() and related operations with
141 * all the EventQueues from the AppContext. Synchronization on any particular
142 * event queue(s) is not enough: we should lock the whole stack.
143 */
144 private final Lock pushPopLock;
145 private final Condition pushPopCond;
146
147 /*
148 * Dummy runnable to wake up EDT from getNextEvent() after
149 push/pop is performed
150 */
151 private final static Runnable dummyRunnable = new Runnable() {
152 public void run() {
153 }
154 };
155
156 private EventDispatchThread dispatchThread;
157
158 private final ThreadGroup threadGroup =
159 Thread.currentThread().getThreadGroup();
160 private final ClassLoader classLoader =
161 Thread.currentThread().getContextClassLoader();
162
163 /*
164 * The time stamp of the last dispatched InputEvent or ActionEvent.
165 */
166 private long mostRecentEventTime = System.currentTimeMillis();
167
168 /**
169 * The modifiers field of the current event, if the current event is an
170 * InputEvent or ActionEvent.
171 */
172 private WeakReference currentEvent;
173
174 /*
175 * Non-zero if a thread is waiting in getNextEvent(int) for an event of
176 * a particular ID to be posted to the queue.
177 */
178 private int waitForID;
179
180 private final String name = "AWT-EventQueue-" + nextThreadNum();
181
182 private static final PlatformLogger eventLog = PlatformLogger.getLogger("java.awt.event.EventQueue");
183
184 static {
185 AWTAccessor.setEventQueueAccessor(
186 new AWTAccessor.EventQueueAccessor() {
187 public Thread getDispatchThread(EventQueue eventQueue) {
188 return eventQueue.getDispatchThread();
189 }
190 public boolean isDispatchThreadImpl(EventQueue eventQueue) {
191 return eventQueue.isDispatchThreadImpl();
192 }
193 });
194 }
195
196 public EventQueue() {
197 for (int i = 0; i < NUM_PRIORITIES; i++) {
198 queues[i] = new Queue();
199 }
200 /*
201 * NOTE: if you ever have to start the associated event dispatch
202 * thread at this point, be aware of the following problem:
203 * If this EventQueue instance is created in
204 * SunToolkit.createNewAppContext() the started dispatch thread
205 * may call AppContext.getAppContext() before createNewAppContext()
206 * completes thus causing mess in thread group to appcontext mapping.
207 */
208
209 pushPopLock = (Lock)AppContext.getAppContext().get(AppContext.EVENT_QUEUE_LOCK_KEY);
210 pushPopCond = (Condition)AppContext.getAppContext().get(AppContext.EVENT_QUEUE_COND_KEY);
211 }
212
213 /**
214 * Posts a 1.1-style event to the <code>EventQueue</code>.
215 * If there is an existing event on the queue with the same ID
216 * and event source, the source <code>Component</code>'s
217 * <code>coalesceEvents</code> method will be called.
218 *
219 * @param theEvent an instance of <code>java.awt.AWTEvent</code>,
220 * or a subclass of it
221 * @throws NullPointerException if <code>theEvent</code> is <code>null</code>
222 */
223 public void postEvent(AWTEvent theEvent) {
224 SunToolkit.flushPendingEvents();
225 postEventPrivate(theEvent);
226 }
227
228 /**
229 * Posts a 1.1-style event to the <code>EventQueue</code>.
230 * If there is an existing event on the queue with the same ID
231 * and event source, the source <code>Component</code>'s
232 * <code>coalesceEvents</code> method will be called.
233 *
234 * @param theEvent an instance of <code>java.awt.AWTEvent</code>,
235 * or a subclass of it
236 */
237 private final void postEventPrivate(AWTEvent theEvent) {
238 theEvent.isPosted = true;
239 pushPopLock.lock();
240 try {
241 if (nextQueue != null) {
242 // Forward the event to the top of EventQueue stack
243 nextQueue.postEventPrivate(theEvent);
244 return;
245 }
246 if (dispatchThread == null) {
247 if (theEvent.getSource() == AWTAutoShutdown.getInstance()) {
248 return;
249 } else {
250 initDispatchThread();
251 }
252 }
253 postEvent(theEvent, getPriority(theEvent));
254 } finally {
255 pushPopLock.unlock();
256 }
257 }
258
259 private static int getPriority(AWTEvent theEvent) {
260 if (theEvent instanceof PeerEvent) {
261 PeerEvent peerEvent = (PeerEvent)theEvent;
262 if ((peerEvent.getFlags() & PeerEvent.ULTIMATE_PRIORITY_EVENT) != 0) {
263 return ULTIMATE_PRIORITY;
264 }
265 if ((peerEvent.getFlags() & PeerEvent.PRIORITY_EVENT) != 0) {
266 return HIGH_PRIORITY;
267 }
268 if ((peerEvent.getFlags() & PeerEvent.LOW_PRIORITY_EVENT) != 0) {
269 return LOW_PRIORITY;
270 }
271 }
272 int id = theEvent.getID();
273 if ((id >= PaintEvent.PAINT_FIRST) && (id <= PaintEvent.PAINT_LAST)) {
274 return LOW_PRIORITY;
275 }
276 return NORM_PRIORITY;
277 }
278
279 /**
280 * Posts the event to the internal Queue of specified priority,
281 * coalescing as appropriate.
282 *
283 * @param theEvent an instance of <code>java.awt.AWTEvent</code>,
284 * or a subclass of it
285 * @param priority the desired priority of the event
286 */
287 private void postEvent(AWTEvent theEvent, int priority) {
288 if (coalesceEvent(theEvent, priority)) {
289 return;
290 }
291
292 EventQueueItem newItem = new EventQueueItem(theEvent);
293
294 cacheEQItem(newItem);
295
296 boolean notifyID = (theEvent.getID() == this.waitForID);
297
298 if (queues[priority].head == null) {
299 boolean shouldNotify = noEvents();
300 queues[priority].head = queues[priority].tail = newItem;
301
302 if (shouldNotify) {
303 if (theEvent.getSource() != AWTAutoShutdown.getInstance()) {
304 AWTAutoShutdown.getInstance().notifyThreadBusy(dispatchThread);
305 }
306 pushPopCond.signalAll();
307 } else if (notifyID) {
308 pushPopCond.signalAll();
309 }
310 } else {
311 // The event was not coalesced or has non-Component source.
312 // Insert it at the end of the appropriate Queue.
313 queues[priority].tail.next = newItem;
314 queues[priority].tail = newItem;
315 if (notifyID) {
316 pushPopCond.signalAll();
317 }
318 }
319 }
320
321 private boolean coalescePaintEvent(PaintEvent e) {
322 ComponentPeer sourcePeer = ((Component)e.getSource()).peer;
323 if (sourcePeer != null) {
324 sourcePeer.coalescePaintEvent(e);
325 }
326 EventQueueItem[] cache = ((Component)e.getSource()).eventCache;
327 if (cache == null) {
328 return false;
329 }
330 int index = eventToCacheIndex(e);
331
332 if (index != -1 && cache[index] != null) {
333 PaintEvent merged = mergePaintEvents(e, (PaintEvent)cache[index].event);
334 if (merged != null) {
335 cache[index].event = merged;
336 return true;
337 }
338 }
339 return false;
340 }
341
342 private PaintEvent mergePaintEvents(PaintEvent a, PaintEvent b) {
343 Rectangle aRect = a.getUpdateRect();
344 Rectangle bRect = b.getUpdateRect();
345 if (bRect.contains(aRect)) {
346 return b;
347 }
348 if (aRect.contains(bRect)) {
349 return a;
350 }
351 return null;
352 }
353
354 private boolean coalesceMouseEvent(MouseEvent e) {
355 EventQueueItem[] cache = ((Component)e.getSource()).eventCache;
356 if (cache == null) {
357 return false;
358 }
359 int index = eventToCacheIndex(e);
360 if (index != -1 && cache[index] != null) {
361 cache[index].event = e;
362 return true;
363 }
364 return false;
365 }
366
367 private boolean coalescePeerEvent(PeerEvent e) {
368 EventQueueItem[] cache = ((Component)e.getSource()).eventCache;
369 if (cache == null) {
370 return false;
371 }
372 int index = eventToCacheIndex(e);
373 if (index != -1 && cache[index] != null) {
374 e = e.coalesceEvents((PeerEvent)cache[index].event);
375 if (e != null) {
376 cache[index].event = e;
377 return true;
378 } else {
379 cache[index] = null;
380 }
381 }
382 return false;
383 }
384
385 /*
386 * Should avoid of calling this method by any means
387 * as it's working time is dependant on EQ length.
388 * In the wors case this method alone can slow down the entire application
389 * 10 times by stalling the Event processing.
390 * Only here by backward compatibility reasons.
391 */
392 private boolean coalesceOtherEvent(AWTEvent e, int priority) {
393 int id = e.getID();
394 Component source = (Component)e.getSource();
395 for (EventQueueItem entry = queues[priority].head;
396 entry != null; entry = entry.next)
397 {
398 // Give Component.coalesceEvents a chance
399 if (entry.event.getSource() == source && entry.event.getID() == id) {
400 AWTEvent coalescedEvent = source.coalesceEvents(
401 entry.event, e);
402 if (coalescedEvent != null) {
403 entry.event = coalescedEvent;
404 return true;
405 }
406 }
407 }
408 return false;
409 }
410
411 private boolean coalesceEvent(AWTEvent e, int priority) {
412 if (!(e.getSource() instanceof Component)) {
413 return false;
414 }
415 if (e instanceof PeerEvent) {
416 return coalescePeerEvent((PeerEvent)e);
417 }
418 // The worst case
419 if (((Component)e.getSource()).isCoalescingEnabled()
420 && coalesceOtherEvent(e, priority))
421 {
422 return true;
423 }
424 if (e instanceof PaintEvent) {
425 return coalescePaintEvent((PaintEvent)e);
426 }
427 if (e instanceof MouseEvent) {
428 return coalesceMouseEvent((MouseEvent)e);
429 }
430 return false;
431 }
432
433 private void cacheEQItem(EventQueueItem entry) {
434 int index = eventToCacheIndex(entry.event);
435 if (index != -1 && entry.event.getSource() instanceof Component) {
436 Component source = (Component)entry.event.getSource();
437 if (source.eventCache == null) {
438 source.eventCache = new EventQueueItem[CACHE_LENGTH];
439 }
440 source.eventCache[index] = entry;
441 }
442 }
443
444 private void uncacheEQItem(EventQueueItem entry) {
445 int index = eventToCacheIndex(entry.event);
446 if (index != -1 && entry.event.getSource() instanceof Component) {
447 Component source = (Component)entry.event.getSource();
448 if (source.eventCache == null) {
449 return;
450 }
451 source.eventCache[index] = null;
452 }
453 }
454
455 private static final int PAINT = 0;
456 private static final int UPDATE = 1;
457 private static final int MOVE = 2;
458 private static final int DRAG = 3;
459 private static final int PEER = 4;
460 private static final int CACHE_LENGTH = 5;
461
462 private static int eventToCacheIndex(AWTEvent e) {
463 switch(e.getID()) {
464 case PaintEvent.PAINT:
465 return PAINT;
466 case PaintEvent.UPDATE:
467 return UPDATE;
468 case MouseEvent.MOUSE_MOVED:
469 return MOVE;
470 case MouseEvent.MOUSE_DRAGGED:
471 return DRAG;
472 default:
473 return e instanceof PeerEvent ? PEER : -1;
474 }
475 }
476
477 /**
478 * Returns whether an event is pending on any of the separate
479 * Queues.
480 * @return whether an event is pending on any of the separate Queues
481 */
482 private boolean noEvents() {
483 for (int i = 0; i < NUM_PRIORITIES; i++) {
484 if (queues[i].head != null) {
485 return false;
486 }
487 }
488
489 return true;
490 }
491
492 /**
493 * Removes an event from the <code>EventQueue</code> and
494 * returns it. This method will block until an event has
495 * been posted by another thread.
496 * @return the next <code>AWTEvent</code>
497 * @exception InterruptedException
498 * if any thread has interrupted this thread
499 */
500 public AWTEvent getNextEvent() throws InterruptedException {
501 do {
502 /*
503 * SunToolkit.flushPendingEvents must be called outside
504 * of the synchronized block to avoid deadlock when
505 * event queues are nested with push()/pop().
506 */
507 SunToolkit.flushPendingEvents();
508 pushPopLock.lock();
509 try {
510 AWTEvent event = getNextEventPrivate();
511 if (event != null) {
512 return event;
513 }
514 AWTAutoShutdown.getInstance().notifyThreadFree(dispatchThread);
515 pushPopCond.await();
516 } finally {
517 pushPopLock.unlock();
518 }
519 } while(true);
520 }
521
522 /*
523 * Must be called under the lock. Doesn't call flushPendingEvents()
524 */
525 AWTEvent getNextEventPrivate() throws InterruptedException {
526 for (int i = NUM_PRIORITIES - 1; i >= 0; i--) {
527 if (queues[i].head != null) {
528 EventQueueItem entry = queues[i].head;
529 queues[i].head = entry.next;
530 if (entry.next == null) {
531 queues[i].tail = null;
532 }
533 uncacheEQItem(entry);
534 return entry.event;
535 }
536 }
537 return null;
538 }
539
540 AWTEvent getNextEvent(int id) throws InterruptedException {
541 do {
542 /*
543 * SunToolkit.flushPendingEvents must be called outside
544 * of the synchronized block to avoid deadlock when
545 * event queues are nested with push()/pop().
546 */
547 SunToolkit.flushPendingEvents();
548 pushPopLock.lock();
549 try {
550 for (int i = 0; i < NUM_PRIORITIES; i++) {
551 for (EventQueueItem entry = queues[i].head, prev = null;
552 entry != null; prev = entry, entry = entry.next)
553 {
554 if (entry.event.getID() == id) {
555 if (prev == null) {
556 queues[i].head = entry.next;
557 } else {
558 prev.next = entry.next;
559 }
560 if (queues[i].tail == entry) {
561 queues[i].tail = prev;
562 }
563 uncacheEQItem(entry);
564 return entry.event;
565 }
566 }
567 }
568 waitForID = id;
569 pushPopCond.await();
570 waitForID = 0;
571 } finally {
572 pushPopLock.unlock();
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) {
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 ((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 }
Save This Page