1501 lines
48 KiB
Java
1501 lines
48 KiB
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.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;
|
|
}
|
|
|
|
}
|