Merge branch 'master' into stash_glyphcache

Conflicts:
	make/scripts/tests.sh
	src/jogl/classes/com/jogamp/graph/curve/OutlineShape.java
	src/jogl/classes/com/jogamp/graph/curve/Region.java
	src/jogl/classes/com/jogamp/graph/curve/opengl/GLRegion.java
	src/jogl/classes/com/jogamp/graph/curve/opengl/RegionRenderer.java
	src/jogl/classes/com/jogamp/graph/curve/opengl/Renderer.java
	src/jogl/classes/com/jogamp/graph/curve/opengl/TextRenderer.java
	src/jogl/classes/com/jogamp/graph/font/Font.java
	src/jogl/classes/com/jogamp/opengl/math/VectorUtil.java
	src/jogl/classes/jogamp/graph/curve/text/GlyphShape.java
	src/jogl/classes/jogamp/graph/curve/text/GlyphString.java
	src/jogl/classes/jogamp/graph/font/typecast/TypecastFont.java
	src/jogl/classes/jogamp/graph/font/typecast/TypecastGlyph.java
	src/jogl/classes/jogamp/graph/font/typecast/TypecastRenderer.java

6 files changed, 587 insertions, 195 deletions

diff --git a/src/jogl/classes/jogamp/opengl/awt/AWTThreadingPlugin.java b/src/jogl/classes/jogamp/opengl/awt/AWTThreadingPlugin.java
index 983f11133..72c9ac54b 100644
--- a/src/jogl/classes/jogamp/opengl/awt/AWTThreadingPlugin.java
+++ b/src/jogl/classes/jogamp/opengl/awt/AWTThreadingPlugin.java
@@ -1,22 +1,22 @@
 /*
  * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
  * Copyright (c) 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:
- * 
+ *
  * - Redistribution of source code must retain the above copyright
  *   notice, this list of conditions and the following disclaimer.
- * 
+ *
  * - Redistribution 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 Sun Microsystems, Inc. or the names of
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
- * 
+ *
  * This software is provided "AS IS," without a warranty of any kind. ALL
  * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
  * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
@@ -29,11 +29,11 @@
  * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
  * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
  * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
- * 
+ *
  * You acknowledge that this software is not designed or intended for use
  * in the design, construction, operation or maintenance of any nuclear
  * facility.
- * 
+ *
  * Sun gratefully acknowledges that this software was originally authored
  * and developed by Kenneth Bradley Russell and Christopher John Kline.
  */
@@ -44,7 +44,8 @@ import java.awt.EventQueue;
 
 import javax.media.opengl.GLException;
 
-import jogamp.common.awt.AWTEDTExecutor;
+import com.jogamp.common.util.awt.AWTEDTExecutor;
+
 import jogamp.opengl.GLWorkerThread;
 import jogamp.opengl.ThreadingImpl;
 import jogamp.opengl.ToolkitThreadingPlugin;
