/*
 * Copyright  1990-2006 Sun Microsystems, Inc. All Rights Reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version
 * 2 only, as published by the Free Software Foundation. 
 * 
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License version 2 for more details (a copy is
 * included at /legal/license.txt). 
 * 
 * You should have received a copy of the GNU General Public License
 * version 2 along with this work; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA 
 * 
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
 * Clara, CA 95054 or visit www.sun.com if you need additional
 * information or have any questions. 
 */

package javax.microedition.khronos.egl;

/**
 * The EGL10 interface contains the Java(TM) programming language
 * bindings for EGL 1.0.
 *
 * <p> The documentation in this interface is normative with respect
 * to instance variable names and values, method names and signatures,
 * and exception behavior.  The remaining documentation is placed here
 * for convenience and does not replace the normative documentation
 * found in the EGL specification and relevant
 * extension specifications.  EGL documentation is available at the <a
 * href="http://www.khronos.org/opengles/spec">Khronos</a> web site.
 *
 * <p>Extensions may return values or allow arguments to take on
 * values other than those listed in this specification.
 * Implementations that provide a given extension must pass such values
 * to and from the underlying engine.
 *
 * <p>If a method throws an exception, the state of the underlying EGL
 * engine is left intact.
 *
 * <p> All OpenGL ES drawing (except to Pbuffer surfaces) must be
 * preceded by a call to
 * <code>eglWaitNative(EGL10.EGL_CORE_NATIVE_ENGINE, target)</code>
 * where <code>target</code> is a platform-specific object describing
 * the rendering target,
 * and followed by a call to <code>eglWaitGL()</code>. Between these
 * calls, the results of calls or calls to any other drawing API, such
 * as MIDP, JSR 184, <code>java.awt</code>, etc., are undefined.  When
 * drawing to an image, the results are not guaranteed to appear in
 * the image pixels until <code>eglWaitGL</code> has returned.
 *
 * <p> It is not required that calls to methods of this interface be
 * mapped one-to-one onto calls to functions in the underlying EGL
 * implementation.  Implementations may contain logic to manage
 * configurations, drawing surface access, threading issues, etc., as
 * required in order to integrate EGL-based APIs with other platform
 * drawing APIs. For example, an implementation that makes use of a
 * software back buffer may translate a call to
 * <code>EGL10.eglCreateWindowSurface</code> into a call to the native
 * function <code>eglCreatePixmapSurface</code> targetting the
 * buffer. Naturally, hardware-accelerated implementations should
 * endeavor to avoid such workarounds.
 *
 * <h4>Drawing to a Pbuffer</h4>
 *
 * <p> A Pbuffer is an invisible, possibly hardware-accelerated
 * buffer. Pbuffer surfaces are created using the
 * <code>EGL10.eglCreatePbufferSurface</code> method.  Pbuffers are
 * accessible only from EGL-based APIs, and follow the rules set out
 * in the EGL specification.  Pbuffers may be used in the same manner
 * on any Java platform.
 *
 * <p>The integration between EGL and specific Java ME platforms is as
 * follows.
 *
 * <h3>CLDC/MIDP</h3>
 *
 * <p>On the CLDC/MIDP platform, drawing can be performed to four
 * types of targets: <code>javax.microedition.lcdui.Canvas</code>,
 * <code>javax.microedition.lcdui.game.GameCanvas</code>, (mutable)
 * <code>javax.microedition.lcdui.Image</code>,
 * <!-- <code>javax.microedition.khronos.egl.EGLCanvas</code>,--> or to a
 * Pbuffer.
 *
 * <p>The <code>EGL_DEFAULT_DISPLAY</code> token is used to
 * specify a display.
 *
 * <h4>Drawing to a <code>Canvas</code> or <code>GameCanvas</code></h4>
 *
 * <p> A <code>Canvas</code> or <code>GameCanvas</code> is specified
 * as a drawing target using the <code>eglCreateWindowSurface</code>
 * method.  The <code>native_window</code> argument must be an
 * instance of <code>javax.microedition.lcdui.Graphics</code> that was
 * obtained directly from the argument to the
 * <code>Canvas.paint()</code> method or from the
 * <code>GameCanvas.getGraphics()</code> method.  A
 * <code>Graphics</code> instance obtained from the argument to
 * <code>Canvas.paint</code> may be reused in subsequent
 * <code>paint</code> calls targeting the same <code>Canvas</code>.
 *
 * <p> Drawing to a <code>Canvas</code> or <code>GameCanvas</code>
 * allows for mixing of different drawing APIs.
 *
 * <p> When drawing to a <code>Canvas</code> (that is not a
 * <code>GameCanvas</code>), drawing must take place entirely within
 * the scope of a system-generated call to the <code>Canvas</code>'s
 * <code>paint(Graphics)</code> method.  The results of drawing to a
 * <code>Canvas</code> outside the scope of such a call are undefined.
 *
 * <p> Calling <code>eglSwapBuffers</code> is equivalent to calling
 * <code>glFinish</code>, and does not affect the screen output.  The
 * normal <code>GameCanvas.flushGraphics</code> method is used to
 * control screen output.
 *
 * <p> The initial contents of the back buffer for a
 * <code>GameCanvas</code> are initialized to white, and calls to
 * <code>flushGraphics</code> do not alter the buffer contents.
 *
 * <pre>
 * import javax.microedition.lcdui.Display;
 * import javax.microedition.lcdui.Graphics;
 * import javax.microedition.lcdui.game.GameCanvas;
 * import javax.microedition.midlet.MIDlet;
 * import javax.microedition.khronos.egl.*;
 * import javax.microedition.khronos.opengles.*;
 * 
 * class MyGameCanvas extends GameCanvas {
 *   EGL11 egl;
 *   GL11 gl;
 *   Graphics midpGraphics;
 *   javax.microedition.m3g.Graphics3D m3gContext;
 * 
 *   MyGameCanvas(MIDlet thisMIDlet) {
 *     // This example doesn't require key events
 *     super(true);
 *
 *     // Get a Graphics instance for MIDP rendering
 *     // and to use in createWindowSurface
 *     this.midpGraphics = getGraphics();
 *
 *     // Show this GameCanvas on the display
 *     Display display = Display.getDisplay(thisMIDlet);
 *     display.setCurrent(this);
 *
 *     // Create an EGL instance
 *     this.egl = (EGL11)EGLContext.getEGL();
 *
 *     // Get the EGL display object and initialize EGL
 *     EGLDisplay eglDisplay = egl.eglGetDisplay(EGL11.EGL_DEFAULT_DISPLAY);
 *     int[] major_minor = new int[2];
 *     egl.eglInitialize(eglDisplay, major_minor);
 *     System.out.println("EGL revision: major = " + major_minor[0]);
 *     System.out.println("EGL revision: minor = " + major_minor[1]);
 *
 *     // Determine the number of available configurations
 *     int[] num_config = new int[1];
 *     egl.eglGetConfigs(eglDisplay, null, 0, num_config);
 *     System.out.println("There are " + num_config[0] + " configurations");
 *
 *     // Locate an 8/8/8 RGB configuration
 *     int[] configAttrs = { EGL11.EGL_RED_SIZE, 8,
 *                           EGL11.EGL_GREEN_SIZE, 8,
 *                           EGL11.EGL_BLUE_SIZE, 8,
 *                           EGL11.EGL_ALPHA_SIZE, EGL11.EGL_DONT_CARE,
 *                           EGL11.EGL_DEPTH_SIZE, EGL11.EGL_DONT_CARE,
 *                           EGL11.EGL_STENCIL_SIZE, EGL11.EGL_DONT_CARE,
 *                           EGL11.EGL_NONE
 *     };
 *
 *     // Grab the first matching config
 *     EGLConfig[] eglConfigs = new EGLConfig[1];
 *     egl.eglChooseConfig(eglDisplay, configAttrs,
 *                         eglConfigs, 1, num_config);
 *     EGLConfig eglConfig = eglConfigs[0];
 * 
 *     // Get a context for EGL rendering
 *     EGLContext eglContext =
 *       egl.eglCreateContext(eglDisplay, eglConfig,
 *                            EGL11.EGL_NO_CONTEXT, null);
 *
 *     // Get a GL object for rendering
 *     this.gl = (GL11)eglContext.getGL();
 *
 *     // Bind a window surface to the context
 *     EGLSurface eglSurface =
 *       egl.eglCreateWindowSurface(eglDisplay, eglConfig, midpGraphics, null);

 *     // Make the context current for future GL calls
 *     egl.eglMakeCurrent(eglDisplay, eglSurface, eglSurface, eglContext);
 *
 *     // Get a context for M3G rendering
 *     this.m3g = ...;
 *   }
 * 
 *   // The update loop
 *   public void run() {
 *     while (true) {
 *       // Do some MIDP 2D rendering
 *       // Use of OpenGL ES or M3G is not allowed here
 *       // MIDP primitives drawn here will appear underneath the
 *       // OpenGL ES drawing
 *       midpGraphics.drawLine(...);
 *
 *       // Wait for MIDP drawing to complete
 *       egl.eglWaitNative(EGL11.EGL_CORE_NATIVE_ENGINE, midpGraphics);
 *       // Now it is O.K. to use OpenGL ES drawing APIs
 *
 *       // Do some OpenGL ES rendering
 *       // Use of MIDP, JSR 184, or other drawing APIs is undefined here
 *       gl.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
 *       gl.glClear(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT);
 *       gl.glFrustumf(...);
 *       // etc.
 *
 *       // Wait for OpenGL ES rendering to complete
 *       egl.eglWaitGL();
 *       // Now it is O.K. to use MIDP drawing APIs
 * 
 *       // MIDP primitives drawn here will appear on top of the
 *       // OpenGL ES drawing
 *       midpGraphics.drawRect(...);
 *
 *       // Do some M3G (JSR 184) rendering
 *       m3g.bindTarget(midpGraphics, ...);
 *       // Now it is O.K. to use M3G, but not MIDP or OpenGL ES
 *
 *       // M3G commands go here
 *
 *       // Wait for M3G drawing to complete
 *       m3g.releaseTarget();
 *       // Now it is O.K. to use MIDP drawing APIs
 * 
 *       // Do some more MIDP 2D rendering
 *       // MIDP primitives drawn here will appear on top of the
 *       // OpenGL ES and M3G drawings
 *       midp_graphics.drawArc(...);
 * 
 *       // Flush the back buffer to the screen
 *       flushGraphics();
 *     }
 *   }
 * }
 * </pre>
 *
 * <h4>Drawing to an <code>Image</code></h4>
 *
 * <p> The <code>eglCreatePixmapSurface</code> method allows drawing
 * to an <code>Image</code>.  The <code>Image</code> must be mutable.
 * The <code>native_pixmap</code> argument must be an instance of
 * <code>javax.microedition.lcdui.Graphics</code> that was obtained
 * from the <code>Image</code>'s <code>getGraphics()</code> method.
 *
 * <p> OpenGL ES drawing must be bracketed between calls to
 * <code>eglWaitNative</code> and <code>eglWaitGL</code> in the same
 * manner as for <code>Canvas</code> and <code>GameCanvas</code>.
 * Calling <code>eglSwapBuffers</code> is equivalent to calling
 * <code>glFinish</code>, since there is no back buffer.
 *
 * <!--
 * <h4>Drawing to an <code>EGLCanvas</code></h4>
 *
 * <p> <code>EGLCanvas</code> maximizes the potential for efficiency
 * by removing the requirement to allow non-OpenGL ES drawing.  The
 * results of drawing to an <code>EGLCanvas</code> using other non-EGL
 * based APIs such as MIDP and JSR 184 is undefined.
 *
 * <p> An <code>EGLCanvas</code> is specified as a drawing target
 * using the <code>eglCreateWindowSurface</code> method.  The
 * <code>native_window</code> argument must be an instance of
 * <code>javax.microedition.lcdui.Graphics</code> that was obtained
 * directly from the <code>EGLCanvas.getGraphics()</code> method.
 *
 * <p> When an <code>EGLCanvas</code> is set using the
 * <code>Display.setCurrent</code> method, it occupies as much of the
 * screen as is allowed by the platform (leaving room for a status bar
 * if the platform requires one).  OpenGL ES drawing is performed to a
 * back buffer, the contents of which are initially undefined. When
 * drawing is complete, a call to <code>eglSwapBuffers</code> causes
 * the contents of the back buffer to be copied to the
 * screen. Following the call, the back buffer contents are once again
 * undefined.
 * -->
 *
 * <h3>Other platforms</h3>
 *
 * <p> The current specification does not address AWT-based platforms
 * such as CDC/Personal Basis Profile, CDC/Personal Profile,
 * and Java Standard Edition.  The details of how to bind to displays
 * and surfaces on these platforms will be provided in a future release
 * of the specification.
 */
