path: root/awt/org/apache/harmony/awt/gl/font/CommonGlyphVector.java

/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
/**
 * @author Ilya S. Okomin
 * @version $Revision$
 */
package org.apache.harmony.awt.gl.font;

import java.awt.Font;
import java.awt.Rectangle;
import java.awt.Shape;
import java.awt.font.FontRenderContext;
import java.awt.font.GlyphJustificationInfo;
import java.awt.font.GlyphMetrics;
import java.awt.font.GlyphVector;
import java.awt.geom.AffineTransform;
import java.awt.geom.GeneralPath;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;

import org.apache.harmony.awt.internal.nls.Messages;

/**
 * GlyphVector implementation
 */
public class CommonGlyphVector extends GlyphVector {

    // array of transforms of glyphs in GlyphVector
    protected AffineTransform[] glsTransforms;

    // array of chars defined in constructor
    public char[] charVector;

    // array of Glyph objects, that describe information about glyphs
    public Glyph[] vector;

    // array of default positions of glyphs in GlyphVector
    // without applying GlyphVector's transform
    float[] defaultPositions;

    // array of logical positions of glyphs in GlyphVector

    float[] logicalPositions;

    // array of visual (real) positions of glyphs in GlyphVector
    public float[] visualPositions;

    // FontRenderContext for this vector.
    protected FontRenderContext vectorFRC;

    // layout flags mask
    protected int layoutFlags = 0;

    // array of cached glyph outlines 
    protected Shape[] gvShapes;

    FontPeerImpl peer;

    // font corresponding to the GlyphVector 
    Font font;

    // ascent of the font
    float ascent;

    // height of the font
    float height;
    
    // leading of the font
    float leading;
    
    // descent of the font
    float descent;

    // transform of the GlyphVector
    AffineTransform transform;

    /**
     * Creates new CommonGlyphVector object from the specified parameters.
     * 
     * @param chars an array of chars
     * @param frc FontRenderContext object
     * @param fnt Font object
     * @param flags layout flags
     */
    @SuppressWarnings("deprecation")
    public CommonGlyphVector(char[] chars, FontRenderContext frc, Font fnt,
            int flags) {
        int len = chars.length;

        this.font = fnt;
        this.transform = fnt.getTransform();
        this.peer = (FontPeerImpl) fnt.getPeer();

        gvShapes = new Shape[len];

        // !! As pointed in API documentation for the 
        // getGlyphPosisitions(int index,int numEntries, float[] positionReturn) 
        // and getGlyphPosition(int index) methods, if the index is equals to 
        // the number of glyphs the position after the last glyph must be 
        // returned, thus there are n+1 positions and last (n+1) position 
        // points to the end of GlyphVector.

        logicalPositions = new float[(len+1)<<1];
        visualPositions = new float[(len+1)<<1];
        defaultPositions = new float[(len+1)<<1];

        glsTransforms = new AffineTransform[len];

        this.charVector = chars;
        this.vectorFRC = frc;
        //LineMetricsImpl lmImpl = (LineMetricsImpl)peer.getLineMetrics();

        LineMetricsImpl lmImpl = (LineMetricsImpl)fnt.getLineMetrics(String.valueOf(chars), frc);

        this.ascent = lmImpl.getAscent();
        this.height = lmImpl.getHeight();
        this.leading = lmImpl.getLeading();
        this.descent = lmImpl.getDescent();
        this.layoutFlags = flags;

        if ((flags & Font.LAYOUT_RIGHT_TO_LEFT) != 0){
            char vector[] = new char[len];
            for(int i=0; i < len; i++){
                vector[i] = chars[len-i-1];
            }
            this.vector = peer.getGlyphs(vector);

        } else {
            this.vector = peer.getGlyphs(chars);
        }

        this.glsTransforms = new AffineTransform[len];

        setDefaultPositions();
        performDefaultLayout();
    }

    /**
     * Creates new CommonGlyphVector object from the specified parameters. 
     * Layout flags set to default.
     * 
     * @param chars an array of chars
     * @param frc FontRenderContext object
     * @param fnt Font object
     */
    public CommonGlyphVector(char[] chars, FontRenderContext frc, Font fnt) {
        this(chars, frc, fnt, 0);
    }

