Fix window mode attribute bit FBO_BIT usage in platform dependent code (map it to native type) ; OSX Caps selection ; WGL/GDI BITMAP fix

Fix window mode attribute bit FBO_BIT usage in platform dependent code (map it to native type)
  All platform dependent winAttrBit mapping: 'nativeType -> winAttrBit' and 'GLCapabilities -> winAttrBits'
  shall replace FBO_BIT w/ the native type of the wrapper surface, i.e. WINDOW_BIT (X11, WGL, CGL) or PBUFFER_BIT (EGL).
  This condenses to changes in
    - EGLGraphicsConfiguration: EGLConfigDrawableTypeBits / GLCapabilities2AttribList

    - X11GLXGraphicsConfiguration: FBCfgDrawableTypeBits, XVisualInfo2GLCapabilities / GLCapabilities2AttribList

    - WindowsWGLGraphicsConfiguration: AttribList2DrawableTypeBits, PFD2DrawableTypeBits / GLCapabilities2AttribList

    - OSX CGL/NS requires changes in MacOSXCGLContext, i.e. fix the surface mode of
      NSPixelFormat2GLCapabilities, CGLPixelFormat2GLCapabilities results.
      This change is included in the upcoming commit (class is heavily edited).

OSX chooseGraphicsConfigurationStatic: Add missing 'GLGraphicsConfigurationUtil.fixGLCapabilities(..)' call
  - all platform impl. require to fix the given user caps due to the new offscreen auto selection mode

WindowsWGLGraphicsConfiguration*: ARB / GDI updateGraphicsConfiguration*()
  - ARB method detects early whether it's suitable for given HDC, i.e. in case of BITMAP (it's not here)
  - GDI methods detect failure while choosing PFD and doesn't care of DOUBLEBUFFER in case of bitmap (fixes BITMAP usage)

Capabilities/GLCapabilities:
  - Fix missing double-buffer check in GLCapabilities.equals()
  - add 'copyFrom(..)' method copy all data from give caps

10 files changed, 372 insertions, 219 deletions

diff --git a/src/jogl/classes/javax/media/opengl/GLCapabilities.java b/src/jogl/classes/javax/media/opengl/GLCapabilities.java
index 30a6215e7..9b004a0af 100644
--- a/src/jogl/classes/javax/media/opengl/GLCapabilities.java
+++ b/src/jogl/classes/javax/media/opengl/GLCapabilities.java
@@ -102,6 +102,34 @@ public class GLCapabilities extends Capabilities implements Cloneable, GLCapabil
     }
   }
 
+  /**
+   * Copies all {@link GLCapabilities} and {@link Capabilities} values 
+   * from <code>source</code> into this instance.
+   * @return this instance
+   */
+  public GLCapabilities copyFrom(GLCapabilitiesImmutable source) {
+    super.copyFrom(source);
+    glProfile = source.getGLProfile();
+    isPBuffer = source.isPBuffer();
+    isFBO = source.isFBO();
+    doubleBuffered = source.getDoubleBuffered();
+    stereo = source.getStereo();
+    hardwareAccelerated = source.getHardwareAccelerated();
+    depthBits = source.getDepthBits();
+    stencilBits = source.getStencilBits();
+    accumRedBits = source.getAccumRedBits();
+    accumGreenBits = source.getAccumGreenBits();
+    accumBlueBits = source.getAccumBlueBits();
+    accumAlphaBits = source.getAccumAlphaBits();
+    sampleBuffers = source.getSampleBuffers();
+    pbufferFloatingPointBuffers = source.getPbufferFloatingPointBuffers();
+    pbufferRenderToTexture = source.getPbufferRenderToTexture();
+    pbufferRenderToTextureRectangle = source.getPbufferRenderToTextureRectangle();
+    numSamples = source.getNumSamples();
+    sampleExtension = source.getSampleExtension();
+    return this;
+  }
+  
   @Override
   public int hashCode() {
     // 31 * x == (x << 5) - x
@@ -137,6 +165,7 @@ public class GLCapabilities extends Capabilities implements Cloneable, GLCapabil
                   other.getGLProfile()==glProfile &&
                   other.isPBuffer()==isPBuffer &&
                   other.isFBO()==isFBO &&
+                  other.getDoubleBuffered() == doubleBuffered &&
                   other.getStereo()==stereo &&
                   other.getHardwareAccelerated()==hardwareAccelerated &&
                   other.getDepthBits()==depthBits &&
diff --git a/src/jogl/classes/jogamp/opengl/GLGraphicsConfigurationUtil.java b/src/jogl/classes/jogamp/opengl/GLGraphicsConfigurationUtil.java
index d8e5ba31a..768fc6892 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 javax.media.opengl.GLCapabilities;
 import javax.media.opengl.GLCapabilitiesImmutable;
 
@@ -37,7 +36,7 @@ public class GLGraphicsConfigurationUtil {
     public static final int WINDOW_BIT  = 1 << 0;
     public static final int BITMAP_BIT  = 1 << 1;
     public static final int PBUFFER_BIT = 1 << 2;
-    public static final int FBO_BIT     = 1 << 3;
+    public static final int FBO_BIT     = 1 << 3; // generic bit must be mapped to native one at impl. level
     public static final int ALL_BITS    = WINDOW_BIT | BITMAP_BIT | PBUFFER_BIT | FBO_BIT ;
 
     public static final StringBuilder winAttributeBits2String(StringBuilder sb, int winattrbits) {
@@ -161,7 +160,7 @@ public class GLGraphicsConfigurationUtil {
         
         final boolean useFBO     =                fboAvailable     && ( auto || capsRequested.isFBO()     ) ;
         final boolean usePbuffer = !useFBO     && pbufferAvailable && ( auto || capsRequested.isPBuffer() ) ;
-        final boolean useBitmap  = !usePbuffer                     && ( auto || capsRequested.isBitmap()  ) ;
+        final boolean useBitmap  = !useFBO     && !usePbuffer      && ( auto || capsRequested.isBitmap()  ) ;
         
         if( capsRequested.isOnscreen() ||
             useFBO != capsRequested.isFBO() || 
diff --git a/src/jogl/classes/jogamp/opengl/egl/EGLGraphicsConfiguration.java b/src/jogl/classes/jogamp/opengl/egl/EGLGraphicsConfiguration.java
index 135101ff2..8ee98072f 100644
--- a/src/jogl/classes/jogamp/opengl/egl/EGLGraphicsConfiguration.java
+++ b/src/jogl/classes/jogamp/opengl/egl/EGLGraphicsConfiguration.java
@@ -46,7 +46,6 @@ 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;
 
@@ -129,12 +128,28 @@ public class EGLGraphicsConfiguration extends MutableGraphicsConfiguration imple
         return configs.get(0);
     }
 
-    static int EGLConfigDrawableTypeBits(final EGLGraphicsDevice device, final GLProfile glp, final long config) {
+    public static boolean isEGLConfigValid(long display, long config) {
+        if(0 == config) {
+            return false;
+        }
+        final IntBuffer val = Buffers.newDirectIntBuffer(1);
+        
+        // get the configID
+        if(!EGL.eglGetConfigAttrib(display, config, EGL.EGL_CONFIG_ID, val)) {
+            final int eglErr = EGL.eglGetError();
+            if(DEBUG) {
+                System.err.println("Info: Couldn't retrieve EGL ConfigID for config "+toHexString(config)+", error "+toHexString(eglErr));
+            }
+            return false;
+        }
+        return true;
+    }
+
+    static int EGLConfigDrawableTypeBits(final EGLGraphicsDevice device, 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)) {
+        if(! EGL.eglGetConfigAttrib(device.getHandle(), config, EGL.EGL_SURFACE_TYPE, stype, 0)) {
             throw new GLException("Could not determine EGL_SURFACE_TYPE");
         }
 
@@ -145,12 +160,9 @@ public class EGLGraphicsConfiguration extends MutableGraphicsConfiguration imple
             val |= GLGraphicsConfigurationUtil.BITMAP_BIT;
         }
         if ( 0 != ( stype[0] & EGL.EGL_PBUFFER_BIT ) ) {
-            val |= GLGraphicsConfigurationUtil.PBUFFER_BIT;
-        }
-        if ( GLContext.isFBOAvailable(device, glp) ) {
-            val |= GLGraphicsConfigurationUtil.FBO_BIT;
+            val |= GLGraphicsConfigurationUtil.PBUFFER_BIT |
+                   GLGraphicsConfigurationUtil.FBO_BIT;     
         }
-
         return val;
     }
 
@@ -269,8 +281,8 @@ public class EGLGraphicsConfiguration extends MutableGraphicsConfiguration imple
 
         // 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;
+        final int availableTypeBits = EGLConfigDrawableTypeBits(device, config);        
+        final int drawableTypeBits = winattrmask & availableTypeBits;
 
         if( 0 == drawableTypeBits ) {
             return null;
@@ -284,7 +296,19 @@ public class EGLGraphicsConfiguration extends MutableGraphicsConfiguration imple
         int idx=0;
 
         attrs[idx++] = EGL.EGL_SURFACE_TYPE;
-        attrs[idx++] = caps.isOnscreen() ? ( EGL.EGL_WINDOW_BIT ) : ( caps.isPBuffer() ? EGL.EGL_PBUFFER_BIT : EGL.EGL_PIXMAP_BIT ) ;
+        final int surfaceType;
+        if( caps.isOnscreen() ) {
+            surfaceType = EGL.EGL_WINDOW_BIT;            
+        } else if( caps.isFBO() ) {
+            surfaceType = EGL.EGL_PBUFFER_BIT;  // native replacement!
+        } else if( caps.isPBuffer() ) {
+            surfaceType = EGL.EGL_PBUFFER_BIT;
+        } else if( caps.isBitmap() ) {
+            surfaceType = EGL.EGL_PIXMAP_BIT;
+        } else {
+            throw new GLException("no surface type set in caps: "+caps);
+        }
+        attrs[idx++] = surfaceType;
 
         attrs[idx++] = EGL.EGL_RED_SIZE;
         attrs[idx++] = caps.getRedBits();
diff --git a/src/jogl/classes/jogamp/opengl/egl/EGLGraphicsConfigurationFactory.java b/src/jogl/classes/jogamp/opengl/egl/EGLGraphicsConfigurationFactory.java
index d08685dcb..e72255108 100644
--- a/src/jogl/classes/jogamp/opengl/egl/EGLGraphicsConfigurationFactory.java
+++ b/src/jogl/classes/jogamp/opengl/egl/EGLGraphicsConfigurationFactory.java
@@ -324,6 +324,7 @@ public class EGLGraphicsConfigurationFactory extends GLGraphicsConfigurationFact
         return res;
     }
 
+    
     static EGLGraphicsConfiguration eglChooseConfig(EGLGraphicsDevice device, 
                                                     GLCapabilitiesImmutable capsChosen, GLCapabilitiesImmutable capsRequested,
                                                     GLCapabilitiesChooser chooser,
@@ -344,7 +345,12 @@ 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)+", "+capsChosen+", numConfigs "+numConfigs.get(0));
+            System.err.println("EGLGraphicsConfiguration.eglChooseConfig: eglChooseConfig eglDisplay "+toHexString(eglDisplay)+
+                               ", nativeVisualID "+toHexString(nativeVisualID)+
+                               ", capsChosen "+capsChosen+", winbits "+GLGraphicsConfigurationUtil.winAttributeBits2String(null, winattrmask).toString()+
+                               ", fboAvail "+GLContext.isFBOAvailable(device, glp)+
+                               ", device "+device+", "+device.getUniqueID()+
+                               ", numConfigs "+numConfigs.get(0));
         }
 
         final IntBuffer attrs = Buffers.newDirectIntBuffer(EGLGraphicsConfiguration.GLCapabilities2AttribList(capsChosen));
@@ -432,10 +438,11 @@ public class EGLGraphicsConfigurationFactory extends GLGraphicsConfigurationFact
             return null;
         }
         final EGLGLCapabilities chosenCaps = (EGLGLCapabilities) availableCaps.get(chosenIndex);
