GLX/GLXExt Robustness: Use NIODirectOnly for all bindings. For these internal APIs, critical array is not required, hence redundant.

8 files changed, 185 insertions, 159 deletions

diff --git a/src/jogl/classes/jogamp/opengl/x11/glx/GLXUtil.java b/src/jogl/classes/jogamp/opengl/x11/glx/GLXUtil.java
index 22e2f14b5..2c591cfbd 100644
--- a/src/jogl/classes/jogamp/opengl/x11/glx/GLXUtil.java
+++ b/src/jogl/classes/jogamp/opengl/x11/glx/GLXUtil.java
@@ -33,10 +33,13 @@
 
 package jogamp.opengl.x11.glx;
 
+import java.nio.IntBuffer;
+
 import javax.media.opengl.GLException;
 
 import jogamp.opengl.Debug;
 
+import com.jogamp.common.nio.Buffers;
 import com.jogamp.common.util.VersionNumber;
 import com.jogamp.nativewindow.x11.X11GraphicsDevice;
 
@@ -53,7 +56,7 @@ public class GLXUtil {
         boolean glXAvailable = false;
         x11Device.lock();
         try {
-            glXAvailable = GLX.glXQueryExtension(x11Device.getHandle(), null, 0, null, 0);
+            glXAvailable = GLX.glXQueryExtension(x11Device.getHandle(), null, null);
         } catch (Throwable t) { /* n/a */
         } finally {
             x11Device.unlock();
@@ -87,32 +90,32 @@ public class GLXUtil {
     }
     
     public static VersionNumber getGLXServerVersionNumber(X11GraphicsDevice x11Device) {
-        int[] major = new int[1];
-        int[] minor = new int[1];
+        final IntBuffer major = Buffers.newDirectIntBuffer(1);
+        final IntBuffer minor = Buffers.newDirectIntBuffer(1);
         
         x11Device.lock();
         try {
-            if (!GLX.glXQueryVersion(x11Device.getHandle(), major, 0, minor, 0)) {
+            if (!GLX.glXQueryVersion(x11Device.getHandle(), major, minor)) {
               throw new GLException("glXQueryVersion failed");
             }
     
             // Work around bugs in ATI's Linux drivers where they report they
             // only implement GLX version 1.2 on the server side
-            if (major[0] == 1 && minor[0] == 2) {
+            if (major.get(0) == 1 && minor.get(0) == 2) {
               String str = GLX.glXGetClientString(x11Device.getHandle(), GLX.GLX_VERSION);
               try {
                   // e.g. "1.3"
-                  major[0] = Integer.valueOf(str.substring(0, 1)).intValue();
-                  minor[0] = Integer.valueOf(str.substring(2, 3)).intValue();
+                  major.put(0, Integer.valueOf(str.substring(0, 1)).intValue());
+                  minor.put(0, Integer.valueOf(str.substring(2, 3)).intValue());
               } catch (Exception e) {
-                  major[0] = 1;
-                  minor[0] = 2;
+                  major.put(0, 1);
+                  minor.put(0, 2);
               }
             }
         } finally {
             x11Device.unlock();
         }
-        return new VersionNumber(major[0], minor[0], 0);
+        return new VersionNumber(major.get(0), minor.get(0), 0);
     }
     
     public static boolean isMultisampleAvailable(String extensions) {
diff --git a/src/jogl/classes/jogamp/opengl/x11/glx/X11ExternalGLXContext.java b/src/jogl/classes/jogamp/opengl/x11/glx/X11ExternalGLXContext.java
index 03a0eefbf..bebb4e68a 100644
--- a/src/jogl/classes/jogamp/opengl/x11/glx/X11ExternalGLXContext.java
+++ b/src/jogl/classes/jogamp/opengl/x11/glx/X11ExternalGLXContext.java
@@ -40,6 +40,8 @@
 
 package jogamp.opengl.x11.glx;
 
+import java.nio.IntBuffer;
+
 import javax.media.nativewindow.NativeSurface;
 import javax.media.nativewindow.VisualIDHolder;
 import javax.media.opengl.GLCapabilities;
@@ -52,6 +54,7 @@ import jogamp.nativewindow.WrappedSurface;
 import jogamp.opengl.GLContextImpl;
 import jogamp.opengl.GLContextShareSet;
 
+import com.jogamp.common.nio.Buffers;
 import com.jogamp.nativewindow.x11.X11GraphicsScreen;
 
 public class X11ExternalGLXContext extends X11GLXContext {
@@ -78,31 +81,31 @@ public class X11ExternalGLXContext extends X11GLXContext {
     if (drawable == 0) {
       throw new GLException("Error: attempted to make an external GLDrawable without a drawable/context current");
     }    
-    int[] val = new int[1];
+    IntBuffer val = Buffers.newDirectIntBuffer(1);
     
     int w, h;
-    GLX.glXQueryDrawable(display, drawable, GLX.GLX_WIDTH, val, 0);
-    w=val[0];
-    GLX.glXQueryDrawable(display, drawable, GLX.GLX_HEIGHT, val, 0);
-    h=val[0];
+    GLX.glXQueryDrawable(display, drawable, GLX.GLX_WIDTH, val);
+    w=val.get(0);
+    GLX.glXQueryDrawable(display, drawable, GLX.GLX_HEIGHT, val);
+    h=val.get(0);
     
-    GLX.glXQueryContext(display, ctx, GLX.GLX_SCREEN, val, 0);
-    X11GraphicsScreen x11Screen = (X11GraphicsScreen) X11GraphicsScreen.createScreenDevice(display, val[0], false);
+    GLX.glXQueryContext(display, ctx, GLX.GLX_SCREEN, val);
+    X11GraphicsScreen x11Screen = (X11GraphicsScreen) X11GraphicsScreen.createScreenDevice(display, val.get(0), false);
 
-    GLX.glXQueryContext(display, ctx, GLX.GLX_FBCONFIG_ID, val, 0);
+    GLX.glXQueryContext(display, ctx, GLX.GLX_FBCONFIG_ID, val);
     X11GLXGraphicsConfiguration cfg = null;
     // sometimes glXQueryContext on an external context gives us a framebuffer config ID
     // of 0, which doesn't work in a subsequent call to glXChooseFBConfig; if this happens,
     // create and use a default config (this has been observed when running on CentOS 5.5 inside
     // of VMWare Server 2.0 with the Mesa 6.5.1 drivers)
-    if( VisualIDHolder.VID_UNDEFINED == val[0] || !X11GLXGraphicsConfiguration.GLXFBConfigIDValid(display, x11Screen.getIndex(), val[0]) ) {
+    if( VisualIDHolder.VID_UNDEFINED == val.get(0) || !X11GLXGraphicsConfiguration.GLXFBConfigIDValid(display, x11Screen.getIndex(), val.get(0)) ) {
         GLCapabilities glcapsDefault = new GLCapabilities(GLProfile.getDefault());
         cfg = X11GLXGraphicsConfigurationFactory.chooseGraphicsConfigurationStatic(glcapsDefault, glcapsDefault, null, x11Screen, VisualIDHolder.VID_UNDEFINED);
         if(DEBUG) {
-            System.err.println("X11ExternalGLXContext invalid FBCONFIG_ID "+val[0]+", using default cfg: " + cfg);
+            System.err.println("X11ExternalGLXContext invalid FBCONFIG_ID "+val.get(0)+", using default cfg: " + cfg);
         }
     } else {
-        cfg = X11GLXGraphicsConfiguration.create(glp, x11Screen, val[0]);
+        cfg = X11GLXGraphicsConfiguration.create(glp, x11Screen, val.get(0));
     }
 
     final WrappedSurface ns = new WrappedSurface(cfg, drawable, w, h, true);
diff --git a/src/jogl/classes/jogamp/opengl/x11/glx/X11ExternalGLXDrawable.java b/src/jogl/classes/jogamp/opengl/x11/glx/X11ExternalGLXDrawable.java
index ac78c6f4a..fca36c0cc 100644
--- a/src/jogl/classes/jogamp/opengl/x11/glx/X11ExternalGLXDrawable.java
+++ b/src/jogl/classes/jogamp/opengl/x11/glx/X11ExternalGLXDrawable.java
@@ -39,6 +39,8 @@
 
 package jogamp.opengl.x11.glx;
 
+import java.nio.IntBuffer;
+
 import javax.media.nativewindow.NativeSurface;
 import javax.media.opengl.GLContext;
 import javax.media.opengl.GLDrawableFactory;
@@ -47,6 +49,7 @@ import javax.media.opengl.GLProfile;
 
 import jogamp.nativewindow.WrappedSurface;
 
+import com.jogamp.common.nio.Buffers;
 import com.jogamp.nativewindow.x11.X11GraphicsScreen;
 
 
@@ -69,23 +72,24 @@ public class X11ExternalGLXDrawable extends X11GLXDrawable {
     if (drawable == 0) {
       throw new GLException("Error: attempted to make an external GLDrawable without a drawable current");
     }
-    int[] val = new int[1];
-    GLX.glXQueryContext(display, context, GLX.GLX_SCREEN, val, 0);
-    X11GraphicsScreen x11Screen = (X11GraphicsScreen) X11GraphicsScreen.createScreenDevice(display, val[0], false);
+    IntBuffer val = Buffers.newDirectIntBuffer(1);
+    
+    GLX.glXQueryContext(display, context, GLX.GLX_SCREEN, val);
+    X11GraphicsScreen x11Screen = (X11GraphicsScreen) X11GraphicsScreen.createScreenDevice(display, val.get(0), false);
 
-    GLX.glXQueryContext(display, context, GLX.GLX_FBCONFIG_ID, val, 0);
-    X11GLXGraphicsConfiguration cfg = X11GLXGraphicsConfiguration.create(glp, x11Screen, val[0]);
+    GLX.glXQueryContext(display, context, GLX.GLX_FBCONFIG_ID, val);
+    X11GLXGraphicsConfiguration cfg = X11GLXGraphicsConfiguration.create(glp, x11Screen, val.get(0));
 
     int w, h;
-    GLX.glXQueryDrawable(display, drawable, GLX.GLX_WIDTH, val, 0);
-    w=val[0];
-    GLX.glXQueryDrawable(display, drawable, GLX.GLX_HEIGHT, val, 0);
-    h=val[0];
+    GLX.glXQueryDrawable(display, drawable, GLX.GLX_WIDTH, val);
+    w=val.get(0);
+    GLX.glXQueryDrawable(display, drawable, GLX.GLX_HEIGHT, val);
+    h=val.get(0);
 
-    GLX.glXQueryContext(display, context, GLX.GLX_RENDER_TYPE, val, 0);
-    if ((val[0] & GLX.GLX_RGBA_TYPE) == 0) {
+    GLX.glXQueryContext(display, context, GLX.GLX_RENDER_TYPE, val);
+    if ((val.get(0) & GLX.GLX_RGBA_TYPE) == 0) {
       if (DEBUG) {
-        System.err.println("X11ExternalGLXDrawable: WARNING: forcing GLX_RGBA_TYPE for newly created contexts (current 0x"+Integer.toHexString(val[0])+")");
+        System.err.println("X11ExternalGLXDrawable: WARNING: forcing GLX_RGBA_TYPE for newly created contexts (current 0x"+Integer.toHexString(val.get(0))+")");
       }
     }
     return new X11ExternalGLXDrawable(factory, new WrappedSurface(cfg, drawable, w, h, true));
diff --git a/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXContext.java b/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXContext.java
index 89907ba15..76e0bc15c 100644
--- a/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXContext.java
+++ b/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXContext.java
@@ -570,9 +570,13 @@ public abstract class X11GLXContext extends GLContextImpl {
       if (initSwapGroupImpl(glXExt)>0) {
         final NativeSurface ns = drawable.getNativeSurface();
         try {
+            final IntBuffer maxGroupsNIO = Buffers.newDirectIntBuffer(maxGroups.length - maxGroups_offset);
+            final IntBuffer maxBarriersNIO = Buffers.newDirectIntBuffer(maxBarriers.length - maxBarriers_offset);
+            
             if( glXExt.glXQueryMaxSwapGroupsNV(ns.getDisplayHandle(), ns.getScreenIndex(),
-                                               maxGroups, maxGroups_offset,
-                                               maxBarriers, maxBarriers_offset) ) {
+                                               maxGroupsNIO, maxBarriersNIO) ) {
+                maxGroupsNIO.get(maxGroups, maxGroups_offset, maxGroupsNIO.remaining());
+                maxBarriersNIO.get(maxGroups, maxGroups_offset, maxBarriersNIO.remaining());
                 res = true;
             }
         } catch (Throwable t) { hasSwapGroupNV=-1; }
diff --git a/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXGraphicsConfiguration.java b/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXGraphicsConfiguration.java
index 96c3c4123..12ce22392 100644
--- a/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXGraphicsConfiguration.java
+++ b/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXGraphicsConfiguration.java
@@ -33,6 +33,8 @@
 
 package jogamp.opengl.x11.glx;
 
+import java.nio.IntBuffer;
+
 import javax.media.nativewindow.CapabilitiesImmutable;
 import javax.media.nativewindow.GraphicsConfigurationFactory;
 import javax.media.nativewindow.VisualIDHolder;
@@ -51,6 +53,7 @@ import jogamp.nativewindow.x11.XRenderPictFormat;
 import jogamp.nativewindow.x11.XVisualInfo;
 import jogamp.opengl.GLGraphicsConfigurationUtil;
 
+import com.jogamp.common.nio.Buffers;
 import com.jogamp.common.nio.PointerBuffer;
 import com.jogamp.nativewindow.x11.X11GraphicsConfiguration;
 import com.jogamp.nativewindow.x11.X11GraphicsDevice;
@@ -122,9 +125,9 @@ public class X11GLXGraphicsConfiguration extends X11GraphicsConfiguration implem
       return new X11GLXGraphicsConfiguration(x11Screen, caps, caps, new DefaultGLCapabilitiesChooser());
     }
 
-    static int[] GLCapabilities2AttribList(GLCapabilitiesImmutable caps,
-                                           boolean forFBAttr, boolean isMultisampleAvailable,
-                                           long display, int screen) 
+    static IntBuffer GLCapabilities2AttribList(GLCapabilitiesImmutable caps,
+                                               boolean forFBAttr, boolean isMultisampleAvailable,
+                                               long display, int screen) 
     {
         int colorDepth = (caps.getRedBits() +
                           caps.getGreenBits() +
@@ -132,11 +135,11 @@ public class X11GLXGraphicsConfiguration extends X11GraphicsConfiguration implem
         if (colorDepth < 15) {
           throw new GLException("Bit depths < 15 (i.e., non-true-color) not supported");
         }
-        int[] res = new int[MAX_ATTRIBS];
+        final IntBuffer res = Buffers.newDirectIntBuffer(MAX_ATTRIBS);
         int idx = 0;
 
         if (forFBAttr) {
-          res[idx++] = GLX.GLX_DRAWABLE_TYPE;
+          res.put(idx++, GLX.GLX_DRAWABLE_TYPE);
           
           final int surfaceType;
           if( caps.isOnscreen() ) {
@@ -150,77 +153,77 @@ public class X11GLXGraphicsConfiguration extends X11GraphicsConfiguration implem
           } else {
               throw new GLException("no surface type set in caps: "+caps);
           }
-          res[idx++] = surfaceType;
+          res.put(idx++, surfaceType);
           
-          res[idx++] = GLX.GLX_RENDER_TYPE;
-          res[idx++] = GLX.GLX_RGBA_BIT;
+          res.put(idx++, GLX.GLX_RENDER_TYPE);
+          res.put(idx++, GLX.GLX_RGBA_BIT);
         } else {
-          res[idx++] = GLX.GLX_RGBA;
+          res.put(idx++, GLX.GLX_RGBA);
         }
 
         // FIXME: Still a bug is Mesa: PBUFFER && GLX_STEREO==GL_FALSE ?
         if (forFBAttr) {
-            res[idx++] = GLX.GLX_DOUBLEBUFFER;
-            res[idx++] = caps.getDoubleBuffered()?GL.GL_TRUE:GL.GL_FALSE;
-            res[idx++] = GLX.GLX_STEREO;
-            res[idx++] = caps.getStereo()?GL.GL_TRUE:GL.GL_FALSE;
-            res[idx++] = GLX.GLX_TRANSPARENT_TYPE;
-            res[idx++] = GLX.GLX_NONE;
+            res.put(idx++, GLX.GLX_DOUBLEBUFFER);
+            res.put(idx++, caps.getDoubleBuffered()?GL.GL_TRUE:GL.GL_FALSE);
+            res.put(idx++, GLX.GLX_STEREO);
+            res.put(idx++, caps.getStereo()?GL.GL_TRUE:GL.GL_FALSE);
+            res.put(idx++, GLX.GLX_TRANSPARENT_TYPE);
+            res.put(idx++, GLX.GLX_NONE);
             /**
-            res[idx++] = caps.isBackgroundOpaque()?GLX.GLX_NONE:GLX.GLX_TRANSPARENT_RGB;
+            res.put(idx++, caps.isBackgroundOpaque()?GLX.GLX_NONE:GLX.GLX_TRANSPARENT_RGB;
             if(!caps.isBackgroundOpaque()) {
-                res[idx++] = GLX.GLX_TRANSPARENT_RED_VALUE;
-                res[idx++] = caps.getTransparentRedValue()>=0?caps.getTransparentRedValue():(int)GLX.GLX_DONT_CARE;
-                res[idx++] = GLX.GLX_TRANSPARENT_GREEN_VALUE;
-                res[idx++] = caps.getTransparentGreenValue()>=0?caps.getTransparentGreenValue():(int)GLX.GLX_DONT_CARE;
-                res[idx++] = GLX.GLX_TRANSPARENT_BLUE_VALUE;
-                res[idx++] = caps.getTransparentBlueValue()>=0?caps.getTransparentBlueValue():(int)GLX.GLX_DONT_CARE;
-                res[idx++] = GLX.GLX_TRANSPARENT_ALPHA_VALUE;
-                res[idx++] = caps.getTransparentAlphaValue()>=0?caps.getTransparentAlphaValue():(int)GLX.GLX_DONT_CARE;
+                res.put(idx++, GLX.GLX_TRANSPARENT_RED_VALUE);
+                res.put(idx++, caps.getTransparentRedValue()>=0?caps.getTransparentRedValue():(int)GLX.GLX_DONT_CARE);
+                res.put(idx++, GLX.GLX_TRANSPARENT_GREEN_VALUE);
+                res.put(idx++, caps.getTransparentGreenValue()>=0?caps.getTransparentGreenValue():(int)GLX.GLX_DONT_CARE);
+                res.put(idx++, GLX.GLX_TRANSPARENT_BLUE_VALUE);
+                res.put(idx++, caps.getTransparentBlueValue()>=0?caps.getTransparentBlueValue():(int)GLX.GLX_DONT_CARE);
+                res.put(idx++, GLX.GLX_TRANSPARENT_ALPHA_VALUE);
+                res.put(idx++, caps.getTransparentAlphaValue()>=0?caps.getTransparentAlphaValue():(int)GLX.GLX_DONT_CARE);
             } */
         } else {
             if (caps.getDoubleBuffered()) {
-              res[idx++] = GLX.GLX_DOUBLEBUFFER;
+              res.put(idx++, GLX.GLX_DOUBLEBUFFER);
             }
             if (caps.getStereo()) {
-              res[idx++] = GLX.GLX_STEREO;
+              res.put(idx++, GLX.GLX_STEREO);
             }
         }
 
-        res[idx++] = GLX.GLX_RED_SIZE;
-        res[idx++] = caps.getRedBits();
-        res[idx++] = GLX.GLX_GREEN_SIZE;
-        res[idx++] = caps.getGreenBits();
-        res[idx++] = GLX.GLX_BLUE_SIZE;
-        res[idx++] = caps.getBlueBits();
+        res.put(idx++, GLX.GLX_RED_SIZE);
+        res.put(idx++, caps.getRedBits());
+        res.put(idx++, GLX.GLX_GREEN_SIZE);
+        res.put(idx++, caps.getGreenBits());
+        res.put(idx++, GLX.GLX_BLUE_SIZE);
+        res.put(idx++, caps.getBlueBits());
         if(caps.getAlphaBits()>0) {
-            res[idx++] = GLX.GLX_ALPHA_SIZE;
-            res[idx++] = caps.getAlphaBits();
+            res.put(idx++, GLX.GLX_ALPHA_SIZE);
+            res.put(idx++, caps.getAlphaBits());
         }
         if (caps.getStencilBits() > 0) {
-          res[idx++] = GLX.GLX_STENCIL_SIZE;
-          res[idx++] = caps.getStencilBits();
+          res.put(idx++, GLX.GLX_STENCIL_SIZE);
+          res.put(idx++, caps.getStencilBits());
         }
-        res[idx++] = GLX.GLX_DEPTH_SIZE;
-        res[idx++] = caps.getDepthBits();
+        res.put(idx++, GLX.GLX_DEPTH_SIZE);
+        res.put(idx++, caps.getDepthBits());
         if (caps.getAccumRedBits()   > 0 ||
             caps.getAccumGreenBits() > 0 ||
             caps.getAccumBlueBits()  > 0 ||
             caps.getAccumAlphaBits() > 0) {
-          res[idx++] = GLX.GLX_ACCUM_RED_SIZE;
-          res[idx++] = caps.getAccumRedBits();
-          res[idx++] = GLX.GLX_ACCUM_GREEN_SIZE;
-          res[idx++] = caps.getAccumGreenBits();
-          res[idx++] = GLX.GLX_ACCUM_BLUE_SIZE;
-          res[idx++] = caps.getAccumBlueBits();
-          res[idx++] = GLX.GLX_ACCUM_ALPHA_SIZE;
-          res[idx++] = caps.getAccumAlphaBits();
+          res.put(idx++, GLX.GLX_ACCUM_RED_SIZE);
+          res.put(idx++, caps.getAccumRedBits());
+          res.put(idx++, GLX.GLX_ACCUM_GREEN_SIZE);
+          res.put(idx++, caps.getAccumGreenBits());
+          res.put(idx++, GLX.GLX_ACCUM_BLUE_SIZE);
+          res.put(idx++, caps.getAccumBlueBits());
+          res.put(idx++, GLX.GLX_ACCUM_ALPHA_SIZE);
+          res.put(idx++, caps.getAccumAlphaBits());
         }
         if (isMultisampleAvailable && caps.getSampleBuffers()) {
-          res[idx++] = GLX.GLX_SAMPLE_BUFFERS;
-          res[idx++] = GL.GL_TRUE;
-          res[idx++] = GLX.GLX_SAMPLES;
-          res[idx++] = caps.getNumSamples();
+          res.put(idx++, GLX.GLX_SAMPLE_BUFFERS);
+          res.put(idx++, GL.GL_TRUE);
+          res.put(idx++, GLX.GLX_SAMPLES);
+          res.put(idx++, caps.getNumSamples());
         }
         if (caps.isPBuffer()) {
           if (caps.getPbufferFloatingPointBuffers()) {
@@ -229,11 +232,11 @@ public class X11GLXGraphicsConfiguration extends X11GraphicsConfiguration implem
                 glXExtensions.indexOf("GLX_NV_float_buffer") < 0) {
               throw new GLException("Floating-point pbuffers on X11 currently require NVidia hardware: "+glXExtensions);
             }
-            res[idx++] = GLXExt.GLX_FLOAT_COMPONENTS_NV;
-            res[idx++] = GL.GL_TRUE;
+            res.put(idx++, GLXExt.GLX_FLOAT_COMPONENTS_NV);
+            res.put(idx++, GL.GL_TRUE);
           }
         }
-        res[idx++] = 0;
+        res.put(idx++, 0);
         return res;
   }
 
@@ -245,8 +248,8 @@ public class X11GLXGraphicsConfiguration extends X11GraphicsConfiguration implem
   }
 
   static boolean GLXFBConfigValid(long display, long fbcfg) {
-    int[] tmp = new int[1];
-    if(GLX.GLX_BAD_ATTRIBUTE == GLX.glXGetFBConfigAttrib(display, fbcfg, GLX.GLX_RENDER_TYPE, tmp, 0)) {
+    final IntBuffer tmp = Buffers.newDirectIntBuffer(1);
+    if(GLX.GLX_BAD_ATTRIBUTE == GLX.glXGetFBConfigAttrib(display, fbcfg, GLX.GLX_RENDER_TYPE, tmp)) {
       return false;
     }
     return true;
@@ -255,8 +258,8 @@ public class X11GLXGraphicsConfiguration extends X11GraphicsConfiguration implem
   static int FBCfgDrawableTypeBits(final X11GraphicsDevice device, final long fbcfg) {
     int val = 0;
 
-    int[] tmp = new int[1];
-    int fbtype = glXGetFBConfig(device.getHandle(), fbcfg, GLX.GLX_DRAWABLE_TYPE, tmp, 0);
+    final IntBuffer tmp = Buffers.newDirectIntBuffer(1);
+    int fbtype = glXGetFBConfig(device.getHandle(), fbcfg, GLX.GLX_DRAWABLE_TYPE, tmp);
 
     if ( 0 != ( fbtype & GLX.GLX_WINDOW_BIT ) ) {
         val |= GLGraphicsConfigurationUtil.WINDOW_BIT |
@@ -299,18 +302,18 @@ public class X11GLXGraphicsConfiguration extends X11GraphicsConfiguration implem
         return null;
     }
 
-    int[] tmp = new int[1];
-    if(GLX.GLX_BAD_ATTRIBUTE == GLX.glXGetFBConfigAttrib(display, fbcfg, GLX.GLX_RENDER_TYPE, tmp, 0)) {
+    final IntBuffer tmp = Buffers.newDirectIntBuffer(1);
+    if(GLX.GLX_BAD_ATTRIBUTE == GLX.glXGetFBConfigAttrib(display, fbcfg, GLX.GLX_RENDER_TYPE, tmp)) {
       return null;
     }
-    if( 0 == ( GLX.GLX_RGBA_BIT & tmp[0] ) ) {
+    if( 0 == ( GLX.GLX_RGBA_BIT & tmp.get(0) ) ) {
       return null; // no RGBA -> color index not supported
     }
 
     final X11GLCapabilities res = new X11GLCapabilities(visualInfo, fbcfg, fbcfgid, glp);
     if (isMultisampleAvailable) {
-      res.setSampleBuffers(glXGetFBConfig(display, fbcfg, GLX.GLX_SAMPLE_BUFFERS, tmp, 0) != 0);
-      res.setNumSamples   (glXGetFBConfig(display, fbcfg, GLX.GLX_SAMPLES,        tmp, 0));
+      res.setSampleBuffers(glXGetFBConfig(display, fbcfg, GLX.GLX_SAMPLE_BUFFERS, tmp) != 0);
+      res.setNumSamples   (glXGetFBConfig(display, fbcfg, GLX.GLX_SAMPLES,        tmp));
     }
     final XRenderDirectFormat xrmask = ( null != visualInfo ) ? 
                                          XVisual2XRenderMask( display, visualInfo.getVisual() ) : 
@@ -324,22 +327,22 @@ public class X11GLXGraphicsConfiguration extends X11GraphicsConfiguration implem
         res.setTransparentAlphaValue(alphaMask);
     }
     // ALPHA shall be set at last - due to it's auto setting by the above (!opaque / samples)    
-    res.setDoubleBuffered(glXGetFBConfig(display, fbcfg, GLX.GLX_DOUBLEBUFFER,     tmp, 0) != 0);
-    res.setStereo        (glXGetFBConfig(display, fbcfg, GLX.GLX_STEREO,           tmp, 0) != 0);
-    res.setHardwareAccelerated(glXGetFBConfig(display, fbcfg, GLX.GLX_CONFIG_CAVEAT, tmp, 0) != GLX.GLX_SLOW_CONFIG);
-    res.setRedBits       (glXGetFBConfig(display, fbcfg, GLX.GLX_RED_SIZE,         tmp, 0));
-    res.setGreenBits     (glXGetFBConfig(display, fbcfg, GLX.GLX_GREEN_SIZE,       tmp, 0));
-    res.setBlueBits      (glXGetFBConfig(display, fbcfg, GLX.GLX_BLUE_SIZE,        tmp, 0));
-    res.setAlphaBits     (glXGetFBConfig(display, fbcfg, GLX.GLX_ALPHA_SIZE,       tmp, 0));
-    res.setAccumRedBits  (glXGetFBConfig(display, fbcfg, GLX.GLX_ACCUM_RED_SIZE,   tmp, 0));
-    res.setAccumGreenBits(glXGetFBConfig(display, fbcfg, GLX.GLX_ACCUM_GREEN_SIZE, tmp, 0));
-    res.setAccumBlueBits (glXGetFBConfig(display, fbcfg, GLX.GLX_ACCUM_BLUE_SIZE,  tmp, 0));
-    res.setAccumAlphaBits(glXGetFBConfig(display, fbcfg, GLX.GLX_ACCUM_ALPHA_SIZE, tmp, 0));
-    res.setDepthBits     (glXGetFBConfig(display, fbcfg, GLX.GLX_DEPTH_SIZE,       tmp, 0));
-    res.setStencilBits   (glXGetFBConfig(display, fbcfg, GLX.GLX_STENCIL_SIZE,     tmp, 0));
+    res.setDoubleBuffered(glXGetFBConfig(display, fbcfg, GLX.GLX_DOUBLEBUFFER,     tmp) != 0);
+    res.setStereo        (glXGetFBConfig(display, fbcfg, GLX.GLX_STEREO,           tmp) != 0);
+    res.setHardwareAccelerated(glXGetFBConfig(display, fbcfg, GLX.GLX_CONFIG_CAVEAT, tmp) != GLX.GLX_SLOW_CONFIG);
+    res.setRedBits       (glXGetFBConfig(display, fbcfg, GLX.GLX_RED_SIZE,         tmp));
+    res.setGreenBits     (glXGetFBConfig(display, fbcfg, GLX.GLX_GREEN_SIZE,       tmp));
+    res.setBlueBits      (glXGetFBConfig(display, fbcfg, GLX.GLX_BLUE_SIZE,        tmp));
+    res.setAlphaBits     (glXGetFBConfig(display, fbcfg, GLX.GLX_ALPHA_SIZE,       tmp));
+    res.setAccumRedBits  (glXGetFBConfig(display, fbcfg, GLX.GLX_ACCUM_RED_SIZE,   tmp));
+    res.setAccumGreenBits(glXGetFBConfig(display, fbcfg, GLX.GLX_ACCUM_GREEN_SIZE, tmp));
+    res.setAccumBlueBits (glXGetFBConfig(display, fbcfg, GLX.GLX_ACCUM_BLUE_SIZE,  tmp));
+    res.setAccumAlphaBits(glXGetFBConfig(display, fbcfg, GLX.GLX_ACCUM_ALPHA_SIZE, tmp));
+    res.setDepthBits     (glXGetFBConfig(display, fbcfg, GLX.GLX_DEPTH_SIZE,       tmp));
+    res.setStencilBits   (glXGetFBConfig(display, fbcfg, GLX.GLX_STENCIL_SIZE,     tmp));
     
     try { 
-        res.setPbufferFloatingPointBuffers(glXGetFBConfig(display, fbcfg, GLXExt.GLX_FLOAT_COMPONENTS_NV, tmp, 0) != GL.GL_FALSE);
+        res.setPbufferFloatingPointBuffers(glXGetFBConfig(display, fbcfg, GLXExt.GLX_FLOAT_COMPONENTS_NV, tmp) != GL.GL_FALSE);
     } catch (Exception e) {}
 
     return (X11GLCapabilities) GLGraphicsConfigurationUtil.fixWinAttribBitsAndHwAccel(device, drawableTypeBits, res); 
@@ -353,26 +356,27 @@ public class X11GLXGraphicsConfiguration extends X11GraphicsConfiguration implem
     }
   }
 
-  static int glXGetFBConfig(long display, long cfg, int attrib, int[] tmp, int tmp_offset) {
+  static int glXGetFBConfig(long display, long cfg, int attrib, IntBuffer tmp) {
     if (display == 0) {
       throw new GLException("No display connection");
     }
-    int res = GLX.glXGetFBConfigAttrib(display, cfg, attrib, tmp, tmp_offset);
+    int res = GLX.glXGetFBConfigAttrib(display, cfg, attrib, tmp);
     if (res != 0) {
       throw new GLException("glXGetFBConfig("+toHexString(attrib)+") failed: error code " + glXGetFBConfigErrorCode(res));
     }
-    return tmp[tmp_offset];
+    return tmp.get(tmp.position());
   }
 
   static int glXFBConfig2FBConfigID(long display, long cfg) {
-      int[] tmpID = new int[1];
-      return glXGetFBConfig(display, cfg, GLX.GLX_FBCONFIG_ID, tmpID, 0);
+      final IntBuffer tmpID = Buffers.newDirectIntBuffer(1);
+      return glXGetFBConfig(display, cfg, GLX.GLX_FBCONFIG_ID, tmpID);
   }
 
   static long glXFBConfigID2FBConfig(long display, int screen, int id) {
-      int[] attribs = new int[] { GLX.GLX_FBCONFIG_ID, id, 0 };
-      int[] count = { -1 };
-      PointerBuffer fbcfgsL = GLX.glXChooseFBConfig(display, screen, attribs, 0, count, 0);
+      final IntBuffer attribs = Buffers.newDirectIntBuffer(new int[] { GLX.GLX_FBCONFIG_ID, id, 0 });
+      final IntBuffer count = Buffers.newDirectIntBuffer(1);
+      count.put(0, -1);      
+      PointerBuffer fbcfgsL = GLX.glXChooseFBConfig(display, screen, attribs, count);
       if (fbcfgsL == null || fbcfgsL.limit()<1) {
           return 0;
       }
@@ -410,15 +414,15 @@ public class X11GLXGraphicsConfiguration extends X11GraphicsConfiguration implem
     }
 
     final long display = device.getHandle();
-    int[] tmp = new int[1];
-    int val = glXGetConfig(display, info, GLX.GLX_USE_GL, tmp, 0);
+    final IntBuffer tmp = Buffers.newDirectIntBuffer(1);
+    int val = glXGetConfig(display, info, GLX.GLX_USE_GL, tmp);
     if (val == 0) {
       if(DEBUG) {
         System.err.println("Visual ("+toHexString(info.getVisualid())+") does not support OpenGL");
       }
       return null;
     }
-    val = glXGetConfig(display, info, GLX.GLX_RGBA, tmp, 0);
+    val = glXGetConfig(display, info, GLX.GLX_RGBA, tmp);
     if (val == 0) {
       if(DEBUG) {
         System.err.println("Visual ("+toHexString(info.getVisualid())+") does not support RGBA");
@@ -428,15 +432,15 @@ public class X11GLXGraphicsConfiguration extends X11GraphicsConfiguration implem
 
     GLCapabilities res = new X11GLCapabilities(info, glp);
 
-    res.setDoubleBuffered(glXGetConfig(display, info, GLX.GLX_DOUBLEBUFFER,     tmp, 0) != 0);
-    res.setStereo        (glXGetConfig(display, info, GLX.GLX_STEREO,           tmp, 0) != 0);
+    res.setDoubleBuffered(glXGetConfig(display, info, GLX.GLX_DOUBLEBUFFER,     tmp) != 0);
+    res.setStereo        (glXGetConfig(display, info, GLX.GLX_STEREO,           tmp) != 0);
     // Note: use of hardware acceleration is determined by
     // glXCreateContext, not by the XVisualInfo. Optimistically claim
     // that all GLCapabilities have the capability to be hardware
     // accelerated.    
     if (isMultisampleEnabled) {
-      res.setSampleBuffers(glXGetConfig(display, info, GLX.GLX_SAMPLE_BUFFERS, tmp, 0) != 0);
-      res.setNumSamples   (glXGetConfig(display, info, GLX.GLX_SAMPLES,        tmp, 0));
+      res.setSampleBuffers(glXGetConfig(display, info, GLX.GLX_SAMPLE_BUFFERS, tmp) != 0);
+      res.setNumSamples   (glXGetConfig(display, info, GLX.GLX_SAMPLES,        tmp));
     }
     final XRenderDirectFormat xrmask = ( null != info ) ? 
                                          XVisual2XRenderMask( display, info.getVisual() ) : 
@@ -451,16 +455,16 @@ public class X11GLXGraphicsConfiguration extends X11GraphicsConfiguration implem
     }
     // ALPHA shall be set at last - due to it's auto setting by the above (!opaque / samples)
     res.setHardwareAccelerated(true);
-    res.setDepthBits     (glXGetConfig(display, info, GLX.GLX_DEPTH_SIZE,       tmp, 0));
-    res.setStencilBits   (glXGetConfig(display, info, GLX.GLX_STENCIL_SIZE,     tmp, 0));
-    res.setRedBits       (glXGetConfig(display, info, GLX.GLX_RED_SIZE,         tmp, 0));
-    res.setGreenBits     (glXGetConfig(display, info, GLX.GLX_GREEN_SIZE,       tmp, 0));
-    res.setBlueBits      (glXGetConfig(display, info, GLX.GLX_BLUE_SIZE,        tmp, 0));
-    res.setAlphaBits     (glXGetConfig(display, info, GLX.GLX_ALPHA_SIZE,       tmp, 0));
-    res.setAccumRedBits  (glXGetConfig(display, info, GLX.GLX_ACCUM_RED_SIZE,   tmp, 0));
-    res.setAccumGreenBits(glXGetConfig(display, info, GLX.GLX_ACCUM_GREEN_SIZE, tmp, 0));
-    res.setAccumBlueBits (glXGetConfig(display, info, GLX.GLX_ACCUM_BLUE_SIZE,  tmp, 0));
-    res.setAccumAlphaBits(glXGetConfig(display, info, GLX.GLX_ACCUM_ALPHA_SIZE, tmp, 0));
+    res.setDepthBits     (glXGetConfig(display, info, GLX.GLX_DEPTH_SIZE,       tmp));
+    res.setStencilBits   (glXGetConfig(display, info, GLX.GLX_STENCIL_SIZE,     tmp));
+    res.setRedBits       (glXGetConfig(display, info, GLX.GLX_RED_SIZE,         tmp));
+    res.setGreenBits     (glXGetConfig(display, info, GLX.GLX_GREEN_SIZE,       tmp));
+    res.setBlueBits      (glXGetConfig(display, info, GLX.GLX_BLUE_SIZE,        tmp));
+    res.setAlphaBits     (glXGetConfig(display, info, GLX.GLX_ALPHA_SIZE,       tmp));
+    res.setAccumRedBits  (glXGetConfig(display, info, GLX.GLX_ACCUM_RED_SIZE,   tmp));
+    res.setAccumGreenBits(glXGetConfig(display, info, GLX.GLX_ACCUM_GREEN_SIZE, tmp));
+    res.setAccumBlueBits (glXGetConfig(display, info, GLX.GLX_ACCUM_BLUE_SIZE,  tmp));
+    res.setAccumAlphaBits(glXGetConfig(display, info, GLX.GLX_ACCUM_ALPHA_SIZE, tmp));
 
     return (X11GLCapabilities) GLGraphicsConfigurationUtil.fixWinAttribBitsAndHwAccel(device, drawableTypeBits, res); 
   }
@@ -475,15 +479,15 @@ public class X11GLXGraphicsConfiguration extends X11GraphicsConfiguration implem
     }
   }
 
-  static int glXGetConfig(long display, XVisualInfo info, int attrib, int[] tmp, int tmp_offset) {
+  static int glXGetConfig(long display, XVisualInfo info, int attrib, IntBuffer tmp) {
     if (display == 0) {
       throw new GLException("No display connection");
     }
-    int res = GLX.glXGetConfig(display, info, attrib, tmp, tmp_offset);
+    int res = GLX.glXGetConfig(display, info, attrib, tmp);
     if (res != 0) {
       throw new GLException("glXGetConfig("+toHexString(attrib)+") failed: error code " + glXGetConfigErrorCode(res));
     }
-    return tmp[tmp_offset];
+    return tmp.get(tmp.position());
   }
 
   public String toString() {
diff --git a/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXGraphicsConfigurationFactory.java b/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXGraphicsConfigurationFactory.java
index 8ac324205..e62dcadcb 100644
--- a/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXGraphicsConfigurationFactory.java
+++ b/src/jogl/classes/jogamp/opengl/x11/glx/X11GLXGraphicsConfigurationFactory.java
@@ -49,6 +49,7 @@ import javax.media.opengl.GLDrawableFactory;
 import javax.media.opengl.GLException;
 import javax.media.opengl.GLProfile;
 
+import com.jogamp.common.nio.Buffers;
 import com.jogamp.common.nio.PointerBuffer;
 import com.jogamp.nativewindow.x11.X11GraphicsDevice;
 import com.jogamp.nativewindow.x11.X11GraphicsScreen;
@@ -58,6 +59,7 @@ import jogamp.nativewindow.x11.XVisualInfo;
 import jogamp.opengl.GLGraphicsConfigurationFactory;
 import jogamp.opengl.GLGraphicsConfigurationUtil;
 
+import java.nio.IntBuffer;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
@@ -159,13 +161,14 @@ public class X11GLXGraphicsConfigurationFactory extends GLGraphicsConfigurationF
         final long display = absDevice.getHandle();
 
         final int screen = x11Screen.getIndex();
-        final int[] count = { -1 };
+        final IntBuffer count = Buffers.newDirectIntBuffer(1);
+        count.put(0, -1);
         final ArrayList<GLCapabilitiesImmutable> availableCaps = new ArrayList<GLCapabilitiesImmutable>();
 
-        fbcfgsL = GLX.glXChooseFBConfig(display, screen, null, 0, count, 0);
+        fbcfgsL = GLX.glXChooseFBConfig(display, screen, null, count);
         if (fbcfgsL == null || fbcfgsL.limit()<=0) {
             if(DEBUG) {
-                System.err.println("X11GLXGraphicsConfiguration.getAvailableGLCapabilitiesFBConfig: Failed glXChooseFBConfig ("+x11Screen+"): "+fbcfgsL+", "+count[0]);
+                System.err.println("X11GLXGraphicsConfiguration.getAvailableGLCapabilitiesFBConfig: Failed glXChooseFBConfig ("+x11Screen+"): "+fbcfgsL+", "+count.get(0));
             }
             return null;
         }
@@ -280,14 +283,15 @@ public class X11GLXGraphicsConfigurationFactory extends GLGraphicsConfigurationF
         
         final X11GLXDrawableFactory factory = (X11GLXDrawableFactory) GLDrawableFactory.getDesktopFactory();                              
         final boolean isMultisampleAvailable = factory.isGLXMultisampleAvailable(x11Device);
-        int[] attribs = X11GLXGraphicsConfiguration.GLCapabilities2AttribList(capsChosen, true, isMultisampleAvailable, display, screen);
-        int[] count = { -1 };
+        final IntBuffer attribs = X11GLXGraphicsConfiguration.GLCapabilities2AttribList(capsChosen, true, isMultisampleAvailable, display, screen);
+        final IntBuffer count = Buffers.newDirectIntBuffer(1);
+        count.put(0, -1);
         List<GLCapabilitiesImmutable> availableCaps = new ArrayList<GLCapabilitiesImmutable>();
         final int winattrmask = GLGraphicsConfigurationUtil.getExclusiveWinAttributeBits(capsChosen);
         // 1st choice: get GLCapabilities based on users GLCapabilities setting recommendedIndex as preferred choice,
         // skipped if xvisualID is given
         if( VisualIDHolder.VID_UNDEFINED == xvisualID ) {
-            fbcfgsL = GLX.glXChooseFBConfig(display, screen, attribs, 0, count, 0);
+            fbcfgsL = GLX.glXChooseFBConfig(display, screen, attribs, count);
         }
         if (fbcfgsL != null && fbcfgsL.limit()>0) {
             for (int i = 0; i < fbcfgsL.limit(); i++) {
@@ -316,10 +320,10 @@ public class X11GLXGraphicsConfigurationFactory extends GLGraphicsConfigurationF
             // reset ..
             recommendedIndex = -1;
 
-            fbcfgsL = GLX.glXChooseFBConfig(display, screen, null, 0, count, 0);
+            fbcfgsL = GLX.glXChooseFBConfig(display, screen, null, count);
             if (fbcfgsL == null || fbcfgsL.limit()<=0) {
                 if(DEBUG) {
-                    System.err.println("X11GLXGraphicsConfiguration.chooseGraphicsConfigurationFBConfig: Failed glXChooseFBConfig ("+x11Screen+","+capsChosen+"): "+fbcfgsL+", "+count[0]);
+                    System.err.println("X11GLXGraphicsConfiguration.chooseGraphicsConfigurationFBConfig: Failed glXChooseFBConfig ("+x11Screen+","+capsChosen+"): "+fbcfgsL+", "+count.get(0));
                 }
                 return null;
             }
@@ -392,13 +396,13 @@ public class X11GLXGraphicsConfigurationFactory extends GLGraphicsConfigurationF
         
         final X11GLXDrawableFactory factory = (X11GLXDrawableFactory) GLDrawableFactory.getDesktopFactory();                              
         final boolean isMultisampleAvailable = factory.isGLXMultisampleAvailable(absDevice);        
-        int[] attribs = X11GLXGraphicsConfiguration.GLCapabilities2AttribList(capsChosen, false, isMultisampleAvailable, display, screen);
+        final IntBuffer attribs = X11GLXGraphicsConfiguration.GLCapabilities2AttribList(capsChosen, false, isMultisampleAvailable, display, screen);
 
         XVisualInfo recommendedVis = null;
         // 1st choice: get GLCapabilities based on users GLCapabilities setting recommendedIndex as preferred choice
         // skipped if xvisualID is given
         if( VisualIDHolder.VID_UNDEFINED == xvisualID ) {  
-            recommendedVis = GLX.glXChooseVisual(display, screen, attribs, 0);
+            recommendedVis = GLX.glXChooseVisual(display, screen, attribs);
             if (DEBUG) {
                 System.err.print("glXChooseVisual recommended ");
                 if (recommendedVis == null) {
diff --git a/src/jogl/classes/jogamp/opengl/x11/glx/X11OnscreenGLXDrawable.java b/src/jogl/classes/jogamp/opengl/x11/glx/X11OnscreenGLXDrawable.java
index 363299321..c15065cfa 100644
--- a/src/jogl/classes/jogamp/opengl/x11/glx/X11OnscreenGLXDrawable.java
+++ b/src/jogl/classes/jogamp/opengl/x11/glx/X11OnscreenGLXDrawable.java
@@ -91,7 +91,7 @@ public class X11OnscreenGLXDrawable extends X11GLXDrawable {
             if(0!=glXWindow) {
                 GLX.glXDestroyWindow(dpy, glXWindow);
             }
-            glXWindow = GLX.glXCreateWindow(dpy, config.getFBConfig(), getNativeSurface().getSurfaceHandle(), null, 0);
+            glXWindow = GLX.glXCreateWindow(dpy, config.getFBConfig(), getNativeSurface().getSurfaceHandle(), null);
             if (DEBUG) {
               System.err.println("X11OnscreenGLXDrawable.setRealized(true): glXWindow: "+toHexString(getNativeSurface().getSurfaceHandle())+" -> "+toHexString(glXWindow));
             }
diff --git a/src/jogl/classes/jogamp/opengl/x11/glx/X11PbufferGLXDrawable.java b/src/jogl/classes/jogamp/opengl/x11/glx/X11PbufferGLXDrawable.java
index bba2b3513..28db2ade9 100644
--- a/src/jogl/classes/jogamp/opengl/x11/glx/X11PbufferGLXDrawable.java
+++ b/src/jogl/classes/jogamp/opengl/x11/glx/X11PbufferGLXDrawable.java
@@ -40,6 +40,8 @@
 
 package jogamp.opengl.x11.glx;
 
+import java.nio.IntBuffer;
+
 import javax.media.nativewindow.AbstractGraphicsDevice;
 import javax.media.nativewindow.AbstractGraphicsScreen;
 import javax.media.nativewindow.NativeSurface;
@@ -50,6 +52,8 @@ import javax.media.opengl.GLDrawableFactory;
 import javax.media.opengl.GLException;
 import javax.media.opengl.GLPbuffer;
 
+import com.jogamp.common.nio.Buffers;
+
 public class X11PbufferGLXDrawable extends X11GLXDrawable {
   protected X11PbufferGLXDrawable(GLDrawableFactory factory, NativeSurface target) {
                                   /* GLCapabilities caps,
@@ -107,17 +111,17 @@ public class X11PbufferGLXDrawable extends X11GLXDrawable {
 
       // Create the p-buffer.
       int niattribs = 0;
-      int[] iattributes = new int[7];
+      IntBuffer iattributes = Buffers.newDirectIntBuffer(7);
 
-      iattributes[niattribs++] = GLX.GLX_PBUFFER_WIDTH;
-      iattributes[niattribs++] = ms.getWidth();
-      iattributes[niattribs++] = GLX.GLX_PBUFFER_HEIGHT;
-      iattributes[niattribs++] = ms.getHeight();
-      iattributes[niattribs++] = GLX.GLX_LARGEST_PBUFFER; // exact
-      iattributes[niattribs++] = 0;
-      iattributes[niattribs++] = 0;
+      iattributes.put(niattribs++, GLX.GLX_PBUFFER_WIDTH);
+      iattributes.put(niattribs++, ms.getWidth());
+      iattributes.put(niattribs++, GLX.GLX_PBUFFER_HEIGHT);
+      iattributes.put(niattribs++, ms.getHeight());
+      iattributes.put(niattribs++, GLX.GLX_LARGEST_PBUFFER); // exact
+      iattributes.put(niattribs++, 0);
+      iattributes.put(niattribs++, 0);
 
-      long pbuffer = GLX.glXCreatePbuffer(display, config.getFBConfig(), iattributes, 0);
+      long pbuffer = GLX.glXCreatePbuffer(display, config.getFBConfig(), iattributes);
       if (pbuffer == 0) {
         // FIXME: query X error code for detail error message
         throw new GLException("pbuffer creation error: glXCreatePbuffer() failed");