refactoring: renamed com.sun.opengl -> com.jogamp.opengl.

97 files changed, 42746 insertions, 0 deletions

diff --git a/src/jogl/classes/com/jogamp/opengl/util/AWTAnimatorImpl.java b/src/jogl/classes/com/jogamp/opengl/util/AWTAnimatorImpl.java
new file mode 100644
index 000000000..d8e1cf080
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/AWTAnimatorImpl.java
@@ -0,0 +1,163 @@
+/*
+ * Copyright (c) 2008 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+package com.jogamp.opengl.util;
+
+import java.awt.Component;
+import java.awt.EventQueue;
+import java.awt.Rectangle;
+import java.util.*;
+import javax.swing.*;
+
+import javax.media.opengl.*;
+
+/** Abstraction to factor out AWT dependencies from the Animator's
+    implementation in a way that still allows the FPSAnimator to pick
+    up this behavior if desired. */
+
+class AWTAnimatorImpl extends AnimatorImpl {
+    // For efficient rendering of Swing components, in particular when
+    // they overlap one another
+    private List lightweights    = new ArrayList();
+    private Map  repaintManagers = new IdentityHashMap();
+    private Map  dirtyRegions    = new IdentityHashMap();
+
+    public void display(Animator animator,
+                        boolean ignoreExceptions,
+                        boolean printExceptions) {
+        Iterator iter = animator.drawableIterator();
+        while (iter.hasNext()) {
+            GLAutoDrawable drawable = (GLAutoDrawable) iter.next();
+            if (drawable instanceof JComponent) {
+                // Lightweight components need a more efficient drawing
+                // scheme than simply forcing repainting of each one in
+                // turn since drawing one can force another one to be
+                // drawn in turn
+                lightweights.add(drawable);
+            } else {
+                try {
+                    drawable.display();
+                } catch (RuntimeException e) {
+                    if (ignoreExceptions) {
+                        if (printExceptions) {
+                            e.printStackTrace();
+                        }
+                    } else {
+                        throw(e);
+                    }
+                }
+            }
+        }
+        if (lightweights.size() > 0) {
+            try {
+                SwingUtilities.invokeAndWait(drawWithRepaintManagerRunnable);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+            lightweights.clear();
+        }
+    }
+
+    // Uses RepaintManager APIs to implement more efficient redrawing of
+    // the Swing widgets we're animating
+    private Runnable drawWithRepaintManagerRunnable = new Runnable() {
+            public void run() {
+                for (Iterator iter = lightweights.iterator(); iter.hasNext(); ) {
+                    JComponent comp = (JComponent) iter.next();
+                    RepaintManager rm = RepaintManager.currentManager(comp);
+                    rm.markCompletelyDirty(comp);
+                    repaintManagers.put(rm, rm);
+
+                    // RepaintManagers don't currently optimize the case of
+                    // overlapping sibling components. If we have two
+                    // JInternalFrames in a JDesktopPane, the redraw of the
+                    // bottom one will cause the top one to be redrawn as
+                    // well. The top one will then be redrawn separately. In
+                    // order to optimize this case we need to compute the union
+                    // of all of the dirty regions on a particular JComponent if
+                    // optimized drawing isn't enabled for it.
+
+                    // Walk up the hierarchy trying to find a non-optimizable
+                    // ancestor
+                    Rectangle visible = comp.getVisibleRect();
+                    int x = visible.x;
+                    int y = visible.y;
+                    while (comp != null) {
+                        x += comp.getX();
+                        y += comp.getY();
+                        Component c = comp.getParent();
+                        if ((c == null) || (!(c instanceof JComponent))) {
+                            comp = null;
+                        } else {
+                            comp = (JComponent) c;
+                            if (!comp.isOptimizedDrawingEnabled()) {
+                                rm = RepaintManager.currentManager(comp);
+                                repaintManagers.put(rm, rm);
+                                // Need to dirty this region
+                                Rectangle dirty = (Rectangle) dirtyRegions.get(comp);
+                                if (dirty == null) {
+                                    dirty = new Rectangle(x, y, visible.width, visible.height);
+                                    dirtyRegions.put(comp, dirty);
+                                } else {
+                                    // Compute union with already dirty region
+                                    // Note we could compute multiple non-overlapping
+                                    // regions: might want to do that in the future
+                                    // (prob. need more complex algorithm -- dynamic
+                                    // programming?)
+                                    dirty.add(new Rectangle(x, y, visible.width, visible.height));
+                                }
+                            }
+                        }
+                    }
+                }
+
+                // Dirty any needed regions on non-optimizable components
+                for (Iterator iter = dirtyRegions.keySet().iterator(); iter.hasNext(); ) {
+                    JComponent comp = (JComponent) iter.next();
+                    Rectangle  rect = (Rectangle) dirtyRegions.get(comp);
+                    RepaintManager rm = RepaintManager.currentManager(comp);
+                    rm.addDirtyRegion(comp, rect.x, rect.y, rect.width, rect.height);
+                }
+
+                // Draw all dirty regions
+                for (Iterator iter = repaintManagers.keySet().iterator(); iter.hasNext(); ) {
+                    ((RepaintManager) iter.next()).paintDirtyRegions();
+                }
+                dirtyRegions.clear();
+                repaintManagers.clear();
+            }
+        };
+
+    public boolean skipWaitForStop(Thread thread) {
+        return ((Thread.currentThread() == thread) || EventQueue.isDispatchThread());
+    }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/Animator.java b/src/jogl/classes/com/jogamp/opengl/util/Animator.java
new file mode 100755
index 000000000..30be0bd90
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/Animator.java
@@ -0,0 +1,241 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util;
+
+import java.util.*;
+
+import javax.media.opengl.*;
+
+import com.jogamp.opengl.impl.Debug;
+
+/** <P> An Animator can be attached to one or more {@link
+    GLAutoDrawable}s to drive their display() methods in a loop. </P>
+
+    <P> The Animator class creates a background thread in which the
+    calls to <code>display()</code> are performed. After each drawable
+    has been redrawn, a brief pause is performed to avoid swamping the
+    CPU, unless {@link #setRunAsFastAsPossible} has been called.  </P>
+*/
+
+public class Animator {
+    protected static final boolean DEBUG = Debug.debug("Animator");
+
+    private volatile ArrayList/*<GLAutoDrawable>*/ drawables = new ArrayList();
+    private AnimatorImpl impl;
+    private Runnable runnable;
+    private boolean runAsFastAsPossible;
+    protected ThreadGroup threadGroup;
+    protected Thread thread;
+    protected volatile boolean shouldStop;
+    protected boolean ignoreExceptions;
+    protected boolean printExceptions;
+
+    /** Creates a new, empty Animator. */
+    public Animator(ThreadGroup tg) {
+
+        if(GLProfile.isAWTJOGLAvailable()) {
+            try {
+                impl = (AnimatorImpl) Class.forName("com.jogamp.opengl.util.awt.AWTAnimatorImpl").newInstance();
+            } catch (Exception e) { }
+        }
+        if(null==impl) {
+            impl = new AnimatorImpl();
+        }
+        threadGroup = tg;
+
+        if(DEBUG) {
+            System.out.println("Animator created, ThreadGroup: "+threadGroup);
+        }
+    }
+
+    public Animator() {
+        this((ThreadGroup)null);
+    }
+
+    /** Creates a new Animator for a particular drawable. */
+    public Animator(GLAutoDrawable drawable) {
+        this((ThreadGroup)null);
+        add(drawable);
+    }
+
+    /** Creates a new Animator for a particular drawable. */
+    public Animator(ThreadGroup tg, GLAutoDrawable drawable) {
+        this(tg);
+        add(drawable);
+    }
+
+    /** Adds a drawable to the list managed by this Animator. */
+    public synchronized void add(GLAutoDrawable drawable) {
+        ArrayList newList = (ArrayList) drawables.clone();
+        newList.add(drawable);
+        drawables = newList;
+        notifyAll();
+    }
+
+    /** Removes a drawable from the list managed by this Animator. */
+    public synchronized void remove(GLAutoDrawable drawable) {
+        ArrayList newList = (ArrayList) drawables.clone();
+        newList.remove(drawable);
+        drawables = newList;
+    }
+
+    /** Returns an iterator over the drawables managed by this
+        Animator. */
+    public Iterator/*<GLAutoDrawable>*/ drawableIterator() {
+        return drawables.iterator();
+    }
+
+    /** Sets a flag causing this Animator to ignore exceptions produced
+        while redrawing the drawables. By default this flag is set to
+        false, causing any exception thrown to halt the Animator. */
+    public void setIgnoreExceptions(boolean ignoreExceptions) {
+        this.ignoreExceptions = ignoreExceptions;
+    }
+
+    /** Sets a flag indicating that when exceptions are being ignored by
+        this Animator (see {@link #setIgnoreExceptions}), to print the
+        exceptions' stack traces for diagnostic information. Defaults to
+        false. */
+    public void setPrintExceptions(boolean printExceptions) {
+        this.printExceptions = printExceptions;
+    }
+
+    /** Sets a flag in this Animator indicating that it is to run as
+        fast as possible. By default there is a brief pause in the
+        animation loop which prevents the CPU from getting swamped.
+        This method may not have an effect on subclasses. */
+    public final void setRunAsFastAsPossible(boolean runFast) {
+        runAsFastAsPossible = runFast;
+    }
+
+    /** Called every frame to cause redrawing of all of the
+        GLAutoDrawables this Animator manages. Subclasses should call
+        this to get the most optimized painting behavior for the set of
+        components this Animator manages, in particular when multiple
+        lightweight widgets are continually being redrawn. */
+    protected void display() {
+        impl.display(this, ignoreExceptions, printExceptions);
+    }
+
+    class MainLoop implements Runnable {
+        public void run() {
+            try {
+                if(DEBUG) {
+                    System.out.println("Animator started: "+Thread.currentThread());
+                }
+                while (!shouldStop) {
+                    // Don't consume CPU unless there is work to be done
+                    if (drawables.size() == 0) {
+                        synchronized (Animator.this) {
+                            while (drawables.size() == 0 && !shouldStop) {
+                                try {
+                                    Animator.this.wait();
+                                } catch (InterruptedException e) {
+                                }
+                            }
+                        }
+                    }
+                    display();
+                    if (!runAsFastAsPossible) {
+                        // Avoid swamping the CPU
+                        Thread.yield();
+                    }
+                }
+                if(DEBUG) {
+                    System.out.println("Animator stopped: "+Thread.currentThread());
+                }
+            } finally {
+                shouldStop = false;
+                synchronized (Animator.this) {
+                    thread = null;
+                    Animator.this.notify();
+                }
+            }
+        }
+    }
+
+    /** Starts this animator. */
+    public synchronized void start() {
+        if (thread != null) {
+            throw new GLException("Already started");
+        }
+        if (runnable == null) {
+            runnable = new MainLoop();
+        }
+        if(null==threadGroup) {
+            thread = new Thread(runnable);
+        } else {
+            thread = new Thread(threadGroup, runnable);
+        }
+        thread.start();
+    }
+
+    /** Indicates whether this animator is currently running. This
+        should only be used as a heuristic to applications because in
+        some circumstances the Animator may be in the process of
+        shutting down and this method will still return true. */
+    public synchronized boolean isAnimating() {
+        return (thread != null);
+    }
+
+    /** Stops this animator. In most situations this method blocks until
+        completion, except when called from the animation thread itself
+        or in some cases from an implementation-internal thread like the
+        AWT event queue thread. */
+    public synchronized void stop() {
+        shouldStop = true;
+        notifyAll();
+
+        // It's hard to tell whether the thread which calls stop() has
+        // dependencies on the Animator's internal thread. Currently we
+        // use a couple of heuristics to determine whether we should do
+        // the blocking wait().
+        if (impl.skipWaitForStop(thread)) {
+            return;
+        }
+
+        while (shouldStop && thread != null) {
+            try {
+                wait();
+            } catch (InterruptedException ie) {
+            }
+        }
+    }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/AnimatorImpl.java b/src/jogl/classes/com/jogamp/opengl/util/AnimatorImpl.java
new file mode 100644
index 000000000..50b91b729
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/AnimatorImpl.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2008 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+package com.jogamp.opengl.util;
+
+import java.util.*;
+import javax.media.opengl.*;
+
+/** Abstraction to factor out AWT dependencies from the Animator's
+    implementation in a way that still allows the FPSAnimator to pick
+    up this behavior if desired. */
+
+class AnimatorImpl {
+    public void display(Animator animator,
+                        boolean ignoreExceptions,
+                        boolean printExceptions) {
+        Iterator iter = animator.drawableIterator();
+        while (iter.hasNext()) {
+            GLAutoDrawable drawable = (GLAutoDrawable) iter.next();
+            try {
+                drawable.display();
+            } catch (RuntimeException e) {
+                if (ignoreExceptions) {
+                    if (printExceptions) {
+                        e.printStackTrace();
+                    }
+                } else {
+                    throw(e);
+                }
+            }
+        }
+    }
+
+    public boolean skipWaitForStop(Thread thread) {
+        return (Thread.currentThread() == thread);
+    }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/BufferUtil.java.javame_cdc_fp b/src/jogl/classes/com/jogamp/opengl/util/BufferUtil.java.javame_cdc_fp
new file mode 100755
index 000000000..2f82487f8
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/BufferUtil.java.javame_cdc_fp
@@ -0,0 +1,449 @@
+/*
+ * Copyright (c) 2008 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util;
+
+import javax.media.opengl.GL;
+import javax.media.opengl.GL2;
+import javax.media.opengl.GL2ES2;
+import javax.media.opengl.GLException;
+import javax.media.opengl.GLProfile;
+
+import java.nio.*;
+import java.util.*;
+
+import java.lang.reflect.*;
+
+/** Utility routines for dealing with direct buffers. */
+
+public class BufferUtil {
+  public static final int SIZEOF_BYTE = 1;
+  public static final int SIZEOF_SHORT = 2;
+  public static final int SIZEOF_INT = 4;
+  public static final int SIZEOF_FLOAT = 4;
+  public static final int SIZEOF_LONG = -1;    // not supported
+  public static final int SIZEOF_DOUBLE = -1;  // not supported
+
+  public static final int sizeOfGLType(int glType) {
+        switch (glType) {
+            case GL.GL_UNSIGNED_BYTE:
+                return SIZEOF_BYTE;
+            case GL.GL_BYTE:
+                return SIZEOF_BYTE;
+            case GL.GL_UNSIGNED_SHORT:
+                return SIZEOF_SHORT;
+            case GL.GL_SHORT:
+                return SIZEOF_SHORT;
+            case GL.GL_FLOAT:
+                return SIZEOF_FLOAT;
+            case GL.GL_FIXED:
+                return SIZEOF_INT;
+            case GL2ES2.GL_INT:
+                return SIZEOF_INT;
+            case GL2ES2.GL_UNSIGNED_INT:
+                return SIZEOF_INT;
+            case GL2.GL_DOUBLE:
+                return SIZEOF_DOUBLE;
+        }
+        return -1;
+  }
+
+  public static final int sizeOfBufferElem(Buffer buffer) {
+        if (buffer == null) {
+            return 0;
+        }
+        if (buffer instanceof ByteBuffer) {
+            return BufferUtil.SIZEOF_BYTE;
+        } else if (buffer instanceof IntBuffer) {
+            return BufferUtil.SIZEOF_INT;
+        } else if (buffer instanceof ShortBuffer) {
+            return BufferUtil.SIZEOF_SHORT;
+        } else if (buffer instanceof FloatBuffer) {
+            return BufferUtil.SIZEOF_FLOAT;
+        }
+        throw new RuntimeException("Unexpected buffer type " +
+                                   buffer.getClass().getName());
+  }
+
+  private BufferUtil() {}
+
+  //----------------------------------------------------------------------
+  // Allocation routines
+  //
+
+  public static final Buffer newGLBuffer(int glType, int numElements) {
+        switch (glType) {
+            case GL.GL_UNSIGNED_BYTE:
+            case GL.GL_BYTE:
+                return newByteBuffer(numElements);
+            case GL.GL_UNSIGNED_SHORT:
+            case GL.GL_SHORT:
+                return newShortBuffer(numElements);
+            case GL.GL_FLOAT:
+                return newFloatBuffer(numElements);
+            case GL.GL_FIXED:
+            case GL2ES2.GL_INT:
+            case GL2ES2.GL_UNSIGNED_INT:
+                return newIntBuffer(numElements);
+        }
+        return null;
+  }
+
+  public static final Buffer sliceGLBuffer(ByteBuffer parent, int bytePos, int byteLen, int glType) {
+        if(parent==null || byteLen==0) return null;
+        parent.position(bytePos);
+        parent.limit(bytePos + byteLen);
+
+        switch (glType) {
+            case GL.GL_UNSIGNED_BYTE:
+            case GL.GL_BYTE:
+                return parent.slice();
+            case GL.GL_UNSIGNED_SHORT:
+            case GL.GL_SHORT:
+                return parent.asShortBuffer();
+            case GL.GL_FLOAT:
+                return parent.asFloatBuffer();
+            case GL.GL_FIXED:
+            case GL2ES2.GL_INT:
+            case GL2ES2.GL_UNSIGNED_INT:
+                return parent.asIntBuffer();
+        }
+        return null;
+  }
+
+  /** Allocates a new direct ByteBuffer with the specified number of
+      elements. The returned buffer will have its byte order set to
+      the host platform's native byte order. */
+  public static ByteBuffer newByteBuffer(int numElements) {
+    ByteBuffer bb = ByteBuffer.allocateDirect(numElements);
+    nativeOrder(bb);
+    return bb;
+  }
+    
+  public static ByteBuffer newByteBuffer(byte[] values, int offset, int len) {
+    ByteBuffer bb = newByteBuffer(len);
+    bb.put(values, offset, len);
+    bb.rewind();
+    return bb;
+  }
+    
+  public static ByteBuffer newByteBuffer(byte[] values, int offset) {
+    return newByteBuffer(values, offset, values.length-offset);
+  }
+    
+  public static ByteBuffer newByteBuffer(byte[] values) {
+    return newByteBuffer(values, 0);
+  }
+    
+  /** Allocates a new direct FloatBuffer with the specified number of
+      elements. The returned buffer will have its byte order set to
+      the host platform's native byte order. */
+  public static FloatBuffer newFloatBuffer(int numElements) {
+    ByteBuffer bb = newByteBuffer(numElements * SIZEOF_FLOAT);
+    return bb.asFloatBuffer();
+  }
+    
+  public static FloatBuffer newFloatBuffer(float[] values, int offset, int len) {
+    FloatBuffer bb = newFloatBuffer(len);
+    bb.put(values, offset, len);
+    bb.rewind();
+    return bb;
+  }
+    
+  public static FloatBuffer newFloatBuffer(float[] values, int offset) {
+    return newFloatBuffer(values, 0, values.length-offset);
+  }
+
+  public static FloatBuffer newFloatBuffer(float[] values) {
+    return newFloatBuffer(values, 0);
+  }
+    
+  /** Allocates a new direct IntBuffer with the specified number of
+      elements. The returned buffer will have its byte order set to
+      the host platform's native byte order. */
+  public static IntBuffer newIntBuffer(int numElements) {
+    ByteBuffer bb = newByteBuffer(numElements * SIZEOF_INT);
+    return bb.asIntBuffer();
+  }
+    
+  public static IntBuffer newIntBuffer(int[] values, int offset, int len) {
+    IntBuffer bb = newIntBuffer(len);
+    bb.put(values, offset, len);
+    bb.rewind();
+    return bb;
+  }
+    
+  public static IntBuffer newIntBuffer(int[] values, int offset) {
+    return newIntBuffer(values, 0, values.length-offset);
+  }
+
+  public static IntBuffer newIntBuffer(int[] values) {
+    return newIntBuffer(values, 0);
+  }
+    
+    
+  /** Allocates a new direct ShortBuffer with the specified number of
+      elements. The returned buffer will have its byte order set to
+      the host platform's native byte order. */
+  public static ShortBuffer newShortBuffer(int numElements) {
+    ByteBuffer bb = newByteBuffer(numElements * SIZEOF_SHORT);
+    return bb.asShortBuffer();
+  }
+
+  public static ShortBuffer newShortBuffer(short[] values, int offset, int len) {
+    ShortBuffer bb = newShortBuffer(len);
+    bb.put(values, offset, len);
+    bb.rewind();
+    return bb;
+  }
+    
+  public static ShortBuffer newShortBuffer(short[] values, int offset) {
+    return newShortBuffer(values, 0, values.length-offset);
+  }
+
+  public static ShortBuffer newShortBuffer(short[] values) {
+    return newShortBuffer(values, 0);
+  }
+    
+    
+  //----------------------------------------------------------------------
+  // Copy routines (type-to-type)
+  //
+  
+  /** Copies the <i>remaining</i> elements (as defined by
+      <code>limit() - position()</code>) in the passed ByteBuffer into
+      a newly-allocated direct ByteBuffer. The returned buffer will
+      have its byte order set to the host platform's native byte
+      order. The position of the newly-allocated buffer will be zero,
+      and the position of the passed buffer is unchanged (though its
+      mark is changed). */
+  public static ByteBuffer copyByteBuffer(ByteBuffer orig) {
+    ByteBuffer dest = newByteBuffer(orig.remaining());
+    dest.put(orig);
+    dest.rewind();
+    return dest;
+  }
+  
+  /** Copies the <i>remaining</i> elements (as defined by
+      <code>limit() - position()</code>) in the passed FloatBuffer
+      into a newly-allocated direct FloatBuffer. The returned buffer
+      will have its byte order set to the host platform's native byte
+      order. The position of the newly-allocated buffer will be zero,
+      and the position of the passed buffer is unchanged (though its
+      mark is changed). */
+  public static FloatBuffer copyFloatBuffer(FloatBuffer orig) {
+    return copyFloatBufferAsByteBuffer(orig).asFloatBuffer();
+  }
+  
+  /** Copies the <i>remaining</i> elements (as defined by
+      <code>limit() - position()</code>) in the passed IntBuffer
+      into a newly-allocated direct IntBuffer. The returned buffer
+      will have its byte order set to the host platform's native byte
+      order. The position of the newly-allocated buffer will be zero,
+      and the position of the passed buffer is unchanged (though its
+      mark is changed). */
+  public static IntBuffer copyIntBuffer(IntBuffer orig) {
+    return copyIntBufferAsByteBuffer(orig).asIntBuffer();
+  }
+  
+  /** Copies the <i>remaining</i> elements (as defined by
+      <code>limit() - position()</code>) in the passed ShortBuffer
+      into a newly-allocated direct ShortBuffer. The returned buffer
+      will have its byte order set to the host platform's native byte
+      order. The position of the newly-allocated buffer will be zero,
+      and the position of the passed buffer is unchanged (though its
+      mark is changed). */
+  public static ShortBuffer copyShortBuffer(ShortBuffer orig) {
+    return copyShortBufferAsByteBuffer(orig).asShortBuffer();
+  }
+  
+  //----------------------------------------------------------------------
+  // Copy routines (type-to-ByteBuffer)
+  //
+  
+  /** Copies the <i>remaining</i> elements (as defined by
+      <code>limit() - position()</code>) in the passed FloatBuffer
+      into a newly-allocated direct ByteBuffer. The returned buffer
+      will have its byte order set to the host platform's native byte
+      order. The position of the newly-allocated buffer will be zero,
+      and the position of the passed buffer is unchanged (though its
+      mark is changed). */
+  public static ByteBuffer copyFloatBufferAsByteBuffer(FloatBuffer orig) {
+    ByteBuffer dest = newByteBuffer(orig.remaining() * SIZEOF_FLOAT);
+    dest.asFloatBuffer().put(orig);
+    dest.rewind();
+    return dest;
+  }
+  
+  /** Copies the <i>remaining</i> elements (as defined by
+      <code>limit() - position()</code>) in the passed IntBuffer into
+      a newly-allocated direct ByteBuffer. The returned buffer will
+      have its byte order set to the host platform's native byte
+      order. The position of the newly-allocated buffer will be zero,
+      and the position of the passed buffer is unchanged (though its
+      mark is changed). */
+  public static ByteBuffer copyIntBufferAsByteBuffer(IntBuffer orig) {
+    ByteBuffer dest = newByteBuffer(orig.remaining() * SIZEOF_INT);
+    dest.asIntBuffer().put(orig);
+    dest.rewind();
+    return dest;
+  }
+  
+  /** Copies the <i>remaining</i> elements (as defined by
+      <code>limit() - position()</code>) in the passed ShortBuffer
+      into a newly-allocated direct ByteBuffer. The returned buffer
+      will have its byte order set to the host platform's native byte
+      order. The position of the newly-allocated buffer will be zero,
+      and the position of the passed buffer is unchanged (though its
+      mark is changed). */
+  public static ByteBuffer copyShortBufferAsByteBuffer(ShortBuffer orig) {
+    ByteBuffer dest = newByteBuffer(orig.remaining() * SIZEOF_SHORT);
+    dest.asShortBuffer().put(orig);
+    dest.rewind();
+    return dest;
+  }
+
+  //----------------------------------------------------------------------
+  // Conversion routines 
+  //
+
+  public final static float[] getFloatArray(double[] source) {
+      int i=source.length;
+      float[] dest = new float[i--];
+      while(i>=0) { dest[i]=(float)source[i]; i--; }
+      return dest;
+  }
+
+  public static ByteBuffer nativeOrder(ByteBuffer buf) {
+    if (!isCDCFP) {
+      try {
+        if (byteOrderClass == null) {
+          byteOrderClass = Class.forName("java.nio.ByteOrder");
+          orderMethod = ByteBuffer.class.getMethod("order", new Class[] { byteOrderClass });
+          Method nativeOrderMethod = byteOrderClass.getMethod("nativeOrder", null);
+          nativeOrderObject = nativeOrderMethod.invoke(null, null);
+        }
+      } catch (Throwable t) {
+        // Must be running on CDC / FP
+        isCDCFP = true;
+      }
+
+      if (!isCDCFP) {
+        try {
+          orderMethod.invoke(buf, new Object[] { nativeOrderObject });
+        } catch (Throwable t) {
+        }
+      }
+    }
+    return buf;
+  }
+
+  //----------------------------------------------------------------------
+  // Convenient GL put methods with generic target Buffer
+  //
+  public static void put(Buffer dest, Buffer v) {
+    if((dest instanceof ByteBuffer) && (v instanceof ByteBuffer)) {
+        ((ByteBuffer)dest).put((ByteBuffer)v);
+    } else if((dest instanceof ShortBuffer) && (v instanceof ShortBuffer)) {
+        ((ShortBuffer)dest).put((ShortBuffer)v);
+    } else if((dest instanceof IntBuffer) && (v instanceof IntBuffer)) {
+        ((IntBuffer)dest).put((IntBuffer)v);
+    } else if((dest instanceof FloatBuffer) && (v instanceof FloatBuffer)) {
+        ((FloatBuffer)dest).put((FloatBuffer)v);
+    } else {
+        throw new GLException("Incompatible Buffer classes: dest = "+dest.getClass().getName() + ", src = " + v.getClass().getName());
+    }
+  }
+
+  public static void putb(Buffer dest, byte v) {
+    if(dest instanceof ByteBuffer) {
+        ((ByteBuffer)dest).put(v);
+    } else if(dest instanceof ShortBuffer) {
+        ((ShortBuffer)dest).put((short)v);
+    } else if(dest instanceof IntBuffer) {
+        ((IntBuffer)dest).put((int)v);
+    } else {
+        throw new GLException("Byte doesn't match Buffer Class: "+dest);
+    }
+  }
+
+  public static void puts(Buffer dest, short v) {
+    if(dest instanceof ShortBuffer) {
+        ((ShortBuffer)dest).put(v);
+    } else if(dest instanceof IntBuffer) {
+        ((IntBuffer)dest).put((int)v);
+    } else {
+        throw new GLException("Short doesn't match Buffer Class: "+dest);
+    }
+  }
+
+  public static void puti(Buffer dest, int v) {
+    if(dest instanceof IntBuffer) {
+        ((IntBuffer)dest).put(v);
+    } else {
+        throw new GLException("Integer doesn't match Buffer Class: "+dest);
+    }
+  }
+
+  public static void putx(Buffer dest, int v) {
+    puti(dest, v);
+  }
+
+  public static void putf(Buffer dest, float v) {
+    if(dest instanceof FloatBuffer) {
+        ((FloatBuffer)dest).put(v);
+    } else if(dest instanceof IntBuffer) {
+        ((IntBuffer)dest).put(FixedPoint.toFixed(v));
+    } else {
+        throw new GLException("Float doesn't match Buffer Class: "+dest);
+    }
+  }
+
+  //----------------------------------------------------------------------
+  // Internals only below this point
+  //
+
+  // NOTE that this work must be done reflectively at the present time
+  // because this code must compile and run correctly on both CDC/FP and J2SE
+  private static boolean isCDCFP;
+  private static Class byteOrderClass;
+  private static Object nativeOrderObject;
+  private static Method orderMethod;
+
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/BufferUtil.java.javase b/src/jogl/classes/com/jogamp/opengl/util/BufferUtil.java.javase
new file mode 100755
index 000000000..fde1e8681
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/BufferUtil.java.javase
@@ -0,0 +1,499 @@
+/*
+ * Copyright (c) 2008 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util;
+
+import javax.media.opengl.GL;
+import javax.media.opengl.GL2;
+import javax.media.opengl.GL2ES2;
+import javax.media.opengl.GLException;
+import javax.media.opengl.GLProfile;
+
+import java.nio.*;
+import java.util.*;
+
+import java.lang.reflect.*;
+
+/** Utility routines for dealing with direct buffers. */
+
+public class BufferUtil {
+  public static final int SIZEOF_BYTE = 1;
+  public static final int SIZEOF_SHORT = 2;
+  public static final int SIZEOF_INT = 4;
+  public static final int SIZEOF_FLOAT = 4;
+  public static final int SIZEOF_LONG = 8;
+  public static final int SIZEOF_DOUBLE = 8;
+
+  public static final int sizeOfGLType(int glType) {
+        switch (glType) {
+            case GL.GL_UNSIGNED_BYTE:
+                return SIZEOF_BYTE;
+            case GL.GL_BYTE:
+                return SIZEOF_BYTE;
+            case GL.GL_UNSIGNED_SHORT:
+                return SIZEOF_SHORT;
+            case GL.GL_SHORT:
+                return SIZEOF_SHORT;
+            case GL.GL_FLOAT:
+                return SIZEOF_FLOAT;
+            case GL.GL_FIXED:
+                return SIZEOF_INT;
+            case GL2ES2.GL_INT:
+                return SIZEOF_INT;
+            case GL2ES2.GL_UNSIGNED_INT:
+                return SIZEOF_INT;
+            case GL2.GL_DOUBLE:
+                return SIZEOF_DOUBLE;
+        }
+        return -1;
+  }
+
+  public static final int sizeOfBufferElem(Buffer buffer) {
+        if (buffer == null) {
+            return 0;
+        }
+        if (buffer instanceof ByteBuffer) {
+            return BufferUtil.SIZEOF_BYTE;
+        } else if (buffer instanceof IntBuffer) {
+            return BufferUtil.SIZEOF_INT;
+        } else if (buffer instanceof ShortBuffer) {
+            return BufferUtil.SIZEOF_SHORT;
+        } else if (buffer instanceof FloatBuffer) {
+            return BufferUtil.SIZEOF_FLOAT;
+        } else if (buffer instanceof DoubleBuffer) {
+            return BufferUtil.SIZEOF_DOUBLE;
+        }
+        throw new RuntimeException("Unexpected buffer type " +
+                                   buffer.getClass().getName());
+  }
+
+  private BufferUtil() {}
+
+  //----------------------------------------------------------------------
+  // Allocation routines
+  //
+
+  public static final Buffer newGLBuffer(int glType, int numElements) {
+        switch (glType) {
+            case GL.GL_UNSIGNED_BYTE:
+            case GL.GL_BYTE:
+                return newByteBuffer(numElements);
+            case GL.GL_UNSIGNED_SHORT:
+            case GL.GL_SHORT:
+                return newShortBuffer(numElements);
+            case GL.GL_FLOAT:
+                return newFloatBuffer(numElements);
+            case GL.GL_FIXED:
+            case GL2ES2.GL_INT:
+            case GL2ES2.GL_UNSIGNED_INT:
+                return newIntBuffer(numElements);
+            case GL2.GL_DOUBLE:
+                return newDoubleBuffer(numElements);
+        }
+        return null;
+  }
+
+  public static final Buffer sliceGLBuffer(ByteBuffer parent, int bytePos, int byteLen, int glType) {
+        if(parent==null || byteLen==0) return null;
+        parent.position(bytePos);
+        parent.limit(bytePos + byteLen);
+
+        switch (glType) {
+            case GL.GL_UNSIGNED_BYTE:
+            case GL.GL_BYTE:
+                return parent.slice();
+            case GL.GL_UNSIGNED_SHORT:
+            case GL.GL_SHORT:
+                return parent.asShortBuffer();
+            case GL.GL_FLOAT:
+                return parent.asFloatBuffer();
+            case GL.GL_FIXED:
+            case GL2ES2.GL_INT:
+            case GL2ES2.GL_UNSIGNED_INT:
+                return parent.asIntBuffer();
+            case GL2.GL_DOUBLE:
+                return parent.asDoubleBuffer();
+        }
+        return null;
+  }
+
+  /** Allocates a new direct ByteBuffer with the specified number of
+      elements. The returned buffer will have its byte order set to
+      the host platform's native byte order. */
+  public static ByteBuffer newByteBuffer(int numElements) {
+    ByteBuffer bb = ByteBuffer.allocateDirect(numElements);
+    nativeOrder(bb);
+    return bb;
+  }
+    
+  public static ByteBuffer newByteBuffer(byte[] values, int offset, int len) {
+    ByteBuffer bb = newByteBuffer(len);
+    bb.put(values, offset, len);
+    bb.rewind();
+    return bb;
+  }
+    
+  public static ByteBuffer newByteBuffer(byte[] values, int offset) {
+    return newByteBuffer(values, offset, values.length-offset);
+  }
+    
+  public static ByteBuffer newByteBuffer(byte[] values) {
+    return newByteBuffer(values, 0);
+  }
+    
+    
+  /** Allocates a new direct DoubleBuffer with the specified number of
+      elements. The returned buffer will have its byte order set to
+      the host platform's native byte order. */
+  public static DoubleBuffer newDoubleBuffer(int numElements) {
+    ByteBuffer bb = newByteBuffer(numElements * SIZEOF_DOUBLE);
+    return bb.asDoubleBuffer();
+  }
+
+  public static DoubleBuffer newDoubleBuffer(double[] values, int offset) {
+    int len = values.length-offset;
+    DoubleBuffer bb = newDoubleBuffer(len);
+    bb.put(values, offset, len);
+    bb.rewind();
+    return bb;
+  }
+    
+  public static DoubleBuffer newDoubleBuffer(double[] values) {
+    return newDoubleBuffer(values, 0);
+  }
+    
+
+  /** Allocates a new direct FloatBuffer with the specified number of
+      elements. The returned buffer will have its byte order set to
+      the host platform's native byte order. */
+  public static FloatBuffer newFloatBuffer(int numElements) {
+    ByteBuffer bb = newByteBuffer(numElements * SIZEOF_FLOAT);
+    return bb.asFloatBuffer();
+  }
+    
+  public static FloatBuffer newFloatBuffer(float[] values, int offset, int len) {
+    FloatBuffer bb = newFloatBuffer(len);
+    bb.put(values, offset, len);
+    bb.rewind();
+    return bb;
+  }
+    
+  public static FloatBuffer newFloatBuffer(float[] values, int offset) {
+    return newFloatBuffer(values, 0, values.length-offset);
+  }
+
+  public static FloatBuffer newFloatBuffer(float[] values) {
+    return newFloatBuffer(values, 0);
+  }
+    
+    
+  /** Allocates a new direct IntBuffer with the specified number of
+      elements. The returned buffer will have its byte order set to
+      the host platform's native byte order. */
+  public static IntBuffer newIntBuffer(int numElements) {
+    ByteBuffer bb = newByteBuffer(numElements * SIZEOF_INT);
+    return bb.asIntBuffer();
+  }
+    
+  public static IntBuffer newIntBuffer(int[] values, int offset, int len) {
+    IntBuffer bb = newIntBuffer(len);
+    bb.put(values, offset, len);
+    bb.rewind();
+    return bb;
+  }
+    
+  public static IntBuffer newIntBuffer(int[] values, int offset) {
+    return newIntBuffer(values, 0, values.length-offset);
+  }
+
+  public static IntBuffer newIntBuffer(int[] values) {
+    return newIntBuffer(values, 0);
+  }
+    
+  /** Allocates a new direct LongBuffer with the specified number of
+      elements. The returned buffer will have its byte order set to
+      the host platform's native byte order. */
+  public static LongBuffer newLongBuffer(int numElements) {
+    ByteBuffer bb = newByteBuffer(numElements * SIZEOF_LONG);
+    return bb.asLongBuffer();
+  }
+
+  /** Allocates a new direct ShortBuffer with the specified number of
+      elements. The returned buffer will have its byte order set to
+      the host platform's native byte order. */
+  public static ShortBuffer newShortBuffer(int numElements) {
+    ByteBuffer bb = newByteBuffer(numElements * SIZEOF_SHORT);
+    return bb.asShortBuffer();
+  }
+
+  public static ShortBuffer newShortBuffer(short[] values, int offset, int len) {
+    ShortBuffer bb = newShortBuffer(len);
+    bb.put(values, offset, len);
+    bb.rewind();
+    return bb;
+  }
+    
+  public static ShortBuffer newShortBuffer(short[] values, int offset) {
+    return newShortBuffer(values, 0, values.length-offset);
+  }
+
+  public static ShortBuffer newShortBuffer(short[] values) {
+    return newShortBuffer(values, 0);
+  }
+    
+  //----------------------------------------------------------------------
+  // Copy routines (type-to-type)
+  //
+  
+  /** Copies the <i>remaining</i> elements (as defined by
+      <code>limit() - position()</code>) in the passed ByteBuffer into
+      a newly-allocated direct ByteBuffer. The returned buffer will
+      have its byte order set to the host platform's native byte
+      order. The position of the newly-allocated buffer will be zero,
+      and the position of the passed buffer is unchanged (though its
+      mark is changed). */
+  public static ByteBuffer copyByteBuffer(ByteBuffer orig) {
+    ByteBuffer dest = newByteBuffer(orig.remaining());
+    dest.put(orig);
+    dest.rewind();
+    return dest;
+  }
+  
+  /** Copies the <i>remaining</i> elements (as defined by
+      <code>limit() - position()</code>) in the passed FloatBuffer
+      into a newly-allocated direct FloatBuffer. The returned buffer
+      will have its byte order set to the host platform's native byte
+      order. The position of the newly-allocated buffer will be zero,
+      and the position of the passed buffer is unchanged (though its
+      mark is changed). */
+  public static FloatBuffer copyFloatBuffer(FloatBuffer orig) {
+    return copyFloatBufferAsByteBuffer(orig).asFloatBuffer();
+  }
+  
+  /** Copies the <i>remaining</i> elements (as defined by
+      <code>limit() - position()</code>) in the passed IntBuffer
+      into a newly-allocated direct IntBuffer. The returned buffer
+      will have its byte order set to the host platform's native byte
+      order. The position of the newly-allocated buffer will be zero,
+      and the position of the passed buffer is unchanged (though its
+      mark is changed). */
+  public static IntBuffer copyIntBuffer(IntBuffer orig) {
+    return copyIntBufferAsByteBuffer(orig).asIntBuffer();
+  }
+  
+  /** Copies the <i>remaining</i> elements (as defined by
+      <code>limit() - position()</code>) in the passed ShortBuffer
+      into a newly-allocated direct ShortBuffer. The returned buffer
+      will have its byte order set to the host platform's native byte
+      order. The position of the newly-allocated buffer will be zero,
+      and the position of the passed buffer is unchanged (though its
+      mark is changed). */
+  public static ShortBuffer copyShortBuffer(ShortBuffer orig) {
+    return copyShortBufferAsByteBuffer(orig).asShortBuffer();
+  }
+  
+  //----------------------------------------------------------------------
+  // Copy routines (type-to-ByteBuffer)
+  //
+  
+  /** Copies the <i>remaining</i> elements (as defined by
+      <code>limit() - position()</code>) in the passed FloatBuffer
+      into a newly-allocated direct ByteBuffer. The returned buffer
+      will have its byte order set to the host platform's native byte
+      order. The position of the newly-allocated buffer will be zero,
+      and the position of the passed buffer is unchanged (though its
+      mark is changed). */
+  public static ByteBuffer copyFloatBufferAsByteBuffer(FloatBuffer orig) {
+    ByteBuffer dest = newByteBuffer(orig.remaining() * SIZEOF_FLOAT);
+    dest.asFloatBuffer().put(orig);
+    dest.rewind();
+    return dest;
+  }
+  
+  /** Copies the <i>remaining</i> elements (as defined by
+      <code>limit() - position()</code>) in the passed IntBuffer into
+      a newly-allocated direct ByteBuffer. The returned buffer will
+      have its byte order set to the host platform's native byte
+      order. The position of the newly-allocated buffer will be zero,
+      and the position of the passed buffer is unchanged (though its
+      mark is changed). */
+  public static ByteBuffer copyIntBufferAsByteBuffer(IntBuffer orig) {
+    ByteBuffer dest = newByteBuffer(orig.remaining() * SIZEOF_INT);
+    dest.asIntBuffer().put(orig);
+    dest.rewind();
+    return dest;
+  }
+  
+  /** Copies the <i>remaining</i> elements (as defined by
+      <code>limit() - position()</code>) in the passed ShortBuffer
+      into a newly-allocated direct ByteBuffer. The returned buffer
+      will have its byte order set to the host platform's native byte
+      order. The position of the newly-allocated buffer will be zero,
+      and the position of the passed buffer is unchanged (though its
+      mark is changed). */
+  public static ByteBuffer copyShortBufferAsByteBuffer(ShortBuffer orig) {
+    ByteBuffer dest = newByteBuffer(orig.remaining() * SIZEOF_SHORT);
+    dest.asShortBuffer().put(orig);
+    dest.rewind();
+    return dest;
+  }
+
+  //----------------------------------------------------------------------
+  // Conversion routines 
+  //
+  
+  public final static float[] getFloatArray(double[] source) {
+      int i=source.length;
+      float[] dest = new float[i--];
+      while(i>=0) { dest[i]=(float)source[i]; i--; }
+      return dest;
+  }
+
+  public final static FloatBuffer getFloatBuffer(DoubleBuffer source) {
+      source.rewind();
+      FloatBuffer dest = BufferUtil.newFloatBuffer(source.limit());
+      while(source.hasRemaining()) { dest.put((float)source.get()); }
+      return dest;
+  }
+
+  public static ByteBuffer nativeOrder(ByteBuffer buf) {
+    if (!isCDCFP) {
+      try {
+        if (byteOrderClass == null) {
+          byteOrderClass = Class.forName("java.nio.ByteOrder");
+          orderMethod = ByteBuffer.class.getMethod("order", new Class[] { byteOrderClass });
+          Method nativeOrderMethod = byteOrderClass.getMethod("nativeOrder", null);
+          nativeOrderObject = nativeOrderMethod.invoke(null, null);
+        }
+      } catch (Throwable t) {
+        // Must be running on CDC / FP
+        isCDCFP = true;
+      }
+
+      if (!isCDCFP) {
+        try {
+          orderMethod.invoke(buf, new Object[] { nativeOrderObject });
+        } catch (Throwable t) {
+        }
+      }
+    }
+    return buf;
+  }
+
+  //----------------------------------------------------------------------
+  // Convenient GL put methods with generic target Buffer
+  //
+  public static void put(Buffer dest, Buffer v) {
+    if((dest instanceof ByteBuffer) && (v instanceof ByteBuffer)) {
+        ((ByteBuffer)dest).put((ByteBuffer)v);
+    } else if((dest instanceof ShortBuffer) && (v instanceof ShortBuffer)) {
+        ((ShortBuffer)dest).put((ShortBuffer)v);
+    } else if((dest instanceof IntBuffer) && (v instanceof IntBuffer)) {
+        ((IntBuffer)dest).put((IntBuffer)v);
+    } else if((dest instanceof FloatBuffer) && (v instanceof FloatBuffer)) {
+        ((FloatBuffer)dest).put((FloatBuffer)v);
+    } else {
+        throw new GLException("Incompatible Buffer classes: dest = "+dest.getClass().getName() + ", src = " + v.getClass().getName());
+    }
+  }
+
+  public static void putb(Buffer dest, byte v) {
+    if(dest instanceof ByteBuffer) {
+        ((ByteBuffer)dest).put(v);
+    } else if(dest instanceof ShortBuffer) {
+        ((ShortBuffer)dest).put((short)v);
+    } else if(dest instanceof IntBuffer) {
+        ((IntBuffer)dest).put((int)v);
+    } else {
+        throw new GLException("Byte doesn't match Buffer Class: "+dest);
+    }
+  }
+
+  public static void puts(Buffer dest, short v) {
+    if(dest instanceof ShortBuffer) {
+        ((ShortBuffer)dest).put(v);
+    } else if(dest instanceof IntBuffer) {
+        ((IntBuffer)dest).put((int)v);
+    } else {
+        throw new GLException("Short doesn't match Buffer Class: "+dest);
+    }
+  }
+
+  public static void puti(Buffer dest, int v) {
+    if(dest instanceof IntBuffer) {
+        ((IntBuffer)dest).put(v);
+    } else {
+        throw new GLException("Integer doesn't match Buffer Class: "+dest);
+    }
+  }
+
+  public static void putx(Buffer dest, int v) {
+    puti(dest, v);
+  }
+
+  public static void putf(Buffer dest, float v) {
+    if(dest instanceof FloatBuffer) {
+        ((FloatBuffer)dest).put(v);
+    } else if(dest instanceof IntBuffer) {
+        ((IntBuffer)dest).put(FixedPoint.toFixed(v));
+    } else {
+        throw new GLException("Float doesn't match Buffer Class: "+dest);
+    }
+  }
+
+  public static void putd(Buffer dest, double v) {
+    if(dest instanceof FloatBuffer) {
+        ((FloatBuffer)dest).put((float)v);
+    } else {
+        throw new GLException("Double doesn't match Buffer Class: "+dest);
+    }
+  }
+
+  //----------------------------------------------------------------------
+  // Internals only below this point
+  //
+
+  // NOTE that this work must be done reflectively at the present time
+  // because this code must compile and run correctly on both CDC/FP and J2SE
+  private static boolean isCDCFP;
+  private static Class byteOrderClass;
+  private static Object nativeOrderObject;
+  private static Method orderMethod;
+
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/FBObject.java b/src/jogl/classes/com/jogamp/opengl/util/FBObject.java
new file mode 100755
index 000000000..4920ed5f5
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/FBObject.java
@@ -0,0 +1,263 @@
+/*
+ * Copyright (c) 2008 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ */
+
+package com.jogamp.opengl.util;
+
+import javax.media.opengl.*;
+
+public class FBObject {
+    private int width, height, attr;
+    private int fb, fbo_tex, depth_rb, stencil_rb, vStatus;
+    private int texInternalFormat, texDataFormat, texDataType;
+
+    public static final int ATTR_DEPTH   = 1 << 0;
+    public static final int ATTR_STENCIL = 1 << 1;
+
+    public FBObject(int width, int height, int attributes) {
+        this.width = width;
+        this.height = height;
+        this.attr = attributes;
+    }        
+
+
+    public boolean validateStatus(GL gl) {
+        vStatus = getStatus(gl, fb);
+        switch(vStatus) {
+            case GL.GL_FRAMEBUFFER_COMPLETE:
+                return true;
+            case GL.GL_FRAMEBUFFER_UNSUPPORTED:
+            case GL.GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
+            case GL.GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
+            case GL.GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
+            case GL.GL_FRAMEBUFFER_INCOMPLETE_FORMATS:
+            //case GL2.GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER:
+            //case GL2.GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER:
+            //case GL2.GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT:
+            case 0:
+            default:
+                return false;
+        }
+    }
+
+    public static int getStatus(GL gl, int fb) {
+        if(!gl.glIsFramebuffer(fb)) {
+            return -1;
+        }
+        return gl.glCheckFramebufferStatus(gl.GL_FRAMEBUFFER);
+        //return gl.glCheckFramebufferStatus(fb);
+    }
+
+    public String getStatusString() {
+        return getStatusString(vStatus);
+    }
+
+    public static String getStatusString(int fbStatus) {
+        switch(fbStatus) {
+            case -1:
+                return "NOT A FBO";
+            case GL.GL_FRAMEBUFFER_COMPLETE:
+                return "OK";
+            case GL.GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
+                return("GL FBO: incomplete,incomplete attachment\n");
+            case GL.GL_FRAMEBUFFER_UNSUPPORTED:
+                return("GL FBO: Unsupported framebuffer format");
+            case GL.GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
+                return("GL FBO: incomplete,missing attachment");
+            case GL.GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS:
+                return("GL FBO: incomplete,attached images must have same dimensions");
+            case GL.GL_FRAMEBUFFER_INCOMPLETE_FORMATS:
+                 return("GL FBO: incomplete,attached images must have same format");
+                 /*
+            case GL2.GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER:
+                return("GL FBO: incomplete,missing draw buffer");
+            case GL2.GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER:
+                return("GL FBO: incomplete,missing read buffer");
+            case GL2.GL_FRAMEBUFFER_INCOMPLETE_DUPLICATE_ATTACHMENT:
+                return("GL FBO: incomplete, duplicate attachment");
+                */
+            case 0:
+                return("GL FBO: incomplete, implementation fault");
+            default:
+                return("GL FBO: incomplete, implementation ERROR");
+        }
+    }
+
+    public void init(GL gl) {
+        int textureInternalFormat, textureDataFormat, textureDataType;
+
+        if(gl.isGL2()) { 
+            textureInternalFormat=GL.GL_RGBA8;
+            textureDataFormat=GL2.GL_BGRA;
+            textureDataType=GL2.GL_UNSIGNED_INT_8_8_8_8_REV;
+        } else if(gl.isGLES()) { 
+            textureInternalFormat=GL.GL_RGBA;
+            textureDataFormat=GL.GL_RGBA;
+            textureDataType=GL.GL_UNSIGNED_BYTE;
+        } else {
+            textureInternalFormat=GL.GL_RGB;
+            textureDataFormat=GL.GL_RGB;
+            textureDataType=GL.GL_UNSIGNED_BYTE;
+        }
+        init(gl, textureInternalFormat, textureDataFormat, textureDataType);
+    }
+
+    public void init(GL gl, int textureInternalFormat, int textureDataFormat, int textureDataType) {
+        texInternalFormat=textureInternalFormat; 
+        texDataFormat=textureDataFormat;
+        texDataType=textureDataType;
+
+        // generate fbo ..
+        int name[] = new int[1];
+
+        gl.glGenFramebuffers(1, name, 0);
+        fb = name[0];
+        System.out.println("fb: "+fb);
+
+        gl.glGenTextures(1, name, 0);
+        fbo_tex = name[0];
+        System.out.println("fbo_tex: "+fbo_tex);
+
+        if(0!=(attr&ATTR_DEPTH)) {
+            gl.glGenRenderbuffers(1, name, 0);
+            depth_rb = name[0];
+            System.out.println("depth_rb: "+depth_rb);
+        } else {
+            depth_rb = 0;
+        }
+        if(0!=(attr&ATTR_STENCIL)) {
+            gl.glGenRenderbuffers(1, name, 0);
+            stencil_rb = name[0];
+            System.out.println("stencil_rb: "+stencil_rb);
+        } else {
+            stencil_rb = 0;
+        }
+
+        // bind fbo ..
+        gl.glBindFramebuffer(GL.GL_FRAMEBUFFER, fb);
+
+        gl.glBindTexture(GL.GL_TEXTURE_2D, fbo_tex);
+        gl.glTexImage2D(GL.GL_TEXTURE_2D, 0, texInternalFormat, width, height, 0,
+                        texDataFormat, texDataType, null);
+        gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_NEAREST);
+        gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_NEAREST);
+        //gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_S, GL2.GL_CLAMP);
+        //gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_T, GL2.GL_CLAMP);
+
+
+        // Set up the color buffer for use as a renderable texture:
+        gl.glFramebufferTexture2D(GL.GL_FRAMEBUFFER,
+                                  GL.GL_COLOR_ATTACHMENT0,
+                                  GL.GL_TEXTURE_2D, fbo_tex, 0); 
+
+        if(depth_rb!=0) {
+            // Initialize the depth buffer:
+            gl.glBindRenderbuffer(GL.GL_RENDERBUFFER, depth_rb);
+            gl.glRenderbufferStorage(GL.GL_RENDERBUFFER,
+                                        GL.GL_DEPTH_COMPONENT16, width, height);
+            // Set up the depth buffer attachment:
+            gl.glFramebufferRenderbuffer(GL.GL_FRAMEBUFFER,
+                                            GL.GL_DEPTH_ATTACHMENT,
+                                            GL.GL_RENDERBUFFER, depth_rb);
+        }
+
+        if(stencil_rb!=0) {
+            // Initialize the stencil buffer:
+            gl.glBindRenderbuffer(GL.GL_RENDERBUFFER, stencil_rb);
+            gl.glRenderbufferStorage(GL.GL_RENDERBUFFER,
+                                        GL.GL_STENCIL_INDEX8, width, height);
+            gl.glFramebufferRenderbuffer(GL.GL_FRAMEBUFFER,
+                                            GL.GL_STENCIL_ATTACHMENT,
+                                            GL.GL_RENDERBUFFER, stencil_rb);
+        }
+
+        // Check the FBO for completeness
+        if(validateStatus(gl)) {
+            System.out.println("Framebuffer " + fb + " is complete");
+        } else {
+            System.out.println("Framebuffer " + fb + " is incomplete: status = 0x" + Integer.toHexString(vStatus) + 
+                               " : " + getStatusString());
+        }
+
+        unbind(gl);
+    }
+
+    public void destroy(GL gl) {
+        unbind(gl);
+
+        int name[] = new int[1];
+
+        if(0!=stencil_rb) {
+            name[0] = stencil_rb;
+            gl.glDeleteRenderbuffers(1, name, 0);
+            stencil_rb = 0;
+        }
+        if(0!=depth_rb) {
+            name[0] = depth_rb;
+            gl.glDeleteRenderbuffers(1, name, 0);
+            depth_rb=0;
+        }
+        if(0!=fbo_tex) {
+            name[0] = fbo_tex;
+            gl.glDeleteTextures(1, name, 0);
+            fbo_tex = 0;
+        }
+        if(0!=fb) {
+            name[0] = fb;
+            gl.glDeleteFramebuffers(1, name, 0);
+            fb = 0;
+        }
+    }
+
+    public void bind(GL gl) {
+        gl.glBindTexture(GL.GL_TEXTURE_2D, fbo_tex);
+        gl.glBindFramebuffer(GL.GL_FRAMEBUFFER, fb); 
+    }
+
+    public void unbind(GL gl) {
+        gl.glBindTexture(GL.GL_TEXTURE_2D, 0);
+        gl.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0);
+    }
+
+    public void use(GL gl) {
+        gl.glBindTexture(GL.GL_TEXTURE_2D, 0);
+        gl.glBindFramebuffer(GL.GL_FRAMEBUFFER, 0);
+        gl.glBindTexture(GL.GL_TEXTURE_2D, fbo_tex); // to use it ..
+    }
+
+    public int getFBName() {
+        return fb;
+    }
+    public int getTextureName() {
+        return fbo_tex;
+    }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/FPSAnimator.java b/src/jogl/classes/com/jogamp/opengl/util/FPSAnimator.java
new file mode 100755
index 000000000..75c4cdff7
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/FPSAnimator.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util;
+
+import java.util.*;
+import javax.media.opengl.*;
+
+/** An Animator subclass which attempts to achieve a target
+    frames-per-second rate to avoid using all CPU time. The target FPS
+    is only an estimate and is not guaranteed. */
+
+public class FPSAnimator extends Animator {
+  private Timer timer;
+  private int   fps;
+  private boolean scheduleAtFixedRate;
+
+  /** Creates an FPSAnimator with a given target frames-per-second
+      value. Equivalent to <code>FPSAnimator(null, fps)</code>. */
+  public FPSAnimator(int fps) {
+    this(null, fps);
+  }
+
+  /** Creates an FPSAnimator with a given target frames-per-second
+      value and a flag indicating whether to use fixed-rate
+      scheduling. Equivalent to <code>FPSAnimator(null, fps,
+      scheduleAtFixedRate)</code>. */
+  public FPSAnimator(int fps, boolean scheduleAtFixedRate) {
+    this(null, fps, scheduleAtFixedRate);
+  }
+
+  /** Creates an FPSAnimator with a given target frames-per-second
+      value and an initial drawable to animate. Equivalent to
+      <code>FPSAnimator(null, fps, false)</code>. */
+  public FPSAnimator(GLAutoDrawable drawable, int fps) {
+    this(drawable, fps, false);
+  }
+
+  /** Creates an FPSAnimator with a given target frames-per-second
+      value, an initial drawable to animate, and a flag indicating
+      whether to use fixed-rate scheduling. */
+  public FPSAnimator(GLAutoDrawable drawable, int fps, boolean scheduleAtFixedRate) {
+    this.fps = fps;
+    if (drawable != null) {
+      add(drawable);
+    }
+    this.scheduleAtFixedRate = scheduleAtFixedRate;
+  }
+
+  /** Starts this FPSAnimator. */
+  public synchronized void start() {
+    if (timer != null) {
+      throw new GLException("Already started");
+    }
+    timer = new Timer();
+    long delay = (long) (1000.0f / (float) fps);
+    TimerTask task = new TimerTask() {
+        public void run() {
+          display();
+        }
+      };
+    if (scheduleAtFixedRate) {
+      timer.scheduleAtFixedRate(task, 0, delay);
+    } else {
+      timer.schedule(task, 0, delay);
+    }
+  }
+
+  /** Indicates whether this FPSAnimator is currently running. This
+      should only be used as a heuristic to applications because in
+      some circumstances the FPSAnimator may be in the process of
+      shutting down and this method will still return true. */
+  public synchronized boolean isAnimating() {
+    return (timer != null);
+  }
+
+  /** Stops this FPSAnimator. Due to the implementation of the
+      FPSAnimator it is not guaranteed that the FPSAnimator will be
+      completely stopped by the time this method returns. */
+  public synchronized void stop() {
+    if (timer == null) {
+      throw new GLException("Already stopped");
+    }
+    timer.cancel();
+    timer = null;
+  }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/FileUtil.java b/src/jogl/classes/com/jogamp/opengl/util/FileUtil.java
new file mode 100755
index 000000000..6ad0da825
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/FileUtil.java
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2005 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util;
+
+import java.io.*;
+
+/** Utilities for dealing with files. */
+
+public class FileUtil {
+    private FileUtil() {}
+
+    /**
+     * Returns the lowercase suffix of the given file name (the text
+     * after the last '.' in the file name). Returns null if the file
+     * name has no suffix. Only operates on the given file name;
+     * performs no I/O operations.
+     *
+     * @param file name of the file
+     * @return lowercase suffix of the file name
+     * @throws NullPointerException if file is null
+     */
+
+    public static String getFileSuffix(File file) {
+        return getFileSuffix(file.getName());
+    }
+
+    /**
+     * Returns the lowercase suffix of the given file name (the text
+     * after the last '.' in the file name). Returns null if the file
+     * name has no suffix. Only operates on the given file name;
+     * performs no I/O operations.
+     *
+     * @param filename name of the file
+     * @return lowercase suffix of the file name
+     * @throws NullPointerException if filename is null
+     */
+    public static String getFileSuffix(String filename) {
+        int lastDot = filename.lastIndexOf('.');
+        if (lastDot < 0) {
+            return null;
+        }
+        return toLowerCase(filename.substring(lastDot + 1));
+    }
+
+    private static String toLowerCase(String arg) {
+        if (arg == null) {
+            return null;
+        }
+
+        return arg.toLowerCase();
+    }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/FixedPoint.java b/src/jogl/classes/com/jogamp/opengl/util/FixedPoint.java
new file mode 100644
index 000000000..6412db5ef
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/FixedPoint.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2009 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ */
+
+package com.jogamp.opengl.util;
+
+public class FixedPoint {
+  public static final int toFixed(int value) {
+    if (value < -32768) value = -32768;
+    if (value > 32767) value = 32767;
+    return value * 65536;
+  }
+
+  public static final int toFixed(float value) {
+    if (value < -32768) value = -32768;
+    if (value > 32767) value = 32767;
+    return (int)(value * 65536.0f);
+  }
+
+  public static final float toFloat(int value) {
+    return (float)value/65536.0f;
+  }
+
+  public static final int mult(int x1, int x2) {
+    return (int) ( ((long)x1*(long)x2)/65536 );
+  }
+
+  public static final int div(int x1, int x2) {
+    return (int) ( (((long)x1)<<16)/x2 );
+  }
+}
+
diff --git a/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataClient.java b/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataClient.java
new file mode 100644
index 000000000..f8951f0fd
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataClient.java
@@ -0,0 +1,353 @@
+
+package com.jogamp.opengl.util;
+
+import java.security.*;
+
+import javax.media.opengl.*;
+
+import com.jogamp.opengl.util.glsl.*;
+
+import com.jogamp.opengl.impl.SystemUtil;
+
+import java.nio.*;
+
+public class GLArrayDataClient extends GLArrayDataWrapper implements GLArrayDataEditable {
+
+  /**
+   * The OpenGL ES emulation on the PC probably has a buggy VBO implementation,
+   * where we have to 'refresh' the VertexPointer or VertexAttribArray after each
+   * BindBuffer !
+   *
+   * This should not be necessary on proper native implementations.
+   */
+  public static final boolean hasVBOBug = AccessController.doPrivileged(new PrivilegedAction() {
+          public Object run() {
+              return SystemUtil.getenv("JOGL_VBO_BUG");
+          }
+      }) != null;
+
+  /**
+   * @param index The GL array index
+   * @param name  The optional custom name for the GL array index, maybe null.
+   *            If null, the default name mapping will be used, see 'getPredefinedArrayIndexName(int)'.
+   *            This name might be used as the shader attribute name.
+   * @param comps The array component number
+   * @param dataType The array index GL data type
+   * @param normalized Wheather the data shall be normalized
+   *
+   * @see javax.media.opengl.GLContext#getPredefinedArrayIndexName(int)
+   */
+  public static GLArrayDataClient createFixed(GL gl, int index, String name, int comps, int dataType, boolean normalized, 
+                                              int initialSize)
+    throws GLException
+  {
+      gl.getGLProfile().isValidArrayDataType(index, comps, dataType, false, true);
+      GLArrayDataClient adc = new GLArrayDataClient();
+      GLArrayHandler glArrayHandler = new GLFixedArrayHandler(adc);
+      adc.init(name, index, comps, dataType, normalized, 0, null, initialSize, false, glArrayHandler, 0, 0);
+      return adc;
+  }
+
+  public static GLArrayDataClient createFixed(GL gl, int index, String name, int comps, int dataType, boolean normalized, 
+                                              int stride, Buffer buffer)
+    throws GLException
+  {
+      gl.getGLProfile().isValidArrayDataType(index, comps, dataType, false, true);
+      GLArrayDataClient adc = new GLArrayDataClient();
+      GLArrayHandler glArrayHandler = new GLFixedArrayHandler(adc);
+      adc.init(name, index, comps, dataType, normalized, stride, buffer, comps*comps, false, glArrayHandler, 0, 0);
+      return adc;
+  }
+
+  public static GLArrayDataClient createGLSL(GL gl, String name, int comps, int dataType, boolean normalized, 
+                                             int initialSize)
+    throws GLException
+  {
+      if(!gl.hasGLSL()) {
+        throw new GLException("GLArrayDataClient.GLSL not supported: "+gl);
+      }
+      gl.getGLProfile().isValidArrayDataType(-1, comps, dataType, true, true);
+
+      GLArrayDataClient adc = new GLArrayDataClient();
+      GLArrayHandler glArrayHandler = new GLSLArrayHandler(adc);
+      adc.init(name, -1, comps, dataType, normalized, 0, null, initialSize, true, glArrayHandler, 0, 0);
+      return adc;
+  }
+
+  public static GLArrayDataClient createGLSL(GL gl, String name, int comps, int dataType, boolean normalized, 
+                                             int stride, Buffer buffer)
+    throws GLException
+  {
+      if(!gl.hasGLSL()) {
+        throw new GLException("GLArrayDataClient.GLSL not supported: "+gl);
+      }
+      gl.getGLProfile().isValidArrayDataType(-1, comps, dataType, true, true);
+
+      GLArrayDataClient adc = new GLArrayDataClient();
+      GLArrayHandler glArrayHandler = new GLSLArrayHandler(adc);
+      adc.init(name, -1, comps, dataType, normalized, stride, buffer, comps*comps, true, glArrayHandler, 0, 0);
+      return adc;
+  }
+
+  // 
+  // Data read access
+  //
+
+  public final boolean isBufferWritten() { return bufferWritten; }
+
+  public final boolean sealed() { return sealed; }
+
+  public int getBufferUsage() { return -1; }
+
+  //
+  // Data and GL state modification ..
+  //
+
+  public final void setBufferWritten(boolean written) { bufferWritten=written; }
+
+  public void destroy(GL gl) {
+    reset(gl);
+    buffer=null;
+  }
+
+  public void reset(GL gl) {
+    enableBuffer(gl, false);
+    reset();
+  }
+
+  public void seal(GL gl, boolean seal)
+  {
+    seal(seal);
+    if(sealedGL==seal) return;
+    sealedGL = seal;
+    if(seal) {
+        init_vbo(gl);
+
+        enableBuffer(gl, true);
+    } else {
+        enableBuffer(gl, false);
+    }
+  }
+
+  public void enableBuffer(GL gl, boolean enable) {
+    if(enableBufferAlways && enable) {
+        bufferEnabled = false;
+    }
+    if( bufferEnabled != enable && components>0 ) {
+        if(enable) {
+            checkSeal(true);
+            if(null!=buffer) {
+                buffer.rewind();
+            }
+        }
+        glArrayHandler.enableBuffer(gl, enable);
+        bufferEnabled = enable;
+    }
+  }
+
+  public void setEnableAlways(boolean always) {
+    enableBufferAlways = always;
+  }
+
+  //
+  // Data modification ..
+  //
+
+  public void reset() {
+    if(buffer!=null) {
+        buffer.clear();
+    }
+    this.sealed=false;
+    this.bufferEnabled=false;
+    this.bufferWritten=false;
+  }
+
+  public void seal(boolean seal)
+  {
+    if(sealed==seal) return;
+    sealed = seal;
+    if(seal) {
+        bufferWritten=false;
+        if (null!=buffer) {
+            buffer.flip();
+        }
+    } else {
+        if (null!=buffer) {
+            buffer.position(buffer.limit());
+            buffer.limit(buffer.capacity());
+        }
+    }
+  }
+
+
+  public void rewind() {
+    if(buffer!=null) {
+        buffer.rewind();
+    }
+  }
+
+  public void padding(int done) {
+    if ( buffer==null || sealed ) return;
+    while(done<strideL) {
+        BufferUtil.putb(buffer, (byte)0);
+        done++;
+    }
+  }
+
+  /**
+   * Generic buffer relative put method.
+   *
+   * This class buffer Class must match the arguments buffer class.
+   * The arguments remaining elements must be a multiple of this arrays element stride.
+   */
+  public void put(Buffer v) {
+    if ( buffer==null || sealed ) return;
+    if(0!=(v.remaining() % strideL)) {
+        throw new GLException("Buffer length ("+v.remaining()+") is not a multiple of component-stride:\n\t"+this);
+    }
+    growBufferIfNecessary(v.remaining());
+    BufferUtil.put(buffer, v);
+  }
+
+  public void putb(byte v) {
+    if ( buffer==null || sealed ) return;
+    growBufferIfNecessary(1);
+    BufferUtil.putb(buffer, v);
+  }
+
+  public void puts(short v) {
+    if ( buffer==null || sealed ) return;
+    growBufferIfNecessary(1);
+    BufferUtil.puts(buffer, v);
+  }
+
+  public void puti(int v) {
+    if ( buffer==null || sealed ) return;
+    growBufferIfNecessary(1);
+    BufferUtil.puti(buffer, v);
+  }
+
+  public void putx(int v) {
+    puti(v);
+  }
+
+  public void putf(float v) {
+    if ( buffer==null || sealed ) return;
+    growBufferIfNecessary(1);
+    BufferUtil.putf(buffer, v);
+  }
+
+  public String toString() {
+    return "GLArrayDataClient["+name+
+                       ", index "+index+
+                       ", location "+location+
+                       ", isVertexAttribute "+isVertexAttribute+
+                       ", dataType "+dataType+ 
+                       ", bufferClazz "+clazz+ 
+                       ", elements "+getElementNumber()+
+                       ", components "+components+ 
+                       ", stride "+stride+"u "+strideB+"b "+strideL+"c"+
+                       ", initialSize "+initialSize+ 
+                       ", sealed "+sealed+ 
+                       ", bufferEnabled "+bufferEnabled+ 
+                       ", bufferWritten "+bufferWritten+ 
+                       ", buffer "+buffer+ 
+                       "]";
+  }
+
+  // non public matters
+
+  protected final boolean growBufferIfNecessary(int spare) {
+    if(buffer==null || buffer.remaining()<spare) { 
+        growBuffer(initialSize);
+        return true;
+    }
+    return false;
+  }
+
+  protected final void growBuffer(int additional) {
+    if(sealed || 0==additional || 0==components) return;
+
+    // add the stride delta
+    additional += (additional/components)*(strideL-components);
+
+    if(components>0) {
+        int osize = (buffer!=null)?buffer.capacity():0;
+        if(clazz==ByteBuffer.class) {
+            ByteBuffer newBBuffer = BufferUtil.newByteBuffer( (osize+additional) * components );
+            if(buffer!=null) {
+                buffer.flip();
+                newBBuffer.put((ByteBuffer)buffer);
+            }
+            buffer = newBBuffer;
+        } else if(clazz==ShortBuffer.class) {
+            ShortBuffer newSBuffer = BufferUtil.newShortBuffer( (osize+additional) * components );
+            if(buffer!=null) {
+                buffer.flip();
+                newSBuffer.put((ShortBuffer)buffer);
+            }
+            buffer = newSBuffer;
+        } else if(clazz==IntBuffer.class) {
+            IntBuffer newIBuffer = BufferUtil.newIntBuffer( (osize+additional) * components );
+            if(buffer!=null) {
+                buffer.flip();
+                newIBuffer.put((IntBuffer)buffer);
+            }
+            buffer = newIBuffer;
+        } else if(clazz==FloatBuffer.class) {
+            FloatBuffer newFBuffer = BufferUtil.newFloatBuffer( (osize+additional) * components );
+            if(buffer!=null) {
+                buffer.flip();
+                newFBuffer.put((FloatBuffer)buffer);
+            }
+            buffer = newFBuffer;
+        } else {
+            throw new GLException("Given Buffer Class not supported: "+clazz+":\n\t"+this);
+        }
+    }
+  }
+
+  protected final void checkSeal(boolean test) throws GLException {
+    if(sealed!=test) {
+        if(test) {
+            throw new GLException("Not Sealed yet, seal first:\n\t"+this); 
+        } else {
+            throw new GLException("Already Sealed, can't modify VBO:\n\t"+this); 
+        }
+    }
+  }
+
+  protected void init(String name, int index, int comps, int dataType, boolean normalized, int stride, Buffer data, 
+                      int initialSize, boolean isVertexAttribute, GLArrayHandler handler,
+                      int vboName, long bufferOffset)
+    throws GLException
+  {
+    super.init(name, index, comps, dataType, normalized, stride, data, isVertexAttribute,
+               vboName, bufferOffset);
+
+    this.initialSize = initialSize;
+    this.glArrayHandler = handler;
+    this.sealed=false;
+    this.sealedGL=false;
+    this.bufferEnabled=false;
+    this.enableBufferAlways=false;
+    this.bufferWritten=false;
+    if(null==buffer) {
+        growBuffer(initialSize);
+    }
+  }
+
+  protected void init_vbo(GL gl) {}
+
+  protected GLArrayDataClient() { }
+
+  protected boolean sealed, sealedGL;
+  protected boolean bufferEnabled;
+  protected boolean bufferWritten;
+  protected boolean enableBufferAlways;
+
+  protected int initialSize;
+
+  protected GLArrayHandler glArrayHandler;
+}
+
diff --git a/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataEditable.java b/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataEditable.java
new file mode 100644
index 000000000..0f8ed27be
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataEditable.java
@@ -0,0 +1,110 @@
+
+package com.jogamp.opengl.util;
+
+import javax.media.opengl.*;
+
+import java.nio.*;
+
+/**
+ *
+ * The total number of bytes hold by the referenced buffer is:
+ * getComponentSize()* getComponentNumber() * getElementNumber()
+ *
+ */
+public interface GLArrayDataEditable extends GLArrayData {
+
+    public boolean sealed();
+
+    /**
+     * The VBO buffer usage, if it's an VBO, otherwise -1
+     */
+    public int getBufferUsage();
+
+    /**
+     * Is the buffer written to the GPU ?
+     */
+    public boolean isBufferWritten();
+
+    /**
+     * Marks the buffer written to the GPU
+     */
+    public void setBufferWritten(boolean written);
+
+    //
+    // Data and GL state modification ..
+    //
+
+    public void destroy(GL gl);
+
+    public void reset(GL gl);
+
+    /**
+     * If seal is true, it
+     * disable write operations to the buffer.
+     * Calls flip, ie limit:=position and position:=0.
+     * Also enables the buffer for OpenGL, and passes the data.
+     *
+     * If seal is false, it
+     * enable write operations continuing
+     * at the buffer position, where you left off at seal(true),
+     * ie position:=limit and limit:=capacity.
+     * Also disables the buffer for OpenGL.
+     *
+     * @see #seal(boolean)
+     */
+    public void seal(GL gl, boolean seal);
+
+    /**
+     * Enables/disables the buffer, which implies
+     * the client state, binding the VBO
+     * and transfering the data if not done yet.
+     * 
+     * The above will only be executed,
+     * if the buffer is disabled,
+     * or 'setEnableAlways' was called with 'true'.
+     *
+     * @see #setEnableAlways(boolean)
+     */
+    public void enableBuffer(GL gl, boolean enable);
+
+    /**
+     * Affects the behavior of 'enableBuffer'.
+     *
+     * The default is 'false'
+     *
+     * This is usefull when you mix up 
+     * GLArrayData usage with conventional GL array calls.
+     *
+     * @see #enableBuffer(GL, boolean)
+     */
+    public void setEnableAlways(boolean always);
+
+    //
+    // Data modification ..
+    //
+
+    public void reset();
+
+    /**
+     * If seal is true, it
+     * disable write operations to the buffer.
+     * Calls flip, ie limit:=position and position:=0.
+     *
+     * If seal is false, it
+     * enable write operations continuing
+     * at the buffer position, where you left off at seal(true),
+     * ie position:=limit and limit:=capacity.
+     *
+     */
+    public void seal(boolean seal);
+
+    public void rewind();
+    public void padding(int done);
+    public void put(Buffer v);
+    public void putb(byte v);
+    public void puts(short v);
+    public void puti(int v);
+    public void putx(int v);
+    public void putf(float v);
+}
+
diff --git a/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataServer.java b/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataServer.java
new file mode 100644
index 000000000..c061e212a
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataServer.java
@@ -0,0 +1,209 @@
+
+package com.jogamp.opengl.util;
+
+import javax.media.opengl.*;
+import java.nio.*;
+
+import com.jogamp.opengl.util.glsl.*;
+
+public class GLArrayDataServer extends GLArrayDataClient implements GLArrayDataEditable {
+
+  //
+  // lifetime matters
+  //
+
+  /**
+   * Create a VBOBuffer object, using a predefined fixed function array index
+   * and starting with a given Buffer object incl it's stride
+   *
+   * On profiles GL2 and ES1 the fixed function pipeline behavior is as expected.
+   * On profile ES2 the fixed function emulation will transform these calls to 
+   * EnableVertexAttribArray and VertexAttribPointer calls,
+   * and a predefined vertex attribute variable name will be choosen.
+   *
+   * @param index The GL array index
+   * @param name  The optional custom name for the GL array index, maybe null.
+   *            If null, the default name mapping will be used, see 'getPredefinedArrayIndexName(int)'.
+   *            This name might be used as the shader attribute name.
+   * @param comps The array component number
+   * @param dataType The array index GL data type
+   * @param normalized Wheather the data shall be normalized
+   *
+   * @see javax.media.opengl.GLContext#getPredefinedArrayIndexName(int)
+   */
+  public static GLArrayDataServer createFixed(GL gl, int index, String name, int comps, int dataType, boolean normalized,
+                                              int stride, Buffer buffer, int vboBufferUsage)
+    throws GLException
+  {
+    gl.getGLProfile().isValidArrayDataType(index, comps, dataType, false, true);
+
+    GLArrayDataServer ads = new GLArrayDataServer();
+    GLArrayHandler glArrayHandler = new GLFixedArrayHandler(ads);
+    ads.init(gl, name, index, comps, dataType, normalized, stride, buffer, buffer.limit(), false, glArrayHandler,
+             0, 0, vboBufferUsage);
+    return ads;
+  }
+
+  /**
+   * Create a VBOBuffer object, using a predefined fixed function array index
+   * and starting with a new created Buffer object with initialSize size
+   *
+   * On profiles GL2 and ES1 the fixed function pipeline behavior is as expected.
+   * On profile ES2 the fixed function emulation will transform these calls to 
+   * EnableVertexAttribArray and VertexAttribPointer calls,
+   * and a predefined vertex attribute variable name will be choosen.
+   *
+   * @see javax.media.opengl.GLContext#getPredefinedArrayIndexName(int)
+   */
+  public static GLArrayDataServer createFixed(GL gl, int index, String name, int comps, int dataType, boolean normalized, 
+                                              int initialSize, int vboBufferUsage)
+    throws GLException
+  {
+    gl.getGLProfile().isValidArrayDataType(index, comps, dataType, false, true);
+
+    GLArrayDataServer ads = new GLArrayDataServer();
+    GLArrayHandler glArrayHandler = new GLFixedArrayHandler(ads);
+    ads.init(gl, name, index, comps, dataType, normalized, 0, null, initialSize, false, glArrayHandler,
+             0, 0, vboBufferUsage);
+    return ads;
+  }
+
+  /**
+   * Create a VBOBuffer object, using a custom GLSL array attribute name
+   * and starting with a new created Buffer object with initialSize size
+   *
+   * @see javax.media.opengl.GLContext#getPredefinedArrayIndexName(int)
+   */
+  public static GLArrayDataServer createGLSL(GL gl, String name, int comps, int dataType, boolean normalized,
+                                             int initialSize, int vboBufferUsage) 
+    throws GLException
+  {
+    if(!gl.hasGLSL()) {
+        throw new GLException("GLArrayDataServer.GLSL not supported: "+gl);
+    }
+    gl.getGLProfile().isValidArrayDataType(-1, comps, dataType, true, true);
+
+    GLArrayDataServer ads = new GLArrayDataServer();
+    GLArrayHandler glArrayHandler = new GLSLArrayHandler(ads);
+    ads.init(gl, name, -1, comps, dataType, normalized, 0, null, initialSize, true, glArrayHandler,
+             0, 0, vboBufferUsage);
+    return ads;
+  }
+
+  /**
+   * Create a VBOBuffer object, using a custom GLSL array attribute name
+   * and starting with a given Buffer object incl it's stride
+   *
+   * @see javax.media.opengl.GLContext#getPredefinedArrayIndexName(int)
+   */
+  public static GLArrayDataServer createGLSL(GL gl, String name, int comps, int dataType, boolean normalized,
+                                             int stride, Buffer buffer, int vboBufferUsage) 
+    throws GLException
+  {
+    if(!gl.hasGLSL()) {
+        throw new GLException("GLArrayDataServer.GLSL not supported: "+gl);
+    }
+    gl.getGLProfile().isValidArrayDataType(-1, comps, dataType, true, true);
+
+    GLArrayDataServer ads = new GLArrayDataServer();
+    GLArrayHandler glArrayHandler = new GLSLArrayHandler(ads);
+    ads.init(gl, name, -1, comps, dataType, normalized, stride, buffer, buffer.limit(), true, glArrayHandler,
+             0, 0, vboBufferUsage);
+    return ads;
+  }
+
+  //
+  // Data matters GLArrayData
+  //
+
+  public int getBufferUsage() { return vboBufferUsage; }
+
+  //
+  // Data and GL state modification ..
+  //
+
+  public void destroy(GL gl) {
+    super.destroy(gl);
+    if(vboName!=0) {
+        int[] tmp = new int[1];
+        tmp[0] = vboName;
+        gl.glDeleteBuffers(1, tmp, 0);
+        vboName = 0;
+    }
+  }
+
+  //
+  // data matters 
+  //
+
+  /**
+   * Convenient way do disable the VBO behavior and 
+   * switch to client side data one
+   * Only possible if buffer is defined.
+   */
+  public void    setVBOUsage(boolean vboUsage) { 
+    checkSeal(false);
+    super.setVBOUsage(vboUsage);
+  }
+
+  public String toString() {
+    return "GLArrayDataServer["+name+
+                       ", index "+index+
+                       ", location "+location+
+                       ", isVertexAttribute "+isVertexAttribute+
+                       ", dataType "+dataType+ 
+                       ", bufferClazz "+clazz+ 
+                       ", elements "+getElementNumber()+
+                       ", components "+components+ 
+                       ", stride "+stride+"u "+strideB+"b "+strideL+"c"+
+                       ", initialSize "+initialSize+ 
+                       ", vboBufferUsage "+vboBufferUsage+ 
+                       ", vboUsage "+vboUsage+ 
+                       ", vboName "+vboName+ 
+                       ", sealed "+sealed+ 
+                       ", bufferEnabled "+bufferEnabled+ 
+                       ", bufferWritten "+bufferWritten+ 
+                       ", buffer "+buffer+ 
+                       ", offset "+bufferOffset+ 
+                       "]";
+  }
+
+  //
+  // non public matters ..
+  //
+
+  protected void init(GL gl, String name, int index, int comps, int dataType, boolean normalized, 
+                      int stride, Buffer data, int initialSize, boolean isVertexAttribute,
+                      GLArrayHandler glArrayHandler,
+                      int vboName, long bufferOffset, int vboBufferUsage)
+    throws GLException
+  {
+    super.init(name, index, comps, dataType, normalized, stride, data, initialSize, isVertexAttribute, glArrayHandler,
+               vboName, bufferOffset);
+
+    vboUsage=true;
+
+    if( ! (gl.isGL2ES2() && vboBufferUsage==GL2ES2.GL_STREAM_DRAW) ) {
+        switch(vboBufferUsage) {
+            case -1: // nop
+            case GL.GL_STATIC_DRAW:
+            case GL.GL_DYNAMIC_DRAW:
+                break;
+            default:
+                throw new GLException("invalid vboBufferUsage: "+vboBufferUsage+":\n\t"+this); 
+        }
+    }
+    this.vboBufferUsage=vboBufferUsage;
+  }
+
+  protected void init_vbo(GL gl) {
+    if(vboUsage && vboName==0) {
+        int[] tmp = new int[1];
+        gl.glGenBuffers(1, tmp, 0);
+        vboName = tmp[0];
+    }
+  }
+
+  protected int vboBufferUsage;
+}
+
diff --git a/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataWrapper.java b/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataWrapper.java
new file mode 100644
index 000000000..aa3059800
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/GLArrayDataWrapper.java
@@ -0,0 +1,215 @@
+
+package com.jogamp.opengl.util;
+
+import javax.media.opengl.*;
+
+import com.jogamp.opengl.util.glsl.fixedfunc.impl.*;
+
+import java.nio.*;
+
+public class GLArrayDataWrapper implements GLArrayData {
+
+  public static GLArrayDataWrapper createFixed(GL gl, int index, int comps, int dataType, boolean normalized, 
+                                              int stride, Buffer buffer,
+                                              int vboName, long bufferOffset)
+    throws GLException
+  {
+      gl.getGLProfile().isValidArrayDataType(index, comps, dataType, false, true);
+      GLArrayDataWrapper adc = new GLArrayDataWrapper();
+      adc.init(null, index, comps, dataType, normalized, stride, buffer, false, 
+               vboName, bufferOffset);
+      return adc;
+  }
+
+  public static GLArrayDataWrapper createGLSL(GL gl, String name, int comps, int dataType, boolean normalized, 
+                                             int stride, Buffer buffer,
+                                             int vboName, long bufferOffset)
+    throws GLException
+  {
+      if(!gl.hasGLSL()) {
+        throw new GLException("GLArrayDataWrapper.GLSL not supported: "+gl);
+      }
+      gl.getGLProfile().isValidArrayDataType(-1, comps, dataType, true, true);
+
+      GLArrayDataWrapper adc = new GLArrayDataWrapper();
+      adc.init(name, -1, comps, dataType, normalized, stride, buffer, true,
+               vboName, bufferOffset);
+      return adc;
+  }
+
+  // 
+  // Data read access
+  //
+
+  public final boolean isVertexAttribute() { return isVertexAttribute; }
+
+  public final int getIndex() { return index; }
+
+  public final int getLocation() { return location; }
+
+  public final void setLocation(int v) { location = v; }
+
+  public final String getName() { return name; }
+
+  public final long getOffset() { return vboUsage?bufferOffset:-1; }
+
+  public final int getVBOName() { return vboUsage?vboName:-1; }
+
+  public final boolean isVBO() { return vboUsage; }
+
+  public final Buffer getBuffer() { return buffer; }
+
+  public final int getComponentNumber() { return components; }
+
+  public final int getComponentType() { return dataType; }
+
+  public final int getComponentSize() {
+    if(clazz==ByteBuffer.class) {
+        return BufferUtil.SIZEOF_BYTE;
+    }
+    if(clazz==ShortBuffer.class) {
+        return BufferUtil.SIZEOF_SHORT;
+    }
+    if(clazz==IntBuffer.class) {
+        return BufferUtil.SIZEOF_INT;
+    }
+    if(clazz==FloatBuffer.class) {
+        return BufferUtil.SIZEOF_FLOAT;
+    }
+    throw new GLException("Given Buffer Class not supported: "+clazz+":\n\t"+this);
+  }
+
+  public final int getElementNumber() {
+    if(null==buffer) return 0;
+    return ( buffer.position()==0 ) ? ( buffer.limit() / components ) : ( buffer.position() / components ) ;
+  }
+
+  public final boolean getNormalized() { return normalized; }
+
+  public final int getStride() { return stride; }
+
+  public final Class getBufferClass() { return clazz; }
+
+  public void destroy(GL gl) {
+    this.buffer = null;
+    this.components = 0;
+    this.stride=0;
+    this.strideB=0;
+    this.strideL=0;
+    this.vboName=0;
+    this.vboUsage=false;
+    this.bufferOffset=0;
+  }
+
+  public String toString() {
+    return "GLArrayDataWrapper["+name+
+                       ", index "+index+
+                       ", location "+location+
+                       ", isVertexAttribute "+isVertexAttribute+
+                       ", dataType "+dataType+ 
+                       ", bufferClazz "+clazz+ 
+                       ", elements "+getElementNumber()+
+                       ", components "+components+ 
+                       ", stride "+stride+"u "+strideB+"b "+strideL+"c"+
+                       ", buffer "+buffer+ 
+                       ", offset "+bufferOffset+ 
+                       ", vboUsage "+vboUsage+ 
+                       ", vboName "+vboName+ 
+                       "]";
+  }
+
+  public static final Class getBufferClass(int dataType) {
+    switch(dataType) {
+        case GL.GL_BYTE:
+        case GL.GL_UNSIGNED_BYTE:
+            return ByteBuffer.class;
+        case GL.GL_SHORT:
+        case GL.GL_UNSIGNED_SHORT:
+            return ShortBuffer.class;
+        case GL2ES1.GL_FIXED:
+            return IntBuffer.class;
+        case GL.GL_FLOAT:
+            return FloatBuffer.class;
+        default:    
+            throw new GLException("Given OpenGL data type not supported: "+dataType);
+    }
+  }
+
+  public void setName(String newName) {
+    location = -1;
+    name = newName;
+  }
+
+  public void    setVBOUsage(boolean vboUsage) {
+    this.vboUsage=vboUsage;
+  }
+
+  public void    setVBOName(int vboName) {
+    this.vboName=vboName;
+    setVBOUsage(vboName>0);
+  }
+
+  protected void init(String name, int index, int comps, int dataType, boolean normalized, int stride, Buffer data, 
+                      boolean isVertexAttribute, 
+                      int vboName, long bufferOffset)
+    throws GLException
+  {
+    this.isVertexAttribute = isVertexAttribute;
+    this.index = index;
+    this.location = -1;
+    // We can't have any dependence on the FixedFuncUtil class here for build bootstrapping reasons
+    this.name = (null==name)?FixedFuncPipeline.getPredefinedArrayIndexName(index):name;
+    if(null==this.name) {
+        throw new GLException("Not a valid GL array index: "+index);
+    }
+    this.dataType = dataType;
+    this.clazz = getBufferClass(dataType);
+    switch(dataType) {
+        case GL.GL_BYTE:
+        case GL.GL_UNSIGNED_BYTE:
+        case GL.GL_SHORT:
+        case GL.GL_UNSIGNED_SHORT:
+        case GL2ES1.GL_FIXED:
+            this.normalized = normalized;
+            break;
+        default:    
+            this.normalized = false;
+    }
+
+    int bpc = getComponentSize();
+    if(0<stride && stride<comps*bpc) {
+        throw new GLException("stride ("+stride+") lower than component bytes, "+comps+" * "+bpc);
+    }
+    if(0<stride && stride%bpc!=0) {
+        throw new GLException("stride ("+stride+") not a multiple of bpc "+bpc);
+    }
+    this.buffer = data;
+    this.components = comps;
+    this.stride=stride;
+    this.strideB=(0==stride)?comps*bpc:stride;
+    this.strideL=(0==stride)?comps:strideB/bpc;
+    this.vboName=vboName;
+    this.vboUsage=vboName>0;
+    this.bufferOffset=bufferOffset;
+  }
+
+  protected GLArrayDataWrapper() { }
+
+  protected int index;
+  protected int location;
+  protected String name;
+  protected int components;
+  protected int dataType;
+  protected boolean normalized;
+  protected int stride;  // user given stride
+  protected int strideB; // stride in bytes
+  protected int strideL; // stride in logical components
+  protected Class clazz;
+  protected Buffer buffer;
+  protected boolean isVertexAttribute;
+
+  protected long bufferOffset;
+  protected int vboName;
+  protected boolean vboUsage;
+}
+
diff --git a/src/jogl/classes/com/jogamp/opengl/util/GLArrayHandler.java b/src/jogl/classes/com/jogamp/opengl/util/GLArrayHandler.java
new file mode 100644
index 000000000..bfabb5b01
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/GLArrayHandler.java
@@ -0,0 +1,11 @@
+
+package com.jogamp.opengl.util;
+
+import javax.media.opengl.*;
+
+public interface GLArrayHandler {
+
+  public void enableBuffer(GL gl, boolean enable);
+
+}
+
diff --git a/src/jogl/classes/com/jogamp/opengl/util/GLFixedArrayHandler.java b/src/jogl/classes/com/jogamp/opengl/util/GLFixedArrayHandler.java
new file mode 100644
index 000000000..f0f5ea896
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/GLFixedArrayHandler.java
@@ -0,0 +1,65 @@
+
+package com.jogamp.opengl.util;
+
+import javax.media.opengl.*;
+import javax.media.opengl.fixedfunc.*;
+import com.jogamp.opengl.util.*;
+import java.nio.*;
+
+public class GLFixedArrayHandler implements GLArrayHandler {
+  private GLArrayDataEditable ad;
+
+  public GLFixedArrayHandler(GLArrayDataEditable ad) {
+    this.ad = ad;
+  }
+
+  protected final void passArrayPointer(GLPointerFunc gl) {
+    switch(ad.getIndex()) {
+        case GLPointerFunc.GL_VERTEX_ARRAY:
+            gl.glVertexPointer(ad);
+            break;
+        case GLPointerFunc.GL_NORMAL_ARRAY:
+            gl.glNormalPointer(ad);
+            break;
+        case GLPointerFunc.GL_COLOR_ARRAY:
+            gl.glColorPointer(ad);
+            break;
+        case GLPointerFunc.GL_TEXTURE_COORD_ARRAY:
+            gl.glTexCoordPointer(ad);
+            break;
+        default:
+            throw new GLException("invalid glArrayIndex: "+ad.getIndex()+":\n\t"+ad); 
+    }
+  }
+
+  public void enableBuffer(GL gl, boolean enable) {
+    GLPointerFunc glp = gl.getGL2ES1();
+    if(enable) {
+        glp.glEnableClientState(ad.getIndex());
+
+        Buffer buffer = ad.getBuffer();
+
+        if(ad.isVBO()) {
+            // always bind and refresh the VBO mgr, 
+            // in case more than one gl*Pointer objects are in use
+            gl.glBindBuffer(GL.GL_ARRAY_BUFFER, ad.getVBOName());
+            if(!ad.isBufferWritten()) {
+                if(null!=buffer) {
+                    gl.glBufferData(GL.GL_ARRAY_BUFFER, buffer.limit() * ad.getComponentSize(), buffer, ad.getBufferUsage());
+                }
+                ad.setBufferWritten(true);
+            }
+            passArrayPointer(glp);
+        } else if(null!=buffer) {
+            passArrayPointer(glp);
+            ad.setBufferWritten(true);
+        }
+    } else {
+        if(ad.isVBO()) {
+            gl.glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
+        }
+        glp.glDisableClientState(ad.getIndex());
+    }
+  }
+}
+
diff --git a/src/jogl/classes/com/jogamp/opengl/util/Gamma.java b/src/jogl/classes/com/jogamp/opengl/util/Gamma.java
new file mode 100755
index 000000000..672325cf3
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/Gamma.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2005 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util;
+
+import javax.media.opengl.*;
+import com.jogamp.opengl.impl.*;
+
+/** Provides control over the primary display's gamma, brightness and
+    contrast controls via the hardware gamma ramp tables. Not
+    supported on all platforms or graphics hardware. <P>
+
+    Thanks to the LWJGL project for illustrating how to access gamma
+    control on the various platforms.
+*/
+
+public class Gamma {
+  private Gamma() {}
+
+  /**
+   * Sets the gamma, brightness, and contrast of the current main
+   * display. This functionality is not available on all platforms and
+   * graphics hardware. Returns true if the settings were successfully
+   * changed, false if not. This method may return false for some
+   * values of the incoming arguments even on hardware which does
+   * support the underlying functionality. <P>
+   *
+   * If this method returns true, the display settings will
+   * automatically be reset to their original values upon JVM exit
+   * (assuming the JVM does not crash); if the user wishes to change
+   * the display settings back to normal ahead of time, use {@link
+   * #resetDisplayGamma resetDisplayGamma}(). It is recommended to
+   * call {@link #resetDisplayGamma resetDisplayGamma} before calling
+   * e.g. <code>System.exit()</code> from the application rather than
+   * rely on the shutdown hook functionality due to inevitable race
+   * conditions and unspecified behavior during JVM teardown. <P>
+   *
+   * This method may be called multiple times during the application's
+   * execution, but calling {@link #resetDisplayGamma
+   * resetDisplayGamma} will only reset the settings to the values
+   * before the first call to this method. <P>
+   *
+   * @param gamma The gamma value, typically > 1.0 (default values
+   *   vary, but typically roughly 1.0)
+   * @param brightness The brightness value between -1.0 and 1.0,
+   *   inclusive (default values vary, but typically 0)
+   * @param contrast The contrast, greater than 0.0 (default values
+   *   vary, but typically 1)
+   * @return true if gamma settings were successfully changed, false
+   *   if not
+   * @throws IllegalArgumentException if any of the parameters were
+   *   out-of-bounds
+   */
+  public static boolean setDisplayGamma(GL gl, float gamma, float brightness, float contrast) throws IllegalArgumentException {
+    return GLDrawableFactoryImpl.getFactoryImpl(gl.getContext().getGLDrawable().getGLProfile()).setDisplayGamma(gamma, brightness, contrast);
+  }
+
+  /**
+   * Resets the gamma, brightness and contrast values for the primary
+   * display to their original values before {@link #setDisplayGamma
+   * setDisplayGamma} was called the first time. {@link
+   * #setDisplayGamma setDisplayGamma} must be called before calling
+   * this method or an unspecified exception will be thrown. While it
+   * is not explicitly required that this method be called before
+   * exiting, calling it is recommended because of the inevitable
+   * unspecified behavior during JVM teardown.
+   */
+  public static void resetDisplayGamma(GL gl) {
+    GLDrawableFactoryImpl.getFactoryImpl(gl.getContext().getGLDrawable().getGLProfile()).resetDisplayGamma();
+  }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/ImmModeSink.java b/src/jogl/classes/com/jogamp/opengl/util/ImmModeSink.java
new file mode 100644
index 000000000..98249184d
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/ImmModeSink.java
@@ -0,0 +1,974 @@
+
+package com.jogamp.opengl.util;
+
+import javax.media.opengl.*;
+import javax.media.opengl.fixedfunc.*;
+import com.sun.nativewindow.impl.NWReflection;
+import java.nio.*;
+import java.util.Iterator;
+import java.util.ArrayList;
+
+public class ImmModeSink {
+
+  public static final boolean DEBUG_BEGIN_END = false;
+  public static final boolean DEBUG_DRAW = false;
+
+  // public static final int GL_QUADS      = 0x0007; // Needs data manipulation
+  public static final int GL_QUAD_STRIP = 0x0008;
+  public static final int GL_POLYGON    = 0x0009;
+
+  /**
+   * Uses a GL2ES1, or ES2 fixed function emulation immediate mode sink
+   */
+  public static ImmModeSink createFixed(GL gl, int glBufferUsage, int initialSize,
+                                        int vComps, int vDataType,
+                                        int cComps, int cDataType, 
+                                        int nComps, int nDataType, 
+                                        int tComps, int tDataType) {
+    return new ImmModeSink(gl, glBufferUsage, initialSize, 
+                           vComps, vDataType, cComps, cDataType, nComps, nDataType, tComps, tDataType, false);
+  }
+
+  /**
+   * Uses a GL2ES2 GLSL shader immediate mode sink.
+   * To issue the draw() command,
+   * a ShaderState must be current, using ShaderState.glUseProgram().
+   *
+   * @see #draw(GL, boolean)
+   * @see javax.media.opengl.glsl.ShaderState#glUseProgram(GL2ES2, boolean)
+   * @see javax.media.opengl.glsl.ShaderState#getCurrent()
+   */
+  public static ImmModeSink createGLSL(GL gl, int glBufferUsage, int initialSize,
+                                       int vComps, int vDataType,
+                                       int cComps, int cDataType, 
+                                       int nComps, int nDataType, 
+                                       int tComps, int tDataType) {
+    return new ImmModeSink(gl, glBufferUsage, initialSize, 
+                           vComps, vDataType, cComps, cDataType, nComps, nDataType, tComps, tDataType, true);
+  }
+
+  public static boolean usesVBO() { return vboUsage; }
+
+  public static void setVBOUsage(boolean v) { vboUsage = v; }
+
+  public void destroy(GL gl) {
+    destroyList(gl);
+
+    vboSet.destroy(gl);
+  }
+
+  public void reset() {
+    reset(null);
+  }
+
+  public void reset(GL gl) {
+    destroyList(gl);
+    vboSet.reset(gl);
+  }
+
+  public String toString() {
+    StringBuffer sb = new StringBuffer("ImmModeSink[");
+    sb.append(",\n\tVBO list: "+vboSetList.size()+" [");
+    for(Iterator i=vboSetList.iterator(); i.hasNext() ; ) {
+        sb.append("\n\t");
+        sb.append( (VBOSet)i.next() );
+    }
+    if(vboSetList.size()>0) {
+        sb.append("\n\t],\nVBO current: NOP]");
+    } else {
+        sb.append("\n\t],\nVBO current: \n");
+        sb.append(vboSet);
+        sb.append("\n]");
+    }
+    return sb.toString();
+  }
+
+  public void draw(GL gl, boolean disableBufferAfterDraw) {
+    if(DEBUG_DRAW) {
+        Exception e = new Exception("ImmModeSink.draw(disableBufferAfterDraw: "+disableBufferAfterDraw+"):\n\t"+this);
+        e.printStackTrace();
+    }
+    int n=0;
+    for(Iterator i=vboSetList.iterator(); i.hasNext() ; n++) {
+        ((VBOSet)i.next()).draw(gl, null, disableBufferAfterDraw, n);
+    }
+  }
+
+  public void draw(GL gl, Buffer indices, boolean disableBufferAfterDraw) {
+    if(DEBUG_DRAW) {
+        Exception e = new Exception("ImmModeSink.draw(disableBufferAfterDraw: "+disableBufferAfterDraw+"):\n\t"+this);
+        e.printStackTrace();
+    }
+    int n=0;
+    for(Iterator i=vboSetList.iterator(); i.hasNext() ; n++) {
+        ((VBOSet)i.next()).draw(gl, indices, disableBufferAfterDraw, n);
+    }
+  }
+
+  public void glBegin(int mode) {
+    if(DEBUG_BEGIN_END) {
+        Exception e = new Exception("ImmModeSink.glBegin("+vboSet.mode+"):\n\t"+this);
+        e.printStackTrace();
+    }
+    vboSet.modeOrig = mode;
+    switch(mode) {
+        // Needs data manipulation ..
+        //case GL_QUADS:
+        //    mode=GL.GL_LINES;
+        //    break;
+        case GL_QUAD_STRIP:
+            mode=GL.GL_TRIANGLE_STRIP;
+            break;
+        case GL_POLYGON:
+            mode=GL.GL_LINES;
+            break;
+    }
+    vboSet.mode = mode;
+    vboSet.checkSeal(false);
+  }
+
+  public final void glEnd(GL gl) {
+      glEnd(gl, null, true);
+  }
+
+  public void glEnd(GL gl, boolean immediateDraw) {
+      glEnd(gl, null, immediateDraw);
+  }
+
+  public final void glEnd(GL gl, Buffer indices) {
+      glEnd(gl, indices, true);
+  }
+
+  private void glEnd(GL gl, Buffer indices, boolean immediateDraw) {
+    if(DEBUG_BEGIN_END) {
+        Exception e = new Exception("ImmModeSink START glEnd(immediate: "+immediateDraw+"):\n\t"+this);
+        e.printStackTrace();
+    }
+    if(immediateDraw) {
+        vboSet.seal(gl, true);
+        vboSet.draw(gl, indices, true, -1);
+        reset(gl);
+    } else {
+        vboSet.seal(gl, true);
+        vboSet.enableBuffer(gl, false);
+        vboSetList.add(vboSet);
+        vboSet = vboSet.regenerate();
+    }
+  }
+
+  public void glVertexv(Buffer v) {
+    vboSet.glVertexv(v);
+  }
+  public void glNormalv(Buffer v) {
+    vboSet.glNormalv(v);
+  }
+  public void glColorv(Buffer v) {
+    vboSet.glColorv(v);
+  }
+  public void glTexCoordv(Buffer v) {
+    vboSet.glTexCoordv(v);
+  }
+
+  public final void glVertex2f(float x, float y) {
+    vboSet.glVertex2f(x,y);
+  }
+
+  public final void glVertex3f(float x, float y, float z) {
+    vboSet.glVertex3f(x,y,z);
+  }
+
+  public final void glNormal3f(float x, float y, float z) {
+    vboSet.glNormal3f(x,y,z);
+  }
+
+  public final void glColor3f(float x, float y, float z) {
+    vboSet.glColor3f(x,y,z);
+  }
+
+  public final void glColor4f(float x, float y, float z, float a) {
+    vboSet.glColor4f(x,y,z, a);
+  }
+
+  public final void glTexCoord2f(float x, float y) {
+    vboSet.glTexCoord2f(x,y);
+  }
+
+  public final void glTexCoord3f(float x, float y, float z) {
+    vboSet.glTexCoord3f(x,y,z);
+  }
+
+  public final void glVertex2s(short x, short y) {
+    vboSet.glVertex2s(x,y);
+  }
+
+  public final void glVertex3s(short x, short y, short z) {
+    vboSet.glVertex3s(x,y,z);
+  }
+
+  public final void glNormal3s(short x, short y, short z) {
+    vboSet.glNormal3s(x,y,z);
+  }
+
+  public final void glColor3s(short x, short y, short z) {
+    vboSet.glColor3s(x,y,z);
+  }
+
+  public final void glColor4s(short x, short y, short z, short a) {
+    vboSet.glColor4s(x,y,z,a);
+  }
+
+  public final void glTexCoord2s(short x, short y) {
+    vboSet.glTexCoord2s(x,y);
+  }
+
+  public final void glTexCoord3s(short x, short y, short z) {
+    vboSet.glTexCoord3s(x,y,z);
+  }
+
+  public final void glVertex2b(byte x, byte y) {
+    vboSet.glVertex2b(x,y);
+  }
+
+  public final void glVertex3b(byte x, byte y, byte z) {
+    vboSet.glVertex3b(x,y,z);
+  }
+
+  public final void glNormal3b(byte x, byte y, byte z) {
+    vboSet.glNormal3b(x,y,z);
+  }
+
+  public final void glColor3b(byte x, byte y, byte z) {
+    vboSet.glColor3b(x,y,z);
+  }
+
+  public final void glColor4b(byte x, byte y, byte z, byte a) {
+    vboSet.glColor4b(x,y,z,a);
+  }
+
+  public final void glTexCoord2b(byte x, byte y) {
+    vboSet.glTexCoord2b(x,y);
+  }
+
+  public final void glTexCoord3b(byte x, byte y, byte z) {
+    vboSet.glTexCoord3b(x,y,z);
+  }
+
+  protected ImmModeSink(GL gl, int glBufferUsage, int initialSize,
+                        int vComps, int vDataType,
+                        int cComps, int cDataType, 
+                        int nComps, int nDataType, 
+                        int tComps, int tDataType, boolean useGLSL) {
+    if(useGLSL && !gl.hasGLSL()) {
+        throw new GLException("ImmModeSink GLSL usage not supported: "+gl);
+    }
+    vboSet = new  VBOSet(gl, glBufferUsage, initialSize, 
+                         vComps, vDataType, cComps, cDataType, nComps, nDataType, tComps, tDataType, useGLSL);
+    this.vboSetList   = new ArrayList();
+  }
+
+  private void destroyList(GL gl) {
+    for(Iterator i=vboSetList.iterator(); i.hasNext() ; ) {
+        ((VBOSet)i.next()).destroy(gl);
+    }
+    vboSetList.clear();
+  }
+
+  private VBOSet vboSet;
+  private ArrayList vboSetList;
+  private static boolean vboUsage = true;
+
+  protected static class VBOSet {
+    protected VBOSet (GL gl, int glBufferUsage, int initialSize,
+                      int vComps, int vDataType,
+                      int cComps, int cDataType, 
+                      int nComps, int nDataType, 
+                      int tComps, int tDataType, boolean useGLSL) {
+        this.gl=gl;
+        this.glBufferUsage=glBufferUsage;
+        this.initialSize=initialSize;
+        this.vDataType=vDataType;
+        this.vComps=vComps;
+        this.cDataType=cDataType;
+        this.cComps=cComps;
+        this.nDataType=nDataType;
+        this.nComps=nComps;
+        this.tDataType=tDataType;
+        this.tComps=tComps;
+        this.useGLSL=useGLSL;
+
+        allocateBuffer(initialSize);
+        rewind();
+
+        this.sealed=false;
+        this.sealedGL=false;
+        this.mode = -1;
+        this.modeOrig = -1;
+        this.bufferEnabled=false;
+        this.bufferWritten=false;
+    }
+
+    protected final VBOSet regenerate() {
+        return new VBOSet(gl, glBufferUsage, initialSize, 
+                          vComps, vDataType, cComps, cDataType, nComps, nDataType, tComps, tDataType, useGLSL);
+    }
+
+    protected void checkSeal(boolean test) throws GLException {
+        if(mode<0) {
+                throw new GLException("No mode set yet, call glBegin(mode) first:\n\t"+this); 
+        }
+        if(sealed!=test) {
+            if(test) {
+                throw new GLException("Not Sealed yet, call glEnd() first:\n\t"+this); 
+            } else {
+                throw new GLException("Already Sealed, can't modify VBO after glEnd():\n\t"+this); 
+            }
+        }
+    }
+
+    protected void draw(GL gl, Buffer indices, boolean disableBufferAfterDraw, int i)
+    {
+        if(DEBUG_DRAW) {
+            Exception e = new Exception("ImmModeSink.draw["+i+"](disableBufferAfterDraw: "+disableBufferAfterDraw+"):\n\t"+this);
+            e.printStackTrace();
+        }
+        enableBuffer(gl, true);
+
+        if (buffer!=null) {
+            GL2ES1 glf = gl.getGL2ES1();
+
+            if(null==indices) {
+                glf.glDrawArrays(mode, 0, count);
+            } else {
+                Class clazz = indices.getClass();
+                int type=-1;
+                if(NWReflection.instanceOf(clazz, ByteBuffer.class.getName())) {
+                    type =  GL.GL_UNSIGNED_BYTE;
+                } else if(NWReflection.instanceOf(clazz, ShortBuffer.class.getName())) {
+                    type =  GL.GL_UNSIGNED_SHORT;
+                }
+                if(0>type) {
+                    throw new GLException("Given Buffer Class not supported: "+clazz+", should be ubyte or ushort:\n\t"+this);
+                }
+                glf.glDrawElements(mode, indices.remaining(), type, indices);
+                // GL2: gl.glDrawRangeElements(mode, 0, indices.remaining()-1, indices.remaining(), type, indices);
+            }
+        }
+
+        if(disableBufferAfterDraw) {
+            enableBuffer(gl, false);
+        }
+    }
+
+    public void glVertexv(Buffer v) {
+        checkSeal(false);
+        BufferUtil.put(vertexArray, v);
+    }
+    public void glNormalv(Buffer v) {
+        checkSeal(false);
+        BufferUtil.put(normalArray, v);
+    }
+    public void glColorv(Buffer v) {
+        checkSeal(false);
+        BufferUtil.put(colorArray, v);
+    }
+    public void glTexCoordv(Buffer v) {
+        checkSeal(false);
+        BufferUtil.put(textCoordArray, v);
+    }
+
+    public void glVertex2b(byte x, byte y) {
+        checkSeal(false);
+        growBufferIfNecessary(VERTEX, 2);
+        if(vComps>0) 
+            BufferUtil.putb(vertexArray, x);
+        if(vComps>1) 
+            BufferUtil.putb(vertexArray, y);
+        padding(VERTEX, vComps-2);
+    }
+    public void glVertex3b(byte x, byte y, byte z) {
+        checkSeal(false);
+        growBufferIfNecessary(VERTEX, 3);
+        if(vComps>0) 
+            BufferUtil.putb(vertexArray, x);
+        if(vComps>1) 
+            BufferUtil.putb(vertexArray, y);
+        if(vComps>2) 
+            BufferUtil.putb(vertexArray, z);
+        padding(VERTEX, vComps-3);
+    }
+    public void glVertex2s(short x, short y) {
+        checkSeal(false);
+        growBufferIfNecessary(VERTEX, 2);
+        if(vComps>0) 
+            BufferUtil.puts(vertexArray, x);
+        if(vComps>1) 
+            BufferUtil.puts(vertexArray, y);
+        padding(VERTEX, vComps-2);
+    }
+    public void glVertex3s(short x, short y, short z) {
+        checkSeal(false);
+        growBufferIfNecessary(VERTEX, 3);
+        if(vComps>0) 
+            BufferUtil.puts(vertexArray, x);
+        if(vComps>1) 
+            BufferUtil.puts(vertexArray, y);
+        if(vComps>2) 
+            BufferUtil.puts(vertexArray, z);
+        padding(VERTEX, vComps-3);
+    }
+    public void glVertex2f(float x, float y) {
+        checkSeal(false);
+        growBufferIfNecessary(VERTEX, 2);
+        if(vComps>0) 
+            BufferUtil.putf(vertexArray, x);
+        if(vComps>1) 
+            BufferUtil.putf(vertexArray, y);
+        padding(VERTEX, vComps-2);
+    }
+    public void glVertex3f(float x, float y, float z) {
+        checkSeal(false);
+        growBufferIfNecessary(VERTEX, 3);
+        if(vComps>0) 
+            BufferUtil.putf(vertexArray, x);
+        if(vComps>1) 
+            BufferUtil.putf(vertexArray, y);
+        if(vComps>2) 
+            BufferUtil.putf(vertexArray, z);
+        padding(VERTEX, vComps-3);
+    }
+
+    public void glNormal3b(byte x, byte y, byte z) {
+        checkSeal(false);
+        growBufferIfNecessary(NORMAL, 3);
+        if(nComps>0) 
+            BufferUtil.putb(normalArray, x);
+        if(nComps>1) 
+            BufferUtil.putb(normalArray, y);
+        if(nComps>2) 
+            BufferUtil.putb(normalArray, z);
+        padding(NORMAL, nComps-3);
+    }
+    public void glNormal3s(short x, short y, short z) {
+        checkSeal(false);
+        growBufferIfNecessary(NORMAL, 3);
+        if(nComps>0) 
+            BufferUtil.puts(normalArray, x);
+        if(nComps>1) 
+            BufferUtil.puts(normalArray, y);
+        if(nComps>2) 
+            BufferUtil.puts(normalArray, z);
+        padding(NORMAL, nComps-3);
+    }
+    public void glNormal3f(float x, float y, float z) {
+        checkSeal(false);
+        growBufferIfNecessary(NORMAL, 3);
+        if(nComps>0) 
+            BufferUtil.putf(normalArray, x);
+        if(nComps>1) 
+            BufferUtil.putf(normalArray, y);
+        if(nComps>2) 
+            BufferUtil.putf(normalArray, z);
+        padding(NORMAL, nComps-3);
+    }
+
+    public void glColor3b(byte r, byte g, byte b) {
+        checkSeal(false);
+        growBufferIfNecessary(COLOR, 3);
+        if(cComps>0) 
+            BufferUtil.putb(colorArray, r);
+        if(cComps>1) 
+            BufferUtil.putb(colorArray, g);
+        if(cComps>2) 
+            BufferUtil.putb(colorArray, b);
+        padding(COLOR, cComps-3);
+    }
+    public void glColor4b(byte r, byte g, byte b, byte a) {
+        checkSeal(false);
+        growBufferIfNecessary(COLOR, 4);
+        if(cComps>0) 
+            BufferUtil.putb(colorArray, r);
+        if(cComps>1) 
+            BufferUtil.putb(colorArray, g);
+        if(cComps>2) 
+            BufferUtil.putb(colorArray, b);
+        if(cComps>3) 
+            BufferUtil.putb(colorArray, a);
+        padding(COLOR, cComps-4);
+    }
+    public void glColor3s(short r, short g, short b) {
+        checkSeal(false);
+        growBufferIfNecessary(COLOR, 3);
+        if(cComps>0) 
+            BufferUtil.puts(colorArray, r);
+        if(cComps>1) 
+            BufferUtil.puts(colorArray, g);
+        if(cComps>2) 
+            BufferUtil.puts(colorArray, b);
+        padding(COLOR, cComps-3);
+    }
+    public void glColor4s(short r, short g, short b, short a) {
+        checkSeal(false);
+        growBufferIfNecessary(COLOR, 4);
+        if(cComps>0) 
+            BufferUtil.puts(colorArray, r);
+        if(cComps>1) 
+            BufferUtil.puts(colorArray, g);
+        if(cComps>2) 
+            BufferUtil.puts(colorArray, b);
+        if(cComps>3) 
+            BufferUtil.puts(colorArray, a);
+        padding(COLOR, cComps-4);
+    }
+    public void glColor3f(float r, float g, float b) {
+        checkSeal(false);
+        growBufferIfNecessary(COLOR, 3);
+        if(cComps>0) 
+            BufferUtil.putf(colorArray, r);
+        if(cComps>1) 
+            BufferUtil.putf(colorArray, g);
+        if(cComps>2) 
+            BufferUtil.putf(colorArray, b);
+        padding(COLOR, cComps-3);
+    }
+    public void glColor4f(float r, float g, float b, float a) {
+        checkSeal(false);
+        growBufferIfNecessary(COLOR, 4);
+        if(cComps>0) 
+            BufferUtil.putf(colorArray, r);
+        if(cComps>1) 
+            BufferUtil.putf(colorArray, g);
+        if(cComps>2) 
+            BufferUtil.putf(colorArray, b);
+        if(cComps>3) 
+            BufferUtil.putf(colorArray, a);
+        padding(COLOR, cComps-4);
+    }
+
+    public void glTexCoord2b(byte x, byte y) {
+        checkSeal(false);
+        growBufferIfNecessary(TEXTCOORD, 2);
+        if(tComps>0) 
+            BufferUtil.putb(textCoordArray, x);
+        if(tComps>1) 
+            BufferUtil.putb(textCoordArray, y);
+        padding(TEXTCOORD, tComps-2);
+    }
+    public void glTexCoord3b(byte x, byte y, byte z) {
+        checkSeal(false);
+        growBufferIfNecessary(TEXTCOORD, 3);
+        if(tComps>0) 
+            BufferUtil.putb(textCoordArray, x);
+        if(tComps>1) 
+            BufferUtil.putb(textCoordArray, y);
+        if(tComps>2) 
+            BufferUtil.putb(textCoordArray, z);
+        padding(TEXTCOORD, tComps-3);
+    }
+    public void glTexCoord2s(short x, short y) {
+        checkSeal(false);
+        growBufferIfNecessary(TEXTCOORD, 2);
+        if(tComps>0) 
+            BufferUtil.puts(textCoordArray, x);
+        if(tComps>1) 
+            BufferUtil.puts(textCoordArray, y);
+        padding(TEXTCOORD, tComps-2);
+    }
+    public void glTexCoord3s(short x, short y, short z) {
+        checkSeal(false);
+        growBufferIfNecessary(TEXTCOORD, 3);
+        if(tComps>0) 
+            BufferUtil.puts(textCoordArray, x);
+        if(tComps>1) 
+            BufferUtil.puts(textCoordArray, y);
+        if(tComps>2) 
+            BufferUtil.puts(textCoordArray, z);
+        padding(TEXTCOORD, tComps-3);
+    }
+    public void glTexCoord2f(float x, float y) {
+        checkSeal(false);
+        growBufferIfNecessary(TEXTCOORD, 2);
+        if(tComps>0) 
+            BufferUtil.putf(textCoordArray, x);
+        if(tComps>1) 
+            BufferUtil.putf(textCoordArray, y);
+        padding(TEXTCOORD, tComps-2);
+    }
+    public void glTexCoord3f(float x, float y, float z) {
+        checkSeal(false);
+        growBufferIfNecessary(TEXTCOORD, 3);
+        if(tComps>0) 
+            BufferUtil.putf(textCoordArray, x);
+        if(tComps>1) 
+            BufferUtil.putf(textCoordArray, y);
+        if(tComps>2) 
+            BufferUtil.putf(textCoordArray, z);
+        padding(TEXTCOORD, tComps-3);
+    }
+
+    public void rewind() {
+        if(null!=vertexArray) {
+            vertexArray.rewind();
+        }
+        if(null!=colorArray) {
+            colorArray.rewind();
+        }
+        if(null!=normalArray) {
+            normalArray.rewind();
+        }
+        if(null!=textCoordArray) {
+            textCoordArray.rewind();
+        }
+    }
+
+    public void destroy(GL gl) {
+        reset(gl);
+
+        vertexArray=null; colorArray=null; normalArray=null; textCoordArray=null;
+        vArrayData=null; cArrayData=null; nArrayData=null; tArrayData=null;
+        buffer=null;
+        bSize=0; count=0;
+    }
+
+    public void reset(GL gl) {
+        enableBuffer(gl, false);
+        reset();
+    }
+
+    public void reset() {
+        if(buffer!=null) {
+            buffer.clear();
+        }
+        rewind();
+
+        this.mode = -1;
+        this.modeOrig = -1;
+        this.sealed=false;
+        this.bufferEnabled=false;
+        this.bufferWritten=false;
+    }
+
+    public void seal(GL glObj, boolean seal)
+    {
+        seal(seal);
+        if(sealedGL==seal) return;
+        sealedGL = seal;
+        GL gl = glObj.getGL();
+        if(seal) {
+            if(vboUsage && vboName==0) {
+                int[] tmp = new int[1];
+                gl.glGenBuffers(1, tmp, 0);
+                vboName = tmp[0];
+            }
+            if(null!=vArrayData)
+                vArrayData.setVBOName(vboName);
+            if(null!=cArrayData)
+                cArrayData.setVBOName(vboName);
+            if(null!=nArrayData)
+                nArrayData.setVBOName(vboName);
+            if(null!=tArrayData)
+                tArrayData.setVBOName(vboName);
+            enableBuffer(gl, true);
+        } else {
+            enableBuffer(gl, false);
+        }
+    }
+
+    public void seal(boolean seal)
+    {
+        if(sealed==seal) return;
+        sealed = seal;
+        if(seal) {
+            bufferWritten=false;
+        }
+    }
+
+  public void enableBuffer(GL gl, boolean enable) {
+    /* if(enableBufferAlways && enable) {
+        bufferEnabled = false;
+    } */
+    if( bufferEnabled != enable && count>0 ) {
+        if(enable) {
+            checkSeal(true);
+        }
+        if(useGLSL) { 
+            enableBufferGLSL(gl, enable);
+        } else {
+            enableBufferFixed(gl, enable);
+        }
+        bufferEnabled = enable;
+    }
+  }
+
+  public void enableBufferFixed(GL gl, boolean enable) {
+    GL2ES1 glf = gl.getGL2ES1();
+
+    if(enable) {
+        gl.glBindBuffer(GL.GL_ARRAY_BUFFER, vboName);
+
+        if(!bufferWritten) {
+            gl.glBufferData(GL.GL_ARRAY_BUFFER, buffer.limit(), buffer, GL.GL_STATIC_DRAW);
+            bufferWritten=true;
+        }
+
+        if(vComps>0) {
+           glf.glEnableClientState(glf.GL_VERTEX_ARRAY);
+           glf.glVertexPointer(vArrayData);
+        }
+        if(cComps>0) {
+           glf.glEnableClientState(glf.GL_COLOR_ARRAY);
+           glf.glColorPointer(cArrayData);
+        }
+        if(nComps>0) {
+           glf.glEnableClientState(glf.GL_NORMAL_ARRAY);
+           glf.glNormalPointer(nArrayData);
+        }
+        if(tComps>0) {
+           glf.glEnableClientState(glf.GL_TEXTURE_COORD_ARRAY);
+           glf.glTexCoordPointer(tArrayData);
+        }
+
+        gl.glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
+    } else {
+        if(vComps>0) {
+           glf.glDisableClientState(glf.GL_VERTEX_ARRAY);
+        }
+        if(cComps>0) {
+           glf.glDisableClientState(glf.GL_COLOR_ARRAY);
+        }
+        if(nComps>0) {
+           glf.glDisableClientState(glf.GL_NORMAL_ARRAY);
+        }
+        if(tComps>0) {
+           glf.glDisableClientState(glf.GL_TEXTURE_COORD_ARRAY);
+        }
+    }
+  }
+
+  public void enableBufferGLSL(GL gl, boolean enable) {
+    GL2ES2 glsl = gl.getGL2ES2();
+    com.jogamp.opengl.util.glsl.ShaderState st = com.jogamp.opengl.util.glsl.ShaderState.getCurrent();
+    if(null==st) {
+        throw new GLException("No ShaderState current");
+    }
+ 
+    if(enable) {
+        glsl.glBindBuffer(GL.GL_ARRAY_BUFFER, vboName);
+
+        if(!bufferWritten) {
+            glsl.glBufferData(GL.GL_ARRAY_BUFFER, buffer.limit(), buffer, GL.GL_STATIC_DRAW);
+            bufferWritten=true;
+        }
+
+        if(vComps>0) {
+           st.glEnableVertexAttribArray(glsl, vArrayData.getName());
+           st.glVertexAttribPointer(glsl, vArrayData);
+        }
+        if(cComps>0) {
+           st.glEnableVertexAttribArray(glsl, cArrayData.getName());
+           st.glVertexAttribPointer(glsl, cArrayData);
+        }
+        if(nComps>0) {
+           st.glEnableVertexAttribArray(glsl, nArrayData.getName());
+           st.glVertexAttribPointer(glsl, nArrayData);
+        }
+        if(tComps>0) {
+           st.glEnableVertexAttribArray(glsl, tArrayData.getName());
+           st.glVertexAttribPointer(glsl, tArrayData);
+        }
+
+        glsl.glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
+    } else {
+        if(vComps>0) {
+           st.glDisableVertexAttribArray(glsl, vArrayData.getName());
+        }
+        if(cComps>0) {
+           st.glDisableVertexAttribArray(glsl, cArrayData.getName());
+        }
+        if(nComps>0) {
+           st.glDisableVertexAttribArray(glsl, nArrayData.getName());
+        }
+        if(tComps>0) {
+           st.glDisableVertexAttribArray(glsl, tArrayData.getName());
+        }
+    }
+  }
+
+    public String toString() {
+        return "VBOSet[mode "+mode+ 
+                       ", modeOrig "+modeOrig+ 
+                       ", sealed "+sealed+ 
+                       ", bufferEnabled "+bufferEnabled+ 
+                       ", bufferWritten "+bufferWritten+ 
+                       ",\n\t"+vArrayData+
+                       ",\n\t"+cArrayData+
+                       ",\n\t"+nArrayData+
+                       ",\n\t"+tArrayData+
+                       "]";
+    }
+
+    // non public matters
+
+    protected void allocateBuffer(int elements) {
+        int vWidth = vComps * BufferUtil.sizeOfGLType(vDataType);
+        int cWidth = cComps * BufferUtil.sizeOfGLType(cDataType);
+        int nWidth = nComps * BufferUtil.sizeOfGLType(nDataType);
+        int tWidth = tComps * BufferUtil.sizeOfGLType(tDataType);
+
+        count  = elements;
+        bSize  = count * ( vWidth + cWidth + nWidth + tWidth ) ;
+
+        buffer = BufferUtil.newByteBuffer(bSize);
+
+        int pos = 0;
+        int size= count * vWidth ;
+        if(size>0) {
+            vertexArray = BufferUtil.sliceGLBuffer(buffer, pos, size, vDataType);
+        } else {
+            vertexArray = null;
+        }
+        vOffset = pos;
+        pos+=size;
+
+        size= count * cWidth ;
+        if(size>0) {
+            colorArray = BufferUtil.sliceGLBuffer(buffer, pos, size, cDataType);
+        } else {
+            colorArray = null;
+        }
+        cOffset = pos;
+        pos+=size;
+
+        size= count * nWidth ;
+        if(size>0) {
+            normalArray = BufferUtil.sliceGLBuffer(buffer, pos, size, nDataType);
+        } else {
+            normalArray = null;
+        }
+        nOffset = pos;
+        pos+=size;
+
+        size= count * tWidth ;
+        if(size>0) {
+            textCoordArray = BufferUtil.sliceGLBuffer(buffer, pos, size, tDataType);
+        } else {
+            textCoordArray = null;
+        }
+        tOffset = pos;
+        pos+=size;
+
+        buffer.position(pos);
+        buffer.flip();
+
+        if(vComps>0) {
+            vArrayData = GLArrayDataWrapper.createFixed(gl, GLPointerFunc.GL_VERTEX_ARRAY, vComps, vDataType, false,
+                                                        0, vertexArray, 0, vOffset);
+        } else {
+            vArrayData = null;
+        }
+        if(cComps>0) {
+            cArrayData = GLArrayDataWrapper.createFixed(gl, GLPointerFunc.GL_COLOR_ARRAY, cComps, cDataType, false,
+                                                        0, colorArray, 0, cOffset);
+        } else {
+            cArrayData = null;
+        }
+        if(nComps>0) {
+            nArrayData = GLArrayDataWrapper.createFixed(gl, GLPointerFunc.GL_NORMAL_ARRAY, nComps, nDataType, false,
+                                                        0, normalArray, 0, nOffset);
+        } else {
+            nArrayData = null;
+        }
+        if(tComps>0) {
+            tArrayData = GLArrayDataWrapper.createFixed(gl, GLPointerFunc.GL_TEXTURE_COORD_ARRAY, tComps, tDataType, false,
+                                                        0, textCoordArray, 0, tOffset);
+        } else {
+            tArrayData = null;
+        }
+
+    }
+
+    protected final boolean growBufferIfNecessary(int type, int spare) {
+        if(buffer==null || count < spare) { 
+            growBuffer(type, initialSize);
+            return true;
+        }
+        return false;
+    }
+
+    protected final void growBuffer(int type, int additional) {
+        if(sealed || 0==additional) return;
+
+        // save olde values ..
+        Buffer _vertexArray=vertexArray, _colorArray=colorArray, _normalArray=normalArray, _textCoordArray=textCoordArray;
+        ByteBuffer _buffer = buffer;
+
+        allocateBuffer(count+additional);
+
+        if(null!=_vertexArray) {
+            _vertexArray.flip();
+            BufferUtil.put(vertexArray, _vertexArray);
+        }
+        if(null!=_colorArray) {
+            _colorArray.flip();
+            BufferUtil.put(colorArray, _colorArray);
+        }
+        if(null!=_normalArray) {
+            _normalArray.flip();
+            BufferUtil.put(normalArray, _normalArray);
+        }
+        if(null!=_textCoordArray) {
+            _textCoordArray.flip();
+            BufferUtil.put(textCoordArray, _textCoordArray);
+        }
+    }
+
+    protected void padding(int type, int fill) {
+        if ( sealed ) return;
+
+        Buffer dest = null;
+
+        switch (type) {
+            case VERTEX:
+                dest = vertexArray;
+                break;
+            case COLOR:
+                dest = colorArray;
+                break;
+            case NORMAL:
+                dest = normalArray;
+                break;
+            case TEXTCOORD:
+                dest = textCoordArray;
+                break;
+        }
+
+        if ( null==dest ) return;
+
+        while((fill--)>0) {
+            BufferUtil.putb(dest, (byte)0);
+        }
+    }
+
+    protected int mode, modeOrig;
+    protected int glBufferUsage, initialSize;
+
+    protected ByteBuffer buffer;
+    protected int bSize, count, vboName;
+
+    public static final int VERTEX = 0;
+    public static final int COLOR = 1;
+    public static final int NORMAL = 2;
+    public static final int TEXTCOORD = 3;
+
+    protected int vOffset, cOffset, nOffset, tOffset;
+    protected int vComps,    cComps,    nComps,    tComps;
+    protected int vDataType, cDataType, nDataType, tDataType;
+    protected Buffer vertexArray, colorArray, normalArray, textCoordArray;
+    protected GLArrayDataWrapper vArrayData, cArrayData, nArrayData, tArrayData;
+
+    protected boolean sealed, sealedGL, useGLSL;
+    protected boolean bufferEnabled, bufferWritten;
+    protected GL gl;
+  }
+
+}
+
diff --git a/src/jogl/classes/com/jogamp/opengl/util/Locator.java b/src/jogl/classes/com/jogamp/opengl/util/Locator.java
new file mode 100644
index 000000000..c524c0888
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/Locator.java
@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) 2009 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ */
+
+package com.jogamp.opengl.util;
+
+import java.util.*;
+import java.nio.*;
+import java.io.*;
+import java.net.*;
+
+/** Utilities for dealing with resources. */
+
+public class Locator {
+    private Locator() {}
+
+    /**
+     * Locates the resource using 'getResource(String path, ClassLoader cl)',
+     * with this context ClassLoader and the path as is,
+     * as well with the context's package name path plus the path.
+     *
+     * @see #getResource(String, ClassLoader)
+     */
+    public static URL getResource(Class context, String path) {
+        ClassLoader contextCL = (null!=context)?context.getClassLoader():null;
+        URL url = getResource(path, contextCL);
+        if (url == null && null!=context) {
+            // Try again by scoping the path within the class's package
+            String className = context.getName().replace('.', '/');
+            int lastSlash = className.lastIndexOf('/');
+            if (lastSlash >= 0) {
+                String tmpPath = className.substring(0, lastSlash + 1) + path;
+                url = getResource(tmpPath, contextCL);
+            }
+        }
+        return url;
+    }
+
+    /**
+     * Locates the resource using the ClassLoader's facility,
+     * the absolute URL and absolute file.
+     *
+     * @see ClassLoader#getResource(String)
+     * @see ClassLoader#getSystemResource(String)
+     * @see URL#URL(String)
+     * @see File#File(String)
+     */
+    public static URL getResource(String path, ClassLoader cl) {
+        URL url = null;
+        if (cl != null) {
+            url = cl.getResource(path);
+        } else {
+            url = ClassLoader.getSystemResource(path);
+        }
+        if(!urlExists(url)) {
+            url = null;
+            try {
+                url = new URL(path);
+            } catch (MalformedURLException e) { }
+        }
+        if(!urlExists(url)) {
+            url = null;
+            try {
+                File file = new File(path);
+                if(file.exists()) {
+                    url = file.toURL();
+                }
+            } catch (MalformedURLException e) {}
+        }
+        return url;
+    }
+
+    /**
+     * Generates a path for the 'relativeFile' relative to the 'absoluteFileLocation'
+     */
+    public static String getRelativeOf(String absoluteFileLocation, String relativeFile) {
+        File file = new File(absoluteFileLocation);
+        file = file.getParentFile();
+        while (file != null && relativeFile.startsWith("../")) {
+            file = file.getParentFile();
+            relativeFile = relativeFile.substring(3);
+        }
+        if (file != null) {
+            String res = new File(file, relativeFile).getPath();
+	        // Handle things on Windows
+            return res.replace('\\', '/');
+        } else {
+            return relativeFile;
+        }
+    }
+
+    /**
+     * Returns true, if the url exists,
+     * trying to open a connection.
+     */
+    public static boolean urlExists(URL url) {
+        boolean v = false;
+        if(null!=url) {
+            try {
+                URLConnection uc = url.openConnection();
+                v = true;
+            } catch (IOException ioe) { }
+        }
+        return v;
+    }
+
+}
+
diff --git a/src/jogl/classes/com/jogamp/opengl/util/PMVMatrix.java b/src/jogl/classes/com/jogamp/opengl/util/PMVMatrix.java
new file mode 100755
index 000000000..9cf41804f
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/PMVMatrix.java
@@ -0,0 +1,685 @@
+/*
+ * Copyright (c) 2009 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ */
+
+package com.jogamp.opengl.util;
+
+import com.jogamp.opengl.impl.ProjectFloat;
+
+import java.nio.*;
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.media.opengl.*;
+import javax.media.opengl.fixedfunc.GLMatrixFunc;
+
+public class PMVMatrix implements GLMatrixFunc {
+
+    public PMVMatrix() {
+          projectFloat = new ProjectFloat();
+
+          matrixIdent = BufferUtil.newFloatBuffer(1*16);
+          projectFloat.gluMakeIdentityf(matrixIdent);
+          matrixIdent.rewind();
+
+          // T    Texture
+          // P    Projection
+          // Mv   ModelView
+          // Mvi  Modelview-Inverse
+          // Mvit Modelview-Inverse-Transpose
+          // Pmv  P * Mv
+          matrixTPMvMvitPmv = BufferUtil.newFloatBuffer(6*16);     // grouping T + P  + Mv + Mvi + Mvit + Pmv
+          matrixPMvMvitPmv = slice(matrixTPMvMvitPmv, 1*16, 5*16); // grouping     P  + Mv + Mvi + Mvit + Pmv
+          matrixT       = slice(matrixTPMvMvitPmv, 0*16, 1*16);    //          T
+          matrixPMvMvit = slice(matrixTPMvMvitPmv, 1*16, 4*16);    // grouping     P  + Mv + Mvi + Mvit
+          matrixPMvMvi  = slice(matrixTPMvMvitPmv, 1*16, 3*16);    // grouping     P  + Mv + Mvi
+          matrixPMv     = slice(matrixTPMvMvitPmv, 1*16, 2*16);    // grouping     P  + Mv
+          matrixP       = slice(matrixTPMvMvitPmv, 1*16, 1*16);    //              P
+          matrixMv      = slice(matrixTPMvMvitPmv, 2*16, 1*16);    //                   Mv
+          matrixMvi     = slice(matrixTPMvMvitPmv, 3*16, 1*16);    //                        Mvi
+          matrixMvit    = slice(matrixTPMvMvitPmv, 4*16, 1*16);    //                              Mvit
+          matrixPmv     = slice(matrixTPMvMvitPmv, 5*16, 1*16);    //                                     Pmv
+          matrixTPMvMvitPmv.rewind();
+
+          matrixMvit3 = BufferUtil.newFloatBuffer(3*3);
+
+          localBuf = BufferUtil.newFloatBuffer(6*16);
+
+          matrixMult=slice(localBuf, 0*16, 16);
+
+          matrixTrans=slice(localBuf, 1*16, 16);
+          projectFloat.gluMakeIdentityf(matrixTrans);
+
+          matrixRot=slice(localBuf, 2*16, 16);
+          projectFloat.gluMakeIdentityf(matrixRot);
+
+          matrixScale=slice(localBuf, 3*16, 16);
+          projectFloat.gluMakeIdentityf(matrixScale);
+
+          matrixOrtho=slice(localBuf, 4*16, 16);
+          projectFloat.gluMakeIdentityf(matrixOrtho);
+
+          matrixFrustum=slice(localBuf, 5*16, 16);
+          projectFloat.gluMakeZero(matrixFrustum);
+
+          vec3f=new float[3];
+
+          matrixPStack = new ArrayList();
+          matrixMvStack= new ArrayList();
+
+          // default values and mode
+          glMatrixMode(GL_PROJECTION);
+          glLoadIdentity();
+          glMatrixMode(GL_MODELVIEW);
+          glLoadIdentity();
+          glMatrixMode(GL.GL_TEXTURE);
+          glLoadIdentity();
+          setDirty();
+    }
+
+    public void destroy() {
+        if(null!=projectFloat) {
+            projectFloat.destroy(); projectFloat=null;
+        }
+
+        if(null!=matrixIdent) {
+            matrixIdent.clear(); matrixIdent=null;
+        }
+        if(null!=matrixTPMvMvitPmv) {
+            matrixTPMvMvitPmv.clear(); matrixTPMvMvitPmv=null;
+        }
+        if(null!=matrixMvit3) {
+            matrixMvit3.clear(); matrixMvit3=null;
+        }
+        if(null!=localBuf) {
+            localBuf.clear(); localBuf=null;
+        }
+
+        if(null!=matrixPStack) {
+            matrixPStack.clear(); matrixPStack=null;
+        }
+        vec3f=null;
+        if(null!=matrixMvStack) {
+            matrixMvStack.clear(); matrixMvStack=null;
+        }
+        if(null!=matrixPStack) {
+        matrixPStack.clear(); matrixPStack=null;
+        }
+        if(null!=matrixTStack) {
+            matrixTStack.clear(); matrixTStack=null;
+        }
+
+        matrixTPMvMvitPmv=null; matrixPMvMvit=null; matrixPMvMvitPmv=null; matrixPMvMvi=null; matrixPMv=null; 
+        matrixP=null; matrixT=null; matrixMv=null; matrixMvi=null; matrixMvit=null; matrixPmv=null;
+        matrixMult=null; matrixTrans=null; matrixRot=null; matrixScale=null; matrixOrtho=null; matrixFrustum=null;
+    }
+
+    private static FloatBuffer slice(FloatBuffer buf, int pos, int len) {
+        buf.position(pos);
+        buf.limit(pos + len);
+        return buf.slice();
+    }
+
+    public static final boolean isMatrixModeName(final int matrixModeName) {
+        switch(matrixModeName) {
+            case GL_MODELVIEW_MATRIX:
+            case GL_PROJECTION_MATRIX:
+            case GL_TEXTURE_MATRIX:
+                return true;
+        }
+        return false;
+    }
+
+    public static final int matrixModeName2MatrixGetName(final int matrixModeName) {
+        switch(matrixModeName) {
+            case GL_MODELVIEW:
+                return GL_MODELVIEW_MATRIX;
+            case GL_PROJECTION:
+                return GL_PROJECTION_MATRIX;
+            case GL.GL_TEXTURE:
+                return GL_TEXTURE_MATRIX;
+            default:
+              throw new GLException("unsupported matrixName: "+matrixModeName);
+        }
+    }
+
+    public static final boolean isMatrixGetName(final int matrixGetName) {
+        switch(matrixGetName) {
+            case GL_MATRIX_MODE:
+            case GL_MODELVIEW_MATRIX:
+            case GL_PROJECTION_MATRIX:
+            case GL_TEXTURE_MATRIX:
+                return true;
+        }
+        return false;
+    }
+
+    public static final int matrixGetName2MatrixModeName(final int matrixGetName) {
+        switch(matrixGetName) {
+            case GL_MODELVIEW_MATRIX:
+                return GL_MODELVIEW;
+            case GL_PROJECTION_MATRIX:
+                return GL_PROJECTION;
+            case GL_TEXTURE_MATRIX:
+                return GL.GL_TEXTURE;
+            default:
+              throw new GLException("unsupported matrixGetName: "+matrixGetName);
+        }
+    }
+
+    public void setDirty() {
+          modified   = DIRTY_MODELVIEW | DIRTY_PROJECTION | DIRTY_TEXTURE ;
+          matrixMode = GL_MODELVIEW;
+    }
+
+    public int getDirtyBits() {
+        return modified;
+    }
+
+    public boolean isDirty(final int matrixName) {
+        boolean res;
+        switch(matrixName) {
+            case GL_MODELVIEW:
+                res = (modified&DIRTY_MODELVIEW)!=0 ;
+                break;
+            case GL_PROJECTION:
+                res = (modified&DIRTY_PROJECTION)!=0 ;
+                break;
+            case GL.GL_TEXTURE:
+                res = (modified&DIRTY_TEXTURE)!=0 ;
+                break;
+            default:
+              throw new GLException("unsupported matrixName: "+matrixName);
+        }
+        return res;
+    }
+
+    public boolean isDirty() {
+        return modified!=0;
+    }
+
+    public boolean update() {
+        // if(0==modified) return false;
+
+        // int res = modified;
+        int res = DIRTY_MODELVIEW | DIRTY_PROJECTION ;
+        if( (res&DIRTY_MODELVIEW)!=0 ) {
+            setMviMvit();
+        }
+        if( (res&DIRTY_MODELVIEW)!=0 || (res&DIRTY_PROJECTION)!=0 ) {
+            glMultMatrixf(matrixP, matrixMv, matrixPmv);
+        }
+        modified=0;
+        return res!=0;
+    }
+
+    public final int  glGetMatrixMode() {
+        return matrixMode;
+    }
+
+    public final FloatBuffer glGetTMatrixf() {
+        return matrixT;
+    }
+
+    public final FloatBuffer glGetPMatrixf() {
+        return matrixP;
+    }
+
+    public final FloatBuffer glGetMvMatrixf() {
+        return matrixMv;
+    }
+
+    public final FloatBuffer glGetPMvMvitPmvMatrixf() {
+        return matrixPMvMvitPmv;
+    }
+
+    public final FloatBuffer glGetPMvMvitMatrixf() {
+        return matrixPMvMvit;
+    }
+
+    public final FloatBuffer glGetPMvMviMatrixf() {
+        return matrixPMvMvi;
+    }
+
+    public final FloatBuffer glGetPMvMatrixf() {
+        return matrixPMv;
+    }
+
+    public final FloatBuffer glGetMviMatrixf() {
+        return matrixMvi;
+    }
+
+    public final FloatBuffer glGetPmvMatrixf() {
+        return matrixPmv;
+    }
+
+    public final FloatBuffer glGetNormalMatrixf() {
+        return matrixMvit3;
+    }
+
+   /*
+    * @return the current matrix
+    */
+    public final FloatBuffer glGetMatrixf() {
+        return glGetMatrixf(matrixMode);
+    }
+
+  /**
+   * @param pname GL_MODELVIEW, GL_PROJECTION or GL.GL_TEXTURE
+   * @return the given matrix
+   */
+    public final FloatBuffer glGetMatrixf(final int matrixName) {
+        if(matrixName==GL_MODELVIEW) {
+            return matrixMv;
+        } else if(matrixName==GL_PROJECTION) {
+            return matrixP;
+        } else if(matrixName==GL.GL_TEXTURE) {
+            return matrixT;
+        } else {
+            throw new GLException("unsupported matrixName: "+matrixName);
+        }
+    }
+
+    public final void gluPerspective(final float fovy, final float aspect, final float zNear, final float zFar) {
+      float top=(float)Math.tan(fovy*((float)Math.PI)/360.0f)*zNear;
+      float bottom=-1.0f*top;
+      float left=aspect*bottom;
+      float right=aspect*top;
+      glFrustumf(left, right, bottom, top, zNear, zFar);
+    }
+
+    public static final void glMultMatrixf(final FloatBuffer a, final FloatBuffer b, FloatBuffer p) {
+       for (int i = 0; i < 4; i++) {
+          final float ai0=a.get(i+0*4),  ai1=a.get(i+1*4),  ai2=a.get(i+2*4),  ai3=a.get(i+3*4);
+          p.put(i+0*4 , ai0 * b.get(0+0*4) + ai1 * b.get(1+0*4) + ai2 * b.get(2+0*4) + ai3 * b.get(3+0*4) );
+          p.put(i+1*4 , ai0 * b.get(0+1*4) + ai1 * b.get(1+1*4) + ai2 * b.get(2+1*4) + ai3 * b.get(3+1*4) );
+          p.put(i+2*4 , ai0 * b.get(0+2*4) + ai1 * b.get(1+2*4) + ai2 * b.get(2+2*4) + ai3 * b.get(3+2*4) );
+          p.put(i+3*4 , ai0 * b.get(0+3*4) + ai1 * b.get(1+3*4) + ai2 * b.get(2+3*4) + ai3 * b.get(3+3*4) );
+       }
+    }
+    public static final void glMultMatrixf(final FloatBuffer a, final float[] b, int b_off, FloatBuffer p) {
+       for (int i = 0; i < 4; i++) {
+          final float ai0=a.get(i+0*4),  ai1=a.get(i+1*4),  ai2=a.get(i+2*4),  ai3=a.get(i+3*4);
+          p.put(i+0*4 , ai0 * b[b_off+0+0*4] + ai1 * b[b_off+1+0*4] + ai2 * b[b_off+2+0*4] + ai3 * b[b_off+3+0*4] );
+          p.put(i+1*4 , ai0 * b[b_off+0+1*4] + ai1 * b[b_off+1+1*4] + ai2 * b[b_off+2+1*4] + ai3 * b[b_off+3+1*4] );
+          p.put(i+2*4 , ai0 * b[b_off+0+2*4] + ai1 * b[b_off+1+2*4] + ai2 * b[b_off+2+2*4] + ai3 * b[b_off+3+2*4] );
+          p.put(i+3*4 , ai0 * b[b_off+0+3*4] + ai1 * b[b_off+1+3*4] + ai2 * b[b_off+2+3*4] + ai3 * b[b_off+3+3*4] );
+       }
+    }
+
+    // 
+    // MatrixIf
+    //
+
+    public void glMatrixMode(final int matrixName) {
+        switch(matrixName) {
+            case GL_MODELVIEW:
+            case GL_PROJECTION:
+            case GL.GL_TEXTURE:
+                break;
+            default:
+              throw new GLException("unsupported matrixName: "+matrixName);
+        }
+        matrixMode = matrixName;
+    }
+
+    public void glGetFloatv(int matrixGetName, FloatBuffer params) {
+        int pos = params.position();
+        if(matrixGetName==GL_MATRIX_MODE) {
+            params.put((float)matrixMode);
+        } else {
+            FloatBuffer matrix = glGetMatrixf(matrixGetName2MatrixModeName(matrixGetName));
+            params.put(matrix);
+            matrix.rewind();
+        }
+        params.position(pos);
+    }
+    public void glGetFloatv(int matrixGetName, float[] params, int params_offset) {
+        if(matrixGetName==GL_MATRIX_MODE) {
+            params[params_offset]=(float)matrixMode;
+        } else {
+            FloatBuffer matrix = glGetMatrixf(matrixGetName2MatrixModeName(matrixGetName));
+            matrix.get(params, params_offset, 16);
+            matrix.rewind();
+        }
+    }
+    public void glGetIntegerv(int pname, IntBuffer params) {
+        int pos = params.position();
+        if(pname==GL_MATRIX_MODE) {
+            params.put(matrixMode);
+        } else {
+            throw new GLException("unsupported pname: "+pname);
+        }
+        params.position(pos);
+    }
+    public void glGetIntegerv(int pname, int[] params, int params_offset) {
+        if(pname==GL_MATRIX_MODE) {
+            params[params_offset]=matrixMode;
+        } else {
+            throw new GLException("unsupported pname: "+pname);
+        }
+    }
+
+    public final void glLoadMatrixf(final float[] values, final int offset) {
+        int len = values.length-offset;
+        if(matrixMode==GL_MODELVIEW) {
+            matrixMv.clear();
+            matrixMv.put(values, offset, len);
+            matrixMv.rewind();
+            modified |= DIRTY_MODELVIEW ;
+        } else if(matrixMode==GL_PROJECTION) {
+            matrixP.clear();
+            matrixP.put(values, offset, len);
+            matrixP.rewind();
+            modified |= DIRTY_PROJECTION ;
+        } else if(matrixMode==GL.GL_TEXTURE) {
+            matrixT.clear();
+            matrixT.put(values, offset, len);
+            matrixT.rewind();
+            modified |= DIRTY_TEXTURE ;
+        } 
+    }
+
+    public final void glLoadMatrixf(java.nio.FloatBuffer m) {
+        int spos = m.position();
+        if(matrixMode==GL_MODELVIEW) {
+            matrixMv.clear();
+            matrixMv.put(m);
+            matrixMv.rewind();
+            modified |= DIRTY_MODELVIEW ;
+        } else if(matrixMode==GL_PROJECTION) {
+            matrixP.clear();
+            matrixP.put(m);
+            matrixP.rewind();
+            modified |= DIRTY_PROJECTION ;
+        } else if(matrixMode==GL.GL_TEXTURE) {
+            matrixT.clear();
+            matrixT.put(m);
+            matrixT.rewind();
+            modified |= DIRTY_TEXTURE ;
+        } 
+        m.position(spos);
+    }
+
+    public final void glPopMatrix() {
+        float[] stackEntry=null;
+        if(matrixMode==GL_MODELVIEW) {
+            stackEntry = (float[])matrixMvStack.remove(0);
+        } else if(matrixMode==GL_PROJECTION) {
+            stackEntry = (float[])matrixPStack.remove(0);
+        } else if(matrixMode==GL.GL_TEXTURE) {
+            stackEntry = (float[])matrixTStack.remove(0);
+        } 
+        glLoadMatrixf(stackEntry, 0);
+    }
+
+    public final void glPushMatrix() {
+        float[] stackEntry = new float[1*16];
+        if(matrixMode==GL_MODELVIEW) {
+            matrixMv.get(stackEntry);
+            matrixMv.rewind();
+            matrixMvStack.add(0, stackEntry);
+        } else if(matrixMode==GL_PROJECTION) {
+            matrixP.get(stackEntry);
+            matrixP.rewind();
+            matrixPStack.add(0, stackEntry);
+        } else if(matrixMode==GL.GL_TEXTURE) {
+            matrixT.get(stackEntry);
+            matrixT.rewind();
+            matrixTStack.add(0, stackEntry);
+        }
+    }
+
+    public final void glLoadIdentity() {
+        if(matrixMode==GL_MODELVIEW) {
+            matrixMv.clear();
+            matrixMv.put(matrixIdent);
+            matrixMv.rewind();
+            matrixIdent.rewind();
+            modified |= DIRTY_MODELVIEW ;
+        } else if(matrixMode==GL_PROJECTION) {
+            matrixP.clear();
+            matrixP.put(matrixIdent);
+            matrixP.rewind();
+            matrixIdent.rewind();
+            modified |= DIRTY_PROJECTION ;
+        } else if(matrixMode==GL.GL_TEXTURE) {
+            matrixT.clear();
+            matrixT.put(matrixIdent);
+            matrixT.rewind();
+            matrixIdent.rewind();
+            modified |= DIRTY_TEXTURE ;
+        } 
+    }
+
+    public final void glMultMatrixf(final FloatBuffer m) {
+        if(matrixMode==GL_MODELVIEW) {
+            glMultMatrixf(matrixMv, m, matrixMult);
+            matrixMv.clear();
+            matrixMv.put(matrixMult);
+            matrixMv.rewind();
+            modified |= DIRTY_MODELVIEW ;
+        } else if(matrixMode==GL_PROJECTION) {
+            glMultMatrixf(matrixP, m, matrixMult);
+            matrixP.clear();
+            matrixP.put(matrixMult);
+            matrixP.rewind();
+            modified |= DIRTY_PROJECTION ;
+        } else if(matrixMode==GL.GL_TEXTURE) {
+            glMultMatrixf(matrixT, m, matrixMult);
+            matrixT.clear();
+            matrixT.put(matrixMult);
+            matrixT.rewind();
+            modified |= DIRTY_TEXTURE ;
+        } 
+        matrixMult.rewind();
+    }
+
+    public void glMultMatrixf(float[] m, int m_offset) {
+        if(matrixMode==GL_MODELVIEW) {
+            glMultMatrixf(matrixMv, m, m_offset, matrixMult);
+            matrixMv.clear();
+            matrixMv.put(matrixMult);
+            matrixMv.rewind();
+            modified |= DIRTY_MODELVIEW ;
+        } else if(matrixMode==GL_PROJECTION) {
+            glMultMatrixf(matrixP, m, m_offset, matrixMult);
+            matrixP.clear();
+            matrixP.put(matrixMult);
+            matrixP.rewind();
+            modified |= DIRTY_PROJECTION ;
+        } else if(matrixMode==GL.GL_TEXTURE) {
+            glMultMatrixf(matrixT, m, m_offset, matrixMult);
+            matrixT.clear();
+            matrixT.put(matrixMult);
+            matrixT.rewind();
+            modified |= DIRTY_TEXTURE ;
+        } 
+        matrixMult.rewind();
+    }
+
+    public final void glTranslatef(final float x, final float y, final float z) {
+        // Translation matrix: 
+        //  1 0 0 x
+        //  0 1 0 y
+        //  0 0 1 z
+        //  0 0 0 1
+        matrixTrans.put(0+4*3, x);
+        matrixTrans.put(1+4*3, y);
+        matrixTrans.put(2+4*3, z);
+        glMultMatrixf(matrixTrans);
+    }
+
+    public final void glRotatef(final float angdeg, float x, float y, float z) {
+        float angrad = angdeg   * (float) Math.PI / 180;
+        float c = (float)Math.cos(angrad);
+        float ic= 1.0f - c; 
+        float s = (float)Math.sin(angrad);
+
+        vec3f[0]=x; vec3f[1]=y; vec3f[2]=z;
+        projectFloat.normalize(vec3f);
+        x = vec3f[0]; y = vec3f[1]; z = vec3f[2];
+
+        // Rotation matrix:
+        //      xx(1−c)+c  xy(1−c)+zs xz(1−c)-ys 0
+        //      xy(1−c)-zs yy(1−c)+c  yz(1−c)+xs 0
+        //      xz(1−c)+ys yz(1−c)-xs zz(1−c)+c  0
+        //      0          0          0          1
+        float xy = x*y;
+        float xz = x*z;
+        float xs = x*s;
+        float ys = y*s;
+        float yz = y*z;
+        float zs = z*s;
+        matrixRot.put(0*4+0, x*x*ic+c);
+        matrixRot.put(0*4+1, xy*ic+zs);
+        matrixRot.put(0*4+2, xz*ic-ys);
+
+        matrixRot.put(1*4+0, xy*ic-zs);
+        matrixRot.put(1*4+1, y*y*ic+c);
+        matrixRot.put(1*4+2, yz*ic+xs);
+
+        matrixRot.put(2*4+0, xz*ic+ys);
+        matrixRot.put(2*4+1, yz*ic-xs);
+        matrixRot.put(2*4+2, z*z*ic+c);
+
+        glMultMatrixf(matrixRot);
+    }
+
+    public final void glScalef(final float x, final float y, final float z) {
+        // Scale matrix: 
+        //  x 0 0 0
+        //  0 y 0 0
+        //  0 0 z 0
+        //  0 0 0 1
+        matrixScale.put(0+4*0, x);
+        matrixScale.put(1+4*1, y);
+        matrixScale.put(2+4*2, z);
+
+        glMultMatrixf(matrixScale);
+    }
+
+    public final void glOrthof(final float left, final float right, final float bottom, final float top, final float zNear, final float zFar) {
+        // Ortho matrix: 
+        //  2/dx  0     0    tx
+        //  0     2/dy  0    ty
+        //  0     0     2/dz tz
+        //  0     0     0    1
+        float dx=right-left;
+        float dy=top-bottom;
+        float dz=zFar-zNear;
+        float tx=-1.0f*(right+left)/dx;
+        float ty=-1.0f*(top+bottom)/dy;
+        float tz=-1.0f*(zFar+zNear)/dz;
+
+        matrixOrtho.put(0+4*0, 2.0f/dx);
+        matrixOrtho.put(1+4*1, 2.0f/dy);
+        matrixOrtho.put(2+4*2, -2.0f/dz);
+        matrixOrtho.put(0+4*3, tx);
+        matrixOrtho.put(1+4*3, ty);
+        matrixOrtho.put(2+4*3, tz);
+
+        glMultMatrixf(matrixOrtho);
+    }
+
+    public final void glFrustumf(final float left, final float right, final float bottom, final float top, final float zNear, final float zFar) {
+        if(zNear<=0.0f||zFar<0.0f) {
+            throw new GLException("GL_INVALID_VALUE: zNear and zFar must be positive, and zNear>0");
+        }
+        if(left==right || top==bottom) {
+            throw new GLException("GL_INVALID_VALUE: top,bottom and left,right must not be equal");
+        }
+        // Frustum matrix: 
+        //  2*zNear/dx   0          A  0
+        //  0            2*zNear/dy B  0
+        //  0            0          C  D
+        //  0            0         −1  0
+        float zNear2 = 2.0f*zNear;
+        float dx=right-left;
+        float dy=top-bottom;
+        float dz=zFar-zNear;
+        float A=(right+left)/dx;
+        float B=(top+bottom)/dy;
+        float C=-1.0f*(zFar+zNear)/dz;
+        float D=-2.0f*(zFar*zNear)/dz;
+
+        matrixFrustum.put(0+4*0, zNear2/dx);
+        matrixFrustum.put(1+4*1, zNear2/dy);
+        matrixFrustum.put(2+4*2, C);
+
+        matrixFrustum.put(0+4*2, A);
+        matrixFrustum.put(1+4*2, B);
+
+        matrixFrustum.put(2+4*3, D);
+        matrixFrustum.put(3+4*2, -1.0f);
+
+        glMultMatrixf(matrixFrustum);
+    }
+
+    //
+    // private 
+    //
+
+    private final void setMviMvit() {
+        if(!projectFloat.gluInvertMatrixf(matrixMv, matrixMvi)) {
+            throw new GLException("Invalid source Mv matrix, can't compute inverse");
+        }
+
+        // transpose matrix 
+        for (int i = 0; i < 4; i++) {
+            for (int j = 0; j < 4; j++) {
+                matrixMvit.put(j+i*4, matrixMvi.get(i+j*4));
+            }
+        }
+
+        // fetch 3x3
+        for (int i = 0; i < 3; i++) {
+            for (int j = 0; j < 3; j++) {
+                matrixMvit3.put(i+j*3, matrixMvit.get(i+j*4));
+            }
+        }
+    }
+
+    protected FloatBuffer matrixIdent;
+    protected FloatBuffer matrixTPMvMvitPmv, matrixPMvMvit, matrixPMvMvitPmv, matrixPMvMvi, matrixPMv, matrixP, matrixT, matrixMv, matrixMvi, matrixMvit, matrixPmv;
+    protected FloatBuffer matrixMvit3;
+    protected FloatBuffer localBuf, matrixMult, matrixTrans, matrixRot, matrixScale, matrixOrtho, matrixFrustum;
+    protected float[] vec3f;
+    protected List/*FloatBuffer*/ matrixTStack, matrixPStack, matrixMvStack;
+    protected int matrixMode = GL_MODELVIEW;
+    protected int modified = 0;
+    protected ProjectFloat projectFloat;
+
+    public static final int DIRTY_MODELVIEW  = 1 << 0;
+    public static final int DIRTY_PROJECTION = 1 << 1;
+    public static final int DIRTY_TEXTURE    = 1 << 2;
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/StreamUtil.java b/src/jogl/classes/com/jogamp/opengl/util/StreamUtil.java
new file mode 100755
index 000000000..294f86303
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/StreamUtil.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util;
+
+import java.io.*;
+import java.nio.*;
+
+/** Utilities for dealing with streams. */
+
+public class StreamUtil {
+    private StreamUtil() {}
+
+    public static byte[] readAll2Array(InputStream stream) throws IOException {
+        BytesRead bytesRead = readAllImpl(stream);
+        byte[] data = bytesRead.data;
+        if (bytesRead.payloadLen != data.length) {
+            data = new byte[bytesRead.payloadLen];
+            System.arraycopy(bytesRead.data, 0, data, 0, bytesRead.payloadLen);
+        }
+        return data;
+    }
+
+    public static ByteBuffer readAll2Buffer(InputStream stream) throws IOException {
+        BytesRead bytesRead = readAllImpl(stream);
+        return BufferUtil.newByteBuffer(bytesRead.data, 0, bytesRead.payloadLen);
+    }
+
+    private static BytesRead readAllImpl(InputStream stream) throws IOException {
+        // FIXME: Shall we do this here ?
+        if( !(stream instanceof BufferedInputStream) ) {
+            stream = new BufferedInputStream(stream);
+        }
+        int avail = stream.available();
+        byte[] data = new byte[avail];
+        int numRead = 0;
+        int pos = 0;
+        do {
+            if (pos + avail > data.length) {
+                byte[] newData = new byte[pos + avail];
+                System.arraycopy(data, 0, newData, 0, pos);
+                data = newData;
+            }
+            numRead = stream.read(data, pos, avail);
+            if (numRead >= 0) {
+                pos += numRead;
+            }
+            avail = stream.available();
+        } while (avail > 0 && numRead >= 0);
+
+        return new BytesRead(pos, data);
+    }
+
+    private static class BytesRead {
+        BytesRead(int payloadLen, byte[] data) {
+            this.payloadLen=payloadLen;
+            this.data=data;
+        }
+        int payloadLen;
+        byte[] data;
+    }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/TGAWriter.java b/src/jogl/classes/com/jogamp/opengl/util/TGAWriter.java
new file mode 100755
index 000000000..c53cafdcb
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/TGAWriter.java
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2005 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ */
+
+package com.jogamp.opengl.util;
+
+import java.io.*;
+import java.nio.*;
+import java.nio.channels.*;
+
+/**
+ * Utility class which helps take fast screenshots of OpenGL rendering
+ * results into Targa-format files. Used by the {@link
+ * com.jogamp.opengl.util.gl2.Screenshot Screenshot} class; can also be used
+ * in conjunction with the {@link com.jogamp.opengl.util.gl2.TileRenderer
+ * TileRenderer} class. <P>
+ */
+
+public class TGAWriter {
+  private static final int TARGA_HEADER_SIZE = 18;
+
+  private FileChannel ch;
+  private ByteBuffer buf;
+
+  /** Constructor for the TGAWriter. */
+  public TGAWriter() {
+  }
+
+  /**
+   * Opens the specified Targa file for writing, overwriting any
+   * existing file, and sets up the header of the file expecting the
+   * data to be filled in before closing it.
+   *
+   * @param file the file to write containing the screenshot
+   * @param width the width of the current drawable
+   * @param height the height of the current drawable
+   * @param alpha whether the alpha channel should be saved. If true,
+   *   requires GL_EXT_abgr extension to be present.
+   *
+   * @throws IOException if an I/O error occurred while writing the
+   *   file
+   */
+  public void open(File file,
+                   int width,
+                   int height,
+                   boolean alpha) throws IOException {
+    RandomAccessFile out = new RandomAccessFile(file, "rw");
+    ch = out.getChannel();
+    int pixelSize = (alpha ? 32 : 24);
+    int numChannels = (alpha ? 4 : 3);
+
+    int fileLength = TARGA_HEADER_SIZE + width * height * numChannels;
+    out.setLength(fileLength);
+    MappedByteBuffer image = ch.map(FileChannel.MapMode.READ_WRITE, 0, fileLength);
+
+    // write the TARGA header
+    image.put(0, (byte) 0).put(1, (byte) 0);
+    image.put(2, (byte) 2); // uncompressed type
+    image.put(12, (byte) (width & 0xFF)); // width
+    image.put(13, (byte) (width >> 8)); // width
+    image.put(14, (byte) (height & 0xFF)); // height
+    image.put(15, (byte) (height >> 8)); // height
+    image.put(16, (byte) pixelSize); // pixel size
+             
+    // go to image data position
+    image.position(TARGA_HEADER_SIZE);
+    // jogl needs a sliced buffer
+    buf = image.slice();
+  }
+
+  /**
+   * Returns the ByteBuffer corresponding to the data for the image.
+   * This must be filled in with data in either BGR or BGRA format
+   * depending on whether an alpha channel was specified during
+   * open().
+   */
+  public ByteBuffer getImageData() {
+    return buf;
+  }
+
+  public void close() throws IOException {
+    // close the file channel
+    ch.close();
+    buf = null;
+  }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/awt/ImageUtil.java b/src/jogl/classes/com/jogamp/opengl/util/awt/ImageUtil.java
new file mode 100755
index 000000000..a3139b16a
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/awt/ImageUtil.java
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) 2005 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util.awt;
+
+import java.awt.*;
+import java.awt.image.*;
+
+/** Utilities for dealing with images. */
+
+public class ImageUtil {
+  private ImageUtil() {}
+
+  /** Flips the supplied BufferedImage vertically. This is often a
+      necessary conversion step to display a Java2D image correctly
+      with OpenGL and vice versa. */
+  public static void flipImageVertically(BufferedImage image) {
+    WritableRaster raster = image.getRaster();
+    Object scanline1 = null;
+    Object scanline2 = null;
+      
+    for (int i = 0; i < image.getHeight() / 2; i++) {
+      scanline1 = raster.getDataElements(0, i, image.getWidth(), 1, scanline1);
+      scanline2 = raster.getDataElements(0, image.getHeight() - i - 1, image.getWidth(), 1, scanline2);
+      raster.setDataElements(0, i, image.getWidth(), 1, scanline2);
+      raster.setDataElements(0, image.getHeight() - i - 1, image.getWidth(), 1, scanline1);
+    }
+  }
+
+  /**
+   * Creates a <code>BufferedImage</code> with a pixel format compatible with the graphics
+   * environment. The returned image can thus benefit from hardware accelerated operations
+   * in Java2D API.
+   *
+   * @param width The width of the image to be created
+   * @param height The height of the image to be created
+   *
+   * @return A instance of <code>BufferedImage</code> with a type compatible with the graphics card.
+   */
+  public static BufferedImage createCompatibleImage(int width, int height) {
+    GraphicsConfiguration configuration =
+      GraphicsEnvironment.getLocalGraphicsEnvironment().
+      getDefaultScreenDevice().getDefaultConfiguration();
+    return configuration.createCompatibleImage(width, height);
+  }
+
+  /**
+   * Creates a thumbnail from an image. A thumbnail is a scaled down version of the original picture.
+   * This method will retain the width to height ratio of the original picture and return a new
+   * instance of <code>BufferedImage</code>. The original picture is not modified.
+   *
+   * @param image The original image to sample down
+   * @param thumbWidth The width of the thumbnail to be created
+   *
+   * @throws IllegalArgumentException If thumbWidth is greater than image.getWidth()
+   *
+   * @return A thumbnail with the requested width or the original picture if thumbWidth = image.getWidth()
+   */
+  public static BufferedImage createThumbnail(BufferedImage image, int thumbWidth) {
+    // Thanks to Romain Guy for this utility
+    if (thumbWidth > image.getWidth()) {
+      throw new IllegalArgumentException("Thumbnail width must be greater than image width");
+    }
+   
+    if (thumbWidth == image.getWidth()) {
+      return image;
+    }
+ 
+    float ratio = (float) image.getWidth() / (float) image.getHeight();
+    int width = image.getWidth();
+    BufferedImage thumb = image;
+   
+    do {
+      width /= 2;
+      if (width < thumbWidth) {
+        width = thumbWidth;
+      }
+     
+      BufferedImage temp = createCompatibleImage(width, (int) (width / ratio));
+      Graphics2D g2 = temp.createGraphics();
+      g2.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
+                          RenderingHints.VALUE_INTERPOLATION_BILINEAR);
+      g2.drawImage(thumb, 0, 0, temp.getWidth(), temp.getHeight(), null);
+      g2.dispose();
+      thumb = temp;
+    } while (width != thumbWidth);
+   
+    return thumb;
+  }
+
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/awt/Overlay.java b/src/jogl/classes/com/jogamp/opengl/util/awt/Overlay.java
new file mode 100755
index 000000000..1275c9391
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/awt/Overlay.java
@@ -0,0 +1,214 @@
+/*
+ * Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util.awt;
+
+import java.awt.Graphics2D;
+
+import javax.media.opengl.*;
+import com.jogamp.opengl.util.texture.*;
+
+/** Provides a Java 2D overlay on top of an arbitrary GLDrawable,
+    making it easier to do things like draw text and images on top of
+    an OpenGL scene while still maintaining reasonably good
+    efficiency. */
+
+public class Overlay {
+  private GLDrawable drawable;
+  private TextureRenderer renderer;
+  private boolean contentsLost;
+
+  /** Creates a new Java 2D overlay on top of the specified
+      GLDrawable. */
+  public Overlay(GLDrawable drawable) {
+    this.drawable = drawable;
+  }
+
+  /** Creates a {@link java.awt.Graphics2D Graphics2D} instance for
+      rendering into the overlay. The returned object should be
+      disposed of using the normal {@link java.awt.Graphics#dispose()
+      Graphics.dispose()} method once it is no longer being used.
+
+      @return a new {@link java.awt.Graphics2D Graphics2D} object for
+        rendering into the backing store of this renderer
+  */
+  public Graphics2D createGraphics() {
+    // Validate the size of the renderer against the current size of
+    // the drawable
+    validateRenderer();
+    return renderer.createGraphics();
+  }
+
+  /** Indicates whether the Java 2D contents of the overlay were lost
+      since the last time {@link #createGraphics} was called. This
+      method should be called immediately after calling {@link
+      #createGraphics} to see whether the entire contents of the
+      overlay need to be redrawn or just the region the application is
+      interested in updating.
+
+      @return whether the contents of the overlay were lost since the
+        last render
+  */
+  public boolean contentsLost() {
+    return contentsLost;
+  }
+
+  /** Marks the given region of the overlay as dirty. This region, and
+      any previously set dirty regions, will be automatically
+      synchronized with the underlying Texture during the next {@link
+      #draw draw} or {@link #drawAll drawAll} operation, at which
+      point the dirty region will be cleared. It is not necessary for
+      an OpenGL context to be current when this method is called.
+
+      @param x the x coordinate (in Java 2D coordinates -- relative to
+        upper left) of the region to update
+      @param y the y coordinate (in Java 2D coordinates -- relative to
+        upper left) of the region to update
+      @param width the width of the region to update
+      @param height the height of the region to update
+
+      @throws GLException If an OpenGL context is not current when this method is called */
+  public void markDirty(int x, int y, int width, int height) {
+    renderer.markDirty(x, y, width, height);
+  }
+
+  /** Draws the entire contents of the overlay on top of the OpenGL
+      drawable. This is a convenience method which encapsulates all
+      portions of the rendering process; if this method is used,
+      {@link #beginRendering}, {@link #endRendering}, etc. should not
+      be used. This method should be called while the OpenGL context
+      for the drawable is current, and after your OpenGL scene has
+      been rendered.
+
+      @throws GLException If an OpenGL context is not current when this method is called
+  */
+  public void drawAll() throws GLException {
+    beginRendering();
+    draw(0, 0, drawable.getWidth(), drawable.getHeight());
+    endRendering();
+  }
+
+  /** Begins the OpenGL rendering process for the overlay. This is
+      separated out so advanced applications can render independent
+      pieces of the overlay to different portions of the drawable.
+
+      @throws GLException If an OpenGL context is not current when this method is called
+  */
+  public void beginRendering() throws GLException {
+    renderer.beginOrthoRendering(drawable.getWidth(), drawable.getHeight());
+  }
+
+  /** Ends the OpenGL rendering process for the overlay. This is
+      separated out so advanced applications can render independent
+      pieces of the overlay to different portions of the drawable.
+
+      @throws GLException If an OpenGL context is not current when this method is called
+  */
+  public void endRendering() throws GLException {
+    renderer.endOrthoRendering();
+  }
+
+  /** Draws the specified sub-rectangle of the overlay on top of the
+      OpenGL drawable. {@link #beginRendering} and {@link
+      #endRendering} must be used in conjunction with this method to
+      achieve proper rendering results. This method should be called
+      while the OpenGL context for the drawable is current, and after
+      your OpenGL scene has been rendered.
+
+      @param x the lower-left x coordinate (relative to the lower left
+        of the overlay) of the rectangle to draw
+      @param y the lower-left y coordinate (relative to the lower left
+        of the overlay) of the rectangle to draw
+      @param width the width of the rectangle to draw
+      @param height the height of the rectangle to draw
+
+      @throws GLException If an OpenGL context is not current when this method is called
+  */
+  public void draw(int x, int y, int width, int height) throws GLException {
+    draw(x, y, x, y, width, height);
+  }
+
+  /** Draws the specified sub-rectangle of the overlay at the
+      specified x and y coordinate on top of the OpenGL drawable.
+      {@link #beginRendering} and {@link #endRendering} must be used
+      in conjunction with this method to achieve proper rendering
+      results. This method should be called while the OpenGL context
+      for the drawable is current, and after your OpenGL scene has
+      been rendered.
+
+      @param screenx the on-screen x coordinate at which to draw the rectangle
+      @param screeny the on-screen y coordinate (relative to lower left) at
+        which to draw the rectangle
+      @param overlayx the x coordinate of the pixel in the overlay of
+        the lower left portion of the rectangle to draw
+      @param overlayy the y coordinate of the pixel in the overlay
+        (relative to lower left) of the lower left portion of the
+        rectangle to draw
+      @param width the width of the rectangle to draw
+      @param height the height of the rectangle to draw
+
+      @throws GLException If an OpenGL context is not current when this method is called
+  */
+  public void draw(int screenx, int screeny,
+                   int overlayx, int overlayy,
+                   int width, int height) throws GLException {
+    renderer.drawOrthoRect(screenx, screeny,
+                           overlayx, overlayy,
+                           width, height);
+  }
+
+  //----------------------------------------------------------------------
+  // Internals only below this point
+  //
+
+  private void validateRenderer() {
+    if (renderer == null) {
+      renderer = new TextureRenderer(drawable.getWidth(),
+                                     drawable.getHeight(),
+                                     true);
+      contentsLost = true;
+    } else if (renderer.getWidth() != drawable.getWidth() ||
+               renderer.getHeight() != drawable.getHeight()) {
+      renderer.setSize(drawable.getWidth(), drawable.getHeight());
+      contentsLost = true;
+    } else {
+      contentsLost = false;
+    }
+  }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/awt/Screenshot.java b/src/jogl/classes/com/jogamp/opengl/util/awt/Screenshot.java
new file mode 100755
index 000000000..7019d720f
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/awt/Screenshot.java
@@ -0,0 +1,432 @@
+/*
+ * Copyright (c) 2005 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ */
+
+package com.jogamp.opengl.util.awt;
+
+import java.awt.image.*;
+import java.io.*;
+import java.nio.*;
+import java.nio.channels.*;
+import javax.imageio.*;
+
+import javax.media.opengl.*;
+import javax.media.opengl.glu.*;
+import javax.media.opengl.glu.gl2.*;
+
+import com.jogamp.opengl.util.*;
+
+/** Utilities for taking screenshots of OpenGL applications. */
+
+public class Screenshot {
+  private Screenshot() {}
+
+  /** 
+   * Takes a fast screenshot of the current OpenGL drawable to a Targa
+   * file. Requires the OpenGL context for the desired drawable to be
+   * current. Takes the screenshot from the last assigned read buffer,
+   * or the OpenGL default read buffer if none has been specified by
+   * the user (GL_FRONT for single-buffered configurations and GL_BACK
+   * for double-buffered configurations). This is the fastest
+   * mechanism for taking a screenshot of an application. Contributed
+   * by Carsten Weisse of Bytonic Software (http://bytonic.de/). <p>
+   *
+   * No alpha channel is written with this variant.
+   *
+   * @param file the file to write containing the screenshot
+   * @param width the width of the current drawable
+   * @param height the height of the current drawable
+   *
+   * @throws GLException if an OpenGL context was not current or
+   *   another OpenGL-related error occurred
+   * @throws IOException if an I/O error occurred while writing the
+   *   file
+   */
+  public static void writeToTargaFile(File file,
+                                      int width,
+                                      int height) throws GLException, IOException {
+    writeToTargaFile(file, width, height, false);
+  }
+
+  /** 
+   * Takes a fast screenshot of the current OpenGL drawable to a Targa
+   * file. Requires the OpenGL context for the desired drawable to be
+   * current. Takes the screenshot from the last assigned read buffer,
+   * or the OpenGL default read buffer if none has been specified by
+   * the user (GL_FRONT for single-buffered configurations and GL_BACK
+   * for double-buffered configurations). This is the fastest
+   * mechanism for taking a screenshot of an application. Contributed
+   * by Carsten Weisse of Bytonic Software (http://bytonic.de/).
+   *
+   * @param file the file to write containing the screenshot
+   * @param width the width of the current drawable
+   * @param height the height of the current drawable
+   * @param alpha whether the alpha channel should be saved. If true,
+   *   requires GL_EXT_abgr extension to be present.
+   *
+   * @throws GLException if an OpenGL context was not current or
+   *   another OpenGL-related error occurred
+   * @throws IOException if an I/O error occurred while writing the
+   *   file
+   */
+  public static void writeToTargaFile(File file,
+                                      int width,
+                                      int height,
+                                      boolean alpha) throws GLException, IOException {
+    writeToTargaFile(file, 0, 0, width, height, alpha);
+  }
+
+  /** 
+   * Takes a fast screenshot of the current OpenGL drawable to a Targa
+   * file. Requires the OpenGL context for the desired drawable to be
+   * current. Takes the screenshot from the last assigned read buffer,
+   * or the OpenGL default read buffer if none has been specified by
+   * the user (GL_FRONT for single-buffered configurations and GL_BACK
+   * for double-buffered configurations). This is the fastest
+   * mechanism for taking a screenshot of an application. Contributed
+   * by Carsten Weisse of Bytonic Software (http://bytonic.de/).
+   *
+   * @param file the file to write containing the screenshot
+   * @param x the starting x coordinate of the screenshot, measured from the lower-left
+   * @param y the starting y coordinate of the screenshot, measured from the lower-left
+   * @param width the width of the desired screenshot area
+   * @param height the height of the desired screenshot area
+   * @param alpha whether the alpha channel should be saved. If true,
+   *   requires GL_EXT_abgr extension to be present.
+   *
+   * @throws GLException if an OpenGL context was not current or
+   *   another OpenGL-related error occurred
+   * @throws IOException if an I/O error occurred while writing the
+   *   file
+   */
+  public static void writeToTargaFile(File file,
+                                      int x,
+                                      int y,
+                                      int width,
+                                      int height,
+                                      boolean alpha) throws GLException, IOException {
+    if (alpha) {
+      checkExtABGR();
+    }
+
+    TGAWriter writer = new TGAWriter();
+    writer.open(file, width, height, alpha);
+    ByteBuffer bgr = writer.getImageData();
+
+    GL2 gl = GLUgl2.getCurrentGL2();
+
+    // Set up pixel storage modes
+    PixelStorageModes psm = new PixelStorageModes();
+    psm.save(gl);
+
+    int readbackType = (alpha ? GL2.GL_ABGR_EXT : GL2.GL_BGR);
+
+    // read the BGR values into the image buffer
+    gl.glReadPixels(x, y, width, height, readbackType,
+                    GL2.GL_UNSIGNED_BYTE, bgr);
+
+    // Restore pixel storage modes
+    psm.restore(gl);
+
+    // close the file
+    writer.close();
+  }
+
+  /**
+   * Takes a screenshot of the current OpenGL drawable to a
+   * BufferedImage. Requires the OpenGL context for the desired
+   * drawable to be current. Takes the screenshot from the last
+   * assigned read buffer, or the OpenGL default read buffer if none
+   * has been specified by the user (GL_FRONT for single-buffered
+   * configurations and GL_BACK for double-buffered configurations).
+   * Note that the scanlines of the resulting image are flipped
+   * vertically in order to correctly match the OpenGL contents, which
+   * takes time and is therefore not as fast as the Targa screenshot
+   * function. <P>
+   *
+   * No alpha channel is read back with this variant.
+   *
+   * @param width the width of the current drawable
+   * @param height the height of the current drawable
+   *
+   * @throws GLException if an OpenGL context was not current or
+   *   another OpenGL-related error occurred
+   */
+  public static BufferedImage readToBufferedImage(int width,
+                                                  int height) throws GLException {
+    return readToBufferedImage(width, height, false);
+  }
+
+  /**
+   * Takes a screenshot of the current OpenGL drawable to a
+   * BufferedImage. Requires the OpenGL context for the desired
+   * drawable to be current. Takes the screenshot from the last
+   * assigned read buffer, or the OpenGL default read buffer if none
+   * has been specified by the user (GL_FRONT for single-buffered
+   * configurations and GL_BACK for double-buffered configurations).
+   * Note that the scanlines of the resulting image are flipped
+   * vertically in order to correctly match the OpenGL contents, which
+   * takes time and is therefore not as fast as the Targa screenshot
+   * function.
+   *
+   * @param width the width of the current drawable
+   * @param height the height of the current drawable
+   * @param alpha whether the alpha channel should be read back. If
+   *   true, requires GL_EXT_abgr extension to be present.
+   *
+   * @throws GLException if an OpenGL context was not current or
+   *   another OpenGL-related error occurred
+   */
+  public static BufferedImage readToBufferedImage(int width,
+                                                  int height,
+                                                  boolean alpha) throws GLException {
+    return readToBufferedImage(0, 0, width, height, alpha);
+  }
+
+  /**
+   * Takes a screenshot of the current OpenGL drawable to a
+   * BufferedImage. Requires the OpenGL context for the desired
+   * drawable to be current. Takes the screenshot from the last
+   * assigned read buffer, or the OpenGL default read buffer if none
+   * has been specified by the user (GL_FRONT for single-buffered
+   * configurations and GL_BACK for double-buffered configurations).
+   * Note that the scanlines of the resulting image are flipped
+   * vertically in order to correctly match the OpenGL contents, which
+   * takes time and is therefore not as fast as the Targa screenshot
+   * function.
+   *
+   * @param x the starting x coordinate of the screenshot, measured from the lower-left
+   * @param y the starting y coordinate of the screenshot, measured from the lower-left
+   * @param width the width of the desired screenshot area
+   * @param height the height of the desired screenshot area
+   * @param alpha whether the alpha channel should be read back. If
+   *   true, requires GL_EXT_abgr extension to be present.
+   *
+   * @throws GLException if an OpenGL context was not current or
+   *   another OpenGL-related error occurred
+   */
+  public static BufferedImage readToBufferedImage(int x,
+                                                  int y,
+                                                  int width,
+                                                  int height,
+                                                  boolean alpha) throws GLException {
+    int bufImgType = (alpha ? BufferedImage.TYPE_4BYTE_ABGR : BufferedImage.TYPE_3BYTE_BGR);
+    int readbackType = (alpha ? GL2.GL_ABGR_EXT : GL2.GL_BGR);
+
+    if (alpha) {
+      checkExtABGR();
+    }
+
+    // Allocate necessary storage
+    BufferedImage image = new BufferedImage(width, height, bufImgType);
+
+    GL2 gl = GLUgl2.getCurrentGL2();
+
+    // Set up pixel storage modes
+    PixelStorageModes psm = new PixelStorageModes();
+    psm.save(gl);
+
+    // read the BGR values into the image
+    gl.glReadPixels(x, y, width, height, readbackType,
+                    GL2.GL_UNSIGNED_BYTE,
+                    ByteBuffer.wrap(((DataBufferByte) image.getRaster().getDataBuffer()).getData()));
+
+    // Restore pixel storage modes
+    psm.restore(gl);
+
+    // Must flip BufferedImage vertically for correct results
+    ImageUtil.flipImageVertically(image);
+    return image;
+  }
+
+  /**
+   * Takes a screenshot of the current OpenGL drawable to the
+   * specified file on disk using the ImageIO package. Requires the
+   * OpenGL context for the desired drawable to be current. Takes the
+   * screenshot from the last assigned read buffer, or the OpenGL
+   * default read buffer if none has been specified by the user
+   * (GL_FRONT for single-buffered configurations and GL_BACK for
+   * double-buffered configurations). This is not the fastest
+   * mechanism for taking a screenshot but may be more convenient than
+   * others for getting images for consumption by other packages. The
+   * file format is inferred from the suffix of the given file. <P>
+   *
+   * No alpha channel is saved with this variant.
+   *
+   * @param file the file to write containing the screenshot
+   * @param width the width of the current drawable
+   * @param height the height of the current drawable
+   *
+   * @throws GLException if an OpenGL context was not current or
+   *   another OpenGL-related error occurred
+   *
+   * @throws IOException if an I/O error occurred or if the file could
+   *   not be written to disk due to the requested file format being
+   *   unsupported by ImageIO
+   */
+  public static void writeToFile(File file,
+                                 int width,
+                                 int height) throws IOException, GLException {
+    writeToFile(file, width, height, false);
+  }
+
+  /**
+   * Takes a screenshot of the current OpenGL drawable to the
+   * specified file on disk using the ImageIO package. Requires the
+   * OpenGL context for the desired drawable to be current. Takes the
+   * screenshot from the last assigned read buffer, or the OpenGL
+   * default read buffer if none has been specified by the user
+   * (GL_FRONT for single-buffered configurations and GL_BACK for
+   * double-buffered configurations). This is not the fastest
+   * mechanism for taking a screenshot but may be more convenient than
+   * others for getting images for consumption by other packages. The
+   * file format is inferred from the suffix of the given file. <P>
+   *
+   * Note that some file formats, in particular JPEG, can not handle
+   * an alpha channel properly. If the "alpha" argument is specified
+   * as true for such a file format it will be silently ignored.
+   *
+   * @param file the file to write containing the screenshot
+   * @param width the width of the current drawable
+   * @param height the height of the current drawable
+   * @param alpha whether an alpha channel should be saved. If true,
+   *   requires GL_EXT_abgr extension to be present.
+   *
+   * @throws GLException if an OpenGL context was not current or
+   *   another OpenGL-related error occurred
+   *
+   * @throws IOException if an I/O error occurred or if the file could
+   *   not be written to disk due to the requested file format being
+   *   unsupported by ImageIO
+   */
+  public static void writeToFile(File file,
+                                 int width,
+                                 int height,
+                                 boolean alpha) throws IOException, GLException {
+    writeToFile(file, 0, 0, width, height, alpha);
+  }
+
+  /**
+   * Takes a screenshot of the current OpenGL drawable to the
+   * specified file on disk using the ImageIO package. Requires the
+   * OpenGL context for the desired drawable to be current. Takes the
+   * screenshot from the last assigned read buffer, or the OpenGL
+   * default read buffer if none has been specified by the user
+   * (GL_FRONT for single-buffered configurations and GL_BACK for
+   * double-buffered configurations). This is not the fastest
+   * mechanism for taking a screenshot but may be more convenient than
+   * others for getting images for consumption by other packages. The
+   * file format is inferred from the suffix of the given file. <P>
+   *
+   * Note that some file formats, in particular JPEG, can not handle
+   * an alpha channel properly. If the "alpha" argument is specified
+   * as true for such a file format it will be silently ignored.
+   *
+   * @param file the file to write containing the screenshot
+   * @param x the starting x coordinate of the screenshot, measured from the lower-left
+   * @param y the starting y coordinate of the screenshot, measured from the lower-left
+   * @param width the width of the current drawable
+   * @param height the height of the current drawable
+   * @param alpha whether an alpha channel should be saved. If true,
+   *   requires GL_EXT_abgr extension to be present.
+   *
+   * @throws GLException if an OpenGL context was not current or
+   *   another OpenGL-related error occurred
+   *
+   * @throws IOException if an I/O error occurred or if the file could
+   *   not be written to disk due to the requested file format being
+   *   unsupported by ImageIO
+   */
+  public static void writeToFile(File file,
+                                 int x,
+                                 int y,
+                                 int width,
+                                 int height,
+                                 boolean alpha) throws IOException, GLException {
+    String fileSuffix = FileUtil.getFileSuffix(file);
+    if (alpha && (fileSuffix.equals("jpg") || fileSuffix.equals("jpeg"))) {
+      // JPEGs can't deal properly with alpha channels
+      alpha = false;
+    }
+
+    BufferedImage image = readToBufferedImage(x, y, width, height, alpha);
+    if (!ImageIO.write(image, fileSuffix, file)) {
+      throw new IOException("Unsupported file format " + fileSuffix);
+    }
+  }
+
+  private static int glGetInteger(GL2 gl, int pname, int[] tmp) {
+    gl.glGetIntegerv(pname, tmp, 0);
+    return tmp[0];
+  }
+
+  private static void checkExtABGR() {
+    GL2 gl = GLUgl2.getCurrentGL2();
+    if (!gl.isExtensionAvailable("GL_EXT_abgr")) {
+      throw new IllegalArgumentException("Saving alpha channel requires GL_EXT_abgr");
+    }
+  }
+ 
+  static class PixelStorageModes {
+    int packAlignment;
+    int packRowLength;
+    int packSkipRows;
+    int packSkipPixels;
+    int packSwapBytes;
+    int[] tmp = new int[1];
+
+    void save(GL2 gl) {
+      packAlignment  = glGetInteger(gl, GL2.GL_PACK_ALIGNMENT, tmp);
+      packRowLength  = glGetInteger(gl, GL2.GL_PACK_ROW_LENGTH, tmp);
+      packSkipRows   = glGetInteger(gl, GL2.GL_PACK_SKIP_ROWS, tmp);
+      packSkipPixels = glGetInteger(gl, GL2.GL_PACK_SKIP_PIXELS, tmp);
+      packSwapBytes  = glGetInteger(gl, GL2.GL_PACK_SWAP_BYTES, tmp);
+
+      gl.glPixelStorei(GL2.GL_PACK_ALIGNMENT, 1);
+      gl.glPixelStorei(GL2.GL_PACK_ROW_LENGTH, 0);
+      gl.glPixelStorei(GL2.GL_PACK_SKIP_ROWS, 0);
+      gl.glPixelStorei(GL2.GL_PACK_SKIP_PIXELS, 0);
+      gl.glPixelStorei(GL2.GL_PACK_SWAP_BYTES, 0);
+    }
+
+    void restore(GL2 gl) {
+      gl.glPixelStorei(GL2.GL_PACK_ALIGNMENT, packAlignment);
+      gl.glPixelStorei(GL2.GL_PACK_ROW_LENGTH, packRowLength);
+      gl.glPixelStorei(GL2.GL_PACK_SKIP_ROWS, packSkipRows);
+      gl.glPixelStorei(GL2.GL_PACK_SKIP_PIXELS, packSkipPixels);
+      gl.glPixelStorei(GL2.GL_PACK_SWAP_BYTES, packSwapBytes);
+    }
+  }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/awt/TextRenderer.java b/src/jogl/classes/com/jogamp/opengl/util/awt/TextRenderer.java
new file mode 100755
index 000000000..1fbdade4e
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/awt/TextRenderer.java
@@ -0,0 +1,1951 @@
+/*
+ * Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ *
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ *
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+package com.jogamp.opengl.util.awt;
+
+import com.jogamp.opengl.impl.Debug;
+import com.jogamp.opengl.util.*;
+import com.jogamp.opengl.util.packrect.*;
+import com.jogamp.opengl.util.texture.*;
+import com.jogamp.opengl.util.texture.awt.*;
+
+import java.awt.AlphaComposite;
+import java.awt.Color;
+import java.awt.Composite;
+
+// For debugging purposes
+import java.awt.EventQueue;
+import java.awt.Font;
+import java.awt.Frame;
+import java.awt.Graphics2D;
+import java.awt.Image;
+import java.awt.Point;
+import java.awt.RenderingHints;
+import java.awt.event.*;
+import java.awt.font.*;
+import java.awt.geom.*;
+
+import java.nio.*;
+
+import java.text.*;
+
+import java.util.*;
+
+import javax.media.opengl.*;
+import javax.media.opengl.glu.*;
+import javax.media.opengl.glu.gl2.*;
+import javax.media.opengl.awt.*;
+
+
+/** Renders bitmapped Java 2D text into an OpenGL window with high
+    performance, full Unicode support, and a simple API. Performs
+    appropriate caching of text rendering results in an OpenGL texture
+    internally to avoid repeated font rasterization. The caching is
+    completely automatic, does not require any user intervention, and
+    has no visible controls in the public API. <P>
+
+    Using the {@link TextRenderer TextRenderer} is simple. Add a
+    "<code>TextRenderer renderer;</code>" field to your {@link
+    javax.media.opengl.GLEventListener GLEventListener}. In your {@link
+    javax.media.opengl.GLEventListener#init init} method, add:
+
+    <PRE>
+    renderer = new TextRenderer(new Font("SansSerif", Font.BOLD, 36));
+    </PRE>
+
+    <P> In the {@link javax.media.opengl.GLEventListener#display display} method of your
+    {@link javax.media.opengl.GLEventListener GLEventListener}, add:
+    <PRE>
+    renderer.beginRendering(drawable.getWidth(), drawable.getHeight());
+    // optionally set the color
+    renderer.setColor(1.0f, 0.2f, 0.2f, 0.8f);
+    renderer.draw("Text to draw", xPosition, yPosition);
+    // ... more draw commands, color changes, etc.
+    renderer.endRendering();
+    </PRE>
+
+    Unless you are sharing textures and display lists between OpenGL
+    contexts, you do not need to call the {@link #dispose dispose}
+    method of the TextRenderer; the OpenGL resources it uses
+    internally will be cleaned up automatically when the OpenGL
+    context is destroyed. <P>
+
+    <b>Note</b> that the TextRenderer may cause the vertex and texture
+    coordinate array buffer bindings to change, or to be unbound. This
+    is important to note if you are using Vertex Buffer Objects (VBOs)
+    in your application. <P>
+
+    Internally, the renderer uses a rectangle packing algorithm to
+    pack both glyphs and full Strings' rendering results (which are
+    variable size) onto a larger OpenGL texture. The internal backing
+    store is maintained using a {@link
+    com.jogamp.opengl.util.awt.TextureRenderer TextureRenderer}. A least
+    recently used (LRU) algorithm is used to discard previously
+    rendered strings; the specific algorithm is undefined, but is
+    currently implemented by flushing unused Strings' rendering
+    results every few hundred rendering cycles, where a rendering
+    cycle is defined as a pair of calls to {@link #beginRendering
+    beginRendering} / {@link #endRendering endRendering}.
+
+    @author John Burkey
+    @author Kenneth Russell
+*/
+public class TextRenderer {
+    private static final boolean DEBUG = Debug.debug("TextRenderer");
+
+    // These are occasionally useful for more in-depth debugging
+    private static final boolean DISABLE_GLYPH_CACHE = false;
+    private static final boolean DRAW_BBOXES = false;
+
+    static final int kSize = 256;
+
+    // Every certain number of render cycles, flush the strings which
+    // haven't been used recently
+    private static final int CYCLES_PER_FLUSH = 100;
+
+    // The amount of vertical dead space on the backing store before we
+    // force a compaction
+    private static final float MAX_VERTICAL_FRAGMENTATION = 0.7f;
+    static final int kQuadsPerBuffer = 100;
+    static final int kCoordsPerVertVerts = 3;
+    static final int kCoordsPerVertTex = 2;
+    static final int kVertsPerQuad = 4;
+    static final int kTotalBufferSizeVerts = kQuadsPerBuffer * kVertsPerQuad;
+    static final int kTotalBufferSizeCoordsVerts = kQuadsPerBuffer * kVertsPerQuad * kCoordsPerVertVerts;
+    static final int kTotalBufferSizeCoordsTex = kQuadsPerBuffer * kVertsPerQuad * kCoordsPerVertTex;
+    static final int kTotalBufferSizeBytesVerts = kTotalBufferSizeCoordsVerts * 4;
+    static final int kTotalBufferSizeBytesTex = kTotalBufferSizeCoordsTex * 4;
+    static final int kSizeInBytes_OneVertices_VertexData = kCoordsPerVertVerts * 4;
+    static final int kSizeInBytes_OneVertices_TexData = kCoordsPerVertTex * 4;
+    private Font font;
+    private boolean antialiased;
+    private boolean useFractionalMetrics;
+
+    // Whether we're attempting to use automatic mipmap generation support
+    private boolean mipmap;
+    private RectanglePacker packer;
+    private boolean haveMaxSize;
+    private RenderDelegate renderDelegate;
+    private TextureRenderer cachedBackingStore;
+    private Graphics2D cachedGraphics;
+    private FontRenderContext cachedFontRenderContext;
+    private Map /*<String,Rect>*/ stringLocations = new HashMap /*<String,Rect>*/();
+    private GlyphProducer mGlyphProducer;
+
+    private int numRenderCycles;
+
+    // Need to keep track of whether we're in a beginRendering() /
+    // endRendering() cycle so we can re-enter the exact same state if
+    // we have to reallocate the backing store
+    private boolean inBeginEndPair;
+    private boolean isOrthoMode;
+    private int beginRenderingWidth;
+    private int beginRenderingHeight;
+    private boolean beginRenderingDepthTestDisabled;
+
+    // For resetting the color after disposal of the old backing store
+    private boolean haveCachedColor;
+    private float cachedR;
+    private float cachedG;
+    private float cachedB;
+    private float cachedA;
+    private Color cachedColor;
+    private boolean needToResetColor;
+
+    // For debugging only
+    private Frame dbgFrame;
+
+    // Debugging purposes only
+    private boolean debugged;
+    Pipelined_QuadRenderer mPipelinedQuadRenderer;
+    
+    //emzic: added boolean flag
+    private boolean useVertexArrays = true;
+    
+    //emzic: added boolean flag
+    private boolean isExtensionAvailable_GL_VERSION_1_5;
+    private boolean checkFor_isExtensionAvailable_GL_VERSION_1_5;
+
+    // Whether GL_LINEAR filtering is enabled for the backing store
+    private boolean smoothing = true;
+
+    /** Creates a new TextRenderer with the given font, using no
+        antialiasing or fractional metrics, and the default
+        RenderDelegate. Equivalent to <code>TextRenderer(font, false,
+        false)</code>.
+
+        @param font the font to render with
+    */
+    public TextRenderer(Font font) {
+        this(font, false, false, null, false);
+    }
+
+    /** Creates a new TextRenderer with the given font, using no
+        antialiasing or fractional metrics, and the default
+        RenderDelegate. If <CODE>mipmap</CODE> is true, attempts to use
+        OpenGL's automatic mipmap generation for better smoothing when
+        rendering the TextureRenderer's contents at a distance.
+        Equivalent to <code>TextRenderer(font, false, false)</code>.
+
+        @param font the font to render with
+        @param mipmap whether to attempt use of automatic mipmap generation
+    */
+    public TextRenderer(Font font, boolean mipmap) {
+        this(font, false, false, null, mipmap);
+    }
+
+    /** Creates a new TextRenderer with the given Font, specified font
+        properties, and default RenderDelegate. The
+        <code>antialiased</code> and <code>useFractionalMetrics</code>
+        flags provide control over the same properties at the Java 2D
+        level. No mipmap support is requested. Equivalent to
+        <code>TextRenderer(font, antialiased, useFractionalMetrics,
+        null)</code>.
+
+        @param font the font to render with
+        @param antialiased whether to use antialiased fonts
+        @param useFractionalMetrics whether to use fractional font
+        metrics at the Java 2D level
+    */
+    public TextRenderer(Font font, boolean antialiased,
+                        boolean useFractionalMetrics) {
+        this(font, antialiased, useFractionalMetrics, null, false);
+    }
+
+    /** Creates a new TextRenderer with the given Font, specified font
+        properties, and given RenderDelegate. The
+        <code>antialiased</code> and <code>useFractionalMetrics</code>
+        flags provide control over the same properties at the Java 2D
+        level. The <code>renderDelegate</code> provides more control
+        over the text rendered. No mipmap support is requested.
+
+        @param font the font to render with
+        @param antialiased whether to use antialiased fonts
+        @param useFractionalMetrics whether to use fractional font
+        metrics at the Java 2D level
+        @param renderDelegate the render delegate to use to draw the
+        text's bitmap, or null to use the default one
+    */
+    public TextRenderer(Font font, boolean antialiased,
+                        boolean useFractionalMetrics, RenderDelegate renderDelegate) {
+        this(font, antialiased, useFractionalMetrics, renderDelegate, false);
+    }
+
+    /** Creates a new TextRenderer with the given Font, specified font
+        properties, and given RenderDelegate. The
+        <code>antialiased</code> and <code>useFractionalMetrics</code>
+        flags provide control over the same properties at the Java 2D
+        level. The <code>renderDelegate</code> provides more control
+        over the text rendered. If <CODE>mipmap</CODE> is true, attempts
+        to use OpenGL's automatic mipmap generation for better smoothing
+        when rendering the TextureRenderer's contents at a distance.
+
+        @param font the font to render with
+        @param antialiased whether to use antialiased fonts
+        @param useFractionalMetrics whether to use fractional font
+        metrics at the Java 2D level
+        @param renderDelegate the render delegate to use to draw the
+        text's bitmap, or null to use the default one
+        @param mipmap whether to attempt use of automatic mipmap generation
+    */
+    public TextRenderer(Font font, boolean antialiased,
+                        boolean useFractionalMetrics, RenderDelegate renderDelegate,
+                        boolean mipmap) {
+        this.font = font;
+        this.antialiased = antialiased;
+        this.useFractionalMetrics = useFractionalMetrics;
+        this.mipmap = mipmap;
+
+        // FIXME: consider adjusting the size based on font size
+        // (it will already automatically resize if necessary)
+        packer = new RectanglePacker(new Manager(), kSize, kSize);
+
+        if (renderDelegate == null) {
+            renderDelegate = new DefaultRenderDelegate();
+        }
+
+        this.renderDelegate = renderDelegate;
+
+        mGlyphProducer = new GlyphProducer(font.getNumGlyphs());
+    }
+
+    /** Returns the bounding rectangle of the given String, assuming it
+        was rendered at the origin. See {@link #getBounds(CharSequence)
+        getBounds(CharSequence)}. */
+    public Rectangle2D getBounds(String str) {
+        return getBounds((CharSequence) str);
+    }
+
+    /** Returns the bounding rectangle of the given CharSequence,
+        assuming it was rendered at the origin. The coordinate system of
+        the returned rectangle is Java 2D's, with increasing Y
+        coordinates in the downward direction. The relative coordinate
+        (0, 0) in the returned rectangle corresponds to the baseline of
+        the leftmost character of the rendered string, in similar
+        fashion to the results returned by, for example, {@link
+        java.awt.font.GlyphVector#getVisualBounds}. Most applications
+        will use only the width and height of the returned Rectangle for
+        the purposes of centering or justifying the String. It is not
+        specified which Java 2D bounds ({@link
+        java.awt.font.GlyphVector#getVisualBounds getVisualBounds},
+        {@link java.awt.font.GlyphVector#getPixelBounds getPixelBounds},
+        etc.) the returned bounds correspond to, although every effort
+        is made to ensure an accurate bound. */
+    public Rectangle2D getBounds(CharSequence str) {
+        // FIXME: this should be more optimized and use the glyph cache
+        Rect r = null;
+
+        if ((r = (Rect) stringLocations.get(str)) != null) {
+            TextData data = (TextData) r.getUserData();
+
+            // Reconstitute the Java 2D results based on the cached values
+            return new Rectangle2D.Double(-data.origin().x, -data.origin().y,
+                                          r.w(), r.h());
+        }
+
+        // Must return a Rectangle compatible with the layout algorithm --
+        // must be idempotent
+        return normalize(renderDelegate.getBounds(str, font,
+                                                  getFontRenderContext()));
+    }
+
+    /** Returns the Font this renderer is using. */
+    public Font getFont() {
+        return font;
+    }
+
+    /** Returns a FontRenderContext which can be used for external
+        text-related size computations. This object should be considered
+        transient and may become invalidated between {@link
+        #beginRendering beginRendering} / {@link #endRendering
+        endRendering} pairs. */
+    public FontRenderContext getFontRenderContext() {
+        if (cachedFontRenderContext == null) {
+            cachedFontRenderContext = getGraphics2D().getFontRenderContext();
+        }
+
+        return cachedFontRenderContext;
+    }
+
+    /** Begins rendering with this {@link TextRenderer TextRenderer}
+        into the current OpenGL drawable, pushing the projection and
+        modelview matrices and some state bits and setting up a
+        two-dimensional orthographic projection with (0, 0) as the
+        lower-left coordinate and (width, height) as the upper-right
+        coordinate. Binds and enables the internal OpenGL texture
+        object, sets the texture environment mode to GL_MODULATE, and
+        changes the current color to the last color set with this
+        TextRenderer via {@link #setColor setColor}. This method
+        disables the depth test and is equivalent to
+        beginRendering(width, height, true).
+
+        @param width the width of the current on-screen OpenGL drawable
+        @param height the height of the current on-screen OpenGL drawable
+        @throws javax.media.opengl.GLException If an OpenGL context is not current when this method is called
+    */
+    public void beginRendering(int width, int height) throws GLException {
+        beginRendering(width, height, true);
+    }
+
+    /** Begins rendering with this {@link TextRenderer TextRenderer}
+        into the current OpenGL drawable, pushing the projection and
+        modelview matrices and some state bits and setting up a
+        two-dimensional orthographic projection with (0, 0) as the
+        lower-left coordinate and (width, height) as the upper-right
+        coordinate. Binds and enables the internal OpenGL texture
+        object, sets the texture environment mode to GL_MODULATE, and
+        changes the current color to the last color set with this
+        TextRenderer via {@link #setColor setColor}. Disables the depth
+        test if the disableDepthTest argument is true.
+
+        @param width the width of the current on-screen OpenGL drawable
+        @param height the height of the current on-screen OpenGL drawable
+        @param disableDepthTest whether to disable the depth test
+        @throws GLException If an OpenGL context is not current when this method is called
+    */
+    public void beginRendering(int width, int height, boolean disableDepthTest)
+        throws GLException {
+        beginRendering(true, width, height, disableDepthTest);
+    }
+
+    /** Begins rendering of 2D text in 3D with this {@link TextRenderer
+        TextRenderer} into the current OpenGL drawable. Assumes the end
+        user is responsible for setting up the modelview and projection
+        matrices, and will render text using the {@link #draw3D draw3D}
+        method. This method pushes some OpenGL state bits, binds and
+        enables the internal OpenGL texture object, sets the texture
+        environment mode to GL_MODULATE, and changes the current color
+        to the last color set with this TextRenderer via {@link
+        #setColor setColor}.
+
+        @throws GLException If an OpenGL context is not current when this method is called
+    */
+    public void begin3DRendering() throws GLException {
+        beginRendering(false, 0, 0, false);
+    }
+
+    /** Changes the current color of this TextRenderer to the supplied
+        one. The default color is opaque white.
+
+        @param color the new color to use for rendering text
+        @throws GLException If an OpenGL context is not current when this method is called
+    */
+    public void setColor(Color color) throws GLException {
+        boolean noNeedForFlush = (haveCachedColor && (cachedColor != null) &&
+                                  color.equals(cachedColor));
+
+        if (!noNeedForFlush) {
+            flushGlyphPipeline();
+        }
+
+        getBackingStore().setColor(color);
+        haveCachedColor = true;
+        cachedColor = color;
+    }
+
+    /** Changes the current color of this TextRenderer to the supplied
+        one, where each component ranges from 0.0f - 1.0f. The alpha
+        component, if used, does not need to be premultiplied into the
+        color channels as described in the documentation for {@link
+        com.jogamp.opengl.util.texture.Texture Texture}, although
+        premultiplied colors are used internally. The default color is
+        opaque white.
+
+        @param r the red component of the new color
+        @param g the green component of the new color
+        @param b the blue component of the new color
+        @param a the alpha component of the new color, 0.0f = completely
+        transparent, 1.0f = completely opaque
+        @throws GLException If an OpenGL context is not current when this method is called
+    */
+    public void setColor(float r, float g, float b, float a)
+        throws GLException {
+        boolean noNeedForFlush = (haveCachedColor && (cachedColor == null) &&
+                                  (r == cachedR) && (g == cachedG) && (b == cachedB) &&
+                                  (a == cachedA));
+
+        if (!noNeedForFlush) {
+            flushGlyphPipeline();
+        }
+
+        getBackingStore().setColor(r, g, b, a);
+        haveCachedColor = true;
+        cachedR = r;
+        cachedG = g;
+        cachedB = b;
+        cachedA = a;
+        cachedColor = null;
+    }
+
+    /** Draws the supplied CharSequence at the desired location using
+        the renderer's current color. The baseline of the leftmost
+        character is at position (x, y) specified in OpenGL coordinates,
+        where the origin is at the lower-left of the drawable and the Y
+        coordinate increases in the upward direction.
+
+        @param str the string to draw
+        @param x the x coordinate at which to draw
+        @param y the y coordinate at which to draw
+        @throws GLException If an OpenGL context is not current when this method is called
+    */
+    public void draw(CharSequence str, int x, int y) throws GLException {
+        draw3D(str, x, y, 0, 1);
+    }
+
+    /** Draws the supplied String at the desired location using the
+        renderer's current color. See {@link #draw(CharSequence, int,
+        int) draw(CharSequence, int, int)}. */
+    public void draw(String str, int x, int y) throws GLException {
+        draw3D(str, x, y, 0, 1);
+    }
+
+    /** Draws the supplied CharSequence at the desired 3D location using
+        the renderer's current color. The baseline of the leftmost
+        character is placed at position (x, y, z) in the current
+        coordinate system.
+
+        @param str the string to draw
+        @param x the x coordinate at which to draw
+        @param y the y coordinate at which to draw
+        @param z the z coordinate at which to draw
+        @param scaleFactor a uniform scale factor applied to the width and height of the drawn rectangle
+        @throws GLException If an OpenGL context is not current when this method is called
+    */
+    public void draw3D(CharSequence str, float x, float y, float z,
+                       float scaleFactor) {
+        internal_draw3D(str, x, y, z, scaleFactor);
+    }
+
+    /** Draws the supplied String at the desired 3D location using the
+        renderer's current color. See {@link #draw3D(CharSequence,
+        float, float, float, float) draw3D(CharSequence, float, float,
+        float, float)}. */
+    public void draw3D(String str, float x, float y, float z, float scaleFactor) {
+        internal_draw3D(str, x, y, z, scaleFactor);
+    }
+
+    /** Returns the pixel width of the given character. */
+    public float getCharWidth(char inChar) {
+        return mGlyphProducer.getGlyphPixelWidth(inChar);
+    }
+
+    /** Causes the TextRenderer to flush any internal caches it may be
+        maintaining and draw its rendering results to the screen. This
+        should be called after each call to draw() if you are setting
+        OpenGL state such as the modelview matrix between calls to
+        draw(). */
+    public void flush() {
+        flushGlyphPipeline();
+    }
+
+    /** Ends a render cycle with this {@link TextRenderer TextRenderer}.
+        Restores the projection and modelview matrices as well as
+        several OpenGL state bits. Should be paired with {@link
+        #beginRendering beginRendering}.
+
+        @throws GLException If an OpenGL context is not current when this method is called
+    */
+    public void endRendering() throws GLException {
+        endRendering(true);
+    }
+
+    /** Ends a 3D render cycle with this {@link TextRenderer TextRenderer}.
+        Restores several OpenGL state bits. Should be paired with {@link
+        #begin3DRendering begin3DRendering}.
+
+        @throws GLException If an OpenGL context is not current when this method is called
+    */
+    public void end3DRendering() throws GLException {
+        endRendering(false);
+    }
+
+    /** Disposes of all resources this TextRenderer is using. It is not
+        valid to use the TextRenderer after this method is called.
+
+        @throws GLException If an OpenGL context is not current when this method is called
+    */
+    public void dispose() throws GLException {
+        packer.dispose();
+        packer = null;
+        cachedBackingStore = null;
+        cachedGraphics = null;
+        cachedFontRenderContext = null;
+
+        if (dbgFrame != null) {
+            dbgFrame.dispose();
+        }
+    }
+
+    //----------------------------------------------------------------------
+    // Internals only below this point
+    //
+
+    private static Rectangle2D preNormalize(Rectangle2D src) {
+        // Need to round to integer coordinates
+        // Also give ourselves a little slop around the reported
+        // bounds of glyphs because it looks like neither the visual
+        // nor the pixel bounds works perfectly well
+        int minX = (int) Math.floor(src.getMinX()) - 1;
+        int minY = (int) Math.floor(src.getMinY()) - 1;
+        int maxX = (int) Math.ceil(src.getMaxX()) + 1;
+        int maxY = (int) Math.ceil(src.getMaxY()) + 1;
+        return new Rectangle2D.Double(minX, minY, maxX - minX, maxY - minY);
+    }
+
+
+    private Rectangle2D normalize(Rectangle2D src) {
+        // Give ourselves a boundary around each entity on the backing
+        // store in order to prevent bleeding of nearby Strings due to
+        // the fact that we use linear filtering
+
+        // NOTE that this boundary is quite heuristic and is related
+        // to how far away in 3D we may view the text --
+        // heuristically, 1.5% of the font's height
+        int boundary = (int) Math.max(1, 0.015 * font.getSize());
+
+        return new Rectangle2D.Double((int) Math.floor(src.getMinX() - boundary),
+                                      (int) Math.floor(src.getMinY() - boundary),
+                                      (int) Math.ceil(src.getWidth() + 2 * boundary),
+                                      (int) Math.ceil(src.getHeight()) + 2 * boundary);
+    }
+
+    private TextureRenderer getBackingStore() {
+        TextureRenderer renderer = (TextureRenderer) packer.getBackingStore();
+
+        if (renderer != cachedBackingStore) {
+            // Backing store changed since last time; discard any cached Graphics2D
+            if (cachedGraphics != null) {
+                cachedGraphics.dispose();
+                cachedGraphics = null;
+                cachedFontRenderContext = null;
+            }
+
+            cachedBackingStore = renderer;
+        }
+
+        return cachedBackingStore;
+    }
+
+    private Graphics2D getGraphics2D() {
+        TextureRenderer renderer = getBackingStore();
+
+        if (cachedGraphics == null) {
+            cachedGraphics = renderer.createGraphics();
+
+            // Set up composite, font and rendering hints
+            cachedGraphics.setComposite(AlphaComposite.Src);
+            cachedGraphics.setColor(Color.WHITE);
+            cachedGraphics.setFont(font);
+            cachedGraphics.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
+                                            (antialiased ? RenderingHints.VALUE_TEXT_ANTIALIAS_ON
+                                             : RenderingHints.VALUE_TEXT_ANTIALIAS_OFF));
+            cachedGraphics.setRenderingHint(RenderingHints.KEY_FRACTIONALMETRICS,
+                                            (useFractionalMetrics
+                                             ? RenderingHints.VALUE_FRACTIONALMETRICS_ON
+                                             : RenderingHints.VALUE_FRACTIONALMETRICS_OFF));
+        }
+
+        return cachedGraphics;
+    }
+
+    private void beginRendering(boolean ortho, int width, int height,
+                                boolean disableDepthTestForOrtho) {
+        GL2 gl = GLContext.getCurrentGL().getGL2();
+
+        if (DEBUG && !debugged) {
+            debug(gl);
+        }
+
+        inBeginEndPair = true;
+        isOrthoMode = ortho;
+        beginRenderingWidth = width;
+        beginRenderingHeight = height;
+        beginRenderingDepthTestDisabled = disableDepthTestForOrtho;
+
+        if (ortho) {
+            getBackingStore().beginOrthoRendering(width, height,
+                                                  disableDepthTestForOrtho);
+        } else {
+            getBackingStore().begin3DRendering();
+        }
+
+        // Push client attrib bits used by the pipelined quad renderer
+        gl.glPushClientAttrib((int) GL2.GL_ALL_CLIENT_ATTRIB_BITS);
+
+        if (!haveMaxSize) {
+            // Query OpenGL for the maximum texture size and set it in the
+            // RectanglePacker to keep it from expanding too large
+            int[] sz = new int[1];
+            gl.glGetIntegerv(GL2.GL_MAX_TEXTURE_SIZE, sz, 0);
+            packer.setMaxSize(sz[0], sz[0]);
+            haveMaxSize = true;
+        }
+
+        if (needToResetColor && haveCachedColor) {
+            if (cachedColor == null) {
+                getBackingStore().setColor(cachedR, cachedG, cachedB, cachedA);
+            } else {
+                getBackingStore().setColor(cachedColor);
+            }
+
+            needToResetColor = false;
+        }
+
+        // Disable future attempts to use mipmapping if TextureRenderer
+        // doesn't support it
+        if (mipmap && !getBackingStore().isUsingAutoMipmapGeneration()) {
+            if (DEBUG) {
+                System.err.println("Disabled mipmapping in TextRenderer");
+            }
+
+            mipmap = false;
+        }
+    }
+
+    /**
+     * emzic: here the call to glBindBuffer crashes on certain graphicscard/driver combinations
+     * this is why the ugly try-catch block has been added, which falls back to the old textrenderer
+     * 
+     * @param ortho
+     * @throws GLException
+     */
+    private void endRendering(boolean ortho) throws GLException {
+        flushGlyphPipeline();
+
+        inBeginEndPair = false;
+
+        GL2 gl = GLContext.getCurrentGL().getGL2();
+
+        // Pop client attrib bits used by the pipelined quad renderer
+        gl.glPopClientAttrib();
+
+        // The OpenGL spec is unclear about whether this changes the
+        // buffer bindings, so preemptively zero out the GL_ARRAY_BUFFER
+        // binding
+        if (is15Available(gl)) {
+            try {
+                gl.glBindBuffer(GL2.GL_ARRAY_BUFFER, 0);
+            } catch (Exception e) {
+                isExtensionAvailable_GL_VERSION_1_5 = false;
+            }
+        }
+
+        if (ortho) {
+            getBackingStore().endOrthoRendering();
+        } else {
+            getBackingStore().end3DRendering();
+        }
+
+        if (++numRenderCycles >= CYCLES_PER_FLUSH) {
+            numRenderCycles = 0;
+
+            if (DEBUG) {
+                System.err.println("Clearing unused entries in endRendering()");
+            }
+
+            clearUnusedEntries();
+        }
+    }
+
+    private void clearUnusedEntries() {
+        final java.util.List deadRects = new ArrayList /*<Rect>*/();
+
+        // Iterate through the contents of the backing store, removing
+        // text strings that haven't been used recently
+        packer.visit(new RectVisitor() {
+                public void visit(Rect rect) {
+                    TextData data = (TextData) rect.getUserData();
+
+                    if (data.used()) {
+                        data.clearUsed();
+                    } else {
+                        deadRects.add(rect);
+                    }
+                }
+            });
+
+        for (Iterator iter = deadRects.iterator(); iter.hasNext();) {
+            Rect r = (Rect) iter.next();
+            packer.remove(r);
+            stringLocations.remove(((TextData) r.getUserData()).string());
+
+            int unicodeToClearFromCache = ((TextData) r.getUserData()).unicodeID;
+
+            if (unicodeToClearFromCache > 0) {
+                mGlyphProducer.clearCacheEntry(unicodeToClearFromCache);
+            }
+
+            //      if (DEBUG) {
+            //        Graphics2D g = getGraphics2D();
+            //        g.setComposite(AlphaComposite.Clear);
+            //        g.fillRect(r.x(), r.y(), r.w(), r.h());
+            //        g.setComposite(AlphaComposite.Src);
+            //      }
+        }
+
+        // If we removed dead rectangles this cycle, try to do a compaction
+        float frag = packer.verticalFragmentationRatio();
+
+        if (!deadRects.isEmpty() && (frag > MAX_VERTICAL_FRAGMENTATION)) {
+            if (DEBUG) {
+                System.err.println(
+                                   "Compacting TextRenderer backing store due to vertical fragmentation " +
+                                   frag);
+            }
+
+            packer.compact();
+        }
+
+        if (DEBUG) {
+            getBackingStore().markDirty(0, 0, getBackingStore().getWidth(),
+                                        getBackingStore().getHeight());
+        }
+    }
+
+    private void internal_draw3D(CharSequence str, float x, float y, float z,
+                                 float scaleFactor) {
+        List/*<Glyph>*/ glyphs = mGlyphProducer.getGlyphs(str);
+        for (Iterator iter = glyphs.iterator(); iter.hasNext(); ) {
+            Glyph glyph = (Glyph) iter.next();
+            float advance = glyph.draw3D(x, y, z, scaleFactor);
+            x += advance * scaleFactor;
+        }
+    }
+
+    private void flushGlyphPipeline() {
+        if (mPipelinedQuadRenderer != null) {
+            mPipelinedQuadRenderer.draw();
+        }
+    }
+
+    private void draw3D_ROBUST(CharSequence str, float x, float y, float z,
+                               float scaleFactor) {
+        String curStr;
+        if (str instanceof String) {
+            curStr = (String) str;
+        } else {
+            curStr = str.toString();
+        }
+
+        // Look up the string on the backing store
+        Rect rect = (Rect) stringLocations.get(curStr);
+
+        if (rect == null) {
+            // Rasterize this string and place it on the backing store
+            Graphics2D g = getGraphics2D();
+            Rectangle2D origBBox = preNormalize(renderDelegate.getBounds(curStr, font, getFontRenderContext()));
+            Rectangle2D bbox = normalize(origBBox);
+            Point origin = new Point((int) -bbox.getMinX(),
+                                     (int) -bbox.getMinY());
+            rect = new Rect(0, 0, (int) bbox.getWidth(),
+                            (int) bbox.getHeight(),
+                            new TextData(curStr, origin, origBBox, -1));
+
+            packer.add(rect);
+            stringLocations.put(curStr, rect);
+
+            // Re-fetch the Graphics2D in case the addition of the rectangle
+            // caused the old backing store to be thrown away
+            g = getGraphics2D();
+
+            // OK, should now have an (x, y) for this rectangle; rasterize
+            // the String
+            int strx = rect.x() + origin.x;
+            int stry = rect.y() + origin.y;
+
+            // Clear out the area we're going to draw into
+            g.setComposite(AlphaComposite.Clear);
+            g.fillRect(rect.x(), rect.y(), rect.w(), rect.h());
+            g.setComposite(AlphaComposite.Src);
+
+            // Draw the string
+            renderDelegate.draw(g, curStr, strx, stry);
+
+            if (DRAW_BBOXES) {
+                TextData data = (TextData) rect.getUserData();
+                // Draw a bounding box on the backing store
+                g.drawRect(strx - data.origOriginX(),
+                           stry - data.origOriginY(),
+                           (int) data.origRect().getWidth(),
+                           (int) data.origRect().getHeight());
+                g.drawRect(strx - data.origin().x,
+                           stry - data.origin().y,
+                           rect.w(),
+                           rect.h());
+            }
+
+            // Mark this region of the TextureRenderer as dirty
+            getBackingStore().markDirty(rect.x(), rect.y(), rect.w(),
+                                        rect.h());
+        }
+
+        // OK, now draw the portion of the backing store to the screen
+        TextureRenderer renderer = getBackingStore();
+
+        // NOTE that the rectangles managed by the packer have their
+        // origin at the upper-left but the TextureRenderer's origin is
+        // at its lower left!!!
+        TextData data = (TextData) rect.getUserData();
+        data.markUsed();
+
+        Rectangle2D origRect = data.origRect();
+        
+        // Align the leftmost point of the baseline to the (x, y, z) coordinate requested
+        renderer.draw3DRect(x - (scaleFactor * data.origOriginX()),
+                            y - (scaleFactor * ((float) origRect.getHeight() - data.origOriginY())), z,
+                            rect.x() + (data.origin().x - data.origOriginX()),
+                            renderer.getHeight() - rect.y() - (int) origRect.getHeight() -
+                              (data.origin().y - data.origOriginY()),
+                            (int) origRect.getWidth(), (int) origRect.getHeight(), scaleFactor);
+    }
+
+    //----------------------------------------------------------------------
+    // Debugging functionality
+    //
+    private void debug(GL gl) {
+        dbgFrame = new Frame("TextRenderer Debug Output");
+
+        GLCanvas dbgCanvas = new GLCanvas(new GLCapabilities(gl.getGLProfile()), null,
+                                          GLContext.getCurrent(), null);
+        dbgCanvas.addGLEventListener(new DebugListener(gl, dbgFrame));
+        dbgFrame.add(dbgCanvas);
+
+        final FPSAnimator anim = new FPSAnimator(dbgCanvas, 10);
+        dbgFrame.addWindowListener(new WindowAdapter() {
+                public void windowClosing(WindowEvent e) {
+                    // Run this on another thread than the AWT event queue to
+                    // make sure the call to Animator.stop() completes before
+                    // exiting
+                    new Thread(new Runnable() {
+                            public void run() {
+                                anim.stop();
+                            }
+                        }).start();
+                }
+            });
+        dbgFrame.setSize(kSize, kSize);
+        dbgFrame.setVisible(true);
+        anim.start();
+        debugged = true;
+    }
+
+    /** Class supporting more full control over the process of rendering
+        the bitmapped text. Allows customization of whether the backing
+        store text bitmap is full-color or intensity only, the size of
+        each individual rendered text rectangle, and the contents of
+        each individual rendered text string. The default implementation
+        of this interface uses an intensity-only texture, a
+        closely-cropped rectangle around the text, and renders text
+        using the color white, which is modulated by the set color
+        during the rendering process. */
+    public static interface RenderDelegate {
+        /** Indicates whether the backing store of this TextRenderer
+            should be intensity-only (the default) or full-color. */
+        public boolean intensityOnly();
+
+        /** Computes the bounds of the given String relative to the
+            origin. */
+        public Rectangle2D getBounds(String str, Font font,
+                                     FontRenderContext frc);
+
+        /** Computes the bounds of the given character sequence relative
+            to the origin. */
+        public Rectangle2D getBounds(CharSequence str, Font font,
+                                     FontRenderContext frc);
+
+        /** Computes the bounds of the given GlyphVector, already
+            assumed to have been created for a particular Font,
+            relative to the origin. */
+        public Rectangle2D getBounds(GlyphVector gv, FontRenderContext frc);
+
+        /** Render the passed character sequence at the designated
+            location using the supplied Graphics2D instance. The
+            surrounding region will already have been cleared to the RGB
+            color (0, 0, 0) with zero alpha. The initial drawing context
+            of the passed Graphics2D will be set to use
+            AlphaComposite.Src, the color white, the Font specified in the
+            TextRenderer's constructor, and the rendering hints specified
+            in the TextRenderer constructor.  Changes made by the end user
+            may be visible in successive calls to this method, but are not
+            guaranteed to be preserved.  Implementors of this method
+            should reset the Graphics2D's state to that desired each time
+            this method is called, in particular those states which are
+            not the defaults. */
+        public void draw(Graphics2D graphics, String str, int x, int y);
+
+        /** Render the passed GlyphVector at the designated location using
+            the supplied Graphics2D instance. The surrounding region will
+            already have been cleared to the RGB color (0, 0, 0) with zero
+            alpha. The initial drawing context of the passed Graphics2D
+            will be set to use AlphaComposite.Src, the color white, the
+            Font specified in the TextRenderer's constructor, and the
+            rendering hints specified in the TextRenderer constructor.
+            Changes made by the end user may be visible in successive
+            calls to this method, but are not guaranteed to be preserved.
+            Implementors of this method should reset the Graphics2D's
+            state to that desired each time this method is called, in
+            particular those states which are not the defaults. */
+        public void drawGlyphVector(Graphics2D graphics, GlyphVector str,
+                                    int x, int y);
+    }
+
+    private static class CharSequenceIterator implements CharacterIterator {
+        CharSequence mSequence;
+        int mLength;
+        int mCurrentIndex;
+
+        CharSequenceIterator() {
+        }
+
+        CharSequenceIterator(CharSequence sequence) {
+            initFromCharSequence(sequence);
+        }
+
+        public void initFromCharSequence(CharSequence sequence) {
+            mSequence = sequence;
+            mLength = mSequence.length();
+            mCurrentIndex = 0;
+        }
+
+        public char last() {
+            mCurrentIndex = Math.max(0, mLength - 1);
+
+            return current();
+        }
+
+        public char current() {
+            if ((mLength == 0) || (mCurrentIndex >= mLength)) {
+                return CharacterIterator.DONE;
+            }
+
+            return mSequence.charAt(mCurrentIndex);
+        }
+
+        public char next() {
+            mCurrentIndex++;
+
+            return current();
+        }
+
+        public char previous() {
+            mCurrentIndex = Math.max(mCurrentIndex - 1, 0);
+
+            return current();
+        }
+
+        public char setIndex(int position) {
+            mCurrentIndex = position;
+
+            return current();
+        }
+
+        public int getBeginIndex() {
+            return 0;
+        }
+
+        public int getEndIndex() {
+            return mLength;
+        }
+
+        public int getIndex() {
+            return mCurrentIndex;
+        }
+
+        public Object clone() {
+            CharSequenceIterator iter = new CharSequenceIterator(mSequence);
+            iter.mCurrentIndex = mCurrentIndex;
+
+            return iter;
+        }
+
+        public char first() {
+            if (mLength == 0) {
+                return CharacterIterator.DONE;
+            }
+
+            mCurrentIndex = 0;
+
+            return current();
+        }
+    }
+
+    // Data associated with each rectangle of text
+    static class TextData {
+        // Back-pointer to String this TextData describes, if it
+        // represents a String rather than a single glyph
+        private String str;
+
+        // If this TextData represents a single glyph, this is its
+        // unicode ID
+        int unicodeID;
+
+        // The following must be defined and used VERY precisely. This is
+        // the offset from the upper-left corner of this rectangle (Java
+        // 2D coordinate system) at which the string must be rasterized in
+        // order to fit within the rectangle -- the leftmost point of the
+        // baseline.
+        private Point origin;
+
+        // This represents the pre-normalized rectangle, which fits
+        // within the rectangle on the backing store. We keep a
+        // one-pixel border around entries on the backing store to
+        // prevent bleeding of adjacent letters when using GL_LINEAR
+        // filtering for rendering. The origin of this rectangle is
+        // equivalent to the origin above.
+        private Rectangle2D origRect;
+
+        private boolean used; // Whether this text was used recently
+
+        TextData(String str, Point origin, Rectangle2D origRect, int unicodeID) {
+            this.str = str;
+            this.origin = origin;
+            this.origRect = origRect;
+            this.unicodeID = unicodeID;
+        }
+
+        String string() {
+            return str;
+        }
+
+        Point origin() {
+            return origin;
+        }
+
+        // The following three methods are used to locate the glyph
+        // within the expanded rectangle coming from normalize()
+        int origOriginX() {
+            return (int) -origRect.getMinX();
+        }
+
+        int origOriginY() {
+            return (int) -origRect.getMinY();
+        }
+
+        Rectangle2D origRect() {
+            return origRect;
+        }
+
+        boolean used() {
+            return used;
+        }
+
+        void markUsed() {
+            used = true;
+        }
+
+        void clearUsed() {
+            used = false;
+        }
+    }
+
+    class Manager implements BackingStoreManager {
+        private Graphics2D g;
+
+        public Object allocateBackingStore(int w, int h) {
+            // FIXME: should consider checking Font's attributes to see
+            // whether we're likely to need to support a full RGBA backing
+            // store (i.e., non-default Paint, foreground color, etc.), but
+            // for now, let's just be more efficient
+            TextureRenderer renderer;
+
+            if (renderDelegate.intensityOnly()) {
+                renderer = TextureRenderer.createAlphaOnlyRenderer(w, h, mipmap);
+            } else {
+                renderer = new TextureRenderer(w, h, true, mipmap);
+            }
+            renderer.setSmoothing(smoothing);
+
+            if (DEBUG) {
+                System.err.println(" TextRenderer allocating backing store " +
+                                   w + " x " + h);
+            }
+
+            return renderer;
+        }
+
+        public void deleteBackingStore(Object backingStore) {
+            ((TextureRenderer) backingStore).dispose();
+        }
+
+        public boolean preExpand(Rect cause, int attemptNumber) {
+            // Only try this one time; clear out potentially obsolete entries
+            // NOTE: this heuristic and the fact that it clears the used bit
+            // of all entries seems to cause cycling of entries in some
+            // situations, where the backing store becomes small compared to
+            // the amount of text on the screen (see the TextFlow demo) and
+            // the entries continually cycle in and out of the backing
+            // store, decreasing performance. If we added a little age
+            // information to the entries, and only cleared out entries
+            // above a certain age, this behavior would be eliminated.
+            // However, it seems the system usually stabilizes itself, so
+            // for now we'll just keep things simple. Note that if we don't
+            // clear the used bit here, the backing store tends to increase
+            // very quickly to its maximum size, at least with the TextFlow
+            // demo when the text is being continually re-laid out.
+            if (attemptNumber == 0) {
+                if (DEBUG) {
+                    System.err.println(
+                        "Clearing unused entries in preExpand(): attempt number " +
+                        attemptNumber);
+                }
+
+                if (inBeginEndPair) {
+                    // Draw any outstanding glyphs
+                    flush();
+                }
+
+                clearUnusedEntries();
+
+                return true;
+            }
+
+            return false;
+        }
+
+        public boolean additionFailed(Rect cause, int attemptNumber) {
+            // Heavy hammer -- might consider doing something different
+            packer.clear();
+            stringLocations.clear();
+            mGlyphProducer.clearAllCacheEntries();
+
+            if (DEBUG) {
+                System.err.println(
+                                   " *** Cleared all text because addition failed ***");
+            }
+
+            if (attemptNumber == 0) {
+                return true;
+            }
+
+            return false;
+        }
+
+        public boolean canCompact() {
+            return true;
+        }
+
+        public void beginMovement(Object oldBackingStore, Object newBackingStore) {
+            // Exit the begin / end pair if necessary
+            if (inBeginEndPair) {
+                // Draw any outstanding glyphs
+                flush();
+
+                GL2 gl = GLContext.getCurrentGL().getGL2();
+
+                // Pop client attrib bits used by the pipelined quad renderer
+                gl.glPopClientAttrib();
+
+                // The OpenGL spec is unclear about whether this changes the
+                // buffer bindings, so preemptively zero out the GL_ARRAY_BUFFER
+                // binding
+                if (is15Available(gl)) {
+                    try {
+                        gl.glBindBuffer(GL2.GL_ARRAY_BUFFER, 0);
+                    } catch (Exception e) {
+                        isExtensionAvailable_GL_VERSION_1_5 = false;
+                    }
+                }
+
+                if (isOrthoMode) {
+                    ((TextureRenderer) oldBackingStore).endOrthoRendering();
+                } else {
+                    ((TextureRenderer) oldBackingStore).end3DRendering();
+                }
+            }
+
+            TextureRenderer newRenderer = (TextureRenderer) newBackingStore;
+            g = newRenderer.createGraphics();
+        }
+
+        public void move(Object oldBackingStore, Rect oldLocation,
+                         Object newBackingStore, Rect newLocation) {
+            TextureRenderer oldRenderer = (TextureRenderer) oldBackingStore;
+            TextureRenderer newRenderer = (TextureRenderer) newBackingStore;
+
+            if (oldRenderer == newRenderer) {
+                // Movement on the same backing store -- easy case
+                g.copyArea(oldLocation.x(), oldLocation.y(), oldLocation.w(),
+                           oldLocation.h(), newLocation.x() - oldLocation.x(),
+                           newLocation.y() - oldLocation.y());
+            } else {
+                // Need to draw from the old renderer's image into the new one
+                Image img = oldRenderer.getImage();
+                g.drawImage(img, newLocation.x(), newLocation.y(),
+                            newLocation.x() + newLocation.w(),
+                            newLocation.y() + newLocation.h(), oldLocation.x(),
+                            oldLocation.y(), oldLocation.x() + oldLocation.w(),
+                            oldLocation.y() + oldLocation.h(), null);
+            }
+        }
+
+        public void endMovement(Object oldBackingStore, Object newBackingStore) {
+            g.dispose();
+
+            // Sync the whole surface
+            TextureRenderer newRenderer = (TextureRenderer) newBackingStore;
+            newRenderer.markDirty(0, 0, newRenderer.getWidth(),
+                                  newRenderer.getHeight());
+
+            // Re-enter the begin / end pair if necessary
+            if (inBeginEndPair) {
+                if (isOrthoMode) {
+                    ((TextureRenderer) newBackingStore).beginOrthoRendering(beginRenderingWidth,
+                                                                            beginRenderingHeight, beginRenderingDepthTestDisabled);
+                } else {
+                    ((TextureRenderer) newBackingStore).begin3DRendering();
+                }
+
+                // Push client attrib bits used by the pipelined quad renderer
+                GL2 gl = GLContext.getCurrentGL().getGL2();
+                gl.glPushClientAttrib((int) GL2.GL_ALL_CLIENT_ATTRIB_BITS);
+
+                if (haveCachedColor) {
+                    if (cachedColor == null) {
+                        ((TextureRenderer) newBackingStore).setColor(cachedR,
+                                                                     cachedG, cachedB, cachedA);
+                    } else {
+                        ((TextureRenderer) newBackingStore).setColor(cachedColor);
+                    }
+                }
+            } else {
+                needToResetColor = true;
+            }
+        }
+    }
+
+    public static class DefaultRenderDelegate implements RenderDelegate {
+        public boolean intensityOnly() {
+            return true;
+        }
+
+        public Rectangle2D getBounds(CharSequence str, Font font,
+                                     FontRenderContext frc) {
+            return getBounds(font.createGlyphVector(frc,
+                                                    new CharSequenceIterator(str)),
+                             frc);
+        }
+
+        public Rectangle2D getBounds(String str, Font font,
+                                     FontRenderContext frc) {
+            return getBounds(font.createGlyphVector(frc, str), frc);
+        }
+
+        public Rectangle2D getBounds(GlyphVector gv, FontRenderContext frc) {
+            return gv.getVisualBounds();
+        }
+
+        public void drawGlyphVector(Graphics2D graphics, GlyphVector str,
+                                    int x, int y) {
+            graphics.drawGlyphVector(str, x, y);
+        }
+
+        public void draw(Graphics2D graphics, String str, int x, int y) {
+            graphics.drawString(str, x, y);
+        }
+    }
+
+    //----------------------------------------------------------------------
+    // Glyph-by-glyph rendering support
+    //
+
+    // A temporary to prevent excessive garbage creation
+    private char[] singleUnicode = new char[1];
+
+    /** A Glyph represents either a single unicode glyph or a
+        substring of characters to be drawn. The reason for the dual
+        behavior is so that we can take in a sequence of unicode
+        characters and partition them into runs of individual glyphs,
+        but if we encounter complex text and/or unicode sequences we
+        don't understand, we can render them using the
+        string-by-string method. <P>
+
+        Glyphs need to be able to re-upload themselves to the backing
+        store on demand as we go along in the render sequence.
+    */
+
+    class Glyph {
+        // If this Glyph represents an individual unicode glyph, this
+        // is its unicode ID. If it represents a String, this is -1.
+        private int unicodeID;
+        // If the above field isn't -1, then these fields are used.
+        // The glyph code in the font
+        private int glyphCode;
+        // The GlyphProducer which created us
+        private GlyphProducer producer;
+        // The advance of this glyph
+        private float advance;
+        // The GlyphVector for this single character; this is passed
+        // in during construction but cleared during the upload
+        // process
+        private GlyphVector singleUnicodeGlyphVector;
+        // The rectangle of this glyph on the backing store, or null
+        // if it has been cleared due to space pressure
+        private Rect glyphRectForTextureMapping;
+        // If this Glyph represents a String, this is the sequence of
+        // characters
+        private String str;
+        // Whether we need a valid advance when rendering this string
+        // (i.e., whether it has other single glyphs coming after it)
+        private boolean needAdvance;
+
+        // Creates a Glyph representing an individual Unicode character
+        public Glyph(int unicodeID,
+                     int glyphCode,
+                     float advance,
+                     GlyphVector singleUnicodeGlyphVector,
+                     GlyphProducer producer) {
+            this.unicodeID = unicodeID;
+            this.glyphCode = glyphCode;
+            this.advance = advance;
+            this.singleUnicodeGlyphVector = singleUnicodeGlyphVector;
+            this.producer = producer;
+        }
+
+        // Creates a Glyph representing a sequence of characters, with
+        // an indication of whether additional single glyphs are being
+        // rendered after it
+        public Glyph(String str, boolean needAdvance) {
+            this.str = str;
+            this.needAdvance = needAdvance;
+        }
+
+        /** Returns this glyph's unicode ID */
+        public int getUnicodeID() {
+            return unicodeID;
+        }
+
+        /** Returns this glyph's (font-specific) glyph code */
+        public int getGlyphCode() {
+            return glyphCode;
+        }
+
+        /** Returns the advance for this glyph */
+        public float getAdvance() {
+            return advance;
+        }
+
+        /** Draws this glyph and returns the (x) advance for this glyph */
+        public float draw3D(float inX, float inY, float z, float scaleFactor) {
+            if (str != null) {
+                draw3D_ROBUST(str, inX, inY, z, scaleFactor);
+                if (!needAdvance) {
+                    return 0;
+                }
+                // Compute and return the advance for this string
+                GlyphVector gv = font.createGlyphVector(getFontRenderContext(), str);
+                float totalAdvance = 0;
+                for (int i = 0; i < gv.getNumGlyphs(); i++) {
+                    totalAdvance += gv.getGlyphMetrics(i).getAdvance();
+                }
+                return totalAdvance;
+            }
+
+            // This is the code path taken for individual glyphs
+            if (glyphRectForTextureMapping == null) {
+                upload();
+            }
+
+            try {
+                if (mPipelinedQuadRenderer == null) {
+                    mPipelinedQuadRenderer = new Pipelined_QuadRenderer();
+                }
+
+                TextureRenderer renderer = getBackingStore();
+                // Handles case where NPOT texture is used for backing store
+                TextureCoords wholeImageTexCoords = renderer.getTexture().getImageTexCoords();
+                float xScale = wholeImageTexCoords.right();
+                float yScale = wholeImageTexCoords.bottom();
+
+                Rect rect = glyphRectForTextureMapping;
+                TextData data = (TextData) rect.getUserData();
+                data.markUsed();
+
+                Rectangle2D origRect = data.origRect();
+
+                float x = inX - (scaleFactor * data.origOriginX());
+                float y = inY - (scaleFactor * ((float) origRect.getHeight() - data.origOriginY()));
+
+                int texturex = rect.x() + (data.origin().x - data.origOriginX());
+                int texturey = renderer.getHeight() - rect.y() - (int) origRect.getHeight() -
+                    (data.origin().y - data.origOriginY());
+                int width = (int) origRect.getWidth();
+                int height = (int) origRect.getHeight();
+
+                float tx1 = xScale * (float) texturex / (float) renderer.getWidth();
+                float ty1 = yScale * (1.0f -
+                                      ((float) texturey / (float) renderer.getHeight()));
+                float tx2 = xScale * (float) (texturex + width) / (float) renderer.getWidth();
+                float ty2 = yScale * (1.0f -
+                                      ((float) (texturey + height) / (float) renderer.getHeight()));
+
+                mPipelinedQuadRenderer.glTexCoord2f(tx1, ty1);
+                mPipelinedQuadRenderer.glVertex3f(x, y, z);
+                mPipelinedQuadRenderer.glTexCoord2f(tx2, ty1);
+                mPipelinedQuadRenderer.glVertex3f(x + (width * scaleFactor), y,
+                                                  z);
+                mPipelinedQuadRenderer.glTexCoord2f(tx2, ty2);
+                mPipelinedQuadRenderer.glVertex3f(x + (width * scaleFactor),
+                                                  y + (height * scaleFactor), z);
+                mPipelinedQuadRenderer.glTexCoord2f(tx1, ty2);
+                mPipelinedQuadRenderer.glVertex3f(x,
+                                                  y + (height * scaleFactor), z);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+            return advance;
+        }
+
+        /** Notifies this glyph that it's been cleared out of the cache */
+        public void clear() {
+            glyphRectForTextureMapping = null;
+        }
+
+        private void upload() {
+            GlyphVector gv = getGlyphVector();
+            Rectangle2D origBBox = preNormalize(renderDelegate.getBounds(gv, getFontRenderContext()));
+            Rectangle2D bbox = normalize(origBBox);
+            Point origin = new Point((int) -bbox.getMinX(),
+                                     (int) -bbox.getMinY());
+            Rect rect = new Rect(0, 0, (int) bbox.getWidth(),
+                                 (int) bbox.getHeight(),
+                                 new TextData(null, origin, origBBox, unicodeID));
+            packer.add(rect);
+            glyphRectForTextureMapping = rect;
+            Graphics2D g = getGraphics2D();
+            // OK, should now have an (x, y) for this rectangle; rasterize
+            // the glyph
+            int strx = rect.x() + origin.x;
+            int stry = rect.y() + origin.y;
+
+            // Clear out the area we're going to draw into
+            g.setComposite(AlphaComposite.Clear);
+            g.fillRect(rect.x(), rect.y(), rect.w(), rect.h());
+            g.setComposite(AlphaComposite.Src);
+
+            // Draw the string
+            renderDelegate.drawGlyphVector(g, gv, strx, stry);
+
+            if (DRAW_BBOXES) {
+                TextData data = (TextData) rect.getUserData();
+                // Draw a bounding box on the backing store
+                g.drawRect(strx - data.origOriginX(),
+                           stry - data.origOriginY(),
+                           (int) data.origRect().getWidth(),
+                           (int) data.origRect().getHeight());
+                g.drawRect(strx - data.origin().x,
+                           stry - data.origin().y,
+                           rect.w(),
+                           rect.h());
+            }
+
+            // Mark this region of the TextureRenderer as dirty
+            getBackingStore().markDirty(rect.x(), rect.y(), rect.w(),
+                                        rect.h());
+            // Re-register ourselves with our producer
+            producer.register(this);
+        }
+
+        private GlyphVector getGlyphVector() {
+            GlyphVector gv = singleUnicodeGlyphVector;
+            if (gv != null) {
+                singleUnicodeGlyphVector = null; // Don't need this anymore
+                return gv;
+            }
+            singleUnicode[0] = (char) unicodeID;
+            return font.createGlyphVector(getFontRenderContext(), singleUnicode);
+        }
+    }
+
+    class GlyphProducer {
+        final int undefined = -2;
+        FontRenderContext fontRenderContext;
+        List/*<Glyph>*/ glyphsOutput = new ArrayList/*<Glyph>*/();
+        // The mapping from unicode character to font-specific glyph ID
+        int[] unicodes2Glyphs;
+        // The mapping from glyph ID to Glyph
+        Glyph[] glyphCache;
+        // We re-use this for each incoming string
+        CharSequenceIterator iter = new CharSequenceIterator();
+
+        GlyphProducer(int fontLengthInGlyphs) {
+            unicodes2Glyphs = new int[512];
+            glyphCache = new Glyph[fontLengthInGlyphs];
+            clearAllCacheEntries();
+        }
+
+        public List/*<Glyph>*/ getGlyphs(CharSequence inString) {
+            glyphsOutput.clear();
+            iter.initFromCharSequence(inString);
+            GlyphVector fullRunGlyphVector = font.createGlyphVector(getFontRenderContext(),
+                                                                    iter);
+            boolean complex = (fullRunGlyphVector.getLayoutFlags() != 0);
+            if (complex || DISABLE_GLYPH_CACHE) {
+                // Punt to the robust version of the renderer
+                glyphsOutput.add(new Glyph(inString.toString(), false));
+                return glyphsOutput;
+            }
+
+            int lengthInGlyphs = fullRunGlyphVector.getNumGlyphs();
+            int i = 0;
+            while (i < lengthInGlyphs) {
+                Glyph glyph = getGlyph(inString, fullRunGlyphVector, i);
+                if (glyph != null) {
+                    glyphsOutput.add(glyph);
+                    i++;
+                } else {
+                    // Assemble a run of characters that don't fit in
+                    // the cache
+                    StringBuffer buf = new StringBuffer();
+                    while (i < lengthInGlyphs &&
+                           getGlyph(inString, fullRunGlyphVector, i) == null) {
+                        buf.append(inString.charAt(i++));
+                    }
+                    glyphsOutput.add(new Glyph(buf.toString(),
+                                               // Any more glyphs after this run?
+                                               i < lengthInGlyphs));
+                }
+            }
+            return glyphsOutput;
+        }
+
+        public void clearCacheEntry(int unicodeID) {
+            int glyphID = unicodes2Glyphs[unicodeID];
+            if (glyphID != undefined) {
+                Glyph glyph = glyphCache[glyphID];
+                if (glyph != null) {
+                    glyph.clear();
+                }
+                glyphCache[glyphID] = null;
+            }
+            unicodes2Glyphs[unicodeID] = undefined;
+        }
+
+        public void clearAllCacheEntries() {
+            for (int i = 0; i < unicodes2Glyphs.length; i++) {
+                clearCacheEntry(i);
+            }
+        }
+
+        public void register(Glyph glyph) {
+            unicodes2Glyphs[glyph.getUnicodeID()] = glyph.getGlyphCode();
+            glyphCache[glyph.getGlyphCode()] = glyph;
+        }
+
+        public float getGlyphPixelWidth(char unicodeID) {
+            Glyph glyph = getGlyph(unicodeID);
+            if (glyph != null) {
+                return glyph.getAdvance();
+            }
+
+            // Have to do this the hard / uncached way
+            singleUnicode[0] = unicodeID;
+            GlyphVector gv = font.createGlyphVector(fontRenderContext,
+                                                                    singleUnicode);
+            return gv.getGlyphMetrics(0).getAdvance();
+        }
+
+        // Returns a glyph object for this single glyph. Returns null
+        // if the unicode or glyph ID would be out of bounds of the
+        // glyph cache.
+        private Glyph getGlyph(CharSequence inString,
+                               GlyphVector fullRunGlyphVector,
+                               int index) {
+            char unicodeID = inString.charAt(index);
+
+            if (unicodeID >= unicodes2Glyphs.length) {
+                return null;
+            }
+
+            int glyphID = unicodes2Glyphs[unicodeID];
+            if (glyphID != undefined) {
+                return glyphCache[glyphID];
+            }
+
+            // Must fabricate the glyph
+            singleUnicode[0] = unicodeID;
+            GlyphVector gv = font.createGlyphVector(getFontRenderContext(), singleUnicode);
+            return getGlyph(unicodeID, gv, fullRunGlyphVector.getGlyphMetrics(index));
+        }
+
+        // It's unclear whether this variant might produce less
+        // optimal results than if we can see the entire GlyphVector
+        // for the incoming string
+        private Glyph getGlyph(int unicodeID) {
+            if (unicodeID >= unicodes2Glyphs.length) {
+                return null;
+            }
+
+            int glyphID = unicodes2Glyphs[unicodeID];
+            if (glyphID != undefined) {
+                return glyphCache[glyphID];
+            }
+            singleUnicode[0] = (char) unicodeID;
+            GlyphVector gv = font.createGlyphVector(getFontRenderContext(), singleUnicode);
+            return getGlyph(unicodeID, gv, gv.getGlyphMetrics(0));
+        }
+
+        private Glyph getGlyph(int unicodeID,
+                               GlyphVector singleUnicodeGlyphVector,
+                               GlyphMetrics metrics) {
+            int glyphCode = singleUnicodeGlyphVector.getGlyphCode(0);
+            // Have seen huge glyph codes (65536) coming out of some fonts in some Unicode situations
+            if (glyphCode >= glyphCache.length) {
+                return null;
+            }
+            Glyph glyph = new Glyph(unicodeID,
+                                    glyphCode,
+                                    metrics.getAdvance(),
+                                    singleUnicodeGlyphVector,
+                                    this);
+            register(glyph);
+            return glyph;
+        }
+    }
+
+    class Pipelined_QuadRenderer {
+        int mOutstandingGlyphsVerticesPipeline = 0;
+        FloatBuffer mTexCoords;
+        FloatBuffer mVertCoords;
+        boolean usingVBOs;
+        int mVBO_For_ResuableTileVertices;
+        int mVBO_For_ResuableTileTexCoords;
+
+        Pipelined_QuadRenderer() {
+            GL2 gl = GLContext.getCurrentGL().getGL2();
+            mVertCoords = BufferUtil.newFloatBuffer(kTotalBufferSizeCoordsVerts);
+            mTexCoords = BufferUtil.newFloatBuffer(kTotalBufferSizeCoordsTex);
+
+            usingVBOs = is15Available(gl);
+
+            if (usingVBOs) {
+                try {
+                    int[] vbos = new int[2];
+                    gl.glGenBuffers(2, IntBuffer.wrap(vbos));
+
+                    mVBO_For_ResuableTileVertices = vbos[0];
+                    mVBO_For_ResuableTileTexCoords = vbos[1];
+
+                    gl.glBindBuffer(GL2.GL_ARRAY_BUFFER,
+                                    mVBO_For_ResuableTileVertices);
+                    gl.glBufferData(GL2.GL_ARRAY_BUFFER, kTotalBufferSizeBytesVerts,
+                                    null, GL2.GL_STREAM_DRAW); // stream draw because this is a single quad use pipeline
+
+                    gl.glBindBuffer(GL2.GL_ARRAY_BUFFER,
+                                    mVBO_For_ResuableTileTexCoords);
+                    gl.glBufferData(GL2.GL_ARRAY_BUFFER, kTotalBufferSizeBytesTex,
+                                    null, GL2.GL_STREAM_DRAW); // stream draw because this is a single quad use pipeline
+                } catch (Exception e) {
+                    isExtensionAvailable_GL_VERSION_1_5 = false;
+                    usingVBOs = false;
+                }
+            }
+        }
+
+        public void glTexCoord2f(float v, float v1) {
+            mTexCoords.put(v);
+            mTexCoords.put(v1);
+        }
+
+        public void glVertex3f(float inX, float inY, float inZ) {
+            mVertCoords.put(inX);
+            mVertCoords.put(inY);
+            mVertCoords.put(inZ);
+
+            mOutstandingGlyphsVerticesPipeline++;
+
+            if (mOutstandingGlyphsVerticesPipeline >= kTotalBufferSizeVerts) {
+                this.draw();
+            }
+        }
+
+        private void draw() {
+            if (useVertexArrays) {
+                drawVertexArrays();
+            } else {
+                drawIMMEDIATE();
+            }
+        }
+
+        private void drawVertexArrays() {
+            if (mOutstandingGlyphsVerticesPipeline > 0) {
+                GL2 gl = GLContext.getCurrentGL().getGL2();
+
+                TextureRenderer renderer = getBackingStore();
+                Texture texture = renderer.getTexture(); // triggers texture uploads.  Maybe this should be more obvious?
+
+                mVertCoords.rewind();
+                mTexCoords.rewind();
+
+                gl.glEnableClientState(GL2.GL_VERTEX_ARRAY);
+
+                if (usingVBOs) {
+                    gl.glBindBuffer(GL2.GL_ARRAY_BUFFER,
+                                    mVBO_For_ResuableTileVertices);
+                    gl.glBufferSubData(GL2.GL_ARRAY_BUFFER, 0,
+                                       mOutstandingGlyphsVerticesPipeline * kSizeInBytes_OneVertices_VertexData,
+                                       mVertCoords); // upload only the new stuff
+                    gl.glVertexPointer(3, GL2.GL_FLOAT, 0, 0);
+                } else {
+                    gl.glVertexPointer(3, GL2.GL_FLOAT, 0, mVertCoords);
+                }
+
+                gl.glEnableClientState(GL2.GL_TEXTURE_COORD_ARRAY);
+
+                if (usingVBOs) {
+                    gl.glBindBuffer(GL2.GL_ARRAY_BUFFER,
+                                    mVBO_For_ResuableTileTexCoords);
+                    gl.glBufferSubData(GL2.GL_ARRAY_BUFFER, 0,
+                                       mOutstandingGlyphsVerticesPipeline * kSizeInBytes_OneVertices_TexData,
+                                       mTexCoords); // upload only the new stuff
+                    gl.glTexCoordPointer(2, GL2.GL_FLOAT, 0, 0);
+                } else {
+                    gl.glTexCoordPointer(2, GL2.GL_FLOAT, 0, mTexCoords);
+                }
+
+                gl.glDrawArrays(GL2.GL_QUADS, 0,
+                                mOutstandingGlyphsVerticesPipeline);
+
+                mVertCoords.rewind();
+                mTexCoords.rewind();
+                mOutstandingGlyphsVerticesPipeline = 0;
+            }
+        }
+
+        private void drawIMMEDIATE() {
+            if (mOutstandingGlyphsVerticesPipeline > 0) {
+                TextureRenderer renderer = getBackingStore();
+                Texture texture = renderer.getTexture(); // triggers texture uploads.  Maybe this should be more obvious?
+
+                GL2 gl = GLContext.getCurrentGL().getGL2();
+                gl.glBegin(GL2.GL_QUADS);
+
+                try {
+                    int numberOfQuads = mOutstandingGlyphsVerticesPipeline / 4;
+                    mVertCoords.rewind();
+                    mTexCoords.rewind();
+
+                    for (int i = 0; i < numberOfQuads; i++) {
+                        gl.glTexCoord2f(mTexCoords.get(), mTexCoords.get());
+                        gl.glVertex3f(mVertCoords.get(), mVertCoords.get(),
+                                      mVertCoords.get());
+
+                        gl.glTexCoord2f(mTexCoords.get(), mTexCoords.get());
+                        gl.glVertex3f(mVertCoords.get(), mVertCoords.get(),
+                                      mVertCoords.get());
+
+                        gl.glTexCoord2f(mTexCoords.get(), mTexCoords.get());
+                        gl.glVertex3f(mVertCoords.get(), mVertCoords.get(),
+                                      mVertCoords.get());
+
+                        gl.glTexCoord2f(mTexCoords.get(), mTexCoords.get());
+                        gl.glVertex3f(mVertCoords.get(), mVertCoords.get(),
+                                      mVertCoords.get());
+                    }
+                } catch (Exception e) {
+                    e.printStackTrace();
+                } finally {
+                    gl.glEnd();
+                    mVertCoords.rewind();
+                    mTexCoords.rewind();
+                    mOutstandingGlyphsVerticesPipeline = 0;
+                }
+            }
+        }
+    }
+
+    class DebugListener implements GLEventListener {
+        private GLU glu;
+        private Frame frame;
+
+        DebugListener(GL gl, Frame frame) {
+            this.glu = GLU.createGLU(gl);
+            this.frame = frame;
+        }
+
+        public void display(GLAutoDrawable drawable) {
+            GL2 gl = GLContext.getCurrentGL().getGL2();
+            gl.glClear(GL2.GL_DEPTH_BUFFER_BIT | GL2.GL_COLOR_BUFFER_BIT);
+
+            if (packer == null) {
+                return;
+            }
+
+            TextureRenderer rend = getBackingStore();
+            final int w = rend.getWidth();
+            final int h = rend.getHeight();
+            rend.beginOrthoRendering(w, h);
+            rend.drawOrthoRect(0, 0);
+            rend.endOrthoRendering();
+
+            if ((frame.getWidth() != w) || (frame.getHeight() != h)) {
+                EventQueue.invokeLater(new Runnable() {
+                        public void run() {
+                            frame.setSize(w, h);
+                        }
+                    });
+            }
+        }
+
+        public void dispose(GLAutoDrawable drawable) {
+            glu.destroy();
+            glu=null;
+            frame=null;
+        }
+
+        // Unused methods
+        public void init(GLAutoDrawable drawable) {
+        }
+
+        public void reshape(GLAutoDrawable drawable, int x, int y, int width,
+                            int height) {
+        }
+
+        public void displayChanged(GLAutoDrawable drawable,
+                                   boolean modeChanged, boolean deviceChanged) {
+        }
+    }
+
+    /**
+     * Sets whether vertex arrays are being used internally for
+     * rendering, or whether text is rendered using the OpenGL
+     * immediate mode commands. This is provided as a concession for
+     * certain graphics cards which have poor vertex array
+     * performance. Defaults to true.
+     */
+    public void setUseVertexArrays(boolean useVertexArrays) {
+        this.useVertexArrays = useVertexArrays;
+    }
+
+    /**
+     * Indicates whether vertex arrays are being used internally for
+     * rendering, or whether text is rendered using the OpenGL
+     * immediate mode commands. Defaults to true.
+     */
+    public boolean getUseVertexArrays() {
+        return useVertexArrays;
+    }
+
+    /**
+     * Sets whether smoothing (i.e., GL_LINEAR filtering) is enabled
+     * in the backing TextureRenderer of this TextRenderer. A few
+     * graphics cards do not behave well when this is enabled,
+     * resulting in fuzzy text. Defaults to true.
+     */
+    public void setSmoothing(boolean smoothing) {
+        this.smoothing = smoothing;
+        getBackingStore().setSmoothing(smoothing);
+    }
+
+    /**
+     * Indicates whether smoothing is enabled in the backing
+     * TextureRenderer of this TextRenderer. A few graphics cards do
+     * not behave well when this is enabled, resulting in fuzzy text.
+     * Defaults to true.
+     */
+    public boolean getSmoothing() {
+        return smoothing;
+    }
+
+    private boolean is15Available(GL gl) {
+        if (!checkFor_isExtensionAvailable_GL_VERSION_1_5) {
+            isExtensionAvailable_GL_VERSION_1_5 = gl.isExtensionAvailable("GL_VERSION_1_5");
+            checkFor_isExtensionAvailable_GL_VERSION_1_5 = true;
+        }
+        return isExtensionAvailable_GL_VERSION_1_5;
+    }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/awt/TextureRenderer.java b/src/jogl/classes/com/jogamp/opengl/util/awt/TextureRenderer.java
new file mode 100755
index 000000000..bc5aa517e
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/awt/TextureRenderer.java
@@ -0,0 +1,699 @@
+/*
+ * Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util.awt;
+
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.Graphics2D;
+import java.awt.Image;
+import java.awt.Rectangle;
+import java.awt.image.*;
+
+import javax.media.opengl.*;
+import javax.media.opengl.glu.*;
+import javax.media.opengl.glu.gl2.*;
+import com.jogamp.opengl.util.texture.*;
+import com.jogamp.opengl.util.texture.spi.*;
+import com.jogamp.opengl.util.texture.awt.*;
+
+/** Provides the ability to render into an OpenGL {@link
+    com.jogamp.opengl.util.texture.Texture Texture} using the Java 2D
+    APIs. This renderer class uses an internal Java 2D image (of
+    unspecified type) for its backing store and flushes portions of
+    that image to an OpenGL texture on demand. The resulting OpenGL
+    texture can then be mapped on to a polygon for display. */
+
+public class TextureRenderer {
+  // For now, we supply only a BufferedImage back-end for this
+  // renderer. In theory we could use the Java 2D/JOGL bridge to fully
+  // accelerate the rendering paths, but there are restrictions on
+  // what work can be done where; for example, Graphics2D-related work
+  // must not be done on the Queue Flusher Thread, but JOGL's
+  // OpenGL-related work must be. This implies that the user's code
+  // would need to be split up into multiple callbacks run from the
+  // appropriate threads, which would be somewhat unfortunate.
+
+  // Whether we have an alpha channel in the (RGB/A) backing store
+  private boolean alpha;
+
+  // Whether we're using only a GL_INTENSITY backing store
+  private boolean intensity;
+
+  // Whether we're attempting to use automatic mipmap generation support
+  private boolean mipmap;
+
+  // Whether smoothing is enabled for the OpenGL texture (switching
+  // between GL_LINEAR and GL_NEAREST filtering)
+  private boolean smoothing = true;
+  private boolean smoothingChanged;
+
+  // The backing store itself
+  private BufferedImage image;
+
+  private Texture texture;
+  private AWTTextureData textureData;
+  private boolean mustReallocateTexture;
+  private Rectangle dirtyRegion;
+
+  private GLUgl2 glu = new GLUgl2();
+
+  // Current color
+  private float r = 1.0f;
+  private float g = 1.0f;
+  private float b = 1.0f;
+  private float a = 1.0f;
+
+  /** Creates a new renderer with backing store of the specified width
+      and height. If <CODE>alpha</CODE> is true, allocates an alpha
+      channel in the backing store image. No mipmap support is
+      requested.
+
+      @param width the width of the texture to render into
+      @param height the height of the texture to render into
+      @param alpha whether to allocate an alpha channel for the texture
+  */
+  public TextureRenderer(int width, int height, boolean alpha) {
+    this(width, height, alpha, false);
+  }
+
+  /** Creates a new renderer with backing store of the specified width
+      and height. If <CODE>alpha</CODE> is true, allocates an alpha channel in the
+      backing store image. If <CODE>mipmap</CODE> is true, attempts to use OpenGL's
+      automatic mipmap generation for better smoothing when rendering
+      the TextureRenderer's contents at a distance.
+
+      @param width the width of the texture to render into
+      @param height the height of the texture to render into
+      @param alpha whether to allocate an alpha channel for the texture
+      @param mipmap whether to attempt use of automatic mipmap generation
+  */
+  public TextureRenderer(int width, int height, boolean alpha, boolean mipmap) {
+    this(width, height, alpha, false, mipmap);
+  }
+
+  // Internal constructor to avoid confusion since alpha only makes
+  // sense when intensity is not set
+  private TextureRenderer(int width, int height, boolean alpha, boolean intensity, boolean mipmap) {
+    this.alpha = alpha;
+    this.intensity = intensity;
+    this.mipmap = mipmap;
+    init(width, height);
+  }
+
+  /** Creates a new renderer with a special kind of backing store
+      which acts only as an alpha channel. No mipmap support is
+      requested. Internally, this associates a GL_INTENSITY OpenGL
+      texture with the backing store. */
+  public static TextureRenderer createAlphaOnlyRenderer(int width, int height) {
+    return createAlphaOnlyRenderer(width, height, false);
+  }
+
+  /** Creates a new renderer with a special kind of backing store
+      which acts only as an alpha channel. If <CODE>mipmap</CODE> is
+      true, attempts to use OpenGL's automatic mipmap generation for
+      better smoothing when rendering the TextureRenderer's contents
+      at a distance. Internally, this associates a GL_INTENSITY OpenGL
+      texture with the backing store. */
+  public static TextureRenderer createAlphaOnlyRenderer(int width, int height, boolean mipmap) {
+    return new TextureRenderer(width, height, false, true, mipmap);
+  }
+
+  /** Returns the width of the backing store of this renderer.
+
+      @return the width of the backing store of this renderer
+  */
+  public int getWidth() {
+    return image.getWidth();
+  }
+
+  /** Returns the height of the backing store of this renderer.
+
+      @return the height of the backing store of this renderer
+  */
+  public int getHeight() {
+    return image.getHeight();
+  }
+
+  /** Returns the size of the backing store of this renderer in a
+      newly-allocated {@link java.awt.Dimension Dimension} object.
+
+      @return the size of the backing store of this renderer
+  */
+  public Dimension getSize() {
+    return getSize(null);
+  }
+
+  /** Returns the size of the backing store of this renderer. Uses the
+      {@link java.awt.Dimension Dimension} object if one is supplied,
+      or allocates a new one if null is passed.
+
+      @param d a {@link java.awt.Dimension Dimension} object in which
+        to store the results, or null to allocate a new one
+
+      @return the size of the backing store of this renderer
+  */
+  public Dimension getSize(Dimension d) {
+    if (d == null)
+      d = new Dimension();
+    d.setSize(image.getWidth(), image.getHeight());
+    return d;
+  }
+
+  /** Sets the size of the backing store of this renderer. This may
+      cause the OpenGL texture object associated with this renderer to
+      be invalidated; it is not recommended to cache this texture
+      object outside this class but to instead call {@link #getTexture
+      getTexture} when it is needed.
+
+      @param width the new width of the backing store of this renderer
+      @param height the new height of the backing store of this renderer
+      @throws GLException If an OpenGL context is not current when this method is called
+  */
+  public void setSize(int width, int height) throws GLException {
+    init(width, height);
+  }
+
+  /** Sets the size of the backing store of this renderer. This may
+      cause the OpenGL texture object associated with this renderer to
+      be invalidated.
+
+      @param d the new size of the backing store of this renderer
+      @throws GLException If an OpenGL context is not current when this method is called
+  */
+  public void setSize(Dimension d) throws GLException {
+    setSize(d.width, d.height);
+  }
+
+  /** Sets whether smoothing is enabled for the OpenGL texture; if so,
+      uses GL_LINEAR interpolation for the minification and
+      magnification filters. Defaults to true. Changes to this setting
+      will not take effect until the next call to {@link
+      #beginOrthoRendering beginOrthoRendering}.
+
+      @param smoothing whether smoothing is enabled for the OpenGL texture
+  */
+  public void setSmoothing(boolean smoothing) {
+    this.smoothing = smoothing;
+    smoothingChanged = true;
+  }
+
+  /** Returns whether smoothing is enabled for the OpenGL texture; see
+      {@link #setSmoothing setSmoothing}. Defaults to true.
+
+      @return whether smoothing is enabled for the OpenGL texture
+  */
+  public boolean getSmoothing() {
+    return smoothing;
+  }
+
+  /** Creates a {@link java.awt.Graphics2D Graphics2D} instance for
+      rendering to the backing store of this renderer. The returned
+      object should be disposed of using the normal {@link
+      java.awt.Graphics#dispose() Graphics.dispose()} method once it
+      is no longer being used.
+
+      @return a new {@link java.awt.Graphics2D Graphics2D} object for
+        rendering into the backing store of this renderer
+  */
+  public Graphics2D createGraphics() {
+    return image.createGraphics();
+  }
+
+  /** Returns the underlying Java 2D {@link java.awt.Image Image}
+      being rendered into. */
+  public Image getImage() {
+    return image;
+  }
+
+  /** Marks the given region of the TextureRenderer as dirty. This
+      region, and any previously set dirty regions, will be
+      automatically synchronized with the underlying Texture during
+      the next {@link #getTexture getTexture} operation, at which
+      point the dirty region will be cleared. It is not necessary for
+      an OpenGL context to be current when this method is called.
+
+      @param x the x coordinate (in Java 2D coordinates -- relative to
+        upper left) of the region to update
+      @param y the y coordinate (in Java 2D coordinates -- relative to
+        upper left) of the region to update
+      @param width the width of the region to update
+      @param height the height of the region to update
+  */
+  public void markDirty(int x, int y, int width, int height) {
+    Rectangle curRegion = new Rectangle(x, y, width, height);
+    if (dirtyRegion == null) {
+      dirtyRegion = curRegion;
+    } else {
+      dirtyRegion.add(curRegion);
+    }
+  }
+
+  /** Returns the underlying OpenGL Texture object associated with
+      this renderer, synchronizing any dirty regions of the
+      TextureRenderer with the underlying OpenGL texture.
+
+      @throws GLException If an OpenGL context is not current when this method is called
+  */
+  public Texture getTexture() throws GLException {
+    if (dirtyRegion != null) {
+      sync(dirtyRegion.x, dirtyRegion.y, dirtyRegion.width, dirtyRegion.height);
+      dirtyRegion = null;
+    }
+
+    ensureTexture();
+    return texture;
+  }
+
+  /** Disposes all resources associated with this renderer. It is not
+      valid to use this renderer after calling this method.
+
+      @throws GLException If an OpenGL context is not current when this method is called
+  */
+  public void dispose() throws GLException {
+    if (texture != null) {
+      texture.dispose();
+      texture = null;
+    }
+    if (image != null) {
+      image.flush();
+      image = null;
+    }
+  }
+
+  /** Convenience method which assists in rendering portions of the
+      OpenGL texture to the screen, if the application intends to draw
+      them as a flat overlay on to the screen. Pushes OpenGL state
+      bits (GL_ENABLE_BIT, GL_DEPTH_BUFFER_BIT and GL_TRANSFORM_BIT);
+      disables the depth test, back-face culling, and lighting;
+      enables the texture in this renderer; and sets up the viewing
+      matrices for orthographic rendering where the coordinates go
+      from (0, 0) at the lower left to (width, height) at the upper
+      right. Equivalent to beginOrthoRendering(width, height, true).
+      {@link #endOrthoRendering} must be used in conjunction with this
+      method to restore all OpenGL states.
+
+      @param width the width of the current on-screen OpenGL drawable
+      @param height the height of the current on-screen OpenGL drawable
+
+      @throws GLException If an OpenGL context is not current when this method is called
+  */
+  public void beginOrthoRendering(int width, int height) throws GLException {
+    beginOrthoRendering(width, height, true);
+  }
+
+  /** Convenience method which assists in rendering portions of the
+      OpenGL texture to the screen, if the application intends to draw
+      them as a flat overlay on to the screen. Pushes OpenGL state
+      bits (GL_ENABLE_BIT, GL_DEPTH_BUFFER_BIT and GL_TRANSFORM_BIT);
+      disables the depth test (if the "disableDepthTest" argument is
+      true), back-face culling, and lighting; enables the texture in
+      this renderer; and sets up the viewing matrices for orthographic
+      rendering where the coordinates go from (0, 0) at the lower left
+      to (width, height) at the upper right. {@link
+      #endOrthoRendering} must be used in conjunction with this method
+      to restore all OpenGL states.
+
+      @param width the width of the current on-screen OpenGL drawable
+      @param height the height of the current on-screen OpenGL drawable
+      @param disableDepthTest whether the depth test should be disabled
+
+      @throws GLException If an OpenGL context is not current when this method is called
+  */
+  public void beginOrthoRendering(int width, int height, boolean disableDepthTest) throws GLException {
+    beginRendering(true, width, height, disableDepthTest);
+  }
+
+  /** Convenience method which assists in rendering portions of the
+      OpenGL texture to the screen as 2D quads in 3D space. Pushes
+      OpenGL state (GL_ENABLE_BIT); disables lighting; and enables the
+      texture in this renderer. Unlike {@link #beginOrthoRendering
+      beginOrthoRendering}, does not modify the depth test, back-face
+      culling, lighting, or the modelview or projection matrices. The
+      user is responsible for setting up the view matrices for correct
+      results of {@link #draw3DRect draw3DRect}. {@link
+      #end3DRendering} must be used in conjunction with this method to
+      restore all OpenGL states.
+
+      @throws GLException If an OpenGL context is not current when this method is called
+  */
+  public void begin3DRendering() throws GLException {
+    beginRendering(false, 0, 0, false);
+  }
+
+  /** Changes the color of the polygons, and therefore the drawn
+      images, this TextureRenderer produces. Use of this method is
+      optional. The TextureRenderer uses the GL_MODULATE texture
+      environment mode, which causes the portions of the rendered
+      texture to be multiplied by the color of the rendered
+      polygons. The polygon color can be varied to achieve effects
+      like tinting of the overall output or fading in and out by
+      changing the alpha of the color. <P>
+
+      Each component ranges from 0.0f - 1.0f. The alpha component, if
+      used, does not need to be premultiplied into the color channels
+      as described in the documentation for {@link
+      com.jogamp.opengl.util.texture.Texture Texture}, although
+      premultiplied colors are used internally. The default color is
+      opaque white.
+
+      @param r the red component of the new color
+      @param g the green component of the new color
+      @param b the blue component of the new color
+      @param a the alpha component of the new color, 0.0f = completely
+        transparent, 1.0f = completely opaque
+      @throws GLException If an OpenGL context is not current when this method is called
+  */
+  public void setColor(float r, float g, float b, float a) throws GLException {
+    GL2 gl = GLContext.getCurrentGL().getGL2();
+    this.r = r * a;
+    this.g = g * a;
+    this.b = b * a;
+    this.a = a;
+
+    gl.glColor4f(this.r, this.g, this.b, this.a);
+  }  
+
+  private float[] compArray;
+  /** Changes the current color of this TextureRenderer to the
+      supplied one. The default color is opaque white. See {@link
+      #setColor(float,float,float,float) setColor} for more details.
+
+      @param color the new color to use for rendering
+      @throws GLException If an OpenGL context is not current when this method is called
+  */
+  public void setColor(Color color) throws GLException {
+    // Get color's RGBA components as floats in the range [0,1].
+    if (compArray == null) {
+      compArray = new float[4];
+    }
+    color.getRGBComponents(compArray);
+    setColor(compArray[0], compArray[1], compArray[2], compArray[3]);
+  }
+
+  /** Draws an orthographically projected rectangle containing all of
+      the underlying texture to the specified location on the
+      screen. All (x, y) coordinates are specified relative to the
+      lower left corner of either the texture image or the current
+      OpenGL drawable. This method is equivalent to
+      <code>drawOrthoRect(screenx, screeny, 0, 0, getWidth(),
+      getHeight());</code>.
+
+      @param screenx the on-screen x coordinate at which to draw the rectangle
+      @param screeny the on-screen y coordinate (relative to lower left) at
+        which to draw the rectangle
+      
+      @throws GLException If an OpenGL context is not current when this method is called
+  */
+  public void drawOrthoRect(int screenx, int screeny) throws GLException {
+    drawOrthoRect(screenx, screeny, 0, 0, getWidth(), getHeight());
+  }
+
+  /** Draws an orthographically projected rectangle of the underlying
+      texture to the specified location on the screen. All (x, y)
+      coordinates are specified relative to the lower left corner of
+      either the texture image or the current OpenGL drawable.
+
+      @param screenx the on-screen x coordinate at which to draw the rectangle
+      @param screeny the on-screen y coordinate (relative to lower left) at
+        which to draw the rectangle
+      @param texturex the x coordinate of the pixel in the texture of
+        the lower left portion of the rectangle to draw
+      @param texturey the y coordinate of the pixel in the texture
+        (relative to lower left) of the lower left portion of the
+        rectangle to draw
+      @param width the width of the rectangle to draw
+      @param height the height of the rectangle to draw
+      
+      @throws GLException If an OpenGL context is not current when this method is called
+  */
+  public void drawOrthoRect(int screenx, int screeny,
+                            int texturex, int texturey,
+                            int width, int height) throws GLException {
+    draw3DRect(screenx, screeny, 0, texturex, texturey, width, height, 1);
+  }
+
+  /** Draws a rectangle of the underlying texture to the specified 3D
+      location. In the current coordinate system, the lower left
+      corner of the rectangle is placed at (x, y, z), and the upper
+      right corner is placed at (x + width * scaleFactor, y + height *
+      scaleFactor, z). The lower left corner of the sub-rectangle of
+      the texture is (texturex, texturey) and the upper right corner
+      is (texturex + width, texturey + height). For back-face culling
+      purposes, the rectangle is drawn with counterclockwise
+      orientation of the vertices when viewed from the front.
+
+      @param x the x coordinate at which to draw the rectangle
+      @param y the y coordinate at which to draw the rectangle
+      @param z the z coordinate at which to draw the rectangle
+      @param texturex the x coordinate of the pixel in the texture of
+        the lower left portion of the rectangle to draw
+      @param texturey the y coordinate of the pixel in the texture
+        (relative to lower left) of the lower left portion of the
+        rectangle to draw
+      @param width the width in texels of the rectangle to draw
+      @param height the height in texels of the rectangle to draw
+      @param scaleFactor the scale factor to apply (multiplicatively)
+        to the size of the drawn rectangle
+      
+      @throws GLException If an OpenGL context is not current when this method is called
+  */
+  public void draw3DRect(float x, float y, float z,
+                         int texturex, int texturey,
+                         int width, int height,
+                         float scaleFactor) throws GLException {
+    GL2 gl = GLContext.getCurrentGL().getGL2();
+    Texture texture = getTexture();
+    TextureCoords coords = texture.getSubImageTexCoords(texturex, texturey,
+                                                        texturex + width,
+                                                        texturey + height);
+    gl.glBegin(GL2.GL_QUADS);
+    gl.glTexCoord2f(coords.left(), coords.bottom());
+    gl.glVertex3f(x, y, z);
+    gl.glTexCoord2f(coords.right(), coords.bottom());
+    gl.glVertex3f(x + width * scaleFactor, y, z);
+    gl.glTexCoord2f(coords.right(), coords.top());
+    gl.glVertex3f(x + width * scaleFactor, y + height * scaleFactor, z);
+    gl.glTexCoord2f(coords.left(), coords.top());
+    gl.glVertex3f(x, y + height * scaleFactor, z);
+    gl.glEnd();
+  }
+
+  /** Convenience method which assists in rendering portions of the
+      OpenGL texture to the screen, if the application intends to draw
+      them as a flat overlay on to the screen. Must be used if {@link
+      #beginOrthoRendering} is used to set up the rendering stage for
+      this overlay. 
+
+      @throws GLException If an OpenGL context is not current when this method is called
+  */
+  public void endOrthoRendering() throws GLException {
+    endRendering(true);
+  }
+
+  /** Convenience method which assists in rendering portions of the
+      OpenGL texture to the screen as 2D quads in 3D space. Must be
+      used if {@link #begin3DRendering} is used to set up the
+      rendering stage for this overlay.
+
+      @throws GLException If an OpenGL context is not current when this method is called
+  */
+  public void end3DRendering() throws GLException {
+    endRendering(false);
+  }
+
+  /** Indicates whether automatic mipmap generation is in use for this
+      TextureRenderer. The result of this method may change from true
+      to false if it is discovered during allocation of the
+      TextureRenderer's backing store that automatic mipmap generation
+      is not supported at the OpenGL level. */
+  public boolean isUsingAutoMipmapGeneration() {
+    return mipmap;
+  }
+
+  //----------------------------------------------------------------------
+  // Internals only below this point
+  //
+
+  private void beginRendering(boolean ortho, int width, int height, boolean disableDepthTestForOrtho) {
+    GL2 gl = GLContext.getCurrentGL().getGL2();
+    int attribBits = 
+      GL2.GL_ENABLE_BIT | GL2.GL_TEXTURE_BIT | GL2.GL_COLOR_BUFFER_BIT |
+      (ortho ? (GL2.GL_DEPTH_BUFFER_BIT | GL2.GL_TRANSFORM_BIT) : 0);
+    gl.glPushAttrib(attribBits);
+    gl.glDisable(GL2.GL_LIGHTING);
+    if (ortho) {
+      if (disableDepthTestForOrtho) {
+        gl.glDisable(GL2.GL_DEPTH_TEST);
+      }
+      gl.glDisable(GL2.GL_CULL_FACE);
+      gl.glMatrixMode(GL2.GL_PROJECTION);
+      gl.glPushMatrix();
+      gl.glLoadIdentity();
+      glu.gluOrtho2D(0, width, 0, height);
+      gl.glMatrixMode(GL2.GL_MODELVIEW);
+      gl.glPushMatrix();
+      gl.glLoadIdentity();
+      gl.glMatrixMode(GL2.GL_TEXTURE);
+      gl.glPushMatrix();
+      gl.glLoadIdentity();
+    }
+    gl.glEnable(GL2.GL_BLEND);
+    gl.glBlendFunc(GL2.GL_ONE, GL2.GL_ONE_MINUS_SRC_ALPHA);
+    Texture texture = getTexture();
+    texture.enable();
+    texture.bind();
+    gl.glTexEnvi(GL2.GL_TEXTURE_ENV, GL2.GL_TEXTURE_ENV_MODE, GL2.GL_MODULATE);
+    // Change polygon color to last saved
+    gl.glColor4f(r, g, b, a);
+    if (smoothingChanged) {
+      smoothingChanged = false;
+      if (smoothing) {
+        texture.setTexParameteri(GL2.GL_TEXTURE_MAG_FILTER, GL2.GL_LINEAR);
+        if (mipmap) {
+          texture.setTexParameteri(GL2.GL_TEXTURE_MIN_FILTER, GL2.GL_LINEAR_MIPMAP_LINEAR);
+        } else {
+          texture.setTexParameteri(GL2.GL_TEXTURE_MIN_FILTER, GL2.GL_LINEAR);
+        }
+      } else {
+        texture.setTexParameteri(GL2.GL_TEXTURE_MIN_FILTER, GL2.GL_NEAREST);
+        texture.setTexParameteri(GL2.GL_TEXTURE_MAG_FILTER, GL2.GL_NEAREST);
+      }
+    }
+  }
+
+  private void endRendering(boolean ortho) {
+    GL2 gl = GLContext.getCurrentGL().getGL2();
+    Texture texture = getTexture();
+    texture.disable();
+    if (ortho) {
+      gl.glMatrixMode(GL2.GL_PROJECTION);
+      gl.glPopMatrix();
+      gl.glMatrixMode(GL2.GL_MODELVIEW);
+      gl.glPopMatrix();
+      gl.glMatrixMode(GL2.GL_TEXTURE);
+      gl.glPopMatrix();
+    }
+    gl.glPopAttrib();
+  }
+
+  private void init(int width, int height) {
+    GL2 gl = GLContext.getCurrentGL().getGL2();
+    // Discard previous BufferedImage if any
+    if (image != null) {
+      image.flush();
+      image = null;
+    }
+
+    // Infer the internal format if not an intensity texture
+    int internalFormat = (intensity ? GL2.GL_INTENSITY : 0);
+    int imageType = 
+      (intensity ? BufferedImage.TYPE_BYTE_GRAY :
+       (alpha ?  BufferedImage.TYPE_INT_ARGB_PRE : BufferedImage.TYPE_INT_RGB));
+    image = new BufferedImage(width, height, imageType);
+    // Always realllocate the TextureData associated with this
+    // BufferedImage; it's just a reference to the contents but we
+    // need it in order to update sub-regions of the underlying
+    // texture
+    textureData = new AWTTextureData(gl.getGLProfile(), internalFormat, 0, mipmap, image);
+    // For now, always reallocate the underlying OpenGL texture when
+    // the backing store size changes
+    mustReallocateTexture = true;
+  }
+
+  /** Synchronizes the specified region of the backing store down to
+      the underlying OpenGL texture. If {@link #markDirty markDirty}
+      is used instead to indicate the regions that are out of sync,
+      this method does not need to be called.
+
+      @param x the x coordinate (in Java 2D coordinates -- relative to
+        upper left) of the region to update
+      @param y the y coordinate (in Java 2D coordinates -- relative to
+        upper left) of the region to update
+      @param width the width of the region to update
+      @param height the height of the region to update
+
+      @throws GLException If an OpenGL context is not current when this method is called
+  */
+  private void sync(int x, int y, int width, int height) throws GLException {
+    // Force allocation if necessary
+    boolean canSkipUpdate = ensureTexture();
+
+    if (!canSkipUpdate) {
+      // Update specified region.
+      // NOTE that because BufferedImage-based TextureDatas now don't
+      // do anything to their contents, the coordinate systems for
+      // OpenGL and Java 2D actually line up correctly for
+      // updateSubImage calls, so we don't need to do any argument
+      // conversion here (i.e., flipping the Y coordinate).
+      texture.updateSubImage(textureData, 0, x, y, x, y, width, height);
+    }
+  }
+
+  // Returns true if the texture was newly allocated, false if not
+  private boolean ensureTexture() {
+    if (mustReallocateTexture) {
+      if (texture != null) {
+        texture.dispose();
+        texture = null;
+      }
+      mustReallocateTexture = false;
+    }
+
+    if (texture == null) {
+      texture = TextureIO.newTexture(textureData);
+      if (mipmap && !texture.isUsingAutoMipmapGeneration()) {
+        // Only try this once
+        texture.dispose();
+        mipmap = false;
+        textureData.setMipmap(false);
+        texture = TextureIO.newTexture(textureData);
+      }
+
+      if (!smoothing) {
+        // The TextureIO classes default to GL_LINEAR filtering
+        texture.setTexParameteri(GL2.GL_TEXTURE_MIN_FILTER, GL2.GL_NEAREST);
+        texture.setTexParameteri(GL2.GL_TEXTURE_MAG_FILTER, GL2.GL_NEAREST);
+      }
+      return true;
+    }
+
+    return false;
+  }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/gl2/BitmapCharRec.java b/src/jogl/classes/com/jogamp/opengl/util/gl2/BitmapCharRec.java
new file mode 100644
index 000000000..34685e1b2
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/gl2/BitmapCharRec.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util.gl2;
+
+/* Copyright (c) Mark J. Kilgard, 1994, 1998. */
+
+/* This program is freely distributable without licensing fees 
+   and is provided without guarantee or warrantee expressed or 
+   implied. This program is -not- in the public domain. */
+
+class BitmapCharRec {
+  public int width;
+  public int height;
+  public float xorig;
+  public float yorig;
+  public float advance;
+  public byte[] bitmap;
+
+  public BitmapCharRec(int width,
+                int height,
+                float xorig,
+                float yorig,
+                float advance,
+                byte[] bitmap) {
+    this.width   = width;
+    this.height  = height;
+    this.xorig   = xorig;
+    this.yorig   = yorig;
+    this.advance = advance;
+    this.bitmap  = bitmap;
+  }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/gl2/BitmapFontRec.java b/src/jogl/classes/com/jogamp/opengl/util/gl2/BitmapFontRec.java
new file mode 100644
index 000000000..18f7d3b28
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/gl2/BitmapFontRec.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util.gl2;
+
+/* Copyright (c) Mark J. Kilgard, 1994, 1998. */
+
+/* This program is freely distributable without licensing fees 
+   and is provided without guarantee or warrantee expressed or 
+   implied. This program is -not- in the public domain. */
+
+class BitmapFontRec {
+  public String name;
+  public int num_chars;
+  public int first;
+  public BitmapCharRec[] ch;
+
+  public BitmapFontRec(String name,
+                int num_chars,
+                int first,
+                BitmapCharRec[] ch) {
+    this.name = name;
+    this.num_chars = num_chars;
+    this.first = first;
+    this.ch = ch;
+  }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/gl2/CoordRec.java b/src/jogl/classes/com/jogamp/opengl/util/gl2/CoordRec.java
new file mode 100644
index 000000000..9ad95ec03
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/gl2/CoordRec.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util.gl2;
+
+/* Copyright (c) Mark J. Kilgard, 1994, 1998. */
+
+/* This program is freely distributable without licensing fees 
+   and is provided without guarantee or warrantee expressed or 
+   implied. This program is -not- in the public domain. */
+
+class CoordRec {
+  public float x;
+  public float y;
+
+  public CoordRec(float x, float y) {
+    this.x = x;
+    this.y = y;
+  }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/gl2/GLUT.java b/src/jogl/classes/com/jogamp/opengl/util/gl2/GLUT.java
new file mode 100644
index 000000000..8befc13ba
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/gl2/GLUT.java
@@ -0,0 +1,1342 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util.gl2;
+
+import javax.media.opengl.*;
+import javax.media.opengl.glu.*;
+import javax.media.opengl.glu.gl2.*;
+
+/** Subset of the routines provided by the GLUT interface. Note the
+    signatures of many of the methods are necessarily different than
+    the corresponding C version. A GLUT object must only be used from
+    one particular thread at a time. <P>
+
+    Copyright (c) Mark J. Kilgard, 1994, 1997. <P>
+
+    (c) Copyright 1993, Silicon Graphics, Inc. <P>
+
+    ALL RIGHTS RESERVED <P>
+
+    Permission to use, copy, modify, and distribute this software
+    for any purpose and without fee is hereby granted, provided
+    that the above copyright notice appear in all copies and that
+    both the copyright notice and this permission notice appear in
+    supporting documentation, and that the name of Silicon
+    Graphics, Inc. not be used in advertising or publicity
+    pertaining to distribution of the software without specific,
+    written prior permission. <P>
+
+    THE MATERIAL EMBODIED ON THIS SOFTWARE IS PROVIDED TO YOU
+    "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, EXPRESS, IMPLIED OR
+    OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY WARRANTY OF
+    MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  IN NO
+    EVENT SHALL SILICON GRAPHICS, INC.  BE LIABLE TO YOU OR ANYONE
+    ELSE FOR ANY DIRECT, SPECIAL, INCIDENTAL, INDIRECT OR
+    CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER,
+    INCLUDING WITHOUT LIMITATION, LOSS OF PROFIT, LOSS OF USE,
+    SAVINGS OR REVENUE, OR THE CLAIMS OF THIRD PARTIES, WHETHER OR
+    NOT SILICON GRAPHICS, INC.  HAS BEEN ADVISED OF THE POSSIBILITY
+    OF SUCH LOSS, HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+    ARISING OUT OF OR IN CONNECTION WITH THE POSSESSION, USE OR
+    PERFORMANCE OF THIS SOFTWARE. <P>
+
+    US Government Users Restricted Rights <P>
+
+    Use, duplication, or disclosure by the Government is subject to
+    restrictions set forth in FAR 52.227.19(c)(2) or subparagraph
+    (c)(1)(ii) of the Rights in Technical Data and Computer
+    Software clause at DFARS 252.227-7013 and/or in similar or
+    successor clauses in the FAR or the DOD or NASA FAR
+    Supplement.  Unpublished-- rights reserved under the copyright
+    laws of the United States.  Contractor/manufacturer is Silicon
+    Graphics, Inc., 2011 N.  Shoreline Blvd., Mountain View, CA
+    94039-7311. <P>
+
+    OpenGL(TM) is a trademark of Silicon Graphics, Inc. <P>
+*/
+
+public class GLUT {
+  public static final int STROKE_ROMAN = 0;
+  public static final int STROKE_MONO_ROMAN = 1;
+  public static final int BITMAP_9_BY_15 = 2;
+  public static final int BITMAP_8_BY_13 = 3;
+  public static final int BITMAP_TIMES_ROMAN_10 = 4;
+  public static final int BITMAP_TIMES_ROMAN_24 = 5;
+  public static final int BITMAP_HELVETICA_10 = 6;
+  public static final int BITMAP_HELVETICA_12 = 7;
+  public static final int BITMAP_HELVETICA_18 = 8;
+
+  private GLUgl2 glu = new GLUgl2();
+
+  //----------------------------------------------------------------------
+  // Shapes
+  //
+
+  public void glutWireSphere(double radius, int slices, int stacks) {
+    quadObjInit(glu);
+    glu.gluQuadricDrawStyle(quadObj, GLU.GLU_LINE);
+    glu.gluQuadricNormals(quadObj, GLU.GLU_SMOOTH);
+    /* If we ever changed/used the texture or orientation state
+       of quadObj, we'd need to change it to the defaults here
+       with gluQuadricTexture and/or gluQuadricOrientation. */
+    glu.gluSphere(quadObj, radius, slices, stacks);
+  }
+
+  public void glutSolidSphere(double radius, int slices, int stacks) {
+    quadObjInit(glu);
+    glu.gluQuadricDrawStyle(quadObj, GLU.GLU_FILL);
+    glu.gluQuadricNormals(quadObj, GLU.GLU_SMOOTH);
+    /* If we ever changed/used the texture or orientation state
+       of quadObj, we'd need to change it to the defaults here
+       with gluQuadricTexture and/or gluQuadricOrientation. */
+    glu.gluSphere(quadObj, radius, slices, stacks);
+  }
+
+  public void glutWireCone(double base, double height,
+                           int slices, int stacks) {
+    quadObjInit(glu);
+    glu.gluQuadricDrawStyle(quadObj, GLU.GLU_LINE);
+    glu.gluQuadricNormals(quadObj, GLU.GLU_SMOOTH);
+    /* If we ever changed/used the texture or orientation state
+       of quadObj, we'd need to change it to the defaults here
+       with gluQuadricTexture and/or gluQuadricOrientation. */
+    glu.gluCylinder(quadObj, base, 0.0, height, slices, stacks);
+  }
+
+  public void glutSolidCone(double base, double height,
+                            int slices, int stacks) {
+    quadObjInit(glu);
+    glu.gluQuadricDrawStyle(quadObj, GLU.GLU_FILL);
+    glu.gluQuadricNormals(quadObj, GLU.GLU_SMOOTH);
+    /* If we ever changed/used the texture or orientation state
+       of quadObj, we'd need to change it to the defaults here
+       with gluQuadricTexture and/or gluQuadricOrientation. */
+    glu.gluCylinder(quadObj, base, 0.0, height, slices, stacks);
+  }
+
+  public void glutWireCylinder(double radius, double height, int slices, int stacks) {
+    quadObjInit(glu);
+    glu.gluQuadricDrawStyle(quadObj, GLU.GLU_LINE);
+    glu.gluQuadricNormals(quadObj, GLU.GLU_SMOOTH);
+    /* If we ever changed/used the texture or orientation state
+       of quadObj, we'd need to change it to the defaults here
+       with gluQuadricTexture and/or gluQuadricOrientation. */
+    glu.gluCylinder(quadObj, radius, radius, height, slices, stacks);
+  }
+
+  public void glutSolidCylinder(double radius, double height, int slices, int stacks) {
+    GL2 gl = GLUgl2.getCurrentGL2();
+  	
+    // Prepare table of points for drawing end caps
+    double [] x = new double[slices];
+    double [] y = new double[slices];
+    double angleDelta = Math.PI * 2 / slices;
+    double angle = 0;
+    for (int i = 0 ; i < slices ; i ++) {
+      angle = i * angleDelta;
+      x[i] = Math.cos(angle) * radius;
+      y[i] = Math.sin(angle) * radius;
+    }
+  	
+    // Draw bottom cap
+    gl.glBegin(GL2.GL_TRIANGLE_FAN);
+    gl.glNormal3d(0,0,-1);
+    gl.glVertex3d(0,0,0);
+    for (int i = 0 ; i < slices ; i ++) {
+      gl.glVertex3d(x[i], y[i], 0);
+    }
+    gl.glVertex3d(x[0], y[0], 0);
+    gl.glEnd();
+  	
+    // Draw top cap
+    gl.glBegin(GL2.GL_TRIANGLE_FAN);
+    gl.glNormal3d(0,0,1);
+    gl.glVertex3d(0,0,height);
+    for (int i = 0 ; i < slices ; i ++) {
+      gl.glVertex3d(x[i], y[i], height);
+    }
+    gl.glVertex3d(x[0], y[0], height);
+    gl.glEnd();
+  	
+    // Draw walls
+    quadObjInit(glu);
+    glu.gluQuadricDrawStyle(quadObj, GLU.GLU_FILL);
+    glu.gluQuadricNormals(quadObj, GLU.GLU_SMOOTH);
+    /* If we ever changed/used the texture or orientation state
+       of quadObj, we'd need to change it to the defaults here
+       with gluQuadricTexture and/or gluQuadricOrientation. */
+    glu.gluCylinder(quadObj, radius, radius, height, slices, stacks);
+  }
+
+  public void glutWireCube(float size) {
+    drawBox(GLUgl2.getCurrentGL2(), size, GL2.GL_LINE_LOOP);
+  }
+
+  public void glutSolidCube(float size) {
+    drawBox(GLUgl2.getCurrentGL2(), size, GL2.GL_QUADS);
+  }
+
+  public void glutWireTorus(double innerRadius, double outerRadius,
+                            int nsides, int rings) {
+    GL2 gl = GLUgl2.getCurrentGL2();
+    gl.glPushAttrib(GL2.GL_POLYGON_BIT);
+    gl.glPolygonMode(GL2.GL_FRONT_AND_BACK, GL2.GL_LINE);
+    doughnut(gl, innerRadius, outerRadius, nsides, rings);
+    gl.glPopAttrib();
+  }
+
+  public void glutSolidTorus(double innerRadius, double outerRadius,
+                             int nsides, int rings) {
+    doughnut(GLUgl2.getCurrentGL2(), innerRadius, outerRadius, nsides, rings);
+  }
+
+  public void glutWireDodecahedron() {
+    dodecahedron(GLUgl2.getCurrentGL2(), GL2.GL_LINE_LOOP);
+  }
+
+  public void glutSolidDodecahedron() {
+    dodecahedron(GLUgl2.getCurrentGL2(), GL2.GL_TRIANGLE_FAN);
+  }
+
+  public void glutWireOctahedron() {
+    octahedron(GLUgl2.getCurrentGL2(), GL2.GL_LINE_LOOP);
+  }
+
+  public void glutSolidOctahedron() {
+    octahedron(GLUgl2.getCurrentGL2(), GL2.GL_TRIANGLES);
+  }
+
+  public void glutWireIcosahedron() {
+    icosahedron(GLUgl2.getCurrentGL2(), GL2.GL_LINE_LOOP);
+  }
+
+  public void glutSolidIcosahedron() {
+    icosahedron(GLUgl2.getCurrentGL2(), GL2.GL_TRIANGLES);
+  }
+
+  public void glutWireTetrahedron() {
+    tetrahedron(GLUgl2.getCurrentGL2(), GL2.GL_LINE_LOOP);
+  }
+
+  public void glutSolidTetrahedron() {
+    tetrahedron(GLUgl2.getCurrentGL2(), GL2.GL_TRIANGLES);
+  }
+
+/**
+   * Renders the teapot as a solid shape of the specified size. The teapot is
+   * created in a way that replicates the C GLUT implementation.
+   * 
+   * @param scale
+   *        the factor by which to scale the teapot
+   */
+  public void glutSolidTeapot(double scale) {
+    glutSolidTeapot(scale, true);
+  }
+
+  /**
+   * Renders the teapot as a solid shape of the specified size. The teapot can
+   * either be created in a way that is backward-compatible with the standard
+   * C glut library (i.e. broken), or in a more pleasing way (i.e. with
+   * surfaces whose front-faces point outwards and standing on the z=0 plane,
+   * instead of the y=-1 plane). Both surface normals and texture coordinates
+   * for the teapot are generated. The teapot is generated with OpenGL
+   * evaluators.
+   * 
+   * @param scale
+   *        the factor by which to scale the teapot
+   * @param cStyle
+   *        whether to create the teapot in exactly the same way as in the C
+   *        implementation of GLUT
+   */
+  public void glutSolidTeapot(double scale, boolean cStyle) {
+    teapot(GLUgl2.getCurrentGL2(), 14, scale, GL2.GL_FILL, cStyle);
+  }
+
+  /**
+   * Renders the teapot as a wireframe shape of the specified size. The teapot
+   * is created in a way that replicates the C GLUT implementation.
+   * 
+   * @param scale
+   *        the factor by which to scale the teapot
+   */
+  public void glutWireTeapot(double scale) {
+    glutWireTeapot(scale, true);
+  }
+  
+  /**
+   * Renders the teapot as a wireframe shape of the specified size. The teapot
+   * can either be created in a way that is backward-compatible with the
+   * standard C glut library (i.e. broken), or in a more pleasing way (i.e.
+   * with surfaces whose front-faces point outwards and standing on the z=0
+   * plane, instead of the y=-1 plane). Both surface normals and texture
+   * coordinates for the teapot are generated. The teapot is generated with
+   * OpenGL evaluators.
+   * 
+   * @param scale
+   *        the factor by which to scale the teapot
+   * @param cStyle
+   *        whether to create the teapot in exactly the same way as in the C
+   *        implementation of GLUT
+   */
+  public void glutWireTeapot(double scale, boolean cStyle) {
+    teapot(GLUgl2.getCurrentGL2(), 10, scale, GL2.GL_LINE, cStyle);
+  }
+
+  //----------------------------------------------------------------------
+  // Fonts
+  //
+
+  public void glutBitmapCharacter(int font, char character) {
+    GL2 gl = GLUgl2.getCurrentGL2();
+    int[] swapbytes  = new int[1];
+    int[] lsbfirst   = new int[1];
+    int[] rowlength  = new int[1];
+    int[] skiprows   = new int[1];
+    int[] skippixels = new int[1];
+    int[] alignment  = new int[1];
+    beginBitmap(gl,
+                swapbytes,
+                lsbfirst,
+                rowlength,
+                skiprows,
+                skippixels,
+                alignment);
+    bitmapCharacterImpl(gl, font, character);
+    endBitmap(gl,
+              swapbytes,
+              lsbfirst,
+              rowlength,
+              skiprows,
+              skippixels,
+              alignment);
+  }
+
+  public void glutBitmapString   (int font, String string) {
+    GL2 gl = GLUgl2.getCurrentGL2();
+    int[] swapbytes  = new int[1];
+    int[] lsbfirst   = new int[1];
+    int[] rowlength  = new int[1];
+    int[] skiprows   = new int[1];
+    int[] skippixels = new int[1];
+    int[] alignment  = new int[1];
+    beginBitmap(gl, 
+                swapbytes,
+                lsbfirst,
+                rowlength,
+                skiprows,
+                skippixels,
+                alignment);
+    int len = string.length();
+    for (int i = 0; i < len; i++) {
+      bitmapCharacterImpl(gl, font, string.charAt(i));
+    }
+    endBitmap(gl, 
+              swapbytes,
+              lsbfirst,
+              rowlength,
+              skiprows,
+              skippixels,
+              alignment);
+  }
+
+  public int  glutBitmapWidth    (int font, char character) {
+    BitmapFontRec fontinfo = getBitmapFont(font);
+    int c = character & 0xFFFF;
+    if (c < fontinfo.first || c >= fontinfo.first + fontinfo.num_chars)
+      return 0;
+    BitmapCharRec ch = fontinfo.ch[c - fontinfo.first];
+    if (ch != null)
+      return (int) ch.advance;
+    else
+      return 0;
+  }
+
+  public void glutStrokeCharacter(int font, char character) {
+    GL2 gl = GLUgl2.getCurrentGL2();
+    StrokeFontRec fontinfo = getStrokeFont(font);
+    int c = character & 0xFFFF;
+    if (c < 0 || c >= fontinfo.num_chars)
+      return;
+    StrokeCharRec ch = fontinfo.ch[c];
+    if (ch != null) {
+      for (int i = 0; i < ch.num_strokes; i++) {
+        StrokeRec stroke = ch.stroke[i];
+        gl.glBegin(GL2.GL_LINE_STRIP);
+        for (int j = 0; j < stroke.num_coords; j++) {
+          CoordRec coord = stroke.coord[j];
+          gl.glVertex2f(coord.x, coord.y);
+        }
+        gl.glEnd();
+      }
+      gl.glTranslatef(ch.right, 0.0f, 0.0f);
+    }
+  }
+
+  public void glutStrokeString(int font, String string) {
+    GL2 gl = GLUgl2.getCurrentGL2();
+    StrokeFontRec fontinfo = getStrokeFont(font);
+    int len = string.length();
+    for (int pos = 0; pos < len; pos++) {
+      int c = string.charAt(pos) & 0xFFFF;
+      if (c < 0 || c >= fontinfo.num_chars)
+        continue;
+      StrokeCharRec ch = fontinfo.ch[c];
+      if (ch != null) {
+        for (int i = 0; i < ch.num_strokes; i++) {
+          StrokeRec stroke = ch.stroke[i];
+          gl.glBegin(GL2.GL_LINE_STRIP);
+          for (int j = 0; j < stroke.num_coords; j++) {
+            CoordRec coord = stroke.coord[j];
+            gl.glVertex2f(coord.x, coord.y);
+          }
+          gl.glEnd();
+        }
+        gl.glTranslatef(ch.right, 0.0f, 0.0f);
+      }
+    }
+  }
+
+  public int  glutStrokeWidth    (int font, char character) {
+    return (int) glutStrokeWidthf(font, character);
+  }
+
+  public float glutStrokeWidthf   (int font, char character) {
+    StrokeFontRec fontinfo = getStrokeFont(font);
+    int c = character & 0xFFFF;
+    if (c < 0 || c >= fontinfo.num_chars)
+      return 0;
+    StrokeCharRec ch = fontinfo.ch[c];
+    if (ch != null)
+      return ch.right;
+    else
+      return 0;
+  }
+
+  public int  glutBitmapLength   (int font, String string) {
+    BitmapFontRec fontinfo = getBitmapFont(font);
+    int length = 0;
+    int len = string.length();
+    for (int pos = 0; pos < len; pos++) {
+      int c = string.charAt(pos) & 0xFFFF;
+      if (c >= fontinfo.first && c < fontinfo.first + fontinfo.num_chars) {
+        BitmapCharRec ch = fontinfo.ch[c - fontinfo.first];
+        if (ch != null)
+          length += ch.advance;
+      }
+    }
+    return length;
+  }
+
+  public int  glutStrokeLength   (int font, String string) {
+    return (int) glutStrokeLengthf(font, string);
+  }
+
+  public float glutStrokeLengthf  (int font, String string) {
+    StrokeFontRec fontinfo = getStrokeFont(font);
+    float length = 0;
+    int len = string.length();
+    for (int i = 0; i < len; i++) {
+      char c = string.charAt(i);
+      if (c >= 0 && c < fontinfo.num_chars) {
+        StrokeCharRec ch = fontinfo.ch[c];
+        if (ch != null)
+          length += ch.right;
+      }
+    }
+    return length;
+  }
+
+  /**
+     This function draws a wireframe dodecahedron whose
+     facets are rhombic and
+     whose vertices are at unit radius.
+     No facet lies normal to any coordinate axes.
+     The polyhedron is centered at the origin.
+  */
+  public void glutWireRhombicDodecahedron() {
+    GL2 gl = GLUgl2.getCurrentGL2();
+    for( int i = 0; i < 12; i++ ) {
+      gl.glBegin( GL2.GL_LINE_LOOP );
+      gl.glNormal3dv( rdod_n[ i ],0 );
+      gl.glVertex3dv( rdod_r[ rdod_v[ i ][ 0 ] ],0 );
+      gl.glVertex3dv( rdod_r[ rdod_v[ i ][ 1 ] ],0 );
+      gl.glVertex3dv( rdod_r[ rdod_v[ i ][ 2 ] ],0 );
+      gl.glVertex3dv( rdod_r[ rdod_v[ i ][ 3 ] ],0 );
+      gl.glEnd( );
+    }
+  }
+  
+  /**
+   This function draws a solid-shaded dodecahedron
+   whose facets are rhombic and
+   whose vertices are at unit radius.
+   No facet lies normal to any coordinate axes.
+   The polyhedron is centered at the origin.
+   */
+  public void glutSolidRhombicDodecahedron() {
+    GL2 gl = GLUgl2.getCurrentGL2();
+    gl.glBegin( GL2.GL_QUADS );
+    for( int i = 0; i < 12; i++ ) {
+      gl.glNormal3dv( rdod_n[ i ],0 );
+      gl.glVertex3dv( rdod_r[ rdod_v[ i ][ 0 ] ],0 );
+      gl.glVertex3dv( rdod_r[ rdod_v[ i ][ 1 ] ],0 );
+      gl.glVertex3dv( rdod_r[ rdod_v[ i ][ 2 ] ],0 );
+      gl.glVertex3dv( rdod_r[ rdod_v[ i ][ 3 ] ],0 );
+    }
+    gl.glEnd( );
+  }
+  
+  //----------------------------------------------------------------------
+  // Internals only below this point
+  //
+
+  //----------------------------------------------------------------------
+  // Shape implementation
+  //
+
+  private GLUquadric quadObj;
+  private void quadObjInit(GLUgl2 glu) {
+    if (quadObj == null) {
+      quadObj = glu.gluNewQuadric();
+    }
+    if (quadObj == null) {
+      throw new GLException("Out of memory");
+    }
+  }
+
+  private static void doughnut(GL2 gl, double r, double R, int nsides, int rings) {
+    int i, j;
+    float theta, phi, theta1;
+    float cosTheta, sinTheta;
+    float cosTheta1, sinTheta1;
+    float ringDelta, sideDelta;
+
+    ringDelta = (float) (2.0 * Math.PI / rings);
+    sideDelta = (float) (2.0 * Math.PI / nsides);
+
+    theta = 0.0f;
+    cosTheta = 1.0f;
+    sinTheta = 0.0f;
+    for (i = rings - 1; i >= 0; i--) {
+      theta1 = theta + ringDelta;
+      cosTheta1 = (float) Math.cos(theta1);
+      sinTheta1 = (float) Math.sin(theta1);
+      gl.glBegin(GL2.GL_QUAD_STRIP);
+      phi = 0.0f;
+      for (j = nsides; j >= 0; j--) {
+        float cosPhi, sinPhi, dist;
+
+        phi += sideDelta;
+        cosPhi = (float) Math.cos(phi);
+        sinPhi = (float) Math.sin(phi);
+        dist = (float) (R + r * cosPhi);
+
+        gl.glNormal3f(cosTheta1 * cosPhi, -sinTheta1 * cosPhi, sinPhi);
+        gl.glVertex3f(cosTheta1 * dist,   -sinTheta1 * dist,   (float) r * sinPhi);
+        gl.glNormal3f(cosTheta  * cosPhi, -sinTheta  * cosPhi, sinPhi);
+        gl.glVertex3f(cosTheta  * dist,   -sinTheta  * dist,   (float) r * sinPhi);
+      }
+      gl.glEnd();
+      theta = theta1;
+      cosTheta = cosTheta1;
+      sinTheta = sinTheta1;
+    }
+  }
+
+  private static float[][] boxVertices;
+  private static final float[][] boxNormals = {
+    {-1.0f, 0.0f, 0.0f},
+    {0.0f, 1.0f, 0.0f},
+    {1.0f, 0.0f, 0.0f},
+    {0.0f, -1.0f, 0.0f},
+    {0.0f, 0.0f, 1.0f},
+    {0.0f, 0.0f, -1.0f}
+  };
+  private static final int[][] boxFaces = {
+    {0, 1, 2, 3},
+    {3, 2, 6, 7},
+    {7, 6, 5, 4},
+    {4, 5, 1, 0},
+    {5, 6, 2, 1},
+    {7, 4, 0, 3}
+  };
+  private void drawBox(GL2 gl, float size, int type) {
+    if (boxVertices == null) {
+      float[][] v = new float[8][];
+      for (int i = 0; i < 8; i++) {
+        v[i] = new float[3];
+      }
+      v[0][0] = v[1][0] = v[2][0] = v[3][0] = -0.5f;
+      v[4][0] = v[5][0] = v[6][0] = v[7][0] =  0.5f;
+      v[0][1] = v[1][1] = v[4][1] = v[5][1] = -0.5f;
+      v[2][1] = v[3][1] = v[6][1] = v[7][1] =  0.5f;
+      v[0][2] = v[3][2] = v[4][2] = v[7][2] = -0.5f;
+      v[1][2] = v[2][2] = v[5][2] = v[6][2] =  0.5f;
+      boxVertices = v;
+    }
+    float[][] v = boxVertices;
+    float[][] n = boxNormals;
+    int[][] faces = boxFaces;
+    for (int i = 5; i >= 0; i--) {
+      gl.glBegin(type);
+      gl.glNormal3fv(n[i], 0);
+      float[] vt = v[faces[i][0]];
+      gl.glVertex3f(vt[0] * size, vt[1] * size, vt[2] * size);
+      vt = v[faces[i][1]];
+      gl.glVertex3f(vt[0] * size, vt[1] * size, vt[2] * size);
+      vt = v[faces[i][2]];
+      gl.glVertex3f(vt[0] * size, vt[1] * size, vt[2] * size);
+      vt = v[faces[i][3]];
+      gl.glVertex3f(vt[0] * size, vt[1] * size, vt[2] * size);
+      gl.glEnd();
+    }
+  }
+
+  private float[][] dodec;
+
+  private void initDodecahedron() {
+    dodec = new float[20][];
+    for (int i = 0; i < dodec.length; i++) {
+      dodec[i] = new float[3];
+    }
+
+    float alpha, beta;
+
+    alpha = (float) Math.sqrt(2.0f / (3.0f + Math.sqrt(5.0)));
+    beta = 1.0f + (float) Math.sqrt(6.0 / (3.0 + Math.sqrt(5.0)) -
+                                    2.0 + 2.0 * Math.sqrt(2.0 / (3.0 + Math.sqrt(5.0))));
+    dodec[0][0] = -alpha; dodec[0][1] = 0; dodec[0][2] = beta;
+    dodec[1][0] = alpha; dodec[1][1] = 0; dodec[1][2] = beta;
+    dodec[2][0] = -1; dodec[2][1] = -1; dodec[2][2] = -1;
+    dodec[3][0] = -1; dodec[3][1] = -1; dodec[3][2] = 1;
+    dodec[4][0] = -1; dodec[4][1] = 1; dodec[4][2] = -1;
+    dodec[5][0] = -1; dodec[5][1] = 1; dodec[5][2] = 1;
+    dodec[6][0] = 1; dodec[6][1] = -1; dodec[6][2] = -1;
+    dodec[7][0] = 1; dodec[7][1] = -1; dodec[7][2] = 1;
+    dodec[8][0] = 1; dodec[8][1] = 1; dodec[8][2] = -1;
+    dodec[9][0] = 1; dodec[9][1] = 1; dodec[9][2] = 1;
+    dodec[10][0] = beta; dodec[10][1] = alpha; dodec[10][2] = 0;
+    dodec[11][0] = beta; dodec[11][1] = -alpha; dodec[11][2] = 0;
+    dodec[12][0] = -beta; dodec[12][1] = alpha; dodec[12][2] = 0;
+    dodec[13][0] = -beta; dodec[13][1] = -alpha; dodec[13][2] = 0;
+    dodec[14][0] = -alpha; dodec[14][1] = 0; dodec[14][2] = -beta;
+    dodec[15][0] = alpha; dodec[15][1] = 0; dodec[15][2] = -beta;
+    dodec[16][0] = 0; dodec[16][1] = beta; dodec[16][2] = alpha;
+    dodec[17][0] = 0; dodec[17][1] = beta; dodec[17][2] = -alpha;
+    dodec[18][0] = 0; dodec[18][1] = -beta; dodec[18][2] = alpha;
+    dodec[19][0] = 0; dodec[19][1] = -beta; dodec[19][2] = -alpha;
+  }
+
+  private static void diff3(float[] a, float[] b, float[] c) {
+    c[0] = a[0] - b[0];
+    c[1] = a[1] - b[1];
+    c[2] = a[2] - b[2];
+  }
+
+  private static void crossprod(float[] v1, float[] v2, float[] prod) {
+    float[] p = new float[3];         /* in case prod == v1 or v2 */
+
+    p[0] = v1[1] * v2[2] - v2[1] * v1[2];
+    p[1] = v1[2] * v2[0] - v2[2] * v1[0];
+    p[2] = v1[0] * v2[1] - v2[0] * v1[1];
+    prod[0] = p[0];
+    prod[1] = p[1];
+    prod[2] = p[2];
+  }
+
+  private static void normalize(float[] v) {
+    float d;
+
+    d = (float) Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+    if (d == 0.0) {
+      v[0] = d = 1.0f;
+    }
+    d = 1 / d;
+    v[0] *= d;
+    v[1] *= d;
+    v[2] *= d;
+  }
+
+  private void pentagon(GL2 gl, int a, int b, int c, int d, int e, int shadeType) {
+    float[] n0 = new float[3];
+    float[] d1 = new float[3];
+    float[] d2 = new float[3];
+
+    diff3(dodec[a], dodec[b], d1);
+    diff3(dodec[b], dodec[c], d2);
+    crossprod(d1, d2, n0);
+    normalize(n0);
+
+    gl.glBegin(shadeType);
+    gl.glNormal3fv(n0, 0);
+    gl.glVertex3fv(dodec[a], 0);
+    gl.glVertex3fv(dodec[b], 0);
+    gl.glVertex3fv(dodec[c], 0);
+    gl.glVertex3fv(dodec[d], 0);
+    gl.glVertex3fv(dodec[e], 0);
+    gl.glEnd();
+  }
+
+  private void dodecahedron(GL2 gl, int type) {
+    if (dodec == null) {
+      initDodecahedron();
+    }
+    pentagon(gl, 0, 1, 9, 16, 5, type);
+    pentagon(gl, 1, 0, 3, 18, 7, type);
+    pentagon(gl, 1, 7, 11, 10, 9, type);
+    pentagon(gl, 11, 7, 18, 19, 6, type);
+    pentagon(gl, 8, 17, 16, 9, 10, type);
+    pentagon(gl, 2, 14, 15, 6, 19, type);
+    pentagon(gl, 2, 13, 12, 4, 14, type);
+    pentagon(gl, 2, 19, 18, 3, 13, type);
+    pentagon(gl, 3, 0, 5, 12, 13, type);
+    pentagon(gl, 6, 15, 8, 10, 11, type);
+    pentagon(gl, 4, 17, 8, 15, 14, type);
+    pentagon(gl, 4, 12, 5, 16, 17, type);
+  }
+
+  private static void recorditem(GL2 gl, float[] n1, float[] n2, float[] n3, int shadeType) {
+    float[] q0 = new float[3];
+    float[] q1 = new float[3];
+
+    diff3(n1, n2, q0);
+    diff3(n2, n3, q1);
+    crossprod(q0, q1, q1);
+    normalize(q1);
+
+    gl.glBegin(shadeType);
+    gl.glNormal3fv(q1, 0);
+    gl.glVertex3fv(n1, 0);
+    gl.glVertex3fv(n2, 0);
+    gl.glVertex3fv(n3, 0);
+    gl.glEnd();
+  }
+
+  private static void subdivide(GL2 gl, float[] v0, float[] v1, float[] v2, int shadeType) {
+    int depth;
+    float[] w0 = new float[3];
+    float[] w1 = new float[3];
+    float[] w2 = new float[3];
+    float l;
+    int i, j, k, n;
+
+    depth = 1;
+    for (i = 0; i < depth; i++) {
+      for (j = 0; i + j < depth; j++) {
+        k = depth - i - j;
+        for (n = 0; n < 3; n++) {
+          w0[n] = (i * v0[n] + j * v1[n] + k * v2[n]) / depth;
+          w1[n] = ((i + 1) * v0[n] + j * v1[n] + (k - 1) * v2[n])
+            / depth;
+          w2[n] = (i * v0[n] + (j + 1) * v1[n] + (k - 1) * v2[n])
+            / depth;
+        }
+        l = (float) Math.sqrt(w0[0] * w0[0] + w0[1] * w0[1] + w0[2] * w0[2]);
+        w0[0] /= l;
+        w0[1] /= l;
+        w0[2] /= l;
+        l = (float) Math.sqrt(w1[0] * w1[0] + w1[1] * w1[1] + w1[2] * w1[2]);
+        w1[0] /= l;
+        w1[1] /= l;
+        w1[2] /= l;
+        l = (float) Math.sqrt(w2[0] * w2[0] + w2[1] * w2[1] + w2[2] * w2[2]);
+        w2[0] /= l;
+        w2[1] /= l;
+        w2[2] /= l;
+        recorditem(gl, w1, w0, w2, shadeType);
+      }
+    }
+  }
+
+  private static void drawtriangle(GL2 gl, int i, float[][] data, int[][] ndx, int shadeType) {
+    float[] x0 = data[ndx[i][0]];
+    float[] x1 = data[ndx[i][1]];
+    float[] x2 = data[ndx[i][2]];
+    subdivide(gl, x0, x1, x2, shadeType);
+  }
+
+  /* octahedron data: The octahedron produced is centered at the
+     origin and has radius 1.0 */
+  private static final float[][] odata =
+  {
+    {1.0f, 0.0f, 0.0f},
+    {-1.0f, 0.0f, 0.0f},
+    {0.0f, 1.0f, 0.0f},
+    {0.0f, -1.0f, 0.0f},
+    {0.0f, 0.0f, 1.0f},
+    {0.0f, 0.0f, -1.0f}
+  };
+
+  private static final int[][] ondex =
+  {
+    {0, 4, 2},
+    {1, 2, 4},
+    {0, 3, 4},
+    {1, 4, 3},
+    {0, 2, 5},
+    {1, 5, 2},
+    {0, 5, 3},
+    {1, 3, 5}
+  };
+
+  private static void octahedron(GL2 gl, int shadeType) {
+    int i;
+
+    for (i = 7; i >= 0; i--) {
+      drawtriangle(gl, i, odata, ondex, shadeType);
+    }
+  }
+
+  /* icosahedron data: These numbers are rigged to make an
+     icosahedron of radius 1.0 */
+
+  private static final float X = .525731112119133606f;
+  private static final float Z = .850650808352039932f;
+
+  private static final float[][] idata =
+  {
+    {-X, 0, Z},
+    {X, 0, Z},
+    {-X, 0, -Z},
+    {X, 0, -Z},
+    {0, Z, X},
+    {0, Z, -X},
+    {0, -Z, X},
+    {0, -Z, -X},
+    {Z, X, 0},
+    {-Z, X, 0},
+    {Z, -X, 0},
+    {-Z, -X, 0}
+  };
+
+  private static final int[][] index =
+  {
+    {0, 4, 1},
+    {0, 9, 4},
+    {9, 5, 4},
+    {4, 5, 8},
+    {4, 8, 1},
+    {8, 10, 1},
+    {8, 3, 10},
+    {5, 3, 8},
+    {5, 2, 3},
+    {2, 7, 3},
+    {7, 10, 3},
+    {7, 6, 10},
+    {7, 11, 6},
+    {11, 0, 6},
+    {0, 1, 6},
+    {6, 1, 10},
+    {9, 0, 11},
+    {9, 11, 2},
+    {9, 2, 5},
+    {7, 2, 11},
+  };
+
+  private static void icosahedron(GL2 gl, int shadeType) {
+    int i;
+
+    for (i = 19; i >= 0; i--) {
+      drawtriangle(gl, i, idata, index, shadeType);
+    }
+  }
+
+  /* rhombic dodecahedron data: */
+  
+  private static final double rdod_r[][] =
+  {
+    { 0.0, 0.0, 1.0 },
+    {  0.707106781187,  0.000000000000,  0.5 },
+    {  0.000000000000,  0.707106781187,  0.5 },
+    { -0.707106781187,  0.000000000000,  0.5 },
+    {  0.000000000000, -0.707106781187,  0.5 },
+    {  0.707106781187,  0.707106781187,  0.0 },
+    { -0.707106781187,  0.707106781187,  0.0 },
+    { -0.707106781187, -0.707106781187,  0.0 },
+    {  0.707106781187, -0.707106781187,  0.0 },
+    {  0.707106781187,  0.000000000000, -0.5 },
+    {  0.000000000000,  0.707106781187, -0.5 },
+    { -0.707106781187,  0.000000000000, -0.5 },
+    {  0.000000000000, -0.707106781187, -0.5 },
+    {  0.0, 0.0, -1.0 }
+  };
+  
+  private static final int rdod_v[][] =
+  {
+    { 0,  1,  5,  2 },
+    { 0,  2,  6,  3 },
+    { 0,  3,  7,  4 },
+    { 0,  4,  8,  1 },
+    { 5, 10,  6,  2 },
+    { 6, 11,  7,  3 },
+    { 7, 12,  8,  4 },
+    { 8,  9,  5,  1 },
+    { 5,  9, 13, 10 },
+    { 6, 10, 13, 11 },
+    { 7, 11, 13, 12 },
+    { 8, 12, 13,  9 }
+  };
+  
+  private static final double rdod_n[][] =
+  {
+    {  0.353553390594,  0.353553390594,  0.5 },
+    { -0.353553390594,  0.353553390594,  0.5 },
+    { -0.353553390594, -0.353553390594,  0.5 },
+    {  0.353553390594, -0.353553390594,  0.5 },
+    {  0.000000000000,  1.000000000000,  0.0 },
+    { -1.000000000000,  0.000000000000,  0.0 },
+    {  0.000000000000, -1.000000000000,  0.0 },
+    {  1.000000000000,  0.000000000000,  0.0 },
+    {  0.353553390594,  0.353553390594, -0.5 },
+    { -0.353553390594,  0.353553390594, -0.5 },
+    { -0.353553390594, -0.353553390594, -0.5 },
+    {  0.353553390594, -0.353553390594, -0.5 }
+  };
+  
+  /* tetrahedron data: */
+
+  private static final float T = 1.73205080756887729f;
+
+  private static final float[][] tdata =
+  {
+    {T, T, T},
+    {T, -T, -T},
+    {-T, T, -T},
+    {-T, -T, T}
+  };
+
+  private static final int[][] tndex =
+  {
+    {0, 1, 3},
+    {2, 1, 0},
+    {3, 2, 0},
+    {1, 2, 3}
+  };
+
+  private static final void tetrahedron(GL2 gl, int shadeType) {
+    for (int i = 3; i >= 0; i--)
+      drawtriangle(gl, i, tdata, tndex, shadeType);
+  }
+
+  // Teapot implementation (a modified port of glut_teapot.c)
+  //
+  // Rim, body, lid, and bottom data must be reflected in x and
+  // y; handle and spout data across the y axis only.
+  private static final int[][] teapotPatchData = {
+    /* rim */
+    {102, 103, 104, 105, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
+    /* body */
+    {12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27},
+    {24, 25, 26, 27, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40},
+    /* lid */
+    {96, 96, 96, 96, 97, 98, 99, 100, 101, 101, 101, 101, 0, 1, 2, 3,},
+    {0, 1, 2, 3, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117},
+    /* bottom */
+    {118, 118, 118, 118, 124, 122, 119, 121, 123, 126, 125, 120, 40, 39, 38, 37},
+    /* handle */
+    {41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56},
+    {53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 28, 65, 66, 67},
+    /* spout */
+    {68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83},
+    {80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95}
+  };
+  private static final float[][] teapotCPData = {
+    {0.2f, 0f, 2.7f},
+    {0.2f, -0.112f, 2.7f},
+    {0.112f, -0.2f, 2.7f},
+    {0f, -0.2f, 2.7f},
+    {1.3375f, 0f, 2.53125f},
+    {1.3375f, -0.749f, 2.53125f},
+    {0.749f, -1.3375f, 2.53125f},
+    {0f, -1.3375f, 2.53125f},
+    {1.4375f, 0f, 2.53125f},
+    {1.4375f, -0.805f, 2.53125f},
+    {0.805f, -1.4375f, 2.53125f},
+    {0f, -1.4375f, 2.53125f},
+    {1.5f, 0f, 2.4f},
+    {1.5f, -0.84f, 2.4f},
+    {0.84f, -1.5f, 2.4f},
+    {0f, -1.5f, 2.4f},
+    {1.75f, 0f, 1.875f},
+    {1.75f, -0.98f, 1.875f},
+    {0.98f, -1.75f, 1.875f},
+    {0f, -1.75f, 1.875f},
+    {2f, 0f, 1.35f},
+    {2f, -1.12f, 1.35f},
+    {1.12f, -2f, 1.35f},
+    {0f, -2f, 1.35f},
+    {2f, 0f, 0.9f},
+    {2f, -1.12f, 0.9f},
+    {1.12f, -2f, 0.9f},
+    {0f, -2f, 0.9f},
+    {-2f, 0f, 0.9f},
+    {2f, 0f, 0.45f},
+    {2f, -1.12f, 0.45f},
+    {1.12f, -2f, 0.45f},
+    {0f, -2f, 0.45f},
+    {1.5f, 0f, 0.225f},
+    {1.5f, -0.84f, 0.225f},
+    {0.84f, -1.5f, 0.225f},
+    {0f, -1.5f, 0.225f},
+    {1.5f, 0f, 0.15f},
+    {1.5f, -0.84f, 0.15f},
+    {0.84f, -1.5f, 0.15f},
+    {0f, -1.5f, 0.15f},
+    {-1.6f, 0f, 2.025f},
+    {-1.6f, -0.3f, 2.025f},
+    {-1.5f, -0.3f, 2.25f},
+    {-1.5f, 0f, 2.25f},
+    {-2.3f, 0f, 2.025f},
+    {-2.3f, -0.3f, 2.025f},
+    {-2.5f, -0.3f, 2.25f},
+    {-2.5f, 0f, 2.25f},
+    {-2.7f, 0f, 2.025f},
+    {-2.7f, -0.3f, 2.025f},
+    {-3f, -0.3f, 2.25f},
+    {-3f, 0f, 2.25f},
+    {-2.7f, 0f, 1.8f},
+    {-2.7f, -0.3f, 1.8f},
+    {-3f, -0.3f, 1.8f},
+    {-3f, 0f, 1.8f},
+    {-2.7f, 0f, 1.575f},
+    {-2.7f, -0.3f, 1.575f},
+    {-3f, -0.3f, 1.35f},
+    {-3f, 0f, 1.35f},
+    {-2.5f, 0f, 1.125f},
+    {-2.5f, -0.3f, 1.125f},
+    {-2.65f, -0.3f, 0.9375f},
+    {-2.65f, 0f, 0.9375f},
+    {-2f, -0.3f, 0.9f},
+    {-1.9f, -0.3f, 0.6f},
+    {-1.9f, 0f, 0.6f},
+    {1.7f, 0f, 1.425f},
+    {1.7f, -0.66f, 1.425f},
+    {1.7f, -0.66f, 0.6f},
+    {1.7f, 0f, 0.6f},
+    {2.6f, 0f, 1.425f},
+    {2.6f, -0.66f, 1.425f},
+    {3.1f, -0.66f, 0.825f},
+    {3.1f, 0f, 0.825f},
+    {2.3f, 0f, 2.1f},
+    {2.3f, -0.25f, 2.1f},
+    {2.4f, -0.25f, 2.025f},
+    {2.4f, 0f, 2.025f},
+    {2.7f, 0f, 2.4f},
+    {2.7f, -0.25f, 2.4f},
+    {3.3f, -0.25f, 2.4f},
+    {3.3f, 0f, 2.4f},
+    {2.8f, 0f, 2.475f},
+    {2.8f, -0.25f, 2.475f},
+    {3.525f, -0.25f, 2.49375f},
+    {3.525f, 0f, 2.49375f},
+    {2.9f, 0f, 2.475f},
+    {2.9f, -0.15f, 2.475f},
+    {3.45f, -0.15f, 2.5125f},
+    {3.45f, 0f, 2.5125f},
+    {2.8f, 0f, 2.4f},
+    {2.8f, -0.15f, 2.4f},
+    {3.2f, -0.15f, 2.4f},
+    {3.2f, 0f, 2.4f},
+    {0f, 0f, 3.15f},
+    {0.8f, 0f, 3.15f},
+    {0.8f, -0.45f, 3.15f},
+    {0.45f, -0.8f, 3.15f},
+    {0f, -0.8f, 3.15f},
+    {0f, 0f, 2.85f},
+    {1.4f, 0f, 2.4f},
+    {1.4f, -0.784f, 2.4f},
+    {0.784f, -1.4f, 2.4f},
+    {0f, -1.4f, 2.4f},
+    {0.4f, 0f, 2.55f},
+    {0.4f, -0.224f, 2.55f},
+    {0.224f, -0.4f, 2.55f},
+    {0f, -0.4f, 2.55f},
+    {1.3f, 0f, 2.55f},
+    {1.3f, -0.728f, 2.55f},
+    {0.728f, -1.3f, 2.55f},
+    {0f, -1.3f, 2.55f},
+    {1.3f, 0f, 2.4f},
+    {1.3f, -0.728f, 2.4f},
+    {0.728f, -1.3f, 2.4f},
+    {0f, -1.3f, 2.4f},
+    {0f, 0f, 0f},
+    {1.425f, -0.798f, 0f},
+    {1.5f, 0f, 0.075f},
+    {1.425f, 0f, 0f},
+    {0.798f, -1.425f, 0f},
+    {0f, -1.5f, 0.075f},
+    {0f, -1.425f, 0f},
+    {1.5f, -0.84f, 0.075f},
+    {0.84f, -1.5f, 0.075f}
+  };
+  // Since GL2.glMap2f expects a packed array of floats, we must convert
+  // from a 3-dimensional array to a 1-dimensional array
+  private static final float[] teapotTex = {
+    0, 0, 1, 0, 0, 1, 1, 1
+  };
+
+  private static void teapot(GL2 gl,
+                             int grid,
+                             double scale,
+                             int type,
+                             boolean backCompatible)
+  {
+    // As mentioned above, GL2.glMap2f expects a packed array of floats
+    float[] p = new float[4*4*3];
+    float[] q = new float[4*4*3];
+    float[] r = new float[4*4*3];
+    float[] s = new float[4*4*3];
+    int i, j, k, l;
+  
+    gl.glPushAttrib(GL2.GL_ENABLE_BIT | GL2.GL_EVAL_BIT | GL2.GL_POLYGON_BIT);
+    gl.glEnable(GL2.GL_AUTO_NORMAL);
+    gl.glEnable(GL2.GL_NORMALIZE);
+    gl.glEnable(GL2.GL_MAP2_VERTEX_3);
+    gl.glEnable(GL2.GL_MAP2_TEXTURE_COORD_2);
+    gl.glPushMatrix();
+    if (!backCompatible) {
+      // The time has come to have the teapot no longer be inside out
+      gl.glFrontFace(GL2.GL_CW);
+      gl.glScaled(0.5*scale, 0.5*scale, 0.5*scale);
+    } else {
+      // We want the teapot in it's backward compatible position and
+      // orientation
+      gl.glRotatef(270.0f, 1, 0, 0);
+      gl.glScalef((float)(0.5 * scale),
+                  (float)(0.5 * scale),
+                  (float)(0.5 * scale));
+      gl.glTranslatef(0.0f, 0.0f, -1.5f);
+    }
+    for (i = 0; i < 10; i++) {
+      for (j = 0; j < 4; j++) {
+        for (k = 0; k < 4; k++) {
+          for (l = 0; l < 3; l++) {
+            p[(j*4+k)*3+l] = teapotCPData[teapotPatchData[i][j * 4 + k]][l];
+            q[(j*4+k)*3+l] =
+              teapotCPData[teapotPatchData[i][j * 4 + (3 - k)]][l];
+            if (l == 1)
+              q[(j*4+k)*3+l] *= -1.0;
+            if (i < 6) {
+              r[(j*4+k)*3+l] =
+                teapotCPData[teapotPatchData[i][j * 4 + (3 - k)]][l];
+              if (l == 0)
+                r[(j*4+k)*3+l] *= -1.0;
+              s[(j*4+k)*3+l] = teapotCPData[teapotPatchData[i][j * 4 + k]][l];
+              if (l == 0)
+                s[(j*4+k)*3+l] *= -1.0;
+              if (l == 1)
+                s[(j*4+k)*3+l] *= -1.0;
+            }
+          }
+        }
+      }
+      gl.glMap2f(GL2.GL_MAP2_TEXTURE_COORD_2, 0, 1, 2, 2, 0, 1, 4, 2, teapotTex, 0);
+      gl.glMap2f(GL2.GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4, p, 0);
+      gl.glMapGrid2f(grid, 0.0f, 1.0f, grid, 0.0f, 1.0f);
+      evaluateTeapotMesh(gl, grid, type, i, !backCompatible);
+      gl.glMap2f(GL2.GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4, q, 0);
+      evaluateTeapotMesh(gl, grid, type, i, !backCompatible);
+      if (i < 6) {
+        gl.glMap2f(GL2.GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4, r, 0);
+        evaluateTeapotMesh(gl, grid, type, i, !backCompatible);
+        gl.glMap2f(GL2.GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4, s, 0);
+        evaluateTeapotMesh(gl, grid, type, i, !backCompatible);
+      }
+    }
+    gl.glPopMatrix();
+    gl.glPopAttrib();
+  }
+  
+  private static void evaluateTeapotMesh(GL2 gl,
+                                         int grid,
+                                         int type,
+                                         int partNum,
+                                         boolean repairSingularities)
+  {
+    if (repairSingularities && (partNum == 5 || partNum == 3)) {
+      // Instead of using evaluators that give bad results at singularities,
+      // evaluate by hand
+      gl.glPolygonMode(GL2.GL_FRONT_AND_BACK, type);
+      for (int nv = 0; nv < grid; nv++) {
+        if (nv == 0) {
+          // Draw a small triangle-fan to fill the hole
+          gl.glDisable(GL2.GL_AUTO_NORMAL);
+          gl.glNormal3f(0, 0, partNum == 3 ? 1 : -1);
+          gl.glBegin(GL2.GL_TRIANGLE_FAN);
+          {
+            gl.glEvalCoord2f(0, 0);
+            // Note that we draw in clock-wise order to match the evaluator
+            // method
+            for (int nu = 0; nu <= grid; nu++)
+            {
+              gl.glEvalCoord2f(nu / (float)grid, (1f / grid) / (float)grid);
+            }
+          }
+          gl.glEnd();
+          gl.glEnable(GL2.GL_AUTO_NORMAL);
+        }
+        // Draw the rest of the piece as an evaluated quad-strip
+        gl.glBegin(GL2.GL_QUAD_STRIP);
+        {
+          // Note that we draw in clock-wise order to match the evaluator method
+          for (int nu = grid; nu >= 0; nu--) {
+            gl.glEvalCoord2f(nu / (float)grid, (nv + 1) / (float)grid);
+            gl.glEvalCoord2f(nu / (float)grid, Math.max(nv, 1f / grid)
+                                                         / (float)grid);
+          }
+        }
+        gl.glEnd();
+      }
+    } else {
+      gl.glEvalMesh2(type, 0, grid, 0, grid);
+    }
+  }
+
+  //----------------------------------------------------------------------
+  // Font implementation
+  //
+
+  private static void bitmapCharacterImpl(GL2 gl, int font, char cin) {
+    BitmapFontRec fontinfo = getBitmapFont(font);
+    int c = cin & 0xFFFF;
+    if (c < fontinfo.first ||
+        c >= fontinfo.first + fontinfo.num_chars)
+      return;
+    BitmapCharRec ch = fontinfo.ch[c - fontinfo.first];
+    if (ch != null) {
+      gl.glBitmap(ch.width, ch.height, ch.xorig, ch.yorig,
+                  ch.advance, 0, ch.bitmap, 0);
+    }
+  }
+
+  private static final BitmapFontRec[] bitmapFonts = new BitmapFontRec[9];
+  private static final StrokeFontRec[] strokeFonts = new StrokeFontRec[9];
+
+  private static BitmapFontRec getBitmapFont(int font) {
+    BitmapFontRec rec = bitmapFonts[font];
+    if (rec == null) {
+      switch (font) {
+        case BITMAP_9_BY_15:
+          rec = GLUTBitmap9x15.glutBitmap9By15;
+          break;
+        case BITMAP_8_BY_13:
+          rec = GLUTBitmap8x13.glutBitmap8By13;
+          break;
+        case BITMAP_TIMES_ROMAN_10:
+          rec = GLUTBitmapTimesRoman10.glutBitmapTimesRoman10;
+          break;
+        case BITMAP_TIMES_ROMAN_24:
+          rec = GLUTBitmapTimesRoman24.glutBitmapTimesRoman24;
+          break;
+        case BITMAP_HELVETICA_10:
+          rec = GLUTBitmapHelvetica10.glutBitmapHelvetica10;
+          break;
+        case BITMAP_HELVETICA_12:
+          rec = GLUTBitmapHelvetica12.glutBitmapHelvetica12;
+          break;
+        case BITMAP_HELVETICA_18:
+          rec = GLUTBitmapHelvetica18.glutBitmapHelvetica18;
+          break;
+        default:
+          throw new GLException("Unknown bitmap font number " + font);
+      }
+      bitmapFonts[font] = rec;
+    }
+    return rec;
+  }
+
+  private static StrokeFontRec getStrokeFont(int font) {
+    StrokeFontRec rec = strokeFonts[font];
+    if (rec == null) {
+      switch (font) {
+        case STROKE_ROMAN:
+          rec = GLUTStrokeRoman.glutStrokeRoman;
+          break;
+        case STROKE_MONO_ROMAN:
+          rec = GLUTStrokeMonoRoman.glutStrokeMonoRoman;
+          break;
+        default:
+          throw new GLException("Unknown stroke font number " + font);
+      }
+    }
+    return rec;
+  }
+
+  private static void beginBitmap(GL2 gl,
+                                  int[] swapbytes,
+                                  int[] lsbfirst,
+                                  int[] rowlength,
+                                  int[] skiprows,
+                                  int[] skippixels,
+                                  int[] alignment) {
+    gl.glGetIntegerv(GL2.GL_UNPACK_SWAP_BYTES, swapbytes, 0);
+    gl.glGetIntegerv(GL2.GL_UNPACK_LSB_FIRST, lsbfirst, 0);
+    gl.glGetIntegerv(GL2.GL_UNPACK_ROW_LENGTH, rowlength, 0);
+    gl.glGetIntegerv(GL2.GL_UNPACK_SKIP_ROWS, skiprows, 0);
+    gl.glGetIntegerv(GL2.GL_UNPACK_SKIP_PIXELS, skippixels, 0);
+    gl.glGetIntegerv(GL2.GL_UNPACK_ALIGNMENT, alignment, 0);
+    /* Little endian machines (DEC Alpha for example) could
+       benefit from setting GL_UNPACK_LSB_FIRST to GL_TRUE
+       instead of GL_FALSE, but this would require changing the
+       generated bitmaps too. */
+    gl.glPixelStorei(GL2.GL_UNPACK_SWAP_BYTES, GL2.GL_FALSE);
+    gl.glPixelStorei(GL2.GL_UNPACK_LSB_FIRST, GL2.GL_FALSE);
+    gl.glPixelStorei(GL2.GL_UNPACK_ROW_LENGTH, 0);
+    gl.glPixelStorei(GL2.GL_UNPACK_SKIP_ROWS, 0);
+    gl.glPixelStorei(GL2.GL_UNPACK_SKIP_PIXELS, 0);
+    gl.glPixelStorei(GL2.GL_UNPACK_ALIGNMENT, 1);
+  }
+
+  private static void endBitmap(GL2 gl,
+                                int[] swapbytes,
+                                int[] lsbfirst,
+                                int[] rowlength,
+                                int[] skiprows,
+                                int[] skippixels,
+                                int[] alignment) {
+    /* Restore saved modes. */
+    gl.glPixelStorei(GL2.GL_UNPACK_SWAP_BYTES, swapbytes[0]);
+    gl.glPixelStorei(GL2.GL_UNPACK_LSB_FIRST, lsbfirst[0]);
+    gl.glPixelStorei(GL2.GL_UNPACK_ROW_LENGTH, rowlength[0]);
+    gl.glPixelStorei(GL2.GL_UNPACK_SKIP_ROWS, skiprows[0]);
+    gl.glPixelStorei(GL2.GL_UNPACK_SKIP_PIXELS, skippixels[0]);
+    gl.glPixelStorei(GL2.GL_UNPACK_ALIGNMENT, alignment[0]);
+  }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/gl2/GLUTBitmap8x13.java b/src/jogl/classes/com/jogamp/opengl/util/gl2/GLUTBitmap8x13.java
new file mode 100644
index 000000000..07ded652a
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/gl2/GLUTBitmap8x13.java
@@ -0,0 +1,2078 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util.gl2;
+
+class GLUTBitmap8x13 {
+
+/* GENERATED FILE -- DO NOT MODIFY */
+
+
+static final BitmapCharRec ch0 = new BitmapCharRec(0,0,0,0,8,null);
+
+static final BitmapCharRec ch32 = new BitmapCharRec(0,0,0,0,8,null);
+
+static final BitmapCharRec ch127 = new BitmapCharRec(0,0,0,0,8,null);
+
+static final BitmapCharRec ch160 = new BitmapCharRec(0,0,0,0,8,null);
+
+/* char: 0xff */
+
+static final byte[] ch255data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x4,(byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x0,(byte) 0x48,(byte) 0x48,
+};
+
+static final BitmapCharRec ch255 = new BitmapCharRec(6,12,-1,2,8,ch255data);
+
+/* char: 0xfe */
+
+static final byte[] ch254data = {
+(byte) 0x80,(byte) 0x80,(byte) 0xb8,(byte) 0xc4,(byte) 0x84,(byte) 0x84,(byte) 0xc4,(byte) 0xb8,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch254 = new BitmapCharRec(6,10,-1,2,8,ch254data);
+
+/* char: 0xfd */
+
+static final byte[] ch253data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x4,(byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x0,(byte) 0x20,(byte) 0x10,
+};
+
+static final BitmapCharRec ch253 = new BitmapCharRec(6,12,-1,2,8,ch253data);
+
+/* char: 0xfc */
+
+static final byte[] ch252data = {
+(byte) 0x74,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x0,(byte) 0x0,(byte) 0x48,(byte) 0x48,
+};
+
+static final BitmapCharRec ch252 = new BitmapCharRec(6,10,-1,0,8,ch252data);
+
+/* char: 0xfb */
+
+static final byte[] ch251data = {
+(byte) 0x74,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x0,(byte) 0x0,(byte) 0x48,(byte) 0x30,
+};
+
+static final BitmapCharRec ch251 = new BitmapCharRec(6,10,-1,0,8,ch251data);
+
+/* char: 0xfa */
+
+static final byte[] ch250data = {
+(byte) 0x74,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x0,(byte) 0x0,(byte) 0x20,(byte) 0x10,
+};
+
+static final BitmapCharRec ch250 = new BitmapCharRec(6,10,-1,0,8,ch250data);
+
+/* char: 0xf9 */
+
+static final byte[] ch249data = {
+(byte) 0x74,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x0,(byte) 0x0,(byte) 0x10,(byte) 0x20,
+};
+
+static final BitmapCharRec ch249 = new BitmapCharRec(6,10,-1,0,8,ch249data);
+
+/* char: 0xf8 */
+
+static final byte[] ch248data = {
+(byte) 0x80,(byte) 0x78,(byte) 0xc4,(byte) 0xa4,(byte) 0x94,(byte) 0x8c,(byte) 0x78,(byte) 0x4,
+};
+
+static final BitmapCharRec ch248 = new BitmapCharRec(6,8,-1,1,8,ch248data);
+
+/* char: 0xf7 */
+
+static final byte[] ch247data = {
+(byte) 0x20,(byte) 0x20,(byte) 0x0,(byte) 0xf8,(byte) 0x0,(byte) 0x20,(byte) 0x20,
+};
+
+static final BitmapCharRec ch247 = new BitmapCharRec(5,7,-1,-1,8,ch247data);
+
+/* char: 0xf6 */
+
+static final byte[] ch246data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x48,(byte) 0x48,
+};
+
+static final BitmapCharRec ch246 = new BitmapCharRec(6,10,-1,0,8,ch246data);
+
+/* char: 0xf5 */
+
+static final byte[] ch245data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x50,(byte) 0x28,
+};
+
+static final BitmapCharRec ch245 = new BitmapCharRec(6,10,-1,0,8,ch245data);
+
+/* char: 0xf4 */
+
+static final byte[] ch244data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x48,(byte) 0x30,
+};
+
+static final BitmapCharRec ch244 = new BitmapCharRec(6,10,-1,0,8,ch244data);
+
+/* char: 0xf3 */
+
+static final byte[] ch243data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x20,(byte) 0x10,
+};
+
+static final BitmapCharRec ch243 = new BitmapCharRec(6,10,-1,0,8,ch243data);
+
+/* char: 0xf2 */
+
+static final byte[] ch242data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x10,(byte) 0x20,
+};
+
+static final BitmapCharRec ch242 = new BitmapCharRec(6,10,-1,0,8,ch242data);
+
+/* char: 0xf1 */
+
+static final byte[] ch241data = {
+(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xc4,(byte) 0xb8,(byte) 0x0,(byte) 0x0,(byte) 0x50,(byte) 0x28,
+};
+
+static final BitmapCharRec ch241 = new BitmapCharRec(6,10,-1,0,8,ch241data);
+
+/* char: 0xf0 */
+
+static final byte[] ch240data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,(byte) 0x8,(byte) 0x50,(byte) 0x30,(byte) 0x48,
+};
+
+static final BitmapCharRec ch240 = new BitmapCharRec(6,10,-1,0,8,ch240data);
+
+/* char: 0xef */
+
+static final byte[] ch239data = {
+(byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x60,(byte) 0x0,(byte) 0x0,(byte) 0x50,(byte) 0x50,
+};
+
+static final BitmapCharRec ch239 = new BitmapCharRec(5,10,-1,0,8,ch239data);
+
+/* char: 0xee */
+
+static final byte[] ch238data = {
+(byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x60,(byte) 0x0,(byte) 0x0,(byte) 0x90,(byte) 0x60,
+};
+
+static final BitmapCharRec ch238 = new BitmapCharRec(5,10,-1,0,8,ch238data);
+
+/* char: 0xed */
+
+static final byte[] ch237data = {
+(byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x60,(byte) 0x0,(byte) 0x0,(byte) 0x40,(byte) 0x20,
+};
+
+static final BitmapCharRec ch237 = new BitmapCharRec(5,10,-1,0,8,ch237data);
+
+/* char: 0xec */
+
+static final byte[] ch236data = {
+(byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x60,(byte) 0x0,(byte) 0x0,(byte) 0x20,(byte) 0x40,
+};
+
+static final BitmapCharRec ch236 = new BitmapCharRec(5,10,-1,0,8,ch236data);
+
+/* char: 0xeb */
+
+static final byte[] ch235data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x80,(byte) 0xfc,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x48,(byte) 0x48,
+};
+
+static final BitmapCharRec ch235 = new BitmapCharRec(6,10,-1,0,8,ch235data);
+
+/* char: 0xea */
+
+static final byte[] ch234data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x80,(byte) 0xfc,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x48,(byte) 0x30,
+};
+
+static final BitmapCharRec ch234 = new BitmapCharRec(6,10,-1,0,8,ch234data);
+
+/* char: 0xe9 */
+
+static final byte[] ch233data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x80,(byte) 0xfc,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x20,(byte) 0x10,
+};
+
+static final BitmapCharRec ch233 = new BitmapCharRec(6,10,-1,0,8,ch233data);
+
+/* char: 0xe8 */
+
+static final byte[] ch232data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x80,(byte) 0xfc,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x10,(byte) 0x20,
+};
+
+static final BitmapCharRec ch232 = new BitmapCharRec(6,10,-1,0,8,ch232data);
+
+/* char: 0xe7 */
+
+static final byte[] ch231data = {
+(byte) 0x20,(byte) 0x10,(byte) 0x78,(byte) 0x84,(byte) 0x80,(byte) 0x80,(byte) 0x84,(byte) 0x78,
+};
+
+static final BitmapCharRec ch231 = new BitmapCharRec(6,8,-1,2,8,ch231data);
+
+/* char: 0xe6 */
+
+static final byte[] ch230data = {
+(byte) 0x6c,(byte) 0x92,(byte) 0x90,(byte) 0x7c,(byte) 0x12,(byte) 0x6c,
+};
+
+static final BitmapCharRec ch230 = new BitmapCharRec(7,6,0,0,8,ch230data);
+
+/* char: 0xe5 */
+
+static final byte[] ch229data = {
+(byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x7c,(byte) 0x4,(byte) 0x78,(byte) 0x0,(byte) 0x30,(byte) 0x48,(byte) 0x30,
+};
+
+static final BitmapCharRec ch229 = new BitmapCharRec(6,10,-1,0,8,ch229data);
+
+/* char: 0xe4 */
+
+static final byte[] ch228data = {
+(byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x7c,(byte) 0x4,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x48,(byte) 0x48,
+};
+
+static final BitmapCharRec ch228 = new BitmapCharRec(6,10,-1,0,8,ch228data);
+
+/* char: 0xe3 */
+
+static final byte[] ch227data = {
+(byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x7c,(byte) 0x4,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x50,(byte) 0x28,
+};
+
+static final BitmapCharRec ch227 = new BitmapCharRec(6,10,-1,0,8,ch227data);
+
+/* char: 0xe2 */
+
+static final byte[] ch226data = {
+(byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x7c,(byte) 0x4,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x48,(byte) 0x30,
+};
+
+static final BitmapCharRec ch226 = new BitmapCharRec(6,10,-1,0,8,ch226data);
+
+/* char: 0xe1 */
+
+static final byte[] ch225data = {
+(byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x7c,(byte) 0x4,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x20,(byte) 0x10,
+};
+
+static final BitmapCharRec ch225 = new BitmapCharRec(6,10,-1,0,8,ch225data);
+
+/* char: 0xe0 */
+
+static final byte[] ch224data = {
+(byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x7c,(byte) 0x4,(byte) 0x78,(byte) 0x0,(byte) 0x0,(byte) 0x10,(byte) 0x20,
+};
+
+static final BitmapCharRec ch224 = new BitmapCharRec(6,10,-1,0,8,ch224data);
+
+/* char: 0xdf */
+
+static final byte[] ch223data = {
+(byte) 0x80,(byte) 0xb8,(byte) 0xc4,(byte) 0x84,(byte) 0x84,(byte) 0xf8,(byte) 0x84,(byte) 0x84,(byte) 0x78,
+};
+
+static final BitmapCharRec ch223 = new BitmapCharRec(6,9,-1,1,8,ch223data);
+
+/* char: 0xde */
+
+static final byte[] ch222data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xf8,(byte) 0x80,
+};
+
+static final BitmapCharRec ch222 = new BitmapCharRec(6,9,-1,0,8,ch222data);
+
+/* char: 0xdd */
+
+static final byte[] ch221data = {
+(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x50,(byte) 0x88,(byte) 0x88,(byte) 0x0,(byte) 0x20,(byte) 0x10,
+};
+
+static final BitmapCharRec ch221 = new BitmapCharRec(5,10,-1,0,8,ch221data);
+
+/* char: 0xdc */
+
+static final byte[] ch220data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x48,(byte) 0x48,
+};
+
+static final BitmapCharRec ch220 = new BitmapCharRec(6,10,-1,0,8,ch220data);
+
+/* char: 0xdb */
+
+static final byte[] ch219data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x48,(byte) 0x30,
+};
+
+static final BitmapCharRec ch219 = new BitmapCharRec(6,10,-1,0,8,ch219data);
+
+/* char: 0xda */
+
+static final byte[] ch218data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x20,(byte) 0x10,
+};
+
+static final BitmapCharRec ch218 = new BitmapCharRec(6,10,-1,0,8,ch218data);
+
+/* char: 0xd9 */
+
+static final byte[] ch217data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x10,(byte) 0x20,
+};
+
+static final BitmapCharRec ch217 = new BitmapCharRec(6,10,-1,0,8,ch217data);
+
+/* char: 0xd8 */
+
+static final byte[] ch216data = {
+(byte) 0x80,(byte) 0x78,(byte) 0xc4,(byte) 0xa4,(byte) 0xa4,(byte) 0xa4,(byte) 0x94,(byte) 0x94,(byte) 0x8c,(byte) 0x78,(byte) 0x4,
+};
+
+static final BitmapCharRec ch216 = new BitmapCharRec(6,11,-1,1,8,ch216data);
+
+/* char: 0xd7 */
+
+static final byte[] ch215data = {
+(byte) 0x84,(byte) 0x48,(byte) 0x30,(byte) 0x30,(byte) 0x48,(byte) 0x84,
+};
+
+static final BitmapCharRec ch215 = new BitmapCharRec(6,6,-1,-1,8,ch215data);
+
+/* char: 0xd6 */
+
+static final byte[] ch214data = {
+(byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x28,(byte) 0x28,
+};
+
+static final BitmapCharRec ch214 = new BitmapCharRec(7,10,0,0,8,ch214data);
+
+/* char: 0xd5 */
+
+static final byte[] ch213data = {
+(byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x28,(byte) 0x14,
+};
+
+static final BitmapCharRec ch213 = new BitmapCharRec(7,10,0,0,8,ch213data);
+
+/* char: 0xd4 */
+
+static final byte[] ch212data = {
+(byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x24,(byte) 0x18,
+};
+
+static final BitmapCharRec ch212 = new BitmapCharRec(7,10,0,0,8,ch212data);
+
+/* char: 0xd3 */
+
+static final byte[] ch211data = {
+(byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x10,(byte) 0x8,
+};
+
+static final BitmapCharRec ch211 = new BitmapCharRec(7,10,0,0,8,ch211data);
+
+/* char: 0xd2 */
+
+static final byte[] ch210data = {
+(byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x8,(byte) 0x10,
+};
+
+static final BitmapCharRec ch210 = new BitmapCharRec(7,10,0,0,8,ch210data);
+
+/* char: 0xd1 */
+
+static final byte[] ch209data = {
+(byte) 0x82,(byte) 0x86,(byte) 0x8a,(byte) 0x92,(byte) 0xa2,(byte) 0xc2,(byte) 0x82,(byte) 0x0,(byte) 0x28,(byte) 0x14,
+};
+
+static final BitmapCharRec ch209 = new BitmapCharRec(7,10,0,0,8,ch209data);
+
+/* char: 0xd0 */
+
+static final byte[] ch208data = {
+(byte) 0xfc,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0xe2,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0xfc,
+};
+
+static final BitmapCharRec ch208 = new BitmapCharRec(7,9,0,0,8,ch208data);
+
+/* char: 0xcf */
+
+static final byte[] ch207data = {
+(byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x0,(byte) 0x50,(byte) 0x50,
+};
+
+static final BitmapCharRec ch207 = new BitmapCharRec(5,10,-1,0,8,ch207data);
+
+/* char: 0xce */
+
+static final byte[] ch206data = {
+(byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x0,(byte) 0x48,(byte) 0x30,
+};
+
+static final BitmapCharRec ch206 = new BitmapCharRec(5,10,-1,0,8,ch206data);
+
+/* char: 0xcd */
+
+static final byte[] ch205data = {
+(byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x0,(byte) 0x20,(byte) 0x10,
+};
+
+static final BitmapCharRec ch205 = new BitmapCharRec(5,10,-1,0,8,ch205data);
+
+/* char: 0xcc */
+
+static final byte[] ch204data = {
+(byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x0,(byte) 0x10,(byte) 0x20,
+};
+
+static final BitmapCharRec ch204 = new BitmapCharRec(5,10,-1,0,8,ch204data);
+
+/* char: 0xcb */
+
+static final byte[] ch203data = {
+(byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0xf0,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x0,(byte) 0x48,(byte) 0x48,
+};
+
+static final BitmapCharRec ch203 = new BitmapCharRec(6,10,-1,0,8,ch203data);
+
+/* char: 0xca */
+
+static final byte[] ch202data = {
+(byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0xf0,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x0,(byte) 0x48,(byte) 0x30,
+};
+
+static final BitmapCharRec ch202 = new BitmapCharRec(6,10,-1,0,8,ch202data);
+
+/* char: 0xc9 */
+
+static final byte[] ch201data = {
+(byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0xf0,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x0,(byte) 0x20,(byte) 0x10,
+};
+
+static final BitmapCharRec ch201 = new BitmapCharRec(6,10,-1,0,8,ch201data);
+
+/* char: 0xc8 */
+
+static final byte[] ch200data = {
+(byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0xf0,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x0,(byte) 0x10,(byte) 0x20,
+};
+
+static final BitmapCharRec ch200 = new BitmapCharRec(6,10,-1,0,8,ch200data);
+
+/* char: 0xc7 */
+
+static final byte[] ch199data = {
+(byte) 0x20,(byte) 0x10,(byte) 0x78,(byte) 0x84,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x84,(byte) 0x78,
+};
+
+static final BitmapCharRec ch199 = new BitmapCharRec(6,11,-1,2,8,ch199data);
+
+/* char: 0xc6 */
+
+static final byte[] ch198data = {
+(byte) 0x9e,(byte) 0x90,(byte) 0x90,(byte) 0xf0,(byte) 0x9c,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x6e,
+};
+
+static final BitmapCharRec ch198 = new BitmapCharRec(7,9,0,0,8,ch198data);
+
+/* char: 0xc5 */
+
+static final byte[] ch197data = {
+(byte) 0x84,(byte) 0x84,(byte) 0xfc,(byte) 0x84,(byte) 0x84,(byte) 0x48,(byte) 0x30,(byte) 0x30,(byte) 0x48,(byte) 0x30,
+};
+
+static final BitmapCharRec ch197 = new BitmapCharRec(6,10,-1,0,8,ch197data);
+
+/* char: 0xc4 */
+
+static final byte[] ch196data = {
+(byte) 0x84,(byte) 0x84,(byte) 0xfc,(byte) 0x84,(byte) 0x84,(byte) 0x48,(byte) 0x30,(byte) 0x0,(byte) 0x48,(byte) 0x48,
+};
+
+static final BitmapCharRec ch196 = new BitmapCharRec(6,10,-1,0,8,ch196data);
+
+/* char: 0xc3 */
+
+static final byte[] ch195data = {
+(byte) 0x84,(byte) 0x84,(byte) 0xfc,(byte) 0x84,(byte) 0x84,(byte) 0x48,(byte) 0x30,(byte) 0x0,(byte) 0x50,(byte) 0x28,
+};
+
+static final BitmapCharRec ch195 = new BitmapCharRec(6,10,-1,0,8,ch195data);
+
+/* char: 0xc2 */
+
+static final byte[] ch194data = {
+(byte) 0x84,(byte) 0x84,(byte) 0xfc,(byte) 0x84,(byte) 0x84,(byte) 0x48,(byte) 0x30,(byte) 0x0,(byte) 0x48,(byte) 0x30,
+};
+
+static final BitmapCharRec ch194 = new BitmapCharRec(6,10,-1,0,8,ch194data);
+
+/* char: 0xc1 */
+
+static final byte[] ch193data = {
+(byte) 0x84,(byte) 0x84,(byte) 0xfc,(byte) 0x84,(byte) 0x84,(byte) 0x48,(byte) 0x30,(byte) 0x0,(byte) 0x20,(byte) 0x10,
+};
+
+static final BitmapCharRec ch193 = new BitmapCharRec(6,10,-1,0,8,ch193data);
+
+/* char: 0xc0 */
+
+static final byte[] ch192data = {
+(byte) 0x84,(byte) 0x84,(byte) 0xfc,(byte) 0x84,(byte) 0x84,(byte) 0x48,(byte) 0x30,(byte) 0x0,(byte) 0x10,(byte) 0x20,
+};
+
+static final BitmapCharRec ch192 = new BitmapCharRec(6,10,-1,0,8,ch192data);
+
+/* char: 0xbf */
+
+static final byte[] ch191data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x0,(byte) 0x20,
+};
+
+static final BitmapCharRec ch191 = new BitmapCharRec(6,9,-1,0,8,ch191data);
+
+/* char: 0xbe */
+
+static final byte[] ch190data = {
+(byte) 0x6,(byte) 0x1a,(byte) 0x12,(byte) 0xa,(byte) 0x66,(byte) 0x92,(byte) 0x10,(byte) 0x20,(byte) 0x90,(byte) 0x60,
+};
+
+static final BitmapCharRec ch190 = new BitmapCharRec(7,10,0,0,8,ch190data);
+
+/* char: 0xbd */
+
+static final byte[] ch189data = {
+(byte) 0x1e,(byte) 0x10,(byte) 0xc,(byte) 0x2,(byte) 0xf2,(byte) 0x4c,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x40,
+};
+
+static final BitmapCharRec ch189 = new BitmapCharRec(7,10,0,0,8,ch189data);
+
+/* char: 0xbc */
+
+static final byte[] ch188data = {
+(byte) 0x6,(byte) 0x1a,(byte) 0x12,(byte) 0xa,(byte) 0xe6,(byte) 0x42,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x40,
+};
+
+static final BitmapCharRec ch188 = new BitmapCharRec(7,10,0,0,8,ch188data);
+
+/* char: 0xbb */
+
+static final byte[] ch187data = {
+(byte) 0x90,(byte) 0x48,(byte) 0x24,(byte) 0x12,(byte) 0x24,(byte) 0x48,(byte) 0x90,
+};
+
+static final BitmapCharRec ch187 = new BitmapCharRec(7,7,0,-1,8,ch187data);
+
+/* char: 0xba */
+
+static final byte[] ch186data = {
+(byte) 0xf0,(byte) 0x0,(byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x60,
+};
+
+static final BitmapCharRec ch186 = new BitmapCharRec(4,6,-1,-3,8,ch186data);
+
+/* char: 0xb9 */
+
+static final byte[] ch185data = {
+(byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x40,
+};
+
+static final BitmapCharRec ch185 = new BitmapCharRec(3,6,-1,-4,8,ch185data);
+
+/* char: 0xb8 */
+
+static final byte[] ch184data = {
+(byte) 0xc0,(byte) 0x40,
+};
+
+static final BitmapCharRec ch184 = new BitmapCharRec(2,2,-3,2,8,ch184data);
+
+/* char: 0xb7 */
+
+static final byte[] ch183data = {
+(byte) 0xc0,
+};
+
+static final BitmapCharRec ch183 = new BitmapCharRec(2,1,-3,-4,8,ch183data);
+
+/* char: 0xb6 */
+
+static final byte[] ch182data = {
+(byte) 0x28,(byte) 0x28,(byte) 0x28,(byte) 0x28,(byte) 0x68,(byte) 0xe8,(byte) 0xe8,(byte) 0xe8,(byte) 0x7c,
+};
+
+static final BitmapCharRec ch182 = new BitmapCharRec(6,9,-1,0,8,ch182data);
+
+/* char: 0xb5 */
+
+static final byte[] ch181data = {
+(byte) 0x80,(byte) 0xb4,(byte) 0xcc,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,
+};
+
+static final BitmapCharRec ch181 = new BitmapCharRec(6,7,-1,1,8,ch181data);
+
+/* char: 0xb4 */
+
+static final byte[] ch180data = {
+(byte) 0x80,(byte) 0x40,
+};
+
+static final BitmapCharRec ch180 = new BitmapCharRec(2,2,-3,-8,8,ch180data);
+
+/* char: 0xb3 */
+
+static final byte[] ch179data = {
+(byte) 0x60,(byte) 0x90,(byte) 0x10,(byte) 0x20,(byte) 0x90,(byte) 0x60,
+};
+
+static final BitmapCharRec ch179 = new BitmapCharRec(4,6,-1,-4,8,ch179data);
+
+/* char: 0xb2 */
+
+static final byte[] ch178data = {
+(byte) 0xf0,(byte) 0x80,(byte) 0x60,(byte) 0x10,(byte) 0x90,(byte) 0x60,
+};
+
+static final BitmapCharRec ch178 = new BitmapCharRec(4,6,-1,-4,8,ch178data);
+
+/* char: 0xb1 */
+
+static final byte[] ch177data = {
+(byte) 0xf8,(byte) 0x0,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0x20,
+};
+
+static final BitmapCharRec ch177 = new BitmapCharRec(5,7,-1,-1,8,ch177data);
+
+/* char: 0xb0 */
+
+static final byte[] ch176data = {
+(byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x60,
+};
+
+static final BitmapCharRec ch176 = new BitmapCharRec(4,4,-2,-5,8,ch176data);
+
+/* char: 0xaf */
+
+static final byte[] ch175data = {
+(byte) 0xfc,
+};
+
+static final BitmapCharRec ch175 = new BitmapCharRec(6,1,-1,-8,8,ch175data);
+
+/* char: 0xae */
+
+static final byte[] ch174data = {
+(byte) 0x38,(byte) 0x44,(byte) 0xaa,(byte) 0xb2,(byte) 0xaa,(byte) 0xaa,(byte) 0x92,(byte) 0x44,(byte) 0x38,
+};
+
+static final BitmapCharRec ch174 = new BitmapCharRec(7,9,0,-1,8,ch174data);
+
+/* char: 0xad */
+
+static final byte[] ch173data = {
+(byte) 0xfc,
+};
+
+static final BitmapCharRec ch173 = new BitmapCharRec(6,1,-1,-4,8,ch173data);
+
+/* char: 0xac */
+
+static final byte[] ch172data = {
+(byte) 0x4,(byte) 0x4,(byte) 0x4,(byte) 0xfc,
+};
+
+static final BitmapCharRec ch172 = new BitmapCharRec(6,4,-1,-1,8,ch172data);
+
+/* char: 0xab */
+
+static final byte[] ch171data = {
+(byte) 0x12,(byte) 0x24,(byte) 0x48,(byte) 0x90,(byte) 0x48,(byte) 0x24,(byte) 0x12,
+};
+
+static final BitmapCharRec ch171 = new BitmapCharRec(7,7,0,-1,8,ch171data);
+
+/* char: 0xaa */
+
+static final byte[] ch170data = {
+(byte) 0xf8,(byte) 0x0,(byte) 0x78,(byte) 0x88,(byte) 0x78,(byte) 0x8,(byte) 0x70,
+};
+
+static final BitmapCharRec ch170 = new BitmapCharRec(5,7,-1,-2,8,ch170data);
+
+/* char: 0xa9 */
+
+static final byte[] ch169data = {
+(byte) 0x38,(byte) 0x44,(byte) 0x92,(byte) 0xaa,(byte) 0xa2,(byte) 0xaa,(byte) 0x92,(byte) 0x44,(byte) 0x38,
+};
+
+static final BitmapCharRec ch169 = new BitmapCharRec(7,9,0,-1,8,ch169data);
+
+/* char: 0xa8 */
+
+static final byte[] ch168data = {
+(byte) 0xd8,
+};
+
+static final BitmapCharRec ch168 = new BitmapCharRec(5,1,-1,-8,8,ch168data);
+
+/* char: 0xa7 */
+
+static final byte[] ch167data = {
+(byte) 0x60,(byte) 0x90,(byte) 0x10,(byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x60,(byte) 0x80,(byte) 0x90,(byte) 0x60,
+};
+
+static final BitmapCharRec ch167 = new BitmapCharRec(4,10,-2,0,8,ch167data);
+
+/* char: 0xa6 */
+
+static final byte[] ch166data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch166 = new BitmapCharRec(1,9,-3,0,8,ch166data);
+
+/* char: 0xa5 */
+
+static final byte[] ch165data = {
+(byte) 0x10,(byte) 0x10,(byte) 0x7c,(byte) 0x10,(byte) 0x7c,(byte) 0x28,(byte) 0x44,(byte) 0x82,(byte) 0x82,
+};
+
+static final BitmapCharRec ch165 = new BitmapCharRec(7,9,0,0,8,ch165data);
+
+/* char: 0xa4 */
+
+static final byte[] ch164data = {
+(byte) 0x84,(byte) 0x78,(byte) 0x48,(byte) 0x48,(byte) 0x78,(byte) 0x84,
+};
+
+static final BitmapCharRec ch164 = new BitmapCharRec(6,6,-1,-1,8,ch164data);
+
+/* char: 0xa3 */
+
+static final byte[] ch163data = {
+(byte) 0xdc,(byte) 0x62,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x70,(byte) 0x20,(byte) 0x22,(byte) 0x1c,
+};
+
+static final BitmapCharRec ch163 = new BitmapCharRec(7,9,0,0,8,ch163data);
+
+/* char: 0xa2 */
+
+static final byte[] ch162data = {
+(byte) 0x20,(byte) 0x70,(byte) 0xa8,(byte) 0xa0,(byte) 0xa0,(byte) 0xa8,(byte) 0x70,(byte) 0x20,
+};
+
+static final BitmapCharRec ch162 = new BitmapCharRec(5,8,-1,-1,8,ch162data);
+
+/* char: 0xa1 */
+
+static final byte[] ch161data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80,
+};
+
+static final BitmapCharRec ch161 = new BitmapCharRec(1,9,-3,0,8,ch161data);
+
+/* char: 0x7e '~' */
+
+static final byte[] ch126data = {
+(byte) 0x90,(byte) 0xa8,(byte) 0x48,
+};
+
+static final BitmapCharRec ch126 = new BitmapCharRec(5,3,-1,-6,8,ch126data);
+
+/* char: 0x7d '}' */
+
+static final byte[] ch125data = {
+(byte) 0xe0,(byte) 0x10,(byte) 0x10,(byte) 0x20,(byte) 0x18,(byte) 0x20,(byte) 0x10,(byte) 0x10,(byte) 0xe0,
+};
+
+static final BitmapCharRec ch125 = new BitmapCharRec(5,9,-1,0,8,ch125data);
+
+/* char: 0x7c '|' */
+
+static final byte[] ch124data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch124 = new BitmapCharRec(1,9,-3,0,8,ch124data);
+
+/* char: 0x7b '{' */
+
+static final byte[] ch123data = {
+(byte) 0x38,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0xc0,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x38,
+};
+
+static final BitmapCharRec ch123 = new BitmapCharRec(5,9,-2,0,8,ch123data);
+
+/* char: 0x7a 'z' */
+
+static final byte[] ch122data = {
+(byte) 0xfc,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x8,(byte) 0xfc,
+};
+
+static final BitmapCharRec ch122 = new BitmapCharRec(6,6,-1,0,8,ch122data);
+
+/* char: 0x79 'y' */
+
+static final byte[] ch121data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x4,(byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x84,(byte) 0x84,
+};
+
+static final BitmapCharRec ch121 = new BitmapCharRec(6,8,-1,2,8,ch121data);
+
+/* char: 0x78 'x' */
+
+static final byte[] ch120data = {
+(byte) 0x84,(byte) 0x48,(byte) 0x30,(byte) 0x30,(byte) 0x48,(byte) 0x84,
+};
+
+static final BitmapCharRec ch120 = new BitmapCharRec(6,6,-1,0,8,ch120data);
+
+/* char: 0x77 'w' */
+
+static final byte[] ch119data = {
+(byte) 0x44,(byte) 0xaa,(byte) 0x92,(byte) 0x92,(byte) 0x82,(byte) 0x82,
+};
+
+static final BitmapCharRec ch119 = new BitmapCharRec(7,6,0,0,8,ch119data);
+
+/* char: 0x76 'v' */
+
+static final byte[] ch118data = {
+(byte) 0x20,(byte) 0x50,(byte) 0x50,(byte) 0x88,(byte) 0x88,(byte) 0x88,
+};
+
+static final BitmapCharRec ch118 = new BitmapCharRec(5,6,-1,0,8,ch118data);
+
+/* char: 0x75 'u' */
+
+static final byte[] ch117data = {
+(byte) 0x74,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,
+};
+
+static final BitmapCharRec ch117 = new BitmapCharRec(6,6,-1,0,8,ch117data);
+
+/* char: 0x74 't' */
+
+static final byte[] ch116data = {
+(byte) 0x38,(byte) 0x44,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xf8,(byte) 0x40,(byte) 0x40,
+};
+
+static final BitmapCharRec ch116 = new BitmapCharRec(6,8,-1,0,8,ch116data);
+
+/* char: 0x73 's' */
+
+static final byte[] ch115data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x18,(byte) 0x60,(byte) 0x84,(byte) 0x78,
+};
+
+static final BitmapCharRec ch115 = new BitmapCharRec(6,6,-1,0,8,ch115data);
+
+/* char: 0x72 'r' */
+
+static final byte[] ch114data = {
+(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x44,(byte) 0xb8,
+};
+
+static final BitmapCharRec ch114 = new BitmapCharRec(6,6,-1,0,8,ch114data);
+
+/* char: 0x71 'q' */
+
+static final byte[] ch113data = {
+(byte) 0x4,(byte) 0x4,(byte) 0x4,(byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x8c,(byte) 0x74,
+};
+
+static final BitmapCharRec ch113 = new BitmapCharRec(6,8,-1,2,8,ch113data);
+
+/* char: 0x70 'p' */
+
+static final byte[] ch112data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xb8,(byte) 0xc4,(byte) 0x84,(byte) 0xc4,(byte) 0xb8,
+};
+
+static final BitmapCharRec ch112 = new BitmapCharRec(6,8,-1,2,8,ch112data);
+
+/* char: 0x6f 'o' */
+
+static final byte[] ch111data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,
+};
+
+static final BitmapCharRec ch111 = new BitmapCharRec(6,6,-1,0,8,ch111data);
+
+/* char: 0x6e 'n' */
+
+static final byte[] ch110data = {
+(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xc4,(byte) 0xb8,
+};
+
+static final BitmapCharRec ch110 = new BitmapCharRec(6,6,-1,0,8,ch110data);
+
+/* char: 0x6d 'm' */
+
+static final byte[] ch109data = {
+(byte) 0x82,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0xec,
+};
+
+static final BitmapCharRec ch109 = new BitmapCharRec(7,6,0,0,8,ch109data);
+
+/* char: 0x6c 'l' */
+
+static final byte[] ch108data = {
+(byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x60,
+};
+
+static final BitmapCharRec ch108 = new BitmapCharRec(5,9,-1,0,8,ch108data);
+
+/* char: 0x6b 'k' */
+
+static final byte[] ch107data = {
+(byte) 0x84,(byte) 0x88,(byte) 0x90,(byte) 0xe0,(byte) 0x90,(byte) 0x88,(byte) 0x80,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch107 = new BitmapCharRec(6,9,-1,0,8,ch107data);
+
+/* char: 0x6a 'j' */
+
+static final byte[] ch106data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x18,(byte) 0x0,(byte) 0x8,
+};
+
+static final BitmapCharRec ch106 = new BitmapCharRec(5,10,-1,2,8,ch106data);
+
+/* char: 0x69 'i' */
+
+static final byte[] ch105data = {
+(byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x60,(byte) 0x0,(byte) 0x20,
+};
+
+static final BitmapCharRec ch105 = new BitmapCharRec(5,8,-1,0,8,ch105data);
+
+/* char: 0x68 'h' */
+
+static final byte[] ch104data = {
+(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xc4,(byte) 0xb8,(byte) 0x80,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch104 = new BitmapCharRec(6,9,-1,0,8,ch104data);
+
+/* char: 0x67 'g' */
+
+static final byte[] ch103data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x78,(byte) 0x80,(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x74,
+};
+
+static final BitmapCharRec ch103 = new BitmapCharRec(6,8,-1,2,8,ch103data);
+
+/* char: 0x66 'f' */
+
+static final byte[] ch102data = {
+(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xf8,(byte) 0x40,(byte) 0x40,(byte) 0x44,(byte) 0x38,
+};
+
+static final BitmapCharRec ch102 = new BitmapCharRec(6,9,-1,0,8,ch102data);
+
+/* char: 0x65 'e' */
+
+static final byte[] ch101data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x80,(byte) 0xfc,(byte) 0x84,(byte) 0x78,
+};
+
+static final BitmapCharRec ch101 = new BitmapCharRec(6,6,-1,0,8,ch101data);
+
+/* char: 0x64 'd' */
+
+static final byte[] ch100data = {
+(byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x84,(byte) 0x8c,(byte) 0x74,(byte) 0x4,(byte) 0x4,(byte) 0x4,
+};
+
+static final BitmapCharRec ch100 = new BitmapCharRec(6,9,-1,0,8,ch100data);
+
+/* char: 0x63 'c' */
+
+static final byte[] ch99data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x80,(byte) 0x80,(byte) 0x84,(byte) 0x78,
+};
+
+static final BitmapCharRec ch99 = new BitmapCharRec(6,6,-1,0,8,ch99data);
+
+/* char: 0x62 'b' */
+
+static final byte[] ch98data = {
+(byte) 0xb8,(byte) 0xc4,(byte) 0x84,(byte) 0x84,(byte) 0xc4,(byte) 0xb8,(byte) 0x80,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch98 = new BitmapCharRec(6,9,-1,0,8,ch98data);
+
+/* char: 0x61 'a' */
+
+static final byte[] ch97data = {
+(byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x7c,(byte) 0x4,(byte) 0x78,
+};
+
+static final BitmapCharRec ch97 = new BitmapCharRec(6,6,-1,0,8,ch97data);
+
+/* char: 0x60 '`' */
+
+static final byte[] ch96data = {
+(byte) 0x10,(byte) 0x60,(byte) 0xe0,
+};
+
+static final BitmapCharRec ch96 = new BitmapCharRec(4,3,-2,-6,8,ch96data);
+
+/* char: 0x5f '_' */
+
+static final byte[] ch95data = {
+(byte) 0xfe,
+};
+
+static final BitmapCharRec ch95 = new BitmapCharRec(7,1,0,1,8,ch95data);
+
+/* char: 0x5e '^' */
+
+static final byte[] ch94data = {
+(byte) 0x88,(byte) 0x50,(byte) 0x20,
+};
+
+static final BitmapCharRec ch94 = new BitmapCharRec(5,3,-1,-6,8,ch94data);
+
+/* char: 0x5d ']' */
+
+static final byte[] ch93data = {
+(byte) 0xf0,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0xf0,
+};
+
+static final BitmapCharRec ch93 = new BitmapCharRec(4,9,-1,0,8,ch93data);
+
+/* char: 0x5c '\' */
+
+static final byte[] ch92data = {
+(byte) 0x2,(byte) 0x2,(byte) 0x4,(byte) 0x8,(byte) 0x10,(byte) 0x20,(byte) 0x40,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch92 = new BitmapCharRec(7,9,0,0,8,ch92data);
+
+/* char: 0x5b '[' */
+
+static final byte[] ch91data = {
+(byte) 0xf0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf0,
+};
+
+static final BitmapCharRec ch91 = new BitmapCharRec(4,9,-2,0,8,ch91data);
+
+/* char: 0x5a 'Z' */
+
+static final byte[] ch90data = {
+(byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x8,(byte) 0x4,(byte) 0xfc,
+};
+
+static final BitmapCharRec ch90 = new BitmapCharRec(6,9,-1,0,8,ch90data);
+
+/* char: 0x59 'Y' */
+
+static final byte[] ch89data = {
+(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x44,(byte) 0x82,(byte) 0x82,
+};
+
+static final BitmapCharRec ch89 = new BitmapCharRec(7,9,0,0,8,ch89data);
+
+/* char: 0x58 'X' */
+
+static final byte[] ch88data = {
+(byte) 0x82,(byte) 0x82,(byte) 0x44,(byte) 0x28,(byte) 0x10,(byte) 0x28,(byte) 0x44,(byte) 0x82,(byte) 0x82,
+};
+
+static final BitmapCharRec ch88 = new BitmapCharRec(7,9,0,0,8,ch88data);
+
+/* char: 0x57 'W' */
+
+static final byte[] ch87data = {
+(byte) 0x44,(byte) 0xaa,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,
+};
+
+static final BitmapCharRec ch87 = new BitmapCharRec(7,9,0,0,8,ch87data);
+
+/* char: 0x56 'V' */
+
+static final byte[] ch86data = {
+(byte) 0x10,(byte) 0x28,(byte) 0x28,(byte) 0x28,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0x82,(byte) 0x82,
+};
+
+static final BitmapCharRec ch86 = new BitmapCharRec(7,9,0,0,8,ch86data);
+
+/* char: 0x55 'U' */
+
+static final byte[] ch85data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,
+};
+
+static final BitmapCharRec ch85 = new BitmapCharRec(6,9,-1,0,8,ch85data);
+
+/* char: 0x54 'T' */
+
+static final byte[] ch84data = {
+(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0xfe,
+};
+
+static final BitmapCharRec ch84 = new BitmapCharRec(7,9,0,0,8,ch84data);
+
+/* char: 0x53 'S' */
+
+static final byte[] ch83data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x4,(byte) 0x4,(byte) 0x78,(byte) 0x80,(byte) 0x80,(byte) 0x84,(byte) 0x78,
+};
+
+static final BitmapCharRec ch83 = new BitmapCharRec(6,9,-1,0,8,ch83data);
+
+/* char: 0x52 'R' */
+
+static final byte[] ch82data = {
+(byte) 0x84,(byte) 0x88,(byte) 0x90,(byte) 0xa0,(byte) 0xf8,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xf8,
+};
+
+static final BitmapCharRec ch82 = new BitmapCharRec(6,9,-1,0,8,ch82data);
+
+/* char: 0x51 'Q' */
+
+static final byte[] ch81data = {
+(byte) 0x4,(byte) 0x78,(byte) 0x94,(byte) 0xa4,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,
+};
+
+static final BitmapCharRec ch81 = new BitmapCharRec(6,10,-1,1,8,ch81data);
+
+/* char: 0x50 'P' */
+
+static final byte[] ch80data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xf8,
+};
+
+static final BitmapCharRec ch80 = new BitmapCharRec(6,9,-1,0,8,ch80data);
+
+/* char: 0x4f 'O' */
+
+static final byte[] ch79data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,
+};
+
+static final BitmapCharRec ch79 = new BitmapCharRec(6,9,-1,0,8,ch79data);
+
+/* char: 0x4e 'N' */
+
+static final byte[] ch78data = {
+(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x8c,(byte) 0x94,(byte) 0xa4,(byte) 0xc4,(byte) 0x84,(byte) 0x84,
+};
+
+static final BitmapCharRec ch78 = new BitmapCharRec(6,9,-1,0,8,ch78data);
+
+/* char: 0x4d 'M' */
+
+static final byte[] ch77data = {
+(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x92,(byte) 0x92,(byte) 0xaa,(byte) 0xc6,(byte) 0x82,(byte) 0x82,
+};
+
+static final BitmapCharRec ch77 = new BitmapCharRec(7,9,0,0,8,ch77data);
+
+/* char: 0x4c 'L' */
+
+static final byte[] ch76data = {
+(byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch76 = new BitmapCharRec(6,9,-1,0,8,ch76data);
+
+/* char: 0x4b 'K' */
+
+static final byte[] ch75data = {
+(byte) 0x84,(byte) 0x88,(byte) 0x90,(byte) 0xa0,(byte) 0xc0,(byte) 0xa0,(byte) 0x90,(byte) 0x88,(byte) 0x84,
+};
+
+static final BitmapCharRec ch75 = new BitmapCharRec(6,9,-1,0,8,ch75data);
+
+/* char: 0x4a 'J' */
+
+static final byte[] ch74data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x3c,
+};
+
+static final BitmapCharRec ch74 = new BitmapCharRec(6,9,-1,0,8,ch74data);
+
+/* char: 0x49 'I' */
+
+static final byte[] ch73data = {
+(byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xf8,
+};
+
+static final BitmapCharRec ch73 = new BitmapCharRec(5,9,-1,0,8,ch73data);
+
+/* char: 0x48 'H' */
+
+static final byte[] ch72data = {
+(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xfc,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,
+};
+
+static final BitmapCharRec ch72 = new BitmapCharRec(6,9,-1,0,8,ch72data);
+
+/* char: 0x47 'G' */
+
+static final byte[] ch71data = {
+(byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x9c,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x84,(byte) 0x78,
+};
+
+static final BitmapCharRec ch71 = new BitmapCharRec(6,9,-1,0,8,ch71data);
+
+/* char: 0x46 'F' */
+
+static final byte[] ch70data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc,
+};
+
+static final BitmapCharRec ch70 = new BitmapCharRec(6,9,-1,0,8,ch70data);
+
+/* char: 0x45 'E' */
+
+static final byte[] ch69data = {
+(byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc,
+};
+
+static final BitmapCharRec ch69 = new BitmapCharRec(6,9,-1,0,8,ch69data);
+
+/* char: 0x44 'D' */
+
+static final byte[] ch68data = {
+(byte) 0xfc,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0xfc,
+};
+
+static final BitmapCharRec ch68 = new BitmapCharRec(7,9,0,0,8,ch68data);
+
+/* char: 0x43 'C' */
+
+static final byte[] ch67data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x84,(byte) 0x78,
+};
+
+static final BitmapCharRec ch67 = new BitmapCharRec(6,9,-1,0,8,ch67data);
+
+/* char: 0x42 'B' */
+
+static final byte[] ch66data = {
+(byte) 0xfc,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0x7c,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0xfc,
+};
+
+static final BitmapCharRec ch66 = new BitmapCharRec(7,9,0,0,8,ch66data);
+
+/* char: 0x41 'A' */
+
+static final byte[] ch65data = {
+(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xfc,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x48,(byte) 0x30,
+};
+
+static final BitmapCharRec ch65 = new BitmapCharRec(6,9,-1,0,8,ch65data);
+
+/* char: 0x40 '@' */
+
+static final byte[] ch64data = {
+(byte) 0x78,(byte) 0x80,(byte) 0x94,(byte) 0xac,(byte) 0xa4,(byte) 0x9c,(byte) 0x84,(byte) 0x84,(byte) 0x78,
+};
+
+static final BitmapCharRec ch64 = new BitmapCharRec(6,9,-1,0,8,ch64data);
+
+/* char: 0x3f '?' */
+
+static final byte[] ch63data = {
+(byte) 0x10,(byte) 0x0,(byte) 0x10,(byte) 0x10,(byte) 0x8,(byte) 0x4,(byte) 0x84,(byte) 0x84,(byte) 0x78,
+};
+
+static final BitmapCharRec ch63 = new BitmapCharRec(6,9,-1,0,8,ch63data);
+
+/* char: 0x3e '>' */
+
+static final byte[] ch62data = {
+(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x8,(byte) 0x10,(byte) 0x20,(byte) 0x40,(byte) 0x80,
+};
+
+static final BitmapCharRec ch62 = new BitmapCharRec(5,9,-1,0,8,ch62data);
+
+/* char: 0x3d '=' */
+
+static final byte[] ch61data = {
+(byte) 0xfc,(byte) 0x0,(byte) 0x0,(byte) 0xfc,
+};
+
+static final BitmapCharRec ch61 = new BitmapCharRec(6,4,-1,-2,8,ch61data);
+
+/* char: 0x3c '<' */
+
+static final byte[] ch60data = {
+(byte) 0x8,(byte) 0x10,(byte) 0x20,(byte) 0x40,(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x8,
+};
+
+static final BitmapCharRec ch60 = new BitmapCharRec(5,9,-2,0,8,ch60data);
+
+/* char: 0x3b ';' */
+
+static final byte[] ch59data = {
+(byte) 0x80,(byte) 0x60,(byte) 0x70,(byte) 0x0,(byte) 0x0,(byte) 0x20,(byte) 0x70,(byte) 0x20,
+};
+
+static final BitmapCharRec ch59 = new BitmapCharRec(4,8,-1,1,8,ch59data);
+
+/* char: 0x3a ':' */
+
+static final byte[] ch58data = {
+(byte) 0x40,(byte) 0xe0,(byte) 0x40,(byte) 0x0,(byte) 0x0,(byte) 0x40,(byte) 0xe0,(byte) 0x40,
+};
+
+static final BitmapCharRec ch58 = new BitmapCharRec(3,8,-2,1,8,ch58data);
+
+/* char: 0x39 '9' */
+
+static final byte[] ch57data = {
+(byte) 0x70,(byte) 0x8,(byte) 0x4,(byte) 0x4,(byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x84,(byte) 0x78,
+};
+
+static final BitmapCharRec ch57 = new BitmapCharRec(6,9,-1,0,8,ch57data);
+
+/* char: 0x38 '8' */
+
+static final byte[] ch56data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,
+};
+
+static final BitmapCharRec ch56 = new BitmapCharRec(6,9,-1,0,8,ch56data);
+
+/* char: 0x37 '7' */
+
+static final byte[] ch55data = {
+(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x10,(byte) 0x10,(byte) 0x8,(byte) 0x4,(byte) 0xfc,
+};
+
+static final BitmapCharRec ch55 = new BitmapCharRec(6,9,-1,0,8,ch55data);
+
+/* char: 0x36 '6' */
+
+static final byte[] ch54data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0xc4,(byte) 0xb8,(byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x38,
+};
+
+static final BitmapCharRec ch54 = new BitmapCharRec(6,9,-1,0,8,ch54data);
+
+/* char: 0x35 '5' */
+
+static final byte[] ch53data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x4,(byte) 0x4,(byte) 0xc4,(byte) 0xb8,(byte) 0x80,(byte) 0x80,(byte) 0xfc,
+};
+
+static final BitmapCharRec ch53 = new BitmapCharRec(6,9,-1,0,8,ch53data);
+
+/* char: 0x34 '4' */
+
+static final byte[] ch52data = {
+(byte) 0x8,(byte) 0x8,(byte) 0xfc,(byte) 0x88,(byte) 0x88,(byte) 0x48,(byte) 0x28,(byte) 0x18,(byte) 0x8,
+};
+
+static final BitmapCharRec ch52 = new BitmapCharRec(6,9,-1,0,8,ch52data);
+
+/* char: 0x33 '3' */
+
+static final byte[] ch51data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x4,(byte) 0x4,(byte) 0x38,(byte) 0x10,(byte) 0x8,(byte) 0x4,(byte) 0xfc,
+};
+
+static final BitmapCharRec ch51 = new BitmapCharRec(6,9,-1,0,8,ch51data);
+
+/* char: 0x32 '2' */
+
+static final byte[] ch50data = {
+(byte) 0xfc,(byte) 0x80,(byte) 0x40,(byte) 0x30,(byte) 0x8,(byte) 0x4,(byte) 0x84,(byte) 0x84,(byte) 0x78,
+};
+
+static final BitmapCharRec ch50 = new BitmapCharRec(6,9,-1,0,8,ch50data);
+
+/* char: 0x31 '1' */
+
+static final byte[] ch49data = {
+(byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xa0,(byte) 0x60,(byte) 0x20,
+};
+
+static final BitmapCharRec ch49 = new BitmapCharRec(5,9,-1,0,8,ch49data);
+
+/* char: 0x30 '0' */
+
+static final byte[] ch48data = {
+(byte) 0x30,(byte) 0x48,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x48,(byte) 0x30,
+};
+
+static final BitmapCharRec ch48 = new BitmapCharRec(6,9,-1,0,8,ch48data);
+
+/* char: 0x2f '/' */
+
+static final byte[] ch47data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x8,(byte) 0x4,(byte) 0x2,(byte) 0x2,
+};
+
+static final BitmapCharRec ch47 = new BitmapCharRec(7,9,0,0,8,ch47data);
+
+/* char: 0x2e '.' */
+
+static final byte[] ch46data = {
+(byte) 0x40,(byte) 0xe0,(byte) 0x40,
+};
+
+static final BitmapCharRec ch46 = new BitmapCharRec(3,3,-2,1,8,ch46data);
+
+/* char: 0x2d '-' */
+
+static final byte[] ch45data = {
+(byte) 0xfc,
+};
+
+static final BitmapCharRec ch45 = new BitmapCharRec(6,1,-1,-4,8,ch45data);
+
+/* char: 0x2c ',' */
+
+static final byte[] ch44data = {
+(byte) 0x80,(byte) 0x60,(byte) 0x70,
+};
+
+static final BitmapCharRec ch44 = new BitmapCharRec(4,3,-1,1,8,ch44data);
+
+/* char: 0x2b '+' */
+
+static final byte[] ch43data = {
+(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0x20,
+};
+
+static final BitmapCharRec ch43 = new BitmapCharRec(5,5,-1,-2,8,ch43data);
+
+/* char: 0x2a '*' */
+
+static final byte[] ch42data = {
+(byte) 0x48,(byte) 0x30,(byte) 0xfc,(byte) 0x30,(byte) 0x48,
+};
+
+static final BitmapCharRec ch42 = new BitmapCharRec(6,5,-1,-2,8,ch42data);
+
+/* char: 0x29 ')' */
+
+static final byte[] ch41data = {
+(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x80,
+};
+
+static final BitmapCharRec ch41 = new BitmapCharRec(3,9,-2,0,8,ch41data);
+
+/* char: 0x28 '(' */
+
+static final byte[] ch40data = {
+(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x20,
+};
+
+static final BitmapCharRec ch40 = new BitmapCharRec(3,9,-3,0,8,ch40data);
+
+/* char: 0x27 ''' */
+
+static final byte[] ch39data = {
+(byte) 0x80,(byte) 0x60,(byte) 0x70,
+};
+
+static final BitmapCharRec ch39 = new BitmapCharRec(4,3,-1,-6,8,ch39data);
+
+/* char: 0x26 '&' */
+
+static final byte[] ch38data = {
+(byte) 0x74,(byte) 0x88,(byte) 0x94,(byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x60,
+};
+
+static final BitmapCharRec ch38 = new BitmapCharRec(6,7,-1,0,8,ch38data);
+
+/* char: 0x25 '%' */
+
+static final byte[] ch37data = {
+(byte) 0x88,(byte) 0x54,(byte) 0x48,(byte) 0x20,(byte) 0x10,(byte) 0x10,(byte) 0x48,(byte) 0xa4,(byte) 0x44,
+};
+
+static final BitmapCharRec ch37 = new BitmapCharRec(6,9,-1,0,8,ch37data);
+
+/* char: 0x24 '$' */
+
+static final byte[] ch36data = {
+(byte) 0x20,(byte) 0xf0,(byte) 0x28,(byte) 0x70,(byte) 0xa0,(byte) 0x78,(byte) 0x20,
+};
+
+static final BitmapCharRec ch36 = new BitmapCharRec(5,7,-1,-1,8,ch36data);
+
+/* char: 0x23 '#' */
+
+static final byte[] ch35data = {
+(byte) 0x48,(byte) 0x48,(byte) 0xfc,(byte) 0x48,(byte) 0xfc,(byte) 0x48,(byte) 0x48,
+};
+
+static final BitmapCharRec ch35 = new BitmapCharRec(6,7,-1,-1,8,ch35data);
+
+/* char: 0x22 '"' */
+
+static final byte[] ch34data = {
+(byte) 0x90,(byte) 0x90,(byte) 0x90,
+};
+
+static final BitmapCharRec ch34 = new BitmapCharRec(4,3,-2,-6,8,ch34data);
+
+/* char: 0x21 '!' */
+
+static final byte[] ch33data = {
+(byte) 0x80,(byte) 0x0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch33 = new BitmapCharRec(1,9,-3,0,8,ch33data);
+
+/* char: 0x1f */
+
+static final byte[] ch31data = {
+(byte) 0x80,
+};
+
+static final BitmapCharRec ch31 = new BitmapCharRec(1,1,-3,-3,8,ch31data);
+
+/* char: 0x1e */
+
+static final byte[] ch30data = {
+(byte) 0xdc,(byte) 0x62,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x70,(byte) 0x20,(byte) 0x22,(byte) 0x1c,
+};
+
+static final BitmapCharRec ch30 = new BitmapCharRec(7,9,0,0,8,ch30data);
+
+/* char: 0x1d */
+
+static final byte[] ch29data = {
+(byte) 0x80,(byte) 0x40,(byte) 0xfe,(byte) 0x10,(byte) 0xfe,(byte) 0x4,(byte) 0x2,
+};
+
+static final BitmapCharRec ch29 = new BitmapCharRec(7,7,0,0,8,ch29data);
+
+/* char: 0x1c */
+
+static final byte[] ch28data = {
+(byte) 0x88,(byte) 0x48,(byte) 0x48,(byte) 0x48,(byte) 0x48,(byte) 0xfc,
+};
+
+static final BitmapCharRec ch28 = new BitmapCharRec(6,6,-1,0,8,ch28data);
+
+/* char: 0x1b */
+
+static final byte[] ch27data = {
+(byte) 0xfe,(byte) 0x80,(byte) 0x20,(byte) 0x8,(byte) 0x2,(byte) 0x8,(byte) 0x20,(byte) 0x80,
+};
+
+static final BitmapCharRec ch27 = new BitmapCharRec(7,8,0,0,8,ch27data);
+
+/* char: 0x1a */
+
+static final byte[] ch26data = {
+(byte) 0xfe,(byte) 0x2,(byte) 0x8,(byte) 0x20,(byte) 0x80,(byte) 0x20,(byte) 0x8,(byte) 0x2,
+};
+
+static final BitmapCharRec ch26 = new BitmapCharRec(7,8,0,0,8,ch26data);
+
+/* char: 0x19 */
+
+static final byte[] ch25data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch25 = new BitmapCharRec(1,13,-3,2,8,ch25data);
+
+/* char: 0x18 */
+
+static final byte[] ch24data = {
+(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0xff,
+};
+
+static final BitmapCharRec ch24 = new BitmapCharRec(8,6,0,2,8,ch24data);
+
+/* char: 0x17 */
+
+static final byte[] ch23data = {
+(byte) 0xff,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,
+};
+
+static final BitmapCharRec ch23 = new BitmapCharRec(8,8,0,-3,8,ch23data);
+
+/* char: 0x16 */
+
+static final byte[] ch22data = {
+(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0xf0,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,
+};
+
+static final BitmapCharRec ch22 = new BitmapCharRec(4,13,0,2,8,ch22data);
+
+/* char: 0x15 */
+
+static final byte[] ch21data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch21 = new BitmapCharRec(5,13,-3,2,8,ch21data);
+
+/* char: 0x14 */
+
+static final byte[] ch20data = {
+(byte) 0xff,
+};
+
+static final BitmapCharRec ch20 = new BitmapCharRec(8,1,0,1,8,ch20data);
+
+/* char: 0x13 */
+
+static final byte[] ch19data = {
+(byte) 0xff,
+};
+
+static final BitmapCharRec ch19 = new BitmapCharRec(8,1,0,-1,8,ch19data);
+
+/* char: 0x12 */
+
+static final byte[] ch18data = {
+(byte) 0xff,
+};
+
+static final BitmapCharRec ch18 = new BitmapCharRec(8,1,0,-3,8,ch18data);
+
+/* char: 0x11 */
+
+static final byte[] ch17data = {
+(byte) 0xff,
+};
+
+static final BitmapCharRec ch17 = new BitmapCharRec(8,1,0,-5,8,ch17data);
+
+/* char: 0x10 */
+
+static final byte[] ch16data = {
+(byte) 0xff,
+};
+
+static final BitmapCharRec ch16 = new BitmapCharRec(8,1,0,-7,8,ch16data);
+
+/* char: 0xf */
+
+static final byte[] ch15data = {
+(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0xff,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,
+};
+
+static final BitmapCharRec ch15 = new BitmapCharRec(8,13,0,2,8,ch15data);
+
+/* char: 0xe */
+
+static final byte[] ch14data = {
+(byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch14 = new BitmapCharRec(5,8,-3,-3,8,ch14data);
+
+/* char: 0xd */
+
+static final byte[] ch13data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf8,
+};
+
+static final BitmapCharRec ch13 = new BitmapCharRec(5,6,-3,2,8,ch13data);
+
+/* char: 0xc */
+
+static final byte[] ch12data = {
+(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0xf0,
+};
+
+static final BitmapCharRec ch12 = new BitmapCharRec(4,6,0,2,8,ch12data);
+
+/* char: 0xb */
+
+static final byte[] ch11data = {
+(byte) 0xf0,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,
+};
+
+static final BitmapCharRec ch11 = new BitmapCharRec(4,8,0,-3,8,ch11data);
+
+/* char: 0xa */
+
+static final byte[] ch10data = {
+(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x3e,(byte) 0x20,(byte) 0x50,(byte) 0x88,(byte) 0x88,
+};
+
+static final BitmapCharRec ch10 = new BitmapCharRec(7,9,0,2,8,ch10data);
+
+/* char: 0x9 */
+
+static final byte[] ch9data = {
+(byte) 0x3e,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x88,(byte) 0x98,(byte) 0xa8,(byte) 0xc8,(byte) 0x88,
+};
+
+static final BitmapCharRec ch9 = new BitmapCharRec(7,9,0,2,8,ch9data);
+
+/* char: 0x8 */
+
+static final byte[] ch8data = {
+(byte) 0xfe,(byte) 0x10,(byte) 0x10,(byte) 0xfe,(byte) 0x10,(byte) 0x10,
+};
+
+static final BitmapCharRec ch8 = new BitmapCharRec(7,6,0,0,8,ch8data);
+
+/* char: 0x7 */
+
+static final byte[] ch7data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x70,
+};
+
+static final BitmapCharRec ch7 = new BitmapCharRec(5,4,-1,-5,8,ch7data);
+
+/* char: 0x6 */
+
+static final byte[] ch6data = {
+(byte) 0x20,(byte) 0x20,(byte) 0x3c,(byte) 0x20,(byte) 0x3e,(byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch6 = new BitmapCharRec(7,9,0,2,8,ch6data);
+
+/* char: 0x5 */
+
+static final byte[] ch5data = {
+(byte) 0x22,(byte) 0x22,(byte) 0x3c,(byte) 0x22,(byte) 0x3c,(byte) 0x78,(byte) 0x80,(byte) 0x80,(byte) 0x78,
+};
+
+static final BitmapCharRec ch5 = new BitmapCharRec(7,9,0,2,8,ch5data);
+
+/* char: 0x4 */
+
+static final byte[] ch4data = {
+(byte) 0x10,(byte) 0x10,(byte) 0x1c,(byte) 0x10,(byte) 0x9e,(byte) 0x80,(byte) 0xe0,(byte) 0x80,(byte) 0xf0,
+};
+
+static final BitmapCharRec ch4 = new BitmapCharRec(7,9,0,2,8,ch4data);
+
+/* char: 0x3 */
+
+static final byte[] ch3data = {
+(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x3e,(byte) 0x88,(byte) 0x88,(byte) 0xf8,(byte) 0x88,(byte) 0x88,
+};
+
+static final BitmapCharRec ch3 = new BitmapCharRec(7,9,0,2,8,ch3data);
+
+/* char: 0x2 */
+
+static final byte[] ch2data = {
+(byte) 0x55,(byte) 0xaa,(byte) 0x55,(byte) 0xaa,(byte) 0x55,(byte) 0xaa,(byte) 0x55,(byte) 0xaa,(byte) 0x55,(byte) 0xaa,(byte) 0x55,(byte) 0xaa,
+};
+
+static final BitmapCharRec ch2 = new BitmapCharRec(8,12,0,2,8,ch2data);
+
+/* char: 0x1 */
+
+static final byte[] ch1data = {
+(byte) 0x10,(byte) 0x38,(byte) 0x7c,(byte) 0xfe,(byte) 0x7c,(byte) 0x38,(byte) 0x10,
+};
+
+static final BitmapCharRec ch1 = new BitmapCharRec(7,7,0,-1,8,ch1data);
+
+static final BitmapCharRec[] chars = {
+ch0,
+ch1,
+ch2,
+ch3,
+ch4,
+ch5,
+ch6,
+ch7,
+ch8,
+ch9,
+ch10,
+ch11,
+ch12,
+ch13,
+ch14,
+ch15,
+ch16,
+ch17,
+ch18,
+ch19,
+ch20,
+ch21,
+ch22,
+ch23,
+ch24,
+ch25,
+ch26,
+ch27,
+ch28,
+ch29,
+ch30,
+ch31,
+ch32,
+ch33,
+ch34,
+ch35,
+ch36,
+ch37,
+ch38,
+ch39,
+ch40,
+ch41,
+ch42,
+ch43,
+ch44,
+ch45,
+ch46,
+ch47,
+ch48,
+ch49,
+ch50,
+ch51,
+ch52,
+ch53,
+ch54,
+ch55,
+ch56,
+ch57,
+ch58,
+ch59,
+ch60,
+ch61,
+ch62,
+ch63,
+ch64,
+ch65,
+ch66,
+ch67,
+ch68,
+ch69,
+ch70,
+ch71,
+ch72,
+ch73,
+ch74,
+ch75,
+ch76,
+ch77,
+ch78,
+ch79,
+ch80,
+ch81,
+ch82,
+ch83,
+ch84,
+ch85,
+ch86,
+ch87,
+ch88,
+ch89,
+ch90,
+ch91,
+ch92,
+ch93,
+ch94,
+ch95,
+ch96,
+ch97,
+ch98,
+ch99,
+ch100,
+ch101,
+ch102,
+ch103,
+ch104,
+ch105,
+ch106,
+ch107,
+ch108,
+ch109,
+ch110,
+ch111,
+ch112,
+ch113,
+ch114,
+ch115,
+ch116,
+ch117,
+ch118,
+ch119,
+ch120,
+ch121,
+ch122,
+ch123,
+ch124,
+ch125,
+ch126,
+ch127,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+ch160,
+ch161,
+ch162,
+ch163,
+ch164,
+ch165,
+ch166,
+ch167,
+ch168,
+ch169,
+ch170,
+ch171,
+ch172,
+ch173,
+ch174,
+ch175,
+ch176,
+ch177,
+ch178,
+ch179,
+ch180,
+ch181,
+ch182,
+ch183,
+ch184,
+ch185,
+ch186,
+ch187,
+ch188,
+ch189,
+ch190,
+ch191,
+ch192,
+ch193,
+ch194,
+ch195,
+ch196,
+ch197,
+ch198,
+ch199,
+ch200,
+ch201,
+ch202,
+ch203,
+ch204,
+ch205,
+ch206,
+ch207,
+ch208,
+ch209,
+ch210,
+ch211,
+ch212,
+ch213,
+ch214,
+ch215,
+ch216,
+ch217,
+ch218,
+ch219,
+ch220,
+ch221,
+ch222,
+ch223,
+ch224,
+ch225,
+ch226,
+ch227,
+ch228,
+ch229,
+ch230,
+ch231,
+ch232,
+ch233,
+ch234,
+ch235,
+ch236,
+ch237,
+ch238,
+ch239,
+ch240,
+ch241,
+ch242,
+ch243,
+ch244,
+ch245,
+ch246,
+ch247,
+ch248,
+ch249,
+ch250,
+ch251,
+ch252,
+ch253,
+ch254,
+ch255,
+};
+
+  public static final BitmapFontRec glutBitmap8By13 = new BitmapFontRec("-misc-fixed-medium-r-normal--13-120-75-75-C-80-iso8859-1",
+                                                                 256,
+                                                                 0,
+                                                                 chars);
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/gl2/GLUTBitmap9x15.java b/src/jogl/classes/com/jogamp/opengl/util/gl2/GLUTBitmap9x15.java
new file mode 100644
index 000000000..5d357f3f7
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/gl2/GLUTBitmap9x15.java
@@ -0,0 +1,2079 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util.gl2;
+
+class GLUTBitmap9x15 {
+
+/* GENERATED FILE -- DO NOT MODIFY */
+
+static final BitmapCharRec ch0 = new BitmapCharRec(0,0,0,0,9,null);
+
+static final BitmapCharRec ch32 = new BitmapCharRec(0,0,0,0,9,null);
+
+static final BitmapCharRec ch127 = new BitmapCharRec(0,0,0,0,9,null);
+
+static final BitmapCharRec ch160 = new BitmapCharRec(0,0,0,0,9,null);
+
+/* char: 0xff */
+
+static final byte[] ch255data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x4,(byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x0,(byte) 0x28,(byte) 0x28,
+};
+
+static final BitmapCharRec ch255 = new BitmapCharRec(6,14,-1,3,9,ch255data);
+
+/* char: 0xfe */
+
+static final byte[] ch254data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xbc,(byte) 0xc2,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xc2,(byte) 0xbc,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch254 = new BitmapCharRec(7,12,-1,3,9,ch254data);
+
+/* char: 0xfd */
+
+static final byte[] ch253data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x4,(byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x0,(byte) 0x30,(byte) 0x8,
+};
+
+static final BitmapCharRec ch253 = new BitmapCharRec(6,14,-1,3,9,ch253data);
+
+/* char: 0xfc */
+
+static final byte[] ch252data = {
+(byte) 0x7a,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x0,(byte) 0x28,(byte) 0x28,
+};
+
+static final BitmapCharRec ch252 = new BitmapCharRec(7,11,-1,0,9,ch252data);
+
+/* char: 0xfb */
+
+static final byte[] ch251data = {
+(byte) 0x7a,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x0,(byte) 0x44,(byte) 0x38,
+};
+
+static final BitmapCharRec ch251 = new BitmapCharRec(7,11,-1,0,9,ch251data);
+
+/* char: 0xfa */
+
+static final byte[] ch250data = {
+(byte) 0x7a,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x0,(byte) 0x30,(byte) 0x8,
+};
+
+static final BitmapCharRec ch250 = new BitmapCharRec(7,11,-1,0,9,ch250data);
+
+/* char: 0xf9 */
+
+static final byte[] ch249data = {
+(byte) 0x7a,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x0,(byte) 0x18,(byte) 0x20,
+};
+
+static final BitmapCharRec ch249 = new BitmapCharRec(7,11,-1,0,9,ch249data);
+
+/* char: 0xf8 */
+
+static final byte[] ch248data = {
+(byte) 0x80,(byte) 0x7c,(byte) 0xa2,(byte) 0xa2,(byte) 0x92,(byte) 0x8a,(byte) 0x8a,(byte) 0x7c,(byte) 0x2,
+};
+
+static final BitmapCharRec ch248 = new BitmapCharRec(7,9,-1,1,9,ch248data);
+
+/* char: 0xf7 */
+
+static final byte[] ch247data = {
+(byte) 0x10,(byte) 0x38,(byte) 0x10,(byte) 0x0,(byte) 0xfe,(byte) 0x0,(byte) 0x10,(byte) 0x38,(byte) 0x10,
+};
+
+static final BitmapCharRec ch247 = new BitmapCharRec(7,9,-1,0,9,ch247data);
+
+/* char: 0xf6 */
+
+static final byte[] ch246data = {
+(byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x28,(byte) 0x28,
+};
+
+static final BitmapCharRec ch246 = new BitmapCharRec(7,11,-1,0,9,ch246data);
+
+/* char: 0xf5 */
+
+static final byte[] ch245data = {
+(byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x50,(byte) 0x28,
+};
+
+static final BitmapCharRec ch245 = new BitmapCharRec(7,11,-1,0,9,ch245data);
+
+/* char: 0xf4 */
+
+static final byte[] ch244data = {
+(byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x44,(byte) 0x38,
+};
+
+static final BitmapCharRec ch244 = new BitmapCharRec(7,11,-1,0,9,ch244data);
+
+/* char: 0xf3 */
+
+static final byte[] ch243data = {
+(byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x30,(byte) 0x8,
+};
+
+static final BitmapCharRec ch243 = new BitmapCharRec(7,11,-1,0,9,ch243data);
+
+/* char: 0xf2 */
+
+static final byte[] ch242data = {
+(byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x18,(byte) 0x20,
+};
+
+static final BitmapCharRec ch242 = new BitmapCharRec(7,11,-1,0,9,ch242data);
+
+/* char: 0xf1 */
+
+static final byte[] ch241data = {
+(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xc2,(byte) 0xbc,(byte) 0x0,(byte) 0x0,(byte) 0x50,(byte) 0x28,
+};
+
+static final BitmapCharRec ch241 = new BitmapCharRec(7,11,-1,0,9,ch241data);
+
+/* char: 0xf0 */
+
+static final byte[] ch240data = {
+(byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x8,(byte) 0x50,(byte) 0x30,(byte) 0x48,
+};
+
+static final BitmapCharRec ch240 = new BitmapCharRec(7,11,-1,0,9,ch240data);
+
+/* char: 0xef */
+
+static final byte[] ch239data = {
+(byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0x50,(byte) 0x50,
+};
+
+static final BitmapCharRec ch239 = new BitmapCharRec(5,11,-2,0,9,ch239data);
+
+/* char: 0xee */
+
+static final byte[] ch238data = {
+(byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0x90,(byte) 0x60,
+};
+
+static final BitmapCharRec ch238 = new BitmapCharRec(5,11,-2,0,9,ch238data);
+
+/* char: 0xed */
+
+static final byte[] ch237data = {
+(byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0x60,(byte) 0x10,
+};
+
+static final BitmapCharRec ch237 = new BitmapCharRec(5,11,-2,0,9,ch237data);
+
+/* char: 0xec */
+
+static final byte[] ch236data = {
+(byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0x30,(byte) 0x40,
+};
+
+static final BitmapCharRec ch236 = new BitmapCharRec(5,11,-2,0,9,ch236data);
+
+/* char: 0xeb */
+
+static final byte[] ch235data = {
+(byte) 0x7c,(byte) 0x80,(byte) 0x80,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x28,(byte) 0x28,
+};
+
+static final BitmapCharRec ch235 = new BitmapCharRec(7,11,-1,0,9,ch235data);
+
+/* char: 0xea */
+
+static final byte[] ch234data = {
+(byte) 0x7c,(byte) 0x80,(byte) 0x80,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x44,(byte) 0x38,
+};
+
+static final BitmapCharRec ch234 = new BitmapCharRec(7,11,-1,0,9,ch234data);
+
+/* char: 0xe9 */
+
+static final byte[] ch233data = {
+(byte) 0x7c,(byte) 0x80,(byte) 0x80,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x30,(byte) 0x8,
+};
+
+static final BitmapCharRec ch233 = new BitmapCharRec(7,11,-1,0,9,ch233data);
+
+/* char: 0xe8 */
+
+static final byte[] ch232data = {
+(byte) 0x7c,(byte) 0x80,(byte) 0x80,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x18,(byte) 0x20,
+};
+
+static final BitmapCharRec ch232 = new BitmapCharRec(7,11,-1,0,9,ch232data);
+
+/* char: 0xe7 */
+
+static final byte[] ch231data = {
+(byte) 0x30,(byte) 0x48,(byte) 0x18,(byte) 0x7c,(byte) 0x82,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x82,(byte) 0x7c,
+};
+
+static final BitmapCharRec ch231 = new BitmapCharRec(7,10,-1,3,9,ch231data);
+
+/* char: 0xe6 */
+
+static final byte[] ch230data = {
+(byte) 0x6e,(byte) 0x92,(byte) 0x90,(byte) 0x7c,(byte) 0x12,(byte) 0x92,(byte) 0x6c,
+};
+
+static final BitmapCharRec ch230 = new BitmapCharRec(7,7,-1,0,9,ch230data);
+
+/* char: 0xe5 */
+
+static final byte[] ch229data = {
+(byte) 0x7a,(byte) 0x86,(byte) 0x82,(byte) 0x7e,(byte) 0x2,(byte) 0x2,(byte) 0x7c,(byte) 0x0,(byte) 0x18,(byte) 0x24,(byte) 0x18,
+};
+
+static final BitmapCharRec ch229 = new BitmapCharRec(7,11,-1,0,9,ch229data);
+
+/* char: 0xe4 */
+
+static final byte[] ch228data = {
+(byte) 0x7a,(byte) 0x86,(byte) 0x82,(byte) 0x7e,(byte) 0x2,(byte) 0x2,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x28,(byte) 0x28,
+};
+
+static final BitmapCharRec ch228 = new BitmapCharRec(7,11,-1,0,9,ch228data);
+
+/* char: 0xe3 */
+
+static final byte[] ch227data = {
+(byte) 0x7a,(byte) 0x86,(byte) 0x82,(byte) 0x7e,(byte) 0x2,(byte) 0x2,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x50,(byte) 0x28,
+};
+
+static final BitmapCharRec ch227 = new BitmapCharRec(7,11,-1,0,9,ch227data);
+
+/* char: 0xe2 */
+
+static final byte[] ch226data = {
+(byte) 0x7a,(byte) 0x86,(byte) 0x82,(byte) 0x7e,(byte) 0x2,(byte) 0x2,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x44,(byte) 0x38,
+};
+
+static final BitmapCharRec ch226 = new BitmapCharRec(7,11,-1,0,9,ch226data);
+
+/* char: 0xe1 */
+
+static final byte[] ch225data = {
+(byte) 0x7a,(byte) 0x86,(byte) 0x82,(byte) 0x7e,(byte) 0x2,(byte) 0x2,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x30,(byte) 0x8,
+};
+
+static final BitmapCharRec ch225 = new BitmapCharRec(7,11,-1,0,9,ch225data);
+
+/* char: 0xe0 */
+
+static final byte[] ch224data = {
+(byte) 0x7a,(byte) 0x86,(byte) 0x82,(byte) 0x7e,(byte) 0x2,(byte) 0x2,(byte) 0x7c,(byte) 0x0,(byte) 0x0,(byte) 0x18,(byte) 0x20,
+};
+
+static final BitmapCharRec ch224 = new BitmapCharRec(7,11,-1,0,9,ch224data);
+
+/* char: 0xdf */
+
+static final byte[] ch223data = {
+(byte) 0x80,(byte) 0xbc,(byte) 0xc2,(byte) 0x82,(byte) 0x82,(byte) 0xfc,(byte) 0x82,(byte) 0x82,(byte) 0x7c,
+};
+
+static final BitmapCharRec ch223 = new BitmapCharRec(7,9,-1,1,9,ch223data);
+
+/* char: 0xde */
+
+static final byte[] ch222data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xfc,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch222 = new BitmapCharRec(7,10,-1,0,9,ch222data);
+
+/* char: 0xdd */
+
+static final byte[] ch221data = {
+(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x44,(byte) 0x82,(byte) 0x82,(byte) 0x0,(byte) 0x30,(byte) 0x8,
+};
+
+static final BitmapCharRec ch221 = new BitmapCharRec(7,11,-1,0,9,ch221data);
+
+/* char: 0xdc */
+
+static final byte[] ch220data = {
+(byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x0,(byte) 0x28,(byte) 0x28,
+};
+
+static final BitmapCharRec ch220 = new BitmapCharRec(7,11,-1,0,9,ch220data);
+
+/* char: 0xdb */
+
+static final byte[] ch219data = {
+(byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x0,(byte) 0x44,(byte) 0x38,
+};
+
+static final BitmapCharRec ch219 = new BitmapCharRec(7,11,-1,0,9,ch219data);
+
+/* char: 0xda */
+
+static final byte[] ch218data = {
+(byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x0,(byte) 0x30,(byte) 0x8,
+};
+
+static final BitmapCharRec ch218 = new BitmapCharRec(7,11,-1,0,9,ch218data);
+
+/* char: 0xd9 */
+
+static final byte[] ch217data = {
+(byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x0,(byte) 0x18,(byte) 0x20,
+};
+
+static final BitmapCharRec ch217 = new BitmapCharRec(7,11,-1,0,9,ch217data);
+
+/* char: 0xd8 */
+
+static final byte[] ch216data = {
+(byte) 0x80,(byte) 0x7c,(byte) 0xc2,(byte) 0xa2,(byte) 0xa2,(byte) 0x92,(byte) 0x92,(byte) 0x8a,(byte) 0x8a,(byte) 0x86,(byte) 0x7c,(byte) 0x2,
+};
+
+static final BitmapCharRec ch216 = new BitmapCharRec(7,12,-1,1,9,ch216data);
+
+/* char: 0xd7 */
+
+static final byte[] ch215data = {
+(byte) 0x82,(byte) 0x44,(byte) 0x28,(byte) 0x10,(byte) 0x28,(byte) 0x44,(byte) 0x82,
+};
+
+static final BitmapCharRec ch215 = new BitmapCharRec(7,7,-1,-1,9,ch215data);
+
+/* char: 0xd6 */
+
+static final byte[] ch214data = {
+(byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x28,(byte) 0x28,
+};
+
+static final BitmapCharRec ch214 = new BitmapCharRec(7,11,-1,0,9,ch214data);
+
+/* char: 0xd5 */
+
+static final byte[] ch213data = {
+(byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x50,(byte) 0x28,
+};
+
+static final BitmapCharRec ch213 = new BitmapCharRec(7,11,-1,0,9,ch213data);
+
+/* char: 0xd4 */
+
+static final byte[] ch212data = {
+(byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x44,(byte) 0x38,
+};
+
+static final BitmapCharRec ch212 = new BitmapCharRec(7,11,-1,0,9,ch212data);
+
+/* char: 0xd3 */
+
+static final byte[] ch211data = {
+(byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x30,(byte) 0x8,
+};
+
+static final BitmapCharRec ch211 = new BitmapCharRec(7,11,-1,0,9,ch211data);
+
+/* char: 0xd2 */
+
+static final byte[] ch210data = {
+(byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x0,(byte) 0x18,(byte) 0x20,
+};
+
+static final BitmapCharRec ch210 = new BitmapCharRec(7,11,-1,0,9,ch210data);
+
+/* char: 0xd1 */
+
+static final byte[] ch209data = {
+(byte) 0x82,(byte) 0x86,(byte) 0x8a,(byte) 0x92,(byte) 0x92,(byte) 0xa2,(byte) 0xc2,(byte) 0x82,(byte) 0x0,(byte) 0x50,(byte) 0x28,
+};
+
+static final BitmapCharRec ch209 = new BitmapCharRec(7,11,-1,0,9,ch209data);
+
+/* char: 0xd0 */
+
+static final byte[] ch208data = {
+(byte) 0xfc,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0xf2,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0xfc,
+};
+
+static final BitmapCharRec ch208 = new BitmapCharRec(7,10,-1,0,9,ch208data);
+
+/* char: 0xcf */
+
+static final byte[] ch207data = {
+(byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x0,(byte) 0x50,(byte) 0x50,
+};
+
+static final BitmapCharRec ch207 = new BitmapCharRec(5,11,-2,0,9,ch207data);
+
+/* char: 0xce */
+
+static final byte[] ch206data = {
+(byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x0,(byte) 0x88,(byte) 0x70,
+};
+
+static final BitmapCharRec ch206 = new BitmapCharRec(5,11,-2,0,9,ch206data);
+
+/* char: 0xcd */
+
+static final byte[] ch205data = {
+(byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x0,(byte) 0x60,(byte) 0x10,
+};
+
+static final BitmapCharRec ch205 = new BitmapCharRec(5,11,-2,0,9,ch205data);
+
+/* char: 0xcc */
+
+static final byte[] ch204data = {
+(byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x0,(byte) 0x30,(byte) 0x40,
+};
+
+static final BitmapCharRec ch204 = new BitmapCharRec(5,11,-2,0,9,ch204data);
+
+/* char: 0xcb */
+
+static final byte[] ch203data = {
+(byte) 0xfe,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x78,(byte) 0x40,(byte) 0x40,(byte) 0xfe,(byte) 0x0,(byte) 0x28,(byte) 0x28,
+};
+
+static final BitmapCharRec ch203 = new BitmapCharRec(7,11,-1,0,9,ch203data);
+
+/* char: 0xca */
+
+static final byte[] ch202data = {
+(byte) 0xfe,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x78,(byte) 0x40,(byte) 0x40,(byte) 0xfe,(byte) 0x0,(byte) 0x44,(byte) 0x38,
+};
+
+static final BitmapCharRec ch202 = new BitmapCharRec(7,11,-1,0,9,ch202data);
+
+/* char: 0xc9 */
+
+static final byte[] ch201data = {
+(byte) 0xfe,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x78,(byte) 0x40,(byte) 0x40,(byte) 0xfe,(byte) 0x0,(byte) 0x30,(byte) 0x8,
+};
+
+static final BitmapCharRec ch201 = new BitmapCharRec(7,11,-1,0,9,ch201data);
+
+/* char: 0xc8 */
+
+static final byte[] ch200data = {
+(byte) 0xfe,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x78,(byte) 0x40,(byte) 0x40,(byte) 0xfe,(byte) 0x0,(byte) 0x18,(byte) 0x20,
+};
+
+static final BitmapCharRec ch200 = new BitmapCharRec(7,11,-1,0,9,ch200data);
+
+/* char: 0xc7 */
+
+static final byte[] ch199data = {
+(byte) 0x30,(byte) 0x48,(byte) 0x18,(byte) 0x7c,(byte) 0x82,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x82,(byte) 0x7c,
+};
+
+static final BitmapCharRec ch199 = new BitmapCharRec(7,13,-1,3,9,ch199data);
+
+/* char: 0xc6 */
+
+static final byte[] ch198data = {
+(byte) 0x9e,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0xfc,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x6e,
+};
+
+static final BitmapCharRec ch198 = new BitmapCharRec(7,10,-1,0,9,ch198data);
+
+/* char: 0xc5 */
+
+static final byte[] ch197data = {
+(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x44,(byte) 0x38,(byte) 0x10,(byte) 0x28,(byte) 0x10,
+};
+
+static final BitmapCharRec ch197 = new BitmapCharRec(7,11,-1,0,9,ch197data);
+
+/* char: 0xc4 */
+
+static final byte[] ch196data = {
+(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x44,(byte) 0x38,(byte) 0x0,(byte) 0x28,(byte) 0x28,
+};
+
+static final BitmapCharRec ch196 = new BitmapCharRec(7,11,-1,0,9,ch196data);
+
+/* char: 0xc3 */
+
+static final byte[] ch195data = {
+(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x44,(byte) 0x38,(byte) 0x0,(byte) 0x50,(byte) 0x28,
+};
+
+static final BitmapCharRec ch195 = new BitmapCharRec(7,11,-1,0,9,ch195data);
+
+/* char: 0xc2 */
+
+static final byte[] ch194data = {
+(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x44,(byte) 0x38,(byte) 0x0,(byte) 0x44,(byte) 0x38,
+};
+
+static final BitmapCharRec ch194 = new BitmapCharRec(7,11,-1,0,9,ch194data);
+
+/* char: 0xc1 */
+
+static final byte[] ch193data = {
+(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x44,(byte) 0x38,(byte) 0x0,(byte) 0x30,(byte) 0x8,
+};
+
+static final BitmapCharRec ch193 = new BitmapCharRec(7,11,-1,0,9,ch193data);
+
+/* char: 0xc0 */
+
+static final byte[] ch192data = {
+(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x44,(byte) 0x38,(byte) 0x0,(byte) 0x18,(byte) 0x20,
+};
+
+static final BitmapCharRec ch192 = new BitmapCharRec(7,11,-1,0,9,ch192data);
+
+/* char: 0xbf */
+
+static final byte[] ch191data = {
+(byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x10,(byte) 0x0,(byte) 0x10,
+};
+
+static final BitmapCharRec ch191 = new BitmapCharRec(7,10,-1,0,9,ch191data);
+
+/* char: 0xbe */
+
+static final byte[] ch190data = {
+(byte) 0x6,(byte) 0x1a,(byte) 0x12,(byte) 0xa,(byte) 0x66,(byte) 0x92,(byte) 0x10,(byte) 0x20,(byte) 0x90,(byte) 0x60,
+};
+
+static final BitmapCharRec ch190 = new BitmapCharRec(7,10,-1,0,9,ch190data);
+
+/* char: 0xbd */
+
+static final byte[] ch189data = {
+(byte) 0x1e,(byte) 0x10,(byte) 0xc,(byte) 0x2,(byte) 0xf2,(byte) 0x4c,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x40,
+};
+
+static final BitmapCharRec ch189 = new BitmapCharRec(7,10,-1,0,9,ch189data);
+
+/* char: 0xbc */
+
+static final byte[] ch188data = {
+(byte) 0x6,(byte) 0x1a,(byte) 0x12,(byte) 0xa,(byte) 0xe6,(byte) 0x42,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x40,
+};
+
+static final BitmapCharRec ch188 = new BitmapCharRec(7,10,-1,0,9,ch188data);
+
+/* char: 0xbb */
+
+static final byte[] ch187data = {
+(byte) 0x90,(byte) 0x48,(byte) 0x24,(byte) 0x12,(byte) 0x12,(byte) 0x24,(byte) 0x48,(byte) 0x90,
+};
+
+static final BitmapCharRec ch187 = new BitmapCharRec(7,8,-1,-1,9,ch187data);
+
+/* char: 0xba */
+
+static final byte[] ch186data = {
+(byte) 0xf8,(byte) 0x0,(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x70,
+};
+
+static final BitmapCharRec ch186 = new BitmapCharRec(5,6,-1,-5,9,ch186data);
+
+/* char: 0xb9 */
+
+static final byte[] ch185data = {
+(byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x40,
+};
+
+static final BitmapCharRec ch185 = new BitmapCharRec(3,6,-1,-4,9,ch185data);
+
+/* char: 0xb8 */
+
+static final byte[] ch184data = {
+(byte) 0x60,(byte) 0x90,(byte) 0x30,
+};
+
+static final BitmapCharRec ch184 = new BitmapCharRec(4,3,-2,3,9,ch184data);
+
+/* char: 0xb7 */
+
+static final byte[] ch183data = {
+(byte) 0xc0,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch183 = new BitmapCharRec(2,2,-4,-4,9,ch183data);
+
+/* char: 0xb6 */
+
+static final byte[] ch182data = {
+(byte) 0xa,(byte) 0xa,(byte) 0xa,(byte) 0xa,(byte) 0xa,(byte) 0x7a,(byte) 0x8a,(byte) 0x8a,(byte) 0x8a,(byte) 0x7e,
+};
+
+static final BitmapCharRec ch182 = new BitmapCharRec(7,10,-1,0,9,ch182data);
+
+/* char: 0xb5 */
+
+static final byte[] ch181data = {
+(byte) 0x80,(byte) 0x80,(byte) 0xba,(byte) 0xc6,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,
+};
+
+static final BitmapCharRec ch181 = new BitmapCharRec(7,9,-1,2,9,ch181data);
+
+/* char: 0xb4 */
+
+static final byte[] ch180data = {
+(byte) 0xc0,(byte) 0x20,
+};
+
+static final BitmapCharRec ch180 = new BitmapCharRec(3,2,-3,-9,9,ch180data);
+
+/* char: 0xb3 */
+
+static final byte[] ch179data = {
+(byte) 0x60,(byte) 0x90,(byte) 0x10,(byte) 0x20,(byte) 0x90,(byte) 0x60,
+};
+
+static final BitmapCharRec ch179 = new BitmapCharRec(4,6,-1,-4,9,ch179data);
+
+/* char: 0xb2 */
+
+static final byte[] ch178data = {
+(byte) 0xf0,(byte) 0x80,(byte) 0x60,(byte) 0x10,(byte) 0x90,(byte) 0x60,
+};
+
+static final BitmapCharRec ch178 = new BitmapCharRec(4,6,-1,-4,9,ch178data);
+
+/* char: 0xb1 */
+
+static final byte[] ch177data = {
+(byte) 0xfe,(byte) 0x0,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0xfe,(byte) 0x10,(byte) 0x10,(byte) 0x10,
+};
+
+static final BitmapCharRec ch177 = new BitmapCharRec(7,9,-1,-1,9,ch177data);
+
+/* char: 0xb0 */
+
+static final byte[] ch176data = {
+(byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x60,
+};
+
+static final BitmapCharRec ch176 = new BitmapCharRec(4,4,-3,-6,9,ch176data);
+
+/* char: 0xaf */
+
+static final byte[] ch175data = {
+(byte) 0xfc,
+};
+
+static final BitmapCharRec ch175 = new BitmapCharRec(6,1,-1,-9,9,ch175data);
+
+/* char: 0xae */
+
+static final byte[] ch174data = {
+(byte) 0x3c,(byte) 0x42,(byte) 0xa5,(byte) 0xa9,(byte) 0xbd,(byte) 0xa5,(byte) 0xb9,(byte) 0x42,(byte) 0x3c,
+};
+
+static final BitmapCharRec ch174 = new BitmapCharRec(8,9,0,-1,9,ch174data);
+
+/* char: 0xad */
+
+static final byte[] ch173data = {
+(byte) 0xfc,
+};
+
+static final BitmapCharRec ch173 = new BitmapCharRec(6,1,-1,-4,9,ch173data);
+
+/* char: 0xac */
+
+static final byte[] ch172data = {
+(byte) 0x4,(byte) 0x4,(byte) 0x4,(byte) 0xfc,
+};
+
+static final BitmapCharRec ch172 = new BitmapCharRec(6,4,-1,-2,9,ch172data);
+
+/* char: 0xab */
+
+static final byte[] ch171data = {
+(byte) 0x12,(byte) 0x24,(byte) 0x48,(byte) 0x90,(byte) 0x90,(byte) 0x48,(byte) 0x24,(byte) 0x12,
+};
+
+static final BitmapCharRec ch171 = new BitmapCharRec(7,8,-1,-1,9,ch171data);
+
+/* char: 0xaa */
+
+static final byte[] ch170data = {
+(byte) 0xf8,(byte) 0x0,(byte) 0x78,(byte) 0x90,(byte) 0x70,(byte) 0x90,(byte) 0x60,
+};
+
+static final BitmapCharRec ch170 = new BitmapCharRec(5,7,-3,-3,9,ch170data);
+
+/* char: 0xa9 */
+
+static final byte[] ch169data = {
+(byte) 0x3c,(byte) 0x42,(byte) 0x99,(byte) 0xa5,(byte) 0xa1,(byte) 0xa5,(byte) 0x99,(byte) 0x42,(byte) 0x3c,
+};
+
+static final BitmapCharRec ch169 = new BitmapCharRec(8,9,0,-1,9,ch169data);
+
+/* char: 0xa8 */
+
+static final byte[] ch168data = {
+(byte) 0xa0,(byte) 0xa0,
+};
+
+static final BitmapCharRec ch168 = new BitmapCharRec(3,2,-3,-9,9,ch168data);
+
+/* char: 0xa7 */
+
+static final byte[] ch167data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x8,(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x80,(byte) 0x88,(byte) 0x70,
+};
+
+static final BitmapCharRec ch167 = new BitmapCharRec(5,11,-2,1,9,ch167data);
+
+/* char: 0xa6 */
+
+static final byte[] ch166data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch166 = new BitmapCharRec(1,11,-4,1,9,ch166data);
+
+/* char: 0xa5 */
+
+static final byte[] ch165data = {
+(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x7c,(byte) 0x10,(byte) 0x7c,(byte) 0x28,(byte) 0x44,(byte) 0x82,(byte) 0x82,
+};
+
+static final BitmapCharRec ch165 = new BitmapCharRec(7,10,-1,0,9,ch165data);
+
+/* char: 0xa4 */
+
+static final byte[] ch164data = {
+(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x44,(byte) 0x7c,(byte) 0x82,
+};
+
+static final BitmapCharRec ch164 = new BitmapCharRec(7,6,-1,-3,9,ch164data);
+
+/* char: 0xa3 */
+
+static final byte[] ch163data = {
+(byte) 0x5c,(byte) 0xa2,(byte) 0x60,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x22,(byte) 0x1c,
+};
+
+static final BitmapCharRec ch163 = new BitmapCharRec(7,10,-1,0,9,ch163data);
+
+/* char: 0xa2 */
+
+static final byte[] ch162data = {
+(byte) 0x40,(byte) 0x78,(byte) 0xa4,(byte) 0xa0,(byte) 0x90,(byte) 0x94,(byte) 0x78,(byte) 0x8,
+};
+
+static final BitmapCharRec ch162 = new BitmapCharRec(6,8,-1,0,9,ch162data);
+
+/* char: 0xa1 */
+
+static final byte[] ch161data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch161 = new BitmapCharRec(1,11,-4,0,9,ch161data);
+
+/* char: 0x7e '~' */
+
+static final byte[] ch126data = {
+(byte) 0x8c,(byte) 0x92,(byte) 0x62,
+};
+
+static final BitmapCharRec ch126 = new BitmapCharRec(7,3,-1,-7,9,ch126data);
+
+/* char: 0x7d '}' */
+
+static final byte[] ch125data = {
+(byte) 0xe0,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x20,(byte) 0x18,(byte) 0x18,(byte) 0x20,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0xe0,
+};
+
+static final BitmapCharRec ch125 = new BitmapCharRec(5,12,-1,1,9,ch125data);
+
+/* char: 0x7c '|' */
+
+static final byte[] ch124data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch124 = new BitmapCharRec(1,12,-4,1,9,ch124data);
+
+/* char: 0x7b '{' */
+
+static final byte[] ch123data = {
+(byte) 0x38,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0xc0,(byte) 0xc0,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x38,
+};
+
+static final BitmapCharRec ch123 = new BitmapCharRec(5,12,-3,1,9,ch123data);
+
+/* char: 0x7a 'z' */
+
+static final byte[] ch122data = {
+(byte) 0xfe,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x8,(byte) 0x4,(byte) 0xfe,
+};
+
+static final BitmapCharRec ch122 = new BitmapCharRec(7,7,-1,0,9,ch122data);
+
+/* char: 0x79 'y' */
+
+static final byte[] ch121data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x4,(byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,
+};
+
+static final BitmapCharRec ch121 = new BitmapCharRec(6,10,-1,3,9,ch121data);
+
+/* char: 0x78 'x' */
+
+static final byte[] ch120data = {
+(byte) 0x82,(byte) 0x44,(byte) 0x28,(byte) 0x10,(byte) 0x28,(byte) 0x44,(byte) 0x82,
+};
+
+static final BitmapCharRec ch120 = new BitmapCharRec(7,7,-1,0,9,ch120data);
+
+/* char: 0x77 'w' */
+
+static final byte[] ch119data = {
+(byte) 0x44,(byte) 0xaa,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0x82,(byte) 0x82,
+};
+
+static final BitmapCharRec ch119 = new BitmapCharRec(7,7,-1,0,9,ch119data);
+
+/* char: 0x76 'v' */
+
+static final byte[] ch118data = {
+(byte) 0x10,(byte) 0x28,(byte) 0x28,(byte) 0x44,(byte) 0x44,(byte) 0x82,(byte) 0x82,
+};
+
+static final BitmapCharRec ch118 = new BitmapCharRec(7,7,-1,0,9,ch118data);
+
+/* char: 0x75 'u' */
+
+static final byte[] ch117data = {
+(byte) 0x7a,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,
+};
+
+static final BitmapCharRec ch117 = new BitmapCharRec(7,7,-1,0,9,ch117data);
+
+/* char: 0x74 't' */
+
+static final byte[] ch116data = {
+(byte) 0x1c,(byte) 0x22,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xfc,(byte) 0x20,(byte) 0x20,
+};
+
+static final BitmapCharRec ch116 = new BitmapCharRec(7,9,-1,0,9,ch116data);
+
+/* char: 0x73 's' */
+
+static final byte[] ch115data = {
+(byte) 0x7c,(byte) 0x82,(byte) 0x2,(byte) 0x7c,(byte) 0x80,(byte) 0x82,(byte) 0x7c,
+};
+
+static final BitmapCharRec ch115 = new BitmapCharRec(7,7,-1,0,9,ch115data);
+
+/* char: 0x72 'r' */
+
+static final byte[] ch114data = {
+(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x42,(byte) 0x62,(byte) 0x9c,
+};
+
+static final BitmapCharRec ch114 = new BitmapCharRec(7,7,-1,0,9,ch114data);
+
+/* char: 0x71 'q' */
+
+static final byte[] ch113data = {
+(byte) 0x2,(byte) 0x2,(byte) 0x2,(byte) 0x7a,(byte) 0x86,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x86,(byte) 0x7a,
+};
+
+static final BitmapCharRec ch113 = new BitmapCharRec(7,10,-1,3,9,ch113data);
+
+/* char: 0x70 'p' */
+
+static final byte[] ch112data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xbc,(byte) 0xc2,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xc2,(byte) 0xbc,
+};
+
+static final BitmapCharRec ch112 = new BitmapCharRec(7,10,-1,3,9,ch112data);
+
+/* char: 0x6f 'o' */
+
+static final byte[] ch111data = {
+(byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,
+};
+
+static final BitmapCharRec ch111 = new BitmapCharRec(7,7,-1,0,9,ch111data);
+
+/* char: 0x6e 'n' */
+
+static final byte[] ch110data = {
+(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xc2,(byte) 0xbc,
+};
+
+static final BitmapCharRec ch110 = new BitmapCharRec(7,7,-1,0,9,ch110data);
+
+/* char: 0x6d 'm' */
+
+static final byte[] ch109data = {
+(byte) 0x82,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0xec,
+};
+
+static final BitmapCharRec ch109 = new BitmapCharRec(7,7,-1,0,9,ch109data);
+
+/* char: 0x6c 'l' */
+
+static final byte[] ch108data = {
+(byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xe0,
+};
+
+static final BitmapCharRec ch108 = new BitmapCharRec(5,10,-2,0,9,ch108data);
+
+/* char: 0x6b 'k' */
+
+static final byte[] ch107data = {
+(byte) 0x82,(byte) 0x8c,(byte) 0xb0,(byte) 0xc0,(byte) 0xb0,(byte) 0x8c,(byte) 0x82,(byte) 0x80,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch107 = new BitmapCharRec(7,10,-1,0,9,ch107data);
+
+/* char: 0x6a 'j' */
+
+static final byte[] ch106data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x4,(byte) 0x4,(byte) 0x4,(byte) 0x4,(byte) 0x4,(byte) 0x1c,(byte) 0x0,(byte) 0x0,(byte) 0xc,
+};
+
+static final BitmapCharRec ch106 = new BitmapCharRec(6,13,-1,3,9,ch106data);
+
+/* char: 0x69 'i' */
+
+static final byte[] ch105data = {
+(byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0x60,
+};
+
+static final BitmapCharRec ch105 = new BitmapCharRec(5,10,-2,0,9,ch105data);
+
+/* char: 0x68 'h' */
+
+static final byte[] ch104data = {
+(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xc2,(byte) 0xbc,(byte) 0x80,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch104 = new BitmapCharRec(7,10,-1,0,9,ch104data);
+
+/* char: 0x67 'g' */
+
+static final byte[] ch103data = {
+(byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x80,(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x7a,
+};
+
+static final BitmapCharRec ch103 = new BitmapCharRec(7,10,-1,3,9,ch103data);
+
+/* char: 0x66 'f' */
+
+static final byte[] ch102data = {
+(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x22,(byte) 0x22,(byte) 0x1c,
+};
+
+static final BitmapCharRec ch102 = new BitmapCharRec(7,10,-1,0,9,ch102data);
+
+/* char: 0x65 'e' */
+
+static final byte[] ch101data = {
+(byte) 0x7c,(byte) 0x80,(byte) 0x80,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x7c,
+};
+
+static final BitmapCharRec ch101 = new BitmapCharRec(7,7,-1,0,9,ch101data);
+
+/* char: 0x64 'd' */
+
+static final byte[] ch100data = {
+(byte) 0x7a,(byte) 0x86,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x86,(byte) 0x7a,(byte) 0x2,(byte) 0x2,(byte) 0x2,
+};
+
+static final BitmapCharRec ch100 = new BitmapCharRec(7,10,-1,0,9,ch100data);
+
+/* char: 0x63 'c' */
+
+static final byte[] ch99data = {
+(byte) 0x7c,(byte) 0x82,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x82,(byte) 0x7c,
+};
+
+static final BitmapCharRec ch99 = new BitmapCharRec(7,7,-1,0,9,ch99data);
+
+/* char: 0x62 'b' */
+
+static final byte[] ch98data = {
+(byte) 0xbc,(byte) 0xc2,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xc2,(byte) 0xbc,(byte) 0x80,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch98 = new BitmapCharRec(7,10,-1,0,9,ch98data);
+
+/* char: 0x61 'a' */
+
+static final byte[] ch97data = {
+(byte) 0x7a,(byte) 0x86,(byte) 0x82,(byte) 0x7e,(byte) 0x2,(byte) 0x2,(byte) 0x7c,
+};
+
+static final BitmapCharRec ch97 = new BitmapCharRec(7,7,-1,0,9,ch97data);
+
+/* char: 0x60 '`' */
+
+static final byte[] ch96data = {
+(byte) 0x10,(byte) 0x20,(byte) 0x40,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch96 = new BitmapCharRec(4,4,-3,-6,9,ch96data);
+
+/* char: 0x5f '_' */
+
+static final byte[] ch95data = {
+(byte) 0xff,
+};
+
+static final BitmapCharRec ch95 = new BitmapCharRec(8,1,0,1,9,ch95data);
+
+/* char: 0x5e '^' */
+
+static final byte[] ch94data = {
+(byte) 0x82,(byte) 0x44,(byte) 0x28,(byte) 0x10,
+};
+
+static final BitmapCharRec ch94 = new BitmapCharRec(7,4,-1,-6,9,ch94data);
+
+/* char: 0x5d ']' */
+
+static final byte[] ch93data = {
+(byte) 0xf0,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0xf0,
+};
+
+static final BitmapCharRec ch93 = new BitmapCharRec(4,12,-2,1,9,ch93data);
+
+/* char: 0x5c '\' */
+
+static final byte[] ch92data = {
+(byte) 0x2,(byte) 0x4,(byte) 0x4,(byte) 0x8,(byte) 0x10,(byte) 0x10,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x80,
+};
+
+static final BitmapCharRec ch92 = new BitmapCharRec(7,10,-1,0,9,ch92data);
+
+/* char: 0x5b '[' */
+
+static final byte[] ch91data = {
+(byte) 0xf0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf0,
+};
+
+static final BitmapCharRec ch91 = new BitmapCharRec(4,12,-3,1,9,ch91data);
+
+/* char: 0x5a 'Z' */
+
+static final byte[] ch90data = {
+(byte) 0xfe,(byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x8,(byte) 0x4,(byte) 0x2,(byte) 0xfe,
+};
+
+static final BitmapCharRec ch90 = new BitmapCharRec(7,10,-1,0,9,ch90data);
+
+/* char: 0x59 'Y' */
+
+static final byte[] ch89data = {
+(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x44,(byte) 0x82,(byte) 0x82,
+};
+
+static final BitmapCharRec ch89 = new BitmapCharRec(7,10,-1,0,9,ch89data);
+
+/* char: 0x58 'X' */
+
+static final byte[] ch88data = {
+(byte) 0x82,(byte) 0x82,(byte) 0x44,(byte) 0x28,(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x44,(byte) 0x82,(byte) 0x82,
+};
+
+static final BitmapCharRec ch88 = new BitmapCharRec(7,10,-1,0,9,ch88data);
+
+/* char: 0x57 'W' */
+
+static final byte[] ch87data = {
+(byte) 0x44,(byte) 0xaa,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,
+};
+
+static final BitmapCharRec ch87 = new BitmapCharRec(7,10,-1,0,9,ch87data);
+
+/* char: 0x56 'V' */
+
+static final byte[] ch86data = {
+(byte) 0x10,(byte) 0x28,(byte) 0x28,(byte) 0x28,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0x82,(byte) 0x82,(byte) 0x82,
+};
+
+static final BitmapCharRec ch86 = new BitmapCharRec(7,10,-1,0,9,ch86data);
+
+/* char: 0x55 'U' */
+
+static final byte[] ch85data = {
+(byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,
+};
+
+static final BitmapCharRec ch85 = new BitmapCharRec(7,10,-1,0,9,ch85data);
+
+/* char: 0x54 'T' */
+
+static final byte[] ch84data = {
+(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0xfe,
+};
+
+static final BitmapCharRec ch84 = new BitmapCharRec(7,10,-1,0,9,ch84data);
+
+/* char: 0x53 'S' */
+
+static final byte[] ch83data = {
+(byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x2,(byte) 0xc,(byte) 0x70,(byte) 0x80,(byte) 0x82,(byte) 0x82,(byte) 0x7c,
+};
+
+static final BitmapCharRec ch83 = new BitmapCharRec(7,10,-1,0,9,ch83data);
+
+/* char: 0x52 'R' */
+
+static final byte[] ch82data = {
+(byte) 0x82,(byte) 0x82,(byte) 0x84,(byte) 0x88,(byte) 0x90,(byte) 0xfc,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xfc,
+};
+
+static final BitmapCharRec ch82 = new BitmapCharRec(7,10,-1,0,9,ch82data);
+
+/* char: 0x51 'Q' */
+
+static final byte[] ch81data = {
+(byte) 0x6,(byte) 0x8,(byte) 0x7c,(byte) 0x92,(byte) 0xa2,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,
+};
+
+static final BitmapCharRec ch81 = new BitmapCharRec(7,12,-1,2,9,ch81data);
+
+/* char: 0x50 'P' */
+
+static final byte[] ch80data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xfc,
+};
+
+static final BitmapCharRec ch80 = new BitmapCharRec(7,10,-1,0,9,ch80data);
+
+/* char: 0x4f 'O' */
+
+static final byte[] ch79data = {
+(byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,
+};
+
+static final BitmapCharRec ch79 = new BitmapCharRec(7,10,-1,0,9,ch79data);
+
+/* char: 0x4e 'N' */
+
+static final byte[] ch78data = {
+(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x86,(byte) 0x8a,(byte) 0x92,(byte) 0xa2,(byte) 0xc2,(byte) 0x82,(byte) 0x82,
+};
+
+static final BitmapCharRec ch78 = new BitmapCharRec(7,10,-1,0,9,ch78data);
+
+/* char: 0x4d 'M' */
+
+static final byte[] ch77data = {
+(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x92,(byte) 0x92,(byte) 0xaa,(byte) 0xaa,(byte) 0xc6,(byte) 0x82,(byte) 0x82,
+};
+
+static final BitmapCharRec ch77 = new BitmapCharRec(7,10,-1,0,9,ch77data);
+
+/* char: 0x4c 'L' */
+
+static final byte[] ch76data = {
+(byte) 0xfe,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch76 = new BitmapCharRec(7,10,-1,0,9,ch76data);
+
+/* char: 0x4b 'K' */
+
+static final byte[] ch75data = {
+(byte) 0x82,(byte) 0x84,(byte) 0x88,(byte) 0x90,(byte) 0xa0,(byte) 0xe0,(byte) 0x90,(byte) 0x88,(byte) 0x84,(byte) 0x82,
+};
+
+static final BitmapCharRec ch75 = new BitmapCharRec(7,10,-1,0,9,ch75data);
+
+/* char: 0x4a 'J' */
+
+static final byte[] ch74data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x4,(byte) 0x4,(byte) 0x4,(byte) 0x4,(byte) 0x4,(byte) 0x4,(byte) 0x4,(byte) 0x1e,
+};
+
+static final BitmapCharRec ch74 = new BitmapCharRec(7,10,-1,0,9,ch74data);
+
+/* char: 0x49 'I' */
+
+static final byte[] ch73data = {
+(byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xf8,
+};
+
+static final BitmapCharRec ch73 = new BitmapCharRec(5,10,-2,0,9,ch73data);
+
+/* char: 0x48 'H' */
+
+static final byte[] ch72data = {
+(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,
+};
+
+static final BitmapCharRec ch72 = new BitmapCharRec(7,10,-1,0,9,ch72data);
+
+/* char: 0x47 'G' */
+
+static final byte[] ch71data = {
+(byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x8e,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x82,(byte) 0x7c,
+};
+
+static final BitmapCharRec ch71 = new BitmapCharRec(7,10,-1,0,9,ch71data);
+
+/* char: 0x46 'F' */
+
+static final byte[] ch70data = {
+(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x78,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xfe,
+};
+
+static final BitmapCharRec ch70 = new BitmapCharRec(7,10,-1,0,9,ch70data);
+
+/* char: 0x45 'E' */
+
+static final byte[] ch69data = {
+(byte) 0xfe,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x78,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xfe,
+};
+
+static final BitmapCharRec ch69 = new BitmapCharRec(7,10,-1,0,9,ch69data);
+
+/* char: 0x44 'D' */
+
+static final byte[] ch68data = {
+(byte) 0xfc,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0xfc,
+};
+
+static final BitmapCharRec ch68 = new BitmapCharRec(7,10,-1,0,9,ch68data);
+
+/* char: 0x43 'C' */
+
+static final byte[] ch67data = {
+(byte) 0x7c,(byte) 0x82,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x82,(byte) 0x7c,
+};
+
+static final BitmapCharRec ch67 = new BitmapCharRec(7,10,-1,0,9,ch67data);
+
+/* char: 0x42 'B' */
+
+static final byte[] ch66data = {
+(byte) 0xfc,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0x7c,(byte) 0x42,(byte) 0x42,(byte) 0x42,(byte) 0xfc,
+};
+
+static final BitmapCharRec ch66 = new BitmapCharRec(7,10,-1,0,9,ch66data);
+
+/* char: 0x41 'A' */
+
+static final byte[] ch65data = {
+(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x44,(byte) 0x28,(byte) 0x10,
+};
+
+static final BitmapCharRec ch65 = new BitmapCharRec(7,10,-1,0,9,ch65data);
+
+/* char: 0x40 '@' */
+
+static final byte[] ch64data = {
+(byte) 0x7c,(byte) 0x80,(byte) 0x80,(byte) 0x9a,(byte) 0xa6,(byte) 0xa2,(byte) 0x9e,(byte) 0x82,(byte) 0x82,(byte) 0x7c,
+};
+
+static final BitmapCharRec ch64 = new BitmapCharRec(7,10,-1,0,9,ch64data);
+
+/* char: 0x3f '?' */
+
+static final byte[] ch63data = {
+(byte) 0x10,(byte) 0x0,(byte) 0x10,(byte) 0x10,(byte) 0x8,(byte) 0x4,(byte) 0x2,(byte) 0x82,(byte) 0x82,(byte) 0x7c,
+};
+
+static final BitmapCharRec ch63 = new BitmapCharRec(7,10,-1,0,9,ch63data);
+
+/* char: 0x3e '>' */
+
+static final byte[] ch62data = {
+(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x8,(byte) 0x8,(byte) 0x10,(byte) 0x20,(byte) 0x40,(byte) 0x80,
+};
+
+static final BitmapCharRec ch62 = new BitmapCharRec(5,10,-2,0,9,ch62data);
+
+/* char: 0x3d '=' */
+
+static final byte[] ch61data = {
+(byte) 0xfe,(byte) 0x0,(byte) 0x0,(byte) 0xfe,
+};
+
+static final BitmapCharRec ch61 = new BitmapCharRec(7,4,-1,-2,9,ch61data);
+
+/* char: 0x3c '<' */
+
+static final byte[] ch60data = {
+(byte) 0x8,(byte) 0x10,(byte) 0x20,(byte) 0x40,(byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x8,
+};
+
+static final BitmapCharRec ch60 = new BitmapCharRec(5,10,-2,0,9,ch60data);
+
+/* char: 0x3b ';' */
+
+static final byte[] ch59data = {
+(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch59 = new BitmapCharRec(2,10,-4,3,9,ch59data);
+
+/* char: 0x3a ':' */
+
+static final byte[] ch58data = {
+(byte) 0xc0,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch58 = new BitmapCharRec(2,7,-4,0,9,ch58data);
+
+/* char: 0x39 '9' */
+
+static final byte[] ch57data = {
+(byte) 0x78,(byte) 0x4,(byte) 0x2,(byte) 0x2,(byte) 0x7a,(byte) 0x86,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,
+};
+
+static final BitmapCharRec ch57 = new BitmapCharRec(7,10,-1,0,9,ch57data);
+
+/* char: 0x38 '8' */
+
+static final byte[] ch56data = {
+(byte) 0x38,(byte) 0x44,(byte) 0x82,(byte) 0x82,(byte) 0x44,(byte) 0x38,(byte) 0x44,(byte) 0x82,(byte) 0x44,(byte) 0x38,
+};
+
+static final BitmapCharRec ch56 = new BitmapCharRec(7,10,-1,0,9,ch56data);
+
+/* char: 0x37 '7' */
+
+static final byte[] ch55data = {
+(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x10,(byte) 0x8,(byte) 0x4,(byte) 0x2,(byte) 0x2,(byte) 0xfe,
+};
+
+static final BitmapCharRec ch55 = new BitmapCharRec(7,10,-1,0,9,ch55data);
+
+/* char: 0x36 '6' */
+
+static final byte[] ch54data = {
+(byte) 0x7c,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xc2,(byte) 0xbc,(byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x3c,
+};
+
+static final BitmapCharRec ch54 = new BitmapCharRec(7,10,-1,0,9,ch54data);
+
+/* char: 0x35 '5' */
+
+static final byte[] ch53data = {
+(byte) 0x7c,(byte) 0x82,(byte) 0x2,(byte) 0x2,(byte) 0x2,(byte) 0xc2,(byte) 0xbc,(byte) 0x80,(byte) 0x80,(byte) 0xfe,
+};
+
+static final BitmapCharRec ch53 = new BitmapCharRec(7,10,-1,0,9,ch53data);
+
+/* char: 0x34 '4' */
+
+static final byte[] ch52data = {
+(byte) 0x4,(byte) 0x4,(byte) 0x4,(byte) 0xfe,(byte) 0x84,(byte) 0x44,(byte) 0x24,(byte) 0x14,(byte) 0xc,(byte) 0x4,
+};
+
+static final BitmapCharRec ch52 = new BitmapCharRec(7,10,-1,0,9,ch52data);
+
+/* char: 0x33 '3' */
+
+static final byte[] ch51data = {
+(byte) 0x7c,(byte) 0x82,(byte) 0x2,(byte) 0x2,(byte) 0x2,(byte) 0x1c,(byte) 0x8,(byte) 0x4,(byte) 0x2,(byte) 0xfe,
+};
+
+static final BitmapCharRec ch51 = new BitmapCharRec(7,10,-1,0,9,ch51data);
+
+/* char: 0x32 '2' */
+
+static final byte[] ch50data = {
+(byte) 0xfe,(byte) 0x80,(byte) 0x40,(byte) 0x30,(byte) 0x8,(byte) 0x4,(byte) 0x2,(byte) 0x82,(byte) 0x82,(byte) 0x7c,
+};
+
+static final BitmapCharRec ch50 = new BitmapCharRec(7,10,-1,0,9,ch50data);
+
+/* char: 0x31 '1' */
+
+static final byte[] ch49data = {
+(byte) 0xfe,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x90,(byte) 0x50,(byte) 0x30,(byte) 0x10,
+};
+
+static final BitmapCharRec ch49 = new BitmapCharRec(7,10,-1,0,9,ch49data);
+
+/* char: 0x30 '0' */
+
+static final byte[] ch48data = {
+(byte) 0x38,(byte) 0x44,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x44,(byte) 0x38,
+};
+
+static final BitmapCharRec ch48 = new BitmapCharRec(7,10,-1,0,9,ch48data);
+
+/* char: 0x2f '/' */
+
+static final byte[] ch47data = {
+(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x10,(byte) 0x8,(byte) 0x4,(byte) 0x4,(byte) 0x2,
+};
+
+static final BitmapCharRec ch47 = new BitmapCharRec(7,10,-1,0,9,ch47data);
+
+/* char: 0x2e '.' */
+
+static final byte[] ch46data = {
+(byte) 0xc0,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch46 = new BitmapCharRec(2,2,-4,0,9,ch46data);
+
+/* char: 0x2d '-' */
+
+static final byte[] ch45data = {
+(byte) 0xfe,
+};
+
+static final BitmapCharRec ch45 = new BitmapCharRec(7,1,-1,-4,9,ch45data);
+
+/* char: 0x2c ',' */
+
+static final byte[] ch44data = {
+(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch44 = new BitmapCharRec(2,5,-4,3,9,ch44data);
+
+/* char: 0x2b '+' */
+
+static final byte[] ch43data = {
+(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0xfe,(byte) 0x10,(byte) 0x10,(byte) 0x10,
+};
+
+static final BitmapCharRec ch43 = new BitmapCharRec(7,7,-1,-1,9,ch43data);
+
+/* char: 0x2a '*' */
+
+static final byte[] ch42data = {
+(byte) 0x10,(byte) 0x92,(byte) 0x54,(byte) 0x38,(byte) 0x54,(byte) 0x92,(byte) 0x10,
+};
+
+static final BitmapCharRec ch42 = new BitmapCharRec(7,7,-1,-1,9,ch42data);
+
+/* char: 0x29 ')' */
+
+static final byte[] ch41data = {
+(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x80,
+};
+
+static final BitmapCharRec ch41 = new BitmapCharRec(3,12,-3,1,9,ch41data);
+
+/* char: 0x28 '(' */
+
+static final byte[] ch40data = {
+(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x20,
+};
+
+static final BitmapCharRec ch40 = new BitmapCharRec(3,12,-3,1,9,ch40data);
+
+/* char: 0x27 ''' */
+
+static final byte[] ch39data = {
+(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x30,
+};
+
+static final BitmapCharRec ch39 = new BitmapCharRec(4,4,-3,-6,9,ch39data);
+
+/* char: 0x26 '&' */
+
+static final byte[] ch38data = {
+(byte) 0x62,(byte) 0x94,(byte) 0x88,(byte) 0x94,(byte) 0x62,(byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x60,
+};
+
+static final BitmapCharRec ch38 = new BitmapCharRec(7,10,-1,0,9,ch38data);
+
+/* char: 0x25 '%' */
+
+static final byte[] ch37data = {
+(byte) 0x84,(byte) 0x4a,(byte) 0x4a,(byte) 0x24,(byte) 0x10,(byte) 0x10,(byte) 0x48,(byte) 0xa4,(byte) 0xa4,(byte) 0x42,
+};
+
+static final BitmapCharRec ch37 = new BitmapCharRec(7,10,-1,0,9,ch37data);
+
+/* char: 0x24 '$' */
+
+static final byte[] ch36data = {
+(byte) 0x10,(byte) 0x7c,(byte) 0x92,(byte) 0x12,(byte) 0x12,(byte) 0x14,(byte) 0x38,(byte) 0x50,(byte) 0x90,(byte) 0x92,(byte) 0x7c,(byte) 0x10,
+};
+
+static final BitmapCharRec ch36 = new BitmapCharRec(7,12,-1,1,9,ch36data);
+
+/* char: 0x23 '#' */
+
+static final byte[] ch35data = {
+(byte) 0x48,(byte) 0x48,(byte) 0xfc,(byte) 0x48,(byte) 0x48,(byte) 0xfc,(byte) 0x48,(byte) 0x48,
+};
+
+static final BitmapCharRec ch35 = new BitmapCharRec(6,8,-1,-1,9,ch35data);
+
+/* char: 0x22 '"' */
+
+static final byte[] ch34data = {
+(byte) 0x90,(byte) 0x90,(byte) 0x90,
+};
+
+static final BitmapCharRec ch34 = new BitmapCharRec(4,3,-3,-7,9,ch34data);
+
+/* char: 0x21 '!' */
+
+static final byte[] ch33data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch33 = new BitmapCharRec(1,11,-4,0,9,ch33data);
+
+/* char: 0x1f */
+
+static final byte[] ch31data = {
+(byte) 0xc0,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch31 = new BitmapCharRec(2,2,-4,-2,9,ch31data);
+
+/* char: 0x1e */
+
+static final byte[] ch30data = {
+(byte) 0x5c,(byte) 0xa2,(byte) 0x60,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x22,(byte) 0x1c,
+};
+
+static final BitmapCharRec ch30 = new BitmapCharRec(7,10,-1,0,9,ch30data);
+
+/* char: 0x1d */
+
+static final byte[] ch29data = {
+(byte) 0x80,(byte) 0x40,(byte) 0xfe,(byte) 0x10,(byte) 0xfe,(byte) 0x4,(byte) 0x2,
+};
+
+static final BitmapCharRec ch29 = new BitmapCharRec(7,7,-1,0,9,ch29data);
+
+/* char: 0x1c */
+
+static final byte[] ch28data = {
+(byte) 0x44,(byte) 0x24,(byte) 0x24,(byte) 0x24,(byte) 0x24,(byte) 0x24,(byte) 0xfe,
+};
+
+static final BitmapCharRec ch28 = new BitmapCharRec(7,7,-1,0,9,ch28data);
+
+/* char: 0x1b */
+
+static final byte[] ch27data = {
+(byte) 0xfe,(byte) 0x0,(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x8,(byte) 0x8,(byte) 0x10,(byte) 0x20,(byte) 0x40,(byte) 0x80,
+};
+
+static final BitmapCharRec ch27 = new BitmapCharRec(7,12,-1,2,9,ch27data);
+
+/* char: 0x1a */
+
+static final byte[] ch26data = {
+(byte) 0xfc,(byte) 0x0,(byte) 0x4,(byte) 0x8,(byte) 0x10,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x8,(byte) 0x4,
+};
+
+static final BitmapCharRec ch26 = new BitmapCharRec(6,12,-2,2,9,ch26data);
+
+/* char: 0x19 */
+
+static final byte[] ch25data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch25 = new BitmapCharRec(1,15,-4,3,9,ch25data);
+
+/* char: 0x18 */
+
+static final byte[] ch24data = {
+(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0xff,(byte) 0x80,
+};
+
+static final BitmapCharRec ch24 = new BitmapCharRec(9,7,0,3,9,ch24data);
+
+/* char: 0x17 */
+
+static final byte[] ch23data = {
+(byte) 0xff,(byte) 0x80,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,
+(byte) 0x8,(byte) 0x0,
+};
+
+static final BitmapCharRec ch23 = new BitmapCharRec(9,9,0,-3,9,ch23data);
+
+/* char: 0x16 */
+
+static final byte[] ch22data = {
+(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0xf8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,
+};
+
+static final BitmapCharRec ch22 = new BitmapCharRec(5,15,0,3,9,ch22data);
+
+/* char: 0x15 */
+
+static final byte[] ch21data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch21 = new BitmapCharRec(5,15,-4,3,9,ch21data);
+
+/* char: 0x14 */
+
+static final byte[] ch20data = {
+(byte) 0xff,(byte) 0x80,
+};
+
+static final BitmapCharRec ch20 = new BitmapCharRec(9,1,0,1,9,ch20data);
+
+/* char: 0x13 */
+
+static final byte[] ch19data = {
+(byte) 0xff,(byte) 0x80,
+};
+
+static final BitmapCharRec ch19 = new BitmapCharRec(9,1,0,-1,9,ch19data);
+
+/* char: 0x12 */
+
+static final byte[] ch18data = {
+(byte) 0xff,(byte) 0x80,
+};
+
+static final BitmapCharRec ch18 = new BitmapCharRec(9,1,0,-3,9,ch18data);
+
+/* char: 0x11 */
+
+static final byte[] ch17data = {
+(byte) 0xff,(byte) 0x80,
+};
+
+static final BitmapCharRec ch17 = new BitmapCharRec(9,1,0,-5,9,ch17data);
+
+/* char: 0x10 */
+
+static final byte[] ch16data = {
+(byte) 0xff,(byte) 0x80,
+};
+
+static final BitmapCharRec ch16 = new BitmapCharRec(9,1,0,-7,9,ch16data);
+
+/* char: 0xf */
+
+static final byte[] ch15data = {
+(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0xff,(byte) 0x80,(byte) 0x8,(byte) 0x0,
+(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,
+};
+
+static final BitmapCharRec ch15 = new BitmapCharRec(9,15,0,3,9,ch15data);
+
+/* char: 0xe */
+
+static final byte[] ch14data = {
+(byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch14 = new BitmapCharRec(5,9,-4,-3,9,ch14data);
+
+/* char: 0xd */
+
+static final byte[] ch13data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf8,
+};
+
+static final BitmapCharRec ch13 = new BitmapCharRec(5,7,-4,3,9,ch13data);
+
+/* char: 0xc */
+
+static final byte[] ch12data = {
+(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0xf8,
+};
+
+static final BitmapCharRec ch12 = new BitmapCharRec(5,7,0,3,9,ch12data);
+
+/* char: 0xb */
+
+static final byte[] ch11data = {
+(byte) 0xf8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,
+};
+
+static final BitmapCharRec ch11 = new BitmapCharRec(5,9,0,-3,9,ch11data);
+
+/* char: 0xa */
+
+static final byte[] ch10data = {
+(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x3e,(byte) 0x0,(byte) 0x20,(byte) 0x50,(byte) 0x88,(byte) 0x88,
+};
+
+static final BitmapCharRec ch10 = new BitmapCharRec(7,10,-1,2,9,ch10data);
+
+/* char: 0x9 */
+
+static final byte[] ch9data = {
+(byte) 0x3e,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x88,(byte) 0x98,(byte) 0xa8,(byte) 0xc8,(byte) 0x88,
+};
+
+static final BitmapCharRec ch9 = new BitmapCharRec(7,10,-1,2,9,ch9data);
+
+/* char: 0x8 */
+
+static final byte[] ch8data = {
+(byte) 0xfe,(byte) 0x10,(byte) 0x10,(byte) 0xfe,(byte) 0x10,(byte) 0x10,
+};
+
+static final BitmapCharRec ch8 = new BitmapCharRec(7,6,-1,0,9,ch8data);
+
+/* char: 0x7 */
+
+static final byte[] ch7data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x70,
+};
+
+static final BitmapCharRec ch7 = new BitmapCharRec(5,4,-2,-6,9,ch7data);
+
+/* char: 0x6 */
+
+static final byte[] ch6data = {
+(byte) 0x20,(byte) 0x20,(byte) 0x3c,(byte) 0x20,(byte) 0x3e,(byte) 0x0,(byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch6 = new BitmapCharRec(7,10,-1,2,9,ch6data);
+
+/* char: 0x5 */
+
+static final byte[] ch5data = {
+(byte) 0x22,(byte) 0x22,(byte) 0x3c,(byte) 0x22,(byte) 0x3c,(byte) 0x0,(byte) 0x78,(byte) 0x80,(byte) 0x80,(byte) 0x78,
+};
+
+static final BitmapCharRec ch5 = new BitmapCharRec(7,10,-1,2,9,ch5data);
+
+/* char: 0x4 */
+
+static final byte[] ch4data = {
+(byte) 0x10,(byte) 0x10,(byte) 0x1c,(byte) 0x10,(byte) 0x1e,(byte) 0x80,(byte) 0x80,(byte) 0xe0,(byte) 0x80,(byte) 0xf0,
+};
+
+static final BitmapCharRec ch4 = new BitmapCharRec(7,10,-1,2,9,ch4data);
+
+/* char: 0x3 */
+
+static final byte[] ch3data = {
+(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x3e,(byte) 0x0,(byte) 0x88,(byte) 0x88,(byte) 0xf8,(byte) 0x88,(byte) 0x88,
+};
+
+static final BitmapCharRec ch3 = new BitmapCharRec(7,10,-1,2,9,ch3data);
+
+/* char: 0x2 */
+
+static final byte[] ch2data = {
+(byte) 0x55,(byte) 0xaa,(byte) 0x55,(byte) 0xaa,(byte) 0x55,(byte) 0xaa,(byte) 0x55,(byte) 0xaa,(byte) 0x55,(byte) 0xaa,(byte) 0x55,(byte) 0xaa,(byte) 0x55,(byte) 0xaa,
+};
+
+static final BitmapCharRec ch2 = new BitmapCharRec(8,14,0,3,9,ch2data);
+
+/* char: 0x1 */
+
+static final byte[] ch1data = {
+(byte) 0x10,(byte) 0x38,(byte) 0x7c,(byte) 0xfe,(byte) 0x7c,(byte) 0x38,(byte) 0x10,
+};
+
+static final BitmapCharRec ch1 = new BitmapCharRec(7,7,-1,0,9,ch1data);
+
+static final BitmapCharRec[] chars = {
+ch0,
+ch1,
+ch2,
+ch3,
+ch4,
+ch5,
+ch6,
+ch7,
+ch8,
+ch9,
+ch10,
+ch11,
+ch12,
+ch13,
+ch14,
+ch15,
+ch16,
+ch17,
+ch18,
+ch19,
+ch20,
+ch21,
+ch22,
+ch23,
+ch24,
+ch25,
+ch26,
+ch27,
+ch28,
+ch29,
+ch30,
+ch31,
+ch32,
+ch33,
+ch34,
+ch35,
+ch36,
+ch37,
+ch38,
+ch39,
+ch40,
+ch41,
+ch42,
+ch43,
+ch44,
+ch45,
+ch46,
+ch47,
+ch48,
+ch49,
+ch50,
+ch51,
+ch52,
+ch53,
+ch54,
+ch55,
+ch56,
+ch57,
+ch58,
+ch59,
+ch60,
+ch61,
+ch62,
+ch63,
+ch64,
+ch65,
+ch66,
+ch67,
+ch68,
+ch69,
+ch70,
+ch71,
+ch72,
+ch73,
+ch74,
+ch75,
+ch76,
+ch77,
+ch78,
+ch79,
+ch80,
+ch81,
+ch82,
+ch83,
+ch84,
+ch85,
+ch86,
+ch87,
+ch88,
+ch89,
+ch90,
+ch91,
+ch92,
+ch93,
+ch94,
+ch95,
+ch96,
+ch97,
+ch98,
+ch99,
+ch100,
+ch101,
+ch102,
+ch103,
+ch104,
+ch105,
+ch106,
+ch107,
+ch108,
+ch109,
+ch110,
+ch111,
+ch112,
+ch113,
+ch114,
+ch115,
+ch116,
+ch117,
+ch118,
+ch119,
+ch120,
+ch121,
+ch122,
+ch123,
+ch124,
+ch125,
+ch126,
+ch127,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+ch160,
+ch161,
+ch162,
+ch163,
+ch164,
+ch165,
+ch166,
+ch167,
+ch168,
+ch169,
+ch170,
+ch171,
+ch172,
+ch173,
+ch174,
+ch175,
+ch176,
+ch177,
+ch178,
+ch179,
+ch180,
+ch181,
+ch182,
+ch183,
+ch184,
+ch185,
+ch186,
+ch187,
+ch188,
+ch189,
+ch190,
+ch191,
+ch192,
+ch193,
+ch194,
+ch195,
+ch196,
+ch197,
+ch198,
+ch199,
+ch200,
+ch201,
+ch202,
+ch203,
+ch204,
+ch205,
+ch206,
+ch207,
+ch208,
+ch209,
+ch210,
+ch211,
+ch212,
+ch213,
+ch214,
+ch215,
+ch216,
+ch217,
+ch218,
+ch219,
+ch220,
+ch221,
+ch222,
+ch223,
+ch224,
+ch225,
+ch226,
+ch227,
+ch228,
+ch229,
+ch230,
+ch231,
+ch232,
+ch233,
+ch234,
+ch235,
+ch236,
+ch237,
+ch238,
+ch239,
+ch240,
+ch241,
+ch242,
+ch243,
+ch244,
+ch245,
+ch246,
+ch247,
+ch248,
+ch249,
+ch250,
+ch251,
+ch252,
+ch253,
+ch254,
+ch255,
+};
+
+  public static final BitmapFontRec glutBitmap9By15 = new BitmapFontRec("-misc-fixed-medium-r-normal--15-140-75-75-C-90-iso8859-1",
+                                                                 256,
+                                                                 0,
+                                                                 chars);
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/gl2/GLUTBitmapHelvetica10.java b/src/jogl/classes/com/jogamp/opengl/util/gl2/GLUTBitmapHelvetica10.java
new file mode 100644
index 000000000..b9c7e6e50
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/gl2/GLUTBitmapHelvetica10.java
@@ -0,0 +1,1798 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util.gl2;
+
+class GLUTBitmapHelvetica10 {
+
+/* GENERATED FILE -- DO NOT MODIFY */
+
+/* char: 0xff */
+
+static final byte[] ch255data = {
+(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x60,(byte) 0xa0,(byte) 0xa0,(byte) 0x90,(byte) 0x90,(byte) 0x0,(byte) 0x50,
+};
+
+static final BitmapCharRec ch255 = new BitmapCharRec(4,10,0,2,5,ch255data);
+
+/* char: 0xfe */
+
+static final byte[] ch254data = {
+(byte) 0x80,(byte) 0x80,(byte) 0xb0,(byte) 0xc8,(byte) 0x88,(byte) 0x88,(byte) 0xc8,(byte) 0xb0,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch254 = new BitmapCharRec(5,10,0,2,6,ch254data);
+
+/* char: 0xfd */
+
+static final byte[] ch253data = {
+(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x60,(byte) 0xa0,(byte) 0xa0,(byte) 0x90,(byte) 0x90,(byte) 0x0,(byte) 0x20,(byte) 0x10,
+};
+
+static final BitmapCharRec ch253 = new BitmapCharRec(4,11,0,2,5,ch253data);
+
+/* char: 0xfc */
+
+static final byte[] ch252data = {
+(byte) 0x70,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x0,(byte) 0x50,
+};
+
+static final BitmapCharRec ch252 = new BitmapCharRec(4,8,0,0,5,ch252data);
+
+/* char: 0xfb */
+
+static final byte[] ch251data = {
+(byte) 0x70,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x0,(byte) 0x50,(byte) 0x20,
+};
+
+static final BitmapCharRec ch251 = new BitmapCharRec(4,9,0,0,5,ch251data);
+
+/* char: 0xfa */
+
+static final byte[] ch250data = {
+(byte) 0x70,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x0,(byte) 0x40,(byte) 0x20,
+};
+
+static final BitmapCharRec ch250 = new BitmapCharRec(4,9,0,0,5,ch250data);
+
+/* char: 0xf9 */
+
+static final byte[] ch249data = {
+(byte) 0x70,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x0,(byte) 0x20,(byte) 0x40,
+};
+
+static final BitmapCharRec ch249 = new BitmapCharRec(4,9,0,0,5,ch249data);
+
+/* char: 0xf8 */
+
+static final byte[] ch248data = {
+(byte) 0x70,(byte) 0x88,(byte) 0xc8,(byte) 0xa8,(byte) 0x98,(byte) 0x74,
+};
+
+static final BitmapCharRec ch248 = new BitmapCharRec(6,6,0,0,6,ch248data);
+
+/* char: 0xf7 */
+
+static final byte[] ch247data = {
+(byte) 0x20,(byte) 0x0,(byte) 0xf8,(byte) 0x0,(byte) 0x20,
+};
+
+static final BitmapCharRec ch247 = new BitmapCharRec(5,5,0,-1,6,ch247data);
+
+/* char: 0xf6 */
+
+static final byte[] ch246data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x50,
+};
+
+static final BitmapCharRec ch246 = new BitmapCharRec(5,8,0,0,6,ch246data);
+
+/* char: 0xf5 */
+
+static final byte[] ch245data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x50,(byte) 0x28,
+};
+
+static final BitmapCharRec ch245 = new BitmapCharRec(5,9,0,0,6,ch245data);
+
+/* char: 0xf4 */
+
+static final byte[] ch244data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x50,(byte) 0x20,
+};
+
+static final BitmapCharRec ch244 = new BitmapCharRec(5,9,0,0,6,ch244data);
+
+/* char: 0xf3 */
+
+static final byte[] ch243data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x20,(byte) 0x10,
+};
+
+static final BitmapCharRec ch243 = new BitmapCharRec(5,9,0,0,6,ch243data);
+
+/* char: 0xf2 */
+
+static final byte[] ch242data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x20,(byte) 0x40,
+};
+
+static final BitmapCharRec ch242 = new BitmapCharRec(5,9,0,0,6,ch242data);
+
+/* char: 0xf1 */
+
+static final byte[] ch241data = {
+(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0xe0,(byte) 0x0,(byte) 0xa0,(byte) 0x50,
+};
+
+static final BitmapCharRec ch241 = new BitmapCharRec(4,9,0,0,5,ch241data);
+
+/* char: 0xf0 */
+
+static final byte[] ch240data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x78,(byte) 0x90,(byte) 0x60,(byte) 0x50,
+};
+
+static final BitmapCharRec ch240 = new BitmapCharRec(5,9,0,0,6,ch240data);
+
+/* char: 0xef */
+
+static final byte[] ch239data = {
+(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0xa0,
+};
+
+static final BitmapCharRec ch239 = new BitmapCharRec(3,8,0,0,2,ch239data);
+
+/* char: 0xee */
+
+static final byte[] ch238data = {
+(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0xa0,(byte) 0x40,
+};
+
+static final BitmapCharRec ch238 = new BitmapCharRec(3,9,1,0,2,ch238data);
+
+/* char: 0xed */
+
+static final byte[] ch237data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80,(byte) 0x40,
+};
+
+static final BitmapCharRec ch237 = new BitmapCharRec(2,9,0,0,2,ch237data);
+
+/* char: 0xec */
+
+static final byte[] ch236data = {
+(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0x40,(byte) 0x80,
+};
+
+static final BitmapCharRec ch236 = new BitmapCharRec(2,9,1,0,2,ch236data);
+
+/* char: 0xeb */
+
+static final byte[] ch235data = {
+(byte) 0x60,(byte) 0x90,(byte) 0x80,(byte) 0xf0,(byte) 0x90,(byte) 0x60,(byte) 0x0,(byte) 0x50,
+};
+
+static final BitmapCharRec ch235 = new BitmapCharRec(4,8,0,0,5,ch235data);
+
+/* char: 0xea */
+
+static final byte[] ch234data = {
+(byte) 0x60,(byte) 0x90,(byte) 0x80,(byte) 0xf0,(byte) 0x90,(byte) 0x60,(byte) 0x0,(byte) 0x50,(byte) 0x20,
+};
+
+static final BitmapCharRec ch234 = new BitmapCharRec(4,9,0,0,5,ch234data);
+
+/* char: 0xe9 */
+
+static final byte[] ch233data = {
+(byte) 0x60,(byte) 0x90,(byte) 0x80,(byte) 0xf0,(byte) 0x90,(byte) 0x60,(byte) 0x0,(byte) 0x40,(byte) 0x20,
+};
+
+static final BitmapCharRec ch233 = new BitmapCharRec(4,9,0,0,5,ch233data);
+
+/* char: 0xe8 */
+
+static final byte[] ch232data = {
+(byte) 0x60,(byte) 0x90,(byte) 0x80,(byte) 0xf0,(byte) 0x90,(byte) 0x60,(byte) 0x0,(byte) 0x20,(byte) 0x40,
+};
+
+static final BitmapCharRec ch232 = new BitmapCharRec(4,9,0,0,5,ch232data);
+
+/* char: 0xe7 */
+
+static final byte[] ch231data = {
+(byte) 0x60,(byte) 0x20,(byte) 0x60,(byte) 0x90,(byte) 0x80,(byte) 0x80,(byte) 0x90,(byte) 0x60,
+};
+
+static final BitmapCharRec ch231 = new BitmapCharRec(4,8,0,2,5,ch231data);
+
+/* char: 0xe6 */
+
+static final byte[] ch230data = {
+(byte) 0x6c,(byte) 0x92,(byte) 0x90,(byte) 0x7e,(byte) 0x12,(byte) 0xec,
+};
+
+static final BitmapCharRec ch230 = new BitmapCharRec(7,6,0,0,8,ch230data);
+
+/* char: 0xe5 */
+
+static final byte[] ch229data = {
+(byte) 0x68,(byte) 0x90,(byte) 0x90,(byte) 0x70,(byte) 0x10,(byte) 0xe0,(byte) 0x20,(byte) 0x50,(byte) 0x20,
+};
+
+static final BitmapCharRec ch229 = new BitmapCharRec(5,9,0,0,5,ch229data);
+
+/* char: 0xe4 */
+
+static final byte[] ch228data = {
+(byte) 0x68,(byte) 0x90,(byte) 0x90,(byte) 0x70,(byte) 0x10,(byte) 0xe0,(byte) 0x0,(byte) 0x50,
+};
+
+static final BitmapCharRec ch228 = new BitmapCharRec(5,8,0,0,5,ch228data);
+
+/* char: 0xe3 */
+
+static final byte[] ch227data = {
+(byte) 0x68,(byte) 0x90,(byte) 0x90,(byte) 0x70,(byte) 0x10,(byte) 0xe0,(byte) 0x0,(byte) 0xa0,(byte) 0x50,
+};
+
+static final BitmapCharRec ch227 = new BitmapCharRec(5,9,0,0,5,ch227data);
+
+/* char: 0xe2 */
+
+static final byte[] ch226data = {
+(byte) 0x68,(byte) 0x90,(byte) 0x90,(byte) 0x70,(byte) 0x10,(byte) 0xe0,(byte) 0x0,(byte) 0x50,(byte) 0x20,
+};
+
+static final BitmapCharRec ch226 = new BitmapCharRec(5,9,0,0,5,ch226data);
+
+/* char: 0xe1 */
+
+static final byte[] ch225data = {
+(byte) 0x68,(byte) 0x90,(byte) 0x90,(byte) 0x70,(byte) 0x10,(byte) 0xe0,(byte) 0x0,(byte) 0x20,(byte) 0x10,
+};
+
+static final BitmapCharRec ch225 = new BitmapCharRec(5,9,0,0,5,ch225data);
+
+/* char: 0xe0 */
+
+static final byte[] ch224data = {
+(byte) 0x68,(byte) 0x90,(byte) 0x90,(byte) 0x70,(byte) 0x10,(byte) 0xe0,(byte) 0x0,(byte) 0x20,(byte) 0x40,
+};
+
+static final BitmapCharRec ch224 = new BitmapCharRec(5,9,0,0,5,ch224data);
+
+/* char: 0xdf */
+
+static final byte[] ch223data = {
+(byte) 0xa0,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0xa0,(byte) 0x90,(byte) 0x90,(byte) 0x60,
+};
+
+static final BitmapCharRec ch223 = new BitmapCharRec(4,8,0,0,5,ch223data);
+
+/* char: 0xde */
+
+static final byte[] ch222data = {
+(byte) 0x80,(byte) 0x80,(byte) 0xf0,(byte) 0x88,(byte) 0x88,(byte) 0xf0,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch222 = new BitmapCharRec(5,8,-1,0,7,ch222data);
+
+/* char: 0xdd */
+
+static final byte[] ch221data = {
+(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x28,(byte) 0x44,(byte) 0x44,(byte) 0x82,(byte) 0x0,(byte) 0x10,(byte) 0x8,
+};
+
+static final BitmapCharRec ch221 = new BitmapCharRec(7,11,0,0,7,ch221data);
+
+/* char: 0xdc */
+
+static final byte[] ch220data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x48,
+};
+
+static final BitmapCharRec ch220 = new BitmapCharRec(6,10,-1,0,8,ch220data);
+
+/* char: 0xdb */
+
+static final byte[] ch219data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x28,(byte) 0x10,
+};
+
+static final BitmapCharRec ch219 = new BitmapCharRec(6,11,-1,0,8,ch219data);
+
+/* char: 0xda */
+
+static final byte[] ch218data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x20,(byte) 0x10,
+};
+
+static final BitmapCharRec ch218 = new BitmapCharRec(6,11,-1,0,8,ch218data);
+
+/* char: 0xd9 */
+
+static final byte[] ch217data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x10,(byte) 0x20,
+};
+
+static final BitmapCharRec ch217 = new BitmapCharRec(6,11,-1,0,8,ch217data);
+
+/* char: 0xd8 */
+
+static final byte[] ch216data = {
+(byte) 0x80,(byte) 0x78,(byte) 0xc4,(byte) 0xa4,(byte) 0xa4,(byte) 0x94,(byte) 0x94,(byte) 0x8c,(byte) 0x78,(byte) 0x4,
+};
+
+static final BitmapCharRec ch216 = new BitmapCharRec(6,10,-1,1,8,ch216data);
+
+/* char: 0xd7 */
+
+static final byte[] ch215data = {
+(byte) 0x88,(byte) 0x50,(byte) 0x20,(byte) 0x50,(byte) 0x88,
+};
+
+static final BitmapCharRec ch215 = new BitmapCharRec(5,5,0,-1,6,ch215data);
+
+/* char: 0xd6 */
+
+static final byte[] ch214data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x48,
+};
+
+static final BitmapCharRec ch214 = new BitmapCharRec(6,10,-1,0,8,ch214data);
+
+/* char: 0xd5 */
+
+static final byte[] ch213data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x50,(byte) 0x28,
+};
+
+static final BitmapCharRec ch213 = new BitmapCharRec(6,11,-1,0,8,ch213data);
+
+/* char: 0xd4 */
+
+static final byte[] ch212data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x28,(byte) 0x10,
+};
+
+static final BitmapCharRec ch212 = new BitmapCharRec(6,11,-1,0,8,ch212data);
+
+/* char: 0xd3 */
+
+static final byte[] ch211data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x10,(byte) 0x8,
+};
+
+static final BitmapCharRec ch211 = new BitmapCharRec(6,11,-1,0,8,ch211data);
+
+/* char: 0xd2 */
+
+static final byte[] ch210data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,(byte) 0x0,(byte) 0x10,(byte) 0x20,
+};
+
+static final BitmapCharRec ch210 = new BitmapCharRec(6,11,-1,0,8,ch210data);
+
+/* char: 0xd1 */
+
+static final byte[] ch209data = {
+(byte) 0x8c,(byte) 0x8c,(byte) 0x94,(byte) 0x94,(byte) 0xa4,(byte) 0xa4,(byte) 0xc4,(byte) 0xc4,(byte) 0x0,(byte) 0x50,(byte) 0x28,
+};
+
+static final BitmapCharRec ch209 = new BitmapCharRec(6,11,-1,0,8,ch209data);
+
+/* char: 0xd0 */
+
+static final byte[] ch208data = {
+(byte) 0x78,(byte) 0x44,(byte) 0x42,(byte) 0x42,(byte) 0xf2,(byte) 0x42,(byte) 0x44,(byte) 0x78,
+};
+
+static final BitmapCharRec ch208 = new BitmapCharRec(7,8,0,0,8,ch208data);
+
+/* char: 0xcf */
+
+static final byte[] ch207data = {
+(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0xa0,
+};
+
+static final BitmapCharRec ch207 = new BitmapCharRec(3,10,0,0,3,ch207data);
+
+/* char: 0xce */
+
+static final byte[] ch206data = {
+(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0xa0,(byte) 0x40,
+};
+
+static final BitmapCharRec ch206 = new BitmapCharRec(3,11,0,0,3,ch206data);
+
+/* char: 0xcd */
+
+static final byte[] ch205data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80,(byte) 0x40,
+};
+
+static final BitmapCharRec ch205 = new BitmapCharRec(2,11,-1,0,3,ch205data);
+
+/* char: 0xcc */
+
+static final byte[] ch204data = {
+(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0x40,(byte) 0x80,
+};
+
+static final BitmapCharRec ch204 = new BitmapCharRec(2,11,0,0,3,ch204data);
+
+/* char: 0xcb */
+
+static final byte[] ch203data = {
+(byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x0,(byte) 0x50,
+};
+
+static final BitmapCharRec ch203 = new BitmapCharRec(5,10,-1,0,7,ch203data);
+
+/* char: 0xca */
+
+static final byte[] ch202data = {
+(byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x0,(byte) 0x50,(byte) 0x20,
+};
+
+static final BitmapCharRec ch202 = new BitmapCharRec(5,11,-1,0,7,ch202data);
+
+/* char: 0xc9 */
+
+static final byte[] ch201data = {
+(byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x0,(byte) 0x20,(byte) 0x10,
+};
+
+static final BitmapCharRec ch201 = new BitmapCharRec(5,11,-1,0,7,ch201data);
+
+/* char: 0xc8 */
+
+static final byte[] ch200data = {
+(byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x0,(byte) 0x20,(byte) 0x40,
+};
+
+static final BitmapCharRec ch200 = new BitmapCharRec(5,11,-1,0,7,ch200data);
+
+/* char: 0xc7 */
+
+static final byte[] ch199data = {
+(byte) 0x30,(byte) 0x10,(byte) 0x78,(byte) 0x84,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x84,(byte) 0x78,
+};
+
+static final BitmapCharRec ch199 = new BitmapCharRec(6,10,-1,2,8,ch199data);
+
+/* char: 0xc6 */
+
+static final byte[] ch198data = {
+(byte) 0x8f,(byte) 0x80,(byte) 0x88,(byte) 0x0,(byte) 0x78,(byte) 0x0,(byte) 0x48,(byte) 0x0,(byte) 0x2f,(byte) 0x80,(byte) 0x28,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0x1f,(byte) 0x80,
+};
+
+static final BitmapCharRec ch198 = new BitmapCharRec(9,8,0,0,10,ch198data);
+
+/* char: 0xc5 */
+
+static final byte[] ch197data = {
+(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x28,(byte) 0x28,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x10,
+};
+
+static final BitmapCharRec ch197 = new BitmapCharRec(7,11,0,0,7,ch197data);
+
+/* char: 0xc4 */
+
+static final byte[] ch196data = {
+(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x28,(byte) 0x28,(byte) 0x10,(byte) 0x10,(byte) 0x0,(byte) 0x28,
+};
+
+static final BitmapCharRec ch196 = new BitmapCharRec(7,10,0,0,7,ch196data);
+
+/* char: 0xc3 */
+
+static final byte[] ch195data = {
+(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x28,(byte) 0x28,(byte) 0x10,(byte) 0x10,(byte) 0x0,(byte) 0x28,(byte) 0x14,
+};
+
+static final BitmapCharRec ch195 = new BitmapCharRec(7,11,0,0,7,ch195data);
+
+/* char: 0xc2 */
+
+static final byte[] ch194data = {
+(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x28,(byte) 0x28,(byte) 0x10,(byte) 0x10,(byte) 0x0,(byte) 0x28,(byte) 0x10,
+};
+
+static final BitmapCharRec ch194 = new BitmapCharRec(7,11,0,0,7,ch194data);
+
+/* char: 0xc1 */
+
+static final byte[] ch193data = {
+(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x28,(byte) 0x28,(byte) 0x10,(byte) 0x10,(byte) 0x0,(byte) 0x10,(byte) 0x8,
+};
+
+static final BitmapCharRec ch193 = new BitmapCharRec(7,11,0,0,7,ch193data);
+
+/* char: 0xc0 */
+
+static final byte[] ch192data = {
+(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x28,(byte) 0x28,(byte) 0x10,(byte) 0x10,(byte) 0x0,(byte) 0x10,(byte) 0x20,
+};
+
+static final BitmapCharRec ch192 = new BitmapCharRec(7,11,0,0,7,ch192data);
+
+/* char: 0xbf */
+
+static final byte[] ch191data = {
+(byte) 0x60,(byte) 0x90,(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x0,(byte) 0x20,
+};
+
+static final BitmapCharRec ch191 = new BitmapCharRec(4,8,-1,2,6,ch191data);
+
+/* char: 0xbe */
+
+static final byte[] ch190data = {
+(byte) 0x21,(byte) 0x0,(byte) 0x17,(byte) 0x80,(byte) 0x13,(byte) 0x0,(byte) 0x9,(byte) 0x0,(byte) 0xc8,(byte) 0x0,(byte) 0x24,(byte) 0x0,(byte) 0x44,(byte) 0x0,(byte) 0xe2,(byte) 0x0,
+};
+
+static final BitmapCharRec ch190 = new BitmapCharRec(9,8,0,0,9,ch190data);
+
+/* char: 0xbd */
+
+static final byte[] ch189data = {
+(byte) 0x27,(byte) 0x12,(byte) 0x15,(byte) 0xb,(byte) 0x48,(byte) 0x44,(byte) 0xc4,(byte) 0x42,
+};
+
+static final BitmapCharRec ch189 = new BitmapCharRec(8,8,0,0,9,ch189data);
+
+/* char: 0xbc */
+
+static final byte[] ch188data = {
+(byte) 0x21,(byte) 0x0,(byte) 0x17,(byte) 0x80,(byte) 0x13,(byte) 0x0,(byte) 0x9,(byte) 0x0,(byte) 0x48,(byte) 0x0,(byte) 0x44,(byte) 0x0,(byte) 0xc4,(byte) 0x0,(byte) 0x42,(byte) 0x0,
+};
+
+static final BitmapCharRec ch188 = new BitmapCharRec(9,8,0,0,9,ch188data);
+
+/* char: 0xbb */
+
+static final byte[] ch187data = {
+(byte) 0xa0,(byte) 0x50,(byte) 0x28,(byte) 0x50,(byte) 0xa0,
+};
+
+static final BitmapCharRec ch187 = new BitmapCharRec(5,5,0,0,6,ch187data);
+
+/* char: 0xba */
+
+static final byte[] ch186data = {
+(byte) 0xe0,(byte) 0x0,(byte) 0xe0,(byte) 0xa0,(byte) 0xe0,
+};
+
+static final BitmapCharRec ch186 = new BitmapCharRec(3,5,0,-3,4,ch186data);
+
+/* char: 0xb9 */
+
+static final byte[] ch185data = {
+(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x40,
+};
+
+static final BitmapCharRec ch185 = new BitmapCharRec(2,4,0,-3,3,ch185data);
+
+/* char: 0xb8 */
+
+static final byte[] ch184data = {
+(byte) 0xc0,(byte) 0x40,
+};
+
+static final BitmapCharRec ch184 = new BitmapCharRec(2,2,0,2,3,ch184data);
+
+/* char: 0xb7 */
+
+static final byte[] ch183data = {
+(byte) 0xc0,
+};
+
+static final BitmapCharRec ch183 = new BitmapCharRec(2,1,0,-3,3,ch183data);
+
+/* char: 0xb6 */
+
+static final byte[] ch182data = {
+(byte) 0x28,(byte) 0x28,(byte) 0x28,(byte) 0x28,(byte) 0x28,(byte) 0x68,(byte) 0xe8,(byte) 0xe8,(byte) 0xe8,(byte) 0x7c,
+};
+
+static final BitmapCharRec ch182 = new BitmapCharRec(6,10,0,2,6,ch182data);
+
+/* char: 0xb5 */
+
+static final byte[] ch181data = {
+(byte) 0x80,(byte) 0x80,(byte) 0xf0,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,
+};
+
+static final BitmapCharRec ch181 = new BitmapCharRec(4,8,0,2,5,ch181data);
+
+/* char: 0xb4 */
+
+static final byte[] ch180data = {
+(byte) 0x80,(byte) 0x40,
+};
+
+static final BitmapCharRec ch180 = new BitmapCharRec(2,2,0,-6,3,ch180data);
+
+/* char: 0xb3 */
+
+static final byte[] ch179data = {
+(byte) 0xc0,(byte) 0x20,(byte) 0x40,(byte) 0xe0,
+};
+
+static final BitmapCharRec ch179 = new BitmapCharRec(3,4,0,-3,3,ch179data);
+
+/* char: 0xb2 */
+
+static final byte[] ch178data = {
+(byte) 0xe0,(byte) 0x40,(byte) 0xa0,(byte) 0x60,
+};
+
+static final BitmapCharRec ch178 = new BitmapCharRec(3,4,0,-3,3,ch178data);
+
+/* char: 0xb1 */
+
+static final byte[] ch177data = {
+(byte) 0xf8,(byte) 0x0,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0x20,
+};
+
+static final BitmapCharRec ch177 = new BitmapCharRec(5,7,0,0,6,ch177data);
+
+/* char: 0xb0 */
+
+static final byte[] ch176data = {
+(byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x60,
+};
+
+static final BitmapCharRec ch176 = new BitmapCharRec(4,4,0,-3,4,ch176data);
+
+/* char: 0xaf */
+
+static final byte[] ch175data = {
+(byte) 0xe0,
+};
+
+static final BitmapCharRec ch175 = new BitmapCharRec(3,1,0,-7,3,ch175data);
+
+/* char: 0xae */
+
+static final byte[] ch174data = {
+(byte) 0x38,(byte) 0x44,(byte) 0xaa,(byte) 0xb2,(byte) 0xba,(byte) 0x44,(byte) 0x38,
+};
+
+static final BitmapCharRec ch174 = new BitmapCharRec(7,7,-1,0,9,ch174data);
+
+/* char: 0xad */
+
+static final byte[] ch173data = {
+(byte) 0xe0,
+};
+
+static final BitmapCharRec ch173 = new BitmapCharRec(3,1,0,-3,4,ch173data);
+
+/* char: 0xac */
+
+static final byte[] ch172data = {
+(byte) 0x8,(byte) 0x8,(byte) 0xf8,
+};
+
+static final BitmapCharRec ch172 = new BitmapCharRec(5,3,-1,-2,7,ch172data);
+
+/* char: 0xab */
+
+static final byte[] ch171data = {
+(byte) 0x28,(byte) 0x50,(byte) 0xa0,(byte) 0x50,(byte) 0x28,
+};
+
+static final BitmapCharRec ch171 = new BitmapCharRec(5,5,0,0,6,ch171data);
+
+/* char: 0xaa */
+
+static final byte[] ch170data = {
+(byte) 0xe0,(byte) 0x0,(byte) 0xa0,(byte) 0x20,(byte) 0xe0,
+};
+
+static final BitmapCharRec ch170 = new BitmapCharRec(3,5,0,-3,4,ch170data);
+
+/* char: 0xa9 */
+
+static final byte[] ch169data = {
+(byte) 0x38,(byte) 0x44,(byte) 0x9a,(byte) 0xa2,(byte) 0x9a,(byte) 0x44,(byte) 0x38,
+};
+
+static final BitmapCharRec ch169 = new BitmapCharRec(7,7,-1,0,9,ch169data);
+
+/* char: 0xa8 */
+
+static final byte[] ch168data = {
+(byte) 0xa0,
+};
+
+static final BitmapCharRec ch168 = new BitmapCharRec(3,1,0,-7,3,ch168data);
+
+/* char: 0xa7 */
+
+static final byte[] ch167data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x18,(byte) 0x70,(byte) 0xc8,(byte) 0x98,(byte) 0x70,(byte) 0xc0,(byte) 0x88,(byte) 0x70,
+};
+
+static final BitmapCharRec ch167 = new BitmapCharRec(5,10,0,2,6,ch167data);
+
+/* char: 0xa6 */
+
+static final byte[] ch166data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch166 = new BitmapCharRec(1,10,-1,2,3,ch166data);
+
+/* char: 0xa5 */
+
+static final byte[] ch165data = {
+(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0xf8,(byte) 0x50,(byte) 0x50,(byte) 0x88,(byte) 0x88,
+};
+
+static final BitmapCharRec ch165 = new BitmapCharRec(5,8,0,0,6,ch165data);
+
+/* char: 0xa4 */
+
+static final byte[] ch164data = {
+(byte) 0x90,(byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x60,(byte) 0x90,
+};
+
+static final BitmapCharRec ch164 = new BitmapCharRec(4,6,0,-1,5,ch164data);
+
+/* char: 0xa3 */
+
+static final byte[] ch163data = {
+(byte) 0xb0,(byte) 0x48,(byte) 0x40,(byte) 0x40,(byte) 0xe0,(byte) 0x40,(byte) 0x48,(byte) 0x30,
+};
+
+static final BitmapCharRec ch163 = new BitmapCharRec(5,8,0,0,6,ch163data);
+
+/* char: 0xa2 */
+
+static final byte[] ch162data = {
+(byte) 0x40,(byte) 0x70,(byte) 0xa8,(byte) 0xa0,(byte) 0xa0,(byte) 0xa8,(byte) 0x70,(byte) 0x10,
+};
+
+static final BitmapCharRec ch162 = new BitmapCharRec(5,8,0,1,6,ch162data);
+
+/* char: 0xa1 */
+
+static final byte[] ch161data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80,
+};
+
+static final BitmapCharRec ch161 = new BitmapCharRec(1,8,-1,2,3,ch161data);
+
+/* char: 0xa0 */
+
+static final BitmapCharRec ch160 = new BitmapCharRec(0,0,0,0,3,null);
+
+/* char: 0x7e '~' */
+
+static final byte[] ch126data = {
+(byte) 0x98,(byte) 0x64,
+};
+
+static final BitmapCharRec ch126 = new BitmapCharRec(6,2,0,-3,7,ch126data);
+
+/* char: 0x7d '}' */
+
+static final byte[] ch125data = {
+(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x80,
+};
+
+static final BitmapCharRec ch125 = new BitmapCharRec(3,10,0,2,3,ch125data);
+
+/* char: 0x7c '|' */
+
+static final byte[] ch124data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch124 = new BitmapCharRec(1,10,-1,2,3,ch124data);
+
+/* char: 0x7b '{' */
+
+static final byte[] ch123data = {
+(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x20,
+};
+
+static final BitmapCharRec ch123 = new BitmapCharRec(3,10,0,2,3,ch123data);
+
+/* char: 0x7a 'z' */
+
+static final byte[] ch122data = {
+(byte) 0xf0,(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0xf0,
+};
+
+static final BitmapCharRec ch122 = new BitmapCharRec(4,6,0,0,5,ch122data);
+
+/* char: 0x79 'y' */
+
+static final byte[] ch121data = {
+(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x60,(byte) 0xa0,(byte) 0xa0,(byte) 0x90,(byte) 0x90,
+};
+
+static final BitmapCharRec ch121 = new BitmapCharRec(4,8,0,2,5,ch121data);
+
+/* char: 0x78 'x' */
+
+static final byte[] ch120data = {
+(byte) 0x88,(byte) 0x88,(byte) 0x50,(byte) 0x20,(byte) 0x50,(byte) 0x88,
+};
+
+static final BitmapCharRec ch120 = new BitmapCharRec(5,6,0,0,6,ch120data);
+
+/* char: 0x77 'w' */
+
+static final byte[] ch119data = {
+(byte) 0x28,(byte) 0x28,(byte) 0x54,(byte) 0x54,(byte) 0x92,(byte) 0x92,
+};
+
+static final BitmapCharRec ch119 = new BitmapCharRec(7,6,0,0,8,ch119data);
+
+/* char: 0x76 'v' */
+
+static final byte[] ch118data = {
+(byte) 0x20,(byte) 0x20,(byte) 0x50,(byte) 0x50,(byte) 0x88,(byte) 0x88,
+};
+
+static final BitmapCharRec ch118 = new BitmapCharRec(5,6,0,0,6,ch118data);
+
+/* char: 0x75 'u' */
+
+static final byte[] ch117data = {
+(byte) 0x70,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,
+};
+
+static final BitmapCharRec ch117 = new BitmapCharRec(4,6,0,0,5,ch117data);
+
+/* char: 0x74 't' */
+
+static final byte[] ch116data = {
+(byte) 0x60,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xe0,(byte) 0x40,(byte) 0x40,
+};
+
+static final BitmapCharRec ch116 = new BitmapCharRec(3,8,0,0,4,ch116data);
+
+/* char: 0x73 's' */
+
+static final byte[] ch115data = {
+(byte) 0x60,(byte) 0x90,(byte) 0x10,(byte) 0x60,(byte) 0x90,(byte) 0x60,
+};
+
+static final BitmapCharRec ch115 = new BitmapCharRec(4,6,0,0,5,ch115data);
+
+/* char: 0x72 'r' */
+
+static final byte[] ch114data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xc0,(byte) 0xa0,
+};
+
+static final BitmapCharRec ch114 = new BitmapCharRec(3,6,0,0,4,ch114data);
+
+/* char: 0x71 'q' */
+
+static final byte[] ch113data = {
+(byte) 0x8,(byte) 0x8,(byte) 0x68,(byte) 0x98,(byte) 0x88,(byte) 0x88,(byte) 0x98,(byte) 0x68,
+};
+
+static final BitmapCharRec ch113 = new BitmapCharRec(5,8,0,2,6,ch113data);
+
+/* char: 0x70 'p' */
+
+static final byte[] ch112data = {
+(byte) 0x80,(byte) 0x80,(byte) 0xb0,(byte) 0xc8,(byte) 0x88,(byte) 0x88,(byte) 0xc8,(byte) 0xb0,
+};
+
+static final BitmapCharRec ch112 = new BitmapCharRec(5,8,0,2,6,ch112data);
+
+/* char: 0x6f 'o' */
+
+static final byte[] ch111data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,
+};
+
+static final BitmapCharRec ch111 = new BitmapCharRec(5,6,0,0,6,ch111data);
+
+/* char: 0x6e 'n' */
+
+static final byte[] ch110data = {
+(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0xc8,(byte) 0xb0,
+};
+
+static final BitmapCharRec ch110 = new BitmapCharRec(5,6,0,0,6,ch110data);
+
+/* char: 0x6d 'm' */
+
+static final byte[] ch109data = {
+(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0xec,
+};
+
+static final BitmapCharRec ch109 = new BitmapCharRec(7,6,0,0,8,ch109data);
+
+/* char: 0x6c 'l' */
+
+static final byte[] ch108data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch108 = new BitmapCharRec(1,8,0,0,2,ch108data);
+
+/* char: 0x6b 'k' */
+
+static final byte[] ch107data = {
+(byte) 0x90,(byte) 0x90,(byte) 0xa0,(byte) 0xc0,(byte) 0xa0,(byte) 0x90,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch107 = new BitmapCharRec(4,8,0,0,5,ch107data);
+
+/* char: 0x6a 'j' */
+
+static final byte[] ch106data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80,
+};
+
+static final BitmapCharRec ch106 = new BitmapCharRec(1,9,0,1,2,ch106data);
+
+/* char: 0x69 'i' */
+
+static final byte[] ch105data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80,
+};
+
+static final BitmapCharRec ch105 = new BitmapCharRec(1,8,0,0,2,ch105data);
+
+/* char: 0x68 'h' */
+
+static final byte[] ch104data = {
+(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0xc8,(byte) 0xb0,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch104 = new BitmapCharRec(5,8,0,0,6,ch104data);
+
+/* char: 0x67 'g' */
+
+static final byte[] ch103data = {
+(byte) 0x70,(byte) 0x8,(byte) 0x68,(byte) 0x98,(byte) 0x88,(byte) 0x88,(byte) 0x98,(byte) 0x68,
+};
+
+static final BitmapCharRec ch103 = new BitmapCharRec(5,8,0,2,6,ch103data);
+
+/* char: 0x66 'f' */
+
+static final byte[] ch102data = {
+(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xe0,(byte) 0x40,(byte) 0x30,
+};
+
+static final BitmapCharRec ch102 = new BitmapCharRec(4,8,0,0,4,ch102data);
+
+/* char: 0x65 'e' */
+
+static final byte[] ch101data = {
+(byte) 0x60,(byte) 0x90,(byte) 0x80,(byte) 0xf0,(byte) 0x90,(byte) 0x60,
+};
+
+static final BitmapCharRec ch101 = new BitmapCharRec(4,6,0,0,5,ch101data);
+
+/* char: 0x64 'd' */
+
+static final byte[] ch100data = {
+(byte) 0x68,(byte) 0x98,(byte) 0x88,(byte) 0x88,(byte) 0x98,(byte) 0x68,(byte) 0x8,(byte) 0x8,
+};
+
+static final BitmapCharRec ch100 = new BitmapCharRec(5,8,0,0,6,ch100data);
+
+/* char: 0x63 'c' */
+
+static final byte[] ch99data = {
+(byte) 0x60,(byte) 0x90,(byte) 0x80,(byte) 0x80,(byte) 0x90,(byte) 0x60,
+};
+
+static final BitmapCharRec ch99 = new BitmapCharRec(4,6,0,0,5,ch99data);
+
+/* char: 0x62 'b' */
+
+static final byte[] ch98data = {
+(byte) 0xb0,(byte) 0xc8,(byte) 0x88,(byte) 0x88,(byte) 0xc8,(byte) 0xb0,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch98 = new BitmapCharRec(5,8,0,0,6,ch98data);
+
+/* char: 0x61 'a' */
+
+static final byte[] ch97data = {
+(byte) 0x68,(byte) 0x90,(byte) 0x90,(byte) 0x70,(byte) 0x10,(byte) 0xe0,
+};
+
+static final BitmapCharRec ch97 = new BitmapCharRec(5,6,0,0,5,ch97data);
+
+/* char: 0x60 '`' */
+
+static final byte[] ch96data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x40,
+};
+
+static final BitmapCharRec ch96 = new BitmapCharRec(2,3,0,-5,3,ch96data);
+
+/* char: 0x5f '_' */
+
+static final byte[] ch95data = {
+(byte) 0xfc,
+};
+
+static final BitmapCharRec ch95 = new BitmapCharRec(6,1,0,2,6,ch95data);
+
+/* char: 0x5e '^' */
+
+static final byte[] ch94data = {
+(byte) 0x88,(byte) 0x50,(byte) 0x50,(byte) 0x20,(byte) 0x20,
+};
+
+static final BitmapCharRec ch94 = new BitmapCharRec(5,5,0,-3,6,ch94data);
+
+/* char: 0x5d ']' */
+
+static final byte[] ch93data = {
+(byte) 0xc0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch93 = new BitmapCharRec(2,10,0,2,3,ch93data);
+
+/* char: 0x5c '\' */
+
+static final byte[] ch92data = {
+(byte) 0x20,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch92 = new BitmapCharRec(3,8,0,0,3,ch92data);
+
+/* char: 0x5b '[' */
+
+static final byte[] ch91data = {
+(byte) 0xc0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch91 = new BitmapCharRec(2,10,-1,2,3,ch91data);
+
+/* char: 0x5a 'Z' */
+
+static final byte[] ch90data = {
+(byte) 0xf8,(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x10,(byte) 0x8,(byte) 0xf8,
+};
+
+static final BitmapCharRec ch90 = new BitmapCharRec(5,8,-1,0,7,ch90data);
+
+/* char: 0x59 'Y' */
+
+static final byte[] ch89data = {
+(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x28,(byte) 0x44,(byte) 0x44,(byte) 0x82,
+};
+
+static final BitmapCharRec ch89 = new BitmapCharRec(7,8,0,0,7,ch89data);
+
+/* char: 0x58 'X' */
+
+static final byte[] ch88data = {
+(byte) 0x88,(byte) 0x88,(byte) 0x50,(byte) 0x50,(byte) 0x20,(byte) 0x50,(byte) 0x88,(byte) 0x88,
+};
+
+static final BitmapCharRec ch88 = new BitmapCharRec(5,8,-1,0,7,ch88data);
+
+/* char: 0x57 'W' */
+
+static final byte[] ch87data = {
+(byte) 0x22,(byte) 0x0,(byte) 0x22,(byte) 0x0,(byte) 0x22,(byte) 0x0,(byte) 0x55,(byte) 0x0,(byte) 0x49,(byte) 0x0,(byte) 0x49,(byte) 0x0,(byte) 0x88,(byte) 0x80,(byte) 0x88,(byte) 0x80,
+};
+
+static final BitmapCharRec ch87 = new BitmapCharRec(9,8,0,0,9,ch87data);
+
+/* char: 0x56 'V' */
+
+static final byte[] ch86data = {
+(byte) 0x10,(byte) 0x28,(byte) 0x28,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0x82,(byte) 0x82,
+};
+
+static final BitmapCharRec ch86 = new BitmapCharRec(7,8,0,0,7,ch86data);
+
+/* char: 0x55 'U' */
+
+static final byte[] ch85data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,
+};
+
+static final BitmapCharRec ch85 = new BitmapCharRec(6,8,-1,0,8,ch85data);
+
+/* char: 0x54 'T' */
+
+static final byte[] ch84data = {
+(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xf8,
+};
+
+static final BitmapCharRec ch84 = new BitmapCharRec(5,8,0,0,5,ch84data);
+
+/* char: 0x53 'S' */
+
+static final byte[] ch83data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x8,(byte) 0x70,(byte) 0x80,(byte) 0x88,(byte) 0x70,
+};
+
+static final BitmapCharRec ch83 = new BitmapCharRec(5,8,-1,0,7,ch83data);
+
+/* char: 0x52 'R' */
+
+static final byte[] ch82data = {
+(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0xf0,(byte) 0x88,(byte) 0x88,(byte) 0xf0,
+};
+
+static final BitmapCharRec ch82 = new BitmapCharRec(5,8,-1,0,7,ch82data);
+
+/* char: 0x51 'Q' */
+
+static final byte[] ch81data = {
+(byte) 0x2,(byte) 0x7c,(byte) 0x8c,(byte) 0x94,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,
+};
+
+static final BitmapCharRec ch81 = new BitmapCharRec(7,9,-1,1,8,ch81data);
+
+/* char: 0x50 'P' */
+
+static final byte[] ch80data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf0,(byte) 0x88,(byte) 0x88,(byte) 0xf0,
+};
+
+static final BitmapCharRec ch80 = new BitmapCharRec(5,8,-1,0,7,ch80data);
+
+/* char: 0x4f 'O' */
+
+static final byte[] ch79data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x78,
+};
+
+static final BitmapCharRec ch79 = new BitmapCharRec(6,8,-1,0,8,ch79data);
+
+/* char: 0x4e 'N' */
+
+static final byte[] ch78data = {
+(byte) 0x8c,(byte) 0x8c,(byte) 0x94,(byte) 0x94,(byte) 0xa4,(byte) 0xa4,(byte) 0xc4,(byte) 0xc4,
+};
+
+static final BitmapCharRec ch78 = new BitmapCharRec(6,8,-1,0,8,ch78data);
+
+/* char: 0x4d 'M' */
+
+static final byte[] ch77data = {
+(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0xaa,(byte) 0xaa,(byte) 0xc6,(byte) 0xc6,(byte) 0x82,
+};
+
+static final BitmapCharRec ch77 = new BitmapCharRec(7,8,-1,0,9,ch77data);
+
+/* char: 0x4c 'L' */
+
+static final byte[] ch76data = {
+(byte) 0xf0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch76 = new BitmapCharRec(4,8,-1,0,6,ch76data);
+
+/* char: 0x4b 'K' */
+
+static final byte[] ch75data = {
+(byte) 0x88,(byte) 0x88,(byte) 0x90,(byte) 0x90,(byte) 0xe0,(byte) 0xa0,(byte) 0x90,(byte) 0x88,
+};
+
+static final BitmapCharRec ch75 = new BitmapCharRec(5,8,-1,0,7,ch75data);
+
+/* char: 0x4a 'J' */
+
+static final byte[] ch74data = {
+(byte) 0x60,(byte) 0x90,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,
+};
+
+static final BitmapCharRec ch74 = new BitmapCharRec(4,8,0,0,5,ch74data);
+
+/* char: 0x49 'I' */
+
+static final byte[] ch73data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch73 = new BitmapCharRec(1,8,-1,0,3,ch73data);
+
+/* char: 0x48 'H' */
+
+static final byte[] ch72data = {
+(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xfc,(byte) 0x84,(byte) 0x84,(byte) 0x84,
+};
+
+static final BitmapCharRec ch72 = new BitmapCharRec(6,8,-1,0,8,ch72data);
+
+/* char: 0x47 'G' */
+
+static final byte[] ch71data = {
+(byte) 0x74,(byte) 0x8c,(byte) 0x84,(byte) 0x8c,(byte) 0x80,(byte) 0x80,(byte) 0x84,(byte) 0x78,
+};
+
+static final BitmapCharRec ch71 = new BitmapCharRec(6,8,-1,0,8,ch71data);
+
+/* char: 0x46 'F' */
+
+static final byte[] ch70data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf0,(byte) 0x80,(byte) 0x80,(byte) 0xf8,
+};
+
+static final BitmapCharRec ch70 = new BitmapCharRec(5,8,-1,0,6,ch70data);
+
+/* char: 0x45 'E' */
+
+static final byte[] ch69data = {
+(byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0xf8,
+};
+
+static final BitmapCharRec ch69 = new BitmapCharRec(5,8,-1,0,7,ch69data);
+
+/* char: 0x44 'D' */
+
+static final byte[] ch68data = {
+(byte) 0xf0,(byte) 0x88,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x88,(byte) 0xf0,
+};
+
+static final BitmapCharRec ch68 = new BitmapCharRec(6,8,-1,0,8,ch68data);
+
+/* char: 0x43 'C' */
+
+static final byte[] ch67data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x84,(byte) 0x78,
+};
+
+static final BitmapCharRec ch67 = new BitmapCharRec(6,8,-1,0,8,ch67data);
+
+/* char: 0x42 'B' */
+
+static final byte[] ch66data = {
+(byte) 0xf0,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0xf0,(byte) 0x88,(byte) 0x88,(byte) 0xf0,
+};
+
+static final BitmapCharRec ch66 = new BitmapCharRec(5,8,-1,0,7,ch66data);
+
+/* char: 0x41 'A' */
+
+static final byte[] ch65data = {
+(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x28,(byte) 0x28,(byte) 0x10,(byte) 0x10,
+};
+
+static final BitmapCharRec ch65 = new BitmapCharRec(7,8,0,0,7,ch65data);
+
+/* char: 0x40 '@' */
+
+static final byte[] ch64data = {
+(byte) 0x3e,(byte) 0x0,(byte) 0x40,(byte) 0x0,(byte) 0x9b,(byte) 0x0,(byte) 0xa4,(byte) 0x80,(byte) 0xa4,(byte) 0x80,(byte) 0xa2,(byte) 0x40,(byte) 0x92,(byte) 0x40,(byte) 0x4d,(byte) 0x40,
+(byte) 0x20,(byte) 0x80,(byte) 0x1f,(byte) 0x0,
+};
+
+static final BitmapCharRec ch64 = new BitmapCharRec(10,10,0,2,11,ch64data);
+
+/* char: 0x3f '?' */
+
+static final byte[] ch63data = {
+(byte) 0x40,(byte) 0x0,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x90,(byte) 0x60,
+};
+
+static final BitmapCharRec ch63 = new BitmapCharRec(4,8,-1,0,6,ch63data);
+
+/* char: 0x3e '>' */
+
+static final byte[] ch62data = {
+(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x40,(byte) 0x80,
+};
+
+static final BitmapCharRec ch62 = new BitmapCharRec(3,5,-1,-1,6,ch62data);
+
+/* char: 0x3d '=' */
+
+static final byte[] ch61data = {
+(byte) 0xf0,(byte) 0x0,(byte) 0xf0,
+};
+
+static final BitmapCharRec ch61 = new BitmapCharRec(4,3,0,-2,5,ch61data);
+
+/* char: 0x3c '<' */
+
+static final byte[] ch60data = {
+(byte) 0x20,(byte) 0x40,(byte) 0x80,(byte) 0x40,(byte) 0x20,
+};
+
+static final BitmapCharRec ch60 = new BitmapCharRec(3,5,-1,-1,6,ch60data);
+
+/* char: 0x3b ';' */
+
+static final byte[] ch59data = {
+(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x40,
+};
+
+static final BitmapCharRec ch59 = new BitmapCharRec(2,8,0,2,3,ch59data);
+
+/* char: 0x3a ':' */
+
+static final byte[] ch58data = {
+(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x80,
+};
+
+static final BitmapCharRec ch58 = new BitmapCharRec(1,6,-1,0,3,ch58data);
+
+/* char: 0x39 '9' */
+
+static final byte[] ch57data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x8,(byte) 0x68,(byte) 0x98,(byte) 0x88,(byte) 0x88,(byte) 0x70,
+};
+
+static final BitmapCharRec ch57 = new BitmapCharRec(5,8,0,0,6,ch57data);
+
+/* char: 0x38 '8' */
+
+static final byte[] ch56data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x70,
+};
+
+static final BitmapCharRec ch56 = new BitmapCharRec(5,8,0,0,6,ch56data);
+
+/* char: 0x37 '7' */
+
+static final byte[] ch55data = {
+(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x10,(byte) 0x10,(byte) 0x8,(byte) 0xf8,
+};
+
+static final BitmapCharRec ch55 = new BitmapCharRec(5,8,0,0,6,ch55data);
+
+/* char: 0x36 '6' */
+
+static final byte[] ch54data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0xc8,(byte) 0xb0,(byte) 0x80,(byte) 0x88,(byte) 0x70,
+};
+
+static final BitmapCharRec ch54 = new BitmapCharRec(5,8,0,0,6,ch54data);
+
+/* char: 0x35 '5' */
+
+static final byte[] ch53data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x8,(byte) 0x8,(byte) 0xf0,(byte) 0x80,(byte) 0x80,(byte) 0xf8,
+};
+
+static final BitmapCharRec ch53 = new BitmapCharRec(5,8,0,0,6,ch53data);
+
+/* char: 0x34 '4' */
+
+static final byte[] ch52data = {
+(byte) 0x10,(byte) 0x10,(byte) 0xf8,(byte) 0x90,(byte) 0x50,(byte) 0x50,(byte) 0x30,(byte) 0x10,
+};
+
+static final BitmapCharRec ch52 = new BitmapCharRec(5,8,0,0,6,ch52data);
+
+/* char: 0x33 '3' */
+
+static final byte[] ch51data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x8,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x88,(byte) 0x70,
+};
+
+static final BitmapCharRec ch51 = new BitmapCharRec(5,8,0,0,6,ch51data);
+
+/* char: 0x32 '2' */
+
+static final byte[] ch50data = {
+(byte) 0xf8,(byte) 0x80,(byte) 0x40,(byte) 0x30,(byte) 0x8,(byte) 0x8,(byte) 0x88,(byte) 0x70,
+};
+
+static final BitmapCharRec ch50 = new BitmapCharRec(5,8,0,0,6,ch50data);
+
+/* char: 0x31 '1' */
+
+static final byte[] ch49data = {
+(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x40,
+};
+
+static final BitmapCharRec ch49 = new BitmapCharRec(2,8,-1,0,6,ch49data);
+
+/* char: 0x30 '0' */
+
+static final byte[] ch48data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,
+};
+
+static final BitmapCharRec ch48 = new BitmapCharRec(5,8,0,0,6,ch48data);
+
+/* char: 0x2f '/' */
+
+static final byte[] ch47data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20,
+};
+
+static final BitmapCharRec ch47 = new BitmapCharRec(3,8,0,0,3,ch47data);
+
+/* char: 0x2e '.' */
+
+static final byte[] ch46data = {
+(byte) 0x80,
+};
+
+static final BitmapCharRec ch46 = new BitmapCharRec(1,1,-1,0,3,ch46data);
+
+/* char: 0x2d '-' */
+
+static final byte[] ch45data = {
+(byte) 0xf8,
+};
+
+static final BitmapCharRec ch45 = new BitmapCharRec(5,1,-1,-3,7,ch45data);
+
+/* char: 0x2c ',' */
+
+static final byte[] ch44data = {
+(byte) 0x80,(byte) 0x40,(byte) 0x40,
+};
+
+static final BitmapCharRec ch44 = new BitmapCharRec(2,3,0,2,3,ch44data);
+
+/* char: 0x2b '+' */
+
+static final byte[] ch43data = {
+(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0x20,
+};
+
+static final BitmapCharRec ch43 = new BitmapCharRec(5,5,0,-1,6,ch43data);
+
+/* char: 0x2a '*' */
+
+static final byte[] ch42data = {
+(byte) 0xa0,(byte) 0x40,(byte) 0xa0,
+};
+
+static final BitmapCharRec ch42 = new BitmapCharRec(3,3,0,-5,4,ch42data);
+
+/* char: 0x29 ')' */
+
+static final byte[] ch41data = {
+(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x80,
+};
+
+static final BitmapCharRec ch41 = new BitmapCharRec(3,10,-1,2,4,ch41data);
+
+/* char: 0x28 '(' */
+
+static final byte[] ch40data = {
+(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x20,
+};
+
+static final BitmapCharRec ch40 = new BitmapCharRec(3,10,0,2,4,ch40data);
+
+/* char: 0x27 ''' */
+
+static final byte[] ch39data = {
+(byte) 0x80,(byte) 0x40,(byte) 0x40,
+};
+
+static final BitmapCharRec ch39 = new BitmapCharRec(2,3,-1,-5,3,ch39data);
+
+/* char: 0x26 '&' */
+
+static final byte[] ch38data = {
+(byte) 0x64,(byte) 0x98,(byte) 0x98,(byte) 0xa4,(byte) 0x60,(byte) 0x50,(byte) 0x50,(byte) 0x20,
+};
+
+static final BitmapCharRec ch38 = new BitmapCharRec(6,8,-1,0,8,ch38data);
+
+/* char: 0x25 '%' */
+
+static final byte[] ch37data = {
+(byte) 0x26,(byte) 0x29,(byte) 0x16,(byte) 0x10,(byte) 0x8,(byte) 0x68,(byte) 0x94,(byte) 0x64,
+};
+
+static final BitmapCharRec ch37 = new BitmapCharRec(8,8,0,0,9,ch37data);
+
+/* char: 0x24 '$' */
+
+static final byte[] ch36data = {
+(byte) 0x20,(byte) 0x70,(byte) 0xa8,(byte) 0x28,(byte) 0x70,(byte) 0xa0,(byte) 0xa8,(byte) 0x70,(byte) 0x20,
+};
+
+static final BitmapCharRec ch36 = new BitmapCharRec(5,9,0,1,6,ch36data);
+
+/* char: 0x23 '#' */
+
+static final byte[] ch35data = {
+(byte) 0x50,(byte) 0x50,(byte) 0xf8,(byte) 0x28,(byte) 0x7c,(byte) 0x28,(byte) 0x28,
+};
+
+static final BitmapCharRec ch35 = new BitmapCharRec(6,7,0,0,6,ch35data);
+
+/* char: 0x22 '"' */
+
+static final byte[] ch34data = {
+(byte) 0xa0,(byte) 0xa0,
+};
+
+static final BitmapCharRec ch34 = new BitmapCharRec(3,2,-1,-6,4,ch34data);
+
+/* char: 0x21 '!' */
+
+static final byte[] ch33data = {
+(byte) 0x80,(byte) 0x0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch33 = new BitmapCharRec(1,8,-1,0,3,ch33data);
+
+/* char: 0x20 ' ' */
+
+static final BitmapCharRec ch32 = new BitmapCharRec(0,0,0,0,3,null);
+
+static final BitmapCharRec[] chars = {
+ch32,
+ch33,
+ch34,
+ch35,
+ch36,
+ch37,
+ch38,
+ch39,
+ch40,
+ch41,
+ch42,
+ch43,
+ch44,
+ch45,
+ch46,
+ch47,
+ch48,
+ch49,
+ch50,
+ch51,
+ch52,
+ch53,
+ch54,
+ch55,
+ch56,
+ch57,
+ch58,
+ch59,
+ch60,
+ch61,
+ch62,
+ch63,
+ch64,
+ch65,
+ch66,
+ch67,
+ch68,
+ch69,
+ch70,
+ch71,
+ch72,
+ch73,
+ch74,
+ch75,
+ch76,
+ch77,
+ch78,
+ch79,
+ch80,
+ch81,
+ch82,
+ch83,
+ch84,
+ch85,
+ch86,
+ch87,
+ch88,
+ch89,
+ch90,
+ch91,
+ch92,
+ch93,
+ch94,
+ch95,
+ch96,
+ch97,
+ch98,
+ch99,
+ch100,
+ch101,
+ch102,
+ch103,
+ch104,
+ch105,
+ch106,
+ch107,
+ch108,
+ch109,
+ch110,
+ch111,
+ch112,
+ch113,
+ch114,
+ch115,
+ch116,
+ch117,
+ch118,
+ch119,
+ch120,
+ch121,
+ch122,
+ch123,
+ch124,
+ch125,
+ch126,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+ch160,
+ch161,
+ch162,
+ch163,
+ch164,
+ch165,
+ch166,
+ch167,
+ch168,
+ch169,
+ch170,
+ch171,
+ch172,
+ch173,
+ch174,
+ch175,
+ch176,
+ch177,
+ch178,
+ch179,
+ch180,
+ch181,
+ch182,
+ch183,
+ch184,
+ch185,
+ch186,
+ch187,
+ch188,
+ch189,
+ch190,
+ch191,
+ch192,
+ch193,
+ch194,
+ch195,
+ch196,
+ch197,
+ch198,
+ch199,
+ch200,
+ch201,
+ch202,
+ch203,
+ch204,
+ch205,
+ch206,
+ch207,
+ch208,
+ch209,
+ch210,
+ch211,
+ch212,
+ch213,
+ch214,
+ch215,
+ch216,
+ch217,
+ch218,
+ch219,
+ch220,
+ch221,
+ch222,
+ch223,
+ch224,
+ch225,
+ch226,
+ch227,
+ch228,
+ch229,
+ch230,
+ch231,
+ch232,
+ch233,
+ch234,
+ch235,
+ch236,
+ch237,
+ch238,
+ch239,
+ch240,
+ch241,
+ch242,
+ch243,
+ch244,
+ch245,
+ch246,
+ch247,
+ch248,
+ch249,
+ch250,
+ch251,
+ch252,
+ch253,
+ch254,
+ch255,
+};
+
+  public static final BitmapFontRec glutBitmapHelvetica10 = new BitmapFontRec("-adobe-helvetica-medium-r-normal--10-100-75-75-p-56-iso8859-1",
+                                                                       224,
+                                                                       32,
+                                                                       chars);
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/gl2/GLUTBitmapHelvetica12.java b/src/jogl/classes/com/jogamp/opengl/util/gl2/GLUTBitmapHelvetica12.java
new file mode 100644
index 000000000..bc86f6216
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/gl2/GLUTBitmapHelvetica12.java
@@ -0,0 +1,1808 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util.gl2;
+
+class GLUTBitmapHelvetica12 {
+
+/* GENERATED FILE -- DO NOT MODIFY */
+
+/* char: 0xff */
+
+static final byte[] ch255data = {
+(byte) 0xc0,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x30,(byte) 0x50,(byte) 0x50,(byte) 0x48,(byte) 0x88,(byte) 0x88,(byte) 0x0,(byte) 0x50,
+};
+
+static final BitmapCharRec ch255 = new BitmapCharRec(5,12,-1,3,7,ch255data);
+
+/* char: 0xfe */
+
+static final byte[] ch254data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xb0,(byte) 0xc8,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0xc8,(byte) 0xb0,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch254 = new BitmapCharRec(5,12,-1,3,7,ch254data);
+
+/* char: 0xfd */
+
+static final byte[] ch253data = {
+(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x50,(byte) 0x50,(byte) 0x90,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x0,(byte) 0x20,(byte) 0x10,
+};
+
+static final BitmapCharRec ch253 = new BitmapCharRec(5,13,-1,3,7,ch253data);
+
+/* char: 0xfc */
+
+static final byte[] ch252data = {
+(byte) 0x68,(byte) 0x98,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x0,(byte) 0x50,
+};
+
+static final BitmapCharRec ch252 = new BitmapCharRec(5,9,-1,0,7,ch252data);
+
+/* char: 0xfb */
+
+static final byte[] ch251data = {
+(byte) 0x68,(byte) 0x98,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x0,(byte) 0x50,(byte) 0x20,
+};
+
+static final BitmapCharRec ch251 = new BitmapCharRec(5,10,-1,0,7,ch251data);
+
+/* char: 0xfa */
+
+static final byte[] ch250data = {
+(byte) 0x68,(byte) 0x98,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x0,(byte) 0x20,(byte) 0x10,
+};
+
+static final BitmapCharRec ch250 = new BitmapCharRec(5,10,-1,0,7,ch250data);
+
+/* char: 0xf9 */
+
+static final byte[] ch249data = {
+(byte) 0x68,(byte) 0x98,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x0,(byte) 0x20,(byte) 0x40,
+};
+
+static final BitmapCharRec ch249 = new BitmapCharRec(5,10,-1,0,7,ch249data);
+
+/* char: 0xf8 */
+
+static final byte[] ch248data = {
+(byte) 0xb8,(byte) 0x44,(byte) 0x64,(byte) 0x54,(byte) 0x4c,(byte) 0x44,(byte) 0x3a,
+};
+
+static final BitmapCharRec ch248 = new BitmapCharRec(7,7,0,0,7,ch248data);
+
+/* char: 0xf7 */
+
+static final byte[] ch247data = {
+(byte) 0x20,(byte) 0x0,(byte) 0xf8,(byte) 0x0,(byte) 0x20,
+};
+
+static final BitmapCharRec ch247 = new BitmapCharRec(5,5,-1,-1,7,ch247data);
+
+/* char: 0xf6 */
+
+static final byte[] ch246data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x50,
+};
+
+static final BitmapCharRec ch246 = new BitmapCharRec(5,9,-1,0,7,ch246data);
+
+/* char: 0xf5 */
+
+static final byte[] ch245data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x50,(byte) 0x28,
+};
+
+static final BitmapCharRec ch245 = new BitmapCharRec(5,10,-1,0,7,ch245data);
+
+/* char: 0xf4 */
+
+static final byte[] ch244data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x50,(byte) 0x20,
+};
+
+static final BitmapCharRec ch244 = new BitmapCharRec(5,10,-1,0,7,ch244data);
+
+/* char: 0xf3 */
+
+static final byte[] ch243data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x20,(byte) 0x10,
+};
+
+static final BitmapCharRec ch243 = new BitmapCharRec(5,10,-1,0,7,ch243data);
+
+/* char: 0xf2 */
+
+static final byte[] ch242data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x20,(byte) 0x40,
+};
+
+static final BitmapCharRec ch242 = new BitmapCharRec(5,10,-1,0,7,ch242data);
+
+/* char: 0xf1 */
+
+static final byte[] ch241data = {
+(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0xc8,(byte) 0xb0,(byte) 0x0,(byte) 0x50,(byte) 0x28,
+};
+
+static final BitmapCharRec ch241 = new BitmapCharRec(5,10,-1,0,7,ch241data);
+
+/* char: 0xf0 */
+
+static final byte[] ch240data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x78,(byte) 0x8,(byte) 0x50,(byte) 0x30,(byte) 0x68,
+};
+
+static final BitmapCharRec ch240 = new BitmapCharRec(5,10,-1,0,7,ch240data);
+
+/* char: 0xef */
+
+static final byte[] ch239data = {
+(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0xa0,
+};
+
+static final BitmapCharRec ch239 = new BitmapCharRec(3,9,0,0,3,ch239data);
+
+/* char: 0xee */
+
+static final byte[] ch238data = {
+(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0xa0,(byte) 0x40,
+};
+
+static final BitmapCharRec ch238 = new BitmapCharRec(3,10,0,0,3,ch238data);
+
+/* char: 0xed */
+
+static final byte[] ch237data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80,(byte) 0x40,
+};
+
+static final BitmapCharRec ch237 = new BitmapCharRec(2,10,-1,0,3,ch237data);
+
+/* char: 0xec */
+
+static final byte[] ch236data = {
+(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0x40,(byte) 0x80,
+};
+
+static final BitmapCharRec ch236 = new BitmapCharRec(2,10,0,0,3,ch236data);
+
+/* char: 0xeb */
+
+static final byte[] ch235data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x80,(byte) 0xf8,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x50,
+};
+
+static final BitmapCharRec ch235 = new BitmapCharRec(5,9,-1,0,7,ch235data);
+
+/* char: 0xea */
+
+static final byte[] ch234data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x80,(byte) 0xf8,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x50,(byte) 0x20,
+};
+
+static final BitmapCharRec ch234 = new BitmapCharRec(5,10,-1,0,7,ch234data);
+
+/* char: 0xe9 */
+
+static final byte[] ch233data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x80,(byte) 0xf8,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x20,(byte) 0x10,
+};
+
+static final BitmapCharRec ch233 = new BitmapCharRec(5,10,-1,0,7,ch233data);
+
+/* char: 0xe8 */
+
+static final byte[] ch232data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x80,(byte) 0xf8,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x20,(byte) 0x40,
+};
+
+static final BitmapCharRec ch232 = new BitmapCharRec(5,10,-1,0,7,ch232data);
+
+/* char: 0xe7 */
+
+static final byte[] ch231data = {
+(byte) 0x60,(byte) 0x10,(byte) 0x20,(byte) 0x70,(byte) 0x88,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x88,(byte) 0x70,
+};
+
+static final BitmapCharRec ch231 = new BitmapCharRec(5,10,-1,3,7,ch231data);
+
+/* char: 0xe6 */
+
+static final byte[] ch230data = {
+(byte) 0x77,(byte) 0x0,(byte) 0x88,(byte) 0x80,(byte) 0x88,(byte) 0x0,(byte) 0x7f,(byte) 0x80,(byte) 0x8,(byte) 0x80,(byte) 0x88,(byte) 0x80,(byte) 0x77,(byte) 0x0,
+};
+
+static final BitmapCharRec ch230 = new BitmapCharRec(9,7,-1,0,11,ch230data);
+
+/* char: 0xe5 */
+
+static final byte[] ch229data = {
+(byte) 0x74,(byte) 0x88,(byte) 0x88,(byte) 0x78,(byte) 0x8,(byte) 0x88,(byte) 0x70,(byte) 0x30,(byte) 0x48,(byte) 0x30,
+};
+
+static final BitmapCharRec ch229 = new BitmapCharRec(6,10,-1,0,7,ch229data);
+
+/* char: 0xe4 */
+
+static final byte[] ch228data = {
+(byte) 0x74,(byte) 0x88,(byte) 0x88,(byte) 0x78,(byte) 0x8,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x50,
+};
+
+static final BitmapCharRec ch228 = new BitmapCharRec(6,9,-1,0,7,ch228data);
+
+/* char: 0xe3 */
+
+static final byte[] ch227data = {
+(byte) 0x74,(byte) 0x88,(byte) 0x88,(byte) 0x78,(byte) 0x8,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x50,(byte) 0x28,
+};
+
+static final BitmapCharRec ch227 = new BitmapCharRec(6,10,-1,0,7,ch227data);
+
+/* char: 0xe2 */
+
+static final byte[] ch226data = {
+(byte) 0x74,(byte) 0x88,(byte) 0x88,(byte) 0x78,(byte) 0x8,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x50,(byte) 0x20,
+};
+
+static final BitmapCharRec ch226 = new BitmapCharRec(6,10,-1,0,7,ch226data);
+
+/* char: 0xe1 */
+
+static final byte[] ch225data = {
+(byte) 0x74,(byte) 0x88,(byte) 0x88,(byte) 0x78,(byte) 0x8,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x20,(byte) 0x10,
+};
+
+static final BitmapCharRec ch225 = new BitmapCharRec(6,10,-1,0,7,ch225data);
+
+/* char: 0xe0 */
+
+static final byte[] ch224data = {
+(byte) 0x74,(byte) 0x88,(byte) 0x88,(byte) 0x78,(byte) 0x8,(byte) 0x88,(byte) 0x70,(byte) 0x0,(byte) 0x10,(byte) 0x20,
+};
+
+static final BitmapCharRec ch224 = new BitmapCharRec(6,10,-1,0,7,ch224data);
+
+/* char: 0xdf */
+
+static final byte[] ch223data = {
+(byte) 0xb0,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0xb0,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,
+};
+
+static final BitmapCharRec ch223 = new BitmapCharRec(5,9,-1,0,7,ch223data);
+
+/* char: 0xde */
+
+static final byte[] ch222data = {
+(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xf8,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch222 = new BitmapCharRec(6,9,-1,0,8,ch222data);
+
+/* char: 0xdd */
+
+static final byte[] ch221data = {
+(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x44,(byte) 0x44,(byte) 0x82,(byte) 0x82,(byte) 0x0,(byte) 0x10,(byte) 0x8,
+};
+
+static final BitmapCharRec ch221 = new BitmapCharRec(7,12,-1,0,9,ch221data);
+
+/* char: 0xdc */
+
+static final byte[] ch220data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x48,
+};
+
+static final BitmapCharRec ch220 = new BitmapCharRec(6,11,-1,0,8,ch220data);
+
+/* char: 0xdb */
+
+static final byte[] ch219data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x28,(byte) 0x10,
+};
+
+static final BitmapCharRec ch219 = new BitmapCharRec(6,12,-1,0,8,ch219data);
+
+/* char: 0xda */
+
+static final byte[] ch218data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x10,(byte) 0x8,
+};
+
+static final BitmapCharRec ch218 = new BitmapCharRec(6,12,-1,0,8,ch218data);
+
+/* char: 0xd9 */
+
+static final byte[] ch217data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x0,(byte) 0x10,(byte) 0x20,
+};
+
+static final BitmapCharRec ch217 = new BitmapCharRec(6,12,-1,0,8,ch217data);
+
+/* char: 0xd8 */
+
+static final byte[] ch216data = {
+(byte) 0x80,(byte) 0x0,(byte) 0x5e,(byte) 0x0,(byte) 0x21,(byte) 0x0,(byte) 0x50,(byte) 0x80,(byte) 0x48,(byte) 0x80,(byte) 0x44,(byte) 0x80,(byte) 0x44,(byte) 0x80,(byte) 0x42,(byte) 0x80,
+(byte) 0x21,(byte) 0x0,(byte) 0x1e,(byte) 0x80,(byte) 0x0,(byte) 0x40,
+};
+
+static final BitmapCharRec ch216 = new BitmapCharRec(10,11,0,1,10,ch216data);
+
+/* char: 0xd7 */
+
+static final byte[] ch215data = {
+(byte) 0x88,(byte) 0x50,(byte) 0x20,(byte) 0x50,(byte) 0x88,
+};
+
+static final BitmapCharRec ch215 = new BitmapCharRec(5,5,-1,-1,7,ch215data);
+
+/* char: 0xd6 */
+
+static final byte[] ch214data = {
+(byte) 0x3c,(byte) 0x42,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x42,(byte) 0x3c,(byte) 0x0,(byte) 0x24,
+};
+
+static final BitmapCharRec ch214 = new BitmapCharRec(8,11,-1,0,10,ch214data);
+
+/* char: 0xd5 */
+
+static final byte[] ch213data = {
+(byte) 0x3c,(byte) 0x42,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x42,(byte) 0x3c,(byte) 0x0,(byte) 0x28,(byte) 0x14,
+};
+
+static final BitmapCharRec ch213 = new BitmapCharRec(8,12,-1,0,10,ch213data);
+
+/* char: 0xd4 */
+
+static final byte[] ch212data = {
+(byte) 0x3c,(byte) 0x42,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x42,(byte) 0x3c,(byte) 0x0,(byte) 0x14,(byte) 0x8,
+};
+
+static final BitmapCharRec ch212 = new BitmapCharRec(8,12,-1,0,10,ch212data);
+
+/* char: 0xd3 */
+
+static final byte[] ch211data = {
+(byte) 0x3c,(byte) 0x42,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x42,(byte) 0x3c,(byte) 0x0,(byte) 0x8,(byte) 0x4,
+};
+
+static final BitmapCharRec ch211 = new BitmapCharRec(8,12,-1,0,10,ch211data);
+
+/* char: 0xd2 */
+
+static final byte[] ch210data = {
+(byte) 0x3c,(byte) 0x42,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x42,(byte) 0x3c,(byte) 0x0,(byte) 0x8,(byte) 0x10,
+};
+
+static final BitmapCharRec ch210 = new BitmapCharRec(8,12,-1,0,10,ch210data);
+
+/* char: 0xd1 */
+
+static final byte[] ch209data = {
+(byte) 0x82,(byte) 0x86,(byte) 0x8a,(byte) 0x8a,(byte) 0x92,(byte) 0xa2,(byte) 0xa2,(byte) 0xc2,(byte) 0x82,(byte) 0x0,(byte) 0x28,(byte) 0x14,
+};
+
+static final BitmapCharRec ch209 = new BitmapCharRec(7,12,-1,0,9,ch209data);
+
+/* char: 0xd0 */
+
+static final byte[] ch208data = {
+(byte) 0x7c,(byte) 0x42,(byte) 0x41,(byte) 0x41,(byte) 0xf1,(byte) 0x41,(byte) 0x41,(byte) 0x42,(byte) 0x7c,
+};
+
+static final BitmapCharRec ch208 = new BitmapCharRec(8,9,0,0,9,ch208data);
+
+/* char: 0xcf */
+
+static final byte[] ch207data = {
+(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0xa0,
+};
+
+static final BitmapCharRec ch207 = new BitmapCharRec(3,11,0,0,3,ch207data);
+
+/* char: 0xce */
+
+static final byte[] ch206data = {
+(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0xa0,(byte) 0x40,
+};
+
+static final BitmapCharRec ch206 = new BitmapCharRec(3,12,0,0,3,ch206data);
+
+/* char: 0xcd */
+
+static final byte[] ch205data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80,(byte) 0x40,
+};
+
+static final BitmapCharRec ch205 = new BitmapCharRec(2,12,-1,0,3,ch205data);
+
+/* char: 0xcc */
+
+static final byte[] ch204data = {
+(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0x40,(byte) 0x80,
+};
+
+static final BitmapCharRec ch204 = new BitmapCharRec(2,12,0,0,3,ch204data);
+
+/* char: 0xcb */
+
+static final byte[] ch203data = {
+(byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x0,(byte) 0x28,
+};
+
+static final BitmapCharRec ch203 = new BitmapCharRec(6,11,-1,0,8,ch203data);
+
+/* char: 0xca */
+
+static final byte[] ch202data = {
+(byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x0,(byte) 0x28,(byte) 0x10,
+};
+
+static final BitmapCharRec ch202 = new BitmapCharRec(6,12,-1,0,8,ch202data);
+
+/* char: 0xc9 */
+
+static final byte[] ch201data = {
+(byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x0,(byte) 0x10,(byte) 0x8,
+};
+
+static final BitmapCharRec ch201 = new BitmapCharRec(6,12,-1,0,8,ch201data);
+
+/* char: 0xc8 */
+
+static final byte[] ch200data = {
+(byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x0,(byte) 0x10,(byte) 0x20,
+};
+
+static final BitmapCharRec ch200 = new BitmapCharRec(6,12,-1,0,8,ch200data);
+
+/* char: 0xc7 */
+
+static final byte[] ch199data = {
+(byte) 0x30,(byte) 0x8,(byte) 0x8,(byte) 0x3c,(byte) 0x42,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x42,(byte) 0x3c,
+};
+
+static final BitmapCharRec ch199 = new BitmapCharRec(7,12,-1,3,9,ch199data);
+
+/* char: 0xc6 */
+
+static final byte[] ch198data = {
+(byte) 0x8f,(byte) 0x80,(byte) 0x88,(byte) 0x0,(byte) 0x88,(byte) 0x0,(byte) 0x78,(byte) 0x0,(byte) 0x4f,(byte) 0x80,(byte) 0x48,(byte) 0x0,(byte) 0x28,(byte) 0x0,(byte) 0x28,(byte) 0x0,
+(byte) 0x1f,(byte) 0x80,
+};
+
+static final BitmapCharRec ch198 = new BitmapCharRec(9,9,-1,0,11,ch198data);
+
+/* char: 0xc5 */
+
+static final byte[] ch197data = {
+(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x44,(byte) 0x28,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x10,
+};
+
+static final BitmapCharRec ch197 = new BitmapCharRec(7,12,-1,0,9,ch197data);
+
+/* char: 0xc4 */
+
+static final byte[] ch196data = {
+(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x44,(byte) 0x28,(byte) 0x10,(byte) 0x10,(byte) 0x0,(byte) 0x28,
+};
+
+static final BitmapCharRec ch196 = new BitmapCharRec(7,11,-1,0,9,ch196data);
+
+/* char: 0xc3 */
+
+static final byte[] ch195data = {
+(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x44,(byte) 0x28,(byte) 0x10,(byte) 0x10,(byte) 0x0,(byte) 0x28,(byte) 0x14,
+};
+
+static final BitmapCharRec ch195 = new BitmapCharRec(7,12,-1,0,9,ch195data);
+
+/* char: 0xc2 */
+
+static final byte[] ch194data = {
+(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x44,(byte) 0x28,(byte) 0x10,(byte) 0x10,(byte) 0x0,(byte) 0x28,(byte) 0x10,
+};
+
+static final BitmapCharRec ch194 = new BitmapCharRec(7,12,-1,0,9,ch194data);
+
+/* char: 0xc1 */
+
+static final byte[] ch193data = {
+(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x44,(byte) 0x28,(byte) 0x10,(byte) 0x10,(byte) 0x0,(byte) 0x10,(byte) 0x8,
+};
+
+static final BitmapCharRec ch193 = new BitmapCharRec(7,12,-1,0,9,ch193data);
+
+/* char: 0xc0 */
+
+static final byte[] ch192data = {
+(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x44,(byte) 0x28,(byte) 0x10,(byte) 0x10,(byte) 0x0,(byte) 0x10,(byte) 0x20,
+};
+
+static final BitmapCharRec ch192 = new BitmapCharRec(7,12,-1,0,9,ch192data);
+
+/* char: 0xbf */
+
+static final byte[] ch191data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x0,(byte) 0x20,
+};
+
+static final BitmapCharRec ch191 = new BitmapCharRec(5,9,-1,3,7,ch191data);
+
+/* char: 0xbe */
+
+static final byte[] ch190data = {
+(byte) 0x21,(byte) 0x0,(byte) 0x17,(byte) 0x80,(byte) 0x15,(byte) 0x0,(byte) 0xb,(byte) 0x0,(byte) 0xc9,(byte) 0x0,(byte) 0x24,(byte) 0x0,(byte) 0x44,(byte) 0x0,(byte) 0x22,(byte) 0x0,
+(byte) 0xe1,(byte) 0x0,
+};
+
+static final BitmapCharRec ch190 = new BitmapCharRec(9,9,0,0,10,ch190data);
+
+/* char: 0xbd */
+
+static final byte[] ch189data = {
+(byte) 0x47,(byte) 0x80,(byte) 0x22,(byte) 0x0,(byte) 0x11,(byte) 0x0,(byte) 0x14,(byte) 0x80,(byte) 0x4b,(byte) 0x0,(byte) 0x48,(byte) 0x0,(byte) 0x44,(byte) 0x0,(byte) 0xc2,(byte) 0x0,
+(byte) 0x41,(byte) 0x0,
+};
+
+static final BitmapCharRec ch189 = new BitmapCharRec(9,9,0,0,10,ch189data);
+
+/* char: 0xbc */
+
+static final byte[] ch188data = {
+(byte) 0x41,(byte) 0x0,(byte) 0x27,(byte) 0x80,(byte) 0x15,(byte) 0x0,(byte) 0x13,(byte) 0x0,(byte) 0x49,(byte) 0x0,(byte) 0x44,(byte) 0x0,(byte) 0x44,(byte) 0x0,(byte) 0xc2,(byte) 0x0,
+(byte) 0x41,(byte) 0x0,
+};
+
+static final BitmapCharRec ch188 = new BitmapCharRec(9,9,0,0,10,ch188data);
+
+/* char: 0xbb */
+
+static final byte[] ch187data = {
+(byte) 0xa0,(byte) 0x50,(byte) 0x28,(byte) 0x50,(byte) 0xa0,
+};
+
+static final BitmapCharRec ch187 = new BitmapCharRec(5,5,-1,-1,7,ch187data);
+
+/* char: 0xba */
+
+static final byte[] ch186data = {
+(byte) 0xe0,(byte) 0x0,(byte) 0xe0,(byte) 0xa0,(byte) 0xe0,
+};
+
+static final BitmapCharRec ch186 = new BitmapCharRec(3,5,-1,-4,5,ch186data);
+
+/* char: 0xb9 */
+
+static final byte[] ch185data = {
+(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x40,
+};
+
+static final BitmapCharRec ch185 = new BitmapCharRec(2,5,-1,-3,4,ch185data);
+
+/* char: 0xb8 */
+
+static final byte[] ch184data = {
+(byte) 0xc0,(byte) 0x20,(byte) 0x20,(byte) 0x40,
+};
+
+static final BitmapCharRec ch184 = new BitmapCharRec(3,4,0,3,3,ch184data);
+
+/* char: 0xb7 */
+
+static final byte[] ch183data = {
+(byte) 0x80,
+};
+
+static final BitmapCharRec ch183 = new BitmapCharRec(1,1,-1,-3,3,ch183data);
+
+/* char: 0xb6 */
+
+static final byte[] ch182data = {
+(byte) 0x28,(byte) 0x28,(byte) 0x28,(byte) 0x28,(byte) 0x28,(byte) 0x28,(byte) 0x68,(byte) 0xe8,(byte) 0xe8,(byte) 0xe8,(byte) 0x68,(byte) 0x3c,
+};
+
+static final BitmapCharRec ch182 = new BitmapCharRec(6,12,0,3,7,ch182data);
+
+/* char: 0xb5 */
+
+static final byte[] ch181data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xe8,(byte) 0x98,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,
+};
+
+static final BitmapCharRec ch181 = new BitmapCharRec(5,10,-1,3,7,ch181data);
+
+/* char: 0xb4 */
+
+static final byte[] ch180data = {
+(byte) 0x80,(byte) 0x40,
+};
+
+static final BitmapCharRec ch180 = new BitmapCharRec(2,2,0,-8,2,ch180data);
+
+/* char: 0xb3 */
+
+static final byte[] ch179data = {
+(byte) 0xc0,(byte) 0x20,(byte) 0x40,(byte) 0x20,(byte) 0xe0,
+};
+
+static final BitmapCharRec ch179 = new BitmapCharRec(3,5,0,-3,4,ch179data);
+
+/* char: 0xb2 */
+
+static final byte[] ch178data = {
+(byte) 0xf0,(byte) 0x40,(byte) 0x20,(byte) 0x90,(byte) 0x60,
+};
+
+static final BitmapCharRec ch178 = new BitmapCharRec(4,5,0,-3,4,ch178data);
+
+/* char: 0xb1 */
+
+static final byte[] ch177data = {
+(byte) 0xf8,(byte) 0x0,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0x20,
+};
+
+static final BitmapCharRec ch177 = new BitmapCharRec(5,7,-1,0,7,ch177data);
+
+/* char: 0xb0 */
+
+static final byte[] ch176data = {
+(byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x60,
+};
+
+static final BitmapCharRec ch176 = new BitmapCharRec(4,4,0,-4,5,ch176data);
+
+/* char: 0xaf */
+
+static final byte[] ch175data = {
+(byte) 0xf0,
+};
+
+static final BitmapCharRec ch175 = new BitmapCharRec(4,1,0,-8,4,ch175data);
+
+/* char: 0xae */
+
+static final byte[] ch174data = {
+(byte) 0x3e,(byte) 0x0,(byte) 0x41,(byte) 0x0,(byte) 0x94,(byte) 0x80,(byte) 0x94,(byte) 0x80,(byte) 0x98,(byte) 0x80,(byte) 0x94,(byte) 0x80,(byte) 0x9c,(byte) 0x80,(byte) 0x41,(byte) 0x0,
+(byte) 0x3e,(byte) 0x0,
+};
+
+static final BitmapCharRec ch174 = new BitmapCharRec(9,9,-1,0,11,ch174data);
+
+/* char: 0xad */
+
+static final byte[] ch173data = {
+(byte) 0xf0,
+};
+
+static final BitmapCharRec ch173 = new BitmapCharRec(4,1,0,-3,5,ch173data);
+
+/* char: 0xac */
+
+static final byte[] ch172data = {
+(byte) 0x4,(byte) 0x4,(byte) 0x4,(byte) 0xfc,
+};
+
+static final BitmapCharRec ch172 = new BitmapCharRec(6,4,-1,-2,8,ch172data);
+
+/* char: 0xab */
+
+static final byte[] ch171data = {
+(byte) 0x28,(byte) 0x50,(byte) 0xa0,(byte) 0x50,(byte) 0x28,
+};
+
+static final BitmapCharRec ch171 = new BitmapCharRec(5,5,-1,-1,7,ch171data);
+
+/* char: 0xaa */
+
+static final byte[] ch170data = {
+(byte) 0xe0,(byte) 0x0,(byte) 0xa0,(byte) 0x20,(byte) 0xe0,
+};
+
+static final BitmapCharRec ch170 = new BitmapCharRec(3,5,-1,-4,5,ch170data);
+
+/* char: 0xa9 */
+
+static final byte[] ch169data = {
+(byte) 0x3e,(byte) 0x0,(byte) 0x41,(byte) 0x0,(byte) 0x9c,(byte) 0x80,(byte) 0xa2,(byte) 0x80,(byte) 0xa0,(byte) 0x80,(byte) 0xa2,(byte) 0x80,(byte) 0x9c,(byte) 0x80,(byte) 0x41,(byte) 0x0,
+(byte) 0x3e,(byte) 0x0,
+};
+
+static final BitmapCharRec ch169 = new BitmapCharRec(9,9,-1,0,11,ch169data);
+
+/* char: 0xa8 */
+
+static final byte[] ch168data = {
+(byte) 0xa0,
+};
+
+static final BitmapCharRec ch168 = new BitmapCharRec(3,1,0,-8,3,ch168data);
+
+/* char: 0xa7 */
+
+static final byte[] ch167data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x8,(byte) 0x30,(byte) 0x48,(byte) 0x88,(byte) 0x88,(byte) 0x90,(byte) 0x60,(byte) 0x80,(byte) 0x88,(byte) 0x70,
+};
+
+static final BitmapCharRec ch167 = new BitmapCharRec(5,12,0,3,6,ch167data);
+
+/* char: 0xa6 */
+
+static final byte[] ch166data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch166 = new BitmapCharRec(1,11,-1,2,3,ch166data);
+
+/* char: 0xa5 */
+
+static final byte[] ch165data = {
+(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0x50,(byte) 0x88,(byte) 0x88,
+};
+
+static final BitmapCharRec ch165 = new BitmapCharRec(5,9,-1,0,7,ch165data);
+
+/* char: 0xa4 */
+
+static final byte[] ch164data = {
+(byte) 0x84,(byte) 0x78,(byte) 0x48,(byte) 0x48,(byte) 0x78,(byte) 0x84,
+};
+
+static final BitmapCharRec ch164 = new BitmapCharRec(6,6,0,-1,7,ch164data);
+
+/* char: 0xa3 */
+
+static final byte[] ch163data = {
+(byte) 0xb0,(byte) 0x48,(byte) 0x20,(byte) 0x20,(byte) 0xf0,(byte) 0x40,(byte) 0x40,(byte) 0x48,(byte) 0x30,
+};
+
+static final BitmapCharRec ch163 = new BitmapCharRec(5,9,-1,0,7,ch163data);
+
+/* char: 0xa2 */
+
+static final byte[] ch162data = {
+(byte) 0x40,(byte) 0x70,(byte) 0xc8,(byte) 0xa0,(byte) 0xa0,(byte) 0xa0,(byte) 0xa8,(byte) 0x70,(byte) 0x10,
+};
+
+static final BitmapCharRec ch162 = new BitmapCharRec(5,9,-1,1,7,ch162data);
+
+/* char: 0xa1 */
+
+static final byte[] ch161data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80,
+};
+
+static final BitmapCharRec ch161 = new BitmapCharRec(1,10,-1,3,3,ch161data);
+
+/* char: 0xa0 */
+
+static final BitmapCharRec ch160 = new BitmapCharRec(0,0,0,0,4,null);
+
+/* char: 0x7e '~' */
+
+static final byte[] ch126data = {
+(byte) 0x98,(byte) 0x64,
+};
+
+static final BitmapCharRec ch126 = new BitmapCharRec(6,2,0,-3,7,ch126data);
+
+/* char: 0x7d '}' */
+
+static final byte[] ch125data = {
+(byte) 0xc0,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x10,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch125 = new BitmapCharRec(4,12,0,3,4,ch125data);
+
+/* char: 0x7c '|' */
+
+static final byte[] ch124data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch124 = new BitmapCharRec(1,12,-1,3,3,ch124data);
+
+/* char: 0x7b '{' */
+
+static final byte[] ch123data = {
+(byte) 0x30,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x30,
+};
+
+static final BitmapCharRec ch123 = new BitmapCharRec(4,12,0,3,4,ch123data);
+
+/* char: 0x7a 'z' */
+
+static final byte[] ch122data = {
+(byte) 0xf0,(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0xf0,
+};
+
+static final BitmapCharRec ch122 = new BitmapCharRec(4,7,-1,0,6,ch122data);
+
+/* char: 0x79 'y' */
+
+static final byte[] ch121data = {
+(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x50,(byte) 0x50,(byte) 0x90,(byte) 0x88,(byte) 0x88,(byte) 0x88,
+};
+
+static final BitmapCharRec ch121 = new BitmapCharRec(5,10,-1,3,7,ch121data);
+
+/* char: 0x78 'x' */
+
+static final byte[] ch120data = {
+(byte) 0x84,(byte) 0x84,(byte) 0x48,(byte) 0x30,(byte) 0x30,(byte) 0x48,(byte) 0x84,
+};
+
+static final BitmapCharRec ch120 = new BitmapCharRec(6,7,0,0,6,ch120data);
+
+/* char: 0x77 'w' */
+
+static final byte[] ch119data = {
+(byte) 0x22,(byte) 0x0,(byte) 0x22,(byte) 0x0,(byte) 0x55,(byte) 0x0,(byte) 0x49,(byte) 0x0,(byte) 0x49,(byte) 0x0,(byte) 0x88,(byte) 0x80,(byte) 0x88,(byte) 0x80,
+};
+
+static final BitmapCharRec ch119 = new BitmapCharRec(9,7,0,0,9,ch119data);
+
+/* char: 0x76 'v' */
+
+static final byte[] ch118data = {
+(byte) 0x20,(byte) 0x20,(byte) 0x50,(byte) 0x50,(byte) 0x88,(byte) 0x88,(byte) 0x88,
+};
+
+static final BitmapCharRec ch118 = new BitmapCharRec(5,7,-1,0,7,ch118data);
+
+/* char: 0x75 'u' */
+
+static final byte[] ch117data = {
+(byte) 0x68,(byte) 0x98,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,
+};
+
+static final BitmapCharRec ch117 = new BitmapCharRec(5,7,-1,0,7,ch117data);
+
+/* char: 0x74 't' */
+
+static final byte[] ch116data = {
+(byte) 0x60,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xe0,(byte) 0x40,(byte) 0x40,
+};
+
+static final BitmapCharRec ch116 = new BitmapCharRec(3,9,0,0,3,ch116data);
+
+/* char: 0x73 's' */
+
+static final byte[] ch115data = {
+(byte) 0x60,(byte) 0x90,(byte) 0x10,(byte) 0x60,(byte) 0x80,(byte) 0x90,(byte) 0x60,
+};
+
+static final BitmapCharRec ch115 = new BitmapCharRec(4,7,-1,0,6,ch115data);
+
+/* char: 0x72 'r' */
+
+static final byte[] ch114data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xc0,(byte) 0xa0,
+};
+
+static final BitmapCharRec ch114 = new BitmapCharRec(3,7,-1,0,4,ch114data);
+
+/* char: 0x71 'q' */
+
+static final byte[] ch113data = {
+(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x68,(byte) 0x98,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x98,(byte) 0x68,
+};
+
+static final BitmapCharRec ch113 = new BitmapCharRec(5,10,-1,3,7,ch113data);
+
+/* char: 0x70 'p' */
+
+static final byte[] ch112data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xb0,(byte) 0xc8,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0xc8,(byte) 0xb0,
+};
+
+static final BitmapCharRec ch112 = new BitmapCharRec(5,10,-1,3,7,ch112data);
+
+/* char: 0x6f 'o' */
+
+static final byte[] ch111data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,
+};
+
+static final BitmapCharRec ch111 = new BitmapCharRec(5,7,-1,0,7,ch111data);
+
+/* char: 0x6e 'n' */
+
+static final byte[] ch110data = {
+(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0xc8,(byte) 0xb0,
+};
+
+static final BitmapCharRec ch110 = new BitmapCharRec(5,7,-1,0,7,ch110data);
+
+/* char: 0x6d 'm' */
+
+static final byte[] ch109data = {
+(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0xda,(byte) 0xa4,
+};
+
+static final BitmapCharRec ch109 = new BitmapCharRec(7,7,-1,0,9,ch109data);
+
+/* char: 0x6c 'l' */
+
+static final byte[] ch108data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch108 = new BitmapCharRec(1,9,-1,0,3,ch108data);
+
+/* char: 0x6b 'k' */
+
+static final byte[] ch107data = {
+(byte) 0x88,(byte) 0x90,(byte) 0xa0,(byte) 0xc0,(byte) 0xc0,(byte) 0xa0,(byte) 0x90,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch107 = new BitmapCharRec(5,9,-1,0,6,ch107data);
+
+/* char: 0x6a 'j' */
+
+static final byte[] ch106data = {
+(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0x40,
+};
+
+static final BitmapCharRec ch106 = new BitmapCharRec(2,12,0,3,3,ch106data);
+
+/* char: 0x69 'i' */
+
+static final byte[] ch105data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80,
+};
+
+static final BitmapCharRec ch105 = new BitmapCharRec(1,9,-1,0,3,ch105data);
+
+/* char: 0x68 'h' */
+
+static final byte[] ch104data = {
+(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0xc8,(byte) 0xb0,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch104 = new BitmapCharRec(5,9,-1,0,7,ch104data);
+
+/* char: 0x67 'g' */
+
+static final byte[] ch103data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x8,(byte) 0x68,(byte) 0x98,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x98,(byte) 0x68,
+};
+
+static final BitmapCharRec ch103 = new BitmapCharRec(5,10,-1,3,7,ch103data);
+
+/* char: 0x66 'f' */
+
+static final byte[] ch102data = {
+(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xe0,(byte) 0x40,(byte) 0x30,
+};
+
+static final BitmapCharRec ch102 = new BitmapCharRec(4,9,0,0,3,ch102data);
+
+/* char: 0x65 'e' */
+
+static final byte[] ch101data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x80,(byte) 0xf8,(byte) 0x88,(byte) 0x88,(byte) 0x70,
+};
+
+static final BitmapCharRec ch101 = new BitmapCharRec(5,7,-1,0,7,ch101data);
+
+/* char: 0x64 'd' */
+
+static final byte[] ch100data = {
+(byte) 0x68,(byte) 0x98,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x98,(byte) 0x68,(byte) 0x8,(byte) 0x8,
+};
+
+static final BitmapCharRec ch100 = new BitmapCharRec(5,9,-1,0,7,ch100data);
+
+/* char: 0x63 'c' */
+
+static final byte[] ch99data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x88,(byte) 0x70,
+};
+
+static final BitmapCharRec ch99 = new BitmapCharRec(5,7,-1,0,7,ch99data);
+
+/* char: 0x62 'b' */
+
+static final byte[] ch98data = {
+(byte) 0xb0,(byte) 0xc8,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0xc8,(byte) 0xb0,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch98 = new BitmapCharRec(5,9,-1,0,7,ch98data);
+
+/* char: 0x61 'a' */
+
+static final byte[] ch97data = {
+(byte) 0x74,(byte) 0x88,(byte) 0x88,(byte) 0x78,(byte) 0x8,(byte) 0x88,(byte) 0x70,
+};
+
+static final BitmapCharRec ch97 = new BitmapCharRec(6,7,-1,0,7,ch97data);
+
+/* char: 0x60 '`' */
+
+static final byte[] ch96data = {
+(byte) 0xc0,(byte) 0x80,(byte) 0x40,
+};
+
+static final BitmapCharRec ch96 = new BitmapCharRec(2,3,0,-6,3,ch96data);
+
+/* char: 0x5f '_' */
+
+static final byte[] ch95data = {
+(byte) 0xfe,
+};
+
+static final BitmapCharRec ch95 = new BitmapCharRec(7,1,0,2,7,ch95data);
+
+/* char: 0x5e '^' */
+
+static final byte[] ch94data = {
+(byte) 0x88,(byte) 0x50,(byte) 0x20,
+};
+
+static final BitmapCharRec ch94 = new BitmapCharRec(5,3,0,-5,6,ch94data);
+
+/* char: 0x5d ']' */
+
+static final byte[] ch93data = {
+(byte) 0xc0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch93 = new BitmapCharRec(2,12,0,3,3,ch93data);
+
+/* char: 0x5c '\' */
+
+static final byte[] ch92data = {
+(byte) 0x10,(byte) 0x10,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch92 = new BitmapCharRec(4,9,0,0,4,ch92data);
+
+/* char: 0x5b '[' */
+
+static final byte[] ch91data = {
+(byte) 0xc0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch91 = new BitmapCharRec(2,12,-1,3,3,ch91data);
+
+/* char: 0x5a 'Z' */
+
+static final byte[] ch90data = {
+(byte) 0xfe,(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x8,(byte) 0x4,(byte) 0x2,(byte) 0xfe,
+};
+
+static final BitmapCharRec ch90 = new BitmapCharRec(7,9,-1,0,9,ch90data);
+
+/* char: 0x59 'Y' */
+
+static final byte[] ch89data = {
+(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x44,(byte) 0x44,(byte) 0x82,(byte) 0x82,
+};
+
+static final BitmapCharRec ch89 = new BitmapCharRec(7,9,-1,0,9,ch89data);
+
+/* char: 0x58 'X' */
+
+static final byte[] ch88data = {
+(byte) 0x82,(byte) 0x44,(byte) 0x44,(byte) 0x28,(byte) 0x10,(byte) 0x28,(byte) 0x44,(byte) 0x44,(byte) 0x82,
+};
+
+static final BitmapCharRec ch88 = new BitmapCharRec(7,9,-1,0,9,ch88data);
+
+/* char: 0x57 'W' */
+
+static final byte[] ch87data = {
+(byte) 0x22,(byte) 0x0,(byte) 0x22,(byte) 0x0,(byte) 0x22,(byte) 0x0,(byte) 0x55,(byte) 0x0,(byte) 0x55,(byte) 0x0,(byte) 0x49,(byte) 0x0,(byte) 0x88,(byte) 0x80,(byte) 0x88,(byte) 0x80,
+(byte) 0x88,(byte) 0x80,
+};
+
+static final BitmapCharRec ch87 = new BitmapCharRec(9,9,-1,0,11,ch87data);
+
+/* char: 0x56 'V' */
+
+static final byte[] ch86data = {
+(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x28,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0x82,(byte) 0x82,
+};
+
+static final BitmapCharRec ch86 = new BitmapCharRec(7,9,-1,0,9,ch86data);
+
+/* char: 0x55 'U' */
+
+static final byte[] ch85data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x84,
+};
+
+static final BitmapCharRec ch85 = new BitmapCharRec(6,9,-1,0,8,ch85data);
+
+/* char: 0x54 'T' */
+
+static final byte[] ch84data = {
+(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0xfe,
+};
+
+static final BitmapCharRec ch84 = new BitmapCharRec(7,9,0,0,7,ch84data);
+
+/* char: 0x53 'S' */
+
+static final byte[] ch83data = {
+(byte) 0x78,(byte) 0x84,(byte) 0x84,(byte) 0x4,(byte) 0x18,(byte) 0x60,(byte) 0x80,(byte) 0x84,(byte) 0x78,
+};
+
+static final BitmapCharRec ch83 = new BitmapCharRec(6,9,-1,0,8,ch83data);
+
+/* char: 0x52 'R' */
+
+static final byte[] ch82data = {
+(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0x88,(byte) 0xf8,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xf8,
+};
+
+static final BitmapCharRec ch82 = new BitmapCharRec(6,9,-1,0,8,ch82data);
+
+/* char: 0x51 'Q' */
+
+static final byte[] ch81data = {
+(byte) 0x3d,(byte) 0x42,(byte) 0x85,(byte) 0x89,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x42,(byte) 0x3c,
+};
+
+static final BitmapCharRec ch81 = new BitmapCharRec(8,9,-1,0,10,ch81data);
+
+/* char: 0x50 'P' */
+
+static final byte[] ch80data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xf8,
+};
+
+static final BitmapCharRec ch80 = new BitmapCharRec(6,9,-1,0,8,ch80data);
+
+/* char: 0x4f 'O' */
+
+static final byte[] ch79data = {
+(byte) 0x3c,(byte) 0x42,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x81,(byte) 0x42,(byte) 0x3c,
+};
+
+static final BitmapCharRec ch79 = new BitmapCharRec(8,9,-1,0,10,ch79data);
+
+/* char: 0x4e 'N' */
+
+static final byte[] ch78data = {
+(byte) 0x82,(byte) 0x86,(byte) 0x8a,(byte) 0x8a,(byte) 0x92,(byte) 0xa2,(byte) 0xa2,(byte) 0xc2,(byte) 0x82,
+};
+
+static final BitmapCharRec ch78 = new BitmapCharRec(7,9,-1,0,9,ch78data);
+
+/* char: 0x4d 'M' */
+
+static final byte[] ch77data = {
+(byte) 0x88,(byte) 0x80,(byte) 0x88,(byte) 0x80,(byte) 0x94,(byte) 0x80,(byte) 0x94,(byte) 0x80,(byte) 0xa2,(byte) 0x80,(byte) 0xa2,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,
+(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch77 = new BitmapCharRec(9,9,-1,0,11,ch77data);
+
+/* char: 0x4c 'L' */
+
+static final byte[] ch76data = {
+(byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch76 = new BitmapCharRec(5,9,-1,0,7,ch76data);
+
+/* char: 0x4b 'K' */
+
+static final byte[] ch75data = {
+(byte) 0x82,(byte) 0x84,(byte) 0x88,(byte) 0x90,(byte) 0xe0,(byte) 0xa0,(byte) 0x90,(byte) 0x88,(byte) 0x84,
+};
+
+static final BitmapCharRec ch75 = new BitmapCharRec(7,9,-1,0,8,ch75data);
+
+/* char: 0x4a 'J' */
+
+static final byte[] ch74data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,(byte) 0x8,
+};
+
+static final BitmapCharRec ch74 = new BitmapCharRec(5,9,-1,0,7,ch74data);
+
+/* char: 0x49 'I' */
+
+static final byte[] ch73data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch73 = new BitmapCharRec(1,9,-1,0,3,ch73data);
+
+/* char: 0x48 'H' */
+
+static final byte[] ch72data = {
+(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0xfe,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,
+};
+
+static final BitmapCharRec ch72 = new BitmapCharRec(7,9,-1,0,9,ch72data);
+
+/* char: 0x47 'G' */
+
+static final byte[] ch71data = {
+(byte) 0x3a,(byte) 0x46,(byte) 0x82,(byte) 0x82,(byte) 0x8e,(byte) 0x80,(byte) 0x80,(byte) 0x42,(byte) 0x3c,
+};
+
+static final BitmapCharRec ch71 = new BitmapCharRec(7,9,-1,0,9,ch71data);
+
+/* char: 0x46 'F' */
+
+static final byte[] ch70data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc,
+};
+
+static final BitmapCharRec ch70 = new BitmapCharRec(6,9,-1,0,8,ch70data);
+
+/* char: 0x45 'E' */
+
+static final byte[] ch69data = {
+(byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xfc,
+};
+
+static final BitmapCharRec ch69 = new BitmapCharRec(6,9,-1,0,8,ch69data);
+
+/* char: 0x44 'D' */
+
+static final byte[] ch68data = {
+(byte) 0xf8,(byte) 0x84,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x84,(byte) 0xf8,
+};
+
+static final BitmapCharRec ch68 = new BitmapCharRec(7,9,-1,0,9,ch68data);
+
+/* char: 0x43 'C' */
+
+static final byte[] ch67data = {
+(byte) 0x3c,(byte) 0x42,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x42,(byte) 0x3c,
+};
+
+static final BitmapCharRec ch67 = new BitmapCharRec(7,9,-1,0,9,ch67data);
+
+/* char: 0x42 'B' */
+
+static final byte[] ch66data = {
+(byte) 0xf8,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xf8,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xf8,
+};
+
+static final BitmapCharRec ch66 = new BitmapCharRec(6,9,-1,0,8,ch66data);
+
+/* char: 0x41 'A' */
+
+static final byte[] ch65data = {
+(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x7c,(byte) 0x44,(byte) 0x44,(byte) 0x28,(byte) 0x28,(byte) 0x10,
+};
+
+static final BitmapCharRec ch65 = new BitmapCharRec(7,9,-1,0,9,ch65data);
+
+/* char: 0x40 '@' */
+
+static final byte[] ch64data = {
+(byte) 0x3e,(byte) 0x0,(byte) 0x40,(byte) 0x0,(byte) 0x9b,(byte) 0x0,(byte) 0xa6,(byte) 0x80,(byte) 0xa2,(byte) 0x40,(byte) 0xa2,(byte) 0x40,(byte) 0x92,(byte) 0x40,(byte) 0x4d,(byte) 0x40,
+(byte) 0x60,(byte) 0x80,(byte) 0x1f,(byte) 0x0,
+};
+
+static final BitmapCharRec ch64 = new BitmapCharRec(10,10,-1,1,12,ch64data);
+
+/* char: 0x3f '?' */
+
+static final byte[] ch63data = {
+(byte) 0x20,(byte) 0x0,(byte) 0x20,(byte) 0x20,(byte) 0x10,(byte) 0x10,(byte) 0x88,(byte) 0x88,(byte) 0x70,
+};
+
+static final BitmapCharRec ch63 = new BitmapCharRec(5,9,-1,0,7,ch63data);
+
+/* char: 0x3e '>' */
+
+static final byte[] ch62data = {
+(byte) 0xc0,(byte) 0x30,(byte) 0xc,(byte) 0x30,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch62 = new BitmapCharRec(6,5,-1,-1,7,ch62data);
+
+/* char: 0x3d '=' */
+
+static final byte[] ch61data = {
+(byte) 0xf8,(byte) 0x0,(byte) 0xf8,
+};
+
+static final BitmapCharRec ch61 = new BitmapCharRec(5,3,-1,-2,7,ch61data);
+
+/* char: 0x3c '<' */
+
+static final byte[] ch60data = {
+(byte) 0xc,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0xc,
+};
+
+static final BitmapCharRec ch60 = new BitmapCharRec(6,5,0,-1,7,ch60data);
+
+/* char: 0x3b ';' */
+
+static final byte[] ch59data = {
+(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x40,
+};
+
+static final BitmapCharRec ch59 = new BitmapCharRec(2,8,0,2,3,ch59data);
+
+/* char: 0x3a ':' */
+
+static final byte[] ch58data = {
+(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x80,
+};
+
+static final BitmapCharRec ch58 = new BitmapCharRec(1,6,-1,0,3,ch58data);
+
+/* char: 0x39 '9' */
+
+static final byte[] ch57data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x8,(byte) 0x8,(byte) 0x78,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,
+};
+
+static final BitmapCharRec ch57 = new BitmapCharRec(5,9,-1,0,7,ch57data);
+
+/* char: 0x38 '8' */
+
+static final byte[] ch56data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x70,
+};
+
+static final BitmapCharRec ch56 = new BitmapCharRec(5,9,-1,0,7,ch56data);
+
+/* char: 0x37 '7' */
+
+static final byte[] ch55data = {
+(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x10,(byte) 0x10,(byte) 0x8,(byte) 0xf8,
+};
+
+static final BitmapCharRec ch55 = new BitmapCharRec(5,9,-1,0,7,ch55data);
+
+/* char: 0x36 '6' */
+
+static final byte[] ch54data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0xc8,(byte) 0xb0,(byte) 0x80,(byte) 0x88,(byte) 0x70,
+};
+
+static final BitmapCharRec ch54 = new BitmapCharRec(5,9,-1,0,7,ch54data);
+
+/* char: 0x35 '5' */
+
+static final byte[] ch53data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x8,(byte) 0x8,(byte) 0xf0,(byte) 0x80,(byte) 0x80,(byte) 0xf8,
+};
+
+static final BitmapCharRec ch53 = new BitmapCharRec(5,9,-1,0,7,ch53data);
+
+/* char: 0x34 '4' */
+
+static final byte[] ch52data = {
+(byte) 0x8,(byte) 0x8,(byte) 0xfc,(byte) 0x88,(byte) 0x48,(byte) 0x28,(byte) 0x28,(byte) 0x18,(byte) 0x8,
+};
+
+static final BitmapCharRec ch52 = new BitmapCharRec(6,9,0,0,7,ch52data);
+
+/* char: 0x33 '3' */
+
+static final byte[] ch51data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x8,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x88,(byte) 0x70,
+};
+
+static final BitmapCharRec ch51 = new BitmapCharRec(5,9,-1,0,7,ch51data);
+
+/* char: 0x32 '2' */
+
+static final byte[] ch50data = {
+(byte) 0xf8,(byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x8,(byte) 0x88,(byte) 0x70,
+};
+
+static final BitmapCharRec ch50 = new BitmapCharRec(5,9,-1,0,7,ch50data);
+
+/* char: 0x31 '1' */
+
+static final byte[] ch49data = {
+(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xe0,(byte) 0x20,
+};
+
+static final BitmapCharRec ch49 = new BitmapCharRec(3,9,-1,0,7,ch49data);
+
+/* char: 0x30 '0' */
+
+static final byte[] ch48data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x88,(byte) 0x70,
+};
+
+static final BitmapCharRec ch48 = new BitmapCharRec(5,9,-1,0,7,ch48data);
+
+/* char: 0x2f '/' */
+
+static final byte[] ch47data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x10,(byte) 0x10,
+};
+
+static final BitmapCharRec ch47 = new BitmapCharRec(4,9,0,0,4,ch47data);
+
+/* char: 0x2e '.' */
+
+static final byte[] ch46data = {
+(byte) 0x80,
+};
+
+static final BitmapCharRec ch46 = new BitmapCharRec(1,1,-1,0,3,ch46data);
+
+/* char: 0x2d '-' */
+
+static final byte[] ch45data = {
+(byte) 0xf8,
+};
+
+static final BitmapCharRec ch45 = new BitmapCharRec(5,1,-1,-3,8,ch45data);
+
+/* char: 0x2c ',' */
+
+static final byte[] ch44data = {
+(byte) 0x80,(byte) 0x40,(byte) 0x40,
+};
+
+static final BitmapCharRec ch44 = new BitmapCharRec(2,3,-1,2,4,ch44data);
+
+/* char: 0x2b '+' */
+
+static final byte[] ch43data = {
+(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0x20,
+};
+
+static final BitmapCharRec ch43 = new BitmapCharRec(5,5,-1,-1,7,ch43data);
+
+/* char: 0x2a '*' */
+
+static final byte[] ch42data = {
+(byte) 0xa0,(byte) 0x40,(byte) 0xa0,
+};
+
+static final BitmapCharRec ch42 = new BitmapCharRec(3,3,-1,-6,5,ch42data);
+
+/* char: 0x29 ')' */
+
+static final byte[] ch41data = {
+(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x80,
+};
+
+static final BitmapCharRec ch41 = new BitmapCharRec(3,12,0,3,4,ch41data);
+
+/* char: 0x28 '(' */
+
+static final byte[] ch40data = {
+(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x20,
+};
+
+static final BitmapCharRec ch40 = new BitmapCharRec(3,12,-1,3,4,ch40data);
+
+/* char: 0x27 ''' */
+
+static final byte[] ch39data = {
+(byte) 0x80,(byte) 0x40,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch39 = new BitmapCharRec(2,3,-1,-6,3,ch39data);
+
+/* char: 0x26 '&' */
+
+static final byte[] ch38data = {
+(byte) 0x72,(byte) 0x8c,(byte) 0x84,(byte) 0x8a,(byte) 0x50,(byte) 0x30,(byte) 0x48,(byte) 0x48,(byte) 0x30,
+};
+
+static final BitmapCharRec ch38 = new BitmapCharRec(7,9,-1,0,9,ch38data);
+
+/* char: 0x25 '%' */
+
+static final byte[] ch37data = {
+(byte) 0x23,(byte) 0x0,(byte) 0x14,(byte) 0x80,(byte) 0x14,(byte) 0x80,(byte) 0x13,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x68,(byte) 0x0,(byte) 0x94,(byte) 0x0,(byte) 0x94,(byte) 0x0,
+(byte) 0x62,(byte) 0x0,
+};
+
+static final BitmapCharRec ch37 = new BitmapCharRec(9,9,-1,0,11,ch37data);
+
+/* char: 0x24 '$' */
+
+static final byte[] ch36data = {
+(byte) 0x20,(byte) 0x70,(byte) 0xa8,(byte) 0xa8,(byte) 0x28,(byte) 0x70,(byte) 0xa0,(byte) 0xa8,(byte) 0x70,(byte) 0x20,
+};
+
+static final BitmapCharRec ch36 = new BitmapCharRec(5,10,-1,1,7,ch36data);
+
+/* char: 0x23 '#' */
+
+static final byte[] ch35data = {
+(byte) 0x50,(byte) 0x50,(byte) 0x50,(byte) 0xfc,(byte) 0x28,(byte) 0xfc,(byte) 0x28,(byte) 0x28,
+};
+
+static final BitmapCharRec ch35 = new BitmapCharRec(6,8,0,0,7,ch35data);
+
+/* char: 0x22 '"' */
+
+static final byte[] ch34data = {
+(byte) 0xa0,(byte) 0xa0,(byte) 0xa0,
+};
+
+static final BitmapCharRec ch34 = new BitmapCharRec(3,3,-1,-6,5,ch34data);
+
+/* char: 0x21 '!' */
+
+static final byte[] ch33data = {
+(byte) 0x80,(byte) 0x0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch33 = new BitmapCharRec(1,9,-1,0,3,ch33data);
+
+/* char: 0x20 ' ' */
+
+static final BitmapCharRec ch32 = new BitmapCharRec(0,0,0,0,4,null);
+
+static final BitmapCharRec[] chars = {
+ch32,
+ch33,
+ch34,
+ch35,
+ch36,
+ch37,
+ch38,
+ch39,
+ch40,
+ch41,
+ch42,
+ch43,
+ch44,
+ch45,
+ch46,
+ch47,
+ch48,
+ch49,
+ch50,
+ch51,
+ch52,
+ch53,
+ch54,
+ch55,
+ch56,
+ch57,
+ch58,
+ch59,
+ch60,
+ch61,
+ch62,
+ch63,
+ch64,
+ch65,
+ch66,
+ch67,
+ch68,
+ch69,
+ch70,
+ch71,
+ch72,
+ch73,
+ch74,
+ch75,
+ch76,
+ch77,
+ch78,
+ch79,
+ch80,
+ch81,
+ch82,
+ch83,
+ch84,
+ch85,
+ch86,
+ch87,
+ch88,
+ch89,
+ch90,
+ch91,
+ch92,
+ch93,
+ch94,
+ch95,
+ch96,
+ch97,
+ch98,
+ch99,
+ch100,
+ch101,
+ch102,
+ch103,
+ch104,
+ch105,
+ch106,
+ch107,
+ch108,
+ch109,
+ch110,
+ch111,
+ch112,
+ch113,
+ch114,
+ch115,
+ch116,
+ch117,
+ch118,
+ch119,
+ch120,
+ch121,
+ch122,
+ch123,
+ch124,
+ch125,
+ch126,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+ch160,
+ch161,
+ch162,
+ch163,
+ch164,
+ch165,
+ch166,
+ch167,
+ch168,
+ch169,
+ch170,
+ch171,
+ch172,
+ch173,
+ch174,
+ch175,
+ch176,
+ch177,
+ch178,
+ch179,
+ch180,
+ch181,
+ch182,
+ch183,
+ch184,
+ch185,
+ch186,
+ch187,
+ch188,
+ch189,
+ch190,
+ch191,
+ch192,
+ch193,
+ch194,
+ch195,
+ch196,
+ch197,
+ch198,
+ch199,
+ch200,
+ch201,
+ch202,
+ch203,
+ch204,
+ch205,
+ch206,
+ch207,
+ch208,
+ch209,
+ch210,
+ch211,
+ch212,
+ch213,
+ch214,
+ch215,
+ch216,
+ch217,
+ch218,
+ch219,
+ch220,
+ch221,
+ch222,
+ch223,
+ch224,
+ch225,
+ch226,
+ch227,
+ch228,
+ch229,
+ch230,
+ch231,
+ch232,
+ch233,
+ch234,
+ch235,
+ch236,
+ch237,
+ch238,
+ch239,
+ch240,
+ch241,
+ch242,
+ch243,
+ch244,
+ch245,
+ch246,
+ch247,
+ch248,
+ch249,
+ch250,
+ch251,
+ch252,
+ch253,
+ch254,
+ch255,
+};
+
+  public static final BitmapFontRec glutBitmapHelvetica12 = new BitmapFontRec("-adobe-helvetica-medium-r-normal--12-120-75-75-p-67-iso8859-1",
+                                                                       224,
+                                                                       32,
+                                                                       chars);
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/gl2/GLUTBitmapHelvetica18.java b/src/jogl/classes/com/jogamp/opengl/util/gl2/GLUTBitmapHelvetica18.java
new file mode 100644
index 000000000..1b2e69ba4
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/gl2/GLUTBitmapHelvetica18.java
@@ -0,0 +1,1917 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util.gl2;
+
+class GLUTBitmapHelvetica18 {
+
+/* GENERATED FILE -- DO NOT MODIFY */
+
+/* char: 0xff */
+
+static final byte[] ch255data = {
+(byte) 0x70,(byte) 0x70,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x3c,(byte) 0x24,(byte) 0x66,(byte) 0x66,(byte) 0x66,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0x0,(byte) 0x66,
+(byte) 0x66,
+};
+
+static final BitmapCharRec ch255 = new BitmapCharRec(8,17,-1,4,10,ch255data);
+
+/* char: 0xfe */
+
+static final byte[] ch254data = {
+(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xde,(byte) 0x0,(byte) 0xff,(byte) 0x0,(byte) 0xe3,(byte) 0x0,(byte) 0xc1,(byte) 0x80,
+(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xe3,(byte) 0x0,(byte) 0xff,(byte) 0x0,(byte) 0xde,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,
+(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,
+};
+
+static final BitmapCharRec ch254 = new BitmapCharRec(9,18,-1,4,11,ch254data);
+
+/* char: 0xfd */
+
+static final byte[] ch253data = {
+(byte) 0x70,(byte) 0x70,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x3c,(byte) 0x24,(byte) 0x66,(byte) 0x66,(byte) 0x66,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0x0,(byte) 0x18,
+(byte) 0xc,(byte) 0x6,
+};
+
+static final BitmapCharRec ch253 = new BitmapCharRec(8,18,-1,4,10,ch253data);
+
+/* char: 0xfc */
+
+static final byte[] ch252data = {
+(byte) 0x73,(byte) 0xfb,(byte) 0xc7,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0x0,(byte) 0x66,(byte) 0x66,
+};
+
+static final BitmapCharRec ch252 = new BitmapCharRec(8,13,-1,0,10,ch252data);
+
+/* char: 0xfb */
+
+static final byte[] ch251data = {
+(byte) 0x73,(byte) 0xfb,(byte) 0xc7,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0x0,(byte) 0x66,(byte) 0x3c,(byte) 0x18,
+};
+
+static final BitmapCharRec ch251 = new BitmapCharRec(8,14,-1,0,10,ch251data);
+
+/* char: 0xfa */
+
+static final byte[] ch250data = {
+(byte) 0x73,(byte) 0xfb,(byte) 0xc7,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0x0,(byte) 0x18,(byte) 0xc,(byte) 0x6,
+};
+
+static final BitmapCharRec ch250 = new BitmapCharRec(8,14,-1,0,10,ch250data);
+
+/* char: 0xf9 */
+
+static final byte[] ch249data = {
+(byte) 0x73,(byte) 0xfb,(byte) 0xc7,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0x0,(byte) 0xc,(byte) 0x18,(byte) 0x30,
+};
+
+static final BitmapCharRec ch249 = new BitmapCharRec(8,14,-1,0,10,ch249data);
+
+/* char: 0xf8 */
+
+static final byte[] ch248data = {
+(byte) 0xce,(byte) 0x0,(byte) 0x7f,(byte) 0x80,(byte) 0x31,(byte) 0x80,(byte) 0x78,(byte) 0xc0,(byte) 0x6c,(byte) 0xc0,(byte) 0x66,(byte) 0xc0,(byte) 0x63,(byte) 0xc0,(byte) 0x31,(byte) 0x80,
+(byte) 0x3f,(byte) 0xc0,(byte) 0xe,(byte) 0x60,
+};
+
+static final BitmapCharRec ch248 = new BitmapCharRec(11,10,0,0,11,ch248data);
+
+/* char: 0xf7 */
+
+static final byte[] ch247data = {
+(byte) 0x18,(byte) 0x18,(byte) 0x0,(byte) 0xff,(byte) 0xff,(byte) 0x0,(byte) 0x18,(byte) 0x18,
+};
+
+static final BitmapCharRec ch247 = new BitmapCharRec(8,8,-1,-1,10,ch247data);
+
+/* char: 0xf6 */
+
+static final byte[] ch246data = {
+(byte) 0x3e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0x63,(byte) 0x0,
+(byte) 0x7f,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x36,(byte) 0x0,(byte) 0x36,(byte) 0x0,
+};
+
+static final BitmapCharRec ch246 = new BitmapCharRec(9,13,-1,0,11,ch246data);
+
+/* char: 0xf5 */
+
+static final byte[] ch245data = {
+(byte) 0x3e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0x63,(byte) 0x0,
+(byte) 0x7f,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x26,(byte) 0x0,(byte) 0x2d,(byte) 0x0,(byte) 0x19,(byte) 0x0,
+};
+
+static final BitmapCharRec ch245 = new BitmapCharRec(9,14,-1,0,11,ch245data);
+
+/* char: 0xf4 */
+
+static final byte[] ch244data = {
+(byte) 0x3e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0x63,(byte) 0x0,
+(byte) 0x7f,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x33,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0xc,(byte) 0x0,
+};
+
+static final BitmapCharRec ch244 = new BitmapCharRec(9,14,-1,0,11,ch244data);
+
+/* char: 0xf3 */
+
+static final byte[] ch243data = {
+(byte) 0x3e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0x63,(byte) 0x0,
+(byte) 0x7f,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x6,(byte) 0x0,
+};
+
+static final BitmapCharRec ch243 = new BitmapCharRec(9,14,-1,0,11,ch243data);
+
+/* char: 0xf2 */
+
+static final byte[] ch242data = {
+(byte) 0x3e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0x63,(byte) 0x0,
+(byte) 0x7f,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0x30,(byte) 0x0,
+};
+
+static final BitmapCharRec ch242 = new BitmapCharRec(9,14,-1,0,11,ch242data);
+
+/* char: 0xf1 */
+
+static final byte[] ch241data = {
+(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xe3,(byte) 0xdf,(byte) 0xce,(byte) 0x0,(byte) 0x4c,(byte) 0x5a,(byte) 0x32,
+};
+
+static final BitmapCharRec ch241 = new BitmapCharRec(8,14,-1,0,10,ch241data);
+
+/* char: 0xf0 */
+
+static final byte[] ch240data = {
+(byte) 0x3e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0x63,(byte) 0x0,
+(byte) 0x7f,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x4c,(byte) 0x0,(byte) 0x38,(byte) 0x0,(byte) 0x36,(byte) 0x0,(byte) 0x60,(byte) 0x0,
+};
+
+static final BitmapCharRec ch240 = new BitmapCharRec(9,14,-1,0,11,ch240data);
+
+/* char: 0xef */
+
+static final byte[] ch239data = {
+(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x0,(byte) 0xd8,(byte) 0xd8,
+};
+
+static final BitmapCharRec ch239 = new BitmapCharRec(5,13,0,0,4,ch239data);
+
+/* char: 0xee */
+
+static final byte[] ch238data = {
+(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x0,(byte) 0xcc,(byte) 0x78,(byte) 0x30,
+};
+
+static final BitmapCharRec ch238 = new BitmapCharRec(6,14,1,0,4,ch238data);
+
+/* char: 0xed */
+
+static final byte[] ch237data = {
+(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x0,(byte) 0xc0,(byte) 0x60,(byte) 0x30,
+};
+
+static final BitmapCharRec ch237 = new BitmapCharRec(4,14,0,0,4,ch237data);
+
+/* char: 0xec */
+
+static final byte[] ch236data = {
+(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x0,(byte) 0x30,(byte) 0x60,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch236 = new BitmapCharRec(4,14,0,0,4,ch236data);
+
+/* char: 0xeb */
+
+static final byte[] ch235data = {
+(byte) 0x3c,(byte) 0x7f,(byte) 0xe3,(byte) 0xc0,(byte) 0xc0,(byte) 0xff,(byte) 0xc3,(byte) 0xc3,(byte) 0x7e,(byte) 0x3c,(byte) 0x0,(byte) 0x36,(byte) 0x36,
+};
+
+static final BitmapCharRec ch235 = new BitmapCharRec(8,13,-1,0,10,ch235data);
+
+/* char: 0xea */
+
+static final byte[] ch234data = {
+(byte) 0x3c,(byte) 0x7f,(byte) 0xe3,(byte) 0xc0,(byte) 0xc0,(byte) 0xff,(byte) 0xc3,(byte) 0xc3,(byte) 0x7e,(byte) 0x3c,(byte) 0x0,(byte) 0x66,(byte) 0x3c,(byte) 0x18,
+};
+
+static final BitmapCharRec ch234 = new BitmapCharRec(8,14,-1,0,10,ch234data);
+
+/* char: 0xe9 */
+
+static final byte[] ch233data = {
+(byte) 0x3c,(byte) 0x7f,(byte) 0xe3,(byte) 0xc0,(byte) 0xc0,(byte) 0xff,(byte) 0xc3,(byte) 0xc3,(byte) 0x7e,(byte) 0x3c,(byte) 0x0,(byte) 0x18,(byte) 0xc,(byte) 0x6,
+};
+
+static final BitmapCharRec ch233 = new BitmapCharRec(8,14,-1,0,10,ch233data);
+
+/* char: 0xe8 */
+
+static final byte[] ch232data = {
+(byte) 0x3c,(byte) 0x7f,(byte) 0xe3,(byte) 0xc0,(byte) 0xc0,(byte) 0xff,(byte) 0xc3,(byte) 0xc3,(byte) 0x7e,(byte) 0x3c,(byte) 0x0,(byte) 0x18,(byte) 0x30,(byte) 0x60,
+};
+
+static final BitmapCharRec ch232 = new BitmapCharRec(8,14,-1,0,10,ch232data);
+
+/* char: 0xe7 */
+
+static final byte[] ch231data = {
+(byte) 0x78,(byte) 0x6c,(byte) 0xc,(byte) 0x38,(byte) 0x3e,(byte) 0x7f,(byte) 0x63,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x63,(byte) 0x7f,(byte) 0x3e,
+};
+
+static final BitmapCharRec ch231 = new BitmapCharRec(8,14,-1,4,10,ch231data);
+
+/* char: 0xe6 */
+
+static final byte[] ch230data = {
+(byte) 0x75,(byte) 0xe0,(byte) 0xef,(byte) 0xf8,(byte) 0xc7,(byte) 0x18,(byte) 0xc6,(byte) 0x0,(byte) 0xe6,(byte) 0x0,(byte) 0x7f,(byte) 0xf8,(byte) 0xe,(byte) 0x18,(byte) 0xc6,(byte) 0x18,
+(byte) 0xef,(byte) 0xf0,(byte) 0x7d,(byte) 0xe0,
+};
+
+static final BitmapCharRec ch230 = new BitmapCharRec(13,10,-1,0,15,ch230data);
+
+/* char: 0xe5 */
+
+static final byte[] ch229data = {
+(byte) 0x76,(byte) 0xee,(byte) 0xc6,(byte) 0xc6,(byte) 0xe6,(byte) 0x7e,(byte) 0xe,(byte) 0xc6,(byte) 0xee,(byte) 0x7c,(byte) 0x38,(byte) 0x6c,(byte) 0x6c,(byte) 0x38,
+};
+
+static final BitmapCharRec ch229 = new BitmapCharRec(7,14,-1,0,9,ch229data);
+
+/* char: 0xe4 */
+
+static final byte[] ch228data = {
+(byte) 0x76,(byte) 0xee,(byte) 0xc6,(byte) 0xc6,(byte) 0xe6,(byte) 0x7e,(byte) 0xe,(byte) 0xc6,(byte) 0xee,(byte) 0x7c,(byte) 0x0,(byte) 0x6c,(byte) 0x6c,
+};
+
+static final BitmapCharRec ch228 = new BitmapCharRec(7,13,-1,0,9,ch228data);
+
+/* char: 0xe3 */
+
+static final byte[] ch227data = {
+(byte) 0x76,(byte) 0xee,(byte) 0xc6,(byte) 0xc6,(byte) 0xe6,(byte) 0x7e,(byte) 0xe,(byte) 0xc6,(byte) 0xee,(byte) 0x7c,(byte) 0x0,(byte) 0x4c,(byte) 0x5a,(byte) 0x32,
+};
+
+static final BitmapCharRec ch227 = new BitmapCharRec(7,14,-1,0,9,ch227data);
+
+/* char: 0xe2 */
+
+static final byte[] ch226data = {
+(byte) 0x76,(byte) 0xee,(byte) 0xc6,(byte) 0xc6,(byte) 0xe6,(byte) 0x7e,(byte) 0xe,(byte) 0xc6,(byte) 0xee,(byte) 0x7c,(byte) 0x0,(byte) 0x66,(byte) 0x3c,(byte) 0x18,
+};
+
+static final BitmapCharRec ch226 = new BitmapCharRec(7,14,-1,0,9,ch226data);
+
+/* char: 0xe1 */
+
+static final byte[] ch225data = {
+(byte) 0x76,(byte) 0xee,(byte) 0xc6,(byte) 0xc6,(byte) 0xe6,(byte) 0x7e,(byte) 0xe,(byte) 0xc6,(byte) 0xee,(byte) 0x7c,(byte) 0x0,(byte) 0x30,(byte) 0x18,(byte) 0xc,
+};
+
+static final BitmapCharRec ch225 = new BitmapCharRec(7,14,-1,0,9,ch225data);
+
+/* char: 0xe0 */
+
+static final byte[] ch224data = {
+(byte) 0x76,(byte) 0xee,(byte) 0xc6,(byte) 0xc6,(byte) 0xe6,(byte) 0x7e,(byte) 0xe,(byte) 0xc6,(byte) 0xee,(byte) 0x7c,(byte) 0x0,(byte) 0x18,(byte) 0x30,(byte) 0x60,
+};
+
+static final BitmapCharRec ch224 = new BitmapCharRec(7,14,-1,0,9,ch224data);
+
+/* char: 0xdf */
+
+static final byte[] ch223data = {
+(byte) 0xdc,(byte) 0xde,(byte) 0xc6,(byte) 0xc6,(byte) 0xc6,(byte) 0xc6,(byte) 0xdc,(byte) 0xdc,(byte) 0xc6,(byte) 0xc6,(byte) 0xc6,(byte) 0xc6,(byte) 0x7c,(byte) 0x38,
+};
+
+static final BitmapCharRec ch223 = new BitmapCharRec(7,14,-1,0,9,ch223data);
+
+/* char: 0xde */
+
+static final byte[] ch222data = {
+(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x0,(byte) 0xff,(byte) 0x80,(byte) 0xc1,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,
+(byte) 0xc1,(byte) 0xc0,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,
+};
+
+static final BitmapCharRec ch222 = new BitmapCharRec(10,14,-1,0,12,ch222data);
+
+/* char: 0xdd */
+
+static final byte[] ch221data = {
+(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0x19,(byte) 0x80,
+(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0x0,(byte) 0x0,(byte) 0x6,(byte) 0x0,
+(byte) 0x3,(byte) 0x0,(byte) 0x1,(byte) 0x80,
+};
+
+static final BitmapCharRec ch221 = new BitmapCharRec(12,18,-1,0,14,ch221data);
+
+/* char: 0xdc */
+
+static final byte[] ch220data = {
+(byte) 0x1f,(byte) 0x0,(byte) 0x7f,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,
+(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0x0,(byte) 0x0,(byte) 0x19,(byte) 0x80,
+(byte) 0x19,(byte) 0x80,
+};
+
+static final BitmapCharRec ch220 = new BitmapCharRec(11,17,-1,0,13,ch220data);
+
+/* char: 0xdb */
+
+static final byte[] ch219data = {
+(byte) 0x1f,(byte) 0x0,(byte) 0x7f,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,
+(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0x0,(byte) 0x0,(byte) 0x19,(byte) 0x80,
+(byte) 0xf,(byte) 0x0,(byte) 0x6,(byte) 0x0,
+};
+
+static final BitmapCharRec ch219 = new BitmapCharRec(11,18,-1,0,13,ch219data);
+
+/* char: 0xda */
+
+static final byte[] ch218data = {
+(byte) 0x1f,(byte) 0x0,(byte) 0x7f,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,
+(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0x0,(byte) 0x0,(byte) 0xc,(byte) 0x0,
+(byte) 0x6,(byte) 0x0,(byte) 0x3,(byte) 0x0,
+};
+
+static final BitmapCharRec ch218 = new BitmapCharRec(11,18,-1,0,13,ch218data);
+
+/* char: 0xd9 */
+
+static final byte[] ch217data = {
+(byte) 0x1f,(byte) 0x0,(byte) 0x7f,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,
+(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0x0,(byte) 0x0,(byte) 0x6,(byte) 0x0,
+(byte) 0xc,(byte) 0x0,(byte) 0x18,(byte) 0x0,
+};
+
+static final BitmapCharRec ch217 = new BitmapCharRec(11,18,-1,0,13,ch217data);
+
+/* char: 0xd8 */
+
+static final byte[] ch216data = {
+(byte) 0xc7,(byte) 0xc0,(byte) 0xff,(byte) 0xf0,(byte) 0x78,(byte) 0x38,(byte) 0x38,(byte) 0x18,(byte) 0x6c,(byte) 0x1c,(byte) 0x6e,(byte) 0xc,(byte) 0x67,(byte) 0xc,(byte) 0x63,(byte) 0x8c,
+(byte) 0x61,(byte) 0xcc,(byte) 0x70,(byte) 0xdc,(byte) 0x30,(byte) 0x78,(byte) 0x38,(byte) 0x38,(byte) 0x1f,(byte) 0xfc,(byte) 0x7,(byte) 0xcc,
+};
+
+static final BitmapCharRec ch216 = new BitmapCharRec(14,14,0,0,15,ch216data);
+
+/* char: 0xd7 */
+
+static final byte[] ch215data = {
+(byte) 0xc0,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x33,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0x33,(byte) 0x0,(byte) 0x61,(byte) 0x80,
+(byte) 0xc0,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch215 = new BitmapCharRec(10,9,0,0,10,ch215data);
+
+/* char: 0xd6 */
+
+static final byte[] ch214data = {
+(byte) 0xf,(byte) 0x80,(byte) 0x3f,(byte) 0xe0,(byte) 0x70,(byte) 0x70,(byte) 0x60,(byte) 0x30,(byte) 0xe0,(byte) 0x38,(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18,
+(byte) 0xc0,(byte) 0x18,(byte) 0xe0,(byte) 0x38,(byte) 0x60,(byte) 0x30,(byte) 0x70,(byte) 0x70,(byte) 0x3f,(byte) 0xe0,(byte) 0xf,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0xd,(byte) 0x80,
+(byte) 0xd,(byte) 0x80,
+};
+
+static final BitmapCharRec ch214 = new BitmapCharRec(13,17,-1,0,15,ch214data);
+
+/* char: 0xd5 */
+
+static final byte[] ch213data = {
+(byte) 0xf,(byte) 0x80,(byte) 0x3f,(byte) 0xe0,(byte) 0x70,(byte) 0x70,(byte) 0x60,(byte) 0x30,(byte) 0xe0,(byte) 0x38,(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18,
+(byte) 0xc0,(byte) 0x18,(byte) 0xe0,(byte) 0x38,(byte) 0x60,(byte) 0x30,(byte) 0x70,(byte) 0x70,(byte) 0x3f,(byte) 0xe0,(byte) 0xf,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x9,(byte) 0x80,
+(byte) 0xb,(byte) 0x40,(byte) 0x6,(byte) 0x40,
+};
+
+static final BitmapCharRec ch213 = new BitmapCharRec(13,18,-1,0,15,ch213data);
+
+/* char: 0xd4 */
+
+static final byte[] ch212data = {
+(byte) 0xf,(byte) 0x80,(byte) 0x3f,(byte) 0xe0,(byte) 0x70,(byte) 0x70,(byte) 0x60,(byte) 0x30,(byte) 0xe0,(byte) 0x38,(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18,
+(byte) 0xc0,(byte) 0x18,(byte) 0xe0,(byte) 0x38,(byte) 0x60,(byte) 0x30,(byte) 0x70,(byte) 0x70,(byte) 0x3f,(byte) 0xe0,(byte) 0xf,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0xc,(byte) 0xc0,
+(byte) 0x7,(byte) 0x80,(byte) 0x3,(byte) 0x0,
+};
+
+static final BitmapCharRec ch212 = new BitmapCharRec(13,18,-1,0,15,ch212data);
+
+/* char: 0xd3 */
+
+static final byte[] ch211data = {
+(byte) 0xf,(byte) 0x80,(byte) 0x3f,(byte) 0xe0,(byte) 0x70,(byte) 0x70,(byte) 0x60,(byte) 0x30,(byte) 0xe0,(byte) 0x38,(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18,
+(byte) 0xc0,(byte) 0x18,(byte) 0xe0,(byte) 0x38,(byte) 0x60,(byte) 0x30,(byte) 0x70,(byte) 0x70,(byte) 0x3f,(byte) 0xe0,(byte) 0xf,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x3,(byte) 0x0,
+(byte) 0x1,(byte) 0x80,(byte) 0x0,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch211 = new BitmapCharRec(13,18,-1,0,15,ch211data);
+
+/* char: 0xd2 */
+
+static final byte[] ch210data = {
+(byte) 0xf,(byte) 0x80,(byte) 0x3f,(byte) 0xe0,(byte) 0x70,(byte) 0x70,(byte) 0x60,(byte) 0x30,(byte) 0xe0,(byte) 0x38,(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18,
+(byte) 0xc0,(byte) 0x18,(byte) 0xe0,(byte) 0x38,(byte) 0x60,(byte) 0x30,(byte) 0x70,(byte) 0x70,(byte) 0x3f,(byte) 0xe0,(byte) 0xf,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x3,(byte) 0x0,
+(byte) 0x6,(byte) 0x0,(byte) 0xc,(byte) 0x0,
+};
+
+static final BitmapCharRec ch210 = new BitmapCharRec(13,18,-1,0,15,ch210data);
+
+/* char: 0xd1 */
+
+static final byte[] ch209data = {
+(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xe0,(byte) 0xc1,(byte) 0xe0,(byte) 0xc1,(byte) 0xe0,(byte) 0xc3,(byte) 0x60,(byte) 0xc6,(byte) 0x60,(byte) 0xc6,(byte) 0x60,(byte) 0xcc,(byte) 0x60,
+(byte) 0xcc,(byte) 0x60,(byte) 0xd8,(byte) 0x60,(byte) 0xd8,(byte) 0x60,(byte) 0xf0,(byte) 0x60,(byte) 0xe0,(byte) 0x60,(byte) 0xe0,(byte) 0x60,(byte) 0x0,(byte) 0x0,(byte) 0x13,(byte) 0x0,
+(byte) 0x16,(byte) 0x80,(byte) 0xc,(byte) 0x80,
+};
+
+static final BitmapCharRec ch209 = new BitmapCharRec(11,18,-1,0,13,ch209data);
+
+/* char: 0xd0 */
+
+static final byte[] ch208data = {
+(byte) 0x7f,(byte) 0x80,(byte) 0x7f,(byte) 0xc0,(byte) 0x60,(byte) 0xe0,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x30,(byte) 0x60,(byte) 0x30,(byte) 0xfc,(byte) 0x30,(byte) 0xfc,(byte) 0x30,
+(byte) 0x60,(byte) 0x30,(byte) 0x60,(byte) 0x30,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0xe0,(byte) 0x7f,(byte) 0xc0,(byte) 0x7f,(byte) 0x80,
+};
+
+static final BitmapCharRec ch208 = new BitmapCharRec(12,14,0,0,13,ch208data);
+
+/* char: 0xcf */
+
+static final byte[] ch207data = {
+(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x0,(byte) 0xcc,
+(byte) 0xcc,
+};
+
+static final BitmapCharRec ch207 = new BitmapCharRec(6,17,0,0,6,ch207data);
+
+/* char: 0xce */
+
+static final byte[] ch206data = {
+(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x0,(byte) 0xcc,
+(byte) 0x78,(byte) 0x30,
+};
+
+static final BitmapCharRec ch206 = new BitmapCharRec(6,18,0,0,6,ch206data);
+
+/* char: 0xcd */
+
+static final byte[] ch205data = {
+(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,
+(byte) 0x60,(byte) 0x30,
+};
+
+static final BitmapCharRec ch205 = new BitmapCharRec(4,18,-2,0,6,ch205data);
+
+/* char: 0xcc */
+
+static final byte[] ch204data = {
+(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x0,(byte) 0x30,
+(byte) 0x60,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch204 = new BitmapCharRec(4,18,0,0,6,ch204data);
+
+/* char: 0xcb */
+
+static final byte[] ch203data = {
+(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x0,(byte) 0xff,(byte) 0x0,
+(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x33,(byte) 0x0,
+(byte) 0x33,(byte) 0x0,
+};
+
+static final BitmapCharRec ch203 = new BitmapCharRec(9,17,-1,0,11,ch203data);
+
+/* char: 0xca */
+
+static final byte[] ch202data = {
+(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x0,(byte) 0xff,(byte) 0x0,
+(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x33,(byte) 0x0,
+(byte) 0x1e,(byte) 0x0,(byte) 0xc,(byte) 0x0,
+};
+
+static final BitmapCharRec ch202 = new BitmapCharRec(9,18,-1,0,11,ch202data);
+
+/* char: 0xc9 */
+
+static final byte[] ch201data = {
+(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x0,(byte) 0xff,(byte) 0x0,
+(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0xc,(byte) 0x0,
+(byte) 0x6,(byte) 0x0,(byte) 0x3,(byte) 0x0,
+};
+
+static final BitmapCharRec ch201 = new BitmapCharRec(9,18,-1,0,11,ch201data);
+
+/* char: 0xc8 */
+
+static final byte[] ch200data = {
+(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x0,(byte) 0xff,(byte) 0x0,
+(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0xc,(byte) 0x0,
+(byte) 0x18,(byte) 0x0,(byte) 0x30,(byte) 0x0,
+};
+
+static final BitmapCharRec ch200 = new BitmapCharRec(9,18,-1,0,11,ch200data);
+
+/* char: 0xc7 */
+
+static final byte[] ch199data = {
+(byte) 0x1e,(byte) 0x0,(byte) 0x1b,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0xe,(byte) 0x0,(byte) 0xf,(byte) 0x80,(byte) 0x3f,(byte) 0xe0,(byte) 0x70,(byte) 0x70,(byte) 0x60,(byte) 0x30,
+(byte) 0xe0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xe0,(byte) 0x0,(byte) 0x60,(byte) 0x30,(byte) 0x70,(byte) 0x70,
+(byte) 0x3f,(byte) 0xe0,(byte) 0xf,(byte) 0x80,
+};
+
+static final BitmapCharRec ch199 = new BitmapCharRec(12,18,-1,4,14,ch199data);
+
+/* char: 0xc6 */
+
+static final byte[] ch198data = {
+(byte) 0xc1,(byte) 0xff,(byte) 0xc1,(byte) 0xff,(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x7f,(byte) 0x80,(byte) 0x3f,(byte) 0x80,(byte) 0x31,(byte) 0xfe,(byte) 0x31,(byte) 0xfe,
+(byte) 0x19,(byte) 0x80,(byte) 0x19,(byte) 0x80,(byte) 0xd,(byte) 0x80,(byte) 0xd,(byte) 0x80,(byte) 0x7,(byte) 0xff,(byte) 0x7,(byte) 0xff,
+};
+
+static final BitmapCharRec ch198 = new BitmapCharRec(16,14,-1,0,18,ch198data);
+
+/* char: 0xc5 */
+
+static final byte[] ch197data = {
+(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x7f,(byte) 0xe0,(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,
+(byte) 0x19,(byte) 0x80,(byte) 0x19,(byte) 0x80,(byte) 0xf,(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0x19,(byte) 0x80,
+(byte) 0x19,(byte) 0x80,(byte) 0xf,(byte) 0x0,
+};
+
+static final BitmapCharRec ch197 = new BitmapCharRec(12,18,0,0,12,ch197data);
+
+/* char: 0xc4 */
+
+static final byte[] ch196data = {
+(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x7f,(byte) 0xe0,(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,
+(byte) 0x19,(byte) 0x80,(byte) 0x19,(byte) 0x80,(byte) 0xf,(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x19,(byte) 0x80,
+(byte) 0x19,(byte) 0x80,
+};
+
+static final BitmapCharRec ch196 = new BitmapCharRec(12,17,0,0,12,ch196data);
+
+/* char: 0xc3 */
+
+static final byte[] ch195data = {
+(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x7f,(byte) 0xe0,(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,
+(byte) 0x19,(byte) 0x80,(byte) 0x19,(byte) 0x80,(byte) 0xf,(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x13,(byte) 0x0,
+(byte) 0x16,(byte) 0x80,(byte) 0xc,(byte) 0x80,
+};
+
+static final BitmapCharRec ch195 = new BitmapCharRec(12,18,0,0,12,ch195data);
+
+/* char: 0xc2 */
+
+static final byte[] ch194data = {
+(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x7f,(byte) 0xe0,(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,
+(byte) 0x19,(byte) 0x80,(byte) 0x19,(byte) 0x80,(byte) 0xf,(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x19,(byte) 0x80,
+(byte) 0xf,(byte) 0x0,(byte) 0x6,(byte) 0x0,
+};
+
+static final BitmapCharRec ch194 = new BitmapCharRec(12,18,0,0,12,ch194data);
+
+/* char: 0xc1 */
+
+static final byte[] ch193data = {
+(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x7f,(byte) 0xe0,(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,
+(byte) 0x19,(byte) 0x80,(byte) 0x19,(byte) 0x80,(byte) 0xf,(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x6,(byte) 0x0,
+(byte) 0x3,(byte) 0x0,(byte) 0x1,(byte) 0x80,
+};
+
+static final BitmapCharRec ch193 = new BitmapCharRec(12,18,0,0,12,ch193data);
+
+/* char: 0xc0 */
+
+static final byte[] ch192data = {
+(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x7f,(byte) 0xe0,(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,
+(byte) 0x19,(byte) 0x80,(byte) 0x19,(byte) 0x80,(byte) 0xf,(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x6,(byte) 0x0,
+(byte) 0xc,(byte) 0x0,(byte) 0x18,(byte) 0x0,
+};
+
+static final BitmapCharRec ch192 = new BitmapCharRec(12,18,0,0,12,ch192data);
+
+/* char: 0xbf */
+
+static final byte[] ch191data = {
+(byte) 0x7c,(byte) 0xfe,(byte) 0xc6,(byte) 0xc6,(byte) 0xe0,(byte) 0x70,(byte) 0x38,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x0,(byte) 0x0,(byte) 0x18,(byte) 0x18,
+};
+
+static final BitmapCharRec ch191 = new BitmapCharRec(7,14,-1,4,10,ch191data);
+
+/* char: 0xbe */
+
+static final byte[] ch190data = {
+(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0xc,(byte) 0xfc,(byte) 0x6,(byte) 0xd8,(byte) 0x6,(byte) 0x78,(byte) 0x73,(byte) 0x38,(byte) 0xf9,(byte) 0x18,(byte) 0x99,(byte) 0x88,
+(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x98,(byte) 0x60,(byte) 0xf8,(byte) 0x30,(byte) 0x70,(byte) 0x30,
+};
+
+static final BitmapCharRec ch190 = new BitmapCharRec(14,13,0,0,15,ch190data);
+
+/* char: 0xbd */
+
+static final byte[] ch189data = {
+(byte) 0x30,(byte) 0xf8,(byte) 0x30,(byte) 0xf8,(byte) 0x18,(byte) 0x60,(byte) 0xc,(byte) 0x30,(byte) 0xc,(byte) 0x18,(byte) 0x66,(byte) 0x98,(byte) 0x62,(byte) 0xf8,(byte) 0x63,(byte) 0x70,
+(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0xe0,(byte) 0xc0,(byte) 0xe0,(byte) 0x60,(byte) 0x60,(byte) 0x60,
+};
+
+static final BitmapCharRec ch189 = new BitmapCharRec(13,13,-1,0,15,ch189data);
+
+/* char: 0xbc */
+
+static final byte[] ch188data = {
+(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x19,(byte) 0xf8,(byte) 0xd,(byte) 0xb0,(byte) 0xc,(byte) 0xf0,(byte) 0x66,(byte) 0x70,(byte) 0x62,(byte) 0x30,(byte) 0x63,(byte) 0x10,
+(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0xe0,(byte) 0xc0,(byte) 0xe0,(byte) 0x60,(byte) 0x60,(byte) 0x60,
+};
+
+static final BitmapCharRec ch188 = new BitmapCharRec(13,13,-1,0,15,ch188data);
+
+/* char: 0xbb */
+
+static final byte[] ch187data = {
+(byte) 0x90,(byte) 0xd8,(byte) 0x6c,(byte) 0x36,(byte) 0x36,(byte) 0x6c,(byte) 0xd8,(byte) 0x90,
+};
+
+static final BitmapCharRec ch187 = new BitmapCharRec(7,8,-1,-1,9,ch187data);
+
+/* char: 0xba */
+
+static final byte[] ch186data = {
+(byte) 0xf8,(byte) 0x0,(byte) 0x70,(byte) 0xd8,(byte) 0x88,(byte) 0x88,(byte) 0xd8,(byte) 0x70,
+};
+
+static final BitmapCharRec ch186 = new BitmapCharRec(5,8,-1,-6,7,ch186data);
+
+/* char: 0xb9 */
+
+static final byte[] ch185data = {
+(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0xe0,(byte) 0xe0,(byte) 0x60,
+};
+
+static final BitmapCharRec ch185 = new BitmapCharRec(3,8,-1,-5,6,ch185data);
+
+/* char: 0xb8 */
+
+static final byte[] ch184data = {
+(byte) 0xf0,(byte) 0xd8,(byte) 0x18,(byte) 0x70,(byte) 0x60,
+};
+
+static final BitmapCharRec ch184 = new BitmapCharRec(5,5,0,4,5,ch184data);
+
+/* char: 0xb7 */
+
+static final byte[] ch183data = {
+(byte) 0xc0,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch183 = new BitmapCharRec(2,2,-1,-4,4,ch183data);
+
+/* char: 0xb6 */
+
+static final byte[] ch182data = {
+(byte) 0x12,(byte) 0x12,(byte) 0x12,(byte) 0x12,(byte) 0x12,(byte) 0x12,(byte) 0x12,(byte) 0x12,(byte) 0x12,(byte) 0x12,(byte) 0x32,(byte) 0x72,(byte) 0xf2,(byte) 0xf2,(byte) 0xf2,(byte) 0xf2,
+(byte) 0x72,(byte) 0x3f,
+};
+
+static final BitmapCharRec ch182 = new BitmapCharRec(8,18,-1,4,10,ch182data);
+
+/* char: 0xb5 */
+
+static final byte[] ch181data = {
+(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xdb,(byte) 0xff,(byte) 0xe7,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,
+};
+
+static final BitmapCharRec ch181 = new BitmapCharRec(8,14,-1,4,10,ch181data);
+
+/* char: 0xb4 */
+
+static final byte[] ch180data = {
+(byte) 0xc0,(byte) 0x60,(byte) 0x30,
+};
+
+static final BitmapCharRec ch180 = new BitmapCharRec(4,3,0,-11,4,ch180data);
+
+/* char: 0xb3 */
+
+static final byte[] ch179data = {
+(byte) 0x70,(byte) 0xf8,(byte) 0x98,(byte) 0x30,(byte) 0x30,(byte) 0x98,(byte) 0xf8,(byte) 0x70,
+};
+
+static final BitmapCharRec ch179 = new BitmapCharRec(5,8,0,-5,6,ch179data);
+
+/* char: 0xb2 */
+
+static final byte[] ch178data = {
+(byte) 0xf8,(byte) 0xf8,(byte) 0x60,(byte) 0x30,(byte) 0x18,(byte) 0x98,(byte) 0xf8,(byte) 0x70,
+};
+
+static final BitmapCharRec ch178 = new BitmapCharRec(5,8,0,-5,6,ch178data);
+
+/* char: 0xb1 */
+
+static final byte[] ch177data = {
+(byte) 0xff,(byte) 0xff,(byte) 0x0,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0xff,(byte) 0xff,(byte) 0x18,(byte) 0x18,(byte) 0x18,
+};
+
+static final BitmapCharRec ch177 = new BitmapCharRec(8,11,-1,0,10,ch177data);
+
+/* char: 0xb0 */
+
+static final byte[] ch176data = {
+(byte) 0x70,(byte) 0xd8,(byte) 0x88,(byte) 0xd8,(byte) 0x70,
+};
+
+static final BitmapCharRec ch176 = new BitmapCharRec(5,5,-1,-8,7,ch176data);
+
+/* char: 0xaf */
+
+static final byte[] ch175data = {
+(byte) 0xf8,
+};
+
+static final BitmapCharRec ch175 = new BitmapCharRec(5,1,0,-12,5,ch175data);
+
+/* char: 0xae */
+
+static final byte[] ch174data = {
+(byte) 0xf,(byte) 0x80,(byte) 0x30,(byte) 0x60,(byte) 0x40,(byte) 0x10,(byte) 0x48,(byte) 0x50,(byte) 0x88,(byte) 0x88,(byte) 0x89,(byte) 0x8,(byte) 0x8f,(byte) 0x88,(byte) 0x88,(byte) 0x48,
+(byte) 0x88,(byte) 0x48,(byte) 0x4f,(byte) 0x90,(byte) 0x40,(byte) 0x10,(byte) 0x30,(byte) 0x60,(byte) 0xf,(byte) 0x80,
+};
+
+static final BitmapCharRec ch174 = new BitmapCharRec(13,13,-1,0,14,ch174data);
+
+/* char: 0xad */
+
+static final byte[] ch173data = {
+(byte) 0xf8,(byte) 0xf8,
+};
+
+static final BitmapCharRec ch173 = new BitmapCharRec(5,2,-1,-4,7,ch173data);
+
+/* char: 0xac */
+
+static final byte[] ch172data = {
+(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80,
+};
+
+static final BitmapCharRec ch172 = new BitmapCharRec(9,5,-1,-3,11,ch172data);
+
+/* char: 0xab */
+
+static final byte[] ch171data = {
+(byte) 0x12,(byte) 0x36,(byte) 0x6c,(byte) 0xd8,(byte) 0xd8,(byte) 0x6c,(byte) 0x36,(byte) 0x12,
+};
+
+static final BitmapCharRec ch171 = new BitmapCharRec(7,8,-1,-1,9,ch171data);
+
+/* char: 0xaa */
+
+static final byte[] ch170data = {
+(byte) 0xf8,(byte) 0x0,(byte) 0x68,(byte) 0xd8,(byte) 0x48,(byte) 0x38,(byte) 0xc8,(byte) 0x70,
+};
+
+static final BitmapCharRec ch170 = new BitmapCharRec(5,8,-1,-6,7,ch170data);
+
+/* char: 0xa9 */
+
+static final byte[] ch169data = {
+(byte) 0xf,(byte) 0x80,(byte) 0x30,(byte) 0x60,(byte) 0x40,(byte) 0x10,(byte) 0x47,(byte) 0x10,(byte) 0x88,(byte) 0x88,(byte) 0x90,(byte) 0x8,(byte) 0x90,(byte) 0x8,(byte) 0x90,(byte) 0x8,
+(byte) 0x88,(byte) 0x88,(byte) 0x47,(byte) 0x10,(byte) 0x40,(byte) 0x10,(byte) 0x30,(byte) 0x60,(byte) 0xf,(byte) 0x80,
+};
+
+static final BitmapCharRec ch169 = new BitmapCharRec(13,13,-1,0,15,ch169data);
+
+/* char: 0xa8 */
+
+static final byte[] ch168data = {
+(byte) 0xd8,(byte) 0xd8,
+};
+
+static final BitmapCharRec ch168 = new BitmapCharRec(5,2,0,-11,6,ch168data);
+
+/* char: 0xa7 */
+
+static final byte[] ch167data = {
+(byte) 0x3c,(byte) 0x7e,(byte) 0xc3,(byte) 0xc3,(byte) 0x7,(byte) 0xe,(byte) 0x3e,(byte) 0x73,(byte) 0xe3,(byte) 0xc3,(byte) 0xc7,(byte) 0x6e,(byte) 0x7c,(byte) 0xf0,(byte) 0xc3,(byte) 0xc3,
+(byte) 0x7e,(byte) 0x3c,
+};
+
+static final BitmapCharRec ch167 = new BitmapCharRec(8,18,-1,4,10,ch167data);
+
+/* char: 0xa6 */
+
+static final byte[] ch166data = {
+(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,
+(byte) 0xc0,
+};
+
+static final BitmapCharRec ch166 = new BitmapCharRec(2,17,-1,3,4,ch166data);
+
+/* char: 0xa5 */
+
+static final byte[] ch165data = {
+(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0xff,(byte) 0x18,(byte) 0xff,(byte) 0x3c,(byte) 0x66,(byte) 0x66,(byte) 0x66,(byte) 0xc3,(byte) 0xc3,
+};
+
+static final BitmapCharRec ch165 = new BitmapCharRec(8,13,-1,0,10,ch165data);
+
+/* char: 0xa4 */
+
+static final byte[] ch164data = {
+(byte) 0xc3,(byte) 0xff,(byte) 0x66,(byte) 0x66,(byte) 0x66,(byte) 0xff,(byte) 0xc3,
+};
+
+static final BitmapCharRec ch164 = new BitmapCharRec(8,7,-1,-3,10,ch164data);
+
+/* char: 0xa3 */
+
+static final byte[] ch163data = {
+(byte) 0xdf,(byte) 0x0,(byte) 0xff,(byte) 0x80,(byte) 0x60,(byte) 0x80,(byte) 0x30,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0x7e,(byte) 0x0,(byte) 0x30,(byte) 0x0,
+(byte) 0x60,(byte) 0x0,(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x3f,(byte) 0x0,(byte) 0x1e,(byte) 0x0,
+};
+
+static final BitmapCharRec ch163 = new BitmapCharRec(9,13,0,0,10,ch163data);
+
+/* char: 0xa2 */
+
+static final byte[] ch162data = {
+(byte) 0x10,(byte) 0x10,(byte) 0x3e,(byte) 0x7f,(byte) 0x6b,(byte) 0xc8,(byte) 0xc8,(byte) 0xc8,(byte) 0xc8,(byte) 0x6b,(byte) 0x7f,(byte) 0x3e,(byte) 0x4,(byte) 0x4,
+};
+
+static final BitmapCharRec ch162 = new BitmapCharRec(8,14,-1,2,10,ch162data);
+
+/* char: 0xa1 */
+
+static final byte[] ch161data = {
+(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch161 = new BitmapCharRec(2,14,-2,4,6,ch161data);
+
+/* char: 0xa0 */
+
+static final BitmapCharRec ch160 = new BitmapCharRec(0,0,0,0,5,null);
+
+/* char: 0x7e '~' */
+
+static final byte[] ch126data = {
+(byte) 0xcc,(byte) 0x7e,(byte) 0x33,
+};
+
+static final BitmapCharRec ch126 = new BitmapCharRec(8,3,-1,-4,10,ch126data);
+
+/* char: 0x7d '}' */
+
+static final byte[] ch125data = {
+(byte) 0xc0,(byte) 0x60,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x18,(byte) 0xc,(byte) 0x18,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,
+(byte) 0x60,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch125 = new BitmapCharRec(6,18,0,4,6,ch125data);
+
+/* char: 0x7c '|' */
+
+static final byte[] ch124data = {
+(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,
+(byte) 0xc0,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch124 = new BitmapCharRec(2,18,-1,4,4,ch124data);
+
+/* char: 0x7b '{' */
+
+static final byte[] ch123data = {
+(byte) 0xc,(byte) 0x18,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,
+(byte) 0x18,(byte) 0xc,
+};
+
+static final BitmapCharRec ch123 = new BitmapCharRec(6,18,0,4,6,ch123data);
+
+/* char: 0x7a 'z' */
+
+static final byte[] ch122data = {
+(byte) 0xfe,(byte) 0xfe,(byte) 0xc0,(byte) 0x60,(byte) 0x30,(byte) 0x18,(byte) 0xc,(byte) 0x6,(byte) 0xfe,(byte) 0xfe,
+};
+
+static final BitmapCharRec ch122 = new BitmapCharRec(7,10,-1,0,9,ch122data);
+
+/* char: 0x79 'y' */
+
+static final byte[] ch121data = {
+(byte) 0x70,(byte) 0x70,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x3c,(byte) 0x24,(byte) 0x66,(byte) 0x66,(byte) 0x66,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,
+};
+
+static final BitmapCharRec ch121 = new BitmapCharRec(8,14,-1,4,10,ch121data);
+
+/* char: 0x78 'x' */
+
+static final byte[] ch120data = {
+(byte) 0xc3,(byte) 0xe7,(byte) 0x66,(byte) 0x3c,(byte) 0x18,(byte) 0x18,(byte) 0x3c,(byte) 0x66,(byte) 0xe7,(byte) 0xc3,
+};
+
+static final BitmapCharRec ch120 = new BitmapCharRec(8,10,-1,0,10,ch120data);
+
+/* char: 0x77 'w' */
+
+static final byte[] ch119data = {
+(byte) 0x19,(byte) 0x80,(byte) 0x19,(byte) 0x80,(byte) 0x39,(byte) 0xc0,(byte) 0x29,(byte) 0x40,(byte) 0x69,(byte) 0x60,(byte) 0x66,(byte) 0x60,(byte) 0x66,(byte) 0x60,(byte) 0xc6,(byte) 0x30,
+(byte) 0xc6,(byte) 0x30,(byte) 0xc6,(byte) 0x30,
+};
+
+static final BitmapCharRec ch119 = new BitmapCharRec(12,10,-1,0,14,ch119data);
+
+/* char: 0x76 'v' */
+
+static final byte[] ch118data = {
+(byte) 0x18,(byte) 0x18,(byte) 0x3c,(byte) 0x24,(byte) 0x66,(byte) 0x66,(byte) 0x66,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,
+};
+
+static final BitmapCharRec ch118 = new BitmapCharRec(8,10,-1,0,10,ch118data);
+
+/* char: 0x75 'u' */
+
+static final byte[] ch117data = {
+(byte) 0x73,(byte) 0xfb,(byte) 0xc7,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,
+};
+
+static final BitmapCharRec ch117 = new BitmapCharRec(8,10,-1,0,10,ch117data);
+
+/* char: 0x74 't' */
+
+static final byte[] ch116data = {
+(byte) 0x18,(byte) 0x38,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0xfc,(byte) 0xfc,(byte) 0x30,(byte) 0x30,(byte) 0x30,
+};
+
+static final BitmapCharRec ch116 = new BitmapCharRec(6,13,0,0,6,ch116data);
+
+/* char: 0x73 's' */
+
+static final byte[] ch115data = {
+(byte) 0x78,(byte) 0xfc,(byte) 0xc6,(byte) 0x6,(byte) 0x3e,(byte) 0xfc,(byte) 0xc0,(byte) 0xc6,(byte) 0x7e,(byte) 0x3c,
+};
+
+static final BitmapCharRec ch115 = new BitmapCharRec(7,10,-1,0,9,ch115data);
+
+/* char: 0x72 'r' */
+
+static final byte[] ch114data = {
+(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xe0,(byte) 0xd8,(byte) 0xd8,
+};
+
+static final BitmapCharRec ch114 = new BitmapCharRec(5,10,-1,0,6,ch114data);
+
+/* char: 0x71 'q' */
+
+static final byte[] ch113data = {
+(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x3d,(byte) 0x80,(byte) 0x7f,(byte) 0x80,(byte) 0x63,(byte) 0x80,(byte) 0xc1,(byte) 0x80,
+(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0x63,(byte) 0x80,(byte) 0x7f,(byte) 0x80,(byte) 0x3d,(byte) 0x80,
+};
+
+static final BitmapCharRec ch113 = new BitmapCharRec(9,14,-1,4,11,ch113data);
+
+/* char: 0x70 'p' */
+
+static final byte[] ch112data = {
+(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xde,(byte) 0x0,(byte) 0xff,(byte) 0x0,(byte) 0xe3,(byte) 0x0,(byte) 0xc1,(byte) 0x80,
+(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xe3,(byte) 0x0,(byte) 0xff,(byte) 0x0,(byte) 0xde,(byte) 0x0,
+};
+
+static final BitmapCharRec ch112 = new BitmapCharRec(9,14,-1,4,11,ch112data);
+
+/* char: 0x6f 'o' */
+
+static final byte[] ch111data = {
+(byte) 0x3e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0x63,(byte) 0x0,
+(byte) 0x7f,(byte) 0x0,(byte) 0x3e,(byte) 0x0,
+};
+
+static final BitmapCharRec ch111 = new BitmapCharRec(9,10,-1,0,11,ch111data);
+
+/* char: 0x6e 'n' */
+
+static final byte[] ch110data = {
+(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xe3,(byte) 0xdf,(byte) 0xce,
+};
+
+static final BitmapCharRec ch110 = new BitmapCharRec(8,10,-1,0,10,ch110data);
+
+/* char: 0x6d 'm' */
+
+static final byte[] ch109data = {
+(byte) 0xc6,(byte) 0x30,(byte) 0xc6,(byte) 0x30,(byte) 0xc6,(byte) 0x30,(byte) 0xc6,(byte) 0x30,(byte) 0xc6,(byte) 0x30,(byte) 0xc6,(byte) 0x30,(byte) 0xc6,(byte) 0x30,(byte) 0xe7,(byte) 0x30,
+(byte) 0xde,(byte) 0xf0,(byte) 0xcc,(byte) 0x60,
+};
+
+static final BitmapCharRec ch109 = new BitmapCharRec(12,10,-1,0,14,ch109data);
+
+/* char: 0x6c 'l' */
+
+static final byte[] ch108data = {
+(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch108 = new BitmapCharRec(2,14,-1,0,4,ch108data);
+
+/* char: 0x6b 'k' */
+
+static final byte[] ch107data = {
+(byte) 0xc7,(byte) 0xc6,(byte) 0xce,(byte) 0xcc,(byte) 0xd8,(byte) 0xf8,(byte) 0xf0,(byte) 0xd8,(byte) 0xcc,(byte) 0xc6,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch107 = new BitmapCharRec(8,14,-1,0,9,ch107data);
+
+/* char: 0x6a 'j' */
+
+static final byte[] ch106data = {
+(byte) 0xe0,(byte) 0xf0,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x0,(byte) 0x0,
+(byte) 0x30,(byte) 0x30,
+};
+
+static final BitmapCharRec ch106 = new BitmapCharRec(4,18,1,4,4,ch106data);
+
+/* char: 0x69 'i' */
+
+static final byte[] ch105data = {
+(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch105 = new BitmapCharRec(2,14,-1,0,4,ch105data);
+
+/* char: 0x68 'h' */
+
+static final byte[] ch104data = {
+(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xe3,(byte) 0xdf,(byte) 0xce,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch104 = new BitmapCharRec(8,14,-1,0,10,ch104data);
+
+/* char: 0x67 'g' */
+
+static final byte[] ch103data = {
+(byte) 0x1c,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x1,(byte) 0x80,(byte) 0x3d,(byte) 0x80,(byte) 0x7f,(byte) 0x80,(byte) 0x63,(byte) 0x80,(byte) 0xc1,(byte) 0x80,
+(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x7f,(byte) 0x80,(byte) 0x3d,(byte) 0x80,
+};
+
+static final BitmapCharRec ch103 = new BitmapCharRec(9,14,-1,4,11,ch103data);
+
+/* char: 0x66 'f' */
+
+static final byte[] ch102data = {
+(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0xfc,(byte) 0xfc,(byte) 0x30,(byte) 0x30,(byte) 0x3c,(byte) 0x1c,
+};
+
+static final BitmapCharRec ch102 = new BitmapCharRec(6,14,0,0,6,ch102data);
+
+/* char: 0x65 'e' */
+
+static final byte[] ch101data = {
+(byte) 0x3c,(byte) 0x7f,(byte) 0xe3,(byte) 0xc0,(byte) 0xc0,(byte) 0xff,(byte) 0xc3,(byte) 0xc3,(byte) 0x7e,(byte) 0x3c,
+};
+
+static final BitmapCharRec ch101 = new BitmapCharRec(8,10,-1,0,10,ch101data);
+
+/* char: 0x64 'd' */
+
+static final byte[] ch100data = {
+(byte) 0x3d,(byte) 0x80,(byte) 0x7f,(byte) 0x80,(byte) 0x63,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0x63,(byte) 0x80,
+(byte) 0x7f,(byte) 0x80,(byte) 0x3d,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,
+};
+
+static final BitmapCharRec ch100 = new BitmapCharRec(9,14,-1,0,11,ch100data);
+
+/* char: 0x63 'c' */
+
+static final byte[] ch99data = {
+(byte) 0x3e,(byte) 0x7f,(byte) 0x63,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x63,(byte) 0x7f,(byte) 0x3e,
+};
+
+static final BitmapCharRec ch99 = new BitmapCharRec(8,10,-1,0,10,ch99data);
+
+/* char: 0x62 'b' */
+
+static final byte[] ch98data = {
+(byte) 0xde,(byte) 0x0,(byte) 0xff,(byte) 0x0,(byte) 0xe3,(byte) 0x0,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xe3,(byte) 0x0,
+(byte) 0xff,(byte) 0x0,(byte) 0xde,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,
+};
+
+static final BitmapCharRec ch98 = new BitmapCharRec(9,14,-1,0,11,ch98data);
+
+/* char: 0x61 'a' */
+
+static final byte[] ch97data = {
+(byte) 0x76,(byte) 0xee,(byte) 0xc6,(byte) 0xc6,(byte) 0xe6,(byte) 0x7e,(byte) 0xe,(byte) 0xc6,(byte) 0xee,(byte) 0x7c,
+};
+
+static final BitmapCharRec ch97 = new BitmapCharRec(7,10,-1,0,9,ch97data);
+
+/* char: 0x60 '`' */
+
+static final byte[] ch96data = {
+(byte) 0xc0,(byte) 0xc0,(byte) 0x80,(byte) 0x80,(byte) 0x40,
+};
+
+static final BitmapCharRec ch96 = new BitmapCharRec(2,5,-1,-9,4,ch96data);
+
+/* char: 0x5f '_' */
+
+static final byte[] ch95data = {
+(byte) 0xff,(byte) 0xc0,(byte) 0xff,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch95 = new BitmapCharRec(10,2,0,4,10,ch95data);
+
+/* char: 0x5e '^' */
+
+static final byte[] ch94data = {
+(byte) 0x82,(byte) 0xc6,(byte) 0x6c,(byte) 0x38,(byte) 0x10,
+};
+
+static final BitmapCharRec ch94 = new BitmapCharRec(7,5,-1,-8,9,ch94data);
+
+/* char: 0x5d ']' */
+
+static final byte[] ch93data = {
+(byte) 0xf0,(byte) 0xf0,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,
+(byte) 0xf0,(byte) 0xf0,
+};
+
+static final BitmapCharRec ch93 = new BitmapCharRec(4,18,0,4,5,ch93data);
+
+/* char: 0x5c '\' */
+
+static final byte[] ch92data = {
+(byte) 0x18,(byte) 0x18,(byte) 0x10,(byte) 0x10,(byte) 0x30,(byte) 0x30,(byte) 0x20,(byte) 0x20,(byte) 0x60,(byte) 0x60,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch92 = new BitmapCharRec(5,14,0,0,5,ch92data);
+
+/* char: 0x5b '[' */
+
+static final byte[] ch91data = {
+(byte) 0xf0,(byte) 0xf0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,
+(byte) 0xf0,(byte) 0xf0,
+};
+
+static final BitmapCharRec ch91 = new BitmapCharRec(4,18,-1,4,5,ch91data);
+
+/* char: 0x5a 'Z' */
+
+static final byte[] ch90data = {
+(byte) 0xff,(byte) 0xc0,(byte) 0xff,(byte) 0xc0,(byte) 0xc0,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0x1c,(byte) 0x0,(byte) 0xc,(byte) 0x0,
+(byte) 0x6,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x1,(byte) 0x80,(byte) 0x0,(byte) 0xc0,(byte) 0xff,(byte) 0xc0,(byte) 0xff,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch90 = new BitmapCharRec(10,14,-1,0,12,ch90data);
+
+/* char: 0x59 'Y' */
+
+static final byte[] ch89data = {
+(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0x19,(byte) 0x80,
+(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,
+};
+
+static final BitmapCharRec ch89 = new BitmapCharRec(12,14,-1,0,14,ch89data);
+
+/* char: 0x58 'X' */
+
+static final byte[] ch88data = {
+(byte) 0xc0,(byte) 0x60,(byte) 0xe0,(byte) 0xe0,(byte) 0x60,(byte) 0xc0,(byte) 0x71,(byte) 0xc0,(byte) 0x31,(byte) 0x80,(byte) 0x1b,(byte) 0x0,(byte) 0xe,(byte) 0x0,(byte) 0xe,(byte) 0x0,
+(byte) 0x1b,(byte) 0x0,(byte) 0x31,(byte) 0x80,(byte) 0x71,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xe0,(byte) 0xe0,(byte) 0xc0,(byte) 0x60,
+};
+
+static final BitmapCharRec ch88 = new BitmapCharRec(11,14,-1,0,13,ch88data);
+
+/* char: 0x57 'W' */
+
+static final byte[] ch87data = {
+(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x1c,(byte) 0x38,(byte) 0x34,(byte) 0x2c,(byte) 0x36,(byte) 0x6c,(byte) 0x36,(byte) 0x6c,(byte) 0x66,(byte) 0x66,(byte) 0x66,(byte) 0x66,
+(byte) 0x62,(byte) 0x46,(byte) 0x63,(byte) 0xc6,(byte) 0xc3,(byte) 0xc3,(byte) 0xc1,(byte) 0x83,(byte) 0xc1,(byte) 0x83,(byte) 0xc1,(byte) 0x83,
+};
+
+static final BitmapCharRec ch87 = new BitmapCharRec(16,14,-1,0,18,ch87data);
+
+/* char: 0x56 'V' */
+
+static final byte[] ch86data = {
+(byte) 0x6,(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0x19,(byte) 0x80,(byte) 0x19,(byte) 0x80,(byte) 0x19,(byte) 0x80,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,
+(byte) 0x30,(byte) 0xc0,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,
+};
+
+static final BitmapCharRec ch86 = new BitmapCharRec(12,14,-1,0,14,ch86data);
+
+/* char: 0x55 'U' */
+
+static final byte[] ch85data = {
+(byte) 0x1f,(byte) 0x0,(byte) 0x7f,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,
+(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,
+};
+
+static final BitmapCharRec ch85 = new BitmapCharRec(11,14,-1,0,13,ch85data);
+
+/* char: 0x54 'T' */
+
+static final byte[] ch84data = {
+(byte) 0xc,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0xc,(byte) 0x0,
+(byte) 0xc,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0xff,(byte) 0xc0,(byte) 0xff,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch84 = new BitmapCharRec(10,14,-1,0,12,ch84data);
+
+/* char: 0x53 'S' */
+
+static final byte[] ch83data = {
+(byte) 0x3f,(byte) 0x0,(byte) 0x7f,(byte) 0xc0,(byte) 0xe0,(byte) 0xe0,(byte) 0xc0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0xe0,(byte) 0x3,(byte) 0xc0,(byte) 0x1f,(byte) 0x0,
+(byte) 0x7c,(byte) 0x0,(byte) 0xe0,(byte) 0x0,(byte) 0xc0,(byte) 0x60,(byte) 0xe0,(byte) 0xe0,(byte) 0x7f,(byte) 0xc0,(byte) 0x1f,(byte) 0x0,
+};
+
+static final BitmapCharRec ch83 = new BitmapCharRec(11,14,-1,0,13,ch83data);
+
+/* char: 0x52 'R' */
+
+static final byte[] ch82data = {
+(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xff,(byte) 0x0,(byte) 0xff,(byte) 0x80,
+(byte) 0xc1,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc1,(byte) 0xc0,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x0,
+};
+
+static final BitmapCharRec ch82 = new BitmapCharRec(10,14,-1,0,12,ch82data);
+
+/* char: 0x51 'Q' */
+
+static final byte[] ch81data = {
+(byte) 0x0,(byte) 0x30,(byte) 0xf,(byte) 0xb0,(byte) 0x3f,(byte) 0xe0,(byte) 0x70,(byte) 0xf0,(byte) 0x61,(byte) 0xb0,(byte) 0xe1,(byte) 0xb8,(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18,
+(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18,(byte) 0xe0,(byte) 0x38,(byte) 0x60,(byte) 0x30,(byte) 0x70,(byte) 0x70,(byte) 0x3f,(byte) 0xe0,(byte) 0xf,(byte) 0x80,
+};
+
+static final BitmapCharRec ch81 = new BitmapCharRec(13,15,-1,1,15,ch81data);
+
+/* char: 0x50 'P' */
+
+static final byte[] ch80data = {
+(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x0,(byte) 0xff,(byte) 0x80,
+(byte) 0xc1,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc1,(byte) 0xc0,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x0,
+};
+
+static final BitmapCharRec ch80 = new BitmapCharRec(10,14,-1,0,12,ch80data);
+
+/* char: 0x4f 'O' */
+
+static final byte[] ch79data = {
+(byte) 0xf,(byte) 0x80,(byte) 0x3f,(byte) 0xe0,(byte) 0x70,(byte) 0x70,(byte) 0x60,(byte) 0x30,(byte) 0xe0,(byte) 0x38,(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18,(byte) 0xc0,(byte) 0x18,
+(byte) 0xc0,(byte) 0x18,(byte) 0xe0,(byte) 0x38,(byte) 0x60,(byte) 0x30,(byte) 0x70,(byte) 0x70,(byte) 0x3f,(byte) 0xe0,(byte) 0xf,(byte) 0x80,
+};
+
+static final BitmapCharRec ch79 = new BitmapCharRec(13,14,-1,0,15,ch79data);
+
+/* char: 0x4e 'N' */
+
+static final byte[] ch78data = {
+(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xe0,(byte) 0xc1,(byte) 0xe0,(byte) 0xc1,(byte) 0xe0,(byte) 0xc3,(byte) 0x60,(byte) 0xc6,(byte) 0x60,(byte) 0xc6,(byte) 0x60,(byte) 0xcc,(byte) 0x60,
+(byte) 0xcc,(byte) 0x60,(byte) 0xd8,(byte) 0x60,(byte) 0xf0,(byte) 0x60,(byte) 0xf0,(byte) 0x60,(byte) 0xe0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,
+};
+
+static final BitmapCharRec ch78 = new BitmapCharRec(11,14,-1,0,13,ch78data);
+
+/* char: 0x4d 'M' */
+
+static final byte[] ch77data = {
+(byte) 0xc3,(byte) 0xc,(byte) 0xc3,(byte) 0xc,(byte) 0xc7,(byte) 0x8c,(byte) 0xc4,(byte) 0x8c,(byte) 0xcc,(byte) 0xcc,(byte) 0xcc,(byte) 0xcc,(byte) 0xd8,(byte) 0x6c,(byte) 0xd8,(byte) 0x6c,
+(byte) 0xf0,(byte) 0x3c,(byte) 0xf0,(byte) 0x3c,(byte) 0xe0,(byte) 0x1c,(byte) 0xe0,(byte) 0x1c,(byte) 0xc0,(byte) 0xc,(byte) 0xc0,(byte) 0xc,
+};
+
+static final BitmapCharRec ch77 = new BitmapCharRec(14,14,-1,0,16,ch77data);
+
+/* char: 0x4c 'L' */
+
+static final byte[] ch76data = {
+(byte) 0xff,(byte) 0xff,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch76 = new BitmapCharRec(8,14,-1,0,10,ch76data);
+
+/* char: 0x4b 'K' */
+
+static final byte[] ch75data = {
+(byte) 0xc0,(byte) 0x70,(byte) 0xc0,(byte) 0xe0,(byte) 0xc1,(byte) 0xc0,(byte) 0xc3,(byte) 0x80,(byte) 0xc7,(byte) 0x0,(byte) 0xce,(byte) 0x0,(byte) 0xfc,(byte) 0x0,(byte) 0xf8,(byte) 0x0,
+(byte) 0xdc,(byte) 0x0,(byte) 0xce,(byte) 0x0,(byte) 0xc7,(byte) 0x0,(byte) 0xc3,(byte) 0x80,(byte) 0xc1,(byte) 0xc0,(byte) 0xc0,(byte) 0xe0,
+};
+
+static final BitmapCharRec ch75 = new BitmapCharRec(12,14,-1,0,13,ch75data);
+
+/* char: 0x4a 'J' */
+
+static final byte[] ch74data = {
+(byte) 0x3c,(byte) 0x7e,(byte) 0xe7,(byte) 0xc3,(byte) 0xc3,(byte) 0x3,(byte) 0x3,(byte) 0x3,(byte) 0x3,(byte) 0x3,(byte) 0x3,(byte) 0x3,(byte) 0x3,(byte) 0x3,
+};
+
+static final BitmapCharRec ch74 = new BitmapCharRec(8,14,-1,0,10,ch74data);
+
+/* char: 0x49 'I' */
+
+static final byte[] ch73data = {
+(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch73 = new BitmapCharRec(2,14,-2,0,6,ch73data);
+
+/* char: 0x48 'H' */
+
+static final byte[] ch72data = {
+(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xff,(byte) 0xe0,(byte) 0xff,(byte) 0xe0,
+(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,
+};
+
+static final BitmapCharRec ch72 = new BitmapCharRec(11,14,-1,0,13,ch72data);
+
+/* char: 0x47 'G' */
+
+static final byte[] ch71data = {
+(byte) 0xf,(byte) 0xb0,(byte) 0x3f,(byte) 0xf0,(byte) 0x70,(byte) 0x70,(byte) 0x60,(byte) 0x30,(byte) 0xe0,(byte) 0x30,(byte) 0xc1,(byte) 0xf0,(byte) 0xc1,(byte) 0xf0,(byte) 0xc0,(byte) 0x0,
+(byte) 0xc0,(byte) 0x0,(byte) 0xe0,(byte) 0x30,(byte) 0x60,(byte) 0x30,(byte) 0x70,(byte) 0x70,(byte) 0x3f,(byte) 0xe0,(byte) 0xf,(byte) 0x80,
+};
+
+static final BitmapCharRec ch71 = new BitmapCharRec(12,14,-1,0,14,ch71data);
+
+/* char: 0x46 'F' */
+
+static final byte[] ch70data = {
+(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x0,(byte) 0xff,(byte) 0x0,
+(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80,
+};
+
+static final BitmapCharRec ch70 = new BitmapCharRec(9,14,-1,0,11,ch70data);
+
+/* char: 0x45 'E' */
+
+static final byte[] ch69data = {
+(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x0,(byte) 0xff,(byte) 0x0,
+(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80,
+};
+
+static final BitmapCharRec ch69 = new BitmapCharRec(9,14,-1,0,11,ch69data);
+
+/* char: 0x44 'D' */
+
+static final byte[] ch68data = {
+(byte) 0xff,(byte) 0x0,(byte) 0xff,(byte) 0x80,(byte) 0xc1,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,
+(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xc0,(byte) 0xc1,(byte) 0xc0,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x0,
+};
+
+static final BitmapCharRec ch68 = new BitmapCharRec(11,14,-1,0,13,ch68data);
+
+/* char: 0x43 'C' */
+
+static final byte[] ch67data = {
+(byte) 0xf,(byte) 0x80,(byte) 0x3f,(byte) 0xe0,(byte) 0x70,(byte) 0x70,(byte) 0x60,(byte) 0x30,(byte) 0xe0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,
+(byte) 0xc0,(byte) 0x0,(byte) 0xe0,(byte) 0x0,(byte) 0x60,(byte) 0x30,(byte) 0x70,(byte) 0x70,(byte) 0x3f,(byte) 0xe0,(byte) 0xf,(byte) 0x80,
+};
+
+static final BitmapCharRec ch67 = new BitmapCharRec(12,14,-1,0,14,ch67data);
+
+/* char: 0x42 'B' */
+
+static final byte[] ch66data = {
+(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0xc0,(byte) 0xc0,(byte) 0xe0,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xe0,(byte) 0xff,(byte) 0xc0,(byte) 0xff,(byte) 0x80,
+(byte) 0xc1,(byte) 0x80,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc1,(byte) 0xc0,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x0,
+};
+
+static final BitmapCharRec ch66 = new BitmapCharRec(11,14,-1,0,13,ch66data);
+
+/* char: 0x41 'A' */
+
+static final byte[] ch65data = {
+(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x7f,(byte) 0xe0,(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0xc0,
+(byte) 0x19,(byte) 0x80,(byte) 0x19,(byte) 0x80,(byte) 0xf,(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,
+};
+
+static final BitmapCharRec ch65 = new BitmapCharRec(12,14,0,0,12,ch65data);
+
+/* char: 0x40 '@' */
+
+static final byte[] ch64data = {
+(byte) 0x7,(byte) 0xe0,(byte) 0x1f,(byte) 0xf0,(byte) 0x38,(byte) 0x0,(byte) 0x70,(byte) 0x0,(byte) 0x67,(byte) 0x70,(byte) 0xcf,(byte) 0xf8,(byte) 0xcc,(byte) 0xcc,(byte) 0xcc,(byte) 0x66,
+(byte) 0xcc,(byte) 0x66,(byte) 0xcc,(byte) 0x63,(byte) 0xc6,(byte) 0x33,(byte) 0x67,(byte) 0x73,(byte) 0x63,(byte) 0xb3,(byte) 0x30,(byte) 0x6,(byte) 0x1c,(byte) 0xe,(byte) 0xf,(byte) 0xfc,
+(byte) 0x3,(byte) 0xf0,
+};
+
+static final BitmapCharRec ch64 = new BitmapCharRec(16,17,-1,3,18,ch64data);
+
+/* char: 0x3f '?' */
+
+static final byte[] ch63data = {
+(byte) 0x30,(byte) 0x30,(byte) 0x0,(byte) 0x0,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x38,(byte) 0x1c,(byte) 0xe,(byte) 0xc6,(byte) 0xc6,(byte) 0xfe,(byte) 0x7c,
+};
+
+static final BitmapCharRec ch63 = new BitmapCharRec(7,14,-1,0,10,ch63data);
+
+/* char: 0x3e '>' */
+
+static final byte[] ch62data = {
+(byte) 0xc0,(byte) 0xf0,(byte) 0x3c,(byte) 0xe,(byte) 0x3,(byte) 0xe,(byte) 0x3c,(byte) 0xf0,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch62 = new BitmapCharRec(8,9,-1,0,10,ch62data);
+
+/* char: 0x3d '=' */
+
+static final byte[] ch61data = {
+(byte) 0xfe,(byte) 0xfe,(byte) 0x0,(byte) 0x0,(byte) 0xfe,(byte) 0xfe,
+};
+
+static final BitmapCharRec ch61 = new BitmapCharRec(7,6,-2,-2,11,ch61data);
+
+/* char: 0x3c '<' */
+
+static final byte[] ch60data = {
+(byte) 0x3,(byte) 0xf,(byte) 0x3c,(byte) 0x70,(byte) 0xc0,(byte) 0x70,(byte) 0x3c,(byte) 0xf,(byte) 0x3,
+};
+
+static final BitmapCharRec ch60 = new BitmapCharRec(8,9,-1,0,10,ch60data);
+
+/* char: 0x3b ';' */
+
+static final byte[] ch59data = {
+(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch59 = new BitmapCharRec(2,13,-1,3,5,ch59data);
+
+/* char: 0x3a ':' */
+
+static final byte[] ch58data = {
+(byte) 0xc0,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch58 = new BitmapCharRec(2,10,-1,0,5,ch58data);
+
+/* char: 0x39 '9' */
+
+static final byte[] ch57data = {
+(byte) 0x7c,(byte) 0xfe,(byte) 0xc6,(byte) 0x3,(byte) 0x3,(byte) 0x3b,(byte) 0x7f,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc7,(byte) 0x7e,(byte) 0x3c,
+};
+
+static final BitmapCharRec ch57 = new BitmapCharRec(8,13,-1,0,10,ch57data);
+
+/* char: 0x38 '8' */
+
+static final byte[] ch56data = {
+(byte) 0x3c,(byte) 0x7e,(byte) 0xe7,(byte) 0xc3,(byte) 0xc3,(byte) 0x66,(byte) 0x7e,(byte) 0x66,(byte) 0xc3,(byte) 0xc3,(byte) 0xe7,(byte) 0x7e,(byte) 0x3c,
+};
+
+static final BitmapCharRec ch56 = new BitmapCharRec(8,13,-1,0,10,ch56data);
+
+/* char: 0x37 '7' */
+
+static final byte[] ch55data = {
+(byte) 0x60,(byte) 0x60,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x18,(byte) 0x18,(byte) 0xc,(byte) 0xc,(byte) 0x6,(byte) 0x3,(byte) 0xff,(byte) 0xff,
+};
+
+static final BitmapCharRec ch55 = new BitmapCharRec(8,13,-1,0,10,ch55data);
+
+/* char: 0x36 '6' */
+
+static final byte[] ch54data = {
+(byte) 0x3c,(byte) 0x7e,(byte) 0xe3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xfe,(byte) 0xdc,(byte) 0xc0,(byte) 0xc0,(byte) 0x63,(byte) 0x7f,(byte) 0x3c,
+};
+
+static final BitmapCharRec ch54 = new BitmapCharRec(8,13,-1,0,10,ch54data);
+
+/* char: 0x35 '5' */
+
+static final byte[] ch53data = {
+(byte) 0x7c,(byte) 0xfe,(byte) 0xc7,(byte) 0xc3,(byte) 0x3,(byte) 0x3,(byte) 0xc7,(byte) 0xfe,(byte) 0xfc,(byte) 0xc0,(byte) 0xc0,(byte) 0xfe,(byte) 0xfe,
+};
+
+static final BitmapCharRec ch53 = new BitmapCharRec(8,13,-1,0,10,ch53data);
+
+/* char: 0x34 '4' */
+
+static final byte[] ch52data = {
+(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80,(byte) 0xc3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x33,(byte) 0x0,
+(byte) 0x33,(byte) 0x0,(byte) 0x1b,(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0x7,(byte) 0x0,(byte) 0x3,(byte) 0x0,
+};
+
+static final BitmapCharRec ch52 = new BitmapCharRec(9,13,-1,0,10,ch52data);
+
+/* char: 0x33 '3' */
+
+static final byte[] ch51data = {
+(byte) 0x3c,(byte) 0x7e,(byte) 0xc7,(byte) 0xc3,(byte) 0x3,(byte) 0x7,(byte) 0x1e,(byte) 0x1c,(byte) 0x6,(byte) 0xc3,(byte) 0xc3,(byte) 0x7e,(byte) 0x3c,
+};
+
+static final BitmapCharRec ch51 = new BitmapCharRec(8,13,-1,0,10,ch51data);
+
+/* char: 0x32 '2' */
+
+static final byte[] ch50data = {
+(byte) 0xff,(byte) 0xff,(byte) 0xc0,(byte) 0xe0,(byte) 0x70,(byte) 0x38,(byte) 0x1c,(byte) 0xe,(byte) 0x7,(byte) 0x3,(byte) 0xc3,(byte) 0xfe,(byte) 0x3c,
+};
+
+static final BitmapCharRec ch50 = new BitmapCharRec(8,13,-1,0,10,ch50data);
+
+/* char: 0x31 '1' */
+
+static final byte[] ch49data = {
+(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0xf8,(byte) 0xf8,(byte) 0x18,
+};
+
+static final BitmapCharRec ch49 = new BitmapCharRec(5,13,-2,0,10,ch49data);
+
+/* char: 0x30 '0' */
+
+static final byte[] ch48data = {
+(byte) 0x3c,(byte) 0x7e,(byte) 0x66,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0xc3,(byte) 0x66,(byte) 0x7e,(byte) 0x3c,
+};
+
+static final BitmapCharRec ch48 = new BitmapCharRec(8,13,-1,0,10,ch48data);
+
+/* char: 0x2f '/' */
+
+static final byte[] ch47data = {
+(byte) 0xc0,(byte) 0xc0,(byte) 0x40,(byte) 0x40,(byte) 0x60,(byte) 0x60,(byte) 0x20,(byte) 0x20,(byte) 0x30,(byte) 0x30,(byte) 0x10,(byte) 0x10,(byte) 0x18,(byte) 0x18,
+};
+
+static final BitmapCharRec ch47 = new BitmapCharRec(5,14,0,0,5,ch47data);
+
+/* char: 0x2e '.' */
+
+static final byte[] ch46data = {
+(byte) 0xc0,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch46 = new BitmapCharRec(2,2,-1,0,5,ch46data);
+
+/* char: 0x2d '-' */
+
+static final byte[] ch45data = {
+(byte) 0xff,(byte) 0xff,
+};
+
+static final BitmapCharRec ch45 = new BitmapCharRec(8,2,-1,-4,11,ch45data);
+
+/* char: 0x2c ',' */
+
+static final byte[] ch44data = {
+(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch44 = new BitmapCharRec(2,5,-1,3,5,ch44data);
+
+/* char: 0x2b '+' */
+
+static final byte[] ch43data = {
+(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0xff,(byte) 0xff,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,
+};
+
+static final BitmapCharRec ch43 = new BitmapCharRec(8,10,-1,0,10,ch43data);
+
+/* char: 0x2a '*' */
+
+static final byte[] ch42data = {
+(byte) 0x88,(byte) 0x70,(byte) 0x70,(byte) 0xf8,(byte) 0x20,(byte) 0x20,
+};
+
+static final BitmapCharRec ch42 = new BitmapCharRec(5,6,-1,-8,7,ch42data);
+
+/* char: 0x29 ')' */
+
+static final byte[] ch41data = {
+(byte) 0x80,(byte) 0xc0,(byte) 0x60,(byte) 0x60,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x60,(byte) 0x60,
+(byte) 0xc0,(byte) 0x80,
+};
+
+static final BitmapCharRec ch41 = new BitmapCharRec(4,18,-1,4,6,ch41data);
+
+/* char: 0x28 '(' */
+
+static final byte[] ch40data = {
+(byte) 0x10,(byte) 0x30,(byte) 0x60,(byte) 0x60,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x60,(byte) 0x60,
+(byte) 0x30,(byte) 0x10,
+};
+
+static final BitmapCharRec ch40 = new BitmapCharRec(4,18,-1,4,6,ch40data);
+
+/* char: 0x27 ''' */
+
+static final byte[] ch39data = {
+(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch39 = new BitmapCharRec(2,5,-1,-9,4,ch39data);
+
+/* char: 0x26 '&' */
+
+static final byte[] ch38data = {
+(byte) 0x3c,(byte) 0x70,(byte) 0x7e,(byte) 0xe0,(byte) 0xe7,(byte) 0xc0,(byte) 0xc3,(byte) 0x80,(byte) 0xc3,(byte) 0xc0,(byte) 0xc6,(byte) 0xc0,(byte) 0xee,(byte) 0xc0,(byte) 0x7c,(byte) 0x0,
+(byte) 0x3c,(byte) 0x0,(byte) 0x66,(byte) 0x0,(byte) 0x66,(byte) 0x0,(byte) 0x7e,(byte) 0x0,(byte) 0x3c,(byte) 0x0,
+};
+
+static final BitmapCharRec ch38 = new BitmapCharRec(12,13,-1,0,13,ch38data);
+
+/* char: 0x25 '%' */
+
+static final byte[] ch37data = {
+(byte) 0x18,(byte) 0x78,(byte) 0x18,(byte) 0xfc,(byte) 0xc,(byte) 0xcc,(byte) 0xc,(byte) 0xcc,(byte) 0x6,(byte) 0xfc,(byte) 0x6,(byte) 0x78,(byte) 0x3,(byte) 0x0,(byte) 0x7b,(byte) 0x0,
+(byte) 0xfd,(byte) 0x80,(byte) 0xcd,(byte) 0x80,(byte) 0xcc,(byte) 0xc0,(byte) 0xfc,(byte) 0xc0,(byte) 0x78,(byte) 0x60,
+};
+
+static final BitmapCharRec ch37 = new BitmapCharRec(14,13,-1,0,16,ch37data);
+
+/* char: 0x24 '$' */
+
+static final byte[] ch36data = {
+(byte) 0x8,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0xeb,(byte) 0x80,(byte) 0xc9,(byte) 0x80,(byte) 0x9,(byte) 0x80,(byte) 0xf,(byte) 0x0,
+(byte) 0x3e,(byte) 0x0,(byte) 0x78,(byte) 0x0,(byte) 0xe8,(byte) 0x0,(byte) 0xc8,(byte) 0x0,(byte) 0xcb,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x8,(byte) 0x0,
+};
+
+static final BitmapCharRec ch36 = new BitmapCharRec(9,16,-1,2,10,ch36data);
+
+/* char: 0x23 '#' */
+
+static final byte[] ch35data = {
+(byte) 0x24,(byte) 0x0,(byte) 0x24,(byte) 0x0,(byte) 0x24,(byte) 0x0,(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0x80,(byte) 0x12,(byte) 0x0,(byte) 0x12,(byte) 0x0,(byte) 0x12,(byte) 0x0,
+(byte) 0x7f,(byte) 0xc0,(byte) 0x7f,(byte) 0xc0,(byte) 0x9,(byte) 0x0,(byte) 0x9,(byte) 0x0,(byte) 0x9,(byte) 0x0,
+};
+
+static final BitmapCharRec ch35 = new BitmapCharRec(10,13,0,0,10,ch35data);
+
+/* char: 0x22 '"' */
+
+static final byte[] ch34data = {
+(byte) 0x90,(byte) 0x90,(byte) 0xd8,(byte) 0xd8,(byte) 0xd8,
+};
+
+static final BitmapCharRec ch34 = new BitmapCharRec(5,5,0,-9,5,ch34data);
+
+/* char: 0x21 '!' */
+
+static final byte[] ch33data = {
+(byte) 0xc0,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x80,(byte) 0x80,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch33 = new BitmapCharRec(2,14,-2,0,6,ch33data);
+
+/* char: 0x20 ' ' */
+
+static final BitmapCharRec ch32 = new BitmapCharRec(0,0,0,0,5,null);
+
+static final BitmapCharRec[] chars = {
+ch32,
+ch33,
+ch34,
+ch35,
+ch36,
+ch37,
+ch38,
+ch39,
+ch40,
+ch41,
+ch42,
+ch43,
+ch44,
+ch45,
+ch46,
+ch47,
+ch48,
+ch49,
+ch50,
+ch51,
+ch52,
+ch53,
+ch54,
+ch55,
+ch56,
+ch57,
+ch58,
+ch59,
+ch60,
+ch61,
+ch62,
+ch63,
+ch64,
+ch65,
+ch66,
+ch67,
+ch68,
+ch69,
+ch70,
+ch71,
+ch72,
+ch73,
+ch74,
+ch75,
+ch76,
+ch77,
+ch78,
+ch79,
+ch80,
+ch81,
+ch82,
+ch83,
+ch84,
+ch85,
+ch86,
+ch87,
+ch88,
+ch89,
+ch90,
+ch91,
+ch92,
+ch93,
+ch94,
+ch95,
+ch96,
+ch97,
+ch98,
+ch99,
+ch100,
+ch101,
+ch102,
+ch103,
+ch104,
+ch105,
+ch106,
+ch107,
+ch108,
+ch109,
+ch110,
+ch111,
+ch112,
+ch113,
+ch114,
+ch115,
+ch116,
+ch117,
+ch118,
+ch119,
+ch120,
+ch121,
+ch122,
+ch123,
+ch124,
+ch125,
+ch126,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+ch160,
+ch161,
+ch162,
+ch163,
+ch164,
+ch165,
+ch166,
+ch167,
+ch168,
+ch169,
+ch170,
+ch171,
+ch172,
+ch173,
+ch174,
+ch175,
+ch176,
+ch177,
+ch178,
+ch179,
+ch180,
+ch181,
+ch182,
+ch183,
+ch184,
+ch185,
+ch186,
+ch187,
+ch188,
+ch189,
+ch190,
+ch191,
+ch192,
+ch193,
+ch194,
+ch195,
+ch196,
+ch197,
+ch198,
+ch199,
+ch200,
+ch201,
+ch202,
+ch203,
+ch204,
+ch205,
+ch206,
+ch207,
+ch208,
+ch209,
+ch210,
+ch211,
+ch212,
+ch213,
+ch214,
+ch215,
+ch216,
+ch217,
+ch218,
+ch219,
+ch220,
+ch221,
+ch222,
+ch223,
+ch224,
+ch225,
+ch226,
+ch227,
+ch228,
+ch229,
+ch230,
+ch231,
+ch232,
+ch233,
+ch234,
+ch235,
+ch236,
+ch237,
+ch238,
+ch239,
+ch240,
+ch241,
+ch242,
+ch243,
+ch244,
+ch245,
+ch246,
+ch247,
+ch248,
+ch249,
+ch250,
+ch251,
+ch252,
+ch253,
+ch254,
+ch255,
+};
+
+  public static final BitmapFontRec glutBitmapHelvetica18 = new BitmapFontRec("-adobe-helvetica-medium-r-normal--18-180-75-75-p-98-iso8859-1",
+                                                                       224,
+                                                                       32,
+                                                                       chars);
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/gl2/GLUTBitmapTimesRoman10.java b/src/jogl/classes/com/jogamp/opengl/util/gl2/GLUTBitmapTimesRoman10.java
new file mode 100644
index 000000000..f753b56f7
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/gl2/GLUTBitmapTimesRoman10.java
@@ -0,0 +1,1797 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util.gl2;
+
+class GLUTBitmapTimesRoman10 {
+
+/* GENERATED FILE -- DO NOT MODIFY */
+
+/* char: 0xff */
+
+static final byte[] ch255data = {
+(byte) 0x80,(byte) 0xc0,(byte) 0x40,(byte) 0x60,(byte) 0xa0,(byte) 0x90,(byte) 0xb8,(byte) 0x0,(byte) 0xa0,
+};
+
+static final BitmapCharRec ch255 = new BitmapCharRec(5,9,0,2,5,ch255data);
+
+/* char: 0xfe */
+
+static final byte[] ch254data = {
+(byte) 0xc0,(byte) 0x80,(byte) 0xe0,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0xe0,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch254 = new BitmapCharRec(4,9,0,2,5,ch254data);
+
+/* char: 0xfd */
+
+static final byte[] ch253data = {
+(byte) 0x80,(byte) 0xc0,(byte) 0x40,(byte) 0x60,(byte) 0xa0,(byte) 0x90,(byte) 0xb8,(byte) 0x0,(byte) 0x20,(byte) 0x10,
+};
+
+static final BitmapCharRec ch253 = new BitmapCharRec(5,10,0,2,5,ch253data);
+
+/* char: 0xfc */
+
+static final byte[] ch252data = {
+(byte) 0x68,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x0,(byte) 0x50,
+};
+
+static final BitmapCharRec ch252 = new BitmapCharRec(5,7,0,0,5,ch252data);
+
+/* char: 0xfb */
+
+static final byte[] ch251data = {
+(byte) 0x68,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x0,(byte) 0x50,(byte) 0x20,
+};
+
+static final BitmapCharRec ch251 = new BitmapCharRec(5,8,0,0,5,ch251data);
+
+/* char: 0xfa */
+
+static final byte[] ch250data = {
+(byte) 0x68,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x0,(byte) 0x40,(byte) 0x20,
+};
+
+static final BitmapCharRec ch250 = new BitmapCharRec(5,8,0,0,5,ch250data);
+
+/* char: 0xf9 */
+
+static final byte[] ch249data = {
+(byte) 0x68,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x0,(byte) 0x20,(byte) 0x40,
+};
+
+static final BitmapCharRec ch249 = new BitmapCharRec(5,8,0,0,5,ch249data);
+
+/* char: 0xf8 */
+
+static final byte[] ch248data = {
+(byte) 0x80,(byte) 0x70,(byte) 0x48,(byte) 0x48,(byte) 0x48,(byte) 0x38,(byte) 0x4,
+};
+
+static final BitmapCharRec ch248 = new BitmapCharRec(6,7,1,1,5,ch248data);
+
+/* char: 0xf7 */
+
+static final byte[] ch247data = {
+(byte) 0x20,(byte) 0x0,(byte) 0xf8,(byte) 0x0,(byte) 0x20,
+};
+
+static final BitmapCharRec ch247 = new BitmapCharRec(5,5,0,0,6,ch247data);
+
+/* char: 0xf6 */
+
+static final byte[] ch246data = {
+(byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x60,(byte) 0x0,(byte) 0xa0,
+};
+
+static final BitmapCharRec ch246 = new BitmapCharRec(4,7,0,0,5,ch246data);
+
+/* char: 0xf5 */
+
+static final byte[] ch245data = {
+(byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x60,(byte) 0x0,(byte) 0xa0,(byte) 0x50,
+};
+
+static final BitmapCharRec ch245 = new BitmapCharRec(4,8,0,0,5,ch245data);
+
+/* char: 0xf4 */
+
+static final byte[] ch244data = {
+(byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x60,(byte) 0x0,(byte) 0xa0,(byte) 0x40,
+};
+
+static final BitmapCharRec ch244 = new BitmapCharRec(4,8,0,0,5,ch244data);
+
+/* char: 0xf3 */
+
+static final byte[] ch243data = {
+(byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x60,(byte) 0x0,(byte) 0x40,(byte) 0x20,
+};
+
+static final BitmapCharRec ch243 = new BitmapCharRec(4,8,0,0,5,ch243data);
+
+/* char: 0xf2 */
+
+static final byte[] ch242data = {
+(byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x60,(byte) 0x0,(byte) 0x20,(byte) 0x40,
+};
+
+static final BitmapCharRec ch242 = new BitmapCharRec(4,8,0,0,5,ch242data);
+
+/* char: 0xf1 */
+
+static final byte[] ch241data = {
+(byte) 0xd8,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0xe0,(byte) 0x0,(byte) 0xa0,(byte) 0x50,
+};
+
+static final BitmapCharRec ch241 = new BitmapCharRec(5,8,0,0,5,ch241data);
+
+/* char: 0xf0 */
+
+static final byte[] ch240data = {
+(byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x70,(byte) 0xa0,(byte) 0x70,(byte) 0x40,
+};
+
+static final BitmapCharRec ch240 = new BitmapCharRec(4,8,0,0,5,ch240data);
+
+/* char: 0xef */
+
+static final byte[] ch239data = {
+(byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x0,(byte) 0xa0,
+};
+
+static final BitmapCharRec ch239 = new BitmapCharRec(3,7,0,0,4,ch239data);
+
+/* char: 0xee */
+
+static final byte[] ch238data = {
+(byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x0,(byte) 0xa0,(byte) 0x40,
+};
+
+static final BitmapCharRec ch238 = new BitmapCharRec(3,8,0,0,4,ch238data);
+
+/* char: 0xed */
+
+static final byte[] ch237data = {
+(byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x0,(byte) 0x40,(byte) 0x20,
+};
+
+static final BitmapCharRec ch237 = new BitmapCharRec(3,8,0,0,4,ch237data);
+
+/* char: 0xec */
+
+static final byte[] ch236data = {
+(byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x0,(byte) 0x40,(byte) 0x80,
+};
+
+static final BitmapCharRec ch236 = new BitmapCharRec(3,8,0,0,4,ch236data);
+
+/* char: 0xeb */
+
+static final byte[] ch235data = {
+(byte) 0x60,(byte) 0x80,(byte) 0xc0,(byte) 0xa0,(byte) 0x60,(byte) 0x0,(byte) 0xa0,
+};
+
+static final BitmapCharRec ch235 = new BitmapCharRec(3,7,0,0,4,ch235data);
+
+/* char: 0xea */
+
+static final byte[] ch234data = {
+(byte) 0x60,(byte) 0x80,(byte) 0xc0,(byte) 0xa0,(byte) 0x60,(byte) 0x0,(byte) 0xa0,(byte) 0x40,
+};
+
+static final BitmapCharRec ch234 = new BitmapCharRec(3,8,0,0,4,ch234data);
+
+/* char: 0xe9 */
+
+static final byte[] ch233data = {
+(byte) 0x60,(byte) 0x80,(byte) 0xc0,(byte) 0xa0,(byte) 0x60,(byte) 0x0,(byte) 0x40,(byte) 0x20,
+};
+
+static final BitmapCharRec ch233 = new BitmapCharRec(3,8,0,0,4,ch233data);
+
+/* char: 0xe8 */
+
+static final byte[] ch232data = {
+(byte) 0x60,(byte) 0x80,(byte) 0xc0,(byte) 0xa0,(byte) 0x60,(byte) 0x0,(byte) 0x40,(byte) 0x80,
+};
+
+static final BitmapCharRec ch232 = new BitmapCharRec(3,8,0,0,4,ch232data);
+
+/* char: 0xe7 */
+
+static final byte[] ch231data = {
+(byte) 0xc0,(byte) 0x20,(byte) 0x40,(byte) 0x60,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x60,
+};
+
+static final BitmapCharRec ch231 = new BitmapCharRec(3,8,0,3,4,ch231data);
+
+/* char: 0xe6 */
+
+static final byte[] ch230data = {
+(byte) 0xd8,(byte) 0xa0,(byte) 0x70,(byte) 0x28,(byte) 0xd8,
+};
+
+static final BitmapCharRec ch230 = new BitmapCharRec(5,5,0,0,6,ch230data);
+
+/* char: 0xe5 */
+
+static final byte[] ch229data = {
+(byte) 0xe0,(byte) 0xa0,(byte) 0x60,(byte) 0x20,(byte) 0xc0,(byte) 0x40,(byte) 0xa0,(byte) 0x40,
+};
+
+static final BitmapCharRec ch229 = new BitmapCharRec(3,8,0,0,4,ch229data);
+
+/* char: 0xe4 */
+
+static final byte[] ch228data = {
+(byte) 0xe0,(byte) 0xa0,(byte) 0x60,(byte) 0x20,(byte) 0xc0,(byte) 0x0,(byte) 0xa0,
+};
+
+static final BitmapCharRec ch228 = new BitmapCharRec(3,7,0,0,4,ch228data);
+
+/* char: 0xe3 */
+
+static final byte[] ch227data = {
+(byte) 0xe0,(byte) 0xa0,(byte) 0x60,(byte) 0x20,(byte) 0xc0,(byte) 0x0,(byte) 0xa0,(byte) 0x50,
+};
+
+static final BitmapCharRec ch227 = new BitmapCharRec(4,8,0,0,4,ch227data);
+
+/* char: 0xe2 */
+
+static final byte[] ch226data = {
+(byte) 0xe0,(byte) 0xa0,(byte) 0x60,(byte) 0x20,(byte) 0xc0,(byte) 0x0,(byte) 0xa0,(byte) 0x40,
+};
+
+static final BitmapCharRec ch226 = new BitmapCharRec(3,8,0,0,4,ch226data);
+
+/* char: 0xe1 */
+
+static final byte[] ch225data = {
+(byte) 0xe0,(byte) 0xa0,(byte) 0x60,(byte) 0x20,(byte) 0xc0,(byte) 0x0,(byte) 0x40,(byte) 0x20,
+};
+
+static final BitmapCharRec ch225 = new BitmapCharRec(3,8,0,0,4,ch225data);
+
+/* char: 0xe0 */
+
+static final byte[] ch224data = {
+(byte) 0xe0,(byte) 0xa0,(byte) 0x60,(byte) 0x20,(byte) 0xc0,(byte) 0x0,(byte) 0x40,(byte) 0x80,
+};
+
+static final BitmapCharRec ch224 = new BitmapCharRec(3,8,0,0,4,ch224data);
+
+/* char: 0xdf */
+
+static final byte[] ch223data = {
+(byte) 0xe0,(byte) 0x50,(byte) 0x50,(byte) 0x60,(byte) 0x50,(byte) 0x50,(byte) 0x20,
+};
+
+static final BitmapCharRec ch223 = new BitmapCharRec(4,7,0,0,5,ch223data);
+
+/* char: 0xde */
+
+static final byte[] ch222data = {
+(byte) 0xe0,(byte) 0x40,(byte) 0x70,(byte) 0x48,(byte) 0x70,(byte) 0x40,(byte) 0xe0,
+};
+
+static final BitmapCharRec ch222 = new BitmapCharRec(5,7,0,0,6,ch222data);
+
+/* char: 0xdd */
+
+static final byte[] ch221data = {
+(byte) 0x38,(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x28,(byte) 0x44,(byte) 0xee,(byte) 0x0,(byte) 0x10,(byte) 0x8,
+};
+
+static final BitmapCharRec ch221 = new BitmapCharRec(7,10,0,0,8,ch221data);
+
+/* char: 0xdc */
+
+static final byte[] ch220data = {
+(byte) 0x38,(byte) 0x6c,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0xee,(byte) 0x0,(byte) 0x28,
+};
+
+static final BitmapCharRec ch220 = new BitmapCharRec(7,9,0,0,8,ch220data);
+
+/* char: 0xdb */
+
+static final byte[] ch219data = {
+(byte) 0x38,(byte) 0x6c,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0xee,(byte) 0x0,(byte) 0x28,(byte) 0x10,
+};
+
+static final BitmapCharRec ch219 = new BitmapCharRec(7,10,0,0,8,ch219data);
+
+/* char: 0xda */
+
+static final byte[] ch218data = {
+(byte) 0x38,(byte) 0x6c,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0xee,(byte) 0x0,(byte) 0x10,(byte) 0x8,
+};
+
+static final BitmapCharRec ch218 = new BitmapCharRec(7,10,0,0,8,ch218data);
+
+/* char: 0xd9 */
+
+static final byte[] ch217data = {
+(byte) 0x38,(byte) 0x6c,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0xee,(byte) 0x0,(byte) 0x10,(byte) 0x20,
+};
+
+static final BitmapCharRec ch217 = new BitmapCharRec(7,10,0,0,8,ch217data);
+
+/* char: 0xd8 */
+
+static final byte[] ch216data = {
+(byte) 0x80,(byte) 0x7c,(byte) 0x66,(byte) 0x52,(byte) 0x52,(byte) 0x4a,(byte) 0x66,(byte) 0x3e,(byte) 0x1,
+};
+
+static final BitmapCharRec ch216 = new BitmapCharRec(8,9,0,1,8,ch216data);
+
+/* char: 0xd7 */
+
+static final byte[] ch215data = {
+(byte) 0x88,(byte) 0x50,(byte) 0x20,(byte) 0x50,(byte) 0x88,
+};
+
+static final BitmapCharRec ch215 = new BitmapCharRec(5,5,0,0,6,ch215data);
+
+/* char: 0xd6 */
+
+static final byte[] ch214data = {
+(byte) 0x78,(byte) 0xcc,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xcc,(byte) 0x78,(byte) 0x0,(byte) 0x50,
+};
+
+static final BitmapCharRec ch214 = new BitmapCharRec(6,9,0,0,7,ch214data);
+
+/* char: 0xd5 */
+
+static final byte[] ch213data = {
+(byte) 0x78,(byte) 0xcc,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xcc,(byte) 0x78,(byte) 0x0,(byte) 0x50,(byte) 0x28,
+};
+
+static final BitmapCharRec ch213 = new BitmapCharRec(6,10,0,0,7,ch213data);
+
+/* char: 0xd4 */
+
+static final byte[] ch212data = {
+(byte) 0x78,(byte) 0xcc,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xcc,(byte) 0x78,(byte) 0x0,(byte) 0x50,(byte) 0x20,
+};
+
+static final BitmapCharRec ch212 = new BitmapCharRec(6,10,0,0,7,ch212data);
+
+/* char: 0xd3 */
+
+static final byte[] ch211data = {
+(byte) 0x78,(byte) 0xcc,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xcc,(byte) 0x78,(byte) 0x0,(byte) 0x10,(byte) 0x8,
+};
+
+static final BitmapCharRec ch211 = new BitmapCharRec(6,10,0,0,7,ch211data);
+
+/* char: 0xd2 */
+
+static final byte[] ch210data = {
+(byte) 0x78,(byte) 0xcc,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xcc,(byte) 0x78,(byte) 0x0,(byte) 0x20,(byte) 0x40,
+};
+
+static final BitmapCharRec ch210 = new BitmapCharRec(6,10,0,0,7,ch210data);
+
+/* char: 0xd1 */
+
+static final byte[] ch209data = {
+(byte) 0xe4,(byte) 0x4c,(byte) 0x4c,(byte) 0x54,(byte) 0x54,(byte) 0x64,(byte) 0xee,(byte) 0x0,(byte) 0x50,(byte) 0x28,
+};
+
+static final BitmapCharRec ch209 = new BitmapCharRec(7,10,0,0,8,ch209data);
+
+/* char: 0xd0 */
+
+static final byte[] ch208data = {
+(byte) 0xf8,(byte) 0x4c,(byte) 0x44,(byte) 0xe4,(byte) 0x44,(byte) 0x4c,(byte) 0xf8,
+};
+
+static final BitmapCharRec ch208 = new BitmapCharRec(6,7,0,0,7,ch208data);
+
+/* char: 0xcf */
+
+static final byte[] ch207data = {
+(byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xe0,(byte) 0x0,(byte) 0xa0,
+};
+
+static final BitmapCharRec ch207 = new BitmapCharRec(3,9,0,0,4,ch207data);
+
+/* char: 0xce */
+
+static final byte[] ch206data = {
+(byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xe0,(byte) 0x0,(byte) 0xa0,(byte) 0x40,
+};
+
+static final BitmapCharRec ch206 = new BitmapCharRec(3,10,0,0,4,ch206data);
+
+/* char: 0xcd */
+
+static final byte[] ch205data = {
+(byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xe0,(byte) 0x0,(byte) 0x40,(byte) 0x20,
+};
+
+static final BitmapCharRec ch205 = new BitmapCharRec(3,10,0,0,4,ch205data);
+
+/* char: 0xcc */
+
+static final byte[] ch204data = {
+(byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xe0,(byte) 0x0,(byte) 0x40,(byte) 0x80,
+};
+
+static final BitmapCharRec ch204 = new BitmapCharRec(3,10,0,0,4,ch204data);
+
+/* char: 0xcb */
+
+static final byte[] ch203data = {
+(byte) 0xf8,(byte) 0x48,(byte) 0x40,(byte) 0x70,(byte) 0x40,(byte) 0x48,(byte) 0xf8,(byte) 0x0,(byte) 0x50,
+};
+
+static final BitmapCharRec ch203 = new BitmapCharRec(5,9,0,0,6,ch203data);
+
+/* char: 0xca */
+
+static final byte[] ch202data = {
+(byte) 0xf8,(byte) 0x48,(byte) 0x40,(byte) 0x70,(byte) 0x40,(byte) 0x48,(byte) 0xf8,(byte) 0x0,(byte) 0x50,(byte) 0x20,
+};
+
+static final BitmapCharRec ch202 = new BitmapCharRec(5,10,0,0,6,ch202data);
+
+/* char: 0xc9 */
+
+static final byte[] ch201data = {
+(byte) 0xf8,(byte) 0x48,(byte) 0x40,(byte) 0x70,(byte) 0x40,(byte) 0x48,(byte) 0xf8,(byte) 0x0,(byte) 0x20,(byte) 0x10,
+};
+
+static final BitmapCharRec ch201 = new BitmapCharRec(5,10,0,0,6,ch201data);
+
+/* char: 0xc8 */
+
+static final byte[] ch200data = {
+(byte) 0xf8,(byte) 0x48,(byte) 0x40,(byte) 0x70,(byte) 0x40,(byte) 0x48,(byte) 0xf8,(byte) 0x0,(byte) 0x20,(byte) 0x40,
+};
+
+static final BitmapCharRec ch200 = new BitmapCharRec(5,10,0,0,6,ch200data);
+
+/* char: 0xc7 */
+
+static final byte[] ch199data = {
+(byte) 0x60,(byte) 0x10,(byte) 0x20,(byte) 0x78,(byte) 0xc4,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xc4,(byte) 0x7c,
+};
+
+static final BitmapCharRec ch199 = new BitmapCharRec(6,10,0,3,7,ch199data);
+
+/* char: 0xc6 */
+
+static final byte[] ch198data = {
+(byte) 0xef,(byte) 0x49,(byte) 0x78,(byte) 0x2e,(byte) 0x28,(byte) 0x39,(byte) 0x1f,
+};
+
+static final BitmapCharRec ch198 = new BitmapCharRec(8,7,0,0,9,ch198data);
+
+/* char: 0xc5 */
+
+static final byte[] ch197data = {
+(byte) 0xee,(byte) 0x44,(byte) 0x7c,(byte) 0x28,(byte) 0x28,(byte) 0x38,(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x10,
+};
+
+static final BitmapCharRec ch197 = new BitmapCharRec(7,10,0,0,8,ch197data);
+
+/* char: 0xc4 */
+
+static final byte[] ch196data = {
+(byte) 0xee,(byte) 0x44,(byte) 0x7c,(byte) 0x28,(byte) 0x28,(byte) 0x38,(byte) 0x10,(byte) 0x0,(byte) 0x28,
+};
+
+static final BitmapCharRec ch196 = new BitmapCharRec(7,9,0,0,8,ch196data);
+
+/* char: 0xc3 */
+
+static final byte[] ch195data = {
+(byte) 0xee,(byte) 0x44,(byte) 0x7c,(byte) 0x28,(byte) 0x28,(byte) 0x38,(byte) 0x10,(byte) 0x0,(byte) 0x28,(byte) 0x14,
+};
+
+static final BitmapCharRec ch195 = new BitmapCharRec(7,10,0,0,8,ch195data);
+
+/* char: 0xc2 */
+
+static final byte[] ch194data = {
+(byte) 0xee,(byte) 0x44,(byte) 0x7c,(byte) 0x28,(byte) 0x28,(byte) 0x38,(byte) 0x10,(byte) 0x0,(byte) 0x28,(byte) 0x10,
+};
+
+static final BitmapCharRec ch194 = new BitmapCharRec(7,10,0,0,8,ch194data);
+
+/* char: 0xc1 */
+
+static final byte[] ch193data = {
+(byte) 0xee,(byte) 0x44,(byte) 0x7c,(byte) 0x28,(byte) 0x28,(byte) 0x38,(byte) 0x10,(byte) 0x0,(byte) 0x10,(byte) 0x8,
+};
+
+static final BitmapCharRec ch193 = new BitmapCharRec(7,10,0,0,8,ch193data);
+
+/* char: 0xc0 */
+
+static final byte[] ch192data = {
+(byte) 0xee,(byte) 0x44,(byte) 0x7c,(byte) 0x28,(byte) 0x28,(byte) 0x38,(byte) 0x10,(byte) 0x0,(byte) 0x10,(byte) 0x20,
+};
+
+static final BitmapCharRec ch192 = new BitmapCharRec(7,10,0,0,8,ch192data);
+
+/* char: 0xbf */
+
+static final byte[] ch191data = {
+(byte) 0xe0,(byte) 0xa0,(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x0,(byte) 0x40,
+};
+
+static final BitmapCharRec ch191 = new BitmapCharRec(3,7,0,2,4,ch191data);
+
+/* char: 0xbe */
+
+static final byte[] ch190data = {
+(byte) 0x44,(byte) 0x3e,(byte) 0x2c,(byte) 0xd4,(byte) 0x28,(byte) 0x48,(byte) 0xe4,
+};
+
+static final BitmapCharRec ch190 = new BitmapCharRec(7,7,0,0,8,ch190data);
+
+/* char: 0xbd */
+
+static final byte[] ch189data = {
+(byte) 0x4e,(byte) 0x24,(byte) 0x2a,(byte) 0xf6,(byte) 0x48,(byte) 0xc8,(byte) 0x44,
+};
+
+static final BitmapCharRec ch189 = new BitmapCharRec(7,7,0,0,8,ch189data);
+
+/* char: 0xbc */
+
+static final byte[] ch188data = {
+(byte) 0x44,(byte) 0x3e,(byte) 0x2c,(byte) 0xf4,(byte) 0x48,(byte) 0xc8,(byte) 0x44,
+};
+
+static final BitmapCharRec ch188 = new BitmapCharRec(7,7,0,0,8,ch188data);
+
+/* char: 0xbb */
+
+static final byte[] ch187data = {
+(byte) 0xa0,(byte) 0x50,(byte) 0x50,(byte) 0xa0,
+};
+
+static final BitmapCharRec ch187 = new BitmapCharRec(4,4,0,-1,5,ch187data);
+
+/* char: 0xba */
+
+static final byte[] ch186data = {
+(byte) 0xe0,(byte) 0x0,(byte) 0x40,(byte) 0xa0,(byte) 0x40,
+};
+
+static final BitmapCharRec ch186 = new BitmapCharRec(3,5,0,-2,4,ch186data);
+
+/* char: 0xb9 */
+
+static final byte[] ch185data = {
+(byte) 0xe0,(byte) 0x40,(byte) 0xc0,(byte) 0x40,
+};
+
+static final BitmapCharRec ch185 = new BitmapCharRec(3,4,0,-3,3,ch185data);
+
+/* char: 0xb8 */
+
+static final byte[] ch184data = {
+(byte) 0xc0,(byte) 0x20,(byte) 0x40,
+};
+
+static final BitmapCharRec ch184 = new BitmapCharRec(3,3,0,3,4,ch184data);
+
+/* char: 0xb7 */
+
+static final byte[] ch183data = {
+(byte) 0x80,
+};
+
+static final BitmapCharRec ch183 = new BitmapCharRec(1,1,0,-2,2,ch183data);
+
+/* char: 0xb6 */
+
+static final byte[] ch182data = {
+(byte) 0x28,(byte) 0x28,(byte) 0x28,(byte) 0x28,(byte) 0x68,(byte) 0xe8,(byte) 0xe8,(byte) 0xe8,(byte) 0x7c,
+};
+
+static final BitmapCharRec ch182 = new BitmapCharRec(6,9,0,2,6,ch182data);
+
+/* char: 0xb5 */
+
+static final byte[] ch181data = {
+(byte) 0x80,(byte) 0x80,(byte) 0xe8,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,
+};
+
+static final BitmapCharRec ch181 = new BitmapCharRec(5,7,0,2,5,ch181data);
+
+/* char: 0xb4 */
+
+static final byte[] ch180data = {
+(byte) 0x80,(byte) 0x40,
+};
+
+static final BitmapCharRec ch180 = new BitmapCharRec(2,2,0,-5,3,ch180data);
+
+/* char: 0xb3 */
+
+static final byte[] ch179data = {
+(byte) 0xc0,(byte) 0x20,(byte) 0x40,(byte) 0xe0,
+};
+
+static final BitmapCharRec ch179 = new BitmapCharRec(3,4,0,-3,3,ch179data);
+
+/* char: 0xb2 */
+
+static final byte[] ch178data = {
+(byte) 0xe0,(byte) 0x40,(byte) 0xa0,(byte) 0x60,
+};
+
+static final BitmapCharRec ch178 = new BitmapCharRec(3,4,0,-3,3,ch178data);
+
+/* char: 0xb1 */
+
+static final byte[] ch177data = {
+(byte) 0xf8,(byte) 0x0,(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0x20,
+};
+
+static final BitmapCharRec ch177 = new BitmapCharRec(5,7,0,0,6,ch177data);
+
+/* char: 0xb0 */
+
+static final byte[] ch176data = {
+(byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x60,
+};
+
+static final BitmapCharRec ch176 = new BitmapCharRec(4,4,0,-3,4,ch176data);
+
+/* char: 0xaf */
+
+static final byte[] ch175data = {
+(byte) 0xe0,
+};
+
+static final BitmapCharRec ch175 = new BitmapCharRec(3,1,0,-6,4,ch175data);
+
+/* char: 0xae */
+
+static final byte[] ch174data = {
+(byte) 0x38,(byte) 0x44,(byte) 0xaa,(byte) 0xb2,(byte) 0xba,(byte) 0x44,(byte) 0x38,
+};
+
+static final BitmapCharRec ch174 = new BitmapCharRec(7,7,-1,0,9,ch174data);
+
+/* char: 0xad */
+
+static final byte[] ch173data = {
+(byte) 0xe0,
+};
+
+static final BitmapCharRec ch173 = new BitmapCharRec(3,1,0,-2,4,ch173data);
+
+/* char: 0xac */
+
+static final byte[] ch172data = {
+(byte) 0x8,(byte) 0x8,(byte) 0xf8,
+};
+
+static final BitmapCharRec ch172 = new BitmapCharRec(5,3,-1,-1,7,ch172data);
+
+/* char: 0xab */
+
+static final byte[] ch171data = {
+(byte) 0x50,(byte) 0xa0,(byte) 0xa0,(byte) 0x50,
+};
+
+static final BitmapCharRec ch171 = new BitmapCharRec(4,4,0,-1,5,ch171data);
+
+/* char: 0xaa */
+
+static final byte[] ch170data = {
+(byte) 0xe0,(byte) 0x0,(byte) 0xa0,(byte) 0x20,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch170 = new BitmapCharRec(3,5,0,-2,4,ch170data);
+
+/* char: 0xa9 */
+
+static final byte[] ch169data = {
+(byte) 0x38,(byte) 0x44,(byte) 0x9a,(byte) 0xa2,(byte) 0x9a,(byte) 0x44,(byte) 0x38,
+};
+
+static final BitmapCharRec ch169 = new BitmapCharRec(7,7,-1,0,9,ch169data);
+
+/* char: 0xa8 */
+
+static final byte[] ch168data = {
+(byte) 0xa0,
+};
+
+static final BitmapCharRec ch168 = new BitmapCharRec(3,1,-1,-6,5,ch168data);
+
+/* char: 0xa7 */
+
+static final byte[] ch167data = {
+(byte) 0xe0,(byte) 0x90,(byte) 0x20,(byte) 0x50,(byte) 0x90,(byte) 0xa0,(byte) 0x40,(byte) 0x90,(byte) 0x70,
+};
+
+static final BitmapCharRec ch167 = new BitmapCharRec(4,9,0,1,5,ch167data);
+
+/* char: 0xa6 */
+
+static final byte[] ch166data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch166 = new BitmapCharRec(1,7,0,0,2,ch166data);
+
+/* char: 0xa5 */
+
+static final byte[] ch165data = {
+(byte) 0x70,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0xd8,(byte) 0x50,(byte) 0x88,
+};
+
+static final BitmapCharRec ch165 = new BitmapCharRec(5,7,0,0,5,ch165data);
+
+/* char: 0xa4 */
+
+static final byte[] ch164data = {
+(byte) 0x88,(byte) 0x70,(byte) 0x50,(byte) 0x50,(byte) 0x70,(byte) 0x88,
+};
+
+static final BitmapCharRec ch164 = new BitmapCharRec(5,6,0,-1,5,ch164data);
+
+/* char: 0xa3 */
+
+static final byte[] ch163data = {
+(byte) 0xf0,(byte) 0xc8,(byte) 0x40,(byte) 0xe0,(byte) 0x40,(byte) 0x50,(byte) 0x30,
+};
+
+static final BitmapCharRec ch163 = new BitmapCharRec(5,7,0,0,5,ch163data);
+
+/* char: 0xa2 */
+
+static final byte[] ch162data = {
+(byte) 0x80,(byte) 0xe0,(byte) 0x90,(byte) 0x80,(byte) 0x90,(byte) 0x70,(byte) 0x10,
+};
+
+static final BitmapCharRec ch162 = new BitmapCharRec(4,7,0,1,5,ch162data);
+
+/* char: 0xa1 */
+
+static final byte[] ch161data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x80,
+};
+
+static final BitmapCharRec ch161 = new BitmapCharRec(1,7,-1,2,3,ch161data);
+
+/* char: 0xa0 */
+
+static final BitmapCharRec ch160 = new BitmapCharRec(0,0,0,0,2,null);
+
+/* char: 0x7e '~' */
+
+static final byte[] ch126data = {
+(byte) 0x98,(byte) 0x64,
+};
+
+static final BitmapCharRec ch126 = new BitmapCharRec(6,2,0,-2,7,ch126data);
+
+/* char: 0x7d '}' */
+
+static final byte[] ch125data = {
+(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x80,
+};
+
+static final BitmapCharRec ch125 = new BitmapCharRec(3,9,0,2,4,ch125data);
+
+/* char: 0x7c '|' */
+
+static final byte[] ch124data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch124 = new BitmapCharRec(1,9,0,2,2,ch124data);
+
+/* char: 0x7b '{' */
+
+static final byte[] ch123data = {
+(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x20,
+};
+
+static final BitmapCharRec ch123 = new BitmapCharRec(3,9,0,2,4,ch123data);
+
+/* char: 0x7a 'z' */
+
+static final byte[] ch122data = {
+(byte) 0xf0,(byte) 0x90,(byte) 0x40,(byte) 0x20,(byte) 0xf0,
+};
+
+static final BitmapCharRec ch122 = new BitmapCharRec(4,5,0,0,5,ch122data);
+
+/* char: 0x79 'y' */
+
+static final byte[] ch121data = {
+(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x30,(byte) 0x50,(byte) 0x48,(byte) 0xdc,
+};
+
+static final BitmapCharRec ch121 = new BitmapCharRec(6,7,1,2,5,ch121data);
+
+/* char: 0x78 'x' */
+
+static final byte[] ch120data = {
+(byte) 0xd8,(byte) 0x50,(byte) 0x20,(byte) 0x50,(byte) 0xd8,
+};
+
+static final BitmapCharRec ch120 = new BitmapCharRec(5,5,0,0,6,ch120data);
+
+/* char: 0x77 'w' */
+
+static final byte[] ch119data = {
+(byte) 0x28,(byte) 0x6c,(byte) 0x54,(byte) 0x92,(byte) 0xdb,
+};
+
+static final BitmapCharRec ch119 = new BitmapCharRec(8,5,0,0,8,ch119data);
+
+/* char: 0x76 'v' */
+
+static final byte[] ch118data = {
+(byte) 0x20,(byte) 0x60,(byte) 0x50,(byte) 0x90,(byte) 0xd8,
+};
+
+static final BitmapCharRec ch118 = new BitmapCharRec(5,5,0,0,5,ch118data);
+
+/* char: 0x75 'u' */
+
+static final byte[] ch117data = {
+(byte) 0x68,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,
+};
+
+static final BitmapCharRec ch117 = new BitmapCharRec(5,5,0,0,5,ch117data);
+
+/* char: 0x74 't' */
+
+static final byte[] ch116data = {
+(byte) 0x30,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xe0,(byte) 0x40,
+};
+
+static final BitmapCharRec ch116 = new BitmapCharRec(4,6,0,0,4,ch116data);
+
+/* char: 0x73 's' */
+
+static final byte[] ch115data = {
+(byte) 0xe0,(byte) 0x20,(byte) 0x60,(byte) 0x80,(byte) 0xe0,
+};
+
+static final BitmapCharRec ch115 = new BitmapCharRec(3,5,0,0,4,ch115data);
+
+/* char: 0x72 'r' */
+
+static final byte[] ch114data = {
+(byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x60,(byte) 0xa0,
+};
+
+static final BitmapCharRec ch114 = new BitmapCharRec(3,5,0,0,4,ch114data);
+
+/* char: 0x71 'q' */
+
+static final byte[] ch113data = {
+(byte) 0x38,(byte) 0x10,(byte) 0x70,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x70,
+};
+
+static final BitmapCharRec ch113 = new BitmapCharRec(5,7,0,2,5,ch113data);
+
+/* char: 0x70 'p' */
+
+static final byte[] ch112data = {
+(byte) 0xc0,(byte) 0x80,(byte) 0xe0,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0xe0,
+};
+
+static final BitmapCharRec ch112 = new BitmapCharRec(4,7,0,2,5,ch112data);
+
+/* char: 0x6f 'o' */
+
+static final byte[] ch111data = {
+(byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x60,
+};
+
+static final BitmapCharRec ch111 = new BitmapCharRec(4,5,0,0,5,ch111data);
+
+/* char: 0x6e 'n' */
+
+static final byte[] ch110data = {
+(byte) 0xd8,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0xe0,
+};
+
+static final BitmapCharRec ch110 = new BitmapCharRec(5,5,0,0,5,ch110data);
+
+/* char: 0x6d 'm' */
+
+static final byte[] ch109data = {
+(byte) 0xdb,(byte) 0x92,(byte) 0x92,(byte) 0x92,(byte) 0xec,
+};
+
+static final BitmapCharRec ch109 = new BitmapCharRec(8,5,0,0,8,ch109data);
+
+/* char: 0x6c 'l' */
+
+static final byte[] ch108data = {
+(byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch108 = new BitmapCharRec(3,7,0,0,4,ch108data);
+
+/* char: 0x6b 'k' */
+
+static final byte[] ch107data = {
+(byte) 0x98,(byte) 0x90,(byte) 0xe0,(byte) 0xa0,(byte) 0x90,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch107 = new BitmapCharRec(5,7,0,0,5,ch107data);
+
+/* char: 0x6a 'j' */
+
+static final byte[] ch106data = {
+(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x0,(byte) 0x40,
+};
+
+static final BitmapCharRec ch106 = new BitmapCharRec(2,9,0,2,3,ch106data);
+
+/* char: 0x69 'i' */
+
+static final byte[] ch105data = {
+(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x0,(byte) 0x40,
+};
+
+static final BitmapCharRec ch105 = new BitmapCharRec(2,7,0,0,3,ch105data);
+
+/* char: 0x68 'h' */
+
+static final byte[] ch104data = {
+(byte) 0xd8,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0xe0,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch104 = new BitmapCharRec(5,7,0,0,5,ch104data);
+
+/* char: 0x67 'g' */
+
+static final byte[] ch103data = {
+(byte) 0xe0,(byte) 0x90,(byte) 0x60,(byte) 0x40,(byte) 0xa0,(byte) 0xa0,(byte) 0x70,
+};
+
+static final BitmapCharRec ch103 = new BitmapCharRec(4,7,0,2,5,ch103data);
+
+/* char: 0x66 'f' */
+
+static final byte[] ch102data = {
+(byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xe0,(byte) 0x40,(byte) 0x30,
+};
+
+static final BitmapCharRec ch102 = new BitmapCharRec(4,7,0,0,4,ch102data);
+
+/* char: 0x65 'e' */
+
+static final byte[] ch101data = {
+(byte) 0x60,(byte) 0x80,(byte) 0xc0,(byte) 0xa0,(byte) 0x60,
+};
+
+static final BitmapCharRec ch101 = new BitmapCharRec(3,5,0,0,4,ch101data);
+
+/* char: 0x64 'd' */
+
+static final byte[] ch100data = {
+(byte) 0x68,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x70,(byte) 0x10,(byte) 0x30,
+};
+
+static final BitmapCharRec ch100 = new BitmapCharRec(5,7,0,0,5,ch100data);
+
+/* char: 0x63 'c' */
+
+static final byte[] ch99data = {
+(byte) 0x60,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x60,
+};
+
+static final BitmapCharRec ch99 = new BitmapCharRec(3,5,0,0,4,ch99data);
+
+/* char: 0x62 'b' */
+
+static final byte[] ch98data = {
+(byte) 0xe0,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0xe0,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch98 = new BitmapCharRec(4,7,0,0,5,ch98data);
+
+/* char: 0x61 'a' */
+
+static final byte[] ch97data = {
+(byte) 0xe0,(byte) 0xa0,(byte) 0x60,(byte) 0x20,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch97 = new BitmapCharRec(3,5,0,0,4,ch97data);
+
+/* char: 0x60 '`' */
+
+static final byte[] ch96data = {
+(byte) 0xc0,(byte) 0x80,
+};
+
+static final BitmapCharRec ch96 = new BitmapCharRec(2,2,0,-5,3,ch96data);
+
+/* char: 0x5f '_' */
+
+static final byte[] ch95data = {
+(byte) 0xf8,
+};
+
+static final BitmapCharRec ch95 = new BitmapCharRec(5,1,0,3,5,ch95data);
+
+/* char: 0x5e '^' */
+
+static final byte[] ch94data = {
+(byte) 0xa0,(byte) 0xa0,(byte) 0x40,
+};
+
+static final BitmapCharRec ch94 = new BitmapCharRec(3,3,-1,-4,5,ch94data);
+
+/* char: 0x5d ']' */
+
+static final byte[] ch93data = {
+(byte) 0xc0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch93 = new BitmapCharRec(2,9,0,2,3,ch93data);
+
+/* char: 0x5c '\' */
+
+static final byte[] ch92data = {
+(byte) 0x20,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch92 = new BitmapCharRec(3,7,0,0,3,ch92data);
+
+/* char: 0x5b '[' */
+
+static final byte[] ch91data = {
+(byte) 0xc0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch91 = new BitmapCharRec(2,9,0,2,3,ch91data);
+
+/* char: 0x5a 'Z' */
+
+static final byte[] ch90data = {
+(byte) 0xf8,(byte) 0x88,(byte) 0x40,(byte) 0x20,(byte) 0x10,(byte) 0x88,(byte) 0xf8,
+};
+
+static final BitmapCharRec ch90 = new BitmapCharRec(5,7,0,0,6,ch90data);
+
+/* char: 0x59 'Y' */
+
+static final byte[] ch89data = {
+(byte) 0x38,(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x28,(byte) 0x44,(byte) 0xee,
+};
+
+static final BitmapCharRec ch89 = new BitmapCharRec(7,7,0,0,8,ch89data);
+
+/* char: 0x58 'X' */
+
+static final byte[] ch88data = {
+(byte) 0xee,(byte) 0x44,(byte) 0x28,(byte) 0x10,(byte) 0x28,(byte) 0x44,(byte) 0xee,
+};
+
+static final BitmapCharRec ch88 = new BitmapCharRec(7,7,0,0,8,ch88data);
+
+/* char: 0x57 'W' */
+
+static final byte[] ch87data = {
+(byte) 0x22,(byte) 0x0,(byte) 0x22,(byte) 0x0,(byte) 0x55,(byte) 0x0,(byte) 0x55,(byte) 0x0,(byte) 0xc9,(byte) 0x80,(byte) 0x88,(byte) 0x80,(byte) 0xdd,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch87 = new BitmapCharRec(10,7,0,0,10,ch87data);
+
+/* char: 0x56 'V' */
+
+static final byte[] ch86data = {
+(byte) 0x10,(byte) 0x10,(byte) 0x28,(byte) 0x28,(byte) 0x6c,(byte) 0x44,(byte) 0xee,
+};
+
+static final BitmapCharRec ch86 = new BitmapCharRec(7,7,0,0,8,ch86data);
+
+/* char: 0x55 'U' */
+
+static final byte[] ch85data = {
+(byte) 0x38,(byte) 0x6c,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0xee,
+};
+
+static final BitmapCharRec ch85 = new BitmapCharRec(7,7,0,0,8,ch85data);
+
+/* char: 0x54 'T' */
+
+static final byte[] ch84data = {
+(byte) 0x70,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xa8,(byte) 0xf8,
+};
+
+static final BitmapCharRec ch84 = new BitmapCharRec(5,7,0,0,6,ch84data);
+
+/* char: 0x53 'S' */
+
+static final byte[] ch83data = {
+(byte) 0xe0,(byte) 0x90,(byte) 0x10,(byte) 0x60,(byte) 0xc0,(byte) 0x90,(byte) 0x70,
+};
+
+static final BitmapCharRec ch83 = new BitmapCharRec(4,7,0,0,5,ch83data);
+
+/* char: 0x52 'R' */
+
+static final byte[] ch82data = {
+(byte) 0xec,(byte) 0x48,(byte) 0x50,(byte) 0x70,(byte) 0x48,(byte) 0x48,(byte) 0xf0,
+};
+
+static final BitmapCharRec ch82 = new BitmapCharRec(6,7,0,0,7,ch82data);
+
+/* char: 0x51 'Q' */
+
+static final byte[] ch81data = {
+(byte) 0xc,(byte) 0x18,(byte) 0x70,(byte) 0xcc,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xcc,(byte) 0x78,
+};
+
+static final BitmapCharRec ch81 = new BitmapCharRec(6,9,0,2,7,ch81data);
+
+/* char: 0x50 'P' */
+
+static final byte[] ch80data = {
+(byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x70,(byte) 0x48,(byte) 0x48,(byte) 0xf0,
+};
+
+static final BitmapCharRec ch80 = new BitmapCharRec(5,7,0,0,6,ch80data);
+
+/* char: 0x4f 'O' */
+
+static final byte[] ch79data = {
+(byte) 0x78,(byte) 0xcc,(byte) 0x84,(byte) 0x84,(byte) 0x84,(byte) 0xcc,(byte) 0x78,
+};
+
+static final BitmapCharRec ch79 = new BitmapCharRec(6,7,0,0,7,ch79data);
+
+/* char: 0x4e 'N' */
+
+static final byte[] ch78data = {
+(byte) 0xe4,(byte) 0x4c,(byte) 0x4c,(byte) 0x54,(byte) 0x54,(byte) 0x64,(byte) 0xee,
+};
+
+static final BitmapCharRec ch78 = new BitmapCharRec(7,7,0,0,8,ch78data);
+
+/* char: 0x4d 'M' */
+
+static final byte[] ch77data = {
+(byte) 0xeb,(byte) 0x80,(byte) 0x49,(byte) 0x0,(byte) 0x55,(byte) 0x0,(byte) 0x55,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0xe3,(byte) 0x80,
+};
+
+static final BitmapCharRec ch77 = new BitmapCharRec(9,7,0,0,10,ch77data);
+
+/* char: 0x4c 'L' */
+
+static final byte[] ch76data = {
+(byte) 0xf8,(byte) 0x48,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xe0,
+};
+
+static final BitmapCharRec ch76 = new BitmapCharRec(5,7,0,0,6,ch76data);
+
+/* char: 0x4b 'K' */
+
+static final byte[] ch75data = {
+(byte) 0xec,(byte) 0x48,(byte) 0x50,(byte) 0x60,(byte) 0x50,(byte) 0x48,(byte) 0xec,
+};
+
+static final BitmapCharRec ch75 = new BitmapCharRec(6,7,0,0,7,ch75data);
+
+/* char: 0x4a 'J' */
+
+static final byte[] ch74data = {
+(byte) 0xc0,(byte) 0xa0,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x70,
+};
+
+static final BitmapCharRec ch74 = new BitmapCharRec(4,7,0,0,4,ch74data);
+
+/* char: 0x49 'I' */
+
+static final byte[] ch73data = {
+(byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xe0,
+};
+
+static final BitmapCharRec ch73 = new BitmapCharRec(3,7,0,0,4,ch73data);
+
+/* char: 0x48 'H' */
+
+static final byte[] ch72data = {
+(byte) 0xee,(byte) 0x44,(byte) 0x44,(byte) 0x7c,(byte) 0x44,(byte) 0x44,(byte) 0xee,
+};
+
+static final BitmapCharRec ch72 = new BitmapCharRec(7,7,0,0,8,ch72data);
+
+/* char: 0x47 'G' */
+
+static final byte[] ch71data = {
+(byte) 0x78,(byte) 0xc4,(byte) 0x84,(byte) 0x9c,(byte) 0x80,(byte) 0xc4,(byte) 0x7c,
+};
+
+static final BitmapCharRec ch71 = new BitmapCharRec(6,7,0,0,7,ch71data);
+
+/* char: 0x46 'F' */
+
+static final byte[] ch70data = {
+(byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x70,(byte) 0x40,(byte) 0x48,(byte) 0xf8,
+};
+
+static final BitmapCharRec ch70 = new BitmapCharRec(5,7,0,0,6,ch70data);
+
+/* char: 0x45 'E' */
+
+static final byte[] ch69data = {
+(byte) 0xf8,(byte) 0x48,(byte) 0x40,(byte) 0x70,(byte) 0x40,(byte) 0x48,(byte) 0xf8,
+};
+
+static final BitmapCharRec ch69 = new BitmapCharRec(5,7,0,0,6,ch69data);
+
+/* char: 0x44 'D' */
+
+static final byte[] ch68data = {
+(byte) 0xf8,(byte) 0x4c,(byte) 0x44,(byte) 0x44,(byte) 0x44,(byte) 0x4c,(byte) 0xf8,
+};
+
+static final BitmapCharRec ch68 = new BitmapCharRec(6,7,0,0,7,ch68data);
+
+/* char: 0x43 'C' */
+
+static final byte[] ch67data = {
+(byte) 0x78,(byte) 0xc4,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0xc4,(byte) 0x7c,
+};
+
+static final BitmapCharRec ch67 = new BitmapCharRec(6,7,0,0,7,ch67data);
+
+/* char: 0x42 'B' */
+
+static final byte[] ch66data = {
+(byte) 0xf0,(byte) 0x48,(byte) 0x48,(byte) 0x70,(byte) 0x48,(byte) 0x48,(byte) 0xf0,
+};
+
+static final BitmapCharRec ch66 = new BitmapCharRec(5,7,0,0,6,ch66data);
+
+/* char: 0x41 'A' */
+
+static final byte[] ch65data = {
+(byte) 0xee,(byte) 0x44,(byte) 0x7c,(byte) 0x28,(byte) 0x28,(byte) 0x38,(byte) 0x10,
+};
+
+static final BitmapCharRec ch65 = new BitmapCharRec(7,7,0,0,8,ch65data);
+
+/* char: 0x40 '@' */
+
+static final byte[] ch64data = {
+(byte) 0x3e,(byte) 0x40,(byte) 0x92,(byte) 0xad,(byte) 0xa5,(byte) 0xa5,(byte) 0x9d,(byte) 0x42,(byte) 0x3c,
+};
+
+static final BitmapCharRec ch64 = new BitmapCharRec(8,9,0,2,9,ch64data);
+
+/* char: 0x3f '?' */
+
+static final byte[] ch63data = {
+(byte) 0x40,(byte) 0x0,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0xa0,(byte) 0xe0,
+};
+
+static final BitmapCharRec ch63 = new BitmapCharRec(3,7,0,0,4,ch63data);
+
+/* char: 0x3e '>' */
+
+static final byte[] ch62data = {
+(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x40,(byte) 0x80,
+};
+
+static final BitmapCharRec ch62 = new BitmapCharRec(3,5,0,0,5,ch62data);
+
+/* char: 0x3d '=' */
+
+static final byte[] ch61data = {
+(byte) 0xf8,(byte) 0x0,(byte) 0xf8,
+};
+
+static final BitmapCharRec ch61 = new BitmapCharRec(5,3,0,-1,6,ch61data);
+
+/* char: 0x3c '<' */
+
+static final byte[] ch60data = {
+(byte) 0x20,(byte) 0x40,(byte) 0x80,(byte) 0x40,(byte) 0x20,
+};
+
+static final BitmapCharRec ch60 = new BitmapCharRec(3,5,-1,0,5,ch60data);
+
+/* char: 0x3b ';' */
+
+static final byte[] ch59data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x80,
+};
+
+static final BitmapCharRec ch59 = new BitmapCharRec(1,7,-1,2,3,ch59data);
+
+/* char: 0x3a ':' */
+
+static final byte[] ch58data = {
+(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x80,
+};
+
+static final BitmapCharRec ch58 = new BitmapCharRec(1,5,-1,0,3,ch58data);
+
+/* char: 0x39 '9' */
+
+static final byte[] ch57data = {
+(byte) 0xc0,(byte) 0x20,(byte) 0x70,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x60,
+};
+
+static final BitmapCharRec ch57 = new BitmapCharRec(4,7,0,0,5,ch57data);
+
+/* char: 0x38 '8' */
+
+static final byte[] ch56data = {
+(byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x60,
+};
+
+static final BitmapCharRec ch56 = new BitmapCharRec(4,7,0,0,5,ch56data);
+
+/* char: 0x37 '7' */
+
+static final byte[] ch55data = {
+(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x90,(byte) 0xf0,
+};
+
+static final BitmapCharRec ch55 = new BitmapCharRec(4,7,0,0,5,ch55data);
+
+/* char: 0x36 '6' */
+
+static final byte[] ch54data = {
+(byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0xe0,(byte) 0x40,(byte) 0x30,
+};
+
+static final BitmapCharRec ch54 = new BitmapCharRec(4,7,0,0,5,ch54data);
+
+/* char: 0x35 '5' */
+
+static final byte[] ch53data = {
+(byte) 0xe0,(byte) 0x90,(byte) 0x10,(byte) 0x10,(byte) 0xe0,(byte) 0x40,(byte) 0x70,
+};
+
+static final BitmapCharRec ch53 = new BitmapCharRec(4,7,0,0,5,ch53data);
+
+/* char: 0x34 '4' */
+
+static final byte[] ch52data = {
+(byte) 0x10,(byte) 0x10,(byte) 0xf8,(byte) 0x90,(byte) 0x50,(byte) 0x30,(byte) 0x10,
+};
+
+static final BitmapCharRec ch52 = new BitmapCharRec(5,7,0,0,5,ch52data);
+
+/* char: 0x33 '3' */
+
+static final byte[] ch51data = {
+(byte) 0xe0,(byte) 0x10,(byte) 0x10,(byte) 0x60,(byte) 0x10,(byte) 0x90,(byte) 0x60,
+};
+
+static final BitmapCharRec ch51 = new BitmapCharRec(4,7,0,0,5,ch51data);
+
+/* char: 0x32 '2' */
+
+static final byte[] ch50data = {
+(byte) 0xf0,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x10,(byte) 0x90,(byte) 0x60,
+};
+
+static final BitmapCharRec ch50 = new BitmapCharRec(4,7,0,0,5,ch50data);
+
+/* char: 0x31 '1' */
+
+static final byte[] ch49data = {
+(byte) 0xe0,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0xc0,(byte) 0x40,
+};
+
+static final BitmapCharRec ch49 = new BitmapCharRec(3,7,-1,0,5,ch49data);
+
+/* char: 0x30 '0' */
+
+static final byte[] ch48data = {
+(byte) 0x60,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x90,(byte) 0x60,
+};
+
+static final BitmapCharRec ch48 = new BitmapCharRec(4,7,0,0,5,ch48data);
+
+/* char: 0x2f '/' */
+
+static final byte[] ch47data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20,
+};
+
+static final BitmapCharRec ch47 = new BitmapCharRec(3,7,0,0,3,ch47data);
+
+/* char: 0x2e '.' */
+
+static final byte[] ch46data = {
+(byte) 0x80,
+};
+
+static final BitmapCharRec ch46 = new BitmapCharRec(1,1,-1,0,3,ch46data);
+
+/* char: 0x2d '-' */
+
+static final byte[] ch45data = {
+(byte) 0xf0,
+};
+
+static final BitmapCharRec ch45 = new BitmapCharRec(4,1,-1,-2,7,ch45data);
+
+/* char: 0x2c ',' */
+
+static final byte[] ch44data = {
+(byte) 0x80,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch44 = new BitmapCharRec(1,3,-1,2,3,ch44data);
+
+/* char: 0x2b '+' */
+
+static final byte[] ch43data = {
+(byte) 0x20,(byte) 0x20,(byte) 0xf8,(byte) 0x20,(byte) 0x20,
+};
+
+static final BitmapCharRec ch43 = new BitmapCharRec(5,5,0,0,6,ch43data);
+
+/* char: 0x2a '*' */
+
+static final byte[] ch42data = {
+(byte) 0xa0,(byte) 0x40,(byte) 0xa0,
+};
+
+static final BitmapCharRec ch42 = new BitmapCharRec(3,3,0,-4,5,ch42data);
+
+/* char: 0x29 ')' */
+
+static final byte[] ch41data = {
+(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x80,
+};
+
+static final BitmapCharRec ch41 = new BitmapCharRec(3,9,0,2,4,ch41data);
+
+/* char: 0x28 '(' */
+
+static final byte[] ch40data = {
+(byte) 0x20,(byte) 0x40,(byte) 0x40,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x40,(byte) 0x40,(byte) 0x20,
+};
+
+static final BitmapCharRec ch40 = new BitmapCharRec(3,9,0,2,4,ch40data);
+
+/* char: 0x27 ''' */
+
+static final byte[] ch39data = {
+(byte) 0x40,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch39 = new BitmapCharRec(2,2,0,-5,3,ch39data);
+
+/* char: 0x26 '&' */
+
+static final byte[] ch38data = {
+(byte) 0x76,(byte) 0x8d,(byte) 0x98,(byte) 0x74,(byte) 0x6e,(byte) 0x50,(byte) 0x30,
+};
+
+static final BitmapCharRec ch38 = new BitmapCharRec(8,7,0,0,8,ch38data);
+
+/* char: 0x25 '%' */
+
+static final byte[] ch37data = {
+(byte) 0x44,(byte) 0x2a,(byte) 0x2a,(byte) 0x56,(byte) 0xa8,(byte) 0xa4,(byte) 0x7e,
+};
+
+static final BitmapCharRec ch37 = new BitmapCharRec(7,7,0,0,8,ch37data);
+
+/* char: 0x24 '$' */
+
+static final byte[] ch36data = {
+(byte) 0x20,(byte) 0xe0,(byte) 0x90,(byte) 0x10,(byte) 0x60,(byte) 0x80,(byte) 0x90,(byte) 0x70,(byte) 0x20,
+};
+
+static final BitmapCharRec ch36 = new BitmapCharRec(4,9,0,1,5,ch36data);
+
+/* char: 0x23 '#' */
+
+static final byte[] ch35data = {
+(byte) 0x50,(byte) 0x50,(byte) 0xf8,(byte) 0x50,(byte) 0xf8,(byte) 0x50,(byte) 0x50,
+};
+
+static final BitmapCharRec ch35 = new BitmapCharRec(5,7,0,0,5,ch35data);
+
+/* char: 0x22 '"' */
+
+static final byte[] ch34data = {
+(byte) 0xa0,(byte) 0xa0,
+};
+
+static final BitmapCharRec ch34 = new BitmapCharRec(3,2,0,-5,4,ch34data);
+
+/* char: 0x21 '!' */
+
+static final byte[] ch33data = {
+(byte) 0x80,(byte) 0x0,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,(byte) 0x80,
+};
+
+static final BitmapCharRec ch33 = new BitmapCharRec(1,7,-1,0,3,ch33data);
+
+/* char: 0x20 ' ' */
+
+static final BitmapCharRec ch32 = new BitmapCharRec(0,0,0,0,2,null);
+
+static final BitmapCharRec[] chars = {
+ch32,
+ch33,
+ch34,
+ch35,
+ch36,
+ch37,
+ch38,
+ch39,
+ch40,
+ch41,
+ch42,
+ch43,
+ch44,
+ch45,
+ch46,
+ch47,
+ch48,
+ch49,
+ch50,
+ch51,
+ch52,
+ch53,
+ch54,
+ch55,
+ch56,
+ch57,
+ch58,
+ch59,
+ch60,
+ch61,
+ch62,
+ch63,
+ch64,
+ch65,
+ch66,
+ch67,
+ch68,
+ch69,
+ch70,
+ch71,
+ch72,
+ch73,
+ch74,
+ch75,
+ch76,
+ch77,
+ch78,
+ch79,
+ch80,
+ch81,
+ch82,
+ch83,
+ch84,
+ch85,
+ch86,
+ch87,
+ch88,
+ch89,
+ch90,
+ch91,
+ch92,
+ch93,
+ch94,
+ch95,
+ch96,
+ch97,
+ch98,
+ch99,
+ch100,
+ch101,
+ch102,
+ch103,
+ch104,
+ch105,
+ch106,
+ch107,
+ch108,
+ch109,
+ch110,
+ch111,
+ch112,
+ch113,
+ch114,
+ch115,
+ch116,
+ch117,
+ch118,
+ch119,
+ch120,
+ch121,
+ch122,
+ch123,
+ch124,
+ch125,
+ch126,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+ch160,
+ch161,
+ch162,
+ch163,
+ch164,
+ch165,
+ch166,
+ch167,
+ch168,
+ch169,
+ch170,
+ch171,
+ch172,
+ch173,
+ch174,
+ch175,
+ch176,
+ch177,
+ch178,
+ch179,
+ch180,
+ch181,
+ch182,
+ch183,
+ch184,
+ch185,
+ch186,
+ch187,
+ch188,
+ch189,
+ch190,
+ch191,
+ch192,
+ch193,
+ch194,
+ch195,
+ch196,
+ch197,
+ch198,
+ch199,
+ch200,
+ch201,
+ch202,
+ch203,
+ch204,
+ch205,
+ch206,
+ch207,
+ch208,
+ch209,
+ch210,
+ch211,
+ch212,
+ch213,
+ch214,
+ch215,
+ch216,
+ch217,
+ch218,
+ch219,
+ch220,
+ch221,
+ch222,
+ch223,
+ch224,
+ch225,
+ch226,
+ch227,
+ch228,
+ch229,
+ch230,
+ch231,
+ch232,
+ch233,
+ch234,
+ch235,
+ch236,
+ch237,
+ch238,
+ch239,
+ch240,
+ch241,
+ch242,
+ch243,
+ch244,
+ch245,
+ch246,
+ch247,
+ch248,
+ch249,
+ch250,
+ch251,
+ch252,
+ch253,
+ch254,
+ch255,
+};
+
+  public static final BitmapFontRec glutBitmapTimesRoman10 = new BitmapFontRec("-adobe-times-medium-r-normal--10-100-75-75-p-54-iso8859-1",
+                                                                        224,
+                                                                        32,
+                                                                        chars);
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/gl2/GLUTBitmapTimesRoman24.java b/src/jogl/classes/com/jogamp/opengl/util/gl2/GLUTBitmapTimesRoman24.java
new file mode 100644
index 000000000..073e6e673
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/gl2/GLUTBitmapTimesRoman24.java
@@ -0,0 +1,2080 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util.gl2;
+
+class GLUTBitmapTimesRoman24 {
+
+/* GENERATED FILE -- DO NOT MODIFY */
+
+/* char: 0xff */
+
+static final byte[] ch255data = {
+(byte) 0xe0,(byte) 0x0,(byte) 0xf0,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x4,(byte) 0x0,(byte) 0xe,(byte) 0x0,(byte) 0xe,(byte) 0x0,
+(byte) 0x1a,(byte) 0x0,(byte) 0x19,(byte) 0x0,(byte) 0x19,(byte) 0x0,(byte) 0x31,(byte) 0x0,(byte) 0x30,(byte) 0x80,(byte) 0x30,(byte) 0x80,(byte) 0x60,(byte) 0x80,(byte) 0x60,(byte) 0xc0,
+(byte) 0xf1,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x33,(byte) 0x0,(byte) 0x33,(byte) 0x0,
+};
+
+static final BitmapCharRec ch255 = new BitmapCharRec(11,21,0,5,11,ch255data);
+
+/* char: 0xfe */
+
+static final byte[] ch254data = {
+(byte) 0xf0,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x6e,(byte) 0x0,(byte) 0x73,(byte) 0x80,(byte) 0x61,(byte) 0x80,
+(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x73,(byte) 0x80,
+(byte) 0x6e,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0xe0,(byte) 0x0,
+};
+
+static final BitmapCharRec ch254 = new BitmapCharRec(10,22,-1,5,12,ch254data);
+
+/* char: 0xfd */
+
+static final byte[] ch253data = {
+(byte) 0xe0,(byte) 0x0,(byte) 0xf0,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x4,(byte) 0x0,(byte) 0xe,(byte) 0x0,(byte) 0xe,(byte) 0x0,
+(byte) 0x1a,(byte) 0x0,(byte) 0x19,(byte) 0x0,(byte) 0x19,(byte) 0x0,(byte) 0x31,(byte) 0x0,(byte) 0x30,(byte) 0x80,(byte) 0x30,(byte) 0x80,(byte) 0x60,(byte) 0x80,(byte) 0x60,(byte) 0xc0,
+(byte) 0xf1,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x3,(byte) 0x80,(byte) 0x1,(byte) 0x80,
+};
+
+static final BitmapCharRec ch253 = new BitmapCharRec(11,22,0,5,11,ch253data);
+
+/* char: 0xfc */
+
+static final byte[] ch252data = {
+(byte) 0x1c,(byte) 0xe0,(byte) 0x3e,(byte) 0xc0,(byte) 0x71,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,
+(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xe1,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x33,(byte) 0x0,(byte) 0x33,(byte) 0x0,
+};
+
+static final BitmapCharRec ch252 = new BitmapCharRec(11,16,-1,0,13,ch252data);
+
+/* char: 0xfb */
+
+static final byte[] ch251data = {
+(byte) 0x1c,(byte) 0xe0,(byte) 0x3e,(byte) 0xc0,(byte) 0x71,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,
+(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xe1,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x21,(byte) 0x0,(byte) 0x12,(byte) 0x0,(byte) 0x1e,(byte) 0x0,
+(byte) 0xc,(byte) 0x0,
+};
+
+static final BitmapCharRec ch251 = new BitmapCharRec(11,17,-1,0,13,ch251data);
+
+/* char: 0xfa */
+
+static final byte[] ch250data = {
+(byte) 0x1c,(byte) 0xe0,(byte) 0x3e,(byte) 0xc0,(byte) 0x71,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,
+(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xe1,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x3,(byte) 0x80,
+(byte) 0x1,(byte) 0x80,
+};
+
+static final BitmapCharRec ch250 = new BitmapCharRec(11,17,-1,0,13,ch250data);
+
+/* char: 0xf9 */
+
+static final byte[] ch249data = {
+(byte) 0x1c,(byte) 0xe0,(byte) 0x3e,(byte) 0xc0,(byte) 0x71,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,
+(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xe1,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x2,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x38,(byte) 0x0,
+(byte) 0x30,(byte) 0x0,
+};
+
+static final BitmapCharRec ch249 = new BitmapCharRec(11,17,-1,0,13,ch249data);
+
+/* char: 0xf8 */
+
+static final byte[] ch248data = {
+(byte) 0xc0,(byte) 0x0,(byte) 0xde,(byte) 0x0,(byte) 0x73,(byte) 0x80,(byte) 0x71,(byte) 0x80,(byte) 0xd0,(byte) 0xc0,(byte) 0xd8,(byte) 0xc0,(byte) 0xc8,(byte) 0xc0,(byte) 0xcc,(byte) 0xc0,
+(byte) 0xc4,(byte) 0xc0,(byte) 0xc6,(byte) 0xc0,(byte) 0x63,(byte) 0x80,(byte) 0x73,(byte) 0x80,(byte) 0x1e,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch248 = new BitmapCharRec(10,14,-1,1,12,ch248data);
+
+/* char: 0xf7 */
+
+static final byte[] ch247data = {
+(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xff,(byte) 0xf0,(byte) 0xff,(byte) 0xf0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,
+(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,
+};
+
+static final BitmapCharRec ch247 = new BitmapCharRec(12,10,-1,-2,14,ch247data);
+
+/* char: 0xf6 */
+
+static final byte[] ch246data = {
+(byte) 0x1e,(byte) 0x0,(byte) 0x73,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,
+(byte) 0xc0,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x73,(byte) 0x80,(byte) 0x1e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x33,(byte) 0x0,(byte) 0x33,(byte) 0x0,
+};
+
+static final BitmapCharRec ch246 = new BitmapCharRec(10,16,-1,0,12,ch246data);
+
+/* char: 0xf5 */
+
+static final byte[] ch245data = {
+(byte) 0x1e,(byte) 0x0,(byte) 0x73,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,
+(byte) 0xc0,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x73,(byte) 0x80,(byte) 0x1e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x27,(byte) 0x0,(byte) 0x1c,(byte) 0x80,
+};
+
+static final BitmapCharRec ch245 = new BitmapCharRec(10,16,-1,0,12,ch245data);
+
+/* char: 0xf4 */
+
+static final byte[] ch244data = {
+(byte) 0x1e,(byte) 0x0,(byte) 0x73,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,
+(byte) 0xc0,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x73,(byte) 0x80,(byte) 0x1e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x21,(byte) 0x0,(byte) 0x12,(byte) 0x0,(byte) 0x1e,(byte) 0x0,
+(byte) 0xc,(byte) 0x0,
+};
+
+static final BitmapCharRec ch244 = new BitmapCharRec(10,17,-1,0,12,ch244data);
+
+/* char: 0xf3 */
+
+static final byte[] ch243data = {
+(byte) 0x1e,(byte) 0x0,(byte) 0x73,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,
+(byte) 0xc0,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x73,(byte) 0x80,(byte) 0x1e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x3,(byte) 0x80,
+(byte) 0x1,(byte) 0x80,
+};
+
+static final BitmapCharRec ch243 = new BitmapCharRec(10,17,-1,0,12,ch243data);
+
+/* char: 0xf2 */
+
+static final byte[] ch242data = {
+(byte) 0x1e,(byte) 0x0,(byte) 0x73,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,
+(byte) 0xc0,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x73,(byte) 0x80,(byte) 0x1e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x2,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x38,(byte) 0x0,
+(byte) 0x30,(byte) 0x0,
+};
+
+static final BitmapCharRec ch242 = new BitmapCharRec(10,17,-1,0,12,ch242data);
+
+/* char: 0xf1 */
+
+static final byte[] ch241data = {
+(byte) 0xf1,(byte) 0xe0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,
+(byte) 0x60,(byte) 0xc0,(byte) 0x71,(byte) 0xc0,(byte) 0x6f,(byte) 0x80,(byte) 0xe7,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x27,(byte) 0x0,(byte) 0x1c,(byte) 0x80,
+};
+
+static final BitmapCharRec ch241 = new BitmapCharRec(11,16,-1,0,13,ch241data);
+
+/* char: 0xf0 */
+
+static final byte[] ch240data = {
+(byte) 0x1e,(byte) 0x0,(byte) 0x73,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,
+(byte) 0xc0,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x73,(byte) 0x80,(byte) 0x1f,(byte) 0x0,(byte) 0xc6,(byte) 0x0,(byte) 0x3c,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0x71,(byte) 0x80,
+(byte) 0xc0,(byte) 0x0,
+};
+
+static final BitmapCharRec ch240 = new BitmapCharRec(10,17,-1,0,12,ch240data);
+
+/* char: 0xef */
+
+static final byte[] ch239data = {
+(byte) 0x78,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x70,(byte) 0x0,(byte) 0x0,(byte) 0xcc,(byte) 0xcc,
+};
+
+static final BitmapCharRec ch239 = new BitmapCharRec(6,16,0,0,6,ch239data);
+
+/* char: 0xee */
+
+static final byte[] ch238data = {
+(byte) 0x78,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x70,(byte) 0x0,(byte) 0x84,(byte) 0x48,(byte) 0x78,
+(byte) 0x30,
+};
+
+static final BitmapCharRec ch238 = new BitmapCharRec(6,17,0,0,6,ch238data);
+
+/* char: 0xed */
+
+static final byte[] ch237data = {
+(byte) 0xf0,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0xe0,(byte) 0x0,(byte) 0x80,(byte) 0x60,(byte) 0x38,
+(byte) 0x18,
+};
+
+static final BitmapCharRec ch237 = new BitmapCharRec(5,17,-1,0,6,ch237data);
+
+/* char: 0xec */
+
+static final byte[] ch236data = {
+(byte) 0x78,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x70,(byte) 0x0,(byte) 0x8,(byte) 0x30,(byte) 0xe0,
+(byte) 0xc0,
+};
+
+static final BitmapCharRec ch236 = new BitmapCharRec(5,17,0,0,6,ch236data);
+
+/* char: 0xeb */
+
+static final byte[] ch235data = {
+(byte) 0x1e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x70,(byte) 0x80,(byte) 0xe0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x80,
+(byte) 0xc1,(byte) 0x80,(byte) 0x41,(byte) 0x80,(byte) 0x63,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x33,(byte) 0x0,(byte) 0x33,(byte) 0x0,
+};
+
+static final BitmapCharRec ch235 = new BitmapCharRec(9,16,-1,0,11,ch235data);
+
+/* char: 0xea */
+
+static final byte[] ch234data = {
+(byte) 0x1e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x70,(byte) 0x80,(byte) 0xe0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x80,
+(byte) 0xc1,(byte) 0x80,(byte) 0x41,(byte) 0x80,(byte) 0x63,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x21,(byte) 0x0,(byte) 0x12,(byte) 0x0,(byte) 0x1e,(byte) 0x0,
+(byte) 0xc,(byte) 0x0,
+};
+
+static final BitmapCharRec ch234 = new BitmapCharRec(9,17,-1,0,11,ch234data);
+
+/* char: 0xe9 */
+
+static final byte[] ch233data = {
+(byte) 0x1e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x70,(byte) 0x80,(byte) 0xe0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x80,
+(byte) 0xc1,(byte) 0x80,(byte) 0x41,(byte) 0x80,(byte) 0x63,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x10,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x7,(byte) 0x0,
+(byte) 0x3,(byte) 0x0,
+};
+
+static final BitmapCharRec ch233 = new BitmapCharRec(9,17,-1,0,11,ch233data);
+
+/* char: 0xe8 */
+
+static final byte[] ch232data = {
+(byte) 0x1e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x70,(byte) 0x80,(byte) 0xe0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x80,
+(byte) 0xc1,(byte) 0x80,(byte) 0x41,(byte) 0x80,(byte) 0x63,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x4,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0x70,(byte) 0x0,
+(byte) 0x60,(byte) 0x0,
+};
+
+static final BitmapCharRec ch232 = new BitmapCharRec(9,17,-1,0,11,ch232data);
+
+/* char: 0xe7 */
+
+static final byte[] ch231data = {
+(byte) 0x3c,(byte) 0x0,(byte) 0x66,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,
+(byte) 0x70,(byte) 0x80,(byte) 0xe0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0x41,(byte) 0x80,
+(byte) 0x63,(byte) 0x80,(byte) 0x1f,(byte) 0x0,
+};
+
+static final BitmapCharRec ch231 = new BitmapCharRec(9,18,-1,6,11,ch231data);
+
+/* char: 0xe6 */
+
+static final byte[] ch230data = {
+(byte) 0x70,(byte) 0xf0,(byte) 0xfb,(byte) 0xf8,(byte) 0xc7,(byte) 0x84,(byte) 0xc3,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x3b,(byte) 0x0,(byte) 0xf,(byte) 0xfc,
+(byte) 0x3,(byte) 0xc,(byte) 0x63,(byte) 0xc,(byte) 0x67,(byte) 0x98,(byte) 0x3c,(byte) 0xf0,
+};
+
+static final BitmapCharRec ch230 = new BitmapCharRec(14,12,-1,0,16,ch230data);
+
+/* char: 0xe5 */
+
+static final byte[] ch229data = {
+(byte) 0x71,(byte) 0x80,(byte) 0xfb,(byte) 0x0,(byte) 0xc7,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x3b,(byte) 0x0,(byte) 0xf,(byte) 0x0,
+(byte) 0x3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x67,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x1c,(byte) 0x0,(byte) 0x22,(byte) 0x0,(byte) 0x22,(byte) 0x0,
+(byte) 0x1c,(byte) 0x0,
+};
+
+static final BitmapCharRec ch229 = new BitmapCharRec(9,17,-1,0,11,ch229data);
+
+/* char: 0xe4 */
+
+static final byte[] ch228data = {
+(byte) 0x71,(byte) 0x80,(byte) 0xfb,(byte) 0x0,(byte) 0xc7,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x3b,(byte) 0x0,(byte) 0xf,(byte) 0x0,
+(byte) 0x3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x67,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x66,(byte) 0x0,(byte) 0x66,(byte) 0x0,
+};
+
+static final BitmapCharRec ch228 = new BitmapCharRec(9,16,-1,0,11,ch228data);
+
+/* char: 0xe3 */
+
+static final byte[] ch227data = {
+(byte) 0x71,(byte) 0x80,(byte) 0xfb,(byte) 0x0,(byte) 0xc7,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x3b,(byte) 0x0,(byte) 0xf,(byte) 0x0,
+(byte) 0x3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x67,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x5c,(byte) 0x0,(byte) 0x3a,(byte) 0x0,
+};
+
+static final BitmapCharRec ch227 = new BitmapCharRec(9,16,-1,0,11,ch227data);
+
+/* char: 0xe2 */
+
+static final byte[] ch226data = {
+(byte) 0x71,(byte) 0x80,(byte) 0xfb,(byte) 0x0,(byte) 0xc7,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x3b,(byte) 0x0,(byte) 0xf,(byte) 0x0,
+(byte) 0x3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x67,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x42,(byte) 0x0,(byte) 0x24,(byte) 0x0,(byte) 0x3c,(byte) 0x0,
+(byte) 0x18,(byte) 0x0,
+};
+
+static final BitmapCharRec ch226 = new BitmapCharRec(9,17,-1,0,11,ch226data);
+
+/* char: 0xe1 */
+
+static final byte[] ch225data = {
+(byte) 0x71,(byte) 0x80,(byte) 0xfb,(byte) 0x0,(byte) 0xc7,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x3b,(byte) 0x0,(byte) 0xf,(byte) 0x0,
+(byte) 0x3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x67,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x10,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x7,(byte) 0x0,
+(byte) 0x3,(byte) 0x0,
+};
+
+static final BitmapCharRec ch225 = new BitmapCharRec(9,17,-1,0,11,ch225data);
+
+/* char: 0xe0 */
+
+static final byte[] ch224data = {
+(byte) 0x71,(byte) 0x80,(byte) 0xfb,(byte) 0x0,(byte) 0xc7,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x3b,(byte) 0x0,(byte) 0xf,(byte) 0x0,
+(byte) 0x3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x67,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x4,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0x70,(byte) 0x0,
+(byte) 0x60,(byte) 0x0,
+};
+
+static final BitmapCharRec ch224 = new BitmapCharRec(9,17,-1,0,11,ch224data);
+
+/* char: 0xdf */
+
+static final byte[] ch223data = {
+(byte) 0xe7,(byte) 0x0,(byte) 0x6c,(byte) 0x80,(byte) 0x6c,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x61,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x63,(byte) 0x80,
+(byte) 0x67,(byte) 0x0,(byte) 0x6c,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x33,(byte) 0x0,
+(byte) 0x1e,(byte) 0x0,
+};
+
+static final BitmapCharRec ch223 = new BitmapCharRec(10,17,-1,0,12,ch223data);
+
+/* char: 0xde */
+
+static final byte[] ch222data = {
+(byte) 0xfc,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0x70,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x18,
+(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x70,(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,
+(byte) 0xfc,(byte) 0x0,
+};
+
+static final BitmapCharRec ch222 = new BitmapCharRec(13,17,-1,0,15,ch222data);
+
+/* char: 0xdd */
+
+static final byte[] ch221data = {
+(byte) 0x7,(byte) 0xe0,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x3,(byte) 0xc0,
+(byte) 0x3,(byte) 0x40,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0x20,(byte) 0xc,(byte) 0x30,(byte) 0x1c,(byte) 0x10,(byte) 0x18,(byte) 0x18,(byte) 0x38,(byte) 0x8,(byte) 0x30,(byte) 0xc,
+(byte) 0xfc,(byte) 0x3f,(byte) 0x0,(byte) 0x0,(byte) 0x1,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0x70,(byte) 0x0,(byte) 0x30,
+};
+
+static final BitmapCharRec ch221 = new BitmapCharRec(16,22,0,0,16,ch221data);
+
+/* char: 0xdc */
+
+static final byte[] ch220data = {
+(byte) 0x7,(byte) 0xe0,(byte) 0x1c,(byte) 0x30,(byte) 0x18,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,
+(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,
+(byte) 0xfc,(byte) 0x1f,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x6,(byte) 0x30,(byte) 0x6,(byte) 0x30,
+};
+
+static final BitmapCharRec ch220 = new BitmapCharRec(16,21,-1,0,18,ch220data);
+
+/* char: 0xdb */
+
+static final byte[] ch219data = {
+(byte) 0x7,(byte) 0xe0,(byte) 0x1c,(byte) 0x30,(byte) 0x18,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,
+(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,
+(byte) 0xfc,(byte) 0x1f,(byte) 0x0,(byte) 0x0,(byte) 0x8,(byte) 0x10,(byte) 0x6,(byte) 0x60,(byte) 0x3,(byte) 0xc0,(byte) 0x1,(byte) 0x80,
+};
+
+static final BitmapCharRec ch219 = new BitmapCharRec(16,22,-1,0,18,ch219data);
+
+/* char: 0xda */
+
+static final byte[] ch218data = {
+(byte) 0x7,(byte) 0xe0,(byte) 0x1c,(byte) 0x30,(byte) 0x18,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,
+(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,
+(byte) 0xfc,(byte) 0x1f,(byte) 0x0,(byte) 0x0,(byte) 0x1,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0x70,(byte) 0x0,(byte) 0x30,
+};
+
+static final BitmapCharRec ch218 = new BitmapCharRec(16,22,-1,0,18,ch218data);
+
+/* char: 0xd9 */
+
+static final byte[] ch217data = {
+(byte) 0x7,(byte) 0xe0,(byte) 0x1c,(byte) 0x30,(byte) 0x18,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,
+(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,
+(byte) 0xfc,(byte) 0x1f,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x40,(byte) 0x1,(byte) 0x80,(byte) 0x7,(byte) 0x0,(byte) 0x6,(byte) 0x0,
+};
+
+static final BitmapCharRec ch217 = new BitmapCharRec(16,22,-1,0,18,ch217data);
+
+/* char: 0xd8 */
+
+static final byte[] ch216data = {
+(byte) 0x20,(byte) 0x0,(byte) 0x27,(byte) 0xe0,(byte) 0x1c,(byte) 0x38,(byte) 0x38,(byte) 0x1c,(byte) 0x68,(byte) 0x6,(byte) 0x64,(byte) 0x6,(byte) 0xc2,(byte) 0x3,(byte) 0xc2,(byte) 0x3,
+(byte) 0xc1,(byte) 0x3,(byte) 0xc1,(byte) 0x3,(byte) 0xc0,(byte) 0x83,(byte) 0xc0,(byte) 0x83,(byte) 0xc0,(byte) 0x43,(byte) 0x60,(byte) 0x46,(byte) 0x60,(byte) 0x26,(byte) 0x38,(byte) 0x1c,
+(byte) 0x1c,(byte) 0x38,(byte) 0x7,(byte) 0xe4,(byte) 0x0,(byte) 0x4,
+};
+
+static final BitmapCharRec ch216 = new BitmapCharRec(16,19,-1,1,18,ch216data);
+
+/* char: 0xd7 */
+
+static final byte[] ch215data = {
+(byte) 0x80,(byte) 0x40,(byte) 0xc0,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x33,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0x33,(byte) 0x0,
+(byte) 0x61,(byte) 0x80,(byte) 0xc0,(byte) 0xc0,(byte) 0x80,(byte) 0x40,
+};
+
+static final BitmapCharRec ch215 = new BitmapCharRec(10,11,-2,-1,14,ch215data);
+
+/* char: 0xd6 */
+
+static final byte[] ch214data = {
+(byte) 0x7,(byte) 0xe0,(byte) 0x1c,(byte) 0x38,(byte) 0x38,(byte) 0x1c,(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,
+(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0x38,(byte) 0x1c,(byte) 0x1c,(byte) 0x38,
+(byte) 0x7,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0x60,
+};
+
+static final BitmapCharRec ch214 = new BitmapCharRec(16,21,-1,0,18,ch214data);
+
+/* char: 0xd5 */
+
+static final byte[] ch213data = {
+(byte) 0x7,(byte) 0xe0,(byte) 0x1c,(byte) 0x38,(byte) 0x38,(byte) 0x1c,(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,
+(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0x38,(byte) 0x1c,(byte) 0x1c,(byte) 0x38,
+(byte) 0x7,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x4,(byte) 0xe0,(byte) 0x3,(byte) 0x90,
+};
+
+static final BitmapCharRec ch213 = new BitmapCharRec(16,21,-1,0,18,ch213data);
+
+/* char: 0xd4 */
+
+static final byte[] ch212data = {
+(byte) 0x7,(byte) 0xe0,(byte) 0x1c,(byte) 0x38,(byte) 0x38,(byte) 0x1c,(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,
+(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0x38,(byte) 0x1c,(byte) 0x1c,(byte) 0x38,
+(byte) 0x7,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0x8,(byte) 0x10,(byte) 0x6,(byte) 0x60,(byte) 0x3,(byte) 0xc0,(byte) 0x1,(byte) 0x80,
+};
+
+static final BitmapCharRec ch212 = new BitmapCharRec(16,22,-1,0,18,ch212data);
+
+/* char: 0xd3 */
+
+static final byte[] ch211data = {
+(byte) 0x7,(byte) 0xe0,(byte) 0x1c,(byte) 0x38,(byte) 0x38,(byte) 0x1c,(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,
+(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0x38,(byte) 0x1c,(byte) 0x1c,(byte) 0x38,
+(byte) 0x7,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0x1,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0x70,(byte) 0x0,(byte) 0x30,
+};
+
+static final BitmapCharRec ch211 = new BitmapCharRec(16,22,-1,0,18,ch211data);
+
+/* char: 0xd2 */
+
+static final byte[] ch210data = {
+(byte) 0x7,(byte) 0xe0,(byte) 0x1c,(byte) 0x38,(byte) 0x38,(byte) 0x1c,(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,
+(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0x38,(byte) 0x1c,(byte) 0x1c,(byte) 0x38,
+(byte) 0x7,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x40,(byte) 0x1,(byte) 0x80,(byte) 0x7,(byte) 0x0,(byte) 0x6,(byte) 0x0,
+};
+
+static final BitmapCharRec ch210 = new BitmapCharRec(16,22,-1,0,18,ch210data);
+
+/* char: 0xd1 */
+
+static final byte[] ch209data = {
+(byte) 0xf8,(byte) 0xc,(byte) 0x20,(byte) 0x1c,(byte) 0x20,(byte) 0x1c,(byte) 0x20,(byte) 0x34,(byte) 0x20,(byte) 0x64,(byte) 0x20,(byte) 0x64,(byte) 0x20,(byte) 0xc4,(byte) 0x21,(byte) 0x84,
+(byte) 0x21,(byte) 0x84,(byte) 0x23,(byte) 0x4,(byte) 0x26,(byte) 0x4,(byte) 0x26,(byte) 0x4,(byte) 0x2c,(byte) 0x4,(byte) 0x38,(byte) 0x4,(byte) 0x38,(byte) 0x4,(byte) 0x30,(byte) 0x4,
+(byte) 0xf0,(byte) 0x1f,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x4,(byte) 0xe0,(byte) 0x3,(byte) 0x90,
+};
+
+static final BitmapCharRec ch209 = new BitmapCharRec(16,21,-1,0,18,ch209data);
+
+/* char: 0xd0 */
+
+static final byte[] ch208data = {
+(byte) 0x7f,(byte) 0xe0,(byte) 0x18,(byte) 0x38,(byte) 0x18,(byte) 0x1c,(byte) 0x18,(byte) 0x6,(byte) 0x18,(byte) 0x6,(byte) 0x18,(byte) 0x3,(byte) 0x18,(byte) 0x3,(byte) 0x18,(byte) 0x3,
+(byte) 0xff,(byte) 0x3,(byte) 0x18,(byte) 0x3,(byte) 0x18,(byte) 0x3,(byte) 0x18,(byte) 0x3,(byte) 0x18,(byte) 0x6,(byte) 0x18,(byte) 0x6,(byte) 0x18,(byte) 0x1c,(byte) 0x18,(byte) 0x38,
+(byte) 0x7f,(byte) 0xe0,
+};
+
+static final BitmapCharRec ch208 = new BitmapCharRec(16,17,0,0,17,ch208data);
+
+/* char: 0xcf */
+
+static final byte[] ch207data = {
+(byte) 0xfc,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,
+(byte) 0xfc,(byte) 0x0,(byte) 0x0,(byte) 0xcc,(byte) 0xcc,
+};
+
+static final BitmapCharRec ch207 = new BitmapCharRec(6,21,-1,0,8,ch207data);
+
+/* char: 0xce */
+
+static final byte[] ch206data = {
+(byte) 0x7e,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,
+(byte) 0x7e,(byte) 0x0,(byte) 0x81,(byte) 0x66,(byte) 0x3c,(byte) 0x18,
+};
+
+static final BitmapCharRec ch206 = new BitmapCharRec(8,22,-1,0,8,ch206data);
+
+/* char: 0xcd */
+
+static final byte[] ch205data = {
+(byte) 0xfc,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,
+(byte) 0xfc,(byte) 0x0,(byte) 0x40,(byte) 0x30,(byte) 0x1c,(byte) 0xc,
+};
+
+static final BitmapCharRec ch205 = new BitmapCharRec(6,22,-1,0,8,ch205data);
+
+/* char: 0xcc */
+
+static final byte[] ch204data = {
+(byte) 0xfc,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,
+(byte) 0xfc,(byte) 0x0,(byte) 0x8,(byte) 0x30,(byte) 0xe0,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch204 = new BitmapCharRec(6,22,-1,0,8,ch204data);
+
+/* char: 0xcb */
+
+static final byte[] ch203data = {
+(byte) 0xff,(byte) 0xf8,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x40,
+(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x10,(byte) 0x30,(byte) 0x10,(byte) 0x30,(byte) 0x30,
+(byte) 0xff,(byte) 0xf0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x19,(byte) 0x80,(byte) 0x19,(byte) 0x80,
+};
+
+static final BitmapCharRec ch203 = new BitmapCharRec(13,21,-1,0,15,ch203data);
+
+/* char: 0xca */
+
+static final byte[] ch202data = {
+(byte) 0xff,(byte) 0xf8,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x40,
+(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x10,(byte) 0x30,(byte) 0x10,(byte) 0x30,(byte) 0x30,
+(byte) 0xff,(byte) 0xf0,(byte) 0x0,(byte) 0x0,(byte) 0x10,(byte) 0x20,(byte) 0xc,(byte) 0xc0,(byte) 0x7,(byte) 0x80,(byte) 0x3,(byte) 0x0,
+};
+
+static final BitmapCharRec ch202 = new BitmapCharRec(13,22,-1,0,15,ch202data);
+
+/* char: 0xc9 */
+
+static final byte[] ch201data = {
+(byte) 0xff,(byte) 0xf8,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x40,
+(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x10,(byte) 0x30,(byte) 0x10,(byte) 0x30,(byte) 0x30,
+(byte) 0xff,(byte) 0xf0,(byte) 0x0,(byte) 0x0,(byte) 0x4,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch201 = new BitmapCharRec(13,22,-1,0,15,ch201data);
+
+/* char: 0xc8 */
+
+static final byte[] ch200data = {
+(byte) 0xff,(byte) 0xf8,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x40,
+(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x10,(byte) 0x30,(byte) 0x10,(byte) 0x30,(byte) 0x30,
+(byte) 0xff,(byte) 0xf0,(byte) 0x0,(byte) 0x0,(byte) 0x1,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x1c,(byte) 0x0,(byte) 0x18,(byte) 0x0,
+};
+
+static final BitmapCharRec ch200 = new BitmapCharRec(13,22,-1,0,15,ch200data);
+
+/* char: 0xc7 */
+
+static final byte[] ch199data = {
+(byte) 0x7,(byte) 0x80,(byte) 0xc,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0x0,(byte) 0x1,(byte) 0x0,(byte) 0x7,(byte) 0xe0,(byte) 0x1e,(byte) 0x38,
+(byte) 0x38,(byte) 0x8,(byte) 0x60,(byte) 0x4,(byte) 0x60,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,
+(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0x60,(byte) 0x4,(byte) 0x60,(byte) 0x4,(byte) 0x38,(byte) 0xc,(byte) 0x1c,(byte) 0x3c,(byte) 0x7,(byte) 0xe4,
+};
+
+static final BitmapCharRec ch199 = new BitmapCharRec(14,23,-1,6,16,ch199data);
+
+/* char: 0xc6 */
+
+static final byte[] ch198data = {
+(byte) 0xf9,(byte) 0xff,(byte) 0xf0,(byte) 0x30,(byte) 0x60,(byte) 0x30,(byte) 0x10,(byte) 0x60,(byte) 0x10,(byte) 0x10,(byte) 0x60,(byte) 0x10,(byte) 0x18,(byte) 0x60,(byte) 0x0,(byte) 0x8,
+(byte) 0x60,(byte) 0x0,(byte) 0xf,(byte) 0xe0,(byte) 0x80,(byte) 0xc,(byte) 0x60,(byte) 0x80,(byte) 0x4,(byte) 0x7f,(byte) 0x80,(byte) 0x4,(byte) 0x60,(byte) 0x80,(byte) 0x6,(byte) 0x60,
+(byte) 0x80,(byte) 0x2,(byte) 0x60,(byte) 0x0,(byte) 0x2,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0x60,(byte) 0x20,(byte) 0x1,(byte) 0x60,(byte) 0x20,(byte) 0x1,(byte) 0xe0,(byte) 0x60,
+(byte) 0x3,(byte) 0xff,(byte) 0xe0,
+};
+
+static final BitmapCharRec ch198 = new BitmapCharRec(20,17,0,0,21,ch198data);
+
+/* char: 0xc5 */
+
+static final byte[] ch197data = {
+(byte) 0xfc,(byte) 0x1f,(byte) 0x80,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x10,(byte) 0x6,(byte) 0x0,(byte) 0x10,(byte) 0xc,(byte) 0x0,(byte) 0x18,(byte) 0xc,(byte) 0x0,(byte) 0x8,
+(byte) 0xc,(byte) 0x0,(byte) 0xf,(byte) 0xf8,(byte) 0x0,(byte) 0xc,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x30,(byte) 0x0,(byte) 0x6,(byte) 0x30,
+(byte) 0x0,(byte) 0x2,(byte) 0x30,(byte) 0x0,(byte) 0x2,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,
+(byte) 0x0,(byte) 0x80,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,(byte) 0x2,(byte) 0x20,(byte) 0x0,(byte) 0x2,(byte) 0x20,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,
+};
+
+static final BitmapCharRec ch197 = new BitmapCharRec(17,21,0,0,17,ch197data);
+
+/* char: 0xc4 */
+
+static final byte[] ch196data = {
+(byte) 0xfc,(byte) 0x1f,(byte) 0x80,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x10,(byte) 0x6,(byte) 0x0,(byte) 0x10,(byte) 0xc,(byte) 0x0,(byte) 0x18,(byte) 0xc,(byte) 0x0,(byte) 0x8,
+(byte) 0xc,(byte) 0x0,(byte) 0xf,(byte) 0xf8,(byte) 0x0,(byte) 0xc,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x30,(byte) 0x0,(byte) 0x6,(byte) 0x30,
+(byte) 0x0,(byte) 0x2,(byte) 0x30,(byte) 0x0,(byte) 0x2,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,
+(byte) 0x0,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x6,(byte) 0x30,(byte) 0x0,(byte) 0x6,(byte) 0x30,(byte) 0x0,
+};
+
+static final BitmapCharRec ch196 = new BitmapCharRec(17,21,0,0,17,ch196data);
+
+/* char: 0xc3 */
+
+static final byte[] ch195data = {
+(byte) 0xfc,(byte) 0x1f,(byte) 0x80,(byte) 0x30,(byte) 0x7,(byte) 0x0,(byte) 0x10,(byte) 0x6,(byte) 0x0,(byte) 0x10,(byte) 0xc,(byte) 0x0,(byte) 0x18,(byte) 0xc,(byte) 0x0,(byte) 0x8,
+(byte) 0xc,(byte) 0x0,(byte) 0xf,(byte) 0xf8,(byte) 0x0,(byte) 0xc,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x30,(byte) 0x0,(byte) 0x6,(byte) 0x30,
+(byte) 0x0,(byte) 0x2,(byte) 0x30,(byte) 0x0,(byte) 0x2,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,
+(byte) 0x0,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x4,(byte) 0xe0,(byte) 0x0,(byte) 0x3,(byte) 0x90,(byte) 0x0,
+};
+
+static final BitmapCharRec ch195 = new BitmapCharRec(17,21,0,0,17,ch195data);
+
+/* char: 0xc2 */
+
+static final byte[] ch194data = {
+(byte) 0xfc,(byte) 0x1f,(byte) 0x80,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x10,(byte) 0x6,(byte) 0x0,(byte) 0x10,(byte) 0xc,(byte) 0x0,(byte) 0x18,(byte) 0xc,(byte) 0x0,(byte) 0x8,
+(byte) 0xc,(byte) 0x0,(byte) 0xf,(byte) 0xf8,(byte) 0x0,(byte) 0xc,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x30,(byte) 0x0,(byte) 0x6,(byte) 0x30,
+(byte) 0x0,(byte) 0x2,(byte) 0x30,(byte) 0x0,(byte) 0x2,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,
+(byte) 0x0,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x8,(byte) 0x10,(byte) 0x0,(byte) 0x6,(byte) 0x60,(byte) 0x0,(byte) 0x3,(byte) 0xc0,(byte) 0x0,(byte) 0x1,
+(byte) 0x80,(byte) 0x0,
+};
+
+static final BitmapCharRec ch194 = new BitmapCharRec(17,22,0,0,17,ch194data);
+
+/* char: 0xc1 */
+
+static final byte[] ch193data = {
+(byte) 0xfc,(byte) 0x1f,(byte) 0x80,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x10,(byte) 0x6,(byte) 0x0,(byte) 0x10,(byte) 0xc,(byte) 0x0,(byte) 0x18,(byte) 0xc,(byte) 0x0,(byte) 0x8,
+(byte) 0xc,(byte) 0x0,(byte) 0xf,(byte) 0xf8,(byte) 0x0,(byte) 0xc,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x30,(byte) 0x0,(byte) 0x6,(byte) 0x30,
+(byte) 0x0,(byte) 0x2,(byte) 0x30,(byte) 0x0,(byte) 0x2,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,
+(byte) 0x0,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x1,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x70,(byte) 0x0,(byte) 0x0,
+(byte) 0x30,(byte) 0x0,
+};
+
+static final BitmapCharRec ch193 = new BitmapCharRec(17,22,0,0,17,ch193data);
+
+/* char: 0xc0 */
+
+static final byte[] ch192data = {
+(byte) 0xfc,(byte) 0x1f,(byte) 0x80,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x10,(byte) 0x6,(byte) 0x0,(byte) 0x10,(byte) 0xc,(byte) 0x0,(byte) 0x18,(byte) 0xc,(byte) 0x0,(byte) 0x8,
+(byte) 0xc,(byte) 0x0,(byte) 0xf,(byte) 0xf8,(byte) 0x0,(byte) 0xc,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x30,(byte) 0x0,(byte) 0x6,(byte) 0x30,
+(byte) 0x0,(byte) 0x2,(byte) 0x30,(byte) 0x0,(byte) 0x2,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,
+(byte) 0x0,(byte) 0x80,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x20,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0x3,(byte) 0x80,(byte) 0x0,(byte) 0x3,
+(byte) 0x0,(byte) 0x0,
+};
+
+static final BitmapCharRec ch192 = new BitmapCharRec(17,22,0,0,17,ch192data);
+
+/* char: 0xbf */
+
+static final byte[] ch191data = {
+(byte) 0x3e,(byte) 0x63,(byte) 0xc1,(byte) 0xc3,(byte) 0xc3,(byte) 0xe0,(byte) 0x70,(byte) 0x30,(byte) 0x38,(byte) 0x18,(byte) 0x18,(byte) 0x8,(byte) 0x8,(byte) 0x0,(byte) 0x0,(byte) 0xc,
+(byte) 0xc,
+};
+
+static final BitmapCharRec ch191 = new BitmapCharRec(8,17,-1,5,11,ch191data);
+
+/* char: 0xbe */
+
+static final byte[] ch190data = {
+(byte) 0x18,(byte) 0x2,(byte) 0x0,(byte) 0x8,(byte) 0x2,(byte) 0x0,(byte) 0xc,(byte) 0x7f,(byte) 0x80,(byte) 0x4,(byte) 0x22,(byte) 0x0,(byte) 0x6,(byte) 0x32,(byte) 0x0,(byte) 0x3,
+(byte) 0x12,(byte) 0x0,(byte) 0x1,(byte) 0xa,(byte) 0x0,(byte) 0x71,(byte) 0x8e,(byte) 0x0,(byte) 0x88,(byte) 0x86,(byte) 0x0,(byte) 0x8c,(byte) 0xc2,(byte) 0x0,(byte) 0xc,(byte) 0x60,
+(byte) 0x0,(byte) 0x8,(byte) 0x20,(byte) 0x0,(byte) 0x30,(byte) 0x30,(byte) 0x0,(byte) 0x8,(byte) 0x10,(byte) 0x0,(byte) 0x8c,(byte) 0x18,(byte) 0x0,(byte) 0x4c,(byte) 0xc,(byte) 0x0,
+(byte) 0x38,(byte) 0x4,(byte) 0x0,
+};
+
+static final BitmapCharRec ch190 = new BitmapCharRec(17,17,0,0,18,ch190data);
+
+/* char: 0xbd */
+
+static final byte[] ch189data = {
+(byte) 0x30,(byte) 0x7e,(byte) 0x10,(byte) 0x22,(byte) 0x18,(byte) 0x10,(byte) 0x8,(byte) 0x18,(byte) 0xc,(byte) 0x8,(byte) 0x6,(byte) 0x4,(byte) 0x2,(byte) 0x6,(byte) 0xfb,(byte) 0x46,
+(byte) 0x21,(byte) 0x26,(byte) 0x21,(byte) 0x9c,(byte) 0x20,(byte) 0xc0,(byte) 0x20,(byte) 0x40,(byte) 0x20,(byte) 0x60,(byte) 0x20,(byte) 0x20,(byte) 0xa0,(byte) 0x30,(byte) 0x60,(byte) 0x18,
+(byte) 0x20,(byte) 0x8,
+};
+
+static final BitmapCharRec ch189 = new BitmapCharRec(15,17,-1,0,18,ch189data);
+
+/* char: 0xbc */
+
+static final byte[] ch188data = {
+(byte) 0x30,(byte) 0x4,(byte) 0x10,(byte) 0x4,(byte) 0x18,(byte) 0xff,(byte) 0x8,(byte) 0x44,(byte) 0xc,(byte) 0x64,(byte) 0x6,(byte) 0x24,(byte) 0x2,(byte) 0x14,(byte) 0xfb,(byte) 0x1c,
+(byte) 0x21,(byte) 0xc,(byte) 0x21,(byte) 0x84,(byte) 0x20,(byte) 0xc0,(byte) 0x20,(byte) 0x40,(byte) 0x20,(byte) 0x60,(byte) 0x20,(byte) 0x20,(byte) 0xa0,(byte) 0x30,(byte) 0x60,(byte) 0x18,
+(byte) 0x20,(byte) 0x8,
+};
+
+static final BitmapCharRec ch188 = new BitmapCharRec(16,17,-1,0,18,ch188data);
+
+/* char: 0xbb */
+
+static final byte[] ch187data = {
+(byte) 0x88,(byte) 0x0,(byte) 0xcc,(byte) 0x0,(byte) 0x66,(byte) 0x0,(byte) 0x33,(byte) 0x0,(byte) 0x19,(byte) 0x80,(byte) 0x19,(byte) 0x80,(byte) 0x33,(byte) 0x0,(byte) 0x66,(byte) 0x0,
+(byte) 0xcc,(byte) 0x0,(byte) 0x88,(byte) 0x0,
+};
+
+static final BitmapCharRec ch187 = new BitmapCharRec(9,10,-2,-1,12,ch187data);
+
+/* char: 0xba */
+
+static final byte[] ch186data = {
+(byte) 0xfc,(byte) 0x0,(byte) 0x78,(byte) 0xcc,(byte) 0xcc,(byte) 0xcc,(byte) 0xcc,(byte) 0xcc,(byte) 0x78,
+};
+
+static final BitmapCharRec ch186 = new BitmapCharRec(6,9,-1,-8,8,ch186data);
+
+/* char: 0xb9 */
+
+static final byte[] ch185data = {
+(byte) 0xf8,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0x20,(byte) 0xa0,(byte) 0x60,(byte) 0x20,
+};
+
+static final BitmapCharRec ch185 = new BitmapCharRec(5,10,-1,-7,7,ch185data);
+
+/* char: 0xb8 */
+
+static final byte[] ch184data = {
+(byte) 0x78,(byte) 0xcc,(byte) 0xc,(byte) 0x3c,(byte) 0x30,(byte) 0x10,
+};
+
+static final BitmapCharRec ch184 = new BitmapCharRec(6,6,-1,6,8,ch184data);
+
+/* char: 0xb7 */
+
+static final byte[] ch183data = {
+(byte) 0xc0,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch183 = new BitmapCharRec(2,2,-2,-6,6,ch183data);
+
+/* char: 0xb6 */
+
+static final byte[] ch182data = {
+(byte) 0x9,(byte) 0x0,(byte) 0x9,(byte) 0x0,(byte) 0x9,(byte) 0x0,(byte) 0x9,(byte) 0x0,(byte) 0x9,(byte) 0x0,(byte) 0x9,(byte) 0x0,(byte) 0x9,(byte) 0x0,(byte) 0x9,(byte) 0x0,
+(byte) 0x9,(byte) 0x0,(byte) 0x9,(byte) 0x0,(byte) 0x9,(byte) 0x0,(byte) 0x19,(byte) 0x0,(byte) 0x39,(byte) 0x0,(byte) 0x79,(byte) 0x0,(byte) 0x79,(byte) 0x0,(byte) 0xf9,(byte) 0x0,
+(byte) 0xf9,(byte) 0x0,(byte) 0xf9,(byte) 0x0,(byte) 0x79,(byte) 0x0,(byte) 0x79,(byte) 0x0,(byte) 0x39,(byte) 0x0,(byte) 0x1f,(byte) 0x80,
+};
+
+static final BitmapCharRec ch182 = new BitmapCharRec(9,22,-1,5,11,ch182data);
+
+/* char: 0xb5 */
+
+static final byte[] ch181data = {
+(byte) 0x40,(byte) 0x0,(byte) 0xe0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0x40,(byte) 0x0,(byte) 0x40,(byte) 0x0,(byte) 0x5c,(byte) 0xe0,(byte) 0x7e,(byte) 0xc0,(byte) 0x71,(byte) 0xc0,
+(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,
+(byte) 0xe1,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch181 = new BitmapCharRec(11,17,-1,5,13,ch181data);
+
+/* char: 0xb4 */
+
+static final byte[] ch180data = {
+(byte) 0x80,(byte) 0x60,(byte) 0x38,(byte) 0x18,
+};
+
+static final BitmapCharRec ch180 = new BitmapCharRec(5,4,-2,-13,8,ch180data);
+
+/* char: 0xb3 */
+
+static final byte[] ch179data = {
+(byte) 0x70,(byte) 0x88,(byte) 0x8c,(byte) 0xc,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x8c,(byte) 0x4c,(byte) 0x38,
+};
+
+static final BitmapCharRec ch179 = new BitmapCharRec(6,10,0,-7,7,ch179data);
+
+/* char: 0xb2 */
+
+static final byte[] ch178data = {
+(byte) 0xfc,(byte) 0x44,(byte) 0x20,(byte) 0x30,(byte) 0x10,(byte) 0x8,(byte) 0xc,(byte) 0x8c,(byte) 0x4c,(byte) 0x38,
+};
+
+static final BitmapCharRec ch178 = new BitmapCharRec(6,10,0,-7,7,ch178data);
+
+/* char: 0xb1 */
+
+static final byte[] ch177data = {
+(byte) 0xff,(byte) 0xf0,(byte) 0xff,(byte) 0xf0,(byte) 0x0,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,
+(byte) 0xff,(byte) 0xf0,(byte) 0xff,(byte) 0xf0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,
+};
+
+static final BitmapCharRec ch177 = new BitmapCharRec(12,15,-1,0,14,ch177data);
+
+/* char: 0xb0 */
+
+static final byte[] ch176data = {
+(byte) 0x38,(byte) 0x44,(byte) 0x82,(byte) 0x82,(byte) 0x82,(byte) 0x44,(byte) 0x38,
+};
+
+static final BitmapCharRec ch176 = new BitmapCharRec(7,7,-1,-10,9,ch176data);
+
+/* char: 0xaf */
+
+static final byte[] ch175data = {
+(byte) 0xfc,(byte) 0xfc,
+};
+
+static final BitmapCharRec ch175 = new BitmapCharRec(6,2,-1,-14,8,ch175data);
+
+/* char: 0xae */
+
+static final byte[] ch174data = {
+(byte) 0x7,(byte) 0xf0,(byte) 0x0,(byte) 0x1c,(byte) 0x1c,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x60,(byte) 0x3,(byte) 0x0,(byte) 0x47,(byte) 0x19,(byte) 0x0,(byte) 0xc2,
+(byte) 0x31,(byte) 0x80,(byte) 0x82,(byte) 0x20,(byte) 0x80,(byte) 0x82,(byte) 0x40,(byte) 0x80,(byte) 0x83,(byte) 0xe0,(byte) 0x80,(byte) 0x82,(byte) 0x30,(byte) 0x80,(byte) 0x82,(byte) 0x10,
+(byte) 0x80,(byte) 0xc2,(byte) 0x11,(byte) 0x80,(byte) 0x42,(byte) 0x31,(byte) 0x0,(byte) 0x67,(byte) 0xe3,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x1c,(byte) 0x1c,(byte) 0x0,
+(byte) 0x7,(byte) 0xf0,(byte) 0x0,
+};
+
+static final BitmapCharRec ch174 = new BitmapCharRec(17,17,-1,0,19,ch174data);
+
+/* char: 0xad */
+
+static final byte[] ch173data = {
+(byte) 0xfe,(byte) 0xfe,
+};
+
+static final BitmapCharRec ch173 = new BitmapCharRec(7,2,-1,-5,9,ch173data);
+
+/* char: 0xac */
+
+static final byte[] ch172data = {
+(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0xff,(byte) 0xf0,(byte) 0xff,(byte) 0xf0,
+};
+
+static final BitmapCharRec ch172 = new BitmapCharRec(12,7,-1,-3,14,ch172data);
+
+/* char: 0xab */
+
+static final byte[] ch171data = {
+(byte) 0x8,(byte) 0x80,(byte) 0x19,(byte) 0x80,(byte) 0x33,(byte) 0x0,(byte) 0x66,(byte) 0x0,(byte) 0xcc,(byte) 0x0,(byte) 0xcc,(byte) 0x0,(byte) 0x66,(byte) 0x0,(byte) 0x33,(byte) 0x0,
+(byte) 0x19,(byte) 0x80,(byte) 0x8,(byte) 0x80,
+};
+
+static final BitmapCharRec ch171 = new BitmapCharRec(9,10,-2,-1,13,ch171data);
+
+/* char: 0xaa */
+
+static final byte[] ch170data = {
+(byte) 0x7e,(byte) 0x0,(byte) 0x76,(byte) 0xcc,(byte) 0xcc,(byte) 0x7c,(byte) 0xc,(byte) 0xcc,(byte) 0x78,
+};
+
+static final BitmapCharRec ch170 = new BitmapCharRec(7,9,0,-8,8,ch170data);
+
+/* char: 0xa9 */
+
+static final byte[] ch169data = {
+(byte) 0x7,(byte) 0xf0,(byte) 0x0,(byte) 0x1c,(byte) 0x1c,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x61,(byte) 0xc3,(byte) 0x0,(byte) 0x47,(byte) 0x71,(byte) 0x0,(byte) 0xc4,
+(byte) 0x19,(byte) 0x80,(byte) 0x8c,(byte) 0x0,(byte) 0x80,(byte) 0x88,(byte) 0x0,(byte) 0x80,(byte) 0x88,(byte) 0x0,(byte) 0x80,(byte) 0x88,(byte) 0x0,(byte) 0x80,(byte) 0x8c,(byte) 0x0,
+(byte) 0x80,(byte) 0xc4,(byte) 0x19,(byte) 0x80,(byte) 0x47,(byte) 0x31,(byte) 0x0,(byte) 0x61,(byte) 0xe3,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x1c,(byte) 0x1c,(byte) 0x0,
+(byte) 0x7,(byte) 0xf0,(byte) 0x0,
+};
+
+static final BitmapCharRec ch169 = new BitmapCharRec(17,17,-1,0,19,ch169data);
+
+/* char: 0xa8 */
+
+static final byte[] ch168data = {
+(byte) 0xcc,(byte) 0xcc,
+};
+
+static final BitmapCharRec ch168 = new BitmapCharRec(6,2,-1,-14,8,ch168data);
+
+/* char: 0xa7 */
+
+static final byte[] ch167data = {
+(byte) 0x38,(byte) 0x64,(byte) 0x62,(byte) 0x6,(byte) 0xe,(byte) 0x1c,(byte) 0x38,(byte) 0x74,(byte) 0xe2,(byte) 0xc3,(byte) 0x83,(byte) 0x87,(byte) 0x4e,(byte) 0x3c,(byte) 0x38,(byte) 0x70,
+(byte) 0x60,(byte) 0x46,(byte) 0x26,(byte) 0x1c,
+};
+
+static final BitmapCharRec ch167 = new BitmapCharRec(8,20,-2,2,12,ch167data);
+
+/* char: 0xa6 */
+
+static final byte[] ch166data = {
+(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,
+(byte) 0xc0,
+};
+
+static final BitmapCharRec ch166 = new BitmapCharRec(2,17,-2,0,6,ch166data);
+
+/* char: 0xa5 */
+
+static final byte[] ch165data = {
+(byte) 0xf,(byte) 0xc0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x1f,(byte) 0xe0,(byte) 0x3,(byte) 0x0,(byte) 0x1f,(byte) 0xe0,
+(byte) 0x3,(byte) 0x0,(byte) 0x7,(byte) 0x80,(byte) 0xc,(byte) 0x80,(byte) 0xc,(byte) 0xc0,(byte) 0x18,(byte) 0x40,(byte) 0x18,(byte) 0x60,(byte) 0x30,(byte) 0x20,(byte) 0x70,(byte) 0x30,
+(byte) 0xf8,(byte) 0x7c,
+};
+
+static final BitmapCharRec ch165 = new BitmapCharRec(14,17,0,0,14,ch165data);
+
+/* char: 0xa4 */
+
+static final byte[] ch164data = {
+(byte) 0xc0,(byte) 0x60,(byte) 0xee,(byte) 0xe0,(byte) 0x7f,(byte) 0xc0,(byte) 0x31,(byte) 0x80,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,
+(byte) 0x31,(byte) 0x80,(byte) 0x7f,(byte) 0xc0,(byte) 0xee,(byte) 0xe0,(byte) 0xc0,(byte) 0x60,
+};
+
+static final BitmapCharRec ch164 = new BitmapCharRec(11,12,-1,-3,13,ch164data);
+
+/* char: 0xa3 */
+
+static final byte[] ch163data = {
+(byte) 0xe7,(byte) 0x80,(byte) 0xbe,(byte) 0xc0,(byte) 0x78,(byte) 0x40,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,
+(byte) 0x30,(byte) 0x0,(byte) 0xfc,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x31,(byte) 0x80,(byte) 0x19,(byte) 0x80,
+(byte) 0xf,(byte) 0x0,
+};
+
+static final BitmapCharRec ch163 = new BitmapCharRec(10,17,-1,0,12,ch163data);
+
+/* char: 0xa2 */
+
+static final byte[] ch162data = {
+(byte) 0x40,(byte) 0x0,(byte) 0x40,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x70,(byte) 0x80,(byte) 0xd0,(byte) 0x0,(byte) 0xc8,(byte) 0x0,(byte) 0xc8,(byte) 0x0,
+(byte) 0xc8,(byte) 0x0,(byte) 0xc4,(byte) 0x0,(byte) 0xc4,(byte) 0x0,(byte) 0x43,(byte) 0x80,(byte) 0x63,(byte) 0x80,(byte) 0x1f,(byte) 0x0,(byte) 0x1,(byte) 0x0,(byte) 0x1,(byte) 0x0,
+};
+
+static final BitmapCharRec ch162 = new BitmapCharRec(9,16,-1,2,12,ch162data);
+
+/* char: 0xa1 */
+
+static final byte[] ch161data = {
+(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xc0,
+(byte) 0xc0,
+};
+
+static final BitmapCharRec ch161 = new BitmapCharRec(2,17,-4,5,8,ch161data);
+
+/* char: 0xa0 */
+
+static final BitmapCharRec ch160 = new BitmapCharRec(0,0,0,0,6,null);
+
+/* char: 0x7e '~' */
+
+static final byte[] ch126data = {
+(byte) 0x83,(byte) 0x80,(byte) 0xc7,(byte) 0xc0,(byte) 0x7c,(byte) 0x60,(byte) 0x38,(byte) 0x20,
+};
+
+static final BitmapCharRec ch126 = new BitmapCharRec(11,4,-1,-5,13,ch126data);
+
+/* char: 0x7d '}' */
+
+static final byte[] ch125data = {
+(byte) 0xe0,(byte) 0x30,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x8,(byte) 0xc,(byte) 0x4,(byte) 0x3,(byte) 0x4,(byte) 0xc,(byte) 0x8,(byte) 0x18,
+(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x30,(byte) 0xe0,
+};
+
+static final BitmapCharRec ch125 = new BitmapCharRec(8,22,-1,5,10,ch125data);
+
+/* char: 0x7c '|' */
+
+static final byte[] ch124data = {
+(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,
+(byte) 0xc0,
+};
+
+static final BitmapCharRec ch124 = new BitmapCharRec(2,17,-2,0,6,ch124data);
+
+/* char: 0x7b '{' */
+
+static final byte[] ch123data = {
+(byte) 0x7,(byte) 0xc,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x10,(byte) 0x30,(byte) 0x20,(byte) 0xc0,(byte) 0x20,(byte) 0x30,(byte) 0x10,(byte) 0x18,
+(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0xc,(byte) 0x7,
+};
+
+static final BitmapCharRec ch123 = new BitmapCharRec(8,22,-1,5,10,ch123data);
+
+/* char: 0x7a 'z' */
+
+static final byte[] ch122data = {
+(byte) 0xff,(byte) 0xc3,(byte) 0x61,(byte) 0x70,(byte) 0x30,(byte) 0x38,(byte) 0x18,(byte) 0x1c,(byte) 0xe,(byte) 0x86,(byte) 0xc3,(byte) 0xff,
+};
+
+static final BitmapCharRec ch122 = new BitmapCharRec(8,12,-1,0,10,ch122data);
+
+/* char: 0x79 'y' */
+
+static final byte[] ch121data = {
+(byte) 0xe0,(byte) 0x0,(byte) 0xf0,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0x8,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x4,(byte) 0x0,(byte) 0xe,(byte) 0x0,(byte) 0xe,(byte) 0x0,
+(byte) 0x1a,(byte) 0x0,(byte) 0x19,(byte) 0x0,(byte) 0x19,(byte) 0x0,(byte) 0x31,(byte) 0x0,(byte) 0x30,(byte) 0x80,(byte) 0x30,(byte) 0x80,(byte) 0x60,(byte) 0x80,(byte) 0x60,(byte) 0xc0,
+(byte) 0xf1,(byte) 0xe0,
+};
+
+static final BitmapCharRec ch121 = new BitmapCharRec(11,17,0,5,11,ch121data);
+
+/* char: 0x78 'x' */
+
+static final byte[] ch120data = {
+(byte) 0xf1,(byte) 0xe0,(byte) 0x60,(byte) 0xc0,(byte) 0x21,(byte) 0x80,(byte) 0x33,(byte) 0x80,(byte) 0x1b,(byte) 0x0,(byte) 0xe,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x1a,(byte) 0x0,
+(byte) 0x39,(byte) 0x0,(byte) 0x31,(byte) 0x80,(byte) 0x60,(byte) 0xc0,(byte) 0xf1,(byte) 0xe0,
+};
+
+static final BitmapCharRec ch120 = new BitmapCharRec(11,12,-1,0,13,ch120data);
+
+/* char: 0x77 'w' */
+
+static final byte[] ch119data = {
+(byte) 0x4,(byte) 0x10,(byte) 0x0,(byte) 0xe,(byte) 0x38,(byte) 0x0,(byte) 0xe,(byte) 0x38,(byte) 0x0,(byte) 0x1a,(byte) 0x28,(byte) 0x0,(byte) 0x1a,(byte) 0x64,(byte) 0x0,(byte) 0x19,
+(byte) 0x64,(byte) 0x0,(byte) 0x31,(byte) 0x64,(byte) 0x0,(byte) 0x30,(byte) 0xc2,(byte) 0x0,(byte) 0x30,(byte) 0xc2,(byte) 0x0,(byte) 0x60,(byte) 0xc2,(byte) 0x0,(byte) 0x60,(byte) 0xc3,
+(byte) 0x0,(byte) 0xf1,(byte) 0xe7,(byte) 0x80,
+};
+
+static final BitmapCharRec ch119 = new BitmapCharRec(17,12,0,0,17,ch119data);
+
+/* char: 0x76 'v' */
+
+static final byte[] ch118data = {
+(byte) 0x4,(byte) 0x0,(byte) 0xe,(byte) 0x0,(byte) 0xe,(byte) 0x0,(byte) 0x1a,(byte) 0x0,(byte) 0x19,(byte) 0x0,(byte) 0x19,(byte) 0x0,(byte) 0x31,(byte) 0x0,(byte) 0x30,(byte) 0x80,
+(byte) 0x30,(byte) 0x80,(byte) 0x60,(byte) 0x80,(byte) 0x60,(byte) 0xc0,(byte) 0xf1,(byte) 0xe0,
+};
+
+static final BitmapCharRec ch118 = new BitmapCharRec(11,12,0,0,11,ch118data);
+
+/* char: 0x75 'u' */
+
+static final byte[] ch117data = {
+(byte) 0x1c,(byte) 0xe0,(byte) 0x3e,(byte) 0xc0,(byte) 0x71,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,
+(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0xe1,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch117 = new BitmapCharRec(11,12,-1,0,13,ch117data);
+
+/* char: 0x74 't' */
+
+static final byte[] ch116data = {
+(byte) 0x1c,(byte) 0x32,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0xfe,(byte) 0x70,(byte) 0x30,(byte) 0x10,
+};
+
+static final BitmapCharRec ch116 = new BitmapCharRec(7,15,0,0,7,ch116data);
+
+/* char: 0x73 's' */
+
+static final byte[] ch115data = {
+(byte) 0xf8,(byte) 0xc6,(byte) 0x83,(byte) 0x3,(byte) 0x7,(byte) 0x1e,(byte) 0x7c,(byte) 0x70,(byte) 0xe0,(byte) 0xc2,(byte) 0x66,(byte) 0x3e,
+};
+
+static final BitmapCharRec ch115 = new BitmapCharRec(8,12,-1,0,10,ch115data);
+
+/* char: 0x72 'r' */
+
+static final byte[] ch114data = {
+(byte) 0xf0,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x76,(byte) 0x6e,(byte) 0xe6,
+};
+
+static final BitmapCharRec ch114 = new BitmapCharRec(7,12,-1,0,8,ch114data);
+
+/* char: 0x71 'q' */
+
+static final byte[] ch113data = {
+(byte) 0x3,(byte) 0xc0,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1d,(byte) 0x80,(byte) 0x73,(byte) 0x80,(byte) 0x61,(byte) 0x80,
+(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x73,(byte) 0x80,
+(byte) 0x1d,(byte) 0x80,
+};
+
+static final BitmapCharRec ch113 = new BitmapCharRec(10,17,-1,5,12,ch113data);
+
+/* char: 0x70 'p' */
+
+static final byte[] ch112data = {
+(byte) 0xf0,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x6e,(byte) 0x0,(byte) 0x73,(byte) 0x80,(byte) 0x61,(byte) 0x80,
+(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x73,(byte) 0x80,
+(byte) 0xee,(byte) 0x0,
+};
+
+static final BitmapCharRec ch112 = new BitmapCharRec(10,17,-1,5,12,ch112data);
+
+/* char: 0x6f 'o' */
+
+static final byte[] ch111data = {
+(byte) 0x1e,(byte) 0x0,(byte) 0x73,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,
+(byte) 0xc0,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x73,(byte) 0x80,(byte) 0x1e,(byte) 0x0,
+};
+
+static final BitmapCharRec ch111 = new BitmapCharRec(10,12,-1,0,12,ch111data);
+
+/* char: 0x6e 'n' */
+
+static final byte[] ch110data = {
+(byte) 0xf1,(byte) 0xe0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,
+(byte) 0x60,(byte) 0xc0,(byte) 0x71,(byte) 0xc0,(byte) 0x6f,(byte) 0x80,(byte) 0xe7,(byte) 0x0,
+};
+
+static final BitmapCharRec ch110 = new BitmapCharRec(11,12,-1,0,13,ch110data);
+
+/* char: 0x6d 'm' */
+
+static final byte[] ch109data = {
+(byte) 0xf1,(byte) 0xe3,(byte) 0xc0,(byte) 0x60,(byte) 0xc1,(byte) 0x80,(byte) 0x60,(byte) 0xc1,(byte) 0x80,(byte) 0x60,(byte) 0xc1,(byte) 0x80,(byte) 0x60,(byte) 0xc1,(byte) 0x80,(byte) 0x60,
+(byte) 0xc1,(byte) 0x80,(byte) 0x60,(byte) 0xc1,(byte) 0x80,(byte) 0x60,(byte) 0xc1,(byte) 0x80,(byte) 0x60,(byte) 0xc1,(byte) 0x80,(byte) 0x71,(byte) 0xe3,(byte) 0x80,(byte) 0x6f,(byte) 0x9f,
+(byte) 0x0,(byte) 0xe7,(byte) 0xe,(byte) 0x0,
+};
+
+static final BitmapCharRec ch109 = new BitmapCharRec(18,12,-1,0,20,ch109data);
+
+/* char: 0x6c 'l' */
+
+static final byte[] ch108data = {
+(byte) 0xf0,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,
+(byte) 0xe0,
+};
+
+static final BitmapCharRec ch108 = new BitmapCharRec(4,17,-1,0,6,ch108data);
+
+/* char: 0x6b 'k' */
+
+static final byte[] ch107data = {
+(byte) 0xf3,(byte) 0xe0,(byte) 0x61,(byte) 0xc0,(byte) 0x63,(byte) 0x80,(byte) 0x67,(byte) 0x0,(byte) 0x6e,(byte) 0x0,(byte) 0x6c,(byte) 0x0,(byte) 0x78,(byte) 0x0,(byte) 0x68,(byte) 0x0,
+(byte) 0x64,(byte) 0x0,(byte) 0x66,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x67,(byte) 0xc0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,
+(byte) 0xe0,(byte) 0x0,
+};
+
+static final BitmapCharRec ch107 = new BitmapCharRec(11,17,-1,0,12,ch107data);
+
+/* char: 0x6a 'j' */
+
+static final byte[] ch106data = {
+(byte) 0xc0,(byte) 0xe0,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,
+(byte) 0x70,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x30,(byte) 0x30,
+};
+
+static final BitmapCharRec ch106 = new BitmapCharRec(4,22,0,5,6,ch106data);
+
+/* char: 0x69 'i' */
+
+static final byte[] ch105data = {
+(byte) 0xf0,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0x60,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x60,
+(byte) 0x60,
+};
+
+static final BitmapCharRec ch105 = new BitmapCharRec(4,17,-1,0,6,ch105data);
+
+/* char: 0x68 'h' */
+
+static final byte[] ch104data = {
+(byte) 0xf1,(byte) 0xe0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,
+(byte) 0x60,(byte) 0xc0,(byte) 0x71,(byte) 0xc0,(byte) 0x6f,(byte) 0x80,(byte) 0x67,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,
+(byte) 0xe0,(byte) 0x0,
+};
+
+static final BitmapCharRec ch104 = new BitmapCharRec(11,17,-1,0,13,ch104data);
+
+/* char: 0x67 'g' */
+
+static final byte[] ch103data = {
+(byte) 0x3f,(byte) 0x0,(byte) 0xf1,(byte) 0xc0,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x20,(byte) 0x60,(byte) 0x60,(byte) 0x3f,(byte) 0xc0,(byte) 0x7f,(byte) 0x0,(byte) 0x60,(byte) 0x0,
+(byte) 0x30,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x33,(byte) 0x0,(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x33,(byte) 0x0,
+(byte) 0x1f,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch103 = new BitmapCharRec(11,17,-1,5,12,ch103data);
+
+/* char: 0x66 'f' */
+
+static final byte[] ch102data = {
+(byte) 0x78,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0xfe,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x16,
+(byte) 0xe,
+};
+
+static final BitmapCharRec ch102 = new BitmapCharRec(7,17,0,0,7,ch102data);
+
+/* char: 0x65 'e' */
+
+static final byte[] ch101data = {
+(byte) 0x1e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x70,(byte) 0x80,(byte) 0xe0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xff,(byte) 0x80,
+(byte) 0xc1,(byte) 0x80,(byte) 0x41,(byte) 0x80,(byte) 0x63,(byte) 0x0,(byte) 0x1e,(byte) 0x0,
+};
+
+static final BitmapCharRec ch101 = new BitmapCharRec(9,12,-1,0,11,ch101data);
+
+/* char: 0x64 'd' */
+
+static final byte[] ch100data = {
+(byte) 0x1e,(byte) 0xc0,(byte) 0x73,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0xc1,(byte) 0x80,
+(byte) 0xc1,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x73,(byte) 0x80,(byte) 0x1d,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,
+(byte) 0x3,(byte) 0x80,
+};
+
+static final BitmapCharRec ch100 = new BitmapCharRec(10,17,-1,0,12,ch100data);
+
+/* char: 0x63 'c' */
+
+static final byte[] ch99data = {
+(byte) 0x1e,(byte) 0x0,(byte) 0x7f,(byte) 0x0,(byte) 0x70,(byte) 0x80,(byte) 0xe0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,
+(byte) 0xc0,(byte) 0x0,(byte) 0x41,(byte) 0x80,(byte) 0x63,(byte) 0x80,(byte) 0x1f,(byte) 0x0,
+};
+
+static final BitmapCharRec ch99 = new BitmapCharRec(9,12,-1,0,11,ch99data);
+
+/* char: 0x62 'b' */
+
+static final byte[] ch98data = {
+(byte) 0x5e,(byte) 0x0,(byte) 0x73,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,(byte) 0x60,(byte) 0xc0,
+(byte) 0x60,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x73,(byte) 0x80,(byte) 0x6e,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,
+(byte) 0xe0,(byte) 0x0,
+};
+
+static final BitmapCharRec ch98 = new BitmapCharRec(10,17,-1,0,12,ch98data);
+
+/* char: 0x61 'a' */
+
+static final byte[] ch97data = {
+(byte) 0x71,(byte) 0x80,(byte) 0xfb,(byte) 0x0,(byte) 0xc7,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x3b,(byte) 0x0,(byte) 0xf,(byte) 0x0,
+(byte) 0x3,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x67,(byte) 0x0,(byte) 0x3e,(byte) 0x0,
+};
+
+static final BitmapCharRec ch97 = new BitmapCharRec(9,12,-1,0,11,ch97data);
+
+/* char: 0x60 '`' */
+
+static final byte[] ch96data = {
+(byte) 0x60,(byte) 0xe0,(byte) 0x80,(byte) 0xc0,(byte) 0x60,
+};
+
+static final BitmapCharRec ch96 = new BitmapCharRec(3,5,-2,-12,7,ch96data);
+
+/* char: 0x5f '_' */
+
+static final byte[] ch95data = {
+(byte) 0xff,(byte) 0xf8,(byte) 0xff,(byte) 0xf8,
+};
+
+static final BitmapCharRec ch95 = new BitmapCharRec(13,2,0,5,13,ch95data);
+
+/* char: 0x5e '^' */
+
+static final byte[] ch94data = {
+(byte) 0x80,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0x41,(byte) 0x0,(byte) 0x63,(byte) 0x0,(byte) 0x22,(byte) 0x0,(byte) 0x36,(byte) 0x0,(byte) 0x14,(byte) 0x0,(byte) 0x1c,(byte) 0x0,
+(byte) 0x8,(byte) 0x0,
+};
+
+static final BitmapCharRec ch94 = new BitmapCharRec(9,9,-1,-8,11,ch94data);
+
+/* char: 0x5d ']' */
+
+static final byte[] ch93data = {
+(byte) 0xf8,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,
+(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0xf8,
+};
+
+static final BitmapCharRec ch93 = new BitmapCharRec(5,21,-1,4,8,ch93data);
+
+/* char: 0x5c '\' */
+
+static final byte[] ch92data = {
+(byte) 0x6,(byte) 0x6,(byte) 0x4,(byte) 0xc,(byte) 0xc,(byte) 0x8,(byte) 0x18,(byte) 0x18,(byte) 0x10,(byte) 0x30,(byte) 0x30,(byte) 0x20,(byte) 0x60,(byte) 0x60,(byte) 0x40,(byte) 0xc0,
+(byte) 0xc0,
+};
+
+static final BitmapCharRec ch92 = new BitmapCharRec(7,17,0,0,7,ch92data);
+
+/* char: 0x5b '[' */
+
+static final byte[] ch91data = {
+(byte) 0xf8,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,
+(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xf8,
+};
+
+static final BitmapCharRec ch91 = new BitmapCharRec(5,21,-2,4,8,ch91data);
+
+/* char: 0x5a 'Z' */
+
+static final byte[] ch90data = {
+(byte) 0xff,(byte) 0xf8,(byte) 0xe0,(byte) 0x18,(byte) 0x70,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x38,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0x1c,(byte) 0x0,(byte) 0xe,(byte) 0x0,
+(byte) 0x6,(byte) 0x0,(byte) 0x7,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x80,(byte) 0x1,(byte) 0xc0,(byte) 0x80,(byte) 0xc0,(byte) 0x80,(byte) 0xe0,(byte) 0xc0,(byte) 0x70,
+(byte) 0xff,(byte) 0xf0,
+};
+
+static final BitmapCharRec ch90 = new BitmapCharRec(13,17,-1,0,15,ch90data);
+
+/* char: 0x59 'Y' */
+
+static final byte[] ch89data = {
+(byte) 0x7,(byte) 0xe0,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x3,(byte) 0xc0,
+(byte) 0x3,(byte) 0x40,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0x20,(byte) 0xc,(byte) 0x30,(byte) 0x1c,(byte) 0x10,(byte) 0x18,(byte) 0x18,(byte) 0x38,(byte) 0x8,(byte) 0x30,(byte) 0xc,
+(byte) 0xfc,(byte) 0x3f,
+};
+
+static final BitmapCharRec ch89 = new BitmapCharRec(16,17,0,0,16,ch89data);
+
+/* char: 0x58 'X' */
+
+static final byte[] ch88data = {
+(byte) 0xfc,(byte) 0xf,(byte) 0xc0,(byte) 0x30,(byte) 0x3,(byte) 0x80,(byte) 0x18,(byte) 0x7,(byte) 0x0,(byte) 0x8,(byte) 0xe,(byte) 0x0,(byte) 0x4,(byte) 0xc,(byte) 0x0,(byte) 0x6,
+(byte) 0x18,(byte) 0x0,(byte) 0x2,(byte) 0x38,(byte) 0x0,(byte) 0x1,(byte) 0x70,(byte) 0x0,(byte) 0x0,(byte) 0xe0,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0x1,(byte) 0xc0,
+(byte) 0x0,(byte) 0x3,(byte) 0xa0,(byte) 0x0,(byte) 0x3,(byte) 0x10,(byte) 0x0,(byte) 0x6,(byte) 0x8,(byte) 0x0,(byte) 0xe,(byte) 0xc,(byte) 0x0,(byte) 0x1c,(byte) 0x6,(byte) 0x0,
+(byte) 0x7e,(byte) 0xf,(byte) 0x80,
+};
+
+static final BitmapCharRec ch88 = new BitmapCharRec(18,17,0,0,18,ch88data);
+
+/* char: 0x57 'W' */
+
+static final byte[] ch87data = {
+(byte) 0x1,(byte) 0x83,(byte) 0x0,(byte) 0x1,(byte) 0x83,(byte) 0x0,(byte) 0x1,(byte) 0x83,(byte) 0x80,(byte) 0x3,(byte) 0x87,(byte) 0x80,(byte) 0x3,(byte) 0x46,(byte) 0x80,(byte) 0x3,
+(byte) 0x46,(byte) 0xc0,(byte) 0x6,(byte) 0x46,(byte) 0x40,(byte) 0x6,(byte) 0x4c,(byte) 0x40,(byte) 0x6,(byte) 0x4c,(byte) 0x60,(byte) 0xc,(byte) 0x2c,(byte) 0x60,(byte) 0xc,(byte) 0x2c,
+(byte) 0x20,(byte) 0x18,(byte) 0x2c,(byte) 0x20,(byte) 0x18,(byte) 0x18,(byte) 0x30,(byte) 0x18,(byte) 0x18,(byte) 0x10,(byte) 0x30,(byte) 0x18,(byte) 0x10,(byte) 0x30,(byte) 0x18,(byte) 0x18,
+(byte) 0xfc,(byte) 0x7e,(byte) 0x7e,
+};
+
+static final BitmapCharRec ch87 = new BitmapCharRec(23,17,0,0,23,ch87data);
+
+/* char: 0x56 'V' */
+
+static final byte[] ch86data = {
+(byte) 0x1,(byte) 0x80,(byte) 0x0,(byte) 0x1,(byte) 0x80,(byte) 0x0,(byte) 0x1,(byte) 0x80,(byte) 0x0,(byte) 0x3,(byte) 0xc0,(byte) 0x0,(byte) 0x3,(byte) 0x40,(byte) 0x0,(byte) 0x3,
+(byte) 0x60,(byte) 0x0,(byte) 0x6,(byte) 0x20,(byte) 0x0,(byte) 0x6,(byte) 0x20,(byte) 0x0,(byte) 0x6,(byte) 0x30,(byte) 0x0,(byte) 0xc,(byte) 0x10,(byte) 0x0,(byte) 0xc,(byte) 0x18,
+(byte) 0x0,(byte) 0x18,(byte) 0x8,(byte) 0x0,(byte) 0x18,(byte) 0x8,(byte) 0x0,(byte) 0x18,(byte) 0xc,(byte) 0x0,(byte) 0x30,(byte) 0x4,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,
+(byte) 0xfc,(byte) 0x1f,(byte) 0x80,
+};
+
+static final BitmapCharRec ch86 = new BitmapCharRec(17,17,0,0,17,ch86data);
+
+/* char: 0x55 'U' */
+
+static final byte[] ch85data = {
+(byte) 0x7,(byte) 0xe0,(byte) 0x1c,(byte) 0x30,(byte) 0x18,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,
+(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,(byte) 0x30,(byte) 0x4,
+(byte) 0xfc,(byte) 0x1f,
+};
+
+static final BitmapCharRec ch85 = new BitmapCharRec(16,17,-1,0,18,ch85data);
+
+/* char: 0x54 'T' */
+
+static final byte[] ch84data = {
+(byte) 0xf,(byte) 0xc0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,
+(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x83,(byte) 0x4,(byte) 0x83,(byte) 0x4,(byte) 0xc3,(byte) 0xc,
+(byte) 0xff,(byte) 0xfc,
+};
+
+static final BitmapCharRec ch84 = new BitmapCharRec(14,17,-1,0,16,ch84data);
+
+/* char: 0x53 'S' */
+
+static final byte[] ch83data = {
+(byte) 0x9e,(byte) 0x0,(byte) 0xf1,(byte) 0x80,(byte) 0xc0,(byte) 0xc0,(byte) 0x80,(byte) 0x60,(byte) 0x80,(byte) 0x60,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0xe0,(byte) 0x3,(byte) 0xc0,
+(byte) 0xf,(byte) 0x80,(byte) 0x1e,(byte) 0x0,(byte) 0x78,(byte) 0x0,(byte) 0xe0,(byte) 0x0,(byte) 0xc0,(byte) 0x40,(byte) 0xc0,(byte) 0x40,(byte) 0xc0,(byte) 0xc0,(byte) 0x63,(byte) 0xc0,
+(byte) 0x1e,(byte) 0x40,
+};
+
+static final BitmapCharRec ch83 = new BitmapCharRec(11,17,-1,0,13,ch83data);
+
+/* char: 0x52 'R' */
+
+static final byte[] ch82data = {
+(byte) 0xfc,(byte) 0x1e,(byte) 0x30,(byte) 0x1c,(byte) 0x30,(byte) 0x38,(byte) 0x30,(byte) 0x70,(byte) 0x30,(byte) 0x60,(byte) 0x30,(byte) 0xc0,(byte) 0x31,(byte) 0xc0,(byte) 0x33,(byte) 0x80,
+(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0x70,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x38,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x38,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x70,
+(byte) 0xff,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch82 = new BitmapCharRec(15,17,-1,0,16,ch82data);
+
+/* char: 0x51 'Q' */
+
+static final byte[] ch81data = {
+(byte) 0x0,(byte) 0xf,(byte) 0x0,(byte) 0x38,(byte) 0x0,(byte) 0x70,(byte) 0x0,(byte) 0xe0,(byte) 0x1,(byte) 0xc0,(byte) 0x7,(byte) 0xe0,(byte) 0x1c,(byte) 0x38,(byte) 0x38,(byte) 0x1c,
+(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,
+(byte) 0xc0,(byte) 0x3,(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0x38,(byte) 0x1c,(byte) 0x1c,(byte) 0x38,(byte) 0x7,(byte) 0xe0,
+};
+
+static final BitmapCharRec ch81 = new BitmapCharRec(16,22,-1,5,18,ch81data);
+
+/* char: 0x50 'P' */
+
+static final byte[] ch80data = {
+(byte) 0xfc,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,
+(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0x70,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x70,
+(byte) 0xff,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch80 = new BitmapCharRec(13,17,-1,0,15,ch80data);
+
+/* char: 0x4f 'O' */
+
+static final byte[] ch79data = {
+(byte) 0x7,(byte) 0xe0,(byte) 0x1c,(byte) 0x38,(byte) 0x38,(byte) 0x1c,(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,
+(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0xc0,(byte) 0x3,(byte) 0x60,(byte) 0x6,(byte) 0x60,(byte) 0x6,(byte) 0x38,(byte) 0x1c,(byte) 0x1c,(byte) 0x38,
+(byte) 0x7,(byte) 0xe0,
+};
+
+static final BitmapCharRec ch79 = new BitmapCharRec(16,17,-1,0,18,ch79data);
+
+/* char: 0x4e 'N' */
+
+static final byte[] ch78data = {
+(byte) 0xf8,(byte) 0xc,(byte) 0x20,(byte) 0x1c,(byte) 0x20,(byte) 0x1c,(byte) 0x20,(byte) 0x34,(byte) 0x20,(byte) 0x64,(byte) 0x20,(byte) 0x64,(byte) 0x20,(byte) 0xc4,(byte) 0x21,(byte) 0x84,
+(byte) 0x21,(byte) 0x84,(byte) 0x23,(byte) 0x4,(byte) 0x26,(byte) 0x4,(byte) 0x26,(byte) 0x4,(byte) 0x2c,(byte) 0x4,(byte) 0x38,(byte) 0x4,(byte) 0x38,(byte) 0x4,(byte) 0x30,(byte) 0x4,
+(byte) 0xf0,(byte) 0x1f,
+};
+
+static final BitmapCharRec ch78 = new BitmapCharRec(16,17,-1,0,18,ch78data);
+
+/* char: 0x4d 'M' */
+
+static final byte[] ch77data = {
+(byte) 0xf8,(byte) 0x21,(byte) 0xf8,(byte) 0x20,(byte) 0x60,(byte) 0x60,(byte) 0x20,(byte) 0x60,(byte) 0x60,(byte) 0x20,(byte) 0xd0,(byte) 0x60,(byte) 0x20,(byte) 0xd0,(byte) 0x60,(byte) 0x21,
+(byte) 0x88,(byte) 0x60,(byte) 0x21,(byte) 0x88,(byte) 0x60,(byte) 0x23,(byte) 0x8,(byte) 0x60,(byte) 0x23,(byte) 0x4,(byte) 0x60,(byte) 0x26,(byte) 0x4,(byte) 0x60,(byte) 0x26,(byte) 0x2,
+(byte) 0x60,(byte) 0x2c,(byte) 0x2,(byte) 0x60,(byte) 0x2c,(byte) 0x2,(byte) 0x60,(byte) 0x38,(byte) 0x1,(byte) 0x60,(byte) 0x38,(byte) 0x1,(byte) 0x60,(byte) 0x30,(byte) 0x0,(byte) 0xe0,
+(byte) 0xf0,(byte) 0x0,(byte) 0xf8,
+};
+
+static final BitmapCharRec ch77 = new BitmapCharRec(21,17,-1,0,22,ch77data);
+
+/* char: 0x4c 'L' */
+
+static final byte[] ch76data = {
+(byte) 0xff,(byte) 0xf8,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,
+(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,
+(byte) 0xfc,(byte) 0x0,
+};
+
+static final BitmapCharRec ch76 = new BitmapCharRec(13,17,-1,0,14,ch76data);
+
+/* char: 0x4b 'K' */
+
+static final byte[] ch75data = {
+(byte) 0xfc,(byte) 0x1f,(byte) 0x30,(byte) 0xe,(byte) 0x30,(byte) 0x1c,(byte) 0x30,(byte) 0x38,(byte) 0x30,(byte) 0x70,(byte) 0x30,(byte) 0xe0,(byte) 0x31,(byte) 0xc0,(byte) 0x33,(byte) 0x80,
+(byte) 0x3f,(byte) 0x0,(byte) 0x3e,(byte) 0x0,(byte) 0x33,(byte) 0x0,(byte) 0x31,(byte) 0x80,(byte) 0x30,(byte) 0xc0,(byte) 0x30,(byte) 0x60,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x18,
+(byte) 0xfc,(byte) 0x7e,
+};
+
+static final BitmapCharRec ch75 = new BitmapCharRec(16,17,-1,0,17,ch75data);
+
+/* char: 0x4a 'J' */
+
+static final byte[] ch74data = {
+(byte) 0x78,(byte) 0x0,(byte) 0xcc,(byte) 0x0,(byte) 0xc6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,
+(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,
+(byte) 0x1f,(byte) 0x80,
+};
+
+static final BitmapCharRec ch74 = new BitmapCharRec(9,17,-1,0,11,ch74data);
+
+/* char: 0x49 'I' */
+
+static final byte[] ch73data = {
+(byte) 0xfc,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x30,
+(byte) 0xfc,
+};
+
+static final BitmapCharRec ch73 = new BitmapCharRec(6,17,-1,0,8,ch73data);
+
+/* char: 0x48 'H' */
+
+static final byte[] ch72data = {
+(byte) 0xfc,(byte) 0x1f,(byte) 0x80,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x30,
+(byte) 0x6,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x3f,(byte) 0xfe,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x30,(byte) 0x6,
+(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x30,(byte) 0x6,(byte) 0x0,
+(byte) 0xfc,(byte) 0x1f,(byte) 0x80,
+};
+
+static final BitmapCharRec ch72 = new BitmapCharRec(17,17,-1,0,19,ch72data);
+
+/* char: 0x47 'G' */
+
+static final byte[] ch71data = {
+(byte) 0x7,(byte) 0xe0,(byte) 0x1e,(byte) 0x38,(byte) 0x38,(byte) 0x1c,(byte) 0x60,(byte) 0xc,(byte) 0x60,(byte) 0xc,(byte) 0xc0,(byte) 0xc,(byte) 0xc0,(byte) 0xc,(byte) 0xc0,(byte) 0x3f,
+(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0x60,(byte) 0x4,(byte) 0x60,(byte) 0x4,(byte) 0x38,(byte) 0xc,(byte) 0x1c,(byte) 0x3c,
+(byte) 0x7,(byte) 0xe4,
+};
+
+static final BitmapCharRec ch71 = new BitmapCharRec(16,17,-1,0,18,ch71data);
+
+/* char: 0x46 'F' */
+
+static final byte[] ch70data = {
+(byte) 0xfc,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x20,(byte) 0x30,(byte) 0x20,
+(byte) 0x3f,(byte) 0xe0,(byte) 0x30,(byte) 0x20,(byte) 0x30,(byte) 0x20,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x10,(byte) 0x30,(byte) 0x10,(byte) 0x30,(byte) 0x30,
+(byte) 0xff,(byte) 0xf0,
+};
+
+static final BitmapCharRec ch70 = new BitmapCharRec(12,17,-1,0,14,ch70data);
+
+/* char: 0x45 'E' */
+
+static final byte[] ch69data = {
+(byte) 0xff,(byte) 0xf8,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x8,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x40,
+(byte) 0x3f,(byte) 0xc0,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x30,(byte) 0x10,(byte) 0x30,(byte) 0x10,(byte) 0x30,(byte) 0x30,
+(byte) 0xff,(byte) 0xf0,
+};
+
+static final BitmapCharRec ch69 = new BitmapCharRec(13,17,-1,0,15,ch69data);
+
+/* char: 0x44 'D' */
+
+static final byte[] ch68data = {
+(byte) 0xff,(byte) 0xc0,(byte) 0x30,(byte) 0x70,(byte) 0x30,(byte) 0x38,(byte) 0x30,(byte) 0xc,(byte) 0x30,(byte) 0xc,(byte) 0x30,(byte) 0x6,(byte) 0x30,(byte) 0x6,(byte) 0x30,(byte) 0x6,
+(byte) 0x30,(byte) 0x6,(byte) 0x30,(byte) 0x6,(byte) 0x30,(byte) 0x6,(byte) 0x30,(byte) 0x6,(byte) 0x30,(byte) 0xc,(byte) 0x30,(byte) 0xc,(byte) 0x30,(byte) 0x38,(byte) 0x30,(byte) 0x70,
+(byte) 0xff,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch68 = new BitmapCharRec(15,17,-1,0,17,ch68data);
+
+/* char: 0x43 'C' */
+
+static final byte[] ch67data = {
+(byte) 0x7,(byte) 0xe0,(byte) 0x1e,(byte) 0x38,(byte) 0x38,(byte) 0x8,(byte) 0x60,(byte) 0x4,(byte) 0x60,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,
+(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0x60,(byte) 0x4,(byte) 0x60,(byte) 0x4,(byte) 0x38,(byte) 0xc,(byte) 0x1c,(byte) 0x3c,
+(byte) 0x7,(byte) 0xe4,
+};
+
+static final BitmapCharRec ch67 = new BitmapCharRec(14,17,-1,0,16,ch67data);
+
+/* char: 0x42 'B' */
+
+static final byte[] ch66data = {
+(byte) 0xff,(byte) 0xe0,(byte) 0x30,(byte) 0x78,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0xc,(byte) 0x30,(byte) 0xc,(byte) 0x30,(byte) 0xc,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x38,
+(byte) 0x3f,(byte) 0xe0,(byte) 0x30,(byte) 0x40,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x18,(byte) 0x30,(byte) 0x30,(byte) 0x30,(byte) 0x70,
+(byte) 0xff,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch66 = new BitmapCharRec(14,17,-1,0,16,ch66data);
+
+/* char: 0x41 'A' */
+
+static final byte[] ch65data = {
+(byte) 0xfc,(byte) 0x1f,(byte) 0x80,(byte) 0x30,(byte) 0x6,(byte) 0x0,(byte) 0x10,(byte) 0x6,(byte) 0x0,(byte) 0x10,(byte) 0xc,(byte) 0x0,(byte) 0x18,(byte) 0xc,(byte) 0x0,(byte) 0x8,
+(byte) 0xc,(byte) 0x0,(byte) 0xf,(byte) 0xf8,(byte) 0x0,(byte) 0xc,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x18,(byte) 0x0,(byte) 0x4,(byte) 0x30,(byte) 0x0,(byte) 0x6,(byte) 0x30,
+(byte) 0x0,(byte) 0x2,(byte) 0x30,(byte) 0x0,(byte) 0x2,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0x60,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,
+(byte) 0x0,(byte) 0x80,(byte) 0x0,
+};
+
+static final BitmapCharRec ch65 = new BitmapCharRec(17,17,0,0,17,ch65data);
+
+/* char: 0x40 '@' */
+
+static final byte[] ch64data = {
+(byte) 0x3,(byte) 0xf0,(byte) 0x0,(byte) 0xe,(byte) 0xc,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x0,(byte) 0x61,(byte) 0xde,(byte) 0x0,(byte) 0x63,
+(byte) 0x7b,(byte) 0x0,(byte) 0xc6,(byte) 0x39,(byte) 0x80,(byte) 0xc6,(byte) 0x18,(byte) 0x80,(byte) 0xc6,(byte) 0x18,(byte) 0xc0,(byte) 0xc6,(byte) 0x18,(byte) 0x40,(byte) 0xc6,(byte) 0xc,
+(byte) 0x40,(byte) 0xc3,(byte) 0xc,(byte) 0x40,(byte) 0xc3,(byte) 0x8c,(byte) 0x40,(byte) 0xe1,(byte) 0xfc,(byte) 0x40,(byte) 0x60,(byte) 0xec,(byte) 0xc0,(byte) 0x70,(byte) 0x0,(byte) 0x80,
+(byte) 0x38,(byte) 0x1,(byte) 0x80,(byte) 0x1c,(byte) 0x3,(byte) 0x0,(byte) 0xf,(byte) 0xe,(byte) 0x0,(byte) 0x3,(byte) 0xf8,(byte) 0x0,
+};
+
+static final BitmapCharRec ch64 = new BitmapCharRec(18,20,-2,3,22,ch64data);
+
+/* char: 0x3f '?' */
+
+static final byte[] ch63data = {
+(byte) 0x30,(byte) 0x30,(byte) 0x0,(byte) 0x0,(byte) 0x10,(byte) 0x10,(byte) 0x10,(byte) 0x18,(byte) 0x18,(byte) 0xc,(byte) 0xe,(byte) 0x7,(byte) 0xc3,(byte) 0xc3,(byte) 0x83,(byte) 0xc6,
+(byte) 0x7c,
+};
+
+static final BitmapCharRec ch63 = new BitmapCharRec(8,17,-2,0,11,ch63data);
+
+/* char: 0x3e '>' */
+
+static final byte[] ch62data = {
+(byte) 0xc0,(byte) 0x0,(byte) 0x70,(byte) 0x0,(byte) 0x1c,(byte) 0x0,(byte) 0x7,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,(byte) 0x60,(byte) 0x1,(byte) 0xc0,(byte) 0x7,(byte) 0x0,
+(byte) 0x1c,(byte) 0x0,(byte) 0x70,(byte) 0x0,(byte) 0xc0,(byte) 0x0,
+};
+
+static final BitmapCharRec ch62 = new BitmapCharRec(11,11,-1,-1,13,ch62data);
+
+/* char: 0x3d '=' */
+
+static final byte[] ch61data = {
+(byte) 0xff,(byte) 0xf0,(byte) 0xff,(byte) 0xf0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xff,(byte) 0xf0,(byte) 0xff,(byte) 0xf0,
+};
+
+static final BitmapCharRec ch61 = new BitmapCharRec(12,6,-1,-4,14,ch61data);
+
+/* char: 0x3c '<' */
+
+static final byte[] ch60data = {
+(byte) 0x0,(byte) 0x60,(byte) 0x1,(byte) 0xc0,(byte) 0x7,(byte) 0x0,(byte) 0x1c,(byte) 0x0,(byte) 0x70,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0x70,(byte) 0x0,(byte) 0x1c,(byte) 0x0,
+(byte) 0x7,(byte) 0x0,(byte) 0x1,(byte) 0xc0,(byte) 0x0,(byte) 0x60,
+};
+
+static final BitmapCharRec ch60 = new BitmapCharRec(11,11,-1,-1,13,ch60data);
+
+/* char: 0x3b ';' */
+
+static final byte[] ch59data = {
+(byte) 0xc0,(byte) 0x60,(byte) 0x20,(byte) 0xe0,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch59 = new BitmapCharRec(3,14,-2,3,7,ch59data);
+
+/* char: 0x3a ':' */
+
+static final byte[] ch58data = {
+(byte) 0xc0,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch58 = new BitmapCharRec(2,11,-2,0,6,ch58data);
+
+/* char: 0x39 '9' */
+
+static final byte[] ch57data = {
+(byte) 0xf0,(byte) 0x0,(byte) 0x1c,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1d,(byte) 0x80,(byte) 0x73,(byte) 0xc0,
+(byte) 0x61,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc1,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x77,(byte) 0x80,
+(byte) 0x1e,(byte) 0x0,
+};
+
+static final BitmapCharRec ch57 = new BitmapCharRec(10,17,-1,0,12,ch57data);
+
+/* char: 0x38 '8' */
+
+static final byte[] ch56data = {
+(byte) 0x1e,(byte) 0x0,(byte) 0x73,(byte) 0x80,(byte) 0xe1,(byte) 0x80,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x41,(byte) 0xc0,(byte) 0x61,(byte) 0x80,
+(byte) 0x37,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0x33,(byte) 0x0,(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x33,(byte) 0x0,
+(byte) 0x1e,(byte) 0x0,
+};
+
+static final BitmapCharRec ch56 = new BitmapCharRec(10,17,-1,0,12,ch56data);
+
+/* char: 0x37 '7' */
+
+static final byte[] ch55data = {
+(byte) 0x18,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x4,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,
+(byte) 0x2,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x1,(byte) 0x0,(byte) 0x1,(byte) 0x80,(byte) 0x81,(byte) 0x80,(byte) 0xc0,(byte) 0xc0,(byte) 0xff,(byte) 0xc0,
+(byte) 0x7f,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch55 = new BitmapCharRec(10,17,-1,0,12,ch55data);
+
+/* char: 0x36 '6' */
+
+static final byte[] ch54data = {
+(byte) 0x1e,(byte) 0x0,(byte) 0x7b,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0xe0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,
+(byte) 0xc1,(byte) 0x80,(byte) 0xf3,(byte) 0x80,(byte) 0xee,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x70,(byte) 0x0,(byte) 0x30,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0xe,(byte) 0x0,
+(byte) 0x3,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch54 = new BitmapCharRec(10,17,-1,0,12,ch54data);
+
+/* char: 0x35 '5' */
+
+static final byte[] ch53data = {
+(byte) 0x7e,(byte) 0x0,(byte) 0xe3,(byte) 0x80,(byte) 0xc1,(byte) 0x80,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x0,(byte) 0xc0,(byte) 0x1,(byte) 0xc0,
+(byte) 0x3,(byte) 0x80,(byte) 0xf,(byte) 0x80,(byte) 0x7e,(byte) 0x0,(byte) 0x78,(byte) 0x0,(byte) 0x60,(byte) 0x0,(byte) 0x20,(byte) 0x0,(byte) 0x20,(byte) 0x0,(byte) 0x1f,(byte) 0x80,
+(byte) 0x1f,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch53 = new BitmapCharRec(10,17,-1,0,12,ch53data);
+
+/* char: 0x34 '4' */
+
+static final byte[] ch52data = {
+(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0xff,(byte) 0xc0,(byte) 0xff,(byte) 0xc0,(byte) 0xc3,(byte) 0x0,(byte) 0x43,(byte) 0x0,
+(byte) 0x63,(byte) 0x0,(byte) 0x23,(byte) 0x0,(byte) 0x33,(byte) 0x0,(byte) 0x13,(byte) 0x0,(byte) 0x1b,(byte) 0x0,(byte) 0xb,(byte) 0x0,(byte) 0x7,(byte) 0x0,(byte) 0x7,(byte) 0x0,
+(byte) 0x3,(byte) 0x0,
+};
+
+static final BitmapCharRec ch52 = new BitmapCharRec(10,17,-1,0,12,ch52data);
+
+/* char: 0x33 '3' */
+
+static final byte[] ch51data = {
+(byte) 0x78,(byte) 0x0,(byte) 0xe6,(byte) 0x0,(byte) 0xc3,(byte) 0x0,(byte) 0x1,(byte) 0x0,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x3,(byte) 0x80,
+(byte) 0x7,(byte) 0x0,(byte) 0x1e,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x83,(byte) 0x0,(byte) 0x83,(byte) 0x0,(byte) 0x47,(byte) 0x0,(byte) 0x7e,(byte) 0x0,
+(byte) 0x1c,(byte) 0x0,
+};
+
+static final BitmapCharRec ch51 = new BitmapCharRec(9,17,-1,0,12,ch51data);
+
+/* char: 0x32 '2' */
+
+static final byte[] ch50data = {
+(byte) 0xff,(byte) 0x80,(byte) 0xff,(byte) 0xc0,(byte) 0x60,(byte) 0x40,(byte) 0x30,(byte) 0x0,(byte) 0x18,(byte) 0x0,(byte) 0xc,(byte) 0x0,(byte) 0x4,(byte) 0x0,(byte) 0x6,(byte) 0x0,
+(byte) 0x3,(byte) 0x0,(byte) 0x3,(byte) 0x0,(byte) 0x1,(byte) 0x80,(byte) 0x1,(byte) 0x80,(byte) 0x81,(byte) 0x80,(byte) 0x81,(byte) 0x80,(byte) 0x43,(byte) 0x80,(byte) 0x7f,(byte) 0x0,
+(byte) 0x1c,(byte) 0x0,
+};
+
+static final BitmapCharRec ch50 = new BitmapCharRec(10,17,-1,0,12,ch50data);
+
+/* char: 0x31 '1' */
+
+static final byte[] ch49data = {
+(byte) 0xff,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x18,(byte) 0x78,(byte) 0x18,
+(byte) 0x8,
+};
+
+static final BitmapCharRec ch49 = new BitmapCharRec(8,17,-2,0,12,ch49data);
+
+/* char: 0x30 '0' */
+
+static final byte[] ch48data = {
+(byte) 0x1e,(byte) 0x0,(byte) 0x33,(byte) 0x0,(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0xe1,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,
+(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x61,(byte) 0x80,(byte) 0x61,(byte) 0x80,(byte) 0x33,(byte) 0x0,
+(byte) 0x1e,(byte) 0x0,
+};
+
+static final BitmapCharRec ch48 = new BitmapCharRec(10,17,-1,0,12,ch48data);
+
+/* char: 0x2f '/' */
+
+static final byte[] ch47data = {
+(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x60,(byte) 0x60,(byte) 0x20,(byte) 0x30,(byte) 0x30,(byte) 0x10,(byte) 0x18,(byte) 0x18,(byte) 0x8,(byte) 0xc,(byte) 0xc,(byte) 0x4,(byte) 0x6,
+(byte) 0x6,(byte) 0x3,(byte) 0x3,(byte) 0x3,
+};
+
+static final BitmapCharRec ch47 = new BitmapCharRec(8,20,1,3,7,ch47data);
+
+/* char: 0x2e '.' */
+
+static final byte[] ch46data = {
+(byte) 0xc0,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch46 = new BitmapCharRec(2,2,-2,0,6,ch46data);
+
+/* char: 0x2d '-' */
+
+static final byte[] ch45data = {
+(byte) 0xff,(byte) 0xf0,(byte) 0xff,(byte) 0xf0,
+};
+
+static final BitmapCharRec ch45 = new BitmapCharRec(12,2,-1,-6,14,ch45data);
+
+/* char: 0x2c ',' */
+
+static final byte[] ch44data = {
+(byte) 0xc0,(byte) 0x60,(byte) 0x20,(byte) 0xe0,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch44 = new BitmapCharRec(3,5,-2,3,7,ch44data);
+
+/* char: 0x2b '+' */
+
+static final byte[] ch43data = {
+(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0xff,(byte) 0xf0,(byte) 0xff,(byte) 0xf0,(byte) 0x6,(byte) 0x0,
+(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,(byte) 0x6,(byte) 0x0,
+};
+
+static final BitmapCharRec ch43 = new BitmapCharRec(12,12,-1,-1,14,ch43data);
+
+/* char: 0x2a '*' */
+
+static final byte[] ch42data = {
+(byte) 0x8,(byte) 0x0,(byte) 0x1c,(byte) 0x0,(byte) 0xc9,(byte) 0x80,(byte) 0xeb,(byte) 0x80,(byte) 0x1c,(byte) 0x0,(byte) 0xeb,(byte) 0x80,(byte) 0xc9,(byte) 0x80,(byte) 0x1c,(byte) 0x0,
+(byte) 0x8,(byte) 0x0,
+};
+
+static final BitmapCharRec ch42 = new BitmapCharRec(9,9,-2,-8,12,ch42data);
+
+/* char: 0x29 ')' */
+
+static final byte[] ch41data = {
+(byte) 0x80,(byte) 0x40,(byte) 0x20,(byte) 0x30,(byte) 0x10,(byte) 0x18,(byte) 0x18,(byte) 0xc,(byte) 0xc,(byte) 0xc,(byte) 0xc,(byte) 0xc,(byte) 0xc,(byte) 0xc,(byte) 0xc,(byte) 0x18,
+(byte) 0x18,(byte) 0x10,(byte) 0x30,(byte) 0x20,(byte) 0x40,(byte) 0x80,
+};
+
+static final BitmapCharRec ch41 = new BitmapCharRec(6,22,-1,5,8,ch41data);
+
+/* char: 0x28 '(' */
+
+static final byte[] ch40data = {
+(byte) 0x4,(byte) 0x8,(byte) 0x10,(byte) 0x30,(byte) 0x20,(byte) 0x60,(byte) 0x60,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0x60,
+(byte) 0x60,(byte) 0x20,(byte) 0x30,(byte) 0x10,(byte) 0x8,(byte) 0x4,
+};
+
+static final BitmapCharRec ch40 = new BitmapCharRec(6,22,-1,5,8,ch40data);
+
+/* char: 0x27 ''' */
+
+static final byte[] ch39data = {
+(byte) 0xc0,(byte) 0x60,(byte) 0x20,(byte) 0xe0,(byte) 0xc0,
+};
+
+static final BitmapCharRec ch39 = new BitmapCharRec(3,5,-3,-12,8,ch39data);
+
+/* char: 0x26 '&' */
+
+static final byte[] ch38data = {
+(byte) 0x3c,(byte) 0x3c,(byte) 0x7f,(byte) 0x7e,(byte) 0xe1,(byte) 0xe1,(byte) 0xc0,(byte) 0xc0,(byte) 0xc1,(byte) 0xc0,(byte) 0xc1,(byte) 0xa0,(byte) 0x63,(byte) 0x20,(byte) 0x37,(byte) 0x10,
+(byte) 0x1e,(byte) 0x18,(byte) 0xe,(byte) 0x3e,(byte) 0xf,(byte) 0x0,(byte) 0x1d,(byte) 0x80,(byte) 0x18,(byte) 0xc0,(byte) 0x18,(byte) 0x40,(byte) 0x18,(byte) 0x40,(byte) 0xc,(byte) 0xc0,
+(byte) 0x7,(byte) 0x80,
+};
+
+static final BitmapCharRec ch38 = new BitmapCharRec(16,17,-1,0,18,ch38data);
+
+/* char: 0x25 '%' */
+
+static final byte[] ch37data = {
+(byte) 0x30,(byte) 0x3c,(byte) 0x0,(byte) 0x18,(byte) 0x72,(byte) 0x0,(byte) 0xc,(byte) 0x61,(byte) 0x0,(byte) 0x4,(byte) 0x60,(byte) 0x80,(byte) 0x6,(byte) 0x60,(byte) 0x80,(byte) 0x3,
+(byte) 0x30,(byte) 0x80,(byte) 0x1,(byte) 0x19,(byte) 0x80,(byte) 0x1,(byte) 0x8f,(byte) 0x0,(byte) 0x78,(byte) 0xc0,(byte) 0x0,(byte) 0xe4,(byte) 0x40,(byte) 0x0,(byte) 0xc2,(byte) 0x60,
+(byte) 0x0,(byte) 0xc1,(byte) 0x30,(byte) 0x0,(byte) 0xc1,(byte) 0x10,(byte) 0x0,(byte) 0x61,(byte) 0x18,(byte) 0x0,(byte) 0x33,(byte) 0xfc,(byte) 0x0,(byte) 0x1e,(byte) 0xc,(byte) 0x0,
+};
+
+static final BitmapCharRec ch37 = new BitmapCharRec(17,16,-1,0,19,ch37data);
+
+/* char: 0x24 '$' */
+
+static final byte[] ch36data = {
+(byte) 0x4,(byte) 0x0,(byte) 0x4,(byte) 0x0,(byte) 0x3f,(byte) 0x0,(byte) 0xe5,(byte) 0xc0,(byte) 0xc4,(byte) 0xc0,(byte) 0x84,(byte) 0x60,(byte) 0x84,(byte) 0x60,(byte) 0x4,(byte) 0x60,
+(byte) 0x4,(byte) 0xe0,(byte) 0x7,(byte) 0xc0,(byte) 0x7,(byte) 0x80,(byte) 0x1e,(byte) 0x0,(byte) 0x3c,(byte) 0x0,(byte) 0x74,(byte) 0x0,(byte) 0x64,(byte) 0x0,(byte) 0x64,(byte) 0x20,
+(byte) 0x64,(byte) 0x60,(byte) 0x34,(byte) 0xe0,(byte) 0x1f,(byte) 0x80,(byte) 0x4,(byte) 0x0,(byte) 0x4,(byte) 0x0,
+};
+
+static final BitmapCharRec ch36 = new BitmapCharRec(11,21,0,2,12,ch36data);
+
+/* char: 0x23 '#' */
+
+static final byte[] ch35data = {
+(byte) 0x22,(byte) 0x0,(byte) 0x22,(byte) 0x0,(byte) 0x22,(byte) 0x0,(byte) 0x22,(byte) 0x0,(byte) 0x22,(byte) 0x0,(byte) 0xff,(byte) 0xc0,(byte) 0xff,(byte) 0xc0,(byte) 0x11,(byte) 0x0,
+(byte) 0x11,(byte) 0x0,(byte) 0x11,(byte) 0x0,(byte) 0x7f,(byte) 0xe0,(byte) 0x7f,(byte) 0xe0,(byte) 0x8,(byte) 0x80,(byte) 0x8,(byte) 0x80,(byte) 0x8,(byte) 0x80,(byte) 0x8,(byte) 0x80,
+(byte) 0x8,(byte) 0x80,
+};
+
+static final BitmapCharRec ch35 = new BitmapCharRec(11,17,-1,0,13,ch35data);
+
+/* char: 0x22 '"' */
+
+static final byte[] ch34data = {
+(byte) 0x88,(byte) 0xcc,(byte) 0xcc,(byte) 0xcc,(byte) 0xcc,
+};
+
+static final BitmapCharRec ch34 = new BitmapCharRec(6,5,-1,-12,10,ch34data);
+
+/* char: 0x21 '!' */
+
+static final byte[] ch33data = {
+(byte) 0xc0,(byte) 0xc0,(byte) 0x0,(byte) 0x0,(byte) 0x0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,(byte) 0xc0,
+(byte) 0xc0,
+};
+
+static final BitmapCharRec ch33 = new BitmapCharRec(2,17,-3,0,8,ch33data);
+
+/* char: 0x20 ' ' */
+
+static final BitmapCharRec ch32 = new BitmapCharRec(0,0,0,0,6,null);
+
+static final BitmapCharRec[] chars = {
+ch32,
+ch33,
+ch34,
+ch35,
+ch36,
+ch37,
+ch38,
+ch39,
+ch40,
+ch41,
+ch42,
+ch43,
+ch44,
+ch45,
+ch46,
+ch47,
+ch48,
+ch49,
+ch50,
+ch51,
+ch52,
+ch53,
+ch54,
+ch55,
+ch56,
+ch57,
+ch58,
+ch59,
+ch60,
+ch61,
+ch62,
+ch63,
+ch64,
+ch65,
+ch66,
+ch67,
+ch68,
+ch69,
+ch70,
+ch71,
+ch72,
+ch73,
+ch74,
+ch75,
+ch76,
+ch77,
+ch78,
+ch79,
+ch80,
+ch81,
+ch82,
+ch83,
+ch84,
+ch85,
+ch86,
+ch87,
+ch88,
+ch89,
+ch90,
+ch91,
+ch92,
+ch93,
+ch94,
+ch95,
+ch96,
+ch97,
+ch98,
+ch99,
+ch100,
+ch101,
+ch102,
+ch103,
+ch104,
+ch105,
+ch106,
+ch107,
+ch108,
+ch109,
+ch110,
+ch111,
+ch112,
+ch113,
+ch114,
+ch115,
+ch116,
+ch117,
+ch118,
+ch119,
+ch120,
+ch121,
+ch122,
+ch123,
+ch124,
+ch125,
+ch126,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+null,
+ch160,
+ch161,
+ch162,
+ch163,
+ch164,
+ch165,
+ch166,
+ch167,
+ch168,
+ch169,
+ch170,
+ch171,
+ch172,
+ch173,
+ch174,
+ch175,
+ch176,
+ch177,
+ch178,
+ch179,
+ch180,
+ch181,
+ch182,
+ch183,
+ch184,
+ch185,
+ch186,
+ch187,
+ch188,
+ch189,
+ch190,
+ch191,
+ch192,
+ch193,
+ch194,
+ch195,
+ch196,
+ch197,
+ch198,
+ch199,
+ch200,
+ch201,
+ch202,
+ch203,
+ch204,
+ch205,
+ch206,
+ch207,
+ch208,
+ch209,
+ch210,
+ch211,
+ch212,
+ch213,
+ch214,
+ch215,
+ch216,
+ch217,
+ch218,
+ch219,
+ch220,
+ch221,
+ch222,
+ch223,
+ch224,
+ch225,
+ch226,
+ch227,
+ch228,
+ch229,
+ch230,
+ch231,
+ch232,
+ch233,
+ch234,
+ch235,
+ch236,
+ch237,
+ch238,
+ch239,
+ch240,
+ch241,
+ch242,
+ch243,
+ch244,
+ch245,
+ch246,
+ch247,
+ch248,
+ch249,
+ch250,
+ch251,
+ch252,
+ch253,
+ch254,
+ch255,
+};
+
+  public static final BitmapFontRec glutBitmapTimesRoman24 = new BitmapFontRec("-adobe-times-medium-r-normal--24-240-75-75-p-124-iso8859-1",
+                                                                        224,
+                                                                        32,
+                                                                        chars);
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/gl2/GLUTStrokeMonoRoman.java b/src/jogl/classes/com/jogamp/opengl/util/gl2/GLUTStrokeMonoRoman.java
new file mode 100644
index 000000000..b8296924e
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/gl2/GLUTStrokeMonoRoman.java
@@ -0,0 +1,2491 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util.gl2;
+
+class GLUTStrokeMonoRoman {
+
+/* GENERATED FILE -- DO NOT MODIFY */
+
+/* char: 33 '!' */
+
+static final CoordRec char33_stroke0[] = {
+    new CoordRec((float) 52.381, (float) 100 ),
+    new CoordRec((float) 52.381, (float) 33.3333 ),
+};
+
+static final CoordRec char33_stroke1[] = {
+    new CoordRec((float) 52.381, (float) 9.5238 ),
+    new CoordRec((float) 47.6191, (float) 4.7619 ),
+    new CoordRec((float) 52.381, (float) 0 ),
+    new CoordRec((float) 57.1429, (float) 4.7619 ),
+    new CoordRec((float) 52.381, (float) 9.5238 ),
+};
+
+static final StrokeRec char33[] = {
+   new StrokeRec( 2, char33_stroke0 ),
+   new StrokeRec( 5, char33_stroke1 ),
+};
+
+/* char: 34 '"' */
+
+static final CoordRec char34_stroke0[] = {
+    new CoordRec((float) 33.3334, (float) 100 ),
+    new CoordRec((float) 33.3334, (float) 66.6667 ),
+};
+
+static final CoordRec char34_stroke1[] = {
+    new CoordRec((float) 71.4286, (float) 100 ),
+    new CoordRec((float) 71.4286, (float) 66.6667 ),
+};
+
+static final StrokeRec char34[] = {
+   new StrokeRec( 2, char34_stroke0 ),
+   new StrokeRec( 2, char34_stroke1 ),
+};
+
+/* char: 35 '#' */
+
+static final CoordRec char35_stroke0[] = {
+    new CoordRec((float) 54.7619, (float) 119.048 ),
+    new CoordRec((float) 21.4286, (float) -33.3333 ),
+};
+
+static final CoordRec char35_stroke1[] = {
+    new CoordRec((float) 83.3334, (float) 119.048 ),
+    new CoordRec((float) 50, (float) -33.3333 ),
+};
+
+static final CoordRec char35_stroke2[] = {
+    new CoordRec((float) 21.4286, (float) 57.1429 ),
+    new CoordRec((float) 88.0952, (float) 57.1429 ),
+};
+
+static final CoordRec char35_stroke3[] = {
+    new CoordRec((float) 16.6667, (float) 28.5714 ),
+    new CoordRec((float) 83.3334, (float) 28.5714 ),
+};
+
+static final StrokeRec char35[] = {
+   new StrokeRec( 2, char35_stroke0 ),
+   new StrokeRec( 2, char35_stroke1 ),
+   new StrokeRec( 2, char35_stroke2 ),
+   new StrokeRec( 2, char35_stroke3 ),
+};
+
+/* char: 36 '$' */
+
+static final CoordRec char36_stroke0[] = {
+    new CoordRec((float) 42.8571, (float) 119.048 ),
+    new CoordRec((float) 42.8571, (float) -19.0476 ),
+};
+
+static final CoordRec char36_stroke1[] = {
+    new CoordRec((float) 61.9047, (float) 119.048 ),
+    new CoordRec((float) 61.9047, (float) -19.0476 ),
+};
+
+static final CoordRec char36_stroke2[] = {
+    new CoordRec((float) 85.7143, (float) 85.7143 ),
+    new CoordRec((float) 76.1905, (float) 95.2381 ),
+    new CoordRec((float) 61.9047, (float) 100 ),
+    new CoordRec((float) 42.8571, (float) 100 ),
+    new CoordRec((float) 28.5714, (float) 95.2381 ),
+    new CoordRec((float) 19.0476, (float) 85.7143 ),
+    new CoordRec((float) 19.0476, (float) 76.1905 ),
+    new CoordRec((float) 23.8095, (float) 66.6667 ),
+    new CoordRec((float) 28.5714, (float) 61.9048 ),
+    new CoordRec((float) 38.0952, (float) 57.1429 ),
+    new CoordRec((float) 66.6666, (float) 47.619 ),
+    new CoordRec((float) 76.1905, (float) 42.8571 ),
+    new CoordRec((float) 80.9524, (float) 38.0952 ),
+    new CoordRec((float) 85.7143, (float) 28.5714 ),
+    new CoordRec((float) 85.7143, (float) 14.2857 ),
+    new CoordRec((float) 76.1905, (float) 4.7619 ),
+    new CoordRec((float) 61.9047, (float) 0 ),
+    new CoordRec((float) 42.8571, (float) 0 ),
+    new CoordRec((float) 28.5714, (float) 4.7619 ),
+    new CoordRec((float) 19.0476, (float) 14.2857 ),
+};
+
+static final StrokeRec char36[] = {
+   new StrokeRec( 2, char36_stroke0 ),
+   new StrokeRec( 2, char36_stroke1 ),
+   new StrokeRec( 20, char36_stroke2 ),
+};
+
+/* char: 37 '%' */
+
+static final CoordRec char37_stroke0[] = {
+    new CoordRec((float) 95.2381, (float) 100 ),
+    new CoordRec((float) 9.5238, (float) 0 ),
+};
+
+static final CoordRec char37_stroke1[] = {
+    new CoordRec((float) 33.3333, (float) 100 ),
+    new CoordRec((float) 42.8571, (float) 90.4762 ),
+    new CoordRec((float) 42.8571, (float) 80.9524 ),
+    new CoordRec((float) 38.0952, (float) 71.4286 ),
+    new CoordRec((float) 28.5714, (float) 66.6667 ),
+    new CoordRec((float) 19.0476, (float) 66.6667 ),
+    new CoordRec((float) 9.5238, (float) 76.1905 ),
+    new CoordRec((float) 9.5238, (float) 85.7143 ),
+    new CoordRec((float) 14.2857, (float) 95.2381 ),
+    new CoordRec((float) 23.8095, (float) 100 ),
+    new CoordRec((float) 33.3333, (float) 100 ),
+    new CoordRec((float) 42.8571, (float) 95.2381 ),
+    new CoordRec((float) 57.1428, (float) 90.4762 ),
+    new CoordRec((float) 71.4286, (float) 90.4762 ),
+    new CoordRec((float) 85.7143, (float) 95.2381 ),
+    new CoordRec((float) 95.2381, (float) 100 ),
+};
+
+static final CoordRec char37_stroke2[] = {
+    new CoordRec((float) 76.1905, (float) 33.3333 ),
+    new CoordRec((float) 66.6667, (float) 28.5714 ),
+    new CoordRec((float) 61.9048, (float) 19.0476 ),
+    new CoordRec((float) 61.9048, (float) 9.5238 ),
+    new CoordRec((float) 71.4286, (float) 0 ),
+    new CoordRec((float) 80.9524, (float) 0 ),
+    new CoordRec((float) 90.4762, (float) 4.7619 ),
+    new CoordRec((float) 95.2381, (float) 14.2857 ),
+    new CoordRec((float) 95.2381, (float) 23.8095 ),
+    new CoordRec((float) 85.7143, (float) 33.3333 ),
+    new CoordRec((float) 76.1905, (float) 33.3333 ),
+};
+
+static final StrokeRec char37[] = {
+   new StrokeRec( 2, char37_stroke0 ),
+   new StrokeRec( 16, char37_stroke1 ),
+   new StrokeRec( 11, char37_stroke2 ),
+};
+
+/* char: 38 '&' */
+
+static final CoordRec char38_stroke0[] = {
+    new CoordRec((float) 100, (float) 57.1429 ),
+    new CoordRec((float) 100, (float) 61.9048 ),
+    new CoordRec((float) 95.2381, (float) 66.6667 ),
+    new CoordRec((float) 90.4762, (float) 66.6667 ),
+    new CoordRec((float) 85.7143, (float) 61.9048 ),
+    new CoordRec((float) 80.9524, (float) 52.381 ),
+    new CoordRec((float) 71.4286, (float) 28.5714 ),
+    new CoordRec((float) 61.9048, (float) 14.2857 ),
+    new CoordRec((float) 52.3809, (float) 4.7619 ),
+    new CoordRec((float) 42.8571, (float) 0 ),
+    new CoordRec((float) 23.8095, (float) 0 ),
+    new CoordRec((float) 14.2857, (float) 4.7619 ),
+    new CoordRec((float) 9.5238, (float) 9.5238 ),
+    new CoordRec((float) 4.7619, (float) 19.0476 ),
+    new CoordRec((float) 4.7619, (float) 28.5714 ),
+    new CoordRec((float) 9.5238, (float) 38.0952 ),
+    new CoordRec((float) 14.2857, (float) 42.8571 ),
+    new CoordRec((float) 47.619, (float) 61.9048 ),
+    new CoordRec((float) 52.3809, (float) 66.6667 ),
+    new CoordRec((float) 57.1429, (float) 76.1905 ),
+    new CoordRec((float) 57.1429, (float) 85.7143 ),
+    new CoordRec((float) 52.3809, (float) 95.2381 ),
+    new CoordRec((float) 42.8571, (float) 100 ),
+    new CoordRec((float) 33.3333, (float) 95.2381 ),
+    new CoordRec((float) 28.5714, (float) 85.7143 ),
+    new CoordRec((float) 28.5714, (float) 76.1905 ),
+    new CoordRec((float) 33.3333, (float) 61.9048 ),
+    new CoordRec((float) 42.8571, (float) 47.619 ),
+    new CoordRec((float) 66.6667, (float) 14.2857 ),
+    new CoordRec((float) 76.1905, (float) 4.7619 ),
+    new CoordRec((float) 85.7143, (float) 0 ),
+    new CoordRec((float) 95.2381, (float) 0 ),
+    new CoordRec((float) 100, (float) 4.7619 ),
+    new CoordRec((float) 100, (float) 9.5238 ),
+};
+
+static final StrokeRec char38[] = {
+   new StrokeRec( 34, char38_stroke0 ),
+};
+
+/* char: 39 ''' */
+
+static final CoordRec char39_stroke0[] = {
+    new CoordRec((float) 52.381, (float) 100 ),
+    new CoordRec((float) 52.381, (float) 66.6667 ),
+};
+
+static final StrokeRec char39[] = {
+   new StrokeRec( 2, char39_stroke0 ),
+};
+
+/* char: 40 '(' */
+
+static final CoordRec char40_stroke0[] = {
+    new CoordRec((float) 69.0476, (float) 119.048 ),
+    new CoordRec((float) 59.5238, (float) 109.524 ),
+    new CoordRec((float) 50, (float) 95.2381 ),
+    new CoordRec((float) 40.4762, (float) 76.1905 ),
+    new CoordRec((float) 35.7143, (float) 52.381 ),
+    new CoordRec((float) 35.7143, (float) 33.3333 ),
+    new CoordRec((float) 40.4762, (float) 9.5238 ),
+    new CoordRec((float) 50, (float) -9.5238 ),
+    new CoordRec((float) 59.5238, (float) -23.8095 ),
+    new CoordRec((float) 69.0476, (float) -33.3333 ),
+};
+
+static final StrokeRec char40[] = {
+   new StrokeRec( 10, char40_stroke0 ),
+};
+
+/* char: 41 ')' */
+
+static final CoordRec char41_stroke0[] = {
+    new CoordRec((float) 35.7143, (float) 119.048 ),
+    new CoordRec((float) 45.2381, (float) 109.524 ),
+    new CoordRec((float) 54.7619, (float) 95.2381 ),
+    new CoordRec((float) 64.2857, (float) 76.1905 ),
+    new CoordRec((float) 69.0476, (float) 52.381 ),
+    new CoordRec((float) 69.0476, (float) 33.3333 ),
+    new CoordRec((float) 64.2857, (float) 9.5238 ),
+    new CoordRec((float) 54.7619, (float) -9.5238 ),
+    new CoordRec((float) 45.2381, (float) -23.8095 ),
+    new CoordRec((float) 35.7143, (float) -33.3333 ),
+};
+
+static final StrokeRec char41[] = {
+   new StrokeRec( 10, char41_stroke0 ),
+};
+
+/* char: 42 '*' */
+
+static final CoordRec char42_stroke0[] = {
+    new CoordRec((float) 52.381, (float) 71.4286 ),
+    new CoordRec((float) 52.381, (float) 14.2857 ),
+};
+
+static final CoordRec char42_stroke1[] = {
+    new CoordRec((float) 28.5715, (float) 57.1429 ),
+    new CoordRec((float) 76.1905, (float) 28.5714 ),
+};
+
+static final CoordRec char42_stroke2[] = {
+    new CoordRec((float) 76.1905, (float) 57.1429 ),
+    new CoordRec((float) 28.5715, (float) 28.5714 ),
+};
+
+static final StrokeRec char42[] = {
+   new StrokeRec( 2, char42_stroke0 ),
+   new StrokeRec( 2, char42_stroke1 ),
+   new StrokeRec( 2, char42_stroke2 ),
+};
+
+/* char: 43 '+' */
+
+static final CoordRec char43_stroke0[] = {
+    new CoordRec((float) 52.3809, (float) 85.7143 ),
+    new CoordRec((float) 52.3809, (float) 0 ),
+};
+
+static final CoordRec char43_stroke1[] = {
+    new CoordRec((float) 9.5238, (float) 42.8571 ),
+    new CoordRec((float) 95.2381, (float) 42.8571 ),
+};
+
+static final StrokeRec char43[] = {
+   new StrokeRec( 2, char43_stroke0 ),
+   new StrokeRec( 2, char43_stroke1 ),
+};
+
+/* char: 44 ',' */
+
+static final CoordRec char44_stroke0[] = {
+    new CoordRec((float) 57.1429, (float) 4.7619 ),
+    new CoordRec((float) 52.381, (float) 0 ),
+    new CoordRec((float) 47.6191, (float) 4.7619 ),
+    new CoordRec((float) 52.381, (float) 9.5238 ),
+    new CoordRec((float) 57.1429, (float) 4.7619 ),
+    new CoordRec((float) 57.1429, (float) -4.7619 ),
+    new CoordRec((float) 52.381, (float) -14.2857 ),
+    new CoordRec((float) 47.6191, (float) -19.0476 ),
+};
+
+static final StrokeRec char44[] = {
+   new StrokeRec( 8, char44_stroke0 ),
+};
+
+/* char: 45 '-' */
+
+static final CoordRec char45_stroke0[] = {
+    new CoordRec((float) 9.5238, (float) 42.8571 ),
+    new CoordRec((float) 95.2381, (float) 42.8571 ),
+};
+
+static final StrokeRec char45[] = {
+   new StrokeRec( 2, char45_stroke0 ),
+};
+
+/* char: 46 '.' */
+
+static final CoordRec char46_stroke0[] = {
+    new CoordRec((float) 52.381, (float) 9.5238 ),
+    new CoordRec((float) 47.6191, (float) 4.7619 ),
+    new CoordRec((float) 52.381, (float) 0 ),
+    new CoordRec((float) 57.1429, (float) 4.7619 ),
+    new CoordRec((float) 52.381, (float) 9.5238 ),
+};
+
+static final StrokeRec char46[] = {
+   new StrokeRec( 5, char46_stroke0 ),
+};
+
+/* char: 47 '/' */
+
+static final CoordRec char47_stroke0[] = {
+    new CoordRec((float) 19.0476, (float) -14.2857 ),
+    new CoordRec((float) 85.7143, (float) 100 ),
+};
+
+static final StrokeRec char47[] = {
+   new StrokeRec( 2, char47_stroke0 ),
+};
+
+/* char: 48 '0' */
+
+static final CoordRec char48_stroke0[] = {
+    new CoordRec((float) 47.619, (float) 100 ),
+    new CoordRec((float) 33.3333, (float) 95.2381 ),
+    new CoordRec((float) 23.8095, (float) 80.9524 ),
+    new CoordRec((float) 19.0476, (float) 57.1429 ),
+    new CoordRec((float) 19.0476, (float) 42.8571 ),
+    new CoordRec((float) 23.8095, (float) 19.0476 ),
+    new CoordRec((float) 33.3333, (float) 4.7619 ),
+    new CoordRec((float) 47.619, (float) 0 ),
+    new CoordRec((float) 57.1428, (float) 0 ),
+    new CoordRec((float) 71.4286, (float) 4.7619 ),
+    new CoordRec((float) 80.9524, (float) 19.0476 ),
+    new CoordRec((float) 85.7143, (float) 42.8571 ),
+    new CoordRec((float) 85.7143, (float) 57.1429 ),
+    new CoordRec((float) 80.9524, (float) 80.9524 ),
+    new CoordRec((float) 71.4286, (float) 95.2381 ),
+    new CoordRec((float) 57.1428, (float) 100 ),
+    new CoordRec((float) 47.619, (float) 100 ),
+};
+
+static final StrokeRec char48[] = {
+   new StrokeRec( 17, char48_stroke0 ),
+};
+
+/* char: 49 '1' */
+
+static final CoordRec char49_stroke0[] = {
+    new CoordRec((float) 40.4762, (float) 80.9524 ),
+    new CoordRec((float) 50, (float) 85.7143 ),
+    new CoordRec((float) 64.2857, (float) 100 ),
+    new CoordRec((float) 64.2857, (float) 0 ),
+};
+
+static final StrokeRec char49[] = {
+   new StrokeRec( 4, char49_stroke0 ),
+};
+
+/* char: 50 '2' */
+
+static final CoordRec char50_stroke0[] = {
+    new CoordRec((float) 23.8095, (float) 76.1905 ),
+    new CoordRec((float) 23.8095, (float) 80.9524 ),
+    new CoordRec((float) 28.5714, (float) 90.4762 ),
+    new CoordRec((float) 33.3333, (float) 95.2381 ),
+    new CoordRec((float) 42.8571, (float) 100 ),
+    new CoordRec((float) 61.9047, (float) 100 ),
+    new CoordRec((float) 71.4286, (float) 95.2381 ),
+    new CoordRec((float) 76.1905, (float) 90.4762 ),
+    new CoordRec((float) 80.9524, (float) 80.9524 ),
+    new CoordRec((float) 80.9524, (float) 71.4286 ),
+    new CoordRec((float) 76.1905, (float) 61.9048 ),
+    new CoordRec((float) 66.6666, (float) 47.619 ),
+    new CoordRec((float) 19.0476, (float) 0 ),
+    new CoordRec((float) 85.7143, (float) 0 ),
+};
+
+static final StrokeRec char50[] = {
+   new StrokeRec( 14, char50_stroke0 ),
+};
+
+/* char: 51 '3' */
+
+static final CoordRec char51_stroke0[] = {
+    new CoordRec((float) 28.5714, (float) 100 ),
+    new CoordRec((float) 80.9524, (float) 100 ),
+    new CoordRec((float) 52.3809, (float) 61.9048 ),
+    new CoordRec((float) 66.6666, (float) 61.9048 ),
+    new CoordRec((float) 76.1905, (float) 57.1429 ),
+    new CoordRec((float) 80.9524, (float) 52.381 ),
+    new CoordRec((float) 85.7143, (float) 38.0952 ),
+    new CoordRec((float) 85.7143, (float) 28.5714 ),
+    new CoordRec((float) 80.9524, (float) 14.2857 ),
+    new CoordRec((float) 71.4286, (float) 4.7619 ),
+    new CoordRec((float) 57.1428, (float) 0 ),
+    new CoordRec((float) 42.8571, (float) 0 ),
+    new CoordRec((float) 28.5714, (float) 4.7619 ),
+    new CoordRec((float) 23.8095, (float) 9.5238 ),
+    new CoordRec((float) 19.0476, (float) 19.0476 ),
+};
+
+static final StrokeRec char51[] = {
+   new StrokeRec( 15, char51_stroke0 ),
+};
+
+/* char: 52 '4' */
+
+static final CoordRec char52_stroke0[] = {
+    new CoordRec((float) 64.2857, (float) 100 ),
+    new CoordRec((float) 16.6667, (float) 33.3333 ),
+    new CoordRec((float) 88.0952, (float) 33.3333 ),
+};
+
+static final CoordRec char52_stroke1[] = {
+    new CoordRec((float) 64.2857, (float) 100 ),
+    new CoordRec((float) 64.2857, (float) 0 ),
+};
+
+static final StrokeRec char52[] = {
+   new StrokeRec( 3, char52_stroke0 ),
+   new StrokeRec( 2, char52_stroke1 ),
+};
+
+/* char: 53 '5' */
+
+static final CoordRec char53_stroke0[] = {
+    new CoordRec((float) 76.1905, (float) 100 ),
+    new CoordRec((float) 28.5714, (float) 100 ),
+    new CoordRec((float) 23.8095, (float) 57.1429 ),
+    new CoordRec((float) 28.5714, (float) 61.9048 ),
+    new CoordRec((float) 42.8571, (float) 66.6667 ),
+    new CoordRec((float) 57.1428, (float) 66.6667 ),
+    new CoordRec((float) 71.4286, (float) 61.9048 ),
+    new CoordRec((float) 80.9524, (float) 52.381 ),
+    new CoordRec((float) 85.7143, (float) 38.0952 ),
+    new CoordRec((float) 85.7143, (float) 28.5714 ),
+    new CoordRec((float) 80.9524, (float) 14.2857 ),
+    new CoordRec((float) 71.4286, (float) 4.7619 ),
+    new CoordRec((float) 57.1428, (float) 0 ),
+    new CoordRec((float) 42.8571, (float) 0 ),
+    new CoordRec((float) 28.5714, (float) 4.7619 ),
+    new CoordRec((float) 23.8095, (float) 9.5238 ),
+    new CoordRec((float) 19.0476, (float) 19.0476 ),
+};
+
+static final StrokeRec char53[] = {
+   new StrokeRec( 17, char53_stroke0 ),
+};
+
+/* char: 54 '6' */
+
+static final CoordRec char54_stroke0[] = {
+    new CoordRec((float) 78.5714, (float) 85.7143 ),
+    new CoordRec((float) 73.8096, (float) 95.2381 ),
+    new CoordRec((float) 59.5238, (float) 100 ),
+    new CoordRec((float) 50, (float) 100 ),
+    new CoordRec((float) 35.7143, (float) 95.2381 ),
+    new CoordRec((float) 26.1905, (float) 80.9524 ),
+    new CoordRec((float) 21.4286, (float) 57.1429 ),
+    new CoordRec((float) 21.4286, (float) 33.3333 ),
+    new CoordRec((float) 26.1905, (float) 14.2857 ),
+    new CoordRec((float) 35.7143, (float) 4.7619 ),
+    new CoordRec((float) 50, (float) 0 ),
+    new CoordRec((float) 54.7619, (float) 0 ),
+    new CoordRec((float) 69.0476, (float) 4.7619 ),
+    new CoordRec((float) 78.5714, (float) 14.2857 ),
+    new CoordRec((float) 83.3334, (float) 28.5714 ),
+    new CoordRec((float) 83.3334, (float) 33.3333 ),
+    new CoordRec((float) 78.5714, (float) 47.619 ),
+    new CoordRec((float) 69.0476, (float) 57.1429 ),
+    new CoordRec((float) 54.7619, (float) 61.9048 ),
+    new CoordRec((float) 50, (float) 61.9048 ),
+    new CoordRec((float) 35.7143, (float) 57.1429 ),
+    new CoordRec((float) 26.1905, (float) 47.619 ),
+    new CoordRec((float) 21.4286, (float) 33.3333 ),
+};
+
+static final StrokeRec char54[] = {
+   new StrokeRec( 23, char54_stroke0 ),
+};
+
+/* char: 55 '7' */
+
+static final CoordRec char55_stroke0[] = {
+    new CoordRec((float) 85.7143, (float) 100 ),
+    new CoordRec((float) 38.0952, (float) 0 ),
+};
+
+static final CoordRec char55_stroke1[] = {
+    new CoordRec((float) 19.0476, (float) 100 ),
+    new CoordRec((float) 85.7143, (float) 100 ),
+};
+
+static final StrokeRec char55[] = {
+   new StrokeRec( 2, char55_stroke0 ),
+   new StrokeRec( 2, char55_stroke1 ),
+};
+
+/* char: 56 '8' */
+
+static final CoordRec char56_stroke0[] = {
+    new CoordRec((float) 42.8571, (float) 100 ),
+    new CoordRec((float) 28.5714, (float) 95.2381 ),
+    new CoordRec((float) 23.8095, (float) 85.7143 ),
+    new CoordRec((float) 23.8095, (float) 76.1905 ),
+    new CoordRec((float) 28.5714, (float) 66.6667 ),
+    new CoordRec((float) 38.0952, (float) 61.9048 ),
+    new CoordRec((float) 57.1428, (float) 57.1429 ),
+    new CoordRec((float) 71.4286, (float) 52.381 ),
+    new CoordRec((float) 80.9524, (float) 42.8571 ),
+    new CoordRec((float) 85.7143, (float) 33.3333 ),
+    new CoordRec((float) 85.7143, (float) 19.0476 ),
+    new CoordRec((float) 80.9524, (float) 9.5238 ),
+    new CoordRec((float) 76.1905, (float) 4.7619 ),
+    new CoordRec((float) 61.9047, (float) 0 ),
+    new CoordRec((float) 42.8571, (float) 0 ),
+    new CoordRec((float) 28.5714, (float) 4.7619 ),
+    new CoordRec((float) 23.8095, (float) 9.5238 ),
+    new CoordRec((float) 19.0476, (float) 19.0476 ),
+    new CoordRec((float) 19.0476, (float) 33.3333 ),
+    new CoordRec((float) 23.8095, (float) 42.8571 ),
+    new CoordRec((float) 33.3333, (float) 52.381 ),
+    new CoordRec((float) 47.619, (float) 57.1429 ),
+    new CoordRec((float) 66.6666, (float) 61.9048 ),
+    new CoordRec((float) 76.1905, (float) 66.6667 ),
+    new CoordRec((float) 80.9524, (float) 76.1905 ),
+    new CoordRec((float) 80.9524, (float) 85.7143 ),
+    new CoordRec((float) 76.1905, (float) 95.2381 ),
+    new CoordRec((float) 61.9047, (float) 100 ),
+    new CoordRec((float) 42.8571, (float) 100 ),
+};
+
+static final StrokeRec char56[] = {
+   new StrokeRec( 29, char56_stroke0 ),
+};
+
+/* char: 57 '9' */
+
+static final CoordRec char57_stroke0[] = {
+    new CoordRec((float) 83.3334, (float) 66.6667 ),
+    new CoordRec((float) 78.5714, (float) 52.381 ),
+    new CoordRec((float) 69.0476, (float) 42.8571 ),
+    new CoordRec((float) 54.7619, (float) 38.0952 ),
+    new CoordRec((float) 50, (float) 38.0952 ),
+    new CoordRec((float) 35.7143, (float) 42.8571 ),
+    new CoordRec((float) 26.1905, (float) 52.381 ),
+    new CoordRec((float) 21.4286, (float) 66.6667 ),
+    new CoordRec((float) 21.4286, (float) 71.4286 ),
+    new CoordRec((float) 26.1905, (float) 85.7143 ),
+    new CoordRec((float) 35.7143, (float) 95.2381 ),
+    new CoordRec((float) 50, (float) 100 ),
+    new CoordRec((float) 54.7619, (float) 100 ),
+    new CoordRec((float) 69.0476, (float) 95.2381 ),
+    new CoordRec((float) 78.5714, (float) 85.7143 ),
+    new CoordRec((float) 83.3334, (float) 66.6667 ),
+    new CoordRec((float) 83.3334, (float) 42.8571 ),
+    new CoordRec((float) 78.5714, (float) 19.0476 ),
+    new CoordRec((float) 69.0476, (float) 4.7619 ),
+    new CoordRec((float) 54.7619, (float) 0 ),
+    new CoordRec((float) 45.2381, (float) 0 ),
+    new CoordRec((float) 30.9524, (float) 4.7619 ),
+    new CoordRec((float) 26.1905, (float) 14.2857 ),
+};
+
+static final StrokeRec char57[] = {
+   new StrokeRec( 23, char57_stroke0 ),
+};
+
+/* char: 58 ':' */
+
+static final CoordRec char58_stroke0[] = {
+    new CoordRec((float) 52.381, (float) 66.6667 ),
+    new CoordRec((float) 47.6191, (float) 61.9048 ),
+    new CoordRec((float) 52.381, (float) 57.1429 ),
+    new CoordRec((float) 57.1429, (float) 61.9048 ),
+    new CoordRec((float) 52.381, (float) 66.6667 ),
+};
+
+static final CoordRec char58_stroke1[] = {
+    new CoordRec((float) 52.381, (float) 9.5238 ),
+    new CoordRec((float) 47.6191, (float) 4.7619 ),
+    new CoordRec((float) 52.381, (float) 0 ),
+    new CoordRec((float) 57.1429, (float) 4.7619 ),
+    new CoordRec((float) 52.381, (float) 9.5238 ),
+};
+
+static final StrokeRec char58[] = {
+   new StrokeRec( 5, char58_stroke0 ),
+   new StrokeRec( 5, char58_stroke1 ),
+};
+
+/* char: 59 ';' */
+
+static final CoordRec char59_stroke0[] = {
+    new CoordRec((float) 52.381, (float) 66.6667 ),
+    new CoordRec((float) 47.6191, (float) 61.9048 ),
+    new CoordRec((float) 52.381, (float) 57.1429 ),
+    new CoordRec((float) 57.1429, (float) 61.9048 ),
+    new CoordRec((float) 52.381, (float) 66.6667 ),
+};
+
+static final CoordRec char59_stroke1[] = {
+    new CoordRec((float) 57.1429, (float) 4.7619 ),
+    new CoordRec((float) 52.381, (float) 0 ),
+    new CoordRec((float) 47.6191, (float) 4.7619 ),
+    new CoordRec((float) 52.381, (float) 9.5238 ),
+    new CoordRec((float) 57.1429, (float) 4.7619 ),
+    new CoordRec((float) 57.1429, (float) -4.7619 ),
+    new CoordRec((float) 52.381, (float) -14.2857 ),
+    new CoordRec((float) 47.6191, (float) -19.0476 ),
+};
+
+static final StrokeRec char59[] = {
+   new StrokeRec( 5, char59_stroke0 ),
+   new StrokeRec( 8, char59_stroke1 ),
+};
+
+/* char: 60 '<' */
+
+static final CoordRec char60_stroke0[] = {
+    new CoordRec((float) 90.4762, (float) 85.7143 ),
+    new CoordRec((float) 14.2857, (float) 42.8571 ),
+    new CoordRec((float) 90.4762, (float) 0 ),
+};
+
+static final StrokeRec char60[] = {
+   new StrokeRec( 3, char60_stroke0 ),
+};
+
+/* char: 61 '=' */
+
+static final CoordRec char61_stroke0[] = {
+    new CoordRec((float) 9.5238, (float) 57.1429 ),
+    new CoordRec((float) 95.2381, (float) 57.1429 ),
+};
+
+static final CoordRec char61_stroke1[] = {
+    new CoordRec((float) 9.5238, (float) 28.5714 ),
+    new CoordRec((float) 95.2381, (float) 28.5714 ),
+};
+
+static final StrokeRec char61[] = {
+   new StrokeRec( 2, char61_stroke0 ),
+   new StrokeRec( 2, char61_stroke1 ),
+};
+
+/* char: 62 '>' */
+
+static final CoordRec char62_stroke0[] = {
+    new CoordRec((float) 14.2857, (float) 85.7143 ),
+    new CoordRec((float) 90.4762, (float) 42.8571 ),
+    new CoordRec((float) 14.2857, (float) 0 ),
+};
+
+static final StrokeRec char62[] = {
+   new StrokeRec( 3, char62_stroke0 ),
+};
+
+/* char: 63 '?' */
+
+static final CoordRec char63_stroke0[] = {
+    new CoordRec((float) 23.8095, (float) 76.1905 ),
+    new CoordRec((float) 23.8095, (float) 80.9524 ),
+    new CoordRec((float) 28.5714, (float) 90.4762 ),
+    new CoordRec((float) 33.3333, (float) 95.2381 ),
+    new CoordRec((float) 42.8571, (float) 100 ),
+    new CoordRec((float) 61.9047, (float) 100 ),
+    new CoordRec((float) 71.4285, (float) 95.2381 ),
+    new CoordRec((float) 76.1905, (float) 90.4762 ),
+    new CoordRec((float) 80.9524, (float) 80.9524 ),
+    new CoordRec((float) 80.9524, (float) 71.4286 ),
+    new CoordRec((float) 76.1905, (float) 61.9048 ),
+    new CoordRec((float) 71.4285, (float) 57.1429 ),
+    new CoordRec((float) 52.3809, (float) 47.619 ),
+    new CoordRec((float) 52.3809, (float) 33.3333 ),
+};
+
+static final CoordRec char63_stroke1[] = {
+    new CoordRec((float) 52.3809, (float) 9.5238 ),
+    new CoordRec((float) 47.619, (float) 4.7619 ),
+    new CoordRec((float) 52.3809, (float) 0 ),
+    new CoordRec((float) 57.1428, (float) 4.7619 ),
+    new CoordRec((float) 52.3809, (float) 9.5238 ),
+};
+
+static final StrokeRec char63[] = {
+   new StrokeRec( 14, char63_stroke0 ),
+   new StrokeRec( 5, char63_stroke1 ),
+};
+
+/* char: 64 '@' */
+
+static final CoordRec char64_stroke0[] = {
+    new CoordRec((float) 64.2857, (float) 52.381 ),
+    new CoordRec((float) 54.7619, (float) 57.1429 ),
+    new CoordRec((float) 45.2381, (float) 57.1429 ),
+    new CoordRec((float) 40.4762, (float) 47.619 ),
+    new CoordRec((float) 40.4762, (float) 42.8571 ),
+    new CoordRec((float) 45.2381, (float) 33.3333 ),
+    new CoordRec((float) 54.7619, (float) 33.3333 ),
+    new CoordRec((float) 64.2857, (float) 38.0952 ),
+};
+
+static final CoordRec char64_stroke1[] = {
+    new CoordRec((float) 64.2857, (float) 57.1429 ),
+    new CoordRec((float) 64.2857, (float) 38.0952 ),
+    new CoordRec((float) 69.0476, (float) 33.3333 ),
+    new CoordRec((float) 78.5714, (float) 33.3333 ),
+    new CoordRec((float) 83.3334, (float) 42.8571 ),
+    new CoordRec((float) 83.3334, (float) 47.619 ),
+    new CoordRec((float) 78.5714, (float) 61.9048 ),
+    new CoordRec((float) 69.0476, (float) 71.4286 ),
+    new CoordRec((float) 54.7619, (float) 76.1905 ),
+    new CoordRec((float) 50, (float) 76.1905 ),
+    new CoordRec((float) 35.7143, (float) 71.4286 ),
+    new CoordRec((float) 26.1905, (float) 61.9048 ),
+    new CoordRec((float) 21.4286, (float) 47.619 ),
+    new CoordRec((float) 21.4286, (float) 42.8571 ),
+    new CoordRec((float) 26.1905, (float) 28.5714 ),
+    new CoordRec((float) 35.7143, (float) 19.0476 ),
+    new CoordRec((float) 50, (float) 14.2857 ),
+    new CoordRec((float) 54.7619, (float) 14.2857 ),
+    new CoordRec((float) 69.0476, (float) 19.0476 ),
+};
+
+static final StrokeRec char64[] = {
+   new StrokeRec( 8, char64_stroke0 ),
+   new StrokeRec( 19, char64_stroke1 ),
+};
+
+/* char: 65 'A' */
+
+static final CoordRec char65_stroke0[] = {
+    new CoordRec((float) 52.3809, (float) 100 ),
+    new CoordRec((float) 14.2857, (float) 0 ),
+};
+
+static final CoordRec char65_stroke1[] = {
+    new CoordRec((float) 52.3809, (float) 100 ),
+    new CoordRec((float) 90.4762, (float) 0 ),
+};
+
+static final CoordRec char65_stroke2[] = {
+    new CoordRec((float) 28.5714, (float) 33.3333 ),
+    new CoordRec((float) 76.1905, (float) 33.3333 ),
+};
+
+static final StrokeRec char65[] = {
+   new StrokeRec( 2, char65_stroke0 ),
+   new StrokeRec( 2, char65_stroke1 ),
+   new StrokeRec( 2, char65_stroke2 ),
+};
+
+/* char: 66 'B' */
+
+static final CoordRec char66_stroke0[] = {
+    new CoordRec((float) 19.0476, (float) 100 ),
+    new CoordRec((float) 19.0476, (float) 0 ),
+};
+
+static final CoordRec char66_stroke1[] = {
+    new CoordRec((float) 19.0476, (float) 100 ),
+    new CoordRec((float) 61.9047, (float) 100 ),
+    new CoordRec((float) 76.1905, (float) 95.2381 ),
+    new CoordRec((float) 80.9524, (float) 90.4762 ),
+    new CoordRec((float) 85.7143, (float) 80.9524 ),
+    new CoordRec((float) 85.7143, (float) 71.4286 ),
+    new CoordRec((float) 80.9524, (float) 61.9048 ),
+    new CoordRec((float) 76.1905, (float) 57.1429 ),
+    new CoordRec((float) 61.9047, (float) 52.381 ),
+};
+
+static final CoordRec char66_stroke2[] = {
+    new CoordRec((float) 19.0476, (float) 52.381 ),
+    new CoordRec((float) 61.9047, (float) 52.381 ),
+    new CoordRec((float) 76.1905, (float) 47.619 ),
+    new CoordRec((float) 80.9524, (float) 42.8571 ),
+    new CoordRec((float) 85.7143, (float) 33.3333 ),
+    new CoordRec((float) 85.7143, (float) 19.0476 ),
+    new CoordRec((float) 80.9524, (float) 9.5238 ),
+    new CoordRec((float) 76.1905, (float) 4.7619 ),
+    new CoordRec((float) 61.9047, (float) 0 ),
+    new CoordRec((float) 19.0476, (float) 0 ),
+};
+
+static final StrokeRec char66[] = {
+   new StrokeRec( 2, char66_stroke0 ),
+   new StrokeRec( 9, char66_stroke1 ),
+   new StrokeRec( 10, char66_stroke2 ),
+};
+
+/* char: 67 'C' */
+
+static final CoordRec char67_stroke0[] = {
+    new CoordRec((float) 88.0952, (float) 76.1905 ),
+    new CoordRec((float) 83.3334, (float) 85.7143 ),
+    new CoordRec((float) 73.8096, (float) 95.2381 ),
+    new CoordRec((float) 64.2857, (float) 100 ),
+    new CoordRec((float) 45.2381, (float) 100 ),
+    new CoordRec((float) 35.7143, (float) 95.2381 ),
+    new CoordRec((float) 26.1905, (float) 85.7143 ),
+    new CoordRec((float) 21.4286, (float) 76.1905 ),
+    new CoordRec((float) 16.6667, (float) 61.9048 ),
+    new CoordRec((float) 16.6667, (float) 38.0952 ),
+    new CoordRec((float) 21.4286, (float) 23.8095 ),
+    new CoordRec((float) 26.1905, (float) 14.2857 ),
+    new CoordRec((float) 35.7143, (float) 4.7619 ),
+    new CoordRec((float) 45.2381, (float) 0 ),
+    new CoordRec((float) 64.2857, (float) 0 ),
+    new CoordRec((float) 73.8096, (float) 4.7619 ),
+    new CoordRec((float) 83.3334, (float) 14.2857 ),
+    new CoordRec((float) 88.0952, (float) 23.8095 ),
+};
+
+static final StrokeRec char67[] = {
+   new StrokeRec( 18, char67_stroke0 ),
+};
+
+/* char: 68 'D' */
+
+static final CoordRec char68_stroke0[] = {
+    new CoordRec((float) 19.0476, (float) 100 ),
+    new CoordRec((float) 19.0476, (float) 0 ),
+};
+
+static final CoordRec char68_stroke1[] = {
+    new CoordRec((float) 19.0476, (float) 100 ),
+    new CoordRec((float) 52.3809, (float) 100 ),
+    new CoordRec((float) 66.6666, (float) 95.2381 ),
+    new CoordRec((float) 76.1905, (float) 85.7143 ),
+    new CoordRec((float) 80.9524, (float) 76.1905 ),
+    new CoordRec((float) 85.7143, (float) 61.9048 ),
+    new CoordRec((float) 85.7143, (float) 38.0952 ),
+    new CoordRec((float) 80.9524, (float) 23.8095 ),
+    new CoordRec((float) 76.1905, (float) 14.2857 ),
+    new CoordRec((float) 66.6666, (float) 4.7619 ),
+    new CoordRec((float) 52.3809, (float) 0 ),
+    new CoordRec((float) 19.0476, (float) 0 ),
+};
+
+static final StrokeRec char68[] = {
+   new StrokeRec( 2, char68_stroke0 ),
+   new StrokeRec( 12, char68_stroke1 ),
+};
+
+/* char: 69 'E' */
+
+static final CoordRec char69_stroke0[] = {
+    new CoordRec((float) 21.4286, (float) 100 ),
+    new CoordRec((float) 21.4286, (float) 0 ),
+};
+
+static final CoordRec char69_stroke1[] = {
+    new CoordRec((float) 21.4286, (float) 100 ),
+    new CoordRec((float) 83.3334, (float) 100 ),
+};
+
+static final CoordRec char69_stroke2[] = {
+    new CoordRec((float) 21.4286, (float) 52.381 ),
+    new CoordRec((float) 59.5238, (float) 52.381 ),
+};
+
+static final CoordRec char69_stroke3[] = {
+    new CoordRec((float) 21.4286, (float) 0 ),
+    new CoordRec((float) 83.3334, (float) 0 ),
+};
+
+static final StrokeRec char69[] = {
+   new StrokeRec( 2, char69_stroke0 ),
+   new StrokeRec( 2, char69_stroke1 ),
+   new StrokeRec( 2, char69_stroke2 ),
+   new StrokeRec( 2, char69_stroke3 ),
+};
+
+/* char: 70 'F' */
+
+static final CoordRec char70_stroke0[] = {
+    new CoordRec((float) 21.4286, (float) 100 ),
+    new CoordRec((float) 21.4286, (float) 0 ),
+};
+
+static final CoordRec char70_stroke1[] = {
+    new CoordRec((float) 21.4286, (float) 100 ),
+    new CoordRec((float) 83.3334, (float) 100 ),
+};
+
+static final CoordRec char70_stroke2[] = {
+    new CoordRec((float) 21.4286, (float) 52.381 ),
+    new CoordRec((float) 59.5238, (float) 52.381 ),
+};
+
+static final StrokeRec char70[] = {
+   new StrokeRec( 2, char70_stroke0 ),
+   new StrokeRec( 2, char70_stroke1 ),
+   new StrokeRec( 2, char70_stroke2 ),
+};
+
+/* char: 71 'G' */
+
+static final CoordRec char71_stroke0[] = {
+    new CoordRec((float) 88.0952, (float) 76.1905 ),
+    new CoordRec((float) 83.3334, (float) 85.7143 ),
+    new CoordRec((float) 73.8096, (float) 95.2381 ),
+    new CoordRec((float) 64.2857, (float) 100 ),
+    new CoordRec((float) 45.2381, (float) 100 ),
+    new CoordRec((float) 35.7143, (float) 95.2381 ),
+    new CoordRec((float) 26.1905, (float) 85.7143 ),
+    new CoordRec((float) 21.4286, (float) 76.1905 ),
+    new CoordRec((float) 16.6667, (float) 61.9048 ),
+    new CoordRec((float) 16.6667, (float) 38.0952 ),
+    new CoordRec((float) 21.4286, (float) 23.8095 ),
+    new CoordRec((float) 26.1905, (float) 14.2857 ),
+    new CoordRec((float) 35.7143, (float) 4.7619 ),
+    new CoordRec((float) 45.2381, (float) 0 ),
+    new CoordRec((float) 64.2857, (float) 0 ),
+    new CoordRec((float) 73.8096, (float) 4.7619 ),
+    new CoordRec((float) 83.3334, (float) 14.2857 ),
+    new CoordRec((float) 88.0952, (float) 23.8095 ),
+    new CoordRec((float) 88.0952, (float) 38.0952 ),
+};
+
+static final CoordRec char71_stroke1[] = {
+    new CoordRec((float) 64.2857, (float) 38.0952 ),
+    new CoordRec((float) 88.0952, (float) 38.0952 ),
+};
+
+static final StrokeRec char71[] = {
+   new StrokeRec( 19, char71_stroke0 ),
+   new StrokeRec( 2, char71_stroke1 ),
+};
+
+/* char: 72 'H' */
+
+static final CoordRec char72_stroke0[] = {
+    new CoordRec((float) 19.0476, (float) 100 ),
+    new CoordRec((float) 19.0476, (float) 0 ),
+};
+
+static final CoordRec char72_stroke1[] = {
+    new CoordRec((float) 85.7143, (float) 100 ),
+    new CoordRec((float) 85.7143, (float) 0 ),
+};
+
+static final CoordRec char72_stroke2[] = {
+    new CoordRec((float) 19.0476, (float) 52.381 ),
+    new CoordRec((float) 85.7143, (float) 52.381 ),
+};
+
+static final StrokeRec char72[] = {
+   new StrokeRec( 2, char72_stroke0 ),
+   new StrokeRec( 2, char72_stroke1 ),
+   new StrokeRec( 2, char72_stroke2 ),
+};
+
+/* char: 73 'I' */
+
+static final CoordRec char73_stroke0[] = {
+    new CoordRec((float) 52.381, (float) 100 ),
+    new CoordRec((float) 52.381, (float) 0 ),
+};
+
+static final StrokeRec char73[] = {
+   new StrokeRec( 2, char73_stroke0 ),
+};
+
+/* char: 74 'J' */
+
+static final CoordRec char74_stroke0[] = {
+    new CoordRec((float) 76.1905, (float) 100 ),
+    new CoordRec((float) 76.1905, (float) 23.8095 ),
+    new CoordRec((float) 71.4286, (float) 9.5238 ),
+    new CoordRec((float) 66.6667, (float) 4.7619 ),
+    new CoordRec((float) 57.1429, (float) 0 ),
+    new CoordRec((float) 47.6191, (float) 0 ),
+    new CoordRec((float) 38.0953, (float) 4.7619 ),
+    new CoordRec((float) 33.3334, (float) 9.5238 ),
+    new CoordRec((float) 28.5715, (float) 23.8095 ),
+    new CoordRec((float) 28.5715, (float) 33.3333 ),
+};
+
+static final StrokeRec char74[] = {
+   new StrokeRec( 10, char74_stroke0 ),
+};
+
+/* char: 75 'K' */
+
+static final CoordRec char75_stroke0[] = {
+    new CoordRec((float) 19.0476, (float) 100 ),
+    new CoordRec((float) 19.0476, (float) 0 ),
+};
+
+static final CoordRec char75_stroke1[] = {
+    new CoordRec((float) 85.7143, (float) 100 ),
+    new CoordRec((float) 19.0476, (float) 33.3333 ),
+};
+
+static final CoordRec char75_stroke2[] = {
+    new CoordRec((float) 42.8571, (float) 57.1429 ),
+    new CoordRec((float) 85.7143, (float) 0 ),
+};
+
+static final StrokeRec char75[] = {
+   new StrokeRec( 2, char75_stroke0 ),
+   new StrokeRec( 2, char75_stroke1 ),
+   new StrokeRec( 2, char75_stroke2 ),
+};
+
+/* char: 76 'L' */
+
+static final CoordRec char76_stroke0[] = {
+    new CoordRec((float) 23.8095, (float) 100 ),
+    new CoordRec((float) 23.8095, (float) 0 ),
+};
+
+static final CoordRec char76_stroke1[] = {
+    new CoordRec((float) 23.8095, (float) 0 ),
+    new CoordRec((float) 80.9524, (float) 0 ),
+};
+
+static final StrokeRec char76[] = {
+   new StrokeRec( 2, char76_stroke0 ),
+   new StrokeRec( 2, char76_stroke1 ),
+};
+
+/* char: 77 'M' */
+
+static final CoordRec char77_stroke0[] = {
+    new CoordRec((float) 14.2857, (float) 100 ),
+    new CoordRec((float) 14.2857, (float) 0 ),
+};
+
+static final CoordRec char77_stroke1[] = {
+    new CoordRec((float) 14.2857, (float) 100 ),
+    new CoordRec((float) 52.3809, (float) 0 ),
+};
+
+static final CoordRec char77_stroke2[] = {
+    new CoordRec((float) 90.4762, (float) 100 ),
+    new CoordRec((float) 52.3809, (float) 0 ),
+};
+
+static final CoordRec char77_stroke3[] = {
+    new CoordRec((float) 90.4762, (float) 100 ),
+    new CoordRec((float) 90.4762, (float) 0 ),
+};
+
+static final StrokeRec char77[] = {
+   new StrokeRec( 2, char77_stroke0 ),
+   new StrokeRec( 2, char77_stroke1 ),
+   new StrokeRec( 2, char77_stroke2 ),
+   new StrokeRec( 2, char77_stroke3 ),
+};
+
+/* char: 78 'N' */
+
+static final CoordRec char78_stroke0[] = {
+    new CoordRec((float) 19.0476, (float) 100 ),
+    new CoordRec((float) 19.0476, (float) 0 ),
+};
+
+static final CoordRec char78_stroke1[] = {
+    new CoordRec((float) 19.0476, (float) 100 ),
+    new CoordRec((float) 85.7143, (float) 0 ),
+};
+
+static final CoordRec char78_stroke2[] = {
+    new CoordRec((float) 85.7143, (float) 100 ),
+    new CoordRec((float) 85.7143, (float) 0 ),
+};
+
+static final StrokeRec char78[] = {
+   new StrokeRec( 2, char78_stroke0 ),
+   new StrokeRec( 2, char78_stroke1 ),
+   new StrokeRec( 2, char78_stroke2 ),
+};
+
+/* char: 79 'O' */
+
+static final CoordRec char79_stroke0[] = {
+    new CoordRec((float) 42.8571, (float) 100 ),
+    new CoordRec((float) 33.3333, (float) 95.2381 ),
+    new CoordRec((float) 23.8095, (float) 85.7143 ),
+    new CoordRec((float) 19.0476, (float) 76.1905 ),
+    new CoordRec((float) 14.2857, (float) 61.9048 ),
+    new CoordRec((float) 14.2857, (float) 38.0952 ),
+    new CoordRec((float) 19.0476, (float) 23.8095 ),
+    new CoordRec((float) 23.8095, (float) 14.2857 ),
+    new CoordRec((float) 33.3333, (float) 4.7619 ),
+    new CoordRec((float) 42.8571, (float) 0 ),
+    new CoordRec((float) 61.9047, (float) 0 ),
+    new CoordRec((float) 71.4286, (float) 4.7619 ),
+    new CoordRec((float) 80.9524, (float) 14.2857 ),
+    new CoordRec((float) 85.7143, (float) 23.8095 ),
+    new CoordRec((float) 90.4762, (float) 38.0952 ),
+    new CoordRec((float) 90.4762, (float) 61.9048 ),
+    new CoordRec((float) 85.7143, (float) 76.1905 ),
+    new CoordRec((float) 80.9524, (float) 85.7143 ),
+    new CoordRec((float) 71.4286, (float) 95.2381 ),
+    new CoordRec((float) 61.9047, (float) 100 ),
+    new CoordRec((float) 42.8571, (float) 100 ),
+};
+
+static final StrokeRec char79[] = {
+   new StrokeRec( 21, char79_stroke0 ),
+};
+
+/* char: 80 'P' */
+
+static final CoordRec char80_stroke0[] = {
+    new CoordRec((float) 19.0476, (float) 100 ),
+    new CoordRec((float) 19.0476, (float) 0 ),
+};
+
+static final CoordRec char80_stroke1[] = {
+    new CoordRec((float) 19.0476, (float) 100 ),
+    new CoordRec((float) 61.9047, (float) 100 ),
+    new CoordRec((float) 76.1905, (float) 95.2381 ),
+    new CoordRec((float) 80.9524, (float) 90.4762 ),
+    new CoordRec((float) 85.7143, (float) 80.9524 ),
+    new CoordRec((float) 85.7143, (float) 66.6667 ),
+    new CoordRec((float) 80.9524, (float) 57.1429 ),
+    new CoordRec((float) 76.1905, (float) 52.381 ),
+    new CoordRec((float) 61.9047, (float) 47.619 ),
+    new CoordRec((float) 19.0476, (float) 47.619 ),
+};
+
+static final StrokeRec char80[] = {
+   new StrokeRec( 2, char80_stroke0 ),
+   new StrokeRec( 10, char80_stroke1 ),
+};
+
+/* char: 81 'Q' */
+
+static final CoordRec char81_stroke0[] = {
+    new CoordRec((float) 42.8571, (float) 100 ),
+    new CoordRec((float) 33.3333, (float) 95.2381 ),
+    new CoordRec((float) 23.8095, (float) 85.7143 ),
+    new CoordRec((float) 19.0476, (float) 76.1905 ),
+    new CoordRec((float) 14.2857, (float) 61.9048 ),
+    new CoordRec((float) 14.2857, (float) 38.0952 ),
+    new CoordRec((float) 19.0476, (float) 23.8095 ),
+    new CoordRec((float) 23.8095, (float) 14.2857 ),
+    new CoordRec((float) 33.3333, (float) 4.7619 ),
+    new CoordRec((float) 42.8571, (float) 0 ),
+    new CoordRec((float) 61.9047, (float) 0 ),
+    new CoordRec((float) 71.4286, (float) 4.7619 ),
+    new CoordRec((float) 80.9524, (float) 14.2857 ),
+    new CoordRec((float) 85.7143, (float) 23.8095 ),
+    new CoordRec((float) 90.4762, (float) 38.0952 ),
+    new CoordRec((float) 90.4762, (float) 61.9048 ),
+    new CoordRec((float) 85.7143, (float) 76.1905 ),
+    new CoordRec((float) 80.9524, (float) 85.7143 ),
+    new CoordRec((float) 71.4286, (float) 95.2381 ),
+    new CoordRec((float) 61.9047, (float) 100 ),
+    new CoordRec((float) 42.8571, (float) 100 ),
+};
+
+static final CoordRec char81_stroke1[] = {
+    new CoordRec((float) 57.1428, (float) 19.0476 ),
+    new CoordRec((float) 85.7143, (float) -9.5238 ),
+};
+
+static final StrokeRec char81[] = {
+   new StrokeRec( 21, char81_stroke0 ),
+   new StrokeRec( 2, char81_stroke1 ),
+};
+
+/* char: 82 'R' */
+
+static final CoordRec char82_stroke0[] = {
+    new CoordRec((float) 19.0476, (float) 100 ),
+    new CoordRec((float) 19.0476, (float) 0 ),
+};
+
+static final CoordRec char82_stroke1[] = {
+    new CoordRec((float) 19.0476, (float) 100 ),
+    new CoordRec((float) 61.9047, (float) 100 ),
+    new CoordRec((float) 76.1905, (float) 95.2381 ),
+    new CoordRec((float) 80.9524, (float) 90.4762 ),
+    new CoordRec((float) 85.7143, (float) 80.9524 ),
+    new CoordRec((float) 85.7143, (float) 71.4286 ),
+    new CoordRec((float) 80.9524, (float) 61.9048 ),
+    new CoordRec((float) 76.1905, (float) 57.1429 ),
+    new CoordRec((float) 61.9047, (float) 52.381 ),
+    new CoordRec((float) 19.0476, (float) 52.381 ),
+};
+
+static final CoordRec char82_stroke2[] = {
+    new CoordRec((float) 52.3809, (float) 52.381 ),
+    new CoordRec((float) 85.7143, (float) 0 ),
+};
+
+static final StrokeRec char82[] = {
+   new StrokeRec( 2, char82_stroke0 ),
+   new StrokeRec( 10, char82_stroke1 ),
+   new StrokeRec( 2, char82_stroke2 ),
+};
+
+/* char: 83 'S' */
+
+static final CoordRec char83_stroke0[] = {
+    new CoordRec((float) 85.7143, (float) 85.7143 ),
+    new CoordRec((float) 76.1905, (float) 95.2381 ),
+    new CoordRec((float) 61.9047, (float) 100 ),
+    new CoordRec((float) 42.8571, (float) 100 ),
+    new CoordRec((float) 28.5714, (float) 95.2381 ),
+    new CoordRec((float) 19.0476, (float) 85.7143 ),
+    new CoordRec((float) 19.0476, (float) 76.1905 ),
+    new CoordRec((float) 23.8095, (float) 66.6667 ),
+    new CoordRec((float) 28.5714, (float) 61.9048 ),
+    new CoordRec((float) 38.0952, (float) 57.1429 ),
+    new CoordRec((float) 66.6666, (float) 47.619 ),
+    new CoordRec((float) 76.1905, (float) 42.8571 ),
+    new CoordRec((float) 80.9524, (float) 38.0952 ),
+    new CoordRec((float) 85.7143, (float) 28.5714 ),
+    new CoordRec((float) 85.7143, (float) 14.2857 ),
+    new CoordRec((float) 76.1905, (float) 4.7619 ),
+    new CoordRec((float) 61.9047, (float) 0 ),
+    new CoordRec((float) 42.8571, (float) 0 ),
+    new CoordRec((float) 28.5714, (float) 4.7619 ),
+    new CoordRec((float) 19.0476, (float) 14.2857 ),
+};
+
+static final StrokeRec char83[] = {
+   new StrokeRec( 20, char83_stroke0 ),
+};
+
+/* char: 84 'T' */
+
+static final CoordRec char84_stroke0[] = {
+    new CoordRec((float) 52.3809, (float) 100 ),
+    new CoordRec((float) 52.3809, (float) 0 ),
+};
+
+static final CoordRec char84_stroke1[] = {
+    new CoordRec((float) 19.0476, (float) 100 ),
+    new CoordRec((float) 85.7143, (float) 100 ),
+};
+
+static final StrokeRec char84[] = {
+   new StrokeRec( 2, char84_stroke0 ),
+   new StrokeRec( 2, char84_stroke1 ),
+};
+
+/* char: 85 'U' */
+
+static final CoordRec char85_stroke0[] = {
+    new CoordRec((float) 19.0476, (float) 100 ),
+    new CoordRec((float) 19.0476, (float) 28.5714 ),
+    new CoordRec((float) 23.8095, (float) 14.2857 ),
+    new CoordRec((float) 33.3333, (float) 4.7619 ),
+    new CoordRec((float) 47.619, (float) 0 ),
+    new CoordRec((float) 57.1428, (float) 0 ),
+    new CoordRec((float) 71.4286, (float) 4.7619 ),
+    new CoordRec((float) 80.9524, (float) 14.2857 ),
+    new CoordRec((float) 85.7143, (float) 28.5714 ),
+    new CoordRec((float) 85.7143, (float) 100 ),
+};
+
+static final StrokeRec char85[] = {
+   new StrokeRec( 10, char85_stroke0 ),
+};
+
+/* char: 86 'V' */
+
+static final CoordRec char86_stroke0[] = {
+    new CoordRec((float) 14.2857, (float) 100 ),
+    new CoordRec((float) 52.3809, (float) 0 ),
+};
+
+static final CoordRec char86_stroke1[] = {
+    new CoordRec((float) 90.4762, (float) 100 ),
+    new CoordRec((float) 52.3809, (float) 0 ),
+};
+
+static final StrokeRec char86[] = {
+   new StrokeRec( 2, char86_stroke0 ),
+   new StrokeRec( 2, char86_stroke1 ),
+};
+
+/* char: 87 'W' */
+
+static final CoordRec char87_stroke0[] = {
+    new CoordRec((float) 4.7619, (float) 100 ),
+    new CoordRec((float) 28.5714, (float) 0 ),
+};
+
+static final CoordRec char87_stroke1[] = {
+    new CoordRec((float) 52.3809, (float) 100 ),
+    new CoordRec((float) 28.5714, (float) 0 ),
+};
+
+static final CoordRec char87_stroke2[] = {
+    new CoordRec((float) 52.3809, (float) 100 ),
+    new CoordRec((float) 76.1905, (float) 0 ),
+};
+
+static final CoordRec char87_stroke3[] = {
+    new CoordRec((float) 100, (float) 100 ),
+    new CoordRec((float) 76.1905, (float) 0 ),
+};
+
+static final StrokeRec char87[] = {
+   new StrokeRec( 2, char87_stroke0 ),
+   new StrokeRec( 2, char87_stroke1 ),
+   new StrokeRec( 2, char87_stroke2 ),
+   new StrokeRec( 2, char87_stroke3 ),
+};
+
+/* char: 88 'X' */
+
+static final CoordRec char88_stroke0[] = {
+    new CoordRec((float) 19.0476, (float) 100 ),
+    new CoordRec((float) 85.7143, (float) 0 ),
+};
+
+static final CoordRec char88_stroke1[] = {
+    new CoordRec((float) 85.7143, (float) 100 ),
+    new CoordRec((float) 19.0476, (float) 0 ),
+};
+
+static final StrokeRec char88[] = {
+   new StrokeRec( 2, char88_stroke0 ),
+   new StrokeRec( 2, char88_stroke1 ),
+};
+
+/* char: 89 'Y' */
+
+static final CoordRec char89_stroke0[] = {
+    new CoordRec((float) 14.2857, (float) 100 ),
+    new CoordRec((float) 52.3809, (float) 52.381 ),
+    new CoordRec((float) 52.3809, (float) 0 ),
+};
+
+static final CoordRec char89_stroke1[] = {
+    new CoordRec((float) 90.4762, (float) 100 ),
+    new CoordRec((float) 52.3809, (float) 52.381 ),
+};
+
+static final StrokeRec char89[] = {
+   new StrokeRec( 3, char89_stroke0 ),
+   new StrokeRec( 2, char89_stroke1 ),
+};
+
+/* char: 90 'Z' */
+
+static final CoordRec char90_stroke0[] = {
+    new CoordRec((float) 85.7143, (float) 100 ),
+    new CoordRec((float) 19.0476, (float) 0 ),
+};
+
+static final CoordRec char90_stroke1[] = {
+    new CoordRec((float) 19.0476, (float) 100 ),
+    new CoordRec((float) 85.7143, (float) 100 ),
+};
+
+static final CoordRec char90_stroke2[] = {
+    new CoordRec((float) 19.0476, (float) 0 ),
+    new CoordRec((float) 85.7143, (float) 0 ),
+};
+
+static final StrokeRec char90[] = {
+   new StrokeRec( 2, char90_stroke0 ),
+   new StrokeRec( 2, char90_stroke1 ),
+   new StrokeRec( 2, char90_stroke2 ),
+};
+
+/* char: 91 '[' */
+
+static final CoordRec char91_stroke0[] = {
+    new CoordRec((float) 35.7143, (float) 119.048 ),
+    new CoordRec((float) 35.7143, (float) -33.3333 ),
+};
+
+static final CoordRec char91_stroke1[] = {
+    new CoordRec((float) 40.4762, (float) 119.048 ),
+    new CoordRec((float) 40.4762, (float) -33.3333 ),
+};
+
+static final CoordRec char91_stroke2[] = {
+    new CoordRec((float) 35.7143, (float) 119.048 ),
+    new CoordRec((float) 69.0476, (float) 119.048 ),
+};
+
+static final CoordRec char91_stroke3[] = {
+    new CoordRec((float) 35.7143, (float) -33.3333 ),
+    new CoordRec((float) 69.0476, (float) -33.3333 ),
+};
+
+static final StrokeRec char91[] = {
+   new StrokeRec( 2, char91_stroke0 ),
+   new StrokeRec( 2, char91_stroke1 ),
+   new StrokeRec( 2, char91_stroke2 ),
+   new StrokeRec( 2, char91_stroke3 ),
+};
+
+/* char: 92 '\' */
+
+static final CoordRec char92_stroke0[] = {
+    new CoordRec((float) 19.0476, (float) 100 ),
+    new CoordRec((float) 85.7143, (float) -14.2857 ),
+};
+
+static final StrokeRec char92[] = {
+   new StrokeRec( 2, char92_stroke0 ),
+};
+
+/* char: 93 ']' */
+
+static final CoordRec char93_stroke0[] = {
+    new CoordRec((float) 64.2857, (float) 119.048 ),
+    new CoordRec((float) 64.2857, (float) -33.3333 ),
+};
+
+static final CoordRec char93_stroke1[] = {
+    new CoordRec((float) 69.0476, (float) 119.048 ),
+    new CoordRec((float) 69.0476, (float) -33.3333 ),
+};
+
+static final CoordRec char93_stroke2[] = {
+    new CoordRec((float) 35.7143, (float) 119.048 ),
+    new CoordRec((float) 69.0476, (float) 119.048 ),
+};
+
+static final CoordRec char93_stroke3[] = {
+    new CoordRec((float) 35.7143, (float) -33.3333 ),
+    new CoordRec((float) 69.0476, (float) -33.3333 ),
+};
+
+static final StrokeRec char93[] = {
+   new StrokeRec( 2, char93_stroke0 ),
+   new StrokeRec( 2, char93_stroke1 ),
+   new StrokeRec( 2, char93_stroke2 ),
+   new StrokeRec( 2, char93_stroke3 ),
+};
+
+/* char: 94 '^' */
+
+static final CoordRec char94_stroke0[] = {
+    new CoordRec((float) 52.3809, (float) 109.524 ),
+    new CoordRec((float) 14.2857, (float) 42.8571 ),
+};
+
+static final CoordRec char94_stroke1[] = {
+    new CoordRec((float) 52.3809, (float) 109.524 ),
+    new CoordRec((float) 90.4762, (float) 42.8571 ),
+};
+
+static final StrokeRec char94[] = {
+   new StrokeRec( 2, char94_stroke0 ),
+   new StrokeRec( 2, char94_stroke1 ),
+};
+
+/* char: 95 '_' */
+
+static final CoordRec char95_stroke0[] = {
+    new CoordRec((float) 0, (float) -33.3333 ),
+    new CoordRec((float) 104.762, (float) -33.3333 ),
+    new CoordRec((float) 104.762, (float) -28.5714 ),
+    new CoordRec((float) 0, (float) -28.5714 ),
+    new CoordRec((float) 0, (float) -33.3333 ),
+};
+
+static final StrokeRec char95[] = {
+   new StrokeRec( 5, char95_stroke0 ),
+};
+
+/* char: 96 '`' */
+
+static final CoordRec char96_stroke0[] = {
+    new CoordRec((float) 42.8572, (float) 100 ),
+    new CoordRec((float) 66.6667, (float) 71.4286 ),
+};
+
+static final CoordRec char96_stroke1[] = {
+    new CoordRec((float) 42.8572, (float) 100 ),
+    new CoordRec((float) 38.0953, (float) 95.2381 ),
+    new CoordRec((float) 66.6667, (float) 71.4286 ),
+};
+
+static final StrokeRec char96[] = {
+   new StrokeRec( 2, char96_stroke0 ),
+   new StrokeRec( 3, char96_stroke1 ),
+};
+
+/* char: 97 'a' */
+
+static final CoordRec char97_stroke0[] = {
+    new CoordRec((float) 80.9524, (float) 66.6667 ),
+    new CoordRec((float) 80.9524, (float) 0 ),
+};
+
+static final CoordRec char97_stroke1[] = {
+    new CoordRec((float) 80.9524, (float) 52.381 ),
+    new CoordRec((float) 71.4285, (float) 61.9048 ),
+    new CoordRec((float) 61.9047, (float) 66.6667 ),
+    new CoordRec((float) 47.619, (float) 66.6667 ),
+    new CoordRec((float) 38.0952, (float) 61.9048 ),
+    new CoordRec((float) 28.5714, (float) 52.381 ),
+    new CoordRec((float) 23.8095, (float) 38.0952 ),
+    new CoordRec((float) 23.8095, (float) 28.5714 ),
+    new CoordRec((float) 28.5714, (float) 14.2857 ),
+    new CoordRec((float) 38.0952, (float) 4.7619 ),
+    new CoordRec((float) 47.619, (float) 0 ),
+    new CoordRec((float) 61.9047, (float) 0 ),
+    new CoordRec((float) 71.4285, (float) 4.7619 ),
+    new CoordRec((float) 80.9524, (float) 14.2857 ),
+};
+
+static final StrokeRec char97[] = {
+   new StrokeRec( 2, char97_stroke0 ),
+   new StrokeRec( 14, char97_stroke1 ),
+};
+
+/* char: 98 'b' */
+
+static final CoordRec char98_stroke0[] = {
+    new CoordRec((float) 23.8095, (float) 100 ),
+    new CoordRec((float) 23.8095, (float) 0 ),
+};
+
+static final CoordRec char98_stroke1[] = {
+    new CoordRec((float) 23.8095, (float) 52.381 ),
+    new CoordRec((float) 33.3333, (float) 61.9048 ),
+    new CoordRec((float) 42.8571, (float) 66.6667 ),
+    new CoordRec((float) 57.1428, (float) 66.6667 ),
+    new CoordRec((float) 66.6666, (float) 61.9048 ),
+    new CoordRec((float) 76.1905, (float) 52.381 ),
+    new CoordRec((float) 80.9524, (float) 38.0952 ),
+    new CoordRec((float) 80.9524, (float) 28.5714 ),
+    new CoordRec((float) 76.1905, (float) 14.2857 ),
+    new CoordRec((float) 66.6666, (float) 4.7619 ),
+    new CoordRec((float) 57.1428, (float) 0 ),
+    new CoordRec((float) 42.8571, (float) 0 ),
+    new CoordRec((float) 33.3333, (float) 4.7619 ),
+    new CoordRec((float) 23.8095, (float) 14.2857 ),
+};
+
+static final StrokeRec char98[] = {
+   new StrokeRec( 2, char98_stroke0 ),
+   new StrokeRec( 14, char98_stroke1 ),
+};
+
+/* char: 99 'c' */
+
+static final CoordRec char99_stroke0[] = {
+    new CoordRec((float) 80.9524, (float) 52.381 ),
+    new CoordRec((float) 71.4285, (float) 61.9048 ),
+    new CoordRec((float) 61.9047, (float) 66.6667 ),
+    new CoordRec((float) 47.619, (float) 66.6667 ),
+    new CoordRec((float) 38.0952, (float) 61.9048 ),
+    new CoordRec((float) 28.5714, (float) 52.381 ),
+    new CoordRec((float) 23.8095, (float) 38.0952 ),
+    new CoordRec((float) 23.8095, (float) 28.5714 ),
+    new CoordRec((float) 28.5714, (float) 14.2857 ),
+    new CoordRec((float) 38.0952, (float) 4.7619 ),
+    new CoordRec((float) 47.619, (float) 0 ),
+    new CoordRec((float) 61.9047, (float) 0 ),
+    new CoordRec((float) 71.4285, (float) 4.7619 ),
+    new CoordRec((float) 80.9524, (float) 14.2857 ),
+};
+
+static final StrokeRec char99[] = {
+   new StrokeRec( 14, char99_stroke0 ),
+};
+
+/* char: 100 'd' */
+
+static final CoordRec char100_stroke0[] = {
+    new CoordRec((float) 80.9524, (float) 100 ),
+    new CoordRec((float) 80.9524, (float) 0 ),
+};
+
+static final CoordRec char100_stroke1[] = {
+    new CoordRec((float) 80.9524, (float) 52.381 ),
+    new CoordRec((float) 71.4285, (float) 61.9048 ),
+    new CoordRec((float) 61.9047, (float) 66.6667 ),
+    new CoordRec((float) 47.619, (float) 66.6667 ),
+    new CoordRec((float) 38.0952, (float) 61.9048 ),
+    new CoordRec((float) 28.5714, (float) 52.381 ),
+    new CoordRec((float) 23.8095, (float) 38.0952 ),
+    new CoordRec((float) 23.8095, (float) 28.5714 ),
+    new CoordRec((float) 28.5714, (float) 14.2857 ),
+    new CoordRec((float) 38.0952, (float) 4.7619 ),
+    new CoordRec((float) 47.619, (float) 0 ),
+    new CoordRec((float) 61.9047, (float) 0 ),
+    new CoordRec((float) 71.4285, (float) 4.7619 ),
+    new CoordRec((float) 80.9524, (float) 14.2857 ),
+};
+
+static final StrokeRec char100[] = {
+   new StrokeRec( 2, char100_stroke0 ),
+   new StrokeRec( 14, char100_stroke1 ),
+};
+
+/* char: 101 'e' */
+
+static final CoordRec char101_stroke0[] = {
+    new CoordRec((float) 23.8095, (float) 38.0952 ),
+    new CoordRec((float) 80.9524, (float) 38.0952 ),
+    new CoordRec((float) 80.9524, (float) 47.619 ),
+    new CoordRec((float) 76.1905, (float) 57.1429 ),
+    new CoordRec((float) 71.4285, (float) 61.9048 ),
+    new CoordRec((float) 61.9047, (float) 66.6667 ),
+    new CoordRec((float) 47.619, (float) 66.6667 ),
+    new CoordRec((float) 38.0952, (float) 61.9048 ),
+    new CoordRec((float) 28.5714, (float) 52.381 ),
+    new CoordRec((float) 23.8095, (float) 38.0952 ),
+    new CoordRec((float) 23.8095, (float) 28.5714 ),
+    new CoordRec((float) 28.5714, (float) 14.2857 ),
+    new CoordRec((float) 38.0952, (float) 4.7619 ),
+    new CoordRec((float) 47.619, (float) 0 ),
+    new CoordRec((float) 61.9047, (float) 0 ),
+    new CoordRec((float) 71.4285, (float) 4.7619 ),
+    new CoordRec((float) 80.9524, (float) 14.2857 ),
+};
+
+static final StrokeRec char101[] = {
+   new StrokeRec( 17, char101_stroke0 ),
+};
+
+/* char: 102 'f' */
+
+static final CoordRec char102_stroke0[] = {
+    new CoordRec((float) 71.4286, (float) 100 ),
+    new CoordRec((float) 61.9048, (float) 100 ),
+    new CoordRec((float) 52.381, (float) 95.2381 ),
+    new CoordRec((float) 47.6191, (float) 80.9524 ),
+    new CoordRec((float) 47.6191, (float) 0 ),
+};
+
+static final CoordRec char102_stroke1[] = {
+    new CoordRec((float) 33.3334, (float) 66.6667 ),
+    new CoordRec((float) 66.6667, (float) 66.6667 ),
+};
+
+static final StrokeRec char102[] = {
+   new StrokeRec( 5, char102_stroke0 ),
+   new StrokeRec( 2, char102_stroke1 ),
+};
+
+/* char: 103 'g' */
+
+static final CoordRec char103_stroke0[] = {
+    new CoordRec((float) 80.9524, (float) 66.6667 ),
+    new CoordRec((float) 80.9524, (float) -9.5238 ),
+    new CoordRec((float) 76.1905, (float) -23.8095 ),
+    new CoordRec((float) 71.4285, (float) -28.5714 ),
+    new CoordRec((float) 61.9047, (float) -33.3333 ),
+    new CoordRec((float) 47.619, (float) -33.3333 ),
+    new CoordRec((float) 38.0952, (float) -28.5714 ),
+};
+
+static final CoordRec char103_stroke1[] = {
+    new CoordRec((float) 80.9524, (float) 52.381 ),
+    new CoordRec((float) 71.4285, (float) 61.9048 ),
+    new CoordRec((float) 61.9047, (float) 66.6667 ),
+    new CoordRec((float) 47.619, (float) 66.6667 ),
+    new CoordRec((float) 38.0952, (float) 61.9048 ),
+    new CoordRec((float) 28.5714, (float) 52.381 ),
+    new CoordRec((float) 23.8095, (float) 38.0952 ),
+    new CoordRec((float) 23.8095, (float) 28.5714 ),
+    new CoordRec((float) 28.5714, (float) 14.2857 ),
+    new CoordRec((float) 38.0952, (float) 4.7619 ),
+    new CoordRec((float) 47.619, (float) 0 ),
+    new CoordRec((float) 61.9047, (float) 0 ),
+    new CoordRec((float) 71.4285, (float) 4.7619 ),
+    new CoordRec((float) 80.9524, (float) 14.2857 ),
+};
+
+static final StrokeRec char103[] = {
+   new StrokeRec( 7, char103_stroke0 ),
+   new StrokeRec( 14, char103_stroke1 ),
+};
+
+/* char: 104 'h' */
+
+static final CoordRec char104_stroke0[] = {
+    new CoordRec((float) 26.1905, (float) 100 ),
+    new CoordRec((float) 26.1905, (float) 0 ),
+};
+
+static final CoordRec char104_stroke1[] = {
+    new CoordRec((float) 26.1905, (float) 47.619 ),
+    new CoordRec((float) 40.4762, (float) 61.9048 ),
+    new CoordRec((float) 50, (float) 66.6667 ),
+    new CoordRec((float) 64.2857, (float) 66.6667 ),
+    new CoordRec((float) 73.8095, (float) 61.9048 ),
+    new CoordRec((float) 78.5715, (float) 47.619 ),
+    new CoordRec((float) 78.5715, (float) 0 ),
+};
+
+static final StrokeRec char104[] = {
+   new StrokeRec( 2, char104_stroke0 ),
+   new StrokeRec( 7, char104_stroke1 ),
+};
+
+/* char: 105 'i' */
+
+static final CoordRec char105_stroke0[] = {
+    new CoordRec((float) 47.6191, (float) 100 ),
+    new CoordRec((float) 52.381, (float) 95.2381 ),
+    new CoordRec((float) 57.1429, (float) 100 ),
+    new CoordRec((float) 52.381, (float) 104.762 ),
+    new CoordRec((float) 47.6191, (float) 100 ),
+};
+
+static final CoordRec char105_stroke1[] = {
+    new CoordRec((float) 52.381, (float) 66.6667 ),
+    new CoordRec((float) 52.381, (float) 0 ),
+};
+
+static final StrokeRec char105[] = {
+   new StrokeRec( 5, char105_stroke0 ),
+   new StrokeRec( 2, char105_stroke1 ),
+};
+
+/* char: 106 'j' */
+
+static final CoordRec char106_stroke0[] = {
+    new CoordRec((float) 57.1429, (float) 100 ),
+    new CoordRec((float) 61.9048, (float) 95.2381 ),
+    new CoordRec((float) 66.6667, (float) 100 ),
+    new CoordRec((float) 61.9048, (float) 104.762 ),
+    new CoordRec((float) 57.1429, (float) 100 ),
+};
+
+static final CoordRec char106_stroke1[] = {
+    new CoordRec((float) 61.9048, (float) 66.6667 ),
+    new CoordRec((float) 61.9048, (float) -14.2857 ),
+    new CoordRec((float) 57.1429, (float) -28.5714 ),
+    new CoordRec((float) 47.6191, (float) -33.3333 ),
+    new CoordRec((float) 38.0953, (float) -33.3333 ),
+};
+
+static final StrokeRec char106[] = {
+   new StrokeRec( 5, char106_stroke0 ),
+   new StrokeRec( 5, char106_stroke1 ),
+};
+
+/* char: 107 'k' */
+
+static final CoordRec char107_stroke0[] = {
+    new CoordRec((float) 26.1905, (float) 100 ),
+    new CoordRec((float) 26.1905, (float) 0 ),
+};
+
+static final CoordRec char107_stroke1[] = {
+    new CoordRec((float) 73.8095, (float) 66.6667 ),
+    new CoordRec((float) 26.1905, (float) 19.0476 ),
+};
+
+static final CoordRec char107_stroke2[] = {
+    new CoordRec((float) 45.2381, (float) 38.0952 ),
+    new CoordRec((float) 78.5715, (float) 0 ),
+};
+
+static final StrokeRec char107[] = {
+   new StrokeRec( 2, char107_stroke0 ),
+   new StrokeRec( 2, char107_stroke1 ),
+   new StrokeRec( 2, char107_stroke2 ),
+};
+
+/* char: 108 'l' */
+
+static final CoordRec char108_stroke0[] = {
+    new CoordRec((float) 52.381, (float) 100 ),
+    new CoordRec((float) 52.381, (float) 0 ),
+};
+
+static final StrokeRec char108[] = {
+   new StrokeRec( 2, char108_stroke0 ),
+};
+
+/* char: 109 'm' */
+
+static final CoordRec char109_stroke0[] = {
+    new CoordRec((float) 0, (float) 66.6667 ),
+    new CoordRec((float) 0, (float) 0 ),
+};
+
+static final CoordRec char109_stroke1[] = {
+    new CoordRec((float) 0, (float) 47.619 ),
+    new CoordRec((float) 14.2857, (float) 61.9048 ),
+    new CoordRec((float) 23.8095, (float) 66.6667 ),
+    new CoordRec((float) 38.0952, (float) 66.6667 ),
+    new CoordRec((float) 47.619, (float) 61.9048 ),
+    new CoordRec((float) 52.381, (float) 47.619 ),
+    new CoordRec((float) 52.381, (float) 0 ),
+};
+
+static final CoordRec char109_stroke2[] = {
+    new CoordRec((float) 52.381, (float) 47.619 ),
+    new CoordRec((float) 66.6667, (float) 61.9048 ),
+    new CoordRec((float) 76.1905, (float) 66.6667 ),
+    new CoordRec((float) 90.4762, (float) 66.6667 ),
+    new CoordRec((float) 100, (float) 61.9048 ),
+    new CoordRec((float) 104.762, (float) 47.619 ),
+    new CoordRec((float) 104.762, (float) 0 ),
+};
+
+static final StrokeRec char109[] = {
+   new StrokeRec( 2, char109_stroke0 ),
+   new StrokeRec( 7, char109_stroke1 ),
+   new StrokeRec( 7, char109_stroke2 ),
+};
+
+/* char: 110 'n' */
+
+static final CoordRec char110_stroke0[] = {
+    new CoordRec((float) 26.1905, (float) 66.6667 ),
+    new CoordRec((float) 26.1905, (float) 0 ),
+};
+
+static final CoordRec char110_stroke1[] = {
+    new CoordRec((float) 26.1905, (float) 47.619 ),
+    new CoordRec((float) 40.4762, (float) 61.9048 ),
+    new CoordRec((float) 50, (float) 66.6667 ),
+    new CoordRec((float) 64.2857, (float) 66.6667 ),
+    new CoordRec((float) 73.8095, (float) 61.9048 ),
+    new CoordRec((float) 78.5715, (float) 47.619 ),
+    new CoordRec((float) 78.5715, (float) 0 ),
+};
+
+static final StrokeRec char110[] = {
+   new StrokeRec( 2, char110_stroke0 ),
+   new StrokeRec( 7, char110_stroke1 ),
+};
+
+/* char: 111 'o' */
+
+static final CoordRec char111_stroke0[] = {
+    new CoordRec((float) 45.2381, (float) 66.6667 ),
+    new CoordRec((float) 35.7143, (float) 61.9048 ),
+    new CoordRec((float) 26.1905, (float) 52.381 ),
+    new CoordRec((float) 21.4286, (float) 38.0952 ),
+    new CoordRec((float) 21.4286, (float) 28.5714 ),
+    new CoordRec((float) 26.1905, (float) 14.2857 ),
+    new CoordRec((float) 35.7143, (float) 4.7619 ),
+    new CoordRec((float) 45.2381, (float) 0 ),
+    new CoordRec((float) 59.5238, (float) 0 ),
+    new CoordRec((float) 69.0476, (float) 4.7619 ),
+    new CoordRec((float) 78.5714, (float) 14.2857 ),
+    new CoordRec((float) 83.3334, (float) 28.5714 ),
+    new CoordRec((float) 83.3334, (float) 38.0952 ),
+    new CoordRec((float) 78.5714, (float) 52.381 ),
+    new CoordRec((float) 69.0476, (float) 61.9048 ),
+    new CoordRec((float) 59.5238, (float) 66.6667 ),
+    new CoordRec((float) 45.2381, (float) 66.6667 ),
+};
+
+static final StrokeRec char111[] = {
+   new StrokeRec( 17, char111_stroke0 ),
+};
+
+/* char: 112 'p' */
+
+static final CoordRec char112_stroke0[] = {
+    new CoordRec((float) 23.8095, (float) 66.6667 ),
+    new CoordRec((float) 23.8095, (float) -33.3333 ),
+};
+
+static final CoordRec char112_stroke1[] = {
+    new CoordRec((float) 23.8095, (float) 52.381 ),
+    new CoordRec((float) 33.3333, (float) 61.9048 ),
+    new CoordRec((float) 42.8571, (float) 66.6667 ),
+    new CoordRec((float) 57.1428, (float) 66.6667 ),
+    new CoordRec((float) 66.6666, (float) 61.9048 ),
+    new CoordRec((float) 76.1905, (float) 52.381 ),
+    new CoordRec((float) 80.9524, (float) 38.0952 ),
+    new CoordRec((float) 80.9524, (float) 28.5714 ),
+    new CoordRec((float) 76.1905, (float) 14.2857 ),
+    new CoordRec((float) 66.6666, (float) 4.7619 ),
+    new CoordRec((float) 57.1428, (float) 0 ),
+    new CoordRec((float) 42.8571, (float) 0 ),
+    new CoordRec((float) 33.3333, (float) 4.7619 ),
+    new CoordRec((float) 23.8095, (float) 14.2857 ),
+};
+
+static final StrokeRec char112[] = {
+   new StrokeRec( 2, char112_stroke0 ),
+   new StrokeRec( 14, char112_stroke1 ),
+};
+
+/* char: 113 'q' */
+
+static final CoordRec char113_stroke0[] = {
+    new CoordRec((float) 80.9524, (float) 66.6667 ),
+    new CoordRec((float) 80.9524, (float) -33.3333 ),
+};
+
+static final CoordRec char113_stroke1[] = {
+    new CoordRec((float) 80.9524, (float) 52.381 ),
+    new CoordRec((float) 71.4285, (float) 61.9048 ),
+    new CoordRec((float) 61.9047, (float) 66.6667 ),
+    new CoordRec((float) 47.619, (float) 66.6667 ),
+    new CoordRec((float) 38.0952, (float) 61.9048 ),
+    new CoordRec((float) 28.5714, (float) 52.381 ),
+    new CoordRec((float) 23.8095, (float) 38.0952 ),
+    new CoordRec((float) 23.8095, (float) 28.5714 ),
+    new CoordRec((float) 28.5714, (float) 14.2857 ),
+    new CoordRec((float) 38.0952, (float) 4.7619 ),
+    new CoordRec((float) 47.619, (float) 0 ),
+    new CoordRec((float) 61.9047, (float) 0 ),
+    new CoordRec((float) 71.4285, (float) 4.7619 ),
+    new CoordRec((float) 80.9524, (float) 14.2857 ),
+};
+
+static final StrokeRec char113[] = {
+   new StrokeRec( 2, char113_stroke0 ),
+   new StrokeRec( 14, char113_stroke1 ),
+};
+
+/* char: 114 'r' */
+
+static final CoordRec char114_stroke0[] = {
+    new CoordRec((float) 33.3334, (float) 66.6667 ),
+    new CoordRec((float) 33.3334, (float) 0 ),
+};
+
+static final CoordRec char114_stroke1[] = {
+    new CoordRec((float) 33.3334, (float) 38.0952 ),
+    new CoordRec((float) 38.0953, (float) 52.381 ),
+    new CoordRec((float) 47.6191, (float) 61.9048 ),
+    new CoordRec((float) 57.1429, (float) 66.6667 ),
+    new CoordRec((float) 71.4286, (float) 66.6667 ),
+};
+
+static final StrokeRec char114[] = {
+   new StrokeRec( 2, char114_stroke0 ),
+   new StrokeRec( 5, char114_stroke1 ),
+};
+
+/* char: 115 's' */
+
+static final CoordRec char115_stroke0[] = {
+    new CoordRec((float) 78.5715, (float) 52.381 ),
+    new CoordRec((float) 73.8095, (float) 61.9048 ),
+    new CoordRec((float) 59.5238, (float) 66.6667 ),
+    new CoordRec((float) 45.2381, (float) 66.6667 ),
+    new CoordRec((float) 30.9524, (float) 61.9048 ),
+    new CoordRec((float) 26.1905, (float) 52.381 ),
+    new CoordRec((float) 30.9524, (float) 42.8571 ),
+    new CoordRec((float) 40.4762, (float) 38.0952 ),
+    new CoordRec((float) 64.2857, (float) 33.3333 ),
+    new CoordRec((float) 73.8095, (float) 28.5714 ),
+    new CoordRec((float) 78.5715, (float) 19.0476 ),
+    new CoordRec((float) 78.5715, (float) 14.2857 ),
+    new CoordRec((float) 73.8095, (float) 4.7619 ),
+    new CoordRec((float) 59.5238, (float) 0 ),
+    new CoordRec((float) 45.2381, (float) 0 ),
+    new CoordRec((float) 30.9524, (float) 4.7619 ),
+    new CoordRec((float) 26.1905, (float) 14.2857 ),
+};
+
+static final StrokeRec char115[] = {
+   new StrokeRec( 17, char115_stroke0 ),
+};
+
+/* char: 116 't' */
+
+static final CoordRec char116_stroke0[] = {
+    new CoordRec((float) 47.6191, (float) 100 ),
+    new CoordRec((float) 47.6191, (float) 19.0476 ),
+    new CoordRec((float) 52.381, (float) 4.7619 ),
+    new CoordRec((float) 61.9048, (float) 0 ),
+    new CoordRec((float) 71.4286, (float) 0 ),
+};
+
+static final CoordRec char116_stroke1[] = {
+    new CoordRec((float) 33.3334, (float) 66.6667 ),
+    new CoordRec((float) 66.6667, (float) 66.6667 ),
+};
+
+static final StrokeRec char116[] = {
+   new StrokeRec( 5, char116_stroke0 ),
+   new StrokeRec( 2, char116_stroke1 ),
+};
+
+/* char: 117 'u' */
+
+static final CoordRec char117_stroke0[] = {
+    new CoordRec((float) 26.1905, (float) 66.6667 ),
+    new CoordRec((float) 26.1905, (float) 19.0476 ),
+    new CoordRec((float) 30.9524, (float) 4.7619 ),
+    new CoordRec((float) 40.4762, (float) 0 ),
+    new CoordRec((float) 54.7619, (float) 0 ),
+    new CoordRec((float) 64.2857, (float) 4.7619 ),
+    new CoordRec((float) 78.5715, (float) 19.0476 ),
+};
+
+static final CoordRec char117_stroke1[] = {
+    new CoordRec((float) 78.5715, (float) 66.6667 ),
+    new CoordRec((float) 78.5715, (float) 0 ),
+};
+
+static final StrokeRec char117[] = {
+   new StrokeRec( 7, char117_stroke0 ),
+   new StrokeRec( 2, char117_stroke1 ),
+};
+
+/* char: 118 'v' */
+
+static final CoordRec char118_stroke0[] = {
+    new CoordRec((float) 23.8095, (float) 66.6667 ),
+    new CoordRec((float) 52.3809, (float) 0 ),
+};
+
+static final CoordRec char118_stroke1[] = {
+    new CoordRec((float) 80.9524, (float) 66.6667 ),
+    new CoordRec((float) 52.3809, (float) 0 ),
+};
+
+static final StrokeRec char118[] = {
+   new StrokeRec( 2, char118_stroke0 ),
+   new StrokeRec( 2, char118_stroke1 ),
+};
+
+/* char: 119 'w' */
+
+static final CoordRec char119_stroke0[] = {
+    new CoordRec((float) 14.2857, (float) 66.6667 ),
+    new CoordRec((float) 33.3333, (float) 0 ),
+};
+
+static final CoordRec char119_stroke1[] = {
+    new CoordRec((float) 52.3809, (float) 66.6667 ),
+    new CoordRec((float) 33.3333, (float) 0 ),
+};
+
+static final CoordRec char119_stroke2[] = {
+    new CoordRec((float) 52.3809, (float) 66.6667 ),
+    new CoordRec((float) 71.4286, (float) 0 ),
+};
+
+static final CoordRec char119_stroke3[] = {
+    new CoordRec((float) 90.4762, (float) 66.6667 ),
+    new CoordRec((float) 71.4286, (float) 0 ),
+};
+
+static final StrokeRec char119[] = {
+   new StrokeRec( 2, char119_stroke0 ),
+   new StrokeRec( 2, char119_stroke1 ),
+   new StrokeRec( 2, char119_stroke2 ),
+   new StrokeRec( 2, char119_stroke3 ),
+};
+
+/* char: 120 'x' */
+
+static final CoordRec char120_stroke0[] = {
+    new CoordRec((float) 26.1905, (float) 66.6667 ),
+    new CoordRec((float) 78.5715, (float) 0 ),
+};
+
+static final CoordRec char120_stroke1[] = {
+    new CoordRec((float) 78.5715, (float) 66.6667 ),
+    new CoordRec((float) 26.1905, (float) 0 ),
+};
+
+static final StrokeRec char120[] = {
+   new StrokeRec( 2, char120_stroke0 ),
+   new StrokeRec( 2, char120_stroke1 ),
+};
+
+/* char: 121 'y' */
+
+static final CoordRec char121_stroke0[] = {
+    new CoordRec((float) 26.1905, (float) 66.6667 ),
+    new CoordRec((float) 54.7619, (float) 0 ),
+};
+
+static final CoordRec char121_stroke1[] = {
+    new CoordRec((float) 83.3334, (float) 66.6667 ),
+    new CoordRec((float) 54.7619, (float) 0 ),
+    new CoordRec((float) 45.2381, (float) -19.0476 ),
+    new CoordRec((float) 35.7143, (float) -28.5714 ),
+    new CoordRec((float) 26.1905, (float) -33.3333 ),
+    new CoordRec((float) 21.4286, (float) -33.3333 ),
+};
+
+static final StrokeRec char121[] = {
+   new StrokeRec( 2, char121_stroke0 ),
+   new StrokeRec( 6, char121_stroke1 ),
+};
+
+/* char: 122 'z' */
+
+static final CoordRec char122_stroke0[] = {
+    new CoordRec((float) 78.5715, (float) 66.6667 ),
+    new CoordRec((float) 26.1905, (float) 0 ),
+};
+
+static final CoordRec char122_stroke1[] = {
+    new CoordRec((float) 26.1905, (float) 66.6667 ),
+    new CoordRec((float) 78.5715, (float) 66.6667 ),
+};
+
+static final CoordRec char122_stroke2[] = {
+    new CoordRec((float) 26.1905, (float) 0 ),
+    new CoordRec((float) 78.5715, (float) 0 ),
+};
+
+static final StrokeRec char122[] = {
+   new StrokeRec( 2, char122_stroke0 ),
+   new StrokeRec( 2, char122_stroke1 ),
+   new StrokeRec( 2, char122_stroke2 ),
+};
+
+/* char: 123 '{' */
+
+static final CoordRec char123_stroke0[] = {
+    new CoordRec((float) 64.2857, (float) 119.048 ),
+    new CoordRec((float) 54.7619, (float) 114.286 ),
+    new CoordRec((float) 50, (float) 109.524 ),
+    new CoordRec((float) 45.2381, (float) 100 ),
+    new CoordRec((float) 45.2381, (float) 90.4762 ),
+    new CoordRec((float) 50, (float) 80.9524 ),
+    new CoordRec((float) 54.7619, (float) 76.1905 ),
+    new CoordRec((float) 59.5238, (float) 66.6667 ),
+    new CoordRec((float) 59.5238, (float) 57.1429 ),
+    new CoordRec((float) 50, (float) 47.619 ),
+};
+
+static final CoordRec char123_stroke1[] = {
+    new CoordRec((float) 54.7619, (float) 114.286 ),
+    new CoordRec((float) 50, (float) 104.762 ),
+    new CoordRec((float) 50, (float) 95.2381 ),
+    new CoordRec((float) 54.7619, (float) 85.7143 ),
+    new CoordRec((float) 59.5238, (float) 80.9524 ),
+    new CoordRec((float) 64.2857, (float) 71.4286 ),
+    new CoordRec((float) 64.2857, (float) 61.9048 ),
+    new CoordRec((float) 59.5238, (float) 52.381 ),
+    new CoordRec((float) 40.4762, (float) 42.8571 ),
+    new CoordRec((float) 59.5238, (float) 33.3333 ),
+    new CoordRec((float) 64.2857, (float) 23.8095 ),
+    new CoordRec((float) 64.2857, (float) 14.2857 ),
+    new CoordRec((float) 59.5238, (float) 4.7619 ),
+    new CoordRec((float) 54.7619, (float) 0 ),
+    new CoordRec((float) 50, (float) -9.5238 ),
+    new CoordRec((float) 50, (float) -19.0476 ),
+    new CoordRec((float) 54.7619, (float) -28.5714 ),
+};
+
+static final CoordRec char123_stroke2[] = {
+    new CoordRec((float) 50, (float) 38.0952 ),
+    new CoordRec((float) 59.5238, (float) 28.5714 ),
+    new CoordRec((float) 59.5238, (float) 19.0476 ),
+    new CoordRec((float) 54.7619, (float) 9.5238 ),
+    new CoordRec((float) 50, (float) 4.7619 ),
+    new CoordRec((float) 45.2381, (float) -4.7619 ),
+    new CoordRec((float) 45.2381, (float) -14.2857 ),
+    new CoordRec((float) 50, (float) -23.8095 ),
+    new CoordRec((float) 54.7619, (float) -28.5714 ),
+    new CoordRec((float) 64.2857, (float) -33.3333 ),
+};
+
+static final StrokeRec char123[] = {
+   new StrokeRec( 10, char123_stroke0 ),
+   new StrokeRec( 17, char123_stroke1 ),
+   new StrokeRec( 10, char123_stroke2 ),
+};
+
+/* char: 124 '|' */
+
+static final CoordRec char124_stroke0[] = {
+    new CoordRec((float) 52.381, (float) 119.048 ),
+    new CoordRec((float) 52.381, (float) -33.3333 ),
+};
+
+static final StrokeRec char124[] = {
+   new StrokeRec( 2, char124_stroke0 ),
+};
+
+/* char: 125 '}' */
+
+static final CoordRec char125_stroke0[] = {
+    new CoordRec((float) 40.4762, (float) 119.048 ),
+    new CoordRec((float) 50, (float) 114.286 ),
+    new CoordRec((float) 54.7619, (float) 109.524 ),
+    new CoordRec((float) 59.5238, (float) 100 ),
+    new CoordRec((float) 59.5238, (float) 90.4762 ),
+    new CoordRec((float) 54.7619, (float) 80.9524 ),
+    new CoordRec((float) 50, (float) 76.1905 ),
+    new CoordRec((float) 45.2381, (float) 66.6667 ),
+    new CoordRec((float) 45.2381, (float) 57.1429 ),
+    new CoordRec((float) 54.7619, (float) 47.619 ),
+};
+
+static final CoordRec char125_stroke1[] = {
+    new CoordRec((float) 50, (float) 114.286 ),
+    new CoordRec((float) 54.7619, (float) 104.762 ),
+    new CoordRec((float) 54.7619, (float) 95.2381 ),
+    new CoordRec((float) 50, (float) 85.7143 ),
+    new CoordRec((float) 45.2381, (float) 80.9524 ),
+    new CoordRec((float) 40.4762, (float) 71.4286 ),
+    new CoordRec((float) 40.4762, (float) 61.9048 ),
+    new CoordRec((float) 45.2381, (float) 52.381 ),
+    new CoordRec((float) 64.2857, (float) 42.8571 ),
+    new CoordRec((float) 45.2381, (float) 33.3333 ),
+    new CoordRec((float) 40.4762, (float) 23.8095 ),
+    new CoordRec((float) 40.4762, (float) 14.2857 ),
+    new CoordRec((float) 45.2381, (float) 4.7619 ),
+    new CoordRec((float) 50, (float) 0 ),
+    new CoordRec((float) 54.7619, (float) -9.5238 ),
+    new CoordRec((float) 54.7619, (float) -19.0476 ),
+    new CoordRec((float) 50, (float) -28.5714 ),
+};
+
+static final CoordRec char125_stroke2[] = {
+    new CoordRec((float) 54.7619, (float) 38.0952 ),
+    new CoordRec((float) 45.2381, (float) 28.5714 ),
+    new CoordRec((float) 45.2381, (float) 19.0476 ),
+    new CoordRec((float) 50, (float) 9.5238 ),
+    new CoordRec((float) 54.7619, (float) 4.7619 ),
+    new CoordRec((float) 59.5238, (float) -4.7619 ),
+    new CoordRec((float) 59.5238, (float) -14.2857 ),
+    new CoordRec((float) 54.7619, (float) -23.8095 ),
+    new CoordRec((float) 50, (float) -28.5714 ),
+    new CoordRec((float) 40.4762, (float) -33.3333 ),
+};
+
+static final StrokeRec char125[] = {
+   new StrokeRec( 10, char125_stroke0 ),
+   new StrokeRec( 17, char125_stroke1 ),
+   new StrokeRec( 10, char125_stroke2 ),
+};
+
+/* char: 126 '~' */
+
+static final CoordRec char126_stroke0[] = {
+    new CoordRec((float) 9.5238, (float) 28.5714 ),
+    new CoordRec((float) 9.5238, (float) 38.0952 ),
+    new CoordRec((float) 14.2857, (float) 52.381 ),
+    new CoordRec((float) 23.8095, (float) 57.1429 ),
+    new CoordRec((float) 33.3333, (float) 57.1429 ),
+    new CoordRec((float) 42.8571, (float) 52.381 ),
+    new CoordRec((float) 61.9048, (float) 38.0952 ),
+    new CoordRec((float) 71.4286, (float) 33.3333 ),
+    new CoordRec((float) 80.9524, (float) 33.3333 ),
+    new CoordRec((float) 90.4762, (float) 38.0952 ),
+    new CoordRec((float) 95.2381, (float) 47.619 ),
+};
+
+static final CoordRec char126_stroke1[] = {
+    new CoordRec((float) 9.5238, (float) 38.0952 ),
+    new CoordRec((float) 14.2857, (float) 47.619 ),
+    new CoordRec((float) 23.8095, (float) 52.381 ),
+    new CoordRec((float) 33.3333, (float) 52.381 ),
+    new CoordRec((float) 42.8571, (float) 47.619 ),
+    new CoordRec((float) 61.9048, (float) 33.3333 ),
+    new CoordRec((float) 71.4286, (float) 28.5714 ),
+    new CoordRec((float) 80.9524, (float) 28.5714 ),
+    new CoordRec((float) 90.4762, (float) 33.3333 ),
+    new CoordRec((float) 95.2381, (float) 47.619 ),
+    new CoordRec((float) 95.2381, (float) 57.1429 ),
+};
+
+static final StrokeRec char126[] = {
+   new StrokeRec( 11, char126_stroke0 ),
+   new StrokeRec( 11, char126_stroke1 ),
+};
+
+/* char: 127 */
+
+static final CoordRec char127_stroke0[] = {
+    new CoordRec((float) 71.4286, (float) 100 ),
+    new CoordRec((float) 33.3333, (float) -33.3333 ),
+};
+
+static final CoordRec char127_stroke1[] = {
+    new CoordRec((float) 47.619, (float) 66.6667 ),
+    new CoordRec((float) 33.3333, (float) 61.9048 ),
+    new CoordRec((float) 23.8095, (float) 52.381 ),
+    new CoordRec((float) 19.0476, (float) 38.0952 ),
+    new CoordRec((float) 19.0476, (float) 23.8095 ),
+    new CoordRec((float) 23.8095, (float) 14.2857 ),
+    new CoordRec((float) 33.3333, (float) 4.7619 ),
+    new CoordRec((float) 47.619, (float) 0 ),
+    new CoordRec((float) 57.1428, (float) 0 ),
+    new CoordRec((float) 71.4286, (float) 4.7619 ),
+    new CoordRec((float) 80.9524, (float) 14.2857 ),
+    new CoordRec((float) 85.7143, (float) 28.5714 ),
+    new CoordRec((float) 85.7143, (float) 42.8571 ),
+    new CoordRec((float) 80.9524, (float) 52.381 ),
+    new CoordRec((float) 71.4286, (float) 61.9048 ),
+    new CoordRec((float) 57.1428, (float) 66.6667 ),
+    new CoordRec((float) 47.619, (float) 66.6667 ),
+};
+
+static final StrokeRec char127[] = {
+   new StrokeRec( 2, char127_stroke0 ),
+   new StrokeRec( 17, char127_stroke1 ),
+};
+
+static final StrokeCharRec chars[] = {
+    new StrokeCharRec(0, /* char0 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec(0, /* char1 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec(0, /* char2 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec(0, /* char3 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec(0, /* char4 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec(0, /* char5 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec(0, /* char6 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec(0, /* char7 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec(0, /* char8 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec(0, /* char9 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec(0, /* char10 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec(0, /* char11 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec(0, /* char12 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec(0, /* char13 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec(0, /* char14 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec(0, /* char15 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec(0, /* char16 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec(0, /* char17 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec(0, /* char18 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec(0, /* char19 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec(0, /* char20 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec(0, /* char21 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec(0, /* char22 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec(0, /* char23 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec(0, /* char24 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec(0, /* char25 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec(0, /* char26 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec(0, /* char27 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec(0, /* char28 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec(0, /* char29 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec(0, /* char30 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec(0, /* char31 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec(0, /* char32 */ null, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char33, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char34, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(4, char35, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(3, char36, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(3, char37, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(1, char38, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(1, char39, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(1, char40, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(1, char41, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(3, char42, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char43, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(1, char44, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(1, char45, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(1, char46, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(1, char47, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(1, char48, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(1, char49, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(1, char50, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(1, char51, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char52, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(1, char53, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(1, char54, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char55, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(1, char56, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(1, char57, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char58, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char59, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(1, char60, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char61, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(1, char62, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char63, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char64, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(3, char65, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(3, char66, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(1, char67, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char68, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(4, char69, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(3, char70, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char71, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(3, char72, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(1, char73, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(1, char74, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(3, char75, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char76, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(4, char77, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(3, char78, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(1, char79, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char80, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char81, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(3, char82, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(1, char83, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char84, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(1, char85, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char86, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(4, char87, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char88, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char89, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(3, char90, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(4, char91, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(1, char92, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(4, char93, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char94, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(1, char95, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char96, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char97, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char98, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(1, char99, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char100, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(1, char101, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char102, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char103, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char104, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char105, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char106, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(3, char107, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(1, char108, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(3, char109, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char110, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(1, char111, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char112, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char113, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char114, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(1, char115, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char116, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char117, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char118, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(4, char119, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char120, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char121, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(3, char122, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(3, char123, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(1, char124, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(3, char125, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char126, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec(2, char127, (float) 52.381, (float) 104.762 ),
+};
+
+public static final StrokeFontRec glutStrokeMonoRoman = new StrokeFontRec( "Roman", 128, chars, (float) 119.048, (float) -33.3333 );
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/gl2/GLUTStrokeRoman.java b/src/jogl/classes/com/jogamp/opengl/util/gl2/GLUTStrokeRoman.java
new file mode 100644
index 000000000..94fa1c4fd
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/gl2/GLUTStrokeRoman.java
@@ -0,0 +1,2491 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util.gl2;
+
+class GLUTStrokeRoman {
+
+/* GENERATED FILE -- DO NOT MODIFY */
+
+/* char: 33 '!' */
+
+static final CoordRec char33_stroke0[] = {
+    new CoordRec((float) 13.3819, (float) 100),
+    new CoordRec((float) 13.3819, (float) 33.3333),
+};
+
+static final CoordRec char33_stroke1[] = {
+    new CoordRec((float) 13.3819, (float) 9.5238),
+    new CoordRec((float) 8.62, (float) 4.7619),
+    new CoordRec((float) 13.3819, (float) 0),
+    new CoordRec((float) 18.1438, (float) 4.7619),
+    new CoordRec((float) 13.3819, (float) 9.5238),
+};
+
+static final StrokeRec char33[] = {
+   new StrokeRec(2, char33_stroke0),
+   new StrokeRec(5, char33_stroke1),
+};
+
+/* char: 34 '"' */
+
+static final CoordRec char34_stroke0[] = {
+    new CoordRec((float) 4.02, (float) 100),
+    new CoordRec((float) 4.02, (float) 66.6667),
+};
+
+static final CoordRec char34_stroke1[] = {
+    new CoordRec((float) 42.1152, (float) 100),
+    new CoordRec((float) 42.1152, (float) 66.6667),
+};
+
+static final StrokeRec char34[] = {
+   new StrokeRec(2, char34_stroke0),
+   new StrokeRec(2, char34_stroke1),
+};
+
+/* char: 35 '#' */
+
+static final CoordRec char35_stroke0[] = {
+    new CoordRec((float) 41.2952, (float) 119.048),
+    new CoordRec((float) 7.9619, (float) -33.3333),
+};
+
+static final CoordRec char35_stroke1[] = {
+    new CoordRec((float) 69.8667, (float) 119.048),
+    new CoordRec((float) 36.5333, (float) -33.3333),
+};
+
+static final CoordRec char35_stroke2[] = {
+    new CoordRec((float) 7.9619, (float) 57.1429),
+    new CoordRec((float) 74.6286, (float) 57.1429),
+};
+
+static final CoordRec char35_stroke3[] = {
+    new CoordRec((float) 3.2, (float) 28.5714),
+    new CoordRec((float) 69.8667, (float) 28.5714),
+};
+
+static final StrokeRec char35[] = {
+   new StrokeRec(2, char35_stroke0),
+   new StrokeRec(2, char35_stroke1),
+   new StrokeRec(2, char35_stroke2),
+   new StrokeRec(2, char35_stroke3),
+};
+
+/* char: 36 '$' */
+
+static final CoordRec char36_stroke0[] = {
+    new CoordRec((float) 28.6295, (float) 119.048),
+    new CoordRec((float) 28.6295, (float) -19.0476),
+};
+
+static final CoordRec char36_stroke1[] = {
+    new CoordRec((float) 47.6771, (float) 119.048),
+    new CoordRec((float) 47.6771, (float) -19.0476),
+};
+
+static final CoordRec char36_stroke2[] = {
+    new CoordRec((float) 71.4867, (float) 85.7143),
+    new CoordRec((float) 61.9629, (float) 95.2381),
+    new CoordRec((float) 47.6771, (float) 100),
+    new CoordRec((float) 28.6295, (float) 100),
+    new CoordRec((float) 14.3438, (float) 95.2381),
+    new CoordRec((float) 4.82, (float) 85.7143),
+    new CoordRec((float) 4.82, (float) 76.1905),
+    new CoordRec((float) 9.5819, (float) 66.6667),
+    new CoordRec((float) 14.3438, (float) 61.9048),
+    new CoordRec((float) 23.8676, (float) 57.1429),
+    new CoordRec((float) 52.439, (float) 47.619),
+    new CoordRec((float) 61.9629, (float) 42.8571),
+    new CoordRec((float) 66.7248, (float) 38.0952),
+    new CoordRec((float) 71.4867, (float) 28.5714),
+    new CoordRec((float) 71.4867, (float) 14.2857),
+    new CoordRec((float) 61.9629, (float) 4.7619),
+    new CoordRec((float) 47.6771, (float) 0),
+    new CoordRec((float) 28.6295, (float) 0),
+    new CoordRec((float) 14.3438, (float) 4.7619),
+    new CoordRec((float) 4.82, (float) 14.2857),
+};
+
+static final StrokeRec char36[] = {
+   new StrokeRec(2, char36_stroke0),
+   new StrokeRec(2, char36_stroke1),
+   new StrokeRec(20, char36_stroke2),
+};
+
+/* char: 37 '%' */
+
+static final CoordRec char37_stroke0[] = {
+    new CoordRec((float) 92.0743, (float) 100),
+    new CoordRec((float) 6.36, (float) 0),
+};
+
+static final CoordRec char37_stroke1[] = {
+    new CoordRec((float) 30.1695, (float) 100),
+    new CoordRec((float) 39.6933, (float) 90.4762),
+    new CoordRec((float) 39.6933, (float) 80.9524),
+    new CoordRec((float) 34.9314, (float) 71.4286),
+    new CoordRec((float) 25.4076, (float) 66.6667),
+    new CoordRec((float) 15.8838, (float) 66.6667),
+    new CoordRec((float) 6.36, (float) 76.1905),
+    new CoordRec((float) 6.36, (float) 85.7143),
+    new CoordRec((float) 11.1219, (float) 95.2381),
+    new CoordRec((float) 20.6457, (float) 100),
+    new CoordRec((float) 30.1695, (float) 100),
+    new CoordRec((float) 39.6933, (float) 95.2381),
+    new CoordRec((float) 53.979, (float) 90.4762),
+    new CoordRec((float) 68.2648, (float) 90.4762),
+    new CoordRec((float) 82.5505, (float) 95.2381),
+    new CoordRec((float) 92.0743, (float) 100),
+};
+
+static final CoordRec char37_stroke2[] = {
+    new CoordRec((float) 73.0267, (float) 33.3333),
+    new CoordRec((float) 63.5029, (float) 28.5714),
+    new CoordRec((float) 58.741, (float) 19.0476),
+    new CoordRec((float) 58.741, (float) 9.5238),
+    new CoordRec((float) 68.2648, (float) 0),
+    new CoordRec((float) 77.7886, (float) 0),
+    new CoordRec((float) 87.3124, (float) 4.7619),
+    new CoordRec((float) 92.0743, (float) 14.2857),
+    new CoordRec((float) 92.0743, (float) 23.8095),
+    new CoordRec((float) 82.5505, (float) 33.3333),
+    new CoordRec((float) 73.0267, (float) 33.3333),
+};
+
+static final StrokeRec char37[] = {
+   new StrokeRec(2, char37_stroke0),
+   new StrokeRec(16, char37_stroke1),
+   new StrokeRec(11, char37_stroke2),
+};
+
+/* char: 38 '&' */
+
+static final CoordRec char38_stroke0[] = {
+    new CoordRec((float) 101.218, (float) 57.1429),
+    new CoordRec((float) 101.218, (float) 61.9048),
+    new CoordRec((float) 96.4562, (float) 66.6667),
+    new CoordRec((float) 91.6943, (float) 66.6667),
+    new CoordRec((float) 86.9324, (float) 61.9048),
+    new CoordRec((float) 82.1705, (float) 52.381),
+    new CoordRec((float) 72.6467, (float) 28.5714),
+    new CoordRec((float) 63.1229, (float) 14.2857),
+    new CoordRec((float) 53.599, (float) 4.7619),
+    new CoordRec((float) 44.0752, (float) 0),
+    new CoordRec((float) 25.0276, (float) 0),
+    new CoordRec((float) 15.5038, (float) 4.7619),
+    new CoordRec((float) 10.7419, (float) 9.5238),
+    new CoordRec((float) 5.98, (float) 19.0476),
+    new CoordRec((float) 5.98, (float) 28.5714),
+    new CoordRec((float) 10.7419, (float) 38.0952),
+    new CoordRec((float) 15.5038, (float) 42.8571),
+    new CoordRec((float) 48.8371, (float) 61.9048),
+    new CoordRec((float) 53.599, (float) 66.6667),
+    new CoordRec((float) 58.361, (float) 76.1905),
+    new CoordRec((float) 58.361, (float) 85.7143),
+    new CoordRec((float) 53.599, (float) 95.2381),
+    new CoordRec((float) 44.0752, (float) 100),
+    new CoordRec((float) 34.5514, (float) 95.2381),
+    new CoordRec((float) 29.7895, (float) 85.7143),
+    new CoordRec((float) 29.7895, (float) 76.1905),
+    new CoordRec((float) 34.5514, (float) 61.9048),
+    new CoordRec((float) 44.0752, (float) 47.619),
+    new CoordRec((float) 67.8848, (float) 14.2857),
+    new CoordRec((float) 77.4086, (float) 4.7619),
+    new CoordRec((float) 86.9324, (float) 0),
+    new CoordRec((float) 96.4562, (float) 0),
+    new CoordRec((float) 101.218, (float) 4.7619),
+    new CoordRec((float) 101.218, (float) 9.5238),
+};
+
+static final StrokeRec char38[] = {
+   new StrokeRec(34, char38_stroke0),
+};
+
+/* char: 39 ''' */
+
+static final CoordRec char39_stroke0[] = {
+    new CoordRec((float) 4.44, (float) 100),
+    new CoordRec((float) 4.44, (float) 66.6667),
+};
+
+static final StrokeRec char39[] = {
+   new StrokeRec(2, char39_stroke0),
+};
+
+/* char: 40 '(' */
+
+static final CoordRec char40_stroke0[] = {
+    new CoordRec((float) 40.9133, (float) 119.048),
+    new CoordRec((float) 31.3895, (float) 109.524),
+    new CoordRec((float) 21.8657, (float) 95.2381),
+    new CoordRec((float) 12.3419, (float) 76.1905),
+    new CoordRec((float) 7.58, (float) 52.381),
+    new CoordRec((float) 7.58, (float) 33.3333),
+    new CoordRec((float) 12.3419, (float) 9.5238),
+    new CoordRec((float) 21.8657, (float) -9.5238),
+    new CoordRec((float) 31.3895, (float) -23.8095),
+    new CoordRec((float) 40.9133, (float) -33.3333),
+};
+
+static final StrokeRec char40[] = {
+   new StrokeRec(10, char40_stroke0),
+};
+
+/* char: 41 ')' */
+
+static final CoordRec char41_stroke0[] = {
+    new CoordRec((float) 5.28, (float) 119.048),
+    new CoordRec((float) 14.8038, (float) 109.524),
+    new CoordRec((float) 24.3276, (float) 95.2381),
+    new CoordRec((float) 33.8514, (float) 76.1905),
+    new CoordRec((float) 38.6133, (float) 52.381),
+    new CoordRec((float) 38.6133, (float) 33.3333),
+    new CoordRec((float) 33.8514, (float) 9.5238),
+    new CoordRec((float) 24.3276, (float) -9.5238),
+    new CoordRec((float) 14.8038, (float) -23.8095),
+    new CoordRec((float) 5.28, (float) -33.3333),
+};
+
+static final StrokeRec char41[] = {
+   new StrokeRec(10, char41_stroke0),
+};
+
+/* char: 42 '*' */
+
+static final CoordRec char42_stroke0[] = {
+    new CoordRec((float) 30.7695, (float) 71.4286),
+    new CoordRec((float) 30.7695, (float) 14.2857),
+};
+
+static final CoordRec char42_stroke1[] = {
+    new CoordRec((float) 6.96, (float) 57.1429),
+    new CoordRec((float) 54.579, (float) 28.5714),
+};
+
+static final CoordRec char42_stroke2[] = {
+    new CoordRec((float) 54.579, (float) 57.1429),
+    new CoordRec((float) 6.96, (float) 28.5714),
+};
+
+static final StrokeRec char42[] = {
+   new StrokeRec(2, char42_stroke0),
+   new StrokeRec(2, char42_stroke1),
+   new StrokeRec(2, char42_stroke2),
+};
+
+/* char: 43 '+' */
+
+static final CoordRec char43_stroke0[] = {
+    new CoordRec((float) 48.8371, (float) 85.7143),
+    new CoordRec((float) 48.8371, (float) 0),
+};
+
+static final CoordRec char43_stroke1[] = {
+    new CoordRec((float) 5.98, (float) 42.8571),
+    new CoordRec((float) 91.6943, (float) 42.8571),
+};
+
+static final StrokeRec char43[] = {
+   new StrokeRec(2, char43_stroke0),
+   new StrokeRec(2, char43_stroke1),
+};
+
+/* char: 44 ',' */
+
+static final CoordRec char44_stroke0[] = {
+    new CoordRec((float) 18.2838, (float) 4.7619),
+    new CoordRec((float) 13.5219, (float) 0),
+    new CoordRec((float) 8.76, (float) 4.7619),
+    new CoordRec((float) 13.5219, (float) 9.5238),
+    new CoordRec((float) 18.2838, (float) 4.7619),
+    new CoordRec((float) 18.2838, (float) -4.7619),
+    new CoordRec((float) 13.5219, (float) -14.2857),
+    new CoordRec((float) 8.76, (float) -19.0476),
+};
+
+static final StrokeRec char44[] = {
+   new StrokeRec(8, char44_stroke0),
+};
+
+/* char: 45 '-' */
+
+static final CoordRec char45_stroke0[] = {
+    new CoordRec((float) 7.38, (float) 42.8571),
+    new CoordRec((float) 93.0943, (float) 42.8571),
+};
+
+static final StrokeRec char45[] = {
+   new StrokeRec(2, char45_stroke0),
+};
+
+/* char: 46 '.' */
+
+static final CoordRec char46_stroke0[] = {
+    new CoordRec((float) 13.1019, (float) 9.5238),
+    new CoordRec((float) 8.34, (float) 4.7619),
+    new CoordRec((float) 13.1019, (float) 0),
+    new CoordRec((float) 17.8638, (float) 4.7619),
+    new CoordRec((float) 13.1019, (float) 9.5238),
+};
+
+static final StrokeRec char46[] = {
+   new StrokeRec(5, char46_stroke0),
+};
+
+/* char: 47 '/' */
+
+static final CoordRec char47_stroke0[] = {
+    new CoordRec((float) 7.24, (float) -14.2857),
+    new CoordRec((float) 73.9067, (float) 100),
+};
+
+static final StrokeRec char47[] = {
+   new StrokeRec(2, char47_stroke0),
+};
+
+/* char: 48 '0' */
+
+static final CoordRec char48_stroke0[] = {
+    new CoordRec((float) 33.5514, (float) 100),
+    new CoordRec((float) 19.2657, (float) 95.2381),
+    new CoordRec((float) 9.7419, (float) 80.9524),
+    new CoordRec((float) 4.98, (float) 57.1429),
+    new CoordRec((float) 4.98, (float) 42.8571),
+    new CoordRec((float) 9.7419, (float) 19.0476),
+    new CoordRec((float) 19.2657, (float) 4.7619),
+    new CoordRec((float) 33.5514, (float) 0),
+    new CoordRec((float) 43.0752, (float) 0),
+    new CoordRec((float) 57.361, (float) 4.7619),
+    new CoordRec((float) 66.8848, (float) 19.0476),
+    new CoordRec((float) 71.6467, (float) 42.8571),
+    new CoordRec((float) 71.6467, (float) 57.1429),
+    new CoordRec((float) 66.8848, (float) 80.9524),
+    new CoordRec((float) 57.361, (float) 95.2381),
+    new CoordRec((float) 43.0752, (float) 100),
+    new CoordRec((float) 33.5514, (float) 100),
+};
+
+static final StrokeRec char48[] = {
+   new StrokeRec(17, char48_stroke0),
+};
+
+/* char: 49 '1' */
+
+static final CoordRec char49_stroke0[] = {
+    new CoordRec((float) 11.82, (float) 80.9524),
+    new CoordRec((float) 21.3438, (float) 85.7143),
+    new CoordRec((float) 35.6295, (float) 100),
+    new CoordRec((float) 35.6295, (float) 0),
+};
+
+static final StrokeRec char49[] = {
+   new StrokeRec(4, char49_stroke0),
+};
+
+/* char: 50 '2' */
+
+static final CoordRec char50_stroke0[] = {
+    new CoordRec((float) 10.1819, (float) 76.1905),
+    new CoordRec((float) 10.1819, (float) 80.9524),
+    new CoordRec((float) 14.9438, (float) 90.4762),
+    new CoordRec((float) 19.7057, (float) 95.2381),
+    new CoordRec((float) 29.2295, (float) 100),
+    new CoordRec((float) 48.2771, (float) 100),
+    new CoordRec((float) 57.801, (float) 95.2381),
+    new CoordRec((float) 62.5629, (float) 90.4762),
+    new CoordRec((float) 67.3248, (float) 80.9524),
+    new CoordRec((float) 67.3248, (float) 71.4286),
+    new CoordRec((float) 62.5629, (float) 61.9048),
+    new CoordRec((float) 53.039, (float) 47.619),
+    new CoordRec((float) 5.42, (float) 0),
+    new CoordRec((float) 72.0867, (float) 0),
+};
+
+static final StrokeRec char50[] = {
+   new StrokeRec(14, char50_stroke0),
+};
+
+/* char: 51 '3' */
+
+static final CoordRec char51_stroke0[] = {
+    new CoordRec((float) 14.5238, (float) 100),
+    new CoordRec((float) 66.9048, (float) 100),
+    new CoordRec((float) 38.3333, (float) 61.9048),
+    new CoordRec((float) 52.619, (float) 61.9048),
+    new CoordRec((float) 62.1429, (float) 57.1429),
+    new CoordRec((float) 66.9048, (float) 52.381),
+    new CoordRec((float) 71.6667, (float) 38.0952),
+    new CoordRec((float) 71.6667, (float) 28.5714),
+    new CoordRec((float) 66.9048, (float) 14.2857),
+    new CoordRec((float) 57.381, (float) 4.7619),
+    new CoordRec((float) 43.0952, (float) 0),
+    new CoordRec((float) 28.8095, (float) 0),
+    new CoordRec((float) 14.5238, (float) 4.7619),
+    new CoordRec((float) 9.7619, (float) 9.5238),
+    new CoordRec((float) 5, (float) 19.0476),
+};
+
+static final StrokeRec char51[] = {
+   new StrokeRec(15, char51_stroke0),
+};
+
+/* char: 52 '4' */
+
+static final CoordRec char52_stroke0[] = {
+    new CoordRec((float) 51.499, (float) 100),
+    new CoordRec((float) 3.88, (float) 33.3333),
+    new CoordRec((float) 75.3086, (float) 33.3333),
+};
+
+static final CoordRec char52_stroke1[] = {
+    new CoordRec((float) 51.499, (float) 100),
+    new CoordRec((float) 51.499, (float) 0),
+};
+
+static final StrokeRec char52[] = {
+   new StrokeRec(3, char52_stroke0),
+   new StrokeRec(2, char52_stroke1),
+};
+
+/* char: 53 '5' */
+
+static final CoordRec char53_stroke0[] = {
+    new CoordRec((float) 62.0029, (float) 100),
+    new CoordRec((float) 14.3838, (float) 100),
+    new CoordRec((float) 9.6219, (float) 57.1429),
+    new CoordRec((float) 14.3838, (float) 61.9048),
+    new CoordRec((float) 28.6695, (float) 66.6667),
+    new CoordRec((float) 42.9552, (float) 66.6667),
+    new CoordRec((float) 57.241, (float) 61.9048),
+    new CoordRec((float) 66.7648, (float) 52.381),
+    new CoordRec((float) 71.5267, (float) 38.0952),
+    new CoordRec((float) 71.5267, (float) 28.5714),
+    new CoordRec((float) 66.7648, (float) 14.2857),
+    new CoordRec((float) 57.241, (float) 4.7619),
+    new CoordRec((float) 42.9552, (float) 0),
+    new CoordRec((float) 28.6695, (float) 0),
+    new CoordRec((float) 14.3838, (float) 4.7619),
+    new CoordRec((float) 9.6219, (float) 9.5238),
+    new CoordRec((float) 4.86, (float) 19.0476),
+};
+
+static final StrokeRec char53[] = {
+   new StrokeRec(17, char53_stroke0),
+};
+
+/* char: 54 '6' */
+
+static final CoordRec char54_stroke0[] = {
+    new CoordRec((float) 62.7229, (float) 85.7143),
+    new CoordRec((float) 57.961, (float) 95.2381),
+    new CoordRec((float) 43.6752, (float) 100),
+    new CoordRec((float) 34.1514, (float) 100),
+    new CoordRec((float) 19.8657, (float) 95.2381),
+    new CoordRec((float) 10.3419, (float) 80.9524),
+    new CoordRec((float) 5.58, (float) 57.1429),
+    new CoordRec((float) 5.58, (float) 33.3333),
+    new CoordRec((float) 10.3419, (float) 14.2857),
+    new CoordRec((float) 19.8657, (float) 4.7619),
+    new CoordRec((float) 34.1514, (float) 0),
+    new CoordRec((float) 38.9133, (float) 0),
+    new CoordRec((float) 53.199, (float) 4.7619),
+    new CoordRec((float) 62.7229, (float) 14.2857),
+    new CoordRec((float) 67.4848, (float) 28.5714),
+    new CoordRec((float) 67.4848, (float) 33.3333),
+    new CoordRec((float) 62.7229, (float) 47.619),
+    new CoordRec((float) 53.199, (float) 57.1429),
+    new CoordRec((float) 38.9133, (float) 61.9048),
+    new CoordRec((float) 34.1514, (float) 61.9048),
+    new CoordRec((float) 19.8657, (float) 57.1429),
+    new CoordRec((float) 10.3419, (float) 47.619),
+    new CoordRec((float) 5.58, (float) 33.3333),
+};
+
+static final StrokeRec char54[] = {
+   new StrokeRec(23, char54_stroke0),
+};
+
+/* char: 55 '7' */
+
+static final CoordRec char55_stroke0[] = {
+    new CoordRec((float) 72.2267, (float) 100),
+    new CoordRec((float) 24.6076, (float) 0),
+};
+
+static final CoordRec char55_stroke1[] = {
+    new CoordRec((float) 5.56, (float) 100),
+    new CoordRec((float) 72.2267, (float) 100),
+};
+
+static final StrokeRec char55[] = {
+   new StrokeRec(2, char55_stroke0),
+   new StrokeRec(2, char55_stroke1),
+};
+
+/* char: 56 '8' */
+
+static final CoordRec char56_stroke0[] = {
+    new CoordRec((float) 29.4095, (float) 100),
+    new CoordRec((float) 15.1238, (float) 95.2381),
+    new CoordRec((float) 10.3619, (float) 85.7143),
+    new CoordRec((float) 10.3619, (float) 76.1905),
+    new CoordRec((float) 15.1238, (float) 66.6667),
+    new CoordRec((float) 24.6476, (float) 61.9048),
+    new CoordRec((float) 43.6952, (float) 57.1429),
+    new CoordRec((float) 57.981, (float) 52.381),
+    new CoordRec((float) 67.5048, (float) 42.8571),
+    new CoordRec((float) 72.2667, (float) 33.3333),
+    new CoordRec((float) 72.2667, (float) 19.0476),
+    new CoordRec((float) 67.5048, (float) 9.5238),
+    new CoordRec((float) 62.7429, (float) 4.7619),
+    new CoordRec((float) 48.4571, (float) 0),
+    new CoordRec((float) 29.4095, (float) 0),
+    new CoordRec((float) 15.1238, (float) 4.7619),
+    new CoordRec((float) 10.3619, (float) 9.5238),
+    new CoordRec((float) 5.6, (float) 19.0476),
+    new CoordRec((float) 5.6, (float) 33.3333),
+    new CoordRec((float) 10.3619, (float) 42.8571),
+    new CoordRec((float) 19.8857, (float) 52.381),
+    new CoordRec((float) 34.1714, (float) 57.1429),
+    new CoordRec((float) 53.219, (float) 61.9048),
+    new CoordRec((float) 62.7429, (float) 66.6667),
+    new CoordRec((float) 67.5048, (float) 76.1905),
+    new CoordRec((float) 67.5048, (float) 85.7143),
+    new CoordRec((float) 62.7429, (float) 95.2381),
+    new CoordRec((float) 48.4571, (float) 100),
+    new CoordRec((float) 29.4095, (float) 100),
+};
+
+static final StrokeRec char56[] = {
+   new StrokeRec(29, char56_stroke0),
+};
+
+/* char: 57 '9' */
+
+static final CoordRec char57_stroke0[] = {
+    new CoordRec((float) 68.5048, (float) 66.6667),
+    new CoordRec((float) 63.7429, (float) 52.381),
+    new CoordRec((float) 54.219, (float) 42.8571),
+    new CoordRec((float) 39.9333, (float) 38.0952),
+    new CoordRec((float) 35.1714, (float) 38.0952),
+    new CoordRec((float) 20.8857, (float) 42.8571),
+    new CoordRec((float) 11.3619, (float) 52.381),
+    new CoordRec((float) 6.6, (float) 66.6667),
+    new CoordRec((float) 6.6, (float) 71.4286),
+    new CoordRec((float) 11.3619, (float) 85.7143),
+    new CoordRec((float) 20.8857, (float) 95.2381),
+    new CoordRec((float) 35.1714, (float) 100),
+    new CoordRec((float) 39.9333, (float) 100),
+    new CoordRec((float) 54.219, (float) 95.2381),
+    new CoordRec((float) 63.7429, (float) 85.7143),
+    new CoordRec((float) 68.5048, (float) 66.6667),
+    new CoordRec((float) 68.5048, (float) 42.8571),
+    new CoordRec((float) 63.7429, (float) 19.0476),
+    new CoordRec((float) 54.219, (float) 4.7619),
+    new CoordRec((float) 39.9333, (float) 0),
+    new CoordRec((float) 30.4095, (float) 0),
+    new CoordRec((float) 16.1238, (float) 4.7619),
+    new CoordRec((float) 11.3619, (float) 14.2857),
+};
+
+static final StrokeRec char57[] = {
+   new StrokeRec(23, char57_stroke0),
+};
+
+/* char: 58 ':' */
+
+static final CoordRec char58_stroke0[] = {
+    new CoordRec((float) 14.0819, (float) 66.6667),
+    new CoordRec((float) 9.32, (float) 61.9048),
+    new CoordRec((float) 14.0819, (float) 57.1429),
+    new CoordRec((float) 18.8438, (float) 61.9048),
+    new CoordRec((float) 14.0819, (float) 66.6667),
+};
+
+static final CoordRec char58_stroke1[] = {
+    new CoordRec((float) 14.0819, (float) 9.5238),
+    new CoordRec((float) 9.32, (float) 4.7619),
+    new CoordRec((float) 14.0819, (float) 0),
+    new CoordRec((float) 18.8438, (float) 4.7619),
+    new CoordRec((float) 14.0819, (float) 9.5238),
+};
+
+static final StrokeRec char58[] = {
+   new StrokeRec(5, char58_stroke0),
+   new StrokeRec(5, char58_stroke1),
+};
+
+/* char: 59 ';' */
+
+static final CoordRec char59_stroke0[] = {
+    new CoordRec((float) 12.9619, (float) 66.6667),
+    new CoordRec((float) 8.2, (float) 61.9048),
+    new CoordRec((float) 12.9619, (float) 57.1429),
+    new CoordRec((float) 17.7238, (float) 61.9048),
+    new CoordRec((float) 12.9619, (float) 66.6667),
+};
+
+static final CoordRec char59_stroke1[] = {
+    new CoordRec((float) 17.7238, (float) 4.7619),
+    new CoordRec((float) 12.9619, (float) 0),
+    new CoordRec((float) 8.2, (float) 4.7619),
+    new CoordRec((float) 12.9619, (float) 9.5238),
+    new CoordRec((float) 17.7238, (float) 4.7619),
+    new CoordRec((float) 17.7238, (float) -4.7619),
+    new CoordRec((float) 12.9619, (float) -14.2857),
+    new CoordRec((float) 8.2, (float) -19.0476),
+};
+
+static final StrokeRec char59[] = {
+   new StrokeRec(5, char59_stroke0),
+   new StrokeRec(8, char59_stroke1),
+};
+
+/* char: 60 '<' */
+
+static final CoordRec char60_stroke0[] = {
+    new CoordRec((float) 79.2505, (float) 85.7143),
+    new CoordRec((float) 3.06, (float) 42.8571),
+    new CoordRec((float) 79.2505, (float) 0),
+};
+
+static final StrokeRec char60[] = {
+   new StrokeRec(3, char60_stroke0),
+};
+
+/* char: 61 '=' */
+
+static final CoordRec char61_stroke0[] = {
+    new CoordRec((float) 5.7, (float) 57.1429),
+    new CoordRec((float) 91.4143, (float) 57.1429),
+};
+
+static final CoordRec char61_stroke1[] = {
+    new CoordRec((float) 5.7, (float) 28.5714),
+    new CoordRec((float) 91.4143, (float) 28.5714),
+};
+
+static final StrokeRec char61[] = {
+   new StrokeRec(2, char61_stroke0),
+   new StrokeRec(2, char61_stroke1),
+};
+
+/* char: 62 '>' */
+
+static final CoordRec char62_stroke0[] = {
+    new CoordRec((float) 2.78, (float) 85.7143),
+    new CoordRec((float) 78.9705, (float) 42.8571),
+    new CoordRec((float) 2.78, (float) 0),
+};
+
+static final StrokeRec char62[] = {
+   new StrokeRec(3, char62_stroke0),
+};
+
+/* char: 63 '?' */
+
+static final CoordRec char63_stroke0[] = {
+    new CoordRec((float) 8.42, (float) 76.1905),
+    new CoordRec((float) 8.42, (float) 80.9524),
+    new CoordRec((float) 13.1819, (float) 90.4762),
+    new CoordRec((float) 17.9438, (float) 95.2381),
+    new CoordRec((float) 27.4676, (float) 100),
+    new CoordRec((float) 46.5152, (float) 100),
+    new CoordRec((float) 56.039, (float) 95.2381),
+    new CoordRec((float) 60.801, (float) 90.4762),
+    new CoordRec((float) 65.5629, (float) 80.9524),
+    new CoordRec((float) 65.5629, (float) 71.4286),
+    new CoordRec((float) 60.801, (float) 61.9048),
+    new CoordRec((float) 56.039, (float) 57.1429),
+    new CoordRec((float) 36.9914, (float) 47.619),
+    new CoordRec((float) 36.9914, (float) 33.3333),
+};
+
+static final CoordRec char63_stroke1[] = {
+    new CoordRec((float) 36.9914, (float) 9.5238),
+    new CoordRec((float) 32.2295, (float) 4.7619),
+    new CoordRec((float) 36.9914, (float) 0),
+    new CoordRec((float) 41.7533, (float) 4.7619),
+    new CoordRec((float) 36.9914, (float) 9.5238),
+};
+
+static final StrokeRec char63[] = {
+   new StrokeRec(14, char63_stroke0),
+   new StrokeRec(5, char63_stroke1),
+};
+
+/* char: 64 '@' */
+
+static final CoordRec char64_stroke0[] = {
+    new CoordRec((float) 49.2171, (float) 52.381),
+    new CoordRec((float) 39.6933, (float) 57.1429),
+    new CoordRec((float) 30.1695, (float) 57.1429),
+    new CoordRec((float) 25.4076, (float) 47.619),
+    new CoordRec((float) 25.4076, (float) 42.8571),
+    new CoordRec((float) 30.1695, (float) 33.3333),
+    new CoordRec((float) 39.6933, (float) 33.3333),
+    new CoordRec((float) 49.2171, (float) 38.0952),
+};
+
+static final CoordRec char64_stroke1[] = {
+    new CoordRec((float) 49.2171, (float) 57.1429),
+    new CoordRec((float) 49.2171, (float) 38.0952),
+    new CoordRec((float) 53.979, (float) 33.3333),
+    new CoordRec((float) 63.5029, (float) 33.3333),
+    new CoordRec((float) 68.2648, (float) 42.8571),
+    new CoordRec((float) 68.2648, (float) 47.619),
+    new CoordRec((float) 63.5029, (float) 61.9048),
+    new CoordRec((float) 53.979, (float) 71.4286),
+    new CoordRec((float) 39.6933, (float) 76.1905),
+    new CoordRec((float) 34.9314, (float) 76.1905),
+    new CoordRec((float) 20.6457, (float) 71.4286),
+    new CoordRec((float) 11.1219, (float) 61.9048),
+    new CoordRec((float) 6.36, (float) 47.619),
+    new CoordRec((float) 6.36, (float) 42.8571),
+    new CoordRec((float) 11.1219, (float) 28.5714),
+    new CoordRec((float) 20.6457, (float) 19.0476),
+    new CoordRec((float) 34.9314, (float) 14.2857),
+    new CoordRec((float) 39.6933, (float) 14.2857),
+    new CoordRec((float) 53.979, (float) 19.0476),
+};
+
+static final StrokeRec char64[] = {
+   new StrokeRec(8, char64_stroke0),
+   new StrokeRec(19, char64_stroke1),
+};
+
+/* char: 65 'A' */
+
+static final CoordRec char65_stroke0[] = {
+    new CoordRec((float) 40.5952, (float) 100),
+    new CoordRec((float) 2.5, (float) 0),
+};
+
+static final CoordRec char65_stroke1[] = {
+    new CoordRec((float) 40.5952, (float) 100),
+    new CoordRec((float) 78.6905, (float) 0),
+};
+
+static final CoordRec char65_stroke2[] = {
+    new CoordRec((float) 16.7857, (float) 33.3333),
+    new CoordRec((float) 64.4048, (float) 33.3333),
+};
+
+static final StrokeRec char65[] = {
+   new StrokeRec(2, char65_stroke0),
+   new StrokeRec(2, char65_stroke1),
+   new StrokeRec(2, char65_stroke2),
+};
+
+/* char: 66 'B' */
+
+static final CoordRec char66_stroke0[] = {
+    new CoordRec((float) 11.42, (float) 100),
+    new CoordRec((float) 11.42, (float) 0),
+};
+
+static final CoordRec char66_stroke1[] = {
+    new CoordRec((float) 11.42, (float) 100),
+    new CoordRec((float) 54.2771, (float) 100),
+    new CoordRec((float) 68.5629, (float) 95.2381),
+    new CoordRec((float) 73.3248, (float) 90.4762),
+    new CoordRec((float) 78.0867, (float) 80.9524),
+    new CoordRec((float) 78.0867, (float) 71.4286),
+    new CoordRec((float) 73.3248, (float) 61.9048),
+    new CoordRec((float) 68.5629, (float) 57.1429),
+    new CoordRec((float) 54.2771, (float) 52.381),
+};
+
+static final CoordRec char66_stroke2[] = {
+    new CoordRec((float) 11.42, (float) 52.381),
+    new CoordRec((float) 54.2771, (float) 52.381),
+    new CoordRec((float) 68.5629, (float) 47.619),
+    new CoordRec((float) 73.3248, (float) 42.8571),
+    new CoordRec((float) 78.0867, (float) 33.3333),
+    new CoordRec((float) 78.0867, (float) 19.0476),
+    new CoordRec((float) 73.3248, (float) 9.5238),
+    new CoordRec((float) 68.5629, (float) 4.7619),
+    new CoordRec((float) 54.2771, (float) 0),
+    new CoordRec((float) 11.42, (float) 0),
+};
+
+static final StrokeRec char66[] = {
+   new StrokeRec(2, char66_stroke0),
+   new StrokeRec(9, char66_stroke1),
+   new StrokeRec(10, char66_stroke2),
+};
+
+/* char: 67 'C' */
+
+static final CoordRec char67_stroke0[] = {
+    new CoordRec((float) 78.0886, (float) 76.1905),
+    new CoordRec((float) 73.3267, (float) 85.7143),
+    new CoordRec((float) 63.8029, (float) 95.2381),
+    new CoordRec((float) 54.279, (float) 100),
+    new CoordRec((float) 35.2314, (float) 100),
+    new CoordRec((float) 25.7076, (float) 95.2381),
+    new CoordRec((float) 16.1838, (float) 85.7143),
+    new CoordRec((float) 11.4219, (float) 76.1905),
+    new CoordRec((float) 6.66, (float) 61.9048),
+    new CoordRec((float) 6.66, (float) 38.0952),
+    new CoordRec((float) 11.4219, (float) 23.8095),
+    new CoordRec((float) 16.1838, (float) 14.2857),
+    new CoordRec((float) 25.7076, (float) 4.7619),
+    new CoordRec((float) 35.2314, (float) 0),
+    new CoordRec((float) 54.279, (float) 0),
+    new CoordRec((float) 63.8029, (float) 4.7619),
+    new CoordRec((float) 73.3267, (float) 14.2857),
+    new CoordRec((float) 78.0886, (float) 23.8095),
+};
+
+static final StrokeRec char67[] = {
+   new StrokeRec(18, char67_stroke0),
+};
+
+/* char: 68 'D' */
+
+static final CoordRec char68_stroke0[] = {
+    new CoordRec((float) 11.96, (float) 100),
+    new CoordRec((float) 11.96, (float) 0),
+};
+
+static final CoordRec char68_stroke1[] = {
+    new CoordRec((float) 11.96, (float) 100),
+    new CoordRec((float) 45.2933, (float) 100),
+    new CoordRec((float) 59.579, (float) 95.2381),
+    new CoordRec((float) 69.1029, (float) 85.7143),
+    new CoordRec((float) 73.8648, (float) 76.1905),
+    new CoordRec((float) 78.6267, (float) 61.9048),
+    new CoordRec((float) 78.6267, (float) 38.0952),
+    new CoordRec((float) 73.8648, (float) 23.8095),
+    new CoordRec((float) 69.1029, (float) 14.2857),
+    new CoordRec((float) 59.579, (float) 4.7619),
+    new CoordRec((float) 45.2933, (float) 0),
+    new CoordRec((float) 11.96, (float) 0),
+};
+
+static final StrokeRec char68[] = {
+   new StrokeRec(2, char68_stroke0),
+   new StrokeRec(12, char68_stroke1),
+};
+
+/* char: 69 'E' */
+
+static final CoordRec char69_stroke0[] = {
+    new CoordRec((float) 11.42, (float) 100),
+    new CoordRec((float) 11.42, (float) 0),
+};
+
+static final CoordRec char69_stroke1[] = {
+    new CoordRec((float) 11.42, (float) 100),
+    new CoordRec((float) 73.3248, (float) 100),
+};
+
+static final CoordRec char69_stroke2[] = {
+    new CoordRec((float) 11.42, (float) 52.381),
+    new CoordRec((float) 49.5152, (float) 52.381),
+};
+
+static final CoordRec char69_stroke3[] = {
+    new CoordRec((float) 11.42, (float) 0),
+    new CoordRec((float) 73.3248, (float) 0),
+};
+
+static final StrokeRec char69[] = {
+   new StrokeRec(2, char69_stroke0),
+   new StrokeRec(2, char69_stroke1),
+   new StrokeRec(2, char69_stroke2),
+   new StrokeRec(2, char69_stroke3),
+};
+
+/* char: 70 'F' */
+
+static final CoordRec char70_stroke0[] = {
+    new CoordRec((float) 11.42, (float) 100),
+    new CoordRec((float) 11.42, (float) 0),
+};
+
+static final CoordRec char70_stroke1[] = {
+    new CoordRec((float) 11.42, (float) 100),
+    new CoordRec((float) 73.3248, (float) 100),
+};
+
+static final CoordRec char70_stroke2[] = {
+    new CoordRec((float) 11.42, (float) 52.381),
+    new CoordRec((float) 49.5152, (float) 52.381),
+};
+
+static final StrokeRec char70[] = {
+   new StrokeRec(2, char70_stroke0),
+   new StrokeRec(2, char70_stroke1),
+   new StrokeRec(2, char70_stroke2),
+};
+
+/* char: 71 'G' */
+
+static final CoordRec char71_stroke0[] = {
+    new CoordRec((float) 78.4886, (float) 76.1905),
+    new CoordRec((float) 73.7267, (float) 85.7143),
+    new CoordRec((float) 64.2029, (float) 95.2381),
+    new CoordRec((float) 54.679, (float) 100),
+    new CoordRec((float) 35.6314, (float) 100),
+    new CoordRec((float) 26.1076, (float) 95.2381),
+    new CoordRec((float) 16.5838, (float) 85.7143),
+    new CoordRec((float) 11.8219, (float) 76.1905),
+    new CoordRec((float) 7.06, (float) 61.9048),
+    new CoordRec((float) 7.06, (float) 38.0952),
+    new CoordRec((float) 11.8219, (float) 23.8095),
+    new CoordRec((float) 16.5838, (float) 14.2857),
+    new CoordRec((float) 26.1076, (float) 4.7619),
+    new CoordRec((float) 35.6314, (float) 0),
+    new CoordRec((float) 54.679, (float) 0),
+    new CoordRec((float) 64.2029, (float) 4.7619),
+    new CoordRec((float) 73.7267, (float) 14.2857),
+    new CoordRec((float) 78.4886, (float) 23.8095),
+    new CoordRec((float) 78.4886, (float) 38.0952),
+};
+
+static final CoordRec char71_stroke1[] = {
+    new CoordRec((float) 54.679, (float) 38.0952),
+    new CoordRec((float) 78.4886, (float) 38.0952),
+};
+
+static final StrokeRec char71[] = {
+   new StrokeRec(19, char71_stroke0),
+   new StrokeRec(2, char71_stroke1),
+};
+
+/* char: 72 'H' */
+
+static final CoordRec char72_stroke0[] = {
+    new CoordRec((float) 11.42, (float) 100),
+    new CoordRec((float) 11.42, (float) 0),
+};
+
+static final CoordRec char72_stroke1[] = {
+    new CoordRec((float) 78.0867, (float) 100),
+    new CoordRec((float) 78.0867, (float) 0),
+};
+
+static final CoordRec char72_stroke2[] = {
+    new CoordRec((float) 11.42, (float) 52.381),
+    new CoordRec((float) 78.0867, (float) 52.381),
+};
+
+static final StrokeRec char72[] = {
+   new StrokeRec(2, char72_stroke0),
+   new StrokeRec(2, char72_stroke1),
+   new StrokeRec(2, char72_stroke2),
+};
+
+/* char: 73 'I' */
+
+static final CoordRec char73_stroke0[] = {
+    new CoordRec((float) 10.86, (float) 100),
+    new CoordRec((float) 10.86, (float) 0),
+};
+
+static final StrokeRec char73[] = {
+   new StrokeRec(2, char73_stroke0),
+};
+
+/* char: 74 'J' */
+
+static final CoordRec char74_stroke0[] = {
+    new CoordRec((float) 50.119, (float) 100),
+    new CoordRec((float) 50.119, (float) 23.8095),
+    new CoordRec((float) 45.3571, (float) 9.5238),
+    new CoordRec((float) 40.5952, (float) 4.7619),
+    new CoordRec((float) 31.0714, (float) 0),
+    new CoordRec((float) 21.5476, (float) 0),
+    new CoordRec((float) 12.0238, (float) 4.7619),
+    new CoordRec((float) 7.2619, (float) 9.5238),
+    new CoordRec((float) 2.5, (float) 23.8095),
+    new CoordRec((float) 2.5, (float) 33.3333),
+};
+
+static final StrokeRec char74[] = {
+   new StrokeRec(10, char74_stroke0),
+};
+
+/* char: 75 'K' */
+
+static final CoordRec char75_stroke0[] = {
+    new CoordRec((float) 11.28, (float) 100),
+    new CoordRec((float) 11.28, (float) 0),
+};
+
+static final CoordRec char75_stroke1[] = {
+    new CoordRec((float) 77.9467, (float) 100),
+    new CoordRec((float) 11.28, (float) 33.3333),
+};
+
+static final CoordRec char75_stroke2[] = {
+    new CoordRec((float) 35.0895, (float) 57.1429),
+    new CoordRec((float) 77.9467, (float) 0),
+};
+
+static final StrokeRec char75[] = {
+   new StrokeRec(2, char75_stroke0),
+   new StrokeRec(2, char75_stroke1),
+   new StrokeRec(2, char75_stroke2),
+};
+
+/* char: 76 'L' */
+
+static final CoordRec char76_stroke0[] = {
+    new CoordRec((float) 11.68, (float) 100),
+    new CoordRec((float) 11.68, (float) 0),
+};
+
+static final CoordRec char76_stroke1[] = {
+    new CoordRec((float) 11.68, (float) 0),
+    new CoordRec((float) 68.8229, (float) 0),
+};
+
+static final StrokeRec char76[] = {
+   new StrokeRec(2, char76_stroke0),
+   new StrokeRec(2, char76_stroke1),
+};
+
+/* char: 77 'M' */
+
+static final CoordRec char77_stroke0[] = {
+    new CoordRec((float) 10.86, (float) 100),
+    new CoordRec((float) 10.86, (float) 0),
+};
+
+static final CoordRec char77_stroke1[] = {
+    new CoordRec((float) 10.86, (float) 100),
+    new CoordRec((float) 48.9552, (float) 0),
+};
+
+static final CoordRec char77_stroke2[] = {
+    new CoordRec((float) 87.0505, (float) 100),
+    new CoordRec((float) 48.9552, (float) 0),
+};
+
+static final CoordRec char77_stroke3[] = {
+    new CoordRec((float) 87.0505, (float) 100),
+    new CoordRec((float) 87.0505, (float) 0),
+};
+
+static final StrokeRec char77[] = {
+   new StrokeRec(2, char77_stroke0),
+   new StrokeRec(2, char77_stroke1),
+   new StrokeRec(2, char77_stroke2),
+   new StrokeRec(2, char77_stroke3),
+};
+
+/* char: 78 'N' */
+
+static final CoordRec char78_stroke0[] = {
+    new CoordRec((float) 11.14, (float) 100),
+    new CoordRec((float) 11.14, (float) 0),
+};
+
+static final CoordRec char78_stroke1[] = {
+    new CoordRec((float) 11.14, (float) 100),
+    new CoordRec((float) 77.8067, (float) 0),
+};
+
+static final CoordRec char78_stroke2[] = {
+    new CoordRec((float) 77.8067, (float) 100),
+    new CoordRec((float) 77.8067, (float) 0),
+};
+
+static final StrokeRec char78[] = {
+   new StrokeRec(2, char78_stroke0),
+   new StrokeRec(2, char78_stroke1),
+   new StrokeRec(2, char78_stroke2),
+};
+
+/* char: 79 'O' */
+
+static final CoordRec char79_stroke0[] = {
+    new CoordRec((float) 34.8114, (float) 100),
+    new CoordRec((float) 25.2876, (float) 95.2381),
+    new CoordRec((float) 15.7638, (float) 85.7143),
+    new CoordRec((float) 11.0019, (float) 76.1905),
+    new CoordRec((float) 6.24, (float) 61.9048),
+    new CoordRec((float) 6.24, (float) 38.0952),
+    new CoordRec((float) 11.0019, (float) 23.8095),
+    new CoordRec((float) 15.7638, (float) 14.2857),
+    new CoordRec((float) 25.2876, (float) 4.7619),
+    new CoordRec((float) 34.8114, (float) 0),
+    new CoordRec((float) 53.859, (float) 0),
+    new CoordRec((float) 63.3829, (float) 4.7619),
+    new CoordRec((float) 72.9067, (float) 14.2857),
+    new CoordRec((float) 77.6686, (float) 23.8095),
+    new CoordRec((float) 82.4305, (float) 38.0952),
+    new CoordRec((float) 82.4305, (float) 61.9048),
+    new CoordRec((float) 77.6686, (float) 76.1905),
+    new CoordRec((float) 72.9067, (float) 85.7143),
+    new CoordRec((float) 63.3829, (float) 95.2381),
+    new CoordRec((float) 53.859, (float) 100),
+    new CoordRec((float) 34.8114, (float) 100),
+};
+
+static final StrokeRec char79[] = {
+   new StrokeRec(21, char79_stroke0),
+};
+
+/* char: 80 'P' */
+
+static final CoordRec char80_stroke0[] = {
+    new CoordRec((float) 12.1, (float) 100),
+    new CoordRec((float) 12.1, (float) 0),
+};
+
+static final CoordRec char80_stroke1[] = {
+    new CoordRec((float) 12.1, (float) 100),
+    new CoordRec((float) 54.9571, (float) 100),
+    new CoordRec((float) 69.2429, (float) 95.2381),
+    new CoordRec((float) 74.0048, (float) 90.4762),
+    new CoordRec((float) 78.7667, (float) 80.9524),
+    new CoordRec((float) 78.7667, (float) 66.6667),
+    new CoordRec((float) 74.0048, (float) 57.1429),
+    new CoordRec((float) 69.2429, (float) 52.381),
+    new CoordRec((float) 54.9571, (float) 47.619),
+    new CoordRec((float) 12.1, (float) 47.619),
+};
+
+static final StrokeRec char80[] = {
+   new StrokeRec(2, char80_stroke0),
+   new StrokeRec(10, char80_stroke1),
+};
+
+/* char: 81 'Q' */
+
+static final CoordRec char81_stroke0[] = {
+    new CoordRec((float) 33.8714, (float) 100),
+    new CoordRec((float) 24.3476, (float) 95.2381),
+    new CoordRec((float) 14.8238, (float) 85.7143),
+    new CoordRec((float) 10.0619, (float) 76.1905),
+    new CoordRec((float) 5.3, (float) 61.9048),
+    new CoordRec((float) 5.3, (float) 38.0952),
+    new CoordRec((float) 10.0619, (float) 23.8095),
+    new CoordRec((float) 14.8238, (float) 14.2857),
+    new CoordRec((float) 24.3476, (float) 4.7619),
+    new CoordRec((float) 33.8714, (float) 0),
+    new CoordRec((float) 52.919, (float) 0),
+    new CoordRec((float) 62.4429, (float) 4.7619),
+    new CoordRec((float) 71.9667, (float) 14.2857),
+    new CoordRec((float) 76.7286, (float) 23.8095),
+    new CoordRec((float) 81.4905, (float) 38.0952),
+    new CoordRec((float) 81.4905, (float) 61.9048),
+    new CoordRec((float) 76.7286, (float) 76.1905),
+    new CoordRec((float) 71.9667, (float) 85.7143),
+    new CoordRec((float) 62.4429, (float) 95.2381),
+    new CoordRec((float) 52.919, (float) 100),
+    new CoordRec((float) 33.8714, (float) 100),
+};
+
+static final CoordRec char81_stroke1[] = {
+    new CoordRec((float) 48.1571, (float) 19.0476),
+    new CoordRec((float) 76.7286, (float) -9.5238),
+};
+
+static final StrokeRec char81[] = {
+   new StrokeRec(21, char81_stroke0),
+   new StrokeRec(2, char81_stroke1),
+};
+
+/* char: 82 'R' */
+
+static final CoordRec char82_stroke0[] = {
+    new CoordRec((float) 11.68, (float) 100),
+    new CoordRec((float) 11.68, (float) 0),
+};
+
+static final CoordRec char82_stroke1[] = {
+    new CoordRec((float) 11.68, (float) 100),
+    new CoordRec((float) 54.5371, (float) 100),
+    new CoordRec((float) 68.8229, (float) 95.2381),
+    new CoordRec((float) 73.5848, (float) 90.4762),
+    new CoordRec((float) 78.3467, (float) 80.9524),
+    new CoordRec((float) 78.3467, (float) 71.4286),
+    new CoordRec((float) 73.5848, (float) 61.9048),
+    new CoordRec((float) 68.8229, (float) 57.1429),
+    new CoordRec((float) 54.5371, (float) 52.381),
+    new CoordRec((float) 11.68, (float) 52.381),
+};
+
+static final CoordRec char82_stroke2[] = {
+    new CoordRec((float) 45.0133, (float) 52.381),
+    new CoordRec((float) 78.3467, (float) 0),
+};
+
+static final StrokeRec char82[] = {
+   new StrokeRec(2, char82_stroke0),
+   new StrokeRec(10, char82_stroke1),
+   new StrokeRec(2, char82_stroke2),
+};
+
+/* char: 83 'S' */
+
+static final CoordRec char83_stroke0[] = {
+    new CoordRec((float) 74.6667, (float) 85.7143),
+    new CoordRec((float) 65.1429, (float) 95.2381),
+    new CoordRec((float) 50.8571, (float) 100),
+    new CoordRec((float) 31.8095, (float) 100),
+    new CoordRec((float) 17.5238, (float) 95.2381),
+    new CoordRec((float) 8, (float) 85.7143),
+    new CoordRec((float) 8, (float) 76.1905),
+    new CoordRec((float) 12.7619, (float) 66.6667),
+    new CoordRec((float) 17.5238, (float) 61.9048),
+    new CoordRec((float) 27.0476, (float) 57.1429),
+    new CoordRec((float) 55.619, (float) 47.619),
+    new CoordRec((float) 65.1429, (float) 42.8571),
+    new CoordRec((float) 69.9048, (float) 38.0952),
+    new CoordRec((float) 74.6667, (float) 28.5714),
+    new CoordRec((float) 74.6667, (float) 14.2857),
+    new CoordRec((float) 65.1429, (float) 4.7619),
+    new CoordRec((float) 50.8571, (float) 0),
+    new CoordRec((float) 31.8095, (float) 0),
+    new CoordRec((float) 17.5238, (float) 4.7619),
+    new CoordRec((float) 8, (float) 14.2857),
+};
+
+static final StrokeRec char83[] = {
+   new StrokeRec(20, char83_stroke0),
+};
+
+/* char: 84 'T' */
+
+static final CoordRec char84_stroke0[] = {
+    new CoordRec((float) 35.6933, (float) 100),
+    new CoordRec((float) 35.6933, (float) 0),
+};
+
+static final CoordRec char84_stroke1[] = {
+    new CoordRec((float) 2.36, (float) 100),
+    new CoordRec((float) 69.0267, (float) 100),
+};
+
+static final StrokeRec char84[] = {
+   new StrokeRec(2, char84_stroke0),
+   new StrokeRec(2, char84_stroke1),
+};
+
+/* char: 85 'U' */
+
+static final CoordRec char85_stroke0[] = {
+    new CoordRec((float) 11.54, (float) 100),
+    new CoordRec((float) 11.54, (float) 28.5714),
+    new CoordRec((float) 16.3019, (float) 14.2857),
+    new CoordRec((float) 25.8257, (float) 4.7619),
+    new CoordRec((float) 40.1114, (float) 0),
+    new CoordRec((float) 49.6352, (float) 0),
+    new CoordRec((float) 63.921, (float) 4.7619),
+    new CoordRec((float) 73.4448, (float) 14.2857),
+    new CoordRec((float) 78.2067, (float) 28.5714),
+    new CoordRec((float) 78.2067, (float) 100),
+};
+
+static final StrokeRec char85[] = {
+   new StrokeRec(10, char85_stroke0),
+};
+
+/* char: 86 'V' */
+
+static final CoordRec char86_stroke0[] = {
+    new CoordRec((float) 2.36, (float) 100),
+    new CoordRec((float) 40.4552, (float) 0),
+};
+
+static final CoordRec char86_stroke1[] = {
+    new CoordRec((float) 78.5505, (float) 100),
+    new CoordRec((float) 40.4552, (float) 0),
+};
+
+static final StrokeRec char86[] = {
+   new StrokeRec(2, char86_stroke0),
+   new StrokeRec(2, char86_stroke1),
+};
+
+/* char: 87 'W' */
+
+static final CoordRec char87_stroke0[] = {
+    new CoordRec((float) 2.22, (float) 100),
+    new CoordRec((float) 26.0295, (float) 0),
+};
+
+static final CoordRec char87_stroke1[] = {
+    new CoordRec((float) 49.839, (float) 100),
+    new CoordRec((float) 26.0295, (float) 0),
+};
+
+static final CoordRec char87_stroke2[] = {
+    new CoordRec((float) 49.839, (float) 100),
+    new CoordRec((float) 73.6486, (float) 0),
+};
+
+static final CoordRec char87_stroke3[] = {
+    new CoordRec((float) 97.4581, (float) 100),
+    new CoordRec((float) 73.6486, (float) 0),
+};
+
+static final StrokeRec char87[] = {
+   new StrokeRec(2, char87_stroke0),
+   new StrokeRec(2, char87_stroke1),
+   new StrokeRec(2, char87_stroke2),
+   new StrokeRec(2, char87_stroke3),
+};
+
+/* char: 88 'X' */
+
+static final CoordRec char88_stroke0[] = {
+    new CoordRec((float) 2.5, (float) 100),
+    new CoordRec((float) 69.1667, (float) 0),
+};
+
+static final CoordRec char88_stroke1[] = {
+    new CoordRec((float) 69.1667, (float) 100),
+    new CoordRec((float) 2.5, (float) 0),
+};
+
+static final StrokeRec char88[] = {
+   new StrokeRec(2, char88_stroke0),
+   new StrokeRec(2, char88_stroke1),
+};
+
+/* char: 89 'Y' */
+
+static final CoordRec char89_stroke0[] = {
+    new CoordRec((float) 1.52, (float) 100),
+    new CoordRec((float) 39.6152, (float) 52.381),
+    new CoordRec((float) 39.6152, (float) 0),
+};
+
+static final CoordRec char89_stroke1[] = {
+    new CoordRec((float) 77.7105, (float) 100),
+    new CoordRec((float) 39.6152, (float) 52.381),
+};
+
+static final StrokeRec char89[] = {
+   new StrokeRec(3, char89_stroke0),
+   new StrokeRec(2, char89_stroke1),
+};
+
+/* char: 90 'Z' */
+
+static final CoordRec char90_stroke0[] = {
+    new CoordRec((float) 69.1667, (float) 100),
+    new CoordRec((float) 2.5, (float) 0),
+};
+
+static final CoordRec char90_stroke1[] = {
+    new CoordRec((float) 2.5, (float) 100),
+    new CoordRec((float) 69.1667, (float) 100),
+};
+
+static final CoordRec char90_stroke2[] = {
+    new CoordRec((float) 2.5, (float) 0),
+    new CoordRec((float) 69.1667, (float) 0),
+};
+
+static final StrokeRec char90[] = {
+   new StrokeRec(2, char90_stroke0),
+   new StrokeRec(2, char90_stroke1),
+   new StrokeRec(2, char90_stroke2),
+};
+
+/* char: 91 '[' */
+
+static final CoordRec char91_stroke0[] = {
+    new CoordRec((float) 7.78, (float) 119.048),
+    new CoordRec((float) 7.78, (float) -33.3333),
+};
+
+static final CoordRec char91_stroke1[] = {
+    new CoordRec((float) 12.5419, (float) 119.048),
+    new CoordRec((float) 12.5419, (float) -33.3333),
+};
+
+static final CoordRec char91_stroke2[] = {
+    new CoordRec((float) 7.78, (float) 119.048),
+    new CoordRec((float) 41.1133, (float) 119.048),
+};
+
+static final CoordRec char91_stroke3[] = {
+    new CoordRec((float) 7.78, (float) -33.3333),
+    new CoordRec((float) 41.1133, (float) -33.3333),
+};
+
+static final StrokeRec char91[] = {
+   new StrokeRec(2, char91_stroke0),
+   new StrokeRec(2, char91_stroke1),
+   new StrokeRec(2, char91_stroke2),
+   new StrokeRec(2, char91_stroke3),
+};
+
+/* char: 92 '\' */
+
+static final CoordRec char92_stroke0[] = {
+    new CoordRec((float) 5.84, (float) 100),
+    new CoordRec((float) 72.5067, (float) -14.2857),
+};
+
+static final StrokeRec char92[] = {
+   new StrokeRec(2, char92_stroke0),
+};
+
+/* char: 93 ']' */
+
+static final CoordRec char93_stroke0[] = {
+    new CoordRec((float) 33.0114, (float) 119.048),
+    new CoordRec((float) 33.0114, (float) -33.3333),
+};
+
+static final CoordRec char93_stroke1[] = {
+    new CoordRec((float) 37.7733, (float) 119.048),
+    new CoordRec((float) 37.7733, (float) -33.3333),
+};
+
+static final CoordRec char93_stroke2[] = {
+    new CoordRec((float) 4.44, (float) 119.048),
+    new CoordRec((float) 37.7733, (float) 119.048),
+};
+
+static final CoordRec char93_stroke3[] = {
+    new CoordRec((float) 4.44, (float) -33.3333),
+    new CoordRec((float) 37.7733, (float) -33.3333),
+};
+
+static final StrokeRec char93[] = {
+   new StrokeRec(2, char93_stroke0),
+   new StrokeRec(2, char93_stroke1),
+   new StrokeRec(2, char93_stroke2),
+   new StrokeRec(2, char93_stroke3),
+};
+
+/* char: 94 '^' */
+
+static final CoordRec char94_stroke0[] = {
+    new CoordRec((float) 44.0752, (float) 109.524),
+    new CoordRec((float) 5.98, (float) 42.8571),
+};
+
+static final CoordRec char94_stroke1[] = {
+    new CoordRec((float) 44.0752, (float) 109.524),
+    new CoordRec((float) 82.1705, (float) 42.8571),
+};
+
+static final StrokeRec char94[] = {
+   new StrokeRec(2, char94_stroke0),
+   new StrokeRec(2, char94_stroke1),
+};
+
+/* char: 95 '_' */
+
+static final CoordRec char95_stroke0[] = {
+    new CoordRec((float)-1.1, (float) -33.3333),
+    new CoordRec((float) 103.662, (float) -33.3333),
+    new CoordRec((float) 103.662, (float) -28.5714),
+    new CoordRec((float)-1.1, (float) -28.5714),
+    new CoordRec((float)-1.1, (float) -33.3333),
+};
+
+static final StrokeRec char95[] = {
+   new StrokeRec(5, char95_stroke0),
+};
+
+/* char: 96 '`' */
+
+static final CoordRec char96_stroke0[] = {
+    new CoordRec((float) 33.0219, (float) 100),
+    new CoordRec((float) 56.8314, (float) 71.4286),
+};
+
+static final CoordRec char96_stroke1[] = {
+    new CoordRec((float) 33.0219, (float) 100),
+    new CoordRec((float) 28.26, (float) 95.2381),
+    new CoordRec((float) 56.8314, (float) 71.4286),
+};
+
+static final StrokeRec char96[] = {
+   new StrokeRec(2, char96_stroke0),
+   new StrokeRec(3, char96_stroke1),
+};
+
+/* char: 97 'a' */
+
+static final CoordRec char97_stroke0[] = {
+    new CoordRec((float) 63.8229, (float) 66.6667),
+    new CoordRec((float) 63.8229, (float) 0),
+};
+
+static final CoordRec char97_stroke1[] = {
+    new CoordRec((float) 63.8229, (float) 52.381),
+    new CoordRec((float) 54.299, (float) 61.9048),
+    new CoordRec((float) 44.7752, (float) 66.6667),
+    new CoordRec((float) 30.4895, (float) 66.6667),
+    new CoordRec((float) 20.9657, (float) 61.9048),
+    new CoordRec((float) 11.4419, (float) 52.381),
+    new CoordRec((float) 6.68, (float) 38.0952),
+    new CoordRec((float) 6.68, (float) 28.5714),
+    new CoordRec((float) 11.4419, (float) 14.2857),
+    new CoordRec((float) 20.9657, (float) 4.7619),
+    new CoordRec((float) 30.4895, (float) 0),
+    new CoordRec((float) 44.7752, (float) 0),
+    new CoordRec((float) 54.299, (float) 4.7619),
+    new CoordRec((float) 63.8229, (float) 14.2857),
+};
+
+static final StrokeRec char97[] = {
+   new StrokeRec(2, char97_stroke0),
+   new StrokeRec(14, char97_stroke1),
+};
+
+/* char: 98 'b' */
+
+static final CoordRec char98_stroke0[] = {
+    new CoordRec((float) 8.76, (float) 100),
+    new CoordRec((float) 8.76, (float) 0),
+};
+
+static final CoordRec char98_stroke1[] = {
+    new CoordRec((float) 8.76, (float) 52.381),
+    new CoordRec((float) 18.2838, (float) 61.9048),
+    new CoordRec((float) 27.8076, (float) 66.6667),
+    new CoordRec((float) 42.0933, (float) 66.6667),
+    new CoordRec((float) 51.6171, (float) 61.9048),
+    new CoordRec((float) 61.141, (float) 52.381),
+    new CoordRec((float) 65.9029, (float) 38.0952),
+    new CoordRec((float) 65.9029, (float) 28.5714),
+    new CoordRec((float) 61.141, (float) 14.2857),
+    new CoordRec((float) 51.6171, (float) 4.7619),
+    new CoordRec((float) 42.0933, (float) 0),
+    new CoordRec((float) 27.8076, (float) 0),
+    new CoordRec((float) 18.2838, (float) 4.7619),
+    new CoordRec((float) 8.76, (float) 14.2857),
+};
+
+static final StrokeRec char98[] = {
+   new StrokeRec(2, char98_stroke0),
+   new StrokeRec(14, char98_stroke1),
+};
+
+/* char: 99 'c' */
+
+static final CoordRec char99_stroke0[] = {
+    new CoordRec((float) 62.6629, (float) 52.381),
+    new CoordRec((float) 53.139, (float) 61.9048),
+    new CoordRec((float) 43.6152, (float) 66.6667),
+    new CoordRec((float) 29.3295, (float) 66.6667),
+    new CoordRec((float) 19.8057, (float) 61.9048),
+    new CoordRec((float) 10.2819, (float) 52.381),
+    new CoordRec((float) 5.52, (float) 38.0952),
+    new CoordRec((float) 5.52, (float) 28.5714),
+    new CoordRec((float) 10.2819, (float) 14.2857),
+    new CoordRec((float) 19.8057, (float) 4.7619),
+    new CoordRec((float) 29.3295, (float) 0),
+    new CoordRec((float) 43.6152, (float) 0),
+    new CoordRec((float) 53.139, (float) 4.7619),
+    new CoordRec((float) 62.6629, (float) 14.2857),
+};
+
+static final StrokeRec char99[] = {
+   new StrokeRec(14, char99_stroke0),
+};
+
+/* char: 100 'd' */
+
+static final CoordRec char100_stroke0[] = {
+    new CoordRec((float) 61.7829, (float) 100),
+    new CoordRec((float) 61.7829, (float) 0),
+};
+
+static final CoordRec char100_stroke1[] = {
+    new CoordRec((float) 61.7829, (float) 52.381),
+    new CoordRec((float) 52.259, (float) 61.9048),
+    new CoordRec((float) 42.7352, (float) 66.6667),
+    new CoordRec((float) 28.4495, (float) 66.6667),
+    new CoordRec((float) 18.9257, (float) 61.9048),
+    new CoordRec((float) 9.4019, (float) 52.381),
+    new CoordRec((float) 4.64, (float) 38.0952),
+    new CoordRec((float) 4.64, (float) 28.5714),
+    new CoordRec((float) 9.4019, (float) 14.2857),
+    new CoordRec((float) 18.9257, (float) 4.7619),
+    new CoordRec((float) 28.4495, (float) 0),
+    new CoordRec((float) 42.7352, (float) 0),
+    new CoordRec((float) 52.259, (float) 4.7619),
+    new CoordRec((float) 61.7829, (float) 14.2857),
+};
+
+static final StrokeRec char100[] = {
+   new StrokeRec(2, char100_stroke0),
+   new StrokeRec(14, char100_stroke1),
+};
+
+/* char: 101 'e' */
+
+static final CoordRec char101_stroke0[] = {
+    new CoordRec((float) 5.72, (float) 38.0952),
+    new CoordRec((float) 62.8629, (float) 38.0952),
+    new CoordRec((float) 62.8629, (float) 47.619),
+    new CoordRec((float) 58.101, (float) 57.1429),
+    new CoordRec((float) 53.339, (float) 61.9048),
+    new CoordRec((float) 43.8152, (float) 66.6667),
+    new CoordRec((float) 29.5295, (float) 66.6667),
+    new CoordRec((float) 20.0057, (float) 61.9048),
+    new CoordRec((float) 10.4819, (float) 52.381),
+    new CoordRec((float) 5.72, (float) 38.0952),
+    new CoordRec((float) 5.72, (float) 28.5714),
+    new CoordRec((float) 10.4819, (float) 14.2857),
+    new CoordRec((float) 20.0057, (float) 4.7619),
+    new CoordRec((float) 29.5295, (float) 0),
+    new CoordRec((float) 43.8152, (float) 0),
+    new CoordRec((float) 53.339, (float) 4.7619),
+    new CoordRec((float) 62.8629, (float) 14.2857),
+};
+
+static final StrokeRec char101[] = {
+   new StrokeRec(17, char101_stroke0),
+};
+
+/* char: 102 'f' */
+
+static final CoordRec char102_stroke0[] = {
+    new CoordRec((float) 38.7752, (float) 100),
+    new CoordRec((float) 29.2514, (float) 100),
+    new CoordRec((float) 19.7276, (float) 95.2381),
+    new CoordRec((float) 14.9657, (float) 80.9524),
+    new CoordRec((float) 14.9657, (float) 0),
+};
+
+static final CoordRec char102_stroke1[] = {
+    new CoordRec((float) 0.68, (float) 66.6667),
+    new CoordRec((float) 34.0133, (float) 66.6667),
+};
+
+static final StrokeRec char102[] = {
+   new StrokeRec(5, char102_stroke0),
+   new StrokeRec(2, char102_stroke1),
+};
+
+/* char: 103 'g' */
+
+static final CoordRec char103_stroke0[] = {
+    new CoordRec((float) 62.5029, (float) 66.6667),
+    new CoordRec((float) 62.5029, (float) -9.5238),
+    new CoordRec((float) 57.741, (float) -23.8095),
+    new CoordRec((float) 52.979, (float) -28.5714),
+    new CoordRec((float) 43.4552, (float) -33.3333),
+    new CoordRec((float) 29.1695, (float) -33.3333),
+    new CoordRec((float) 19.6457, (float) -28.5714),
+};
+
+static final CoordRec char103_stroke1[] = {
+    new CoordRec((float) 62.5029, (float) 52.381),
+    new CoordRec((float) 52.979, (float) 61.9048),
+    new CoordRec((float) 43.4552, (float) 66.6667),
+    new CoordRec((float) 29.1695, (float) 66.6667),
+    new CoordRec((float) 19.6457, (float) 61.9048),
+    new CoordRec((float) 10.1219, (float) 52.381),
+    new CoordRec((float) 5.36, (float) 38.0952),
+    new CoordRec((float) 5.36, (float) 28.5714),
+    new CoordRec((float) 10.1219, (float) 14.2857),
+    new CoordRec((float) 19.6457, (float) 4.7619),
+    new CoordRec((float) 29.1695, (float) 0),
+    new CoordRec((float) 43.4552, (float) 0),
+    new CoordRec((float) 52.979, (float) 4.7619),
+    new CoordRec((float) 62.5029, (float) 14.2857),
+};
+
+static final StrokeRec char103[] = {
+   new StrokeRec(7, char103_stroke0),
+   new StrokeRec(14, char103_stroke1),
+};
+
+/* char: 104 'h' */
+
+static final CoordRec char104_stroke0[] = {
+    new CoordRec((float) 9.6, (float) 100),
+    new CoordRec((float) 9.6, (float) 0),
+};
+
+static final CoordRec char104_stroke1[] = {
+    new CoordRec((float) 9.6, (float) 47.619),
+    new CoordRec((float) 23.8857, (float) 61.9048),
+    new CoordRec((float) 33.4095, (float) 66.6667),
+    new CoordRec((float) 47.6952, (float) 66.6667),
+    new CoordRec((float) 57.219, (float) 61.9048),
+    new CoordRec((float) 61.981, (float) 47.619),
+    new CoordRec((float) 61.981, (float) 0),
+};
+
+static final StrokeRec char104[] = {
+   new StrokeRec(2, char104_stroke0),
+   new StrokeRec(7, char104_stroke1),
+};
+
+/* char: 105 'i' */
+
+static final CoordRec char105_stroke0[] = {
+    new CoordRec((float) 10.02, (float) 100),
+    new CoordRec((float) 14.7819, (float) 95.2381),
+    new CoordRec((float) 19.5438, (float) 100),
+    new CoordRec((float) 14.7819, (float) 104.762),
+    new CoordRec((float) 10.02, (float) 100),
+};
+
+static final CoordRec char105_stroke1[] = {
+    new CoordRec((float) 14.7819, (float) 66.6667),
+    new CoordRec((float) 14.7819, (float) 0),
+};
+
+static final StrokeRec char105[] = {
+   new StrokeRec(5, char105_stroke0),
+   new StrokeRec(2, char105_stroke1),
+};
+
+/* char: 106 'j' */
+
+static final CoordRec char106_stroke0[] = {
+    new CoordRec((float) 17.3876, (float) 100),
+    new CoordRec((float) 22.1495, (float) 95.2381),
+    new CoordRec((float) 26.9114, (float) 100),
+    new CoordRec((float) 22.1495, (float) 104.762),
+    new CoordRec((float) 17.3876, (float) 100),
+};
+
+static final CoordRec char106_stroke1[] = {
+    new CoordRec((float) 22.1495, (float) 66.6667),
+    new CoordRec((float) 22.1495, (float) -14.2857),
+    new CoordRec((float) 17.3876, (float) -28.5714),
+    new CoordRec((float) 7.8638, (float) -33.3333),
+    new CoordRec((float)-1.66, (float) -33.3333),
+};
+
+static final StrokeRec char106[] = {
+   new StrokeRec(5, char106_stroke0),
+   new StrokeRec(5, char106_stroke1),
+};
+
+/* char: 107 'k' */
+
+static final CoordRec char107_stroke0[] = {
+    new CoordRec((float) 9.6, (float) 100),
+    new CoordRec((float) 9.6, (float) 0),
+};
+
+static final CoordRec char107_stroke1[] = {
+    new CoordRec((float) 57.219, (float) 66.6667),
+    new CoordRec((float) 9.6, (float) 19.0476),
+};
+
+static final CoordRec char107_stroke2[] = {
+    new CoordRec((float) 28.6476, (float) 38.0952),
+    new CoordRec((float) 61.981, (float) 0),
+};
+
+static final StrokeRec char107[] = {
+   new StrokeRec(2, char107_stroke0),
+   new StrokeRec(2, char107_stroke1),
+   new StrokeRec(2, char107_stroke2),
+};
+
+/* char: 108 'l' */
+
+static final CoordRec char108_stroke0[] = {
+    new CoordRec((float) 10.02, (float) 100),
+    new CoordRec((float) 10.02, (float) 0),
+};
+
+static final StrokeRec char108[] = {
+   new StrokeRec(2, char108_stroke0),
+};
+
+/* char: 109 'm' */
+
+static final CoordRec char109_stroke0[] = {
+    new CoordRec((float) 9.6, (float) 66.6667),
+    new CoordRec((float) 9.6, (float) 0),
+};
+
+static final CoordRec char109_stroke1[] = {
+    new CoordRec((float) 9.6, (float) 47.619),
+    new CoordRec((float) 23.8857, (float) 61.9048),
+    new CoordRec((float) 33.4095, (float) 66.6667),
+    new CoordRec((float) 47.6952, (float) 66.6667),
+    new CoordRec((float) 57.219, (float) 61.9048),
+    new CoordRec((float) 61.981, (float) 47.619),
+    new CoordRec((float) 61.981, (float) 0),
+};
+
+static final CoordRec char109_stroke2[] = {
+    new CoordRec((float) 61.981, (float) 47.619),
+    new CoordRec((float) 76.2667, (float) 61.9048),
+    new CoordRec((float) 85.7905, (float) 66.6667),
+    new CoordRec((float) 100.076, (float) 66.6667),
+    new CoordRec((float) 109.6, (float) 61.9048),
+    new CoordRec((float) 114.362, (float) 47.619),
+    new CoordRec((float) 114.362, (float) 0),
+};
+
+static final StrokeRec char109[] = {
+   new StrokeRec(2, char109_stroke0),
+   new StrokeRec(7, char109_stroke1),
+   new StrokeRec(7, char109_stroke2),
+};
+
+/* char: 110 'n' */
+
+static final CoordRec char110_stroke0[] = {
+    new CoordRec((float) 9.18, (float) 66.6667),
+    new CoordRec((float) 9.18, (float) 0),
+};
+
+static final CoordRec char110_stroke1[] = {
+    new CoordRec((float) 9.18, (float) 47.619),
+    new CoordRec((float) 23.4657, (float) 61.9048),
+    new CoordRec((float) 32.9895, (float) 66.6667),
+    new CoordRec((float) 47.2752, (float) 66.6667),
+    new CoordRec((float) 56.799, (float) 61.9048),
+    new CoordRec((float) 61.561, (float) 47.619),
+    new CoordRec((float) 61.561, (float) 0),
+};
+
+static final StrokeRec char110[] = {
+   new StrokeRec(2, char110_stroke0),
+   new StrokeRec(7, char110_stroke1),
+};
+
+/* char: 111 'o' */
+
+static final CoordRec char111_stroke0[] = {
+    new CoordRec((float) 28.7895, (float) 66.6667),
+    new CoordRec((float) 19.2657, (float) 61.9048),
+    new CoordRec((float) 9.7419, (float) 52.381),
+    new CoordRec((float) 4.98, (float) 38.0952),
+    new CoordRec((float) 4.98, (float) 28.5714),
+    new CoordRec((float) 9.7419, (float) 14.2857),
+    new CoordRec((float) 19.2657, (float) 4.7619),
+    new CoordRec((float) 28.7895, (float) 0),
+    new CoordRec((float) 43.0752, (float) 0),
+    new CoordRec((float) 52.599, (float) 4.7619),
+    new CoordRec((float) 62.1229, (float) 14.2857),
+    new CoordRec((float) 66.8848, (float) 28.5714),
+    new CoordRec((float) 66.8848, (float) 38.0952),
+    new CoordRec((float) 62.1229, (float) 52.381),
+    new CoordRec((float) 52.599, (float) 61.9048),
+    new CoordRec((float) 43.0752, (float) 66.6667),
+    new CoordRec((float) 28.7895, (float) 66.6667),
+};
+
+static final StrokeRec char111[] = {
+   new StrokeRec(17, char111_stroke0),
+};
+
+/* char: 112 'p' */
+
+static final CoordRec char112_stroke0[] = {
+    new CoordRec((float) 9.46, (float) 66.6667),
+    new CoordRec((float) 9.46, (float) -33.3333),
+};
+
+static final CoordRec char112_stroke1[] = {
+    new CoordRec((float) 9.46, (float) 52.381),
+    new CoordRec((float) 18.9838, (float) 61.9048),
+    new CoordRec((float) 28.5076, (float) 66.6667),
+    new CoordRec((float) 42.7933, (float) 66.6667),
+    new CoordRec((float) 52.3171, (float) 61.9048),
+    new CoordRec((float) 61.841, (float) 52.381),
+    new CoordRec((float) 66.6029, (float) 38.0952),
+    new CoordRec((float) 66.6029, (float) 28.5714),
+    new CoordRec((float) 61.841, (float) 14.2857),
+    new CoordRec((float) 52.3171, (float) 4.7619),
+    new CoordRec((float) 42.7933, (float) 0),
+    new CoordRec((float) 28.5076, (float) 0),
+    new CoordRec((float) 18.9838, (float) 4.7619),
+    new CoordRec((float) 9.46, (float) 14.2857),
+};
+
+static final StrokeRec char112[] = {
+   new StrokeRec(2, char112_stroke0),
+   new StrokeRec(14, char112_stroke1),
+};
+
+/* char: 113 'q' */
+
+static final CoordRec char113_stroke0[] = {
+    new CoordRec((float) 61.9829, (float) 66.6667),
+    new CoordRec((float) 61.9829, (float) -33.3333),
+};
+
+static final CoordRec char113_stroke1[] = {
+    new CoordRec((float) 61.9829, (float) 52.381),
+    new CoordRec((float) 52.459, (float) 61.9048),
+    new CoordRec((float) 42.9352, (float) 66.6667),
+    new CoordRec((float) 28.6495, (float) 66.6667),
+    new CoordRec((float) 19.1257, (float) 61.9048),
+    new CoordRec((float) 9.6019, (float) 52.381),
+    new CoordRec((float) 4.84, (float) 38.0952),
+    new CoordRec((float) 4.84, (float) 28.5714),
+    new CoordRec((float) 9.6019, (float) 14.2857),
+    new CoordRec((float) 19.1257, (float) 4.7619),
+    new CoordRec((float) 28.6495, (float) 0),
+    new CoordRec((float) 42.9352, (float) 0),
+    new CoordRec((float) 52.459, (float) 4.7619),
+    new CoordRec((float) 61.9829, (float) 14.2857),
+};
+
+static final StrokeRec char113[] = {
+   new StrokeRec(2, char113_stroke0),
+   new StrokeRec(14, char113_stroke1),
+};
+
+/* char: 114 'r' */
+
+static final CoordRec char114_stroke0[] = {
+    new CoordRec((float) 9.46, (float) 66.6667),
+    new CoordRec((float) 9.46, (float) 0),
+};
+
+static final CoordRec char114_stroke1[] = {
+    new CoordRec((float) 9.46, (float) 38.0952),
+    new CoordRec((float) 14.2219, (float) 52.381),
+    new CoordRec((float) 23.7457, (float) 61.9048),
+    new CoordRec((float) 33.2695, (float) 66.6667),
+    new CoordRec((float) 47.5552, (float) 66.6667),
+};
+
+static final StrokeRec char114[] = {
+   new StrokeRec(2, char114_stroke0),
+   new StrokeRec(5, char114_stroke1),
+};
+
+/* char: 115 's' */
+
+static final CoordRec char115_stroke0[] = {
+    new CoordRec((float) 57.081, (float) 52.381),
+    new CoordRec((float) 52.319, (float) 61.9048),
+    new CoordRec((float) 38.0333, (float) 66.6667),
+    new CoordRec((float) 23.7476, (float) 66.6667),
+    new CoordRec((float) 9.4619, (float) 61.9048),
+    new CoordRec((float) 4.7, (float) 52.381),
+    new CoordRec((float) 9.4619, (float) 42.8571),
+    new CoordRec((float) 18.9857, (float) 38.0952),
+    new CoordRec((float) 42.7952, (float) 33.3333),
+    new CoordRec((float) 52.319, (float) 28.5714),
+    new CoordRec((float) 57.081, (float) 19.0476),
+    new CoordRec((float) 57.081, (float) 14.2857),
+    new CoordRec((float) 52.319, (float) 4.7619),
+    new CoordRec((float) 38.0333, (float) 0),
+    new CoordRec((float) 23.7476, (float) 0),
+    new CoordRec((float) 9.4619, (float) 4.7619),
+    new CoordRec((float) 4.7, (float) 14.2857),
+};
+
+static final StrokeRec char115[] = {
+   new StrokeRec(17, char115_stroke0),
+};
+
+/* char: 116 't' */
+
+static final CoordRec char116_stroke0[] = {
+    new CoordRec((float) 14.8257, (float) 100),
+    new CoordRec((float) 14.8257, (float) 19.0476),
+    new CoordRec((float) 19.5876, (float) 4.7619),
+    new CoordRec((float) 29.1114, (float) 0),
+    new CoordRec((float) 38.6352, (float) 0),
+};
+
+static final CoordRec char116_stroke1[] = {
+    new CoordRec((float) 0.54, (float) 66.6667),
+    new CoordRec((float) 33.8733, (float) 66.6667),
+};
+
+static final StrokeRec char116[] = {
+   new StrokeRec(5, char116_stroke0),
+   new StrokeRec(2, char116_stroke1),
+};
+
+/* char: 117 'u' */
+
+static final CoordRec char117_stroke0[] = {
+    new CoordRec((float) 9.46, (float) 66.6667),
+    new CoordRec((float) 9.46, (float) 19.0476),
+    new CoordRec((float) 14.2219, (float) 4.7619),
+    new CoordRec((float) 23.7457, (float) 0),
+    new CoordRec((float) 38.0314, (float) 0),
+    new CoordRec((float) 47.5552, (float) 4.7619),
+    new CoordRec((float) 61.841, (float) 19.0476),
+};
+
+static final CoordRec char117_stroke1[] = {
+    new CoordRec((float) 61.841, (float) 66.6667),
+    new CoordRec((float) 61.841, (float) 0),
+};
+
+static final StrokeRec char117[] = {
+   new StrokeRec(7, char117_stroke0),
+   new StrokeRec(2, char117_stroke1),
+};
+
+/* char: 118 'v' */
+
+static final CoordRec char118_stroke0[] = {
+    new CoordRec((float) 1.8, (float) 66.6667),
+    new CoordRec((float) 30.3714, (float) 0),
+};
+
+static final CoordRec char118_stroke1[] = {
+    new CoordRec((float) 58.9429, (float) 66.6667),
+    new CoordRec((float) 30.3714, (float) 0),
+};
+
+static final StrokeRec char118[] = {
+   new StrokeRec(2, char118_stroke0),
+   new StrokeRec(2, char118_stroke1),
+};
+
+/* char: 119 'w' */
+
+static final CoordRec char119_stroke0[] = {
+    new CoordRec((float) 2.5, (float) 66.6667),
+    new CoordRec((float) 21.5476, (float) 0),
+};
+
+static final CoordRec char119_stroke1[] = {
+    new CoordRec((float) 40.5952, (float) 66.6667),
+    new CoordRec((float) 21.5476, (float) 0),
+};
+
+static final CoordRec char119_stroke2[] = {
+    new CoordRec((float) 40.5952, (float) 66.6667),
+    new CoordRec((float) 59.6429, (float) 0),
+};
+
+static final CoordRec char119_stroke3[] = {
+    new CoordRec((float) 78.6905, (float) 66.6667),
+    new CoordRec((float) 59.6429, (float) 0),
+};
+
+static final StrokeRec char119[] = {
+   new StrokeRec(2, char119_stroke0),
+   new StrokeRec(2, char119_stroke1),
+   new StrokeRec(2, char119_stroke2),
+   new StrokeRec(2, char119_stroke3),
+};
+
+/* char: 120 'x' */
+
+static final CoordRec char120_stroke0[] = {
+    new CoordRec((float) 1.66, (float) 66.6667),
+    new CoordRec((float) 54.041, (float) 0),
+};
+
+static final CoordRec char120_stroke1[] = {
+    new CoordRec((float) 54.041, (float) 66.6667),
+    new CoordRec((float) 1.66, (float) 0),
+};
+
+static final StrokeRec char120[] = {
+   new StrokeRec(2, char120_stroke0),
+   new StrokeRec(2, char120_stroke1),
+};
+
+/* char: 121 'y' */
+
+static final CoordRec char121_stroke0[] = {
+    new CoordRec((float) 6.5619, (float) 66.6667),
+    new CoordRec((float) 35.1333, (float) 0),
+};
+
+static final CoordRec char121_stroke1[] = {
+    new CoordRec((float) 63.7048, (float) 66.6667),
+    new CoordRec((float) 35.1333, (float) 0),
+    new CoordRec((float) 25.6095, (float) -19.0476),
+    new CoordRec((float) 16.0857, (float) -28.5714),
+    new CoordRec((float) 6.5619, (float) -33.3333),
+    new CoordRec((float) 1.8, (float) -33.3333),
+};
+
+static final StrokeRec char121[] = {
+   new StrokeRec(2, char121_stroke0),
+   new StrokeRec(6, char121_stroke1),
+};
+
+/* char: 122 'z' */
+
+static final CoordRec char122_stroke0[] = {
+    new CoordRec((float) 56.821, (float) 66.6667),
+    new CoordRec((float) 4.44, (float) 0),
+};
+
+static final CoordRec char122_stroke1[] = {
+    new CoordRec((float) 4.44, (float) 66.6667),
+    new CoordRec((float) 56.821, (float) 66.6667),
+};
+
+static final CoordRec char122_stroke2[] = {
+    new CoordRec((float) 4.44, (float) 0),
+    new CoordRec((float) 56.821, (float) 0),
+};
+
+static final StrokeRec char122[] = {
+   new StrokeRec(2, char122_stroke0),
+   new StrokeRec(2, char122_stroke1),
+   new StrokeRec(2, char122_stroke2),
+};
+
+/* char: 123 '{' */
+
+static final CoordRec char123_stroke0[] = {
+    new CoordRec((float) 31.1895, (float) 119.048),
+    new CoordRec((float) 21.6657, (float) 114.286),
+    new CoordRec((float) 16.9038, (float) 109.524),
+    new CoordRec((float) 12.1419, (float) 100),
+    new CoordRec((float) 12.1419, (float) 90.4762),
+    new CoordRec((float) 16.9038, (float) 80.9524),
+    new CoordRec((float) 21.6657, (float) 76.1905),
+    new CoordRec((float) 26.4276, (float) 66.6667),
+    new CoordRec((float) 26.4276, (float) 57.1429),
+    new CoordRec((float) 16.9038, (float) 47.619),
+};
+
+static final CoordRec char123_stroke1[] = {
+    new CoordRec((float) 21.6657, (float) 114.286),
+    new CoordRec((float) 16.9038, (float) 104.762),
+    new CoordRec((float) 16.9038, (float) 95.2381),
+    new CoordRec((float) 21.6657, (float) 85.7143),
+    new CoordRec((float) 26.4276, (float) 80.9524),
+    new CoordRec((float) 31.1895, (float) 71.4286),
+    new CoordRec((float) 31.1895, (float) 61.9048),
+    new CoordRec((float) 26.4276, (float) 52.381),
+    new CoordRec((float) 7.38, (float) 42.8571),
+    new CoordRec((float) 26.4276, (float) 33.3333),
+    new CoordRec((float) 31.1895, (float) 23.8095),
+    new CoordRec((float) 31.1895, (float) 14.2857),
+    new CoordRec((float) 26.4276, (float) 4.7619),
+    new CoordRec((float) 21.6657, (float) 0),
+    new CoordRec((float) 16.9038, (float) -9.5238),
+    new CoordRec((float) 16.9038, (float) -19.0476),
+    new CoordRec((float) 21.6657, (float) -28.5714),
+};
+
+static final CoordRec char123_stroke2[] = {
+    new CoordRec((float) 16.9038, (float) 38.0952),
+    new CoordRec((float) 26.4276, (float) 28.5714),
+    new CoordRec((float) 26.4276, (float) 19.0476),
+    new CoordRec((float) 21.6657, (float) 9.5238),
+    new CoordRec((float) 16.9038, (float) 4.7619),
+    new CoordRec((float) 12.1419, (float) -4.7619),
+    new CoordRec((float) 12.1419, (float) -14.2857),
+    new CoordRec((float) 16.9038, (float) -23.8095),
+    new CoordRec((float) 21.6657, (float) -28.5714),
+    new CoordRec((float) 31.1895, (float) -33.3333),
+};
+
+static final StrokeRec char123[] = {
+   new StrokeRec(10, char123_stroke0),
+   new StrokeRec(17, char123_stroke1),
+   new StrokeRec(10, char123_stroke2),
+};
+
+/* char: 124 '|' */
+
+static final CoordRec char124_stroke0[] = {
+    new CoordRec((float) 11.54, (float) 119.048),
+    new CoordRec((float) 11.54, (float) -33.3333),
+};
+
+static final StrokeRec char124[] = {
+   new StrokeRec(2, char124_stroke0),
+};
+
+/* char: 125 '}' */
+
+static final CoordRec char125_stroke0[] = {
+    new CoordRec((float) 9.18, (float) 119.048),
+    new CoordRec((float) 18.7038, (float) 114.286),
+    new CoordRec((float) 23.4657, (float) 109.524),
+    new CoordRec((float) 28.2276, (float) 100),
+    new CoordRec((float) 28.2276, (float) 90.4762),
+    new CoordRec((float) 23.4657, (float) 80.9524),
+    new CoordRec((float) 18.7038, (float) 76.1905),
+    new CoordRec((float) 13.9419, (float) 66.6667),
+    new CoordRec((float) 13.9419, (float) 57.1429),
+    new CoordRec((float) 23.4657, (float) 47.619),
+};
+
+static final CoordRec char125_stroke1[] = {
+    new CoordRec((float) 18.7038, (float) 114.286),
+    new CoordRec((float) 23.4657, (float) 104.762),
+    new CoordRec((float) 23.4657, (float) 95.2381),
+    new CoordRec((float) 18.7038, (float) 85.7143),
+    new CoordRec((float) 13.9419, (float) 80.9524),
+    new CoordRec((float) 9.18, (float) 71.4286),
+    new CoordRec((float) 9.18, (float) 61.9048),
+    new CoordRec((float) 13.9419, (float) 52.381),
+    new CoordRec((float) 32.9895, (float) 42.8571),
+    new CoordRec((float) 13.9419, (float) 33.3333),
+    new CoordRec((float) 9.18, (float) 23.8095),
+    new CoordRec((float) 9.18, (float) 14.2857),
+    new CoordRec((float) 13.9419, (float) 4.7619),
+    new CoordRec((float) 18.7038, (float) 0),
+    new CoordRec((float) 23.4657, (float) -9.5238),
+    new CoordRec((float) 23.4657, (float) -19.0476),
+    new CoordRec((float) 18.7038, (float) -28.5714),
+};
+
+static final CoordRec char125_stroke2[] = {
+    new CoordRec((float) 23.4657, (float) 38.0952),
+    new CoordRec((float) 13.9419, (float) 28.5714),
+    new CoordRec((float) 13.9419, (float) 19.0476),
+    new CoordRec((float) 18.7038, (float) 9.5238),
+    new CoordRec((float) 23.4657, (float) 4.7619),
+    new CoordRec((float) 28.2276, (float) -4.7619),
+    new CoordRec((float) 28.2276, (float) -14.2857),
+    new CoordRec((float) 23.4657, (float) -23.8095),
+    new CoordRec((float) 18.7038, (float) -28.5714),
+    new CoordRec((float) 9.18, (float) -33.3333),
+};
+
+static final StrokeRec char125[] = {
+   new StrokeRec(10, char125_stroke0),
+   new StrokeRec(17, char125_stroke1),
+   new StrokeRec(10, char125_stroke2),
+};
+
+/* char: 126 '~' */
+
+static final CoordRec char126_stroke0[] = {
+    new CoordRec((float) 2.92, (float) 28.5714),
+    new CoordRec((float) 2.92, (float) 38.0952),
+    new CoordRec((float) 7.6819, (float) 52.381),
+    new CoordRec((float) 17.2057, (float) 57.1429),
+    new CoordRec((float) 26.7295, (float) 57.1429),
+    new CoordRec((float) 36.2533, (float) 52.381),
+    new CoordRec((float) 55.301, (float) 38.0952),
+    new CoordRec((float) 64.8248, (float) 33.3333),
+    new CoordRec((float) 74.3486, (float) 33.3333),
+    new CoordRec((float) 83.8724, (float) 38.0952),
+    new CoordRec((float) 88.6343, (float) 47.619),
+};
+
+static final CoordRec char126_stroke1[] = {
+    new CoordRec((float) 2.92, (float) 38.0952),
+    new CoordRec((float) 7.6819, (float) 47.619),
+    new CoordRec((float) 17.2057, (float) 52.381),
+    new CoordRec((float) 26.7295, (float) 52.381),
+    new CoordRec((float) 36.2533, (float) 47.619),
+    new CoordRec((float) 55.301, (float) 33.3333),
+    new CoordRec((float) 64.8248, (float) 28.5714),
+    new CoordRec((float) 74.3486, (float) 28.5714),
+    new CoordRec((float) 83.8724, (float) 33.3333),
+    new CoordRec((float) 88.6343, (float) 47.619),
+    new CoordRec((float) 88.6343, (float) 57.1429),
+};
+
+static final StrokeRec char126[] = {
+   new StrokeRec(11, char126_stroke0),
+   new StrokeRec(11, char126_stroke1),
+};
+
+/* char: 127 */
+
+static final CoordRec char127_stroke0[] = {
+    new CoordRec((float) 52.381, (float) 100),
+    new CoordRec((float) 14.2857, (float) -33.3333),
+};
+
+static final CoordRec char127_stroke1[] = {
+    new CoordRec((float) 28.5714, (float) 66.6667),
+    new CoordRec((float) 14.2857, (float) 61.9048),
+    new CoordRec((float) 4.7619, (float) 52.381),
+    new CoordRec((float) 0, (float) 38.0952),
+    new CoordRec((float) 0, (float) 23.8095),
+    new CoordRec((float) 4.7619, (float) 14.2857),
+    new CoordRec((float) 14.2857, (float) 4.7619),
+    new CoordRec((float) 28.5714, (float) 0),
+    new CoordRec((float) 38.0952, (float) 0),
+    new CoordRec((float) 52.381, (float) 4.7619),
+    new CoordRec((float) 61.9048, (float) 14.2857),
+    new CoordRec((float) 66.6667, (float) 28.5714),
+    new CoordRec((float) 66.6667, (float) 42.8571),
+    new CoordRec((float) 61.9048, (float) 52.381),
+    new CoordRec((float) 52.381, (float) 61.9048),
+    new CoordRec((float) 38.0952, (float) 66.6667),
+    new CoordRec((float) 28.5714, (float) 66.6667),
+};
+
+static final StrokeRec char127[] = {
+   new StrokeRec(2, char127_stroke0),
+   new StrokeRec(17, char127_stroke1),
+};
+
+static final StrokeCharRec chars[] = {
+    new StrokeCharRec( 0, /* char0 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec( 0, /* char1 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec( 0, /* char2 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec( 0, /* char3 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec( 0, /* char4 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec( 0, /* char5 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec( 0, /* char6 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec( 0, /* char7 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec( 0, /* char8 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec( 0, /* char9 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec( 0, /* char10 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec( 0, /* char11 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec( 0, /* char12 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec( 0, /* char13 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec( 0, /* char14 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec( 0, /* char15 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec( 0, /* char16 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec( 0, /* char17 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec( 0, /* char18 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec( 0, /* char19 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec( 0, /* char20 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec( 0, /* char21 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec( 0, /* char22 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec( 0, /* char23 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec( 0, /* char24 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec( 0, /* char25 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec( 0, /* char26 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec( 0, /* char27 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec( 0, /* char28 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec( 0, /* char29 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec( 0, /* char30 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec( 0, /* char31 */ null, (float) 0, (float) 0 ),
+    new StrokeCharRec( 0, /* char32 */ null, (float) 52.381, (float) 104.762 ),
+    new StrokeCharRec( 2, char33, (float) 13.3819, (float) 26.6238 ),
+    new StrokeCharRec( 2, char34, (float) 23.0676, (float) 51.4352 ),
+    new StrokeCharRec( 4, char35, (float) 36.5333, (float) 79.4886 ),
+    new StrokeCharRec( 3, char36, (float) 38.1533, (float) 76.2067 ),
+    new StrokeCharRec( 3, char37, (float) 49.2171, (float) 96.5743 ),
+    new StrokeCharRec( 1, char38, (float) 53.599, (float) 101.758 ),
+    new StrokeCharRec( 1, char39, (float) 4.44, (float) 13.62 ),
+    new StrokeCharRec( 1, char40, (float) 21.8657, (float) 47.1733 ),
+    new StrokeCharRec( 1, char41, (float) 24.3276, (float) 47.5333 ),
+    new StrokeCharRec( 3, char42, (float) 30.7695, (float) 59.439 ),
+    new StrokeCharRec( 2, char43, (float) 48.8371, (float) 97.2543 ),
+    new StrokeCharRec( 1, char44, (float) 13.5219, (float) 26.0638 ),
+    new StrokeCharRec( 1, char45, (float) 50.2371, (float) 100.754 ),
+    new StrokeCharRec( 1, char46, (float) 13.1019, (float) 26.4838 ),
+    new StrokeCharRec( 1, char47, (float) 40.5733, (float) 82.1067 ),
+    new StrokeCharRec( 1, char48, (float) 38.3133, (float) 77.0667 ),
+    new StrokeCharRec( 1, char49, (float) 30.8676, (float) 66.5295 ),
+    new StrokeCharRec( 1, char50, (float) 38.7533, (float) 77.6467 ),
+    new StrokeCharRec( 1, char51, (float) 38.3333, (float) 77.0467 ),
+    new StrokeCharRec( 2, char52, (float) 37.2133, (float) 80.1686 ),
+    new StrokeCharRec( 1, char53, (float) 38.1933, (float) 77.6867 ),
+    new StrokeCharRec( 1, char54, (float) 34.1514, (float) 73.8048 ),
+    new StrokeCharRec( 2, char55, (float) 38.8933, (float) 77.2267 ),
+    new StrokeCharRec( 1, char56, (float) 38.9333, (float) 77.6667 ),
+    new StrokeCharRec( 1, char57, (float) 39.9333, (float) 74.0648 ),
+    new StrokeCharRec( 2, char58, (float) 14.0819, (float) 26.2238 ),
+    new StrokeCharRec( 2, char59, (float) 12.9619, (float) 26.3038 ),
+    new StrokeCharRec( 1, char60, (float) 41.1552, (float) 81.6105 ),
+    new StrokeCharRec( 2, char61, (float) 48.5571, (float) 97.2543 ),
+    new StrokeCharRec( 1, char62, (float) 40.8752, (float) 81.6105 ),
+    new StrokeCharRec( 2, char63, (float) 36.9914, (float) 73.9029 ),
+    new StrokeCharRec( 2, char64, (float) 34.9314, (float) 74.3648 ),
+    new StrokeCharRec( 3, char65, (float) 40.5952, (float) 80.4905 ),
+    new StrokeCharRec( 3, char66, (float) 44.7533, (float) 83.6267 ),
+    new StrokeCharRec( 1, char67, (float) 39.9933, (float) 84.4886 ),
+    new StrokeCharRec( 2, char68, (float) 45.2933, (float) 85.2867 ),
+    new StrokeCharRec( 4, char69, (float) 39.9914, (float) 78.1848 ),
+    new StrokeCharRec( 3, char70, (float) 39.9914, (float) 78.7448 ),
+    new StrokeCharRec( 2, char71, (float) 40.3933, (float) 89.7686 ),
+    new StrokeCharRec( 3, char72, (float) 44.7533, (float) 89.0867 ),
+    new StrokeCharRec( 1, char73, (float) 10.86, (float) 21.3 ),
+    new StrokeCharRec( 1, char74, (float) 31.0714, (float) 59.999 ),
+    new StrokeCharRec( 3, char75, (float) 44.6133, (float) 79.3267 ),
+    new StrokeCharRec( 2, char76, (float) 40.2514, (float) 71.3229 ),
+    new StrokeCharRec( 4, char77, (float) 48.9552, (float) 97.2105 ),
+    new StrokeCharRec( 3, char78, (float) 44.4733, (float) 88.8067 ),
+    new StrokeCharRec( 1, char79, (float) 44.3352, (float) 88.8305 ),
+    new StrokeCharRec( 2, char80, (float) 45.4333, (float) 85.6667 ),
+    new StrokeCharRec( 2, char81, (float) 43.3952, (float) 88.0905 ),
+    new StrokeCharRec( 3, char82, (float) 45.0133, (float) 82.3667 ),
+    new StrokeCharRec( 1, char83, (float) 41.3333, (float) 80.8267 ),
+    new StrokeCharRec( 2, char84, (float) 35.6933, (float) 71.9467 ),
+    new StrokeCharRec( 1, char85, (float) 44.8733, (float) 89.4867 ),
+    new StrokeCharRec( 2, char86, (float) 40.4552, (float) 81.6105 ),
+    new StrokeCharRec( 4, char87, (float) 49.839, (float) 100.518 ),
+    new StrokeCharRec( 2, char88, (float) 35.8333, (float) 72.3667 ),
+    new StrokeCharRec( 2, char89, (float) 39.6152, (float) 79.6505 ),
+    new StrokeCharRec( 3, char90, (float) 35.8333, (float) 73.7467 ),
+    new StrokeCharRec( 4, char91, (float) 22.0657, (float) 46.1133 ),
+    new StrokeCharRec( 1, char92, (float) 39.1733, (float) 78.2067 ),
+    new StrokeCharRec( 4, char93, (float) 23.4876, (float) 46.3933 ),
+    new StrokeCharRec( 2, char94, (float) 44.0752, (float) 90.2305 ),
+    new StrokeCharRec( 1, char95, (float) 51.281, (float) 104.062 ),
+    new StrokeCharRec( 2, char96, (float) 42.5457, (float) 83.5714 ),
+    new StrokeCharRec( 2, char97, (float) 35.2514, (float) 66.6029 ),
+    new StrokeCharRec( 2, char98, (float) 37.3314, (float) 70.4629 ),
+    new StrokeCharRec( 1, char99, (float) 34.0914, (float) 68.9229 ),
+    new StrokeCharRec( 2, char100, (float) 33.2114, (float) 70.2629 ),
+    new StrokeCharRec( 1, char101, (float) 34.2914, (float) 68.5229 ),
+    new StrokeCharRec( 2, char102, (float) 14.9657, (float) 38.6552 ),
+    new StrokeCharRec( 2, char103, (float) 33.9314, (float) 70.9829 ),
+    new StrokeCharRec( 2, char104, (float) 33.4095, (float) 71.021 ),
+    new StrokeCharRec( 2, char105, (float) 14.7819, (float) 28.8638 ),
+    new StrokeCharRec( 2, char106, (float) 17.3876, (float) 36.2314 ),
+    new StrokeCharRec( 3, char107, (float) 33.4095, (float) 62.521 ),
+    new StrokeCharRec( 1, char108, (float) 10.02, (float) 19.34 ),
+    new StrokeCharRec( 3, char109, (float) 61.981, (float) 123.962 ),
+    new StrokeCharRec( 2, char110, (float) 32.9895, (float) 70.881 ),
+    new StrokeCharRec( 1, char111, (float) 33.5514, (float) 71.7448 ),
+    new StrokeCharRec( 2, char112, (float) 38.0314, (float) 70.8029 ),
+    new StrokeCharRec( 2, char113, (float) 33.4114, (float) 70.7429 ),
+    new StrokeCharRec( 2, char114, (float) 23.7457, (float) 49.4952 ),
+    new StrokeCharRec( 1, char115, (float) 28.5095, (float) 62.321 ),
+    new StrokeCharRec( 2, char116, (float) 14.8257, (float) 39.3152 ),
+    new StrokeCharRec( 2, char117, (float) 33.2695, (float) 71.161 ),
+    new StrokeCharRec( 2, char118, (float) 30.3714, (float) 60.6029 ),
+    new StrokeCharRec( 4, char119, (float) 40.5952, (float) 80.4905 ),
+    new StrokeCharRec( 2, char120, (float) 25.4695, (float) 56.401 ),
+    new StrokeCharRec( 2, char121, (float) 35.1333, (float) 66.0648 ),
+    new StrokeCharRec( 3, char122, (float) 28.2495, (float) 61.821 ),
+    new StrokeCharRec( 3, char123, (float) 21.6657, (float) 41.6295 ),
+    new StrokeCharRec( 1, char124, (float) 11.54, (float) 23.78 ),
+    new StrokeCharRec( 3, char125, (float) 18.7038, (float) 41.4695 ),
+    new StrokeCharRec( 2, char126, (float) 45.7771, (float) 91.2743 ),
+    new StrokeCharRec( 2, char127, (float) 33.3333, (float) 66.6667 ),
+};
+
+public static final StrokeFontRec glutStrokeRoman = new StrokeFontRec( "Roman", 128, chars, (float) 119.048, (float) -33.3333 );
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/gl2/StrokeCharRec.java b/src/jogl/classes/com/jogamp/opengl/util/gl2/StrokeCharRec.java
new file mode 100644
index 000000000..af3d538ae
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/gl2/StrokeCharRec.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util.gl2;
+
+/* Copyright (c) Mark J. Kilgard, 1994, 1998. */
+
+/* This program is freely distributable without licensing fees 
+   and is provided without guarantee or warrantee expressed or 
+   implied. This program is -not- in the public domain. */
+
+class StrokeCharRec {
+  public int num_strokes;
+  public StrokeRec[] stroke;
+  public float center;
+  public float right;
+
+  public StrokeCharRec(int num_strokes,
+                StrokeRec[] stroke,
+                float center,
+                float right) {
+    this.num_strokes = num_strokes;
+    this.stroke = stroke;
+    this.center = center;
+    this.right = right;
+  }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/gl2/StrokeFontRec.java b/src/jogl/classes/com/jogamp/opengl/util/gl2/StrokeFontRec.java
new file mode 100644
index 000000000..d3195f24d
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/gl2/StrokeFontRec.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util.gl2;
+
+/* Copyright (c) Mark J. Kilgard, 1994, 1998. */
+
+/* This program is freely distributable without licensing fees 
+   and is provided without guarantee or warrantee expressed or 
+   implied. This program is -not- in the public domain. */
+
+class StrokeFontRec {
+  public String name;
+  public int num_chars;
+  public StrokeCharRec[] ch;
+  public float top;
+  public float bottom;
+
+  public StrokeFontRec(String name,
+                int num_chars,
+                StrokeCharRec[] ch,
+                float top,
+                float bottom) {
+    this.name = name;
+    this.num_chars = num_chars;
+    this.ch = ch;
+    this.top = top;
+    this.bottom = bottom;
+  }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/gl2/StrokeRec.java b/src/jogl/classes/com/jogamp/opengl/util/gl2/StrokeRec.java
new file mode 100644
index 000000000..8796e8b08
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/gl2/StrokeRec.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util.gl2;
+
+/* Copyright (c) Mark J. Kilgard, 1994, 1998. */
+
+/* This program is freely distributable without licensing fees 
+   and is provided without guarantee or warrantee expressed or 
+   implied. This program is -not- in the public domain. */
+
+class StrokeRec {
+  public int num_coords;
+  public CoordRec[] coord;
+  
+  public StrokeRec(int num_coords,
+            CoordRec[] coord) {
+    this.num_coords = num_coords;
+    this.coord = coord;
+  }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/gl2/TileRenderer.java b/src/jogl/classes/com/jogamp/opengl/util/gl2/TileRenderer.java
new file mode 100755
index 000000000..714c134d4
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/gl2/TileRenderer.java
@@ -0,0 +1,601 @@
+package com.jogamp.opengl.util.gl2;
+
+import java.awt.Dimension;
+import java.nio.Buffer;
+
+import javax.media.opengl.*;
+import javax.media.opengl.glu.*;
+import javax.media.opengl.glu.gl2.*;
+
+/**
+ * A fairly direct port of Brian Paul's tile rendering library, found
+ * at <a href = "http://www.mesa3d.org/brianp/TR.html">
+ * http://www.mesa3d.org/brianp/TR.html </a> . I've java-fied it, but
+ * the functionality is the same.
+ * 
+ * Original code Copyright (C) 1997-2005 Brian Paul. Licensed under
+ * BSD-compatible terms with permission of the author. See LICENSE.txt
+ * for license information.
+ * 
+ * @author ryanm
+ */
+public class TileRenderer
+{
+  private static final int DEFAULT_TILE_WIDTH = 256;
+
+  private static final int DEFAULT_TILE_HEIGHT = 256;
+
+  private static final int DEFAULT_TILE_BORDER = 0;
+
+  //
+  // Enumeration flags for accessing variables
+  //
+  // @author ryanm
+  //
+
+  /**
+   * The width of a tile
+   */
+  public static final int TR_TILE_WIDTH = 0;
+  /**
+   * The height of a tile
+   */
+  public static final int TR_TILE_HEIGHT = 1;
+  /**
+   * The width of the border around the tiles
+   */
+  public static final int TR_TILE_BORDER = 2;
+  /**
+   * The width of the final image
+   */
+  public static final int TR_IMAGE_WIDTH = 3;
+  /**
+   * The height of the final image
+   */
+  public static final int TR_IMAGE_HEIGHT = 4;
+  /**
+   * The number of rows of tiles
+   */
+  public static final int TR_ROWS = 5;
+  /**
+   * The number of columns of tiles
+   */
+  public static final int TR_COLUMNS = 6;
+  /**
+   * The current row number
+   */
+  public static final int TR_CURRENT_ROW = 7;
+  /**
+   * The current column number
+   */
+  public static final int TR_CURRENT_COLUMN = 8;
+  /**
+   * The width of the current tile
+   */
+  public static final int TR_CURRENT_TILE_WIDTH = 9;
+  /**
+   * The height of the current tile
+   */
+  public static final int TR_CURRENT_TILE_HEIGHT = 10;
+  /**
+   * The order that the rows are traversed
+   */
+  public static final int TR_ROW_ORDER = 11;
+
+
+  /**
+   * Indicates we are traversing rows from the top to the bottom
+   */
+  public static final int TR_TOP_TO_BOTTOM = 1;
+
+  /**
+   * Indicates we are traversing rows from the bottom to the top
+   */
+  public static final int TR_BOTTOM_TO_TOP = 2;
+
+  /* Final image parameters */
+  private Dimension imageSize = new Dimension();
+
+  private int imageFormat, imageType;
+
+  private Buffer imageBuffer;
+
+  /* Tile parameters */
+  private Dimension tileSize = new Dimension();
+
+  private Dimension tileSizeNB = new Dimension();
+
+  private int tileBorder;
+
+  private int tileFormat, tileType;
+
+  private Buffer tileBuffer;
+
+  /* Projection parameters */
+  private boolean perspective;
+
+  private double left;
+
+  private double right;
+
+  private double bottom;
+
+  private double top;
+
+  private double near;
+
+  private double far;
+
+  /* Misc */
+  private int rowOrder;
+
+  private int rows, columns;
+
+  private int currentTile;
+
+  private int currentTileWidth, currentTileHeight;
+
+  private int currentRow, currentColumn;
+
+  private int[] viewportSave = new int[ 4 ];
+
+  /**
+   * Creates a new TileRenderer object
+   */
+  public TileRenderer()
+  {
+    tileSize.width = DEFAULT_TILE_WIDTH;
+    tileSize.height = DEFAULT_TILE_HEIGHT;
+    tileBorder = DEFAULT_TILE_BORDER;
+    rowOrder = TR_BOTTOM_TO_TOP;
+    currentTile = -1;
+  }
+
+  /**
+   * Sets up the number of rows and columns needed
+   */
+  private void setup()
+  {
+    columns = ( imageSize.width + tileSizeNB.width - 1 ) / tileSizeNB.width;
+    rows = ( imageSize.height + tileSizeNB.height - 1 ) / tileSizeNB.height;
+    currentTile = 0;
+
+    assert columns >= 0;
+    assert rows >= 0;
+  }
+
+  /**
+   * Sets the size of the tiles to use in rendering. The actual
+   * effective size of the tile depends on the border size, ie (
+   * width - 2*border ) * ( height - 2 * border )
+   * 
+   * @param width
+   *           The width of the tiles. Must not be larger than the GL
+   *           context
+   * @param height
+   *           The height of the tiles. Must not be larger than the
+   *           GL context
+   * @param border
+   *           The width of the borders on each tile. This is needed
+   *           to avoid artifacts when rendering lines or points with
+   *           thickness > 1.
+   */
+  public void setTileSize( int width, int height, int border )
+  {
+    assert ( border >= 0 );
+    assert ( width >= 1 );
+    assert ( height >= 1 );
+    assert ( width >= 2 * border );
+    assert ( height >= 2 * border );
+
+    tileBorder = border;
+    tileSize.width = width;
+    tileSize.height = height;
+    tileSizeNB.width = width - 2 * border;
+    tileSizeNB.height = height - 2 * border;
+    setup();
+  }
+
+  /**
+   * Specify a buffer the tiles to be copied to. This is not
+   * necessary for the creation of the final image, but useful if you
+   * want to inspect each tile in turn.
+   * 
+   * @param format
+   *           Interpreted as in glReadPixels
+   * @param type
+   *           Interpreted as in glReadPixels
+   * @param image
+   *           The buffer itself. Must be large enough to contain a
+   *           tile, minus any borders
+   */
+  public void setTileBuffer( int format, int type, Buffer image )
+  {
+    tileFormat = format;
+    tileType = type;
+    tileBuffer = image;
+  }
+
+  /**
+   * Sets the desired size of the final image
+   * 
+   * @param width
+   *           The width of the final image
+   * @param height
+   *           The height of the final image
+   */
+  public void setImageSize( int width, int height )
+  {
+    imageSize.width = width;
+    imageSize.height = height;
+    setup();
+  }
+
+  /**
+   * Sets the buffer in which to store the final image
+   * 
+   * @param format
+   *           Interpreted as in glReadPixels
+   * @param type
+   *           Interpreted as in glReadPixels
+   * @param image
+   *           the buffer itself, must be large enough to hold the
+   *           final image
+   */
+  public void setImageBuffer( int format, int type, Buffer image )
+  {
+    imageFormat = format;
+    imageType = type;
+    imageBuffer = image;
+  }
+
+  /**
+   * Gets the parameters of this TileRenderer object
+   * 
+   * @param param
+   *           The parameter that is to be retrieved
+   * @return the value of the parameter
+   */
+  public int getParam( int param )
+  {
+    switch (param) {
+      case TR_TILE_WIDTH:
+        return tileSize.width;
+      case TR_TILE_HEIGHT:
+        return tileSize.height;
+      case TR_TILE_BORDER:
+        return tileBorder;
+      case TR_IMAGE_WIDTH:
+        return imageSize.width;
+      case TR_IMAGE_HEIGHT:
+        return imageSize.height;
+      case TR_ROWS:
+        return rows;
+      case TR_COLUMNS:
+        return columns;
+      case TR_CURRENT_ROW:
+        if( currentTile < 0 )
+          return -1;
+        else
+          return currentRow;
+      case TR_CURRENT_COLUMN:
+        if( currentTile < 0 )
+          return -1;
+        else
+          return currentColumn;
+      case TR_CURRENT_TILE_WIDTH:
+        return currentTileWidth;
+      case TR_CURRENT_TILE_HEIGHT:
+        return currentTileHeight;
+      case TR_ROW_ORDER:
+        return rowOrder;
+      default:
+        throw new IllegalArgumentException("Invalid enumerant as argument");
+    }
+  }
+
+  /**
+   * Sets the order of row traversal
+   * 
+   * @param order
+   *           The row traversal order, must be
+   *           eitherTR_TOP_TO_BOTTOM or TR_BOTTOM_TO_TOP
+   */
+  public void setRowOrder( int order )
+  {
+    if (order == TR_TOP_TO_BOTTOM || order == TR_BOTTOM_TO_TOP) {
+      rowOrder = order;
+    } else {
+      throw new IllegalArgumentException("Must pass TR_TOP_TO_BOTTOM or TR_BOTTOM_TO_TOP");
+    }
+  }
+
+  /**
+   * Sets the context to use an orthographic projection. Must be
+   * called before rendering the first tile
+   * 
+   * @param left
+   *           As in glOrtho
+   * @param right
+   *           As in glOrtho
+   * @param bottom
+   *           As in glOrtho
+   * @param top
+   *           As in glOrtho
+   * @param zNear
+   *           As in glOrtho
+   * @param zFar
+   *           As in glOrtho
+   */
+  public void trOrtho( double left, double right, double bottom, double top, double zNear,
+                       double zFar )
+  {
+    this.perspective = false;
+    this.left = left;
+    this.right = right;
+    this.bottom = bottom;
+    this.top = top;
+    this.near = zNear;
+    this.far = zFar;
+  }
+
+  /**
+   * Sets the perspective projection frustrum. Must be called before
+   * rendering the first tile
+   * 
+   * @param left
+   *           As in glFrustrum
+   * @param right
+   *           As in glFrustrum
+   * @param bottom
+   *           As in glFrustrum
+   * @param top
+   *           As in glFrustrum
+   * @param zNear
+   *           As in glFrustrum
+   * @param zFar
+   *           As in glFrustrum
+   */
+  public void trFrustum( double left, double right, double bottom, double top, double zNear,
+                         double zFar )
+  {
+    this.perspective = true;
+    this.left = left;
+    this.right = right;
+    this.bottom = bottom;
+    this.top = top;
+    this.near = zNear;
+    this.far = zFar;
+  }
+
+  /**
+   * Convenient way to specify a perspective projection
+   * 
+   * @param fovy
+   *           As in gluPerspective
+   * @param aspect
+   *           As in gluPerspective
+   * @param zNear
+   *           As in gluPerspective
+   * @param zFar
+   *           As in gluPerspective
+   */
+  public void trPerspective( double fovy, double aspect, double zNear, double zFar )
+  {
+    double xmin, xmax, ymin, ymax;
+    ymax = zNear * Math.tan( fovy * 3.14159265 / 360.0 );
+    ymin = -ymax;
+    xmin = ymin * aspect;
+    xmax = ymax * aspect;
+    trFrustum( xmin, xmax, ymin, ymax, zNear, zFar );
+  }
+
+  /**
+   * Begins rendering a tile. The projection matrix stack should be
+   * left alone after calling this
+   * 
+   * @param gl
+   *           The gl context
+   */
+  public void beginTile( GL2 gl )
+  {
+    if (currentTile <= 0) {
+      setup();
+      /*
+       * Save user's viewport, will be restored after last tile
+       * rendered
+       */
+      gl.glGetIntegerv( GL2.GL_VIEWPORT, viewportSave, 0 );
+    }
+
+    /* which tile (by row and column) we're about to render */
+    if (rowOrder == TR_BOTTOM_TO_TOP) {
+      currentRow = currentTile / columns;
+      currentColumn = currentTile % columns;
+    } else {
+      currentRow = rows - ( currentTile / columns ) - 1;
+      currentColumn = currentTile % columns;
+    }
+    assert ( currentRow < rows );
+    assert ( currentColumn < columns );
+
+    int border = tileBorder;
+
+    int th, tw;
+
+    /* Compute actual size of this tile with border */
+    if (currentRow < rows - 1) {
+      th = tileSize.height;
+    } else {
+      th = imageSize.height - ( rows - 1 ) * ( tileSizeNB.height  ) + 2 * border;
+    }
+
+    if (currentColumn < columns - 1) {
+      tw = tileSize.width;
+    } else {
+      tw = imageSize.width - ( columns - 1 ) * ( tileSizeNB.width  ) + 2 * border;
+    }
+
+    /* Save tile size, with border */
+    currentTileWidth = tw;
+    currentTileHeight = th;
+
+    gl.glViewport( 0, 0, tw, th );
+
+    /* save current matrix mode */
+    int[] matrixMode = new int[ 1 ];
+    gl.glGetIntegerv( GL2.GL_MATRIX_MODE, matrixMode, 0 );
+    gl.glMatrixMode( GL2.GL_PROJECTION );
+    gl.glLoadIdentity();
+
+    /* compute projection parameters */
+    double l =
+      left + ( right - left ) * ( currentColumn * tileSizeNB.width - border )
+      / imageSize.width;
+    double r = l + ( right - left ) * tw / imageSize.width;
+    double b =
+      bottom + ( top - bottom ) * ( currentRow * tileSizeNB.height - border )
+      / imageSize.height;
+    double t = b + ( top - bottom ) * th / imageSize.height;
+
+    if( perspective ) {
+      gl.glFrustum( l, r, b, t, near, far );
+    } else {
+      gl.glOrtho( l, r, b, t, near, far );
+    }
+
+    /* restore user's matrix mode */
+    gl.glMatrixMode( matrixMode[ 0 ] );
+  }
+
+  /**
+   * Must be called after rendering the scene
+   * 
+   * @param gl
+   *           the gl context
+   * @return true if there are more tiles to be rendered, false if
+   *         the final image is complete
+   */
+  public boolean endTile( GL2 gl )
+  {
+    int[] prevRowLength = new int[ 1 ], prevSkipRows = new int[ 1 ], prevSkipPixels = new int[ 1 ], prevAlignment =
+      new int[ 1 ];
+
+    assert ( currentTile >= 0 );
+
+    // be sure OpenGL rendering is finished
+    gl.glFlush();
+
+    // save current glPixelStore values
+    gl.glGetIntegerv( GL2.GL_PACK_ROW_LENGTH, prevRowLength, 0 );
+    gl.glGetIntegerv( GL2.GL_PACK_SKIP_ROWS, prevSkipRows, 0 );
+    gl.glGetIntegerv( GL2.GL_PACK_SKIP_PIXELS, prevSkipPixels, 0 );
+    gl.glGetIntegerv( GL2.GL_PACK_ALIGNMENT, prevAlignment, 0 );
+
+    if( tileBuffer != null ) {
+      int srcX = tileBorder;
+      int srcY = tileBorder;
+      int srcWidth = tileSizeNB.width;
+      int srcHeight = tileSizeNB.height;
+      gl.glReadPixels( srcX, srcY, srcWidth, srcHeight, tileFormat, tileType, tileBuffer );
+    }
+
+    if( imageBuffer != null ) {
+      int srcX = tileBorder;
+      int srcY = tileBorder;
+      int srcWidth = currentTileWidth - 2 * tileBorder;
+      int srcHeight = currentTileHeight - 2 * tileBorder;
+      int destX = tileSizeNB.width * currentColumn;
+      int destY = tileSizeNB.height * currentRow;
+
+      /* setup pixel store for glReadPixels */
+      gl.glPixelStorei( GL2.GL_PACK_ROW_LENGTH, imageSize.width );
+      gl.glPixelStorei( GL2.GL_PACK_SKIP_ROWS, destY );
+      gl.glPixelStorei( GL2.GL_PACK_SKIP_PIXELS, destX );
+      gl.glPixelStorei( GL2.GL_PACK_ALIGNMENT, 1 );
+
+      /* read the tile into the final image */
+      gl.glReadPixels( srcX, srcY, srcWidth, srcHeight, imageFormat, imageType, imageBuffer );
+    }
+
+    /* restore previous glPixelStore values */
+    gl.glPixelStorei( GL2.GL_PACK_ROW_LENGTH, prevRowLength[ 0 ] );
+    gl.glPixelStorei( GL2.GL_PACK_SKIP_ROWS, prevSkipRows[ 0 ] );
+    gl.glPixelStorei( GL2.GL_PACK_SKIP_PIXELS, prevSkipPixels[ 0 ] );
+    gl.glPixelStorei( GL2.GL_PACK_ALIGNMENT, prevAlignment[ 0 ] );
+
+    /* increment tile counter, return 1 if more tiles left to render */
+    currentTile++;
+    if( currentTile >= rows * columns ) {
+      /* restore user's viewport */
+      gl.glViewport( viewportSave[ 0 ], viewportSave[ 1 ], viewportSave[ 2 ], viewportSave[ 3 ] );
+      currentTile = -1; /* all done */
+      return false;
+    } else {
+      return true;
+    }
+  }
+
+  /**
+   * Tile rendering causes problems with using glRasterPos3f, so you
+   * should use this replacement instead
+   * 
+   * @param x
+   *           As in glRasterPos3f
+   * @param y
+   *           As in glRasterPos3f
+   * @param z
+   *           As in glRasterPos3f
+   * @param gl
+   *           The gl context
+   * @param glu
+   *           A GLUgl2 object
+   */
+  public void trRasterPos3f( float x, float y, float z, GL2 gl, GLUgl2 glu )
+  {
+    if (currentTile < 0) {
+      /* not doing tile rendering right now. Let OpenGL do this. */
+      gl.glRasterPos3f( x, y, z );
+    } else {
+      double[] modelview = new double[ 16 ], proj = new double[ 16 ];
+      int[] viewport = new int[ 4 ];
+      double[] win = new double[3];
+
+      /* Get modelview, projection and viewport */
+      gl.glGetDoublev( GL2.GL_MODELVIEW_MATRIX, modelview, 0 );
+      gl.glGetDoublev( GL2.GL_PROJECTION_MATRIX, proj, 0 );
+      viewport[ 0 ] = 0;
+      viewport[ 1 ] = 0;
+      viewport[ 2 ] = currentTileWidth;
+      viewport[ 3 ] = currentTileHeight;
+
+      /* Project object coord to window coordinate */
+      if( glu.gluProject( x, y, z, modelview, 0, proj, 0, viewport, 0, win, 0 ) ) {
+
+        /* set raster pos to window coord (0,0) */
+        gl.glMatrixMode( GL2.GL_MODELVIEW );
+        gl.glPushMatrix();
+        gl.glLoadIdentity();
+        gl.glMatrixMode( GL2.GL_PROJECTION );
+        gl.glPushMatrix();
+        gl.glLoadIdentity();
+        gl.glOrtho( 0.0, currentTileWidth, 0.0, currentTileHeight, 0.0, 1.0 );
+        gl.glRasterPos3d( 0.0, 0.0, -win[ 2 ] );
+
+        /*
+         * Now use empty bitmap to adjust raster position to
+         * (winX,winY)
+         */
+        {
+          byte[] bitmap = { 0 };
+          gl.glBitmap( 1, 1, 0.0f, 0.0f, ( float ) win[ 0 ], ( float ) win[ 1 ], bitmap , 0 );
+        }
+
+        /* restore original matrices */
+        gl.glPopMatrix(); /* proj */
+        gl.glMatrixMode( GL2.GL_MODELVIEW );
+        gl.glPopMatrix();
+      }
+    }
+  }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/glsl/GLSLArrayHandler.java b/src/jogl/classes/com/jogamp/opengl/util/glsl/GLSLArrayHandler.java
new file mode 100644
index 000000000..1119aa5ab
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/glsl/GLSLArrayHandler.java
@@ -0,0 +1,60 @@
+
+package com.jogamp.opengl.util.glsl;
+
+import javax.media.opengl.*;
+import javax.media.opengl.fixedfunc.*;
+import com.jogamp.opengl.util.*;
+import com.jogamp.opengl.util.glsl.ShaderState;
+import java.nio.*;
+
+public class GLSLArrayHandler implements GLArrayHandler {
+  private GLArrayDataEditable ad;
+
+  public GLSLArrayHandler(GLArrayDataEditable ad) {
+    this.ad = ad;
+  }
+
+  protected final void passVertexAttribPointer(GL2ES2 gl, ShaderState st) {
+    st.glVertexAttribPointer(gl, ad);
+  }
+
+  public void enableBuffer(GL gl, boolean enable) {
+    if(!gl.isGL2ES2()) {
+        throw new GLException("GLSLArrayHandler expects a GL2ES2 implementation");
+    }
+    GL2ES2 glsl = gl.getGL2ES2();
+    ShaderState st = ShaderState.getCurrent();
+    if(null==st) {
+        throw new GLException("No ShaderState current");
+    }
+
+    if(enable) {
+        st.glEnableVertexAttribArray(glsl, ad.getName());
+
+        Buffer buffer = ad.getBuffer();
+
+        if(ad.isVBO()) {
+            // always bind and refresh the VBO mgr,
+            // in case more than one gl*Pointer objects are in use
+            glsl.glBindBuffer(GL.GL_ARRAY_BUFFER, ad.getVBOName());
+            if(!ad.isBufferWritten()) {
+                if(null!=buffer) {
+                    glsl.glBufferData(GL.GL_ARRAY_BUFFER, buffer.limit() * ad.getComponentSize(), buffer, ad.getBufferUsage());
+                }
+                ad.setBufferWritten(true);
+            }
+            passVertexAttribPointer(glsl, st);
+        } else if(null!=buffer) {
+            passVertexAttribPointer(glsl, st);
+            ad.setBufferWritten(true);
+        }
+    } else {
+        if(ad.isVBO()) {
+            glsl.glBindBuffer(GL.GL_ARRAY_BUFFER, 0);
+        }
+        st.glDisableVertexAttribArray(glsl, ad.getName());
+    }
+  }
+
+}
+
diff --git a/src/jogl/classes/com/jogamp/opengl/util/glsl/ShaderCode.java b/src/jogl/classes/com/jogamp/opengl/util/glsl/ShaderCode.java
new file mode 100644
index 000000000..01b94d0d9
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/glsl/ShaderCode.java
@@ -0,0 +1,347 @@
+
+package com.jogamp.opengl.util.glsl;
+
+import javax.media.opengl.*;
+import com.jogamp.opengl.util.*;
+import com.jogamp.opengl.impl.Debug;
+
+import java.util.*;
+import java.nio.*;
+import java.io.*;
+import java.net.*;
+import java.security.*;
+
+public class ShaderCode {
+    public static final boolean DEBUG = Debug.debug("GLSLCode");
+    public static final boolean DEBUG_CODE = Debug.isPropertyDefined("jogl.debug.GLSLCode", true, AccessController.getContext());
+
+    public static final String SUFFIX_VERTEX_SOURCE   =  "vp" ;
+    public static final String SUFFIX_VERTEX_BINARY   = "bvp" ;
+    public static final String SUFFIX_FRAGMENT_SOURCE =  "fp" ;
+    public static final String SUFFIX_FRAGMENT_BINARY = "bfp" ;
+    
+    public static final String SUB_PATH_NVIDIA = "nvidia" ;
+
+    public ShaderCode(int type, int number, String[][] source) {
+        switch (type) {
+            case GL2ES2.GL_VERTEX_SHADER:
+            case GL2ES2.GL_FRAGMENT_SHADER:
+                break;
+            default:
+                throw new GLException("Unknown shader type: "+type);
+        }
+        shaderSource = source;
+        shaderBinaryFormat = -1;
+        shaderBinary = null;
+        shaderType   = type;
+        shader = BufferUtil.newIntBuffer(number);
+        id = getNextID();
+
+        if(DEBUG_CODE) {
+            System.out.println("Created: "+toString());
+            dumpShaderSource(System.out);
+        }
+    }
+
+    public ShaderCode(int type, int number, int binFormat, Buffer binary) {
+        switch (type) {
+            case GL2ES2.GL_VERTEX_SHADER:
+            case GL2ES2.GL_FRAGMENT_SHADER:
+                break;
+            default:
+                throw new GLException("Unknown shader type: "+type);
+        }
+        shaderSource = null;
+        shaderBinaryFormat = binFormat;
+        shaderBinary = binary;
+        shaderType   = type;
+        shader = BufferUtil.newIntBuffer(number);
+        id = getNextID();
+    }
+
+    public static ShaderCode create(GL2ES2 gl, int type, int number, Class context, String[] sourceFiles) {
+        if(!ShaderUtil.isShaderCompilerAvailable(gl)) return null;
+
+        String[][] shaderSources = null;
+        if(null!=sourceFiles) {
+            shaderSources = new String[sourceFiles.length][1];
+            for(int i=0; null!=shaderSources && i<sourceFiles.length; i++) {
+                shaderSources[i][0] = readShaderSource(context, sourceFiles[i]);
+                if(null == shaderSources[i][0]) {
+                    shaderSources = null;
+                }
+            }
+        }
+        if(null==shaderSources) {
+            return null;
+        }
+        return new ShaderCode(type, number, shaderSources);
+    }
+
+    public static ShaderCode create(int type, int number, Class context, int binFormat, String binaryFile) {
+        ByteBuffer shaderBinary = null;
+        if(null!=binaryFile && 0<=binFormat) {
+            shaderBinary = readShaderBinary(context, binaryFile);
+            if(null == shaderBinary) {
+                binFormat = -1;
+            }
+        }
+        if(null==shaderBinary) {
+            return null;
+        }
+        return new ShaderCode(type, number, binFormat, shaderBinary);
+    }
+
+    public static String getFileSuffix(boolean binary, int type) {
+        switch (type) {
+            case GL2ES2.GL_VERTEX_SHADER:
+                return binary?SUFFIX_VERTEX_BINARY:SUFFIX_VERTEX_SOURCE;
+            case GL2ES2.GL_FRAGMENT_SHADER:
+                return binary?SUFFIX_FRAGMENT_BINARY:SUFFIX_FRAGMENT_SOURCE;
+            default:
+                throw new GLException("illegal shader type: "+type);
+        }
+    }
+
+    public static String getBinarySubPath(int binFormat) {
+        switch (binFormat) {
+            case GLES2.GL_NVIDIA_PLATFORM_BINARY_NV:
+                return SUB_PATH_NVIDIA;
+            default:
+                throw new GLException("unsupported binary format: "+binFormat);
+        }
+    }
+
+    public static ShaderCode create(GL2ES2 gl, int type, int number, Class context, 
+                                    String srcRoot, String binRoot, String basename) {
+        ShaderCode res = null;
+        String srcFileName = null;
+        String binFileName = null;
+
+        if(ShaderUtil.isShaderCompilerAvailable(gl)) {
+            String srcPath[] = new String[1];
+            srcFileName = srcRoot + '/' + basename + "." + getFileSuffix(false, type);
+            srcPath[0] = srcFileName;
+            res = create(gl, type, number, context, srcPath);
+            if(null!=res) {
+                return res;
+            }
+        }
+        Set binFmts = ShaderUtil.getShaderBinaryFormats(gl);
+        for(Iterator iter=binFmts.iterator(); null==res && iter.hasNext(); ) {
+            int bFmt = ((Integer)(iter.next())).intValue();
+            String bFmtPath = getBinarySubPath(bFmt);
+            if(null==bFmtPath) continue;
+            binFileName = binRoot + '/' + bFmtPath + '/' + basename + "." + getFileSuffix(true, type);
+            res = create(type, number, context, bFmt, binFileName);
+        }
+
+        if(null==res) {
+            throw new GLException("No shader code found (source nor binary) for src: "+srcFileName+
+                                  ", bin: "+binFileName);
+        }
+
+        return res;
+    }
+
+    /**
+     * returns the uniq shader id as an integer
+     * @see #key()
+     */
+    public int        id() { return id.intValue(); }
+
+    /**
+     * returns the uniq shader id as an Integer
+     *
+     * @see #id()
+     */
+    public Integer    key() { return id; }
+
+    public int        shaderType() { return shaderType; }
+    public String     shaderTypeStr() { return shaderTypeStr(shaderType); }
+
+    public static String shaderTypeStr(int type) { 
+        switch (type) {
+            case GL2ES2.GL_VERTEX_SHADER:
+                return "VERTEX_SHADER";
+            case GL2ES2.GL_FRAGMENT_SHADER:
+                return "FRAGMENT_SHADER";
+        }
+        return "UNKNOWN_SHADER";
+    }
+
+    public int        shaderBinaryFormat() { return shaderBinaryFormat; }
+    public Buffer     shaderBinary() { return shaderBinary; }
+    public String[][] shaderSource() { return shaderSource; }
+
+    public boolean    isValid() { return valid; }
+
+    public IntBuffer  shader() { return shader; }
+
+    public boolean compile(GL2ES2 gl) {
+        return compile(gl, null);
+    }
+    public boolean compile(GL2ES2 gl, PrintStream verboseOut) {
+        if(isValid()) return true;
+
+        // Create & Compile the vertex/fragment shader objects
+        if(null!=shaderSource) {
+            valid=ShaderUtil.createAndCompileShader(gl, shader, shaderType,
+                                                    shaderSource, verboseOut);
+        } else if(null!=shaderBinary) {
+            valid=ShaderUtil.createAndLoadShader(gl, shader, shaderType,
+                                                 shaderBinaryFormat, shaderBinary, verboseOut);
+        } else {
+            throw new GLException("no code (source or binary)");
+        }
+        return valid;
+    }
+
+    public void destroy(GL2ES2 gl) {
+        if(isValid()) {
+            if(null!=gl) {
+                ShaderUtil.deleteShader(gl, shader());
+            }
+            valid=false;
+        }
+        if(null!=shaderBinary) {
+            shaderBinary.clear();
+            shaderBinary=null;
+        }
+        shaderSource=null;
+        shaderBinaryFormat=-1;
+        shaderType=-1;
+        id=null;
+    }
+
+    public boolean equals(Object obj) {
+        if(this==obj) return true;
+        if(obj instanceof ShaderCode) {
+            return id()==((ShaderCode)obj).id();
+        }
+        return false;
+    }
+    public int hashCode() {
+        return id.intValue();
+    }
+    public String toString() {
+        StringBuffer buf = new StringBuffer("ShaderCode [id="+id+", type="+shaderTypeStr()+", valid="+valid+", shader: ");
+        for(int i=0; i<shader.remaining(); i++) {
+            buf.append(" "+shader.get(i));
+        }
+        if(null!=shaderSource) {
+            buf.append(", source]");
+        } else if(null!=shaderBinary) {
+            buf.append(", binary "+shaderBinary+"]");
+        }
+        return buf.toString();
+    }
+
+    public void dumpShaderSource(PrintStream out) {
+        if(null==shaderSource) {
+            out.println("<no shader source>");
+            return;
+        }
+        int sourceNum = (null!=shaderSource)?shaderSource.length:0;
+        int shaderNum = (null!=shader)?shader.capacity():0;
+        for(int i=0; i<shaderNum; i++) {
+            out.println("");
+            out.println("Shader #"+i+"/"+shaderNum+" name "+shader.get(i));
+            out.println("--------------------------------------------------------------");
+            if(i>=sourceNum) {
+                out.println("<no shader source>");
+            } else {
+                String[] src = shaderSource[i];
+                for(int j=0; j<src.length; j++) {
+                    out.println("Segment "+j+"/"+src.length+" :");
+                    out.println(src[j]);
+                    out.println("");
+                }
+            }
+            out.println("--------------------------------------------------------------");
+        }
+    }
+
+    public static void readShaderSource(ClassLoader context, String path, URL url, StringBuffer result) {
+        try {
+            BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream()));
+            String line = null;
+            while ((line = reader.readLine()) != null) {
+                if (line.startsWith("#include ")) {
+                    String includeFile = line.substring(9).trim();
+                    // Try relative path first
+                    String next = Locator.getRelativeOf(path, includeFile);
+                    URL nextURL = Locator.getResource(next, context);
+                    if (nextURL == null) {
+                        // Try absolute path
+                        next = includeFile;
+                        nextURL = Locator.getResource(next, context);
+                    }
+                    if (nextURL == null) {
+                        // Fail
+                        throw new FileNotFoundException("Can't find include file " + includeFile);
+                    }
+                    readShaderSource(context, next, nextURL, result);
+                } else {
+                    result.append(line + "\n");
+                }
+            }
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public static String readShaderSource(Class context, String path) {
+        ClassLoader contextCL = (null!=context)?context.getClassLoader():null;
+        URL url = Locator.getResource(path, contextCL);
+        if (url == null && null!=context) {
+            // Try again by scoping the path within the class's package
+            String className = context.getName().replace('.', '/');
+            int lastSlash = className.lastIndexOf('/');
+            if (lastSlash >= 0) {
+                String tmpPath = className.substring(0, lastSlash + 1) + path;
+                url = Locator.getResource(tmpPath, contextCL);
+                if (url != null) {
+                    path = tmpPath;
+                }
+            }
+        }
+        if (url == null) {
+            return null;
+        }
+        StringBuffer result = new StringBuffer();
+        readShaderSource(contextCL, path, url, result);
+        return result.toString();
+    }
+
+    public static ByteBuffer readShaderBinary(Class context, String path) {
+        try {
+            URL url = Locator.getResource(context, path);
+            if (url == null) {
+                return null;
+            }
+            return StreamUtil.readAll2Buffer(new BufferedInputStream(url.openStream()));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    //----------------------------------------------------------------------
+    // Internals only below this point
+    //
+
+    protected String[][] shaderSource = null;
+    protected Buffer     shaderBinary = null;
+    protected int        shaderBinaryFormat = -1;
+    protected IntBuffer  shader = null;
+    protected int        shaderType = -1;
+    protected Integer    id = null;
+
+    protected boolean valid=false;
+
+    private static synchronized Integer getNextID() {
+        return new Integer(nextID++);
+    }
+    protected static int nextID = 1;
+}
+
diff --git a/src/jogl/classes/com/jogamp/opengl/util/glsl/ShaderProgram.java b/src/jogl/classes/com/jogamp/opengl/util/glsl/ShaderProgram.java
new file mode 100644
index 000000000..49a341cc6
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/glsl/ShaderProgram.java
@@ -0,0 +1,212 @@
+
+package com.jogamp.opengl.util.glsl;
+
+import javax.media.opengl.*;
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.nio.*;
+import java.io.PrintStream;
+
+public class ShaderProgram {
+    public ShaderProgram() {
+        id = getNextID();
+    }
+
+    public boolean linked() {
+        return programLinked;
+    }
+
+    public boolean inUse() {
+        return programInUse;
+    }
+
+    public int program() { return shaderProgram; }
+
+    /**
+     * returns the uniq shader id as an integer
+     * @see #key()
+     */
+    public int        id() { return id.intValue(); }
+
+    /**
+     * returns the uniq shader id as an Integer
+     *
+     * @see #id()
+     */
+    public Integer    key() { return id; }
+
+    /**
+     * Detaches all shader codes and deletes the program.
+     * Destroys the shader codes as well.
+     * Calls release(gl, true)
+     *
+     * @see #release(GL2ES2, boolean)
+     */
+    public synchronized void destroy(GL2ES2 gl) {
+        release(gl, true);
+    }
+
+    /**
+     * Detaches all shader codes and deletes the program.
+     * Calls release(gl, false)
+     *
+     * @see #release(GL2ES2, boolean)
+     */
+    public synchronized void release(GL2ES2 gl) {
+        release(gl, false);
+    }
+
+    /**
+     * Detaches all shader codes and deletes the program.
+     * If releaseShaderToo is true, destroys the shader codes as well.
+     */
+    public synchronized void release(GL2ES2 gl, boolean releaseShaderToo) {
+        glUseProgram(gl, false);
+        for(Iterator iter=shaderMap.values().iterator(); iter.hasNext(); ) {
+            ShaderCode shaderCode = (ShaderCode) iter.next();
+            ShaderUtil.detachShader(gl, shaderProgram, shaderCode.shader());
+            if(releaseShaderToo) {
+                shaderCode.destroy(gl);
+            }
+        }
+        shaderMap.clear();
+        gl.glDeleteProgram(shaderProgram);
+        shaderProgram=-1;
+    }
+
+    //
+    // ShaderCode handling
+    //
+
+    /**
+     * Adds a new shader to a this non running program.
+     *
+     * @return false if the program is in use, or the shader already exist,
+     *         otherwise true.
+     */
+    public synchronized boolean add(ShaderCode shaderCode) {
+        if(shaderMap.containsKey(shaderCode.key())) return false;
+        shaderMap.put(shaderCode.key(), shaderCode);
+        return true;
+    }
+
+    public synchronized ShaderCode getShader(int id) {
+        return (ShaderCode) shaderMap.get(new Integer(id));
+    }
+
+    //
+    // Program handling
+    //
+
+    /**
+     * Replace a shader in a 'running' program.
+     * Refetches all previously bin/get attribute names
+     * and resets all attribute data as well
+     *
+     * @see getAttribLocation
+     * @param gl 
+     * @param oldShaderID the to be replace Shader
+     * @param newShader   the new ShaderCode
+     * @param verboseOut  the optional verbose outputstream
+     * @throws GLException is the program is not linked
+     *
+     * @see #glRefetchAttribLocations
+     * @see #glResetAllVertexAttributes
+     * @see #glReplaceShader
+     */
+    public synchronized boolean glReplaceShader(GL2ES2 gl, int oldShaderID, ShaderCode newShader, PrintStream verboseOut) {
+        if(!programLinked) throw new GLException("Program is not linked");
+        boolean shaderWasInUse = programInUse;
+        glUseProgram(gl, false);
+        if(!newShader.compile(gl, verboseOut)) {
+            return false;
+        } 
+        if(oldShaderID>=0) {
+            ShaderCode oldShader = (ShaderCode) shaderMap.remove(new Integer(oldShaderID));
+            if(null!=oldShader) {
+                ShaderUtil.detachShader(gl, shaderProgram, oldShader.shader());
+            }
+        }
+        add(newShader);
+
+        ShaderUtil.attachShader(gl, shaderProgram, newShader.shader());
+        gl.glLinkProgram(shaderProgram);
+        if ( ! ShaderUtil.isProgramValid(gl, shaderProgram, System.err) )  {
+            return false;
+        }
+
+        if(shaderWasInUse) {
+            glUseProgram(gl, true);
+        }
+        return true;
+    }
+
+    public synchronized boolean link(GL2ES2 gl, PrintStream verboseOut) {
+        if(programLinked) throw new GLException("Program is already linked");
+
+        if(0>shaderProgram) {
+            shaderProgram = gl.glCreateProgram();
+        }
+
+        for(Iterator iter=shaderMap.values().iterator(); iter.hasNext(); ) {
+            ShaderCode shaderCode = (ShaderCode) iter.next();
+            if(!shaderCode.compile(gl, verboseOut)) {
+                return false;
+            }
+            ShaderUtil.attachShader(gl, shaderProgram, shaderCode.shader());
+        }
+
+        // Link the program
+        gl.glLinkProgram(shaderProgram);
+
+        programLinked = ShaderUtil.isProgramValid(gl, shaderProgram, System.err);
+
+        return programLinked;
+    }
+
+    public boolean equals(Object obj) {
+        if(this==obj) return true;
+        if(obj instanceof ShaderCode) {
+            return id()==((ShaderCode)obj).id();
+        }
+        return false;
+    }
+    public int hashCode() {
+        return id.intValue();
+    }
+    public String toString() {
+        StringBuffer buf = new StringBuffer();
+        buf.append("ShaderProgram[id="+id);
+        buf.append(", linked="+programLinked+", inUse="+programInUse+", program: "+shaderProgram+", [");
+        for(Iterator iter=shaderMap.values().iterator(); iter.hasNext(); ) {
+            buf.append((ShaderCode) iter.next());
+            buf.append(" ");
+        }
+        buf.append("]");
+        return buf.toString();
+    }
+
+    protected synchronized void glUseProgram(GL2ES2 gl, boolean on) {
+        if(!programLinked) throw new GLException("Program is not linked");
+        if(programInUse==on) return;
+        gl.glUseProgram(on?shaderProgram:0);
+        programInUse = on;
+
+        //Throwable tX = new Throwable("Info: ShaderProgram.glUseProgram: "+on);
+        //tX.printStackTrace();
+
+    }
+
+    protected boolean programLinked = false;
+    protected boolean programInUse = false;
+    protected int shaderProgram=-1;
+    protected HashMap shaderMap = new HashMap();
+    protected Integer    id = null;
+
+    private static synchronized Integer getNextID() {
+        return new Integer(nextID++);
+    }
+    protected static int nextID = 1;
+}
+
diff --git a/src/jogl/classes/com/jogamp/opengl/util/glsl/ShaderState.java b/src/jogl/classes/com/jogamp/opengl/util/glsl/ShaderState.java
new file mode 100644
index 000000000..33f6e210b
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/glsl/ShaderState.java
@@ -0,0 +1,652 @@
+
+package com.jogamp.opengl.util.glsl;
+
+import javax.media.opengl.*;
+import com.jogamp.opengl.util.*;
+import com.jogamp.opengl.impl.Debug;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.nio.*;
+import java.io.PrintStream;
+import java.security.*;
+
+public class ShaderState {
+    public static final boolean DEBUG = Debug.isPropertyDefined("jogl.debug.GLSLState", true, AccessController.getContext());
+
+    public ShaderState() {
+    }
+
+    public boolean verbose() { return verbose; }
+
+    public void setVerbose(boolean v) { verbose=v; }
+
+    /**
+     * Fetches the current shader state from the thread local storage (TLS)
+     *
+     * @see javax.media.opengl.glsl.ShaderState#glUseProgram(GL2ES2, boolean)
+     * @see javax.media.opengl.glsl.ShaderState#getCurrent()
+     */
+    public static synchronized ShaderState getCurrent() { 
+        GLContext current = GLContext.getCurrent();
+        if(null==current) {
+            throw new GLException("No context is current on this thread");
+        }
+        return (ShaderState) current.getAttachedObject(ShaderState.class.getName());
+    }
+
+    /**
+     * Turns the shader program on or off.<br>
+     * Puts this ShaderState to to the thread local storage (TLS),
+     * if <code>on</code> is <code>true</code>.
+     *
+     * @see javax.media.opengl.glsl.ShaderState#glUseProgram(GL2ES2, boolean)
+     * @see javax.media.opengl.glsl.ShaderState#getCurrent()
+     */
+    public synchronized void glUseProgram(GL2ES2 gl, boolean on) {
+        if(on) {
+            if(null!=shaderProgram) {
+                shaderProgram.glUseProgram(gl, true);
+            } else {
+                throw new GLException("No program is attached");
+            }
+            // update the current ShaderState to the TLS ..
+            gl.getContext().putAttachedObject(ShaderState.class.getName(), this);
+        } else if(null!=shaderProgram) {
+            shaderProgram.glUseProgram(gl, false);
+        }
+    }
+
+    public boolean linked() {
+        return (null!=shaderProgram)?shaderProgram.linked():false;
+    }
+
+    public boolean inUse() {
+        return (null!=shaderProgram)?shaderProgram.inUse():false;
+    }
+
+    /**
+     * Attach or switch a shader program
+     *
+     * Attaching a shader program the first time, 
+     * as well as switching to another program on the fly,
+     * while managing all attribute and uniform data.
+     */
+    public synchronized void attachShaderProgram(GL2ES2 gl, ShaderProgram prog) {
+        boolean prgInUse = false; // earmarked state
+
+        if(DEBUG) {
+            int curId = (null!=shaderProgram)?shaderProgram.id():-1;
+            int newId = (null!=prog)?prog.id():-1;
+            System.err.println("Info: attachShaderProgram: "+curId+" -> "+newId+"\n\t"+shaderProgram+"\n\t"+prog);
+            if(verbose) {
+                Throwable tX = new Throwable("Info: attachShaderProgram: Trace");
+                tX.printStackTrace();
+            }
+        }
+        if(null!=shaderProgram) {
+            if(shaderProgram.equals(prog)) {
+                // nothing to do ..
+                if(DEBUG) {
+                    System.err.println("Info: attachShaderProgram: NOP: equal id: "+shaderProgram.id());
+                }
+                return;
+            }
+            prgInUse = shaderProgram.inUse();
+            shaderProgram.glUseProgram(gl, false);
+        }
+
+        // register new one
+        shaderProgram = prog;
+
+        if(null!=shaderProgram) {
+            // reinstall all data ..
+            shaderProgram.glUseProgram(gl, true);
+            glResetAllVertexAttributes(gl);
+            glResetAllUniforms(gl);
+            if(!prgInUse) {
+                shaderProgram.glUseProgram(gl, false);
+            }
+        }
+        if(DEBUG) {
+            System.err.println("Info: attachShaderProgram: END");
+        }
+    }
+
+    public ShaderProgram shaderProgram() { return shaderProgram; }
+
+    /**
+     * Calls release(gl, true, true)
+     *
+     * @see #glReleaseAllVertexAttributes
+     * @see #glReleaseAllUniforms
+     * @see #release(GL2ES2, boolean, boolean)
+     */
+    public synchronized void destroy(GL2ES2 gl) {
+        release(gl, true, true);
+    }
+
+    /**
+     * Calls release(gl, false, false)
+     *
+     * @see #glReleaseAllVertexAttributes
+     * @see #glReleaseAllUniforms
+     * @see #release(GL2ES2, boolean, boolean)
+     */
+    public synchronized void releaseAllData(GL2ES2 gl) {
+        release(gl, false, false);
+    }
+
+    /**
+     * @see #glReleaseAllVertexAttributes
+     * @see #glReleaseAllUniforms
+     * @see ShaderProgram#release(GL2ES2, boolean)
+     */
+    public synchronized void release(GL2ES2 gl, boolean releaseProgramToo, boolean releaseShaderToo) {
+        boolean prgInUse = false;
+        if(null!=shaderProgram) {
+            prgInUse = shaderProgram.inUse();
+            if(!prgInUse) {
+                shaderProgram.glUseProgram(gl, true);
+            }
+        }
+        glReleaseAllVertexAttributes(gl);
+        glReleaseAllUniforms(gl);
+        if(null!=shaderProgram) {
+            if(releaseProgramToo) {
+                shaderProgram.release(gl, releaseShaderToo);
+            } else if(!prgInUse) {
+                shaderProgram.glUseProgram(gl, false);
+            }
+        }
+    }
+
+    //
+    // Shader attribute handling
+    //
+
+    /**
+     * Binds an attribute to the shader.
+     * This must be done before the program is linked !
+     * n name - 1 idx, where name is a uniq key
+     *
+     * @throws GLException is the program is already linked
+     *
+     * @see #glBindAttribLocation
+     * @see javax.media.opengl.GL2ES2#glBindAttribLocation
+     * @see #glGetAttribLocation
+     * @see javax.media.opengl.GL2ES2#glGetAttribLocation
+     * @see #getAttribLocation
+     * @see #glReplaceShader
+     */
+    public void glBindAttribLocation(GL2ES2 gl, int index, String name) {
+        if(null==shaderProgram) throw new GLException("No program is attached");
+        if(shaderProgram.linked()) throw new GLException("Program is already linked");
+        Integer idx = new Integer(index);
+        if(!attribMap2Idx.containsKey(name)) {
+            attribMap2Idx.put(name, idx);
+            gl.glBindAttribLocation(shaderProgram.program(), index, name);
+        }
+    }
+
+    /**
+     * Gets the index of a shader attribute.
+     * This must be done after the program is linked !
+     *
+     * @return -1 if there is no such attribute available, 
+     *         otherwise >= 0
+     * @throws GLException is the program is not linked
+     *
+     * @see #glBindAttribLocation
+     * @see javax.media.opengl.GL2ES2#glBindAttribLocation
+     * @see #glGetAttribLocation
+     * @see javax.media.opengl.GL2ES2#glGetAttribLocation
+     * @see #getAttribLocation
+     * @see #glReplaceShader
+     */
+    public int glGetAttribLocation(GL2ES2 gl, String name) {
+        if(!shaderProgram.linked()) throw new GLException("Program is not linked");
+        int index = getAttribLocation(name);
+        if(0>index) {
+            index = gl.glGetAttribLocation(shaderProgram.program(), name);
+            if(0<=index) {
+                Integer idx = new Integer(index);
+                attribMap2Idx.put(name, idx);
+                if(DEBUG) {
+                    System.err.println("Info: glGetAttribLocation: "+name+", loc: "+index);
+                }
+            } else if(verbose) {
+                Throwable tX = new Throwable("Info: glGetAttribLocation failed, no location for: "+name+", index: "+index);
+                tX.printStackTrace();
+            }
+        }
+        return index;
+    }
+
+    protected int getAttribLocation(String name) {
+        Integer idx = (Integer) attribMap2Idx.get(name);
+        return (null!=idx)?idx.intValue():-1;
+    }
+
+
+    //
+    // Enabled Vertex Arrays and its data
+    //
+
+    /**
+     * Enable a vertex attribute array
+     *
+     * Even if the attribute is not found in the current shader,
+     * it is stored in this state.
+     *
+     * @returns false, if the name is not found, otherwise true
+     *
+     * @throws GLException if the program is not in use
+     *
+     * @see #glEnableVertexAttribArray
+     * @see #glDisableVertexAttribArray
+     * @see #glVertexAttribPointer
+     * @see #getVertexAttributePointer
+     * @see #glReleaseAllVertexAttributes
+     * @see #glResetAllVertexAttributes
+     * @see #glReplaceShader
+     */
+    public boolean glEnableVertexAttribArray(GL2ES2 gl, String name) {
+        if(!shaderProgram.inUse()) throw new GLException("Program is not in use");
+        enabledVertexAttribArraySet.add(name);
+        int index = glGetAttribLocation(gl, name);
+        if(0>index) {
+            if(verbose) {
+                Throwable tX = new Throwable("Info: glEnableVertexAttribArray failed, no index for: "+name);
+                tX.printStackTrace();
+            }
+            return false;
+        }
+        if(DEBUG) {
+            System.err.println("Info: glEnableVertexAttribArray: "+name+", loc: "+index);
+        }
+        gl.glEnableVertexAttribArray(index);
+        return true;
+    }
+
+    public boolean isVertexAttribArrayEnabled(String name) {
+        if(!shaderProgram.inUse()) throw new GLException("Program is not in use");
+        return enabledVertexAttribArraySet.contains(name);
+    }
+
+    /**
+     * Disables a vertex attribute array
+     *
+     * Even if the attribute is not found in the current shader,
+     * it is removed from this state.
+     *
+     * @returns false, if the name is not found, otherwise true
+     *
+     * @throws GLException if the program is not in use
+     *
+     * @see #glEnableVertexAttribArray
+     * @see #glDisableVertexAttribArray
+     * @see #glVertexAttribPointer
+     * @see #getVertexAttributePointer
+     * @see #glReleaseAllVertexAttributes
+     * @see #glResetAllVertexAttributes
+     * @see #glReplaceShader
+     */
+    public boolean glDisableVertexAttribArray(GL2ES2 gl, String name) {
+        if(!shaderProgram.inUse()) throw new GLException("Program is not in use");
+        enabledVertexAttribArraySet.remove(name);
+        int index = glGetAttribLocation(gl, name);
+        if(0>index) {
+            if(verbose) {
+                Throwable tX = new Throwable("Info: glDisableVertexAttribArray failed, no index for: "+name);
+                tX.printStackTrace();
+            }
+            return false;
+        }
+        if(DEBUG) {
+            System.err.println("Info: glDisableVertexAttribArray: "+name);
+        }
+        gl.glDisableVertexAttribArray(index);
+        return true;
+    }
+
+    /**
+     * Set the vertex attribute data.
+     * Enable the attribute, if it is not enabled yet.
+     *
+     * Even if the attribute is not found in the current shader,
+     * it is stored in this state.
+     *
+     * @param data the GLArrayData's name must match the attributes one,
+     *      it's index will be set with the attribute's location,
+     *      if found.
+     *
+     * @returns false, if the name is not found, otherwise true
+     *
+     * @throws GLException if the program is not in use
+     *
+     * @see #glEnableVertexAttribArray
+     * @see #glDisableVertexAttribArray
+     * @see #glVertexAttribPointer
+     * @see #getVertexAttributePointer
+     * @see #glReleaseAllVertexAttributes
+     * @see #glResetAllVertexAttributes
+     * @see #glReplaceShader
+     */
+    public boolean glVertexAttribPointer(GL2ES2 gl, GLArrayData data) {
+        if(!shaderProgram.inUse()) throw new GLException("Program is not in use");
+        if(!enabledVertexAttribArraySet.contains(data.getName())) {
+            if(!glEnableVertexAttribArray(gl, data.getName())) {
+                if(verbose) {
+                    Throwable tX = new Throwable("Info: glVertexAttribPointer: couldn't enable: "+data);
+                    tX.printStackTrace();
+                }
+            }
+        }
+        int index = getAttribLocation(data.getName());
+        if(0>index) {
+            if(verbose) {
+                Throwable tX = new Throwable("Info: glVertexAttribPointer failed, no index for: "+data);
+                tX.printStackTrace();
+            }
+        }
+        data.setLocation(index);
+        vertexAttribMap2Data.put(data.getName(), data);
+        if(0<=index) {
+            // only pass the data, if the attribute exists in the current shader
+            if(DEBUG) {
+                System.err.println("Info: glVertexAttribPointer: "+data);
+            }
+            gl.glVertexAttribPointer(data);
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Get the vertex attribute data, previously set.
+     *
+     * @returns the GLArrayData object, null if not previously set.
+     *
+     * @see #glEnableVertexAttribArray
+     * @see #glDisableVertexAttribArray
+     * @see #glVertexAttribPointer
+     * @see #getVertexAttributePointer
+     * @see #glReleaseAllVertexAttributes
+     * @see #glResetAllVertexAttributes
+     * @see #glReplaceShader
+     */
+    public GLArrayData getVertexAttribPointer(String name) {
+        return (GLArrayData) vertexAttribMap2Data.get(name);
+    }
+
+    /**
+     * Releases all mapped vertex attribute data,
+     * disables all enabled attributes and loses all indices
+     *
+     * @throws GLException is the program is not in use but the shaderProgram is set
+     *
+     * @see #glEnableVertexAttribArray
+     * @see #glDisableVertexAttribArray
+     * @see #glVertexAttribPointer
+     * @see #getVertexAttributePointer
+     * @see #glReleaseAllVertexAttributes
+     * @see #glResetAllVertexAttributes
+     * @see #glResetAllVertexAttributes
+     * @see #glReplaceShader
+     */
+    public void glReleaseAllVertexAttributes(GL2ES2 gl) {
+        if(null!=shaderProgram) {
+            if(!shaderProgram.inUse()) throw new GLException("Program is not in use");
+            for(Iterator iter = vertexAttribMap2Data.keySet().iterator(); iter.hasNext(); ) {
+                if(!glDisableVertexAttribArray(gl, (String) iter.next())) {
+                    throw new GLException("Internal Error: mapped vertex attribute couldn't be disabled");
+                }
+            }
+            for(Iterator iter = enabledVertexAttribArraySet.iterator(); iter.hasNext(); ) {
+                if(!glDisableVertexAttribArray(gl, (String) iter.next())) {
+                    throw new GLException("Internal Error: prev enabled vertex attribute couldn't be disabled");
+                }
+            }
+        }
+        vertexAttribMap2Data.clear();
+        enabledVertexAttribArraySet.clear();
+        attribMap2Idx.clear();
+    }
+        
+    /**
+     * Disables all vertex attribute arrays.
+     *
+     * Their enabled stated will be removed from this state only
+     * if 'removeFromState' is true.
+     *
+     * This method purpose is more for debugging. 
+     *
+     * @throws GLException is the program is not in use but the shaderProgram is set
+     *
+     * @see #glEnableVertexAttribArray
+     * @see #glDisableVertexAttribArray
+     * @see #glVertexAttribPointer
+     * @see #getVertexAttributePointer
+     * @see #glReleaseAllVertexAttributes
+     * @see #glResetAllVertexAttributes
+     * @see #glResetAllVertexAttributes
+     * @see #glReplaceShader
+     */
+    public void glDisableAllVertexAttributeArrays(GL2ES2 gl, boolean removeFromState) {
+        if(!shaderProgram.inUse()) throw new GLException("Program is not in use");
+
+        for(Iterator iter = enabledVertexAttribArraySet.iterator(); iter.hasNext(); ) {
+            String name = (String) iter.next();
+            if(removeFromState) {
+                enabledVertexAttribArraySet.remove(name);
+            }
+            int index = glGetAttribLocation(gl, name);
+            if(0<=index) {
+                gl.glDisableVertexAttribArray(index);
+            }
+        }
+    }
+
+    /**
+     * Reset all previously enabled mapped vertex attribute data,
+     * incl enabling them
+     *
+     * @throws GLException is the program is not in use
+     *
+     * @see #glEnableVertexAttribArray
+     * @see #glDisableVertexAttribArray
+     * @see #glVertexAttribPointer
+     * @see #getVertexAttributePointer
+     * @see #glReleaseAllVertexAttributes
+     * @see #glResetAllVertexAttributes
+     * @see #glReplaceShader
+     */
+    public void glResetAllVertexAttributes(GL2ES2 gl) {
+        if(!shaderProgram.inUse()) throw new GLException("Program is not in use");
+        attribMap2Idx.clear();
+
+        /**
+         *
+        for(Iterator iter = enabledVertexAttribArraySet.iterator(); iter.hasNext(); ) {
+            glEnableVertexAttribArray(gl, (String) iter.next());
+        }
+        for(Iterator iter = vertexAttribMap2Data.values().iterator(); iter.hasNext(); ) {
+            GLArrayData data = (GLArrayData) iter.next();
+
+            ...
+        } */
+
+        for(Iterator iter = enabledVertexAttribArraySet.iterator(); iter.hasNext(); ) {
+            // get new location ..
+            String name = (String) iter.next();
+            int loc = glGetAttribLocation(gl, name);
+
+            // get & update data ..
+            GLArrayData data = getVertexAttribPointer(name);
+            data.setLocation(loc);
+            vertexAttribMap2Data.put(name, data);
+
+            if(0>loc) {
+                // not used in shader
+                continue;
+            }
+
+            // enable attrib, VBO and pass location/data
+            gl.glEnableVertexAttribArray(loc);
+
+            if( data.isVBO() ) {
+                gl.glBindBuffer(GL.GL_ARRAY_BUFFER, data.getVBOName());
+            } 
+
+            gl.glVertexAttribPointer(data);
+        }
+    }
+
+    //
+    // Shader Uniform handling
+    //
+
+    /**
+     * Gets the index of a shader uniform.
+     * This must be done when the program is in use !
+     *
+     * @return -1 if there is no such attribute available,
+     *         otherwise >= 0
+
+     * @throws GLException is the program is not linked
+     *
+     * @see #glGetUniformLocation
+     * @see javax.media.opengl.GL2ES2#glGetUniformLocation
+     * @see #getUniformLocation
+     * @see #glReplaceShader
+     */
+    protected int glGetUniformLocation(GL2ES2 gl, String name) {
+        if(!shaderProgram.inUse()) throw new GLException("Program is not in use");
+        int index = getUniformLocation(name);
+        if(0>index) {
+            index = gl.glGetUniformLocation(shaderProgram.program(), name);
+            if(0<=index) {
+                Integer idx = new Integer(index);
+                uniformMap2Idx.put(name, idx);
+            } else if(verbose) {
+                Throwable tX = new Throwable("Info: glUniform failed, no location for: "+name+", index: "+index);
+                tX.printStackTrace();
+            }
+        }
+        return index;
+    }
+
+    protected int getUniformLocation(String name) {
+        Integer idx = (Integer) uniformMap2Idx.get(name);
+        return (null!=idx)?idx.intValue():-1;
+    }
+
+    /**
+     * Set the uniform data.
+     *
+     * Even if the uniform is not found in the current shader,
+     * it is stored in this state.
+     *
+     * @param data the GLUniforms's name must match the uniform one,
+     *      it's index will be set with the uniforms's location,
+     *      if found.
+     *
+     *
+     * @returns false, if the name is not found, otherwise true
+     *
+     * @throws GLException if the program is not in use
+     *
+     * @see #glGetUniformLocation
+     * @see javax.media.opengl.GL2ES2#glGetUniformLocation
+     * @see #getUniformLocation
+     * @see #glReplaceShader
+     */
+    public boolean glUniform(GL2ES2 gl, GLUniformData data) {
+        if(!shaderProgram.inUse()) throw new GLException("Program is not in use");
+        int location = glGetUniformLocation(gl, data.getName());
+        data.setLocation(location);
+        uniformMap2Data.put(data.getName(), data);
+        if(0<=location) {
+            // only pass the data, if the uniform exists in the current shader
+            if(DEBUG) {
+                System.err.println("Info: glUniform: "+data);
+            }
+            gl.glUniform(data);
+        }
+        return true;
+    }
+
+    /**
+     * Get the uniform data, previously set.
+     *
+     * @returns the GLUniformData object, null if not previously set.
+     */
+    public GLUniformData getUniform(String name) {
+        return (GLUniformData) uniformMap2Data.get(name);
+    }
+
+    /**
+     * Releases all mapped uniform data
+     * and loses all indices
+     *
+     * @throws GLException is the program is not in use
+     */
+    public void glReleaseAllUniforms(GL2ES2 gl) {
+        uniformMap2Data.clear();
+        uniformMap2Idx.clear();
+    }
+        
+    /**
+     * Reset all previously mapped uniform data
+     *
+     * @throws GLException is the program is not in use
+     */
+    public void glResetAllUniforms(GL2ES2 gl) {
+        if(!shaderProgram.inUse()) throw new GLException("Program is not in use");
+        uniformMap2Idx.clear();
+        for(Iterator iter = uniformMap2Data.values().iterator(); iter.hasNext(); ) {
+            glUniform(gl, (GLUniformData) iter.next());
+        }
+    }
+
+    public String toString() {
+        StringBuffer buf = new StringBuffer();
+        buf.append("ShaderState[");
+        buf.append(shaderProgram.toString());
+        buf.append(",EnabledStates: [");
+        for(Iterator iter = enabledVertexAttribArraySet.iterator(); iter.hasNext(); ) {
+            buf.append("\n  ");
+            buf.append((String)iter.next());
+        }
+        buf.append("], [");
+        for(Iterator iter = vertexAttribMap2Data.values().iterator(); iter.hasNext(); ) {
+            GLArrayData data = (GLArrayData) iter.next();
+            if(data.getLocation()>=0) {
+                buf.append("\n  ");
+                buf.append(data);
+            }
+        }
+        buf.append("], [");
+        for(Iterator iter=uniformMap2Data.values().iterator(); iter.hasNext(); ) {
+            GLUniformData data = (GLUniformData) iter.next();
+            if(data.getLocation()>=0) {
+                buf.append("\n  ");
+                buf.append(data);
+            }
+        }
+        buf.append("]");
+        return buf.toString();
+    }
+
+    protected boolean verbose = false;
+    protected ShaderProgram shaderProgram=null;
+    protected HashMap attribMap2Idx = new HashMap();
+    protected HashSet enabledVertexAttribArraySet = new HashSet();
+    protected HashMap vertexAttribMap2Data = new HashMap();
+    protected HashMap uniformMap2Idx = new HashMap();
+    protected HashMap uniformMap2Data = new HashMap();
+
+}
+
diff --git a/src/jogl/classes/com/jogamp/opengl/util/glsl/ShaderUtil.java b/src/jogl/classes/com/jogamp/opengl/util/glsl/ShaderUtil.java
new file mode 100644
index 000000000..21f359f52
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/glsl/ShaderUtil.java
@@ -0,0 +1,476 @@
+/*
+ * Copyright (c) 2009 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ */
+
+package com.jogamp.opengl.util.glsl;
+
+import java.io.PrintStream;
+import java.nio.*;
+import java.util.*;
+
+import javax.media.opengl.*;
+
+public class ShaderUtil {
+    static abstract class Impl {
+        public abstract String getShaderInfoLog(GL gl, int shaderObj);
+        public abstract String getProgramInfoLog(GL gl, int programObj);
+        public abstract boolean isShaderStatusValid(GL gl, int shaderObj, int name);
+        public abstract boolean isShaderStatusValid(GL gl, int shaderObj, int name, PrintStream verboseOut);
+        public abstract boolean isShaderStatusValid(GL gl, IntBuffer shaders, int name);
+        public abstract boolean isShaderStatusValid(GL gl, IntBuffer shaders, int name, PrintStream verboseOut);
+        public abstract boolean isProgramStatusValid(GL gl, int programObj, int name);
+        public abstract boolean isProgramValid(GL gl, int programObj);
+        public abstract boolean isProgramValid(GL gl, int programObj, PrintStream verboseOut);
+        public abstract void createShader(GL gl, int type, IntBuffer shaders);
+        public abstract Set getShaderBinaryFormats(GL gl);
+        public abstract boolean isShaderCompilerAvailable(GL gl);
+        public abstract void shaderSource(GL gl, int shader, java.lang.String[] source);
+        public abstract void shaderSource(GL gl, IntBuffer shaders, java.lang.String[][] sources);
+        public abstract void shaderBinary(GL gl, IntBuffer shaders, int binFormat, java.nio.Buffer bin);
+        public abstract void compileShader(GL gl, IntBuffer shaders);
+        public abstract void attachShader(GL gl, int program, IntBuffer shaders);
+        public abstract void detachShader(GL gl, int program, IntBuffer shaders);
+        public abstract void deleteShader(GL gl, IntBuffer shaders);
+
+        public abstract boolean createAndLoadShader(GL gl, IntBuffer shader, int shaderType,
+                                                    int binFormat, java.nio.Buffer bin,
+                                                    PrintStream verboseOut);
+
+        public abstract boolean createAndCompileShader(GL gl, IntBuffer shader, int shaderType,
+                                                       java.lang.String[][] sources, 
+                                                       PrintStream verboseOut);
+    }
+
+    static class GL2ES2Impl extends Impl {
+        public String getShaderInfoLog(GL _gl, int shaderObj) {
+            GL2ES2 gl = _gl.getGL2ES2();
+            int[] infoLogLength=new int[1];
+            gl.glGetShaderiv(shaderObj, gl.GL_INFO_LOG_LENGTH, infoLogLength, 0);
+
+            if(infoLogLength[0]==0) {
+                return "(no info log)";
+            }
+            int[] charsWritten=new int[1];
+            byte[] infoLogBytes = new byte[infoLogLength[0]];
+            gl.glGetShaderInfoLog(shaderObj, infoLogLength[0], charsWritten, 0, infoLogBytes, 0);
+
+            return new String(infoLogBytes, 0, charsWritten[0]);
+        }
+
+        public String getProgramInfoLog(GL _gl, int programObj) {
+            GL2ES2 gl = _gl.getGL2ES2();
+            int[] infoLogLength=new int[1];
+            gl.glGetProgramiv(programObj, gl.GL_INFO_LOG_LENGTH, infoLogLength, 0);
+
+            if(infoLogLength[0]==0) {
+                return "(no info log)";
+            }
+            int[] charsWritten=new int[1];
+            byte[] infoLogBytes = new byte[infoLogLength[0]];
+            gl.glGetProgramInfoLog(programObj, infoLogLength[0], charsWritten, 0, infoLogBytes, 0);
+
+            return new String(infoLogBytes, 0, charsWritten[0]);
+        }
+
+        public boolean isShaderStatusValid(GL _gl, int shaderObj, int name) {
+            return isShaderStatusValid(_gl, shaderObj, name, null);
+        }
+
+        public boolean isShaderStatusValid(GL _gl, int shaderObj, int name, PrintStream verboseOut) {
+            GL2ES2 gl = _gl.getGL2ES2();
+            int[] ires = new int[1];
+            gl.glGetShaderiv(shaderObj, name, ires, 0);
+
+            boolean res = ires[0]==1;
+            if(!res && null!=verboseOut) {
+                verboseOut.println("Shader status invalid: "+ getShaderInfoLog(gl, shaderObj));
+            }
+            return res;
+        }
+
+        public boolean isShaderStatusValid(GL _gl, IntBuffer shaders, int name) {
+            return isShaderStatusValid(_gl, shaders, name, null);
+        }
+
+        public boolean isShaderStatusValid(GL _gl, IntBuffer shaders, int name, PrintStream verboseOut) {
+            boolean res = true;
+            for (int i = shaders.position(); i < shaders.limit(); i++) {
+                res = isShaderStatusValid(_gl, shaders.get(i), name, verboseOut) && res;
+            }
+            return res;
+        }
+
+        public boolean isProgramStatusValid(GL _gl, int programObj, int name) {
+            GL2ES2 gl = _gl.getGL2ES2();
+            int[] ires = new int[1];
+            gl.glGetProgramiv(programObj, name, ires, 0);
+
+            return ires[0]==1;
+        }
+
+        public boolean isProgramValid(GL _gl, int programObj) {
+            return isProgramValid(_gl, programObj, null);
+        }
+
+        public boolean isProgramValid(GL _gl, int programObj, PrintStream verboseOut) {
+            GL2ES2 gl = _gl.getGL2ES2();
+            int[] ires = new int[1];
+            if(!gl.glIsProgram(programObj)) {
+                if(null!=verboseOut) {
+                    verboseOut.println("Program name invalid: "+programObj);
+                }
+                return false;
+            }
+            if(!isProgramStatusValid(gl, programObj, gl.GL_LINK_STATUS)) {
+                if(null!=verboseOut) {
+                    verboseOut.println("Program link failed: "+programObj+"\n\t"+ getProgramInfoLog(gl, programObj));
+                }
+                return false;
+            }
+            if ( !gl.isGLES2() || isShaderCompilerAvailable(gl) ) {
+                // failed on APX2500 (ES2.0, no compiler) for valid programs
+                gl.glValidateProgram(programObj);
+                if(!isProgramStatusValid(gl, programObj, gl.GL_VALIDATE_STATUS)) {
+                    if(null!=verboseOut) {
+                        verboseOut.println("Program validation failed: "+programObj+"\n\t"+ getProgramInfoLog(gl, programObj));
+                    }
+                    return false;
+                }
+            }
+            return true;
+        }
+
+        public void createShader(GL _gl, int type, IntBuffer shaders) {
+            GL2ES2 gl = _gl.getGL2ES2();
+            for (int i = shaders.position(); i < shaders.limit(); i++) {
+                shaders.put(i, gl.glCreateShader(type));
+            }
+        }
+
+        private Boolean shaderCompilerAvailable = null;
+        private Set shaderBinaryFormats = null;
+
+        public Set getShaderBinaryFormats(GL _gl) {
+            GL2ES2 gl = _gl.getGL2ES2();
+            if(null==shaderBinaryFormats) {
+                if(gl.getContext()!=GLContext.getCurrent()) {
+                    return new HashSet(0); // bail out
+                }
+
+                int[] param = new int[1];
+                shaderBinaryFormats = new HashSet();
+
+                if (gl.isGLES2()) {
+                    gl.glGetIntegerv(GL2ES2.GL_NUM_SHADER_BINARY_FORMATS, param, 0);
+                    int numFormats = param[0];
+                    if(numFormats>0) {
+                        int[] formats = new int[numFormats];
+                        gl.glGetIntegerv(GL2ES2.GL_SHADER_BINARY_FORMATS, formats, 0);
+                        for(int i=0; i<numFormats; i++) {
+                            shaderBinaryFormats.add(new Integer(formats[i]));
+                        }
+                    }
+                }
+            }
+            return shaderBinaryFormats;
+        }
+
+
+        public boolean isShaderCompilerAvailable(GL _gl) {
+            GL2ES2 gl = _gl.getGL2ES2();
+            if(null==shaderCompilerAvailable) {
+                if(gl.getContext()!=GLContext.getCurrent()) {
+                    return false; // bail out
+                }
+                Set bfs = getShaderBinaryFormats(gl);
+                if(gl.isGLES2()) {
+                    byte[] param = new byte[1];
+                    gl.glGetBooleanv(GL2ES2.GL_SHADER_COMPILER, param, 0);
+                    boolean v = param[0]!=(byte)0x00;
+                    if(!v && bfs.size()==0) {
+                        // no supported binary formats, hence a compiler must be available!
+                        v = true;
+                    }
+                    shaderCompilerAvailable = new Boolean(v);
+                } else if( gl.isGL2() || gl.isGL2ES2() ) {
+                    shaderCompilerAvailable = new Boolean(true);
+                } else {
+                    throw new GLException("Invalid OpenGL profile");
+                }
+            }
+            return shaderCompilerAvailable.booleanValue();
+        }
+
+        public void shaderSource(GL _gl, int shader, java.lang.String[] source)
+        {
+            GL2ES2 gl = _gl.getGL2ES2();
+            if(!isShaderCompilerAvailable(_gl)) {
+                throw new GLException("No compiler is available");
+            }
+
+            int count = (null!=source)?source.length:0;
+            if(count==0) {
+                throw new GLException("No sources specified");
+            }
+
+            int[] lengths = new int[count];
+            for(int i=0; i<count; i++) {
+                lengths[i] = source[i].length();
+            }
+            gl.glShaderSource(shader, count, source, lengths, 0);
+        }
+
+        public void shaderSource(GL _gl, IntBuffer shaders, java.lang.String[][] sources)
+        {
+            int sourceNum = (null!=sources)?sources.length:0;
+            int shaderNum = (null!=shaders)?shaders.remaining():0;
+            if(shaderNum<=0 || sourceNum<=0 || shaderNum!=sourceNum) {
+                throw new GLException("Invalid number of shaders and/or sources: shaders="+
+                                      shaderNum+", sources="+sourceNum);
+            }
+            for(int i=0; i<sourceNum; i++) {
+                shaderSource(_gl, shaders.get(shaders.position() + i), sources[i]);
+            }
+        }
+
+        public void shaderBinary(GL _gl, IntBuffer shaders, int binFormat, java.nio.Buffer bin)
+        {
+            GL2ES2 gl = _gl.getGL2ES2();
+            if(getShaderBinaryFormats(gl).size()<=0) {
+                throw new GLException("No binary formats are supported");
+            }
+
+            int shaderNum = shaders.remaining();
+            if(shaderNum<=0) {
+                throw new GLException("No shaders specified");
+            }
+            if(null==bin) {
+                throw new GLException("Null shader binary");
+            }
+            int binLength = bin.remaining();
+            if(0>=binLength) {
+                throw new GLException("Empty shader binary (remaining == 0)");
+            }
+            gl.glShaderBinary(shaderNum, shaders, binFormat, bin, binLength);
+        }
+
+        public void compileShader(GL _gl, IntBuffer shaders)
+        {
+            GL2ES2 gl = _gl.getGL2ES2();
+            for (int i = shaders.position(); i < shaders.limit(); i++) {
+                gl.glCompileShader(shaders.get(i));
+            }
+        }
+
+        public void attachShader(GL _gl, int program, IntBuffer shaders)
+        {
+            GL2ES2 gl = _gl.getGL2ES2();
+            for (int i = shaders.position(); i < shaders.limit(); i++) {
+                gl.glAttachShader(program, shaders.get(i));
+            }
+        }
+
+        public void detachShader(GL _gl, int program, IntBuffer shaders)
+        {
+            GL2ES2 gl = _gl.getGL2ES2();
+            for (int i = shaders.position(); i < shaders.limit(); i++) {
+                gl.glDetachShader(program, shaders.get(i));
+            }
+        }
+
+        public void deleteShader(GL _gl, IntBuffer shaders)
+        {
+            GL2ES2 gl = _gl.getGL2ES2();
+            for (int i = shaders.position(); i < shaders.limit(); i++) {
+                gl.glDeleteShader(shaders.get(i));
+
+            }
+        }
+
+        public boolean createAndLoadShader(GL _gl, IntBuffer shader, int shaderType,
+                                           int binFormat, java.nio.Buffer bin,
+                                           PrintStream verboseOut)
+        {
+            GL2ES2 gl = _gl.getGL2ES2();
+            int err = gl.glGetError(); // flush previous errors ..
+            if(err!=GL.GL_NO_ERROR && null!=verboseOut) {
+                verboseOut.println("createAndLoadShader: Pre GL Error: 0x"+Integer.toHexString(err));
+            }
+
+            createShader(gl, shaderType, shader);
+            err = gl.glGetError(); 
+            if(err!=GL.GL_NO_ERROR) {
+                throw new GLException("createAndLoadShader: CreateShader failed, GL Error: 0x"+Integer.toHexString(err));
+            }
+
+
+            shaderBinary(gl, shader, binFormat, bin);
+
+            err = gl.glGetError();
+            if(err!=GL.GL_NO_ERROR && null!=verboseOut) {
+                verboseOut.println("createAndLoadShader: ShaderBinary failed, GL Error: 0x"+Integer.toHexString(err));
+            }
+            return err == GL.GL_NO_ERROR;
+        }
+
+        public boolean createAndCompileShader(GL _gl, IntBuffer shader, int shaderType,
+                                              java.lang.String[][] sources, 
+                                              PrintStream verboseOut)
+        {
+            GL2ES2 gl = _gl.getGL2ES2();
+            int err = gl.glGetError(); // flush previous errors ..
+            if(err!=GL.GL_NO_ERROR && null!=verboseOut) {
+                verboseOut.println("createAndCompileShader: Pre GL Error: 0x"+Integer.toHexString(err));
+            }
+
+            createShader(gl, shaderType, shader);
+            err = gl.glGetError(); 
+            if(err!=GL.GL_NO_ERROR) {
+                throw new GLException("createAndCompileShader: CreateShader failed, GL Error: 0x"+Integer.toHexString(err));
+            }
+
+            shaderSource(gl, shader, sources);
+            err = gl.glGetError(); 
+            if(err!=GL.GL_NO_ERROR) {
+                throw new GLException("createAndCompileShader: ShaderSource failed, GL Error: 0x"+Integer.toHexString(err));
+            }
+
+            compileShader(gl, shader);
+            err = gl.glGetError(); 
+            if(err!=GL.GL_NO_ERROR && null!=verboseOut) {
+                verboseOut.println("createAndCompileShader: CompileShader failed, GL Error: 0x"+Integer.toHexString(err));
+            }
+
+            return isShaderStatusValid(gl, shader, gl.GL_COMPILE_STATUS, verboseOut) && err == GL.GL_NO_ERROR;
+        }
+
+    }
+
+    public static String getShaderInfoLog(GL gl, int shaderObj) {
+        return getImpl(gl).getShaderInfoLog(gl, shaderObj);
+    }
+
+    public static String getProgramInfoLog(GL gl, int programObj) {
+        return getImpl(gl).getProgramInfoLog(gl, programObj);
+    }
+
+    public static boolean isShaderStatusValid(GL gl, int shaderObj, int name) {
+        return getImpl(gl).isShaderStatusValid(gl, shaderObj, name);
+    }
+
+    public static boolean isShaderStatusValid(GL gl, int shaderObj, int name, PrintStream verboseOut) {
+        return getImpl(gl).isShaderStatusValid(gl, shaderObj, name, verboseOut);
+    }
+
+    public static boolean isShaderStatusValid(GL gl, IntBuffer shaders, int name) {
+        return getImpl(gl).isShaderStatusValid(gl, shaders, name);
+    }
+
+    public static boolean isShaderStatusValid(GL gl, IntBuffer shaders, int name, PrintStream verboseOut) {
+        return getImpl(gl).isShaderStatusValid(gl, shaders, name, verboseOut);
+    }
+
+    public static boolean isProgramStatusValid(GL gl, int programObj, int name) {
+        return getImpl(gl).isProgramStatusValid(gl, programObj, name);
+    }
+
+    public static boolean isProgramValid(GL gl, int programObj) {
+        return getImpl(gl).isProgramValid(gl, programObj);
+    }
+
+    public static boolean isProgramValid(GL gl, int programObj, PrintStream verboseOut) {
+        return getImpl(gl).isProgramValid(gl, programObj, verboseOut);
+    }
+
+    public static void createShader(GL gl, int type, IntBuffer shaders) {
+        getImpl(gl).createShader(gl, type, shaders);
+    }
+
+    public static Set getShaderBinaryFormats(GL gl) {
+        return getImpl(gl).getShaderBinaryFormats(gl);
+    }
+
+    public static boolean isShaderCompilerAvailable(GL gl) {
+        return getImpl(gl).isShaderCompilerAvailable(gl);
+    }
+
+    public static void shaderSource(GL gl, int shader, java.lang.String[] source) {
+        getImpl(gl).shaderSource(gl, shader, source);
+    }
+
+    public static void shaderSource(GL gl, IntBuffer shaders, java.lang.String[][] sources) {
+        getImpl(gl).shaderSource(gl, shaders, sources);
+    }
+
+    public static void shaderBinary(GL gl, IntBuffer shaders, int binFormat, java.nio.Buffer bin) {
+        getImpl(gl).shaderBinary(gl, shaders, binFormat, bin);
+    }
+
+    public static void compileShader(GL gl, IntBuffer shaders) {
+        getImpl(gl).compileShader(gl, shaders);
+    }
+
+    public static void attachShader(GL gl, int program, IntBuffer shaders) {
+        getImpl(gl).attachShader(gl, program, shaders);
+    }
+
+    public static void detachShader(GL gl, int program, IntBuffer shaders) {
+        getImpl(gl).detachShader(gl, program, shaders);
+    }
+
+    public static void deleteShader(GL gl, IntBuffer shaders) {
+        getImpl(gl).deleteShader(gl, shaders);
+    }
+
+    public static boolean createAndLoadShader(GL gl, IntBuffer shader, int shaderType,
+                                              int binFormat, java.nio.Buffer bin,
+                                              PrintStream verboseOut) {
+        return getImpl(gl).createAndLoadShader(gl, shader, shaderType, binFormat, bin, verboseOut);
+    }
+
+    public static boolean createAndCompileShader(GL gl, IntBuffer shader, int shaderType,
+                                                 java.lang.String[][] sources, 
+                                                 PrintStream verboseOut) {
+        return getImpl(gl).createAndCompileShader(gl, shader, shaderType, sources, verboseOut);
+    }
+
+    private static Impl getImpl(GL _gl) {
+        GL2ES2 gl = _gl.getGL2ES2();
+        GLContext context = gl.getContext();
+        Impl impl = (Impl) context.getAttachedObject(ShaderUtil.class.getName());
+        if (impl == null) {
+            impl = new GL2ES2Impl();
+            context.putAttachedObject(ShaderUtil.class.getName(), impl);
+        }
+        return impl;
+    }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/FixedFuncUtil.java b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/FixedFuncUtil.java
new file mode 100644
index 000000000..a7042c47a
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/FixedFuncUtil.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright 2009 Sun Microsystems, Inc. All Rights Reserved.
+ */
+
+package com.jogamp.opengl.util.glsl.fixedfunc;
+
+import javax.media.opengl.*;
+import javax.media.opengl.fixedfunc.*;
+
+import com.jogamp.opengl.util.glsl.fixedfunc.impl.*;
+
+/**
+ * Tool to pipeline GL2ES2 into a fixed function emulation implementing GL2ES1.
+ */
+public class FixedFuncUtil {
+    /**
+     * @return If gl is a GL2ES1 and force is false, return the type cast object,
+     *         otherwise create a fixed function emulation pipeline with the GL2ES2 impl.
+     * @throws GLException if the GL object is neither GL2ES1 nor GL2ES2
+     */
+    public static final GL2ES1 getFixedFuncImpl(GL gl, boolean force) {
+        if(!force && gl.isGL2ES1()) {
+            return gl.getGL2ES1();
+        } else if(gl.isGL2ES2()) {
+            GL2ES2 es2 = gl.getGL2ES2();
+            FixedFuncHook hook = new FixedFuncHook(es2);
+            FixedFuncImpl impl = new FixedFuncImpl(es2, hook);
+            gl.getContext().setGL(impl);
+            return impl;
+        }
+        throw new GLException("GL Object is neither GL2ES1 nor GL2ES2");
+    }
+
+    /**
+     * @return If gl is a GL2ES1, return the type cast object,
+     *         otherwise create a fixed function emulation pipeline with the GL2ES2 impl.
+     * @throws GLException if the GL object is neither GL2ES1 nor GL2ES2
+     */
+    public static final GL2ES1 getFixedFuncImpl(GL gl) {
+        return getFixedFuncImpl(gl, false);
+    }
+
+    /**
+     * Mapping fixed function (client) array indices to 
+     * GLSL array attribute names.
+     *
+     * Useful for uniq mapping of canonical array index names as listed.
+     * 
+     * @see #mgl_Vertex
+     * @see javax.media.opengl.fixedfunc.GLPointerFunc#GL_VERTEX_ARRAY
+     * @see #mgl_Normal
+     * @see javax.media.opengl.fixedfunc.GLPointerFunc#GL_NORMAL_ARRAY
+     * @see #mgl_Color
+     * @see javax.media.opengl.fixedfunc.GLPointerFunc#GL_COLOR_ARRAY
+     * @see #mgl_MultiTexCoord
+     * @see javax.media.opengl.fixedfunc.GLPointerFunc#GL_TEXTURE_COORD_ARRAY
+     * @see javax.media.opengl.fixedfunc.GLPointerFunc#glEnableClientState
+     * @see javax.media.opengl.fixedfunc.GLPointerFunc#glVertexPointer
+     * @see javax.media.opengl.fixedfunc.GLPointerFunc#glColorPointer
+     * @see javax.media.opengl.fixedfunc.GLPointerFunc#glNormalPointer
+     * @see javax.media.opengl.fixedfunc.GLPointerFunc#glTexCoordPointer
+     */
+    public static String getPredefinedArrayIndexName(int glArrayIndex) {
+        return FixedFuncPipeline.getPredefinedArrayIndexName(glArrayIndex);
+    }
+
+    /**
+     * String name for
+     * @see javax.media.opengl.GL#GL_VERTEX_ARRAY
+     */
+    public static final String mgl_Vertex = FixedFuncPipeline.mgl_Vertex;
+
+    /**
+     * String name for
+     * @see javax.media.opengl.GL#GL_NORMAL_ARRAY
+     */
+    public static final String mgl_Normal = FixedFuncPipeline.mgl_Normal;
+
+    /**
+     * String name for
+     * @see javax.media.opengl.GL#GL_COLOR_ARRAY
+     */
+    public static final String mgl_Color = FixedFuncPipeline.mgl_Color;
+
+    /**
+     * String name for
+     * @see javax.media.opengl.GL#GL_TEXTURE_COORD_ARRAY
+     */
+    public static final String mgl_MultiTexCoord = FixedFuncPipeline.mgl_MultiTexCoord;
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/FixedFuncHook.java b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/FixedFuncHook.java
new file mode 100755
index 000000000..c03ee8e30
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/FixedFuncHook.java
@@ -0,0 +1,331 @@
+/*
+ * Copyright 2009 Sun Microsystems, Inc. All Rights Reserved.
+ */
+
+package com.jogamp.opengl.util.glsl.fixedfunc.impl;
+
+import javax.media.opengl.*;
+import javax.media.opengl.fixedfunc.*;
+import javax.media.opengl.glu.*;
+import com.jogamp.gluegen.runtime.BufferFactory;
+import com.jogamp.opengl.util.*;
+import com.jogamp.opengl.util.glsl.*;
+import java.nio.*;
+
+public class FixedFuncHook implements GLLightingFunc, GLMatrixFunc, GLPointerFunc {
+    public static final int MAX_TEXTURE_UNITS = 8;
+
+    protected FixedFuncPipeline fixedFunction=null;
+    protected PMVMatrix pmvMatrix=null;
+    protected GL2ES2 gl=null;
+
+    public FixedFuncHook (GL2ES2 gl) {
+        this(gl, null);
+    }
+
+    public FixedFuncHook (GL2ES2 gl, PMVMatrix matrix) {
+        this.gl = gl;
+        pmvMatrix = (null!=matrix)?matrix:new PMVMatrix();
+
+        fixedFunction = new FixedFuncPipeline(gl, pmvMatrix);
+    }
+
+    public FixedFuncHook(GL2ES2 gl, PMVMatrix matrix, 
+                       Class shaderRootClass, String shaderSrcRoot, String shaderBinRoot, 
+                       String vertexColorFile,
+                       String vertexColorLightFile,
+                       String fragmentColorFile,
+                       String fragmentColorTextureFile) {
+        this.gl = gl;
+        pmvMatrix = matrix;
+
+        fixedFunction = new FixedFuncPipeline(gl, pmvMatrix,
+                                              shaderRootClass, shaderSrcRoot, shaderBinRoot, 
+                                              vertexColorFile, vertexColorLightFile, fragmentColorFile, fragmentColorTextureFile);
+    }
+
+    public void destroy() {
+        fixedFunction.destroy(gl);
+        fixedFunction = null;
+    }
+
+    public PMVMatrix getMatrix() { return pmvMatrix; }
+
+    //
+    // FixedFuncHookIf - hooks 
+    //
+    public void glDrawArrays(int mode, int first, int count) {
+        fixedFunction.validate(gl); 
+        gl.glDrawArrays(mode, first, count);
+    }
+    public void glDrawElements(int mode, int count, int type, java.nio.Buffer indices) {
+        fixedFunction.validate(gl); 
+        gl.glDrawElements(mode, count, type, indices);
+    }
+    public void glDrawElements(int mode, int count, int type, long indices_buffer_offset) {
+        fixedFunction.validate(gl); 
+        gl.glDrawElements(mode, count, type, indices_buffer_offset);
+    }
+
+    public void glActiveTexture(int texture) {
+        fixedFunction.glActiveTexture(gl, texture);
+        gl.glActiveTexture(texture);
+    }
+    public void glEnable(int cap) {
+        if(fixedFunction.glEnable(gl, cap, true)) {
+            gl.glEnable(cap);
+        }
+    }
+    public void glDisable(int cap) {
+        if(fixedFunction.glEnable(gl, cap, false)) {
+            gl.glDisable(cap);
+        }
+    }
+    public void glCullFace(int faceName) {
+        fixedFunction.glCullFace(gl, faceName);
+        gl.glCullFace(faceName);
+    }
+
+    public void glGetFloatv(int pname, java.nio.FloatBuffer params) {
+        if(pmvMatrix.isMatrixGetName(pname)) {
+            pmvMatrix.glGetFloatv(pname, params);
+            return;
+        }
+        gl.glGetFloatv(pname, params);
+    }
+    public void glGetFloatv(int pname, float[] params, int params_offset) {
+        if(pmvMatrix.isMatrixGetName(pname)) {
+            pmvMatrix.glGetFloatv(pname, params, params_offset);
+            return;
+        }
+        gl.glGetFloatv(pname, params, params_offset);
+    }
+    public void glGetIntegerv(int pname, IntBuffer params) {
+        if(pmvMatrix.isMatrixGetName(pname)) {
+            pmvMatrix.glGetIntegerv(pname, params);
+            return;
+        }
+        gl.glGetIntegerv(pname, params);
+    }
+    public void glGetIntegerv(int pname, int[] params, int params_offset) {
+        if(pmvMatrix.isMatrixGetName(pname)) {
+            pmvMatrix.glGetIntegerv(pname, params, params_offset);
+            return;
+        }
+        gl.glGetIntegerv(pname, params, params_offset);
+    }
+
+    // 
+    // MatrixIf
+    //
+    public int  glGetMatrixMode() {
+        return pmvMatrix.glGetMatrixMode();
+    }
+    public void glMatrixMode(int mode) {
+        pmvMatrix.glMatrixMode(mode);
+    }
+    public void glLoadMatrixf(java.nio.FloatBuffer m) {
+        pmvMatrix.glLoadMatrixf(m);
+    }
+    public void glLoadMatrixf(float[] m, int m_offset) {
+        glLoadMatrixf(BufferUtil.newFloatBuffer(m, m_offset));
+    }
+    public void glPopMatrix() {
+        pmvMatrix.glPopMatrix();
+    }
+    public void glPushMatrix() {
+        pmvMatrix.glPushMatrix();
+    }
+    public void glLoadIdentity() {
+        pmvMatrix.glLoadIdentity();
+    }
+    public void glMultMatrixf(java.nio.FloatBuffer m) {
+        pmvMatrix.glMultMatrixf(m);
+    }
+    public void glMultMatrixf(float[] m, int m_offset) {
+        glMultMatrixf(BufferUtil.newFloatBuffer(m, m_offset));
+    }
+    public void glTranslatef(float x, float y, float z) {
+        pmvMatrix.glTranslatef(x, y, z);
+    }
+    public void glRotatef(float angdeg, float x, float y, float z) {
+        pmvMatrix.glRotatef(angdeg, x, y, z);
+    }
+    public void glScalef(float x, float y, float z) {
+        pmvMatrix.glScalef(x, y, z);
+    }
+    public void glOrthof(float left, float right, float bottom, float top, float zNear, float zFar) {
+        pmvMatrix.glOrthof(left, right, bottom, top, zNear, zFar);
+    }
+    public void glFrustumf(float left, float right, float bottom, float top, float zNear, float zFar) {
+        pmvMatrix.glFrustumf(left, right, bottom, top, zNear, zFar);
+    }
+
+    // 
+    // LightingIf
+    //
+    public void glColor4f(float red, float green, float blue, float alpha) {
+      fixedFunction.glColor4fv(gl, BufferUtil.newFloatBuffer(new float[] { red, green, blue, alpha })); 
+    }
+
+    public void glLightfv(int light, int pname, java.nio.FloatBuffer params) {
+      fixedFunction.glLightfv(gl, light, pname, params);
+    }
+    public void glLightfv(int light, int pname, float[] params, int params_offset) {
+        glLightfv(light, pname, BufferUtil.newFloatBuffer(params, params_offset));
+    }
+    public void glMaterialfv(int face, int pname, java.nio.FloatBuffer params) {
+      fixedFunction.glMaterialfv(gl, face, pname, params);
+    }
+    public void glMaterialfv(int face, int pname, float[] params, int params_offset) {
+        glMaterialfv(face, pname, BufferUtil.newFloatBuffer(params, params_offset));
+    }
+    public void glMaterialf(int face, int pname, float param) {
+        glMaterialfv(face, pname, BufferUtil.newFloatBuffer(new float[] { param }));
+    }
+    public void glShadeModel(int mode) {
+      fixedFunction.glShadeModel(gl, mode);
+    }
+
+    //
+    // PointerIf
+    //
+    public void glEnableClientState(int glArrayIndex) {
+      fixedFunction.glEnableClientState(gl, glArrayIndex);
+    }
+    public void glDisableClientState(int glArrayIndex) {
+      fixedFunction.glDisableClientState(gl, glArrayIndex);
+    }
+
+    public void glVertexPointer(GLArrayData array) {
+      if(array.isVBO()) {
+          if(!gl.glIsVBOArrayEnabled()) {
+            throw new GLException("VBO array is not enabled: "+array);
+          }
+      } else {
+          if(gl.glIsVBOArrayEnabled()) {
+            throw new GLException("VBO array is not disabled: "+array);
+          }
+          BufferFactory.rangeCheck(array.getBuffer(), 1);
+          if (!BufferFactory.isDirect(array.getBuffer())) {
+            throw new GLException("Argument \"pointer\" was not a direct buffer"); }
+      }
+      fixedFunction.glVertexPointer(gl, array);
+    }
+
+    public void glVertexPointer(int size, int type, int stride, java.nio.Buffer pointer) {
+      glVertexPointer(GLArrayDataWrapper.createFixed(gl, GL_VERTEX_ARRAY, size, type, false, stride, pointer, 0, 0));
+    }
+    public void glVertexPointer(int size, int type, int stride, long pointer_buffer_offset) {
+      int vboName = gl.glGetBoundBuffer(GL.GL_ARRAY_BUFFER);
+      if(vboName==0) {
+        throw new GLException("no GL_ARRAY_BUFFER VBO bound");
+      }
+      glVertexPointer(GLArrayDataWrapper.createFixed(gl, GL_VERTEX_ARRAY, size, type, false, 
+                                                     stride, null, vboName, pointer_buffer_offset));
+    }
+
+    public void glColorPointer(GLArrayData array) {
+      if(array.isVBO()) {
+          if(!gl.glIsVBOArrayEnabled()) {
+            throw new GLException("VBO array is not enabled: "+array);
+          }
+      } else {
+          if(gl.glIsVBOArrayEnabled()) {
+            throw new GLException("VBO array is not disabled: "+array);
+          }
+          BufferFactory.rangeCheck(array.getBuffer(), 1);
+          if (!BufferFactory.isDirect(array.getBuffer())) {
+            throw new GLException("Argument \"pointer\" was not a direct buffer"); }
+      }
+      fixedFunction.glColorPointer(gl, array);
+    }
+    public void glColorPointer(int size, int type, int stride, java.nio.Buffer pointer) {
+      glColorPointer(GLArrayDataWrapper.createFixed(gl, GL_COLOR_ARRAY, size, type, false, 
+                                                    stride, pointer, 0, 0));
+    }
+    public void glColorPointer(int size, int type, int stride, long pointer_buffer_offset) {
+      int vboName = gl.glGetBoundBuffer(GL.GL_ARRAY_BUFFER);
+      if(vboName==0) {
+        throw new GLException("no GL_ARRAY_BUFFER VBO bound");
+      }
+      glColorPointer(GLArrayDataWrapper.createFixed(gl, GL_COLOR_ARRAY, size, type, false, 
+                                                   stride, null, vboName, pointer_buffer_offset));
+    }
+
+    public void glNormalPointer(GLArrayData array) {
+      if(array.getComponentNumber()!=3) {
+        throw new GLException("Only 3 components per normal allowed");
+      }
+      if(array.isVBO()) {
+          if(!gl.glIsVBOArrayEnabled()) {
+            throw new GLException("VBO array is not enabled: "+array);
+          }
+      } else {
+          if(gl.glIsVBOArrayEnabled()) {
+            throw new GLException("VBO array is not disabled: "+array);
+          }
+          BufferFactory.rangeCheck(array.getBuffer(), 1);
+          if (!BufferFactory.isDirect(array.getBuffer())) {
+            throw new GLException("Argument \"pointer\" was not a direct buffer"); }
+      }
+      fixedFunction.glNormalPointer(gl, array);
+    }
+    public void glNormalPointer(int type, int stride, java.nio.Buffer pointer) {
+      glNormalPointer(GLArrayDataWrapper.createFixed(gl, GL_NORMAL_ARRAY, 3, type, false, 
+                                                     stride, pointer, 0, 0));
+    }
+    public void glNormalPointer(int type, int stride, long pointer_buffer_offset) {
+      int vboName = gl.glGetBoundBuffer(GL.GL_ARRAY_BUFFER);
+      if(vboName==0) {
+        throw new GLException("no GL_ARRAY_BUFFER VBO bound");
+      }
+      glNormalPointer(GLArrayDataWrapper.createFixed(gl, GL_NORMAL_ARRAY, 3, type, false, 
+                                                     stride, null, vboName, pointer_buffer_offset));
+    }
+
+    public void glTexCoordPointer(GLArrayData array) {
+      if(array.isVBO()) {
+          if(!gl.glIsVBOArrayEnabled()) {
+            throw new GLException("VBO array is not enabled: "+array);
+          }
+      } else {
+          if(gl.glIsVBOArrayEnabled()) {
+            throw new GLException("VBO array is not disabled: "+array);
+          }
+          BufferFactory.rangeCheck(array.getBuffer(), 1);
+          if (!BufferFactory.isDirect(array.getBuffer())) {
+            throw new GLException("Argument \"pointer\" was not a direct buffer"); }
+      }
+      fixedFunction.glTexCoordPointer(gl, array);
+    }
+    public void glTexCoordPointer(int size, int type, int stride, java.nio.Buffer pointer) {
+      glTexCoordPointer(
+        GLArrayDataWrapper.createFixed(gl, GL_TEXTURE_COORD_ARRAY, size, type, false, stride, pointer, 0,0));
+    }
+    public void glTexCoordPointer(int size, int type, int stride, long pointer_buffer_offset) {
+      int vboName = gl.glGetBoundBuffer(GL.GL_ARRAY_BUFFER);
+      if(vboName==0) {
+        throw new GLException("no GL_ARRAY_BUFFER VBO bound");
+      }
+      glTexCoordPointer(
+        GLArrayDataWrapper.createFixed(gl, GL_TEXTURE_COORD_ARRAY, size, type, false, 
+                                       stride, null, vboName, pointer_buffer_offset) );
+    }
+
+    public final String toString() {
+          StringBuffer buf = new StringBuffer();
+          buf.append(getClass().getName()+" (");
+          if(null!=pmvMatrix) {
+              buf.append(", matrixDirty: "+pmvMatrix.isDirty());
+          }
+          buf.append("\n\t, FixedFunction: "+fixedFunction);
+          buf.append(gl);
+          buf.append(" )");
+
+          return buf.toString();
+    }
+
+}
+
+
diff --git a/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/FixedFuncPipeline.java b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/FixedFuncPipeline.java
new file mode 100644
index 000000000..1a60ab21e
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/FixedFuncPipeline.java
@@ -0,0 +1,554 @@
+
+package com.jogamp.opengl.util.glsl.fixedfunc.impl;
+
+import javax.media.opengl.*;
+import javax.media.opengl.fixedfunc.*;
+import com.jogamp.opengl.util.*;
+import com.jogamp.opengl.util.glsl.*;
+import com.jogamp.opengl.util.glsl.fixedfunc.*;
+import java.nio.*;
+
+public class FixedFuncPipeline {
+    public static final int MAX_TEXTURE_UNITS = 8;
+    public static final int MAX_LIGHTS        = 8;
+
+    // We can't have any dependencies on the FixedFuncUtil class for build bootstrapping reasons
+    public static final String mgl_Vertex = "mgl_Vertex";
+    public static final String mgl_Normal = "mgl_Normal";
+    public static final String mgl_Color = "mgl_Color";
+    public static final String mgl_MultiTexCoord = "mgl_MultiTexCoord" ;
+
+    public static String getPredefinedArrayIndexName(int glArrayIndex) {
+        switch(glArrayIndex) {
+            case GLPointerFunc.GL_VERTEX_ARRAY:
+                return mgl_Vertex;
+            case GLPointerFunc.GL_NORMAL_ARRAY:
+                return mgl_Normal;
+            case GLPointerFunc.GL_COLOR_ARRAY:
+                return mgl_Color;
+            case GLPointerFunc.GL_TEXTURE_COORD_ARRAY:
+                return mgl_MultiTexCoord;
+        }
+        return null;
+    }
+
+    public FixedFuncPipeline(GL2ES2 gl, PMVMatrix pmvMatrix) {
+        init(gl, pmvMatrix, FixedFuncPipeline.class, shaderSrcRootDef, shaderBinRootDef, 
+             vertexColorFileDef, vertexColorLightFileDef, fragmentColorFileDef, fragmentColorTextureFileDef);
+    }
+    public FixedFuncPipeline(GL2ES2 gl, PMVMatrix pmvMatrix, Class shaderRootClass, String shaderSrcRoot, String shaderBinRoot, 
+                       String vertexColorFile,
+                       String vertexColorLightFile,
+                       String fragmentColorFile,
+                       String fragmentColorTextureFile) {
+        init(gl, pmvMatrix, shaderRootClass, shaderSrcRoot, shaderBinRoot, 
+             vertexColorFile, vertexColorLightFile, fragmentColorFile, fragmentColorTextureFile);
+    }
+
+    public boolean verbose() { return verbose; }
+
+    public void setVerbose(boolean v) { verbose=v; }
+
+    public boolean isValid() {
+        return shaderState.linked();
+    }
+
+    public ShaderState getShaderState() {
+        return shaderState;
+    }
+
+    public int getActiveTextureUnit() {
+        return activeTextureUnit;
+    }
+
+    public String getArrayIndexName(int glArrayIndex) {
+      String name = getPredefinedArrayIndexName(glArrayIndex); 
+      switch(glArrayIndex) {
+          case GLPointerFunc.GL_VERTEX_ARRAY:
+          case GLPointerFunc.GL_NORMAL_ARRAY:
+          case GLPointerFunc.GL_COLOR_ARRAY:
+              break;
+          case GLPointerFunc.GL_TEXTURE_COORD_ARRAY:
+              name = name + activeTextureUnit;
+      }
+      return name;
+    }
+
+    public void destroy(GL2ES2 gl) {
+        shaderProgramColor.release(gl, true);
+        shaderProgramColorLight.release(gl, true);
+        shaderProgramColorTexture.release(gl, true);
+        shaderProgramColorTextureLight.release(gl, true);
+        shaderState.destroy(gl);
+    }
+
+    public void glEnableClientState(GL2ES2 gl, int glArrayIndex) {
+        shaderState.glUseProgram(gl, true);
+
+        shaderState.glEnableVertexAttribArray(gl, getArrayIndexName(glArrayIndex));
+        // textureCoordsEnabled |=  (1 << activeTextureUnit);
+        if ( textureCoordsEnabled.get(activeTextureUnit) != 1 ) {
+            textureCoordsEnabled.put(activeTextureUnit, 1);
+            textureCoordsEnabledDirty = true;
+        }
+    }
+
+    public void glDisableClientState(GL2ES2 gl, int glArrayIndex) {
+        shaderState.glUseProgram(gl, true);
+
+        shaderState.glDisableVertexAttribArray(gl, getArrayIndexName(glArrayIndex));
+        // textureCoordsEnabled &= ~(1 << activeTextureUnit);
+        if ( textureCoordsEnabled.get(activeTextureUnit) != 0 ) {
+            textureCoordsEnabled.put(activeTextureUnit, 0);
+            textureCoordsEnabledDirty = true;
+        }
+    }
+
+    public void glVertexPointer(GL2ES2 gl, GLArrayData data) {
+        shaderState.glUseProgram(gl, true);
+        shaderState.glVertexAttribPointer(gl, data);
+    }
+
+    public void glColorPointer(GL2ES2 gl, GLArrayData data) {
+        shaderState.glUseProgram(gl, true);
+        shaderState.glVertexAttribPointer(gl, data);
+    }
+
+    public void glColor4fv(GL2ES2 gl, FloatBuffer data ) {
+        shaderState.glUseProgram(gl, true);
+        GLUniformData ud = shaderState.getUniform(mgl_ColorStatic);
+        if(null!=ud) {
+            ud.setData(data);
+            shaderState.glUniform(gl, ud);
+        }
+    }
+
+    public void glNormalPointer(GL2ES2 gl, GLArrayData data) {
+        shaderState.glUseProgram(gl, true);
+        shaderState.glVertexAttribPointer(gl, data);
+    }
+
+    public void glTexCoordPointer(GL2ES2 gl, GLArrayData data) {
+        shaderState.glUseProgram(gl, true);
+        data.setName( getArrayIndexName(data.getIndex()) );
+        shaderState.glVertexAttribPointer(gl, data);
+    }
+
+    public void glLightfv(GL2ES2 gl, int light, int pname, java.nio.FloatBuffer params) {
+        shaderState.glUseProgram(gl, true);
+        light -=GLLightingFunc.GL_LIGHT0;
+        if(0 <= light && light < MAX_LIGHTS) {
+            GLUniformData ud = null;
+            switch(pname) {
+                case  GLLightingFunc.GL_AMBIENT:
+                    ud = shaderState.getUniform(mgl_LightSource+"["+light+"].ambient");
+                    break;
+                case  GLLightingFunc.GL_DIFFUSE:
+                    ud = shaderState.getUniform(mgl_LightSource+"["+light+"].diffuse");
+                    break;
+                case  GLLightingFunc.GL_SPECULAR:
+                    ud = shaderState.getUniform(mgl_LightSource+"["+light+"].specular");
+                    break;
+                case GLLightingFunc.GL_POSITION:
+                    ud = shaderState.getUniform(mgl_LightSource+"["+light+"].position");
+                    break;
+                case GLLightingFunc.GL_SPOT_DIRECTION:
+                    ud = shaderState.getUniform(mgl_LightSource+"["+light+"].spotDirection");
+                    break;
+                case GLLightingFunc.GL_SPOT_EXPONENT:
+                    ud = shaderState.getUniform(mgl_LightSource+"["+light+"].spotExponent");
+                    break;
+                case GLLightingFunc.GL_SPOT_CUTOFF:
+                    ud = shaderState.getUniform(mgl_LightSource+"["+light+"].spotCutoff");
+                    break;
+                case GLLightingFunc.GL_CONSTANT_ATTENUATION:
+                    ud = shaderState.getUniform(mgl_LightSource+"["+light+"].constantAttenuation");
+                    break;
+                case GLLightingFunc.GL_LINEAR_ATTENUATION:
+                    ud = shaderState.getUniform(mgl_LightSource+"["+light+"].linearAttenuation");
+                    break;
+                case GLLightingFunc.GL_QUADRATIC_ATTENUATION:
+                    ud = shaderState.getUniform(mgl_LightSource+"["+light+"].quadraticAttenuation");
+                    break;
+                default:
+                    if(verbose) {
+                        System.err.println("glLightfv pname not within [GL_AMBIENT GL_DIFFUSE GL_SPECULAR GL_POSITION GL_SPOT_DIRECTION]: "+pname);
+                    }
+                    return;
+            }
+            if(null!=ud) {
+                ud.setData(params);
+                shaderState.glUniform(gl, ud);
+            }
+        } else if(verbose) {
+            System.err.println("glLightfv light not within [0.."+MAX_LIGHTS+"]: "+light);
+        }
+    }
+
+    public void glMaterialfv(GL2ES2 gl, int face, int pname, java.nio.FloatBuffer params) {
+        shaderState.glUseProgram(gl, true);
+
+        switch (face) {
+            case GL.GL_FRONT:
+            case GL.GL_FRONT_AND_BACK:
+                break;
+            case GL.GL_BACK:
+                if(verbose) {
+                    System.err.println("glMaterialfv face GL_BACK currently not supported");
+                }
+                break;
+            default:
+        }
+
+        GLUniformData ud = null;
+        switch(pname) {
+            case  GLLightingFunc.GL_AMBIENT:
+                ud = shaderState.getUniform(mgl_FrontMaterial+".ambient");
+                break;
+            case  GLLightingFunc.GL_AMBIENT_AND_DIFFUSE:
+                glMaterialfv(gl, face, GLLightingFunc.GL_AMBIENT, params);
+                // fall through intended ..
+            case  GLLightingFunc.GL_DIFFUSE:
+                ud = shaderState.getUniform(mgl_FrontMaterial+".diffuse");
+                break;
+            case  GLLightingFunc.GL_SPECULAR:
+                ud = shaderState.getUniform(mgl_FrontMaterial+".specular");
+                break;
+            case  GLLightingFunc.GL_EMISSION:
+                ud = shaderState.getUniform(mgl_FrontMaterial+".emission");
+                break;
+            case  GLLightingFunc.GL_SHININESS:
+                ud = shaderState.getUniform(mgl_FrontMaterial+".shininess");
+                break;
+            default:
+                if(verbose) {
+                    System.err.println("glMaterialfv pname not within [GL_AMBIENT GL_DIFFUSE GL_SPECULAR GL_EMISSION GL_SHININESS]: "+pname);
+                }
+                return;
+        }
+        if(null!=ud) {
+            ud.setData(params);
+            shaderState.glUniform(gl, ud);
+        }
+    }
+
+    public void glShadeModel(GL2ES2 gl, int mode) {
+        shaderState.glUseProgram(gl, true);
+        GLUniformData ud = shaderState.getUniform(mgl_ShadeModel);
+        if(null!=ud) {
+            ud.setData(mode);
+            shaderState.glUniform(gl, ud);
+        }
+    }
+
+    public void glActiveTexture(GL2ES2 gl, int textureUnit) {
+        textureUnit -= GL.GL_TEXTURE0;
+        if(0 <= textureUnit && textureUnit<MAX_TEXTURE_UNITS) {
+            shaderState.glUseProgram(gl, true);
+            GLUniformData ud;
+            ud = shaderState.getUniform(mgl_ActiveTexture);
+            if(null!=ud) {
+                ud.setData(textureUnit);
+                shaderState.glUniform(gl, ud);
+            }
+            ud = shaderState.getUniform(mgl_ActiveTextureIdx);
+            if(null!=ud) {
+                ud.setData(textureUnit);
+                shaderState.glUniform(gl, ud);
+            }
+            activeTextureUnit = textureUnit;
+        } else {
+            throw new GLException("glActivateTexture textureUnit not within GL_TEXTURE0 + [0.."+MAX_TEXTURE_UNITS+"]: "+textureUnit);
+        }
+    }
+
+    /**
+     * @return false if digested in regard to GL2ES2 spec, 
+     *         eg this call must not be passed to an underlying ES2 implementation.
+     *         true if this call shall be passed to an underlying GL2ES2/ES2 implementation as well.
+     */
+    public boolean glEnable(GL2ES2 gl, int cap, boolean enable) {
+        switch(cap) {
+            case GL.GL_TEXTURE_2D:
+                textureEnabled=enable;
+                return true;
+            case GLLightingFunc.GL_LIGHTING:
+                lightingEnabled=enable;
+                return false;
+            case GL.GL_CULL_FACE:
+                cullFace=Math.abs(cullFace);
+                if(!enable) {
+                    cullFace*=-1;
+                }
+                return true;
+        }
+
+        int light = cap - GLLightingFunc.GL_LIGHT0;
+        if(0 <= light && light < MAX_LIGHTS) {
+            if ( (lightsEnabled.get(light)==1) != enable ) {
+                lightsEnabled.put(light, enable?1:0);
+                lightsEnabledDirty = true;
+                return false;
+            }
+        }
+        return true; // pass it on ..
+    }
+
+    public void glCullFace(GL2ES2 gl, int faceName) {
+        switch(faceName) {
+            case GL.GL_FRONT:
+                faceName = 1; break;
+            case GL.GL_BACK:
+                faceName = 2; break;
+            case GL.GL_FRONT_AND_BACK:
+                faceName = 3; break;
+        }
+        if(0>cullFace) {
+            faceName *= -1;
+        }
+        cullFace = faceName;
+    }
+
+    public void validate(GL2ES2 gl) {
+        shaderState.glUseProgram(gl, true);
+        GLUniformData ud;
+        if(pmvMatrix.update()) {
+            ud = shaderState.getUniform(mgl_PMVMatrix);
+            if(null!=ud) {
+                // same data object ..
+                shaderState.glUniform(gl, ud);
+            } else {
+                throw new GLException("Failed to update: mgl_PMVMatrix");
+            }
+            ud = shaderState.getUniform(mgl_NormalMatrix);
+            if(null!=ud) {
+                // same data object ..
+                shaderState.glUniform(gl, ud);
+            }
+        }
+        ud = shaderState.getUniform(mgl_ColorEnabled);
+        if(null!=ud) {
+            int ca = (shaderState.isVertexAttribArrayEnabled(mgl_Color)==true)?1:0;
+            if(ca!=ud.intValue()) {
+                ud.setData(ca);
+                shaderState.glUniform(gl, ud);
+            }
+        }
+        ud = shaderState.getUniform(mgl_CullFace);
+        if(null!=ud) {
+            if(cullFace!=ud.intValue()) {
+                ud.setData(cullFace);
+                shaderState.glUniform(gl, ud);
+            }
+        }
+
+        if(lightsEnabledDirty) {
+            ud = shaderState.getUniform(mgl_LightsEnabled);
+            if(null!=ud) {
+                // same data object 
+                shaderState.glUniform(gl, ud);
+            }
+            lightsEnabledDirty=false;
+        }
+
+        if(textureCoordsEnabledDirty) {
+            ud = shaderState.getUniform(mgl_TexCoordEnabled);
+            if(null!=ud) {
+                // same data object 
+                shaderState.glUniform(gl, ud);
+            }
+            textureCoordsEnabledDirty=false;
+        }
+
+        if(textureEnabled) {
+            if(lightingEnabled) {
+                shaderState.attachShaderProgram(gl, shaderProgramColorTextureLight);
+            } else {
+                shaderState.attachShaderProgram(gl, shaderProgramColorTexture);
+            }
+        } else {
+            if(lightingEnabled) {
+                shaderState.attachShaderProgram(gl, shaderProgramColorLight);
+            } else {
+                shaderState.attachShaderProgram(gl, shaderProgramColor);
+            }
+        }
+        if(DEBUG) {
+            System.err.println("validate: "+this);
+        }
+    }
+
+    public String toString() {
+        return "FixedFuncPipeline[pmv: "+pmvMatrix+
+               ", textureEnabled: "+textureEnabled+
+               ", textureCoordsEnabled: "+textureCoordsEnabled+
+               ", lightingEnabled: "+lightingEnabled+
+               ", lightsEnabled: "+lightsEnabled+
+               "\n\t, shaderProgramColor: "+shaderProgramColor+
+               "\n\t, shaderProgramColorTexture: "+shaderProgramColorTexture+
+               "\n\t, shaderProgramColorLight: "+shaderProgramColorLight+
+               "\n\t, shaderProgramColorTextureLight: "+shaderProgramColorTextureLight+
+               "\n\t, ShaderState: "+shaderState+
+               "]";
+    }
+
+    protected void init(GL2ES2 gl, PMVMatrix pmvMatrix, Class shaderRootClass, String shaderSrcRoot, String shaderBinRoot, 
+                       String vertexColorFile,
+                       String vertexColorLightFile,
+                       String fragmentColorFile,
+                       String fragmentColorTextureFile) 
+   {
+        if(null==pmvMatrix) {
+            throw new GLException("PMVMatrix is null");
+        }
+        this.pmvMatrix=pmvMatrix;
+        this.shaderState=new ShaderState();
+        this.shaderState.setVerbose(verbose);
+        ShaderCode vertexColor, vertexColorLight, fragmentColor, fragmentColorTexture;
+
+        vertexColor = ShaderCode.create( gl, gl.GL_VERTEX_SHADER, 1, shaderRootClass,
+                                         shaderSrcRoot, shaderBinRoot, vertexColorFile);
+
+        vertexColorLight = ShaderCode.create( gl, gl.GL_VERTEX_SHADER, 1, shaderRootClass,
+                                           shaderSrcRoot, shaderBinRoot, vertexColorLightFile);
+
+        fragmentColor = ShaderCode.create( gl, gl.GL_FRAGMENT_SHADER, 1, shaderRootClass,
+                                           shaderSrcRoot, shaderBinRoot, fragmentColorFile);
+
+        fragmentColorTexture = ShaderCode.create( gl, gl.GL_FRAGMENT_SHADER, 1, shaderRootClass,
+                                                  shaderSrcRoot, shaderBinRoot, fragmentColorTextureFile);
+
+        shaderProgramColor = new ShaderProgram();
+        shaderProgramColor.add(vertexColor);
+        shaderProgramColor.add(fragmentColor);
+        if(!shaderProgramColor.link(gl, System.err)) {
+            throw new GLException("Couldn't link VertexColor program: "+shaderProgramColor);
+        }
+
+        shaderProgramColorTexture = new ShaderProgram();
+        shaderProgramColorTexture.add(vertexColor);
+        shaderProgramColorTexture.add(fragmentColorTexture);
+        if(!shaderProgramColorTexture.link(gl, System.err)) {
+            throw new GLException("Couldn't link VertexColorTexture program: "+shaderProgramColorTexture);
+        }
+
+        shaderProgramColorLight = new ShaderProgram();
+        shaderProgramColorLight.add(vertexColorLight);
+        shaderProgramColorLight.add(fragmentColor);
+        if(!shaderProgramColorLight.link(gl, System.err)) {
+            throw new GLException("Couldn't link VertexColorLight program: "+shaderProgramColorLight);
+        }
+
+        shaderProgramColorTextureLight = new ShaderProgram();
+        shaderProgramColorTextureLight.add(vertexColorLight);
+        shaderProgramColorTextureLight.add(fragmentColorTexture);
+        if(!shaderProgramColorTextureLight.link(gl, System.err)) {
+            throw new GLException("Couldn't link VertexColorLight program: "+shaderProgramColorTextureLight);
+        }
+
+        shaderState.attachShaderProgram(gl, shaderProgramColor);
+        shaderState.glUseProgram(gl, true);
+
+        // mandatory ..
+        if(!shaderState.glUniform(gl, new GLUniformData(mgl_PMVMatrix, 4, 4, pmvMatrix.glGetPMvMviMatrixf()))) {
+            throw new GLException("Error setting PMVMatrix in shader: "+this);
+        }
+
+        // optional parameter ..
+        shaderState.glUniform(gl, new GLUniformData(mgl_NormalMatrix, 3, 3, pmvMatrix.glGetNormalMatrixf()));
+
+        shaderState.glUniform(gl, new GLUniformData(mgl_ColorEnabled,  0));
+        shaderState.glUniform(gl, new GLUniformData(mgl_ColorStatic, 4, zero4f));
+        shaderState.glUniform(gl, new GLUniformData(mgl_TexCoordEnabled,  1, textureCoordsEnabled));
+        shaderState.glUniform(gl, new GLUniformData(mgl_ActiveTexture, activeTextureUnit));
+        shaderState.glUniform(gl, new GLUniformData(mgl_ActiveTextureIdx, activeTextureUnit));
+        shaderState.glUniform(gl, new GLUniformData(mgl_ShadeModel, 0));
+        shaderState.glUniform(gl, new GLUniformData(mgl_CullFace, cullFace));
+        for(int i=0; i<MAX_LIGHTS; i++) {
+            shaderState.glUniform(gl, new GLUniformData(mgl_LightSource+"["+i+"].ambient", 4, defAmbient));
+            shaderState.glUniform(gl, new GLUniformData(mgl_LightSource+"["+i+"].diffuse", 4, defDiffuse));
+            shaderState.glUniform(gl, new GLUniformData(mgl_LightSource+"["+i+"].specular", 4, defSpecular));
+            shaderState.glUniform(gl, new GLUniformData(mgl_LightSource+"["+i+"].position", 4, defPosition));
+            shaderState.glUniform(gl, new GLUniformData(mgl_LightSource+"["+i+"].spotDirection", 3, defSpotDir));
+            shaderState.glUniform(gl, new GLUniformData(mgl_LightSource+"["+i+"].spotExponent", defSpotExponent));
+            shaderState.glUniform(gl, new GLUniformData(mgl_LightSource+"["+i+"].spotCutoff", defSpotCutoff));
+            shaderState.glUniform(gl, new GLUniformData(mgl_LightSource+"["+i+"].constantAttenuation", defConstantAtten));
+            shaderState.glUniform(gl, new GLUniformData(mgl_LightSource+"["+i+"].linearAttenuation", defLinearAtten));
+            shaderState.glUniform(gl, new GLUniformData(mgl_LightSource+"["+i+"].quadraticAttenuation", defQuadraticAtten));
+        }
+        shaderState.glUniform(gl, new GLUniformData(mgl_LightsEnabled,  1, lightsEnabled));
+        shaderState.glUniform(gl, new GLUniformData(mgl_FrontMaterial+".ambient", 4, defMatAmbient));
+        shaderState.glUniform(gl, new GLUniformData(mgl_FrontMaterial+".diffuse", 4, defMatDiffuse));
+        shaderState.glUniform(gl, new GLUniformData(mgl_FrontMaterial+".specular", 4, defMatSpecular));
+        shaderState.glUniform(gl, new GLUniformData(mgl_FrontMaterial+".emission", 4, defMatEmission));
+        shaderState.glUniform(gl, new GLUniformData(mgl_FrontMaterial+".shininess", defMatShininess));
+
+        shaderState.glUseProgram(gl, false);
+    }
+
+    protected static final boolean DEBUG=false;
+    protected boolean verbose=false;
+
+    protected boolean textureEnabled=false;
+    protected IntBuffer textureCoordsEnabled = BufferUtil.newIntBuffer(new int[] { 0, 0, 0, 0, 0, 0, 0, 0 });
+    protected boolean textureCoordsEnabledDirty = false;
+    protected int     activeTextureUnit=0;
+
+    protected int cullFace=-2; // <=0 disabled, 1: front, 2: back (default, but disabled), 3: front & back
+
+    protected boolean lightingEnabled=false;
+    protected IntBuffer lightsEnabled = BufferUtil.newIntBuffer(new int[] { 0, 0, 0, 0, 0, 0, 0, 0 });
+    protected boolean   lightsEnabledDirty = false;
+
+    protected PMVMatrix pmvMatrix;
+    protected ShaderState shaderState;
+    protected ShaderProgram shaderProgramColor;
+    protected ShaderProgram shaderProgramColorTexture;
+    protected ShaderProgram shaderProgramColorLight;
+    protected ShaderProgram shaderProgramColorTextureLight;
+
+    // uniforms ..
+    protected static final String mgl_PMVMatrix        = "mgl_PMVMatrix";       // m4fv[3]
+    protected static final String mgl_NormalMatrix     = "mgl_NormalMatrix";    // m4fv
+    protected static final String mgl_ColorEnabled     = "mgl_ColorEnabled";    //  1i
+    protected static final String mgl_ColorStatic      = "mgl_ColorStatic";     //  4fv
+
+    protected static final String mgl_LightSource      = "mgl_LightSource";     //  struct mgl_LightSourceParameters[MAX_LIGHTS]
+    protected static final String mgl_FrontMaterial    = "mgl_FrontMaterial";   //  struct mgl_MaterialParameters
+    protected static final String mgl_LightsEnabled    = "mgl_LightsEnabled";   //  int mgl_LightsEnabled[MAX_LIGHTS];
+
+    protected static final String mgl_ShadeModel       = "mgl_ShadeModel";      //  1i
+
+    protected static final String mgl_TexCoordEnabled  = "mgl_TexCoordEnabled"; //  int mgl_TexCoordEnabled[MAX_TEXTURE_UNITS];
+    protected static final String mgl_ActiveTexture    = "mgl_ActiveTexture";   //  1i
+    protected static final String mgl_ActiveTextureIdx = "mgl_ActiveTextureIdx";//  1i
+
+    protected static final String mgl_CullFace         = "mgl_CullFace";   //  1i
+
+    protected static final FloatBuffer zero4f     = BufferUtil.newFloatBuffer(new float[] { 0.0f, 0.0f, 0.0f, 0.0f });
+
+    public static final FloatBuffer defAmbient = BufferUtil.newFloatBuffer(new float[] { 0f, 0f, 0f, 1f });
+    public static final FloatBuffer defDiffuse = zero4f;
+    public static final FloatBuffer defSpecular= zero4f;
+    public static final FloatBuffer defPosition= BufferUtil.newFloatBuffer(new float[] { 0f, 0f, 1f, 0f });
+    public static final FloatBuffer defSpotDir = BufferUtil.newFloatBuffer(new float[] { 0f, 0f, -1f });
+    public static final float defSpotExponent  = 0f;
+    public static final float defSpotCutoff    = 180f;
+    public static final float defConstantAtten = 1f;
+    public static final float defLinearAtten   = 0f;
+    public static final float defQuadraticAtten= 0f;
+
+    public static final FloatBuffer defMatAmbient = BufferUtil.newFloatBuffer(new float[] { 0.2f, 0.2f, 0.2f, 1.0f });
+    public static final FloatBuffer defMatDiffuse = BufferUtil.newFloatBuffer(new float[] { 0.8f, 0.8f, 0.8f, 1.0f });
+    public static final FloatBuffer defMatSpecular= BufferUtil.newFloatBuffer(new float[] { 0f, 0f, 0f, 1f});
+    public static final FloatBuffer defMatEmission= BufferUtil.newFloatBuffer(new float[] { 0f, 0f, 0f, 1f});
+    public static final float       defMatShininess = 0f;
+
+    protected static final String vertexColorFileDef          = "FixedFuncColor";
+    protected static final String vertexColorLightFileDef    = "FixedFuncColorLight";
+    protected static final String fragmentColorFileDef        = "FixedFuncColor";
+    protected static final String fragmentColorTextureFileDef = "FixedFuncColorTexture";
+    protected static final String shaderSrcRootDef = "shaders" ;
+    protected static final String shaderBinRootDef = "shaders/bin" ;
+}
+
diff --git a/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/FixedFuncColor.fp b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/FixedFuncColor.fp
new file mode 100644
index 000000000..408ff7251
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/FixedFuncColor.fp
@@ -0,0 +1,16 @@
+#include es_precision.glsl
+
+#include mgl_uniform.glsl
+#include mgl_varying.glsl
+
+void main (void)
+{
+  if( mgl_CullFace > 0 && 
+      ( ( mgl_CullFace == 1 && gl_FrontFacing ) ||
+        ( mgl_CullFace == 2 && !gl_FrontFacing ) ||
+        ( mgl_CullFace == 3 ) ) ) {
+    discard;
+  }
+  gl_FragColor = frontColor;
+}
+
diff --git a/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/FixedFuncColor.vp b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/FixedFuncColor.vp
new file mode 100644
index 000000000..346e40196
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/FixedFuncColor.vp
@@ -0,0 +1,22 @@
+#include es_precision.glsl
+
+#include mgl_const.glsl
+#include mgl_uniform.glsl
+#include mgl_attribute.glsl
+#include mgl_varying.glsl
+
+#include mgl_settexcoord.vp
+
+void main(void)
+{
+  if(mgl_ColorEnabled>0) {
+    frontColor=mgl_Color;
+  } else {
+    frontColor=mgl_ColorStatic;
+  }
+
+  gl_Position = mgl_PMVMatrix[0] * mgl_PMVMatrix[1] * mgl_Vertex;
+
+  setTexCoord(gl_Position);
+}
+
diff --git a/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/FixedFuncColorLight.vp b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/FixedFuncColorLight.vp
new file mode 100644
index 000000000..ce203cfb9
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/FixedFuncColorLight.vp
@@ -0,0 +1,70 @@
+#include es_precision.glsl
+#include mgl_lightdef.glsl
+
+#include mgl_const.glsl
+#include mgl_uniform.glsl
+#include mgl_uniform_light.glsl
+#include mgl_attribute.glsl
+#include mgl_varying.glsl
+
+#include mgl_settexcoord.vp
+
+void main(void)
+{
+  vec4 position;
+  vec3 normal, lightDir, cameraDir, halfDir;
+  vec4 ambient, diffuse, specular;
+  float NdotL, NdotHV, dist, attenuation;
+  int i;
+
+  position  = mgl_PMVMatrix[1] * mgl_Vertex; // vertex eye position 
+
+  normal = normalize(mgl_NormalMatrix * mgl_Normal); 
+  // cameraPosition:      (mgl_PMVMatrix[2] * vec4(0,0,0,1.0)).xyz                   
+  cameraDir  = normalize( (mgl_PMVMatrix[2] * vec4(0,0,0,1.0)).xyz - mgl_Vertex.xyz ); 
+
+  ambient = vec4(0,0,0,0);
+  diffuse = vec4(0,0,0,0);
+  specular = vec4(0,0,0,0);
+
+  bool lightEnabled = false;
+
+  for(i=0; i<MAX_LIGHTS; i++) {
+    if( 0!= mgl_LightsEnabled[i] ) {
+      lightEnabled = true;
+      ambient += mgl_LightSource[i].ambient;
+      lightDir = mgl_LightSource[i].position.xyz - position.xyz;
+      dist     = length(lightDir);
+      lightDir = normalize(lightDir);
+      attenuation = 1.0 / ( 
+                       mgl_LightSource[i].constantAttenuation+ 
+                       mgl_LightSource[i].linearAttenuation    * dist +   
+                       mgl_LightSource[i].quadraticAttenuation * dist * dist );
+      NdotL = max(0.0, dot(normal, lightDir));
+      diffuse += mgl_LightSource[i].diffuse * NdotL * attenuation;
+      if (NdotL != 0.0) {
+        halfDir  = normalize (lightDir + cameraDir); 
+        NdotHV   = max(0.0, dot(normal, halfDir));
+        specular += mgl_LightSource[i].specular * 
+                    pow(NdotHV,mgl_FrontMaterial.shininess) * attenuation;
+      }
+    }
+  }
+  ambient  += mgl_FrontMaterial.ambient;
+  diffuse  *= mgl_FrontMaterial.diffuse;
+  specular *= mgl_FrontMaterial.specular;
+
+  if(mgl_ColorEnabled>0) {
+    frontColor=mgl_Color;
+  } else {
+    frontColor=mgl_ColorStatic;
+  }
+  if( lightEnabled ) {
+    frontColor *= ambient + diffuse + specular;
+  }
+
+  gl_Position  = mgl_PMVMatrix[0] * position;
+
+  setTexCoord(gl_Position);
+}
+
diff --git a/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/FixedFuncColorTexture.fp b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/FixedFuncColorTexture.fp
new file mode 100644
index 000000000..86e6ace73
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/FixedFuncColorTexture.fp
@@ -0,0 +1,47 @@
+
+#include es_precision.glsl
+#include mgl_lightdef.glsl
+
+#include mgl_const.glsl
+#include mgl_uniform.glsl
+#include mgl_varying.glsl
+
+vec4 getTexColor(in sampler2D tex, in int idx) {
+    vec4 coord;
+    if(idx==0) {
+        coord= mgl_TexCoords[0];
+    } else if(idx==1) {
+        coord= mgl_TexCoords[1];
+    } else if(idx==2) {
+        coord= mgl_TexCoords[2];
+    } else if(idx==3) {
+        coord= mgl_TexCoords[3];
+    } else if(idx==4) {
+        coord= mgl_TexCoords[4];
+    } else if(idx==5) {
+        coord= mgl_TexCoords[5];
+    } else if(idx==6) {
+        coord= mgl_TexCoords[6];
+    } else {
+        coord= mgl_TexCoords[7];
+    }
+    return texture2D(tex, coord.st);
+}
+
+void main (void)
+{
+  if( mgl_CullFace > 0 && 
+      ( ( mgl_CullFace == 1 && gl_FrontFacing ) ||
+        ( mgl_CullFace == 2 && !gl_FrontFacing ) ||
+        ( mgl_CullFace == 3 ) ) ) {
+    discard;
+  }
+
+  vec4 texColor = getTexColor(mgl_ActiveTexture,mgl_ActiveTextureIdx);
+
+  if(length(texColor.rgb)>0.0) {
+    gl_FragColor = vec4(frontColor.rgb*texColor.rgb, frontColor.a) ;
+  } else {
+    gl_FragColor = frontColor;
+  }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/bin/nvidia/FixedFuncColor.bfp b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/bin/nvidia/FixedFuncColor.bfp
new file mode 100755
index 000000000..3ebaaee1d
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/bin/nvidia/FixedFuncColor.bfp
diff --git a/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/bin/nvidia/FixedFuncColor.bvp b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/bin/nvidia/FixedFuncColor.bvp
new file mode 100755
index 000000000..279ef72c7
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/bin/nvidia/FixedFuncColor.bvp
diff --git a/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/bin/nvidia/FixedFuncColorLight.bvp b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/bin/nvidia/FixedFuncColorLight.bvp
new file mode 100755
index 000000000..5a9deea71
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/bin/nvidia/FixedFuncColorLight.bvp
diff --git a/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/bin/nvidia/FixedFuncColorTexture.bfp b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/bin/nvidia/FixedFuncColorTexture.bfp
new file mode 100755
index 000000000..ce1397fe1
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/bin/nvidia/FixedFuncColorTexture.bfp
diff --git a/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/es_precision.glsl b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/es_precision.glsl
new file mode 100644
index 000000000..fd6abe54e
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/es_precision.glsl
@@ -0,0 +1,14 @@
+#ifndef es_precision_glsl
+#define es_precision_glsl
+
+#ifdef GL_ES
+  #define MEDIUMP mediump
+  #define HIGHP highp
+  #define LOWP  lowp
+#else
+  #define MEDIUMP
+  #define HIGHP
+  #define LOWP
+#endif
+
+#endif // es_precision_glsl
diff --git a/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/mgl_attribute.glsl b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/mgl_attribute.glsl
new file mode 100644
index 000000000..b09bdb05a
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/mgl_attribute.glsl
@@ -0,0 +1,19 @@
+
+#ifndef mgl_attribute_glsl
+#define mgl_attribute_glsl
+
+#include es_precision.glsl
+
+attribute HIGHP vec4    mgl_Vertex;
+attribute HIGHP vec3    mgl_Normal;
+attribute HIGHP vec4    mgl_Color;
+attribute HIGHP vec4    mgl_MultiTexCoord0;
+attribute HIGHP vec4    mgl_MultiTexCoord1;
+attribute HIGHP vec4    mgl_MultiTexCoord2;
+attribute HIGHP vec4    mgl_MultiTexCoord3;
+attribute HIGHP vec4    mgl_MultiTexCoord4;
+attribute HIGHP vec4    mgl_MultiTexCoord5;
+attribute HIGHP vec4    mgl_MultiTexCoord6;
+attribute HIGHP vec4    mgl_MultiTexCoord7;
+
+#endif // mgl_attribute_glsl
diff --git a/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/mgl_const.glsl b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/mgl_const.glsl
new file mode 100644
index 000000000..1a464a1cb
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/mgl_const.glsl
@@ -0,0 +1,10 @@
+
+#ifndef mgl_const_glsl
+#define mgl_const_glsl
+
+#include es_precision.glsl
+
+const   LOWP int     MAX_TEXTURE_UNITS = 8; // <=gl_MaxTextureImageUnits 
+const   LOWP int     MAX_LIGHTS = 8; 
+
+#endif // mgl_const_glsl
diff --git a/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/mgl_lightdef.glsl b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/mgl_lightdef.glsl
new file mode 100644
index 000000000..98e214139
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/mgl_lightdef.glsl
@@ -0,0 +1,26 @@
+#ifndef mgl_lightdef_glsl
+#define mgl_lightdef_glsl
+
+struct mgl_LightSourceParameters {
+   vec4 ambient; 
+   vec4 diffuse; 
+   vec4 specular; 
+   vec4 position; 
+   // vec4 halfVector; // is computed here
+   vec3 spotDirection; 
+   float spotExponent; 
+   float spotCutoff; // (range: [0.0,90.0], 180.0)
+   //float spotCosCutoff; // (range: [1.0,0.0],-1.0)
+   float constantAttenuation; 
+   float linearAttenuation; 
+   float quadraticAttenuation; 
+};
+struct mgl_MaterialParameters {
+   vec4 ambient;    
+   vec4 diffuse;    
+   vec4 specular;   
+   vec4 emission;   
+   float shininess; 
+};
+
+#endif // mgl_lightdef_glsl
diff --git a/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/mgl_settexcoord.vp b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/mgl_settexcoord.vp
new file mode 100644
index 000000000..1efe328d0
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/mgl_settexcoord.vp
@@ -0,0 +1,35 @@
+#ifndef mgl_settexcoord_vp
+#define mgl_settexcoord_vp
+
+#include es_precision.glsl
+
+#include mgl_const.glsl
+#include mgl_uniform.glsl
+#include mgl_attribute.glsl
+#include mgl_varying.glsl
+
+void setTexCoord(in vec4 defpos) {
+  /**
+   * bitwise operator not supported on APX 2500 ES 2.0
+   *
+  mgl_TexCoords[0] = ( 0 != (mgl_TexCoordEnabled &   1) ) ? mgl_MultiTexCoord0 : defpos;
+  mgl_TexCoords[1] = ( 0 != (mgl_TexCoordEnabled &   2) ) ? mgl_MultiTexCoord1 : defpos;
+  mgl_TexCoords[2] = ( 0 != (mgl_TexCoordEnabled &   4) ) ? mgl_MultiTexCoord2 : defpos;
+  mgl_TexCoords[3] = ( 0 != (mgl_TexCoordEnabled &   8) ) ? mgl_MultiTexCoord3 : defpos;
+  mgl_TexCoords[4] = ( 0 != (mgl_TexCoordEnabled &  16) ) ? mgl_MultiTexCoord4 : defpos;
+  mgl_TexCoords[5] = ( 0 != (mgl_TexCoordEnabled &  32) ) ? mgl_MultiTexCoord5 : defpos;
+  mgl_TexCoords[6] = ( 0 != (mgl_TexCoordEnabled &  64) ) ? mgl_MultiTexCoord6 : defpos;
+  mgl_TexCoords[7] = ( 0 != (mgl_TexCoordEnabled & 128) ) ? mgl_MultiTexCoord7 : defpos;
+   */
+  
+  mgl_TexCoords[0] = ( 0 != mgl_TexCoordEnabled[0] ) ? mgl_MultiTexCoord0 : defpos;
+  mgl_TexCoords[1] = ( 0 != mgl_TexCoordEnabled[1] ) ? mgl_MultiTexCoord1 : defpos;
+  mgl_TexCoords[2] = ( 0 != mgl_TexCoordEnabled[2] ) ? mgl_MultiTexCoord2 : defpos;
+  mgl_TexCoords[3] = ( 0 != mgl_TexCoordEnabled[3] ) ? mgl_MultiTexCoord3 : defpos;
+  mgl_TexCoords[4] = ( 0 != mgl_TexCoordEnabled[4] ) ? mgl_MultiTexCoord4 : defpos;
+  mgl_TexCoords[5] = ( 0 != mgl_TexCoordEnabled[5] ) ? mgl_MultiTexCoord5 : defpos;
+  mgl_TexCoords[6] = ( 0 != mgl_TexCoordEnabled[6] ) ? mgl_MultiTexCoord6 : defpos;
+  mgl_TexCoords[7] = ( 0 != mgl_TexCoordEnabled[7] ) ? mgl_MultiTexCoord7 : defpos;
+}
+
+#endif // mgl_settexcoord_vp
diff --git a/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/mgl_uniform.glsl b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/mgl_uniform.glsl
new file mode 100644
index 000000000..d8b3c7f95
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/mgl_uniform.glsl
@@ -0,0 +1,18 @@
+
+#ifndef mgl_uniform_glsl
+#define mgl_uniform_glsl
+
+#include es_precision.glsl
+
+#include mgl_const.glsl
+
+uniform   HIGHP mat4    mgl_PMVMatrix[3]; // P, Mv, and Mvi
+uniform   HIGHP mat3    mgl_NormalMatrix; // transpose(inverse(ModelView)).3x3
+uniform LOWP    int     mgl_ColorEnabled;
+uniform HIGHP   vec4    mgl_ColorStatic;
+uniform LOWP    int     mgl_TexCoordEnabled[MAX_TEXTURE_UNITS];
+uniform       sampler2D mgl_ActiveTexture;
+uniform LOWP    int     mgl_ActiveTextureIdx;
+uniform LOWP    int     mgl_CullFace;
+
+#endif // mgl_uniform_glsl
diff --git a/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/mgl_uniform_light.glsl b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/mgl_uniform_light.glsl
new file mode 100644
index 000000000..0dedb5d5d
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/mgl_uniform_light.glsl
@@ -0,0 +1,15 @@
+
+#ifndef mgl_uniform_light_glsl
+#define mgl_uniform_light_glsl
+
+#include es_precision.glsl
+
+#include mgl_const.glsl
+#include mgl_lightdef.glsl
+
+uniform LOWP    int     mgl_LightsEnabled[MAX_LIGHTS];
+
+uniform mgl_LightSourceParameters mgl_LightSource[MAX_LIGHTS];
+uniform mgl_MaterialParameters    mgl_FrontMaterial;
+
+#endif // mgl_uniform_light_glsl
diff --git a/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/mgl_varying.glsl b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/mgl_varying.glsl
new file mode 100644
index 000000000..fc9f735d1
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/mgl_varying.glsl
@@ -0,0 +1,12 @@
+
+#ifndef mgl_varying_glsl
+#define mgl_varying_glsl
+
+#include es_precision.glsl
+
+#include mgl_const.glsl
+
+varying   vec4    frontColor;
+varying   vec4    mgl_TexCoords[MAX_TEXTURE_UNITS];
+
+#endif // mgl_varying_glsl
diff --git a/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/scripts/nvidia-apx/glslc-ff.bat b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/scripts/nvidia-apx/glslc-ff.bat
new file mode 100755
index 000000000..8a2114e07
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/scripts/nvidia-apx/glslc-ff.bat
@@ -0,0 +1,9 @@
+REM 
+REM You have to call it from the 'shaders' directory, e.g.:
+REM   scripts\nvidia-apx\glslc-ff.bat 
+REM
+IF !"%JOGLDIR%"==""! GOTO YESPATH
+set JOGLDIR=..\lib
+:YESPATH
+   
+java -cp %JOGLDIR%\jogl.core.jar;%JOGLDIR%\jogl.gles2.jar;%JOGLDIR%\jogl.fixed.jar;%JOGLDIR%\jogl.sdk.jar com.jogamp.opengl.util.glsl.sdk.CompileShaderNVidia FixedFuncColor.fp FixedFuncColorTexture.fp FixedFuncColorLight.vp FixedFuncColor.vp
diff --git a/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/scripts/nvidia-apx/glslc.bat b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/scripts/nvidia-apx/glslc.bat
new file mode 100755
index 000000000..c7ca0a8b7
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/glsl/fixedfunc/impl/shaders/scripts/nvidia-apx/glslc.bat
@@ -0,0 +1,9 @@
+REM 
+REM You have to call it from the 'shaders' directory, e.g.:
+REM   scripts\nvidia-apx\glslc.bat <FileName>
+REM
+IF !"%JOGLDIR%"==""! GOTO YESPATH
+set JOGLDIR=..\lib
+:YESPATH
+
+java -cp %JOGLDIR%\jogl.core.jar;%JOGLDIR%\jogl.gles2.jar;%JOGLDIR%\jogl.fixed.jar;%JOGLDIR%\jogl.sdk.jar com.jogamp.opengl.util.glsl.sdk.CompileShaderNVidia %1
diff --git a/src/jogl/classes/com/jogamp/opengl/util/glsl/sdk/CompileShader.java b/src/jogl/classes/com/jogamp/opengl/util/glsl/sdk/CompileShader.java
new file mode 100755
index 000000000..9741da737
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/glsl/sdk/CompileShader.java
@@ -0,0 +1,184 @@
+package com.jogamp.opengl.util.glsl.sdk;
+
+import javax.media.opengl.*;
+import com.jogamp.opengl.util.*;
+import com.jogamp.opengl.util.glsl.*;
+
+import java.io.*;
+import java.net.*;
+
+/** Precompiles a shader into a vendor binary format. Input is the
+    resource name of the shader, such as
+    "com/jogamp/opengl/impl/glsl/fixed/shader/a.fp".
+    Output is "com/jogamp/opengl/impl/glsl/fixed/shader/bin/nvidia/a.bfp".
+
+    All path and suffixes are determined by the ShaderCode class,
+    which ensures runtime compatibility.
+
+    @see javax.media.opengl.glsl.ShaderCode
+  */
+
+public abstract class CompileShader {
+
+    public abstract int getBinaryFormat();
+
+    public abstract File getSDKCompilerDir();
+
+    public abstract String getVertexShaderCompiler();
+
+    public abstract String getFragmentShaderCompiler();
+
+    public void processOneShader(String resourceName)
+        throws IOException, UnsupportedEncodingException, InterruptedException
+    {
+        int type = -1;
+        String outName=null;
+        int suffixLen = -1;
+        if(resourceName.endsWith(ShaderCode.getFileSuffix(false, GL2ES2.GL_FRAGMENT_SHADER))) {
+            suffixLen = 2;
+            type = GL2ES2.GL_FRAGMENT_SHADER;
+        } else if(resourceName.endsWith(".frag")) {
+            suffixLen = 4;
+            type = GL2ES2.GL_FRAGMENT_SHADER;
+        } else if(resourceName.endsWith(ShaderCode.getFileSuffix(false, GL2ES2.GL_VERTEX_SHADER))) {
+            suffixLen = 2;
+            type = GL2ES2.GL_VERTEX_SHADER;
+        } else if(resourceName.endsWith(".vert")) {
+            suffixLen = 4;
+            type = GL2ES2.GL_VERTEX_SHADER;
+        }
+        String justName = basename(resourceName);
+        outName = justName.substring(0, justName.length() - suffixLen) +
+                  ShaderCode.getFileSuffix(true, type);
+        URL resourceURL = Locator.getResource(null, resourceName);
+        String dirName = dirname(resourceURL.getPath());
+
+        outName = dirName + File.separator + "bin" + File.separator + 
+                  ShaderCode.getBinarySubPath(getBinaryFormat()) + File.separator + 
+                  outName;
+        processOneShader(resourceName, outName, type);
+    }
+
+    public void processOneShader(String resourceName, String outName, int type)
+        throws IOException, UnsupportedEncodingException, InterruptedException
+    {
+        URL resourceURL = Locator.getResource(null, resourceName);
+        String dirName = dirname(resourceURL.getPath());
+
+        String shader = ShaderCode.readShaderSource(null, resourceName);
+        if(null==shader) {
+            System.err.println("Can't find shader source " + resourceName + " - ignored");
+            return;
+        }
+        System.err.println("Preprocessing: "+ resourceName+", in dir: "+dirName);
+        String justName = basename(resourceName);
+        String processor;
+        switch (type) {
+            case GL2ES2.GL_VERTEX_SHADER:
+                processor = getVertexShaderCompiler();
+                break;
+            case GL2ES2.GL_FRAGMENT_SHADER:
+                processor = getFragmentShaderCompiler();
+                break;
+            default:
+                throw new GLException("Unknown shader type: "+type);
+        }
+        File outputFile = new File(outName);
+
+        // Write shader to a file in java.io.tmpdir
+        File tmpDir = new File(dirName+File.separator+"tmp");
+        tmpDir.mkdirs();
+        File tmpFile = new File(tmpDir, justName);
+        Writer writer = new BufferedWriter(new FileWriter(tmpFile));
+        writer.write(shader, 0, shader.length());
+        writer.flush();
+        writer.close();
+        System.err.println("Preprocessed: "+ tmpFile.getAbsolutePath());
+
+        File processorDir = getSDKCompilerDir();
+
+        System.err.println("SDK: "+ processorDir.getAbsolutePath() + ", compiler: "+processor);
+
+        System.err.println("Output: "+ outputFile.getAbsolutePath());
+
+        // Run the tool
+        Process process = Runtime.getRuntime().exec(new String[] {
+                processorDir.getAbsolutePath() + File.separator + processor,
+                tmpFile.getAbsolutePath(),
+                outputFile.getAbsolutePath()
+            }); // , null, processorDir);
+        new StreamMonitor(process.getInputStream());
+        new StreamMonitor(process.getErrorStream());
+        process.waitFor();
+        // Delete the temporary file
+        // tmpFile.delete();
+    }
+
+    protected static String basename(String path) {
+        int lastSlash = path.lastIndexOf("/");
+        if (lastSlash < 0) {
+            lastSlash = path.lastIndexOf("\\");
+        }
+        String basename;
+        if (lastSlash < 0) {
+            basename = path;
+        } else {
+            basename = path.substring(lastSlash + 1);
+        }
+        return basename;
+    }
+
+    protected static String dirname(String path) {
+        int lastSlash = path.lastIndexOf("/");
+        if (lastSlash < 0) {
+            lastSlash = path.lastIndexOf("\\");
+        }
+        String dirname;
+        if (lastSlash < 0) {
+            dirname = new String();
+        } else {
+            dirname = path.substring(0, lastSlash + 1);
+        }
+        return dirname;
+    }
+
+    public void run(String[] args) {
+        try {
+            for (int i = 0; i < args.length; i++) {
+                processOneShader(args[i]);
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static class StreamMonitor implements Runnable {
+        private InputStream istream;
+        public StreamMonitor(InputStream stream) {
+            istream = stream;
+            new Thread(this, "Output Reader Thread").start();
+        }
+
+        public void run()
+        {
+            byte[] buffer = new byte[4096];
+            try {
+                int numRead = 0;
+                do {
+                    numRead = istream.read(buffer);
+                    if (numRead > 0) {
+                        System.out.write(buffer, 0, numRead);
+                        System.out.flush();
+                    }
+                } while (numRead >= 0);
+            }
+            catch (IOException e) {
+                try {
+                    istream.close();
+                } catch (IOException e2) {
+                }
+                // Should allow clean exit when process shuts down
+            }
+        }
+    }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/glsl/sdk/CompileShaderNVidia.java b/src/jogl/classes/com/jogamp/opengl/util/glsl/sdk/CompileShaderNVidia.java
new file mode 100755
index 000000000..8eb9ef579
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/glsl/sdk/CompileShaderNVidia.java
@@ -0,0 +1,53 @@
+package com.jogamp.opengl.util.glsl.sdk;
+
+import javax.media.opengl.*;
+
+import java.io.*;
+
+/** Precompiles a shader into NVidia binary format. Input is the
+    resource name of the shader, such as
+    "com/jogamp/opengl/impl/glsl/fixed/shader/a.fp".
+    Output is "com/jogamp/opengl/impl/glsl/fixed/shader/bin/nvidia/a.bfp". */
+
+public class CompileShaderNVidia extends CompileShader {
+    private static final String NVAPSDK;
+
+    static {
+        String nvapSDKProp = System.getProperty("NVAPSDK");
+        if (nvapSDKProp != null) {
+            NVAPSDK = nvapSDKProp;
+        } else {
+            NVAPSDK = "C:\\nvap_sdk_0_3_x";
+        }
+    }
+
+    public int getBinaryFormat() {
+        return GLES2.GL_NVIDIA_PLATFORM_BINARY_NV;
+    }
+
+    public File getSDKCompilerDir() {
+        File compilerDir = new File( NVAPSDK + File.separator + "tools" + File.separator );
+        File compilerFile = new File( compilerDir, getVertexShaderCompiler());
+        if(!compilerFile.exists()) {
+            compilerDir = new File( NVAPSDK );
+            compilerFile = new File( compilerDir, getVertexShaderCompiler());
+        }
+        if(!compilerFile.exists()) {
+            throw new GLException("Can't find compiler: "+getVertexShaderCompiler() + " in : " +
+                                  NVAPSDK+", "+NVAPSDK + File.separator + "tools");
+        }
+        return compilerDir;
+    }
+
+    public String getVertexShaderCompiler() {
+        return "glslv.bat";
+    }
+
+    public String getFragmentShaderCompiler() {
+        return "glslf.bat";
+    }
+
+    public static void main(String[] args) {
+        new CompileShaderNVidia().run(args);
+    }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/packrect/BackingStoreManager.java b/src/jogl/classes/com/jogamp/opengl/util/packrect/BackingStoreManager.java
new file mode 100755
index 000000000..7b6a1b479
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/packrect/BackingStoreManager.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util.packrect;
+
+/** This interface must be implemented by the end user and is called
+    in response to events like addition of rectangles into the
+    RectanglePacker. It is used both when a full re-layout must be
+    done as well as when the data in the backing store must be copied
+    to a new one. */
+
+public interface BackingStoreManager {
+  public Object allocateBackingStore(int w, int h);
+  public void   deleteBackingStore(Object backingStore);
+
+  /** Indication whether this BackingStoreManager supports compaction;
+      in other words, the allocation of a new backing store and
+      movement of the contents of the backing store from the old to
+      the new one. If it does not, then RectanglePacker.add() may
+      throw an exception if additionFailed() can not make enough room
+      available. If an implementation returns false, this also implies
+      that the backing store can not grow, so that preExpand() will
+      never be called. */
+  public boolean canCompact();
+
+  /** Notification that expansion of the backing store is about to be
+      done due to addition of the given rectangle. Gives the manager a
+      chance to do some compaction and potentially remove old entries
+      from the backing store, if it acts like a least-recently-used
+      cache. This method receives as argument the number of attempts
+      so far to add the given rectangle. Manager should return true if
+      the RectanglePacker should retry the addition (which may result
+      in this method being called again, with an increased attempt
+      number) or false if the RectanglePacker should just expand the
+      backing store. The caller should not call RectanglePacker.add()
+      in its preExpand() method. */
+  public boolean preExpand(Rect cause, int attemptNumber);
+
+  /** Notification that addition of the given Rect failed because a
+      maximum size was set in the RectanglePacker and the backing
+      store could not be expanded, or because compaction (and,
+      therefore, implicitly expansion) was not supported. Should
+      return false if the manager can do nothing more to handle the
+      failed addition, which will cause a RuntimeException to be
+      thrown from the RectanglePacker. */
+  public boolean additionFailed(Rect cause, int attemptNumber);
+
+  /** Notification that movement is starting. */
+  public void beginMovement(Object oldBackingStore, Object newBackingStore);
+
+  /** Tells the manager to move the contents of the given rect from
+      the old location on the old backing store to the new location on
+      the new backing store. The backing stores can be identical in
+      the case of compacting the existing backing store instead of
+      reallocating it. */
+  public void move(Object oldBackingStore,
+                   Rect   oldLocation,
+                   Object newBackingStore,
+                   Rect   newLocation);
+
+  /** Notification that movement is ending. */
+  public void endMovement(Object oldBackingStore, Object newBackingStore);
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/packrect/Level.java b/src/jogl/classes/com/jogamp/opengl/util/packrect/Level.java
new file mode 100755
index 000000000..5ba3f7330
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/packrect/Level.java
@@ -0,0 +1,275 @@
+/*
+ * Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util.packrect;
+
+import java.util.*;
+
+public class Level {
+  private int width;
+  private int height;
+  private int yPos;
+  private LevelSet holder;
+
+  private List/*<Rect>*/ rects = new ArrayList/*<Rect>*/();
+  private List/*<Rect>*/ freeList;
+  private int nextAddX;
+
+  static class RectXComparator implements Comparator {
+    public int compare(Object o1, Object o2) {
+      Rect r1 = (Rect) o1;
+      Rect r2 = (Rect) o2;
+      return r1.x() - r2.x();
+    }
+
+    public boolean equals(Object obj) {
+      return this == obj;
+    }
+  }
+  private static final Comparator rectXComparator = new RectXComparator();
+
+  public Level(int width, int height, int yPos, LevelSet holder) {
+    this.width = width;
+    this.height = height;
+    this.yPos = yPos;
+    this.holder = holder;
+  }
+
+  public int w()    { return width;  }
+  public int h()    { return height; }
+  public int yPos() { return yPos;   }
+
+  /** Tries to add the given rectangle to this level only allowing
+      non-disruptive changes like trivial expansion of the last level
+      in the RectanglePacker and allocation from the free list. More
+      disruptive changes like compaction of the level must be
+      requested explicitly. */
+  public boolean add(Rect rect) {
+    if (rect.h() > height) {
+      // See whether it's worth trying to expand vertically
+      if (nextAddX + rect.w() > width) {
+        return false;
+      }
+
+      // See whether we're the last level and can expand
+      if (!holder.canExpand(this, rect.h())) {
+        return false;
+      }
+
+      // Trivially expand and try the allocation
+      holder.expand(this, height, rect.h());
+      height = rect.h();
+    }
+
+    // See whether we can add at the end
+    if (nextAddX + rect.w() <= width) {
+      rect.setPosition(nextAddX, yPos);
+      rects.add(rect);
+      nextAddX += rect.w();
+      return true;
+    }
+
+    // See whether we can add from the free list
+    if (freeList != null) {
+      Rect candidate = null;
+      for (Iterator iter = freeList.iterator(); iter.hasNext(); ) {
+        Rect cur = (Rect) iter.next();
+        if (cur.canContain(rect)) {
+          candidate = cur;
+          break;
+        }
+      }
+
+      if (candidate != null) {
+        // Remove the candidate from the free list
+        freeList.remove(candidate);
+        // Set up and add the real rect
+        rect.setPosition(candidate.x(), candidate.y());
+        rects.add(rect);
+        // Re-add any remaining free space
+        if (candidate.w() > rect.w()) {
+          candidate.setPosition(candidate.x() + rect.w(), candidate.y());
+          candidate.setSize(candidate.w() - rect.w(), height);
+          freeList.add(candidate);
+        }
+        
+        coalesceFreeList();
+
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /** Removes the given Rect from this Level. */
+  public boolean remove(Rect rect) {
+    if (!rects.remove(rect))
+      return false;
+
+    // If this is the rightmost rectangle, instead of adding its space
+    // to the free list, we can just decrease the nextAddX
+    if (rect.maxX() + 1 == nextAddX) {
+      nextAddX -= rect.w();
+    } else {
+      if (freeList == null) {
+        freeList = new ArrayList/*<Rect>*/();
+      }
+      freeList.add(new Rect(rect.x(), rect.y(), rect.w(), height, null));
+      coalesceFreeList();
+    }
+
+    return true;
+  }
+
+  /** Indicates whether this Level contains no rectangles. */
+  public boolean isEmpty() {
+    return rects.isEmpty();
+  }
+
+  /** Indicates whether this Level could satisfy an allocation request
+      if it were compacted. */
+  public boolean couldAllocateIfCompacted(Rect rect) {
+    if (rect.h() > height)
+      return false;
+    if (freeList == null)
+      return false;
+    int freeListWidth = 0;
+    for (Iterator iter = freeList.iterator(); iter.hasNext(); ) {
+      Rect cur = (Rect) iter.next();
+      freeListWidth += cur.w();
+    }
+    // Add on the remaining space at the end
+    freeListWidth += (width - nextAddX);
+    return (freeListWidth >= rect.w());
+  }
+
+  public void compact(Object backingStore, BackingStoreManager manager) {
+    Collections.sort(rects, rectXComparator);
+    int nextCompactionDest = 0;
+    manager.beginMovement(backingStore, backingStore);
+    for (Iterator iter = rects.iterator(); iter.hasNext(); ) {
+      Rect cur = (Rect) iter.next();
+      if (cur.x() != nextCompactionDest) {
+        manager.move(backingStore, cur,
+                     backingStore, new Rect(nextCompactionDest, cur.y(), cur.w(), cur.h(), null));
+        cur.setPosition(nextCompactionDest, cur.y());
+      }
+      nextCompactionDest += cur.w();
+    }
+    nextAddX = nextCompactionDest;
+    freeList.clear();
+    manager.endMovement(backingStore, backingStore);
+  }
+
+  public Iterator iterator() {
+    return rects.iterator();
+  }
+
+  /** Visits all Rects contained in this Level. */
+  public void visit(RectVisitor visitor) {
+    for (Iterator iter = rects.iterator(); iter.hasNext(); ) {
+      Rect rect = (Rect) iter.next();
+      visitor.visit(rect);
+    }
+  }
+
+  /** Updates the references to the Rect objects in this Level with
+      the "next locations" of those Rects. This is actually used to
+      update the new Rects in a newly laid-out LevelSet with the
+      original Rects. */
+  public void updateRectangleReferences() {
+    for (int i = 0; i < rects.size(); i++) {
+      Rect cur = (Rect) rects.get(i);
+      Rect next = cur.getNextLocation();
+      next.setPosition(cur.x(), cur.y());
+      if (cur.w() != next.w() || cur.h() != next.h())
+        throw new RuntimeException("Unexpected disparity in rectangle sizes during updateRectangleReferences");
+      rects.set(i, next);
+    }
+  }
+
+  private void coalesceFreeList() {
+    if (freeList == null)
+      return;
+    if (freeList.isEmpty())
+      return;
+
+    // Try to coalesce adjacent free blocks in the free list
+    Collections.sort(freeList, rectXComparator);
+    int i = 0;
+    while (i < freeList.size() - 1) {
+      Rect r1 = (Rect) freeList.get(i);
+      Rect r2 = (Rect) freeList.get(i+1);
+      if (r1.maxX() + 1 == r2.x()) {
+        // Coalesce r1 and r2 into one block
+        freeList.remove(i+1);
+        r1.setSize(r1.w() + r2.w(), r1.h());
+      } else {
+        ++i;
+      }
+    }
+    // See whether the last block bumps up against the addition point
+    Rect last = (Rect) freeList.get(freeList.size() - 1);
+    if (last.maxX() + 1 == nextAddX) {
+      nextAddX -= last.w();
+      freeList.remove(freeList.size() - 1);
+    }
+    if (freeList.isEmpty()) {
+      freeList = null;
+    }
+  }
+
+  //----------------------------------------------------------------------
+  // Debugging functionality
+  //
+
+  public void dumpFreeSpace() {
+    int freeListWidth = 0;
+    for (Iterator iter = freeList.iterator(); iter.hasNext(); ) {
+      Rect cur = (Rect) iter.next();
+      System.err.println(" Free rectangle at " + cur);
+      freeListWidth += cur.w();
+    }
+    // Add on the remaining space at the end
+    System.err.println(" Remaining free space " + (width - nextAddX));
+    freeListWidth += (width - nextAddX);
+    System.err.println(" Total free space " + freeListWidth);
+  }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/packrect/LevelSet.java b/src/jogl/classes/com/jogamp/opengl/util/packrect/LevelSet.java
new file mode 100755
index 000000000..6783aec3b
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/packrect/LevelSet.java
@@ -0,0 +1,213 @@
+/*
+ * Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util.packrect;
+
+import java.util.*;
+
+/** Manages a list of Levels; this is the core data structure
+    contained within the RectanglePacker and encompasses the storage
+    algorithm for the contained Rects. */
+
+public class LevelSet {
+  // Maintained in sorted order by increasing Y coordinate
+  private List/*<Level>*/ levels = new ArrayList/*<Level>*/();
+  private int nextAddY;
+  private int w;
+  private int h;
+
+  /** A LevelSet manages all of the backing store for a region of a
+      specified width and height. */
+  public LevelSet(int w, int h) {
+    this.w = w;
+    this.h = h;
+  }
+
+  public int w() { return w; }
+  public int h() { return h; }
+
+  /** Returns true if the given rectangle was successfully added to
+      the LevelSet given its current dimensions, false if not. Caller
+      is responsible for performing compaction, expansion, etc. as a
+      consequence. */
+  public boolean add(Rect rect) {
+    if (rect.w() > w)
+      return false;
+
+    // Go in reverse order through the levels seeing whether we can
+    // trivially satisfy the allocation request
+    for (int i = levels.size() - 1; i >= 0; --i) {
+      Level level = (Level) levels.get(i);
+      if (level.add(rect))
+        return true;
+    }
+
+    // See whether compaction could satisfy this allocation. This
+    // increases the computational complexity of the addition process,
+    // but prevents us from expanding unnecessarily.
+    for (int i = levels.size() - 1; i >= 0; --i) {
+      Level level = (Level) levels.get(i);
+      if (level.couldAllocateIfCompacted(rect))
+        return false;
+    }
+
+    // OK, we need to either add a new Level or expand the backing
+    // store. Try to add a new Level.
+    if (nextAddY + rect.h() > h)
+      return false;
+
+    Level newLevel = new Level(w, rect.h(), nextAddY, this);
+    levels.add(newLevel);
+    nextAddY += rect.h();
+    boolean res = newLevel.add(rect);
+    if (!res)
+      throw new RuntimeException("Unexpected failure in addition to new Level");
+    return true;
+  }
+
+  /** Removes the given Rect from this LevelSet. */
+  public boolean remove(Rect rect) {
+    for (int i = levels.size() - 1; i >= 0; --i) {
+      Level level = (Level) levels.get(i);
+      if (level.remove(rect))
+        return true;
+    }
+    
+    return false;
+  }
+
+  /** Allocates the given Rectangle, performing compaction of a Level
+      if necessary. This is the correct fallback path to {@link
+      #add(Rect)} above. Returns true if allocated successfully, false
+      otherwise (indicating the need to expand the backing store). */
+  public boolean compactAndAdd(Rect rect,
+                               Object backingStore,
+                               BackingStoreManager manager) {
+    for (int i = levels.size() - 1; i >= 0; --i) {
+      Level level = (Level) levels.get(i);
+      if (level.couldAllocateIfCompacted(rect)) {
+        level.compact(backingStore, manager);
+        boolean res = level.add(rect);
+        if (!res)
+          throw new RuntimeException("Unexpected failure to add after compaction");
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /** Indicates whether it's legal to trivially increase the height of
+      the given Level. This is only possible if it's the last Level
+      added and there's enough room in the backing store. */
+  public boolean canExpand(Level level, int height) {
+    if (levels.isEmpty())
+      return false; // Should not happen
+    if (levels.get(levels.size() - 1) == level &&
+        (h - nextAddY >= height - level.h()))
+      return true;
+    return false;
+  }
+
+  public void expand(Level level, int oldHeight, int newHeight) {
+    nextAddY += (newHeight - oldHeight);
+  }
+
+  /** Gets the used height of the levels in this LevelSet. */
+  public int getUsedHeight() {
+    return nextAddY;
+  }
+
+  /** Sets the height of this LevelSet. It is only legal to reduce the
+      height to greater than or equal to the currently used height. */
+  public void setHeight(int height) throws IllegalArgumentException {
+    if (height < getUsedHeight()) {
+      throw new IllegalArgumentException("May not reduce height below currently used height");
+    }
+    h = height;
+  }
+
+  /** Returns the vertical fragmentation ratio of this LevelSet. This
+      is defined as the ratio of the sum of the heights of all
+      completely empty Levels divided by the overall used height of
+      the LevelSet. A high vertical fragmentation ratio indicates that
+      it may be profitable to perform a compaction. */
+  public float verticalFragmentationRatio() {
+    int freeHeight = 0;
+    int usedHeight = getUsedHeight();
+    if (usedHeight == 0)
+      return 0.0f;
+    for (Iterator iter = iterator(); iter.hasNext(); ) {
+      Level level = (Level) iter.next();
+      if (level.isEmpty()) {
+        freeHeight += level.h();
+      }
+    }
+    return (float) freeHeight / (float) usedHeight;
+  }
+
+  public Iterator iterator() {
+    return levels.iterator();
+  }
+
+  /** Visits all Rects contained in this LevelSet. */
+  public void visit(RectVisitor visitor) {
+    for (Iterator iter = levels.iterator(); iter.hasNext(); ) {
+      Level level = (Level) iter.next();
+      level.visit(visitor);
+    }
+  }
+
+  /** Updates the references to the Rect objects in this LevelSet with
+      the "next locations" of those Rects. This is actually used to
+      update the new Rects in a newly laid-out LevelSet with the
+      original Rects. */
+  public void updateRectangleReferences() {
+    for (Iterator iter = levels.iterator(); iter.hasNext(); ) {
+      Level level = (Level) iter.next();
+      level.updateRectangleReferences();
+    }
+  }
+
+  /** Clears out all Levels stored in this LevelSet. */
+  public void clear() {
+    levels.clear();
+    nextAddY = 0;
+  }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/packrect/Rect.java b/src/jogl/classes/com/jogamp/opengl/util/packrect/Rect.java
new file mode 100755
index 000000000..6206c4a11
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/packrect/Rect.java
@@ -0,0 +1,170 @@
+/*
+ * Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util.packrect;
+
+/** Represents a rectangular region on the backing store. The edges of
+    the rectangle are the infinitely thin region between adjacent
+    pixels on the screen. The origin of the rectangle is its
+    upper-left corner. It is inclusive of the pixels on the top and
+    left edges and exclusive of the pixels on the bottom and right
+    edges. For example, a rect at position (0, 0) and of size (1, 1)
+    would include only the pixel at (0, 0). <P>
+
+    Negative coordinates and sizes are not supported, since they make
+    no sense in the context of the packer, which deals only with
+    positively sized regions. <P>
+
+    This class contains a user data field for efficient hookup to
+    external data structures as well as enough other hooks to
+    efficiently plug into the rectangle packer. */
+
+public class Rect {
+  private int x;
+  private int y;
+  private int w;
+  private int h;
+
+  // The level we're currently installed in in the parent
+  // RectanglePacker, or null if not hooked in to the table yet
+  private Level level;
+
+  // The user's object this rectangle represents.
+  private Object userData;
+
+  // Used transiently during re-layout of the backing store (when
+  // there is no room left due either to fragmentation or just being
+  // out of space)
+  private Rect nextLocation;
+  
+  public Rect() {
+    this(null);
+  }
+
+  public Rect(Object userData) {
+    this(0, 0, 0, 0, userData);
+  }
+
+  public Rect(int x, int y, int w, int h, Object userData) {
+    setPosition(x, y);
+    setSize(w, h);
+    setUserData(userData);
+  }
+
+  public int x() { return x; }
+  public int y() { return y; }
+  public int w() { return w; }
+  public int h() { return h; }
+  public Object getUserData() { return userData; }
+  public Rect getNextLocation() { return nextLocation; }
+
+  public void setPosition(int x, int y) {
+    if (x < 0)
+      throw new IllegalArgumentException("Negative x");
+    if (y < 0)
+      throw new IllegalArgumentException("Negative y");
+    this.x = x;
+    this.y = y;
+  }
+
+  public void setSize(int w, int h) throws IllegalArgumentException {
+    if (w < 0)
+      throw new IllegalArgumentException("Negative width");
+    if (h < 0)
+      throw new IllegalArgumentException("Negative height");
+    this.w = w;
+    this.h = h;
+  }
+
+  public void setUserData(Object obj) { userData = obj; }
+  public void setNextLocation(Rect nextLocation) { this.nextLocation = nextLocation; }
+
+  // Helpers for computations.
+
+  /** Returns the maximum x-coordinate contained within this
+      rectangle. Note that this returns a different result than Java
+      2D's rectangles; for a rectangle of position (0, 0) and size (1,
+      1) this will return 0, not 1. Returns -1 if the width of this
+      rectangle is 0. */
+  public int maxX() {
+    if (w() < 1)
+      return -1;
+    return x() + w() - 1;
+  }
+
+  /** Returns the maximum y-coordinate contained within this
+      rectangle. Note that this returns a different result than Java
+      2D's rectangles; for a rectangle of position (0, 0) and size (1,
+      1) this will return 0, not 1. Returns -1 if the height of this
+      rectangle is 0. */
+  public int maxY() {
+    if (h() < 1)
+      return -1;
+    return y() + h() - 1;
+  }
+
+  public boolean canContain(Rect other) {
+    return (w() >= other.w() &&
+            h() >= other.h());
+  }
+
+  public String toString() {
+    return "[Rect x: " + x() + " y: " + y() + " w: " + w() + " h: " + h() + "]";
+  }
+
+  // Unclear whether it's a good idea to override hashCode and equals
+  // for these objects
+  /*
+  public boolean equals(Object other) {
+    if (other == null || (!(other instanceof Rect))) {
+      return false;
+    }
+
+    Rect r = (Rect) other;
+    return (this.x() == r.x() &&
+            this.y() == r.y() &&
+            this.w() == r.w() &&
+            this.h() == r.h());
+  }
+
+  public int hashCode() {
+    return (x + y * 13 + w * 17 + h * 23);
+  }
+  */
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/packrect/RectVisitor.java b/src/jogl/classes/com/jogamp/opengl/util/packrect/RectVisitor.java
new file mode 100755
index 000000000..49cfc82e6
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/packrect/RectVisitor.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util.packrect;
+
+/** Iteration construct without exposing the internals of the
+    RectanglePacker and without implementing a complex Iterator. */
+
+public interface RectVisitor {
+  public void visit(Rect rect);
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/packrect/RectanglePacker.java b/src/jogl/classes/com/jogamp/opengl/util/packrect/RectanglePacker.java
new file mode 100755
index 000000000..1496a04a6
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/packrect/RectanglePacker.java
@@ -0,0 +1,306 @@
+/*
+ * Copyright (c) 2006 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util.packrect;
+
+import java.util.*;
+
+/** Packs rectangles supplied by the user (typically representing
+    image regions) into a larger backing store rectangle (typically
+    representing a large texture). Supports automatic compaction of
+    the space on the backing store, and automatic expansion of the
+    backing store, when necessary. */
+
+public class RectanglePacker {
+  private BackingStoreManager manager;
+  private Object backingStore;
+  private LevelSet levels;
+  private float EXPANSION_FACTOR = 0.5f;
+  private float SHRINK_FACTOR = 0.3f;
+
+  private int initialWidth;
+  private int initialHeight;
+
+  private int maxWidth  = -1;
+  private int maxHeight = -1;
+
+  static class RectHComparator implements Comparator {
+    public int compare(Object o1, Object o2) {
+      Rect r1 = (Rect) o1;
+      Rect r2 = (Rect) o2;
+      return r2.h() - r1.h();
+    }
+
+    public boolean equals(Object obj) {
+      return this == obj;
+    }
+  }
+  private static final Comparator rectHComparator = new RectHComparator();
+
+  public RectanglePacker(BackingStoreManager manager,
+                         int initialWidth,
+                         int initialHeight) {
+    this.manager = manager;
+    levels = new LevelSet(initialWidth, initialHeight);
+    this.initialWidth = initialWidth;
+    this.initialHeight = initialHeight;
+  }
+
+  public Object getBackingStore() {
+    if (backingStore == null) {
+      backingStore = manager.allocateBackingStore(levels.w(), levels.h());
+    }
+
+    return backingStore;
+  }
+
+  /** Sets up a maximum width and height for the backing store. These
+      are optional and if not specified the backing store will grow as
+      necessary. Setting up a maximum width and height introduces the
+      possibility that additions will fail; these are handled with the
+      BackingStoreManager's allocationFailed notification. */
+  public void setMaxSize(int maxWidth, int maxHeight) {
+    this.maxWidth  = maxWidth;
+    this.maxHeight = maxHeight;
+  }
+
+  /** Decides upon an (x, y) position for the given rectangle (leaving
+      its width and height unchanged) and places it on the backing
+      store. May provoke re-layout of other Rects already added. If
+      the BackingStoreManager does not support compaction, and {@link
+      BackingStoreManager#preExpand BackingStoreManager.preExpand}
+      does not clear enough space for the incoming rectangle, then
+      this method will throw a RuntimeException. */
+  public void add(Rect rect) throws RuntimeException {
+    // Allocate backing store if we don't have any yet
+    if (backingStore == null)
+      backingStore = manager.allocateBackingStore(levels.w(), levels.h());
+
+    int attemptNumber = 0;
+    boolean tryAgain = false;
+
+    do {
+      // Try to allocate
+      if (levels.add(rect))
+        return;
+
+      if (manager.canCompact()) {
+        // Try to allocate with horizontal compaction
+        if (levels.compactAndAdd(rect, backingStore, manager))
+          return;
+        // Let the manager have a chance at potentially evicting some entries
+        tryAgain = manager.preExpand(rect, attemptNumber++);
+      } else {
+        tryAgain = manager.additionFailed(rect, attemptNumber++);
+      }
+    } while (tryAgain);
+
+    if (!manager.canCompact()) {
+      throw new RuntimeException("BackingStoreManager does not support compaction or expansion, and didn't clear space for new rectangle");
+    }
+
+    compactImpl(rect);
+
+    // Retry the addition of the incoming rectangle
+    add(rect);
+    // Done
+  }
+
+  /** Removes the given rectangle from this RectanglePacker. */
+  public void remove(Rect rect) {
+    levels.remove(rect);
+  }
+
+  /** Visits all Rects contained in this RectanglePacker. */
+  public void visit(RectVisitor visitor) {
+    levels.visit(visitor);
+  }
+
+  /** Returns the vertical fragmentation ratio of this
+      RectanglePacker. This is defined as the ratio of the sum of the
+      heights of all completely empty Levels divided by the overall
+      used height of the LevelSet. A high vertical fragmentation ratio
+      indicates that it may be profitable to perform a compaction. */
+  public float verticalFragmentationRatio() {
+    return levels.verticalFragmentationRatio();
+  }
+
+  /** Forces a compaction cycle, which typically results in allocating
+      a new backing store and copying all entries to it. */
+  public void compact() {
+    compactImpl(null);
+  }
+
+  // The "cause" rect may be null
+  private void compactImpl(Rect cause) {
+    // Have to either expand, compact or both. Need to figure out what
+    // direction to go. Prefer to expand vertically. Expand
+    // horizontally only if rectangle being added is too wide. FIXME:
+    // may want to consider rebalancing the width and height to be
+    // more equal if it turns out we keep expanding in the vertical
+    // direction.
+    boolean done = false;
+    int newWidth = levels.w();
+    int newHeight = levels.h();
+    LevelSet nextLevelSet = null;
+    int attemptNumber = 0;
+    boolean needAdditionFailureNotification = false;
+
+    while (!done) {
+      if (cause != null) {
+        if (cause.w() > newWidth) {
+          newWidth = cause.w();
+        } else {
+          newHeight = (int) (newHeight * (1.0f + EXPANSION_FACTOR));
+        }
+      }
+
+      // Clamp to maximum values
+      needAdditionFailureNotification = false;
+      if (maxWidth > 0 && newWidth > maxWidth) {
+        newWidth = maxWidth;
+        needAdditionFailureNotification = true;
+      }
+      if (maxHeight > 0 && newHeight > maxHeight) {
+        newHeight = maxHeight;
+        needAdditionFailureNotification = true;
+      }
+
+      nextLevelSet = new LevelSet(newWidth, newHeight);
+      
+      // Make copies of all existing rectangles
+      List/*<Rect>*/ newRects = new ArrayList/*<Rect>*/();
+      for (Iterator i1 = levels.iterator(); i1.hasNext(); ) {
+        Level level = (Level) i1.next();
+        for (Iterator i2 = level.iterator(); i2.hasNext(); ) {
+          Rect cur = (Rect) i2.next();
+          Rect newRect = new Rect(0, 0, cur.w(), cur.h(), null);
+          cur.setNextLocation(newRect);
+          // Hook up the reverse mapping too for easier replacement
+          newRect.setNextLocation(cur);
+          newRects.add(newRect);
+        }
+      }
+      // Sort them by decreasing height (note: this isn't really
+      // guaranteed to improve the chances of a successful layout)
+      Collections.sort(newRects, rectHComparator);
+      // Try putting all of these rectangles into the new level set
+      done = true;
+      for (Iterator iter = newRects.iterator(); iter.hasNext(); ) {
+        if (!nextLevelSet.add((Rect) iter.next())) {
+          done = false;
+          break;
+        }
+      }
+
+      if (done && cause != null) {
+        // Try to add the new rectangle as well
+        if (nextLevelSet.add(cause)) {
+          // We're OK
+        } else {
+          done = false;
+        }
+      }
+
+      // Don't send addition failure notifications if we're only doing
+      // a compaction
+      if (!done && needAdditionFailureNotification && cause != null) {
+        manager.additionFailed(cause, attemptNumber);
+      }
+      ++attemptNumber;
+    }
+
+    // See whether the implicit compaction that just occurred has
+    // yielded excess empty space.
+    if (nextLevelSet.getUsedHeight() > 0 &&
+        nextLevelSet.getUsedHeight() < nextLevelSet.h() * SHRINK_FACTOR) {
+      int shrunkHeight = Math.max(initialHeight,
+                                  (int) (nextLevelSet.getUsedHeight() * (1.0f + EXPANSION_FACTOR)));
+      if (maxHeight > 0 && shrunkHeight > maxHeight) {
+        shrunkHeight = maxHeight;
+      }
+      nextLevelSet.setHeight(shrunkHeight);
+    }
+
+    // If we temporarily added the new rectangle to the new LevelSet,
+    // take it out since we don't "really" add it here but in add(), above
+    if (cause != null) {
+      nextLevelSet.remove(cause);
+    }
+
+    // OK, now we have a new layout and a mapping from the old to the
+    // new locations of rectangles on the backing store. Allocate a
+    // new backing store, move the contents over and deallocate the
+    // old one.
+    Object newBackingStore = manager.allocateBackingStore(nextLevelSet.w(),
+                                                          nextLevelSet.h());
+    manager.beginMovement(backingStore, newBackingStore);
+    for (Iterator i1 = levels.iterator(); i1.hasNext(); ) {
+      Level level = (Level) i1.next();
+      for (Iterator i2 = level.iterator(); i2.hasNext(); ) {
+        Rect cur = (Rect) i2.next();
+        manager.move(backingStore, cur,
+                     newBackingStore, cur.getNextLocation());
+      }
+    }
+    // Replace references to temporary rectangles with original ones
+    nextLevelSet.updateRectangleReferences();
+    manager.endMovement(backingStore, newBackingStore);
+    // Now delete the old backing store
+    manager.deleteBackingStore(backingStore);
+    // Update to new versions of backing store and LevelSet
+    backingStore = newBackingStore;
+    levels = nextLevelSet;
+  }
+
+  /** Clears all Rects contained in this RectanglePacker. */
+  public void clear() {
+    levels.clear();
+  }
+
+  /** Disposes the backing store allocated by the
+      BackingStoreManager. This RectanglePacker may no longer be used
+      after calling this method. */
+  public void dispose() {
+    if (backingStore != null)
+      manager.deleteBackingStore(backingStore);
+    backingStore = null;
+    levels = null;
+  }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/packrect/package.html b/src/jogl/classes/com/jogamp/opengl/util/packrect/package.html
new file mode 100755
index 000000000..c1c5db477
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/packrect/package.html
@@ -0,0 +1,9 @@
+<BODY>
+This package implements a rectangle packing algorithm suitable for
+tracking the placement of multiple rectangles inside a larger one. It
+is useful for cases such as placing the contents of multiple windows
+on a larger backing store texture for a compositing window manager;
+placing multiple rasterized strings in a texture map for quick
+rendering to the screen; and many other situations where it is useful
+to carve up a larger texture into smaller pieces dynamically. <P>
+</BODY>
diff --git a/src/jogl/classes/com/jogamp/opengl/util/texture/Texture.java b/src/jogl/classes/com/jogamp/opengl/util/texture/Texture.java
new file mode 100755
index 000000000..5ef96eeaf
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/texture/Texture.java
@@ -0,0 +1,1120 @@
+/*
+ * Copyright (c) 2005 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ */
+
+package com.jogamp.opengl.util.texture;
+
+import java.nio.*;
+import java.security.*;
+
+import javax.media.opengl.*;
+import javax.media.opengl.glu.*;
+import javax.media.nativewindow.NativeWindowFactory;
+import com.jogamp.opengl.impl.*;
+import com.jogamp.opengl.util.texture.*;
+import com.jogamp.opengl.util.texture.spi.*;
+
+/**
+ * Represents an OpenGL texture object. Contains convenience routines
+ * for enabling/disabling OpenGL texture state, binding this texture,
+ * and computing texture coordinates for both the entire image as well
+ * as a sub-image. 
+ * 
+ * <p><a name="nonpow2"><b>Non-power-of-two restrictions</b></a>
+ * <br> When creating an OpenGL texture object, the Texture class will
+ * attempt to leverage the <a
+ * href="http://www.opengl.org/registry/specs/ARB/texture_non_power_of_two.txt">GL_ARB_texture_non_power_of_two</a>
+ * and <a
+ * href="http://www.opengl.org/registry/specs/ARB/texture_rectangle.txt">GL_ARB_texture_rectangle</a>
+ * extensions (in that order) whenever possible.  If neither extension
+ * is available, the Texture class will simply upload a non-pow2-sized
+ * image into a standard pow2-sized texture (without any special
+ * scaling).  Since the choice of extension (or whether one is used at
+ * all) depends on the user's machine configuration, developers are
+ * recommended to use {@link #getImageTexCoords} and {@link
+ * #getSubImageTexCoords}, as those methods will calculate the
+ * appropriate texture coordinates for the situation.
+ *
+ * <p>One caveat in this approach is that certain texture wrap modes
+ * (e.g.  <code>GL_REPEAT</code>) are not legal when the GL_ARB_texture_rectangle
+ * extension is in use.  Another issue to be aware of is that in the
+ * default pow2 scenario, if the original image does not have pow2
+ * dimensions, then wrapping may not work as one might expect since
+ * the image does not extend to the edges of the pow2 texture.  If
+ * texture wrapping is important, it is recommended to use only
+ * pow2-sized images with the Texture class.
+ *
+ * <p><a name="perftips"><b>Performance Tips</b></a>
+ * <br> For best performance, try to avoid calling {@link #enable} /
+ * {@link #bind} / {@link #disable} any more than necessary. For
+ * example, applications using many Texture objects in the same scene
+ * may want to reduce the number of calls to both {@link #enable} and
+ * {@link #disable}. To do this it is necessary to call {@link
+ * #getTarget} to make sure the OpenGL texture target is the same for
+ * all of the Texture objects in use; non-power-of-two textures using
+ * the GL_ARB_texture_rectangle extension use a different target than
+ * power-of-two textures using the GL_TEXTURE_2D target. Note that
+ * when switching between textures it is necessary to call {@link
+ * #bind}, but when drawing many triangles all using the same texture,
+ * for best performance only one call to {@link #bind} should be made.
+ *
+ * <p><a name="premult"><b>Alpha premultiplication and blending</b></a>
+ * <br> The mathematically correct way to perform blending in OpenGL
+ * (with the SrcOver "source over destination" mode, or any other
+ * Porter-Duff rule) is to use "premultiplied color components", which
+ * means the R/G/ B color components have already been multiplied by
+ * the alpha value.  To make things easier for developers, the Texture
+ * class will automatically convert non-premultiplied image data into
+ * premultiplied data when storing it into an OpenGL texture.  As a
+ * result, it is important to use the correct blending function; for
+ * example, the SrcOver rule is expressed as:
+<pre>
+    gl.glBlendFunc(GL.GL_ONE, GL.GL_ONE_MINUS_SRC_ALPHA);
+</pre>
+ * Also, when using a texture function like <code>GL_MODULATE</code> where
+ * the current color plays a role, it is important to remember to make
+ * sure that the color is specified in a premultiplied form, for
+ * example:
+<pre>
+    float a = ...;
+    float r = r * a;
+    float g = g * a;
+    float b = b * a;
+    gl.glColor4f(r, g, b, a);
+</pre> 
+ *
+ * For reference, here is a list of the Porter-Duff compositing rules
+ * and the associated OpenGL blend functions (source and destination
+ * factors) to use in the face of premultiplied alpha:
+ *
+<CENTER>
+<TABLE WIDTH="75%">
+<TR> <TD> Rule     <TD> Source                  <TD> Dest
+<TR> <TD> Clear    <TD> GL_ZERO                 <TD> GL_ZERO
+<TR> <TD> Src      <TD> GL_ONE                  <TD> GL_ZERO
+<TR> <TD> SrcOver  <TD> GL_ONE                  <TD> GL_ONE_MINUS_SRC_ALPHA
+<TR> <TD> DstOver  <TD> GL_ONE_MINUS_DST_ALPHA  <TD> GL_ONE
+<TR> <TD> SrcIn    <TD> GL_DST_ALPHA            <TD> GL_ZERO
+<TR> <TD> DstIn    <TD> GL_ZERO                 <TD> GL_SRC_ALPHA
+<TR> <TD> SrcOut   <TD> GL_ONE_MINUS_DST_ALPHA  <TD> GL_ZERO
+<TR> <TD> DstOut   <TD> GL_ZERO                 <TD> GL_ONE_MINUS_SRC_ALPHA
+<TR> <TD> Dst      <TD> GL_ZERO                 <TD> GL_ONE
+<TR> <TD> SrcAtop  <TD> GL_DST_ALPHA            <TD> GL_ONE_MINUS_SRC_ALPHA
+<TR> <TD> DstAtop  <TD> GL_ONE_MINUS_DST_ALPHA  <TD> GL_SRC_ALPHA
+<TR> <TD> AlphaXor <TD> GL_ONE_MINUS_DST_ALPHA  <TD> GL_ONE_MINUS_SRC_ALPHA
+</TABLE>
+</CENTER>
+ *
+ * @author Chris Campbell
+ * @author Kenneth Russell
+ */
+public class Texture {
+    /** The GL target type. */
+    private int target;
+    /** The GL texture ID. */
+    private int texID;
+    /** The width of the texture. */
+    private int texWidth;
+    /** The height of the texture. */
+    private int texHeight;
+    /** The width of the image. */
+    private int imgWidth;
+    /** The height of the image. */
+    private int imgHeight;
+    /** The original aspect ratio of the image, before any rescaling
+        that might have occurred due to using the GLU mipmap routines. */
+    private float aspectRatio;
+    /** Indicates whether the TextureData requires a vertical flip of
+        the texture coords. */
+    private boolean mustFlipVertically;
+    /** Indicates whether we're using automatic mipmap generation
+        support (GL_GENERATE_MIPMAP). */
+    private boolean usingAutoMipmapGeneration;
+
+    /** The texture coordinates corresponding to the entire image. */
+    private TextureCoords coords;
+
+    /** An estimate of the amount of texture memory this texture consumes. */
+    private int estimatedMemorySize;
+
+    private static final AccessControlContext localACC = AccessController.getContext();
+
+    private static final boolean DEBUG = Debug.debug("Texture");
+    private static final boolean VERBOSE = Debug.verbose();
+
+    // For testing alternate code paths on more capable hardware
+    private static final boolean disableNPOT    = Debug.isPropertyDefined("jogl.texture.nonpot", true, localACC);
+    private static final boolean disableTexRect = Debug.isPropertyDefined("jogl.texture.notexrect", true, localACC);
+
+    public Texture(TextureData data) throws GLException {
+        texID = 0;
+        updateImage(data);
+    }
+
+    // Constructor for use when creating e.g. cube maps, where there is
+    // no initial texture data
+    public Texture(int target) throws GLException {
+        texID = 0;
+        this.target = target;
+    }
+
+    // Package-private constructor for creating a texture object which wraps
+    // an existing texture ID from another package
+    Texture(int textureID,
+	    int target,
+	    int texWidth,
+	    int texHeight,
+	    int imgWidth,
+	    int imgHeight,
+	    boolean mustFlipVertically) {
+	this.texID = textureID;
+	this.target = target;
+	this.mustFlipVertically = mustFlipVertically;
+	this.texWidth = texWidth;
+	this.texHeight = texHeight;
+	setImageSize(imgWidth, imgHeight, target);
+    }
+
+    /**
+     * Enables this texture's target (e.g., GL_TEXTURE_2D) in the
+     * current GL context's state. This method is a shorthand equivalent
+     * of the following OpenGL code:
+     <pre>
+     gl.glEnable(texture.getTarget());
+     </pre>
+     *
+     * See the <a href="#perftips">performance tips</a> above for hints
+     * on how to maximize performance when using many Texture objects.
+     *
+     * @throws GLException if no OpenGL context was current or if any
+     * OpenGL-related errors occurred
+     */
+    public void enable() throws GLException {
+        GLContext.getCurrentGL().glEnable(target);
+    }
+
+    /**
+     * Disables this texture's target (e.g., GL_TEXTURE_2D) in the
+     * current GL context's state. This method is a shorthand equivalent
+     * of the following OpenGL code:
+     <pre>
+     gl.glDisable(texture.getTarget());
+     </pre>
+     *
+     * See the <a href="#perftips">performance tips</a> above for hints
+     * on how to maximize performance when using many Texture objects.
+     *
+     * @throws GLException if no OpenGL context was current or if any
+     * OpenGL-related errors occurred
+     */
+    public void disable() throws GLException {
+        GLContext.getCurrentGL().glDisable(target); 
+    }
+
+    /**
+     * Binds this texture to the current GL context. This method is a
+     * shorthand equivalent of the following OpenGL code:
+     <pre>
+     gl.glBindTexture(texture.getTarget(), texture.getTextureObject());
+     </pre>
+     *
+     * See the <a href="#perftips">performance tips</a> above for hints
+     * on how to maximize performance when using many Texture objects.
+     *
+     * @throws GLException if no OpenGL context was current or if any
+     * OpenGL-related errors occurred
+     */
+    public void bind() throws GLException {
+        validateTexID(null, true);
+        GLContext.getCurrentGL().glBindTexture(target, texID); 
+    }
+
+    /**
+     * Disposes the native resources used by this texture object.
+     *
+     * @throws GLException if no OpenGL context was current or if any
+     * OpenGL-related errors occurred
+     * @deprecated use destroy(GL)
+     */
+    public void dispose() throws GLException {
+        destroy(GLContext.getCurrentGL());
+    }
+
+    /**
+     * Disposes the native resources used by this texture object.
+     *
+     * @throws GLException if any OpenGL-related errors occurred
+     * @deprecated use destroy(GL)
+     */
+    public void dispose(GL gl) throws GLException {
+        destroy(gl);
+    }
+
+    /**
+     * Destroys the native resources used by this texture object.
+     *
+     * @throws GLException if any OpenGL-related errors occurred
+     */
+    public void destroy(GL gl) throws GLException {
+        if(0<texID) {
+            gl.glDeleteTextures(1, new int[] {texID}, 0);
+            texID = 0;
+        }
+    }
+
+    /**
+     * Returns the OpenGL "target" of this texture.
+     *
+     * @return the OpenGL target of this texture
+     * @see javax.media.opengl.GL#GL_TEXTURE_2D
+     * @see javax.media.opengl.GL2#GL_TEXTURE_RECTANGLE_ARB
+     */
+    public int getTarget() {
+        return target;
+    }
+
+    /**
+     * Returns the width of the allocated OpenGL texture in pixels.
+     * Note that the texture width will be greater than or equal to the
+     * width of the image contained within.
+     *
+     * @return the width of the texture
+     */
+    public int getWidth() {
+        return texWidth;
+    }
+    
+    /**
+     * Returns the height of the allocated OpenGL texture in pixels.
+     * Note that the texture height will be greater than or equal to the
+     * height of the image contained within.
+     *
+     * @return the height of the texture
+     */
+    public int getHeight() {
+        return texHeight;
+    }   
+    
+    /** 
+     * Returns the width of the image contained within this texture.
+     * Note that for non-power-of-two textures in particular this may
+     * not be equal to the result of {@link #getWidth}. It is
+     * recommended that applications call {@link #getImageTexCoords} and
+     * {@link #getSubImageTexCoords} rather than using this API
+     * directly.
+     *
+     * @return the width of the image
+     */
+    public int getImageWidth() {
+        return imgWidth;
+    }
+
+    /**
+     * Returns the height of the image contained within this texture.
+     * Note that for non-power-of-two textures in particular this may
+     * not be equal to the result of {@link #getHeight}. It is
+     * recommended that applications call {@link #getImageTexCoords} and
+     * {@link #getSubImageTexCoords} rather than using this API
+     * directly.
+     *
+     * @return the height of the image
+     */
+    public int getImageHeight() {
+        return imgHeight;
+    }
+
+    /**
+     * Returns the original aspect ratio of the image, defined as (image
+     * width) / (image height), before any scaling that might have
+     * occurred as a result of using the GLU mipmap routines.
+     */
+    public float getAspectRatio() {
+        return aspectRatio;
+    }
+
+    /**
+     * Returns the set of texture coordinates corresponding to the
+     * entire image. If the TextureData indicated that the texture
+     * coordinates must be flipped vertically, the returned
+     * TextureCoords will take that into account.
+     * 
+     * @return the texture coordinates corresponding to the entire image
+     */
+    public TextureCoords getImageTexCoords() {
+        return coords;
+    }
+
+    /**
+     * Returns the set of texture coordinates corresponding to the
+     * specified sub-image. The (x1, y1) and (x2, y2) points are
+     * specified in terms of pixels starting from the lower-left of the
+     * image. (x1, y1) should specify the lower-left corner of the
+     * sub-image and (x2, y2) the upper-right corner of the sub-image.
+     * If the TextureData indicated that the texture coordinates must be
+     * flipped vertically, the returned TextureCoords will take that
+     * into account; this should not be handled by the end user in the
+     * specification of the y1 and y2 coordinates.
+     * 
+     * @return the texture coordinates corresponding to the specified sub-image
+     */
+    public TextureCoords getSubImageTexCoords(int x1, int y1, int x2, int y2) {
+        if (target == GL2.GL_TEXTURE_RECTANGLE_ARB) {
+            if (mustFlipVertically) {
+                return new TextureCoords(x1, texHeight - y1, x2, texHeight - y2);
+            } else {
+                return new TextureCoords(x1, y1, x2, y2);
+            }
+        } else {
+            float tx1 = (float)x1 / (float)texWidth;
+            float ty1 = (float)y1 / (float)texHeight;
+            float tx2 = (float)x2 / (float)texWidth;
+            float ty2 = (float)y2 / (float)texHeight;
+            if (mustFlipVertically) {
+                float yMax = (float) imgHeight / (float) texHeight;
+                return new TextureCoords(tx1, yMax - ty1, tx2, yMax - ty2);
+            } else {
+                return new TextureCoords(tx1, ty1, tx2, ty2);
+            }
+        }
+    }
+
+    /**
+     * Updates the entire content area of this texture using the data in
+     * the given image.
+     * 
+     * @throws GLException if no OpenGL context was current or if any
+     * OpenGL-related errors occurred
+     */
+    public void updateImage(TextureData data) throws GLException {
+        updateImage(data, 0);
+    }
+
+    /**
+     * Indicates whether this texture's texture coordinates must be
+     * flipped vertically in order to properly display the texture. This
+     * is handled automatically by {@link #getImageTexCoords
+     * getImageTexCoords} and {@link #getSubImageTexCoords
+     * getSubImageTexCoords}, but applications may generate or otherwise
+     * produce texture coordinates which must be corrected.
+     */
+    public boolean getMustFlipVertically() {
+        return mustFlipVertically;
+    }
+
+    /**
+     * Updates the content area of the specified target of this texture
+     * using the data in the given image. In general this is intended
+     * for construction of cube maps.
+     * 
+     * @throws GLException if no OpenGL context was current or if any
+     * OpenGL-related errors occurred
+     */
+    public void updateImage(TextureData data, int target) throws GLException {
+        GL gl = GLContext.getCurrentGL();
+        validateTexID(gl, true);
+
+        imgWidth = data.getWidth();
+        imgHeight = data.getHeight();
+        aspectRatio = (float) imgWidth / (float) imgHeight;
+        mustFlipVertically = data.getMustFlipVertically();
+
+        int texTarget = 0;
+        int texParamTarget = this.target;
+
+        // See whether we have automatic mipmap generation support
+        boolean haveAutoMipmapGeneration =
+            (gl.isExtensionAvailable("GL_VERSION_1_4") ||
+             gl.isExtensionAvailable("GL_SGIS_generate_mipmap"));
+
+        // Indicate to the TextureData what functionality is available
+        data.setHaveEXTABGR(gl.isExtensionAvailable("GL_EXT_abgr"));
+        data.setHaveGL12(gl.isExtensionAvailable("GL_VERSION_1_2"));
+
+        // Indicates whether both width and height are power of two
+        boolean isPOT = isPowerOfTwo(imgWidth) && isPowerOfTwo(imgHeight);
+
+        // Note that automatic mipmap generation doesn't work for
+        // GL_ARB_texture_rectangle
+        if (!isPOT && !haveNPOT(gl)) {
+            haveAutoMipmapGeneration = false;
+        }
+
+        boolean expandingCompressedTexture = false;
+        boolean done = false;
+        if (data.getMipmap() && !haveAutoMipmapGeneration) {
+            // GLU always scales the texture's dimensions to be powers of
+            // two. It also doesn't really matter exactly what the texture
+            // width and height are because the texture coords are always
+            // between 0.0 and 1.0.
+            imgWidth = nextPowerOfTwo(imgWidth);
+            imgHeight = nextPowerOfTwo(imgHeight);
+            texWidth = imgWidth;
+            texHeight = imgHeight;
+            texTarget = GL.GL_TEXTURE_2D;
+            done = true;
+        }
+
+        if (!done && preferTexRect(gl) && !isPOT &&
+            haveTexRect(gl) && !data.isDataCompressed() && gl.isGL2()) {
+            // GL_ARB_texture_rectangle does not work for compressed textures
+            if (DEBUG) {
+                System.err.println("Using GL_ARB_texture_rectangle preferentially on this hardware");
+            }
+
+            texWidth = imgWidth;
+            texHeight = imgHeight;
+            texTarget = GL2.GL_TEXTURE_RECTANGLE_ARB;
+            done = true;
+        }
+
+        if (!done && (isPOT || haveNPOT(gl))) {
+            if (DEBUG) {
+                if (isPOT) {
+                    System.err.println("Power-of-two texture");
+                } else {
+                    System.err.println("Using GL_ARB_texture_non_power_of_two");
+                }
+            }
+
+            texWidth = imgWidth;
+            texHeight = imgHeight;
+            texTarget = GL.GL_TEXTURE_2D;
+            done = true;
+        }
+
+        if (!done && haveTexRect(gl) && !data.isDataCompressed() && gl.isGL2()) {
+            // GL_ARB_texture_rectangle does not work for compressed textures
+            if (DEBUG) {
+                System.err.println("Using GL_ARB_texture_rectangle");
+            }
+
+            texWidth = imgWidth;
+            texHeight = imgHeight;
+            texTarget = GL2.GL_TEXTURE_RECTANGLE_ARB;
+            done = true;
+        }
+
+        if (!done) {
+            // If we receive non-power-of-two compressed texture data and
+            // don't have true hardware support for compressed textures, we
+            // can fake this support by producing an empty "compressed"
+            // texture image, using glCompressedTexImage2D with that to
+            // allocate the texture, and glCompressedTexSubImage2D with the
+            // incoming data.
+            if (data.isDataCompressed()) {
+                if (data.getMipmapData() != null) {
+
+                    // We don't currently support expanding of compressed,
+                    // mipmapped non-power-of-two textures to the nearest power
+                    // of two; the obvious port of the non-mipmapped code didn't
+                    // work
+                    throw new GLException("Mipmapped non-power-of-two compressed textures only supported on OpenGL 2.0 hardware (GL_ARB_texture_non_power_of_two)");
+                }
+
+                expandingCompressedTexture = true;
+            }
+
+            if (DEBUG) {
+                System.err.println("Expanding texture to power-of-two dimensions");
+            }
+
+            if (data.getBorder() != 0) {
+                throw new RuntimeException("Scaling up a non-power-of-two texture which has a border won't work");
+            }
+            texWidth = nextPowerOfTwo(imgWidth);
+            texHeight = nextPowerOfTwo(imgHeight);
+            texTarget = GL.GL_TEXTURE_2D;
+        }
+
+        texParamTarget = texTarget;
+        setImageSize(imgWidth, imgHeight, texTarget);
+
+        if (target != 0) {
+            // Allow user to override auto detection and skip bind step (for
+            // cubemap construction)
+            texTarget = target;
+            if (this.target == 0) {
+                throw new GLException("Override of target failed; no target specified yet");
+            }
+            texParamTarget = this.target;
+            gl.glBindTexture(texParamTarget, texID);
+        } else {
+            gl.glBindTexture(texTarget, texID);
+        }
+
+        if (data.getMipmap() && !haveAutoMipmapGeneration) {
+            int[] align = new int[1];
+            gl.glGetIntegerv(GL.GL_UNPACK_ALIGNMENT, align, 0); // save alignment
+            gl.glPixelStorei(GL.GL_UNPACK_ALIGNMENT, data.getAlignment());
+
+            if (data.isDataCompressed()) {
+                throw new GLException("May not request mipmap generation for compressed textures");
+            }
+
+            try {
+                // FIXME: may need check for GLUnsupportedException
+                GLU glu = GLU.createGLU(gl);
+                glu.gluBuild2DMipmaps(texTarget, data.getInternalFormat(),
+                                      data.getWidth(), data.getHeight(),
+                                      data.getPixelFormat(), data.getPixelType(), data.getBuffer());
+            } finally {
+                gl.glPixelStorei(GL.GL_UNPACK_ALIGNMENT, align[0]); // restore alignment
+            }
+        } else {
+            checkCompressedTextureExtensions(data);
+            Buffer[] mipmapData = data.getMipmapData();
+            if (mipmapData != null) {
+                int width = texWidth;
+                int height = texHeight;
+                for (int i = 0; i < mipmapData.length; i++) {
+                    if (data.isDataCompressed()) {
+                        // Need to use glCompressedTexImage2D directly to allocate and fill this image
+                        // Avoid spurious memory allocation when possible
+                        gl.glCompressedTexImage2D(texTarget, i, data.getInternalFormat(),
+                                                  width, height, data.getBorder(),
+                                                  mipmapData[i].remaining(), mipmapData[i]);
+                    } else {
+                        // Allocate texture image at this level
+                        gl.glTexImage2D(texTarget, i, data.getInternalFormat(),
+                                        width, height, data.getBorder(),
+                                        data.getPixelFormat(), data.getPixelType(), null);
+                        updateSubImageImpl(data, texTarget, i, 0, 0, 0, 0, data.getWidth(), data.getHeight());
+                    }
+
+                    width = Math.max(width / 2, 1);
+                    height = Math.max(height / 2, 1);
+                }
+            } else {
+                if (data.isDataCompressed()) {
+                    if (!expandingCompressedTexture) {
+                        // Need to use glCompressedTexImage2D directly to allocate and fill this image
+                        // Avoid spurious memory allocation when possible
+                        gl.glCompressedTexImage2D(texTarget, 0, data.getInternalFormat(),
+                                                  texWidth, texHeight, data.getBorder(),
+                                                  data.getBuffer().capacity(), data.getBuffer());
+                    } else {
+                        ByteBuffer buf = DDSImage.allocateBlankBuffer(texWidth,
+                                                                      texHeight,
+                                                                      data.getInternalFormat());
+                        gl.glCompressedTexImage2D(texTarget, 0, data.getInternalFormat(),
+                                                  texWidth, texHeight, data.getBorder(),
+                                                  buf.capacity(), buf);
+                        updateSubImageImpl(data, texTarget, 0, 0, 0, 0, 0, data.getWidth(), data.getHeight());
+                    }
+                } else {
+                    if (data.getMipmap() && haveAutoMipmapGeneration && gl.isGL2ES1()) {
+                        // For now, only use hardware mipmapping for uncompressed 2D
+                        // textures where the user hasn't explicitly specified
+                        // mipmap data; don't know about interactions between
+                        // GL_GENERATE_MIPMAP and glCompressedTexImage2D
+                        gl.glTexParameteri(texParamTarget, GL2ES1.GL_GENERATE_MIPMAP, GL.GL_TRUE);
+                        usingAutoMipmapGeneration = true;
+                    }
+
+                    gl.glTexImage2D(texTarget, 0, data.getInternalFormat(),
+                                    texWidth, texHeight, data.getBorder(),
+                                    data.getPixelFormat(), data.getPixelType(), null);
+                    updateSubImageImpl(data, texTarget, 0, 0, 0, 0, 0, data.getWidth(), data.getHeight());
+                }
+            }
+        }
+
+        int minFilter = (data.getMipmap() ? GL.GL_LINEAR_MIPMAP_LINEAR : GL.GL_LINEAR);
+        int magFilter = GL.GL_LINEAR;
+        int wrapMode = (gl.isExtensionAvailable("GL_VERSION_1_2") || !gl.isGL2()) ? GL.GL_CLAMP_TO_EDGE : GL2.GL_CLAMP;
+
+        // REMIND: figure out what to do for GL_TEXTURE_RECTANGLE_ARB
+        if (texTarget != GL2.GL_TEXTURE_RECTANGLE_ARB) {
+            gl.glTexParameteri(texParamTarget, GL.GL_TEXTURE_MIN_FILTER, minFilter);
+            gl.glTexParameteri(texParamTarget, GL.GL_TEXTURE_MAG_FILTER, magFilter);
+            gl.glTexParameteri(texParamTarget, GL.GL_TEXTURE_WRAP_S, wrapMode);
+            gl.glTexParameteri(texParamTarget, GL.GL_TEXTURE_WRAP_T, wrapMode);
+            if (this.target == GL2.GL_TEXTURE_CUBE_MAP) {
+                gl.glTexParameteri(texParamTarget, GL2.GL_TEXTURE_WRAP_R, wrapMode);
+            }
+        }
+
+        // Don't overwrite target if we're loading e.g. faces of a cube
+        // map
+        if ((this.target == 0) ||
+            (this.target == GL.GL_TEXTURE_2D) ||
+            (this.target == GL2.GL_TEXTURE_RECTANGLE_ARB)) {
+            this.target = texTarget;
+        }
+
+        // This estimate will be wrong for cube maps
+        estimatedMemorySize = data.getEstimatedMemorySize();
+    }
+
+    /**
+     * Updates a subregion of the content area of this texture using the
+     * given data. If automatic mipmap generation is in use (see {@link
+     * #isUsingAutoMipmapGeneration isUsingAutoMipmapGeneration}),
+     * updates to the base (level 0) mipmap will cause the lower-level
+     * mipmaps to be regenerated, and updates to other mipmap levels
+     * will be ignored. Otherwise, if automatic mipmap generation is not
+     * in use, only updates the specified mipmap level and does not
+     * re-generate mipmaps if they were originally produced or loaded.
+     *
+     * @param data the image data to be uploaded to this texture
+     * @param mipmapLevel the mipmap level of the texture to set. If
+     * this is non-zero and the TextureData contains mipmap data, the
+     * appropriate mipmap level will be selected.
+     * @param x the x offset (in pixels) relative to the lower-left corner
+     * of this texture
+     * @param y the y offset (in pixels) relative to the lower-left corner
+     * of this texture
+     *
+     * @throws GLException if no OpenGL context was current or if any
+     * OpenGL-related errors occurred
+     */
+    public void updateSubImage(TextureData data, int mipmapLevel, int x, int y) throws GLException {
+        if (usingAutoMipmapGeneration && mipmapLevel != 0) {
+            // When we're using mipmap generation via GL_GENERATE_MIPMAP, we
+            // don't need to update other mipmap levels
+            return;
+        }
+        bind();
+        updateSubImageImpl(data, target, mipmapLevel, x, y, 0, 0, data.getWidth(), data.getHeight());
+    }
+
+    /**
+     * Updates a subregion of the content area of this texture using the
+     * specified sub-region of the given data.  If automatic mipmap
+     * generation is in use (see {@link #isUsingAutoMipmapGeneration
+     * isUsingAutoMipmapGeneration}), updates to the base (level 0)
+     * mipmap will cause the lower-level mipmaps to be regenerated, and
+     * updates to other mipmap levels will be ignored. Otherwise, if
+     * automatic mipmap generation is not in use, only updates the
+     * specified mipmap level and does not re-generate mipmaps if they
+     * were originally produced or loaded. This method is only supported
+     * for uncompressed TextureData sources.
+     *
+     * @param data the image data to be uploaded to this texture
+     * @param mipmapLevel the mipmap level of the texture to set. If
+     * this is non-zero and the TextureData contains mipmap data, the
+     * appropriate mipmap level will be selected.
+     * @param dstx the x offset (in pixels) relative to the lower-left corner
+     * of this texture where the update will be applied
+     * @param dsty the y offset (in pixels) relative to the lower-left corner
+     * of this texture where the update will be applied
+     * @param srcx the x offset (in pixels) relative to the lower-left corner
+     * of the supplied TextureData from which to fetch the update rectangle
+     * @param srcy the y offset (in pixels) relative to the lower-left corner
+     * of the supplied TextureData from which to fetch the update rectangle
+     * @param width the width (in pixels) of the rectangle to be updated
+     * @param height the height (in pixels) of the rectangle to be updated
+     *
+     * @throws GLException if no OpenGL context was current or if any
+     * OpenGL-related errors occurred
+     */
+    public void updateSubImage(TextureData data, int mipmapLevel,
+                               int dstx, int dsty,
+                               int srcx, int srcy,
+                               int width, int height) throws GLException {
+        if (data.isDataCompressed()) {
+            throw new GLException("updateSubImage specifying a sub-rectangle is not supported for compressed TextureData");
+        }
+        if (usingAutoMipmapGeneration && mipmapLevel != 0) {
+            // When we're using mipmap generation via GL_GENERATE_MIPMAP, we
+            // don't need to update other mipmap levels
+            return;
+        }
+        bind();
+        updateSubImageImpl(data, target, mipmapLevel, dstx, dsty, srcx, srcy, width, height);
+    }
+
+    /**
+     * Sets the OpenGL floating-point texture parameter for the
+     * texture's target. This gives control over parameters such as
+     * GL_TEXTURE_MAX_ANISOTROPY_EXT. Causes this texture to be bound to
+     * the current texture state.
+     * 
+     * @throws GLException if no OpenGL context was current or if any
+     * OpenGL-related errors occurred
+     */
+    public void setTexParameterf(int parameterName,
+                                 float value) {
+        bind();
+        GL gl = GLContext.getCurrentGL();
+        gl.glTexParameterf(target, parameterName, value);
+    }
+
+    /**
+     * Sets the OpenGL multi-floating-point texture parameter for the
+     * texture's target. Causes this texture to be bound to the current
+     * texture state.
+     * 
+     * @throws GLException if no OpenGL context was current or if any
+     * OpenGL-related errors occurred
+     */
+    public void setTexParameterfv(int parameterName,
+                                  FloatBuffer params) {
+        bind();
+        GL gl = GLContext.getCurrentGL();
+        gl.glTexParameterfv(target, parameterName, params);
+    }
+
+    /**
+     * Sets the OpenGL multi-floating-point texture parameter for the
+     * texture's target. Causes this texture to be bound to the current
+     * texture state.
+     * 
+     * @throws GLException if no OpenGL context was current or if any
+     * OpenGL-related errors occurred
+     */
+    public void setTexParameterfv(int parameterName,
+                                  float[] params, int params_offset) {
+        bind();
+        GL gl = GLContext.getCurrentGL();
+        gl.glTexParameterfv(target, parameterName, params, params_offset);
+    }
+
+    /**
+     * Sets the OpenGL integer texture parameter for the texture's
+     * target. This gives control over parameters such as
+     * GL_TEXTURE_WRAP_S and GL_TEXTURE_WRAP_T, which by default are set
+     * to GL_CLAMP_TO_EDGE if OpenGL 1.2 is supported on the current
+     * platform and GL_CLAMP if not. Causes this texture to be bound to
+     * the current texture state.
+     * 
+     * @throws GLException if no OpenGL context was current or if any
+     * OpenGL-related errors occurred
+     */
+    public void setTexParameteri(int parameterName,
+                                 int value) {
+        bind();
+        GL gl = GLContext.getCurrentGL();
+        gl.glTexParameteri(target, parameterName, value);
+    }
+
+    /**
+     * Sets the OpenGL multi-integer texture parameter for the texture's
+     * target. Causes this texture to be bound to the current texture
+     * state.
+     * 
+     * @throws GLException if no OpenGL context was current or if any
+     * OpenGL-related errors occurred
+     */
+    public void setTexParameteriv(int parameterName,
+                                  IntBuffer params) {
+        bind();
+        GL gl = GLContext.getCurrentGL();
+        gl.glTexParameteriv(target, parameterName, params);
+    }
+
+    /**
+     * Sets the OpenGL multi-integer texture parameter for the texture's
+     * target. Causes this texture to be bound to the current texture
+     * state.
+     * 
+     * @throws GLException if no OpenGL context was current or if any
+     * OpenGL-related errors occurred
+     */
+    public void setTexParameteriv(int parameterName,
+                                  int[] params, int params_offset) {
+        bind();
+        GL gl = GLContext.getCurrentGL();
+        gl.glTexParameteriv(target, parameterName, params, params_offset);
+    }
+
+    /**
+     * Returns the underlying OpenGL texture object for this texture.
+     * Most applications will not need to access this, since it is
+     * handled automatically by the bind() and dispose() APIs.
+     */
+    public int getTextureObject() {
+        validateTexID(null, false);
+        return texID;
+    }
+
+    /** Returns an estimate of the amount of texture memory in bytes
+        this Texture consumes. It should only be treated as an estimate;
+        most applications should not need to query this but instead let
+        the OpenGL implementation page textures in and out as
+        necessary. */
+    public int getEstimatedMemorySize() {
+        return estimatedMemorySize;
+    }
+
+    /** Indicates whether this Texture is using automatic mipmap
+        generation (via the OpenGL texture parameter
+        GL_GENERATE_MIPMAP). This will automatically be used when
+        mipmapping is requested via the TextureData and either OpenGL
+        1.4 or the GL_SGIS_generate_mipmap extension is available. If
+        so, updates to the base image (mipmap level 0) will
+        automatically propagate down to the lower mipmap levels. Manual
+        updates of the mipmap data at these lower levels will be
+        ignored. */
+    public boolean isUsingAutoMipmapGeneration() {
+        return usingAutoMipmapGeneration;
+    }
+
+    //----------------------------------------------------------------------
+    // Internals only below this point
+    //
+
+    /**
+     * Returns true if the given value is a power of two.
+     *
+     * @return true if the given value is a power of two, false otherwise
+     */
+    private static boolean isPowerOfTwo(int val) {
+        return ((val & (val - 1)) == 0);
+    }
+
+    /**
+     * Returns the nearest power of two that is larger than the given value.
+     * If the given value is already a power of two, this method will simply
+     * return that value.
+     *
+     * @param val the value
+     * @return the next power of two
+     */
+    private static int nextPowerOfTwo(int val) {
+        int ret = 1;
+        while (ret < val) {
+            ret <<= 1;
+        }
+        return ret;
+    }
+
+    /**
+     * Updates the actual image dimensions; usually only called from
+     * <code>updateImage</code>.
+     */
+    private void setImageSize(int width, int height, int target) {
+        imgWidth = width;
+        imgHeight = height;
+        if (target == GL2.GL_TEXTURE_RECTANGLE_ARB) {
+            if (mustFlipVertically) {
+                coords = new TextureCoords(0, imgHeight, imgWidth, 0);
+            } else {
+                coords = new TextureCoords(0, 0, imgWidth, imgHeight);
+            }
+        } else {
+            if (mustFlipVertically) {
+                coords = new TextureCoords(0, (float) imgHeight / (float) texHeight,
+                                           (float) imgWidth / (float) texWidth, 0);
+            } else {
+                coords = new TextureCoords(0, 0,
+                                           (float) imgWidth / (float) texWidth,
+                                           (float) imgHeight / (float) texHeight);
+            }
+        }
+    }
+
+    private void updateSubImageImpl(TextureData data, int newTarget, int mipmapLevel,
+                                    int dstx, int dsty,
+                                    int srcx, int srcy, int width, int height) throws GLException {
+        GL gl = GLContext.getCurrentGL();
+        data.setHaveEXTABGR(gl.isExtensionAvailable("GL_EXT_abgr"));
+        data.setHaveGL12(gl.isExtensionAvailable("GL_VERSION_1_2"));
+
+        Buffer buffer = data.getBuffer();
+        if (buffer == null && data.getMipmapData() == null) {
+            // Assume user just wanted to get the Texture object allocated
+            return;
+        }
+
+        int rowlen = data.getRowLength();
+        int dataWidth = data.getWidth();
+        int dataHeight = data.getHeight();
+        if (data.getMipmapData() != null) {
+            // Compute the width, height and row length at the specified mipmap level
+            // Note we do not support specification of the row length for
+            // mipmapped textures at this point
+            for (int i = 0; i < mipmapLevel; i++) {
+                width = Math.max(width / 2, 1);
+                height = Math.max(height / 2, 1);
+
+                dataWidth = Math.max(dataWidth / 2, 1);
+                dataHeight = Math.max(dataHeight / 2, 1);
+            }
+            rowlen = 0;
+            buffer = data.getMipmapData()[mipmapLevel];
+        }
+
+        // Clip incoming rectangles to what is available both on this
+        // texture and in the incoming TextureData
+        if (srcx < 0) {
+            width += srcx;
+            srcx = 0;
+        }
+        if (srcy < 0) {
+            height += srcy;
+            srcy = 0;
+        }
+        // NOTE: not sure whether the following two are the correct thing to do
+        if (dstx < 0) {
+            width += dstx;
+            dstx = 0;
+        }
+        if (dsty < 0) {
+            height += dsty;
+            dsty = 0;
+        }
+
+        if (srcx + width > dataWidth) {
+            width = dataWidth - srcx;
+        }
+        if (srcy + height > dataHeight) {
+            height = dataHeight - srcy;
+        }
+        if (dstx + width > texWidth) {
+            width = texWidth - dstx;
+        }
+        if (dsty + height > texHeight) {
+            height = texHeight - dsty;
+        }
+
+        checkCompressedTextureExtensions(data);
+
+        if (data.isDataCompressed()) {
+            gl.glCompressedTexSubImage2D(newTarget, mipmapLevel,
+                                         dstx, dsty, width, height,
+                                         data.getInternalFormat(),
+                                         buffer.remaining(), buffer);
+        } else {
+            int[] align = { 0 };
+            int[] rowLength = { 0 };
+            int[] skipRows = { 0 };
+            int[] skipPixels = { 0 };
+            gl.glGetIntegerv(GL.GL_UNPACK_ALIGNMENT,   align,      0); // save alignment
+            if(gl.isGL2()) {
+                gl.glGetIntegerv(GL2.GL_UNPACK_ROW_LENGTH,  rowLength,  0); // save row length
+                gl.glGetIntegerv(GL2.GL_UNPACK_SKIP_ROWS,   skipRows,   0); // save skipped rows
+                gl.glGetIntegerv(GL2.GL_UNPACK_SKIP_PIXELS, skipPixels, 0); // save skipped pixels
+            }
+            gl.glPixelStorei(GL.GL_UNPACK_ALIGNMENT, data.getAlignment());
+            if (DEBUG && VERBOSE) {
+                System.out.println("Row length  = " + rowlen);
+                System.out.println("skip pixels = " + srcx);
+                System.out.println("skip rows   = " + srcy);
+                System.out.println("dstx        = " + dstx);
+                System.out.println("dsty        = " + dsty);
+                System.out.println("width       = " + width);
+                System.out.println("height      = " + height);
+            }
+            if(gl.isGL2()) {
+                gl.glPixelStorei(GL2.GL_UNPACK_ROW_LENGTH, rowlen);
+                gl.glPixelStorei(GL2.GL_UNPACK_SKIP_ROWS, srcy);
+                gl.glPixelStorei(GL2.GL_UNPACK_SKIP_PIXELS, srcx);
+            } else {
+                if ( rowlen!=0 && rowlen!=width &&
+                     srcy!=0 && srcx!=0 ) {
+                    throw new GLException("rowlen and/or x/y offset only available for GL2");
+                }
+            }
+
+            gl.glTexSubImage2D(newTarget, mipmapLevel,
+                               dstx, dsty, width, height,
+                               data.getPixelFormat(), data.getPixelType(),
+                               buffer);
+            gl.glPixelStorei(GL.GL_UNPACK_ALIGNMENT,   align[0]);      // restore alignment
+            if(gl.isGL2()) {
+                gl.glPixelStorei(GL2.GL_UNPACK_ROW_LENGTH,  rowLength[0]);  // restore row length
+                gl.glPixelStorei(GL2.GL_UNPACK_SKIP_ROWS,   skipRows[0]);   // restore skipped rows
+                gl.glPixelStorei(GL2.GL_UNPACK_SKIP_PIXELS, skipPixels[0]); // restore skipped pixels
+            }
+        }
+    }
+
+    private void checkCompressedTextureExtensions(TextureData data) {
+        GL gl = GLContext.getCurrentGL();
+        if (data.isDataCompressed()) {
+            switch (data.getInternalFormat()) {
+            case GL.GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
+            case GL.GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
+            case GL.GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
+            case GL.GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
+                if (!gl.isExtensionAvailable("GL_EXT_texture_compression_s3tc") &&
+                    !gl.isExtensionAvailable("GL_NV_texture_compression_vtc")) {
+                    throw new GLException("DXTn compressed textures not supported by this graphics card");
+                }
+                break;
+            default:
+                // FI1027GXME: should test availability of more texture
+                // compression extensions here
+                break;
+            }
+        }
+    }
+
+    private void validateTexID(GL gl, boolean throwException) {
+        if( 0 < texID ) return;
+        if(null==gl) {
+            GLContext ctx = GLContext.getCurrent();
+            if(null!=ctx) {
+                gl = ctx.getGL();
+            } else if(throwException) {
+                throw new GLException("No context current, can't create texture ID");
+            }
+        }
+
+        if(null!=gl) {
+            int[] tmp = new int[1];
+            gl.glGenTextures(1, tmp, 0);
+            texID = tmp[0];
+        }
+    }
+
+    // Helper routines for disabling certain codepaths
+    private static boolean haveNPOT(GL gl) {
+        return (!disableNPOT &&
+                ( gl.isGLES2() ||
+                  gl.isExtensionAvailable("GL_ARB_texture_non_power_of_two") ) );
+    }
+
+    private static boolean haveTexRect(GL gl) {
+        return (!disableTexRect &&
+                TextureIO.isTexRectEnabled() &&
+                gl.isExtensionAvailable("GL_ARB_texture_rectangle"));
+    }
+
+    private static boolean preferTexRect(GL gl) {
+        // Prefer GL_ARB_texture_rectangle on ATI hardware on Mac OS X
+        // due to software fallbacks
+
+        if (NativeWindowFactory.TYPE_MACOSX.equals(NativeWindowFactory.getNativeWindowType(false))) {
+            String vendor = gl.glGetString(GL.GL_VENDOR);
+            if (vendor != null && vendor.startsWith("ATI")) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/texture/TextureCoords.java b/src/jogl/classes/com/jogamp/opengl/util/texture/TextureCoords.java
new file mode 100755
index 000000000..8d8b3679d
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/texture/TextureCoords.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2005 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ */
+
+package com.jogamp.opengl.util.texture;
+
+/** Specifies texture coordinates for a rectangular area of a
+    texture. Note that some textures are inherently flipped vertically
+    from OpenGL's standard coordinate system. This class takes care of
+    this vertical flip so that the "bottom" and "top" coordinates may
+    sometimes be reversed. From the point of view of code rendering
+    textured polygons, it can always map the bottom and left texture
+    coordinates from the TextureCoords to the lower left point of the
+    textured polygon and achieve correct results. */
+
+public class TextureCoords {
+    // These represent the lower-left point
+    private float left;
+    private float bottom;
+    // These represent the upper-right point
+    private float right;
+    private float top;
+
+    public TextureCoords(float left, float bottom,
+                         float right, float top) {
+        this.left = left;
+        this.bottom = bottom;
+        this.right = right;
+        this.top = top;
+    }
+
+    /** Returns the leftmost (x) texture coordinate of this
+        rectangle. */
+    public float left() { return left; }
+
+    /** Returns the rightmost (x) texture coordinate of this
+        rectangle. */
+    public float right() { return right; }
+
+    /** Returns the bottommost (y) texture coordinate of this
+        rectangle. */
+    public float bottom() { return bottom; }
+
+    /** Returns the topmost (y) texture coordinate of this
+        rectangle. */
+    public float top() { return top; }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/texture/TextureData.java b/src/jogl/classes/com/jogamp/opengl/util/texture/TextureData.java
new file mode 100755
index 000000000..9a28f3316
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/texture/TextureData.java
@@ -0,0 +1,370 @@
+/*
+ * Copyright (c) 2005 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ */
+
+package com.jogamp.opengl.util.texture;
+
+import java.nio.*;
+
+import javax.media.opengl.*;
+import com.jogamp.opengl.util.*;
+
+/**
+ * Represents the data for an OpenGL texture. This is separated from
+ * the notion of a Texture to support things like streaming in of
+ * textures in a background thread without requiring an OpenGL context
+ * to be current on that thread.
+ *
+ * @author Chris Campbell
+ * @author Kenneth Russell
+ * @author Sven Gothel
+ */
+
+public class TextureData {
+    protected int width;
+    protected int height;
+    private int border;
+    protected int pixelFormat;
+    protected int pixelType;
+    protected int internalFormat; // perhaps inferred from pixelFormat?
+    protected boolean mipmap; // indicates whether mipmaps should be generated
+    // (ignored if mipmaps are supplied from the file)
+    private boolean dataIsCompressed;
+    protected boolean mustFlipVertically; // Must flip texture coordinates
+    // vertically to get OpenGL output
+    // to look correct
+    protected Buffer buffer; // the actual data...
+    private Buffer[] mipmapData; // ...or a series of mipmaps
+    private Flusher flusher;
+    protected int rowLength;
+    protected int alignment; // 1, 2, or 4 bytes
+    protected int estimatedMemorySize;
+
+    // These booleans are a concession to the AWTTextureData subclass
+    protected boolean haveEXTABGR;
+    protected boolean haveGL12;
+    protected GLProfile glProfile;
+
+    /** 
+     * Constructs a new TextureData object with the specified parameters
+     * and data contained in the given Buffer. The optional Flusher can
+     * be used to clean up native resources associated with this
+     * TextureData when processing is complete; for example, closing of
+     * memory-mapped files that might otherwise require a garbage
+     * collection to reclaim and close.
+     *
+     * @param glp the OpenGL Profile this texture data should be
+     *                  created for.
+     * @param internalFormat the OpenGL internal format for the
+     *                       resulting texture; must be specified, may
+     *                       not be 0
+     * @param width          the width in pixels of the texture
+     * @param height         the height in pixels of the texture
+     * @param border         the number of pixels of border this texture
+     *                       data has (0 or 1)
+     * @param pixelFormat    the OpenGL pixel format for the
+     *                       resulting texture; must be specified, may
+     *                       not be 0
+     * @param pixelType      the OpenGL type of the pixels of the texture
+     * @param mipmap         indicates whether mipmaps should be
+     *                       autogenerated (using GLU) for the resulting
+     *                       texture. Currently if mipmap is true then
+     *                       dataIsCompressed may not be true.
+     * @param dataIsCompressed indicates whether the texture data is in
+     *                       compressed form
+     *                       (e.g. GL_COMPRESSED_RGB_S3TC_DXT1_EXT)
+     * @param mustFlipVertically indicates whether the texture
+     *                           coordinates must be flipped vertically
+     *                           in order to properly display the
+     *                           texture
+     * @param buffer         the buffer containing the texture data
+     * @param flusher        optional flusher to perform cleanup tasks
+     *                       upon call to flush()
+     *
+     * @throws IllegalArgumentException if any parameters of the texture
+     *   data were invalid, such as requesting mipmap generation for a
+     *   compressed texture
+     */
+    public TextureData(GLProfile glp, 
+                       int internalFormat,
+                       int width,
+                       int height,
+                       int border,
+                       int pixelFormat,
+                       int pixelType,
+                       boolean mipmap,
+                       boolean dataIsCompressed,
+                       boolean mustFlipVertically,
+                       Buffer buffer,
+                       Flusher flusher) throws IllegalArgumentException {
+        if (mipmap && dataIsCompressed) {
+            throw new IllegalArgumentException("Can not generate mipmaps for compressed textures");
+        }
+
+        this.glProfile = glp;
+        this.width = width;
+        this.height = height;
+        this.border = border;
+        this.pixelFormat = pixelFormat;
+        this.pixelType = pixelType;
+        this.internalFormat = internalFormat;
+        this.mipmap = mipmap;
+        this.dataIsCompressed = dataIsCompressed;
+        this.mustFlipVertically = mustFlipVertically;
+        this.buffer = buffer;
+        this.flusher = flusher;
+        alignment = 1;  // FIXME: is this correct enough in all situations?
+        estimatedMemorySize = estimatedMemorySize(buffer);
+    }
+
+    /** 
+     * Constructs a new TextureData object with the specified parameters
+     * and data for multiple mipmap levels contained in the given array
+     * of Buffers. The optional Flusher can be used to clean up native
+     * resources associated with this TextureData when processing is
+     * complete; for example, closing of memory-mapped files that might
+     * otherwise require a garbage collection to reclaim and close.
+     *
+     * @param glp the OpenGL Profile this texture data should be
+     *                  created for.
+     * @param internalFormat the OpenGL internal format for the
+     *                       resulting texture; must be specified, may
+     *                       not be 0
+     * @param width          the width in pixels of the topmost mipmap
+     *                       level of the texture
+     * @param height         the height in pixels of the topmost mipmap
+     *                       level of the texture
+     * @param border         the number of pixels of border this texture
+     *                       data has (0 or 1)
+     * @param pixelFormat    the OpenGL pixel format for the
+     *                       resulting texture; must be specified, may
+     *                       not be 0
+     * @param pixelType      the OpenGL type of the pixels of the texture
+     * @param dataIsCompressed indicates whether the texture data is in
+     *                       compressed form
+     *                       (e.g. GL_COMPRESSED_RGB_S3TC_DXT1_EXT)
+     * @param mustFlipVertically indicates whether the texture
+     *                           coordinates must be flipped vertically
+     *                           in order to properly display the
+     *                           texture
+     * @param mipmapData     the buffers containing all mipmap levels
+     *                       of the texture's data
+     * @param flusher        optional flusher to perform cleanup tasks
+     *                       upon call to flush()
+     *
+     * @throws IllegalArgumentException if any parameters of the texture
+     *   data were invalid, such as requesting mipmap generation for a
+     *   compressed texture
+     */
+    public TextureData(GLProfile glp,
+                       int internalFormat,
+                       int width,
+                       int height,
+                       int border,
+                       int pixelFormat,
+                       int pixelType,
+                       boolean dataIsCompressed,
+                       boolean mustFlipVertically,
+                       Buffer[] mipmapData,
+                       Flusher flusher) throws IllegalArgumentException {
+        this.glProfile = glp;
+        this.width = width;
+        this.height = height;
+        this.border = border;
+        this.pixelFormat = pixelFormat;
+        this.pixelType = pixelType;
+        this.internalFormat = internalFormat;
+        this.dataIsCompressed = dataIsCompressed;
+        this.mustFlipVertically = mustFlipVertically;
+        this.mipmapData = (Buffer[]) mipmapData.clone();
+        this.flusher = flusher;
+        alignment = 1;  // FIXME: is this correct enough in all situations?
+        for (int i = 0; i < mipmapData.length; i++) {
+            estimatedMemorySize += estimatedMemorySize(mipmapData[i]);
+        }
+    }
+
+    /** Used only by subclasses */
+    protected TextureData(GLProfile glp) { this.glProfile = glp; }
+
+    /** Returns the width in pixels of the texture data. */
+    public int getWidth() { return width; }
+    /** Returns the height in pixels of the texture data. */
+    public int getHeight() { return height; }
+    /** Returns the border in pixels of the texture data. */
+    public int getBorder() { 
+        return border; 
+    }
+    /** Returns the intended OpenGL pixel format of the texture data. */
+    public int getPixelFormat() {
+        return pixelFormat;
+    }
+    /** Returns the intended OpenGL pixel type of the texture data. */
+    public int getPixelType() {
+        return pixelType;
+    }
+    /** Returns the intended OpenGL internal format of the texture data. */
+    public int getInternalFormat() { 
+        return internalFormat; 
+    }
+    /** Returns whether mipmaps should be generated for the texture data. */
+    public boolean getMipmap() { 
+        return mipmap; 
+    }
+    /** Indicates whether the texture data is in compressed form. */
+    public boolean isDataCompressed() { 
+        return dataIsCompressed; 
+    }
+    /** Indicates whether the texture coordinates must be flipped
+        vertically for proper display. */
+    public boolean getMustFlipVertically() { 
+        return mustFlipVertically; 
+    }
+    /** Returns the texture data, or null if it is specified as a set of mipmaps. */
+    public Buffer getBuffer() {
+        return buffer;
+    }
+    /** Returns all mipmap levels for the texture data, or null if it is
+        specified as a single image. */
+    public Buffer[] getMipmapData() { 
+        return mipmapData; 
+    }
+    /** Returns the required byte alignment for the texture data. */
+    public int getAlignment() { 
+        return alignment; 
+    }
+    /** Returns the row length needed for correct GL_UNPACK_ROW_LENGTH
+        specification. This is currently only supported for
+        non-mipmapped, non-compressed textures. */
+    public int getRowLength() { 
+        return rowLength; 
+    }
+
+    /** Sets the width in pixels of the texture data. */
+    public void setWidth(int width) { this.width = width; }
+    /** Sets the height in pixels of the texture data. */
+    public void setHeight(int height) { this.height = height; }
+    /** Sets the border in pixels of the texture data. */
+    public void setBorder(int border) { this.border = border; }
+    /** Sets the intended OpenGL pixel format of the texture data. */
+    public void setPixelFormat(int pixelFormat) { this.pixelFormat = pixelFormat; }
+    /** Sets the intended OpenGL pixel type of the texture data. */
+    public void setPixelType(int pixelType) { this.pixelType = pixelType; }
+    /** Sets the intended OpenGL internal format of the texture data. */
+    public void setInternalFormat(int internalFormat) { this.internalFormat = internalFormat; }
+    /** Sets whether mipmaps should be generated for the texture data. */
+    public void setMipmap(boolean mipmap) { this.mipmap = mipmap; }
+    /** Sets whether the texture data is in compressed form. */
+    public void setIsDataCompressed(boolean compressed) { this.dataIsCompressed = compressed; }
+    /** Sets whether the texture coordinates must be flipped vertically
+        for proper display. */
+    public void setMustFlipVertically(boolean mustFlipVertically) { this.mustFlipVertically = mustFlipVertically; }
+    /** Sets the texture data. */
+    public void setBuffer(Buffer buffer) {
+        this.buffer = buffer;
+        estimatedMemorySize = estimatedMemorySize(buffer);
+    }
+    /** Sets the required byte alignment for the texture data. */
+    public void setAlignment(int alignment) { this.alignment = alignment; }
+    /** Sets the row length needed for correct GL_UNPACK_ROW_LENGTH
+        specification. This is currently only supported for
+        non-mipmapped, non-compressed textures. */
+    public void setRowLength(int rowLength) { this.rowLength = rowLength; }
+    /** Indicates to this TextureData whether the GL_EXT_abgr extension
+        is available. Used for optimization along some code paths to
+        avoid data copies. */
+    public void setHaveEXTABGR(boolean haveEXTABGR) {
+        this.haveEXTABGR = haveEXTABGR;
+    }
+    /** Indicates to this TextureData whether OpenGL version 1.2 is
+        available. If not, falls back to relatively inefficient code
+        paths for several input data types (several kinds of packed
+        pixel formats, in particular). */
+    public void setHaveGL12(boolean haveGL12) {
+        this.haveGL12 = haveGL12;
+    }
+
+    /** Returns the GLProfile this texture data is intended and created for. */
+    public GLProfile getGLProfile() { return glProfile; }
+
+    /** Returns an estimate of the amount of memory in bytes this
+        TextureData will consume once uploaded to the graphics card. It
+        should only be treated as an estimate; most applications should
+        not need to query this but instead let the OpenGL implementation
+        page textures in and out as necessary. */
+    public int getEstimatedMemorySize() {
+        return estimatedMemorySize;
+    }
+
+    /** Flushes resources associated with this TextureData by calling
+        Flusher.flush(). */
+    public void flush() {
+        if (flusher != null) {
+            flusher.flush();
+            flusher = null;
+        }
+    }
+
+    /** Calls flush()
+     * @see #flush()
+     */
+    public void destroy() {
+        flush();
+    }
+
+    /** Defines a callback mechanism to allow the user to explicitly
+        deallocate native resources (memory-mapped files, etc.)
+        associated with a particular TextureData. */
+    public static interface Flusher {
+        /** Flushes any native resources associated with this
+            TextureData. */
+        public void flush();
+    }
+
+    public String toString() {
+        return "TextureData["+width+"x"+height+", internFormat "+internalFormat+", pixelFormat "+pixelFormat+", pixelType "+pixelType+", border "+border+", estSize "+estimatedMemorySize+", alignment "+alignment+", rowlen "+rowLength;
+    }
+
+    //----------------------------------------------------------------------
+    // Internals only below this point
+    //
+
+    protected static int estimatedMemorySize(Buffer buffer) {
+        if (buffer == null) {
+            return 0;
+        }
+        return buffer.capacity() * BufferUtil.sizeOfBufferElem(buffer);
+    }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/texture/TextureIO.java.javame_cdc_fp b/src/jogl/classes/com/jogamp/opengl/util/texture/TextureIO.java.javame_cdc_fp
new file mode 100755
index 000000000..dbd194d21
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/texture/TextureIO.java.javame_cdc_fp
@@ -0,0 +1,1256 @@
+/*
+ * Copyright (c) 2005 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util.texture;
+
+import java.io.*;
+import java.net.*;
+import java.nio.*;
+import java.util.*;
+
+import javax.media.opengl.*;
+import javax.media.opengl.glu.*;
+import com.jogamp.opengl.impl.Debug;
+import com.jogamp.opengl.util.*;
+import com.jogamp.opengl.util.texture.spi.*;
+
+/** <P> Provides input and output facilities for both loading OpenGL
+    textures from disk and streams as well as writing textures already
+    in memory back to disk. </P>
+
+    <P> The TextureIO class supports an arbitrary number of plug-in
+    readers and writers via TextureProviders and TextureWriters.
+    TextureProviders know how to produce TextureData objects from
+    files, InputStreams and URLs. TextureWriters know how to write
+    TextureData objects to disk in various file formats. The
+    TextureData class represents the raw data of the texture before it
+    has been converted to an OpenGL texture object. The Texture class
+    represents the OpenGL texture object and provides easy facilities
+    for using the texture. </P>
+
+    <P> There are several built-in TextureProviders and TextureWriters
+    supplied with the TextureIO implementation. The most basic
+    provider uses the platform's Image I/O facilities to read in a
+    BufferedImage and convert it to a texture. This is the baseline
+    provider and is registered so that it is the last one consulted.
+    All others are asked first to open a given file. </P>
+
+    <P> There are three other providers registered by default as of
+    the time of this writing. One handles SGI RGB (".sgi", ".rgb")
+    images from both files and streams. One handles DirectDraw Surface
+    (".dds") images read from files, though can not read these images
+    from streams. One handles Targa (".tga") images read from both
+    files and streams. These providers are executed in an arbitrary
+    order. Some of these providers require the file's suffix to either
+    be specified via the newTextureData methods or for the file to be
+    named with the appropriate suffix. In general a file suffix should
+    be provided to the newTexture and newTextureData methods if at all
+    possible. </P>
+
+    <P> Note that additional TextureProviders, if reading images from
+    InputStreams, must use the mark()/reset() methods on InputStream
+    when probing for e.g. magic numbers at the head of the file to
+    make sure not to disturb the state of the InputStream for
+    downstream TextureProviders. </P>
+
+    <P> There are analogous TextureWriters provided for writing
+    textures back to disk if desired. As of this writing, there are
+    four TextureWriters registered by default: one for Targa files,
+    one for SGI RGB files, one for DirectDraw surface (.dds) files,
+    and one for ImageIO-supplied formats such as .jpg and .png.  Some
+    of these writers have certain limitations such as only being able
+    to write out textures stored in GL_RGB or GL_RGBA format. The DDS
+    writer supports fetching and writing to disk of texture data in
+    DXTn compressed format. Whether this will occur is dependent on
+    whether the texture's internal format is one of the DXTn
+    compressed formats and whether the target file is .dds format.
+*/
+
+public class TextureIO {
+    /** Constant which can be used as a file suffix to indicate a
+        DirectDraw Surface file. */
+    public static final String DDS     = "dds";
+
+    /** Constant which can be used as a file suffix to indicate an SGI
+        RGB file. */
+    public static final String SGI     = "sgi";
+
+    /** Constant which can be used as a file suffix to indicate an SGI
+        RGB file. */
+    public static final String SGI_RGB = "rgb";
+
+    /** Constant which can be used as a file suffix to indicate a GIF
+        file. */
+    public static final String GIF     = "gif";
+
+    /** Constant which can be used as a file suffix to indicate a JPEG
+        file. */
+    public static final String JPG     = "jpg";
+
+    /** Constant which can be used as a file suffix to indicate a PNG
+        file. */
+    public static final String PNG     = "png";
+
+    /** Constant which can be used as a file suffix to indicate a Targa
+        file. */
+    public static final String TGA     = "tga";
+
+    /** Constant which can be used as a file suffix to indicate a TIFF
+        file. */
+    public static final String TIFF    = "tiff";
+
+    private static final boolean DEBUG = Debug.debug("TextureIO");
+
+    // For manually disabling the use of the texture rectangle
+    // extensions so you know the texture target is GL_TEXTURE_2D; this
+    // is useful for shader writers (thanks to Chris Campbell for this
+    // observation)
+    private static boolean texRectEnabled = true;
+
+    //----------------------------------------------------------------------
+    // methods that *do not* require a current context
+    // These methods assume RGB or RGBA textures.
+    // Some texture providers may not recognize the file format unless
+    // the fileSuffix is specified, so it is strongly recommended to
+    // specify it wherever it is known.
+    // Some texture providers may also only support one kind of input,
+    // i.e., reading from a file as opposed to a stream.
+
+    /**
+     * Creates a TextureData from the given file. Does no OpenGL work.
+     *
+     * @param glp the OpenGL Profile this texture data should be
+     *                  created for.
+     * @param file the file from which to read the texture data
+     * @param mipmap     whether mipmaps should be produced for this
+     *                   texture either by autogenerating them or
+     *                   reading them from the file. Some file formats
+     *                   support multiple mipmaps in a single file in
+     *                   which case those mipmaps will be used rather
+     *                   than generating them.
+     * @param fileSuffix the suffix of the file name to be used as a
+     *                   hint of the file format to the underlying
+     *                   texture provider, or null if none and should be
+     *                   auto-detected (some texture providers do not
+     *                   support this)
+     * @return the texture data from the file, or null if none of the
+     *         registered texture providers could read the file
+     * @throws IOException if an error occurred while reading the file
+     */
+    public static TextureData newTextureData(GLProfile glp, File file,
+                                             boolean mipmap,
+                                             String fileSuffix) throws IOException {
+        if (fileSuffix == null) {
+            fileSuffix = FileUtil.getFileSuffix(file);
+        }
+        return newTextureDataImpl(glp, file, 0, 0, mipmap, fileSuffix);
+    }
+
+    /**
+     * Creates a TextureData from the given stream. Does no OpenGL work.
+     *
+     * @param glp the OpenGL Profile this texture data should be
+     *                  created for.
+     * @param stream the stream from which to read the texture data
+     * @param mipmap     whether mipmaps should be produced for this
+     *                   texture either by autogenerating them or
+     *                   reading them from the file. Some file formats
+     *                   support multiple mipmaps in a single file in
+     *                   which case those mipmaps will be used rather
+     *                   than generating them.
+     * @param fileSuffix the suffix of the file name to be used as a
+     *                   hint of the file format to the underlying
+     *                   texture provider, or null if none and should be
+     *                   auto-detected (some texture providers do not
+     *                   support this)
+     * @return the texture data from the stream, or null if none of the
+     *         registered texture providers could read the stream
+     * @throws IOException if an error occurred while reading the stream
+     */
+    public static TextureData newTextureData(GLProfile glp, InputStream stream,
+                                             boolean mipmap,
+                                             String fileSuffix) throws IOException {
+        return newTextureDataImpl(glp, stream, 0, 0, mipmap, fileSuffix);
+    }
+
+    /**
+     * Creates a TextureData from the given URL. Does no OpenGL work.
+     *
+     * @param glp the OpenGL Profile this texture data should be
+     *                  created for.
+     * @param url the URL from which to read the texture data
+     * @param mipmap     whether mipmaps should be produced for this
+     *                   texture either by autogenerating them or
+     *                   reading them from the file. Some file formats
+     *                   support multiple mipmaps in a single file in
+     *                   which case those mipmaps will be used rather
+     *                   than generating them.
+     * @param fileSuffix the suffix of the file name to be used as a
+     *                   hint of the file format to the underlying
+     *                   texture provider, or null if none and should be
+     *                   auto-detected (some texture providers do not
+     *                   support this)
+     * @return the texture data from the URL, or null if none of the
+     *         registered texture providers could read the URL
+     * @throws IOException if an error occurred while reading the URL
+     */
+    public static TextureData newTextureData(GLProfile glp, URL url,
+                                             boolean mipmap,
+                                             String fileSuffix) throws IOException {
+        if (fileSuffix == null) {
+            fileSuffix = FileUtil.getFileSuffix(url.getPath());
+        }
+        return newTextureDataImpl(glp, url, 0, 0, mipmap, fileSuffix);
+    }
+
+    //----------------------------------------------------------------------
+    // These methods make no assumption about the OpenGL internal format
+    // or pixel format of the texture; they must be specified by the
+    // user. It is not allowed to supply 0 (indicating no preference)
+    // for either the internalFormat or the pixelFormat;
+    // IllegalArgumentException will be thrown in this case.
+
+    /**
+     * Creates a TextureData from the given file, using the specified
+     * OpenGL internal format and pixel format for the texture which
+     * will eventually result. The internalFormat and pixelFormat must
+     * be specified and may not be zero; to use default values, use the
+     * variant of this method which does not take these arguments. Does
+     * no OpenGL work.
+     *
+     * @param glp the OpenGL Profile this texture data should be
+     *                  created for.
+     * @param file the file from which to read the texture data
+     * @param internalFormat the OpenGL internal format of the texture
+     *                   which will eventually result from the TextureData
+     * @param pixelFormat the OpenGL pixel format of the texture
+     *                    which will eventually result from the TextureData
+     * @param mipmap     whether mipmaps should be produced for this
+     *                   texture either by autogenerating them or
+     *                   reading them from the file. Some file formats
+     *                   support multiple mipmaps in a single file in
+     *                   which case those mipmaps will be used rather
+     *                   than generating them.
+     * @param fileSuffix the suffix of the file name to be used as a
+     *                   hint of the file format to the underlying
+     *                   texture provider, or null if none and should be
+     *                   auto-detected (some texture providers do not
+     *                   support this)
+     * @return the texture data from the file, or null if none of the
+     *         registered texture providers could read the file
+     * @throws IllegalArgumentException if either internalFormat or
+     *                                  pixelFormat was 0
+     * @throws IOException if an error occurred while reading the file
+     */
+    public static TextureData newTextureData(GLProfile glp, File file,
+                                             int internalFormat,
+                                             int pixelFormat,
+                                             boolean mipmap,
+                                             String fileSuffix) throws IOException, IllegalArgumentException {
+        if ((internalFormat == 0) || (pixelFormat == 0)) {
+            throw new IllegalArgumentException("internalFormat and pixelFormat must be non-zero");
+        }
+
+        if (fileSuffix == null) {
+            fileSuffix = FileUtil.getFileSuffix(file);
+        }
+
+        return newTextureDataImpl(glp, file, internalFormat, pixelFormat, mipmap, fileSuffix);
+    }
+
+    /**
+     * Creates a TextureData from the given stream, using the specified
+     * OpenGL internal format and pixel format for the texture which
+     * will eventually result. The internalFormat and pixelFormat must
+     * be specified and may not be zero; to use default values, use the
+     * variant of this method which does not take these arguments. Does
+     * no OpenGL work.
+     *
+     * @param glp the OpenGL Profile this texture data should be
+     *                  created for.
+     * @param stream the stream from which to read the texture data
+     * @param internalFormat the OpenGL internal format of the texture
+     *                   which will eventually result from the TextureData
+     * @param pixelFormat the OpenGL pixel format of the texture
+     *                    which will eventually result from the TextureData
+     * @param mipmap     whether mipmaps should be produced for this
+     *                   texture either by autogenerating them or
+     *                   reading them from the file. Some file formats
+     *                   support multiple mipmaps in a single file in
+     *                   which case those mipmaps will be used rather
+     *                   than generating them.
+     * @param fileSuffix the suffix of the file name to be used as a
+     *                   hint of the file format to the underlying
+     *                   texture provider, or null if none and should be
+     *                   auto-detected (some texture providers do not
+     *                   support this)
+     * @return the texture data from the stream, or null if none of the
+     *         registered texture providers could read the stream
+     * @throws IllegalArgumentException if either internalFormat or
+     *                                  pixelFormat was 0
+     * @throws IOException if an error occurred while reading the stream
+     */
+    public static TextureData newTextureData(GLProfile glp, InputStream stream,
+                                             int internalFormat,
+                                             int pixelFormat,
+                                             boolean mipmap,
+                                             String fileSuffix) throws IOException, IllegalArgumentException {
+        if ((internalFormat == 0) || (pixelFormat == 0)) {
+            throw new IllegalArgumentException("internalFormat and pixelFormat must be non-zero");
+        }
+
+        return newTextureDataImpl(glp, stream, internalFormat, pixelFormat, mipmap, fileSuffix);
+    }
+
+    /**
+     * Creates a TextureData from the given URL, using the specified
+     * OpenGL internal format and pixel format for the texture which
+     * will eventually result. The internalFormat and pixelFormat must
+     * be specified and may not be zero; to use default values, use the
+     * variant of this method which does not take these arguments. Does
+     * no OpenGL work.
+     *
+     * @param glp the OpenGL Profile this texture data should be
+     *                  created for.
+     * @param url the URL from which to read the texture data
+     * @param internalFormat the OpenGL internal format of the texture
+     *                   which will eventually result from the TextureData
+     * @param pixelFormat the OpenGL pixel format of the texture
+     *                    which will eventually result from the TextureData
+     * @param mipmap     whether mipmaps should be produced for this
+     *                   texture either by autogenerating them or
+     *                   reading them from the file. Some file formats
+     *                   support multiple mipmaps in a single file in
+     *                   which case those mipmaps will be used rather
+     *                   than generating them.
+     * @param fileSuffix the suffix of the file name to be used as a
+     *                   hint of the file format to the underlying
+     *                   texture provider, or null if none and should be
+     *                   auto-detected (some texture providers do not
+     *                   support this)
+     * @return the texture data from the URL, or null if none of the
+     *         registered texture providers could read the URL
+     * @throws IllegalArgumentException if either internalFormat or
+     *                                  pixelFormat was 0
+     * @throws IOException if an error occurred while reading the URL
+     */
+    public static TextureData newTextureData(GLProfile glp, URL url,
+                                             int internalFormat,
+                                             int pixelFormat,
+                                             boolean mipmap,
+                                             String fileSuffix) throws IOException, IllegalArgumentException {
+        if ((internalFormat == 0) || (pixelFormat == 0)) {
+            throw new IllegalArgumentException("internalFormat and pixelFormat must be non-zero");
+        }
+
+        if (fileSuffix == null) {
+            fileSuffix = FileUtil.getFileSuffix(url.getPath());
+        }
+
+        return newTextureDataImpl(glp, url, internalFormat, pixelFormat, mipmap, fileSuffix);
+    }
+
+    //----------------------------------------------------------------------
+    // methods that *do* require a current context
+    //
+
+    /** 
+     * Creates an OpenGL texture object from the specified TextureData
+     * using the current OpenGL context.
+     *
+     * @param data the texture data to turn into an OpenGL texture
+     * @throws GLException if no OpenGL context is current or if an
+     *                     OpenGL error occurred
+     * @throws IllegalArgumentException if the passed TextureData was null
+     */
+    public static Texture newTexture(TextureData data) throws GLException, IllegalArgumentException {
+        if (data == null) {
+            throw new IllegalArgumentException("Null TextureData");
+        }
+        return new Texture(data);
+    }
+
+    /** 
+     * Creates an OpenGL texture object from the specified file using
+     * the current OpenGL context.
+     *
+     * @param file the file from which to read the texture data
+     * @param mipmap     whether mipmaps should be produced for this
+     *                   texture either by autogenerating them or
+     *                   reading them from the file. Some file formats
+     *                   support multiple mipmaps in a single file in
+     *                   which case those mipmaps will be used rather
+     *                   than generating them.
+     * @throws IOException if an error occurred while reading the file
+     * @throws GLException if no OpenGL context is current or if an
+     *                     OpenGL error occurred
+     */
+    public static Texture newTexture(File file, boolean mipmap) throws IOException, GLException {
+        GLProfile glp = GLContext.getCurrentGL().getGLProfile();
+        TextureData data = newTextureData(glp, file, mipmap, FileUtil.getFileSuffix(file));
+        Texture texture = newTexture(data);
+        data.flush();
+        return texture;
+    }
+
+    /** 
+     * Creates an OpenGL texture object from the specified stream using
+     * the current OpenGL context.
+     *
+     * @param stream the stream from which to read the texture data
+     * @param mipmap     whether mipmaps should be produced for this
+     *                   texture either by autogenerating them or
+     *                   reading them from the file. Some file formats
+     *                   support multiple mipmaps in a single file in
+     *                   which case those mipmaps will be used rather
+     *                   than generating them.
+     * @param fileSuffix the suffix of the file name to be used as a
+     *                   hint of the file format to the underlying
+     *                   texture provider, or null if none and should be
+     *                   auto-detected (some texture providers do not
+     *                   support this)
+     * @throws IOException if an error occurred while reading the stream
+     * @throws GLException if no OpenGL context is current or if an
+     *                     OpenGL error occurred
+     */
+    public static Texture newTexture(InputStream stream, boolean mipmap, String fileSuffix) throws IOException, GLException {
+        GLProfile glp = GLContext.getCurrentGL().getGLProfile();
+        TextureData data = newTextureData(glp, stream, mipmap, fileSuffix);
+        Texture texture = newTexture(data);
+        data.flush();
+        return texture;
+    }
+
+    /** 
+     * Creates an OpenGL texture object from the specified URL using the
+     * current OpenGL context.
+     *
+     * @param url the URL from which to read the texture data
+     * @param mipmap     whether mipmaps should be produced for this
+     *                   texture either by autogenerating them or
+     *                   reading them from the file. Some file formats
+     *                   support multiple mipmaps in a single file in
+     *                   which case those mipmaps will be used rather
+     *                   than generating them.
+     * @param fileSuffix the suffix of the file name to be used as a
+     *                   hint of the file format to the underlying
+     *                   texture provider, or null if none and should be
+     *                   auto-detected (some texture providers do not
+     *                   support this)
+     * @throws IOException if an error occurred while reading the URL
+     * @throws GLException if no OpenGL context is current or if an
+     *                     OpenGL error occurred
+     */
+    public static Texture newTexture(URL url, boolean mipmap, String fileSuffix) throws IOException, GLException {
+        if (fileSuffix == null) {
+            fileSuffix = FileUtil.getFileSuffix(url.getPath());
+        }
+        GLProfile glp = GLContext.getCurrentGL().getGLProfile();
+        TextureData data = newTextureData(glp, url, mipmap, fileSuffix);
+        Texture texture = newTexture(data);
+        data.flush();
+        return texture;
+    }
+
+    /** 
+     * Creates an OpenGL texture object associated with the given OpenGL
+     * texture target using the current OpenGL context. The texture has
+     * no initial data. This is used, for example, to construct cube
+     * maps out of multiple TextureData objects.
+     *
+     * @param target the OpenGL target type, eg GL.GL_TEXTURE_2D, 
+     *               GL.GL_TEXTURE_RECTANGLE_ARB
+     *
+     * @throws GLException if no OpenGL context is current or if an
+     *                     OpenGL error occurred
+     */
+    public static Texture newTexture(int target) throws GLException {
+        return new Texture(target);
+    }
+
+    /**
+     * Wraps an OpenGL texture ID from an external library and allows
+     * some of the base methods from the Texture class, such as
+     * binding and querying of texture coordinates, to be used with
+     * it. Attempts to update such textures' contents will yield
+     * undefined results.
+     *
+     * @param textureID the OpenGL texture object to wrap
+     * @param target the OpenGL texture target, eg GL.GL_TEXTURE_2D, 
+     *               GL2.GL_TEXTURE_RECTANGLE
+     * @param texWidth the width of the texture in pixels
+     * @param texHeight the height of the texture in pixels
+     * @param imgWidth the width of the image within the texture in
+     *          pixels (if the content is a sub-rectangle in the upper
+     *          left corner); otherwise, pass in texWidth
+     * @param imgHeight the height of the image within the texture in
+     *          pixels (if the content is a sub-rectangle in the upper
+     *          left corner); otherwise, pass in texHeight
+     * @param mustFlipVertically indicates whether the texture
+     *                           coordinates must be flipped vertically
+     *                           in order to properly display the
+     *                           texture
+     */
+    public static Texture newTexture(int textureID,
+				     int target,
+				     int texWidth,
+				     int texHeight,
+				     int imgWidth,
+				     int imgHeight,
+				     boolean mustFlipVertically) {
+	return new Texture(textureID,
+			   target,
+			   texWidth,
+			   texHeight,
+			   imgWidth,
+			   imgHeight,
+			   mustFlipVertically);
+    }
+
+    /**
+     * Writes the given texture to a file. The type of the file is
+     * inferred from its suffix. An OpenGL context must be current in
+     * order to fetch the texture data back from the OpenGL pipeline.
+     * This method causes the specified Texture to be bound to the
+     * GL_TEXTURE_2D state. If no suitable writer for the requested file
+     * format was found, throws an IOException. <P>
+     *
+     * Reasonable attempts are made to produce good results in the
+     * resulting images. The Targa, SGI and ImageIO writers produce
+     * results in the correct vertical orientation for those file
+     * formats. The DDS writer performs no vertical flip of the data,
+     * even in uncompressed mode. (It is impossible to perform such a
+     * vertical flip with compressed data.) Applications should keep
+     * this in mind when using this routine to save textures to disk for
+     * later re-loading. <P>
+     *
+     * Any mipmaps for the specified texture are currently discarded
+     * when it is written to disk, regardless of whether the underlying
+     * file format supports multiple mipmaps in a given file.
+     *
+     * @throws IOException if an error occurred during writing or no
+     *   suitable writer was found
+     * @throws GLException if no OpenGL context was current or an
+     *   OpenGL-related error occurred
+     */
+    public static void write(Texture texture, File file) throws IOException, GLException {
+        if (texture.getTarget() != GL.GL_TEXTURE_2D) {
+            throw new GLException("Only GL_TEXTURE_2D textures are supported");
+        }
+
+        // First fetch the texture data
+        GL _gl = GLContext.getCurrentGL();
+        if (!_gl.isGL2()) {
+            throw new GLException("Only GL2 supports fetching compressed images, GL: " + _gl);
+        }
+        GL2 gl = _gl.getGL2();
+
+        texture.bind();
+        int internalFormat = glGetTexLevelParameteri(gl, GL.GL_TEXTURE_2D, 0, GL2.GL_TEXTURE_INTERNAL_FORMAT);
+        int width  = glGetTexLevelParameteri(gl, GL.GL_TEXTURE_2D, 0, GL2.GL_TEXTURE_WIDTH);
+        int height = glGetTexLevelParameteri(gl, GL.GL_TEXTURE_2D, 0, GL2.GL_TEXTURE_HEIGHT);
+        int border = glGetTexLevelParameteri(gl, GL.GL_TEXTURE_2D, 0, GL2.GL_TEXTURE_BORDER);
+        TextureData data = null;
+        if (internalFormat == GL.GL_COMPRESSED_RGB_S3TC_DXT1_EXT ||
+            internalFormat == GL.GL_COMPRESSED_RGBA_S3TC_DXT1_EXT ||
+            internalFormat == GL.GL_COMPRESSED_RGBA_S3TC_DXT3_EXT ||
+            internalFormat == GL.GL_COMPRESSED_RGBA_S3TC_DXT5_EXT) {
+            // Fetch using glGetCompressedTexImage
+            int size   = glGetTexLevelParameteri(gl, GL.GL_TEXTURE_2D, 0, GL2.GL_TEXTURE_COMPRESSED_IMAGE_SIZE);
+            ByteBuffer res = ByteBuffer.wrap(new byte[size]);
+            gl.glGetCompressedTexImage(GL.GL_TEXTURE_2D, 0, res);
+            data = new TextureData(gl.getGLProfile(), internalFormat, width, height, border, internalFormat, GL.GL_UNSIGNED_BYTE,
+                                   false, true, true, res, null);
+        } else {
+            int bytesPerPixel = 0;
+            int fetchedFormat = 0;
+            switch (internalFormat) {
+            case GL.GL_RGB:
+            case GL2.GL_BGR:
+            case GL.GL_RGB8:
+                bytesPerPixel = 3;
+                fetchedFormat = GL.GL_RGB;
+                break;
+            case GL.GL_RGBA:
+            case GL2.GL_BGRA:
+            case GL2.GL_ABGR_EXT:
+            case GL.GL_RGBA8:
+                bytesPerPixel = 4;
+                fetchedFormat = GL.GL_RGBA;
+                break;
+            default:
+                throw new IOException("Unsupported texture internal format 0x" + Integer.toHexString(internalFormat));
+            }
+
+            // Fetch using glGetTexImage
+            int packAlignment  = glGetInteger(GL.GL_PACK_ALIGNMENT);
+            int packRowLength  = glGetInteger(GL2.GL_PACK_ROW_LENGTH);
+            int packSkipRows   = glGetInteger(GL2.GL_PACK_SKIP_ROWS);
+            int packSkipPixels = glGetInteger(GL2.GL_PACK_SKIP_PIXELS);
+            int packSwapBytes  = glGetInteger(GL2.GL_PACK_SWAP_BYTES);
+
+            gl.glPixelStorei(GL.GL_PACK_ALIGNMENT, 1);
+            gl.glPixelStorei(GL2.GL_PACK_ROW_LENGTH, 0);
+            gl.glPixelStorei(GL2.GL_PACK_SKIP_ROWS, 0);
+            gl.glPixelStorei(GL2.GL_PACK_SKIP_PIXELS, 0);
+            gl.glPixelStorei(GL2.GL_PACK_SWAP_BYTES, 0);
+
+            ByteBuffer res = ByteBuffer.wrap(new byte[(width + (2 * border)) *
+                                                      (height + (2 * border)) *
+                                                      bytesPerPixel]);
+            if (DEBUG) {
+                System.out.println("Allocated buffer of size " + res.remaining() + " for fetched image (" +
+                                   ((fetchedFormat == GL.GL_RGB) ? "GL_RGB" : "GL_RGBA") + ")");
+            }
+            gl.glGetTexImage(GL.GL_TEXTURE_2D, 0, fetchedFormat, GL.GL_UNSIGNED_BYTE, res);
+
+            gl.glPixelStorei(GL.GL_PACK_ALIGNMENT, packAlignment);
+            gl.glPixelStorei(GL2.GL_PACK_ROW_LENGTH, packRowLength);
+            gl.glPixelStorei(GL2.GL_PACK_SKIP_ROWS, packSkipRows);
+            gl.glPixelStorei(GL2.GL_PACK_SKIP_PIXELS, packSkipPixels);
+            gl.glPixelStorei(GL2.GL_PACK_SWAP_BYTES, packSwapBytes);
+      
+            data = new TextureData(gl.getGLProfile(), internalFormat, width, height, border, fetchedFormat, GL.GL_UNSIGNED_BYTE,
+                                   false, false, false, res, null);
+
+            if (DEBUG) {
+                System.out.println("data.getPixelFormat() = " +
+                                   ((data.getPixelFormat() == GL.GL_RGB) ? "GL_RGB" : "GL_RGBA"));
+            }
+        }
+
+        write(data, file);
+    }
+  
+    public static void write(TextureData data, File file) throws IOException, GLException {
+        for (Iterator iter = textureWriters.iterator(); iter.hasNext(); ) {
+            TextureWriter writer = (TextureWriter) iter.next();
+            if (writer.write(file, data)) {
+                return;
+            }
+        }
+
+        throw new IOException("No suitable texture writer found for "+file.getAbsolutePath());
+    }
+
+    //----------------------------------------------------------------------
+    // SPI support
+    //
+
+    /** Adds a TextureProvider to support reading of a new file
+        format. */
+    public static void addTextureProvider(TextureProvider provider) {
+        // Must always add at the front so the ImageIO provider is last,
+        // so we don't accidentally use it instead of a user's possibly
+        // more optimal provider
+        textureProviders.add(0, provider);
+    }
+
+    /** Adds a TextureWriter to support writing of a new file
+        format. */
+    public static void addTextureWriter(TextureWriter writer) {
+        // Must always add at the front so the ImageIO writer is last,
+        // so we don't accidentally use it instead of a user's possibly
+        // more optimal writer
+        textureWriters.add(0, writer);
+    }
+
+    //---------------------------------------------------------------------------
+    // Global disabling of texture rectangle extension
+    //
+
+    /** Toggles the use of the GL_ARB_texture_rectangle extension by the
+        TextureIO classes. By default, on hardware supporting this
+        extension, the TextureIO classes may use the
+        GL_ARB_texture_rectangle extension for non-power-of-two
+        textures. (If the hardware supports the
+        GL_ARB_texture_non_power_of_two extension, that one is
+        preferred.) In some situations, for example when writing
+        shaders, it is advantageous to force the texture target to
+        always be GL_TEXTURE_2D in order to have one version of the
+        shader, even at the expense of texture memory in the case where
+        NPOT textures are not supported. This method allows the use of
+        the GL_ARB_texture_rectangle extension to be turned off globally
+        for this purpose. The default is that the use of the extension
+        is enabled. */
+    public static void setTexRectEnabled(boolean enabled) {
+        texRectEnabled = enabled;
+    }
+
+    /** Indicates whether the GL_ARB_texture_rectangle extension is
+        allowed to be used for non-power-of-two textures; see {@link
+        #setTexRectEnabled setTexRectEnabled}. */
+    public static boolean isTexRectEnabled() {
+        return texRectEnabled;
+    }
+
+    //----------------------------------------------------------------------
+    // Internals only below this point
+    //
+
+    private static List/*<TextureProvider>*/ textureProviders = new ArrayList/*<TextureProvider>*/();
+    private static List/*<TextureWriter>*/   textureWriters   = new ArrayList/*<TextureWriter>*/();
+
+    static {
+        /*
+        if(GLProfile.isAWTJOGLAvailable()) {
+            // ImageIO provider, the fall-back, must be the first one added
+            try {
+                // Use reflection to avoid compile-time dependencies on AWT-related classes
+                TextureProvider provider = (TextureProvider)
+                    Class.forName("com.jogamp.opengl.util.texture.spi.awt.IIOTextureProvider").newInstance();
+                addTextureProvider(provider);
+            } catch (Exception e) {
+                if (DEBUG) {
+                    e.printStackTrace();
+                }
+            }
+        }
+        */
+
+        // Other special-case providers
+        addTextureProvider(new DDSTextureProvider());
+        addTextureProvider(new SGITextureProvider());
+        addTextureProvider(new TGATextureProvider());
+
+        /*
+        // ImageIO writer, the fall-back, must be the first one added
+        if(GLProfile.isAWTJOGLAvailable()) {
+            try {
+                // Use reflection to avoid compile-time dependencies on AWT-related classes
+                TextureWriter writer = (TextureWriter)
+                    Class.forName("com.jogamp.opengl.util.texture.spi.awt.IIOTextureWriter").newInstance();
+                addTextureWriter(writer);
+            } catch (Exception e) {
+                if (DEBUG) {
+                    e.printStackTrace();
+                }
+            }
+        }
+        */
+
+        // Other special-case writers
+        addTextureWriter(new DDSTextureWriter());
+        addTextureWriter(new SGITextureWriter());
+        addTextureWriter(new TGATextureWriter());
+        addTextureWriter(new NetPbmTextureWriter());
+    }
+
+    // Implementation methods
+    private static TextureData newTextureDataImpl(GLProfile glp, File file,
+                                                  int internalFormat,
+                                                  int pixelFormat,
+                                                  boolean mipmap,
+                                                  String fileSuffix) throws IOException {
+        if (file == null) {
+            throw new IOException("File was null");
+        }
+
+        fileSuffix = toLowerCase(fileSuffix);
+
+        for (Iterator iter = textureProviders.iterator(); iter.hasNext(); ) {
+            TextureProvider provider = (TextureProvider) iter.next();
+            TextureData data = provider.newTextureData(glp, file,
+                                                       internalFormat,
+                                                       pixelFormat,
+                                                       mipmap,
+                                                       fileSuffix);
+            if (data != null) {
+                return data;
+            }
+        }
+
+        throw new IOException("No suitable reader for given file "+file.getAbsolutePath());
+    }
+
+    private static TextureData newTextureDataImpl(GLProfile glp, InputStream stream,
+                                                  int internalFormat,
+                                                  int pixelFormat,
+                                                  boolean mipmap,
+                                                  String fileSuffix) throws IOException {
+        if (stream == null) {
+            throw new IOException("Stream was null");
+        }
+
+        fileSuffix = toLowerCase(fileSuffix);
+
+        // Note: use of BufferedInputStream works around 4764639/4892246
+        if (!(stream instanceof BufferedInputStream)) {
+            stream = new BufferedInputStream(stream);
+        }
+
+        for (Iterator iter = textureProviders.iterator(); iter.hasNext(); ) {
+            TextureProvider provider = (TextureProvider) iter.next();
+            TextureData data = provider.newTextureData(glp, stream,
+                                                       internalFormat,
+                                                       pixelFormat,
+                                                       mipmap,
+                                                       fileSuffix);
+            if (data != null) {
+                return data;
+            }
+        }
+
+        throw new IOException("No suitable reader for given stream");
+    }
+
+    private static TextureData newTextureDataImpl(GLProfile glp, URL url,
+                                                  int internalFormat,
+                                                  int pixelFormat,
+                                                  boolean mipmap,
+                                                  String fileSuffix) throws IOException {
+        if (url == null) {
+            throw new IOException("URL was null");
+        }
+
+        fileSuffix = toLowerCase(fileSuffix);
+
+        for (Iterator iter = textureProviders.iterator(); iter.hasNext(); ) {
+            TextureProvider provider = (TextureProvider) iter.next();
+            TextureData data = provider.newTextureData(glp, url,
+                                                       internalFormat,
+                                                       pixelFormat,
+                                                       mipmap,
+                                                       fileSuffix);
+            if (data != null) {
+                return data;
+            }
+        }
+
+        throw new IOException("No suitable reader for given URL "+url);
+    }
+
+    //----------------------------------------------------------------------
+    // DDS provider -- supports files only for now
+    static class DDSTextureProvider implements TextureProvider {
+        public TextureData newTextureData(GLProfile glp, File file,
+                                          int internalFormat,
+                                          int pixelFormat,
+                                          boolean mipmap,
+                                          String fileSuffix) throws IOException {
+            if (DDS.equals(fileSuffix) ||
+                DDS.equals(FileUtil.getFileSuffix(file))) {
+                DDSImage image = DDSImage.read(file);
+                return newTextureData(glp, image, internalFormat, pixelFormat, mipmap);
+            }
+
+            return null;
+        }
+
+        public TextureData newTextureData(GLProfile glp, InputStream stream,
+                                          int internalFormat,
+                                          int pixelFormat,
+                                          boolean mipmap,
+                                          String fileSuffix) throws IOException {
+            if (DDS.equals(fileSuffix) ||
+                DDSImage.isDDSImage(stream)) {
+                DDSImage image = DDSImage.read(stream);
+                return newTextureData(glp, image, internalFormat, pixelFormat, mipmap);
+            }
+
+            return null;
+        }
+
+        public TextureData newTextureData(GLProfile glp, URL url,
+                                          int internalFormat,
+                                          int pixelFormat,
+                                          boolean mipmap,
+                                          String fileSuffix) throws IOException {
+            InputStream stream = new BufferedInputStream(url.openStream());
+            try {
+                return newTextureData(glp, stream, internalFormat, pixelFormat, mipmap, fileSuffix);
+            } finally {
+                stream.close();
+            }
+        }
+
+        private TextureData newTextureData(GLProfile glp, final DDSImage image,
+                                           int internalFormat,
+                                           int pixelFormat,
+                                           boolean mipmap) {
+            DDSImage.ImageInfo info = image.getMipMap(0);
+            if (pixelFormat == 0) {
+                switch (image.getPixelFormat()) {
+                case DDSImage.D3DFMT_R8G8B8:
+                    pixelFormat = GL.GL_RGB;
+                    break;
+                default:
+                    pixelFormat = GL.GL_RGBA;
+                    break;
+                }
+            }
+            if (info.isCompressed()) {
+                switch (info.getCompressionFormat()) {
+                case DDSImage.D3DFMT_DXT1:
+                    internalFormat = GL.GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
+                    break;
+                case DDSImage.D3DFMT_DXT3:
+                    internalFormat = GL.GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
+                    break;
+                case DDSImage.D3DFMT_DXT5:
+                    internalFormat = GL.GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
+                    break;
+                default:
+                    throw new RuntimeException("Unsupported DDS compression format \"" +
+                                               DDSImage.getCompressionFormatName(info.getCompressionFormat()) + "\"");
+                }
+            }
+            if (internalFormat == 0) {
+                switch (image.getPixelFormat()) {
+                case DDSImage.D3DFMT_R8G8B8:
+                    pixelFormat = GL.GL_RGB;
+                    break;
+                default:
+                    pixelFormat = GL.GL_RGBA;
+                    break;
+                }
+            }
+            TextureData.Flusher flusher = new TextureData.Flusher() {
+                    public void flush() {
+                        image.close();
+                    }
+                };
+            TextureData data;
+            if (mipmap && image.getNumMipMaps() > 0) {
+                Buffer[] mipmapData = new Buffer[image.getNumMipMaps()];
+                for (int i = 0; i < image.getNumMipMaps(); i++) {
+                    mipmapData[i] = image.getMipMap(i).getData();
+                }
+                data = new TextureData(glp, internalFormat,
+                                       info.getWidth(),
+                                       info.getHeight(),
+                                       0,
+                                       pixelFormat,
+                                       GL.GL_UNSIGNED_BYTE,
+                                       info.isCompressed(),
+                                       true,
+                                       mipmapData,
+                                       flusher);
+            } else {
+                // Fix this up for the end user because we can't generate
+                // mipmaps for compressed textures
+                mipmap = false;
+                data = new TextureData(glp, internalFormat,
+                                       info.getWidth(),
+                                       info.getHeight(),
+                                       0,
+                                       pixelFormat,
+                                       GL.GL_UNSIGNED_BYTE,
+                                       mipmap,
+                                       info.isCompressed(),
+                                       true,
+                                       info.getData(),
+                                       flusher);
+            }
+            return data;
+        }
+    }
+
+    //----------------------------------------------------------------------
+    // Base class for SGI RGB and TGA image providers
+    static abstract class StreamBasedTextureProvider implements TextureProvider {
+        public TextureData newTextureData(GLProfile glp, File file,
+                                          int internalFormat,
+                                          int pixelFormat,
+                                          boolean mipmap,
+                                          String fileSuffix) throws IOException {
+            InputStream inStream = new BufferedInputStream(new FileInputStream(file));
+            try {
+                // The SGIImage and TGAImage implementations use InputStreams
+                // anyway so there isn't much point in having a separate code
+                // path for files
+                return newTextureData(glp, inStream,
+                                      internalFormat,
+                                      pixelFormat,
+                                      mipmap,
+                                      ((fileSuffix != null) ? fileSuffix : FileUtil.getFileSuffix(file)));
+            } finally {
+                inStream.close();
+            }
+        }
+
+        public TextureData newTextureData(GLProfile glp, URL url,
+                                          int internalFormat,
+                                          int pixelFormat,
+                                          boolean mipmap,
+                                          String fileSuffix) throws IOException {
+            InputStream stream = new BufferedInputStream(url.openStream());
+            try {
+                return newTextureData(glp, stream, internalFormat, pixelFormat, mipmap, fileSuffix);
+            } finally {
+                stream.close();
+            }
+        }
+    }
+
+    //----------------------------------------------------------------------
+    // SGI RGB image provider
+    static class SGITextureProvider extends StreamBasedTextureProvider {
+        public TextureData newTextureData(GLProfile glp, InputStream stream,
+                                          int internalFormat,
+                                          int pixelFormat,
+                                          boolean mipmap,
+                                          String fileSuffix) throws IOException {
+            if (SGI.equals(fileSuffix) ||
+                SGI_RGB.equals(fileSuffix) ||
+                SGIImage.isSGIImage(stream)) {
+                SGIImage image = SGIImage.read(stream);
+                if (pixelFormat == 0) {
+                    pixelFormat = image.getFormat();
+                }
+                if (internalFormat == 0) {
+                    internalFormat = image.getFormat();
+                }
+                return new TextureData(glp, internalFormat,
+                                       image.getWidth(),
+                                       image.getHeight(),
+                                       0,
+                                       pixelFormat,
+                                       GL.GL_UNSIGNED_BYTE,
+                                       mipmap,
+                                       false,
+                                       false,
+                                       ByteBuffer.wrap(image.getData()),
+                                       null);
+            }
+
+            return null;
+        }
+    }
+
+    //----------------------------------------------------------------------
+    // TGA (Targa) image provider
+    static class TGATextureProvider extends StreamBasedTextureProvider {
+        public TextureData newTextureData(GLProfile glp, InputStream stream,
+                                          int internalFormat,
+                                          int pixelFormat,
+                                          boolean mipmap,
+                                          String fileSuffix) throws IOException {
+            if (TGA.equals(fileSuffix)) {
+                TGAImage image = TGAImage.read(stream);
+                if (pixelFormat == 0) {
+                    pixelFormat = image.getGLFormat();
+                }
+                if (internalFormat == 0) {
+                    GL gl = GLContext.getCurrentGL();
+                    if(gl.isGL2()) {
+                        internalFormat = GL.GL_RGBA8;
+                    } else {
+                        internalFormat = (image.getBytesPerPixel()==4)?GL.GL_RGBA:GL.GL_RGB;
+                    }
+                }
+                return new TextureData(glp, internalFormat,
+                                       image.getWidth(),
+                                       image.getHeight(),
+                                       0,
+                                       pixelFormat,
+                                       GL.GL_UNSIGNED_BYTE,
+                                       mipmap,
+                                       false,
+                                       false,
+                                       image.getData(),
+                                       null);
+            }
+
+            return null;
+        }
+    }
+
+    //----------------------------------------------------------------------
+    // DDS texture writer
+    //
+    static class DDSTextureWriter implements TextureWriter {
+        public boolean write(File file,
+                             TextureData data) throws IOException {
+            if (DDS.equals(FileUtil.getFileSuffix(file))) {
+                // See whether the DDS writer can handle this TextureData
+                int pixelFormat = data.getPixelFormat();
+                int pixelType   = data.getPixelType();
+                if (pixelType != GL.GL_BYTE &&
+                    pixelType != GL.GL_UNSIGNED_BYTE) {
+                    throw new IOException("DDS writer only supports byte / unsigned byte textures");
+                }
+
+                int d3dFormat = 0;
+                // FIXME: some of these are probably not completely correct and would require swizzling
+                switch (pixelFormat) {
+                case GL.GL_RGB:                        d3dFormat = DDSImage.D3DFMT_R8G8B8; break;
+                case GL.GL_RGBA:                       d3dFormat = DDSImage.D3DFMT_A8R8G8B8; break;
+                case GL.GL_COMPRESSED_RGB_S3TC_DXT1_EXT:  d3dFormat = DDSImage.D3DFMT_DXT1; break;
+                case GL.GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: throw new IOException("RGBA DXT1 not yet supported");
+                case GL.GL_COMPRESSED_RGBA_S3TC_DXT3_EXT: d3dFormat = DDSImage.D3DFMT_DXT3; break;
+                case GL.GL_COMPRESSED_RGBA_S3TC_DXT5_EXT: d3dFormat = DDSImage.D3DFMT_DXT5; break;
+                default: throw new IOException("Unsupported pixel format 0x" + Integer.toHexString(pixelFormat) + " by DDS writer");
+                }
+        
+                ByteBuffer[] mipmaps = null;
+                if (data.getMipmapData() != null) {
+                    mipmaps = new ByteBuffer[data.getMipmapData().length];
+                    for (int i = 0; i < mipmaps.length; i++) {
+                        mipmaps[i] = (ByteBuffer) data.getMipmapData()[i];
+                    }
+                } else {
+                    mipmaps = new ByteBuffer[] { (ByteBuffer) data.getBuffer() };
+                }
+
+                DDSImage image = DDSImage.createFromData(d3dFormat,
+                                                         data.getWidth(),
+                                                         data.getHeight(),
+                                                         mipmaps);
+                image.write(file);
+                return true;
+            }
+
+            return false;
+        }
+    }
+
+    //----------------------------------------------------------------------
+    // SGI (rgb) texture writer
+    //
+    static class SGITextureWriter implements TextureWriter {
+        public boolean write(File file,
+                             TextureData data) throws IOException {
+            String fileSuffix = FileUtil.getFileSuffix(file);
+            if (SGI.equals(fileSuffix) ||
+                SGI_RGB.equals(fileSuffix)) {
+                // See whether the SGI writer can handle this TextureData
+                int pixelFormat = data.getPixelFormat();
+                int pixelType   = data.getPixelType();
+                if ((pixelFormat == GL.GL_RGB ||
+                     pixelFormat == GL.GL_RGBA) &&
+                    (pixelType == GL.GL_BYTE ||
+                     pixelType == GL.GL_UNSIGNED_BYTE)) {
+                    ByteBuffer buf = ((data.getBuffer() != null) ?
+                                      (ByteBuffer) data.getBuffer() :
+                                      (ByteBuffer) data.getMipmapData()[0]);
+                    byte[] bytes;
+                    if (buf.hasArray()) {
+                        bytes = buf.array();
+                    } else {
+                        buf.rewind();
+                        bytes = new byte[buf.remaining()];
+                        buf.get(bytes);
+                        buf.rewind();
+                    }
+
+                    SGIImage image = SGIImage.createFromData(data.getWidth(),
+                                                             data.getHeight(),
+                                                             (pixelFormat == GL.GL_RGBA),
+                                                             bytes);
+                    image.write(file, false);
+                    return true;
+                }
+
+                throw new IOException("SGI writer doesn't support this pixel format / type (only GL_RGB/A + bytes)");
+            }
+
+            return false;
+        }
+    }
+
+    //----------------------------------------------------------------------
+    // TGA (Targa) texture writer
+  
+    static class TGATextureWriter implements TextureWriter {
+        public boolean write(File file,
+                             TextureData data) throws IOException {
+            if (TGA.equals(FileUtil.getFileSuffix(file))) {
+                // See whether the TGA writer can handle this TextureData
+                int pixelFormat = data.getPixelFormat();
+                int pixelType   = data.getPixelType();
+                if ((pixelFormat == GL.GL_RGB ||
+                     pixelFormat == GL.GL_RGBA) &&
+                    (pixelType == GL.GL_BYTE ||
+                     pixelType == GL.GL_UNSIGNED_BYTE)) {
+                    ByteBuffer buf = ((data.getBuffer() != null) ?
+                                      (ByteBuffer) data.getBuffer() :
+                                      (ByteBuffer) data.getMipmapData()[0]);
+                    // Must reverse order of red and blue channels to get correct results
+                    int skip = ((pixelFormat == GL.GL_RGB) ? 3 : 4);
+                    for (int i = 0; i < buf.remaining(); i += skip) {
+                        byte red  = buf.get(i + 0);
+                        byte blue = buf.get(i + 2);
+                        buf.put(i + 0, blue);
+                        buf.put(i + 2, red);
+                    }
+
+                    TGAImage image = TGAImage.createFromData(data.getWidth(),
+                                                             data.getHeight(),
+                                                             (pixelFormat == GL.GL_RGBA),
+                                                             false,
+                                                             ((data.getBuffer() != null) ?
+                                                              (ByteBuffer) data.getBuffer() :
+                                                              (ByteBuffer) data.getMipmapData()[0]));
+                    image.write(file);
+                    return true;
+                }
+
+                throw new IOException("TGA writer doesn't support this pixel format / type (only GL_RGB/A + bytes)");
+            }
+
+            return false;
+        }    
+    }
+
+    //----------------------------------------------------------------------
+    // Helper routines
+    //
+
+    private static int glGetInteger(int pname) {
+        int[] tmp = new int[1];
+        GL gl = GLContext.getCurrentGL();
+        gl.glGetIntegerv(pname, tmp, 0);
+        return tmp[0];
+    }
+
+    private static int glGetTexLevelParameteri(GL2 gl, int target, int level, int pname) {
+        int[] tmp = new int[1];
+        gl.glGetTexLevelParameteriv(target, 0, pname, tmp, 0);
+        return tmp[0];
+    }
+
+    private static String toLowerCase(String arg) {
+        if (arg == null) {
+            return null;
+        }
+
+        return arg.toLowerCase();
+    }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/texture/TextureIO.java.javase b/src/jogl/classes/com/jogamp/opengl/util/texture/TextureIO.java.javase
new file mode 100755
index 000000000..3e6f66f10
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/texture/TextureIO.java.javase
@@ -0,0 +1,1258 @@
+/*
+ * Copyright (c) 2005 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util.texture;
+
+import java.io.*;
+import java.net.*;
+import java.nio.*;
+import java.util.*;
+
+import javax.media.opengl.*;
+import javax.media.opengl.glu.*;
+import com.jogamp.opengl.impl.Debug;
+import com.jogamp.opengl.util.*;
+import com.jogamp.opengl.util.texture.spi.*;
+
+/** <P> Provides input and output facilities for both loading OpenGL
+    textures from disk and streams as well as writing textures already
+    in memory back to disk. </P>
+
+    <P> The TextureIO class supports an arbitrary number of plug-in
+    readers and writers via TextureProviders and TextureWriters.
+    TextureProviders know how to produce TextureData objects from
+    files, InputStreams and URLs. TextureWriters know how to write
+    TextureData objects to disk in various file formats. The
+    TextureData class represents the raw data of the texture before it
+    has been converted to an OpenGL texture object. The Texture class
+    represents the OpenGL texture object and provides easy facilities
+    for using the texture. </P>
+
+    <P> There are several built-in TextureProviders and TextureWriters
+    supplied with the TextureIO implementation. The most basic
+    provider uses the platform's Image I/O facilities to read in a
+    BufferedImage and convert it to a texture. This is the baseline
+    provider and is registered so that it is the last one consulted.
+    All others are asked first to open a given file. </P>
+
+    <P> There are three other providers registered by default as of
+    the time of this writing. One handles SGI RGB (".sgi", ".rgb")
+    images from both files and streams. One handles DirectDraw Surface
+    (".dds") images read from files, though can not read these images
+    from streams. One handles Targa (".tga") images read from both
+    files and streams. These providers are executed in an arbitrary
+    order. Some of these providers require the file's suffix to either
+    be specified via the newTextureData methods or for the file to be
+    named with the appropriate suffix. In general a file suffix should
+    be provided to the newTexture and newTextureData methods if at all
+    possible. </P>
+
+    <P> Note that additional TextureProviders, if reading images from
+    InputStreams, must use the mark()/reset() methods on InputStream
+    when probing for e.g. magic numbers at the head of the file to
+    make sure not to disturb the state of the InputStream for
+    downstream TextureProviders. </P>
+
+    <P> There are analogous TextureWriters provided for writing
+    textures back to disk if desired. As of this writing, there are
+    four TextureWriters registered by default: one for Targa files,
+    one for SGI RGB files, one for DirectDraw surface (.dds) files,
+    and one for ImageIO-supplied formats such as .jpg and .png.  Some
+    of these writers have certain limitations such as only being able
+    to write out textures stored in GL_RGB or GL_RGBA format. The DDS
+    writer supports fetching and writing to disk of texture data in
+    DXTn compressed format. Whether this will occur is dependent on
+    whether the texture's internal format is one of the DXTn
+    compressed formats and whether the target file is .dds format.
+*/
+
+public class TextureIO {
+    /** Constant which can be used as a file suffix to indicate a
+        DirectDraw Surface file. */
+    public static final String DDS     = "dds";
+
+    /** Constant which can be used as a file suffix to indicate an SGI
+        RGB file. */
+    public static final String SGI     = "sgi";
+
+    /** Constant which can be used as a file suffix to indicate an SGI
+        RGB file. */
+    public static final String SGI_RGB = "rgb";
+
+    /** Constant which can be used as a file suffix to indicate a GIF
+        file. */
+    public static final String GIF     = "gif";
+
+    /** Constant which can be used as a file suffix to indicate a JPEG
+        file. */
+    public static final String JPG     = "jpg";
+
+    /** Constant which can be used as a file suffix to indicate a PNG
+        file. */
+    public static final String PNG     = "png";
+
+    /** Constant which can be used as a file suffix to indicate a Targa
+        file. */
+    public static final String TGA     = "tga";
+
+    /** Constant which can be used as a file suffix to indicate a TIFF
+        file. */
+    public static final String TIFF    = "tiff";
+
+    private static final boolean DEBUG = Debug.debug("TextureIO");
+
+    // For manually disabling the use of the texture rectangle
+    // extensions so you know the texture target is GL_TEXTURE_2D; this
+    // is useful for shader writers (thanks to Chris Campbell for this
+    // observation)
+    private static boolean texRectEnabled = true;
+
+    //----------------------------------------------------------------------
+    // methods that *do not* require a current context
+    // These methods assume RGB or RGBA textures.
+    // Some texture providers may not recognize the file format unless
+    // the fileSuffix is specified, so it is strongly recommended to
+    // specify it wherever it is known.
+    // Some texture providers may also only support one kind of input,
+    // i.e., reading from a file as opposed to a stream.
+
+    /**
+     * Creates a TextureData from the given file. Does no OpenGL work.
+     *
+     * @param glp the OpenGL Profile this texture data should be
+     *                  created for.
+     * @param file the file from which to read the texture data
+     * @param mipmap     whether mipmaps should be produced for this
+     *                   texture either by autogenerating them or
+     *                   reading them from the file. Some file formats
+     *                   support multiple mipmaps in a single file in
+     *                   which case those mipmaps will be used rather
+     *                   than generating them.
+     * @param fileSuffix the suffix of the file name to be used as a
+     *                   hint of the file format to the underlying
+     *                   texture provider, or null if none and should be
+     *                   auto-detected (some texture providers do not
+     *                   support this)
+     * @return the texture data from the file, or null if none of the
+     *         registered texture providers could read the file
+     * @throws IOException if an error occurred while reading the file
+     */
+    public static TextureData newTextureData(GLProfile glp, File file,
+                                             boolean mipmap,
+                                             String fileSuffix) throws IOException {
+        if (fileSuffix == null) {
+            fileSuffix = FileUtil.getFileSuffix(file);
+        }
+        return newTextureDataImpl(glp, file, 0, 0, mipmap, fileSuffix);
+    }
+
+    /**
+     * Creates a TextureData from the given stream. Does no OpenGL work.
+     *
+     * @param glp the OpenGL Profile this texture data should be
+     *                  created for.
+     * @param stream the stream from which to read the texture data
+     * @param mipmap     whether mipmaps should be produced for this
+     *                   texture either by autogenerating them or
+     *                   reading them from the file. Some file formats
+     *                   support multiple mipmaps in a single file in
+     *                   which case those mipmaps will be used rather
+     *                   than generating them.
+     * @param fileSuffix the suffix of the file name to be used as a
+     *                   hint of the file format to the underlying
+     *                   texture provider, or null if none and should be
+     *                   auto-detected (some texture providers do not
+     *                   support this)
+     * @return the texture data from the stream, or null if none of the
+     *         registered texture providers could read the stream
+     * @throws IOException if an error occurred while reading the stream
+     */
+    public static TextureData newTextureData(GLProfile glp, InputStream stream,
+                                             boolean mipmap,
+                                             String fileSuffix) throws IOException {
+        return newTextureDataImpl(glp, stream, 0, 0, mipmap, fileSuffix);
+    }
+
+    /**
+     * Creates a TextureData from the given URL. Does no OpenGL work.
+     *
+     * @param glp the OpenGL Profile this texture data should be
+     *                  created for.
+     * @param url the URL from which to read the texture data
+     * @param mipmap     whether mipmaps should be produced for this
+     *                   texture either by autogenerating them or
+     *                   reading them from the file. Some file formats
+     *                   support multiple mipmaps in a single file in
+     *                   which case those mipmaps will be used rather
+     *                   than generating them.
+     * @param fileSuffix the suffix of the file name to be used as a
+     *                   hint of the file format to the underlying
+     *                   texture provider, or null if none and should be
+     *                   auto-detected (some texture providers do not
+     *                   support this)
+     * @return the texture data from the URL, or null if none of the
+     *         registered texture providers could read the URL
+     * @throws IOException if an error occurred while reading the URL
+     */
+    public static TextureData newTextureData(GLProfile glp, URL url,
+                                             boolean mipmap,
+                                             String fileSuffix) throws IOException {
+        if (fileSuffix == null) {
+            fileSuffix = FileUtil.getFileSuffix(url.getPath());
+        }
+        return newTextureDataImpl(glp, url, 0, 0, mipmap, fileSuffix);
+    }
+
+    //----------------------------------------------------------------------
+    // These methods make no assumption about the OpenGL internal format
+    // or pixel format of the texture; they must be specified by the
+    // user. It is not allowed to supply 0 (indicating no preference)
+    // for either the internalFormat or the pixelFormat;
+    // IllegalArgumentException will be thrown in this case.
+
+    /**
+     * Creates a TextureData from the given file, using the specified
+     * OpenGL internal format and pixel format for the texture which
+     * will eventually result. The internalFormat and pixelFormat must
+     * be specified and may not be zero; to use default values, use the
+     * variant of this method which does not take these arguments. Does
+     * no OpenGL work.
+     *
+     * @param glp the OpenGL Profile this texture data should be
+     *                  created for.
+     * @param file the file from which to read the texture data
+     * @param internalFormat the OpenGL internal format of the texture
+     *                   which will eventually result from the TextureData
+     * @param pixelFormat the OpenGL pixel format of the texture
+     *                    which will eventually result from the TextureData
+     * @param mipmap     whether mipmaps should be produced for this
+     *                   texture either by autogenerating them or
+     *                   reading them from the file. Some file formats
+     *                   support multiple mipmaps in a single file in
+     *                   which case those mipmaps will be used rather
+     *                   than generating them.
+     * @param fileSuffix the suffix of the file name to be used as a
+     *                   hint of the file format to the underlying
+     *                   texture provider, or null if none and should be
+     *                   auto-detected (some texture providers do not
+     *                   support this)
+     * @return the texture data from the file, or null if none of the
+     *         registered texture providers could read the file
+     * @throws IllegalArgumentException if either internalFormat or
+     *                                  pixelFormat was 0
+     * @throws IOException if an error occurred while reading the file
+     */
+    public static TextureData newTextureData(GLProfile glp, File file,
+                                             int internalFormat,
+                                             int pixelFormat,
+                                             boolean mipmap,
+                                             String fileSuffix) throws IOException, IllegalArgumentException {
+        if ((internalFormat == 0) || (pixelFormat == 0)) {
+            throw new IllegalArgumentException("internalFormat and pixelFormat must be non-zero");
+        }
+
+        if (fileSuffix == null) {
+            fileSuffix = FileUtil.getFileSuffix(file);
+        }
+
+        return newTextureDataImpl(glp, file, internalFormat, pixelFormat, mipmap, fileSuffix);
+    }
+
+    /**
+     * Creates a TextureData from the given stream, using the specified
+     * OpenGL internal format and pixel format for the texture which
+     * will eventually result. The internalFormat and pixelFormat must
+     * be specified and may not be zero; to use default values, use the
+     * variant of this method which does not take these arguments. Does
+     * no OpenGL work.
+     *
+     * @param glp the OpenGL Profile this texture data should be
+     *                  created for.
+     * @param stream the stream from which to read the texture data
+     * @param internalFormat the OpenGL internal format of the texture
+     *                   which will eventually result from the TextureData
+     * @param pixelFormat the OpenGL pixel format of the texture
+     *                    which will eventually result from the TextureData
+     * @param mipmap     whether mipmaps should be produced for this
+     *                   texture either by autogenerating them or
+     *                   reading them from the file. Some file formats
+     *                   support multiple mipmaps in a single file in
+     *                   which case those mipmaps will be used rather
+     *                   than generating them.
+     * @param fileSuffix the suffix of the file name to be used as a
+     *                   hint of the file format to the underlying
+     *                   texture provider, or null if none and should be
+     *                   auto-detected (some texture providers do not
+     *                   support this)
+     * @return the texture data from the stream, or null if none of the
+     *         registered texture providers could read the stream
+     * @throws IllegalArgumentException if either internalFormat or
+     *                                  pixelFormat was 0
+     * @throws IOException if an error occurred while reading the stream
+     */
+    public static TextureData newTextureData(GLProfile glp, InputStream stream,
+                                             int internalFormat,
+                                             int pixelFormat,
+                                             boolean mipmap,
+                                             String fileSuffix) throws IOException, IllegalArgumentException {
+        if ((internalFormat == 0) || (pixelFormat == 0)) {
+            throw new IllegalArgumentException("internalFormat and pixelFormat must be non-zero");
+        }
+
+        return newTextureDataImpl(glp, stream, internalFormat, pixelFormat, mipmap, fileSuffix);
+    }
+
+    /**
+     * Creates a TextureData from the given URL, using the specified
+     * OpenGL internal format and pixel format for the texture which
+     * will eventually result. The internalFormat and pixelFormat must
+     * be specified and may not be zero; to use default values, use the
+     * variant of this method which does not take these arguments. Does
+     * no OpenGL work.
+     *
+     * @param glp the OpenGL Profile this texture data should be
+     *                  created for.
+     * @param url the URL from which to read the texture data
+     * @param internalFormat the OpenGL internal format of the texture
+     *                   which will eventually result from the TextureData
+     * @param pixelFormat the OpenGL pixel format of the texture
+     *                    which will eventually result from the TextureData
+     * @param mipmap     whether mipmaps should be produced for this
+     *                   texture either by autogenerating them or
+     *                   reading them from the file. Some file formats
+     *                   support multiple mipmaps in a single file in
+     *                   which case those mipmaps will be used rather
+     *                   than generating them.
+     * @param fileSuffix the suffix of the file name to be used as a
+     *                   hint of the file format to the underlying
+     *                   texture provider, or null if none and should be
+     *                   auto-detected (some texture providers do not
+     *                   support this)
+     * @return the texture data from the URL, or null if none of the
+     *         registered texture providers could read the URL
+     * @throws IllegalArgumentException if either internalFormat or
+     *                                  pixelFormat was 0
+     * @throws IOException if an error occurred while reading the URL
+     */
+    public static TextureData newTextureData(GLProfile glp, URL url,
+                                             int internalFormat,
+                                             int pixelFormat,
+                                             boolean mipmap,
+                                             String fileSuffix) throws IOException, IllegalArgumentException {
+        if ((internalFormat == 0) || (pixelFormat == 0)) {
+            throw new IllegalArgumentException("internalFormat and pixelFormat must be non-zero");
+        }
+
+        if (fileSuffix == null) {
+            fileSuffix = FileUtil.getFileSuffix(url.getPath());
+        }
+
+        return newTextureDataImpl(glp, url, internalFormat, pixelFormat, mipmap, fileSuffix);
+    }
+
+    //----------------------------------------------------------------------
+    // methods that *do* require a current context
+    //
+
+    /** 
+     * Creates an OpenGL texture object from the specified TextureData
+     * using the current OpenGL context.
+     *
+     * @param data the texture data to turn into an OpenGL texture
+     * @throws GLException if no OpenGL context is current or if an
+     *                     OpenGL error occurred
+     * @throws IllegalArgumentException if the passed TextureData was null
+     */
+    public static Texture newTexture(TextureData data) throws GLException, IllegalArgumentException {
+        if (data == null) {
+            throw new IllegalArgumentException("Null TextureData");
+        }
+        return new Texture(data);
+    }
+
+    /** 
+     * Creates an OpenGL texture object from the specified file using
+     * the current OpenGL context.
+     *
+     * @param file the file from which to read the texture data
+     * @param mipmap     whether mipmaps should be produced for this
+     *                   texture either by autogenerating them or
+     *                   reading them from the file. Some file formats
+     *                   support multiple mipmaps in a single file in
+     *                   which case those mipmaps will be used rather
+     *                   than generating them.
+     * @throws IOException if an error occurred while reading the file
+     * @throws GLException if no OpenGL context is current or if an
+     *                     OpenGL error occurred
+     */
+    public static Texture newTexture(File file, boolean mipmap) throws IOException, GLException {
+        GLProfile glp = GLContext.getCurrentGL().getGLProfile();
+        TextureData data = newTextureData(glp, file, mipmap, FileUtil.getFileSuffix(file));
+        Texture texture = newTexture(data);
+        data.flush();
+        return texture;
+    }
+
+    /** 
+     * Creates an OpenGL texture object from the specified stream using
+     * the current OpenGL context.
+     *
+     * @param stream the stream from which to read the texture data
+     * @param mipmap     whether mipmaps should be produced for this
+     *                   texture either by autogenerating them or
+     *                   reading them from the file. Some file formats
+     *                   support multiple mipmaps in a single file in
+     *                   which case those mipmaps will be used rather
+     *                   than generating them.
+     * @param fileSuffix the suffix of the file name to be used as a
+     *                   hint of the file format to the underlying
+     *                   texture provider, or null if none and should be
+     *                   auto-detected (some texture providers do not
+     *                   support this)
+     * @throws IOException if an error occurred while reading the stream
+     * @throws GLException if no OpenGL context is current or if an
+     *                     OpenGL error occurred
+     */
+    public static Texture newTexture(InputStream stream, boolean mipmap, String fileSuffix) throws IOException, GLException {
+        GLProfile glp = GLContext.getCurrentGL().getGLProfile();
+        TextureData data = newTextureData(glp, stream, mipmap, fileSuffix);
+        Texture texture = newTexture(data);
+        data.flush();
+        return texture;
+    }
+
+    /** 
+     * Creates an OpenGL texture object from the specified URL using the
+     * current OpenGL context.
+     *
+     * @param url the URL from which to read the texture data
+     * @param mipmap     whether mipmaps should be produced for this
+     *                   texture either by autogenerating them or
+     *                   reading them from the file. Some file formats
+     *                   support multiple mipmaps in a single file in
+     *                   which case those mipmaps will be used rather
+     *                   than generating them.
+     * @param fileSuffix the suffix of the file name to be used as a
+     *                   hint of the file format to the underlying
+     *                   texture provider, or null if none and should be
+     *                   auto-detected (some texture providers do not
+     *                   support this)
+     * @throws IOException if an error occurred while reading the URL
+     * @throws GLException if no OpenGL context is current or if an
+     *                     OpenGL error occurred
+     */
+    public static Texture newTexture(URL url, boolean mipmap, String fileSuffix) throws IOException, GLException {
+        if (fileSuffix == null) {
+            fileSuffix = FileUtil.getFileSuffix(url.getPath());
+        }
+        GLProfile glp = GLContext.getCurrentGL().getGLProfile();
+        TextureData data = newTextureData(glp, url, mipmap, fileSuffix);
+        Texture texture = newTexture(data);
+        data.flush();
+        return texture;
+    }
+
+    /** 
+     * Creates an OpenGL texture object associated with the given OpenGL
+     * texture target using the current OpenGL context. The texture has
+     * no initial data. This is used, for example, to construct cube
+     * maps out of multiple TextureData objects.
+     *
+     * @param target the OpenGL target type, eg GL.GL_TEXTURE_2D, 
+     *               GL.GL_TEXTURE_RECTANGLE_ARB
+     *
+     * @throws GLException if no OpenGL context is current or if an
+     *                     OpenGL error occurred
+     */
+    public static Texture newTexture(int target) throws GLException {
+        return new Texture(target);
+    }
+
+    /**
+     * Wraps an OpenGL texture ID from an external library and allows
+     * some of the base methods from the Texture class, such as
+     * binding and querying of texture coordinates, to be used with
+     * it. Attempts to update such textures' contents will yield
+     * undefined results.
+     *
+     * @param textureID the OpenGL texture object to wrap
+     * @param target the OpenGL texture target, eg GL.GL_TEXTURE_2D, 
+     *               GL2.GL_TEXTURE_RECTANGLE
+     * @param texWidth the width of the texture in pixels
+     * @param texHeight the height of the texture in pixels
+     * @param imgWidth the width of the image within the texture in
+     *          pixels (if the content is a sub-rectangle in the upper
+     *          left corner); otherwise, pass in texWidth
+     * @param imgHeight the height of the image within the texture in
+     *          pixels (if the content is a sub-rectangle in the upper
+     *          left corner); otherwise, pass in texHeight
+     * @param mustFlipVertically indicates whether the texture
+     *                           coordinates must be flipped vertically
+     *                           in order to properly display the
+     *                           texture
+     */
+    public static Texture newTexture(int textureID,
+				     int target,
+				     int texWidth,
+				     int texHeight,
+				     int imgWidth,
+				     int imgHeight,
+				     boolean mustFlipVertically) {
+	return new Texture(textureID,
+			   target,
+			   texWidth,
+			   texHeight,
+			   imgWidth,
+			   imgHeight,
+			   mustFlipVertically);
+    }
+
+    /**
+     * Writes the given texture to a file. The type of the file is
+     * inferred from its suffix. An OpenGL context must be current in
+     * order to fetch the texture data back from the OpenGL pipeline.
+     * This method causes the specified Texture to be bound to the
+     * GL_TEXTURE_2D state. If no suitable writer for the requested file
+     * format was found, throws an IOException. <P>
+     *
+     * Reasonable attempts are made to produce good results in the
+     * resulting images. The Targa, SGI and ImageIO writers produce
+     * results in the correct vertical orientation for those file
+     * formats. The DDS writer performs no vertical flip of the data,
+     * even in uncompressed mode. (It is impossible to perform such a
+     * vertical flip with compressed data.) Applications should keep
+     * this in mind when using this routine to save textures to disk for
+     * later re-loading. <P>
+     *
+     * Any mipmaps for the specified texture are currently discarded
+     * when it is written to disk, regardless of whether the underlying
+     * file format supports multiple mipmaps in a given file.
+     *
+     * @throws IOException if an error occurred during writing or no
+     *   suitable writer was found
+     * @throws GLException if no OpenGL context was current or an
+     *   OpenGL-related error occurred
+     */
+    public static void write(Texture texture, File file) throws IOException, GLException {
+        if (texture.getTarget() != GL.GL_TEXTURE_2D) {
+            throw new GLException("Only GL_TEXTURE_2D textures are supported");
+        }
+
+        // First fetch the texture data
+        GL _gl = GLContext.getCurrentGL();
+        if (!_gl.isGL2()) {
+            throw new GLException("Only GL2 supports fetching compressed images, GL: " + _gl);
+        }
+        GL2 gl = _gl.getGL2();
+
+        texture.bind();
+        int internalFormat = glGetTexLevelParameteri(gl, GL.GL_TEXTURE_2D, 0, GL2.GL_TEXTURE_INTERNAL_FORMAT);
+        int width  = glGetTexLevelParameteri(gl, GL.GL_TEXTURE_2D, 0, GL2.GL_TEXTURE_WIDTH);
+        int height = glGetTexLevelParameteri(gl, GL.GL_TEXTURE_2D, 0, GL2.GL_TEXTURE_HEIGHT);
+        int border = glGetTexLevelParameteri(gl, GL.GL_TEXTURE_2D, 0, GL2.GL_TEXTURE_BORDER);
+        TextureData data = null;
+        if (internalFormat == GL.GL_COMPRESSED_RGB_S3TC_DXT1_EXT ||
+            internalFormat == GL.GL_COMPRESSED_RGBA_S3TC_DXT1_EXT ||
+            internalFormat == GL.GL_COMPRESSED_RGBA_S3TC_DXT3_EXT ||
+            internalFormat == GL.GL_COMPRESSED_RGBA_S3TC_DXT5_EXT) {
+            // Fetch using glGetCompressedTexImage
+            int size   = glGetTexLevelParameteri(gl, GL.GL_TEXTURE_2D, 0, GL2.GL_TEXTURE_COMPRESSED_IMAGE_SIZE);
+            ByteBuffer res = ByteBuffer.allocate(size);
+            gl.glGetCompressedTexImage(GL.GL_TEXTURE_2D, 0, res);
+            data = new TextureData(gl.getGLProfile(), internalFormat, width, height, border, internalFormat, GL.GL_UNSIGNED_BYTE,
+                                   false, true, true, res, null);
+        } else {
+            int bytesPerPixel = 0;
+            int fetchedFormat = 0;
+            switch (internalFormat) {
+            case GL.GL_RGB:
+            case GL2.GL_BGR:
+            case GL.GL_RGB8:
+                bytesPerPixel = 3;
+                fetchedFormat = GL.GL_RGB;
+                break;
+            case GL.GL_RGBA:
+            case GL2.GL_BGRA:
+            case GL2.GL_ABGR_EXT:
+            case GL.GL_RGBA8:
+                bytesPerPixel = 4;
+                fetchedFormat = GL.GL_RGBA;
+                break;
+            default:
+                throw new IOException("Unsupported texture internal format 0x" + Integer.toHexString(internalFormat));
+            }
+
+            // Fetch using glGetTexImage
+            int packAlignment  = glGetInteger(GL.GL_PACK_ALIGNMENT);
+            int packRowLength  = glGetInteger(GL2.GL_PACK_ROW_LENGTH);
+            int packSkipRows   = glGetInteger(GL2.GL_PACK_SKIP_ROWS);
+            int packSkipPixels = glGetInteger(GL2.GL_PACK_SKIP_PIXELS);
+            int packSwapBytes  = glGetInteger(GL2.GL_PACK_SWAP_BYTES);
+
+            gl.glPixelStorei(GL.GL_PACK_ALIGNMENT, 1);
+            gl.glPixelStorei(GL2.GL_PACK_ROW_LENGTH, 0);
+            gl.glPixelStorei(GL2.GL_PACK_SKIP_ROWS, 0);
+            gl.glPixelStorei(GL2.GL_PACK_SKIP_PIXELS, 0);
+            gl.glPixelStorei(GL2.GL_PACK_SWAP_BYTES, 0);
+
+            ByteBuffer res = ByteBuffer.allocate((width + (2 * border)) *
+                                                 (height + (2 * border)) *
+                                                 bytesPerPixel);
+            if (DEBUG) {
+                System.out.println("Allocated buffer of size " + res.remaining() + " for fetched image (" +
+                                   ((fetchedFormat == GL.GL_RGB) ? "GL_RGB" : "GL_RGBA") + ")");
+            }
+            gl.glGetTexImage(GL.GL_TEXTURE_2D, 0, fetchedFormat, GL.GL_UNSIGNED_BYTE, res);
+
+            gl.glPixelStorei(GL.GL_PACK_ALIGNMENT, packAlignment);
+            gl.glPixelStorei(GL2.GL_PACK_ROW_LENGTH, packRowLength);
+            gl.glPixelStorei(GL2.GL_PACK_SKIP_ROWS, packSkipRows);
+            gl.glPixelStorei(GL2.GL_PACK_SKIP_PIXELS, packSkipPixels);
+            gl.glPixelStorei(GL2.GL_PACK_SWAP_BYTES, packSwapBytes);
+      
+            data = new TextureData(gl.getGLProfile(), internalFormat, width, height, border, fetchedFormat, GL.GL_UNSIGNED_BYTE,
+                                   false, false, false, res, null);
+
+            if (DEBUG) {
+                System.out.println("data.getPixelFormat() = " +
+                                   ((data.getPixelFormat() == GL.GL_RGB) ? "GL_RGB" : "GL_RGBA"));
+            }
+        }
+
+        write(data, file);
+    }
+  
+    public static void write(TextureData data, File file) throws IOException, GLException {
+        for (Iterator iter = textureWriters.iterator(); iter.hasNext(); ) {
+            TextureWriter writer = (TextureWriter) iter.next();
+            if (writer.write(file, data)) {
+                return;
+            }
+        }
+
+        throw new IOException("No suitable texture writer found for "+file.getAbsolutePath());
+    }
+  
+    //----------------------------------------------------------------------
+    // SPI support
+    //
+
+    /** Adds a TextureProvider to support reading of a new file
+        format. */
+    public static void addTextureProvider(TextureProvider provider) {
+        // Must always add at the front so the ImageIO provider is last,
+        // so we don't accidentally use it instead of a user's possibly
+        // more optimal provider
+        textureProviders.add(0, provider);
+    }
+
+    /** Adds a TextureWriter to support writing of a new file
+        format. */
+    public static void addTextureWriter(TextureWriter writer) {
+        // Must always add at the front so the ImageIO writer is last,
+        // so we don't accidentally use it instead of a user's possibly
+        // more optimal writer
+        textureWriters.add(0, writer);
+    }
+
+    //---------------------------------------------------------------------------
+    // Global disabling of texture rectangle extension
+    //
+
+    /** Toggles the use of the GL_ARB_texture_rectangle extension by the
+        TextureIO classes. By default, on hardware supporting this
+        extension, the TextureIO classes may use the
+        GL_ARB_texture_rectangle extension for non-power-of-two
+        textures. (If the hardware supports the
+        GL_ARB_texture_non_power_of_two extension, that one is
+        preferred.) In some situations, for example when writing
+        shaders, it is advantageous to force the texture target to
+        always be GL_TEXTURE_2D in order to have one version of the
+        shader, even at the expense of texture memory in the case where
+        NPOT textures are not supported. This method allows the use of
+        the GL_ARB_texture_rectangle extension to be turned off globally
+        for this purpose. The default is that the use of the extension
+        is enabled. */
+    public static void setTexRectEnabled(boolean enabled) {
+        texRectEnabled = enabled;
+    }
+
+    /** Indicates whether the GL_ARB_texture_rectangle extension is
+        allowed to be used for non-power-of-two textures; see {@link
+        #setTexRectEnabled setTexRectEnabled}. */
+    public static boolean isTexRectEnabled() {
+        return texRectEnabled;
+    }
+
+    //----------------------------------------------------------------------
+    // Internals only below this point
+    //
+
+    private static List/*<TextureProvider>*/ textureProviders = new ArrayList/*<TextureProvider>*/();
+    private static List/*<TextureWriter>*/   textureWriters   = new ArrayList/*<TextureWriter>*/();
+
+    static {
+        // ImageIO provider, the fall-back, must be the first one added
+        if(GLProfile.isAWTJOGLAvailable()) {
+            try {
+                // Use reflection to avoid compile-time dependencies on AWT-related classes
+                TextureProvider provider = (TextureProvider)
+                    Class.forName("com.jogamp.opengl.util.texture.spi.awt.IIOTextureProvider").newInstance();
+                addTextureProvider(provider);
+            } catch (Exception e) {
+                if (DEBUG) {
+                    e.printStackTrace();
+                }
+            }
+        }
+
+        // Other special-case providers
+        addTextureProvider(new DDSTextureProvider());
+        addTextureProvider(new SGITextureProvider());
+        addTextureProvider(new TGATextureProvider());
+
+        // ImageIO writer, the fall-back, must be the first one added
+        if(GLProfile.isAWTJOGLAvailable()) {
+            try {
+                // Use reflection to avoid compile-time dependencies on AWT-related classes
+                TextureWriter writer = (TextureWriter)
+                    Class.forName("com.jogamp.opengl.util.texture.spi.awt.IIOTextureWriter").newInstance();
+                addTextureWriter(writer);
+            } catch (Exception e) {
+                if (DEBUG) {
+                    e.printStackTrace();
+                }
+            } catch (Error e) {
+                if (DEBUG) {
+                    e.printStackTrace();
+                }
+            }
+        }
+
+        // Other special-case writers
+        addTextureWriter(new DDSTextureWriter());
+        addTextureWriter(new SGITextureWriter());
+        addTextureWriter(new TGATextureWriter());
+        addTextureWriter(new NetPbmTextureWriter());
+    }
+
+    // Implementation methods
+    private static TextureData newTextureDataImpl(GLProfile glp, File file,
+                                                  int internalFormat,
+                                                  int pixelFormat,
+                                                  boolean mipmap,
+                                                  String fileSuffix) throws IOException {
+        if (file == null) {
+            throw new IOException("File was null");
+        }
+
+        fileSuffix = toLowerCase(fileSuffix);
+
+        for (Iterator iter = textureProviders.iterator(); iter.hasNext(); ) {
+            TextureProvider provider = (TextureProvider) iter.next();
+            TextureData data = provider.newTextureData(glp, file,
+                                                       internalFormat,
+                                                       pixelFormat,
+                                                       mipmap,
+                                                       fileSuffix);
+            if (data != null) {
+                return data;
+            }
+        }
+
+        throw new IOException("No suitable reader for given file "+file.getAbsolutePath());
+    }
+
+    private static TextureData newTextureDataImpl(GLProfile glp, InputStream stream,
+                                                  int internalFormat,
+                                                  int pixelFormat,
+                                                  boolean mipmap,
+                                                  String fileSuffix) throws IOException {
+        if (stream == null) {
+            throw new IOException("Stream was null");
+        }
+
+        fileSuffix = toLowerCase(fileSuffix);
+
+        // Note: use of BufferedInputStream works around 4764639/4892246
+        if (!(stream instanceof BufferedInputStream)) {
+            stream = new BufferedInputStream(stream);
+        }
+
+        for (Iterator iter = textureProviders.iterator(); iter.hasNext(); ) {
+            TextureProvider provider = (TextureProvider) iter.next();
+            TextureData data = provider.newTextureData(glp, stream,
+                                                       internalFormat,
+                                                       pixelFormat,
+                                                       mipmap,
+                                                       fileSuffix);
+            if (data != null) {
+                return data;
+            }
+        }
+
+        throw new IOException("No suitable reader for given stream");
+    }
+
+    private static TextureData newTextureDataImpl(GLProfile glp, URL url,
+                                                  int internalFormat,
+                                                  int pixelFormat,
+                                                  boolean mipmap,
+                                                  String fileSuffix) throws IOException {
+        if (url == null) {
+            throw new IOException("URL was null");
+        }
+
+        fileSuffix = toLowerCase(fileSuffix);
+
+        for (Iterator iter = textureProviders.iterator(); iter.hasNext(); ) {
+            TextureProvider provider = (TextureProvider) iter.next();
+            TextureData data = provider.newTextureData(glp, url,
+                                                       internalFormat,
+                                                       pixelFormat,
+                                                       mipmap,
+                                                       fileSuffix);
+            if (data != null) {
+                return data;
+            }
+        }
+
+        throw new IOException("No suitable reader for given URL "+url);
+    }
+
+    //----------------------------------------------------------------------
+    // DDS provider -- supports files only for now
+    static class DDSTextureProvider implements TextureProvider {
+        public TextureData newTextureData(GLProfile glp, File file,
+                                          int internalFormat,
+                                          int pixelFormat,
+                                          boolean mipmap,
+                                          String fileSuffix) throws IOException {
+            if (DDS.equals(fileSuffix) ||
+                DDS.equals(FileUtil.getFileSuffix(file))) {
+                DDSImage image = DDSImage.read(file);
+                return newTextureData(glp, image, internalFormat, pixelFormat, mipmap);
+            }
+
+            return null;
+        }
+
+        public TextureData newTextureData(GLProfile glp, InputStream stream,
+                                          int internalFormat,
+                                          int pixelFormat,
+                                          boolean mipmap,
+                                          String fileSuffix) throws IOException {
+            if (DDS.equals(fileSuffix) ||
+                DDSImage.isDDSImage(stream)) {
+                byte[] data = StreamUtil.readAll2Array(stream);
+                ByteBuffer buf = ByteBuffer.wrap(data);
+                DDSImage image = DDSImage.read(buf);
+                return newTextureData(glp, image, internalFormat, pixelFormat, mipmap);
+            }
+
+            return null;
+        }
+
+        public TextureData newTextureData(GLProfile glp, URL url,
+                                          int internalFormat,
+                                          int pixelFormat,
+                                          boolean mipmap,
+                                          String fileSuffix) throws IOException {
+            InputStream stream = new BufferedInputStream(url.openStream());
+            try {
+                return newTextureData(glp, stream, internalFormat, pixelFormat, mipmap, fileSuffix);
+            } finally {
+                stream.close();
+            }
+        }
+
+        private TextureData newTextureData(GLProfile glp, final DDSImage image,
+                                           int internalFormat,
+                                           int pixelFormat,
+                                           boolean mipmap) {
+            DDSImage.ImageInfo info = image.getMipMap(0);
+            if (pixelFormat == 0) {
+                switch (image.getPixelFormat()) {
+                case DDSImage.D3DFMT_R8G8B8:
+                    pixelFormat = GL.GL_RGB;
+                    break;
+                default:
+                    pixelFormat = GL.GL_RGBA;
+                    break;
+                }
+            }
+            if (info.isCompressed()) {
+                switch (info.getCompressionFormat()) {
+                case DDSImage.D3DFMT_DXT1:
+                    internalFormat = GL.GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
+                    break;
+                case DDSImage.D3DFMT_DXT3:
+                    internalFormat = GL.GL_COMPRESSED_RGBA_S3TC_DXT3_EXT;
+                    break;
+                case DDSImage.D3DFMT_DXT5:
+                    internalFormat = GL.GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
+                    break;
+                default:
+                    throw new RuntimeException("Unsupported DDS compression format \"" +
+                                               DDSImage.getCompressionFormatName(info.getCompressionFormat()) + "\"");
+                }
+            }
+            if (internalFormat == 0) {
+                switch (image.getPixelFormat()) {
+                case DDSImage.D3DFMT_R8G8B8:
+                    pixelFormat = GL.GL_RGB;
+                    break;
+                default:
+                    pixelFormat = GL.GL_RGBA;
+                    break;
+                }
+            }
+            TextureData.Flusher flusher = new TextureData.Flusher() {
+                    public void flush() {
+                        image.close();
+                    }
+                };
+            TextureData data;
+            if (mipmap && image.getNumMipMaps() > 0) {
+                Buffer[] mipmapData = new Buffer[image.getNumMipMaps()];
+                for (int i = 0; i < image.getNumMipMaps(); i++) {
+                    mipmapData[i] = image.getMipMap(i).getData();
+                }
+                data = new TextureData(glp, internalFormat,
+                                       info.getWidth(),
+                                       info.getHeight(),
+                                       0,
+                                       pixelFormat,
+                                       GL.GL_UNSIGNED_BYTE,
+                                       info.isCompressed(),
+                                       true,
+                                       mipmapData,
+                                       flusher);
+            } else {
+                // Fix this up for the end user because we can't generate
+                // mipmaps for compressed textures
+                mipmap = false;
+                data = new TextureData(glp, internalFormat,
+                                       info.getWidth(),
+                                       info.getHeight(),
+                                       0,
+                                       pixelFormat,
+                                       GL.GL_UNSIGNED_BYTE,
+                                       mipmap,
+                                       info.isCompressed(),
+                                       true,
+                                       info.getData(),
+                                       flusher);
+            }
+            return data;
+        }
+    }
+
+    //----------------------------------------------------------------------
+    // Base class for SGI RGB and TGA image providers
+    static abstract class StreamBasedTextureProvider implements TextureProvider {
+        public TextureData newTextureData(GLProfile glp, File file,
+                                          int internalFormat,
+                                          int pixelFormat,
+                                          boolean mipmap,
+                                          String fileSuffix) throws IOException {
+            InputStream inStream = new BufferedInputStream(new FileInputStream(file));
+            try {
+                // The SGIImage and TGAImage implementations use InputStreams
+                // anyway so there isn't much point in having a separate code
+                // path for files
+                return newTextureData(glp, inStream,
+                                      internalFormat,
+                                      pixelFormat,
+                                      mipmap,
+                                      ((fileSuffix != null) ? fileSuffix : FileUtil.getFileSuffix(file)));
+            } finally {
+                inStream.close();
+            }
+        }
+
+        public TextureData newTextureData(GLProfile glp, URL url,
+                                          int internalFormat,
+                                          int pixelFormat,
+                                          boolean mipmap,
+                                          String fileSuffix) throws IOException {
+            InputStream stream = new BufferedInputStream(url.openStream());
+            try {
+                return newTextureData(glp, stream, internalFormat, pixelFormat, mipmap, fileSuffix);
+            } finally {
+                stream.close();
+            }
+        }
+    }
+
+    //----------------------------------------------------------------------
+    // SGI RGB image provider
+    static class SGITextureProvider extends StreamBasedTextureProvider {
+        public TextureData newTextureData(GLProfile glp, InputStream stream,
+                                          int internalFormat,
+                                          int pixelFormat,
+                                          boolean mipmap,
+                                          String fileSuffix) throws IOException {
+            if (SGI.equals(fileSuffix) ||
+                SGI_RGB.equals(fileSuffix) ||
+                SGIImage.isSGIImage(stream)) {
+                SGIImage image = SGIImage.read(stream);
+                if (pixelFormat == 0) {
+                    pixelFormat = image.getFormat();
+                }
+                if (internalFormat == 0) {
+                    internalFormat = image.getFormat();
+                }
+                return new TextureData(glp, internalFormat,
+                                       image.getWidth(),
+                                       image.getHeight(),
+                                       0,
+                                       pixelFormat,
+                                       GL.GL_UNSIGNED_BYTE,
+                                       mipmap,
+                                       false,
+                                       false,
+                                       ByteBuffer.wrap(image.getData()),
+                                       null);
+            }
+
+            return null;
+        }
+    }
+
+    //----------------------------------------------------------------------
+    // TGA (Targa) image provider
+    static class TGATextureProvider extends StreamBasedTextureProvider {
+        public TextureData newTextureData(GLProfile glp, InputStream stream,
+                                          int internalFormat,
+                                          int pixelFormat,
+                                          boolean mipmap,
+                                          String fileSuffix) throws IOException {
+            if (TGA.equals(fileSuffix)) {
+                TGAImage image = TGAImage.read(stream);
+                if (pixelFormat == 0) {
+                    pixelFormat = image.getGLFormat();
+                }
+                if (internalFormat == 0) {
+                    GL gl = GLContext.getCurrentGL();
+                    if(gl.isGL2()) {
+                        internalFormat = GL.GL_RGBA8;
+                    } else {
+                        internalFormat = (image.getBytesPerPixel()==4)?GL.GL_RGBA:GL.GL_RGB;
+                    }
+                }
+                return new TextureData(glp, internalFormat,
+                                       image.getWidth(),
+                                       image.getHeight(),
+                                       0,
+                                       pixelFormat,
+                                       GL.GL_UNSIGNED_BYTE,
+                                       mipmap,
+                                       false,
+                                       false,
+                                       image.getData(),
+                                       null);
+            }
+
+            return null;
+        }
+    }
+
+    //----------------------------------------------------------------------
+    // DDS texture writer
+    //
+    static class DDSTextureWriter implements TextureWriter {
+        public boolean write(File file,
+                             TextureData data) throws IOException {
+            if (DDS.equals(FileUtil.getFileSuffix(file))) {
+                // See whether the DDS writer can handle this TextureData
+                int pixelFormat = data.getPixelFormat();
+                int pixelType   = data.getPixelType();
+                if (pixelType != GL.GL_BYTE &&
+                    pixelType != GL.GL_UNSIGNED_BYTE) {
+                    throw new IOException("DDS writer only supports byte / unsigned byte textures");
+                }
+
+                int d3dFormat = 0;
+                // FIXME: some of these are probably not completely correct and would require swizzling
+                switch (pixelFormat) {
+                case GL.GL_RGB:                        d3dFormat = DDSImage.D3DFMT_R8G8B8; break;
+                case GL.GL_RGBA:                       d3dFormat = DDSImage.D3DFMT_A8R8G8B8; break;
+                case GL.GL_COMPRESSED_RGB_S3TC_DXT1_EXT:  d3dFormat = DDSImage.D3DFMT_DXT1; break;
+                case GL.GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: throw new IOException("RGBA DXT1 not yet supported");
+                case GL.GL_COMPRESSED_RGBA_S3TC_DXT3_EXT: d3dFormat = DDSImage.D3DFMT_DXT3; break;
+                case GL.GL_COMPRESSED_RGBA_S3TC_DXT5_EXT: d3dFormat = DDSImage.D3DFMT_DXT5; break;
+                default: throw new IOException("Unsupported pixel format 0x" + Integer.toHexString(pixelFormat) + " by DDS writer");
+                }
+        
+                ByteBuffer[] mipmaps = null;
+                if (data.getMipmapData() != null) {
+                    mipmaps = new ByteBuffer[data.getMipmapData().length];
+                    for (int i = 0; i < mipmaps.length; i++) {
+                        mipmaps[i] = (ByteBuffer) data.getMipmapData()[i];
+                    }
+                } else {
+                    mipmaps = new ByteBuffer[] { (ByteBuffer) data.getBuffer() };
+                }
+
+                DDSImage image = DDSImage.createFromData(d3dFormat,
+                                                         data.getWidth(),
+                                                         data.getHeight(),
+                                                         mipmaps);
+                image.write(file);
+                return true;
+            }
+
+            return false;
+        }
+    }
+
+    //----------------------------------------------------------------------
+    // SGI (rgb) texture writer
+    //
+    static class SGITextureWriter implements TextureWriter {
+        public boolean write(File file,
+                             TextureData data) throws IOException {
+            String fileSuffix = FileUtil.getFileSuffix(file);
+            if (SGI.equals(fileSuffix) ||
+                SGI_RGB.equals(fileSuffix)) {
+                // See whether the SGI writer can handle this TextureData
+                int pixelFormat = data.getPixelFormat();
+                int pixelType   = data.getPixelType();
+                if ((pixelFormat == GL.GL_RGB ||
+                     pixelFormat == GL.GL_RGBA) &&
+                    (pixelType == GL.GL_BYTE ||
+                     pixelType == GL.GL_UNSIGNED_BYTE)) {
+                    ByteBuffer buf = ((data.getBuffer() != null) ?
+                                      (ByteBuffer) data.getBuffer() :
+                                      (ByteBuffer) data.getMipmapData()[0]);
+                    byte[] bytes;
+                    if (buf.hasArray()) {
+                        bytes = buf.array();
+                    } else {
+                        buf.rewind();
+                        bytes = new byte[buf.remaining()];
+                        buf.get(bytes);
+                        buf.rewind();
+                    }
+
+                    SGIImage image = SGIImage.createFromData(data.getWidth(),
+                                                             data.getHeight(),
+                                                             (pixelFormat == GL.GL_RGBA),
+                                                             bytes);
+                    image.write(file, false);
+                    return true;
+                }
+
+                throw new IOException("SGI writer doesn't support this pixel format / type (only GL_RGB/A + bytes)");
+            }
+
+            return false;
+        }
+    }
+
+    //----------------------------------------------------------------------
+    // TGA (Targa) texture writer
+  
+    static class TGATextureWriter implements TextureWriter {
+        public boolean write(File file,
+                             TextureData data) throws IOException {
+            if (TGA.equals(FileUtil.getFileSuffix(file))) {
+                // See whether the TGA writer can handle this TextureData
+                int pixelFormat = data.getPixelFormat();
+                int pixelType   = data.getPixelType();
+                if ((pixelFormat == GL.GL_RGB ||
+                     pixelFormat == GL.GL_RGBA) &&
+                    (pixelType == GL.GL_BYTE ||
+                     pixelType == GL.GL_UNSIGNED_BYTE)) {
+                    ByteBuffer buf = ((data.getBuffer() != null) ?
+                                      (ByteBuffer) data.getBuffer() :
+                                      (ByteBuffer) data.getMipmapData()[0]);
+                    // Must reverse order of red and blue channels to get correct results
+                    int skip = ((pixelFormat == GL.GL_RGB) ? 3 : 4);
+                    for (int i = 0; i < buf.remaining(); i += skip) {
+                        byte red  = buf.get(i + 0);
+                        byte blue = buf.get(i + 2);
+                        buf.put(i + 0, blue);
+                        buf.put(i + 2, red);
+                    }
+
+                    TGAImage image = TGAImage.createFromData(data.getWidth(),
+                                                             data.getHeight(),
+                                                             (pixelFormat == GL.GL_RGBA),
+                                                             false,
+                                                             ((data.getBuffer() != null) ?
+                                                              (ByteBuffer) data.getBuffer() :
+                                                              (ByteBuffer) data.getMipmapData()[0]));
+                    image.write(file);
+                    return true;
+                }
+
+                throw new IOException("TGA writer doesn't support this pixel format / type (only GL_RGB/A + bytes)");
+            }
+
+            return false;
+        }    
+    }
+
+    //----------------------------------------------------------------------
+    // Helper routines
+    //
+
+    private static int glGetInteger(int pname) {
+        int[] tmp = new int[1];
+        GL gl = GLContext.getCurrentGL();
+        gl.glGetIntegerv(pname, tmp, 0);
+        return tmp[0];
+    }
+
+    private static int glGetTexLevelParameteri(GL2 gl, int target, int level, int pname) {
+        int[] tmp = new int[1];
+        gl.glGetTexLevelParameteriv(target, 0, pname, tmp, 0);
+        return tmp[0];
+    }
+
+    private static String toLowerCase(String arg) {
+        if (arg == null) {
+            return null;
+        }
+
+        return arg.toLowerCase();
+    }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/texture/awt/AWTTextureData.java b/src/jogl/classes/com/jogamp/opengl/util/texture/awt/AWTTextureData.java
new file mode 100755
index 000000000..39ec74b97
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/texture/awt/AWTTextureData.java
@@ -0,0 +1,498 @@
+/*
+ * Copyright (c) 2005 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ */
+
+package com.jogamp.opengl.util.texture.awt;
+
+import java.awt.AlphaComposite;
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.Transparency;
+import java.awt.color.*;
+import java.awt.image.*;
+import java.nio.*;
+
+import javax.media.opengl.*;
+import com.jogamp.opengl.util.texture.*;
+
+public class AWTTextureData extends TextureData {
+    // Mechanism for lazily converting input BufferedImages with custom
+    // ColorModels to standard ones for uploading to OpenGL, as well as
+    // backing off from the optimizations of hoping that either
+    // GL_EXT_abgr or OpenGL 1.2 are present
+    private BufferedImage imageForLazyCustomConversion;
+    private boolean expectingEXTABGR;
+    private boolean expectingGL12;
+
+    private static final ColorModel rgbaColorModel =
+        new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_sRGB),
+                                new int[] {8, 8, 8, 8}, true, true, 
+                                Transparency.TRANSLUCENT,
+                                DataBuffer.TYPE_BYTE);
+    private static final ColorModel rgbColorModel =
+        new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_sRGB),
+                                new int[] {8, 8, 8, 0}, false, false,
+                                Transparency.OPAQUE,
+                                DataBuffer.TYPE_BYTE);
+
+
+    /** 
+     * Constructs a new TextureData object with the specified parameters
+     * and data contained in the given BufferedImage. The resulting
+     * TextureData "wraps" the contents of the BufferedImage, so if a
+     * modification is made to the BufferedImage between the time the
+     * TextureData is constructed and when a Texture is made from the
+     * TextureData, that modification will be visible in the resulting
+     * Texture.
+     *
+     * @param glp      the OpenGL Profile this texture data should be
+     *                       created for.
+     * @param internalFormat the OpenGL internal format for the
+     *                       resulting texture; may be 0, in which case
+     *                       it is inferred from the image's type
+     * @param pixelFormat    the OpenGL internal format for the
+     *                       resulting texture; may be 0, in which case
+     *                       it is inferred from the image's type (note:
+     *                       this argument is currently always ignored)
+     * @param mipmap         indicates whether mipmaps should be
+     *                       autogenerated (using GLU) for the resulting
+     *                       texture
+     * @param image          the image containing the texture data
+     */
+    public AWTTextureData(GLProfile glp, 
+                          int internalFormat,
+                          int pixelFormat,
+                          boolean mipmap,
+                          BufferedImage image) {
+        super(glp);
+        if (internalFormat == 0) {
+            this.internalFormat = image.getColorModel().hasAlpha() ? GL.GL_RGBA : GL.GL_RGB;
+        } else {
+            this.internalFormat = internalFormat;
+        }
+        createFromImage(glp, image);
+        this.mipmap = mipmap;
+        if (buffer != null) {
+            estimatedMemorySize = estimatedMemorySize(buffer);
+        } else {
+            // In the lazy custom conversion case we don't yet have a buffer
+            if (imageForLazyCustomConversion != null) {
+                estimatedMemorySize = estimatedMemorySize(wrapImageDataBuffer(imageForLazyCustomConversion));
+            }
+        }
+    }
+
+    /** Returns the intended OpenGL pixel format of the texture data. */
+    public int getPixelFormat() {
+        if (imageForLazyCustomConversion != null) {
+            if (!((expectingEXTABGR && haveEXTABGR) ||
+                  (expectingGL12    && haveGL12))) {
+                revertPixelFormatAndType();
+            }
+        }
+        return pixelFormat;
+    }
+    /** Returns the intended OpenGL pixel type of the texture data. */
+    public int getPixelType() {
+        if (imageForLazyCustomConversion != null) {
+            if (!((expectingEXTABGR && haveEXTABGR) ||
+                  (expectingGL12    && haveGL12))) {
+                revertPixelFormatAndType();
+            }
+        }
+        return pixelType;
+    }
+
+    /** Returns the texture data, or null if it is specified as a set of mipmaps. */
+    public Buffer getBuffer() {
+        if (imageForLazyCustomConversion != null) {
+            if (!((expectingEXTABGR && haveEXTABGR) ||
+                  (expectingGL12    && haveGL12))) {
+                revertPixelFormatAndType();
+                // Must present the illusion to the end user that we are simply
+                // wrapping the input BufferedImage
+                createFromCustom(imageForLazyCustomConversion);
+            }
+        }
+        return buffer;
+    }
+
+    private void createFromImage(GLProfile glp, BufferedImage image) {
+        pixelType = 0; // Determine from image
+        mustFlipVertically = true;
+
+        width = image.getWidth();
+        height = image.getHeight();
+
+        int scanlineStride;
+
+        SampleModel sm = image.getRaster().getSampleModel();
+        if (sm instanceof SinglePixelPackedSampleModel) {
+            scanlineStride =
+                ((SinglePixelPackedSampleModel)sm).getScanlineStride();
+        } else if (sm instanceof MultiPixelPackedSampleModel) {
+            scanlineStride =
+                ((MultiPixelPackedSampleModel)sm).getScanlineStride();
+        } else if (sm instanceof ComponentSampleModel) {
+            scanlineStride =
+                ((ComponentSampleModel)sm).getScanlineStride();
+        } else {
+            // This will only happen for TYPE_CUSTOM anyway
+            setupLazyCustomConversion(image);
+            return;
+        }
+
+        width = image.getWidth();
+        height = image.getHeight();
+
+        if (glp.isGL2GL3()) {
+            switch (image.getType()) {
+                case BufferedImage.TYPE_INT_RGB:
+                    pixelFormat = GL2GL3.GL_BGRA;
+                    pixelType = GL2GL3.GL_UNSIGNED_INT_8_8_8_8_REV;
+                    rowLength = scanlineStride;
+                    alignment = 4;
+                    expectingGL12 = true;
+                    setupLazyCustomConversion(image);
+                    break;
+                case BufferedImage.TYPE_INT_ARGB_PRE:
+                    pixelFormat = GL2GL3.GL_BGRA;
+                    pixelType = GL2GL3.GL_UNSIGNED_INT_8_8_8_8_REV;
+                    rowLength = scanlineStride;
+                    alignment = 4;
+                    expectingGL12 = true;
+                    setupLazyCustomConversion(image);
+                    break;
+                case BufferedImage.TYPE_INT_BGR:
+                    pixelFormat = GL.GL_RGBA;
+                    pixelType = GL2GL3.GL_UNSIGNED_INT_8_8_8_8_REV;
+                    rowLength = scanlineStride;
+                    alignment = 4;
+                    expectingGL12 = true;
+                    setupLazyCustomConversion(image);
+                    break;
+                case BufferedImage.TYPE_3BYTE_BGR:
+                    {
+                        // we can pass the image data directly to OpenGL only if
+                        // we have an integral number of pixels in each scanline
+                        if ((scanlineStride % 3) == 0) {
+                            pixelFormat = GL2GL3.GL_BGR;
+                            pixelType = GL.GL_UNSIGNED_BYTE;
+                            rowLength = scanlineStride / 3;
+                            alignment = 1;
+                        } else {
+                            setupLazyCustomConversion(image);
+                            return;
+                        }
+                    }
+                    break;
+                case BufferedImage.TYPE_4BYTE_ABGR_PRE:
+                    {
+                        // we can pass the image data directly to OpenGL only if
+                        // we have an integral number of pixels in each scanline
+                        // and only if the GL_EXT_abgr extension is present
+    
+                        // NOTE: disabling this code path for now as it appears it's
+                        // buggy at least on some NVidia drivers and doesn't perform
+                        // the necessary byte swapping (FIXME: needs more
+                        // investigation)
+                        if ((scanlineStride % 4) == 0 && glp.isGL2() && false) {
+                            pixelFormat = GL2.GL_ABGR_EXT;
+                            pixelType = GL.GL_UNSIGNED_BYTE;
+                            rowLength = scanlineStride / 4;
+                            alignment = 4;
+    
+                            // Store a reference to the original image for later in
+                            // case it turns out that we don't have GL_EXT_abgr at the
+                            // time we're going to do the texture upload to OpenGL
+                            setupLazyCustomConversion(image);
+                            expectingEXTABGR = true;
+                            break;
+                        } else {
+                            setupLazyCustomConversion(image);
+                            return;
+                        }
+                    }
+                case BufferedImage.TYPE_USHORT_565_RGB:
+                    pixelFormat = GL.GL_RGB;
+                    pixelType = GL.GL_UNSIGNED_SHORT_5_6_5;
+                    rowLength = scanlineStride;
+                    alignment = 2;
+                    expectingGL12 = true;
+                    setupLazyCustomConversion(image);
+                    break;
+                case BufferedImage.TYPE_USHORT_555_RGB:
+                    pixelFormat = GL2GL3.GL_BGRA;
+                    pixelType = GL2GL3.GL_UNSIGNED_SHORT_1_5_5_5_REV;
+                    rowLength = scanlineStride;
+                    alignment = 2;
+                    expectingGL12 = true;
+                    setupLazyCustomConversion(image);
+                    break;
+                case BufferedImage.TYPE_BYTE_GRAY:
+                    pixelFormat = GL.GL_LUMINANCE;
+                    pixelType = GL.GL_UNSIGNED_BYTE;
+                    rowLength = scanlineStride;
+                    alignment = 1;
+                    break;
+                case BufferedImage.TYPE_USHORT_GRAY:
+                    pixelFormat = GL.GL_LUMINANCE;
+                    pixelType = GL.GL_UNSIGNED_SHORT;
+                    rowLength = scanlineStride;
+                    alignment = 2;
+                    break;
+                    // Note: TYPE_INT_ARGB and TYPE_4BYTE_ABGR images go down the
+                    // custom code path to satisfy the invariant that images with an
+                    // alpha channel always go down with premultiplied alpha.
+                case BufferedImage.TYPE_INT_ARGB:
+                case BufferedImage.TYPE_4BYTE_ABGR:
+                case BufferedImage.TYPE_BYTE_BINARY:
+                case BufferedImage.TYPE_BYTE_INDEXED:
+                case BufferedImage.TYPE_CUSTOM:
+                default:
+                    ColorModel cm = image.getColorModel();
+                    if (cm.equals(rgbColorModel)) {
+                        pixelFormat = GL.GL_RGB;
+                        pixelType = GL.GL_UNSIGNED_BYTE;
+                        rowLength = scanlineStride / 3;
+                        alignment = 1;
+                    } else if (cm.equals(rgbaColorModel)) {
+                        pixelFormat = GL.GL_RGBA;
+                        pixelType = GL.GL_UNSIGNED_BYTE;
+                        rowLength = scanlineStride / 4; // FIXME: correct?
+                        alignment = 4;
+                    } else {
+                        setupLazyCustomConversion(image);
+                        return;
+                    }
+                    break;
+            }
+        } else {
+            switch (image.getType()) {
+                case BufferedImage.TYPE_INT_RGB:
+                    pixelFormat = GL.GL_RGB;
+                    pixelType = GL.GL_UNSIGNED_BYTE;
+                    rowLength = scanlineStride;
+                    alignment = 3;
+                    expectingGL12 = true;
+                    setupLazyCustomConversion(image);
+                    break;
+                case BufferedImage.TYPE_INT_ARGB_PRE:
+                    throw new GLException("INT_ARGB_PRE n.a.");
+                case BufferedImage.TYPE_INT_BGR:
+                    throw new GLException("INT_BGR n.a.");
+                case BufferedImage.TYPE_3BYTE_BGR:
+                    throw new GLException("INT_BGR n.a.");
+                case BufferedImage.TYPE_4BYTE_ABGR_PRE:
+                    throw new GLException("INT_BGR n.a.");
+                case BufferedImage.TYPE_USHORT_565_RGB:
+                    pixelFormat = GL.GL_RGB;
+                    pixelType = GL.GL_UNSIGNED_SHORT_5_6_5;
+                    rowLength = scanlineStride;
+                    alignment = 2;
+                    expectingGL12 = true;
+                    setupLazyCustomConversion(image);
+                    break;
+                case BufferedImage.TYPE_USHORT_555_RGB:
+                    pixelFormat = GL.GL_RGBA;
+                    pixelType = GL.GL_UNSIGNED_SHORT_5_5_5_1;
+                    rowLength = scanlineStride;
+                    alignment = 2;
+                    expectingGL12 = true;
+                    setupLazyCustomConversion(image);
+                    break;
+                case BufferedImage.TYPE_BYTE_GRAY:
+                    pixelFormat = GL.GL_LUMINANCE;
+                    pixelType = GL.GL_UNSIGNED_BYTE;
+                    rowLength = scanlineStride;
+                    alignment = 1;
+                    break;
+                case BufferedImage.TYPE_USHORT_GRAY:
+                    throw new GLException("USHORT_GRAY n.a.");
+                    // Note: TYPE_INT_ARGB and TYPE_4BYTE_ABGR images go down the
+                    // custom code path to satisfy the invariant that images with an
+                    // alpha channel always go down with premultiplied alpha.
+                case BufferedImage.TYPE_INT_ARGB:
+                case BufferedImage.TYPE_4BYTE_ABGR:
+                case BufferedImage.TYPE_BYTE_BINARY:
+                case BufferedImage.TYPE_BYTE_INDEXED:
+                case BufferedImage.TYPE_CUSTOM:
+                default:
+                    ColorModel cm = image.getColorModel();
+                    if (cm.equals(rgbColorModel)) {
+                        pixelFormat = GL.GL_RGB;
+                        pixelType = GL.GL_UNSIGNED_BYTE;
+                        rowLength = scanlineStride / 3;
+                        alignment = 1;
+                    } else if (cm.equals(rgbaColorModel)) {
+                        pixelFormat = GL.GL_RGBA;
+                        pixelType = GL.GL_UNSIGNED_BYTE;
+                        rowLength = scanlineStride / 4; // FIXME: correct?
+                        alignment = 4;
+                    } else {
+                        setupLazyCustomConversion(image);
+                        return;
+                    }
+                    break;
+            }
+        }
+
+        createNIOBufferFromImage(image);
+    }
+
+    private void setupLazyCustomConversion(BufferedImage image) {
+        imageForLazyCustomConversion = image;
+        boolean hasAlpha = image.getColorModel().hasAlpha();
+        if (pixelFormat == 0) {
+            pixelFormat = hasAlpha ? GL.GL_RGBA : GL.GL_RGB;
+        }
+        alignment = 1; // FIXME: do we need better?
+        rowLength = width; // FIXME: correct in all cases?
+
+        // Allow previously-selected pixelType (if any) to override that
+        // we can infer from the DataBuffer
+        DataBuffer data = image.getRaster().getDataBuffer();
+        if (data instanceof DataBufferByte || isPackedInt(image)) {
+            // Don't use GL_UNSIGNED_INT for BufferedImage packed int images
+            if (pixelType == 0) pixelType = GL.GL_UNSIGNED_BYTE;
+        } else if (data instanceof DataBufferDouble) {
+            throw new RuntimeException("DataBufferDouble rasters not supported by OpenGL");
+        } else if (data instanceof DataBufferFloat) {
+            if (pixelType == 0) pixelType = GL.GL_FLOAT;
+        } else if (data instanceof DataBufferInt) {
+            // FIXME: should we support signed ints?
+            if (pixelType == 0) pixelType = GL2GL3.GL_UNSIGNED_INT;
+        } else if (data instanceof DataBufferShort) {
+            if (pixelType == 0) pixelType = GL.GL_SHORT;
+        } else if (data instanceof DataBufferUShort) {
+            if (pixelType == 0) pixelType = GL.GL_UNSIGNED_SHORT;
+        } else {
+            throw new RuntimeException("Unexpected DataBuffer type?");
+        }
+    }
+
+    private void createFromCustom(BufferedImage image) {
+        int width = image.getWidth();
+        int height = image.getHeight();
+
+        // create a temporary image that is compatible with OpenGL
+        boolean hasAlpha = image.getColorModel().hasAlpha();
+        ColorModel cm = null;
+        int dataBufferType = image.getRaster().getDataBuffer().getDataType();
+        // Don't use integer components for packed int images
+        if (isPackedInt(image)) {
+            dataBufferType = DataBuffer.TYPE_BYTE;
+        }
+        if (dataBufferType == DataBuffer.TYPE_BYTE) {
+            cm = hasAlpha ? rgbaColorModel : rgbColorModel;
+        } else {
+            if (hasAlpha) {
+                cm = new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_sRGB),
+                                             null, true, true,
+                                             Transparency.TRANSLUCENT,
+                                             dataBufferType);
+            } else {
+                cm = new ComponentColorModel(ColorSpace.getInstance(ColorSpace.CS_sRGB),
+                                             null, false, false,
+                                             Transparency.OPAQUE,
+                                             dataBufferType);
+            }
+        }
+
+        boolean premult = cm.isAlphaPremultiplied();
+        WritableRaster raster =
+            cm.createCompatibleWritableRaster(width, height);
+        BufferedImage texImage = new BufferedImage(cm, raster, premult, null);
+
+        // copy the source image into the temporary image
+        Graphics2D g = texImage.createGraphics();
+        g.setComposite(AlphaComposite.Src);
+        g.drawImage(image, 0, 0, null);
+        g.dispose();
+
+        // Wrap the buffer from the temporary image
+        createNIOBufferFromImage(texImage);
+    }
+
+    private boolean isPackedInt(BufferedImage image) {
+        int imgType = image.getType();
+        return (imgType == BufferedImage.TYPE_INT_RGB ||
+                imgType == BufferedImage.TYPE_INT_BGR ||
+                imgType == BufferedImage.TYPE_INT_ARGB ||
+                imgType == BufferedImage.TYPE_INT_ARGB_PRE);
+    }
+
+    private void revertPixelFormatAndType() {
+        // Knowing we don't have e.g. OpenGL 1.2 functionality available,
+        // and knowing we're in the process of doing the fallback code
+        // path, re-infer a vanilla pixel format and type compatible with
+        // OpenGL 1.1
+        pixelFormat = 0;
+        pixelType = 0;
+        setupLazyCustomConversion(imageForLazyCustomConversion);
+    }
+
+    private void createNIOBufferFromImage(BufferedImage image) {
+        buffer = wrapImageDataBuffer(image);
+    }
+
+    private Buffer wrapImageDataBuffer(BufferedImage image) {
+        //
+        // Note: Grabbing the DataBuffer will defeat Java2D's image
+        // management mechanism (as of JDK 5/6, at least).  This shouldn't
+        // be a problem for most JOGL apps, but those that try to upload
+        // the image into an OpenGL texture and then use the same image in
+        // Java2D rendering might find the 2D rendering is not as fast as
+        // it could be.
+        //
+
+        DataBuffer data = image.getRaster().getDataBuffer();
+        if (data instanceof DataBufferByte) {
+            return ByteBuffer.wrap(((DataBufferByte) data).getData());
+        } else if (data instanceof DataBufferDouble) {
+            throw new RuntimeException("DataBufferDouble rasters not supported by OpenGL");
+        } else if (data instanceof DataBufferFloat) {
+            return FloatBuffer.wrap(((DataBufferFloat) data).getData());
+        } else if (data instanceof DataBufferInt) {
+            return IntBuffer.wrap(((DataBufferInt) data).getData());
+        } else if (data instanceof DataBufferShort) {
+            return ShortBuffer.wrap(((DataBufferShort) data).getData());
+        } else if (data instanceof DataBufferUShort) {
+            return ShortBuffer.wrap(((DataBufferUShort) data).getData());
+        } else {
+            throw new RuntimeException("Unexpected DataBuffer type?");
+        }
+    }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/texture/awt/AWTTextureIO.java b/src/jogl/classes/com/jogamp/opengl/util/texture/awt/AWTTextureIO.java
new file mode 100644
index 000000000..fdd1365f7
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/texture/awt/AWTTextureIO.java
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2005 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util.texture.awt;
+
+import java.awt.image.*;
+
+import javax.media.opengl.*;
+import com.jogamp.opengl.util.texture.*;
+
+public class AWTTextureIO extends TextureIO {
+    /**
+     * Creates a TextureData from the given BufferedImage. Does no
+     * OpenGL work.
+     * We assume a desktop GLProfile GL2GL3, otherwise use the other factory.
+     *
+     * @param glp the OpenGL Profile this texture data should be
+     *                  created for.
+     * @param image the BufferedImage containing the texture data
+     * @param mipmap     whether mipmaps should be produced for this
+     *                   texture by autogenerating them
+     * @return the texture data from the image
+     *
+     * @see #newTextureData(GLProfile, BufferedImage, boolean)
+     */
+    public static TextureData newTextureData(GLProfile glp, BufferedImage image,
+                                             boolean mipmap) {
+        return newTextureDataImpl(glp, image, 0, 0, mipmap);
+    }
+
+    /**
+     * Creates a TextureData from the given BufferedImage, using the
+     * specified OpenGL internal format and pixel format for the texture
+     * which will eventually result. The internalFormat and pixelFormat
+     * must be specified and may not be zero; to use default values, use
+     * the variant of this method which does not take these
+     * arguments. Does no OpenGL work.
+     *
+     * @param glp the OpenGL Profile this texture data should be
+     *                  created for.
+     * @param image the BufferedImage containing the texture data
+     * @param internalFormat the OpenGL internal format of the texture
+     *                   which will eventually result from the TextureData
+     * @param pixelFormat the OpenGL pixel format of the texture
+     *                    which will eventually result from the TextureData
+     * @param mipmap     whether mipmaps should be produced for this
+     *                   texture either by autogenerating them or
+     *                   reading them from the file. Some file formats
+     *                   support multiple mipmaps in a single file in
+     *                   which case those mipmaps will be used rather
+     *                   than generating them.
+     * @return the texture data from the image
+     * @throws IllegalArgumentException if either internalFormat or
+     *                                  pixelFormat was 0
+     */
+    public static TextureData newTextureData(GLProfile glp, BufferedImage image,
+                                             int internalFormat,
+                                             int pixelFormat,
+                                             boolean mipmap) throws IllegalArgumentException {
+        if ((internalFormat == 0) || (pixelFormat == 0)) {
+            throw new IllegalArgumentException("internalFormat and pixelFormat must be non-zero");
+        }
+
+        return newTextureDataImpl(glp, image, internalFormat, pixelFormat, mipmap);
+    }
+
+    /** 
+     * Creates an OpenGL texture object from the specified BufferedImage
+     * using the current OpenGL context.
+     *
+     * @param glp the OpenGL Profile this texture data should be
+     *                  created for.
+     * @param image the BufferedImage from which to read the texture data
+     * @param mipmap     whether mipmaps should be produced for this
+     *                   texture by autogenerating them
+     * @throws GLException if no OpenGL context is current or if an
+     *                     OpenGL error occurred
+     */
+    public static Texture newTexture(GLProfile glp, BufferedImage image, boolean mipmap) throws GLException {
+        TextureData data = newTextureData(glp, image, mipmap);
+        Texture texture = newTexture(data);
+        data.flush();
+        return texture;
+    }
+
+    private static TextureData newTextureDataImpl(GLProfile glp, 
+                                                  BufferedImage image,
+                                                  int internalFormat,
+                                                  int pixelFormat,
+                                                  boolean mipmap) {
+        return new AWTTextureData(glp, internalFormat, pixelFormat, mipmap, image);
+    }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/texture/spi/DDSImage.java.javame_cdc_fp b/src/jogl/classes/com/jogamp/opengl/util/texture/spi/DDSImage.java.javame_cdc_fp
new file mode 100755
index 000000000..4feeb9f4e
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/texture/spi/DDSImage.java.javame_cdc_fp
@@ -0,0 +1,889 @@
+/*
+ * Copyright (c) 2005 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util.texture.spi;
+
+import java.io.*;
+import java.nio.*;
+
+import javax.media.opengl.*;
+import com.jogamp.opengl.util.*;
+import com.jogamp.opengl.util.texture.*;
+
+/** A reader and writer for DirectDraw Surface (.dds) files, which are
+    used to describe textures. These files can contain multiple mipmap
+    levels in one file. This class is currently minimal and does not
+    support all of the possible file formats. */
+
+public class DDSImage {
+
+    /** Simple class describing images and data; does not encapsulate
+        image format information. User is responsible for transmitting
+        that information in another way. */
+
+    public static class ImageInfo {
+        private ByteBuffer data;
+        private int width;
+        private int height;
+        private boolean isCompressed;
+        private int compressionFormat;
+
+        public ImageInfo(ByteBuffer data, int width, int height, boolean compressed, int compressionFormat) {
+            this.data = data; this.width = width; this.height = height;
+            this.isCompressed = compressed; this.compressionFormat = compressionFormat;
+        }
+        public int        getWidth()  { return width;  }
+        public int        getHeight() { return height; }
+        public ByteBuffer getData()   { return data;   }
+        public boolean    isCompressed() { return isCompressed; }
+        public int        getCompressionFormat() {
+            if (!isCompressed())
+                throw new RuntimeException("Should not call unless compressed");
+            return compressionFormat;
+        }
+    }
+
+    private ByteBuffer buf;
+    private Header header;
+
+    //
+    // Selected bits in header flags
+    //
+
+    public static final int DDSD_CAPS            = 0x00000001; // Capacities are valid
+    public static final int DDSD_HEIGHT          = 0x00000002; // Height is valid
+    public static final int DDSD_WIDTH           = 0x00000004; // Width is valid
+    public static final int DDSD_PITCH           = 0x00000008; // Pitch is valid
+    public static final int DDSD_BACKBUFFERCOUNT = 0x00000020; // Back buffer count is valid
+    public static final int DDSD_ZBUFFERBITDEPTH = 0x00000040; // Z-buffer bit depth is valid (shouldn't be used in DDSURFACEDESC2)
+    public static final int DDSD_ALPHABITDEPTH   = 0x00000080; // Alpha bit depth is valid
+    public static final int DDSD_LPSURFACE       = 0x00000800; // lpSurface is valid
+    public static final int DDSD_PIXELFORMAT     = 0x00001000; // ddpfPixelFormat is valid
+    public static final int DDSD_MIPMAPCOUNT     = 0x00020000; // Mip map count is valid
+    public static final int DDSD_LINEARSIZE      = 0x00080000; // dwLinearSize is valid
+    public static final int DDSD_DEPTH           = 0x00800000; // dwDepth is valid
+
+    public static final int DDPF_ALPHAPIXELS     = 0x00000001; // Alpha channel is present
+    public static final int DDPF_ALPHA           = 0x00000002; // Only contains alpha information
+    public static final int DDPF_FOURCC          = 0x00000004; // FourCC code is valid
+    public static final int DDPF_PALETTEINDEXED4 = 0x00000008; // Surface is 4-bit color indexed
+    public static final int DDPF_PALETTEINDEXEDTO8 = 0x00000010; // Surface is indexed into a palette which stores indices
+    // into the destination surface's 8-bit palette
+    public static final int DDPF_PALETTEINDEXED8 = 0x00000020; // Surface is 8-bit color indexed
+    public static final int DDPF_RGB             = 0x00000040; // RGB data is present
+    public static final int DDPF_COMPRESSED      = 0x00000080; // Surface will accept pixel data in the format specified
+    // and compress it during the write
+    public static final int DDPF_RGBTOYUV        = 0x00000100; // Surface will accept RGB data and translate it during
+    // the write to YUV data. The format of the data to be written
+    // will be contained in the pixel format structure. The DDPF_RGB
+    // flag will be set.
+    public static final int DDPF_YUV             = 0x00000200; // Pixel format is YUV - YUV data in pixel format struct is valid
+    public static final int DDPF_ZBUFFER         = 0x00000400; // Pixel format is a z buffer only surface
+    public static final int DDPF_PALETTEINDEXED1 = 0x00000800; // Surface is 1-bit color indexed
+    public static final int DDPF_PALETTEINDEXED2 = 0x00001000; // Surface is 2-bit color indexed
+    public static final int DDPF_ZPIXELS         = 0x00002000; // Surface contains Z information in the pixels
+
+    // Selected bits in DDS capabilities flags
+    public static final int DDSCAPS_TEXTURE      = 0x00001000; // Can be used as a texture
+    public static final int DDSCAPS_MIPMAP       = 0x00400000; // Is one level of a mip-map
+    public static final int DDSCAPS_COMPLEX      = 0x00000008; // Complex surface structure, such as a cube map
+
+    // Selected bits in DDS extended capabilities flags
+    public static final int DDSCAPS2_CUBEMAP           = 0x00000200;
+    public static final int DDSCAPS2_CUBEMAP_POSITIVEX = 0x00000400;
+    public static final int DDSCAPS2_CUBEMAP_NEGATIVEX = 0x00000800;
+    public static final int DDSCAPS2_CUBEMAP_POSITIVEY = 0x00001000;
+    public static final int DDSCAPS2_CUBEMAP_NEGATIVEY = 0x00002000;
+    public static final int DDSCAPS2_CUBEMAP_POSITIVEZ = 0x00004000;
+    public static final int DDSCAPS2_CUBEMAP_NEGATIVEZ = 0x00008000;
+
+    // Known pixel formats
+    public static final int D3DFMT_UNKNOWN   =  0;
+    public static final int D3DFMT_R8G8B8    =  20;
+    public static final int D3DFMT_A8R8G8B8  =  21;
+    public static final int D3DFMT_X8R8G8B8  =  22;
+    // The following are also valid FourCC codes
+    public static final int D3DFMT_DXT1      =  0x31545844;
+    public static final int D3DFMT_DXT2      =  0x32545844;
+    public static final int D3DFMT_DXT3      =  0x33545844;
+    public static final int D3DFMT_DXT4      =  0x34545844;
+    public static final int D3DFMT_DXT5      =  0x35545844;
+
+    /** Reads a DirectDraw surface from the specified file name,
+        returning the resulting DDSImage.
+
+        @param filename File name
+        @return DDS image object
+        @throws java.io.IOException if an I/O exception occurred
+    */
+    public static DDSImage read(String filename) throws IOException {
+        return read(new File(filename));
+    }
+  
+    /** Reads a DirectDraw surface from the specified file, returning
+        the resulting DDSImage.
+
+        @param file File object
+        @return DDS image object
+        @throws java.io.IOException if an I/O exception occurred
+    */
+    public static DDSImage read(File file) throws IOException {
+        DDSImage image = new DDSImage();
+        image.readFromFile(file);
+        return image;
+    }
+
+    /** Reads a DirectDraw surface from the specified InputStream, returning
+        the resulting DDSImage.
+
+        @param input Input stream
+        @return DDS image object
+        @throws java.io.IOException if an I/O exception occurred
+    */
+    public static DDSImage read(InputStream input) throws IOException {
+        DDSImage image = new DDSImage();
+        image.readFromStream(input);
+        return image;
+    }
+
+    /** Closes open files and resources associated with the open
+        DDSImage. No other methods may be called on this object once
+        this is called. */
+    public void close() {
+    }
+
+    /** 
+     * Creates a new DDSImage from data supplied by the user. The
+     * resulting DDSImage can be written to disk using the write()
+     * method.
+     *
+     * @param d3dFormat the D3DFMT_ constant describing the data; it is
+     *                  assumed that it is packed tightly
+     * @param width  the width in pixels of the topmost mipmap image
+     * @param height the height in pixels of the topmost mipmap image
+     * @param mipmapData the data for each mipmap level of the resulting
+     *                   DDSImage; either only one mipmap level should
+     *                   be specified, or they all must be
+     * @throws IllegalArgumentException if the data does not match the
+     *   specified arguments
+     * @return DDS image object
+     */
+    public static DDSImage createFromData(int d3dFormat,
+                                          int width,
+                                          int height,
+                                          ByteBuffer[] mipmapData) throws IllegalArgumentException {
+        DDSImage image = new DDSImage();
+        image.initFromData(d3dFormat, width, height, mipmapData);
+        return image;
+    }
+
+    /** Determines from the magic number whether the given InputStream
+        points to a DDS image. The given InputStream must return true
+        from markSupported() and support a minimum of four bytes of
+        read-ahead.
+
+        @param in Stream to check
+        @return true if input stream is DDS image or false otherwise
+        @throws java.io.IOException if an I/O exception occurred
+    */
+    public static boolean isDDSImage(InputStream in) throws IOException {
+        if (!(in instanceof BufferedInputStream)) {
+            in = new BufferedInputStream(in);
+        }
+        if (!in.markSupported()) {
+            throw new IOException("Can not test non-destructively whether given InputStream is a DDS image");
+        }
+        in.mark(4);
+        int magic = 0;
+        for (int i = 0; i < 4; i++) {
+            int tmp = in.read();
+            if (tmp < 0) {
+                in.reset();
+                return false;
+            }
+            magic = ((magic >>> 8) | (tmp << 24));
+        }
+        in.reset();
+        return (magic == MAGIC);
+    }
+
+    /**
+     * Writes this DDSImage to the specified file name.
+     * @param filename File name to write to
+     * @throws java.io.IOException if an I/O exception occurred
+     */
+    public void write(String filename) throws IOException {
+        write(new File(filename));
+    }
+
+    /**
+     * Writes this DDSImage to the specified file name.
+     * @param file File object to write to
+     * @throws java.io.IOException if an I/O exception occurred
+     */
+    public void write(File file) throws IOException {
+        LEDataOutputStream output =
+            new LEDataOutputStream(new DataOutputStream(new BufferedOutputStream(new FileOutputStream(file))));
+        header.write(output);
+        output.write(buf.array());
+        output.close();
+    }
+
+    /** Test for presence/absence of surface description flags (DDSD_*)
+     * @param flag DDSD_* flags set to test
+     * @return true if flag present or false otherwise
+     */
+    public boolean isSurfaceDescFlagSet(int flag) {
+        return ((header.flags & flag) != 0);
+    }
+
+    /** Test for presence/absence of pixel format flags (DDPF_*) */
+    public boolean isPixelFormatFlagSet(int flag) {
+        return ((header.pfFlags & flag) != 0);
+    }
+
+    /** Gets the pixel format of this texture (D3DFMT_*) based on some
+        heuristics. Returns D3DFMT_UNKNOWN if could not recognize the
+        pixel format. */
+    public int getPixelFormat() {
+        if (isCompressed()) {
+            return getCompressionFormat();
+        } else if (isPixelFormatFlagSet(DDPF_RGB)) {
+            if (isPixelFormatFlagSet(DDPF_ALPHAPIXELS)) {
+                if (getDepth() == 32 &&
+                    header.pfRBitMask == 0x00FF0000 &&
+                    header.pfGBitMask == 0x0000FF00 &&
+                    header.pfBBitMask == 0x000000FF &&
+                    header.pfABitMask == 0xFF000000) {
+                    return D3DFMT_A8R8G8B8;
+                }
+            } else {
+                if (getDepth() == 24 &&
+                    header.pfRBitMask == 0x00FF0000 &&
+                    header.pfGBitMask == 0x0000FF00 &&
+                    header.pfBBitMask == 0x000000FF) {
+                    return D3DFMT_R8G8B8;
+                } else if (getDepth() == 32 &&
+                           header.pfRBitMask == 0x00FF0000 &&
+                           header.pfGBitMask == 0x0000FF00 &&
+                           header.pfBBitMask == 0x000000FF) {
+                    return D3DFMT_X8R8G8B8;
+                }
+            }
+        }
+
+        return D3DFMT_UNKNOWN;
+    }
+
+    /**
+     * Indicates whether this texture is cubemap
+     * @return true if cubemap or false otherwise
+     */
+    public boolean isCubemap() {
+        return ((header.ddsCaps1 & DDSCAPS_COMPLEX) != 0) && ((header.ddsCaps2 & DDSCAPS2_CUBEMAP) != 0);
+    }
+
+    /**
+     * Indicates whethe this cubemap side present
+     * @param side Side to test
+     * @return true if side present or false otherwise
+     */
+    public boolean isCubemapSidePresent(int side) {
+        return isCubemap() && (header.ddsCaps2 & side) != 0;
+    }
+
+    /** Indicates whether this texture is compressed. */
+    public boolean isCompressed() {
+        return (isPixelFormatFlagSet(DDPF_FOURCC));
+    }
+
+    /** If this surface is compressed, returns the kind of compression
+        used (DXT1..DXT5). */
+    public int getCompressionFormat() {
+        return header.pfFourCC;
+    }
+
+    /** Width of the texture (or the top-most mipmap if mipmaps are
+        present) */
+    public int getWidth() {
+        return header.width;
+    }
+
+    /** Height of the texture (or the top-most mipmap if mipmaps are
+        present) */
+    public int getHeight() {
+        return header.height;
+    }
+
+    /** Total number of bits per pixel. Only valid if DDPF_RGB is
+        present. For A8R8G8B8, would be 32. */
+    public int getDepth() {
+        return header.pfRGBBitCount;
+    }
+
+    /** Number of mip maps in the texture */
+    public int getNumMipMaps() {
+        if (!isSurfaceDescFlagSet(DDSD_MIPMAPCOUNT)) {
+            return 0;
+        }
+        return header.mipMapCountOrAux;
+    }
+
+    /** Gets the <i>i</i>th mipmap data (0..getNumMipMaps() - 1)
+     * @param map Mipmap index
+     * @return Image object
+     */
+    public ImageInfo getMipMap(int map) {
+        return getMipMap( 0, map );
+    }
+
+    /**
+     * Gets the <i>i</i>th mipmap data (0..getNumMipMaps() - 1)
+     * @param side Cubemap side or 0 for 2D texture
+     * @param map Mipmap index
+     * @return Image object
+     */
+    public ImageInfo getMipMap(int side, int map) {
+        if (!isCubemap() && (side != 0)) {
+            throw new RuntimeException( "Illegal side for 2D texture: " + side );
+        }
+        if (isCubemap() && !isCubemapSidePresent(side)) {
+            throw new RuntimeException( "Illegal side, side not present: " + side );
+        }
+        if (getNumMipMaps() > 0 &&
+            ((map < 0) || (map >= getNumMipMaps()))) {
+            throw new RuntimeException("Illegal mipmap number " + map + " (0.." + (getNumMipMaps() - 1) + ")");
+        }
+
+        // Figure out how far to seek
+        int seek = 0;
+        if (isCubemap()) {
+            seek += sideShiftInBytes(side);
+        }
+        for (int i = 0; i < map; i++) {
+            seek += mipMapSizeInBytes(i);
+        }
+        buf.limit(seek + mipMapSizeInBytes(map));
+        buf.position(seek);
+        ByteBuffer next = buf.slice();
+        buf.position(0);
+        buf.limit(buf.capacity());
+        return new ImageInfo(next, mipMapWidth(map), mipMapHeight(map), isCompressed(), getCompressionFormat());
+    }
+
+    /** Returns an array of ImageInfos corresponding to all mipmap
+        levels of this DDS file.
+        @return Mipmap image objects set
+    */
+    public ImageInfo[] getAllMipMaps() {
+        return getAllMipMaps(0);
+    }
+
+    /**
+     * Returns an array of ImageInfos corresponding to all mipmap
+     * levels of this DDS file.
+     * @param side Cubemap side or 0 for 2D texture
+     * @return Mipmap image objects set
+     */
+    public ImageInfo[] getAllMipMaps( int side ) {
+        int numLevels = getNumMipMaps();
+        if (numLevels == 0) {
+            numLevels = 1;
+        }
+        ImageInfo[] result = new ImageInfo[numLevels];
+        for (int i = 0; i < numLevels; i++) {
+            result[i] = getMipMap(side, i);
+        }
+        return result;
+    }
+
+    /** Converts e.g. DXT1 compression format constant (see {@link
+        #getCompressionFormat}) into "DXT1".
+        @param compressionFormat Compression format constant
+        @return String format code
+    */
+    public static String getCompressionFormatName(int compressionFormat) {
+        StringBuffer buf = new StringBuffer();
+        for (int i = 0; i < 4; i++) {
+            char c = (char) (compressionFormat & 0xFF);
+            buf.append(c);
+            compressionFormat = compressionFormat >> 8;
+        }
+        return buf.toString();
+    }
+
+    /** Allocates a temporary, empty ByteBuffer suitable for use in a
+        call to glCompressedTexImage2D. This is used by the Texture
+        class to expand non-power-of-two DDS compressed textures to
+        power-of-two sizes on hardware not supporting OpenGL 2.0 and the
+        NPOT texture extension. The specified OpenGL internal format
+        must be one of GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
+        GL_COMPRESSED_RGBA_S3TC_DXT1_EXT,
+        GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, or
+        GL_COMPRESSED_RGBA_S3TC_DXT5_EXT.
+    */
+    public static ByteBuffer allocateBlankBuffer(int width,
+                                                 int height,
+                                                 int openGLInternalFormat) {
+        int size = width * height;
+        switch (openGLInternalFormat) {
+        case GL.GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
+        case GL.GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
+            size /= 2;
+            break;
+
+        case GL.GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
+        case GL.GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
+            break;
+
+        default:
+            throw new IllegalArgumentException("Illegal OpenGL texture internal format " +
+                                               openGLInternalFormat);
+        }
+        if (size == 0)
+            size = 1;
+        return BufferUtil.newByteBuffer(size);
+    }
+
+    public void debugPrint() {
+        PrintStream tty = System.err;
+        tty.println("Compressed texture: " + isCompressed());
+        if (isCompressed()) {
+            int fmt = getCompressionFormat();
+            String name = getCompressionFormatName(fmt);
+            tty.println("Compression format: 0x" + Integer.toHexString(fmt) + " (" + name + ")");
+        }
+        tty.println("Width: " + header.width + " Height: " + header.height);
+        tty.println("header.pitchOrLinearSize: " + header.pitchOrLinearSize);
+        tty.println("header.pfRBitMask: 0x" + Integer.toHexString(header.pfRBitMask));
+        tty.println("header.pfGBitMask: 0x" + Integer.toHexString(header.pfGBitMask));
+        tty.println("header.pfBBitMask: 0x" + Integer.toHexString(header.pfBBitMask));
+        tty.println("SurfaceDesc flags:");
+        boolean recognizedAny = false;
+        recognizedAny |= printIfRecognized(tty, header.flags, DDSD_CAPS, "DDSD_CAPS");
+        recognizedAny |= printIfRecognized(tty, header.flags, DDSD_HEIGHT, "DDSD_HEIGHT");
+        recognizedAny |= printIfRecognized(tty, header.flags, DDSD_WIDTH, "DDSD_WIDTH");
+        recognizedAny |= printIfRecognized(tty, header.flags, DDSD_PITCH, "DDSD_PITCH");
+        recognizedAny |= printIfRecognized(tty, header.flags, DDSD_BACKBUFFERCOUNT, "DDSD_BACKBUFFERCOUNT");
+        recognizedAny |= printIfRecognized(tty, header.flags, DDSD_ZBUFFERBITDEPTH, "DDSD_ZBUFFERBITDEPTH");
+        recognizedAny |= printIfRecognized(tty, header.flags, DDSD_ALPHABITDEPTH, "DDSD_ALPHABITDEPTH");
+        recognizedAny |= printIfRecognized(tty, header.flags, DDSD_LPSURFACE, "DDSD_LPSURFACE");
+        recognizedAny |= printIfRecognized(tty, header.flags, DDSD_PIXELFORMAT, "DDSD_PIXELFORMAT");
+        recognizedAny |= printIfRecognized(tty, header.flags, DDSD_MIPMAPCOUNT, "DDSD_MIPMAPCOUNT");
+        recognizedAny |= printIfRecognized(tty, header.flags, DDSD_LINEARSIZE, "DDSD_LINEARSIZE");
+        recognizedAny |= printIfRecognized(tty, header.flags, DDSD_DEPTH, "DDSD_DEPTH");
+        if (!recognizedAny) {
+            tty.println("(none)");
+        }
+        tty.println("Raw SurfaceDesc flags: 0x" + Integer.toHexString(header.flags));
+        tty.println("Pixel format flags:");
+        recognizedAny = false;
+        recognizedAny |= printIfRecognized(tty, header.pfFlags, DDPF_ALPHAPIXELS, "DDPF_ALPHAPIXELS");
+        recognizedAny |= printIfRecognized(tty, header.pfFlags, DDPF_ALPHA, "DDPF_ALPHA");
+        recognizedAny |= printIfRecognized(tty, header.pfFlags, DDPF_FOURCC, "DDPF_FOURCC");
+        recognizedAny |= printIfRecognized(tty, header.pfFlags, DDPF_PALETTEINDEXED4, "DDPF_PALETTEINDEXED4");
+        recognizedAny |= printIfRecognized(tty, header.pfFlags, DDPF_PALETTEINDEXEDTO8, "DDPF_PALETTEINDEXEDTO8");
+        recognizedAny |= printIfRecognized(tty, header.pfFlags, DDPF_PALETTEINDEXED8, "DDPF_PALETTEINDEXED8");
+        recognizedAny |= printIfRecognized(tty, header.pfFlags, DDPF_RGB, "DDPF_RGB");
+        recognizedAny |= printIfRecognized(tty, header.pfFlags, DDPF_COMPRESSED, "DDPF_COMPRESSED");
+        recognizedAny |= printIfRecognized(tty, header.pfFlags, DDPF_RGBTOYUV, "DDPF_RGBTOYUV");
+        recognizedAny |= printIfRecognized(tty, header.pfFlags, DDPF_YUV, "DDPF_YUV");
+        recognizedAny |= printIfRecognized(tty, header.pfFlags, DDPF_ZBUFFER, "DDPF_ZBUFFER");
+        recognizedAny |= printIfRecognized(tty, header.pfFlags, DDPF_PALETTEINDEXED1, "DDPF_PALETTEINDEXED1");
+        recognizedAny |= printIfRecognized(tty, header.pfFlags, DDPF_PALETTEINDEXED2, "DDPF_PALETTEINDEXED2");
+        recognizedAny |= printIfRecognized(tty, header.pfFlags, DDPF_ZPIXELS, "DDPF_ZPIXELS");
+        if (!recognizedAny) {
+            tty.println("(none)");
+        }
+        tty.println("Raw pixel format flags: 0x" + Integer.toHexString(header.pfFlags));
+        tty.println("Depth: " + getDepth());
+        tty.println("Number of mip maps: " + getNumMipMaps());
+        int fmt = getPixelFormat();
+        tty.print("Pixel format: ");
+        switch (fmt) {
+        case D3DFMT_R8G8B8:   tty.println("D3DFMT_R8G8B8"); break;
+        case D3DFMT_A8R8G8B8: tty.println("D3DFMT_A8R8G8B8"); break;
+        case D3DFMT_X8R8G8B8: tty.println("D3DFMT_X8R8G8B8"); break;
+        case D3DFMT_DXT1:     tty.println("D3DFMT_DXT1"); break;
+        case D3DFMT_DXT2:     tty.println("D3DFMT_DXT2"); break;
+        case D3DFMT_DXT3:     tty.println("D3DFMT_DXT3"); break;
+        case D3DFMT_DXT4:     tty.println("D3DFMT_DXT4"); break;
+        case D3DFMT_DXT5:     tty.println("D3DFMT_DXT5"); break;
+        case D3DFMT_UNKNOWN:  tty.println("D3DFMT_UNKNOWN"); break;
+        default:              tty.println("(unknown pixel format " + fmt + ")"); break;
+        }
+    }
+
+    //----------------------------------------------------------------------
+    // Internals only below this point
+    //
+
+    private static final int MAGIC = 0x20534444;
+
+    static class Header {
+        int size;                 // size of the DDSURFACEDESC structure
+        int flags;                // determines what fields are valid
+        int height;               // height of surface to be created
+        int width;                // width of input surface
+        int pitchOrLinearSize;
+        int backBufferCountOrDepth;
+        int mipMapCountOrAux;     // number of mip-map levels requested (in this context)
+        int alphaBitDepth;        // depth of alpha buffer requested
+        int reserved1;            // reserved
+        int surface;              // pointer to the associated surface memory
+        // NOTE: following two entries are from DDCOLORKEY data structure
+        // Are overlaid with color for empty cubemap faces (unused in this reader)
+        int colorSpaceLowValue;
+        int colorSpaceHighValue;
+        int destBltColorSpaceLowValue;
+        int destBltColorSpaceHighValue;
+        int srcOverlayColorSpaceLowValue;
+        int srcOverlayColorSpaceHighValue;
+        int srcBltColorSpaceLowValue;
+        int srcBltColorSpaceHighValue;
+        // NOTE: following entries are from DDPIXELFORMAT data structure
+        // Are overlaid with flexible vertex format description of vertex
+        // buffers (unused in this reader)
+        int pfSize;                 // size of DDPIXELFORMAT structure
+        int pfFlags;                // pixel format flags
+        int pfFourCC;               // (FOURCC code)
+        // Following five entries have multiple interpretations, not just
+        // RGBA (but that's all we support right now)
+        int pfRGBBitCount;          // how many bits per pixel
+        int pfRBitMask;             // mask for red bits
+        int pfGBitMask;             // mask for green bits
+        int pfBBitMask;             // mask for blue bits
+        int pfABitMask;             // mask for alpha channel
+        int ddsCaps1;               // Texture and mip-map flags
+        int ddsCaps2;               // Advanced capabilities including cubemap support
+        int ddsCapsReserved1;
+        int ddsCapsReserved2;
+        int textureStage;           // stage in multitexture cascade
+
+        void read(LEDataInputStream input) throws IOException {
+            int magic                     = input.readInt();
+            if (magic != MAGIC) {
+                throw new IOException("Incorrect magic number 0x" +
+                                      Integer.toHexString(magic) +
+                                      " (expected " + MAGIC + ")");
+            }
+
+            size                          = input.readInt();
+            flags                         = input.readInt();
+            height                        = input.readInt();
+            width                         = input.readInt();
+            pitchOrLinearSize             = input.readInt();
+            backBufferCountOrDepth        = input.readInt();
+            mipMapCountOrAux              = input.readInt();
+            alphaBitDepth                 = input.readInt();
+            reserved1                     = input.readInt();
+            surface                       = input.readInt();
+            colorSpaceLowValue            = input.readInt();
+            colorSpaceHighValue           = input.readInt();
+            destBltColorSpaceLowValue     = input.readInt();
+            destBltColorSpaceHighValue    = input.readInt();
+            srcOverlayColorSpaceLowValue  = input.readInt();
+            srcOverlayColorSpaceHighValue = input.readInt();
+            srcBltColorSpaceLowValue      = input.readInt();
+            srcBltColorSpaceHighValue     = input.readInt();
+            pfSize                        = input.readInt();
+            pfFlags                       = input.readInt();
+            pfFourCC                      = input.readInt();
+            pfRGBBitCount                 = input.readInt();
+            pfRBitMask                    = input.readInt();
+            pfGBitMask                    = input.readInt();
+            pfBBitMask                    = input.readInt();
+            pfABitMask                    = input.readInt();
+            ddsCaps1                      = input.readInt();
+            ddsCaps2                      = input.readInt();
+            ddsCapsReserved1              = input.readInt();
+            ddsCapsReserved2              = input.readInt();
+            textureStage                  = input.readInt();
+        }
+
+        // buf must be in little-endian byte order
+        void write(LEDataOutputStream output) throws IOException {
+            output.writeInt(MAGIC);
+            output.writeInt(size);
+            output.writeInt(flags);
+            output.writeInt(height);
+            output.writeInt(width);
+            output.writeInt(pitchOrLinearSize);
+            output.writeInt(backBufferCountOrDepth);
+            output.writeInt(mipMapCountOrAux);
+            output.writeInt(alphaBitDepth);
+            output.writeInt(reserved1);
+            output.writeInt(surface);
+            output.writeInt(colorSpaceLowValue);
+            output.writeInt(colorSpaceHighValue);
+            output.writeInt(destBltColorSpaceLowValue);
+            output.writeInt(destBltColorSpaceHighValue);
+            output.writeInt(srcOverlayColorSpaceLowValue);
+            output.writeInt(srcOverlayColorSpaceHighValue);
+            output.writeInt(srcBltColorSpaceLowValue);
+            output.writeInt(srcBltColorSpaceHighValue);
+            output.writeInt(pfSize);
+            output.writeInt(pfFlags);
+            output.writeInt(pfFourCC);
+            output.writeInt(pfRGBBitCount);
+            output.writeInt(pfRBitMask);
+            output.writeInt(pfGBitMask);
+            output.writeInt(pfBBitMask);
+            output.writeInt(pfABitMask);
+            output.writeInt(ddsCaps1);
+            output.writeInt(ddsCaps2);
+            output.writeInt(ddsCapsReserved1);
+            output.writeInt(ddsCapsReserved2);
+            output.writeInt(textureStage);
+        }
+
+        private static int size() {
+            return 124;
+        }
+
+        private static int pfSize() {
+            return 32;
+        }
+
+        private static int writtenSize() {
+            return 128;
+        }
+    }
+
+    private DDSImage() {
+    }
+
+    private void readFromFile(File file) throws IOException {
+        readFromStream(new BufferedInputStream(new FileInputStream(file)));
+    }
+
+    private void readFromStream(InputStream input) throws IOException {
+        LEDataInputStream leInput = new LEDataInputStream(input);
+        header = new Header();
+        header.read(leInput);
+        fixupHeader();
+        buf = StreamUtil.readAll2Buffer(input);
+    }
+
+    private void initFromData(int d3dFormat,
+                              int width,
+                              int height,
+                              ByteBuffer[] mipmapData) throws IllegalArgumentException {
+        // Check size of mipmap data compared against format, width and
+        // height
+        int topmostMipmapSize = width * height;
+        int pitchOrLinearSize = width;
+        boolean isCompressed = false;
+        switch (d3dFormat) {
+        case D3DFMT_R8G8B8:   topmostMipmapSize *= 3; pitchOrLinearSize *= 3; break;
+        case D3DFMT_A8R8G8B8: topmostMipmapSize *= 4; pitchOrLinearSize *= 4; break;
+        case D3DFMT_X8R8G8B8: topmostMipmapSize *= 4; pitchOrLinearSize *= 4; break;
+        case D3DFMT_DXT1:
+        case D3DFMT_DXT2:
+        case D3DFMT_DXT3:
+        case D3DFMT_DXT4:
+        case D3DFMT_DXT5:
+            topmostMipmapSize = computeCompressedBlockSize(width, height, 1, d3dFormat);
+            pitchOrLinearSize = topmostMipmapSize;
+            isCompressed = true;
+            break;
+        default:
+            throw new IllegalArgumentException("d3dFormat must be one of the known formats");
+        }
+    
+        // Now check the mipmaps against this size
+        int curSize = topmostMipmapSize;
+        int totalSize = 0;
+        for (int i = 0; i < mipmapData.length; i++) {
+            if (mipmapData[i].remaining() != curSize) {
+                throw new IllegalArgumentException("Mipmap level " + i +
+                                                   " didn't match expected data size (expected " + curSize + ", got " +
+                                                   mipmapData[i].remaining() + ")");
+            }
+            curSize /= 4;
+            totalSize += mipmapData[i].remaining();
+        }
+
+        // OK, create one large byte array to hold all of the mipmap data
+        byte[] data = new byte[totalSize];
+        ByteBuffer buf = ByteBuffer.wrap(data);
+        for (int i = 0; i < mipmapData.length; i++) {
+            buf.put(mipmapData[i]);
+        }
+        this.buf = buf;
+    
+        // Allocate and initialize a Header
+        header = new Header();
+        header.size = Header.size();
+        header.flags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
+        if (mipmapData.length > 1) {
+            header.flags |= DDSD_MIPMAPCOUNT;
+            header.mipMapCountOrAux = mipmapData.length;
+        }
+        header.width = width;
+        header.height = height;
+        if (isCompressed) {
+            header.flags |= DDSD_LINEARSIZE;
+            header.pfFlags |= DDPF_FOURCC;
+            header.pfFourCC = d3dFormat;
+        } else {
+            header.flags |= DDSD_PITCH;
+            // Figure out the various settings from the pixel format
+            header.pfFlags |= DDPF_RGB;
+            switch (d3dFormat) {
+            case D3DFMT_R8G8B8:   header.pfRGBBitCount = 24; break;
+            case D3DFMT_A8R8G8B8: header.pfRGBBitCount = 32; header.pfFlags |= DDPF_ALPHAPIXELS; break;
+            case D3DFMT_X8R8G8B8: header.pfRGBBitCount = 32; break;
+            }
+            header.pfRBitMask = 0x00FF0000;
+            header.pfGBitMask = 0x0000FF00;
+            header.pfBBitMask = 0x000000FF;
+            if (d3dFormat == D3DFMT_A8R8G8B8) {
+                header.pfABitMask = 0xFF000000;
+            }
+        }
+        header.pitchOrLinearSize = pitchOrLinearSize;
+        header.pfSize = Header.pfSize();
+        // Not sure whether we can get away with leaving the rest of the
+        // header blank
+    }
+
+    // Microsoft doesn't follow their own specifications and the
+    // simplest conversion using the DxTex tool to e.g. a DXT3 texture
+    // results in an illegal .dds file without either DDSD_PITCH or
+    // DDSD_LINEARSIZE set in the header's flags. This code, adapted
+    // from the DevIL library, fixes up the header in these situations.
+    private void fixupHeader() {
+        if (isCompressed() && !isSurfaceDescFlagSet(DDSD_LINEARSIZE)) {
+            // Figure out how big the linear size should be
+            int depth = header.backBufferCountOrDepth;
+            if (depth == 0) {
+                depth = 1;
+            }
+
+            header.pitchOrLinearSize = computeCompressedBlockSize(getWidth(), getHeight(), depth, getCompressionFormat());
+            header.flags |= DDSD_LINEARSIZE;
+        }
+    }
+
+    private static int computeCompressedBlockSize(int width,
+                                                  int height,
+                                                  int depth,
+                                                  int compressionFormat) {
+        int blockSize = ((width + 3)/4) * ((height + 3)/4) * ((depth + 3)/4);
+        switch (compressionFormat) {
+        case D3DFMT_DXT1:  blockSize *=  8; break;
+        default:           blockSize *= 16; break;
+        }
+        return blockSize;
+    }
+
+    private int mipMapWidth(int map) {
+        int width = getWidth();
+        for (int i = 0; i < map; i++) {
+            width >>= 1;
+        }
+        return Math.max(width, 1);
+    }
+
+    private int mipMapHeight(int map) {
+        int height = getHeight();
+        for (int i = 0; i < map; i++) {
+            height >>= 1;
+        }
+        return Math.max(height, 1);
+    }
+
+    private int mipMapSizeInBytes(int map) {
+        int width  = mipMapWidth(map);
+        int height = mipMapHeight(map);
+        if (isCompressed()) {
+            int blockSize = (getCompressionFormat() == D3DFMT_DXT1 ? 8 : 16);
+            return ((width+3)/4)*((height+3)/4)*blockSize;
+        } else {
+            return width * height * (getDepth() / 8);
+        }
+    }
+
+    private int sideSizeInBytes() {
+        int numLevels = getNumMipMaps();
+        if (numLevels == 0) {
+            numLevels = 1;
+        }
+
+        int size = 0;
+        for (int i = 0; i < numLevels; i++) {
+            size += mipMapSizeInBytes(i);
+        }
+
+        return size;
+    }
+
+    private int sideShiftInBytes(int side) {
+        int[] sides = {
+            DDSCAPS2_CUBEMAP_POSITIVEX,
+            DDSCAPS2_CUBEMAP_NEGATIVEX,
+            DDSCAPS2_CUBEMAP_POSITIVEY,
+            DDSCAPS2_CUBEMAP_NEGATIVEY,
+            DDSCAPS2_CUBEMAP_POSITIVEZ,
+            DDSCAPS2_CUBEMAP_NEGATIVEZ
+        };
+
+        int shift = 0;
+        int sideSize = sideSizeInBytes();
+        for (int i = 0; i < sides.length; i++) {
+            int temp = sides[i];
+            if ((temp & side) != 0) {
+                return shift;
+            }
+
+            shift += sideSize;
+        }
+
+        throw new RuntimeException("Illegal side: " + side);
+    }
+
+    private boolean printIfRecognized(PrintStream tty, int flags, int flag, String what) {
+        if ((flags & flag) != 0) {
+            tty.println(what);
+            return true;
+        }
+        return false;
+    }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/texture/spi/DDSImage.java.javase b/src/jogl/classes/com/jogamp/opengl/util/texture/spi/DDSImage.java.javase
new file mode 100755
index 000000000..b1f18cc9e
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/texture/spi/DDSImage.java.javase
@@ -0,0 +1,919 @@
+/*
+ * Copyright (c) 2005 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util.texture.spi;
+
+import java.io.*;
+import java.nio.*;
+import java.nio.channels.*;
+
+import javax.media.opengl.*;
+import com.jogamp.opengl.util.*;
+import com.jogamp.opengl.util.texture.*;
+
+/** A reader and writer for DirectDraw Surface (.dds) files, which are
+    used to describe textures. These files can contain multiple mipmap
+    levels in one file. This class is currently minimal and does not
+    support all of the possible file formats. */
+
+public class DDSImage {
+
+    /** Simple class describing images and data; does not encapsulate
+        image format information. User is responsible for transmitting
+        that information in another way. */
+
+    public static class ImageInfo {
+        private ByteBuffer data;
+        private int width;
+        private int height;
+        private boolean isCompressed;
+        private int compressionFormat;
+
+        public ImageInfo(ByteBuffer data, int width, int height, boolean compressed, int compressionFormat) {
+            this.data = data; this.width = width; this.height = height;
+            this.isCompressed = compressed; this.compressionFormat = compressionFormat;
+        }
+        public int        getWidth()  { return width;  }
+        public int        getHeight() { return height; }
+        public ByteBuffer getData()   { return data;   }
+        public boolean    isCompressed() { return isCompressed; }
+        public int        getCompressionFormat() {
+            if (!isCompressed())
+                throw new RuntimeException("Should not call unless compressed");
+            return compressionFormat;
+        }
+    }
+
+    private FileInputStream fis;
+    private FileChannel     chan;
+    private ByteBuffer buf;
+    private Header header;
+
+    //
+    // Selected bits in header flags
+    //
+
+    public static final int DDSD_CAPS            = 0x00000001; // Capacities are valid
+    public static final int DDSD_HEIGHT          = 0x00000002; // Height is valid
+    public static final int DDSD_WIDTH           = 0x00000004; // Width is valid
+    public static final int DDSD_PITCH           = 0x00000008; // Pitch is valid
+    public static final int DDSD_BACKBUFFERCOUNT = 0x00000020; // Back buffer count is valid
+    public static final int DDSD_ZBUFFERBITDEPTH = 0x00000040; // Z-buffer bit depth is valid (shouldn't be used in DDSURFACEDESC2)
+    public static final int DDSD_ALPHABITDEPTH   = 0x00000080; // Alpha bit depth is valid
+    public static final int DDSD_LPSURFACE       = 0x00000800; // lpSurface is valid
+    public static final int DDSD_PIXELFORMAT     = 0x00001000; // ddpfPixelFormat is valid
+    public static final int DDSD_MIPMAPCOUNT     = 0x00020000; // Mip map count is valid
+    public static final int DDSD_LINEARSIZE      = 0x00080000; // dwLinearSize is valid
+    public static final int DDSD_DEPTH           = 0x00800000; // dwDepth is valid
+
+    public static final int DDPF_ALPHAPIXELS     = 0x00000001; // Alpha channel is present
+    public static final int DDPF_ALPHA           = 0x00000002; // Only contains alpha information
+    public static final int DDPF_FOURCC          = 0x00000004; // FourCC code is valid
+    public static final int DDPF_PALETTEINDEXED4 = 0x00000008; // Surface is 4-bit color indexed
+    public static final int DDPF_PALETTEINDEXEDTO8 = 0x00000010; // Surface is indexed into a palette which stores indices
+    // into the destination surface's 8-bit palette
+    public static final int DDPF_PALETTEINDEXED8 = 0x00000020; // Surface is 8-bit color indexed
+    public static final int DDPF_RGB             = 0x00000040; // RGB data is present
+    public static final int DDPF_COMPRESSED      = 0x00000080; // Surface will accept pixel data in the format specified
+    // and compress it during the write
+    public static final int DDPF_RGBTOYUV        = 0x00000100; // Surface will accept RGB data and translate it during
+    // the write to YUV data. The format of the data to be written
+    // will be contained in the pixel format structure. The DDPF_RGB
+    // flag will be set.
+    public static final int DDPF_YUV             = 0x00000200; // Pixel format is YUV - YUV data in pixel format struct is valid
+    public static final int DDPF_ZBUFFER         = 0x00000400; // Pixel format is a z buffer only surface
+    public static final int DDPF_PALETTEINDEXED1 = 0x00000800; // Surface is 1-bit color indexed
+    public static final int DDPF_PALETTEINDEXED2 = 0x00001000; // Surface is 2-bit color indexed
+    public static final int DDPF_ZPIXELS         = 0x00002000; // Surface contains Z information in the pixels
+
+    // Selected bits in DDS capabilities flags
+    public static final int DDSCAPS_TEXTURE      = 0x00001000; // Can be used as a texture
+    public static final int DDSCAPS_MIPMAP       = 0x00400000; // Is one level of a mip-map
+    public static final int DDSCAPS_COMPLEX      = 0x00000008; // Complex surface structure, such as a cube map
+
+    // Selected bits in DDS extended capabilities flags
+    public static final int DDSCAPS2_CUBEMAP           = 0x00000200;
+    public static final int DDSCAPS2_CUBEMAP_POSITIVEX = 0x00000400;
+    public static final int DDSCAPS2_CUBEMAP_NEGATIVEX = 0x00000800;
+    public static final int DDSCAPS2_CUBEMAP_POSITIVEY = 0x00001000;
+    public static final int DDSCAPS2_CUBEMAP_NEGATIVEY = 0x00002000;
+    public static final int DDSCAPS2_CUBEMAP_POSITIVEZ = 0x00004000;
+    public static final int DDSCAPS2_CUBEMAP_NEGATIVEZ = 0x00008000;
+
+    // Known pixel formats
+    public static final int D3DFMT_UNKNOWN   =  0;
+    public static final int D3DFMT_R8G8B8    =  20;
+    public static final int D3DFMT_A8R8G8B8  =  21;
+    public static final int D3DFMT_X8R8G8B8  =  22;
+    // The following are also valid FourCC codes
+    public static final int D3DFMT_DXT1      =  0x31545844;
+    public static final int D3DFMT_DXT2      =  0x32545844;
+    public static final int D3DFMT_DXT3      =  0x33545844;
+    public static final int D3DFMT_DXT4      =  0x34545844;
+    public static final int D3DFMT_DXT5      =  0x35545844;
+
+    /** Reads a DirectDraw surface from the specified file name,
+        returning the resulting DDSImage.
+
+        @param filename File name
+        @return DDS image object
+        @throws java.io.IOException if an I/O exception occurred
+    */
+    public static DDSImage read(String filename) throws IOException {
+        return read(new File(filename));
+    }
+  
+    /** Reads a DirectDraw surface from the specified file, returning
+        the resulting DDSImage.
+
+        @param file File object
+        @return DDS image object
+        @throws java.io.IOException if an I/O exception occurred
+    */
+    public static DDSImage read(File file) throws IOException {
+        DDSImage image = new DDSImage();
+        image.readFromFile(file);
+        return image;
+    }
+
+    /** Reads a DirectDraw surface from the specified ByteBuffer, returning
+        the resulting DDSImage.
+
+        @param buf Input data
+        @return DDS image object
+        @throws java.io.IOException if an I/O exception occurred
+    */
+    public static DDSImage read(ByteBuffer buf) throws IOException {
+        DDSImage image = new DDSImage();
+        image.readFromBuffer(buf);
+        return image;
+    }
+
+    /** Closes open files and resources associated with the open
+        DDSImage. No other methods may be called on this object once
+        this is called. */
+    public void close() {
+        try {
+            if (chan != null) {
+                chan.close();
+                chan = null;
+            }
+            if (fis != null) {
+                fis.close();
+                fis = null;
+            }
+            buf = null;
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    /** 
+     * Creates a new DDSImage from data supplied by the user. The
+     * resulting DDSImage can be written to disk using the write()
+     * method.
+     *
+     * @param d3dFormat the D3DFMT_ constant describing the data; it is
+     *                  assumed that it is packed tightly
+     * @param width  the width in pixels of the topmost mipmap image
+     * @param height the height in pixels of the topmost mipmap image
+     * @param mipmapData the data for each mipmap level of the resulting
+     *                   DDSImage; either only one mipmap level should
+     *                   be specified, or they all must be
+     * @throws IllegalArgumentException if the data does not match the
+     *   specified arguments
+     * @return DDS image object
+     */
+    public static DDSImage createFromData(int d3dFormat,
+                                          int width,
+                                          int height,
+                                          ByteBuffer[] mipmapData) throws IllegalArgumentException {
+        DDSImage image = new DDSImage();
+        image.initFromData(d3dFormat, width, height, mipmapData);
+        return image;
+    }
+
+    /** Determines from the magic number whether the given InputStream
+        points to a DDS image. The given InputStream must return true
+        from markSupported() and support a minimum of four bytes of
+        read-ahead.
+
+        @param in Stream to check
+        @return true if input stream is DDS image or false otherwise
+        @throws java.io.IOException if an I/O exception occurred
+    */
+    public static boolean isDDSImage(InputStream in) throws IOException {
+        if (!(in instanceof BufferedInputStream)) {
+            in = new BufferedInputStream(in);
+        }
+        if (!in.markSupported()) {
+            throw new IOException("Can not test non-destructively whether given InputStream is a DDS image");
+        }
+        in.mark(4);
+        int magic = 0;
+        for (int i = 0; i < 4; i++) {
+            int tmp = in.read();
+            if (tmp < 0) {
+                in.reset();
+                return false;
+            }
+            magic = ((magic >>> 8) | (tmp << 24));
+        }
+        in.reset();
+        return (magic == MAGIC);
+    }
+
+    /**
+     * Writes this DDSImage to the specified file name.
+     * @param filename File name to write to
+     * @throws java.io.IOException if an I/O exception occurred
+     */
+    public void write(String filename) throws IOException {
+        write(new File(filename));
+    }
+
+    /**
+     * Writes this DDSImage to the specified file name.
+     * @param file File object to write to
+     * @throws java.io.IOException if an I/O exception occurred
+     */
+    public void write(File file) throws IOException {
+        FileOutputStream stream = new FileOutputStream(file);
+        FileChannel chan = stream.getChannel();
+        // Create ByteBuffer for header in case the start of our
+        // ByteBuffer isn't actually memory-mapped
+        ByteBuffer hdr = ByteBuffer.allocate(Header.writtenSize());
+        hdr.order(ByteOrder.LITTLE_ENDIAN);
+        header.write(hdr);
+        hdr.rewind();
+        chan.write(hdr);
+        buf.position(Header.writtenSize());
+        chan.write(buf);
+        chan.force(true);
+        chan.close();
+        stream.close();
+    }
+
+    /** Test for presence/absence of surface description flags (DDSD_*)
+     * @param flag DDSD_* flags set to test
+     * @return true if flag present or false otherwise
+     */
+    public boolean isSurfaceDescFlagSet(int flag) {
+        return ((header.flags & flag) != 0);
+    }
+
+    /** Test for presence/absence of pixel format flags (DDPF_*) */
+    public boolean isPixelFormatFlagSet(int flag) {
+        return ((header.pfFlags & flag) != 0);
+    }
+
+    /** Gets the pixel format of this texture (D3DFMT_*) based on some
+        heuristics. Returns D3DFMT_UNKNOWN if could not recognize the
+        pixel format. */
+    public int getPixelFormat() {
+        if (isCompressed()) {
+            return getCompressionFormat();
+        } else if (isPixelFormatFlagSet(DDPF_RGB)) {
+            if (isPixelFormatFlagSet(DDPF_ALPHAPIXELS)) {
+                if (getDepth() == 32 &&
+                    header.pfRBitMask == 0x00FF0000 &&
+                    header.pfGBitMask == 0x0000FF00 &&
+                    header.pfBBitMask == 0x000000FF &&
+                    header.pfABitMask == 0xFF000000) {
+                    return D3DFMT_A8R8G8B8;
+                }
+            } else {
+                if (getDepth() == 24 &&
+                    header.pfRBitMask == 0x00FF0000 &&
+                    header.pfGBitMask == 0x0000FF00 &&
+                    header.pfBBitMask == 0x000000FF) {
+                    return D3DFMT_R8G8B8;
+                } else if (getDepth() == 32 &&
+                           header.pfRBitMask == 0x00FF0000 &&
+                           header.pfGBitMask == 0x0000FF00 &&
+                           header.pfBBitMask == 0x000000FF) {
+                    return D3DFMT_X8R8G8B8;
+                }
+            }
+        }
+
+        return D3DFMT_UNKNOWN;
+    }
+
+    /**
+     * Indicates whether this texture is cubemap
+     * @return true if cubemap or false otherwise
+     */
+    public boolean isCubemap() {
+        return ((header.ddsCaps1 & DDSCAPS_COMPLEX) != 0) && ((header.ddsCaps2 & DDSCAPS2_CUBEMAP) != 0);
+    }
+
+    /**
+     * Indicates whethe this cubemap side present
+     * @param side Side to test
+     * @return true if side present or false otherwise
+     */
+    public boolean isCubemapSidePresent(int side) {
+        return isCubemap() && (header.ddsCaps2 & side) != 0;
+    }
+
+    /** Indicates whether this texture is compressed. */
+    public boolean isCompressed() {
+        return (isPixelFormatFlagSet(DDPF_FOURCC));
+    }
+
+    /** If this surface is compressed, returns the kind of compression
+        used (DXT1..DXT5). */
+    public int getCompressionFormat() {
+        return header.pfFourCC;
+    }
+
+    /** Width of the texture (or the top-most mipmap if mipmaps are
+        present) */
+    public int getWidth() {
+        return header.width;
+    }
+
+    /** Height of the texture (or the top-most mipmap if mipmaps are
+        present) */
+    public int getHeight() {
+        return header.height;
+    }
+
+    /** Total number of bits per pixel. Only valid if DDPF_RGB is
+        present. For A8R8G8B8, would be 32. */
+    public int getDepth() {
+        return header.pfRGBBitCount;
+    }
+
+    /** Number of mip maps in the texture */
+    public int getNumMipMaps() {
+        if (!isSurfaceDescFlagSet(DDSD_MIPMAPCOUNT)) {
+            return 0;
+        }
+        return header.mipMapCountOrAux;
+    }
+
+    /** Gets the <i>i</i>th mipmap data (0..getNumMipMaps() - 1)
+     * @param map Mipmap index
+     * @return Image object
+     */
+    public ImageInfo getMipMap(int map) {
+        return getMipMap( 0, map );
+    }
+
+    /**
+     * Gets the <i>i</i>th mipmap data (0..getNumMipMaps() - 1)
+     * @param side Cubemap side or 0 for 2D texture
+     * @param map Mipmap index
+     * @return Image object
+     */
+    public ImageInfo getMipMap(int side, int map) {
+        if (!isCubemap() && (side != 0)) {
+            throw new RuntimeException( "Illegal side for 2D texture: " + side );
+        }
+        if (isCubemap() && !isCubemapSidePresent(side)) {
+            throw new RuntimeException( "Illegal side, side not present: " + side );
+        }
+        if (getNumMipMaps() > 0 &&
+            ((map < 0) || (map >= getNumMipMaps()))) {
+            throw new RuntimeException("Illegal mipmap number " + map + " (0.." + (getNumMipMaps() - 1) + ")");
+        }
+
+        // Figure out how far to seek
+        int seek = Header.writtenSize();
+        if (isCubemap()) {
+            seek += sideShiftInBytes(side);
+        }
+        for (int i = 0; i < map; i++) {
+            seek += mipMapSizeInBytes(i);
+        }
+        buf.limit(seek + mipMapSizeInBytes(map));
+        buf.position(seek);
+        ByteBuffer next = buf.slice();
+        buf.position(0);
+        buf.limit(buf.capacity());
+        return new ImageInfo(next, mipMapWidth(map), mipMapHeight(map), isCompressed(), getCompressionFormat());
+    }
+
+    /** Returns an array of ImageInfos corresponding to all mipmap
+        levels of this DDS file.
+        @return Mipmap image objects set
+    */
+    public ImageInfo[] getAllMipMaps() {
+        return getAllMipMaps(0);
+    }
+
+    /**
+     * Returns an array of ImageInfos corresponding to all mipmap
+     * levels of this DDS file.
+     * @param side Cubemap side or 0 for 2D texture
+     * @return Mipmap image objects set
+     */
+    public ImageInfo[] getAllMipMaps( int side ) {
+        int numLevels = getNumMipMaps();
+        if (numLevels == 0) {
+            numLevels = 1;
+        }
+        ImageInfo[] result = new ImageInfo[numLevels];
+        for (int i = 0; i < numLevels; i++) {
+            result[i] = getMipMap(side, i);
+        }
+        return result;
+    }
+
+    /** Converts e.g. DXT1 compression format constant (see {@link
+        #getCompressionFormat}) into "DXT1".
+        @param compressionFormat Compression format constant
+        @return String format code
+    */
+    public static String getCompressionFormatName(int compressionFormat) {
+        StringBuffer buf = new StringBuffer();
+        for (int i = 0; i < 4; i++) {
+            char c = (char) (compressionFormat & 0xFF);
+            buf.append(c);
+            compressionFormat = compressionFormat >> 8;
+        }
+        return buf.toString();
+    }
+
+    /** Allocates a temporary, empty ByteBuffer suitable for use in a
+        call to glCompressedTexImage2D. This is used by the Texture
+        class to expand non-power-of-two DDS compressed textures to
+        power-of-two sizes on hardware not supporting OpenGL 2.0 and the
+        NPOT texture extension. The specified OpenGL internal format
+        must be one of GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
+        GL_COMPRESSED_RGBA_S3TC_DXT1_EXT,
+        GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, or
+        GL_COMPRESSED_RGBA_S3TC_DXT5_EXT.
+    */
+    public static ByteBuffer allocateBlankBuffer(int width,
+                                                 int height,
+                                                 int openGLInternalFormat) {
+        int size = width * height;
+        switch (openGLInternalFormat) {
+        case GL.GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
+        case GL.GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
+            size /= 2;
+            break;
+
+        case GL.GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
+        case GL.GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
+            break;
+
+        default:
+            throw new IllegalArgumentException("Illegal OpenGL texture internal format " +
+                                               openGLInternalFormat);
+        }
+        if (size == 0)
+            size = 1;
+        return BufferUtil.newByteBuffer(size);
+    }
+
+    public void debugPrint() {
+        PrintStream tty = System.err;
+        tty.println("Compressed texture: " + isCompressed());
+        if (isCompressed()) {
+            int fmt = getCompressionFormat();
+            String name = getCompressionFormatName(fmt);
+            tty.println("Compression format: 0x" + Integer.toHexString(fmt) + " (" + name + ")");
+        }
+        tty.println("Width: " + header.width + " Height: " + header.height);
+        tty.println("header.pitchOrLinearSize: " + header.pitchOrLinearSize);
+        tty.println("header.pfRBitMask: 0x" + Integer.toHexString(header.pfRBitMask));
+        tty.println("header.pfGBitMask: 0x" + Integer.toHexString(header.pfGBitMask));
+        tty.println("header.pfBBitMask: 0x" + Integer.toHexString(header.pfBBitMask));
+        tty.println("SurfaceDesc flags:");
+        boolean recognizedAny = false;
+        recognizedAny |= printIfRecognized(tty, header.flags, DDSD_CAPS, "DDSD_CAPS");
+        recognizedAny |= printIfRecognized(tty, header.flags, DDSD_HEIGHT, "DDSD_HEIGHT");
+        recognizedAny |= printIfRecognized(tty, header.flags, DDSD_WIDTH, "DDSD_WIDTH");
+        recognizedAny |= printIfRecognized(tty, header.flags, DDSD_PITCH, "DDSD_PITCH");
+        recognizedAny |= printIfRecognized(tty, header.flags, DDSD_BACKBUFFERCOUNT, "DDSD_BACKBUFFERCOUNT");
+        recognizedAny |= printIfRecognized(tty, header.flags, DDSD_ZBUFFERBITDEPTH, "DDSD_ZBUFFERBITDEPTH");
+        recognizedAny |= printIfRecognized(tty, header.flags, DDSD_ALPHABITDEPTH, "DDSD_ALPHABITDEPTH");
+        recognizedAny |= printIfRecognized(tty, header.flags, DDSD_LPSURFACE, "DDSD_LPSURFACE");
+        recognizedAny |= printIfRecognized(tty, header.flags, DDSD_PIXELFORMAT, "DDSD_PIXELFORMAT");
+        recognizedAny |= printIfRecognized(tty, header.flags, DDSD_MIPMAPCOUNT, "DDSD_MIPMAPCOUNT");
+        recognizedAny |= printIfRecognized(tty, header.flags, DDSD_LINEARSIZE, "DDSD_LINEARSIZE");
+        recognizedAny |= printIfRecognized(tty, header.flags, DDSD_DEPTH, "DDSD_DEPTH");
+        if (!recognizedAny) {
+            tty.println("(none)");
+        }
+        tty.println("Raw SurfaceDesc flags: 0x" + Integer.toHexString(header.flags));
+        tty.println("Pixel format flags:");
+        recognizedAny = false;
+        recognizedAny |= printIfRecognized(tty, header.pfFlags, DDPF_ALPHAPIXELS, "DDPF_ALPHAPIXELS");
+        recognizedAny |= printIfRecognized(tty, header.pfFlags, DDPF_ALPHA, "DDPF_ALPHA");
+        recognizedAny |= printIfRecognized(tty, header.pfFlags, DDPF_FOURCC, "DDPF_FOURCC");
+        recognizedAny |= printIfRecognized(tty, header.pfFlags, DDPF_PALETTEINDEXED4, "DDPF_PALETTEINDEXED4");
+        recognizedAny |= printIfRecognized(tty, header.pfFlags, DDPF_PALETTEINDEXEDTO8, "DDPF_PALETTEINDEXEDTO8");
+        recognizedAny |= printIfRecognized(tty, header.pfFlags, DDPF_PALETTEINDEXED8, "DDPF_PALETTEINDEXED8");
+        recognizedAny |= printIfRecognized(tty, header.pfFlags, DDPF_RGB, "DDPF_RGB");
+        recognizedAny |= printIfRecognized(tty, header.pfFlags, DDPF_COMPRESSED, "DDPF_COMPRESSED");
+        recognizedAny |= printIfRecognized(tty, header.pfFlags, DDPF_RGBTOYUV, "DDPF_RGBTOYUV");
+        recognizedAny |= printIfRecognized(tty, header.pfFlags, DDPF_YUV, "DDPF_YUV");
+        recognizedAny |= printIfRecognized(tty, header.pfFlags, DDPF_ZBUFFER, "DDPF_ZBUFFER");
+        recognizedAny |= printIfRecognized(tty, header.pfFlags, DDPF_PALETTEINDEXED1, "DDPF_PALETTEINDEXED1");
+        recognizedAny |= printIfRecognized(tty, header.pfFlags, DDPF_PALETTEINDEXED2, "DDPF_PALETTEINDEXED2");
+        recognizedAny |= printIfRecognized(tty, header.pfFlags, DDPF_ZPIXELS, "DDPF_ZPIXELS");
+        if (!recognizedAny) {
+            tty.println("(none)");
+        }
+        tty.println("Raw pixel format flags: 0x" + Integer.toHexString(header.pfFlags));
+        tty.println("Depth: " + getDepth());
+        tty.println("Number of mip maps: " + getNumMipMaps());
+        int fmt = getPixelFormat();
+        tty.print("Pixel format: ");
+        switch (fmt) {
+        case D3DFMT_R8G8B8:   tty.println("D3DFMT_R8G8B8"); break;
+        case D3DFMT_A8R8G8B8: tty.println("D3DFMT_A8R8G8B8"); break;
+        case D3DFMT_X8R8G8B8: tty.println("D3DFMT_X8R8G8B8"); break;
+        case D3DFMT_DXT1:     tty.println("D3DFMT_DXT1"); break;
+        case D3DFMT_DXT2:     tty.println("D3DFMT_DXT2"); break;
+        case D3DFMT_DXT3:     tty.println("D3DFMT_DXT3"); break;
+        case D3DFMT_DXT4:     tty.println("D3DFMT_DXT4"); break;
+        case D3DFMT_DXT5:     tty.println("D3DFMT_DXT5"); break;
+        case D3DFMT_UNKNOWN:  tty.println("D3DFMT_UNKNOWN"); break;
+        default:              tty.println("(unknown pixel format " + fmt + ")"); break;
+        }
+    }
+
+    //----------------------------------------------------------------------
+    // Internals only below this point
+    //
+
+    private static final int MAGIC = 0x20534444;
+
+    static class Header {
+        int size;                 // size of the DDSURFACEDESC structure
+        int flags;                // determines what fields are valid
+        int height;               // height of surface to be created
+        int width;                // width of input surface
+        int pitchOrLinearSize;
+        int backBufferCountOrDepth;
+        int mipMapCountOrAux;     // number of mip-map levels requested (in this context)
+        int alphaBitDepth;        // depth of alpha buffer requested
+        int reserved1;            // reserved
+        int surface;              // pointer to the associated surface memory
+        // NOTE: following two entries are from DDCOLORKEY data structure
+        // Are overlaid with color for empty cubemap faces (unused in this reader)
+        int colorSpaceLowValue;
+        int colorSpaceHighValue;
+        int destBltColorSpaceLowValue;
+        int destBltColorSpaceHighValue;
+        int srcOverlayColorSpaceLowValue;
+        int srcOverlayColorSpaceHighValue;
+        int srcBltColorSpaceLowValue;
+        int srcBltColorSpaceHighValue;
+        // NOTE: following entries are from DDPIXELFORMAT data structure
+        // Are overlaid with flexible vertex format description of vertex
+        // buffers (unused in this reader)
+        int pfSize;                 // size of DDPIXELFORMAT structure
+        int pfFlags;                // pixel format flags
+        int pfFourCC;               // (FOURCC code)
+        // Following five entries have multiple interpretations, not just
+        // RGBA (but that's all we support right now)
+        int pfRGBBitCount;          // how many bits per pixel
+        int pfRBitMask;             // mask for red bits
+        int pfGBitMask;             // mask for green bits
+        int pfBBitMask;             // mask for blue bits
+        int pfABitMask;             // mask for alpha channel
+        int ddsCaps1;               // Texture and mip-map flags
+        int ddsCaps2;               // Advanced capabilities including cubemap support
+        int ddsCapsReserved1;
+        int ddsCapsReserved2;
+        int textureStage;           // stage in multitexture cascade
+
+        void read(ByteBuffer buf) throws IOException {
+            int magic                     = buf.getInt();
+            if (magic != MAGIC) {
+                throw new IOException("Incorrect magic number 0x" +
+                                      Integer.toHexString(magic) +
+                                      " (expected " + MAGIC + ")");
+            }
+
+            size                          = buf.getInt();
+            flags                         = buf.getInt();
+            height                        = buf.getInt();
+            width                         = buf.getInt();
+            pitchOrLinearSize             = buf.getInt();
+            backBufferCountOrDepth        = buf.getInt();
+            mipMapCountOrAux              = buf.getInt();
+            alphaBitDepth                 = buf.getInt();
+            reserved1                     = buf.getInt();
+            surface                       = buf.getInt();
+            colorSpaceLowValue            = buf.getInt();
+            colorSpaceHighValue           = buf.getInt();
+            destBltColorSpaceLowValue     = buf.getInt();
+            destBltColorSpaceHighValue    = buf.getInt();
+            srcOverlayColorSpaceLowValue  = buf.getInt();
+            srcOverlayColorSpaceHighValue = buf.getInt();
+            srcBltColorSpaceLowValue      = buf.getInt();
+            srcBltColorSpaceHighValue     = buf.getInt();
+            pfSize                        = buf.getInt();
+            pfFlags                       = buf.getInt();
+            pfFourCC                      = buf.getInt();
+            pfRGBBitCount                 = buf.getInt();
+            pfRBitMask                    = buf.getInt();
+            pfGBitMask                    = buf.getInt();
+            pfBBitMask                    = buf.getInt();
+            pfABitMask                    = buf.getInt();
+            ddsCaps1                      = buf.getInt();
+            ddsCaps2                      = buf.getInt();
+            ddsCapsReserved1              = buf.getInt();
+            ddsCapsReserved2              = buf.getInt();
+            textureStage                  = buf.getInt();
+        }
+
+        // buf must be in little-endian byte order
+        void write(ByteBuffer buf) {
+            buf.putInt(MAGIC);
+            buf.putInt(size);
+            buf.putInt(flags);
+            buf.putInt(height);
+            buf.putInt(width);
+            buf.putInt(pitchOrLinearSize);
+            buf.putInt(backBufferCountOrDepth);
+            buf.putInt(mipMapCountOrAux);
+            buf.putInt(alphaBitDepth);
+            buf.putInt(reserved1);
+            buf.putInt(surface);
+            buf.putInt(colorSpaceLowValue);
+            buf.putInt(colorSpaceHighValue);
+            buf.putInt(destBltColorSpaceLowValue);
+            buf.putInt(destBltColorSpaceHighValue);
+            buf.putInt(srcOverlayColorSpaceLowValue);
+            buf.putInt(srcOverlayColorSpaceHighValue);
+            buf.putInt(srcBltColorSpaceLowValue);
+            buf.putInt(srcBltColorSpaceHighValue);
+            buf.putInt(pfSize);
+            buf.putInt(pfFlags);
+            buf.putInt(pfFourCC);
+            buf.putInt(pfRGBBitCount);
+            buf.putInt(pfRBitMask);
+            buf.putInt(pfGBitMask);
+            buf.putInt(pfBBitMask);
+            buf.putInt(pfABitMask);
+            buf.putInt(ddsCaps1);
+            buf.putInt(ddsCaps2);
+            buf.putInt(ddsCapsReserved1);
+            buf.putInt(ddsCapsReserved2);
+            buf.putInt(textureStage);
+        }
+
+        private static int size() {
+            return 124;
+        }
+
+        private static int pfSize() {
+            return 32;
+        }
+
+        private static int writtenSize() {
+            return 128;
+        }
+    }
+
+    private DDSImage() {
+    }
+
+    private void readFromFile(File file) throws IOException {
+        fis = new FileInputStream(file);
+        chan = fis.getChannel();
+        ByteBuffer buf = chan.map(FileChannel.MapMode.READ_ONLY,
+                                  0, (int) file.length());
+        readFromBuffer(buf);
+    }
+
+    private void readFromBuffer(ByteBuffer buf) throws IOException {
+        this.buf = buf;
+        buf.order(ByteOrder.LITTLE_ENDIAN);
+        header = new Header();
+        header.read(buf);
+        fixupHeader();
+    }
+
+    private void initFromData(int d3dFormat,
+                              int width,
+                              int height,
+                              ByteBuffer[] mipmapData) throws IllegalArgumentException {
+        // Check size of mipmap data compared against format, width and
+        // height
+        int topmostMipmapSize = width * height;
+        int pitchOrLinearSize = width;
+        boolean isCompressed = false;
+        switch (d3dFormat) {
+        case D3DFMT_R8G8B8:   topmostMipmapSize *= 3; pitchOrLinearSize *= 3; break;
+        case D3DFMT_A8R8G8B8: topmostMipmapSize *= 4; pitchOrLinearSize *= 4; break;
+        case D3DFMT_X8R8G8B8: topmostMipmapSize *= 4; pitchOrLinearSize *= 4; break;
+        case D3DFMT_DXT1:
+        case D3DFMT_DXT2:
+        case D3DFMT_DXT3:
+        case D3DFMT_DXT4:
+        case D3DFMT_DXT5:
+            topmostMipmapSize = computeCompressedBlockSize(width, height, 1, d3dFormat);
+            pitchOrLinearSize = topmostMipmapSize;
+            isCompressed = true;
+            break;
+        default:
+            throw new IllegalArgumentException("d3dFormat must be one of the known formats");
+        }
+    
+        // Now check the mipmaps against this size
+        int curSize = topmostMipmapSize;
+        int totalSize = 0;
+        for (int i = 0; i < mipmapData.length; i++) {
+            if (mipmapData[i].remaining() != curSize) {
+                throw new IllegalArgumentException("Mipmap level " + i +
+                                                   " didn't match expected data size (expected " + curSize + ", got " +
+                                                   mipmapData[i].remaining() + ")");
+            }
+            curSize /= 4;
+            totalSize += mipmapData[i].remaining();
+        }
+
+        // OK, create one large ByteBuffer to hold all of the mipmap data
+        totalSize += Header.writtenSize();
+        ByteBuffer buf = ByteBuffer.allocate(totalSize);
+        buf.position(Header.writtenSize());
+        for (int i = 0; i < mipmapData.length; i++) {
+            buf.put(mipmapData[i]);
+        }
+        this.buf = buf;
+    
+        // Allocate and initialize a Header
+        header = new Header();
+        header.size = Header.size();
+        header.flags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
+        if (mipmapData.length > 1) {
+            header.flags |= DDSD_MIPMAPCOUNT;
+            header.mipMapCountOrAux = mipmapData.length;
+        }
+        header.width = width;
+        header.height = height;
+        if (isCompressed) {
+            header.flags |= DDSD_LINEARSIZE;
+            header.pfFlags |= DDPF_FOURCC;
+            header.pfFourCC = d3dFormat;
+        } else {
+            header.flags |= DDSD_PITCH;
+            // Figure out the various settings from the pixel format
+            header.pfFlags |= DDPF_RGB;
+            switch (d3dFormat) {
+            case D3DFMT_R8G8B8:   header.pfRGBBitCount = 24; break;
+            case D3DFMT_A8R8G8B8: header.pfRGBBitCount = 32; header.pfFlags |= DDPF_ALPHAPIXELS; break;
+            case D3DFMT_X8R8G8B8: header.pfRGBBitCount = 32; break;
+            }
+            header.pfRBitMask = 0x00FF0000;
+            header.pfGBitMask = 0x0000FF00;
+            header.pfBBitMask = 0x000000FF;
+            if (d3dFormat == D3DFMT_A8R8G8B8) {
+                header.pfABitMask = 0xFF000000;
+            }
+        }
+        header.pitchOrLinearSize = pitchOrLinearSize;
+        header.pfSize = Header.pfSize();
+        // Not sure whether we can get away with leaving the rest of the
+        // header blank
+    }
+
+    // Microsoft doesn't follow their own specifications and the
+    // simplest conversion using the DxTex tool to e.g. a DXT3 texture
+    // results in an illegal .dds file without either DDSD_PITCH or
+    // DDSD_LINEARSIZE set in the header's flags. This code, adapted
+    // from the DevIL library, fixes up the header in these situations.
+    private void fixupHeader() {
+        if (isCompressed() && !isSurfaceDescFlagSet(DDSD_LINEARSIZE)) {
+            // Figure out how big the linear size should be
+            int depth = header.backBufferCountOrDepth;
+            if (depth == 0) {
+                depth = 1;
+            }
+
+            header.pitchOrLinearSize = computeCompressedBlockSize(getWidth(), getHeight(), depth, getCompressionFormat());
+            header.flags |= DDSD_LINEARSIZE;
+        }
+    }
+
+    private static int computeCompressedBlockSize(int width,
+                                                  int height,
+                                                  int depth,
+                                                  int compressionFormat) {
+        int blockSize = ((width + 3)/4) * ((height + 3)/4) * ((depth + 3)/4);
+        switch (compressionFormat) {
+        case D3DFMT_DXT1:  blockSize *=  8; break;
+        default:           blockSize *= 16; break;
+        }
+        return blockSize;
+    }
+
+    private int mipMapWidth(int map) {
+        int width = getWidth();
+        for (int i = 0; i < map; i++) {
+            width >>= 1;
+        }
+        return Math.max(width, 1);
+    }
+
+    private int mipMapHeight(int map) {
+        int height = getHeight();
+        for (int i = 0; i < map; i++) {
+            height >>= 1;
+        }
+        return Math.max(height, 1);
+    }
+
+    private int mipMapSizeInBytes(int map) {
+        int width  = mipMapWidth(map);
+        int height = mipMapHeight(map);
+        if (isCompressed()) {
+            int blockSize = (getCompressionFormat() == D3DFMT_DXT1 ? 8 : 16);
+            return ((width+3)/4)*((height+3)/4)*blockSize;
+        } else {
+            return width * height * (getDepth() / 8);
+        }
+    }
+
+    private int sideSizeInBytes() {
+        int numLevels = getNumMipMaps();
+        if (numLevels == 0) {
+            numLevels = 1;
+        }
+
+        int size = 0;
+        for (int i = 0; i < numLevels; i++) {
+            size += mipMapSizeInBytes(i);
+        }
+
+        return size;
+    }
+
+    private int sideShiftInBytes(int side) {
+        int[] sides = {
+            DDSCAPS2_CUBEMAP_POSITIVEX,
+            DDSCAPS2_CUBEMAP_NEGATIVEX,
+            DDSCAPS2_CUBEMAP_POSITIVEY,
+            DDSCAPS2_CUBEMAP_NEGATIVEY,
+            DDSCAPS2_CUBEMAP_POSITIVEZ,
+            DDSCAPS2_CUBEMAP_NEGATIVEZ
+        };
+
+        int shift = 0;
+        int sideSize = sideSizeInBytes();
+        for (int i = 0; i < sides.length; i++) {
+            int temp = sides[i];
+            if ((temp & side) != 0) {
+                return shift;
+            }
+
+            shift += sideSize;
+        }
+
+        throw new RuntimeException("Illegal side: " + side);
+    }
+
+    private boolean printIfRecognized(PrintStream tty, int flags, int flag, String what) {
+        if ((flags & flag) != 0) {
+            tty.println(what);
+            return true;
+        }
+        return false;
+    }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/texture/spi/LEDataInputStream.java b/src/jogl/classes/com/jogamp/opengl/util/texture/spi/LEDataInputStream.java
new file mode 100755
index 000000000..d5f49599c
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/texture/spi/LEDataInputStream.java
@@ -0,0 +1,223 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package	com.jogamp.opengl.util.texture.spi;
+
+import java.io.DataInput;
+import java.io.DataInputStream;
+import java.io.FilterInputStream;
+import java.io.InputStream;
+import java.io.FileInputStream;
+import java.io.EOFException;
+import java.io.IOException;
+
+/**
+ * Little Endian Data Input Stream.
+ *
+ * This class implements an input stream filter to allow reading
+ * of java native datatypes from an input stream which has those
+ * native datatypes stored in a little endian byte order.<p>
+ *
+ * This is the sister class of the DataInputStream which allows
+ * for reading of java native datatypes from an input stream with
+ * the datatypes stored in big endian byte order.<p>
+ *
+ * This class implements the minimum required and calls DataInputStream
+ * for some of the required methods for DataInput.<p>
+ *
+ * Not all methods are implemented due to lack of immediatte requirement
+ * for that functionality. It is not clear if it is ever going to be
+ * functionally required to be able to read UTF data in a LittleEndianManner<p>
+ *
+ * @author	Robin Luiten
+ * @version	1.1	15/Dec/1997
+ */
+public class LEDataInputStream extends FilterInputStream implements DataInput
+{
+    /**
+     * To reuse	some of	the	non	endian dependent methods from
+     * DataInputStreams	methods.
+     */
+    DataInputStream	dataIn;
+
+    public LEDataInputStream(InputStream in)
+    {
+        super(in);
+        dataIn = new DataInputStream(in);
+    }
+
+    public void close() throws IOException
+    {
+        dataIn.close();		// better close as we create it.
+        // this will close underlying as well.
+    }
+
+    public synchronized	final int read(byte	b[]) throws	IOException
+    {
+        return dataIn.read(b, 0, b.length);
+    }
+
+    public synchronized	final int read(byte	b[], int off, int len) throws IOException
+    {
+        int	rl = dataIn.read(b,	off, len);
+        return rl;
+    }
+
+    public final void readFully(byte b[]) throws IOException
+    {
+        dataIn.readFully(b,	0, b.length);
+    }
+
+    public final void readFully(byte b[], int off, int len)	throws IOException
+    {
+        dataIn.readFully(b,	off, len);
+    }
+
+    public final int skipBytes(int n) throws IOException
+    {
+        return dataIn.skipBytes(n);
+    }
+
+    public final boolean readBoolean() throws IOException
+    {
+        int	ch = dataIn.read();
+        if (ch < 0)
+            throw new EOFException();
+        return (ch != 0);
+    }
+
+    public final byte readByte() throws	IOException
+    {
+        int	ch = dataIn.read();
+        if (ch < 0)
+            throw new EOFException();
+        return (byte)(ch);
+    }
+
+    public final int readUnsignedByte()	throws IOException
+    {
+        int	ch = dataIn.read();
+        if (ch < 0)
+            throw new EOFException();
+        return ch;
+    }
+
+    public final short readShort() throws IOException
+    {
+        int	ch1	= dataIn.read();
+        int	ch2	= dataIn.read();
+        if ((ch1 | ch2)	< 0)
+            throw new EOFException();
+        return (short)((ch1	<< 0) +	(ch2 <<	8));
+    }
+
+    public final int readUnsignedShort() throws	IOException
+    { 
+        int	ch1	= dataIn.read();
+        int	ch2	= dataIn.read();
+        if ((ch1 | ch2)	< 0)
+            throw new EOFException();
+        return (ch1	<< 0) +	(ch2 <<	8);
+    }
+
+    public final char readChar() throws	IOException
+    {
+        int	ch1	= dataIn.read();
+        int	ch2	= dataIn.read();
+        if ((ch1 | ch2)	< 0)
+            throw new EOFException();
+        return (char)((ch1 << 0) + (ch2	<< 8));
+    }
+
+    public final int readInt() throws IOException
+    {
+        int	ch1	= dataIn.read();
+        int	ch2	= dataIn.read();
+        int	ch3	= dataIn.read();
+        int	ch4	= dataIn.read();
+        if ((ch1 | ch2 | ch3 | ch4)	< 0)
+            throw new EOFException();
+        return ((ch1 <<	0) + (ch2 << 8)	+ (ch3 << 16) +	(ch4 <<	24));
+    }
+
+    public final long readLong() throws	IOException
+    {
+        int	i1 = readInt();
+        int	i2 = readInt();
+        return ((long)(i1) & 0xFFFFFFFFL) +	(i2	<< 32);
+    }
+
+    public final float readFloat() throws IOException
+    {
+        return Float.intBitsToFloat(readInt());
+    }
+
+    public final double	readDouble() throws	IOException
+    {
+        return Double.longBitsToDouble(readLong());
+    }
+
+    /**
+     * dont call this it is not implemented.
+     * @return empty new string 
+     **/
+    public final String	readLine() throws IOException
+    {
+        return new String();
+    }
+
+    /**
+     * dont call this it is not implemented
+     * @return empty new string 
+     **/
+    public final String	readUTF() throws IOException
+    {
+        return new String();
+    }
+
+    /**
+     * dont call this it is not implemented
+     * @return empty new string 
+     **/
+    public final static	String readUTF(DataInput in) throws	IOException
+    {
+        return new String();
+    }
+}
+
diff --git a/src/jogl/classes/com/jogamp/opengl/util/texture/spi/LEDataOutputStream.java b/src/jogl/classes/com/jogamp/opengl/util/texture/spi/LEDataOutputStream.java
new file mode 100755
index 000000000..e1e1ca924
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/texture/spi/LEDataOutputStream.java
@@ -0,0 +1,165 @@
+/*
+ * Copyright (c) 2003 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util.texture.spi;
+
+import java.io.DataOutput;
+import java.io.DataOutputStream;
+import java.io.FilterOutputStream;
+import java.io.OutputStream;
+import java.io.IOException;
+
+/**
+ * Little Endian Data Output Stream.
+ *
+ * This class implements an output stream filter to allow writing
+ * of java native datatypes to an output stream which has those
+ * native datatypes stored in a little endian byte order.<p>
+ *
+ * This is the sister class of the DataOutputStream which allows
+ * for writing of java native datatypes to an output stream with
+ * the datatypes stored in big endian byte order.<p>
+ *
+ * This class implements the minimum required and calls DataOutputStream
+ * for some of the required methods for DataOutput.<p>
+ *
+ * Not all methods are implemented due to lack of immediate requirement
+ * for that functionality. It is not clear if it is ever going to be
+ * functionally required to be able to read UTF data in a LittleEndianManner<p>
+ *
+ */
+public class LEDataOutputStream extends FilterOutputStream implements DataOutput
+{
+    /**
+     * To reuse some of the non endian dependent methods from
+     * DataOutputStream's methods.
+     */
+    DataOutputStream dataOut;
+
+    public LEDataOutputStream(OutputStream out)
+    {
+        super(out);
+        dataOut = new DataOutputStream(out);
+    }
+
+    public void close() throws IOException
+    {
+        dataOut.close(); // better close as we create it.
+        // this will close underlying as well.
+    }
+
+    public synchronized final void write(byte b[]) throws IOException
+    {
+        dataOut.write(b, 0, b.length);
+    }
+
+    public synchronized final void write(byte b[], int off, int len) throws IOException
+    {
+        dataOut.write(b, off, len);
+    }
+
+    public final void write(int b) throws IOException
+    {
+        dataOut.write(b);
+    }
+
+    public final void writeBoolean(boolean v) throws IOException
+    {
+        dataOut.writeBoolean(v);
+    }
+
+    public final void writeByte(int v) throws IOException
+    {
+        dataOut.writeByte(v);
+    }
+
+    /** Don't call this -- not implemented */
+    public final void writeBytes(String s) throws IOException
+    {
+        throw new UnsupportedOperationException();
+    }
+
+    public final void writeChar(int v) throws IOException
+    {
+        dataOut.writeChar(((v >> 8) & 0xff) |
+                          ((v & 0xff) << 8));
+    }
+
+    /** Don't call this -- not implemented */
+    public final void writeChars(String s) throws IOException
+    {
+        throw new UnsupportedOperationException();
+    }
+
+    public final void writeDouble(double v) throws IOException
+    {
+        writeLong(Double.doubleToRawLongBits(v));
+    }
+
+    public final void writeFloat(float v) throws IOException
+    {
+        writeInt(Float.floatToRawIntBits(v));
+    }
+
+    public final void writeInt(int v) throws IOException
+    {
+        dataOut.writeInt((v >>> 24) |
+                         ((v >>> 8) & 0xff00) |
+                         ((v << 8)  & 0x00ff00) |
+                         (v << 24));
+    }
+
+    public final void writeLong(long v) throws IOException
+    {
+        writeInt((int) v);
+        writeInt((int) (v >>> 32));
+    }
+
+    public final void writeShort(int v) throws IOException
+    {
+        dataOut.writeShort(((v >> 8) & 0xff) |
+                           ((v & 0xff) << 8));
+    }
+
+    /** Don't call this -- not implemented */
+    public final void writeUTF(String s) throws IOException
+    {
+        throw new UnsupportedOperationException();
+    }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/texture/spi/NetPbmTextureWriter.java b/src/jogl/classes/com/jogamp/opengl/util/texture/spi/NetPbmTextureWriter.java
new file mode 100644
index 000000000..499dce7fb
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/texture/spi/NetPbmTextureWriter.java
@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) 2005 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util.texture.spi;
+
+import java.io.*;
+import java.net.*;
+import java.nio.*;
+
+import javax.media.opengl.*;
+import com.jogamp.opengl.util.*;
+import com.jogamp.opengl.util.texture.*;
+import com.jogamp.opengl.util.texture.spi.*;
+
+public class NetPbmTextureWriter implements TextureWriter {
+    int magic;
+
+    public NetPbmTextureWriter() {
+        this(0); // auto
+    }
+
+    /**
+     * supported magic values are:<br>
+     * <pre>
+     *   magic 0 - detect by file suffix (TextureIO compliant)
+     *   magic 6 - PPM binary RGB
+     *   magic 7 - PAM binary RGB or RGBA
+     * </pre>
+     */
+    public NetPbmTextureWriter(int magic) {
+        switch(magic) {
+            case 0:
+            case 6:
+            case 7:
+                break;
+            default:
+                throw new GLException("Unsupported magic: "+magic+", should be 0 (auto), 6 (PPM) or 7 (PAM)");
+        }
+        this.magic = magic;
+    }
+
+    public int getMagic() { return magic; }
+
+    public static final String PPM     = "ppm";
+    public static final String PAM     = "pam";
+
+    public String getSuffix() { return (magic==6)?PPM:PAM; }
+
+    public boolean write(File file,
+                         TextureData data) throws IOException {
+
+        // file suffix selection 
+        if (0==magic) {
+            if (PPM.equals(FileUtil.getFileSuffix(file))) {
+                magic = 6;
+            } else if (PAM.equals(FileUtil.getFileSuffix(file))) {
+                magic = 7;
+            } else {
+                return false;
+            }
+        }
+
+        int pixelFormat = data.getPixelFormat();
+        int pixelType   = data.getPixelType();
+        if ((pixelFormat == GL.GL_RGB ||
+             pixelFormat == GL.GL_RGBA) &&
+            (pixelType == GL.GL_BYTE ||
+             pixelType == GL.GL_UNSIGNED_BYTE)) {
+    
+            int comps = ( pixelFormat == GL.GL_RGBA ) ? 4 : 3 ;
+
+            if(magic==6 && comps==4) {
+                throw new IOException("NetPbmTextureWriter magic 6 (PPM) doesn't RGBA pixel format, use magic 7 (PAM)");
+            }
+
+            FileOutputStream fos = new FileOutputStream(file);
+
+            StringBuffer header = new StringBuffer();
+            header.append("P");
+            header.append(magic);
+            header.append("\n");
+            if(7==magic) {
+                header.append("WIDTH ");
+            }
+            header.append(data.getWidth());
+            if(7==magic) {
+                header.append("\nHEIGHT ");
+            } else {
+                header.append(" ");
+            }
+            header.append(data.getHeight());
+            if(7==magic) {
+                header.append("\nDEPTH ");
+                header.append(comps);
+                header.append("\nMAXVAL 255\nTUPLTYPE ");
+                if(pixelFormat == GL.GL_RGBA) {
+                    header.append("RGB_ALPHA");
+                } else {
+                    header.append("RGB");
+                }
+                header.append("\nENDHDR\n");
+            } else {
+                header.append("\n255\n");
+            }
+
+            fos.write(header.toString().getBytes());
+                
+            ByteBuffer buf = (ByteBuffer) data.getBuffer();
+            if (buf == null) {
+                buf = (ByteBuffer) data.getMipmapData()[0];
+            }
+            buf.rewind();
+
+            byte[] bufArray = null;
+
+            try {
+                bufArray = buf.array();
+            } catch (Throwable t) {}
+            if(null==bufArray) {
+                bufArray = new byte[data.getWidth()*data.getHeight()*comps];
+                buf.get(bufArray);
+                buf.rewind();
+            }
+
+            fos.write(bufArray);
+            fos.close();
+
+            return true;
+        }
+      
+        throw new IOException("NetPbmTextureWriter writer doesn't support this pixel format / type (only GL_RGB/A + bytes)");
+    }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/texture/spi/SGIImage.java b/src/jogl/classes/com/jogamp/opengl/util/texture/spi/SGIImage.java
new file mode 100755
index 000000000..bb5040a31
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/texture/spi/SGIImage.java
@@ -0,0 +1,670 @@
+/*
+ * Portions Copyright (c) 2005 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util.texture.spi;
+
+import java.io.*;
+import javax.media.opengl.*;
+import com.jogamp.opengl.util.*;
+
+/** <p> Reads and writes SGI RGB/RGBA images. </p>
+
+    <p> Written from <a href =
+    "http://astronomy.swin.edu.au/~pbourke/dataformats/sgirgb/">Paul
+    Bourke's adaptation</a> of the <a href =
+    "http://astronomy.swin.edu.au/~pbourke/dataformats/sgirgb/sgiversion.html">SGI
+    specification</a>. </p>
+*/
+
+public class SGIImage {
+    private Header header;
+    private int    format;
+    private byte[] data;
+    // Used for decoding RLE-compressed images
+    private int[]  rowStart;
+    private int[]  rowSize;
+    private int    rleEnd;
+    private byte[] tmpData;
+    private byte[] tmpRead;
+
+    private static final int MAGIC = 474;
+
+    static class Header {
+        short magic;        // IRIS image file magic number
+        // This should be decimal 474
+        byte  storage;      // Storage format
+        // 0 for uncompressed
+        // 1 for RLE compression
+        byte  bpc;          // Number of bytes per pixel channel 
+        // Legally 1 or 2
+        short dimension;    // Number of dimensions
+        // Legally 1, 2, or 3
+        // 1 means a single row, XSIZE long
+        // 2 means a single 2D image
+        // 3 means multiple 2D images
+        short xsize;        // X size in pixels 
+        short ysize;        // Y size in pixels 
+        short zsize;        // Number of channels
+        // 1 indicates greyscale
+        // 3 indicates RGB
+        // 4 indicates RGB and Alpha
+        int pixmin;         // Minimum pixel value
+        // This is the lowest pixel value in the image
+        int pixmax;         // Maximum pixel value
+        // This is the highest pixel value in the image
+        int dummy;          // Ignored
+        // Normally set to 0
+        String imagename;   // Image name; 80 bytes long
+        // Must be null terminated, therefore at most 79 bytes
+        int colormap;       // Colormap ID
+        // 0 - normal mode
+        // 1 - dithered, 3 mits for red and green, 2 for blue, obsolete
+        // 2 - index colour, obsolete
+        // 3 - not an image but a colourmap
+        // 404 bytes  char    DUMMY      Ignored
+        // Should be set to 0, makes the header 512 bytes.
+
+        Header() {
+            magic = MAGIC;
+        }
+
+        Header(DataInputStream in) throws IOException {
+            magic      = in.readShort();
+            storage    = in.readByte();
+            bpc        = in.readByte();
+            dimension  = in.readShort();
+            xsize      = in.readShort();
+            ysize      = in.readShort();
+            zsize      = in.readShort();
+            pixmin     = in.readInt();
+            pixmax     = in.readInt();
+            dummy      = in.readInt();
+            byte[] tmpname = new byte[80];
+            in.read(tmpname);
+            int numChars = 0;
+            while (tmpname[numChars++] != 0);
+            imagename  = new String(tmpname, 0, numChars);
+            colormap   = in.readInt();
+            byte[] tmp = new byte[404];
+            in.read(tmp);
+        }
+
+        public String toString() {
+            return ("magic: " + magic +
+                    " storage: " + (int) storage +
+                    " bpc: " + (int) bpc +
+                    " dimension: " + dimension +
+                    " xsize: " + xsize +
+                    " ysize: " + ysize +
+                    " zsize: " + zsize +
+                    " pixmin: " + pixmin +
+                    " pixmax: " + pixmax +
+                    " imagename: " + imagename +
+                    " colormap: " + colormap);
+        }
+    }
+
+    private SGIImage(Header header) {
+        this.header = header;
+    }
+
+    /** Reads an SGI image from the specified file. */
+    public static SGIImage read(String filename) throws IOException {
+        return read(new FileInputStream(filename));
+    }
+
+    /** Reads an SGI image from the specified InputStream. */
+    public static SGIImage read(InputStream in) throws IOException {
+        DataInputStream dIn = new DataInputStream(new BufferedInputStream(in));
+
+        Header header = new Header(dIn);
+        SGIImage res = new SGIImage(header);
+        res.decodeImage(dIn);
+        return res;
+    }
+
+    /** Writes this SGIImage to the specified file name. If
+        flipVertically is set, outputs the scanlines from top to bottom
+        rather than the default bottom to top order. */
+    public void write(String filename, boolean flipVertically) throws IOException {
+        write(new File(filename), flipVertically);
+    }
+
+    /** Writes this SGIImage to the specified file. If flipVertically is
+        set, outputs the scanlines from top to bottom rather than the
+        default bottom to top order. */
+    public void write(File file, boolean flipVertically) throws IOException {
+        writeImage(file, data, header.xsize, header.ysize, header.zsize, flipVertically);
+    }
+
+    /** Creates an SGIImage from the specified data in either RGB or
+        RGBA format. */
+    public static SGIImage createFromData(int width,
+                                          int height,
+                                          boolean hasAlpha,
+                                          byte[] data) {
+        Header header = new Header();
+        header.xsize = (short) width;
+        header.ysize = (short) height;
+        header.zsize = (short) (hasAlpha ? 4 : 3);
+        SGIImage image = new SGIImage(header);
+        image.data = data;
+        return image;
+    }
+
+    /** Determines from the magic number whether the given InputStream
+        points to an SGI RGB image. The given InputStream must return
+        true from markSupported() and support a minimum of two bytes
+        of read-ahead. */
+    public static boolean isSGIImage(InputStream in) throws IOException {
+        if (!(in instanceof BufferedInputStream)) {
+            in = new BufferedInputStream(in);
+        }
+        if (!in.markSupported()) {
+            throw new IOException("Can not test non-destructively whether given InputStream is an SGI RGB image");
+        }
+        DataInputStream dIn = new DataInputStream(in);
+        dIn.mark(4);
+        short magic = dIn.readShort();
+        dIn.reset();
+        return (magic == MAGIC);
+    }
+
+    /** Returns the width of the image. */
+    public int getWidth() {
+        return header.xsize;
+    }
+
+    /** Returns the height of the image. */
+    public int getHeight() {
+        return header.ysize;
+    }
+
+    /** Returns the OpenGL format for this texture; e.g. GL.GL_RGB or GL.GL_RGBA. */
+    public int getFormat() {
+        return format;
+    }
+
+    /** Returns the raw data for this texture in the correct
+        (bottom-to-top) order for calls to glTexImage2D. */
+    public byte[] getData()  { return data; }
+
+    public String toString() {
+        return header.toString();
+    }
+
+    //----------------------------------------------------------------------
+    // Internals only below this point
+    //
+  
+    private void decodeImage(DataInputStream in) throws IOException {
+        if (header.storage == 1) {
+            // Read RLE compression data; row starts and sizes
+            int x = header.ysize * header.zsize;
+            rowStart = new int[x];
+            rowSize  = new int[x];
+            rleEnd   = 4 * 2 * x + 512;
+            for (int i = 0; i < x; i++) {
+                rowStart[i] = in.readInt();
+            }
+            for (int i = 0; i < x; i++) {
+                rowSize[i] = in.readInt();
+            }
+            tmpRead = new byte[header.xsize * 256];
+        }
+        tmpData = readAll(in);
+
+        int xsize = header.xsize;
+        int ysize = header.ysize;
+        int zsize = header.zsize;
+        int lptr  = 0;
+
+        data = new byte[xsize * ysize * 4];
+        byte[] rbuf = new byte[xsize];
+        byte[] gbuf = new byte[xsize];
+        byte[] bbuf = new byte[xsize];
+        byte[] abuf = new byte[xsize];
+        for (int y = 0; y < ysize; y++) {
+            if (zsize >= 4) {
+                getRow(rbuf, y, 0);
+                getRow(gbuf, y, 1);
+                getRow(bbuf, y, 2);
+                getRow(abuf, y, 3);
+                rgbatorgba(rbuf, gbuf, bbuf, abuf, data, lptr);
+            } else if (zsize == 3) {
+                getRow(rbuf, y, 0);
+                getRow(gbuf, y, 1);
+                getRow(bbuf, y, 2);
+                rgbtorgba(rbuf, gbuf, bbuf, data, lptr);
+            } else if (zsize == 2) {
+                getRow(rbuf, y, 0);
+                getRow(abuf, y, 1);
+                latorgba(rbuf, abuf, data, lptr);
+            } else {
+                getRow(rbuf, y, 0);
+                bwtorgba(rbuf, data, lptr);
+            }
+            lptr += 4 * xsize;
+        }
+        rowStart = null;
+        rowSize  = null;
+        tmpData  = null;
+        tmpRead  = null;
+        format   = GL.GL_RGBA;
+        header.zsize = 4;
+    }
+
+    private void getRow(byte[] buf, int y, int z) {
+        if (header.storage == 1) {
+            int offs = rowStart[y + z * header.ysize] - rleEnd;
+            System.arraycopy(tmpData, offs, tmpRead, 0, rowSize[y + z * header.ysize]);
+            int iPtr = 0;
+            int oPtr = 0;
+            for (;;) {
+                byte pixel = tmpRead[iPtr++];
+                int count = (int) (pixel & 0x7F);
+                if (count == 0) {
+                    return;
+                }
+                if ((pixel & 0x80) != 0) {
+                    while ((count--) > 0) {
+                        buf[oPtr++] = tmpRead[iPtr++];
+                    }
+                } else {
+                    pixel = tmpRead[iPtr++];
+                    while ((count--) > 0) {
+                        buf[oPtr++] = pixel;
+                    }
+                }
+            }
+        } else {
+            int offs = (y * header.xsize) + (z * header.xsize * header.ysize);
+            System.arraycopy(tmpData, offs, buf, 0, header.xsize);
+        }
+    }
+
+    private void bwtorgba(byte[] b, byte[] dest, int lptr) {
+        for (int i = 0; i < b.length; i++) {
+            dest[4 * i + lptr + 0] = b[i];
+            dest[4 * i + lptr + 1] = b[i];
+            dest[4 * i + lptr + 2] = b[i];
+            dest[4 * i + lptr + 3] = (byte) 0xFF;
+        }
+    }
+
+    private void latorgba(byte[] b, byte[] a, byte[] dest, int lptr) {
+        for (int i = 0; i < b.length; i++) {
+            dest[4 * i + lptr + 0] = b[i];
+            dest[4 * i + lptr + 1] = b[i];
+            dest[4 * i + lptr + 2] = b[i];
+            dest[4 * i + lptr + 3] = a[i];
+        }
+    }
+
+    private void rgbtorgba(byte[] r, byte[] g, byte[] b, byte[] dest, int lptr) {
+        for (int i = 0; i < b.length; i++) {
+            dest[4 * i + lptr + 0] = r[i];
+            dest[4 * i + lptr + 1] = g[i];
+            dest[4 * i + lptr + 2] = b[i];
+            dest[4 * i + lptr + 3] = (byte) 0xFF;
+        }
+    }
+
+    private void rgbatorgba(byte[] r, byte[] g, byte[] b, byte[] a, byte[] dest, int lptr) {
+        for (int i = 0; i < b.length; i++) {
+            dest[4 * i + lptr + 0] = r[i];
+            dest[4 * i + lptr + 1] = g[i];
+            dest[4 * i + lptr + 2] = b[i];
+            dest[4 * i + lptr + 3] = a[i];
+        }
+    }
+
+    private static byte imgref(byte[] i,
+                               int x,
+                               int y,
+                               int z,
+                               int xs,
+                               int ys,
+                               int zs) {
+        return i[(xs*ys*z)+(xs*y)+x];
+    }
+
+
+    private void writeHeader(DataOutputStream stream,
+                             int xsize, int ysize, int zsize, boolean rle) throws IOException {
+        // effects: outputs the 512-byte IRIS RGB header to STREAM, using xsize,
+        //          ysize, and depth as the dimensions of the image. NOTE that
+        //          the following defaults are used:
+        //              STORAGE = 1     (storage format = RLE)
+        //              BPC = 1         (# bytes/channel)
+        //              DIMENSION = 3
+        //              PIXMIN = 0
+        //              PIXMAX = 255
+        //              IMAGENAME = <80 nulls>
+        //              COLORMAP = 0
+        //          See ftp://ftp.sgi.com/pub/sgi/SGIIMAGESPEC for more details.
+
+        // write out MAGIC, STORAGE, BPC
+        stream.writeShort(474);
+        stream.write((rle ? 1 : 0));
+        stream.write(1);
+
+        // write out DIMENSION
+        stream.writeShort(3);
+
+        // write XSIZE, YSIZE, ZSIZE
+        stream.writeShort(xsize);
+        stream.writeShort(ysize);
+        stream.writeShort(zsize);
+
+        // write PIXMIN, PIXMAX
+        stream.writeInt(0);
+        stream.writeInt(255);
+
+        // write DUMMY
+        stream.writeInt(0);
+
+        // write IMAGENAME
+        for (int i = 0; i < 80; i++)
+            stream.write(0);
+
+        // write COLORMAP
+        stream.writeInt(0);
+
+        // write DUMMY (404 bytes)
+        for (int i = 0; i < 404; i++)
+            stream.write(0);
+    }
+
+    private void writeImage(File file,
+                            byte[] data,
+                            int xsize,
+                            int ysize,
+                            int zsize,
+                            boolean yflip) throws IOException {
+        // Input data is in RGBRGBRGB or RGBARGBARGBA format; first unswizzle it
+        byte[] tmpData = new byte[xsize * ysize * zsize];
+        int dest = 0;
+        for (int i = 0; i < zsize; i++) {
+            for (int j = i; j < (xsize * ysize * zsize); j += zsize) {
+                tmpData[dest++] = data[j];
+            }
+        }
+        data = tmpData;
+
+        // requires: DATA must be an array of size XSIZE * YSIZE * ZSIZE,
+        //           indexed in the following manner:
+        //             data[0]    ...data[xsize-1] == first row of first channel
+        //             data[xsize]...data[2*xsize-1]   == second row of first channel
+        //         ... data[(ysize - 1) * xsize]...data[(ysize * xsize) - 1] ==
+        //                                            last row of first channel
+        //           Later channels follow the same format.
+        //           *** NOTE that "first row" is defined by the BOTTOM ROW of
+        //           the image. That is, the origin is in the lower left corner.
+        // effects: writes out an SGI image to FILE, RLE-compressed, INCLUDING
+        //          header, of dimensions (xsize, ysize, zsize), and containing
+        //          the data in DATA. If YFLIP is set, outputs the data in DATA
+        //          in reverse order vertically (equivalent to a flip about the
+        //          x axis).
+
+        // Build the offset tables
+        int[] starttab  = new int[ysize * zsize];
+        int[] lengthtab = new int[ysize * zsize];
+
+        // Temporary buffer for holding RLE data.
+        // Note that this makes the assumption that RLE-compressed data will
+        // never exceed twice the size of the input data.
+        // There are surely formal proofs about how big the RLE buffer should
+        // be, as well as what the optimal look-ahead size is (i.e. don't switch
+        // copy/repeat modes for less than N repeats). However, I'm going from
+        // empirical evidence here; the break-even point seems to be a look-
+        // ahead of 3. (That is, if the three values following this one are all
+        // the same as the current value, switch to repeat mode.)
+        int lookahead = 3;
+        byte[] rlebuf = new byte[2 * xsize * ysize * zsize];
+
+        int cur_loc = 0;   // current offset location.
+        int ptr = 0;
+        int total_size = 0;
+        int ystart = 0;
+        int yincr = 1;
+        int yend = ysize;
+
+        if (yflip) {
+            ystart = ysize - 1;
+            yend = -1;
+            yincr = -1;
+        }
+
+        boolean DEBUG = false;
+
+        for (int z = 0; z < zsize; z++) {
+            for (int y = ystart; y != yend; y += yincr) {
+                // RLE-compress each row.
+	  
+                int x = 0;
+                byte count = 0;
+                boolean repeat_mode = false;
+                boolean should_switch = false;
+                int start_ptr = ptr;
+                int num_ptr = ptr++;
+                byte repeat_val = 0;
+	  
+                while (x < xsize) {
+                    // see if we should switch modes
+                    should_switch = false;
+                    if (repeat_mode) {
+                        if (imgref(data, x, y, z, xsize, ysize, zsize) != repeat_val) {
+                            should_switch = true;
+                        }
+                    } else {
+                        // look ahead to see if we should switch to repeat mode.
+                        // stay within the scanline for the lookahead
+                        if ((x + lookahead) < xsize) {
+                            should_switch = true;
+                            for (int i = 1; i <= lookahead; i++) {
+                                if (DEBUG)
+                                    System.err.println("left side was " + ((int) imgref(data, x, y, z, xsize, ysize, zsize)) +
+                                                       ", right side was " + (int)imgref(data, x+i, y, z, xsize, ysize, zsize));
+			  
+                                if (imgref(data, x, y, z, xsize, ysize, zsize) !=
+                                    imgref(data, x+i, y, z, xsize, ysize, zsize))
+                                    should_switch = false;
+                            }
+                        }
+                    }
+
+                    if (should_switch || (count == 127)) {
+                        // update the number of elements we repeated/copied
+                        if (x > 0) {
+                            if (repeat_mode)
+                                rlebuf[num_ptr] = count;
+                            else
+                                rlebuf[num_ptr] = (byte) (count | 0x80);
+                        }
+                        // perform mode switch if necessary; output repeat_val if
+                        // switching FROM repeat mode, and set it if switching
+                        // TO repeat mode.
+                        if (repeat_mode) {
+                            if (should_switch)
+                                repeat_mode = false;
+                            rlebuf[ptr++] = repeat_val;
+                        } else {
+                            if (should_switch)
+                                repeat_mode = true;
+                            repeat_val = imgref(data, x, y, z, xsize, ysize, zsize);
+                        }
+		  
+                        if (x > 0) {
+                            // reset the number pointer
+                            num_ptr = ptr++;
+                            // reset number of bytes copied
+                            count = 0;
+                        }
+                    }
+		    
+                    // if not in repeat mode, copy element to ptr
+                    if (!repeat_mode) {
+                        rlebuf[ptr++] = imgref(data, x, y, z, xsize, ysize, zsize);
+                    }
+                    count++;
+
+                    if (x == xsize - 1) {
+                        // Need to store the number of pixels we copied/repeated.
+                        if (repeat_mode) {
+                            rlebuf[num_ptr] = count;
+                            // If we ended the row in repeat mode, store the
+                            // repeated value
+                            rlebuf[ptr++] = repeat_val;
+                        }
+                        else
+                            rlebuf[num_ptr] = (byte) (count | 0x80);
+
+                        // output zero counter for the last value in the row
+                        rlebuf[ptr++] = 0;
+                    }
+
+                    x++;
+                }
+                // output this row's length into the length table
+                int rowlen = ptr - start_ptr;
+                if (yflip)
+                    lengthtab[ysize*z+(ysize-y-1)] = rowlen;
+                else
+                    lengthtab[ysize*z+y] = rowlen;
+                // add to the start table, and update the current offset
+                if (yflip)
+                    starttab[ysize*z+(ysize-y-1)] = cur_loc;
+                else
+                    starttab[ysize*z+y] = cur_loc;
+                cur_loc += rowlen;
+            }
+        }
+
+        // Now we have the offset tables computed, as well as the RLE data.
+        // Output this information to the file.
+        total_size = ptr;
+  
+        if (DEBUG) 
+            System.err.println("total_size was " + total_size);
+
+        DataOutputStream stream = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(file)));
+
+        writeHeader(stream, xsize, ysize, zsize, true);
+
+        int SIZEOF_INT = 4;
+        for (int i = 0; i < (ysize * zsize); i++)
+            stream.writeInt(starttab[i] + 512 + (2 * ysize * zsize * SIZEOF_INT));
+        for (int i = 0; i < (ysize * zsize); i++)
+            stream.writeInt(lengthtab[i]);
+        for (int i = 0; i < total_size; i++)
+            stream.write(rlebuf[i]);
+
+        stream.close();
+    }
+
+    private byte[] readAll(DataInputStream in) throws IOException {
+        byte[] dest = new byte[16384];
+        int pos = 0;
+        int numRead = 0;
+    
+        boolean done = false;
+
+        do {
+            numRead = in.read(dest, pos, dest.length - pos);
+            if (pos == dest.length) {
+                // Resize destination buffer
+                byte[] newDest = new byte[2 * dest.length];
+                System.arraycopy(dest, 0, newDest, 0, pos);
+                dest = newDest;
+            }
+            if (numRead > 0) {
+                pos += numRead;
+            }
+
+            done = ((numRead == -1) || (in.available() == 0));
+        } while (!done);
+
+        // Trim destination buffer
+        if (pos != dest.length) {
+            byte[] finalDest = new byte[pos];
+            System.arraycopy(dest, 0, finalDest, 0, pos);
+            dest = finalDest;
+        }
+
+        return dest;
+    }
+
+    // Test case
+    /*
+      import java.awt.image.*;
+      import javax.swing.*;
+
+      public static void main(String[] args) {
+      for (int i = 0; i < args.length; i++) {
+      try {
+      System.out.println(args[i] + ":");
+      SGIImage image = SGIImage.read(args[i]);
+      System.out.println(image);
+      BufferedImage img = new BufferedImage(image.getWidth(), image.getHeight(), BufferedImage.TYPE_4BYTE_ABGR);
+      WritableRaster raster = img.getRaster();
+      DataBufferByte db = (DataBufferByte) raster.getDataBuffer();
+      byte[] src  = image.getData();
+      byte[] dest = db.getData();
+      for (int j = 0; j < src.length; j += 4) {
+      dest[j + 0] = src[j + 3];
+      dest[j + 1] = src[j + 2];
+      dest[j + 2] = src[j + 1];
+      dest[j + 3] = src[j + 0];
+      }
+      // System.arraycopy(src, 0, dest, 0, src.length);
+      ImageIcon icon = new ImageIcon(img);
+      JLabel label = new JLabel();
+      label.setIcon(icon);
+      JFrame frame = new JFrame(args[i]);
+      frame.getContentPane().add(label);
+      frame.pack();
+      frame.show();
+      } catch (IOException e) {
+      e.printStackTrace();
+      }
+      }
+      }
+    */
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/texture/spi/TGAImage.java.javame_cdc_fp b/src/jogl/classes/com/jogamp/opengl/util/texture/spi/TGAImage.java.javame_cdc_fp
new file mode 100755
index 000000000..d1eca7c69
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/texture/spi/TGAImage.java.javame_cdc_fp
@@ -0,0 +1,417 @@
+/*
+ * Copyright (c) 2003-2005 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util.texture.spi;
+
+import java.io.*;
+import java.nio.*;
+import javax.media.opengl.*;
+import com.jogamp.opengl.util.*;
+import com.jogamp.opengl.util.texture.spi.*;
+import com.jogamp.opengl.util.texture.*;
+
+/**
+ * Targa image reader and writer adapted from sources of the <a href =
+ * "http://java.sun.com/products/jimi/">Jimi</a> image I/O class library.
+ *
+ * <P>
+ *
+ * Image decoder for image data stored in TGA file format.
+ * Currently only the original TGA file format is supported. This is
+ * because the new TGA format has data at the end of the file, getting
+ * to the end of a file in an InputStream orient environment presents
+ * several difficulties which are avoided at the moment.
+ *
+ * <P>
+ *
+ * This is a simple decoder and is only setup to load a single image
+ * from the input stream
+ *
+ * <P>
+ *
+ * @author    Robin Luiten
+ * @author    Kenneth Russell
+ * @version    $Revision: 1768 $
+ */
+
+public class TGAImage {
+    private Header header;
+    private int    format;
+    private int    bpp;
+    private ByteBuffer data;
+
+    private TGAImage(Header header) {
+        this.header = header;
+    }
+
+    /**
+     * This class reads in all of the TGA image header in addition it also
+     * reads in the imageID field as it is convenient to handle that here.
+     *
+     * @author    Robin Luiten
+     * @version   1.1
+     */
+    public static class Header {
+        /** Set of possible file format TGA types */
+        public final static int TYPE_NEW = 0;
+        public final static int TYPE_OLD = 1;
+        public final static int TYPE_UNK = 2;               // cant rewind stream so unknown for now.
+
+        /**  Set of possible image types in TGA file */
+        public final static int NO_IMAGE = 0;               // no image data
+        public final static int UCOLORMAPPED = 1;           // uncompressed color mapped image
+        public final static int UTRUECOLOR = 2;             // uncompressed true color image
+        public final static int UBLACKWHITE = 3;            // uncompressed black and white image
+        public final static int COLORMAPPED = 9;            // compressed color mapped image
+        public final static int TRUECOLOR = 10;             // compressed true color image
+        public final static int BLACKWHITE = 11;            // compressed black and white image
+
+        /** Field image descriptor bitfield values definitions */
+        public final static int ID_ATTRIBPERPIXEL = 0xF;
+        public final static int ID_RIGHTTOLEFT = 0x10;
+        public final static int ID_TOPTOBOTTOM = 0x20;
+        public final static int ID_INTERLEAVE  = 0xC0;
+
+        /** Field image descriptor / interleave values */
+        public final static int I_NOTINTERLEAVED = 0;
+        public final static int I_TWOWAY = 1;
+        public final static int I_FOURWAY = 2;
+
+        /** Type of this TGA file format */
+        private int tgaType;
+
+        /** initial TGA image data fields */
+        private int idLength;         // byte value
+        private int colorMapType;     // byte value
+        private int imageType;        // byte value
+
+        /** TGA image colour map fields */
+        private int firstEntryIndex;
+        private int colorMapLength;
+        private byte colorMapEntrySize;
+
+        /** TGA image specification fields */
+        private int xOrigin;
+        private int yOrigin;
+        private int width;
+        private int height;
+        private byte pixelDepth;
+        private byte imageDescriptor;
+
+        private byte[] imageIDbuf;
+        private String imageID;
+
+        // For construction from user data
+        Header() {
+            tgaType = TYPE_OLD; // dont try and get footer.
+        }
+
+        Header(LEDataInputStream in) throws IOException {
+            int ret;
+
+            tgaType = TYPE_OLD; // dont try and get footer.
+
+            // initial header fields
+            idLength = in.readUnsignedByte();    
+            colorMapType = in.readUnsignedByte();
+            imageType = in.readUnsignedByte();    
+
+            // color map header fields
+            firstEntryIndex = in.readUnsignedShort();
+            colorMapLength = in.readUnsignedShort();
+            colorMapEntrySize = in.readByte();
+
+            // TGA image specification fields
+            xOrigin = in.readUnsignedShort();
+            yOrigin = in.readUnsignedShort();
+            width = in.readUnsignedShort();
+            height = in.readUnsignedShort();
+            pixelDepth = in.readByte();
+            imageDescriptor = in.readByte();
+
+            if (idLength > 0) {
+                imageIDbuf = new byte[idLength];
+                in.read(imageIDbuf, 0, idLength);
+                imageID = new String(imageIDbuf, "US-ASCII");
+            }
+        }
+
+        public int tgaType()                 { return tgaType; }
+
+        /** initial TGA image data fields */
+        public int idLength()                { return idLength; }
+        public int colorMapType()            { return colorMapType; }
+        public int imageType()               { return imageType; }
+
+        /** TGA image colour map fields */
+        public int firstEntryIndex()         { return firstEntryIndex; }
+        public int colorMapLength()          { return colorMapLength; }
+        public byte colorMapEntrySize()      { return colorMapEntrySize; }
+
+        /** TGA image specification fields */
+        public int xOrigin()                 { return xOrigin; }
+        public int yOrigin()                 { return yOrigin; }
+        public int width()                   { return width; }
+        public int height()                  { return height; }
+        public byte pixelDepth()             { return pixelDepth; }
+        public byte imageDescriptor()        { return imageDescriptor; }
+
+        /** bitfields in imageDescriptor */
+        public byte attribPerPixel()         { return (byte)(imageDescriptor & ID_ATTRIBPERPIXEL); }
+        public boolean rightToLeft()         { return ((imageDescriptor & ID_RIGHTTOLEFT) != 0); }
+        public boolean topToBottom()         { return ((imageDescriptor & ID_TOPTOBOTTOM) != 0); }
+        public byte interleave()             { return (byte)((imageDescriptor & ID_INTERLEAVE) >> 6); }
+
+        public byte[] imageIDbuf()           { return imageIDbuf; }
+        public String imageID()              { return imageID; }
+
+        public String toString() {
+            return "TGA Header " +
+                " id length: " + idLength +
+                " color map type: "+ colorMapType +
+                " image type: "+ imageType +
+                " first entry index: " + firstEntryIndex +
+                " color map length: " + colorMapLength +
+                " color map entry size: " + colorMapEntrySize +
+                " x Origin: " + xOrigin +
+                " y Origin: " + yOrigin +
+                " width: "+ width +
+                " height: "+ height +
+                " pixel depth: "+ pixelDepth +
+                " image descriptor: "+ imageDescriptor +
+                (imageIDbuf == null ? "" : (" ID String: " + imageID));
+        }
+
+        public int size() { return 18 + idLength; }
+
+        private void write(LEDataOutputStream output) throws IOException {
+            output.write(idLength);
+            output.write(colorMapType);
+            output.write(imageType);
+            output.writeShort(firstEntryIndex);
+            output.writeShort(colorMapLength);
+            output.write(colorMapEntrySize);
+            output.writeShort(xOrigin);
+            output.writeShort(yOrigin);
+            output.writeShort(width);
+            output.writeShort(height);
+            output.write(pixelDepth);
+            output.write(imageDescriptor);
+            if (idLength > 0) {
+                try {
+                    byte[] chars = imageID.getBytes("US-ASCII");
+                    output.write(chars);
+                } catch (UnsupportedEncodingException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        }
+    }
+
+
+    /**
+     * Identifies the image type of the tga image data and loads
+     * it into the JimiImage structure. This was taken from the
+     * prototype and modified for the new Jimi structure
+     */
+    private void decodeImage(LEDataInputStream dIn) throws IOException {
+        switch (header.imageType()) {
+        case Header.UCOLORMAPPED:
+            throw new IOException("TGADecoder Uncompressed Colormapped images not supported");
+
+        case Header.UTRUECOLOR:    // pixelDepth 15, 16, 24 and 32
+            switch (header.pixelDepth) {
+            case 16:
+                throw new IOException("TGADecoder Compressed 16-bit True Color images not supported");
+
+            case 24:
+            case 32:
+                decodeRGBImageU24_32(dIn);
+                break;
+            }
+            break;
+
+        case Header.UBLACKWHITE:
+            throw new IOException("TGADecoder Uncompressed Grayscale images not supported");
+
+        case Header.COLORMAPPED:
+            throw new IOException("TGADecoder Compressed Colormapped images not supported");
+
+        case Header.TRUECOLOR:
+            throw new IOException("TGADecoder Compressed True Color images not supported");
+
+        case Header.BLACKWHITE:
+            throw new IOException("TGADecoder Compressed Grayscale images not supported");
+        }
+    }
+  
+    /**
+     * This assumes that the body is for a 24 bit or 32 bit for a
+     * RGB or ARGB image respectively.
+     */
+    private void decodeRGBImageU24_32(LEDataInputStream dIn) throws IOException {
+        int i;    // row index
+        int j;    // column index
+        int y;    // output row index
+        int raw;  // index through the raw input buffer
+        int rawWidth = header.width() * (header.pixelDepth() / 8);
+        byte[] rawBuf = new byte[rawWidth];
+        byte[] tmpData = new byte[rawWidth * header.height()];
+
+        for (i = 0; i < header.height(); ++i) {
+            dIn.readFully(rawBuf, 0, rawWidth);
+
+            if (header.topToBottom())
+                y = header.height - i - 1; // range 0 to (header.height - 1)
+            else
+                y = i;
+
+            System.arraycopy(rawBuf, 0, tmpData, y * rawWidth, rawBuf.length);
+        }
+
+        GL gl = GLContext.getCurrentGL();
+        if (header.pixelDepth() == 24) {
+            bpp=3;
+            if(gl.isGL2()) {
+                format = GL2.GL_BGR;
+            } else {
+                format = GL.GL_RGB;
+                swapBGR(tmpData, rawWidth, header.height(), bpp);
+            }
+        } else {
+            assert header.pixelDepth() == 32;
+            bpp=4;
+
+            if(gl.isGL2()) {
+                format = GL2.GL_BGRA;
+            } else {
+                format = GL.GL_RGBA;
+                swapBGR(tmpData, rawWidth, header.height(), bpp);
+            }
+        }
+
+        data = ByteBuffer.wrap(tmpData);
+    }
+
+    private static void swapBGR(byte[] data, int bWidth, int height, int bpp) {
+        byte r,b;
+        int k;
+        for(int i=0; i<height; ++i) {
+            for(int j=0; j<bWidth; j+=bpp) {
+                k=i*bWidth+j;
+                b=data[k+0];
+                r=data[k+2];
+                data[k+0]=r;
+                data[k+2]=b;
+            }
+        }
+    }
+
+    /** Returns the width of the image. */
+    public int getWidth()    { return header.width(); }
+
+    /** Returns the height of the image. */
+    public int getHeight()   { return header.height(); }
+
+    /** Returns the OpenGL format for this texture; e.g. GL.GL_BGR or GL.GL_BGRA. */
+    public int getGLFormat() { return format; }
+
+    /** Returns the bytes per pixel */
+    public int getBytesPerPixel() { return bpp; }
+
+    /** Returns the raw data for this texture in the correct
+        (bottom-to-top) order for calls to glTexImage2D. */
+    public ByteBuffer getData()  { return data; }
+
+    /** Reads a Targa image from the specified file. */
+    public static TGAImage read(String filename) throws IOException {
+        return read(new FileInputStream(filename));
+    }
+
+    /** Reads a Targa image from the specified InputStream. */
+    public static TGAImage read(InputStream in) throws IOException {
+        LEDataInputStream dIn = new LEDataInputStream(new BufferedInputStream(in));
+
+        Header header = new Header(dIn);
+        TGAImage res = new TGAImage(header);
+        res.decodeImage(dIn);
+        return res;
+    }
+
+    /** Writes the image in Targa format to the specified file name. */
+    public void write(String filename) throws IOException {
+        write(new File(filename));
+    }
+
+    /** Writes the image in Targa format to the specified file. */
+    public void write(File file) throws IOException {
+        LEDataOutputStream output =
+            new LEDataOutputStream(new DataOutputStream(new BufferedOutputStream(new FileOutputStream(file))));
+        header.write(output);
+        if (!data.isDirect()) {
+            output.write(data.array());
+        } else {
+            for (int i = 0; i < data.limit(); i++) {
+                output.write(data.get(i));
+            }
+        }
+        output.close();
+    }
+
+    /** Creates a TGAImage from data supplied by the end user. Shares
+        data with the passed ByteBuffer. Assumes the data is already in
+        the correct byte order for writing to disk, i.e., BGR or
+        BGRA. */
+    public static TGAImage createFromData(int width,
+                                          int height,
+                                          boolean hasAlpha,
+                                          boolean topToBottom,
+                                          ByteBuffer data) {
+        Header header = new Header();
+        header.imageType = Header.UTRUECOLOR;
+        header.width = width;
+        header.height = height;
+        header.pixelDepth = (byte) (hasAlpha ? 32 : 24);
+        header.imageDescriptor = (byte) (topToBottom ? Header.ID_TOPTOBOTTOM : 0);
+        // Note ID not supported
+        TGAImage ret = new TGAImage(header);
+        ret.data = data;
+        return ret;
+    }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/texture/spi/TGAImage.java.javase b/src/jogl/classes/com/jogamp/opengl/util/texture/spi/TGAImage.java.javase
new file mode 100755
index 000000000..8575f553d
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/texture/spi/TGAImage.java.javase
@@ -0,0 +1,420 @@
+/*
+ * Copyright (c) 2003-2005 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util.texture.spi;
+
+import java.io.*;
+import java.nio.*;
+import java.nio.channels.*;
+import javax.media.opengl.*;
+import com.jogamp.opengl.util.*;
+import com.jogamp.opengl.util.texture.spi.*;
+import com.jogamp.opengl.util.texture.*;
+
+/**
+ * Targa image reader and writer adapted from sources of the <a href =
+ * "http://java.sun.com/products/jimi/">Jimi</a> image I/O class library.
+ *
+ * <P>
+ *
+ * Image decoder for image data stored in TGA file format.
+ * Currently only the original TGA file format is supported. This is
+ * because the new TGA format has data at the end of the file, getting
+ * to the end of a file in an InputStream orient environment presents
+ * several difficulties which are avoided at the moment.
+ *
+ * <P>
+ *
+ * This is a simple decoder and is only setup to load a single image
+ * from the input stream
+ *
+ * <P>
+ *
+ * @author    Robin Luiten
+ * @author    Kenneth Russell
+ * @version    $Revision: 1768 $
+ */
+
+public class TGAImage {
+    private Header header;
+    private int    format;
+    private int    bpp;
+    private ByteBuffer data;
+
+    private TGAImage(Header header) {
+        this.header = header;
+    }
+
+    /**
+     * This class reads in all of the TGA image header in addition it also
+     * reads in the imageID field as it is convenient to handle that here.
+     *
+     * @author    Robin Luiten
+     * @version   1.1
+     */
+    public static class Header {
+        /** Set of possible file format TGA types */
+        public final static int TYPE_NEW = 0;
+        public final static int TYPE_OLD = 1;
+        public final static int TYPE_UNK = 2;               // cant rewind stream so unknown for now.
+
+        /**  Set of possible image types in TGA file */
+        public final static int NO_IMAGE = 0;               // no image data
+        public final static int UCOLORMAPPED = 1;           // uncompressed color mapped image
+        public final static int UTRUECOLOR = 2;             // uncompressed true color image
+        public final static int UBLACKWHITE = 3;            // uncompressed black and white image
+        public final static int COLORMAPPED = 9;            // compressed color mapped image
+        public final static int TRUECOLOR = 10;             // compressed true color image
+        public final static int BLACKWHITE = 11;            // compressed black and white image
+
+        /** Field image descriptor bitfield values definitions */
+        public final static int ID_ATTRIBPERPIXEL = 0xF;
+        public final static int ID_RIGHTTOLEFT = 0x10;
+        public final static int ID_TOPTOBOTTOM = 0x20;
+        public final static int ID_INTERLEAVE  = 0xC0;
+
+        /** Field image descriptor / interleave values */
+        public final static int I_NOTINTERLEAVED = 0;
+        public final static int I_TWOWAY = 1;
+        public final static int I_FOURWAY = 2;
+
+        /** Type of this TGA file format */
+        private int tgaType;
+
+        /** initial TGA image data fields */
+        private int idLength;         // byte value
+        private int colorMapType;     // byte value
+        private int imageType;        // byte value
+
+        /** TGA image colour map fields */
+        private int firstEntryIndex;
+        private int colorMapLength;
+        private byte colorMapEntrySize;
+
+        /** TGA image specification fields */
+        private int xOrigin;
+        private int yOrigin;
+        private int width;
+        private int height;
+        private byte pixelDepth;
+        private byte imageDescriptor;
+
+        private byte[] imageIDbuf;
+        private String imageID;
+
+        // For construction from user data
+        Header() {
+            tgaType = TYPE_OLD; // dont try and get footer.
+        }
+
+        Header(LEDataInputStream in) throws IOException {
+            int ret;
+
+            tgaType = TYPE_OLD; // dont try and get footer.
+
+            // initial header fields
+            idLength = in.readUnsignedByte();    
+            colorMapType = in.readUnsignedByte();
+            imageType = in.readUnsignedByte();    
+
+            // color map header fields
+            firstEntryIndex = in.readUnsignedShort();
+            colorMapLength = in.readUnsignedShort();
+            colorMapEntrySize = in.readByte();
+
+            // TGA image specification fields
+            xOrigin = in.readUnsignedShort();
+            yOrigin = in.readUnsignedShort();
+            width = in.readUnsignedShort();
+            height = in.readUnsignedShort();
+            pixelDepth = in.readByte();
+            imageDescriptor = in.readByte();
+
+            if (idLength > 0) {
+                imageIDbuf = new byte[idLength];
+                in.read(imageIDbuf, 0, idLength);
+                imageID = new String(imageIDbuf, "US-ASCII");
+            }
+        }
+
+        public int tgaType()                 { return tgaType; }
+
+        /** initial TGA image data fields */
+        public int idLength()                { return idLength; }
+        public int colorMapType()            { return colorMapType; }
+        public int imageType()               { return imageType; }
+
+        /** TGA image colour map fields */
+        public int firstEntryIndex()         { return firstEntryIndex; }
+        public int colorMapLength()          { return colorMapLength; }
+        public byte colorMapEntrySize()      { return colorMapEntrySize; }
+
+        /** TGA image specification fields */
+        public int xOrigin()                 { return xOrigin; }
+        public int yOrigin()                 { return yOrigin; }
+        public int width()                   { return width; }
+        public int height()                  { return height; }
+        public byte pixelDepth()             { return pixelDepth; }
+        public byte imageDescriptor()        { return imageDescriptor; }
+
+        /** bitfields in imageDescriptor */
+        public byte attribPerPixel()         { return (byte)(imageDescriptor & ID_ATTRIBPERPIXEL); }
+        public boolean rightToLeft()         { return ((imageDescriptor & ID_RIGHTTOLEFT) != 0); }
+        public boolean topToBottom()         { return ((imageDescriptor & ID_TOPTOBOTTOM) != 0); }
+        public byte interleave()             { return (byte)((imageDescriptor & ID_INTERLEAVE) >> 6); }
+
+        public byte[] imageIDbuf()           { return imageIDbuf; }
+        public String imageID()              { return imageID; }
+
+        public String toString() {
+            return "TGA Header " +
+                " id length: " + idLength +
+                " color map type: "+ colorMapType +
+                " image type: "+ imageType +
+                " first entry index: " + firstEntryIndex +
+                " color map length: " + colorMapLength +
+                " color map entry size: " + colorMapEntrySize +
+                " x Origin: " + xOrigin +
+                " y Origin: " + yOrigin +
+                " width: "+ width +
+                " height: "+ height +
+                " pixel depth: "+ pixelDepth +
+                " image descriptor: "+ imageDescriptor +
+                (imageIDbuf == null ? "" : (" ID String: " + imageID));
+        }
+
+        public int size() { return 18 + idLength; }
+
+        // buf must be in little-endian byte order
+        private void write(ByteBuffer buf) {
+            buf.put((byte) idLength);
+            buf.put((byte) colorMapType);
+            buf.put((byte) imageType);
+            buf.putShort((short) firstEntryIndex);
+            buf.putShort((short) colorMapLength);
+            buf.put((byte) colorMapEntrySize);
+            buf.putShort((short) xOrigin);
+            buf.putShort((short) yOrigin);
+            buf.putShort((short) width);
+            buf.putShort((short) height);
+            buf.put((byte) pixelDepth);
+            buf.put((byte) imageDescriptor);
+            if (idLength > 0) {
+                try {
+                    byte[] chars = imageID.getBytes("US-ASCII");
+                    buf.put(chars);
+                } catch (UnsupportedEncodingException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        }
+    }
+
+
+    /**
+     * Identifies the image type of the tga image data and loads
+     * it into the JimiImage structure. This was taken from the
+     * prototype and modified for the new Jimi structure
+     */
+    private void decodeImage(LEDataInputStream dIn) throws IOException {
+        switch (header.imageType()) {
+        case Header.UCOLORMAPPED:
+            throw new IOException("TGADecoder Uncompressed Colormapped images not supported");
+
+        case Header.UTRUECOLOR:    // pixelDepth 15, 16, 24 and 32
+            switch (header.pixelDepth) {
+            case 16:
+                throw new IOException("TGADecoder Compressed 16-bit True Color images not supported");
+
+            case 24:
+            case 32:
+                decodeRGBImageU24_32(dIn);
+                break;
+            }
+            break;
+
+        case Header.UBLACKWHITE:
+            throw new IOException("TGADecoder Uncompressed Grayscale images not supported");
+
+        case Header.COLORMAPPED:
+            throw new IOException("TGADecoder Compressed Colormapped images not supported");
+
+        case Header.TRUECOLOR:
+            throw new IOException("TGADecoder Compressed True Color images not supported");
+
+        case Header.BLACKWHITE:
+            throw new IOException("TGADecoder Compressed Grayscale images not supported");
+        }
+    }
+  
+    /**
+     * This assumes that the body is for a 24 bit or 32 bit for a
+     * RGB or ARGB image respectively.
+     */
+    private void decodeRGBImageU24_32(LEDataInputStream dIn) throws IOException {
+        int i;    // row index
+        int j;    // column index
+        int y;    // output row index
+        int raw;  // index through the raw input buffer
+        int rawWidth = header.width() * (header.pixelDepth() / 8);
+        byte[] rawBuf = new byte[rawWidth];
+        byte[] tmpData = new byte[rawWidth * header.height()];
+
+        for (i = 0; i < header.height(); ++i) {
+            dIn.readFully(rawBuf, 0, rawWidth);
+
+            if (header.topToBottom())
+                y = header.height - i - 1; // range 0 to (header.height - 1)
+            else
+                y = i;
+
+            System.arraycopy(rawBuf, 0, tmpData, y * rawWidth, rawBuf.length);
+        }
+
+        GL gl = GLContext.getCurrentGL();
+        if (header.pixelDepth() == 24) {
+            bpp=3;
+            if(gl.isGL2()) {
+                format = GL2.GL_BGR;
+            } else {
+                format = GL.GL_RGB;
+                swapBGR(tmpData, rawWidth, header.height(), bpp);
+            }
+        } else {
+            assert header.pixelDepth() == 32;
+            bpp=4;
+
+            if(gl.isGL2()) {
+                format = GL2.GL_BGRA;
+            } else {
+                format = GL.GL_RGBA;
+                swapBGR(tmpData, rawWidth, header.height(), bpp);
+            }
+        }
+
+        data = ByteBuffer.wrap(tmpData);
+    }
+
+    private static void swapBGR(byte[] data, int bWidth, int height, int bpp) {
+        byte r,b;
+        int k;
+        for(int i=0; i<height; ++i) {
+            for(int j=0; j<bWidth; j+=bpp) {
+                k=i*bWidth+j;
+                b=data[k+0];
+                r=data[k+2];
+                data[k+0]=r;
+                data[k+2]=b;
+            }
+        }
+    }
+
+    /** Returns the width of the image. */
+    public int getWidth()    { return header.width(); }
+
+    /** Returns the height of the image. */
+    public int getHeight()   { return header.height(); }
+
+    /** Returns the OpenGL format for this texture; e.g. GL.GL_BGR or GL.GL_BGRA. */
+    public int getGLFormat() { return format; }
+
+    /** Returns the bytes per pixel */
+    public int getBytesPerPixel() { return bpp; }
+
+    /** Returns the raw data for this texture in the correct
+        (bottom-to-top) order for calls to glTexImage2D. */
+    public ByteBuffer getData()  { return data; }
+
+    /** Reads a Targa image from the specified file. */
+    public static TGAImage read(String filename) throws IOException {
+        return read(new FileInputStream(filename));
+    }
+
+    /** Reads a Targa image from the specified InputStream. */
+    public static TGAImage read(InputStream in) throws IOException {
+        LEDataInputStream dIn = new LEDataInputStream(new BufferedInputStream(in));
+
+        Header header = new Header(dIn);
+        TGAImage res = new TGAImage(header);
+        res.decodeImage(dIn);
+        return res;
+    }
+
+    /** Writes the image in Targa format to the specified file name. */
+    public void write(String filename) throws IOException {
+        write(new File(filename));
+    }
+
+    /** Writes the image in Targa format to the specified file. */
+    public void write(File file) throws IOException {
+        FileOutputStream stream = new FileOutputStream(file);
+        FileChannel chan = stream.getChannel();
+        ByteBuffer buf = ByteBuffer.allocate(header.size());
+        buf.order(ByteOrder.LITTLE_ENDIAN);
+        header.write(buf);
+        buf.rewind();
+        chan.write(buf);
+        chan.write(data);
+        data.rewind();
+        chan.force(true);
+        chan.close();
+        stream.close();
+    }
+
+    /** Creates a TGAImage from data supplied by the end user. Shares
+        data with the passed ByteBuffer. Assumes the data is already in
+        the correct byte order for writing to disk, i.e., BGR or
+        BGRA. */
+    public static TGAImage createFromData(int width,
+                                          int height,
+                                          boolean hasAlpha,
+                                          boolean topToBottom,
+                                          ByteBuffer data) {
+        Header header = new Header();
+        header.imageType = Header.UTRUECOLOR;
+        header.width = width;
+        header.height = height;
+        header.pixelDepth = (byte) (hasAlpha ? 32 : 24);
+        header.imageDescriptor = (byte) (topToBottom ? Header.ID_TOPTOBOTTOM : 0);
+        // Note ID not supported
+        TGAImage ret = new TGAImage(header);
+        ret.data = data;
+        return ret;
+    }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/texture/spi/TextureProvider.java b/src/jogl/classes/com/jogamp/opengl/util/texture/spi/TextureProvider.java
new file mode 100755
index 000000000..88018edbe
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/texture/spi/TextureProvider.java
@@ -0,0 +1,172 @@
+/*
+ * Copyright (c) 2005 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util.texture.spi;
+
+import java.io.*;
+import java.net.*;
+import javax.media.opengl.GLProfile;
+
+import com.jogamp.opengl.util.texture.*;
+
+/** Plug-in interface to TextureIO to support reading OpenGL textures
+    from new file formats. For all methods, either internalFormat or
+    pixelFormat may be 0 in which case they must be inferred as
+    e.g. RGB or RGBA depending on the file contents.
+*/
+
+public interface TextureProvider {
+
+    /**
+     * Produces a TextureData object from a file, or returns null if the
+     * file format was not supported by this TextureProvider. Does not
+     * do any OpenGL-related work. The resulting TextureData can be
+     * converted into an OpenGL texture in a later step.
+     *
+     * @param glp the OpenGL Profile this texture data should be
+     *                  created for.
+     * @param file         the file from which to read the texture data
+     *
+     * @param internalFormat the OpenGL internal format to be used for
+     *                       the texture, or 0 if it should be inferred
+     *                       from the file's contents
+     *
+     * @param pixelFormat    the OpenGL pixel format to be used for
+     *                       the texture, or 0 if it should be inferred
+     *                       from the file's contents
+     *
+     * @param mipmap     whether mipmaps should be produced for this
+     *                   texture either by autogenerating them or
+     *                   reading them from the file. Some file formats
+     *                   support multiple mipmaps in a single file in
+     *                   which case those mipmaps will be used rather
+     *                   than generating them.
+     *
+     * @param fileSuffix     the file suffix to be used as a hint to the
+     *                       provider to more quickly decide whether it
+     *                       can handle the file, or null if the
+     *                       provider should infer the type from the
+     *                       file's contents
+     *
+     * @throws IOException if an error occurred while reading the file
+     */
+    public TextureData newTextureData(GLProfile glp, File file,
+                                      int internalFormat,
+                                      int pixelFormat,
+                                      boolean mipmap,
+                                      String fileSuffix) throws IOException;
+
+    /**
+     * Produces a TextureData object from a stream, or returns null if
+     * the file format was not supported by this TextureProvider. Does
+     * not do any OpenGL-related work. The resulting TextureData can be
+     * converted into an OpenGL texture in a later step.
+     *
+     * @param glp the OpenGL Profile this texture data should be
+     *                  created for.
+     * @param stream       the stream from which to read the texture data
+     *
+     * @param internalFormat the OpenGL internal format to be used for
+     *                       the texture, or 0 if it should be inferred
+     *                       from the file's contents
+     *
+     * @param pixelFormat    the OpenGL pixel format to be used for
+     *                       the texture, or 0 if it should be inferred
+     *                       from the file's contents
+     *
+     * @param mipmap     whether mipmaps should be produced for this
+     *                   texture either by autogenerating them or
+     *                   reading them from the file. Some file formats
+     *                   support multiple mipmaps in a single file in
+     *                   which case those mipmaps will be used rather
+     *                   than generating them.
+     *
+     * @param fileSuffix     the file suffix to be used as a hint to the
+     *                       provider to more quickly decide whether it
+     *                       can handle the file, or null if the
+     *                       provider should infer the type from the
+     *                       file's contents
+     *
+     * @throws IOException if an error occurred while reading the stream
+     */
+    public TextureData newTextureData(GLProfile glp, InputStream stream,
+                                      int internalFormat,
+                                      int pixelFormat,
+                                      boolean mipmap,
+                                      String fileSuffix) throws IOException;
+
+    /**
+     * Produces a TextureData object from a URL, or returns null if the
+     * file format was not supported by this TextureProvider. Does not
+     * do any OpenGL-related work. The resulting TextureData can be
+     * converted into an OpenGL texture in a later step.
+     *
+     * @param glp the OpenGL Profile this texture data should be
+     *                  created for.
+     * @param url          the URL from which to read the texture data
+     *
+     * @param internalFormat the OpenGL internal format to be used for
+     *                       the texture, or 0 if it should be inferred
+     *                       from the file's contents
+     *
+     * @param pixelFormat    the OpenGL pixel format to be used for
+     *                       the texture, or 0 if it should be inferred
+     *                       from the file's contents
+     *
+     * @param mipmap     whether mipmaps should be produced for this
+     *                   texture either by autogenerating them or
+     *                   reading them from the file. Some file formats
+     *                   support multiple mipmaps in a single file in
+     *                   which case those mipmaps will be used rather
+     *                   than generating them.
+     *
+     * @param fileSuffix     the file suffix to be used as a hint to the
+     *                       provider to more quickly decide whether it
+     *                       can handle the file, or null if the
+     *                       provider should infer the type from the
+     *                       file's contents
+     *
+     * @throws IOException if an error occurred while reading the URL
+     */
+    public TextureData newTextureData(GLProfile glp, URL url,
+                                      int internalFormat,
+                                      int pixelFormat,
+                                      boolean mipmap,
+                                      String fileSuffix) throws IOException;
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/texture/spi/TextureWriter.java b/src/jogl/classes/com/jogamp/opengl/util/texture/spi/TextureWriter.java
new file mode 100755
index 000000000..55527cef5
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/texture/spi/TextureWriter.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2005 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util.texture.spi;
+
+import java.io.*;
+
+import com.jogamp.opengl.util.texture.*;
+
+/** Plug-in interface to TextureIO to support writing OpenGL textures
+    to new file formats. */
+
+public interface TextureWriter {
+    /** Writes the given TextureData to the passed file. Returns true if
+        this TextureWriter successfully handled the writing of the file,
+        otherwise false. May throw IOException if either this writer did
+        not support certain parameters of the TextureData or if an I/O
+        error occurred. */
+    public boolean write(File file,
+                         TextureData data) throws IOException;
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/texture/spi/awt/IIOTextureProvider.java b/src/jogl/classes/com/jogamp/opengl/util/texture/spi/awt/IIOTextureProvider.java
new file mode 100644
index 000000000..a45821d87
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/texture/spi/awt/IIOTextureProvider.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2005 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util.texture.spi.awt;
+
+import java.awt.Graphics;
+import java.awt.image.*;
+import java.io.*;
+import java.net.*;
+import javax.imageio.*;
+import javax.media.opengl.GLProfile;
+
+import com.jogamp.opengl.impl.Debug;
+import com.jogamp.opengl.util.texture.*;
+import com.jogamp.opengl.util.texture.awt.*;
+import com.jogamp.opengl.util.texture.spi.*;
+
+public class IIOTextureProvider implements TextureProvider {
+    private static final boolean DEBUG = Debug.debug("TextureIO");
+
+    public TextureData newTextureData(GLProfile glp, File file,
+                                      int internalFormat,
+                                      int pixelFormat,
+                                      boolean mipmap,
+                                      String fileSuffix) throws IOException {
+        BufferedImage img = ImageIO.read(file);
+        if (img == null) {
+            return null;
+        }
+        if (DEBUG) {
+            System.out.println("TextureIO.newTextureData(): BufferedImage type for " + file + " = " +
+                               img.getType());
+        }
+        return new AWTTextureData(glp, internalFormat, pixelFormat, mipmap, img);
+    }
+
+    public TextureData newTextureData(GLProfile glp, InputStream stream,
+                                      int internalFormat,
+                                      int pixelFormat,
+                                      boolean mipmap,
+                                      String fileSuffix) throws IOException {
+        BufferedImage img = ImageIO.read(stream);
+        if (img == null) {
+            return null;
+        }
+        if (DEBUG) {
+            System.out.println("TextureIO.newTextureData(): BufferedImage type for stream = " +
+                               img.getType());
+        }
+        return new AWTTextureData(glp, internalFormat, pixelFormat, mipmap, img);
+    }
+
+    public TextureData newTextureData(GLProfile glp, URL url,
+                                      int internalFormat,
+                                      int pixelFormat,
+                                      boolean mipmap,
+                                      String fileSuffix) throws IOException {
+        InputStream stream = url.openStream();
+        try {
+            return newTextureData(glp, stream, internalFormat, pixelFormat, mipmap, fileSuffix);
+        } finally {
+            stream.close();
+        }
+    }
+}
diff --git a/src/jogl/classes/com/jogamp/opengl/util/texture/spi/awt/IIOTextureWriter.java b/src/jogl/classes/com/jogamp/opengl/util/texture/spi/awt/IIOTextureWriter.java
new file mode 100644
index 000000000..405211204
--- /dev/null
+++ b/src/jogl/classes/com/jogamp/opengl/util/texture/spi/awt/IIOTextureWriter.java
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) 2005 Sun Microsystems, Inc. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name of Sun Microsystems, Inc. or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SUN HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ * 
+ * You acknowledge that this software is not designed or intended for use
+ * in the design, construction, operation or maintenance of any nuclear
+ * facility.
+ * 
+ * Sun gratefully acknowledges that this software was originally authored
+ * and developed by Kenneth Bradley Russell and Christopher John Kline.
+ */
+
+package com.jogamp.opengl.util.texture.spi.awt;
+
+import java.awt.Graphics;
+import java.awt.image.*;
+import java.io.*;
+import java.net.*;
+import java.nio.*;
+import javax.imageio.*;
+
+import javax.media.opengl.*;
+import com.jogamp.opengl.util.*;
+import com.jogamp.opengl.util.awt.*;
+import com.jogamp.opengl.util.texture.*;
+import com.jogamp.opengl.util.texture.spi.*;
+
+public class IIOTextureWriter implements TextureWriter {
+    public boolean write(File file,
+                         TextureData data) throws IOException {
+        int pixelFormat = data.getPixelFormat();
+        int pixelType   = data.getPixelType();
+        if ((pixelFormat == GL.GL_RGB ||
+             pixelFormat == GL.GL_RGBA) &&
+            (pixelType == GL.GL_BYTE ||
+             pixelType == GL.GL_UNSIGNED_BYTE)) {
+            // Convert TextureData to appropriate BufferedImage
+            // FIXME: almost certainly not obeying correct pixel order
+            BufferedImage image = new BufferedImage(data.getWidth(), data.getHeight(),
+                                                    (pixelFormat == GL.GL_RGB) ?
+                                                    BufferedImage.TYPE_3BYTE_BGR :
+                                                    BufferedImage.TYPE_4BYTE_ABGR);
+            byte[] imageData = ((DataBufferByte) image.getRaster().getDataBuffer()).getData();
+            ByteBuffer buf = (ByteBuffer) data.getBuffer();
+            if (buf == null) {
+                buf = (ByteBuffer) data.getMipmapData()[0];
+            }
+            buf.rewind();
+            buf.get(imageData);
+            buf.rewind();
+
+            // Swizzle image components to be correct
+            if (pixelFormat == GL.GL_RGB) {
+                for (int i = 0; i < imageData.length; i += 3) {
+                    byte red  = imageData[i + 0];
+                    byte blue = imageData[i + 2];
+                    imageData[i + 0] = blue;
+                    imageData[i + 2] = red;
+                }
+            } else {
+                for (int i = 0; i < imageData.length; i += 4) {
+                    byte red   = imageData[i + 0];
+                    byte green = imageData[i + 1];
+                    byte blue  = imageData[i + 2];
+                    byte alpha = imageData[i + 3];
+                    imageData[i + 0] = alpha;
+                    imageData[i + 1] = blue;
+                    imageData[i + 2] = green;
+                    imageData[i + 3] = red;
+                }
+            }
+
+            // Flip image vertically for the user's convenience
+            ImageUtil.flipImageVertically(image);
+
+            // Happened to notice that writing RGBA images to JPEGS is broken
+            if (TextureIO.JPG.equals(FileUtil.getFileSuffix(file)) &&
+                image.getType() == BufferedImage.TYPE_4BYTE_ABGR) {
+                BufferedImage tmpImage = new BufferedImage(image.getWidth(), image.getHeight(),
+                                                           BufferedImage.TYPE_3BYTE_BGR);
+                Graphics g = tmpImage.getGraphics();
+                g.drawImage(image, 0, 0, null);
+                g.dispose();
+                image = tmpImage;
+            }
+
+            return ImageIO.write(image, FileUtil.getFileSuffix(file), file);
+        }
+      
+        throw new IOException("ImageIO writer doesn't support this pixel format / type (only GL_RGB/A + bytes)");
+    }
+}