Initial revision

1 files changed, 2251 insertions, 0 deletions

diff --git a/gl4java/GLContext.java.skel b/gl4java/GLContext.java.skel
new file mode 100644
index 0000000..c91e4f6
--- /dev/null
+++ b/gl4java/GLContext.java.skel
@@ -0,0 +1,2251 @@
+/**
+ * @(#) GLContext.java
+ */
+
+
+package gl4java;
+
+import gl4java.jau.awt.WinHandleAccess;
+
+import java.awt.*;
+import java.applet.Applet;
+import java.awt.event.*;
+import java.lang.reflect.*;
+
+/**
+ * The base manager class for the OpenGL language mapping for Java !
+ *
+ * <p>
+ * If you are interessting in further Documentation and/or
+ * the history of GL4Java follow the following link.
+ * 
+ * <pre>
+        <a href="../GL4Java.html">The GL4Java Documentation</a>
+ * </pre>
+ * <p>
+ *
+ * All native libraries and GLFunc* and GLUFunc* implementations
+ * can/should be loaded right here !
+ *
+ * <pre>
+ 	<a href="GLContext.html#loadNativeLibraries(java.lang.String, java.lang.String, java.lang.String)">loadNativeLibraries</a>
+ 	<a href="GLContext.html#createGLFunc(java.lang.String)">createGLFunc</a>
+ 	<a href="GLContext.html#createGLUFunc(java.lang.String)">createGLUFunc</a>
+        <p>
+        To check the library versions, you can start the 
+ 	<a href="GLContext.html#main(java.lang.String[])">main</a>
+        function with <code>java gl4java.GLContext</code>
+ * </pre>
+ *
+ * <p>
+ *
+ * This class creates a GLContext in the constructor which fits to the native Window 
+ * of the given Component !
+ *
+ * <pre>
+   	<a href="GLContext.html#GLContext(java.awt.Component, gl4java.GLFunc, gl4java.GLUFunc>
+ * </pre>
+ *
+ * <p>
+ *
+ * If you want to port any OpenGL program to GL4Java,
+ * you can use 'glc2glj'. This easy kornshell-sed script converts
+ * many types and Math function calls ;-). E.g.: All C double constant literals
+ * will be changed to floats (0.0 -> 0.0f) and all sin, cos, .. functions
+ * will get the '(float)Math.' prefix !
+ *
+ * <pre>
+	<a href="../../../demos/glc2glj">glc2glj - A simple c to java converter for C- and GL-types</a>
+ * </pre>
+ * <p>
+ *
+ * The native libraries are plattform depended. 
+ *
+ * <pre>
+	  The default native library for Win32 and Unice's is :
+	  <p>
+	  	GLContext:	GL4JavaJauGljJNI
+		GLFuncJauJNI:	GL4JavaJauGLJNI
+		GLUFuncJauJNI:	GL4JavaJauGLUJNI
+	  <p>
+		Note:
+	  <p>
+	  The default native library for Macintosh is :
+	  <p>
+	  	GLContext:	GL4JavaMacGZGljJNI
+		GLFuncJauJNI:	GL4JavaMacGZGLJNI
+		GLUFuncJauJNI:	GL4JavaMacGZGLUJNI
+	  <p>
+	  <p>
+	  To check wich version and vendors are currently used,
+	  just call while a GLContext is created :
+	  <p>
+	  <a href="GLContext.html#gljShowVersions()">gljShowVersions</a>
+	  <p>
+	  Where an own Frame is opened !
+ * </pre>
+ *
+ * Make sure that this library is installed in your library path.
+ * The library path is for Unices one path of the environment 
+ * variable �LD_LIBRARY_PATH� and for Windows 32 
+ * �c:/winnt/system32� (WinNT) or 'c:/windows/system' (Windows 95) .
+ * Or it should be installed in the 'jre/bin' or 
+ * 'Netscape/communicator/Program/java/bin'  path !
+ *
+ * <p>
+ *
+ * To have a convinient usage, e.g. automatic resizing, GLContext
+ * and painting/gl-rendering, some classes in the package gl4java.awt
+ * may help you.
+ * 
+ * <pre>
+          E.g.: <a href="awt/GLCanvas.html">gl4java.awt.GLCanvas</a> 
+	  <p>
+	  <a href="awt/GLCanvas.html#init()">init</a> to create the java-stuff and GL-inits 
+	  <a href="awt/GLCanvas.html#display()">display</a> to render one frame, called by paint
+	  <a href="awt/GLCanvas.html#reshape(int, int)">reshape</a> to reshape (window resize)
+          <p>
+          Or look for animation at 
+	  <a href="awt/GLAnimCanvas.html">gl4java.awt.GLAnimCanvas</a> !
+ * </pre>
+ *
+ * <p>
+ *
+ * IF you remove/release a The component which is binded to this GLContext,
+ * you have to release the GLContext also - while calling:
+ *
+ * <pre>
+ 	<a href="GLContext.html#gljDestroy()">gljDestroy</a>
+ * </pre>
+ *
+ * before releasing/dispose it�s Window !
+ * 
+ * <p>
+ *
+ * We also define our own OpenGL extension. This extension functions
+ * start with the prefix glj like you can see here:
+ *
+ * <pre>
+        THIS FUNCTIONS ARE FOR USERS PURPOSES:
+	======================================
+
+ 	<a href="GLContext.html#loadNativeLibraries(java.lang.String, java.lang.String, java.lang.String)">loadNativeLibraries</a>
+ 	<a href="GLContext.html#createGLFunc(java.lang.String)">createGLFunc</a>
+ 	<a href="GLContext.html#createGLUFunc(java.lang.String)">createGLUFunc</a>
+ 	<a href="GLContext.html#gljGetNativeLibVersion()">gljGetNativeLibVersion</a>
+ 	<a href="GLContext.html#gljGetClassVersion()">gljGetClassVersion</a>
+	<a href="GLContext.html#gljShowVersions()">gljShowVersions</a>
+ 	<a href="GLContext.html#gljCheckGL()">gljCheckGL</a>
+ 	<a href="GLContext.html#gljCheckGLTypes()">gljCheckGLTypes</a>
+ 	<a href="GLContext.html#gljResize(int, int)">gljResize</a>
+ 	<a href="GLContext.html#gljSwap()">gljSwap</a>
+ 	<a href="GLContext.html#gljIsInit()">gljIsInit</a>
+ 	<a href="GLContext.html#gljMakeCurrent(boolean)">gljMakeCurrent</a>
+ 	<a href="GLContext.html#gljDestroy()">gljDestroy</a>
+ 	<a href="GLContext.html#gljFree()">gljFree</a>
+
+ * </pre>
+ * <p>
+ *
+ * You can see our example demo sources:
+ * <pre>
+	<a href="../../../demos/olympicCvs.java">olympicCvs.java as java source</a>
+	<a href="../../../demos/glLogoCvs.java">glLogoCvs.java as java source</a>
+	<a href="../../../demos/glDemosCvs.java">glDemosCvs.java as java source</a>
+ * </pre>
+ * <p>
+ *
+ * If you are interessting in further Documentation, downloading the latest
+ * version,  and/or the history of GL4Java click on the following link.
+ * 
+ * <pre>
+	<a href="http://www.jausoft.com/gl4java.html">The GL4Java Homepage</a>
+ * </pre>
+ * <p>
+ *
+ * @see WinDataAccess
+ * @version 	2.00, 21. April 1999
+ * @author      Sven Goethel
+ * 
+ */
+public class GLContext extends Object 
+	implements Runnable
+{
+
+    protected boolean isInitialized = false;
+
+   /**
+    * Flag is the native library is loaded.
+    * The native library is loaded at startup.
+    * If we failed loading the lib., 
+    * gljMakeCurrent and gljIsInit will return false.
+    *
+    * @see GLContext#gljMakeCurrent
+    * @see GLContext#gljIsInit
+    */
+    protected static boolean libsLoaded 	        = false;
+
+    /**
+     * The default GLContext native library for Windows 95/NT && MS-JVM
+     *
+     */
+    public static final String defGljMSWinLib   = "GL4JavaGljMSJDirect" ;
+
+    /**
+     * The default GLContext native library for all 
+     *
+     */
+    public static final String defGljLib   = "GL4JavaJauGljJNI" ;
+
+    /**
+     * The default GLFunc implementation 
+     *
+     */
+    public static final String defGLFuncClass 	   = "GLFuncJauJNI" ;
+
+    /**
+     * The default GLFunc native library for all
+     */
+    public static final String defGLFuncLib = "GL4JavaJauGLJNI" ;
+
+    /**
+     * The default GLUFunc implementation 
+     *
+     */
+    public static final String defGLUFuncClass = "GLUFuncJauJNI" ;
+
+    /**
+     * The default GLUFunc native library for all
+     */
+    public static final String defGLUFuncLib = "GL4JavaJauGLUJNI" ;
+
+
+   /**
+    * the version of this java-class
+    *
+    * <Major>.<Minor>.<BugFix>.<Release>
+    *
+    * Each <Value> is dezimal !
+    */
+    public static final String version             = __SED_CLASS_VERSION__ ;
+
+   /**
+    * Flag's to enable/disable verbose Information.
+    * Usually for debugging.
+    */
+    public static boolean gljClassDebug 	= false;
+    public static boolean gljNativeDebug 	= false;
+    
+   /**
+    * We will store the GL Context right here.
+    *
+    * @see GLContext#createGLContext
+    * @see GLContext#gljInit
+    */
+    protected int glContext=0;	
+
+   /**
+    * The context with witch display lists and textures will be shared.
+    *
+    * @see GLContext#createGLContext
+    * @see GLContext#gljInit
+    */
+    protected GLContext sharedGLContext;	
+    protected int sharedGLContextNative= 0; // No sharing by default.	
+
+   /**
+    * Xwindow data AND Windows data for the widget
+    *
+    * @see GLContext#createGLContext
+    * @see GLContext#gljInit
+    */
+    protected int pixmapHandle=0;     // unique handle for the Pixmap
+    protected int windowHandle=0;     // unique handle for this widget's window
+    protected int displayHandle=0;    // unqiue handle to the display
+
+   /**
+    * MS-JDirect-Window data for the MS-JVM interface
+    *
+    * @see GLContext#createGLContext
+    * @see GLContext#gljInit
+    */
+    private int createwinx;
+    private int createwiny;
+    private int createwinw;
+    private int createwinh;
+    private boolean threadRunning = false;
+    private boolean destroyWindow = false;
+    protected Container containerWindow = null;
+
+   /**
+    * The custom set offscreen Size
+    *
+    * If this is set to != null, 
+    * the offscreen pixmap is used in this size,
+    * not in the components-size (-> faster if smaller)
+    *
+    * Must be set via createOffScreenCtx
+    *
+    * @see GLJPanel#paint
+    * @see GLJPanel#createOffScreenCtx
+    */
+    protected Dimension offScrnSize = null;
+
+   /**
+    * Windows data AND flag is Window-Handel is read (for X11 also) ! 
+    *
+    * @see GLContext#createGLContext
+    * @see GLContext#gljInit
+    */
+    int pData = 0;  // stores the pointer structure that holds windows info
+
+    /**
+     * Flag to check, if the OpenGL-Context is active !
+     *
+     * @see	GLCanvas#gljIsEnabled
+     * @see	GLCanvas#gljSetEnabled
+     */
+    protected boolean glEnabled = true;
+
+   /**
+    * Do we use offscreen rendering 
+    *  X11: pixmap eq window-ressources, 
+    *       window eq. GLXPixmap a GLXDrawable
+    *       glContext eq. GLXContext
+    *
+    * This is set via the constructor !
+    * 
+    * @see GLContext#GLContext
+    */
+    protected boolean offScreenRenderer = false;    
+
+   /**
+    * Do we use doubleBuffer - of course !
+    * This is the default visual property ... !
+    *
+    * This is set via the constructor !
+    * 
+    * @see GLContext#isDoubleBuffer
+    * @see GLContext#GLContext
+    */
+    protected boolean doubleBuffer = true;    
+
+    /**
+     * Visual pre-set for stencil-bit number, default: 0
+     *
+     * @see GLContext#GLContext
+     */
+    protected int stencilBits = 0;
+
+    /**
+     * Visual pre-set for accumulator-size number, default: 0
+     *
+     * This value has a special behavior.
+     * For input - within the contructor,
+     * it is the value for each component !
+     *
+     * The output value, after the constructor returns,
+     * it is the summary of all accumulation bits of all components !
+     *
+     * @see GLContext#GLContext
+     */
+    protected int accumSize = 0;
+
+   /**
+    * Do we use stereoView - not yet ;-) !
+    * This is the default visual property ... !
+    *
+    * This is set via the constructor !
+    * 
+    * @see GLContext#isStereoView
+    * @see GLContext#GLContext
+    */
+    protected boolean stereoView = false;    
+
+   /**
+    * Do we use True-Color RGBA  - of course ;-) !
+    * This is the default visual property ... !
+    *
+    * This is set via the constructor !
+    * 
+    * @see GLContext#isRGBA
+    * @see GLContext#GLContext
+    */
+    protected boolean rgba = true;    
+
+   /**
+    * We normally do not have to create an own Window !
+    * This is the default visual property ... !
+    * But some machines, like SGI's Irix, 
+    * must use an own created overlapped window !
+    * For these machines, a compiler flag is set, 
+    * so that this value is alsways set to true !
+    *
+    * This is set via the constructor !
+    * 
+    * @see GLContext#isOwnWindowCreated
+    * @see GLContext#GLContext
+    */
+    protected boolean createOwnWindow = false;
+
+   /**
+    * The resize flag, which indicates a resize for the next paint function !
+    * This flag will bes set in 'componentResized'
+    * and will be cleared after resize (glViewport) in sDisplay !!
+    *
+    * @see gl4java.awt.GLCanvas#sDisplay
+    */
+    protected boolean mustResize = false;
+
+    protected Dimension size = null;
+
+    /**
+     * the light- or heavy component
+     * where GL commands should be drawn
+     */
+    protected Component _comp = null;
+
+    /**
+     * the heavy component
+     * where GL commands should be drawn
+     *
+     * if the _comp component is a swing (light)
+     * component, this component contains its heavy parent !
+     */
+    protected Component _compHeavy = null;
+
+   /**
+    * Variable to tell is where windows or not (X11) 
+    * Usally X11 ;-))
+    *
+    * Ok - lets give one to the Max :-) 
+    */
+    public static final int
+       OsWindoof	= -1,
+       OsUnknown	=  0,
+       OsX11	   	=  1,
+       OsMac		=  2; // for Gerard Ziemski's port
+ 
+    private static int osType=OsUnknown;
+  
+    private static boolean isNetscapeJvm = false;
+    private static boolean isMicrosoftJvm = false;
+    private static boolean useMSJDirect = false;
+    private static String jvmVendor = null;
+    private static String jvmVersion = null;
+    private static int    jvmVersionMajor = 1; // min. defaults
+    private static int    jvmVersionMinor = 1; // min. defaults
+    private static String osName = null;
+
+   /**
+    * Get the native GL Context !
+    *
+    * @see GLContext#glContext
+    */
+    public final long getNativeGLContext() { return (long)glContext; }
+
+   /**
+    * Get the native Window Handle !
+    *
+    * @see GLContext#windowHandle
+    */
+    public final long getNativeWindoHandle() { return (long)windowHandle; }
+
+   /**
+    * Get the optional shared GL Context !
+    *
+    * @see GLContext#sharedGLContext
+    */
+    public final GLContext getSharedGLContext() { return sharedGLContext; }
+
+   /**
+    * Get the native OS-Type !
+    *
+    * @see GLContext#osType
+    * @see GLContext#OsWindoof
+    * @see GLContext#OsUnknown
+    * @see GLContext#OsX11
+    * @see GLContext#OsMac
+    */
+    public final int getNativeOSType() { return osType; }
+
+   /**
+    * Query the visual property ... !
+    *
+    * After a GLContext is created, this property can be queried !
+    *
+    * @see GLContext#doubleBuffer
+    * @see GLContext#GLContext
+    */
+    public final boolean isDoubleBuffer() { return doubleBuffer; }
+
+   /**
+    * Query the visual property ... !
+    *
+    * After a GLContext is created, this property can be queried !
+    *
+    * @see GLContext#stereoView
+    * @see GLContext#GLContext
+    */
+    public final int getStencilBitNumber() { return stencilBits; }
+
+   /**
+    * Query the visual property ... !
+    *
+    * After a GLContext is created, this property can be queried !
+    *
+    * @see GLContext#GLContext
+    */
+    public final int getAccumSize() { return accumSize; }
+
+   /**
+    * Query the visual property ... !
+    *
+    * After a GLContext is created, this property can be queried !
+    *
+    * @see GLContext#stereoView
+    * @see GLContext#GLContext
+    */
+    public final boolean isStereoView() { return stereoView; }
+
+   /**
+    * Query the visual property ... !
+    *
+    * After a GLContext is created, this property can be queried !
+    *
+    * @see GLContext#rgba
+    * @see GLContext#GLContext
+    */
+    public final boolean isRGBA() { return rgba; }
+
+   /**
+    * Query the visual property ... !
+    *
+    * After a GLContext is created, this property can be queried !
+    *
+    * @see GLContext#createOwnWindow
+    * @see GLContext#GLContext
+    */
+    public final boolean isOwnWindowCreated() { return createOwnWindow; }
+
+    /**
+     * Support of loading the native library seperatly.
+     *
+     * Link with the native OpenGL library.  If we cannot link, an exception
+     * is thrown.  
+     * The name of the library is named e.g.: "GL4JavaJauGljJNI" at the 
+     * Java level, or "libGL4JavaJauGljJNI.so" at the solaris level,
+     * or "GL4JavaJauGljJNI.dll" at the win32 level :-).
+     *
+     * @param gljLibName The name of the GLContex native library.
+     *                   If gljLibName==null, the default library will be used !
+     *
+     * @param glLibName  The name of the GLFunc native library.
+     *                   If glLibName==null, the default library will be used !
+     *
+     * @param gluLibName The name of the GLUFunc native library.
+     *                   If gluLibName==null, the default library will be used !
+     *
+     * @return 		boolean, true if succesfull !
+     *
+     * @see	GLContext#defGljLib   
+     *
+     * @see	GLContext#defGLFuncLib 
+     *
+     * @see	GLContext#defGLUFuncLib 
+     */
+    public static boolean loadNativeLibraries ( String gljLibName,
+    						String glLibName,
+						String gluLibName
+					      )
+    {
+        if(libsLoaded) return true;
+
+	String libNames[] = null;
+
+        jvmVendor = java.lang.System.getProperty("java.vendor");
+        jvmVersion = java.lang.System.getProperty("java.version");
+
+        if(gljClassDebug)
+	{
+		System.out.println("jvm vendor: "+jvmVendor);
+		System.out.println("jvm version: "+jvmVersion);
+        }
+
+	int i0 = 0;
+	int i1 = jvmVersion.indexOf(".", i0);
+        String strhlp = null;
+	if(i1>0)
+	{
+	    strhlp = jvmVersion.substring(i0,i1);
+	    try {
+	      jvmVersionMajor = Integer.valueOf(strhlp).intValue();
+	    } catch (Exception e) 
+	    {System.out.println("Not a number: "+strhlp+" ("+jvmVersion+")");}
+	}
+	i0 = i1+1;
+	i1 = jvmVersion.indexOf(".", i0);
+	if( i1 < 0 )
+		i1 = jvmVersion.length(); // no 2nd dot, no bug version number
+
+	if( 0<i0 && i0<i1 )
+	{
+	    strhlp = jvmVersion.substring(i0,i1);
+	    try {
+	      jvmVersionMinor = Integer.valueOf(strhlp).intValue();
+	    } catch (Exception e) 
+	    {System.out.println("Not a number: "+strhlp+" ("+jvmVersion+")");}
+	}
+
+        if(gljClassDebug)
+	{
+		System.out.println("jvm version (parsed): "+
+				   "major: "+jvmVersionMajor+
+		                   ", minor: "+jvmVersionMinor);
+        }
+
+        isNetscapeJvm = jvmVendor!=null && jvmVendor.indexOf("Netscape")>=0 ;
+        isMicrosoftJvm = jvmVendor!=null && jvmVendor.indexOf("Microsoft")>=0 ;
+
+ 	// Determine the OS
+ 	osName = System.getProperty( "os.name" );
+ 	if( osName.startsWith( "Wind" ) )
+	   osType = OsWindoof;
+ 	else if( osName.startsWith( "Mac OS" ) )
+	   osType = OsMac;
+	else /* oops - lets guess unix/x11 :-) */
+	   osType = OsX11;
+
+	String jniEXTsuff = "";
+
+	if( jvmVersionMajor>=2 ||
+	       ( jvmVersionMajor==1 && jvmVersionMinor>=2 )
+	  )
+	{
+		jniEXTsuff = "12";
+	}
+
+	if(gljLibName==null)
+	    gljLibName = defGljLib+jniEXTsuff;
+	if(glLibName==null)
+	    glLibName  = defGLFuncLib+jniEXTsuff;
+	if(gluLibName==null)
+	    gluLibName = defGLUFuncLib+jniEXTsuff;
+
+	if ( (osType==OsWindoof) && (isMicrosoftJvm) )
+	{
+	   // JDirect loads the GL libraries automatically,
+	   // so we don't have to.
+	   libNames = new String[4];
+	   libNames[0]= gljLibName;
+	   libNames[1]= glLibName;
+	   libNames[2]= gluLibName;
+	   libNames[3]= defGljMSWinLib;
+	   useMSJDirect = true;
+	} else {
+	   /* For MAC, Win32+SunJVM, Unices ... 
+	    */
+	   libNames = new String[3];
+	   libNames[0]= gljLibName;
+	   libNames[1]= glLibName;
+	   libNames[2]= gluLibName;
+	   useMSJDirect = false;
+	}
+
+	if(isNetscapeJvm)
+	{
+	  System.out.println("Netscape JVM try to get Privileges");
+	  try {
+	        Class privmgr = 
+			Class.forName("netscape.security.PrivilegeManager");
+		Class[] parameterTypes = new Class[1];
+		parameterTypes[0] = Class.forName("java.lang.String");
+		Method m = privmgr.getMethod("enablePrivilege",parameterTypes);
+		Object args[] = new Object[1];
+		args[0] = (Object)(new String("UniversalLinkAccess"));
+		m.invoke(privmgr,args);
+		/*
+		netscape.security.PrivilegeManager.enablePrivilege
+			("UniversalLinkAccess");
+		*/
+		System.out.println("Netscape-Privilege: enabled UniversalLinkAccess priv.");
+	  } catch (Exception ex) 
+	  { 
+		System.out.println("Not enabled Netscape-Privilege: UniversalLinkAccess priv.");
+	  }
+	}
+
+	/* load libs */
+	int libNumber = 0;
+	String _libName = null ;
+        boolean libLoaded[] = new boolean[libNames.length];
+
+	for(libNumber=0; libNumber<libNames.length; libNumber++)
+	    libLoaded[libNumber]=false;
+
+	for(libNumber=0; libNumber<libNames.length; libNumber++)
+	{
+		do {
+		      try {
+			System.loadLibrary( libNames[libNumber] );  
+			libLoaded[libNumber]=true;
+			if(gljClassDebug)
+			{
+			    System.out.println("loaded native library: "+
+			    			libNames[libNumber]);
+			}
+		      } catch ( UnsatisfiedLinkError e) {
+			System.out.println
+			( "Sorry, can't find the library: "+
+			  libNames[libNumber]+"\n"+e );
+			
+			libNames[libNumber]=null; // stop trying ... :-(
+		      }
+		} while( libLoaded[libNumber]==false && 
+		         libNames[libNumber]!=null );
+	}
+
+	for(libNumber=0; libNumber<libNames.length; libNumber++)
+	{
+		if(libLoaded[libNumber]==false) break;
+	}
+	if(libNumber==libNames.length) 
+	{
+		libsLoaded=true;
+	}
+
+	return libsLoaded;
+    }
+ 
+    /** 
+     * no no no .. the user has to choose !
+     *
+     * The user must call loadNativeLibrary !
+     * 
+     * @see GLContext#loadNativeLibrary
+     *
+     * static {
+     * 	if(!libLoaded)
+     * 		loadNativeLibrares(null, null, null);
+     * }
+     */
+
+    /**
+     * Test to load the native library, GLFunc and GLUFunc implementation !
+     * If succesfull, a Frame will created and the GL-Infos (vendor, ...)
+     * are shown in it !
+     *
+     * @param args, a list of args, 
+     *
+     *    -gljlib   <glj-libname> gl4java-glj-lib native library
+     *    -gllib    <gl-libname> gl4java-gl-lib native library
+     *    -glulib   <glu-libname> gl4java-glu-lib native library
+     *    -glclass  <gl-class> gl4java-gl-class java GLFunc implementation
+     *    -gluclass <glu-class> gl4java-glu-class java GLUFunc implementation
+     *    -info     creates a GLContext and prints all avaiable information of GL/GLU and GL4Java
+     *    -infotxt  like -info, but exits straight after -info !
+     *
+     *    without any arguments, a help screen is shown 
+     */
+    public static void main( String args[] ) 
+    {
+     	String gljLibName = null;
+     	String glLibName = null;
+     	String gluLibName = null;
+     	String glName = defGLFuncClass;
+     	String gluName = defGLUFuncClass;
+	boolean info=false;
+	boolean exitImmediatly=false;
+	int i = 0;
+	boolean ok=true;
+
+	if(args.length==0)
+	{
+		System.out.println("usage: java gl4java.GLContext <options>, where options can be: ");
+		System.out.println("	-gljlib <glj-libname> \t choose a custom the gl4java-glj-lib native library (default: GL4JavaJauGljJNI)");
+		System.out.println("	-gllib <gl-libname> \t choose a custom the gl4java-gl-lib native library (default: GL4JavaJauGLJNI)");
+		System.out.println("	-glulib <glu-libname> \t choose a custom the gl4java-glu-lib native library (default: GL4JavaJauGLUJNI");
+		System.out.println("	-glclass <gl-class> \t choose a custom the gl4java-gl-class java GLFunc implementation (default: GLFuncJauJNI)");
+		System.out.println("	-gluclass <glu-class> \t choose a custom the gl4java-glu-class java GLUFunc implementation (default: GLUFuncJauJNI)");
+		System.out.println("	-info \t creates a GLContext and prints all avaiable information of GL/GLU and GL4Java");
+		System.out.println("	-infotxt \t like -info, but exits straight after -info !");
+	        System.exit(0);
+	}
+
+	while(args.length>i)
+	{
+		if(args[i].equals("-gljlib")) {
+			if(args.length>++i) gljLibName=args[i];
+		} else if(args[i].equals("-gllib")) {
+			if(args.length>++i) glLibName=args[i];
+		} else if(args[i].equals("-glulib")) {
+			if(args.length>++i) gluLibName=args[i];
+		} else if(args[i].equals("-glclass")) {
+			if(args.length>++i) glName=args[i];
+		} else if(args[i].equals("-gluclass")) {
+			if(args.length>++i) gluName=args[i];
+		} else if(args[i].equals("-info")) {
+			info=true;
+		} else if(args[i].equals("-infotxt")) {
+			info=true;
+			exitImmediatly=true;
+		} else {
+		  System.out.println("illegal arg "+i+": "+args[i]);
+		  ok=false;
+		}
+		i++;
+	}
+
+	GLContext.gljNativeDebug = true;
+	GLContext.gljClassDebug = true;
+
+	GLFunc  gl = null;
+	GLUFunc glu = null;
+
+	if(GLContext.loadNativeLibraries(gljLibName, glLibName, gluLibName))
+		System.out.println("native Libraries loaded succesfull");
+	else {
+		System.out.println("native library NOT loaded complete");
+		ok=false;
+	}
+
+	if( (gl=GLContext.createGLFunc(glName)) !=null)
+		System.out.println("GLFunc implementation "+glName+" created succesfull");
+	else {
+		System.out.println("GLFunc implementation "+glName+" not created");
+		ok=false;
+	}
+	if( (glu=GLContext.createGLUFunc(gluName)) !=null)
+		System.out.println("GLUFunc implementation "+gluName+" created succesfull");
+	else {
+	        System.out.println("GLUFunc implementation "+gluName+" not created");
+		ok=false;
+	}
+
+	if( info && ok==true) {
+		Frame f = new Frame("GL4Java Info");
+		f.setSize(10, 10);
+
+		f.pack();
+		f.setVisible(true);
+
+		GLContext glj = new GLContext(f, gl, glu);
+
+		Frame fInfo = glj.gljShowVersions();
+
+                fInfo.addWindowListener
+		                   ( new WindowAdapter()
+                                      {
+                                        public void windowClosed(WindowEvent e)
+                                        {
+                                           // button exit
+                                           System.exit(0);
+                                        }
+                                      }
+                                    );              
+
+	        glj.gljDestroy();
+
+		if(exitImmediatly)
+		   System.exit(0);
+	}
+    }
+		
+    public static String getJVMVendor() { return jvmVendor; }
+    public static boolean isNetscapeJVM() { return isNetscapeJvm; }
+    public static boolean isMicrosoftJVM() { return isMicrosoftJvm; }
+ 
+    /**
+     * Used to hold the user given GLFunc implementation
+     */
+    private GLFunc gl 	= null;
+
+    /**
+     * Used to hold the user given GLUFunc implementation
+     */
+    private GLUFunc glu = null;
+
+   /**
+    *
+    * Constructor
+    *
+    * This privat constructor is for all possible
+    * compinations and is called from the customized
+    * constructors.
+    *
+    *  First the GLContext is fetched from the Component itself !
+    * To do so, the Component is set visible if it is not !
+    *
+    * If a GLContext is fetched, it is current !
+    *
+    * @param comp	  the users component for the gl-context
+    * @param glf	  the users selected GLFunc implementation
+    * @param glf	  the users selected GLUFunc implementation
+    * @param _createOwnWindow the flag for the visual property
+    * @param _offScreenRenderer the flag for the visual property
+    * @param _doubleBuffer the flag for the visual property
+    * @param _stereoView  the flag for the visual property
+    * @param _rgba	  the flag for the visual property
+    * @param _stencilBits the flag for the visual property
+    * @param _accumSize   the flag for the visual property
+    * @param _sharedGLContext the shared GLContext
+    * @param _offScrnSize the fixed offscreen pixmap size
+    *
+    */
+    protected GLContext( Component comp, GLFunc glf, GLUFunc gluf, 
+		         boolean _createOwnWindow, boolean _offScreenRenderer,
+                         boolean _doubleBuffer, boolean _stereoView,
+		         boolean _rgba,
+		         int _stencilBits,
+		         int _accumSize,
+		         GLContext _sharedGLContext,
+    			 Dimension _offScrnSize
+                       )
+    {
+		super( );
+
+		_comp = comp ;  // the light- or heavy component
+		gl    = glf ;
+		glu   = gluf ;
+	        createOwnWindow = _createOwnWindow;
+	        offScreenRenderer = _offScreenRenderer;
+		doubleBuffer=_doubleBuffer;
+		stereoView=_stereoView;
+		rgba=_rgba;
+		stencilBits=_stencilBits;
+		accumSize=_accumSize;
+		offScrnSize= _offScrnSize;
+
+		this.sharedGLContext  = _sharedGLContext;
+		if(sharedGLContext != null) 
+			sharedGLContextNative =
+				(int)sharedGLContext.getNativeGLContext();
+
+		// fetch the heavy peer component in temporary var. comp
+		while(comp!=null &&
+		      (comp.getPeer() instanceof java.awt.peer.LightweightPeer)
+		     )
+			comp=comp.getParent();
+
+		_compHeavy = comp ;  // the heavy component
+
+    		Graphics  _gr = null;
+
+		if(_compHeavy!=null)
+		{
+			if( ! _comp.isVisible() )
+				setVisible(true); // use our own ...
+
+
+			_gr = _compHeavy.getGraphics();
+			if(_gr==null)
+			  System.out.println("got empty Graphics");
+		} else
+		  System.out.println("got empty Component");
+
+		if(_comp!=null && _gr!=null)
+		{
+			int i = 0;
+			do {
+				createGLContext(_gr); // uses _comp
+				if(gljIsInit()==false)
+				{
+				    try
+				    {
+				      Thread.sleep( 100 );
+				    }
+				    catch( Exception e )
+				    { }
+				}
+				i++;
+			} while(gljIsInit()==false && i<5) ;
+		}
+
+	        if(gljClassDebug)
+		{
+			if(gljIsInit())
+			  System.out.println(">>> GLContext() succeded");
+			else
+			  System.out.println(">>> GLContext() failed");
+		}
+    }
+
+   /**
+    *
+    * Constructor
+    *
+    * First the GLContext is fetched from the Component itself !
+    * To do so, the Component is set visible if it is not !
+    *
+    * If a GLContext is fetched, it is current !
+    *
+    * @param comp	  the users component for the gl-context
+    * @param glf	  the users selected GLFunc implementation
+    * @param glf	  the users selected GLUFunc implementation
+    * @param _createOwnWindow the flag for the visual property
+    * @param _doubleBuffer the flag for the visual property
+    * @param _stereoView  the flag for the visual property
+    * @param _rgba	  the flag for the visual property
+    * @param _stencilBits the flag for the visual property
+    * @param _accumSize   the flag for the visual property
+    * @param _sharedGLContext the shared GLContext
+    *
+    */
+    public GLContext( Component comp, GLFunc glf, GLUFunc gluf, 
+		      boolean _createOwnWindow,
+                      boolean _doubleBuffer, boolean _stereoView,
+		      boolean _rgba,
+		      int _stencilBits,
+		      int _accumSize,
+		      GLContext _sharedGLContext
+                    )
+    {
+    	this(comp, glf, gluf, 
+	      _createOwnWindow, false /* offscreen renderer */,
+	      _doubleBuffer,
+	      _stereoView,
+	      _rgba,
+	      _stencilBits,
+	      _accumSize,
+	      _sharedGLContext,
+	      null /* offscreen size */
+	    );
+    }
+
+   /**
+    *
+    * Constructor
+    *
+    * First the GLContext is fetched from the Component itself !
+    * To do so, the Component is set visible if it is not !
+    *
+    * If a GLContext is fetched, it is current !
+    *
+    * @param comp	  the users component for the gl-context
+    * @param glf	  the users selected GLFunc implementation
+    * @param glf	  the users selected GLUFunc implementation
+    * @param _createOwnWindow the flag for the visual property
+    * @param _doubleBuffer the flag for the visual property
+    * @param _stereoView  the flag for the visual property
+    * @param _rgba	  the flag for the visual property
+    * @param _stencilBits the flag for the visual property
+    * @param _accumSize   the flag for the visual property
+    *
+    */
+    public GLContext( Component comp, GLFunc glf, GLUFunc gluf, 
+		      boolean _createOwnWindow,
+                      boolean _doubleBuffer, boolean _stereoView,
+		      boolean _rgba,
+		      int _stencilBits,
+		      int _accumSize
+                    )
+    {
+    	this(comp, glf, gluf, 
+	      _createOwnWindow, false /* offscreen renderer */,
+	      _doubleBuffer,
+	      _stereoView,
+	      _rgba,
+	      _stencilBits,
+	      _accumSize,
+	      null /* sharedGLContext */,
+	      null /* offscreen size */
+	    );
+    }
+
+   /**
+    *
+    * Constructor
+    *
+    * First the GLContext is fetched from the Component itself !
+    * To do so, the Component is set visible if it is not !
+    *
+    * If a GLContext is fetched, it is current !
+    *
+    * @param comp	  the users component for the gl-context
+    * @param glf	  the users selected GLFunc implementation
+    * @param glf	  the users selected GLUFunc implementation
+    * @param _createOwnWindow the flag for the visual property
+    * @param _doubleBuffer the flag for the visual property
+    * @param _stereoView  the flag for the visual property
+    * @param _rgba	  the flag for the visual property
+    * @param _stencilBits the flag for the visual property
+    *
+    */
+    public GLContext( Component comp, GLFunc glf, GLUFunc gluf, 
+		      boolean _createOwnWindow,
+                      boolean _doubleBuffer, boolean _stereoView,
+		      boolean _rgba,
+		      int _stencilBits
+                    )
+    {
+    	this(comp, glf, gluf, 
+	      _createOwnWindow, false /* offscreen renderer */,
+	      _doubleBuffer,
+	      _stereoView,
+	      _rgba,
+	      _stencilBits,
+	      0 /* accumSize */,
+	      null /* sharedGLContext */,
+	      null /* offscreen size */
+	    );
+    }
+
+   /**
+    *
+    * Constructor
+    *
+    * First the GLContext is fetched from the Component itself !
+    * To do so, the Component is set visible if it is not !
+    *
+    * If a GLContext is fetched, it is current !
+    *
+    * @param comp	  the users component for the gl-context
+    * @param glf	  the users selected GLFunc implementation
+    * @param glf	  the users selected GLUFunc implementation
+    * @param _doubleBuffer the flag for the visual property
+    * @param _stereoView  the flag for the visual property
+    * @param _rgba	  the flag for the visual property
+    * @param _stencilBits the flag for the visual property
+    *
+    */
+    public GLContext( Component comp, GLFunc glf, GLUFunc gluf, 
+                      boolean _doubleBuffer, boolean _stereoView,
+		      boolean _rgba,
+		      int _stencilBits,
+		      int _accumSize
+                    )
+    {
+    	this(comp, glf, gluf, 
+	      false /* ownWindow */, false /* offscreen renderer */,
+	      _doubleBuffer,
+	      _stereoView,
+	      _rgba,
+	      _stencilBits,
+	      _accumSize,
+	      null /* sharedGLContext */,
+	      null /* offscreen size */
+	    );
+    }
+
+   /**
+    *
+    * Constructor
+    *
+    * First the GLContext is fetched from the Component itself !
+    * To do so, the Component is set visible if it is not !
+    *
+    * If a GLContext is fetched, it is current !
+    *
+    * @param comp	  the users component for the gl-context
+    * @param glf	  the users selected GLFunc implementation
+    * @param glf	  the users selected GLUFunc implementation
+    * @param _doubleBuffer the flag for the visual property
+    * @param _stereoView  the flag for the visual property
+    * @param _rgba	  the flag for the visual property
+    * @param _stencilBits the flag for the visual property
+    *
+    */
+    public GLContext( Component comp, GLFunc glf, GLUFunc gluf, 
+                      boolean _doubleBuffer, boolean _stereoView,
+		      boolean _rgba,
+		      int _stencilBits
+                    )
+    {
+    	this(comp, glf, gluf, 
+	      false /* ownWindow */, false /* offscreen renderer */,
+	      _doubleBuffer,
+	      _stereoView,
+	      _rgba,
+	      _stencilBits,
+	      0 /* accumSize */,
+	      null /* sharedGLContext */,
+	      null /* offscreen size */
+	    );
+    }
+
+   /**
+    *
+    * Constructor
+    *
+    * First the GLContext is fetched from the Component itself !
+    * To do so, the Component is set visible if it is not !
+    *
+    * If a GLContext is fetched, it is current !
+    *
+    * @param comp	  the users component for the gl-context
+    * @param glf	  the users selected GLFunc implementation
+    * @param glf	  the users selected GLUFunc implementation
+    * @param _doubleBuffer the flag for the visual property
+    * @param _stereoView  the flag for the visual property
+    * @param _rgba	  the flag for the visual property
+    * @param _stencilBits the flag for the visual property
+    *
+    */
+    public GLContext( Component comp, GLFunc glf, GLUFunc gluf, 
+                      boolean _doubleBuffer, boolean _stereoView,
+		      boolean _rgba
+                    )
+    {
+    	this(comp, glf, gluf, 
+	      false /* ownWindow */, false /* offscreen renderer */,
+	      _doubleBuffer,
+	      _stereoView,
+	      _rgba,
+	      0, /* _stencilBits */
+	      0 /* accumSize */,
+	      null /* sharedGLContext */,
+	      null /* offscreen size */
+	    );
+    }
+
+   /**
+    *
+    * Constructor
+    *
+    * First the GLContext is fetched from the Component itself !
+    * To do so, the Component is set visible if it is not !
+    *
+    * If a GLContext is fetched, it is current !
+    *
+    * ! WARNING ! This flag is just for testing purpose !!!
+    *
+    * @param comp	  the users component for the gl-context
+    * @param glf	  the users selected GLFunc implementation
+    * @param glf	  the users selected GLUFunc implementation
+    * @param _doubleBuffer the flag for the visual property
+    * @param _stereoView  the flag for the visual property
+    *
+    */
+    public GLContext( Component comp, GLFunc glf, GLUFunc gluf, 
+                      boolean _doubleBuffer, boolean _stereoView
+                    )
+    {
+    	this(comp, glf, gluf, 
+	      false /* ownWindow */, false /* offscreen renderer */,
+	      _doubleBuffer,
+	      _stereoView,
+	      true /* _rgba */,
+	      0, /* _stencilBits */
+	      0 /* accumSize */,
+	      null /* sharedGLContext */,
+	      null /* offscreen size */
+	    );
+    }
+
+   /**
+    *
+    * Constructor
+    *
+    * First the GLContext is fetched from the Component itself !
+    * To do so, the Component is set visible if it is not !
+    *
+    * We use a visual with doubleBuffer and NO stereoView !
+    * Do not force a new native window !
+    *
+    * If a GLContext is fetched, it is current !
+    *
+    * @param comp	the users component for the gl-context
+    * @param glf	the users selected GLFunc implementation
+    * @param glf	the users selected GLUFunc implementation
+    */
+    public GLContext( Component comp, GLFunc glf, GLUFunc gluf )
+    {
+    	this(comp, glf, gluf, 
+	      false /* ownWindow */, false /* offscreen renderer */,
+	      true /* _doubleBuffer */,
+	      false /* _stereoView */,
+	      true /* _rgba */,
+	      0, /* _stencilBits */
+	      0 /* accumSize */,
+	      null /* sharedGLContext */,
+	      null /* offscreen size */
+	    );
+    }
+
+   /**
+    *
+    * Constructor Function for offscreen rendering !
+    *
+    * First the GLContext is fetched from the Component itself !
+    * To do so, the Component is set visible if it is not !
+    *
+    * If a GLContext is fetched, it is current !
+    *
+    * @param comp	  the users component for the gl-context
+    * @param glf	  the users selected GLFunc implementation
+    * @param glf	  the users selected GLUFunc implementation
+    * @param _stereoView  the flag for the visual property
+    * @param _rgba	  the flag for the visual property
+    * @param _stencilBits the flag for the visual property
+    * @param _sharedGLContext the shared GLContext
+    *
+    * @return             the created offscreen context
+    */
+    public static final GLContext createOffScreenCtx
+    		       ( Component comp, GLFunc glf, GLUFunc gluf, 
+                         boolean _stereoView,
+		         boolean _rgba,
+		         int _stencilBits,
+		         int _accumSize,
+		         GLContext _sharedGLContext
+                       )
+    {
+    	return new GLContext(comp, glf, gluf, 
+		      false /* _createOwnWindow */, 
+		      true /* offscreen renderer */,
+		      false /* _doubleBuffer */,
+		      _stereoView,
+		      _rgba,
+		      _stencilBits,
+		      _accumSize,
+		      _sharedGLContext,
+		      null
+		    );
+    }
+
+   /**
+    *
+    * Constructor Function for offscreen rendering !
+    *
+    * First the GLContext is fetched from the Component itself !
+    * To do so, the Component is set visible if it is not !
+    *
+    * If a GLContext is fetched, it is current !
+    *
+    * @param comp	  the users component for the gl-context
+    * @param glf	  the users selected GLFunc implementation
+    * @param glf	  the users selected GLUFunc implementation
+    * @param _stereoView  the flag for the visual property
+    * @param _rgba	  the flag for the visual property
+    * @param _stencilBits the flag for the visual property
+    * @param _sharedGLContext the shared GLContext
+    * @param _offScrnSize the fixed offscreen pixmap size
+    *
+    * @return             the created offscreen context
+    */
+    public static final GLContext createOffScreenCtx
+    		       ( Component comp, GLFunc glf, GLUFunc gluf, 
+                         boolean _stereoView,
+		         boolean _rgba,
+		         int _stencilBits,
+		         int _accumSize,
+		         GLContext _sharedGLContext,
+    			 Dimension _offScrnSize
+                       )
+    {
+    	return new GLContext(comp, glf, gluf, 
+		      false /* _createOwnWindow */, 
+		      true /* offscreen renderer */,
+		      false /* _doubleBuffer */,
+		      _stereoView,
+		      _rgba,
+		      _stencilBits,
+		      _accumSize,
+		      _sharedGLContext,
+		      _offScrnSize
+		    );
+    }
+
+    /**
+     * Used to set the user given GLFunc implementation
+     */
+    public final void setGLFunc(GLFunc _gl) { gl = _gl; }
+
+    /**
+     * Used to set the user given GLUFunc implementation
+     */
+    public final void setGLUFunc(GLUFunc _glu) { glu = _glu; }
+
+    /**
+     * Used to return the user given GLFunc implementation
+     */
+    public final GLFunc getGLFunc() { return gl; }
+
+    /**
+     * Used to return the user given GLUFunc implementation
+     */
+    public final GLUFunc getGLUFunc() { return glu; }
+
+    /**
+     * Support of loading a vendors GLFunc implementation
+     *
+     * Try to load the Class, if succesfull we do return the instance of it.
+     * Else null is returned !
+     *
+     * The Class-Name is: "GL4Java." + vendorClass + ".class" !
+     *
+     * @param vendorClass  The name of the GLFunc implementation.
+     *                     If vendorSuffix==null, the default implementation 
+     *			   "GLFuncJauJNI" (-> GL4Java.GLFuncJauJNI.class ) 
+     *			   will be used !
+     *
+     * @return 		GLFunc, the implementation's instance if exists 
+     *			and valid, or null
+     *
+     * @see	GLContext#defGLFuncClass   
+     */
+    public static final GLFunc createGLFunc(String vendorClass)
+    {
+        String access_name = "gl4java.";
+	GLFunc gl = null;
+	Object clazz = null;
+
+	if(vendorClass==null) 
+	{
+	    vendorClass = defGLFuncClass ;
+	}
+
+	String clazzName   = access_name + vendorClass ;
+
+	try {
+		clazz = Class.forName(clazzName).newInstance();
+	} catch (Exception ex) {
+		// thats ok :-)
+		System.out.println("could not create instance of: "+ clazzName);
+	}
+	if(clazz !=null && (clazz instanceof GLFunc))
+		gl = (GLFunc) clazz;
+	else
+		System.out.println("Not a GLFunc implementation: "+ clazzName);
+
+	return gl;
+    }
+
+    /**
+     * Support of loading a vendors GLUFunc implementation
+     *
+     * Try to load the Class, if succesfull we do return the instance of it.
+     * Else null is returned !
+     *
+     * The Class-Name is: "GL4Java." + vendorClass + ".class" !
+     *
+     * @param vendorClass  The name of the GLUFunc implementation.
+     *                     If vendorSuffix==null, the default implementation 
+     *			   "GLUFuncJauJNI" (-> GL4Java.GLUFuncJauJNI.class ) 
+     *			   will be used !
+     *
+     * @return 		GLUFunc, the implementation's instance if exists 
+     *			and valid, or null
+     *
+     * @see	GLContext#defGLUFuncClass   
+     */
+    public static final GLUFunc createGLUFunc(String vendorClass)
+    {
+        String access_name = "gl4java.";
+	GLUFunc glu = null;
+	Object clazz = null;
+
+	if(vendorClass==null) 
+	{
+	    vendorClass = defGLUFuncClass ;
+	}
+
+
+	String clazzName   = access_name + vendorClass ;
+
+	try {
+		clazz = Class.forName(clazzName).newInstance();
+	} catch (Exception ex) {
+		// thats ok :-)
+		System.out.println("could not create instance of: "+ clazzName);
+	}
+	if(clazz!=null && (clazz instanceof GLUFunc))
+		glu = (GLUFunc) clazz;
+	else
+		System.out.println("Not a GLUFunc implementation: "+ clazzName);
+		
+
+	return glu;
+    }
+
+   /**
+    *
+    * Own setVisible
+    * This one set's us visible - and wait's for that result !
+    *
+    * @param visible	boolean: visible==true, hide==false
+    * @return 		void
+    */ 
+    public void setVisible( boolean visible )
+    {
+    	    int i= 0;
+
+	    _comp.setVisible( visible );
+
+	    while( _comp.isVisible() != visible  && i<5) 
+	    {
+		_comp.setVisible( visible );
+
+	        try
+	        {
+		    Thread.sleep( 100 );
+	        }
+	        catch( Exception e )
+	        {
+		    System.out.println( "GLContext:setVisible: Error - " + e );
+	        }
+		i++;
+	    }
+	    if(i>=5)
+	      System.out.println( "GLContext:setVisible: Error, could not set to "+visible); 
+    }
+
+   /**
+    *
+    * createGLContext gets the window handle and calls gljInit,
+    * so the gl-context will be initialised here.
+    *
+    * this method will be invoked by the constructor
+    *
+    * this method is left public - this time,
+    * to allow the user to to it again later - if it was not succesfull !
+    *
+    * @param g		the graphics reference, 
+    *			where we will get the native window handle from.
+    *
+    * @return 		void
+    *
+    * @see GLContext#GLContext
+    */ 
+    public final void createGLContext(Graphics g)
+    {
+        String access_name = "gl4java.jau.awt.";
+        WinHandleAccess win_access = null;
+
+	try {
+	    if(gljClassDebug)
+	      System.out.println(">>> createGLContext");
+ 
+          if(pData == 0)
+	  {
+	    if ( useMSJDirect )
+	    {
+	          if(gljClassDebug)
+			  System.out.println("using MSJDirect ...");
+
+		  win_access = (WinHandleAccess)
+		    Class.forName(access_name + "windows.MSWin32HandleAccess").newInstance();
+                  /* _comp should be a subclass of Canvas, and its parent
+                     class should be of type Panel, Frame or Window.  If not,
+                     this all falls apart. */
+
+		  /* This part is now rewritten, 
+	             to respect direkt Windows (Frames and Dialogs)
+		     and Applets .. */
+
+                  Component ob = _comp;
+
+		  while ( (ob instanceof Window)==false &&
+		  	  (ob instanceof Applet)==false
+			)
+		  {
+                      ob = ob.getParent();
+                  }
+
+		  containerWindow = (Container)ob;
+
+		  /* refetch the Graphics component */
+		  g = ob.getGraphics();
+		  if(g==null)
+		    System.out.println("GL4Java-MSJVM: got empty Graphics");
+
+		  pData = (int)win_access.getWinHandle(ob,g);
+
+		  if (pData != 0)
+		  {
+			Point p1;
+			try
+			{
+				p1 = _comp.getLocationOnScreen();
+			}
+			catch (Exception e)
+			{
+				p1 = _comp.getLocation();
+				Point p2 = containerWindow.getLocation();
+				p1.x += p2.x;
+				p1.y += p2.y;
+				Insets is = containerWindow.getInsets();
+				p1.x += is.left;
+				p1.y += is.top;
+			}
+			Rectangle r = _comp.getBounds();
+			createwinx = p1.x;
+			createwiny = p1.y;
+			createwinw = r.width;
+			createwinh = r.height;
+			windowHandle = 0;
+			threadRunning = true;
+			destroyWindow = false;
+			Thread th = new Thread(this);
+			th.start();
+			while ( (windowHandle == 0) && (threadRunning) )
+			{
+				try
+				{
+					Thread.currentThread().sleep(100);
+				}
+				catch( Exception e )
+				{ }
+			}
+		  }
+ 	    } else if(osType==OsWindoof)
+	    {
+		  win_access = (WinHandleAccess) 
+		    Class.forName(access_name + "windows.Win32HandleAccess").newInstance();
+		  pData = (int) win_access.getWinHandle(_compHeavy, g);
+		  windowHandle = pData;
+	    }
+            else if(osType==OsMac)
+            {
+		  win_access = (WinHandleAccess)
+			Class.forName(access_name + "macintosh.MacHandleAccess").newInstance();
+		  pData = (int) win_access.getWinHandle(_compHeavy, g);
+		  windowHandle = pData;
+            }     
+	    else /* X11 */
+	    {
+		  win_access = (WinHandleAccess) 
+		    Class.forName(access_name + "motif.X11HandleAccess").newInstance();
+		  pData = (int) win_access.getWinHandle(_compHeavy, g);
+		  windowHandle = pData;
+	    }
+	  }
+
+	  if(offScrnSize!=null)
+	  {
+		  createwinw = offScrnSize.width;
+		  createwinh = offScrnSize.height;
+	  } else {
+		  Rectangle r = _comp.getBounds();
+		  createwinw = r.width;
+		  createwinh = r.height;
+	  }
+
+	  /* try to establish a context to OpenGL */
+	  try 
+	  {
+		    gljInit();
+	  }
+	  catch( GL4JavaInitException e ) 
+	  {
+		    System.out.println( "can't create a GL context\n");
+	  }
+    
+	} catch (Exception e) {
+	      System.out.println( "An exception is thrown, while creating a GL context\n");
+	      System.out.println(e);
+	      e.printStackTrace();
+	}
+    }
+
+    /* glj* stuff */
+    			
+   /**
+    *
+    * Initializes the gl-context. 
+    * gljInit is called by createGLContext (which is calles by the first paint)!
+    *
+    * Also gljInit will call the init method after GL initialisation,
+    * so the user can override �init� to initialize his own stuff !
+    *
+    * @return 		void
+    * @exception 	GL4Java.GL4JavaInitException 
+    *			this class throws an exception 
+    *			if the native call to create a OpenGL context failed.
+    * @see GLContext#createGLContext
+    * @see gl4java.awt.GLCanvas#paint
+    * @see gl4java.awt.GLCanvas#init
+    */ 
+    protected final synchronized void gljInit() 
+      throws GL4JavaInitException 
+    {
+	if( libsLoaded==false ) return ;
+
+	if(pData==0 && !offScreenRenderer)
+	{
+	    System.out.println("could not open a GL widget -- Win CONTEXT");
+            throw new GL4JavaInitException ();
+	}
+
+	if(gljClassDebug)
+	  System.out.println(">>> gljInit");
+
+        if( openOpenGLNative() == false ) 
+        {
+	    if ( useMSJDirect )
+	    {
+		destroyWindow = true;
+		while (threadRunning)
+		{
+			try
+			{
+				Thread.currentThread().sleep(100);
+			}
+			catch( Exception e )
+			{ }
+		}
+		pData = 0;
+		windowHandle = 0;
+	    }
+	    System.out.println("could not open a GL widget -- GL CONTEXT");
+            throw new GL4JavaInitException ();
+          } else {
+	    isInitialized = true;
+	}
+    }
+
+    /**
+     * For MSJVM Only !
+     *
+     * This functions fetches the window-handle within a special thread !
+     */
+    public void run()
+    {
+	if ( !useMSJDirect )
+	{
+		System.err.println("GL4Java-MSJVM-Run: INTERNAL ERROR"); 
+		System.exit(0);
+	}
+
+	pData = gl4java.system.GljMSJDirect.createOGLWindowNative( 
+					      pData,
+	                                      createwinx,createwiny,
+					      createwinw,createwinh);
+	if (pData != 0)
+	{
+		windowHandle = pData;
+		while (!destroyWindow)
+		{
+			gl4java.system.GljMSJDirect.OGLWindowMsgPump();
+			try
+			{
+				Thread.currentThread().sleep(10);
+			}
+			catch( Exception e )
+			{ }
+		}
+		destroyWindow = false;
+		gl4java.system.GljMSJDirect.destroyOGLWindowNative(
+								windowHandle);
+		windowHandle = 0;
+		pData = 0;
+		gl4java.system.GljMSJDirect.OGLWindowMsgPump();
+	}
+	threadRunning = false;
+    }
+
+   /**
+    *
+    * Checks if the gl-context is Initializes
+    * If returns true,
+    * gljInit is allready called and a valid gl-context is achieved.
+    *
+    * No glMakeCurrent is done - 
+    * like gljMakeCurrent (important for more gl-context) !
+    * 
+    * <p>
+    *
+    * The user can use this method to check if he can start rendering
+    * and to be sure his initialisation (init) is done !
+    *
+    * <p>
+    *
+    * If you use gl4java.awt.GLCanvas, you should use the cvsIsInit
+    * method !
+    * <p>
+    *
+    * @return 		boolean
+    * @see GLContext#gljInit
+    * @see gl4java.awt.GLCanvas#cvsIsInit
+    */ 
+    public final boolean gljIsInit() 
+    {
+	return isInitialized;
+    }
+
+    /**
+     * Resizes the gl-viewport
+     *
+     * Should be called, if the component is resized.
+     * The user should take advantage of this functionality.
+     *
+     * Be sure to resize not within the event-method of the
+     * ComponentHandler, you better resize while normal painting.
+     * This can be done while using a boolean flag ;-)
+     * 
+     * Look at GLComponent !
+     */
+    public final void gljResize(int width, int height)
+    {
+    	if ( ! isInitialized || !glEnabled ) return;
+
+	if(offScreenRenderer)
+	{
+		//JAU: TODO
+		return;
+	}
+
+	if ( useMSJDirect )
+        {
+		try
+		{
+			Point p = _comp.getLocationOnScreen();
+			gl4java.system.GljMSJDirect.moveOGLWindowNative(
+					     windowHandle,p.x,p.y,width,height);
+		}
+		catch (Exception e)
+		{ }
+	}
+        else
+                gljResizeNative( createOwnWindow,
+		                 displayHandle, windowHandle,
+		                 width,height);
+    }
+
+    private final native void gljResizeNative( boolean isOwnWindow,
+				               int disp, int thisWin,
+				               int width, int height );
+
+    /**
+     * native C function to open the OpenGLwidget
+     */
+    protected final native boolean openOpenGLNative();
+
+    /**
+     * native C function to check the gl types.
+     * At this time, all GL* types will be checked if they fit's
+     * in the used java JNI types.
+     *
+     * this checks is allready performed, while the GL context is
+     * fetched with gljInit !
+     *
+     * BUT we used this function, to perform a check without an
+     * X11-connection to our AIX host ;-))
+     * So a call to this function is not needed !
+     */
+    public static final boolean gljCheckGLTypes()
+    {
+        return gljCheckGLTypesNative();
+    }
+
+    private static final native boolean gljCheckGLTypesNative();
+
+    public final boolean gljCheckGL()
+    {
+	int ec = gl.glGetError();
+
+	if(ec!=GLFunc.GL_NO_ERROR)
+	{
+		String errStr = glu.gluErrorString(ec);
+
+		try
+		{
+		   throw new Exception();
+		}
+		catch (Exception e)
+		{
+		   System.out.println("GL ERROR : "+errStr);
+		   System.out.println("GL ERROR : "+ec+" == 0x"+Integer.toHexString(ec));
+		   e.printStackTrace();
+		   System.out.println();
+		   System.out.flush();
+		}
+
+		return false;
+	}
+	return true;
+    }
+
+   /**
+    *
+    * gljMakeCurrent checks whether GL4Java is initializes 
+    * AND makes the GL-Context current for this thread.
+    *
+    * It's more save to use �gljMakeCurrent�, instead of
+    * �gljMakeCurrentNative�, because we do check if GL is initalised !
+    *
+    * @return 		boolean
+    */ 
+    public final boolean gljMakeCurrent()
+    {
+    	if ( ! isInitialized || !glEnabled )
+	    return false;
+
+        return  gljMakeCurrentNative( displayHandle,
+				      windowHandle,
+				      glContext);
+    }
+
+
+   /**
+    *
+    * gljMakeCurrent checks whether GL4Java is initializes 
+    * AND makes the GL-Context current for this thread.
+    *
+    * It's more save to use �gljMakeCurrent�, instead of
+    * �gljMakeCurrentNative�, because we do check if GL is initalised !
+    *
+    * @param	freeContextFirst is obsolete !
+    *
+    * @return 		boolean
+    *
+    * @deprecated The argument freeContextFirst is obsolete !
+    */ 
+    public final boolean gljMakeCurrent(boolean freeContextFirst)
+    {
+    	if ( ! isInitialized || !glEnabled )
+	    return false;
+
+        return  gljMakeCurrentNative( displayHandle,
+				      windowHandle,
+				      glContext);
+    }
+
+    private static final native boolean gljMakeCurrentNative(
+    						int disp, 
+    					        int thisWin,
+					        int glContext);
+
+   /**
+    *
+    * gljGetCurrentContext fetches the current native
+    * GL-Context, which is attached to this _native_ thread !
+    *
+    * @return 		int
+    */ 
+    public static final native int gljGetCurrentContext();
+
+    /**
+     *
+     * gljDestroy free�s AND destroy�s the GL Context
+     *
+     * This function should be called when removing 
+     * a GLContext !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+     *
+     * @return 		void
+     *
+     * @see GLContext#gljMakeCurrent
+     * @see GLContext#gljSwap
+     */ 
+     public final synchronized boolean gljDestroy()
+     {
+        boolean result = true;
+
+        if (!gljDestroyNative()) 
+		result = false;
+
+        windowHandle = 0;
+        glContext = 0;
+	pixmapHandle = 0;
+
+
+	if ( useMSJDirect )
+	{
+		destroyWindow = false;
+		gl4java.system.GljMSJDirect.destroyOGLWindowNative( pData );
+		windowHandle = 0;
+		gl4java.system.GljMSJDirect.OGLWindowMsgPump();
+	}
+
+        pData = 0;
+
+        return result;
+    }
+
+     private final native boolean gljDestroyNative();
+
+    /**
+     *
+     * gljFree free�s the GL Context
+     *
+     * This could be called after at last in your display function,
+     * if you have GC problems ....
+     *
+     * @return 		void
+     *
+     * @see GLContext#gljMakeCurrent
+     * @see GLContext#gljSwap
+     * @see gl4java.awt.GLCanvas#sDisplay
+     */ 
+    public final boolean gljFree()
+    {
+    	if ( ! isInitialized ) return false;
+
+        return gljFreeNative ( displayHandle,
+		               windowHandle,
+		               glContext);
+    }
+
+     private static final native boolean gljFreeNative( int disp, 
+    					                int thisWin,
+					                int glContext );
+
+    /**
+     * swap method are for double buffering
+     */
+    public final boolean gljSwap()
+    {
+    	if ( ! isInitialized ) return false;
+
+        return gljSwapNative( displayHandle,
+			      windowHandle,
+			      glContext,
+			      doubleBuffer);
+    }
+
+    private static final native boolean gljSwapNative( int disp, 
+    					              int thisWin,
+					              int glContext,
+						      boolean doubleBuffer );
+
+    /**
+     * This function enables, disables the GL-Context !
+     * If false is given, the openGL renderer/context is 
+     * disabled and disconected (gljFree is called, if initialized) !
+     *
+     * If disabled, gljMakeCurrent returns always false !
+     *
+     * @return 	boolean
+     *
+     * @see	GLContext#gljIsEnabled
+     * @see     GLContext#gljMakeCurrent
+     */ 
+    public void setEnabled(boolean b)
+    {
+        glEnabled = b;
+    	if ( b==false && isInitialized ) 
+		gljFree();
+    }
+
+    /**
+     * This function queries, if the GL-Context is enabled !
+     *
+     * @return 	boolean
+     *
+     * @see	GLContext#setEnabled
+     * @see     GLContext#gljMakeCurrent
+     */ 
+    public boolean isEnabled()
+    {
+        return glEnabled;
+    }
+
+    /**
+     * This functions checks the existence of 
+     * the GL functions !
+     */
+    public final static native boolean gljTestGLProc 
+    					( String name, boolean verbose );
+
+    /**
+     * This functions reads the pixel from the GL frame
+     * and puts it into the pixelDest array,
+     * while converting them correctly to the AWT pixel format,
+     * using GL_RGB[A] and BufferedImage.TYPE_INT[A]RGB !
+     */
+    public final static native void gljReadPixelGL2AWT (
+			int x, int y, int width, int height,
+			int format, int type, int bufferName,
+			byte[] pixelGL, int[] pixelDest);
+
+    /**
+     * Experimental Code, not done yet !
+     * This one is to upspeed the Offscreen rendering engine for e.g. Swing !
+     *
+     * This functions reads the pixel from the GL frame
+     * and puts it into the pixelDest array,
+     * while using hardware correct AWT and GL pixel format,
+     * using GL_BGR[A]_EXT and BufferedImage.TYPE_[34]BYTE_[A]BGR !
+     *
+     * ATTENTION: This functions runs only if hardware supports this,
+     * e.g. on Win32 platforms !!!
+     */
+    public final static native void gljReadPixelGL2AWT (
+			int x, int y, int width, int height,
+			int format, int type, int bufferName,
+			byte[] pixelGLDest);
+
+    /**
+     * Experimental Code, not done yet !
+     * This one is to upspeed the Offscreen rendering engine for e.g. Swing !
+     */
+    public final native void gljCpyOffScrnImg2Buffer(int width, int height, int format, byte[] pixelDest);
+
+    /**
+     * Experimental Code, not done yet !
+     * This one is to upspeed the Offscreen rendering engine for e.g. Swing !
+     */
+    public final native void gljCpyOffScrnImg2Buffer(int width, int height, int format, int[] pixelDest);
+
+    /**
+     * native C function to achieve the native lib vendor !
+     *
+     * now it is possible to check the native-lib at runtime !
+     */
+    public final static String gljGetNativeLibVendor()
+    {
+        return gljGetNativeLibVendorNative();
+    }
+
+    private final static native String gljGetNativeLibVendorNative();
+
+    /**
+     * native C function to achieve the native lib version !
+     *
+     * now it is possible to check the native-lib at runtime !
+     */
+    public final static String gljGetNativeLibVersion()
+    {
+        return gljGetNativeLibVersionNative();
+    }
+
+    private final static native String gljGetNativeLibVersionNative();
+
+    /**
+     * function to achieve the java-class version !
+     *
+     * now it is possible to check the java-class at runtime !
+     */
+    public final static String gljGetClassVersion()
+    { return version; }
+
+    /**
+     * function to achieve the java-class vendor !
+     *
+     * now it is possible to check the java-class at runtime !
+     */
+    public final static String gljGetClassVendor()
+    { return "Jausoft - Sven Goethel Software Development"; }
+
+    /**
+     * function to achieve complete version info
+     *
+     * Be sure that the native library must be loaded !
+     */
+    public final String gljGetVersions()
+    {
+	return gljGetVersions(false);
+    }
+
+    public final String gljGetVersions(boolean verbose)
+    {
+      if(libsLoaded==false || gl==null || glu==null || !gljIsInit())
+      	return null;
+
+      String info1= "GL4Java - LGPL-Version"                       + "\n" +
+      	            "-------------------------------------------------\n" +
+      	            "-------------------------------------------------\n" +
+		    "Java-Class         : GL4Java.GLContext           \n" +
+		    "          : Version: "+gljGetClassVersion()   + "\n" +
+		    "            Vendor : "+gljGetClassVendor()    + "\n" +
+		    "Native-Library     : GL4Java.GLContext           \n" +
+		    "            Version: "+gljGetNativeLibVersion()+"\n" +
+		    "            Vendor : "+gljGetNativeLibVendor() +"\n" +
+      	            "-------------------------------------------------\n" +
+		    "Java-Class         : GL4Java.GLFunc impl.        \n" +
+		    "          : Version: "+gl.getClassVersion()   + "\n" +
+		    "            Vendor : "+gl.getClassVendor()    + "\n" +
+		    "Native-Library     : GL4Java.GLFunc impl.        \n" +
+		    "            Version: "+gl.getNativeVersion()  + "\n" +
+		    "            Vendor : "+gl.getNativeVendor()   + "\n" +
+      	            "-------------------------------------------------\n" +
+		    "Java-Class         : GL4Java.GLUFunc impl.       \n" +
+		    "          : Version: "+glu.getClassVersion()  + "\n" +
+		    "            Vendor : "+glu.getClassVendor()   + "\n" +
+		    "Native-Library     : GL4Java.GLUFunc impl.       \n" +
+		    "            Version: "+glu.getNativeVersion() + "\n" +
+		    "            Vendor : "+glu.getNativeVendor()  + "\n" +
+      	            "-------------------------------------------------\n" +
+		    "\n" ;
+
+        String glVen = gl.glGetString(GLFunc.GL_VENDOR);
+	String glRen = gl.glGetString(GLFunc.GL_RENDERER);
+	String glVer = gl.glGetString(GLFunc.GL_VERSION);
+	String glExt = gl.glGetString(GLFunc.GL_EXTENSIONS);
+	String gluVer = glu.gluGetString(GLUFunc.GLU_VERSION);
+	String gluExt = glu.gluGetString(GLUFunc.GLU_EXTENSIONS);
+
+     String info2=      "OpenGL - Versions                              \n" +
+      	                "-----------------------------------------------\n" +
+	                "GL  VENDOR: "+glVen+"\n"+
+			"GL  RENDERER: "+glRen+"\n"+
+			"GL  VERSION: "+glVer+"\n"+
+			"GL  EXTENSIONS: "+glExt+"\n"+
+			"GLU VERSION: "+gluVer+"\n"+
+			"GLU EXTENSIONS: "+gluExt+"\n"+"\n" ;
+	
+     String info3=      "OpenGL - Function Test ("+ 
+     			GLFunc.GL_PROC_NAMES.length +" Functions)       \n" +
+      	                "-----------------------------------------------\n";
+
+     if(verbose)
+     {
+	 System.out.println(info1);
+	 System.out.println(info2);
+	 System.out.println(info3);
+     }
+	 
+     String h;	
+     String tmp;
+
+     for(int i=0; i<GLFunc.GL_PROC_NAMES.length; i++)
+     {
+        h=GLFunc.GL_PROC_NAMES[i];
+	if(h==null) break;
+
+     	if(gljTestGLProc (h, verbose))
+		tmp= "OK  : "+h+"\n";
+	else
+		tmp= "NOPE: "+h+"\n";
+	    
+	info3 += tmp;
+     }
+
+     return info1+"\n"+info2+"\n"+info3;
+    }
+
+    /**
+     * function to show complete version info into an extra Frame
+     *
+     * Be sure that the native library must be loaded !
+     */
+    public final Frame gljShowVersions()
+    {
+	Frame f = new Frame("GL4Java Version");
+	TextArea info= new TextArea(25, 80);
+	info.setEditable(false);
+	f.add(info);
+	f.setSize(600, 400);
+
+	f.pack();
+	f.setVisible(true);
+
+	String str = "null string";
+	if( gljMakeCurrent(true) == false ) 
+	{
+		str="problem in use() method\n";
+	} else {
+		str=gljGetVersions(gljNativeDebug);
+		if(str==null)
+			str="could not get versions";
+		System.out.println(str);
+		gljFree();
+	}
+	info.append(str);
+
+	f.addWindowListener
+			   ( new WindowAdapter()
+			      {
+				public void windowClosing(WindowEvent e)
+				{
+				   // button window menu ... :-)
+				   e.getWindow().dispose();
+				}
+			      }
+			    );              
+
+	return f;
+    }
+
+}
+