16 files changed, 3989 insertions, 3494 deletions
diff --git a/CNativeCode/OpenGLU_JauJNI12_funcs.c b/CNativeCode/OpenGLU_JauJNI12_funcs.c
index 5ad9e76..0b59881 100644
--- a/CNativeCode/OpenGLU_JauJNI12_funcs.c
+++ b/CNativeCode/OpenGLU_JauJNI12_funcs.c
@@ -62,7 +62,7 @@ Java_gl4java_GLUFuncJauJNI_gluGetString ( JNIEnv *env, jobject obj,
 }
 
 static const char * _glu_lib_vendor_="Jausoft - Sven Goethel Software Development";
-static const char * _glu_lib_version_="2.4.1.0";
+static const char * _glu_lib_version_="2.5.2.0";
 
 JNIEXPORT jstring JNICALL
 Java_gl4java_GLUFuncJauJNI_getNativeVendor ( JNIEnv *env, jobject obj )
diff --git a/CNativeCode/OpenGLU_JauJNI12tst_funcs.c b/CNativeCode/OpenGLU_JauJNI12tst_funcs.c
index 1fc3b2c..4c6fa7e 100644
--- a/CNativeCode/OpenGLU_JauJNI12tst_funcs.c
+++ b/CNativeCode/OpenGLU_JauJNI12tst_funcs.c
@@ -62,7 +62,7 @@ Java_gl4java_GLUFuncJauJNI_gluGetString ( JNIEnv *env, jobject obj,
 }
 
 static const char * _glu_lib_vendor_="Jausoft - Sven Goethel Software Development";
-static const char * _glu_lib_version_="2.4.1.0";
+static const char * _glu_lib_version_="2.5.2.0";
 
 JNIEXPORT jstring JNICALL
 Java_gl4java_GLUFuncJauJNI_getNativeVendor ( JNIEnv *env, jobject obj )
diff --git a/CNativeCode/OpenGLU_JauJNI_funcs.c b/CNativeCode/OpenGLU_JauJNI_funcs.c
index 1fda2a3..8b2f135 100644
--- a/CNativeCode/OpenGLU_JauJNI_funcs.c
+++ b/CNativeCode/OpenGLU_JauJNI_funcs.c
@@ -62,7 +62,7 @@ Java_gl4java_GLUFuncJauJNI_gluGetString ( JNIEnv *env, jobject obj,
 }
 
 static const char * _glu_lib_vendor_="Jausoft - Sven Goethel Software Development";
-static const char * _glu_lib_version_="2.4.1.0";
+static const char * _glu_lib_version_="2.5.2.0";
 
 JNIEXPORT jstring JNICALL
 Java_gl4java_GLUFuncJauJNI_getNativeVendor ( JNIEnv *env, jobject obj )
diff --git a/CNativeCode/OpenGLU_JauJNInf_funcs.c b/CNativeCode/OpenGLU_JauJNInf_funcs.c
index 9860fad..ddddcee 100644
--- a/CNativeCode/OpenGLU_JauJNInf_funcs.c
+++ b/CNativeCode/OpenGLU_JauJNInf_funcs.c
@@ -1,9 +1,9 @@
-/* WARNING ! WARNING *** THIS FILE IS GENERATED BY C2J !!!
-
-   DO NOT MAKE ANY CHANGES *** MAKE CHANGES IN THE SKELETON FILES !!!
-*/
-
-
+/* WARNING ! WARNING *** THIS FILE IS GENERATED BY C2J !!!
+
+   DO NOT MAKE ANY CHANGES *** MAKE CHANGES IN THE SKELETON FILES !!!
+*/
+
+
 /*
  * Leo Chan -- 1995
  *
@@ -33,2269 +33,2269 @@
  * herein lies the native JAVA methods for the OpenGL functions.  
  */
 
