createFont that the supplied font data
* is in TrueType format.
*
* Specification Note: The Sun JavaDoc for J2SE 1.4 does
* not indicate whether this value also subsumes OpenType. OpenType
* is essentially the same format as TrueType, but allows to define
* glyph shapes in the same way as PostScript, using cubic bezier
* curves.
*
* @since 1.3
*/
public static final int TRUETYPE_FONT = 0;
/**
* Indicates to createFont that the supplied font data
* is in Type1 format.
*
* @since 1.5
*/
public static final int TYPE1_FONT = 1;
/**
* A flag for layoutGlyphVector, indicating that the
* orientation of a text run is from left to right.
*
* @since 1.4
*/
public static final int LAYOUT_LEFT_TO_RIGHT = 0;
/**
* A flag for layoutGlyphVector, indicating that the
* orientation of a text run is from right to left.
*
* @since 1.4
*/
public static final int LAYOUT_RIGHT_TO_LEFT = 1;
/**
* A flag for layoutGlyphVector, indicating that the
* text does not contain valid characters before the
* start position. If this flag is set,
* layoutGlyphVector does not examine the text before
* start, even if this would be necessary to select the
* correct glyphs (e.g., for Arabic text).
*
* @since 1.4
*/
public static final int LAYOUT_NO_START_CONTEXT = 2;
/**
* A flag for layoutGlyphVector, indicating that the
* text does not contain valid characters after the
* limit position. If this flag is set,
* layoutGlyphVector does not examine the text after
* limit, even if this would be necessary to select the
* correct glyphs (e.g., for Arabic text).
*
* @since 1.4
*/
public static final int LAYOUT_NO_LIMIT_CONTEXT = 4;
/**
* @since 1.6
*/
public static final String DIALOG = "Dialog";
/**
* @since 1.6
*/
public static final String DIALOG_INPUT = "DialogInput";
/**
* @since 1.6
*/
public static final String MONOSPACED = "Monospaced";
/**
* @since 1.6
*/
public static final String SANS_SERIF = "SansSerif";
/**
* @since 1.6
*/
public static final String SERIF = "Serif";
/**
* The logical name of this font.
*
* @since 1.0
*/
protected String name;
/**
* The size of this font in points, rounded.
*
* @since 1.0
*/
protected int size;
/**
* The size of this font in points.
*
* @since 1.0
*/
protected float pointSize;
/**
* The style of this font -- PLAIN, BOLD, ITALIC or BOLD+ITALIC.
*
* @since 1.0
*/
protected int style;
//Serialization constant
private static final long serialVersionUID = -4206021311591459213L;
// The ClasspathToolkit-provided peer which implements this font
private transient ClasspathFontPeer peer;
/**
* The cached hashcode. A value of 0 (default initialized) means that the
* hashcode is not computed yet.
*/
private transient int hashCode;
/**
* Creates a Font object from the specified string, which
* is in one of the following formats:
*
*
* The style should be one of BOLD, ITALIC, or BOLDITALIC. The default
* style if none is specified is PLAIN. The default size if none
* is specified is 12.
*
* @param fontspec a string specifying the required font (
* null
* permitted, interpreted as 'Dialog-PLAIN-12').
*
* @return A font.
*/
public static Font decode(String fontspec)
{
if (fontspec == null)
fontspec = "Dialog-PLAIN-12";
String name = null;
int style = PLAIN;
int size = 12;
StringTokenizer st = new StringTokenizer(fontspec, "- ");
while (st.hasMoreTokens())
{
String token = st.nextToken();
if (name == null)
{
name = token;
continue;
}
if (token.toUpperCase().equals("BOLD"))
{
style = BOLD;
continue;
}
if (token.toUpperCase().equals("ITALIC"))
{
style = ITALIC;
continue;
}
if (token.toUpperCase().equals("BOLDITALIC"))
{
style = BOLD | ITALIC;
continue;
}
int tokenval = 0;
try
{
tokenval = Integer.parseInt(token);
}
catch (NumberFormatException e)
{
// Ignored.
}
if (tokenval != 0)
size = tokenval;
}
HashMap attrs = new HashMap();
ClasspathFontPeer.copyStyleToAttrs(style, attrs);
ClasspathFontPeer.copySizeToAttrs(size, attrs);
return getFontFromToolkit(name, attrs);
}
/* These methods delegate to the toolkit. */
static ClasspathToolkit tk()
{
return (ClasspathToolkit) Toolkit.getDefaultToolkit();
}
/* Every factory method in Font should eventually call this. */
static Font getFontFromToolkit(String name, Map attribs)
{
return tk().getFont(name, attribs);
}
/* Every Font constructor should eventually call this. */
static ClasspathFontPeer getPeerFromToolkit(String name, Map attrs)
{
return tk().getClasspathFontPeer(name, attrs);
}
/**
* Returns a Font object from the passed property name.
*
* @param propname The name of the system property.
* @param defval Value to use if the property is not found.
*
* @return The requested font, or default if the property
* not exist or is malformed.
*/
public static Font getFont(String propname, Font defval)
{
String propval = System.getProperty(propname);
if (propval != null)
return decode(propval);
return defval;
}
/**
* Returns a Font object from the passed property name.
*
* @param propname The name of the system property.
*
* @return The requested font, or null if the property
* not exist or is malformed.
*/
public static Font getFont(String propname)
{
return getFont(propname, (Font) null);
}
protected Font(Font font)
{
this(font.getName(), font.getAttributes());
}
/**
* Initializes a new instance of Font with the specified
* attributes.
*
* @param name The name of the font.
* @param style The font style.
* @param size The font point size.
*/
public Font(String name, int style, int size)
{
HashMap attrs = new HashMap();
ClasspathFontPeer.copyStyleToAttrs(style, attrs);
ClasspathFontPeer.copySizeToAttrs(size, attrs);
this.peer = getPeerFromToolkit(name, attrs);
this.size = size;
this.pointSize = (float) size;
if (name != null)
this.name = name;
else
this.name = peer.getName(this);
}
public Font(Map attrs)
{
this(null, attrs);
}
/* This extra constructor is here to permit ClasspathToolkit and to
build a font with a "logical name" as well as attrs.
ClasspathToolkit.getFont(String,Map) uses reflection to call this
package-private constructor. */
Font(String name, Map attrs)
{
// If attrs is null, setting it to an empty HashMap will give this
// Font default attributes.
if (attrs == null)
attrs = new HashMap();
peer = getPeerFromToolkit(name, attrs);
size = (int) peer.getSize(this);
pointSize = peer.getSize(this);
if (name != null)
this.name = name;
else
this.name = peer.getName(this);
}
/**
* Returns the logical name of the font. A logical name is the name the
* font was constructed with. It may be the name of a logical font (one
* of 6 required names in all java environments) or it may be a face
* name.
*
* @return The logical name of the font.
*
* @see #getFamily()
* @see #getFontName()
*/
public String getName ()
{
return peer.getName(this);
}
/**
* Returns the size of the font, in typographics points (1/72 of an inch),
* rounded to an integer.
*
* @return The font size
*/
public int getSize()
{
return size;
}
/**
* Returns the size of the font, in typographics points (1/72 of an inch).
*
* @return The font size
*/
public float getSize2D()
{
return pointSize;
}
/**
* Tests whether or not this is a plain font. This will be true if
* and only if neither the bold nor the italics style is set.
*
* @return true if this is a plain font, false
* otherwise.
*/
public boolean isPlain()
{
return peer.isPlain(this);
}
/**
* Tests whether or not this font is bold.
*
* @return true if this font is bold, false
* otherwise.
*/
public boolean isBold()
{
return peer.isBold(this);
}
/**
* Tests whether or not this font is italic.
*
* @return true if this font is italic, false
* otherwise.
*/
public boolean isItalic()
{
return peer.isItalic(this);
}
/**
* Returns the family name of this font. A family name describes a design
* or "brand name" (such as Helvetica or Palatino). It is less specific
* than a font face name (such as Helvetica Bold).
*
* @return A string containing the font family name.
*
* @since 1.2
*
* @see #getName()
* @see #getFontName()
* @see GraphicsEnvironment#getAvailableFontFamilyNames()
*/
public String getFamily()
{
return peer.getFamily(this);
}
/**
* Returns integer code representing the sum of style flags of this font, a
* combination of either {@link #PLAIN}, {@link #BOLD}, or {@link #ITALIC}.
*
* @return code representing the style of this font.
*
* @see #isPlain()
* @see #isBold()
* @see #isItalic()
*/
public int getStyle()
{
return peer.getStyle(this);
}
/**
* Checks if specified character maps to a glyph in this font.
*
* @param c The character to check.
*
* @return Whether the character has a corresponding glyph in this font.
*
* @since 1.2
*/
public boolean canDisplay(char c)
{
return canDisplay((int) c);
}
public boolean canDisplay(int codePoint)
{
return peer.canDisplay(this, codePoint);
}
/**
* Checks how much of a given string can be mapped to glyphs in
* this font.
*
* @param s The string to check.
*
* @return The index of the first character in s which cannot
* be converted to a glyph by this font, or -1 if all
* characters can be mapped to glyphs.
*
* @since 1.2
*/
public int canDisplayUpTo(String s)
{
return peer.canDisplayUpTo(this, new StringCharacterIterator(s),
0, s.length() - 1);
}
/**
* Checks how much of a given sequence of text can be mapped to glyphs in
* this font.
*
* @param text Array containing the text to check.
* @param start Position of first character to check in text.
* @param limit Position of last character to check in text.
*
* @return The index of the first character in the indicated range which
* cannot be converted to a glyph by this font, or -1 if all
* characters can be mapped to glyphs.
*
* @since 1.2
*
* @throws IndexOutOfBoundsException if the range [start, limit] is
* invalid in text.
*/
public int canDisplayUpTo (char[] text, int start, int limit)
{
return peer.canDisplayUpTo(this,
new StringCharacterIterator(new String (text)),
start, limit);
}
/**
* Checks how much of a given sequence of text can be mapped to glyphs in
* this font.
*
* @param i Iterator over the text to check.
* @param start Position of first character to check in i.
* @param limit Position of last character to check in i.
*
* @return The index of the first character in the indicated range which
* cannot be converted to a glyph by this font, or -1 if all
* characters can be mapped to glyphs.
*
* @since 1.2
*
* @throws IndexOutOfBoundsException if the range [start, limit] is
* invalid in i.
*/
public int canDisplayUpTo(CharacterIterator i, int start, int limit)
{
return peer.canDisplayUpTo(this, i, start, limit);
}
/**
* Creates a new font with point size 1 and {@link #PLAIN} style,
* reading font data from the provided input stream. The resulting font
* can have further fonts derived from it using its
* deriveFont method.
*
* @param fontFormat Integer code indicating the format the font data is
* in.Currently this can only be {@link #TRUETYPE_FONT}.
* @param is {@link InputStream} from which font data will be read. This
* stream is not closed after font data is extracted.
*
* @return A new {@link Font} of the format indicated.
*
* @throws IllegalArgumentException if fontType is not
* recognized.
* @throws FontFormatException if data in InputStream is not of format
* indicated.
* @throws IOException if insufficient data is present on InputStream.
*
* @since 1.3
*/
public static Font createFont (int fontFormat, InputStream is)
throws FontFormatException, IOException
{
return tk().createFont(fontFormat, is);
}
/**
* Creates a new font from a File object.
*
* @see #layoutGlyphVector(FontRenderContext, char[], int, int, int)
*
* @param fontFormat - Integer code indicating the format the font data is
* in.Currently this can only be {@link #TRUETYPE_FONT}.
* @param file - a {@link File} from which font data will be read.
*
* @return A new {@link Font} of the format indicated.
*
* @throws IllegalArgumentException if fontType is not
* recognized.
* @throws NullPointerException if file is null.
* @throws FontFormatException if data in the file is invalid or cannot be read..
* @throws SecurityException if the caller has no read permission for the file.
* @throws IOException if the file cannot be read
*
* @since 1.5
*/
public static Font createFont (int fontFormat, File file)
throws FontFormatException, IOException
{
if( file == null )
throw new NullPointerException("Null file argument");
return tk().createFont(fontFormat, new FileInputStream( file ));
}
/**
* Maps characters to glyphs in a one-to-one relationship, returning a new
* {@link GlyphVector} with a mapped glyph for each input character. This
* sort of mapping is often sufficient for some scripts such as Roman, but
* is inappropriate for scripts with special shaping or contextual layout
* requirements such as Arabic, Indic, Hebrew or Thai.
*
* @param ctx The rendering context used for precise glyph placement.
* @param str The string to convert to Glyphs.
*
* @return A new {@link GlyphVector} containing glyphs mapped from str,
* through the font's cmap table.
*
* @see #layoutGlyphVector(FontRenderContext, char[], int, int, int)
*/
public GlyphVector createGlyphVector(FontRenderContext ctx, String str)
{
return peer.createGlyphVector(this, ctx, new StringCharacterIterator(str));
}
/**
* Maps characters to glyphs in a one-to-one relationship, returning a new
* {@link GlyphVector} with a mapped glyph for each input character. This
* sort of mapping is often sufficient for some scripts such as Roman, but
* is inappropriate for scripts with special shaping or contextual layout
* requirements such as Arabic, Indic, Hebrew or Thai.
*
* @param ctx The rendering context used for precise glyph placement.
* @param i Iterator over the text to convert to glyphs.
*
* @return A new {@link GlyphVector} containing glyphs mapped from str,
* through the font's cmap table.
*
* @see #layoutGlyphVector(FontRenderContext, char[], int, int, int)
*/
public GlyphVector createGlyphVector(FontRenderContext ctx,
CharacterIterator i)
{
return peer.createGlyphVector(this, ctx, i);
}
/**
* Maps characters to glyphs in a one-to-one relationship, returning a new
* {@link GlyphVector} with a mapped glyph for each input character. This
* sort of mapping is often sufficient for some scripts such as Roman, but
* is inappropriate for scripts with special shaping or contextual layout
* requirements such as Arabic, Indic, Hebrew or Thai.
*
* @param ctx The rendering context used for precise glyph placement.
* @param chars Array of characters to convert to glyphs.
*
* @return A new {@link GlyphVector} containing glyphs mapped from str,
* through the font's cmap table.
*
* @see #layoutGlyphVector(FontRenderContext, char[], int, int, int)
*/
public GlyphVector createGlyphVector(FontRenderContext ctx, char[] chars)
{
return peer.createGlyphVector(this, ctx,
new StringCharacterIterator(new String(chars)));
}
/**
* Extracts a sequence of glyphs from a font, returning a new {@link
* GlyphVector} with a mapped glyph for each input glyph code.
*
* @param ctx The rendering context used for precise glyph placement.
* @param glyphCodes Array of characters to convert to glyphs.
*
* @return A new {@link GlyphVector} containing glyphs mapped from str,
* through the font's cmap table.
*
* @see #layoutGlyphVector(FontRenderContext, char[], int, int, int)
*
* @specnote This method is documented to perform character-to-glyph
* conversions, in the Sun documentation, but its second parameter name is
* "glyphCodes" and it is not clear to me why it would exist if its
* purpose was to transport character codes inside integers. I assume it
* is mis-documented in the Sun documentation.
*/
public GlyphVector createGlyphVector(FontRenderContext ctx, int[] glyphCodes)
{
return peer.createGlyphVector(this, ctx, glyphCodes);
}
/**
* Produces a new {@link Font} based on the current font, adjusted to a
* new size and style.
*
* @param style The style of the newly created font.
* @param size The size of the newly created font.
*
* @return A clone of the current font, with the specified size and style.
*
* @since 1.2
*/
public Font deriveFont(int style, float size)
{
return peer.deriveFont(this, style, size);
}
/**
* Produces a new {@link Font} based on the current font, adjusted to a
* new size.
*
* @param size The size of the newly created font.
*
* @return A clone of the current font, with the specified size.
*
* @since 1.2
*/
public Font deriveFont(float size)
{
return peer.deriveFont(this, size);
}
/**
* Produces a new {@link Font} based on the current font, adjusted to a
* new style.
*
* @param style The style of the newly created font.
*
* @return A clone of the current font, with the specified style.
*
* @since 1.2
*/
public Font deriveFont(int style)
{
return peer.deriveFont(this, style);
}
/**
* Produces a new {@link Font} based on the current font, adjusted to a
* new style and subjected to a new affine transformation.
*
* @param style The style of the newly created font.
* @param a The transformation to apply.
*
* @return A clone of the current font, with the specified style and
* transform.
*
* @throws IllegalArgumentException If transformation is
* null.
*
* @since 1.2
*/
public Font deriveFont(int style, AffineTransform a)
{
if (a == null)
throw new IllegalArgumentException("Affine transformation is null");
return peer.deriveFont(this, style, a);
}
/**
* Produces a new {@link Font} based on the current font, subjected
* to a new affine transformation.
*
* @param a The transformation to apply.
*
* @return A clone of the current font, with the specified transform.
*
* @throws IllegalArgumentException If transformation is
* null.
*
* @since 1.2
*/
public Font deriveFont(AffineTransform a)
{
if (a == null)
throw new IllegalArgumentException("Affine transformation is null");
return peer.deriveFont(this, a);
}
/**
* Produces a new {@link Font} based on the current font, adjusted to a
* new set of attributes.
*
* @param attributes Attributes of the newly created font.
*
* @return A clone of the current font, with the specified attributes.
*
* @since 1.2
*/
public Font deriveFont(Map attributes)
{
return peer.deriveFont(this, attributes);
}
/**
* Returns a map of chracter attributes which this font currently has set.
*
* @return A map of chracter attributes which this font currently has set.
*
* @see #getAvailableAttributes()
* @see java.text.AttributedCharacterIterator.Attribute
* @see java.awt.font.TextAttribute
*/
public Maptext to measure.
* @param limit Index of last character in text to measure.
* @param rc Context for calculating precise glyph placement and hints.
*
* @return A new {@link LineMetrics} object.
*
* @throws IndexOutOfBoundsException if the range [begin, limit] is
* invalid in text.
*/
public LineMetrics getLineMetrics(String text, int begin,
int limit, FontRenderContext rc)
{
return peer.getLineMetrics(this, new StringCharacterIterator(text),
begin, limit, rc);
}
/**
* Returns a {@link LineMetrics} object constructed with the specified
* text and {@link FontRenderContext}.
*
* @param chars The string to calculate metrics from.
* @param begin Index of first character in text to measure.
* @param limit Index of last character in text to measure.
* @param rc Context for calculating precise glyph placement and hints.
*
* @return A new {@link LineMetrics} object.
*
* @throws IndexOutOfBoundsException if the range [begin, limit] is
* invalid in chars.
*/
public LineMetrics getLineMetrics(char[] chars, int begin,
int limit, FontRenderContext rc)
{
return peer.getLineMetrics(this,
new StringCharacterIterator(new String(chars)),
begin, limit, rc);
}
/**
* Returns a {@link LineMetrics} object constructed with the specified
* text and {@link FontRenderContext}.
*
* @param ci The string to calculate metrics from.
* @param begin Index of first character in text to measure.
* @param limit Index of last character in text to measure.
* @param rc Context for calculating precise glyph placement and hints.
*
* @return A new {@link LineMetrics} object.
*
* @throws IndexOutOfBoundsException if the range [begin, limit] is
* invalid in ci.
*/
public LineMetrics getLineMetrics(CharacterIterator ci, int begin,
int limit, FontRenderContext rc)
{
return peer.getLineMetrics(this, ci, begin, limit, rc);
}
/**
* Returns the maximal bounding box of all the bounding boxes in this
* font, when the font's bounding boxes are evaluated in a given {@link
* FontRenderContext}
*
* @param rc Context in which to evaluate bounding boxes.
*
* @return The maximal bounding box.
*/
public Rectangle2D getMaxCharBounds(FontRenderContext rc)
{
return peer.getMaxCharBounds(this, rc);
}
/**
* Returns the glyph code this font uses to represent missing glyphs. This
* code will be present in glyph vectors when the font was unable to
* locate a glyph to represent a particular character code.
*
* @return The missing glyph code.
*
* @since 1.2
*/
public int getMissingGlyphCode()
{
return peer.getMissingGlyphCode(this);
}
/**
* Returns the overall number of glyphs in this font. This number is one
* more than the greatest glyph code used in any glyph vectors this font
* produces. In other words, glyph codes are taken from the range
* [ 0, getNumGlyphs() - 1 ].
*
* @return The number of glyphs in this font.
*
* @since 1.2
*/
public int getNumGlyphs()
{
return peer.getNumGlyphs(this);
}
/**
* Returns the PostScript Name of this font.
*
* @return The PostScript Name of this font.
*
* @since 1.2
*
* @see #getName()
* @see #getFamily()
* @see #getFontName()
*/
public String getPSName()
{
return peer.getPostScriptName(this);
}
/**
* Returns the logical bounds of the specified string when rendered with this
* font in the specified {@link FontRenderContext}. This box will include the
* glyph origin, ascent, advance, height, and leading, but may not include all
* diacritics or accents. To get the complete visual bounding box of all the
* glyphs in a run of text, use the {@link TextLayout#getBounds} method of
* {@link TextLayout}.
*
* @param str The string to measure.
* @param frc The context in which to make the precise glyph measurements.
*
* @return A bounding box covering the logical bounds of the specified text.
*
* @see #createGlyphVector(FontRenderContext, String)
*/
public Rectangle2D getStringBounds(String str, FontRenderContext frc)
{
char[] chars = str.toCharArray();
return getStringBounds(chars, 0, chars.length, frc);
}
/**
* Returns the logical bounds of the specified string when rendered with this
* font in the specified {@link FontRenderContext}. This box will include the
* glyph origin, ascent, advance, height, and leading, but may not include all
* diacritics or accents. To get the complete visual bounding box of all the
* glyphs in a run of text, use the {@link TextLayout#getBounds} method of
* {@link TextLayout}.
*
* @param str The string to measure.
* @param begin Index of the first character in str to measure.
* @param limit Index of the last character in str to measure.
* @param frc The context in which to make the precise glyph measurements.
*
* @return A bounding box covering the logical bounds of the specified text.
*
* @throws IndexOutOfBoundsException if the range [begin, limit] is
* invalid in str.
*
* @since 1.2
*
* @see #createGlyphVector(FontRenderContext, String)
*/
public Rectangle2D getStringBounds(String str, int begin,
int limit, FontRenderContext frc)
{
String sub = str.substring(begin, limit);
return getStringBounds(sub, frc);
}
/**
* Returns the logical bounds of the specified string when rendered with this
* font in the specified {@link FontRenderContext}. This box will include the
* glyph origin, ascent, advance, height, and leading, but may not include all
* diacritics or accents. To get the complete visual bounding box of all the
* glyphs in a run of text, use the {@link TextLayout#getBounds} method of
* {@link TextLayout}.
*
* @param ci The text to measure.
* @param begin Index of the first character in ci to measure.
* @param limit Index of the last character in ci to measure.
* @param frc The context in which to make the precise glyph measurements.
*
* @return A bounding box covering the logical bounds of the specified text.
*
* @throws IndexOutOfBoundsException if the range [begin, limit] is
* invalid in ci.
*
* @since 1.2
*
* @see #createGlyphVector(FontRenderContext, CharacterIterator)
*/
public Rectangle2D getStringBounds(CharacterIterator ci, int begin,
int limit, FontRenderContext frc)
{
int start = ci.getBeginIndex();
int end = ci.getEndIndex();
char[] chars = new char[limit - start];
ci.setIndex(start);
for (int index = 0; index < chars.length; index++)
{
chars[index] = ci.current();
ci.next();
}
return getStringBounds(chars, 0, chars.length, frc);
}
/**
* Returns the logical bounds of the specified string when rendered with this
* font in the specified {@link FontRenderContext}. This box will include the
* glyph origin, ascent, advance, height, and leading, but may not include all
* diacritics or accents. To get the complete visual bounding box of all the
* glyphs in a run of text, use the {@link TextLayout#getBounds} method of
* {@link TextLayout}.
*
* @param chars The text to measure.
* @param begin Index of the first character in ci to measure.
* @param limit Index of the last character in ci to measure.
* @param frc The context in which to make the precise glyph measurements.
*
* @return A bounding box covering the logical bounds of the specified text.
*
* @throws IndexOutOfBoundsException if the range [begin, limit] is
* invalid in chars.
*
* @since 1.2
*
* @see #createGlyphVector(FontRenderContext, char[])
*/
public Rectangle2D getStringBounds(char[] chars, int begin,
int limit, FontRenderContext frc)
{
String str = new String(chars, begin, limit - begin);
TextLayout layout = new TextLayout(str, this, frc);
return new Rectangle2D.Float(0, -layout.getAscent(), layout.getAdvance(),
layout.getDescent() + layout.getLeading());
}
/**
* Returns a copy of the affine transformation this font is currently
* subject to, if any.
*
* @return The current transformation.
*/
public AffineTransform getTransform()
{
return peer.getTransform(this);
}
/**
* Indicates whether this font's line metrics are uniform. A font may be
* composed of several "subfonts", each covering a different code range,
* and each with their own line metrics. A font with no subfonts, or
* subfonts with identical line metrics, is said to have "uniform" line
* metrics.
*
* @return Whether this font has uniform line metrics.
*
* @see LineMetrics
* @see #getLineMetrics(String, FontRenderContext)
*/
public boolean hasUniformLineMetrics()
{
return peer.hasUniformLineMetrics(this);
}
/**
* Indicates whether this font is subject to a non-identity affine
* transformation.
*
* @return true iff the font has a non-identity affine
* transformation applied to it.
*/
public boolean isTransformed()
{
return peer.isTransformed(this);
}
/**
* Produces a glyph vector representing a full layout fo the specified
* text in this font. Full layouts may include complex shaping and
* reordering operations, for scripts such as Arabic or Hindi.
*
* Bidirectional (bidi) layout is not performed in this method; text
* should have its bidi direction specified with one of the flags {@link
* #LAYOUT_LEFT_TO_RIGHT} or {@link #LAYOUT_RIGHT_TO_LEFT}.
*
* Some types of layout (notably Arabic glyph shaping) may examine context
* characters beyond the bounds of the indicated range, in order to select
* an appropriate shape. The flags {@link #LAYOUT_NO_START_CONTEXT} and
* {@link #LAYOUT_NO_LIMIT_CONTEXT} can be provided to prevent these extra
* context areas from being examined, for instance if they contain invalid
* characters.
*
* @param frc Context in which to perform the layout.
* @param chars Text to perform layout on.
* @param start Index of first character to perform layout on.
* @param limit Index of last character to perform layout on.
* @param flags Combination of flags controlling layout.
*
* @return A new {@link GlyphVector} representing the specified text.
*
* @throws IndexOutOfBoundsException if the range [begin, limit] is
* invalid in chars.
*/
public GlyphVector layoutGlyphVector(FontRenderContext frc,
char[] chars, int start,
int limit, int flags)
{
return peer.layoutGlyphVector(this, frc, chars, start, limit, flags);
}
/**
* Returns a native peer object for this font.
*
* @return A native peer object for this font.
*
* @deprecated
*/
public FontPeer getPeer()
{
return peer;
}
/**
* Returns a hash value for this font.
*
* @return A hash for this font.
*/
public int hashCode()
{
// We cache the hashcode. This makes sense, because the font wouldn't
// change the relevant properties.
if (hashCode == 0)
{
hashCode = getName().hashCode() ^ getTransform().hashCode() ^ getSize()
^ getStyle();
// In the rare case when the above yields 0, we set this to some other
// value to avoid recomputing over and over again. This is still
// conform to the specification of hashCode().
if (hashCode == 0)
{
hashCode = -1;
}
}
return hashCode;
}
/**
* Tests whether or not the specified object is equal to this font. This
* will be true if and only if:
*
*
*
* @return null.
* Font.
* true if the specified object is equal to this
* object, false otherwise.
*/
public boolean equals(Object obj)
{
if (obj == null)
return false;
if (! (obj instanceof Font))
return false;
Font f = (Font) obj;
return (f.getName().equals(this.getName())
&& f.getFamily().equals(this.getFamily())
&& f.getFontName().equals(this.getFontName())
&& f.getTransform().equals(this.getTransform ())
&& f.getSize() == this.getSize()
&& f.getStyle() == this.getStyle());
}
/**
* Returns a string representation of this font.
*
* @return A string representation of this font.
*/
public String toString()
{
String styleString = "";
switch (getStyle())
{
case 0:
styleString = "plain";
break;
case 1:
styleString = "bold";
break;
case 2:
styleString = "italic";
break;
default:
styleString = "unknown";
}
return getClass().getName()
+ "[family=" + getFamily ()
+ ",name=" + getFontName ()
+ ",style=" + styleString
+ ",size=" + getSize () + "]";
}
/**
* Determines the line metrics for a run of text.
*
* @param str the text run to be measured.
*
* @param frc the font rendering parameters that are used for the
* measurement. The exact placement and size of text slightly
* depends on device-specific characteristics, for instance
* the device resolution or anti-aliasing. For this reason,
* the returned measurement will only be accurate if the
* passed FontRenderContext correctly reflects
* the relevant parameters. Hence, frc should be
* obtained from the same Graphics2D that will
* be used for drawing, and any rendering hints should be set
* to the desired values before obtaining frc.
*
* @see java.awt.Graphics2D#getFontRenderContext()
*/
public LineMetrics getLineMetrics(String str, FontRenderContext frc)
{
return getLineMetrics(str, 0, str.length() - 1, frc);
}
public boolean hasLayoutAttributes()
{
// TODO: Implement properly.
return false;
}
/**
* Reads the normal fields from the stream and then constructs the
* peer from the style and size through getPeerFromToolkit().
*/
private void readObject(ObjectInputStream ois)
throws IOException, ClassNotFoundException
{
ois.defaultReadObject();
HashMap attrs = new HashMap();
ClasspathFontPeer.copyStyleToAttrs(style, attrs);
ClasspathFontPeer.copySizeToAttrs(size, attrs);
peer = getPeerFromToolkit(name, attrs);
}
}