    /**
     * Creates new CommonGlyphVector object from the specified parameters. 
     * Layout flags set to default.
     * 
     * @param str specified string
     * @param frc FontRenderContext object
     * @param fnt Font object
     */
    public CommonGlyphVector(String str, FontRenderContext frc, Font fnt) {
        this(str.toCharArray(), frc, fnt, 0);
    }

    /**
     * Creates new CommonGlyphVector object from the specified parameters.
     * 
     * @param str specified string
     * @param frc FontRenderContext object
     * @param fnt Font object
     * @param flags layout flags
     */
    public CommonGlyphVector(String str, FontRenderContext frc, Font fnt, int flags) {
        this(str.toCharArray(), frc, fnt, flags);
    }

    /**
     * Set array of logical positions of the glyphs to
     * default with their default advances and height.
     */
    void setDefaultPositions(){
        int len = getNumGlyphs();

        // First [x,y] is set into [0,0] position
        // for this reason start index is 1
        for (int i=1; i <= len; i++ ){
                int idx = i << 1;
                float advanceX = vector[i-1].getGlyphPointMetrics().getAdvanceX();
                float advanceY = vector[i-1].getGlyphPointMetrics().getAdvanceY();

                defaultPositions[idx] = defaultPositions[idx-2] + advanceX;
                defaultPositions[idx+1] = defaultPositions[idx-1] + advanceY;

        }
        transform.transform(defaultPositions, 0, logicalPositions, 0, getNumGlyphs()+1);

    }

    /**
     * Returnes the pixel bounds of this GlyphVector rendered at the 
     * specified x,y location with the given FontRenderContext.
     *  
     * @param frc a FontRenderContext that is used
     * @param x specified x coordinate value
     * @param y specified y coordinate value
     * @return a Rectangle that bounds pixels of this GlyphVector
     */
    @Override
    public Rectangle getPixelBounds(FontRenderContext frc, float x, float y) {

        double xM, yM, xm, ym;

        double minX = 0;
        double minY = 0;
        double maxX = 0;
        double maxY = 0;

        for (int i = 0; i < this.getNumGlyphs(); i++) {
            Rectangle glyphBounds = this.getGlyphPixelBounds(i, frc, 0, 0);
            xm = glyphBounds.getMinX();
            ym = glyphBounds.getMinY();
            xM = glyphBounds.getMaxX();
            yM = glyphBounds.getMaxY();

            if (i == 0) {
                minX = xm;
                minY = ym;
                maxX = xM;
                maxY = yM;
            }

            if (minX > xm) {
                minX = xm;
            }
            if (minY > ym) {
                minY = ym;
            }
            if (maxX < xM) {
                maxX = xM;
            }
            if (maxY < yM) {
                maxY = yM;
            }
        }
        return new Rectangle((int)(minX + x), (int)(minY + y), (int)(maxX - minX), (int)(maxY - minY));

    }

    /**
     * Returns the visual bounds of this GlyphVector.
     * The visual bounds is the bounds of the total outline of 
     * this GlyphVector.
     * @return a Rectangle2D that id the visual bounds of this GlyphVector
     */
    @Override
    public Rectangle2D getVisualBounds() {
        float xM, yM, xm, ym;
        float minX = 0;
        float minY = 0;
        float maxX = 0;
        float maxY = 0;
        boolean firstIteration = true;

        for (int i = 0; i < this.getNumGlyphs(); i++) {
            Rectangle2D bounds = this.getGlyphVisualBounds(i).getBounds2D();
            if (bounds.getWidth() == 0){
                continue;
            }
            xm = (float)bounds.getX();
            ym = (float)bounds.getY();

            xM = (float)(xm + bounds.getWidth());

            yM = ym + (float) bounds.getHeight();

            if (firstIteration) {
                minX = xm;
                minY = ym;
                maxX = xM;
                maxY = yM;
                firstIteration = false;
            } else {
                if (minX > xm) {
                    minX = xm;
                }
                if (minY > ym) {
                    minY = ym;
                }
                if (maxX < xM) {
                    maxX = xM;
                }
                if (maxY < yM) {
                    maxY = yM;
                }

            }
        }

        return (this.getNumGlyphs() != 0) ? new Rectangle2D.Float(minX, minY,
                (maxX - minX), (maxY - minY)) : null;
    }

