/*

* Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.

* Copyright (c) 2010 JogAmp Community. All rights reserved.

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions are

* met:

* - Redistribution of source code must retain the above copyright

* notice, this list of conditions and the following disclaimer.

* - Redistribution in binary form must reproduce the above copyright

* notice, this list of conditions and the following disclaimer in the

* documentation and/or other materials provided with the distribution.

* Neither the name of Sun Microsystems, Inc. or the names of

* contributors may be used to endorse or promote products derived from

* this software without specific prior written permission.

* This software is provided "AS IS," without a warranty of any kind. ALL

* EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,

* INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A

* DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,

* ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF

* SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.

* You acknowledge that this software is not designed or intended for use

* in the design, construction, operation or maintenance of any nuclear

* facility.

* Sun gratefully acknowledges that this software was originally authored

* and developed by Kenneth Bradley Russell and Christopher John Kline.

*/

private static final boolean DEBUG = Debug.debug("GLCanvas");

private AWTGraphicsConfiguration awtConfig;

private volatile GLDrawable drawable;

private GLContextImpl context;

private boolean sendReshape = false;

// copy of the cstr args, mainly for recreation

private GLCapabilitiesImmutable capsReqUser;

private GLCapabilitiesChooser chooser;

private GLContext shareWith;

private GraphicsDevice device;

private boolean shallUseOffscreenLayer = false;

private AWTWindowClosingProtocol awtWindowClosingProtocol =

