| /* |
| * 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.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 glyth, 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. |
| */ |
| 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. |
| */ |
| 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); |
| } |
| |
| /** |
| * Perfoms 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 shuch 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; |
| } |
| |
| } |