    /**
     * Sets new position to the specified glyph.
     */
    @Override
    public void setGlyphPosition(int glyphIndex, Point2D newPos) {
        if ((glyphIndex > vector.length) || (glyphIndex < 0)) {
            // awt.43=glyphIndex is out of vector's limits
            throw new IndexOutOfBoundsException(Messages.getString("awt.43")); //$NON-NLS-1$
        }
        float x = (float)newPos.getX();
        float y = (float)newPos.getY();
        int index = glyphIndex << 1;

        if ((x != visualPositions[index]) || (y != visualPositions[index + 1])){
            visualPositions[index] = x;
            visualPositions[index+1] = y;
            layoutFlags = layoutFlags | FLAG_HAS_POSITION_ADJUSTMENTS;
        }

    }

    /**
     * Returns the position of the specified glyph relative to the origin of
     * this GlyphVector
     * @return a Point2D that the origin of the glyph with specified index
     */
    @Override
    public Point2D getGlyphPosition(int glyphIndex) {
        if ((glyphIndex > vector.length) || (glyphIndex < 0)) {
            // awt.43=glyphIndex is out of vector's limits
            throw new IndexOutOfBoundsException(Messages.getString("awt.43")); //$NON-NLS-1$
        }
        int index = glyphIndex << 1;
        Point2D pos = new Point2D.Float(visualPositions[index], visualPositions[index+1]);

        // For last position we don't have to transform !!
        if(glyphIndex==vector.length){
            return pos;
        }

        AffineTransform at = getGlyphTransform(glyphIndex);
        if ((at == null) || (at.isIdentity())){
            return pos;
        }

        pos.setLocation(pos.getX() + at.getTranslateX(), pos.getY() + at.getTranslateY());

        return pos;
    }

    /**
     * Sets new transform to the specified glyph.
     * 
     * @param glyphIndex specified index of the glyph
     * @param trans AffineTransform of the glyph with specified index
     */
    @Override
    public void setGlyphTransform(int glyphIndex, AffineTransform trans) {
        if ((glyphIndex >= vector.length) || (glyphIndex < 0)) {
            // awt.43=glyphIndex is out of vector's limits
            throw new IndexOutOfBoundsException(Messages.getString("awt.43")); //$NON-NLS-1$
        }

        if ((trans == null) || (trans.isIdentity())) {
            glsTransforms[glyphIndex] = null;
        } else {
            glsTransforms[glyphIndex] = new AffineTransform(trans);
            layoutFlags = layoutFlags | FLAG_HAS_TRANSFORMS;
        }
    }

    /**
     * Returns the affine transform of the specified glyph.
     * 
     * @param glyphIndex specified index of the glyph
     * @return an AffineTransform of the glyph with specified index
     */
    @Override
    public AffineTransform getGlyphTransform(int glyphIndex) {
        if ((glyphIndex >= this.vector.length) || (glyphIndex < 0)) {
            // awt.43=glyphIndex is out of vector's limits
            throw new IndexOutOfBoundsException(Messages.getString("awt.43")); //$NON-NLS-1$
        }
        return this.glsTransforms[glyphIndex];
    }

    /**
     * Returns the metrics of the specified glyph.
     * 
     * @param glyphIndex specified index of the glyph
     */
    @Override
    public GlyphMetrics getGlyphMetrics(int glyphIndex) {

        if ((glyphIndex < 0) || ((glyphIndex) >= this.getNumGlyphs())) {
            // awt.43=glyphIndex is out of vector's limits
            throw new IndexOutOfBoundsException(Messages.getString("awt.43")); //$NON-NLS-1$
        }
        // TODO: is there a sence in GlyphMetrics
        // if certain glyph or Font has a transform??
        return this.vector[glyphIndex].getGlyphMetrics();
    }

    /**
     * Returns a justification information for the glyph with specified glyph 
     * index.
     * @param glyphIndex index of a glyph which GlyphJustificationInfo is to be 
     * received   
     * @return a GlyphJustificationInfo object that contains glyph justification 
     * properties of the specified glyph
     */
    @Override
    public GlyphJustificationInfo getGlyphJustificationInfo(int glyphIndex) {
        // TODO : Find out the source of Justification info
        if (true) {
            throw new RuntimeException("Method is not implemented"); //$NON-NLS-1$
        }
        return null;
    }

    /**
     * Returns the FontRenderContext parameter of this GlyphVector.
     */
    @Override
    public FontRenderContext getFontRenderContext() {
        return this.vectorFRC;
    }

