1 /*
2 * Copyright (c) 1995, 2015, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package java.awt;
27
28 import java.awt.font.FontRenderContext;
29 import java.awt.font.GlyphVector;
30 import java.awt.font.LineMetrics;
31 import java.awt.font.TextAttribute;
32 import java.awt.font.TextLayout;
33 import java.awt.geom.AffineTransform;
34 import java.awt.geom.Point2D;
35 import java.awt.geom.Rectangle2D;
36 import java.awt.peer.FontPeer;
37 import java.io.*;
38 import java.lang.ref.SoftReference;
39 import java.nio.file.Files;
40 import java.security.AccessController;
41 import java.security.PrivilegedExceptionAction;
42 import java.text.AttributedCharacterIterator.Attribute;
43 import java.text.CharacterIterator;
44 import java.util.Hashtable;
45 import java.util.Locale;
46 import java.util.Map;
47 import sun.font.StandardGlyphVector;
48
49 import sun.font.AttributeMap;
50 import sun.font.AttributeValues;
51 import sun.font.CompositeFont;
52 import sun.font.CreatedFontTracker;
53 import sun.font.Font2D;
54 import sun.font.Font2DHandle;
55 import sun.font.FontAccess;
56 import sun.font.FontManager;
57 import sun.font.FontManagerFactory;
58 import sun.font.FontUtilities;
59 import sun.font.GlyphLayout;
60 import sun.font.FontLineMetrics;
61 import sun.font.CoreMetrics;
62
63 import static sun.font.EAttribute.*;
64
65 /**
66 * The <code>Font</code> class represents fonts, which are used to
67 * render text in a visible way.
68 * A font provides the information needed to map sequences of
69 * <em>characters</em> to sequences of <em>glyphs</em>
70 * and to render sequences of glyphs on <code>Graphics</code> and
71 * <code>Component</code> objects.
72 *
73 * <h3>Characters and Glyphs</h3>
74 *
75 * A <em>character</em> is a symbol that represents an item such as a letter,
76 * a digit, or punctuation in an abstract way. For example, <code>'g'</code>,
77 * LATIN SMALL LETTER G, is a character.
78 * <p>
79 * A <em>glyph</em> is a shape used to render a character or a sequence of
80 * characters. In simple writing systems, such as Latin, typically one glyph
81 * represents one character. In general, however, characters and glyphs do not
82 * have one-to-one correspondence. For example, the character 'á'
83 * LATIN SMALL LETTER A WITH ACUTE, can be represented by
84 * two glyphs: one for 'a' and one for '´'. On the other hand, the
85 * two-character string "fi" can be represented by a single glyph, an
86 * "fi" ligature. In complex writing systems, such as Arabic or the South
87 * and South-East Asian writing systems, the relationship between characters
88 * and glyphs can be more complicated and involve context-dependent selection
89 * of glyphs as well as glyph reordering.
90 *
91 * A font encapsulates the collection of glyphs needed to render a selected set
92 * of characters as well as the tables needed to map sequences of characters to
93 * corresponding sequences of glyphs.
94 *
95 * <h3>Physical and Logical Fonts</h3>
96 *
97 * The Java Platform distinguishes between two kinds of fonts:
98 * <em>physical</em> fonts and <em>logical</em> fonts.
99 * <p>
100 * <em>Physical</em> fonts are the actual font libraries containing glyph data
101 * and tables to map from character sequences to glyph sequences, using a font
102 * technology such as TrueType or PostScript Type 1.
103 * All implementations of the Java Platform must support TrueType fonts;
104 * support for other font technologies is implementation dependent.
105 * Physical fonts may use names such as Helvetica, Palatino, HonMincho, or
106 * any number of other font names.
107 * Typically, each physical font supports only a limited set of writing
108 * systems, for example, only Latin characters or only Japanese and Basic
109 * Latin.
110 * The set of available physical fonts varies between configurations.
111 * Applications that require specific fonts can bundle them and instantiate
112 * them using the {@link #createFont createFont} method.
113 * <p>
114 * <em>Logical</em> fonts are the five font families defined by the Java
115 * platform which must be supported by any Java runtime environment:
116 * Serif, SansSerif, Monospaced, Dialog, and DialogInput.
117 * These logical fonts are not actual font libraries. Instead, the logical
118 * font names are mapped to physical fonts by the Java runtime environment.
119 * The mapping is implementation and usually locale dependent, so the look
120 * and the metrics provided by them vary.
121 * Typically, each logical font name maps to several physical fonts in order to
122 * cover a large range of characters.
123 * <p>
124 * Peered AWT components, such as {@link Label Label} and
125 * {@link TextField TextField}, can only use logical fonts.
126 * <p>
127 * For a discussion of the relative advantages and disadvantages of using
128 * physical or logical fonts, see the
129 * <a href="http://www.oracle.com/technetwork/java/javase/tech/faq-jsp-138165.html">Internationalization FAQ</a>
130 * document.
131 *
132 * <h3>Font Faces and Names</h3>
133 *
134 * A <code>Font</code>
135 * can have many faces, such as heavy, medium, oblique, gothic and
136 * regular. All of these faces have similar typographic design.
137 * <p>
138 * There are three different names that you can get from a
139 * <code>Font</code> object. The <em>logical font name</em> is simply the
140 * name that was used to construct the font.
141 * The <em>font face name</em>, or just <em>font name</em> for
142 * short, is the name of a particular font face, like Helvetica Bold. The
143 * <em>family name</em> is the name of the font family that determines the
144 * typographic design across several faces, like Helvetica.
145 * <p>
146 * The <code>Font</code> class represents an instance of a font face from
147 * a collection of font faces that are present in the system resources
148 * of the host system. As examples, Arial Bold and Courier Bold Italic
149 * are font faces. There can be several <code>Font</code> objects
150 * associated with a font face, each differing in size, style, transform
151 * and font features.
152 * <p>
153 * The {@link GraphicsEnvironment#getAllFonts() getAllFonts} method
154 * of the <code>GraphicsEnvironment</code> class returns an
155 * array of all font faces available in the system. These font faces are
156 * returned as <code>Font</code> objects with a size of 1, identity
157 * transform and default font features. These
158 * base fonts can then be used to derive new <code>Font</code> objects
159 * with varying sizes, styles, transforms and font features via the
160 * <code>deriveFont</code> methods in this class.
161 *
162 * <h3>Font and TextAttribute</h3>
163 *
164 * <p><code>Font</code> supports most
165 * <code>TextAttribute</code>s. This makes some operations, such as
166 * rendering underlined text, convenient since it is not
167 * necessary to explicitly construct a <code>TextLayout</code> object.
168 * Attributes can be set on a Font by constructing or deriving it
169 * using a <code>Map</code> of <code>TextAttribute</code> values.
170 *
171 * <p>The values of some <code>TextAttributes</code> are not
172 * serializable, and therefore attempting to serialize an instance of
173 * <code>Font</code> that has such values will not serialize them.
174 * This means a Font deserialized from such a stream will not compare
175 * equal to the original Font that contained the non-serializable
176 * attributes. This should very rarely pose a problem
177 * since these attributes are typically used only in special
178 * circumstances and are unlikely to be serialized.
179 *
180 * <ul>
181 * <li><code>FOREGROUND</code> and <code>BACKGROUND</code> use
182 * <code>Paint</code> values. The subclass <code>Color</code> is
183 * serializable, while <code>GradientPaint</code> and
184 * <code>TexturePaint</code> are not.</li>
185 * <li><code>CHAR_REPLACEMENT</code> uses
186 * <code>GraphicAttribute</code> values. The subclasses
187 * <code>ShapeGraphicAttribute</code> and
188 * <code>ImageGraphicAttribute</code> are not serializable.</li>
189 * <li><code>INPUT_METHOD_HIGHLIGHT</code> uses
190 * <code>InputMethodHighlight</code> values, which are
191 * not serializable. See {@link java.awt.im.InputMethodHighlight}.</li>
192 * </ul>
193 *
194 * <p>Clients who create custom subclasses of <code>Paint</code> and
195 * <code>GraphicAttribute</code> can make them serializable and
196 * avoid this problem. Clients who use input method highlights can
197 * convert these to the platform-specific attributes for that
198 * highlight on the current platform and set them on the Font as
199 * a workaround.
200 *
201 * <p>The <code>Map</code>-based constructor and
202 * <code>deriveFont</code> APIs ignore the FONT attribute, and it is
203 * not retained by the Font; the static {@link #getFont} method should
204 * be used if the FONT attribute might be present. See {@link
205 * java.awt.font.TextAttribute#FONT} for more information.</p>
206 *
207 * <p>Several attributes will cause additional rendering overhead
208 * and potentially invoke layout. If a <code>Font</code> has such
209 * attributes, the <code>{@link #hasLayoutAttributes()}</code> method
210 * will return true.</p>
211 *
212 * <p>Note: Font rotations can cause text baselines to be rotated. In
213 * order to account for this (rare) possibility, font APIs are
214 * specified to return metrics and take parameters 'in
215 * baseline-relative coordinates'. This maps the 'x' coordinate to
216 * the advance along the baseline, (positive x is forward along the
217 * baseline), and the 'y' coordinate to a distance along the
218 * perpendicular to the baseline at 'x' (positive y is 90 degrees
219 * clockwise from the baseline vector). APIs for which this is
220 * especially important are called out as having 'baseline-relative
221 * coordinates.'
222 */
223 public class Font implements java.io.Serializable
224 {
225 private static class FontAccessImpl extends FontAccess {
226 public Font2D getFont2D(Font font) {
227 return font.getFont2D();
228 }
229
230 public void setFont2D(Font font, Font2DHandle handle) {
231 font.font2DHandle = handle;
232 }
233
234 public void setCreatedFont(Font font) {
235 font.createdFont = true;
236 }
237
238 public boolean isCreatedFont(Font font) {
239 return font.createdFont;
240 }
241
242 @Override
243 public FontPeer getFontPeer(final Font font) {
244 return font.getFontPeer();
245 }
246 }
247
248 static {
249 /* ensure that the necessary native libraries are loaded */
250 Toolkit.loadLibraries();
251 initIDs();
252 FontAccess.setFontAccess(new FontAccessImpl());
253 }
254
255 /**
256 * This is now only used during serialization. Typically
257 * it is null.
258 *
259 * @serial
260 * @see #getAttributes()
261 */
262 private Hashtable<Object, Object> fRequestedAttributes;
263
264 /*
265 * Constants to be used for logical font family names.
266 */
267
268 /**
269 * A String constant for the canonical family name of the
270 * logical font "Dialog". It is useful in Font construction
271 * to provide compile-time verification of the name.
272 * @since 1.6
273 */
274 public static final String DIALOG = "Dialog";
275
276 /**
277 * A String constant for the canonical family name of the
278 * logical font "DialogInput". It is useful in Font construction
279 * to provide compile-time verification of the name.
280 * @since 1.6
281 */
282 public static final String DIALOG_INPUT = "DialogInput";
283
284 /**
285 * A String constant for the canonical family name of the
286 * logical font "SansSerif". It is useful in Font construction
287 * to provide compile-time verification of the name.
288 * @since 1.6
289 */
290 public static final String SANS_SERIF = "SansSerif";
291
292 /**
293 * A String constant for the canonical family name of the
294 * logical font "Serif". It is useful in Font construction
295 * to provide compile-time verification of the name.
296 * @since 1.6
297 */
298 public static final String SERIF = "Serif";
299
300 /**
301 * A String constant for the canonical family name of the
302 * logical font "Monospaced". It is useful in Font construction
303 * to provide compile-time verification of the name.
304 * @since 1.6
305 */
306 public static final String MONOSPACED = "Monospaced";
307
308 /*
309 * Constants to be used for styles. Can be combined to mix
310 * styles.
311 */
312
313 /**
314 * The plain style constant.
315 */
316 public static final int PLAIN = 0;
317
318 /**
319 * The bold style constant. This can be combined with the other style
320 * constants (except PLAIN) for mixed styles.
321 */
322 public static final int BOLD = 1;
323
324 /**
325 * The italicized style constant. This can be combined with the other
326 * style constants (except PLAIN) for mixed styles.
327 */
328 public static final int ITALIC = 2;
329
330 /**
331 * The baseline used in most Roman scripts when laying out text.
332 */
333 public static final int ROMAN_BASELINE = 0;
334
335 /**
336 * The baseline used in ideographic scripts like Chinese, Japanese,
337 * and Korean when laying out text.
338 */
339 public static final int CENTER_BASELINE = 1;
340
341 /**
342 * The baseline used in Devanagari and similar scripts when laying
343 * out text.
344 */
345 public static final int HANGING_BASELINE = 2;
346
347 /**
348 * Identify a font resource of type TRUETYPE.
349 * Used to specify a TrueType font resource to the
350 * {@link #createFont} method.
351 * The TrueType format was extended to become the OpenType
352 * format, which adds support for fonts with Postscript outlines,
353 * this tag therefore references these fonts, as well as those
354 * with TrueType outlines.
355 * @since 1.3
356 */
357
358 public static final int TRUETYPE_FONT = 0;
359
360 /**
361 * Identify a font resource of type TYPE1.
362 * Used to specify a Type1 font resource to the
363 * {@link #createFont} method.
364 * @since 1.5
365 */
366 public static final int TYPE1_FONT = 1;
367
368 /**
369 * The logical name of this <code>Font</code>, as passed to the
370 * constructor.
371 * @since 1.0
372 *
373 * @serial
374 * @see #getName
375 */
376 protected String name;
377
378 /**
379 * The style of this <code>Font</code>, as passed to the constructor.
380 * This style can be PLAIN, BOLD, ITALIC, or BOLD+ITALIC.
381 * @since 1.0
382 *
383 * @serial
384 * @see #getStyle()
385 */
386 protected int style;
387
388 /**
389 * The point size of this <code>Font</code>, rounded to integer.
390 * @since 1.0
391 *
392 * @serial
393 * @see #getSize()
394 */
395 protected int size;
396
397 /**
398 * The point size of this <code>Font</code> in <code>float</code>.
399 *
400 * @serial
401 * @see #getSize()
402 * @see #getSize2D()
403 */
404 protected float pointSize;
405
406 /**
407 * The platform specific font information.
408 */
409 private transient FontPeer peer;
410 private transient long pData; // native JDK1.1 font pointer
411 private transient Font2DHandle font2DHandle;
412
413 private transient AttributeValues values;
414 private transient boolean hasLayoutAttributes;
415
416 /*
417 * If the origin of a Font is a created font then this attribute
418 * must be set on all derived fonts too.
419 */
420 private transient boolean createdFont = false;
421
422 /*
423 * This is true if the font transform is not identity. It
424 * is used to avoid unnecessary instantiation of an AffineTransform.
425 */
426 private transient boolean nonIdentityTx;
427
428 /*
429 * A cached value used when a transform is required for internal
430 * use. This must not be exposed to callers since AffineTransform
431 * is mutable.
432 */
433 private static final AffineTransform identityTx = new AffineTransform();
434
435 /*
436 * JDK 1.1 serialVersionUID
437 */
438 private static final long serialVersionUID = -4206021311591459213L;
439
440 /**
441 * Gets the peer of this {@code Font}.
442 *
443 * @return the peer of the {@code Font}.
444 */
445 @SuppressWarnings("deprecation")
446 private FontPeer getFontPeer() {
447 if(peer == null) {
448 Toolkit tk = Toolkit.getDefaultToolkit();
449 peer = tk.getFontPeer(name, style);
450 }
451 return peer;
452 }
453
454 /**
455 * Return the AttributeValues object associated with this
456 * font. Most of the time, the internal object is null.
457 * If required, it will be created from the 'standard'
458 * state on the font. Only non-default values will be
459 * set in the AttributeValues object.
460 *
461 * <p>Since the AttributeValues object is mutable, and it
462 * is cached in the font, care must be taken to ensure that
463 * it is not mutated.
464 */
465 private AttributeValues getAttributeValues() {
466 if (values == null) {
467 AttributeValues valuesTmp = new AttributeValues();
468 valuesTmp.setFamily(name);
469 valuesTmp.setSize(pointSize); // expects the float value.
470
471 if ((style & BOLD) != 0) {
472 valuesTmp.setWeight(2); // WEIGHT_BOLD
473 }
474
475 if ((style & ITALIC) != 0) {
476 valuesTmp.setPosture(.2f); // POSTURE_OBLIQUE
477 }
478 valuesTmp.defineAll(PRIMARY_MASK); // for streaming compatibility
479 values = valuesTmp;
480 }
481
482 return values;
483 }
484
485 private Font2D getFont2D() {
486 FontManager fm = FontManagerFactory.getInstance();
487 if (fm.usingPerAppContextComposites() &&
488 font2DHandle != null &&
489 font2DHandle.font2D instanceof CompositeFont &&
490 ((CompositeFont)(font2DHandle.font2D)).isStdComposite()) {
491 return fm.findFont2D(name, style,
492 FontManager.LOGICAL_FALLBACK);
493 } else if (font2DHandle == null) {
494 font2DHandle =
495 fm.findFont2D(name, style,
496 FontManager.LOGICAL_FALLBACK).handle;
497 }
498 /* Do not cache the de-referenced font2D. It must be explicitly
499 * de-referenced to pick up a valid font in the event that the
500 * original one is marked invalid
501 */
502 return font2DHandle.font2D;
503 }
504
505 /**
506 * Creates a new <code>Font</code> from the specified name, style and
507 * point size.
508 * <p>
509 * The font name can be a font face name or a font family name.
510 * It is used together with the style to find an appropriate font face.
511 * When a font family name is specified, the style argument is used to
512 * select the most appropriate face from the family. When a font face
513 * name is specified, the face's style and the style argument are
514 * merged to locate the best matching font from the same family.
515 * For example if face name "Arial Bold" is specified with style
516 * <code>Font.ITALIC</code>, the font system looks for a face in the
517 * "Arial" family that is bold and italic, and may associate the font
518 * instance with the physical font face "Arial Bold Italic".
519 * The style argument is merged with the specified face's style, not
520 * added or subtracted.
521 * This means, specifying a bold face and a bold style does not
522 * double-embolden the font, and specifying a bold face and a plain
523 * style does not lighten the font.
524 * <p>
525 * If no face for the requested style can be found, the font system
526 * may apply algorithmic styling to achieve the desired style.
527 * For example, if <code>ITALIC</code> is requested, but no italic
528 * face is available, glyphs from the plain face may be algorithmically
529 * obliqued (slanted).
530 * <p>
531 * Font name lookup is case insensitive, using the case folding
532 * rules of the US locale.
533 * <p>
534 * If the <code>name</code> parameter represents something other than a
535 * logical font, i.e. is interpreted as a physical font face or family, and
536 * this cannot be mapped by the implementation to a physical font or a
537 * compatible alternative, then the font system will map the Font
538 * instance to "Dialog", such that for example, the family as reported
539 * by {@link #getFamily() getFamily} will be "Dialog".
540 *
541 * @param name the font name. This can be a font face name or a font
542 * family name, and may represent either a logical font or a physical
543 * font found in this {@code GraphicsEnvironment}.
544 * The family names for logical fonts are: Dialog, DialogInput,
545 * Monospaced, Serif, or SansSerif. Pre-defined String constants exist
546 * for all of these names, for example, {@code DIALOG}. If {@code name} is
547 * {@code null}, the <em>logical font name</em> of the new
548 * {@code Font} as returned by {@code getName()} is set to
549 * the name "Default".
550 * @param style the style constant for the {@code Font}
551 * The style argument is an integer bitmask that may
552 * be {@code PLAIN}, or a bitwise union of {@code BOLD} and/or
553 * {@code ITALIC} (for example, {@code ITALIC} or {@code BOLD|ITALIC}).
554 * If the style argument does not conform to one of the expected
555 * integer bitmasks then the style is set to {@code PLAIN}.
556 * @param size the point size of the {@code Font}
557 * @see GraphicsEnvironment#getAllFonts
558 * @see GraphicsEnvironment#getAvailableFontFamilyNames
559 * @since 1.0
560 */
561 public Font(String name, int style, int size) {
562 this.name = (name != null) ? name : "Default";
563 this.style = (style & ~0x03) == 0 ? style : 0;
564 this.size = size;
565 this.pointSize = size;
566 }
567
568 private Font(String name, int style, float sizePts) {
569 this.name = (name != null) ? name : "Default";
570 this.style = (style & ~0x03) == 0 ? style : 0;
571 this.size = (int)(sizePts + 0.5);
572 this.pointSize = sizePts;
573 }
574
575 /* This constructor is used by deriveFont when attributes is null */
576 private Font(String name, int style, float sizePts,
577 boolean created, Font2DHandle handle) {
578 this(name, style, sizePts);
579 this.createdFont = created;
580 /* Fonts created from a stream will use the same font2D instance
581 * as the parent.
582 * One exception is that if the derived font is requested to be
583 * in a different style, then also check if its a CompositeFont
584 * and if so build a new CompositeFont from components of that style.
585 * CompositeFonts can only be marked as "created" if they are used
586 * to add fall backs to a physical font. And non-composites are
587 * always from "Font.createFont()" and shouldn't get this treatment.
588 */
589 if (created) {
590 if (handle.font2D instanceof CompositeFont &&
591 handle.font2D.getStyle() != style) {
592 FontManager fm = FontManagerFactory.getInstance();
593 this.font2DHandle = fm.getNewComposite(null, style, handle);
594 } else {
595 this.font2DHandle = handle;
596 }
597 }
598 }
599
600 /* used to implement Font.createFont */
601 private Font(File fontFile, int fontFormat,
602 boolean isCopy, CreatedFontTracker tracker)
603 throws FontFormatException {
604 this.createdFont = true;
605 /* Font2D instances created by this method track their font file
606 * so that when the Font2D is GC'd it can also remove the file.
607 */
608 FontManager fm = FontManagerFactory.getInstance();
609 this.font2DHandle = fm.createFont2D(fontFile, fontFormat, isCopy,
610 tracker).handle;
611 this.name = this.font2DHandle.font2D.getFontName(Locale.getDefault());
612 this.style = Font.PLAIN;
613 this.size = 1;
614 this.pointSize = 1f;
615 }
616
617 /* This constructor is used when one font is derived from another.
618 * Fonts created from a stream will use the same font2D instance as the
619 * parent. They can be distinguished because the "created" argument
620 * will be "true". Since there is no way to recreate these fonts they
621 * need to have the handle to the underlying font2D passed in.
622 * "created" is also true when a special composite is referenced by the
623 * handle for essentially the same reasons.
624 * But when deriving a font in these cases two particular attributes
625 * need special attention: family/face and style.
626 * The "composites" in these cases need to be recreated with optimal
627 * fonts for the new values of family and style.
628 * For fonts created with createFont() these are treated differently.
629 * JDK can often synthesise a different style (bold from plain
630 * for example). For fonts created with "createFont" this is a reasonable
631 * solution but its also possible (although rare) to derive a font with a
632 * different family attribute. In this case JDK needs
633 * to break the tie with the original Font2D and find a new Font.
634 * The oldName and oldStyle are supplied so they can be compared with
635 * what the Font2D and the values. To speed things along :
636 * oldName == null will be interpreted as the name is unchanged.
637 * oldStyle = -1 will be interpreted as the style is unchanged.
638 * In these cases there is no need to interrogate "values".
639 */
640 private Font(AttributeValues values, String oldName, int oldStyle,
641 boolean created, Font2DHandle handle) {
642
643 this.createdFont = created;
644 if (created) {
645 this.font2DHandle = handle;
646
647 String newName = null;
648 if (oldName != null) {
649 newName = values.getFamily();
650 if (oldName.equals(newName)) newName = null;
651 }
652 int newStyle = 0;
653 if (oldStyle == -1) {
654 newStyle = -1;
655 } else {
656 if (values.getWeight() >= 2f) newStyle = BOLD;
657 if (values.getPosture() >= .2f) newStyle |= ITALIC;
658 if (oldStyle == newStyle) newStyle = -1;
659 }
660 if (handle.font2D instanceof CompositeFont) {
661 if (newStyle != -1 || newName != null) {
662 FontManager fm = FontManagerFactory.getInstance();
663 this.font2DHandle =
664 fm.getNewComposite(newName, newStyle, handle);
665 }
666 } else if (newName != null) {
667 this.createdFont = false;
668 this.font2DHandle = null;
669 }
670 }
671 initFromValues(values);
672 }
673
674 /**
675 * Creates a new <code>Font</code> with the specified attributes.
676 * Only keys defined in {@link java.awt.font.TextAttribute TextAttribute}
677 * are recognized. In addition the FONT attribute is
678 * not recognized by this constructor
679 * (see {@link #getAvailableAttributes}). Only attributes that have
680 * values of valid types will affect the new <code>Font</code>.
681 * <p>
682 * If <code>attributes</code> is <code>null</code>, a new
683 * <code>Font</code> is initialized with default values.
684 * @see java.awt.font.TextAttribute
685 * @param attributes the attributes to assign to the new
686 * <code>Font</code>, or <code>null</code>
687 */
688 public Font(Map<? extends Attribute, ?> attributes) {
689 initFromValues(AttributeValues.fromMap(attributes, RECOGNIZED_MASK));
690 }
691
692 /**
693 * Creates a new <code>Font</code> from the specified <code>font</code>.
694 * This constructor is intended for use by subclasses.
695 * @param font from which to create this <code>Font</code>.
696 * @throws NullPointerException if <code>font</code> is null
697 * @since 1.6
698 */
699 protected Font(Font font) {
700 if (font.values != null) {
701 initFromValues(font.getAttributeValues().clone());
702 } else {
703 this.name = font.name;
704 this.style = font.style;
705 this.size = font.size;
706 this.pointSize = font.pointSize;
707 }
708 this.font2DHandle = font.font2DHandle;
709 this.createdFont = font.createdFont;
710 }
711
712 /**
713 * Font recognizes all attributes except FONT.
714 */
715 private static final int RECOGNIZED_MASK = AttributeValues.MASK_ALL
716 & ~AttributeValues.getMask(EFONT);
717
718 /**
719 * These attributes are considered primary by the FONT attribute.
720 */
721 private static final int PRIMARY_MASK =
722 AttributeValues.getMask(EFAMILY, EWEIGHT, EWIDTH, EPOSTURE, ESIZE,
723 ETRANSFORM, ESUPERSCRIPT, ETRACKING);
724
725 /**
726 * These attributes are considered secondary by the FONT attribute.
727 */
728 private static final int SECONDARY_MASK =
729 RECOGNIZED_MASK & ~PRIMARY_MASK;
730
731 /**
732 * These attributes are handled by layout.
733 */
734 private static final int LAYOUT_MASK =
735 AttributeValues.getMask(ECHAR_REPLACEMENT, EFOREGROUND, EBACKGROUND,
736 EUNDERLINE, ESTRIKETHROUGH, ERUN_DIRECTION,
737 EBIDI_EMBEDDING, EJUSTIFICATION,
738 EINPUT_METHOD_HIGHLIGHT, EINPUT_METHOD_UNDERLINE,
739 ESWAP_COLORS, ENUMERIC_SHAPING, EKERNING,
740 ELIGATURES, ETRACKING, ESUPERSCRIPT);
741
742 private static final int EXTRA_MASK =
743 AttributeValues.getMask(ETRANSFORM, ESUPERSCRIPT, EWIDTH);
744
745 /**
746 * Initialize the standard Font fields from the values object.
747 */
748 private void initFromValues(AttributeValues values) {
749 this.values = values;
750 values.defineAll(PRIMARY_MASK); // for 1.5 streaming compatibility
751
752 this.name = values.getFamily();
753 this.pointSize = values.getSize();
754 this.size = (int)(values.getSize() + 0.5);
755 if (values.getWeight() >= 2f) this.style |= BOLD; // not == 2f
756 if (values.getPosture() >= .2f) this.style |= ITALIC; // not == .2f
757
758 this.nonIdentityTx = values.anyNonDefault(EXTRA_MASK);
759 this.hasLayoutAttributes = values.anyNonDefault(LAYOUT_MASK);
760 }
761
762 /**
763 * Returns a <code>Font</code> appropriate to the attributes.
764 * If <code>attributes</code>contains a <code>FONT</code> attribute
765 * with a valid <code>Font</code> as its value, it will be
766 * merged with any remaining attributes. See
767 * {@link java.awt.font.TextAttribute#FONT} for more
768 * information.
769 *
770 * @param attributes the attributes to assign to the new
771 * <code>Font</code>
772 * @return a new <code>Font</code> created with the specified
773 * attributes
774 * @throws NullPointerException if <code>attributes</code> is null.
775 * @since 1.2
776 * @see java.awt.font.TextAttribute
777 */
778 public static Font getFont(Map<? extends Attribute, ?> attributes) {
779 // optimize for two cases:
780 // 1) FONT attribute, and nothing else
781 // 2) attributes, but no FONT
782
783 // avoid turning the attributemap into a regular map for no reason
784 if (attributes instanceof AttributeMap &&
785 ((AttributeMap)attributes).getValues() != null) {
786 AttributeValues values = ((AttributeMap)attributes).getValues();
787 if (values.isNonDefault(EFONT)) {
788 Font font = values.getFont();
789 if (!values.anyDefined(SECONDARY_MASK)) {
790 return font;
791 }
792 // merge
793 values = font.getAttributeValues().clone();
794 values.merge(attributes, SECONDARY_MASK);
795 return new Font(values, font.name, font.style,
796 font.createdFont, font.font2DHandle);
797 }
798 return new Font(attributes);
799 }
800
801 Font font = (Font)attributes.get(TextAttribute.FONT);
802 if (font != null) {
803 if (attributes.size() > 1) { // oh well, check for anything else
804 AttributeValues values = font.getAttributeValues().clone();
805 values.merge(attributes, SECONDARY_MASK);
806 return new Font(values, font.name, font.style,
807 font.createdFont, font.font2DHandle);
808 }
809
810 return font;
811 }
812
813 return new Font(attributes);
814 }
815
816 /**
817 * Used with the byte count tracker for fonts created from streams.
818 * If a thread can create temp files anyway, no point in counting
819 * font bytes.
820 */
821 private static boolean hasTempPermission() {
822
823 if (System.getSecurityManager() == null) {
824 return true;
825 }
826 File f = null;
827 boolean hasPerm = false;
828 try {
829 f = Files.createTempFile("+~JT", ".tmp").toFile();
830 f.delete();
831 f = null;
832 hasPerm = true;
833 } catch (Throwable t) {
834 /* inc. any kind of SecurityException */
835 }
836 return hasPerm;
837 }
838
839 /**
840 * Returns a new <code>Font</code> using the specified font type
841 * and input data. The new <code>Font</code> is
842 * created with a point size of 1 and style {@link #PLAIN PLAIN}.
843 * This base font can then be used with the <code>deriveFont</code>
844 * methods in this class to derive new <code>Font</code> objects with
845 * varying sizes, styles, transforms and font features. This
846 * method does not close the {@link InputStream}.
847 * <p>
848 * To make the <code>Font</code> available to Font constructors the
849 * returned <code>Font</code> must be registered in the
850 * <code>GraphicsEnvironment</code> by calling
851 * {@link GraphicsEnvironment#registerFont(Font) registerFont(Font)}.
852 * @param fontFormat the type of the <code>Font</code>, which is
853 * {@link #TRUETYPE_FONT TRUETYPE_FONT} if a TrueType resource is specified.
854 * or {@link #TYPE1_FONT TYPE1_FONT} if a Type 1 resource is specified.
855 * @param fontStream an <code>InputStream</code> object representing the
856 * input data for the font.
857 * @return a new <code>Font</code> created with the specified font type.
858 * @throws IllegalArgumentException if <code>fontFormat</code> is not
859 * <code>TRUETYPE_FONT</code>or<code>TYPE1_FONT</code>.
860 * @throws FontFormatException if the <code>fontStream</code> data does
861 * not contain the required font tables for the specified format.
862 * @throws IOException if the <code>fontStream</code>
863 * cannot be completely read.
864 * @see GraphicsEnvironment#registerFont(Font)
865 * @since 1.3
866 */
867 public static Font createFont(int fontFormat, InputStream fontStream)
868 throws java.awt.FontFormatException, java.io.IOException {
869
870 if (hasTempPermission()) {
871 return createFont0(fontFormat, fontStream, null);
872 }
873
874 // Otherwise, be extra conscious of pending temp file creation and
875 // resourcefully handle the temp file resources, among other things.
876 CreatedFontTracker tracker = CreatedFontTracker.getTracker();
877 boolean acquired = false;
878 try {
879 acquired = tracker.acquirePermit();
880 if (!acquired) {
881 throw new IOException("Timed out waiting for resources.");
882 }
883 return createFont0(fontFormat, fontStream, tracker);
884 } catch (InterruptedException e) {
885 throw new IOException("Problem reading font data.");
886 } finally {
887 if (acquired) {
888 tracker.releasePermit();
889 }
890 }
891 }
892
893 private static Font createFont0(int fontFormat, InputStream fontStream,
894 CreatedFontTracker tracker)
895 throws java.awt.FontFormatException, java.io.IOException {
896
897 if (fontFormat != Font.TRUETYPE_FONT &&
898 fontFormat != Font.TYPE1_FONT) {
899 throw new IllegalArgumentException ("font format not recognized");
900 }
901 boolean copiedFontData = false;
902 try {
903 final File tFile = AccessController.doPrivileged(
904 new PrivilegedExceptionAction<File>() {
905 public File run() throws IOException {
906 return Files.createTempFile("+~JF", ".tmp").toFile();
907 }
908 }
909 );
910 if (tracker != null) {
911 tracker.add(tFile);
912 }
913
914 int totalSize = 0;
915 try {
916 final OutputStream outStream =
917 AccessController.doPrivileged(
918 new PrivilegedExceptionAction<OutputStream>() {
919 public OutputStream run() throws IOException {
920 return new FileOutputStream(tFile);
921 }
922 }
923 );
924 if (tracker != null) {
925 tracker.set(tFile, outStream);
926 }
927 try {
928 byte[] buf = new byte[8192];
929 for (;;) {
930 int bytesRead = fontStream.read(buf);
931 if (bytesRead < 0) {
932 break;
933 }
934 if (tracker != null) {
935 if (totalSize+bytesRead > CreatedFontTracker.MAX_FILE_SIZE) {
936 throw new IOException("File too big.");
937 }
938 if (totalSize+tracker.getNumBytes() >
939 CreatedFontTracker.MAX_TOTAL_BYTES)
940 {
941 throw new IOException("Total files too big.");
942 }
943 totalSize += bytesRead;
944 tracker.addBytes(bytesRead);
945 }
946 outStream.write(buf, 0, bytesRead);
947 }
948 /* don't close the input stream */
949 } finally {
950 outStream.close();
951 }
952 /* After all references to a Font2D are dropped, the file
953 * will be removed. To support long-lived AppContexts,
954 * we need to then decrement the byte count by the size
955 * of the file.
956 * If the data isn't a valid font, the implementation will
957 * delete the tmp file and decrement the byte count
958 * in the tracker object before returning from the
959 * constructor, so we can set 'copiedFontData' to true here
960 * without waiting for the results of that constructor.
961 */
962 copiedFontData = true;
963 Font font = new Font(tFile, fontFormat, true, tracker);
964 return font;
965 } finally {
966 if (tracker != null) {
967 tracker.remove(tFile);
968 }
969 if (!copiedFontData) {
970 if (tracker != null) {
971 tracker.subBytes(totalSize);
972 }
973 AccessController.doPrivileged(
974 new PrivilegedExceptionAction<Void>() {
975 public Void run() {
976 tFile.delete();
977 return null;
978 }
979 }
980 );
981 }
982 }
983 } catch (Throwable t) {
984 if (t instanceof FontFormatException) {
985 throw (FontFormatException)t;
986 }
987 if (t instanceof IOException) {
988 throw (IOException)t;
989 }
990 Throwable cause = t.getCause();
991 if (cause instanceof FontFormatException) {
992 throw (FontFormatException)cause;
993 }
994 throw new IOException("Problem reading font data.");
995 }
996 }
997
998 /**
999 * Returns a new <code>Font</code> using the specified font type
1000 * and the specified font file. The new <code>Font</code> is
1001 * created with a point size of 1 and style {@link #PLAIN PLAIN}.
1002 * This base font can then be used with the <code>deriveFont</code>
1003 * methods in this class to derive new <code>Font</code> objects with
1004 * varying sizes, styles, transforms and font features.
1005 * @param fontFormat the type of the <code>Font</code>, which is
1006 * {@link #TRUETYPE_FONT TRUETYPE_FONT} if a TrueType resource is
1007 * specified or {@link #TYPE1_FONT TYPE1_FONT} if a Type 1 resource is
1008 * specified.
1009 * So long as the returned font, or its derived fonts are referenced
1010 * the implementation may continue to access <code>fontFile</code>
1011 * to retrieve font data. Thus the results are undefined if the file
1012 * is changed, or becomes inaccessible.
1013 * <p>
1014 * To make the <code>Font</code> available to Font constructors the
1015 * returned <code>Font</code> must be registered in the
1016 * <code>GraphicsEnvironment</code> by calling
1017 * {@link GraphicsEnvironment#registerFont(Font) registerFont(Font)}.
1018 * @param fontFile a <code>File</code> object representing the
1019 * input data for the font.
1020 * @return a new <code>Font</code> created with the specified font type.
1021 * @throws IllegalArgumentException if <code>fontFormat</code> is not
1022 * <code>TRUETYPE_FONT</code>or<code>TYPE1_FONT</code>.
1023 * @throws NullPointerException if <code>fontFile</code> is null.
1024 * @throws IOException if the <code>fontFile</code> cannot be read.
1025 * @throws FontFormatException if <code>fontFile</code> does
1026 * not contain the required font tables for the specified format.
1027 * @throws SecurityException if the executing code does not have
1028 * permission to read from the file.
1029 * @see GraphicsEnvironment#registerFont(Font)
1030 * @since 1.5
1031 */
1032 public static Font createFont(int fontFormat, File fontFile)
1033 throws java.awt.FontFormatException, java.io.IOException {
1034
1035 fontFile = new File(fontFile.getPath());
1036
1037 if (fontFormat != Font.TRUETYPE_FONT &&
1038 fontFormat != Font.TYPE1_FONT) {
1039 throw new IllegalArgumentException ("font format not recognized");
1040 }
1041 SecurityManager sm = System.getSecurityManager();
1042 if (sm != null) {
1043 FilePermission filePermission =
1044 new FilePermission(fontFile.getPath(), "read");
1045 sm.checkPermission(filePermission);
1046 }
1047 if (!fontFile.canRead()) {
1048 throw new IOException("Can't read " + fontFile);
1049 }
1050 return new Font(fontFile, fontFormat, false, null);
1051 }
1052
1053 /**
1054 * Returns a copy of the transform associated with this
1055 * <code>Font</code>. This transform is not necessarily the one
1056 * used to construct the font. If the font has algorithmic
1057 * superscripting or width adjustment, this will be incorporated
1058 * into the returned <code>AffineTransform</code>.
1059 * <p>
1060 * Typically, fonts will not be transformed. Clients generally
1061 * should call {@link #isTransformed} first, and only call this
1062 * method if <code>isTransformed</code> returns true.
1063 *
1064 * @return an {@link AffineTransform} object representing the
1065 * transform attribute of this <code>Font</code> object.
1066 */
1067 public AffineTransform getTransform() {
1068 /* The most common case is the identity transform. Most callers
1069 * should call isTransformed() first, to decide if they need to
1070 * get the transform, but some may not. Here we check to see
1071 * if we have a nonidentity transform, and only do the work to
1072 * fetch and/or compute it if so, otherwise we return a new
1073 * identity transform.
1074 *
1075 * Note that the transform is _not_ necessarily the same as
1076 * the transform passed in as an Attribute in a Map, as the
1077 * transform returned will also reflect the effects of WIDTH and
1078 * SUPERSCRIPT attributes. Clients who want the actual transform
1079 * need to call getRequestedAttributes.
1080 */
1081 if (nonIdentityTx) {
1082 AttributeValues values = getAttributeValues();
1083
1084 AffineTransform at = values.isNonDefault(ETRANSFORM)
1085 ? new AffineTransform(values.getTransform())
1086 : new AffineTransform();
1087
1088 if (values.getSuperscript() != 0) {
1089 // can't get ascent and descent here, recursive call to this fn,
1090 // so use pointsize
1091 // let users combine super- and sub-scripting
1092
1093 int superscript = values.getSuperscript();
1094
1095 double trans = 0;
1096 int n = 0;
1097 boolean up = superscript > 0;
1098 int sign = up ? -1 : 1;
1099 int ss = up ? superscript : -superscript;
1100
1101 while ((ss & 7) > n) {
1102 int newn = ss & 7;
1103 trans += sign * (ssinfo[newn] - ssinfo[n]);
1104 ss >>= 3;
1105 sign = -sign;
1106 n = newn;
1107 }
1108 trans *= pointSize;
1109 double scale = Math.pow(2./3., n);
1110
1111 at.preConcatenate(AffineTransform.getTranslateInstance(0, trans));
1112 at.scale(scale, scale);
1113
1114 // note on placement and italics
1115 // We preconcatenate the transform because we don't want to translate along
1116 // the italic angle, but purely perpendicular to the baseline. While this
1117 // looks ok for superscripts, it can lead subscripts to stack on each other
1118 // and bring the following text too close. The way we deal with potential
1119 // collisions that can occur in the case of italics is by adjusting the
1120 // horizontal spacing of the adjacent glyphvectors. Examine the italic
1121 // angle of both vectors, if one is non-zero, compute the minimum ascent
1122 // and descent, and then the x position at each for each vector along its
1123 // italic angle starting from its (offset) baseline. Compute the difference
1124 // between the x positions and use the maximum difference to adjust the
1125 // position of the right gv.
1126 }
1127
1128 if (values.isNonDefault(EWIDTH)) {
1129 at.scale(values.getWidth(), 1f);
1130 }
1131
1132 return at;
1133 }
1134
1135 return new AffineTransform();
1136 }
1137
1138 // x = r^0 + r^1 + r^2... r^n
1139 // rx = r^1 + r^2 + r^3... r^(n+1)
1140 // x - rx = r^0 - r^(n+1)
1141 // x (1 - r) = r^0 - r^(n+1)
1142 // x = (r^0 - r^(n+1)) / (1 - r)
1143 // x = (1 - r^(n+1)) / (1 - r)
1144
1145 // scale ratio is 2/3
1146 // trans = 1/2 of ascent * x
1147 // assume ascent is 3/4 of point size
1148
1149 private static final float[] ssinfo = {
1150 0.0f,
1151 0.375f,
1152 0.625f,
1153 0.7916667f,
1154 0.9027778f,
1155 0.9768519f,
1156 1.0262346f,
1157 1.0591564f,
1158 };
1159
1160 /**
1161 * Returns the family name of this <code>Font</code>.
1162 *
1163 * <p>The family name of a font is font specific. Two fonts such as
1164 * Helvetica Italic and Helvetica Bold have the same family name,
1165 * <i>Helvetica</i>, whereas their font face names are
1166 * <i>Helvetica Bold</i> and <i>Helvetica Italic</i>. The list of
1167 * available family names may be obtained by using the
1168 * {@link GraphicsEnvironment#getAvailableFontFamilyNames()} method.
1169 *
1170 * <p>Use <code>getName</code> to get the logical name of the font.
1171 * Use <code>getFontName</code> to get the font face name of the font.
1172 * @return a <code>String</code> that is the family name of this
1173 * <code>Font</code>.
1174 *
1175 * @see #getName
1176 * @see #getFontName
1177 * @since 1.1
1178 */
1179 public String getFamily() {
1180 return getFamily_NoClientCode();
1181 }
1182 // NOTE: This method is called by privileged threads.
1183 // We implement this functionality in a package-private
1184 // method to insure that it cannot be overridden by client
1185 // subclasses.
1186 // DO NOT INVOKE CLIENT CODE ON THIS THREAD!
1187 final String getFamily_NoClientCode() {
1188 return getFamily(Locale.getDefault());
1189 }
1190
1191 /**
1192 * Returns the family name of this <code>Font</code>, localized for
1193 * the specified locale.
1194 *
1195 * <p>The family name of a font is font specific. Two fonts such as
1196 * Helvetica Italic and Helvetica Bold have the same family name,
1197 * <i>Helvetica</i>, whereas their font face names are
1198 * <i>Helvetica Bold</i> and <i>Helvetica Italic</i>. The list of
1199 * available family names may be obtained by using the
1200 * {@link GraphicsEnvironment#getAvailableFontFamilyNames()} method.
1201 *
1202 * <p>Use <code>getFontName</code> to get the font face name of the font.
1203 * @param l locale for which to get the family name
1204 * @return a <code>String</code> representing the family name of the
1205 * font, localized for the specified locale.
1206 * @see #getFontName
1207 * @see java.util.Locale
1208 * @since 1.2
1209 */
1210 public String getFamily(Locale l) {
1211 if (l == null) {
1212 throw new NullPointerException("null locale doesn't mean default");
1213 }
1214 return getFont2D().getFamilyName(l);
1215 }
1216
1217 /**
1218 * Returns the postscript name of this <code>Font</code>.
1219 * Use <code>getFamily</code> to get the family name of the font.
1220 * Use <code>getFontName</code> to get the font face name of the font.
1221 * @return a <code>String</code> representing the postscript name of
1222 * this <code>Font</code>.
1223 * @since 1.2
1224 */
1225 public String getPSName() {
1226 return getFont2D().getPostscriptName();
1227 }
1228
1229 /**
1230 * Returns the logical name of this <code>Font</code>.
1231 * Use <code>getFamily</code> to get the family name of the font.
1232 * Use <code>getFontName</code> to get the font face name of the font.
1233 * @return a <code>String</code> representing the logical name of
1234 * this <code>Font</code>.
1235 * @see #getFamily
1236 * @see #getFontName
1237 * @since 1.0
1238 */
1239 public String getName() {
1240 return name;
1241 }
1242
1243 /**
1244 * Returns the font face name of this <code>Font</code>. For example,
1245 * Helvetica Bold could be returned as a font face name.
1246 * Use <code>getFamily</code> to get the family name of the font.
1247 * Use <code>getName</code> to get the logical name of the font.
1248 * @return a <code>String</code> representing the font face name of
1249 * this <code>Font</code>.
1250 * @see #getFamily
1251 * @see #getName
1252 * @since 1.2
1253 */
1254 public String getFontName() {
1255 return getFontName(Locale.getDefault());
1256 }
1257
1258 /**
1259 * Returns the font face name of the <code>Font</code>, localized
1260 * for the specified locale. For example, Helvetica Fett could be
1261 * returned as the font face name.
1262 * Use <code>getFamily</code> to get the family name of the font.
1263 * @param l a locale for which to get the font face name
1264 * @return a <code>String</code> representing the font face name,
1265 * localized for the specified locale.
1266 * @see #getFamily
1267 * @see java.util.Locale
1268 */
1269 public String getFontName(Locale l) {
1270 if (l == null) {
1271 throw new NullPointerException("null locale doesn't mean default");
1272 }
1273 return getFont2D().getFontName(l);
1274 }
1275
1276 /**
1277 * Returns the style of this <code>Font</code>. The style can be
1278 * PLAIN, BOLD, ITALIC, or BOLD+ITALIC.
1279 * @return the style of this <code>Font</code>
1280 * @see #isPlain
1281 * @see #isBold
1282 * @see #isItalic
1283 * @since 1.0
1284 */
1285 public int getStyle() {
1286 return style;
1287 }
1288
1289 /**
1290 * Returns the point size of this <code>Font</code>, rounded to
1291 * an integer.
1292 * Most users are familiar with the idea of using <i>point size</i> to
1293 * specify the size of glyphs in a font. This point size defines a
1294 * measurement between the baseline of one line to the baseline of the
1295 * following line in a single spaced text document. The point size is
1296 * based on <i>typographic points</i>, approximately 1/72 of an inch.
1297 * <p>
1298 * The Java(tm)2D API adopts the convention that one point is
1299 * equivalent to one unit in user coordinates. When using a
1300 * normalized transform for converting user space coordinates to
1301 * device space coordinates 72 user
1302 * space units equal 1 inch in device space. In this case one point
1303 * is 1/72 of an inch.
1304 * @return the point size of this <code>Font</code> in 1/72 of an
1305 * inch units.
1306 * @see #getSize2D
1307 * @see GraphicsConfiguration#getDefaultTransform
1308 * @see GraphicsConfiguration#getNormalizingTransform
1309 * @since 1.0
1310 */
1311 public int getSize() {
1312 return size;
1313 }
1314
1315 /**
1316 * Returns the point size of this <code>Font</code> in
1317 * <code>float</code> value.
1318 * @return the point size of this <code>Font</code> as a
1319 * <code>float</code> value.
1320 * @see #getSize
1321 * @since 1.2
1322 */
1323 public float getSize2D() {
1324 return pointSize;
1325 }
1326
1327 /**
1328 * Indicates whether or not this <code>Font</code> object's style is
1329 * PLAIN.
1330 * @return <code>true</code> if this <code>Font</code> has a
1331 * PLAIN style;
1332 * <code>false</code> otherwise.
1333 * @see java.awt.Font#getStyle
1334 * @since 1.0
1335 */
1336 public boolean isPlain() {
1337 return style == 0;
1338 }
1339
1340 /**
1341 * Indicates whether or not this <code>Font</code> object's style is
1342 * BOLD.
1343 * @return <code>true</code> if this <code>Font</code> object's
1344 * style is BOLD;
1345 * <code>false</code> otherwise.
1346 * @see java.awt.Font#getStyle
1347 * @since 1.0
1348 */
1349 public boolean isBold() {
1350 return (style & BOLD) != 0;
1351 }
1352
1353 /**
1354 * Indicates whether or not this <code>Font</code> object's style is
1355 * ITALIC.
1356 * @return <code>true</code> if this <code>Font</code> object's
1357 * style is ITALIC;
1358 * <code>false</code> otherwise.
1359 * @see java.awt.Font#getStyle
1360 * @since 1.0
1361 */
1362 public boolean isItalic() {
1363 return (style & ITALIC) != 0;
1364 }
1365
1366 /**
1367 * Indicates whether or not this <code>Font</code> object has a
1368 * transform that affects its size in addition to the Size
1369 * attribute.
1370 * @return <code>true</code> if this <code>Font</code> object
1371 * has a non-identity AffineTransform attribute.
1372 * <code>false</code> otherwise.
1373 * @see java.awt.Font#getTransform
1374 * @since 1.4
1375 */
1376 public boolean isTransformed() {
1377 return nonIdentityTx;
1378 }
1379
1380 /**
1381 * Return true if this Font contains attributes that require extra
1382 * layout processing.
1383 * @return true if the font has layout attributes
1384 * @since 1.6
1385 */
1386 public boolean hasLayoutAttributes() {
1387 return hasLayoutAttributes;
1388 }
1389
1390 /**
1391 * Returns a <code>Font</code> object from the system properties list.
1392 * <code>nm</code> is treated as the name of a system property to be
1393 * obtained. The <code>String</code> value of this property is then
1394 * interpreted as a <code>Font</code> object according to the
1395 * specification of <code>Font.decode(String)</code>
1396 * If the specified property is not found, or the executing code does
1397 * not have permission to read the property, null is returned instead.
1398 *
1399 * @param nm the property name
1400 * @return a <code>Font</code> object that the property name
1401 * describes, or null if no such property exists.
1402 * @throws NullPointerException if nm is null.
1403 * @since 1.2
1404 * @see #decode(String)
1405 */
1406 public static Font getFont(String nm) {
1407 return getFont(nm, null);
1408 }
1409
1410 /**
1411 * Returns the <code>Font</code> that the <code>str</code>
1412 * argument describes.
1413 * To ensure that this method returns the desired Font,
1414 * format the <code>str</code> parameter in
1415 * one of these ways
1416 *
1417 * <ul>
1418 * <li><em>fontname-style-pointsize</em>
1419 * <li><em>fontname-pointsize</em>
1420 * <li><em>fontname-style</em>
1421 * <li><em>fontname</em>
1422 * <li><em>fontname style pointsize</em>
1423 * <li><em>fontname pointsize</em>
1424 * <li><em>fontname style</em>
1425 * <li><em>fontname</em>
1426 * </ul>
1427 * in which <i>style</i> is one of the four
1428 * case-insensitive strings:
1429 * <code>"PLAIN"</code>, <code>"BOLD"</code>, <code>"BOLDITALIC"</code>, or
1430 * <code>"ITALIC"</code>, and pointsize is a positive decimal integer
1431 * representation of the point size.
1432 * For example, if you want a font that is Arial, bold, with
1433 * a point size of 18, you would call this method with:
1434 * "Arial-BOLD-18".
1435 * This is equivalent to calling the Font constructor :
1436 * <code>new Font("Arial", Font.BOLD, 18);</code>
1437 * and the values are interpreted as specified by that constructor.
1438 * <p>
1439 * A valid trailing decimal field is always interpreted as the pointsize.
1440 * Therefore a fontname containing a trailing decimal value should not
1441 * be used in the fontname only form.
1442 * <p>
1443 * If a style name field is not one of the valid style strings, it is
1444 * interpreted as part of the font name, and the default style is used.
1445 * <p>
1446 * Only one of ' ' or '-' may be used to separate fields in the input.
1447 * The identified separator is the one closest to the end of the string
1448 * which separates a valid pointsize, or a valid style name from
1449 * the rest of the string.
1450 * Null (empty) pointsize and style fields are treated
1451 * as valid fields with the default value for that field.
1452 *<p>
1453 * Some font names may include the separator characters ' ' or '-'.
1454 * If <code>str</code> is not formed with 3 components, e.g. such that
1455 * <code>style</code> or <code>pointsize</code> fields are not present in
1456 * <code>str</code>, and <code>fontname</code> also contains a
1457 * character determined to be the separator character
1458 * then these characters where they appear as intended to be part of
1459 * <code>fontname</code> may instead be interpreted as separators
1460 * so the font name may not be properly recognised.
1461 *
1462 * <p>
1463 * The default size is 12 and the default style is PLAIN.
1464 * If <code>str</code> does not specify a valid size, the returned
1465 * <code>Font</code> has a size of 12. If <code>str</code> does not
1466 * specify a valid style, the returned Font has a style of PLAIN.
1467 * If you do not specify a valid font name in
1468 * the <code>str</code> argument, this method will return
1469 * a font with the family name "Dialog".
1470 * To determine what font family names are available on
1471 * your system, use the
1472 * {@link GraphicsEnvironment#getAvailableFontFamilyNames()} method.
1473 * If <code>str</code> is <code>null</code>, a new <code>Font</code>
1474 * is returned with the family name "Dialog", a size of 12 and a
1475 * PLAIN style.
1476 * @param str the name of the font, or <code>null</code>
1477 * @return the <code>Font</code> object that <code>str</code>
1478 * describes, or a new default <code>Font</code> if
1479 * <code>str</code> is <code>null</code>.
1480 * @see #getFamily
1481 * @since 1.1
1482 */
1483 public static Font decode(String str) {
1484 String fontName = str;
1485 String styleName = "";
1486 int fontSize = 12;
1487 int fontStyle = Font.PLAIN;
1488
1489 if (str == null) {
1490 return new Font(DIALOG, fontStyle, fontSize);
1491 }
1492
1493 int lastHyphen = str.lastIndexOf('-');
1494 int lastSpace = str.lastIndexOf(' ');
1495 char sepChar = (lastHyphen > lastSpace) ? '-' : ' ';
1496 int sizeIndex = str.lastIndexOf(sepChar);
1497 int styleIndex = str.lastIndexOf(sepChar, sizeIndex-1);
1498 int strlen = str.length();
1499
1500 if (sizeIndex > 0 && sizeIndex+1 < strlen) {
1501 try {
1502 fontSize =
1503 Integer.valueOf(str.substring(sizeIndex+1)).intValue();
1504 if (fontSize <= 0) {
1505 fontSize = 12;
1506 }
1507 } catch (NumberFormatException e) {
1508 /* It wasn't a valid size, if we didn't also find the
1509 * start of the style string perhaps this is the style */
1510 styleIndex = sizeIndex;
1511 sizeIndex = strlen;
1512 if (str.charAt(sizeIndex-1) == sepChar) {
1513 sizeIndex--;
1514 }
1515 }
1516 }
1517
1518 if (styleIndex >= 0 && styleIndex+1 < strlen) {
1519 styleName = str.substring(styleIndex+1, sizeIndex);
1520 styleName = styleName.toLowerCase(Locale.ENGLISH);
1521 if (styleName.equals("bolditalic")) {
1522 fontStyle = Font.BOLD | Font.ITALIC;
1523 } else if (styleName.equals("italic")) {
1524 fontStyle = Font.ITALIC;
1525 } else if (styleName.equals("bold")) {
1526 fontStyle = Font.BOLD;
1527 } else if (styleName.equals("plain")) {
1528 fontStyle = Font.PLAIN;
1529 } else {
1530 /* this string isn't any of the expected styles, so
1531 * assume its part of the font name
1532 */
1533 styleIndex = sizeIndex;
1534 if (str.charAt(styleIndex-1) == sepChar) {
1535 styleIndex--;
1536 }
1537 }
1538 fontName = str.substring(0, styleIndex);
1539
1540 } else {
1541 int fontEnd = strlen;
1542 if (styleIndex > 0) {
1543 fontEnd = styleIndex;
1544 } else if (sizeIndex > 0) {
1545 fontEnd = sizeIndex;
1546 }
1547 if (fontEnd > 0 && str.charAt(fontEnd-1) == sepChar) {
1548 fontEnd--;
1549 }
1550 fontName = str.substring(0, fontEnd);
1551 }
1552
1553 return new Font(fontName, fontStyle, fontSize);
1554 }
1555
1556 /**
1557 * Gets the specified <code>Font</code> from the system properties
1558 * list. As in the <code>getProperty</code> method of
1559 * <code>System</code>, the first
1560 * argument is treated as the name of a system property to be
1561 * obtained. The <code>String</code> value of this property is then
1562 * interpreted as a <code>Font</code> object.
1563 * <p>
1564 * The property value should be one of the forms accepted by
1565 * <code>Font.decode(String)</code>
1566 * If the specified property is not found, or the executing code does not
1567 * have permission to read the property, the <code>font</code>
1568 * argument is returned instead.
1569 * @param nm the case-insensitive property name
1570 * @param font a default <code>Font</code> to return if property
1571 * <code>nm</code> is not defined
1572 * @return the <code>Font</code> value of the property.
1573 * @throws NullPointerException if nm is null.
1574 * @see #decode(String)
1575 */
1576 public static Font getFont(String nm, Font font) {
1577 String str = null;
1578 try {
1579 str =System.getProperty(nm);
1580 } catch(SecurityException e) {
1581 }
1582 if (str == null) {
1583 return font;
1584 }
1585 return decode ( str );
1586 }
1587
1588 transient int hash;
1589 /**
1590 * Returns a hashcode for this <code>Font</code>.
1591 * @return a hashcode value for this <code>Font</code>.
1592 * @since 1.0
1593 */
1594 public int hashCode() {
1595 if (hash == 0) {
1596 hash = name.hashCode() ^ style ^ size;
1597 /* It is possible many fonts differ only in transform.
1598 * So include the transform in the hash calculation.
1599 * nonIdentityTx is set whenever there is a transform in
1600 * 'values'. The tests for null are required because it can
1601 * also be set for other reasons.
1602 */
1603 if (nonIdentityTx &&
1604 values != null && values.getTransform() != null) {
1605 hash ^= values.getTransform().hashCode();
1606 }
1607 }
1608 return hash;
1609 }
1610
1611 /**
1612 * Compares this <code>Font</code> object to the specified
1613 * <code>Object</code>.
1614 * @param obj the <code>Object</code> to compare
1615 * @return <code>true</code> if the objects are the same
1616 * or if the argument is a <code>Font</code> object
1617 * describing the same font as this object;
1618 * <code>false</code> otherwise.
1619 * @since 1.0
1620 */
1621 public boolean equals(Object obj) {
1622 if (obj == this) {
1623 return true;
1624 }
1625
1626 if (obj != null) {
1627 try {
1628 Font font = (Font)obj;
1629 if (size == font.size &&
1630 style == font.style &&
1631 nonIdentityTx == font.nonIdentityTx &&
1632 hasLayoutAttributes == font.hasLayoutAttributes &&
1633 pointSize == font.pointSize &&
1634 name.equals(font.name)) {
1635
1636 /* 'values' is usually initialized lazily, except when
1637 * the font is constructed from a Map, or derived using
1638 * a Map or other values. So if only one font has
1639 * the field initialized we need to initialize it in
1640 * the other instance and compare.
1641 */
1642 if (values == null) {
1643 if (font.values == null) {
1644 return true;
1645 } else {
1646 return getAttributeValues().equals(font.values);
1647 }
1648 } else {
1649 return values.equals(font.getAttributeValues());
1650 }
1651 }
1652 }
1653 catch (ClassCastException e) {
1654 }
1655 }
1656 return false;
1657 }
1658
1659 /**
1660 * Converts this <code>Font</code> object to a <code>String</code>
1661 * representation.
1662 * @return a <code>String</code> representation of this
1663 * <code>Font</code> object.
1664 * @since 1.0
1665 */
1666 // NOTE: This method may be called by privileged threads.
1667 // DO NOT INVOKE CLIENT CODE ON THIS THREAD!
1668 public String toString() {
1669 String strStyle;
1670
1671 if (isBold()) {
1672 strStyle = isItalic() ? "bolditalic" : "bold";
1673 } else {
1674 strStyle = isItalic() ? "italic" : "plain";
1675 }
1676
1677 return getClass().getName() + "[family=" + getFamily() + ",name=" + name + ",style=" +
1678 strStyle + ",size=" + size + "]";
1679 } // toString()
1680
1681
1682 /** Serialization support. A <code>readObject</code>
1683 * method is necessary because the constructor creates
1684 * the font's peer, and we can't serialize the peer.
1685 * Similarly the computed font "family" may be different
1686 * at <code>readObject</code> time than at
1687 * <code>writeObject</code> time. An integer version is
1688 * written so that future versions of this class will be
1689 * able to recognize serialized output from this one.
1690 */
1691 /**
1692 * The <code>Font</code> Serializable Data Form.
1693 *
1694 * @serial
1695 */
1696 private int fontSerializedDataVersion = 1;
1697
1698 /**
1699 * Writes default serializable fields to a stream.
1700 *
1701 * @param s the <code>ObjectOutputStream</code> to write
1702 * @see AWTEventMulticaster#save(ObjectOutputStream, String, EventListener)
1703 * @see #readObject(java.io.ObjectInputStream)
1704 */
1705 private void writeObject(java.io.ObjectOutputStream s)
1706 throws java.lang.ClassNotFoundException,
1707 java.io.IOException
1708 {
1709 if (values != null) {
1710 synchronized(values) {
1711 // transient
1712 fRequestedAttributes = values.toSerializableHashtable();
1713 s.defaultWriteObject();
1714 fRequestedAttributes = null;
1715 }
1716 } else {
1717 s.defaultWriteObject();
1718 }
1719 }
1720
1721 /**
1722 * Reads the <code>ObjectInputStream</code>.
1723 * Unrecognized keys or values will be ignored.
1724 *
1725 * @param s the <code>ObjectInputStream</code> to read
1726 * @serial
1727 * @see #writeObject(java.io.ObjectOutputStream)
1728 */
1729 private void readObject(java.io.ObjectInputStream s)
1730 throws java.lang.ClassNotFoundException,
1731 java.io.IOException
1732 {
1733 s.defaultReadObject();
1734 if (pointSize == 0) {
1735 pointSize = (float)size;
1736 }
1737
1738 // Handle fRequestedAttributes.
1739 // in 1.5, we always streamed out the font values plus
1740 // TRANSFORM, SUPERSCRIPT, and WIDTH, regardless of whether the
1741 // values were default or not. In 1.6 we only stream out
1742 // defined values. So, 1.6 streams in from a 1.5 stream,
1743 // it check each of these values and 'undefines' it if the
1744 // value is the default.
1745
1746 if (fRequestedAttributes != null) {
1747 values = getAttributeValues(); // init
1748 AttributeValues extras =
1749 AttributeValues.fromSerializableHashtable(fRequestedAttributes);
1750 if (!AttributeValues.is16Hashtable(fRequestedAttributes)) {
1751 extras.unsetDefault(); // if legacy stream, undefine these
1752 }
1753 values = getAttributeValues().merge(extras);
1754 this.nonIdentityTx = values.anyNonDefault(EXTRA_MASK);
1755 this.hasLayoutAttributes = values.anyNonDefault(LAYOUT_MASK);
1756
1757 fRequestedAttributes = null; // don't need it any more
1758 }
1759 }
1760
1761 /**
1762 * Returns the number of glyphs in this <code>Font</code>. Glyph codes
1763 * for this <code>Font</code> range from 0 to
1764 * <code>getNumGlyphs()</code> - 1.
1765 * @return the number of glyphs in this <code>Font</code>.
1766 * @since 1.2
1767 */
1768 public int getNumGlyphs() {
1769 return getFont2D().getNumGlyphs();
1770 }
1771
1772 /**
1773 * Returns the glyphCode which is used when this <code>Font</code>
1774 * does not have a glyph for a specified unicode code point.
1775 * @return the glyphCode of this <code>Font</code>.
1776 * @since 1.2
1777 */
1778 public int getMissingGlyphCode() {
1779 return getFont2D().getMissingGlyphCode();
1780 }
1781
1782 /**
1783 * Returns the baseline appropriate for displaying this character.
1784 * <p>
1785 * Large fonts can support different writing systems, and each system can
1786 * use a different baseline.
1787 * The character argument determines the writing system to use. Clients
1788 * should not assume all characters use the same baseline.
1789 *
1790 * @param c a character used to identify the writing system
1791 * @return the baseline appropriate for the specified character.
1792 * @see LineMetrics#getBaselineOffsets
1793 * @see #ROMAN_BASELINE
1794 * @see #CENTER_BASELINE
1795 * @see #HANGING_BASELINE
1796 * @since 1.2
1797 */
1798 public byte getBaselineFor(char c) {
1799 return getFont2D().getBaselineFor(c);
1800 }
1801
1802 /**
1803 * Returns a map of font attributes available in this
1804 * <code>Font</code>. Attributes include things like ligatures and
1805 * glyph substitution.
1806 * @return the attributes map of this <code>Font</code>.
1807 */
1808 public Map<TextAttribute,?> getAttributes(){
1809 return new AttributeMap(getAttributeValues());
1810 }
1811
1812 /**
1813 * Returns the keys of all the attributes supported by this
1814 * <code>Font</code>. These attributes can be used to derive other
1815 * fonts.
1816 * @return an array containing the keys of all the attributes
1817 * supported by this <code>Font</code>.
1818 * @since 1.2
1819 */
1820 public Attribute[] getAvailableAttributes() {
1821 // FONT is not supported by Font
1822
1823 Attribute attributes[] = {
1824 TextAttribute.FAMILY,
1825 TextAttribute.WEIGHT,
1826 TextAttribute.WIDTH,
1827 TextAttribute.POSTURE,
1828 TextAttribute.SIZE,
1829 TextAttribute.TRANSFORM,
1830 TextAttribute.SUPERSCRIPT,
1831 TextAttribute.CHAR_REPLACEMENT,
1832 TextAttribute.FOREGROUND,
1833 TextAttribute.BACKGROUND,
1834 TextAttribute.UNDERLINE,
1835 TextAttribute.STRIKETHROUGH,
1836 TextAttribute.RUN_DIRECTION,
1837 TextAttribute.BIDI_EMBEDDING,
1838 TextAttribute.JUSTIFICATION,
1839 TextAttribute.INPUT_METHOD_HIGHLIGHT,
1840 TextAttribute.INPUT_METHOD_UNDERLINE,
1841 TextAttribute.SWAP_COLORS,
1842 TextAttribute.NUMERIC_SHAPING,
1843 TextAttribute.KERNING,
1844 TextAttribute.LIGATURES,
1845 TextAttribute.TRACKING,
1846 };
1847
1848 return attributes;
1849 }
1850
1851 /**
1852 * Creates a new <code>Font</code> object by replicating this
1853 * <code>Font</code> object and applying a new style and size.
1854 * @param style the style for the new <code>Font</code>
1855 * @param size the size for the new <code>Font</code>
1856 * @return a new <code>Font</code> object.
1857 * @since 1.2
1858 */
1859 public Font deriveFont(int style, float size){
1860 if (values == null) {
1861 return new Font(name, style, size, createdFont, font2DHandle);
1862 }
1863 AttributeValues newValues = getAttributeValues().clone();
1864 int oldStyle = (this.style != style) ? this.style : -1;
1865 applyStyle(style, newValues);
1866 newValues.setSize(size);
1867 return new Font(newValues, null, oldStyle, createdFont, font2DHandle);
1868 }
1869
1870 /**
1871 * Creates a new <code>Font</code> object by replicating this
1872 * <code>Font</code> object and applying a new style and transform.
1873 * @param style the style for the new <code>Font</code>
1874 * @param trans the <code>AffineTransform</code> associated with the
1875 * new <code>Font</code>
1876 * @return a new <code>Font</code> object.
1877 * @throws IllegalArgumentException if <code>trans</code> is
1878 * <code>null</code>
1879 * @since 1.2
1880 */
1881 public Font deriveFont(int style, AffineTransform trans){
1882 AttributeValues newValues = getAttributeValues().clone();
1883 int oldStyle = (this.style != style) ? this.style : -1;
1884 applyStyle(style, newValues);
1885 applyTransform(trans, newValues);
1886 return new Font(newValues, null, oldStyle, createdFont, font2DHandle);
1887 }
1888
1889 /**
1890 * Creates a new <code>Font</code> object by replicating the current
1891 * <code>Font</code> object and applying a new size to it.
1892 * @param size the size for the new <code>Font</code>.
1893 * @return a new <code>Font</code> object.
1894 * @since 1.2
1895 */
1896 public Font deriveFont(float size){
1897 if (values == null) {
1898 return new Font(name, style, size, createdFont, font2DHandle);
1899 }
1900 AttributeValues newValues = getAttributeValues().clone();
1901 newValues.setSize(size);
1902 return new Font(newValues, null, -1, createdFont, font2DHandle);
1903 }
1904
1905 /**
1906 * Creates a new <code>Font</code> object by replicating the current
1907 * <code>Font</code> object and applying a new transform to it.
1908 * @param trans the <code>AffineTransform</code> associated with the
1909 * new <code>Font</code>
1910 * @return a new <code>Font</code> object.
1911 * @throws IllegalArgumentException if <code>trans</code> is
1912 * <code>null</code>
1913 * @since 1.2
1914 */
1915 public Font deriveFont(AffineTransform trans){
1916 AttributeValues newValues = getAttributeValues().clone();
1917 applyTransform(trans, newValues);
1918 return new Font(newValues, null, -1, createdFont, font2DHandle);
1919 }
1920
1921 /**
1922 * Creates a new <code>Font</code> object by replicating the current
1923 * <code>Font</code> object and applying a new style to it.
1924 * @param style the style for the new <code>Font</code>
1925 * @return a new <code>Font</code> object.
1926 * @since 1.2
1927 */
1928 public Font deriveFont(int style){
1929 if (values == null) {
1930 return new Font(name, style, size, createdFont, font2DHandle);
1931 }
1932 AttributeValues newValues = getAttributeValues().clone();
1933 int oldStyle = (this.style != style) ? this.style : -1;
1934 applyStyle(style, newValues);
1935 return new Font(newValues, null, oldStyle, createdFont, font2DHandle);
1936 }
1937
1938 /**
1939 * Creates a new <code>Font</code> object by replicating the current
1940 * <code>Font</code> object and applying a new set of font attributes
1941 * to it.
1942 *
1943 * @param attributes a map of attributes enabled for the new
1944 * <code>Font</code>
1945 * @return a new <code>Font</code> object.
1946 * @since 1.2
1947 */
1948 public Font deriveFont(Map<? extends Attribute, ?> attributes) {
1949 if (attributes == null) {
1950 return this;
1951 }
1952 AttributeValues newValues = getAttributeValues().clone();
1953 newValues.merge(attributes, RECOGNIZED_MASK);
1954
1955 return new Font(newValues, name, style, createdFont, font2DHandle);
1956 }
1957
1958 /**
1959 * Checks if this <code>Font</code> has a glyph for the specified
1960 * character.
1961 *
1962 * <p> <b>Note:</b> This method cannot handle <a
1963 * href="../../java/lang/Character.html#supplementary"> supplementary
1964 * characters</a>. To support all Unicode characters, including
1965 * supplementary characters, use the {@link #canDisplay(int)}
1966 * method or <code>canDisplayUpTo</code> methods.
1967 *
1968 * @param c the character for which a glyph is needed
1969 * @return <code>true</code> if this <code>Font</code> has a glyph for this
1970 * character; <code>false</code> otherwise.
1971 * @since 1.2
1972 */
1973 public boolean canDisplay(char c){
1974 return getFont2D().canDisplay(c);
1975 }
1976
1977 /**
1978 * Checks if this <code>Font</code> has a glyph for the specified
1979 * character.
1980 *
1981 * @param codePoint the character (Unicode code point) for which a glyph
1982 * is needed.
1983 * @return <code>true</code> if this <code>Font</code> has a glyph for the
1984 * character; <code>false</code> otherwise.
1985 * @throws IllegalArgumentException if the code point is not a valid Unicode
1986 * code point.
1987 * @see Character#isValidCodePoint(int)
1988 * @since 1.5
1989 */
1990 public boolean canDisplay(int codePoint) {
1991 if (!Character.isValidCodePoint(codePoint)) {
1992 throw new IllegalArgumentException("invalid code point: " +
1993 Integer.toHexString(codePoint));
1994 }
1995 return getFont2D().canDisplay(codePoint);
1996 }
1997
1998 /**
1999 * Indicates whether or not this <code>Font</code> can display a
2000 * specified <code>String</code>. For strings with Unicode encoding,
2001 * it is important to know if a particular font can display the
2002 * string. This method returns an offset into the <code>String</code>
2003 * <code>str</code> which is the first character this
2004 * <code>Font</code> cannot display without using the missing glyph
2005 * code. If the <code>Font</code> can display all characters, -1 is
2006 * returned.
2007 * @param str a <code>String</code> object
2008 * @return an offset into <code>str</code> that points
2009 * to the first character in <code>str</code> that this
2010 * <code>Font</code> cannot display; or <code>-1</code> if
2011 * this <code>Font</code> can display all characters in
2012 * <code>str</code>.
2013 * @since 1.2
2014 */
2015 public int canDisplayUpTo(String str) {
2016 Font2D font2d = getFont2D();
2017 int len = str.length();
2018 for (int i = 0; i < len; i++) {
2019 char c = str.charAt(i);
2020 if (font2d.canDisplay(c)) {
2021 continue;
2022 }
2023 if (!Character.isHighSurrogate(c)) {
2024 return i;
2025 }
2026 if (!font2d.canDisplay(str.codePointAt(i))) {
2027 return i;
2028 }
2029 i++;
2030 }
2031 return -1;
2032 }
2033
2034 /**
2035 * Indicates whether or not this <code>Font</code> can display
2036 * the characters in the specified <code>text</code>
2037 * starting at <code>start</code> and ending at
2038 * <code>limit</code>. This method is a convenience overload.
2039 * @param text the specified array of <code>char</code> values
2040 * @param start the specified starting offset (in
2041 * <code>char</code>s) into the specified array of
2042 * <code>char</code> values
2043 * @param limit the specified ending offset (in
2044 * <code>char</code>s) into the specified array of
2045 * <code>char</code> values
2046 * @return an offset into <code>text</code> that points
2047 * to the first character in <code>text</code> that this
2048 * <code>Font</code> cannot display; or <code>-1</code> if
2049 * this <code>Font</code> can display all characters in
2050 * <code>text</code>.
2051 * @since 1.2
2052 */
2053 public int canDisplayUpTo(char[] text, int start, int limit) {
2054 Font2D font2d = getFont2D();
2055 for (int i = start; i < limit; i++) {
2056 char c = text[i];
2057 if (font2d.canDisplay(c)) {
2058 continue;
2059 }
2060 if (!Character.isHighSurrogate(c)) {
2061 return i;
2062 }
2063 if (!font2d.canDisplay(Character.codePointAt(text, i, limit))) {
2064 return i;
2065 }
2066 i++;
2067 }
2068 return -1;
2069 }
2070
2071 /**
2072 * Indicates whether or not this <code>Font</code> can display the
2073 * text specified by the <code>iter</code> starting at
2074 * <code>start</code> and ending at <code>limit</code>.
2075 *
2076 * @param iter a {@link CharacterIterator} object
2077 * @param start the specified starting offset into the specified
2078 * <code>CharacterIterator</code>.
2079 * @param limit the specified ending offset into the specified
2080 * <code>CharacterIterator</code>.
2081 * @return an offset into <code>iter</code> that points
2082 * to the first character in <code>iter</code> that this
2083 * <code>Font</code> cannot display; or <code>-1</code> if
2084 * this <code>Font</code> can display all characters in
2085 * <code>iter</code>.
2086 * @since 1.2
2087 */
2088 public int canDisplayUpTo(CharacterIterator iter, int start, int limit) {
2089 Font2D font2d = getFont2D();
2090 char c = iter.setIndex(start);
2091 for (int i = start; i < limit; i++, c = iter.next()) {
2092 if (font2d.canDisplay(c)) {
2093 continue;
2094 }
2095 if (!Character.isHighSurrogate(c)) {
2096 return i;
2097 }
2098 char c2 = iter.next();
2099 // c2 could be CharacterIterator.DONE which is not a low surrogate.
2100 if (!Character.isLowSurrogate(c2)) {
2101 return i;
2102 }
2103 if (!font2d.canDisplay(Character.toCodePoint(c, c2))) {
2104 return i;
2105 }
2106 i++;
2107 }
2108 return -1;
2109 }
2110
2111 /**
2112 * Returns the italic angle of this <code>Font</code>. The italic angle
2113 * is the inverse slope of the caret which best matches the posture of this
2114 * <code>Font</code>.
2115 * @see TextAttribute#POSTURE
2116 * @return the angle of the ITALIC style of this <code>Font</code>.
2117 */
2118 public float getItalicAngle() {
2119 return getItalicAngle(null);
2120 }
2121
2122 /* The FRC hints don't affect the value of the italic angle but
2123 * we need to pass them in to look up a strike.
2124 * If we can pass in ones already being used it can prevent an extra
2125 * strike from being allocated. Note that since italic angle is
2126 * a property of the font, the font transform is needed not the
2127 * device transform. Finally, this is private but the only caller of this
2128 * in the JDK - and the only likely caller - is in this same class.
2129 */
2130 private float getItalicAngle(FontRenderContext frc) {
2131 Object aa, fm;
2132 if (frc == null) {
2133 aa = RenderingHints.VALUE_TEXT_ANTIALIAS_OFF;
2134 fm = RenderingHints.VALUE_FRACTIONALMETRICS_OFF;
2135 } else {
2136 aa = frc.getAntiAliasingHint();
2137 fm = frc.getFractionalMetricsHint();
2138 }
2139 return getFont2D().getItalicAngle(this, identityTx, aa, fm);
2140 }
2141
2142 /**
2143 * Checks whether or not this <code>Font</code> has uniform
2144 * line metrics. A logical <code>Font</code> might be a
2145 * composite font, which means that it is composed of different
2146 * physical fonts to cover different code ranges. Each of these
2147 * fonts might have different <code>LineMetrics</code>. If the
2148 * logical <code>Font</code> is a single
2149 * font then the metrics would be uniform.
2150 * @return <code>true</code> if this <code>Font</code> has
2151 * uniform line metrics; <code>false</code> otherwise.
2152 */
2153 public boolean hasUniformLineMetrics() {
2154 return false; // REMIND always safe, but prevents caller optimize
2155 }
2156
2157 private transient SoftReference<FontLineMetrics> flmref;
2158 private FontLineMetrics defaultLineMetrics(FontRenderContext frc) {
2159 FontLineMetrics flm = null;
2160 if (flmref == null
2161 || (flm = flmref.get()) == null
2162 || !flm.frc.equals(frc)) {
2163
2164 /* The device transform in the frc is not used in obtaining line
2165 * metrics, although it probably should be: REMIND find why not?
2166 * The font transform is used but its applied in getFontMetrics, so
2167 * just pass identity here
2168 */
2169 float [] metrics = new float[8];
2170 getFont2D().getFontMetrics(this, identityTx,
2171 frc.getAntiAliasingHint(),
2172 frc.getFractionalMetricsHint(),
2173 metrics);
2174 float ascent = metrics[0];
2175 float descent = metrics[1];
2176 float leading = metrics[2];
2177 float ssOffset = 0;
2178 if (values != null && values.getSuperscript() != 0) {
2179 ssOffset = (float)getTransform().getTranslateY();
2180 ascent -= ssOffset;
2181 descent += ssOffset;
2182 }
2183 float height = ascent + descent + leading;
2184
2185 int baselineIndex = 0; // need real index, assumes roman for everything
2186 // need real baselines eventually
2187 float[] baselineOffsets = { 0, (descent/2f - ascent) / 2f, -ascent };
2188
2189 float strikethroughOffset = metrics[4];
2190 float strikethroughThickness = metrics[5];
2191
2192 float underlineOffset = metrics[6];
2193 float underlineThickness = metrics[7];
2194
2195 float italicAngle = getItalicAngle(frc);
2196
2197 if (isTransformed()) {
2198 AffineTransform ctx = values.getCharTransform(); // extract rotation
2199 if (ctx != null) {
2200 Point2D.Float pt = new Point2D.Float();
2201 pt.setLocation(0, strikethroughOffset);
2202 ctx.deltaTransform(pt, pt);
2203 strikethroughOffset = pt.y;
2204 pt.setLocation(0, strikethroughThickness);
2205 ctx.deltaTransform(pt, pt);
2206 strikethroughThickness = pt.y;
2207 pt.setLocation(0, underlineOffset);
2208 ctx.deltaTransform(pt, pt);
2209 underlineOffset = pt.y;
2210 pt.setLocation(0, underlineThickness);
2211 ctx.deltaTransform(pt, pt);
2212 underlineThickness = pt.y;
2213 }
2214 }
2215 strikethroughOffset += ssOffset;
2216 underlineOffset += ssOffset;
2217
2218 CoreMetrics cm = new CoreMetrics(ascent, descent, leading, height,
2219 baselineIndex, baselineOffsets,
2220 strikethroughOffset, strikethroughThickness,
2221 underlineOffset, underlineThickness,
2222 ssOffset, italicAngle);
2223
2224 flm = new FontLineMetrics(0, cm, frc);
2225 flmref = new SoftReference<FontLineMetrics>(flm);
2226 }
2227
2228 return (FontLineMetrics)flm.clone();
2229 }
2230
2231 /**
2232 * Returns a {@link LineMetrics} object created with the specified
2233 * <code>String</code> and {@link FontRenderContext}.
2234 * @param str the specified <code>String</code>
2235 * @param frc the specified <code>FontRenderContext</code>
2236 * @return a <code>LineMetrics</code> object created with the
2237 * specified <code>String</code> and {@link FontRenderContext}.
2238 */
2239 public LineMetrics getLineMetrics( String str, FontRenderContext frc) {
2240 FontLineMetrics flm = defaultLineMetrics(frc);
2241 flm.numchars = str.length();
2242 return flm;
2243 }
2244
2245 /**
2246 * Returns a <code>LineMetrics</code> object created with the
2247 * specified arguments.
2248 * @param str the specified <code>String</code>
2249 * @param beginIndex the initial offset of <code>str</code>
2250 * @param limit the end offset of <code>str</code>
2251 * @param frc the specified <code>FontRenderContext</code>
2252 * @return a <code>LineMetrics</code> object created with the
2253 * specified arguments.
2254 */
2255 public LineMetrics getLineMetrics( String str,
2256 int beginIndex, int limit,
2257 FontRenderContext frc) {
2258 FontLineMetrics flm = defaultLineMetrics(frc);
2259 int numChars = limit - beginIndex;
2260 flm.numchars = (numChars < 0)? 0: numChars;
2261 return flm;
2262 }
2263
2264 /**
2265 * Returns a <code>LineMetrics</code> object created with the
2266 * specified arguments.
2267 * @param chars an array of characters
2268 * @param beginIndex the initial offset of <code>chars</code>
2269 * @param limit the end offset of <code>chars</code>
2270 * @param frc the specified <code>FontRenderContext</code>
2271 * @return a <code>LineMetrics</code> object created with the
2272 * specified arguments.
2273 */
2274 public LineMetrics getLineMetrics(char [] chars,
2275 int beginIndex, int limit,
2276 FontRenderContext frc) {
2277 FontLineMetrics flm = defaultLineMetrics(frc);
2278 int numChars = limit - beginIndex;
2279 flm.numchars = (numChars < 0)? 0: numChars;
2280 return flm;
2281 }
2282
2283 /**
2284 * Returns a <code>LineMetrics</code> object created with the
2285 * specified arguments.
2286 * @param ci the specified <code>CharacterIterator</code>
2287 * @param beginIndex the initial offset in <code>ci</code>
2288 * @param limit the end offset of <code>ci</code>
2289 * @param frc the specified <code>FontRenderContext</code>
2290 * @return a <code>LineMetrics</code> object created with the
2291 * specified arguments.
2292 */
2293 public LineMetrics getLineMetrics(CharacterIterator ci,
2294 int beginIndex, int limit,
2295 FontRenderContext frc) {
2296 FontLineMetrics flm = defaultLineMetrics(frc);
2297 int numChars = limit - beginIndex;
2298 flm.numchars = (numChars < 0)? 0: numChars;
2299 return flm;
2300 }
2301
2302 /**
2303 * Returns the logical bounds of the specified <code>String</code> in
2304 * the specified <code>FontRenderContext</code>. The logical bounds
2305 * contains the origin, ascent, advance, and height, which includes
2306 * the leading. The logical bounds does not always enclose all the
2307 * text. For example, in some languages and in some fonts, accent
2308 * marks can be positioned above the ascent or below the descent.
2309 * To obtain a visual bounding box, which encloses all the text,
2310 * use the {@link TextLayout#getBounds() getBounds} method of
2311 * <code>TextLayout</code>.
2312 * <p>Note: The returned bounds is in baseline-relative coordinates
2313 * (see {@link java.awt.Font class notes}).
2314 * @param str the specified <code>String</code>
2315 * @param frc the specified <code>FontRenderContext</code>
2316 * @return a {@link Rectangle2D} that is the bounding box of the
2317 * specified <code>String</code> in the specified
2318 * <code>FontRenderContext</code>.
2319 * @see FontRenderContext
2320 * @see Font#createGlyphVector
2321 * @since 1.2
2322 */
2323 public Rectangle2D getStringBounds( String str, FontRenderContext frc) {
2324 char[] array = str.toCharArray();
2325 return getStringBounds(array, 0, array.length, frc);
2326 }
2327
2328 /**
2329 * Returns the logical bounds of the specified <code>String</code> in
2330 * the specified <code>FontRenderContext</code>. The logical bounds
2331 * contains the origin, ascent, advance, and height, which includes
2332 * the leading. The logical bounds does not always enclose all the
2333 * text. For example, in some languages and in some fonts, accent
2334 * marks can be positioned above the ascent or below the descent.
2335 * To obtain a visual bounding box, which encloses all the text,
2336 * use the {@link TextLayout#getBounds() getBounds} method of
2337 * <code>TextLayout</code>.
2338 * <p>Note: The returned bounds is in baseline-relative coordinates
2339 * (see {@link java.awt.Font class notes}).
2340 * @param str the specified <code>String</code>
2341 * @param beginIndex the initial offset of <code>str</code>
2342 * @param limit the end offset of <code>str</code>
2343 * @param frc the specified <code>FontRenderContext</code>
2344 * @return a <code>Rectangle2D</code> that is the bounding box of the
2345 * specified <code>String</code> in the specified
2346 * <code>FontRenderContext</code>.
2347 * @throws IndexOutOfBoundsException if <code>beginIndex</code> is
2348 * less than zero, or <code>limit</code> is greater than the
2349 * length of <code>str</code>, or <code>beginIndex</code>
2350 * is greater than <code>limit</code>.
2351 * @see FontRenderContext
2352 * @see Font#createGlyphVector
2353 * @since 1.2
2354 */
2355 public Rectangle2D getStringBounds( String str,
2356 int beginIndex, int limit,
2357 FontRenderContext frc) {
2358 String substr = str.substring(beginIndex, limit);
2359 return getStringBounds(substr, frc);
2360 }
2361
2362 /**
2363 * Returns the logical bounds of the specified array of characters
2364 * in the specified <code>FontRenderContext</code>. The logical
2365 * bounds contains the origin, ascent, advance, and height, which
2366 * includes the leading. The logical bounds does not always enclose
2367 * all the text. For example, in some languages and in some fonts,
2368 * accent marks can be positioned above the ascent or below the
2369 * descent. To obtain a visual bounding box, which encloses all the
2370 * text, use the {@link TextLayout#getBounds() getBounds} method of
2371 * <code>TextLayout</code>.
2372 * <p>Note: The returned bounds is in baseline-relative coordinates
2373 * (see {@link java.awt.Font class notes}).
2374 * @param chars an array of characters
2375 * @param beginIndex the initial offset in the array of
2376 * characters
2377 * @param limit the end offset in the array of characters
2378 * @param frc the specified <code>FontRenderContext</code>
2379 * @return a <code>Rectangle2D</code> that is the bounding box of the
2380 * specified array of characters in the specified
2381 * <code>FontRenderContext</code>.
2382 * @throws IndexOutOfBoundsException if <code>beginIndex</code> is
2383 * less than zero, or <code>limit</code> is greater than the
2384 * length of <code>chars</code>, or <code>beginIndex</code>
2385 * is greater than <code>limit</code>.
2386 * @see FontRenderContext
2387 * @see Font#createGlyphVector
2388 * @since 1.2
2389 */
2390 public Rectangle2D getStringBounds(char [] chars,
2391 int beginIndex, int limit,
2392 FontRenderContext frc) {
2393 if (beginIndex < 0) {
2394 throw new IndexOutOfBoundsException("beginIndex: " + beginIndex);
2395 }
2396 if (limit > chars.length) {
2397 throw new IndexOutOfBoundsException("limit: " + limit);
2398 }
2399 if (beginIndex > limit) {
2400 throw new IndexOutOfBoundsException("range length: " +
2401 (limit - beginIndex));
2402 }
2403
2404 // this code should be in textlayout
2405 // quick check for simple text, assume GV ok to use if simple
2406
2407 boolean simple = values == null ||
2408 (values.getKerning() == 0 && values.getLigatures() == 0 &&
2409 values.getBaselineTransform() == null);
2410 if (simple) {
2411 simple = ! FontUtilities.isComplexText(chars, beginIndex, limit);
2412 }
2413
2414 if (simple) {
2415 GlyphVector gv = new StandardGlyphVector(this, chars, beginIndex,
2416 limit - beginIndex, frc);
2417 return gv.getLogicalBounds();
2418 } else {
2419 // need char array constructor on textlayout
2420 String str = new String(chars, beginIndex, limit - beginIndex);
2421 TextLayout tl = new TextLayout(str, this, frc);
2422 return new Rectangle2D.Float(0, -tl.getAscent(), tl.getAdvance(),
2423 tl.getAscent() + tl.getDescent() +
2424 tl.getLeading());
2425 }
2426 }
2427
2428 /**
2429 * Returns the logical bounds of the characters indexed in the
2430 * specified {@link CharacterIterator} in the
2431 * specified <code>FontRenderContext</code>. The logical bounds
2432 * contains the origin, ascent, advance, and height, which includes
2433 * the leading. The logical bounds does not always enclose all the
2434 * text. For example, in some languages and in some fonts, accent
2435 * marks can be positioned above the ascent or below the descent.
2436 * To obtain a visual bounding box, which encloses all the text,
2437 * use the {@link TextLayout#getBounds() getBounds} method of
2438 * <code>TextLayout</code>.
2439 * <p>Note: The returned bounds is in baseline-relative coordinates
2440 * (see {@link java.awt.Font class notes}).
2441 * @param ci the specified <code>CharacterIterator</code>
2442 * @param beginIndex the initial offset in <code>ci</code>
2443 * @param limit the end offset in <code>ci</code>
2444 * @param frc the specified <code>FontRenderContext</code>
2445 * @return a <code>Rectangle2D</code> that is the bounding box of the
2446 * characters indexed in the specified <code>CharacterIterator</code>
2447 * in the specified <code>FontRenderContext</code>.
2448 * @see FontRenderContext
2449 * @see Font#createGlyphVector
2450 * @since 1.2
2451 * @throws IndexOutOfBoundsException if <code>beginIndex</code> is
2452 * less than the start index of <code>ci</code>, or
2453 * <code>limit</code> is greater than the end index of
2454 * <code>ci</code>, or <code>beginIndex</code> is greater
2455 * than <code>limit</code>
2456 */
2457 public Rectangle2D getStringBounds(CharacterIterator ci,
2458 int beginIndex, int limit,
2459 FontRenderContext frc) {
2460 int start = ci.getBeginIndex();
2461 int end = ci.getEndIndex();
2462
2463 if (beginIndex < start) {
2464 throw new IndexOutOfBoundsException("beginIndex: " + beginIndex);
2465 }
2466 if (limit > end) {
2467 throw new IndexOutOfBoundsException("limit: " + limit);
2468 }
2469 if (beginIndex > limit) {
2470 throw new IndexOutOfBoundsException("range length: " +
2471 (limit - beginIndex));
2472 }
2473
2474 char[] arr = new char[limit - beginIndex];
2475
2476 ci.setIndex(beginIndex);
2477 for(int idx = 0; idx < arr.length; idx++) {
2478 arr[idx] = ci.current();
2479 ci.next();
2480 }
2481
2482 return getStringBounds(arr,0,arr.length,frc);
2483 }
2484
2485 /**
2486 * Returns the bounds for the character with the maximum
2487 * bounds as defined in the specified <code>FontRenderContext</code>.
2488 * <p>Note: The returned bounds is in baseline-relative coordinates
2489 * (see {@link java.awt.Font class notes}).
2490 * @param frc the specified <code>FontRenderContext</code>
2491 * @return a <code>Rectangle2D</code> that is the bounding box
2492 * for the character with the maximum bounds.
2493 */
2494 public Rectangle2D getMaxCharBounds(FontRenderContext frc) {
2495 float [] metrics = new float[4];
2496
2497 getFont2D().getFontMetrics(this, frc, metrics);
2498
2499 return new Rectangle2D.Float(0, -metrics[0],
2500 metrics[3],
2501 metrics[0] + metrics[1] + metrics[2]);
2502 }
2503
2504 /**
2505 * Creates a {@link java.awt.font.GlyphVector GlyphVector} by
2506 * mapping characters to glyphs one-to-one based on the
2507 * Unicode cmap in this <code>Font</code>. This method does no other
2508 * processing besides the mapping of glyphs to characters. This
2509 * means that this method is not useful for some scripts, such
2510 * as Arabic, Hebrew, Thai, and Indic, that require reordering,
2511 * shaping, or ligature substitution.
2512 * @param frc the specified <code>FontRenderContext</code>
2513 * @param str the specified <code>String</code>
2514 * @return a new <code>GlyphVector</code> created with the
2515 * specified <code>String</code> and the specified
2516 * <code>FontRenderContext</code>.
2517 */
2518 public GlyphVector createGlyphVector(FontRenderContext frc, String str)
2519 {
2520 return (GlyphVector)new StandardGlyphVector(this, str, frc);
2521 }
2522
2523 /**
2524 * Creates a {@link java.awt.font.GlyphVector GlyphVector} by
2525 * mapping characters to glyphs one-to-one based on the
2526 * Unicode cmap in this <code>Font</code>. This method does no other
2527 * processing besides the mapping of glyphs to characters. This
2528 * means that this method is not useful for some scripts, such
2529 * as Arabic, Hebrew, Thai, and Indic, that require reordering,
2530 * shaping, or ligature substitution.
2531 * @param frc the specified <code>FontRenderContext</code>
2532 * @param chars the specified array of characters
2533 * @return a new <code>GlyphVector</code> created with the
2534 * specified array of characters and the specified
2535 * <code>FontRenderContext</code>.
2536 */
2537 public GlyphVector createGlyphVector(FontRenderContext frc, char[] chars)
2538 {
2539 return (GlyphVector)new StandardGlyphVector(this, chars, frc);
2540 }
2541
2542 /**
2543 * Creates a {@link java.awt.font.GlyphVector GlyphVector} by
2544 * mapping the specified characters to glyphs one-to-one based on the
2545 * Unicode cmap in this <code>Font</code>. This method does no other
2546 * processing besides the mapping of glyphs to characters. This
2547 * means that this method is not useful for some scripts, such
2548 * as Arabic, Hebrew, Thai, and Indic, that require reordering,
2549 * shaping, or ligature substitution.
2550 * @param frc the specified <code>FontRenderContext</code>
2551 * @param ci the specified <code>CharacterIterator</code>
2552 * @return a new <code>GlyphVector</code> created with the
2553 * specified <code>CharacterIterator</code> and the specified
2554 * <code>FontRenderContext</code>.
2555 */
2556 public GlyphVector createGlyphVector( FontRenderContext frc,
2557 CharacterIterator ci)
2558 {
2559 return (GlyphVector)new StandardGlyphVector(this, ci, frc);
2560 }
2561
2562 /**
2563 * Creates a {@link java.awt.font.GlyphVector GlyphVector} by
2564 * mapping characters to glyphs one-to-one based on the
2565 * Unicode cmap in this <code>Font</code>. This method does no other
2566 * processing besides the mapping of glyphs to characters. This
2567 * means that this method is not useful for some scripts, such
2568 * as Arabic, Hebrew, Thai, and Indic, that require reordering,
2569 * shaping, or ligature substitution.
2570 * @param frc the specified <code>FontRenderContext</code>
2571 * @param glyphCodes the specified integer array
2572 * @return a new <code>GlyphVector</code> created with the
2573 * specified integer array and the specified
2574 * <code>FontRenderContext</code>.
2575 */
2576 public GlyphVector createGlyphVector( FontRenderContext frc,
2577 int [] glyphCodes)
2578 {
2579 return (GlyphVector)new StandardGlyphVector(this, glyphCodes, frc);
2580 }
2581
2582 /**
2583 * Returns a new <code>GlyphVector</code> object, performing full
2584 * layout of the text if possible. Full layout is required for
2585 * complex text, such as Arabic or Hindi. Support for different
2586 * scripts depends on the font and implementation.
2587 * <p>
2588 * Layout requires bidi analysis, as performed by
2589 * <code>Bidi</code>, and should only be performed on text that
2590 * has a uniform direction. The direction is indicated in the
2591 * flags parameter,by using LAYOUT_RIGHT_TO_LEFT to indicate a
2592 * right-to-left (Arabic and Hebrew) run direction, or
2593 * LAYOUT_LEFT_TO_RIGHT to indicate a left-to-right (English)
2594 * run direction.
2595 * <p>
2596 * In addition, some operations, such as Arabic shaping, require
2597 * context, so that the characters at the start and limit can have
2598 * the proper shapes. Sometimes the data in the buffer outside
2599 * the provided range does not have valid data. The values
2600 * LAYOUT_NO_START_CONTEXT and LAYOUT_NO_LIMIT_CONTEXT can be
2601 * added to the flags parameter to indicate that the text before
2602 * start, or after limit, respectively, should not be examined
2603 * for context.
2604 * <p>
2605 * All other values for the flags parameter are reserved.
2606 *
2607 * @param frc the specified <code>FontRenderContext</code>
2608 * @param text the text to layout
2609 * @param start the start of the text to use for the <code>GlyphVector</code>
2610 * @param limit the limit of the text to use for the <code>GlyphVector</code>
2611 * @param flags control flags as described above
2612 * @return a new <code>GlyphVector</code> representing the text between
2613 * start and limit, with glyphs chosen and positioned so as to best represent
2614 * the text
2615 * @throws ArrayIndexOutOfBoundsException if start or limit is
2616 * out of bounds
2617 * @see java.text.Bidi
2618 * @see #LAYOUT_LEFT_TO_RIGHT
2619 * @see #LAYOUT_RIGHT_TO_LEFT
2620 * @see #LAYOUT_NO_START_CONTEXT
2621 * @see #LAYOUT_NO_LIMIT_CONTEXT
2622 * @since 1.4
2623 */
2624 public GlyphVector layoutGlyphVector(FontRenderContext frc,
2625 char[] text,
2626 int start,
2627 int limit,
2628 int flags) {
2629
2630 GlyphLayout gl = GlyphLayout.get(null); // !!! no custom layout engines
2631 StandardGlyphVector gv = gl.layout(this, frc, text,
2632 start, limit-start, flags, null);
2633 GlyphLayout.done(gl);
2634 return gv;
2635 }
2636
2637 /**
2638 * A flag to layoutGlyphVector indicating that text is left-to-right as
2639 * determined by Bidi analysis.
2640 */
2641 public static final int LAYOUT_LEFT_TO_RIGHT = 0;
2642
2643 /**
2644 * A flag to layoutGlyphVector indicating that text is right-to-left as
2645 * determined by Bidi analysis.
2646 */
2647 public static final int LAYOUT_RIGHT_TO_LEFT = 1;
2648
2649 /**
2650 * A flag to layoutGlyphVector indicating that text in the char array
2651 * before the indicated start should not be examined.
2652 */
2653 public static final int LAYOUT_NO_START_CONTEXT = 2;
2654
2655 /**
2656 * A flag to layoutGlyphVector indicating that text in the char array
2657 * after the indicated limit should not be examined.
2658 */
2659 public static final int LAYOUT_NO_LIMIT_CONTEXT = 4;
2660
2661
2662 private static void applyTransform(AffineTransform trans, AttributeValues values) {
2663 if (trans == null) {
2664 throw new IllegalArgumentException("transform must not be null");
2665 }
2666 values.setTransform(trans);
2667 }
2668
2669 private static void applyStyle(int style, AttributeValues values) {
2670 // WEIGHT_BOLD, WEIGHT_REGULAR
2671 values.setWeight((style & BOLD) != 0 ? 2f : 1f);
2672 // POSTURE_OBLIQUE, POSTURE_REGULAR
2673 values.setPosture((style & ITALIC) != 0 ? .2f : 0f);
2674 }
2675
2676 /*
2677 * Initialize JNI field and method IDs
2678 */
2679 private static native void initIDs();
2680 }