| /* 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(); | |
| } | |
| } |