You are viewing a plain text version of this content. The canonical link for it is here.
Posted to batik-dev@xmlgraphics.apache.org by de...@apache.org on 2003/05/08 14:15:25 UTC
cvs commit: xml-batik/sources/org/apache/batik/gvt/font AWTGVTGlyphVector.java
deweese 2003/05/08 05:15:25
Modified: sources/org/apache/batik/gvt/font AWTGVTGlyphVector.java
Log:
No longer uses drawGlyphVector for 'complex' fills (gradients, patterns).
Revision Changes Path
1.23 +866 -859 xml-batik/sources/org/apache/batik/gvt/font/AWTGVTGlyphVector.java
Index: AWTGVTGlyphVector.java
===================================================================
RCS file: /home/cvs/xml-batik/sources/org/apache/batik/gvt/font/AWTGVTGlyphVector.java,v
retrieving revision 1.22
retrieving revision 1.23
diff -u -r1.22 -r1.23
--- AWTGVTGlyphVector.java 8 May 2003 11:39:12 -0000 1.22
+++ AWTGVTGlyphVector.java 8 May 2003 12:15:25 -0000 1.23
@@ -1,859 +1,866 @@
-/*****************************************************************************
- * Copyright (C) The Apache Software Foundation. All rights reserved. *
- * ------------------------------------------------------------------------- *
- * This software is published under the terms of the Apache Software License *
- * version 1.1, a copy of which has been included with this distribution in *
- * the LICENSE file. *
- *****************************************************************************/
-
-package org.apache.batik.gvt.font;
-
-import java.awt.Graphics2D;
-import java.awt.Paint;
-import java.awt.Shape;
-import java.awt.Stroke;
-import java.awt.font.FontRenderContext;
-import java.awt.font.GlyphJustificationInfo;
-import java.awt.font.GlyphMetrics;
-import java.awt.font.GlyphVector;
-import java.awt.font.TextAttribute;
-import java.awt.geom.AffineTransform;
-import java.awt.geom.GeneralPath;
-import java.awt.geom.Point2D;
-import java.awt.geom.Rectangle2D;
-import java.text.AttributedCharacterIterator;
-import java.text.CharacterIterator;
-
-import org.apache.batik.gvt.text.ArabicTextHandler;
-import org.apache.batik.gvt.text.GVTAttributedCharacterIterator;
-
-/**
- * This is a wrapper class for a java.awt.font.GlyphVector instance.
- *
- * @author <a href="mailto:bella.robinson@cmis.csiro.au">Bella Robinson</a>
- * @version $Id$
- */
-public class AWTGVTGlyphVector implements GVTGlyphVector {
-
- private GlyphVector awtGlyphVector;
- private AWTGVTFont gvtFont;
- private CharacterIterator ci;
-
- // This contains the glyphPostions after doing a performDefaultLayout
- private Point2D[] defaultGlyphPositions;
- private Point2D[] glyphPositions;
-
- // need to keep track of the glyphTransforms since GlyphVector doesn't
- // seem to
- private AffineTransform[] glyphTransforms;
-
- // these are for caching the glyph outlines
- private Shape[] glyphOutlines;
- private Shape[] glyphVisualBounds;
- private Shape[] glyphLogicalBounds;
- private boolean[] glyphVisible;
- private GVTGlyphMetrics [] glyphMetrics;
- private GeneralPath outline;
- private Rectangle2D visualBounds;
- private Rectangle2D logicalBounds;
- private Rectangle2D bounds2D;
- private float scaleFactor;
- private float ascent;
- private float descent;
-
- /**
- * Creates and new AWTGVTGlyphVector from the specified GlyphVector and
- * AWTGVTFont objects.
- *
- * @param glyphVector The glyph vector that this one will be based upon.
- * @param font The font that is creating this glyph vector.
- * @param scaleFactor The scale factor to apply to the glyph vector.
- * IMPORTANT: This is only required because the GlyphVector class doesn't
- * handle font sizes less than 1 correctly. By using the scale factor we
- * can use a GlyphVector created by a larger font and then scale it down to
- * the correct size.
- * @param ci The character string that this glyph vector represents.
- */
- public AWTGVTGlyphVector(GlyphVector glyphVector,
- AWTGVTFont font,
- float scaleFactor,
- CharacterIterator ci) {
-
- this.awtGlyphVector = glyphVector;
- this.gvtFont = font;
- this.scaleFactor = scaleFactor;
- this.ci = ci;
-
- GVTLineMetrics lineMetrics = gvtFont.getLineMetrics
- ("By", awtGlyphVector.getFontRenderContext());
-
- ascent = lineMetrics.getAscent();
- descent = lineMetrics.getDescent();
-
- outline = null;
- visualBounds = null;
- logicalBounds = null;
- bounds2D = null;
- int numGlyphs = glyphVector.getNumGlyphs();
- glyphPositions = new Point2D.Float [numGlyphs+1];
- glyphTransforms = new AffineTransform[numGlyphs];
- glyphOutlines = new Shape [numGlyphs];
- glyphVisualBounds = new Shape [numGlyphs];
- glyphLogicalBounds = new Shape [numGlyphs];
- glyphVisible = new boolean [numGlyphs];
- glyphMetrics = new GVTGlyphMetrics[numGlyphs];
-
- for (int i = 0; i < numGlyphs; i++) {
- glyphVisible[i] = true;
- }
- }
-
- /**
- * Returns the GVTFont associated with this GVTGlyphVector.
- */
- public GVTFont getFont() {
- return gvtFont;
- }
-
- /**
- * Returns the FontRenderContext associated with this GlyphVector.
- */
- public FontRenderContext getFontRenderContext() {
- return awtGlyphVector.getFontRenderContext();
- }
-
- /**
- * Returns the glyphcode of the specified glyph.
- */
- public int getGlyphCode(int glyphIndex) {
- return awtGlyphVector.getGlyphCode(glyphIndex);
- }
-
- /**
- * Returns an array of glyphcodes for the specified glyphs.
- */
- public int[] getGlyphCodes(int beginGlyphIndex, int numEntries,
- int[] codeReturn) {
- return awtGlyphVector.getGlyphCodes(beginGlyphIndex, numEntries,
- codeReturn);
- }
-
- /**
- * Returns the justification information for the glyph at the specified
- * index into this GlyphVector.
- */
- public GlyphJustificationInfo getGlyphJustificationInfo(int glyphIndex) {
- return awtGlyphVector.getGlyphJustificationInfo(glyphIndex);
- }
-
- /**
- * Returns a tight bounds on the GylphVector including stroking.
- */
- public Rectangle2D getBounds2D(AttributedCharacterIterator aci) {
- if (bounds2D != null)
- return bounds2D;
-
- Shape outline = null;
-
- aci.first();
- Paint fillP = (Paint)aci.getAttribute(TextAttribute.FOREGROUND);
- if (fillP != null) {
- outline = getOutline();
- bounds2D = outline.getBounds2D();
- }
-
- // check if we need to include the
- // outline of this glyph
- Stroke stroke = (Stroke) aci.getAttribute
- (GVTAttributedCharacterIterator.TextAttribute.STROKE);
- Paint paint = (Paint) aci.getAttribute
- (GVTAttributedCharacterIterator.TextAttribute.STROKE_PAINT);
- if ((stroke != null) && (paint != null)) {
- if (outline == null)
- outline = getOutline();
- Rectangle2D strokeBounds
- = stroke.createStrokedShape(outline).getBounds2D();
- if (bounds2D == null)
- bounds2D = strokeBounds;
- else
- bounds2D = bounds2D.createUnion(strokeBounds);
- }
-
- return bounds2D;
- }
-
- /**
- * Returns the logical bounds of this GlyphVector.
- * This is a bound useful for hit detection and highlighting.
- */
- public Rectangle2D getLogicalBounds() {
- if (logicalBounds == null) {
- // This fills in logicalBounds...
- computeGlyphLogicalBounds();
- }
- return logicalBounds;
- }
-
- /**
- * Returns the logical bounds of the specified glyph within this
- * GlyphVector.
- */
- public Shape getGlyphLogicalBounds(int glyphIndex) {
- if (glyphLogicalBounds[glyphIndex] == null &&
- glyphVisible[glyphIndex]) {
-
- computeGlyphLogicalBounds();
- }
- return glyphLogicalBounds[glyphIndex];
- }
-
- /**
- * Calculates the logical bounds for each glyph. The logical
- * bounds are what is used for highlighting the glyphs when
- * selected.
- */
- private void computeGlyphLogicalBounds() {
-
- Shape[] tempLogicalBounds = new Shape[getNumGlyphs()];
- boolean[] rotated = new boolean[getNumGlyphs()];
-
- double maxWidth = -1;
- double maxHeight = -1;
-
- for (int i = 0; i < getNumGlyphs(); i++) {
-
- if (!glyphVisible[i]) {
- // the glyph is not drawn
- tempLogicalBounds[i] = null;
- continue;
- }
-
- AffineTransform glyphTransform = getGlyphTransform(i);
- GVTGlyphMetrics glyphMetrics = getGlyphMetrics(i);
-
- float glyphX = 0;
- float glyphY = -ascent/scaleFactor;
- float glyphWidth = (glyphMetrics.getHorizontalAdvance()/
- scaleFactor);
- float glyphHeight = (glyphMetrics.getVerticalAdvance()/
- scaleFactor);
-
- Rectangle2D glyphBounds = new Rectangle2D.Double(glyphX,
- glyphY,
- glyphWidth,
- glyphHeight);
-
- if (glyphBounds.isEmpty()) {
- if (i > 0) {
- // can't tell if rotated or not, make it the same as
- // the previous glyph
- rotated [i] = rotated [i-1];
- } else {
- rotated [i] = true;
- }
- } else {
- // get three corner points so we can determine
- // whether the glyph is rotated
- Point2D p1 = new Point2D.Double(glyphBounds.getMinX(),
- glyphBounds.getMinY());
- Point2D p2 = new Point2D.Double(glyphBounds.getMaxX(),
- glyphBounds.getMinY());
- Point2D p3 = new Point2D.Double(glyphBounds.getMinX(),
- glyphBounds.getMaxY());
-
- AffineTransform tr = AffineTransform.getTranslateInstance
- (getGlyphPosition(i).getX(),
- getGlyphPosition(i).getY());
-
- if (glyphTransform != null)
- tr.concatenate(glyphTransform);
- tr.scale(scaleFactor, scaleFactor);
-
- tempLogicalBounds[i] = tr.createTransformedShape(glyphBounds);
-
- Point2D tp1 = new Point2D.Double();
- Point2D tp2 = new Point2D.Double();
- Point2D tp3 = new Point2D.Double();
- tr.transform(p1, tp1);
- tr.transform(p2, tp2);
- tr.transform(p3, tp3);
- double tdx12 = tp1.getX()-tp2.getX();
- double tdx13 = tp1.getX()-tp3.getX();
- double tdy12 = tp1.getY()-tp2.getY();
- double tdy13 = tp1.getY()-tp3.getY();
-
- if (((Math.abs(tdx12) < 0.001) && (Math.abs(tdy13) < 0.001)) ||
- ((Math.abs(tdx13) < 0.001) && (Math.abs(tdy12) < 0.001))) {
- // If either of these are zero then it is axially aligned
- rotated[i] = false;
- } else {
- rotated [i] = true;
- }
-
- Rectangle2D rectBounds;
- rectBounds = tempLogicalBounds[i].getBounds2D();
- if (rectBounds.getWidth() > maxWidth)
- maxWidth = rectBounds.getWidth();
- if (rectBounds.getHeight() > maxHeight)
- maxHeight = rectBounds.getHeight();
- }
- }
-
- // if appropriate, join adjacent glyph logical bounds
- GeneralPath logicalBoundsPath = new GeneralPath();
- for (int i = 0; i < getNumGlyphs(); i++) {
- if (tempLogicalBounds[i] != null) {
- logicalBoundsPath.append(tempLogicalBounds[i], false);
- }
- }
-
- logicalBounds = logicalBoundsPath.getBounds2D();
-
- if (logicalBounds.getHeight() < maxHeight*1.5) {
- // make all glyphs tops and bottoms the same as the full bounds
- for (int i = 0; i < getNumGlyphs(); i++) {
- // first make sure that the glyph logical bounds are
- // not rotated
- if (rotated[i]) continue;
- if (tempLogicalBounds[i] == null) continue;
-
- Rectangle2D glyphBounds = tempLogicalBounds[i].getBounds2D();
-
- double x = glyphBounds.getMinX();
- double width = glyphBounds.getWidth();
-
- if ((i < getNumGlyphs()-1) &&
- (tempLogicalBounds[i+1] != null)) {
- // make this glyph extend to the start of the next one
- Rectangle2D nextGlyphBounds =
- tempLogicalBounds[i+1].getBounds2D();
-
- if (nextGlyphBounds.getX() > x) {
- // going left to right (this is pretty hoky)
- width = nextGlyphBounds.getX() - x;
- } else {
- double newGlyphX = (nextGlyphBounds.getX() +
- nextGlyphBounds.getWidth());
- width += (x - newGlyphX);
- x = newGlyphX;
- }
- }
-
- tempLogicalBounds[i] = new Rectangle2D.Double
- (x, logicalBounds.getMinY(),
- width, logicalBounds.getHeight());
- }
- } else if (logicalBounds.getWidth() < maxWidth*1.5) {
- // make all glyphs left and right edges the same as the full bounds
- for (int i = 0; i < getNumGlyphs(); i++) {
- // first make sure that the glyph logical bounds are
- // not rotated
- if (rotated[i]) continue;
- if (tempLogicalBounds[i] == null) continue;
-
- Rectangle2D glyphBounds = tempLogicalBounds[i].getBounds2D();
- double y = glyphBounds.getMinY();
- double height = glyphBounds.getHeight();
-
- if ((i < getNumGlyphs()-1) &&
- (tempLogicalBounds[i+1] != null)) {
- // make this glyph extend to the start of the next one
- Rectangle2D nextGlyphBounds =
- tempLogicalBounds[i+1].getBounds2D();
- if (nextGlyphBounds.getY() > y) { // going top to bottom
- height = nextGlyphBounds.getY() - y;
- } else {
- double newGlyphY = (nextGlyphBounds.getY() +
- nextGlyphBounds.getHeight());
- height += (y - newGlyphY);
- y = newGlyphY;
- }
- }
-
- tempLogicalBounds[i] = new Rectangle2D.Double
- (logicalBounds.getMinX(), y,
- logicalBounds.getWidth(), height);
- }
- }
-
- for (int i = 0; i < getNumGlyphs(); i++) {
- glyphLogicalBounds[i] = tempLogicalBounds[i];
- }
- }
-
- /**
- * Returns the metrics of the glyph at the specified index into this
- * GVTGlyphVector.
- */
- public GVTGlyphMetrics getGlyphMetrics(int glyphIndex) {
- if (glyphMetrics[glyphIndex] == null) {
-/*
- GlyphMetrics gm = awtGlyphVector.getGlyphMetrics(glyphIndex);
- Rectangle2D gmB = gm.getBounds2D();
-*/
- // -- start glyph cache code --
- Point2D glyphPos = defaultGlyphPositions[glyphIndex];
- char c = ci.setIndex(ci.getBeginIndex()+glyphIndex);
- ci.setIndex(ci.getBeginIndex());
- AWTGlyphGeometryCache.Value v = AWTGVTFont.getGlyphGeometry
- (gvtFont, c, awtGlyphVector, glyphIndex, glyphPos);
- Rectangle2D gmB = v.getBounds2D();
- // -- end glyph cache code --
-
- Rectangle2D bounds = new Rectangle2D.Double
- (gmB.getX() * scaleFactor, gmB.getY() * scaleFactor,
- gmB.getWidth() * scaleFactor, gmB.getHeight() * scaleFactor);
-
- // defaultGlyphPositions has one more entry than glyphs
- // the last entry stores the total advance for the
- // glyphVector.
- float adv = (float)(defaultGlyphPositions[glyphIndex+1].getX()-
- defaultGlyphPositions[glyphIndex] .getX());
- glyphMetrics[glyphIndex] = new GVTGlyphMetrics
- (adv*scaleFactor, (ascent+descent),
- bounds, GlyphMetrics.STANDARD);
- }
- return glyphMetrics[glyphIndex];
- }
-
- /**
- * Returns a Shape whose interior corresponds to the visual representation
- * of the specified glyph within this GlyphVector.
- */
- public Shape getGlyphOutline(int glyphIndex) {
- if (glyphOutlines[glyphIndex] == null) {
-/*
- Shape glyphOutline = awtGlyphVector.getGlyphOutline(glyphIndex);
-*/
- // -- start glyph cache code --
- Point2D glyphPos = defaultGlyphPositions[glyphIndex];
- char c = ci.setIndex(ci.getBeginIndex()+glyphIndex);
- ci.setIndex(ci.getBeginIndex());
- AWTGlyphGeometryCache.Value v = AWTGVTFont.getGlyphGeometry
- (gvtFont, c, awtGlyphVector, glyphIndex, glyphPos);
- Shape glyphOutline = v.getOutline();
- // -- end glyph cache code --
-
- AffineTransform tr = AffineTransform.getTranslateInstance
- (getGlyphPosition(glyphIndex).getX(),
- getGlyphPosition(glyphIndex).getY());
-
- AffineTransform glyphTransform = getGlyphTransform(glyphIndex);
-
- if (glyphTransform != null) {
- tr.concatenate(glyphTransform);
- }
- //
- // <!> HACK
- //
- // GlyphVector.getGlyphOutline behavior changes between 1.3 and 1.4
- //
- // I've looked at this problem a bit more and the incorrect glyph
- // positioning in Batik is definitely due to the change in
- // behavior of GlyphVector.getGlyphOutline(glyphIndex). It used to
- // return the outline of the glyph at position 0,0 which meant
- // that we had to translate it to the actual glyph position before
- // drawing it. Now, it returns the outline which has already been
- // positioned.
- //
- // -- Bella
- //
-/*
- if (outlinesPositioned()) {
- Point2D glyphPos = defaultGlyphPositions[glyphIndex];
- tr.translate(-glyphPos.getX(), -glyphPos.getY());
- }
-*/
- tr.scale(scaleFactor, scaleFactor);
- glyphOutlines[glyphIndex]=tr.createTransformedShape(glyphOutline);
- }
-
- return glyphOutlines[glyphIndex];
- }
-
- private static final boolean outlinesPositioned;
- private static final boolean glyphVectorTransformWorks;
-
- static {
- String s = System.getProperty("java.specification.version");
- if ("1.4".compareTo(s) <= 0) {
- outlinesPositioned = true;
- glyphVectorTransformWorks = true;
- } else if ("Mac OS X".equals(System.getProperty("os.name"))) {
- outlinesPositioned = true;
- glyphVectorTransformWorks = false; // Note sure about this...
- } else {
- outlinesPositioned = false;
- glyphVectorTransformWorks = false;
- }
- }
-
- static boolean outlinesPositioned() {
- return outlinesPositioned;
- }
-
- /**
- * Returns the position of the specified glyph within this GlyphVector.
- */
- public Point2D getGlyphPosition(int glyphIndex) {
- return glyphPositions[glyphIndex];
- }
-
- /**
- * Returns an array of glyph positions for the specified glyphs
- */
- public float[] getGlyphPositions(int beginGlyphIndex,
- int numEntries,
- float[] positionReturn) {
-
- if (positionReturn == null) {
- positionReturn = new float[numEntries*2];
- }
-
- for (int i = beginGlyphIndex; i < (beginGlyphIndex+numEntries); i++) {
- Point2D glyphPos = getGlyphPosition(i);
- positionReturn[(i-beginGlyphIndex)*2] = (float)glyphPos.getX();
- positionReturn[(i-beginGlyphIndex)*2 + 1] = (float)glyphPos.getY();
- }
-
- return positionReturn;
- }
-
- /**
- * Gets the transform of the specified glyph within this GlyphVector.
- */
- public AffineTransform getGlyphTransform(int glyphIndex) {
- return glyphTransforms[glyphIndex];
- }
-
- /**
- * Returns the visual bounds of the specified glyph within the GlyphVector.
- */
- public Shape getGlyphVisualBounds(int glyphIndex) {
- if (glyphVisualBounds[glyphIndex] == null) {
-/*
- Shape glyphOutline = awtGlyphVector.getGlyphOutline(glyphIndex);
- Rectangle2D glyphBounds = glyphOutline.getBounds2D();
-*/
- // -- start glyph cache code --
- Point2D glyphPos = defaultGlyphPositions[glyphIndex];
- char c = ci.setIndex(ci.getBeginIndex()+glyphIndex);
- ci.setIndex(ci.getBeginIndex());
- AWTGlyphGeometryCache.Value v = AWTGVTFont.getGlyphGeometry
- (gvtFont, c, awtGlyphVector, glyphIndex, glyphPos);
- Rectangle2D glyphBounds = v.getOutlineBounds2D();
- // -- end glyph cache code --
-
- AffineTransform tr = AffineTransform.getTranslateInstance
- (getGlyphPosition(glyphIndex).getX(),
- getGlyphPosition(glyphIndex).getY());
-
- AffineTransform glyphTransform = getGlyphTransform(glyphIndex);
- if (glyphTransform != null) {
- tr.concatenate(glyphTransform);
- }
- tr.scale(scaleFactor, scaleFactor);
- glyphVisualBounds[glyphIndex] =
- tr.createTransformedShape(glyphBounds);
- }
-
- return glyphVisualBounds[glyphIndex];
- }
-
- /**
- * Returns the number of glyphs in this GlyphVector.
- */
- public int getNumGlyphs() {
- return awtGlyphVector.getNumGlyphs();
- }
-
- /**
- * Returns a Shape whose interior corresponds to the visual representation
- * of this GlyphVector.
- */
- public Shape getOutline() {
- if (outline == null) {
- outline = new GeneralPath();
- for (int i = 0; i < getNumGlyphs(); i++) {
- if (glyphVisible[i]) {
- Shape glyphOutline = getGlyphOutline(i);
- outline.append(glyphOutline, false);
- }
- }
- }
-
- return outline;
- }
-
- /**
- * Returns a Shape whose interior corresponds to the visual representation
- * of this GlyphVector, offset to x, y.
- */
- public Shape getOutline(float x, float y) {
- Shape outline = getOutline();
- AffineTransform tr = AffineTransform.getTranslateInstance(x,y);
- outline = tr.createTransformedShape(outline);
- return outline;
- }
-
- /**
- * Returns the visual bounds of this GlyphVector The visual bounds is the
- * tightest rectangle enclosing all non-background pixels in the rendered
- * representation of this GlyphVector.
- */
- public Rectangle2D getGeometricBounds() {
- if (visualBounds == null) {
- Shape outline = getOutline();
- visualBounds = outline.getBounds2D();
- }
- return visualBounds;
- }
-
- /**
- * Assigns default positions to each glyph in this GlyphVector.
- */
- public void performDefaultLayout() {
- if (defaultGlyphPositions == null) {
- awtGlyphVector.performDefaultLayout();
- defaultGlyphPositions = new Point2D.Float[getNumGlyphs()+1];
- for (int i = 0; i <= getNumGlyphs(); i++)
- defaultGlyphPositions[i] = awtGlyphVector.getGlyphPosition(i);
- }
-
- outline = null;
- visualBounds = null;
- logicalBounds = null;
- bounds2D = null;
- float shiftLeft = 0;
- int i=0;
- for (; i < getNumGlyphs(); i++) {
- glyphTransforms [i] = null;
- glyphVisualBounds [i] = null;
- glyphLogicalBounds[i] = null;
- glyphOutlines [i] = null;
- glyphMetrics [i] = null;
- Point2D glyphPos = defaultGlyphPositions[i];
- glyphPositions[i] = new Point2D.Float
- ((float)((glyphPos.getX() * scaleFactor)-shiftLeft),
- (float) (glyphPos.getY() * scaleFactor));
-
- // if c is a transparent arabic char then need to shift the
- // following glyphs left so that the current glyph is overwritten
- char c = ci.setIndex(i + ci.getBeginIndex());
- if (ArabicTextHandler.arabicCharTransparent(c)) {
- shiftLeft += getGlyphMetrics(i).getHorizontalAdvance();
- }
- }
-
- // Need glyph pos for point after last char...
- Point2D glyphPos = defaultGlyphPositions[i];
- glyphPositions[i] = new Point2D.Float
- ((float)((glyphPos.getX() * scaleFactor)-shiftLeft),
- (float) (glyphPos.getY() * scaleFactor));
- }
-
- /**
- * Sets the position of the specified glyph within this GlyphVector.
- */
- public void setGlyphPosition(int glyphIndex, Point2D newPos) {
- glyphPositions[glyphIndex] =
- new Point2D.Float((float)newPos.getX(), (float)newPos.getY());
- outline = null;
- visualBounds = null;
- logicalBounds = null;
- bounds2D = null;
-
- if (glyphIndex != getNumGlyphs()) {
- glyphVisualBounds [glyphIndex] = null;
- glyphLogicalBounds[glyphIndex] = null;
- glyphOutlines [glyphIndex] = null;
- glyphMetrics [glyphIndex] = null;
- }
- }
-
- /**
- * Sets the transform of the specified glyph within this GlyphVector.
- */
- public void setGlyphTransform(int glyphIndex, AffineTransform newTX) {
- glyphTransforms[glyphIndex] = newTX;
- outline = null;
- visualBounds = null;
- logicalBounds = null;
- bounds2D = null;
-
- glyphVisualBounds [glyphIndex] = null;
- glyphLogicalBounds[glyphIndex] = null;
- glyphOutlines [glyphIndex] = null;
- glyphMetrics [glyphIndex] = null;
- }
-
- /**
- * Tells the glyph vector whether or not to draw the specified glyph.
- */
- public void setGlyphVisible(int glyphIndex, boolean visible) {
- if (visible == glyphVisible[glyphIndex])
- return;
- glyphVisible[glyphIndex] = visible;
- outline = null;
- visualBounds = null;
- logicalBounds = null;
- bounds2D = null;
-
- glyphVisualBounds [glyphIndex] = null;
- glyphLogicalBounds[glyphIndex] = null;
- glyphOutlines [glyphIndex] = null;
- glyphMetrics [glyphIndex] = null;
- }
-
- /**
- * Returns true if specified glyph will be rendered.
- */
- public boolean isGlyphVisible(int glyphIndex) {
- return glyphVisible[glyphIndex];
- }
-
- /**
- * Returns the number of chars represented by the glyphs within the
- * specified range.
- *
- * @param startGlyphIndex The index of the first glyph in the range.
- * @param endGlyphIndex The index of the last glyph in the range.
- * @return The number of chars.
- */
- public int getCharacterCount(int startGlyphIndex, int endGlyphIndex) {
- if (startGlyphIndex < 0) {
- startGlyphIndex = 0;
- }
- if (endGlyphIndex >= getNumGlyphs()) {
- endGlyphIndex = getNumGlyphs()-1;
- }
- int charCount = 0;
- int start = startGlyphIndex+ci.getBeginIndex();
- int end = endGlyphIndex+ci.getBeginIndex();
-
- for (char c = ci.setIndex(start); ci.getIndex() <= end; c=ci.next()) {
- if (ArabicTextHandler.isLigature(c)) {
- charCount += ArabicTextHandler.getNumChars(c);
- } else {
- charCount++;
- }
- }
-
- return charCount;
- }
-
- /**
- * Draws this glyph vector.
- */
- public void draw(Graphics2D graphics2D,
- AttributedCharacterIterator aci) {
- int numGlyphs = getNumGlyphs();
-
- aci.first();
- Paint fillPaint = (Paint)aci.getAttribute(TextAttribute.FOREGROUND);
- Stroke stroke = (Stroke) aci.getAttribute
- (GVTAttributedCharacterIterator.TextAttribute.STROKE);
- Paint strokePaint = (Paint) aci.getAttribute
- (GVTAttributedCharacterIterator.TextAttribute.STROKE_PAINT);
- if ((fillPaint == null) && ((strokePaint == null) ||
- (stroke == null)))
- return;
-
- boolean useHinting = true;
- if ((stroke != null) && (strokePaint != null))
- useHinting = false;
-
- final int typeGRot = AffineTransform.TYPE_GENERAL_ROTATION;
- final int typeGTrans = AffineTransform.TYPE_GENERAL_TRANSFORM;
- if (useHinting) {
- // Check if usr->dev transform has general rotation,
- // or shear..
- AffineTransform at = graphics2D.getTransform();
- int type = at.getType();
- if (((type & typeGTrans) != 0) || ((type & typeGRot) != 0))
- useHinting = false;
- }
-
- if (useHinting) {
- double [] mat = new double[4];
- for (int i=0; i<numGlyphs; i++) {
- if (!glyphVisible[i]) {
- useHinting = false;
- break;
- }
- AffineTransform at = glyphTransforms[i];
- if (at != null) {
- int type = at.getType();
- if ((type & ~AffineTransform.TYPE_TRANSLATION) == 0) {
- // Just translation
- } else if (glyphVectorTransformWorks &&
- ((type & typeGTrans) == 0) &&
- ((type & typeGRot) == 0)) {
- // It's a simple 90Deg rotate, and we can put
- // it into the GlyphVector.
- } else {
- // we can't (or it doesn't make sense
- // to use the GlyphVector.
- useHinting = false;
- break;
- }
- }
- }
- }
-
- if (useHinting) {
- double sf = scaleFactor;
- double [] mat = new double[6];
- for (int i=0; i< numGlyphs; i++) {
- Point2D pos = glyphPositions[i];
- double x = pos.getX();
- double y = pos.getY();
- AffineTransform at = glyphTransforms[i];
- if (at != null) {
- // Scale the translate portion of matrix,
- // and add it into the position.
- at.getMatrix(mat);
- x += mat[4];
- y += mat[5];
- if ((mat[0] != 1) || (mat[1] != 0) ||
- (mat[2] != 0) || (mat[3] != 1)) {
- // More than just translation.
- mat[4] = 0; mat[5] = 0;
- at = new AffineTransform(mat);
- } else {
- at = null;
- }
- }
- pos = new Point2D.Double(x/sf, y/sf);
- awtGlyphVector.setGlyphPosition(i, pos);
- awtGlyphVector.setGlyphTransform(i, at);
- }
- graphics2D.scale(sf, sf);
- graphics2D.setPaint(fillPaint);
- graphics2D.drawGlyphVector(awtGlyphVector, 0, 0);
- graphics2D.scale(1/sf, 1/sf);
-
- for (int i=0; i< numGlyphs; i++) {
- Point2D pos = defaultGlyphPositions[i];
- awtGlyphVector.setGlyphPosition(i, pos);
- awtGlyphVector.setGlyphTransform(i, null);
- }
-
- } else {
- Shape outline = getOutline();
-
- // check if we need to fill this glyph
- if (fillPaint != null) {
- graphics2D.setPaint(fillPaint);
- graphics2D.fill(outline);
- }
-
- // check if we need to draw the outline of this glyph
- if (stroke != null && strokePaint != null) {
- graphics2D.setStroke(stroke);
- graphics2D.setPaint(strokePaint);
- graphics2D.draw(outline);
- }
- }
- }
-}
+/*****************************************************************************
+ * Copyright (C) The Apache Software Foundation. All rights reserved. *
+ * ------------------------------------------------------------------------- *
+ * This software is published under the terms of the Apache Software License *
+ * version 1.1, a copy of which has been included with this distribution in *
+ * the LICENSE file. *
+ *****************************************************************************/
+
+package org.apache.batik.gvt.font;
+
+import java.awt.Color;
+import java.awt.Graphics2D;
+import java.awt.Paint;
+import java.awt.Shape;
+import java.awt.Stroke;
+import java.awt.font.FontRenderContext;
+import java.awt.font.GlyphJustificationInfo;
+import java.awt.font.GlyphMetrics;
+import java.awt.font.GlyphVector;
+import java.awt.font.TextAttribute;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.GeneralPath;
+import java.awt.geom.Point2D;
+import java.awt.geom.Rectangle2D;
+import java.text.AttributedCharacterIterator;
+import java.text.CharacterIterator;
+
+import org.apache.batik.gvt.text.ArabicTextHandler;
+import org.apache.batik.gvt.text.GVTAttributedCharacterIterator;
+
+/**
+ * This is a wrapper class for a java.awt.font.GlyphVector instance.
+ *
+ * @author <a href="mailto:bella.robinson@cmis.csiro.au">Bella Robinson</a>
+ * @version $Id$
+ */
+public class AWTGVTGlyphVector implements GVTGlyphVector {
+
+ private GlyphVector awtGlyphVector;
+ private AWTGVTFont gvtFont;
+ private CharacterIterator ci;
+
+ // This contains the glyphPostions after doing a performDefaultLayout
+ private Point2D[] defaultGlyphPositions;
+ private Point2D[] glyphPositions;
+
+ // need to keep track of the glyphTransforms since GlyphVector doesn't
+ // seem to
+ private AffineTransform[] glyphTransforms;
+
+ // these are for caching the glyph outlines
+ private Shape[] glyphOutlines;
+ private Shape[] glyphVisualBounds;
+ private Shape[] glyphLogicalBounds;
+ private boolean[] glyphVisible;
+ private GVTGlyphMetrics [] glyphMetrics;
+ private GeneralPath outline;
+ private Rectangle2D visualBounds;
+ private Rectangle2D logicalBounds;
+ private Rectangle2D bounds2D;
+ private float scaleFactor;
+ private float ascent;
+ private float descent;
+
+ /**
+ * Creates and new AWTGVTGlyphVector from the specified GlyphVector and
+ * AWTGVTFont objects.
+ *
+ * @param glyphVector The glyph vector that this one will be based upon.
+ * @param font The font that is creating this glyph vector.
+ * @param scaleFactor The scale factor to apply to the glyph vector.
+ * IMPORTANT: This is only required because the GlyphVector class doesn't
+ * handle font sizes less than 1 correctly. By using the scale factor we
+ * can use a GlyphVector created by a larger font and then scale it down to
+ * the correct size.
+ * @param ci The character string that this glyph vector represents.
+ */
+ public AWTGVTGlyphVector(GlyphVector glyphVector,
+ AWTGVTFont font,
+ float scaleFactor,
+ CharacterIterator ci) {
+
+ this.awtGlyphVector = glyphVector;
+ this.gvtFont = font;
+ this.scaleFactor = scaleFactor;
+ this.ci = ci;
+
+ GVTLineMetrics lineMetrics = gvtFont.getLineMetrics
+ ("By", awtGlyphVector.getFontRenderContext());
+
+ ascent = lineMetrics.getAscent();
+ descent = lineMetrics.getDescent();
+
+ outline = null;
+ visualBounds = null;
+ logicalBounds = null;
+ bounds2D = null;
+ int numGlyphs = glyphVector.getNumGlyphs();
+ glyphPositions = new Point2D.Float [numGlyphs+1];
+ glyphTransforms = new AffineTransform[numGlyphs];
+ glyphOutlines = new Shape [numGlyphs];
+ glyphVisualBounds = new Shape [numGlyphs];
+ glyphLogicalBounds = new Shape [numGlyphs];
+ glyphVisible = new boolean [numGlyphs];
+ glyphMetrics = new GVTGlyphMetrics[numGlyphs];
+
+ for (int i = 0; i < numGlyphs; i++) {
+ glyphVisible[i] = true;
+ }
+ }
+
+ /**
+ * Returns the GVTFont associated with this GVTGlyphVector.
+ */
+ public GVTFont getFont() {
+ return gvtFont;
+ }
+
+ /**
+ * Returns the FontRenderContext associated with this GlyphVector.
+ */
+ public FontRenderContext getFontRenderContext() {
+ return awtGlyphVector.getFontRenderContext();
+ }
+
+ /**
+ * Returns the glyphcode of the specified glyph.
+ */
+ public int getGlyphCode(int glyphIndex) {
+ return awtGlyphVector.getGlyphCode(glyphIndex);
+ }
+
+ /**
+ * Returns an array of glyphcodes for the specified glyphs.
+ */
+ public int[] getGlyphCodes(int beginGlyphIndex, int numEntries,
+ int[] codeReturn) {
+ return awtGlyphVector.getGlyphCodes(beginGlyphIndex, numEntries,
+ codeReturn);
+ }
+
+ /**
+ * Returns the justification information for the glyph at the specified
+ * index into this GlyphVector.
+ */
+ public GlyphJustificationInfo getGlyphJustificationInfo(int glyphIndex) {
+ return awtGlyphVector.getGlyphJustificationInfo(glyphIndex);
+ }
+
+ /**
+ * Returns a tight bounds on the GylphVector including stroking.
+ */
+ public Rectangle2D getBounds2D(AttributedCharacterIterator aci) {
+ if (bounds2D != null)
+ return bounds2D;
+
+ Shape outline = null;
+
+ aci.first();
+ Paint fillP = (Paint)aci.getAttribute(TextAttribute.FOREGROUND);
+ if (fillP != null) {
+ outline = getOutline();
+ bounds2D = outline.getBounds2D();
+ }
+
+ // check if we need to include the
+ // outline of this glyph
+ Stroke stroke = (Stroke) aci.getAttribute
+ (GVTAttributedCharacterIterator.TextAttribute.STROKE);
+ Paint paint = (Paint) aci.getAttribute
+ (GVTAttributedCharacterIterator.TextAttribute.STROKE_PAINT);
+ if ((stroke != null) && (paint != null)) {
+ if (outline == null)
+ outline = getOutline();
+ Rectangle2D strokeBounds
+ = stroke.createStrokedShape(outline).getBounds2D();
+ if (bounds2D == null)
+ bounds2D = strokeBounds;
+ else
+ bounds2D = bounds2D.createUnion(strokeBounds);
+ }
+
+ return bounds2D;
+ }
+
+ /**
+ * Returns the logical bounds of this GlyphVector.
+ * This is a bound useful for hit detection and highlighting.
+ */
+ public Rectangle2D getLogicalBounds() {
+ if (logicalBounds == null) {
+ // This fills in logicalBounds...
+ computeGlyphLogicalBounds();
+ }
+ return logicalBounds;
+ }
+
+ /**
+ * Returns the logical bounds of the specified glyph within this
+ * GlyphVector.
+ */
+ public Shape getGlyphLogicalBounds(int glyphIndex) {
+ if (glyphLogicalBounds[glyphIndex] == null &&
+ glyphVisible[glyphIndex]) {
+
+ computeGlyphLogicalBounds();
+ }
+ return glyphLogicalBounds[glyphIndex];
+ }
+
+ /**
+ * Calculates the logical bounds for each glyph. The logical
+ * bounds are what is used for highlighting the glyphs when
+ * selected.
+ */
+ private void computeGlyphLogicalBounds() {
+
+ Shape[] tempLogicalBounds = new Shape[getNumGlyphs()];
+ boolean[] rotated = new boolean[getNumGlyphs()];
+
+ double maxWidth = -1;
+ double maxHeight = -1;
+
+ for (int i = 0; i < getNumGlyphs(); i++) {
+
+ if (!glyphVisible[i]) {
+ // the glyph is not drawn
+ tempLogicalBounds[i] = null;
+ continue;
+ }
+
+ AffineTransform glyphTransform = getGlyphTransform(i);
+ GVTGlyphMetrics glyphMetrics = getGlyphMetrics(i);
+
+ float glyphX = 0;
+ float glyphY = -ascent/scaleFactor;
+ float glyphWidth = (glyphMetrics.getHorizontalAdvance()/
+ scaleFactor);
+ float glyphHeight = (glyphMetrics.getVerticalAdvance()/
+ scaleFactor);
+
+ Rectangle2D glyphBounds = new Rectangle2D.Double(glyphX,
+ glyphY,
+ glyphWidth,
+ glyphHeight);
+
+ if (glyphBounds.isEmpty()) {
+ if (i > 0) {
+ // can't tell if rotated or not, make it the same as
+ // the previous glyph
+ rotated [i] = rotated [i-1];
+ } else {
+ rotated [i] = true;
+ }
+ } else {
+ // get three corner points so we can determine
+ // whether the glyph is rotated
+ Point2D p1 = new Point2D.Double(glyphBounds.getMinX(),
+ glyphBounds.getMinY());
+ Point2D p2 = new Point2D.Double(glyphBounds.getMaxX(),
+ glyphBounds.getMinY());
+ Point2D p3 = new Point2D.Double(glyphBounds.getMinX(),
+ glyphBounds.getMaxY());
+
+ AffineTransform tr = AffineTransform.getTranslateInstance
+ (getGlyphPosition(i).getX(),
+ getGlyphPosition(i).getY());
+
+ if (glyphTransform != null)
+ tr.concatenate(glyphTransform);
+ tr.scale(scaleFactor, scaleFactor);
+
+ tempLogicalBounds[i] = tr.createTransformedShape(glyphBounds);
+
+ Point2D tp1 = new Point2D.Double();
+ Point2D tp2 = new Point2D.Double();
+ Point2D tp3 = new Point2D.Double();
+ tr.transform(p1, tp1);
+ tr.transform(p2, tp2);
+ tr.transform(p3, tp3);
+ double tdx12 = tp1.getX()-tp2.getX();
+ double tdx13 = tp1.getX()-tp3.getX();
+ double tdy12 = tp1.getY()-tp2.getY();
+ double tdy13 = tp1.getY()-tp3.getY();
+
+ if (((Math.abs(tdx12) < 0.001) && (Math.abs(tdy13) < 0.001)) ||
+ ((Math.abs(tdx13) < 0.001) && (Math.abs(tdy12) < 0.001))) {
+ // If either of these are zero then it is axially aligned
+ rotated[i] = false;
+ } else {
+ rotated [i] = true;
+ }
+
+ Rectangle2D rectBounds;
+ rectBounds = tempLogicalBounds[i].getBounds2D();
+ if (rectBounds.getWidth() > maxWidth)
+ maxWidth = rectBounds.getWidth();
+ if (rectBounds.getHeight() > maxHeight)
+ maxHeight = rectBounds.getHeight();
+ }
+ }
+
+ // if appropriate, join adjacent glyph logical bounds
+ GeneralPath logicalBoundsPath = new GeneralPath();
+ for (int i = 0; i < getNumGlyphs(); i++) {
+ if (tempLogicalBounds[i] != null) {
+ logicalBoundsPath.append(tempLogicalBounds[i], false);
+ }
+ }
+
+ logicalBounds = logicalBoundsPath.getBounds2D();
+
+ if (logicalBounds.getHeight() < maxHeight*1.5) {
+ // make all glyphs tops and bottoms the same as the full bounds
+ for (int i = 0; i < getNumGlyphs(); i++) {
+ // first make sure that the glyph logical bounds are
+ // not rotated
+ if (rotated[i]) continue;
+ if (tempLogicalBounds[i] == null) continue;
+
+ Rectangle2D glyphBounds = tempLogicalBounds[i].getBounds2D();
+
+ double x = glyphBounds.getMinX();
+ double width = glyphBounds.getWidth();
+
+ if ((i < getNumGlyphs()-1) &&
+ (tempLogicalBounds[i+1] != null)) {
+ // make this glyph extend to the start of the next one
+ Rectangle2D nextGlyphBounds =
+ tempLogicalBounds[i+1].getBounds2D();
+
+ if (nextGlyphBounds.getX() > x) {
+ // going left to right (this is pretty hoky)
+ width = nextGlyphBounds.getX() - x;
+ } else {
+ double newGlyphX = (nextGlyphBounds.getX() +
+ nextGlyphBounds.getWidth());
+ width += (x - newGlyphX);
+ x = newGlyphX;
+ }
+ }
+
+ tempLogicalBounds[i] = new Rectangle2D.Double
+ (x, logicalBounds.getMinY(),
+ width, logicalBounds.getHeight());
+ }
+ } else if (logicalBounds.getWidth() < maxWidth*1.5) {
+ // make all glyphs left and right edges the same as the full bounds
+ for (int i = 0; i < getNumGlyphs(); i++) {
+ // first make sure that the glyph logical bounds are
+ // not rotated
+ if (rotated[i]) continue;
+ if (tempLogicalBounds[i] == null) continue;
+
+ Rectangle2D glyphBounds = tempLogicalBounds[i].getBounds2D();
+ double y = glyphBounds.getMinY();
+ double height = glyphBounds.getHeight();
+
+ if ((i < getNumGlyphs()-1) &&
+ (tempLogicalBounds[i+1] != null)) {
+ // make this glyph extend to the start of the next one
+ Rectangle2D nextGlyphBounds =
+ tempLogicalBounds[i+1].getBounds2D();
+ if (nextGlyphBounds.getY() > y) { // going top to bottom
+ height = nextGlyphBounds.getY() - y;
+ } else {
+ double newGlyphY = (nextGlyphBounds.getY() +
+ nextGlyphBounds.getHeight());
+ height += (y - newGlyphY);
+ y = newGlyphY;
+ }
+ }
+
+ tempLogicalBounds[i] = new Rectangle2D.Double
+ (logicalBounds.getMinX(), y,
+ logicalBounds.getWidth(), height);
+ }
+ }
+
+ for (int i = 0; i < getNumGlyphs(); i++) {
+ glyphLogicalBounds[i] = tempLogicalBounds[i];
+ }
+ }
+
+ /**
+ * Returns the metrics of the glyph at the specified index into this
+ * GVTGlyphVector.
+ */
+ public GVTGlyphMetrics getGlyphMetrics(int glyphIndex) {
+ if (glyphMetrics[glyphIndex] == null) {
+/*
+ GlyphMetrics gm = awtGlyphVector.getGlyphMetrics(glyphIndex);
+ Rectangle2D gmB = gm.getBounds2D();
+*/
+ // -- start glyph cache code --
+ Point2D glyphPos = defaultGlyphPositions[glyphIndex];
+ char c = ci.setIndex(ci.getBeginIndex()+glyphIndex);
+ ci.setIndex(ci.getBeginIndex());
+ AWTGlyphGeometryCache.Value v = AWTGVTFont.getGlyphGeometry
+ (gvtFont, c, awtGlyphVector, glyphIndex, glyphPos);
+ Rectangle2D gmB = v.getBounds2D();
+ // -- end glyph cache code --
+
+ Rectangle2D bounds = new Rectangle2D.Double
+ (gmB.getX() * scaleFactor, gmB.getY() * scaleFactor,
+ gmB.getWidth() * scaleFactor, gmB.getHeight() * scaleFactor);
+
+ // defaultGlyphPositions has one more entry than glyphs
+ // the last entry stores the total advance for the
+ // glyphVector.
+ float adv = (float)(defaultGlyphPositions[glyphIndex+1].getX()-
+ defaultGlyphPositions[glyphIndex] .getX());
+ glyphMetrics[glyphIndex] = new GVTGlyphMetrics
+ (adv*scaleFactor, (ascent+descent),
+ bounds, GlyphMetrics.STANDARD);
+ }
+ return glyphMetrics[glyphIndex];
+ }
+
+ /**
+ * Returns a Shape whose interior corresponds to the visual representation
+ * of the specified glyph within this GlyphVector.
+ */
+ public Shape getGlyphOutline(int glyphIndex) {
+ if (glyphOutlines[glyphIndex] == null) {
+/*
+ Shape glyphOutline = awtGlyphVector.getGlyphOutline(glyphIndex);
+*/
+ // -- start glyph cache code --
+ Point2D glyphPos = defaultGlyphPositions[glyphIndex];
+ char c = ci.setIndex(ci.getBeginIndex()+glyphIndex);
+ ci.setIndex(ci.getBeginIndex());
+ AWTGlyphGeometryCache.Value v = AWTGVTFont.getGlyphGeometry
+ (gvtFont, c, awtGlyphVector, glyphIndex, glyphPos);
+ Shape glyphOutline = v.getOutline();
+ // -- end glyph cache code --
+
+ AffineTransform tr = AffineTransform.getTranslateInstance
+ (getGlyphPosition(glyphIndex).getX(),
+ getGlyphPosition(glyphIndex).getY());
+
+ AffineTransform glyphTransform = getGlyphTransform(glyphIndex);
+
+ if (glyphTransform != null) {
+ tr.concatenate(glyphTransform);
+ }
+ //
+ // <!> HACK
+ //
+ // GlyphVector.getGlyphOutline behavior changes between 1.3 and 1.4
+ //
+ // I've looked at this problem a bit more and the incorrect glyph
+ // positioning in Batik is definitely due to the change in
+ // behavior of GlyphVector.getGlyphOutline(glyphIndex). It used to
+ // return the outline of the glyph at position 0,0 which meant
+ // that we had to translate it to the actual glyph position before
+ // drawing it. Now, it returns the outline which has already been
+ // positioned.
+ //
+ // -- Bella
+ //
+/*
+ if (outlinesPositioned()) {
+ Point2D glyphPos = defaultGlyphPositions[glyphIndex];
+ tr.translate(-glyphPos.getX(), -glyphPos.getY());
+ }
+*/
+ tr.scale(scaleFactor, scaleFactor);
+ glyphOutlines[glyphIndex]=tr.createTransformedShape(glyphOutline);
+ }
+
+ return glyphOutlines[glyphIndex];
+ }
+
+ private static final boolean outlinesPositioned;
+ private static final boolean glyphVectorTransformWorks;
+
+ static {
+ String s = System.getProperty("java.specification.version");
+ if ("1.4".compareTo(s) <= 0) {
+ outlinesPositioned = true;
+ glyphVectorTransformWorks = true;
+ } else if ("Mac OS X".equals(System.getProperty("os.name"))) {
+ outlinesPositioned = true;
+ glyphVectorTransformWorks = false; // Note sure about this...
+ } else {
+ outlinesPositioned = false;
+ glyphVectorTransformWorks = false;
+ }
+ }
+
+ static boolean outlinesPositioned() {
+ return outlinesPositioned;
+ }
+
+ /**
+ * Returns the position of the specified glyph within this GlyphVector.
+ */
+ public Point2D getGlyphPosition(int glyphIndex) {
+ return glyphPositions[glyphIndex];
+ }
+
+ /**
+ * Returns an array of glyph positions for the specified glyphs
+ */
+ public float[] getGlyphPositions(int beginGlyphIndex,
+ int numEntries,
+ float[] positionReturn) {
+
+ if (positionReturn == null) {
+ positionReturn = new float[numEntries*2];
+ }
+
+ for (int i = beginGlyphIndex; i < (beginGlyphIndex+numEntries); i++) {
+ Point2D glyphPos = getGlyphPosition(i);
+ positionReturn[(i-beginGlyphIndex)*2] = (float)glyphPos.getX();
+ positionReturn[(i-beginGlyphIndex)*2 + 1] = (float)glyphPos.getY();
+ }
+
+ return positionReturn;
+ }
+
+ /**
+ * Gets the transform of the specified glyph within this GlyphVector.
+ */
+ public AffineTransform getGlyphTransform(int glyphIndex) {
+ return glyphTransforms[glyphIndex];
+ }
+
+ /**
+ * Returns the visual bounds of the specified glyph within the GlyphVector.
+ */
+ public Shape getGlyphVisualBounds(int glyphIndex) {
+ if (glyphVisualBounds[glyphIndex] == null) {
+/*
+ Shape glyphOutline = awtGlyphVector.getGlyphOutline(glyphIndex);
+ Rectangle2D glyphBounds = glyphOutline.getBounds2D();
+*/
+ // -- start glyph cache code --
+ Point2D glyphPos = defaultGlyphPositions[glyphIndex];
+ char c = ci.setIndex(ci.getBeginIndex()+glyphIndex);
+ ci.setIndex(ci.getBeginIndex());
+ AWTGlyphGeometryCache.Value v = AWTGVTFont.getGlyphGeometry
+ (gvtFont, c, awtGlyphVector, glyphIndex, glyphPos);
+ Rectangle2D glyphBounds = v.getOutlineBounds2D();
+ // -- end glyph cache code --
+
+ AffineTransform tr = AffineTransform.getTranslateInstance
+ (getGlyphPosition(glyphIndex).getX(),
+ getGlyphPosition(glyphIndex).getY());
+
+ AffineTransform glyphTransform = getGlyphTransform(glyphIndex);
+ if (glyphTransform != null) {
+ tr.concatenate(glyphTransform);
+ }
+ tr.scale(scaleFactor, scaleFactor);
+ glyphVisualBounds[glyphIndex] =
+ tr.createTransformedShape(glyphBounds);
+ }
+
+ return glyphVisualBounds[glyphIndex];
+ }
+
+ /**
+ * Returns the number of glyphs in this GlyphVector.
+ */
+ public int getNumGlyphs() {
+ return awtGlyphVector.getNumGlyphs();
+ }
+
+ /**
+ * Returns a Shape whose interior corresponds to the visual representation
+ * of this GlyphVector.
+ */
+ public Shape getOutline() {
+ if (outline == null) {
+ outline = new GeneralPath();
+ for (int i = 0; i < getNumGlyphs(); i++) {
+ if (glyphVisible[i]) {
+ Shape glyphOutline = getGlyphOutline(i);
+ outline.append(glyphOutline, false);
+ }
+ }
+ }
+
+ return outline;
+ }
+
+ /**
+ * Returns a Shape whose interior corresponds to the visual representation
+ * of this GlyphVector, offset to x, y.
+ */
+ public Shape getOutline(float x, float y) {
+ Shape outline = getOutline();
+ AffineTransform tr = AffineTransform.getTranslateInstance(x,y);
+ outline = tr.createTransformedShape(outline);
+ return outline;
+ }
+
+ /**
+ * Returns the visual bounds of this GlyphVector The visual bounds is the
+ * tightest rectangle enclosing all non-background pixels in the rendered
+ * representation of this GlyphVector.
+ */
+ public Rectangle2D getGeometricBounds() {
+ if (visualBounds == null) {
+ Shape outline = getOutline();
+ visualBounds = outline.getBounds2D();
+ }
+ return visualBounds;
+ }
+
+ /**
+ * Assigns default positions to each glyph in this GlyphVector.
+ */
+ public void performDefaultLayout() {
+ if (defaultGlyphPositions == null) {
+ awtGlyphVector.performDefaultLayout();
+ defaultGlyphPositions = new Point2D.Float[getNumGlyphs()+1];
+ for (int i = 0; i <= getNumGlyphs(); i++)
+ defaultGlyphPositions[i] = awtGlyphVector.getGlyphPosition(i);
+ }
+
+ outline = null;
+ visualBounds = null;
+ logicalBounds = null;
+ bounds2D = null;
+ float shiftLeft = 0;
+ int i=0;
+ for (; i < getNumGlyphs(); i++) {
+ glyphTransforms [i] = null;
+ glyphVisualBounds [i] = null;
+ glyphLogicalBounds[i] = null;
+ glyphOutlines [i] = null;
+ glyphMetrics [i] = null;
+ Point2D glyphPos = defaultGlyphPositions[i];
+ glyphPositions[i] = new Point2D.Float
+ ((float)((glyphPos.getX() * scaleFactor)-shiftLeft),
+ (float) (glyphPos.getY() * scaleFactor));
+
+ // if c is a transparent arabic char then need to shift the
+ // following glyphs left so that the current glyph is overwritten
+ char c = ci.setIndex(i + ci.getBeginIndex());
+ if (ArabicTextHandler.arabicCharTransparent(c)) {
+ shiftLeft += getGlyphMetrics(i).getHorizontalAdvance();
+ }
+ }
+
+ // Need glyph pos for point after last char...
+ Point2D glyphPos = defaultGlyphPositions[i];
+ glyphPositions[i] = new Point2D.Float
+ ((float)((glyphPos.getX() * scaleFactor)-shiftLeft),
+ (float) (glyphPos.getY() * scaleFactor));
+ }
+
+ /**
+ * Sets the position of the specified glyph within this GlyphVector.
+ */
+ public void setGlyphPosition(int glyphIndex, Point2D newPos) {
+ glyphPositions[glyphIndex] =
+ new Point2D.Float((float)newPos.getX(), (float)newPos.getY());
+ outline = null;
+ visualBounds = null;
+ logicalBounds = null;
+ bounds2D = null;
+
+ if (glyphIndex != getNumGlyphs()) {
+ glyphVisualBounds [glyphIndex] = null;
+ glyphLogicalBounds[glyphIndex] = null;
+ glyphOutlines [glyphIndex] = null;
+ glyphMetrics [glyphIndex] = null;
+ }
+ }
+
+ /**
+ * Sets the transform of the specified glyph within this GlyphVector.
+ */
+ public void setGlyphTransform(int glyphIndex, AffineTransform newTX) {
+ glyphTransforms[glyphIndex] = newTX;
+ outline = null;
+ visualBounds = null;
+ logicalBounds = null;
+ bounds2D = null;
+
+ glyphVisualBounds [glyphIndex] = null;
+ glyphLogicalBounds[glyphIndex] = null;
+ glyphOutlines [glyphIndex] = null;
+ glyphMetrics [glyphIndex] = null;
+ }
+
+ /**
+ * Tells the glyph vector whether or not to draw the specified glyph.
+ */
+ public void setGlyphVisible(int glyphIndex, boolean visible) {
+ if (visible == glyphVisible[glyphIndex])
+ return;
+ glyphVisible[glyphIndex] = visible;
+ outline = null;
+ visualBounds = null;
+ logicalBounds = null;
+ bounds2D = null;
+
+ glyphVisualBounds [glyphIndex] = null;
+ glyphLogicalBounds[glyphIndex] = null;
+ glyphOutlines [glyphIndex] = null;
+ glyphMetrics [glyphIndex] = null;
+ }
+
+ /**
+ * Returns true if specified glyph will be rendered.
+ */
+ public boolean isGlyphVisible(int glyphIndex) {
+ return glyphVisible[glyphIndex];
+ }
+
+ /**
+ * Returns the number of chars represented by the glyphs within the
+ * specified range.
+ *
+ * @param startGlyphIndex The index of the first glyph in the range.
+ * @param endGlyphIndex The index of the last glyph in the range.
+ * @return The number of chars.
+ */
+ public int getCharacterCount(int startGlyphIndex, int endGlyphIndex) {
+ if (startGlyphIndex < 0) {
+ startGlyphIndex = 0;
+ }
+ if (endGlyphIndex >= getNumGlyphs()) {
+ endGlyphIndex = getNumGlyphs()-1;
+ }
+ int charCount = 0;
+ int start = startGlyphIndex+ci.getBeginIndex();
+ int end = endGlyphIndex+ci.getBeginIndex();
+
+ for (char c = ci.setIndex(start); ci.getIndex() <= end; c=ci.next()) {
+ if (ArabicTextHandler.isLigature(c)) {
+ charCount += ArabicTextHandler.getNumChars(c);
+ } else {
+ charCount++;
+ }
+ }
+
+ return charCount;
+ }
+
+ /**
+ * Draws this glyph vector.
+ */
+ public void draw(Graphics2D graphics2D,
+ AttributedCharacterIterator aci) {
+ int numGlyphs = getNumGlyphs();
+
+ aci.first();
+ Paint fillPaint = (Paint)aci.getAttribute(TextAttribute.FOREGROUND);
+ Stroke stroke = (Stroke) aci.getAttribute
+ (GVTAttributedCharacterIterator.TextAttribute.STROKE);
+ Paint strokePaint = (Paint) aci.getAttribute
+ (GVTAttributedCharacterIterator.TextAttribute.STROKE_PAINT);
+ if ((fillPaint == null) && ((strokePaint == null) ||
+ (stroke == null)))
+ return;
+
+ boolean useHinting = true;
+ if ((stroke != null) && (strokePaint != null))
+ useHinting = false;
+
+ if (useHinting &&
+ (fillPaint != null) && !(fillPaint instanceof Color))
+ // The coordinate system is different for drawGlyphVector.
+ // So complex paints aren't positioned properly.
+ useHinting = false;
+
+ final int typeGRot = AffineTransform.TYPE_GENERAL_ROTATION;
+ final int typeGTrans = AffineTransform.TYPE_GENERAL_TRANSFORM;
+ if (useHinting) {
+ // Check if usr->dev transform has general rotation,
+ // or shear..
+ AffineTransform at = graphics2D.getTransform();
+ int type = at.getType();
+ if (((type & typeGTrans) != 0) || ((type & typeGRot) != 0))
+ useHinting = false;
+ }
+
+ if (useHinting) {
+ double [] mat = new double[4];
+ for (int i=0; i<numGlyphs; i++) {
+ if (!glyphVisible[i]) {
+ useHinting = false;
+ break;
+ }
+ AffineTransform at = glyphTransforms[i];
+ if (at != null) {
+ int type = at.getType();
+ if ((type & ~AffineTransform.TYPE_TRANSLATION) == 0) {
+ // Just translation
+ } else if (glyphVectorTransformWorks &&
+ ((type & typeGTrans) == 0) &&
+ ((type & typeGRot) == 0)) {
+ // It's a simple 90Deg rotate, and we can put
+ // it into the GlyphVector.
+ } else {
+ // we can't (or it doesn't make sense
+ // to use the GlyphVector.
+ useHinting = false;
+ break;
+ }
+ }
+ }
+ }
+
+ if (useHinting) {
+ double sf = scaleFactor;
+ double [] mat = new double[6];
+ for (int i=0; i< numGlyphs; i++) {
+ Point2D pos = glyphPositions[i];
+ double x = pos.getX();
+ double y = pos.getY();
+ AffineTransform at = glyphTransforms[i];
+ if (at != null) {
+ // Scale the translate portion of matrix,
+ // and add it into the position.
+ at.getMatrix(mat);
+ x += mat[4];
+ y += mat[5];
+ if ((mat[0] != 1) || (mat[1] != 0) ||
+ (mat[2] != 0) || (mat[3] != 1)) {
+ // More than just translation.
+ mat[4] = 0; mat[5] = 0;
+ at = new AffineTransform(mat);
+ } else {
+ at = null;
+ }
+ }
+ pos = new Point2D.Double(x/sf, y/sf);
+ awtGlyphVector.setGlyphPosition(i, pos);
+ awtGlyphVector.setGlyphTransform(i, at);
+ }
+ graphics2D.scale(sf, sf);
+ graphics2D.setPaint(fillPaint);
+ graphics2D.drawGlyphVector(awtGlyphVector, 0, 0);
+ graphics2D.scale(1/sf, 1/sf);
+
+ for (int i=0; i< numGlyphs; i++) {
+ Point2D pos = defaultGlyphPositions[i];
+ awtGlyphVector.setGlyphPosition(i, pos);
+ awtGlyphVector.setGlyphTransform(i, null);
+ }
+
+ } else {
+ Shape outline = getOutline();
+
+ // check if we need to fill this glyph
+ if (fillPaint != null) {
+ graphics2D.setPaint(fillPaint);
+ graphics2D.fill(outline);
+ }
+
+ // check if we need to draw the outline of this glyph
+ if (stroke != null && strokePaint != null) {
+ graphics2D.setStroke(stroke);
+ graphics2D.setPaint(strokePaint);
+ graphics2D.draw(outline);
+ }
+ }
+ }
+}
---------------------------------------------------------------------
To unsubscribe, e-mail: batik-dev-unsubscribe@xml.apache.org
For additional commands, e-mail: batik-dev-help@xml.apache.org