public interface EGL10 extends EGL {

  /**
   * An object that is used as an argument to
   * <code>eglGetDisplay</code> to indicate that the defalt display of
   * the device is to be used.
   */
  public static final Object EGL_DEFAULT_DISPLAY =
      new Object();

  /**
   * An <code>EGLContext</code> object used to indicate a null context.
   */
  public static final EGLContext EGL_NO_CONTEXT =
      EGLContextImpl.getInstance(0);

  /**
   * An <code>EGLContext</code> object used to indicate a null display.
   */
  public static final EGLDisplay EGL_NO_DISPLAY =
      EGLDisplayImpl.getInstance(0);

  /**
   * An <code>EGLContext</code> object used to indicate a null surface.
   */
  public static final EGLSurface EGL_NO_SURFACE =
      EGLSurfaceImpl.getInstance(0); // C #define of EGL_NO_SURFACE
  
  // Boolean

  /**
   * A value corresponding to the 'EGLBoolean' false value.
   */
  public static final int EGL_FALSE                   = 0;

  /**
   * A value corresponding to the 'EGLBoolean' true value.
   */
  public static final int EGL_TRUE                    = 1;
  
  // Errors

  /**
   * EGL error code indicating success.
   */
  public static final int EGL_SUCCESS                 = 0x3000;

  /**
   * EGL error code indicating 'not initialized'.
   */
  public static final int EGL_NOT_INITIALIZED         = 0x3001;

  /**
   * EGL error code indicating 'bad access'.
   */
  public static final int EGL_BAD_ACCESS              = 0x3002;

  /**
   * EGL error code indicating 'bad alloc'.
   */
  public static final int EGL_BAD_ALLOC               = 0x3003;

  /**
   * EGL error code indicating 'bad attribute'.
   */
  public static final int EGL_BAD_ATTRIBUTE           = 0x3004;

  /**
   * EGL error code indicating 'bad config'.
   */
  public static final int EGL_BAD_CONFIG              = 0x3005;

  /**
   * EGL error code indicating 'bad context'.
   */
  public static final int EGL_BAD_CONTEXT             = 0x3006;

  /**
   * EGL error code indicating 'bad current surface'.
   */
  public static final int EGL_BAD_CURRENT_SURFACE     = 0x3007;

  /**
   * EGL error code indicating 'bad display'.
   */
  public static final int EGL_BAD_DISPLAY             = 0x3008;

  /**
   * EGL error code indicating 'bad match'.
   */
  public static final int EGL_BAD_MATCH               = 0x3009;

  /**
   * EGL error code indicating 'bad native pixmap'.
   */
  public static final int EGL_BAD_NATIVE_PIXMAP       = 0x300A;

  /**
   * EGL error code indicating 'bad native window'.
   */
  public static final int EGL_BAD_NATIVE_WINDOW       = 0x300B;

  /**
   * EGL error code indicating 'bad parameter'.
   */
  public static final int EGL_BAD_PARAMETER           = 0x300C;

  /**
   * EGL error code indicating 'bad surface'.
   */
  public static final int EGL_BAD_SURFACE             = 0x300D;
  
  // Config attributes

  /**
   * <code>EGLConfig</code> attribute name.
   */
  public static final int EGL_BUFFER_SIZE             = 0x3020;

  /**
   * <code>EGLConfig</code> attribute name.
   */
  public static final int EGL_ALPHA_SIZE              = 0x3021;

  /**
   * <code>EGLConfig</code> attribute name.
   */
  public static final int EGL_BLUE_SIZE               = 0x3022;

  /**
   * <code>EGLConfig</code> attribute name.
   */
  public static final int EGL_GREEN_SIZE              = 0x3023;

  /**
   * <code>EGLConfig</code> attribute name.
   */
  public static final int EGL_RED_SIZE                = 0x3024;

  /**
   * <code>EGLConfig</code> attribute name.
   */
  public static final int EGL_DEPTH_SIZE              = 0x3025;

  /**
   * <code>EGLConfig</code> attribute name.
   */
  public static final int EGL_STENCIL_SIZE            = 0x3026;

  /**
   * <code>EGLConfig</code> attribute name.
   */
  public static final int EGL_CONFIG_CAVEAT           = 0x3027;

  /**
   * <code>EGLConfig</code> attribute name.
   */
  public static final int EGL_CONFIG_ID               = 0x3028;

  /**
   * <code>EGLConfig</code> attribute name.
   */
  public static final int EGL_LEVEL                   = 0x3029;

  /**
   * <code>EGLConfig</code> attribute name.
   */
  public static final int EGL_MAX_PBUFFER_HEIGHT      = 0x302A;

  /**
   * <code>EGLConfig</code> attribute name.
   */
  public static final int EGL_MAX_PBUFFER_PIXELS      = 0x302B;

  /**
   * <code>EGLConfig</code> attribute name.
   */
  public static final int EGL_MAX_PBUFFER_WIDTH       = 0x302C;

  /**
   * <code>EGLConfig</code> attribute name.
   */
  public static final int EGL_NATIVE_RENDERABLE       = 0x302D;

  /**
   * <code>EGLConfig</code> attribute name.
   */
  public static final int EGL_NATIVE_VISUAL_ID        = 0x302E;

  /**
   * <code>EGLConfig</code> attribute name.
   */
  public static final int EGL_NATIVE_VISUAL_TYPE      = 0x302F;

  /**
   * <code>EGLConfig</code> attribute name.
   */
  public static final int EGL_PRESERVED_RESOURCES  = 0x3030;

  /**
   * <code>EGLConfig</code> attribute name.
   */
  public static final int EGL_SAMPLES                 = 0x3031;

  /**
   * <code>EGLConfig</code> attribute name.
   */
  public static final int EGL_SAMPLE_BUFFERS          = 0x3032;

  /**
   * <code>EGLConfig</code> attribute name.
   */
  public static final int EGL_SURFACE_TYPE            = 0x3033;

  /**
   * <code>EGLConfig</code> attribute name.
   */
  public static final int EGL_TRANSPARENT_TYPE        = 0x3034;

  /**
   * <code>EGLConfig</code> attribute name.
   */
  public static final int EGL_TRANSPARENT_BLUE_VALUE  = 0x3035;

  /**
   * <code>EGLConfig</code> attribute name.
   */
  public static final int EGL_TRANSPARENT_GREEN_VALUE = 0x3036;

  /**
   * <code>EGLConfig</code> attribute name.
   */
  public static final int EGL_TRANSPARENT_RED_VALUE   = 0x3037;

  // Config atribute and value

  /**
   * <code>EGLConfig</code> attribute name and value.
   */
  public static final int EGL_NONE                    = 0x3038;

  // Config values

  /**
   * <code>EGLConfig</code> attribute value.
   */
  public static final int EGL_DONT_CARE               = -1;

  /**
   * <code>EGLConfig</code> attribute value.
   */
  public static final int EGL_PBUFFER_BIT             = 0x01;

  /**
   * <code>EGLConfig</code> attribute value.
   */
  public static final int EGL_PIXMAP_BIT              = 0x02;

  /**
   * <code>EGLConfig</code> attribute value.
   */
  public static final int EGL_WINDOW_BIT              = 0x04;

  /**
   * <code>EGLConfig</code> attribute value.
   */
  public static final int EGL_SLOW_CONFIG             = 0x3050;

  /**
   * <code>EGLConfig</code> attribute value.
   */
  public static final int EGL_NON_CONFORMANT_CONFIG   = 0x3051;

  /**
   * <code>EGLConfig</code> attribute value.
   */
  public static final int EGL_TRANSPARENT_RGB         = 0x3052;

  // String names

  /**
   * Constant for use in <code>eglQueryString</code>.
   */
  public static final int EGL_VENDOR                  = 0x3053;

  /**
   * Constant for use in <code>eglQueryString</code>.
   */
  public static final int EGL_VERSION                 = 0x3054;

  /**
   * Constant for use in <code>eglQueryString</code>.
   */
  public static final int EGL_EXTENSIONS              = 0x3055;
    
  // Surface attributes

  /**
   * <code>EGLSurface</code> attribute name.
   */
  public static final int EGL_HEIGHT                  = 0x3056;

  /**
   * <code>EGLSurface</code> attribute name.
   */
  public static final int EGL_WIDTH                   = 0x3057;

  /**
   * <code>EGLSurface</code> attribute name.
   */
  public static final int EGL_LARGEST_PBUFFER         = 0x3058;

  // Current surfaces

  /**
   * Constant for use in the <code>readdraw</code> argument of
   * <code>getCurrentSurface</code>.
   */
  public static final int EGL_DRAW                    = 0x3059;

  /**
   * Constant for use as the <code>readdraw</code> argument of
   * <code>getCurrentSurface</code>.
   */
  public static final int EGL_READ                    = 0x305A;

  // Engines

  /**
   * Constant for use as the <code>engine</code> argument of
   * <code>eglWaitNative</code>, indicating the core native engine of
   * the platform.
   *
   * <p>On a JME CLDC/MIDP platform, this specifies the MIDP/LCDUI
   * drawing engine.
   *
   * <!-- <p>On other JME or JSE platforms, this specifies the AWT/Java2D
   * drawing engine. -->
   */
  public static final int EGL_CORE_NATIVE_ENGINE      = 0x305B;

  // Functions
  
  /**
   * Return error information.
   *
   * <p><code>eglGetError</code> returns the error of the last called EGL
   * function in the current thread. Initially, the error is set to
   * <code>EGL_SUCCESS</code>.
   *
   * <p>The following errors are currently defined:
   *
   * <ul>
   *
   * <li><code>EGL_SUCCESS</code></li>
   *
   * <p>The last function succeeded without error.
   *
   * <li><code>EGL_NOT_INITIALIZED</code></li>
   *
   * <p>EGL is not initialized, or could not be initialized, for the
   * specified EGL display connection.
   *
   * <li><code>EGL_BAD_ACCESS</code></li>
   *
   * <p>EGL cannot access a requested resource (for example a context
   * is bound in another thread).
   *
   * <li><code>EGL_BAD_ALLOC</code></li>
   *
   * <p>EGL failed to allocate resources for the requested operation.
   *
   * <li><code>EGL_BAD_ATTRIBUTE</code></li>
   *
   * <p>An unrecognized attribute or attribute value was passed in
   * the attribute list.
   *
   * <li><code>EGL_BAD_CONTEXT</code></li>
   *
   * <p>An <code>EGLContext</code> argument does not name a valid EGL
   * rendering context.
   *
   * <li><code>EGL_BAD_CONFIG</code></li>
   *
   * <p>An <code>EGLConfig</code> argument does not name a valid EGL
   * frame buffer configuration.
   *
   * <li><code>EGL_BAD_CURRENT_SURFACE</code></li>
   *
   * <p>The current surface of the calling thread is a window, pixel
   * buffer or pixmap that is no longer valid.
   *
   * <li><code>EGL_BAD_DISPLAY</code></li>
   *
   * <p>An <code>EGLDisplay</code> argument does not name a valid EGL
   * display connection.
   *
   * <li><code>EGL_BAD_SURFACE</code></li>
   *
   * <p>An <code>EGLSurface</code> argument does not name a valid
   * surface (window, pixel buffer or pixmap) configured for GL
   * rendering.
   *
   * <li><code>EGL_BAD_MATCH</code></li>
   *
   * <p>Arguments are inconsistent (for example, a valid context
   * requires buffers not supplied by a valid surface).
   *
   * <li><code>EGL_BAD_PARAMETER</code></li>
   *
   * <p>One or more argument values are invalid.
   *
   * <li><code>EGL_BAD_NATIVE_PIXMAP</code></li>
   *
   * <p>A <code>native_pixmap</code> argument does not refer to a
   * valid native pixmap.
   *
   * <li><code>EGL_BAD_NATIVE_WINDOW</code></li>
   *
   * <p>A <code>native_window</code> argument does not refer to a
   * valid native window.
   *
   * <li><code>EGL_CONTEXT_LOST</code> (1.1 only)</li>
   *
   * <p>A power management event has occurred. The application must
   * destroy all contexts and reinitialise OpenGL ES state and objects
   * to continue rendering.
   *
   * </ul>
   *
   * <h4>Errors</h4>
   *
   * <p>A call to <code>eglGetError</code> sets the error to
   * <code>EGL_SUCCESS</code>.
   *
   * @return One of <code>EGL_SUCCESS</code>,
   * <code>EGL_NOT_INITIALIZED</code>, <code>EGL_BAD_ACCESS</code>,
   * <code>EGL_BAD_ALLOC</code>, <code>EGL_BAD_ATTRIBUTE</code>,
   * <code>EGL_BAD_CONTEXT</code>, <code>EGL_BAD_CONFIG</code>,
   * <code>EGL_BAD_CURRENT_SURFACE</code>,
   * <code>EGL_BAD_DISPLAY</code>, <code>EGL_BAD_MATCH</code>,
   * <code>EGL_BAD_NATIVE_PIXMAP</code>,
   * <code>EGL_BAD_NATIVE_WINDOW</code>,
   * <code>EGL_BAD_PARAMETER</code>, <code>EGL_BAD_SURFACE</code>, or
   * other error code defined by an extension.
   */
  int eglGetError();

