GLAutoDrawable* refinement of abstraction / generalization - API Change!

- GLAutoDrawable (compat change - recompile):
  - 'void invoke(boolean wait, GLRunnable glRunnable)' -> 'boolean invoke(boolean wait, GLRunnable glRunnable)'
    Allows notifying caller whether the task has been executed or at least enqueued.

- GLAutoDrawable add 'GLEventListener removeGLEventListener(int index)'
  - This allow one to remove a specific GLEventListener and reusing it (return value).

- GLDrawableImpl remove 'destroy()' to favor 'setRealized(false)'
  - Using more common code of GLAutoDrawableBase, i.e. GLPbufferImpl can use defaultDestroyOp().
  - Removes redundancy of methods

- GLAutoDrawableBase/Delegate
  - better 'default' names to emphasize it's purpose, adding API doc

  - includes more generic functionality
    - defaultWindowDestroyNotify()
    - defaultDestroyOp()

  - TestGLAutoDrawableDelegateNEWT demonstrates a simple example w/ all window events handled.

- Fix TestParenting01cSwingAWT's threading use (gl disturbance thread)

1 files changed, 52 insertions, 16 deletions

diff --git a/src/jogl/classes/javax/media/opengl/GLAutoDrawableDelegate.java b/src/jogl/classes/javax/media/opengl/GLAutoDrawableDelegate.java
index 992bf9fee..89d5cc4cb 100644
--- a/src/jogl/classes/javax/media/opengl/GLAutoDrawableDelegate.java
+++ b/src/jogl/classes/javax/media/opengl/GLAutoDrawableDelegate.java
@@ -28,6 +28,9 @@
  
 package javax.media.opengl;
 
+import com.jogamp.common.util.locks.LockFactory;
+import com.jogamp.common.util.locks.RecursiveLock;
+
 import jogamp.opengl.Debug;
 import jogamp.opengl.GLAutoDrawableBase;
 import jogamp.opengl.GLContextImpl;
@@ -39,11 +42,16 @@ import jogamp.opengl.GLDrawableImpl;
  * utilizing already created created {@link GLDrawable} and {@link GLContext} instances.
  * <p>
  * Since no native windowing system events are being processed, it is recommended
- * to handle at least {@link com.jogamp.newt.event.WindowListener#windowResized(com.jogamp.newt.event.WindowEvent) resize},
- * {@link com.jogamp.newt.event.WindowListener#windowDestroyNotify(com.jogamp.newt.event.WindowEvent) destroy-notify} 
- * and maybe {@link com.jogamp.newt.event.WindowListener#windowRepaint(com.jogamp.newt.event.WindowUpdateEvent) repaint}. 
- * The latter is only required if no {@link GLAnimatorControl} is being used.
- * </p> 
+ * to handle at least:
+ * <ul>
+ *   <li>{@link com.jogamp.newt.event.WindowListener#windowRepaint(com.jogamp.newt.event.WindowUpdateEvent) repaint} using {@link #defaultWindowRepaintOp()}</li>
+ *   <li>{@link com.jogamp.newt.event.WindowListener#windowResized(com.jogamp.newt.event.WindowEvent) resize} using {@link #defaultWindowResizedOp()}</li>
+ *   <li>{@link com.jogamp.newt.event.WindowListener#windowDestroyNotify(com.jogamp.newt.event.WindowEvent) destroy-notify}  using {@link #defaultWindowDestroyNotifyOp()}</li> 
+ * </ul> 
+ * </p>
+ * <p> 
+ * See example {@link com.jogamp.opengl.test.junit.jogl.acore.TestGLAutoDrawableDelegateNEWT TestGLAutoDrawableDelegateNEWT}.
+ * </p>
  */
 public class GLAutoDrawableDelegate extends GLAutoDrawableBase {
     public static final boolean DEBUG = Debug.debug("GLAutoDrawableDelegate");
@@ -52,36 +60,64 @@ public class GLAutoDrawableDelegate extends GLAutoDrawableBase {
         super((GLDrawableImpl)drawable, (GLContextImpl)context);
     }
     
-    public void defaultRepaintOp() {
-        super.defaultRepaintOp();
+    //
+    // make protected methods accessible
+    //
+    
+    public void defaultWindowRepaintOp() {
+        super.defaultWindowRepaintOp();
+    }
+    
+    public void defaultWindowResizedOp() {
+        super.defaultWindowResizedOp();
     }
     
-    public void defaultReshapeOp() {
-        super.defaultReshapeOp();
+    public void defaultWindowDestroyNotifyOp() {
+        super.defaultWindowDestroyNotifyOp();
     }
     
     //
     // Complete GLAutoDrawable
     //
     
+    private RecursiveLock lock = LockFactory.createRecursiveLock();  // instance wide lock
+
     /**
      * {@inheritDoc}
      * <p>
-     * This implementation simply removes references to drawable and context.
+     * This implementation calls {@link #defaultDestroyOp()}.
+     * </p>
+     * <p>
+     * User still needs to destroy the upstream window, which details are hidden from this aspect.
      * </p>
      */
     @Override
     public void destroy() {
-        drawable = null;
-        context = null;
+        lock.lock();
+        try {
+            defaultDestroyOp();
+        } finally {
+            lock.unlock();
+        }
     }
 
     @Override
     public void display() {
-        if( null == drawable || !drawable.isRealized() || null == context ) { return; }
-
-        // surface is locked/unlocked implicit by context's makeCurrent/release
-        helper.invokeGL(drawable, context, defaultDisplayAction, defaultInitAction);
+        if( sendDestroy ) {
+            sendDestroy=false;
+            destroy();
+            return;
+        }
+        
+        lock.lock(); // sync: context/drawable could been recreated/destroyed while animating
+        try {
+            if( null != drawable && drawable.isRealized() && null != context ) {
+                // surface is locked/unlocked implicit by context's makeCurrent/release
+                helper.invokeGL(drawable, context, defaultDisplayAction, defaultInitAction);
+            }
+        } finally {
+            lock.unlock();
+        }
     }
     
     //