javax.media.opengl

## Class GLContext

- java.lang.Object
- - javax.media.opengl.GLContext

    public abstract class GLContext
    extends Object

Abstraction for an OpenGL rendering context. In order to perform OpenGL rendering, a context must be "made current" on the current thread. OpenGL rendering semantics specify that only one context may be current on the current thread at any given time, and also that a given context may be current on only one thread at any given time. Because components can be added to and removed from the component hierarchy at any time, it is possible that the underlying OpenGL context may need to be destroyed and recreated multiple times over the lifetime of a given component. This process is handled by the implementation, and the GLContext abstraction provides a stable object which clients can use to refer to a given context.

### Field Summary

Fields
`static int` `CONTEXT_CURRENT` Indicates that the context was made current during the last call to `makeCurrent`.
`static int` `CONTEXT_CURRENT_NEW` Indicates that a newly-created context was made current during the last call to `makeCurrent`.
`static int` `CONTEXT_NOT_CURRENT` Indicates that the context was not made current during the last call to `makeCurrent`.

### Constructor Summary

Constructors
Constructor and Description
`GLContext()`

### Method Summary

Methods
`abstract void` `copy(GLContext source, int mask)` Copies selected groups of OpenGL state variables from the supplied source context into this one.
`abstract void` `destroy()` Destroys this OpenGL context and frees its associated resources.
`static GLContext` `getCurrent()` Returns the context which is current on the current thread.
`abstract GL` `getGL()` Returns the GL pipeline object for this GLContext.
`abstract GLDrawable` `getGLDrawable()` Returns the GLDrawable to which this context may be used to draw.
`abstract boolean` `isSynchronized()` Returns true if 'makeCurrent' will exhibit synchronized behavior.
`abstract int` `makeCurrent()` Makes this GLContext current on the calling thread.
`abstract void` `release()` Releases control of this GLContext from the current thread.
`protected static void` `setCurrent(GLContext cur)` Sets the thread-local variable returned by `getCurrent()` and has no other side-effects.
`abstract void` `setGL(GL gl)` Sets the GL pipeline object for this GLContext.
`abstract void` `setSynchronized(boolean isSynchronized)` Determines whether 'makeCurrent' will exhibit synchronized behavior.

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Field Detail

#### CONTEXT_NOT_CURRENT

    public static final int CONTEXT_NOT_CURRENT

Indicates that the context was not made current during the last call to `makeCurrent`.

See Also:
  Constant Field Values

#### CONTEXT_CURRENT

    public static final int CONTEXT_CURRENT

Indicates that the context was made current during the last call to `makeCurrent`.

See Also:
  Constant Field Values

#### CONTEXT_CURRENT_NEW

    public static final int CONTEXT_CURRENT_NEW

Indicates that a newly-created context was made current during the last call to `makeCurrent`.

See Also:
  Constant Field Values

### Constructor Detail

#### GLContext

    public GLContext()

### Method Detail

#### getGLDrawable

    public abstract GLDrawable getGLDrawable()

Returns the GLDrawable to which this context may be used to draw.

#### makeCurrent

    public abstract int makeCurrent()
                             throws GLException

Makes this GLContext current on the calling thread. There are two return values that indicate success and one that indicates failure. A return value of CONTEXT_CURRENT_NEW indicates that that context has been made current, and that this is the first time this context has been made current, or that the state of the underlying context or drawable may have changed since the last time this context was made current. In this case, the application may wish to initialize the state. A return value of CONTEXT_CURRENT indicates that the context has been made currrent, with its previous state restored. If the context could not be made current (for example, because the underlying drawable has not ben realized on the display) , a value of CONTEXT_NOT_CURRENT is returned. If the context is in use by another thread at the time of the call, then if isSynchronized() is true the call will block. If isSynchronized() is false, an exception will be thrown and the context will remain current on the other thread.

Returns:
  CONTEXT_CURRENT if the context was successfully made current
Throws:
  `GLException` - if synchronization is disabled and the context is current on another thread, or because the context could not be created or made current due to non-recoverable, window system-specific errors.

#### release

    public abstract void release()
                          throws GLException

Releases control of this GLContext from the current thread.

Throws:
  `GLException` - if the context had not previously been made current on the current thread

#### copy

    public abstract void copy(GLContext source,
            int mask)
                       throws GLException

Copies selected groups of OpenGL state variables from the supplied source context into this one. The `mask` parameter indicates which groups of state variables are to be copied. `mask` contains the bitwise OR of the same symbolic names that are passed to the GL command `glPushAttrib`. The single symbolic constant `GL_ALL_ATTRIB_BITS` can be used to copy the maximum possible portion of rendering state.

Not all values for GL state can be copied. For example, pixel pack and unpack state, render mode state, and select and feedback state are not copied. The state that can be copied is exactly the state that is manipulated by the GL command `glPushAttrib`.

On most platforms, this context may not be current to any thread, including the calling thread, when this method is called. Some platforms have additional requirements such as whether this context or the source context must occasionally be made current in order for the results of the copy to be seen; these requirements are beyond the scope of this specification.

Parameters:
  `source` - the source OpenGL context from which to copy state
  `mask` - a mask of symbolic names indicating which groups of state to copy
Throws:
  `GLException` - if an OpenGL-related error occurred

#### getCurrent

    public static GLContext getCurrent()

Returns the context which is current on the current thread. If no context is current, returns null.

Returns:
  the context current on this thread, or null if no context is current.

#### setCurrent

    protected static void setCurrent(GLContext cur)

Sets the thread-local variable returned by `getCurrent()` and has no other side-effects. For use by third parties adding new GLContext implementations; not for use by end users.

#### destroy

    public abstract void destroy()

Destroys this OpenGL context and frees its associated resources. The context should have been released before this method is called.

#### isSynchronized

    public abstract boolean isSynchronized()

Returns true if 'makeCurrent' will exhibit synchronized behavior.

#### setSynchronized

    public abstract void setSynchronized(boolean isSynchronized)

Determines whether 'makeCurrent' will exhibit synchronized behavior.

#### getGL

    public abstract GL getGL()

Returns the GL pipeline object for this GLContext.

#### setGL

    public abstract void setGL(GL gl)

Sets the GL pipeline object for this GLContext.