  /**
   * Return an EGL display connection.
   *
   * <p><code>eglGetDisplay</code> obtains the EGL display connection
   * for the native display <code>native_display</code>.
   *
   * <p>If <code>display_id</code> is
   * <code>EGL_DEFAULT_DISPLAY</code>, a default display connection is
   * returned.
   *
   * <p>If no display connection matching <code>native_display</code>
   * is available, <code>EGL_NO_DISPLAY</code> is returned. No error
   * is generated.
   *
   * <p>Use <code>eglInitialize</code> to initialize the display
   * connection.
   *
   * @param native_display Specifies the display to connect
   * to. <code>EGL_DEFAULT_DISPLAY</code> indicates the default
   * display.
   *
   * @return An <code>EGLDisplay</code> object.
   *
   * @exception IllegalArgumentException if <code>native_display</code> is
   * <code>null</code> or is not of a suitable type for the platform.
   *
   */
  EGLDisplay eglGetDisplay(Object native_display);

  /**
   * Initialize an EGL display connection.
   *
   * <p><code>eglInitialize</code> initializes the EGL display
   * connection obtained with <code>eglGetDisplay</code>. Initializing
   * an already initialized EGL display connection has no effect
   * besides returning the version numbers and returing
   * <code>true</code>.
   *
   * <p>No value is returned in <code>major_minor</code> if it is specified as
   * <code>null</code>.
   *
   * <p>Use <code>eglTerminate</code> to release resources associated
   * with an EGL display connection.
   *
   * <h4>Errors</h4>
   *
   * <p><code>false</code> is returned if <code>eglInitialize</code>
   * fails, <code>true</code> otherwise. <code>major_minor</code> is
   * not modified when <code>false</code> is returned.
   *
   * <p><code>EGL_BAD_DISPLAY</code> is generated if
   * <code>display</code> is not an EGL display connection.
   *
   * <p><code>EGL_NOT_INITIALIZED</code> is generated if
   * <code>display</code> cannot be initialized.
   *
   * @param display Specifies the EGL display connection to initialize.
   * @param major_minor an <code>int</code> array of length at least
   * 2, in which the major and minor version number of the EGL
   * implementation will be returned as elements 0 and 1. May be
   * <code>null</code>.
   *
   * @return <code>true</code> if the operation succeeds.
   *
   * @exception IllegalArgumentException if <code>display</code> is
   * <code>null</code>.
   * @exception IllegalArgumentException if <code>major_minor</code> is
   * non-<code>null</code> but has length less than 2.
   */
  boolean eglInitialize(EGLDisplay display, int[] major_minor);

  /**
   * Terminate an EGL display connection.
   *
   * <p><code>eglTerminate</code> releases resources associated with
   * an EGL display connection. Termination marks all EGL resources
   * associated with the EGL display connection for deletion. If
   * contexts or surfaces associated with <code>display</code> is
   * current to any thread, they are not released until they are no
   * longer current as a result of <code>eglMakeCurrent</code>.
   *
   * <p>Terminating an already terminated EGL display connection has
   * no effect other than returning <code>true</code>. A terminated
   * display may be re-initialized by calling
   * <code>eglInitialize</code> again.
   *
   * <h4>Errors</h4>
   *
   * <p><code>false</code> is returned if <code>eglTerminate</code>
   * fails, <code>true</code> otherwise.
   *
   * <p><code>EGL_BAD_DISPLAY</code> is generated if display is not an
   * EGL display connection.
   *
   * @param display Specifies the EGL display connection to terminate.
   *
   * @exception IllegalArgumentException if <code>display</code> is
   * <code>null</code>.
   * @return <code>true</code> if the operation succeeds.
   */
  boolean eglTerminate(EGLDisplay display);

  /**
   * Return a string describing an EGL display connection.
   *
   * <p><code>eglQueryString</code> returns a <code>String</code>
   * describing an EGL display connection. <code>name</code> can be
   * one of the following:
   *
   * <ul>
   *
   * <li><code>EGL_VENDOR</code></li>
   *
   * <p>Returns the company responsible for this EGL implementation. This
   * name does not change from release to release.
   *
   * <li><code>EGL_VERSION</code></li>
   *
   * <p>Returns a version or release number. The <code>EGL_VERSION</code>
   * string is laid out as follows:
   *
   * <p><code>major_version.minor_version space vendor_specific_info</code>
   *
   * <li><code>EGL_EXTENSIONS</code></li>
   *
   * <p>Returns a space-separated list of supported extensions to EGL.
   *
   * </ul>
   *
   * <p>The string data returned from the native EGL implementation is
   * converted into UTF8 format and returned as a Java
   * <code>String</code>.
   *
   * <h4>Errors</h4>
   *
   * <p><code>null</code> is returned on failure.
   *
   * <p><code>EGL_BAD_DISPLAY</code> is generated if
   * <code>display</code> is not an EGL display connection.
   *
   * <p><code>EGL_NOT_INITIALIZED</code> is generated if
   * <code>display</code> has not been initialized.
   *
   * <p><code>EGL_BAD_PARAMETER</code> is generated if
   * <code>name</code> is not an accepted value.
   *
   * @param display Specifies the EGL display connection.
   * @param name Specifies a symbolic constant, one of
   * <code>EGL_VENDOR</code>, <code>EGL_VERSION</code>, or
   * <code>EGL_EXTENSIONS</code>.
   *
   * @exception IllegalArgumentException if <code>display</code> is
   * <code>null</code>.
   * @return A <code>String</code> containing the query result.
   */
  String eglQueryString(EGLDisplay display, int name);
 
  /**
   * Return a list of all EGL frame buffer configurations for a display.
   *
   * <p><code>eglGetConfigs</code> returns a list of all EGL frame
   * buffer configurations that are available for the specified
   * display. The items in the list can be used in any EGL function
   * that requires an EGL frame buffer configuration. No more than
   * <code>config_size</code> <code>EGLConfig</code>s will be returned
   * even if more are available on the specified display.
   *
   * <p><code>configs</code> does not return values, if it is specified
   * as <code>null</code>. This is useful for querying just the number
   * of all frame buffer configurations.
   *
   * <p>Use <code>eglGetConfigAttrib</code> to retrieve individual
   * attribute values of a frame buffer configuration.
   *
   * <h4>Errors</h4>
   *
   * <p><code>false</code> is returned on failure, <code>true</code>
   * otherwise. <code>configs</code> and <code>num_config</code> are
   * not modified when <code>false</code> is returned.
   *
   * <p><code>EGL_BAD_DISPLAY</code> is generated if
   * <code>display</code> is not an EGL display connection.
   *
   * <p><code>EGL_NOT_INITIALIZED</code> is generated if
   * <code>display</code> has not been initialized.
   *
   * <p><code>EGL_BAD_PARAMETER</code> is generated if
   * <code>num_config</code> is <code>null</code>.
   *
   * @param display Specifies the EGL display connection.
   * @param configs An array of <code>EGLConfig</code> objects into
   * which a list of configs will be stored, or <code>null</code>.
   * @param config_size Specifies the size of the list of configs.
   * @param num_config An <code>int</code> array, in which the number
   * of configs will be returned in element 0.
   *
   * @return <code>true</code> if the operation succeeds.
   *
   * @exception IllegalArgumentException if <code>display</code> is
   * <code>null</code>.
   * @exception IllegalArgumentException if <code>configs</code> is
   * non-<code>null</code> and <code>configs.length</code> is smaller
   * than <code>config_size</code>.
   * @exception IllegalArgumentException if <code>num_config</code> is
   * non-<code>null</code> but has length less than 1.
   */
  boolean eglGetConfigs(EGLDisplay display,
			EGLConfig[] configs,
    			int config_size,
    			int[] num_config);
    
