1 /*
2 * Copyright (c) 1997, 2018, 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 sun.font;
27
28 import java.lang.ref.ReferenceQueue;
29 import java.lang.ref.SoftReference;
30
31 import java.awt.FontMetrics;
32 import java.awt.Font;
33 import java.awt.GraphicsEnvironment;
34 import java.awt.geom.AffineTransform;
35 import java.awt.geom.NoninvertibleTransformException;
36 import java.awt.geom.Rectangle2D;
37 import java.awt.font.FontRenderContext;
38 import java.awt.font.TextLayout;
39
40 import java.io.IOException;
41 import java.io.ObjectInputStream;
42 import java.io.ObjectOutputStream;
43
44 import java.util.concurrent.ConcurrentHashMap;
45
46 import sun.java2d.Disposer;
47 import sun.java2d.DisposerRecord;
48
49 /*
50 * This class provides a summary of the glyph measurements for a Font
51 * and a set of hints that guide their display. It provides more metrics
52 * information for the Font than the java.awt.FontMetrics class. There
53 * is also some redundancy with that class.
54 * <p>
55 * The design metrics for a Font are obtained from Font.getDesignMetrics().
56 * The FontDesignMetrics object returned will be independent of the
57 * point size of the Font.
58 * Most users are familiar with the idea of using <i>point size</i> to
59 * specify the size of glyphs in a font. This point size defines a
60 * measurement between the baseline of one line to the baseline of the
61 * following line in a single spaced text document. The point size is
62 * based on <i>typographic points</i>, approximately 1/72 of an inch.
63 * <p>
64 * The Java2D API adopts the convention that one point is equivalent
65 * to one unit in user coordinates. When using a normalized transform
66 * for converting user space coordinates to device space coordinates (see
67 * GraphicsConfiguration.getDefaultTransform() and
68 * GraphicsConfiguration.getNormalizingTransform()), 72 user space units
69 * equal 1 inch in device space. In this case one point is 1/72 of an inch.
70 * <p>
71 * The FontDesignMetrics class expresses font metrics in terms of arbitrary
72 * <i>typographic units</i> (not points) chosen by the font supplier
73 * and used in the underlying platform font representations. These units are
74 * defined by dividing the em-square into a grid. The em-sqaure is the
75 * theoretical square whose dimensions are the full body height of the
76 * font. A typographic unit is the smallest measurable unit in the
77 * em-square. The number of units-per-em is determined by the font
78 * designer. The greater the units-per-em, the greater the precision
79 * in metrics. For example, Type 1 fonts divide the em-square into a
80 * 1000 x 1000 grid, while TrueType fonts typically use a 2048 x 2048
81 * grid. The scale of these units can be obtained by calling
82 * getUnitsPerEm().
83 * <p>
84 * Typographic units are relative -- their absolute size changes as the
85 * size of the of the em-square changes. An em-square is 9 points high
86 * in a 9-point font. Because typographic units are relative to the
87 * em-square, a given location on a glyph will have the same coordinates
88 * in typographic units regardless of the point size.
89 * <p>
90 * Converting typographic units to pixels requires computing pixels-per-em
91 * (ppem). This can be computed as:
92 * <pre>
93 ppem = device_resolution * (inches-per-point) * pointSize
94 * </pre>
95 * where device resolution could be measured in pixels/inch and the point
96 * size of a font is effectively points/em. Using a normalized transform
97 * from user space to device space (see above), results in 1/72 inch/point.
98 * In this case, ppem is equal to the point size on a 72 dpi monitor, so
99 * that an N point font displays N pixels high. In general,
100 * <pre>
101 pixel_units = typographic_units * (ppem / units_per_em)
102 * </pre>
103 * @see java.awt.Font
104 * @see java.awt.GraphicsConfiguration#getDefaultTransform
105 * @see java.awt.GraphicsConfiguration#getNormalizingTransform
106 */
107
108 public final class FontDesignMetrics extends FontMetrics {
109
110 static final long serialVersionUID = 4480069578560887773L;
111
112 private static final float UNKNOWN_WIDTH = -1;
113 private static final int CURRENT_VERSION = 1;
114
115 // height, ascent, descent, leading are reported to the client
116 // as an integer this value is added to the true fp value to
117 // obtain a value which is usually going to result in a round up
118 // to the next integer except for very marginal cases.
119 private static float roundingUpValue = 0.95f;
120
121 // These fields are all part of the old serialization representation
122 private Font font;
123 private float ascent;
124 private float descent;
125 private float leading;
126 private float maxAdvance;
127 private double[] matrix;
128 private int[] cache; // now unused, still here only for serialization
129 // End legacy serialization fields
130
131 private int serVersion = 0; // If 1 in readObject, these fields are on the input stream:
132 private boolean isAntiAliased;
133 private boolean usesFractionalMetrics;
134 private AffineTransform frcTx;
135
136 private transient float[] advCache; // transient since values could change across runtimes
137 private transient int height = -1;
138
139 private transient FontRenderContext frc;
140
141 private transient double[] devmatrix = null;
142
143 private transient FontStrike fontStrike;
144
145 private static FontRenderContext DEFAULT_FRC = null;
146
147 private static FontRenderContext getDefaultFrc() {
148
149 if (DEFAULT_FRC == null) {
150 AffineTransform tx;
151 if (GraphicsEnvironment.isHeadless()) {
152 tx = new AffineTransform();
153 } else {
154 tx = GraphicsEnvironment
155 .getLocalGraphicsEnvironment()
156 .getDefaultScreenDevice()
157 .getDefaultConfiguration()
158 .getDefaultTransform();
159 }
160 DEFAULT_FRC = new FontRenderContext(tx, false, false);
161 }
162 return DEFAULT_FRC;
163 }
164
165 /* Strongly cache up to 5 most recently requested FontMetrics objects,
166 * and softly cache as many as GC allows. In practice this means we
167 * should keep references around until memory gets low.
168 * We key the cache either by a Font or a combination of the Font and
169 * and FRC. A lot of callers use only the font so although there's code
170 * duplication, we allow just a font to be a key implying a default FRC.
171 * Also we put the references on a queue so that if they do get nulled
172 * out we can clear the keys from the table.
173 */
174 private static class KeyReference extends SoftReference<Object>
175 implements DisposerRecord, Disposer.PollDisposable {
176
177 static ReferenceQueue<Object> queue = Disposer.getQueue();
178
179 Object key;
180
181 KeyReference(Object key, Object value) {
182 super(value, queue);
183 this.key = key;
184 Disposer.addReference(this, this);
185 }
186
187 /* It is possible that since this reference object has been
188 * enqueued, that a new metrics has been put into the table
189 * for the same key value. So we'll test to see if the table maps
190 * to THIS reference. If its a new one, we'll leave it alone.
191 * It is possible that a new entry comes in after our test, but
192 * it is unlikely and if this were a problem we would need to
193 * synchronize all 'put' and 'remove' accesses to the cache which
194 * I would prefer not to do.
195 */
196 public void dispose() {
197 if (metricsCache.get(key) == this) {
198 metricsCache.remove(key);
199 }
200 }
201 }
202
203 private static class MetricsKey {
204 Font font;
205 FontRenderContext frc;
206 int hash;
207
208 MetricsKey() {
209 }
210
211 MetricsKey(Font font, FontRenderContext frc) {
212 init(font, frc);
213 }
214
215 void init(Font font, FontRenderContext frc) {
216 this.font = font;
217 this.frc = frc;
218 this.hash = font.hashCode() + frc.hashCode();
219 }
220
221 public boolean equals(Object key) {
222 if (!(key instanceof MetricsKey)) {
223 return false;
224 }
225 return
226 font.equals(((MetricsKey)key).font) &&
227 frc.equals(((MetricsKey)key).frc);
228 }
229
230 public int hashCode() {
231 return hash;
232 }
233
234 /* Synchronize access to this on the class */
235 static final MetricsKey key = new MetricsKey();
236 }
237
238 /* All accesses to a CHM do not in general need to be synchronized,
239 * as incomplete operations on another thread would just lead to
240 * harmless cache misses.
241 */
242 private static final ConcurrentHashMap<Object, KeyReference>
243 metricsCache = new ConcurrentHashMap<Object, KeyReference>();
244
245 private static final int MAXRECENT = 5;
246 private static final FontDesignMetrics[]
247 recentMetrics = new FontDesignMetrics[MAXRECENT];
248 private static int recentIndex = 0;
249
250 public static FontDesignMetrics getMetrics(Font font) {
251 return getMetrics(font, getDefaultFrc());
252 }
253
254 public static FontDesignMetrics getMetrics(Font font,
255 FontRenderContext frc) {
256
257
258 /* When using alternate composites, can't cache based just on
259 * the java.awt.Font. Since this is rarely used and we can still
260 * cache the physical fonts, its not a problem to just return a
261 * new instance in this case.
262 * Note that currently Swing native L&F composites are not handled
263 * by this code as they use the metrics of the physical anyway.
264 */
265 SunFontManager fm = SunFontManager.getInstance();
266 if (fm.maybeUsingAlternateCompositeFonts() &&
267 FontUtilities.getFont2D(font) instanceof CompositeFont) {
268 return new FontDesignMetrics(font, frc);
269 }
270
271 FontDesignMetrics m = null;
272 KeyReference r;
273
274 /* There are 2 possible keys used to perform lookups in metricsCache.
275 * If the FRC is set to all defaults, we just use the font as the key.
276 * If the FRC is non-default in any way, we construct a hybrid key
277 * that combines the font and FRC.
278 */
279 boolean usefontkey = frc.equals(getDefaultFrc());
280
281 if (usefontkey) {
282 r = metricsCache.get(font);
283 } else /* use hybrid key */ {
284 // NB synchronization is not needed here because of updates to
285 // the metrics cache but is needed for the shared key.
286 synchronized (MetricsKey.class) {
287 MetricsKey.key.init(font, frc);
288 r = metricsCache.get(MetricsKey.key);
289 }
290 }
291
292 if (r != null) {
293 m = (FontDesignMetrics)r.get();
294 }
295
296 if (m == null) {
297 /* either there was no reference, or it was cleared. Need a new
298 * metrics instance. The key to use in the map is a new
299 * MetricsKey instance when we've determined the FRC is
300 * non-default. Its constructed from local vars so we are
301 * thread-safe - no need to worry about the shared key changing.
302 */
303 m = new FontDesignMetrics(font, frc);
304 if (usefontkey) {
305 metricsCache.put(font, new KeyReference(font, m));
306 } else /* use hybrid key */ {
307 MetricsKey newKey = new MetricsKey(font, frc);
308 metricsCache.put(newKey, new KeyReference(newKey, m));
309 }
310 }
311
312 /* Here's where we keep the recent metrics */
313 for (int i=0; i<recentMetrics.length; i++) {
314 if (recentMetrics[i]==m) {
315 return m;
316 }
317 }
318
319 synchronized (recentMetrics) {
320 recentMetrics[recentIndex++] = m;
321 if (recentIndex == MAXRECENT) {
322 recentIndex = 0;
323 }
324 }
325 return m;
326 }
327
328 /*
329 * Constructs a new FontDesignMetrics object for the given Font.
330 * Its private to enable caching - call getMetrics() instead.
331 * @param font a Font object.
332 */
333
334 private FontDesignMetrics(Font font) {
335
336 this(font, getDefaultFrc());
337 }
338
339 /* private to enable caching - call getMetrics() instead. */
340 private FontDesignMetrics(Font font, FontRenderContext frc) {
341 super(font);
342 this.font = font;
343 this.frc = frc;
344
345 this.isAntiAliased = frc.isAntiAliased();
346 this.usesFractionalMetrics = frc.usesFractionalMetrics();
347
348 frcTx = frc.getTransform();
349
350 matrix = new double[4];
351 initMatrixAndMetrics();
352
353 initAdvCache();
354 }
355
356 private void initMatrixAndMetrics() {
357
358 Font2D font2D = FontUtilities.getFont2D(font);
359 fontStrike = font2D.getStrike(font, frc);
360 StrikeMetrics metrics = fontStrike.getFontMetrics();
361 this.ascent = metrics.getAscent();
362 this.descent = metrics.getDescent();
363 this.leading = metrics.getLeading();
364 this.maxAdvance = metrics.getMaxAdvance();
365
366 devmatrix = new double[4];
367 frcTx.getMatrix(devmatrix);
368 }
369
370 private void initAdvCache() {
371 advCache = new float[256];
372 // 0 is a valid metric so force it to -1
373 for (int i = 0; i < 256; i++) {
374 advCache[i] = UNKNOWN_WIDTH;
375 }
376 }
377
378 private void readObject(ObjectInputStream in) throws IOException,
379 ClassNotFoundException {
380
381 in.defaultReadObject();
382 if (serVersion != CURRENT_VERSION) {
383 frc = getDefaultFrc();
384 isAntiAliased = frc.isAntiAliased();
385 usesFractionalMetrics = frc.usesFractionalMetrics();
386 frcTx = frc.getTransform();
387 }
388 else {
389 frc = new FontRenderContext(frcTx, isAntiAliased, usesFractionalMetrics);
390 }
391
392 // when deserialized, members are set to their default values for their type--
393 // not to the values assigned during initialization before the constructor
394 // body!
395 height = -1;
396
397 cache = null;
398
399 initMatrixAndMetrics();
400 initAdvCache();
401 }
402
403 private void writeObject(ObjectOutputStream out) throws IOException {
404
405 cache = new int[256];
406 for (int i=0; i < 256; i++) {
407 cache[i] = -1;
408 }
409 serVersion = CURRENT_VERSION;
410
411 out.defaultWriteObject();
412
413 cache = null;
414 }
415
416 private float handleCharWidth(int ch) {
417 return fontStrike.getCodePointAdvance(ch); // x-component of result only
418 }
419
420 // Uses advCache to get character width
421 // It is incorrect to call this method for ch > 255
422 private float getLatinCharWidth(char ch) {
423
424 float w = advCache[ch];
425 if (w == UNKNOWN_WIDTH) {
426 w = handleCharWidth(ch);
427 advCache[ch] = w;
428 }
429 return w;
430 }
431
432
433 /* Override of FontMetrics.getFontRenderContext() */
434 public FontRenderContext getFontRenderContext() {
435 return frc;
436 }
437
438 public int charWidth(char ch) {
439 // default metrics for compatibility with legacy code
440 float w;
441 if (ch < 0x100) {
442 w = getLatinCharWidth(ch);
443 }
444 else {
445 w = handleCharWidth(ch);
446 }
447 return (int)(0.5 + w);
448 }
449
450 public int charWidth(int ch) {
451 if (!Character.isValidCodePoint(ch)) {
452 ch = 0xffff;
453 }
454
455 float w = handleCharWidth(ch);
456
457 return (int)(0.5 + w);
458 }
459
460 public int stringWidth(String str) {
461
462 float width = 0;
463 if (font.hasLayoutAttributes()) {
464 /* TextLayout throws IAE for null, so throw NPE explicitly */
465 if (str == null) {
466 throw new NullPointerException("str is null");
467 }
468 if (str.length() == 0) {
469 return 0;
470 }
471 width = new TextLayout(str, font, frc).getAdvance();
472 } else {
473 int length = str.length();
474 for (int i=0; i < length; i++) {
475 char ch = str.charAt(i);
476 if (ch < 0x100) {
477 width += getLatinCharWidth(ch);
478 } else if (FontUtilities.isNonSimpleChar(ch)) {
479 width = new TextLayout(str, font, frc).getAdvance();
480 break;
481 } else {
482 width += handleCharWidth(ch);
483 }
484 }
485 }
486
487 return (int) (0.5 + width);
488 }
489
490 public int charsWidth(char[] data, int off, int len) {
491
492 float width = 0;
493 if (font.hasLayoutAttributes()) {
494 if (len == 0) {
495 return 0;
496 }
497 String str = new String(data, off, len);
498 width = new TextLayout(str, font, frc).getAdvance();
499 } else {
500 /* Explicit test needed to satisfy superclass spec */
501 if (len < 0) {
502 throw new IndexOutOfBoundsException("len="+len);
503 }
504 int limit = off + len;
505 for (int i=off; i < limit; i++) {
506 char ch = data[i];
507 if (ch < 0x100) {
508 width += getLatinCharWidth(ch);
509 } else if (FontUtilities.isNonSimpleChar(ch)) {
510 String str = new String(data, off, len);
511 width = new TextLayout(str, font, frc).getAdvance();
512 break;
513 } else {
514 width += handleCharWidth(ch);
515 }
516 }
517 }
518
519 return (int) (0.5 + width);
520 }
521
522 /**
523 * This method is called from java.awt.Font only after verifying
524 * the arguments and that the text is simple and there are no
525 * layout attributes, font transform etc.
526 */
527 public Rectangle2D getSimpleBounds(char[] data, int off, int len) {
528
529 float width = 0;
530 int limit = off + len;
531 for (int i=off; i < limit; i++) {
532 char ch = data[i];
533 if (ch < 0x100) {
534 width += getLatinCharWidth(ch);
535 } else {
536 width += handleCharWidth(ch);
537 }
538 }
539
540 float height = ascent + descent + leading;
541 return new Rectangle2D.Float(0f, -ascent, width, height);
542 }
543
544 /**
545 * Gets the advance widths of the first 256 characters in the
546 * {@code Font}. The advance is the
547 * distance from the leftmost point to the rightmost point on the
548 * character's baseline. Note that the advance of a
549 * {@code String} is not necessarily the sum of the advances
550 * of its characters.
551 * @return an array storing the advance widths of the
552 * characters in the {@code Font}
553 * described by this {@code FontMetrics} object.
554 */
555 // More efficient than base class implementation - reuses existing cache
556 public int[] getWidths() {
557 int[] widths = new int[256];
558 for (char ch = 0 ; ch < 256 ; ch++) {
559 float w = advCache[ch];
560 if (w == UNKNOWN_WIDTH) {
561 w = advCache[ch] = handleCharWidth(ch);
562 }
563 widths[ch] = (int) (0.5 + w);
564 }
565 return widths;
566 }
567
568 public int getMaxAdvance() {
569 return (int)(0.99f + this.maxAdvance);
570 }
571
572 /*
573 * Returns the typographic ascent of the font. This is the maximum distance
574 * glyphs in this font extend above the base line (measured in typographic
575 * units).
576 */
577 public int getAscent() {
578 return (int)(roundingUpValue + this.ascent);
579 }
580
581 /*
582 * Returns the typographic descent of the font. This is the maximum distance
583 * glyphs in this font extend below the base line.
584 */
585 public int getDescent() {
586 return (int)(roundingUpValue + this.descent);
587 }
588
589 public int getLeading() {
590 // nb this ensures the sum of the results of the public methods
591 // for leading, ascent & descent sum to height.
592 // if the calculations in any other methods change this needs
593 // to be changed too.
594 // the 0.95 value used here and in the other methods allows some
595 // tiny fraction of leeway before rouding up. A higher value (0.99)
596 // caused some excessive rounding up.
597 return
598 (int)(roundingUpValue + descent + leading) -
599 (int)(roundingUpValue + descent);
600 }
601
602 // height is calculated as the sum of two separately rounded up values
603 // because typically clients use ascent to determine the y location to
604 // pass to drawString etc and we need to ensure that the height has enough
605 // space below the baseline to fully contain any descender.
606 public int getHeight() {
607
608 if (height < 0) {
609 height = getAscent() + (int)(roundingUpValue + descent + leading);
610 }
611 return height;
612 }
613 }