@Override
public Node.PropertySet[] getPropertySets() {
final Node.PropertySet[][] props = new Node.PropertySet[1][];
Runnable runnable =
new Runnable() {
@Override
public void run() {
FormLAF.executeWithLAFLocks(
new Runnable() {
@Override
public void run() {
props[0] = component.getProperties();
}
});
}
};
if (EventQueue.isDispatchThread()) {
runnable.run();
} else {
try {
// We have made some attempts to keep initialization
// of properties outside AWT thread, but it always
// deadlocked with AWT thread for various reasons.
EventQueue.invokeAndWait(runnable);
} catch (InterruptedException iex) {
FormUtils.LOGGER.log(Level.INFO, iex.getMessage(), iex);
} catch (InvocationTargetException itex) {
FormUtils.LOGGER.log(Level.INFO, itex.getMessage(), itex);
}
}
return props[0];
}
/** invokes the given Runnable */
public void invoke(boolean wait, Runnable r) {
if (r == null) {
return;
}
if (NativeWindowFactory.isAWTAvailable()) {
initAWTReflection();
// handover to AWT MainThread ..
try {
if (((Boolean) ReflectionUtil.callMethod(null, mAWTIsDispatchThread, null))
.booleanValue()) {
r.run();
return;
}
if (wait) {
ReflectionUtil.callMethod(null, mAWTInvokeAndWait, new Object[] {r});
} else {
ReflectionUtil.callMethod(null, mAWTInvokeLater, new Object[] {r});
}
} catch (Exception e) {
throw new NativeWindowException(e);
}
return;
}
// if this main thread is not being used or
// if this is already the main thread .. just execute.
if (!isRunning() || mainThread == Thread.currentThread()) {
r.run();
return;
}
boolean doWait = wait && isRunning() && mainThread != Thread.currentThread();
Object lock = new Object();
RunnableTask rTask = new RunnableTask(r, doWait ? lock : null, true);
Throwable throwable = null;
synchronized (lock) {
invokeLater(rTask);
if (doWait) {
try {
lock.wait();
} catch (InterruptedException ie) {
throwable = ie;
}
}
}
if (null == throwable) {
throwable = rTask.getThrowable();
}
if (null != throwable) {
throw new RuntimeException(throwable);
}
}
/*
* If the result indicates that we have outstanding tasks to do,
* go ahead and run them in this thread.
*/
private static void runDelegatedTasks(SSLEngineResult result, SSLEngine engine) throws Exception {
if (result.getHandshakeStatus() == HandshakeStatus.NEED_TASK) {
Runnable runnable;
while ((runnable = engine.getDelegatedTask()) != null) {
log("\trunning delegated task...");
runnable.run();
}
HandshakeStatus hsStatus = engine.getHandshakeStatus();
if (hsStatus == HandshakeStatus.NEED_TASK) {
throw new Exception("handshake shouldn't need additional tasks");
}
log("\tnew HandshakeStatus: " + hsStatus);
}
}
/**
* This method runs the Runnable and measures how long it takes.
*
* @param r is the Runnable for the task that we want to measure
* @return the time it took to execute this task
*/
public static long time(Runnable r) {
long time = -System.currentTimeMillis();
r.run();
time += System.currentTimeMillis();
System.out.println("Took " + time + "ms");
return time;
}
private void checkResult(
SSLEngine engine,
SSLEngineResult result,
HandshakeStatus rqdHsStatus,
boolean consumed,
boolean produced)
throws Exception {
HandshakeStatus hsStatus = result.getHandshakeStatus();
if (hsStatus == HandshakeStatus.NEED_TASK) {
Runnable runnable;
while ((runnable = engine.getDelegatedTask()) != null) {
runnable.run();
}
hsStatus = engine.getHandshakeStatus();
}
if (hsStatus != rqdHsStatus) {
throw new Exception("Required " + rqdHsStatus + ", got " + hsStatus);
}
int bc = result.bytesConsumed();
int bp = result.bytesProduced();
if (consumed) {
if (bc <= 0) {
throw new Exception("Should have consumed bytes");
}
} else {
if (bc > 0) {
throw new Exception("Should not have consumed bytes");
}
}
if (produced) {
if (bp <= 0) {
throw new Exception("Should have produced bytes");
}
} else {
if (bp > 0) {
throw new Exception("Should not have produced bytes");
}
}
}
private void invokeLater(Runnable task) {
synchronized (taskWorkerLock) {
if (isRunning() && mainThread != Thread.currentThread()) {
tasks.add(task);
taskWorkerLock.notifyAll();
} else {
// if !running or isEDTThread, do it right away
task.run();
}
}
}
public void run() {
if (DEBUG) System.err.println("MainThread.run(): " + Thread.currentThread().getName());
synchronized (taskWorkerLock) {
isRunning = true;
taskWorkerLock.notifyAll();
}
while (!shouldStop) {
try {
// wait for something todo ..
synchronized (taskWorkerLock) {
while (!shouldStop && tasks.size() == 0) {
try {
taskWorkerLock.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// take over the tasks ..
if (!shouldStop && tasks.size() > 0) {
Runnable task = (Runnable) tasks.remove(0);
task.run(); // FIXME: could be run outside of lock
}
taskWorkerLock.notifyAll();
}
} catch (Throwable t) {
// handle errors ..
t.printStackTrace();
} finally {
// epilog - unlock locked stuff
}
}
if (DEBUG) System.err.println("MainThread.run(): " + Thread.currentThread().getName() + " fin");
synchronized (taskWorkerLock) {
isRunning = false;
isExit = true;
taskWorkerLock.notifyAll();
}
}