summaryrefslogtreecommitdiffstats
path: root/src/newt/classes/com
diff options
context:
space:
mode:
Diffstat (limited to 'src/newt/classes/com')
-rwxr-xr-xsrc/newt/classes/com/jogamp/newt/Display.java80
-rwxr-xr-xsrc/newt/classes/com/jogamp/newt/Window.java179
-rw-r--r--src/newt/classes/com/jogamp/newt/event/NEWTEvent.java21
-rw-r--r--src/newt/classes/com/jogamp/newt/impl/event/NEWTEventTask.java54
-rw-r--r--src/newt/classes/com/jogamp/newt/opengl/GLWindow.java46
-rw-r--r--src/newt/classes/com/jogamp/newt/util/EDTUtil.java34
6 files changed, 326 insertions, 88 deletions
diff --git a/src/newt/classes/com/jogamp/newt/Display.java b/src/newt/classes/com/jogamp/newt/Display.java
index c804b3d2d..193bb26dc 100755
--- a/src/newt/classes/com/jogamp/newt/Display.java
+++ b/src/newt/classes/com/jogamp/newt/Display.java
@@ -36,6 +36,7 @@ package com.jogamp.newt;
import javax.media.nativewindow.*;
import com.jogamp.nativewindow.impl.RecursiveToolkitLock;
import com.jogamp.newt.event.*;
+import com.jogamp.newt.impl.event.*;
import com.jogamp.newt.impl.Debug;
import com.jogamp.newt.util.EDTUtil;
import java.util.*;
@@ -315,46 +316,31 @@ public abstract class Display {
private Object eventsLock = new Object();
private LinkedList/*<NEWTEvent>*/ events = new LinkedList();
- private boolean events2Wait = false;
protected void dispatchMessages() {
if(0==refCount) return; // we should not exist ..
if(!events.isEmpty()) {
- if(events2Wait) {
- synchronized(eventsLock) {
- while (!events.isEmpty()) {
- NEWTEvent e = (NEWTEvent) events.removeFirst();
- Object source = e.getSource();
- if(source instanceof Window) {
- ((Window)source).sendEvent(e);
- } else {
- throw new RuntimeException("Event source not a NEWT Window: "+source.getClass().getName()+", "+source);
- }
- }
- events2Wait = false; // clear
- eventsLock.notifyAll();
- }
- } else {
- // swap events list to free ASAP
- LinkedList/*<NEWTEvent>*/ _events = null;
- synchronized(eventsLock) {
- if(!events.isEmpty()) {
- _events = events;
- events = new LinkedList();
- }
- eventsLock.notifyAll();
+ // swap events list to free ASAP
+ LinkedList/*<NEWTEvent>*/ _events = null;
+ synchronized(eventsLock) {
+ if(!events.isEmpty()) {
+ _events = events;
+ events = new LinkedList();
}
- if( null != _events ) {
- while (!_events.isEmpty()) {
- NEWTEvent e = (NEWTEvent) _events.removeFirst();
- Object source = e.getSource();
- if(source instanceof Window) {
- ((Window)source).sendEvent(e);
- } else {
- throw new RuntimeException("Event source not a NEWT Window: "+source.getClass().getName()+", "+source);
- }
+ eventsLock.notifyAll();
+ }
+ if( null != _events ) {
+ for (Iterator iter = _events.iterator(); iter.hasNext(); ) {
+ NEWTEventTask eventTask = (NEWTEventTask) iter.next();
+ NEWTEvent event = eventTask.get();
+ Object source = event.getSource();
+ if(source instanceof Window) {
+ ((Window)source).sendEvent(event);
+ } else {
+ throw new RuntimeException("Event source not a NEWT Window: "+source.getClass().getName()+", "+source);
}
+ eventTask.notifyIssuer();
}
}
}
@@ -372,27 +358,21 @@ public abstract class Display {
}
public void enqueueEvent(boolean wait, NEWTEvent e) {
- synchronized(eventsLock) {
- if(DEBUG) {
- System.out.println("Display.enqueueEvent: START - wait "+wait+", "+e);
- }
- events2Wait = wait;
- events.addLast(e);
- }
- if(wait && !events.isEmpty()) {
+ Object lock = new Object();
+ NEWTEventTask eTask = new NEWTEventTask(e, wait?lock:null);
+ synchronized(lock) {
synchronized(eventsLock) {
- while(!events.isEmpty()) {
- try {
- eventsLock.wait();
- } catch (InterruptedException ie) {
- ie.printStackTrace();
- }
+ events.addLast(eTask);
+ eventsLock.notifyAll();
+ }
+ if( wait ) {
+ try {
+ lock.wait();
+ } catch (InterruptedException ie) {
+ throw new RuntimeException(ie);
}
}
}
- if(DEBUG) {
- System.out.println("Display.enqueueEvent: END - wait "+wait+", "+e);
- }
}
public void lock() {
diff --git a/src/newt/classes/com/jogamp/newt/Window.java b/src/newt/classes/com/jogamp/newt/Window.java
index 89c1bd146..e9289f5dc 100755
--- a/src/newt/classes/com/jogamp/newt/Window.java
+++ b/src/newt/classes/com/jogamp/newt/Window.java
@@ -42,6 +42,7 @@ import javax.media.nativewindow.*;
import com.jogamp.nativewindow.impl.RecursiveToolkitLock;
import java.util.ArrayList;
+import java.util.List;
import java.util.Iterator;
import java.lang.reflect.Method;
@@ -706,9 +707,9 @@ public abstract class Window implements NativeWindow
public void reparentWindow(NativeWindow newParent, Screen newScreen) {
if(!isDestroyed()) {
runOnEDTIfAvail(true, new ReparentAction(newParent, newScreen));
- if( isVisible() ) {
- enqueueWindowEvent(WindowEvent.EVENT_WINDOW_RESIZED); // trigger a resize/relayout to listener
- }
+ // if( isVisible() ) {
+ enqueueWindowEvent(true, WindowEvent.EVENT_WINDOW_RESIZED); // trigger a resize/relayout to listener
+ // }
}
}
@@ -974,13 +975,36 @@ public abstract class Window implements NativeWindow
private ArrayList surfaceUpdatedListeners = new ArrayList();
+ /**
+ * Appends the given {@link com.jogamp.newt.event.SurfaceUpdatedListener} to the end of
+ * the list.
+ */
public void addSurfaceUpdatedListener(SurfaceUpdatedListener l) {
+ getInnerWindow().addSurfaceUpdatedListener(-1, l);
+ }
+
+ /**
+ * Inserts the given {@link com.jogamp.newt.event.SurfaceUpdatedListener} at the
+ * specified position in the list.<br>
+
+ * @param index Position where the listener will be inserted.
+ * Should be within (0 <= index && index <= size()).
+ * An index value of -1 is interpreted as the end of the list, size().
+ * @param l The listener object to be inserted
+ * @throws IndexOutOfBoundsException If the index is not within (0 <= index && index <= size()), or -1
+ */
+ public void addSurfaceUpdatedListener(int index, SurfaceUpdatedListener l)
+ throws IndexOutOfBoundsException
+ {
if(l == null) {
return;
}
synchronized(surfaceUpdatedListeners) {
+ if(0>index) {
+ index = surfaceUpdatedListeners.size();
+ }
ArrayList newSurfaceUpdatedListeners = (ArrayList) surfaceUpdatedListeners.clone();
- newSurfaceUpdatedListeners.add(l);
+ newSurfaceUpdatedListeners.add(index, l);
surfaceUpdatedListeners = newSurfaceUpdatedListeners;
}
}
@@ -1002,7 +1026,16 @@ public abstract class Window implements NativeWindow
}
}
- public SurfaceUpdatedListener[] getSurfaceUpdatedListener() {
+ public SurfaceUpdatedListener getSurfaceUpdatedListener(int index) {
+ synchronized(surfaceUpdatedListeners) {
+ if(0>index) {
+ index = surfaceUpdatedListeners.size()-1;
+ }
+ return (SurfaceUpdatedListener) surfaceUpdatedListeners.get(index);
+ }
+ }
+
+ public SurfaceUpdatedListener[] getSurfaceUpdatedListeners() {
synchronized(surfaceUpdatedListeners) {
return (SurfaceUpdatedListener[]) surfaceUpdatedListeners.toArray();
}
@@ -1088,13 +1121,34 @@ public abstract class Window implements NativeWindow
}
+ /**
+ * Appends the given {@link com.jogamp.newt.event.MouseListener} to the end of
+ * the list.
+ */
public void addMouseListener(MouseListener l) {
+ getInnerWindow().addMouseListener(-1, l);
+ }
+
+ /**
+ * Inserts the given {@link com.jogamp.newt.event.MouseListener} at the
+ * specified position in the list.<br>
+
+ * @param index Position where the listener will be inserted.
+ * Should be within (0 <= index && index <= size()).
+ * An index value of -1 is interpreted as the end of the list, size().
+ * @param l The listener object to be inserted
+ * @throws IndexOutOfBoundsException If the index is not within (0 <= index && index <= size()), or -1
+ */
+ public void addMouseListener(int index, MouseListener l) {
if(l == null) {
return;
}
synchronized(mouseListeners) {
+ if(0>index) {
+ index = mouseListeners.size();
+ }
ArrayList newMouseListeners = (ArrayList) mouseListeners.clone();
- newMouseListeners.add(l);
+ newMouseListeners.add(index, l);
mouseListeners = newMouseListeners;
}
}
@@ -1110,6 +1164,15 @@ public abstract class Window implements NativeWindow
}
}
+ public MouseListener getMouseListener(int index) {
+ synchronized(mouseListeners) {
+ if(0>index) {
+ index = mouseListeners.size()-1;
+ }
+ return (MouseListener) mouseListeners.get(index);
+ }
+ }
+
public MouseListener[] getMouseListeners() {
synchronized(mouseListeners) {
return (MouseListener[]) mouseListeners.toArray();
@@ -1168,13 +1231,34 @@ public abstract class Window implements NativeWindow
modifiers, keyCode, keyChar) );
}
+ /**
+ * Appends the given {@link com.jogamp.newt.event.KeyListener} to the end of
+ * the list.
+ */
public void addKeyListener(KeyListener l) {
+ getInnerWindow().addKeyListener(-1, l);
+ }
+
+ /**
+ * Inserts the given {@link com.jogamp.newt.event.KeyListener} at the
+ * specified position in the list.<br>
+
+ * @param index Position where the listener will be inserted.
+ * Should be within (0 <= index && index <= size()).
+ * An index value of -1 is interpreted as the end of the list, size().
+ * @param l The listener object to be inserted
+ * @throws IndexOutOfBoundsException If the index is not within (0 <= index && index <= size()), or -1
+ */
+ public void addKeyListener(int index, KeyListener l) {
if(l == null) {
return;
}
synchronized(keyListeners) {
+ if(0>index) {
+ index = keyListeners.size();
+ }
ArrayList newKeyListeners = (ArrayList) keyListeners.clone();
- newKeyListeners.add(l);
+ newKeyListeners.add(index, l);
keyListeners = newKeyListeners;
}
}
@@ -1190,6 +1274,15 @@ public abstract class Window implements NativeWindow
}
}
+ public KeyListener getKeyListener(int index) {
+ synchronized(keyListeners) {
+ if(0>index) {
+ index = keyListeners.size()-1;
+ }
+ return (KeyListener) keyListeners.get(index);
+ }
+ }
+
public KeyListener[] getKeyListeners() {
synchronized(keyListeners) {
return (KeyListener[]) keyListeners.toArray();
@@ -1228,20 +1321,47 @@ public abstract class Window implements NativeWindow
// WindowListener/Event Support
//
protected void enqueueWindowEvent(int eventType) {
+ enqueueWindowEvent(false, eventType);
+ }
+
+ protected void enqueueWindowEvent(boolean wait, int eventType) {
WindowEvent event = new WindowEvent(eventType, this, System.currentTimeMillis());
- screen.getDisplay().enqueueEvent( event );
+ screen.getDisplay().enqueueEvent( wait, event );
// sendWindowEvent ( event ); // FIXME: Think about performance/lag .. ?
}
private ArrayList windowListeners = new ArrayList();
+ /**
+ * Appends the given {@link com.jogamp.newt.event.WindowListener} to the end of
+ * the list.
+ */
public void addWindowListener(WindowListener l) {
+ getInnerWindow().addWindowListener(-1, l);
+ }
+
+ /**
+ * Inserts the given {@link com.jogamp.newt.event.WindowListener} at the
+ * specified position in the list.<br>
+
+ * @param index Position where the listener will be inserted.
+ * Should be within (0 <= index && index <= size()).
+ * An index value of -1 is interpreted as the end of the list, size().
+ * @param l The listener object to be inserted
+ * @throws IndexOutOfBoundsException If the index is not within (0 <= index && index <= size()), or -1
+ */
+ public void addWindowListener(int index, WindowListener l)
+ throws IndexOutOfBoundsException
+ {
if(l == null) {
return;
}
synchronized(windowListeners) {
+ if(0>index) {
+ index = windowListeners.size();
+ }
ArrayList newWindowListeners = (ArrayList) windowListeners.clone();
- newWindowListeners.add(l);
+ newWindowListeners.add(index, l);
windowListeners = newWindowListeners;
}
}
@@ -1257,6 +1377,15 @@ public abstract class Window implements NativeWindow
}
}
+ public WindowListener getWindowListener(int index) {
+ synchronized(windowListeners) {
+ if(0>index) {
+ index = windowListeners.size()-1;
+ }
+ return (WindowListener) windowListeners.get(index);
+ }
+ }
+
public WindowListener[] getWindowListeners() {
synchronized(windowListeners) {
return (WindowListener[]) windowListeners.toArray();
@@ -1304,13 +1433,34 @@ public abstract class Window implements NativeWindow
private ArrayList paintListeners = new ArrayList();
+ /**
+ * Appends the given {@link com.jogamp.newt.event.PaintListener} to the end of
+ * the list.
+ */
public void addPaintListener(PaintListener l) {
+ getInnerWindow().addPaintListener(-1, l);
+ }
+
+ /**
+ * Inserts the given {@link com.jogamp.newt.event.PaintListener} at the
+ * specified position in the list.<br>
+
+ * @param index Position where the listener will be inserted.
+ * Should be within (0 <= index && index <= size()).
+ * An index value of -1 is interpreted as the end of the list, size().
+ * @param l The listener object to be inserted
+ * @throws IndexOutOfBoundsException If the index is not within (0 <= index && index <= size()), or -1
+ */
+ public void addPaintListener(int index, PaintListener l) {
if(l == null) {
return;
}
synchronized(paintListeners) {
+ if(0>index) {
+ index = paintListeners.size();
+ }
ArrayList newPaintListeners = (ArrayList) paintListeners.clone();
- newPaintListeners.add(l);
+ newPaintListeners.add(index, l);
paintListeners = newPaintListeners;
}
}
@@ -1326,6 +1476,15 @@ public abstract class Window implements NativeWindow
}
}
+ public PaintListener getPaintListener(int index) {
+ synchronized(paintListeners) {
+ if(0>index) {
+ index = paintListeners.size()-1;
+ }
+ return (PaintListener) paintListeners.get(index);
+ }
+ }
+
protected void sendPaintEvent(int eventType, int x, int y, int w, int h) {
sendPaintEvent( new PaintEvent(eventType, this, System.currentTimeMillis(), x, y, w, h) );
}
diff --git a/src/newt/classes/com/jogamp/newt/event/NEWTEvent.java b/src/newt/classes/com/jogamp/newt/event/NEWTEvent.java
index 1be3dcb3f..2cb2c5177 100644
--- a/src/newt/classes/com/jogamp/newt/event/NEWTEvent.java
+++ b/src/newt/classes/com/jogamp/newt/event/NEWTEvent.java
@@ -45,6 +45,7 @@ public class NEWTEvent extends java.util.EventObject {
private boolean isSystemEvent;
private int eventType;
private long when;
+ private Object attachment;
static final boolean DEBUG = false;
@@ -105,6 +106,7 @@ public class NEWTEvent extends java.util.EventObject {
this.isSystemEvent = evaluateIsSystemEvent(this, new Throwable());
this.eventType = eventType;
this.when = when;
+ this.attachment=null;
}
/** Indicates whether this event was produced by the system or
@@ -123,6 +125,25 @@ public class NEWTEvent extends java.util.EventObject {
return when;
}
+ /**
+ * Attach the passed object to this event.<br>
+ * If an object was previously attached, it will replaced.<br>
+ * Attachments to NEWT events allow users to pass on information
+ * from one custom listener to another, ie custom listener to listener
+ * communication.
+ * @param attachment User application specific object
+ */
+ public final void setAttachment(Object attachment) {
+ this.attachment=attachment;
+ }
+
+ /**
+ * @return The user application specific attachment, or null
+ */
+ public final Object getAttachment() {
+ return attachment;
+ }
+
public String toString() {
return "NEWTEvent[sys:"+isSystemEvent()+", source:"+getSource().getClass().getName()+", when:"+getWhen()+" d "+(System.currentTimeMillis()-getWhen())+"ms]";
}
diff --git a/src/newt/classes/com/jogamp/newt/impl/event/NEWTEventTask.java b/src/newt/classes/com/jogamp/newt/impl/event/NEWTEventTask.java
new file mode 100644
index 000000000..479c493b0
--- /dev/null
+++ b/src/newt/classes/com/jogamp/newt/impl/event/NEWTEventTask.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2010, Sven Gothel
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * * Neither the name of Sven Gothel nor the
+ * names of its contributors may be used to endorse or promote products
+ * derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL Sven Gothel BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package com.jogamp.newt.impl.event;
+
+import com.jogamp.newt.event.NEWTEvent;
+
+/**
+ * Helper class to provide a NEWTEvent queue implementation with a NEWTEvent wrapper
+ * which notifies after sending the event for the <code>invokeAndWait()</code> semantics.
+ */
+public class NEWTEventTask {
+ NEWTEvent event;
+ Object notifyObject;
+
+ public NEWTEventTask(NEWTEvent event, Object notifyObject) {
+ this.event = event ;
+ this.notifyObject = notifyObject ;
+ }
+
+ public NEWTEvent get() { return event; }
+
+ public void notifyIssuer() {
+ if(null != notifyObject) {
+ synchronized (notifyObject) {
+ notifyObject.notifyAll();
+ }
+ }
+ }
+}
+
diff --git a/src/newt/classes/com/jogamp/newt/opengl/GLWindow.java b/src/newt/classes/com/jogamp/newt/opengl/GLWindow.java
index 7a223026e..0e93fc0bd 100644
--- a/src/newt/classes/com/jogamp/newt/opengl/GLWindow.java
+++ b/src/newt/classes/com/jogamp/newt/opengl/GLWindow.java
@@ -373,8 +373,8 @@ public class GLWindow extends Window implements GLAutoDrawable {
window.sendEvent(e);
}
- public void addSurfaceUpdatedListener(SurfaceUpdatedListener l) {
- window.addSurfaceUpdatedListener(l);
+ public void addSurfaceUpdatedListener(int index, SurfaceUpdatedListener l) {
+ window.addSurfaceUpdatedListener(index, l);
}
public void removeSurfaceUpdatedListener(SurfaceUpdatedListener l) {
window.removeSurfaceUpdatedListener(l);
@@ -382,45 +382,51 @@ public class GLWindow extends Window implements GLAutoDrawable {
public void removeAllSurfaceUpdatedListener() {
window.removeAllSurfaceUpdatedListener();
}
- public SurfaceUpdatedListener[] getSurfaceUpdatedListener() {
- return window.getSurfaceUpdatedListener();
+ public SurfaceUpdatedListener getSurfaceUpdatedListener(int index) {
+ return window.getSurfaceUpdatedListener(index);
+ }
+ public SurfaceUpdatedListener[] getSurfaceUpdatedListeners() {
+ return window.getSurfaceUpdatedListeners();
}
public void surfaceUpdated(Object updater, NativeWindow window0, long when) {
window.surfaceUpdated(updater, window, when);
}
- public void addMouseListener(MouseListener l) {
- window.addMouseListener(l);
+ public void addMouseListener(int index, MouseListener l) {
+ window.addMouseListener(index, l);
}
-
public void removeMouseListener(MouseListener l) {
window.removeMouseListener(l);
}
-
+ public MouseListener getMouseListener(int index) {
+ return window.getMouseListener(index);
+ }
public MouseListener[] getMouseListeners() {
return window.getMouseListeners();
}
- public void addKeyListener(KeyListener l) {
- window.addKeyListener(l);
+ public void addKeyListener(int index, KeyListener l) {
+ window.addKeyListener(index, l);
}
-
public void removeKeyListener(KeyListener l) {
window.removeKeyListener(l);
}
-
+ public KeyListener getKeyListener(int index) {
+ return window.getKeyListener(index);
+ }
public KeyListener[] getKeyListeners() {
return window.getKeyListeners();
}
- public void addWindowListener(WindowListener l) {
- window.addWindowListener(l);
+ public void addWindowListener(int index, WindowListener l) {
+ window.addWindowListener(index, l);
}
-
public void removeWindowListener(WindowListener l) {
window.removeWindowListener(l);
}
-
+ public WindowListener getWindowListener(int index) {
+ return window.getWindowListener(index);
+ }
public WindowListener[] getWindowListeners() {
return window.getWindowListeners();
}
@@ -473,10 +479,18 @@ public class GLWindow extends Window implements GLAutoDrawable {
helper.addGLEventListener(listener);
}
+ public void addGLEventListener(int index, GLEventListener listener) {
+ helper.addGLEventListener(index, listener);
+ }
+
public void removeGLEventListener(GLEventListener listener) {
helper.removeGLEventListener(listener);
}
+ public void invoke(boolean wait, GLRunnable glRunnable) {
+ helper.invoke(wait, glRunnable);
+ }
+
public void display() {
display(false);
}
diff --git a/src/newt/classes/com/jogamp/newt/util/EDTUtil.java b/src/newt/classes/com/jogamp/newt/util/EDTUtil.java
index 235132460..2e339fd45 100644
--- a/src/newt/classes/com/jogamp/newt/util/EDTUtil.java
+++ b/src/newt/classes/com/jogamp/newt/util/EDTUtil.java
@@ -36,6 +36,7 @@
package com.jogamp.newt.util;
+import com.jogamp.common.util.RunnableTask;
import com.jogamp.newt.Display;
import com.jogamp.newt.impl.Debug;
import java.util.*;
@@ -107,10 +108,7 @@ public class EDTUtil {
return null!=edt && edt.isRunning() ;
}
- public void invokeLater(Runnable task) {
- if(task == null) {
- return;
- }
+ private void invokeLater(Runnable task) {
synchronized(edtLock) {
if(null!=edt && edt.isRunning() && edt != Thread.currentThread() ) {
tasks.add(task);
@@ -122,21 +120,33 @@ public class EDTUtil {
}
}
- public void invokeAndWait(Runnable task) {
- invoke(true, task);
- }
-
public void invoke(boolean wait, Runnable task) {
if(task == null) {
return;
}
- invokeLater(task);
- if(wait) {
- waitOnWorker();
+ boolean doWait = wait && null!=edt && edt.isRunning() && edt != Thread.currentThread();
+ Object lock = new Object();
+ RunnableTask rTask = new RunnableTask(task, 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);
}
}
- public void waitOnWorker() {
+ public void waitUntilIdle() {
synchronized(edtLock) {
if(null!=edt && edt.isRunning() && tasks.size()>0 && edt != Thread.currentThread() ) {
try {
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-15 19:46:39 +0000