GLCapabilities enhancements: Choosing, All-Available, Data Handling (X11, WGL and EGL)

- GLDrawableFactory exposes:
    public final List/*GLCapabilitiesImmutable*/ getAvailableCapabilities(AbstractGraphicsDevice device)

- GLCapabilities platform specialization containing native ids (XVisual/FBConfig, PFD, EGLConfig, ..)

- GLCapabilities setPbuffer(true) disables onscreen

- Capabilities setOnscreen(true) disables pbuffer

- Capabilities implements Comparable

- *Capabilities: enhanced 'toString(..)'

- CapabilitiesChooser.chooseCapabilities:
     'CapabilitiesImmutable[] available' -> 'List /*<CapabilitiesImmutable>*/ available'

- VersionApplet, GLCanvas.main, GLWindow.main, GLProfile/debug: dumps all available GLCaps

- WGLGLCapabilities: proper non-displayeble (pbuffer) pfdid handling

TODO: ES/EGL test with emulation

6 files changed, 386 insertions, 185 deletions

diff --git a/src/jogl/classes/com/jogamp/opengl/impl/x11/glx/X11GLCapabilities.java b/src/jogl/classes/com/jogamp/opengl/impl/x11/glx/X11GLCapabilities.java
new file mode 100644
index 000000000..e3a1e7d72
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/impl/x11/glx/X11GLCapabilities.java
@@ -0,0 +1,116 @@
+/**
+ * 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.impl.x11.glx;
+
+import com.jogamp.nativewindow.impl.x11.XVisualInfo;
+import javax.media.opengl.GLCapabilities;
+import javax.media.opengl.GLException;
+import javax.media.opengl.GLProfile;
+import java.util.Comparator;
+
+public class X11GLCapabilities extends GLCapabilities {
+  XVisualInfo xVisualInfo;
+  long fbcfg;
+  int  fbcfgid;
+
+  /** Comparing xvisual id only */
+  public static class XVisualIDComparator implements Comparator {
+
+      public int compare(Object o1, Object o2) {
+        if ( ! ( o1 instanceof X11GLCapabilities ) ) {
+            Class c = (null != o1) ? o1.getClass() : null ;
+            throw new ClassCastException("arg1 not a X11GLCapabilities object: " + c);
+        }
+        if ( ! ( o2 instanceof X11GLCapabilities ) ) {
+            Class c = (null != o2) ? o2.getClass() : null ;
+            throw new ClassCastException("arg2 not a X11GLCapabilities object: " + c);
+        }
+
+        final X11GLCapabilities caps1 = (X11GLCapabilities) o1;
+        final long id1 = caps1.getXVisualID();
+
+        final X11GLCapabilities caps2 = (X11GLCapabilities) o2;
+        final long id2 = caps2.getXVisualID();
+
+        if(id1 > id2) {
+            return 1;
+        } else if(id1 < id2) {
+            return -1;
+        }
+        return 0;
+      }
+  }
+
+  public X11GLCapabilities(XVisualInfo xVisualInfo, long fbcfg, int fbcfgid, GLProfile glp) {
+      super(glp);
+      this.xVisualInfo = xVisualInfo;
+      this.fbcfg = fbcfg;
+      this.fbcfgid = fbcfgid;
+  }
+
+  public X11GLCapabilities(XVisualInfo xVisualInfo, GLProfile glp) {
+      super(glp);
+      this.xVisualInfo = xVisualInfo;
+      this.fbcfg = 0;
+      this.fbcfgid = -1;
+  }
+
+  public Object cloneMutable() {
+    return clone();
+  }
+
+  public Object clone() {
+    try {
+      return super.clone();
+    } catch (RuntimeException e) {
+      throw new GLException(e);
+    }
+  }
+
+  final public XVisualInfo getXVisualInfo() { return xVisualInfo; }
+  final public long getXVisualID() { return xVisualInfo.getVisualid(); }
+
+  final public long getFBConfig() { return fbcfg; }
+  final public int getFBConfigID() { return fbcfgid; }
+  final public boolean isFBConfig() { return 0!=fbcfg && fbcfgid>0; }
+  
+  public StringBuffer toString(StringBuffer sink) {
+    if(null == sink) {
+        sink = new StringBuffer();
+    }
+    sink.append("0x").append(Long.toHexString(xVisualInfo.getVisualid())).append(" ");
+    if(isFBConfig()) {
+        sink.append("0x").append(Integer.toHexString(fbcfgid));
+    } else {
+        sink.append("----");
+    }
+    sink.append(": ");
+    return super.toString(sink);
+  }
+}
\ No newline at end of file
diff --git a/src/jogl/classes/com/jogamp/opengl/impl/x11/glx/X11GLXContext.java b/src/jogl/classes/com/jogamp/opengl/impl/x11/glx/X11GLXContext.java
index 32d70ad6b..dd25f241e 100644
--- a/src/jogl/classes/com/jogamp/opengl/impl/x11/glx/X11GLXContext.java
+++ b/src/jogl/classes/com/jogamp/opengl/impl/x11/glx/X11GLXContext.java
@@ -40,11 +40,14 @@
 
 package com.jogamp.opengl.impl.x11.glx;
 
-import com.jogamp.common.util.VersionNumber;
 import java.nio.*;
 import java.util.*;
+
 import javax.media.opengl.*;
 import javax.media.nativewindow.*;
+import javax.media.nativewindow.x11.X11GraphicsDevice;
+
+import com.jogamp.common.util.VersionNumber;
 import com.jogamp.opengl.impl.*;
 import com.jogamp.gluegen.runtime.ProcAddressTable;
 import com.jogamp.gluegen.runtime.opengl.GLProcAddressResolver;
