1 /*
2 * Copyright (c) 2000, 2010, 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.util.LinkedList;
29 import sun.awt.AppContext;
30 import sun.awt.SunToolkit;
31
32 /**
33 * A mechanism for ensuring that a series of AWTEvents are executed in a
34 * precise order, even across multiple AppContexts. The nested events will be
35 * dispatched in the order in which their wrapping SequencedEvents were
36 * constructed. The only exception to this rule is if the peer of the target of
37 * the nested event was destroyed (with a call to Component.removeNotify)
38 * before the wrapping SequencedEvent was able to be dispatched. In this case,
39 * the nested event is never dispatched.
40 *
41 * @author David Mendenhall
42 */
43 class SequencedEvent extends AWTEvent implements ActiveEvent {
44 /*
45 * serialVersionUID
46 */
47 private static final long serialVersionUID = 547742659238625067L;
48
49 private static final int ID =
50 java.awt.event.FocusEvent.FOCUS_LAST + 1;
51 private static final LinkedList list = new LinkedList();
52
53 private final AWTEvent nested;
54 private AppContext appContext;
55 private boolean disposed;
56
57 /**
58 * Constructs a new SequencedEvent which will dispatch the specified
59 * nested event.
60 *
61 * @param nested the AWTEvent which this SequencedEvent's dispatch()
62 * method will dispatch
63 */
64 public SequencedEvent(AWTEvent nested) {
65 super(nested.getSource(), ID);
66 this.nested = nested;
67 // All AWTEvents that are wrapped in SequencedEvents are (at
68 // least currently) implicitly generated by the system
69 SunToolkit.setSystemGenerated(nested);
70 synchronized (SequencedEvent.class) {
71 list.add(this);
72 }
73 }
74
75 /**
76 * Dispatches the nested event after all previous nested events have been
77 * dispatched or disposed. If this method is invoked before all previous nested events
78 * have been dispatched, then this method blocks until such a point is
79 * reached.
80 * While waiting disposes nested events to disposed AppContext
81 *
82 * NOTE: Locking protocol. Since dispose() can get EventQueue lock,
83 * dispatch() shall never call dispose() while holding the lock on the list,
84 * as EventQueue lock is held during dispatching. The locks should be acquired
85 * in the same order.
86 */
87 public final void dispatch() {
88 try {
89 appContext = AppContext.getAppContext();
90
91 if (getFirst() != this) {
92 if (EventQueue.isDispatchThread()) {
93 EventDispatchThread edt = (EventDispatchThread)
94 Thread.currentThread();
95 edt.pumpEvents(SentEvent.ID, new Conditional() {
96 public boolean evaluate() {
97 return !SequencedEvent.this.isFirstOrDisposed();
98 }
99 });
100 } else {
101 while(!isFirstOrDisposed()) {
102 synchronized (SequencedEvent.class) {
103 try {
104 SequencedEvent.class.wait(1000);
105 } catch (InterruptedException e) {
106 break;
107 }
108 }
109 }
110 }
111 }
112
113 if (!disposed) {
114 KeyboardFocusManager.getCurrentKeyboardFocusManager().
115 setCurrentSequencedEvent(this);
116 Toolkit.getEventQueue().dispatchEvent(nested);
117 }
118 } finally {
119 dispose();
120 }
121 }
122
123 /**
124 * true only if event exists and nested source appContext is disposed.
125 */
126 private final static boolean isOwnerAppContextDisposed(SequencedEvent se) {
127 if (se != null) {
128 Object target = se.nested.getSource();
129 if (target instanceof Component) {
130 return ((Component)target).appContext.isDisposed();
131 }
132 }
133 return false;
134 }
135
136 /**
137 * Sequenced events are dispatched in order, so we cannot dispatch
138 * until we are the first sequenced event in the queue (i.e. it's our
139 * turn). But while we wait for our turn to dispatch, the event
140 * could have been disposed for a number of reasons.
141 */
142 public final boolean isFirstOrDisposed() {
143 if (disposed) {
144 return true;
145 }
146 // getFirstWithContext can dispose this
147 return this == getFirstWithContext() || disposed;
148 }
149
150 private final synchronized static SequencedEvent getFirst() {
151 return (SequencedEvent)list.getFirst();
152 }
153
154 /* Disposes all events from disposed AppContext
155 * return first valid event
156 */
157 private final static SequencedEvent getFirstWithContext() {
158 SequencedEvent first = getFirst();
159 while(isOwnerAppContextDisposed(first)) {
160 first.dispose();
161 first = getFirst();
162 }
163 return first;
164 }
165
166 /**
167 * Disposes of this instance. This method is invoked once the nested event
168 * has been dispatched and handled, or when the peer of the target of the
169 * nested event has been disposed with a call to Component.removeNotify.
170 *
171 * NOTE: Locking protocol. Since SunToolkit.postEvent can get EventQueue lock,
172 * it shall never be called while holding the lock on the list,
173 * as EventQueue lock is held during dispatching and dispatch() will get
174 * lock on the list. The locks should be acquired in the same order.
175 */
176 final void dispose() {
177 synchronized (SequencedEvent.class) {
178 if (disposed) {
179 return;
180 }
181 if (KeyboardFocusManager.getCurrentKeyboardFocusManager().
182 getCurrentSequencedEvent() == this) {
183 KeyboardFocusManager.getCurrentKeyboardFocusManager().
184 setCurrentSequencedEvent(null);
185 }
186 disposed = true;
187 }
188 // Wake myself up
189 if (appContext != null) {
190 SunToolkit.postEvent(appContext, new SentEvent());
191 }
192
193 SequencedEvent next = null;
194
195 synchronized (SequencedEvent.class) {
196 SequencedEvent.class.notifyAll();
197
198 if (list.getFirst() == this) {
199 list.removeFirst();
200
201 if (!list.isEmpty()) {
202 next = (SequencedEvent)list.getFirst();
203 }
204 } else {
205 list.remove(this);
206 }
207 }
208 // Wake up waiting threads
209 if (next != null && next.appContext != null) {
210 SunToolkit.postEvent(next.appContext, new SentEvent());
211 }
212 }
213 }