+        final EGLGraphicsConfiguration res = new EGLGraphicsConfiguration(absScreen, chosenCaps, capsRequested, chooser);
         if (DEBUG) {
-            System.err.println("EGLGraphicsConfiguration.eglChooseConfig: X chosen :"+chosenIndex+", eglConfig: "+toHexString(chosenCaps.getEGLConfig())+", "+chosenCaps);
+            System.err.println("EGLGraphicsConfiguration.eglChooseConfig: X chosen :"+chosenIndex+", eglConfig: "+toHexString(chosenCaps.getEGLConfig())+": "+res);
         }
-        return new EGLGraphicsConfiguration(absScreen, chosenCaps, capsRequested, chooser);
+        return res;
     }
 
     static List<GLCapabilitiesImmutable> eglConfigs2GLCaps(EGLGraphicsDevice device, GLProfile glp, PointerBuffer configs, int num, int winattrmask, boolean forceTransparentFlag) {
diff --git a/src/jogl/classes/jogamp/opengl/macosx/cgl/MacOSXCGLGraphicsConfiguration.java b/src/jogl/classes/jogamp/opengl/macosx/cgl/MacOSXCGLGraphicsConfiguration.java
index 10e8193e2..149927160 100644
--- a/src/jogl/classes/jogamp/opengl/macosx/cgl/MacOSXCGLGraphicsConfiguration.java
+++ b/src/jogl/classes/jogamp/opengl/macosx/cgl/MacOSXCGLGraphicsConfiguration.java
@@ -280,7 +280,7 @@ public class MacOSXCGLGraphicsConfiguration extends MutableGraphicsConfiguration
         if(null == glp) {
             glp = GLProfile.get(GLProfile.GL2);
         }
-        GLCapabilities caps = new GLCapabilities(glp);
+        final GLCapabilities caps = new GLCapabilities(glp);
         int alphaBits = 0;
         for (int i = 0; i < len; i++) {
           int attr = cglInternalAttributeToken[i+off];
@@ -353,7 +353,7 @@ public class MacOSXCGLGraphicsConfiguration extends MutableGraphicsConfiguration
           }
         }
         caps.setAlphaBits(alphaBits);
-
+        
         return caps;
       }
 }
diff --git a/src/jogl/classes/jogamp/opengl/macosx/cgl/MacOSXCGLGraphicsConfigurationFactory.java b/src/jogl/classes/jogamp/opengl/macosx/cgl/MacOSXCGLGraphicsConfigurationFactory.java
index f138e7557..13faf7090 100644
--- a/src/jogl/classes/jogamp/opengl/macosx/cgl/MacOSXCGLGraphicsConfigurationFactory.java
+++ b/src/jogl/classes/jogamp/opengl/macosx/cgl/MacOSXCGLGraphicsConfigurationFactory.java
@@ -34,13 +34,19 @@
 package jogamp.opengl.macosx.cgl;
 
 import jogamp.opengl.GLGraphicsConfigurationFactory;
+import jogamp.opengl.GLGraphicsConfigurationUtil;
+import jogamp.opengl.x11.glx.X11GLXDrawableFactory;
+
 import javax.media.nativewindow.AbstractGraphicsConfiguration;
+import javax.media.nativewindow.AbstractGraphicsDevice;
 import javax.media.nativewindow.AbstractGraphicsScreen;
 import javax.media.nativewindow.CapabilitiesChooser;
 import javax.media.nativewindow.CapabilitiesImmutable;
 import javax.media.nativewindow.GraphicsConfigurationFactory;
 import javax.media.opengl.GLCapabilitiesChooser;
 import javax.media.opengl.GLCapabilitiesImmutable;
