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

5 files changed, 238 insertions, 95 deletions

diff --git a/src/jogl/classes/javax/media/opengl/DefaultGLCapabilitiesChooser.java b/src/jogl/classes/javax/media/opengl/DefaultGLCapabilitiesChooser.java
index 695fad5a9..ecba18147 100644
--- a/src/jogl/classes/javax/media/opengl/DefaultGLCapabilitiesChooser.java
+++ b/src/jogl/classes/javax/media/opengl/DefaultGLCapabilitiesChooser.java
@@ -42,6 +42,7 @@ package javax.media.opengl;
 
 import javax.media.nativewindow.NativeWindowException;
 import com.jogamp.opengl.impl.Debug;
+import java.util.List;
 import javax.media.nativewindow.CapabilitiesImmutable;
 
 /** <P> The default implementation of the {@link
@@ -85,38 +86,40 @@ import javax.media.nativewindow.CapabilitiesImmutable;
 public class DefaultGLCapabilitiesChooser implements GLCapabilitiesChooser {
   private static final boolean DEBUG = Debug.debug("CapabilitiesChooser");
 
-  public int chooseCapabilities(CapabilitiesImmutable desired,
-                                CapabilitiesImmutable[] available,
-                                int windowSystemRecommendedChoice) {
-    GLCapabilitiesImmutable _desired = (GLCapabilitiesImmutable) desired;
-    GLCapabilitiesImmutable[] _available = (GLCapabilitiesImmutable[]) available;
-    int availnum = 0;
-
-    for (int i = 0; i < _available.length; i++) {
-      if(null != _available[i]) { availnum++; }
+  public int chooseCapabilities(final CapabilitiesImmutable desired,
+                                final List /*<CapabilitiesImmutable>*/ available,
+                                final int windowSystemRecommendedChoice) {
+    if ( null == desired ) {
+      throw new NativeWindowException("Null desired capabilities");
+    }
+    if ( 0 == available.size() ) {
+      throw new NativeWindowException("Empty available capabilities");
     }
 
+    final GLCapabilitiesImmutable gldes = (GLCapabilitiesImmutable) desired;
+    final int availnum = available.size();
+
     if (DEBUG) {
-      System.err.println("Desired: " + _desired);
-      System.err.println("Available: Valid " + availnum + "/" + _available.length);
-      for (int i = 0; i < _available.length; i++) {
-        System.err.println(i + ": " + _available[i]);
+      System.err.println("Desired: " + gldes);
+      System.err.println("Available: " + availnum);
+      for (int i = 0; i < available.size(); i++) {
+        System.err.println(i + ": " + available.get(i));
       }
       System.err.println("Window system's recommended choice: " + windowSystemRecommendedChoice);
     }
 
     if (windowSystemRecommendedChoice >= 0 &&
-        windowSystemRecommendedChoice < _available.length &&
-        _available[windowSystemRecommendedChoice] != null) {
+        windowSystemRecommendedChoice < availnum &&
+        null != available.get(windowSystemRecommendedChoice)) {
       if (DEBUG) {
         System.err.println("Choosing window system's recommended choice of " + windowSystemRecommendedChoice);
-        System.err.println(_available[windowSystemRecommendedChoice]);
+        System.err.println(available.get(windowSystemRecommendedChoice));
       }
       return windowSystemRecommendedChoice;
     }
 
     // Create score array
-    int[] scores = new int[_available.length];
+    int[] scores = new int[availnum];
     int NO_SCORE = -9999999;
     int DOUBLE_BUFFER_MISMATCH_PENALTY = 1000;
     int STENCIL_MISMATCH_PENALTY = 500;
@@ -131,18 +134,18 @@ public class DefaultGLCapabilitiesChooser implements GLCapabilitiesChooser {
       scores[i] = NO_SCORE;
     }
     // Compute score for each
-    for (int i = 0; i < scores.length; i++) {
-      GLCapabilitiesImmutable cur = _available[i];
+    for (int i = 0; i < availnum; i++) {
+      GLCapabilitiesImmutable cur = (GLCapabilitiesImmutable) available.get(i);
       if (cur == null) {
         continue;
       }
-      if (_desired.isOnscreen() != cur.isOnscreen()) {
+      if (gldes.isOnscreen() != cur.isOnscreen()) {
         continue;
       }
-      if (!_desired.isOnscreen() && _desired.isPBuffer() && !cur.isPBuffer()) {
+      if (!gldes.isOnscreen() && gldes.isPBuffer() && !cur.isPBuffer()) {
         continue; // only skip if requested Offscreen && PBuffer, but no PBuffer available
       }
-      if (_desired.getStereo() != cur.getStereo()) {
+      if (gldes.getStereo() != cur.getStereo()) {
         continue;
       }
       int score = 0;
@@ -150,20 +153,20 @@ public class DefaultGLCapabilitiesChooser implements GLCapabilitiesChooser {
       // (Note that this decides the direction of all other penalties)
       score += (COLOR_MISMATCH_PENALTY_SCALE *
                 ((cur.getRedBits() + cur.getGreenBits() + cur.getBlueBits() + cur.getAlphaBits()) -
-                 (_desired.getRedBits() + _desired.getGreenBits() + _desired.getBlueBits() + _desired.getAlphaBits())));
+                 (gldes.getRedBits() + gldes.getGreenBits() + gldes.getBlueBits() + gldes.getAlphaBits())));
       // Compute difference in depth buffer depth
       score += (DEPTH_MISMATCH_PENALTY_SCALE * sign(score) * 
-                Math.abs(cur.getDepthBits() - _desired.getDepthBits()));
+                Math.abs(cur.getDepthBits() - gldes.getDepthBits()));
       // Compute difference in accumulation buffer depth
       score += (ACCUM_MISMATCH_PENALTY_SCALE * sign(score) *
                 Math.abs((cur.getAccumRedBits() + cur.getAccumGreenBits() + cur.getAccumBlueBits() + cur.getAccumAlphaBits()) -
-                         (_desired.getAccumRedBits() + _desired.getAccumGreenBits() + _desired.getAccumBlueBits() + _desired.getAccumAlphaBits())));
+                         (gldes.getAccumRedBits() + gldes.getAccumGreenBits() + gldes.getAccumBlueBits() + gldes.getAccumAlphaBits())));
       // Compute difference in stencil bits
-      score += STENCIL_MISMATCH_PENALTY_SCALE * sign(score) * (cur.getStencilBits() - _desired.getStencilBits());
-      if (cur.getDoubleBuffered() != _desired.getDoubleBuffered()) {
+      score += STENCIL_MISMATCH_PENALTY_SCALE * sign(score) * (cur.getStencilBits() - gldes.getStencilBits());
+      if (cur.getDoubleBuffered() != gldes.getDoubleBuffered()) {
         score += sign(score) * DOUBLE_BUFFER_MISMATCH_PENALTY;
       }
-      if ((_desired.getStencilBits() > 0) && (cur.getStencilBits() == 0)) {
+      if ((gldes.getStencilBits() > 0) && (cur.getStencilBits() == 0)) {
         score += sign(score) * STENCIL_MISMATCH_PENALTY;
       }
       scores[i] = score;
@@ -172,12 +175,12 @@ public class DefaultGLCapabilitiesChooser implements GLCapabilitiesChooser {
     // non-hardware-accelerated visuals out
     boolean gotHW = false;
     int maxAbsoluteHWScore = 0;
-    for (int i = 0; i < scores.length; i++) {
+    for (int i = 0; i < availnum; i++) {
       int score = scores[i];
       if (score == NO_SCORE) {
         continue;
       }
-      GLCapabilitiesImmutable cur = _available[i];
+      GLCapabilitiesImmutable cur = (GLCapabilitiesImmutable) available.get(i);
       if (cur.getHardwareAccelerated()) {
         int absScore = Math.abs(score);
         if (!gotHW ||
@@ -188,12 +191,12 @@ public class DefaultGLCapabilitiesChooser implements GLCapabilitiesChooser {
       }
     }
     if (gotHW) {
-      for (int i = 0; i < scores.length; i++) {
+      for (int i = 0; i < availnum; i++) {
         int score = scores[i];
         if (score == NO_SCORE) {
           continue;
         }
-        GLCapabilitiesImmutable cur = _available[i];
+        GLCapabilitiesImmutable cur = (GLCapabilitiesImmutable) available.get(i);
         if (!cur.getHardwareAccelerated()) {
           if (score <= 0) {
             score -= maxAbsoluteHWScore;
@@ -207,7 +210,7 @@ public class DefaultGLCapabilitiesChooser implements GLCapabilitiesChooser {
 
     if (DEBUG) {
       System.err.print("Scores: [");
-      for (int i = 0; i < _available.length; i++) {
+      for (int i = 0; i < availnum; i++) {
         if (i > 0) {
           System.err.print(",");
         }
@@ -219,7 +222,7 @@ public class DefaultGLCapabilitiesChooser implements GLCapabilitiesChooser {
     // Ready to select. Choose score closest to 0. 
     int scoreClosestToZero = NO_SCORE;
     int chosenIndex = -1;
-    for (int i = 0; i < scores.length; i++) {
+    for (int i = 0; i < availnum; i++) {
       int score = scores[i];
       if (score == NO_SCORE) {
         continue;
@@ -238,7 +241,7 @@ public class DefaultGLCapabilitiesChooser implements GLCapabilitiesChooser {
     if (DEBUG) {
       System.err.println("Chosen index: " + chosenIndex);
       System.err.println("Chosen capabilities:");
-      System.err.println(_available[chosenIndex]);
+      System.err.println(available.get(chosenIndex));
     }
 
     return chosenIndex;
@@ -250,4 +253,5 @@ public class DefaultGLCapabilitiesChooser implements GLCapabilitiesChooser {
     }
     return 1;
   }
+
 }
diff --git a/src/jogl/classes/javax/media/opengl/GLCapabilities.java b/src/jogl/classes/javax/media/opengl/GLCapabilities.java
index 82f83dc82..1ae9e40aa 100644
--- a/src/jogl/classes/javax/media/opengl/GLCapabilities.java
+++ b/src/jogl/classes/javax/media/opengl/GLCapabilities.java
@@ -143,6 +143,56 @@ public class GLCapabilities extends Capabilities implements Cloneable, GLCapabil
     return res;
   }
 
+  /** comparing hw/sw, stereo, multisample, stencil, RGBA and depth only */
+  public int compareTo(Object o) {
+    if ( ! ( o instanceof GLCapabilities ) ) {
+        Class c = (null != o) ? o.getClass() : null ;
+        throw new ClassCastException("Not a GLCapabilities object: " + c);
+    }
+
+    final GLCapabilities caps = (GLCapabilities) o;
+
+    if(hardwareAccelerated && !caps.hardwareAccelerated) {
+        return 1;
+    } else if(!hardwareAccelerated && caps.hardwareAccelerated) {
+        return -1;
+    }
+
+    if(stereo && !caps.stereo) {
+        return 1;
+    } else if(!stereo && caps.stereo) {
+        return -1;
+    }
+
+    final int ms = sampleBuffers ? numSamples : 0;
+    final int xms = caps.sampleBuffers ? caps.numSamples : 0;
+
+    if(ms > xms) {
+        return 1;
+    } else if( ms < xms ) {
+        return -1;
+    }
+
+    if(stencilBits > caps.stencilBits) {
+        return 1;
+    } else if(stencilBits < caps.stencilBits) {
+        return -1;
+    }
+
+    final int sc = super.compareTo(caps); // RGBA
+    if(0 != sc) {
+        return sc;
+    }
+
+    if(depthBits > caps.depthBits) {
+        return 1;
+    } else if(depthBits < caps.depthBits) {
+        return -1;
+    }
+
+    return 0; // they are equal: hw/sw, stereo, multisample, stencil, RGBA and depth
+  }
+
   /** Returns the GL profile you desire or used by the drawable. */
   public GLProfile getGLProfile() {
     return glProfile;
@@ -158,11 +208,30 @@ public class GLCapabilities extends Capabilities implements Cloneable, GLCapabil
     return pbuffer;
   }
 
-  /** Enables or disables pbuffer usage. */
+  /** 
+   * Enables or disables pbuffer usage.<br>
+   * If enabled, onscreen := false.
+   * Defaults to false.
+   */
   public void setPBuffer(boolean onOrOff) {
+    if(onOrOff) {
+      setOnscreen(false);
+    }
     pbuffer = onOrOff;
   }
 
+  /**
+   * Sets whether the drawable surface supports onscreen.<br>
+   * If enabled, pbuffer := false.<br>
+   * Defaults to true.
+  */
+  public void setOnscreen(boolean onscreen) {
+    if(onscreen) {
+        setPBuffer(false);
+    }
+    super.setOnscreen(onscreen);
+  }
+
   /** Indicates whether double-buffering is enabled. */
   public boolean getDoubleBuffered() {
     return doubleBuffered;
@@ -340,28 +409,54 @@ public class GLCapabilities extends Capabilities implements Cloneable, GLCapabil
     return pbufferRenderToTextureRectangle;
   }
 
+  public StringBuffer toString(StringBuffer sink) {
+    if(null == sink) {
+        sink = new StringBuffer();
+    }
+
+    int samples = sampleBuffers ? numSamples : 0 ;
+
+    super.toString(sink);
+
+    sink.append(", accum-rgba ").append(accumRedBits).append("/").append(accumGreenBits).append("/").append(accumBlueBits).append("/").append(accumAlphaBits);
+    sink.append(", dp/st/ms: ").append(depthBits).append("/").append(stencilBits).append("/").append(samples);
+    if(doubleBuffered) {
+        sink.append(", dbl");
+    } else {
+        sink.append(", one");
+    }
+    if(stereo) {
+        sink.append(", stereo");
+    } else {
+        sink.append(", mono  ");
+    }
+    if(hardwareAccelerated) {
+        sink.append(", hw, ");
+    } else {
+        sink.append(", sw, ");
+    }
+    sink.append(glProfile);
+    if(!isOnscreen()) {
+        if(pbuffer) {
+            sink.append(", pbuffer [r2t ").append(pbufferRenderToTexture?1:0)
+                .append(", r2tr ").append(pbufferRenderToTextureRectangle?1:0)
+                .append(", float ").append(pbufferFloatingPointBuffers?1:0)
+                .append("]");
+        } else {
+            sink.append(", pixmap");
+        }
+    }
+    
+    return sink;
+  }
+
   /** Returns a textual representation of this GLCapabilities
       object. */ 
   public String toString() {
     StringBuffer msg = new StringBuffer();
-    msg.append("GLCapabilities[");
-    msg.append(super.toString());
-    msg.append(", GL profile: " + glProfile +
-        ", PBuffer: " + pbuffer +
-        ", DoubleBuffered: " + doubleBuffered +
-	    ", Stereo: " + stereo + 
-        ", HardwareAccelerated: " + hardwareAccelerated +
-	    ", DepthBits: " + depthBits +
-	    ", StencilBits: " + stencilBits +
-	    ", Red Accum: " + accumRedBits +
-	    ", Green Accum: " + accumGreenBits +
-	    ", Blue Accum: " + accumBlueBits +
-	    ", Alpha Accum: " + accumAlphaBits +
-        ", Multisample: " + sampleBuffers +
-        ", Num samples: "+(sampleBuffers ? numSamples : 0));
-    msg.append(", PBuffer-FloatingPointBuffers: "+pbufferFloatingPointBuffers+
-        ", PBuffer-RenderToTexture: "+pbufferRenderToTexture+
-        ", PBuffer-RenderToTextureRectangle: "+pbufferRenderToTextureRectangle+ "]");
+    msg.append("GLCaps[");
+    toString(msg);
+    msg.append("]");
     return msg.toString();
   }
 }
diff --git a/src/jogl/classes/javax/media/opengl/GLDrawableFactory.java b/src/jogl/classes/javax/media/opengl/GLDrawableFactory.java
index fe591c9fc..11c2bc18b 100644
--- a/src/jogl/classes/javax/media/opengl/GLDrawableFactory.java
+++ b/src/jogl/classes/javax/media/opengl/GLDrawableFactory.java
@@ -40,13 +40,14 @@
 
 package javax.media.opengl;
 
-import com.jogamp.common.JogampRuntimeException;
-import com.jogamp.common.impl.Debug;
-import com.jogamp.common.util.ReflectionUtil;
-
 import java.security.AccessController;
 import java.security.PrivilegedAction;
 import java.util.ArrayList;
+import java.util.List;
+
+import com.jogamp.common.JogampRuntimeException;
+import com.jogamp.common.impl.Debug;
+import com.jogamp.common.util.ReflectionUtil;
 
 import javax.media.nativewindow.AbstractGraphicsDevice;
 import javax.media.nativewindow.NativeSurface;
@@ -239,6 +240,24 @@ public abstract class GLDrawableFactory {
    */
   public abstract boolean getIsDeviceCompatible(AbstractGraphicsDevice device);
 
+  protected final AbstractGraphicsDevice validateDevice(AbstractGraphicsDevice device) {
+      if(null==device) {
+          device = getDefaultDevice();
+          if(null==device) {
+              throw new InternalError("no default device");
+          }
+          if (GLProfile.DEBUG) {
+              System.err.println("Info: GLDrawableFactory.validateDevice: using default device : "+device);
+          }
+      } else if( !getIsDeviceCompatible(device) ) {
+          if (GLProfile.DEBUG) {
+              System.err.println("Info: GLDrawableFactory.validateDevice: device not compatible : "+device);
+          }
+          return null;
+      }
+      return device;
+  }
+
   /**
    * Returns true if a shared context is already mapped to the <code>device</code> {@link AbstractGraphicsDevice#getConnection()},
    * or if a new shared context could be created and mapped. Otherwise return false.<br>
@@ -258,24 +277,28 @@ public abstract class GLDrawableFactory {
    * @param device which {@link javax.media.nativewindow.AbstractGraphicsDevice#getConnection() connection} denotes the shared the target device, may be <code>null</code> for the platform's default device.
    */
   protected final GLContext getOrCreateSharedContext(AbstractGraphicsDevice device) {
-      if(null==device) {
-          device = getDefaultDevice();
-          if(null==device) {
-              throw new InternalError("no default device");
-          }
-          if (GLProfile.DEBUG) {
-              System.err.println("Info: GLDrawableFactory.getOrCreateSharedContext: using default device : "+device);
-          }
-      } else if( !getIsDeviceCompatible(device) ) {
-          if (GLProfile.DEBUG) {
-              System.err.println("Info: GLDrawableFactory.getOrCreateSharedContext: device not compatible : "+device);
-          }
-          return null;
+      device = validateDevice(device);
+      if(null!=device) {
+        return getOrCreateSharedContextImpl(device);
       }
-      return getOrCreateSharedContextImpl(device);
+      return null;
   }
   protected abstract GLContext getOrCreateSharedContextImpl(AbstractGraphicsDevice device);
 
+  /**
+   * Returns the sole GLDrawableFactory instance for the desktop (X11, WGL, ..) if exist or null
+   */
+  public static GLDrawableFactory getDesktopFactory() {
+    return nativeOSFactory;
+  }
+
+  /**
+   * Returns the sole GLDrawableFactory instance for EGL if exist or null
+   */
+  public static GLDrawableFactory getEGLFactory() {
+    return eglFactory;
+  }
+
   /** 
    * Returns the sole GLDrawableFactory instance. 
    * 
@@ -300,16 +323,6 @@ public abstract class GLDrawableFactory {
     throw new GLException("No native platform GLDrawableFactory, nor EGLDrawableFactory available: "+glProfileImplName);
   }
 
-  /**
-   * Returns the sole GLDrawableFactory instance.
-   *
-   * @param device AbstractGraphicsDevice to determine the factory type, ie EGLDrawableFactory,
-   *                or one of the native GLDrawableFactory's, ie X11/GLX, Windows/WGL or MacOSX/CGL.
-   */
-  public static GLDrawableFactory getFactory(AbstractGraphicsDevice device) throws GLException {
-    return getFactoryImpl(device);
-  }
-
   protected static GLDrawableFactory getFactoryImpl(AbstractGraphicsDevice device) throws GLException {
     if(null != nativeOSFactory && nativeOSFactory.getIsDeviceCompatible(device)) {
         return nativeOSFactory;
@@ -320,6 +333,22 @@ public abstract class GLDrawableFactory {
     throw new GLException("No native platform GLDrawableFactory, nor EGLDrawableFactory available: "+device);
   }
 
+  /**
+   * Returns an array of available GLCapabilities for the device.<br>
+   * The list is sorted by the native ID, ascending.
+   *
+   * @param device which {@link javax.media.nativewindow.AbstractGraphicsDevice#getConnection() connection} denotes the shared the target device, may be <code>null</code> for the platform's default device.
+   * @return A list of {@link javax.media.opengl.GLCapabilitiesImmutable}'s, maybe empty if none is available.
+   */
+  public final List/*GLCapabilitiesImmutable*/ getAvailableCapabilities(AbstractGraphicsDevice device) {
+      device = validateDevice(device);
+      if(null!=device) {
+        return getAvailableCapabilitiesImpl(device);
+      }
+      return null;
+  }
+  protected abstract List/*GLCapabilitiesImmutable*/ getAvailableCapabilitiesImpl(AbstractGraphicsDevice device);
+
   //----------------------------------------------------------------------
   // Methods to create high-level objects
 
diff --git a/src/jogl/classes/javax/media/opengl/GLProfile.java b/src/jogl/classes/javax/media/opengl/GLProfile.java
index 3e1727f50..3867355f8 100644
--- a/src/jogl/classes/javax/media/opengl/GLProfile.java
+++ b/src/jogl/classes/javax/media/opengl/GLProfile.java
@@ -47,12 +47,13 @@ import com.jogamp.opengl.impl.GLDrawableFactoryImpl;
 import com.jogamp.opengl.impl.GLDynamicLookupHelper;
 import com.jogamp.opengl.impl.DesktopGLDynamicLookupHelper;
 import com.jogamp.opengl.JoglVersion;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.security.*;
 import javax.media.nativewindow.AbstractGraphicsDevice;
 import javax.media.opengl.fixedfunc.GLPointerFunc;
 import javax.media.nativewindow.NativeWindowFactory;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.security.*;
+import java.util.List;
 
 /**
  * Specifies the the OpenGL profile.
@@ -1301,8 +1302,16 @@ public class GLProfile {
             System.err.println("GLProfile.initProfilesForDevice: "+device.getConnection()+": "+glAvailabilityToString(device));
             if(addedDesktopProfile) {
                 dumpGLInfo(desktopFactory, device);
+                List/*<GLCapabilitiesImmutable>*/ availCaps = desktopFactory.getAvailableCapabilities(device);
+                for(int i=0; i<availCaps.size(); i++) {
+                    System.err.println(availCaps.get(i));
+                }
             } else if(addedEGLProfile) {
                 dumpGLInfo(eglFactory, device);
+                List/*<GLCapabilitiesImmutable>*/ availCaps = eglFactory.getAvailableCapabilities(device);
+                for(int i=0; i<availCaps.size(); i++) {
+                    System.err.println(availCaps.get(i));
+                }
             }
         }
 
@@ -1314,13 +1323,10 @@ public class GLProfile {
         System.err.println("GLProfile.dumpGLInfo: "+ctx);
         ctx.makeCurrent();
         try {
-            System.err.println("GLProfile.dumpGLInfo: p2");
             System.err.println(JoglVersion.getGLInfo(ctx.getGL(), null));
-            System.err.println("GLProfile.dumpGLInfo: p3");
         } finally {
             ctx.release();
         }
-        System.err.println("GLProfile.dumpGLInfo: p4");
     }
 
     public static AbstractGraphicsDevice getDefaultDevice() {
diff --git a/src/jogl/classes/javax/media/opengl/awt/GLCanvas.java b/src/jogl/classes/javax/media/opengl/awt/GLCanvas.java
index d47501795..acabe58a5 100644
--- a/src/jogl/classes/javax/media/opengl/awt/GLCanvas.java
+++ b/src/jogl/classes/javax/media/opengl/awt/GLCanvas.java
@@ -54,9 +54,10 @@ import java.awt.GraphicsConfiguration;
 import java.awt.GraphicsDevice;
 import java.awt.geom.Rectangle2D;
 
-import com.jogamp.common.GlueGenVersion;
-import com.jogamp.common.util.VersionUtil;
-import com.jogamp.common.util.locks.RecursiveLock;
+import java.awt.EventQueue;
+import java.lang.reflect.InvocationTargetException;
+import java.util.ArrayList;
+import java.util.List;
 
 import javax.media.nativewindow.WindowClosingProtocol;
 import javax.media.nativewindow.AbstractGraphicsConfiguration;
@@ -69,7 +70,6 @@ import javax.media.nativewindow.awt.AWTGraphicsConfiguration;
 import javax.media.nativewindow.awt.AWTGraphicsDevice;
 import javax.media.nativewindow.awt.AWTGraphicsScreen;
 import javax.media.nativewindow.awt.AWTWindowClosingProtocol;
-import com.jogamp.nativewindow.NativeWindowVersion;
 
 import javax.media.opengl.GL;
 import javax.media.opengl.GLAnimatorControl;
@@ -85,14 +85,17 @@ import javax.media.opengl.GLException;
 import javax.media.opengl.GLProfile;
 import javax.media.opengl.GLRunnable;
 import javax.media.opengl.Threading;
+
+import com.jogamp.nativewindow.NativeWindowVersion;
+import com.jogamp.common.GlueGenVersion;
+import com.jogamp.common.util.VersionUtil;
 import com.jogamp.opengl.JoglVersion;
+
+import com.jogamp.common.util.locks.RecursiveLock;
 import com.jogamp.opengl.impl.Debug;
 import com.jogamp.opengl.impl.GLContextImpl;
 import com.jogamp.opengl.impl.GLDrawableHelper;
 import com.jogamp.opengl.impl.ThreadingImpl;
-import java.awt.EventQueue;
-import java.lang.reflect.InvocationTargetException;
-import java.util.ArrayList;
 
 // FIXME: Subclasses need to call resetGLFunctionAvailability() on their
 // context whenever the displayChanged() function is called on our
@@ -996,6 +999,12 @@ public class GLCanvas extends Canvas implements AWTGLAutoDrawable, WindowClosing
     System.err.println(NativeWindowVersion.getInstance());
     System.err.println(JoglVersion.getInstance());
 
+    GLDrawableFactory factory = GLDrawableFactory.getDesktopFactory();
+    List/*<GLCapabilitiesImmutable>*/ availCaps = factory.getAvailableCapabilities(null);
+    for(int i=0; i<availCaps.size(); i++) {
+        System.err.println(availCaps.get(i));
+    }
+
     GLCapabilitiesImmutable caps = new GLCapabilities( GLProfile.getDefault(GLProfile.getDefaultDesktopDevice()) );
     Frame frame = new Frame("JOGL AWT Test");