Disposes all added initialized GLEventListeners via GLEventListener#dispose(GLAutoDrawable).

If remove is true, the GLEventListeners are removed from this drawable queue before disposal, otherwise maked uninitialized.

Please consider using disposeAllGLEventListener(GLAutoDrawable, GLContext, boolean) or disposeGL(GLAutoDrawable, GLContext, boolean) for correctness, i.e. encapsulating all calls w/ makeCurrent etc.

Returns:int

the disposal count

Exceptions

GLException:

caused by GLEventListener#dispose(GLAutoDrawable)

Principal helper method which runs disposeAllGLEventListener(GLAutoDrawable, boolean) with the context made current.

If an GLAnimatorControl is being attached and the current thread is different than the animator's thread, it is paused during the operation.

Principal helper method which runs disposeAllGLEventListener(autoDrawable, false) with the context made current.

If destroyContext is true the context is destroyed in the end while holding the lock.

If destroyContext is false the context is natively released, i.e. released as often as locked before.

Parameters

destroyContext:boolean

destroy context in the end while holding the lock

Exceptions

GLException:

caused by GLEventListener#dispose(GLAutoDrawable) or context closing

Disposes the given GLEventListener via GLEventListener#dispose(GLAutoDrawable) if it has been initialized and added to this queue.

If remove is true, the GLEventListener is removed from this drawable queue before disposal, otherwise marked uninitialized.

Please consider using disposeGLEventListener(GLAutoDrawable, GLDrawable, GLContext, GLEventListener) for correctness, i.e. encapsulating all calls w/ makeCurrent etc.

Parameters

remove:boolean

if true, the listener gets removed

Returns:GLEventListener

the disposed and/or removed listener, otherwise null if neither action is performed

Principal helper method which runs disposeGLEventListener(GLAutoDrawable, GLEventListener, boolean) with the context made current.

If an GLAnimatorControl is being attached and the current thread is different than the animator's thread, it is paused during the operation.

Since GLContext's GLContext#makeCurrent() and GLContext#release() is recursive, a call to GLContext#release() may not natively release the context.

This methods continues calling GLContext#release() until the context has been natively released.

See Also

setExclusiveContextThread(Thread, GLContext)

The default init action to be called once after ctx is being created @ 1st makeCurrent().

Parameters

sendReshape:boolean

set to true if the subsequent display call won't reshape, otherwise false to avoid double reshape.

If wait is true the call blocks until the glRunnable has been executed.

If wait is true and GLDrawable#isRealized() returns false or GLAutoDrawable#getContext() returns null, the call is ignored and returns false.
This helps avoiding deadlocking the caller.

0 == deferredHere && 0 == isGLThread -> display() will issue on GL thread, blocking!

        deferredHere wait isGLThread   lockedByThisThread  Note
 OK     0            x    1            x
 OK     0            x    0            0
 ERROR  0            x    0            1                   Will be deferred on GL thread by display() (blocking),
                                                           but locked by this thread -> ERROR

        1            0    x            x                   All good, due to no wait, non blocking

        1            1    1            0
        1            1    0            0
 SWITCH 1            1    1            1                   Run immediately, don't defer since locked by this thread, but isGLThread
 ERROR  1            1    0            1                   Locked by this thread, but _not_ isGLThread -> ERROR

Parameters

drawable:GLAutoDrawable

the GLAutoDrawable to be used

wait:boolean

if true block until execution of glRunnable is finished, otherwise return immediatly w/o waiting

glRunnable:GLRunnable

the GLRunnable to execute within display()

Returns:boolean

true if the GLRunnable has been processed or queued, otherwise false.

Exceptions

IllegalStateException:

in case the drawable is locked by this thread, no animator is running on another thread and wait is true.

See Also

invoke(GLAutoDrawable, boolean, GLRunnable)

Principal helper method which runs a Runnable with the context made current. This could have been made part of GLContext, but a desired goal is to be able to implement GLAutoDrawable's in terms of the GLContext's public APIs, and putting it into a separate class helps ensure that we don't inadvertently use private methods of the GLContext or its implementing classes.

Parameters

shared:GLContext[]

returns the shared GLContext, based on set shared GLAutoDrawable or GLContext. Maybe null if none is set.

