diff options
| author | Kenneth Russel <[email protected]> | 2006-01-13 07:29:23 +0000 |
|---|---|---|
| committer | Kenneth Russel <[email protected]> | 2006-01-13 07:29:23 +0000 |
| commit | 16e23f079b1e5fdc15b64bf1593cbda8e8dcffc0 (patch) | |
| tree | 8cf430f395f2a2691d152c9a61ca212d7a6c1f55 /src/classes/com/sun/opengl/util | |
| parent | 688ffdc8cc190c51c3e7355a4893e3e475efa29f (diff) | |
Renamed com.sun.opengl.utils to com.sun.opengl.util. Moved
TextureIO-related classes to com.sun.opengl.util.texture and
TextureProvider, TextureWriter and format-specific readers to
com.sun.opengl.util.texture.spi. Renamed BufferUtils to BufferUtil.
Added ImageUtil and FileUtil. Cleaned up javadoc. Updated demos.
Cleaned up some imports.
git-svn-id: file:///usr/local/projects/SUN/JOGL/git-svn/svn-server-sync/jogl/trunk@538 232f8b59-042b-4e1e-8c03-345bb8c30851
Diffstat (limited to 'src/classes/com/sun/opengl/util')
34 files changed, 26569 insertions, 0 deletions
diff --git a/src/classes/com/sun/opengl/util/Animator.java b/src/classes/com/sun/opengl/util/Animator.java new file mode 100755 index 000000000..417fc776d --- /dev/null +++ b/src/classes/com/sun/opengl/util/Animator.java @@ -0,0 +1,308 @@ +/* + * 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.sun.opengl.util; + +import java.awt.Component; +import java.awt.EventQueue; +import java.awt.Rectangle; +import java.util.*; +import javax.swing.*; + +import javax.media.opengl.*; + +/** <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 { + private volatile ArrayList/*<GLAutoDrawable>*/ drawables = new ArrayList(); + private Runnable runnable; + private Thread thread; + private volatile boolean shouldStop; + protected boolean ignoreExceptions; + protected boolean printExceptions; + private boolean runAsFastAsPossible; + + // 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(); + + /** Creates a new, empty Animator. */ + public Animator() { + } + + /** Creates a new Animator for a particular drawable. */ + public Animator(GLAutoDrawable drawable) { + 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() { + Iterator iter = 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(); + } + } + + class MainLoop implements Runnable { + public void run() { + try { + 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(); + } + } + } 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(); + } + thread = new Thread(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 ((Thread.currentThread() == thread) || EventQueue.isDispatchThread()) { + return; + } + while (shouldStop && thread != null) { + try { + wait(); + } catch (InterruptedException ie) { + } + } + } + + // 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(); + } + }; +} diff --git a/src/classes/com/sun/opengl/util/BitmapCharRec.java b/src/classes/com/sun/opengl/util/BitmapCharRec.java new file mode 100644 index 000000000..b20781ba1 --- /dev/null +++ b/src/classes/com/sun/opengl/util/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.sun.opengl.util; + +/* 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 { + int width; + int height; + float xorig; + float yorig; + float advance; + byte[] bitmap; + + 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/classes/com/sun/opengl/util/BitmapFontRec.java b/src/classes/com/sun/opengl/util/BitmapFontRec.java new file mode 100644 index 000000000..95b7a7346 --- /dev/null +++ b/src/classes/com/sun/opengl/util/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.sun.opengl.util; + +/* 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 { + String name; + int num_chars; + int first; + BitmapCharRec[] ch; + + 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/classes/com/sun/opengl/util/BufferUtil.java b/src/classes/com/sun/opengl/util/BufferUtil.java new file mode 100755 index 000000000..e16c5685d --- /dev/null +++ b/src/classes/com/sun/opengl/util/BufferUtil.java @@ -0,0 +1,268 @@ +/* + * 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.sun.opengl.util; + +import java.nio.*; +import java.util.*; + +/** 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; + + private BufferUtil() {} + + //---------------------------------------------------------------------- + // Allocation routines + // + + /** 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); + bb.order(ByteOrder.nativeOrder()); + return bb; + } + + /** 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(); + } + + /** 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(); + } + + /** 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(); + } + + /** 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(); + } + + //---------------------------------------------------------------------- + // 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()); + orig.mark(); + dest.put(orig); + orig.reset(); + dest.rewind(); + return dest; + } + + /** Copies the <i>remaining</i> elements (as defined by + <code>limit() - position()</code>) in the passed DoubleBuffer + into a newly-allocated direct DoubleBuffer. 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 DoubleBuffer copyDoubleBuffer(DoubleBuffer orig) { + return copyDoubleBufferAsByteBuffer(orig).asDoubleBuffer(); + } + + /** 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 LongBuffer + into a newly-allocated direct LongBuffer. 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 LongBuffer copyLongBuffer(LongBuffer orig) { + return copyLongBufferAsByteBuffer(orig).asLongBuffer(); + } + + /** 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 DoubleBuffer + 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 copyDoubleBufferAsByteBuffer(DoubleBuffer orig) { + ByteBuffer dest = newByteBuffer(orig.remaining() * SIZEOF_DOUBLE); + orig.mark(); + dest.asDoubleBuffer().put(orig); + orig.reset(); + 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 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); + orig.mark(); + dest.asFloatBuffer().put(orig); + orig.reset(); + 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); + orig.mark(); + dest.asIntBuffer().put(orig); + orig.reset(); + dest.rewind(); + return dest; + } + + /** Copies the <i>remaining</i> elements (as defined by + <code>limit() - position()</code>) in the passed LongBuffer 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 copyLongBufferAsByteBuffer(LongBuffer orig) { + ByteBuffer dest = newByteBuffer(orig.remaining() * SIZEOF_LONG); + orig.mark(); + dest.asLongBuffer().put(orig); + orig.reset(); + 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); + orig.mark(); + dest.asShortBuffer().put(orig); + orig.reset(); + dest.rewind(); + return dest; + } +} diff --git a/src/classes/com/sun/opengl/util/CoordRec.java b/src/classes/com/sun/opengl/util/CoordRec.java new file mode 100644 index 000000000..6a1cba8fb --- /dev/null +++ b/src/classes/com/sun/opengl/util/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.sun.opengl.util; + +/* 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 { + float x; + float y; + + CoordRec(float x, float y) { + this.x = x; + this.y = y; + } +} diff --git a/src/classes/com/sun/opengl/util/FPSAnimator.java b/src/classes/com/sun/opengl/util/FPSAnimator.java new file mode 100755 index 000000000..fae0ce0ae --- /dev/null +++ b/src/classes/com/sun/opengl/util/FPSAnimator.java @@ -0,0 +1,99 @@ +/* + * 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.sun.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; + + /** Creates an FPSAnimator with a given target frames-per-second value. */ + public FPSAnimator(int fps) { + this(null, fps); + } + + /** Creates an FPSAnimator with a given target frames-per-second + value and an initial drawable to animate. */ + public FPSAnimator(GLAutoDrawable drawable, int fps) { + this.fps = fps; + if (drawable != null) { + add(drawable); + } + } + + /** 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); + timer.schedule(new TimerTask() { + public void run() { + display(); + } + }, 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/classes/com/sun/opengl/util/FileUtil.java b/src/classes/com/sun/opengl/util/FileUtil.java new file mode 100755 index 000000000..6ff3e2bbd --- /dev/null +++ b/src/classes/com/sun/opengl/util/FileUtil.java @@ -0,0 +1,81 @@ +/* + * 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.sun.opengl.util; + +import java.io.*; + +/** Utilities for dealing with files. */ + +public class FileUtil { + private FileUtil() {} + + /** + * Returns the suffix of the given file name for identifying the + * file to the configured TextureProviders. + * + * @param file name of the file + */ + + public static String getFileSuffix(File file) { + return getFileSuffix(file.getName()); + } + + /** + * Returns the suffix of the given file name for identifying the + * file to the configured TextureProviders. + * + * @param filename name of the file + */ + 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/classes/com/sun/opengl/util/GLUT.java b/src/classes/com/sun/opengl/util/GLUT.java new file mode 100644 index 000000000..07264b240 --- /dev/null +++ b/src/classes/com/sun/opengl/util/GLUT.java @@ -0,0 +1,1197 @@ +/* + * 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.sun.opengl.util; + +import javax.media.opengl.*; +import javax.media.opengl.glu.*; + +/** 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 GLU glu = new GLU(); + + //---------------------------------------------------------------------- + // 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 glutWireCube(float size) { + drawBox(GLU.getCurrentGL(), size, GL.GL_LINE_LOOP); + } + + public void glutSolidCube(float size) { + drawBox(GLU.getCurrentGL(), size, GL.GL_QUADS); + } + + public void glutWireTorus(double innerRadius, double outerRadius, + int nsides, int rings) { + GL gl = GLU.getCurrentGL(); + gl.glPushAttrib(GL.GL_POLYGON_BIT); + gl.glPolygonMode(GL.GL_FRONT_AND_BACK, GL.GL_LINE); + doughnut(gl, innerRadius, outerRadius, nsides, rings); + gl.glPopAttrib(); + } + + public void glutSolidTorus(double innerRadius, double outerRadius, + int nsides, int rings) { + doughnut(GLU.getCurrentGL(), innerRadius, outerRadius, nsides, rings); + } + + public void glutWireDodecahedron() { + dodecahedron(GLU.getCurrentGL(), GL.GL_LINE_LOOP); + } + + public void glutSolidDodecahedron() { + dodecahedron(GLU.getCurrentGL(), GL.GL_TRIANGLE_FAN); + } + + public void glutWireOctahedron() { + octahedron(GLU.getCurrentGL(), GL.GL_LINE_LOOP); + } + + public void glutSolidOctahedron() { + octahedron(GLU.getCurrentGL(), GL.GL_TRIANGLES); + } + + public void glutWireIcosahedron() { + icosahedron(GLU.getCurrentGL(), GL.GL_LINE_LOOP); + } + + public void glutSolidIcosahedron() { + icosahedron(GLU.getCurrentGL(), GL.GL_TRIANGLES); + } + + public void glutWireTetrahedron() { + tetrahedron(GLU.getCurrentGL(), GL.GL_LINE_LOOP); + } + + public void glutSolidTetrahedron() { + tetrahedron(GLU.getCurrentGL(), GL.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(GLU.getCurrentGL(), 14, scale, GL.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(GLU.getCurrentGL(), 10, scale, GL.GL_LINE, cStyle); + } + + //---------------------------------------------------------------------- + // Fonts + // + + public void glutBitmapCharacter(int font, char character) { + GL gl = GLU.getCurrentGL(); + 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) { + GL gl = GLU.getCurrentGL(); + 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) { + GL gl = GLU.getCurrentGL(); + 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(GL.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) { + GL gl = GLU.getCurrentGL(); + 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(GL.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; + } + + //---------------------------------------------------------------------- + // Internals only below this point + // + + //---------------------------------------------------------------------- + // Shape implementation + // + + private GLUquadric quadObj; + private void quadObjInit(GLU glu) { + if (quadObj == null) { + quadObj = glu.gluNewQuadric(); + } + if (quadObj == null) { + throw new GLException("Out of memory"); + } + } + + private static void doughnut(GL 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(GL.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(GL 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(GL 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(GL 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(GL 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(GL 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(GL 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(GL 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(GL gl, int shadeType) { + int i; + + for (i = 19; i >= 0; i--) { + drawtriangle(gl, i, idata, index, shadeType); + } + } + + /* 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(GL 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 GL.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(GL gl, + int grid, + double scale, + int type, + boolean backCompatible) + { + // As mentioned above, GL.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(GL.GL_ENABLE_BIT | GL.GL_EVAL_BIT | GL.GL_POLYGON_BIT); + gl.glEnable(GL.GL_AUTO_NORMAL); + gl.glEnable(GL.GL_NORMALIZE); + gl.glEnable(GL.GL_MAP2_VERTEX_3); + gl.glEnable(GL.GL_MAP2_TEXTURE_COORD_2); + if (!backCompatible) { + // The time has come to have the teapot no longer be inside out + gl.glFrontFace(GL.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.glPushMatrix(); + 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(GL.GL_MAP2_TEXTURE_COORD_2, 0, 1, 2, 2, 0, 1, 4, 2, teapotTex, 0); + gl.glMap2f(GL.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(GL.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(GL.GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4, r, 0); + evaluateTeapotMesh(gl, grid, type, i, !backCompatible); + gl.glMap2f(GL.GL_MAP2_VERTEX_3, 0, 1, 3, 4, 0, 1, 12, 4, s, 0); + evaluateTeapotMesh(gl, grid, type, i, !backCompatible); + } + } + if (backCompatible) { + gl.glPopMatrix(); + } + gl.glPopAttrib(); + } + + private static void evaluateTeapotMesh(GL 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(GL.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(GL.GL_AUTO_NORMAL); + gl.glNormal3f(0, 0, partNum == 3 ? 1 : -1); + gl.glBegin(GL.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(GL.GL_AUTO_NORMAL); + } + // Draw the rest of the piece as an evaluated quad-strip + gl.glBegin(GL.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(GL 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(GL gl, + int[] swapbytes, + int[] lsbfirst, + int[] rowlength, + int[] skiprows, + int[] skippixels, + int[] alignment) { + gl.glGetIntegerv(GL.GL_UNPACK_SWAP_BYTES, swapbytes, 0); + gl.glGetIntegerv(GL.GL_UNPACK_LSB_FIRST, lsbfirst, 0); + gl.glGetIntegerv(GL.GL_UNPACK_ROW_LENGTH, rowlength, 0); + gl.glGetIntegerv(GL.GL_UNPACK_SKIP_ROWS, skiprows, 0); + gl.glGetIntegerv(GL.GL_UNPACK_SKIP_PIXELS, skippixels, 0); + gl.glGetIntegerv(GL.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(GL.GL_UNPACK_SWAP_BYTES, GL.GL_FALSE); + gl.glPixelStorei(GL.GL_UNPACK_LSB_FIRST, GL.GL_FALSE); + gl.glPixelStorei(GL.GL_UNPACK_ROW_LENGTH, 0); + gl.glPixelStorei(GL.GL_UNPACK_SKIP_ROWS, 0); + gl.glPixelStorei(GL.GL_UNPACK_SKIP_PIXELS, 0); + gl.glPixelStorei(GL.GL_UNPACK_ALIGNMENT, 1); + } + + private static void endBitmap(GL gl, + int[] swapbytes, + int[] lsbfirst, + int[] rowlength, + int[] skiprows, + int[] skippixels, + int[] alignment) { + /* Restore saved modes. */ + gl.glPixelStorei(GL.GL_UNPACK_SWAP_BYTES, swapbytes[0]); + gl.glPixelStorei(GL.GL_UNPACK_LSB_FIRST, lsbfirst[0]); + gl.glPixelStorei(GL.GL_UNPACK_ROW_LENGTH, rowlength[0]); + gl.glPixelStorei(GL.GL_UNPACK_SKIP_ROWS, skiprows[0]); + gl.glPixelStorei(GL.GL_UNPACK_SKIP_PIXELS, skippixels[0]); + gl.glPixelStorei(GL.GL_UNPACK_ALIGNMENT, alignment[0]); + } +} diff --git a/src/classes/com/sun/opengl/util/GLUTBitmap8x13.java b/src/classes/com/sun/opengl/util/GLUTBitmap8x13.java new file mode 100644 index 000000000..55a213c02 --- /dev/null +++ b/src/classes/com/sun/opengl/util/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.sun.opengl.util; + +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, +}; + + 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/classes/com/sun/opengl/util/GLUTBitmap9x15.java b/src/classes/com/sun/opengl/util/GLUTBitmap9x15.java new file mode 100644 index 000000000..d6e0de05f --- /dev/null +++ b/src/classes/com/sun/opengl/util/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.sun.opengl.util; + +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, +}; + + 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/classes/com/sun/opengl/util/GLUTBitmapHelvetica10.java b/src/classes/com/sun/opengl/util/GLUTBitmapHelvetica10.java new file mode 100644 index 000000000..f2fc8ab76 --- /dev/null +++ b/src/classes/com/sun/opengl/util/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.sun.opengl.util; + +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, +}; + + 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/classes/com/sun/opengl/util/GLUTBitmapHelvetica12.java b/src/classes/com/sun/opengl/util/GLUTBitmapHelvetica12.java new file mode 100644 index 000000000..97a3fffbf --- /dev/null +++ b/src/classes/com/sun/opengl/util/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.sun.opengl.util; + +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, +}; + + 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/classes/com/sun/opengl/util/GLUTBitmapHelvetica18.java b/src/classes/com/sun/opengl/util/GLUTBitmapHelvetica18.java new file mode 100644 index 000000000..f172de683 --- /dev/null +++ b/src/classes/com/sun/opengl/util/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.sun.opengl.util; + +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, +}; + + 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/classes/com/sun/opengl/util/GLUTBitmapTimesRoman10.java b/src/classes/com/sun/opengl/util/GLUTBitmapTimesRoman10.java new file mode 100644 index 000000000..fc06ddea3 --- /dev/null +++ b/src/classes/com/sun/opengl/util/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.sun.opengl.util; + +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, +}; + + 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/classes/com/sun/opengl/util/GLUTBitmapTimesRoman24.java b/src/classes/com/sun/opengl/util/GLUTBitmapTimesRoman24.java new file mode 100644 index 000000000..3a03e3893 --- /dev/null +++ b/src/classes/com/sun/opengl/util/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.sun.opengl.util; + +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, +}; + + 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/classes/com/sun/opengl/util/GLUTStrokeMonoRoman.java b/src/classes/com/sun/opengl/util/GLUTStrokeMonoRoman.java new file mode 100644 index 000000000..8c9910994 --- /dev/null +++ b/src/classes/com/sun/opengl/util/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.sun.opengl.util; + +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 ), +}; + +static final StrokeFontRec glutStrokeMonoRoman = new StrokeFontRec( "Roman", 128, chars, (float) 119.048, (float) -33.3333 ); +} diff --git a/src/classes/com/sun/opengl/util/GLUTStrokeRoman.java b/src/classes/com/sun/opengl/util/GLUTStrokeRoman.java new file mode 100644 index 000000000..8345c15e8 --- /dev/null +++ b/src/classes/com/sun/opengl/util/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.sun.opengl.util; + +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 ), +}; + +static final StrokeFontRec glutStrokeRoman = new StrokeFontRec( "Roman", 128, chars, (float) 119.048, (float) -33.3333 ); +} diff --git a/src/classes/com/sun/opengl/util/ImageUtil.java b/src/classes/com/sun/opengl/util/ImageUtil.java new file mode 100755 index 000000000..1ce77fecf --- /dev/null +++ b/src/classes/com/sun/opengl/util/ImageUtil.java @@ -0,0 +1,64 @@ +/* + * 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.sun.opengl.util; + +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); + } + } +} diff --git a/src/classes/com/sun/opengl/util/JOGLAppletLauncher.java b/src/classes/com/sun/opengl/util/JOGLAppletLauncher.java new file mode 100755 index 000000000..d3a460053 --- /dev/null +++ b/src/classes/com/sun/opengl/util/JOGLAppletLauncher.java @@ -0,0 +1,702 @@ +/* This java class is distributed under the BSD license. + * + * Copyright 2005 Lilian Chamontin. + * contact lilian.chamontin at f r e e . f r + */ + +/* + * Portions 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. + */ + +package com.sun.opengl.util; + +import java.awt.BorderLayout; +import java.awt.Color; +import java.awt.Graphics; +import java.awt.Label; +import java.awt.Panel; +import java.applet.Applet; +import java.applet.AppletStub; +import java.applet.AppletContext; +import java.io.*; +import java.net.*; +import java.security.cert.*; +import java.util.*; +import java.util.jar.*; +import javax.swing.*; + +import javax.media.opengl.*; + + +/** Basic JOGL installer for Applets. The key functionality this class + * supplies is the ability to deploy unsigned applets which use JOGL. + * It may also be used to deploy signed applets in which case + * multiple security dialogs will be displayed. <p> + * + * On the server side the codebase must contain jogl.jar and all of + * the jogl-natives-*.jar files from the standard JOGL distribution. + * This is the location from which the JOGL library used by the + * applet is downloaded. The codebase additionally contains the jar + * file of the user's potentially untrusted applet. The jogl.jar and + * all jogl-natives jars must be signed by the same entity, which is + * typically Sun Microsystems, Inc. + * + * Sample applet code: + * <pre> + * <applet code="com.sun.opengl.util.JOGLAppletLauncher" + * width=600 + * height=400 + * codebase="/lib" + * archive="jogl.jar,your_applet.jar"> + * <param name="subapplet.classname" VALUE="untrusted.JOGLApplet"> + * <param name="subapplet.displayname" VALUE="My JOGL Applet"> + * <param name="progressbar" value="true"> + * <param name="cache_archive" VALUE="jogl.jar,your_applet.jar"> + * <param name="cache_archive_ex" VALUE="jogl.jar;preload,your_applet.jar;preload"> + * </applet> + * </pre> + * <p> + * + * There are some limitations with this approach. It is not possible + * to specify e.g. -Dsun.java2d.noddraw=true or + * -Dsun.java2d.opengl=true for better control over the Java2D + * pipeline as it is with Java Web Start. There appear to be issues + * with multiple JOGL-based applets on the same web page, though + * multiple instances of the same applet appear to work. The latter + * may simply be a bug which needs to be fixed. <p> + * + * The JOGL natives are cached in the user's home directory (the value + * of the "user.home" system property in Java) under the directory + * .jogl_ext. The Java Plug-In is responsible for performing all other + * jar caching. If the JOGL installation is updated on the server, the + * .jogl_ext cache will automatically be updated. <p> + * + * This technique requires that JOGL has not been installed in to the + * JRE under e.g. jre/lib/ext. If problems are seen when deploying + * this applet launcher, the first question to ask the end user is + * whether jogl.jar and any associated DLLs, .so's, etc. are installed + * directly in to the JRE. The applet launcher has been tested + * primarily under Mozilla and Firefox; there may be problems when + * running under, for example, Opera. <p> + * + * @author Lilian Chamontin + * @author Kenneth Russell + */ +public class JOGLAppletLauncher extends Applet { + static { + try { + UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName()); + } catch (Exception ignore) { + } + } + + // metadata for native libraries + private static class NativeLibInfo { + private String osName; + private String osArch; + private String nativeJar; + private String nativePrefix; + private String nativeSuffix; + + public NativeLibInfo(String osName, String osArch, String nativeJar, String nativePrefix, String nativeSuffix) { + this.osName = osName; + this.osArch = osArch; + this.nativeJar = nativeJar; + this.nativePrefix = nativePrefix; + this.nativeSuffix = nativeSuffix; + } + + public boolean matchesOSAndArch(String osName, String osArch) { + if (osName.startsWith(this.osName)) { + if ((this.osArch == null) || + (osArch.startsWith(this.osArch))) { + return true; + } + } + return false; + } + + public boolean matchesNativeLib(String nativeLibraryName) { + if (nativeLibraryName.toLowerCase().endsWith(nativeSuffix)) { + return true; + } + return false; + } + + public String getNativeJarName() { + return nativeJar; + } + + public String getNativeLibName(String baseName) { + return nativePrefix + baseName + nativeSuffix; + } + + public boolean isMacOS() { + return (osName.equals("mac")); + } + } + + private static final NativeLibInfo[] allNativeLibInfo = { + new NativeLibInfo("win", null, "jogl-natives-win32.jar", "", ".dll"), + new NativeLibInfo("mac", null, "jogl-natives-macosx.jar", "lib", ".jnilib"), + new NativeLibInfo("linux", null, "jogl-natives-linux.jar", "lib", ".so"), + new NativeLibInfo("sunos", "sparc", "jogl-natives-solsparc.jar", "lib", ".so"), + new NativeLibInfo("sunos", "x86", "jogl-natives-solx86.jar", "lib", ".so") + }; + + private NativeLibInfo nativeLibInfo; + // Library names computed once the jar comes down. + // The signatures of these native libraries are checked before + // installing them. + private String[] nativeLibNames; + + /** The applet we have to start */ + private Applet subApplet; + + private String subAppletClassName; // from applet PARAM + private String subAppletDisplayName; // from applet PARAM + /** URL string to an image used while installing */ + private String subAppletImageName; // from applet PARAM + + private String installDirectory; // (defines a private directory for native libs) + + private JPanel loaderPanel = new JPanel(new BorderLayout()); + + private JProgressBar progressBar = new JProgressBar(0,100); + + private boolean isInitOk = false; + + /** false once start() has been invoked */ + private boolean firstStart = true; + + /** true if start() has passed successfully */ + private boolean joglStarted = false; + + public JOGLAppletLauncher() { + } + + /** Applet initialization */ + public void init() { + + this.subAppletClassName = getParameter("subapplet.classname"); + if (subAppletClassName == null){ + displayError("Init failed : Missing subapplet.classname argument"); + return; + } + this.subAppletDisplayName = getParameter("subapplet.displayname"); + if (subAppletDisplayName == null){ + subAppletDisplayName = "Applet"; + } + + this.subAppletImageName = getParameter("subapplet.image"); + + initLoaderLayout(); + validate(); + + String codeBase = getCodeBase().toExternalForm().substring(7); // minus http:// + + this.installDirectory = codeBase.replace(':', '_') + .replace('.', '_').replace('/', '_').replace('~','_'); // clean up the name + + String osName = System.getProperty("os.name").toLowerCase(); + String osArch = System.getProperty("os.arch").toLowerCase(); + if (checkOSAndArch(osName, osArch)) { + this.isInitOk = true; + } else { + displayError("Init failed : Unsupported os / arch ( " + osName + " / " + osArch + " )"); + } + } + + private void displayMessage(String message){ + progressBar.setString(message); + } + + private void displayError(String errorMessage){ + progressBar.setString("Error : " + errorMessage); + } + + private void initLoaderLayout(){ + setLayout(new BorderLayout()); + progressBar.setBorderPainted(true); + progressBar.setStringPainted(true); + progressBar.setString("Loading..."); + boolean includeImage = false; + ImageIcon image = null; + if (subAppletImageName != null){ + try { + image = new ImageIcon(new URL(subAppletImageName)); + includeImage = true; + } catch (MalformedURLException ex) { + ex.printStackTrace(); + // not blocking + } + } + if (includeImage){ + add(loaderPanel, BorderLayout.SOUTH); + loaderPanel.add(new JLabel(image), BorderLayout.CENTER); + loaderPanel.add(progressBar, BorderLayout.SOUTH); + } else { + add(loaderPanel, BorderLayout.SOUTH); + loaderPanel.add(progressBar, BorderLayout.CENTER); + } + } + + + /** start asynchroneous loading of libraries if needed */ + public void start(){ + if (isInitOk){ + if (firstStart) { + firstStart = false; + String userHome = System.getProperty("user.home"); + String installDirName = userHome + File.separator + ".jogl_ext" + + File.separator + installDirectory + File.separator + Version.getVersion(); + + final File installDir = new File(installDirName); + + Thread refresher = new Thread() { + public void run() { + refreshJOGL(installDir); + } + }; + refresher.setPriority(Thread.NORM_PRIORITY - 1); + refresher.start(); + } else if (joglStarted) { + // we have to start again the applet (start can be called multiple times, + // e.g once per tabbed browsing + subApplet.start(); + } + } + } + + public void stop(){ + if (subApplet != null){ + subApplet.stop(); + } + } + + public void destroy(){ + if (subApplet != null){ + subApplet.destroy(); + } + } + + + private boolean checkOSAndArch(String osName, String osArch) { + for (int i = 0; i < allNativeLibInfo.length; i++) { + NativeLibInfo info = allNativeLibInfo[i]; + if (info.matchesOSAndArch(osName, osArch)) { + nativeLibInfo = info; + return true; + } + } + return false; + } + + /** This method is executed from outside the Event Dispatch Thread, and installs + * the required native libraries in the local folder. + */ + private void refreshJOGL(final File installDir) { + try { + Class subAppletClass = Class.forName(subAppletClassName); + // this will block until the applet jar is downloaded + } catch (ClassNotFoundException cnfe){ + displayError("Start failed : class not found : " + subAppletClassName); + return; + } + + if (!installDir.exists()){ + if (!installDir.mkdirs()) { + displayError("Unable to create directories for target: " + installDir); + return; + } + } + + String nativeJarName = nativeLibInfo.getNativeJarName(); + + URL nativeLibURL; + URLConnection urlConnection; + String path = getCodeBase().toExternalForm() + nativeJarName; + try { + nativeLibURL = new URL(path); + urlConnection = nativeLibURL.openConnection(); + } catch (Exception e){ + e.printStackTrace(); + displayError("Couldn't access the native lib URL : " + path); + return; + } + + // the timestamp used to determine if we have to download the native jar again + // don't rely on the OS's timestamp to cache this + long lastModified = getTimestamp(installDir, urlConnection.getLastModified()); + if (lastModified != urlConnection.getLastModified()) { + displayMessage("Updating local version of the native libraries"); + // first download the full jar locally + File localJarFile = new File(installDir, nativeJarName); + try { + saveNativesJarLocally(localJarFile, urlConnection); + } catch (IOException ioe) { + ioe.printStackTrace(); + displayError("Unable to install the native file locally"); + return; + } + + try { + JarFile jf = new JarFile(localJarFile); + + // Iterate the entries finding all candidate libraries that need + // to have their signatures verified + if (!findNativeEntries(jf)) { + displayError("native libraries not found in jar file"); + return; + } + + byte[] buf = new byte[8192]; + + // Go back and verify the signatures + for (int i = 0; i < nativeLibNames.length; i++) { + JarEntry entry = jf.getJarEntry(nativeLibNames[i]); + if (entry == null) { + displayError("error looking up jar entry " + nativeLibNames[i]); + return; + } + if (!checkNativeCertificates(jf, entry, buf)) { + displayError("Native library " + nativeLibNames[i] + " isn't properly signed or has other errors"); + return; + } + } + + // Now install the native library files + progressBar.setValue(0); + for (int i = 0; i < nativeLibNames.length; i++) { + displayMessage("Installing native files"); + if (!installFile(installDir, jf, nativeLibNames[i], buf)) { + return; + } + int percent = (100 * (i + 1) / nativeLibNames.length); + progressBar.setValue(percent); + } + + // At this point we can delete the jar file we just downloaded + jf.close(); + localJarFile.delete(); + + // If installation succeeded, write a timestamp for all of the + // files to be checked next time + try { + File timestampFile = new File(installDir, "timestamp"); + timestampFile.delete(); + BufferedWriter writer = new BufferedWriter(new FileWriter(timestampFile)); + writer.write("" + urlConnection.getLastModified()); + writer.flush(); + writer.close(); + } catch (Exception e) { + displayError("Error writing time stamp for native libraries"); + return; + } + + } catch (Exception e) { + displayError("Error opening jar file " + localJarFile.getName() + " for reading"); + return; + } + } + + loadNativesAndStart(installDir); + } + + private long getTimestamp(File installDir, long timestamp) { + // Avoid returning valid value if timestamp file doesn't exist + try { + BufferedReader reader = new BufferedReader(new FileReader(new File(installDir, "timestamp"))); + try { + StreamTokenizer tokenizer = new StreamTokenizer(reader); + // Avoid screwing up by not being able to read full longs + tokenizer.resetSyntax(); + tokenizer.wordChars('0', '9'); + tokenizer.wordChars('-', '-'); + tokenizer.nextToken(); + String tok = tokenizer.sval; + if (tok != null) { + return Long.parseLong(tok); + } + } catch (Exception e) { + } finally { + reader.close(); + } + } catch (Exception e) { + } + return ((timestamp == 0) ? 1 : 0); + } + + private void saveNativesJarLocally(File localJarFile, + URLConnection urlConnection) throws IOException { + BufferedOutputStream out = null;; + InputStream in = null; + displayMessage("Downloading native library"); + progressBar.setValue(0); + try { + out = new BufferedOutputStream(new + FileOutputStream(localJarFile)); + int totalLength = urlConnection.getContentLength(); + in = urlConnection.getInputStream(); + byte[] buffer = new byte[1024]; + int len; + int sum = 0; + while ( (len = in.read(buffer)) > 0) { + out.write(buffer, 0, len); + sum += len; + int percent = (100 * sum / totalLength); + progressBar.setValue(percent); + } + out.close(); + in.close(); + } finally { + // close the files + if (out != null) { + try { + out.close(); + } catch (IOException ignore) { + } + } + if (in != null) { + try { + in.close(); + } catch (IOException ignore) { + } + } + } + } + + private boolean findNativeEntries(JarFile jf) { + List list = new ArrayList(); + Enumeration e = jf.entries(); + while (e.hasMoreElements()) { + JarEntry entry = (JarEntry) e.nextElement(); + if (nativeLibInfo.matchesNativeLib(entry.getName())) { + list.add(entry.getName()); + } + } + if (list.isEmpty()) { + return false; + } + nativeLibNames = (String[]) list.toArray(new String[0]); + return true; + } + + /** checking the native certificates with the jogl ones (all must match)*/ + private boolean checkNativeCertificates(JarFile jar, JarEntry entry, byte[] buf){ + // API states that we must read all of the data from the entry's + // InputStream in order to be able to get its certificates + try { + InputStream is = jar.getInputStream(entry); + int totalLength = (int) entry.getSize(); + int len; + while ((len = is.read(buf)) > 0) { + } + is.close(); + Certificate[] nativeCerts = entry.getCertificates(); + // locate the JOGL certificates + Certificate[] joglCerts = GLDrawableFactory.class.getProtectionDomain(). + getCodeSource().getCertificates(); + + if (nativeCerts == null || nativeCerts.length == 0) { + return false; + } + int checked = 0; + for (int i = 0; i < joglCerts.length; i++) { + for (int j = 0; j < nativeCerts.length; j++) { + if (nativeCerts[j].equals(joglCerts[i])){ + checked++; + break; + } + } + } + return (checked == joglCerts.length); + } catch (Exception e) { + return false; + } + } + + private boolean installFile(File installDir, + JarFile jar, + String fileName, + byte[] buf) { + try { + JarEntry entry = jar.getJarEntry(fileName); + if (entry == null) { + displayError("Error finding native library " + fileName); + return false; + } + InputStream is = jar.getInputStream(entry); + int totalLength = (int) entry.getSize(); + BufferedOutputStream out = null; + File outputFile = new File(installDir, fileName); + try { + out = new BufferedOutputStream(new FileOutputStream(outputFile)); + } catch (Exception e) { + displayError("Error opening file " + fileName + " for writing"); + return false; + } + int len; + try { + while ( (len = is.read(buf)) > 0) { + out.write(buf, 0, len); + } + } catch (IOException ioe) { + displayError("Error writing file " + fileName + " to disk"); + ioe.printStackTrace(); + outputFile.delete(); + return false; + } + out.flush(); + out.close(); + return true; + } catch (Exception e2) { + e2.printStackTrace(); + displayError("Error writing file " + fileName + " to disk"); + return false; + } + } + + /** last step before launch : System.load() the natives and init()/start() the child applet */ + private void loadNativesAndStart(final File nativeLibDir) { + // back to the EDT + SwingUtilities.invokeLater(new Runnable() { + public void run() { + displayMessage("Loading native libraries"); + + // Load core JOGL native library + loadLibrary(nativeLibDir, "jogl"); + + if (!nativeLibInfo.isMacOS()) { // borrowed from NativeLibLoader + // Must pre-load JAWT on all non-Mac platforms to + // ensure references from jogl_awt shared object + // will succeed since JAWT shared object isn't in + // default library path + try { + System.loadLibrary("jawt"); + } catch (UnsatisfiedLinkError ex) { + // Accessibility technologies load JAWT themselves; safe to continue + // as long as JAWT is loaded by any loader + if (ex.getMessage().indexOf("already loaded") == -1) { + displayError("Unable to load JAWT"); + throw ex; + } + } + } + + // Load AWT-specific native code + loadLibrary(nativeLibDir, "jogl_awt"); + + // disable JOGL loading from elsewhere + com.sun.opengl.impl.NativeLibLoader.disableLoading(); + + displayMessage("Starting applet " + subAppletDisplayName); + + // start the subapplet + startSubApplet(); + } + }); + } + + private void loadLibrary(File installDir, String libName) { + String nativeLibName = nativeLibInfo.getNativeLibName(libName); + try { + System.load(new File(installDir, nativeLibName).getPath()); + } catch (UnsatisfiedLinkError ex) { + // should be safe to continue as long as the native is loaded by any loader + if (ex.getMessage().indexOf("already loaded") == -1) { + displayError("Unable to load " + nativeLibName); + throw ex; + } + } + } + + /** The true start of the sub applet (invoked in the EDT) */ + private void startSubApplet(){ + try { + subApplet = (Applet)Class.forName(subAppletClassName).newInstance(); + subApplet.setStub(new AppletStubProxy()); + } catch (ClassNotFoundException cnfe) { + cnfe.printStackTrace(); + displayError("Class not found (" + subAppletClassName + ")"); + return; + } catch (Exception ex) { + ex.printStackTrace(); + displayError("Unable to start " + subAppletDisplayName); + return; + } + + add(subApplet, BorderLayout.CENTER); + + try { + subApplet.init(); + remove(loaderPanel); + validate(); + subApplet.start(); + joglStarted = true; + } catch (Exception ex){ + ex.printStackTrace(); + } + + } + + /** a proxy to allow the subApplet to work like a real applet */ + class AppletStubProxy implements AppletStub { + public boolean isActive() { + return JOGLAppletLauncher.this.isActive(); + } + + public URL getDocumentBase() { + return JOGLAppletLauncher.this.getDocumentBase(); + } + + public URL getCodeBase() { + return JOGLAppletLauncher.this.getCodeBase(); + } + + public String getParameter(String name) { + return JOGLAppletLauncher.this.getParameter(name); + } + + public AppletContext getAppletContext() { + return JOGLAppletLauncher.this.getAppletContext(); + } + + public void appletResize(int width, int height) { + JOGLAppletLauncher.this.resize(width, height); + } + } +} + diff --git a/src/classes/com/sun/opengl/util/Screenshot.java b/src/classes/com/sun/opengl/util/Screenshot.java new file mode 100755 index 000000000..dfbc44b02 --- /dev/null +++ b/src/classes/com/sun/opengl/util/Screenshot.java @@ -0,0 +1,210 @@ +/* + * 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.sun.opengl.util; + +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.*; + +/** Utilities for taking screenshots of OpenGL applications. */ + +public class Screenshot { + private static final int TARGA_HEADER_SIZE = 18; + + 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. 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 + * + * @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 { + RandomAccessFile out = new RandomAccessFile(file, "rw"); + FileChannel ch = out.getChannel(); + int fileLength = TARGA_HEADER_SIZE + width * height * 3; + 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) 24); // pixel size + + // go to image data position + image.position(TARGA_HEADER_SIZE); + // jogl needs a sliced buffer + ByteBuffer bgr = image.slice(); + + GL gl = GLU.getCurrentGL(); + + // Set up pixel storage modes + PixelStorageModes psm = new PixelStorageModes(); + psm.save(gl); + + // read the BGR values into the image buffer + gl.glReadPixels(0, 0, width, height, GL.GL_BGR, + GL.GL_UNSIGNED_BYTE, bgr); + + // Restore pixel storage modes + psm.restore(gl); + + // close the file channel + ch.close(); + } + + /** + * Takes a screenshot of the current OpenGL drawable to a + * BufferedImage. Requires the OpenGL context for the desired + * drawable to be current. 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 + * + * @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 { + // Allocate necessary storage + BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_3BYTE_BGR); + + GL gl = GLU.getCurrentGL(); + + // Set up pixel storage modes + PixelStorageModes psm = new PixelStorageModes(); + psm.save(gl); + + // read the BGR values into the image + gl.glReadPixels(0, 0, width, height, GL.GL_BGR, + GL.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. 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. + * + * @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 { + BufferedImage image = readToBufferedImage(width, height); + if (!ImageIO.write(image, FileUtil.getFileSuffix(file), file)) { + throw new IOException("Unsupported file format " + + FileUtil.getFileSuffix(file)); + } + } + + private static int glGetInteger(GL gl, int pname, int[] tmp) { + gl.glGetIntegerv(pname, tmp, 0); + return tmp[0]; + } + + static class PixelStorageModes { + int packAlignment; + int packRowLength; + int packSkipRows; + int packSkipPixels; + int packSwapBytes; + int[] tmp = new int[1]; + + void save(GL gl) { + packAlignment = glGetInteger(gl, GL.GL_PACK_ALIGNMENT, tmp); + packRowLength = glGetInteger(gl, GL.GL_PACK_ROW_LENGTH, tmp); + packSkipRows = glGetInteger(gl, GL.GL_PACK_SKIP_ROWS, tmp); + packSkipPixels = glGetInteger(gl, GL.GL_PACK_SKIP_PIXELS, tmp); + packSwapBytes = glGetInteger(gl, GL.GL_PACK_SWAP_BYTES, tmp); + + gl.glPixelStorei(GL.GL_PACK_ALIGNMENT, 1); + gl.glPixelStorei(GL.GL_PACK_ROW_LENGTH, 0); + gl.glPixelStorei(GL.GL_PACK_SKIP_ROWS, 0); + gl.glPixelStorei(GL.GL_PACK_SKIP_PIXELS, 0); + gl.glPixelStorei(GL.GL_PACK_SWAP_BYTES, 0); + } + + void restore(GL gl) { + gl.glPixelStorei(GL.GL_PACK_ALIGNMENT, packAlignment); + gl.glPixelStorei(GL.GL_PACK_ROW_LENGTH, packRowLength); + gl.glPixelStorei(GL.GL_PACK_SKIP_ROWS, packSkipRows); + gl.glPixelStorei(GL.GL_PACK_SKIP_PIXELS, packSkipPixels); + gl.glPixelStorei(GL.GL_PACK_SWAP_BYTES, packSwapBytes); + } + } +} diff --git a/src/classes/com/sun/opengl/util/StrokeCharRec.java b/src/classes/com/sun/opengl/util/StrokeCharRec.java new file mode 100644 index 000000000..5c6f14b6c --- /dev/null +++ b/src/classes/com/sun/opengl/util/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.sun.opengl.util; + +/* 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 { + int num_strokes; + StrokeRec[] stroke; + float center; + float right; + + 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/classes/com/sun/opengl/util/StrokeFontRec.java b/src/classes/com/sun/opengl/util/StrokeFontRec.java new file mode 100644 index 000000000..825bed7c5 --- /dev/null +++ b/src/classes/com/sun/opengl/util/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.sun.opengl.util; + +/* 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 { + String name; + int num_chars; + StrokeCharRec[] ch; + float top; + float bottom; + + 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/classes/com/sun/opengl/util/StrokeRec.java b/src/classes/com/sun/opengl/util/StrokeRec.java new file mode 100644 index 000000000..ed5bec48f --- /dev/null +++ b/src/classes/com/sun/opengl/util/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.sun.opengl.util; + +/* 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 { + int num_coords; + CoordRec[] coord; + + StrokeRec(int num_coords, + CoordRec[] coord) { + this.num_coords = num_coords; + this.coord = coord; + } +} diff --git a/src/classes/com/sun/opengl/util/Version.java b/src/classes/com/sun/opengl/util/Version.java new file mode 100644 index 000000000..8f0acef0e --- /dev/null +++ b/src/classes/com/sun/opengl/util/Version.java @@ -0,0 +1,104 @@ +/* +* Copyright (c) 2004 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.sun.opengl.util; + +/** + * The version and build number of this implementation. + * Version numbers for a release are of the form: w.x.y[-a]-z, where: + * <ul> + * <li> + * w - the major version number of the release. This number should + * start at 1. Typically, a bump in the major version number + * signifies that the release breaks backwards compatibility + * with some older release. + * </li> + * <li> + * x - minor version number. This number starts at 0. A bump in + * the minor version number signifies a release that has significant + * new functionality. + * </li> + * <li> + * y - minor-minor version number number. This number starts at 0. A + * bump in the minor-minor version number signifies that new bug + * fixes have been added to the build. + * </li> + * <li> + * a - an optional build designator followed by a digit. Valid build + * designators are: + * <ul> + * <li>alpha</li> + * <li>beta</li> + * </ul> + * </li> + * <li> + * z - build number. This is used to specify the build number of the + * release. This is usually only important to people that use + * the daily build of a project. The format is the lower-case + * letter 'b' followed by a two digit number. + * </li> + * </ul> + * + * For example, the following are all valid version strings: + * <ul> + * <li>1.1.2-b02</li> + * <li>1.3.5-alpha1-b19</li> + * <li>4.7.1-beta3-b20</li> + * </ul> + * + */ +public final class Version { + + /** + * Private constructor - no need for user to create + * an instance of this class. + */ + private Version() { + } + + /** + * Version string of this build. + */ + private static final String version = "jsr231-1.0-beta2-b01"; + + /** + * Returns the version string and build number of + * this implementation. See the class description + * for the version string format. + * + * @return The version string of this implementation. + */ + public static String getVersion() { + return version; + } +} diff --git a/src/classes/com/sun/opengl/util/texture/Texture.java b/src/classes/com/sun/opengl/util/texture/Texture.java new file mode 100755 index 000000000..9987551e2 --- /dev/null +++ b/src/classes/com/sun/opengl/util/texture/Texture.java @@ -0,0 +1,536 @@ +/* + * 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.sun.opengl.util.texture; + +import java.nio.*; + +import javax.media.opengl.*; +import javax.media.opengl.glu.*; +import com.sun.opengl.impl.*; + +/** + * 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. + * + * <br> REMIND: document GL_TEXTURE_2D/GL_TEXTURE_RECTANGLE_ARB issues... + * <br> REMIND: translucent images will have premultiplied comps by default... + * + * @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; + /** Indicates whether the TextureData requires a vertical flip of + the texture coords. */ + private boolean mustFlipVertically; + + /** The texture coordinates corresponding to the entire image. */ + private TextureCoords coords; + + private static final boolean DEBUG = Debug.debug("Texture"); + + // For now make Texture constructor package-private to limit the + // number of public APIs we commit to + Texture(TextureData data) throws GLException { + GL gl = GLU.getCurrentGL(); + texID = createTextureID(gl); + + updateImage(data); + } + + // Constructor for use when creating e.g. cube maps, where there is + // no initial texture data + Texture(int target) throws GLException { + GL gl = GLU.getCurrentGL(); + texID = createTextureID(gl); + this.target = target; + } + + /** + * Enables this texture's target (e.g., GL_TEXTURE_2D) in the + * current GL context's state. + * + * @throws GLException if no OpenGL context was current or if any + * OpenGL-related errors occurred + */ + public void enable() throws GLException { + GLU.getCurrentGL().glEnable(target); + } + + /** + * Disables this texture's target (e.g., GL_TEXTURE_2D) in the + * current GL context's state. + * + * @throws GLException if no OpenGL context was current or if any + * OpenGL-related errors occurred + */ + public void disable() throws GLException { + GLU.getCurrentGL().glDisable(target); + } + + /** + * Binds this texture to the current GL context. + * + * @throws GLException if no OpenGL context was current or if any + * OpenGL-related errors occurred + */ + public void bind() throws GLException { + GLU.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 + */ + public void dispose() throws GLException { + GLU.getCurrentGL().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.GL#GL_TEXTURE_RECTANGLE_ARB + */ + public int getTarget() { + return target; + } + + /** + * Returns the width of the texture. 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 texture. 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. + * + * @return the width of the image + */ + public int getImageWidth() { + return imgWidth; + } + + /** + * Returns the height of the image contained within this texture. + * + * @return the height of the image + */ + public int getImageHeight() { + return imgHeight; + } + + /** + * 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 == GL.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) { + return new TextureCoords(tx1, 1.0f - ty1, tx2, 1.0f - 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} and {@link + * #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 = GLU.getCurrentGL(); + + imgWidth = data.getWidth(); + imgHeight = data.getHeight(); + mustFlipVertically = data.getMustFlipVertically(); + + int newTarget = 0; + + if (data.getMipmap()) { + // 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; + newTarget = GL.GL_TEXTURE_2D; + } else if ((isPowerOfTwo(imgWidth) && isPowerOfTwo(imgHeight)) || + gl.isExtensionAvailable("GL_ARB_texture_non_power_of_two")) { + if (DEBUG) { + if (isPowerOfTwo(imgWidth) && isPowerOfTwo(imgHeight)) { + System.err.println("Power-of-two texture"); + } else { + System.err.println("Using GL_ARB_texture_non_power_of_two"); + } + } + + texWidth = imgWidth; + texHeight = imgHeight; + newTarget = GL.GL_TEXTURE_2D; + } else if (gl.isExtensionAvailable("GL_ARB_texture_rectangle")) { + if (DEBUG) { + System.err.println("Using GL_ARB_texture_rectangle"); + } + + texWidth = imgWidth; + texHeight = imgHeight; + newTarget = GL.GL_TEXTURE_RECTANGLE_ARB; + } else { + 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); + newTarget = GL.GL_TEXTURE_2D; + } + + setImageSize(imgWidth, imgHeight); + + if (target != 0) { + // Allow user to override auto detection and skip bind step (for + // cubemap construction) + newTarget = target; + if (this.target == 0) { + throw new GLException("Override of target failed; no target specified yet"); + } + gl.glBindTexture(this.target, texID); + } else { + gl.glBindTexture(newTarget, texID); + } + + // REMIND: let the user specify these, optionally + int minFilter = (data.getMipmap() ? GL.GL_LINEAR_MIPMAP_LINEAR : GL.GL_LINEAR); + int magFilter = GL.GL_LINEAR; + int wrapMode = GL.GL_CLAMP_TO_EDGE; + + // REMIND: figure out what to do for GL_TEXTURE_RECTANGLE_ARB + if (newTarget != GL.GL_TEXTURE_RECTANGLE_ARB) { + gl.glTexParameteri(newTarget, GL.GL_TEXTURE_MIN_FILTER, minFilter); + gl.glTexParameteri(newTarget, GL.GL_TEXTURE_MAG_FILTER, magFilter); + gl.glTexParameteri(newTarget, GL.GL_TEXTURE_WRAP_S, wrapMode); + gl.glTexParameteri(newTarget, GL.GL_TEXTURE_WRAP_T, wrapMode); + if (newTarget == GL.GL_TEXTURE_CUBE_MAP) { + gl.glTexParameteri(newTarget, GL.GL_TEXTURE_WRAP_R, wrapMode); + } + } + + if (data.getMipmap()) { + GLU glu = new GLU(); + glu.gluBuild2DMipmaps(newTarget, data.getInternalFormat(), + data.getWidth(), data.getHeight(), + data.getPixelFormat(), data.getPixelType(), data.getBuffer()); + } else { + gl.glTexImage2D(newTarget, 0, data.getInternalFormat(), + texWidth, texHeight, data.getBorder(), + data.getPixelFormat(), data.getPixelType(), null); + Buffer[] mipmapData = data.getMipmapData(); + if (mipmapData != null) { + for (int i = 0; i < mipmapData.length; i++) { + updateSubImageImpl(data, newTarget, i, 0, 0); + } + } else { + updateSubImageImpl(data, newTarget, 0, 0, 0); + } + } + + // 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 == GL.GL_TEXTURE_RECTANGLE_ARB)) { + this.target = newTarget; + } + } + + /** + * Updates a subregion of the content area of this texture using the + * data in the given image. 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 { + updateSubImageImpl(data, target, mipmapLevel, x, y); + } + + /** + * 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. 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 = GLU.getCurrentGL(); + gl.glTexParameteri(target, parameterName, value); + } + + /** + * 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() { + return texID; + } + + //---------------------------------------------------------------------- + // 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) { + imgWidth = width; + imgHeight = height; + if (target == GL.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 x, int y) throws GLException { + GL gl = GLU.getCurrentGL(); + gl.glBindTexture(newTarget, texID); + int width = data.getWidth(); + int height = data.getHeight(); + Buffer buffer = data.getBuffer(); + if (data.getMipmapData() != null) { + // Compute the width and height at the specified mipmap level + for (int i = 0; i < mipmapLevel; i++) { + width /= 2; + height /= 2; + } + buffer = data.getMipmapData()[mipmapLevel]; + } + + 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: + // FIXME: should test availability of more texture + // compression extensions here + break; + } + + gl.glCompressedTexSubImage2D(newTarget, mipmapLevel, + x, y, width, height, + data.getInternalFormat(), + buffer.remaining(), buffer); + } else { + int[] align = new int[1]; + gl.glGetIntegerv(GL.GL_UNPACK_ALIGNMENT, align, 0); // save alignment + gl.glPixelStorei(GL.GL_UNPACK_ALIGNMENT, data.getAlignment()); + + gl.glTexSubImage2D(newTarget, mipmapLevel, + x, y, width, height, + data.getPixelFormat(), data.getPixelType(), + buffer); + gl.glPixelStorei(GL.GL_UNPACK_ALIGNMENT, align[0]); // restore align + } + } + + /** + * Creates a new texture ID. + * + * @param gl the GL object associated with the current OpenGL context + * @return a new texture ID + */ + private static int createTextureID(GL gl) { + int[] tmp = new int[1]; + gl.glGenTextures(1, tmp, 0); + return tmp[0]; + } +} diff --git a/src/classes/com/sun/opengl/util/texture/TextureCoords.java b/src/classes/com/sun/opengl/util/texture/TextureCoords.java new file mode 100755 index 000000000..dca1d1e01 --- /dev/null +++ b/src/classes/com/sun/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.sun.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/classes/com/sun/opengl/util/texture/TextureData.java b/src/classes/com/sun/opengl/util/texture/TextureData.java new file mode 100755 index 000000000..83a1c983e --- /dev/null +++ b/src/classes/com/sun/opengl/util/texture/TextureData.java @@ -0,0 +1,512 @@ +/* + * 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.sun.opengl.util.texture; + +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.sun.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 + */ + +public class TextureData { + private int width; + private int height; + private int border; + private int pixelFormat; + private int pixelType; + private int internalFormat; // perhaps inferred from pixelFormat? + private boolean mipmap; // indicates whether mipmaps should be generated + // (ignored if mipmaps are supplied from the file) + private boolean dataIsCompressed; + private boolean mustFlipVertically; // Must flip texture coordinates + // vertically to get OpenGL output + // to look correct + private Buffer buffer; // the actual data... + private Buffer[] mipmapData; // ...or a series of mipmaps + private Flusher flusher; + private int alignment; // 1, 2, or 4 bytes + + 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 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 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(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.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? + } + + /** + * 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 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(int internalFormat, + int width, + int height, + int border, + int pixelFormat, + int pixelType, + boolean dataIsCompressed, + boolean mustFlipVertically, + Buffer[] mipmapData, + Flusher flusher) throws IllegalArgumentException { + 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? + } + + /** + * Constructs a new TextureData object with the specified parameters + * and data contained in the given BufferedImage. + * + * @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 TextureData(int internalFormat, + int pixelFormat, + boolean mipmap, + BufferedImage image) { + if (internalFormat == 0) { + this.internalFormat = image.getColorModel().hasAlpha() ? GL.GL_RGBA : GL.GL_RGB; + } else { + this.internalFormat = internalFormat; + } + createFromImage(image); + this.mipmap = mipmap; + } + + /** 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; } + + /** 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; } + /** Sets the required byte alignment for the texture data. */ + public void setAlignment(int alignment) { this.alignment = alignment; } + + /** Flushes resources associated with this TextureData by calling + Flusher.flush(). */ + public void flush() { + if (flusher != null) { + flusher.flush(); + flusher = null; + } + } + + /** 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(); + } + + //---------------------------------------------------------------------- + // Internals only below this point + // + + private void createNIOBufferFromImage(BufferedImage image, boolean flipVertically) { + if (flipVertically) { + ImageUtil.flipImageVertically(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. + // + + // Allow previously-selected pixelType (if any) to override that + // we can infer from the DataBuffer + DataBuffer data = image.getRaster().getDataBuffer(); + if (data instanceof DataBufferByte) { + if (pixelType == 0) pixelType = GL.GL_UNSIGNED_BYTE; + buffer = ByteBuffer.wrap(((DataBufferByte) data).getData()); + } 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; + buffer = FloatBuffer.wrap(((DataBufferFloat) data).getData()); + } else if (data instanceof DataBufferInt) { + // FIXME: should we support signed ints? + if (pixelType == 0) pixelType = GL.GL_UNSIGNED_INT; + buffer = IntBuffer.wrap(((DataBufferInt) data).getData()); + } else if (data instanceof DataBufferShort) { + if (pixelType == 0) pixelType = GL.GL_SHORT; + buffer = ShortBuffer.wrap(((DataBufferShort) data).getData()); + } else if (data instanceof DataBufferUShort) { + if (pixelType == 0) pixelType = GL.GL_UNSIGNED_SHORT; + buffer = ShortBuffer.wrap(((DataBufferShort) data).getData()); + } else { + throw new RuntimeException("Unexpected DataBuffer type?"); + } + } + + private void createFromImage(BufferedImage image) { + pixelType = 0; // Determine from image + + width = image.getWidth(); + height = image.getHeight(); + + switch (image.getType()) { + case BufferedImage.TYPE_INT_RGB: + pixelFormat = GL.GL_BGRA; + pixelType = GL.GL_UNSIGNED_INT_8_8_8_8_REV; + alignment = 4; + break; + case BufferedImage.TYPE_INT_ARGB_PRE: + pixelFormat = GL.GL_BGRA; + pixelType = GL.GL_UNSIGNED_INT_8_8_8_8_REV; + alignment = 4; + break; + case BufferedImage.TYPE_INT_BGR: + pixelFormat = GL.GL_RGBA; + pixelType = GL.GL_UNSIGNED_INT_8_8_8_8_REV; + alignment = 4; + break; + case BufferedImage.TYPE_3BYTE_BGR: + { + Raster raster = image.getRaster(); + ComponentSampleModel csm = + (ComponentSampleModel)raster.getSampleModel(); + // we can pass the image data directly to OpenGL only if + // the raster is tightly packed (i.e. there is no extra + // space at the end of each scanline) + if ((csm.getScanlineStride() / 3) == csm.getWidth()) { + pixelFormat = GL.GL_BGR; + pixelType = GL.GL_UNSIGNED_BYTE; + alignment = 1; + } else { + createFromCustom(image); + return; + } + } + break; + case BufferedImage.TYPE_4BYTE_ABGR_PRE: + { + Raster raster = image.getRaster(); + ComponentSampleModel csm = + (ComponentSampleModel)raster.getSampleModel(); + // we can pass the image data directly to OpenGL only if + // the raster is tightly packed (i.e. there is no extra + // space at the end of each scanline) and only if the + // GL_EXT_abgr extension is present + + // FIXME: with the way this is currently organized we can't + // probe for the existence of the GL_EXT_abgr extension + // here; disable this code path for now + if (((csm.getScanlineStride() / 4) == csm.getWidth()) && + /* gl.isExtensionAvailable("GL_EXT_abgr") */ false) + { + pixelFormat = GL.GL_ABGR_EXT; + pixelType = GL.GL_UNSIGNED_BYTE; + alignment = 4; + } else { + createFromCustom(image); + return; + } + } + break; + case BufferedImage.TYPE_USHORT_565_RGB: + pixelFormat = GL.GL_RGB; + pixelType = GL.GL_UNSIGNED_SHORT_5_6_5; + alignment = 2; + break; + case BufferedImage.TYPE_USHORT_555_RGB: + pixelFormat = GL.GL_BGRA; + pixelType = GL.GL_UNSIGNED_SHORT_1_5_5_5_REV; + alignment = 2; + break; + case BufferedImage.TYPE_BYTE_GRAY: + pixelFormat = GL.GL_LUMINANCE; + pixelType = GL.GL_UNSIGNED_BYTE; + alignment = 1; + break; + case BufferedImage.TYPE_USHORT_GRAY: + pixelFormat = GL.GL_LUMINANCE; + pixelType = GL.GL_UNSIGNED_SHORT; + alignment = 2; + break; + 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; + alignment = 1; + } else if (cm.equals(rgbaColorModel)) { + pixelFormat = GL.GL_RGBA; + pixelType = GL.GL_UNSIGNED_BYTE; + alignment = 4; + } else { + createFromCustom(image); + return; + } + break; + } + + createNIOBufferFromImage(image, true); + } + + 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(); + 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); + // Flip image vertically as long as we're at it + g.drawImage(image, + 0, height, width, 0, + 0, 0, width, height, + null); + g.dispose(); + + // Wrap the buffer from the temporary image + createNIOBufferFromImage(texImage, false); + pixelFormat = hasAlpha ? GL.GL_RGBA : GL.GL_RGB; + alignment = 1; // FIXME: do we need better? + } +} diff --git a/src/classes/com/sun/opengl/util/texture/TextureIO.java b/src/classes/com/sun/opengl/util/texture/TextureIO.java new file mode 100755 index 000000000..c1e5bcf8b --- /dev/null +++ b/src/classes/com/sun/opengl/util/texture/TextureIO.java @@ -0,0 +1,1272 @@ +/* + * 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.sun.opengl.util.texture; + +import java.awt.Graphics; +import java.awt.image.*; +import java.io.*; +import java.net.*; +import java.nio.*; +import java.util.*; +import javax.imageio.*; + +import javax.media.opengl.*; +import javax.media.opengl.glu.*; +import com.sun.opengl.util.*; +import com.sun.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"; + + //---------------------------------------------------------------------- + // 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 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(File file, + boolean mipmap, + String fileSuffix) throws IOException { + return newTextureDataImpl(file, 0, 0, mipmap, fileSuffix); + } + + /** + * Creates a TextureData from the given stream. Does no OpenGL work. + * + * @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(InputStream stream, + boolean mipmap, + String fileSuffix) throws IOException { + return newTextureDataImpl(stream, 0, 0, mipmap, fileSuffix); + } + + /** + * Creates a TextureData from the given URL. Does no OpenGL work. + * + * @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(URL url, + boolean mipmap, + String fileSuffix) throws IOException { + return newTextureDataImpl(url, 0, 0, mipmap, fileSuffix); + } + + /** + * Creates a TextureData from the given BufferedImage. Does no + * OpenGL work. + * + * @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 + */ + public static TextureData newTextureData(BufferedImage image, + boolean mipmap) { + return newTextureDataImpl(image, 0, 0, mipmap); + } + + //---------------------------------------------------------------------- + // 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 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(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"); + } + + return newTextureDataImpl(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 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(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(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 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(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"); + } + + return newTextureDataImpl(url, internalFormat, pixelFormat, mipmap, fileSuffix); + } + + /** + * 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 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(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(image, internalFormat, pixelFormat, mipmap); + } + + //---------------------------------------------------------------------- + // methods that *do* require a current context + // + + /** + * Creates an OpenGL texture object from the specified TextureData + * using the current OpenGL context. Does not automatically generate + * mipmaps for the resulting texture. + * + * @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. Does not automatically generate + * mipmaps for the resulting texture. + * + * @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 { + TextureData data = newTextureData(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. Does not automatically generate + * mipmaps for the resulting texture. + * + * @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 { + TextureData data = newTextureData(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. Does not automatically generate mipmaps + * for the resulting texture. + * + * @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 { + TextureData data = newTextureData(url, mipmap, fileSuffix); + Texture texture = newTexture(data); + data.flush(); + return texture; + } + + /** + * Creates an OpenGL texture object from the specified BufferedImage + * using the current OpenGL context. + * + * @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(BufferedImage image, boolean mipmap) throws GLException { + TextureData data = newTextureData(image, mipmap); + 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. + * + * @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); + } + + /** + * 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 = GLU.getCurrentGL(); + + texture.bind(); + int internalFormat = glGetTexLevelParameteri(GL.GL_TEXTURE_2D, 0, GL.GL_TEXTURE_INTERNAL_FORMAT); + int width = glGetTexLevelParameteri(GL.GL_TEXTURE_2D, 0, GL.GL_TEXTURE_WIDTH); + int height = glGetTexLevelParameteri(GL.GL_TEXTURE_2D, 0, GL.GL_TEXTURE_HEIGHT); + int border = glGetTexLevelParameteri(GL.GL_TEXTURE_2D, 0, GL.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_TEXTURE_2D, 0, GL.GL_TEXTURE_COMPRESSED_IMAGE_SIZE); + ByteBuffer res = ByteBuffer.allocate(size); + gl.glGetCompressedTexImage(GL.GL_TEXTURE_2D, 0, res); + data = new TextureData(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 GL.GL_BGR: + case GL.GL_RGB8: + bytesPerPixel = 3; + fetchedFormat = GL.GL_RGB; + break; + case GL.GL_RGBA: + case GL.GL_BGRA: + case GL.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(GL.GL_PACK_ROW_LENGTH); + int packSkipRows = glGetInteger(GL.GL_PACK_SKIP_ROWS); + int packSkipPixels = glGetInteger(GL.GL_PACK_SKIP_PIXELS); + int packSwapBytes = glGetInteger(GL.GL_PACK_SWAP_BYTES); + + gl.glPixelStorei(GL.GL_PACK_ALIGNMENT, 1); + gl.glPixelStorei(GL.GL_PACK_ROW_LENGTH, 0); + gl.glPixelStorei(GL.GL_PACK_SKIP_ROWS, 0); + gl.glPixelStorei(GL.GL_PACK_SKIP_PIXELS, 0); + gl.glPixelStorei(GL.GL_PACK_SWAP_BYTES, 0); + + ByteBuffer res = ByteBuffer.allocate((width + (2 * border)) * + (height + (2 * border)) * + bytesPerPixel); + System.err.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(GL.GL_PACK_ROW_LENGTH, packRowLength); + gl.glPixelStorei(GL.GL_PACK_SKIP_ROWS, packSkipRows); + gl.glPixelStorei(GL.GL_PACK_SKIP_PIXELS, packSkipPixels); + gl.glPixelStorei(GL.GL_PACK_SWAP_BYTES, packSwapBytes); + + data = new TextureData(internalFormat, width, height, border, fetchedFormat, GL.GL_UNSIGNED_BYTE, + false, false, false, res, null); + + System.out.println("data.getPixelFormat() = " + + ((data.getPixelFormat() == GL.GL_RGB) ? "GL_RGB" : "GL_RGBA")); + } + + 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"); + } + + //---------------------------------------------------------------------- + // 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); + } + + //---------------------------------------------------------------------- + // 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 + addTextureProvider(new IIOTextureProvider()); + + // Other special-case providers + addTextureProvider(new DDSTextureProvider()); + addTextureProvider(new SGITextureProvider()); + addTextureProvider(new TGATextureProvider()); + + // ImageIO writer, the fall-back, must be the first one added + textureWriters.add(new IIOTextureWriter()); + + // Other special-case writers + addTextureWriter(new DDSTextureWriter()); + addTextureWriter(new SGITextureWriter()); + addTextureWriter(new TGATextureWriter()); + } + + // Implementation methods + private static TextureData newTextureDataImpl(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(file, + internalFormat, + pixelFormat, + mipmap, + fileSuffix); + if (data != null) { + return data; + } + } + + throw new IOException("No suitable reader for given file"); + } + + private static TextureData newTextureDataImpl(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(stream, + internalFormat, + pixelFormat, + mipmap, + fileSuffix); + if (data != null) { + return data; + } + } + + throw new IOException("No suitable reader for given stream"); + } + + private static TextureData newTextureDataImpl(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(url, + internalFormat, + pixelFormat, + mipmap, + fileSuffix); + if (data != null) { + return data; + } + } + + throw new IOException("No suitable reader for given URL"); + } + + private static TextureData newTextureDataImpl(BufferedImage image, + int internalFormat, + int pixelFormat, + boolean mipmap) { + return new TextureData(internalFormat, pixelFormat, mipmap, image); + } + + //---------------------------------------------------------------------- + // Base provider - used last + static class IIOTextureProvider implements TextureProvider { + public TextureData newTextureData(File file, + int internalFormat, + int pixelFormat, + boolean mipmap, + String fileSuffix) throws IOException { + BufferedImage img = ImageIO.read(file); + if (img == null) { + return null; + } + return new TextureData(internalFormat, pixelFormat, mipmap, img); + } + + public TextureData newTextureData(InputStream stream, + int internalFormat, + int pixelFormat, + boolean mipmap, + String fileSuffix) throws IOException { + BufferedImage img = ImageIO.read(stream); + if (img == null) { + return null; + } + return new TextureData(internalFormat, pixelFormat, mipmap, img); + } + + public TextureData newTextureData(URL url, + int internalFormat, + int pixelFormat, + boolean mipmap, + String fileSuffix) throws IOException { + InputStream stream = url.openStream(); + try { + return newTextureData(stream, internalFormat, pixelFormat, mipmap, fileSuffix); + } finally { + stream.close(); + } + } + } + + //---------------------------------------------------------------------- + // DDS provider -- supports files only for now + static class DDSTextureProvider implements TextureProvider { + public TextureData newTextureData(File file, + int internalFormat, + int pixelFormat, + boolean mipmap, + String fileSuffix) throws IOException { + if (DDS.equals(fileSuffix) || + DDS.equals(FileUtil.getFileSuffix(file))) { + final DDSImage image = DDSImage.read(file); + 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(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(internalFormat, + info.getWidth(), + info.getHeight(), + 0, + pixelFormat, + GL.GL_UNSIGNED_BYTE, + mipmap, + info.isCompressed(), + true, + info.getData(), + flusher); + } + return data; + } + + return null; + } + + public TextureData newTextureData(InputStream stream, + int internalFormat, + int pixelFormat, + boolean mipmap, + String fileSuffix) throws IOException { + return null; + } + + public TextureData newTextureData(URL url, + int internalFormat, + int pixelFormat, + boolean mipmap, + String fileSuffix) throws IOException { + return null; + } + } + + //---------------------------------------------------------------------- + // Base class for SGI RGB and TGA image providers + static abstract class StreamBasedTextureProvider implements TextureProvider { + public TextureData newTextureData(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(inStream, + internalFormat, + pixelFormat, + mipmap, + ((fileSuffix != null) ? fileSuffix : FileUtil.getFileSuffix(file))); + } finally { + inStream.close(); + } + } + + public TextureData newTextureData(URL url, + int internalFormat, + int pixelFormat, + boolean mipmap, + String fileSuffix) throws IOException { + InputStream stream = new BufferedInputStream(url.openStream()); + try { + return newTextureData(stream, internalFormat, pixelFormat, mipmap, fileSuffix); + } finally { + stream.close(); + } + } + } + + //---------------------------------------------------------------------- + // SGI RGB image provider + static class SGITextureProvider extends StreamBasedTextureProvider { + public TextureData newTextureData(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(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(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) { + internalFormat = GL.GL_RGBA8; + } + return new TextureData(internalFormat, + image.getWidth(), + image.getHeight(), + 0, + pixelFormat, + GL.GL_UNSIGNED_BYTE, + mipmap, + false, + false, + image.getData(), + null); + } + + return null; + } + } + + //---------------------------------------------------------------------- + // ImageIO texture writer + // + static 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 (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)"); + } + } + + //---------------------------------------------------------------------- + // 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 = GLU.getCurrentGL(); + gl.glGetIntegerv(pname, tmp, 0); + return tmp[0]; + } + + private static int glGetTexLevelParameteri(int target, int level, int pname) { + int[] tmp = new int[1]; + GL gl = GLU.getCurrentGL(); + 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/classes/com/sun/opengl/util/texture/spi/DDSImage.java b/src/classes/com/sun/opengl/util/texture/spi/DDSImage.java new file mode 100755 index 000000000..486515628 --- /dev/null +++ b/src/classes/com/sun/opengl/util/texture/spi/DDSImage.java @@ -0,0 +1,722 @@ +/* + * 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.sun.opengl.util.texture.spi; + +import java.io.*; +import java.nio.*; +import java.nio.channels.*; + +/** 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 + + // 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. */ + 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. */ + public static DDSImage read(File file) throws IOException { + DDSImage image = new DDSImage(); + image.readFromFile(file); + 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 + */ + 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; + } + + /** + * Writes this DDSImage to the specified file name. + */ + public void write(String filename) throws IOException { + write(new File(filename)); + } + + /** + * Writes this DDSImage to the specified file name. + */ + 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_*) */ + 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 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) */ + public ImageInfo getMipMap(int map) { + 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(); + 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. */ + public ImageInfo[] getAllMipMaps() { + int numLevels = getNumMipMaps(); + if (numLevels == 0) { + numLevels = 1; + } + ImageInfo[] result = new ImageInfo[numLevels]; + for (int i = 0; i < numLevels; i++) { + result[i] = getMipMap(i); + } + return result; + } + + /** Converts e.g. DXT1 compression format constant (see {@link + #getCompressionFormat}) into "DXT1". */ + 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(); + } + + 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, not yet used + 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 final int size() { + return 124; + } + + private static final int pfSize() { + return 32; + } + + private static final int writtenSize() { + return 128; + } + } + + private DDSImage() { + } + + private void readFromFile(File file) throws IOException { + fis = new FileInputStream(file); + chan = fis.getChannel(); + buf = chan.map(FileChannel.MapMode.READ_ONLY, + 0, (int) file.length()); + 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; + } + + int blockSize = computeCompressedBlockSize(getWidth(), getHeight(), depth, getCompressionFormat()); + + header.pitchOrLinearSize = blockSize; + 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 width; + } + + private int mipMapHeight(int map) { + int height = getHeight(); + for (int i = 0; i < map; i++) { + height >>= 1; + } + return height; + } + + private int mipMapSizeInBytes(int map) { + if (isCompressed()) { + if (!isSurfaceDescFlagSet(DDSD_LINEARSIZE)) { + throw new RuntimeException("Illegal compressed texture: DDSD_LINEARSIZE not specified in texture header"); + } + int bytes = header.pitchOrLinearSize; + for (int i = 0; i < map; i++) { + bytes >>= 2; + } + return bytes; + } else { + int width = mipMapWidth(map); + int height = mipMapHeight(map); + return width * height * (getDepth() / 8); + } + } + + 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/classes/com/sun/opengl/util/texture/spi/LEDataInputStream.java b/src/classes/com/sun/opengl/util/texture/spi/LEDataInputStream.java new file mode 100755 index 000000000..edbb6e35e --- /dev/null +++ b/src/classes/com/sun/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.sun.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 + */ +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/classes/com/sun/opengl/util/texture/spi/SGIImage.java b/src/classes/com/sun/opengl/util/texture/spi/SGIImage.java new file mode 100755 index 000000000..12523eb18 --- /dev/null +++ b/src/classes/com/sun/opengl/util/texture/spi/SGIImage.java @@ -0,0 +1,671 @@ +/* + * 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.sun.opengl.util.texture.spi; + +import java.io.*; +import javax.media.opengl.*; +import com.sun.opengl.util.*; + +// Test harness +import java.awt.image.*; +import javax.swing.*; + +/** <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 + /* + 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/classes/com/sun/opengl/util/texture/spi/TGAImage.java b/src/classes/com/sun/opengl/util/texture/spi/TGAImage.java new file mode 100755 index 000000000..8ab095643 --- /dev/null +++ b/src/classes/com/sun/opengl/util/texture/spi/TGAImage.java @@ -0,0 +1,386 @@ +/* + * 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.sun.opengl.util.texture.spi; + +import java.io.*; +import java.nio.*; +import java.nio.channels.*; +import javax.media.opengl.*; +import com.sun.opengl.util.*; + +/** + * 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$ + */ + +public class TGAImage { + private Header header; + private int format; + 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()]; + + if (header.pixelDepth() == 24) { + format = GL.GL_BGR; + } else { + assert header.pixelDepth() == 32; + format = GL.GL_BGRA; + } + + 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); + } + + data = ByteBuffer.wrap(tmpData); + } + + /** 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 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/classes/com/sun/opengl/util/texture/spi/TextureProvider.java b/src/classes/com/sun/opengl/util/texture/spi/TextureProvider.java new file mode 100755 index 000000000..1c822ef02 --- /dev/null +++ b/src/classes/com/sun/opengl/util/texture/spi/TextureProvider.java @@ -0,0 +1,165 @@ +/* + * 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.sun.opengl.util.texture.spi; + +import java.io.*; +import java.net.*; + +import com.sun.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 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(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 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(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 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(URL url, + int internalFormat, + int pixelFormat, + boolean mipmap, + String fileSuffix) throws IOException; +} diff --git a/src/classes/com/sun/opengl/util/texture/spi/TextureWriter.java b/src/classes/com/sun/opengl/util/texture/spi/TextureWriter.java new file mode 100755 index 000000000..423a3b3e5 --- /dev/null +++ b/src/classes/com/sun/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.sun.opengl.util.texture.spi; + +import java.io.*; + +import com.sun.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; +} |