    /**
     * Returns the visual bounds of the specified glyph.
     * 
     * @param glyphIndex specified index of the glyph
     */
    @Override
    public Shape getGlyphVisualBounds(int glyphIndex) {
        if ((glyphIndex < 0) || (glyphIndex >= this.getNumGlyphs())) {
            // awt.43=glyphIndex is out of vector's limits
            throw new IndexOutOfBoundsException(Messages.getString("awt.43")); //$NON-NLS-1$
        }

        int idx  = glyphIndex << 1;

        AffineTransform fontTransform = this.transform;
        double xOffs = fontTransform.getTranslateX();
        double yOffs = fontTransform.getTranslateY();

        if (vector[glyphIndex].getWidth() == 0){
            return new Rectangle2D.Float((float)xOffs, (float)yOffs, 0, 0);
        }

        AffineTransform at = AffineTransform.getTranslateInstance(xOffs, yOffs);
        AffineTransform glyphTransform = getGlyphTransform(glyphIndex);

        if (transform.isIdentity() && ((glyphTransform == null) || glyphTransform.isIdentity())){
            Rectangle2D blackBox = vector[glyphIndex].getGlyphMetrics().getBounds2D();
            at.translate(visualPositions[idx], visualPositions[idx+1]);
            return(at.createTransformedShape(blackBox));
        }

        GeneralPath shape = (GeneralPath)this.getGlyphOutline(glyphIndex);
        shape.transform(at);
        return shape.getBounds2D();
    }

    /**
     * Returnes the pixel bounds of the specified glyph within GlyphVector 
     * rendered at the specified x,y location.
     *  
     * @param glyphIndex index of the glyph
     * @param frc a FontRenderContext that is used
     * @param x specified x coordinate value
     * @param y specified y coordinate value
     * @return a Rectangle that bounds pixels of the specified glyph
     */
    @Override
    public Rectangle getGlyphPixelBounds(int glyphIndex, FontRenderContext frc,
            float x, float y) {
        // TODO : need to be implemented with FontRenderContext
        if ((glyphIndex < 0) || (glyphIndex >= this.getNumGlyphs())) {
            // awt.43=glyphIndex is out of vector's limits
            throw new IndexOutOfBoundsException(Messages.getString("awt.43")); //$NON-NLS-1$
        }

        int idx  = glyphIndex << 1;

        if (vector[glyphIndex].getWidth() == 0){
            AffineTransform fontTransform = this.transform;
            double xOffs = x + visualPositions[idx] + fontTransform.getTranslateX();
            double yOffs = y + visualPositions[idx+1] + fontTransform.getTranslateY();
            return new Rectangle((int)xOffs, (int)yOffs, 0, 0);
        }

        GeneralPath shape = (GeneralPath)this.getGlyphOutline(glyphIndex);

        AffineTransform at = AffineTransform.getTranslateInstance(x, y);

        if (frc != null){
            at.concatenate(frc.getTransform());
        }

        shape.transform(at);

        Rectangle bounds = shape.getBounds();
        return new Rectangle((int)bounds.getX(), (int)bounds.getY(),
                            (int)bounds.getWidth()-1, (int)bounds.getHeight()-1);
        }

    /**
     * Returns a Shape that encloses specified glyph.
     * 
     * @param glyphIndex specified index of the glyph
     */
    @Override
    public Shape getGlyphOutline(int glyphIndex) {
        if ((glyphIndex < 0) || (glyphIndex >= this.getNumGlyphs())) {
            // awt.43=glyphIndex is out of vector's limits
            throw new IndexOutOfBoundsException(Messages.getString("awt.43")); //$NON-NLS-1$
        }

        if (gvShapes[glyphIndex] == null) {
            gvShapes[glyphIndex] = vector[glyphIndex].getShape();
        }

        GeneralPath gp = (GeneralPath)((GeneralPath)gvShapes[glyphIndex]).clone();

        /* Applying GlyphVector font transform */
        AffineTransform at = (AffineTransform)this.transform.clone();

        /* Applying Glyph transform */
        AffineTransform glyphAT = getGlyphTransform(glyphIndex);
        if (glyphAT != null){
            at.preConcatenate(glyphAT);
        }

        int idx  = glyphIndex << 1;

        gp.transform(at);
        gp.transform(AffineTransform.getTranslateInstance(visualPositions[idx], visualPositions[idx+1]));
        return gp;
    }


