replicant-frameworks_native/awt/java/awt/Font.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.
 */

package java.awt;

import com.android.internal.awt.AndroidGraphics2D;

import java.awt.font.FontRenderContext;
import java.awt.font.GlyphVector;
import java.awt.font.LineMetrics;
import java.awt.font.TextAttribute;
import java.awt.font.TransformAttribute;
import java.awt.geom.AffineTransform;
import java.awt.geom.Rectangle2D;
import java.io.File;
import java.io.FileInputStream;
import java.io.BufferedInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.Serializable;
import java.text.CharacterIterator;
import java.text.AttributedCharacterIterator.Attribute;
import java.util.Hashtable;
import java.util.Locale;
import java.util.Map;
import java.util.StringTokenizer;

import org.apache.harmony.awt.gl.font.AndroidGlyphVector;
import org.apache.harmony.awt.gl.font.CommonGlyphVector;
import org.apache.harmony.awt.gl.font.FontPeerImpl;
import org.apache.harmony.awt.gl.font.FontMetricsImpl;
import org.apache.harmony.awt.gl.font.LineMetricsImpl;
import org.apache.harmony.awt.internal.nls.Messages;
import org.apache.harmony.luni.util.NotImplementedException;
import org.apache.harmony.misc.HashCode;

/**
 * The Font class represents fonts for rendering text. This class allow to map
 * characters to glyphs.
 * <p>
 * A glyph is a shape used to render a character or a sequence of characters.
 * For example one character of Latin writing system represented by one glyph,
 * but in complex writing system such as South and South-East Asian there is
 * more complicated correspondence between characters and glyphs.
 * <p>
 * The Font object is identified by two types of names. The logical font name is
 * the name that is used to construct the font. The font name is the name of a
 * particular font face (for example, Arial Bold). The family name is the font's
 * family name that specifies the typographic design across several faces (for
 * example, Arial). In all the Font is identified by three attributes: the
 * family name, the style (such as bold or italic), and the size.
 * 
 * @since Android 1.0
 */
public class Font implements Serializable {

    /**
     * The Constant serialVersionUID.
     */
    private static final long serialVersionUID = -4206021311591459213L;

    // Identity Transform attribute
    /**
     * The Constant IDENTITY_TRANSFORM.
     */
    private static final TransformAttribute IDENTITY_TRANSFORM = new TransformAttribute(
            new AffineTransform());

    /**
     * The Constant PLAIN indicates font's plain style.
     */
    public static final int PLAIN = 0;

    /**
     * The Constant BOLD indicates font's bold style.
     */
    public static final int BOLD = 1;

    /**
     * The Constant ITALIC indicates font's italic style.
     */
    public static final int ITALIC = 2;

    /**
     * The Constant ROMAN_BASELINE indicated roman baseline.
     */
    public static final int ROMAN_BASELINE = 0;

    /**
     * The Constant CENTER_BASELINE indicates center baseline.
     */
    public static final int CENTER_BASELINE = 1;

    /**
     * The Constant HANGING_BASELINE indicates hanging baseline.
     */
    public static final int HANGING_BASELINE = 2;

    /**
     * The Constant TRUETYPE_FONT indicates a font resource of type TRUETYPE.
     */
    public static final int TRUETYPE_FONT = 0;

    /**
     * The Constant TYPE1_FONT indicates a font resource of type TYPE1.
     */
    public static final int TYPE1_FONT = 1;

    /**
     * The Constant LAYOUT_LEFT_TO_RIGHT indicates that text is left to right.
     */
    public static final int LAYOUT_LEFT_TO_RIGHT = 0;

    /**
     * The Constant LAYOUT_RIGHT_TO_LEFT indicates that text is right to left.
     */
    public static final int LAYOUT_RIGHT_TO_LEFT = 1;

    /**
     * The Constant LAYOUT_NO_START_CONTEXT indicates that the text in the char
     * array before the indicated start should not be examined.
     */
    public static final int LAYOUT_NO_START_CONTEXT = 2;

    /**
     * The Constant LAYOUT_NO_LIMIT_CONTEXT indicates that text in the char
     * array after the indicated limit should not be examined.
     */
    public static final int LAYOUT_NO_LIMIT_CONTEXT = 4;

    /**
     * The Constant DEFAULT_FONT.
     */
    static final Font DEFAULT_FONT = new Font("Dialog", Font.PLAIN, 12); //$NON-NLS-1$

    /**
     * The name of the Font.
     */
    protected String name;

    /**
     * The style of the Font.
     */
    protected int style;

    /**
     * The size of the Font.
     */
    protected int size;

    /**
     * The point size of the Font.
     */
    protected float pointSize;

    // Flag if the Font object transformed
    /**
     * The transformed.
     */
    private boolean transformed;

    // Set of font attributes
    /**
     * The requested attributes.
     */
    private Hashtable<Attribute, Object> fRequestedAttributes;

    // font peer object corresponding to this Font
    /**
     * The font peer.
     */
    private transient FontPeerImpl fontPeer;

    // number of glyphs in this Font
    /**
     * The num glyphs.
     */
    private transient int numGlyphs = -1;

    // code for missing glyph for this Font
    /**
     * The missing glyph code.
     */
    private transient int missingGlyphCode = -1;

    /**
     * Writes object to ObjectOutputStream.
     * 
     * @param out
     *            ObjectOutputStream.
     * @throws IOException
     *             Signals that an I/O exception has occurred.
     */
    private void writeObject(java.io.ObjectOutputStream out) throws IOException {
        out.defaultWriteObject();
    }

