Application: gvSIG desktop

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2005 IVER T.I. and Generalitat Valenciana.

 *

 * This program 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

 * of the License, or (at your option) any later version.

 *

 * This program 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 this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

/* CVS MESSAGES:

*

* $Id: TextPath.java 21105 2008-06-03 10:20:03Z vcaballero $

* $Log$

* Revision 1.2  2007-03-09 11:20:57  jaume

* Advanced symbology (start committing)

*

* Revision 1.1.2.3  2007/02/21 07:34:09  jaume

* labeling starts working

*

* Revision 1.1.2.2  2007/02/09 07:47:05  jaume

* Isymbol moved

*

* Revision 1.1.2.1  2007/02/06 17:01:04  jaume

* first version (only lines)

*

*

*/

package org.gvsig.fmap.mapcontext.rendering.legend.styling;

import java.awt.Font;

import java.awt.Graphics2D;

import java.awt.font.FontRenderContext;

import java.awt.font.GlyphVector;

import java.awt.geom.Point2D;

import org.apache.batik.ext.awt.geom.PathLength;

import org.apache.log4j.Logger;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.mapcontext.Messages;

import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;

import org.gvsig.fmap.mapcontext.rendering.symbols.ITextSymbol;

/**

 * <p>Class that represents baseline of a string and allows the baseline to

 * be composed as contiguous segments with distinct slope each.<br></p>

 *

 * <p>Once a TextPath is created for a string it is possible to know where

 * the character at a determined position in the string is placed and

 * rotated.<br></p>

 *

 * @author jaume dominguez faus - jaume.dominguez@iver.es

 *

 */

public class TextPath {

        public static final int NO_POS = -9999;

        private char[] text;

        private double[][] pos;

        private int alignment;

        private float characterSpacing;

        private boolean kerning;

        private float wordSpacing;

        private float margin;

        private boolean rightToLeft;

        private int numGlyphs;

        private float characterWidth;

        /**

         * <p>Creates a new instance of TextPath with the current graphics

         * context.<br></p>

         *

         * <p>Given a <b>Graphics2D</b>, TextPath can know which Font and FontRenderContext

         * is in use. So, it can calculate the position and rotation of each

         * character in <b>char[] text</b> based in the path defined by the

         * <b>FShape path</b> argument.</p>

         * @param g, Graphics2D

         * @param path, FShape

         * @param text, char[]

         */

        public TextPath(Graphics2D g, Geometry path, char[] text, Font font,

                        float characterSpacing, float characterWidth, boolean kerning,

                        float leading, int alignment, float wordSpacing, float margin,

                        boolean rightToLeft) {

                this.text = text;

                if (alignment == ITextSymbol.SYMBOL_STYLE_ALIGNMENT_LEFT ||

                                alignment == ITextSymbol.SYMBOL_STYLE_ALIGNMENT_RIGHT ||

                                alignment == ITextSymbol.SYMBOL_STYLE_ALIGNMENT_CENTERED ||

                                alignment == ITextSymbol.SYMBOL_STYLE_ALIGNMENT_JUSTIFY) {

                        this.alignment = alignment;

                } else throw new IllegalArgumentException(

                                Messages.getString("invalid_value_for") + ": " +

                                Messages.getString("alignment")+" ( "+alignment+")");

                this.characterWidth = characterWidth;

                this.characterSpacing = characterSpacing;

                this.kerning = kerning;

                this.wordSpacing = wordSpacing;

                this.margin = margin;

                this.rightToLeft = rightToLeft;

                compute(g, path);

        }

        /**

         * Initializes the position vector.

         * @param g

         * @param path

         */