    /**
     * Returns a Shape that is the outline representation of this GlyphVector 
     * rendered at the specified x,y coordinates.
     * 
     * @param x specified x coordinate value
     * @param y specified y coordinate value
     * @return a Shape object that is the outline of this GlyphVector
     * at the specified coordinates.
     */
    @Override
    public Shape getOutline(float x, float y) {
        GeneralPath gp = new GeneralPath(GeneralPath.WIND_EVEN_ODD);
        for (int i = 0; i < this.vector.length; i++) {
            GeneralPath outline = (GeneralPath)getGlyphOutline(i);

            /* Applying translation to actual visual bounds */
            outline.transform(AffineTransform.getTranslateInstance(x, y));
            gp.append(outline, false);
        }

        return gp;
    }

    /**
     * Returns a Shape that is the outline representation of this GlyphVector.
     * 
     * @return a Shape object that is the outline of this GlyphVector
     */
    @Override
    public Shape getOutline() {
        return this.getOutline(0, 0);
    }

    /**
     * Returns an array of glyphcodes for the specified glyphs.
     * 
     * @param beginGlyphIndex the start index
     * @param numEntries the number of glyph codes to get
     * @param codeReturn the array that receives glyph codes' values
     * @return an array that receives glyph codes' values
     */
    @Override
    public int[] getGlyphCodes(int beginGlyphIndex, int numEntries,
            int[] codeReturn) {

        if ((beginGlyphIndex < 0) || ((numEntries + beginGlyphIndex) > this.getNumGlyphs())) {
            // awt.44=beginGlyphIndex is out of vector's range
            throw new IndexOutOfBoundsException(Messages.getString("awt.44")); //$NON-NLS-1$
        }

        if (numEntries < 0) {
            // awt.45=numEntries is out of vector's range
            throw new IllegalArgumentException(Messages.getString("awt.45")); //$NON-NLS-1$
        }

        if (codeReturn == null) {
            codeReturn = new int[numEntries];
        }

        for (int i = beginGlyphIndex; i < beginGlyphIndex + numEntries; i++) {
            codeReturn[i-beginGlyphIndex] = this.vector[i].getGlyphCode();
        }

        return codeReturn;
    }

    /**
     * Returns an array of numEntries character indices for the specified glyphs.
     * 
     * @param beginGlyphIndex the start index
     * @param numEntries the number of glyph codes to get
     * @param codeReturn the array that receives glyph codes' values
     * @return an array that receives glyph char indices
     */
    @Override
    public int[] getGlyphCharIndices(int beginGlyphIndex, int numEntries,
            int[] codeReturn) {
        if ((beginGlyphIndex < 0) || (beginGlyphIndex >= this.getNumGlyphs())) {
            // awt.44=beginGlyphIndex is out of vector's range
            throw new IllegalArgumentException(Messages.getString("awt.44")); //$NON-NLS-1$
        }

        if ((numEntries < 0)
                || ((numEntries + beginGlyphIndex) > this.getNumGlyphs())) {
            // awt.45=numEntries is out of vector's range
            throw new IllegalArgumentException(Messages.getString("awt.45")); //$NON-NLS-1$
        }

        if (codeReturn == null) {
            codeReturn = new int[numEntries];
        }

        for (int i = 0; i < numEntries; i++) {
            codeReturn[i] = this.getGlyphCharIndex(i + beginGlyphIndex);
        }
        return codeReturn;
    }

    /**
     * Returns an array of numEntries glyphs positions from beginGlyphIndex
     * glyph in Glyph Vector.
     * 
     * @param beginGlyphIndex the start index
     * @param numEntries the number of glyph codes to get
     * @param positionReturn the array that receives glyphs' positions
     * @return an array of floats that receives glyph char indices
     */
    @Override
    public float[] getGlyphPositions(int beginGlyphIndex, int numEntries,
            float[] positionReturn) {

        int len = (this.getNumGlyphs()+1) << 1;
        beginGlyphIndex *= 2;
        numEntries *= 2;

        if ((beginGlyphIndex < 0) || ((numEntries + beginGlyphIndex) > len)) {
            // awt.44=beginGlyphIndex is out of vector's range
            throw new IndexOutOfBoundsException(Messages.getString("awt.44")); //$NON-NLS-1$
        }

        if (numEntries < 0) {
            // awt.45=numEntries is out of vector's range
            throw new IllegalArgumentException(Messages.getString("awt.45")); //$NON-NLS-1$
        }

        if (positionReturn == null) {
            positionReturn = new float[numEntries];
        }

        System.arraycopy(visualPositions, beginGlyphIndex, positionReturn, 0, numEntries);

        return positionReturn;
    }