  /**
   * Return a list of EGL frame buffer configurations that match
   * specified attributes.
   *
   * <p><code>eglChooseConfig</code> returns a list of all EGL frame
   * buffer configurations that match the attributes specified in
   * <code>attrib_list</code>. The items in the list can be used in
   * any EGL function that requires an EGL frame buffer configuration.
   *
   * <p><code>configs</code> does not return values, if it is specified
   * as <code>null</code>. This is useful for querying just the number
   * of matching frame buffer configurations.
   *
   * <p>All attributes in <code>attrib_list</code>, including boolean
   * attributes, are immediately followed by the corresponding desired
   * value. The list is terminated with <code>EGL_NONE</code>. If an
   * attribute is not specified in <code>attrib_list</code> then the
   * default value (see below) is used (and the attribute is said to
   * be specified implicitly). For example, if
   * <code>EGL_DEPTH_SIZE</code> is not specified then it is assumed
   * to be 0. For some attributes, the default is
   * <code>EGL_DONT_CARE</code> meaning that any value is OK for this
   * attribute, so the attribute will not be checked.
   *
   * <p> If <code>attrib_list</code> is <code>null</code> or empty
   * (first attribute is <code>EGL_NONE</code>), then selection and
   * sorting of <code>EGLConfig</code>s is done according to the
   * default criteria described below.
   *
   * <p> Attributes are matched in an attribute-specific manner. Some of
   * the attributes, such as <code>EGL_LEVEL</code>, must match the
   * specified value exactly. Others, such as,
   * <code>EGL_RED_SIZE</code> must meet or exceed the specified
   * minimum values. If more than one EGL frame buffer configuration
   * is found, then a list of configurations, sorted according to the
   * "best" match criteria, is returned. The match criteria for each
   * attribute and the exact sorting order is defined below.
   *
   * <p>The interpretations of the various EGL frame buffer configuration
   * attributes are as follows:
   *
   * <ul>
   *
   * <li><code>EGL_BUFFER_SIZE</code></li>
   *
   * <p>Must be followed by a nonnegative integer that indicates the
   * desired color buffer size. The smallest color buffer of at least
   * the specified size is preferred. The default value is 0.
   *
   * <li><code>EGL_RED_SIZE</code></li>
   *
   * <p>Must be followed by a nonnegative minimum size specification. If
   * this value is zero, the smallest available red buffer is
   * preferred. Otherwise, the largest available red buffer of at
   * least the minimum size is preferred. The default value is 0.
   *
   * <li><code>EGL_GREEN_SIZE</code></li>
   *
   * <p>Must be followed by a nonnegative minimum size specification. If
   * this value is zero, the smallest available green buffer is
   * preferred. Otherwise, the largest available green buffer of at
   * least the minimum size is preferred. The default value is 0.
   *
   * <li><code>EGL_BLUE_SIZE</code></li>
   *
   * <p>Must be followed by a nonnegative minimum size specification. If
   * this value is zero, the smallest available blue buffer is
   * preferred. Otherwise, the largest available blue buffer of at
   * least the minimum size is preferred. The default value is 0.
   *
   * <li><code>EGL_ALPHA_SIZE</code></li>
   *
   * <p>Must be followed by a nonnegative minimum size specification. If
   * this value is zero, the smallest available alpha buffer is
   * preferred. Otherwise, the largest available alpha buffer of at
   * least the minimum size is preferred. The default value is 0.
   *
   * <li><code>EGL_CONFIG_CAVEAT</code></li>
   *
   * <p>Must be followed by one of <code>EGL_DONT_CARE</code>,
   * <code>EGL_NONE</code>, <code>EGL_SLOW_CONFIG</code>,
   * <code>EGL_NON_CONFORMANT_CONFIG</code>. If <code>EGL_NONE</code>
   * is specified, then only frame buffer configurations with no
   * caveats will be considered. If <code>EGL_SLOW_CONFIG</code> is
   * specified, then only slow frame buffer configurations will be
   * considered. If <code>EGL_NON_CONFORMANT_CONFIG</code> is
   * specified, then only non-conformant frame buffer configurations
   * will be considered. The default value is
   * <code>EGL_DONT_CARE</code>.
   *
   * <li><code>EGL_CONFIG_ID</code></li>
   *
   * <p>Must be followed by a valid ID that indicates the desired EGL
   * frame buffer configuration. When a <code>EGL_CONFIG_ID</code> is
   * specified, all attributes are ignored. The default value is
   * <code>EGL_DONT_CARE</code>.
   *
   * <li><code>EGL_DEPTH_SIZE</code></li>
   *
   * <p>Must be followed by a nonnegative integer that indicates the
   * desired depth buffer size. The smallest available depth buffer of
   * at least the minimum size is preferred. If the desired value is
   * zero, frame buffer configurations with no depth buffer are
   * preferred. The default value is 0.
   *
   * <li><code>EGL_LEVEL</code></li>
   *
   * <p>Must be followed by an integer buffer-level specification. This
   * specification is honored exactly. Buffer level 0 corresponds to
   * the default frame buffer of the display. Buffer level 1 is the
   * first overlay frame buffer, level two the second overlay frame
   * buffer, and so on. Negative buffer levels correspond to underlay
   * frame buffers. The default value is 0.
   *
   * <li><code>EGL_NATIVE_RENDERABLE</code></li>
   *
   * <p>Must be followed by <code>EGL_DONT_CARE</code>,
   * <code>EGL_TRUE</code>, or <code>EGL_FALSE</code>. If
   * <code>EGL_TRUE</code> is specified, then only frame buffer
   * configurations that allow native rendering into the surface will
   * be considered. The default value is <code>EGL_DONT_CARE</code>.
   *
   * <li><code>EGL_NATIVE_VISUAL_TYPE</code> (1.0 only)</li>
   *
   * <p>Must be followed by a platform dependent value or
   * <code>EGL_DONT_CARE</code>. The default value is
   * <code>EGL_DONT_CARE</code>.
   *
   * <li><code>EGL_SAMPLE_BUFFERS</code></li>
   *
   * <p>Must be followed by the minimum acceptable number of multisample
   * buffers. Configurations with the smallest number of multisample
   * buffers that meet or exceed this minimum number are
   * preferred. Currently operation with more than one multisample
   * buffer is undefined, so only values of zero or one will produce a
   * match. The default value is 0.
   *
   * <li><code>EGL_SAMPLES</code></li>
   *
   * <p>Must be followed by the minimum number of samples required in
   * multisample buffers. Configurations with the smallest number of
   * samples that meet or exceed the specified minimum number are
   * preferred. Note that it is possible for color samples in the
   * multisample buffer to have fewer bits than colors in the main
   * color buffers. However, multisampled colors maintain at least as
   * much color resolution in aggregate as the main color buffers.
   *
   * <li><code>EGL_STENCIL_SIZE</code></li>
   *
   * <p>Must be followed by a nonnegative integer that indicates the
   * desired number of stencil bitplanes. The smallest stencil buffer
   * of at least the specified size is preferred. If the desired value
   * is zero, frame buffer configurations with no stencil buffer are
   * preferred. The default value is 0.
   *
   * <li><code>EGL_SURFACE_TYPE</code></li>
   *
   * <p>Must be followed by a mask indicating which EGL surface types
   * the frame buffer configuration must support. Valid bits are
   * <code>EGL_WINDOW_BIT</code>, <code>EGL_PBUFFER_BIT</code>, and
   * <code>EGL_PIXMAP_BIT</code>. For example, if <code>mask</code> is
   * set to <code>EGL_WINDOW_BIT | EGL_PIXMAP_BIT</code>,
   * only frame buffer configurations that support both windows and
   * pixmaps will be considered. The default value is
   * <code>EGL_WINDOW_BIT</code>.
   *
   * <li><code>EGL_TRANSPARENT_TYPE</code></li>
   *
   * <p>Must be followed by one of <code>EGL_NONE</code> or
   * <code>EGL_TRANSPARENT_RGB</code>. If <code>EGL_NONE</code> is
   * specified, then only opaque frame buffer configurations will be
   * considered. If <code>EGL_TRANSPARENT_RGB</code> is specified,
   * then only transparent frame buffer configurations will be
   * considered. The default value is <code>EGL_NONE</code>.
   *
   * <li><code>EGL_TRANSPARENT_RED_VALUE</code></li>
   *
   * <p>Must be followed by an integer value indicating the transparent
   * red value. The value must be between 0 and the maximum color
   * buffer value for red. Only frame buffer configurations that use
   * the specified transparent red value will be considered. The
   * default value is <code>EGL_DONT_CARE</code>.
   *
   * <p>This attribute is ignored unless
   * <code>EGL_TRANSPARENT_TYPE</code> is included in
   * <code>attrib_list</code> and specified as
   * <code>EGL_TRANSPARENT_RGB</code>.
   *
   * <li><code>EGL_TRANSPARENT_GREEN_VALUE</code></li>
   *
   * <p>Must be followed by an integer value indicating the transparent
   * green value. The value must be between 0 and the maximum color
   * buffer value for red. Only frame buffer configurations that use
   * the specified transparent green value will be considered. The
   * default value is <code>EGL_DONT_CARE</code>.
   *
   * <p>This attribute is ignored unless
   * <code>EGL_TRANSPARENT_TYPE</code> is included in
   * <code>attrib_list</code> and specified as
   * <code>EGL_TRANSPARENT_RGB</code>.
   *
   * <li><code>EGL_TRANSPARENT_BLUE_VALUE</code></li>
   *
   * <p>Must be followed by an integer value indicating the transparent
   * blue value. The value must be between 0 and the maximum color
   * buffer value for red. Only frame buffer configurations that use
   * the specified transparent blue value will be considered. The
   * default value is <code>EGL_DONT_CARE</code>.
   *
   * <p>This attribute is ignored unless
   * <code>EGL_TRANSPARENT_TYPE</code> is included in
   * <code>attrib_list</code> and specified as
   * <code>EGL_TRANSPARENT_RGB</code>.
   *
   * <li><code>EGL_BIND_TO_TEXTURE_RGB</code> (1.1 only)</li>
   *
   * <p>Must be followed by <code>EGL_DONT_CARE</code>,
   * <code>EGL_TRUE</code>, or <code>EGL_FALSE</code>. If
   * <code>EGL_TRUE</code> is specified, then only frame buffer
   * configurations that support binding of color buffers to an RGB
   * texture will be considered. Currently only frame buffer
   * configurations that support pbuffers allow this. The default
   * value is <code>EGL_DONT_CARE</code>.
   *
   * <li><code>EGL_BIND_TO_TEXTURE_RGBA</code> (1.1 only)></li>
   *
   * <p>Must be followed by <code>EGL_DONT_CARE</code>,
   * <code>EGL_TRUE</code>, or <code>EGL_FALSE</code>. If
   * <code>EGL_TRUE</code> is specified, then only frame buffer
   * configurations that support binding of color buffers to an RGBA
   * texture will be considered. Currently only frame buffer
   * configurations that support pbuffers allow this. The default
   * value is <code>EGL_DONT_CARE</code>.
   *
   * <li><code>EGL_MAX_SWAP_INTERVAL</code> (1.1 only)</li>
   *
   * <p>Must be followed by a integer that indicates the maximum value
   * that can be passed to <code>eglSwapInterval</code>. The default
   * value is <code>EGL_DONT_CARE</code>.
   *
   * <li><code>EGL_MIN_SWAP_INTERVAL</code> (1.1 only)</li>
   *
   * <p>Must be followed by a integer that indicates the minimum value
   * that can be passed to <code>eglSwapInterval</code>. The default
   * value is <code>EGL_DONT_CARE</code>.
   *
   * </ul>
   *
   * <p>When more than one EGL frame buffer configuration matches the
   * specified attributes, a list of matching configurations is
   * returned. The list is sorted according to the following
   * precedence rules, which are applied in ascending order (i.e.,
   * configurations that are considered equal by a lower numbered rule
   * are sorted by the higher numbered rule):
   *
   * <ol>
   *
   * <li>By <code>EGL_CONFIG_CAVEAT</code>, where the precedence is
   * <code>EGL_NONE</code>, <code>EGL_SLOW_CONFIG</code>, and
   * <code>EGL_NON_CONFORMANT_CONFIG</code>.</li>
   *
   * <li>Larger total number of color components
   * (<code>EGL_RED_SIZE</code>, <code>EGL_GREEN_SIZE</code>,
   * <code>EGL_BLUE_SIZE</code>, and <code>EGL_ALPHA_SIZE</code>) that
   * have higher number of bits. If the requested number of bits in
   * <code>attrib_list</code> is zero or <code>EGL_DONT_CARE</code>
   * for a particular color component, then the number of bits for
   * that component is not considered.</li>
   *
   * <li>Smaller <code>EGL_BUFFER_SIZE</code>.</li>
   *
   * <li>Smaller <code>EGL_SAMPLE_BUFFERS</code>.</li>
   *
   * <li>Smaller <code>EGL_SAMPLES</code>.</li>
   *
   * <li>Smaller <code>EGL_DEPTH_SIZE</code>.</li>
   *
   * <li>Smaller <code>EGL_STENCIL_SIZE</code>.</li>
   *
   * <li>By <code>EGL_NATIVE_VISUAL_TYPE</code>, where the precedence
   * order is platform dependent.</li>
   *
   * <li>Smaller <code>EGL_CONFIG_ID</code>.</li>
   *
   * </ol>
   *
   * <p>(1.1) <code>EGLConfigs</code> are not sorted with respect to the
   * parameters <code>EGL_BIND_TO_TEXTURE_RGB</code>,
   * <code>EGL_BIND_TO_TEXTURE_RGBA</code>, <code>EGL_LEVEL</code>,
   * <code>EGL_NATIVE_RENDERABLE</code>,
   * <code>EGL_MAX_SWAP_INTERVAL</code>,
   * <code>EGL_MIN_SWAP_INTERVAL</code>,
   * <code>EGL_SURFACE_TYPE</code>, <code>EGL_TRANSPARENT_TYPE</code>,
   * <code>EGL_TRANSPARENT_RED_VALUE</code>,
   * <code>EGL_TRANSPARENT_GREEN_VALUE</code>, and
   * <code>EGL_TRANSPARENT_BLUE_VALUE</code>.
   *
   * <h4>Examples</h4>
   *
   * <p>The following example specifies a frame buffer configuration in
   * the normal frame buffer (not an overlay or underlay). The
   * returned frame buffer configuration supports at least 4 bits each
   * of red, green and blue and possible no alpha bits. The code shown
   * in the example may or may not have a depth buffer, or a stencil
   * buffer.
   *
   * <pre>
   * int attrib_list[] = {
   *     EGL10.EGL_RED_SIZE, 4,
   *     EGL10.EGL_GREEN_SIZE, 4,
   *     EGL10.EGL_BLUE_SIZE, 4,
   *     EGL10.EGL_NONE
   * };
   * </pre>
   *
   * <h4>Notes</h4>
   *
   * <p><code>eglGetConfigs</code> and <code>eglGetConfigAttrib</code> can be
   * used to implement selection algorithms other than the generic one
   * implemented by <code>eglChooseConfig</code>. Call
   * <code>eglGetConfigs</code> to retrieve all the frame buffer
   * configurations, or alternatively, all the frame buffer configurations
   * with a particular set of attributes. Next call
   * <code>eglGetConfigAttrib</code> to retrieve additional attributes for
   * the frame buffer configurations and then select between them.
   *
   * <p>EGL implementors are strongly discouraged, but not proscribed, from
   * changing the selection algorithm used by
   * <code>eglChooseConfig</code>. Therefore, selections may change from
   * release to release of the client-side library.
   *
   * <h4>Errors</h4>
   *
   * <p><code>false</code> is returned on failure, <code>true</code>
   * otherwise. <code>configs</code> and <code>num_config</code> are
   * not modified when <code>false</code> is returned.
   *
   * <p><code>EGL_BAD_DISPLAY</code> is generated if
   * <code>display</code> is not an EGL display connection.
   *
   * <p><code>EGL_BAD_ATTRIBUTE</code> is generated if
   * <code>attribute_list</code> contains an invalid frame buffer
   * configuration attribute or an attribute value that is
   * unrecognized or out of range.
   *
   * <p><code>EGL_NOT_INITIALIZED</code> is generated if
   * <code>display</code> has not been initialized.
   *
   * <p><code>EGL_BAD_PARAMETER</code> is generated if
   * <code>num_config</code> is <code>null</code>.
   *
   * @param display Specifies the EGL display connection.
   * @param attrib_list Specifies attributes required to match by configs.
   * @param configs Returns an array of frame buffer configurations.
   * @param config_size Specifies the size of the array of frame
   * buffer configurations.
   * @param num_config An <code>int</code> array in which the number of frame
   * buffer configurations will be returned in element 0.
   * @return <code>true</code> if the operation succeeds.
   *
   * @exception IllegalArgumentException if <code>display</code> is
   * <code>null</code>.
   * @exception IllegalArgumentException if <code>attrib_list</code> is
   * non-<code>null</code> but is not terminated with
   * <code>EGL_NONE</code>.
   * @exception IllegalArgumentException if <code>configs</code> is
   * non-<code>null</code> and <code>configs.length</code> is smaller
   * than <code>config_size</code>.
   * @exception IllegalArgumentException if <code>num_config</code> is
   * non-<code>null</code> but has length less than 1.
   */
  boolean eglChooseConfig(EGLDisplay display,
    			  int[] attrib_list,
    			  EGLConfig[] configs,
    			  int config_size,
    			  int[] num_config);
   
