1 /*
2 * Copyright (c) 2000, 2014, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package java.awt;
27
28 import java.security.AccessController;
29 import java.security.PrivilegedAction;
30 import java.util.LinkedList;
31 import sun.awt.AWTAccessor;
32 import sun.awt.AppContext;
33 import sun.awt.SunToolkit;
34
35 /**
36 * A mechanism for ensuring that a series of AWTEvents are executed in a
37 * precise order, even across multiple AppContexts. The nested events will be
38 * dispatched in the order in which their wrapping SequencedEvents were
39 * constructed. The only exception to this rule is if the peer of the target of
40 * the nested event was destroyed (with a call to Component.removeNotify)
41 * before the wrapping SequencedEvent was able to be dispatched. In this case,
42 * the nested event is never dispatched.
43 *
44 * @author David Mendenhall
45 */
46 class SequencedEvent extends AWTEvent implements ActiveEvent {
47 /*
48 * serialVersionUID
49 */
50 private static final long serialVersionUID = 547742659238625067L;
51
52 private static final int ID =
53 java.awt.event.FocusEvent.FOCUS_LAST + 1;
54 private static final LinkedList<SequencedEvent> list = new LinkedList<>();
55
56 private final AWTEvent nested;
57 private AppContext appContext;
58 private boolean disposed;
59
60 private static boolean fxAppThreadIsDispatchThread;
61 private Thread fxCheckSequenceThread;
62 static {
63 AWTAccessor.setSequencedEventAccessor(new AWTAccessor.SequencedEventAccessor() {
64 public AWTEvent getNested(AWTEvent sequencedEvent) {
65 return ((SequencedEvent)sequencedEvent).nested;
66 }
67 public boolean isSequencedEvent(AWTEvent event) {
68 return event instanceof SequencedEvent;
69 }
70
71 public AWTEvent create(AWTEvent event) {
72 return new SequencedEvent(event);
73 }
74 });
75 AccessController.doPrivileged(new PrivilegedAction<Object>() {
76 public Object run() {
77 fxAppThreadIsDispatchThread =
78 "true".equals(System.getProperty("javafx.embed.singleThread"));
79 return null;
80 }
81 });
82 }
83
84 /**
85 * Constructs a new SequencedEvent which will dispatch the specified
86 * nested event.
87 *
88 * @param nested the AWTEvent which this SequencedEvent's dispatch()
89 * method will dispatch
90 */
91 public SequencedEvent(AWTEvent nested) {
92 super(nested.getSource(), ID);
93 this.nested = nested;
94 // All AWTEvents that are wrapped in SequencedEvents are (at
95 // least currently) implicitly generated by the system
96 SunToolkit.setSystemGenerated(nested);
97
98 if (fxAppThreadIsDispatchThread) {
99 fxCheckSequenceThread = new Thread() {
100 @Override
101 public void run() {
102 while(!isFirstOrDisposed()) {
103 try {
104 Thread.sleep(100);
105 } catch (InterruptedException e) {
106 break;
107 }
108 }
109 }
110 };
111 }
112 synchronized (SequencedEvent.class) {
113 list.add(this);
114 }
115 }
116
117 /**
118 * Dispatches the nested event after all previous nested events have been
119 * dispatched or disposed. If this method is invoked before all previous nested events
120 * have been dispatched, then this method blocks until such a point is
121 * reached.
122 * While waiting disposes nested events to disposed AppContext
123 *
124 * NOTE: Locking protocol. Since dispose() can get EventQueue lock,
125 * dispatch() shall never call dispose() while holding the lock on the list,
126 * as EventQueue lock is held during dispatching. The locks should be acquired
127 * in the same order.
128 */
129 public final void dispatch() {
130 try {
131 appContext = AppContext.getAppContext();
132
133 if (getFirst() != this) {
134 if (EventQueue.isDispatchThread()) {
135 if (Thread.currentThread() instanceof EventDispatchThread) {
136 EventDispatchThread edt = (EventDispatchThread)
137 Thread.currentThread();
138 edt.pumpEvents(SentEvent.ID, new Conditional() {
139 public boolean evaluate() {
140 return !SequencedEvent.this.isFirstOrDisposed();
141 }
142 });
143 } else {
144 if (fxAppThreadIsDispatchThread) {
145 fxCheckSequenceThread.start();
146 }
147 }
148 } else {
149 while(!isFirstOrDisposed()) {
150 synchronized (SequencedEvent.class) {
151 try {
152 SequencedEvent.class.wait(1000);
153 } catch (InterruptedException e) {
154 break;
155 }
156 }
157 }
158 }
159 }
160
161 if (!disposed) {
162 KeyboardFocusManager.getCurrentKeyboardFocusManager().
163 setCurrentSequencedEvent(this);
164 Toolkit.getEventQueue().dispatchEvent(nested);
165 }
166 } finally {
167 dispose();
168 }
169 }
170
171 /**
172 * true only if event exists and nested source appContext is disposed.
173 */
174 private static final boolean isOwnerAppContextDisposed(SequencedEvent se) {
175 if (se != null) {
176 Object target = se.nested.getSource();
177 if (target instanceof Component) {
178 return ((Component)target).appContext.isDisposed();
179 }
180 }
181 return false;
182 }
183
184 /**
185 * Sequenced events are dispatched in order, so we cannot dispatch
186 * until we are the first sequenced event in the queue (i.e. it's our
187 * turn). But while we wait for our turn to dispatch, the event
188 * could have been disposed for a number of reasons.
189 */
190 public final boolean isFirstOrDisposed() {
191 if (disposed) {
192 return true;
193 }
194 // getFirstWithContext can dispose this
195 return this == getFirstWithContext() || disposed;
196 }
197
198 private static final synchronized SequencedEvent getFirst() {
199 return list.getFirst();
200 }
201
202 /* Disposes all events from disposed AppContext
203 * return first valid event
204 */
205 private static final SequencedEvent getFirstWithContext() {
206 SequencedEvent first = getFirst();
207 while(isOwnerAppContextDisposed(first)) {
208 first.dispose();
209 first = getFirst();
210 }
211 return first;
212 }
213
214 /**
215 * Disposes of this instance. This method is invoked once the nested event
216 * has been dispatched and handled, or when the peer of the target of the
217 * nested event has been disposed with a call to Component.removeNotify.
218 *
219 * NOTE: Locking protocol. Since SunToolkit.postEvent can get EventQueue lock,
220 * it shall never be called while holding the lock on the list,
221 * as EventQueue lock is held during dispatching and dispatch() will get
222 * lock on the list. The locks should be acquired in the same order.
223 */
224 final void dispose() {
225 synchronized (SequencedEvent.class) {
226 if (disposed) {
227 return;
228 }
229 if (KeyboardFocusManager.getCurrentKeyboardFocusManager().
230 getCurrentSequencedEvent() == this) {
231 KeyboardFocusManager.getCurrentKeyboardFocusManager().
232 setCurrentSequencedEvent(null);
233 }
234 disposed = true;
235 }
236 // Wake myself up
237 if (appContext != null) {
238 SunToolkit.postEvent(appContext, new SentEvent());
239 }
240
241 SequencedEvent next = null;
242
243 synchronized (SequencedEvent.class) {
244 SequencedEvent.class.notifyAll();
245
246 if (list.getFirst() == this) {
247 list.removeFirst();
248
249 if (!list.isEmpty()) {
250 next = list.getFirst();
251 }
252 } else {
253 list.remove(this);
254 }
255 }
256 // Wake up waiting threads
257 if (next != null && next.appContext != null) {
258 SunToolkit.postEvent(next.appContext, new SentEvent());
259 }
260 }
261 }