package gl4java.awt;

import gl4java.*;
import gl4java.drawable.*;
import gl4java.drawable.utils.*;

import java.awt.*;
import java.awt.geom.*;
import java.awt.image.*;
import java.awt.event.*;

/**
 * This is meant as an base class writing
 * easy offscreen render functions. 
 *
 * <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>
 *
 * There are two ways of using a GLOffScreenDrawable: the {@link
 * gl4java.drawable.GLEventListener} model or the subclassing model. Earlier
 * versions of the system only supported the subclassing model. The
 * default implementations of {@link #init}, {@link #display},
 * {@link #reshape} and {@link #doCleanup}
 * now send events to GLEventListeners; they can
 * still be overridden as before to support the subclassing model.
 *
 * <p>
 * If using the subclassing model, you should override the following
 * methods for your needs:
 * <pre>
        <a href="GLOffScreenDrawable.html#init()">preInit - initialisation before creating GLContext</a>
        <a href="GLOffScreenDrawable.html#init()">init - 1st initialisation after creating GLContext</a>
        <a href="GLOffScreenDrawable.html#doCleanup()">doCleanup - OGL cleanup prior to context deletion</a>
        <a href="GLOffScreenDrawable.html#display()">display - render your frame</a>
	<a href="GLOffScreenDrawable.html#reshape(int, int)">reshape - to reshape (window resize), gljResize() is allready invoked !</a>
 * </pre>
 *
 * To check if you can use the GLContext and GL and GLU methods,
 * use the function
 * <pre>
        <a href="GLOffScreenDrawable.html#cvsIsInit()">cvsIsInit</a>
 * </pre>
 * <p>  
 * IF you remove/release a GLOffScreenDrawable,
 * e.g. you want to close/dispose it´s Window (which contains this GLOffScreenDrawable),
 * you HAVE TO call:
 *
 * <pre>
        <a href="GLOffScreenDrawable.html#cvsDispose()">cvsDispose</a>
 * </pre>
 * You should call this before releasing/dispose this Window ! 
 * Also you can overwrite this class,
 * to dispose your own elements, e.g. a Frame etc. - 
 * but be shure that you call
 * cvsDispose implementation call this one !
 * 
 * <p>  
 * We do offer the following Canvas methods.
 *
 * <pre>
        <a href="GLOffScreenDrawable.html#repaint(java.awt.Graphics)">repaint</a>
 * </pre>
 * <p>        
 *
 * @version 	2.0, 21. April 1999
 * @author      Sven Goethel
 *  */
