HiDPI AWT/NEWT: Propagate AWT enforced pixelScale via setSurfaceScale() blocking native change by monitor-pixelScale (Windows, X11)

2 files changed, 705 insertions, 12 deletions

diff --git a/src/test/com/jogamp/opengl/test/junit/jogl/acore/TestSharedContextNewtAWTBug523.java b/src/test/com/jogamp/opengl/test/junit/jogl/acore/TestSharedContextNewtAWTBug523.java
index 7a1d48cf0..397b3696c 100644
--- a/src/test/com/jogamp/opengl/test/junit/jogl/acore/TestSharedContextNewtAWTBug523.java
+++ b/src/test/com/jogamp/opengl/test/junit/jogl/acore/TestSharedContextNewtAWTBug523.java
@@ -1,5 +1,5 @@
 /**
- * Copyright 2011 JogAmp Community. All rights reserved.
+ * Copyright 2011-2023 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:
@@ -86,16 +86,16 @@ import com.jogamp.opengl.util.Animator;
 /**
  * TestSharedContextNewtAWTBug523
  *
- * Opens a single JFrame with two OpenGL windows and sliders to adjust the view orientation.
+ * Opens a single JFrame with two OpenGL widgets and sliders to adjust the view orientation.
  *
- * Each window renders a red triangle and a blue triangle.
+ * Each OpenGL widget renders a red triangle and a blue triangle.
  * The red triangle is rendered using glBegin / glVertex / glEnd.
  * The blue triangle is rendered using vertex buffer objects.
  *
  * VAO's are not used to allow testing on OSX GL2 context!
  *
- * If static useNewt is true, then those windows are GLWindow objects in a NewtCanvasAWT.
- * If static useNewt is false, then those windows are GLCanvas objects.
+ * If static useNewt is true, then those OpenGL widgets are GLWindow objects in a NewtCanvasAWT.
+ * If static useNewt is false, then those OpenGL widgets are GLCanvas objects.
  *
  * If shareContext is true, then the two OpenGL windows are initialized with a shared context,
  * so that they share the vertex buffer and array objects and display lists.
@@ -222,6 +222,7 @@ public class TestSharedContextNewtAWTBug523 extends UITestCase {
         }
 
 
+        @Override
         public void init(final GLAutoDrawable drawable) {
             final GL2 gl2 = drawable.getGL().getGL2();
 
@@ -300,12 +301,9 @@ public class TestSharedContextNewtAWTBug523 extends UITestCase {
 
                 initializationCounter++;
             } // synchronized (this)
-
-
-            viewDistance = setupViewFrustum(gl2, canvasWidth, canvasHeight, boundsRadius, 1.0f, viewFovDegrees);
-
         }
 
+        @Override
         public void dispose(final GLAutoDrawable drawable) {
 
             synchronized (this) {
@@ -340,9 +338,16 @@ public class TestSharedContextNewtAWTBug523 extends UITestCase {
             } // synchronized (this)
         }
 
+        @Override
         public void reshape(final GLAutoDrawable drawable, final int x, final int y, final int width, final int height) {
+            System.err.println("reshape: "+canvasWidth+"x"+canvasHeight+" -> "+width+"x"+height+", [drawable pixel "+drawable.getSurfaceWidth()+"x"+drawable.getSurfaceHeight()+"]");
+            canvasWidth = width;
+            canvasHeight = height;
+            final GL2 gl2 = drawable.getGL().getGL2();
+            viewDistance = setupViewFrustum(gl2, canvasWidth, canvasHeight, boundsRadius, 1.0f, viewFovDegrees);
         }
 
+        @Override
         public void display(final GLAutoDrawable drawable) {
 
             // wait until all instances are initialized before attempting to draw using the
@@ -553,7 +558,7 @@ public class TestSharedContextNewtAWTBug523 extends UITestCase {
      * It waits until the window is closed an then attempts orderly shutdown and resource deallocation.
      */
     public void testContextSharingCreateVisibleDestroy(final boolean useNewt, final boolean shareContext) throws InterruptedException, InvocationTargetException {
-        final JFrame frame = new JFrame("Simple JOGL App for testing context sharing");
+        final JFrame frame = new JFrame("JSlider with "+(shareContext?"Shared":"NonShared")+" "+(useNewt?"NEWT":"AWT")+"-OpenGL Widget");
         final TestUtil.WindowClosingListener awtClosingListener = AWTRobotUtil.addClosingListener(frame);
 
         //
@@ -571,8 +576,8 @@ public class TestSharedContextNewtAWTBug523 extends UITestCase {
             sharedDrawable = null;
         }
 
-        final TwoTriangles eventListener1 = new TwoTriangles(640, 480, shareContext);
-        final TwoTriangles eventListener2 = new TwoTriangles(320, 480, shareContext);
+        final TwoTriangles eventListener1 = new TwoTriangles(480, 480, shareContext);
+        final TwoTriangles eventListener2 = new TwoTriangles(480, 480, shareContext);
 
         final Component openGLComponent1;
         final Component openGLComponent2;
@@ -637,6 +642,7 @@ public class TestSharedContextNewtAWTBug523 extends UITestCase {
         xAxisRotationSlider.setSnapToTicks(false);
         xAxisRotationSlider.addChangeListener(new ChangeListener() {
 
+            @Override
             public void stateChanged(final ChangeEvent e) {
                 eventListener1.setXAxisRotation(xAxisRotationSlider.getValue());
                 eventListener2.setXAxisRotation(xAxisRotationSlider.getValue());
@@ -652,6 +658,7 @@ public class TestSharedContextNewtAWTBug523 extends UITestCase {
         yAxisRotationSlider.setSnapToTicks(false);
         yAxisRotationSlider.addChangeListener(new ChangeListener() {
 
+            @Override
             public void stateChanged(final ChangeEvent e) {
                 eventListener1.setYAxisRotation(yAxisRotationSlider.getValue());
                 eventListener2.setYAxisRotation(yAxisRotationSlider.getValue());
@@ -668,6 +675,7 @@ public class TestSharedContextNewtAWTBug523 extends UITestCase {
         viewDistanceFactorSlider.setSnapToTicks(false);
         viewDistanceFactorSlider.addChangeListener(new ChangeListener() {
 
+            @Override
             public void stateChanged(final ChangeEvent e) {
                 eventListener1.setViewDistanceFactor(viewDistanceFactorSlider.getValue() / 10.0f);
                 eventListener2.setViewDistanceFactor(viewDistanceFactorSlider.getValue() / 10.0f);
@@ -731,6 +739,7 @@ public class TestSharedContextNewtAWTBug523 extends UITestCase {
 
         // make the window visible using the EDT
         SwingUtilities.invokeLater( new Runnable() {
+            @Override
             public void run() {
                 frame.pack();
                 frame.setVisible(true);
@@ -763,6 +772,7 @@ public class TestSharedContextNewtAWTBug523 extends UITestCase {
         // ask the EDT to dispose of the frame;
         // if using newt, explicitly dispose of the canvases because otherwise it seems our destroy methods are not called
         SwingUtilities.invokeLater( new Runnable() {
+            @Override
             public void run() {
                 frame.setVisible(false);
                 frame.dispose();
diff --git a/src/test/com/jogamp/opengl/test/junit/jogl/acore/TestSingleGLInJSliderNewtAWT.java b/src/test/com/jogamp/opengl/test/junit/jogl/acore/TestSingleGLInJSliderNewtAWT.java
new file mode 100644
index 000000000..63edbb8e4
--- /dev/null
+++ b/src/test/com/jogamp/opengl/test/junit/jogl/acore/TestSingleGLInJSliderNewtAWT.java
@@ -0,0 +1,683 @@
+/**
+ * Copyright 2011-2023 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.opengl.test.junit.jogl.acore;
+
+import java.awt.Component;
+import java.awt.Dimension;
+import java.awt.event.WindowAdapter;
+import java.awt.event.WindowEvent;
+import java.io.IOException;
+import java.lang.reflect.InvocationTargetException;
+import java.nio.FloatBuffer;
+import java.nio.IntBuffer;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.concurrent.Semaphore;
+import java.util.concurrent.TimeUnit;
+
+import com.jogamp.opengl.GL;
+import com.jogamp.opengl.GL2;
+import com.jogamp.opengl.GLAutoDrawable;
+import com.jogamp.opengl.GLCapabilities;
+import com.jogamp.opengl.GLEventListener;
+import com.jogamp.opengl.GLProfile;
+import com.jogamp.opengl.awt.GLCanvas;
+import com.jogamp.opengl.fixedfunc.GLMatrixFunc;
+import com.jogamp.opengl.fixedfunc.GLPointerFunc;
+import com.jogamp.opengl.glu.GLU;
+import javax.swing.Box;
+import javax.swing.BoxLayout;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JSlider;
+import javax.swing.SwingConstants;
+import javax.swing.SwingUtilities;
+import javax.swing.event.ChangeEvent;
+import javax.swing.event.ChangeListener;
+
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.FixMethodOrder;
+import org.junit.runners.MethodSorters;
+
+import com.jogamp.common.ExceptionUtils;
+import com.jogamp.common.nio.Buffers;
+import com.jogamp.newt.awt.NewtCanvasAWT;
+import com.jogamp.newt.opengl.GLWindow;
+import com.jogamp.opengl.test.junit.util.AWTRobotUtil;
+import com.jogamp.opengl.test.junit.util.TestUtil;
+import com.jogamp.opengl.test.junit.util.UITestCase;
+import com.jogamp.opengl.util.Animator;
+
+
+/**
+ * TestSingleGLInJSliderNewtAWT
+ *
+ * Opens a single JFrame with one OpenGL widget and sliders to adjust the view orientation.
+ *
+ * The OpenGL widget renders a red triangle and a blue triangle.
+ *
+ * If static useNewt is true, then those OpenGL widgets are GLWindow objects in a NewtCanvasAWT.
+ * If static useNewt is false, then those OpenGL widgets are GLCanvas objects.
+ */
+@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+public class TestSingleGLInJSliderNewtAWT extends UITestCase {
+
+    static long durationPerTest = 1000;
+
+    // This semaphore is released once each time a GLEventListener destroy method is called.
+    // The main thread waits twice on this semaphore to ensure both canvases have finished cleaning up.
+    private static Semaphore disposalCompleteSemaphore = new Semaphore(0);
+
+    @BeforeClass
+    public static void initClass() {
+        if(!GLProfile.isAvailable(GLProfile.GL2)) {
+            setTestSupported(false);
+        }
+    }
+
+    // inner class that implements the event listener
+    static class TwoTriangles implements GLEventListener {
+
+        int canvasWidth;
+        int canvasHeight;
+        private static final float boundsRadius = 2f;
+        private float viewDistance;
+        private static float viewDistanceFactor = 1.0f;
+        private float xAxisRotation;
+        private float yAxisRotation;
+        private static final float viewFovDegrees = 15f;
+
+        // Buffer objects can be shared across canvas instances, if those canvases are initialized with the same GLContext.
+        // If we run with sharedBufferObjects true, then the tests will use these shared buffer objects.
+        // If we run with sharedBufferObjects false, then each event listener allocates its own buffer objects.
+        private final int [] privateVertexBufferObjects = {0};
+        private final int [] privateIndexBufferObjects = {0};
+
+        public static int createVertexBuffer(final GL2 gl2) {
+            final FloatBuffer vertexBuffer = Buffers.newDirectFloatBuffer(18);
+            vertexBuffer.put(new float[]{
+                    1.0f, -0.5f, 0f,    // vertex 1
+                    0f, 0f, 1f,         // normal 1
+                    1.5f, -0.5f, 0f,    // vertex 2
+                    0f, 0f, 1f,         // normal 2
+                    1.0f, 0.5f, 0f,     // vertex 3
+                    0f, 0f, 1f          // normal 3
+            });
+            vertexBuffer.position(0);
+
+            final int[] vbo = { 0 };
+            gl2.glGenBuffers(1, vbo, 0);
+            gl2.glBindBuffer(GL.GL_ARRAY_BUFFER, vbo[0]);
+            gl2.glBufferData(GL.GL_ARRAY_BUFFER, vertexBuffer.capacity() * Buffers.SIZEOF_FLOAT, vertexBuffer, GL.GL_STATIC_DRAW);
+            gl2.glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
+            return vbo[0];
+        }
+        public static int createVertexIndexBuffer(final GL2 gl2) {
+            final IntBuffer indexBuffer = Buffers.newDirectIntBuffer(3);
+            indexBuffer.put(new int[]{0, 1, 2});
+            indexBuffer.position(0);
+
+            final int[] vbo = { 0 };
+            gl2.glGenBuffers(1, vbo, 0);
+            gl2.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, vbo[0]);
+            gl2.glBufferData(GL.GL_ELEMENT_ARRAY_BUFFER, indexBuffer.capacity() * Buffers.SIZEOF_INT, indexBuffer, GL.GL_STATIC_DRAW);
+            gl2.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, 0);
+            return vbo[0];
+        }
+
+        TwoTriangles (final int canvasWidth, final int canvasHeight) {
+            // instanceNum = instanceCounter++;
+            this.canvasWidth = canvasWidth;
+            this.canvasHeight = canvasHeight;
+        }
+
+        public void setXAxisRotation(final float xRot) {
+            xAxisRotation = xRot;
+        }
+
+        public void setYAxisRotation(final float yRot) {
+            yAxisRotation = yRot;
+        }
+
+        public void setViewDistanceFactor(final float factor) {
+            viewDistanceFactor = factor;
+        }
+
+
+        @Override
+        public void init(final GLAutoDrawable drawable) {
+            final GL2 gl2 = drawable.getGL().getGL2();
+
+            System.err.println("INIT GL IS: " + gl2.getClass().getName());
+
+            // Disable VSync
+            gl2.setSwapInterval(0);
+
+            // Setup the drawing area and shading mode
+            gl2.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
+
+            // the first instance of TwoTriangles initializes the shared buffer objects;
+            // synchronizing to deal with potential liveness issues if the data is initialized from one thread and used on another
+            synchronized (this) {
+                // use either the shared or private vertex buffers, as
+                System.err.println("Using local VBOs on slave 0x"+Integer.toHexString(hashCode()));
+                final int [] vertexBufferObjects = privateVertexBufferObjects;
+                final int [] indexBufferObjects = privateIndexBufferObjects;
+
+                System.err.println("Creating vertex VBO on slave 0x"+Integer.toHexString(hashCode()));
+                vertexBufferObjects[0] = createVertexBuffer(gl2);
+
+                // A check in the case that buffer sharing is enabled but context sharing is not enabled -- in that
+                // case, the buffer objects are not shareable, and the blue triangle cannot be rendereds.
+                // Furthermore, although the calls to bind and draw elements do not cause an error from glGetError
+                // when this check is removed, true blue triangle is not rendered anyways, and more importantly,
+                // I found that with my system glDrawElements causes a runtime exception 50% of the time. Executing the binds
+                // to unshareable buffers sets up glDrawElements for unpredictable crashes -- sometimes it does, sometimes not.
+                if (gl2.glIsBuffer(vertexBufferObjects[0])) {
+                    gl2.glBindBuffer(GL.GL_ARRAY_BUFFER, vertexBufferObjects[0]);
+                    //
+                    gl2.glEnableClientState(GLPointerFunc.GL_VERTEX_ARRAY);
+                    gl2.glVertexPointer(3, GL.GL_FLOAT, 6 * Buffers.SIZEOF_FLOAT, 0);
+                    //
+                    gl2.glEnableClientState(GLPointerFunc.GL_NORMAL_ARRAY);
+                    gl2.glNormalPointer(GL.GL_FLOAT, 6 * Buffers.SIZEOF_FLOAT, 3 * Buffers.SIZEOF_FLOAT);
+                } else {
+                    System.err.println("Vertex VBO is not a buffer on slave 0x"+Integer.toHexString(hashCode()));
+                }
+
+                System.err.println("Creating index VBO on slave 0x"+Integer.toHexString(hashCode()));
+                indexBufferObjects[0] = createVertexIndexBuffer(gl2);
+
+                // again, a check in the case that buffer sharing is enabled but context sharing is not enabled
+                if (gl2.glIsBuffer(indexBufferObjects[0])) {
+                    gl2.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, indexBufferObjects[0]);
+                } else {
+                    System.err.println("Index VBO is not a buffer on slave 0x"+Integer.toHexString(hashCode()));
+                }
+
+                gl2.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, 0);
+                gl2.glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
+                gl2.glDisableClientState(GLPointerFunc.GL_VERTEX_ARRAY);
+                gl2.glDisableClientState(GLPointerFunc.GL_NORMAL_ARRAY);
+            } // synchronized (this)
+        }
+
+        @Override
+        public void dispose(final GLAutoDrawable drawable) {
+
+            synchronized (this) {
+                final GL2 gl2 = drawable.getGL().getGL2();
+
+                // release shared resources
+                {
+                    // use either the shared or private vertex buffers, as
+                    int [] vertexBufferObjects;
+                    int [] indexBufferObjects;
+                    vertexBufferObjects = privateVertexBufferObjects;
+                    indexBufferObjects = privateIndexBufferObjects;
+
+                    gl2.glDeleteBuffers(1, vertexBufferObjects, 0);
+                    logAnyErrorCodes(this, gl2, "dispose.2");
+                    gl2.glDeleteBuffers(1, indexBufferObjects, 0);
+                    logAnyErrorCodes(this, gl2, "dispose.3");
+                    vertexBufferObjects[0] = 0;
+                    indexBufferObjects[0] = 0;
+                }
+
+                // release the main thread once for each disposal
+                disposalCompleteSemaphore.release();
+            } // synchronized (this)
+        }
+
+        @Override
+        public void reshape(final GLAutoDrawable drawable, final int x, final int y, final int width, final int height) {
+            System.err.println("reshape: "+canvasWidth+"x"+canvasHeight+" -> "+width+"x"+height+", [drawable pixel "+drawable.getSurfaceWidth()+"x"+drawable.getSurfaceHeight()+"]");
+            canvasWidth = width;
+            canvasHeight = height;
+            final GL2 gl2 = drawable.getGL().getGL2();
+            viewDistance = setupViewFrustum(gl2, canvasWidth, canvasHeight, boundsRadius, 1.0f, viewFovDegrees);
+        }
+
+        @Override
+        public void display(final GLAutoDrawable drawable) {
+            final GL2 gl2 = drawable.getGL().getGL2();
+            final GLU glu = new GLU();
+
+            logAnyErrorCodes(this, gl2, "display.0");
+
+            // Clear the drawing area
+            gl2.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
+
+            gl2.glViewport(0, 0, canvasWidth, canvasHeight);
+            gl2.glMatrixMode(GLMatrixFunc.GL_PROJECTION);
+            gl2.glLoadIdentity();
+            glu.gluPerspective(viewFovDegrees, (float)canvasWidth/(float)canvasHeight,
+                               viewDistance*viewDistanceFactor-boundsRadius, viewDistance*viewDistanceFactor+boundsRadius);
+
+            // Reset the current matrix to the "identity"
+            gl2.glMatrixMode(GLMatrixFunc.GL_MODELVIEW);
+            gl2.glLoadIdentity();
+
+            // draw the scene
+            gl2.glPushAttrib(GL2.GL_ALL_ATTRIB_BITS);
+            gl2.glPushMatrix();
+
+            glu.gluLookAt(0, 0, 0 + viewDistance*viewDistanceFactor, 0, 0, 0, 0, 1, 0);
+            gl2.glRotatef(xAxisRotation, 1, 0, 0);
+            gl2.glRotatef(yAxisRotation, 0, 1, 0);
+
+            gl2.glDisable(GL.GL_CULL_FACE);
+            gl2.glEnable(GL.GL_DEPTH_TEST);
+
+            logAnyErrorCodes(this, gl2, "display.1");
+
+            // draw the triangles
+            drawTwoTriangles(gl2);
+
+            gl2.glPopMatrix();
+            gl2.glPopAttrib();
+
+            // Flush all drawing operations to the graphics card
+            gl2.glFlush();
+
+            logAnyErrorCodes(this, gl2, "display.X");
+        }
+
+        public void drawTwoTriangles(final GL2 gl2) {
+
+            // draw a red triangle the old fashioned way
+            gl2.glColor3f(1f, 0f, 0f);
+            gl2.glBegin(GL.GL_TRIANGLES);
+            gl2.glVertex3d(-1.5, -0.5, 0);
+            gl2.glNormal3d(0, 0, 1);
+            gl2.glVertex3d(-0.5, -0.5, 0);
+            gl2.glNormal3d(0, 0, 1);
+            gl2.glVertex3d(-0.75, 0.5, 0);
+            gl2.glNormal3d(0, 0, 1);
+            gl2.glEnd();
+
+            logAnyErrorCodes(this, gl2, "drawTwoTriangles.1");
+
+            // draw the blue triangle using a vertex array object, sharing the vertex and index buffer objects across
+            // contexts; if context sharing is not initialized, then one window will simply have to live without a blue triangle
+            //
+            // synchronizing to deal with potential liveness issues if the data is initialized from one
+            // thread and used on another
+            boolean vboBound = false;
+            // use either the shared or private vertex buffers, as
+            int [] vertexBufferObjects;
+            int [] indexBufferObjects;
+            synchronized (this) {
+                vertexBufferObjects = privateVertexBufferObjects;
+                indexBufferObjects = privateIndexBufferObjects;
+            } // synchronized (this)
+
+            // A check in the case that buffer sharing is enabled but context sharing is not enabled -- in that
+            // case, the buffer objects are not shareable, and the blue triangle cannot be rendereds.
+            // Furthermore, although the calls to bind and draw elements do not cause an error from glGetError
+            // when this check is removed, true blue triangle is not rendered anyways, and more importantly,
+            // I found that with my system glDrawElements causes a runtime exception 50% of the time. Executing the binds
+            // to unshareable buffers sets up glDrawElements for unpredictable crashes -- sometimes it does, sometimes not.
+            final boolean isVBO1 = gl2.glIsBuffer(indexBufferObjects[0]);
+            final boolean isVBO2 = gl2.glIsBuffer(vertexBufferObjects[0]);
+            final boolean useVBO = isVBO1 && isVBO2;
+            if ( useVBO ) {
+                gl2.glBindBuffer(GL.GL_ARRAY_BUFFER, vertexBufferObjects[0]);
+                gl2.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, indexBufferObjects[0]);
+
+                gl2.glEnableClientState(GLPointerFunc.GL_VERTEX_ARRAY);
+                // gl2.glVertexPointer(3, GL2.GL_FLOAT, 6 * GLBuffers.SIZEOF_FLOAT, 0);
+                gl2.glEnableClientState(GLPointerFunc.GL_NORMAL_ARRAY);
+                // gl2.glNormalPointer(GL2.GL_FLOAT, 6 * GLBuffers.SIZEOF_FLOAT, 3 * GLBuffers.SIZEOF_FLOAT);
+                vboBound = true;
+            }
+            // System.err.println("XXX VBO bound "+vboBound+"[ vbo1 "+isVBO1+", vbo2 "+isVBO2+"]");
+
+            logAnyErrorCodes(this, gl2, "drawTwoTriangles.2");
+
+            if (vboBound) {
+                gl2.glColor3f(0f, 0f, 1f);
+                gl2.glDrawElements(GL.GL_TRIANGLES, 3, GL.GL_UNSIGNED_INT, 0);
+                gl2.glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
+                gl2.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, 0);
+                gl2.glDisableClientState(GLPointerFunc.GL_VERTEX_ARRAY);
+                gl2.glDisableClientState(GLPointerFunc.GL_NORMAL_ARRAY);
+            }
+
+            logAnyErrorCodes(this, gl2, "drawTwoTriangles.3");
+        }
+
+        public void displayChanged(final GLAutoDrawable drawable, final boolean modeChanged, final boolean deviceChanged) {
+        }
+
+    } // inner class TwoTriangles
+
+    private static final Set<String> errorSet = new HashSet<String>();
+
+    public static void logAnyErrorCodes(final Object obj, final GL gl, final String prefix) {
+        final int glError = gl.glGetError();
+        if(glError != GL.GL_NO_ERROR) {
+            final String errStr = "GL-Error: "+prefix + " on obj 0x"+Integer.toHexString(obj.hashCode())+", OpenGL error: 0x" + Integer.toHexString(glError);
+            if( errorSet.add(errStr) ) {
+                System.err.println(errStr);
+                ExceptionUtils.dumpStack(System.err);
+            }
+        }
+        final int status = gl.glCheckFramebufferStatus(GL.GL_FRAMEBUFFER);
+        if (status != GL.GL_FRAMEBUFFER_COMPLETE) {
+            final String errStr = "GL-Error: "+prefix + " on obj 0x"+Integer.toHexString(obj.hashCode())+", glCheckFramebufferStatus: 0x" + Integer.toHexString(status);
+            if( errorSet.add(errStr) ) {
+                System.err.println(errStr);
+                ExceptionUtils.dumpStack(System.err);
+            }
+        }
+    }
+
+    /**
+     * Sets the OpenGL projection matrix and front and back clipping planes for
+     * a viewport and returns the distance the camera should be placed from
+     * the center of the scene's bounding sphere such that the geometry is
+     * centered in the view frustum.
+     *
+     * @param gl2 current OpenGL context
+     * @param width width of GLDrawable
+     * @param height height of GLDrawable
+     * @param boundsRadius radius of a minimal bounding sphere of objects to be
+     *            rendered in the viewport
+     * @param zoomFactor affects how far away the camera is placed from the scene; changing the
+     *            zoom from 1.0 to 0.5 would make the scene appear half the size
+     * @param viewFovDegrees the desired field of vision for the viewport,
+     *            higher is more fish-eye
+     * @return the distance the camera should be from the center of the scenes
+     *         bounding sphere
+     */
+    public static float setupViewFrustum(final GL2 gl2, final int width, final int height, final float boundsRadius, final float zoomFactor, final float viewFovDegrees) {
+    	assert boundsRadius > 0.0f;
+    	assert zoomFactor > 0.0f;
+    	assert viewFovDegrees > 0.0f;
+
+        final GLU glu = new GLU();
+
+        final float aspectRatio = (float) width / (float) height;
+        final float boundRadiusAdjusted = boundsRadius / zoomFactor;
+        final float lowestFov = aspectRatio > 1.0f ? viewFovDegrees : aspectRatio * viewFovDegrees;
+        final float viewDist = (float) (boundRadiusAdjusted / Math.sin( (lowestFov / 2.0) * (Math.PI / 180.0) ));
+
+        gl2.glMatrixMode(GLMatrixFunc.GL_PROJECTION);
+        gl2.glLoadIdentity();
+        glu.gluPerspective(viewFovDegrees, aspectRatio,	0.1*viewDist, viewDist + boundRadiusAdjusted);
+
+        return viewDist;
+    }
+
+    @Test
+    public void test01UseAWTNotShared() throws InterruptedException, InvocationTargetException {
+        testCreateVisibleDestroy(false);
+    }
+
+    @Test
+    public void test10UseNEWTNotShared() throws InterruptedException, InvocationTargetException {
+        testCreateVisibleDestroy(true);
+    }
+
+    /**
+     * Assemble the user interface and start the animator.
+     * It waits until the window is closed an then attempts orderly shutdown and resource deallocation.
+     */
+    public void testCreateVisibleDestroy(final boolean useNewt) throws InterruptedException, InvocationTargetException {
+        final JFrame frame = new JFrame("JSlider with "+(useNewt?"NEWT":"AWT")+"-OpenGL Widget");
+        final TestUtil.WindowClosingListener awtClosingListener = AWTRobotUtil.addClosingListener(frame);
+
+        //
+        // GLDrawableFactory factory = GLDrawableFactory.getFactory(GLProfile.get(GLProfile.GL2));
+        // GLContext sharedContext = factory.getOrCreateSharedContext(factory.getDefaultDevice());
+        //
+        final GLCapabilities glCapabilities = new GLCapabilities(GLProfile.get(GLProfile.GL2));
+        glCapabilities.setSampleBuffers(true);
+        glCapabilities.setNumSamples(4);
+
+        final TwoTriangles eventListener1 = new TwoTriangles(480, 480);
+
+        final Component openGLComponent1;
+        final GLAutoDrawable openGLAutoDrawable1;
+
+        if (useNewt) {
+            final GLWindow glWindow1 = GLWindow.create(glCapabilities);
+            final NewtCanvasAWT newtCanvasAWT1 = new NewtCanvasAWT(glWindow1);
+            newtCanvasAWT1.setPreferredSize(new Dimension(eventListener1.canvasWidth, eventListener1.canvasHeight));
+            glWindow1.addGLEventListener(eventListener1);
+            //
+            openGLComponent1 = newtCanvasAWT1;
+            openGLAutoDrawable1 = glWindow1;
+        } else {
+            // Implementation using two GLCanvas instances; for GLCanvas context sharing to work, you must pass it in
+            // through the constructor; if you set it after it has no effect -- it does no harm if you initialized the ctor
+            // with the shared context, but if you didn't, it also doesn't trigger sharing
+            final GLCanvas canvas1;
+
+            canvas1 = new GLCanvas(glCapabilities);
+            canvas1.setSize(eventListener1.canvasWidth, eventListener1.canvasHeight);
+            canvas1.addGLEventListener(eventListener1);
+
+            openGLComponent1 = canvas1;
+            openGLAutoDrawable1 = canvas1;
+        }
+
+        // Create slider for x rotation.
+        // The vertically oriented slider rotates around the x axis
+        final JSlider xAxisRotationSlider = new JSlider(SwingConstants.VERTICAL, -180, 180, 1);
+        xAxisRotationSlider.setPaintTicks(false);
+        xAxisRotationSlider.setPaintLabels(false);
+        xAxisRotationSlider.setSnapToTicks(false);
+        xAxisRotationSlider.addChangeListener(new ChangeListener() {
+
+            @Override
+            public void stateChanged(final ChangeEvent e) {
+                eventListener1.setXAxisRotation(xAxisRotationSlider.getValue());
+            }
+        });
+        final JLabel xAxisRotationLabel = new JLabel("X-Axis Rotation");
+
+        // Create slider for y rotation.
+        // The horizontally oriented slider rotates around the y axis
+        final JSlider yAxisRotationSlider = new JSlider(SwingConstants.HORIZONTAL, -180, 180, 1);
+        yAxisRotationSlider.setPaintTicks(false);
+        yAxisRotationSlider.setPaintLabels(false);
+        yAxisRotationSlider.setSnapToTicks(false);
+        yAxisRotationSlider.addChangeListener(new ChangeListener() {
+
+            @Override
+            public void stateChanged(final ChangeEvent e) {
+                eventListener1.setYAxisRotation(yAxisRotationSlider.getValue());
+            }
+        });
+        final JLabel yAxisRotationLabel = new JLabel("Y-Axis Rotation");
+
+        // Create slider for view distance factor.
+        // We want a range of 0.0 to 10.0 with 0.1 increments (so we can scale down using 0.0 to 1.0).
+        // So, set JSlider to 0 to 100 and divide by 10.0 in stateChanged
+        final JSlider viewDistanceFactorSlider = new JSlider(SwingConstants.HORIZONTAL, 0, 100, 10);
+        viewDistanceFactorSlider.setPaintTicks(false);
+        viewDistanceFactorSlider.setPaintLabels(false);
+        viewDistanceFactorSlider.setSnapToTicks(false);
+        viewDistanceFactorSlider.addChangeListener(new ChangeListener() {
+
+            @Override
+            public void stateChanged(final ChangeEvent e) {
+                eventListener1.setViewDistanceFactor(viewDistanceFactorSlider.getValue() / 10.0f);
+            }
+        });
+        final JLabel viewDistanceFactorLabel = new JLabel("View Distance Factor");
+
+        // group the view distance and label into a vertical panel
+        final JPanel viewDistancePanel = new JPanel();
+        viewDistancePanel.setLayout(new BoxLayout(viewDistancePanel, BoxLayout.PAGE_AXIS));
+        viewDistancePanel.add(Box.createVerticalGlue());
+        viewDistancePanel.add(viewDistanceFactorSlider);
+        viewDistancePanel.add(viewDistanceFactorLabel);
+        viewDistancePanel.add(Box.createVerticalGlue());
+
+        // group both OpenGL canvases / windows into a horizontal panel
+        final JPanel openGLPanel = new JPanel();
+        openGLPanel.setLayout(new BoxLayout(openGLPanel, BoxLayout.LINE_AXIS));
+        openGLPanel.add(openGLComponent1);
+        openGLPanel.add(Box.createHorizontalStrut(5));
+
+        // group the open GL panel and the y-axis rotation slider into a vertical panel.
+        final JPanel canvasAndYAxisPanel = new JPanel();
+        canvasAndYAxisPanel.setLayout(new BoxLayout(canvasAndYAxisPanel, BoxLayout.PAGE_AXIS));
+        canvasAndYAxisPanel.add(openGLPanel);
+        canvasAndYAxisPanel.add(Box.createVerticalGlue());
+        canvasAndYAxisPanel.add(yAxisRotationSlider);
+        canvasAndYAxisPanel.add(yAxisRotationLabel);
+
+        // group the X-axis rotation slider and label into a horizontal panel.
+        final JPanel xAxisPanel = new JPanel();
+        xAxisPanel.setLayout(new BoxLayout(xAxisPanel, BoxLayout.LINE_AXIS));
+        xAxisPanel.add(xAxisRotationSlider);
+        xAxisPanel.add(xAxisRotationLabel);
+
+        final JPanel mainPanel = (JPanel) frame.getContentPane();
+        mainPanel.setLayout(new BoxLayout(mainPanel, BoxLayout.LINE_AXIS));
+        mainPanel.add(viewDistancePanel);
+        mainPanel.add(Box.createHorizontalGlue());
+        mainPanel.add(canvasAndYAxisPanel);
+        mainPanel.add(Box.createHorizontalGlue());
+        mainPanel.add(xAxisPanel);
+
+        final Animator animator = new Animator(Thread.currentThread().getThreadGroup());
+        animator.setUpdateFPSFrames(1, null);
+        animator.add(openGLAutoDrawable1);
+
+        final Semaphore windowOpenSemaphore = new Semaphore(0);
+        final Semaphore closingSemaphore = new Semaphore(0);
+
+        // signal the main thread when the frame is closed
+        frame.addWindowListener(new WindowAdapter() {
+
+            @Override
+            public void windowClosing(final WindowEvent e) {
+                closingSemaphore.release();
+            }
+        });
+
+        // make the window visible using the EDT
+        SwingUtilities.invokeLater( new Runnable() {
+            @Override
+            public void run() {
+                frame.pack();
+                frame.setVisible(true);
+                windowOpenSemaphore.release();
+            }
+        });
+
+        // wait for the window to be visible and start the animation
+        try {
+            final boolean windowOpened = windowOpenSemaphore.tryAcquire(5000, TimeUnit.MILLISECONDS);
+            Assert.assertEquals(true, windowOpened);
+        } catch (final InterruptedException e) {
+            System.err.println("Closing wait interrupted: " + e.getMessage());
+        }
+        animator.start();
+
+        // sleep for test duration, then request the window to close, wait for the window to close,s and stop the animation
+        try {
+            while(animator.isAnimating() && animator.getTotalFPSDuration() < durationPerTest) {
+                Thread.sleep(100);
+            }
+            AWTRobotUtil.closeWindow(frame, true, awtClosingListener, null);
+            final boolean windowClosed = closingSemaphore.tryAcquire(5000, TimeUnit.MILLISECONDS);
+            Assert.assertEquals(true, windowClosed);
+        } catch (final InterruptedException e) {
+            System.err.println("Closing wait interrupted: " + e.getMessage());
+        }
+        animator.stop();
+
+        // ask the EDT to dispose of the frame;
+        // if using newt, explicitly dispose of the canvases because otherwise it seems our destroy methods are not called
+        SwingUtilities.invokeLater( new Runnable() {
+            @Override
+            public void run() {
+                frame.setVisible(false);
+                frame.dispose();
+                if (useNewt) {
+                    ((NewtCanvasAWT)openGLComponent1).destroy();
+                }
+                closingSemaphore.release();
+            }
+        });
+
+        // wait for orderly destruction; it seems that if we share a GLContext across newt windows, bad things happen;
+        // I must be doing something wrong but I haven't figured it out yet
+        try {
+            final boolean windowsDisposed = closingSemaphore.tryAcquire(5000, TimeUnit.MILLISECONDS);
+            Assert.assertEquals(true, windowsDisposed);
+        } catch (final InterruptedException e) {
+            System.err.println("Closing wait interrupted: " + e.getMessage());
+        }
+
+        // ensure that the two OpenGL canvas' destroy methods completed successfully and released resources before we move on
+        int disposalSuccesses = 0;
+        try {
+            boolean acquired;
+            acquired = disposalCompleteSemaphore.tryAcquire(5000, TimeUnit.MILLISECONDS);
+            if (acquired){
+                disposalSuccesses++;
+            }
+        } catch (final InterruptedException e) {
+            System.err.println("Clean exit interrupted: " + e.getMessage());
+        }
+
+        Assert.assertEquals(true, disposalSuccesses == 1);
+    }
+
+    static int atoi(final String a) {
+        int i=0;
+        try {
+            i = Integer.parseInt(a);
+        } catch (final Exception ex) { ex.printStackTrace(); }
+        return i;
+    }
+
+    public static void main(final String[] args) throws IOException {
+        for(int i=0; i<args.length; i++) {
+            if(args[i].equals("-time")) {
+                if (++i < args.length) {
+                    durationPerTest = atoi(args[i]);
+                }
+            }
+        }
+        org.junit.runner.JUnitCore.main(TestSingleGLInJSliderNewtAWT.class.getName());
+    }
+
+}
+