    /**
     * Set numEntries elements of the visualPositions array from beginGlyphIndex
     * of numEntries glyphs positions from beginGlyphIndex glyph in Glyph Vector.
     * 
     * @param beginGlyphIndex the start index
     * @param numEntries the number of glyph codes to get
     * @param setPositions the array of positions to set
     */
    public void setGlyphPositions(int beginGlyphIndex, int numEntries,
            float[] setPositions) {

        int len = (this.getNumGlyphs()+1) << 1;
        beginGlyphIndex *= 2;
        numEntries *= 2;

        if ((beginGlyphIndex < 0) || ((numEntries + beginGlyphIndex) > len)) {
            // awt.44=beginGlyphIndex is out of vector's range
            throw new IndexOutOfBoundsException(Messages.getString("awt.44")); //$NON-NLS-1$
        }

        if (numEntries < 0) {
            // awt.45=numEntries is out of vector's range
            throw new IllegalArgumentException(Messages.getString("awt.45")); //$NON-NLS-1$
        }

        System.arraycopy(setPositions, 0, visualPositions, beginGlyphIndex, numEntries);
        layoutFlags = layoutFlags & FLAG_HAS_POSITION_ADJUSTMENTS;

    }

    /**
     * Set elements of the visualPositions array.
     * 
     * @param setPositions the array of positions to set
     */
    public void setGlyphPositions(float[] setPositions) {

        int len = (this.getNumGlyphs()+1) << 1;
        if (len != setPositions.length){
            // awt.46=length of setPositions array differs from the length of positions array
            throw new IllegalArgumentException(Messages.getString("awt.46")); //$NON-NLS-1$
        }

        System.arraycopy(setPositions, 0, visualPositions, 0, len);
        layoutFlags = layoutFlags & FLAG_HAS_POSITION_ADJUSTMENTS;

    }


    /**
     * Returns glyph code of the specified glyph.
     * 
     * @param glyphIndex specified index of the glyph
     */
    @Override
    public int getGlyphCode(int glyphIndex) {
        if (glyphIndex >= this.vector.length || glyphIndex < 0) {
            // awt.43=glyphIndex is out of vector's limits
            throw new IndexOutOfBoundsException(Messages.getString("awt.43")); //$NON-NLS-1$
        }
        return this.vector[glyphIndex].getGlyphCode();
    }

    /**
     * Returns character index of the specified glyph.
     * 
     * @param glyphIndex specified index of the glyph
     */
    @Override
    public int getGlyphCharIndex(int glyphIndex) {

        if ((glyphIndex < 0) || (glyphIndex >= this.getNumGlyphs())) {
            // awt.43=glyphIndex is out of vector's limits
            throw new IllegalArgumentException(Messages.getString("awt.43")); //$NON-NLS-1$
        }

        if ((this.layoutFlags & Font.LAYOUT_RIGHT_TO_LEFT) != 0) {
            return this.charVector.length - glyphIndex - 1;
        }

        return glyphIndex;
    }

    /**
     * Returns a character value of the specified glyph.
     * 
     * @param glyphIndex specified index of the glyph
     */
    public char getGlyphChar(int glyphIndex) {

        if ((glyphIndex < 0) || (glyphIndex >= this.getNumGlyphs())) {
            // awt.43=glyphIndex is out of vector's limits
            throw new IllegalArgumentException(Messages.getString("awt.43")); //$NON-NLS-1$
        }
        return this.charVector[glyphIndex];
    }

    /**
     * Assigns default positions to each glyph in this GlyphVector.
     */
    @Override
    public void performDefaultLayout() {

        System.arraycopy(logicalPositions, 0, visualPositions, 0, logicalPositions.length);

        // Set position changes flag to zero
        clearLayoutFlags(GlyphVector.FLAG_HAS_POSITION_ADJUSTMENTS);
    }