public class GLOffScreenDrawable
	implements GLEnum, GLUEnum,
                   GLDrawable
{
    protected GLContext glj = null;
    public GLFunc gl = null;
    public GLUFunc glu = null;

    protected boolean cvsInitialized=false;

    protected boolean needCvsDispose = false;

    /**
     * Visual pre-set for stencil-bit number, default: 0
     * This value is updated after a GLContext is created with the
     * original updated value of GLContext !
     *
     * @see gl4java.awt.GLOffScreenDrawable#preInit
     * @see gl4java.awt.GLOffScreenDrawable#repaint
     */
    protected int stencilBits = 0;

    /**
     * Visual pre-set for accumulator buffer size, default: 0
     * This value is updated after a GLContext is created with the
     * original updated value of GLContext !
     *
     * @see gl4java.awt.GLOffScreenDrawable#preInit
     * @see gl4java.awt.GLOffScreenDrawable#repaint
     */
    protected int accumSize = 0;

    /**
     * Visual pre-set for stereoView, default: false
     * This value is updated after a GLContext is created with the
     * original updated value of GLContext !
     *
     * @see gl4java.awt.GLOffScreenDrawable#preInit
     * @see gl4java.awt.GLOffScreenDrawable#repaint
     */
    protected boolean stereoView = false;

   /**
    * Visual pre-set for RGBA usage, default: true - of course ;-)
    * This value is updated after a GLContext is created with the
    * original updated value of GLContext !
    *
    * @see gl4java.awt.GLOffScreenDrawable#preInit
    * @see gl4java.awt.GLOffScreenDrawable#repaint
    */
    protected boolean rgba = true;    

   /**
    * The context with witch display lists and textures will be shared.
    *
    * @see gl4java.awt.GLOffScreenDrawable#preInit
    * @see gl4java.awt.GLOffScreenDrawable#repaint
    */
    protected GLContext sharedGLContext;	

   /**
    * The data to hold the offscreen pixels on the java side !
    *
    * @see gl4java.awt.GLOffScreenDrawable#repaint
    */
    protected BufferedImage offImage = null;

    protected int glFormat=0;
    protected int glType=0;
    protected int glComps=0;
    protected int awtFormat=0;

   /**
    * 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)
    *
    * @see gl4java.awt.GLOffScreenDrawable#setOffScreenSize
    * @see gl4java.awt.GLOffScreenDrawable#getOffScreenSize
    */
    protected Dimension offScrnSize = null;
    protected boolean offScrnSizeChanged=false;

    // The list of GLEventListeners
    private GLEventListenerList listeners = new GLEventListenerList();

    static {
	if(GLContext.doLoadNativeLibraries(null, null, null)==false)
	  System.out.println("GLOffScreenDrawable could not load def. native libs.");
    }

    /**
     *
     * Constructor
     *
     * @param gl_Name     The name of the GLFunc implementation
     *                    If gl_Name==null, the default class will be used !
     *
     * @param glu_Name    The name of the GLUFunc implementation
     *                    If gl_LibName==null, the default class will be used !
     *
     * @param size        The offscreen Size 
     */
    public GLOffScreenDrawable( String gl_Name, 
			     String glu_Name,
			     Dimension size
		           )
    {
	if( (gl=GLContext.createGLFunc(gl_Name)) ==null)
	{
	  System.out.println("GLFunc implementation "+gl_Name+" not created");
	}
	if( (glu=GLContext.createGLUFunc(glu_Name)) ==null)
	{
	  System.out.println("GLUFunc implementation "+glu_Name+" not created");
	}
	offScrnSizeChanged=true;
	offScrnSize=size; 
    }

    /**
     *
     * Constructor
     *
     * @param size        The offscreen Size 
     */
    public GLOffScreenDrawable(Dimension size )
    {
	this(null, null, size);
    }

    /**
     * Used to return the created GLContext
     */
    public final GLContext getGLContext() { return glj; }

   /**
    * Get the customers offscreen Size
    *
    * If this is set, 
    * the offscreen pixmap is used in this size,
    * not in the components-size (-> faster if smaller)
    *
    * @see gl4java.awt.GLOffScreenDrawable#offScrnSize
    * @see gl4java.awt.GLOffScreenDrawable#setSize
    */
    public Dimension getSize()
    { return offScrnSize; }

   /**
    * The customers offscreen Size
    *
    * If this is set, 
    * the offscreen pixmap is used in this size,
    * not in the components-size (-> faster if smaller)
    *
    * @see gl4java.awt.GLOffScreenDrawable#offScrnSize
    * @see gl4java.awt.GLOffScreenDrawable#getOffScreenSize
    */
    public void setSize(Dimension size)
    {
    	if((size!=null && size.equals(offScrnSize)==false) ||
	   size!=offScrnSize
	  )
	{
    		offScrnSizeChanged=true;
                offScrnSize=size; 
	        initDrawable();
	}
    }

    /**
     * The data to hold the offscreen pixels on the java side !
     *
     * @see gl4java.awt.GLOffScreenDrawable#repaint
     */
    public BufferedImage getImage()
    {
    	return offImage;
    }

    /**
     * The data to hold the offscreen pixels on the java side !
     *
     * @param gr	the Graphics which should draw
     * @param x         the destination x pos to draw
     * @param y         the destination y pos to draw
     * @param width     the destination width to draw
     * @param height    the destination height to draw
     * @param notifiedObject the notified Object for proceding
     */
    public void drawImage(Graphics gr, int x, int y, int width, int height,
                          ImageObserver notifiedObject)
    {
	    gr.drawImage(offImage, x, y, width, height, 
                         notifiedObject);
    }
	     
    /**
     * The format of GL pixel data
     *
     * @see gl4java.GLFunc#glReadPixels
     */
    public int getGLFormat()
    {
    	return glFormat;
    }

    /**
     * The type of GL pixel data
     *
     * @see gl4java.GLFunc#glReadPixels
     */
    public int getGLType()
    {
    	return glType;
    }

    /**
     * The number of byte components per pixel
     *
     * @see gl4java.GLFunc#glReadPixels
     */
    public int getGLComponents()
    {
    	return glComps;
    }

    /**
     * The AWT BufferedImage Type
     */
    public int getAwtFormat()
    {
    	return awtFormat;
    }

    /**
     * The initialisation procedure
     *
     * must be called by the user at least once,
     * best after adding the GLEventListener's !
     *
     * @see gl4java.awt.GLOffScreenDrawable#repaint
     */
    public synchronized final void initDrawable()
    {
	if(glj == null || offScrnSizeChanged  )
	{
		cvsDispose();
		preInit();
		glj = GLContext.createOffScreenCtx ( 
				      gl, glu, 
		                      stereoView,
				      rgba, stencilBits, accumSize,
				      sharedGLContext,
				      offScrnSize
				      );

		if(glj!=null)
		{
			stencilBits = glj.getStencilBitNumber();
			accumSize = glj.getAccumSize();
			stereoView = glj.isStereoView();
			rgba = glj.isRGBA();
		}
		if(offImage!=null)
			offImage.flush();
		offImage=null;
		offScrnSizeChanged=false;

		init();
	        Dimension size = getSize();
		reshape(size.width, size.height);

		if(glj!=null && glj.gljIsInit())
			cvsInitialized=true;
	} 
	repaint();
    }

    Graphics gr = null;
    DataBufferInt dbInt = null;
    DataBufferUShort dbUShort = null;
    DataBufferByte dbByte = null;

    /**
     * this function can be called to force a repaint
     *
     * Repaints this component. 
     *
     * This method causes a call to this component's update method 
     * as soon as possible.
     *
     * This is the thread save rendering-method called by yourself.
     * The actual thread will be set to highes priority befor calling
     * 'display'. After 'display' the priority will be reset !
     *
     * 'gljFree' will be NOT called after 'display'.
     * 
     * We tested the above to use multi-threading and
     * for the demonstration 'glDemos' it works ;-)) !
     *
     * BE SURE, if you want to call 'display' by yourself
     * (e.g. in the run method for animation)
     * YOU HAVE TO CALL sDisplay  -- OR YOU MUST KNOW WHAT YOU ARE DOING THEN !
     *
     * @return 		void
     *
     * @see gl4java.awt.GLOffScreenDrawable#display
     * @see gl4java.awt.GLEventListener#preDisplay
     * @see gl4java.awt.GLEventListener#display
     * @see gl4java.awt.GLEventListener#postDisplay
     */ 
    public synchronized final void repaint()
    {
        boolean ok = true;

	long _s = System.currentTimeMillis();

	if(!cvsIsInit())
		return;

        listeners.sendPreDisplayEvent(this);

	if( glj.gljMakeCurrent() == false ) {
		System.out.println("GLOffScreenDrawable: problem in use() method");
		return;
        }

	if(ok) 
	{
	    display();
	    _f_dur_self = System.currentTimeMillis()-_s;
	    if(GLContext.gljClassDebug)
	    {
	    	_f_dur_self_sum+=_f_dur_self;
		glj.gljCheckGL();
	    }

	    Dimension size = offScrnSize;
	    int w=size.width;
	    int h=size.height;

	    long _s_tst = System.currentTimeMillis();

	    if(offImage==null || 
	       offImage.getHeight()!=h  || offImage.getWidth()!=w)
	    {
	        GLCapabilities caps = glj.getGLCapabilities();

    		switch ( GLContext.getNativeOSType() )
		{
		    case GLContext.OsWindoof:
	        	if(caps.getAlphaBits()>0)
				awtFormat = BufferedImage.TYPE_INT_ARGB;
	        	else
				awtFormat = BufferedImage.TYPE_INT_RGB;
			break;
		    case GLContext.OsX11:
		    case GLContext.OsMac9:
		    case GLContext.OsMacX:
		    case GLContext.OsUnknown:
		    default:
	        	if(caps.getAlphaBits()>0)
		    		awtFormat = BufferedImage.TYPE_INT_ARGB;
	        	else
		    		awtFormat = BufferedImage.TYPE_3BYTE_BGR;
			break;
		}

	    	if(offImage!=null)
			offImage.flush();

		offImage = new BufferedImage(w,h,awtFormat);

	        dbByte=null;
	        dbUShort=null;
	        dbInt=null;

		switch (awtFormat)
		{
			case BufferedImage.TYPE_3BYTE_BGR:
			        if(GLContext.gljClassDebug)
				System.out.println("awt=3BYTE_BGR, gl=BGR,UNSIGNED_BYTE");
				glFormat = GL_BGR;
				glType   = GL_UNSIGNED_BYTE;
				glComps  = 3;
			        dbByte   = (DataBufferByte)
				           offImage.getRaster().getDataBuffer();
				break;
			case BufferedImage.TYPE_4BYTE_ABGR:
			        if(GLContext.gljClassDebug)
				System.out.println("awt=4BYTE_ABGR, gl=BGRA,UNSIGNED_INT_8_8_8_8");
				glFormat = GL_BGRA;
				glType   = GL_UNSIGNED_BYTE;
				glComps  = 4;
			        dbByte   = (DataBufferByte)
				           offImage.getRaster().getDataBuffer();
				break;
			case BufferedImage.TYPE_INT_RGB:
			        if(GLContext.gljClassDebug)
				System.out.println("awt=INT_RGB, gl=BGRA,UNSIGNED_BYTE");
				glFormat = GL_BGRA;
				glType   = GL_UNSIGNED_BYTE;
				glComps  = 4;
			        dbInt    = (DataBufferInt)
				           offImage.getRaster().getDataBuffer();
				break;
			case BufferedImage.TYPE_INT_ARGB:
			        if(GLContext.gljClassDebug)
				System.out.println("awt=INT_ARGB, gl=BGRA,UNSIGNED_BYTE");
				glFormat = GL_BGRA;
				glType   = GL_UNSIGNED_BYTE;
				glComps  = 4;
			        dbInt    = (DataBufferInt)
				           offImage.getRaster().getDataBuffer();
				break;
			case BufferedImage.TYPE_INT_BGR:
			        if(GLContext.gljClassDebug)
				System.out.println("awt=INT_BGR, gl=BGRA,UNSIGNED_INT_8_8_8_8");
				glFormat = GL_BGRA;
				glType   = GL_UNSIGNED_INT_8_8_8_8;
				glComps  = 4;
			        dbInt    = (DataBufferInt)
				           offImage.getRaster().getDataBuffer();
				break;
			case BufferedImage.TYPE_USHORT_555_RGB:
			        if(GLContext.gljClassDebug)
				System.out.println("awt=USHORT_555_RGB, gl=RGBA,UNSIGNED_INT_5_5_5_1");
				glFormat = GL_RGBA;
				glType   = GL_UNSIGNED_SHORT_5_5_5_1;
				glComps  = 2;
			        dbUShort = (DataBufferUShort)
				           offImage.getRaster().getDataBuffer();
				break;
			case BufferedImage.TYPE_USHORT_565_RGB:
			        if(GLContext.gljClassDebug)
				System.out.println("awt=USHORT_565_RGB, gl=RGB,UNSIGNED_INT_5_6_5");
				glFormat = GL_RGB;
				glType   = GL_UNSIGNED_SHORT_5_6_5;
				glComps  = 2;
			        dbUShort = (DataBufferUShort)
				           offImage.getRaster().getDataBuffer();
				break;
		}
	    } 

	    if(dbByte!=null)
		    glj.gljReadPixelGL2AWT(w, 0,0, 0, 0, w, h, glFormat, glType,
				   glj.isDoubleBuffer()?GL_BACK:GL_FRONT,
				   dbByte.getData());
	    else if(dbUShort!=null)
		    glj.gljReadPixelGL2AWT(w, 0,0, 0, 0, w, h, glFormat, glType,
				   glj.isDoubleBuffer()?GL_BACK:GL_FRONT,
				   dbUShort.getData());
	    else if(dbInt!=null)
		    glj.gljReadPixelGL2AWT(w, 0,0, 0, 0, w, h, glFormat,glType,
				   glj.isDoubleBuffer()?GL_BACK:GL_FRONT,
				   dbInt.getData());

	    //glj.gljSwap(); // no true swapping with offscreen buffers ..

	    if(GLContext.gljClassDebug)
	    	_f_dur_tst_sum+=System.currentTimeMillis()-_s_tst;

	    if(GLContext.gljClassDebug)
		glj.gljCheckGL();
	    glj.gljFree(); // enable ctx for threads ...

	    _f_dur_total = System.currentTimeMillis()-_s;
	    if(GLContext.gljClassDebug)
	    {
	    	_f_dur_total_sum+=_f_dur_total;
		if(++_f_dur_times==100)
		{
			System.out.println("self p 100: "+
				(double)(_f_dur_self_sum/100)/1000.0+" s");

			System.out.println("tst p 100: "+
				(double)(_f_dur_tst_sum/100)/1000.0+" s");

			System.out.println("gl-bitblit p 100: "+
				(double)((_f_dur_total_sum-_f_dur_self_sum)/100)/1000.0+" s");
			System.out.println("total p 100: "+
				(double)(_f_dur_total_sum/100)/1000.0+" s");

			_f_dur_self_sum=0;
			_f_dur_tst_sum=0;
			_f_dur_total_sum=0;
			_f_dur_times=0;
		}
	    }
	}
        listeners.sendPostDisplayEvent(this);
    }

    /**
     *
     * This is the rendering-method called by repaint 
     *
     * <p>
     * The default implementation of display() sends display events to
     * all {@link gl4java.drawable.GLEventListener}s associated with this
     * GLOffScreenDrawable, and automatically calls {@link
     * gl4java.GLContext#gljMakeCurrent} and {@link
     * gl4java.GLContext#gljFree} as necessary.
     *
     * <p>}
     * If you use the subclassing model (as opposed to the
     * GLEventListener model), your subclass will redefine this to
     * perform its OpenGL drawing.
     *
     * <p>
     * BE SURE, if you want to call 'display' by yourself
     * (e.g. in the run method for animation)
     * YOU HAVE TO CALL sDisplay !
     *
     * 'sDisplay' manages a semaphore to avoid reentrance of
     * the display function !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
     *
     * @return 		void
     *
     * @see gl4java.awt.GLOffScreenDrawable#sDisplay
     * @see gl4java.awt.GLOffScreenDrawable#paint
     * @see gl4java.drawable.GLEventListener#display
     */ 
    public void display()
    {
        listeners.sendDisplayEvent(this);
    }

    /**
     *
     * This is your pre-init method.
     * preInit is called just BEFORE the GL-Context is created.
     * You should override preInit, to initialize your visual-stuff,
     * like the protected vars: doubleBuffer and stereoView
     *
     * @return 		void
     *
     * @see	gl4java.awt.GLOffScreenDrawable#paint
     * @see	gl4java.awt.GLOffScreenDrawable#stereoView
     * @see	gl4java.awt.GLOffScreenDrawable#rgba
     * @see	gl4java.awt.GLOffScreenDrawable#stencilBits
     * @see	gl4java.awt.GLOffScreenDrawable#accumSize
     */ 
    public void preInit()
    {
    }

    /**
     *
     * init is called right after the GL-Context is initialized.
     * The default implementation calls init() on all of this
     * component's GLEventListeners.
     *     
     * <p>
     * If using the subclassing model, you can override this to
     * perform one-time OpenGL initializations such as setting up
     * lights and display lists.
     *
     * @return 		void
     *
     * @see	gl4java.awt.GLOffScreenDrawable#paint
     * @see gl4java.drawable.GLEventListener#init
     */ 
    public void init()
    {
        listeners.sendInitEvent(this);
    }

    /**
     * This method is used to clean up any OpenGL stuff (delete textures
     * or whatever) prior to actually deleting the OpenGL context.
     * You should override this with your own version, if you need to do
     * any cleanup work at this phase.
     * This functions is called within cvsDispose
     *
     * @return 		void
     *
     * @see	gl4java.awt.GLOffScreenDrawable#cvsDispose
     * @see gl4java.drawable.GLEventListener#cleanup
     */
    public void doCleanup()
    {
        listeners.sendCleanupEvent(this);
    }

    /**
     * This function returns, if everything is init: the GLContext,
     * the and the users init function 
     * This value is set in the paint method!
     *
     * @return 	boolean
     *
     * @see	gl4java.awt.GLOffScreenDrawable#paint
     * @see	gl4java.awt.GLOffScreenDrawable#init
     */ 
    public boolean cvsIsInit()
    {
    	return cvsInitialized;
    }

    protected long _f_dur_self   = 0;
    protected long _f_dur_self_sum   = 0;
    protected long _f_dur_tst_sum   = 0;
    protected long _f_dur_total  = 0;
    protected long _f_dur_total_sum  = 0;
    protected int _f_dur_times  = 0;

    /**
     *
     * This ´reshape´ method will be invoked after the first paint command
     * after GLCanvas.componentResize is called AND only if ´gljMakeCurrent´ was
     * successful (so a call of gljMakeCurrent is redundant).
     * ´reshape´ is not an overloading of java.awt.Component.reshape,
     * ´reshape´ is more like ´glut´-reshape.
     * 
     * <p>
     * GLCanvas.reshape already has a simple default implementation,
     * which calls ´gljResize´ and ´glViewport´. It also sends the
     * reshape() event to all GLEventListeners. If using the
     * GLEventListener model, it may not be necessary to do anything
     * in your event listener's reshape() method; if using the
     * subclassing model, it may not be necessary to override this.
     *
     * <p>
     * The needed call to ´gljResize´ is done by the invoker paint !
     *
     * @param width		the new width
     * @param height	the new height
     * @return 		void
     *
     * @see gl4java.awt.GLOffScreenDrawable#paint
     * @see gl4java.awt.GLOffScreenDrawable#sDisplay
     * @see gl4java.drawable.GLEventListener#reshape
     */ 
    public void reshape( int width, int height )
    {
        if(GLContext.gljClassDebug)
          System.out.println("GLOffScreenDrawable::reshape size("+getSize()+")");
	gl.glViewport(0,0, width, height);
        listeners.sendReshapeEvent(this, width, height);
    }

    /**
      * You should call this before releasing/dispose this Window ! 
      * Also you can overwrite this class,
      * to dispose your own elements, e.g. a Frame etc. - 
      * but be shure that you call
      * cvsDispose implementation call this one !
      * 
      * This function calls gljDestroy of GLContext !
      *
      * @see gl4java.GLContext#gljDestroy
      * @see gl4java.awt.GLOffScreenDrawable#doCleanup
      * @see gl4java.drawable.GLEventListener#cleanup
      */
    public void cvsDispose()
    {
        cvsInitialized = false;
	if (glj != null)
	{
		if (glj.gljIsInit())
		{
			/* Sometimes the Microsoft VM calls the
			   Applet.stop() method but doesn't have
			   permissions to do J/Direct calls, so
			   this whole block of code will throw a
			   security exception.  If this happens,
			   however, windowClosing() will still
			   call us again later and we will have
			   another opportunity to shut down the
			   context, so it all works out fine. */
			try
			{
				glj.gljFree();
				doCleanup();
				//locks and free's GLContext	
				glj.setEnabled(false); 
				glj.gljDestroy();
        			needCvsDispose = false;
			}
			catch (Exception ex)
                	{
        			needCvsDispose = true;
                	}
		}
	}

	// Setting glj to null will simply cause paint() to re-initialize.
	// We don't want that to happen, so we will leave glj non-null.
    }

    /**
     * does nothing than:
     * 
     * @see	gl4java.awt.GLCanvas#cvsDispose
     */
    protected void finalize()
    	throws Throwable
    {
	if(GLContext.gljClassDebug)
		System.out.println("GLCanvas finalize ..");
	  
        cvsDispose();
	super.finalize();
    }

    /**
     * get methods
     */
    public final int cvsGetWidth() {
        return getSize().width;
     }
    public final int cvsGetHeight() {
        return getSize().height;
     }

    //----------------------------------------------------------------------
    // Implementation of GLDrawable
    //
    /**
     * the components listener's should be implemented also !
     * since JDK 1.1
     */
    public void addComponentListener(ComponentListener l)
    { }
    public void removeComponentListener(ComponentListener l)
    { }
    public void addFocusListener(FocusListener l)
    { }
    public void addKeyListener(KeyListener l)
    { }
    public void removeFocusListener(FocusListener l)
    { }
    public void addMouseListener(MouseListener l)
    { }
    public void removeMouseListener(MouseListener l)
    { }
    public void addMouseMotionListener(MouseMotionListener l)
    { }
    public void removeMouseMotionListener(MouseMotionListener l)
    { }

    public void addGLEventListener(GLEventListener listener) {
        listeners.add(listener);
    }

    public void removeGLEventListener(GLEventListener listener) {
        listeners.remove(listener);
    }

    public GLFunc getGL() {
        return gl;
    }

    public GLUFunc getGLU() {
        return glu;
    }
}