  /**
   * Return information about an EGL frame buffer configuration.
   *
   * <p><code>eglGetConfigAttrib</code> returns in <code>value[0]</code> the
   * value of <code>attribute</code> for
   * <code>config</code>. <code>attribute</code> can be one of the
   * following:
   *
   * <ul>
   *
   * <li><code>EGL_BUFFER_SIZE</code></li>
   *
   * <p>Returns the depth of the color buffer. It is the sum of
   * <code>EGL_RED_SIZE</code>, <code>EGL_GREEN_SIZE</code>,
   * <code>EGL_BLUE_SIZE</code>, and <code>EGL_ALPHA_SIZE</code>.
   *
   * <li><code>EGL_RED_SIZE</code></li>
   *
   * <p>Returns the number of bits of red stored in the color buffer.
   *
   * <li><code>EGL_GREEN_SIZE</code></li>
   *
   * <p>Returns the number of bits of green stored in the color buffer.
   *
   * <li><code>EGL_BLUE_SIZE</code></li>
   *
   * <p>Returns the number of bits of blue stored in the color buffer.
   *
   * <li><code>EGL_ALPHA_SIZE</code></li>
   *
   * <p>Returns the number of bits of alpha stored in the color buffer.
   *
   * <li><code>EGL_CONFIG_CAVEAT</code></li>
   *
   * <p>Returns the caveats for the frame buffer configuration. Possible
   * caveat values are <code>EGL_NONE</code>,
   * <code>EGL_SLOW_CONFIG</code>, and
   * <code>EGL_NON_CONFORMANT</code>.
   *
   * <li><code>EGL_CONFIG_ID</code></li>
   *
   * <p>Returns the ID of the frame buffer configuration.
   *
   * <li><code>EGL_DEPTH_SIZE</code></li>
   *
   * <p>Returns the number of bits in the depth buffer.
   *
   * <li><code>EGL_LEVEL</code></li>
   *
   * <p>Returns the frame buffer level. Level zero is the default frame
   * buffer. Positive levels correspond to frame buffers that overlay
   * the default buffer and negative levels correspond to frame
   * buffers that underlay the default buffer.
   *
   * <li><code>EGL_MAX_PBUFFER_WIDTH</code></li>
   *
   * <p>Returns the maximum width of a pixel buffer surface in pixels.
   *
   * <li><code>EGL_MAX_PBUFFER_HEIGHT</code></li>
   *
   * <p>Returns the maximum height of a pixel buffer surface in pixels.
   *
   * <li><code>EGL_MAX_PBUFFER_PIXELS</code></li>
   *
   * <p>Returns the maximum size of a pixel buffer surface in pixels.
   *
   * <li><code>EGL_NATIVE_RENDERABLE</code></li>
   *
   * <p>Returns <code>EGL_TRUE</code> if native rendering APIs can render
   * into the surface, <code>EGL_FALSE</code> otherwise.
   *
   * <li><code>EGL_NATIVE_VISUAL_ID</code></li>
   *
   * <p>Returns the ID of the associated native visual.
   *
   * <li><code>EGL_NATIVE_VISUAL_TYPE</code></li>
   *
   * <p>Returns the type of the associated native visual.
   *
   * <li><code>EGL_PRESERVED_RESOURCES</code> (1.0 only)</li>
   *
   * Returns <code>EGL_TRUE</code> if resources are preserved across
   * power management events, <code>EGL_FALSE</code> otherwise.
   *
   * <li><code>EGL_SAMPLE_BUFFERS</code></li>
   *
   * <p>Returns the number of multisample buffers.
   *
   * <li><code>EGL_SAMPLES</code></li>
   *
   * <p>Returns the number of samples per pixel.
   *
   * <li><code>EGL_STENCIL_SIZE</code></li>
   *
   * <p>Returns the number of bits in the stencil buffer.
   *
   * <li><code>EGL_SURFACE_TYPE</code></li>
   *
   * <p>Returns the types of supported EGL surfaces.
   *
   * <li><code>EGL_TRANSPARENT_TYPE</code></li>
   *
   * <p>Returns the type of supported transparency. Possible transparency
   * values are: <code>EGL_NONE</code>, and
   * <code>EGL_TRANSPARENT_RGB</code>.
   *
   * <li><code>EGL_TRANSPARENT_RED_VALUE</code></li>
   *
   * <p>Returns the transparent red value.
   *
   * <li><code>EGL_TRANSPARENT_GREEN_VALUE</code></li>
   *
   * <p>Returns the transparent green value.
   *
   * <li><code>EGL_TRANSPARENT_BLUE_VALUE</code></li>
   *
   * <p>Returns the transparent blue value.
   *
   * <li><code>EGL_BIND_TO_TEXTURE_RGB</code> (1.1 only)</li>
   *
   * <p>Returns <code>EGL_TRUE</code> if color buffers can be bound to an
   * RGB texture, <code>EGL_FALSE</code> otherwise.
   *
   * <li><code>EGL_BIND_TO_TEXTURE_RGBA</code> (1.1 only)</li>
   *
   * <p>Returns <code>EGL_TRUE</code> if color buffers can be bound to an
   * RGBA texture, <code>EGL_FALSE</code> otherwise.
   *
   * <li><code>EGL_MAX_SWAP_INTERVAL</code> (1.1 only)</li>
   *
   * <p>Returns the maximum value that can be passed to
   * <code>eglSwapInterval</code>.
   *
   * <li><code>EGL_MIN_SWAP_INTERVAL</code> (1.1 only)</li>
   *
   * <p>Returns the minimum value that can be passed to
   * <code>eglSwapInterval</code>.
   *
   * </ul>
   *
   * <h4>Errors</h4>
   *
   * <p><code>false</code> is returned on failure, <code>true</code>
   * otherwise. <code>value</code> is not modified when
   * <code>false</code> is returned.
   *
   * <p><code>EGL_BAD_DISPLAY</code> is generated if <code>display</code>
   * is not an EGL display connection.
   *
   * <p><code>EGL_NOT_INITIALIZED</code> is generated if
   * <code>display</code> has not been initialized.
   *
   * <p><code>EGL_BAD_CONFIG</code> is generated if <code>config</code>
   * is not an EGL frame buffer configuration.
   *
   * <p><code>EGL_BAD_ATTRIBUTE</code> is generated if
   * <code>attribute</code> is not a valid frame buffer configuration
   * attribute.
   *
   * @param display Specifies the EGL display connection.
   * @param config Specifies the EGL frame buffer configuration to be queried.
   * @param attribute Specifies the EGL rendering context attribute to
   * be returned.
   * @param value An <code>int</code> array of length at least 1 in
   * which the requested value will be returned as element 0.
   *
   * @exception IllegalArgumentException if <code>display</code> is
   * <code>null</code>.
   * @exception IllegalArgumentException if <code>config</code> is
   * <code>null</code>.
   * @exception IllegalArgumentException if <code>value</code> is
   * <code>null</code> or has length less than 1.
   *
   * @return <code>true</code> if the query succeeds.
   */
  boolean eglGetConfigAttrib(EGLDisplay display,
    			     EGLConfig config,
    			     int attribute,
    			     int[] value);
  
  /**
   * Create a new EGL window surface.
   *
   * <p><code>eglCreateWindowSurface</code> creates an EGL window surface
   * and returns its handle. If <code>eglCreateWindowSurface</code>
   * fails to create a window surface, <code>EGL_NO_SURFACE</code> is
   * returned.
   *
   * <p>Any EGL rendering context that was created with respect to
   * <code>config</code> can be used to render into the surface. Use
   * <code>eglMakeCurrent</code> to attach an EGL rendering context to
   * the surface.
   *
   * <p>Use <code>eglQuerySurface</code> to retrieve the ID of
   * <code>config</code>.
   *
   * <p>Use <code>eglDestroySurface</code> to destroy the surface.
   *
   * <h4>Notes</h4>
   *
   * <p>On JME CLDC/MIDP platforms, <code>native_window</code> must be
   * an instance of <code>javax.microedition.lcdui.Graphics</code>
   * object created directly from an instance of
   * <code>GameCanvas</code> or from the argument supplied to the
   * <code>Canvas.paint</code> method. <!-- <code>EGLCanvas</code> -->
   *
   * <!--
   * <p>On JME Personal Basis Profile platforms,
   * <code>native_window</code> must be an instance of
   * <code>java.awt.Container</code>.

   * <p>On JME Personal Profile platforms,
   * <code>native_window</code> must be an instance of
   * <code>java.awt.Canvas</code>.
   * -->
   *
   * <h4>Errors</h4>
   *
   * <p><code>EGL_NO_SURFACE</code> is returned if creation of the
   * context fails.
   *
   * <p><code>EGL_BAD_DISPLAY</code> is generated if <code>display</code>
   * is not an EGL display connection.
   *
   * <p><code>EGL_NOT_INITIALIZED</code> is generated if
   * <code>display</code> has not been initialized.
   *
   * <p><code>EGL_BAD_CONFIG</code> is generated if <code>config</code>
   * is not an EGL frame buffer configuration.
   *
   * <p><code>EGL_BAD_NATIVE_WINDOW</code> may be generated if
   * <code>native_window</code> is not a valid native window.
   *
   * <p><code>EGL_BAD_ATTRIBUTE</code> is generated if
   * <code>attrib_list</code> contains an invalid window attribute or
   * if an attribute value is not recognized or is out of range.
   *
   * <p><code>EGL_BAD_ALLOC</code> is generated if there are not enough
   * resources to allocate the new surface.
   *
   * <p><code>EGL_BAD_MATCH</code> is generated if the attributes of
   * <code>native_window</code> do not correspond to
   * <code>config</code> or if <code>config</code> does not support
   * rendering to windows (the <code>EGL_SURFACE_TYPE</code> attribute
   * does not contain <code>EGL_WINDOW_BIT</code>).
   *
   * @param display Specifies the EGL display connection.
   * @param config Specifies the EGL frame buffer configuration that
   * defines the frame buffer resource available to the surface.
   * @param native_window Specifies the native window.
   * @param attrib_list Specifies window surface attributes. Must be
   * <code>null</code> or empty (first attribute is <code>EGL_NONE</code>).
   *
   * @return an <code>EGLSurface</code> for rendering to the window.
   *
   * @exception IllegalArgumentException if <code>display</code> is
   * <code>null</code>.
   * @exception IllegalArgumentException if <code>config</code> is
   * <code>null</code>.
   * @exception IllegalArgumentException if <code>native_window</code>
   * is <code>null</code> or is not of a suitable type for the
   * underlying platform (e.g., not a properly-created
   * <code>javax.microedition.lcdui.Graphics</code> instance for
   * CLDC/MIDP).
   * @exception IllegalArgumentException if <code>attrib_list</code>
   * is non-<code>null</code> but is not terminated with
   * <code>EGL_NONE</code>.
   */
  EGLSurface eglCreateWindowSurface(EGLDisplay display,
    				    EGLConfig config,
    				    Object native_window,
    				    int[] attrib_list);     