    /**
     * Reads object from ObjectInputStream object and set native platform
     * dependent fields to default values.
     * 
     * @param in
     *            ObjectInputStream object.
     * @throws IOException
     *             Signals that an I/O exception has occurred.
     * @throws ClassNotFoundException
     *             the class not found exception.
     */
    private void readObject(java.io.ObjectInputStream in) throws IOException,
            ClassNotFoundException {
        in.defaultReadObject();

        numGlyphs = -1;
        missingGlyphCode = -1;

    }

    /**
     * Instantiates a new Font with the specified attributes. The Font will be
     * created with default attributes if the attribute's parameter is null.
     * 
     * @param attributes
     *            the attributes to be assigned to the new Font, or null.
     */
    public Font(Map<? extends Attribute, ?> attributes) {
        Object currAttr;

        // Default values are taken from the documentation of the Font class.
        // See Font constructor, decode and getFont sections.

        this.name = "default"; //$NON-NLS-1$
        this.size = 12;
        this.pointSize = 12;
        this.style = Font.PLAIN;

        if (attributes != null) {

            fRequestedAttributes = new Hashtable<Attribute, Object>(attributes);

            currAttr = attributes.get(TextAttribute.SIZE);
            if (currAttr != null) {
                this.pointSize = ((Float)currAttr).floatValue();
                this.size = (int)Math.ceil(this.pointSize);
            }

            currAttr = attributes.get(TextAttribute.POSTURE);
            if (currAttr != null && currAttr.equals(TextAttribute.POSTURE_OBLIQUE)) {
                this.style |= Font.ITALIC;
            }

            currAttr = attributes.get(TextAttribute.WEIGHT);
            if ((currAttr != null)
                    && (((Float)currAttr).floatValue() >= (TextAttribute.WEIGHT_BOLD).floatValue())) {
                this.style |= Font.BOLD;
            }

            currAttr = attributes.get(TextAttribute.FAMILY);
            if (currAttr != null) {
                this.name = (String)currAttr;
            }

            currAttr = attributes.get(TextAttribute.TRANSFORM);
            if (currAttr != null) {
                if (currAttr instanceof TransformAttribute) {
                    this.transformed = !((TransformAttribute)currAttr).getTransform().isIdentity();
                } else if (currAttr instanceof AffineTransform) {
                    this.transformed = !((AffineTransform)currAttr).isIdentity();
                }
            }

        } else {
            fRequestedAttributes = new Hashtable<Attribute, Object>(5);
            fRequestedAttributes.put(TextAttribute.TRANSFORM, IDENTITY_TRANSFORM);

            this.transformed = false;

            fRequestedAttributes.put(TextAttribute.FAMILY, name);

            fRequestedAttributes.put(TextAttribute.SIZE, new Float(this.size));

            if ((this.style & Font.BOLD) != 0) {
                fRequestedAttributes.put(TextAttribute.WEIGHT, TextAttribute.WEIGHT_BOLD);
            } else {
                fRequestedAttributes.put(TextAttribute.WEIGHT, TextAttribute.WEIGHT_REGULAR);
            }
            if ((this.style & Font.ITALIC) != 0) {
                fRequestedAttributes.put(TextAttribute.POSTURE, TextAttribute.POSTURE_OBLIQUE);
            } else {
                fRequestedAttributes.put(TextAttribute.POSTURE, TextAttribute.POSTURE_REGULAR);
            }

        }
    }

    /**
     * Instantiates a new Font with the specified name, style and size.
     * 
     * @param name
     *            the name of font.
     * @param style
     *            the style of font.
     * @param size
     *            the size of font.
     */
    public Font(String name, int style, int size) {

        this.name = (name != null) ? name : "Default"; //$NON-NLS-1$
        this.size = (size >= 0) ? size : 0;
        this.style = (style & ~0x03) == 0 ? style : Font.PLAIN;
        this.pointSize = this.size;

        fRequestedAttributes = new Hashtable<Attribute, Object>(5);

        fRequestedAttributes.put(TextAttribute.TRANSFORM, IDENTITY_TRANSFORM);

        this.transformed = false;

        fRequestedAttributes.put(TextAttribute.FAMILY, this.name);
        fRequestedAttributes.put(TextAttribute.SIZE, new Float(this.size));

        if ((this.style & Font.BOLD) != 0) {
            fRequestedAttributes.put(TextAttribute.WEIGHT, TextAttribute.WEIGHT_BOLD);
        } else {
            fRequestedAttributes.put(TextAttribute.WEIGHT, TextAttribute.WEIGHT_REGULAR);
        }
        if ((this.style & Font.ITALIC) != 0) {
            fRequestedAttributes.put(TextAttribute.POSTURE, TextAttribute.POSTURE_OBLIQUE);
        } else {
            fRequestedAttributes.put(TextAttribute.POSTURE, TextAttribute.POSTURE_REGULAR);
        }
    }

    /**
     * Returns true if this Font has a glyph for the specified character.
     * 
     * @param c
     *            the character.
     * @return true if this Font has a glyph for the specified character, false
     *         otherwise.
     */
    public boolean canDisplay(char c) {
        FontPeerImpl peer = (FontPeerImpl)this.getPeer();
        return peer.canDisplay(c);
    }

    /**
     * Returns true if the Font can display the characters of the the specified
     * text from the specified start position to the specified limit position.
     * 
     * @param text
     *            the text.
     * @param start
     *            the start offset (in the character array).
     * @param limit
     *            the limit offset (in the character array).
     * @return the a character's position in the text that this Font can not
     *         display, or -1 if this Font can display all characters in this
     *         text.
     */
    public int canDisplayUpTo(char[] text, int start, int limit) {
        int st = start;
        int result;
        while ((st < limit) && canDisplay(text[st])) {
            st++;
        }

        if (st == limit) {
            result = -1;
        } else {
            result = st;
        }

        return result;
    }