-static const char _glu_n_a_string[] = "GLU-String not avaiable !";
-
-JNIEXPORT jstring JNICALL
-Java_gl4java_GLUFuncJauJNInf_gluErrorString ( JNIEnv *env, jobject obj,
-	                                    jint errorCode ) 
-{
-    const char *tmpString=0;
-
-    tmpString = gluErrorString ( /* jint */ errorCode );
-    if(tmpString==NULL)
-    	tmpString=_glu_n_a_string;
-
-    return (*env)->NewStringUTF(env, tmpString);
-}
-
-JNIEXPORT jstring JNICALL
-Java_gl4java_GLUFuncJauJNInf_gluGetString ( JNIEnv *env, jobject obj,
-	                                  jint name ) 
-{
-    const char *tmpString=0;
-
-    tmpString = gluGetString ( /* jint */ name);
-    if(tmpString==NULL)
-    	tmpString=_glu_n_a_string;
-
-    return (*env)->NewStringUTF(env, tmpString);   
-}
-
-static const char * _glu_lib_vendor_="Jausoft - Sven Goethel Software Development";
-static const char * _glu_lib_version_="2.4.1.0";
-
-JNIEXPORT jstring JNICALL
-Java_gl4java_GLUFuncJauJNInf_getNativeVendor ( JNIEnv *env, jobject obj )
-{
-    return (*env)->NewStringUTF(env, _glu_lib_vendor_);   
-}
-
-JNIEXPORT jstring JNICALL
-Java_gl4java_GLUFuncJauJNInf_getNativeVersion ( JNIEnv *env, jobject obj )
-{
-    return (*env)->NewStringUTF(env, _glu_lib_version_);   
-}
-
-static void _AddCallbackNode(JNIEnv *env,
-	                          jlong qnt_obj, jint which,
-			          jobject methodClassInstance, 
-			          jstring methodName, 
-				  jstring signature,
-				  jint arrayLen1,
-				  jint arrayLen2,
-				  jint arrayLen3,
-				  jint arrayLen4,
-				  jint arrayLen5)
-{
-	char * strMethodName = jnitoolsGetJavaString(env, methodName);
-	char * strSignature = jnitoolsGetJavaString(env, signature);
-	jlong glx=0;
-
-	glx = GetCurrentGLContext();
-
-	AddCallbackNode(env, methodClassInstance, strMethodName, strSignature,
-			arrayLen1, arrayLen2, arrayLen3,
-			arrayLen4, arrayLen5,
-			(void *)((PointerHolder)qnt_obj), which, glx);
-	free(strMethodName);
-	free(strSignature);
-}
-                  
-
-JNIEXPORT void JNICALL
-Java_gl4java_GLUFuncJauJNInf_gluQuadricCallback( JNIEnv *env, jobject obj,
-	                          jlong qobj, jint which,
-			          jobject methodClassInstance, 
-			          jstring methodName, 
-				  jstring signature)
-{
-	switch(which)
-	{
-		case GLU_ERROR:
-			gluQuadricCallback((void *)((PointerHolder)qobj), 
-			                   which, cbf_GLU_ERROR );
-			break;
-		default:
-		    jnitoolsThrowByName(env, "java/lang/IllegalArgumentException", "Wrong Callback-Function type (\"which\") !");
-		    return;
-	}
-	_AddCallbackNode(env, 
-			 qobj, which, methodClassInstance, methodName, 
-			  signature, 
-			  0, 0, 0, 0, 0);
-}
-
-
-JNIEXPORT void JNICALL
-Java_gl4java_GLUFuncJauJNInf_gluNurbsCallback( JNIEnv *env, jobject obj,
-	                          jlong nobj, jint which,
-			          jobject methodClassInstance, 
-			          jstring methodName, 
-				  jstring signature)
-{
-	switch(which)
-	{
-		case GLU_ERROR:
-			gluNurbsCallback((void *)((PointerHolder)nobj), which, 
-				         cbf_GLU_ERROR );
-			break;
-		default:
-		    jnitoolsThrowByName(env, "java/lang/IllegalArgumentException", "Wrong Callback-Function type (\"which\") !");
-		    return;
-	}
-	_AddCallbackNode(env,
-			 nobj, which, methodClassInstance, methodName, 
-			  signature, 
-			  0, 0, 0, 0, 0);
-}
-
-JNIEXPORT void JNICALL
-Java_gl4java_GLUFuncJauJNInf_gluTessCallback( JNIEnv *env, jobject obj,
-	                          jlong tobj, jint which,
-			          jobject methodClassInstance, 
-			          jstring methodName, 
-				  jstring signature,
-				  jint arrayLen1,
-				  jint arrayLen2,
-				  jint arrayLen3,
-				  jint arrayLen4,
-				  jint arrayLen5)
-{
-	switch(which)
-	{
-		case GLU_TESS_BEGIN:
-			gluTessCallback((GLUtesselator *)((PointerHolder)tobj), 
-			                which, 
-				        cbf_GLU_TESS_BEGIN );
-			break;
-		case GLU_TESS_BEGIN_DATA:
-			gluTessCallback((GLUtesselator *)((PointerHolder)tobj), 
-			                which, 
-				        cbf_GLU_TESS_BEGIN_DATA );
-			break;
-		case GLU_TESS_EDGE_FLAG:
-			gluTessCallback((GLUtesselator *)((PointerHolder)tobj), 
-			                which, 
-				        cbf_GLU_TESS_EDGE_FLAG );
-			break;
-		case GLU_TESS_EDGE_FLAG_DATA:
-			gluTessCallback((GLUtesselator *)((PointerHolder)tobj), 
-			                which, 
-				        cbf_GLU_TESS_EDGE_FLAG_DATA );
-			break;
-		case GLU_TESS_VERTEX:
-			gluTessCallback((GLUtesselator *)((PointerHolder)tobj), 
-			                which, 
-				        cbf_GLU_TESS_VERTEX );
-			break;
-		case GLU_TESS_VERTEX_DATA:
-			gluTessCallback((GLUtesselator *)((PointerHolder)tobj), 
-			                which, 
-				        cbf_GLU_TESS_VERTEX_DATA );
-			break;
-		case GLU_TESS_END:
-			gluTessCallback((GLUtesselator *)((PointerHolder)tobj), 
-			                which, 
-				        cbf_GLU_TESS_END );
-			break;
-		case GLU_TESS_END_DATA:
-			gluTessCallback((GLUtesselator *)((PointerHolder)tobj), 
-			                which, 
-				        cbf_GLU_TESS_END_DATA );
-			break;
-		case GLU_TESS_ERROR:
-			gluTessCallback((GLUtesselator *)((PointerHolder)tobj), 
-			                which, 
-				        cbf_GLU_TESS_ERROR );
-			break;
-		case GLU_TESS_ERROR_DATA:
-			gluTessCallback((GLUtesselator *)((PointerHolder)tobj), 
-			                which, 
-				        cbf_GLU_TESS_ERROR_DATA );
-			break;
-		case GLU_TESS_COMBINE:
-			gluTessCallback((GLUtesselator *)((PointerHolder)tobj), 
-			                which, 
-				        cbf_GLU_TESS_COMBINE );
-			break;
-		case GLU_TESS_COMBINE_DATA:
-			gluTessCallback((GLUtesselator *)((PointerHolder)tobj), 
-			                which, 
-				        cbf_GLU_TESS_COMBINE_DATA );
-			break;
-		default:
-		    jnitoolsThrowByName(env, "java/lang/IllegalArgumentException", "Wrong Callback-Function type (\"which\") !");
-		    return;
-	}
-	_AddCallbackNode(env,
-			  tobj, which, methodClassInstance, methodName, 
-			  signature, 
-			  arrayLen1, arrayLen2, arrayLen3,
-			  arrayLen4, arrayLen5);
-}
-
-JNIEXPORT void JNICALL
-Java_gl4java_GLUFuncJauJNInf_gluDeleteQuadric( JNIEnv *env, jobject obj,
-					     jlong qobj )
-{
-	gluDeleteQuadric((void *)((PointerHolder)qobj));
-	RemoveCallbackNodes((void *)((PointerHolder)qobj));
-}
-
-JNIEXPORT void JNICALL
-Java_gl4java_GLUFuncJauJNInf_gluDeleteNurbsRenderer( JNIEnv *env, jobject obj,
-						   jlong nobj )
-{
-	gluDeleteNurbsRenderer((void *)((PointerHolder)nobj));
-	RemoveCallbackNodes((void *)((PointerHolder)nobj));
-}
-
-JNIEXPORT void JNICALL
-Java_gl4java_GLUFuncJauJNInf_gluDeleteTess( JNIEnv *env, jobject obj,
-					  jlong tobj )
-{
-	gluDeleteTess((GLUtesselator *)((PointerHolder)tobj));
-	RemoveCallbackNodes((void *)((PointerHolder)tobj));
-}
-
-JNIEXPORT jlong JNICALL
-Java_gl4java_GLUFuncJauJNInf_gluNewQuadric( JNIEnv *env, jobject obj)
-{
-	return (jlong)((PointerHolder)gluNewQuadric());
-}
-
-JNIEXPORT jlong JNICALL
-Java_gl4java_GLUFuncJauJNInf_gluNewNurbsRenderer( JNIEnv *env, jobject obj)
-{
-	return (jlong)((PointerHolder)gluNewNurbsRenderer());
-}
-
-JNIEXPORT jlong JNICALL
-Java_gl4java_GLUFuncJauJNInf_gluNewTess( JNIEnv *env, jobject obj)
-{
-	return (jlong)((PointerHolder)gluNewTess());
-}
-
-/**
- * C2J Parser Version 1.5 Beta
- * Jausoft - Sven Goethel Software Development
- * Reading from file: glu-proto-auto.orig.h . . .
- * Destination-Class: gl4java_GLUFuncJauJNInf ! 
- */
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluLookAt ( GLdouble eyex , GLdouble eyey , GLdouble eyez , GLdouble centerx , GLdouble centery , GLdouble centerz , GLdouble upx , GLdouble upy , GLdouble upz ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluLookAt (
-		JNIEnv *env, jobject obj,
-		jdouble eyex,
-		jdouble eyey,
-		jdouble eyez,
-		jdouble centerx,
-		jdouble centery,
-		jdouble centerz,
-		jdouble upx,
-		jdouble upy,
-		jdouble upz)
-	{
-
-		gluLookAt (
-			(GLdouble) eyex,
-			(GLdouble) eyey,
-			(GLdouble) eyez,
-			(GLdouble) centerx,
-			(GLdouble) centery,
-			(GLdouble) centerz,
-			(GLdouble) upx,
-			(GLdouble) upy,
-			(GLdouble) upz
-		);
-
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluOrtho2D ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluOrtho2D (
-		JNIEnv *env, jobject obj,
-		jdouble left,
-		jdouble right,
-		jdouble bottom,
-		jdouble top)
-	{
-
-		gluOrtho2D (
-			(GLdouble) left,
-			(GLdouble) right,
-			(GLdouble) bottom,
-			(GLdouble) top
-		);
-
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluPerspective ( GLdouble fovy , GLdouble aspect , GLdouble zNear , GLdouble zFar ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluPerspective (
-		JNIEnv *env, jobject obj,
-		jdouble fovy,
-		jdouble aspect,
-		jdouble zNear,
-		jdouble zFar)
-	{
-
-		gluPerspective (
-			(GLdouble) fovy,
-			(GLdouble) aspect,
-			(GLdouble) zNear,
-			(GLdouble) zFar
-		);
-
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluPickMatrix ( GLdouble x , GLdouble y , GLdouble width , GLdouble height , GLint * viewport ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluPickMatrix (
-		JNIEnv *env, jobject obj,
-		jdouble x,
-		jdouble y,
-		jdouble width,
-		jdouble height,
-		jintArray viewport)
-	{
-		jboolean isCopiedArray4 = JNI_FALSE;
-		jint *ptr4 = NULL;
-
-		if(viewport!=NULL)
-		{
-			ptr4 = (*env)->GetIntArrayElements(env, viewport, &isCopiedArray4);
-		}
-		gluPickMatrix (
-			(GLdouble) x,
-			(GLdouble) y,
-			(GLdouble) width,
-			(GLdouble) height,
-			(GLint *) ptr4
-		);
-
-		if(viewport!=NULL)
-		{
-			(*env)->ReleaseIntArrayElements(env,  viewport, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
-		}
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern GLint gluProject ( GLdouble objx , GLdouble objy , GLdouble objz , const GLdouble modelMatrix [ 16 ] , const GLdouble projMatrix [ 16 ] , const GLint viewport [ 4 ] , GLdouble * winx , GLdouble * winy , GLdouble * winz ) ;
- * </pre> 
- */
-	JNIEXPORT jint JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluProject (
-		JNIEnv *env, jobject obj,
-		jdouble objx,
-		jdouble objy,
-		jdouble objz,
-		jdoubleArray modelMatrix,
-		jdoubleArray projMatrix,
-		jintArray viewport,
-		jdoubleArray winx,
-		jdoubleArray winy,
-		jdoubleArray winz)
-	{
-		jint ret;
-
-		jdouble *ptr3 = NULL;
-		jdouble *ptr4 = NULL;
-		jint *ptr5 = NULL;
-		jboolean isCopiedArray6 = JNI_FALSE;
-		jdouble *ptr6 = NULL;
-		jboolean isCopiedArray7 = JNI_FALSE;
-		jdouble *ptr7 = NULL;
-		jboolean isCopiedArray8 = JNI_FALSE;
-		jdouble *ptr8 = NULL;
-
-		if(modelMatrix!=NULL)
-		{
-			ptr3 = (*env)->GetDoubleArrayElements(env, modelMatrix, 0);
-		}
-		if(projMatrix!=NULL)
-		{
-			ptr4 = (*env)->GetDoubleArrayElements(env, projMatrix, 0);
-		}
-		if(viewport!=NULL)
-		{
-			ptr5 = (*env)->GetIntArrayElements(env, viewport, 0);
-		}
-		if(winx!=NULL)
-		{
-			ptr6 = (*env)->GetDoubleArrayElements(env, winx, &isCopiedArray6);
-		}
-		if(winy!=NULL)
-		{
-			ptr7 = (*env)->GetDoubleArrayElements(env, winy, &isCopiedArray7);
-		}
-		if(winz!=NULL)
-		{
-			ptr8 = (*env)->GetDoubleArrayElements(env, winz, &isCopiedArray8);
-		}
-		ret = (jint) gluProject (
-			(GLdouble) objx,
-			(GLdouble) objy,
-			(GLdouble) objz,
-			(const GLdouble *) ptr3,
-			(const GLdouble *) ptr4,
-			(const GLint *) ptr5,
-			(GLdouble *) ptr6,
-			(GLdouble *) ptr7,
-			(GLdouble *) ptr8
-		);
-
-		if(modelMatrix!=NULL)
-		{
-			(*env)->ReleaseDoubleArrayElements(env,  modelMatrix, ptr3, JNI_ABORT);
-		}
-		if(projMatrix!=NULL)
-		{
-			(*env)->ReleaseDoubleArrayElements(env,  projMatrix, ptr4, JNI_ABORT);
-		}
-		if(viewport!=NULL)
-		{
-			(*env)->ReleaseIntArrayElements(env,  viewport, ptr5, JNI_ABORT);
-		}
-		if(winx!=NULL)
-		{
-			(*env)->ReleaseDoubleArrayElements(env,  winx, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
-		}
-		if(winy!=NULL)
-		{
-			(*env)->ReleaseDoubleArrayElements(env,  winy, ptr7, (isCopiedArray7 == JNI_TRUE)?0:JNI_ABORT);
-		}
-		if(winz!=NULL)
-		{
-			(*env)->ReleaseDoubleArrayElements(env,  winz, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT);
-		}
-		return ret;
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern GLint gluUnProject ( GLdouble winx , GLdouble winy , GLdouble winz , const GLdouble modelMatrix [ 16 ] , const GLdouble projMatrix [ 16 ] , const GLint viewport [ 4 ] , GLdouble * objx , GLdouble * objy , GLdouble * objz ) ;
- * </pre> 
- */
-	JNIEXPORT jint JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluUnProject (
-		JNIEnv *env, jobject obj,
-		jdouble winx,
-		jdouble winy,
-		jdouble winz,
-		jdoubleArray modelMatrix,
-		jdoubleArray projMatrix,
-		jintArray viewport,
-		jdoubleArray objx,
-		jdoubleArray objy,
-		jdoubleArray objz)
-	{
-		jint ret;
-
-		jdouble *ptr3 = NULL;
-		jdouble *ptr4 = NULL;
-		jint *ptr5 = NULL;
-		jboolean isCopiedArray6 = JNI_FALSE;
-		jdouble *ptr6 = NULL;
-		jboolean isCopiedArray7 = JNI_FALSE;
-		jdouble *ptr7 = NULL;
-		jboolean isCopiedArray8 = JNI_FALSE;
-		jdouble *ptr8 = NULL;
-
-		if(modelMatrix!=NULL)
-		{
-			ptr3 = (*env)->GetDoubleArrayElements(env, modelMatrix, 0);
-		}
-		if(projMatrix!=NULL)
-		{
-			ptr4 = (*env)->GetDoubleArrayElements(env, projMatrix, 0);
-		}
-		if(viewport!=NULL)
-		{
-			ptr5 = (*env)->GetIntArrayElements(env, viewport, 0);
-		}
-		if(objx!=NULL)
-		{
-			ptr6 = (*env)->GetDoubleArrayElements(env, objx, &isCopiedArray6);
-		}
-		if(objy!=NULL)
-		{
-			ptr7 = (*env)->GetDoubleArrayElements(env, objy, &isCopiedArray7);
-		}
-		if(objz!=NULL)
-		{
-			ptr8 = (*env)->GetDoubleArrayElements(env, objz, &isCopiedArray8);
-		}
-		ret = (jint) gluUnProject (
-			(GLdouble) winx,
-			(GLdouble) winy,
-			(GLdouble) winz,
-			(const GLdouble *) ptr3,
-			(const GLdouble *) ptr4,
-			(const GLint *) ptr5,
-			(GLdouble *) ptr6,
-			(GLdouble *) ptr7,
-			(GLdouble *) ptr8
-		);
-
-		if(modelMatrix!=NULL)
-		{
-			(*env)->ReleaseDoubleArrayElements(env,  modelMatrix, ptr3, JNI_ABORT);
-		}
-		if(projMatrix!=NULL)
-		{
-			(*env)->ReleaseDoubleArrayElements(env,  projMatrix, ptr4, JNI_ABORT);
-		}
-		if(viewport!=NULL)
-		{
-			(*env)->ReleaseIntArrayElements(env,  viewport, ptr5, JNI_ABORT);
-		}
-		if(objx!=NULL)
-		{
-			(*env)->ReleaseDoubleArrayElements(env,  objx, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
-		}
-		if(objy!=NULL)
-		{
-			(*env)->ReleaseDoubleArrayElements(env,  objy, ptr7, (isCopiedArray7 == JNI_TRUE)?0:JNI_ABORT);
-		}
-		if(objz!=NULL)
-		{
-			(*env)->ReleaseDoubleArrayElements(env,  objz, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT);
-		}
-		return ret;
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern GLint gluScaleImage ( GLenum format , GLsizei widthin , GLsizei heightin , GLenum typein , const char * datain , GLsizei widthout , GLsizei heightout , GLenum typeout , char * dataout ) ;
- * </pre> 
- */
-	JNIEXPORT jint JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluScaleImage (
-		JNIEnv *env, jobject obj,
-		jint format,
-		jint widthin,
-		jint heightin,
-		jint typein,
-		jbyteArray datain,
-		jint widthout,
-		jint heightout,
-		jint typeout,
-		jbyteArray dataout)
-	{
-		jint ret;
-
-		jbyte *ptr4 = NULL;
-		jboolean isCopiedArray8 = JNI_FALSE;
-		jbyte *ptr8 = NULL;
-
-		if(datain!=NULL)
-		{
-			ptr4 = (*env)->GetByteArrayElements(env, datain, 0);
-		}
-		if(dataout!=NULL)
-		{
-			ptr8 = (*env)->GetByteArrayElements(env, dataout, &isCopiedArray8);
-		}
-		ret = (jint) gluScaleImage (
-			(GLenum) format,
-			(GLsizei) widthin,
-			(GLsizei) heightin,
-			(GLenum) typein,
-			(const char *) ptr4,
-			(GLsizei) widthout,
-			(GLsizei) heightout,
-			(GLenum) typeout,
-			(char *) ptr8
-		);
-
-		if(datain!=NULL)
-		{
-			(*env)->ReleaseByteArrayElements(env,  datain, ptr4, JNI_ABORT);
-		}
-		if(dataout!=NULL)
-		{
-			(*env)->ReleaseByteArrayElements(env,  dataout, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT);
-		}
-		return ret;
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern GLint gluBuild1DMipmaps ( GLenum target , GLint components , GLint width , GLenum format , GLenum type , const void * data ) ;
- * </pre> 
- */
-	JNIEXPORT jint JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluBuild1DMipmaps__IIIII_3B (
-		JNIEnv *env, jobject obj,
-		jint target,
-		jint components,
-		jint width,
-		jint format,
-		jint type,
-		jbyteArray data)
-	{
-		jint ret;
-
-		jbyte *ptr5 = NULL;
-
-		if(data!=NULL)
-		{
-			ptr5 = (*env)->GetByteArrayElements(env, data, 0);
-		}
-		ret = (jint) gluBuild1DMipmaps (
-			(GLenum) target,
-			(GLint) components,
-			(GLint) width,
-			(GLenum) format,
-			(GLenum) type,
-			(const void *) ptr5
-		);
-
-		if(data!=NULL)
-		{
-			(*env)->ReleaseByteArrayElements(env,  data, ptr5, JNI_ABORT);
-		}
-		return ret;
-	}
-	JNIEXPORT jint JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluBuild1DMipmaps__IIIII_3S (
-		JNIEnv *env, jobject obj,
-		jint target,
-		jint components,
-		jint width,
-		jint format,
-		jint type,
-		jshortArray data)
-	{
-		jint ret;
-
-		jshort *ptr5 = NULL;
-
-		if(data!=NULL)
-		{
-			ptr5 = (*env)->GetShortArrayElements(env, data, 0);
-		}
-		ret = (jint) gluBuild1DMipmaps (
-			(GLenum) target,
-			(GLint) components,
-			(GLint) width,
-			(GLenum) format,
-			(GLenum) type,
-			(const void *) ptr5
-		);
-
-		if(data!=NULL)
-		{
-			(*env)->ReleaseShortArrayElements(env,  data, ptr5, JNI_ABORT);
-		}
-		return ret;
-	}
-	JNIEXPORT jint JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluBuild1DMipmaps__IIIII_3I (
-		JNIEnv *env, jobject obj,
-		jint target,
-		jint components,
-		jint width,
-		jint format,
-		jint type,
-		jintArray data)
-	{
-		jint ret;
-
-		jint *ptr5 = NULL;
-
-		if(data!=NULL)
-		{
-			ptr5 = (*env)->GetIntArrayElements(env, data, 0);
-		}
-		ret = (jint) gluBuild1DMipmaps (
-			(GLenum) target,
-			(GLint) components,
-			(GLint) width,
-			(GLenum) format,
-			(GLenum) type,
-			(const void *) ptr5
-		);
-
-		if(data!=NULL)
-		{
-			(*env)->ReleaseIntArrayElements(env,  data, ptr5, JNI_ABORT);
-		}
-		return ret;
-	}
-	JNIEXPORT jint JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluBuild1DMipmaps__IIIII_3F (
-		JNIEnv *env, jobject obj,
-		jint target,
-		jint components,
-		jint width,
-		jint format,
-		jint type,
-		jfloatArray data)
-	{
-		jint ret;
-
-		jfloat *ptr5 = NULL;
-
-		if(data!=NULL)
-		{
-			ptr5 = (*env)->GetFloatArrayElements(env, data, 0);
-		}
-		ret = (jint) gluBuild1DMipmaps (
-			(GLenum) target,
-			(GLint) components,
-			(GLint) width,
-			(GLenum) format,
-			(GLenum) type,
-			(const void *) ptr5
-		);
-
-		if(data!=NULL)
-		{
-			(*env)->ReleaseFloatArrayElements(env,  data, ptr5, JNI_ABORT);
-		}
-		return ret;
-	}
-	JNIEXPORT jint JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluBuild1DMipmaps__IIIII_3D (
-		JNIEnv *env, jobject obj,
-		jint target,
-		jint components,
-		jint width,
-		jint format,
-		jint type,
-		jdoubleArray data)
-	{
-		jint ret;
-
-		jdouble *ptr5 = NULL;
-
-		if(data!=NULL)
-		{
-			ptr5 = (*env)->GetDoubleArrayElements(env, data, 0);
-		}
-		ret = (jint) gluBuild1DMipmaps (
-			(GLenum) target,
-			(GLint) components,
-			(GLint) width,
-			(GLenum) format,
-			(GLenum) type,
-			(const void *) ptr5
-		);
-
-		if(data!=NULL)
-		{
-			(*env)->ReleaseDoubleArrayElements(env,  data, ptr5, JNI_ABORT);
-		}
-		return ret;
-	}
-	JNIEXPORT jint JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluBuild1DMipmaps__IIIII_3Z (
-		JNIEnv *env, jobject obj,
-		jint target,
-		jint components,
-		jint width,
-		jint format,
-		jint type,
-		jbooleanArray data)
-	{
-		jint ret;
-
-		jboolean *ptr5 = NULL;
-
-		if(data!=NULL)
-		{
-			ptr5 = (*env)->GetBooleanArrayElements(env, data, 0);
-		}
-		ret = (jint) gluBuild1DMipmaps (
-			(GLenum) target,
-			(GLint) components,
-			(GLint) width,
-			(GLenum) format,
-			(GLenum) type,
-			(const void *) ptr5
-		);
-
-		if(data!=NULL)
-		{
-			(*env)->ReleaseBooleanArrayElements(env,  data, ptr5, JNI_ABORT);
-		}
-		return ret;
-	}
-	JNIEXPORT jint JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluBuild1DMipmaps__IIIII_3J (
-		JNIEnv *env, jobject obj,
-		jint target,
-		jint components,
-		jint width,
-		jint format,
-		jint type,
-		jlongArray data)
-	{
-		jint ret;
-
-		jlong *ptr5 = NULL;
-
-		if(data!=NULL)
-		{
-			ptr5 = (*env)->GetLongArrayElements(env, data, 0);
-		}
-		ret = (jint) gluBuild1DMipmaps (
-			(GLenum) target,
-			(GLint) components,
-			(GLint) width,
-			(GLenum) format,
-			(GLenum) type,
-			(const void *) ptr5
-		);
-
-		if(data!=NULL)
-		{
-			(*env)->ReleaseLongArrayElements(env,  data, ptr5, JNI_ABORT);
-		}
-		return ret;
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern GLint gluBuild2DMipmaps ( GLenum target , GLint components , GLint width , GLint height , GLenum format , GLenum type , const void * data ) ;
- * </pre> 
- */
-	JNIEXPORT jint JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluBuild2DMipmaps__IIIIII_3B (
-		JNIEnv *env, jobject obj,
-		jint target,
-		jint components,
-		jint width,
-		jint height,
-		jint format,
-		jint type,
-		jbyteArray data)
-	{
-		jint ret;
-
-		jbyte *ptr6 = NULL;
-
-		if(data!=NULL)
-		{
-			ptr6 = (*env)->GetByteArrayElements(env, data, 0);
-		}
-		ret = (jint) gluBuild2DMipmaps (
-			(GLenum) target,
-			(GLint) components,
-			(GLint) width,
-			(GLint) height,
-			(GLenum) format,
-			(GLenum) type,
-			(const void *) ptr6
-		);
-
-		if(data!=NULL)
-		{
-			(*env)->ReleaseByteArrayElements(env,  data, ptr6, JNI_ABORT);
-		}
-		return ret;
-	}
-	JNIEXPORT jint JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluBuild2DMipmaps__IIIIII_3S (
-		JNIEnv *env, jobject obj,
-		jint target,
-		jint components,
-		jint width,
-		jint height,
-		jint format,
-		jint type,
-		jshortArray data)
-	{
-		jint ret;
-
-		jshort *ptr6 = NULL;
-
-		if(data!=NULL)
-		{
-			ptr6 = (*env)->GetShortArrayElements(env, data, 0);
-		}
-		ret = (jint) gluBuild2DMipmaps (
-			(GLenum) target,
-			(GLint) components,
-			(GLint) width,
-			(GLint) height,
-			(GLenum) format,
-			(GLenum) type,
-			(const void *) ptr6
-		);
-
-		if(data!=NULL)
-		{
-			(*env)->ReleaseShortArrayElements(env,  data, ptr6, JNI_ABORT);
-		}
-		return ret;
-	}
-	JNIEXPORT jint JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluBuild2DMipmaps__IIIIII_3I (
-		JNIEnv *env, jobject obj,
-		jint target,
-		jint components,
-		jint width,
-		jint height,
-		jint format,
-		jint type,
-		jintArray data)
-	{
-		jint ret;
-
-		jint *ptr6 = NULL;
-
-		if(data!=NULL)
-		{
-			ptr6 = (*env)->GetIntArrayElements(env, data, 0);
-		}
-		ret = (jint) gluBuild2DMipmaps (
-			(GLenum) target,
-			(GLint) components,
-			(GLint) width,
-			(GLint) height,
-			(GLenum) format,
-			(GLenum) type,
-			(const void *) ptr6
-		);
-
-		if(data!=NULL)
-		{
-			(*env)->ReleaseIntArrayElements(env,  data, ptr6, JNI_ABORT);
-		}
-		return ret;
-	}
-	JNIEXPORT jint JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluBuild2DMipmaps__IIIIII_3F (
-		JNIEnv *env, jobject obj,
-		jint target,
-		jint components,
-		jint width,
-		jint height,
-		jint format,
-		jint type,
-		jfloatArray data)
-	{
-		jint ret;
-
-		jfloat *ptr6 = NULL;
-
-		if(data!=NULL)
-		{
-			ptr6 = (*env)->GetFloatArrayElements(env, data, 0);
-		}
-		ret = (jint) gluBuild2DMipmaps (
-			(GLenum) target,
-			(GLint) components,
-			(GLint) width,
-			(GLint) height,
-			(GLenum) format,
-			(GLenum) type,
-			(const void *) ptr6
-		);
-
-		if(data!=NULL)
-		{
-			(*env)->ReleaseFloatArrayElements(env,  data, ptr6, JNI_ABORT);
-		}
-		return ret;
-	}
-	JNIEXPORT jint JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluBuild2DMipmaps__IIIIII_3D (
-		JNIEnv *env, jobject obj,
-		jint target,
-		jint components,
-		jint width,
-		jint height,
-		jint format,
-		jint type,
-		jdoubleArray data)
-	{
-		jint ret;
-
-		jdouble *ptr6 = NULL;
-
-		if(data!=NULL)
-		{
-			ptr6 = (*env)->GetDoubleArrayElements(env, data, 0);
-		}
-		ret = (jint) gluBuild2DMipmaps (
-			(GLenum) target,
-			(GLint) components,
-			(GLint) width,
-			(GLint) height,
-			(GLenum) format,
-			(GLenum) type,
-			(const void *) ptr6
-		);
-
-		if(data!=NULL)
-		{
-			(*env)->ReleaseDoubleArrayElements(env,  data, ptr6, JNI_ABORT);
-		}
-		return ret;
-	}
-	JNIEXPORT jint JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluBuild2DMipmaps__IIIIII_3Z (
-		JNIEnv *env, jobject obj,
-		jint target,
-		jint components,
-		jint width,
-		jint height,
-		jint format,
-		jint type,
-		jbooleanArray data)
-	{
-		jint ret;
-
-		jboolean *ptr6 = NULL;
-
-		if(data!=NULL)
-		{
-			ptr6 = (*env)->GetBooleanArrayElements(env, data, 0);
-		}
-		ret = (jint) gluBuild2DMipmaps (
-			(GLenum) target,
-			(GLint) components,
-			(GLint) width,
-			(GLint) height,
-			(GLenum) format,
-			(GLenum) type,
-			(const void *) ptr6
-		);
-
-		if(data!=NULL)
-		{
-			(*env)->ReleaseBooleanArrayElements(env,  data, ptr6, JNI_ABORT);
-		}
-		return ret;
-	}
-	JNIEXPORT jint JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluBuild2DMipmaps__IIIIII_3J (
-		JNIEnv *env, jobject obj,
-		jint target,
-		jint components,
-		jint width,
-		jint height,
-		jint format,
-		jint type,
-		jlongArray data)
-	{
-		jint ret;
-
-		jlong *ptr6 = NULL;
-
-		if(data!=NULL)
-		{
-			ptr6 = (*env)->GetLongArrayElements(env, data, 0);
-		}
-		ret = (jint) gluBuild2DMipmaps (
-			(GLenum) target,
-			(GLint) components,
-			(GLint) width,
-			(GLint) height,
-			(GLenum) format,
-			(GLenum) type,
-			(const void *) ptr6
-		);
-
-		if(data!=NULL)
-		{
-			(*env)->ReleaseLongArrayElements(env,  data, ptr6, JNI_ABORT);
-		}
-		return ret;
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluQuadricDrawStyle ( GLUquadricObj * quadObject , GLenum drawStyle ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluQuadricDrawStyle (
-		JNIEnv *env, jobject obj,
-		jlong quadObject,
-		jint drawStyle)
-	{
-
-		gluQuadricDrawStyle (
-			(GLUquadricObj *) (PointerHolder) quadObject,
-			(GLenum) drawStyle
-		);
-
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluQuadricOrientation ( GLUquadricObj * quadObject , GLenum orientation ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluQuadricOrientation (
-		JNIEnv *env, jobject obj,
-		jlong quadObject,
-		jint orientation)
-	{
-
-		gluQuadricOrientation (
-			(GLUquadricObj *) (PointerHolder) quadObject,
-			(GLenum) orientation
-		);
-
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluQuadricNormals ( GLUquadricObj * quadObject , GLenum normals ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluQuadricNormals (
-		JNIEnv *env, jobject obj,
-		jlong quadObject,
-		jint normals)
-	{
-
-		gluQuadricNormals (
-			(GLUquadricObj *) (PointerHolder) quadObject,
-			(GLenum) normals
-		);
-
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluQuadricTexture ( GLUquadricObj * quadObject , GLboolean textureCoords ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluQuadricTexture (
-		JNIEnv *env, jobject obj,
-		jlong quadObject,
-		jboolean textureCoords)
-	{
-
-		gluQuadricTexture (
-			(GLUquadricObj *) (PointerHolder) quadObject,
-			(GLboolean) textureCoords
-		);
-
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluCylinder ( GLUquadricObj * qobj , GLdouble baseRadius , GLdouble topRadius , GLdouble height , GLint slices , GLint stacks ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluCylinder (
-		JNIEnv *env, jobject obj,
-		jlong qobj,
-		jdouble baseRadius,
-		jdouble topRadius,
-		jdouble height,
-		jint slices,
-		jint stacks)
-	{
-
-		gluCylinder (
-			(GLUquadricObj *) (PointerHolder) qobj,
-			(GLdouble) baseRadius,
-			(GLdouble) topRadius,
-			(GLdouble) height,
-			(GLint) slices,
-			(GLint) stacks
-		);
-
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluSphere ( GLUquadricObj * qobj , GLdouble radius , GLint slices , GLint stacks ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluSphere (
-		JNIEnv *env, jobject obj,
-		jlong qobj,
-		jdouble radius,
-		jint slices,
-		jint stacks)
-	{
-
-		gluSphere (
-			(GLUquadricObj *) (PointerHolder) qobj,
-			(GLdouble) radius,
-			(GLint) slices,
-			(GLint) stacks
-		);
-
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluDisk ( GLUquadricObj * qobj , GLdouble innerRadius , GLdouble outerRadius , GLint slices , GLint loops ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluDisk (
-		JNIEnv *env, jobject obj,
-		jlong qobj,
-		jdouble innerRadius,
-		jdouble outerRadius,
-		jint slices,
-		jint loops)
-	{
-
-		gluDisk (
-			(GLUquadricObj *) (PointerHolder) qobj,
-			(GLdouble) innerRadius,
-			(GLdouble) outerRadius,
-			(GLint) slices,
-			(GLint) loops
-		);
-
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluPartialDisk ( GLUquadricObj * qobj , GLdouble innerRadius , GLdouble outerRadius , GLint slices , GLint loops , GLdouble startAngle , GLdouble sweepAngle ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluPartialDisk (
-		JNIEnv *env, jobject obj,
-		jlong qobj,
-		jdouble innerRadius,
-		jdouble outerRadius,
-		jint slices,
-		jint loops,
-		jdouble startAngle,
-		jdouble sweepAngle)
-	{
-
-		gluPartialDisk (
-			(GLUquadricObj *) (PointerHolder) qobj,
-			(GLdouble) innerRadius,
-			(GLdouble) outerRadius,
-			(GLint) slices,
-			(GLint) loops,
-			(GLdouble) startAngle,
-			(GLdouble) sweepAngle
-		);
-
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluLoadSamplingMatrices ( GLUnurbsObj * nobj , const GLfloat modelMatrix [ 16 ] , const GLfloat projMatrix [ 16 ] , const GLint viewport [ 4 ] ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluLoadSamplingMatrices (
-		JNIEnv *env, jobject obj,
-		jlong nobj,
-		jfloatArray modelMatrix,
-		jfloatArray projMatrix,
-		jintArray viewport)
-	{
-		jfloat *ptr1 = NULL;
-		jfloat *ptr2 = NULL;
-		jint *ptr3 = NULL;
-
-		if(modelMatrix!=NULL)
-		{
-			ptr1 = (*env)->GetFloatArrayElements(env, modelMatrix, 0);
-		}
-		if(projMatrix!=NULL)
-		{
-			ptr2 = (*env)->GetFloatArrayElements(env, projMatrix, 0);
-		}
-		if(viewport!=NULL)
-		{
-			ptr3 = (*env)->GetIntArrayElements(env, viewport, 0);
-		}
-		gluLoadSamplingMatrices (
-			(GLUnurbsObj *) (PointerHolder) nobj,
-			(const GLfloat *) ptr1,
-			(const GLfloat *) ptr2,
-			(const GLint *) ptr3
-		);
-
-		if(modelMatrix!=NULL)
-		{
-			(*env)->ReleaseFloatArrayElements(env,  modelMatrix, ptr1, JNI_ABORT);
-		}
-		if(projMatrix!=NULL)
-		{
-			(*env)->ReleaseFloatArrayElements(env,  projMatrix, ptr2, JNI_ABORT);
-		}
-		if(viewport!=NULL)
-		{
-			(*env)->ReleaseIntArrayElements(env,  viewport, ptr3, JNI_ABORT);
-		}
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluNurbsProperty ( GLUnurbsObj * nobj , GLenum property , GLfloat value ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluNurbsProperty (
-		JNIEnv *env, jobject obj,
-		jlong nobj,
-		jint property,
-		jfloat value)
-	{
-
-		gluNurbsProperty (
-			(GLUnurbsObj *) (PointerHolder) nobj,
-			(GLenum) property,
-			(GLfloat) value
-		);
-
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluGetNurbsProperty ( GLUnurbsObj * nobj , GLenum property , GLfloat * value ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluGetNurbsProperty (
-		JNIEnv *env, jobject obj,
-		jlong nobj,
-		jint property,
-		jfloatArray value)
-	{
-		jboolean isCopiedArray2 = JNI_FALSE;
-		jfloat *ptr2 = NULL;
-
-		if(value!=NULL)
-		{
-			ptr2 = (*env)->GetFloatArrayElements(env, value, &isCopiedArray2);
-		}
-		gluGetNurbsProperty (
-			(GLUnurbsObj *) (PointerHolder) nobj,
-			(GLenum) property,
-			(GLfloat *) ptr2
-		);
-
-		if(value!=NULL)
-		{
-			(*env)->ReleaseFloatArrayElements(env,  value, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
-		}
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluBeginCurve ( GLUnurbsObj * nobj ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluBeginCurve (
-		JNIEnv *env, jobject obj,
-		jlong nobj)
-	{
-
-		gluBeginCurve (
-			(GLUnurbsObj *) (PointerHolder) nobj
-		);
-
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluEndCurve ( GLUnurbsObj * nobj ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluEndCurve (
-		JNIEnv *env, jobject obj,
-		jlong nobj)
-	{
-
-		gluEndCurve (
-			(GLUnurbsObj *) (PointerHolder) nobj
-		);
-
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluNurbsCurve ( GLUnurbsObj * nobj , GLint nknots , GLfloat * knot , GLint stride , GLfloat * ctlarray , GLint order , GLenum type ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluNurbsCurve (
-		JNIEnv *env, jobject obj,
-		jlong nobj,
-		jint nknots,
-		jfloatArray knot,
-		jint stride,
-		jfloatArray ctlarray,
-		jint order,
-		jint type)
-	{
-		jboolean isCopiedArray2 = JNI_FALSE;
-		jfloat *ptr2 = NULL;
-		jboolean isCopiedArray4 = JNI_FALSE;
-		jfloat *ptr4 = NULL;
-
-		if(knot!=NULL)
-		{
-			ptr2 = (*env)->GetFloatArrayElements(env, knot, &isCopiedArray2);
-		}
-		if(ctlarray!=NULL)
-		{
-			ptr4 = (*env)->GetFloatArrayElements(env, ctlarray, &isCopiedArray4);
-		}
-		gluNurbsCurve (
-			(GLUnurbsObj *) (PointerHolder) nobj,
-			(GLint) nknots,
-			(GLfloat *) ptr2,
-			(GLint) stride,
-			(GLfloat *) ptr4,
-			(GLint) order,
-			(GLenum) type
-		);
-
-		if(knot!=NULL)
-		{
-			(*env)->ReleaseFloatArrayElements(env,  knot, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
-		}
-		if(ctlarray!=NULL)
-		{
-			(*env)->ReleaseFloatArrayElements(env,  ctlarray, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
-		}
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluBeginSurface ( GLUnurbsObj * nobj ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluBeginSurface (
-		JNIEnv *env, jobject obj,
-		jlong nobj)
-	{
-
-		gluBeginSurface (
-			(GLUnurbsObj *) (PointerHolder) nobj
-		);
-
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluEndSurface ( GLUnurbsObj * nobj ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluEndSurface (
-		JNIEnv *env, jobject obj,
-		jlong nobj)
-	{
-
-		gluEndSurface (
-			(GLUnurbsObj *) (PointerHolder) nobj
-		);
-
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluNurbsSurface ( GLUnurbsObj * nobj , GLint sknot_count , GLfloat * sknot , GLint tknot_count , GLfloat * tknot , GLint s_stride , GLint t_stride , GLfloat * ctlarray , GLint sorder , GLint torder , GLenum type ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluNurbsSurface (
-		JNIEnv *env, jobject obj,
-		jlong nobj,
-		jint sknot_count,
-		jfloatArray sknot,
-		jint tknot_count,
-		jfloatArray tknot,
-		jint s_stride,
-		jint t_stride,
-		jfloatArray ctlarray,
-		jint sorder,
-		jint torder,
-		jint type)
-	{
-		jboolean isCopiedArray2 = JNI_FALSE;
-		jfloat *ptr2 = NULL;
-		jboolean isCopiedArray4 = JNI_FALSE;
-		jfloat *ptr4 = NULL;
-		jboolean isCopiedArray7 = JNI_FALSE;
-		jfloat *ptr7 = NULL;
-
-		if(sknot!=NULL)
-		{
-			ptr2 = (*env)->GetFloatArrayElements(env, sknot, &isCopiedArray2);
-		}
-		if(tknot!=NULL)
-		{
-			ptr4 = (*env)->GetFloatArrayElements(env, tknot, &isCopiedArray4);
-		}
-		if(ctlarray!=NULL)
-		{
-			ptr7 = (*env)->GetFloatArrayElements(env, ctlarray, &isCopiedArray7);
-		}
-		gluNurbsSurface (
-			(GLUnurbsObj *) (PointerHolder) nobj,
-			(GLint) sknot_count,
-			(GLfloat *) ptr2,
-			(GLint) tknot_count,
-			(GLfloat *) ptr4,
-			(GLint) s_stride,
-			(GLint) t_stride,
-			(GLfloat *) ptr7,
-			(GLint) sorder,
-			(GLint) torder,
-			(GLenum) type
-		);
-
-		if(sknot!=NULL)
-		{
-			(*env)->ReleaseFloatArrayElements(env,  sknot, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
-		}
-		if(tknot!=NULL)
-		{
-			(*env)->ReleaseFloatArrayElements(env,  tknot, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
-		}
-		if(ctlarray!=NULL)
-		{
-			(*env)->ReleaseFloatArrayElements(env,  ctlarray, ptr7, (isCopiedArray7 == JNI_TRUE)?0:JNI_ABORT);
-		}
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluBeginTrim ( GLUnurbsObj * nobj ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluBeginTrim (
-		JNIEnv *env, jobject obj,
-		jlong nobj)
-	{
-
-		gluBeginTrim (
-			(GLUnurbsObj *) (PointerHolder) nobj
-		);
-
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluEndTrim ( GLUnurbsObj * nobj ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluEndTrim (
-		JNIEnv *env, jobject obj,
-		jlong nobj)
-	{
-
-		gluEndTrim (
-			(GLUnurbsObj *) (PointerHolder) nobj
-		);
-
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluPwlCurve ( GLUnurbsObj * nobj , GLint count , GLfloat * array , GLint stride , GLenum type ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluPwlCurve (
-		JNIEnv *env, jobject obj,
-		jlong nobj,
-		jint count,
-		jfloatArray array,
-		jint stride,
-		jint type)
-	{
-		jboolean isCopiedArray2 = JNI_FALSE;
-		jfloat *ptr2 = NULL;
-
-		if(array!=NULL)
-		{
-			ptr2 = (*env)->GetFloatArrayElements(env, array, &isCopiedArray2);
-		}
-		gluPwlCurve (
-			(GLUnurbsObj *) (PointerHolder) nobj,
-			(GLint) count,
-			(GLfloat *) ptr2,
-			(GLint) stride,
-			(GLenum) type
-		);
-
-		if(array!=NULL)
-		{
-			(*env)->ReleaseFloatArrayElements(env,  array, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
-		}
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluTessBeginPolygon ( GLUtesselator * tobj , void * polygon_data ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluTessBeginPolygon__J_3B (
-		JNIEnv *env, jobject obj,
-		jlong tobj,
-		jbyteArray polygon_data)
-	{
-		jboolean isCopiedArray1 = JNI_FALSE;
-		jbyte *ptr1 = NULL;
-
-		if(polygon_data!=NULL)
-		{
-			ptr1 = (*env)->GetByteArrayElements(env, polygon_data, &isCopiedArray1);
-		}
-		gluTessBeginPolygon (
-			(GLUtesselator *) (PointerHolder) tobj,
-			(void *) ptr1
-		);
-
-		if(polygon_data!=NULL)
-		{
-			(*env)->ReleaseByteArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
-		}
-	}
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluTessBeginPolygon__J_3S (
-		JNIEnv *env, jobject obj,
-		jlong tobj,
-		jshortArray polygon_data)
-	{
-		jboolean isCopiedArray1 = JNI_FALSE;
-		jshort *ptr1 = NULL;
-
-		if(polygon_data!=NULL)
-		{
-			ptr1 = (*env)->GetShortArrayElements(env, polygon_data, &isCopiedArray1);
-		}
-		gluTessBeginPolygon (
-			(GLUtesselator *) (PointerHolder) tobj,
-			(void *) ptr1
-		);
-
-		if(polygon_data!=NULL)
-		{
-			(*env)->ReleaseShortArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
-		}
-	}
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluTessBeginPolygon__J_3I (
-		JNIEnv *env, jobject obj,
-		jlong tobj,
-		jintArray polygon_data)
-	{
-		jboolean isCopiedArray1 = JNI_FALSE;
-		jint *ptr1 = NULL;
-
-		if(polygon_data!=NULL)
-		{
-			ptr1 = (*env)->GetIntArrayElements(env, polygon_data, &isCopiedArray1);
-		}
-		gluTessBeginPolygon (
-			(GLUtesselator *) (PointerHolder) tobj,
-			(void *) ptr1
-		);
-
-		if(polygon_data!=NULL)
-		{
-			(*env)->ReleaseIntArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
-		}
-	}
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluTessBeginPolygon__J_3F (
-		JNIEnv *env, jobject obj,
-		jlong tobj,
-		jfloatArray polygon_data)
-	{
-		jboolean isCopiedArray1 = JNI_FALSE;
-		jfloat *ptr1 = NULL;
-
-		if(polygon_data!=NULL)
-		{
-			ptr1 = (*env)->GetFloatArrayElements(env, polygon_data, &isCopiedArray1);
-		}
-		gluTessBeginPolygon (
-			(GLUtesselator *) (PointerHolder) tobj,
-			(void *) ptr1
-		);
-
-		if(polygon_data!=NULL)
-		{
-			(*env)->ReleaseFloatArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
-		}
-	}
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluTessBeginPolygon__J_3D (
-		JNIEnv *env, jobject obj,
-		jlong tobj,
-		jdoubleArray polygon_data)
-	{
-		jboolean isCopiedArray1 = JNI_FALSE;
-		jdouble *ptr1 = NULL;
-
-		if(polygon_data!=NULL)
-		{
-			ptr1 = (*env)->GetDoubleArrayElements(env, polygon_data, &isCopiedArray1);
-		}
-		gluTessBeginPolygon (
-			(GLUtesselator *) (PointerHolder) tobj,
-			(void *) ptr1
-		);
-
-		if(polygon_data!=NULL)
-		{
-			(*env)->ReleaseDoubleArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
-		}
-	}
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluTessBeginPolygon__J_3Z (
-		JNIEnv *env, jobject obj,
-		jlong tobj,
-		jbooleanArray polygon_data)
-	{
-		jboolean isCopiedArray1 = JNI_FALSE;
-		jboolean *ptr1 = NULL;
-
-		if(polygon_data!=NULL)
-		{
-			ptr1 = (*env)->GetBooleanArrayElements(env, polygon_data, &isCopiedArray1);
-		}
-		gluTessBeginPolygon (
-			(GLUtesselator *) (PointerHolder) tobj,
-			(void *) ptr1
-		);
-
-		if(polygon_data!=NULL)
-		{
-			(*env)->ReleaseBooleanArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
-		}
-	}
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluTessBeginPolygon__J_3J (
-		JNIEnv *env, jobject obj,
-		jlong tobj,
-		jlongArray polygon_data)
-	{
-		jboolean isCopiedArray1 = JNI_FALSE;
-		jlong *ptr1 = NULL;
-
-		if(polygon_data!=NULL)
-		{
-			ptr1 = (*env)->GetLongArrayElements(env, polygon_data, &isCopiedArray1);
-		}
-		gluTessBeginPolygon (
-			(GLUtesselator *) (PointerHolder) tobj,
-			(void *) ptr1
-		);
-
-		if(polygon_data!=NULL)
-		{
-			(*env)->ReleaseLongArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
-		}
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluTessBeginContour ( GLUtesselator * tobj ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluTessBeginContour (
-		JNIEnv *env, jobject obj,
-		jlong tobj)
-	{
-
-		gluTessBeginContour (
-			(GLUtesselator *) (PointerHolder) tobj
-		);
-
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluTessVertex ( GLUtesselator * tobj , GLdouble coords [ 3 ] , void * vertex_data ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluTessVertex__J_3D_3B (
-		JNIEnv *env, jobject obj,
-		jlong tobj,
-		jdoubleArray coords,
-		jbyteArray vertex_data)
-	{
-		jboolean isCopiedArray1 = JNI_FALSE;
-		jdouble *ptr1 = NULL;
-		jboolean isCopiedArray2 = JNI_FALSE;
-		jbyte *ptr2 = NULL;
-
-		if(coords!=NULL)
-		{
-			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
-		}
-		if(vertex_data!=NULL)
-		{
-			ptr2 = (*env)->GetByteArrayElements(env, vertex_data, &isCopiedArray2);
-		}
-		gluTessVertex (
-			(GLUtesselator *) (PointerHolder) tobj,
-			(GLdouble *) ptr1,
-			(void *) ptr2
-		);
-
-		if(coords!=NULL)
-		{
-			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
-		}
-		if(vertex_data!=NULL)
-		{
-			(*env)->ReleaseByteArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
-		}
-	}
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluTessVertex__J_3D_3S (
-		JNIEnv *env, jobject obj,
-		jlong tobj,
-		jdoubleArray coords,
-		jshortArray vertex_data)
-	{
-		jboolean isCopiedArray1 = JNI_FALSE;
-		jdouble *ptr1 = NULL;
-		jboolean isCopiedArray2 = JNI_FALSE;
-		jshort *ptr2 = NULL;
-
-		if(coords!=NULL)
-		{
-			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
-		}
-		if(vertex_data!=NULL)
-		{
-			ptr2 = (*env)->GetShortArrayElements(env, vertex_data, &isCopiedArray2);
-		}
-		gluTessVertex (
-			(GLUtesselator *) (PointerHolder) tobj,
-			(GLdouble *) ptr1,
-			(void *) ptr2
-		);
-
-		if(coords!=NULL)
-		{
-			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
-		}
-		if(vertex_data!=NULL)
-		{
-			(*env)->ReleaseShortArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
-		}
-	}
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluTessVertex__J_3D_3I (
-		JNIEnv *env, jobject obj,
-		jlong tobj,
-		jdoubleArray coords,
-		jintArray vertex_data)
-	{
-		jboolean isCopiedArray1 = JNI_FALSE;
-		jdouble *ptr1 = NULL;
-		jboolean isCopiedArray2 = JNI_FALSE;
-		jint *ptr2 = NULL;
-
-		if(coords!=NULL)
-		{
-			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
-		}
-		if(vertex_data!=NULL)
-		{
-			ptr2 = (*env)->GetIntArrayElements(env, vertex_data, &isCopiedArray2);
-		}
-		gluTessVertex (
-			(GLUtesselator *) (PointerHolder) tobj,
-			(GLdouble *) ptr1,
-			(void *) ptr2
-		);
-
-		if(coords!=NULL)
-		{
-			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
-		}
-		if(vertex_data!=NULL)
-		{
-			(*env)->ReleaseIntArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
-		}
-	}
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluTessVertex__J_3D_3F (
-		JNIEnv *env, jobject obj,
-		jlong tobj,
-		jdoubleArray coords,
-		jfloatArray vertex_data)
-	{
-		jboolean isCopiedArray1 = JNI_FALSE;
-		jdouble *ptr1 = NULL;
-		jboolean isCopiedArray2 = JNI_FALSE;
-		jfloat *ptr2 = NULL;
-
-		if(coords!=NULL)
-		{
-			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
-		}
-		if(vertex_data!=NULL)
-		{
-			ptr2 = (*env)->GetFloatArrayElements(env, vertex_data, &isCopiedArray2);
-		}
-		gluTessVertex (
-			(GLUtesselator *) (PointerHolder) tobj,
-			(GLdouble *) ptr1,
-			(void *) ptr2
-		);
-
-		if(coords!=NULL)
-		{
-			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
-		}
-		if(vertex_data!=NULL)
-		{
-			(*env)->ReleaseFloatArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
-		}
-	}
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluTessVertex__J_3D_3D (
-		JNIEnv *env, jobject obj,
-		jlong tobj,
-		jdoubleArray coords,
-		jdoubleArray vertex_data)
-	{
-		jboolean isCopiedArray1 = JNI_FALSE;
-		jdouble *ptr1 = NULL;
-		jboolean isCopiedArray2 = JNI_FALSE;
-		jdouble *ptr2 = NULL;
-
-		if(coords!=NULL)
-		{
-			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
-		}
-		if(vertex_data!=NULL)
-		{
-			ptr2 = (*env)->GetDoubleArrayElements(env, vertex_data, &isCopiedArray2);
-		}
-		gluTessVertex (
-			(GLUtesselator *) (PointerHolder) tobj,
-			(GLdouble *) ptr1,
-			(void *) ptr2
-		);
-
-		if(coords!=NULL)
-		{
-			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
-		}
-		if(vertex_data!=NULL)
-		{
-			(*env)->ReleaseDoubleArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
-		}
-	}
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluTessVertex__J_3D_3Z (
-		JNIEnv *env, jobject obj,
-		jlong tobj,
-		jdoubleArray coords,
-		jbooleanArray vertex_data)
-	{
-		jboolean isCopiedArray1 = JNI_FALSE;
-		jdouble *ptr1 = NULL;
-		jboolean isCopiedArray2 = JNI_FALSE;
-		jboolean *ptr2 = NULL;
-
-		if(coords!=NULL)
-		{
-			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
-		}
-		if(vertex_data!=NULL)
-		{
-			ptr2 = (*env)->GetBooleanArrayElements(env, vertex_data, &isCopiedArray2);
-		}
-		gluTessVertex (
-			(GLUtesselator *) (PointerHolder) tobj,
-			(GLdouble *) ptr1,
-			(void *) ptr2
-		);
-
-		if(coords!=NULL)
-		{
-			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
-		}
-		if(vertex_data!=NULL)
-		{
-			(*env)->ReleaseBooleanArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
-		}
-	}
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluTessVertex__J_3D_3J (
-		JNIEnv *env, jobject obj,
-		jlong tobj,
-		jdoubleArray coords,
-		jlongArray vertex_data)
-	{
-		jboolean isCopiedArray1 = JNI_FALSE;
-		jdouble *ptr1 = NULL;
-		jboolean isCopiedArray2 = JNI_FALSE;
-		jlong *ptr2 = NULL;
-
-		if(coords!=NULL)
-		{
-			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
-		}
-		if(vertex_data!=NULL)
-		{
-			ptr2 = (*env)->GetLongArrayElements(env, vertex_data, &isCopiedArray2);
-		}
-		gluTessVertex (
-			(GLUtesselator *) (PointerHolder) tobj,
-			(GLdouble *) ptr1,
-			(void *) ptr2
-		);
-
-		if(coords!=NULL)
-		{
-			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
-		}
-		if(vertex_data!=NULL)
-		{
-			(*env)->ReleaseLongArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
-		}
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluTessEndContour ( GLUtesselator * tobj ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluTessEndContour (
-		JNIEnv *env, jobject obj,
-		jlong tobj)
-	{
-
-		gluTessEndContour (
-			(GLUtesselator *) (PointerHolder) tobj
-		);
-
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluTessEndPolygon ( GLUtesselator * tobj ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluTessEndPolygon (
-		JNIEnv *env, jobject obj,
-		jlong tobj)
-	{
-
-		gluTessEndPolygon (
-			(GLUtesselator *) (PointerHolder) tobj
-		);
-
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluTessProperty ( GLUtesselator * tobj , GLenum which , GLdouble value ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluTessProperty (
-		JNIEnv *env, jobject obj,
-		jlong tobj,
-		jint which,
-		jdouble value)
-	{
-
-		gluTessProperty (
-			(GLUtesselator *) (PointerHolder) tobj,
-			(GLenum) which,
-			(GLdouble) value
-		);
-
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluTessNormal ( GLUtesselator * tobj , GLdouble x , GLdouble y , GLdouble z ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluTessNormal (
-		JNIEnv *env, jobject obj,
-		jlong tobj,
-		jdouble x,
-		jdouble y,
-		jdouble z)
-	{
-
-		gluTessNormal (
-			(GLUtesselator *) (PointerHolder) tobj,
-			(GLdouble) x,
-			(GLdouble) y,
-			(GLdouble) z
-		);
-
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluGetTessProperty ( GLUtesselator * tobj , GLenum which , GLdouble * value ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluGetTessProperty (
-		JNIEnv *env, jobject obj,
-		jlong tobj,
-		jint which,
-		jdoubleArray value)
-	{
-		jboolean isCopiedArray2 = JNI_FALSE;
-		jdouble *ptr2 = NULL;
-
-		if(value!=NULL)
-		{
-			ptr2 = (*env)->GetDoubleArrayElements(env, value, &isCopiedArray2);
-		}
-		gluGetTessProperty (
-			(GLUtesselator *) (PointerHolder) tobj,
-			(GLenum) which,
-			(GLdouble *) ptr2
-		);
-
-		if(value!=NULL)
-		{
-			(*env)->ReleaseDoubleArrayElements(env,  value, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
-		}
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluBeginPolygon ( GLUtesselator * tobj ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluBeginPolygon (
-		JNIEnv *env, jobject obj,
-		jlong tobj)
-	{
-
-		gluBeginPolygon (
-			(GLUtesselator *) (PointerHolder) tobj
-		);
-
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluNextContour ( GLUtesselator * tobj , GLenum type ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluNextContour (
-		JNIEnv *env, jobject obj,
-		jlong tobj,
-		jint type)
-	{
-
-		gluNextContour (
-			(GLUtesselator *) (PointerHolder) tobj,
-			(GLenum) type
-		);
-
-	}
-
-/**
- * Original Function-Prototype :
- * <pre> 
-   extern void gluEndPolygon ( GLUtesselator * tobj ) ;
- * </pre> 
- */
-	JNIEXPORT void JNICALL
-	Java_gl4java_GLUFuncJauJNInf_gluEndPolygon (
-		JNIEnv *env, jobject obj,
-		jlong tobj)
-	{
-
-		gluEndPolygon (
-			(GLUtesselator *) (PointerHolder) tobj
-		);
-
-	}
-
-/* C2J Parser Version 1.5 Beta:  Java program parsed successfully. */ 
+static const char _glu_n_a_string[] = "GLU-String not avaiable !";
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLUFuncJauJNInf_gluErrorString ( JNIEnv *env, jobject obj,
+	                                    jint errorCode ) 
+{
+    const char *tmpString=0;
+
+    tmpString = gluErrorString ( /* jint */ errorCode );
+    if(tmpString==NULL)
+    	tmpString=_glu_n_a_string;
+
+    return (*env)->NewStringUTF(env, tmpString);
+}
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLUFuncJauJNInf_gluGetString ( JNIEnv *env, jobject obj,
+	                                  jint name ) 
+{
+    const char *tmpString=0;
+
+    tmpString = gluGetString ( /* jint */ name);
+    if(tmpString==NULL)
+    	tmpString=_glu_n_a_string;
+
+    return (*env)->NewStringUTF(env, tmpString);   
+}
+
+static const char * _glu_lib_vendor_="Jausoft - Sven Goethel Software Development";
+static const char * _glu_lib_version_="2.5.2.0";
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLUFuncJauJNInf_getNativeVendor ( JNIEnv *env, jobject obj )
+{
+    return (*env)->NewStringUTF(env, _glu_lib_vendor_);   
+}
+
+JNIEXPORT jstring JNICALL
+Java_gl4java_GLUFuncJauJNInf_getNativeVersion ( JNIEnv *env, jobject obj )
+{
+    return (*env)->NewStringUTF(env, _glu_lib_version_);   
+}
+
+static void _AddCallbackNode(JNIEnv *env,
+	                          jlong qnt_obj, jint which,
+			          jobject methodClassInstance, 
+			          jstring methodName, 
+				  jstring signature,
+				  jint arrayLen1,
+				  jint arrayLen2,
+				  jint arrayLen3,
+				  jint arrayLen4,
+				  jint arrayLen5)
+{
+	char * strMethodName = jnitoolsGetJavaString(env, methodName);
+	char * strSignature = jnitoolsGetJavaString(env, signature);
+	jlong glx=0;
+
+	glx = GetCurrentGLContext();
+
+	AddCallbackNode(env, methodClassInstance, strMethodName, strSignature,
+			arrayLen1, arrayLen2, arrayLen3,
+			arrayLen4, arrayLen5,
+			(void *)((PointerHolder)qnt_obj), which, glx);
+	free(strMethodName);
+	free(strSignature);
+}
+                  
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFuncJauJNInf_gluQuadricCallback( JNIEnv *env, jobject obj,
+	                          jlong qobj, jint which,
+			          jobject methodClassInstance, 
+			          jstring methodName, 
+				  jstring signature)
+{
+	switch(which)
+	{
+		case GLU_ERROR:
+			gluQuadricCallback((void *)((PointerHolder)qobj), 
+			                   which, cbf_GLU_ERROR );
+			break;
+		default:
+		    jnitoolsThrowByName(env, "java/lang/IllegalArgumentException", "Wrong Callback-Function type (\"which\") !");
+		    return;
+	}
+	_AddCallbackNode(env, 
+			 qobj, which, methodClassInstance, methodName, 
+			  signature, 
+			  0, 0, 0, 0, 0);
+}
+
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFuncJauJNInf_gluNurbsCallback( JNIEnv *env, jobject obj,
+	                          jlong nobj, jint which,
+			          jobject methodClassInstance, 
+			          jstring methodName, 
+				  jstring signature)
+{
+	switch(which)
+	{
+		case GLU_ERROR:
+			gluNurbsCallback((void *)((PointerHolder)nobj), which, 
+				         cbf_GLU_ERROR );
+			break;
+		default:
+		    jnitoolsThrowByName(env, "java/lang/IllegalArgumentException", "Wrong Callback-Function type (\"which\") !");
+		    return;
+	}
+	_AddCallbackNode(env,
+			 nobj, which, methodClassInstance, methodName, 
+			  signature, 
+			  0, 0, 0, 0, 0);
+}
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFuncJauJNInf_gluTessCallback( JNIEnv *env, jobject obj,
+	                          jlong tobj, jint which,
+			          jobject methodClassInstance, 
+			          jstring methodName, 
+				  jstring signature,
+				  jint arrayLen1,
+				  jint arrayLen2,
+				  jint arrayLen3,
+				  jint arrayLen4,
+				  jint arrayLen5)
+{
+	switch(which)
+	{
+		case GLU_TESS_BEGIN:
+			gluTessCallback((GLUtesselator *)((PointerHolder)tobj), 
+			                which, 
+				        cbf_GLU_TESS_BEGIN );
+			break;
+		case GLU_TESS_BEGIN_DATA:
+			gluTessCallback((GLUtesselator *)((PointerHolder)tobj), 
+			                which, 
+				        cbf_GLU_TESS_BEGIN_DATA );
+			break;
+		case GLU_TESS_EDGE_FLAG:
+			gluTessCallback((GLUtesselator *)((PointerHolder)tobj), 
+			                which, 
+				        cbf_GLU_TESS_EDGE_FLAG );
+			break;
+		case GLU_TESS_EDGE_FLAG_DATA:
+			gluTessCallback((GLUtesselator *)((PointerHolder)tobj), 
+			                which, 
+				        cbf_GLU_TESS_EDGE_FLAG_DATA );
+			break;
+		case GLU_TESS_VERTEX:
+			gluTessCallback((GLUtesselator *)((PointerHolder)tobj), 
+			                which, 
+				        cbf_GLU_TESS_VERTEX );
+			break;
+		case GLU_TESS_VERTEX_DATA:
+			gluTessCallback((GLUtesselator *)((PointerHolder)tobj), 
+			                which, 
+				        cbf_GLU_TESS_VERTEX_DATA );
+			break;
+		case GLU_TESS_END:
+			gluTessCallback((GLUtesselator *)((PointerHolder)tobj), 
+			                which, 
+				        cbf_GLU_TESS_END );
+			break;
+		case GLU_TESS_END_DATA:
+			gluTessCallback((GLUtesselator *)((PointerHolder)tobj), 
+			                which, 
+				        cbf_GLU_TESS_END_DATA );
+			break;
+		case GLU_TESS_ERROR:
+			gluTessCallback((GLUtesselator *)((PointerHolder)tobj), 
+			                which, 
+				        cbf_GLU_TESS_ERROR );
+			break;
+		case GLU_TESS_ERROR_DATA:
+			gluTessCallback((GLUtesselator *)((PointerHolder)tobj), 
+			                which, 
+				        cbf_GLU_TESS_ERROR_DATA );
+			break;
+		case GLU_TESS_COMBINE:
+			gluTessCallback((GLUtesselator *)((PointerHolder)tobj), 
+			                which, 
+				        cbf_GLU_TESS_COMBINE );
+			break;
+		case GLU_TESS_COMBINE_DATA:
+			gluTessCallback((GLUtesselator *)((PointerHolder)tobj), 
+			                which, 
+				        cbf_GLU_TESS_COMBINE_DATA );
+			break;
+		default:
+		    jnitoolsThrowByName(env, "java/lang/IllegalArgumentException", "Wrong Callback-Function type (\"which\") !");
+		    return;
+	}
+	_AddCallbackNode(env,
+			  tobj, which, methodClassInstance, methodName, 
+			  signature, 
+			  arrayLen1, arrayLen2, arrayLen3,
+			  arrayLen4, arrayLen5);
+}
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFuncJauJNInf_gluDeleteQuadric( JNIEnv *env, jobject obj,
+					     jlong qobj )
+{
+	gluDeleteQuadric((void *)((PointerHolder)qobj));
+	RemoveCallbackNodes((void *)((PointerHolder)qobj));
+}
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFuncJauJNInf_gluDeleteNurbsRenderer( JNIEnv *env, jobject obj,
+						   jlong nobj )
+{
+	gluDeleteNurbsRenderer((void *)((PointerHolder)nobj));
+	RemoveCallbackNodes((void *)((PointerHolder)nobj));
+}
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLUFuncJauJNInf_gluDeleteTess( JNIEnv *env, jobject obj,
+					  jlong tobj )
+{
+	gluDeleteTess((GLUtesselator *)((PointerHolder)tobj));
+	RemoveCallbackNodes((void *)((PointerHolder)tobj));
+}
+
+JNIEXPORT jlong JNICALL
+Java_gl4java_GLUFuncJauJNInf_gluNewQuadric( JNIEnv *env, jobject obj)
+{
+	return (jlong)((PointerHolder)gluNewQuadric());
+}
+
+JNIEXPORT jlong JNICALL
+Java_gl4java_GLUFuncJauJNInf_gluNewNurbsRenderer( JNIEnv *env, jobject obj)
+{
+	return (jlong)((PointerHolder)gluNewNurbsRenderer());
+}
+
+JNIEXPORT jlong JNICALL
+Java_gl4java_GLUFuncJauJNInf_gluNewTess( JNIEnv *env, jobject obj)
+{
+	return (jlong)((PointerHolder)gluNewTess());
+}
+
+/**
+ * C2J Parser Version 1.5 Beta
+ * Jausoft - Sven Goethel Software Development
+ * Reading from file: glu-proto-auto.orig.h . . .
+ * Destination-Class: gl4java_GLUFuncJauJNInf ! 
+ */
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluLookAt ( GLdouble eyex , GLdouble eyey , GLdouble eyez , GLdouble centerx , GLdouble centery , GLdouble centerz , GLdouble upx , GLdouble upy , GLdouble upz ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluLookAt (
+		JNIEnv *env, jobject obj,
+		jdouble eyex,
+		jdouble eyey,
+		jdouble eyez,
+		jdouble centerx,
+		jdouble centery,
+		jdouble centerz,
+		jdouble upx,
+		jdouble upy,
+		jdouble upz)
+	{
+
+		gluLookAt (
+			(GLdouble) eyex,
+			(GLdouble) eyey,
+			(GLdouble) eyez,
+			(GLdouble) centerx,
+			(GLdouble) centery,
+			(GLdouble) centerz,
+			(GLdouble) upx,
+			(GLdouble) upy,
+			(GLdouble) upz
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluOrtho2D ( GLdouble left , GLdouble right , GLdouble bottom , GLdouble top ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluOrtho2D (
+		JNIEnv *env, jobject obj,
+		jdouble left,
+		jdouble right,
+		jdouble bottom,
+		jdouble top)
+	{
+
+		gluOrtho2D (
+			(GLdouble) left,
+			(GLdouble) right,
+			(GLdouble) bottom,
+			(GLdouble) top
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluPerspective ( GLdouble fovy , GLdouble aspect , GLdouble zNear , GLdouble zFar ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluPerspective (
+		JNIEnv *env, jobject obj,
+		jdouble fovy,
+		jdouble aspect,
+		jdouble zNear,
+		jdouble zFar)
+	{
+
+		gluPerspective (
+			(GLdouble) fovy,
+			(GLdouble) aspect,
+			(GLdouble) zNear,
+			(GLdouble) zFar
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluPickMatrix ( GLdouble x , GLdouble y , GLdouble width , GLdouble height , GLint * viewport ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluPickMatrix (
+		JNIEnv *env, jobject obj,
+		jdouble x,
+		jdouble y,
+		jdouble width,
+		jdouble height,
+		jintArray viewport)
+	{
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jint *ptr4 = NULL;
+
+		if(viewport!=NULL)
+		{
+			ptr4 = (*env)->GetIntArrayElements(env, viewport, &isCopiedArray4);
+		}
+		gluPickMatrix (
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) width,
+			(GLdouble) height,
+			(GLint *) ptr4
+		);
+
+		if(viewport!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  viewport, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLint gluProject ( GLdouble objx , GLdouble objy , GLdouble objz , const GLdouble modelMatrix [ 16 ] , const GLdouble projMatrix [ 16 ] , const GLint viewport [ 4 ] , GLdouble * winx , GLdouble * winy , GLdouble * winz ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluProject (
+		JNIEnv *env, jobject obj,
+		jdouble objx,
+		jdouble objy,
+		jdouble objz,
+		jdoubleArray modelMatrix,
+		jdoubleArray projMatrix,
+		jintArray viewport,
+		jdoubleArray winx,
+		jdoubleArray winy,
+		jdoubleArray winz)
+	{
+		jint ret;
+
+		jdouble *ptr3 = NULL;
+		jdouble *ptr4 = NULL;
+		jint *ptr5 = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jdouble *ptr6 = NULL;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jdouble *ptr7 = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jdouble *ptr8 = NULL;
+
+		if(modelMatrix!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, modelMatrix, 0);
+		}
+		if(projMatrix!=NULL)
+		{
+			ptr4 = (*env)->GetDoubleArrayElements(env, projMatrix, 0);
+		}
+		if(viewport!=NULL)
+		{
+			ptr5 = (*env)->GetIntArrayElements(env, viewport, 0);
+		}
+		if(winx!=NULL)
+		{
+			ptr6 = (*env)->GetDoubleArrayElements(env, winx, &isCopiedArray6);
+		}
+		if(winy!=NULL)
+		{
+			ptr7 = (*env)->GetDoubleArrayElements(env, winy, &isCopiedArray7);
+		}
+		if(winz!=NULL)
+		{
+			ptr8 = (*env)->GetDoubleArrayElements(env, winz, &isCopiedArray8);
+		}
+		ret = (jint) gluProject (
+			(GLdouble) objx,
+			(GLdouble) objy,
+			(GLdouble) objz,
+			(const GLdouble *) ptr3,
+			(const GLdouble *) ptr4,
+			(const GLint *) ptr5,
+			(GLdouble *) ptr6,
+			(GLdouble *) ptr7,
+			(GLdouble *) ptr8
+		);
+
+		if(modelMatrix!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  modelMatrix, ptr3, JNI_ABORT);
+		}
+		if(projMatrix!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  projMatrix, ptr4, JNI_ABORT);
+		}
+		if(viewport!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  viewport, ptr5, JNI_ABORT);
+		}
+		if(winx!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  winx, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(winy!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  winy, ptr7, (isCopiedArray7 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(winz!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  winz, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLint gluUnProject ( GLdouble winx , GLdouble winy , GLdouble winz , const GLdouble modelMatrix [ 16 ] , const GLdouble projMatrix [ 16 ] , const GLint viewport [ 4 ] , GLdouble * objx , GLdouble * objy , GLdouble * objz ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluUnProject (
+		JNIEnv *env, jobject obj,
+		jdouble winx,
+		jdouble winy,
+		jdouble winz,
+		jdoubleArray modelMatrix,
+		jdoubleArray projMatrix,
+		jintArray viewport,
+		jdoubleArray objx,
+		jdoubleArray objy,
+		jdoubleArray objz)
+	{
+		jint ret;
+
+		jdouble *ptr3 = NULL;
+		jdouble *ptr4 = NULL;
+		jint *ptr5 = NULL;
+		jboolean isCopiedArray6 = JNI_FALSE;
+		jdouble *ptr6 = NULL;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jdouble *ptr7 = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jdouble *ptr8 = NULL;
+
+		if(modelMatrix!=NULL)
+		{
+			ptr3 = (*env)->GetDoubleArrayElements(env, modelMatrix, 0);
+		}
+		if(projMatrix!=NULL)
+		{
+			ptr4 = (*env)->GetDoubleArrayElements(env, projMatrix, 0);
+		}
+		if(viewport!=NULL)
+		{
+			ptr5 = (*env)->GetIntArrayElements(env, viewport, 0);
+		}
+		if(objx!=NULL)
+		{
+			ptr6 = (*env)->GetDoubleArrayElements(env, objx, &isCopiedArray6);
+		}
+		if(objy!=NULL)
+		{
+			ptr7 = (*env)->GetDoubleArrayElements(env, objy, &isCopiedArray7);
+		}
+		if(objz!=NULL)
+		{
+			ptr8 = (*env)->GetDoubleArrayElements(env, objz, &isCopiedArray8);
+		}
+		ret = (jint) gluUnProject (
+			(GLdouble) winx,
+			(GLdouble) winy,
+			(GLdouble) winz,
+			(const GLdouble *) ptr3,
+			(const GLdouble *) ptr4,
+			(const GLint *) ptr5,
+			(GLdouble *) ptr6,
+			(GLdouble *) ptr7,
+			(GLdouble *) ptr8
+		);
+
+		if(modelMatrix!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  modelMatrix, ptr3, JNI_ABORT);
+		}
+		if(projMatrix!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  projMatrix, ptr4, JNI_ABORT);
+		}
+		if(viewport!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  viewport, ptr5, JNI_ABORT);
+		}
+		if(objx!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  objx, ptr6, (isCopiedArray6 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(objy!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  objy, ptr7, (isCopiedArray7 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(objz!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  objz, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLint gluScaleImage ( GLenum format , GLsizei widthin , GLsizei heightin , GLenum typein , const char * datain , GLsizei widthout , GLsizei heightout , GLenum typeout , char * dataout ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluScaleImage (
+		JNIEnv *env, jobject obj,
+		jint format,
+		jint widthin,
+		jint heightin,
+		jint typein,
+		jbyteArray datain,
+		jint widthout,
+		jint heightout,
+		jint typeout,
+		jbyteArray dataout)
+	{
+		jint ret;
+
+		jbyte *ptr4 = NULL;
+		jboolean isCopiedArray8 = JNI_FALSE;
+		jbyte *ptr8 = NULL;
+
+		if(datain!=NULL)
+		{
+			ptr4 = (*env)->GetByteArrayElements(env, datain, 0);
+		}
+		if(dataout!=NULL)
+		{
+			ptr8 = (*env)->GetByteArrayElements(env, dataout, &isCopiedArray8);
+		}
+		ret = (jint) gluScaleImage (
+			(GLenum) format,
+			(GLsizei) widthin,
+			(GLsizei) heightin,
+			(GLenum) typein,
+			(const char *) ptr4,
+			(GLsizei) widthout,
+			(GLsizei) heightout,
+			(GLenum) typeout,
+			(char *) ptr8
+		);
+
+		if(datain!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  datain, ptr4, JNI_ABORT);
+		}
+		if(dataout!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  dataout, ptr8, (isCopiedArray8 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLint gluBuild1DMipmaps ( GLenum target , GLint components , GLint width , GLenum format , GLenum type , const void * data ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluBuild1DMipmaps__IIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jbyteArray data)
+	{
+		jint ret;
+
+		jbyte *ptr5 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetByteArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluBuild1DMipmaps__IIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jshortArray data)
+	{
+		jint ret;
+
+		jshort *ptr5 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetShortArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluBuild1DMipmaps__IIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jintArray data)
+	{
+		jint ret;
+
+		jint *ptr5 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetIntArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluBuild1DMipmaps__IIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jfloatArray data)
+	{
+		jint ret;
+
+		jfloat *ptr5 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetFloatArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluBuild1DMipmaps__IIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jdoubleArray data)
+	{
+		jint ret;
+
+		jdouble *ptr5 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetDoubleArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluBuild1DMipmaps__IIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jbooleanArray data)
+	{
+		jint ret;
+
+		jboolean *ptr5 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetBooleanArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluBuild1DMipmaps__IIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint format,
+		jint type,
+		jlongArray data)
+	{
+		jint ret;
+
+		jlong *ptr5 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr5 = (*env)->GetLongArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild1DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr5
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  data, ptr5, JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern GLint gluBuild2DMipmaps ( GLenum target , GLint components , GLint width , GLint height , GLenum format , GLenum type , const void * data ) ;
+ * </pre> 
+ */
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluBuild2DMipmaps__IIIIII_3B (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbyteArray data)
+	{
+		jint ret;
+
+		jbyte *ptr6 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr6 = (*env)->GetByteArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluBuild2DMipmaps__IIIIII_3S (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jshortArray data)
+	{
+		jint ret;
+
+		jshort *ptr6 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr6 = (*env)->GetShortArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluBuild2DMipmaps__IIIIII_3I (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jintArray data)
+	{
+		jint ret;
+
+		jint *ptr6 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr6 = (*env)->GetIntArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluBuild2DMipmaps__IIIIII_3F (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jfloatArray data)
+	{
+		jint ret;
+
+		jfloat *ptr6 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr6 = (*env)->GetFloatArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluBuild2DMipmaps__IIIIII_3D (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jdoubleArray data)
+	{
+		jint ret;
+
+		jdouble *ptr6 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr6 = (*env)->GetDoubleArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluBuild2DMipmaps__IIIIII_3Z (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jbooleanArray data)
+	{
+		jint ret;
+
+		jboolean *ptr6 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr6 = (*env)->GetBooleanArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+	JNIEXPORT jint JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluBuild2DMipmaps__IIIIII_3J (
+		JNIEnv *env, jobject obj,
+		jint target,
+		jint components,
+		jint width,
+		jint height,
+		jint format,
+		jint type,
+		jlongArray data)
+	{
+		jint ret;
+
+		jlong *ptr6 = NULL;
+
+		if(data!=NULL)
+		{
+			ptr6 = (*env)->GetLongArrayElements(env, data, 0);
+		}
+		ret = (jint) gluBuild2DMipmaps (
+			(GLenum) target,
+			(GLint) components,
+			(GLint) width,
+			(GLint) height,
+			(GLenum) format,
+			(GLenum) type,
+			(const void *) ptr6
+		);
+
+		if(data!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  data, ptr6, JNI_ABORT);
+		}
+		return ret;
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluQuadricDrawStyle ( GLUquadricObj * quadObject , GLenum drawStyle ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluQuadricDrawStyle (
+		JNIEnv *env, jobject obj,
+		jlong quadObject,
+		jint drawStyle)
+	{
+
+		gluQuadricDrawStyle (
+			(GLUquadricObj *) (PointerHolder) quadObject,
+			(GLenum) drawStyle
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluQuadricOrientation ( GLUquadricObj * quadObject , GLenum orientation ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluQuadricOrientation (
+		JNIEnv *env, jobject obj,
+		jlong quadObject,
+		jint orientation)
+	{
+
+		gluQuadricOrientation (
+			(GLUquadricObj *) (PointerHolder) quadObject,
+			(GLenum) orientation
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluQuadricNormals ( GLUquadricObj * quadObject , GLenum normals ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluQuadricNormals (
+		JNIEnv *env, jobject obj,
+		jlong quadObject,
+		jint normals)
+	{
+
+		gluQuadricNormals (
+			(GLUquadricObj *) (PointerHolder) quadObject,
+			(GLenum) normals
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluQuadricTexture ( GLUquadricObj * quadObject , GLboolean textureCoords ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluQuadricTexture (
+		JNIEnv *env, jobject obj,
+		jlong quadObject,
+		jboolean textureCoords)
+	{
+
+		gluQuadricTexture (
+			(GLUquadricObj *) (PointerHolder) quadObject,
+			(GLboolean) textureCoords
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluCylinder ( GLUquadricObj * qobj , GLdouble baseRadius , GLdouble topRadius , GLdouble height , GLint slices , GLint stacks ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluCylinder (
+		JNIEnv *env, jobject obj,
+		jlong qobj,
+		jdouble baseRadius,
+		jdouble topRadius,
+		jdouble height,
+		jint slices,
+		jint stacks)
+	{
+
+		gluCylinder (
+			(GLUquadricObj *) (PointerHolder) qobj,
+			(GLdouble) baseRadius,
+			(GLdouble) topRadius,
+			(GLdouble) height,
+			(GLint) slices,
+			(GLint) stacks
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluSphere ( GLUquadricObj * qobj , GLdouble radius , GLint slices , GLint stacks ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluSphere (
+		JNIEnv *env, jobject obj,
+		jlong qobj,
+		jdouble radius,
+		jint slices,
+		jint stacks)
+	{
+
+		gluSphere (
+			(GLUquadricObj *) (PointerHolder) qobj,
+			(GLdouble) radius,
+			(GLint) slices,
+			(GLint) stacks
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluDisk ( GLUquadricObj * qobj , GLdouble innerRadius , GLdouble outerRadius , GLint slices , GLint loops ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluDisk (
+		JNIEnv *env, jobject obj,
+		jlong qobj,
+		jdouble innerRadius,
+		jdouble outerRadius,
+		jint slices,
+		jint loops)
+	{
+
+		gluDisk (
+			(GLUquadricObj *) (PointerHolder) qobj,
+			(GLdouble) innerRadius,
+			(GLdouble) outerRadius,
+			(GLint) slices,
+			(GLint) loops
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluPartialDisk ( GLUquadricObj * qobj , GLdouble innerRadius , GLdouble outerRadius , GLint slices , GLint loops , GLdouble startAngle , GLdouble sweepAngle ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluPartialDisk (
+		JNIEnv *env, jobject obj,
+		jlong qobj,
+		jdouble innerRadius,
+		jdouble outerRadius,
+		jint slices,
+		jint loops,
+		jdouble startAngle,
+		jdouble sweepAngle)
+	{
+
+		gluPartialDisk (
+			(GLUquadricObj *) (PointerHolder) qobj,
+			(GLdouble) innerRadius,
+			(GLdouble) outerRadius,
+			(GLint) slices,
+			(GLint) loops,
+			(GLdouble) startAngle,
+			(GLdouble) sweepAngle
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluLoadSamplingMatrices ( GLUnurbsObj * nobj , const GLfloat modelMatrix [ 16 ] , const GLfloat projMatrix [ 16 ] , const GLint viewport [ 4 ] ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluLoadSamplingMatrices (
+		JNIEnv *env, jobject obj,
+		jlong nobj,
+		jfloatArray modelMatrix,
+		jfloatArray projMatrix,
+		jintArray viewport)
+	{
+		jfloat *ptr1 = NULL;
+		jfloat *ptr2 = NULL;
+		jint *ptr3 = NULL;
+
+		if(modelMatrix!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, modelMatrix, 0);
+		}
+		if(projMatrix!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, projMatrix, 0);
+		}
+		if(viewport!=NULL)
+		{
+			ptr3 = (*env)->GetIntArrayElements(env, viewport, 0);
+		}
+		gluLoadSamplingMatrices (
+			(GLUnurbsObj *) (PointerHolder) nobj,
+			(const GLfloat *) ptr1,
+			(const GLfloat *) ptr2,
+			(const GLint *) ptr3
+		);
+
+		if(modelMatrix!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  modelMatrix, ptr1, JNI_ABORT);
+		}
+		if(projMatrix!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  projMatrix, ptr2, JNI_ABORT);
+		}
+		if(viewport!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  viewport, ptr3, JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluNurbsProperty ( GLUnurbsObj * nobj , GLenum property , GLfloat value ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluNurbsProperty (
+		JNIEnv *env, jobject obj,
+		jlong nobj,
+		jint property,
+		jfloat value)
+	{
+
+		gluNurbsProperty (
+			(GLUnurbsObj *) (PointerHolder) nobj,
+			(GLenum) property,
+			(GLfloat) value
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluGetNurbsProperty ( GLUnurbsObj * nobj , GLenum property , GLfloat * value ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluGetNurbsProperty (
+		JNIEnv *env, jobject obj,
+		jlong nobj,
+		jint property,
+		jfloatArray value)
+	{
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(value!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, value, &isCopiedArray2);
+		}
+		gluGetNurbsProperty (
+			(GLUnurbsObj *) (PointerHolder) nobj,
+			(GLenum) property,
+			(GLfloat *) ptr2
+		);
+
+		if(value!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  value, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluBeginCurve ( GLUnurbsObj * nobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluBeginCurve (
+		JNIEnv *env, jobject obj,
+		jlong nobj)
+	{
+
+		gluBeginCurve (
+			(GLUnurbsObj *) (PointerHolder) nobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluEndCurve ( GLUnurbsObj * nobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluEndCurve (
+		JNIEnv *env, jobject obj,
+		jlong nobj)
+	{
+
+		gluEndCurve (
+			(GLUnurbsObj *) (PointerHolder) nobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluNurbsCurve ( GLUnurbsObj * nobj , GLint nknots , GLfloat * knot , GLint stride , GLfloat * ctlarray , GLint order , GLenum type ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluNurbsCurve (
+		JNIEnv *env, jobject obj,
+		jlong nobj,
+		jint nknots,
+		jfloatArray knot,
+		jint stride,
+		jfloatArray ctlarray,
+		jint order,
+		jint type)
+	{
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+
+		if(knot!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, knot, &isCopiedArray2);
+		}
+		if(ctlarray!=NULL)
+		{
+			ptr4 = (*env)->GetFloatArrayElements(env, ctlarray, &isCopiedArray4);
+		}
+		gluNurbsCurve (
+			(GLUnurbsObj *) (PointerHolder) nobj,
+			(GLint) nknots,
+			(GLfloat *) ptr2,
+			(GLint) stride,
+			(GLfloat *) ptr4,
+			(GLint) order,
+			(GLenum) type
+		);
+
+		if(knot!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  knot, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(ctlarray!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ctlarray, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluBeginSurface ( GLUnurbsObj * nobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluBeginSurface (
+		JNIEnv *env, jobject obj,
+		jlong nobj)
+	{
+
+		gluBeginSurface (
+			(GLUnurbsObj *) (PointerHolder) nobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluEndSurface ( GLUnurbsObj * nobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluEndSurface (
+		JNIEnv *env, jobject obj,
+		jlong nobj)
+	{
+
+		gluEndSurface (
+			(GLUnurbsObj *) (PointerHolder) nobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluNurbsSurface ( GLUnurbsObj * nobj , GLint sknot_count , GLfloat * sknot , GLint tknot_count , GLfloat * tknot , GLint s_stride , GLint t_stride , GLfloat * ctlarray , GLint sorder , GLint torder , GLenum type ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluNurbsSurface (
+		JNIEnv *env, jobject obj,
+		jlong nobj,
+		jint sknot_count,
+		jfloatArray sknot,
+		jint tknot_count,
+		jfloatArray tknot,
+		jint s_stride,
+		jint t_stride,
+		jfloatArray ctlarray,
+		jint sorder,
+		jint torder,
+		jint type)
+	{
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+		jboolean isCopiedArray4 = JNI_FALSE;
+		jfloat *ptr4 = NULL;
+		jboolean isCopiedArray7 = JNI_FALSE;
+		jfloat *ptr7 = NULL;
+
+		if(sknot!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, sknot, &isCopiedArray2);
+		}
+		if(tknot!=NULL)
+		{
+			ptr4 = (*env)->GetFloatArrayElements(env, tknot, &isCopiedArray4);
+		}
+		if(ctlarray!=NULL)
+		{
+			ptr7 = (*env)->GetFloatArrayElements(env, ctlarray, &isCopiedArray7);
+		}
+		gluNurbsSurface (
+			(GLUnurbsObj *) (PointerHolder) nobj,
+			(GLint) sknot_count,
+			(GLfloat *) ptr2,
+			(GLint) tknot_count,
+			(GLfloat *) ptr4,
+			(GLint) s_stride,
+			(GLint) t_stride,
+			(GLfloat *) ptr7,
+			(GLint) sorder,
+			(GLint) torder,
+			(GLenum) type
+		);
+
+		if(sknot!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  sknot, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(tknot!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  tknot, ptr4, (isCopiedArray4 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(ctlarray!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  ctlarray, ptr7, (isCopiedArray7 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluBeginTrim ( GLUnurbsObj * nobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluBeginTrim (
+		JNIEnv *env, jobject obj,
+		jlong nobj)
+	{
+
+		gluBeginTrim (
+			(GLUnurbsObj *) (PointerHolder) nobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluEndTrim ( GLUnurbsObj * nobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluEndTrim (
+		JNIEnv *env, jobject obj,
+		jlong nobj)
+	{
+
+		gluEndTrim (
+			(GLUnurbsObj *) (PointerHolder) nobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluPwlCurve ( GLUnurbsObj * nobj , GLint count , GLfloat * array , GLint stride , GLenum type ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluPwlCurve (
+		JNIEnv *env, jobject obj,
+		jlong nobj,
+		jint count,
+		jfloatArray array,
+		jint stride,
+		jint type)
+	{
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(array!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, array, &isCopiedArray2);
+		}
+		gluPwlCurve (
+			(GLUnurbsObj *) (PointerHolder) nobj,
+			(GLint) count,
+			(GLfloat *) ptr2,
+			(GLint) stride,
+			(GLenum) type
+		);
+
+		if(array!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  array, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessBeginPolygon ( GLUtesselator * tobj , void * polygon_data ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluTessBeginPolygon__J_3B (
+		JNIEnv *env, jobject obj,
+		jlong tobj,
+		jbyteArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jbyte *ptr1 = NULL;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (*env)->GetByteArrayElements(env, polygon_data, &isCopiedArray1);
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) (PointerHolder) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluTessBeginPolygon__J_3S (
+		JNIEnv *env, jobject obj,
+		jlong tobj,
+		jshortArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jshort *ptr1 = NULL;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (*env)->GetShortArrayElements(env, polygon_data, &isCopiedArray1);
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) (PointerHolder) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluTessBeginPolygon__J_3I (
+		JNIEnv *env, jobject obj,
+		jlong tobj,
+		jintArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jint *ptr1 = NULL;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (*env)->GetIntArrayElements(env, polygon_data, &isCopiedArray1);
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) (PointerHolder) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluTessBeginPolygon__J_3F (
+		JNIEnv *env, jobject obj,
+		jlong tobj,
+		jfloatArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jfloat *ptr1 = NULL;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (*env)->GetFloatArrayElements(env, polygon_data, &isCopiedArray1);
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) (PointerHolder) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluTessBeginPolygon__J_3D (
+		JNIEnv *env, jobject obj,
+		jlong tobj,
+		jdoubleArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, polygon_data, &isCopiedArray1);
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) (PointerHolder) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluTessBeginPolygon__J_3Z (
+		JNIEnv *env, jobject obj,
+		jlong tobj,
+		jbooleanArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jboolean *ptr1 = NULL;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (*env)->GetBooleanArrayElements(env, polygon_data, &isCopiedArray1);
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) (PointerHolder) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluTessBeginPolygon__J_3J (
+		JNIEnv *env, jobject obj,
+		jlong tobj,
+		jlongArray polygon_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jlong *ptr1 = NULL;
+
+		if(polygon_data!=NULL)
+		{
+			ptr1 = (*env)->GetLongArrayElements(env, polygon_data, &isCopiedArray1);
+		}
+		gluTessBeginPolygon (
+			(GLUtesselator *) (PointerHolder) tobj,
+			(void *) ptr1
+		);
+
+		if(polygon_data!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  polygon_data, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessBeginContour ( GLUtesselator * tobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluTessBeginContour (
+		JNIEnv *env, jobject obj,
+		jlong tobj)
+	{
+
+		gluTessBeginContour (
+			(GLUtesselator *) (PointerHolder) tobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessVertex ( GLUtesselator * tobj , GLdouble coords [ 3 ] , void * vertex_data ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluTessVertex__J_3D_3B (
+		JNIEnv *env, jobject obj,
+		jlong tobj,
+		jdoubleArray coords,
+		jbyteArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jbyte *ptr2 = NULL;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (*env)->GetByteArrayElements(env, vertex_data, &isCopiedArray2);
+		}
+		gluTessVertex (
+			(GLUtesselator *) (PointerHolder) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleaseByteArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluTessVertex__J_3D_3S (
+		JNIEnv *env, jobject obj,
+		jlong tobj,
+		jdoubleArray coords,
+		jshortArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jshort *ptr2 = NULL;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (*env)->GetShortArrayElements(env, vertex_data, &isCopiedArray2);
+		}
+		gluTessVertex (
+			(GLUtesselator *) (PointerHolder) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleaseShortArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluTessVertex__J_3D_3I (
+		JNIEnv *env, jobject obj,
+		jlong tobj,
+		jdoubleArray coords,
+		jintArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jint *ptr2 = NULL;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (*env)->GetIntArrayElements(env, vertex_data, &isCopiedArray2);
+		}
+		gluTessVertex (
+			(GLUtesselator *) (PointerHolder) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleaseIntArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluTessVertex__J_3D_3F (
+		JNIEnv *env, jobject obj,
+		jlong tobj,
+		jdoubleArray coords,
+		jfloatArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jfloat *ptr2 = NULL;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (*env)->GetFloatArrayElements(env, vertex_data, &isCopiedArray2);
+		}
+		gluTessVertex (
+			(GLUtesselator *) (PointerHolder) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleaseFloatArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluTessVertex__J_3D_3D (
+		JNIEnv *env, jobject obj,
+		jlong tobj,
+		jdoubleArray coords,
+		jdoubleArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jdouble *ptr2 = NULL;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (*env)->GetDoubleArrayElements(env, vertex_data, &isCopiedArray2);
+		}
+		gluTessVertex (
+			(GLUtesselator *) (PointerHolder) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluTessVertex__J_3D_3Z (
+		JNIEnv *env, jobject obj,
+		jlong tobj,
+		jdoubleArray coords,
+		jbooleanArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jboolean *ptr2 = NULL;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (*env)->GetBooleanArrayElements(env, vertex_data, &isCopiedArray2);
+		}
+		gluTessVertex (
+			(GLUtesselator *) (PointerHolder) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleaseBooleanArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluTessVertex__J_3D_3J (
+		JNIEnv *env, jobject obj,
+		jlong tobj,
+		jdoubleArray coords,
+		jlongArray vertex_data)
+	{
+		jboolean isCopiedArray1 = JNI_FALSE;
+		jdouble *ptr1 = NULL;
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jlong *ptr2 = NULL;
+
+		if(coords!=NULL)
+		{
+			ptr1 = (*env)->GetDoubleArrayElements(env, coords, &isCopiedArray1);
+		}
+		if(vertex_data!=NULL)
+		{
+			ptr2 = (*env)->GetLongArrayElements(env, vertex_data, &isCopiedArray2);
+		}
+		gluTessVertex (
+			(GLUtesselator *) (PointerHolder) tobj,
+			(GLdouble *) ptr1,
+			(void *) ptr2
+		);
+
+		if(coords!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  coords, ptr1, (isCopiedArray1 == JNI_TRUE)?0:JNI_ABORT);
+		}
+		if(vertex_data!=NULL)
+		{
+			(*env)->ReleaseLongArrayElements(env,  vertex_data, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessEndContour ( GLUtesselator * tobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluTessEndContour (
+		JNIEnv *env, jobject obj,
+		jlong tobj)
+	{
+
+		gluTessEndContour (
+			(GLUtesselator *) (PointerHolder) tobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessEndPolygon ( GLUtesselator * tobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluTessEndPolygon (
+		JNIEnv *env, jobject obj,
+		jlong tobj)
+	{
+
+		gluTessEndPolygon (
+			(GLUtesselator *) (PointerHolder) tobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessProperty ( GLUtesselator * tobj , GLenum which , GLdouble value ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluTessProperty (
+		JNIEnv *env, jobject obj,
+		jlong tobj,
+		jint which,
+		jdouble value)
+	{
+
+		gluTessProperty (
+			(GLUtesselator *) (PointerHolder) tobj,
+			(GLenum) which,
+			(GLdouble) value
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluTessNormal ( GLUtesselator * tobj , GLdouble x , GLdouble y , GLdouble z ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluTessNormal (
+		JNIEnv *env, jobject obj,
+		jlong tobj,
+		jdouble x,
+		jdouble y,
+		jdouble z)
+	{
+
+		gluTessNormal (
+			(GLUtesselator *) (PointerHolder) tobj,
+			(GLdouble) x,
+			(GLdouble) y,
+			(GLdouble) z
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluGetTessProperty ( GLUtesselator * tobj , GLenum which , GLdouble * value ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluGetTessProperty (
+		JNIEnv *env, jobject obj,
+		jlong tobj,
+		jint which,
+		jdoubleArray value)
+	{
+		jboolean isCopiedArray2 = JNI_FALSE;
+		jdouble *ptr2 = NULL;
+
+		if(value!=NULL)
+		{
+			ptr2 = (*env)->GetDoubleArrayElements(env, value, &isCopiedArray2);
+		}
+		gluGetTessProperty (
+			(GLUtesselator *) (PointerHolder) tobj,
+			(GLenum) which,
+			(GLdouble *) ptr2
+		);
+
+		if(value!=NULL)
+		{
+			(*env)->ReleaseDoubleArrayElements(env,  value, ptr2, (isCopiedArray2 == JNI_TRUE)?0:JNI_ABORT);
+		}
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluBeginPolygon ( GLUtesselator * tobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluBeginPolygon (
+		JNIEnv *env, jobject obj,
+		jlong tobj)
+	{
+
+		gluBeginPolygon (
+			(GLUtesselator *) (PointerHolder) tobj
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluNextContour ( GLUtesselator * tobj , GLenum type ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluNextContour (
+		JNIEnv *env, jobject obj,
+		jlong tobj,
+		jint type)
+	{
+
+		gluNextContour (
+			(GLUtesselator *) (PointerHolder) tobj,
+			(GLenum) type
+		);
+
+	}
+
+/**
+ * Original Function-Prototype :
+ * <pre> 
+   extern void gluEndPolygon ( GLUtesselator * tobj ) ;
+ * </pre> 
+ */
+	JNIEXPORT void JNICALL
+	Java_gl4java_GLUFuncJauJNInf_gluEndPolygon (
+		JNIEnv *env, jobject obj,
+		jlong tobj)
+	{
+
+		gluEndPolygon (
+			(GLUtesselator *) (PointerHolder) tobj
+		);
+
+	}
+
+/* C2J Parser Version 1.5 Beta:  Java program parsed successfully. */ 
diff --git a/CNativeCode/OpenGLU_JauJNItst_funcs.c b/CNativeCode/OpenGLU_JauJNItst_funcs.c
index 1fc3b2c..4c6fa7e 100644
--- a/CNativeCode/OpenGLU_JauJNItst_funcs.c
+++ b/CNativeCode/OpenGLU_JauJNItst_funcs.c
@@ -62,7 +62,7 @@ Java_gl4java_GLUFuncJauJNI_gluGetString ( JNIEnv *env, jobject obj,
 }
 
 static const char * _glu_lib_vendor_="Jausoft - Sven Goethel Software Development";
-static const char * _glu_lib_version_="2.4.1.0";
+static const char * _glu_lib_version_="2.5.2.0";
 
 JNIEXPORT jstring JNICALL
 Java_gl4java_GLUFuncJauJNI_getNativeVendor ( JNIEnv *env, jobject obj )
diff --git a/CNativeCode/OpenGL_Win32.c b/CNativeCode/OpenGL_Win32.c
index 8f77752..df4ad2d 100755
--- a/CNativeCode/OpenGL_Win32.c
+++ b/CNativeCode/OpenGL_Win32.c
@@ -75,26 +75,26 @@ Java_gl4java_GLContext_openOpenGLNative( JNIEnv *env, jobject obj,
     jfieldID fpixmapHandle=0;
     jfieldID foffScreenRenderer=0;
     jfieldID faccumSize=0;
-    jfieldID fwindowHandle=0, fpData=0, fdoubleBuffer=0, fstereoView=0, fstencilBits=0;
+    jfieldID fwindowHandle=0, fpData=0;
     jfieldID fverbose=0;
     jfieldID fglContext=0;
     jfieldID fshareWith=0;
     jfieldID fcreatewinw = 0, fcreatewinh = 0;
+    jfieldID fglCaps=0;
 
     /* these variables will be mapped in the java-object ! */
     jboolean joffScreenRenderer=JNI_FALSE;
-	jboolean jdoubleBuffer=JNI_TRUE;
-	jboolean jstereoView=JNI_FALSE;
-	jint jstencilBits=0;
-    jint jaccumSize=0;
     HDC thisWin=0;
     HGLRC gc=0;
+    PIXELFORMATDESCRIPTOR pfd;
     HDC pData=0;
 	HGLRC shareWith=NULL;
     jint jcreatewinw = 0, jcreatewinh = 0;
     HBITMAP pix=0;
-
-    PIXELFORMATDESCRIPTOR pfd;
+    GLCapabilities glCaps;
+    jobject  jglCaps=0;
+    jthrowable exc;
+    jclass _GLCapabilities= 0;
 
     (void) canvas;
 
@@ -103,7 +103,7 @@ Java_gl4java_GLContext_openOpenGLNative( JNIEnv *env, jobject obj,
     {
         fprintf(stderr,"oo0.0 cls==0\n");
 		  fflush(stderr);
-		  ret=JNI_FALSE;
+		  return JNI_FALSE;
     }
 
     if(ret==JNI_TRUE)
@@ -113,7 +113,7 @@ Java_gl4java_GLContext_openOpenGLNative( JNIEnv *env, jobject obj,
 	    {
                 fprintf(stderr,"oo0.2 fverbose==0\n");
                 fflush(stderr);
-					 ret=JNI_FALSE;
+		return JNI_FALSE;
 	    } else {
 		verbose = (*env)->GetStaticBooleanField(env, cls, fverbose);
 	    }
@@ -133,8 +133,11 @@ Java_gl4java_GLContext_openOpenGLNative( JNIEnv *env, jobject obj,
 
     if(ret==JNI_TRUE) {
 	    fpData = (*env)->GetFieldID(env, cls, "pData", "J");
-	    if (fpData == 0) ret= JNI_FALSE;
-	    else pData = (HDC)
+		if (fpData == 0) {
+			fprintf(stderr, "pData not accessible !\n");
+			fflush(stderr);
+			ret= JNI_FALSE;
+		} else pData = (HDC)
 	      ( (PointerHolder)(*env)->GetLongField(env, obj, fpData));
     }
     if(JNI_TRUE==verbose)
@@ -144,43 +147,80 @@ Java_gl4java_GLContext_openOpenGLNative( JNIEnv *env, jobject obj,
 
     if(ret==JNI_TRUE) {
 	    fwindowHandle = (*env)->GetFieldID(env, cls, "windowHandle", "J");
-	    if (fwindowHandle == 0) ret= JNI_FALSE;
+	    if (fwindowHandle == 0) {
+			fprintf(stderr, "windowHandle not accessible !\n");
+			fflush(stderr);
+			ret= JNI_FALSE;
+		}
     }
 
     if(ret==JNI_TRUE) {
 	    fglContext=(*env)->GetFieldID(env, cls, "glContext", "J");
-	    if (fglContext == 0) ret= JNI_FALSE;
+	    if (fglContext == 0)
+	    {
+			fprintf(stderr, "fglContext not accessible !\n");
+			fflush(stderr);
+			ret= JNI_FALSE;
+		}
     }
 
     if(ret==JNI_TRUE) {
 	    foffScreenRenderer = 
 	    		(*env)->GetFieldID(env, cls, "offScreenRenderer", "Z");
-	    if (foffScreenRenderer == 0) ret= JNI_FALSE;
+	    if (foffScreenRenderer == 0)
+	    {
+			fprintf(stderr, "foffScreenRenderer not accessible !\n");
+			fflush(stderr);
+			ret= JNI_FALSE;
+		}
 	    else joffScreenRenderer =(*env)->GetBooleanField(env, obj, foffScreenRenderer);
     }
 
     if(ret==JNI_TRUE) {
-	    fdoubleBuffer = (*env)->GetFieldID(env, cls, "doubleBuffer", "Z");
-	    if (fdoubleBuffer == 0) ret= JNI_FALSE;
-	    else jdoubleBuffer =(*env)->GetBooleanField(env, obj, fdoubleBuffer);
-    }
-
-    if(ret==JNI_TRUE) {
-	    fstereoView = (*env)->GetFieldID(env, cls, "stereoView", "Z");
-	    if (fstereoView == 0) ret= JNI_FALSE;
-	    else jstereoView =(*env)->GetBooleanField(env, obj, fstereoView);
+            fglCaps = (*env)->GetFieldID(env, cls, "glCaps", "Lgl4java/GLCapabilities;");
+            if (fglCaps == 0)
+			{
+				fprintf(stderr, "fglCaps not accessible !\n");
+				fflush(stderr);
+				ret= JNI_FALSE;
+			}
+            else jglCaps =(*env)->GetObjectField(env, obj, fglCaps);
     }
 
-    if(ret==JNI_TRUE) {
-	    fstencilBits = (*env)->GetFieldID(env, cls, "stencilBits", "I");
-	    if (fstencilBits == 0) ret= JNI_FALSE;
-	    else jstencilBits =(*env)->GetIntField(env, obj, fstencilBits);
+    if( jglCaps==0 )
+    {
+      fprintf(stderr,"\nGL4Java openOpenGL ERROR: ZERO capsObj was fetched by GetObjectField !\n");
+      fflush(stderr);
+      return JNI_FALSE;
+    }
+
+    _GLCapabilities= (*env)->FindClass(env, "Lgl4java/GLCapabilities;");
+    exc = (*env)->ExceptionOccurred(env);
+    if(exc) {
+          if(JNI_TRUE==verbose)
+	  {
+             fprintf(stderr, "GL4Java: openOpen FindClass gl4java/GLCapabilities failed, cannot check glCaps object\n");
+	     (*env)->ExceptionDescribe(env);
+             fflush(stderr);
+	  }
+	  (*env)->ExceptionClear(env);
+	  _GLCapabilities=0;
+    }
+    exc=0;
+
+    if( _GLCapabilities!=0 &&
+        (*env)->IsInstanceOf(env, jglCaps, _GLCapabilities)==JNI_FALSE )
+    {
+      fprintf(stderr,"\nGL4Java openOpenGL ERROR: glCaps is not instanceof gl4java/GLCapabilities !\n");
+      fflush(stderr);
+      return JNI_FALSE;
     }
 
-    if(ret==JNI_TRUE) {
-	    faccumSize = (*env)->GetFieldID(env, cls, "accumSize", "I");
-	    if (faccumSize == 0) ret= JNI_FALSE;
-	    else jaccumSize =(*env)->GetIntField(env, obj, faccumSize);
+    if( JNI_TRUE != javaGLCapabilities2NativeGLCapabilities ( env, jglCaps, &glCaps ) )
+    {
+      fprintf(stderr,"\nGL4Java ERROR: glCaps Object is not valid !\n");
+      fflush(stderr);
+      return JNI_FALSE;
     }
 
     if(ret==JNI_TRUE) {
@@ -209,7 +249,7 @@ Java_gl4java_GLContext_openOpenGLNative( JNIEnv *env, jobject obj,
 
     if(joffScreenRenderer==JNI_TRUE)
     {
-	    jdoubleBuffer = JNI_FALSE;
+	glCaps.buffer=BUFFER_SINGLE;
     }
 
     if(JNI_TRUE==verbose && joffScreenRenderer==JNI_TRUE)
@@ -236,8 +276,10 @@ Java_gl4java_GLContext_openOpenGLNative( JNIEnv *env, jobject obj,
 	    thisWin = (HDC)pData;
 
     /* get the graphics context for this widget */
-    if( (gc = get_GC( &thisWin, jdoubleBuffer, jstereoView, jstencilBits, shareWith, 
-				      joffScreenRenderer, jcreatewinw, jcreatewinh, &pix, verbose)) == 0 )
+    if( (gc = get_GC( &thisWin, &glCaps, shareWith, 
+	              joffScreenRenderer, jcreatewinw, jcreatewinh, 
+		      &pix, verbose)) == 0 
+      )
     {
 	    printf( "getGC error" );
 	    return JNI_FALSE;
@@ -246,24 +288,19 @@ Java_gl4java_GLContext_openOpenGLNative( JNIEnv *env, jobject obj,
 	/* fetch the states of doubleBuffer and stereo */
     (void) PixelFormatDescriptorFromDc( thisWin, &pfd);
 
-	jdoubleBuffer = (pfd.dwFlags & PFD_DOUBLEBUFFER)?JNI_TRUE:JNI_FALSE;
-    if(ret==JNI_TRUE && fdoubleBuffer!=0) {
-	    (*env)->SetBooleanField(env, obj, fdoubleBuffer, 
-	                            jdoubleBuffer);
+    if(JNI_TRUE==verbose) 
+    { 
+	fprintf(stdout,"\nGL4Java: writing capabilities to GLContext's java object\n");
+        fflush(stdout);
     }
 
-	jstencilBits = (jint)(pfd.cStencilBits);
-	if(ret==JNI_TRUE && fstencilBits!=0) {
-	    (*env)->SetIntField(env, obj, 
-				fstencilBits, (jint)jstencilBits);
-	}
-
-	jaccumSize=(jint)(pfd.cAccumRedBits+pfd.cAccumGreenBits+pfd.cAccumBlueBits+pfd.cAccumAlphaBits);
-	if(ret==JNI_TRUE && faccumSize!=0) {
-	    (*env)->SetIntField(env, obj, 
-				faccumSize, (jint)jaccumSize);
-	}
+    if(jglCaps!=0)
+       (void) nativeGLCapabilities2JavaGLCapabilities (env, jglCaps, &glCaps);
 
+    if(ret==JNI_TRUE && fglCaps && jglCaps) {
+                    (*env)->SetObjectField(env, obj, fglCaps, jglCaps);
+    }
+  
     if(ret==JNI_TRUE && fwindowHandle!=0) {
 	    (*env)->SetLongField(env, obj, fwindowHandle, 
 	                        (jlong)((PointerHolder)thisWin));
diff --git a/CNativeCode/OpenGL_Win32_common.c b/CNativeCode/OpenGL_Win32_common.c
index dcf5822..8368677 100755
--- a/CNativeCode/OpenGL_Win32_common.c
+++ b/CNativeCode/OpenGL_Win32_common.c
@@ -17,8 +17,8 @@
 #include "OpenGL_Win32_common.h"
 
 
-HGLRC LIBAPIENTRY get_GC( HDC * hDC, jboolean doubleBuffer, 
-		jboolean stereo, jint stencilBits, HGLRC shareWith, 
+HGLRC LIBAPIENTRY get_GC( HDC * hDC, GLCapabilities *glCaps,
+		HGLRC shareWith, 
 		jboolean offScreenRenderer,
 		int width, int height, HBITMAP *pix,
 		jboolean verbose)
@@ -45,7 +45,7 @@ HGLRC LIBAPIENTRY get_GC( HDC * hDC, jboolean doubleBuffer,
 		/* setupPalette(hDC); USE MY PROC */
 	}
 
-	SetDCPixelFormat(*hDC, doubleBuffer, stereo, stencilBits, offScreenRenderer, verbose);
+	SetDCPixelFormat(*hDC, glCaps, offScreenRenderer, verbose);
 
 	// Create palette if needed
 	hPalette = GetOpenGLPalette(*hDC);
@@ -89,64 +89,116 @@ HGLRC LIBAPIENTRY get_GC( HDC * hDC, jboolean doubleBuffer,
     return tempRC;
 }
 
-// Select the pixel format for a given device context
-void LIBAPIENTRY SetDCPixelFormat(HDC hDC, jboolean doubleBuffer, 
-		jboolean stereo, jint stencilBits, jboolean offScreenRenderer,
-		jboolean verbose)
+void LIBAPIENTRY setPixelFormatByGLCapabilities( 
+					PIXELFORMATDESCRIPTOR *pfd,
+				        GLCapabilities *glCaps,
+					jboolean offScreenRenderer,
+					HDC hdc)
 {
-    int nPixelFormat=0;
-	const char * text=0;
 
-    PIXELFORMATDESCRIPTOR pfd = {
-			sizeof(PIXELFORMATDESCRIPTOR),  // Size of this structure
-			1,                              // Version of this structure
-			0,								// will be defined later !!!!
-			PFD_TYPE_RGBA,                  // RGBA Color mode
-			24,                             // Want 24bit color
-			0,0,0,0,0,0,                    // Not used to select mode
-			0,0,                            // Not used to select mode
-			0,0,0,0,0,                      // Not used to select mode
-			32,                             // Size of depth buffer
-			0,                              // Not used to select mode
-			0,                              // Not used to select mode
-			PFD_MAIN_PLANE,                 // Draw in main plane
-			0,                              // Not used to select mode
-			0,0,0 };                        // Not used to select mode
-
-
-	// customize dw_flags
-	DWORD dw_flags = PFD_SUPPORT_OPENGL | PFD_GENERIC_ACCELERATED;	// Support accelerated OpenGL calls in window
+	int colorBits = glCaps->redBits + glCaps->greenBits + glCaps->blueBits;
+
+	pfd->nSize=sizeof(PIXELFORMATDESCRIPTOR); 
+	pfd->nVersion=1; 
+	pfd->dwFlags=PFD_SUPPORT_OPENGL | PFD_GENERIC_ACCELERATED; /* refined later */
+	pfd->iPixelType=0; 
+	pfd->cColorBits=0; 
+	pfd->cRedBits=0; 
+	pfd->cRedShift=0; 
+	pfd->cGreenBits=0; 
+	pfd->cGreenShift=0; 
+	pfd->cBlueBits=0; 
+	pfd->cBlueShift=0; 
+	pfd->cAlphaBits=0; 
+	pfd->cAlphaShift=0; 
+	pfd->cAccumBits=0; 
+	pfd->cAccumRedBits=0; 
+	pfd->cAccumGreenBits=0; 
+	pfd->cAccumBlueBits=0; 
+	pfd->cAccumAlphaBits=0; 
+	pfd->cDepthBits=32; 
+	pfd->cStencilBits=0; 
+	pfd->cAuxBuffers=0; 
+	pfd->iLayerType=PFD_MAIN_PLANE; 
+	pfd->bReserved=0; 
+	pfd->dwLayerMask=0; 
+	pfd->dwVisibleMask=0; 
+	pfd->dwDamageMask=0; 
+ 
+    if(COLOR_RGBA == glCaps->color)
+		pfd->iPixelType=PFD_TYPE_RGBA; 
+	else
+		pfd->iPixelType=PFD_TYPE_COLORINDEX; 
 
-	if(offScreenRenderer)
-		dw_flags |= PFD_DRAW_TO_BITMAP;           // Draw to Bitmap
+    if(offScreenRenderer)
+		pfd->dwFlags |= PFD_DRAW_TO_BITMAP;           // Draw to Bitmap
 	else
-		dw_flags |= PFD_DRAW_TO_WINDOW;           // Draw to Window (not to bitmap)
+		pfd->dwFlags |= PFD_DRAW_TO_WINDOW;           // Draw to Window (not to bitmap)
+
+
+    if(BUFFER_DOUBLE==glCaps->buffer)
+		pfd->dwFlags |= PFD_DOUBLEBUFFER ;  // Double buffered is optional
 
+    if(STEREO_ON==glCaps->stereo)
+		pfd->dwFlags |= PFD_STEREO ;        // Stereo is optional
 
-	if(doubleBuffer==JNI_TRUE)
-		dw_flags |= PFD_DOUBLEBUFFER ;  // Double buffered is optional
+    if(hdc!=NULL && GetDeviceCaps(hdc, BITSPIXEL)<colorBits)
+    	    pfd->cColorBits = GetDeviceCaps(hdc, BITSPIXEL);
+        else
+    pfd->cColorBits = (BYTE)colorBits;
 
-	if(stereo==JNI_TRUE)
-		dw_flags |= PFD_STEREO ;        // Stereo is optional
+	pfd->cStencilBits = (BYTE) glCaps->stencilBits;
+}
 
-	pfd.dwFlags = dw_flags;
 
-    pfd.cColorBits = GetDeviceCaps(hDC, BITSPIXEL);
+void LIBAPIENTRY SetDCPixelFormat(HDC hDC, GLCapabilities *glCaps,
+		                  jboolean offScreenRenderer, jboolean verbose)
+{
+    int nPixelFormat=-1;
+	const char * text=0;
 
-	if(stencilBits>0)
-		pfd.cStencilBits = (BYTE) stencilBits;
+    PIXELFORMATDESCRIPTOR pfd ;
 
-	if(verbose==JNI_TRUE)
-	{
+    if(verbose==JNI_TRUE)
+    {
+	fprintf(stdout, "GL4Java SetDCPixelFormat: input capabilities:\n");
+	printGLCapabilities ( glCaps );
+    }
+
+    if(glCaps->nativeVisualID>=0)
+    {
+            if ( 0 < DescribePixelFormat( hDC, (int)(glCaps->nativeVisualID), 
+	                                  sizeof(pfd), &pfd ) )
+	    {
+	        nPixelFormat=(int)(glCaps->nativeVisualID);
+	        if(verbose==JNI_TRUE)
+		{
+		  fprintf(stderr,"\n\nUSER found stored PIXELFORMAT number: %ld\n",
+		  	nPixelFormat);
+		  fflush(stderr);
+		}	
+	    } else {
+		  fprintf(stderr,"\n\nUSER no stored PIXELFORMAT number found !!\n");
+           nPixelFormat = -1;
+		  fflush(stderr);
+	    }
+	}
+
+    if(nPixelFormat<0)
+        setPixelFormatByGLCapabilities( &pfd, glCaps, offScreenRenderer, hDC);
+
+    if(verbose==JNI_TRUE)
+    {
 		fprintf(stderr,"\n\nUSER CHOOSED PIXELFORMAT (TRYING):\n");
-		text=GetTextualPixelFormatByPFD(&pfd, 0);			
+		text=GetTextualPixelFormatByPFD(&pfd, nPixelFormat);			
 		fprintf(stderr,text);
-	}
+		fflush(stderr);
+    }
 
     // Choose a pixel format that best matches that described in pfd
     if( hDC == 0 )
 	    printf( "SetDCPixelFormat: Error, no HDC-Contex is given\n");
-    else
+    else if(nPixelFormat<0)
 	    nPixelFormat = ChoosePixelFormat(hDC, &pfd);
 
     if( nPixelFormat == 0 )
@@ -155,6 +207,16 @@ void LIBAPIENTRY SetDCPixelFormat(HDC hDC, jboolean doubleBuffer,
     // Set the pixel format for the device context
     if( SetPixelFormat(hDC, nPixelFormat, &pfd) == FALSE)
 	    printf( "setpixel failed\n" );
+    else {
+            (void) setGLCapabilities ( hDC, nPixelFormat, glCaps );
+	    if(verbose==JNI_TRUE)
+	    {
+	        fprintf(stdout, "GL4Java SetDCPixelFormat: used capabilities:\n");
+	        printGLCapabilities ( glCaps );
+	    }
+    }
+	fflush(stdout);
+	fflush(stderr);
 }
 
 
@@ -267,6 +329,7 @@ jboolean LIBAPIENTRY testWin32Java()
 }
 
 
+
 static void
 PrintMessage( const char *Format, ... )
 {
@@ -335,8 +398,8 @@ GetTextualPixelFormatByPFD(PIXELFORMATDESCRIPTOR *ppfd, int format)
     strcat(buffer, line); sprintf(line,"  cGreenShift - %d\n", ppfd->cGreenShift);
     strcat(buffer, line); sprintf(line,"  cBlueBits - %d\n", ppfd->cBlueBits);
     strcat(buffer, line); sprintf(line,"  cBlueShift - %d\n", ppfd->cBlueShift);
-    strcat(buffer, line); sprintf(line,"  cAlphaBits - %d\n", ppfd->cAlphaBits);
-    strcat(buffer, line); sprintf(line,"  cAlphaShift - 0x%x\n", ppfd->cAlphaShift);
+    strcat(buffer, line); sprintf(line,"  cAlphaBits - %d (N.A.)\n", ppfd->cAlphaBits);
+    strcat(buffer, line); sprintf(line,"  cAlphaShift - 0x%x (N.A.)\n", ppfd->cAlphaShift);
     strcat(buffer, line); sprintf(line,"  cAccumBits - %d\n", ppfd->cAccumBits);
     strcat(buffer, line); sprintf(line,"  cAccumRedBits - %d\n", ppfd->cAccumRedBits);
     strcat(buffer, line); sprintf(line,"  cAccumGreenBits - %d\n", ppfd->cAccumGreenBits);
@@ -658,3 +721,44 @@ HPALETTE LIBAPIENTRY setupPalette(HDC hDC)
 }
 
 
+jboolean LIBAPIENTRY setGLCapabilities ( HDC hdc, 
+					 int nPixelFormat,
+ 					 GLCapabilities *glCaps )
+{
+    PIXELFORMATDESCRIPTOR pfd;
+
+    (void) PixelFormatDescriptorFromDc( hdc, &pfd);
+
+    if (pfd.dwFlags & PFD_DOUBLEBUFFER)
+	glCaps->buffer=BUFFER_DOUBLE;
+    else
+	glCaps->buffer=BUFFER_SINGLE;
+
+    if (pfd.dwFlags & PFD_STEREO)
+	glCaps->stereo=STEREO_ON;
+    else
+	glCaps->stereo=STEREO_OFF;
+
+    if (pfd.iPixelType == PFD_TYPE_RGBA)
+	glCaps->color=COLOR_RGBA;
+
+    if (pfd.iPixelType == PFD_TYPE_COLORINDEX)
+	glCaps->color=COLOR_INDEX;
+
+    glCaps->depthBits = pfd.cDepthBits;
+    glCaps->stencilBits = pfd.cStencilBits;
+
+    glCaps->redBits = pfd.cRedBits;
+    glCaps->greenBits= pfd.cGreenBits;
+    glCaps->blueBits=  pfd.cBlueBits;
+    /* glCaps->alphaBits= pfd.cAlphaBits; N.A. */
+    glCaps->accumRedBits = pfd.cAccumRedBits;
+    glCaps->accumGreenBits= pfd.cAccumGreenBits;
+    glCaps->accumBlueBits= pfd.cAccumBlueBits;
+    glCaps->accumAlphaBits= pfd.cAccumAlphaBits;
+
+    glCaps->nativeVisualID=nPixelFormat;
+
+    return JNI_TRUE;
+}
+
diff --git a/CNativeCode/OpenGL_Win32_common.h b/CNativeCode/OpenGL_Win32_common.h
index ed7287f..9e99aed 100755
--- a/CNativeCode/OpenGL_Win32_common.h
+++ b/CNativeCode/OpenGL_Win32_common.h
@@ -6,16 +6,20 @@
 #include <wingdi.h>
 
 
+LIBAPI void LIBAPIENTRY setPixelFormatByGLCapabilities( 
+					PIXELFORMATDESCRIPTOR *pfd,
+				        GLCapabilities *glCaps,
+					jboolean offScreenRenderer,
+					HDC hdc);
+
 // Set Pixel Format function - forward declaration
-LIBAPI void LIBAPIENTRY SetDCPixelFormat(HDC hDC, jboolean doubleBuffer, 
-		jboolean stereo, jint stencilBits, jboolean offScreenRenderer, 
-		jboolean verbose);
+LIBAPI void LIBAPIENTRY SetDCPixelFormat(HDC hDC, GLCapabilities *glCaps,
+		jboolean offScreenRenderer, jboolean verbose);
 
 LIBAPI HPALETTE LIBAPIENTRY GetOpenGLPalette(HDC hDC);
 
-LIBAPI HGLRC LIBAPIENTRY get_GC( HDC *hDC, jboolean doubleBuffer, 
-		jboolean stereo, jint stencilBits, HGLRC shareWith, 
-		jboolean offScreenRenderer,
+LIBAPI HGLRC LIBAPIENTRY get_GC( HDC *hDC, GLCapabilities *glCaps,
+		HGLRC shareWith, jboolean offScreenRenderer,
 		int width, int height, HBITMAP *pix,
 		jboolean verbose);
 
@@ -41,4 +45,6 @@ LIBAPI void LIBAPIENTRY resizeDIB(HDC hDC, HBITMAP *hOldBitmap,
 
 LIBAPI HPALETTE LIBAPIENTRY setupPalette(HDC hDC);
 
+LIBAPI jboolean LIBAPIENTRY setGLCapabilities ( HDC hdc, int nPixelFormat,
+					        GLCapabilities *glCaps );
 #endif
diff --git a/CNativeCode/OpenGL_Win32_jawt.c b/CNativeCode/OpenGL_Win32_jawt.c
index 4eeeb8e..d025603 100755
--- a/CNativeCode/OpenGL_Win32_jawt.c
+++ b/CNativeCode/OpenGL_Win32_jawt.c
@@ -1,676 +1,726 @@
-/*
- * Original Author: Leo Chan -- 1995
- *
- * Adam King 1997
- *		Ported to Win32 from X
- *
- * This file takes care of the C implementation of finding the correct
- * Win32 window, assigning an OpenGL graphics context to it, storing that
- * graphics context in the java class data structure.
- *
- * also contains the use() and swap() functions for double buffering
- *
- * September 12, 1997	- Adam King
- *		- Added support for rendering directly into a Canvas ( BIG rewrite )
- */
-
-/**
- * Pointer Semantics of GLContext:
- * ==============================
-
-   "displayHandle"	:= not used
-   	
-   "pData" 		:= (JAWTDataHolder *)
-   	"windowHandle" 	:= "pData"
-
-        This holds the current state of the JAWT context !
-
-   	This is used as the "not initialized" flag also !
-	It is reset to zero while Destroy Method
-
-   "pData"->dsi_win     := (HDC)
-   	if("offScreenRenderer" == TRUE)
-		"pData"->dsi_win contains the window handle,
-		of the last lock !
-		"pData"->dsi_win_created=0 !
-
-   "pixmapHandle"	:= (HBITMAP)
-   	if("offScreenRenderer" == TRUE)
-		"pixmapHandle" contains the new BITMAP (by CreateDIBSection)!
-		"windowHandle" contains the new created OffScreenWindow 
-			       (by CreateCompatibleDC)!
-        else
-		"pixmapHandle" is unused !
-
-   "sharedGLContextNative" := (HGLRC)
-   	This is the optional shared GLContext !
-
-   "glContext" := (HGLRC)
-   	This is THE used GLContext !
- */
-
-#include "OpenGL_Win32_common.h"
-
-#include "jawt_misc.h"
-
-/*
- * Macros ..
- */
-
-#define GET_W32_JAWT_DSI(a) \
-	( (JAWT_Win32DrawingSurfaceInfo *) \
-	  ( ( (JAWTDataHolder *)((PointerHolder)(a)) ) ->dsi_os ) \
-        )
-
-#define GET_USED_WINDOW(a) \
-	( (HDC) \
-	  ( ( (JAWTDataHolder *)((PointerHolder)(a)) ) ->dsi_win ) \
-        )
-
-static jboolean verbose = JNI_FALSE;
-
-JNIEXPORT jboolean JNICALL
-Java_gl4java_GLContext_useJAWT( JNIEnv *env, jobject obj )
-{
-    (void)env;
-    (void)obj;
-    return JNI_TRUE;
-}
-
-JNIEXPORT jboolean JNICALL
-Java_gl4java_GLContext_hasJAWTSurfaceChanged( JNIEnv *env, jobject obj,
-					      jlong thisWin )
-{
-    JAWTDataHolder * pData = (JAWTDataHolder *) ( (PointerHolder) thisWin );
-    (void)env;
-    (void)obj;
-	
-	if(pData!=0)
-		return (pData->lock & JAWT_LOCK_SURFACE_CHANGED) != 0 ;
-
-	return JNI_FALSE;
-}
-
-JNIEXPORT jboolean JNICALL
-Java_gl4java_GLContext_openOpenGLNative( JNIEnv *env, jobject obj,
-					jobject canvas)
-{
-    jboolean ret = JNI_TRUE;
-
-    jclass cls = 0;
-    jfieldID fpixmapHandle=0;
-    jfieldID foffScreenRenderer=0;
-    jfieldID faccumSize=0;
-    jfieldID fwindowHandle=0, fpData=0, fdoubleBuffer=0, fstereoView=0, fstencilBits=0;
-    jfieldID fverbose=0;
-    jfieldID fglContext=0;
-    jfieldID fshareWith=0;
-    jfieldID fcreatewinw = 0, fcreatewinh = 0;
-
-    /* these variables will be mapped in the java-object ! */
-    jboolean joffScreenRenderer=JNI_FALSE;
-	jboolean jdoubleBuffer=JNI_TRUE;
-	jboolean jstereoView=JNI_FALSE;
-	jint jstencilBits=0;
-    jint jaccumSize=0;
-    HDC theWindow=0;
-    HGLRC gc=0;
-    JAWTDataHolder * pData=0;
-	HGLRC shareWith=NULL;
-    jint jcreatewinw = 0, jcreatewinh = 0;
-    HBITMAP pix=0;
-
-    PIXELFORMATDESCRIPTOR pfd;
-
-    cls = (*env)->GetObjectClass(env, obj);
-    if(cls==0)
-    {
-        fprintf(stderr,"oo0.0 cls==0\n");
-		  fflush(stderr);
-		  ret=JNI_FALSE;
-    }
-
-    if(ret==JNI_TRUE)
-    {
-	    fverbose =(*env)->GetStaticFieldID(env, cls, "gljNativeDebug", "Z");
-	    if (fverbose == 0)
-	    {
-                fprintf(stderr,"oo0.2 fverbose==0\n");
-                fflush(stderr);
-					 ret=JNI_FALSE;
-	    } else {
-		verbose = (*env)->GetStaticBooleanField(env, cls, fverbose);
-	    }
-    }
-
-    if(JNI_TRUE==verbose)
-    {
-		fprintf(stderr, "sizes:\n jlong=%d\n HGLRC=%d\n HDC=%d\n",
-	  		sizeof(jlong), sizeof(HGLRC), sizeof(HDC) );
-		fflush(stderr);
-    }
-
-    /* FIRST OF ALL CHECK IF A NATIVE POINTER OR WIN-TYPE FITS IN �jlong� */
-    ret = testWin32Java();
-
-    ret = testJavaGLTypes(verbose);
-
-    if(ret==JNI_TRUE) {
-	    fpData = (*env)->GetFieldID(env, cls, "pData", "J");
-	    if (fpData == 0) ret= JNI_FALSE;
-	    else pData = (JAWTDataHolder *)
-	      ( (PointerHolder)(*env)->GetLongField(env, obj, fpData));
-    }
-    if(JNI_TRUE==verbose)
-    {
-    	fprintf(stderr, "received pData : %d\n", (int)pData);
-    }
-
-    if(ret==JNI_TRUE) {
-	    fwindowHandle = (*env)->GetFieldID(env, cls, "windowHandle", "J");
-	    if (fwindowHandle == 0) ret= JNI_FALSE;
-    }
-
-    if(ret==JNI_TRUE) {
-	    fglContext=(*env)->GetFieldID(env, cls, "glContext", "J");
-	    if (fglContext == 0) ret= JNI_FALSE;
-    }
-
-    if(ret==JNI_TRUE) {
-	    foffScreenRenderer = 
-	    		(*env)->GetFieldID(env, cls, "offScreenRenderer", "Z");
-	    if (foffScreenRenderer == 0) ret= JNI_FALSE;
-	    else joffScreenRenderer =(*env)->GetBooleanField(env, obj, foffScreenRenderer);
-    }
-
-    if(ret==JNI_TRUE) {
-	    fdoubleBuffer = (*env)->GetFieldID(env, cls, "doubleBuffer", "Z");
-	    if (fdoubleBuffer == 0) ret= JNI_FALSE;
-	    else jdoubleBuffer =(*env)->GetBooleanField(env, obj, fdoubleBuffer);
-    }
-
-    if(ret==JNI_TRUE) {
-	    fstereoView = (*env)->GetFieldID(env, cls, "stereoView", "Z");
-	    if (fstereoView == 0) ret= JNI_FALSE;
-	    else jstereoView =(*env)->GetBooleanField(env, obj, fstereoView);
-    }
-
-    if(ret==JNI_TRUE) {
-	    fstencilBits = (*env)->GetFieldID(env, cls, "stencilBits", "I");
-	    if (fstencilBits == 0) ret= JNI_FALSE;
-	    else jstencilBits =(*env)->GetIntField(env, obj, fstencilBits);
-    }
-
-    if(ret==JNI_TRUE) {
-	    faccumSize = (*env)->GetFieldID(env, cls, "accumSize", "I");
-	    if (faccumSize == 0) ret= JNI_FALSE;
-	    else jaccumSize =(*env)->GetIntField(env, obj, faccumSize);
-    }
-
-    if(ret==JNI_TRUE) {
-	    fcreatewinw = (*env)->GetFieldID(env, cls, "createwinw", "I");
-	    if (fcreatewinw == 0) ret= JNI_FALSE;
-	    else jcreatewinw =(*env)->GetIntField(env, obj, fcreatewinw);
-    }
-
-    if(ret==JNI_TRUE) {
-	    fcreatewinh = (*env)->GetFieldID(env, cls, "createwinh", "I");
-	    if (fcreatewinh == 0) ret= JNI_FALSE;
-	    else jcreatewinh =(*env)->GetIntField(env, obj, fcreatewinh);
-    }
-
-    if(ret==JNI_TRUE) {
-	    fshareWith = (*env)->GetFieldID(env, cls, "sharedGLContextNative", "J");
-	    if (fshareWith == 0) ret= JNI_FALSE;
-	    else shareWith = (HGLRC) 
-	      ( (PointerHolder)(*env)->GetLongField(env, obj, fshareWith));
-    }
-
-    if(ret==JNI_TRUE) {
-	    fpixmapHandle = (*env)->GetFieldID(env, cls, "pixmapHandle", "J");
-	    if (fpixmapHandle == 0) ret= JNI_FALSE;
-    }
-
-    if(joffScreenRenderer==JNI_TRUE)
-    {
-	    jdoubleBuffer = JNI_FALSE;
-    }
-
-    if(JNI_TRUE==verbose && joffScreenRenderer==JNI_TRUE)
-    {
-		fprintf(stderr,"\nGL4Java:  (USING OFFSCREEN GLPIXMAP BUFFER,\n\t forced: !doubleBuffer)\n");
-		fflush(stderr);
-    }
-
-    if(joffScreenRenderer==JNI_TRUE)
-    {
-        jawt_create_offscreen(env, &pData, verbose);
-    } 
-    else {
-        if(jawt_create_open(env, canvas, &pData, verbose)==JNI_FALSE ||
-           pData->result==JNI_FALSE
-          )
-        {
-	  fprintf(stderr,"\nGL4Java ERROR: openOpen could not create&open JAWT reference!\n");
-	  fflush(stderr);
-	  jawt_free_close_unlock(env, &pData, JNI_FALSE);
-	  ret=JNI_FALSE;
-	  return ret;
-        }
-
-        if(jawt_lock(env, pData, JNI_TRUE, verbose)==JNI_FALSE ||
-           pData->result==JNI_FALSE
-          )
-        {
-	  fprintf(stderr,"\nGL4Java ERROR: openOpen could not lock JAWT reference!\n");
-	  fflush(stderr);
-	  jawt_free_close_unlock(env, &pData, JNI_FALSE);
-	  ret=JNI_FALSE;
-	  return ret;
-        }
-    }
-
-    if(pData->result==JNI_TRUE)
-    {
-	    if(joffScreenRenderer==JNI_FALSE)
-	    {
-	    	theWindow = GET_W32_JAWT_DSI(pData)->hdc;
-	        jcreatewinw =  pData->dsi->bounds.width;
-	        jcreatewinh =  pData->dsi->bounds.height;
-	    }
-    }
-
-    wglMakeCurrent(NULL, NULL);
-
-    /**
-     * with version jdk1.1.6 and later, we are able to use 
-     * the java-function straight to achieve the native window
-     * handle ....
-     *
-     * this handle is saved to pData for the windows version !
-     */
-    if( theWindow == 0 && !joffScreenRenderer)
-    {
-	    printf( "get_GC: Error, pData->hdc is zero\n");
-	    jawt_free_close_unlock(env, &pData, JNI_FALSE);
-	    return JNI_FALSE;
-    }
-
-    /* get the graphics context for this widget */
-    if( (gc = get_GC( &theWindow, jdoubleBuffer, jstereoView, jstencilBits, 
-                       shareWith, joffScreenRenderer, jcreatewinw, 
-		       jcreatewinh, &pix, verbose)) == 0 )
-    {
-	    printf( "getGC error" );
-	    return JNI_FALSE;
-    }
-
-	/* fetch the states of doubleBuffer and stereo */
-    (void) PixelFormatDescriptorFromDc( theWindow, &pfd);
-
-	jdoubleBuffer = (pfd.dwFlags & PFD_DOUBLEBUFFER)?JNI_TRUE:JNI_FALSE;
-    if(ret==JNI_TRUE && fdoubleBuffer!=0) {
-	    (*env)->SetBooleanField(env, obj, fdoubleBuffer, 
-	                            jdoubleBuffer);
-    }
-
-	jstencilBits = (jint)(pfd.cStencilBits);
-	if(ret==JNI_TRUE && fstencilBits!=0) {
-	    (*env)->SetIntField(env, obj, 
-				fstencilBits, (jint)jstencilBits);
-	}
-
-	jaccumSize=(jint)(pfd.cAccumRedBits+pfd.cAccumGreenBits+pfd.cAccumBlueBits+pfd.cAccumAlphaBits);
-	if(ret==JNI_TRUE && faccumSize!=0) {
-	    (*env)->SetIntField(env, obj, 
-				faccumSize, (jint)jaccumSize);
-	}
-
-    jawt_close_unlock(env, pData, verbose);    
-
-    if(ret==JNI_TRUE && fwindowHandle!=0) {
-	    (*env)->SetLongField(env, obj, fwindowHandle, 
-	                        (jlong)((PointerHolder)pData));
-    }
-    if(ret==JNI_TRUE && fpData!=0) {
-	    (*env)->SetLongField(env, obj, fpData, 
-	                        (jlong)((PointerHolder)pData));
-    }
-
-    if(ret==JNI_TRUE && fpixmapHandle!=0) {
-	    (*env)->SetLongField(env, obj, fpixmapHandle, (jlong)((PointerHolder)pix));
-    	 if(JNI_TRUE==verbose)
-    		fprintf(stderr, "go and set pixmapHandle pix: %d; 0x%X\n",
-         	(int)pix, (int)pix);
-    }
-
-    if(ret==JNI_TRUE && fglContext !=0 ) {
-	    (*env)->SetLongField(env, obj, fglContext, (jlong)((PointerHolder)gc));
-    	 if(JNI_TRUE==verbose)
-    		fprintf(stderr, "go and set gc  : %d, 0x%X\n",
-         	(int)gc, (int)gc);
-    }
-
-	/*
-	gl4java_bind_ext(JNI_TRUE==verbose);
-	*/
-
-    return ret;
-}
-
-JNIEXPORT jboolean JNICALL
-Java_gl4java_GLContext_gljMakeCurrentNative( JNIEnv *env, jobject obj,
-					     jobject canvas,
-					     jlong disp,
-					     jlong thisWin,
-					     jlong glContext)
-{
-	jboolean ret = JNI_TRUE;
-	JAWTDataHolder * pData = (JAWTDataHolder *) ( (PointerHolder) thisWin ); 
-
-	if( !thisWin )
-	{
-	    return JNI_FALSE;
-	}
-
-	if( !glContext )
-	{
-	    return JNI_FALSE;
-	}
-
-        if(jawt_open(env, canvas, pData, verbose)==JNI_FALSE ||
-           pData->result==JNI_FALSE
-          )
-        {
-              fprintf(stderr,"\nGL4Java ERROR: MakeCurrent could not open JAWT reference!\n");
-              fflush(stderr);
-              ret=JNI_FALSE;
-              jawt_close_unlock(env, pData, JNI_FALSE);
-              return ret;
-        }
-    
-        if(jawt_lock(env, pData, JNI_FALSE, verbose)==JNI_FALSE ||
-           pData->result==JNI_FALSE
-          )
-        {
-             /* this can happen:
-               if ( (pJData->lock & JAWT_LOCK_SURFACE_CHANGED) != 0 )
-    
-               In this case, we need a new GLXContext ...
-    
-               This has to be queried by the java class,
-               while using the native method hasJAWTSurfaceChanged !
-              */
-              if(verbose)
-              {
-                 fprintf(stderr,"\nGL4Java ERROR: MakeCurrent could not lock JAWT reference!\n");
-                 fflush(stderr);
-              }
-              ret=JNI_FALSE;
-              jawt_close_unlock(env, pData, JNI_FALSE);
-              return ret;
-        }
-    
-        if ( ret==JNI_TRUE && !wglMakeCurrent(GET_USED_WINDOW(thisWin),
-	                                      (HGLRC)((PointerHolder)glContext)) )
-        {
-		jawt_close_unlock(env, pData, JNI_FALSE);
-    		return JNI_FALSE;
-        } 
-        return JNI_TRUE;
-}
-
-JNIEXPORT jboolean JNICALL
-Java_gl4java_GLContext_gljFreeNative( JNIEnv *env, jobject obj,
-				      jobject canvas,
-				      jlong disp,
-				      jlong thisWin,
-				      jlong glContext
-				    )
-{
-    JAWTDataHolder * pData = (JAWTDataHolder *) ( (PointerHolder) thisWin );
-	jboolean ret = JNI_TRUE;
-
-    (void)glContext;
-    (void)disp;
-    (void)canvas;
-
-    if ( ! wglMakeCurrent( NULL, NULL ) )
-    {
-			fprintf(stderr, "gljFree failed\n");
-			fflush(stderr);
-			ret = JNI_FALSE;
-    }
-
-	if(pData!=NULL)
-		jawt_close_unlock(env, pData, verbose);
-
-    return ret;
-}
-
-JNIEXPORT jboolean JNICALL
-Java_gl4java_GLContext_gljDestroyNative( JNIEnv *env, jobject obj,
-					 jobject canvas)
-{
-	jboolean ret = JNI_TRUE;
-
-	jclass cls = 0;
-	jfieldID fpData=0;
-	jfieldID fwindowHandle=0, fpixmapHandle=0;
-	jfieldID fglContext=0;
-    jfieldID foffScreenRenderer=0;
-    jfieldID fownwind=0;
-
-    jboolean jownwind = JNI_FALSE ;
-    jboolean joffScreenRenderer=JNI_FALSE;
-    HBITMAP pix=0;
-	HDC thisWin=0;
-	HGLRC gc=0;
-	JAWTDataHolder * pData = NULL;
-
-	(void)canvas;
-
-	cls = (*env)->GetObjectClass(env, obj);
-	if(cls==0)
-	{
-	    ret=JNI_FALSE;
-	}
-
-	if(ret==JNI_TRUE) {
-	    fwindowHandle = (*env)->GetFieldID(env, cls, "windowHandle", "J");
-	    if (fwindowHandle == 0) ret= JNI_FALSE;
-	}
-
-	if(ret==JNI_TRUE) {
-	    fglContext=(*env)->GetFieldID(env, cls, "glContext", "J");
-	    if (fglContext == 0) ret= JNI_FALSE;
-	    else gc =(HGLRC)
-	      ((PointerHolder)(*env)->GetLongField(env, obj, fglContext));
-	}
-
-
-        if(ret==JNI_TRUE) {
-    	    fpixmapHandle = (*env)->GetFieldID(env, cls, "pixmapHandle", "J");
-    	    if (fpixmapHandle == 0) ret= JNI_FALSE;
-    	    else pix =(HBITMAP)
-    	      ((PointerHolder)(*env)->GetLongField(env, obj, fpixmapHandle));
-        }
-    
-        if(ret==JNI_TRUE) {
-    	    foffScreenRenderer = 
-    	    		(*env)->GetFieldID(env, cls, "offScreenRenderer", "Z");
-    	    if (foffScreenRenderer == 0) ret= JNI_FALSE;
-    	    else joffScreenRenderer =(*env)->GetBooleanField(env, obj, foffScreenRenderer);
-        }
-    
-        if(ret==JNI_TRUE) {
-    	    fownwind = (*env)->GetFieldID(env, cls, "createOwnWindow", "Z");
-    	    if (fownwind == 0) ret= JNI_FALSE;
-    	    else jownwind =(*env)->GetBooleanField(env, obj, fownwind);
-        }
-    
-        if(ret==JNI_TRUE) {
-            fpData = (*env)->GetFieldID(env, cls, "pData", "J");
-            if (fpData == 0) ret= JNI_FALSE;
-            else pData =(JAWTDataHolder *)
-                  ( (PointerHolder) (*env)->GetLongField(env, obj, fpData) );
-        }
-
- 
-        if(jawt_open(env, canvas, pData, verbose)==JNI_FALSE ||
-           pData->result==JNI_FALSE
-          )
-        {
-              fprintf(stderr,"\nGL4Java ERROR: gljDestroy could not open JAWT reference!\n");
-              fflush(stderr);
-              ret=JNI_FALSE;
-              jawt_close_unlock(env, pData, JNI_FALSE);
-              return ret;
-        }
-    
-        if(jawt_lock(env, pData, JNI_TRUE, verbose)==JNI_FALSE ||
-           pData->result==JNI_FALSE
-          )
-        {
-            if(JNI_TRUE==verbose)
-            {
-                fprintf(stderr, "GL4Java: gljDestroy lock failed\n");
-                fflush(stderr);
-            }
-		/**
-		 * we have to continue destroying the context !
-		 *
-		 * therefore, the show ain't over yet !
-		 *
-		    jawt_close_unlock(env, pData, JNI_FALSE);
-		    return JNI_FALSE;
-		 */
-		pData->result=JNI_TRUE; // the force will be with us ;-)
-        }
-    
-        thisWin = GET_USED_WINDOW(pData);
-
-    if(ret==JNI_TRUE)
-    {
-	    if ( gc == 0 )
-	    {
-	        if(JNI_TRUE==verbose)
-			{
-				fprintf(stderr, "gljDestroy error, GL context is 0\n");
-				fflush(stderr);
-			}
-		}
-
-		if ( ! wglMakeCurrent( NULL, NULL ) )
-		{
-			fprintf(stderr, "gljDestroy failed (free)\n");
-			fflush(stderr);
-		} 
-
-		if(ret==JNI_TRUE) 
-		{
-			if(gc!=0)
-				wglDeleteContext(gc);
-
-			if(pix!=0)
-			{
-			    if(thisWin!=0)
-				    DeleteDC(thisWin);
-			    thisWin=0;
-			    pData->dsi_win = NULL;
-			    pData->dsi_win_created = 0;
-			    DeleteObject(pix);
-			    pix=0;
-			}
-			if(jownwind && thisWin!=0)
-			{
-			    DeleteDC(thisWin);
-			    thisWin=0;
-			    pData->dsi_win = NULL;
-			    pData->dsi_win_created = 0;
-			    jownwind=JNI_FALSE;
-			}
-		}
-	}
-
-	gc = 0;
-	thisWin = 0;
-
-    jawt_free_close_unlock(env, &pData, verbose); 
-
-	pData=0;
-	ret=JNI_TRUE; // force ..
-
-    if(ret==JNI_TRUE && fpData!=0) {
-	    (*env)->SetLongField(env, obj, fpData, (jlong)((PointerHolder)pData));
-    }
-
-    if(ret==JNI_TRUE && fwindowHandle!=0) {
-	    (*env)->SetLongField(env, obj, fwindowHandle, (jlong)((PointerHolder)pData));
-    }
-
-    if(ret==JNI_TRUE && fglContext) {
-	    (*env)->SetLongField(env, obj, fglContext, (jlong)((PointerHolder)gc));
-    }
-
-
-    if(ret==JNI_TRUE && fpixmapHandle!=0) {
-	    (*env)->SetLongField(env, obj, fpixmapHandle, (jlong)((PointerHolder)pix));
-    }
-
-    if(ret==JNI_TRUE && fownwind) {
-	    (*env)->SetBooleanField(env, obj, fownwind, jownwind);
-    }
-
-    return ret;
-}
-
-JNIEXPORT jboolean JNICALL
-Java_gl4java_GLContext_gljSwapNative( JNIEnv *env, jobject obj,
-				      jlong disp,
-				      jlong thisWin,
-				      jlong glContext,
-				      jboolean doubleBuffer
-			      )
-{
-	jboolean ret = JNI_TRUE;
-
-        (void)glContext;
-        (void)disp;
-
-	if( !thisWin || GET_USED_WINDOW(thisWin)==0)
-	{
-            fprintf(stderr,"Swap does not got the window ...\n");
-	    return JNI_FALSE;
-	}
-
-	if( doubleBuffer==JNI_TRUE )
-	{
-		if( SwapBuffers( GET_USED_WINDOW(thisWin) ) == FALSE )
-		{
-			/* Error in Win2000 implementation :o)
-			 * printf( "Error in swap buffer!\n" );
-			 */
-	                return JNI_FALSE;
-		}
-	} else {
-		glFlush();
-	}
-	return ret;
-}
-
-JNIEXPORT void JNICALL
-Java_gl4java_GLContext_gljResizeNative( JNIEnv *env, jobject obj,
-	                                jboolean isOwnWindow,
-				        jlong disp, jlong thisWin,
-				        jint width, jint height)
-{
-	(void)isOwnWindow;
-	(void)disp;
-	(void)thisWin;
-	(void)width;
-	(void)height;
-
-	return;
-}
-
+/*
+ * Original Author: Leo Chan -- 1995
+ *
+ * Adam King 1997
+ *		Ported to Win32 from X
+ *
+ * This file takes care of the C implementation of finding the correct
+ * Win32 window, assigning an OpenGL graphics context to it, storing that
+ * graphics context in the java class data structure.
+ *
+ * also contains the use() and swap() functions for double buffering
+ *
+ * September 12, 1997	- Adam King
+ *		- Added support for rendering directly into a Canvas ( BIG rewrite )
+ */
+
+/**
+ * Pointer Semantics of GLContext:
+ * ==============================
+
+   "displayHandle"	:= not used
+   	
+   "pData" 		:= (JAWTDataHolder *)
+   	"windowHandle" 	:= "pData"
+
+        This holds the current state of the JAWT context !
+
+   	This is used as the "not initialized" flag also !
+	It is reset to zero while Destroy Method
+
+   "pData"->dsi_win     := (HDC)
+   	if("offScreenRenderer" == TRUE)
+		"pData"->dsi_win contains the window handle,
+		of the last lock !
+		"pData"->dsi_win_created=0 !
+
+   "pixmapHandle"	:= (HBITMAP)
+   	if("offScreenRenderer" == TRUE)
+		"pixmapHandle" contains the new BITMAP (by CreateDIBSection)!
+		"windowHandle" contains the new created OffScreenWindow 
+			       (by CreateCompatibleDC)!
+        else
+		"pixmapHandle" is unused !
+
+   "sharedGLContextNative" := (HGLRC)
+   	This is the optional shared GLContext !
+
+   "glContext" := (HGLRC)
+   	This is THE used GLContext !
+ */
+
+#include "OpenGL_Win32_common.h"
+
+#include "jawt_misc.h"
+
+/*
+ * Macros ..
+ */
+
+#define GET_W32_JAWT_DSI(a) \
+	( (JAWT_Win32DrawingSurfaceInfo *) \
+	  ( ( (JAWTDataHolder *)((PointerHolder)(a)) ) ->dsi_os ) \
+        )
+
+#define GET_USED_WINDOW(a) \
+	( (HDC) \
+	  ( ( (JAWTDataHolder *)((PointerHolder)(a)) ) ->dsi_win ) \
+        )
+
+static jboolean verbose = JNI_FALSE;
+
+JNIEXPORT jboolean JNICALL
+Java_gl4java_GLContext_useJAWT( JNIEnv *env, jobject obj )
+{
+    (void)env;
+    (void)obj;
+    return JNI_TRUE;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_gl4java_GLContext_hasJAWTSurfaceChanged( JNIEnv *env, jobject obj,
+					      jlong thisWin )
+{
+    JAWTDataHolder * pData = (JAWTDataHolder *) ( (PointerHolder) thisWin );
+    (void)env;
+    (void)obj;
+	
+	if(pData!=0)
+		return (pData->lock & JAWT_LOCK_SURFACE_CHANGED) != 0 ;
+
+	return JNI_FALSE;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_gl4java_GLContext_openOpenGLNative( JNIEnv *env, jobject obj,
+					jobject canvas)
+{
+    jboolean ret = JNI_TRUE;
+
+    jclass cls = 0;
+    jfieldID fpixmapHandle=0;
+    jfieldID foffScreenRenderer=0;
+    jfieldID fwindowHandle=0, fpData=0;
+    jfieldID fverbose=0;
+    jfieldID fglContext=0;
+    jfieldID fshareWith=0;
+    jfieldID fcreatewinw = 0, fcreatewinh = 0;
+    jfieldID fglCaps=0;
+
+    /* these variables will be mapped in the java-object ! */
+    jboolean joffScreenRenderer=JNI_FALSE;
+    HDC theWindow=0;
+    PIXELFORMATDESCRIPTOR pfd;
+    HGLRC gc=0;
+    JAWTDataHolder * pData=0;
+	HGLRC shareWith=NULL;
+    jint jcreatewinw = 0, jcreatewinh = 0;
+    HBITMAP pix=0;
+
+    GLCapabilities glCaps;
+    jobject  jglCaps=0;
+    jthrowable exc;
+    jclass _GLCapabilities= 0;
+    jclass _AwtComponent=0;
+
+    cls = (*env)->GetObjectClass(env, obj);
+    if(cls==0)
+    {
+        fprintf(stderr,"oo0.0 cls==0\n");
+		  fflush(stderr);
+		  return JNI_FALSE;
+    }
+
+    if(ret==JNI_TRUE)
+    {
+	    fverbose =(*env)->GetStaticFieldID(env, cls, "gljNativeDebug", "Z");
+	    if (fverbose == 0)
+	    {
+                fprintf(stderr,"oo0.2 fverbose==0\n");
+                fflush(stderr);
+		return JNI_FALSE;
+	    } else {
+		verbose = (*env)->GetStaticBooleanField(env, cls, fverbose);
+	    }
+    }
+
+    if(JNI_TRUE==verbose)
+    {
+		fprintf(stderr, "sizes:\n jlong=%d\n HGLRC=%d\n HDC=%d\n",
+	  		sizeof(jlong), sizeof(HGLRC), sizeof(HDC) );
+		fflush(stderr);
+    }
+
+    /* FIRST OF ALL CHECK IF A NATIVE POINTER OR WIN-TYPE FITS IN �jlong� */
+    ret = testWin32Java();
+
+    ret = testJavaGLTypes(verbose);
+
+    if(ret==JNI_TRUE) {
+	    fpData = (*env)->GetFieldID(env, cls, "pData", "J");
+	    if (fpData == 0) ret= JNI_FALSE;
+	    else pData = (JAWTDataHolder *)
+	      ( (PointerHolder)(*env)->GetLongField(env, obj, fpData));
+    }
+    if(JNI_TRUE==verbose)
+    {
+    	fprintf(stderr, "received pData : %d\n", (int)pData);
+    }
+
+    if(ret==JNI_TRUE) {
+	    fwindowHandle = (*env)->GetFieldID(env, cls, "windowHandle", "J");
+	    if (fwindowHandle == 0) ret= JNI_FALSE;
+    }
+
+    if(ret==JNI_TRUE) {
+	    fglContext=(*env)->GetFieldID(env, cls, "glContext", "J");
+	    if (fglContext == 0) ret= JNI_FALSE;
+    }
+
+    if(ret==JNI_TRUE) {
+	    foffScreenRenderer = 
+	    		(*env)->GetFieldID(env, cls, "offScreenRenderer", "Z");
+	    if (foffScreenRenderer == 0) ret= JNI_FALSE;
+	    else joffScreenRenderer =(*env)->GetBooleanField(env, obj, foffScreenRenderer);
+    }
+
+    if(ret==JNI_TRUE) {
+            fglCaps = (*env)->GetFieldID(env, cls, "glCaps", "Lgl4java/GLCapabilities;");
+            if (fglCaps == 0) 
+	    {
+	    	fprintf(stderr, "fglCaps not accessible !\n");
+		fflush(stderr);
+		ret= JNI_FALSE; 
+	    }
+            else jglCaps =(*env)->GetObjectField(env, obj, fglCaps);
+    }
+
+    if( jglCaps==0 )
+    {
+      fprintf(stderr,"\nGL4Java openOpenGL ERROR: ZERO capsObj was fetched by GetObjectField !\n");
+      fflush(stderr);
+      return JNI_FALSE;
+    }
+
+    _GLCapabilities= (*env)->FindClass(env, "Lgl4java/GLCapabilities;");
+    exc = (*env)->ExceptionOccurred(env);
+    if(exc) {
+          if(JNI_TRUE==verbose)
+	  {
+             fprintf(stderr, "GL4Java: openOpen FindClass gl4java/GLCapabilities failed, cannot check glCaps object\n");
+	     (*env)->ExceptionDescribe(env);
+             fflush(stderr);
+	  }
+	  (*env)->ExceptionClear(env);
+	  _GLCapabilities=0;
+    }
+    exc=0;
+
+    if( _GLCapabilities!=0 &&
+        (*env)->IsInstanceOf(env, jglCaps, _GLCapabilities)==JNI_FALSE )
+    {
+      fprintf(stderr,"\nGL4Java openOpenGL ERROR: glCaps is not instanceof gl4java/GLCapabilities !\n");
+      fflush(stderr);
+      return JNI_FALSE;
+    }
+
+    if(JNI_TRUE != javaGLCapabilities2NativeGLCapabilities
+                           ( env, jglCaps, &glCaps ) )
+    {
+      fprintf(stderr,"\nGL4Java ERROR: glCaps Object is not valid !\n");
+      fflush(stderr);
+      return JNI_FALSE;
+    }
+
+    if(ret==JNI_TRUE) {
+	    fcreatewinw = (*env)->GetFieldID(env, cls, "createwinw", "I");
+	    if (fcreatewinw == 0) ret= JNI_FALSE;
+	    else jcreatewinw =(*env)->GetIntField(env, obj, fcreatewinw);
+    }
+
+    if(ret==JNI_TRUE) {
+	    fcreatewinh = (*env)->GetFieldID(env, cls, "createwinh", "I");
+	    if (fcreatewinh == 0) ret= JNI_FALSE;
+	    else jcreatewinh =(*env)->GetIntField(env, obj, fcreatewinh);
+    }
+
+    if(ret==JNI_TRUE) {
+	    fshareWith = (*env)->GetFieldID(env, cls, "sharedGLContextNative", "J");
+	    if (fshareWith == 0) ret= JNI_FALSE;
+	    else shareWith = (HGLRC) 
+	      ( (PointerHolder)(*env)->GetLongField(env, obj, fshareWith));
+    }
+
+    if(ret==JNI_TRUE) {
+	    fpixmapHandle = (*env)->GetFieldID(env, cls, "pixmapHandle", "J");
+	    if (fpixmapHandle == 0) ret= JNI_FALSE;
+    }
+
+    if(joffScreenRenderer==JNI_TRUE)
+    {
+	glCaps.buffer=BUFFER_SINGLE;
+    }
+
+    if(JNI_TRUE==verbose && joffScreenRenderer==JNI_TRUE)
+    {
+		fprintf(stderr,"\nGL4Java:  (USING OFFSCREEN GLPIXMAP BUFFER,\n\t forced: !doubleBuffer)\n");
+		fflush(stderr);
+    }
+
+    _AwtComponent= (*env)->FindClass(env, "Ljava/awt/Component;");
+    exc = (*env)->ExceptionOccurred(env);
+    if(exc) {
+          if(JNI_TRUE==verbose)
+	  {
+             fprintf(stderr, "GL4Java: openOpen FindClass java/awt/Component failed, cannot check canvas object\n");
+	     (*env)->ExceptionDescribe(env);
+             fflush(stderr);
+	  }
+	  (*env)->ExceptionClear(env);
+	  _AwtComponent=0;
+    }
+    exc=0;
+
+    if(ret==JNI_TRUE) {
+	if (canvas == 0) 
+	{
+		ret= JNI_FALSE;
+		fprintf(stderr,"\nGL4Java ERROR: canvas == NULL !\n");
+		fflush(stderr);
+	} else {
+		if( _AwtComponent!=0 &&
+		    (*env)->IsInstanceOf(env, canvas, _AwtComponent)==JNI_FALSE)
+		{
+		  fprintf(stderr,"\nGL4Java ERROR: canvas is not instanceof java/awt/Component !\n");
+		  fflush(stderr);
+		  ret= JNI_FALSE;
+		}
+	}
+    }
+
+    if(joffScreenRenderer==JNI_TRUE)
+    {
+        jawt_create_offscreen(env, &pData, verbose);
+    } 
+    else {
+        if(jawt_create_open(env, canvas, &pData, verbose)==JNI_FALSE ||
+           pData->result==JNI_FALSE
+          )
+        {
+	  fprintf(stderr,"\nGL4Java ERROR: openOpen could not create&open JAWT reference!\n");
+	  fflush(stderr);
+	  jawt_free_close_unlock(env, &pData, JNI_FALSE);
+	  ret=JNI_FALSE;
+	  return ret;
+        }
+
+        if(jawt_lock(env, pData, JNI_TRUE, verbose)==JNI_FALSE ||
+           pData->result==JNI_FALSE
+          )
+        {
+	  fprintf(stderr,"\nGL4Java ERROR: openOpen could not lock JAWT reference!\n");
+	  fflush(stderr);
+	  jawt_free_close_unlock(env, &pData, JNI_FALSE);
+	  ret=JNI_FALSE;
+	  return ret;
+        }
+    }
+
+    if(pData->result==JNI_TRUE)
+    {
+	    if(joffScreenRenderer==JNI_FALSE)
+	    {
+	    	theWindow = GET_W32_JAWT_DSI(pData)->hdc;
+	        jcreatewinw =  pData->dsi->bounds.width;
+	        jcreatewinh =  pData->dsi->bounds.height;
+	    }
+    }
+
+    wglMakeCurrent(NULL, NULL);
+
+    /**
+     * with version jdk1.1.6 and later, we are able to use 
+     * the java-function straight to achieve the native window
+     * handle ....
+     *
+     * this handle is saved to pData for the windows version !
+     */
+    if( theWindow == 0 && !joffScreenRenderer)
+    {
+	    printf( "get_GC: Error, pData->hdc is zero\n");
+	    jawt_free_close_unlock(env, &pData, JNI_FALSE);
+	    return JNI_FALSE;
+    }
+
+    /* get the graphics context for this widget */
+    if( (gc = get_GC( &theWindow, &glCaps,
+                       shareWith, joffScreenRenderer, jcreatewinw, 
+		       jcreatewinh, &pix, verbose)) == 0 )
+    {
+	    printf( "getGC error" );
+	    return JNI_FALSE;
+    }
+
+	/* fetch the states of doubleBuffer and stereo */
+    (void) PixelFormatDescriptorFromDc( theWindow, &pfd);
+
+    if(JNI_TRUE==verbose) 
+    { 
+	fprintf(stdout,"\nGL4Java: writing capabilities to GLContext's java object\n");
+        fflush(stdout);
+    }
+
+    (void) nativeGLCapabilities2JavaGLCapabilities (env, jglCaps, &glCaps);
+
+    if(ret==JNI_TRUE && fglCaps) {
+                    (*env)->SetObjectField(env, obj, fglCaps, jglCaps);
+    }
+  
+    jawt_close_unlock(env, pData, verbose);    
+
+    if(ret==JNI_TRUE && fwindowHandle!=0) {
+	    (*env)->SetLongField(env, obj, fwindowHandle, 
+	                        (jlong)((PointerHolder)pData));
+    }
+    if(ret==JNI_TRUE && fpData!=0) {
+	    (*env)->SetLongField(env, obj, fpData, 
+	                        (jlong)((PointerHolder)pData));
+    }
+
+    if(ret==JNI_TRUE && fpixmapHandle!=0) {
+	    (*env)->SetLongField(env, obj, fpixmapHandle, (jlong)((PointerHolder)pix));
+    	 if(JNI_TRUE==verbose)
+    		fprintf(stderr, "go and set pixmapHandle pix: %d; 0x%X\n",
+         	(int)pix, (int)pix);
+    }
+
+    if(ret==JNI_TRUE && fglContext !=0 ) {
+	    (*env)->SetLongField(env, obj, fglContext, (jlong)((PointerHolder)gc));
+    	 if(JNI_TRUE==verbose)
+    		fprintf(stderr, "go and set gc  : %d, 0x%X\n",
+         	(int)gc, (int)gc);
+    }
+
+	/*
+	gl4java_bind_ext(JNI_TRUE==verbose);
+	*/
+
+    return ret;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_gl4java_GLContext_gljMakeCurrentNative( JNIEnv *env, jobject obj,
+					     jobject canvas,
+					     jlong disp,
+					     jlong thisWin,
+					     jlong glContext)
+{
+	jboolean ret = JNI_TRUE;
+	JAWTDataHolder * pData = (JAWTDataHolder *) ( (PointerHolder) thisWin ); 
+
+	if( !thisWin )
+	{
+	    return JNI_FALSE;
+	}
+
+	if( !glContext )
+	{
+	    return JNI_FALSE;
+	}
+
+        if(jawt_open(env, canvas, pData, verbose)==JNI_FALSE ||
+           pData->result==JNI_FALSE
+          )
+        {
+              fprintf(stderr,"\nGL4Java ERROR: MakeCurrent could not open JAWT reference!\n");
+              fflush(stderr);
+              ret=JNI_FALSE;
+              jawt_close_unlock(env, pData, JNI_FALSE);
+              return ret;
+        }
+    
+        if(jawt_lock(env, pData, JNI_FALSE, verbose)==JNI_FALSE ||
+           pData->result==JNI_FALSE
+          )
+        {
+             /* this can happen:
+               if ( (pJData->lock & JAWT_LOCK_SURFACE_CHANGED) != 0 )
+    
+               In this case, we need a new GLXContext ...
+    
+               This has to be queried by the java class,
+               while using the native method hasJAWTSurfaceChanged !
+              */
+              if(verbose)
+              {
+                 fprintf(stderr,"\nGL4Java ERROR: MakeCurrent could not lock JAWT reference!\n");
+                 fflush(stderr);
+              }
+              ret=JNI_FALSE;
+              jawt_close_unlock(env, pData, JNI_FALSE);
+              return ret;
+        }
+    
+        if ( ret==JNI_TRUE && !wglMakeCurrent(GET_USED_WINDOW(thisWin),
+	                                      (HGLRC)((PointerHolder)glContext)) )
+        {
+		jawt_close_unlock(env, pData, JNI_FALSE);
+    		return JNI_FALSE;
+        } 
+        return JNI_TRUE;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_gl4java_GLContext_gljFreeNative( JNIEnv *env, jobject obj,
+				      jobject canvas,
+				      jlong disp,
+				      jlong thisWin,
+				      jlong glContext
+				    )
+{
+    JAWTDataHolder * pData = (JAWTDataHolder *) ( (PointerHolder) thisWin );
+	jboolean ret = JNI_TRUE;
+
+    (void)glContext;
+    (void)disp;
+    (void)canvas;
+
+    if ( ! wglMakeCurrent( NULL, NULL ) )
+    {
+			fprintf(stderr, "gljFree failed\n");
+			fflush(stderr);
+			ret = JNI_FALSE;
+    }
+
+	if(pData!=NULL)
+		jawt_close_unlock(env, pData, verbose);
+
+    return ret;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_gl4java_GLContext_gljDestroyNative( JNIEnv *env, jobject obj,
+					 jobject canvas)
+{
+	jboolean ret = JNI_TRUE;
+
+	jclass cls = 0;
+	jfieldID fpData=0;
+	jfieldID fwindowHandle=0, fpixmapHandle=0;
+	jfieldID fglContext=0;
+    jfieldID foffScreenRenderer=0;
+    jfieldID fownwind=0;
+
+    jboolean jownwind = JNI_FALSE ;
+    jboolean joffScreenRenderer=JNI_FALSE;
+    HBITMAP pix=0;
+	HDC thisWin=0;
+	HGLRC gc=0;
+	JAWTDataHolder * pData = NULL;
+
+	(void)canvas;
+
+	cls = (*env)->GetObjectClass(env, obj);
+	if(cls==0)
+	{
+	    ret=JNI_FALSE;
+	}
+
+	if(ret==JNI_TRUE) {
+	    fwindowHandle = (*env)->GetFieldID(env, cls, "windowHandle", "J");
+	    if (fwindowHandle == 0) ret= JNI_FALSE;
+	}
+
+	if(ret==JNI_TRUE) {
+	    fglContext=(*env)->GetFieldID(env, cls, "glContext", "J");
+	    if (fglContext == 0) ret= JNI_FALSE;
+	    else gc =(HGLRC)
+	      ((PointerHolder)(*env)->GetLongField(env, obj, fglContext));
+	}
+
+
+        if(ret==JNI_TRUE) {
+    	    fpixmapHandle = (*env)->GetFieldID(env, cls, "pixmapHandle", "J");
+    	    if (fpixmapHandle == 0) ret= JNI_FALSE;
+    	    else pix =(HBITMAP)
+    	      ((PointerHolder)(*env)->GetLongField(env, obj, fpixmapHandle));
+        }
+    
+        if(ret==JNI_TRUE) {
+    	    foffScreenRenderer = 
+    	    		(*env)->GetFieldID(env, cls, "offScreenRenderer", "Z");
+    	    if (foffScreenRenderer == 0) ret= JNI_FALSE;
+    	    else joffScreenRenderer =(*env)->GetBooleanField(env, obj, foffScreenRenderer);
+        }
+    
+        if(ret==JNI_TRUE) {
+    	    fownwind = (*env)->GetFieldID(env, cls, "createOwnWindow", "Z");
+    	    if (fownwind == 0) ret= JNI_FALSE;
+    	    else jownwind =(*env)->GetBooleanField(env, obj, fownwind);
+        }
+    
+        if(ret==JNI_TRUE) {
+            fpData = (*env)->GetFieldID(env, cls, "pData", "J");
+            if (fpData == 0) ret= JNI_FALSE;
+            else pData =(JAWTDataHolder *)
+                  ( (PointerHolder) (*env)->GetLongField(env, obj, fpData) );
+        }
+
+ 
+        if(jawt_open(env, canvas, pData, verbose)==JNI_FALSE ||
+           pData->result==JNI_FALSE
+          )
+        {
+              fprintf(stderr,"\nGL4Java ERROR: gljDestroy could not open JAWT reference!\n");
+              fflush(stderr);
+              ret=JNI_FALSE;
+              jawt_close_unlock(env, pData, JNI_FALSE);
+              return ret;
+        }
+    
+        if(jawt_lock(env, pData, JNI_TRUE, verbose)==JNI_FALSE ||
+           pData->result==JNI_FALSE
+          )
+        {
+            if(JNI_TRUE==verbose)
+            {
+                fprintf(stderr, "GL4Java: gljDestroy lock failed\n");
+                fflush(stderr);
+            }
+		/**
+		 * we have to continue destroying the context !
+		 *
+		 * therefore, the show ain't over yet !
+		 *
+		    jawt_close_unlock(env, pData, JNI_FALSE);
+		    return JNI_FALSE;
+		 */
+		pData->result=JNI_TRUE; // the force will be with us ;-)
+        }
+    
+        thisWin = GET_USED_WINDOW(pData);
+
+    if(ret==JNI_TRUE)
+    {
+	    if ( gc == 0 )
+	    {
+	        if(JNI_TRUE==verbose)
+			{
+				fprintf(stderr, "gljDestroy error, GL context is 0\n");
+				fflush(stderr);
+			}
+		}
+
+		if ( ! wglMakeCurrent( NULL, NULL ) )
+		{
+			fprintf(stderr, "gljDestroy failed (free)\n");
+			fflush(stderr);
+		} 
+
+		if(ret==JNI_TRUE) 
+		{
+			if(gc!=0)
+				wglDeleteContext(gc);
+
+			if(pix!=0)
+			{
+			    if(thisWin!=0)
+				    DeleteDC(thisWin);
+			    thisWin=0;
+			    pData->dsi_win = NULL;
+			    pData->dsi_win_created = 0;
+			    DeleteObject(pix);
+			    pix=0;
+			}
+			if(jownwind && thisWin!=0)
+			{
+			    DeleteDC(thisWin);
+			    thisWin=0;
+			    pData->dsi_win = NULL;
+			    pData->dsi_win_created = 0;
+			    jownwind=JNI_FALSE;
+			}
+		}
+	}
+
+	gc = 0;
+	thisWin = 0;
+
+    jawt_free_close_unlock(env, &pData, verbose); 
+
+	pData=0;
+	ret=JNI_TRUE; // force ..
+
+    if(ret==JNI_TRUE && fpData!=0) {
+	    (*env)->SetLongField(env, obj, fpData, (jlong)((PointerHolder)pData));
+    }
+
+    if(ret==JNI_TRUE && fwindowHandle!=0) {
+	    (*env)->SetLongField(env, obj, fwindowHandle, (jlong)((PointerHolder)pData));
+    }
+
+    if(ret==JNI_TRUE && fglContext) {
+	    (*env)->SetLongField(env, obj, fglContext, (jlong)((PointerHolder)gc));
+    }
+
+
+    if(ret==JNI_TRUE && fpixmapHandle!=0) {
+	    (*env)->SetLongField(env, obj, fpixmapHandle, (jlong)((PointerHolder)pix));
+    }
+
+    if(ret==JNI_TRUE && fownwind) {
+	    (*env)->SetBooleanField(env, obj, fownwind, jownwind);
+    }
+
+    return ret;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_gl4java_GLContext_gljSwapNative( JNIEnv *env, jobject obj,
+				      jlong disp,
+				      jlong thisWin,
+				      jlong glContext,
+				      jboolean doubleBuffer
+			      )
+{
+	jboolean ret = JNI_TRUE;
+
+        (void)glContext;
+        (void)disp;
+
+	if( !thisWin || GET_USED_WINDOW(thisWin)==0)
+	{
+            fprintf(stderr,"Swap does not got the window ...\n");
+	    return JNI_FALSE;
+	}
+
+	if( doubleBuffer==JNI_TRUE )
+	{
+		if( SwapBuffers( GET_USED_WINDOW(thisWin) ) == FALSE )
+		{
+			/* Error in Win2000 implementation :o)
+			 * printf( "Error in swap buffer!\n" );
+			 */
+	                return JNI_FALSE;
+		}
+	} else {
+		glFlush();
+	}
+	return ret;
+}
+
+JNIEXPORT void JNICALL
+Java_gl4java_GLContext_gljResizeNative( JNIEnv *env, jobject obj,
+	                                jboolean isOwnWindow,
+				        jlong disp, jlong thisWin,
+				        jint width, jint height)
+{
+	(void)isOwnWindow;
+	(void)disp;
+	(void)thisWin;
+	(void)width;
+	(void)height;
+
+	return;
+}
+
diff --git a/CNativeCode/OpenGL_X11.c b/CNativeCode/OpenGL_X11.c
index 610611d..ac88c70 100644
--- a/CNativeCode/OpenGL_X11.c
+++ b/CNativeCode/OpenGL_X11.c
@@ -126,18 +126,16 @@ Java_gl4java_GLContext_openOpenGLNative( JNIEnv *env, jobject obj,
     jfieldID fdisplayHandle=0, fwindowHandle=0, fpixmapHandle=0;
     jfieldID fverbose=0;
     jfieldID fglContext=0;
-    jfieldID fstereoView=0, frgba=0, fstencilBits=0, 
-             faccumSize=0, fownwind=0;
-    jfieldID fdoubleBuffer=0, foffScreenRenderer;
+    jfieldID fglCaps=0;
+    jfieldID fownwind=0, foffScreenRenderer;
 
     jfieldID fcreatewinw = 0, fcreatewinh = 0;
     jfieldID fshareWith = 0;
     jboolean joffScreenRenderer=JNI_FALSE;
-    jboolean jdoubleBuffer=JNI_TRUE;
-    jboolean jstereoView=JNI_FALSE;
-    jboolean jrgba=JNI_TRUE;
-    jint jstencilBits=0;
-    jint jaccumSize=0;
+
+    jobject  jglCaps=0;
+    GLCapabilities glCaps;
+
     jboolean jownwind = JNI_FALSE ;
     jint jcreatewinw = 0, jcreatewinh = 0;
     GLXContext jshareWith = 0;
@@ -148,7 +146,8 @@ Java_gl4java_GLContext_openOpenGLNative( JNIEnv *env, jobject obj,
     Window rootwini  = 0;
     Pixmap pix;
 
-    int iValue, iValue1, iValue2, iValue3;
+    jthrowable exc;
+    jclass _GLCapabilities= 0;
 
     (void)canvas;
 
@@ -191,33 +190,39 @@ Java_gl4java_GLContext_openOpenGLNative( JNIEnv *env, jobject obj,
     }
 
     if(ret==JNI_TRUE) {
-	    fdoubleBuffer = (*env)->GetFieldID(env, cls, "doubleBuffer", "Z");
-	    if (fdoubleBuffer == 0) ret= JNI_FALSE;
-	    else jdoubleBuffer =(*env)->GetBooleanField(env, obj, fdoubleBuffer);
-    }
-
-    if(ret==JNI_TRUE) {
-	    fstereoView = (*env)->GetFieldID(env, cls, "stereoView", "Z");
-	    if (fstereoView == 0) ret= JNI_FALSE;
-	    else jstereoView =(*env)->GetBooleanField(env, obj, fstereoView);
-    }
-
-    if(ret==JNI_TRUE) {
-	    frgba = (*env)->GetFieldID(env, cls, "rgba", "Z");
-	    if (frgba == 0) ret= JNI_FALSE;
-	    else jrgba =(*env)->GetBooleanField(env, obj, frgba);
-    }
-
-    if(ret==JNI_TRUE) {
-	    fstencilBits = (*env)->GetFieldID(env, cls, "stencilBits", "I");
-	    if (fstencilBits == 0) ret= JNI_FALSE;
-	    else jstencilBits =(*env)->GetIntField(env, obj, fstencilBits);
+	    fglCaps = (*env)->GetFieldID(env, cls, "glCaps", "Lgl4java/GLCapabilities;");
+	    if (fglCaps == 0) ret= JNI_FALSE;
+	    else jglCaps =(*env)->GetObjectField(env, obj, fglCaps);
+    }
+
+    _GLCapabilities= (*env)->FindClass(env, "Lgl4java/GLCapabilities;");
+    exc = (*env)->ExceptionOccurred(env);
+    if(exc) {
+          if(JNI_TRUE==verbose)
+	  {
+             fprintf(stderr, "GL4Java: openOpen FindClass gl4java/GLCapabilities failed, cannot check glCaps object\n");
+	     (*env)->ExceptionDescribe(env);
+             fflush(stderr);
+	  }
+	  (*env)->ExceptionClear(env);
+	  _GLCapabilities=0;
+    }
+    exc=0;
+
+    if( _GLCapabilities!=0 &&
+        (*env)->IsInstanceOf(env, jglCaps, _GLCapabilities)==JNI_FALSE )
+    {
+      fprintf(stderr,"\nGL4Java openOpenGL ERROR: glCaps is not instanceof gl4java/GLCapabilities !\n");
+      fflush(stderr);
+      return JNI_FALSE;
     }
 
-    if(ret==JNI_TRUE) {
-	    faccumSize = (*env)->GetFieldID(env, cls, "accumSize", "I");
-	    if (faccumSize == 0) ret= JNI_FALSE;
-	    else jaccumSize =(*env)->GetIntField(env, obj, faccumSize);
+    if(JNI_TRUE != javaGLCapabilities2NativeGLCapabilities
+                           ( env, jglCaps, &glCaps ) )
+    {
+      fprintf(stderr,"\nGL4Java ERROR: glCaps Object is not valid !\n");
+      fflush(stderr);
+      return JNI_FALSE;
     }
 
     if(ret==JNI_TRUE) {
@@ -283,14 +288,6 @@ Java_gl4java_GLContext_openOpenGLNative( JNIEnv *env, jobject obj,
 	fflush(stderr);
     }
 
-    if(JNI_TRUE==verbose)
-    {
-	fprintf(stderr,"\nGL4Java:  (try to use visuals: doubleBuffer=%d, stereoView=%d, rgba=%d, stencilBits=%d, accumSize=%d, ownWindow=%d)\n)\n",
-	    (int)jdoubleBuffer, (int)jstereoView, (int)jrgba, (int)jstencilBits, (int)jaccumSize,
-	    (int)jownwind );
-	fflush(stderr);
-    }
-
     if(ret==JNI_TRUE) {
 	    fdisplayHandle = (*env)->GetFieldID(env, cls, "displayHandle", "J");
 	    if (fdisplayHandle == 0) ret= JNI_FALSE;
@@ -327,12 +324,11 @@ Java_gl4java_GLContext_openOpenGLNative( JNIEnv *env, jobject obj,
 	fprintf(stderr, "GL4Java ERROR: Can not query glx extension -> Server does not support OpenGL\n");
 	fflush(stderr);
         ret = JNI_FALSE;
-      } else {
-	if (JNI_TRUE==verbose) {
+      } else if (JNI_TRUE==verbose) 
+      {
 		fprintf(stdout, "GLX by %s Version %s\n", 
 			glXGetClientString(display, GLX_VENDOR),
 			glXGetClientString(display, GLX_VERSION));
-	}
       }
     }
 
@@ -346,18 +342,21 @@ Java_gl4java_GLContext_openOpenGLNative( JNIEnv *env, jobject obj,
 
             vgc = findVisualGlX( display, rootwini, &thisWin,
 	                         (int)jcreatewinw, (int)jcreatewinh, 
-                                 jdoubleBuffer, jstereoView, jrgba, 
-				 jstencilBits, jaccumSize,
+				 &glCaps,
 				 &jownwind, jshareWith,
 				 joffScreenRenderer, &pix, verbose);
 
-	    if(vgc.success == 0 && jrgba==JNI_TRUE)
+	    if(vgc.success == 0 && glCaps.color==COLOR_RGBA)
 	    {
-	        jrgba=JNI_FALSE;
+		if (JNI_TRUE==verbose) {
+			fprintf(stdout, "GL4Java switching color:=COLOR_INDEX\n");
+			fflush(stdout);
+		}
+	        glCaps.color=COLOR_INDEX;
+
                 vgc = findVisualGlX( display, rootwini, &thisWin,
 	                             (int)jcreatewinw, (int)jcreatewinh, 
-                                     jdoubleBuffer, jstereoView, jrgba, 
-				     jstencilBits, jaccumSize,
+				     &glCaps,
 				     &jownwind, jshareWith,
 				     joffScreenRenderer, &pix, verbose);
 	    }
@@ -374,104 +373,20 @@ Java_gl4java_GLContext_openOpenGLNative( JNIEnv *env, jobject obj,
 		 XCloseDisplay( display );
 		 ret = JNI_FALSE;
 	    } else {
-	    	 if(glXGetConfig( display, vgc.visual, 
-		                  GLX_DOUBLEBUFFER, &iValue)==0)
-		 {
-	                if (JNI_TRUE==verbose) {
-				fprintf(stdout,"doubleBuffer: %d\n", iValue);
-				fflush(stdout);
-			}
-			jdoubleBuffer=iValue?JNI_TRUE:JNI_FALSE;
-		        if(ret==JNI_TRUE && fdoubleBuffer!=0) {
-			    (*env)->SetBooleanField(env, obj, fdoubleBuffer, 
-			                            jdoubleBuffer);
-		        }
-
-		 } else {
-		 	fprintf(stderr,"GL4Java: fetching doubleBuffer state failed\n");
-		        fflush(stderr);
-		 }
-	    	 if(glXGetConfig( display, vgc.visual, 
-		                  GLX_STEREO, &iValue)==0)
-		 {
-	                if (JNI_TRUE==verbose) {
-				fprintf(stdout,"stereoView: %d\n", iValue);
-				fflush(stdout);
-			}
-			jstereoView=iValue?JNI_TRUE:JNI_FALSE;
-		        if(ret==JNI_TRUE && fstereoView!=0) {
-			    (*env)->SetBooleanField(env, obj, fstereoView, 
-			                            jstereoView);
-		        }
-
-		 } else {
-		 	fprintf(stderr,"GL4Java: fetching stereoView state failed\n");
-		        fflush(stderr);
-		 }
-	    	 if(glXGetConfig( display, vgc.visual, 
-		                  GLX_RGBA, &iValue)==0)
-		 {
-	                if (JNI_TRUE==verbose) {
-				fprintf(stdout,"rgba: %d\n", iValue);
-				fflush(stdout);
-			}
-			jrgba=iValue?JNI_TRUE:JNI_FALSE;
-		        if(ret==JNI_TRUE && frgba!=0) {
-			    (*env)->SetBooleanField(env, obj, frgba, 
-			                            jrgba);
-		        }
-
-		 } else {
-		 	fprintf(stderr,"GL4Java: fetching rgba state failed\n");
-		        fflush(stderr);
-		 }
-	    	 if(glXGetConfig( display, vgc.visual, 
-		                  GLX_STENCIL_SIZE, &iValue)==0)
-		 {
-	                if (JNI_TRUE==verbose) {
-				fprintf(stdout,"stencilBits: %d\n", iValue);
-				fflush(stdout);
-			}
-			jstencilBits=iValue;
-		        if(ret==JNI_TRUE && fstencilBits!=0) {
-	                    (*env)->SetIntField(env, obj, 
-	                                        fstencilBits, (jint)jstencilBits);
-		        }
-
-		 } else {
-		 	fprintf(stderr,"GL4Java: fetching stencilBits state failed\n");
-		        fflush(stderr);
-		 }
-	    	 if(glXGetConfig( display, vgc.visual,GLX_ACCUM_RED_SIZE, &iValue)==0 &&
-	    	    glXGetConfig( display, vgc.visual,GLX_ACCUM_GREEN_SIZE, &iValue1)==0 &&
-	    	    glXGetConfig( display, vgc.visual,GLX_ACCUM_BLUE_SIZE, &iValue2)==0 &&
-	    	    glXGetConfig( display, vgc.visual,GLX_ACCUM_ALPHA_SIZE, &iValue3)==0 )
-		 {
-	                if (JNI_TRUE==verbose) {
-				fprintf(stdout,"accumSize(red): %d\n", iValue);
-				fprintf(stdout,"accumSize(green): %d\n", iValue1);
-				fprintf(stdout,"accumSize(blue): %d\n", iValue2);
-				fprintf(stdout,"accumSize(alpha): %d\n", iValue3);
-				fflush(stdout);
-			}
-			jaccumSize=iValue+iValue1+iValue2+iValue3;
-		        if(ret==JNI_TRUE && faccumSize!=0) {
-	                    (*env)->SetIntField(env, obj, 
-	                                        faccumSize, (jint)jaccumSize);
-		        }
-
-		 } else {
-		 	fprintf(stderr,"GL4Java: fetching accumSize(red) state failed\n");
-		        fflush(stderr);
-		 }
+		 (void) setGLCapabilities (display, vgc.visual, &glCaps);
+
 		 if(JNI_TRUE==verbose)
 		 {
-			fprintf(stderr,"\nGL4Java: (using visuals: doubleBuffer=%d, stereoView=%d, rgba=%d, stencilBits=%d, accumSize=%d, ownWindow=%d)\n)\n",
-			    (int)jdoubleBuffer, (int)jstereoView, (int)jrgba,
-			    (int)jstencilBits, (int)jaccumSize, (int)jownwind);
-			fflush(stderr);
+			fprintf(stdout,"\nGL4Java: writing capabilities to GLContext's java object\n");
+			fflush(stdout);
 		 }
 
+		 (void) nativeGLCapabilities2JavaGLCapabilities
+		 		(env, jglCaps, &glCaps);
+
+	         if(ret==JNI_TRUE && fglCaps) {
+		    (*env)->SetObjectField(env, obj, fglCaps, jglCaps);
+	         }
 	    }
     }
 
@@ -769,3 +684,4 @@ Java_gl4java_GLContext_gljSwapNative( JNIEnv *env, jobject obj,
     return JNI_TRUE;
 }
 
+
diff --git a/CNativeCode/OpenGL_X11_common.c b/CNativeCode/OpenGL_X11_common.c
index 0c92a65..a23e8cf 100644
--- a/CNativeCode/OpenGL_X11_common.c
+++ b/CNativeCode/OpenGL_X11_common.c
@@ -96,6 +96,46 @@ int LIBAPIENTRY get_GC( Display *display, Window win, XVisualInfo *visual,
 }
 
 
+int LIBAPIENTRY setVisualAttribListByGLCapabilities( 
+					int visualAttribList[/*>=32*/],
+				        GLCapabilities *glCaps )
+{
+    int i=0;
+    visualAttribList[i++] = GLX_RED_SIZE;
+    visualAttribList[i++] = 1;
+    visualAttribList[i++] = GLX_GREEN_SIZE;
+    visualAttribList[i++] = 1;
+    visualAttribList[i++] = GLX_BLUE_SIZE;
+    visualAttribList[i++] = 1;
+    visualAttribList[i++] = GLX_DEPTH_SIZE;
+    visualAttribList[i++] = 1;
+    visualAttribList[i++] = GLX_ACCUM_RED_SIZE;
+    visualAttribList[i++] = (glCaps->accumRedBits>0)?1:0;
+    visualAttribList[i++] = GLX_ACCUM_GREEN_SIZE;
+    visualAttribList[i++] = (glCaps->accumGreenBits>0)?1:0;
+    visualAttribList[i++] = GLX_ACCUM_BLUE_SIZE;
+    visualAttribList[i++] = (glCaps->accumBlueBits>0)?1:0;
+
+    if(COLOR_RGBA == glCaps->color)
+    {
+	    visualAttribList[i++] = GLX_RGBA;
+	    visualAttribList[i++] = GLX_ALPHA_SIZE;
+	    visualAttribList[i++] = (glCaps->alphaBits>0)?1:0;
+	    visualAttribList[i++] = GLX_ACCUM_ALPHA_SIZE;
+	    visualAttribList[i++] = (glCaps->accumAlphaBits>0)?1:0;
+    }
+    if(BUFFER_DOUBLE==glCaps->buffer)
+	    visualAttribList[i++] = GLX_DOUBLEBUFFER;
+
+    if(STEREO_ON==glCaps->stereo)
+	    visualAttribList[i++] = GLX_STEREO;
+
+    visualAttribList[i++] = GLX_STENCIL_SIZE;
+    visualAttribList[i++] = glCaps->stencilBits;
+    visualAttribList[i] = None;
+    return i;
+}
+
 
 /**
  * Description for pWin:
@@ -109,11 +149,7 @@ VisualGC LIBAPIENTRY findVisualGlX( Display *display,
 			       Window rootWin,
 			       Window * pWin, 
 			       int width, int height,
-                               jboolean doubleBuffer, 
-                               jboolean stereoView,
-			       jboolean rgba,
-			       jint stencilBits,
-			       jint accumSize,
+    			       GLCapabilities * glCaps,
 			       jboolean * pOwnWin,
 			       GLXContext shareWith,
 			       jboolean offscreen,
@@ -122,8 +158,7 @@ VisualGC LIBAPIENTRY findVisualGlX( Display *display,
 			     )
 {
     Window newWin = 0;
-    int visualAttribList[32];
-    int i=0;
+    int visualAttribList[64];
     int j=0;
     int done=0;
     VisualGC vgc = { NULL, 0, 0 };
@@ -135,12 +170,14 @@ VisualGC LIBAPIENTRY findVisualGlX( Display *display,
      */
     XVisualInfo * visualList=NULL; /* the visual list, to be XFree-ed */
 
-    /* backup variables ... */
-    jboolean 	_rgba=rgba;
-    jint 	_stencilBits=stencilBits;
-    jint 	_accumSize=accumSize;
-    jboolean 	_stereoView=stereoView;
-    jboolean 	_doubleBuffer=doubleBuffer;
+    /* backup ... */
+    GLCapabilities _glCaps = *glCaps;
+
+    if(JNI_TRUE==verbose)
+    {
+	    fprintf(stdout, "GL4Java findVisualGlX: input capabilities:\n");
+	    printGLCapabilities ( glCaps );
+    }
 
     do {
             if(JNI_TRUE==verbose)
@@ -148,35 +185,19 @@ VisualGC LIBAPIENTRY findVisualGlX( Display *display,
 	         fprintf(stderr, "GL4Java: seeking visual loop# %d\n", j);
 	    }
 
-            i=0;
-	    visualAttribList[i++] = GLX_RED_SIZE;
-	    visualAttribList[i++] = 1;
-	    visualAttribList[i++] = GLX_GREEN_SIZE;
-	    visualAttribList[i++] = 1;
-	    visualAttribList[i++] = GLX_BLUE_SIZE;
-	    visualAttribList[i++] = 1;
-	    visualAttribList[i++] = GLX_DEPTH_SIZE;
-	    visualAttribList[i++] = 1;
-	    visualAttribList[i++] = GLX_ACCUM_RED_SIZE;
-	    visualAttribList[i++] = accumSize;
-	    visualAttribList[i++] = GLX_ACCUM_GREEN_SIZE;
-	    visualAttribList[i++] = accumSize;
-	    visualAttribList[i++] = GLX_ACCUM_BLUE_SIZE;
-	    visualAttribList[i++] = accumSize;
-
-	    if(JNI_TRUE==rgba)
+            if(glCaps->nativeVisualID>=0)
+	    {
+	    	vgc.visual = findVisualIdByID(&visualList, 
+		                              (int)(glCaps->nativeVisualID), 
+					       display, *pWin, verbose);
+	    }
+
+	    if(vgc.visual==NULL)
 	    {
-		    visualAttribList[i++] = GLX_RGBA;
-		    visualAttribList[i++] = GLX_ACCUM_ALPHA_SIZE;
-		    visualAttribList[i++] = accumSize;
+                glCaps->nativeVisualID=0;
+                (void) setVisualAttribListByGLCapabilities( 
+						visualAttribList, glCaps);
 	    }
-	    if(JNI_TRUE==doubleBuffer)
-		    visualAttribList[i++] = GLX_DOUBLEBUFFER;
-	    if(JNI_TRUE==stereoView)
-		    visualAttribList[i++] = GLX_STEREO;
-	    visualAttribList[i++] = GLX_STENCIL_SIZE;
-	    visualAttribList[i++] = (int)stencilBits;
-	    visualAttribList[i] = None;
 
             if(tryChooseVisual==JNI_TRUE && vgc.visual==NULL)
 	    {
@@ -187,13 +208,13 @@ VisualGC LIBAPIENTRY findVisualGlX( Display *display,
 		    {
 			if(vgc.visual!=NULL)
 			{
-			    fprintf(stderr, "glXChooseVisual: test visual(ID:%d(0x%X)):\n", 
+			    fprintf(stdout, "findVisualGlX.glXChooseVisual: found visual(ID:%d(0x%X))\n", 
 				(int) vgc.visual->visualid,
 				(int) vgc.visual->visualid);
-			    printVisualInfo ( display, vgc.visual);
-			} else
-			    fprintf(stderr, "glXChooseVisual: no visual\n");
-			fflush(stderr);
+			} else {
+			    fprintf(stdout, "findVisualGlX.glXChooseVisual: no visual\n");
+			}
+			fflush(stdout);
 		    }
 	    }
 
@@ -201,25 +222,17 @@ VisualGC LIBAPIENTRY findVisualGlX( Display *display,
 	    {
 	        vgc.visual = findVisualIdByFeature( &visualList, 
 				                      display, *pWin,
-	                                              doubleBuffer, stereoView,
-	                                              rgba, 
-						      stencilBits, 
-						      accumSize,
+						      glCaps,
 						      verbose);
 	    }
 
-	    if(vgc.visual==NULL)
-	    {
-	        vgc.visual = findVisualIdByFeature( &visualList, 
-				                      display, *pWin,
-	                                              doubleBuffer, stereoView,
-	                                              rgba, 
-						      stencilBits>0, 
-						      accumSize>0, verbose);
-            }
-
 	    if( *pOwnWin == JNI_TRUE && vgc.visual!=NULL)
 	    {
+		if(JNI_TRUE==verbose)
+		{
+		    fprintf(stdout, "findVisualGlX: CREATING OWN WINDOW !\n");
+		    fflush(stdout);
+		}
 		newWin = createOwnOverlayWin(display, 
 					     rootWin, 
 					     *pWin /* the parent */,
@@ -302,32 +315,41 @@ VisualGC LIBAPIENTRY findVisualGlX( Display *display,
 	    		vgc.visual=NULL;
 		    }
 
-		    /* Fall-Back ... */
+		    /**
+		     * Falling-Back the exact (min. requirement) parameters ..
+		     */
 		    if(*pOwnWin==JNI_FALSE && offscreen==JNI_FALSE) {
-			rgba=_rgba;
-			stencilBits=_stencilBits;
-			accumSize=_accumSize;
-			stereoView=_stereoView;
-			doubleBuffer=_doubleBuffer;
+		        *glCaps=_glCaps;
 			*pOwnWin=JNI_TRUE;
-		    } else if(accumSize>0 && offscreen==JNI_TRUE) {
-		        accumSize=0;
-		    } else if(doubleBuffer==JNI_FALSE && offscreen==JNI_TRUE) {
-		        doubleBuffer=JNI_TRUE;
-		    } else if(stencilBits>0) {
-		        stencilBits=0;
-		    } else if(stereoView==JNI_TRUE) {
-			stereoView=JNI_FALSE;
-		    } else if(rgba==JNI_TRUE) {
-			rgba=JNI_FALSE;
-		    } else if(doubleBuffer==JNI_TRUE) {
-			doubleBuffer=JNI_FALSE;
+		    } else if( (glCaps->accumRedBits>0 ||
+		                glCaps->accumGreenBits>0 ||
+		                glCaps->accumBlueBits>0 ||
+		                glCaps->accumAlphaBits>0
+			       ) && offscreen==JNI_TRUE
+			     ) 
+	            {
+		        glCaps->accumRedBits=0;
+			glCaps->accumGreenBits=0;
+			glCaps->accumBlueBits=0;
+			glCaps->accumAlphaBits=0;
+		    } else if(glCaps->buffer==BUFFER_SINGLE && 
+		              offscreen==JNI_TRUE) 
+		    {
+		        glCaps->buffer=BUFFER_DOUBLE;
+		    } else if(glCaps->stereo==STEREO_ON) {
+			glCaps->stereo=STEREO_OFF;
+		    } else if(glCaps->stencilBits>32) {
+		        glCaps->stencilBits=32;
+		    } else if(glCaps->stencilBits>16) {
+		        glCaps->stencilBits=16;
+		    } else if(glCaps->stencilBits>8) {
+		        glCaps->stencilBits=8;
+		    } else if(glCaps->stencilBits>0) {
+		        glCaps->stencilBits=0;
+		    } else if(glCaps->buffer==BUFFER_DOUBLE) {
+		        glCaps->buffer=BUFFER_SINGLE;
 		    } else if(tryChooseVisual==JNI_TRUE) {
-			rgba=_rgba;
-			stencilBits=_stencilBits;
-			accumSize=_accumSize;
-			stereoView=_stereoView;
-			doubleBuffer=_doubleBuffer;
+		        *glCaps=_glCaps;
 			*pOwnWin=JNI_FALSE;
 			tryChooseVisual=JNI_FALSE;
 		    } else done=1;
@@ -336,7 +358,9 @@ VisualGC LIBAPIENTRY findVisualGlX( Display *display,
 
     if(vgc.success==1 && JNI_TRUE==verbose)
     {
-	    fprintf(stderr, "\nfindVisualGlX vi(ID:%d): \n screen %d, depth %d, class %d,\n clrmapsz %d, bitsPerRGB %d, shared with %d\n",
+	    (void) setGLCapabilities (display, vgc.visual, glCaps);
+
+	    fprintf(stderr, "\nfindVisualGlX results vi(ID:%d): \n screen %d, depth %d, class %d,\n clrmapsz %d, bitsPerRGB %d, shared with %d\n",
 		(int)vgc.visual->visualid,
 		(int)vgc.visual->screen,
 		(int)vgc.visual->depth,
@@ -353,10 +377,11 @@ VisualGC LIBAPIENTRY findVisualGlX( Display *display,
 
 void LIBAPIENTRY printVisualInfo ( Display *display, XVisualInfo * vi)
 {
-    int dblBuffer, stereoView, rgbaMode, stencilSize;
-    int accumRedSize, accumGreenSize, accumBlueSize, accumAlphaSize;
+    GLCapabilities glCaps;
 
-    fprintf(stderr, "\nvi(ID:%d(0x%X)): \n screen %d, depth %d, class %d,\n clrmapsz %d, bitsPerRGB %d\n",
+    setGLCapabilities ( display, vi, &glCaps);
+
+    fprintf(stdout, "\nvi(ID:%d(0x%X)): \n screen %d, depth %d, class %d,\n clrmapsz %d, bitsPerRGB %d\n",
 	(int) vi->visualid,
 	(int) vi->visualid,
 	(int) vi->screen,
@@ -365,25 +390,7 @@ void LIBAPIENTRY printVisualInfo ( Display *display, XVisualInfo * vi)
 	(int) vi->colormap_size,
 	(int) vi->bits_per_rgb );
 
-    glXGetConfig( display, vi, GLX_DOUBLEBUFFER, &dblBuffer);
-    glXGetConfig( display, vi, GLX_STEREO, &stereoView);
-    glXGetConfig( display, vi, GLX_RGBA, &rgbaMode);
-    glXGetConfig( display, vi, GLX_STENCIL_SIZE, &stencilSize);
-    glXGetConfig( display, vi, GLX_ACCUM_RED_SIZE, &accumRedSize);
-    glXGetConfig( display, vi, GLX_ACCUM_GREEN_SIZE, &accumGreenSize);
-    glXGetConfig( display, vi, GLX_ACCUM_BLUE_SIZE, &accumBlueSize);
-    glXGetConfig( display, vi, GLX_ACCUM_ALPHA_SIZE, &accumAlphaSize);
-
-    fprintf(stderr, "\t doubleBuff: %d, ", dblBuffer);
-    fprintf(stderr, " stereo: %d, ", stereoView);
-    fprintf(stderr, " rgba: %d, ", rgbaMode);
-    fprintf(stderr, " stencilSize: %d !\n", stencilSize);
-    fprintf(stderr, "\t red accum: %d, ", accumRedSize);
-    fprintf(stderr, " green accum: %d, ", accumGreenSize);
-    fprintf(stderr, " blue accum: %d, ", accumBlueSize);
-    fprintf(stderr, " alpha accum: %d !\n", accumAlphaSize);
-
-    fflush(stderr);
+    printGLCapabilities ( &glCaps );
 }
 
 void LIBAPIENTRY printAllVisualInfo ( Display *disp, Window win, jboolean verbose)
@@ -423,45 +430,103 @@ void LIBAPIENTRY printAllVisualInfo ( Display *disp, Window win, jboolean verbos
 }
 
 int LIBAPIENTRY testVisualInfo ( Display *display, XVisualInfo * vi, 
-		            int dblBuffer, int stereoView, int rgbaMode, 
-			    int stencilSize, int accumSize)
+				 GLCapabilities *glCaps)
 {
-    int glxCfg;
+    GLCapabilities _glCaps;
+    setGLCapabilities ( display, vi, &_glCaps);
+
+    if(_glCaps.buffer<glCaps->buffer) return 0;
+
+    if(_glCaps.color<glCaps->color) return 0;
+
+    if(_glCaps.stereo<glCaps->stereo) return 0;
 
-    glXGetConfig( display, vi, GLX_DOUBLEBUFFER, &glxCfg);
-    if(glxCfg<dblBuffer) return 0;
+    /*
+    if(_glCaps.depthBits<glCaps->depthBits) return 0;
+    */
 
-    glXGetConfig( display, vi, GLX_STEREO, &glxCfg);
-    if(glxCfg<stereoView) return 0;
+    if(_glCaps.stencilBits<glCaps->stencilBits) return 0;
 
-    glXGetConfig( display, vi, GLX_RGBA, &glxCfg);
-    if(glxCfg<rgbaMode) return 0;
+    /*
+    if(_glCaps.redBits<glCaps->redBits) return 0;
 
-    glXGetConfig( display, vi, GLX_STENCIL_SIZE, &glxCfg);
-    if(glxCfg<stencilSize) return 0;
+    if(_glCaps.greenBits<glCaps->greenBits) return 0;
 
-    glXGetConfig(display, vi, GLX_ACCUM_RED_SIZE, &glxCfg);
-    if(glxCfg<accumSize) return 0;
+    if(_glCaps.blueBits<glCaps->blueBits) return 0;
+    */
 
-    glXGetConfig(display, vi, GLX_ACCUM_GREEN_SIZE, &glxCfg);
-    if(glxCfg<accumSize) return 0;
+    if(_glCaps.accumRedBits<glCaps->accumRedBits) return 0;
 
-    glXGetConfig(display, vi, GLX_ACCUM_BLUE_SIZE, &glxCfg);
-    if(glxCfg<accumSize) return 0;
+    if(_glCaps.accumGreenBits<glCaps->accumGreenBits) return 0;
 
-    if(rgbaMode>0) {
-	    glXGetConfig(display, vi, GLX_ACCUM_ALPHA_SIZE, &glxCfg);
-	    if(glxCfg<accumSize) return 0;
+    if(_glCaps.accumBlueBits<glCaps->accumBlueBits) return 0;
+
+    if(glCaps->color>0) {
+    	    /*
+	    if(_glCaps.alphaBits<glCaps->alphaBits) return 0;
+	    */
+	    if(_glCaps.accumAlphaBits<glCaps->accumAlphaBits) return 0;
     }
 
     return 1;
 }
 
 
+XVisualInfo * LIBAPIENTRY findVisualIdByID( XVisualInfo ** visualList, 
+					    int visualID, Display *disp,
+					    Window win, jboolean verbose)
+{
+    XVisualInfo    *    vi=0;
+    XVisualInfo    	viTemplate;
+    int 		i, numReturns;
+    XWindowAttributes 	xwa;
+    int 		done=0;
+
+    if(XGetWindowAttributes(disp, win, &xwa) == 0)
+    {
+	fprintf(stderr, "\nERROR while fetching XWindowAttributes\n");
+	fflush(stderr);
+	return 0;
+    }
+
+    viTemplate.screen = DefaultScreen( disp );
+    viTemplate.class = (xwa.visual)->class ;
+    viTemplate.depth = xwa.depth;
+
+    *visualList = XGetVisualInfo( disp, VisualScreenMask,
+	                          &viTemplate, &numReturns ); 
+
+    for(i=0; done==0 && i<numReturns; i++)
+    {
+        vi = &((*visualList)[i]);
+
+	if(vi->visualid==visualID)
+	{
+                if(JNI_TRUE==verbose)
+		{
+		    fprintf(stderr, "findVisualIdByID: Found matching Visual:\n");
+		    printVisualInfo ( disp, vi);
+		}
+		return vi;
+	}
+    }
+
+    if(JNI_TRUE==verbose)
+    {
+	    if( numReturns==0 )
+		fprintf(stderr, "findVisualIdByID: No available visuals. Exiting...\n" );
+	    else if( i>=numReturns )
+		fprintf(stderr, "findVisualIdByID: No matching visualID found ...\n" );
+	    fflush(stderr);
+    }
+     
+    XFree(*visualList);
+    *visualList=NULL;
+    return NULL;
+}
 XVisualInfo * LIBAPIENTRY findVisualIdByFeature( XVisualInfo ** visualList, 
                                   Display *disp, Window win,
-	                          int dblBuffer, int stereoView, int rgbaMode, 
-		                  int stencilSize, int accumSize,
+				  GLCapabilities *glCaps,
 				  jboolean verbose)
 {
     XVisualInfo    *    vi=0;
@@ -487,8 +552,7 @@ XVisualInfo * LIBAPIENTRY findVisualIdByFeature( XVisualInfo ** visualList,
     for(i=0; done==0 && i<numReturns; i++)
     {
         vi = &((*visualList)[i]);
-	if ( testVisualInfo ( disp, vi, dblBuffer, stereoView, rgbaMode, 
-			      stencilSize, accumSize) )
+	if ( testVisualInfo ( disp, vi, glCaps ) )
 	{
                 if(JNI_TRUE==verbose)
 		{
@@ -548,6 +612,86 @@ jboolean LIBAPIENTRY testX11Java()
     return ret;
 }
 
+jboolean LIBAPIENTRY setGLCapabilities ( Display * disp, 
+                                 XVisualInfo * visual, GLCapabilities *glCaps)
+{
+    int iValue=0;
+    int iValue1=0;
+    int iValue2=0;
+    int iValue3=0;
+
+    if(glXGetConfig( disp, visual, GLX_DOUBLEBUFFER, &iValue)==0)
+    {
+	glCaps->buffer=iValue?BUFFER_DOUBLE:BUFFER_SINGLE;
+    } else {
+	fprintf(stderr,"GL4Java: fetching doubleBuffer state failed\n");
+	fflush(stderr);
+    }
+
+    if(glXGetConfig( disp, visual, GLX_RGBA, &iValue)==0)
+    {
+	glCaps->color=iValue?COLOR_RGBA:COLOR_INDEX;
+    } else {
+	fprintf(stderr,"GL4Java: fetching rgba state failed\n");
+	fflush(stderr);
+    }
+
+    if(glXGetConfig( disp, visual, GLX_STEREO, &iValue)==0)
+    {
+	glCaps->stereo=iValue?STEREO_ON:STEREO_OFF;
+    } else {
+	fprintf(stderr,"GL4Java: fetching stereoView state failed\n");
+	fflush(stderr);
+    }
+
+    if(glXGetConfig( disp, visual, GLX_DEPTH_SIZE, &iValue)==0)
+    {
+        glCaps->depthBits = iValue;
+    } else {
+	fprintf(stderr,"GL4Java: fetching depthBits state failed\n");
+	fflush(stderr);
+    }
+
+    if(glXGetConfig( disp, visual, GLX_STENCIL_SIZE, &iValue)==0)
+    {
+        glCaps->stencilBits = iValue;
+    } else {
+	fprintf(stderr,"GL4Java: fetching stencilBits state failed\n");
+	fflush(stderr);
+    }
+
+    if(glXGetConfig(disp,visual,GLX_RED_SIZE, &iValue)==0 &&
+       glXGetConfig(disp,visual,GLX_GREEN_SIZE, &iValue1)==0 &&
+       glXGetConfig(disp,visual,GLX_BLUE_SIZE, &iValue2)==0 &&
+       glXGetConfig(disp,visual,GLX_ALPHA_SIZE, &iValue3)==0 )
+    {
+        glCaps->redBits = iValue;
+        glCaps->greenBits= iValue1;
+        glCaps->blueBits= iValue2;
+        glCaps->alphaBits= iValue3;
+    } else {
+	fprintf(stderr,"GL4Java: fetching rgba Size states failed\n");
+	fflush(stderr);
+    }
+
+    if(glXGetConfig(disp,visual,GLX_ACCUM_RED_SIZE, &iValue)==0 &&
+       glXGetConfig(disp,visual,GLX_ACCUM_GREEN_SIZE, &iValue1)==0 &&
+       glXGetConfig(disp,visual,GLX_ACCUM_BLUE_SIZE, &iValue2)==0 &&
+       glXGetConfig(disp,visual,GLX_ACCUM_ALPHA_SIZE, &iValue3)==0 )
+    {
+        glCaps->accumRedBits = iValue;
+        glCaps->accumGreenBits= iValue1;
+        glCaps->accumBlueBits= iValue2;
+        glCaps->accumAlphaBits= iValue3;
+    } else {
+	fprintf(stderr,"GL4Java: fetching rgba AccumSize states failed\n");
+	fflush(stderr);
+    }
+    glCaps->nativeVisualID=(long)visual->visualid;
+
+    return JNI_TRUE;
+}
+
 
 int LIBAPIENTRY x11gl_myErrorHandler(Display *pDisp, XErrorEvent *p_error)
 {
diff --git a/CNativeCode/OpenGL_X11_common.h b/CNativeCode/OpenGL_X11_common.h
index bba3040..1bb39c4 100644
--- a/CNativeCode/OpenGL_X11_common.h
+++ b/CNativeCode/OpenGL_X11_common.h
@@ -24,7 +24,7 @@
   	int           success;  /* 1: OK, 0: ERROR */
   } VisualGC;
   
-  
+
   /*
    * prototypes for functions local to this file scope
    */
@@ -33,35 +33,37 @@
                                  GLXContext *gc, GLXContext gc_share,
 				 jboolean verbose );
   
+  LIBAPI int LIBAPIENTRY setVisualAttribListByGLCapabilities( 
+					int visualAttribList[/*>=32*/],
+				        GLCapabilities *glCaps );
+
   LIBAPI VisualGC LIBAPIENTRY findVisualGlX( Display *display, 
-  			       Window rootWin,
-  			       Window * pWin, 
-  			       int width, int height,
-                               jboolean doubleBuffer, 
-                               jboolean stereoView,
-  			       jboolean rgba,
-  			       jint stencilBits,
-  			       jint accumSize,
-  			       jboolean * pOwnWin,
-  			       GLXContext shareWith,
-  			       jboolean offscreen,
-  			       Pixmap *pix,
+			       Window rootWin,
+			       Window * pWin, 
+			       int width, int height,
+    			       GLCapabilities *glCaps,
+			       jboolean * pOwnWin,
+			       GLXContext shareWith,
+			       jboolean offscreen,
+			       Pixmap *pix,
 			       jboolean verbose
-  			     );
+			     );
   
   LIBAPI void LIBAPIENTRY printVisualInfo ( Display *display, XVisualInfo * vi);
   LIBAPI void LIBAPIENTRY printAllVisualInfo ( Display *disp, Window win, 
   					       jboolean verbose);
   
   LIBAPI int LIBAPIENTRY testVisualInfo ( Display *display, XVisualInfo * vi, 
-  		            int dblBuffer, int stereoView, int rgbaMode, 
-  			    int stencilSize, int accumSize);
+    			                  GLCapabilities *glCaps);
   
+  LIBAPI XVisualInfo * LIBAPIENTRY findVisualIdByID( XVisualInfo ** visualList, 
+					    int visualID, Display *disp,
+					    Window win, jboolean verbose);
+
   LIBAPI XVisualInfo * LIBAPIENTRY findVisualIdByFeature( 
   				  XVisualInfo ** visualList, 
                                   Display *disp, Window win,
-  	                          int dblBuffer, int stereoView, int rgbaMode, 
-  		                  int stencilSize, int accumSize,
+				  GLCapabilities *glCaps,
 				  jboolean verbose);
   
   /* testX11Java does important implementation plattformspecific checks:
@@ -70,6 +72,9 @@
    */
   LIBAPI jboolean LIBAPIENTRY testX11Java();
   
+  LIBAPI jboolean LIBAPIENTRY setGLCapabilities ( Display * disp, 
+                                 XVisualInfo * visual, GLCapabilities *glCaps);
+
   LIBAPI int LIBAPIENTRY x11gl_myErrorHandler(
   				  Display *pDisp, XErrorEvent *p_error);
   
diff --git a/CNativeCode/OpenGL_X11_jawt.c b/CNativeCode/OpenGL_X11_jawt.c
index db7cd39..995e31a 100644
--- a/CNativeCode/OpenGL_X11_jawt.c
+++ b/CNativeCode/OpenGL_X11_jawt.c
@@ -162,31 +162,29 @@ Java_gl4java_GLContext_openOpenGLNative( JNIEnv *env, jobject obj,
     jfieldID fdisplayHandle=0, fpixmapHandle=0;
     jfieldID fverbose=0;
     jfieldID fglContext=0;
-    jfieldID fstereoView=0, frgba=0, fstencilBits=0, 
-             faccumSize=0, fownwind=0;
-    jfieldID fdoubleBuffer=0, foffScreenRenderer=0;
+
+    jfieldID fglCaps=0;
+    jfieldID foffScreenRenderer=0, fownwind=0;
 
     jfieldID fcreatewinw = 0, fcreatewinh = 0;
     jfieldID fshareWith = 0;
     jboolean joffScreenRenderer=JNI_FALSE;
-    jboolean jdoubleBuffer=JNI_TRUE;
-    jboolean jstereoView=JNI_FALSE;
-    jboolean jrgba=JNI_TRUE;
-    jint jstencilBits=0;
-    jint jaccumSize=0;
     jboolean jownwind = JNI_FALSE ;
     jint jcreatewinw = 0, jcreatewinh = 0;
     GLXContext jshareWith = 0;
 
+    jobject  jglCaps=0;
+    GLCapabilities glCaps;
+
     /* these variables will be mapped in the java-object ! */
     JAWTDataHolder * pData = NULL;
     Display * display = 0;
     Window rootwini  = 0;
     Window theWindow  = 0;
     Pixmap pix=0;
-    jclass AwtComponent = (*env)->FindClass(env, "Ljava/awt/Component;");
-
-    int iValue=0, iValue1=0, iValue2=0, iValue3=0;
+    jthrowable exc;
+    jclass _GLCapabilities= 0;
+    jclass _AwtComponent=0;
 
     cls = (*env)->GetObjectClass(env, obj);
     if(cls==0) 
@@ -227,33 +225,39 @@ Java_gl4java_GLContext_openOpenGLNative( JNIEnv *env, jobject obj,
     }
 
     if(ret==JNI_TRUE) {
-	    fdoubleBuffer = (*env)->GetFieldID(env, cls, "doubleBuffer", "Z");
-	    if (fdoubleBuffer == 0) ret= JNI_FALSE;
-	    else jdoubleBuffer =(*env)->GetBooleanField(env, obj, fdoubleBuffer);
-    }
-
-    if(ret==JNI_TRUE) {
-	    fstereoView = (*env)->GetFieldID(env, cls, "stereoView", "Z");
-	    if (fstereoView == 0) ret= JNI_FALSE;
-	    else jstereoView =(*env)->GetBooleanField(env, obj, fstereoView);
+	    fglCaps = (*env)->GetFieldID(env, cls, "glCaps", "Lgl4java/GLCapabilities;");
+	    if (fglCaps == 0) ret= JNI_FALSE;
+	    else jglCaps =(*env)->GetObjectField(env, obj, fglCaps);
     }
 
-    if(ret==JNI_TRUE) {
-	    frgba = (*env)->GetFieldID(env, cls, "rgba", "Z");
-	    if (frgba == 0) ret= JNI_FALSE;
-	    else jrgba =(*env)->GetBooleanField(env, obj, frgba);
+    _GLCapabilities= (*env)->FindClass(env, "Lgl4java/GLCapabilities;");
+    exc = (*env)->ExceptionOccurred(env);
+    if(exc) {
+          if(JNI_TRUE==verbose)
+	  {
+             fprintf(stderr, "GL4Java: openOpen FindClass gl4java/GLCapabilities failed, cannot check glCaps object\n");
+	     (*env)->ExceptionDescribe(env);
+             fflush(stderr);
+	  }
+	  (*env)->ExceptionClear(env);
+	  _GLCapabilities=0;
     }
+    exc=0;
 
-    if(ret==JNI_TRUE) {
-	    fstencilBits = (*env)->GetFieldID(env, cls, "stencilBits", "I");
-	    if (fstencilBits == 0) ret= JNI_FALSE;
-	    else jstencilBits =(*env)->GetIntField(env, obj, fstencilBits);
+    if( _GLCapabilities!=0 &&
+        (*env)->IsInstanceOf(env, jglCaps, _GLCapabilities)==JNI_FALSE )
+    {
+      fprintf(stderr,"\nGL4Java openOpenGL ERROR: glCaps is not instanceof gl4java/GLCapabilities !\n");
+      fflush(stderr);
+      return JNI_FALSE;
     }
 
-    if(ret==JNI_TRUE) {
-	    faccumSize = (*env)->GetFieldID(env, cls, "accumSize", "I");
-	    if (faccumSize == 0) ret= JNI_FALSE;
-	    else jaccumSize =(*env)->GetIntField(env, obj, faccumSize);
+    if(JNI_TRUE != javaGLCapabilities2NativeGLCapabilities
+                           ( env, jglCaps, &glCaps ) )
+    {
+      fprintf(stderr,"\nGL4Java ERROR: glCaps Object is not valid !\n");
+      fflush(stderr);
+      return JNI_FALSE;
     }
 
     if(ret==JNI_TRUE) {
@@ -302,14 +306,6 @@ Java_gl4java_GLContext_openOpenGLNative( JNIEnv *env, jobject obj,
 	    jownwind = JNI_FALSE;
     }
 
-    if(JNI_TRUE==verbose)
-    {
-	fprintf(stderr,"\nGL4Java:  (try to use visuals: doubleBuffer=%d, stereoView=%d, rgba=%d, stencilBits=%d, accumSize=%d, ownWindow=%d)\n)\n",
-	    (int)jdoubleBuffer, (int)jstereoView, (int)jrgba, (int)jstencilBits, (int)jaccumSize,
-	    (int)jownwind );
-	fflush(stderr);
-    }
-
     if(ret==JNI_TRUE) {
 	    fdisplayHandle = (*env)->GetFieldID(env, cls, "displayHandle", "J");
 	    if (fdisplayHandle == 0) ret= JNI_FALSE;
@@ -320,6 +316,20 @@ Java_gl4java_GLContext_openOpenGLNative( JNIEnv *env, jobject obj,
 	    if (fglContext == 0) ret= JNI_FALSE;
     }
 
+    _AwtComponent= (*env)->FindClass(env, "Ljava/awt/Component;");
+    exc = (*env)->ExceptionOccurred(env);
+    if(exc) {
+          if(JNI_TRUE==verbose)
+	  {
+             fprintf(stderr, "GL4Java: openOpen FindClass java/awt/Component failed, cannot check canvas object\n");
+	     (*env)->ExceptionDescribe(env);
+             fflush(stderr);
+	  }
+	  (*env)->ExceptionClear(env);
+	  _AwtComponent=0;
+    }
+    exc=0;
+
     if(ret==JNI_TRUE) {
 	if (canvas == 0) 
 	{
@@ -327,7 +337,8 @@ Java_gl4java_GLContext_openOpenGLNative( JNIEnv *env, jobject obj,
 		fprintf(stderr,"\nGL4Java ERROR: canvas == NULL !\n");
 		fflush(stderr);
 	} else {
-		if( (*env)->IsInstanceOf(env, canvas, AwtComponent)==JNI_FALSE )
+		if( _AwtComponent!=0 &&
+		    (*env)->IsInstanceOf(env, canvas, _AwtComponent)==JNI_FALSE)
 		{
 		  fprintf(stderr,"\nGL4Java ERROR: canvas is not instanceof java/awt/Component !\n");
 		  fflush(stderr);
@@ -391,6 +402,14 @@ Java_gl4java_GLContext_openOpenGLNative( JNIEnv *env, jobject obj,
 	    }
     }
 
+	/*
+	    if(ret==JNI_TRUE)
+		XSetErrorHandler(x11gl_myErrorHandler);
+
+	    if(ret==JNI_TRUE)
+		XSetIOErrorHandler(x11gl_myIOErrorHandler);
+	*/
+
     if(JNI_TRUE==ret && JNI_TRUE==verbose)
     {
 	if(joffScreenRenderer==JNI_TRUE)
@@ -416,6 +435,7 @@ Java_gl4java_GLContext_openOpenGLNative( JNIEnv *env, jobject obj,
 		fprintf(stdout, "GLX by %s Version %s\n", 
 			glXGetClientString(display, GLX_VENDOR),
 			glXGetClientString(display, GLX_VERSION));
+		fflush(stdout);
 	}
       }
     }
@@ -430,18 +450,21 @@ Java_gl4java_GLContext_openOpenGLNative( JNIEnv *env, jobject obj,
 
             vgc = findVisualGlX( display, rootwini, &theWindow,
 	                         (int)jcreatewinw, (int)jcreatewinh, 
-                                 jdoubleBuffer, jstereoView, jrgba, 
-				 jstencilBits, jaccumSize,
+				 &glCaps,
 				 &jownwind, jshareWith,
 				 joffScreenRenderer, &pix, verbose);
 
-	    if(vgc.success == 0 && jrgba==JNI_TRUE)
+	    if(vgc.success == 0 && glCaps.color==COLOR_RGBA)
 	    {
-	        jrgba=JNI_FALSE;
+		if (JNI_TRUE==verbose) {
+			fprintf(stdout, "GL4Java switching color:=COLOR_INDEX\n");
+			fflush(stdout);
+		}
+	        glCaps.color=COLOR_INDEX;
+
                 vgc = findVisualGlX( display, rootwini, &theWindow,
 	                             (int)jcreatewinw, (int)jcreatewinh, 
-                                     jdoubleBuffer, jstereoView, jrgba, 
-				     jstencilBits, jaccumSize,
+				     &glCaps,
 				     &jownwind, jshareWith,
 				     joffScreenRenderer, &pix, verbose);
 	    }
@@ -465,104 +488,18 @@ Java_gl4java_GLContext_openOpenGLNative( JNIEnv *env, jobject obj,
 	         	pData->dsi_win_created=1;
 		 }
 
-	    	 if(glXGetConfig( display, vgc.visual, 
-		                  GLX_DOUBLEBUFFER, &iValue)==0)
-		 {
-	                if (JNI_TRUE==verbose) {
-				fprintf(stdout,"doubleBuffer: %d\n", iValue);
-				fflush(stdout);
-			}
-			jdoubleBuffer=iValue?JNI_TRUE:JNI_FALSE;
-		        if(ret==JNI_TRUE && fdoubleBuffer!=0) {
-			    (*env)->SetBooleanField(env, obj, fdoubleBuffer, 
-			                            jdoubleBuffer);
-		        }
-
-		 } else {
-		 	fprintf(stderr,"GL4Java: fetching doubleBuffer state failed\n");
-		        fflush(stderr);
-		 }
-	    	 if(glXGetConfig( display, vgc.visual, 
-		                  GLX_STEREO, &iValue)==0)
-		 {
-	                if (JNI_TRUE==verbose) {
-				fprintf(stdout,"stereoView: %d\n", iValue);
-				fflush(stdout);
-			}
-			jstereoView=iValue?JNI_TRUE:JNI_FALSE;
-		        if(ret==JNI_TRUE && fstereoView!=0) {
-			    (*env)->SetBooleanField(env, obj, fstereoView, 
-			                            jstereoView);
-		        }
-
-		 } else {
-		 	fprintf(stderr,"GL4Java: fetching stereoView state failed\n");
-		        fflush(stderr);
-		 }
-	    	 if(glXGetConfig( display, vgc.visual, 
-		                  GLX_RGBA, &iValue)==0)
-		 {
-	                if (JNI_TRUE==verbose) {
-				fprintf(stdout,"rgba: %d\n", iValue);
-				fflush(stdout);
-			}
-			jrgba=iValue?JNI_TRUE:JNI_FALSE;
-		        if(ret==JNI_TRUE && frgba!=0) {
-			    (*env)->SetBooleanField(env, obj, frgba, 
-			                            jrgba);
-		        }
-
-		 } else {
-		 	fprintf(stderr,"GL4Java: fetching rgba state failed\n");
-		        fflush(stderr);
-		 }
-	    	 if(glXGetConfig( display, vgc.visual, 
-		                  GLX_STENCIL_SIZE, &iValue)==0)
-		 {
-	                if (JNI_TRUE==verbose) {
-				fprintf(stdout,"stencilBits: %d\n", iValue);
-				fflush(stdout);
-			}
-			jstencilBits=iValue;
-		        if(ret==JNI_TRUE && fstencilBits!=0) {
-	                    (*env)->SetIntField(env, obj, 
-	                                        fstencilBits, (jint)jstencilBits);
-		        }
-
-		 } else {
-		 	fprintf(stderr,"GL4Java: fetching stencilBits state failed\n");
-		        fflush(stderr);
-		 }
-	    	 if(glXGetConfig( display, vgc.visual,GLX_ACCUM_RED_SIZE, &iValue)==0 &&
-	    	    glXGetConfig( display, vgc.visual,GLX_ACCUM_GREEN_SIZE, &iValue1)==0 &&
-	    	    glXGetConfig( display, vgc.visual,GLX_ACCUM_BLUE_SIZE, &iValue2)==0 &&
-	    	    glXGetConfig( display, vgc.visual,GLX_ACCUM_ALPHA_SIZE, &iValue3)==0 )
-		 {
-	                if (JNI_TRUE==verbose) {
-				fprintf(stdout,"accumSize(red): %d\n", iValue);
-				fprintf(stdout,"accumSize(green): %d\n", iValue1);
-				fprintf(stdout,"accumSize(blue): %d\n", iValue2);
-				fprintf(stdout,"accumSize(alpha): %d\n", iValue3);
-				fflush(stdout);
-			}
-			jaccumSize=iValue+iValue1+iValue2+iValue3;
-		        if(ret==JNI_TRUE && faccumSize!=0) {
-	                    (*env)->SetIntField(env, obj, 
-	                                        faccumSize, (jint)jaccumSize);
-		        }
-
-		 } else {
-		 	fprintf(stderr,"GL4Java: fetching accumSize(red) state failed\n");
-		        fflush(stderr);
-		 }
 		 if(JNI_TRUE==verbose)
 		 {
-			fprintf(stderr,"\nGL4Java: (using visuals: doubleBuffer=%d, stereoView=%d, rgba=%d, stencilBits=%d, accumSize=%d, ownWindow=%d)\n)\n",
-			    (int)jdoubleBuffer, (int)jstereoView, (int)jrgba,
-			    (int)jstencilBits, (int)jaccumSize, (int)jownwind);
-			fflush(stderr);
+			fprintf(stdout,"\nGL4Java: writing capabilities to GLContext's java object\n");
+			fflush(stdout);
 		 }
 
+		 (void) nativeGLCapabilities2JavaGLCapabilities
+		 		(env, jglCaps, &glCaps);
+
+	         if(ret==JNI_TRUE && fglCaps) {
+		    (*env)->SetObjectField(env, obj, fglCaps, jglCaps);
+	         }
 	    }
     }
 
@@ -699,7 +636,6 @@ Java_gl4java_GLContext_gljMakeCurrentNative( JNIEnv *env, jobject obj,
 	                         GET_USED_WINDOW(thisWin),
 	                         (GLXContext)((PointerHolder)glContext) ) ) 
 	    {
-   extern GLenum glGetError ( void ) ;
 		fprintf(stderr, "GL4Java: gljMakeCurrent failed with GC\n  Another thread may be use it now ...\n");
 		fflush(stderr);
 	        jawt_close_unlock(env, pData, JNI_FALSE);
@@ -960,3 +896,4 @@ Java_gl4java_GLContext_gljSwapNative( JNIEnv *env, jobject obj,
     return JNI_TRUE;
 }
 
+
diff --git a/CNativeCode/OpenGL_misc.c b/CNativeCode/OpenGL_misc.c
index 5f9d502..201a048 100644
--- a/CNativeCode/OpenGL_misc.c
+++ b/CNativeCode/OpenGL_misc.c
@@ -31,6 +31,250 @@ static const char * _lib_version_=  __LIB_VERSION__ ;
 	#define CALLBACK
 #endif
 
+
+#ifdef  J_GET_INT_FIELD
+	#undef  J_GET_INT_FIELD
+#endif
+#define J_GET_INT_FIELD(ATTRIBUTE_NAME, ATTRIBUTE_NAME_STR) if(ok==JNI_TRUE) { f ## ATTRIBUTE_NAME = (*env)->GetFieldID(env, cls, ATTRIBUTE_NAME_STR, "I"); if ( f ## ATTRIBUTE_NAME == 0) ok= JNI_FALSE; }
+
+#ifdef  J_GET_INT_FIELD_VAL
+	#undef  J_GET_INT_FIELD_VAL
+#endif
+#define J_GET_INT_FIELD_VAL(ATTRIBUTE_NAME, ATTRIBUTE_NAME_STR) if(ok==JNI_TRUE) { f ## ATTRIBUTE_NAME = (*env)->GetFieldID(env, cls, ATTRIBUTE_NAME_STR, "I"); if ( f ## ATTRIBUTE_NAME == 0) ok= JNI_FALSE; else glCaps-> ## ATTRIBUTE_NAME = (int) ((*env)->GetIntField(env, capsObj, f ## ATTRIBUTE_NAME)); }
+
+#ifdef  J_SET_INT_FIELD_VAL
+	#undef  J_SET_INT_FIELD_VAL
+#endif
+#define J_SET_INT_FIELD_VAL(ATTRIBUTE_NAME) if(ok==JNI_TRUE && f ## ATTRIBUTE_NAME!=0) { (*env)->SetIntField(env, capsObj, f ## ATTRIBUTE_NAME, (jint) glCaps-> ## ATTRIBUTE_NAME); }
+
+#ifdef  J_GET_LONG_FIELD
+	#undef  J_GET_LONG_FIELD
+#endif
+#define J_GET_LONG_FIELD(ATTRIBUTE_NAME, ATTRIBUTE_NAME_STR) if(ok==JNI_TRUE) { f ## ATTRIBUTE_NAME = (*env)->GetFieldID(env, cls, ATTRIBUTE_NAME_STR, "J"); if ( f ## ATTRIBUTE_NAME == 0) ok= JNI_FALSE; }
+
+
+#ifdef  J_GET_LONG_FIELD_VAL
+	#undef  J_GET_LONG_FIELD_VAL
+#endif
+#define J_GET_LONG_FIELD_VAL(ATTRIBUTE_NAME, ATTRIBUTE_NAME_STR) if(ok==JNI_TRUE) { f ## ATTRIBUTE_NAME = (*env)->GetFieldID(env, cls, ATTRIBUTE_NAME_STR, "J"); if ( f ## ATTRIBUTE_NAME == 0) ok= JNI_FALSE; else glCaps-> ## ATTRIBUTE_NAME = (long) ((*env)->GetLongField(env, capsObj, f ## ATTRIBUTE_NAME)); }
+
+#ifdef  J_SET_LONG_FIELD_VAL
+	#undef  J_SET_LONG_FIELD_VAL
+#endif
+#define J_SET_LONG_FIELD_VAL(ATTRIBUTE_NAME) if(ok==JNI_TRUE && f ## ATTRIBUTE_NAME!=0) { (*env)->SetLongField(env, capsObj, f ## ATTRIBUTE_NAME, (jlong) glCaps-> ## ATTRIBUTE_NAME); }
+
+jboolean LIBAPIENTRY javaGLCapabilities2NativeGLCapabilities 
+					     ( JNIEnv *env, 
+		                               jobject capsObj, 
+					       GLCapabilities *glCaps )
+{
+    jfieldID fbuffer=0;
+    jfieldID fcolor=0;
+    jfieldID fstereo=0;
+    jfieldID fdepthBits=0;
+    jfieldID fstencilBits=0;
+    jfieldID fredBits=0;
+    jfieldID fgreenBits=0;
+    jfieldID fblueBits=0;
+    jfieldID falphaBits=0;
+    jfieldID faccumRedBits=0;
+    jfieldID faccumGreenBits=0;
+    jfieldID faccumBlueBits=0;
+    jfieldID faccumAlphaBits=0;
+    jfieldID fnativeVisualID=0;
+
+    jclass cls = 0;
+
+    jboolean ok = JNI_TRUE;
+
+    /**
+     *
+    jthrowable exc;
+    jclass _GLCapabilities= 0;
+
+    _GLCapabilities= (*env)->FindClass(env, "Lgl4java/GLCapabilities;");
+    exc = (*env)->ExceptionOccurred(env);
+    if(exc) {
+          fprintf(stderr, "GL4Java: glcaps java2native FindClass gl4java/GLCapabilities failed, cannot check glCaps object\n");
+	  (*env)->ExceptionClear(env);
+          fflush(stderr);
+	  _GLCapabilities=0;
+    }
+    exc=0;
+
+
+    if(_GLCapabilities!=0 &&
+        (*env)->IsInstanceOf(env, capsObj, _GLCapabilities)==JNI_FALSE )
+    {
+      fprintf(stderr,"\nGL4Java glcaps java2native ERROR: capsObj is not instanceof gl4java/GLCapabilities !\n");
+      fflush(stderr);
+      return JNI_FALSE;
+    }
+    */
+							                  
+    cls = (*env)->GetObjectClass(env, capsObj);
+    if(cls==0) 
+    {
+        fprintf(stderr,"GL4Java ERROR: clazz not accessible\n");
+	fflush(stderr);
+        return JNI_FALSE;
+    }
+
+    if(glCaps==0) 
+    {
+        fprintf(stderr,"GL4Java ERROR: native argument GLCapabilities not given\n");
+	fflush(stderr);
+        return JNI_FALSE;
+    }
+
+    J_GET_INT_FIELD_VAL(buffer, "buffer")
+    J_GET_INT_FIELD_VAL(color, "color")
+    J_GET_INT_FIELD_VAL(stereo, "stereo")
+    J_GET_INT_FIELD_VAL(depthBits, "depthBits")
+    J_GET_INT_FIELD_VAL(stencilBits, "stencilBits")
+    J_GET_INT_FIELD_VAL(redBits, "redBits")
+    J_GET_INT_FIELD_VAL(greenBits, "greenBits")
+    J_GET_INT_FIELD_VAL(blueBits, "blueBits")
+    J_GET_INT_FIELD_VAL(alphaBits, "alphaBits")
+    J_GET_INT_FIELD_VAL(accumRedBits, "accumRedBits")
+    J_GET_INT_FIELD_VAL(accumGreenBits, "accumGreenBits")
+    J_GET_INT_FIELD_VAL(accumBlueBits, "accumBlueBits")
+    J_GET_INT_FIELD_VAL(accumAlphaBits, "accumAlphaBits")
+    J_GET_LONG_FIELD_VAL(nativeVisualID, "nativeVisualID")
+
+    if(JNI_TRUE!=ok)
+    {
+        fprintf(stderr,"GL4Java ERROR: gl4java/GLCapabilities fields not accessible\n");
+	fflush(stderr);
+        return JNI_FALSE;
+    }
+
+    return JNI_TRUE;
+}
+
+jboolean LIBAPIENTRY nativeGLCapabilities2JavaGLCapabilities 
+				     ( JNIEnv *env, 
+				       jobject capsObj, 
+				       GLCapabilities *glCaps )
+{
+    jfieldID fbuffer=0;
+    jfieldID fcolor=0;
+    jfieldID fstereo=0;
+    jfieldID fdepthBits=0;
+    jfieldID fstencilBits=0;
+    jfieldID fredBits=0;
+    jfieldID fgreenBits=0;
+    jfieldID fblueBits=0;
+    jfieldID falphaBits=0;
+    jfieldID faccumRedBits=0;
+    jfieldID faccumGreenBits=0;
+    jfieldID faccumBlueBits=0;
+    jfieldID faccumAlphaBits=0;
+    jfieldID fnativeVisualID=0;
+
+    jclass cls = 0;
+
+    jboolean ok = JNI_TRUE;
+
+    /**
+    jthrowable exc;
+    jclass _GLCapabilities= 0;
+
+    _GLCapabilities= (*env)->FindClass(env, "Lgl4java/GLCapabilities;");
+    exc = (*env)->ExceptionOccurred(env);
+    if(exc) {
+          fprintf(stderr, "GL4Java: glcaps native2java FindClass gl4java/GLCapabilities failed, cannot check glCaps object\n");
+	  (*env)->ExceptionClear(env);
+          fflush(stderr);
+	  _GLCapabilities=0;
+    }
+    exc=0;
+
+
+    if(_GLCapabilities!=0 &&
+        (*env)->IsInstanceOf(env, capsObj, _GLCapabilities)==JNI_FALSE )
+    {
+      fprintf(stderr,"\nGL4Java glcaps native2java ERROR: capsObj is not instanceof gl4java/GLCapabilities !\n");
+      fflush(stderr);
+      return JNI_FALSE;
+    }
+    */
+							                  
+    cls = (*env)->GetObjectClass(env, capsObj);
+    if(cls==0) 
+    {
+        fprintf(stderr,"GL4Java ERROR: clazz not accessible\n");
+	fflush(stderr);
+        return JNI_FALSE;
+    }
+
+    J_GET_INT_FIELD(buffer, "buffer")
+    J_GET_INT_FIELD(color, "color")
+    J_GET_INT_FIELD(stereo, "stereo")
+    J_GET_INT_FIELD(depthBits, "depthBits")
+    J_GET_INT_FIELD(stencilBits, "stencilBits")
+    J_GET_INT_FIELD(redBits, "redBits")
+    J_GET_INT_FIELD(greenBits, "greenBits")
+    J_GET_INT_FIELD(blueBits, "blueBits")
+    J_GET_INT_FIELD(alphaBits, "alphaBits")
+    J_GET_INT_FIELD(accumRedBits, "accumRedBits")
+    J_GET_INT_FIELD(accumGreenBits, "accumGreenBits")
+    J_GET_INT_FIELD(accumBlueBits, "accumBlueBits")
+    J_GET_INT_FIELD(accumAlphaBits, "accumAlphaBits")
+    J_GET_LONG_FIELD(nativeVisualID, "nativeVisualID")
+
+    if(JNI_TRUE!=ok)
+    {
+        fprintf(stderr,"GL4Java ERROR: gl4java/GLCapabilities fields not accessible\n");
+	fflush(stderr);
+        return JNI_FALSE;
+    }
+
+    J_SET_INT_FIELD_VAL(buffer);
+    J_SET_INT_FIELD_VAL(color);
+    J_SET_INT_FIELD_VAL(stereo);
+    J_SET_INT_FIELD_VAL(depthBits);
+    J_SET_INT_FIELD_VAL(stencilBits);
+    J_SET_INT_FIELD_VAL(redBits);
+    J_SET_INT_FIELD_VAL(greenBits);
+    J_SET_INT_FIELD_VAL(blueBits);
+    J_SET_INT_FIELD_VAL(alphaBits);
+    J_SET_INT_FIELD_VAL(accumRedBits);
+    J_SET_INT_FIELD_VAL(accumGreenBits);
+    J_SET_INT_FIELD_VAL(accumBlueBits);
+    J_SET_INT_FIELD_VAL(accumAlphaBits);
+    J_GET_LONG_FIELD_VAL(nativeVisualID, "nativeVisualID")
+
+    if(JNI_TRUE!=ok)
+    {
+        fprintf(stderr,"GL4Java ERROR: gl4java/GLCapabilities fields not writable\n");
+	fflush(stderr);
+        return JNI_FALSE;
+    }
+
+    return JNI_TRUE;
+}
+	
+void LIBAPIENTRY printGLCapabilities ( GLCapabilities *glCaps )
+{
+    fprintf(stdout, "\t doubleBuff: %d, ", (int)glCaps->buffer);
+    fprintf(stdout, " rgba: %d, ", (int)glCaps->color);
+    fprintf(stdout, " stereo: %d, ", (int)glCaps->stereo);
+    fprintf(stdout, " depthSize: %d, ", (int)glCaps->depthBits);
+    fprintf(stdout, " stencilSize: %d !\n", (int)glCaps->stencilBits);
+    fprintf(stdout, "\t red: %d, ", (int)glCaps->redBits);
+    fprintf(stdout, " green: %d, ", (int)glCaps->greenBits);
+    fprintf(stdout, " blue: %d, ", (int)glCaps->blueBits);
+    fprintf(stdout, " alpha: %d !\n", (int)glCaps->alphaBits);
+    fprintf(stdout, "\t red accum: %d, ", (int)glCaps->accumRedBits);
+    fprintf(stdout, " green accum: %d, ", (int)glCaps->accumGreenBits);
+    fprintf(stdout, " blue accum: %d, ", (int)glCaps->accumBlueBits);
+    fprintf(stdout, " alpha accum: %d !\n", (int)glCaps->accumAlphaBits);
+    fprintf(stdout, "\t nativeVisualID: %ld !\n", (long)glCaps->nativeVisualID);
+
+    fflush(stdout);
+}
+
 jboolean LIBAPIENTRY testJavaGLTypes(jboolean verbose)
 {
     jboolean ret=JNI_TRUE;
diff --git a/CNativeCode/OpenGL_misc.h b/CNativeCode/OpenGL_misc.h
index 368e2f7..1438877 100644
--- a/CNativeCode/OpenGL_misc.h
+++ b/CNativeCode/OpenGL_misc.h
@@ -28,6 +28,60 @@
 		typedef long PointerHolder;
 	#endif
 
+	  /* to match the GLCapabilities values .. */
+
+	  #define BUFFER_SINGLE 0
+	  #define BUFFER_DOUBLE 1
+	 
+	  #define COLOR_INDEX 0
+	  #define COLOR_RGBA  1
+	  
+	  #define STEREO_OFF 0
+	  #define STEREO_ON  1
+
+	  typedef struct {
+		  jint buffer;
+		  jint color;
+		  jint stereo;
+		  jint depthBits;
+		  jint stencilBits;
+
+		  jint redBits;
+		  jint greenBits;
+		  jint blueBits;
+		  jint alphaBits;
+		  jint accumRedBits;
+		  jint accumGreenBits;
+		  jint accumBlueBits;
+		  jint accumAlphaBits;
+
+		  jlong nativeVisualID;
+	  } GLCapabilities;
+		
+	/**
+	 * gets the capabilities outta java's GLCapabilities object 'capsObj'
+	 * and puts those values to the C-Struct GLCapabilities !
+	 */
+	LIBAPI jboolean LIBAPIENTRY javaGLCapabilities2NativeGLCapabilities 
+						     ( JNIEnv *env, 
+						       jobject capsObj, 
+						       GLCapabilities *glCaps );
+
+	/**
+	 * gets the capabilities outta the C-Struct GLCapabilities
+	 * and puts those values to java's GLCapabilities object 'capsObj'
+	 */
+	LIBAPI jboolean LIBAPIENTRY nativeGLCapabilities2JavaGLCapabilities 
+						     ( JNIEnv *env, 
+						       jobject capsObj, 
+						       GLCapabilities *glCaps );
+
+		
+	/**
+	 * prints the contents of the GLCapabilities to stdout !
+	 */
+	LIBAPI void LIBAPIENTRY printGLCapabilities ( GLCapabilities *glCaps );
+
 	/* testJavaGLTypes does important implementation plattformspecific checks:
 	 *
 	 * o do fit the JNI <-> GL Variables-Type Mapping 
diff --git a/CNativeCode/jawt_misc.c b/CNativeCode/jawt_misc.c
index 4696773..d884406 100644
--- a/CNativeCode/jawt_misc.c
+++ b/CNativeCode/jawt_misc.c
@@ -338,12 +338,12 @@ jawt_unlock (JNIEnv *env, JAWTDataHolder *pJData, jboolean verbose)
   }
   pJData->dsi=0;
  
-  // Unlock the drawing surface
-  if ( (pJData->lock & JAWT_LOCK_ERROR) == 0 )
+  // Unlock the drawing surface
+  if ( (pJData->lock & JAWT_LOCK_ERROR) == 0 )
   {
 	pJData->ds->Unlock(pJData->ds);
 	exc = (*env)->ExceptionOccurred(env);
-	if(exc) 
+	if(exc) 
 	{
           if(verbose)
           {
@@ -355,11 +355,9 @@ jawt_unlock (JNIEnv *env, JAWTDataHolder *pJData, jboolean verbose)
 			(*env)->ExceptionDescribe(env);
 		  (*env)->ExceptionClear(env);
 		  return pJData->result;
-	}
-	pJData->lock = 0;
+	}
+	pJData->lock = 0;
   }
 
   return JNI_TRUE;
 }
-
-