  /**
   * Create a new EGL pixmap surface.
   *
   * <p><code>eglCreatePixmapSurface</code> creates an off-screen EGL
   * pixmap surface and returns its handle. If
   * <code>eglCreatePixmapSurface</code> fails to create a pixmap
   * surface, <code>EGL_NO_SURFACE</code> is returned.
   *
   * <p>Any EGL rendering context that was created with respect to
   * <code>config</code> can be used to render into the surface. Use
   * <code>eglMakeCurrent</code> to attach an EGL rendering context to
   * the surface.
   *
   * <p>Use <code>eglQuerySurface</code> to retrieve the ID of
   * <code>config</code>.
   *
   * <p>Use <code>eglDestroySurface</code> to destroy the surface.
   *
   * <h4>Notes</h4>
   *
   * <p>On JME CLDC/MIDP platforms, <code>native_pixmap</code> must be
   * an instance of <code>javax.microedition.lcdui.Graphics</code>
   * that was created directly from a mutable instance of
   * <code>javax.microedition.lcdui.Image</code>.
   *
   * <!--
   * <p>On JME Personal Basis Profile and Personal Profile platforms,
   * <code>native_pixmap</code> must be an instance of
   * <code>java.awt.Graphics</code> that was created using the
   * <code>BufferedImage.getGraphics</code> or
   * <code>createGraphics</code> methods.
   * -->
   *
   * <h4>Errors</h4>
   *
   * <p><code>EGL_NO_SURFACE</code> is returned if creation of the
   * context fails.
   *
   * <p><code>EGL_BAD_DISPLAY</code> is generated if <code>display</code>
   * is not an EGL display connection.
   *
   * <p><code>EGL_NOT_INITIALIZED</code> is generated if
   * <code>display</code> has not been initialized.
   *
   * <p><code>EGL_BAD_CONFIG</code> is generated if <code>config</code>
   * is not an EGL config.
   *
   * <p><code>EGL_BAD_NATIVE_PIXMAP</code> may be generated if
   * <code>native_pixmap</code> is not a valid native pixmap.
   *
   * <p><code>EGL_BAD_ATTRIBUTE</code> is generated if
   * <code>attrib_list</code> contains an invalid pixmap attribute or
   * if an attribute value is not recognized or out of range.
   *
   * <p><code>EGL_BAD_ALLOC</code> is generated if there are not enough
   * resources to allocate the new surface.
   *
   * <p><code>EGL_BAD_MATCH</code> is generated if the attributes of
   * <code>native_pixmap</code> do not correspond to
   * <code>config</code> or if <code>config</code> does not support
   * rendering to pixmaps (the <code>EGL_SURFACE_TYPE</code> attribute
   * does not contain <code>EGL_PIXMAP_BIT</code>).
   *
   * @param display Specifies the EGL display connection.
   * @param config Specifies the EGL frame buffer configuration that
   * defines the frame buffer resource available to the surface.
   * @param native_pixmap Specifies the native pixmap.
   * @param attrib_list Specifies pixmap surface attributes. Must be
   * <code>null</code> or empty (first attribute is <code>EGL_NONE</code>).
   *
   * @return An <code>EGLSurface</code> for offscreen rendering.
   *
   * @exception IllegalArgumentException if <code>display</code> is
   * <code>null</code>.
   * @exception IllegalArgumentException if <code>config</code> is
   * <code>null</code>
   * @exception IllegalArgumentException if <code>native_pixmap</code>
   * is <code>null</code> or is not of a suitable type for the
   * underlying platform (e.g., not a mutable <code>Image</code> for
   * CLDC/MIDP).
   * @exception IllegalArgumentException if <code>attrib_list</code>
   * is non-<code>null</code> but is not terminated with
   * <code>EGL_NONE</code>.
   */
  EGLSurface eglCreatePixmapSurface(EGLDisplay display,
    				    EGLConfig config,
    				    Object native_pixmap,
    				    int[] attrib_list);     
 
  /**
   * Create a new EGL pixel buffer surface.
   *
   * <p><code>eglCreatePbufferSurface</code> creates an off-screen pixel
   * buffer surface and returns its handle. If
   * <code>eglCreatePbufferSurface</code> fails to create a pixel
   * buffer surface, <code>EGL_NO_SURFACE</code> is returned.
   *
   * <p>Any EGL rendering context that was created with respect to
   * <code>config</code> can be used to render into the surface. Use
   * <code>eglMakeCurrent</code> to attach an EGL rendering context to
   * the surface.
   *
   * <p>Use <code>eglQuerySurface</code> to retrieve the dimensions of
   * the allocated pixel buffer surface or the ID of
   * <code>config</code>.
   *
   * <p>Use <code>eglDestroySurface</code> to destroy the surface.
   *
   * <p>The pixel buffer surface attributes are specified in
   * <code>attrib_list</code> as a list of attribute value pairs,
   * terminated with <code>EGL_NONE</code>. A <code>null</code> value
   * for <code>attrib_list</code> is treated as an empty list. The
   * accepted attributes for an EGL pixel buffer surface are:
   *
   * <ul>
   *
   * <li><code>EGL_WIDTH</code></li>
   *
   * <p>Specifies the requested width of the pixel buffer surface. The
   * default value is 0.
   *
   * <li><code>EGL_HEIGHT</code></li>
   *
   * <p>Specifies the requests height of the pixel buffer surface. The
   * default value is 0.
   *
   * <li><code>EGL_LARGEST_PBUFFER</code></li>
   *
   * <p>Requests the largest available pixel buffer surface when the
   * allocation would otherwise fail. Use <code>eglQuerySurface</code>
   * to retrieve the dimensions of the allocated pixel buffer. The
   * default value is <code>EGL_FALSE</code>.
   *
   * <li><code>EGL_TEXTURE_FORMAT</code> (1.1 only)</li>
   *
   * <p>Specifies the format of the texture that will be created when
   * a pbuffer is bound to a texture map. Possible values are
   * <code>EGL_NO_TEXTURE</code>, <code>EGL_TEXTURE_RGB</code>, and
   * <code>EGL_TEXTURE_RGBA</code>. The default value is
   * <code>EGL_NO_TEXTURE</code>.
   *
   * <li><code>EGL_TEXTURE_TARGET</code> (1.1 only)</li>
   *
   * <p>Specifies the target for the texture that will be created when
   * the pbuffer is created with a texture format of
   * <code>EGL_TEXTURE_RGB</code> or
   * <code>EGL_TEXTURE_RGBA</code>. Possible values are
   * <code>EGL_NO_TEXTURE</code>, or <code>EGL_TEXTURE_2D</code>. The
   * default value is <code>EGL_NO_TEXTURE</code>.
   *
   * <li><code>EGL_MIPMAP_TEXTURE</code> (1.1 only)</li>
   *
   * <p>Specifies whether storage for mipmaps should be allocated. Space
   * for mipmaps will be set aside if the attribute value is
   * <code>EGL_TRUE</code> and <code>EGL_TEXTURE_FORMAT</code> is not
   * <code>EGL_NO_TEXTURE</code>. The default value is
   * <code>EGL_FALSE</code>.
   *
   * </ul>
   *
   * <h4>1.1 Notes</h4>
   *
   * <p>If the value of config attribute <code>EGL_TEXTURE_FORMAT</code>
   * is not <code>EGL_NO_TEXTURE</code>, then the pbuffer width and
   * height specify the size of the level zero texture image
   *
   * <p>If <code>EGL_LARGEST_PBUFFER</code> is specified and if the
   * pbuffer will be used as a texture (i.e. the value of
   * <code>EGL_TEXTURE_TARGET</code> is <code>EGL_TEXTURE_2D</code>,
   * and the value of EGL_TEXTURE <code>FORMAT</code> is
   * <code>EGL_TEXTURE_RGB</code> or <code>EGL_TEXTURE_RGBA</code>),
   * then the aspect ratio will be preserved and the new width and
   * height will be valid sizes for the texture target (e.g. if the
   * underlying OpenGL ES implementation does not support
   * non-power-of-two textures, both the width and height will be a
   * power of 2).
   *
   * <p>The contents of the depth and stencil buffers may not be
   * preserved when rendering a texture to the pbuffer and switching
   * which image of the texture is rendered to (e.g., switching from
   * rendering one mipmap level to rendering another).
   *
   * <h4>Errors</h4>
   *
   * <p><code>EGL_NO_SURFACE</code> is returned if creation of the
   * context fails.
   *
   * <p><code>EGL_BAD_DISPLAY</code> is generated if <code>display</code>
   * is not an EGL display connection.
   *
   * <p><code>EGL_NOT_INITIALIZED</code> is generated if
   * <code>display</code> has not been initialized.
   *
   * <p><code>EGL_BAD_CONFIG</code> is generated if <code>config</code>
   * is not an EGL frame buffer configuration.
   *
   * <p><code>EGL_BAD_ATTRIBUTE</code> is generated if
   * <code>attrib_list</code> contains an invalid pixel buffer
   * attribute or if an attribute value is not recognized or out of
   * range.
   *
   * <p><code>EGL_BAD_ALLOC</code> is generated if there are not enough
   * resources to allocate the new surface.
   *
   * <p><code>EGL_BAD_MATCH</code> is generated if <code>config</code>
   * does not support rendering to pixel buffers (the
   * <code>EGL_SURFACE_TYPE</code> attribute does not contain
   * <code>EGL_PBUFFER_BIT</code>).
   *
   * <p>(1.1 only) <code>EGL_BAD_VALUE</code> is generated if the
   * <code>EGL_TEXTURE_FORMAT</code> attribute is not
   * <code>EGL_NO_TEXTURE</code>, and <code>EGL_WIDTH</code> and/or
   * <code>EGL_HEIGHT</code> specify an invalid size (e.g., the
   * texture size is not a power of 2, and the underlying OpenGL ES
   * implementation does not support non-power-of-two textures).
   *
   * <p>(1.1 only) <code>EGL_BAD_VALUE</code> can also be generated if
   * The <code>EGL_TEXTURE_FORMAT</code> attribute is
   * <code>EGL_NO_TEXTURE</code>, and <code>EGL_TEXTURE_TARGET</code>
   * is something other than <code>EGL_NO_TEXTURE</code>; or,
   * <code>EGL_TEXTURE_FORMAT</code> is something other than
   * <code>EGL_NO_TEXTURE</code>, and <code>EGL_TEXTURE_TARGET</code>
   * is <code>EGL_NO_TEXTURE</code>.
   *
   * @param display Specifies the EGL display connection.
   * @param config Specifies the EGL frame buffer configuration that
   * defines the frame buffer resource available to the surface.
   * @param attrib_list Specifies the pixel buffer surface
   * attributes. May be <code>null</code> or empty (first attribute is
   * <code>EGL_NONE</code>).
   *
   * @return An <code>EGLSurface</code> for offscreen rendering.
   *
   * @exception IllegalArgumentException if <code>display</code> is
   * <code>null</code>.
   * @exception IllegalArgumentException if <code>config</code> is
   * <code>null</code>.
   * @exception IllegalArgumentException if <code>attrib_list</code>
   * is non-<code>null</code> but is not terminated with
   * <code>EGL_NONE</code>.
   */
  EGLSurface eglCreatePbufferSurface(EGLDisplay display,
    				     EGLConfig config,
    				     int[] attrib_list);

  /**
   * Destroy an EGL surface.
   *
   * <p>If the EGL surface <code>surface</code> is not current to any
   * thread, <code>eglDestroySurface</code> destroys it
   * immediately. Otherwise, <code>surface</code> is destroyed when it
   * becomes not current to any thread.
   *
   * <p>(1.1) In OpenGL ES 1.1, resources associated with a pbuffer surface
   * are not released until all color buffers of that pbuffer bound to
   * a texture object have been released.
   *
   * <h4>Errors</h4>
   *
   * <p><code>false</code> is returned if destruction of the surface
   * fails, <code>true</code> otherwise.
   *
   * <p><code>EGL_BAD_DISPLAY</code> is generated if <code>display</code>
   * is not an EGL display connection.
   *
   * <p><code>EGL_NOT_INITIALIZED</code> is generated if
   * <code>display</code> has not been initialized.
   *
   * <p><code>EGL_BAD_SURFACE</code> is generated if <code>surface</code>
   * is not an EGL surface.
   *
   * @param display Specifies the EGL display connection.
   * @param surface Specifies the EGL surface to be destroyed.
   *
   * @exception IllegalArgumentException if <code>display</code> is
   * <code>null</code>.
   * @exception IllegalArgumentException if <code>surface</code> is
   * <code>null</code>.
   *
   * @return <code>true</code> if the operation succeeds.
   */
  boolean eglDestroySurface(EGLDisplay display, EGLSurface surface);