    /**
     * Returns true if the Font can display the characters of the the specified
     * CharacterIterator from the specified start position and the specified
     * limit position.
     * 
     * @param iter
     *            the CharacterIterator.
     * @param start
     *            the start offset.
     * @param limit
     *            the limit offset.
     * @return the a character's position in the CharacterIterator that this
     *         Font can not display, or -1 if this Font can display all
     *         characters in this text.
     */
    public int canDisplayUpTo(CharacterIterator iter, int start, int limit) {
        int st = start;
        char c = iter.setIndex(start);
        int result;

        while ((st < limit) && (canDisplay(c))) {
            st++;
            c = iter.next();
        }
        if (st == limit) {
            result = -1;
        } else {
            result = st;
        }

        return result;
    }

    /**
     * Returns true if this Font can display a specified String.
     * 
     * @param str
     *            the String.
     * @return the a character's position in the String that this Font can not
     *         display, or -1 if this Font can display all characters in this
     *         text.
     */
    public int canDisplayUpTo(String str) {
        char[] chars = str.toCharArray();
        return canDisplayUpTo(chars, 0, chars.length);
    }

    /**
     * Creates a GlyphVector of associating characters to glyphs based on the
     * Unicode map of this Font.
     * 
     * @param frc
     *            the FontRenderContext.
     * @param chars
     *            the characters array.
     * @return the GlyphVector of associating characters to glyphs based on the
     *         Unicode map of this Font.
     */
    public GlyphVector createGlyphVector(FontRenderContext frc, char[] chars) {
        return new AndroidGlyphVector(chars, frc, this, 0);
    }

    /**
     * Creates a GlyphVector of associating characters contained in the
     * specified CharacterIterator to glyphs based on the Unicode map of this
     * Font.
     * 
     * @param frc
     *            the FontRenderContext.
     * @param iter
     *            the CharacterIterator.
     * @return the GlyphVector of associating characters contained in the
     *         specified CharacterIterator to glyphs based on the Unicode map of
     *         this Font.
     */
    public GlyphVector createGlyphVector(FontRenderContext frc, CharacterIterator iter) {
        throw new RuntimeException("Not implemented!"); //$NON-NLS-1$    
    }

    /**
     * Creates a GlyphVector of associating characters to glyphs based on the
     * Unicode map of this Font.
     * 
     * @param frc
     *            the FontRenderContext.
     * @param glyphCodes
     *            the specified integer array of glyph codes.
     * @return the GlyphVector of associating characters to glyphs based on the
     *         Unicode map of this Font.
     * @throws NotImplementedException
     *             if this method is not implemented by a subclass.
     */
    public GlyphVector createGlyphVector(FontRenderContext frc, int[] glyphCodes)
            throws org.apache.harmony.luni.util.NotImplementedException {
        throw new RuntimeException("Not implemented!"); //$NON-NLS-1$
    }

    /**
     * Creates a GlyphVector of associating characters to glyphs based on the
     * Unicode map of this Font.
     * 
     * @param frc
     *            the FontRenderContext.
     * @param str
     *            the specified String.
     * @return the GlyphVector of associating characters to glyphs based on the
     *         Unicode map of this Font.
     */
    public GlyphVector createGlyphVector(FontRenderContext frc, String str) {
        return new AndroidGlyphVector(str.toCharArray(), frc, this, 0);

    }

    /**
     * Returns the font style constant value corresponding to one of the font
     * style names ("BOLD", "ITALIC", "BOLDITALIC"). This method returns
     * Font.PLAIN if the argument is not one of the predefined style names.
     * 
     * @param fontStyleName
     *            font style name.
     * @return font style constant value corresponding to the font style name
     *         specified.
     */
    private static int getFontStyle(String fontStyleName) {
        int result = Font.PLAIN;

        if (fontStyleName.toUpperCase().equals("BOLDITALIC")) { //$NON-NLS-1$
            result = Font.BOLD | Font.ITALIC;
        } else if (fontStyleName.toUpperCase().equals("BOLD")) { //$NON-NLS-1$
            result = Font.BOLD;
        } else if (fontStyleName.toUpperCase().equals("ITALIC")) { //$NON-NLS-1$
            result = Font.ITALIC;
        }

        return result;
    }

    /**
     * Decodes the specified string which described the Font. The string should
     * have the following format: fontname-style-pointsize. The style can be
     * PLAIN, BOLD, BOLDITALIC, or ITALIC.
     * 
     * @param str
     *            the string which describes the font.
     * @return the Font from the specified string.
     */
    public static Font decode(String str) {
        // XXX: Documentation doesn't describe all cases, e.g. fonts face names
        // with
        // symbols that are suggested as delimiters in the documentation.
        // In this decode implementation only ***-***-*** format is used with
        // '-'
        // as the delimiter to avoid unexpected parse results of font face names
        // with spaces.

        if (str == null) {
            return DEFAULT_FONT;
        }

        StringTokenizer strTokens;
        String delim = "-"; //$NON-NLS-1$
        String substr;

        int fontSize = DEFAULT_FONT.size;
        int fontStyle = DEFAULT_FONT.style;
        String fontName = DEFAULT_FONT.name;

        strTokens = new StringTokenizer(str.trim(), delim);

        // Font Name
        if (strTokens.hasMoreTokens()) {
            fontName = strTokens.nextToken(); // first token is the font name
        }

        // Font Style or Size (if the style is undefined)
        if (strTokens.hasMoreTokens()) {
            substr = strTokens.nextToken();

            try {
                // if second token is the font size
                fontSize = Integer.parseInt(substr);
            } catch (NumberFormatException e) {
                // then second token is the font style
                fontStyle = getFontStyle(substr);
            }

        }

        // Font Size
        if (strTokens.hasMoreTokens()) {
            try {
                fontSize = Integer.parseInt(strTokens.nextToken());
            } catch (NumberFormatException e) {
            }
        }

        return new Font(fontName, fontStyle, fontSize);
    }

