Further context-related changes for the JSR-231 API. The GLContext

implementations on all platforms have been split into orthogonal
GLDrawable and GLContext concepts. It is now possible to create more
than one GLContet per GLDrawable (though this has not been tested
yet). GLCanvas has been reimplemented in terms of
GLDrawableFactory.getGLDrawable(). More functionality has been moved
from GLDrawable to GLAutoDrawable. Reimplemented lazy sending of
reshape GLEventListener events in GLCanvas and GLJPanel and deleted
notion of deferred reshapes from GLDrawableHelper and elsewhere.
Sharing of textures and display lists is now expressed in terms of
GLContexts instead of GLDrawables. Still need to move pbuffer creation
into GLDrawableFactory from the onscreen GLContext implementations.
Added option to gleem ExaminerViewer to disable automatic redraws upon
mouse events and respecified more of gleem to work on GLAutoDrawables
rather than GLDrawables. Updated all JOGL demos to work with new APIs
and slightly different initialization sequences (in particular, for
pbuffers -- this will change with the addition of
GLDrawableFactory.createGLPbuffer()).


git-svn-id: file:///usr/local/projects/SUN/JOGL/git-svn/svn-server-sync/jogl/branches/JSR-231@324 232f8b59-042b-4e1e-8c03-345bb8c30851

1 files changed, 36 insertions, 479 deletions

diff --git a/src/net/java/games/jogl/impl/windows/WindowsGLContext.java b/src/net/java/games/jogl/impl/windows/WindowsGLContext.java
index 338b11e6a..44f2894eb 100644
--- a/src/net/java/games/jogl/impl/windows/WindowsGLContext.java
+++ b/src/net/java/games/jogl/impl/windows/WindowsGLContext.java
@@ -39,19 +39,14 @@
 
 package net.java.games.jogl.impl.windows;
 