        private void compute(Graphics2D g, Geometry path) {

                PathLength pl = new PathLength(path);

                Font font = g.getFont();

                FontRenderContext frc = g.getFontRenderContext();

                /* java 6 code

                 * TODO keep this!!

                if (kerning) {

                        HashMap<TextAttribute, Object> attrs = new HashMap<TextAttribute, Object>();

                        attrs.put(TextAttribute.KERNING , TextAttribute.KERNING_ON);

                }

                */

                GlyphVector gv = font.createGlyphVector(frc, text);

                numGlyphs = gv.getNumGlyphs();

                pos = new double[numGlyphs][3];

                float[] charAnchors = new float[numGlyphs];

                float leftMargin = 0;

                float rightMargin = 0;

                // first compute margins and substract it to the distance available

                // for the glyphs

                if (alignment == ITextSymbol.SYMBOL_STYLE_ALIGNMENT_LEFT) {

                        leftMargin = margin;

                } else if (alignment == ITextSymbol.SYMBOL_STYLE_ALIGNMENT_CENTERED){

                        float halfMargin = margin*0.5f;

                        leftMargin = halfMargin;

                        rightMargin = halfMargin;

                } else if (alignment == ITextSymbol.SYMBOL_STYLE_ALIGNMENT_RIGHT) {

                        rightMargin = margin;

                }

                String[] words = new String(text).split(" +");

                float spaceBetweenAllWords = words.length * wordSpacing;

                float spaceBetweenAllChars = 0;

                for (int i = 0; i < words.length; i++) {

                        spaceBetweenAllChars += words[i].length()*characterSpacing;

                }

                float lengthOfPath = pl.lengthOfPath();

                float lineLength = (lengthOfPath / numGlyphs)

                                                                - leftMargin

                                                                - rightMargin

                                                                - spaceBetweenAllWords

                                                                - spaceBetweenAllChars;

                float invLineLength = 1/lineLength;

                float charDistance = leftMargin;

                int charsCosumed = 0;

                for (int i = 0; i < words.length; i++) {

                        charAnchors[charsCosumed++] = charDistance;

                        for (int j = 1; j < words[i].length(); j++) {

                                charDistance += invLineLength*j+characterSpacing;

                                charAnchors[charsCosumed] = charDistance;

                                charDistance += Math.max(gv.getGlyphMetrics(charsCosumed).getAdvance(), characterWidth);

                                charsCosumed++;

                        }

                        charDistance += wordSpacing;

                        charsCosumed++;

                }

//                for (int i = 0; i < numGlyphs; i++) {

//                        if (text[i] == ' ') {

//                                charDistance += wordSpacing;

//                                charAnchors[i] = charDistance;

//                                while (i<numGlyphs && text[i+1] == ' ') i++;

//                        } else {

////                                if (!spaced && i > 0) {

//                                        // not to apply the character spacing if this is the first character of a word

//                                        charDistance += characterSpacing;

////                                }

//                                charDistance += invLineLength*i;

//

//                                charAnchors[i] = charDistance;

//

//                                charDistance += Math.max(gv.getGlyphMetrics(i).getAdvance(), characterWidth);

//                        }

//                }

                for (int i = 0; i < charAnchors.length; i++) {

                        float anchor = (rightToLeft) ? charAnchors[charAnchors.length-1-i] : charAnchors[i];

                        Point2D p = pl.pointAtLength( anchor );

                        if (p == null) {

                                Logger.getLogger(getClass()).error(

                                                Messages.getString("glyph_distance_out_of_range")+" "+anchor);

                                pos[i][0] = NO_POS;

                                pos[i][1] = NO_POS;

                                continue;

                        }

                        pos[i][0] = p.getX();

                        pos[i][1] = p.getY();

                        pos[i][2] = pl.angleAtLength( anchor );

                }

        }

        /**

         * <p>Returns the placement of the next character to draw and the corresponding

         * rotation in a double array of three elements with this order:</p><br>

         *

         * <p><b>double[0]</b> Position in X in the screen</p>

         * <p><b>double[1]</b> Position in Y in the screen</p>

         * <p><b>double[2]</b> Angle of the character.</p>

         * @return

         */

        public double[] nextPosForGlyph(int glyphIndex) {

                return pos[glyphIndex];

        }

        public int getGlyphCount() {

                return numGlyphs;

        }

}