    /**
     * Performs the specified affine transform to the Font and returns a new
     * Font.
     * 
     * @param trans
     *            the AffineTransform.
     * @return the Font object.
     * @throws IllegalArgumentException
     *             if affine transform parameter is null.
     */
    @SuppressWarnings("unchecked")
    public Font deriveFont(AffineTransform trans) {

        if (trans == null) {
            // awt.94=transform can not be null
            throw new IllegalArgumentException(Messages.getString("awt.94")); //$NON-NLS-1$
        }

        Hashtable<Attribute, Object> derivefRequestedAttributes = (Hashtable<Attribute, Object>)fRequestedAttributes
                .clone();

        derivefRequestedAttributes.put(TextAttribute.TRANSFORM, new TransformAttribute(trans));

        return new Font(derivefRequestedAttributes);

    }

    /**
     * Returns a new Font that is a copy of the current Font modified so that
     * the size is the specified size.
     * 
     * @param size
     *            the size of font.
     * @return the Font object.
     */
    @SuppressWarnings("unchecked")
    public Font deriveFont(float size) {
        Hashtable<Attribute, Object> derivefRequestedAttributes = (Hashtable<Attribute, Object>)fRequestedAttributes
                .clone();
        derivefRequestedAttributes.put(TextAttribute.SIZE, new Float(size));
        return new Font(derivefRequestedAttributes);
    }

    /**
     * Returns a new Font that is a copy of the current Font modified so that
     * the style is the specified style.
     * 
     * @param style
     *            the style of font.
     * @return the Font object.
     */
    @SuppressWarnings("unchecked")
    public Font deriveFont(int style) {
        Hashtable<Attribute, Object> derivefRequestedAttributes = (Hashtable<Attribute, Object>)fRequestedAttributes
                .clone();

        if ((style & Font.BOLD) != 0) {
            derivefRequestedAttributes.put(TextAttribute.WEIGHT, TextAttribute.WEIGHT_BOLD);
        } else if (derivefRequestedAttributes.get(TextAttribute.WEIGHT) != null) {
            derivefRequestedAttributes.remove(TextAttribute.WEIGHT);
        }

        if ((style & Font.ITALIC) != 0) {
            derivefRequestedAttributes.put(TextAttribute.POSTURE, TextAttribute.POSTURE_OBLIQUE);
        } else if (derivefRequestedAttributes.get(TextAttribute.POSTURE) != null) {
            derivefRequestedAttributes.remove(TextAttribute.POSTURE);
        }

        return new Font(derivefRequestedAttributes);
    }

    /**
     * Returns a new Font that is a copy of the current Font modified to match
     * the specified style and with the specified affine transform applied to
     * its glyphs.
     * 
     * @param style
     *            the style of font.
     * @param trans
     *            the AffineTransform.
     * @return the Font object.
     */
    @SuppressWarnings("unchecked")
    public Font deriveFont(int style, AffineTransform trans) {

        if (trans == null) {
            // awt.94=transform can not be null
            throw new IllegalArgumentException(Messages.getString("awt.94")); //$NON-NLS-1$
        }
        Hashtable<Attribute, Object> derivefRequestedAttributes = (Hashtable<Attribute, Object>)fRequestedAttributes
                .clone();

        if ((style & BOLD) != 0) {
            derivefRequestedAttributes.put(TextAttribute.WEIGHT, TextAttribute.WEIGHT_BOLD);
        } else if (derivefRequestedAttributes.get(TextAttribute.WEIGHT) != null) {
            derivefRequestedAttributes.remove(TextAttribute.WEIGHT);
        }

        if ((style & ITALIC) != 0) {
            derivefRequestedAttributes.put(TextAttribute.POSTURE, TextAttribute.POSTURE_OBLIQUE);
        } else if (derivefRequestedAttributes.get(TextAttribute.POSTURE) != null) {
            derivefRequestedAttributes.remove(TextAttribute.POSTURE);
        }
        derivefRequestedAttributes.put(TextAttribute.TRANSFORM, new TransformAttribute(trans));

        return new Font(derivefRequestedAttributes);
    }

    /**
     * Returns a new Font that is a copy of the current Font modified so that
     * the size and style are the specified size and style.
     * 
     * @param style
     *            the style of font.
     * @param size
     *            the size of font.
     * @return the Font object.
     */
    @SuppressWarnings("unchecked")
    public Font deriveFont(int style, float size) {
        Hashtable<Attribute, Object> derivefRequestedAttributes = (Hashtable<Attribute, Object>)fRequestedAttributes
                .clone();

        if ((style & BOLD) != 0) {
            derivefRequestedAttributes.put(TextAttribute.WEIGHT, TextAttribute.WEIGHT_BOLD);
        } else if (derivefRequestedAttributes.get(TextAttribute.WEIGHT) != null) {
            derivefRequestedAttributes.remove(TextAttribute.WEIGHT);
        }

        if ((style & ITALIC) != 0) {
            derivefRequestedAttributes.put(TextAttribute.POSTURE, TextAttribute.POSTURE_OBLIQUE);
        } else if (derivefRequestedAttributes.get(TextAttribute.POSTURE) != null) {
            derivefRequestedAttributes.remove(TextAttribute.POSTURE);
        }

        derivefRequestedAttributes.put(TextAttribute.SIZE, new Float(size));
        return new Font(derivefRequestedAttributes);

    }