  /**
   * Return EGL surface information.
   *
   * <p><code>eglQuerySurface</code> returns in <code>value[0]</code> the
   * <code>value</code> of <code>attribute</code> for
   * <code>surface</code>. <code>attribute</code> can be one of the
   * following:
   *
   * <ul>
   *
   * <li><code>EGL_CONFIG_ID</code></li>
   *
   * <p>Returns the ID of the EGL frame buffer configuration with respect
   * to which the surface was created.
   *
   * <li><code>EGL_WIDTH</code></li>
   *
   * <p>Returns the width of the surface in pixels.
   *
   * <li><code>EGL_HEIGHT</code></li>
   *
   * <p>Returns the height of the surface in pixels.
   *
   * <li><code>EGL_LARGEST_PBUFFER</code></li>
   *
   * <p>Returns the same attribute value specified when the surface was
   * created with <code>eglCreatePbufferSurface</code>. For a window
   * or pixmap surface, value is not modified.
   *
   * <li><code>EGL_TEXTURE_FORMAT</code> (1.1 only)</li>
   *
   * <p>Returns format of texture. Possible values are
   * <code>EGL_NO_TEXTURE</code>, <code>EGL_TEXTURE_RGB</code>, and
   * <code>EGL_TEXTURE_RGBA</code>.
   *
   * <li><code>EGL_TEXTURE_TARGET</code> (1.1 only)</li>
   *
   * <p>Returns type of texture. Possible values are
   * <code>EGL_NO_TEXTURE</code>, or <code>EGL_TEXTURE_2D</code>.
   *
   * <li><code>EGL_MIPMAP_TEXTURE</code> (1.1 only)</li>
   *
   * <p>Returns <code>EGL_TRUE</code> if texture has mipmaps,
   * <code>EGL_FALSE</code> otherwise.
   *
   * <li><code>EGL_MIPMAP_LEVEL</code> (1.1 only)</li>
   *
   * <p>Returns which level of the mipmap to render to, if texture has mipmaps.
   *
   * </ul>
   *
   * <h4>1.1 Notes</h4>
   *
   * Querying <code>EGL_TEXTURE_FORMAT</code>,
   * <code>EGL_TEXTURE_TARGET</code>, <code>EGL_MIPMAP_TEXTURE</code>,
   * or <code>EGL_MIPMAP_LEVEL</code> for a non-pbuffer surface is not
   * an error, but <code>value</code> is not modified.
   *
   * <h4>Errors</h4>
   *
   * <p><code>false</code> is returned on failure, <code>true</code>
   * otherwise. <code>value</code> is not modified when
   * <code>false</code> is returned.
   *
   * <p><code>EGL_BAD_DISPLAY</code> is generated if <code>display</code>
   * is not an EGL display connection.
   *
   * <p><code>EGL_NOT_INITIALIZED</code> is generated if
   * <code>display</code> has not been initialized.
   *
   * <p><code>EGL_BAD_SURFACE</code> is generated if <code>surface</code>
   * is not an EGL surface.
   *
   * <p><code>EGL_BAD_ATTRIBUTE</code> is generated if
   * <code>attribute</code> is not a valid surface attribute.
   *
   * @param display Specifies the EGL display connection.
   * @param surface Specifies the EGL surface to query.
   * @param attribute Specifies the EGL surface attribute to be returned.
   * @param value Returns the requested value.
   *
   * @exception IllegalArgumentException if <code>display</code> is
   * <code>null</code>.
   * @exception IllegalArgumentException if <code>surface</code> is
   * <code>null</code>.
   * @exception IllegalArgumentException if <code>value</code> is
   * <code>null</code> or has length less than 1.
   *
   * @return <code>true</code> if the query succeeds.
   */
  boolean eglQuerySurface(EGLDisplay display,
    			  EGLSurface surface,
    			  int attribute,
    			  int[] value);

  /**
   * Create a new EGL rendering context.
   *
   * <p><code>eglCreateContext</code> creates an EGL rendering context
   * and returns its handle. This context can be used to render into
   * an EGL drawing surface. If <code>eglCreateContext</code> fails to
   * create a rendering context, <code>EGL_NO_CONTEXT</code> is
   * returned.
   *
   * <p>If <code>share_context</code> is not <code>EGL_NO_CONTEXT</code>,
   * then all texture objects except object 0, are shared by context
   * <code>share_context</code> and by the newly created context. An
   * arbitrary number of rendering contexts can share a single texture
   * object space. However, all rendering contexts that share a single
   * texture object space must themselves exist in the same address
   * space. Two rendering contexts share an address space if both are
   * owned by a single process.
   *
   * <p> Currently no attributes are recognized, so
   * <code>attrib_list</code> will normally be <code>null</code> or
   * empty (first attribute is <code>EGL_NONE</code>). However, it is
   * possible that some platforms will define attributes specific to
   * those environments, as an EGL extension.  A non-<code>null</code>
   * attribute list that is terminated with <code>EGL_NONE</code> will
   * be passed to the underlying EGL implementation.
   *
   * <!--
   * <h4>Notes</h4>
   *
   * <p>A process is a single execution environment, implemented in a
   * single address space, consisting of one or more threads.
   *
   * <p>A thread is one of a set of subprocesses that share a single
   * address space, but maintain separate program counters, stack
   * spaces, and other related global data. A thread is the only
   * member of its subprocess group is equivalent to a process.
   * -->
   *
   * <h4>Errors</h4>
   *
   * <p><code>EGL_NO_CONTEXT</code> is returned if creation of the
   * context fails.
   *
   * <p><code>EGL_BAD_DISPLAY</code> is generated if <code>display</code>
   * is not an EGL display connection.
   *
   * <p><code>EGL_NOT_INITIALIZED</code> is generated if
   * <code>display</code> has not been initialized.
   *
   * <p><code>EGL_BAD_CONFIG</code> is generated if <code>config</code>
   * is not an EGL frame buffer configuration.
   *
   * <p><code>EGL_BAD_CONTEXT</code> is generated if
   * <code>share_context</code> is not an EGL rendering context and is
   * not <code>EGL_NO_CONTEXT</code>.
   *
   * <p><code>EGL_BAD_ATTRIBUTE</code> is generated if
   * <code>attrib_list</code> contains an invalid context attribute or
   * if an attribute is not recognized or out of range.
   *
   * <p><code>EGL_BAD_ALLOC</code> is generated if there are not enough
   * resources to allocate the new context.
   *
   * @param display Specifies the EGL display connection.
   * @param config Specifies the EGL frame buffer configuration that
   * defines the frame buffer resource available to the rendering
   * context.
   * @param share_context Specifies the EGL rendering context with
   * which to share texture objects. <code>EGL_NO_CONTEXT</code>
   * indicates that no sharing is to take place.
   * @param attrib_list Specifies attributes.
   *
   * @return A new <code>EGLContext</code>, or <code>null</code>
   * if context creation was unsuccessful.
   *
   * @exception IllegalArgumentException if <code>display</code> is
   * <code>null</code>.
   * @exception IllegalArgumentException if <code>config</code> is
   * <code>null</code>.
   * @exception IllegalArgumentException if <code>share_context</code> is
   * <code>null</code>.
   * @exception IllegalArgumentException if <code>attrib_list</code> is
   * non-<code>null</code> but is not terminated with
   * <code>EGL_NONE</code>.
   */
  EGLContext eglCreateContext(EGLDisplay display,
    			      EGLConfig config,
    			      EGLContext share_context,
    			      int[] attrib_list);

  /**
   * Destroy an EGL rendering context.
   *
   * <p>If the EGL rendering context context is not current to any
   * thread, <code>eglDestroyContext</code> destroys it
   * immediately. Otherwise, <code>context</code> is destroyed when it
   * becomes not current to any thread.
   *
   * <h4>Errors</h4>
   *
   * <p><code>false</code> is returned if destruction of the context
   * fails, <code>true</code> otherwise.
   *
   * <p><code>EGL_BAD_DISPLAY</code> is generated if <code>display</code>
   * is not an EGL display connection.
   *
   * <p><code>EGL_NOT_INITIALIZED</code> is generated if
   * <code>display</code> has not been initialized.
   *
   * <p><code>EGL_BAD_CONTEXT</code> is generated if <code>context</code>
   * is not an EGL rendering context.
   *
   * @param display Specifies the EGL display connection.
   * @param context Specifies the EGL rendering context to be destroyed.
   *
   * @exception IllegalArgumentException if <code>display</code> is
   * <code>null</code>.
   * @exception IllegalArgumentException if <code>context</code> is
   * <code>null</code>.
   *
   * @return <code>true</code> if the operation succeeds.
   */
  boolean eglDestroyContext(EGLDisplay display, EGLContext context);

  /**
   * Attach an EGL rendering context to EGL surfaces.
   *
   * <p><code>eglMakeCurrent</code> binds <code>context</code> to the
   * current rendering thread and to the <code>draw</code> and
   * <code>read</code> surfaces. <code>draw</code> is used for all GL
   * operations except for any pixel data read back
   * (<code>glReadPixels</code>, <code>glCopyTexImage2D</code>, and
   * <code>glCopyTexSubImage2D</code>), which is taken from the frame
   * buffer values of <code>read</code>.
   *
   * <p>If the calling thread has already a current rendering context,
   * that context is flushed and marked as no longer current.
   *
   * <p>The first time that context is made current, the viewport and
   * scissor dimensions are set to the size of the <code>draw</code>
   * surface. The viewport and scissor are not modified when
   * <code>context</code> is subsequently made current.
   *
   * <p>To release the current context without assigning a new one, call
   * eglMakeCurrent with <code>draw</code> and <code>read</code> set
   * to <code>EGL_NO_SURFACE</code> and <code>context</code> set to
   * <code>EGL_NO_CONTEXT</code>.
   *
   * <p>Use <code>eglGetCurrentContext</code>,
   * <code>eglGetCurrentDisplay</code>, and
   * <code>eglGetCurrentSurface</code> to query the current rendering
   * context and associated display connection and surfaces.
   *
   * <h4>Errors</h4>
   *
   * <p><code>false</code> is returned on failure,
   * <code>true</code> otherwise. If <code>false</code> is
   * returned, the previously current rendering context and surfaces
   * (if any) remain unchanged.
   *
   * <p><code>EGL_BAD_DISPLAY</code> is generated if <code>display</code>
   * is not an EGL display connection.
   *
   * <p><code>EGL_NOT_INITIALIZED</code> is generated if
   * <code>display</code> has not been initialized.
   *
   * <p><code>EGL_BAD_SURFACE</code> is generated if <code>draw</code> or
   * <code>read</code> is not an EGL surface.
   *
   * <p><code>EGL_BAD_CONTEXT</code> is generated if <code>context</code>
   * is not an EGL rendering context.
   *
   * <p><code>EGL_BAD_MATCH</code> is generated if <code>draw</code> or
   * <code>read</code> are not compatible with context, or if
   * <code>context</code> is set to <code>EGL_NO_CONTEXT</code> and
   * <code>draw</code> or <code>read</code> are not set to
   * <code>EGL_NO_SURFACE</code>, or if <code>draw</code> or
   * <code>read</code> are set to <code>EGL_NO_SURFACE</code> and
   * <code>context</code> is not set to <code>EGL_NO_CONTEXT</code>.
   *
   * <p><code>EGL_BAD_ACCESS</code> is generated if <code>context</code>
   * is current to some other thread.
   *
   * <p><code>EGL_BAD_NATIVE_PIXMAP</code> may be generated if a native
   * pixmap underlying either <code>draw</code> or <code>read</code>
   * is no longer valid.
   *
   * <p><code>EGL_BAD_NATIVE_WINDOW</code> may be generated if a native
   * window underlying either <code>draw</code> or <code>read</code>
   * is no longer valid.
   *
   * <p><code>EGL_BAD_CURRENT_SURFACE</code> is generated if the previous
   * context has unflushed commands and the previous surface is no
   * longer valid.
   *
   * <p><code>EGL_BAD_ALLOC</code> may be generated if allocation of
   * ancillary buffers for draw or read were delayed until
   * <code>eglMakeCurrent</code> is called, and there are not enough
   * resources to allocate them.
   *
   * <p><code>EGL_CONTEXT_LOST</code> (1.1 only)
   *
   * <p>A power management event has occurred. The application must
   * destroy all contexts and reinitialise OpenGL ES state and objects
   * to continue rendering.
   *
   * @param display Specifies the EGL display connection.
   * @param draw Specifies the EGL draw surface.
   * @param read Specifies the EGL read surface.
   * @param context Specifies the EGL rendering context to be attached
   * to the surfaces.
   *
   * @exception IllegalArgumentException if <code>display</code> is
   * <code>null</code>.
   * @exception IllegalArgumentException if <code>draw</code> is
   * <code>null</code>.
   * @exception IllegalArgumentException if <code>read</code> is
   * <code>null</code>.
   * @exception IllegalArgumentException if <code>context</code> is
   * <code>null</code>.
   *
   * @return <code>true</code> if the operation succeeds.
   */
  boolean eglMakeCurrent(EGLDisplay display,
    			 EGLSurface draw,
    			 EGLSurface read,
    			 EGLContext context);
   
