OS X Layered View Part8: Generalize OffscreenLayerSurface ; Use local JAWT instance ; Applet's on OS X are working

Generalize OffscreenLayerSurface
  - Using new OffscreenLayerSurface allows using this functionality in a clean manner,
    ie. no 'dirty' usage of MacOSXJAWTWindow in a JOGL GL class.

  - 'Promoting' OffscreenLayerSurface functionality to JAWTWindow
    and it's handling to GLDrawableFactoryImpl::createGLDrawable().

  - Move MacOSXCGLDrawableFactory's "MacOSXJAWTWindow getLayeredSurfaceHost(NativeSurface surface)"
    to NativeWindowFactory "OffscreenLayerSurface getOffscreenLayerSurface(NativeSurface surface, boolean ifEnabled)"

Use local JAWT instance
  - Only w/ a local JAWT instance per JAWTWindow it is possible to switch between
    offscreen-layer and onscreen. We also have to determing offscreen-layer lazy
    at surface lock, since only at that time we have knowledge whether it's an Applet
    or not.

+++

ContextUpdater:
  Use local pthread mutex, add DEBUG output

JAWTWindow/NewtCanvasAWT:
  Adding methods to request offscreen-layer-surface (if supported),
  besides 'if applet' this may trigger the new functionality.

+++

Applet's on OS X are working:
  - OS X 10.6.4
    - Safari:
      - Hangs for a while at start .. whole screen freezes .. approx. 10s
      - Sometimes crashes when Applet stops - after all our resources are released!
      - Keyboard input isn't assigned sometimes.
      - Otherwise .. works well, incl. offscreen/onscreen parenting

    - Firefox 8.0:
      - Hangs for a while at start .. whole screen freezes .. approx. 10s
      - Sometimes crashes when Applet stops - after all our resources are released!
      - Keyboard input is never assigned.
      - Otherwise .. works well, incl. offscreen/onscreen parenting

  - OS X 10.7
    - Safari:
      - Sometimes crashes when Applet stops - after all our resources are released!
      - Keyboard input isn't assigned sometimes.
      - Otherwise .. works well, incl. offscreen/onscreen parenting

    - Firefox 8.0:
      - Sometimes crashes when Applet stops - after all our resources are released!
      - Keyboard input is never assigned.
      - Otherwise .. works well, incl. offscreen/onscreen parenting

7 files changed, 274 insertions, 100 deletions

diff --git a/src/nativewindow/classes/javax/media/nativewindow/NativeWindowFactory.java b/src/nativewindow/classes/javax/media/nativewindow/NativeWindowFactory.java
index 60ce07f09..b6c850098 100644
--- a/src/nativewindow/classes/javax/media/nativewindow/NativeWindowFactory.java
+++ b/src/nativewindow/classes/javax/media/nativewindow/NativeWindowFactory.java
@@ -475,4 +475,33 @@ public abstract class NativeWindowFactory {
         NativeWindow. Implementors of concrete NativeWindowFactory
         subclasses should override this method. */
     protected abstract NativeWindow getNativeWindowImpl(Object winObj, AbstractGraphicsConfiguration config) throws IllegalArgumentException;
+    
+    /**
+     * Returns the {@link OffscreenLayerSurface} instance of this {@link NativeSurface}.
+     * <p>
+     * In case this surface is a {@link NativeWindow}, we traverse from the given surface 
+     * up to root until a {@link OffscreenLayerSurface} is found.
+     * </p>
+     * 
+     * @param surface The surface to query.
+     * @param ifEnabled If true, only return the enabled {@link OffscreenLayerSurface}, see {@link OffscreenLayerSurface#isOffscreenLayerSurfaceEnabled()}. 
+     * @return
+     */
+    public static OffscreenLayerSurface getOffscreenLayerSurface(NativeSurface surface, boolean ifEnabled) {
+        if(surface instanceof OffscreenLayerSurface) {
+            final OffscreenLayerSurface ols = (OffscreenLayerSurface) surface;
+            return ( !ifEnabled || ols.isOffscreenLayerSurfaceEnabled() ) ? ols : null;
+        }
+        if(surface instanceof NativeWindow) {
+            NativeWindow nw = ((NativeWindow) surface).getParent();
+            while(null != nw) {
+                if(nw instanceof OffscreenLayerSurface) {
+                    final OffscreenLayerSurface ols = (OffscreenLayerSurface) nw;
+                    return ( !ifEnabled || ols.isOffscreenLayerSurfaceEnabled() ) ? ols : null;
+                }
+                nw = nw.getParent();                
+            }
+        }
+        return null;            
+    }
 }
