JOGL.GLAutoDrawable:

    - Add: 'public void addGLEventListener(int index, GLEventListener listener)'
      Fixes previous GLWindow addition, ie public in interface and common impl. behavior.

    - Add: 'public void invoke(boolean wait, GLRunnable glRunnable)'

    - Change: 'public void display()' semantics, in regards to the GLRunnable queue

New: GLRunnable, invoke() at GLAutoDrawable
    Allows injection of GL commands from other threads, executed after the
    GLEventListener's display() notifyier by the GLAutoDrawable.

NEWT:
    - Fix EDTUTil.invokeAndWait() and Display.enqueueAndWait() impl.,
      where we only wait for the single action/event to be processed now.

JUnit: NEWT Parenting
        - Added test cases for Swing (JFrame, JPanel and COntainer) with NewtCanvasAWT
        - Added thread calling 'invoke(true, GLRunnable)'
        - start Animator ASAP

3 files changed, 121 insertions, 0 deletions

diff --git a/src/jogl/classes/com/jogamp/opengl/impl/GLDrawableHelper.java b/src/jogl/classes/com/jogamp/opengl/impl/GLDrawableHelper.java
index fcd662048..8fefe149e 100644
--- a/src/jogl/classes/com/jogamp/opengl/impl/GLDrawableHelper.java
+++ b/src/jogl/classes/com/jogamp/opengl/impl/GLDrawableHelper.java
@@ -51,6 +51,7 @@ public class GLDrawableHelper {
   private static final boolean VERBOSE = Debug.verbose();
   private static final boolean NVIDIA_CRASH_WORKAROUND = Debug.isPropertyDefined("jogl.nvidia.crash.workaround", true);
   private boolean autoSwapBufferMode = true;
+  private ArrayList glRunnables = new ArrayList(); // one shot GL tasks
 
   public GLDrawableHelper() {
   }
@@ -100,6 +101,7 @@ public class GLDrawableHelper {
     for (Iterator iter = listeners.iterator(); iter.hasNext(); ) {
       ((GLEventListener) iter.next()).display(drawable);
     }
+    execGLRunnables(drawable);
   }
 
   public void reshape(GLAutoDrawable drawable,
@@ -109,6 +111,55 @@ public class GLDrawableHelper {
     }
   }
 
+  private void execGLRunnables(GLAutoDrawable drawable) {
+    if(glRunnables.size()>0) {
+        ArrayList _glRunnables = null;
+        synchronized(glRunnables) {
+            if(glRunnables.size()>0) {
+                _glRunnables = glRunnables;
+                glRunnables = new ArrayList();
+            }
+        }
+        if(null!=_glRunnables) {
+            for (Iterator iter = _glRunnables.iterator(); iter.hasNext(); ) {
+              ((GLRunnable) iter.next()).run(drawable);
+            }
+        }
+    }
+  }
+
+  private void invokeLater(GLRunnable glRunnable) {
+    synchronized(glRunnables) {
+        glRunnables.add(glRunnable);
+        glRunnables.notifyAll();
+    }
+  }
+
+  public void invoke(boolean wait, GLRunnable glRunnable) {
+    if(glRunnable == null) {
+        return;
+    }
+    Object lock = new Object();
+    GLRunnableTask rTask = new GLRunnableTask(glRunnable, wait?lock:null/*, true*/);
+    Throwable throwable = null;
+    synchronized(lock) {
+        invokeLater(rTask);
+        if( wait ) {
+            try {
+                lock.wait();
+            } catch (InterruptedException ie) {
+                throwable = ie;
+            }
+        }
+    }
+    if(null==throwable) {
+        throwable = rTask.getThrowable();
+    }
+    if(null!=throwable) {
+        throw new RuntimeException(throwable);
+    }
+  }
+
   public void setAutoSwapBufferMode(boolean onOrOff) {
     autoSwapBufferMode = onOrOff;
   }
diff --git a/src/jogl/classes/com/jogamp/opengl/impl/GLPbufferImpl.java b/src/jogl/classes/com/jogamp/opengl/impl/GLPbufferImpl.java
index eb5e09d2f..071ac1378 100644
--- a/src/jogl/classes/com/jogamp/opengl/impl/GLPbufferImpl.java
+++ b/src/jogl/classes/com/jogamp/opengl/impl/GLPbufferImpl.java
@@ -130,10 +130,18 @@ public class GLPbufferImpl implements GLPbuffer {
     drawableHelper.addGLEventListener(listener);
   }
 
+  public void addGLEventListener(int index, GLEventListener listener) {
+    drawableHelper.addGLEventListener(index, listener);
+  }
+
   public void removeGLEventListener(GLEventListener listener) {
     drawableHelper.removeGLEventListener(listener);
   }
 
+  public void invoke(boolean wait, GLRunnable glRunnable) {
+    drawableHelper.invoke(wait, glRunnable);
+  }
+
   public void setContext(GLContext ctx) {
     context=(GLContextImpl)ctx;
   }
diff --git a/src/jogl/classes/com/jogamp/opengl/impl/GLRunnableTask.java b/src/jogl/classes/com/jogamp/opengl/impl/GLRunnableTask.java
new file mode 100644
index 000000000..a6a030c6b
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/impl/GLRunnableTask.java
@@ -0,0 +1,62 @@
+/*
+ * 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.opengl.impl;
+
+import javax.media.opengl.GLRunnable;
+import javax.media.opengl.GLAutoDrawable;
+
+/**
+ * Helper class to provide a Runnable queue implementation with a Runnable wrapper
+ * which notifies after execution for the <code>invokeAndWait()</code> semantics.
+ */
+public class GLRunnableTask implements GLRunnable {
+    GLRunnable runnable;
+    Object notifyObject;
+
+    Throwable runnableException;
+
+    public GLRunnableTask(GLRunnable runnable, Object notifyObject) {
+        this.runnable = runnable ;
+        this.notifyObject = notifyObject ;
+    }
+
+    public void run(GLAutoDrawable drawable) {
+        try {
+            runnable.run(drawable);
+        } catch (Throwable t) {
+            runnableException = t;
+        }
+        if(null != notifyObject) {
+            synchronized (notifyObject) {
+                notifyObject.notifyAll();
+            }
+        }
+    }
+
+    public Throwable getThrowable() { return runnableException; }
+}
+