    /**
     * Returns the number of glyphs in this Glyph Vector
     */
    @Override
    public int getNumGlyphs() {
        return vector.length;
    }

    /**
     * Returns the logical bounds of this GlyphVector
     */
    @Override
    public Rectangle2D getLogicalBounds(){
        // XXX: for transforms where an angle between basis vectors is not 90 degrees
        // Rectanlge2D class doesn't fit as Logical bounds. For this reason we use
        // only non-transformed bounds!!

        float x = visualPositions[0];
        float width = visualPositions[visualPositions.length-2];

        double scaleY =  transform.getScaleY();

        Rectangle2D bounds = new Rectangle2D.Float(x, (float)((-this.ascent-this.leading)*scaleY), width, (float)(this.height*scaleY));
        return bounds;
    }


    /**
     * Checks whether given GlyphVector equals to this GlyphVector.
     * @param glyphVector GlyphVector object to compare
     */
    @Override
    public boolean equals(GlyphVector glyphVector){
        if (glyphVector == this){
            return true;
        }

        if (glyphVector != null) {

            if (!(glyphVector.getFontRenderContext().equals(this.vectorFRC) &&
                      glyphVector.getFont().equals(this.font))){
                return false;
            }

            try {
                boolean eq = true;
                for (int i = 0; i < getNumGlyphs(); i++) {

                    int idx = i*2;
                    eq = (((CommonGlyphVector)glyphVector).visualPositions[idx] == this.visualPositions[idx]) &&
                        (((CommonGlyphVector)glyphVector).visualPositions[idx+1] == this.visualPositions[idx+1]) &&
                        (glyphVector.getGlyphCharIndex(i) == this.getGlyphCharIndex(i));

                    if (eq){
                        AffineTransform trans = glyphVector.getGlyphTransform(i);
                        if (trans == null){
                            eq = (this.glsTransforms[i] == null);
                        }else{
                            eq = this.glsTransforms[i].equals(trans);
                        }
                    }

                    if (!eq){
                        return false;
                    }
                }

                return  eq;
            } catch (ClassCastException e) {
            }
        }

        return false;
    }


    /**
     * Returns flags describing the state of the GlyphVector.
     */
    @Override
    public int getLayoutFlags() {
        return layoutFlags;
    }

    /**
     * Returns char with the specified index.
     * 
     * @param index specified index of the char
     * 
     */
    public char getChar(int index) {
        return this.charVector[index];

    }

    /**
     * Clear desired flags in layout flags describing the state. 
     * 
     * @param clearFlags flags mask to clear 
     */
    
    private void clearLayoutFlags(int clearFlags){
        layoutFlags &= ~clearFlags;
    }

    /**
     * Returns the logical bounds of the specified glyph within this CommonGlyphVector.
     * 
     * @param glyphIndex index of the glyph to get it's logical bounds
     * @return logical bounds of the specified glyph
     */
    @Override
    public Shape getGlyphLogicalBounds(int glyphIndex){
        if ((glyphIndex < 0) || (glyphIndex >= this.getNumGlyphs())){
            // awt.43=glyphIndex is out of vector's limits
            throw new IndexOutOfBoundsException(Messages.getString("awt.43")); //$NON-NLS-1$
        }
        Glyph glyph = this.vector[glyphIndex];

        float x0 = visualPositions[glyphIndex*2];
        float y0 = visualPositions[glyphIndex*2+1];
        float advanceX = glyph.getGlyphPointMetrics().getAdvanceX();

        GeneralPath gp = new GeneralPath();
        gp.moveTo(0, -ascent - leading);
        gp.lineTo(advanceX ,-ascent - leading);
        gp.lineTo(advanceX, descent);
        gp.lineTo(0, descent);
        gp.lineTo(0, -ascent - leading);
        gp.closePath();

        /* Applying GlyphVector font transform */
        AffineTransform at = (AffineTransform)this.transform.clone();

        /* Applying Glyph transform */
        AffineTransform glyphTransform = getGlyphTransform(glyphIndex);
        if (glyphTransform != null){
            at.concatenate(glyphTransform);
        }

        /* Applying translation to actual visual bounds */
        at.preConcatenate(AffineTransform.getTranslateInstance(x0, y0));
        gp.transform(at);
        return gp;
    }

    /**
     * Returns the Font parameter of this GlyphVector
     */
    @Override
    public Font getFont(){
        return this.font;
    }


}