Fix Capabilities ambiguity and explosion of queried available-list; Add FBO availability detection for EGL, WGL and OSX.

Introducing Capabilities 'bitmap' boolean, complementing the offscreen modes FBO and PBuffer.
This allows:
  1 - deterministic setting of the offscreen mode

  2 - utilizing auto configuration of offscreen mode, if !onscreen !FBO !PBuffer and !Bitmap

  3 - adding 'availability' semantic of 'onscreen' boolean,
      i.e. if onscree:=1 for a queried instance, the offscreen modes still indicate offscreen
      availability - see [4]

  4 - avoiding explosion of the availability list due to [3],
      one Capability entry reflect on- and offscreen settings.

Add FBO availability detection for EGL, WGL and OSX.

Tested manually w/ 'TestGLCapabilities01NEWT' on X11 [NV, ATI], WGL[NV], OSX[NV].

21 files changed, 841 insertions, 455 deletions

diff --git a/src/jogl/classes/javax/media/opengl/DefaultGLCapabilitiesChooser.java b/src/jogl/classes/javax/media/opengl/DefaultGLCapabilitiesChooser.java
index 5fa8ce32d..b052769ca 100644
--- a/src/jogl/classes/javax/media/opengl/DefaultGLCapabilitiesChooser.java
+++ b/src/jogl/classes/javax/media/opengl/DefaultGLCapabilitiesChooser.java
@@ -87,20 +87,20 @@ import jogamp.opengl.Debug;
 public class DefaultGLCapabilitiesChooser implements GLCapabilitiesChooser {
   private static final boolean DEBUG = Debug.isPropertyDefined("jogl.debug.CapabilitiesChooser", true);
 
-  final static int NO_SCORE = -9999999;
-  final static int DOUBLE_BUFFER_MISMATCH_PENALTY = 1000;
-  final static int OPAQUE_MISMATCH_PENALTY = 750;
-  final static int STENCIL_MISMATCH_PENALTY = 500;
-  final static int MULTISAMPLE_MISMATCH_PENALTY = 500;
-  final static int MULTISAMPLE_EXTENSION_MISMATCH_PENALTY = 250; // just a little drop, no scale
+  private final static int NO_SCORE = -9999999;
+  private final static int DOUBLE_BUFFER_MISMATCH_PENALTY = 1000;
+  private final static int OPAQUE_MISMATCH_PENALTY = 750;
+  private final static int STENCIL_MISMATCH_PENALTY = 500;
+  private final static int MULTISAMPLE_MISMATCH_PENALTY = 500;
+  private final static int MULTISAMPLE_EXTENSION_MISMATCH_PENALTY = 250; // just a little drop, no scale
   // Pseudo attempt to keep equal rank penalties scale-equivalent
   // (e.g., stencil mismatch is 3 * accum because there are 3 accum
   // components)
-  final static int COLOR_MISMATCH_PENALTY_SCALE     = 36;
-  final static int DEPTH_MISMATCH_PENALTY_SCALE     = 6;
-  final static int ACCUM_MISMATCH_PENALTY_SCALE     = 1;
-  final static int STENCIL_MISMATCH_PENALTY_SCALE   = 3;
-  final static int MULTISAMPLE_MISMATCH_PENALTY_SCALE   = 3;
+  private final static int COLOR_MISMATCH_PENALTY_SCALE     = 36;
+  private final static int DEPTH_MISMATCH_PENALTY_SCALE     = 6;
+  private final static int ACCUM_MISMATCH_PENALTY_SCALE     = 1;
+  private final static int STENCIL_MISMATCH_PENALTY_SCALE   = 3;
+  private final static int MULTISAMPLE_MISMATCH_PENALTY_SCALE   = 3;
   
   @Override
   public int chooseCapabilities(final CapabilitiesImmutable desired,
@@ -150,11 +150,20 @@ public class DefaultGLCapabilitiesChooser implements GLCapabilitiesChooser {
       if (cur == null) {
         continue;
       }
-      if (gldes.isOnscreen() != cur.isOnscreen()) {
-        continue;
+      if (gldes.isOnscreen() && !cur.isOnscreen()) {
+        continue; // requested onscreen, but n/a
       }
-      if (!gldes.isOnscreen() && gldes.isPBuffer() && !cur.isPBuffer()) {
-        continue; // only skip if requested Offscreen && PBuffer, but no PBuffer available
+      if (!gldes.isOnscreen()) {
+          /** FBO is generic ..
+          if (gldes.isFBO() && !cur.isFBO()) {
+            continue; // requested FBO, but n/a
+          }  */
+          if (gldes.isPBuffer() && !cur.isPBuffer()) {
+            continue; // requested pBuffer, but n/a
+          }          
+          if (gldes.isBitmap() && !cur.isBitmap()) {
+            continue; // requested pBuffer, but n/a
+          }          
       }
       if (gldes.getStereo() != cur.getStereo()) {
         continue;
diff --git a/src/jogl/classes/javax/media/opengl/GLCapabilities.java b/src/jogl/classes/javax/media/opengl/GLCapabilities.java
index 8845ec665..30a6215e7 100644
--- a/src/jogl/classes/javax/media/opengl/GLCapabilities.java
+++ b/src/jogl/classes/javax/media/opengl/GLCapabilities.java
@@ -105,20 +105,21 @@ public class GLCapabilities extends Capabilities implements Cloneable, GLCapabil
   @Override
   public int hashCode() {
     // 31 * x == (x << 5) - x
-    int hash = 31 + this.glProfile.hashCode() ;
+    int hash = super.hashCode(); 
+    hash = ((hash << 5) - hash) + this.glProfile.hashCode() ;
+    hash = ((hash << 5) - hash) + ( this.hardwareAccelerated ? 1 : 0 );
+    hash = ((hash << 5) - hash) + ( this.stereo ? 1 : 0 );
     hash = ((hash << 5) - hash) + ( this.isFBO ? 1 : 0 );
     hash = ((hash << 5) - hash) + ( this.isPBuffer ? 1 : 0 );
-    hash = ((hash << 5) - hash) + ( this.stereo ? 1 : 0 );
-    hash = ((hash << 5) - hash) + ( this.hardwareAccelerated ? 1 : 0 );
+    hash = ((hash << 5) - hash) + ( this.sampleBuffers ? 1 : 0 );
+    hash = ((hash << 5) - hash) + this.getNumSamples();
+    hash = ((hash << 5) - hash) + this.sampleExtension.hashCode();
     hash = ((hash << 5) - hash) + this.depthBits;
     hash = ((hash << 5) - hash) + this.stencilBits;
     hash = ((hash << 5) - hash) + this.accumRedBits;
     hash = ((hash << 5) - hash) + this.accumGreenBits;
     hash = ((hash << 5) - hash) + this.accumBlueBits;
     hash = ((hash << 5) - hash) + this.accumAlphaBits;
-    hash = ((hash << 5) - hash) + ( this.sampleBuffers ? 1 : 0 );
-    hash = ((hash << 5) - hash) + this.numSamples;
-    hash = ((hash << 5) - hash) + this.sampleExtension.hashCode();
     hash = ((hash << 5) - hash) + ( this.pbufferFloatingPointBuffers ? 1 : 0 );
     hash = ((hash << 5) - hash) + ( this.pbufferRenderToTexture ? 1 : 0 );
     hash = ((hash << 5) - hash) + ( this.pbufferRenderToTextureRectangle ? 1 : 0 );
@@ -148,9 +149,8 @@ public class GLCapabilities extends Capabilities implements Cloneable, GLCapabil
                   other.getPbufferFloatingPointBuffers()==pbufferFloatingPointBuffers &&
                   other.getPbufferRenderToTexture()==pbufferRenderToTexture &&
                   other.getPbufferRenderToTextureRectangle()==pbufferRenderToTextureRectangle;
-    if(sampleBuffers) {
-        res = res &&
-              other.getNumSamples()==numSamples &&
+    if(res && sampleBuffers) {
+        res = other.getNumSamples()==getNumSamples() &&
               other.getSampleExtension().equals(sampleExtension) ;
     }
     return res;
@@ -222,19 +222,24 @@ public class GLCapabilities extends Capabilities implements Cloneable, GLCapabil
   public void setGLProfile(GLProfile profile) {
     glProfile=profile;
   }
-
+  
   @Override
   public final boolean isPBuffer() {
     return isPBuffer;
   }
 
   /**
-   * Enables or disables pbuffer usage.
+   * Requesting offscreen pbuffer mode.
    * <p>
    * If enabled this method also invokes {@link #setOnscreen(int) setOnscreen(false)}.
    * </p>
+   * <p>
    * Defaults to false.
-   */
+   * </p>
+   * <p>
+   * Requesting offscreen pbuffer mode disables the offscreen auto selection.
+   * </p>
+   */  
   public void setPBuffer(boolean enable) {
     if(enable) {
       setOnscreen(false);
@@ -248,11 +253,16 @@ public class GLCapabilities extends Capabilities implements Cloneable, GLCapabil
   }
   
   /**
-   * Enables or disables FBO usage.
+   * Requesting offscreen FBO mode.
    * <p>
    * If enabled this method also invokes {@link #setOnscreen(int) setOnscreen(false)}.
    * </p>
+   * <p>
    * Defaults to false.
+   * </p>
+   * <p>
+   * Requesting offscreen FBO mode disables the offscreen auto selection.
+   * </p>
    */
   public void setFBO(boolean enable) {
     if(enable) {
@@ -261,21 +271,6 @@ public class GLCapabilities extends Capabilities implements Cloneable, GLCapabil
     isFBO = enable;
   }
 
-  /**
-   * Sets whether the drawable surface supports onscreen.<br>
-   * If enabled this method also invokes {@link #setPBuffer(int) setPBuffer(false)}
-   * and {@link #setFBO(int) setFBO(false)}<br>
-   * Defaults to true.
-  */
-  @Override
-  public void setOnscreen(boolean onscreen) {
-    if(onscreen) {
-        setPBuffer(false);
-        setFBO(false);
-    }
-    super.setOnscreen(onscreen);
-  }
-
   @Override
   public final boolean getDoubleBuffered() {
     return doubleBuffered;
@@ -465,9 +460,9 @@ public class GLCapabilities extends Capabilities implements Cloneable, GLCapabil
         sink = new StringBuilder();
     }
 
-    int samples = sampleBuffers ? numSamples : 0 ;
+    final int samples = sampleBuffers ? numSamples : 0 ;
 
-    super.toString(sink);
+    super.toString(sink, false);
 
     sink.append(", accum-rgba ").append(accumRedBits).append("/").append(accumGreenBits).append("/").append(accumBlueBits).append("/").append(accumAlphaBits);
     sink.append(", dp/st/ms: ").append(depthBits).append("/").append(stencilBits).append("/").append(samples);
@@ -490,20 +485,37 @@ public class GLCapabilities extends Capabilities implements Cloneable, GLCapabil
         sink.append(", sw, ");
     }
     sink.append(glProfile);
-    if(!isOnscreen()) {
-        if(isFBO) {
-            sink.append(", fbo");
-        } 
-        if(isPBuffer) {
-            sink.append(", pbuffer [r2t ").append(pbufferRenderToTexture?1:0)
-                .append(", r2tr ").append(pbufferRenderToTextureRectangle?1:0)
-                .append(", float ").append(pbufferFloatingPointBuffers?1:0)
-                .append("]");
-        } 
-        if(!isFBO && !isPBuffer) {
-            sink.append(", pixmap");
+    if(isOnscreen()) {
+        sink.append(", on-scr[");
+    } else {
+        sink.append(", offscr[");
+    }
+    boolean ns=false;
+    if(isFBO()) {
+        sink.append("fbo");
+        ns = true;
+    }
+    if(isPBuffer()) {
+        if(ns) { sink.append(", "); }
+        sink.append("pbuffer [r2t ").append(pbufferRenderToTexture?1:0)
+            .append(", r2tr ").append(pbufferRenderToTextureRectangle?1:0)
+            .append(", float ").append(pbufferFloatingPointBuffers?1:0)
+            .append("]");                
+        ns = true;
+    }
+    if(isBitmap()) {
+        if(ns) { sink.append(", "); }
+        sink.append("bitmap");
+        ns = true;
+    }
+    if(!ns) { // !FBO !PBuffer !Bitmap
+        if(isOnscreen()) {
+            sink.append(".");        // no additional off-screen modes besides on-screen
+        } else {
+            sink.append("auto-cfg"); // auto-config off-screen mode            
         }
     }
+    sink.append("]");
 
     return sink;
   }
diff --git a/src/jogl/classes/javax/media/opengl/GLCapabilitiesImmutable.java b/src/jogl/classes/javax/media/opengl/GLCapabilitiesImmutable.java
index 7e0459b2d..ee261ca01 100644
--- a/src/jogl/classes/javax/media/opengl/GLCapabilitiesImmutable.java
+++ b/src/jogl/classes/javax/media/opengl/GLCapabilitiesImmutable.java
@@ -50,7 +50,7 @@ public interface GLCapabilitiesImmutable extends CapabilitiesImmutable {
     GLProfile getGLProfile();
 
     /**
-     * Returns the number of bits requested for the accumulation
+     * Returns the number of bits for the accumulation
      * buffer's alpha component. On some systems only the accumulation
      * buffer depth, which is the sum of the red, green, and blue bits,
      * is considered.
@@ -58,7 +58,7 @@ public interface GLCapabilitiesImmutable extends CapabilitiesImmutable {
     int getAccumAlphaBits();
 
     /**
-     * Returns the number of bits requested for the accumulation
+     * Returns the number of bits for the accumulation
      * buffer's blue component. On some systems only the accumulation
      * buffer depth, which is the sum of the red, green, and blue bits,
      * is considered.
@@ -66,7 +66,7 @@ public interface GLCapabilitiesImmutable extends CapabilitiesImmutable {
     int getAccumBlueBits();
 
     /**
-     * Returns the number of bits requested for the accumulation
+     * Returns the number of bits for the accumulation
      * buffer's green component. On some systems only the accumulation
      * buffer depth, which is the sum of the red, green, and blue bits,
      * is considered.
@@ -74,7 +74,7 @@ public interface GLCapabilitiesImmutable extends CapabilitiesImmutable {
     int getAccumGreenBits();
 
     /**
-     * Returns the number of bits requested for the accumulation
+     * Returns the number of bits for the accumulation
      * buffer's red component. On some systems only the accumulation
      * buffer depth, which is the sum of the red, green, and blue bits,
      * is considered.
@@ -82,74 +82,115 @@ public interface GLCapabilitiesImmutable extends CapabilitiesImmutable {
     int getAccumRedBits();
 
     /**
-     * Returns the number of bits requested for the depth buffer.
+     * Returns the number of depth buffer bits.
      */
     int getDepthBits();
 
     /**
-     * Indicates whether double-buffering is enabled.
+     * Returns whether double-buffering is requested, available or chosen.
+     * <p>
+     * Default is true.
+     * </p>
      */
     boolean getDoubleBuffered();
 
     /**
-     * Indicates whether hardware acceleration is enabled.
+     * Returns whether hardware acceleration is requested, available or chosen.
+     * <p>
+     * Default is true.
+     * </p>
      */
     boolean getHardwareAccelerated();
 
     /**
-     * Returns the used extension for full-scene antialiasing
-     * (FSAA), default is {@link #DEFAULT_SAMPLE_EXTENSION}.
+     * Returns the extension for full-scene antialiasing
+     * (FSAA).
+     * <p>
+     * Default is {@link #DEFAULT_SAMPLE_EXTENSION}.
+     * </p>
      */
     String getSampleExtension();
     
     /**
      * Returns whether sample buffers for full-scene antialiasing
-     * (FSAA) should be allocated for this drawable. Defaults to
-     * false.
+     * (FSAA) should be allocated for this drawable. 
+     * <p>
+     * Default is false.
+     * </p>
      */
     boolean getSampleBuffers();
 
     /**
      * Returns the number of sample buffers to be allocated if sample
-     * buffers are enabled, otherwise returns 0. Defaults to 2.
+     * buffers are enabled, otherwise returns 0.
+     * <p>
+     * Default is 0 due to disable sample buffers per default.
+     * </p>
      */
     int getNumSamples();
 
     /**
      * For pbuffers only, returns whether floating-point buffers should
-     * be used if available. Defaults to false.
+     * be used if available. 
+     * <p>
+     * Default is false.
+     * </p>
      */
     boolean getPbufferFloatingPointBuffers();
 
     /**
      * For pbuffers only, returns whether the render-to-texture
-     * extension should be used if available.  Defaults to false.
+     * extension should be used if available.  
+     * <p>
+     * Default is false.
+     * </p>
      */
     boolean getPbufferRenderToTexture();
 
     /**
      * For pbuffers only, returns whether the render-to-texture
-     * extension should be used. Defaults to false.
+     * extension should be used. 
+     * <p>
+     * Default is false.
+     * </p>
      */
     boolean getPbufferRenderToTextureRectangle();
 
     /**
-     * Returns the number of bits requested for the stencil buffer.
+     * Returns the number of stencil buffer bits.
+     * <p>
+     * Default is 0.
+     * </p>
      */
     int getStencilBits();
 
     /**
-     * Indicates whether stereo is enabled.
+     * Returns whether stereo is requested, available or chosen.
+     * <p>
+     * Default is false.
+     * </p>
      */
     boolean getStereo();
 
     /**
-     * Indicates whether pbuffer offscreen is used/requested.
+     * Returns whether pbuffer offscreen mode is requested, available or chosen.
+     * <p>
+     * Default is false.
+     * </p>
+     * <p>
+     * For chosen capabilities, only the selected offscreen surface is set to <code>true</code>.
+     * </p>
      */
     boolean isPBuffer();
 
     /**
-     * Indicates whether FBO offscreen is used/requested.
+     * Returns whether FBO offscreen mode is requested, available or chosen.
+     * <p>
+     * Default is false.
+     * </p>
+     * <p>
+     * For chosen capabilities, only the selected offscreen surface is set to <code>true</code>.
+     * </p>
      */
     boolean isFBO();
 
diff --git a/src/jogl/classes/jogamp/opengl/GLDrawableFactoryImpl.java b/src/jogl/classes/jogamp/opengl/GLDrawableFactoryImpl.java
index 2f2bf5961..e1e253d35 100644
--- a/src/jogl/classes/jogamp/opengl/GLDrawableFactoryImpl.java
+++ b/src/jogl/classes/jogamp/opengl/GLDrawableFactoryImpl.java
@@ -271,7 +271,10 @@ public abstract class GLDrawableFactoryImpl extends GLDrawableFactory {
         throw new GLException("No shared device for requested: "+deviceReq);
     }
     
-    if( capsRequested.isFBO() && GLContext.isFBOAvailable(device, capsRequested.getGLProfile()) ) {
+    final GLCapabilitiesImmutable capsChosen = GLGraphicsConfigurationUtil.fixOffscreenGLCapabilities(capsRequested, 
+                                                        GLContext.isFBOAvailable(device, capsRequested.getGLProfile()), 
+                                                        canCreateGLPbuffer(device));    
+    if( capsChosen.isFBO() ) {
         device.lock();
         try {
             return createFBODrawableImpl(device, capsRequested, chooser, width, height);
@@ -280,7 +283,6 @@ public abstract class GLDrawableFactoryImpl extends GLDrawableFactory {
         }
     }
     
-    final GLCapabilitiesImmutable capsChosen = GLGraphicsConfigurationUtil.fixOffscreenGLCapabilities(capsRequested, false, canCreateGLPbuffer(device));
     device.lock();
     try {
         return createOffscreenDrawableImpl( createMutableSurfaceImpl(device, true, capsChosen, capsRequested, chooser, width, height, null) );
diff --git a/src/jogl/classes/jogamp/opengl/GLGraphicsConfigurationUtil.java b/src/jogl/classes/jogamp/opengl/GLGraphicsConfigurationUtil.java
index 3f38f33bc..d8e5ba31a 100644
--- a/src/jogl/classes/jogamp/opengl/GLGraphicsConfigurationUtil.java
+++ b/src/jogl/classes/jogamp/opengl/GLGraphicsConfigurationUtil.java
@@ -28,7 +28,6 @@
 
 package jogamp.opengl;
 
-import java.util.List;
 
 import javax.media.opengl.GLCapabilities;
 import javax.media.opengl.GLCapabilitiesImmutable;
@@ -74,56 +73,60 @@ public class GLGraphicsConfigurationUtil {
     }
 
     /**
-     * @param isFBO TODO
-     * @return bitmask representing the input boolean in exclusive or logic, ie only one bit will be set
+    public static final int getWinAttributeBits(boolean isOnscreen, boolean isFBO, boolean isPBuffer, boolean isBitmap) {
+        int winattrbits = 0;
+        if(isOnscreen) {
+            winattrbits |= WINDOW_BIT;
+        }
+        if(isFBO) {
+            winattrbits |= FBO_BIT;
+        } 
+        if(isPBuffer ){
+            winattrbits |= PBUFFER_BIT;
+        } 
+        if(isBitmap) {
+            winattrbits |= BITMAP_BIT;                
+        }
+        return winattrbits;
+    }
+    public static final int getWinAttributeBits(GLCapabilitiesImmutable caps) {
+        return getWinAttributeBits(caps.isOnscreen(), caps.isFBO(), caps.isPBuffer(), caps.isBitmap());
+    } */
+
+    /**
+     * @return bitmask representing the input boolean in exclusive or logic, ie only one bit will be set.
      */
-    public static final int getWinAttributeBits(boolean isOnscreen, boolean isPBuffer, boolean isFBO) {
+    public static final int getExclusiveWinAttributeBits(boolean isOnscreen, boolean isFBO, boolean isPBuffer, boolean isBitmap) {
         int winattrbits = 0;
         if(isOnscreen) {
             winattrbits |= WINDOW_BIT;
-        } else {
-            if(isFBO) {
-                winattrbits |= FBO_BIT;
-            }
-            if (!isPBuffer) {
-                winattrbits |= BITMAP_BIT;
-            } else {
-                winattrbits |= PBUFFER_BIT;
-            }
+        } else if(isFBO) {
+            winattrbits |= FBO_BIT;
+        } else if(isPBuffer ){
+            winattrbits |= PBUFFER_BIT;
+        } else if(isBitmap) {
+            winattrbits |= BITMAP_BIT;                
+        }
+        if(0 == winattrbits) {
+            throw new InternalError("Empty bitmask");
         }
         return winattrbits;
     }
 
     /**
-     * @see #getWinAttributeBits(boolean, boolean, boolean)
+     * @see #getExclusiveWinAttributeBits(boolean, boolean, boolean, boolean)
      */
-    public static final int getWinAttributeBits(GLCapabilitiesImmutable caps) {
-        return getWinAttributeBits(caps.isOnscreen(), caps.isPBuffer(), false);
+    public static final int getExclusiveWinAttributeBits(GLCapabilitiesImmutable caps) {
+        return getExclusiveWinAttributeBits(caps.isOnscreen(), caps.isFBO(), caps.isPBuffer(), caps.isBitmap());
     }
 
-    public static final boolean addGLCapabilitiesPermutations(List<GLCapabilitiesImmutable> capsBucket, GLCapabilitiesImmutable temp, int winattrbits) {
-        int preSize = capsBucket.size();
-        if( 0 != ( WINDOW_BIT & winattrbits )  )  {
-            GLCapabilities cpy  = (GLCapabilities) temp.cloneMutable();
-            cpy.setOnscreen(true);
-            cpy.setPBuffer(false);
-            cpy.setFBO(false);
-            capsBucket.add(cpy);
-        }
-        if( 0 != ( PBUFFER_BIT & winattrbits ) || 0 != ( FBO_BIT & winattrbits )  )  {
-            GLCapabilities cpy  = (GLCapabilities) temp.cloneMutable();
-            cpy.setFBO(0 != ( FBO_BIT & winattrbits ));
-            cpy.setPBuffer(0 != ( PBUFFER_BIT & winattrbits ));
-            capsBucket.add(cpy);
-        }
-        if( 0 != ( BITMAP_BIT & winattrbits )  )  {
-            GLCapabilities cpy  = (GLCapabilities) temp.cloneMutable();
-            cpy.setOnscreen(false);
-            cpy.setPBuffer(false);
-            cpy.setFBO(false);
-            capsBucket.add(cpy);
-        }
-        return capsBucket.size() > preSize;
+    public static final GLCapabilities setWinAttributeBits(GLCapabilities caps, int winattrbits) {
+        caps.setBitmap  ( 0 != ( BITMAP_BIT  & winattrbits ) );
+        caps.setPBuffer ( 0 != ( PBUFFER_BIT & winattrbits ) );
+        caps.setFBO     ( 0 != ( FBO_BIT     & winattrbits ) );
+        // we reflect availability semantics, hence setting onscreen at last (maybe overwritten above)!
+        caps.setOnscreen( 0 != ( WINDOW_BIT  & winattrbits ) ); 
+        return caps;
     }
 
     public static GLCapabilitiesImmutable fixGLCapabilities(GLCapabilitiesImmutable capsRequested, boolean fboAvailable, boolean pbufferAvailable)
@@ -131,33 +134,46 @@ public class GLGraphicsConfigurationUtil {
         if( !capsRequested.isOnscreen() ) {
             return fixOffscreenGLCapabilities(capsRequested, fboAvailable, pbufferAvailable);
         }
-        return fixOnscreenGLCapabilities(capsRequested);
+        return capsRequested;
     }
 
     public static GLCapabilitiesImmutable fixOnscreenGLCapabilities(GLCapabilitiesImmutable capsRequested)
     {
         if( !capsRequested.isOnscreen() ) {
             // fix caps ..
-            GLCapabilities caps2 = (GLCapabilities) capsRequested.cloneMutable();
+            final GLCapabilities caps2 = (GLCapabilities) capsRequested.cloneMutable();
+            caps2.setBitmap  (false);
+            caps2.setPBuffer (false);
+            caps2.setFBO     (false);
             caps2.setOnscreen(true);
             return caps2;
         }
         return capsRequested;
     }
-    
-    public static GLCapabilitiesImmutable fixOffscreenGLCapabilities(GLCapabilitiesImmutable capsRequested, boolean fboAvailable, boolean pbufferAvailable)
-    {
-        if( capsRequested.getDoubleBuffered() ||
-            capsRequested.isOnscreen() ||
-            ( fboAvailable != capsRequested.isFBO() ) || 
-            ( pbufferAvailable != capsRequested.isPBuffer() ) )
+
+    public static boolean isGLCapabilitiesOffscreenAutoSelection(GLCapabilitiesImmutable capsRequested) {
+        return !capsRequested.isOnscreen() &&
+               !capsRequested.isFBO() && !capsRequested.isPBuffer() && !capsRequested.isBitmap() ;        
+    }
+
+    public static GLCapabilitiesImmutable fixOffscreenGLCapabilities(GLCapabilitiesImmutable capsRequested, boolean fboAvailable, boolean pbufferAvailable) {
+        final boolean auto = !capsRequested.isFBO() && !capsRequested.isPBuffer() && !capsRequested.isBitmap() ;
+        
+        final boolean useFBO     =                fboAvailable     && ( auto || capsRequested.isFBO()     ) ;
+        final boolean usePbuffer = !useFBO     && pbufferAvailable && ( auto || capsRequested.isPBuffer() ) ;
+        final boolean useBitmap  = !usePbuffer                     && ( auto || capsRequested.isBitmap()  ) ;
+        
+        if( capsRequested.isOnscreen() ||
+            useFBO != capsRequested.isFBO() || 
+            usePbuffer != capsRequested.isPBuffer() || 
+            useBitmap != capsRequested.isBitmap() )
         {
             // fix caps ..
-            GLCapabilities caps2 = (GLCapabilities) capsRequested.cloneMutable();
-            caps2.setDoubleBuffered(false); // FIXME DBLBUFOFFSCRN
+            final GLCapabilities caps2 = (GLCapabilities) capsRequested.cloneMutable();
             caps2.setOnscreen(false);
-            caps2.setFBO( fboAvailable ); 
-            caps2.setPBuffer( pbufferAvailable );
+            caps2.setFBO( useFBO ); 
+            caps2.setPBuffer( usePbuffer );
+            caps2.setBitmap( useBitmap );
             return caps2;
         }
         return capsRequested;
@@ -165,31 +181,40 @@ public class GLGraphicsConfigurationUtil {
 
     public static GLCapabilitiesImmutable fixGLPBufferGLCapabilities(GLCapabilitiesImmutable capsRequested)
     {
-        if( capsRequested.getDoubleBuffered() || capsRequested.isOnscreen() || !capsRequested.isPBuffer() || capsRequested.isFBO() ) {
+        if( capsRequested.isOnscreen() ||
+            !capsRequested.isPBuffer() || 
+            capsRequested.isFBO() ) 
+        {
             // fix caps ..
-            GLCapabilities caps2 = (GLCapabilities) capsRequested.cloneMutable();
-            caps2.setDoubleBuffered(false); // FIXME DBLBUFOFFSCRN - we don't need to be single buffered ..
+            final GLCapabilities caps2 = (GLCapabilities) capsRequested.cloneMutable();
             caps2.setOnscreen(false);
-            caps2.setPBuffer(true);
             caps2.setFBO(false);
+            caps2.setPBuffer(true);
+            caps2.setBitmap(false);
             return caps2;
         }
         return capsRequested;
     }
 
     /** Fix opaque setting while preserve alpha bits */
-    public static GLCapabilitiesImmutable fixOpaqueGLCapabilities(GLCapabilitiesImmutable capsRequested, boolean isOpaque)
+    public static GLCapabilities fixOpaqueGLCapabilities(GLCapabilities capsRequested, boolean isOpaque)
     {
-        GLCapabilities caps2 = null;
-        
         if( capsRequested.isBackgroundOpaque() != isOpaque) {
             final int alphaBits = capsRequested.getAlphaBits();
-            caps2 = (GLCapabilities) capsRequested.cloneMutable();
-            caps2.setBackgroundOpaque(isOpaque);
-            caps2.setAlphaBits(alphaBits);
-            return caps2;
+            capsRequested.setBackgroundOpaque(isOpaque);
+            capsRequested.setAlphaBits(alphaBits);
         }
         return capsRequested;
     }
     
+    /** Fix double buffered setting */
+    public static GLCapabilitiesImmutable fixDoubleBufferedGLCapabilities(GLCapabilitiesImmutable capsRequested, boolean doubleBuffered)
+    {
+        if( capsRequested.getDoubleBuffered() != doubleBuffered) {
+            final GLCapabilities caps2 = (GLCapabilities) capsRequested.cloneMutable();
+            caps2.setDoubleBuffered(doubleBuffered);
+            return caps2;
+        }
+        return capsRequested;
+    }
 }
diff --git a/src/jogl/classes/jogamp/opengl/egl/EGLDrawableFactory.java b/src/jogl/classes/jogamp/opengl/egl/EGLDrawableFactory.java
index a9e339bea..986b110be 100644
--- a/src/jogl/classes/jogamp/opengl/egl/EGLDrawableFactory.java
+++ b/src/jogl/classes/jogamp/opengl/egl/EGLDrawableFactory.java
@@ -290,9 +290,9 @@ public class EGLDrawableFactory extends GLDrawableFactoryImpl {
         if(0 < numConfigs.get(0)) {
             final PointerBuffer configs = PointerBuffer.allocateDirect(numConfigs.get(0));
             final IntBuffer attrs = Buffers.newDirectIntBuffer(EGLGraphicsConfiguration.GLCapabilities2AttribList(caps));
-            final int winattrmask = GLGraphicsConfigurationUtil.getWinAttributeBits(true, true, true);
+            final int winattrmask = GLGraphicsConfigurationUtil.getExclusiveWinAttributeBits(caps);
             if( EGL.eglChooseConfig(eglDisplay.getHandle(), attrs, configs, configs.capacity(), numConfigs) && numConfigs.get(0) > 0) {
-                return EGLGraphicsConfigurationFactory.eglConfigs2GLCaps(caps.getGLProfile(), eglDisplay.getHandle(), configs, numConfigs.get(0), winattrmask, false /* forceTransparentFlag */);
+                return EGLGraphicsConfigurationFactory.eglConfigs2GLCaps(eglDisplay, caps.getGLProfile(), configs, numConfigs.get(0), winattrmask, false /* forceTransparentFlag */);
             }
         }
         return new ArrayList<GLCapabilitiesImmutable>(0);
@@ -649,7 +649,10 @@ public class EGLDrawableFactory extends GLDrawableFactoryImpl {
     @Override
     public final ProxySurface createDummySurfaceImpl(AbstractGraphicsDevice deviceReq, boolean createNewDevice, 
                                                      GLCapabilitiesImmutable requestedCaps, GLCapabilitiesChooser chooser, int width, int height) {
-        final GLCapabilitiesImmutable chosenCaps = GLGraphicsConfigurationUtil.fixOffscreenGLCapabilities(requestedCaps, false, canCreateGLPbuffer(deviceReq));        
+        final GLCapabilitiesImmutable chosenCaps =
+                GLGraphicsConfigurationUtil.fixDoubleBufferedGLCapabilities(
+                        GLGraphicsConfigurationUtil.fixOffscreenGLCapabilities(requestedCaps, false, canCreateGLPbuffer(deviceReq)), 
+                        false);        
         return createMutableSurfaceImpl(deviceReq, createNewDevice, chosenCaps, requestedCaps, chooser, width, height, dummySurfaceLifecycleHook);
     }
     private static final ProxySurface.UpstreamSurfaceHook dummySurfaceLifecycleHook = new ProxySurface.UpstreamSurfaceHook() {
diff --git a/src/jogl/classes/jogamp/opengl/egl/EGLGLCapabilities.java b/src/jogl/classes/jogamp/opengl/egl/EGLGLCapabilities.java
index 70a570174..e513a86cf 100644
--- a/src/jogl/classes/jogamp/opengl/egl/EGLGLCapabilities.java
+++ b/src/jogl/classes/jogamp/opengl/egl/EGLGLCapabilities.java
@@ -33,6 +33,8 @@ import javax.media.opengl.GLCapabilities;
 import javax.media.opengl.GLException;
 import javax.media.opengl.GLProfile;
 
+import com.jogamp.nativewindow.egl.EGLGraphicsDevice;
+
 
 public class EGLGLCapabilities extends GLCapabilities {
   private long eglcfg;
@@ -45,13 +47,13 @@ public class EGLGLCapabilities extends GLCapabilities {
    * @param eglcfg
    * @param eglcfgid
    * @param visualID native visualID if valid, otherwise VisualIDHolder.VID_UNDEFINED
-   * @param glp desired GLProfile, or null if determined by renderableType
+   * @param glp desired GLProfile
    * @param renderableType actual EGL renderableType
    *
    * May throw GLException if given GLProfile is not compatible w/ renderableType
    */
   public EGLGLCapabilities(long eglcfg, int eglcfgid, int visualID, GLProfile glp, int renderableType) {
-      super( ( null != glp ) ? glp : getCompatible(renderableType) );
+      super( glp );
       this.eglcfg = eglcfg;
       this.eglcfgid = eglcfgid;
       if(!isCompatible(glp, renderableType)) {
@@ -111,15 +113,15 @@ public class EGLGLCapabilities extends GLCapabilities {
     return false;
   }
 
-  public static GLProfile getCompatible(int renderableType) {
-    if(0 != (renderableType & EGL.EGL_OPENGL_ES2_BIT) && GLProfile.isAvailable(GLProfile.GLES2)) {
-        return GLProfile.get(GLProfile.GLES2);
+  public static GLProfile getCompatible(EGLGraphicsDevice device, int renderableType) {
+    if(0 != (renderableType & EGL.EGL_OPENGL_ES2_BIT) && GLProfile.isAvailable(device, GLProfile.GLES2)) {
+        return GLProfile.get(device, GLProfile.GLES2);
     }
-    if(0 != (renderableType & EGL.EGL_OPENGL_ES_BIT) && GLProfile.isAvailable(GLProfile.GLES1)) {
-        return GLProfile.get(GLProfile.GLES1);
+    if(0 != (renderableType & EGL.EGL_OPENGL_ES_BIT) && GLProfile.isAvailable(device, GLProfile.GLES1)) {
+        return GLProfile.get(device, GLProfile.GLES1);
     }
     if(0 != (renderableType & EGL.EGL_OPENGL_BIT)) {
-        return GLProfile.getDefault();
+        return GLProfile.getDefault(device);
     }
     return null;
   }
diff --git a/src/jogl/classes/jogamp/opengl/egl/EGLGraphicsConfiguration.java b/src/jogl/classes/jogamp/opengl/egl/EGLGraphicsConfiguration.java
index 20102547d..135101ff2 100644
--- a/src/jogl/classes/jogamp/opengl/egl/EGLGraphicsConfiguration.java
+++ b/src/jogl/classes/jogamp/opengl/egl/EGLGraphicsConfiguration.java
@@ -37,8 +37,6 @@
 package jogamp.opengl.egl;
 
 import java.nio.IntBuffer;
-import java.util.ArrayList;
-import java.util.List;
 
 import javax.media.nativewindow.AbstractGraphicsDevice;
 import javax.media.nativewindow.AbstractGraphicsScreen;
@@ -48,6 +46,7 @@ import javax.media.nativewindow.VisualIDHolder;
 import javax.media.opengl.DefaultGLCapabilitiesChooser;
 import javax.media.opengl.GLCapabilitiesChooser;
 import javax.media.opengl.GLCapabilitiesImmutable;
+import javax.media.opengl.GLContext;
 import javax.media.opengl.GLException;
 import javax.media.opengl.GLProfile;
 
@@ -85,7 +84,8 @@ public class EGLGraphicsConfiguration extends MutableGraphicsConfiguration imple
         }
         final long cfg = EGLConfigId2EGLConfig(dpy, cfgID);
         if(0 < cfg) {
-            final EGLGLCapabilities caps = EGLConfig2Capabilities(capsRequested.getGLProfile(), dpy, cfg, false, capsRequested.isOnscreen(), capsRequested.isPBuffer(), false);
+            final int winattrmask = GLGraphicsConfigurationUtil.getExclusiveWinAttributeBits(capsRequested);
+            final EGLGLCapabilities caps = EGLConfig2Capabilities((EGLGraphicsDevice)absDevice, capsRequested.getGLProfile(), cfg, winattrmask, false);
             return new EGLGraphicsConfiguration(absScreen, caps, capsRequested, new DefaultGLCapabilitiesChooser());
         }
         return null;
@@ -129,9 +129,10 @@ public class EGLGraphicsConfiguration extends MutableGraphicsConfiguration imple
         return configs.get(0);
     }
 
-    static int EGLConfigDrawableTypeBits(final long display, final long config) {
+    static int EGLConfigDrawableTypeBits(final EGLGraphicsDevice device, final GLProfile glp, final long config) {
         int val = 0;
 
+        final long display = device.getHandle();
         int[] stype = new int[1];
         if(! EGL.eglGetConfigAttrib(display, config, EGL.EGL_SURFACE_TYPE, stype, 0)) {
             throw new GLException("Could not determine EGL_SURFACE_TYPE");
@@ -146,32 +147,24 @@ public class EGLGraphicsConfiguration extends MutableGraphicsConfiguration imple
         if ( 0 != ( stype[0] & EGL.EGL_PBUFFER_BIT ) ) {
             val |= GLGraphicsConfigurationUtil.PBUFFER_BIT;
         }
+        if ( GLContext.isFBOAvailable(device, glp) ) {
+            val |= GLGraphicsConfigurationUtil.FBO_BIT;
+        }
 
         return val;
     }
 
-    public static EGLGLCapabilities EGLConfig2Capabilities(GLProfile glp, long display, long config,
-                                                           boolean relaxed, boolean onscreen, boolean usePBuffer, boolean forceTransparentFlag) {
-        List<GLCapabilitiesImmutable> bucket = new ArrayList<GLCapabilitiesImmutable>();
-        final int winattrmask = GLGraphicsConfigurationUtil.getWinAttributeBits(onscreen, usePBuffer, false);
-        if( EGLConfig2Capabilities(bucket, glp, display, config, winattrmask, forceTransparentFlag) ) {
-            return (EGLGLCapabilities) bucket.get(0);
-        } else if ( relaxed && EGLConfig2Capabilities(bucket, glp, display, config, GLGraphicsConfigurationUtil.ALL_BITS, forceTransparentFlag) ) {
-            return (EGLGLCapabilities) bucket.get(0);
-        }
-        return null;
-    }
-
-    public static boolean EGLConfig2Capabilities(List<GLCapabilitiesImmutable> capsBucket,
-                                                 GLProfile glp, long display, long config,
-                                                 int winattrmask, boolean forceTransparentFlag) {
-        final int allDrawableTypeBits = EGLConfigDrawableTypeBits(display, config);
-        final int drawableTypeBits = winattrmask & allDrawableTypeBits;
-
-        if( 0 == drawableTypeBits ) {
-            return false;
-        }
-
+    /**
+     * @param device
+     * @param glp desired GLProfile, may be null
+     * @param config
+     * @param winattrmask
+     * @param forceTransparentFlag
+     * @return
+     */
+    public static EGLGLCapabilities EGLConfig2Capabilities(EGLGraphicsDevice device, GLProfile glp, long config,
+                                                           int winattrmask, boolean forceTransparentFlag) {
+        final long display = device.getHandle();
         final IntBuffer val = Buffers.newDirectIntBuffer(1);
         final int cfgID;
         final int rType;
@@ -183,7 +176,7 @@ public class EGLGraphicsConfiguration extends MutableGraphicsConfiguration imple
                 // FIXME: this happens on a ATI PC Emulation ..
                 System.err.println("EGL couldn't retrieve ConfigID for config "+toHexString(config)+", error "+toHexString(EGL.eglGetError()));
             }
-            return false;
+            return null;
         }
         cfgID = val.get(0);
         
@@ -191,10 +184,10 @@ public class EGLGraphicsConfiguration extends MutableGraphicsConfiguration imple
             if(DEBUG) {
                 System.err.println("EGL couldn't retrieve EGL_RENDERABLE_TYPE for config "+toHexString(config)+", error "+toHexString(EGL.eglGetError()));
             }
-            return false;
+            return null;
         }
         rType = val.get(0);
-                       
+
         if(EGL.eglGetConfigAttrib(display, config, EGL.EGL_NATIVE_VISUAL_ID, val)) {
             visualID = val.get(0);
         } else {
@@ -203,12 +196,15 @@ public class EGLGraphicsConfiguration extends MutableGraphicsConfiguration imple
         
         EGLGLCapabilities caps = null;        
         try {
+            if(null == glp) {
+                glp = EGLGLCapabilities.getCompatible(device, rType);
+            }
             caps = new EGLGLCapabilities(config, cfgID, visualID, glp, rType);
         } catch (GLException gle) {
             if(DEBUG) {
                 System.err.println("config "+toHexString(config)+": "+gle);
             }
-            return false;
+            return null;
         }        
                 
         if(EGL.eglGetConfigAttrib(display, config, EGL.EGL_CONFIG_CAVEAT, val)) {
@@ -270,7 +266,17 @@ public class EGLGraphicsConfiguration extends MutableGraphicsConfiguration imple
         if(EGL.eglGetConfigAttrib(display, config, EGL.EGL_DEPTH_SIZE, val)) {
             caps.setDepthBits(val.get(0));
         }
-        return GLGraphicsConfigurationUtil.addGLCapabilitiesPermutations(capsBucket, caps, drawableTypeBits );
+
+        // Since the passed GLProfile may be null, 
+        // we use EGL_RENDERABLE_TYPE derived profile as created in the EGLGLCapabilities constructor.
+        final int allDrawableTypeBits = EGLConfigDrawableTypeBits(device, caps.getGLProfile(), config);
+        final int drawableTypeBits = winattrmask & allDrawableTypeBits;
+
+        if( 0 == drawableTypeBits ) {
+            return null;
+        }
+        
+        return (EGLGLCapabilities) GLGraphicsConfigurationUtil.setWinAttributeBits(caps, drawableTypeBits);
     }
 
     public static int[] GLCapabilities2AttribList(GLCapabilitiesImmutable caps) {
diff --git a/src/jogl/classes/jogamp/opengl/egl/EGLGraphicsConfigurationFactory.java b/src/jogl/classes/jogamp/opengl/egl/EGLGraphicsConfigurationFactory.java
index 72dea9ead..d08685dcb 100644
--- a/src/jogl/classes/jogamp/opengl/egl/EGLGraphicsConfigurationFactory.java
+++ b/src/jogl/classes/jogamp/opengl/egl/EGLGraphicsConfigurationFactory.java
@@ -207,7 +207,7 @@ public class EGLGraphicsConfigurationFactory extends GLGraphicsConfigurationFact
             throw new GLException("Graphics configuration get all configs (eglGetConfigs) call failed, error "+toHexString(EGL.eglGetError()));
         }
         if (numConfigs.get(0) > 0) {
-            availableCaps = eglConfigs2GLCaps(null, eglDisplay, configs, numConfigs.get(0), GLGraphicsConfigurationUtil.ALL_BITS, false);
+            availableCaps = eglConfigs2GLCaps(eglDevice, null, configs, numConfigs.get(0), GLGraphicsConfigurationUtil.ALL_BITS, false);
             if( null != availableCaps && availableCaps.size() > 1) {
                 Collections.sort(availableCaps, EglCfgIDComparator);
             }
@@ -250,7 +250,7 @@ public class EGLGraphicsConfigurationFactory extends GLGraphicsConfigurationFact
         final EGLDrawableFactory factory = (EGLDrawableFactory) GLDrawableFactory.getEGLFactory();
         capsChosen = GLGraphicsConfigurationUtil.fixGLCapabilities( capsChosen, GLContext.isFBOAvailable(absDevice, glp), factory.canCreateGLPbuffer(absDevice) );
 
-        EGLGraphicsConfiguration res = eglChooseConfig(eglDevice.getHandle(), capsChosen, capsReq, chooser, absScreen, nativeVisualID, forceTransparentFlag);
+        EGLGraphicsConfiguration res = eglChooseConfig(eglDevice, capsChosen, capsReq, chooser, absScreen, nativeVisualID, forceTransparentFlag);
         if(null==res) {
             if(DEBUG) {
                 System.err.println("eglChooseConfig failed with given capabilities "+capsChosen);
@@ -274,7 +274,7 @@ public class EGLGraphicsConfigurationFactory extends GLGraphicsConfigurationFact
             if(DEBUG) {
                 System.err.println("trying fixed caps (1): "+fixedCaps);
             }
-            res = eglChooseConfig(eglDevice.getHandle(), fixedCaps, capsReq, chooser, absScreen, nativeVisualID, false);
+            res = eglChooseConfig(eglDevice, fixedCaps, capsReq, chooser, absScreen, nativeVisualID, false);
         }
         if(null==res) {
             //
@@ -292,7 +292,7 @@ public class EGLGraphicsConfigurationFactory extends GLGraphicsConfigurationFact
             if(DEBUG) {
                 System.err.println("trying fixed caps (2): "+fixedCaps);
             }
-            res = eglChooseConfig(eglDevice.getHandle(), fixedCaps, capsReq, chooser, absScreen, nativeVisualID, false);
+            res = eglChooseConfig(eglDevice, fixedCaps, capsReq, chooser, absScreen, nativeVisualID, false);
         }
         if(null==res) {
             //
@@ -312,7 +312,7 @@ public class EGLGraphicsConfigurationFactory extends GLGraphicsConfigurationFact
             if(DEBUG) {
                 System.err.println("trying fixed caps (3): "+fixedCaps);
             }
-            res = eglChooseConfig(eglDevice.getHandle(), fixedCaps, capsReq, chooser, absScreen, nativeVisualID, false);
+            res = eglChooseConfig(eglDevice, fixedCaps, capsReq, chooser, absScreen, nativeVisualID, false);
         }
         if(null==res) {
             throw new GLException("Graphics configuration failed [direct caps, eglGetConfig/chooser and fixed-caps(1-3)]");
@@ -324,15 +324,14 @@ public class EGLGraphicsConfigurationFactory extends GLGraphicsConfigurationFact
         return res;
     }
 
-    static EGLGraphicsConfiguration eglChooseConfig(long eglDisplay, 
+    static EGLGraphicsConfiguration eglChooseConfig(EGLGraphicsDevice device, 
                                                     GLCapabilitiesImmutable capsChosen, GLCapabilitiesImmutable capsRequested,
                                                     GLCapabilitiesChooser chooser,
                                                     AbstractGraphicsScreen absScreen,
                                                     int nativeVisualID, boolean forceTransparentFlag) {
+        final long eglDisplay = device.getHandle();
         final GLProfile glp = capsChosen.getGLProfile();
-        final boolean onscreen = capsChosen.isOnscreen();
-        final boolean usePBuffer = capsChosen.isPBuffer();
-        final int winattrmask = GLGraphicsConfigurationUtil.getWinAttributeBits(onscreen, usePBuffer, false);
+        final int winattrmask = GLGraphicsConfigurationUtil.getExclusiveWinAttributeBits(capsChosen);
         List<GLCapabilitiesImmutable> availableCaps = null;
         int recommendedIndex = -1;
         long recommendedEGLConfig = -1;
@@ -345,7 +344,7 @@ public class EGLGraphicsConfigurationFactory extends GLGraphicsConfigurationFact
             throw new GLException("EGLGraphicsConfiguration.eglChooseConfig: Get maxConfigs (eglGetConfigs) no configs");
         }
         if (DEBUG) {
-            System.err.println("EGLGraphicsConfiguration.eglChooseConfig: eglChooseConfig eglDisplay "+toHexString(eglDisplay)+", nativeVisualID "+toHexString(nativeVisualID)+", onscreen "+onscreen+", usePBuffer "+usePBuffer+", "+capsChosen+", numConfigs "+numConfigs.get(0));
+            System.err.println("EGLGraphicsConfiguration.eglChooseConfig: eglChooseConfig eglDisplay "+toHexString(eglDisplay)+", nativeVisualID "+toHexString(nativeVisualID)+", "+capsChosen+", numConfigs "+numConfigs.get(0));
         }
 
         final IntBuffer attrs = Buffers.newDirectIntBuffer(EGLGraphicsConfiguration.GLCapabilities2AttribList(capsChosen));
@@ -359,7 +358,7 @@ public class EGLGraphicsConfigurationFactory extends GLGraphicsConfigurationFact
                 System.err.println("EGLGraphicsConfiguration.eglChooseConfig: #1 eglChooseConfig: false");
             }
         } else  if (numConfigs.get(0) > 0) {
-            availableCaps = eglConfigs2GLCaps(glp, eglDisplay, configs, numConfigs.get(0), winattrmask, forceTransparentFlag);
+            availableCaps = eglConfigs2GLCaps(device, glp, configs, numConfigs.get(0), winattrmask, forceTransparentFlag);
             if(availableCaps.size() > 0) {
                 recommendedEGLConfig =  configs.get(0);
                 recommendedIndex = 0;
@@ -384,7 +383,7 @@ public class EGLGraphicsConfigurationFactory extends GLGraphicsConfigurationFact
                 throw new GLException("EGLGraphicsConfiguration.eglChooseConfig: #2 Get all configs (eglGetConfigs) call failed, error "+toHexString(EGL.eglGetError()));
             }
             if (numConfigs.get(0) > 0) {
-                availableCaps = eglConfigs2GLCaps(glp, eglDisplay, configs, numConfigs.get(0), winattrmask, forceTransparentFlag);                
+                availableCaps = eglConfigs2GLCaps(device, glp, configs, numConfigs.get(0), winattrmask, forceTransparentFlag);                
             }
         }
 
@@ -392,7 +391,7 @@ public class EGLGraphicsConfigurationFactory extends GLGraphicsConfigurationFact
             if(DEBUG) {
                 // FIXME: this happens on a ATI PC Emulation ..
                 System.err.println("EGLGraphicsConfiguration.eglChooseConfig: #2 Graphics configuration 1st choice and 2nd choice failed - no configs");
-                availableCaps = eglConfigs2GLCaps(glp, eglDisplay, configs, numConfigs.get(0), GLGraphicsConfigurationUtil.ALL_BITS, forceTransparentFlag);
+                availableCaps = eglConfigs2GLCaps(device, glp, configs, numConfigs.get(0), GLGraphicsConfigurationUtil.ALL_BITS, forceTransparentFlag);
                 printCaps("AllCaps", availableCaps, System.err);
             }
             return null;
@@ -439,12 +438,15 @@ public class EGLGraphicsConfigurationFactory extends GLGraphicsConfigurationFact
         return new EGLGraphicsConfiguration(absScreen, chosenCaps, capsRequested, chooser);
     }
 
-    static List<GLCapabilitiesImmutable> eglConfigs2GLCaps(GLProfile glp, long eglDisplay, PointerBuffer configs, int num, int winattrmask, boolean forceTransparentFlag) {
-        List<GLCapabilitiesImmutable> caps = new ArrayList<GLCapabilitiesImmutable>(num);
+    static List<GLCapabilitiesImmutable> eglConfigs2GLCaps(EGLGraphicsDevice device, GLProfile glp, PointerBuffer configs, int num, int winattrmask, boolean forceTransparentFlag) {
+        List<GLCapabilitiesImmutable> bucket = new ArrayList<GLCapabilitiesImmutable>(num);
         for(int i=0; i<num; i++) {
-            EGLGraphicsConfiguration.EGLConfig2Capabilities(caps, glp, eglDisplay, configs.get(i), winattrmask, forceTransparentFlag);
+            final GLCapabilitiesImmutable caps = EGLGraphicsConfiguration.EGLConfig2Capabilities(device, glp, configs.get(i), winattrmask, forceTransparentFlag);
+            if(null != caps) {
+                bucket.add(caps);
+            }
         }
-        return caps;
+        return bucket;
     }
 
     static void printCaps(String prefix, List<GLCapabilitiesImmutable> caps, PrintStream out) {
diff --git a/src/jogl/classes/jogamp/opengl/macosx/cgl/MacOSXCGLContext.java b/src/jogl/classes/jogamp/opengl/macosx/cgl/MacOSXCGLContext.java
index 82525cfde..55aea3a98 100644
--- a/src/jogl/classes/jogamp/opengl/macosx/cgl/MacOSXCGLContext.java
+++ b/src/jogl/classes/jogamp/opengl/macosx/cgl/MacOSXCGLContext.java
@@ -49,6 +49,7 @@ import javax.media.nativewindow.NativeSurface;
 import javax.media.nativewindow.NativeWindowFactory;
 import javax.media.nativewindow.OffscreenLayerSurface;
 import javax.media.nativewindow.ProxySurface;
+import javax.media.opengl.GLCapabilities;
 import javax.media.opengl.GLCapabilitiesImmutable;
 import javax.media.opengl.GLContext;
 import javax.media.opengl.GLException;
@@ -495,8 +496,14 @@ public abstract class MacOSXCGLContext extends GLContextImpl
               CGL.setContextOpacity(ctx, 0);
           }
 
-          GLCapabilitiesImmutable fixedCaps = MacOSXCGLGraphicsConfiguration.NSPixelFormat2GLCapabilities(chosenCaps.getGLProfile(), pixelFormat);
+          GLCapabilities fixedCaps = MacOSXCGLGraphicsConfiguration.NSPixelFormat2GLCapabilities(chosenCaps.getGLProfile(), pixelFormat);
           fixedCaps = GLGraphicsConfigurationUtil.fixOpaqueGLCapabilities(fixedCaps, chosenCaps.isBackgroundOpaque());
+          if(!fixedCaps.isPBuffer()) {
+              // not handled, so copy them
+              fixedCaps.setFBO(chosenCaps.isFBO());
+              fixedCaps.setBitmap(chosenCaps.isBitmap());
+              fixedCaps.setOnscreen(chosenCaps.isOnscreen());
+          }
           config.setChosenCapabilities(fixedCaps);
           if(DEBUG) {
               System.err.println("NS create fixedCaps: "+fixedCaps);
diff --git a/src/jogl/classes/jogamp/opengl/macosx/cgl/MacOSXCGLGraphicsConfiguration.java b/src/jogl/classes/jogamp/opengl/macosx/cgl/MacOSXCGLGraphicsConfiguration.java
index 202644bb3..10e8193e2 100644
--- a/src/jogl/classes/jogamp/opengl/macosx/cgl/MacOSXCGLGraphicsConfiguration.java
+++ b/src/jogl/classes/jogamp/opengl/macosx/cgl/MacOSXCGLGraphicsConfiguration.java
@@ -176,7 +176,7 @@ public class MacOSXCGLGraphicsConfiguration extends MutableGraphicsConfiguration
         return CGL.createPixelFormat(cglInternalAttributeToken, off, len, ivalues, 0);
     }
 
-    static GLCapabilitiesImmutable NSPixelFormat2GLCapabilities(GLProfile glp, long pixelFormat) {
+    static GLCapabilities NSPixelFormat2GLCapabilities(GLProfile glp, long pixelFormat) {
         return PixelFormat2GLCapabilities(glp, pixelFormat, true);
     }
 
@@ -233,11 +233,11 @@ public class MacOSXCGLGraphicsConfiguration extends MutableGraphicsConfiguration
       return fmt.get(0);
     }
     
-    static GLCapabilitiesImmutable CGLPixelFormat2GLCapabilities(long pixelFormat) {        
+    static GLCapabilities CGLPixelFormat2GLCapabilities(long pixelFormat) {        
         return PixelFormat2GLCapabilities(null, pixelFormat, false);
     }
 
-    private static GLCapabilitiesImmutable PixelFormat2GLCapabilities(GLProfile glp, long pixelFormat, boolean nsUsage) {
+    private static GLCapabilities PixelFormat2GLCapabilities(GLProfile glp, long pixelFormat, boolean nsUsage) {
         int len = cglInternalAttributeToken.length;
         int off = 0;
         if ( !MacOSXCGLContext.isLionOrLater ) {
diff --git a/src/jogl/classes/jogamp/opengl/windows/wgl/WindowsPbufferWGLDrawable.java b/src/jogl/classes/jogamp/opengl/windows/wgl/WindowsPbufferWGLDrawable.java
index 175622343..75c1c4441 100644
--- a/src/jogl/classes/jogamp/opengl/windows/wgl/WindowsPbufferWGLDrawable.java
+++ b/src/jogl/classes/jogamp/opengl/windows/wgl/WindowsPbufferWGLDrawable.java
@@ -40,6 +40,7 @@
 
 package jogamp.opengl.windows.wgl;
 
+import javax.media.nativewindow.AbstractGraphicsDevice;
 import javax.media.nativewindow.NativeSurface;
 import javax.media.nativewindow.NativeWindowException;
 import javax.media.nativewindow.MutableSurface;
@@ -52,6 +53,7 @@ import javax.media.opengl.GLProfile;
 
 import jogamp.nativewindow.windows.GDI;
 import jogamp.opengl.GLDrawableImpl;
+import jogamp.opengl.GLGraphicsConfigurationUtil;
 import jogamp.opengl.windows.wgl.WindowsWGLDrawableFactory.SharedResource;
 // import javax.media.opengl.GLPbuffer;
 
@@ -127,13 +129,16 @@ public class WindowsPbufferWGLDrawable extends WindowsWGLDrawable {
             System.out.println("Pbuffer config: " + config);
         }
 
+        final int winattrPbuffer = GLGraphicsConfigurationUtil.getExclusiveWinAttributeBits(false /* onscreen */, false /* fbo */, true /* pbuffer */, false /* bitmap */);
+        
         int[]   iattributes = new int  [2*WindowsWGLGraphicsConfiguration.MAX_ATTRIBS];
         float[] fattributes = new float[1];
         int[]   floatModeTmp = new int[1];
         int     niattribs   = 0;
 
-        GLCapabilitiesImmutable chosenCaps = (GLCapabilitiesImmutable)config.getChosenCapabilities();
-        GLProfile glProfile = chosenCaps.getGLProfile();
+        final GLCapabilitiesImmutable chosenCaps = (GLCapabilitiesImmutable)config.getChosenCapabilities();
+        final GLProfile glProfile = chosenCaps.getGLProfile();
+        final AbstractGraphicsDevice device = config.getScreen().getDevice();
 
         if (DEBUG) {
           System.out.println("Pbuffer parentHdc = " + toHexString(sharedHdc));
@@ -175,7 +180,8 @@ public class WindowsPbufferWGLDrawable extends WindowsWGLDrawable {
         if (DEBUG) {
           System.err.println("" + nformats + " suitable pixel formats found");
           for (int i = 0; i < nformats; i++) {
-            WGLGLCapabilities dbgCaps = WindowsWGLGraphicsConfiguration.wglARBPFID2GLCapabilities(sharedResource, sharedHdc, pformats[i], glProfile, false, true);
+            WGLGLCapabilities dbgCaps = WindowsWGLGraphicsConfiguration.wglARBPFID2GLCapabilities(sharedResource, device, glProfile, 
+                                          sharedHdc, pformats[i], winattrPbuffer);
             System.err.println("pixel format " + pformats[i] + " (index " + i + "): " + dbgCaps);
           }
         }
@@ -239,7 +245,8 @@ public class WindowsPbufferWGLDrawable extends WindowsWGLDrawable {
 
         // Re-query chosen pixel format
         {
-          WGLGLCapabilities newCaps = WindowsWGLGraphicsConfiguration.wglARBPFID2GLCapabilities(sharedResource, sharedHdc, pfdid, glProfile, false, true);
+          WGLGLCapabilities newCaps = WindowsWGLGraphicsConfiguration.wglARBPFID2GLCapabilities(sharedResource, device, glProfile, 
+                                          sharedHdc, pfdid, winattrPbuffer);
           if(null == newCaps) {
             throw new GLException("pbuffer creation error: unable to re-query chosen PFD ID: " + pfdid + ", hdc " + GLDrawableImpl.toHexString(tmpHdc));
           }
diff --git a/src/jogl/classes/jogamp/opengl/windows/wgl/WindowsWGLGraphicsConfiguration.java b/src/jogl/classes/jogamp/opengl/windows/wgl/WindowsWGLGraphicsConfiguration.java
index 209589b29..5b21353c3 100644
--- a/src/jogl/classes/jogamp/opengl/windows/wgl/WindowsWGLGraphicsConfiguration.java
+++ b/src/jogl/classes/jogamp/opengl/windows/wgl/WindowsWGLGraphicsConfiguration.java
@@ -42,6 +42,7 @@ import javax.media.nativewindow.AbstractGraphicsDevice;
 import javax.media.opengl.GL;
 import javax.media.opengl.GLCapabilitiesImmutable;
 import javax.media.opengl.GLCapabilitiesChooser;
+import javax.media.opengl.GLContext;
 import javax.media.opengl.GLDrawableFactory;
 import javax.media.opengl.GLException;
 import javax.media.opengl.GLPbuffer;
@@ -104,9 +105,9 @@ public class WindowsWGLGraphicsConfiguration extends MutableGraphicsConfiguratio
         WGLGLCapabilities caps = null;
 
         if(hasARB) {
-            caps = wglARBPFID2GLCapabilities(sharedResource, hdc, pfdID, glp, onscreen, true /* pbuffer */);
+            caps = wglARBPFID2GLCapabilities(sharedResource, device, glp, hdc, pfdID, GLGraphicsConfigurationUtil.ALL_BITS);
         } else {
-            caps = PFD2GLCapabilities(glp, hdc, pfdID, onscreen);
+            caps = PFD2GLCapabilities(device, glp, hdc, pfdID, GLGraphicsConfigurationUtil.ALL_BITS);
         }
         if(null==caps) {
             throw new GLException("Couldn't choose Capabilities by: HDC 0x"+Long.toHexString(hdc)+
@@ -304,8 +305,8 @@ public class WindowsWGLGraphicsConfiguration extends MutableGraphicsConfiguratio
     }
 
     static WGLGLCapabilities wglARBPFID2GLCapabilities(WindowsWGLDrawableFactory.SharedResource sharedResource,
-                                                       long hdc, int pfdID,
-                                                       GLProfile glp, boolean onscreen, boolean usePBuffer) {
+                                                       AbstractGraphicsDevice device, GLProfile glp,
+                                                       long hdc, int pfdID, int winattrbits) {
         if (!sharedResource.hasARBPixelFormat()) {
             return null;
         }
@@ -319,17 +320,12 @@ public class WindowsWGLGraphicsConfiguration extends MutableGraphicsConfiguratio
             throw new GLException("wglARBPFID2GLCapabilities: Error getting pixel format attributes for pixel format " + pfdID + 
                                   " of device context " + toHexString(hdc) + ", werr " + GDI.GetLastError());
         }
-        List<GLCapabilitiesImmutable> bucket = new ArrayList<GLCapabilitiesImmutable>(1);
-        final int winattrbits = GLGraphicsConfigurationUtil.getWinAttributeBits(onscreen, usePBuffer, false);
-        if(AttribList2GLCapabilities(bucket, glp, hdc, pfdID, iattributes, niattribs, iresults, winattrbits)) {
-            return (WGLGLCapabilities) bucket.get(0);
-        }
-        return null;
+        return AttribList2GLCapabilities(device, glp, hdc, pfdID, iattributes, niattribs, iresults, winattrbits);
     }
 
-    static int[] wglChoosePixelFormatARB(long hdc, WindowsWGLDrawableFactory.SharedResource sharedResource,
+    static int[] wglChoosePixelFormatARB(WindowsWGLDrawableFactory.SharedResource sharedResource, AbstractGraphicsDevice device,
                                          GLCapabilitiesImmutable capabilities,
-                                         int[] iattributes, int accelerationMode, float[] fattributes)
+                                         long hdc, int[] iattributes, int accelerationMode, float[] fattributes)
     {
 
         if ( !WindowsWGLGraphicsConfiguration.GLCapabilities2AttribList(capabilities,
@@ -366,27 +362,20 @@ public class WindowsWGLGraphicsConfiguration extends MutableGraphicsConfiguratio
                     + Integer.toHexString(accelerationMode) + ": " + numFormats);
             for (int i = 0; i < numFormats; i++) {
                 WGLGLCapabilities dbgCaps0 = WindowsWGLGraphicsConfiguration.wglARBPFID2GLCapabilities(
-                                                sharedResource, hdc, pformats[i],
-                                                capabilities.getGLProfile(), capabilities.isOnscreen(), capabilities.isPBuffer());
+                                                sharedResource, device, capabilities.getGLProfile(), hdc, pformats[i], GLGraphicsConfigurationUtil.ALL_BITS);
                 System.err.println("pixel format " + pformats[i] + " (index " + i + "): " + dbgCaps0);
             }
         }
         return pformats;
     }
 
-    static List<GLCapabilitiesImmutable> wglARBPFIDs2GLCapabilities(WindowsWGLDrawableFactory.SharedResource sharedResource,
-                                                                    long hdc, int[] pfdIDs, GLProfile glp, boolean onscreen, boolean usePBuffer) {
-        final int winattrbits = GLGraphicsConfigurationUtil.getWinAttributeBits(onscreen, usePBuffer, false);
-        return wglARBPFIDs2GLCapabilitiesImpl(sharedResource, hdc, pfdIDs, glp, winattrbits);
-    }
-
     static List <GLCapabilitiesImmutable> wglARBPFIDs2AllGLCapabilities(WindowsWGLDrawableFactory.SharedResource sharedResource,
-                                                                                  long hdc, int[] pfdIDs, GLProfile glp) {
-        return wglARBPFIDs2GLCapabilitiesImpl(sharedResource, hdc, pfdIDs, glp, GLGraphicsConfigurationUtil.ALL_BITS);
+                                                                        AbstractGraphicsDevice device, GLProfile glp, long hdc, int[] pfdIDs) {
+        return wglARBPFIDs2GLCapabilities(sharedResource, device, glp, hdc, pfdIDs, GLGraphicsConfigurationUtil.ALL_BITS);
     }
     
-    private static List <GLCapabilitiesImmutable> wglARBPFIDs2GLCapabilitiesImpl(WindowsWGLDrawableFactory.SharedResource sharedResource,
-                                                                                 long hdc, int[] pfdIDs, GLProfile glp, int winattrbits) {
+    static List <GLCapabilitiesImmutable> wglARBPFIDs2GLCapabilities(WindowsWGLDrawableFactory.SharedResource sharedResource,
+                                                                     AbstractGraphicsDevice device, GLProfile glp, long hdc, int[] pfdIDs, int winattrbits) {
         if (!sharedResource.hasARBPixelFormat()) {
             return null;
         }
@@ -401,7 +390,10 @@ public class WindowsWGLGraphicsConfiguration extends MutableGraphicsConfiguratio
         for(int i = 0; i<numFormats; i++) {
             if ( pfdIDs[i] >= 1 &&
                  ((WindowsWGLContext)sharedResource.getContext()).getWGLExt().wglGetPixelFormatAttribivARB(hdc, pfdIDs[i], 0, niattribs, iattributes, 0, iresults, 0) ) {
-                AttribList2GLCapabilities(bucket, glp, hdc, pfdIDs[i], iattributes, niattribs, iresults, winattrbits);
+                final GLCapabilitiesImmutable caps = AttribList2GLCapabilities(device, glp, hdc, pfdIDs[i], iattributes, niattribs, iresults, winattrbits);
+                if(null != caps) {
+                    bucket.add(caps);
+                }
             } else if (DEBUG) {
                 System.err.println("wglARBPFIDs2GLCapabilities: Cannot get pixel format attributes for pixel format " +
                                    i + "/" + numFormats + ": " + pfdIDs[i] + ", " +
@@ -582,7 +574,7 @@ public class WindowsWGLGraphicsConfiguration extends MutableGraphicsConfiguratio
         return true;
     }
 
-    static int AttribList2DrawableTypeBits(final int[] iattribs, final int niattribs, final int[] iresults) {
+    static int AttribList2DrawableTypeBits(AbstractGraphicsDevice device, GLProfile glp, final int[] iattribs, final int niattribs, final int[] iresults) {
         int val = 0;
 
         for (int i = 0; i < niattribs; i++) {
@@ -599,18 +591,20 @@ public class WindowsWGLGraphicsConfiguration extends MutableGraphicsConfiguratio
                 break;
             }
         }
+        if ( GLContext.isFBOAvailable(device, glp) ) {
+            val |= GLGraphicsConfigurationUtil.FBO_BIT;
+        }        
         return val;
     }
 
-    static boolean AttribList2GLCapabilities( List<GLCapabilitiesImmutable> capsBucket,
-                                              final GLProfile glp, final long hdc, final int pfdID, final int[] iattribs,
-                                              final int niattribs,
-                                              final int[] iresults, final int winattrmask) {
-        final int allDrawableTypeBits = AttribList2DrawableTypeBits(iattribs, niattribs, iresults);
+    static WGLGLCapabilities AttribList2GLCapabilities(final AbstractGraphicsDevice device, 
+                                                       final GLProfile glp, final long hdc, final int pfdID,
+                                                       final int[] iattribs, final int niattribs, final int[] iresults, final int winattrmask) {
+        final int allDrawableTypeBits = AttribList2DrawableTypeBits(device, glp, iattribs, niattribs, iresults);
         int drawableTypeBits = winattrmask & allDrawableTypeBits;
 
         if( 0 == drawableTypeBits ) {
-            return false;
+            return null;
         }
         PIXELFORMATDESCRIPTOR pfd = createPixelFormatDescriptor();
 
@@ -618,14 +612,13 @@ public class WindowsWGLGraphicsConfiguration extends MutableGraphicsConfiguratio
             // remove displayable bits, since pfdID is non displayable
             drawableTypeBits = drawableTypeBits & ~(GLGraphicsConfigurationUtil.WINDOW_BIT | GLGraphicsConfigurationUtil.BITMAP_BIT);
             if( 0 == drawableTypeBits ) {
-                return false;
+                return null;
             }
             // non displayable requested (pbuffer)
         }
-        WGLGLCapabilities res = new WGLGLCapabilities(pfd, pfdID, glp);
+        final WGLGLCapabilities res = new WGLGLCapabilities(pfd, pfdID, glp);
         res.setValuesByARB(iattribs, niattribs, iresults);
-
-        return GLGraphicsConfigurationUtil.addGLCapabilitiesPermutations(capsBucket, res, drawableTypeBits );
+        return (WGLGLCapabilities) GLGraphicsConfigurationUtil.setWinAttributeBits(res, drawableTypeBits);
     }
 
     //
@@ -645,7 +638,7 @@ public class WindowsWGLGraphicsConfiguration extends MutableGraphicsConfiguratio
         return pfdIDs;
     }
 
-    static int PFD2DrawableTypeBits(PIXELFORMATDESCRIPTOR pfd) {
+    static int PFD2DrawableTypeBits(AbstractGraphicsDevice device, GLProfile glp, PIXELFORMATDESCRIPTOR pfd) {
         int val = 0;
 
         int dwFlags = pfd.getDwFlags();
@@ -656,37 +649,30 @@ public class WindowsWGLGraphicsConfiguration extends MutableGraphicsConfiguratio
         if( 0 != (GDI.PFD_DRAW_TO_BITMAP & dwFlags ) ) {
             val |= GLGraphicsConfigurationUtil.BITMAP_BIT;
         }
+        if ( GLContext.isFBOAvailable(device, glp) ) {
+            val |= GLGraphicsConfigurationUtil.FBO_BIT;
+        }                
         return val;
     }
 
-    static WGLGLCapabilities PFD2GLCapabilities(GLProfile glp, long hdc, int pfdID, boolean onscreen) {
-        final int winattrmask = GLGraphicsConfigurationUtil.getWinAttributeBits(onscreen, false, false);
-        List<GLCapabilitiesImmutable> capsBucket = new ArrayList<GLCapabilitiesImmutable>(1);
-        if( PFD2GLCapabilities(capsBucket, glp, hdc, pfdID, winattrmask) ) {
-            return (WGLGLCapabilities) capsBucket.get(0);
-        }
-        return null;
-    }
-
-    static boolean  PFD2GLCapabilities(List<GLCapabilitiesImmutable> capsBucket, final GLProfile glp, final long hdc, final int pfdID, final int winattrmask) {
+    static WGLGLCapabilities PFD2GLCapabilities(AbstractGraphicsDevice device, final GLProfile glp, final long hdc, final int pfdID, final int winattrmask) {
         PIXELFORMATDESCRIPTOR pfd = createPixelFormatDescriptor(hdc, pfdID);
         if(null == pfd) {
-            return false;
+            return null;
         }
         if ((pfd.getDwFlags() & GDI.PFD_SUPPORT_OPENGL) == 0) {
-          return false;
+          return null;
         }
-        final int allDrawableTypeBits = PFD2DrawableTypeBits(pfd);
+        final int allDrawableTypeBits = PFD2DrawableTypeBits(device, glp, pfd);
         final int drawableTypeBits = winattrmask & allDrawableTypeBits;
 
         if( 0 == drawableTypeBits ) {
-            return false;
+            return null;
         }
 
-        WGLGLCapabilities res = new WGLGLCapabilities(pfd, pfdID, glp);
+        final WGLGLCapabilities res = new WGLGLCapabilities(pfd, pfdID, glp);
         res.setValuesByGDI();
-
-        return GLGraphicsConfigurationUtil.addGLCapabilitiesPermutations(capsBucket, res, drawableTypeBits );
+        return (WGLGLCapabilities) GLGraphicsConfigurationUtil.setWinAttributeBits(res, drawableTypeBits );
   }
 
   static PIXELFORMATDESCRIPTOR GLCapabilities2PFD(GLCapabilitiesImmutable caps, PIXELFORMATDESCRIPTOR pfd) {
diff --git a/src/jogl/classes/jogamp/opengl/windows/wgl/WindowsWGLGraphicsConfigurationFactory.java b/src/jogl/classes/jogamp/opengl/windows/wgl/WindowsWGLGraphicsConfigurationFactory.java
index 00ed91bb4..66a5821d3 100644
--- a/src/jogl/classes/jogamp/opengl/windows/wgl/WindowsWGLGraphicsConfigurationFactory.java
+++ b/src/jogl/classes/jogamp/opengl/windows/wgl/WindowsWGLGraphicsConfigurationFactory.java
@@ -131,10 +131,10 @@ public class WindowsWGLGraphicsConfigurationFactory extends GLGraphicsConfigurat
                 throw new GLException("Error: HDC is null");
             }
             if (sharedResource.hasARBPixelFormat()) {
-                availableCaps = getAvailableGLCapabilitiesARB(hdc, sharedResource, capsChosen.getGLProfile());
+                availableCaps = WindowsWGLGraphicsConfigurationFactory.getAvailableGLCapabilitiesARB(sharedResource, sharedResource.getDevice(), capsChosen.getGLProfile(), hdc);
             }
             if( null == availableCaps || availableCaps.isEmpty() ) {
-                availableCaps = getAvailableGLCapabilitiesGDI(hdc, capsChosen.getGLProfile());
+                availableCaps = getAvailableGLCapabilitiesGDI(device, capsChosen.getGLProfile(), hdc);
             }
         } finally {
             if ( sharedResource.needsCurrentContext4ARBPFDQueries() ) {
@@ -150,17 +150,20 @@ public class WindowsWGLGraphicsConfigurationFactory extends GLGraphicsConfigurat
         return availableCaps;
     }
 
-    static List<GLCapabilitiesImmutable> getAvailableGLCapabilitiesARB(long hdc, WindowsWGLDrawableFactory.SharedResource sharedResource, GLProfile glProfile) {
+    static List<GLCapabilitiesImmutable> getAvailableGLCapabilitiesARB(WindowsWGLDrawableFactory.SharedResource sharedResource, AbstractGraphicsDevice device, GLProfile glProfile, long hdc) {
         int[] pformats = WindowsWGLGraphicsConfiguration.wglAllARBPFIDs((WindowsWGLContext)sharedResource.getContext(), hdc);
-        return WindowsWGLGraphicsConfiguration.wglARBPFIDs2AllGLCapabilities(sharedResource, hdc, pformats, glProfile);
+        return WindowsWGLGraphicsConfiguration.wglARBPFIDs2AllGLCapabilities(sharedResource, device, glProfile, hdc, pformats);
     }
 
-    static List<GLCapabilitiesImmutable> getAvailableGLCapabilitiesGDI(long hdc, GLProfile glProfile) {
+    static List<GLCapabilitiesImmutable> getAvailableGLCapabilitiesGDI(AbstractGraphicsDevice device, GLProfile glProfile, long hdc) {
         int[] pformats = WindowsWGLGraphicsConfiguration.wglAllGDIPFIDs(hdc);
         int numFormats = pformats.length;
         List<GLCapabilitiesImmutable> bucket = new ArrayList<GLCapabilitiesImmutable>(numFormats);
         for (int i = 0; i < numFormats; i++) {
-            WindowsWGLGraphicsConfiguration.PFD2GLCapabilities(bucket, glProfile, hdc, pformats[i], GLGraphicsConfigurationUtil.ALL_BITS);
+            final GLCapabilitiesImmutable caps = WindowsWGLGraphicsConfiguration.PFD2GLCapabilities(device, glProfile, hdc, pformats[i], GLGraphicsConfigurationUtil.ALL_BITS);
+            if(null != caps) {
+                bucket.add(caps);
+            }
         }
         return bucket;
     }
@@ -274,8 +277,8 @@ public class WindowsWGLGraphicsConfigurationFactory extends GLGraphicsConfigurat
             }
         }
         try {
-            if( !updateGraphicsConfigurationARB(hdc, extHDC, config, chooser, (WindowsWGLDrawableFactory)factory, pfdIDs) ) {
-                updateGraphicsConfigurationGDI(hdc, extHDC, config, chooser, pfdIDs);
+            if( !updateGraphicsConfigurationARB((WindowsWGLDrawableFactory)factory, config, chooser, hdc, extHDC, pfdIDs) ) {
+                updateGraphicsConfigurationGDI(config, chooser, hdc, extHDC, pfdIDs);
             }
         } finally {
             if (null != sharedContext) {
@@ -284,10 +287,10 @@ public class WindowsWGLGraphicsConfigurationFactory extends GLGraphicsConfigurat
         }
     }
 
-    private static boolean updateGraphicsConfigurationARB(long hdc, boolean extHDC, WindowsWGLGraphicsConfiguration config,
-                                                          CapabilitiesChooser chooser, WindowsWGLDrawableFactory factory, int[] pformats) {
-        AbstractGraphicsDevice device = config.getScreen().getDevice();
-        WindowsWGLDrawableFactory.SharedResource sharedResource = factory.getOrCreateSharedResource(device);
+    private static boolean updateGraphicsConfigurationARB(WindowsWGLDrawableFactory factory, WindowsWGLGraphicsConfiguration config, CapabilitiesChooser chooser,
+                                                          long hdc, boolean extHDC, int[] pformats) {
+        final AbstractGraphicsDevice device = config.getScreen().getDevice();
+        final WindowsWGLDrawableFactory.SharedResource sharedResource = factory.getOrCreateSharedResource(device);
 
         if (null == sharedResource) {
             if (DEBUG) {
@@ -302,11 +305,10 @@ public class WindowsWGLGraphicsConfigurationFactory extends GLGraphicsConfigurat
             return false;
         }
 
-        GLCapabilitiesImmutable capsChosen = (GLCapabilitiesImmutable) config.getChosenCapabilities();
-        boolean isOpaque = capsChosen.isBackgroundOpaque() && GDI.DwmIsCompositionEnabled();
-        boolean onscreen = capsChosen.isOnscreen();
-        boolean usePBuffer = capsChosen.isPBuffer();
-        GLProfile glProfile = capsChosen.getGLProfile();
+        final GLCapabilitiesImmutable capsChosen = (GLCapabilitiesImmutable) config.getChosenCapabilities();
+        final boolean isOpaque = capsChosen.isBackgroundOpaque() && GDI.DwmIsCompositionEnabled();
+        final int winattrbits = GLGraphicsConfigurationUtil.getExclusiveWinAttributeBits(capsChosen);
+        final GLProfile glProfile = capsChosen.getGLProfile();
         
         if(DEBUG) {
             System.err.println("translucency requested: "+(!capsChosen.isBackgroundOpaque())+", compositioning enabled: "+GDI.DwmIsCompositionEnabled()+" -> translucency "+(!isOpaque));
@@ -325,7 +327,7 @@ public class WindowsWGLGraphicsConfigurationFactory extends GLGraphicsConfigurat
                         + ", pixelformat " + presetPFDID);
             }
             pixelFormatSet = true;
-            pixelFormatCaps = WindowsWGLGraphicsConfiguration.wglARBPFID2GLCapabilities(sharedResource, hdc, presetPFDID, glProfile, onscreen, usePBuffer);
+            pixelFormatCaps = WindowsWGLGraphicsConfiguration.wglARBPFID2GLCapabilities(sharedResource, device, glProfile, hdc, presetPFDID, winattrbits);
             pixelFormatCaps = (WGLGLCapabilities) GLGraphicsConfigurationUtil.fixOpaqueGLCapabilities(pixelFormatCaps, isOpaque);
         } else {
             int recommendedIndex = -1; // recommended index
@@ -337,17 +339,17 @@ public class WindowsWGLGraphicsConfigurationFactory extends GLGraphicsConfigurat
                 int[] iattributes = new int[2 * WindowsWGLGraphicsConfiguration.MAX_ATTRIBS];
                 float[] fattributes = new float[1];
                 int accelerationMode = WGLExt.WGL_FULL_ACCELERATION_ARB;
-                pformats = WindowsWGLGraphicsConfiguration.wglChoosePixelFormatARB(hdc, sharedResource, capsChosen,
-                                                                                   iattributes, accelerationMode, fattributes);
+                pformats = WindowsWGLGraphicsConfiguration.wglChoosePixelFormatARB(sharedResource, device, capsChosen,
+                                                                                   hdc, iattributes, accelerationMode, fattributes);
                 if (null == pformats) {
                     accelerationMode = WGLExt.WGL_GENERIC_ACCELERATION_ARB;
-                    pformats = WindowsWGLGraphicsConfiguration.wglChoosePixelFormatARB(hdc, sharedResource, capsChosen,
-                                                                                       iattributes, accelerationMode, fattributes);
+                    pformats = WindowsWGLGraphicsConfiguration.wglChoosePixelFormatARB(sharedResource, device, capsChosen,
+                                                                                       hdc, iattributes, accelerationMode, fattributes);
                 }
                 if (null == pformats) {
                     accelerationMode = -1; // use what we are offered ..
-                    pformats = WindowsWGLGraphicsConfiguration.wglChoosePixelFormatARB(hdc, sharedResource, capsChosen,
-                                                                                       iattributes, accelerationMode, fattributes);
+                    pformats = WindowsWGLGraphicsConfiguration.wglChoosePixelFormatARB(sharedResource, device, capsChosen,
+                                                                                       hdc, iattributes, accelerationMode, fattributes);
                 }
                 if (null != pformats) {
                     recommendedIndex = 0;
@@ -371,13 +373,13 @@ public class WindowsWGLGraphicsConfigurationFactory extends GLGraphicsConfigurat
                 }
             }
 
-            List<GLCapabilitiesImmutable> availableCaps =
-                WindowsWGLGraphicsConfiguration.wglARBPFIDs2GLCapabilities(sharedResource, hdc, pformats,
-                                                                           glProfile, onscreen, usePBuffer);
+            List<GLCapabilitiesImmutable> availableCaps = 
+                    WindowsWGLGraphicsConfiguration.wglARBPFIDs2GLCapabilities(sharedResource, device, glProfile, hdc, pformats, winattrbits);
+            
             if( null == availableCaps || 0 == availableCaps.size() ) {
                 if (DEBUG) {
                     System.err.println("updateGraphicsConfigurationARB: wglARBPFIDs2GLCapabilities failed with " + pformats.length +
-                                       " pfd ids, onscreen " + onscreen + ", pbuffer " + usePBuffer);
+                                       " pfd ids, " + GLGraphicsConfigurationUtil.winAttributeBits2String(null, winattrbits).toString());
                     Thread.dumpStack();
                 }
                 return false;
@@ -385,7 +387,7 @@ public class WindowsWGLGraphicsConfigurationFactory extends GLGraphicsConfigurat
 
             if (DEBUG) {
                 System.err.println("updateGraphicsConfigurationARB: " + pformats.length +
-                                   " pfd ids, onscreen " + onscreen + ", pbuffer " + usePBuffer + ", " + availableCaps.size() + " glcaps");
+                                   " pfd ids, " + GLGraphicsConfigurationUtil.winAttributeBits2String(null, winattrbits).toString() + ", " + availableCaps.size() + " glcaps");
                 if(0 <= recommendedIndex) {
                     System.err.println("updateGraphicsConfigurationARB: Used wglChoosePixelFormatARB to recommend pixel format " +
                                        pformats[recommendedIndex] + ", idx " + recommendedIndex +", "+availableCaps.get(recommendedIndex));
@@ -420,8 +422,8 @@ public class WindowsWGLGraphicsConfigurationFactory extends GLGraphicsConfigurat
         return true;
     }
 
-    private static boolean updateGraphicsConfigurationGDI(long hdc, boolean extHDC, WindowsWGLGraphicsConfiguration config,
-                                                          CapabilitiesChooser chooser, int[] pformats) {
+    private static boolean updateGraphicsConfigurationGDI(WindowsWGLGraphicsConfiguration config, CapabilitiesChooser chooser, long hdc,
+                                                          boolean extHDC, int[] pformats) {
         GLCapabilitiesImmutable capsChosen = (GLCapabilitiesImmutable) config.getChosenCapabilities();
         if(capsChosen.isPBuffer()) {
             if (DEBUG) {
@@ -429,9 +431,11 @@ public class WindowsWGLGraphicsConfigurationFactory extends GLGraphicsConfigurat
             }
             return false;
         }
-        boolean onscreen = capsChosen.isOnscreen();
-        GLProfile glProfile = capsChosen.getGLProfile();
-
+        // final boolean onscreen = capsChosen.isOnscreen();
+        // final boolean useFBO = capsChosen.isFBO();
+        final GLProfile glProfile = capsChosen.getGLProfile();
+        final int winattrmask = GLGraphicsConfigurationUtil.getExclusiveWinAttributeBits(capsChosen);
+        
         List<GLCapabilitiesImmutable> availableCaps = new ArrayList<GLCapabilitiesImmutable>();
         int pfdID; // chosen or preset PFD ID
         WGLGLCapabilities pixelFormatCaps = null; // chosen or preset PFD ID's caps
@@ -447,15 +451,17 @@ public class WindowsWGLGraphicsConfigurationFactory extends GLGraphicsConfigurat
                         + ", pixelformat " + pfdID);
             }
             pixelFormatSet = true;
-            pixelFormatCaps = WindowsWGLGraphicsConfiguration.PFD2GLCapabilities(glProfile, hdc, pfdID, onscreen);
+            pixelFormatCaps = WindowsWGLGraphicsConfiguration.PFD2GLCapabilities(config.getScreen().getDevice(), glProfile, hdc, pfdID, winattrmask);
         } else {
             if(null == pformats) {
                 pformats = WindowsWGLGraphicsConfiguration.wglAllGDIPFIDs(hdc);
             }
-            final int winattrmask = GLGraphicsConfigurationUtil.getWinAttributeBits(onscreen, false, false);
 
             for (int i = 0; i < pformats.length; i++) {
-                WindowsWGLGraphicsConfiguration.PFD2GLCapabilities(availableCaps, glProfile, hdc, pformats[i], winattrmask);
+                final GLCapabilitiesImmutable caps = WindowsWGLGraphicsConfiguration.PFD2GLCapabilities(config.getScreen().getDevice(), glProfile, hdc, pformats[i], winattrmask);
+                if(null != caps) {
+                    availableCaps.add(caps);
+                }                
             }
 
             // 1st choice: get GLCapabilities based on users GLCapabilities setting recommendedIndex as preferred choice
diff --git a/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXGraphicsConfiguration.java b/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXGraphicsConfiguration.java
index b458fffe1..d169945fe 100644
--- a/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXGraphicsConfiguration.java
+++ b/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXGraphicsConfiguration.java
@@ -33,10 +33,6 @@
 
 package jogamp.opengl.x11.glx;
 
-import java.util.ArrayList;
-import java.util.List;
-
-import javax.media.nativewindow.AbstractGraphicsDevice;
 import javax.media.nativewindow.CapabilitiesImmutable;
 import javax.media.nativewindow.GraphicsConfigurationFactory;
 import javax.media.nativewindow.VisualIDHolder;
@@ -58,6 +54,7 @@ import jogamp.opengl.GLGraphicsConfigurationUtil;
 
 import com.jogamp.common.nio.PointerBuffer;
 import com.jogamp.nativewindow.x11.X11GraphicsConfiguration;
+import com.jogamp.nativewindow.x11.X11GraphicsDevice;
 import com.jogamp.nativewindow.x11.X11GraphicsScreen;
 
 public class X11GLXGraphicsConfiguration extends X11GraphicsConfiguration implements Cloneable {
@@ -71,7 +68,7 @@ public class X11GLXGraphicsConfiguration extends X11GraphicsConfiguration implem
     }
 
     static X11GLXGraphicsConfiguration create(GLProfile glp, X11GraphicsScreen x11Screen, int fbcfgID) {
-      final AbstractGraphicsDevice device = x11Screen.getDevice();
+      final X11GraphicsDevice device = (X11GraphicsDevice) x11Screen.getDevice();
       final long display = device.getHandle();
       if(0==display) {
           throw new GLException("Display null of "+x11Screen);
@@ -85,7 +82,7 @@ public class X11GLXGraphicsConfiguration extends X11GraphicsConfiguration implem
         glp = GLProfile.getDefault(x11Screen.getDevice());
       }
       final X11GLXDrawableFactory factory = (X11GLXDrawableFactory) GLDrawableFactory.getDesktopFactory();
-      final X11GLCapabilities caps = GLXFBConfig2GLCapabilities(glp, device, fbcfg, true, true, true, factory.isGLXMultisampleAvailable(device));
+      final X11GLCapabilities caps = GLXFBConfig2GLCapabilities(device, glp, fbcfg, GLGraphicsConfigurationUtil.ALL_BITS, factory.isGLXMultisampleAvailable(device));      
       if(null==caps) {
           throw new GLException("GLCapabilities null of "+toHexString(fbcfg));
       }
@@ -247,7 +244,7 @@ public class X11GLXGraphicsConfiguration extends X11GraphicsConfiguration implem
     return true;
   }
 
-  static int FBCfgDrawableTypeBits(final AbstractGraphicsDevice device, GLProfile glp, final long fbcfg) {
+  static int FBCfgDrawableTypeBits(final X11GraphicsDevice device, GLProfile glp, final long fbcfg) {
     int val = 0;
 
     int[] tmp = new int[1];
@@ -268,19 +265,6 @@ public class X11GLXGraphicsConfiguration extends X11GraphicsConfiguration implem
     return val;
   }
 
-  static X11GLCapabilities GLXFBConfig2GLCapabilities(GLProfile glp, AbstractGraphicsDevice device, long fbcfg,
-                                                            boolean relaxed, boolean onscreen, boolean usePBuffer,
-                                                            boolean isMultisampleAvailable) {
-    ArrayList<GLCapabilitiesImmutable> bucket = new ArrayList<GLCapabilitiesImmutable>();
-    final int winattrmask = GLGraphicsConfigurationUtil.getWinAttributeBits(onscreen, usePBuffer, false);
-    if( GLXFBConfig2GLCapabilities(bucket, glp, device, fbcfg, winattrmask, isMultisampleAvailable) ) {
-        return (X11GLCapabilities) bucket.get(0);
-    } else if ( relaxed && GLXFBConfig2GLCapabilities(bucket, glp, device, fbcfg, GLGraphicsConfigurationUtil.ALL_BITS, isMultisampleAvailable) ) {
-        return (X11GLCapabilities) bucket.get(0);
-    }
-    return null;
-  }
-
   static XRenderDirectFormat XVisual2XRenderMask(long dpy, long visual) {
     XRenderPictFormat renderPictFmt = X11Lib.XRenderFindVisualFormat(dpy, visual);
     if(null == renderPictFmt) {
@@ -289,9 +273,8 @@ public class X11GLXGraphicsConfiguration extends X11GraphicsConfiguration implem
     return renderPictFmt.getDirect();
   }
 
-  static boolean GLXFBConfig2GLCapabilities(List<GLCapabilitiesImmutable> capsBucket,
-                                            GLProfile glp, AbstractGraphicsDevice device, long fbcfg,
-                                            int winattrmask, boolean isMultisampleAvailable) {
+  static X11GLCapabilities GLXFBConfig2GLCapabilities(X11GraphicsDevice device, GLProfile glp, long fbcfg,
+                                                      int winattrmask, boolean isMultisampleAvailable) {
     final int allDrawableTypeBits = FBCfgDrawableTypeBits(device, glp,  fbcfg);
     int drawableTypeBits = winattrmask & allDrawableTypeBits;
     
@@ -307,18 +290,18 @@ public class X11GLXGraphicsConfiguration extends X11GraphicsConfiguration implem
     }
 
     if( 0 == drawableTypeBits ) {
-        return false;
+        return null;
     }
 
     int[] tmp = new int[1];
     if(GLX.GLX_BAD_ATTRIBUTE == GLX.glXGetFBConfigAttrib(display, fbcfg, GLX.GLX_RENDER_TYPE, tmp, 0)) {
-      return false;
+      return null;
     }
     if( 0 == ( GLX.GLX_RGBA_BIT & tmp[0] ) ) {
-      return false; // no RGBA -> color index not supported
+      return null; // no RGBA -> color index not supported
     }
 
-    GLCapabilities res = new X11GLCapabilities(visualInfo, fbcfg, fbcfgid, glp);
+    X11GLCapabilities res = new X11GLCapabilities(visualInfo, fbcfg, fbcfgid, glp);
     if (isMultisampleAvailable) {
       res.setSampleBuffers(glXGetFBConfig(display, fbcfg, GLX.GLX_SAMPLE_BUFFERS, tmp, 0) != 0);
       res.setNumSamples   (glXGetFBConfig(display, fbcfg, GLX.GLX_SAMPLES,        tmp, 0));
@@ -353,7 +336,7 @@ public class X11GLXGraphicsConfiguration extends X11GraphicsConfiguration implem
         res.setPbufferFloatingPointBuffers(glXGetFBConfig(display, fbcfg, GLXExt.GLX_FLOAT_COMPONENTS_NV, tmp, 0) != GL.GL_FALSE);
     } catch (Exception e) {}
 
-    return GLGraphicsConfigurationUtil.addGLCapabilitiesPermutations(capsBucket, res, drawableTypeBits );
+    return (X11GLCapabilities) GLGraphicsConfigurationUtil.setWinAttributeBits(res, drawableTypeBits);
   }
 
   private static String glXGetFBConfigErrorCode(int err) {
@@ -408,30 +391,34 @@ public class X11GLXGraphicsConfiguration extends X11GraphicsConfiguration implem
       return res;
   }
 
-  static boolean XVisualInfo2GLCapabilities(List<GLCapabilitiesImmutable> capsBucket,
-                                            GLProfile glp, long display, XVisualInfo info,
-                                            final int winattrmask, boolean isMultisampleEnabled) {
-    final int allDrawableTypeBits = GLGraphicsConfigurationUtil.WINDOW_BIT | GLGraphicsConfigurationUtil.BITMAP_BIT ;
+  static X11GLCapabilities XVisualInfo2GLCapabilities(final X11GraphicsDevice device, GLProfile glp, XVisualInfo info,
+                                                      final int winattrmask, boolean isMultisampleEnabled) {
+    final int allDrawableTypeBits = GLGraphicsConfigurationUtil.WINDOW_BIT | 
+                                    GLGraphicsConfigurationUtil.BITMAP_BIT | 
+                                    ( GLContext.isFBOAvailable(device, glp) ? GLGraphicsConfigurationUtil.FBO_BIT : 0 )
+                                    ;
+
     final int drawableTypeBits = winattrmask & allDrawableTypeBits;
 
     if( 0 == drawableTypeBits ) {
-        return false;
+        return null;
     }
 
+    final long display = device.getHandle();
     int[] tmp = new int[1];
     int val = glXGetConfig(display, info, GLX.GLX_USE_GL, tmp, 0);
     if (val == 0) {
       if(DEBUG) {
         System.err.println("Visual ("+toHexString(info.getVisualid())+") does not support OpenGL");
       }
-      return false;
+      return null;
     }
     val = glXGetConfig(display, info, GLX.GLX_RGBA, tmp, 0);
     if (val == 0) {
       if(DEBUG) {
         System.err.println("Visual ("+toHexString(info.getVisualid())+") does not support RGBA");
       }
-      return false;
+      return null;
     }
 
     GLCapabilities res = new X11GLCapabilities(info, glp);
@@ -470,7 +457,7 @@ public class X11GLXGraphicsConfiguration extends X11GraphicsConfiguration implem
     res.setAccumBlueBits (glXGetConfig(display, info, GLX.GLX_ACCUM_BLUE_SIZE,  tmp, 0));
     res.setAccumAlphaBits(glXGetConfig(display, info, GLX.GLX_ACCUM_ALPHA_SIZE, tmp, 0));
 
-    return GLGraphicsConfigurationUtil.addGLCapabilitiesPermutations(capsBucket, res, drawableTypeBits);
+    return (X11GLCapabilities) GLGraphicsConfigurationUtil.setWinAttributeBits(res, drawableTypeBits);
   }
 
   private static String glXGetConfigErrorCode(int err) {
diff --git a/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXGraphicsConfigurationFactory.java b/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXGraphicsConfigurationFactory.java
index 234b06bdb..3189f933f 100644
--- a/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXGraphicsConfigurationFactory.java
+++ b/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXGraphicsConfigurationFactory.java
@@ -152,12 +152,12 @@ public class X11GLXGraphicsConfigurationFactory extends GLGraphicsConfigurationF
 
         // Utilizing FBConfig
         //
-        AbstractGraphicsDevice absDevice = x11Screen.getDevice();
-        long display = absDevice.getHandle();
+        final X11GraphicsDevice absDevice = (X11GraphicsDevice) x11Screen.getDevice();
+        final long display = absDevice.getHandle();
 
-        int screen = x11Screen.getIndex();
-        int[] count = { -1 };
-        ArrayList<GLCapabilitiesImmutable> availableCaps = new ArrayList<GLCapabilitiesImmutable>();
+        final int screen = x11Screen.getIndex();
+        final int[] count = { -1 };
+        final ArrayList<GLCapabilitiesImmutable> availableCaps = new ArrayList<GLCapabilitiesImmutable>();
 
         fbcfgsL = GLX.glXChooseFBConfig(display, screen, null, 0, count, 0);
         if (fbcfgsL == null || fbcfgsL.limit()<=0) {
@@ -167,18 +167,19 @@ public class X11GLXGraphicsConfigurationFactory extends GLGraphicsConfigurationF
             return null;
         }
         for (int i = 0; i < fbcfgsL.limit(); i++) {
-            if( !X11GLXGraphicsConfiguration.GLXFBConfig2GLCapabilities(availableCaps, glProfile, absDevice, fbcfgsL.get(i), GLGraphicsConfigurationUtil.ALL_BITS, isMultisampleAvailable) ) {
-                if(DEBUG) {
-                    System.err.println("X11GLXGraphicsConfiguration.getAvailableGLCapabilitiesFBConfig: FBConfig invalid (2): ("+x11Screen+"): fbcfg: "+toHexString(fbcfgsL.get(i)));
-                }
+            final GLCapabilitiesImmutable caps = X11GLXGraphicsConfiguration.GLXFBConfig2GLCapabilities(absDevice, glProfile, fbcfgsL.get(i), GLGraphicsConfigurationUtil.ALL_BITS, isMultisampleAvailable);
+            if(null != caps) {
+                availableCaps.add(caps);
+            } else if(DEBUG) {
+                System.err.println("X11GLXGraphicsConfiguration.getAvailableGLCapabilitiesFBConfig: FBConfig invalid (2): ("+x11Screen+"): fbcfg: "+toHexString(fbcfgsL.get(i)));
             }
         }
         return availableCaps;
     }
 
     static List<GLCapabilitiesImmutable> getAvailableGLCapabilitiesXVisual(X11GraphicsScreen x11Screen, GLProfile glProfile, boolean isMultisampleAvailable) {
-        AbstractGraphicsDevice absDevice = x11Screen.getDevice();
-        long display = absDevice.getHandle();
+        final X11GraphicsDevice absDevice = (X11GraphicsDevice) x11Screen.getDevice();
+        final long display = absDevice.getHandle();
 
         int screen = x11Screen.getIndex();
 
@@ -191,10 +192,11 @@ public class X11GLXGraphicsConfigurationFactory extends GLGraphicsConfigurationF
         }
         ArrayList<GLCapabilitiesImmutable> availableCaps = new ArrayList<GLCapabilitiesImmutable>();
         for (int i = 0; i < infos.length; i++) {
-            if( !X11GLXGraphicsConfiguration.XVisualInfo2GLCapabilities(availableCaps, glProfile, display, infos[i], GLGraphicsConfigurationUtil.ALL_BITS, isMultisampleAvailable) ) {
-                if(DEBUG) {
-                    System.err.println("X11GLXGraphicsConfiguration.getAvailableGLCapabilitiesXVisual: XVisual invalid: ("+x11Screen+"): fbcfg: "+toHexString(infos[i].getVisualid()));
-                }
+            final GLCapabilitiesImmutable caps = X11GLXGraphicsConfiguration.XVisualInfo2GLCapabilities(absDevice, glProfile, infos[i], GLGraphicsConfigurationUtil.ALL_BITS, isMultisampleAvailable);
+            if(null != caps) {
+                availableCaps.add(caps);
+            } if(DEBUG) {
+                System.err.println("X11GLXGraphicsConfiguration.getAvailableGLCapabilitiesXVisual: XVisual invalid: ("+x11Screen+"): fbcfg: "+toHexString(infos[i].getVisualid()));
             }
         }
         return availableCaps;
@@ -238,8 +240,8 @@ public class X11GLXGraphicsConfigurationFactory extends GLGraphicsConfigurationF
     }
 
     static X11GLXGraphicsConfiguration fetchGraphicsConfigurationFBConfig(X11GraphicsScreen x11Screen, int fbID, GLProfile glp) {
-        final AbstractGraphicsDevice absDevice = x11Screen.getDevice();
-        final long display = absDevice.getHandle();
+        final X11GraphicsDevice x11Device = (X11GraphicsDevice) x11Screen.getDevice();
+        final long display = x11Device.getHandle();
         final int screen = x11Screen.getIndex();
 
         final long fbcfg = X11GLXGraphicsConfiguration.glXFBConfigID2FBConfig(display, screen, fbID);
@@ -251,7 +253,7 @@ public class X11GLXGraphicsConfigurationFactory extends GLGraphicsConfigurationF
         }
         final X11GLXDrawableFactory factory = (X11GLXDrawableFactory) GLDrawableFactory.getDesktopFactory();
                
-        final X11GLCapabilities caps = X11GLXGraphicsConfiguration.GLXFBConfig2GLCapabilities(glp, absDevice, fbcfg, true, true, true, factory.isGLXMultisampleAvailable(absDevice));
+        final X11GLCapabilities caps = X11GLXGraphicsConfiguration.GLXFBConfig2GLCapabilities(x11Device, glp, fbcfg, GLGraphicsConfigurationUtil.ALL_BITS, factory.isGLXMultisampleAvailable(x11Device));
         return new X11GLXGraphicsConfiguration(x11Screen, caps, caps, new DefaultGLCapabilitiesChooser());
     }
 
@@ -262,22 +264,19 @@ public class X11GLXGraphicsConfigurationFactory extends GLGraphicsConfigurationF
         int recommendedIndex = -1;
         PointerBuffer fbcfgsL = null;
         GLProfile glProfile = capsChosen.getGLProfile();
-        boolean onscreen = capsChosen.isOnscreen();
-        boolean usePBuffer = capsChosen.isPBuffer();
-        boolean useFBO = capsChosen.isFBO();
 
         // Utilizing FBConfig
         //
-        AbstractGraphicsDevice absDevice = x11Screen.getDevice();
-        long display = absDevice.getHandle();
+        X11GraphicsDevice x11Device = (X11GraphicsDevice) x11Screen.getDevice();
+        long display = x11Device.getHandle();
         int screen = x11Screen.getIndex();
         
         final X11GLXDrawableFactory factory = (X11GLXDrawableFactory) GLDrawableFactory.getDesktopFactory();                              
-        final boolean isMultisampleAvailable = factory.isGLXMultisampleAvailable(absDevice);
+        final boolean isMultisampleAvailable = factory.isGLXMultisampleAvailable(x11Device);
         int[] attribs = X11GLXGraphicsConfiguration.GLCapabilities2AttribList(capsChosen, true, isMultisampleAvailable, display, screen);
         int[] count = { -1 };
         List<GLCapabilitiesImmutable> availableCaps = new ArrayList<GLCapabilitiesImmutable>();
-        final int winattrmask = GLGraphicsConfigurationUtil.getWinAttributeBits(onscreen, usePBuffer, useFBO);
+        final int winattrmask = GLGraphicsConfigurationUtil.getExclusiveWinAttributeBits(capsChosen);
         // 1st choice: get GLCapabilities based on users GLCapabilities setting recommendedIndex as preferred choice,
         // skipped if xvisualID is given
         if( VisualIDHolder.VID_UNDEFINED == xvisualID ) {
@@ -285,10 +284,11 @@ public class X11GLXGraphicsConfigurationFactory extends GLGraphicsConfigurationF
         }
         if (fbcfgsL != null && fbcfgsL.limit()>0) {
             for (int i = 0; i < fbcfgsL.limit(); i++) {
-                if( !X11GLXGraphicsConfiguration.GLXFBConfig2GLCapabilities(availableCaps, glProfile, absDevice, fbcfgsL.get(i), winattrmask, isMultisampleAvailable) ) {
-                    if(DEBUG) {
-                        System.err.println("X11GLXGraphicsConfiguration.chooseGraphicsConfigurationFBConfig: FBConfig invalid (1): ("+x11Screen+","+capsChosen+"): fbcfg: "+toHexString(fbcfgsL.get(i)));
-                    }
+                final GLCapabilitiesImmutable caps = X11GLXGraphicsConfiguration.GLXFBConfig2GLCapabilities(x11Device, glProfile, fbcfgsL.get(i), winattrmask, isMultisampleAvailable);
+                if( null != caps ) {
+                    availableCaps.add(caps);
+                } else if(DEBUG) {
+                    System.err.println("X11GLXGraphicsConfiguration.chooseGraphicsConfigurationFBConfig: FBConfig invalid (1): ("+x11Screen+","+capsChosen+"): fbcfg: "+toHexString(fbcfgsL.get(i)));
                 }
             }
             if(availableCaps.size() > 0) {
@@ -318,10 +318,11 @@ public class X11GLXGraphicsConfigurationFactory extends GLGraphicsConfigurationF
             }
 
             for (int i = 0; i < fbcfgsL.limit(); i++) {
-                if( !X11GLXGraphicsConfiguration.GLXFBConfig2GLCapabilities(availableCaps, glProfile, absDevice, fbcfgsL.get(i), winattrmask, isMultisampleAvailable) ) {
-                    if(DEBUG) {
-                        System.err.println("X11GLXGraphicsConfiguration.chooseGraphicsConfigurationFBConfig: FBConfig invalid (2): ("+x11Screen+"): fbcfg: "+toHexString(fbcfgsL.get(i)));
-                    }
+                final GLCapabilitiesImmutable caps = X11GLXGraphicsConfiguration.GLXFBConfig2GLCapabilities(x11Device, glProfile, fbcfgsL.get(i), winattrmask, isMultisampleAvailable);
+                if( null != caps ) {
+                    availableCaps.add(caps);
+                } else if(DEBUG) {
+                    System.err.println("X11GLXGraphicsConfiguration.chooseGraphicsConfigurationFBConfig: FBConfig invalid (2): ("+x11Screen+"): fbcfg: "+toHexString(fbcfgsL.get(i)));
                 }
             }
         }
@@ -374,11 +375,11 @@ public class X11GLXGraphicsConfigurationFactory extends GLGraphicsConfigurationF
         }
 
         GLProfile glProfile = capsChosen.getGLProfile();
-        final int winattrmask = GLGraphicsConfigurationUtil.getWinAttributeBits(capsChosen.isOnscreen(), false /* pbuffer */, false);
+        final int winattrmask = GLGraphicsConfigurationUtil.getExclusiveWinAttributeBits(capsChosen.isOnscreen(), capsChosen.isFBO(), false /* pbuffer */, capsChosen.isBitmap());
         List<GLCapabilitiesImmutable> availableCaps = new ArrayList<GLCapabilitiesImmutable>();
         int recommendedIndex = -1;
 
-        AbstractGraphicsDevice absDevice = x11Screen.getDevice();
+        X11GraphicsDevice absDevice = (X11GraphicsDevice) x11Screen.getDevice();
         long display = absDevice.getHandle();
         int screen = x11Screen.getIndex();
         
@@ -411,15 +412,15 @@ public class X11GLXGraphicsConfigurationFactory extends GLGraphicsConfigurationF
         }
 
         for (int i = 0; i < infos.length; i++) {
-            if( !X11GLXGraphicsConfiguration.XVisualInfo2GLCapabilities(availableCaps, glProfile, display, infos[i], winattrmask, isMultisampleAvailable) ) {
-                if(DEBUG) {
-                    System.err.println("X11GLXGraphicsConfiguration.chooseGraphicsConfigurationXVisual: XVisual invalid: ("+x11Screen+"): fbcfg: "+toHexString(infos[i].getVisualid()));
-                }
-            } else {
+            final GLCapabilitiesImmutable caps = X11GLXGraphicsConfiguration.XVisualInfo2GLCapabilities(absDevice, glProfile, infos[i], winattrmask, isMultisampleAvailable);
+            if( null != caps ) {
+                availableCaps.add(caps);
                 // Attempt to find the visual chosenIndex by glXChooseVisual, if not translucent
                 if (capsChosen.isBackgroundOpaque() && recommendedVis != null && recommendedVis.getVisualid() == infos[i].getVisualid()) {
                     recommendedIndex = availableCaps.size() - 1;
                 }
+            } else if(DEBUG) {
+                System.err.println("X11GLXGraphicsConfiguration.chooseGraphicsConfigurationXVisual: XVisual invalid: ("+x11Screen+"): fbcfg: "+toHexString(infos[i].getVisualid()));
             }
         }
 
diff --git a/src/nativewindow/classes/javax/media/nativewindow/Capabilities.java b/src/nativewindow/classes/javax/media/nativewindow/Capabilities.java
index cb33aec5e..50e6ed46c 100644
--- a/src/nativewindow/classes/javax/media/nativewindow/Capabilities.java
+++ b/src/nativewindow/classes/javax/media/nativewindow/Capabilities.java
@@ -61,6 +61,9 @@ public class Capabilities implements CapabilitiesImmutable, Cloneable {
 
   // Switch for on- or offscreen
   private boolean onscreen  = true;
+  
+  // offscreen bitmap mode
+  private boolean isBitmap  = false;
 
   /** Creates a Capabilities object. All attributes are in a default
       state.
@@ -85,6 +88,8 @@ public class Capabilities implements CapabilitiesImmutable, Cloneable {
   public int hashCode() {
     // 31 * x == (x << 5) - x
     int hash = 31 + this.redBits;
+    hash = ((hash << 5) - hash) + ( this.onscreen ? 1 : 0 );
+    hash = ((hash << 5) - hash) + ( this.isBitmap ? 1 : 0 );
     hash = ((hash << 5) - hash) + this.greenBits;
     hash = ((hash << 5) - hash) + this.blueBits;
     hash = ((hash << 5) - hash) + this.alphaBits;
@@ -93,7 +98,6 @@ public class Capabilities implements CapabilitiesImmutable, Cloneable {
     hash = ((hash << 5) - hash) + this.transparentValueGreen;
     hash = ((hash << 5) - hash) + this.transparentValueBlue;
     hash = ((hash << 5) - hash) + this.transparentValueAlpha;
-    hash = ((hash << 5) - hash) + ( this.onscreen ? 1 : 0 );
     return hash;
   }
 
@@ -109,12 +113,13 @@ public class Capabilities implements CapabilitiesImmutable, Cloneable {
                   other.getBlueBits()==blueBits &&
                   other.getAlphaBits()==alphaBits &&
                   other.isBackgroundOpaque()==backgroundOpaque &&
-                  other.isOnscreen()==onscreen;
-    if(!backgroundOpaque) {
-     res = res && other.getTransparentRedValue()==transparentValueRed &&
-                  other.getTransparentGreenValue()==transparentValueGreen &&
-                  other.getTransparentBlueValue()==transparentValueBlue &&
-                  other.getTransparentAlphaValue()==transparentValueAlpha;
+                  other.isOnscreen()==onscreen &&
+                  other.isBitmap()==isBitmap;
+    if(res && !backgroundOpaque) {
+     res = other.getTransparentRedValue()==transparentValueRed &&
+           other.getTransparentGreenValue()==transparentValueGreen &&
+           other.getTransparentBlueValue()==transparentValueBlue &&
+           other.getTransparentAlphaValue()==transparentValueAlpha;
     }
 
     return res;
@@ -158,9 +163,6 @@ public class Capabilities implements CapabilitiesImmutable, Cloneable {
       }
   }
 
-  /** Returns the number of bits requested for the color buffer's red
-      component. On some systems only the color depth, which is the
-      sum of the red, green, and blue bits, is considered. */
   @Override
   public final int getRedBits() {
     return redBits;
@@ -173,9 +175,6 @@ public class Capabilities implements CapabilitiesImmutable, Cloneable {
     this.redBits = redBits;
   }
 
-  /** Returns the number of bits requested for the color buffer's
-      green component. On some systems only the color depth, which is
-      the sum of the red, green, and blue bits, is considered. */
   @Override
   public final int getGreenBits() {
     return greenBits;
@@ -188,9 +187,6 @@ public class Capabilities implements CapabilitiesImmutable, Cloneable {
     this.greenBits = greenBits;
   }
 
-  /** Returns the number of bits requested for the color buffer's blue
-      component. On some systems only the color depth, which is the
-      sum of the red, green, and blue bits, is considered. */
   @Override
   public final int getBlueBits() {
     return blueBits;
@@ -203,9 +199,6 @@ public class Capabilities implements CapabilitiesImmutable, Cloneable {
     this.blueBits = blueBits;
   }
 
-  /** Returns the number of bits requested for the color buffer's
-      alpha component. On some systems only the color depth, which is
-      the sum of the red, green, and blue bits, is considered. */
   @Override
   public final int getAlphaBits() {
     return alphaBits;
@@ -228,10 +221,7 @@ public class Capabilities implements CapabilitiesImmutable, Cloneable {
   }
 
   /**
-   * Defaults to true, ie. opaque surface.
-   * <p>
-   * On supported platforms, setting opaque to false may result in a translucent surface. </p>
-   *
+   * Sets whether the surface shall be opaque or translucent.
    * <p>
    * Platform implementations may need an alpha component in the surface (eg. Windows),
    * or expect pre-multiplied alpha values (eg. X11/XRender).<br>
@@ -240,16 +230,9 @@ public class Capabilities implements CapabilitiesImmutable, Cloneable {
    * Please note that in case alpha is required on the platform the
    * clear color shall have an alpha lower than 1.0 to allow anything shining through.
    * </p>
-   *
    * <p>
    * Mind that translucency may cause a performance penalty
-   * due to the composite work required by the window manager.</p>
-   *
-   * <p>
-   * The platform implementation may utilize the transparency RGBA values.<br>
-   * This is true for the original GLX transparency specification, which is no more used today.<br>
-   * Actually these values are currently not used by any implementation,
-   * so we may mark them deprecated soon, if this doesn't change.<br>
+   * due to the composite work required by the window manager.
    * </p>
    */
   public void setBackgroundOpaque(boolean opaque) {
@@ -259,56 +242,65 @@ public class Capabilities implements CapabilitiesImmutable, Cloneable {
       }
   }
 
-  /** Indicates whether the background of this OpenGL context should
-      be considered opaque. Defaults to true.
-
-      @see #setBackgroundOpaque
-  */
   @Override
   public final boolean isBackgroundOpaque() {
     return backgroundOpaque;
   }
 
-  /** Sets whether the drawable surface supports onscreen.
-      Defaults to true.
-  */
+  /**
+   * Sets whether the surface shall be on- or offscreen.
+   * <p>
+   * Defaults to true.
+   * </p>
+   * <p>
+   * If requesting an offscreen surface without further selection of it's mode, 
+   * e.g. FBO, Pbuffer or {@link #setBitmap(boolean) bitmap},
+   * the implementation will choose the best available offscreen mode.
+   * </p>
+   * @param onscreen
+   */
   public void setOnscreen(boolean onscreen) {
     this.onscreen=onscreen;
   }
 
-  /** Indicates whether the drawable surface is onscreen.
-      Defaults to true.
-  */
   @Override
   public final boolean isOnscreen() {
     return onscreen;
   }
 
-  /** Gets the transparent red value for the frame buffer configuration.
-    * This value is undefined if {@link #isBackgroundOpaque()} equals true.
-    * @see #setTransparentRedValue
-    */
+  /**
+   * Requesting offscreen bitmap mode.
+   * <p>
+   * If enabled this method also invokes {@link #setOnscreen(int) setOnscreen(false)}.
+   * </p>
+   * <p>
+   * Defaults to false.
+   * </p>
+   * <p>
+   * Requesting offscreen bitmap mode disables the offscreen auto selection.
+   * </p>
+   */
+  public void setBitmap(boolean enable) {
+    if(enable) {
+      setOnscreen(false);
+    }
+    isBitmap = enable;
+  }
+  
+  @Override
+  public boolean isBitmap() {
+    return isBitmap;      
+  }
+  
   @Override
   public final int getTransparentRedValue() { return transparentValueRed; }
 
-  /** Gets the transparent green value for the frame buffer configuration.
-    * This value is undefined if {@link #isBackgroundOpaque()} equals true.
-    * @see #setTransparentGreenValue
-    */
   @Override
   public final int getTransparentGreenValue() { return transparentValueGreen; }
 
-  /** Gets the transparent blue value for the frame buffer configuration.
-    * This value is undefined if {@link #isBackgroundOpaque()} equals true.
-    * @see #setTransparentBlueValue
-    */
   @Override
   public final int getTransparentBlueValue() { return transparentValueBlue; }
 
-  /** Gets the transparent alpha value for the frame buffer configuration.
-    * This value is undefined if {@link #isBackgroundOpaque()} equals true.
-    * @see #setTransparentAlphaValue
-    */
   @Override
   public final int getTransparentAlphaValue() { return transparentValueAlpha; }
 
@@ -342,32 +334,58 @@ public class Capabilities implements CapabilitiesImmutable, Cloneable {
 
   @Override
   public StringBuilder toString(StringBuilder sink) {
+      return toString(sink, true);
+  }
+  
+  /** Returns a textual representation of this Capabilities
+      object. */
+  @Override
+  public String toString() {
+    StringBuilder msg = new StringBuilder();
+    msg.append("Caps[");
+    toString(msg);
+    msg.append("]");
+    return msg.toString();
+  }
+  
+  /** Return a textual representation of this object's on/off screen state. Use the given StringBuffer [optional]. */
+  protected StringBuilder onoffScreenToString(StringBuilder sink) {
     if(null == sink) {
         sink = new StringBuilder();
     }
     if(onscreen) {
         sink.append("on-scr");
     } else {
-        sink.append("offscr");
+        sink.append("offscr[");
+    }
+    if(isBitmap) {
+        sink.append("bitmap");
+    } else if(onscreen) {
+        sink.append(".");        // no additional off-screen modes besides on-screen
+    } else {
+        sink.append("auto-cfg"); // auto-config off-screen mode            
+    }
+    sink.append("]");    
+    
+    return sink;
+  }
+  
+  protected StringBuilder toString(StringBuilder sink, boolean withOnOffScreen) {  
+    if(null == sink) {
+        sink = new StringBuilder();
     }
-    sink.append(", rgba 0x").append(toHexString(redBits)).append("/").append(toHexString(greenBits)).append("/").append(toHexString(blueBits)).append("/").append(toHexString(alphaBits));
+    sink.append("rgba 0x").append(toHexString(redBits)).append("/").append(toHexString(greenBits)).append("/").append(toHexString(blueBits)).append("/").append(toHexString(alphaBits));
     if(backgroundOpaque) {
         sink.append(", opaque");
     } else {
         sink.append(", trans-rgba 0x").append(toHexString(transparentValueRed)).append("/").append(toHexString(transparentValueGreen)).append("/").append(toHexString(transparentValueBlue)).append("/").append(toHexString(transparentValueAlpha));
     }
+    if(withOnOffScreen) {
+        sink.append(", ");
+        onoffScreenToString(sink);
+    }
     return sink;
   }
+  
   protected final String toHexString(int val) { return Integer.toHexString(val); }
-
-  /** Returns a textual representation of this Capabilities
-      object. */
-  @Override
-  public String toString() {
-    StringBuilder msg = new StringBuilder();
-    msg.append("Caps[");
-    toString(msg);
-    msg.append("]");
-    return msg.toString();
-  }
 }
diff --git a/src/nativewindow/classes/javax/media/nativewindow/CapabilitiesImmutable.java b/src/nativewindow/classes/javax/media/nativewindow/CapabilitiesImmutable.java
index b984a4626..b801ab457 100644
--- a/src/nativewindow/classes/javax/media/nativewindow/CapabilitiesImmutable.java
+++ b/src/nativewindow/classes/javax/media/nativewindow/CapabilitiesImmutable.java
@@ -39,45 +39,66 @@ import com.jogamp.common.type.WriteCloneable;
 public interface CapabilitiesImmutable extends VisualIDHolder, WriteCloneable, Comparable<CapabilitiesImmutable> {
 
     /**
-     * Returns the number of bits requested for the color buffer's red
+     * Returns the number of bits for the color buffer's red
      * component. On some systems only the color depth, which is the sum of the
      * red, green, and blue bits, is considered.
      */
     int getRedBits();
 
     /**
-     * Returns the number of bits requested for the color buffer's green
+     * Returns the number of bits for the color buffer's green
      * component. On some systems only the color depth, which is the sum of the
      * red, green, and blue bits, is considered.
      */
     int getGreenBits();
 
     /**
-     * Returns the number of bits requested for the color buffer's blue
+     * Returns the number of bits for the color buffer's blue
      * component. On some systems only the color depth, which is the sum of the
      * red, green, and blue bits, is considered.
      */
     int getBlueBits();
 
     /**
-     * Returns the number of bits requested for the color buffer's alpha
+     * Returns the number of bits for the color buffer's alpha
      * component. On some systems only the color depth, which is the sum of the
      * red, green, and blue bits, is considered.
      */
     int getAlphaBits();
 
     /**
-     * Indicates whether the background of this OpenGL context should be
-     * considered opaque. Defaults to true.
+     * Returns whether an opaque or translucent surface is requested, supported or chosen.
+     * <p>
+     * Default is true, i.e. opaque.
+     * </p> 
      */
     boolean isBackgroundOpaque();
 
     /**
-     * Indicates whether the drawable surface is onscreen. Defaults to true.
+     * Returns whether an on- or offscreen surface is requested, available or chosen. 
+     * <p>
+     * Default is true, i.e. onscreen.
+     * </p>
+     * <p>
+     * Mind that an capabilities intance w/ <i>available</i> semantics
+     * may show onscreen, but also the offscreen modes FBO, Pbuffer or {@link #setBitmap(boolean) bitmap}.
+     * This is valid, since one native configuration maybe used for either functionality.
+     * </p> 
      */
     boolean isOnscreen();
 
     /**
+     * Returns whether bitmap offscreen mode is requested, available or chosen.
+     * <p>
+     * Default is false.
+     * </p>
+     * <p>
+     * For chosen capabilities, only the selected offscreen surface is set to <code>true</code>.
+     * </p>
+     */
+    boolean isBitmap();
+    
+    /**
      * Gets the transparent red value for the frame buffer configuration. This
      * value is undefined if; equals true.
      */
diff --git a/src/nativewindow/classes/javax/media/nativewindow/DefaultCapabilitiesChooser.java b/src/nativewindow/classes/javax/media/nativewindow/DefaultCapabilitiesChooser.java
index 9d4b112b1..744c7e6d5 100644
--- a/src/nativewindow/classes/javax/media/nativewindow/DefaultCapabilitiesChooser.java
+++ b/src/nativewindow/classes/javax/media/nativewindow/DefaultCapabilitiesChooser.java
@@ -68,6 +68,9 @@ import jogamp.nativewindow.Debug;
 public class DefaultCapabilitiesChooser implements CapabilitiesChooser {
   private static final boolean DEBUG = Debug.isPropertyDefined("nativewindow.debug.CapabilitiesChooser", true); 
 
+  private final static int NO_SCORE = -9999999;
+  private final static int COLOR_MISMATCH_PENALTY_SCALE     = 36;
+  
   public int chooseCapabilities(final CapabilitiesImmutable desired,
                                 final List<? extends CapabilitiesImmutable> available,
                                 final int windowSystemRecommendedChoice) {
@@ -92,8 +95,6 @@ public class DefaultCapabilitiesChooser implements CapabilitiesChooser {
 
     // Create score array
     int[] scores = new int[availnum];
-    int NO_SCORE = -9999999;
-    int COLOR_MISMATCH_PENALTY_SCALE     = 36;
     for (int i = 0; i < availnum; i++) {
       scores[i] = NO_SCORE;
     }
@@ -103,6 +104,10 @@ public class DefaultCapabilitiesChooser implements CapabilitiesChooser {
       if (cur == null) {
         continue;
       }
+      if (desired.isOnscreen() && !cur.isOnscreen()) {
+        continue; // requested onscreen, but n/a
+      }
+      
       int score = 0;
       // Compute difference in color depth
       score += (COLOR_MISMATCH_PENALTY_SCALE *
diff --git a/src/test/com/jogamp/opengl/test/junit/jogl/acore/TestGLCapabilities01NEWT.java b/src/test/com/jogamp/opengl/test/junit/jogl/acore/TestGLCapabilities01NEWT.java
new file mode 100644
index 000000000..0782e8915
--- /dev/null
+++ b/src/test/com/jogamp/opengl/test/junit/jogl/acore/TestGLCapabilities01NEWT.java
@@ -0,0 +1,233 @@
+/**
+ * Copyright 2010 JogAmp Community. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification, are
+ * permitted provided that the following conditions are met:
+ * 
+ *    1. Redistributions of source code must retain the above copyright notice, this list of
+ *       conditions and the following disclaimer.
+ * 
+ *    2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *       of conditions and the following disclaimer in the documentation and/or other materials
+ *       provided with the distribution.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ * The views and conclusions contained in the software and documentation are those of the
+ * authors and should not be interpreted as representing official policies, either expressed
+ * or implied, of JogAmp Community.
+ */
+ 
+package com.jogamp.opengl.test.junit.jogl.acore;
+
+import java.io.IOException;
+
+import javax.media.nativewindow.CapabilitiesImmutable;
+import javax.media.opengl.GLCapabilities;
+import javax.media.opengl.GLCapabilitiesImmutable;
+import javax.media.opengl.GLContext;
+import javax.media.opengl.GLDrawable;
+import javax.media.opengl.GLDrawableFactory;
+import javax.media.opengl.GLEventListener;
+import javax.media.opengl.GLProfile;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import com.jogamp.newt.NewtFactory;
+import com.jogamp.newt.Window;
+import com.jogamp.opengl.JoglVersion;
+import com.jogamp.opengl.test.junit.jogl.demos.es2.GearsES2;
+import com.jogamp.opengl.test.junit.util.AWTRobotUtil;
+import com.jogamp.opengl.test.junit.util.UITestCase;
+
+public class TestGLCapabilities01NEWT extends UITestCase {
+    static final int width = 100;
+    static final int height = 100;
+
+    boolean checkProfile(String profile) {
+        if( !GLProfile.isAvailable(profile) )  {
+            System.err.println("Profile "+profile+" n/a");
+            return false;
+        }
+        return true;
+    }
+    
+    void doTest(GLCapabilities reqGLCaps, GLEventListener demo) throws InterruptedException {
+        System.out.println("Requested  GL Caps: "+reqGLCaps);
+
+        //
+        // Create native windowing resources .. X11/Win/OSX
+        // 
+        final Window window = NewtFactory.createWindow(reqGLCaps);
+        Assert.assertNotNull(window);
+        window.setSize(width, height);
+        window.setVisible(true);
+        Assert.assertTrue(AWTRobotUtil.waitForVisible(window, true));
+        Assert.assertTrue(AWTRobotUtil.waitForRealized(window, true));
+        System.out.println("Window: "+window.getClass().getName());
+        
+        // Check caps of NativeWindow config w/o GL
+        final CapabilitiesImmutable chosenCaps = window.getGraphicsConfiguration().getChosenCapabilities();
+        System.out.println("Window Caps Pre_GL: "+chosenCaps);
+        Assert.assertNotNull(chosenCaps);
+        Assert.assertTrue(chosenCaps.getGreenBits()>5);
+        Assert.assertTrue(chosenCaps.getBlueBits()>5);
+        Assert.assertTrue(chosenCaps.getRedBits()>5);
+
+        //
+        // Create native OpenGL resources .. XGL/WGL/CGL .. 
+        // equivalent to GLAutoDrawable methods: setVisible(true)
+        // 
+        final GLDrawableFactory factory = GLDrawableFactory.getFactory(reqGLCaps.getGLProfile());
+        
+        final GLDrawable drawable = factory.createGLDrawable(window);
+        Assert.assertNotNull(drawable);
+        System.out.println("Drawable    Pre-GL(0): "+drawable.getClass().getName()+", "+drawable.getNativeSurface().getClass().getName());
+        
+        //
+        drawable.setRealized(true);
+        Assert.assertTrue(drawable.isRealized());
+
+        System.out.println("Window Caps PostGL   : "+window.getGraphicsConfiguration().getChosenCapabilities());
+        System.out.println("Drawable   Post-GL(1): "+drawable.getClass().getName()+", "+drawable.getNativeSurface().getClass().getName());
+        
+        // Check caps of GLDrawable after realization
+        final GLCapabilitiesImmutable chosenGLCaps = drawable.getChosenGLCapabilities();
+        System.out.println("Chosen     GL Caps(1): "+chosenGLCaps);
+        Assert.assertNotNull(chosenGLCaps);
+        Assert.assertTrue(chosenGLCaps.getGreenBits()>5);
+        Assert.assertTrue(chosenGLCaps.getBlueBits()>5);
+        Assert.assertTrue(chosenGLCaps.getRedBits()>5);
+        Assert.assertTrue(chosenGLCaps.getDepthBits()>4);
+        Assert.assertEquals(reqGLCaps.isOnscreen(), chosenGLCaps.isOnscreen());
+        Assert.assertEquals(reqGLCaps.isFBO(), chosenGLCaps.isFBO());
+        Assert.assertEquals(reqGLCaps.isPBuffer(), chosenGLCaps.isPBuffer());
+        Assert.assertEquals(reqGLCaps.isBitmap(), chosenGLCaps.isBitmap());
+        if(chosenGLCaps.isOnscreen() || chosenGLCaps.isFBO()) {
+            // dbl buffer may be disabled w/ offscreen pbuffer and bitmap
+            Assert.assertEquals(reqGLCaps.getDoubleBuffered(), chosenGLCaps.getDoubleBuffered());
+        }
+
+        GLContext context = drawable.createContext(null);
+        Assert.assertNotNull(context);
+        int res = context.makeCurrent();
+        Assert.assertTrue(GLContext.CONTEXT_CURRENT_NEW==res || GLContext.CONTEXT_CURRENT==res);
+        context.release();
+        
+        System.out.println("Chosen     GL Caps(2): "+drawable.getChosenGLCapabilities());
+        System.out.println("Drawable   Post-GL(2): "+drawable.getClass().getName()+", "+drawable.getNativeSurface().getClass().getName());
+        
+        drawable.setRealized(false);
+        window.destroy();
+    }
+
+    @Test
+    public void testAvailableInfo() {
+        GLDrawableFactory f = GLDrawableFactory.getDesktopFactory();
+        if(null != f) {
+            System.err.println(JoglVersion.getDefaultOpenGLInfo(f.getDefaultDevice(), null, true).toString());
+        }
+        f = GLDrawableFactory.getEGLFactory();
+        if(null != f) {
+            System.err.println(JoglVersion.getDefaultOpenGLInfo(f.getDefaultDevice(), null, true).toString());
+        }
+    }
+    
+    //@Test
+    public void testGL2OffScreenAutoDblBuf() throws InterruptedException {
+        if(!checkProfile(GLProfile.GL2)) {
+            return;
+        }
+        final GLCapabilities reqGLCaps = new GLCapabilities(GLProfile.get(GLProfile.GL2));        
+        reqGLCaps.setOnscreen(false);
+        doTest(reqGLCaps, new GearsES2(1));
+    }
+
+    // @Test
+    public void testGL2OffScreenFBODblBuf() throws InterruptedException {
+        if(!checkProfile(GLProfile.GL2)) {
+            return;
+        }
+        final GLCapabilities reqGLCaps = new GLCapabilities(GLProfile.get(GLProfile.GL2));        
+        reqGLCaps.setOnscreen(false);
+        reqGLCaps.setFBO(true);
+        doTest(reqGLCaps, new GearsES2(1));
+    }
+    
+    @Test
+    public void testGL2OnScreenDblBuf() throws InterruptedException {
+        if(!checkProfile(GLProfile.GL2)) {
+            return;
+        }
+        final GLCapabilities reqGLCaps = new GLCapabilities(GLProfile.get(GLProfile.GL2));        
+        doTest(reqGLCaps, new GearsES2(1));
+    }
+    
+    @Test
+    public void testGL2OffScreenPbufferDblBuf() throws InterruptedException {
+        if(!checkProfile(GLProfile.GL2)) {
+            return;
+        }
+        final GLCapabilities reqGLCaps = new GLCapabilities(GLProfile.get(GLProfile.GL2));        
+        reqGLCaps.setOnscreen(false);
+        reqGLCaps.setPBuffer(true);
+        doTest(reqGLCaps, new GearsES2(1));
+    }
+    
+    @Test
+    public void testGL2OffScreenBitmapDblBuf() throws InterruptedException {
+        if(!checkProfile(GLProfile.GL2)) {
+            return;
+        }
+        final GLCapabilities reqGLCaps = new GLCapabilities(GLProfile.get(GLProfile.GL2));        
+        reqGLCaps.setOnscreen(false);
+        reqGLCaps.setBitmap(true);
+        doTest(reqGLCaps, new GearsES2(1));
+    }
+    
+    @Test
+    public void testES2OnScreenDblBuf() throws InterruptedException {
+        if(!checkProfile(GLProfile.GLES2)) {
+            return;
+        }
+        final GLCapabilities reqGLCaps = new GLCapabilities(GLProfile.get(GLProfile.GLES2));        
+        doTest(reqGLCaps, new GearsES2(1));
+    }
+    
+    @Test
+    public void testES2OffScreenPbufferDblBuf() throws InterruptedException {
+        if(!checkProfile(GLProfile.GLES2)) {
+            return;
+        }
+        final GLCapabilities reqGLCaps = new GLCapabilities(GLProfile.get(GLProfile.GLES2));        
+        reqGLCaps.setOnscreen(false);
+        reqGLCaps.setPBuffer(true);
+        doTest(reqGLCaps, new GearsES2(1));
+    }
+    
+    /** Not implemented !
+    @Test
+    public void testES2OffScreenBitmapDblBuf() throws InterruptedException {
+        if(!checkProfile(GLProfile.GLES2)) {
+            return;
+        }
+        final GLCapabilities reqGLCaps = new GLCapabilities(GLProfile.get(GLProfile.GLES2));        
+        reqGLCaps.setOnscreen(false);
+        reqGLCaps.setBitmap(true);
+        doTest(reqGLCaps, new GearsES2(1));
+    } */
+    
+    public static void main(String args[]) throws IOException {
+        org.junit.runner.JUnitCore.main(TestGLCapabilities01NEWT.class.getName());
+    }
+
+}
diff --git a/src/test/com/jogamp/opengl/test/junit/util/AWTRobotUtil.java b/src/test/com/jogamp/opengl/test/junit/util/AWTRobotUtil.java
index 35a2d9669..9e96db5e1 100644
--- a/src/test/com/jogamp/opengl/test/junit/util/AWTRobotUtil.java
+++ b/src/test/com/jogamp/opengl/test/junit/util/AWTRobotUtil.java
@@ -38,6 +38,7 @@ import java.awt.Robot;
 import java.awt.Toolkit;
 
 import javax.media.nativewindow.NativeWindow;
+import javax.media.opengl.GLDrawable;
 import javax.media.opengl.awt.GLCanvas;
 
 import org.junit.Assert;
@@ -496,6 +497,18 @@ public class AWTRobotUtil {
 
     /**
      *
+     * @return True if the GLDrawable recives the expected size within TIME_OUT
+     */
+    public static boolean waitForSize(GLDrawable drawable, int width, int height) throws InterruptedException {
+        int wait;
+        for (wait=0; wait<POLL_DIVIDER && ( width != drawable.getWidth() || height != drawable.getHeight() ) ; wait++) {
+            Thread.sleep(TIME_SLICE);
+        }
+        return wait<POLL_DIVIDER;
+    }
+
+    /**
+     *
      * @return True if the Component becomes realized (not displayable, native invalid) within TIME_OUT
      */
     public static boolean waitForRealized(Object obj, boolean realized) throws InterruptedException {