Merge branch 'master' of ssh://[email protected]/jogl~jogl-git

8 files changed, 284 insertions, 199 deletions

diff --git a/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsExternalWGLContext.java b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsExternalWGLContext.java
index b9fc80156..31e65fc8c 100755
--- a/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsExternalWGLContext.java
+++ b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsExternalWGLContext.java
@@ -51,7 +51,7 @@ public class WindowsExternalWGLContext extends WindowsWGLContext {
   private boolean created = true;
   private GLContext lastContext;
 
-  private WindowsExternalWGLContext(Drawable drawable, long hglrc) {
+  private WindowsExternalWGLContext(Drawable drawable, long hglrc, WindowsWGLGraphicsConfiguration cfg) {
     super(drawable, null);
     this.hglrc = hglrc;
     if (DEBUG) {
@@ -59,6 +59,7 @@ public class WindowsExternalWGLContext extends WindowsWGLContext {
     }
     GLContextShareSet.contextCreated(this);
     setGLFunctionAvailability(false);
+    cfg.updateCapabilitiesByWGL(this);
   }
 
   protected static WindowsExternalWGLContext create(GLDrawableFactory factory, GLProfile glp) {
@@ -76,12 +77,12 @@ public class WindowsExternalWGLContext extends WindowsWGLContext {
     }
 
     AbstractGraphicsScreen aScreen = DefaultGraphicsScreen.createDefault();
-    WindowsWGLGraphicsConfiguration cfg = WindowsWGLGraphicsConfiguration.create(glp, aScreen, hdc, pfdID, true, true);
+    WindowsWGLGraphicsConfiguration cfg = WindowsWGLGraphicsConfiguration.create(hdc, pfdID, glp, aScreen, true, true);
 
     NullWindow nw = new NullWindow(cfg);
     nw.setSurfaceHandle(hdc);
 
-    return new WindowsExternalWGLContext(new Drawable(factory, nw), hglrc);
+    return new WindowsExternalWGLContext(new Drawable(factory, nw), hglrc, cfg);
   }
 
   public int makeCurrent() throws GLException {
diff --git a/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsExternalWGLDrawable.java b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsExternalWGLDrawable.java
index 706675893..9b87afc38 100755
--- a/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsExternalWGLDrawable.java
+++ b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsExternalWGLDrawable.java
@@ -61,12 +61,12 @@ public class WindowsExternalWGLDrawable extends WindowsWGLDrawable {
     }
 
     AbstractGraphicsScreen aScreen = DefaultGraphicsScreen.createDefault();
-    WindowsWGLGraphicsConfiguration cfg = WindowsWGLGraphicsConfiguration.create(glp, aScreen, hdc, pfdID, true, true);
+    WindowsWGLGraphicsConfiguration cfg = WindowsWGLGraphicsConfiguration.create(hdc, pfdID, glp, aScreen, true, true);
 
     NullWindow nw = new NullWindow(cfg);
     nw.setSurfaceHandle(hdc);
 
-    // cfg.updateGraphicsConfiguration(factory, nw);
+    cfg.updateGraphicsConfiguration(factory, nw);
 
     return new WindowsExternalWGLDrawable(factory, nw);
   }
diff --git a/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsOffscreenWGLDrawable.java b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsOffscreenWGLDrawable.java
index ecd4e1685..71d82e784 100644
--- a/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsOffscreenWGLDrawable.java
+++ b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsOffscreenWGLDrawable.java
@@ -127,7 +127,7 @@ public class WindowsOffscreenWGLDrawable extends WindowsWGLDrawable {
     }
   }
 
-  public void swapBuffers() throws GLException {
+  protected void swapBuffersImpl() {
   }
 
 }
diff --git a/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsPbufferWGLDrawable.java b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsPbufferWGLDrawable.java
index 6a03406f9..20a891414 100644
--- a/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsPbufferWGLDrawable.java
+++ b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsPbufferWGLDrawable.java
@@ -107,7 +107,7 @@ public class WindowsPbufferWGLDrawable extends WindowsWGLDrawable {
     return floatMode;
   }
 
-  public void swapBuffers() throws GLException {
+  protected void swapBuffersImpl() {
   }
 
   private void createPbuffer(long parentHdc, WGLExt wglExt) {
@@ -290,12 +290,14 @@ public class WindowsPbufferWGLDrawable extends WindowsWGLDrawable {
         GLCapabilities newCaps = WindowsWGLGraphicsConfiguration.AttribList2GLCapabilities(glProfile, iattributes, niattribs, ivalues, true, false, true);
         PIXELFORMATDESCRIPTOR pfd = WindowsWGLGraphicsConfiguration.createPixelFormatDescriptor();
         if (WGL.DescribePixelFormat(parentHdc, pformats[whichFormat], pfd.size(), pfd) == 0) {
-          throw new GLException("Unable to describe pixel format " + pformats[whichFormat]);
+          if (DEBUG) {
+              System.err.println("Unable to describe pixel format (Continue: true) " + whichFormat + "/" + nformats + " pfdID " + pformats[whichFormat]+":\n\t"+newCaps);
+          }
         }
         if(newCaps.isOnscreen()) {
-          throw new GLException("Error: Selected Onscreen Caps for PBuffer: "+newCaps);
+          throw new GLException("Error: Selected Onscreen Caps for PBuffer: "+newCaps+"\n\t"+newCaps);
         }
-        config.setCapsPFD(newCaps, pfd, pformats[whichFormat]);
+        config.setCapsPFD(newCaps, pfd, pformats[whichFormat], true);
       } else {
         PIXELFORMATDESCRIPTOR pfd = WindowsWGLGraphicsConfiguration.createPixelFormatDescriptor();
         if (WGL.DescribePixelFormat(parentHdc, pformats[whichFormat], pfd.size(), pfd) == 0) {
@@ -303,9 +305,9 @@ public class WindowsPbufferWGLDrawable extends WindowsWGLDrawable {
         }
         GLCapabilities newCaps = WindowsWGLGraphicsConfiguration.PFD2GLCapabilities(glProfile, pfd, false, true);
         if(newCaps.isOnscreen()) {
-          throw new GLException("Error: Selected Onscreen Caps for PBuffer: "+newCaps);
+          throw new GLException("Error: Selected Onscreen Caps for PBuffer: "+newCaps+"\n\t"+newCaps);
         }
-        config.setCapsPFD(newCaps, pfd, pformats[whichFormat]);
+        config.setCapsPFD(newCaps, pfd, pformats[whichFormat], false);
       }
     }
 
diff --git a/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsWGLContext.java b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsWGLContext.java
index 1bc3acada..9a3860ae2 100644
--- a/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsWGLContext.java
+++ b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsWGLContext.java
@@ -147,20 +147,16 @@ public class WindowsWGLContext extends GLContextImpl {
       throw new GLException("Unable to create temp OpenGL context for device context " + toHexString(drawable.getNativeWindow().getSurfaceHandle()));
     } else {
         if (!WGL.wglMakeCurrent(drawable.getNativeWindow().getSurfaceHandle(), temp_hglrc)) {
-            throw new GLException("Error making temp context current: " + WGL.GetLastError());
+            throw new GLException("Error making temp context current: 0x" + Integer.toHexString(WGL.GetLastError()));
         }
         setGLFunctionAvailability(true);
 
         if( !isFunctionAvailable("wglCreateContextAttribsARB") ||
             !isExtensionAvailable("WGL_ARB_create_context") ) {
             if(glCaps.getGLProfile().isGL3()) {
-              if (!WGL.wglMakeCurrent(0, 0)) {
-                throw new GLException("Error freeing temp OpenGL context: " + WGL.GetLastError());
-              }
-              if (!WGL.wglDeleteContext(temp_hglrc)) {
-                throw new GLException("Unable to delete OpenGL context");
-              }
-              throw new GLException("Unable to create OpenGL 3.1 context (no WGL_ARB_create_context)");
+              WGL.wglMakeCurrent(0, 0);
+              WGL.wglDeleteContext(temp_hglrc);
+              throw new GLException("Unable to create OpenGL >= 3.1 context (no WGL_ARB_create_context)");
             }
 
             // continue with temp context for GL < 3.0
@@ -173,47 +169,70 @@ public class WindowsWGLContext extends GLContextImpl {
 
             // preset with default values
             int attribs[] = {
-                WGLExt.WGL_CONTEXT_MAJOR_VERSION_ARB, 3,
-                WGLExt.WGL_CONTEXT_MINOR_VERSION_ARB, 0,
-                WGLExt.WGL_CONTEXT_FLAGS_ARB, 0,      
-                0
+                /*  0 */ WGLExt.WGL_CONTEXT_MAJOR_VERSION_ARB, 3,
+                /*  2 */ WGLExt.WGL_CONTEXT_MINOR_VERSION_ARB, 0,
+                /*  4 */ WGLExt.WGL_CONTEXT_FLAGS_ARB,         0 /* WGLExt.WGL_CONTEXT_DEBUG_BIT_ARB */,
+                /*  6 */ 0,                                    0,
+                /*  8 */ 0
             };
 
             if(glCaps.getGLProfile().isGL3()) {
-                attribs[1] |= 3;
-                attribs[3] |= 1;
-                // attribs[5] |= WGLExt.WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB ; // NVidia WGL driver doesn't support this one ..
-                // attribs[5] |= WGLExt.WGL_CONTEXT_DEBUG_BIT_ARB ;
+                // Try >= 3.2 core first !
+                // In contrast to GLX no verify with a None drawable binding (default framebuffer) is necessary,
+                // if no 3.2 is available creation fails already!
+                attribs[0+1]  = 3;
+                attribs[2+1]  = 2;
+                attribs[6+0]  = WGLExt.WGL_CONTEXT_PROFILE_MASK_ARB;
+                attribs[6+1]  = WGLExt.WGL_CONTEXT_CORE_PROFILE_BIT_ARB;
+                hglrc = wglExt.wglCreateContextAttribsARB(drawable.getNativeWindow().getSurfaceHandle(), hglrc2, attribs, 0); 
+                if(0==hglrc) {
+                    if(DEBUG) {
+                        System.err.println("WindowsWGLContext.createContext couldn't create >= 3.2 core context - fallback");
+                    }
+                    // Try >= 3.1 forward compatible - last resort for GL3 !
+                    attribs[0+1]  = 3;
+                    attribs[2+1]  = 1;
+                    attribs[4+1] |= WGLExt.WGL_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB;
+                    attribs[6+0]  = 0;
+                    attribs[6+1]  = 0;
+                } else if(DEBUG) {
+                  System.err.println("WindowsWGLContext.createContext >= 3.2 available 0x"+Long.toHexString(hglrc));
+                }
+            }
+            if(0==hglrc) {
+                // 3.1 or 3.0 ..
+                hglrc = wglExt.wglCreateContextAttribsARB(drawable.getNativeWindow().getSurfaceHandle(), hglrc2, attribs, 0); 
+                if(DEBUG) {
+                  if(0==hglrc) {
+                      System.err.println("WindowsWGLContext.createContext couldn't create >= 3.0 context - fallback");
+                  } else {
+                      System.err.println("WindowsWGLContext.createContext >= 3.0 available 0x"+Long.toHexString(hglrc));
+                  }
+                }
             }
 
-            hglrc = wglExt.wglCreateContextAttribsARB(drawable.getNativeWindow().getSurfaceHandle(), hglrc2, attribs, 0); 
             if(0==hglrc) {
                 if(glCaps.getGLProfile().isGL3()) {
-                  if (!WGL.wglMakeCurrent(0, 0)) {
-                    throw new GLException("Error freeing temp OpenGL context: " + WGL.GetLastError());
-                  }
-                  if (!WGL.wglDeleteContext(temp_hglrc)) {
-                    throw new GLException("Unable to delete OpenGL context");
-                  }
-                  throw new GLException("Unable to create OpenGL 3.1 context (have WGL_ARB_create_context)");
+                  WGL.wglMakeCurrent(0, 0);
+                  WGL.wglDeleteContext(temp_hglrc);
+                  throw new GLException("Unable to create OpenGL >= 3.1 context (have WGL_ARB_create_context)");
                 }
 
                 // continue with temp context for GL < 3.0
                 hglrc = temp_hglrc;
+                if (!WGL.wglMakeCurrent(drawable.getNativeWindow().getSurfaceHandle(), hglrc)) {
+                    throw new GLException("Error making old context current: 0x" + Integer.toHexString(WGL.GetLastError()));
+                }
                 if(DEBUG) {
                   System.err.println("WindowsWGLContext.create done (old ctx < 3.0 - no 3.0) 0x"+Long.toHexString(hglrc));
                 }
             } else {
                 hglrc2 = 0; // mark as shared ..
-                if (!WGL.wglMakeCurrent(0, 0)) {
-                    throw new GLException("Error freeing temp OpenGL context: " + WGL.GetLastError());
-                }
-                if (!WGL.wglDeleteContext(temp_hglrc)) {
-                    throw new GLException("Unable to delete temp OpenGL context");
-                }
+                WGL.wglMakeCurrent(0, 0);
+                WGL.wglDeleteContext(temp_hglrc);
 
                 if (!WGL.wglMakeCurrent(drawable.getNativeWindow().getSurfaceHandle(), hglrc)) {
-                    throw new GLException("Error making new context current: " + WGL.GetLastError());
+                    throw new GLException("Error making new context current: 0x" + Integer.toHexString(WGL.GetLastError()));
                 }
                 updateGLProcAddressTable();
                 if(DEBUG) {
@@ -225,8 +244,8 @@ public class WindowsWGLContext extends GLContextImpl {
     if(0!=hglrc2) {
         if (!WGL.wglShareLists(hglrc2, hglrc)) {
             throw new GLException("wglShareLists(" + toHexString(hglrc2) +
-                                  ", " + toHexString(hglrc) + ") failed: error code " +
-                                  WGL.GetLastError());
+                                  ", " + toHexString(hglrc) + ") failed: error code 0x" +
+                                  Integer.toHexString(WGL.GetLastError()));
         }
     }
     GLContextShareSet.contextCreated(this);
@@ -253,7 +272,7 @@ public class WindowsWGLContext extends GLContextImpl {
 
     if (WGL.wglGetCurrentContext() != hglrc) {
       if (!WGL.wglMakeCurrent(drawable.getNativeWindow().getSurfaceHandle(), hglrc)) {
-        throw new GLException("Error making context current: " + WGL.GetLastError());
+        throw new GLException("Error making context current: 0x" + Integer.toHexString(WGL.GetLastError()));
       } else {
         if (DEBUG && VERBOSE) {
           System.err.println(getThreadName() + ": wglMakeCurrent(hdc " + toHexString(drawable.getNativeWindow().getSurfaceHandle()) +
@@ -264,6 +283,11 @@ public class WindowsWGLContext extends GLContextImpl {
 
     if (created) {
       setGLFunctionAvailability(false);
+
+      WindowsWGLGraphicsConfiguration config = 
+        (WindowsWGLGraphicsConfiguration)drawable.getNativeWindow().getGraphicsConfiguration().getNativeGraphicsConfiguration();
+      config.updateCapabilitiesByWGL(this);
+
       return CONTEXT_CURRENT_NEW;
     }
     return CONTEXT_CURRENT;
@@ -271,7 +295,7 @@ public class WindowsWGLContext extends GLContextImpl {
 
   protected void releaseImpl() throws GLException {
     if (!WGL.wglMakeCurrent(0, 0)) {
-        throw new GLException("Error freeing OpenGL context: " + WGL.GetLastError());
+        throw new GLException("Error freeing OpenGL context: 0x" + Integer.toHexString(WGL.GetLastError()));
     }
   }
 
@@ -308,7 +332,6 @@ public class WindowsWGLContext extends GLContextImpl {
   }
 
   protected void updateGLProcAddressTable() {
-    super.updateGLProcAddressTable();
     if (DEBUG) {
       System.err.println(getThreadName() + ": !!! Initializing WGL extension address table for " + this);
     }
@@ -318,6 +341,7 @@ public class WindowsWGLContext extends GLContextImpl {
       wglExtProcAddressTable = new WGLExtProcAddressTable();
     }          
     resetProcAddressTable(getWGLExtProcAddressTable());
+    super.updateGLProcAddressTable();
   }
   
   public String getPlatformExtensionsString() {
@@ -332,29 +356,12 @@ public class WindowsWGLContext extends GLContextImpl {
     }
   }
 
-  public boolean isFunctionAvailable(String glFunctionName)
-  {
-    boolean available = super.isFunctionAvailable(glFunctionName);
-    
-    // Sanity check for implementations that use proc addresses for run-time
-    // linking: if the function IS available, then make sure there's a proc
-    // address for it if it's an extension or not part of the OpenGL 1.1 core
-    // (post GL 1.1 functions are run-time linked on windows).
-    /* FIXME: 
-    assert(!available ||
-           (getGLProcAddressTable().getAddressFor(mapToRealGLFunctionName(glFunctionName)) != 0 ||
-            FunctionAvailabilityCache.isPartOfGLCore("1.1", mapToRealGLFunctionName(glFunctionName)))
-           ); */
-
-    return available;
-  }
-  
-  public void setSwapInterval(int interval) {
-    // FIXME: make the context current first? Currently assumes that
-    // will not be necessary. Make the caller do this?
+  protected void setSwapIntervalImpl(int interval) {
     WGLExt wglExt = getWGLExt();
     if (wglExt.isExtensionAvailable("WGL_EXT_swap_control")) {
-      wglExt.wglSwapIntervalEXT(interval);
+      if ( wglExt.wglSwapIntervalEXT(interval) ) {
+        currentSwapInterval = interval ;
+      }
     }
   }
 
diff --git a/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsWGLDrawable.java b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsWGLDrawable.java
index 3017d258b..01e259665 100644
--- a/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsWGLDrawable.java
+++ b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsWGLDrawable.java
@@ -82,44 +82,41 @@ public abstract class WindowsWGLDrawable extends GLDrawableImpl {
     }
   }
 
-  public void swapBuffers() throws GLException {
-    GLCapabilities caps = (GLCapabilities)getNativeWindow().getGraphicsConfiguration().getNativeGraphicsConfiguration().getChosenCapabilities();
-    if (caps.getDoubleBuffered()) {
-        boolean didLock = false;
+  protected void swapBuffersImpl() {
+    boolean didLock = false;
 
-        try {
-            if ( !isSurfaceLocked() ) {
-                // Usually the surface shall be locked within [makeCurrent .. swap .. release]
-                if (lockSurface() == NativeWindow.LOCK_SURFACE_NOT_READY) {
-                    return;
-                }
-                didLock = true;
+    try {
+        if ( !isSurfaceLocked() ) {
+            // Usually the surface shall be locked within [makeCurrent .. swap .. release]
+            if (lockSurface() == NativeWindow.LOCK_SURFACE_NOT_READY) {
+                return;
             }
+            didLock = true;
+        }
 
-            long startTime = 0;
-            if (PROFILING) {
-              startTime = System.currentTimeMillis();
-            }
+        long startTime = 0;
+        if (PROFILING) {
+          startTime = System.currentTimeMillis();
+        }
 
-            if (!WGL.SwapBuffers(getNativeWindow().getSurfaceHandle()) && (WGL.GetLastError() != 0)) {
-              throw new GLException("Error swapping buffers");
-            }
+        if (!WGL.SwapBuffers(getNativeWindow().getSurfaceHandle()) && (WGL.GetLastError() != 0)) {
+          throw new GLException("Error swapping buffers");
+        }
 
-            if (PROFILING) {
-              long endTime = System.currentTimeMillis();
-              profilingSwapBuffersTime += (endTime - startTime);
-              int ticks = PROFILING_TICKS;
-              if (++profilingSwapBuffersTicks == ticks) {
-                System.err.println("SwapBuffers calls: " + profilingSwapBuffersTime + " ms / " + ticks + "  calls (" +
-                                   ((float) profilingSwapBuffersTime / (float) ticks) + " ms/call)");
-                profilingSwapBuffersTime = 0;
-                profilingSwapBuffersTicks = 0;
-              }
-            }
-        } finally {
-            if (didLock) {
-              unlockSurface();
-            }
+        if (PROFILING) {
+          long endTime = System.currentTimeMillis();
+          profilingSwapBuffersTime += (endTime - startTime);
+          int ticks = PROFILING_TICKS;
+          if (++profilingSwapBuffersTicks == ticks) {
+            System.err.println("SwapBuffers calls: " + profilingSwapBuffersTime + " ms / " + ticks + "  calls (" +
+                               ((float) profilingSwapBuffersTime / (float) ticks) + " ms/call)");
+            profilingSwapBuffersTime = 0;
+            profilingSwapBuffersTicks = 0;
+          }
+        }
+    } finally {
+        if (didLock) {
+          unlockSurface();
         }
     }
   }
diff --git a/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsWGLGraphicsConfiguration.java b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsWGLGraphicsConfiguration.java
index 1a8d45465..844e72841 100644
--- a/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsWGLGraphicsConfiguration.java
+++ b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsWGLGraphicsConfiguration.java
@@ -49,6 +49,7 @@ public class WindowsWGLGraphicsConfiguration extends DefaultGraphicsConfiguratio
     private int pixelfmtID;
     private boolean isChosen = false;
     private GLCapabilitiesChooser chooser;
+    private boolean choosenByWGLPixelFormat=false;
 
     public WindowsWGLGraphicsConfiguration(AbstractGraphicsScreen screen, GLCapabilities capsChosen, GLCapabilities capsRequested,
                                            PIXELFORMATDESCRIPTOR pixelfmt, int pixelfmtID, GLCapabilitiesChooser chooser) {
@@ -58,17 +59,26 @@ public class WindowsWGLGraphicsConfiguration extends DefaultGraphicsConfiguratio
         this.pixelfmtID = pixelfmtID;
     }
 
-    public static WindowsWGLGraphicsConfiguration create(GLProfile glp, AbstractGraphicsScreen screen, long hdc, int pfdID, boolean onscreen, boolean usePBuffer) {
-        PIXELFORMATDESCRIPTOR pfd = createPixelFormatDescriptor();
-        if (WGL.DescribePixelFormat(hdc, pfdID, pfd.size(), pfd) == 0) {
-            throw new GLException("Unable to describe pixel format " + pfdID);
+    public static WindowsWGLGraphicsConfiguration create(long hdc, int pfdID, 
+                                                         GLProfile glp, AbstractGraphicsScreen screen, boolean onscreen, boolean usePBuffer)
+    {
+        if(pfdID<=0) {
+            throw new GLException("Invalid pixelformat id "+pfdID);
         }
         if(null==glp) {
           glp = GLProfile.getDefault();
         }
+        PIXELFORMATDESCRIPTOR pfd = createPixelFormatDescriptor();
+        if (WGL.DescribePixelFormat(hdc, pfdID, pfd.size(), pfd) == 0) {
+            throw new GLException("Unable to describe pixel format " + pfdID);
+        }
+
         GLCapabilities caps = PFD2GLCapabilities(glp, pfd, onscreen, usePBuffer);
+        if(null==caps) {
+            throw new GLException("Couldn't choose Capabilities by: HDC 0x"+Long.toHexString(hdc)+", pfdID "+pfdID);
+        }
         WindowsWGLGraphicsConfiguration cfg = new WindowsWGLGraphicsConfiguration(screen, caps, caps, pfd, pfdID, new DefaultGLCapabilitiesChooser());
-        cfg.setCapsPFD(caps, pfd, pfdID);
+        cfg.setCapsPFD(caps, pfd, pfdID, false);
 
         return cfg;
     }
@@ -77,15 +87,40 @@ public class WindowsWGLGraphicsConfiguration extends DefaultGraphicsConfiguratio
         return super.clone();
     }
 
+    /** Update config - before having a valid context */
     protected void updateGraphicsConfiguration(GLDrawableFactory factory, NativeWindow nativeWindow) {
         WindowsWGLGraphicsConfigurationFactory.updateGraphicsConfiguration(chooser, factory, nativeWindow);
     }
-    protected void setCapsPFD(GLCapabilities caps, PIXELFORMATDESCRIPTOR pfd, int pfdID) {
-        // FIXME: setScreen ( .. )
+
+    /** Update config - after having a valid and current context */
+    protected void updateCapabilitiesByWGL(GLContextImpl context) {
+        if(choosenByWGLPixelFormat) return; // already done ..
+
+        GLCapabilities capabilities = (GLCapabilities) getRequestedCapabilities();
+        boolean onscreen = capabilities.isOnscreen();
+        boolean usePBuffer = capabilities.isPBuffer();
+        GLProfile glp = capabilities.getGLProfile();
+
+        WGLExt wglExt = (WGLExt) context.getPlatformGLExtensions();
+        GLDrawable drawable = context.getGLDrawable();
+        NativeWindow nativeWindow = drawable.getNativeWindow();
+        long hdc = nativeWindow.getSurfaceHandle();
+
+        GLCapabilities[] caps = HDC2GLCapabilities(wglExt, hdc, getPixelFormatID(), glp, true, onscreen, usePBuffer);
+        if(null!=caps && null!=caps[0]) {
+            setCapsPFD(caps[0], getPixelFormat(), getPixelFormatID(), true);
+        }
+    }
+
+    protected void setCapsPFD(GLCapabilities caps, PIXELFORMATDESCRIPTOR pfd, int pfdID, boolean choosenByWGLPixelFormat) {
         this.pixelfmt = pfd;
         this.pixelfmtID = pfdID;
         setChosenCapabilities(caps);
-        isChosen=true;
+        this.isChosen=true;
+        this.choosenByWGLPixelFormat=choosenByWGLPixelFormat;
+        if (DEBUG) {
+            System.err.println("*** setCapsPFD: WGL-Choosen "+choosenByWGLPixelFormat+", pfdID "+pfdID+", "+caps);
+        }
     }
 
     public boolean getCapabilitiesChosen() {
@@ -94,6 +129,102 @@ public class WindowsWGLGraphicsConfiguration extends DefaultGraphicsConfiguratio
 
     public PIXELFORMATDESCRIPTOR getPixelFormat()   { return pixelfmt; }
     public int getPixelFormatID() { return pixelfmtID; }
+    public boolean isChoosenByWGL() { return choosenByWGLPixelFormat; }
+
+    private static int haveWGLChoosePixelFormatARB = -1;
+    private static int haveWGLARBMultisample = -1;
+
+    public static GLCapabilities[] HDC2GLCapabilities(WGLExt wglExt, long hdc, int pfdIDOnly,
+                                                      GLProfile glp, boolean relaxed, boolean onscreen, boolean usePBuffer) {
+    
+        if(haveWGLChoosePixelFormatARB<0) {
+            haveWGLChoosePixelFormatARB = wglExt.isExtensionAvailable("WGL_ARB_pixel_format")?1:0;
+        }
+        if(haveWGLARBMultisample<0) {
+            haveWGLARBMultisample = wglExt.isExtensionAvailable("WGL_ARB_multisample")?1:0;
+        }
+        if (0==haveWGLChoosePixelFormatARB) {
+            return null;
+        }
+
+        // Produce a list of GLCapabilities to give to the
+        // GLCapabilitiesChooser.
+        // Use wglGetPixelFormatAttribivARB instead of
+        // DescribePixelFormat to get higher-precision information
+        // about the pixel format (should make the GLCapabilities
+        // more precise as well...i.e., remove the
+        // "HardwareAccelerated" bit, which is basically
+        // meaningless, and put in whether it can render to a
+        // window, to a pbuffer, or to a pixmap)
+        GLCapabilities[] availableCaps = null;
+        int numFormats = 0;
+        int niattribs = 0;
+        int[] iattributes = new int  [2*MAX_ATTRIBS];
+        int[] iresults    = new int  [2*MAX_ATTRIBS];
+
+        iattributes[0] = WGLExt.WGL_NUMBER_PIXEL_FORMATS_ARB;
+        if (wglExt.wglGetPixelFormatAttribivARB(hdc, 0, 0, 1, iattributes, 0, iresults, 0)) {
+          numFormats = iresults[0];
+
+          if (DEBUG) {
+            System.err.println("wglGetPixelFormatAttribivARB reported WGL_NUMBER_PIXEL_FORMATS = " + numFormats);
+          }
+
+          if(pfdIDOnly>0 && pfdIDOnly>numFormats) {
+            throw new GLException("Invalid pixelformat ID " + pfdIDOnly + " (should be between 1 and " + numFormats + ")");
+          }
+
+          // Should we be filtering out the pixel formats which aren't
+          // applicable, as we are doing here?
+          // We don't have enough information in the GLCapabilities to
+          // represent those that aren't...
+          iattributes[niattribs++] = WGLExt.WGL_DRAW_TO_WINDOW_ARB;
+          iattributes[niattribs++] = WGLExt.WGL_ACCELERATION_ARB;
+          iattributes[niattribs++] = WGLExt.WGL_SUPPORT_OPENGL_ARB;
+          iattributes[niattribs++] = WGLExt.WGL_DEPTH_BITS_ARB;
+          iattributes[niattribs++] = WGLExt.WGL_STENCIL_BITS_ARB;
+          iattributes[niattribs++] = WGLExt.WGL_DOUBLE_BUFFER_ARB;
+          iattributes[niattribs++] = WGLExt.WGL_STEREO_ARB;
+          iattributes[niattribs++] = WGLExt.WGL_PIXEL_TYPE_ARB;
+          iattributes[niattribs++] = WGLExt.WGL_RED_BITS_ARB;
+          iattributes[niattribs++] = WGLExt.WGL_GREEN_BITS_ARB;
+          iattributes[niattribs++] = WGLExt.WGL_BLUE_BITS_ARB;
+          iattributes[niattribs++] = WGLExt.WGL_ALPHA_BITS_ARB;
+          iattributes[niattribs++] = WGLExt.WGL_ACCUM_RED_BITS_ARB;
+          iattributes[niattribs++] = WGLExt.WGL_ACCUM_GREEN_BITS_ARB;
+          iattributes[niattribs++] = WGLExt.WGL_ACCUM_BLUE_BITS_ARB;
+          iattributes[niattribs++] = WGLExt.WGL_ACCUM_ALPHA_BITS_ARB;
+          if (1==haveWGLARBMultisample) {
+            iattributes[niattribs++] = WGLExt.WGL_SAMPLE_BUFFERS_ARB;
+            iattributes[niattribs++] = WGLExt.WGL_SAMPLES_ARB;
+          }
+
+          if(pfdIDOnly>0) {
+              availableCaps = new GLCapabilities[1];
+              if (!wglExt.wglGetPixelFormatAttribivARB(hdc, pfdIDOnly, 0, niattribs, iattributes, 0, iresults, 0)) {
+                  throw new GLException("Error getting pixel format attributes for pixel format " + pfdIDOnly + " of device context");
+              }
+              availableCaps[0] = AttribList2GLCapabilities(glp, iattributes, niattribs, iresults, 
+                                                           relaxed, onscreen, usePBuffer);
+          } else {
+              availableCaps = new GLCapabilities[numFormats];
+              for (int i = 0; i < numFormats; i++) {
+                if (!wglExt.wglGetPixelFormatAttribivARB(hdc, i+1, 0, niattribs, iattributes, 0, iresults, 0)) {
+                  throw new GLException("Error getting pixel format attributes for pixel format " + (i + 1) + " of device context");
+                }
+                availableCaps[i] = AttribList2GLCapabilities(glp, iattributes, niattribs, iresults, 
+                                                             relaxed, onscreen, usePBuffer);
+              }
+          }
+        } else {
+          long lastErr = WGL.GetLastError();
+          // Intel Extreme graphics fails with a zero error code
+          if (lastErr != 0) {
+            throw new GLException("Unable to enumerate pixel formats of window using wglGetPixelFormatAttribivARB: error code " + WGL.GetLastError());
+          }
+        }
+        return availableCaps;
+    }
 
     public static boolean GLCapabilities2AttribList(GLCapabilities caps,
                                                   int[] iattributes,
@@ -498,7 +629,7 @@ public class WindowsWGLGraphicsConfiguration extends DefaultGraphicsConfiguratio
   }
 
   public String toString() {
-    return "WindowsWGLGraphicsConfiguration["+getScreen()+", pfdID " + pixelfmtID + 
+    return "WindowsWGLGraphicsConfiguration["+getScreen()+", pfdID " + pixelfmtID + ", wglChoosen "+choosenByWGLPixelFormat+
                                             ",\n\trequested " + getRequestedCapabilities() +
                                             ",\n\tchosen    " + getChosenCapabilities() +
                                             "]";
diff --git a/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsWGLGraphicsConfigurationFactory.java b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsWGLGraphicsConfigurationFactory.java
index f5974dc61..a7d7be349 100644
--- a/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsWGLGraphicsConfigurationFactory.java
+++ b/src/jogl/classes/com/sun/opengl/impl/windows/wgl/WindowsWGLGraphicsConfigurationFactory.java
@@ -99,6 +99,7 @@ public class WindowsWGLGraphicsConfigurationFactory extends GraphicsConfiguratio
             throw new IllegalArgumentException("This NativeWindowFactory accepts only GLCapabilitiesChooser objects");
         }
 
+        boolean choosenBywGLPixelFormat = false;
         WindowsWGLGraphicsConfiguration config = (WindowsWGLGraphicsConfiguration) nativeWindow.getGraphicsConfiguration().getNativeGraphicsConfiguration();
         GLCapabilities capabilities = (GLCapabilities) config.getRequestedCapabilities();
         boolean onscreen = capabilities.isOnscreen();
@@ -113,7 +114,7 @@ public class WindowsWGLGraphicsConfigurationFactory extends GraphicsConfiguratio
         }
 
         PIXELFORMATDESCRIPTOR pfd = null;
-        int pixelFormat = -1;
+        int pixelFormat = -1; // 1-based pixel format
         boolean pixelFormatSet = false;
         GLCapabilities chosenCaps = null;
 
@@ -125,7 +126,7 @@ public class WindowsWGLGraphicsConfigurationFactory extends GraphicsConfiguratio
             //  - or the Java2D/OpenGL pipeline's configuration
             if (DEBUG) {
               System.err.println("!!!! NOTE: pixel format already chosen for HDC: 0x" + Long.toHexString(hdc)+
-                                 ", pixelformat "+WGL.GetPixelFormat(hdc));
+                                 ", pixelformat "+pixelFormat);
             }
             pixelFormatSet = true;
           }
@@ -138,27 +139,25 @@ public class WindowsWGLGraphicsConfigurationFactory extends GraphicsConfiguratio
           WindowsWGLDrawable dummyDrawable = null;
           GLContextImpl     dummyContext  = null;
           WGLExt            dummyWGLExt   = null;
-          dummyDrawable = new WindowsDummyWGLDrawable(factory);
-          dummyContext  = (GLContextImpl) dummyDrawable.createContext(null);
-          if (dummyContext != null) {
-            dummyContext.makeCurrent();
-            dummyWGLExt = (WGLExt) dummyContext.getPlatformGLExtensions();
-          }      
-          int recommendedPixelFormat = pixelFormat - 1;
+          if (capabilities.getSampleBuffers()) {
+              dummyDrawable = new WindowsDummyWGLDrawable(factory);
+              dummyContext  = (GLContextImpl) dummyDrawable.createContext(null);
+              if (dummyContext != null) {
+                dummyContext.makeCurrent();
+                dummyWGLExt = (WGLExt) dummyContext.getPlatformGLExtensions();
+              }
+          }
+          int recommendedPixelFormat = pixelFormat; // 1-based pixel format
           boolean haveWGLChoosePixelFormatARB = false;
-          boolean haveWGLARBMultisample = false;
           boolean gotAvailableCaps = false;
           if (dummyWGLExt != null) {
             try {
               haveWGLChoosePixelFormatARB = dummyWGLExt.isExtensionAvailable("WGL_ARB_pixel_format");
               if (haveWGLChoosePixelFormatARB) {
-                haveWGLARBMultisample = dummyWGLExt.isExtensionAvailable("WGL_ARB_multisample");
-
-                int[]   iattributes = new int  [2*WindowsWGLGraphicsConfiguration.MAX_ATTRIBS];
-                int[]   iresults    = new int  [2*WindowsWGLGraphicsConfiguration.MAX_ATTRIBS];
-                float[] fattributes = new float[1];
-
                 if(pixelFormat<=0) {
+                  int[]   iattributes = new int  [2*WindowsWGLGraphicsConfiguration.MAX_ATTRIBS];
+                  float[] fattributes = new float[1];
+
                   if(WindowsWGLGraphicsConfiguration.GLCapabilities2AttribList(capabilities,
                                                                                iattributes,
                                                                                dummyWGLExt,
@@ -174,8 +173,7 @@ public class WindowsWGLGraphicsConfigurationFactory extends GraphicsConfiguratio
                                                          numFormatsTmp, 0)) {
                       numFormats = numFormatsTmp[0];
                       if (recommendedPixelFormat<=0 && numFormats > 0) {
-                        // Remove one-basing of pixel format (added on later)
-                        recommendedPixelFormat = pformats[0] - 1;
+                        recommendedPixelFormat = pformats[0];
                         if (DEBUG) {
                           System.err.println(getThreadName() + ": Used wglChoosePixelFormatARB to recommend pixel format " + recommendedPixelFormat);
                         }
@@ -187,7 +185,7 @@ public class WindowsWGLGraphicsConfigurationFactory extends GraphicsConfiguratio
                       }
                     }
                     if (DEBUG) {
-                      if (recommendedPixelFormat < 0) {
+                      if (recommendedPixelFormat <= 0) {
                         System.err.print(getThreadName() + ": wglChoosePixelFormatARB didn't recommend a pixel format");
                         if (capabilities.getSampleBuffers()) {
                           System.err.print(" for multisampled GLCapabilities");
@@ -198,65 +196,9 @@ public class WindowsWGLGraphicsConfigurationFactory extends GraphicsConfiguratio
                   }
                 }
 
-                // Produce a list of GLCapabilities to give to the
-                // GLCapabilitiesChooser.
-                // Use wglGetPixelFormatAttribivARB instead of
-                // DescribePixelFormat to get higher-precision information
-                // about the pixel format (should make the GLCapabilities
-                // more precise as well...i.e., remove the
-                // "HardwareAccelerated" bit, which is basically
-                // meaningless, and put in whether it can render to a
-                // window, to a pbuffer, or to a pixmap)
-                int niattribs = 0;
-                iattributes[0] = WGLExt.WGL_NUMBER_PIXEL_FORMATS_ARB;
-                if (dummyWGLExt.wglGetPixelFormatAttribivARB(hdc, 0, 0, 1, iattributes, 0, iresults, 0)) {
-                  numFormats = iresults[0];
-
-                  if (DEBUG) {
-                    System.err.println("wglGetPixelFormatAttribivARB reported WGL_NUMBER_PIXEL_FORMATS = " + numFormats);
-                  }
-
-                  // Should we be filtering out the pixel formats which aren't
-                  // applicable, as we are doing here?
-                  // We don't have enough information in the GLCapabilities to
-                  // represent those that aren't...
-                  iattributes[niattribs++] = WGLExt.WGL_DRAW_TO_WINDOW_ARB;
-                  iattributes[niattribs++] = WGLExt.WGL_ACCELERATION_ARB;
-                  iattributes[niattribs++] = WGLExt.WGL_SUPPORT_OPENGL_ARB;
-                  iattributes[niattribs++] = WGLExt.WGL_DEPTH_BITS_ARB;
-                  iattributes[niattribs++] = WGLExt.WGL_STENCIL_BITS_ARB;
-                  iattributes[niattribs++] = WGLExt.WGL_DOUBLE_BUFFER_ARB;
-                  iattributes[niattribs++] = WGLExt.WGL_STEREO_ARB;
-                  iattributes[niattribs++] = WGLExt.WGL_PIXEL_TYPE_ARB;
-                  iattributes[niattribs++] = WGLExt.WGL_RED_BITS_ARB;
-                  iattributes[niattribs++] = WGLExt.WGL_GREEN_BITS_ARB;
-                  iattributes[niattribs++] = WGLExt.WGL_BLUE_BITS_ARB;
-                  iattributes[niattribs++] = WGLExt.WGL_ALPHA_BITS_ARB;
-                  iattributes[niattribs++] = WGLExt.WGL_ACCUM_RED_BITS_ARB;
-                  iattributes[niattribs++] = WGLExt.WGL_ACCUM_GREEN_BITS_ARB;
-                  iattributes[niattribs++] = WGLExt.WGL_ACCUM_BLUE_BITS_ARB;
-                  iattributes[niattribs++] = WGLExt.WGL_ACCUM_ALPHA_BITS_ARB;
-                  if (haveWGLARBMultisample) {
-                    iattributes[niattribs++] = WGLExt.WGL_SAMPLE_BUFFERS_ARB;
-                    iattributes[niattribs++] = WGLExt.WGL_SAMPLES_ARB;
-                  }
-
-                  availableCaps = new GLCapabilities[numFormats];
-                  for (int i = 0; i < numFormats; i++) {
-                    if (!dummyWGLExt.wglGetPixelFormatAttribivARB(hdc, i+1, 0, niattribs, iattributes, 0, iresults, 0)) {
-                      throw new GLException("Error getting pixel format attributes for pixel format " + (i + 1) + " of device context");
-                    }
-                    availableCaps[i] = WindowsWGLGraphicsConfiguration.AttribList2GLCapabilities(glProfile, iattributes, niattribs, iresults, 
-                                                                                                 pixelFormatSet, onscreen, usePBuffer);
-                  }
-                  gotAvailableCaps = true;
-                } else {
-                  long lastErr = WGL.GetLastError();
-                  // Intel Extreme graphics fails with a zero error code
-                  if (lastErr != 0) {
-                    throw new GLException("Unable to enumerate pixel formats of window using wglGetPixelFormatAttribivARB: error code " + WGL.GetLastError());
-                  }
-                }
+                availableCaps = WindowsWGLGraphicsConfiguration.HDC2GLCapabilities(dummyWGLExt, hdc, -1, glProfile, pixelFormatSet, onscreen, usePBuffer);
+                gotAvailableCaps = null!=availableCaps ;
+                choosenBywGLPixelFormat = gotAvailableCaps ;
               }
             } finally {
               dummyContext.release();
@@ -265,7 +207,6 @@ public class WindowsWGLGraphicsConfigurationFactory extends GraphicsConfiguratio
             }
           }
 
-          // Fallback path for older cards, in particular Intel Extreme motherboard graphics
           if (!gotAvailableCaps) {
             if (DEBUG) {
               if (!capabilities.getSampleBuffers()) {
@@ -279,8 +220,6 @@ public class WindowsWGLGraphicsConfigurationFactory extends GraphicsConfiguratio
             if (DEBUG) {
               System.err.println(getThreadName() + ": Recommended pixel format = " + recommendedPixelFormat);
             }
-            // Remove one-basing of pixel format (added on later)
-            recommendedPixelFormat -= 1;
 
             numFormats = WGL.DescribePixelFormat(hdc, 1, 0, null);
             if (numFormats == 0) {
@@ -305,19 +244,27 @@ public class WindowsWGLGraphicsConfigurationFactory extends GraphicsConfiguratio
               if(null!=chooser) {
                   // Supply information to chooser
                   try {
-                    pixelFormat = chooser.chooseCapabilities(capabilities, availableCaps, recommendedPixelFormat);
+                    pixelFormat = chooser.chooseCapabilities(capabilities, availableCaps, recommendedPixelFormat) + 1;
                   } catch (NativeWindowException e) {
-                    throw new GLException(e);
+                    if(DEBUG) {
+                          e.printStackTrace();
+                    }
+                    pixelFormat = -1;
                   }
               } else {
                   pixelFormat = recommendedPixelFormat;
               }
-              if ((pixelFormat < 0) || (pixelFormat >= numFormats)) {
+              if (pixelFormat <= 0) {
+                  // keep on going ..
+                  if(DEBUG) {
+                      System.err.println("WindowsWGLGraphicsConfigurationFactory.updateGraphicsConfiguration .. unable to choose config, using first");
+                  }
+                  pixelFormat = 1; // default ..
+              } else if ( pixelFormat > numFormats ) {
                 throw new GLException("Invalid result " + pixelFormat +
-                                      " from GLCapabilitiesChooser (should be between 0 and " +
-                                      (numFormats - 1) + ")");
+                                      " from GLCapabilitiesChooser (should be between 1 and " +
+                                      numFormats + ")");
               }
-              pixelFormat += 1; // one-base the index
           }
           chosenCaps = availableCaps[pixelFormat-1];
           if (DEBUG) {
@@ -355,7 +302,7 @@ public class WindowsWGLGraphicsConfigurationFactory extends GraphicsConfiguratio
         } else {
           capabilities = WindowsWGLGraphicsConfiguration.PFD2GLCapabilities(glProfile, pfd, onscreen, usePBuffer);
         }
-        config.setCapsPFD(capabilities, pfd, pixelFormat);
+        config.setCapsPFD(capabilities, pfd, pixelFormat, choosenBywGLPixelFormat);
     }
 
   protected static String getThreadName() {