1 /*
2 * Copyright (c) 2008, 2020, 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.awt.Font;
29 import java.io.BufferedReader;
30 import java.io.File;
31 import java.io.FileInputStream;
32 import java.io.InputStreamReader;
33 import java.lang.ref.SoftReference;
34 import java.util.concurrent.ConcurrentHashMap;
35 import java.security.AccessController;
36
37 import java.security.PrivilegedAction;
38 import javax.swing.plaf.FontUIResource;
39
40 import sun.util.logging.PlatformLogger;
41
42 /**
43 * A collection of utility methods.
44 */
45 public final class FontUtilities {
46
47 public static boolean isLinux;
48
49 public static boolean isMacOSX;
50 public static boolean isMacOSX14;
51
52 public static boolean useJDKScaler;
53
54 public static boolean isWindows;
55
56 private static boolean debugFonts = false;
57 private static PlatformLogger logger = null;
58 private static boolean logging;
59
60 // This static initializer block figures out the OS constants.
61 static {
62
63 AccessController.doPrivileged(new PrivilegedAction<Object>() {
64 @SuppressWarnings("deprecation") // PlatformLogger.setLevel is deprecated.
65 @Override
66 public Object run() {
67 String osName = System.getProperty("os.name", "unknownOS");
68
69 isLinux = osName.startsWith("Linux");
70
71 isMacOSX = osName.contains("OS X"); // TODO: MacOSX
72 if (isMacOSX) {
73 // os.version has values like 10.13.6, 10.14.6
74 // If it is not positively recognised as 10.13 or less,
75 // assume it means 10.14 or some later version.
76 isMacOSX14 = true;
77 String version = System.getProperty("os.version", "");
78 if (version.startsWith("10.")) {
79 version = version.substring(3);
80 int periodIndex = version.indexOf('.');
81 if (periodIndex != -1) {
82 version = version.substring(0, periodIndex);
83 }
84 try {
85 int v = Integer.parseInt(version);
86 isMacOSX14 = (v >= 14);
87 } catch (NumberFormatException e) {
88 }
89 }
90 }
91 /* If set to "jdk", use the JDK's scaler rather than
92 * the platform one. This may be a no-op on platforms where
93 * JDK has been configured so that it always relies on the
94 * platform scaler. The principal case where it has an
95 * effect is that on Windows, 2D will never use GDI.
96 */
97 String scalerStr = System.getProperty("sun.java2d.font.scaler");
98 if (scalerStr != null) {
99 useJDKScaler = "jdk".equals(scalerStr);
100 } else {
101 useJDKScaler = false;
102 }
103 isWindows = osName.startsWith("Windows");
104 String debugLevel =
105 System.getProperty("sun.java2d.debugfonts");
106
107 if (debugLevel != null && !debugLevel.equals("false")) {
108 debugFonts = true;
109 logger = PlatformLogger.getLogger("sun.java2d");
110 if (debugLevel.equals("warning")) {
111 logger.setLevel(PlatformLogger.Level.WARNING);
112 } else if (debugLevel.equals("severe")) {
113 logger.setLevel(PlatformLogger.Level.SEVERE);
114 }
115 }
116
117 if (debugFonts) {
118 logger = PlatformLogger.getLogger("sun.java2d");
119 logging = logger.isEnabled();
120 }
121
122 return null;
123 }
124 });
125 }
126
127 /**
128 * Referenced by code in the JDK which wants to test for the
129 * minimum char code for which layout may be required.
130 * Note that even basic latin text can benefit from ligatures,
131 * eg "ffi" but we presently apply those only if explicitly
132 * requested with TextAttribute.LIGATURES_ON.
133 * The value here indicates the lowest char code for which failing
134 * to invoke layout would prevent acceptable rendering.
135 */
136 public static final int MIN_LAYOUT_CHARCODE = 0x0300;
137
138 /**
139 * Referenced by code in the JDK which wants to test for the
140 * maximum char code for which layout may be required.
141 * Note this does not account for supplementary characters
142 * where the caller interprets 'layout' to mean any case where
143 * one 'char' (ie the java type char) does not map to one glyph
144 */
145 public static final int MAX_LAYOUT_CHARCODE = 0x206F;
146
147 /**
148 * Calls the private getFont2D() method in java.awt.Font objects.
149 *
150 * @param font the font object to call
151 *
152 * @return the Font2D object returned by Font.getFont2D()
153 */
154 public static Font2D getFont2D(Font font) {
155 return FontAccess.getFontAccess().getFont2D(font);
156 }
157
158 /**
159 * Return true if there any characters which would trigger layout.
160 * This method considers supplementary characters to be simple,
161 * since we do not presently invoke layout on any code points in
162 * outside the BMP.
163 */
164 public static boolean isComplexScript(char [] chs, int start, int limit) {
165
166 for (int i = start; i < limit; i++) {
167 if (chs[i] < MIN_LAYOUT_CHARCODE) {
168 continue;
169 }
170 else if (isComplexCharCode(chs[i])) {
171 return true;
172 }
173 }
174 return false;
175 }
176
177 /**
178 * If there is anything in the text which triggers a case
179 * where char->glyph does not map 1:1 in straightforward
180 * left->right ordering, then this method returns true.
181 * Scripts which might require it but are not treated as such
182 * due to JDK implementations will not return true.
183 * ie a 'true' return is an indication of the treatment by
184 * the implementation.
185 * Whether supplementary characters should be considered is dependent
186 * on the needs of the caller. Since this method accepts the 'char' type
187 * then such chars are always represented by a pair. From a rendering
188 * perspective these will all (in the cases I know of) still be one
189 * unicode character -> one glyph. But if a caller is using this to
190 * discover any case where it cannot make naive assumptions about
191 * the number of chars, and how to index through them, then it may
192 * need the option to have a 'true' return in such a case.
193 */
194 public static boolean isComplexText(char [] chs, int start, int limit) {
195
196 for (int i = start; i < limit; i++) {
197 if (chs[i] < MIN_LAYOUT_CHARCODE) {
198 continue;
199 }
200 else if (isNonSimpleChar(chs[i])) {
201 return true;
202 }
203 }
204 return false;
205 }
206
207 /* This is almost the same as the method above, except it takes a
208 * char which means it may include undecoded surrogate pairs.
209 * The distinction is made so that code which needs to identify all
210 * cases in which we do not have a simple mapping from
211 * char->unicode character->glyph can be identified.
212 * For example measurement cannot simply sum advances of 'chars',
213 * the caret in editable text cannot advance one 'char' at a time, etc.
214 * These callers really are asking for more than whether 'layout'
215 * needs to be run, they need to know if they can assume 1->1
216 * char->glyph mapping.
217 */
218 public static boolean isNonSimpleChar(char ch) {
219 return
220 isComplexCharCode(ch) ||
221 (ch >= CharToGlyphMapper.HI_SURROGATE_START &&
222 ch <= CharToGlyphMapper.LO_SURROGATE_END);
223 }
224
225 /* If the character code falls into any of a number of unicode ranges
226 * where we know that simple left->right layout mapping chars to glyphs
227 * 1:1 and accumulating advances is going to produce incorrect results,
228 * we want to know this so the caller can use a more intelligent layout
229 * approach. A caller who cares about optimum performance may want to
230 * check the first case and skip the method call if its in that range.
231 * Although there's a lot of tests in here, knowing you can skip
232 * CTL saves a great deal more. The rest of the checks are ordered
233 * so that rather than checking explicitly if (>= start & <= end)
234 * which would mean all ranges would need to be checked so be sure
235 * CTL is not needed, the method returns as soon as it recognises
236 * the code point is outside of a CTL ranges.
237 * NOTE: Since this method accepts an 'int' it is asssumed to properly
238 * represent a CHARACTER. ie it assumes the caller has already
239 * converted surrogate pairs into supplementary characters, and so
240 * can handle this case and doesn't need to be told such a case is
241 * 'complex'.
242 */
243 public static boolean isComplexCharCode(int code) {
244
245 if (code < MIN_LAYOUT_CHARCODE || code > MAX_LAYOUT_CHARCODE) {
246 return false;
247 }
248 else if (code <= 0x036f) {
249 // Trigger layout for combining diacriticals 0x0300->0x036f
250 return true;
251 }
252 else if (code < 0x0590) {
253 // No automatic layout for Greek, Cyrillic, Armenian.
254 return false;
255 }
256 else if (code <= 0x06ff) {
257 // Hebrew 0590 - 05ff
258 // Arabic 0600 - 06ff
259 return true;
260 }
261 else if (code < 0x0900) {
262 return false; // Syriac and Thaana
263 }
264 else if (code <= 0x0e7f) {
265 // if Indic, assume shaping for conjuncts, reordering:
266 // 0900 - 097F Devanagari
267 // 0980 - 09FF Bengali
268 // 0A00 - 0A7F Gurmukhi
269 // 0A80 - 0AFF Gujarati
270 // 0B00 - 0B7F Oriya
271 // 0B80 - 0BFF Tamil
272 // 0C00 - 0C7F Telugu
273 // 0C80 - 0CFF Kannada
274 // 0D00 - 0D7F Malayalam
275 // 0D80 - 0DFF Sinhala
276 // 0E00 - 0E7F if Thai, assume shaping for vowel, tone marks
277 return true;
278 }
279 else if (code < 0x0f00) {
280 return false;
281 }
282 else if (code <= 0x0fff) { // U+0F00 - U+0FFF Tibetan
283 return true;
284 }
285 else if (code < 0x10A0) { // U+1000 - U+109F Myanmar
286 return true;
287 }
288 else if (code < 0x1100) {
289 return false;
290 }
291 else if (code < 0x11ff) { // U+1100 - U+11FF Old Hangul
292 return true;
293 }
294 else if (code < 0x1780) {
295 return false;
296 }
297 else if (code <= 0x17ff) { // 1780 - 17FF Khmer
298 return true;
299 }
300 else if (code < 0x200c) {
301 return false;
302 }
303 else if (code <= 0x200d) { // zwj or zwnj
304 return true;
305 }
306 else if (code >= 0x202a && code <= 0x202e) { // directional control
307 return true;
308 }
309 else if (code >= 0x206a && code <= 0x206f) { // directional control
310 return true;
311 }
312 return false;
313 }
314
315 public static PlatformLogger getLogger() {
316 return logger;
317 }
318
319 public static boolean isLogging() {
320 return logging;
321 }
322
323 public static boolean debugFonts() {
324 return debugFonts;
325 }
326
327
328 // The following methods are used by Swing.
329
330 /* Revise the implementation to in fact mean "font is a composite font.
331 * This ensures that Swing components will always benefit from the
332 * fall back fonts
333 */
334 public static boolean fontSupportsDefaultEncoding(Font font) {
335 return getFont2D(font) instanceof CompositeFont;
336 }
337
338 /**
339 * This method is provided for internal and exclusive use by Swing.
340 *
341 * It may be used in conjunction with fontSupportsDefaultEncoding(Font)
342 * In the event that a desktop properties font doesn't directly
343 * support the default encoding, (ie because the host OS supports
344 * adding support for the current locale automatically for native apps),
345 * then Swing calls this method to get a font which uses the specified
346 * font for the code points it covers, but also supports this locale
347 * just as the standard composite fonts do.
348 * Note: this will over-ride any setting where an application
349 * specifies it prefers locale specific composite fonts.
350 * The logic for this, is that this method is used only where the user or
351 * application has specified that the native L&F be used, and that
352 * we should honour that request to use the same font as native apps use.
353 *
354 * The behaviour of this method is to construct a new composite
355 * Font object that uses the specified physical font as its first
356 * component, and adds all the components of "dialog" as fall back
357 * components.
358 * The method currently assumes that only the size and style attributes
359 * are set on the specified font. It doesn't copy the font transform or
360 * other attributes because they aren't set on a font created from
361 * the desktop. This will need to be fixed if use is broadened.
362 *
363 * Operations such as Font.deriveFont will work properly on the
364 * font returned by this method for deriving a different point size.
365 * Additionally it tries to support a different style by calling
366 * getNewComposite() below. That also supports replacing slot zero
367 * with a different physical font but that is expected to be "rare".
368 * Deriving with a different style is needed because its been shown
369 * that some applications try to do this for Swing FontUIResources.
370 * Also operations such as new Font(font.getFontName(..), Font.PLAIN, 14);
371 * will NOT yield the same result, as the new underlying CompositeFont
372 * cannot be "looked up" in the font registry.
373 * This returns a FontUIResource as that is the Font sub-class needed
374 * by Swing.
375 * Suggested usage is something like :
376 * FontUIResource fuir;
377 * Font desktopFont = getDesktopFont(..);
378 * if (FontManager.fontSupportsDefaultEncoding(desktopFont)) {
379 * fuir = new FontUIResource(desktopFont);
380 * } else {
381 * fuir = FontManager.getCompositeFontUIResource(desktopFont);
382 * }
383 * return fuir;
384 */
385 private static volatile
386 SoftReference<ConcurrentHashMap<PhysicalFont, CompositeFont>>
387 compMapRef = new SoftReference<>(null);
388
389 public static FontUIResource getCompositeFontUIResource(Font font) {
390
391 FontUIResource fuir = new FontUIResource(font);
392 Font2D font2D = FontUtilities.getFont2D(font);
393
394 if (!(font2D instanceof PhysicalFont)) {
395 /* Swing should only be calling this when a font is obtained
396 * from desktop properties, so should generally be a physical font,
397 * an exception might be for names like "MS Serif" which are
398 * automatically mapped to "Serif", so there's no need to do
399 * anything special in that case. But note that suggested usage
400 * is first to call fontSupportsDefaultEncoding(Font) and this
401 * method should not be called if that were to return true.
402 */
403 return fuir;
404 }
405
406 FontManager fm = FontManagerFactory.getInstance();
407 Font2D dialog = fm.findFont2D("dialog", font.getStyle(), FontManager.NO_FALLBACK);
408 // Should never be null, but MACOSX fonts are not CompositeFonts
409 if (dialog == null || !(dialog instanceof CompositeFont)) {
410 return fuir;
411 }
412 CompositeFont dialog2D = (CompositeFont)dialog;
413 PhysicalFont physicalFont = (PhysicalFont)font2D;
414 ConcurrentHashMap<PhysicalFont, CompositeFont> compMap = compMapRef.get();
415 if (compMap == null) { // Its been collected.
416 compMap = new ConcurrentHashMap<PhysicalFont, CompositeFont>();
417 compMapRef = new SoftReference<>(compMap);
418 }
419 CompositeFont compFont = compMap.get(physicalFont);
420 if (compFont == null) {
421 compFont = new CompositeFont(physicalFont, dialog2D);
422 compMap.put(physicalFont, compFont);
423 }
424 FontAccess.getFontAccess().setFont2D(fuir, compFont.handle);
425 /* marking this as a created font is needed as only created fonts
426 * copy their creator's handles.
427 */
428 FontAccess.getFontAccess().setCreatedFont(fuir);
429 return fuir;
430 }
431
432 /* A small "map" from GTK/fontconfig names to the equivalent JDK
433 * logical font name.
434 */
435 private static final String[][] nameMap = {
436 {"sans", "sansserif"},
437 {"sans-serif", "sansserif"},
438 {"serif", "serif"},
439 {"monospace", "monospaced"}
440 };
441
442 public static String mapFcName(String name) {
443 for (int i = 0; i < nameMap.length; i++) {
444 if (name.equals(nameMap[i][0])) {
445 return nameMap[i][1];
446 }
447 }
448 return null;
449 }
450
451
452 /* This is called by Swing passing in a fontconfig family name
453 * such as "sans". In return Swing gets a FontUIResource instance
454 * that has queried fontconfig to resolve the font(s) used for this.
455 * Fontconfig will if asked return a list of fonts to give the largest
456 * possible code point coverage.
457 * For now we use only the first font returned by fontconfig, and
458 * back it up with the most closely matching JDK logical font.
459 * Essentially this means pre-pending what we return now with fontconfig's
460 * preferred physical font. This could lead to some duplication in cases,
461 * if we already included that font later. We probably should remove such
462 * duplicates, but it is not a significant problem. It can be addressed
463 * later as part of creating a Composite which uses more of the
464 * same fonts as fontconfig. At that time we also should pay more
465 * attention to the special rendering instructions fontconfig returns,
466 * such as whether we should prefer embedded bitmaps over antialiasing.
467 * There's no way to express that via a Font at present.
468 */
469 public static FontUIResource getFontConfigFUIR(String fcFamily,
470 int style, int size) {
471
472 String mapped = mapFcName(fcFamily);
473 if (mapped == null) {
474 mapped = "sansserif";
475 }
476
477 FontUIResource fuir;
478 FontManager fm = FontManagerFactory.getInstance();
479 if (fm instanceof SunFontManager) {
480 SunFontManager sfm = (SunFontManager) fm;
481 fuir = sfm.getFontConfigFUIR(mapped, style, size);
482 } else {
483 fuir = new FontUIResource(mapped, style, size);
484 }
485 return fuir;
486 }
487
488
489 /**
490 * Used by windows printing to assess if a font is likely to
491 * be layout compatible with JDK
492 * TrueType fonts should be, but if they have no GPOS table,
493 * but do have a GSUB table, then they are probably older
494 * fonts GDI handles differently.
495 */
496 public static boolean textLayoutIsCompatible(Font font) {
497
498 Font2D font2D = getFont2D(font);
499 if (font2D instanceof TrueTypeFont) {
500 TrueTypeFont ttf = (TrueTypeFont) font2D;
501 return
502 ttf.getDirectoryEntry(TrueTypeFont.GSUBTag) == null ||
503 ttf.getDirectoryEntry(TrueTypeFont.GPOSTag) != null;
504 } else {
505 return false;
506 }
507 }
508
509 }