Relocated RecursiveToolkitLock -> gluegen ; NEWT AWTParentWindowAdapter fix & WindowImpl debug change ; Add NEWT/AWT unit test 1 frame - 2 NewtCanvasAWT

Relocated RecursiveToolkitLock -> gluegen
    com.jogamp.nativewindow.impl.RecursiveToolkitLock -> com.jogamp.common.util.RecursiveToolkitLock

NEWT AWTParentWindowAdapter fix
    - minimize action if status unchanged
    - added missing isValid() condition before runOnEDT..

NEWT WindowImpl:
    - debug output only if action triggered (resize/visible)

Add NEWT/AWT unit test 1 frame - 2 NewtCanvasAWT
    - Testing case where AWTParentWindowAdapter provokes both
      GLWindow instances to resize/visible

2 files changed, 221 insertions, 281 deletions

diff --git a/src/junit/com/jogamp/test/junit/nativewindow/TestRecursiveToolkitLockCORE.java b/src/junit/com/jogamp/test/junit/nativewindow/TestRecursiveToolkitLockCORE.java
deleted file mode 100644
index 7da448363..000000000
--- a/src/junit/com/jogamp/test/junit/nativewindow/TestRecursiveToolkitLockCORE.java
+++ /dev/null
@@ -1,281 +0,0 @@
-/**
- * Copyright 2010 JogAmp Community. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without modification, are
- * permitted provided that the following conditions are met:
- * 
- *    1. Redistributions of source code must retain the above copyright notice, this list of
- *       conditions and the following disclaimer.
- * 
- *    2. 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.
- * 
- * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``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 JogAmp Community OR
- * CONTRIBUTORS 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.
- * 
- * The views and conclusions contained in the software and documentation are those of the
- * authors and should not be interpreted as representing official policies, either expressed
- * or implied, of JogAmp Community.
- */
- 
-package com.jogamp.test.junit.nativewindow;
-
-import java.lang.reflect.*;
-import java.io.IOException;
-
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.After;
-import org.junit.AfterClass;
-import org.junit.Test;
-
-import com.jogamp.nativewindow.impl.RecursiveToolkitLock;
-
-public class TestRecursiveToolkitLockCORE {
-
-    static final int YIELD_NONE = 0;
-    static final int YIELD_YIELD = 1;
-    static final int YIELD_SLEEP = 2;
-
-    static void yield(int mode) {
-        switch(mode) {
-            case YIELD_YIELD:
-                Thread.yield();
-                break;
-            case YIELD_SLEEP:
-                try {
-                    Thread.sleep(20);
-                } catch (InterruptedException ie) {
-                    ie.printStackTrace();
-                }
-                break;
-            default:
-                break;
-        }
-
-    }
-
-    static class LockedObject {
-        static final boolean DEBUG = false;
-
-        public LockedObject() {
-            locker = new RecursiveToolkitLock();
-            actionCounter = 0;
-        }
-
-        public final void action1Direct(int l, int yieldMode) {
-            if(DEBUG) {
-                System.err.print("<a1");
-            }
-            lock();
-            try {
-                if(DEBUG) {
-                    System.err.print("+");
-                }
-                while(l>0) l--;
-                actionCounter++;
-                yield(yieldMode);
-            } finally {
-                if(DEBUG) {
-                    System.err.print("-");
-                }
-                unlock();
-                if(DEBUG) {
-                    System.err.println(">");
-                }
-            }
-        }
-
-        class Action2 implements Runnable {
-            int l, yieldMode;
-            Action2(int l, int yieldMode) {
-                this.l=l;
-                this.yieldMode=yieldMode;
-            }
-            public void run() {
-                if(DEBUG) {
-                    System.err.print("[a2");
-                }
-                lock();
-                try {
-                    if(DEBUG) {
-                        System.err.print("+");
-                    }
-                    while(l>0) l--;
-                    actionCounter++;
-                    yield(yieldMode);
-                } finally {
-                    if(DEBUG) {
-                        System.err.print("-");
-                    }
-                    unlock();
-                    if(DEBUG) {
-                        System.err.println("]");
-                    }
-                }
-            }
-        }
-
-        public final void action2Deferred(int l, int yieldMode) {
-            Thread thread = new Thread(new Action2(l, yieldMode), Thread.currentThread()+"-action2Deferred");
-            thread.start();
-        }
-
-        public final void lock() {
-            locker.lock();
-        }
-
-        public final void unlock() {
-            locker.unlock();
-        }
-
-        public final boolean isLocked() {
-            return locker.isLocked();
-        }
-
-        RecursiveToolkitLock locker;
-        int actionCounter;
-    }
-
-    interface LockedObjectIf extends Runnable {
-        void stop();
-        boolean isStopped();
-        int remaining();
-    }
-
-    class LockedObjectAction1 implements LockedObjectIf {
-        boolean shouldStop;
-        boolean stopped;
-        LockedObject lo;
-        volatile int loops;
-        int iloops;
-        int yieldMode;
-
-        public LockedObjectAction1(LockedObject lo, int loops, int iloops, int yieldMode) {
-            this.lo = lo;
-            this.loops = loops;
-            this.iloops = iloops;
-            this.shouldStop = false;
-            this.stopped = false;
-            this.yieldMode = yieldMode;
-        }
-
-        public final synchronized void stop() {
-            shouldStop = true;
-        }
-
-        public final synchronized boolean isStopped() {
-            return stopped;
-        }
-
-        public final int remaining() {
-            return loops;
-        }
-
-        public void run() {
-            while(!shouldStop && loops>0) {
-                lo.action1Direct(iloops, yieldMode);
-                lo.action2Deferred(iloops, yieldMode);
-                loops--;
-            }
-            synchronized(this) {
-                stopped = true;
-                notifyAll();
-            }
-        }
-    }
-
-    protected void testLockedObjectImpl(int threadNum, int loops, int iloops, int yieldMode) throws InterruptedException {
-        LockedObject lo = new LockedObject();
-        LockedObjectIf[] runners = new LockedObjectIf[threadNum];
-        Thread[] threads = new Thread[threadNum];
-        int i;
-
-        for(i=0; i<threadNum; i++) {
-            runners[i] = new LockedObjectAction1(lo, loops, iloops, yieldMode);
-            threads[i] = new Thread( runners[i], Thread.currentThread()+"-ActionThread-"+i+"/"+threadNum);
-            threads[i].start();
-        }
-
-        int active;
-        do {
-            active = threadNum;
-            for(i=0; i<threadNum; i++) {
-                if(runners[i].isStopped()) {
-                    active--;
-                }
-            }
-            yield(yieldMode);
-        } while(0<active);
-    }
-
-    // @Test
-    public void testLockedObjectThreading1x100() throws InterruptedException {
-        System.err.println("++++ TestRecursiveToolkitLockCORE.testLockedObjectThreading1x100");
-        testLockedObjectImpl(1, 100, 100, YIELD_NONE);
-        System.err.println("---- TestRecursiveToolkitLockCORE.testLockedObjectThreading1x100");
-    }
-
-    @Test
-    public void testLockedObjectThreading200x200Yield() throws InterruptedException {
-        System.err.println("++++ TestRecursiveToolkitLockCORE.testLockedObjectThreading200x200-Yield");
-        testLockedObjectImpl(200, 200, 100, YIELD_YIELD);
-        System.err.println("---- TestRecursiveToolkitLockCORE.testLockedObjectThreading200x200-Yield");
-    }
-
-    // @Test
-    public void testLockedObjectThreading200x200Sleep() throws InterruptedException {
-        System.err.println("++++ TestRecursiveToolkitLockCORE.testLockedObjectThreading200x200-Sleep");
-        testLockedObjectImpl(200, 200, 100, YIELD_SLEEP);
-        System.err.println("---- TestRecursiveToolkitLockCORE.testLockedObjectThreading200x200-Sleep");
-    }
-
-    @Test
-    public void testLockedObjectThreading200x200None() throws InterruptedException {
-        System.err.println("++++ TestRecursiveToolkitLockCORE.testLockedObjectThreading200x200-None");
-        testLockedObjectImpl(200, 200, 100, YIELD_NONE);
-        System.err.println("---- TestRecursiveToolkitLockCORE.testLockedObjectThreading200x200-None");
-    }
-
-    static int atoi(String a) {
-        int i=0;
-        try {
-            i = Integer.parseInt(a);
-        } catch (Exception ex) { ex.printStackTrace(); }
-        return i;
-    }
-
-    public static void main(String args[]) throws IOException {
-        /*for(int i=0; i<args.length; i++) {
-            if(args[i].equals("-time")) {
-                durationPerTest = atoi(args[++i]);
-            }
-        }
-        System.out.println("durationPerTest: "+durationPerTest);
-        */
-        String tstname = TestRecursiveToolkitLockCORE.class.getName();
-        /*
-        org.apache.tools.ant.taskdefs.optional.junit.JUnitTestRunner.main(new String[] {
-            tstname,
-            "filtertrace=true",
-            "haltOnError=false",
-            "haltOnFailure=false",
-            "showoutput=true",
-            "outputtoformatters=true",
-            "logfailedtests=true",
-            "logtestlistenerevents=true",
-            "formatter=org.apache.tools.ant.taskdefs.optional.junit.PlainJUnitResultFormatter",
-            "formatter=org.apache.tools.ant.taskdefs.optional.junit.XMLJUnitResultFormatter,TEST-"+tstname+".xml" } ); */
-        org.junit.runner.JUnitCore.main(tstname);
-    }
-
-}
diff --git a/src/junit/com/jogamp/test/junit/newt/parenting/TestParenting03AWT.java b/src/junit/com/jogamp/test/junit/newt/parenting/TestParenting03AWT.java
new file mode 100644
index 000000000..86900a41e
--- /dev/null
+++ b/src/junit/com/jogamp/test/junit/newt/parenting/TestParenting03AWT.java
@@ -0,0 +1,221 @@
+/**
+ * Copyright 2010 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ * 
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ * 
+ *    2. 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.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``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 JogAmp Community OR
+ * CONTRIBUTORS 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.
+ * 
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+ 
+package com.jogamp.test.junit.newt.parenting;
+
+import java.lang.reflect.*;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Test;
+
+import java.awt.Button;
+import java.awt.BorderLayout;
+import java.awt.Canvas;
+import java.awt.Frame;
+import java.awt.Dimension;
+import java.awt.Label;
+
+import javax.media.opengl.*;
+import javax.media.nativewindow.*;
+
+import com.jogamp.opengl.util.Animator;
+import com.jogamp.opengl.util.FPSAnimator;
+import com.jogamp.newt.*;
+import com.jogamp.newt.event.*;
+import com.jogamp.newt.opengl.*;
+import com.jogamp.newt.awt.NewtCanvasAWT;
+
+import java.io.IOException;
+
+import com.jogamp.test.junit.util.*;
+import com.jogamp.test.junit.jogl.demos.gl2.gears.Gears;
+
+public class TestParenting03AWT extends UITestCase {
+    static {
+        GLProfile.initSingleton();
+    }
+
+    static int width, height;
+    static long durationPerTest = 800;
+    static long waitReparent = 0;
+    static GLCapabilities glCaps;
+
+    @BeforeClass
+    public static void initClass() {
+        width  = 800;
+        height = 400;
+        glCaps = new GLCapabilities(null);
+    }
+
+    @Test
+    public void testWindowParenting1AWT2NewtChilds01() throws InterruptedException {
+        testWindowParenting1AWT2NewtChilds();
+    }
+
+    public void testWindowParenting1AWT2NewtChilds() throws InterruptedException {
+        int x = 0;
+        int y = 0;
+
+        NEWTEventFiFo eventFifo = new NEWTEventFiFo();
+
+        GLWindow glWindow1 = GLWindow.create(glCaps);
+        glWindow1.setUndecorated(true);
+        GLEventListener demo1 = new Gears();
+        setDemoFields(demo1, glWindow1, false);
+        glWindow1.addGLEventListener(demo1);
+        final GLWindow f_glWindow1 = glWindow1;
+        glWindow1.addKeyListener(new KeyAdapter() {
+            public void keyTyped(KeyEvent e) {
+                if(e.getKeyChar()=='f') {
+                    f_glWindow1.invoke(false, new GLRunnable() {
+                        public void run(GLAutoDrawable drawable) {
+                            GLWindow win = (GLWindow)drawable;
+                            win.setFullscreen(!win.isFullscreen());
+                        } });
+                }
+            }
+        });
+        GLAnimatorControl animator1 = new Animator(glWindow1);
+        animator1.start();
+
+        GLWindow glWindow2 = GLWindow.create(glCaps);
+        glWindow2.setUndecorated(true);
+        GLEventListener demo2 = new Gears();
+        setDemoFields(demo2, glWindow2, false);
+        glWindow2.addGLEventListener(demo2);
+        final GLWindow f_glWindow2 = glWindow2;
+        glWindow2.addKeyListener(new KeyAdapter() {
+            public void keyTyped(KeyEvent e) {
+                if(e.getKeyChar()=='f') {
+                    f_glWindow2.invoke(false, new GLRunnable() {
+                        public void run(GLAutoDrawable drawable) {
+                            GLWindow win = (GLWindow)drawable;
+                            win.setFullscreen(!win.isFullscreen());
+                        } });
+                }
+            }
+        });
+        GLAnimatorControl animator2 = new Animator(glWindow2);
+        animator2.start();
+
+        NewtCanvasAWT newtCanvasAWT1 = new NewtCanvasAWT(glWindow1);
+        NewtCanvasAWT newtCanvasAWT2 = new NewtCanvasAWT(glWindow2);
+
+        Frame frame1 = new Frame("AWT Parent Frame");
+        frame1.setLayout(new BorderLayout());
+        frame1.add(newtCanvasAWT1, BorderLayout.EAST);
+        frame1.add(new Label("center"), BorderLayout.CENTER);
+        frame1.add(newtCanvasAWT2, BorderLayout.WEST);
+        frame1.setLocation(0, 0);
+        frame1.setSize(width/2, height/2);
+        System.err.println("1: "+frame1);
+        frame1.pack();
+        frame1.setVisible(true);
+        System.err.println("2: "+frame1);
+
+        Assert.assertEquals(newtCanvasAWT1.getNativeWindow(),glWindow1.getParent());
+        Assert.assertEquals(newtCanvasAWT2.getNativeWindow(),glWindow2.getParent());
+
+        Assert.assertEquals(true, animator1.isAnimating());
+        Assert.assertEquals(false, animator1.isPaused());
+        Assert.assertNotNull(animator1.getThread());
+
+        Assert.assertEquals(true, animator2.isAnimating());
+        Assert.assertEquals(false, animator2.isPaused());
+        Assert.assertNotNull(animator2.getThread());
+
+        Thread.sleep(durationPerTest);
+
+        animator1.stop();
+        Assert.assertEquals(false, animator1.isAnimating());
+        Assert.assertEquals(false, animator1.isPaused());
+        Assert.assertEquals(null, animator1.getThread());
+
+        animator2.stop();
+        Assert.assertEquals(false, animator2.isAnimating());
+        Assert.assertEquals(false, animator2.isPaused());
+        Assert.assertEquals(null, animator2.getThread());
+
+        frame1.dispose();
+        glWindow1.destroy(true);
+        glWindow2.destroy(true);
+    }
+
+    public static void setDemoFields(GLEventListener demo, GLWindow glWindow, boolean debug) {
+        Assert.assertNotNull(demo);
+        Assert.assertNotNull(glWindow);
+        Window window = glWindow.getWindow();
+        if(debug) {
+            MiscUtils.setFieldIfExists(demo, "glDebug", true);
+            MiscUtils.setFieldIfExists(demo, "glTrace", true);
+        }
+        if(!MiscUtils.setFieldIfExists(demo, "window", window)) {
+            MiscUtils.setFieldIfExists(demo, "glWindow", glWindow);
+        }
+    }
+
+    static int atoi(String a) {
+        int i=0;
+        try {
+            i = Integer.parseInt(a);
+        } catch (Exception ex) { ex.printStackTrace(); }
+        return i;
+    }
+
+    public static void main(String args[]) throws IOException {
+        for(int i=0; i<args.length; i++) {
+            if(args[i].equals("-time")) {
+                durationPerTest = atoi(args[++i]);
+            } else if(args[i].equals("-wait")) {
+                waitReparent = atoi(args[++i]);
+            }
+        }
+        String tstname = TestParenting03AWT.class.getName();
+        /*
+        org.apache.tools.ant.taskdefs.optional.junit.JUnitTestRunner.main(new String[] {
+            tstname,
+            "filtertrace=true",
+            "haltOnError=false",
+            "haltOnFailure=false",
+            "showoutput=true",
+            "outputtoformatters=true",
+            "logfailedtests=true",
+            "logtestlistenerevents=true",
+            "formatter=org.apache.tools.ant.taskdefs.optional.junit.PlainJUnitResultFormatter",
+            "formatter=org.apache.tools.ant.taskdefs.optional.junit.XMLJUnitResultFormatter,TEST-"+tstname+".xml" } ); */
+        org.junit.runner.JUnitCore.main(tstname);
+    }
+
+}