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