    /**
     * Returns a new Font object with a new set of font attributes.
     * 
     * @param attributes
     *            the map of attributes.
     * @return the Font.
     */
    @SuppressWarnings("unchecked")
    public Font deriveFont(Map<? extends Attribute, ?> attributes) {
        Attribute[] avalAttributes = this.getAvailableAttributes();

        Hashtable<Attribute, Object> derivefRequestedAttributes = (Hashtable<Attribute, Object>)fRequestedAttributes
                .clone();
        Object currAttribute;
        for (Attribute element : avalAttributes) {
            currAttribute = attributes.get(element);
            if (currAttribute != null) {
                derivefRequestedAttributes.put(element, currAttribute);
            }
        }
        return new Font(derivefRequestedAttributes);
    }

    /**
     * Compares the specified Object with the current Font.
     * 
     * @param obj
     *            the Object to be compared.
     * @return true, if the specified Object is an instance of Font with the
     *         same family, size, and style as this Font, false otherwise.
     */
    @Override
    public boolean equals(Object obj) {
        if (obj == this) {
            return true;
        }

        if (obj != null) {
            try {
                Font font = (Font)obj;

                return ((this.style == font.style) && (this.size == font.size)
                        && this.name.equals(font.name) && (this.pointSize == font.pointSize) && (this
                        .getTransform()).equals(font.getTransform()));
            } catch (ClassCastException e) {
            }
        }

        return false;
    }

    /**
     * Gets the map of font's attributes.
     * 
     * @return the map of font's attributes.
     */
    @SuppressWarnings("unchecked")
    public Map<TextAttribute, ?> getAttributes() {
        return (Map<TextAttribute, ?>)fRequestedAttributes.clone();
    }

    /**
     * Gets the keys of all available attributes.
     * 
     * @return the keys array of all available attributes.
     */
    public Attribute[] getAvailableAttributes() {
        Attribute[] attrs = {
                TextAttribute.FAMILY, TextAttribute.POSTURE, TextAttribute.SIZE,
                TextAttribute.TRANSFORM, TextAttribute.WEIGHT, TextAttribute.SUPERSCRIPT,
                TextAttribute.WIDTH
        };
        return attrs;
    }

    /**
     * Gets the baseline for this character.
     * 
     * @param c
     *            the character.
     * @return the baseline for this character.
     */
    public byte getBaselineFor(char c) {
        // TODO: implement using TT BASE table data
        return 0;
    }

    /**
     * Gets the family name of the Font.
     * 
     * @return the family name of the Font.
     */
    public String getFamily() {
        if (fRequestedAttributes != null) {
            fRequestedAttributes.get(TextAttribute.FAMILY);
        }
        return null;
    }

    /**
     * Returns the family name of this Font associated with the specified
     * locale.
     * 
     * @param l
     *            the locale.
     * @return the family name of this Font associated with the specified
     *         locale.
     */
    public String getFamily(Locale l) {
        if (l == null) {
            // awt.01='{0}' parameter is null
            throw new NullPointerException(Messages.getString("awt.01", "Locale")); //$NON-NLS-1$ //$NON-NLS-2$ 
        }
        return getFamily();
    }

    /**
     * Gets a Font with the specified attribute set.
     * 
     * @param attributes
     *            the attributes to be assigned to the new Font.
     * @return the Font.
     */
    public static Font getFont(Map<? extends Attribute, ?> attributes) {
        Font fnt = (Font)attributes.get(TextAttribute.FONT);
        if (fnt != null) {
            return fnt;
        }
        return new Font(attributes);
    }

    /**
     * Gets a Font object from the system properties list with the specified
     * name or returns the specified Font if there is no such property.
     * 
     * @param sp
     *            the specified property name.
     * @param f
     *            the Font.
     * @return the Font object from the system properties list with the
     *         specified name or the specified Font if there is no such
     *         property.
     */
    public static Font getFont(String sp, Font f) {
        String pr = System.getProperty(sp);
        if (pr == null) {
            return f;
        }
        return decode(pr);
    }

    /**
     * Gets a Font object from the system properties list with the specified
     * name.
     * 
     * @param sp
     *            the system property name.
     * @return the Font, or null if there is no such property with the specified
     *         name.
     */
    public static Font getFont(String sp) {
        return getFont(sp, null);
    }

    /**
     * Gets the font name.
     * 
     * @return the font name.
     */
    public String getFontName() {
        if (fRequestedAttributes != null) {
            fRequestedAttributes.get(TextAttribute.FAMILY);
        }
        return null;
    }

    /**
     * Returns the font name associated with the specified locale.
     * 
     * @param l
     *            the locale.
     * @return the font name associated with the specified locale.
     */
    public String getFontName(Locale l) {
        return getFamily();
    }

    /**
     * Returns a LineMetrics object created with the specified parameters.
     * 
     * @param chars
     *            the chars array.
     * @param start
     *            the start offset.
     * @param end
     *            the end offset.
     * @param frc
     *            the FontRenderContext.
     * @return the LineMetrics for the specified parameters.
     */
    public LineMetrics getLineMetrics(char[] chars, int start, int end, FontRenderContext frc) {
        if (frc == null) {
            // awt.00=FontRenderContext is null
            throw new NullPointerException(Messages.getString("awt.00")); //$NON-NLS-1$
        }

        // FontMetrics fm = AndroidGraphics2D.getInstance().getFontMetrics();
        FontMetrics fm = new FontMetricsImpl(this);
        float[] fmet = {
                fm.getAscent(), fm.getDescent(), fm.getLeading()
        };
        return new LineMetricsImpl(chars.length, fmet, null);
    }