@@ -119,21 +122,23 @@ public abstract class X11GLXContext extends GLContextImpl {
 
   protected Map/*<String, String>*/ getExtensionNameMap() { return extensionNameMap; }
 
-  public final boolean isGLReadDrawableAvailable() {
+  public final boolean isGLXVersionGreaterEqualOneThree() {
     if(null == glXVersion) {
         X11GLXDrawableFactory factory = (X11GLXDrawableFactory)drawable.getFactoryImpl();
 
         X11GLXGraphicsConfiguration config = (X11GLXGraphicsConfiguration)drawable.getNativeSurface().getGraphicsConfiguration().getNativeGraphicsConfiguration();
-        AbstractGraphicsDevice device = config.getScreen().getDevice();
+        X11GraphicsDevice device = (X11GraphicsDevice) config.getScreen().getDevice();
 
         glXVersion = factory.getGLXVersion(device);
-        if( null != glXVersion ) {
-            glXVersionOneThreeCapable = glXVersion.compareTo(factory.versionOneThree)>=0;
-        }
+        glXVersionOneThreeCapable = ( null != glXVersion ) ? glXVersion.compareTo(X11GLXDrawableFactory.versionOneThree) >= 0 : false ;
     }
     return glXVersionOneThreeCapable;
   }
 
+  public final boolean isGLReadDrawableAvailable() {
+    return isGLXVersionGreaterEqualOneThree();
+  }
+
   private final boolean glXMakeContextCurrent(long dpy, long writeDrawable, long readDrawable, long ctx) {
     boolean res = false;
 
diff --git a/src/jogl/classes/com/jogamp/opengl/impl/x11/glx/X11GLXDrawableFactory.java b/src/jogl/classes/com/jogamp/opengl/impl/x11/glx/X11GLXDrawableFactory.java
index 186bd5ec5..7f16ef1a4 100644
--- a/src/jogl/classes/com/jogamp/opengl/impl/x11/glx/X11GLXDrawableFactory.java
+++ b/src/jogl/classes/com/jogamp/opengl/impl/x11/glx/X11GLXDrawableFactory.java
@@ -37,7 +37,11 @@
 
 package com.jogamp.opengl.impl.x11.glx;
 
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
 import java.nio.*;
+
 import javax.media.nativewindow.*;
 import javax.media.nativewindow.x11.*;
 import javax.media.opengl.*;
@@ -47,8 +51,6 @@ import com.jogamp.common.JogampRuntimeException;
 import com.jogamp.common.util.*;
 import com.jogamp.nativewindow.impl.ProxySurface;
 import com.jogamp.nativewindow.impl.x11.*;
-import java.util.Collection;
-import java.util.HashMap;
 
 public class X11GLXDrawableFactory extends GLDrawableFactoryImpl {
   
@@ -70,6 +72,13 @@ public class X11GLXDrawableFactory extends GLDrawableFactoryImpl {
     }
   }
 
+  public static VersionNumber getGLXVersion(X11GraphicsDevice device) {
+    int[] major = new int[1];
+    int[] minor = new int[1];
+    GLXUtil.getGLXVersion(device.getHandle(), major, minor);
+    return new VersionNumber(major[0], minor[0], 0);
+  }
+
   public GLDynamicLookupHelper getGLDynamicLookupHelper(int profile) {
       return x11GLXDynamicLookupHelper;
   }
@@ -125,15 +134,18 @@ public class X11GLXDrawableFactory extends GLDrawableFactoryImpl {
           isGLXVendorATI = GLXUtil.isVendorATI(glXVendorName);
           isGLXVendorNVIDIA = GLXUtil.isVendorNVIDIA(glXVendorName);
       }
-      public AbstractGraphicsDevice getDevice() { return device; }
-      public AbstractGraphicsScreen getScreen() { return screen; }
-      public GLDrawableImpl getDrawable() { return drawable; }
-      public GLContextImpl getContext() { return context; }
-
-      String getGLXVendorName() { return glXVendorName; }
-      boolean isGLXVendorATI() { return isGLXVendorATI; }
-      boolean isGLXVendorNVIDIA() { return isGLXVendorNVIDIA; }
-      VersionNumber getGLXVersion() { return glXVersion; }
+      final public AbstractGraphicsDevice getDevice() { return device; }
+      final public AbstractGraphicsScreen getScreen() { return screen; }
+      final public GLDrawableImpl getDrawable() { return drawable; }
+      final public GLContextImpl getContext() { return context; }
+
+      final String getGLXVendorName() { return glXVendorName; }
+      final boolean isGLXVendorATI() { return isGLXVendorATI; }
+      final boolean isGLXVendorNVIDIA() { return isGLXVendorNVIDIA; }
+      final VersionNumber getGLXVersion() { return glXVersion; }
+      final boolean isGLXVersionGreaterEqualOneThree() {
+        return ( null != glXVersion ) ? glXVersion.compareTo(versionOneThree) >= 0 : false ;
+      }
   }
 
   class SharedResourceImplementation implements SharedResourceRunner.Implementation {
@@ -181,20 +193,18 @@ public class X11GLXDrawableFactory extends GLDrawableFactoryImpl {
                     throw new GLException("Couldn't create shared context for drawable: "+sharedDrawable);
                 }
                 sharedContext.setSynchronized(true);
-                VersionNumber glXVersion;
+                VersionNumber glXVersion = getGLXVersion(sharedDevice);
+                boolean madeCurrent = false;
                 sharedContext.makeCurrent();
                 try {
-                    int[] major = new int[1];
-                    int[] minor = new int[1];
-                    GLXUtil.getGLXVersion(sharedDevice.getHandle(), major, minor);
-                    glXVersion = new VersionNumber(major[0], minor[0], 0);
+                    madeCurrent = sharedContext.isCurrent();
                 } finally {
                     sharedContext.release();
                 }
                 if (DEBUG) {
                     System.err.println("!!! SharedDevice:  " + sharedDevice);
                     System.err.println("!!! SharedScreen:  " + sharedScreen);
-                    System.err.println("!!! SharedContext: " + sharedContext);
+                    System.err.println("!!! SharedContext: " + sharedContext + ", madeCurrent " + madeCurrent);
                     System.err.println("!!! GLX Vendor:    " + glXVendorName);
                     System.err.println("!!! GLX Version:   " + glXVersion
                             + " >= 1.3: " + (glXVersion.compareTo(versionOneThree) >= 0));
@@ -273,15 +283,11 @@ public class X11GLXDrawableFactory extends GLDrawableFactoryImpl {
     return 0;
   }
 
-  protected final VersionNumber getGLXVersion(AbstractGraphicsDevice device) {
-    SharedResourceRunner.Resource sr = sharedResourceRunner.getOrCreateShared(device);
-    if(null!=sr) {
-      return ((SharedResource)sr).getGLXVersion();
-    }
-    return null;
+  SharedResource getOrCreateSharedResource(AbstractGraphicsDevice device) {
+    return (SharedResource) sharedResourceRunner.getOrCreateShared(device);
   }
 
-  protected final String getGLXVendorName(AbstractGraphicsDevice device) {
+  public final String getGLXVendorName(AbstractGraphicsDevice device) {
     SharedResourceRunner.Resource sr = sharedResourceRunner.getOrCreateShared(device);
     if(null!=sr) {
       return ((SharedResource)sr).getGLXVendorName();
@@ -289,7 +295,7 @@ public class X11GLXDrawableFactory extends GLDrawableFactoryImpl {
     return GLXUtil.getVendorName(device.getHandle());
   }
 
-  protected final boolean isGLXVendorATI(AbstractGraphicsDevice device) {
+  public final boolean isGLXVendorATI(AbstractGraphicsDevice device) {
     SharedResourceRunner.Resource sr = sharedResourceRunner.getOrCreateShared(device);
     if(null!=sr) {
       return ((SharedResource)sr).isGLXVendorATI();
@@ -297,7 +303,7 @@ public class X11GLXDrawableFactory extends GLDrawableFactoryImpl {
     return GLXUtil.isVendorATI(device.getHandle());
   }
 
-  protected final boolean isGLXVendorNVIDIA(AbstractGraphicsDevice device) {
+  public final boolean isGLXVendorNVIDIA(AbstractGraphicsDevice device) {
     SharedResourceRunner.Resource sr = sharedResourceRunner.getOrCreateShared(device);
     if(null!=sr) {
       return ((SharedResource)sr).isGLXVendorNVIDIA();
@@ -313,6 +319,10 @@ public class X11GLXDrawableFactory extends GLDrawableFactoryImpl {
     X11Util.shutdown( false, DEBUG );
   }
 
+  protected List/*GLCapabilitiesImmutable*/ getAvailableCapabilitiesImpl(AbstractGraphicsDevice device) {
+    return X11GLXGraphicsConfigurationFactory.getAvailableCapabilities(this, device);
+  }
+
   protected final GLDrawableImpl createOnscreenDrawableImpl(NativeSurface target) {
     if (target == null) {
       throw new IllegalArgumentException("Null target");
@@ -354,9 +364,12 @@ public class X11GLXDrawableFactory extends GLDrawableFactoryImpl {
     return pbufferDrawable;
   }
 
-  public final boolean glXVersionGreaterEqualOneThree(AbstractGraphicsDevice device) {
-      VersionNumber glXVersion = getGLXVersion(device);
-      return ( null != glXVersion ) ? glXVersion.compareTo(versionOneThree) >= 0 : false ;
+  public final boolean isGLXVersionGreaterEqualOneThree(AbstractGraphicsDevice device) {
+    SharedResource sr = (SharedResource) sharedResourceRunner.getOrCreateShared(device);
+    if(null!=sr) {
+      return sr.isGLXVersionGreaterEqualOneThree();
+    }
+    return false;
   }
 
   public final boolean canCreateGLPbuffer(AbstractGraphicsDevice device) {
@@ -366,7 +379,7 @@ public class X11GLXDrawableFactory extends GLDrawableFactoryImpl {
             device = sr.getDevice();
         }
       }
-      return glXVersionGreaterEqualOneThree(device);
+      return isGLXVersionGreaterEqualOneThree(device);
   }
 
   protected final NativeSurface createOffscreenSurfaceImpl(AbstractGraphicsDevice device,
diff --git a/src/jogl/classes/com/jogamp/opengl/impl/x11/glx/X11GLXGraphicsConfiguration.java b/src/jogl/classes/com/jogamp/opengl/impl/x11/glx/X11GLXGraphicsConfiguration.java
index 3dbaab21b..f7779ab28 100644
--- a/src/jogl/classes/com/jogamp/opengl/impl/x11/glx/X11GLXGraphicsConfiguration.java
+++ b/src/jogl/classes/com/jogamp/opengl/impl/x11/glx/X11GLXGraphicsConfiguration.java
@@ -33,10 +33,13 @@
 
 package com.jogamp.opengl.impl.x11.glx;
 
-import com.jogamp.common.nio.PointerBuffer;
+import java.util.ArrayList;
+
 import javax.media.nativewindow.*;
 import javax.media.nativewindow.x11.*;
 import javax.media.opengl.*;
+
+import com.jogamp.common.nio.PointerBuffer;
 import com.jogamp.opengl.impl.*;
 import com.jogamp.nativewindow.impl.x11.*;
 
@@ -44,17 +47,12 @@ public class X11GLXGraphicsConfiguration extends X11GraphicsConfiguration implem
     protected static final boolean DEBUG = Debug.debug("GraphicsConfiguration");
     
     public static final int MAX_ATTRIBS = 128;
-    private long fbConfig;
-    private int  fbConfigID;
     private GLCapabilitiesChooser chooser; 
 
     X11GLXGraphicsConfiguration(X11GraphicsScreen screen, 
-                                GLCapabilitiesImmutable capsChosen, GLCapabilitiesImmutable capsRequested, GLCapabilitiesChooser chooser,
-                                XVisualInfo info, long fbcfg, int fbcfgID) {
-        super(screen, capsChosen, capsRequested, info);
+                                X11GLCapabilities capsChosen, GLCapabilitiesImmutable capsRequested, GLCapabilitiesChooser chooser) {
+        super(screen, capsChosen, capsRequested, capsChosen.getXVisualInfo());
         this.chooser=chooser;
-        fbConfig = fbcfg;
-        fbConfigID = fbcfgID;
     }
 
     static X11GLXGraphicsConfiguration create(GLProfile glp, X11GraphicsScreen x11Screen, int fbcfgID) {
@@ -70,23 +68,23 @@ public class X11GLXGraphicsConfiguration extends X11GraphicsConfiguration implem
       if(null==glp) {
         glp = GLProfile.getDefault(x11Screen.getDevice());
       }
-      GLCapabilitiesImmutable caps = GLXFBConfig2GLCapabilities(glp, display, fbcfg, true, true, true, GLXUtil.isMultisampleAvailable(display));
+      X11GLCapabilities caps = GLXFBConfig2GLCapabilities(glp, display, fbcfg, true, true, true, GLXUtil.isMultisampleAvailable(display));
       if(null==caps) {
           throw new GLException("GLCapabilities null of "+toHexString(fbcfg));
       }
-      XVisualInfo xvi = GLX.glXGetVisualFromFBConfig(display, fbcfg);
-      if(null==xvi) {
-          throw new GLException("XVisualInfo null of "+toHexString(fbcfg));
-      }
-      return new X11GLXGraphicsConfiguration(x11Screen, caps, caps, new DefaultGLCapabilitiesChooser(), xvi, fbcfg, fbcfgID);
+      return new X11GLXGraphicsConfiguration(x11Screen, caps, caps, new DefaultGLCapabilitiesChooser());
     }
 
     public Object clone() {
         return super.clone();
     }
 
-    public long getFBConfig()   { return fbConfig; }
-    public int  getFBConfigID() { return fbConfigID; }
+    public final long getFBConfig()   {
+        return ((X11GLCapabilities)capabilitiesChosen).getFBConfig();
+    }
+    public final int  getFBConfigID() {
+        return ((X11GLCapabilities)capabilitiesChosen).getFBConfigID();
+    }
 
     void updateGraphicsConfiguration() {
         X11GLXGraphicsConfiguration newConfig = (X11GLXGraphicsConfiguration)
@@ -96,8 +94,6 @@ public class X11GLXGraphicsConfiguration extends X11GraphicsConfiguration implem
             // FIXME: setScreen( ... );
             setXVisualInfo(newConfig.getXVisualInfo());
             setChosenCapabilities(newConfig.getChosenCapabilities());
-            fbConfig = newConfig.getFBConfig();
-            fbConfigID = newConfig.getFBConfigID();
             if(DEBUG) {
                 System.err.println("!!! updateGraphicsConfiguration: "+this);
             }
@@ -220,49 +216,63 @@ public class X11GLXGraphicsConfiguration extends X11GraphicsConfiguration implem
     return true;
   }
 
-  static boolean GLXFBConfigDrawableTypeVerify(int val, boolean onscreen, boolean usePBuffer) {
-    boolean res;
+  static int FBCfgDrawableTypeBits(final long display, final long fbcfg) {
+    int val = 0;
 
-    if ( onscreen ) {
-        res = ( 0 != (val & GLX.GLX_WINDOW_BIT) ) ;
-    } else {
-        if ( usePBuffer ) {
-            res = ( 0 != (val & GLX.GLX_PBUFFER_BIT) ) ;
-        } else {
-            res = ( 0 != (val & GLX.GLX_PIXMAP_BIT) ) ;
-        }
-    }
+    int[] tmp = new int[1];
+    int fbtype = glXGetFBConfig(display, fbcfg, GLX.GLX_DRAWABLE_TYPE, tmp, 0);
 
-    return res;
+    if ( 0 != ( fbtype & GLX.GLX_WINDOW_BIT ) ) {
+        val |= GLGraphicsConfigurationUtil.WINDOW_BIT;
+    }
+    if ( 0 != ( fbtype & GLX.GLX_PIXMAP_BIT ) ) {
+        val |= GLGraphicsConfigurationUtil.BITMAP_BIT;
+    }
+    if ( 0 != ( fbtype & GLX.GLX_PBUFFER_BIT ) ) {
+        val |= GLGraphicsConfigurationUtil.PBUFFER_BIT;
+    }
+    return val;
   }
 
-  static GLCapabilitiesImmutable GLXFBConfig2GLCapabilities(GLProfile glp, long display, long fbcfg,
+  static X11GLCapabilities GLXFBConfig2GLCapabilities(GLProfile glp, long display, long fbcfg,
                                                             boolean relaxed, boolean onscreen, boolean usePBuffer,
                                                             boolean isMultisampleAvailable) {
-    int[] tmp = new int[1];
-    int val;
-    val = glXGetFBConfig(display, fbcfg, GLX.GLX_RENDER_TYPE, tmp, 0);
-    if (val != GLX.GLX_RGBA_BIT) {
-      if(DEBUG) {
-        System.err.println("FBConfig ("+toHexString(fbcfg)+") does not support RGBA: "+toHexString(val));
-      }
-      return null;
+    ArrayList bucket = new ArrayList();
+    final int winattrmask = GLGraphicsConfigurationUtil.getWinAttributeBits(onscreen, usePBuffer);
+    if( GLXFBConfig2GLCapabilities(bucket, glp, display, fbcfg, winattrmask, isMultisampleAvailable) ) {
+        return (X11GLCapabilities) bucket.get(0);
+    } else if ( relaxed && GLXFBConfig2GLCapabilities(bucket, glp, display, fbcfg, GLGraphicsConfigurationUtil.ALL_BITS, isMultisampleAvailable) ) {
+        return (X11GLCapabilities) bucket.get(0);
     }
-    GLCapabilities res = new GLCapabilities(glp);
-
-    val = glXGetFBConfig(display, fbcfg, GLX.GLX_DRAWABLE_TYPE, tmp, 0);
-    if(GLXFBConfigDrawableTypeVerify(val, onscreen, usePBuffer)) {
-        res.setOnscreen(onscreen);
-        res.setPBuffer(usePBuffer);
-    } else if(relaxed) {
-        res.setOnscreen( 0 != (val & GLX.GLX_WINDOW_BIT) );
-        res.setPBuffer ( 0 != (val & GLX.GLX_PBUFFER_BIT) );
-    } else {
+    return null;
+  }
+
+  static boolean GLXFBConfig2GLCapabilities(ArrayList capsBucket,
+                                            GLProfile glp, long display, long fbcfg,
+                                            int winattrmask, boolean isMultisampleAvailable) {
+    final int allDrawableTypeBits = FBCfgDrawableTypeBits(display, fbcfg);
+    int drawableTypeBits = winattrmask & allDrawableTypeBits;
+
+    int fbcfgid = X11GLXGraphicsConfiguration.glXFBConfig2FBConfigID(display, fbcfg);
+    XVisualInfo visualInfo = GLX.glXGetVisualFromFBConfig(display, fbcfg);
+    if(null == visualInfo) {
         if(DEBUG) {
-          System.err.println("FBConfig ("+toHexString(fbcfg)+") GLX_DRAWABLE_TYPE does not match: req(onscrn "+onscreen+", pbuffer "+usePBuffer+"), got(onscreen "+( 0 != (val & GLX.GLX_WINDOW_BIT) )+", pbuffer "+( 0 != (val & GLX.GLX_PBUFFER_BIT) )+", pixmap "+( 0 != (val & GLX.GLX_PIXMAP_BIT) )+")");
+            System.err.println("X11GLXGraphicsConfiguration.GLXFBConfig2GLCapabilities: Null XVisualInfo for FBConfigID 0x" + Integer.toHexString(fbcfgid));
         }
-        return null;
+        // onscreen must have an XVisualInfo
+        drawableTypeBits = drawableTypeBits & ~GLGraphicsConfigurationUtil.WINDOW_BIT;
     }
+
+    if( 0 == drawableTypeBits ) {
+        return false;
+    }
+
+    int[] tmp = new int[1];
+    if(GLX.GLX_BAD_ATTRIBUTE == GLX.glXGetFBConfigAttrib(display, fbcfg, GLX.GLX_RENDER_TYPE, tmp, 0)) {
+      return false;
+    }
+
+    GLCapabilities res = new X11GLCapabilities(visualInfo, fbcfg, fbcfgid, glp);
     res.setDoubleBuffered(glXGetFBConfig(display, fbcfg, GLX.GLX_DOUBLEBUFFER,     tmp, 0) != 0);
     res.setStereo        (glXGetFBConfig(display, fbcfg, GLX.GLX_STEREO,           tmp, 0) != 0);
     res.setHardwareAccelerated(glXGetFBConfig(display, fbcfg, GLX.GLX_CONFIG_CAVEAT, tmp, 0) != GLX.GLX_SLOW_CONFIG);
@@ -297,7 +307,8 @@ public class X11GLXGraphicsConfiguration extends X11GraphicsConfiguration implem
     try { 
         res.setPbufferFloatingPointBuffers(glXGetFBConfig(display, fbcfg, GLXExt.GLX_FLOAT_COMPONENTS_NV, tmp, 0) != GL.GL_FALSE);
     } catch (Exception e) {}
-    return res;
+
+    return GLGraphicsConfigurationUtil.addGLCapabilitiesPermutations(capsBucket, res, drawableTypeBits );
   }
 
   private static String glXGetFBConfigErrorCode(int err) {
@@ -352,26 +363,34 @@ public class X11GLXGraphicsConfiguration extends X11GraphicsConfiguration implem
       return res;
   }
 
-  static GLCapabilitiesImmutable XVisualInfo2GLCapabilities(GLProfile glp, long display, XVisualInfo info,
-                                                            boolean onscreen, boolean usePBuffer, boolean isMultisampleEnabled) {
+  static boolean XVisualInfo2GLCapabilities(ArrayList capsBucket,
+                                            GLProfile glp, long display, XVisualInfo info,
+                                            final int winattrmask, boolean isMultisampleEnabled) {
+    final int allDrawableTypeBits = GLGraphicsConfigurationUtil.WINDOW_BIT | GLGraphicsConfigurationUtil.BITMAP_BIT ;
+    final int drawableTypeBits = winattrmask & allDrawableTypeBits;
+
+    if( 0 == drawableTypeBits ) {
+        return false;
+    }
+
     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 null;
+      return false;
     }
     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 null;
+      return false;
     }
-    GLCapabilities res = new GLCapabilities(glp);
-    res.setOnscreen      (onscreen);
-    res.setPBuffer       (usePBuffer);
+
+    GLCapabilities res = new X11GLCapabilities(info, glp);
+
     res.setDoubleBuffered(glXGetConfig(display, info, GLX.GLX_DOUBLEBUFFER,     tmp, 0) != 0);
     res.setStereo        (glXGetConfig(display, info, GLX.GLX_STEREO,           tmp, 0) != 0);
     // Note: use of hardware acceleration is determined by
@@ -393,7 +412,8 @@ public class X11GLXGraphicsConfiguration extends X11GraphicsConfiguration implem
       res.setSampleBuffers(glXGetConfig(display, info, GLX.GLX_SAMPLE_BUFFERS, tmp, 0) != 0);
       res.setNumSamples   (glXGetConfig(display, info, GLX.GLX_SAMPLES,        tmp, 0));
     }
-    return res;
+
+    return GLGraphicsConfigurationUtil.addGLCapabilitiesPermutations(capsBucket, res, drawableTypeBits);
   }
 
   private static String glXGetConfigErrorCode(int err) {
@@ -417,16 +437,8 @@ public class X11GLXGraphicsConfiguration extends X11GraphicsConfiguration implem
     return tmp[tmp_offset];
   }
 
-  static String toHexString(int val) {
-    return "0x"+Integer.toHexString(val);
-  }
-
-  static String toHexString(long val) {
-    return "0x"+Long.toHexString(val);
-  }
-
   public String toString() {
-    return "X11GLXGraphicsConfiguration["+getScreen()+", visualID " + toHexString(getVisualID()) + ", fbConfigID " + toHexString(fbConfigID) + 
+    return "X11GLXGraphicsConfiguration["+getScreen()+", visualID " + toHexString(getVisualID()) + ", fbConfigID " + toHexString(getFBConfigID()) +
                                         ",\n\trequested " + getRequestedCapabilities()+
                                         ",\n\tchosen    " + getChosenCapabilities()+
                                         "]";
diff --git a/src/jogl/classes/com/jogamp/opengl/impl/x11/glx/X11GLXGraphicsConfigurationFactory.java b/src/jogl/classes/com/jogamp/opengl/impl/x11/glx/X11GLXGraphicsConfigurationFactory.java
index 88ed852d5..b391dc948 100644
--- a/src/jogl/classes/com/jogamp/opengl/impl/x11/glx/X11GLXGraphicsConfigurationFactory.java
+++ b/src/jogl/classes/com/jogamp/opengl/impl/x11/glx/X11GLXGraphicsConfigurationFactory.java
@@ -39,12 +39,13 @@ import javax.media.nativewindow.AbstractGraphicsScreen;
 import javax.media.nativewindow.CapabilitiesChooser;
 import javax.media.nativewindow.CapabilitiesImmutable;
 import javax.media.nativewindow.GraphicsConfigurationFactory;
-import javax.media.nativewindow.NativeWindowException;
 import javax.media.nativewindow.x11.X11GraphicsScreen;
+import javax.media.nativewindow.x11.X11GraphicsDevice;
 import javax.media.opengl.DefaultGLCapabilitiesChooser;
 import javax.media.opengl.GLCapabilities;
 import javax.media.opengl.GLCapabilitiesChooser;
 import javax.media.opengl.GLCapabilitiesImmutable;
+import javax.media.opengl.GLDrawableFactory;
 import javax.media.opengl.GLException;
 import javax.media.opengl.GLProfile;
 
@@ -53,7 +54,12 @@ import com.jogamp.nativewindow.impl.x11.X11Lib;
 import com.jogamp.nativewindow.impl.x11.X11Util;
 import com.jogamp.nativewindow.impl.x11.XVisualInfo;
 import com.jogamp.opengl.impl.Debug;
-import com.jogamp.opengl.impl.GLGraphicsConfigurationFactoryImpl;
+import com.jogamp.opengl.impl.GLGraphicsConfigurationFactory;
+import com.jogamp.opengl.impl.GLGraphicsConfigurationUtil;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
 
 
 /** Subclass of GraphicsConfigurationFactory used when non-AWT toolkits
@@ -61,8 +67,9 @@ import com.jogamp.opengl.impl.GLGraphicsConfigurationFactoryImpl;
     to this one to change the accepted and returned types of the
     GraphicsDevice and GraphicsConfiguration abstractions. */
 
-public class X11GLXGraphicsConfigurationFactory extends GLGraphicsConfigurationFactoryImpl {
+public class X11GLXGraphicsConfigurationFactory extends GLGraphicsConfigurationFactory {
     protected static final boolean DEBUG = Debug.debug("GraphicsConfiguration");
+    static X11GLCapabilities.XVisualIDComparator XVisualIDComparator = new X11GLCapabilities.XVisualIDComparator();
 
     X11GLXGraphicsConfigurationFactory() {
         GraphicsConfigurationFactory.registerFactory(javax.media.nativewindow.x11.X11GraphicsDevice.class, this);
@@ -89,6 +96,86 @@ public class X11GLXGraphicsConfigurationFactory extends GLGraphicsConfigurationF
                                                  (GLCapabilitiesChooser)chooser, (X11GraphicsScreen)absScreen);
     }
 
+    protected static List/*<X11GLCapabilities>*/ getAvailableCapabilities(X11GLXDrawableFactory factory, AbstractGraphicsDevice device) {
+        X11GLXDrawableFactory.SharedResource sharedResource = factory.getOrCreateSharedResource(device);
+        if(null == sharedResource) {
+            throw new GLException("Shared resource for device n/a: "+device);
+        }
+        X11GraphicsScreen sharedScreen = (X11GraphicsScreen) sharedResource.getScreen();
+        X11GLXDrawable sharedDrawable = (X11GLXDrawable) sharedResource.getDrawable();
+        GLCapabilitiesImmutable capsChosen = sharedDrawable.getChosenGLCapabilities();
+        GLProfile glp = capsChosen.getGLProfile();
+
+        List/*GLCapabilitiesImmutable*/ availableCaps = null;
+
+        if( sharedResource.isGLXVersionGreaterEqualOneThree() ) {
+            availableCaps = getAvailableGLCapabilitiesFBConfig(sharedScreen, glp);
+        }
+        if( null == availableCaps || 0 == availableCaps.size() ) {
+            availableCaps = getAvailableGLCapabilitiesXVisual(sharedScreen, glp);
+        }
+        if( null != availableCaps ) {
+            Collections.sort(availableCaps, XVisualIDComparator);
+        }
+        return availableCaps;
+    }
+
+    static List/*<X11GLCapabilities>*/ getAvailableGLCapabilitiesFBConfig(X11GraphicsScreen x11Screen, GLProfile glProfile) {
+        PointerBuffer fbcfgsL = null;
+
+        // Utilizing FBConfig
+        //
+        AbstractGraphicsDevice absDevice = x11Screen.getDevice();
+        long display = absDevice.getHandle();
+
+        int screen = x11Screen.getIndex();
+        boolean isMultisampleAvailable = GLXUtil.isMultisampleAvailable(display);
+        int[] count = { -1 };
+        ArrayList availableCaps = new ArrayList();
+
+        fbcfgsL = GLX.glXChooseFBConfig(display, screen, null, 0, count, 0);
+        if (fbcfgsL == null || fbcfgsL.limit()<=0) {
+            if(DEBUG) {
+                System.err.println("X11GLXGraphicsConfiguration.getAvailableGLCapabilitiesFBConfig: Failed glXChooseFBConfig ("+x11Screen+"): "+fbcfgsL+", "+count[0]);
+            }
+            return null;
+        }
+        for (int i = 0; i < fbcfgsL.limit(); i++) {
+            if( !X11GLXGraphicsConfiguration.GLXFBConfig2GLCapabilities(availableCaps, glProfile, display, fbcfgsL.get(i), GLGraphicsConfigurationUtil.ALL_BITS, isMultisampleAvailable) ) {
+                if(DEBUG) {
+                    System.err.println("X11GLXGraphicsConfiguration.getAvailableGLCapabilitiesFBConfig: FBConfig invalid (2): ("+x11Screen+"): fbcfg: "+toHexString(fbcfgsL.get(i)));
+                }
+            }
+        }
+        return availableCaps;
+    }
+
+    static List/*<X11GLCapabilities>*/ getAvailableGLCapabilitiesXVisual(X11GraphicsScreen x11Screen, GLProfile glProfile) {
+        AbstractGraphicsDevice absDevice = x11Screen.getDevice();
+        long display = absDevice.getHandle();
+
+        int screen = x11Screen.getIndex();
+        boolean isMultisampleAvailable = GLXUtil.isMultisampleAvailable(display);
+
+        int[] count = new int[1];
+        XVisualInfo template = XVisualInfo.create();
+        template.setScreen(screen);
+        XVisualInfo[] infos = X11Util.XGetVisualInfo(display, X11Lib.VisualScreenMask, template, count, 0);
+        if (infos == null || infos.length<1) {
+            throw new GLException("Error while enumerating available XVisualInfos");
+        }
+        ArrayList availableCaps = new ArrayList();
+        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()));
+                }
+            }
+        }
+        return availableCaps;
+    }
+
+
     static X11GLXGraphicsConfiguration chooseGraphicsConfigurationStatic(GLCapabilitiesImmutable capsChosen,
                                                                          GLCapabilitiesImmutable capsReq,
                                                                          GLCapabilitiesChooser chooser,
@@ -100,18 +187,16 @@ public class X11GLXGraphicsConfigurationFactory extends GLGraphicsConfigurationF
         if (capsChosen == null) {
             capsChosen = new GLCapabilities(null);
         }
+        X11GraphicsDevice x11Device = (X11GraphicsDevice) x11Screen.getDevice();
+        X11GLXDrawableFactory factory = (X11GLXDrawableFactory) GLDrawableFactory.getDesktopFactory();
 
-        if(!capsChosen.isOnscreen() && capsChosen.getDoubleBuffered()) {
-            // OFFSCREEN !DOUBLE_BUFFER // FIXME DBLBUFOFFSCRN
-            GLCapabilities caps2 = (GLCapabilities) capsChosen.cloneMutable();
-            caps2.setDoubleBuffered(false);
-            capsChosen = caps2;
-        }
-
+        capsChosen = GLGraphicsConfigurationUtil.fixGLCapabilities( capsChosen, factory.canCreateGLPbuffer(x11Device) );
         boolean usePBuffer = capsChosen.isPBuffer();
     
-        X11GLXGraphicsConfiguration res;
-        res = chooseGraphicsConfigurationFBConfig(capsChosen, capsReq, chooser, x11Screen);
+        X11GLXGraphicsConfiguration res = null;
+        if( factory.isGLXVersionGreaterEqualOneThree(x11Device) ) {
+            res = chooseGraphicsConfigurationFBConfig(capsChosen, capsReq, chooser, x11Screen);
+        }
         if(null==res) {
             if(usePBuffer) {
                 throw new GLException("Error: Couldn't create X11GLXGraphicsConfiguration based on FBConfig for "+capsChosen);
@@ -139,14 +224,8 @@ public class X11GLXGraphicsConfigurationFactory extends GLGraphicsConfigurationF
             }
             return null;
         }
-        XVisualInfo visualInfo = GLX.glXGetVisualFromFBConfig(display, fbcfg);
-        if (visualInfo==null) {
-            System.err.println("X11GLXGraphicsConfiguration.chooseGraphicsConfigurationFBConfig: Failed glXGetVisualFromFBConfig ("+x11Screen+", "+toHexString(fbcfg)+")");
-            return null;
-        }
-        GLCapabilitiesImmutable caps = X11GLXGraphicsConfiguration.GLXFBConfig2GLCapabilities(glp, display, fbcfg, true, true, true, GLXUtil.isMultisampleAvailable(display));
-        return new X11GLXGraphicsConfiguration(x11Screen, caps, caps, new DefaultGLCapabilitiesChooser(), visualInfo, fbcfg, fbID);
-
+        X11GLCapabilities caps = X11GLXGraphicsConfiguration.GLXFBConfig2GLCapabilities(glp, display, fbcfg, true, true, true, GLXUtil.isMultisampleAvailable(display));
+        return new X11GLXGraphicsConfiguration(x11Screen, caps, caps, new DefaultGLCapabilitiesChooser());
     }
 
     private static X11GLXGraphicsConfiguration chooseGraphicsConfigurationFBConfig(GLCapabilitiesImmutable capsChosen,
@@ -155,10 +234,7 @@ public class X11GLXGraphicsConfigurationFactory extends GLGraphicsConfigurationF
                                                                                    X11GraphicsScreen x11Screen) {
         long recommendedFBConfig = -1;
         int recommendedIndex = -1;
-        int retFBID=-1;
-        GLCapabilitiesImmutable[] availableCaps = null;
         PointerBuffer fbcfgsL = null;
-        XVisualInfo retXVisualInfo = null;
         GLProfile glProfile = capsChosen.getGLProfile();
         boolean onscreen = capsChosen.isOnscreen();
         boolean usePBuffer = capsChosen.isPBuffer();
@@ -172,39 +248,39 @@ public class X11GLXGraphicsConfigurationFactory extends GLGraphicsConfigurationF
         boolean isMultisampleAvailable = GLXUtil.isMultisampleAvailable(display);
         int[] attribs = X11GLXGraphicsConfiguration.GLCapabilities2AttribList(capsChosen, true, isMultisampleAvailable, display, screen);
         int[] count = { -1 };
+        ArrayList/*<X11GLCapabilities>*/ availableCaps = new ArrayList();
+        final int winattrmask = GLGraphicsConfigurationUtil.getWinAttributeBits(onscreen, usePBuffer);
 
         // 1st choice: get GLCapabilities based on users GLCapabilities setting recommendedIndex as preferred choice
         fbcfgsL = GLX.glXChooseFBConfig(display, screen, attribs, 0, count, 0);
         if (fbcfgsL != null && fbcfgsL.limit()>0) {
-            availableCaps = new GLCapabilitiesImmutable[fbcfgsL.limit()];
             for (int i = 0; i < fbcfgsL.limit(); i++) {
-                if( !X11GLXGraphicsConfiguration.GLXFBConfigValid( display, fbcfgsL.get(i) ) ) {
+                if( !X11GLXGraphicsConfiguration.GLXFBConfig2GLCapabilities(availableCaps, glProfile, display, fbcfgsL.get(i), winattrmask, isMultisampleAvailable) ) {
                     if(DEBUG) {
                         System.err.println("X11GLXGraphicsConfiguration.chooseGraphicsConfigurationFBConfig: FBConfig invalid (1): ("+x11Screen+","+capsChosen+"): fbcfg: "+toHexString(fbcfgsL.get(i)));
                     }
-                } else {
-                    availableCaps[i] = X11GLXGraphicsConfiguration.GLXFBConfig2GLCapabilities(glProfile, display, fbcfgsL.get(i),
-                                                                                     false, onscreen, usePBuffer, isMultisampleAvailable);
                 }
             }
-            if(availableCaps[0]!=null) {
+            if(availableCaps.size() > 0) {
                 recommendedFBConfig = fbcfgsL.get(0);
                 recommendedIndex=0;
                 if (DEBUG) {
                     System.err.println("!!! glXChooseFBConfig recommended fbcfg " + toHexString(recommendedFBConfig) + ", idx " + recommendedIndex);
                     System.err.println("!!! user  caps " + capsChosen);
-                    System.err.println("!!! fbcfg caps " + availableCaps[recommendedIndex]);
-                }
-            } else {
-                if (DEBUG) {
-                    System.err.println("!!! glXChooseFBConfig no caps for recommended fbcfg " + toHexString(recommendedFBConfig));
-                    System.err.println("!!! user  caps " + capsChosen);
+                    System.err.println("!!! fbcfg caps " + availableCaps.get(recommendedIndex));
                 }
+            } else if (DEBUG) {
+                System.err.println("!!! glXChooseFBConfig no caps for recommended fbcfg " + toHexString(fbcfgsL.get(0)));
+                System.err.println("!!! user  caps " + capsChosen);
             }
         }
 
         // 2nd choice: get all GLCapabilities available, no preferred recommendedIndex available
-        if(null == availableCaps) {
+        if( 0 == availableCaps.size() ) {
+            // reset ..
+            recommendedFBConfig = -1;
+            recommendedIndex = -1;
+
             fbcfgsL = GLX.glXChooseFBConfig(display, screen, null, 0, count, 0);
             if (fbcfgsL == null || fbcfgsL.limit()<=0) {
                 if(DEBUG) {
@@ -213,19 +289,14 @@ public class X11GLXGraphicsConfigurationFactory extends GLGraphicsConfigurationF
                 return null;
             }
 
-            availableCaps = new GLCapabilitiesImmutable[fbcfgsL.limit()];
             for (int i = 0; i < fbcfgsL.limit(); i++) {
-                if( !X11GLXGraphicsConfiguration.GLXFBConfigValid( display, fbcfgsL.get(i) ) ) {
+                if( !X11GLXGraphicsConfiguration.GLXFBConfig2GLCapabilities(availableCaps, glProfile, display, fbcfgsL.get(i), winattrmask, isMultisampleAvailable) ) {
                     if(DEBUG) {
                         System.err.println("X11GLXGraphicsConfiguration.chooseGraphicsConfigurationFBConfig: FBConfig invalid (2): ("+x11Screen+"): fbcfg: "+toHexString(fbcfgsL.get(i)));
                     }
-                } else {
-                    availableCaps[i] = X11GLXGraphicsConfiguration.GLXFBConfig2GLCapabilities(glProfile, display, fbcfgsL.get(i),
-                                                                                     false, onscreen, usePBuffer, isMultisampleAvailable);
                 }
             }
         }
-
         int chosenIndex = chooseCapabilities(chooser, capsChosen, availableCaps, recommendedIndex);
         if ( 0 > chosenIndex ) {
             if (DEBUG) {
@@ -233,20 +304,9 @@ public class X11GLXGraphicsConfigurationFactory extends GLGraphicsConfigurationF
             }
             return null;
         }
-        retFBID = X11GLXGraphicsConfiguration.glXFBConfig2FBConfigID(display, fbcfgsL.get(chosenIndex));
+        X11GLCapabilities chosenCaps = (X11GLCapabilities) availableCaps.get(chosenIndex);
 
-        retXVisualInfo = GLX.glXGetVisualFromFBConfig(display, fbcfgsL.get(chosenIndex));
-        if (retXVisualInfo==null) {
-            if(DEBUG) {
-                System.err.println("X11GLXGraphicsConfiguration.chooseGraphicsConfigurationFBConfig: Failed glXGetVisualFromFBConfig ("+x11Screen+", "+fbcfgsL.get(chosenIndex) +" (Continue: "+(false==availableCaps[chosenIndex].isOnscreen())+"):\n\t"+availableCaps[chosenIndex]);
-            }
-            if(availableCaps[chosenIndex].isOnscreen()) {
-                // Onscreen drawables shall have a XVisual ..
-                return null;
-            }
-        }
-
-        return new X11GLXGraphicsConfiguration(x11Screen, availableCaps[chosenIndex], capsReq, chooser, retXVisualInfo, fbcfgsL.get(chosenIndex), retFBID);
+        return new X11GLXGraphicsConfiguration(x11Screen, chosenCaps, capsReq, chooser);
     }
 
     private static X11GLXGraphicsConfiguration chooseGraphicsConfigurationXVisual(GLCapabilitiesImmutable capsChosen,
@@ -257,15 +317,10 @@ public class X11GLXGraphicsConfigurationFactory extends GLGraphicsConfigurationF
             chooser = new DefaultGLCapabilitiesChooser();
         }
 
-        // Until we have a rock-solid visual selection algorithm written
-        // in pure Java, we're going to provide the underlying window
-        // system's selection to the chooser as a hint
-
         GLProfile glProfile = capsChosen.getGLProfile();
-        boolean onscreen = capsChosen.isOnscreen();
-        GLCapabilitiesImmutable[] availableCaps = null;
+        final int winattrmask = GLGraphicsConfigurationUtil.getWinAttributeBits(capsChosen.isOnscreen(), false /* pbuffer */);
+        ArrayList availableCaps = new ArrayList();
         int recommendedIndex = -1;
-        XVisualInfo retXVisualInfo = null;
 
         AbstractGraphicsDevice absDevice = x11Screen.getDevice();
         long display = absDevice.getHandle();
@@ -273,8 +328,8 @@ public class X11GLXGraphicsConfigurationFactory extends GLGraphicsConfigurationF
         int screen = x11Screen.getIndex();
         boolean isMultisampleAvailable = GLXUtil.isMultisampleAvailable(display);
         int[] attribs = X11GLXGraphicsConfiguration.GLCapabilities2AttribList(capsChosen, false, isMultisampleAvailable, display, screen);
-        XVisualInfo[] infos = null;
 
+        // 1st choice: get GLCapabilities based on users GLCapabilities setting recommendedIndex as preferred choice
         XVisualInfo recommendedVis = GLX.glXChooseVisual(display, screen, attribs, 0);
         if (DEBUG) {
             System.err.print("!!! glXChooseVisual recommended ");
@@ -284,21 +339,29 @@ public class X11GLXGraphicsConfigurationFactory extends GLGraphicsConfigurationF
                 System.err.println("visual id " + toHexString(recommendedVis.getVisualid()));
             }
         }
+
+        // 2nd choice: get all GLCapabilities available, preferred recommendedIndex might be available if 1st choice was successful
         int[] count = new int[1];
         XVisualInfo template = XVisualInfo.create();
         template.setScreen(screen);
-        infos = X11Util.XGetVisualInfo(display, X11Lib.VisualScreenMask, template, count, 0);
+        XVisualInfo[] infos = X11Util.XGetVisualInfo(display, X11Lib.VisualScreenMask, template, count, 0);
         if (infos == null || infos.length<1) {
             throw new GLException("Error while enumerating available XVisualInfos");
         }
-        availableCaps = new GLCapabilitiesImmutable[infos.length];
+
         for (int i = 0; i < infos.length; i++) {
-            availableCaps[i] = X11GLXGraphicsConfiguration.XVisualInfo2GLCapabilities(glProfile, display, infos[i], onscreen, false, isMultisampleAvailable);
-            // Attempt to find the visual chosenIndex by glXChooseVisual
-            if (recommendedVis != null && recommendedVis.getVisualid() == infos[i].getVisualid()) {
-                recommendedIndex = i;
+            if( !X11GLXGraphicsConfiguration.XVisualInfo2GLCapabilities(availableCaps, glProfile, display, infos[i], winattrmask, isMultisampleAvailable) ) {
+                if(DEBUG) {
+                    System.err.println("X11GLXGraphicsConfiguration.getAvailableGLCapabilitiesXVisual: XVisual invalid: ("+x11Screen+"): fbcfg: "+toHexString(infos[i].getVisualid()));
+                }
+            } else {
+                // Attempt to find the visual chosenIndex by glXChooseVisual
+                if (recommendedVis != null && recommendedVis.getVisualid() == infos[i].getVisualid()) {
+                    recommendedIndex = availableCaps.size() - 1;
+                }
             }
         }
+
         int chosenIndex = chooseCapabilities(chooser, capsChosen, availableCaps, recommendedIndex);
         if ( 0 > chosenIndex ) {
             if (DEBUG) {
@@ -306,17 +369,9 @@ public class X11GLXGraphicsConfigurationFactory extends GLGraphicsConfigurationF
             }
             return null;
         }
+        X11GLCapabilities chosenCaps = (X11GLCapabilities) availableCaps.get(chosenIndex);
 
-        retXVisualInfo = XVisualInfo.create(infos[chosenIndex]);
-        return new X11GLXGraphicsConfiguration(x11Screen, availableCaps[chosenIndex], capsReq, chooser, retXVisualInfo, 0, -1);
-    }
-
-    static String toHexString(int val) {
-        return "0x"+Integer.toHexString(val);
-    }
-
-    static String toHexString(long val) {
-        return "0x"+Long.toHexString(val);
+        return new X11GLXGraphicsConfiguration(x11Screen, chosenCaps, capsReq, chooser);
     }
 
 }
diff --git a/src/jogl/classes/com/jogamp/opengl/impl/x11/glx/awt/X11AWTGLXGraphicsConfigurationFactory.java b/src/jogl/classes/com/jogamp/opengl/impl/x11/glx/awt/X11AWTGLXGraphicsConfigurationFactory.java
index 51f9f53cc..898a8a658 100644
--- a/src/jogl/classes/com/jogamp/opengl/impl/x11/glx/awt/X11AWTGLXGraphicsConfigurationFactory.java
+++ b/src/jogl/classes/com/jogamp/opengl/impl/x11/glx/awt/X11AWTGLXGraphicsConfigurationFactory.java
@@ -44,7 +44,7 @@ import com.jogamp.opengl.impl.*;
 import com.jogamp.nativewindow.impl.jawt.x11.*;
 import com.jogamp.nativewindow.impl.x11.*;
 
-public class X11AWTGLXGraphicsConfigurationFactory extends GLGraphicsConfigurationFactoryImpl {
+public class X11AWTGLXGraphicsConfigurationFactory extends GLGraphicsConfigurationFactory {
     protected static final boolean DEBUG = Debug.debug("GraphicsConfiguration");
 
     public X11AWTGLXGraphicsConfigurationFactory() {