aboutsummaryrefslogtreecommitdiffstats
path: root/gcc-4.4.3/libjava/classpath/gnu/java/awt/font/GNUGlyphVector.java
diff options
context:
space:
mode:
Diffstat (limited to 'gcc-4.4.3/libjava/classpath/gnu/java/awt/font/GNUGlyphVector.java')
-rw-r--r--gcc-4.4.3/libjava/classpath/gnu/java/awt/font/GNUGlyphVector.java663
1 files changed, 663 insertions, 0 deletions
diff --git a/gcc-4.4.3/libjava/classpath/gnu/java/awt/font/GNUGlyphVector.java b/gcc-4.4.3/libjava/classpath/gnu/java/awt/font/GNUGlyphVector.java
new file mode 100644
index 000000000..22f331e15
--- /dev/null
+++ b/gcc-4.4.3/libjava/classpath/gnu/java/awt/font/GNUGlyphVector.java
@@ -0,0 +1,663 @@
+/* GNUGlyphVector.java -- The GNU implementation of GlyphVector.
+ Copyright (C) 2006 Free Software Foundation, Inc.
+
+This file is part of GNU Classpath.
+
+GNU Classpath is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2, or (at your option)
+any later version.
+
+GNU Classpath is distributed in the hope that it will be useful, but
+WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Classpath; see the file COPYING. If not, write to the
+Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+02110-1301 USA.
+
+Linking this library statically or dynamically with other modules is
+making a combined work based on this library. Thus, the terms and
+conditions of the GNU General Public License cover the whole
+combination.
+
+As a special exception, the copyright holders of this library give you
+permission to link this library with independent modules to produce an
+executable, regardless of the license terms of these independent
+modules, and to copy and distribute the resulting executable under
+terms of your choice, provided that you also meet, for each linked
+independent module, the terms and conditions of the license of that
+module. An independent module is a module which is not derived from
+or based on this library. If you modify this library, you may extend
+this exception to your version of the library, but you are not
+obligated to do so. If you do not wish to do so, delete this
+exception statement from your version. */
+
+package gnu.java.awt.font;
+
+import gnu.java.awt.java2d.ShapeWrapper;
+
+import java.awt.Font;
+import java.awt.font.FontRenderContext;
+import java.awt.font.GlyphMetrics;
+import java.awt.font.GlyphJustificationInfo;
+import java.awt.font.GlyphVector;
+
+import java.awt.Shape;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.GeneralPath;
+import java.awt.geom.Point2D;
+import java.awt.geom.Rectangle2D;
+
+
+/**
+ * The GNU implementation of the abstract GlyphVector class, which
+ * uses the services provided by a FontDelegate for its functionality.
+ *
+ * @author Sascha Brawer (brawer@dandelis.ch)
+ */
+public class GNUGlyphVector
+ extends GlyphVector
+{
+ private FontDelegate fontDelegate;
+ private Font font;
+ private FontRenderContext renderContext;
+ private int[] glyphs;
+ private float fontSize;
+ private AffineTransform transform;
+ private boolean valid;
+
+
+ /**
+ * The position of each glyph. The horizontal position of the
+ * <code>i</code>-th glyph is at <code>pos[i * 2]</code>, its
+ * vertical position at <code>pos[i * 2 + 1]</code>. The total
+ * advance width of the entire vector is stored at
+ * <code>pos[numGlyphs]</code>, the total advance height at
+ * <code>pos[numGlyphs + 1]</code>.
+ */
+ private float[] pos;
+
+
+ private AffineTransform[] transforms;
+ private int layoutFlags;
+
+ /**
+ * The cached non-transformed outline of this glyph vector.
+ */
+ private Shape cleanOutline;
+
+ /**
+ * Constructs a new GNUGlyphVector.
+ *
+ * @param fontDelegate the FontDelegate that creates this vector.
+ *
+ * @param font the Font that this GlyphVector will return for {@link
+ * #getFont()}. That object is also used to determine the point
+ * size, which affects the affine transformation used by the font
+ * scaler.
+ *
+ * @param renderContext an object with parameters for font
+ * rendering, such as whether anti-aliasing is enabled.
+ *
+ * @param glyphs the glyphs in this vector.
+ */
+ public GNUGlyphVector(FontDelegate fontDelegate,
+ Font font,
+ FontRenderContext renderContext,
+ int[] glyphs)
+ {
+ this.fontDelegate = fontDelegate;
+ this.font = font;
+ this.renderContext = renderContext;
+ this.glyphs = glyphs;
+
+ fontSize = font.getSize2D();
+ transform = font.getTransform(); // returns a modifiable copy
+ //transform.concatenate(renderContext.getTransform());
+ }
+
+
+
+ /**
+ * Returns the font of the glyphs in this GlyphVector.
+ */
+ public Font getFont()
+ {
+ return font;
+ }
+
+
+ /**
+ * Returns the FontRenderContext that is used to calculate the
+ * extent and position of the glyphs.
+ */
+ public FontRenderContext getFontRenderContext()
+ {
+ return renderContext;
+ }
+
+
+ /**
+ * Moves each glyph in the vector to its default position.
+ */
+ public void performDefaultLayout()
+ {
+ float x, y, advanceWidth, advanceHeight;
+ int i, p;
+ AffineTransform tx;
+ Point2D.Float advance = new Point2D.Float();
+
+ pos = new float[(glyphs.length + 1) * 2];
+ x = y = 0.0f;
+ p = 0;
+ for (i = p = 0; i < glyphs.length; i++)
+ {
+ p += 2;
+
+ if ((transforms == null) || (tx = transforms[i]) == null)
+ tx = this.transform;
+ else
+ {
+ tx = new AffineTransform(tx);
+ tx.concatenate(this.transform);
+ }
+
+ fontDelegate.getAdvance(glyphs[i], fontSize, tx,
+ renderContext.isAntiAliased(),
+ renderContext.usesFractionalMetrics(),
+ /* horizontal */ true,
+ advance);
+ // FIXME: We shouldn't round here, but instead hint the metrics
+ // correctly.
+ pos[p] = x += Math.round(advance.x);
+ pos[p + 1] = y += advance.y;
+ }
+ valid = true;
+ }
+
+
+ /**
+ * Determines the number of glyphs in this GlyphVector.
+ */
+ public int getNumGlyphs()
+ {
+ return glyphs.length;
+ }
+
+
+ /**
+ * Determines the glyph number by index in this vector.
+ * Glyph numbers are specific to each font, so two fonts
+ * will likely assign different numbers to the same glyph.
+ *
+ * @param glyphIndex the index of the glyph whose glyph number is to
+ * be retrieved.
+ *
+ * @throws IndexOutOfBoundsException if <code>glyphIndex</code>
+ * is not in the range <code[0 .. getNumGlyphs() - 1]</code>.
+ */
+ public int getGlyphCode(int glyphIndex)
+ {
+ /* The exception is thrown automatically if the index is out
+ * of the valid bounds.
+ */
+ return glyphs[glyphIndex];
+ }
+
+
+ /**
+ * Returns a slice of this GlyphVector.
+ *
+ * @param firstGlyphIndex the index of the first glyph in the
+ * returned slice.
+ *
+ * @param numEntries the size of the returned slice.
+ *
+ * @param outCodes a pre-allocated array for storing the slice,
+ * or <code>null</code> to cause allocation of a new array.
+ *
+ * @return a slice of this GlyphVector. If <code>outCodes</code>
+ * is <code>null</code>, the slice will be stored into a freshly
+ * allocated array; otherwise, the result will be stored into
+ * <code>outCodes</code>.
+ */
+ public int[] getGlyphCodes(int firstGlyphIndex,
+ int numEntries,
+ int[] outCodes)
+ {
+ if (numEntries < 0)
+ throw new IllegalArgumentException();
+ if (outCodes == null)
+ outCodes = new int[numEntries];
+ System.arraycopy(glyphs, firstGlyphIndex, outCodes, 0, numEntries);
+ return outCodes;
+ }
+
+
+ public Rectangle2D getLogicalBounds()
+ {
+ float ascent, descent;
+
+ validate();
+
+ return new Rectangle2D.Float(0, 0,
+ pos[pos.length - 2],
+ getAscent() - getDescent());
+ }
+
+
+ public Rectangle2D getVisualBounds()
+ {
+ validate();
+
+ // FIXME: Not yet implemented.
+ return getLogicalBounds();
+ }
+
+
+ /**
+ * Returns the shape of this GlyphVector.
+ */
+ public Shape getOutline()
+ {
+ return getOutline(0.0f, 0.0f);
+ }
+
+
+ /**
+ * Returns the shape of this GlyphVector, translated to the
+ * specified position.
+ *
+ * @param x the horizontal position for rendering this vector.
+ * @param y the vertical position for rendering this vector.
+ */
+ public Shape getOutline(float x, float y)
+ {
+ validate();
+
+ Shape outline;
+ if (cleanOutline == null)
+ {
+ GeneralPath path = new GeneralPath();
+ int len = glyphs.length;
+ for (int i = 0; i < len; i++)
+ {
+ GeneralPath p = new GeneralPath(getGlyphOutline(i));
+ path.append(p, false);
+ }
+ // Protect the cached instance from beeing modified by application
+ // code.
+ cleanOutline = new ShapeWrapper(path);
+ outline = cleanOutline;
+ }
+ else
+ {
+ outline = cleanOutline;
+ }
+ if (x != 0 || y != 0)
+ {
+ GeneralPath path = new GeneralPath(outline);
+ AffineTransform t = new AffineTransform();
+ t.translate(x, y);
+ path.transform(t);
+ outline = path;
+ }
+ return outline;
+ }
+
+ public Shape getOutline(float x, float y, int type)
+ {
+ validate();
+
+ GeneralPath outline = new GeneralPath();
+ int len = glyphs.length;
+ for (int i = 0; i < len; i++)
+ {
+ GeneralPath p = new GeneralPath(getGlyphOutline(i, type));
+ outline.append(p, false);
+ }
+ AffineTransform t = new AffineTransform();
+ t.translate(x, y);
+ outline.transform(t);
+ return outline;
+ }
+
+ /**
+ * Determines the shape of the specified glyph.
+ *
+ * @throws IndexOutOfBoundsException if <code>glyphIndex</code> is
+ * not in the range <code[0 .. getNumGlyphs()]</code>.
+ */
+ public Shape getGlyphOutline(int glyphIndex)
+ {
+ AffineTransform tx, glyphTx;
+ GeneralPath path;
+
+ validate();
+
+ if ((transforms != null)
+ && ((glyphTx = transforms[glyphIndex]) != null))
+ {
+ tx = new AffineTransform(transform);
+ tx.concatenate(glyphTx);
+ }
+ else
+ tx = transform;
+
+ path = fontDelegate.getGlyphOutline(glyphs[glyphIndex], fontSize, tx,
+ renderContext.isAntiAliased(),
+ renderContext.usesFractionalMetrics(),
+ FontDelegate.FLAG_FITTED);
+
+ tx = new AffineTransform();
+ tx.translate(pos[glyphIndex * 2], pos[glyphIndex * 2 + 1]);
+ path.transform(tx);
+ return path;
+ }
+
+ public Shape getGlyphOutline(int glyphIndex, int type)
+ {
+ AffineTransform tx, glyphTx;
+ GeneralPath path;
+
+ validate();
+
+ if ((transforms != null)
+ && ((glyphTx = transforms[glyphIndex]) != null))
+ {
+ tx = new AffineTransform(transform);
+ tx.concatenate(glyphTx);
+ }
+ else
+ tx = transform;
+
+ path = fontDelegate.getGlyphOutline(glyphs[glyphIndex], fontSize, tx,
+ renderContext.isAntiAliased(),
+ renderContext.usesFractionalMetrics(),
+ type);
+
+ tx = new AffineTransform();
+ tx.translate(pos[glyphIndex * 2], pos[glyphIndex * 2 + 1]);
+ path.transform(tx);
+ return path;
+ }
+
+ /**
+ * Determines the position of the specified glyph, or the
+ * total advance width and height of the vector.
+ *
+ * @param glyphIndex the index of the glyph in question.
+ * If this value equals <code>getNumGlyphs()</code>, the
+ * position <i>after</i> the last glyph will be returned,
+ * which is the total advance width and height of the vector.
+ *
+ * @throws IndexOutOfBoundsException if <code>glyphIndex</code> is
+ * not in the range <code[0 .. getNumGlyphs()]</code>.
+ */
+ public Point2D getGlyphPosition(int glyphIndex)
+ {
+ validate();
+ return new Point2D.Float(pos[glyphIndex * 2],
+ pos[glyphIndex * 2 + 1]);
+ }
+
+
+ /**
+ * Moves the specified glyph to a new position, or changes the
+ * advance width and height of the entire glyph vector.
+ *
+ * <p>Note that the position of an individual glyph may also
+ * affected by its affine transformation.
+ *
+ * @param glyphIndex the index of the moved glyph. If
+ * <code>glyphIndex</code> equals the total number of glyphs in this
+ * vector, the advance width and height of the vector is changed.
+ *
+ * @param position the new position of the glyph.
+ *
+ * @throws IndexOutOfBoundsException if <code>glyphIndex</code> is
+ * not in the range <code[0 .. getNumGlyphs()]</code>.
+ */
+ public void setGlyphPosition(int glyphIndex, Point2D position)
+ {
+ validate();
+ pos[glyphIndex * 2] = (float) position.getX();
+ pos[glyphIndex * 2 + 1] = (float) position.getY();
+ }
+
+
+ /**
+ * Returns the affine transformation that is applied to the
+ * glyph at the specified index.
+ *
+ * @param glyphIndex the index of the glyph whose transformation
+ * is to be retrieved.
+ *
+ * @return an affine transformation, or <code>null</code>
+ * for the identity transformation.
+ *
+ * @throws IndexOutOfBoundsException if <code>glyphIndex</code> is
+ * not in the range <code[0 .. getNumGlyphs() - 1]</code>.
+ */
+ public AffineTransform getGlyphTransform(int glyphIndex)
+ {
+ if (transforms == null)
+ return null;
+ else
+ return transforms[glyphIndex];
+ }
+
+
+ /**
+ * Applies an affine transformation to the glyph at the specified
+ * index.
+ *
+ * @param glyphIndex the index of the glyph to which the
+ * transformation is applied.
+ *
+ * @param transform the affine transformation for the glyph, or
+ * <code>null</code> for an identity transformation.
+ */
+ public void setGlyphTransform(int glyphIndex,
+ AffineTransform transform)
+ {
+ if (transforms == null)
+ transforms = new AffineTransform[glyphs.length];
+ transforms[glyphIndex] = transform;
+
+ /* If the GlyphVector has only a transform for a single glyph, and
+ * the caller clears its transform, the FLAG_HAS_TRANSFORMS bit
+ * should be cleared in layoutFlags. However, this would require
+ * that we keep track of the number of transformed glyphs, or that
+ * we count them when a transform is cleared. This would
+ * complicate the code quite a bit. Note that the only drawback of
+ * wrongly setting FLAG_HAS_TRANSFORMS is that a slower code path
+ * might be taken for rendering the vector. Right now, we never
+ * really look at the flag, so it does not make any difference.
+ */
+ if (transform != null)
+ layoutFlags |= FLAG_HAS_TRANSFORMS;
+ valid = false;
+ }
+
+
+ /**
+ * Returns flags that can be used for optimizing the rendering
+ * of this GlyphVector.
+ *
+ * @return a bit mask with the applicable flags set.
+ *
+ * @since 1.4
+ *
+ * @see GlyphVector#FLAG_HAS_POSITION_ADJUSTMENTS
+ * @see GlyphVector#FLAG_HAS_TRANSFORMS
+ * @see GlyphVector#FLAG_RUN_RTL
+ * @see GlyphVector#FLAG_COMPLEX_GLYPHS
+ * @see GlyphVector#FLAG_MASK
+ */
+ public int getLayoutFlags()
+ {
+ return layoutFlags;
+ }
+
+
+ /**
+ * Returns the positions of a range of glyphs in this vector.
+ *
+ * @param firstGlyphIndex the index of the first glyph whose
+ * position is retrieved.
+ *
+ * @param numGlyphs the number of glyphs whose positions
+ * are retrieved.
+ *
+ * @param outPositions an array for storing the results
+ * (the length must be at least twice <code>numGlyphs</code>),
+ * or <code>null</code> for freshly allocating an array.
+ *
+ * @return an array with the glyph positions. The horizontal
+ * position of the <code>i</code>-th glyph is at index <code>2 *
+ * i</code>, the vertical position at index <code>2 * i + 1</code>.
+ *
+ * @throws IllegalArgumentException if <code>numGlyphs</code>
+ * is less than zero.
+ *
+ * @throws IndexOutOfBoundsException if either
+ * <code>firstGlyphIndex</code> or <code>(firstGlyphIndex +
+ * numGlyphs)</code> is not in the range <code>[0 .. getNumGlyphs() -
+ * 1]</code>.
+ */
+ public float[] getGlyphPositions(int firstGlyphIndex,
+ int numGlyphs,
+ float[] outPositions)
+ {
+ if (numGlyphs < 0)
+ throw new IllegalArgumentException();
+
+ validate();
+ if (outPositions == null)
+ outPositions = new float[numGlyphs * 2];
+
+ System.arraycopy(/*src */ pos, /* srcStart */ firstGlyphIndex * 2,
+ /* dest */ outPositions, /* destStart */ 0,
+ /* length */ numGlyphs * 2);
+ return outPositions;
+ }
+
+
+ private float getAscent()
+ {
+ return fontDelegate.getAscent(fontSize, transform,
+ renderContext.isAntiAliased(),
+ renderContext.usesFractionalMetrics(),
+ /* horizontal */ true);
+ }
+
+
+ private float getDescent()
+ {
+ return fontDelegate.getDescent(fontSize, transform,
+ renderContext.isAntiAliased(),
+ renderContext.usesFractionalMetrics(),
+ /* horizontal */ true);
+ }
+
+
+ public Shape getGlyphLogicalBounds(int glyphIndex)
+ {
+ float x, y, ascent;
+
+ validate();
+ ascent = getAscent();
+ x = pos[glyphIndex * 2];
+ y = pos[glyphIndex * 2 + 1];
+
+ return new Rectangle2D.Float(x, y - ascent,
+ pos[(glyphIndex + 1) * 2] - x,
+ ascent - getDescent());
+ }
+
+
+ public Shape getGlyphVisualBounds(int glyphIndex)
+ {
+ return getGlyphOutline(glyphIndex).getBounds2D();
+ }
+
+
+ /**
+ * Determines the metrics of the glyph at the specified index.
+ *
+ * @param glyphIndex the index of the glyph whose metrics is to be
+ * retrieved.
+ *
+ * @throws IndexOutOfBoundsException if <code>glyphIndex</code> is
+ * not in the range <code[0 .. getNumGlyphs() - 1]</code>.
+ */
+ public GlyphMetrics getGlyphMetrics(int glyphIndex)
+ {
+ // FIXME: Not yet implemented.
+ throw new UnsupportedOperationException();
+ }
+
+
+ /**
+ * Determines the justification information for the glyph at the
+ * specified index.
+ *
+ * @param glyphIndex the index of the glyph whose justification
+ * information is to be retrieved.
+ *
+ * @throws IndexOutOfBoundsException if <code>glyphIndex</code> is
+ * not in the range <code[0 .. getNumGlyphs() - 1]</code>.
+ */
+ public GlyphJustificationInfo getGlyphJustificationInfo(int glyphIndex)
+ {
+ // FIXME: Not yet implemented.
+ throw new UnsupportedOperationException();
+ }
+
+
+ /**
+ * Determines whether another GlyphVector is for the same font and
+ * rendering context, uses the same glyphs and positions them to the
+ * same location.
+ *
+ * @param other the GlyphVector to compare with.
+ *
+ * @return <code>true</code> if the two vectors are equal,
+ * <code>false</code> otherwise.
+ */
+ public boolean equals(GlyphVector other)
+ {
+ GNUGlyphVector o;
+ if (!(other instanceof GNUGlyphVector))
+ return false;
+
+ o = (GNUGlyphVector) other;
+ if ((this.font != o.font)
+ || (this.fontDelegate != o.fontDelegate)
+ || (this.renderContext != o.renderContext)
+ || (this.glyphs.length != o.glyphs.length))
+ return false;
+
+ for (int i = 0; i < glyphs.length; i++)
+ if (this.glyphs[i] != o.glyphs[i])
+ return false;
+
+ validate();
+ o.validate();
+ for (int i = 0; i < pos.length; i++)
+ if (this.pos[i] != o.pos[i])
+ return false;
+
+ return true;
+ }
+
+ private void validate()
+ {
+ if (!valid)
+ performDefaultLayout();
+ }
+}