    /**
     * Returns a LineMetrics object created with the specified parameters.
     * 
     * @param iter
     *            the CharacterIterator.
     * @param start
     *            the start offset.
     * @param end
     *            the end offset.
     * @param frc
     *            the FontRenderContext.
     * @return the LineMetrics for the specified parameters.
     */
    public LineMetrics getLineMetrics(CharacterIterator iter, int start, int end,
            FontRenderContext frc) {

        if (frc == null) {
            // awt.00=FontRenderContext is null
            throw new NullPointerException(Messages.getString("awt.00")); //$NON-NLS-1$
        }

        String resultString;
        int iterCount;

        iterCount = end - start;
        if (iterCount < 0) {
            resultString = ""; //$NON-NLS-1$
        } else {
            char[] chars = new char[iterCount];
            int i = 0;
            for (char c = iter.setIndex(start); c != CharacterIterator.DONE && (i < iterCount); c = iter
                    .next()) {
                chars[i] = c;
                i++;
            }
            resultString = new String(chars);
        }
        return this.getLineMetrics(resultString, frc);
    }

    /**
     * Returns a LineMetrics object created with the specified parameters.
     * 
     * @param str
     *            the String.
     * @param frc
     *            the FontRenderContext.
     * @return the LineMetrics for the specified parameters.
     */
    public LineMetrics getLineMetrics(String str, FontRenderContext frc) {
        // FontMetrics fm = AndroidGraphics2D.getInstance().getFontMetrics();
        FontMetrics fm = new FontMetricsImpl(this);
        float[] fmet = {
                fm.getAscent(), fm.getDescent(), fm.getLeading()
        };
        // Log.i("FONT FMET", fmet.toString());
        return new LineMetricsImpl(str.length(), fmet, null);

    }

    /**
     * Returns a LineMetrics object created with the specified parameters.
     * 
     * @param str
     *            the String.
     * @param start
     *            the start offset.
     * @param end
     *            the end offset.
     * @param frc
     *            the FontRenderContext.
     * @return the LineMetrics for the specified parameters.
     */
    public LineMetrics getLineMetrics(String str, int start, int end, FontRenderContext frc) {
        return this.getLineMetrics(str.substring(start, end), frc);
    }

    /**
     * Gets the logical bounds of the specified String in the specified
     * FontRenderContext. The logical bounds contains the origin, ascent,
     * advance, and height.
     * 
     * @param ci
     *            the specified CharacterIterator.
     * @param start
     *            the start offset.
     * @param end
     *            the end offset.
     * @param frc
     *            the FontRenderContext.
     * @return a Rectangle2D object.
     */
    public Rectangle2D getStringBounds(CharacterIterator ci, int start, int end,
            FontRenderContext frc) {
        int first = ci.getBeginIndex();
        int finish = ci.getEndIndex();
        char[] chars;

        if (start < first) {
            // awt.95=Wrong start index: {0}
            throw new IndexOutOfBoundsException(Messages.getString("awt.95", start)); //$NON-NLS-1$
        }
        if (end > finish) {
            // awt.96=Wrong finish index: {0}
            throw new IndexOutOfBoundsException(Messages.getString("awt.96", end)); //$NON-NLS-1$
        }
        if (start > end) {
            // awt.97=Wrong range length: {0}
            throw new IndexOutOfBoundsException(Messages.getString("awt.97", //$NON-NLS-1$
                    (end - start)));
        }

        if (frc == null) {
            throw new NullPointerException(Messages.getString("awt.00")); //$NON-NLS-1$
        }

        chars = new char[end - start];

        ci.setIndex(start);
        for (int i = 0; i < chars.length; i++) {
            chars[i] = ci.current();
            ci.next();
        }

        return this.getStringBounds(chars, 0, chars.length, frc);

    }

    /**
     * Gets the logical bounds of the specified String in the specified
     * FontRenderContext. The logical bounds contains the origin, ascent,
     * advance, and height.
     * 
     * @param str
     *            the specified String.
     * @param frc
     *            the FontRenderContext.
     * @return a Rectangle2D object.
     */
    public Rectangle2D getStringBounds(String str, FontRenderContext frc) {
        char[] chars = str.toCharArray();
        return this.getStringBounds(chars, 0, chars.length, frc);

    }

    /**
     * Gets the logical bounds of the specified String in the specified
     * FontRenderContext. The logical bounds contains the origin, ascent,
     * advance, and height.
     * 
     * @param str
     *            the specified String.
     * @param start
     *            the start offset.
     * @param end
     *            the end offset.
     * @param frc
     *            the FontRenderContext.
     * @return a Rectangle2D object.
     */
    public Rectangle2D getStringBounds(String str, int start, int end, FontRenderContext frc) {

        return this.getStringBounds((str.substring(start, end)), frc);
    }