diff --git a/src/nativewindow/classes/javax/media/nativewindow/OffscreenLayerSurface.java b/src/nativewindow/classes/javax/media/nativewindow/OffscreenLayerSurface.java
new file mode 100644
index 000000000..82ae0f39e
--- /dev/null
+++ b/src/nativewindow/classes/javax/media/nativewindow/OffscreenLayerSurface.java
@@ -0,0 +1,51 @@
+/**
+ * Copyright 2011 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 javax.media.nativewindow;
+
+/**
+ * Interface specifying the offscreen layer surface protocol.
+ */
+public interface OffscreenLayerSurface {
+  /** Returns true if this instance uses an offscreen layer, otherwise false. */
+  public boolean isOffscreenLayerSurfaceEnabled();
+  
+  /** 
+   * Attach the offscreen layer to this offscreen layer surface.
+   * @see #isOffscreenLayerSurfaceEnabled()
+   * @throws NativeWindowException if {@link #isOffscreenLayerSurfaceEnabled()} == false
+   */
+  public void attachSurfaceLayer(final long layerHandle) throws NativeWindowException;
+  
+  /** 
+   * Detaches a previously attached offscreen layer from this offscreen layer surface.
+   * @see #attachSurfaceLayer(long)
+   * @see #isOffscreenLayerSurfaceEnabled()
+   * @throws NativeWindowException if {@link #isOffscreenLayerSurfaceEnabled()} == false
+   */
+  public void detachSurfaceLayer(final long layerHandle) throws NativeWindowException;
+}
diff --git a/src/nativewindow/classes/jogamp/nativewindow/jawt/JAWTUtil.java b/src/nativewindow/classes/jogamp/nativewindow/jawt/JAWTUtil.java
index 4435c4f8f..ddf453bab 100644
--- a/src/nativewindow/classes/jogamp/nativewindow/jawt/JAWTUtil.java
+++ b/src/nativewindow/classes/jogamp/nativewindow/jawt/JAWTUtil.java
@@ -57,6 +57,7 @@ public class JAWTUtil {
 
   // See whether we're running in headless mode
   private static final boolean headlessMode;
+  private static final JAWT jawtLockObject;
 
   // Java2D magic ..
   private static final Method isQueueFlusherThread;
@@ -85,29 +86,26 @@ public class JAWTUtil {
        return Platform.OS_TYPE == Platform.OSType.MACOS &&
               Platform.OS_VERSION_NUMBER.compareTo(JAWT.JAWT_MacOSXCALayerMinVersion) >= 0;      
   }
-  
+ 
   /**
-   * 
-   * FIXME: Need to get rid of the cached JAWT instance, 
-   *        in case we like to have dual usage of offscreenLayeredSurface and onscreen.
-   *        This would be done implicit by using NEWT .. hence low prio.
-   *        
    * @param useOffscreenLayerIfAvailable
    * @return
    */
-  public static boolean setCachedJAWTVersionFlags(boolean useOffscreenLayerIfAvailable) {
-    if(JAWT.isJAWTInstantiated()) { return false; } // already instantiated
-    
-    if(useOffscreenLayerIfAvailable && isOffscreenLayerSupported()) {
-        JAWT.setJAWTVersionFlags(JAWTFactory.JAWT_VERSION_1_4 | JAWT.JAWT_MACOSX_USE_CALAYER);
-       return true;
+  public static JAWT getJAWT(boolean useOffscreenLayerIfAvailable) {
+    int jawt_version_flags = JAWTFactory.JAWT_VERSION_1_4;
+    if(useOffscreenLayerIfAvailable) {
+        switch(Platform.OS_TYPE) {
+            case MACOS:
+                if(Platform.OS_VERSION_NUMBER.compareTo(JAWT.JAWT_MacOSXCALayerMinVersion) >= 0) {
+                    jawt_version_flags |= JAWT.JAWT_MACOSX_USE_CALAYER;
+                }
+        }
     }
-    JAWT.setJAWTVersionFlags(JAWTFactory.JAWT_VERSION_1_4);
-    return !useOffscreenLayerIfAvailable; // n/a
+    return JAWT.getJAWT(jawt_version_flags);
   }
   
-  public static boolean isCachedJAWTUsingOffscreenLayer() {
-      return 0 != ( JAWT.getJAWT().getVersionCached() & JAWT.JAWT_MACOSX_USE_CALAYER );
+  public static boolean isJAWTUsingOffscreenLayer(JAWT jawt) {
+      return 0 != ( jawt.getCachedVersion() & JAWT.JAWT_MACOSX_USE_CALAYER );
   }
   
   static {
@@ -115,19 +113,19 @@ public class JAWTUtil {
     JAWTJNILibLoader.loadNativeWindow("awt");
 
     headlessMode = GraphicsEnvironment.isHeadless();
-    if(!headlessMode) {
-        JAWT.setJAWTVersionFlags(JAWTFactory.JAWT_VERSION_1_4);
-    }
     boolean ok = false;
     Class<?> jC = null;
     Method m = null;
     if (!headlessMode) {
+        jawtLockObject = getJAWT(false); // don't care for offscreen layer here
         try {
             jC = Class.forName("jogamp.opengl.awt.Java2D");
             m = jC.getMethod("isQueueFlusherThread", (Class[])null);
             ok = true;
         } catch (Exception e) {
         }
+    } else {
+        jawtLockObject = null; // headless !
     }
     isQueueFlusherThread = m;
     j2dExist = ok;
@@ -166,21 +164,21 @@ public class JAWTUtil {
     jawtToolkitLock = new JAWTToolkitLock();
 
     // trigger native AWT toolkit / properties initialization
-    Map desktophints = null;
+    Map<?,?> desktophints = null;
     try {
         if(EventQueue.isDispatchThread()) {
-            desktophints = (Map)(Toolkit.getDefaultToolkit().getDesktopProperty("awt.font.desktophints"));
+            desktophints = (Map<?,?>)(Toolkit.getDefaultToolkit().getDesktopProperty("awt.font.desktophints"));
         } else {
-            final ArrayList desktophintsBucket = new ArrayList(1);
+            final ArrayList<Map<?,?>> desktophintsBucket = new ArrayList<Map<?,?>>(1);
             EventQueue.invokeAndWait(new Runnable() {
                 public void run() {
-                    Map _desktophints = (Map)(Toolkit.getDefaultToolkit().getDesktopProperty("awt.font.desktophints"));
+                    Map<?,?> _desktophints = (Map<?,?>)(Toolkit.getDefaultToolkit().getDesktopProperty("awt.font.desktophints"));
                     if(null!=_desktophints) {
                         desktophintsBucket.add(_desktophints);
                     }
                 }
             });
-            desktophints = ( desktophintsBucket.size() > 0 ) ? (Map)desktophintsBucket.get(0) : null ;
+            desktophints = ( desktophintsBucket.size() > 0 ) ? desktophintsBucket.get(0) : null ;
         }
     } catch (InterruptedException ex) {
         ex.printStackTrace();
@@ -226,7 +224,7 @@ public class JAWTUtil {
    * JAWT's native Lock() function calls SunToolkit.awtLock(),
    * which just uses AWT's global ReentrantLock.<br>
    */
-  public static void awtLock() {
+  private static void awtLock() {
     if(hasSunToolkitAWTLock) {
         try {
             sunToolkitAWTLockMethod.invoke(null, (Object[])null);
@@ -234,7 +232,7 @@ public class JAWTUtil {
           throw new NativeWindowException("SunToolkit.awtLock failed", e);
         }
     } else {
-        JAWT.getJAWT().Lock();
+        jawtLockObject.Lock();
     }
   }
 
@@ -244,7 +242,7 @@ public class JAWTUtil {
    * JAWT's native Unlock() function calls SunToolkit.awtUnlock(),
    * which just uses AWT's global ReentrantLock.<br>
    */
-  public static void awtUnlock() {
+  private static void awtUnlock() {
     if(hasSunToolkitAWTLock) {
         try {
             sunToolkitAWTUnlockMethod.invoke(null, (Object[])null);
@@ -252,7 +250,7 @@ public class JAWTUtil {
           throw new NativeWindowException("SunToolkit.awtUnlock failed", e);
         }
     } else {
-        JAWT.getJAWT().Unlock();
+        jawtLockObject.Unlock();
     }
   }
 
diff --git a/src/nativewindow/classes/jogamp/nativewindow/jawt/JAWTWindow.java b/src/nativewindow/classes/jogamp/nativewindow/jawt/JAWTWindow.java
index efd3522b8..4d5fac891 100644
--- a/src/nativewindow/classes/jogamp/nativewindow/jawt/JAWTWindow.java
+++ b/src/nativewindow/classes/jogamp/nativewindow/jawt/JAWTWindow.java
@@ -48,6 +48,7 @@ import javax.media.nativewindow.AbstractGraphicsDevice;
 import javax.media.nativewindow.NativeSurface;
 import javax.media.nativewindow.NativeWindow;
 import javax.media.nativewindow.NativeWindowException;
+import javax.media.nativewindow.OffscreenLayerSurface;
 import javax.media.nativewindow.SurfaceUpdatedListener;
 import javax.media.nativewindow.awt.AWTGraphicsConfiguration;
 import javax.media.nativewindow.util.Insets;
@@ -58,16 +59,21 @@ import javax.media.nativewindow.util.RectangleImmutable;
 
 import jogamp.nativewindow.SurfaceUpdatedHelper;
 
-public abstract class JAWTWindow implements NativeWindow {
+public abstract class JAWTWindow implements NativeWindow, OffscreenLayerSurface {
   protected static final boolean DEBUG = JAWTUtil.DEBUG;
 
+  // user properties
+  protected boolean shallUseOffscreenLayer = false;
+  
   // lifetime: forever
   protected Component component;
-  protected boolean isApplet;
   protected AWTGraphicsConfiguration config;
   private SurfaceUpdatedHelper surfaceUpdatedHelper = new SurfaceUpdatedHelper();
 
-  // lifetime: valid after lock, forever until invalidate
+  // lifetime: valid after lock but may change with each 1st lock, purges after invalidate
+  private boolean isApplet;
+  private JAWT jawt;
+  private boolean isOffscreenLayerSurface;
   protected long drawable;
   protected Rectangle bounds;
 
@@ -93,16 +99,25 @@ public abstract class JAWTWindow implements NativeWindow {
     invalidate();
     this.component = windowObject;
     this.isApplet = false;
-    while(!isApplet && null != windowObject) {
-        isApplet = windowObject instanceof Applet;
-        windowObject = windowObject.getParent();
-    }
-    if(isApplet) {
-        JAWTUtil.setCachedJAWTVersionFlags(true); // useOffScreenLayerIfAvailable := true
-    }
     validateNative();
   }
   
+  /** 
+   * Request an JAWT offscreen layer if supported.
+   * Shall be called before {@link #lockSurface()}.
+   * 
+   * @see #getShallUseOffscreenLayer()
+   * @see #isOffscreenLayerSurfaceEnabled() 
+   */
+  public void setShallUseOffscreenLayer(boolean v) {
+      shallUseOffscreenLayer = v;
+  }
+  
+  /** Returns the property set by {@link #setShallUseOffscreenLayer(boolean)}. */
+  public final boolean getShallUseOffscreenLayer() {
+      return shallUseOffscreenLayer;
+  }
+  
   /**
    * Implementors shall ensure that all native handles are valid, eg. the {@link javax.media.nativewindow.awt.AWTGraphicsDevice AWTGraphicsDevice}'s
    * subtype via {@link javax.media.nativewindow.awt.AWTGraphicsDevice#setSubType(String, long) awtGraphicsDevice.setSubType(NativeWindowFactory.TYPE_X11, displayHandle)}.
@@ -116,6 +131,8 @@ public abstract class JAWTWindow implements NativeWindow {
 
   protected synchronized void invalidate() {
     invalidateNative();
+    jawt = null;
+    isOffscreenLayerSurface = false;
     drawable= 0;
     bounds = new Rectangle();
   }
@@ -137,10 +154,71 @@ public abstract class JAWTWindow implements NativeWindow {
     return component;
   }
   
+  /** 
+   * Returns true if the AWT component is parented to an {@link java.applet.Applet}, 
+   * otherwise false. This information is valid only after {@link #lockSurface()}. 
+   */
   public final boolean isApplet() {
       return isApplet;
   }
 
+  /** Returns the underlying JAWT instance created @ {@link #lockSurface()}. */
+  public final JAWT getJAWT() {
+      return jawt;
+  }
+
+  /** 
+   * {@inheritDoc}
+   * @see #setShallUseOffscreenLayer(boolean) 
+   */
+  public final boolean isOffscreenLayerSurfaceEnabled() { 
+      return isOffscreenLayerSurface;
+  }
+  
+  /** 
+   * {@inheritDoc}
+   */
+  public final void attachSurfaceLayer(final long layerHandle) throws NativeWindowException {  
+      if( !isOffscreenLayerSurfaceEnabled() ) {
+          throw new NativeWindowException("Not an offscreen layer surface");
+      }
+      int lockRes = lockSurface();
+      if (NativeSurface.LOCK_SURFACE_NOT_READY >= lockRes) {
+          throw new NativeWindowException("Could not lock (offscreen layer): "+this);
+      }
+      try {
+          if(DEBUG) {
+            System.err.println("JAWTWindow.attachSurfaceHandle(): 0x"+Long.toHexString(layerHandle));
+          }
+          attachSurfaceLayerImpl(layerHandle);
+      } finally {
+          unlockSurface();
+      }
+  }  
+  protected abstract void attachSurfaceLayerImpl(final long layerHandle);
+  
+  /** 
+   * {@inheritDoc}
+   */
+  public final void detachSurfaceLayer(final long layerHandle) throws NativeWindowException {  
+      if( !isOffscreenLayerSurfaceEnabled() ) {
+          throw new java.lang.UnsupportedOperationException("Not an offscreen layer surface");
+      }
+      int lockRes = lockSurface();
+      if (NativeSurface.LOCK_SURFACE_NOT_READY >= lockRes) {
+          throw new NativeWindowException("Could not lock (offscreen layer): "+this);
+      }
+      try {
+          if(DEBUG) {
+            System.err.println("JAWTWindow.detachSurfaceHandle(): 0x"+Long.toHexString(layerHandle));
+          }
+          detachSurfaceLayerImpl(layerHandle);
+      } finally {
+          unlockSurface();
+      }
+  }  
+  protected abstract void detachSurfaceLayerImpl(final long layerHandle);
+  
   //
   // SurfaceUpdateListener
   //
@@ -167,6 +245,24 @@ public abstract class JAWTWindow implements NativeWindow {
 
   private RecursiveLock surfaceLock = LockFactory.createRecursiveLock();
 
+  private void determineIfApplet() {
+    Component c = component;
+    while(!isApplet && null != c) {
+        isApplet = c instanceof Applet;
+        c = c.getParent();
+    }
+  }
+  
+  /**
+   * If JAWT offscreen layer is supported, 
+   * implementation shall respect {@link #getShallUseOffscreenLayer()}
+   * and may respect {@link #isApplet()}.
+   * 
+   * @return The JAWT instance reflecting offscreen layer support, etc.
+   * 
+   * @throws NativeWindowException
+   */
+  protected abstract JAWT fetchJAWTImpl() throws NativeWindowException;
   protected abstract int lockSurfaceImpl() throws NativeWindowException;
 
   public final int lockSurface() throws NativeWindowException {
@@ -175,10 +271,13 @@ public abstract class JAWTWindow implements NativeWindow {
     int res = surfaceLock.getHoldCount() == 1 ? LOCK_SURFACE_NOT_READY : LOCK_SUCCESS; // new lock ?
 
     if ( LOCK_SURFACE_NOT_READY == res ) {
+        determineIfApplet();
         try {
             final AbstractGraphicsDevice adevice = config.getScreen().getDevice();
             adevice.lock();
             try {
+                jawt = fetchJAWTImpl();
+                isOffscreenLayerSurface = JAWTUtil.isJAWTUsingOffscreenLayer(jawt);
                 res = lockSurfaceImpl();
             } finally {
                 if (LOCK_SURFACE_NOT_READY >= res) {
diff --git a/src/nativewindow/classes/jogamp/nativewindow/jawt/macosx/MacOSXJAWTWindow.java b/src/nativewindow/classes/jogamp/nativewindow/jawt/macosx/MacOSXJAWTWindow.java
index c19569606..de7feb3b8 100644
--- a/src/nativewindow/classes/jogamp/nativewindow/jawt/macosx/MacOSXJAWTWindow.java
+++ b/src/nativewindow/classes/jogamp/nativewindow/jawt/macosx/MacOSXJAWTWindow.java
@@ -63,8 +63,9 @@ import jogamp.nativewindow.macosx.OSXUtil;
 public class MacOSXJAWTWindow extends JAWTWindow implements SurfaceChangeable {
   public MacOSXJAWTWindow(Object comp, AbstractGraphicsConfiguration config) {
     super(comp, config);
-    isOffscreenLayerSurface = JAWTUtil.isCachedJAWTUsingOffscreenLayer();
-    dumpInfo();
+    if(DEBUG) {
+        dumpInfo();
+    }
   }
 
   protected void validateNative() throws NativeWindowException {
@@ -72,7 +73,7 @@ public class MacOSXJAWTWindow extends JAWTWindow implements SurfaceChangeable {
 
   protected void invalidateNative() {
       surfaceHandle=0;
-      if(isOffscreenLayerSurface) {
+      if(isOffscreenLayerSurfaceEnabled()) {
           if(0 != drawable) {
               OSXUtil.DestroyNSWindow(drawable);
               drawable = 0;
@@ -80,50 +81,20 @@ public class MacOSXJAWTWindow extends JAWTWindow implements SurfaceChangeable {
       }
   }
 
-  public final boolean isOffscreenLayerSurface() { 
-      return isOffscreenLayerSurface;
-  }  
-  public void attachSurfaceLayer(final long layerHandle) {
-      if( !isOffscreenLayerSurface() ) {
-          throw new NativeWindowException("Not using CALAYER");
-      }
-      int lockRes = lockSurface();
-      if (NativeSurface.LOCK_SURFACE_NOT_READY >= lockRes) {
-          throw new NativeWindowException("Could not lock layeredSurfaceHost: "+this);
-      }
-      try {
-          if(DEBUG) {
-            System.err.println("MacOSXJAWTWindow.attachSurfaceLayer(): 0x"+Long.toHexString(layerHandle));
-          }
-          OSXUtil.AddCASublayer(rootSurfaceLayerHandle, layerHandle);
-      } finally {
-          unlockSurface();
-      }
+  protected void attachSurfaceLayerImpl(final long layerHandle) {
+      OSXUtil.AddCASublayer(rootSurfaceLayerHandle, layerHandle);
   }
-  public void detachSurfaceLayer(final long layerHandle) {
-      if( !isOffscreenLayerSurface() ) {
-          throw new NativeWindowException("Not using CALAYER");
-      }
-      int lockRes = lockSurface();
-      if (NativeSurface.LOCK_SURFACE_NOT_READY >= lockRes) {
-          throw new NativeWindowException("Could not lock layeredSurfaceHost: "+this);
-      }
-      try {
-          if(DEBUG) {
-            System.err.println("MacOSXJAWTWindow.detachSurfaceLayer(): 0x"+Long.toHexString(layerHandle));
-          }
-          OSXUtil.RemoveCASublayer(rootSurfaceLayerHandle, layerHandle);
-      } finally {
-          unlockSurface();
-      }
+  
+  protected void detachSurfaceLayerImpl(final long layerHandle) {
+      OSXUtil.RemoveCASublayer(rootSurfaceLayerHandle, layerHandle);
   }
     
   public long getSurfaceHandle() {
-    return isOffscreenLayerSurface ? surfaceHandle : super.getSurfaceHandle() ;
+    return isOffscreenLayerSurfaceEnabled() ? surfaceHandle : super.getSurfaceHandle() ;
   }
   
   public void setSurfaceHandle(long surfaceHandle) {
-      if( !isOffscreenLayerSurface() ) {
+      if( !isOffscreenLayerSurfaceEnabled() ) {
           throw new java.lang.UnsupportedOperationException("Not using CALAYER");
       }
       if(DEBUG) {
@@ -147,11 +118,14 @@ public class MacOSXJAWTWindow extends JAWTWindow implements SurfaceChangeable {
     return sscSet ? sscHeight: super.getHeight();
   }
 
+  protected JAWT fetchJAWTImpl() throws NativeWindowException {
+       // use offscreen if supported and [ applet or requested ]
+      return JAWTUtil.getJAWT(getShallUseOffscreenLayer() || isApplet());
+  }
   protected int lockSurfaceImpl() throws NativeWindowException {
     int ret = NativeWindow.LOCK_SURFACE_NOT_READY;
     if(null == ds) {
-        final JAWT jawt = JAWT.getJAWT();
-        ds = jawt.GetDrawingSurface(component);
+        ds = getJAWT().GetDrawingSurface(component);
         if (ds == null) {
           // Widget not yet realized
           unlockSurfaceImpl();
@@ -189,12 +163,12 @@ public class MacOSXJAWTWindow extends JAWTWindow implements SurfaceChangeable {
         }
     }
     updateBounds(dsi.getBounds());
-    if (DEBUG && firstLock) {
+    if (DEBUG && firstLock ) {
       dumpInfo();
     }
     firstLock = false;
-    if( !isOffscreenLayerSurface ) {
-        macosxdsi = (JAWT_MacOSXDrawingSurfaceInfo) dsi.platformInfo();
+    if( !isOffscreenLayerSurfaceEnabled() ) {
+        macosxdsi = (JAWT_MacOSXDrawingSurfaceInfo) dsi.platformInfo(getJAWT());
         if (macosxdsi == null) {
           unlockSurfaceImpl();
           return NativeWindow.LOCK_SURFACE_NOT_READY;
@@ -257,7 +231,7 @@ public class MacOSXJAWTWindow extends JAWTWindow implements SurfaceChangeable {
         if (dsLocked) {
             ds.Unlock();
         }
-        JAWT.getJAWT().FreeDrawingSurface(ds);
+        getJAWT().FreeDrawingSurface(ds);
     }
     ds = null;
     dsi = null;
@@ -265,10 +239,13 @@ public class MacOSXJAWTWindow extends JAWTWindow implements SurfaceChangeable {
 
   private void dumpInfo() {
       System.err.println("MaxOSXJAWTWindow: 0x"+Integer.toHexString(this.hashCode())+" - thread: "+Thread.currentThread().getName());
-      // System.err.println(this);
-      System.err.println("JAWT version: 0x"+Integer.toHexString(JAWT.getJAWT().getVersionCached())+
-                         ", CA_LAYER: "+ (0!=(JAWT.getJAWT().getVersionCached() & JAWT.JAWT_MACOSX_USE_CALAYER))+
-                         ", isLayeredSurface "+isOffscreenLayerSurface()+", bounds "+bounds);
+      if(null != getJAWT()) {
+          System.err.println("JAWT version: 0x"+Integer.toHexString(getJAWT().getCachedVersion())+
+                             ", CA_LAYER: "+ JAWTUtil.isJAWTUsingOffscreenLayer(getJAWT())+
+                             ", isLayeredSurface "+isOffscreenLayerSurfaceEnabled()+", bounds "+bounds);
+      } else {
+          System.err.println("JAWT n/a, bounds "+bounds);          
+      }
       // Thread.dumpStack();
   }
   
@@ -291,7 +268,6 @@ public class MacOSXJAWTWindow extends JAWTWindow implements SurfaceChangeable {
   
   private JAWT_MacOSXDrawingSurfaceInfo macosxdsi;
   
-  private final boolean isOffscreenLayerSurface;
   private long rootSurfaceLayerHandle = 0; // is autoreleased, once it is attached to the JAWT_SurfaceLayer
   
   private long surfaceHandle = 0;
diff --git a/src/nativewindow/classes/jogamp/nativewindow/jawt/windows/WindowsJAWTWindow.java b/src/nativewindow/classes/jogamp/nativewindow/jawt/windows/WindowsJAWTWindow.java
index 610ce0f15..581e2337c 100644
--- a/src/nativewindow/classes/jogamp/nativewindow/jawt/windows/WindowsJAWTWindow.java
+++ b/src/nativewindow/classes/jogamp/nativewindow/jawt/windows/WindowsJAWTWindow.java
@@ -47,6 +47,7 @@ import javax.media.nativewindow.util.Point;
 
 import jogamp.nativewindow.jawt.JAWT;
 import jogamp.nativewindow.jawt.JAWTFactory;
+import jogamp.nativewindow.jawt.JAWTUtil;
 import jogamp.nativewindow.jawt.JAWTWindow;
 import jogamp.nativewindow.jawt.JAWT_DrawingSurface;
 import jogamp.nativewindow.jawt.JAWT_DrawingSurfaceInfo;
@@ -65,9 +66,20 @@ public class WindowsJAWTWindow extends JAWTWindow {
     windowHandle = 0;
   }
 
+  protected void attachSurfaceLayerImpl(final long layerHandle) {
+      throw new UnsupportedOperationException("offscreen layer not supported");
+  }
+  protected void detachSurfaceLayerImpl(final long layerHandle) {
+      throw new UnsupportedOperationException("offscreen layer not supported");
+  }
+  
+  protected JAWT fetchJAWTImpl() throws NativeWindowException {
+      return JAWTUtil.getJAWT(false); // no offscreen
+  }
+  
   protected int lockSurfaceImpl() throws NativeWindowException {
     int ret = NativeWindow.LOCK_SUCCESS;
-    ds = JAWT.getJAWT().GetDrawingSurface(component);
+    ds = getJAWT().GetDrawingSurface(component);
     if (ds == null) {
       // Widget not yet realized
       unlockSurfaceImpl();
@@ -92,7 +104,8 @@ public class WindowsJAWTWindow extends JAWTWindow {
       unlockSurfaceImpl();
       return LOCK_SURFACE_NOT_READY;
     }
-    win32dsi = (JAWT_Win32DrawingSurfaceInfo) dsi.platformInfo();
+    updateBounds(dsi.getBounds());
+    win32dsi = (JAWT_Win32DrawingSurfaceInfo) dsi.platformInfo(getJAWT());
     if (win32dsi == null) {
       unlockSurfaceImpl();
       return LOCK_SURFACE_NOT_READY;
@@ -102,14 +115,11 @@ public class WindowsJAWTWindow extends JAWTWindow {
     if (windowHandle == 0 || drawable == 0) {
       unlockSurfaceImpl();
       return LOCK_SURFACE_NOT_READY;
-    } else {
-      updateBounds(dsi.getBounds());
     }
     return ret;
   }
 
   protected void unlockSurfaceImpl() throws NativeWindowException {
-    long startTime = 0;
     if(null!=ds) {
         if (null!=dsi) {
             ds.FreeDrawingSurfaceInfo(dsi);
@@ -117,7 +127,7 @@ public class WindowsJAWTWindow extends JAWTWindow {
         if (dsLocked) {
             ds.Unlock();
         }
-        JAWT.getJAWT().FreeDrawingSurface(ds);
+        getJAWT().FreeDrawingSurface(ds);
     }
     ds = null;
     dsi = null;
diff --git a/src/nativewindow/classes/jogamp/nativewindow/jawt/x11/X11JAWTWindow.java b/src/nativewindow/classes/jogamp/nativewindow/jawt/x11/X11JAWTWindow.java
index 16dcf11fe..e469fe337 100644
--- a/src/nativewindow/classes/jogamp/nativewindow/jawt/x11/X11JAWTWindow.java
+++ b/src/nativewindow/classes/jogamp/nativewindow/jawt/x11/X11JAWTWindow.java
@@ -48,6 +48,7 @@ import javax.media.nativewindow.util.Point;
 
 import jogamp.nativewindow.jawt.JAWT;
 import jogamp.nativewindow.jawt.JAWTFactory;
+import jogamp.nativewindow.jawt.JAWTUtil;
 import jogamp.nativewindow.jawt.JAWTWindow;
 import jogamp.nativewindow.jawt.JAWT_DrawingSurface;
 import jogamp.nativewindow.jawt.JAWT_DrawingSurfaceInfo;
@@ -88,9 +89,20 @@ public class X11JAWTWindow extends JAWTWindow {
   
   protected void invalidateNative() { }
 
+  protected void attachSurfaceLayerImpl(final long layerHandle) {
+      throw new UnsupportedOperationException("offscreen layer not supported");
+  }
+  protected void detachSurfaceLayerImpl(final long layerHandle) {
+      throw new UnsupportedOperationException("offscreen layer not supported");
+  }
+  
+  protected JAWT fetchJAWTImpl() throws NativeWindowException {
+      return JAWTUtil.getJAWT(false); // no offscreen
+  }
+    
   protected int lockSurfaceImpl() throws NativeWindowException {
     int ret = NativeWindow.LOCK_SUCCESS;
-    ds = JAWT.getJAWT().GetDrawingSurface(component);
+    ds = getJAWT().GetDrawingSurface(component);
     if (ds == null) {
       // Widget not yet realized
       unlockSurfaceImpl();
@@ -115,7 +127,8 @@ public class X11JAWTWindow extends JAWTWindow {
       unlockSurfaceImpl();
       return LOCK_SURFACE_NOT_READY;
     }
-    x11dsi = (JAWT_X11DrawingSurfaceInfo) dsi.platformInfo();
+    updateBounds(dsi.getBounds());
+    x11dsi = (JAWT_X11DrawingSurfaceInfo) dsi.platformInfo(getJAWT());
     if (x11dsi == null) {
       unlockSurfaceImpl();
       return LOCK_SURFACE_NOT_READY;
@@ -124,8 +137,6 @@ public class X11JAWTWindow extends JAWTWindow {
     if (drawable == 0) {
       unlockSurfaceImpl();
       return LOCK_SURFACE_NOT_READY;
-    } else {
-      updateBounds(dsi.getBounds());
     }
     return ret;
   }
@@ -138,7 +149,7 @@ public class X11JAWTWindow extends JAWTWindow {
         if (dsLocked) {
             ds.Unlock();
         }
-        JAWT.getJAWT().FreeDrawingSurface(ds);
+        getJAWT().FreeDrawingSurface(ds);
     }
     ds = null;
     dsi = null;