refactoring part 3 (impl package): renamed com.sun.opengl -> com.jogamp.opengl.

15 files changed, 3094 insertions, 0 deletions

diff --git a/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsDummyWGLDrawable.java b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsDummyWGLDrawable.java
new file mode 100644
index 000000000..89a25fe9a
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsDummyWGLDrawable.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution 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.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.impl.windows.wgl;
+
+import javax.media.opengl.*;
+import com.jogamp.opengl.impl.*;
+import com.sun.nativewindow.impl.NullWindow;
+
+public class WindowsDummyWGLDrawable extends WindowsWGLDrawable {
+  private long hwnd, hdc;
+
+  public WindowsDummyWGLDrawable(GLDrawableFactory factory) {
+    super(factory, new NullWindow(WindowsWGLGraphicsConfigurationFactory.createDefaultGraphicsConfiguration(null, true, true)), true);
+    // All entries to CreateDummyWindow must synchronize on one object
+    // to avoid accidentally registering the dummy window class twice
+    synchronized (WindowsDummyWGLDrawable.class) {
+      hwnd = WGL.CreateDummyWindow(0, 0, 1, 1);
+    }
+    hdc = WGL.GetDC(hwnd);
+    NullWindow nw = (NullWindow) getNativeWindow();
+    nw.setSurfaceHandle(hdc);
+    // Choose a (hopefully hardware-accelerated) OpenGL pixel format for this device context
+    GLCapabilities caps = new GLCapabilities(null);
+    caps.setDepthBits(16);
+    PIXELFORMATDESCRIPTOR pfd = WindowsWGLGraphicsConfiguration.GLCapabilities2PFD(caps);
+    int pixelFormat = WGL.ChoosePixelFormat(hdc, pfd);
+    if ((pixelFormat == 0) ||
+        (!WGL.SetPixelFormat(hdc, pixelFormat, pfd))) {
+      destroy();
+    }
+  }
+
+  public void setSize(int width, int height) {
+  }
+
+  public int getWidth() {
+    return 1;
+  }
+
+  public int getHeight() {
+    return 1;
+  }
+
+  public GLContext createContext(GLContext shareWith) {
+    if (hdc == 0) {
+      // Construction failed
+      return null;
+    }
+    // FIXME: figure out how to hook back in the Java 2D / JOGL bridge
+    return new WindowsWGLContext(this, shareWith);
+  }
+
+  public void destroy() {
+    if (hdc != 0) {
+      WGL.ReleaseDC(hwnd, hdc);
+      hdc = 0;
+    }
+    if (hwnd != 0) {
+      WGL.ShowWindow(hwnd, WGL.SW_HIDE);
+      WGL.DestroyWindow(hwnd);
+      hwnd = 0;
+    }
+  }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsExternalWGLContext.java b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsExternalWGLContext.java
new file mode 100755
index 000000000..25691ab91
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsExternalWGLContext.java
@@ -0,0 +1,146 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution 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.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.impl.windows.wgl;
+
+import javax.media.opengl.*;
+import javax.media.nativewindow.*;
+import com.jogamp.opengl.impl.*;
+import com.sun.nativewindow.impl.NullWindow;
+
+public class WindowsExternalWGLContext extends WindowsWGLContext {
+  private boolean firstMakeCurrent = true;
+  private boolean created = true;
+  private GLContext lastContext;
+
+  private WindowsExternalWGLContext(Drawable drawable, long hglrc, WindowsWGLGraphicsConfiguration cfg) {
+    super(drawable, null);
+    this.context = hglrc;
+    if (DEBUG) {
+      System.err.println(getThreadName() + ": !!! Created external OpenGL context " + toHexString(hglrc) + " for " + this);
+    }
+    GLContextShareSet.contextCreated(this);
+    setGLFunctionAvailability(false);
+    cfg.updateCapabilitiesByWGL(this);
+    getGLStateTracker().setEnabled(false); // external context usage can't track state in Java
+  }
+
+  protected static WindowsExternalWGLContext create(GLDrawableFactory factory, GLProfile glp) {
+    long hdc = WGL.wglGetCurrentDC();
+    if (0==hdc) {
+      throw new GLException("Error: attempted to make an external GLDrawable without a drawable current");
+    }
+    long hglrc = WGL.wglGetCurrentContext();
+    if (hglrc == 0) {
+      throw new GLException("Error: attempted to make an external GLContext without a context current");
+    }
+    int pfdID = WGL.GetPixelFormat(hdc);
+    if (pfdID == 0) {
+      throw new GLException("Error: attempted to make an external GLContext without a valid pixelformat");
+    }
+
+    AbstractGraphicsScreen aScreen = DefaultGraphicsScreen.createDefault();
+    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, cfg);
+  }
+
+  public int makeCurrent() throws GLException {
+    // Save last context if necessary to allow external GLContexts to
+    // talk to other GLContexts created by this library
+    GLContext cur = getCurrent();
+    if (cur != null && cur != this) {
+      lastContext = cur;
+      setCurrent(null);
+    }
+    return super.makeCurrent();
+  }  
+
+  public void release() throws GLException {
+    super.release();
+    setCurrent(lastContext);
+    lastContext = null;
+  }
+
+  protected int makeCurrentImpl() throws GLException {
+    if (firstMakeCurrent) {
+      firstMakeCurrent = false;
+      return CONTEXT_CURRENT_NEW;
+    }
+    return CONTEXT_CURRENT;
+  }
+
+  protected void releaseImpl() throws GLException {
+  }
+
+  protected void destroyImpl() throws GLException {
+    created = false;
+    GLContextShareSet.contextDestroyed(this);
+  }
+
+  public boolean isCreated() {
+    return created;
+  }
+
+  // Need to provide the display connection to extension querying APIs
+  static class Drawable extends WindowsWGLDrawable {
+    Drawable(GLDrawableFactory factory, NativeWindow comp) {
+      super(factory, comp, true);
+    }
+
+    public GLContext createContext(GLContext shareWith) {
+      throw new GLException("Should not call this");
+    }
+
+    public int getWidth() {
+      throw new GLException("Should not call this");
+    }
+
+    public int getHeight() {
+      throw new GLException("Should not call this");
+    }
+
+    public void setSize(int width, int height) {
+      throw new GLException("Should not call this");
+    }
+  }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsExternalWGLDrawable.java b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsExternalWGLDrawable.java
new file mode 100755
index 000000000..f5b89842d
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsExternalWGLDrawable.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution 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.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.impl.windows.wgl;
+
+import javax.media.nativewindow.*;
+import javax.media.opengl.*;
+import com.jogamp.opengl.impl.*;
+import com.sun.nativewindow.impl.NullWindow;
+
+public class WindowsExternalWGLDrawable extends WindowsWGLDrawable {
+
+  private WindowsExternalWGLDrawable(GLDrawableFactory factory, NativeWindow component) {
+    super(factory, component, true);
+  }
+
+  protected static WindowsExternalWGLDrawable create(GLDrawableFactory factory, GLProfile glp) {
+    long hdc = WGL.wglGetCurrentDC();
+    if (0==hdc) {
+      throw new GLException("Error: attempted to make an external GLDrawable without a drawable current");
+    }
+    int pfdID = WGL.GetPixelFormat(hdc);
+    if (pfdID == 0) {
+      throw new GLException("Error: attempted to make an external GLContext without a valid pixelformat");
+    }
+
+    AbstractGraphicsScreen aScreen = DefaultGraphicsScreen.createDefault();
+    WindowsWGLGraphicsConfiguration cfg = WindowsWGLGraphicsConfiguration.create(hdc, pfdID, glp, aScreen, true, true);
+
+    NullWindow nw = new NullWindow(cfg);
+    nw.setSurfaceHandle(hdc);
+
+    cfg.updateGraphicsConfiguration(factory, nw);
+
+    return new WindowsExternalWGLDrawable(factory, nw);
+  }
+
+
+  public GLContext createContext(GLContext shareWith) {
+    return new WindowsWGLContext(this, shareWith);
+  }
+  
+  public void setSize(int newWidth, int newHeight) {
+    throw new GLException("Should not call this");
+  }
+
+  public int getWidth() {
+    throw new GLException("Should not call this");
+  }  
+
+  public int getHeight() {
+    throw new GLException("Should not call this");
+  }  
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsOffscreenWGLContext.java b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsOffscreenWGLContext.java
new file mode 100644
index 000000000..25d93b50e
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsOffscreenWGLContext.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution 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.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.impl.windows.wgl;
+
+import javax.media.opengl.*;
+import com.jogamp.opengl.impl.*;
+
+public class WindowsOffscreenWGLContext extends WindowsWGLContext {
+  public WindowsOffscreenWGLContext(WindowsOffscreenWGLDrawable drawable,
+                                   GLContext shareWith) {
+    super(drawable, shareWith);
+  }
+
+  public int getOffscreenContextPixelDataType() {
+      return GL.GL_UNSIGNED_BYTE;
+  }
+  
+  public int getOffscreenContextReadBuffer() {
+    // On Windows these contexts are always single-buffered
+    return GL.GL_FRONT;
+  }
+
+  public boolean offscreenImageNeedsVerticalFlip() {
+    // We can take care of this in the DIB creation (see below)
+    return false;
+  }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsOffscreenWGLDrawable.java b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsOffscreenWGLDrawable.java
new file mode 100644
index 000000000..88bfb3b1c
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsOffscreenWGLDrawable.java
@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution 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.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.impl.windows.wgl;
+
+import javax.media.opengl.*;
+import javax.media.nativewindow.*;
+import com.jogamp.opengl.impl.*;
+import com.sun.nativewindow.impl.NullWindow;
+
+public class WindowsOffscreenWGLDrawable extends WindowsWGLDrawable {
+  private long origbitmap;
+  private long hbitmap;
+
+  public WindowsOffscreenWGLDrawable(GLDrawableFactory factory, NativeWindow target) {
+    super(factory, target, true);
+    create();
+  }
+
+  protected void setRealizedImpl() {
+    if(realized) {
+        create();
+    } else {
+        destroy();
+    }
+  }
+
+  public GLContext createContext(GLContext shareWith) {
+    return new WindowsOffscreenWGLContext(this, shareWith);
+  }
+
+  private void create() {
+    NativeWindow nw = getNativeWindow();
+    WindowsWGLGraphicsConfiguration config = (WindowsWGLGraphicsConfiguration)nw.getGraphicsConfiguration().getNativeGraphicsConfiguration();
+    GLCapabilities capabilities = (GLCapabilities)config.getRequestedCapabilities();
+    int width = getWidth();
+    int height = getHeight();
+    BITMAPINFO info = BITMAPINFO.create();
+    BITMAPINFOHEADER header = info.getBmiHeader();
+    int bitsPerPixel = (capabilities.getRedBits() +
+                        capabilities.getGreenBits() +
+                        capabilities.getBlueBits() +
+                        capabilities.getAlphaBits());
+    header.setBiSize(header.size());
+    header.setBiWidth(width);
+    // NOTE: negating the height causes the DIB to be in top-down row
+    // order rather than bottom-up; ends up being correct during pixel
+    // readback
+    header.setBiHeight(-1 * height);
+    header.setBiPlanes((short) 1);
+    header.setBiBitCount((short) bitsPerPixel);
+    header.setBiXPelsPerMeter(0);
+    header.setBiYPelsPerMeter(0);
+    header.setBiClrUsed(0);
+    header.setBiClrImportant(0);
+    header.setBiCompression(WGL.BI_RGB);
+    header.setBiSizeImage(width * height * bitsPerPixel / 8);
+
+    long hdc = WGL.CreateCompatibleDC(0);
+    if (hdc == 0) {
+      System.out.println("LastError: " + WGL.GetLastError());
+      throw new GLException("Error creating device context for offscreen OpenGL context");
+    }
+    ((SurfaceChangeable)nw).setSurfaceHandle(hdc);
+
+    hbitmap = WGL.CreateDIBSection(hdc, info, WGL.DIB_RGB_COLORS, 0, 0, 0);
+    if (hbitmap == 0) {
+      WGL.DeleteDC(hdc);
+      hdc = 0;
+      throw new GLException("Error creating offscreen bitmap of width " + width +
+                            ", height " + height);
+    }
+    if ((origbitmap = WGL.SelectObject(hdc, hbitmap)) == 0) {
+      WGL.DeleteObject(hbitmap);
+      hbitmap = 0;
+      WGL.DeleteDC(hdc);
+      hdc = 0;
+      throw new GLException("Error selecting bitmap into new device context");
+    }
+        
+    config.updateGraphicsConfiguration(getFactory(), nw);
+  }
+  
+  public void destroy() {
+    NativeWindow nw = getNativeWindow();
+    if (nw.getSurfaceHandle() != 0) {
+      // Must destroy bitmap and device context
+      WGL.SelectObject(nw.getSurfaceHandle(), origbitmap);
+      WGL.DeleteObject(hbitmap);
+      WGL.DeleteDC(nw.getSurfaceHandle());
+      origbitmap = 0;
+      hbitmap = 0;
+      ((SurfaceChangeable)nw).setSurfaceHandle(0);
+    }
+  }
+
+  protected void swapBuffersImpl() {
+    if(DEBUG) {
+        System.err.println("unhandled swapBuffersImpl() called for: "+this);
+    }
+  }
+
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsOnscreenWGLContext.java b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsOnscreenWGLContext.java
new file mode 100644
index 000000000..aeb13110e
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsOnscreenWGLContext.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution 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.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.impl.windows.wgl;
+
+import java.util.*;
+
+import javax.media.nativewindow.*;
+import javax.media.opengl.*;
+import com.jogamp.opengl.impl.*;
+
+public class WindowsOnscreenWGLContext extends WindowsWGLContext {
+  protected WindowsOnscreenWGLDrawable drawable;
+
+  public WindowsOnscreenWGLContext(WindowsOnscreenWGLDrawable drawable,
+                                  GLContext shareWith) {
+    super(drawable, shareWith);
+    this.drawable = drawable;
+  }
+  
+  // Note: Usually the surface shall be locked within [makeCurrent .. swap .. release]
+  protected int makeCurrentImpl() throws GLException {
+    int lockRes = drawable.lockSurface();
+    boolean exceptionOccurred = false;
+    try {
+      if (lockRes == NativeWindow.LOCK_SURFACE_NOT_READY) {
+        return CONTEXT_NOT_CURRENT;
+      }
+      int ret = super.makeCurrentImpl();
+      return ret;
+    } catch (RuntimeException e) {
+      exceptionOccurred = true;
+      throw e;
+    } finally {
+      if (exceptionOccurred ||
+          (isOptimizable() && lockRes != NativeWindow.LOCK_SURFACE_NOT_READY) && drawable.isSurfaceLocked()) {
+        drawable.unlockSurface();
+      }
+    }
+  }
+
+  // Note: Usually the surface shall be locked within [makeCurrent .. swap .. release]
+  protected void releaseImpl() throws GLException {
+    try {
+      super.releaseImpl();
+    } finally {
+      if (!isOptimizable() && drawable.isSurfaceLocked()) {
+        drawable.unlockSurface();
+      }
+    }
+  }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsOnscreenWGLDrawable.java b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsOnscreenWGLDrawable.java
new file mode 100644
index 000000000..401b8c3c6
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsOnscreenWGLDrawable.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution 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.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.impl.windows.wgl;
+
+import javax.media.nativewindow.*;
+import javax.media.opengl.*;
+import com.jogamp.opengl.impl.*;
+
+public class WindowsOnscreenWGLDrawable extends WindowsWGLDrawable {
+  protected WindowsOnscreenWGLDrawable(GLDrawableFactory factory, NativeWindow component) {
+    super(factory, component, false);
+  }
+
+  public GLContext createContext(GLContext shareWith) {
+    return new WindowsOnscreenWGLContext(this, shareWith);
+  }
+
+  public int getWidth() {
+    return component.getWidth();
+  }
+
+  public int getHeight() {
+    return component.getHeight();
+  }
+
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsPbufferWGLContext.java b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsPbufferWGLContext.java
new file mode 100644
index 000000000..b0524bcd9
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsPbufferWGLContext.java
@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution 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.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.impl.windows.wgl;
+
+import javax.media.opengl.*;
+import com.jogamp.opengl.impl.*;
+
+public class WindowsPbufferWGLContext extends WindowsWGLContext {
+  private static final boolean DEBUG = Debug.debug("WindowsPbufferWGLContext");
+
+  // State for render-to-texture and render-to-texture-rectangle support
+  private WindowsPbufferWGLDrawable drawable;
+  private boolean rtt;       // render-to-texture?
+  private boolean hasRTT;    // render-to-texture extension available?
+  private boolean rect;      // render-to-texture-rectangle?
+  private int textureTarget; // e.g. GL_TEXTURE_2D, GL_TEXTURE_RECTANGLE_NV
+  private int texture;       // actual texture object
+
+  public WindowsPbufferWGLContext(WindowsPbufferWGLDrawable drawable,
+                                 GLContext shareWith) {
+    super(drawable, shareWith);
+    this.drawable = drawable;
+  }
+
+  public void bindPbufferToTexture() {
+    if (!rtt) {
+      throw new GLException("Shouldn't try to bind a pbuffer to a texture if render-to-texture hasn't been " +
+                            "specified in its GLCapabilities");
+    }
+    GL gl = getGL();
+    WGLExt wglExt = getWGLExt();
+    gl.glBindTexture(textureTarget, texture);
+    if (rtt && hasRTT) {
+      if (!wglExt.wglBindTexImageARB(drawable.getPbuffer(), WGLExt.WGL_FRONT_LEFT_ARB)) {
+        throw new GLException("Binding of pbuffer to texture failed: " + wglGetLastError());
+      }
+    }
+    // FIXME: comment is wrong now
+    // Note that if the render-to-texture extension is not supported,
+    // we perform a glCopyTexImage2D in swapBuffers().
+  }
+
+  public void releasePbufferFromTexture() {
+    if (!rtt) {
+      throw new GLException("Shouldn't try to bind a pbuffer to a texture if render-to-texture hasn't been " +
+                            "specified in its GLCapabilities");
+    }
+    if (rtt && hasRTT) {
+      WGLExt wglExt = getWGLExt();
+      if (!wglExt.wglReleaseTexImageARB(drawable.getPbuffer(), WGLExt.WGL_FRONT_LEFT_ARB)) {
+        throw new GLException("Releasing of pbuffer from texture failed: " + wglGetLastError());
+      }
+    }
+  }
+
+  protected int makeCurrentImpl() throws GLException {
+    int res = super.makeCurrentImpl();
+    if (DEBUG && VERBOSE) {
+      System.err.println("WindowsPbufferWGLContext: super.makeCurrentImpl() = " + res);
+    }
+    if (res == CONTEXT_CURRENT_NEW) {
+      GLCapabilities capabilities = drawable.getChosenGLCapabilities();
+
+      // Initialize render-to-texture support if requested
+      GL gl = getGL();
+      rtt  = capabilities.getPbufferRenderToTexture();
+      rect = gl.isGL2() && capabilities.getPbufferRenderToTextureRectangle();
+
+      if (rtt) {
+        if (DEBUG) {
+          System.err.println("Initializing render-to-texture support");
+        }
+
+        if (!gl.isExtensionAvailable("WGL_ARB_render_texture")) {
+          System.err.println("WindowsPbufferWGLContext: WARNING: WGL_ARB_render_texture extension not " +
+                             "supported; implementing render_to_texture support using slow texture readback");
+        } else {
+          hasRTT = true;
+
+          if (rect && !gl.isExtensionAvailable("GL_NV_texture_rectangle")) {
+            System.err.println("WindowsPbufferWGLContext: WARNING: GL_NV_texture_rectangle extension not " +
+                               "supported; skipping requested render_to_texture_rectangle support for pbuffer");
+            rect = false;
+          }
+          if (rect) {
+            if (DEBUG) {
+              System.err.println("  Using render-to-texture-rectangle");
+            }
+            textureTarget = GL2.GL_TEXTURE_RECTANGLE_ARB;
+          } else {
+            if (DEBUG) {
+              System.err.println("  Using vanilla render-to-texture");
+            }
+            textureTarget = GL.GL_TEXTURE_2D;
+          }
+          int[] tmp = new int[1];
+          gl.glGenTextures(1, tmp, 0);
+          texture = tmp[0];
+          gl.glBindTexture(textureTarget, texture);
+          gl.glTexParameteri(textureTarget, GL.GL_TEXTURE_MIN_FILTER, GL.GL_NEAREST);
+          gl.glTexParameteri(textureTarget, GL.GL_TEXTURE_MAG_FILTER, GL.GL_NEAREST);
+          gl.glTexParameteri(textureTarget, GL.GL_TEXTURE_WRAP_S, GL.GL_CLAMP_TO_EDGE);
+          gl.glTexParameteri(textureTarget, GL.GL_TEXTURE_WRAP_T, GL.GL_CLAMP_TO_EDGE);
+          gl.glCopyTexImage2D(textureTarget, 0, GL.GL_RGB, 0, 0, drawable.getWidth(), drawable.getHeight(), 0);
+        }
+      }
+    }
+    return res;
+  }
+
+  public int getFloatingPointMode() {
+    return drawable.getFloatingPointMode();
+  }
+
+  private static String wglGetLastError() {
+    return WindowsWGLDrawableFactory.wglGetLastError();
+  }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsPbufferWGLDrawable.java b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsPbufferWGLDrawable.java
new file mode 100644
index 000000000..c7034e93b
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsPbufferWGLDrawable.java
@@ -0,0 +1,330 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution 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.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.impl.windows.wgl;
+
+import javax.media.opengl.*;
+import javax.media.nativewindow.*;
+import com.jogamp.opengl.impl.*;
+
+public class WindowsPbufferWGLDrawable extends WindowsWGLDrawable {
+  private long cachedParentHdc;
+  private WGLExt cachedWGLExt; // cached WGLExt instance from parent GLCanvas,
+                               // needed to destroy pbuffer
+  private long buffer; // pbuffer handle
+
+  private int floatMode;
+
+  public WindowsPbufferWGLDrawable(GLDrawableFactory factory, NativeWindow target,
+                                   WindowsWGLDrawable dummyDrawable,
+                                   WGLExt wglExt) {
+    super(factory, target, true);
+
+    if (DEBUG) {
+        System.out.println("Pbuffer config: " + getNativeWindow().getGraphicsConfiguration().getNativeGraphicsConfiguration());
+    }
+
+    createPbuffer(dummyDrawable.getNativeWindow().getSurfaceHandle(), wglExt);
+
+    if (DEBUG) {
+        System.err.println("Created pbuffer " + this);
+    }
+  }
+
+  protected void setRealizedImpl() {
+    if(realized) {
+        throw new GLException("Recreation via setRealized not supported.");
+    } else {
+        destroy();
+    }
+  }
+
+  public GLContext createContext(GLContext shareWith) {
+    return new WindowsPbufferWGLContext(this, shareWith);
+  }
+
+  public void destroy() {
+    NativeWindow nw = getNativeWindow();
+    if(0!=buffer) {
+        WGLExt wglExt = cachedWGLExt;
+        if (nw.getSurfaceHandle() != 0) {
+          // Must release DC and pbuffer
+          // NOTE that since the context is not current, glGetError() can
+          // not be called here, so we skip the use of any composable
+          // pipelines (see WindowsOnscreenWGLContext.makeCurrentImpl)
+          if (wglExt.wglReleasePbufferDCARB(buffer, nw.getSurfaceHandle()) == 0) {
+            throw new GLException("Error releasing pbuffer device context: error code " + WGL.GetLastError());
+          }
+          ((SurfaceChangeable)nw).setSurfaceHandle(0);
+        }
+        if (!wglExt.wglDestroyPbufferARB(buffer)) {
+            throw new GLException("Error destroying pbuffer: error code " + WGL.GetLastError());
+        }
+        buffer = 0;
+    }
+  }
+
+  public long getPbuffer() {
+    return buffer;
+  }
+
+  public int getFloatingPointMode() {
+    return floatMode;
+  }
+
+  protected void swapBuffersImpl() {
+    if(DEBUG) {
+        System.err.println("unhandled swapBuffersImpl() called for: "+this);
+    }
+  }
+
+  private void createPbuffer(long parentHdc, WGLExt wglExt) {
+    int[]   iattributes = new int  [2*WindowsWGLGraphicsConfiguration.MAX_ATTRIBS];
+    float[] fattributes = new float[1];
+    int[]   floatModeTmp = new int[1];
+    int     niattribs   = 0;
+    int     width, height;
+
+    WindowsWGLGraphicsConfiguration config = (WindowsWGLGraphicsConfiguration) getNativeWindow().getGraphicsConfiguration().getNativeGraphicsConfiguration();
+    GLCapabilities capabilities = (GLCapabilities)config.getRequestedCapabilities();
+    GLProfile glProfile = capabilities.getGLProfile();
+
+    if (DEBUG) {
+      System.out.println("Pbuffer parentHdc = " + toHexString(parentHdc));
+      System.out.println("Pbuffer caps: " + capabilities);
+    }
+
+    if(!WindowsWGLGraphicsConfiguration.GLCapabilities2AttribList(capabilities,
+                                    iattributes,
+                                    wglExt,
+                                    true,
+                                    floatModeTmp)){
+      throw new GLException("Pbuffer-related extensions not supported");
+    }
+
+    floatMode = floatModeTmp[0];
+    boolean rtt      = capabilities.getPbufferRenderToTexture();
+    boolean rect     = capabilities.getPbufferRenderToTextureRectangle();
+    boolean useFloat = capabilities.getPbufferFloatingPointBuffers();
+    boolean ati      = false;
+
+    if (useFloat) {
+      ati = (floatMode == GLPbuffer.ATI_FLOAT);
+    }
+
+    int[] pformats = new int[WindowsWGLGraphicsConfiguration.MAX_PFORMATS];
+    int   nformats;
+    int[] nformatsTmp = new int[1];
+    if (!wglExt.wglChoosePixelFormatARB(parentHdc,
+                                     iattributes, 0,
+                                     fattributes, 0,
+                                     WindowsWGLGraphicsConfiguration.MAX_PFORMATS,
+                                     pformats, 0,
+                                     nformatsTmp, 0)) {
+      throw new GLException("pbuffer creation error: wglChoosePixelFormat() failed");
+    }
+    nformats = nformatsTmp[0];
+    if (nformats <= 0) {
+      throw new GLException("pbuffer creation error: Couldn't find a suitable pixel format");
+    }
+
+    boolean haveMultisample = wglExt.isExtensionAvailable("WGL_ARB_multisample");
+
+    if (DEBUG) {
+      System.err.println("" + nformats + " suitable pixel formats found");
+      // query pixel format
+      iattributes[0] = WGLExt.WGL_RED_BITS_ARB;
+      iattributes[1] = WGLExt.WGL_GREEN_BITS_ARB;
+      iattributes[2] = WGLExt.WGL_BLUE_BITS_ARB;
+      iattributes[3] = WGLExt.WGL_ALPHA_BITS_ARB;
+      iattributes[4] = WGLExt.WGL_DEPTH_BITS_ARB;
+      iattributes[5] = (useFloat ? (ati ? WGLExt.WGL_PIXEL_TYPE_ARB : WGLExt.WGL_FLOAT_COMPONENTS_NV) : WGLExt.WGL_RED_BITS_ARB);
+      iattributes[6] = (haveMultisample ? WGLExt.WGL_SAMPLE_BUFFERS_ARB : WGLExt.WGL_RED_BITS_ARB);
+      iattributes[7] = (haveMultisample ? WGLExt.WGL_SAMPLES_ARB : WGLExt.WGL_RED_BITS_ARB);
+      iattributes[8] = WGLExt.WGL_DRAW_TO_PBUFFER_ARB;
+      int[] ivalues = new int[9];
+      for (int i = 0; i < nformats; i++) {
+        if (!wglExt.wglGetPixelFormatAttribivARB(parentHdc, pformats[i], 0, 9, iattributes, 0, ivalues, 0)) {
+          throw new GLException("Error while querying pixel format " + pformats[i] +
+                                "'s (index " + i + "'s) capabilities for debugging");
+        }
+        System.err.print("pixel format " + pformats[i] + " (index " + i + "): ");
+        System.err.print( "r: " + ivalues[0]);
+        System.err.print(" g: " + ivalues[1]);
+        System.err.print(" b: " + ivalues[2]);
+        System.err.print(" a: " + ivalues[3]);
+        System.err.print(" depth: " + ivalues[4]);
+        if (haveMultisample) {
+          System.err.print(" multisample: " + ivalues[6]);
+        }
+        System.err.print(" samples: " + ivalues[7]);
+        if (useFloat) {
+          if (ati) {
+            if (ivalues[5] == WGLExt.WGL_TYPE_RGBA_FLOAT_ARB) {
+              System.err.print(" [ati float]");
+            } else if (ivalues[5] != WGLExt.WGL_TYPE_RGBA_ARB) {
+              System.err.print(" [unknown pixel type " + ivalues[5] + "]");
+            }
+          } else {
+            if (ivalues[5] != 0) {
+              System.err.print(" [float]");
+            }
+          }
+        }
+
+        if (ivalues[8] != 0) {
+          System.err.print(" [pbuffer]");
+        }
+        System.err.println();
+      }
+    }
+
+    long tmpBuffer = 0;
+    int whichFormat = -1;
+    // Loop is a workaround for bugs in NVidia's recent drivers
+    for (whichFormat = 0; whichFormat < nformats; whichFormat++) {
+      int format = pformats[whichFormat];
+
+      // Create the p-buffer.
+      niattribs = 0;
+
+      if (rtt) {
+        iattributes[niattribs++]   = WGLExt.WGL_TEXTURE_FORMAT_ARB;
+        if (useFloat) {
+          iattributes[niattribs++] = WGLExt.WGL_TEXTURE_FLOAT_RGB_NV;
+        } else {
+          iattributes[niattribs++] = WGLExt.WGL_TEXTURE_RGBA_ARB;
+        }
+
+        iattributes[niattribs++] = WGLExt.WGL_TEXTURE_TARGET_ARB;
+        iattributes[niattribs++] = rect ? WGLExt.WGL_TEXTURE_RECTANGLE_NV : WGLExt.WGL_TEXTURE_2D_ARB;
+
+        iattributes[niattribs++] = WGLExt.WGL_MIPMAP_TEXTURE_ARB;
+        iattributes[niattribs++] = GL.GL_FALSE;
+
+        iattributes[niattribs++] = WGLExt.WGL_PBUFFER_LARGEST_ARB;
+        iattributes[niattribs++] = GL.GL_FALSE;
+      }
+
+      iattributes[niattribs++] = 0;
+
+      tmpBuffer = wglExt.wglCreatePbufferARB(parentHdc, format, getWidth(), getHeight(), iattributes, 0);
+      if (tmpBuffer != 0) {
+        // Done
+        break;
+      }
+    }
+
+    if (tmpBuffer == 0) {
+      throw new GLException("pbuffer creation error: wglCreatePbuffer() failed: tried " + nformats +
+                            " pixel formats, last error was: " + wglGetLastError());
+    }
+
+    // Get the device context.
+    long tmpHdc = wglExt.wglGetPbufferDCARB(tmpBuffer);
+    if (tmpHdc == 0) {
+      throw new GLException("pbuffer creation error: wglGetPbufferDC() failed");
+    }
+
+    NativeWindow nw = getNativeWindow();
+    // Set up instance variables
+    buffer = tmpBuffer;
+    ((SurfaceChangeable)nw).setSurfaceHandle(tmpHdc);
+    cachedWGLExt = wglExt;
+    cachedParentHdc = parentHdc;
+
+    // Re-query chosen pixel format
+    {
+      niattribs = 0;
+      iattributes[niattribs++] = WGLExt.WGL_ACCELERATION_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_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_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;
+      iattributes[niattribs++] = (useFloat ? (ati ? WGLExt.WGL_PIXEL_TYPE_ARB : WGLExt.WGL_FLOAT_COMPONENTS_NV) : WGLExt.WGL_RED_BITS_ARB);
+      iattributes[niattribs++] = (haveMultisample ? WGLExt.WGL_SAMPLE_BUFFERS_ARB : WGLExt.WGL_RED_BITS_ARB);
+      iattributes[niattribs++] = (haveMultisample ? WGLExt.WGL_SAMPLES_ARB : WGLExt.WGL_RED_BITS_ARB);
+      iattributes[niattribs++] = WGLExt.WGL_DRAW_TO_PBUFFER_ARB;
+      int[] ivalues = new int[niattribs];
+      if (wglExt.wglGetPixelFormatAttribivARB(parentHdc, pformats[whichFormat], 0, niattribs, iattributes, 0, ivalues, 0)) {
+        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) {
+          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+"\n\t"+newCaps);
+        }
+        config.setCapsPFD(newCaps, pfd, pformats[whichFormat], true);
+      } else {
+        PIXELFORMATDESCRIPTOR pfd = WindowsWGLGraphicsConfiguration.createPixelFormatDescriptor();
+        if (WGL.DescribePixelFormat(parentHdc, pformats[whichFormat], pfd.size(), pfd) == 0) {
+          throw new GLException("Unable to describe pixel format " + pformats[whichFormat]);
+        }
+        GLCapabilities newCaps = WindowsWGLGraphicsConfiguration.PFD2GLCapabilities(glProfile, pfd, false, true);
+        if(newCaps.isOnscreen()) {
+          throw new GLException("Error: Selected Onscreen Caps for PBuffer: "+newCaps+"\n\t"+newCaps);
+        }
+        config.setCapsPFD(newCaps, pfd, pformats[whichFormat], false);
+      }
+    }
+
+    // Determine the actual width and height we were able to create.
+    int[] tmp = new int[1];
+    wglExt.wglQueryPbufferARB( buffer, WGLExt.WGL_PBUFFER_WIDTH_ARB,  tmp, 0 );
+    width = tmp[0];
+    wglExt.wglQueryPbufferARB( buffer, WGLExt.WGL_PBUFFER_HEIGHT_ARB, tmp, 0 );
+    height = tmp[0];
+    ((SurfaceChangeable)nw).setSize(width, height);
+  }
+
+  private static String wglGetLastError() {
+    return WindowsWGLDrawableFactory.wglGetLastError();
+  }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsWGLContext.java b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsWGLContext.java
new file mode 100644
index 000000000..08c77539c
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsWGLContext.java
@@ -0,0 +1,439 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution 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.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.impl.windows.wgl;
+
+import java.nio.*;
+import java.util.*;
+import javax.media.opengl.*;
+import javax.media.nativewindow.*;
+import com.jogamp.opengl.impl.*;
+import com.jogamp.gluegen.runtime.ProcAddressTable;
+
+public class WindowsWGLContext extends GLContextImpl {
+  protected long hglrc;
+  private boolean wglGetExtensionsStringEXTInitialized;
+  private boolean wglGetExtensionsStringEXTAvailable;
+  private boolean wglMakeContextCurrentInitialized;
+  private boolean wglMakeContextCurrentARBAvailable;
+  private boolean wglMakeContextCurrentEXTAvailable;
+  private static final Map/*<String, String>*/ functionNameMap;
+  private static final Map/*<String, String>*/ extensionNameMap;
+  private WGLExt wglExt;
+  // Table that holds the addresses of the native C-language entry points for
+  // WGL extension functions.
+  private WGLExtProcAddressTable wglExtProcAddressTable;
+
+  static {
+    functionNameMap = new HashMap();
+    functionNameMap.put("glAllocateMemoryNV", "wglAllocateMemoryNV");
+    functionNameMap.put("glFreeMemoryNV", "wglFreeMemoryNV");
+
+    extensionNameMap = new HashMap();
+    extensionNameMap.put("GL_ARB_pbuffer", "WGL_ARB_pbuffer");
+    extensionNameMap.put("GL_ARB_pixel_format", "WGL_ARB_pixel_format");
+  }
+
+  // FIXME: figure out how to hook back in the Java 2D / JOGL bridge
+  public WindowsWGLContext(GLDrawableImpl drawable, GLDrawableImpl drawableRead,
+                           GLContext shareWith) {
+    super(drawable, drawableRead, shareWith);
+  }
+
+  public WindowsWGLContext(GLDrawableImpl drawable,
+                           GLContext shareWith) {
+    this(drawable, null, shareWith);
+  }
+  
+  public Object getPlatformGLExtensions() {
+    return getWGLExt();
+  }
+
+  public WGLExt getWGLExt() {
+    if (wglExt == null) {
+      wglExt = new WGLExtImpl(this);
+    }
+    return wglExt;
+  }
+
+  public boolean wglMakeContextCurrent(long hDrawDC, long hReadDC, long hglrc) {
+    WGLExt wglExt = getWGLExt();
+    if (!wglMakeContextCurrentInitialized) {
+      wglMakeContextCurrentARBAvailable = isFunctionAvailable("wglMakeContextCurrentARB");
+      wglMakeContextCurrentEXTAvailable = isFunctionAvailable("wglMakeContextCurrentEXT");
+      wglMakeContextCurrentInitialized = true;
+      if(DEBUG) {
+          System.err.println("WindowsWGLContext.wglMakeContextCurrent: ARB "+wglMakeContextCurrentARBAvailable+", EXT "+wglMakeContextCurrentEXTAvailable);
+      }
+    }
+    if(wglMakeContextCurrentARBAvailable) {
+        return wglExt.wglMakeContextCurrentARB(hDrawDC, hReadDC, hglrc);
+    } else if(wglMakeContextCurrentEXTAvailable) {
+        return wglExt.wglMakeContextCurrentEXT(hDrawDC, hReadDC, hglrc);
+    }
+    return WGL.wglMakeCurrent(hDrawDC, hglrc);
+  }
+
+  public final ProcAddressTable getPlatformExtProcAddressTable() {
+    return getWGLExtProcAddressTable();
+  }
+
+  public final WGLExtProcAddressTable getWGLExtProcAddressTable() {
+    return wglExtProcAddressTable;
+  }
+
+  protected String mapToRealGLFunctionName(String glFunctionName) {
+    String lookup = (String) functionNameMap.get(glFunctionName);
+    if (lookup != null) {
+      return lookup;
+    }
+    return glFunctionName;
+  }
+
+  protected String mapToRealGLExtensionName(String glExtensionName) {
+    String lookup = (String) extensionNameMap.get(glExtensionName);
+    if (lookup != null) {
+      return lookup;
+    }
+    return glExtensionName;
+  }
+
+  /**
+   * Creates and initializes an appropriate OpenGL context. Should only be
+   * called by {@link #makeCurrentImpl()}.
+   */
+  protected void create() {
+    GLCapabilities glCaps = drawable.getChosenGLCapabilities();
+    if(DEBUG) {
+          System.err.println("WindowsWGLContext.create got "+glCaps);
+    }
+
+    if (drawable.getNativeWindow().getSurfaceHandle() == 0) {
+      throw new GLException("Internal error: attempted to create OpenGL context without an associated drawable");
+    }
+    // Windows can set up sharing of display lists after creation time
+    WindowsWGLContext other = (WindowsWGLContext) GLContextShareSet.getShareContext(this);
+    long hglrc2 = 0;
+    if (other != null) {
+      hglrc2 = other.getHGLRC();
+      if (hglrc2 == 0) {
+        throw new GLException("GLContextShareSet returned an invalid OpenGL context");
+      }
+    }
+
+    // To use WGL_ARB_create_context, we have to make a temp context current,
+    // so we are able to use GetProcAddress
+    long temp_hglrc = WGL.wglCreateContext(drawable.getNativeWindow().getSurfaceHandle());
+    if (DEBUG) {
+      System.err.println(getThreadName() + ": !!! Created temp OpenGL context " + toHexString(temp_hglrc) + " for " + this + ", device context " + toHexString(drawable.getNativeWindow().getSurfaceHandle()) + ", not yet sharing");
+    }
+    if (temp_hglrc == 0) {
+      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: 0x" + Integer.toHexString(WGL.GetLastError()));
+        }
+        setGLFunctionAvailability(true);
+
+        if( !isFunctionAvailable("wglCreateContextAttribsARB") ||
+            !isExtensionAvailable("WGL_ARB_create_context") ) {
+            if(glCaps.getGLProfile().isGL3()) {
+              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
+            hglrc = temp_hglrc;
+            if(DEBUG) {
+              System.err.println("WindowsWGLContext.create done (old ctx < 3.0 - no WGL_ARB_create_context) 0x"+Long.toHexString(hglrc));
+            }
+        } else {
+            WGLExt wglExt = getWGLExt();
+
+            // preset with default values
+            int attribs[] = {
+                /*  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()) {
+                // 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;
+                if(glCaps.getGLProfile().isGL3bc()) {
+                    attribs[6+0]  = WGLExt.WGL_CONTEXT_PROFILE_MASK_ARB;
+                    attribs[6+1]  = WGLExt.WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB;
+                }
+                /**
+                 * don't stricten requirements any further, even compatible would be fine
+                 *
+                 } else {
+                    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;
+                    if(!glCaps.getGLProfile().isGL3bc()) {
+                        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));
+                  }
+                }
+            }
+
+            if(0==hglrc) {
+                if(glCaps.getGLProfile().isGL3()) {
+                  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()));
+                }
+                updateGLProcAddressTable();
+                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 ..
+                WGL.wglMakeCurrent(0, 0);
+                WGL.wglDeleteContext(temp_hglrc);
+
+                if (!WGL.wglMakeCurrent(drawable.getNativeWindow().getSurfaceHandle(), hglrc)) {
+                    throw new GLException("Error making new context current: 0x" + Integer.toHexString(WGL.GetLastError()));
+                }
+                updateGLProcAddressTable();
+                if(DEBUG) {
+                  System.err.println("WindowsWGLContext.create done (new ctx >= 3.0) 0x"+Long.toHexString(hglrc));
+                }
+            }
+        }
+    }
+    if(0!=hglrc2) {
+        if (!WGL.wglShareLists(hglrc2, hglrc)) {
+            throw new GLException("wglShareLists(" + toHexString(hglrc2) +
+                                  ", " + toHexString(hglrc) + ") failed: error code 0x" +
+                                  Integer.toHexString(WGL.GetLastError()));
+        }
+    }
+    GLContextShareSet.contextCreated(this);
+    WGL.wglMakeCurrent(0, 0); // release immediatly to gain from ARB/EXT wglMakeContextCurrent(draw, read, ctx)!
+    if (DEBUG) {
+      System.err.println(getThreadName() + ": !!! Created OpenGL context " + toHexString(hglrc) + " for " + this + ", device context " + toHexString(drawable.getNativeWindow().getSurfaceHandle()) + ", sharing with " + toHexString(hglrc2));
+    }
+  }
+  
+  protected int makeCurrentImpl() throws GLException {
+    if (drawable.getNativeWindow().getSurfaceHandle() == 0) {
+        if (DEBUG) {
+          System.err.println("drawable not properly initialized");
+        }
+        return CONTEXT_NOT_CURRENT;
+    }
+    boolean created = false;
+    if (hglrc == 0) {
+      create();
+      if (DEBUG) {
+        System.err.println(getThreadName() + ": !!! Created GL context for " + getClass().getName());
+      }
+      created = true;
+    }
+
+    if (WGL.wglGetCurrentContext() != hglrc) {
+      if (!wglMakeContextCurrent(drawable.getNativeWindow().getSurfaceHandle(), drawableRead.getNativeWindow().getSurfaceHandle(), hglrc)) {
+        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()) +
+                             ", hglrc " + toHexString(hglrc) + ") succeeded");
+        }
+      }
+    }
+
+    if (created) {
+      setGLFunctionAvailability(false);
+
+      WindowsWGLGraphicsConfiguration config = 
+        (WindowsWGLGraphicsConfiguration)drawable.getNativeWindow().getGraphicsConfiguration().getNativeGraphicsConfiguration();
+      config.updateCapabilitiesByWGL(this);
+
+      return CONTEXT_CURRENT_NEW;
+    }
+    return CONTEXT_CURRENT;
+  }
+
+  protected void releaseImpl() throws GLException {
+    if (!wglMakeContextCurrent(0, 0, 0)) {
+        throw new GLException("Error freeing OpenGL context: 0x" + Integer.toHexString(WGL.GetLastError()));
+    }
+  }
+
+  protected void destroyImpl() throws GLException {
+    if (DEBUG) {
+        Exception e = new Exception(getThreadName() + ": !!! Destroyed OpenGL context " + toHexString(hglrc));
+        e.printStackTrace();
+    }
+    if (hglrc != 0) {
+      if (!WGL.wglDeleteContext(hglrc)) {
+        throw new GLException("Unable to delete OpenGL context");
+      }
+      hglrc = 0;
+      GLContextShareSet.contextDestroyed(this);
+    }
+  }
+
+  public boolean isCreated() {
+    return (hglrc != 0);
+  }
+
+  public void copy(GLContext source, int mask) throws GLException {
+    long dst = getHGLRC();
+    long src = ((WindowsWGLContext) source).getHGLRC();
+    if (src == 0) {
+      throw new GLException("Source OpenGL context has not been created");
+    }
+    if (dst == 0) {
+      throw new GLException("Destination OpenGL context has not been created");
+    }
+    if (!WGL.wglCopyContext(src, dst, mask)) {
+      throw new GLException("wglCopyContext failed");
+    }
+  }
+
+  protected void updateGLProcAddressTable() {
+    if (DEBUG) {
+      System.err.println(getThreadName() + ": !!! Initializing WGL extension address table for " + this);
+    }
+    wglGetExtensionsStringEXTInitialized=false;
+    wglGetExtensionsStringEXTAvailable=false;
+    wglMakeContextCurrentInitialized=false;
+    wglMakeContextCurrentARBAvailable=false;
+    wglMakeContextCurrentEXTAvailable=false;
+
+    if (wglExtProcAddressTable == null) {
+      // FIXME: cache ProcAddressTables by capability bits so we can
+      // share them among contexts with the same capabilities
+      wglExtProcAddressTable = new WGLExtProcAddressTable();
+    }          
+    resetProcAddressTable(getWGLExtProcAddressTable());
+    super.updateGLProcAddressTable();
+  }
+  
+  public String getPlatformExtensionsString() {
+    if (!wglGetExtensionsStringEXTInitialized) {
+      wglGetExtensionsStringEXTAvailable = (WGL.wglGetProcAddress("wglGetExtensionsStringEXT") != 0);
+      wglGetExtensionsStringEXTInitialized = true;
+    }
+    if (wglGetExtensionsStringEXTAvailable) {
+      return getWGLExt().wglGetExtensionsStringEXT();
+    } else {
+      return "";
+    }
+  }
+
+  protected void setSwapIntervalImpl(int interval) {
+    WGLExt wglExt = getWGLExt();
+    if (wglExt.isExtensionAvailable("WGL_EXT_swap_control")) {
+      if ( wglExt.wglSwapIntervalEXT(interval) ) {
+        currentSwapInterval = interval ;
+      }
+    }
+  }
+
+  public ByteBuffer glAllocateMemoryNV(int arg0, float arg1, float arg2, float arg3) {
+    return getWGLExt().wglAllocateMemoryNV(arg0, arg1, arg2, arg3);
+  }
+
+  public int getOffscreenContextPixelDataType() {
+    throw new GLException("Should not call this");
+  }
+
+  public int getOffscreenContextReadBuffer() {
+    throw new GLException("Should not call this");
+  }
+
+  public boolean offscreenImageNeedsVerticalFlip() {
+    throw new GLException("Should not call this");
+  }
+
+  public void bindPbufferToTexture() {
+    throw new GLException("Should not call this");
+  }
+
+  public void releasePbufferFromTexture() {
+    throw new GLException("Should not call this");
+  }
+
+  //----------------------------------------------------------------------
+  // Internals only below this point
+  //
+
+  public long getHGLRC() {
+    return hglrc;
+  }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsWGLDrawable.java b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsWGLDrawable.java
new file mode 100644
index 000000000..c76766b2e
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsWGLDrawable.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution 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.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.impl.windows.wgl;
+
+import javax.media.nativewindow.*;
+import javax.media.opengl.*;
+import com.jogamp.opengl.impl.*;
+import com.jogamp.gluegen.runtime.DynamicLookupHelper;
+
+public abstract class WindowsWGLDrawable extends GLDrawableImpl {
+  private static final int MAX_SET_PIXEL_FORMAT_FAIL_COUNT = 5;
+  private static final boolean PROFILING = Debug.debug("WindowsWGLDrawable.profiling");
+  private static final int PROFILING_TICKS = 200;
+  private int  profilingLockSurfaceTicks;
+  private long profilingLockSurfaceTime;
+  private int  profilingUnlockSurfaceTicks;
+  private long profilingUnlockSurfaceTime;
+  private int  profilingSwapBuffersTicks;
+  private long profilingSwapBuffersTime;
+
+
+  public WindowsWGLDrawable(GLDrawableFactory factory, NativeWindow comp, boolean realized) {
+    super(factory, comp, realized);
+  }
+
+  protected void setRealizedImpl() {
+    if(!realized) {
+        return; // nothing todo ..
+    }
+
+    if(NativeWindow.LOCK_SURFACE_NOT_READY == lockSurface()) {
+      throw new GLException("WindowsWGLDrawable.setRealized(true): lockSurface - surface not ready");
+    }
+    try {
+        NativeWindow nativeWindow = getNativeWindow();
+        WindowsWGLGraphicsConfiguration config = (WindowsWGLGraphicsConfiguration)nativeWindow.getGraphicsConfiguration().getNativeGraphicsConfiguration();
+        config.updateGraphicsConfiguration(getFactory(), nativeWindow);
+        if (DEBUG) {
+          System.err.println("!!! WindowsWGLDrawable.setRealized(true): "+config);
+        }
+    } finally {
+        unlockSurface();
+    }
+  }
+
+  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;
+        }
+
+        long startTime = 0;
+        if (PROFILING) {
+          startTime = System.currentTimeMillis();
+        }
+
+        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();
+        }
+    }
+  }
+
+  public DynamicLookupHelper getDynamicLookupHelper() {
+    return (WindowsWGLDrawableFactory) getFactoryImpl() ;
+  }
+
+  protected static String getThreadName() {
+    return Thread.currentThread().getName();
+  }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsWGLDrawableFactory.java b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsWGLDrawableFactory.java
new file mode 100644
index 000000000..38b9bac51
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsWGLDrawableFactory.java
@@ -0,0 +1,279 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution 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.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.impl.windows.wgl;
+
+import java.nio.*;
+import java.util.*;
+import javax.media.nativewindow.*;
+import javax.media.opengl.*;
+import com.jogamp.opengl.impl.*;
+import com.sun.nativewindow.impl.NWReflection;
+import com.jogamp.gluegen.runtime.DynamicLookupHelper;
+import com.sun.nativewindow.impl.NullWindow;
+
+public class WindowsWGLDrawableFactory extends GLDrawableFactoryImpl implements DynamicLookupHelper {
+  private static final boolean VERBOSE = Debug.verbose();
+
+  // Handle to GLU32.dll
+  // FIXME: this should go away once we delete support for the C GLU library
+  private long hglu32;
+
+  // Handle to core OpenGL32.dll
+  private long hopengl32;
+
+  public WindowsWGLDrawableFactory() {
+    super();
+
+    // Register our GraphicsConfigurationFactory implementations
+    // The act of constructing them causes them to be registered
+    new WindowsWGLGraphicsConfigurationFactory();
+    try {
+      NWReflection.createInstance("com.jogamp.opengl.impl.windows.wgl.awt.WindowsAWTWGLGraphicsConfigurationFactory",
+                                  new Object[] {});
+    } catch (Throwable t) { }
+
+    loadOpenGL32Library();
+  }
+
+  public GLDrawableImpl createOnscreenDrawable(NativeWindow target) {
+    if (target == null) {
+      throw new IllegalArgumentException("Null target");
+    }
+    return new WindowsOnscreenWGLDrawable(this, target);
+  }
+
+  protected GLDrawableImpl createOffscreenDrawable(NativeWindow target) {
+    return new WindowsOffscreenWGLDrawable(this, target);
+  }
+
+  private boolean pbufferSupportInitialized = false;
+  private boolean canCreateGLPbuffer = false;
+  public boolean canCreateGLPbuffer() {
+    if (!pbufferSupportInitialized) {
+      final GLDrawableFactory factory = this;
+      Runnable r = new Runnable() {
+          public void run() {
+            WindowsDummyWGLDrawable dummyDrawable = new WindowsDummyWGLDrawable(factory);
+            GLContext dummyContext  = dummyDrawable.createContext(null);
+            if (dummyContext != null) {
+              GLContext lastContext = GLContext.getCurrent();
+              if (lastContext != null) {
+                lastContext.release();
+              }
+              dummyContext.makeCurrent();
+              GL dummyGL = dummyContext.getGL();
+              canCreateGLPbuffer = dummyGL.isExtensionAvailable("GL_ARB_pbuffer");
+              pbufferSupportInitialized = true;
+              dummyContext.release();
+              dummyContext.destroy();
+              dummyDrawable.destroy();
+              if (lastContext != null) {
+                lastContext.makeCurrent();
+              }
+            }
+          }
+        };
+      maybeDoSingleThreadedWorkaround(r);
+    }
+    if (DEBUG) {
+      System.err.println("WindowsWGLDrawableFactory.canCreateGLPbuffer() = " + canCreateGLPbuffer);
+    }
+    return canCreateGLPbuffer;
+  }
+
+  protected GLDrawableImpl createGLPbufferDrawableImpl(final NativeWindow target) {
+    final List returnList = new ArrayList();
+    final GLDrawableFactory factory = this;
+    Runnable r = new Runnable() {
+        public void run() {
+          WindowsDummyWGLDrawable dummyDrawable = new WindowsDummyWGLDrawable(factory);
+          WindowsWGLContext       dummyContext  = (WindowsWGLContext) dummyDrawable.createContext(null);
+          GLContext lastContext = GLContext.getCurrent();
+          if (lastContext != null) {
+            lastContext.release();
+          }
+          dummyContext.makeCurrent();
+          WGLExt dummyWGLExt = dummyContext.getWGLExt();
+          try {
+            GLDrawableImpl pbufferDrawable = new WindowsPbufferWGLDrawable(factory, target,
+                                                                           dummyDrawable,
+                                                                           dummyWGLExt);
+            returnList.add(pbufferDrawable);
+            dummyContext.release();
+            dummyContext.destroy();
+            dummyDrawable.destroy();
+          } finally {
+            if (lastContext != null) {
+              lastContext.makeCurrent();
+            }
+          }
+        }
+      };
+    maybeDoSingleThreadedWorkaround(r);
+    return (GLDrawableImpl) returnList.get(0);
+  }
+
+  protected NativeWindow createOffscreenWindow(GLCapabilities capabilities, GLCapabilitiesChooser chooser, int width, int height) {
+    AbstractGraphicsScreen screen = DefaultGraphicsScreen.createDefault();
+    NullWindow nw = new NullWindow(WindowsWGLGraphicsConfigurationFactory.chooseGraphicsConfigurationStatic(
+                                   capabilities, chooser, screen) );
+    nw.setSize(width, height);
+    return nw;
+  }
+ 
+  public GLContext createExternalGLContext() {
+    return WindowsExternalWGLContext.create(this, null);
+  }
+
+  public boolean canCreateExternalGLDrawable() {
+    return true;
+  }
+
+  public GLDrawable createExternalGLDrawable() {
+    return WindowsExternalWGLDrawable.create(this, null);
+  }
+
+  public void loadOpenGL32Library() {
+    if (hopengl32 == 0) {
+      hopengl32 = WGL.LoadLibraryA("OpenGL32");
+      if (DEBUG) {
+        if (hopengl32 == 0) {
+          System.err.println("WindowsWGLDrawableFactory: Could not load OpenGL32.dll - maybe an embedded device");
+        }
+      }
+    }
+  }
+
+  public void loadGLULibrary() {
+    if (hglu32 == 0) {
+      hglu32 = WGL.LoadLibraryA("GLU32");
+      if (hglu32 == 0) {
+        throw new GLException("Error loading GLU32.DLL");
+      }
+    }
+  }
+
+  public long dynamicLookupFunction(String glFuncName) {
+    long res = WGL.wglGetProcAddress(glFuncName);
+    if (res == 0) {
+      // It may happen that a driver doesn't return the OpenGL32 core function pointer
+      // with wglGetProcAddress (e.g. NVidia GL 3.1) - hence we have to look harder.
+      if (hopengl32 != 0) {
+        res = WGL.GetProcAddress(hopengl32, glFuncName);
+      }
+    }
+    if (res == 0) {
+      // GLU routines aren't known to the OpenGL function lookup
+      if (hglu32 != 0) {
+        res = WGL.GetProcAddress(hglu32, glFuncName);
+      }
+    }
+    return res;
+  }
+
+  static String wglGetLastError() {
+    long err = WGL.GetLastError();
+    String detail = null;
+    switch ((int) err) {
+      case WGL.ERROR_INVALID_PIXEL_FORMAT: detail = "ERROR_INVALID_PIXEL_FORMAT";       break;
+      case WGL.ERROR_NO_SYSTEM_RESOURCES:  detail = "ERROR_NO_SYSTEM_RESOURCES";        break;
+      case WGL.ERROR_INVALID_DATA:         detail = "ERROR_INVALID_DATA";               break;
+      case WGL.ERROR_PROC_NOT_FOUND:       detail = "ERROR_PROC_NOT_FOUND";             break;
+      case WGL.ERROR_INVALID_WINDOW_HANDLE:detail = "ERROR_INVALID_WINDOW_HANDLE";      break;
+      default:                             detail = "(Unknown error code " + err + ")"; break;
+    }
+    return detail;
+  }
+
+  public boolean canCreateContextOnJava2DSurface() {
+    return false;
+  }
+
+  public GLContext createContextOnJava2DSurface(Object graphics, GLContext shareWith)
+    throws GLException {
+    throw new GLException("Unimplemented on this platform");
+  }
+
+  //------------------------------------------------------
+  // Gamma-related functionality
+  //
+
+  private static final int GAMMA_RAMP_LENGTH = 256;
+
+  protected int getGammaRampLength() {
+    return GAMMA_RAMP_LENGTH;
+  }
+
+  protected boolean setGammaRamp(float[] ramp) {
+    short[] rampData = new short[3 * GAMMA_RAMP_LENGTH];
+    for (int i = 0; i < GAMMA_RAMP_LENGTH; i++) {
+      short scaledValue = (short) (ramp[i] * 65535);
+      rampData[i] = scaledValue;
+      rampData[i +     GAMMA_RAMP_LENGTH] = scaledValue;
+      rampData[i + 2 * GAMMA_RAMP_LENGTH] = scaledValue;
+    }
+
+    long screenDC = WGL.GetDC(0);
+    boolean res = WGL.SetDeviceGammaRamp(screenDC, ShortBuffer.wrap(rampData));
+    WGL.ReleaseDC(0, screenDC);
+    return res;
+  }
+
+  protected Buffer getGammaRamp() {
+    ShortBuffer rampData = ShortBuffer.wrap(new short[3 * GAMMA_RAMP_LENGTH]);
+    long screenDC = WGL.GetDC(0);
+    boolean res = WGL.GetDeviceGammaRamp(screenDC, rampData);
+    WGL.ReleaseDC(0, screenDC);
+    if (!res) {
+      return null;
+    }
+    return rampData;
+  }
+
+  protected void resetGammaRamp(Buffer originalGammaRamp) {
+    if (originalGammaRamp == null) {
+      // getGammaRamp failed earlier
+      return;
+    }
+    long screenDC = WGL.GetDC(0);
+    WGL.SetDeviceGammaRamp(screenDC, originalGammaRamp);
+    WGL.ReleaseDC(0, screenDC);
+  }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsWGLGraphicsConfiguration.java b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsWGLGraphicsConfiguration.java
new file mode 100644
index 000000000..bb59434b7
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsWGLGraphicsConfiguration.java
@@ -0,0 +1,638 @@
+/*
+ * Copyright (c) 2008 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution 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.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+package com.jogamp.opengl.impl.windows.wgl;
+
+import java.util.*;
+import javax.media.nativewindow.*;
+import javax.media.opengl.*;
+import com.jogamp.opengl.impl.*;
+import com.jogamp.gluegen.runtime.NativeLibrary;
+
+public class WindowsWGLGraphicsConfiguration extends DefaultGraphicsConfiguration implements Cloneable {
+    // Keep this under the same debug flag as the drawable factory for convenience
+    protected static final boolean DEBUG = com.jogamp.opengl.impl.Debug.debug("GraphicsConfiguration");
+    
+    protected static final int MAX_PFORMATS = 256;
+    protected static final int MAX_ATTRIBS  = 256;
+
+    private PIXELFORMATDESCRIPTOR pixelfmt;
+    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) {
+        super(screen, capsChosen, capsRequested);
+        this.chooser=chooser;
+        this.pixelfmt = pixelfmt;
+        this.pixelfmtID = pixelfmtID;
+    }
+
+    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, false);
+
+        return cfg;
+    }
+
+    public Object clone() {
+        return super.clone();
+    }
+
+    /** Update config - before having a valid context */
+    protected void updateGraphicsConfiguration(GLDrawableFactory factory, NativeWindow nativeWindow) {
+        WindowsWGLGraphicsConfigurationFactory.updateGraphicsConfiguration(chooser, factory, nativeWindow);
+    }
+
+    /** 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);
+        this.isChosen=true;
+        this.choosenByWGLPixelFormat=choosenByWGLPixelFormat;
+        if (DEBUG) {
+            System.err.println("*** setCapsPFD: WGL-Choosen "+choosenByWGLPixelFormat+", pfdID "+pfdID+", "+caps);
+        }
+    }
+
+    public boolean getCapabilitiesChosen() {
+        return isChosen;
+    }
+
+    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,
+                                                  WGLExt wglExt,
+                                                  boolean pbuffer,
+                                                  int[] floatMode) throws GLException {
+        if (!wglExt.isExtensionAvailable("WGL_ARB_pixel_format")) {
+          return false;
+        }
+
+        int niattribs = 0;
+
+        iattributes[niattribs++] = WGLExt.WGL_SUPPORT_OPENGL_ARB;
+        iattributes[niattribs++] = GL.GL_TRUE;
+        if (pbuffer) {
+          iattributes[niattribs++] = WGLExt.WGL_DRAW_TO_PBUFFER_ARB;
+          iattributes[niattribs++] = GL.GL_TRUE;
+        } else {
+          iattributes[niattribs++] = WGLExt.WGL_DRAW_TO_WINDOW_ARB;
+          iattributes[niattribs++] = GL.GL_TRUE;
+        }
+
+        iattributes[niattribs++] = WGLExt.WGL_DOUBLE_BUFFER_ARB;
+        if (caps.getDoubleBuffered()) {
+          iattributes[niattribs++] = GL.GL_TRUE;
+        } else {
+          iattributes[niattribs++] = GL.GL_FALSE;
+        }
+
+        iattributes[niattribs++] = WGLExt.WGL_STEREO_ARB;
+        if (caps.getStereo()) {
+          iattributes[niattribs++] = GL.GL_TRUE;
+        } else {
+          iattributes[niattribs++] = GL.GL_FALSE;
+        }
+        
+        iattributes[niattribs++] = WGLExt.WGL_DEPTH_BITS_ARB;
+        iattributes[niattribs++] = caps.getDepthBits();
+        iattributes[niattribs++] = WGLExt.WGL_RED_BITS_ARB;
+        iattributes[niattribs++] = caps.getRedBits();
+        iattributes[niattribs++] = WGLExt.WGL_GREEN_BITS_ARB;
+        iattributes[niattribs++] = caps.getGreenBits();
+        iattributes[niattribs++] = WGLExt.WGL_BLUE_BITS_ARB;
+        iattributes[niattribs++] = caps.getBlueBits();
+        iattributes[niattribs++] = WGLExt.WGL_ALPHA_BITS_ARB;
+        iattributes[niattribs++] = caps.getAlphaBits();
+        iattributes[niattribs++] = WGLExt.WGL_STENCIL_BITS_ARB;
+        iattributes[niattribs++] = caps.getStencilBits();
+        if (caps.getAccumRedBits()   > 0 ||
+            caps.getAccumGreenBits() > 0 ||
+            caps.getAccumBlueBits()  > 0 ||
+            caps.getAccumAlphaBits() > 0) {
+          iattributes[niattribs++] = WGLExt.WGL_ACCUM_BITS_ARB;
+          iattributes[niattribs++] = (caps.getAccumRedBits() +
+                                      caps.getAccumGreenBits() +
+                                      caps.getAccumBlueBits() +
+                                      caps.getAccumAlphaBits());
+          iattributes[niattribs++] = WGLExt.WGL_ACCUM_RED_BITS_ARB;
+          iattributes[niattribs++] = caps.getAccumRedBits();
+          iattributes[niattribs++] = WGLExt.WGL_ACCUM_GREEN_BITS_ARB;
+          iattributes[niattribs++] = caps.getAccumGreenBits();
+          iattributes[niattribs++] = WGLExt.WGL_ACCUM_BLUE_BITS_ARB;
+          iattributes[niattribs++] = caps.getAccumBlueBits();
+          iattributes[niattribs++] = WGLExt.WGL_ACCUM_ALPHA_BITS_ARB;
+          iattributes[niattribs++] = caps.getAccumAlphaBits();
+        }
+
+        if (wglExt.isExtensionAvailable("WGL_ARB_multisample")) {
+          if (caps.getSampleBuffers()) {
+            iattributes[niattribs++] = WGLExt.WGL_SAMPLE_BUFFERS_ARB;
+            iattributes[niattribs++] = GL.GL_TRUE;
+            iattributes[niattribs++] = WGLExt.WGL_SAMPLES_ARB;
+            iattributes[niattribs++] = caps.getNumSamples();
+          }
+        }
+
+        boolean rtt      = caps.getPbufferRenderToTexture();
+        boolean rect     = caps.getPbufferRenderToTextureRectangle();
+        boolean useFloat = caps.getPbufferFloatingPointBuffers();
+        boolean ati      = false;
+        if (pbuffer) {
+          // Check some invariants and set up some state
+          if (rect && !rtt) {
+            throw new GLException("Render-to-texture-rectangle requires render-to-texture to be specified");
+          }
+
+          if (rect) {
+            if (!wglExt.isExtensionAvailable("GL_NV_texture_rectangle")) {
+              throw new GLException("Render-to-texture-rectangle requires GL_NV_texture_rectangle extension");
+            }
+          }
+
+          if (useFloat) {
+            if (!wglExt.isExtensionAvailable("WGL_ATI_pixel_format_float") &&
+                !wglExt.isExtensionAvailable("WGL_NV_float_buffer")) {
+              throw new GLException("Floating-point pbuffers not supported by this hardware");
+            }
+
+            // Prefer NVidia extension over ATI
+            if (wglExt.isExtensionAvailable("WGL_NV_float_buffer")) {
+              ati = false;
+              floatMode[0] = GLPbuffer.NV_FLOAT;
+            } else {
+              ati = true;
+              floatMode[0] = GLPbuffer.ATI_FLOAT;
+            }
+            if (DEBUG) {
+              System.err.println("Using " + (ati ? "ATI" : "NVidia") + " floating-point extension");
+            }
+          }
+
+          // See whether we need to change the pixel type to support ATI's
+          // floating-point pbuffers
+          if (useFloat && ati) {
+            if (rtt) {
+              throw new GLException("Render-to-floating-point-texture not supported on ATI hardware");
+            } else {
+              iattributes[niattribs++] = WGLExt.WGL_PIXEL_TYPE_ARB;
+              iattributes[niattribs++] = WGLExt.WGL_TYPE_RGBA_FLOAT_ARB;
+            }
+          } else {
+            if (!rtt) {
+              // Currently we don't support non-truecolor visuals in the
+              // GLCapabilities, so we don't offer the option of making
+              // color-index pbuffers.
+              iattributes[niattribs++] = WGLExt.WGL_PIXEL_TYPE_ARB;
+              iattributes[niattribs++] = WGLExt.WGL_TYPE_RGBA_ARB;
+            }
+          }
+
+          if (useFloat && !ati) {
+            iattributes[niattribs++] = WGLExt.WGL_FLOAT_COMPONENTS_NV;
+            iattributes[niattribs++] = GL.GL_TRUE;
+          }
+
+          if (rtt) {
+            if (useFloat) {
+              assert(!ati);
+              if (!rect) {
+                throw new GLException("Render-to-floating-point-texture only supported on NVidia hardware with render-to-texture-rectangle");
+              }
+              iattributes[niattribs++] = WGLExt.WGL_BIND_TO_TEXTURE_RECTANGLE_FLOAT_RGB_NV;
+              iattributes[niattribs++] = GL.GL_TRUE;
+            } else {
+              iattributes[niattribs++] = rect ? WGLExt.WGL_BIND_TO_TEXTURE_RECTANGLE_RGB_NV : WGLExt.WGL_BIND_TO_TEXTURE_RGB_ARB;
+              iattributes[niattribs++] = GL.GL_TRUE;
+            }
+          }
+        } else {
+          iattributes[niattribs++] = WGLExt.WGL_PIXEL_TYPE_ARB;
+          iattributes[niattribs++] = WGLExt.WGL_TYPE_RGBA_ARB;
+        }
+        iattributes[niattribs++] = 0;
+
+        return true;
+    }
+
+    public static final int WINDOW_BIT  = 1 << 0 ;
+    public static final int BITMAP_BIT  = 1 << 1 ;
+    public static final int PBUFFER_BIT = 1 << 2 ;
+
+    public static int WGLConfig2DrawableTypeBits(int[] iattribs,
+                                                 int niattribs,
+                                                 int[] iresults) {
+        int val = 0;
+
+        for (int i = 0; i < niattribs; i++) {
+          int attr = iattribs[i];
+          switch (attr) {
+            case WGLExt.WGL_DRAW_TO_WINDOW_ARB:
+                if(iresults[i] == GL.GL_TRUE) val |= WINDOW_BIT;
+                break;
+            case WGLExt.WGL_DRAW_TO_BITMAP_ARB:
+                if(iresults[i] == GL.GL_TRUE) val |= BITMAP_BIT;
+                break;
+            case WGLExt.WGL_DRAW_TO_PBUFFER_ARB:
+                if(iresults[i] == GL.GL_TRUE) val |= PBUFFER_BIT;
+                break;
+            }
+        }
+        return val;
+    }
+
+    public static boolean WGLConfigDrawableTypeVerify(int val, boolean onscreen, boolean usePBuffer) {
+        boolean res;
+
+        if ( onscreen ) {
+            res = ( 0 != (val & WINDOW_BIT) ) ;
+        } else {
+            res = ( 0 != (val & BITMAP_BIT) ) || usePBuffer ;
+        }
+        if ( usePBuffer ) {
+            res = res && ( 0 != (val & PBUFFER_BIT) ) ;
+        }
+
+        return res;
+    }
+    public static GLCapabilities AttribList2GLCapabilities(GLProfile glp, int[] iattribs,
+                                                         int niattribs,
+                                                         int[] iresults,
+                                                         boolean relaxed, boolean onscreen, boolean usePBuffer) {
+        GLCapabilities res = new GLCapabilities(glp);
+        int drawableTypeBits = WGLConfig2DrawableTypeBits(iattribs, niattribs, iresults);
+        if(WGLConfigDrawableTypeVerify(drawableTypeBits, onscreen, usePBuffer)) {
+            res.setOnscreen(onscreen);
+            res.setPBuffer(usePBuffer);
+        } else if(relaxed) {
+            res.setOnscreen( 0 != (drawableTypeBits & WINDOW_BIT) );
+            res.setPBuffer ( 0 != (drawableTypeBits & PBUFFER_BIT) );
+        } else {
+            throw new GLException("WGL DrawableType does not match !!!");
+        }
+
+        for (int i = 0; i < niattribs; i++) {
+          int attr = iattribs[i];
+          switch (attr) {
+            case WGLExt.WGL_DRAW_TO_WINDOW_ARB:
+            case WGLExt.WGL_DRAW_TO_BITMAP_ARB:
+            case WGLExt.WGL_DRAW_TO_PBUFFER_ARB:
+              break;
+
+            case WGLExt.WGL_ACCELERATION_ARB:
+              res.setHardwareAccelerated(iresults[i] == WGLExt.WGL_FULL_ACCELERATION_ARB);
+              break;
+
+            case WGLExt.WGL_SUPPORT_OPENGL_ARB:
+              if (iresults[i] != GL.GL_TRUE) {
+                return null;
+              }
+              break;
+
+            case WGLExt.WGL_DEPTH_BITS_ARB:
+              res.setDepthBits(iresults[i]);
+              break;
+
+            case WGLExt.WGL_STENCIL_BITS_ARB:
+              res.setStencilBits(iresults[i]);
+              break;
+
+            case WGLExt.WGL_DOUBLE_BUFFER_ARB:
+              res.setDoubleBuffered(iresults[i] == GL.GL_TRUE);
+              break;
+
+            case WGLExt.WGL_STEREO_ARB:
+              res.setStereo(iresults[i] == GL.GL_TRUE);
+              break;
+
+            case WGLExt.WGL_PIXEL_TYPE_ARB:
+              // Fail softly with unknown results here
+              if (iresults[i] == WGLExt.WGL_TYPE_RGBA_ARB||
+                  iresults[i] == WGLExt.WGL_TYPE_RGBA_FLOAT_ARB) {
+                res.setPbufferFloatingPointBuffers(true);
+              }
+              break;
+
+            case WGLExt.WGL_FLOAT_COMPONENTS_NV:
+              if (iresults[i] != 0) {
+                res.setPbufferFloatingPointBuffers(true);
+              }
+              break;
+
+            case WGLExt.WGL_RED_BITS_ARB:
+              res.setRedBits(iresults[i]);
+              break;
+              
+            case WGLExt.WGL_GREEN_BITS_ARB:
+              res.setGreenBits(iresults[i]);
+              break;
+
+            case WGLExt.WGL_BLUE_BITS_ARB:
+              res.setBlueBits(iresults[i]);
+              break;
+
+            case WGLExt.WGL_ALPHA_BITS_ARB:
+              res.setAlphaBits(iresults[i]);
+              break;
+
+            case WGLExt.WGL_ACCUM_RED_BITS_ARB:
+              res.setAccumRedBits(iresults[i]);
+              break;
+
+            case WGLExt.WGL_ACCUM_GREEN_BITS_ARB:
+              res.setAccumGreenBits(iresults[i]);
+              break;
+
+            case WGLExt.WGL_ACCUM_BLUE_BITS_ARB:
+              res.setAccumBlueBits(iresults[i]);
+              break;
+
+            case WGLExt.WGL_ACCUM_ALPHA_BITS_ARB:
+              res.setAccumAlphaBits(iresults[i]);
+              break;
+
+            case WGLExt.WGL_SAMPLE_BUFFERS_ARB:
+              res.setSampleBuffers(iresults[i] != 0);
+              break;
+
+            case WGLExt.WGL_SAMPLES_ARB:
+              res.setNumSamples(iresults[i]);
+              break;
+
+            default:
+              throw new GLException("Unknown pixel format attribute " + iattribs[i]);
+          }
+        }
+        return res;
+    }
+
+  // PIXELFORMAT
+
+    public static GLCapabilities PFD2GLCapabilities(GLProfile glp, PIXELFORMATDESCRIPTOR pfd, boolean onscreen, boolean usePBuffer) {
+        if ((pfd.getDwFlags() & WGL.PFD_SUPPORT_OPENGL) == 0) {
+          return null;
+        }
+        GLCapabilities res = new GLCapabilities(glp);
+        res.setRedBits       (pfd.getCRedBits());
+        res.setGreenBits     (pfd.getCGreenBits());
+        res.setBlueBits      (pfd.getCBlueBits());
+        res.setAlphaBits     (pfd.getCAlphaBits());
+        res.setAccumRedBits  (pfd.getCAccumRedBits());
+        res.setAccumGreenBits(pfd.getCAccumGreenBits());
+        res.setAccumBlueBits (pfd.getCAccumBlueBits());
+        res.setAccumAlphaBits(pfd.getCAccumAlphaBits());
+        res.setDepthBits     (pfd.getCDepthBits());
+        res.setStencilBits   (pfd.getCStencilBits());
+        res.setDoubleBuffered((pfd.getDwFlags() & WGL.PFD_DOUBLEBUFFER) != 0);
+        res.setStereo        ((pfd.getDwFlags() & WGL.PFD_STEREO) != 0);
+        res.setHardwareAccelerated( ((pfd.getDwFlags() & WGL.PFD_GENERIC_FORMAT) == 0) ||
+                                    ((pfd.getDwFlags() & WGL.PFD_GENERIC_ACCELERATED) != 0) );
+        res.setOnscreen      ( onscreen && ((pfd.getDwFlags() & WGL.PFD_DRAW_TO_WINDOW) != 0) );
+        res.setPBuffer       ( usePBuffer );
+        /* FIXME: Missing ??
+        if (GLXUtil.isMultisampleAvailable()) {
+          res.setSampleBuffers(glXGetFBConfig(display, fbcfg, GLX.GLX_SAMPLE_BUFFERS, tmp, 0) != 0);
+          res.setNumSamples   (glXGetFBConfig(display, fbcfg, GLX.GLX_SAMPLES,        tmp, 0));
+        }
+        res.setBackgroundOpaque(glXGetFBConfig(display, fbcfg, GLX.GLX_TRANSPARENT_TYPE, tmp, 0) != GLX.GLX_NONE);
+        try { 
+            res.setPbufferFloatingPointBuffers(glXGetFBConfig(display, fbcfg, GLXExt.GLX_FLOAT_COMPONENTS_NV, tmp, 0) != GL.GL_FALSE);
+        } catch (Exception e) {}
+        */
+        return res;
+  }
+
+  public static PIXELFORMATDESCRIPTOR GLCapabilities2PFD(GLCapabilities caps) {
+    int colorDepth = (caps.getRedBits() +
+                      caps.getGreenBits() +
+                      caps.getBlueBits());
+    if (colorDepth < 15) {
+      throw new GLException("Bit depths < 15 (i.e., non-true-color) not supported");
+    }
+    PIXELFORMATDESCRIPTOR pfd = createPixelFormatDescriptor();
+    int pfdFlags = (WGL.PFD_SUPPORT_OPENGL |
+                    WGL.PFD_GENERIC_ACCELERATED);
+    if (caps.getDoubleBuffered()) {
+      pfdFlags |= WGL.PFD_DOUBLEBUFFER;
+    }
+    if (caps.isOnscreen()) {
+      pfdFlags |= WGL.PFD_DRAW_TO_WINDOW;
+    } else {
+      pfdFlags |= WGL.PFD_DRAW_TO_BITMAP;
+    }
+    if (caps.getStereo()) {
+      pfdFlags |= WGL.PFD_STEREO;
+    }
+    pfd.setDwFlags(pfdFlags);
+    pfd.setIPixelType((byte) WGL.PFD_TYPE_RGBA);
+    pfd.setCColorBits((byte) colorDepth);
+    pfd.setCRedBits  ((byte) caps.getRedBits());
+    pfd.setCGreenBits((byte) caps.getGreenBits());
+    pfd.setCBlueBits ((byte) caps.getBlueBits());
+    pfd.setCAlphaBits((byte) caps.getAlphaBits());
+    int accumDepth = (caps.getAccumRedBits() +
+                      caps.getAccumGreenBits() +
+                      caps.getAccumBlueBits());
+    pfd.setCAccumBits     ((byte) accumDepth);
+    pfd.setCAccumRedBits  ((byte) caps.getAccumRedBits());
+    pfd.setCAccumGreenBits((byte) caps.getAccumGreenBits());
+    pfd.setCAccumBlueBits ((byte) caps.getAccumBlueBits());
+    pfd.setCAccumAlphaBits((byte) caps.getAccumAlphaBits());
+    pfd.setCDepthBits((byte) caps.getDepthBits());
+    pfd.setCStencilBits((byte) caps.getStencilBits());
+    pfd.setILayerType((byte) WGL.PFD_MAIN_PLANE);
+
+    /* FIXME: Missing: 
+      caps.getSampleBuffers()
+      caps.getNumSamples   ()
+    }
+    caps.getBackgroundOpaque()
+    try { 
+        caps.getPbufferFloatingPointBuffers()
+    } catch (Exception e) {}
+    */
+    return pfd;
+  }
+
+  public static PIXELFORMATDESCRIPTOR createPixelFormatDescriptor() {
+    PIXELFORMATDESCRIPTOR pfd = PIXELFORMATDESCRIPTOR.create();
+    pfd.setNSize((short) pfd.size());
+    pfd.setNVersion((short) 1);
+    return pfd;
+  }
+
+  public String toString() {
+    return "WindowsWGLGraphicsConfiguration["+getScreen()+", pfdID " + pixelfmtID + ", wglChoosen "+choosenByWGLPixelFormat+
+                                            ",\n\trequested " + getRequestedCapabilities() +
+                                            ",\n\tchosen    " + getChosenCapabilities() +
+                                            "]";
+  }
+}
+
diff --git a/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsWGLGraphicsConfigurationFactory.java b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsWGLGraphicsConfigurationFactory.java
new file mode 100644
index 000000000..06590a913
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/WindowsWGLGraphicsConfigurationFactory.java
@@ -0,0 +1,319 @@
+/*
+ * Copyright (c) 2008 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution 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.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+package com.jogamp.opengl.impl.windows.wgl;
+
+import javax.media.nativewindow.*;
+import javax.media.nativewindow.windows.*;
+import com.sun.nativewindow.impl.*;
+
+import javax.media.opengl.*;
+import com.jogamp.opengl.impl.*;
+
+/** Subclass of GraphicsConfigurationFactory used when non-AWT tookits
+    are used on Windows platforms. Toolkits will likely need to delegate
+    to this one to change the accepted and returned types of the
+    GraphicsDevice and GraphicsConfiguration abstractions. */
+
+public class WindowsWGLGraphicsConfigurationFactory extends GraphicsConfigurationFactory {
+    protected static final boolean DEBUG = com.jogamp.opengl.impl.Debug.debug("GraphicsConfiguration");
+
+    public WindowsWGLGraphicsConfigurationFactory() {
+        GraphicsConfigurationFactory.registerFactory(javax.media.nativewindow.windows.WindowsGraphicsDevice.class, this);
+    }
+
+    public AbstractGraphicsConfiguration chooseGraphicsConfiguration(Capabilities capabilities,
+                                                                     CapabilitiesChooser chooser,
+                                                                     AbstractGraphicsScreen absScreen) {
+        GLCapabilities caps = (GLCapabilities)capabilities;
+        return chooseGraphicsConfigurationStatic(caps, chooser, absScreen);
+    }
+
+    protected static WindowsWGLGraphicsConfiguration createDefaultGraphicsConfiguration(AbstractGraphicsScreen absScreen, boolean onscreen, boolean usePBuffer) {
+        GLCapabilities caps = new GLCapabilities(null);
+        caps.setDoubleBuffered(onscreen); // FIXME
+        caps.setOnscreen  (onscreen);
+        caps.setPBuffer   (usePBuffer);
+
+        GLCapabilities caps2 = (GLCapabilities) caps.clone();
+        if(!caps2.isOnscreen()) {
+            // OFFSCREEN !DOUBLE_BUFFER
+            caps2.setDoubleBuffered(false);
+        }
+
+        if(null==absScreen) {
+            absScreen = DefaultGraphicsScreen.createScreenDevice(0);
+        }
+        return new WindowsWGLGraphicsConfiguration(absScreen, caps2, caps, WindowsWGLGraphicsConfiguration.GLCapabilities2PFD(caps2), -1, null);
+    }
+
+    protected static WindowsWGLGraphicsConfiguration chooseGraphicsConfigurationStatic(GLCapabilities caps,
+                                                                                       CapabilitiesChooser chooser,
+                                                                                       AbstractGraphicsScreen absScreen) {
+        if(null==absScreen) {
+            absScreen = DefaultGraphicsScreen.createScreenDevice(0);
+        }
+        GLCapabilities caps2 = (GLCapabilities) caps.clone();
+        if(!caps2.isOnscreen()) {
+            // OFFSCREEN !DOUBLE_BUFFER
+            caps2.setDoubleBuffered(false);
+        }
+        return new WindowsWGLGraphicsConfiguration(absScreen, caps2, caps, WindowsWGLGraphicsConfiguration.GLCapabilities2PFD(caps2), -1, 
+                                                   (GLCapabilitiesChooser)chooser);
+    }
+
+    protected static void updateGraphicsConfiguration(CapabilitiesChooser chooser,
+                                                      GLDrawableFactory factory, NativeWindow nativeWindow) {
+        if (nativeWindow == null) {
+            throw new IllegalArgumentException("NativeWindow is null");
+        }
+
+        if (chooser != null &&
+            !(chooser instanceof GLCapabilitiesChooser)) {
+            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();
+        boolean usePBuffer = capabilities.isPBuffer();
+        GLProfile glProfile = capabilities.getGLProfile();
+        long hdc = nativeWindow.getSurfaceHandle();
+
+        if (DEBUG) {
+          Exception ex = new Exception("WindowsWGLGraphicsConfigurationFactory got HDC "+toHexString(hdc));
+          ex.printStackTrace();
+          System.err.println("WindowsWGLGraphicsConfigurationFactory got NW    "+nativeWindow);
+        }
+
+        PIXELFORMATDESCRIPTOR pfd = null;
+        int pixelFormat = -1; // 1-based pixel format
+        boolean pixelFormatSet = false;
+        GLCapabilities chosenCaps = null;
+
+        if (onscreen) {
+          if ((pixelFormat = WGL.GetPixelFormat(hdc)) != 0) {
+            // Pixelformat already set by either 
+            //  - a previous updateGraphicsConfiguration() call on the same HDC,
+            //  - the graphics driver, copying the HDC's pixelformat to the new one,
+            //  - or the Java2D/OpenGL pipeline's configuration
+            if (DEBUG) {
+              System.err.println("!!!! NOTE: pixel format already chosen for HDC: " + toHexString(hdc)+
+                                 ", pixelformat "+pixelFormat);
+            }
+            pixelFormatSet = true;
+          }
+
+          GLCapabilities[] availableCaps = null;
+          int numFormats = 0;
+          pfd = WindowsWGLGraphicsConfiguration.createPixelFormatDescriptor();
+          // Produce a recommended pixel format selection for the GLCapabilitiesChooser.
+          // Use wglChoosePixelFormatARB if user requested multisampling and if we have it available
+          WindowsWGLDrawable dummyDrawable = null;
+          GLContextImpl     dummyContext  = null;
+          WGLExt            dummyWGLExt   = null;
+          if (capabilities.getSampleBuffers()) {
+              dummyDrawable = new WindowsDummyWGLDrawable(factory);
+              dummyContext  = (GLContextImpl) dummyDrawable.createContext(null);
+              if (dummyContext != null) {
+                dummyContext.makeCurrent();
+                dummyWGLExt = (WGLExt) dummyContext.getPlatformGLExtensions();
+              }
+          } else if (DEBUG) {
+              System.err.println(getThreadName() + ": Not using WGL_ARB_pixel_format, because multisampling not requested");
+          }
+          int recommendedPixelFormat = pixelFormat; // 1-based pixel format
+          boolean haveWGLChoosePixelFormatARB = false;
+          boolean gotAvailableCaps = false;
+          if (dummyWGLExt != null) {
+            try {
+              haveWGLChoosePixelFormatARB = dummyWGLExt.isExtensionAvailable("WGL_ARB_pixel_format");
+              if (haveWGLChoosePixelFormatARB) {
+                if(pixelFormat<=0) {
+                  int[]   iattributes = new int  [2*WindowsWGLGraphicsConfiguration.MAX_ATTRIBS];
+                  float[] fattributes = new float[1];
+
+                  if(WindowsWGLGraphicsConfiguration.GLCapabilities2AttribList(capabilities,
+                                                                               iattributes,
+                                                                               dummyWGLExt,
+                                                                               false,
+                                                                               null)) {
+                    int[] pformats = new int[WindowsWGLGraphicsConfiguration.MAX_PFORMATS];
+                    int[] numFormatsTmp = new int[1];
+                    if (dummyWGLExt.wglChoosePixelFormatARB(hdc,
+                                                         iattributes, 0,
+                                                         fattributes, 0,
+                                                         WindowsWGLGraphicsConfiguration.MAX_PFORMATS,
+                                                         pformats, 0,
+                                                         numFormatsTmp, 0)) {
+                      numFormats = numFormatsTmp[0];
+                      if (recommendedPixelFormat<=0 && numFormats > 0) {
+                        recommendedPixelFormat = pformats[0];
+                        if (DEBUG) {
+                          System.err.println(getThreadName() + ": Used wglChoosePixelFormatARB to recommend pixel format " + recommendedPixelFormat);
+                        }
+                      }
+                    } else {
+                      if (DEBUG) {
+                        System.err.println(getThreadName() + ": wglChoosePixelFormatARB failed: " + WGL.GetLastError() );
+                        Thread.dumpStack();
+                      }
+                    }
+                    if (DEBUG) {
+                      if (recommendedPixelFormat <= 0) {
+                        System.err.print(getThreadName() + ": wglChoosePixelFormatARB didn't recommend a pixel format: "+WGL.GetLastError());
+                        if (capabilities.getSampleBuffers()) {
+                          System.err.print(" for multisampled GLCapabilities");
+                        }
+                        System.err.println();
+                      }
+                    }
+                  }
+                }
+
+                availableCaps = WindowsWGLGraphicsConfiguration.HDC2GLCapabilities(dummyWGLExt, hdc, -1, glProfile, pixelFormatSet, onscreen, usePBuffer);
+                gotAvailableCaps = null!=availableCaps ;
+                choosenBywGLPixelFormat = gotAvailableCaps ;
+              } else if (DEBUG) {
+                System.err.println(getThreadName() + ": wglChoosePixelFormatARB not available");
+              }
+            } finally {
+              dummyContext.release();
+              dummyContext.destroy();
+              dummyDrawable.destroy();
+            }
+          }
+
+          if (!gotAvailableCaps) {
+            if (DEBUG) {
+              System.err.println(getThreadName() + ": Using ChoosePixelFormat ... (LastError: "+WGL.GetLastError()+")");
+            }
+            pfd = WindowsWGLGraphicsConfiguration.GLCapabilities2PFD(capabilities);
+            recommendedPixelFormat = WGL.ChoosePixelFormat(hdc, pfd);
+            if (DEBUG) {
+              System.err.println(getThreadName() + ": ChoosePixelFormat(HDC "+toHexString(hdc)+") = " + recommendedPixelFormat + " (LastError: "+WGL.GetLastError()+")");
+              System.err.println(getThreadName() + ": Used " + capabilities);
+            }
+
+            numFormats = WGL.DescribePixelFormat(hdc, 1, 0, null);
+            if (numFormats == 0) {
+              throw new GLException("Unable to enumerate pixel formats of window " +
+                                    toHexString(hdc) + " for GLCapabilitiesChooser (LastError: "+WGL.GetLastError()+")");
+            }
+            availableCaps = new GLCapabilities[numFormats];
+            for (int i = 0; i < numFormats; i++) {
+              if (WGL.DescribePixelFormat(hdc, 1 + i, pfd.size(), pfd) == 0) {
+                throw new GLException("Error describing pixel format " + (1 + i) + " of device context");
+              }
+              availableCaps[i] = WindowsWGLGraphicsConfiguration.PFD2GLCapabilities(glProfile, pfd, onscreen, usePBuffer);
+            }
+          }
+
+          // NOTE: officially, should make a copy of all of these
+          // GLCapabilities to avoid mutation by the end user during the
+          // chooseCapabilities call, but for the time being, assume they
+          // won't be changed
+
+          if(pixelFormat<=0) {
+              if(null!=chooser) {
+                  // Supply information to chooser
+                  try {
+                    pixelFormat = chooser.chooseCapabilities(capabilities, availableCaps, recommendedPixelFormat) + 1;
+                  } catch (NativeWindowException e) {
+                    if(DEBUG) {
+                          e.printStackTrace();
+                    }
+                    pixelFormat = -1;
+                  }
+              } else {
+                  pixelFormat = recommendedPixelFormat;
+              }
+              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 1 and " +
+                                      numFormats + ")");
+              }
+          }
+          chosenCaps = availableCaps[pixelFormat-1];
+          if (DEBUG) {
+            System.err.println(getThreadName() + ": Chosen pixel format (" + pixelFormat + "):");
+            System.err.println(chosenCaps);
+          }
+          if (WGL.DescribePixelFormat(hdc, pixelFormat, pfd.size(), pfd) == 0) {
+            throw new GLException("Error re-describing the chosen pixel format: " + WGL.GetLastError());
+          }
+        } else {
+          // For now, use ChoosePixelFormat for offscreen surfaces until
+          // we figure out how to properly choose an offscreen-
+          // compatible pixel format
+          pfd = WindowsWGLGraphicsConfiguration.GLCapabilities2PFD(capabilities);
+          pixelFormat = WGL.ChoosePixelFormat(hdc, pfd);
+        }
+        if(!pixelFormatSet) {
+            if (!WGL.SetPixelFormat(hdc, pixelFormat, pfd)) {
+              long lastError = WGL.GetLastError();
+              if (DEBUG) {
+                System.err.println(getThreadName() + ": SetPixelFormat failed: current context = " + WGL.wglGetCurrentContext() +
+                                   ", current DC = " + WGL.wglGetCurrentDC());
+                System.err.println(getThreadName() + ": GetPixelFormat(hdc " + toHexString(hdc) + ") returns " + WGL.GetPixelFormat(hdc));
+              }
+              throw new GLException("Unable to set pixel format " + pixelFormat + " for device context " + toHexString(hdc) + ": error code " + lastError);
+            }
+            pixelFormatSet=true;
+        }
+        // Reuse the previously-constructed GLCapabilities because it
+        // turns out that using DescribePixelFormat on some pixel formats
+        // (which, for example, support full-scene antialiasing) for some
+        // reason return that they are not OpenGL-capable
+        if (chosenCaps != null) {
+          capabilities = chosenCaps;
+        } else {
+          capabilities = WindowsWGLGraphicsConfiguration.PFD2GLCapabilities(glProfile, pfd, onscreen, usePBuffer);
+        }
+        config.setCapsPFD(capabilities, pfd, pixelFormat, choosenBywGLPixelFormat);
+    }
+
+  protected static String getThreadName() {
+    return Thread.currentThread().getName();
+  }
+  public static String toHexString(long hex) {
+      return "0x" + Long.toHexString(hex);
+  }
+}
+
diff --git a/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/awt/WindowsAWTWGLGraphicsConfigurationFactory.java b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/awt/WindowsAWTWGLGraphicsConfigurationFactory.java
new file mode 100644
index 000000000..4458fb1ac
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/impl/windows/wgl/awt/WindowsAWTWGLGraphicsConfigurationFactory.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2008 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution 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.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+package com.jogamp.opengl.impl.windows.wgl.awt;
+
+import java.awt.GraphicsConfiguration;
+import java.awt.GraphicsDevice;
+import java.awt.GraphicsEnvironment;
+import javax.media.nativewindow.*;
+import javax.media.nativewindow.windows.*;
+import javax.media.nativewindow.awt.*;
+import javax.media.opengl.*;
+import javax.media.opengl.awt.*;
+
+import com.jogamp.opengl.impl.*;
+import com.jogamp.opengl.impl.windows.wgl.*;
+import com.sun.nativewindow.impl.jawt.*;
+import com.sun.nativewindow.impl.jawt.windows.*;
+
+public class WindowsAWTWGLGraphicsConfigurationFactory extends GraphicsConfigurationFactory {
+    protected static final boolean DEBUG = com.jogamp.opengl.impl.Debug.debug("GraphicsConfiguration");
+
+    public WindowsAWTWGLGraphicsConfigurationFactory() {
+        GraphicsConfigurationFactory.registerFactory(javax.media.nativewindow.awt.AWTGraphicsDevice.class, this);
+    }
+
+    public AbstractGraphicsConfiguration chooseGraphicsConfiguration(Capabilities capabilities,
+                                                                     CapabilitiesChooser chooser,
+                                                                     AbstractGraphicsScreen absScreen) {
+        GraphicsDevice device = null;
+        if (absScreen != null &&
+            !(absScreen instanceof AWTGraphicsScreen)) {
+            throw new IllegalArgumentException("This GraphicsConfigurationFactory accepts only AWTGraphicsScreen objects");
+        }
+
+        if(null==absScreen) {
+            absScreen = AWTGraphicsScreen.createScreenDevice(-1);
+        }
+        AWTGraphicsScreen awtScreen = (AWTGraphicsScreen) absScreen;
+        device = ((AWTGraphicsDevice)awtScreen.getDevice()).getGraphicsDevice();
+
+        if (capabilities != null &&
+            !(capabilities instanceof GLCapabilities)) {
+            throw new IllegalArgumentException("This GraphicsConfigurationFactory accepts only GLCapabilities objects");
+        }
+
+        if (chooser != null &&
+            !(chooser instanceof GLCapabilitiesChooser)) {
+            throw new IllegalArgumentException("This GraphicsConfigurationFactory accepts only GLCapabilitiesChooser objects");
+        }
+
+        if(DEBUG) {
+            System.err.println("WindowsAWTWGLGraphicsConfigurationFactory: got "+absScreen);
+        }
+        GraphicsConfiguration gc = device.getDefaultConfiguration();
+        AWTGraphicsConfiguration.setupCapabilitiesRGBABits(capabilities, gc);
+        if(DEBUG) {
+            System.err.println("AWT Colormodel compatible: "+capabilities);
+        }
+
+        long displayHandle = 0;
+
+        WindowsGraphicsDevice winDevice = new WindowsGraphicsDevice();
+        DefaultGraphicsScreen winScreen = new DefaultGraphicsScreen(winDevice, awtScreen.getIndex());
+        if(DEBUG) {
+            System.err.println("WindowsAWTWGLGraphicsConfigurationFactory: made "+winScreen);
+        }
+
+        WindowsWGLGraphicsConfiguration winConfig = (WindowsWGLGraphicsConfiguration)
+            GraphicsConfigurationFactory.getFactory(winDevice).chooseGraphicsConfiguration(capabilities,
+                                                                                           chooser,
+                                                                                           winScreen);
+
+        if (winConfig == null) {
+            throw new GLException("Unable to choose a GraphicsConfiguration: "+capabilities+",\n\t"+chooser+"\n\t"+winScreen);
+        }
+
+        if(DEBUG) {
+            System.err.println("WindowsAWTWGLGraphicsConfigurationFactory: chosen "+winConfig);
+        }
+
+        // FIXME: we have nothing to match .. so choose the default
+        return new AWTGraphicsConfiguration(awtScreen, winConfig.getChosenCapabilities(), winConfig.getRequestedCapabilities(), gc, winConfig);
+    }
+}