    /**
     * Gets the logical bounds of the specified String in the specified
     * FontRenderContext. The logical bounds contains the origin, ascent,
     * advance, and height.
     * 
     * @param chars
     *            the specified character array.
     * @param start
     *            the start offset.
     * @param end
     *            the end offset.
     * @param frc
     *            the FontRenderContext.
     * @return a Rectangle2D object.
     */
    public Rectangle2D getStringBounds(char[] chars, int start, int end, FontRenderContext frc) {
        if (start < 0) {
            // awt.95=Wrong start index: {0}
            throw new IndexOutOfBoundsException(Messages.getString("awt.95", start)); //$NON-NLS-1$
        }
        if (end > chars.length) {
            // awt.96=Wrong finish index: {0}
            throw new IndexOutOfBoundsException(Messages.getString("awt.96", end)); //$NON-NLS-1$
        }
        if (start > end) {
            // awt.97=Wrong range length: {0}
            throw new IndexOutOfBoundsException(Messages.getString("awt.97", //$NON-NLS-1$
                    (end - start)));
        }

        if (frc == null) {
            throw new NullPointerException(Messages.getString("awt.00")); //$NON-NLS-1$
        }

        FontPeerImpl peer = (FontPeerImpl)this.getPeer();

        final int TRANSFORM_MASK = AffineTransform.TYPE_GENERAL_ROTATION
                | AffineTransform.TYPE_GENERAL_TRANSFORM;
        Rectangle2D bounds;

        AffineTransform transform = getTransform();

        // XXX: for transforms where an angle between basis vectors is not 90
        // degrees Rectanlge2D class doesn't fit as Logical bounds.
        if ((transform.getType() & TRANSFORM_MASK) == 0) {
            int width = 0;
            for (int i = start; i < end; i++) {
                width += peer.charWidth(chars[i]);
            }
            // LineMetrics nlm = peer.getLineMetrics();

            LineMetrics nlm = getLineMetrics(chars, start, end, frc);

            bounds = transform.createTransformedShape(
                    new Rectangle2D.Float(0, -nlm.getAscent(), width, nlm.getHeight()))
                    .getBounds2D();
        } else {
            int len = end - start;
            char[] subChars = new char[len];
            System.arraycopy(chars, start, subChars, 0, len);
            bounds = createGlyphVector(frc, subChars).getLogicalBounds();
        }
        return bounds;
    }

    /**
     * Gets the character's maximum bounds as defined in the specified
     * FontRenderContext.
     * 
     * @param frc
     *            the FontRenderContext.
     * @return the character's maximum bounds.
     */
    public Rectangle2D getMaxCharBounds(FontRenderContext frc) {
        if (frc == null) {
            // awt.00=FontRenderContext is null
            throw new NullPointerException(Messages.getString("awt.00")); //$NON-NLS-1$ 
        }

        FontPeerImpl peer = (FontPeerImpl)this.getPeer();

        Rectangle2D bounds = peer.getMaxCharBounds(frc);
        AffineTransform transform = getTransform();
        // !! Documentation doesn't describe meaning of max char bounds
        // for the fonts that have rotate transforms. For all transforms
        // returned bounds are the bounds of transformed maxCharBounds
        // Rectangle2D that corresponds to the font with identity transform.
        // TODO: resolve this issue to return correct bounds
        bounds = transform.createTransformedShape(bounds).getBounds2D();

        return bounds;
    }