-import java.awt.Component;
-import java.awt.GraphicsConfiguration;
-import java.awt.GraphicsDevice;
-import java.awt.Rectangle;
 import java.util.*;
 import net.java.games.gluegen.runtime.*; // for PROCADDRESS_VAR_PREFIX
 import net.java.games.jogl.*;
 import net.java.games.jogl.impl.*;
 
 public abstract class WindowsGLContext extends GLContextImpl {
-  private static JAWT jawt;
+  protected WindowsGLDrawable drawable;
   protected long hglrc;
-  protected long hdc;
   private boolean wglGetExtensionsStringEXTInitialized;
   private boolean wglGetExtensionsStringEXTAvailable;
   private static final Map/*<String, String>*/ functionNameMap;
@@ -63,9 +58,6 @@ public abstract class WindowsGLContext extends GLContextImpl {
   private long hglu32;
   private boolean haveWGLARBPbuffer = true;
 
-  private static final int MAX_PFORMATS = 256;
-  private static final int MAX_ATTRIBS  = 256;
-
   static {
     functionNameMap = new HashMap();
     functionNameMap.put("glAllocateMemoryNV", "wglAllocateMemoryNV");
@@ -76,11 +68,10 @@ public abstract class WindowsGLContext extends GLContextImpl {
     extensionNameMap.put("GL_ARB_pixel_format", "WGL_ARB_pixel_format");
   }
 
-  public WindowsGLContext(Component component,
-                          GLCapabilities capabilities,
-                          GLCapabilitiesChooser chooser,
+  public WindowsGLContext(WindowsGLDrawable drawable,
                           GLContext shareWith) {
-    super(component, capabilities, chooser, shareWith);
+    super(shareWith);
+    this.drawable = drawable;
   }
   
   protected GL createGL()
@@ -104,16 +95,6 @@ public abstract class WindowsGLContext extends GLContextImpl {
     return glExtensionName;
   }
 
-  protected abstract boolean isOffscreen();
-  
-  public int getOffscreenContextWidth() {
-    throw new GLException("Should not call this");
-  }
-  
-  public int getOffscreenContextHeight() {
-    throw new GLException("Should not call this");
-  }
-  
   public int getOffscreenContextPixelDataType() {
     throw new GLException("Should not call this");
   }
@@ -126,7 +107,32 @@ public abstract class WindowsGLContext extends GLContextImpl {
    * Creates and initializes an appropriate OpenGL context. Should only be
    * called by {@link #makeCurrentImpl()}.
    */
-  protected abstract void create();
+  protected void create() {
+    if (drawable.getHDC() == 0) {
+      throw new GLException("Internal error: attempted to create OpenGL context without an associated drawable");
+    }
+    hglrc = WGL.wglCreateContext(drawable.getHDC());
+    if (hglrc == 0) {
+      throw new GLException("Unable to create OpenGL context");
+    }
+    // Windows can set up sharing of display lists after creation time
+    WindowsGLContext other = (WindowsGLContext) GLContextShareSet.getShareContext(this);
+    if (other != null) {
+      long hglrc2 = other.getHGLRC();
+      if (hglrc2 == 0) {
+        throw new GLException("GLContextShareSet returned an invalid OpenGL context");
+      }
+      if (!WGL.wglShareLists(hglrc2, hglrc)) {
+        throw new GLException("wglShareLists(0x" + Long.toHexString(hglrc2) +
+                              ", 0x" + Long.toHexString(hglrc) + ") failed: error code " +
+                              WGL.GetLastError());
+      }
+    }
+    GLContextShareSet.contextCreated(this);      
+    if (DEBUG) {
+      System.err.println(getThreadName() + ": !!! Created OpenGL context " + toHexString(hglrc) + " for " + this + ", device context " + toHexString(drawable.getHDC()));
+    }
+  }
   
   protected int makeCurrentImpl() throws GLException {
     boolean created = false;
@@ -149,12 +155,12 @@ public abstract class WindowsGLContext extends GLContextImpl {
     }
 
     if (!skipMakeCurrent) {
-      if (!WGL.wglMakeCurrent(hdc, hglrc)) {
+      if (!WGL.wglMakeCurrent(drawable.getHDC(), hglrc)) {
         throw new GLException("Error making context current: " + WGL.GetLastError());
       } else {
         if (DEBUG && VERBOSE) {
-          System.err.println(getThreadName() + ": wglMakeCurrent(hdc " + hdcToString(hdc) +
-                             ", hglrc " + hdcToString(hglrc) + ") succeeded");
+          System.err.println(getThreadName() + ": wglMakeCurrent(hdc " + toHexString(drawable.getHDC()) +
+                             ", hglrc " + toHexString(hglrc) + ") succeeded");
         }
       }
     }
@@ -163,20 +169,6 @@ public abstract class WindowsGLContext extends GLContextImpl {
       resetGLFunctionAvailability();
       haveWGLARBPbuffer = (isExtensionAvailable("WGL_ARB_pbuffer") &&
                            isExtensionAvailable("WGL_ARB_pixel_format"));
-      // Windows can set up sharing of display lists after creation time
-      WindowsGLContext other = (WindowsGLContext) GLContextShareSet.getShareContext(this);
-      if (other != null) {
-        long hglrc2 = other.getHGLRC();
-        if (hglrc2 == 0) {
-          throw new GLException("GLContextShareSet returned an invalid OpenGL context");
-        }
-        if (!WGL.wglShareLists(hglrc2, hglrc)) {
-          throw new GLException("wglShareLists(0x" + Long.toHexString(hglrc2) +
-                                ", 0x" + Long.toHexString(hglrc) + ") failed: error code " +
-                                WGL.GetLastError());
-        }
-      }
-      GLContextShareSet.contextCreated(this);      
       return CONTEXT_CURRENT_NEW;
     }
     return CONTEXT_CURRENT;
@@ -195,15 +187,14 @@ public abstract class WindowsGLContext extends GLContextImpl {
       if (!WGL.wglDeleteContext(hglrc)) {
         throw new GLException("Unable to delete OpenGL context");
       }
+      hglrc = 0;
+      GLContextShareSet.contextDestroyed(this);
       if (DEBUG) {
-        System.err.println(getThreadName() + ": !!! Destroyed OpenGL context " + hglrc);
+        System.err.println(getThreadName() + ": !!! Destroyed OpenGL context " + toHexString(hglrc));
       }
-      hglrc = 0;
     }
   }
 
-  public abstract void swapBuffers() throws GLException;
-
   protected long dynamicLookupFunction(String glFuncName) {
     long res = WGL.wglGetProcAddress(glFuncName);
     if (res == 0) {
@@ -272,444 +263,10 @@ public abstract class WindowsGLContext extends GLContextImpl {
   // Internals only below this point
   //
 
-  protected JAWT getJAWT() {
-    if (jawt == null) {
-      JAWT j = new JAWT();
-      j.version(JAWTFactory.JAWT_VERSION_1_4);
-      if (!JAWTFactory.JAWT_GetAWT(j)) {
-        throw new RuntimeException("Unable to initialize JAWT");
-      }
-      jawt = j;
-    }
-    return jawt;
-  }
-  
-  // Helper routine for the overridden create() to call
-  protected void choosePixelFormatAndCreateContext(boolean onscreen) {
-    PIXELFORMATDESCRIPTOR pfd = null;
-    int pixelFormat = 0;
-    if (onscreen) {
-      GLCapabilities[] availableCaps = null;
-      int numFormats = 0;
-      pfd = newPixelFormatDescriptor();
-      GraphicsConfiguration config = component.getGraphicsConfiguration();
-      GraphicsDevice device = config.getDevice();
-      // Produce a recommended pixel format selection for the GLCapabilitiesChooser.
-      // Use wglChoosePixelFormatARB if user requested multisampling and if we have it available
-      GL dummyGL = null;
-      if (capabilities.getSampleBuffers()) {
-        dummyGL = WindowsGLContextFactory.getDummyGL(device);
-      }
-      int recommendedPixelFormat = -1;
-      boolean haveWGLChoosePixelFormatARB = false;
-      boolean haveWGLARBMultisample = false;
-      if (dummyGL != null) {
-        String availableWGLExtensions = WindowsGLContextFactory.getDummyGLExtensions(device);
-        if (availableWGLExtensions.indexOf("WGL_ARB_pixel_format") >= 0) {
-          haveWGLChoosePixelFormatARB = true;
-          if (availableWGLExtensions.indexOf("WGL_ARB_multisample") >= 0) {
-            haveWGLARBMultisample = true;
-          }
-        }
-      }
-      Rectangle rect = config.getBounds();
-      long dc = 0;
-      long rc = 0;
-      boolean freeWGLC = false;
-      if( dummyGL != null ) {
-        dc = WindowsGLContextFactory.getDummyGLContext( device ).hdc;
-        rc = WindowsGLContextFactory.getDummyGLContext( device ).hglrc;
-        if( !WGL.wglMakeCurrent( dc, rc ) ) {
-          System.err.println(getThreadName() + ": Error Making WGLC Current: " + WGL.GetLastError() );
-        } else {
-          freeWGLC = true;
-        }
-      }
-      // Fallback path for older cards, in particular Intel Extreme motherboard graphics
-      boolean gotAvailableCaps = false;
-      if (dummyGL != null && haveWGLChoosePixelFormatARB) {
-        int[]   iattributes = new int  [2 * MAX_ATTRIBS];
-        int[]   iresults    = new int  [2 * MAX_ATTRIBS];
-        float[] fattributes = new float[2 * MAX_ATTRIBS];
-        int niattribs = 0;
-        int nfattribs = 0;
-        iattributes[niattribs++] = GL.WGL_SUPPORT_OPENGL_ARB;
-        iattributes[niattribs++] = GL.GL_TRUE;
-        iattributes[niattribs++] = GL.WGL_DRAW_TO_WINDOW_ARB;
-        iattributes[niattribs++] = GL.GL_TRUE;
-        iattributes[niattribs++] = GL.WGL_PIXEL_TYPE_ARB;
-        iattributes[niattribs++] = GL.WGL_TYPE_RGBA_ARB;
-        iattributes[niattribs++] = GL.WGL_DOUBLE_BUFFER_ARB;
-        if (capabilities.getDoubleBuffered()) {
-          iattributes[niattribs++] = GL.GL_TRUE;
-        } else {
-          iattributes[niattribs++] = GL.GL_FALSE;
-        }
-        iattributes[niattribs++] = GL.WGL_STEREO_ARB;
-        if (capabilities.getStereo()) {
-          iattributes[niattribs++] = GL.GL_TRUE;
-        } else {
-          iattributes[niattribs++] = GL.GL_FALSE;
-        }
-        iattributes[niattribs++] = GL.WGL_DEPTH_BITS_ARB;
-        iattributes[niattribs++] = capabilities.getDepthBits();
-        iattributes[niattribs++] = GL.WGL_RED_BITS_ARB;
-        iattributes[niattribs++] = capabilities.getRedBits();
-        iattributes[niattribs++] = GL.WGL_GREEN_BITS_ARB;
-        iattributes[niattribs++] = capabilities.getGreenBits();
-        iattributes[niattribs++] = GL.WGL_BLUE_BITS_ARB;
-        iattributes[niattribs++] = capabilities.getBlueBits();
-        iattributes[niattribs++] = GL.WGL_ALPHA_BITS_ARB;
-        iattributes[niattribs++] = capabilities.getAlphaBits();
-        iattributes[niattribs++] = GL.WGL_STENCIL_BITS_ARB;
-        iattributes[niattribs++] = capabilities.getStencilBits();
-        if (capabilities.getAccumRedBits()   > 0 ||
-            capabilities.getAccumGreenBits() > 0 ||
-            capabilities.getAccumBlueBits()  > 0 ||
-            capabilities.getAccumAlphaBits()  > 0) {
-          iattributes[niattribs++] = GL.WGL_ACCUM_BITS_ARB;
-          iattributes[niattribs++] = (capabilities.getAccumRedBits() +
-                                      capabilities.getAccumGreenBits() +
-                                      capabilities.getAccumBlueBits() +
-                                      capabilities.getAccumAlphaBits());
-          iattributes[niattribs++] = GL.WGL_ACCUM_RED_BITS_ARB;
-          iattributes[niattribs++] = capabilities.getAccumRedBits();
-          iattributes[niattribs++] = GL.WGL_ACCUM_GREEN_BITS_ARB;
-          iattributes[niattribs++] = capabilities.getAccumGreenBits();
-          iattributes[niattribs++] = GL.WGL_ACCUM_BLUE_BITS_ARB;
-          iattributes[niattribs++] = capabilities.getAccumBlueBits();
-          iattributes[niattribs++] = GL.WGL_ACCUM_ALPHA_BITS_ARB;
-          iattributes[niattribs++] = capabilities.getAccumAlphaBits();
-        }
-        if (haveWGLARBMultisample) {
-          if (capabilities.getSampleBuffers()) {
-            iattributes[niattribs++] = GL.WGL_SAMPLE_BUFFERS_ARB;
-            iattributes[niattribs++] = GL.GL_TRUE;
-            iattributes[niattribs++] = GL.WGL_SAMPLES_ARB;
-            iattributes[niattribs++] = capabilities.getNumSamples();
-          }
-        }
-          
-        int[] pformats = new int[MAX_PFORMATS];
-        int[] numFormatsTmp = new int[1];
-        if (dummyGL.wglChoosePixelFormatARB(hdc,
-                                            iattributes, 0,
-                                            fattributes, 0,
-                                            MAX_PFORMATS,
-                                            pformats, 0,
-                                            numFormatsTmp, 0)) {
-          numFormats = numFormatsTmp[0];
-          if (numFormats > 0) {
-            // Remove one-basing of pixel format (added on later)
-            recommendedPixelFormat = pformats[0] - 1;
-            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");
-            if (capabilities.getSampleBuffers()) {
-              System.err.print(" for multisampled GLCapabilities");
-            }
-            System.err.println();
-          }
-        }
-
-        // 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)
-        niattribs = 0;
-        iattributes[0] = GL.WGL_NUMBER_PIXEL_FORMATS_ARB;
-        if (dummyGL.wglGetPixelFormatAttribivARB(hdc, 0, 0, 1, iattributes, 0, iresults, 0)) {
-          numFormats = iresults[0];
-          // 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++] = GL.WGL_DRAW_TO_WINDOW_ARB;
-          iattributes[niattribs++] = GL.WGL_ACCELERATION_ARB;
-          iattributes[niattribs++] = GL.WGL_SUPPORT_OPENGL_ARB;
-          iattributes[niattribs++] = GL.WGL_DEPTH_BITS_ARB;
-          iattributes[niattribs++] = GL.WGL_STENCIL_BITS_ARB;
-          iattributes[niattribs++] = GL.WGL_DOUBLE_BUFFER_ARB;
-          iattributes[niattribs++] = GL.WGL_STEREO_ARB;
-          iattributes[niattribs++] = GL.WGL_PIXEL_TYPE_ARB;
-          iattributes[niattribs++] = GL.WGL_RED_BITS_ARB;
-          iattributes[niattribs++] = GL.WGL_GREEN_BITS_ARB;
-          iattributes[niattribs++] = GL.WGL_BLUE_BITS_ARB;
-          iattributes[niattribs++] = GL.WGL_ALPHA_BITS_ARB;
-          iattributes[niattribs++] = GL.WGL_ACCUM_RED_BITS_ARB;
-          iattributes[niattribs++] = GL.WGL_ACCUM_GREEN_BITS_ARB;
-          iattributes[niattribs++] = GL.WGL_ACCUM_BLUE_BITS_ARB;
-          iattributes[niattribs++] = GL.WGL_ACCUM_ALPHA_BITS_ARB;
-          if (haveWGLARBMultisample) {
-            iattributes[niattribs++] = GL.WGL_SAMPLE_BUFFERS_ARB;
-            iattributes[niattribs++] = GL.WGL_SAMPLES_ARB;
-          }
-
-          availableCaps = new GLCapabilities[numFormats];
-          for (int i = 0; i < numFormats; i++) {
-            if (!dummyGL.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] = iattributes2GLCapabilities(iattributes, iresults, niattribs, true);
-          }
-          if( freeWGLC ) {
-            WGL.wglMakeCurrent( 0, 0 );
-          }
-          gotAvailableCaps = true;
-        } else {
-          int 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());
-          }
-        }
-      }
-
-      if (!gotAvailableCaps) {
-        if (DEBUG) {
-          if (!capabilities.getSampleBuffers()) {
-            System.err.println(getThreadName() + ": Using ChoosePixelFormat because multisampling not requested");
-          } else {
-            System.err.println(getThreadName() + ": Using ChoosePixelFormat because no wglChoosePixelFormatARB: dummyGL = " + dummyGL);
-          }
-        }
-        pfd = glCapabilities2PFD(capabilities, onscreen);
-        // Remove one-basing of pixel format (added on later)
-        recommendedPixelFormat = WGL.ChoosePixelFormat(hdc, pfd) - 1;
-
-        numFormats = WGL.DescribePixelFormat(hdc, 1, 0, null);
-        if (numFormats == 0) {
-          throw new GLException("Unable to enumerate pixel formats of window for GLCapabilitiesChooser");
-        }
-        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] = pfd2GLCapabilities(pfd);
-        }
-      }
-
-      // Supply information to chooser
-      pixelFormat = chooser.chooseCapabilities(capabilities, availableCaps, recommendedPixelFormat);
-      if ((pixelFormat < 0) || (pixelFormat >= numFormats)) {
-        throw new GLException("Invalid result " + pixelFormat +
-                              " from GLCapabilitiesChooser (should be between 0 and " +
-                              (numFormats - 1) + ")");
-      }
-      if (DEBUG) {
-        System.err.println(getThreadName() + ": Chosen pixel format (" + pixelFormat + "):");
-        System.err.println(availableCaps[pixelFormat]);
-      }
-      pixelFormat += 1; // one-base the index
-      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 = glCapabilities2PFD(capabilities, onscreen);
-      pixelFormat = WGL.ChoosePixelFormat(hdc, pfd);
-    }
-    if (!WGL.SetPixelFormat(hdc, pixelFormat, pfd)) {
-      int 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 " + hdcToString(hdc) + ") returns " + WGL.GetPixelFormat(hdc));
-      }
-      throw new GLException("Unable to set pixel format " + pixelFormat + " for device context " + hdcToString(hdc) + ": error code " + lastError);
-    }
-    hglrc = WGL.wglCreateContext(hdc);
-    if (DEBUG) {
-      System.err.println(getThreadName() + ": !!! Created OpenGL context " + hglrc + " for device context " + hdcToString(hdc) + " using pixel format " + pixelFormat);
-    }
-    if (hglrc == 0) {
-      throw new GLException("Unable to create OpenGL context");
-    }
-  }
-
   protected long getHGLRC() {
     return hglrc;
   }
 
-  static PIXELFORMATDESCRIPTOR glCapabilities2PFD(GLCapabilities caps, boolean onscreen) {
-    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 = newPixelFormatDescriptor();
-    int pfdFlags = (WGL.PFD_SUPPORT_OPENGL |
-                    WGL.PFD_GENERIC_ACCELERATED);
-    if (caps.getDoubleBuffered()) {
-      pfdFlags |= WGL.PFD_DOUBLEBUFFER;
-    }
-    if (onscreen) {
-      pfdFlags |= WGL.PFD_DRAW_TO_WINDOW;
-    } else {
-      pfdFlags |= WGL.PFD_DRAW_TO_BITMAP;
-    }
-    pfd.dwFlags(pfdFlags);
-    pfd.iPixelType((byte) WGL.PFD_TYPE_RGBA);
-    pfd.cColorBits((byte) colorDepth);
-    pfd.cRedBits  ((byte) caps.getRedBits());
-    pfd.cGreenBits((byte) caps.getGreenBits());
-    pfd.cBlueBits ((byte) caps.getBlueBits());
-    pfd.cAlphaBits((byte) caps.getAlphaBits());
-    int accumDepth = (caps.getAccumRedBits() +
-                      caps.getAccumGreenBits() +
-                      caps.getAccumBlueBits());
-    pfd.cAccumBits     ((byte) accumDepth);
-    pfd.cAccumRedBits  ((byte) caps.getAccumRedBits());
-    pfd.cAccumGreenBits((byte) caps.getAccumGreenBits());
-    pfd.cAccumBlueBits ((byte) caps.getAccumBlueBits());
-    pfd.cAccumAlphaBits((byte) caps.getAccumAlphaBits());
-    pfd.cDepthBits((byte) caps.getDepthBits());
-    pfd.cStencilBits((byte) caps.getStencilBits());
-    pfd.iLayerType((byte) WGL.PFD_MAIN_PLANE);
-    return pfd;
-  }
-
-  static PIXELFORMATDESCRIPTOR newPixelFormatDescriptor() {
-    PIXELFORMATDESCRIPTOR pfd = new PIXELFORMATDESCRIPTOR();
-    pfd.nSize((short) pfd.size());
-    pfd.nVersion((short) 1);
-    return pfd;
-  }
-
-  static GLCapabilities pfd2GLCapabilities(PIXELFORMATDESCRIPTOR pfd) {
-    if ((pfd.dwFlags() & WGL.PFD_SUPPORT_OPENGL) == 0) {
-      return null;
-    }
-    GLCapabilities res = new GLCapabilities();
-    res.setRedBits       (pfd.cRedBits());
-    res.setGreenBits     (pfd.cGreenBits());
-    res.setBlueBits      (pfd.cBlueBits());
-    res.setAlphaBits     (pfd.cAlphaBits());
-    res.setAccumRedBits  (pfd.cAccumRedBits());
-    res.setAccumGreenBits(pfd.cAccumGreenBits());
-    res.setAccumBlueBits (pfd.cAccumBlueBits());
-    res.setAccumAlphaBits(pfd.cAccumAlphaBits());
-    res.setDepthBits     (pfd.cDepthBits());
-    res.setStencilBits   (pfd.cStencilBits());
-    res.setDoubleBuffered((pfd.dwFlags() & WGL.PFD_DOUBLEBUFFER) != 0);
-    res.setStereo        ((pfd.dwFlags() & WGL.PFD_STEREO) != 0);
-    res.setHardwareAccelerated(((pfd.dwFlags() & WGL.PFD_GENERIC_FORMAT) == 0) ||
-			       ((pfd.dwFlags() & WGL.PFD_GENERIC_ACCELERATED) != 0));
-    return res;
-  }
-
-  static GLCapabilities iattributes2GLCapabilities(int[] iattribs,
-                                                   int[] iresults,
-                                                   int   niattribs,
-                                                   boolean requireRenderToWindow) {
-    GLCapabilities res = new GLCapabilities();
-    for (int i = 0; i < niattribs; i++) {
-      switch (iattribs[i]) {
-        case GL.WGL_DRAW_TO_WINDOW_ARB:
-          if (iresults[i] != GL.GL_TRUE)
-            return null;
-          break;
-
-        case GL.WGL_ACCELERATION_ARB:
-          res.setHardwareAccelerated(iresults[i] == GL.WGL_FULL_ACCELERATION_ARB);
-          break;
-
-        case GL.WGL_SUPPORT_OPENGL_ARB:
-          if (iresults[i] != GL.GL_TRUE)
-            return null;
-          break;
-
-        case GL.WGL_DEPTH_BITS_ARB:
-          res.setDepthBits(iresults[i]);
-          break;
-
-        case GL.WGL_STENCIL_BITS_ARB:
-          res.setStencilBits(iresults[i]);
-          break;
-
-        case GL.WGL_DOUBLE_BUFFER_ARB:
-          res.setDoubleBuffered(iresults[i] == GL.GL_TRUE);
-          break;
-
-        case GL.WGL_STEREO_ARB:
-          res.setStereo(iresults[i] == GL.GL_TRUE);
-          break;
-
-        case GL.WGL_PIXEL_TYPE_ARB:
-          if (iresults[i] != GL.WGL_TYPE_RGBA_ARB)
-            return null;
-          break;
-
-        case GL.WGL_RED_BITS_ARB:
-          res.setRedBits(iresults[i]);
-          break;
-          
-        case GL.WGL_GREEN_BITS_ARB:
-          res.setGreenBits(iresults[i]);
-          break;
-
-        case GL.WGL_BLUE_BITS_ARB:
-          res.setBlueBits(iresults[i]);
-          break;
-
-        case GL.WGL_ALPHA_BITS_ARB:
-          res.setAlphaBits(iresults[i]);
-          break;
-
-        case GL.WGL_ACCUM_RED_BITS_ARB:
-          res.setAccumRedBits(iresults[i]);
-          break;
-
-        case GL.WGL_ACCUM_GREEN_BITS_ARB:
-          res.setAccumGreenBits(iresults[i]);
-          break;
-
-        case GL.WGL_ACCUM_BLUE_BITS_ARB:
-          res.setAccumBlueBits(iresults[i]);
-          break;
-
-        case GL.WGL_ACCUM_ALPHA_BITS_ARB:
-          res.setAccumAlphaBits(iresults[i]);
-          break;
-
-        case GL.WGL_SAMPLE_BUFFERS_ARB:
-          res.setSampleBuffers(iresults[i] == GL.GL_TRUE);
-          break;
-
-        case GL.WGL_SAMPLES_ARB:
-          res.setNumSamples(iresults[i]);
-          break;
-
-        default:
-          throw new GLException("Unknown pixel format attribute " + iattribs[i]);
-      }
-    }
-    return res;
-  }
-
-  protected static String hdcToString(long hdc) {
-    return "0x" + Long.toHexString(hdc);
-  }
-
   protected boolean haveWGLARBPbuffer() {
     return haveWGLARBPbuffer;
   }