+import javax.media.opengl.GLContext;
+import javax.media.opengl.GLDrawableFactory;
 
 
 /** Subclass of GraphicsConfigurationFactory used when non-AWT tookits
@@ -58,13 +64,7 @@ public class MacOSXCGLGraphicsConfigurationFactory extends GLGraphicsConfigurati
     protected AbstractGraphicsConfiguration chooseGraphicsConfigurationImpl(
             CapabilitiesImmutable capsChosen, CapabilitiesImmutable capsRequested,
             CapabilitiesChooser chooser, AbstractGraphicsScreen absScreen, int nativeVisualID) {
-        return chooseGraphicsConfigurationStatic(capsChosen, capsRequested, chooser, absScreen, false);
-    }
-
-    static MacOSXCGLGraphicsConfiguration chooseGraphicsConfigurationStatic(CapabilitiesImmutable capsChosen,
-                                                                            CapabilitiesImmutable capsRequested,
-                                                                            CapabilitiesChooser chooser,
-                                                                            AbstractGraphicsScreen absScreen, boolean usePBuffer) {
+        
         if (absScreen == null) {
             throw new IllegalArgumentException("AbstractGraphicsScreen is null");
         }
@@ -77,11 +77,25 @@ public class MacOSXCGLGraphicsConfigurationFactory extends GLGraphicsConfigurati
             throw new IllegalArgumentException("This NativeWindowFactory accepts only GLCapabilities objects - requested");
         }
 
-        if (chooser != null &&
-            !(chooser instanceof GLCapabilitiesChooser)) {
+        if (chooser != null && !(chooser instanceof GLCapabilitiesChooser)) {
             throw new IllegalArgumentException("This NativeWindowFactory accepts only GLCapabilitiesChooser objects");
         }
+        
+        return chooseGraphicsConfigurationStatic((GLCapabilitiesImmutable)capsChosen, (GLCapabilitiesImmutable)capsRequested, (GLCapabilitiesChooser)chooser, absScreen, false);
+    }
+
+    static MacOSXCGLGraphicsConfiguration chooseGraphicsConfigurationStatic(GLCapabilitiesImmutable capsChosen,
+                                                                            GLCapabilitiesImmutable capsRequested,
+                                                                            GLCapabilitiesChooser chooser,
+                                                                            AbstractGraphicsScreen absScreen, boolean usePBuffer) {
+        if (absScreen == null) {
+            throw new IllegalArgumentException("AbstractGraphicsScreen is null");
+        }
+        final MacOSXCGLDrawableFactory factory = (MacOSXCGLDrawableFactory) GLDrawableFactory.getDesktopFactory();
+        final AbstractGraphicsDevice device = absScreen.getDevice();
 
+        capsChosen = GLGraphicsConfigurationUtil.fixGLCapabilities( capsChosen, GLContext.isFBOAvailable(device, capsChosen.getGLProfile()), factory.canCreateGLPbuffer(device) );
+        
         return new MacOSXCGLGraphicsConfiguration(absScreen, (GLCapabilitiesImmutable)capsChosen, (GLCapabilitiesImmutable)capsRequested, 0);
     }
 }
diff --git a/src/jogl/classes/jogamp/opengl/windows/wgl/WindowsWGLGraphicsConfiguration.java b/src/jogl/classes/jogamp/opengl/windows/wgl/WindowsWGLGraphicsConfiguration.java
index 5b21353c3..4d1069e6b 100644
--- a/src/jogl/classes/jogamp/opengl/windows/wgl/WindowsWGLGraphicsConfiguration.java
+++ b/src/jogl/classes/jogamp/opengl/windows/wgl/WindowsWGLGraphicsConfiguration.java
@@ -42,7 +42,6 @@ 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;
@@ -58,6 +57,7 @@ import jogamp.nativewindow.windows.PIXELFORMATDESCRIPTOR;
 import jogamp.opengl.GLContextImpl;
 import jogamp.opengl.GLGraphicsConfigurationUtil;
 
+@SuppressWarnings("deprecation")
 public class WindowsWGLGraphicsConfiguration extends MutableGraphicsConfiguration implements Cloneable {    
     protected static final int MAX_PFORMATS = 256;
     protected static final int MAX_ATTRIBS  = 256;
@@ -107,7 +107,7 @@ public class WindowsWGLGraphicsConfiguration extends MutableGraphicsConfiguratio
         if(hasARB) {
             caps = wglARBPFID2GLCapabilities(sharedResource, device, glp, hdc, pfdID, GLGraphicsConfigurationUtil.ALL_BITS);
         } else {
-            caps = PFD2GLCapabilities(device, glp, hdc, pfdID, GLGraphicsConfigurationUtil.ALL_BITS);
+            caps = PFD2GLCapabilities(glp, hdc, pfdID, GLGraphicsConfigurationUtil.ALL_BITS);
         }
         if(null==caps) {
             throw new GLException("Couldn't choose Capabilities by: HDC 0x"+Long.toHexString(hdc)+
@@ -186,7 +186,7 @@ public class WindowsWGLGraphicsConfiguration extends MutableGraphicsConfiguratio
             }
         }
         if (DEBUG) {
-            System.err.println("setPixelFormat (ARB): hdc "+toHexString(hdc) +", "+caps);
+            System.err.println("setPixelFormat: hdc "+toHexString(hdc) +", "+caps);
         }
         setCapsPFD(caps);
     }
@@ -274,36 +274,41 @@ public class WindowsWGLGraphicsConfiguration extends MutableGraphicsConfiguratio
         return true;
     }
 
-    static int[] wglAllARBPFIDs(WindowsWGLContext sharedCtx, long hdc) {
+    static int wglARBPFDIDCount(WindowsWGLContext sharedCtx, long hdc) {
         int[] iattributes = new int[1];
         int[] iresults = new int[1];
 
         WGLExt wglExt = sharedCtx.getWGLExt();
-        iattributes[0] = WGLExt.WGL_NUMBER_PIXEL_FORMATS_ARB;
-        if (!wglExt.wglGetPixelFormatAttribivARB(hdc, 0, 0, 1, iattributes, 0, iresults, 0)) {
+        iattributes[0] = WGLExt.WGL_NUMBER_PIXEL_FORMATS_ARB; 
+        // pfdID shall be ignored here (spec), however, pass a valid pdf index '1' below (possible driver bug)
+        if (!wglExt.wglGetPixelFormatAttribivARB(hdc, 1 /* pfdID */, 0, 1, iattributes, 0, iresults, 0)) {
             if(DEBUG) {
                 System.err.println("GetPixelFormatAttribivARB: Failed - HDC 0x" + Long.toHexString(hdc) +
+                                  ", value "+iresults[0]+
                                   ", LastError: " + GDI.GetLastError());
                 Thread.dumpStack();
             }
-            return null;
+            return 0;
         }
-        int numFormats = iresults[0];
-        if(0 == numFormats) {
+        final int pfdIDCount = iresults[0];
+        if(0 == pfdIDCount) {
             if(DEBUG) {
                 System.err.println("GetPixelFormatAttribivARB: No formats - HDC 0x" + Long.toHexString(hdc) +
                                   ", LastError: " + GDI.GetLastError());
                 Thread.dumpStack();
             }
-            return null;
         }
-        int[] pfdIDs = new int[numFormats];
-        for (int i = 0; i < numFormats; i++) {
+        return pfdIDCount;
+    }
+    
+    static int[] wglAllARBPFDIDs(int pfdIDCount) {
+        int[] pfdIDs = new int[pfdIDCount];
+        for (int i = 0; i < pfdIDCount; i++) {
             pfdIDs[i] = 1 + i;
         }
         return pfdIDs;
     }
-
+    
     static WGLGLCapabilities wglARBPFID2GLCapabilities(WindowsWGLDrawableFactory.SharedResource sharedResource,
                                                        AbstractGraphicsDevice device, GLProfile glp,
                                                        long hdc, int pfdID, int winattrbits) {
@@ -320,7 +325,7 @@ 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());
         }
-        return AttribList2GLCapabilities(device, glp, hdc, pfdID, iattributes, niattribs, iresults, winattrbits);
+        return AttribList2GLCapabilities(glp, hdc, pfdID, iattributes, niattribs, iresults, winattrbits);
     }
 
     static int[] wglChoosePixelFormatARB(WindowsWGLDrawableFactory.SharedResource sharedResource, AbstractGraphicsDevice device,
@@ -369,11 +374,6 @@ public class WindowsWGLGraphicsConfiguration extends MutableGraphicsConfiguratio
         return pformats;
     }
 