  /**
   * Return the current EGL rendering context.
   *
   * <p><code>eglGetCurrentContext</code> returns the current EGL
   * rendering context, as specified by
   * <code>eglMakeCurrent</code>. If no context is current,
   * <code>EGL_NO_CONTEXT</code> is returned.
   *
   * @return The current <code>EGLContext</code>, or
   * <code>EGL_NO_CONTEXT</code>.
   */
  EGLContext eglGetCurrentContext();

  /**
   * Return the read or draw surface for the current EGL rendering
   * context.
   *
   * <p><code>eglGetCurrentSurface</code> returns the read or draw
   * surface attached to the current EGL rendering context, as
   * specified by <code>eglMakeCurrent</code>. If no context is
   * current, <code>EGL_NO_SURFACE</code> is returned.
   *
   * @param readdraw Specifies whether the EGL read or draw surface is
   * to be returned, one of <code>EGL_READ</code> or
   * <code>EGL_DRAW</code>.
   * @return The current <code>EGLSurface</code> used for reading (if
   * <code>readdraw</code> equals <code>EGL_READ</code>, or drawing
   * (if <code>readdraw</code> equals <code>EGL_DRAW</code>).
   *
   * @exception IllegalArgumentException if <code>readdraw</code> is
   * not one of the specified constants.
   */
  EGLSurface eglGetCurrentSurface(int readdraw);

  /**
   * Return the display for the current EGL rendering context.
   *
   * <p><code>eglGetCurrentDisplay</code> returns the current EGL display
   * connection for the current EGL rendering context, as specified by
   * <code>eglMakeCurrent</code>. If no context is current,
   * <code>EGL_NO_DISPLAY</code> is returned.
   *
   * @return The current <code>EGLDisplay</code>
   */
  EGLDisplay eglGetCurrentDisplay();

  /**
   * Return EGL rendering context information.
   *
   * <p><code>eglQueryContext</code> returns in <code>value[0]</code> the
   * value of <code>attribute</code> for
   * <code>context</code>. <code>attribute</code> can be one of the
   * following:
   *
   * <ul>
   *
   * <li><code>EGL_CONFIG_ID</code></li>
   *
   * <p>Returns the ID of the EGL frame buffer configuration with respect
   * to which the context was created.
   *
   * </ul>
   *
   * <h4>Errors</h4>
   *
   * <p><code>false</code> is returned on failure, <code>true</code>
   * otherwise. <code>value</code> is not modified when
   * <code>false</code> is returned.
   *
   * <p><code>EGL_BAD_DISPLAY</code> is generated if <code>display</code>
   * is not an EGL display connection.
   *
   * <p><code>EGL_NOT_INITIALIZED</code> is generated if
   * <code>display</code> has not been initialized.
   *
   * <p><code>EGL_BAD_CONTEXT</code> is generated if <code>context</code>
   * is not an EGL rendering context.
   *
   * <p><code>EGL_BAD_ATTRIBUTE</code> is generated if
   * <code>attribute</code> is not a valid context attribute.
   *
   * @param display Specifies the EGL display connection.
   * @param context Specifies the EGL rendering context to query.
   * @param attribute Specifies the EGL rendering context attribute to
   * be returned.
   * @param value Returns the requested value.
   * 
   * @exception IllegalArgumentException if <code>display</code> is
   * <code>null</code>.
   * @exception IllegalArgumentException if <code>context</code> is
   * <code>null</code>.
   * @exception IllegalArgumentException if <code>value</code> is
   * <code>null</code> or has length less than 1.
   *
   * @return <code>true</code> if the query succeeds.
   */
  boolean eglQueryContext(EGLDisplay display,
    			  EGLContext context,
    			  int attribute,
    			  int[] value);

  /**
   * Complete GL execution prior to subsequent native rendering calls.
   *
   * <p>GL rendering calls made prior to <code>eglWaitGL</code> are
   * guaranteed to be executed before native rendering calls made
   * after <code>eglWaitGL</code>. The same result can be achieved
   * using <code>glFinish</code>.
   *
   * <p><code>eglWaitGL</code> is ignored if there is no current EGL
   * rendering context.
   *
   * <h4>Errors</h4>
   *
   * <p><code>false</code> is returned if <code>eglWaitGL</code> fails,
   * <code>true</code> otherwise.
   *
   * <p><code>EGL_BAD_NATIVE_SURFACE</code> is generated if the surface
   * associated with the current context has a native window or
   * pixmap, and that window or pixmap is no longer valid.
   *
   * @return <code>true</code> if the operation succeeds.
   */
  boolean eglWaitGL();

  /**
   * Complete native execution prior to subsequent GL rendering calls.
   *
   * <p>Native rendering calls made prior to <code>eglWaitNative</code>
   * are guaranteed to be executed before GL rendering calls made
   * after <code>eglWaitNative</code>.
   *
   * <p><code>eglWaitNative</code> is ignored if there is no current EGL
   * rendering context.
   *
   * <h4>Notes</h4>
   *
   * <p>In a MIDP environment, OpenGL ES drawing to an <code>Image</code>,
   * <code>Canvas</code>, or <code>GameCanvas</code> must be preceded
   * by a call to
   * <code>eglWaitNative(<code>EGL10.EGL_CORE_NATIVE_ENGINE</code>,
   * graphics)</code> and followed by a call to
   * <code>eglWaitGL()</code>.  The <code>bindTarget</code> parameter
   * must be the instance of
   * <code>javax.microedition.lcdui.Graphics</code> obtained from the
   * <code>GameCanvas.getGraphics</code> method (if drawing to a
   * <code>GameCanvas</code>), from the <code>Image.getGraphics()</code>
   * method (if drawing to a mutable <code>Image</code>),
   * or the instance obtained as the
   * parameter to the <code>Canvas.paint</code> method (if drawing to
   * a <code>Canvas</code>).
   *
   * <p>The results of passing improper values for <code>engine</code>
   * and/or <code>bindTarget</code> are undefined.
   * 
   * <p> The results of MIDP drawing calls are undefined from the time
   * of the call to <code>eglWaitNative</code> until
   * <code>eglWaitGL</code> returns.
   * 
   * <h4>Errors</h4>
   *
   * <p><code>EGL_BAD_PARAMETER</code> is generated if
   * <code>engine</code> is not a recognized marking engine.
   *
   * <p><code>EGL_BAD_NATIVE_SURFACE</code> is generated if the surface
   * associated with the current context has a native window or
   * pixmap, and that window or pixmap is no longer valid.
   *
   * @param engine Specifies a particular marking engine to be waited
   * on. Must be <code>EGL_CORE_NATIVE_ENGINE</code>.
   * @param bindTarget the rendering target shared by the native
   * engine and the EGL drawing surface.  For MIDP, must be the
   * instance of <code>javax.microedition.lcdui.Graphics</code>
   * representing the targetted <code>Canvas</code>, <code>Image</code>, or
   * <code>GameCanvas</code>.
   *
   * @return <code>true</code> if the operation succeeds.
   */
  boolean eglWaitNative(int engine, Object bindTarget);

  /**
   * Post EGL surface color buffer to a native window.
   *
   * <p>If surface is a window surface, <code>eglSwapBuffers</code> posts
   * its color buffer to the associated native window.
   *
   * <p><code>eglSwapBuffers</code> performs an implicit
   * <code>glFlush</code> before it returns. Subsequent GL commands
   * may be issued immediately after calling
   * <code>eglSwapBuffers</code>, but are not executed until the
   * buffer exchange is completed.
   *
   * <p>If surface is a pixel buffer or a pixmap,
   * <code>eglSwapBuffers</code> has no effect, and no error is
   * generated.
   *
   * <h4>Notes</h4>
   *
   * <p>The color buffer of surface is left undefined after calling
   * <code>eglSwapBuffers</code>.
   *
   * <p>On the CLDC/MIDP plaform, calling <code>eglSwapBuffers</code>
   * is equivalent to calling <code>glFinish</code> when drawing to a
   * <code>GameCanvas</code>.  The
   * <code>GameCanvas.flushGraphics</code> method is used to copy the
   * contents of the back buffer to the screen.
   *
   * <h4>Errors</h4>
   *
   * <p><code>false</code> is returned if swapping of the surface
   * buffers fails, <code>true</code> otherwise.
   *
   * <p><code>EGL_BAD_DISPLAY</code> is generated if <code>display</code>
   * is not an EGL display connection.
   *
   * <p><code>EGL_NOT_INITIALIZED</code> is generated if
   * <code>display</code> has not been initialized.
   *
   * <p><code>EGL_BAD_SURFACE</code> is generated if <code>surface</code>
   * is not an EGL drawing surface.
   *
   * <p><code>EGL_CONTEXT_LOST</code> (1.1 only)
   *
   * <p>A power management event has occurred. The application must
   * destroy all contexts and reinitialise OpenGL ES state and objects
   * to continue rendering.
   *
   * @param display Specifies the EGL display connection.
   * @param surface Specifies the EGL drawing surface whose buffers
   * are to be swapped.
   *
   * @exception IllegalArgumentException if <code>display</code> is
   * <code>null</code>.
   * @exception IllegalArgumentException if <code>surface</code> is
   * <code>null</code>.
   *
   * @return <code>true</code> if the operation succeeds.
   */
  boolean eglSwapBuffers(EGLDisplay display, EGLSurface surface);

  /**
   * Copy EGL surface color buffer to a native pixmap.
   *
   * <p><code>eglCopyBuffers</code> copies the color buffer of
   * <code>surface</code> to <code>native_pixmap</code>.
   *
   * <p><code>eglCopyBuffers</code> performs an implicit
   * <code>glFlush</code> before it returns. Subsequent GL commands
   * may be issued immediately after calling
   * <code>eglCopyBuffers</code>, but are not executed until copying
   * of the color buffer is completed.
   *
   * <h4>Notes</h4>
   *
   * <p>The color buffer of surface is left unchanged after calling
   * <code>eglCopyBuffers</code>.
   *
   * <p>On JME CLDC/MIDP platforms, <code>native_pixmap</code> must be
   * an instance of <code>javax.microedition.lcdui.Image</code> that
   * is mutable, or an instance of
   * <code>javax.microedition.lcdui.Graphics</code> 
   * that was obtained directly from such
   * an image by means of a call to <code>createGraphics()</code> or
   * <code>getGraphics()</code>.
   *
   * <!--
   * <p>On JME Personal Basis Profile and Personal Profile platforms,
   * <code>native_pixmap</code> must be an instance of
   * <code>java.awt.image.BufferedImage</code>, or an instance of
   * <code>java.awt.Graphics</code> that was obtained directly from
   * such an image by means of a call to <code>createGraphics()</code>
   * or <code>getGraphics()</code>.
   * -->
   *
   * <h4>Errors</h4>
   *
   * <p><code>false</code> is returned if swapping of the surface
   * buffers fails, <code>true</code> otherwise.
   *
   * <p><code>EGL_BAD_DISPLAY</code> is generated if <code>display</code>
   * is not an EGL display connection.
   *
   * <p><code>EGL_NOT_INITIALIZED</code> is generated if
   * <code>display</code> has not been initialized.
   *
   * <p><code>EGL_BAD_SURFACE</code> is generated if <code>surface</code>
   * is not an EGL drawing surface.
   *
   * <p><code>EGL_BAD_NATIVE_PIXMAP</code> is generated if the
   * implementation does not support native pixmaps.
   *
   * <p><code>EGL_BAD_NATIVE_PIXMAP</code> may be generated if
   * <code>native_pixmap</code> is not a valid native pixmap.
   *
   * <p><code>EGL_BAD_MATCH</code> is generated if the format of
   * <code>native_pixmap</code> is not compatible with the color
   * buffer of surface.
   * 
   * <p>(1.1 only) <code>EGL_CONTEXT_LOST</code> is generated if a
   * power management event has occurred. The application must destroy
   * all contexts and reinitialize OpenGL ES state and objects to
   * continue rendering.
   *
   * @param display Specifies the EGL display connection.
   * @param surface Specifies the EGL surface whose color buffer is to
   * be copied.
   * @param native_pixmap Specifies the native pixmap as target of the
   * copy.
   *
   * @exception IllegalArgumentException if <code>display</code> is
   * <code>null</code>.
   * @exception IllegalArgumentException if <code>surface</code> is
   * <code>null</code>.
   * @exception IllegalArgumentException if <code>native_pixmap</code>
   * is <code>null</code> or is not of a suitable type for the
   * underlying platform (e.g., a mutable <code>Image</code> for CLDC/MIDP).
   *
   * @return <code>true</code> if the copy succeeds.
   */
  boolean eglCopyBuffers(EGLDisplay display,
    			 EGLSurface surface,
			 Object native_pixmap);
}