@@ -53,10 +54,12 @@ public class AWTThreadingPlugin implements ToolkitThreadingPlugin {
 
   public AWTThreadingPlugin() {}
 
+  @Override
   public final boolean isToolkitThread() throws GLException {
       return EventQueue.isDispatchThread();
   }
-  
+
+  @Override
   public final boolean isOpenGLThread() throws GLException {
     switch (ThreadingImpl.getMode()) {
       case ST_AWT:
@@ -82,6 +85,7 @@ public class AWTThreadingPlugin implements ToolkitThreadingPlugin {
     }
   }
 
+  @Override
   public final void invokeOnOpenGLThread(boolean wait, Runnable r) throws GLException {
     switch (ThreadingImpl.getMode()) {
       case ST_AWT:
@@ -94,11 +98,7 @@ public class AWTThreadingPlugin implements ToolkitThreadingPlugin {
         // QFT which is not allowed. For now, on X11 platforms,
         // continue to perform this work on the EDT.
         if (wait && Java2D.isOGLPipelineActive() && !ThreadingImpl.isX11()) {
-          if(wait) {
-              Java2D.invokeWithOGLContextCurrent(null, r);
-          } else {
-              
-          }
+          Java2D.invokeWithOGLContextCurrent(null, r);
         } else {
           AWTEDTExecutor.singleton.invoke(wait, r);
         }
diff --git a/src/jogl/classes/jogamp/opengl/awt/AWTTilePainter.java b/src/jogl/classes/jogamp/opengl/awt/AWTTilePainter.java
new file mode 100644
index 000000000..1c1d2350a
--- /dev/null
+++ b/src/jogl/classes/jogamp/opengl/awt/AWTTilePainter.java
@@ -0,0 +1,400 @@
+/**
+ * Copyright 2013 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 jogamp.opengl.awt;
+
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.Rectangle;
+import java.awt.RenderingHints;
+import java.awt.Shape;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.NoninvertibleTransformException;
+import java.awt.geom.Rectangle2D;
+import java.awt.image.BufferedImage;
+import java.awt.image.DataBufferInt;
+import java.io.File;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.Set;
+import java.util.Map.Entry;
+
+import javax.imageio.ImageIO;
+import javax.media.nativewindow.util.DimensionImmutable;
+import javax.media.opengl.GL;
+import javax.media.opengl.GLAutoDrawable;
+import javax.media.opengl.GLCapabilitiesImmutable;
+import javax.media.opengl.GLEventListener;
+
+import jogamp.opengl.Debug;
+
+import com.jogamp.opengl.util.TileRenderer;
+import com.jogamp.opengl.util.TileRendererBase;
+import com.jogamp.opengl.util.GLPixelBuffer.GLPixelAttributes;
+import com.jogamp.opengl.util.awt.AWTGLPixelBuffer;
+import com.jogamp.opengl.util.awt.AWTGLPixelBuffer.AWTGLPixelBufferProvider;
+
+/**
+ * Implementing AWT {@link Graphics2D} based {@link TileRenderer} <i>painter</i>.
+ * <p>
+ * Maybe utilized for AWT printing.
+ * </p>
+ */
+public class AWTTilePainter {
+    private static final boolean DEBUG_TILES = Debug.debug("TileRenderer.PNG");
+
+    public final TileRenderer renderer;
+    public final int componentCount;
+    public final double scaleMatX, scaleMatY;
+    public final int customTileWidth, customTileHeight, customNumSamples;
+    public final boolean verbose;
+
+    /** Default for OpenGL: True */
+    public boolean flipVertical;
+    /** Default for OpenGL: True */
+    public boolean originBottomLeft;
+    private AWTGLPixelBuffer tBuffer = null;
+    private BufferedImage vFlipImage = null;
+    private Graphics2D g2d = null;
+    private AffineTransform saveAT = null;
+
+    public static void dumpHintsAndScale(Graphics2D g2d) {
+          final RenderingHints rHints = g2d.getRenderingHints();
+          final Set<Entry<Object, Object>> rEntries = rHints.entrySet();
+          int count = 0;
+          for(Iterator<Entry<Object, Object>> rEntryIter = rEntries.iterator(); rEntryIter.hasNext(); count++) {
+              final Entry<Object, Object> rEntry = rEntryIter.next();
+              System.err.println("Hint["+count+"]: "+rEntry.getKey()+" -> "+rEntry.getValue());
+          }
+          final AffineTransform aTrans = g2d.getTransform();
+          if( null != aTrans ) {
+              System.err.println(" type "+aTrans.getType());
+              System.err.println(" scale "+aTrans.getScaleX()+" x "+aTrans.getScaleY());
+              System.err.println(" move "+aTrans.getTranslateX()+" x "+aTrans.getTranslateY());
+              System.err.println(" mat  "+aTrans);
+          } else {
+              System.err.println(" null transform");
+          }
+    }
+
+    /**
+     * @return resulting number of samples by comparing w/ {@link #customNumSamples} and the caps-config, 0 if disabled
+     */
+    public int getNumSamples(GLCapabilitiesImmutable caps) {
+          if( 0 > customNumSamples ) {
+              return 0;
+          } else if( 0 < customNumSamples ) {
+              if ( !caps.getGLProfile().isGL2ES3() ) {
+                  return 0;
+              }
+              return Math.max(caps.getNumSamples(), customNumSamples);
+          } else {
+              return caps.getNumSamples();
+          }
+    }
+
+    /**
+     * Assumes a configured {@link TileRenderer}, i.e.
+     * an {@link TileRenderer#attachAutoDrawable(GLAutoDrawable) attached}
+     * {@link GLAutoDrawable} with {@link TileRenderer#setTileSize(int, int, int) set tile size}.
+     * <p>
+     * Sets the renderer to {@link TileRenderer#TR_TOP_TO_BOTTOM} row order.
+     * </p>
+     * <p>
+     * <code>componentCount</code> reflects opaque, i.e. 4 if non opaque.
+     * </p>
+     * @param renderer
+     * @param componentCount
+     * @param scaleMatX {@link Graphics2D} {@link Graphics2D#scale(double, double) scaling factor}, i.e. rendering 1/scaleMatX * width pixels
+     * @param scaleMatY {@link Graphics2D} {@link Graphics2D#scale(double, double) scaling factor}, i.e. rendering 1/scaleMatY * height pixels
+     * @param numSamples custom multisampling value: < 0 turns off, == 0 leaves as-is, > 0 enables using given num samples
+     * @param tileWidth custom tile width for {@link TileRenderer#setTileSize(int, int, int) tile renderer}, pass -1 for default.
+     * @param tileHeight custom tile height for {@link TileRenderer#setTileSize(int, int, int) tile renderer}, pass -1 for default.
+     * @param verbose
+     */
+    public AWTTilePainter(TileRenderer renderer, int componentCount, double scaleMatX, double scaleMatY, int numSamples, int tileWidth, int tileHeight, boolean verbose) {
+        this.renderer = renderer;
+        this.renderer.setGLEventListener(preTileGLEL, postTileGLEL);
+        this.componentCount = componentCount;
+        this.scaleMatX = scaleMatX;
+        this.scaleMatY = scaleMatY;
+        this.customNumSamples = numSamples;
+        this.customTileWidth= tileWidth;
+        this.customTileHeight = tileHeight;
+        this.verbose = verbose;
+        this.flipVertical = true;
+    }
+
+    @Override
+    public String toString() {
+        return "AWTTilePainter[flipVertical "+flipVertical+", startFromBottom "+originBottomLeft+", "+
+                renderer.toString()+"]";
+    }
+
+    /**
+     * @param flipVertical if <code>true</code>, the image will be flipped vertically (Default for OpenGL).
+     * @param originBottomLeft if <code>true</code>, the image's origin is on the bottom left (Default for OpenGL).
+     */
+    public void setGLOrientation(boolean flipVertical, boolean originBottomLeft) {
+        this.flipVertical = flipVertical;
+        this.originBottomLeft = originBottomLeft;
+    }
+
+    private static Rectangle2D getClipBounds2D(Graphics2D g) {
+        final Shape shape = g.getClip();
+        return null != shape ? shape.getBounds2D() : null;
+    }
+    private static Rectangle2D clipNegative(Rectangle2D in) {
+        if( null == in ) { return null; }
+        double x=in.getX(), y=in.getY(), width=in.getWidth(), height=in.getHeight();
+        if( 0 > x ) {
+            width += x;
+            x = 0;
+        }
+        if( 0 > y ) {
+            height += y;
+            y = 0;
+        }
+        return new Rectangle2D.Double(x, y, width, height);
+    }
+
+    /**
+     * Caches the {@link Graphics2D} instance for rendering.
+     * <p>
+     * Copies the current {@link Graphics2D} {@link AffineTransform}
+     * and scales {@link Graphics2D} w/ <code>scaleMatX</code> x <code>scaleMatY</code>.<br>
+     * After rendering, the {@link AffineTransform} should be reset via {@link #resetGraphics2D()}.
+     * </p>
+     * <p>
+     * Sets the {@link TileRenderer}'s {@link TileRenderer#setImageSize(int, int) image size}
+     * and {@link TileRenderer#setTileOffset(int, int) tile offset} according the
+     * the {@link Graphics2D#getClipBounds() graphics clip bounds}.
+     * </p>
+     * @param g2d Graphics2D instance used for transform and clipping
+     * @param width width of the AWT component in case clipping is null
+     * @param height height of the AWT component in case clipping is null
+     * @throws NoninvertibleTransformException if the {@link Graphics2D}'s {@link AffineTransform} {@link AffineTransform#invert() inversion} fails.
+     *                                         Since inversion is tested before scaling the given {@link Graphics2D}, caller shall ignore the whole <i>term</i>.
+     */
+    public void setupGraphics2DAndClipBounds(Graphics2D g2d, int width, int height) throws NoninvertibleTransformException {
+        this.g2d = g2d;
+        saveAT = g2d.getTransform();
+        if( null == saveAT ) {
+            saveAT = new AffineTransform(); // use identity
+        }
+        // We use double precision for scaling
+        //
+        // Setup original rectangles
+        final Rectangle2D dClipOrigR = getClipBounds2D(g2d);
+        final Rectangle2D dClipOrig = clipNegative(dClipOrigR);
+        final Rectangle2D dImageSizeOrig = new Rectangle2D.Double(0, 0, width, height);
+
+        // Retrieve scaled image-size and clip-bounds
+        // Note: Clip bounds lie within image-size!
+        final Rectangle2D dImageSizeScaled, dClipScaled;
+        {
+            final AffineTransform scaledATI;
+            {
+                final AffineTransform scaledAT = new AffineTransform(saveAT);
+                scaledAT.scale(scaleMatX, scaleMatY);
+                scaledATI = scaledAT.createInverse(); // -> NoninvertibleTransformException
+            }
+            Shape s0 = saveAT.createTransformedShape(dImageSizeOrig); // user in
+            dImageSizeScaled = scaledATI.createTransformedShape(s0).getBounds2D(); // scaled out
+            if( null == dClipOrig ) {
+                dClipScaled = (Rectangle2D) dImageSizeScaled.clone();
+            } else {
+                s0 = saveAT.createTransformedShape(dClipOrig); // user in
+                dClipScaled = scaledATI.createTransformedShape(s0).getBounds2D(); // scaled out
+            }
+        }
+        final Rectangle iClipScaled = dClipScaled.getBounds();
+        final Rectangle iImageSizeScaled = dImageSizeScaled.getBounds();
+        renderer.setImageSize(iImageSizeScaled.width, iImageSizeScaled.height);
+        renderer.clipImageSize(iClipScaled.width, iClipScaled.height);
+        final int clipH = Math.min(iImageSizeScaled.height, iClipScaled.height);
+        // Clip bounds lie within image-size!
+        // GL y-offset is lower-left origin, AWT y-offset upper-left.
+        scaledYOffset = iClipScaled.y;
+        renderer.setTileOffset(iClipScaled.x, iImageSizeScaled.height - ( iClipScaled.y + clipH ));
+
+        // Scale actual Grahics2D matrix
+        g2d.scale(scaleMatX, scaleMatY);
+
+        if( verbose ) {
+            System.err.println("AWT print.0: image "+dImageSizeOrig + " -> " + dImageSizeScaled + " -> " + iImageSizeScaled);
+            System.err.println("AWT print.0: clip  "+dClipOrigR + " -> " + dClipOrig + " -> " + dClipScaled + " -> " + iClipScaled);
+            System.err.println("AWT print.0: "+renderer);
+        }
+    }
+    private int scaledYOffset;
+
+    /** See {@ #setupGraphics2DAndClipBounds(Graphics2D)}. */
+    public void resetGraphics2D() {
+        g2d.setTransform(saveAT);
+    }
+
+    /**
+     * Disposes resources and {@link TileRenderer#detachAutoDrawable() detaches}
+     * the {@link TileRenderer}'s {@link GLAutoDrawable}.
+     */
+    public void dispose() {
+        renderer.detachAutoDrawable(); // tile-renderer -> printGLAD
+        g2d = null;
+        if( null != tBuffer ) {
+            tBuffer.dispose();
+            tBuffer = null;
+        }
+        if( null != vFlipImage ) {
+            vFlipImage.flush();
+            vFlipImage = null;
+        }
+    }
+
+    final GLEventListener preTileGLEL = new GLEventListener() {
+        @Override
+        public void init(GLAutoDrawable drawable) {}
+        @Override
+        public void dispose(GLAutoDrawable drawable) {}
+        @Override
+        public void display(GLAutoDrawable drawable) {
+            final GL gl = drawable.getGL();
+            if( null == tBuffer ) {
+                final int tWidth = renderer.getParam(TileRenderer.TR_TILE_WIDTH);
+                final int tHeight = renderer.getParam(TileRenderer.TR_TILE_HEIGHT);
+                final AWTGLPixelBufferProvider printBufferProvider = new AWTGLPixelBufferProvider( true /* allowRowStride */ );
+                final GLPixelAttributes pixelAttribs = printBufferProvider.getAttributes(gl, componentCount);
+                tBuffer = printBufferProvider.allocate(gl, pixelAttribs, tWidth, tHeight, 1, true, 0);
+                renderer.setTileBuffer(tBuffer);
+                if( flipVertical ) {
+                    vFlipImage = new BufferedImage(tBuffer.width, tBuffer.height, tBuffer.image.getType());
+                } else {
+                    vFlipImage = null;
+                }
+            }
+            if( verbose ) {
+                System.err.println("XXX tile-pre "+renderer);
+            }
+        }
+        @Override
+        public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {}
+    };
+    static int _counter = 0;
+    final GLEventListener postTileGLEL = new GLEventListener() {
+        @Override
+        public void init(GLAutoDrawable drawable) {
+        }
+        @Override
+        public void dispose(GLAutoDrawable drawable) {}
+        @Override
+        public void display(GLAutoDrawable drawable) {
+            final DimensionImmutable cis = renderer.getClippedImageSize();
+            final int tWidth = renderer.getParam(TileRendererBase.TR_CURRENT_TILE_WIDTH);
+            final int tHeight = renderer.getParam(TileRendererBase.TR_CURRENT_TILE_HEIGHT);
+            final int tY = renderer.getParam(TileRendererBase.TR_CURRENT_TILE_Y_POS);
+            final int tYOff = renderer.getParam(TileRenderer.TR_TILE_Y_OFFSET);
+            final int imgYOff = originBottomLeft ? 0 : renderer.getParam(TileRenderer.TR_TILE_HEIGHT) - tHeight; // imgYOff will be cut-off via sub-image
+            final int pX = renderer.getParam(TileRendererBase.TR_CURRENT_TILE_X_POS); // tileX == pX
+            final int pY = cis.getHeight() - ( tY - tYOff + tHeight ) + scaledYOffset;
+
+            // Copy temporary data into raster of BufferedImage for faster
+            // blitting Note that we could avoid this copy in the cases
+            // where !offscreenDrawable.isGLOriented(),
+            // but that's the software rendering path which is very slow anyway.
+            final BufferedImage dstImage;
+            if( DEBUG_TILES ) {
+                final String fname = String.format("file_%03d_0_tile_[%02d][%02d]_sz_%03dx%03d_pos0_%03d_%03d_yOff_%03d_pos1_%03d_%03d.png",
+                        _counter,
+                        renderer.getParam(TileRenderer.TR_CURRENT_COLUMN), renderer.getParam(TileRenderer.TR_CURRENT_ROW),
+                        tWidth, tHeight,
+                        pX, tY, tYOff, pX, pY).replace(' ', '_');
+                System.err.println("XXX file "+fname);
+                final File fout = new File(fname);
+                try {
+                    ImageIO.write(tBuffer.image, "png", fout);
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            }
+            if( flipVertical ) {
+                final BufferedImage srcImage = tBuffer.image;
+                dstImage = vFlipImage;
+                final int[] src = ((DataBufferInt) srcImage.getRaster().getDataBuffer()).getData();
+                final int[] dst = ((DataBufferInt) dstImage.getRaster().getDataBuffer()).getData();
+                if( DEBUG_TILES ) {
+                    Arrays.fill(dst, 0x55);
+                }
+                final int incr = tBuffer.width;
+                int srcPos = 0;
+                int destPos = (tHeight - 1) * tBuffer.width;
+                for (; destPos >= 0; srcPos += incr, destPos -= incr) {
+                    System.arraycopy(src, srcPos, dst, destPos, incr);
+                }
+            } else {
+                dstImage = tBuffer.image;
+            }
+            if( DEBUG_TILES ) {
+                final String fname = String.format("file_%03d_1_tile_[%02d][%02d]_sz_%03dx%03d_pos0_%03d_%03d_yOff_%03d_pos1_%03d_%03d.png",
+                        _counter,
+                        renderer.getParam(TileRenderer.TR_CURRENT_COLUMN), renderer.getParam(TileRenderer.TR_CURRENT_ROW),
+                        tWidth, tHeight,
+                        pX, tY, tYOff, pX, pY).replace(' ', '_');
+                System.err.println("XXX file "+fname);
+                final File fout = new File(fname);
+                try {
+                    ImageIO.write(dstImage, "png", fout);
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+                _counter++;
+            }
+            // Draw resulting image in one shot
+            final BufferedImage outImage = dstImage.getSubimage(0, imgYOff, tWidth, tHeight);
+            final boolean drawDone = g2d.drawImage(outImage, pX, pY, null); // Null ImageObserver since image data is ready.
+            if( verbose ) {
+                final Shape oClip = g2d.getClip();
+                System.err.println("XXX tile-post.X tile 0 / "+imgYOff+" "+tWidth+"x"+tHeight+", clippedImgSize "+cis);
+                System.err.println("XXX tile-post.X pYf "+cis.getHeight()+" - ( "+tY+" - "+tYOff+" + "+tHeight+" ) "+scaledYOffset+" = "+ pY);
+                System.err.println("XXX tile-post.X clip "+oClip+" + "+pX+" / [pY "+tY+", pYOff "+tYOff+", pYf "+pY+"] -> "+g2d.getClip());
+                g2d.setColor(Color.BLACK);
+                g2d.drawRect(pX, pY, tWidth, tHeight);
+                if( null != oClip ) {
+                    final Rectangle r = oClip.getBounds();
+                    g2d.setColor(Color.YELLOW);
+                    g2d.drawRect(r.x, r.y, r.width, r.height);
+                }
+                System.err.println("XXX tile-post.X "+renderer);
+                System.err.println("XXX tile-post.X dst-img "+dstImage.getWidth()+"x"+dstImage.getHeight());
+                System.err.println("XXX tile-post.X out-img "+outImage.getWidth()+"x"+outImage.getHeight());
+                System.err.println("XXX tile-post.X y-flip "+flipVertical+", originBottomLeft "+originBottomLeft+" -> "+pX+"/"+pY+", drawDone "+drawDone);
+            }
+        }
+        @Override
+        public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {}
+    };
+}
diff --git a/src/jogl/classes/jogamp/opengl/awt/AWTUtil.java b/src/jogl/classes/jogamp/opengl/awt/AWTUtil.java
index e15e538c2..dc286ca59 100644
--- a/src/jogl/classes/jogamp/opengl/awt/AWTUtil.java
+++ b/src/jogl/classes/jogamp/opengl/awt/AWTUtil.java
@@ -1,22 +1,22 @@
 /*
  * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
  * Copyright (c) 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:
- * 
+ *
  * - Redistribution of source code must retain the above copyright
  *   notice, this list of conditions and the following disclaimer.
- * 
+ *
  * - Redistribution 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 Sun Microsystems, Inc. or the names of
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
- * 
+ *
  * This software is provided "AS IS," without a warranty of any kind. ALL
  * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
  * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
@@ -29,7 +29,7 @@
  * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
  * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
  * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
- * 
+ *
  * You acknowledge that this software is not designed or intended for use
  * in the design, construction, operation or maintenance of any nuclear
  * facility.
@@ -85,7 +85,7 @@ public class AWTUtil {
           NativeWindowFactory.getAWTToolkitLock().lock();
         }
       } catch (Exception e) { j2dOk=false; }
-    } 
+    }
     if(!j2dOk) {
       NativeWindowFactory.getAWTToolkitLock().lock();
     }
@@ -108,7 +108,7 @@ public class AWTUtil {
               NativeWindowFactory.getAWTToolkitLock().unlock();
             }
           } catch (Exception e) { j2dOk=false; }
-        } 
+        }
         if(!j2dOk) {
           NativeWindowFactory.getAWTToolkitLock().unlock();
         }
diff --git a/src/jogl/classes/jogamp/opengl/awt/Java2D.java b/src/jogl/classes/jogamp/opengl/awt/Java2D.java
index 3dbfefb19..886cd9368 100644
--- a/src/jogl/classes/jogamp/opengl/awt/Java2D.java
+++ b/src/jogl/classes/jogamp/opengl/awt/Java2D.java
@@ -1,21 +1,21 @@
 /*
  * Copyright (c) 2003-2005 Sun Microsystems, Inc. All Rights Reserved.
- * 
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
- * 
+ *
  * - Redistribution of source code must retain the above copyright
  *   notice, this list of conditions and the following disclaimer.
- * 
+ *
  * - Redistribution 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 Sun Microsystems, Inc. or the names of
  * contributors may be used to endorse or promote products derived from
  * this software without specific prior written permission.
- * 
+ *
  * This software is provided "AS IS," without a warranty of any kind. ALL
  * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
  * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
@@ -28,11 +28,11 @@
  * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
  * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
  * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
- * 
+ *
  * You acknowledge that this software is not designed or intended for use
  * in the design, construction, operation or maintenance of any nuclear
  * facility.
- * 
+ *
  * Sun gratefully acknowledges that this software was originally authored
  * and developed by Kenneth Bradley Russell and Christopher John Kline.
  */
@@ -69,6 +69,7 @@ public class Java2D {
   private static boolean DEBUG = Debug.debug("Java2D");
   private static boolean isHeadless;
   private static boolean isOGLPipelineActive;
+  private static boolean isOGLPipelineResourceCompatible;
   private static Method invokeWithOGLContextCurrentMethod;
   private static Method isQueueFlusherThreadMethod;
   private static Method getOGLViewportMethod;
@@ -115,6 +116,7 @@ public class Java2D {
 
   static {
     AccessController.doPrivileged(new PrivilegedAction<Object>() {
+        @Override
         public Object run() {
           if (DEBUG) {
             System.err.println("Checking for Java2D/OpenGL support");
@@ -124,18 +126,36 @@ public class Java2D {
             isHeadless = true;
             // Figure out whether the default graphics configuration is an
             // OpenGL graphics configuration
-            GraphicsConfiguration cfg =
-              GraphicsEnvironment.getLocalGraphicsEnvironment().
-              getDefaultScreenDevice().
-              getDefaultConfiguration();
+            final GraphicsConfiguration cfg;
+            final String cfgName;
+            final boolean java2dOGLDisabledByOS = Platform.OS_TYPE == Platform.OSType.MACOS;
+            final boolean java2dOGLDisabledByProp;
+            {
+                boolean enabled = true;
+                final String sVal = System.getProperty("sun.java2d.opengl");
+                if( null != sVal ) {
+                    enabled = Boolean.valueOf(sVal);
+                }
+                java2dOGLDisabledByProp = !enabled;
+            }
+            if( !java2dOGLDisabledByProp && !java2dOGLDisabledByOS ) {
+                cfg = GraphicsEnvironment.getLocalGraphicsEnvironment().
+                        getDefaultScreenDevice().getDefaultConfiguration();
+                cfgName = cfg.getClass().getName();
+            } else {
+                if (DEBUG) {
+                  System.err.println("Java2D support disabled: by Property "+java2dOGLDisabledByProp+", by OS "+java2dOGLDisabledByOS);
+                }
+                cfg = null;
+                cfgName = "nil";
+            }
             // If we get here, we aren't running in headless mode
             isHeadless = false;
-            String name = cfg.getClass().getName();
             if (DEBUG) {
-              System.err.println("Java2D support: default GraphicsConfiguration = " + name);
+              System.err.println("Java2D support: default GraphicsConfiguration = " + cfgName);
             }
-            isOGLPipelineActive = Platform.OS_TYPE != Platform.OSType.MACOS &&
-                                  (name.startsWith("sun.java2d.opengl"));
+            isOGLPipelineActive = cfgName.startsWith("sun.java2d.opengl");
+            isOGLPipelineResourceCompatible = isOGLPipelineActive;
 
             if (isOGLPipelineActive) {
               try {
@@ -152,99 +172,101 @@ public class Java2D {
                                                                      new Class[] {});
                 isQueueFlusherThreadMethod.setAccessible(true);
 
-                getOGLViewportMethod = utils.getDeclaredMethod("getOGLViewport",
-                                                               new Class[] {
-                                                                 Graphics.class,
-                                                                 Integer.TYPE,
-                                                                 Integer.TYPE
-                                                               });
-                getOGLViewportMethod.setAccessible(true);
-
-                getOGLScissorBoxMethod = utils.getDeclaredMethod("getOGLScissorBox",
-                                                                 new Class[] {
-                                                                   Graphics.class
-                                                                 });
-                getOGLScissorBoxMethod.setAccessible(true);
-
-                getOGLSurfaceIdentifierMethod = utils.getDeclaredMethod("getOGLSurfaceIdentifier",
+                if( isOGLPipelineResourceCompatible ) {
+                    getOGLViewportMethod = utils.getDeclaredMethod("getOGLViewport",
+                                                                   new Class[] {
+                                                                     Graphics.class,
+                                                                     Integer.TYPE,
+                                                                     Integer.TYPE
+                                                                   });
+                    getOGLViewportMethod.setAccessible(true);
+
+                    getOGLScissorBoxMethod = utils.getDeclaredMethod("getOGLScissorBox",
+                                                                     new Class[] {
+                                                                       Graphics.class
+                                                                     });
+                    getOGLScissorBoxMethod.setAccessible(true);
+
+                    getOGLSurfaceIdentifierMethod = utils.getDeclaredMethod("getOGLSurfaceIdentifier",
+                                                                            new Class[] {
+                                                                              Graphics.class
+                                                                            });
+                    getOGLSurfaceIdentifierMethod.setAccessible(true);
+
+                    // Try to get additional methods required for proper FBO support
+                    fbObjectSupportInitialized = true;
+                    try {
+                      invokeWithOGLSharedContextCurrentMethod = utils.getDeclaredMethod("invokeWithOGLSharedContextCurrent",
+                                                                                        new Class[] {
+                                                                                          GraphicsConfiguration.class,
+                                                                                          Runnable.class
+                                                                                        });
+                      invokeWithOGLSharedContextCurrentMethod.setAccessible(true);
+
+                      getOGLSurfaceTypeMethod = utils.getDeclaredMethod("getOGLSurfaceType",
                                                                         new Class[] {
                                                                           Graphics.class
                                                                         });
-                getOGLSurfaceIdentifierMethod.setAccessible(true);
-
-                // Try to get additional methods required for proper FBO support
-                fbObjectSupportInitialized = true;
-                try {
-                  invokeWithOGLSharedContextCurrentMethod = utils.getDeclaredMethod("invokeWithOGLSharedContextCurrent",
-                                                                                    new Class[] {
-                                                                                      GraphicsConfiguration.class,
-                                                                                      Runnable.class
-                                                                                    });
-                  invokeWithOGLSharedContextCurrentMethod.setAccessible(true);
-
-                  getOGLSurfaceTypeMethod = utils.getDeclaredMethod("getOGLSurfaceType",
-                                                                    new Class[] {
-                                                                      Graphics.class
-                                                                    });
-                  getOGLSurfaceTypeMethod.setAccessible(true);
-                } catch (Exception e) {
-                  fbObjectSupportInitialized = false;
-                  if (DEBUG) {
-                    e.printStackTrace();
-                    System.err.println("Info: Disabling Java2D/JOGL FBO support");
-                  }
-                }
-
-                // Try to get an additional method for FBO support in recent Mustang builds
-                try {
-                  getOGLTextureTypeMethod = utils.getDeclaredMethod("getOGLTextureType",
-                                                                    new Class[] {
-                                                                      Graphics.class
-                                                                    });
-                  getOGLTextureTypeMethod.setAccessible(true);
-                } catch (Exception e) {
-                  if (DEBUG) {
-                    e.printStackTrace();
-                    System.err.println("Info: GL_ARB_texture_rectangle FBO support disabled");
-                  }
-                }
-
-                // Try to set up APIs for enabling the bridge on OS X,
-                // where it isn't possible to create generalized
-                // external GLDrawables
-                Class<?> cglSurfaceData = null;
-                try {
-                  cglSurfaceData = Class.forName("sun.java2d.opengl.CGLSurfaceData");
-                } catch (Exception e) {
-                  if (DEBUG) {
-                    e.printStackTrace();
-                    System.err.println("Info: Unable to find class sun.java2d.opengl.CGLSurfaceData for OS X");
-                  }
-                }
-                if (cglSurfaceData != null) {
-                  // FIXME: for now, assume that FBO support is not enabled on OS X
-                  fbObjectSupportInitialized = false;
-
-                  // We need to find these methods in order to make the bridge work on OS X
-                  createOGLContextOnSurfaceMethod = cglSurfaceData.getDeclaredMethod("createOGLContextOnSurface",
-                                                                                     new Class[] {
-                                                                                       Graphics.class,
-                                                                                       Long.TYPE
-                                                                                     });
-                  createOGLContextOnSurfaceMethod.setAccessible(true);
-
-                  makeOGLContextCurrentOnSurfaceMethod = cglSurfaceData.getDeclaredMethod("makeOGLContextCurrentOnSurface",
-                                                                                          new Class[] {
-                                                                                            Graphics.class,
-                                                                                            Long.TYPE
-                                                                                          });
-                  makeOGLContextCurrentOnSurfaceMethod.setAccessible(true);
-
-                  destroyOGLContextMethod = cglSurfaceData.getDeclaredMethod("destroyOGLContext",
-                                                                             new Class[] {
-                                                                               Long.TYPE
-                                                                             });
-                  destroyOGLContextMethod.setAccessible(true);
+                      getOGLSurfaceTypeMethod.setAccessible(true);
+                    } catch (Exception e) {
+                      fbObjectSupportInitialized = false;
+                      if (DEBUG) {
+                        e.printStackTrace();
+                        System.err.println("Info: Disabling Java2D/JOGL FBO support");
+                      }
+                    }
+
+                    // Try to get an additional method for FBO support in recent Mustang builds
+                    try {
+                      getOGLTextureTypeMethod = utils.getDeclaredMethod("getOGLTextureType",
+                                                                        new Class[] {
+                                                                          Graphics.class
+                                                                        });
+                      getOGLTextureTypeMethod.setAccessible(true);
+                    } catch (Exception e) {
+                      if (DEBUG) {
+                        e.printStackTrace();
+                        System.err.println("Info: GL_ARB_texture_rectangle FBO support disabled");
+                      }
+                    }
+
+                    // Try to set up APIs for enabling the bridge on OS X,
+                    // where it isn't possible to create generalized
+                    // external GLDrawables
+                    Class<?> cglSurfaceData = null;
+                    try {
+                      cglSurfaceData = Class.forName("sun.java2d.opengl.CGLSurfaceData");
+                    } catch (Exception e) {
+                      if (DEBUG) {
+                        e.printStackTrace();
+                        System.err.println("Info: Unable to find class sun.java2d.opengl.CGLSurfaceData for OS X");
+                      }
+                    }
+                    if (cglSurfaceData != null) {
+                      // FIXME: for now, assume that FBO support is not enabled on OS X
+                      fbObjectSupportInitialized = false;
+
+                      // We need to find these methods in order to make the bridge work on OS X
+                      createOGLContextOnSurfaceMethod = cglSurfaceData.getDeclaredMethod("createOGLContextOnSurface",
+                                                                                         new Class[] {
+                                                                                           Graphics.class,
+                                                                                           Long.TYPE
+                                                                                         });
+                      createOGLContextOnSurfaceMethod.setAccessible(true);
+
+                      makeOGLContextCurrentOnSurfaceMethod = cglSurfaceData.getDeclaredMethod("makeOGLContextCurrentOnSurface",
+                                                                                              new Class[] {
+                                                                                                Graphics.class,
+                                                                                                Long.TYPE
+                                                                                              });
+                      makeOGLContextCurrentOnSurfaceMethod.setAccessible(true);
+
+                      destroyOGLContextMethod = cglSurfaceData.getDeclaredMethod("destroyOGLContext",
+                                                                                 new Class[] {
+                                                                                   Long.TYPE
+                                                                                 });
+                      destroyOGLContextMethod.setAccessible(true);
+                    }
                 }
               } catch (Exception e) {
                 catched = e;
@@ -252,6 +274,7 @@ public class Java2D {
                   System.err.println("Info: Disabling Java2D/JOGL integration");
                 }
                 isOGLPipelineActive = false;
+                isOGLPipelineResourceCompatible = false;
               }
             }
           } catch (HeadlessException e) {
@@ -265,7 +288,7 @@ public class Java2D {
             if(null != catched) {
                 catched.printStackTrace();
             }
-            System.err.println("JOGL/Java2D integration " + (isOGLPipelineActive ? "enabled" : "disabled"));
+            System.err.println("JOGL/Java2D OGL Pipeline active " + isOGLPipelineActive + ", resourceCompatible "+isOGLPipelineResourceCompatible);
           }
           return null;
         }
@@ -276,6 +299,10 @@ public class Java2D {
     return isOGLPipelineActive;
   }
 
+  public static boolean isOGLPipelineResourceCompatible() {
+    return isOGLPipelineResourceCompatible;
+  }
+
   public static boolean isFBOEnabled() {
     return fbObjectSupportInitialized;
   }
@@ -291,7 +318,7 @@ public class Java2D {
       throw (InternalError) new InternalError().initCause(e);
     }
   }
-  
+
   /** Makes current the OpenGL context associated with the passed
       Graphics object and runs the given Runnable on the Queue
       Flushing Thread in one atomic action. */
@@ -330,7 +357,7 @@ public class Java2D {
       false if the passed GraphicsConfiguration was not an OpenGL
       GraphicsConfiguration. */
   public static boolean invokeWithOGLSharedContextCurrent(GraphicsConfiguration g, Runnable r) throws GLException {
-    checkActive();
+    checkCompatible();
 
     try {
       AWTUtil.lockToolkit();
@@ -355,7 +382,7 @@ public class Java2D {
   public static Rectangle getOGLViewport(Graphics g,
                                          int componentWidth,
                                          int componentHeight) {
-    checkActive();
+    checkCompatible();
 
     try {
       return (Rectangle) getOGLViewportMethod.invoke(null, new Object[] {g,
@@ -375,7 +402,7 @@ public class Java2D {
       passed to a call to glScissor(). Should only be called from the
       Queue Flusher Thread. */
   public static Rectangle getOGLScissorBox(Graphics g) {
-    checkActive();
+    checkCompatible();
 
     try {
       return (Rectangle) getOGLScissorBoxMethod.invoke(null, new Object[] {g});
@@ -393,7 +420,7 @@ public class Java2D {
       created (and the old ones destroyed). Should only be called from
       the Queue Flusher Thread.*/
   public static Object getOGLSurfaceIdentifier(Graphics g) {
-    checkActive();
+    checkCompatible();
 
     try {
       return getOGLSurfaceIdentifierMethod.invoke(null, new Object[] {g});
@@ -408,7 +435,7 @@ public class Java2D {
       object. This indicates, in particular, whether Java2D is
       currently rendering into a pbuffer or FBO. */
   public static int getOGLSurfaceType(Graphics g) {
-    checkActive();
+    checkCompatible();
 
     try {
       // FIXME: fallback path for pre-b73 (?) Mustang builds -- remove
@@ -429,7 +456,7 @@ public class Java2D {
       object assuming it is rendering to an FBO. Returns either
       GL_TEXTURE_2D or GL_TEXTURE_RECTANGLE_ARB. */
   public static int getOGLTextureType(Graphics g) {
-    checkActive();
+    checkCompatible();
 
     if (getOGLTextureTypeMethod == null) {
       return GL.GL_TEXTURE_2D;
@@ -483,7 +510,7 @@ public class Java2D {
       associated with the given Graphics object, sharing textures and
       display lists with the specified (CGLContextObj) share context. */
   public static long createOGLContextOnSurface(Graphics g, long shareCtx) {
-    checkActive();
+    checkCompatible();
 
     try {
       return ((Long) createOGLContextOnSurfaceMethod.invoke(null, new Object[] { g, new Long(shareCtx) })).longValue();
@@ -497,7 +524,7 @@ public class Java2D {
   /** (Mac OS X-specific) Makes the given OpenGL context current on
       the surface associated with the given Graphics object. */
   public static boolean makeOGLContextCurrentOnSurface(Graphics g, long ctx) {
-    checkActive();
+    checkCompatible();
 
     try {
       return ((Boolean) makeOGLContextCurrentOnSurfaceMethod.invoke(null, new Object[] { g, new Long(ctx) })).booleanValue();
@@ -510,7 +537,7 @@ public class Java2D {
 
   /** (Mac OS X-specific) Destroys the given OpenGL context. */
   public static void destroyOGLContext(long ctx) {
-    checkActive();
+    checkCompatible();
 
     try {
       destroyOGLContextMethod.invoke(null, new Object[] { new Long(ctx) });
@@ -527,12 +554,19 @@ public class Java2D {
 
   private static void checkActive() {
     if (!isOGLPipelineActive()) {
-      throw new GLException("Java2D OpenGL pipeline not active (or necessary support not present)");
+      throw new GLException("Java2D OpenGL pipeline not active");
+    }
+  }
+
+  private static void checkCompatible() {
+    if ( !isOGLPipelineResourceCompatible() ) {
+      throw new GLException("Java2D OpenGL pipeline not resource compatible");
     }
   }
 
   private static int getOGLUtilitiesIntField(final String name) {
     Integer i = AccessController.doPrivileged(new PrivilegedAction<Integer>() {
+        @Override
         public Integer run() {
           try {
             Class<?> utils = Class.forName("sun.java2d.opengl.OGLUtilities");
@@ -562,7 +596,7 @@ public class Java2D {
     // Note 2: the first execution of this method must not be from the
     // Java2D Queue Flusher Thread.
 
-    if (isOGLPipelineActive() &&
+    if (isOGLPipelineResourceCompatible() &&
         isFBOEnabled() &&
         !initializedJ2DFBOShareContext) {
 
@@ -576,6 +610,7 @@ public class Java2D {
         System.err.println("Starting initialization of J2D FBO share context");
       }
       invokeWithOGLSharedContextCurrent(device.getDefaultConfiguration(), new Runnable() {
+          @Override
           public void run() {
             j2dFBOShareContext = GLDrawableFactory.getFactory(GLProfile.getDefault(GLProfile.getDefaultDevice())).createExternalGLContext();
           }
diff --git a/src/jogl/classes/jogamp/opengl/awt/Java2DGLContext.java b/src/jogl/classes/jogamp/opengl/awt/Java2DGLContext.java
deleted file mode 100644
index 4a5b1db54..000000000
--- a/src/jogl/classes/jogamp/opengl/awt/Java2DGLContext.java
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 
- * - Redistribution of source code must retain the above copyright
- *   notice, this list of conditions and the following disclaimer.
- * 
- * - Redistribution 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 Sun Microsystems, Inc. or the names of
- * contributors may be used to endorse or promote products derived from
- * this software without specific prior written permission.
- * 
- * This software is provided "AS IS," without a warranty of any kind. ALL
- * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
- * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
- * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
- * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
- * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
- * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
- * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
- * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
- * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
- * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
- * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
- * 
- * You acknowledge that this software is not designed or intended for use
- * in the design, construction, operation or maintenance of any nuclear
- * facility.
- * 
- * Sun gratefully acknowledges that this software was originally authored
- * and developed by Kenneth Bradley Russell and Christopher John Kline.
- */
-
-package jogamp.opengl.awt;
-
-import jogamp.opengl.*;
-import java.awt.Graphics;
-
-/** Provides a construct by which the shared GLJPanel code can
- * interact with a few methods in the Mac OS X-specific Java2D/JOGL
- * bridge implementation.
- */
-
-public interface Java2DGLContext {
-  public void setGraphics(Graphics g);
-}
diff --git a/src/jogl/classes/jogamp/opengl/awt/VersionApplet.java b/src/jogl/classes/jogamp/opengl/awt/VersionApplet.java
index 55fb3f9a2..9173a38cb 100644
--- a/src/jogl/classes/jogamp/opengl/awt/VersionApplet.java
+++ b/src/jogl/classes/jogamp/opengl/awt/VersionApplet.java
@@ -42,7 +42,7 @@ public class VersionApplet extends Applet {
     va.init();
     frame.add(va, BorderLayout.CENTER);
     frame.validate();
-        
+
     frame.setVisible(true);
     va.start();
   }
@@ -54,6 +54,7 @@ public class VersionApplet extends Applet {
         this.f = f;
         this.va = va;
     }
+    @Override
     public void windowClosing(WindowEvent ev) {
         f.setVisible(false);
         va.stop();
@@ -68,7 +69,7 @@ public class VersionApplet extends Applet {
     if(null != canvas) { return; }
 
     setEnabled(true);
-    
+
     GLProfile glp = GLProfile.getDefault();
     GLCapabilities glcaps = new GLCapabilities(glp);
 
@@ -87,7 +88,7 @@ public class VersionApplet extends Applet {
     /*
     s = NativeWindowVersion.getInstance().toString();
     System.err.println(s);
-    tareaVersion.append(NativeWindowVersion.getInstance().toString()); 
+    tareaVersion.append(NativeWindowVersion.getInstance().toString());
     */
 
     s = JoglVersion.getInstance().toString();
@@ -129,24 +130,28 @@ public class VersionApplet extends Applet {
       }
   }
 
+  @Override
   public void init() {
     System.err.println("VersionApplet: init() - begin");
     my_init();
     System.err.println("VersionApplet: init() - end");
   }
 
+  @Override
   public void start() {
     System.err.println("VersionApplet: start() - begin");
     canvas.setVisible(true);
     System.err.println("VersionApplet: start() - end");
   }
 
+  @Override
   public void stop() {
     System.err.println("VersionApplet: stop() - begin");
     canvas.setVisible(false);
     System.err.println("VersionApplet: stop() - end");
   }
 
+  @Override
   public void destroy() {
     System.err.println("VersionApplet: destroy() - start");
     my_release();
@@ -154,6 +159,7 @@ public class VersionApplet extends Applet {
   }
 
   class GLInfo implements GLEventListener {
+    @Override
     public void init(GLAutoDrawable drawable) {
         GL gl = drawable.getGL();
         String s = JoglVersion.getGLInfo(gl, null).toString();
@@ -161,12 +167,15 @@ public class VersionApplet extends Applet {
         tareaVersion.append(s);
     }
 
+    @Override
     public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {
     }
 
+    @Override
     public void display(GLAutoDrawable drawable) {
     }
 
+    @Override
     public void dispose(GLAutoDrawable drawable) {
     }
   }