-    static List <GLCapabilitiesImmutable> wglARBPFIDs2AllGLCapabilities(WindowsWGLDrawableFactory.SharedResource sharedResource,
-                                                                        AbstractGraphicsDevice device, GLProfile glp, long hdc, int[] pfdIDs) {
-        return wglARBPFIDs2GLCapabilities(sharedResource, device, glp, hdc, pfdIDs, GLGraphicsConfigurationUtil.ALL_BITS);
-    }
-    
     static List <GLCapabilitiesImmutable> wglARBPFIDs2GLCapabilities(WindowsWGLDrawableFactory.SharedResource sharedResource,
                                                                      AbstractGraphicsDevice device, GLProfile glp, long hdc, int[] pfdIDs, int winattrbits) {
         if (!sharedResource.hasARBPixelFormat()) {
@@ -390,14 +390,24 @@ 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) ) {
-                final GLCapabilitiesImmutable caps = AttribList2GLCapabilities(device, glp, hdc, pfdIDs[i], iattributes, niattribs, iresults, winattrbits);
+                final GLCapabilitiesImmutable caps = AttribList2GLCapabilities(glp, hdc, pfdIDs[i], iattributes, niattribs, iresults, winattrbits);
                 if(null != caps) {
                     bucket.add(caps);
+                    if(DEBUG) {
+                        final int j = bucket.size() - 1; 
+                        System.err.println("wglARBPFIDs2GLCapabilities: bucket["+i+" -> "+j+"]: "+caps);
+                    }
+                } else if(DEBUG) {
+                    GLCapabilitiesImmutable skipped = AttribList2GLCapabilities(glp, hdc, pfdIDs[i], iattributes, niattribs, iresults, GLGraphicsConfigurationUtil.ALL_BITS);
+                    System.err.println("wglARBPFIDs2GLCapabilities: bucket["+i+" -> skip]: pfdID "+pfdIDs[i]+", "+skipped+", winattr "+GLGraphicsConfigurationUtil.winAttributeBits2String(null, winattrbits).toString());
                 }
             } else if (DEBUG) {
-                System.err.println("wglARBPFIDs2GLCapabilities: Cannot get pixel format attributes for pixel format " +
-                                   i + "/" + numFormats + ": " + pfdIDs[i] + ", " +
-                                   GLGraphicsConfigurationUtil.winAttributeBits2String(null, winattrbits).toString());
+                if( 1 > pfdIDs[i] ) {
+                    System.err.println("wglARBPFIDs2GLCapabilities: Invalid pfdID " + i + "/" + numFormats + ": " + pfdIDs[i]);
+                } else {
+                    System.err.println("wglARBPFIDs2GLCapabilities: Cannot get pixel format attributes for pixel format " +
+                                       i + "/" + numFormats + ": " + pfdIDs[i] + ", hdc " + toHexString(hdc));
+                }
             }
         }
         return bucket;
@@ -412,9 +422,6 @@ public class WindowsWGLGraphicsConfiguration extends MutableGraphicsConfiguratio
           return false;
         }
 
-        boolean onscreen = caps.isOnscreen();
-        boolean pbuffer = caps.isPBuffer();
-
         int niattribs = 0;
 
         iattributes[niattribs++] = WGLExt.WGL_SUPPORT_OPENGL_ARB;
@@ -423,17 +430,24 @@ public class WindowsWGLGraphicsConfiguration extends MutableGraphicsConfiguratio
             iattributes[niattribs++] = WGLExt.WGL_ACCELERATION_ARB;
             iattributes[niattribs++] = accelerationValue;
         }