    /**
     * Returns a new GlyphVector object performing full layout of the text.
     * 
     * @param frc
     *            the FontRenderContext.
     * @param chars
     *            the character array to be layout.
     * @param start
     *            the start offset of the text to use for the GlyphVector.
     * @param count
     *            the count of characters to use for the GlyphVector.
     * @param flags
     *            the flag indicating text direction: LAYOUT_RIGHT_TO_LEFT,
     *            LAYOUT_LEFT_TO_RIGHT.
     * @return the GlyphVector.
     */
    public GlyphVector layoutGlyphVector(FontRenderContext frc, char[] chars, int start, int count,
            int flags) {
        // TODO: implement method for bidirectional text.
        // At the moment only LTR and RTL texts supported.
        if (start < 0) {
            // awt.95=Wrong start index: {0}
            throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.95", //$NON-NLS-1$
                    start));
        }

        if (count < 0) {
            // awt.98=Wrong count value, can not be negative: {0}
            throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.98", //$NON-NLS-1$
                    count));
        }

        if (start + count > chars.length) {
            // awt.99=Wrong [start + count] is out of range: {0}
            throw new ArrayIndexOutOfBoundsException(Messages.getString("awt.99", //$NON-NLS-1$
                    (start + count)));
        }

        char[] out = new char[count];
        System.arraycopy(chars, start, out, 0, count);

        return new CommonGlyphVector(out, frc, this, flags);
    }

    /**
     * Returns the String representation of this Font.
     * 
     * @return the String representation of this Font.
     */
    @Override
    public String toString() {
        String stl = "plain"; //$NON-NLS-1$
        String result;

        if (this.isBold() && this.isItalic()) {
            stl = "bolditalic"; //$NON-NLS-1$
        }
        if (this.isBold() && !this.isItalic()) {
            stl = "bold"; //$NON-NLS-1$
        }

        if (!this.isBold() && this.isItalic()) {
            stl = "italic"; //$NON-NLS-1$
        }

        result = this.getClass().getName() + "[family=" + this.getFamily() + //$NON-NLS-1$
                ",name=" + this.name + //$NON-NLS-1$
                ",style=" + stl + //$NON-NLS-1$
                ",size=" + this.size + "]"; //$NON-NLS-1$ //$NON-NLS-2$
        return result;
    }

    /**
     * Gets the postscript name of this Font.
     * 
     * @return the postscript name of this Font.
     */
    public String getPSName() {
        FontPeerImpl peer = (FontPeerImpl)this.getPeer();
        return peer.getPSName();
    }

    /**
     * Gets the logical name of this Font.
     * 
     * @return the logical name of this Font.
     */
    public String getName() {
        return (this.name);
    }

    /**
     * Gets the peer of this Font.
     * 
     * @return the peer of this Font.
     * @deprecated Font rendering is platform independent now.
     */
    @Deprecated
    public java.awt.peer.FontPeer getPeer() {
        if (fontPeer == null) {
            fontPeer = (FontPeerImpl)Toolkit.getDefaultToolkit().getGraphicsFactory().getFontPeer(
                    this);
        }
        return fontPeer;

    }

    /**
     * Gets the transform acting on this Font (from the Font's attributes).
     * 
     * @return the transformation of this Font.
     */
    public AffineTransform getTransform() {
        Object transform = fRequestedAttributes.get(TextAttribute.TRANSFORM);

        if (transform != null) {
            if (transform instanceof TransformAttribute) {
                return ((TransformAttribute)transform).getTransform();
            }
            if (transform instanceof AffineTransform) {
                return new AffineTransform((AffineTransform)transform);
            }
        } else {
            transform = new AffineTransform();
        }
        return (AffineTransform)transform;

    }

    /**
     * Checks if this font is transformed or not.
     * 
     * @return true, if this font is transformed, false otherwise.
     */
    public boolean isTransformed() {
        return this.transformed;
    }

    /**
     * Checks if this font has plain style or not.
     * 
     * @return true, if this font has plain style, false otherwise.
     */
    public boolean isPlain() {
        return (this.style == PLAIN);
    }

    /**
     * Checks if this font has italic style or not.
     * 
     * @return true, if this font has italic style, false otherwise.
     */
    public boolean isItalic() {
        return (this.style & ITALIC) != 0;
    }

    /**
     * Checks if this font has bold style or not.
     * 
     * @return true, if this font has bold style, false otherwise.
     */
    public boolean isBold() {
        return (this.style & BOLD) != 0;
    }

    /**
     * Returns true if this Font has uniform line metrics.
     * 
     * @return true if this Font has uniform line metrics, false otherwise.
     */
    public boolean hasUniformLineMetrics() {
        FontPeerImpl peer = (FontPeerImpl)this.getPeer();
        return peer.hasUniformLineMetrics();
    }

    /**
     * Returns hash code of this Font object.
     * 
     * @return the hash code of this Font object.
     */
    @Override
    public int hashCode() {
        HashCode hash = new HashCode();

        hash.append(this.name);
        hash.append(this.style);
        hash.append(this.size);

        return hash.hashCode();
    }

    /**
     * Gets the style of this Font.
     * 
     * @return the style of this Font.
     */
    public int getStyle() {
        return this.style;
    }

    /**
     * Gets the size of this Font.
     * 
     * @return the size of this Font.
     */
    public int getSize() {
        return this.size;
    }

    /**
     * Gets the number of glyphs for this Font.
     * 
     * @return the number of glyphs for this Font.
     */
    public int getNumGlyphs() {
        if (numGlyphs == -1) {
            FontPeerImpl peer = (FontPeerImpl)this.getPeer();
            this.numGlyphs = peer.getNumGlyphs();
        }
        return this.numGlyphs;
    }

    /**
     * Gets the glyphCode which is used as default glyph when this Font does not
     * have a glyph for a specified Unicode.
     * 
     * @return the missing glyph code.
     */
    public int getMissingGlyphCode() {
        if (missingGlyphCode == -1) {
            FontPeerImpl peer = (FontPeerImpl)this.getPeer();
            this.missingGlyphCode = peer.getMissingGlyphCode();
        }
        return this.missingGlyphCode;
    }

    /**
     * Gets the float value of font's size.
     * 
     * @return the float value of font's size.
     */
    public float getSize2D() {
        return this.pointSize;
    }

    /**
     * Gets the italic angle of this Font.
     * 
     * @return the italic angle of this Font.
     */
    public float getItalicAngle() {
        FontPeerImpl peer = (FontPeerImpl)this.getPeer();
        return peer.getItalicAngle();
    }

    /**
     * Creates the font with the specified font format and font file.
     * 
     * @param fontFormat
     *            the font format.
     * @param fontFile
     *            the file object represented the input data for the font.
     * @return the Font.
     * @throws FontFormatException
     *             is thrown if fontFile does not contain the required font
     *             tables for the specified format.
     * @throws IOException
     *             signals that an I/O exception has occurred.
     */
    public static Font createFont(int fontFormat, File fontFile) throws FontFormatException,
            IOException {
        // ???AWT not supported
        InputStream is = new FileInputStream(fontFile);
        try {
            return createFont(fontFormat, is);
        } finally {
            is.close();
        }
    }

    /**
     * Creates the font with the specified font format and input stream.
     * 
     * @param fontFormat
     *            the font format.
     * @param fontStream
     *            the input stream represented input data for the font.
     * @return the Font.
     * @throws FontFormatException
     *             is thrown if fontFile does not contain the required font
     *             tables for the specified format.
     * @throws IOException
     *             signals that an I/O exception has occurred.
     */
    public static Font createFont(int fontFormat, InputStream fontStream)
            throws FontFormatException, IOException {

        // ???AWT not supported

        BufferedInputStream buffStream;
        int bRead = 0;
        int size = 8192;
        // memory page size, for the faster reading
        byte buf[] = new byte[size];

        if (fontFormat != TRUETYPE_FONT) { // awt.9A=Unsupported font format
            throw new IllegalArgumentException(Messages.getString("awt.9A")); //$NON-NLS-1$ 
        }

        /* Get font file in system-specific directory */

        File fontFile = Toolkit.getDefaultToolkit().getGraphicsFactory().getFontManager()
                .getTempFontFile();

        // BEGIN android-modified
        buffStream = new BufferedInputStream(fontStream, 8192);
        // END android-modified
        FileOutputStream fOutStream = new FileOutputStream(fontFile);

        bRead = buffStream.read(buf, 0, size);

        while (bRead != -1) {
            fOutStream.write(buf, 0, bRead);
            bRead = buffStream.read(buf, 0, size);
        }

        buffStream.close();
        fOutStream.close();

        Font font = null;

        font = Toolkit.getDefaultToolkit().getGraphicsFactory().embedFont(
                fontFile.getAbsolutePath());
        if (font == null) { // awt.9B=Can't create font - bad font data
            throw new FontFormatException(Messages.getString("awt.9B")); //$NON-NLS-1$
        }
        return font;
    }

}