new AWTWindowClosingProtocol(this, new Runnable() {

public void run() {

GLCanvas.this.destroy();

}

/** Creates a new GLCanvas component with a default set of OpenGL

capabilities, using the default OpenGL capabilities selection

* @throws GLException if no default profile is available for the default desktop device.

*/

public GLCanvas() throws GLException {

/** Creates a new GLCanvas component with the requested set of

OpenGL capabilities, using the default OpenGL capabilities

* @throws GLException if no GLCapabilities are given and no default profile is available for the default desktop device.

* @see GLCanvas#GLCanvas(javax.media.opengl.GLCapabilitiesImmutable, javax.media.opengl.GLCapabilitiesChooser, javax.media.opengl.GLContext, java.awt.GraphicsDevice)

*/

* @throws GLException if no GLCapabilities are given and no default profile is available for the default desktop device.

* @see GLCanvas#GLCanvas(javax.media.opengl.GLCapabilitiesImmutable, javax.media.opengl.GLCapabilitiesChooser, javax.media.opengl.GLContext, java.awt.GraphicsDevice)

*/

{

this(capsReqUser, null, shareWith, null);

}

sharing</a>. The passed GraphicsDevice indicates the screen on

which to create the GLCanvas; the GLDrawableFactory uses the

default screen device of the local GraphicsEnvironment if null

* @throws GLException if no GLCapabilities are given and no default profile is available for the default desktop device.

*/

public GLCanvas(GLCapabilitiesImmutable capsReqUser,

GLCapabilitiesChooser chooser,

GLContext shareWith,

{

/*

* Determination of the native window is made in 'super.addNotify()',

this.device = device;

}

public void setShallUseOffscreenLayer(boolean v) {

shallUseOffscreenLayer = v;

}

public final boolean getShallUseOffscreenLayer() {

}

public final boolean isOffscreenLayerSurfaceEnabled() {

if(null != drawable) {

return ((JAWTWindow)drawable.getNativeSurface()).isOffscreenLayerSurfaceEnabled();

return false;

}

/**

* Overridden to choose a GraphicsConfiguration on a parent container's

* GraphicsDevice because both devices

*/

public GraphicsConfiguration getGraphicsConfiguration() {

/*

* Workaround for problems with Xinerama and java.awt.Component.checkGD

* when adding to a container on a different graphics device than the

* one that this Canvas is associated with.

* GC will be null unless:

* - A native peer has assigned it. This means we have a native

* peer, and are already comitted to a graphics configuration.

* chosen is only non-null on platforms where the GLDrawableFactory

* returns a non-null GraphicsConfiguration (in the GLCanvas

* constructor).

* if gc is from this Canvas' native peer then it should equal chosen,

* otherwise it is from an ancestor component that this Canvas is being

* added to, and we go into this block.

* Check for compatibility with gc. If they differ by only the

* device then return a new GCconfig with the super-class' GDevice

* (and presumably the same visual ID in Xinerama).

*/

if (!chosen.getDevice().getIDstring().equals(gc.getDevice().getIDstring())) {

/*

* Here we select a GraphicsConfiguration on the alternate

* device that is presumably identical to the chosen

* configuration, but on the other device.

* Should really check to ensure that we select a configuration

* with the same X visual ID for Xinerama screens, otherwise the

* GLDrawable may have the wrong visual ID (I don't think this

* ever gets updated). May need to add a method to

* X11GLDrawableFactory to do this in a platform specific

* manner.

* However, on platforms where we can actually get into this

* block, both devices should have the same visual list, and the

* same configuration should be selected here.

* return the GC that was selected in the constructor (and might

* cause an exception in Component.checkGD when adding to a

* container, but in this case that would be the desired behavior).

*/

return chosen;

} else if (gc == null) {

*/

return gc;

}

public GLContext createContext(GLContext shareWith) {

return (null != drawable) ? drawable.createContext(shareWith) : null;

}

public void setRealized(boolean realized) {

}

public boolean isRealized() {

return ( null != drawable ) ? drawable.isRealized() : false;

}

return ( null != drawable ) ? drawable.isRealized() : false;

}

public WindowClosingMode getDefaultCloseOperation() {

return awtWindowClosingProtocol.getDefaultCloseOperation();

}

public WindowClosingMode setDefaultCloseOperation(WindowClosingMode op) {

return awtWindowClosingProtocol.setDefaultCloseOperation(op);

}

public void display() {

if( !validateGLDrawable() ) {

if(DEBUG) {

}

return; // not yet available ..

}

awtWindowClosingProtocol.addClosingListenerOneShot();

}

disposeRegenerate=regenerate;

if(context.isCreated()) {

}

if(animatorPaused) {

animator.resume();

}

}

if(!regenerate) {

disposeAbstractGraphicsDevice();

}

}

/**

*/

public void destroy() {

removeNotify();

}

jawtWindow.unlockSurface();

}

}

private boolean validateGLDrawable() {

boolean realized = false;

if (!Beans.isDesignTime()) {

realized = drawable.isRealized();

if ( !realized && 0 < drawable.getWidth() * drawable.getHeight() ) {

// make sure drawable realization happens on AWT EDT, due to AWTTree lock

realized = true;

sendReshape=true; // ensure a reshape is being send ..

if(DEBUG) {

}

return realized;

}

drawable.setRealized(true);

} };

/** <B>Overrides:</B>

<DL><DD><CODE>update</CODE> in class <CODE>java.awt.Component</CODE></DD></DL> */

* Overridden from Canvas to prevent the AWT's clearing of the

* canvas from interfering with the OpenGL rendering.

*/

public void update(Graphics g) {

paint(g);

}

public void addGLEventListener(GLEventListener listener) {

drawableHelper.addGLEventListener(listener);

}

public void addGLEventListener(int index, GLEventListener listener) {

drawableHelper.addGLEventListener(index, listener);

}

public void removeGLEventListener(GLEventListener listener) {

drawableHelper.removeGLEventListener(listener);

}

public void setAnimator(GLAnimatorControl animatorControl) {

drawableHelper.setAnimator(animatorControl);

}

public GLAnimatorControl getAnimator() {

return drawableHelper.getAnimator();

}

public void invoke(boolean wait, GLRunnable glRunnable) {

drawableHelper.invoke(this, wait, glRunnable);

}

public void setContext(GLContext ctx) {

context=(GLContextImpl)ctx;

if(null != context) {

}

}

public GLContext getContext() {

return context;

}

public GL getGL() {

if (Beans.isDesignTime()) {

return null;

return (ctx == null) ? null : ctx.getGL();

}

public GL setGL(GL gl) {

GLContext ctx = getContext();

if (ctx != null) {

}

public void setAutoSwapBufferMode(boolean onOrOff) {

drawableHelper.setAutoSwapBufferMode(onOrOff);

}

public boolean getAutoSwapBufferMode() {

return drawableHelper.getAutoSwapBufferMode();

}

public void swapBuffers() {

}

public void setContextCreationFlags(int flags) {

additionalCtxCreationFlags = flags;

}

public int getContextCreationFlags() {

}

public GLProfile getGLProfile() {

return capsReqUser.getGLProfile();

}

public GLCapabilitiesImmutable getChosenGLCapabilities() {

if (awtConfig == null) {

throw new GLException("No AWTGraphicsConfiguration: "+this);

return (GLCapabilitiesImmutable)awtConfig.getRequestedCapabilities();

}

public NativeSurface getNativeSurface() {

return (null != drawable) ? drawable.getNativeSurface() : null;

}

public long getHandle() {

return (null != drawable) ? drawable.getHandle() : 0;

}

public GLDrawableFactory getFactory() {

return (null != drawable) ? drawable.getFactory() : null;

}

public String toString() {

final int dw = (null!=drawable) ? drawable.getWidth() : -1;

final int dh = (null!=drawable) ? drawable.getHeight() : -1;

return "AWT-GLCanvas[Realized "+isRealized()+

",\n\tFactory "+getFactory()+

",\n\thandle 0x"+Long.toHexString(getHandle())+

",\n\tDrawable size "+dw+"x"+dh+

",\n\tvisible "+isVisible()+

",\n\t"+awtConfig+"]";

}

//----------------------------------------------------------------------

// Internals only below this point

//

private boolean disposeRegenerate;

private final Runnable postDisposeAction = new Runnable() {

public void run() {

context=null;

if(null!=drawable) {

drawable=null;

if(null!=jawtWindow) {

jawtWindow.destroy();

}

if(disposeRegenerate) {

// Similar process as in addNotify()!

// Recreate GLDrawable/GLContext to reflect it's new graphics configuration

createDrawableAndContext();

if(DEBUG) {

System.err.println(getThreadName()+": GLCanvas.dispose(true): new drawable: "+drawable);

}

validateGLDrawable(); // immediate attempt to recreate the drawable

}

}

public void run() {

}

};

private final Runnable disposeAbstractGraphicsDeviceAction = new Runnable() {

public void run() {

if(null != awtConfig) {

final AbstractGraphicsDevice adevice = aconfig.getScreen().getDevice();

final String adeviceMsg;

if(DEBUG) {

adeviceMsg = adevice.toString();

} else {

}

boolean closed = adevice.close();

if(DEBUG) {

}

private final Runnable initAction = new Runnable() {

public void run() {

drawableHelper.init(GLCanvas.this);

}

};

private final Runnable displayAction = new Runnable() {

public void run() {

if (sendReshape) {

if(DEBUG) {

};

private final Runnable swapBuffersAction = new Runnable() {

public void run() {

drawable.swapBuffers();

}

// Workaround for ATI driver bugs related to multithreading issues

// like simultaneous rendering via Animators to canvases that are

// being resized on the AWT event dispatch thread

public void run() {

drawableHelper.invokeGL(drawable, context, displayAction, initAction);

}

};

public void run() {

drawableHelper.invokeGL(drawable, context, swapBuffersAction, initAction);

};

// Disables the AWT's erasing of this Canvas's background on Windows

if (!disableBackgroundEraseInitialized) {

try {

AccessController.doPrivileged(new PrivilegedAction<Object>() {

public Object run() {

try {

Class<?> clazz = getToolkit().getClass();

return null;

}

AWTGraphicsScreen.createScreenDevice(device, AbstractGraphicsDevice.DEFAULT_UNIT):

AWTGraphicsScreen.createDefault();

AWTGraphicsConfiguration config = null;

try {

final ArrayList<AWTGraphicsConfiguration> bucket = new ArrayList<AWTGraphicsConfiguration>(1);

EventQueue.invokeAndWait(new Runnable() {

public void run() {

AWTGraphicsConfiguration c = (AWTGraphicsConfiguration)

GraphicsConfigurationFactory.getFactory(AWTGraphicsDevice.class).chooseGraphicsConfiguration(capsChosen,

return config;

}

protected static String getThreadName() {

return Thread.currentThread().getName();

}

/**

* A most simple JOGL AWT test entry

*/

frame.setSize(128, 128);

glCanvas.addGLEventListener(new GLEventListener() {

public void init(GLAutoDrawable drawable) {

GL gl = drawable.getGL();

System.err.println(JoglVersion.getGLInfo(gl, null));

}

public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) { }

public void display(GLAutoDrawable drawable) { }

public void dispose(GLAutoDrawable drawable) { }

});

try {

javax.swing.SwingUtilities.invokeAndWait(new Runnable() {

public void run() {

frame.setVisible(true);

}});

glCanvas.display();

try {

javax.swing.SwingUtilities.invokeAndWait(new Runnable() {

public void run() {

frame.dispose();

}});