-        if (onscreen) {
-          iattributes[niattribs++] = WGLExt.WGL_DRAW_TO_WINDOW_ARB;
-          iattributes[niattribs++] = GL.GL_TRUE;
-        } else if (pbuffer && sharedResource.hasARBPBuffer()) {
-          iattributes[niattribs++] = WGLExt.WGL_DRAW_TO_PBUFFER_ARB;
-          iattributes[niattribs++] = GL.GL_TRUE;
+
+        final boolean usePBuffer = caps.isPBuffer() && sharedResource.hasARBPBuffer() ;
+        
+        final int surfaceType;
+        if( caps.isOnscreen() ) {
+            surfaceType = WGLExt.WGL_DRAW_TO_WINDOW_ARB;            
+        } else if( caps.isFBO() ) {
+            surfaceType = WGLExt.WGL_DRAW_TO_WINDOW_ARB;  // native replacement!
+        } else if( usePBuffer ) {
+            surfaceType = WGLExt.WGL_DRAW_TO_PBUFFER_ARB;
+        } else if( caps.isBitmap() ) {
+            surfaceType = WGLExt.WGL_DRAW_TO_BITMAP_ARB;
         } else {
-          iattributes[niattribs++] = WGLExt.WGL_DRAW_TO_BITMAP_ARB;
-          iattributes[niattribs++] = GL.GL_TRUE;
+            throw new GLException("no surface type set in caps: "+caps);
         }
-
+        iattributes[niattribs++] = surfaceType;
+        iattributes[niattribs++] = GL.GL_TRUE;
+        
         iattributes[niattribs++] = WGLExt.WGL_DOUBLE_BUFFER_ARB;
         if (caps.getDoubleBuffered()) {
           iattributes[niattribs++] = GL.GL_TRUE;
@@ -495,7 +509,7 @@ public class WindowsWGLGraphicsConfiguration extends MutableGraphicsConfiguratio
         boolean useFloat = caps.getPbufferFloatingPointBuffers();
         boolean ati      = false;
         boolean nvidia   = false;
-        if (pbuffer && sharedResource.hasARBPBuffer()) {
+        if ( usePBuffer ) {
           // Check some invariants and set up some state
           if (rect && !rtt) {
             throw new GLException("Render-to-texture-rectangle requires render-to-texture to be specified");
@@ -574,33 +588,38 @@ public class WindowsWGLGraphicsConfiguration extends MutableGraphicsConfiguratio
         return true;
     }
 
-    static int AttribList2DrawableTypeBits(AbstractGraphicsDevice device, GLProfile glp, final int[] iattribs, final int niattribs, final int[] iresults) {
+    static int AttribList2DrawableTypeBits(final int[] iattribs, 
+                                           final int niattribs, final int[] iresults) {
         int val = 0;
 
         for (int i = 0; i < niattribs; i++) {
           int attr = iattribs[i];
           switch (attr) {
             case WGLExt.WGL_DRAW_TO_WINDOW_ARB:
-                if(iresults[i] == GL.GL_TRUE) val |= GLGraphicsConfigurationUtil.WINDOW_BIT;
+                if(iresults[i] == GL.GL_TRUE) {
+                    val |= GLGraphicsConfigurationUtil.WINDOW_BIT |
+                           GLGraphicsConfigurationUtil.FBO_BIT;
+                }
                 break;
             case WGLExt.WGL_DRAW_TO_BITMAP_ARB:
-                if(iresults[i] == GL.GL_TRUE) val |= GLGraphicsConfigurationUtil.BITMAP_BIT;
+                if(iresults[i] == GL.GL_TRUE) {
+                    val |= GLGraphicsConfigurationUtil.BITMAP_BIT;
+                }
                 break;
             case WGLExt.WGL_DRAW_TO_PBUFFER_ARB:
-                if(iresults[i] == GL.GL_TRUE) val |= GLGraphicsConfigurationUtil.PBUFFER_BIT;
+                if(iresults[i] == GL.GL_TRUE) {
+                    val |= GLGraphicsConfigurationUtil.PBUFFER_BIT;
+                }
                 break;
             }
         }
-        if ( GLContext.isFBOAvailable(device, glp) ) {
-            val |= GLGraphicsConfigurationUtil.FBO_BIT;
-        }        
         return val;
     }
 
-    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);
+    static WGLGLCapabilities AttribList2GLCapabilities(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);
         int drawableTypeBits = winattrmask & allDrawableTypeBits;
 
         if( 0 == drawableTypeBits ) {
@@ -610,7 +629,7 @@ public class WindowsWGLGraphicsConfiguration extends MutableGraphicsConfiguratio
 
         if (WGLUtil.DescribePixelFormat(hdc, pfdID, PIXELFORMATDESCRIPTOR.size(), pfd) == 0) {
             // remove displayable bits, since pfdID is non displayable
-            drawableTypeBits = drawableTypeBits & ~(GLGraphicsConfigurationUtil.WINDOW_BIT | GLGraphicsConfigurationUtil.BITMAP_BIT);
+            drawableTypeBits = drawableTypeBits & ~(GLGraphicsConfigurationUtil.WINDOW_BIT | GLGraphicsConfigurationUtil.BITMAP_BIT | GLGraphicsConfigurationUtil.FBO_BIT );
             if( 0 == drawableTypeBits ) {
                 return null;
             }
@@ -638,32 +657,30 @@ public class WindowsWGLGraphicsConfiguration extends MutableGraphicsConfiguratio
         return pfdIDs;
     }
 
-    static int PFD2DrawableTypeBits(AbstractGraphicsDevice device, GLProfile glp, PIXELFORMATDESCRIPTOR pfd) {
+    static int PFD2DrawableTypeBits(PIXELFORMATDESCRIPTOR pfd) {
         int val = 0;
 
         int dwFlags = pfd.getDwFlags();
 
         if( 0 != (GDI.PFD_DRAW_TO_WINDOW & dwFlags ) ) {
-            val |= GLGraphicsConfigurationUtil.WINDOW_BIT;
+            val |= GLGraphicsConfigurationUtil.WINDOW_BIT |
+                   GLGraphicsConfigurationUtil.FBO_BIT;
         }
         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(AbstractGraphicsDevice device, final GLProfile glp, final long hdc, final int pfdID, final int winattrmask) {
+    static WGLGLCapabilities PFD2GLCapabilities(final GLProfile glp, final long hdc, final int pfdID, final int winattrmask) {
         PIXELFORMATDESCRIPTOR pfd = createPixelFormatDescriptor(hdc, pfdID);
         if(null == pfd) {
             return null;
         }
         if ((pfd.getDwFlags() & GDI.PFD_SUPPORT_OPENGL) == 0) {
-          return null;
+            return null;
         }
-        final int allDrawableTypeBits = PFD2DrawableTypeBits(device, glp, pfd);
+        final int allDrawableTypeBits = PFD2DrawableTypeBits(pfd);
         final int drawableTypeBits = winattrmask & allDrawableTypeBits;
 
         if( 0 == drawableTypeBits ) {
@@ -673,79 +690,105 @@ public class WindowsWGLGraphicsConfiguration extends MutableGraphicsConfiguratio
         final WGLGLCapabilities res = new WGLGLCapabilities(pfd, pfdID, glp);
         res.setValuesByGDI();
         return (WGLGLCapabilities) GLGraphicsConfigurationUtil.setWinAttributeBits(res, drawableTypeBits );
-  }
-
-  static PIXELFORMATDESCRIPTOR GLCapabilities2PFD(GLCapabilitiesImmutable caps, PIXELFORMATDESCRIPTOR pfd) {
-    int colorDepth = (caps.getRedBits() +
-                      caps.getGreenBits() +
-                      caps.getBlueBits());
-    if (colorDepth < 15) {
-      throw new GLException("Bit depths < 15 (i.e., non-true-color) not supported");
-    }
-    int pfdFlags = (GDI.PFD_SUPPORT_OPENGL |
-                    GDI.PFD_GENERIC_ACCELERATED);
-    if (caps.getDoubleBuffered()) {
-      pfdFlags |= GDI.PFD_DOUBLEBUFFER;
-    }
-    if (caps.isOnscreen()) {
-      pfdFlags |= GDI.PFD_DRAW_TO_WINDOW;
-    } else {
-      pfdFlags |= GDI.PFD_DRAW_TO_BITMAP;
-    }
-    if (caps.getStereo()) {
-      pfdFlags |= GDI.PFD_STEREO;
-    }
-    pfd.setDwFlags(pfdFlags);
-    pfd.setIPixelType((byte) GDI.PFD_TYPE_RGBA);
-    pfd.setCColorBits((byte) colorDepth);
-    pfd.setCRedBits  ((byte) caps.getRedBits());
-    pfd.setCGreenBits((byte) caps.getGreenBits());
-    pfd.setCBlueBits ((byte) caps.getBlueBits());
-    pfd.setCAlphaBits((byte) caps.getAlphaBits());
-    int accumDepth = (caps.getAccumRedBits() +
-                      caps.getAccumGreenBits() +
-                      caps.getAccumBlueBits());
-    pfd.setCAccumBits     ((byte) accumDepth);
-    pfd.setCAccumRedBits  ((byte) caps.getAccumRedBits());
-    pfd.setCAccumGreenBits((byte) caps.getAccumGreenBits());
-    pfd.setCAccumBlueBits ((byte) caps.getAccumBlueBits());
-    pfd.setCAccumAlphaBits((byte) caps.getAccumAlphaBits());
-    pfd.setCDepthBits((byte) caps.getDepthBits());
-    pfd.setCStencilBits((byte) caps.getStencilBits());
-    pfd.setILayerType((byte) GDI.PFD_MAIN_PLANE);
-
-    // n/a with non ARB/GDI method:
-    //       multisample
-    //       opaque
-    //       pbuffer
-    return pfd;
-  }
-
-  static PIXELFORMATDESCRIPTOR createPixelFormatDescriptor(long hdc, int pfdID) {
-    PIXELFORMATDESCRIPTOR pfd = PIXELFORMATDESCRIPTOR.create();
-    pfd.setNSize((short) PIXELFORMATDESCRIPTOR.size());
-    pfd.setNVersion((short) 1);
-    if(0 != hdc && 1 <= pfdID) {
-        if (WGLUtil.DescribePixelFormat(hdc, pfdID, PIXELFORMATDESCRIPTOR.size(), pfd) == 0) {
-            // Accelerated pixel formats that are non displayable
-            if(DEBUG) {
-                System.err.println("Info: Non displayable pixel format " + pfdID + " of device context: error code " + GDI.GetLastError());
-            }
+   }
+
+    static WGLGLCapabilities PFD2GLCapabilitiesNoCheck(final GLProfile glp, final long hdc, final int pfdID) {
+        PIXELFORMATDESCRIPTOR pfd = createPixelFormatDescriptor(hdc, pfdID);
+        return PFD2GLCapabilitiesNoCheck(glp, pfd, pfdID);
+   }
+    
+   static WGLGLCapabilities PFD2GLCapabilitiesNoCheck(GLProfile glp, PIXELFORMATDESCRIPTOR pfd, int pfdID) {
+        if(null == pfd) {
             return null;
         }
-    }
-    return pfd;
-  }
-
-  static PIXELFORMATDESCRIPTOR createPixelFormatDescriptor() {
-    return createPixelFormatDescriptor(0, 0);
-  }
-  
-  public String toString() {
-    return "WindowsWGLGraphicsConfiguration["+getScreen()+", pfdID " + getPixelFormatID() + ", ARB-Choosen " + isChoosenByARB() +
-                                            ",\n\trequested " + getRequestedCapabilities() +
-                                            ",\n\tchosen    " + getChosenCapabilities() +
-                                            "]";
-  }
+        final WGLGLCapabilities res = new WGLGLCapabilities(pfd, pfdID, glp);
+        res.setValuesByGDI();
+        return (WGLGLCapabilities) GLGraphicsConfigurationUtil.setWinAttributeBits(res, PFD2DrawableTypeBits(pfd));
+   }
+    
+   static PIXELFORMATDESCRIPTOR GLCapabilities2PFD(GLCapabilitiesImmutable caps, PIXELFORMATDESCRIPTOR pfd) {
+       int colorDepth = (caps.getRedBits() +
+               caps.getGreenBits() +
+               caps.getBlueBits());
+       if (colorDepth < 15) {
+           throw new GLException("Bit depths < 15 (i.e., non-true-color) not supported");
+       }
+       int pfdFlags = ( GDI.PFD_SUPPORT_OPENGL | GDI.PFD_GENERIC_ACCELERATED );
+
+       if( caps.isOnscreen() ) {
+           pfdFlags |= GDI.PFD_DRAW_TO_WINDOW;
+       } else if( caps.isFBO() ) {
+           pfdFlags |= GDI.PFD_DRAW_TO_WINDOW; // native replacement!
+       } else if( caps.isPBuffer() ) {
+           pfdFlags |= GDI.PFD_DRAW_TO_BITMAP; // pbuffer n/a, use bitmap
+       } else if( caps.isBitmap() ) {
+           pfdFlags |= GDI.PFD_DRAW_TO_BITMAP;
+       } else {
+           throw new GLException("no surface type set in caps: "+caps);
+       }
+
+       if ( caps.getDoubleBuffered() ) {
+           if( caps.isBitmap() || caps.isPBuffer() ) {
+               pfdFlags |= GDI.PFD_DOUBLEBUFFER_DONTCARE; // bitmaps probably don't have dbl buffering
+           } else {
+               pfdFlags |= GDI.PFD_DOUBLEBUFFER;
+           }
+       }
+       
+       if (caps.getStereo()) {
+           pfdFlags |= GDI.PFD_STEREO;
+       }
+       pfd.setDwFlags(pfdFlags);
+       pfd.setIPixelType((byte) GDI.PFD_TYPE_RGBA);
+       pfd.setCColorBits((byte) colorDepth);
+       pfd.setCRedBits  ((byte) caps.getRedBits());
+       pfd.setCGreenBits((byte) caps.getGreenBits());
+       pfd.setCBlueBits ((byte) caps.getBlueBits());
+       pfd.setCAlphaBits((byte) caps.getAlphaBits());
+       int accumDepth = (caps.getAccumRedBits() +
+               caps.getAccumGreenBits() +
+               caps.getAccumBlueBits());
+       pfd.setCAccumBits     ((byte) accumDepth);
+       pfd.setCAccumRedBits  ((byte) caps.getAccumRedBits());
+       pfd.setCAccumGreenBits((byte) caps.getAccumGreenBits());
+       pfd.setCAccumBlueBits ((byte) caps.getAccumBlueBits());
+       pfd.setCAccumAlphaBits((byte) caps.getAccumAlphaBits());
+       pfd.setCDepthBits((byte) caps.getDepthBits());
+       pfd.setCStencilBits((byte) caps.getStencilBits());
+       pfd.setILayerType((byte) GDI.PFD_MAIN_PLANE);
+
+       // n/a with non ARB/GDI method:
+       //       multisample
+       //       opaque
+       //       pbuffer
+       return pfd;
+   }
+
+   static PIXELFORMATDESCRIPTOR createPixelFormatDescriptor(long hdc, int pfdID) {
+       PIXELFORMATDESCRIPTOR pfd = PIXELFORMATDESCRIPTOR.create();
+       pfd.setNSize((short) PIXELFORMATDESCRIPTOR.size());
+       pfd.setNVersion((short) 1);
+       if(0 != hdc && 1 <= pfdID) {
+           if (WGLUtil.DescribePixelFormat(hdc, pfdID, PIXELFORMATDESCRIPTOR.size(), pfd) == 0) {
+               // Accelerated pixel formats that are non displayable
+               if(DEBUG) {
+                   System.err.println("Info: Non displayable pixel format " + pfdID + " of device context: error code " + GDI.GetLastError());
+               }
+               return null;
+           }
+       }
+       return pfd;
+   }
+
+   static PIXELFORMATDESCRIPTOR createPixelFormatDescriptor() {
+       return createPixelFormatDescriptor(0, 0);
+   }
+
+   public String toString() {
+       return "WindowsWGLGraphicsConfiguration["+getScreen()+", pfdID " + getPixelFormatID() + ", ARB-Choosen " + isChoosenByARB() +
+               ",\n\trequested " + getRequestedCapabilities() +
+               ",\n\tchosen    " + getChosenCapabilities() +
+               "]";
+   }
 }
 
diff --git a/src/jogl/classes/jogamp/opengl/windows/wgl/WindowsWGLGraphicsConfigurationFactory.java b/src/jogl/classes/jogamp/opengl/windows/wgl/WindowsWGLGraphicsConfigurationFactory.java
index 66a5821d3..41c9bba02 100644
--- a/src/jogl/classes/jogamp/opengl/windows/wgl/WindowsWGLGraphicsConfigurationFactory.java
+++ b/src/jogl/classes/jogamp/opengl/windows/wgl/WindowsWGLGraphicsConfigurationFactory.java
@@ -85,7 +85,11 @@ public class WindowsWGLGraphicsConfigurationFactory extends GLGraphicsConfigurat
             throw new IllegalArgumentException("This NativeWindowFactory accepts only GLCapabilities objects - requested");
         }
 
-        return chooseGraphicsConfigurationStatic((GLCapabilitiesImmutable)capsChosen, (GLCapabilitiesImmutable)capsRequested, chooser, absScreen);
+        if (chooser != null && !(chooser instanceof GLCapabilitiesChooser)) {
+            throw new IllegalArgumentException("This NativeWindowFactory accepts only GLCapabilitiesChooser objects");
+        }
+        
+        return chooseGraphicsConfigurationStatic((GLCapabilitiesImmutable)capsChosen, (GLCapabilitiesImmutable)capsRequested, (GLCapabilitiesChooser)chooser, absScreen);
     }
 
     static WindowsWGLGraphicsConfiguration createDefaultGraphicsConfiguration(GLCapabilitiesImmutable caps,
@@ -95,7 +99,7 @@ public class WindowsWGLGraphicsConfigurationFactory extends GLGraphicsConfigurat
 
     static WindowsWGLGraphicsConfiguration chooseGraphicsConfigurationStatic(GLCapabilitiesImmutable capsChosen,
                                                                              GLCapabilitiesImmutable capsReq,
-                                                                             CapabilitiesChooser chooser,
+                                                                             GLCapabilitiesChooser chooser,
                                                                              AbstractGraphicsScreen absScreen) {
         if(null==absScreen) {
             absScreen = DefaultGraphicsScreen.createDefault(NativeWindowFactory.TYPE_WINDOWS);
@@ -151,8 +155,9 @@ public class WindowsWGLGraphicsConfigurationFactory extends GLGraphicsConfigurat
     }
 
     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, device, glProfile, hdc, pformats);
+        final int pfdIDCount = WindowsWGLGraphicsConfiguration.wglARBPFDIDCount((WindowsWGLContext)sharedResource.getContext(), hdc);
+        final int[] pformats = WindowsWGLGraphicsConfiguration.wglAllARBPFDIDs(pfdIDCount);
+        return WindowsWGLGraphicsConfiguration.wglARBPFIDs2GLCapabilities(sharedResource, device, glProfile, hdc, pformats, GLGraphicsConfigurationUtil.ALL_BITS);
     }
 
     static List<GLCapabilitiesImmutable> getAvailableGLCapabilitiesGDI(AbstractGraphicsDevice device, GLProfile glProfile, long hdc) {
@@ -160,7 +165,7 @@ public class WindowsWGLGraphicsConfigurationFactory extends GLGraphicsConfigurat
         int numFormats = pformats.length;
         List<GLCapabilitiesImmutable> bucket = new ArrayList<GLCapabilitiesImmutable>(numFormats);
         for (int i = 0; i < numFormats; i++) {
-            final GLCapabilitiesImmutable caps = WindowsWGLGraphicsConfiguration.PFD2GLCapabilities(device, glProfile, hdc, pformats[i], GLGraphicsConfigurationUtil.ALL_BITS);
+            final GLCapabilitiesImmutable caps = WindowsWGLGraphicsConfiguration.PFD2GLCapabilities(glProfile, hdc, pformats[i], GLGraphicsConfigurationUtil.ALL_BITS);
             if(null != caps) {
                 bucket.add(caps);
             }
@@ -310,10 +315,20 @@ public class WindowsWGLGraphicsConfigurationFactory extends GLGraphicsConfigurat
         final int winattrbits = GLGraphicsConfigurationUtil.getExclusiveWinAttributeBits(capsChosen);
         final GLProfile glProfile = capsChosen.getGLProfile();
         
+        final int pfdIDCount = WindowsWGLGraphicsConfiguration.wglARBPFDIDCount((WindowsWGLContext)sharedResource.getContext(), hdc);
+        
         if(DEBUG) {
-            System.err.println("translucency requested: "+(!capsChosen.isBackgroundOpaque())+", compositioning enabled: "+GDI.DwmIsCompositionEnabled()+" -> translucency "+(!isOpaque));
+            System.err.println("updateGraphicsConfigurationARB: hdc "+toHexString(hdc)+", pfdIDCount(hdc) "+pfdIDCount+", capsChosen "+capsChosen+", "+GLGraphicsConfigurationUtil.winAttributeBits2String(null, winattrbits).toString());
+            System.err.println("isOpaque "+isOpaque+" (translucency requested: "+(!capsChosen.isBackgroundOpaque())+", compositioning enabled: "+GDI.DwmIsCompositionEnabled()+")");
         }
 
+        if(0 >= pfdIDCount) {
+            if (DEBUG) {
+                System.err.println("updateGraphicsConfigurationARB: failed due to 0 pfdIDs for hdc "+toHexString(hdc)+" - hdc incompatible w/ ARB ext.");
+            }
+            return false;
+        }
+        
         WGLGLCapabilities pixelFormatCaps = null; // chosen or preset PFD ID's caps
         boolean pixelFormatSet = false; // indicates a preset PFD ID [caps]
         final int presetPFDID = extHDC ? -1 : WGLUtil.GetPixelFormat(hdc) ;
@@ -358,7 +373,7 @@ public class WindowsWGLGraphicsConfigurationFactory extends GLGraphicsConfigurat
                         System.err.println("updateGraphicsConfigurationARB: wglChoosePixelFormatARB failed with: "+capsChosen);
                     }
                     // 2nd choice: get all GLCapabilities available, no preferred recommendedIndex available
-                    pformats = WindowsWGLGraphicsConfiguration.wglAllARBPFIDs((WindowsWGLContext)sharedResource.getContext(), hdc);
+                    pformats = WindowsWGLGraphicsConfiguration.wglAllARBPFDIDs(pfdIDCount);
                     if (DEBUG) {
                         final int len = ( null != pformats ) ? pformats.length : 0;
                         System.err.println("updateGraphicsConfigurationARB: NumFormats (wglAllARBPFIDs) " + len);
@@ -378,8 +393,7 @@ public class WindowsWGLGraphicsConfigurationFactory extends GLGraphicsConfigurat
             
             if( null == availableCaps || 0 == availableCaps.size() ) {
                 if (DEBUG) {
-                    System.err.println("updateGraphicsConfigurationARB: wglARBPFIDs2GLCapabilities failed with " + pformats.length +
-                                       " pfd ids, " + GLGraphicsConfigurationUtil.winAttributeBits2String(null, winattrbits).toString());
+                    System.err.println("updateGraphicsConfigurationARB: wglARBPFIDs2GLCapabilities failed with " + pformats.length + " pfd ids");
                     Thread.dumpStack();
                 }
                 return false;
@@ -436,7 +450,10 @@ public class WindowsWGLGraphicsConfigurationFactory extends GLGraphicsConfigurat
         final GLProfile glProfile = capsChosen.getGLProfile();
         final int winattrmask = GLGraphicsConfigurationUtil.getExclusiveWinAttributeBits(capsChosen);
         
-        List<GLCapabilitiesImmutable> availableCaps = new ArrayList<GLCapabilitiesImmutable>();
+        if(DEBUG) {
+            System.err.println("updateGraphicsConfigurationGDI: capsChosen "+capsChosen+", "+GLGraphicsConfigurationUtil.winAttributeBits2String(null, winattrmask).toString());
+        }
+        
         int pfdID; // chosen or preset PFD ID
         WGLGLCapabilities pixelFormatCaps = null; // chosen or preset PFD ID's caps
         boolean pixelFormatSet = false; // indicates a preset PFD ID [caps]
@@ -451,17 +468,29 @@ public class WindowsWGLGraphicsConfigurationFactory extends GLGraphicsConfigurat
                         + ", pixelformat " + pfdID);
             }
             pixelFormatSet = true;
-            pixelFormatCaps = WindowsWGLGraphicsConfiguration.PFD2GLCapabilities(config.getScreen().getDevice(), glProfile, hdc, pfdID, winattrmask);
+            pixelFormatCaps = WindowsWGLGraphicsConfiguration.PFD2GLCapabilities(glProfile, hdc, pfdID, winattrmask);
+            if(null == pixelFormatCaps) {
+                throw new GLException("Could not map PFD2GLCaps w/ already chosen pfdID "+pfdID);
+            }
         } else {
-            if(null == pformats) {
+            final boolean givenPFormats = null != pformats;
+            if( !givenPFormats ) {
                 pformats = WindowsWGLGraphicsConfiguration.wglAllGDIPFIDs(hdc);
             }
 
+            List<GLCapabilitiesImmutable> availableCaps = new ArrayList<GLCapabilitiesImmutable>();
             for (int i = 0; i < pformats.length; i++) {
-                final GLCapabilitiesImmutable caps = WindowsWGLGraphicsConfiguration.PFD2GLCapabilities(config.getScreen().getDevice(), glProfile, hdc, pformats[i], winattrmask);
+                final GLCapabilitiesImmutable caps = WindowsWGLGraphicsConfiguration.PFD2GLCapabilities(glProfile, hdc, pformats[i], winattrmask);
                 if(null != caps) {
                     availableCaps.add(caps);
-                }                
+                    if(DEBUG) {
+                        final int j = availableCaps.size() - 1; 
+                        System.err.println("updateGraphicsConfigurationGDI: availableCaps["+i+" -> "+j+"]: "+caps);
+                    }
+                } else if(DEBUG) {
+                    GLCapabilitiesImmutable skipped = WindowsWGLGraphicsConfiguration.PFD2GLCapabilitiesNoCheck(glProfile, hdc, pformats[i]);
+                    System.err.println("updateGraphicsConfigurationGDI: availableCaps["+i+" -> skip]: pfdID "+pformats[i]+", "+skipped);
+                }
             }
 
             // 1st choice: get GLCapabilities based on users GLCapabilities setting recommendedIndex as preferred choice
@@ -470,16 +499,21 @@ public class WindowsWGLGraphicsConfigurationFactory extends GLGraphicsConfigurat
             pfdID = WGLUtil.ChoosePixelFormat(hdc, pfd);
             int recommendedIndex = -1 ;
             if( 1 <= pfdID ) {
-                // seek index ..
+                // seek index .. in all formats _or_ in given formats!
                 for (recommendedIndex = availableCaps.size() - 1 ;
                      0 <= recommendedIndex && pfdID != ((WGLGLCapabilities) availableCaps.get(recommendedIndex)).getPFDID();
                      recommendedIndex--)
                 { /* nop */ }
+                if(DEBUG && 0 > recommendedIndex) {
+                    final GLCapabilitiesImmutable reqPFDCaps = WindowsWGLGraphicsConfiguration.PFD2GLCapabilitiesNoCheck(glProfile, pfd, pfdID);
+                    final GLCapabilitiesImmutable chosenCaps = WindowsWGLGraphicsConfiguration.PFD2GLCapabilities(glProfile, hdc, pfdID, winattrmask);
+                    System.err.println("Chosen PFDID "+pfdID+", but not found in available caps (use given pfdIDs "+givenPFormats+", reqPFDCaps "+reqPFDCaps+", chosenCaps: "+chosenCaps);
+                }
             }
-            // 2nd choice: if no preferred recommendedIndex available
             if (DEBUG) {
-                System.err.println("updateGraphicsConfigurationGDI: ChoosePixelFormat(HDC " + toHexString(hdc) + ") = " + pfdID + ", idx " + recommendedIndex + " (LastError: " + GDI.GetLastError() + ")");
+                System.err.println("updateGraphicsConfigurationGDI: ChoosePixelFormat(HDC " + toHexString(hdc) + ") = pfdID " + pfdID + ", idx " + recommendedIndex + " (LastError: " + GDI.GetLastError() + ")");
             }
+            // 2nd choice: if no preferred recommendedIndex available
             int chosenIndex = chooseCapabilities(chooser, capsChosen, availableCaps, recommendedIndex);
             if ( 0 > chosenIndex ) {
                 if (DEBUG) {
@@ -490,8 +524,7 @@ public class WindowsWGLGraphicsConfigurationFactory extends GLGraphicsConfigurat
             }
             pixelFormatCaps = (WGLGLCapabilities) availableCaps.get(chosenIndex);
             if (DEBUG) {
-                System.err.println("chosen pfdID (GDI): native recommended "+ (recommendedIndex+1) +
-                                   ", caps " + pixelFormatCaps);
+                System.err.println("chosen pfdID (GDI): chosenIndex "+ chosenIndex + ", caps " + pixelFormatCaps);
             }
         }
 
diff --git a/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXGraphicsConfiguration.java b/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXGraphicsConfiguration.java
index d169945fe..866fcbbe4 100644
--- a/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXGraphicsConfiguration.java
+++ b/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXGraphicsConfiguration.java
@@ -41,7 +41,6 @@ import javax.media.opengl.GL;
 import javax.media.opengl.GLCapabilities;
 import javax.media.opengl.GLCapabilitiesChooser;
 import javax.media.opengl.GLCapabilitiesImmutable;
-import javax.media.opengl.GLContext;
 import javax.media.opengl.GLDrawableFactory;
 import javax.media.opengl.GLException;
 import javax.media.opengl.GLProfile;
@@ -67,28 +66,6 @@ public class X11GLXGraphicsConfiguration extends X11GraphicsConfiguration implem
         this.chooser=chooser;
     }
 
-    static X11GLXGraphicsConfiguration create(GLProfile glp, X11GraphicsScreen x11Screen, int fbcfgID) {
-      final X11GraphicsDevice device = (X11GraphicsDevice) x11Screen.getDevice();
-      final long display = device.getHandle();
-      if(0==display) {
-          throw new GLException("Display null of "+x11Screen);
-      }
-      final int screen = x11Screen.getIndex();
-      final long fbcfg = glXFBConfigID2FBConfig(display, screen, fbcfgID);
-      if(0==fbcfg) {
-          throw new GLException("FBConfig null of "+toHexString(fbcfgID));
-      }
-      if(null==glp) {
-        glp = GLProfile.getDefault(x11Screen.getDevice());
-      }
-      final X11GLXDrawableFactory factory = (X11GLXDrawableFactory) GLDrawableFactory.getDesktopFactory();
-      final X11GLCapabilities caps = GLXFBConfig2GLCapabilities(device, glp, fbcfg, GLGraphicsConfigurationUtil.ALL_BITS, factory.isGLXMultisampleAvailable(device));      
-      if(null==caps) {
-          throw new GLException("GLCapabilities null of "+toHexString(fbcfg));
-      }
-      return new X11GLXGraphicsConfiguration(x11Screen, caps, caps, new DefaultGLCapabilitiesChooser());
-    }
-
     public Object clone() {
         return super.clone();
     }
@@ -123,11 +100,31 @@ public class X11GLXGraphicsConfiguration extends X11GraphicsConfiguration implem
         }
     }
 
+    static X11GLXGraphicsConfiguration create(GLProfile glp, X11GraphicsScreen x11Screen, int fbcfgID) {
+      final X11GraphicsDevice device = (X11GraphicsDevice) x11Screen.getDevice();
+      final long display = device.getHandle();
+      if(0==display) {
+          throw new GLException("Display null of "+x11Screen);
+      }
+      final int screen = x11Screen.getIndex();
+      final long fbcfg = glXFBConfigID2FBConfig(display, screen, fbcfgID);
+      if(0==fbcfg) {
+          throw new GLException("FBConfig null of "+toHexString(fbcfgID));
+      }
+      if(null==glp) {
+        glp = GLProfile.getDefault(x11Screen.getDevice());
+      }
+      final X11GLXDrawableFactory factory = (X11GLXDrawableFactory) GLDrawableFactory.getDesktopFactory();
+      final X11GLCapabilities caps = GLXFBConfig2GLCapabilities(device, glp, fbcfg, GLGraphicsConfigurationUtil.ALL_BITS, factory.isGLXMultisampleAvailable(device));      
+      if(null==caps) {
+          throw new GLException("GLCapabilities null of "+toHexString(fbcfg));
+      }
+      return new X11GLXGraphicsConfiguration(x11Screen, caps, caps, new DefaultGLCapabilitiesChooser());
+    }
+
     static int[] GLCapabilities2AttribList(GLCapabilitiesImmutable caps,
-                                           boolean forFBAttr,
-                                           boolean isMultisampleAvailable,
-                                           long display,
-                                           int screen) 
+                                           boolean forFBAttr, boolean isMultisampleAvailable,
+                                           long display, int screen) 
     {
         int colorDepth = (caps.getRedBits() +
                           caps.getGreenBits() +
@@ -140,10 +137,21 @@ public class X11GLXGraphicsConfiguration extends X11GraphicsConfiguration implem
 
         if (forFBAttr) {
           res[idx++] = GLX.GLX_DRAWABLE_TYPE;
-          res[idx++] = caps.isOnscreen() ? ( GLX.GLX_WINDOW_BIT ) : ( caps.isPBuffer() ? GLX.GLX_PBUFFER_BIT : GLX.GLX_PIXMAP_BIT ) ;
-        }
-
-        if (forFBAttr) {
+          
+          final int surfaceType;
+          if( caps.isOnscreen() ) {
+              surfaceType = GLX.GLX_WINDOW_BIT;
+          } else if( caps.isFBO() ) {
+              surfaceType = GLX.GLX_WINDOW_BIT;  // native replacement!
+          } else if( caps.isPBuffer() ) {
+              surfaceType = GLX.GLX_PBUFFER_BIT;
+          } else if( caps.isBitmap() ) {
+              surfaceType = GLX.GLX_PIXMAP_BIT;
+          } else {
+              throw new GLException("no surface type set in caps: "+caps);
+          }
+          res[idx++] = surfaceType;
+          
           res[idx++] = GLX.GLX_RENDER_TYPE;
           res[idx++] = GLX.GLX_RGBA_BIT;
         } else {
@@ -244,14 +252,15 @@ public class X11GLXGraphicsConfiguration extends X11GraphicsConfiguration implem
     return true;
   }
 
-  static int FBCfgDrawableTypeBits(final X11GraphicsDevice device, GLProfile glp, final long fbcfg) {
+  static int FBCfgDrawableTypeBits(final X11GraphicsDevice device, final long fbcfg) {
     int val = 0;
 
     int[] tmp = new int[1];
     int fbtype = glXGetFBConfig(device.getHandle(), fbcfg, GLX.GLX_DRAWABLE_TYPE, tmp, 0);
 
     if ( 0 != ( fbtype & GLX.GLX_WINDOW_BIT ) ) {
-        val |= GLGraphicsConfigurationUtil.WINDOW_BIT;
+        val |= GLGraphicsConfigurationUtil.WINDOW_BIT |
+               GLGraphicsConfigurationUtil.FBO_BIT;
     }
     if ( 0 != ( fbtype & GLX.GLX_PIXMAP_BIT ) ) {
         val |= GLGraphicsConfigurationUtil.BITMAP_BIT;
@@ -259,9 +268,6 @@ public class X11GLXGraphicsConfiguration extends X11GraphicsConfiguration implem
     if ( 0 != ( fbtype & GLX.GLX_PBUFFER_BIT ) ) {
         val |= GLGraphicsConfigurationUtil.PBUFFER_BIT;
     }
-    if ( GLContext.isFBOAvailable(device, glp) ) {
-        val |= GLGraphicsConfigurationUtil.FBO_BIT;
-    }
     return val;
   }
 
@@ -275,7 +281,7 @@ public class X11GLXGraphicsConfiguration extends X11GraphicsConfiguration implem
 
   static X11GLCapabilities GLXFBConfig2GLCapabilities(X11GraphicsDevice device, GLProfile glp, long fbcfg,
                                                       int winattrmask, boolean isMultisampleAvailable) {
-    final int allDrawableTypeBits = FBCfgDrawableTypeBits(device, glp,  fbcfg);
+    final int allDrawableTypeBits = FBCfgDrawableTypeBits(device, fbcfg);
     int drawableTypeBits = winattrmask & allDrawableTypeBits;
     
     final long display = device.getHandle(); 
@@ -286,7 +292,7 @@ public class X11GLXGraphicsConfiguration extends X11GraphicsConfiguration implem
             System.err.println("X11GLXGraphicsConfiguration.GLXFBConfig2GLCapabilities: Null XVisualInfo for FBConfigID 0x" + Integer.toHexString(fbcfgid));
         }
         // onscreen must have an XVisualInfo
-        drawableTypeBits = drawableTypeBits & ~GLGraphicsConfigurationUtil.WINDOW_BIT;
+        drawableTypeBits &= ~(GLGraphicsConfigurationUtil.WINDOW_BIT | GLGraphicsConfigurationUtil.FBO_BIT);
     }
 
     if( 0 == drawableTypeBits ) {
@@ -394,10 +400,9 @@ public class X11GLXGraphicsConfiguration extends X11GraphicsConfiguration implem
   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 )
-                                    ;
-
+                                    GLGraphicsConfigurationUtil.BITMAP_BIT |
+                                    GLGraphicsConfigurationUtil.FBO_BIT ;
+    
     final int drawableTypeBits = winattrmask & allDrawableTypeBits;
 
     if( 0 == drawableTypeBits ) {
diff --git a/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXGraphicsConfigurationFactory.java b/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXGraphicsConfigurationFactory.java
index 3189f933f..8086cd26a 100644
--- a/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXGraphicsConfigurationFactory.java
+++ b/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXGraphicsConfigurationFactory.java
@@ -210,7 +210,6 @@ public class X11GLXGraphicsConfigurationFactory extends GLGraphicsConfigurationF
         if (x11Screen == null) {
             throw new IllegalArgumentException("AbstractGraphicsScreen is null");
         }
-
         if (capsChosen == null) {
             capsChosen = new GLCapabilities(null);
         }