Returns:boolean

true if initialization is pending due to a set shared GLAutoDrawable or GLContext which is not ready yet. Otherwise false.

If the drawable is not realized, OP is a NOP.

• release context if current
• destroy old drawable
• create new drawable
• attach new drawable to context
• make context current, if it was current

Locking is performed via GLContext#makeCurrent() on the passed context.

Parameters

context:GLContext

maybe null

Returns:GLDrawableImpl

the new drawable

Note that no GLEventListener#dispose(GLAutoDrawable) call is being issued due to the lack of a current context. Consider calling disposeGLEventListener(GLAutoDrawable, GLDrawable, GLContext, GLEventListener).

Returns:GLEventListener

the removed listener, or null if listener was not added

Performs resize operation on the given drawable, assuming it is offscreen.

The GLDrawableImpl's NativeSurface is being locked during operation. In case the holder is an auto drawable or similar, it's lock shall be claimed by the caller.

May recreate the drawable via recreateGLDrawable(GLDrawableImpl, GLContext) in case of a a pbuffer- or pixmap-drawable.

FBO drawables are resized w/o drawable destruction.

Offscreen resize operation is validated w/ drawable size in the end. An exception is thrown if not successful.

Parameters

newWidth:int

the new width, it's minimum is capped to 1

newHeight:int

the new height, it's minimum is capped to 1

Returns:GLDrawableImpl

the new drawable in case of an pbuffer/pixmap drawable, otherwise the passed drawable is being returned.

Exceptions

NativeWindowException:

is drawable is not offscreen or it's surface lock couldn't be claimed

GLException:

may be thrown a resize operation

private static GLEventListenerAction displayAction = new GLEventListenerAction() { public void run(final GLAutoDrawable drawable, final GLEventListener listener) { listener.display(drawable); } };

Runs given runnable outside of a probable claimed exclusive thread, i.e. releases the exclusive thread, executes the runnable and reclaims it.

Since

2.3.2

See Also

setExclusiveContextThread(Thread, GLContext)

Dedicates this instance's GLContext to the given thread.
The thread will exclusively claim the GLContext via display() and not release it until destroy() or setExclusiveContextThread(null) has been called.

Default non-exclusive behavior is requested via setExclusiveContextThread(null), which will cause the next call of display() on the exclusive thread to release the GLContext. Only after it's async release, getExclusiveContextThread() will return null.

To release a previous made exclusive thread, a user issues setExclusiveContextThread(null) and may poll getExclusiveContextThread() until it returns null, while the exclusive thread is still running.

One scenario could be to dedicate the context to the animator thread and spare redundant context switches.

Parameters

t:Thread

the exclusive thread to claim the context, or null for default operation.

Returns:Thread

previous exclusive context thread

Exceptions

GLException:

If an exclusive thread is still active but a new one is attempted to be set

Switch GLContext / GLDrawable association.

Remarks:

• The oldCtx will be destroyed if destroyPrevCtx is true, otherwise disassociate oldCtx from drawable via oldCtx.setGLDrawable(null, true); including glFinish().
• Reassociate newCtx with drawable via newCtx.setGLDrawable(drawable, true);.
• If the old context was current on this thread, it is being released after disassociating the drawable.
• If the new context was current on this thread, it is being released before associating the drawable and made current afterwards.
• Implementation may issue makeCurrent() and release() while drawable reassociation.
• The user shall take extra care of thread synchronization, i.e. lock the involved drawable's NativeSurfaces to avoid a race condition. In case auto-drawable's are used, their upstream-lock must be locked beforehand see GLAutoDrawable Locking.

Parameters

drawable:GLDrawable

the drawable which context is changed

oldCtx:GLContext

the old context, maybe null.

destroyOldCtx:boolean

if true, destroy the oldCtx

newCtx:GLContext

the new context, maybe null for dis-association.

newCtxCreationFlags:int

additional creation flags if newCtx is not null and not been created yet, see GLContext#setContextCreationFlags(int)

See Also

GLAutoDrawable#setContext(GLContext, boolean)

Overrides java.lang.Object.toString.

Doc from java.lang.Object.toString.

Returns a string representation of the object.

Returns:String

a string representation of the object

Annotations

@Override